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