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