fs/xfs/xfs_reflink.c

   1 /*
   2  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   3  *
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it would be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write the Free Software Foundation,
  18  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 #include "xfs.h"
  21 #include "xfs_fs.h"
  22 #include "xfs_shared.h"
  23 #include "xfs_format.h"
  24 #include "xfs_log_format.h"
  25 #include "xfs_trans_resv.h"
  26 #include "xfs_mount.h"
  27 #include "xfs_defer.h"
  28 #include "xfs_da_format.h"
  29 #include "xfs_da_btree.h"
  30 #include "xfs_inode.h"
  31 #include "xfs_trans.h"
  32 #include "xfs_inode_item.h"
  33 #include "xfs_bmap.h"
  34 #include "xfs_bmap_util.h"
  35 #include "xfs_error.h"
  36 #include "xfs_dir2.h"
  37 #include "xfs_dir2_priv.h"
  38 #include "xfs_ioctl.h"
  39 #include "xfs_trace.h"
  40 #include "xfs_log.h"
  41 #include "xfs_icache.h"
  42 #include "xfs_pnfs.h"
  43 #include "xfs_btree.h"
  44 #include "xfs_refcount_btree.h"
  45 #include "xfs_refcount.h"
  46 #include "xfs_bmap_btree.h"
  47 #include "xfs_trans_space.h"
  48 #include "xfs_bit.h"
  49 #include "xfs_alloc.h"
  50 #include "xfs_quota_defs.h"
  51 #include "xfs_quota.h"
  52 #include "xfs_reflink.h"
  53 #include "xfs_iomap.h"
  54 #include "xfs_rmap_btree.h"
  55 #include "xfs_sb.h"
  56 #include "xfs_ag_resv.h"
  57
  58 /*
  59  * Copy on Write of Shared Blocks
  60  *
  61  * XFS must preserve "the usual" file semantics even when two files share
  62  * the same physical blocks.  This means that a write to one file must not
  63  * alter the blocks in a different file; the way that we'll do that is
  64  * through the use of a copy-on-write mechanism.  At a high level, that
  65  * means that when we want to write to a shared block, we allocate a new
  66  * block, write the data to the new block, and if that succeeds we map the
  67  * new block into the file.
  68  *
  69  * XFS provides a "delayed allocation" mechanism that defers the allocation
  70  * of disk blocks to dirty-but-not-yet-mapped file blocks as long as
  71  * possible.  This reduces fragmentation by enabling the filesystem to ask
  72  * for bigger chunks less often, which is exactly what we want for CoW.
  73  *
  74  * The delalloc mechanism begins when the kernel wants to make a block
  75  * writable (write_begin or page_mkwrite).  If the offset is not mapped, we
  76  * create a delalloc mapping, which is a regular in-core extent, but without
  77  * a real startblock.  (For delalloc mappings, the startblock encodes both
  78  * a flag that this is a delalloc mapping, and a worst-case estimate of how
  79  * many blocks might be required to put the mapping into the BMBT.)  delalloc
  80  * mappings are a reservation against the free space in the filesystem;
  81  * adjacent mappings can also be combined into fewer larger mappings.
  82  *
  83  * As an optimization, the CoW extent size hint (cowextsz) creates
  84  * outsized aligned delalloc reservations in the hope of landing out of
  85  * order nearby CoW writes in a single extent on disk, thereby reducing
  86  * fragmentation and improving future performance.
  87  *
  88  * D: --RRRRRRSSSRRRRRRRR--- (data fork)
  89  * C: ------DDDDDDD--------- (CoW fork)
  90  *
  91  * When dirty pages are being written out (typically in writepage), the
  92  * delalloc reservations are converted into unwritten mappings by
  93  * allocating blocks and replacing the delalloc mapping with real ones.
  94  * A delalloc mapping can be replaced by several unwritten ones if the
  95  * free space is fragmented.
  96  *
  97  * D: --RRRRRRSSSRRRRRRRR---
  98  * C: ------UUUUUUU---------
  99  *
 100  * We want to adapt the delalloc mechanism for copy-on-write, since the
 101  * write paths are similar.  The first two steps (creating the reservation
 102  * and allocating the blocks) are exactly the same as delalloc except that
 103  * the mappings must be stored in a separate CoW fork because we do not want
 104  * to disturb the mapping in the data fork until we're sure that the write
 105  * succeeded.  IO completion in this case is the process of removing the old
 106  * mapping from the data fork and moving the new mapping from the CoW fork to
 107  * the data fork.  This will be discussed shortly.
 108  *
 109  * For now, unaligned directio writes will be bounced back to the page cache.
 110  * Block-aligned directio writes will use the same mechanism as buffered
 111  * writes.
 112  *
 113  * Just prior to submitting the actual disk write requests, we convert
 114  * the extents representing the range of the file actually being written
 115  * (as opposed to extra pieces created for the cowextsize hint) to real
 116  * extents.  This will become important in the next step:
 117  *
 118  * D: --RRRRRRSSSRRRRRRRR---
 119  * C: ------UUrrUUU---------
 120  *
 121  * CoW remapping must be done after the data block write completes,
 122  * because we don't want to destroy the old data fork map until we're sure
 123  * the new block has been written.  Since the new mappings are kept in a
 124  * separate fork, we can simply iterate these mappings to find the ones
 125  * that cover the file blocks that we just CoW'd.  For each extent, simply
 126  * unmap the corresponding range in the data fork, map the new range into
 127  * the data fork, and remove the extent from the CoW fork.  Because of
 128  * the presence of the cowextsize hint, however, we must be careful
 129  * only to remap the blocks that we've actually written out --  we must
 130  * never remap delalloc reservations nor CoW staging blocks that have
 131  * yet to be written.  This corresponds exactly to the real extents in
 132  * the CoW fork:
 133  *
 134  * D: --RRRRRRrrSRRRRRRRR---
 135  * C: ------UU--UUU---------
 136  *
 137  * Since the remapping operation can be applied to an arbitrary file
 138  * range, we record the need for the remap step as a flag in the ioend
 139  * instead of declaring a new IO type.  This is required for direct io
 140  * because we only have ioend for the whole dio, and we have to be able to
 141  * remember the presence of unwritten blocks and CoW blocks with a single
 142  * ioend structure.  Better yet, the more ground we can cover with one
 143  * ioend, the better.
 144  */
 145
 146 /*
 147  * Given an AG extent, find the lowest-numbered run of shared blocks
 148  * within that range and return the range in fbno/flen.  If
 149  * find_end_of_shared is true, return the longest contiguous extent of
 150  * shared blocks.  If there are no shared extents, fbno and flen will
 151  * be set to NULLAGBLOCK and 0, respectively.
 152  */
 153 int
 154 xfs_reflink_find_shared(
 155         struct xfs_mount        *mp,
 156         struct xfs_trans        *tp,
 157         xfs_agnumber_t          agno,
 158         xfs_agblock_t           agbno,
 159         xfs_extlen_t            aglen,
 160         xfs_agblock_t           *fbno,
 161         xfs_extlen_t            *flen,
 162         bool                    find_end_of_shared)
 163 {
 164         struct xfs_buf          *agbp;
 165         struct xfs_btree_cur    *cur;
 166         int                     error;
 167
 168         error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
 169         if (error)
 170                 return error;
 171         if (!agbp)
 172                 return -ENOMEM;
 173
 174         cur = xfs_refcountbt_init_cursor(mp, tp, agbp, agno, NULL);
 175
 176         error = xfs_refcount_find_shared(cur, agbno, aglen, fbno, flen,
 177                         find_end_of_shared);
 178
 179         xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
 180
 181         xfs_trans_brelse(tp, agbp);
 182         return error;
 183 }
 184
 185 /*
 186  * Trim the mapping to the next block where there's a change in the
 187  * shared/unshared status.  More specifically, this means that we
 188  * find the lowest-numbered extent of shared blocks that coincides with
 189  * the given block mapping.  If the shared extent overlaps the start of
 190  * the mapping, trim the mapping to the end of the shared extent.  If
 191  * the shared region intersects the mapping, trim the mapping to the
 192  * start of the shared extent.  If there are no shared regions that
 193  * overlap, just return the original extent.
 194  */
 195 int
 196 xfs_reflink_trim_around_shared(
 197         struct xfs_inode        *ip,
 198         struct xfs_bmbt_irec    *irec,
 199         bool                    *shared,
 200         bool                    *trimmed)
 201 {
 202         xfs_agnumber_t          agno;
 203         xfs_agblock_t           agbno;
 204         xfs_extlen_t            aglen;
 205         xfs_agblock_t           fbno;
 206         xfs_extlen_t            flen;
 207         int                     error = 0;
 208
 209         /* Holes, unwritten, and delalloc extents cannot be shared */
 210         if (!xfs_is_reflink_inode(ip) || !xfs_bmap_is_real_extent(irec)) {
 211                 *shared = false;
 212                 return 0;
 213         }
 214
 215         trace_xfs_reflink_trim_around_shared(ip, irec);
 216
 217         agno = XFS_FSB_TO_AGNO(ip->i_mount, irec->br_startblock);
 218         agbno = XFS_FSB_TO_AGBNO(ip->i_mount, irec->br_startblock);
 219         aglen = irec->br_blockcount;
 220
 221         error = xfs_reflink_find_shared(ip->i_mount, NULL, agno, agbno,
 222                         aglen, &fbno, &flen, true);
 223         if (error)
 224                 return error;
 225
 226         *shared = *trimmed = false;
 227         if (fbno == NULLAGBLOCK) {
 228                 /* No shared blocks at all. */
 229                 return 0;
 230         } else if (fbno == agbno) {
 231                 /*
 232                  * The start of this extent is shared.  Truncate the
 233                  * mapping at the end of the shared region so that a
 234                  * subsequent iteration starts at the start of the
 235                  * unshared region.
 236                  */
 237                 irec->br_blockcount = flen;
 238                 *shared = true;
 239                 if (flen != aglen)
 240                         *trimmed = true;
 241                 return 0;
 242         } else {
 243                 /*
 244                  * There's a shared extent midway through this extent.
 245                  * Truncate the mapping at the start of the shared
 246                  * extent so that a subsequent iteration starts at the
 247                  * start of the shared region.
 248                  */
 249                 irec->br_blockcount = fbno - agbno;
 250                 *trimmed = true;
 251                 return 0;
 252         }
 253 }
 254
 255 /*
 256  * Trim the passed in imap to the next shared/unshared extent boundary, and
 257  * if imap->br_startoff points to a shared extent reserve space for it in the
 258  * COW fork.  In this case *shared is set to true, else to false.
 259  *
 260  * Note that imap will always contain the block numbers for the existing blocks
 261  * in the data fork, as the upper layers need them for read-modify-write
 262  * operations.
 263  */
 264 int
 265 xfs_reflink_reserve_cow(
 266         struct xfs_inode        *ip,
 267         struct xfs_bmbt_irec    *imap,
 268         bool                    *shared)
 269 {
 270         struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 271         struct xfs_bmbt_irec    got;
 272         int                     error = 0;
 273         bool                    eof = false, trimmed;
 274         struct xfs_iext_cursor  icur;
 275
 276         /*
 277          * Search the COW fork extent list first.  This serves two purposes:
 278          * first this implement the speculative preallocation using cowextisze,
 279          * so that we also unshared block adjacent to shared blocks instead
 280          * of just the shared blocks themselves.  Second the lookup in the
 281          * extent list is generally faster than going out to the shared extent
 282          * tree.
 283          */
 284
 285         if (!xfs_iext_lookup_extent(ip, ifp, imap->br_startoff, &icur, &got))
 286                 eof = true;
 287         if (!eof && got.br_startoff <= imap->br_startoff) {
 288                 trace_xfs_reflink_cow_found(ip, imap);
 289                 xfs_trim_extent(imap, got.br_startoff, got.br_blockcount);
 290
 291                 *shared = true;
 292                 return 0;
 293         }
 294
 295         /* Trim the mapping to the nearest shared extent boundary. */
 296         error = xfs_reflink_trim_around_shared(ip, imap, shared, &trimmed);
 297         if (error)
 298                 return error;
 299
 300         /* Not shared?  Just report the (potentially capped) extent. */
 301         if (!*shared)
 302                 return 0;
 303
 304         /*
 305          * Fork all the shared blocks from our write offset until the end of
 306          * the extent.
 307          */
 308         error = xfs_qm_dqattach_locked(ip, 0);
 309         if (error)
 310                 return error;
 311
 312         error = xfs_bmapi_reserve_delalloc(ip, XFS_COW_FORK, imap->br_startoff,
 313                         imap->br_blockcount, 0, &got, &icur, eof);
 314         if (error == -ENOSPC || error == -EDQUOT)
 315                 trace_xfs_reflink_cow_enospc(ip, imap);
 316         if (error)
 317                 return error;
 318
 319         trace_xfs_reflink_cow_alloc(ip, &got);
 320         return 0;
 321 }
 322
 323 /* Convert part of an unwritten CoW extent to a real one. */
 324 STATIC int
 325 xfs_reflink_convert_cow_extent(
 326         struct xfs_inode                *ip,
 327         struct xfs_bmbt_irec            *imap,
 328         xfs_fileoff_t                   offset_fsb,
 329         xfs_filblks_t                   count_fsb,
 330         struct xfs_defer_ops            *dfops)
 331 {
 332         xfs_fsblock_t                   first_block = NULLFSBLOCK;
 333         int                             nimaps = 1;
 334
 335         if (imap->br_state == XFS_EXT_NORM)
 336                 return 0;
 337
 338         xfs_trim_extent(imap, offset_fsb, count_fsb);
 339         trace_xfs_reflink_convert_cow(ip, imap);
 340         if (imap->br_blockcount == 0)
 341                 return 0;
 342         return xfs_bmapi_write(NULL, ip, imap->br_startoff, imap->br_blockcount,
 343                         XFS_BMAPI_COWFORK | XFS_BMAPI_CONVERT, &first_block,
 344                         0, imap, &nimaps, dfops);
 345 }
 346
 347 /* Convert all of the unwritten CoW extents in a file's range to real ones. */
 348 int
 349 xfs_reflink_convert_cow(
 350         struct xfs_inode        *ip,
 351         xfs_off_t               offset,
 352         xfs_off_t               count)
 353 {
 354         struct xfs_mount        *mp = ip->i_mount;
 355         xfs_fileoff_t           offset_fsb = XFS_B_TO_FSBT(mp, offset);
 356         xfs_fileoff_t           end_fsb = XFS_B_TO_FSB(mp, offset + count);
 357         xfs_filblks_t           count_fsb = end_fsb - offset_fsb;
 358         struct xfs_bmbt_irec    imap;
 359         struct xfs_defer_ops    dfops;
 360         xfs_fsblock_t           first_block = NULLFSBLOCK;
 361         int                     nimaps = 1, error = 0;
 362
 363         ASSERT(count != 0);
 364
 365         xfs_ilock(ip, XFS_ILOCK_EXCL);
 366         error = xfs_bmapi_write(NULL, ip, offset_fsb, count_fsb,
 367                         XFS_BMAPI_COWFORK | XFS_BMAPI_CONVERT |
 368                         XFS_BMAPI_CONVERT_ONLY, &first_block, 0, &imap, &nimaps,
 369                         &dfops);
 370         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 371         return error;
 372 }
 373
 374 /* Allocate all CoW reservations covering a range of blocks in a file. */
 375 int
 376 xfs_reflink_allocate_cow(
 377         struct xfs_inode        *ip,
 378         struct xfs_bmbt_irec    *imap,
 379         bool                    *shared,
 380         uint                    *lockmode)
 381 {
 382         struct xfs_mount        *mp = ip->i_mount;
 383         xfs_fileoff_t           offset_fsb = imap->br_startoff;
 384         xfs_filblks_t           count_fsb = imap->br_blockcount;
 385         struct xfs_bmbt_irec    got;
 386         struct xfs_defer_ops    dfops;
 387         struct xfs_trans        *tp = NULL;
 388         xfs_fsblock_t           first_block;
 389         int                     nimaps, error = 0;
 390         bool                    trimmed;
 391         xfs_filblks_t           resaligned;
 392         xfs_extlen_t            resblks = 0;
 393         struct xfs_iext_cursor  icur;
 394
 395 retry:
 396         ASSERT(xfs_is_reflink_inode(ip));
 397         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
 398
 399         /*
 400          * Even if the extent is not shared we might have a preallocation for
 401          * it in the COW fork.  If so use it.
 402          */
 403         if (xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got) &&
 404             got.br_startoff <= offset_fsb) {
 405                 *shared = true;
 406
 407                 /* If we have a real allocation in the COW fork we're done. */
 408                 if (!isnullstartblock(got.br_startblock)) {
 409                         xfs_trim_extent(&got, offset_fsb, count_fsb);
 410                         *imap = got;
 411                         goto convert;
 412                 }
 413
 414                 xfs_trim_extent(imap, got.br_startoff, got.br_blockcount);
 415         } else {
 416                 error = xfs_reflink_trim_around_shared(ip, imap, shared, &trimmed);
 417                 if (error || !*shared)
 418                         goto out;
 419         }
 420
 421         if (!tp) {
 422                 resaligned = xfs_aligned_fsb_count(imap->br_startoff,
 423                         imap->br_blockcount, xfs_get_cowextsz_hint(ip));
 424                 resblks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
 425
 426                 xfs_iunlock(ip, *lockmode);
 427                 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp);
 428                 *lockmode = XFS_ILOCK_EXCL;
 429                 xfs_ilock(ip, *lockmode);
 430
 431                 if (error)
 432                         return error;
 433
 434                 error = xfs_qm_dqattach_locked(ip, 0);
 435                 if (error)
 436                         goto out;
 437                 goto retry;
 438         }
 439
 440         error = xfs_trans_reserve_quota_nblks(tp, ip, resblks, 0,
 441                         XFS_QMOPT_RES_REGBLKS);
 442         if (error)
 443                 goto out;
 444
 445         xfs_trans_ijoin(tp, ip, 0);
 446
 447         xfs_defer_init(&dfops, &first_block);
 448         nimaps = 1;
 449
 450         /* Allocate the entire reservation as unwritten blocks. */
 451         error = xfs_bmapi_write(tp, ip, imap->br_startoff, imap->br_blockcount,
 452                         XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC, &first_block,
 453                         resblks, imap, &nimaps, &dfops);
 454         if (error)
 455                 goto out_bmap_cancel;
 456
 457         xfs_inode_set_cowblocks_tag(ip);
 458
 459         /* Finish up. */
 460         error = xfs_defer_finish(&tp, &dfops);
 461         if (error)
 462                 goto out_bmap_cancel;
 463
 464         error = xfs_trans_commit(tp);
 465         if (error)
 466                 return error;
 467 convert:
 468         return xfs_reflink_convert_cow_extent(ip, imap, offset_fsb, count_fsb,
 469                         &dfops);
 470 out_bmap_cancel:
 471         xfs_defer_cancel(&dfops);
 472         xfs_trans_unreserve_quota_nblks(tp, ip, (long)resblks, 0,
 473                         XFS_QMOPT_RES_REGBLKS);
 474 out:
 475         if (tp)
 476                 xfs_trans_cancel(tp);
 477         return error;
 478 }
 479
 480 /*
 481  * Find the CoW reservation for a given byte offset of a file.
 482  */
 483 bool
 484 xfs_reflink_find_cow_mapping(
 485         struct xfs_inode                *ip,
 486         xfs_off_t                       offset,
 487         struct xfs_bmbt_irec            *imap)
 488 {
 489         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 490         xfs_fileoff_t                   offset_fsb;
 491         struct xfs_bmbt_irec            got;
 492         struct xfs_iext_cursor          icur;
 493
 494         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
 495
 496         if (!xfs_is_reflink_inode(ip))
 497                 return false;
 498         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 499         if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
 500                 return false;
 501         if (got.br_startoff > offset_fsb)
 502                 return false;
 503
 504         trace_xfs_reflink_find_cow_mapping(ip, offset, 1, XFS_IO_OVERWRITE,
 505                         &got);
 506         *imap = got;
 507         return true;
 508 }
 509
 510 /*
 511  * Trim an extent to end at the next CoW reservation past offset_fsb.
 512  */
 513 void
 514 xfs_reflink_trim_irec_to_next_cow(
 515         struct xfs_inode                *ip,
 516         xfs_fileoff_t                   offset_fsb,
 517         struct xfs_bmbt_irec            *imap)
 518 {
 519         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 520         struct xfs_bmbt_irec            got;
 521         struct xfs_iext_cursor          icur;
 522
 523         if (!xfs_is_reflink_inode(ip))
 524                 return;
 525
 526         /* Find the extent in the CoW fork. */
 527         if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
 528                 return;
 529
 530         /* This is the extent before; try sliding up one. */
 531         if (got.br_startoff < offset_fsb) {
 532                 if (!xfs_iext_next_extent(ifp, &icur, &got))
 533                         return;
 534         }
 535
 536         if (got.br_startoff >= imap->br_startoff + imap->br_blockcount)
 537                 return;
 538
 539         imap->br_blockcount = got.br_startoff - imap->br_startoff;
 540         trace_xfs_reflink_trim_irec(ip, imap);
 541 }
 542
 543 /*
 544  * Cancel CoW reservations for some block range of an inode.
 545  *
 546  * If cancel_real is true this function cancels all COW fork extents for the
 547  * inode; if cancel_real is false, real extents are not cleared.
 548  */
 549 int
 550 xfs_reflink_cancel_cow_blocks(
 551         struct xfs_inode                *ip,
 552         struct xfs_trans                **tpp,
 553         xfs_fileoff_t                   offset_fsb,
 554         xfs_fileoff_t                   end_fsb,
 555         bool                            cancel_real)
 556 {
 557         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 558         struct xfs_bmbt_irec            got, del;
 559         struct xfs_iext_cursor          icur;
 560         xfs_fsblock_t                   firstfsb;
 561         struct xfs_defer_ops            dfops;
 562         int                             error = 0;
 563
 564         if (!xfs_is_reflink_inode(ip))
 565                 return 0;
 566         if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
 567                 return 0;
 568
 569         /* Walk backwards until we're out of the I/O range... */
 570         while (got.br_startoff + got.br_blockcount > offset_fsb) {
 571                 del = got;
 572                 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
 573
 574                 /* Extent delete may have bumped ext forward */
 575                 if (!del.br_blockcount) {
 576                         xfs_iext_prev(ifp, &icur);
 577                         goto next_extent;
 578                 }
 579
 580                 trace_xfs_reflink_cancel_cow(ip, &del);
 581
 582                 if (isnullstartblock(del.br_startblock)) {
 583                         error = xfs_bmap_del_extent_delay(ip, XFS_COW_FORK,
 584                                         &icur, &got, &del);
 585                         if (error)
 586                                 break;
 587                 } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) {
 588                         xfs_trans_ijoin(*tpp, ip, 0);
 589                         xfs_defer_init(&dfops, &firstfsb);
 590
 591                         /* Free the CoW orphan record. */
 592                         error = xfs_refcount_free_cow_extent(ip->i_mount,
 593                                         &dfops, del.br_startblock,
 594                                         del.br_blockcount);
 595                         if (error)
 596                                 break;
 597
 598                         xfs_bmap_add_free(ip->i_mount, &dfops,
 599                                         del.br_startblock, del.br_blockcount,
 600                                         NULL);
 601
 602                         /* Update quota accounting */
 603                         xfs_trans_mod_dquot_byino(*tpp, ip, XFS_TRANS_DQ_BCOUNT,
 604                                         -(long)del.br_blockcount);
 605
 606                         /* Roll the transaction */
 607                         xfs_defer_ijoin(&dfops, ip);
 608                         error = xfs_defer_finish(tpp, &dfops);
 609                         if (error) {
 610                                 xfs_defer_cancel(&dfops);
 611                                 break;
 612                         }
 613
 614                         /* Remove the mapping from the CoW fork. */
 615                         xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
 616                 } else {
 617                         /* Didn't do anything, push cursor back. */
 618                         xfs_iext_prev(ifp, &icur);
 619                 }
 620 next_extent:
 621                 if (!xfs_iext_get_extent(ifp, &icur, &got))
 622                         break;
 623         }
 624
 625         /* clear tag if cow fork is emptied */
 626         if (!ifp->if_bytes)
 627                 xfs_inode_clear_cowblocks_tag(ip);
 628
 629         return error;
 630 }
 631
 632 /*
 633  * Cancel CoW reservations for some byte range of an inode.
 634  *
 635  * If cancel_real is true this function cancels all COW fork extents for the
 636  * inode; if cancel_real is false, real extents are not cleared.
 637  */
 638 int
 639 xfs_reflink_cancel_cow_range(
 640         struct xfs_inode        *ip,
 641         xfs_off_t               offset,
 642         xfs_off_t               count,
 643         bool                    cancel_real)
 644 {
 645         struct xfs_trans        *tp;
 646         xfs_fileoff_t           offset_fsb;
 647         xfs_fileoff_t           end_fsb;
 648         int                     error;
 649
 650         trace_xfs_reflink_cancel_cow_range(ip, offset, count);
 651         ASSERT(xfs_is_reflink_inode(ip));
 652
 653         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 654         if (count == NULLFILEOFF)
 655                 end_fsb = NULLFILEOFF;
 656         else
 657                 end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
 658
 659         /* Start a rolling transaction to remove the mappings */
 660         error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
 661                         0, 0, 0, &tp);
 662         if (error)
 663                 goto out;
 664
 665         xfs_ilock(ip, XFS_ILOCK_EXCL);
 666         xfs_trans_ijoin(tp, ip, 0);
 667
 668         /* Scrape out the old CoW reservations */
 669         error = xfs_reflink_cancel_cow_blocks(ip, &tp, offset_fsb, end_fsb,
 670                         cancel_real);
 671         if (error)
 672                 goto out_cancel;
 673
 674         error = xfs_trans_commit(tp);
 675
 676         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 677         return error;
 678
 679 out_cancel:
 680         xfs_trans_cancel(tp);
 681         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 682 out:
 683         trace_xfs_reflink_cancel_cow_range_error(ip, error, _RET_IP_);
 684         return error;
 685 }
 686
 687 /*
 688  * Remap parts of a file's data fork after a successful CoW.
 689  */
 690 int
 691 xfs_reflink_end_cow(
 692         struct xfs_inode                *ip,
 693         xfs_off_t                       offset,
 694         xfs_off_t                       count)
 695 {
 696         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 697         struct xfs_bmbt_irec            got, del;
 698         struct xfs_trans                *tp;
 699         xfs_fileoff_t                   offset_fsb;
 700         xfs_fileoff_t                   end_fsb;
 701         xfs_fsblock_t                   firstfsb;
 702         struct xfs_defer_ops            dfops;
 703         int                             error;
 704         unsigned int                    resblks;
 705         xfs_filblks_t                   rlen;
 706         struct xfs_iext_cursor          icur;
 707
 708         trace_xfs_reflink_end_cow(ip, offset, count);
 709
 710         /* No COW extents?  That's easy! */
 711         if (ifp->if_bytes == 0)
 712                 return 0;
 713
 714         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 715         end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
 716
 717         /*
 718          * Start a rolling transaction to switch the mappings.  We're
 719          * unlikely ever to have to remap 16T worth of single-block
 720          * extents, so just cap the worst case extent count to 2^32-1.
 721          * Stick a warning in just in case, and avoid 64-bit division.
 722          */
 723         BUILD_BUG_ON(MAX_RW_COUNT > UINT_MAX);
 724         if (end_fsb - offset_fsb > UINT_MAX) {
 725                 error = -EFSCORRUPTED;
 726                 xfs_force_shutdown(ip->i_mount, SHUTDOWN_CORRUPT_INCORE);
 727                 ASSERT(0);
 728                 goto out;
 729         }
 730         resblks = XFS_NEXTENTADD_SPACE_RES(ip->i_mount,
 731                         (unsigned int)(end_fsb - offset_fsb),
 732                         XFS_DATA_FORK);
 733         error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
 734                         resblks, 0, XFS_TRANS_RESERVE, &tp);
 735         if (error)
 736                 goto out;
 737
 738         xfs_ilock(ip, XFS_ILOCK_EXCL);
 739         xfs_trans_ijoin(tp, ip, 0);
 740
 741         /*
 742          * In case of racing, overlapping AIO writes no COW extents might be
 743          * left by the time I/O completes for the loser of the race.  In that
 744          * case we are done.
 745          */
 746         if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
 747                 goto out_cancel;
 748
 749         /* Walk backwards until we're out of the I/O range... */
 750         while (got.br_startoff + got.br_blockcount > offset_fsb) {
 751                 del = got;
 752                 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
 753
 754                 /* Extent delete may have bumped ext forward */
 755                 if (!del.br_blockcount) {
 756                         xfs_iext_prev(ifp, &icur);
 757                         goto next_extent;
 758                 }
 759
 760                 ASSERT(!isnullstartblock(got.br_startblock));
 761
 762                 /*
 763                  * Don't remap unwritten extents; these are
 764                  * speculatively preallocated CoW extents that have been
 765                  * allocated but have not yet been involved in a write.
 766                  */
 767                 if (got.br_state == XFS_EXT_UNWRITTEN) {
 768                         xfs_iext_prev(ifp, &icur);
 769                         goto next_extent;
 770                 }
 771
 772                 /* Unmap the old blocks in the data fork. */
 773                 xfs_defer_init(&dfops, &firstfsb);
 774                 rlen = del.br_blockcount;
 775                 error = __xfs_bunmapi(tp, ip, del.br_startoff, &rlen, 0, 1,
 776                                 &firstfsb, &dfops);
 777                 if (error)
 778                         goto out_defer;
 779
 780                 /* Trim the extent to whatever got unmapped. */
 781                 if (rlen) {
 782                         xfs_trim_extent(&del, del.br_startoff + rlen,
 783                                 del.br_blockcount - rlen);
 784                 }
 785                 trace_xfs_reflink_cow_remap(ip, &del);
 786
 787                 /* Free the CoW orphan record. */
 788                 error = xfs_refcount_free_cow_extent(tp->t_mountp, &dfops,
 789                                 del.br_startblock, del.br_blockcount);
 790                 if (error)
 791                         goto out_defer;
 792
 793                 /* Map the new blocks into the data fork. */
 794                 error = xfs_bmap_map_extent(tp->t_mountp, &dfops, ip, &del);
 795                 if (error)
 796                         goto out_defer;
 797
 798                 /* Remove the mapping from the CoW fork. */
 799                 xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
 800
 801                 xfs_defer_ijoin(&dfops, ip);
 802                 error = xfs_defer_finish(&tp, &dfops);
 803                 if (error)
 804                         goto out_defer;
 805 next_extent:
 806                 if (!xfs_iext_get_extent(ifp, &icur, &got))
 807                         break;
 808         }
 809
 810         error = xfs_trans_commit(tp);
 811         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 812         if (error)
 813                 goto out;
 814         return 0;
 815
 816 out_defer:
 817         xfs_defer_cancel(&dfops);
 818 out_cancel:
 819         xfs_trans_cancel(tp);
 820         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 821 out:
 822         trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_);
 823         return error;
 824 }
 825
 826 /*
 827  * Free leftover CoW reservations that didn't get cleaned out.
 828  */
 829 int
 830 xfs_reflink_recover_cow(
 831         struct xfs_mount        *mp)
 832 {
 833         xfs_agnumber_t          agno;
 834         int                     error = 0;
 835
 836         if (!xfs_sb_version_hasreflink(&mp->m_sb))
 837                 return 0;
 838
 839         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
 840                 error = xfs_refcount_recover_cow_leftovers(mp, agno);
 841                 if (error)
 842                         break;
 843         }
 844
 845         return error;
 846 }
 847
 848 /*
 849  * Reflinking (Block) Ranges of Two Files Together
 850  *
 851  * First, ensure that the reflink flag is set on both inodes.  The flag is an
 852  * optimization to avoid unnecessary refcount btree lookups in the write path.
 853  *
 854  * Now we can iteratively remap the range of extents (and holes) in src to the
 855  * corresponding ranges in dest.  Let drange and srange denote the ranges of
 856  * logical blocks in dest and src touched by the reflink operation.
 857  *
 858  * While the length of drange is greater than zero,
 859  *    - Read src's bmbt at the start of srange ("imap")
 860  *    - If imap doesn't exist, make imap appear to start at the end of srange
 861  *      with zero length.
 862  *    - If imap starts before srange, advance imap to start at srange.
 863  *    - If imap goes beyond srange, truncate imap to end at the end of srange.
 864  *    - Punch (imap start - srange start + imap len) blocks from dest at
 865  *      offset (drange start).
 866  *    - If imap points to a real range of pblks,
 867  *         > Increase the refcount of the imap's pblks
 868  *         > Map imap's pblks into dest at the offset
 869  *           (drange start + imap start - srange start)
 870  *    - Advance drange and srange by (imap start - srange start + imap len)
 871  *
 872  * Finally, if the reflink made dest longer, update both the in-core and
 873  * on-disk file sizes.
 874  *
 875  * ASCII Art Demonstration:
 876  *
 877  * Let's say we want to reflink this source file:
 878  *
 879  * ----SSSSSSS-SSSSS----SSSSSS (src file)
 880  *   <-------------------->
 881  *
 882  * into this destination file:
 883  *
 884  * --DDDDDDDDDDDDDDDDDDD--DDD (dest file)
 885  *        <-------------------->
 886  * '-' means a hole, and 'S' and 'D' are written blocks in the src and dest.
 887  * Observe that the range has different logical offsets in either file.
 888  *
 889  * Consider that the first extent in the source file doesn't line up with our
 890  * reflink range.  Unmapping  and remapping are separate operations, so we can
 891  * unmap more blocks from the destination file than we remap.
 892  *
 893  * ----SSSSSSS-SSSSS----SSSSSS
 894  *   <------->
 895  * --DDDDD---------DDDDD--DDD
 896  *        <------->
 897  *
 898  * Now remap the source extent into the destination file:
 899  *
 900  * ----SSSSSSS-SSSSS----SSSSSS
 901  *   <------->
 902  * --DDDDD--SSSSSSSDDDDD--DDD
 903  *        <------->
 904  *
 905  * Do likewise with the second hole and extent in our range.  Holes in the
 906  * unmap range don't affect our operation.
 907  *
 908  * ----SSSSSSS-SSSSS----SSSSSS
 909  *            <---->
 910  * --DDDDD--SSSSSSS-SSSSS-DDD
 911  *                 <---->
 912  *
 913  * Finally, unmap and remap part of the third extent.  This will increase the
 914  * size of the destination file.
 915  *
 916  * ----SSSSSSS-SSSSS----SSSSSS
 917  *                  <----->
 918  * --DDDDD--SSSSSSS-SSSSS----SSS
 919  *                       <----->
 920  *
 921  * Once we update the destination file's i_size, we're done.
 922  */
 923
 924 /*
 925  * Ensure the reflink bit is set in both inodes.
 926  */
 927 STATIC int
 928 xfs_reflink_set_inode_flag(
 929         struct xfs_inode        *src,
 930         struct xfs_inode        *dest)
 931 {
 932         struct xfs_mount        *mp = src->i_mount;
 933         int                     error;
 934         struct xfs_trans        *tp;
 935
 936         if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest))
 937                 return 0;
 938
 939         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
 940         if (error)
 941                 goto out_error;
 942
 943         /* Lock both files against IO */
 944         if (src->i_ino == dest->i_ino)
 945                 xfs_ilock(src, XFS_ILOCK_EXCL);
 946         else
 947                 xfs_lock_two_inodes(src, dest, XFS_ILOCK_EXCL);
 948
 949         if (!xfs_is_reflink_inode(src)) {
 950                 trace_xfs_reflink_set_inode_flag(src);
 951                 xfs_trans_ijoin(tp, src, XFS_ILOCK_EXCL);
 952                 src->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
 953                 xfs_trans_log_inode(tp, src, XFS_ILOG_CORE);
 954                 xfs_ifork_init_cow(src);
 955         } else
 956                 xfs_iunlock(src, XFS_ILOCK_EXCL);
 957
 958         if (src->i_ino == dest->i_ino)
 959                 goto commit_flags;
 960
 961         if (!xfs_is_reflink_inode(dest)) {
 962                 trace_xfs_reflink_set_inode_flag(dest);
 963                 xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
 964                 dest->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
 965                 xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
 966                 xfs_ifork_init_cow(dest);
 967         } else
 968                 xfs_iunlock(dest, XFS_ILOCK_EXCL);
 969
 970 commit_flags:
 971         error = xfs_trans_commit(tp);
 972         if (error)
 973                 goto out_error;
 974         return error;
 975
 976 out_error:
 977         trace_xfs_reflink_set_inode_flag_error(dest, error, _RET_IP_);
 978         return error;
 979 }
 980
 981 /*
 982  * Update destination inode size & cowextsize hint, if necessary.
 983  */
 984 STATIC int
 985 xfs_reflink_update_dest(
 986         struct xfs_inode        *dest,
 987         xfs_off_t               newlen,
 988         xfs_extlen_t            cowextsize,
 989         bool                    is_dedupe)
 990 {
 991         struct xfs_mount        *mp = dest->i_mount;
 992         struct xfs_trans        *tp;
 993         int                     error;
 994
 995         if (is_dedupe && newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0)
 996                 return 0;
 997
 998         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
 999         if (error)
1000                 goto out_error;
1001
1002         xfs_ilock(dest, XFS_ILOCK_EXCL);
1003         xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
1004
1005         if (newlen > i_size_read(VFS_I(dest))) {
1006                 trace_xfs_reflink_update_inode_size(dest, newlen);
1007                 i_size_write(VFS_I(dest), newlen);
1008                 dest->i_d.di_size = newlen;
1009         }
1010
1011         if (cowextsize) {
1012                 dest->i_d.di_cowextsize = cowextsize;
1013                 dest->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
1014         }
1015
1016         if (!is_dedupe) {
1017                 xfs_trans_ichgtime(tp, dest,
1018                                    XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1019         }
1020         xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
1021
1022         error = xfs_trans_commit(tp);
1023         if (error)
1024                 goto out_error;
1025         return error;
1026
1027 out_error:
1028         trace_xfs_reflink_update_inode_size_error(dest, error, _RET_IP_);
1029         return error;
1030 }
1031
1032 /*
1033  * Do we have enough reserve in this AG to handle a reflink?  The refcount
1034  * btree already reserved all the space it needs, but the rmap btree can grow
1035  * infinitely, so we won't allow more reflinks when the AG is down to the
1036  * btree reserves.
1037  */
1038 static int
1039 xfs_reflink_ag_has_free_space(
1040         struct xfs_mount        *mp,
1041         xfs_agnumber_t          agno)
1042 {
1043         struct xfs_perag        *pag;
1044         int                     error = 0;
1045
1046         if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
1047                 return 0;
1048
1049         pag = xfs_perag_get(mp, agno);
1050         if (xfs_ag_resv_critical(pag, XFS_AG_RESV_AGFL) ||
1051             xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA))
1052                 error = -ENOSPC;
1053         xfs_perag_put(pag);
1054         return error;
1055 }
1056
1057 /*
1058  * Unmap a range of blocks from a file, then map other blocks into the hole.
1059  * The range to unmap is (destoff : destoff + srcioff + irec->br_blockcount).
1060  * The extent irec is mapped into dest at irec->br_startoff.
1061  */
1062 STATIC int
1063 xfs_reflink_remap_extent(
1064         struct xfs_inode        *ip,
1065         struct xfs_bmbt_irec    *irec,
1066         xfs_fileoff_t           destoff,
1067         xfs_off_t               new_isize)
1068 {
1069         struct xfs_mount        *mp = ip->i_mount;
1070         bool                    real_extent = xfs_bmap_is_real_extent(irec);
1071         struct xfs_trans        *tp;
1072         xfs_fsblock_t           firstfsb;
1073         unsigned int            resblks;
1074         struct xfs_defer_ops    dfops;
1075         struct xfs_bmbt_irec    uirec;
1076         xfs_filblks_t           rlen;
1077         xfs_filblks_t           unmap_len;
1078         xfs_off_t               newlen;
1079         int                     error;
1080
1081         unmap_len = irec->br_startoff + irec->br_blockcount - destoff;
1082         trace_xfs_reflink_punch_range(ip, destoff, unmap_len);
1083
1084         /* No reflinking if we're low on space */
1085         if (real_extent) {
1086                 error = xfs_reflink_ag_has_free_space(mp,
1087                                 XFS_FSB_TO_AGNO(mp, irec->br_startblock));
1088                 if (error)
1089                         goto out;
1090         }
1091
1092         /* Start a rolling transaction to switch the mappings */
1093         resblks = XFS_EXTENTADD_SPACE_RES(ip->i_mount, XFS_DATA_FORK);
1094         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp);
1095         if (error)
1096                 goto out;
1097
1098         xfs_ilock(ip, XFS_ILOCK_EXCL);
1099         xfs_trans_ijoin(tp, ip, 0);
1100
1101         /* If we're not just clearing space, then do we have enough quota? */
1102         if (real_extent) {
1103                 error = xfs_trans_reserve_quota_nblks(tp, ip,
1104                                 irec->br_blockcount, 0, XFS_QMOPT_RES_REGBLKS);
1105                 if (error)
1106                         goto out_cancel;
1107         }
1108
1109         trace_xfs_reflink_remap(ip, irec->br_startoff,
1110                                 irec->br_blockcount, irec->br_startblock);
1111
1112         /* Unmap the old blocks in the data fork. */
1113         rlen = unmap_len;
1114         while (rlen) {
1115                 xfs_defer_init(&dfops, &firstfsb);
1116                 error = __xfs_bunmapi(tp, ip, destoff, &rlen, 0, 1,
1117                                 &firstfsb, &dfops);
1118                 if (error)
1119                         goto out_defer;
1120
1121                 /*
1122                  * Trim the extent to whatever got unmapped.
1123                  * Remember, bunmapi works backwards.
1124                  */
1125                 uirec.br_startblock = irec->br_startblock + rlen;
1126                 uirec.br_startoff = irec->br_startoff + rlen;
1127                 uirec.br_blockcount = unmap_len - rlen;
1128                 unmap_len = rlen;
1129
1130                 /* If this isn't a real mapping, we're done. */
1131                 if (!real_extent || uirec.br_blockcount == 0)
1132                         goto next_extent;
1133
1134                 trace_xfs_reflink_remap(ip, uirec.br_startoff,
1135                                 uirec.br_blockcount, uirec.br_startblock);
1136
1137                 /* Update the refcount tree */
1138                 error = xfs_refcount_increase_extent(mp, &dfops, &uirec);
1139                 if (error)
1140                         goto out_defer;
1141
1142                 /* Map the new blocks into the data fork. */
1143                 error = xfs_bmap_map_extent(mp, &dfops, ip, &uirec);
1144                 if (error)
1145                         goto out_defer;
1146
1147                 /* Update quota accounting. */
1148                 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT,
1149                                 uirec.br_blockcount);
1150
1151                 /* Update dest isize if needed. */
1152                 newlen = XFS_FSB_TO_B(mp,
1153                                 uirec.br_startoff + uirec.br_blockcount);
1154                 newlen = min_t(xfs_off_t, newlen, new_isize);
1155                 if (newlen > i_size_read(VFS_I(ip))) {
1156                         trace_xfs_reflink_update_inode_size(ip, newlen);
1157                         i_size_write(VFS_I(ip), newlen);
1158                         ip->i_d.di_size = newlen;
1159                         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1160                 }
1161
1162 next_extent:
1163                 /* Process all the deferred stuff. */
1164                 xfs_defer_ijoin(&dfops, ip);
1165                 error = xfs_defer_finish(&tp, &dfops);
1166                 if (error)
1167                         goto out_defer;
1168         }
1169
1170         error = xfs_trans_commit(tp);
1171         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1172         if (error)
1173                 goto out;
1174         return 0;
1175
1176 out_defer:
1177         xfs_defer_cancel(&dfops);
1178 out_cancel:
1179         xfs_trans_cancel(tp);
1180         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1181 out:
1182         trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_);
1183         return error;
1184 }
1185
1186 /*
1187  * Iteratively remap one file's extents (and holes) to another's.
1188  */
1189 STATIC int
1190 xfs_reflink_remap_blocks(
1191         struct xfs_inode        *src,
1192         xfs_fileoff_t           srcoff,
1193         struct xfs_inode        *dest,
1194         xfs_fileoff_t           destoff,
1195         xfs_filblks_t           len,
1196         xfs_off_t               new_isize)
1197 {
1198         struct xfs_bmbt_irec    imap;
1199         int                     nimaps;
1200         int                     error = 0;
1201         xfs_filblks_t           range_len;
1202
1203         /* drange = (destoff, destoff + len); srange = (srcoff, srcoff + len) */
1204         while (len) {
1205                 trace_xfs_reflink_remap_blocks_loop(src, srcoff, len,
1206                                 dest, destoff);
1207                 /* Read extent from the source file */
1208                 nimaps = 1;
1209                 xfs_ilock(src, XFS_ILOCK_EXCL);
1210                 error = xfs_bmapi_read(src, srcoff, len, &imap, &nimaps, 0);
1211                 xfs_iunlock(src, XFS_ILOCK_EXCL);
1212                 if (error)
1213                         goto err;
1214                 ASSERT(nimaps == 1);
1215
1216                 trace_xfs_reflink_remap_imap(src, srcoff, len, XFS_IO_OVERWRITE,
1217                                 &imap);
1218
1219                 /* Translate imap into the destination file. */
1220                 range_len = imap.br_startoff + imap.br_blockcount - srcoff;
1221                 imap.br_startoff += destoff - srcoff;
1222
1223                 /* Clear dest from destoff to the end of imap and map it in. */
1224                 error = xfs_reflink_remap_extent(dest, &imap, destoff,
1225                                 new_isize);
1226                 if (error)
1227                         goto err;
1228
1229                 if (fatal_signal_pending(current)) {
1230                         error = -EINTR;
1231                         goto err;
1232                 }
1233
1234                 /* Advance drange/srange */
1235                 srcoff += range_len;
1236                 destoff += range_len;
1237                 len -= range_len;
1238         }
1239
1240         return 0;
1241
1242 err:
1243         trace_xfs_reflink_remap_blocks_error(dest, error, _RET_IP_);
1244         return error;
1245 }
1246
1247 /*
1248  * Link a range of blocks from one file to another.
1249  */
1250 int
1251 xfs_reflink_remap_range(
1252         struct file             *file_in,
1253         loff_t                  pos_in,
1254         struct file             *file_out,
1255         loff_t                  pos_out,
1256         u64                     len,
1257         bool                    is_dedupe)
1258 {
1259         struct inode            *inode_in = file_inode(file_in);
1260         struct xfs_inode        *src = XFS_I(inode_in);
1261         struct inode            *inode_out = file_inode(file_out);
1262         struct xfs_inode        *dest = XFS_I(inode_out);
1263         struct xfs_mount        *mp = src->i_mount;
1264         bool                    same_inode = (inode_in == inode_out);
1265         xfs_fileoff_t           sfsbno, dfsbno;
1266         xfs_filblks_t           fsblen;
1267         xfs_extlen_t            cowextsize;
1268         ssize_t                 ret;
1269
1270         if (!xfs_sb_version_hasreflink(&mp->m_sb))
1271                 return -EOPNOTSUPP;
1272
1273         if (XFS_FORCED_SHUTDOWN(mp))
1274                 return -EIO;
1275
1276         /* Lock both files against IO */
1277         lock_two_nondirectories(inode_in, inode_out);
1278         if (same_inode)
1279                 xfs_ilock(src, XFS_MMAPLOCK_EXCL);
1280         else
1281                 xfs_lock_two_inodes(src, dest, XFS_MMAPLOCK_EXCL);
1282
1283         /* Check file eligibility and prepare for block sharing. */
1284         ret = -EINVAL;
1285         /* Don't reflink realtime inodes */
1286         if (XFS_IS_REALTIME_INODE(src) || XFS_IS_REALTIME_INODE(dest))
1287                 goto out_unlock;
1288
1289         /* Don't share DAX file data for now. */
1290         if (IS_DAX(inode_in) || IS_DAX(inode_out))
1291                 goto out_unlock;
1292
1293         ret = vfs_clone_file_prep_inodes(inode_in, pos_in, inode_out, pos_out,
1294                         &len, is_dedupe);
1295         if (ret <= 0)
1296                 goto out_unlock;
1297
1298         trace_xfs_reflink_remap_range(src, pos_in, len, dest, pos_out);
1299
1300         /*
1301          * Clear out post-eof preallocations because we don't have page cache
1302          * backing the delayed allocations and they'll never get freed on
1303          * their own.
1304          */
1305         if (xfs_can_free_eofblocks(dest, true)) {
1306                 ret = xfs_free_eofblocks(dest);
1307                 if (ret)
1308                         goto out_unlock;
1309         }
1310
1311         /* Set flags and remap blocks. */
1312         ret = xfs_reflink_set_inode_flag(src, dest);
1313         if (ret)
1314                 goto out_unlock;
1315
1316         dfsbno = XFS_B_TO_FSBT(mp, pos_out);
1317         sfsbno = XFS_B_TO_FSBT(mp, pos_in);
1318         fsblen = XFS_B_TO_FSB(mp, len);
1319         ret = xfs_reflink_remap_blocks(src, sfsbno, dest, dfsbno, fsblen,
1320                         pos_out + len);
1321         if (ret)
1322                 goto out_unlock;
1323
1324         /* Zap any page cache for the destination file's range. */
1325         truncate_inode_pages_range(&inode_out->i_data, pos_out,
1326                                    PAGE_ALIGN(pos_out + len) - 1);
1327
1328         /*
1329          * Carry the cowextsize hint from src to dest if we're sharing the
1330          * entire source file to the entire destination file, the source file
1331          * has a cowextsize hint, and the destination file does not.
1332          */
1333         cowextsize = 0;
1334         if (pos_in == 0 && len == i_size_read(inode_in) &&
1335             (src->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) &&
1336             pos_out == 0 && len >= i_size_read(inode_out) &&
1337             !(dest->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1338                 cowextsize = src->i_d.di_cowextsize;
1339
1340         ret = xfs_reflink_update_dest(dest, pos_out + len, cowextsize,
1341                         is_dedupe);
1342
1343 out_unlock:
1344         xfs_iunlock(src, XFS_MMAPLOCK_EXCL);
1345         if (!same_inode)
1346                 xfs_iunlock(dest, XFS_MMAPLOCK_EXCL);
1347         unlock_two_nondirectories(inode_in, inode_out);
1348         if (ret)
1349                 trace_xfs_reflink_remap_range_error(dest, ret, _RET_IP_);
1350         return ret;
1351 }
1352
1353 /*
1354  * The user wants to preemptively CoW all shared blocks in this file,
1355  * which enables us to turn off the reflink flag.  Iterate all
1356  * extents which are not prealloc/delalloc to see which ranges are
1357  * mentioned in the refcount tree, then read those blocks into the
1358  * pagecache, dirty them, fsync them back out, and then we can update
1359  * the inode flag.  What happens if we run out of memory? :)
1360  */
1361 STATIC int
1362 xfs_reflink_dirty_extents(
1363         struct xfs_inode        *ip,
1364         xfs_fileoff_t           fbno,
1365         xfs_filblks_t           end,
1366         xfs_off_t               isize)
1367 {
1368         struct xfs_mount        *mp = ip->i_mount;
1369         xfs_agnumber_t          agno;
1370         xfs_agblock_t           agbno;
1371         xfs_extlen_t            aglen;
1372         xfs_agblock_t           rbno;
1373         xfs_extlen_t            rlen;
1374         xfs_off_t               fpos;
1375         xfs_off_t               flen;
1376         struct xfs_bmbt_irec    map[2];
1377         int                     nmaps;
1378         int                     error = 0;
1379
1380         while (end - fbno > 0) {
1381                 nmaps = 1;
1382                 /*
1383                  * Look for extents in the file.  Skip holes, delalloc, or
1384                  * unwritten extents; they can't be reflinked.
1385                  */
1386                 error = xfs_bmapi_read(ip, fbno, end - fbno, map, &nmaps, 0);
1387                 if (error)
1388                         goto out;
1389                 if (nmaps == 0)
1390                         break;
1391                 if (!xfs_bmap_is_real_extent(&map[0]))
1392                         goto next;
1393
1394                 map[1] = map[0];
1395                 while (map[1].br_blockcount) {
1396                         agno = XFS_FSB_TO_AGNO(mp, map[1].br_startblock);
1397                         agbno = XFS_FSB_TO_AGBNO(mp, map[1].br_startblock);
1398                         aglen = map[1].br_blockcount;
1399
1400                         error = xfs_reflink_find_shared(mp, NULL, agno, agbno,
1401                                         aglen, &rbno, &rlen, true);
1402                         if (error)
1403                                 goto out;
1404                         if (rbno == NULLAGBLOCK)
1405                                 break;
1406
1407                         /* Dirty the pages */
1408                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1409                         fpos = XFS_FSB_TO_B(mp, map[1].br_startoff +
1410                                         (rbno - agbno));
1411                         flen = XFS_FSB_TO_B(mp, rlen);
1412                         if (fpos + flen > isize)
1413                                 flen = isize - fpos;
1414                         error = iomap_file_dirty(VFS_I(ip), fpos, flen,
1415                                         &xfs_iomap_ops);
1416                         xfs_ilock(ip, XFS_ILOCK_EXCL);
1417                         if (error)
1418                                 goto out;
1419
1420                         map[1].br_blockcount -= (rbno - agbno + rlen);
1421                         map[1].br_startoff += (rbno - agbno + rlen);
1422                         map[1].br_startblock += (rbno - agbno + rlen);
1423                 }
1424
1425 next:
1426                 fbno = map[0].br_startoff + map[0].br_blockcount;
1427         }
1428 out:
1429         return error;
1430 }
1431
1432 /* Does this inode need the reflink flag? */
1433 int
1434 xfs_reflink_inode_has_shared_extents(
1435         struct xfs_trans                *tp,
1436         struct xfs_inode                *ip,
1437         bool                            *has_shared)
1438 {
1439         struct xfs_bmbt_irec            got;
1440         struct xfs_mount                *mp = ip->i_mount;
1441         struct xfs_ifork                *ifp;
1442         xfs_agnumber_t                  agno;
1443         xfs_agblock_t                   agbno;
1444         xfs_extlen_t                    aglen;
1445         xfs_agblock_t                   rbno;
1446         xfs_extlen_t                    rlen;
1447         struct xfs_iext_cursor          icur;
1448         bool                            found;
1449         int                             error;
1450
1451         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1452         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1453                 error = xfs_iread_extents(tp, ip, XFS_DATA_FORK);
1454                 if (error)
1455                         return error;
1456         }
1457
1458         *has_shared = false;
1459         found = xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got);
1460         while (found) {
1461                 if (isnullstartblock(got.br_startblock) ||
1462                     got.br_state != XFS_EXT_NORM)
1463                         goto next;
1464                 agno = XFS_FSB_TO_AGNO(mp, got.br_startblock);
1465                 agbno = XFS_FSB_TO_AGBNO(mp, got.br_startblock);
1466                 aglen = got.br_blockcount;
1467
1468                 error = xfs_reflink_find_shared(mp, tp, agno, agbno, aglen,
1469                                 &rbno, &rlen, false);
1470                 if (error)
1471                         return error;
1472                 /* Is there still a shared block here? */
1473                 if (rbno != NULLAGBLOCK) {
1474                         *has_shared = true;
1475                         return 0;
1476                 }
1477 next:
1478                 found = xfs_iext_next_extent(ifp, &icur, &got);
1479         }
1480
1481         return 0;
1482 }
1483
1484 /* Clear the inode reflink flag if there are no shared extents. */
1485 int
1486 xfs_reflink_clear_inode_flag(
1487         struct xfs_inode        *ip,
1488         struct xfs_trans        **tpp)
1489 {
1490         bool                    needs_flag;
1491         int                     error = 0;
1492
1493         ASSERT(xfs_is_reflink_inode(ip));
1494
1495         error = xfs_reflink_inode_has_shared_extents(*tpp, ip, &needs_flag);
1496         if (error || needs_flag)
1497                 return error;
1498
1499         /*
1500          * We didn't find any shared blocks so turn off the reflink flag.
1501          * First, get rid of any leftover CoW mappings.
1502          */
1503         error = xfs_reflink_cancel_cow_blocks(ip, tpp, 0, NULLFILEOFF, true);
1504         if (error)
1505                 return error;
1506
1507         /* Clear the inode flag. */
1508         trace_xfs_reflink_unset_inode_flag(ip);
1509         ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1510         xfs_inode_clear_cowblocks_tag(ip);
1511         xfs_trans_ijoin(*tpp, ip, 0);
1512         xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE);
1513
1514         return error;
1515 }
1516
1517 /*
1518  * Clear the inode reflink flag if there are no shared extents and the size
1519  * hasn't changed.
1520  */
1521 STATIC int
1522 xfs_reflink_try_clear_inode_flag(
1523         struct xfs_inode        *ip)
1524 {
1525         struct xfs_mount        *mp = ip->i_mount;
1526         struct xfs_trans        *tp;
1527         int                     error = 0;
1528
1529         /* Start a rolling transaction to remove the mappings */
1530         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1531         if (error)
1532                 return error;
1533
1534         xfs_ilock(ip, XFS_ILOCK_EXCL);
1535         xfs_trans_ijoin(tp, ip, 0);
1536
1537         error = xfs_reflink_clear_inode_flag(ip, &tp);
1538         if (error)
1539                 goto cancel;
1540
1541         error = xfs_trans_commit(tp);
1542         if (error)
1543                 goto out;
1544
1545         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1546         return 0;
1547 cancel:
1548         xfs_trans_cancel(tp);
1549 out:
1550         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1551         return error;
1552 }
1553
1554 /*
1555  * Pre-COW all shared blocks within a given byte range of a file and turn off
1556  * the reflink flag if we unshare all of the file's blocks.
1557  */
1558 int
1559 xfs_reflink_unshare(
1560         struct xfs_inode        *ip,
1561         xfs_off_t               offset,
1562         xfs_off_t               len)
1563 {
1564         struct xfs_mount        *mp = ip->i_mount;
1565         xfs_fileoff_t           fbno;
1566         xfs_filblks_t           end;
1567         xfs_off_t               isize;
1568         int                     error;
1569
1570         if (!xfs_is_reflink_inode(ip))
1571                 return 0;
1572
1573         trace_xfs_reflink_unshare(ip, offset, len);
1574
1575         inode_dio_wait(VFS_I(ip));
1576
1577         /* Try to CoW the selected ranges */
1578         xfs_ilock(ip, XFS_ILOCK_EXCL);
1579         fbno = XFS_B_TO_FSBT(mp, offset);
1580         isize = i_size_read(VFS_I(ip));
1581         end = XFS_B_TO_FSB(mp, offset + len);
1582         error = xfs_reflink_dirty_extents(ip, fbno, end, isize);
1583         if (error)
1584                 goto out_unlock;
1585         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1586
1587         /* Wait for the IO to finish */
1588         error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1589         if (error)
1590                 goto out;
1591
1592         /* Turn off the reflink flag if possible. */
1593         error = xfs_reflink_try_clear_inode_flag(ip);
1594         if (error)
1595                 goto out;
1596
1597         return 0;
1598
1599 out_unlock:
1600         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1601 out:
1602         trace_xfs_reflink_unshare_error(ip, error, _RET_IP_);
1603         return error;
1604 }