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