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