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