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