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         /* Finish up. */
 458         error = xfs_defer_finish(&tp, &dfops);
 459         if (error)
 460                 goto out_bmap_cancel;
 461
 462         error = xfs_trans_commit(tp);
 463         if (error)
 464                 return error;
 465 convert:
 466         return xfs_reflink_convert_cow_extent(ip, imap, offset_fsb, count_fsb,
 467                         &dfops);
 468 out_bmap_cancel:
 469         xfs_defer_cancel(&dfops);
 470         xfs_trans_unreserve_quota_nblks(tp, ip, (long)resblks, 0,
 471                         XFS_QMOPT_RES_REGBLKS);
 472 out:
 473         if (tp)
 474                 xfs_trans_cancel(tp);
 475         return error;
 476 }
 477
 478 /*
 479  * Find the CoW reservation for a given byte offset of a file.
 480  */
 481 bool
 482 xfs_reflink_find_cow_mapping(
 483         struct xfs_inode                *ip,
 484         xfs_off_t                       offset,
 485         struct xfs_bmbt_irec            *imap)
 486 {
 487         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 488         xfs_fileoff_t                   offset_fsb;
 489         struct xfs_bmbt_irec            got;
 490         struct xfs_iext_cursor          icur;
 491
 492         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
 493         ASSERT(xfs_is_reflink_inode(ip));
 494
 495         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 496         if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
 497                 return false;
 498         if (got.br_startoff > offset_fsb)
 499                 return false;
 500
 501         trace_xfs_reflink_find_cow_mapping(ip, offset, 1, XFS_IO_OVERWRITE,
 502                         &got);
 503         *imap = got;
 504         return true;
 505 }
 506
 507 /*
 508  * Trim an extent to end at the next CoW reservation past offset_fsb.
 509  */
 510 void
 511 xfs_reflink_trim_irec_to_next_cow(
 512         struct xfs_inode                *ip,
 513         xfs_fileoff_t                   offset_fsb,
 514         struct xfs_bmbt_irec            *imap)
 515 {
 516         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 517         struct xfs_bmbt_irec            got;
 518         struct xfs_iext_cursor          icur;
 519
 520         if (!xfs_is_reflink_inode(ip))
 521                 return;
 522
 523         /* Find the extent in the CoW fork. */
 524         if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
 525                 return;
 526
 527         /* This is the extent before; try sliding up one. */
 528         if (got.br_startoff < offset_fsb) {
 529                 if (!xfs_iext_next_extent(ifp, &icur, &got))
 530                         return;
 531         }
 532
 533         if (got.br_startoff >= imap->br_startoff + imap->br_blockcount)
 534                 return;
 535
 536         imap->br_blockcount = got.br_startoff - imap->br_startoff;
 537         trace_xfs_reflink_trim_irec(ip, imap);
 538 }
 539
 540 /*
 541  * Cancel CoW reservations for some block range of an inode.
 542  *
 543  * If cancel_real is true this function cancels all COW fork extents for the
 544  * inode; if cancel_real is false, real extents are not cleared.
 545  */
 546 int
 547 xfs_reflink_cancel_cow_blocks(
 548         struct xfs_inode                *ip,
 549         struct xfs_trans                **tpp,
 550         xfs_fileoff_t                   offset_fsb,
 551         xfs_fileoff_t                   end_fsb,
 552         bool                            cancel_real)
 553 {
 554         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 555         struct xfs_bmbt_irec            got, del;
 556         struct xfs_iext_cursor          icur;
 557         xfs_fsblock_t                   firstfsb;
 558         struct xfs_defer_ops            dfops;
 559         int                             error = 0;
 560
 561         if (!xfs_is_reflink_inode(ip))
 562                 return 0;
 563         if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
 564                 return 0;
 565
 566         /* Walk backwards until we're out of the I/O range... */
 567         while (got.br_startoff + got.br_blockcount > offset_fsb) {
 568                 del = got;
 569                 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
 570
 571                 /* Extent delete may have bumped ext forward */
 572                 if (!del.br_blockcount) {
 573                         xfs_iext_prev(ifp, &icur);
 574                         goto next_extent;
 575                 }
 576
 577                 trace_xfs_reflink_cancel_cow(ip, &del);
 578
 579                 if (isnullstartblock(del.br_startblock)) {
 580                         error = xfs_bmap_del_extent_delay(ip, XFS_COW_FORK,
 581                                         &icur, &got, &del);
 582                         if (error)
 583                                 break;
 584                 } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) {
 585                         xfs_trans_ijoin(*tpp, ip, 0);
 586                         xfs_defer_init(&dfops, &firstfsb);
 587
 588                         /* Free the CoW orphan record. */
 589                         error = xfs_refcount_free_cow_extent(ip->i_mount,
 590                                         &dfops, del.br_startblock,
 591                                         del.br_blockcount);
 592                         if (error)
 593                                 break;
 594
 595                         xfs_bmap_add_free(ip->i_mount, &dfops,
 596                                         del.br_startblock, del.br_blockcount,
 597                                         NULL);
 598
 599                         /* Update quota accounting */
 600                         xfs_trans_mod_dquot_byino(*tpp, ip, XFS_TRANS_DQ_BCOUNT,
 601                                         -(long)del.br_blockcount);
 602
 603                         /* Roll the transaction */
 604                         xfs_defer_ijoin(&dfops, ip);
 605                         error = xfs_defer_finish(tpp, &dfops);
 606                         if (error) {
 607                                 xfs_defer_cancel(&dfops);
 608                                 break;
 609                         }
 610
 611                         /* Remove the mapping from the CoW fork. */
 612                         xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
 613                 }
 614 next_extent:
 615                 if (!xfs_iext_get_extent(ifp, &icur, &got))
 616                         break;
 617         }
 618
 619         /* clear tag if cow fork is emptied */
 620         if (!ifp->if_bytes)
 621                 xfs_inode_clear_cowblocks_tag(ip);
 622
 623         return error;
 624 }
 625
 626 /*
 627  * Cancel CoW reservations for some byte range of an inode.
 628  *
 629  * If cancel_real is true this function cancels all COW fork extents for the
 630  * inode; if cancel_real is false, real extents are not cleared.
 631  */
 632 int
 633 xfs_reflink_cancel_cow_range(
 634         struct xfs_inode        *ip,
 635         xfs_off_t               offset,
 636         xfs_off_t               count,
 637         bool                    cancel_real)
 638 {
 639         struct xfs_trans        *tp;
 640         xfs_fileoff_t           offset_fsb;
 641         xfs_fileoff_t           end_fsb;
 642         int                     error;
 643
 644         trace_xfs_reflink_cancel_cow_range(ip, offset, count);
 645         ASSERT(xfs_is_reflink_inode(ip));
 646
 647         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 648         if (count == NULLFILEOFF)
 649                 end_fsb = NULLFILEOFF;
 650         else
 651                 end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
 652
 653         /* Start a rolling transaction to remove the mappings */
 654         error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
 655                         0, 0, 0, &tp);
 656         if (error)
 657                 goto out;
 658
 659         xfs_ilock(ip, XFS_ILOCK_EXCL);
 660         xfs_trans_ijoin(tp, ip, 0);
 661
 662         /* Scrape out the old CoW reservations */
 663         error = xfs_reflink_cancel_cow_blocks(ip, &tp, offset_fsb, end_fsb,
 664                         cancel_real);
 665         if (error)
 666                 goto out_cancel;
 667
 668         error = xfs_trans_commit(tp);
 669
 670         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 671         return error;
 672
 673 out_cancel:
 674         xfs_trans_cancel(tp);
 675         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 676 out:
 677         trace_xfs_reflink_cancel_cow_range_error(ip, error, _RET_IP_);
 678         return error;
 679 }
 680
 681 /*
 682  * Remap parts of a file's data fork after a successful CoW.
 683  */
 684 int
 685 xfs_reflink_end_cow(
 686         struct xfs_inode                *ip,
 687         xfs_off_t                       offset,
 688         xfs_off_t                       count)
 689 {
 690         struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
 691         struct xfs_bmbt_irec            got, del;
 692         struct xfs_trans                *tp;
 693         xfs_fileoff_t                   offset_fsb;
 694         xfs_fileoff_t                   end_fsb;
 695         xfs_fsblock_t                   firstfsb;
 696         struct xfs_defer_ops            dfops;
 697         int                             error;
 698         unsigned int                    resblks;
 699         xfs_filblks_t                   rlen;
 700         struct xfs_iext_cursor          icur;
 701
 702         trace_xfs_reflink_end_cow(ip, offset, count);
 703
 704         /* No COW extents?  That's easy! */
 705         if (ifp->if_bytes == 0)
 706                 return 0;
 707
 708         offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 709         end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
 710
 711         /*
 712          * Start a rolling transaction to switch the mappings.  We're
 713          * unlikely ever to have to remap 16T worth of single-block
 714          * extents, so just cap the worst case extent count to 2^32-1.
 715          * Stick a warning in just in case, and avoid 64-bit division.
 716          */
 717         BUILD_BUG_ON(MAX_RW_COUNT > UINT_MAX);
 718         if (end_fsb - offset_fsb > UINT_MAX) {
 719                 error = -EFSCORRUPTED;
 720                 xfs_force_shutdown(ip->i_mount, SHUTDOWN_CORRUPT_INCORE);
 721                 ASSERT(0);
 722                 goto out;
 723         }
 724         resblks = XFS_NEXTENTADD_SPACE_RES(ip->i_mount,
 725                         (unsigned int)(end_fsb - offset_fsb),
 726                         XFS_DATA_FORK);
 727         error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
 728                         resblks, 0, 0, &tp);
 729         if (error)
 730                 goto out;
 731
 732         xfs_ilock(ip, XFS_ILOCK_EXCL);
 733         xfs_trans_ijoin(tp, ip, 0);
 734
 735         /*
 736          * In case of racing, overlapping AIO writes no COW extents might be
 737          * left by the time I/O completes for the loser of the race.  In that
 738          * case we are done.
 739          */
 740         if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
 741                 goto out_cancel;
 742
 743         /* Walk backwards until we're out of the I/O range... */
 744         while (got.br_startoff + got.br_blockcount > offset_fsb) {
 745                 del = got;
 746                 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
 747
 748                 /* Extent delete may have bumped ext forward */
 749                 if (!del.br_blockcount) {
 750                         xfs_iext_prev(ifp, &icur);
 751                         goto next_extent;
 752                 }
 753
 754                 ASSERT(!isnullstartblock(got.br_startblock));
 755
 756                 /*
 757                  * Don't remap unwritten extents; these are
 758                  * speculatively preallocated CoW extents that have been
 759                  * allocated but have not yet been involved in a write.
 760                  */
 761                 if (got.br_state == XFS_EXT_UNWRITTEN) {
 762                         xfs_iext_prev(ifp, &icur);
 763                         goto next_extent;
 764                 }
 765
 766                 /* Unmap the old blocks in the data fork. */
 767                 xfs_defer_init(&dfops, &firstfsb);
 768                 rlen = del.br_blockcount;
 769                 error = __xfs_bunmapi(tp, ip, del.br_startoff, &rlen, 0, 1,
 770                                 &firstfsb, &dfops);
 771                 if (error)
 772                         goto out_defer;
 773
 774                 /* Trim the extent to whatever got unmapped. */
 775                 if (rlen) {
 776                         xfs_trim_extent(&del, del.br_startoff + rlen,
 777                                 del.br_blockcount - rlen);
 778                 }
 779                 trace_xfs_reflink_cow_remap(ip, &del);
 780
 781                 /* Free the CoW orphan record. */
 782                 error = xfs_refcount_free_cow_extent(tp->t_mountp, &dfops,
 783                                 del.br_startblock, del.br_blockcount);
 784                 if (error)
 785                         goto out_defer;
 786
 787                 /* Map the new blocks into the data fork. */
 788                 error = xfs_bmap_map_extent(tp->t_mountp, &dfops, ip, &del);
 789                 if (error)
 790                         goto out_defer;
 791
 792                 /* Remove the mapping from the CoW fork. */
 793                 xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
 794
 795                 xfs_defer_ijoin(&dfops, ip);
 796                 error = xfs_defer_finish(&tp, &dfops);
 797                 if (error)
 798                         goto out_defer;
 799 next_extent:
 800                 if (!xfs_iext_get_extent(ifp, &icur, &got))
 801                         break;
 802         }
 803
 804         error = xfs_trans_commit(tp);
 805         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 806         if (error)
 807                 goto out;
 808         return 0;
 809
 810 out_defer:
 811         xfs_defer_cancel(&dfops);
 812 out_cancel:
 813         xfs_trans_cancel(tp);
 814         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 815 out:
 816         trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_);
 817         return error;
 818 }
 819
 820 /*
 821  * Free leftover CoW reservations that didn't get cleaned out.
 822  */
 823 int
 824 xfs_reflink_recover_cow(
 825         struct xfs_mount        *mp)
 826 {
 827         xfs_agnumber_t          agno;
 828         int                     error = 0;
 829
 830         if (!xfs_sb_version_hasreflink(&mp->m_sb))
 831                 return 0;
 832
 833         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
 834                 error = xfs_refcount_recover_cow_leftovers(mp, agno);
 835                 if (error)
 836                         break;
 837         }
 838
 839         return error;
 840 }
 841
 842 /*
 843  * Reflinking (Block) Ranges of Two Files Together
 844  *
 845  * First, ensure that the reflink flag is set on both inodes.  The flag is an
 846  * optimization to avoid unnecessary refcount btree lookups in the write path.
 847  *
 848  * Now we can iteratively remap the range of extents (and holes) in src to the
 849  * corresponding ranges in dest.  Let drange and srange denote the ranges of
 850  * logical blocks in dest and src touched by the reflink operation.
 851  *
 852  * While the length of drange is greater than zero,
 853  *    - Read src's bmbt at the start of srange ("imap")
 854  *    - If imap doesn't exist, make imap appear to start at the end of srange
 855  *      with zero length.
 856  *    - If imap starts before srange, advance imap to start at srange.
 857  *    - If imap goes beyond srange, truncate imap to end at the end of srange.
 858  *    - Punch (imap start - srange start + imap len) blocks from dest at
 859  *      offset (drange start).
 860  *    - If imap points to a real range of pblks,
 861  *         > Increase the refcount of the imap's pblks
 862  *         > Map imap's pblks into dest at the offset
 863  *           (drange start + imap start - srange start)
 864  *    - Advance drange and srange by (imap start - srange start + imap len)
 865  *
 866  * Finally, if the reflink made dest longer, update both the in-core and
 867  * on-disk file sizes.
 868  *
 869  * ASCII Art Demonstration:
 870  *
 871  * Let's say we want to reflink this source file:
 872  *
 873  * ----SSSSSSS-SSSSS----SSSSSS (src file)
 874  *   <-------------------->
 875  *
 876  * into this destination file:
 877  *
 878  * --DDDDDDDDDDDDDDDDDDD--DDD (dest file)
 879  *        <-------------------->
 880  * '-' means a hole, and 'S' and 'D' are written blocks in the src and dest.
 881  * Observe that the range has different logical offsets in either file.
 882  *
 883  * Consider that the first extent in the source file doesn't line up with our
 884  * reflink range.  Unmapping  and remapping are separate operations, so we can
 885  * unmap more blocks from the destination file than we remap.
 886  *
 887  * ----SSSSSSS-SSSSS----SSSSSS
 888  *   <------->
 889  * --DDDDD---------DDDDD--DDD
 890  *        <------->
 891  *
 892  * Now remap the source extent into the destination file:
 893  *
 894  * ----SSSSSSS-SSSSS----SSSSSS
 895  *   <------->
 896  * --DDDDD--SSSSSSSDDDDD--DDD
 897  *        <------->
 898  *
 899  * Do likewise with the second hole and extent in our range.  Holes in the
 900  * unmap range don't affect our operation.
 901  *
 902  * ----SSSSSSS-SSSSS----SSSSSS
 903  *            <---->
 904  * --DDDDD--SSSSSSS-SSSSS-DDD
 905  *                 <---->
 906  *
 907  * Finally, unmap and remap part of the third extent.  This will increase the
 908  * size of the destination file.
 909  *
 910  * ----SSSSSSS-SSSSS----SSSSSS
 911  *                  <----->
 912  * --DDDDD--SSSSSSS-SSSSS----SSS
 913  *                       <----->
 914  *
 915  * Once we update the destination file's i_size, we're done.
 916  */
 917
 918 /*
 919  * Ensure the reflink bit is set in both inodes.
 920  */
 921 STATIC int
 922 xfs_reflink_set_inode_flag(
 923         struct xfs_inode        *src,
 924         struct xfs_inode        *dest)
 925 {
 926         struct xfs_mount        *mp = src->i_mount;
 927         int                     error;
 928         struct xfs_trans        *tp;
 929
 930         if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest))
 931                 return 0;
 932
 933         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
 934         if (error)
 935                 goto out_error;
 936
 937         /* Lock both files against IO */
 938         if (src->i_ino == dest->i_ino)
 939                 xfs_ilock(src, XFS_ILOCK_EXCL);
 940         else
 941                 xfs_lock_two_inodes(src, dest, XFS_ILOCK_EXCL);
 942
 943         if (!xfs_is_reflink_inode(src)) {
 944                 trace_xfs_reflink_set_inode_flag(src);
 945                 xfs_trans_ijoin(tp, src, XFS_ILOCK_EXCL);
 946                 src->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
 947                 xfs_trans_log_inode(tp, src, XFS_ILOG_CORE);
 948                 xfs_ifork_init_cow(src);
 949         } else
 950                 xfs_iunlock(src, XFS_ILOCK_EXCL);
 951
 952         if (src->i_ino == dest->i_ino)
 953                 goto commit_flags;
 954
 955         if (!xfs_is_reflink_inode(dest)) {
 956                 trace_xfs_reflink_set_inode_flag(dest);
 957                 xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
 958                 dest->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
 959                 xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
 960                 xfs_ifork_init_cow(dest);
 961         } else
 962                 xfs_iunlock(dest, XFS_ILOCK_EXCL);
 963
 964 commit_flags:
 965         error = xfs_trans_commit(tp);
 966         if (error)
 967                 goto out_error;
 968         return error;
 969
 970 out_error:
 971         trace_xfs_reflink_set_inode_flag_error(dest, error, _RET_IP_);
 972         return error;
 973 }
 974
 975 /*
 976  * Update destination inode size & cowextsize hint, if necessary.
 977  */
 978 STATIC int
 979 xfs_reflink_update_dest(
 980         struct xfs_inode        *dest,
 981         xfs_off_t               newlen,
 982         xfs_extlen_t            cowextsize,
 983         bool                    is_dedupe)
 984 {
 985         struct xfs_mount        *mp = dest->i_mount;
 986         struct xfs_trans        *tp;
 987         int                     error;
 988
 989         if (is_dedupe && newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0)
 990                 return 0;
 991
 992         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
 993         if (error)
 994                 goto out_error;
 995
 996         xfs_ilock(dest, XFS_ILOCK_EXCL);
 997         xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
 998
 999         if (newlen > i_size_read(VFS_I(dest))) {
1000                 trace_xfs_reflink_update_inode_size(dest, newlen);
1001                 i_size_write(VFS_I(dest), newlen);
1002                 dest->i_d.di_size = newlen;
1003         }
1004
1005         if (cowextsize) {
1006                 dest->i_d.di_cowextsize = cowextsize;
1007                 dest->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
1008         }
1009
1010         if (!is_dedupe) {
1011                 xfs_trans_ichgtime(tp, dest,
1012                                    XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1013         }
1014         xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
1015
1016         error = xfs_trans_commit(tp);
1017         if (error)
1018                 goto out_error;
1019         return error;
1020
1021 out_error:
1022         trace_xfs_reflink_update_inode_size_error(dest, error, _RET_IP_);
1023         return error;
1024 }
1025
1026 /*
1027  * Do we have enough reserve in this AG to handle a reflink?  The refcount
1028  * btree already reserved all the space it needs, but the rmap btree can grow
1029  * infinitely, so we won't allow more reflinks when the AG is down to the
1030  * btree reserves.
1031  */
1032 static int
1033 xfs_reflink_ag_has_free_space(
1034         struct xfs_mount        *mp,
1035         xfs_agnumber_t          agno)
1036 {
1037         struct xfs_perag        *pag;
1038         int                     error = 0;
1039
1040         if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
1041                 return 0;
1042
1043         pag = xfs_perag_get(mp, agno);
1044         if (xfs_ag_resv_critical(pag, XFS_AG_RESV_AGFL) ||
1045             xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA))
1046                 error = -ENOSPC;
1047         xfs_perag_put(pag);
1048         return error;
1049 }
1050
1051 /*
1052  * Unmap a range of blocks from a file, then map other blocks into the hole.
1053  * The range to unmap is (destoff : destoff + srcioff + irec->br_blockcount).
1054  * The extent irec is mapped into dest at irec->br_startoff.
1055  */
1056 STATIC int
1057 xfs_reflink_remap_extent(
1058         struct xfs_inode        *ip,
1059         struct xfs_bmbt_irec    *irec,
1060         xfs_fileoff_t           destoff,
1061         xfs_off_t               new_isize)
1062 {
1063         struct xfs_mount        *mp = ip->i_mount;
1064         bool                    real_extent = xfs_bmap_is_real_extent(irec);
1065         struct xfs_trans        *tp;
1066         xfs_fsblock_t           firstfsb;
1067         unsigned int            resblks;
1068         struct xfs_defer_ops    dfops;
1069         struct xfs_bmbt_irec    uirec;
1070         xfs_filblks_t           rlen;
1071         xfs_filblks_t           unmap_len;
1072         xfs_off_t               newlen;
1073         int                     error;
1074
1075         unmap_len = irec->br_startoff + irec->br_blockcount - destoff;
1076         trace_xfs_reflink_punch_range(ip, destoff, unmap_len);
1077
1078         /* No reflinking if we're low on space */
1079         if (real_extent) {
1080                 error = xfs_reflink_ag_has_free_space(mp,
1081                                 XFS_FSB_TO_AGNO(mp, irec->br_startblock));
1082                 if (error)
1083                         goto out;
1084         }
1085
1086         /* Start a rolling transaction to switch the mappings */
1087         resblks = XFS_EXTENTADD_SPACE_RES(ip->i_mount, XFS_DATA_FORK);
1088         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp);
1089         if (error)
1090                 goto out;
1091
1092         xfs_ilock(ip, XFS_ILOCK_EXCL);
1093         xfs_trans_ijoin(tp, ip, 0);
1094
1095         /* If we're not just clearing space, then do we have enough quota? */
1096         if (real_extent) {
1097                 error = xfs_trans_reserve_quota_nblks(tp, ip,
1098                                 irec->br_blockcount, 0, XFS_QMOPT_RES_REGBLKS);
1099                 if (error)
1100                         goto out_cancel;
1101         }
1102
1103         trace_xfs_reflink_remap(ip, irec->br_startoff,
1104                                 irec->br_blockcount, irec->br_startblock);
1105
1106         /* Unmap the old blocks in the data fork. */
1107         rlen = unmap_len;
1108         while (rlen) {
1109                 xfs_defer_init(&dfops, &firstfsb);
1110                 error = __xfs_bunmapi(tp, ip, destoff, &rlen, 0, 1,
1111                                 &firstfsb, &dfops);
1112                 if (error)
1113                         goto out_defer;
1114
1115                 /*
1116                  * Trim the extent to whatever got unmapped.
1117                  * Remember, bunmapi works backwards.
1118                  */
1119                 uirec.br_startblock = irec->br_startblock + rlen;
1120                 uirec.br_startoff = irec->br_startoff + rlen;
1121                 uirec.br_blockcount = unmap_len - rlen;
1122                 unmap_len = rlen;
1123
1124                 /* If this isn't a real mapping, we're done. */
1125                 if (!real_extent || uirec.br_blockcount == 0)
1126                         goto next_extent;
1127
1128                 trace_xfs_reflink_remap(ip, uirec.br_startoff,
1129                                 uirec.br_blockcount, uirec.br_startblock);
1130
1131                 /* Update the refcount tree */
1132                 error = xfs_refcount_increase_extent(mp, &dfops, &uirec);
1133                 if (error)
1134                         goto out_defer;
1135
1136                 /* Map the new blocks into the data fork. */
1137                 error = xfs_bmap_map_extent(mp, &dfops, ip, &uirec);
1138                 if (error)
1139                         goto out_defer;
1140
1141                 /* Update quota accounting. */
1142                 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT,
1143                                 uirec.br_blockcount);
1144
1145                 /* Update dest isize if needed. */
1146                 newlen = XFS_FSB_TO_B(mp,
1147                                 uirec.br_startoff + uirec.br_blockcount);
1148                 newlen = min_t(xfs_off_t, newlen, new_isize);
1149                 if (newlen > i_size_read(VFS_I(ip))) {
1150                         trace_xfs_reflink_update_inode_size(ip, newlen);
1151                         i_size_write(VFS_I(ip), newlen);
1152                         ip->i_d.di_size = newlen;
1153                         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1154                 }
1155
1156 next_extent:
1157                 /* Process all the deferred stuff. */
1158                 xfs_defer_ijoin(&dfops, ip);
1159                 error = xfs_defer_finish(&tp, &dfops);
1160                 if (error)
1161                         goto out_defer;
1162         }
1163
1164         error = xfs_trans_commit(tp);
1165         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1166         if (error)
1167                 goto out;
1168         return 0;
1169
1170 out_defer:
1171         xfs_defer_cancel(&dfops);
1172 out_cancel:
1173         xfs_trans_cancel(tp);
1174         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1175 out:
1176         trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_);
1177         return error;
1178 }
1179
1180 /*
1181  * Iteratively remap one file's extents (and holes) to another's.
1182  */
1183 STATIC int
1184 xfs_reflink_remap_blocks(
1185         struct xfs_inode        *src,
1186         xfs_fileoff_t           srcoff,
1187         struct xfs_inode        *dest,
1188         xfs_fileoff_t           destoff,
1189         xfs_filblks_t           len,
1190         xfs_off_t               new_isize)
1191 {
1192         struct xfs_bmbt_irec    imap;
1193         int                     nimaps;
1194         int                     error = 0;
1195         xfs_filblks_t           range_len;
1196
1197         /* drange = (destoff, destoff + len); srange = (srcoff, srcoff + len) */
1198         while (len) {
1199                 trace_xfs_reflink_remap_blocks_loop(src, srcoff, len,
1200                                 dest, destoff);
1201                 /* Read extent from the source file */
1202                 nimaps = 1;
1203                 xfs_ilock(src, XFS_ILOCK_EXCL);
1204                 error = xfs_bmapi_read(src, srcoff, len, &imap, &nimaps, 0);
1205                 xfs_iunlock(src, XFS_ILOCK_EXCL);
1206                 if (error)
1207                         goto err;
1208                 ASSERT(nimaps == 1);
1209
1210                 trace_xfs_reflink_remap_imap(src, srcoff, len, XFS_IO_OVERWRITE,
1211                                 &imap);
1212
1213                 /* Translate imap into the destination file. */
1214                 range_len = imap.br_startoff + imap.br_blockcount - srcoff;
1215                 imap.br_startoff += destoff - srcoff;
1216
1217                 /* Clear dest from destoff to the end of imap and map it in. */
1218                 error = xfs_reflink_remap_extent(dest, &imap, destoff,
1219                                 new_isize);
1220                 if (error)
1221                         goto err;
1222
1223                 if (fatal_signal_pending(current)) {
1224                         error = -EINTR;
1225                         goto err;
1226                 }
1227
1228                 /* Advance drange/srange */
1229                 srcoff += range_len;
1230                 destoff += range_len;
1231                 len -= range_len;
1232         }
1233
1234         return 0;
1235
1236 err:
1237         trace_xfs_reflink_remap_blocks_error(dest, error, _RET_IP_);
1238         return error;
1239 }
1240
1241 /*
1242  * Link a range of blocks from one file to another.
1243  */
1244 int
1245 xfs_reflink_remap_range(
1246         struct file             *file_in,
1247         loff_t                  pos_in,
1248         struct file             *file_out,
1249         loff_t                  pos_out,
1250         u64                     len,
1251         bool                    is_dedupe)
1252 {
1253         struct inode            *inode_in = file_inode(file_in);
1254         struct xfs_inode        *src = XFS_I(inode_in);
1255         struct inode            *inode_out = file_inode(file_out);
1256         struct xfs_inode        *dest = XFS_I(inode_out);
1257         struct xfs_mount        *mp = src->i_mount;
1258         bool                    same_inode = (inode_in == inode_out);
1259         xfs_fileoff_t           sfsbno, dfsbno;
1260         xfs_filblks_t           fsblen;
1261         xfs_extlen_t            cowextsize;
1262         ssize_t                 ret;
1263
1264         if (!xfs_sb_version_hasreflink(&mp->m_sb))
1265                 return -EOPNOTSUPP;
1266
1267         if (XFS_FORCED_SHUTDOWN(mp))
1268                 return -EIO;
1269
1270         /* Lock both files against IO */
1271         lock_two_nondirectories(inode_in, inode_out);
1272         if (same_inode)
1273                 xfs_ilock(src, XFS_MMAPLOCK_EXCL);
1274         else
1275                 xfs_lock_two_inodes(src, dest, XFS_MMAPLOCK_EXCL);
1276
1277         /* Check file eligibility and prepare for block sharing. */
1278         ret = -EINVAL;
1279         /* Don't reflink realtime inodes */
1280         if (XFS_IS_REALTIME_INODE(src) || XFS_IS_REALTIME_INODE(dest))
1281                 goto out_unlock;
1282
1283         /* Don't share DAX file data for now. */
1284         if (IS_DAX(inode_in) || IS_DAX(inode_out))
1285                 goto out_unlock;
1286
1287         ret = vfs_clone_file_prep_inodes(inode_in, pos_in, inode_out, pos_out,
1288                         &len, is_dedupe);
1289         if (ret <= 0)
1290                 goto out_unlock;
1291
1292         trace_xfs_reflink_remap_range(src, pos_in, len, dest, pos_out);
1293
1294         /* Set flags and remap blocks. */
1295         ret = xfs_reflink_set_inode_flag(src, dest);
1296         if (ret)
1297                 goto out_unlock;
1298
1299         dfsbno = XFS_B_TO_FSBT(mp, pos_out);
1300         sfsbno = XFS_B_TO_FSBT(mp, pos_in);
1301         fsblen = XFS_B_TO_FSB(mp, len);
1302         ret = xfs_reflink_remap_blocks(src, sfsbno, dest, dfsbno, fsblen,
1303                         pos_out + len);
1304         if (ret)
1305                 goto out_unlock;
1306
1307         /* Zap any page cache for the destination file's range. */
1308         truncate_inode_pages_range(&inode_out->i_data, pos_out,
1309                                    PAGE_ALIGN(pos_out + len) - 1);
1310
1311         /*
1312          * Carry the cowextsize hint from src to dest if we're sharing the
1313          * entire source file to the entire destination file, the source file
1314          * has a cowextsize hint, and the destination file does not.
1315          */
1316         cowextsize = 0;
1317         if (pos_in == 0 && len == i_size_read(inode_in) &&
1318             (src->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) &&
1319             pos_out == 0 && len >= i_size_read(inode_out) &&
1320             !(dest->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1321                 cowextsize = src->i_d.di_cowextsize;
1322
1323         ret = xfs_reflink_update_dest(dest, pos_out + len, cowextsize,
1324                         is_dedupe);
1325
1326 out_unlock:
1327         xfs_iunlock(src, XFS_MMAPLOCK_EXCL);
1328         if (!same_inode)
1329                 xfs_iunlock(dest, XFS_MMAPLOCK_EXCL);
1330         unlock_two_nondirectories(inode_in, inode_out);
1331         if (ret)
1332                 trace_xfs_reflink_remap_range_error(dest, ret, _RET_IP_);
1333         return ret;
1334 }
1335
1336 /*
1337  * The user wants to preemptively CoW all shared blocks in this file,
1338  * which enables us to turn off the reflink flag.  Iterate all
1339  * extents which are not prealloc/delalloc to see which ranges are
1340  * mentioned in the refcount tree, then read those blocks into the
1341  * pagecache, dirty them, fsync them back out, and then we can update
1342  * the inode flag.  What happens if we run out of memory? :)
1343  */
1344 STATIC int
1345 xfs_reflink_dirty_extents(
1346         struct xfs_inode        *ip,
1347         xfs_fileoff_t           fbno,
1348         xfs_filblks_t           end,
1349         xfs_off_t               isize)
1350 {
1351         struct xfs_mount        *mp = ip->i_mount;
1352         xfs_agnumber_t          agno;
1353         xfs_agblock_t           agbno;
1354         xfs_extlen_t            aglen;
1355         xfs_agblock_t           rbno;
1356         xfs_extlen_t            rlen;
1357         xfs_off_t               fpos;
1358         xfs_off_t               flen;
1359         struct xfs_bmbt_irec    map[2];
1360         int                     nmaps;
1361         int                     error = 0;
1362
1363         while (end - fbno > 0) {
1364                 nmaps = 1;
1365                 /*
1366                  * Look for extents in the file.  Skip holes, delalloc, or
1367                  * unwritten extents; they can't be reflinked.
1368                  */
1369                 error = xfs_bmapi_read(ip, fbno, end - fbno, map, &nmaps, 0);
1370                 if (error)
1371                         goto out;
1372                 if (nmaps == 0)
1373                         break;
1374                 if (!xfs_bmap_is_real_extent(&map[0]))
1375                         goto next;
1376
1377                 map[1] = map[0];
1378                 while (map[1].br_blockcount) {
1379                         agno = XFS_FSB_TO_AGNO(mp, map[1].br_startblock);
1380                         agbno = XFS_FSB_TO_AGBNO(mp, map[1].br_startblock);
1381                         aglen = map[1].br_blockcount;
1382
1383                         error = xfs_reflink_find_shared(mp, NULL, agno, agbno,
1384                                         aglen, &rbno, &rlen, true);
1385                         if (error)
1386                                 goto out;
1387                         if (rbno == NULLAGBLOCK)
1388                                 break;
1389
1390                         /* Dirty the pages */
1391                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1392                         fpos = XFS_FSB_TO_B(mp, map[1].br_startoff +
1393                                         (rbno - agbno));
1394                         flen = XFS_FSB_TO_B(mp, rlen);
1395                         if (fpos + flen > isize)
1396                                 flen = isize - fpos;
1397                         error = iomap_file_dirty(VFS_I(ip), fpos, flen,
1398                                         &xfs_iomap_ops);
1399                         xfs_ilock(ip, XFS_ILOCK_EXCL);
1400                         if (error)
1401                                 goto out;
1402
1403                         map[1].br_blockcount -= (rbno - agbno + rlen);
1404                         map[1].br_startoff += (rbno - agbno + rlen);
1405                         map[1].br_startblock += (rbno - agbno + rlen);
1406                 }
1407
1408 next:
1409                 fbno = map[0].br_startoff + map[0].br_blockcount;
1410         }
1411 out:
1412         return error;
1413 }
1414
1415 /* Does this inode need the reflink flag? */
1416 int
1417 xfs_reflink_inode_has_shared_extents(
1418         struct xfs_trans                *tp,
1419         struct xfs_inode                *ip,
1420         bool                            *has_shared)
1421 {
1422         struct xfs_bmbt_irec            got;
1423         struct xfs_mount                *mp = ip->i_mount;
1424         struct xfs_ifork                *ifp;
1425         xfs_agnumber_t                  agno;
1426         xfs_agblock_t                   agbno;
1427         xfs_extlen_t                    aglen;
1428         xfs_agblock_t                   rbno;
1429         xfs_extlen_t                    rlen;
1430         struct xfs_iext_cursor          icur;
1431         bool                            found;
1432         int                             error;
1433
1434         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1435         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1436                 error = xfs_iread_extents(tp, ip, XFS_DATA_FORK);
1437                 if (error)
1438                         return error;
1439         }
1440
1441         *has_shared = false;
1442         found = xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got);
1443         while (found) {
1444                 if (isnullstartblock(got.br_startblock) ||
1445                     got.br_state != XFS_EXT_NORM)
1446                         goto next;
1447                 agno = XFS_FSB_TO_AGNO(mp, got.br_startblock);
1448                 agbno = XFS_FSB_TO_AGBNO(mp, got.br_startblock);
1449                 aglen = got.br_blockcount;
1450
1451                 error = xfs_reflink_find_shared(mp, tp, agno, agbno, aglen,
1452                                 &rbno, &rlen, false);
1453                 if (error)
1454                         return error;
1455                 /* Is there still a shared block here? */
1456                 if (rbno != NULLAGBLOCK) {
1457                         *has_shared = true;
1458                         return 0;
1459                 }
1460 next:
1461                 found = xfs_iext_next_extent(ifp, &icur, &got);
1462         }
1463
1464         return 0;
1465 }
1466
1467 /* Clear the inode reflink flag if there are no shared extents. */
1468 int
1469 xfs_reflink_clear_inode_flag(
1470         struct xfs_inode        *ip,
1471         struct xfs_trans        **tpp)
1472 {
1473         bool                    needs_flag;
1474         int                     error = 0;
1475
1476         ASSERT(xfs_is_reflink_inode(ip));
1477
1478         error = xfs_reflink_inode_has_shared_extents(*tpp, ip, &needs_flag);
1479         if (error || needs_flag)
1480                 return error;
1481
1482         /*
1483          * We didn't find any shared blocks so turn off the reflink flag.
1484          * First, get rid of any leftover CoW mappings.
1485          */
1486         error = xfs_reflink_cancel_cow_blocks(ip, tpp, 0, NULLFILEOFF, true);
1487         if (error)
1488                 return error;
1489
1490         /* Clear the inode flag. */
1491         trace_xfs_reflink_unset_inode_flag(ip);
1492         ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1493         xfs_inode_clear_cowblocks_tag(ip);
1494         xfs_trans_ijoin(*tpp, ip, 0);
1495         xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE);
1496
1497         return error;
1498 }
1499
1500 /*
1501  * Clear the inode reflink flag if there are no shared extents and the size
1502  * hasn't changed.
1503  */
1504 STATIC int
1505 xfs_reflink_try_clear_inode_flag(
1506         struct xfs_inode        *ip)
1507 {
1508         struct xfs_mount        *mp = ip->i_mount;
1509         struct xfs_trans        *tp;
1510         int                     error = 0;
1511
1512         /* Start a rolling transaction to remove the mappings */
1513         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1514         if (error)
1515                 return error;
1516
1517         xfs_ilock(ip, XFS_ILOCK_EXCL);
1518         xfs_trans_ijoin(tp, ip, 0);
1519
1520         error = xfs_reflink_clear_inode_flag(ip, &tp);
1521         if (error)
1522                 goto cancel;
1523
1524         error = xfs_trans_commit(tp);
1525         if (error)
1526                 goto out;
1527
1528         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1529         return 0;
1530 cancel:
1531         xfs_trans_cancel(tp);
1532 out:
1533         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1534         return error;
1535 }
1536
1537 /*
1538  * Pre-COW all shared blocks within a given byte range of a file and turn off
1539  * the reflink flag if we unshare all of the file's blocks.
1540  */
1541 int
1542 xfs_reflink_unshare(
1543         struct xfs_inode        *ip,
1544         xfs_off_t               offset,
1545         xfs_off_t               len)
1546 {
1547         struct xfs_mount        *mp = ip->i_mount;
1548         xfs_fileoff_t           fbno;
1549         xfs_filblks_t           end;
1550         xfs_off_t               isize;
1551         int                     error;
1552
1553         if (!xfs_is_reflink_inode(ip))
1554                 return 0;
1555
1556         trace_xfs_reflink_unshare(ip, offset, len);
1557
1558         inode_dio_wait(VFS_I(ip));
1559
1560         /* Try to CoW the selected ranges */
1561         xfs_ilock(ip, XFS_ILOCK_EXCL);
1562         fbno = XFS_B_TO_FSBT(mp, offset);
1563         isize = i_size_read(VFS_I(ip));
1564         end = XFS_B_TO_FSB(mp, offset + len);
1565         error = xfs_reflink_dirty_extents(ip, fbno, end, isize);
1566         if (error)
1567                 goto out_unlock;
1568         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1569
1570         /* Wait for the IO to finish */
1571         error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1572         if (error)
1573                 goto out;
1574
1575         /* Turn off the reflink flag if possible. */
1576         error = xfs_reflink_try_clear_inode_flag(ip);
1577         if (error)
1578                 goto out;
1579
1580         return 0;
1581
1582 out_unlock:
1583         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1584 out:
1585         trace_xfs_reflink_unshare_error(ip, error, _RET_IP_);
1586         return error;
1587 }