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