1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 4 * Copyright (c) 2012 Red Hat, Inc. 5 * All Rights Reserved. 6 */ 7#include "xfs.h" 8#include "xfs_fs.h" 9#include "xfs_shared.h" 10#include "xfs_format.h" 11#include "xfs_log_format.h" 12#include "xfs_trans_resv.h" 13#include "xfs_bit.h" 14#include "xfs_mount.h" 15#include "xfs_defer.h" 16#include "xfs_inode.h" 17#include "xfs_btree.h" 18#include "xfs_trans.h" 19#include "xfs_alloc.h" 20#include "xfs_bmap.h" 21#include "xfs_bmap_util.h" 22#include "xfs_bmap_btree.h" 23#include "xfs_rtalloc.h" 24#include "xfs_error.h" 25#include "xfs_quota.h" 26#include "xfs_trans_space.h" 27#include "xfs_trace.h" 28#include "xfs_icache.h" 29#include "xfs_iomap.h" 30#include "xfs_reflink.h" 31 32/* Kernel only BMAP related definitions and functions */ 33 34/* 35 * Convert the given file system block to a disk block. We have to treat it 36 * differently based on whether the file is a real time file or not, because the 37 * bmap code does. 38 */ 39xfs_daddr_t 40xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb) 41{ 42 if (XFS_IS_REALTIME_INODE(ip)) 43 return XFS_FSB_TO_BB(ip->i_mount, fsb); 44 return XFS_FSB_TO_DADDR(ip->i_mount, fsb); 45} 46 47/* 48 * Routine to zero an extent on disk allocated to the specific inode. 49 * 50 * The VFS functions take a linearised filesystem block offset, so we have to 51 * convert the sparse xfs fsb to the right format first. 52 * VFS types are real funky, too. 53 */ 54int 55xfs_zero_extent( 56 struct xfs_inode *ip, 57 xfs_fsblock_t start_fsb, 58 xfs_off_t count_fsb) 59{ 60 struct xfs_mount *mp = ip->i_mount; 61 struct xfs_buftarg *target = xfs_inode_buftarg(ip); 62 xfs_daddr_t sector = xfs_fsb_to_db(ip, start_fsb); 63 sector_t block = XFS_BB_TO_FSBT(mp, sector); 64 65 return blkdev_issue_zeroout(target->bt_bdev, 66 block << (mp->m_super->s_blocksize_bits - 9), 67 count_fsb << (mp->m_super->s_blocksize_bits - 9), 68 GFP_NOFS, 0); 69} 70 71#ifdef CONFIG_XFS_RT 72int 73xfs_bmap_rtalloc( 74 struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 75{ 76 int error; /* error return value */ 77 xfs_mount_t *mp; /* mount point structure */ 78 xfs_extlen_t prod = 0; /* product factor for allocators */ 79 xfs_extlen_t mod = 0; /* product factor for allocators */ 80 xfs_extlen_t ralen = 0; /* realtime allocation length */ 81 xfs_extlen_t align; /* minimum allocation alignment */ 82 xfs_rtblock_t rtb; 83 84 mp = ap->ip->i_mount; 85 align = xfs_get_extsz_hint(ap->ip); 86 prod = align / mp->m_sb.sb_rextsize; 87 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 88 align, 1, ap->eof, 0, 89 ap->conv, &ap->offset, &ap->length); 90 if (error) 91 return error; 92 ASSERT(ap->length); 93 ASSERT(ap->length % mp->m_sb.sb_rextsize == 0); 94 95 /* 96 * If the offset & length are not perfectly aligned 97 * then kill prod, it will just get us in trouble. 98 */ 99 div_u64_rem(ap->offset, align, &mod); 100 if (mod || ap->length % align) 101 prod = 1; 102 /* 103 * Set ralen to be the actual requested length in rtextents. 104 */ 105 ralen = ap->length / mp->m_sb.sb_rextsize; 106 /* 107 * If the old value was close enough to MAXEXTLEN that 108 * we rounded up to it, cut it back so it's valid again. 109 * Note that if it's a really large request (bigger than 110 * MAXEXTLEN), we don't hear about that number, and can't 111 * adjust the starting point to match it. 112 */ 113 if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN) 114 ralen = MAXEXTLEN / mp->m_sb.sb_rextsize; 115 116 /* 117 * Lock out modifications to both the RT bitmap and summary inodes 118 */ 119 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 120 xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL); 121 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 122 xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL); 123 124 /* 125 * If it's an allocation to an empty file at offset 0, 126 * pick an extent that will space things out in the rt area. 127 */ 128 if (ap->eof && ap->offset == 0) { 129 xfs_rtblock_t rtx; /* realtime extent no */ 130 131 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx); 132 if (error) 133 return error; 134 ap->blkno = rtx * mp->m_sb.sb_rextsize; 135 } else { 136 ap->blkno = 0; 137 } 138 139 xfs_bmap_adjacent(ap); 140 141 /* 142 * Realtime allocation, done through xfs_rtallocate_extent. 143 */ 144 do_div(ap->blkno, mp->m_sb.sb_rextsize); 145 rtb = ap->blkno; 146 ap->length = ralen; 147 error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, ap->length, 148 &ralen, ap->wasdel, prod, &rtb); 149 if (error) 150 return error; 151 152 ap->blkno = rtb; 153 if (ap->blkno != NULLFSBLOCK) { 154 ap->blkno *= mp->m_sb.sb_rextsize; 155 ralen *= mp->m_sb.sb_rextsize; 156 ap->length = ralen; 157 ap->ip->i_d.di_nblocks += ralen; 158 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 159 if (ap->wasdel) 160 ap->ip->i_delayed_blks -= ralen; 161 /* 162 * Adjust the disk quota also. This was reserved 163 * earlier. 164 */ 165 xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 166 ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT : 167 XFS_TRANS_DQ_RTBCOUNT, (long) ralen); 168 } else { 169 ap->length = 0; 170 } 171 return 0; 172} 173#endif /* CONFIG_XFS_RT */ 174 175/* 176 * Extent tree block counting routines. 177 */ 178 179/* 180 * Count leaf blocks given a range of extent records. Delayed allocation 181 * extents are not counted towards the totals. 182 */ 183xfs_extnum_t 184xfs_bmap_count_leaves( 185 struct xfs_ifork *ifp, 186 xfs_filblks_t *count) 187{ 188 struct xfs_iext_cursor icur; 189 struct xfs_bmbt_irec got; 190 xfs_extnum_t numrecs = 0; 191 192 for_each_xfs_iext(ifp, &icur, &got) { 193 if (!isnullstartblock(got.br_startblock)) { 194 *count += got.br_blockcount; 195 numrecs++; 196 } 197 } 198 199 return numrecs; 200} 201 202/* 203 * Count fsblocks of the given fork. Delayed allocation extents are 204 * not counted towards the totals. 205 */ 206int 207xfs_bmap_count_blocks( 208 struct xfs_trans *tp, 209 struct xfs_inode *ip, 210 int whichfork, 211 xfs_extnum_t *nextents, 212 xfs_filblks_t *count) 213{ 214 struct xfs_mount *mp = ip->i_mount; 215 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 216 struct xfs_btree_cur *cur; 217 xfs_extlen_t btblocks = 0; 218 int error; 219 220 *nextents = 0; 221 *count = 0; 222 223 if (!ifp) 224 return 0; 225 226 switch (ifp->if_format) { 227 case XFS_DINODE_FMT_BTREE: 228 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 229 error = xfs_iread_extents(tp, ip, whichfork); 230 if (error) 231 return error; 232 } 233 234 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 235 error = xfs_btree_count_blocks(cur, &btblocks); 236 xfs_btree_del_cursor(cur, error); 237 if (error) 238 return error; 239 240 /* 241 * xfs_btree_count_blocks includes the root block contained in 242 * the inode fork in @btblocks, so subtract one because we're 243 * only interested in allocated disk blocks. 244 */ 245 *count += btblocks - 1; 246 247 /* fall through */ 248 case XFS_DINODE_FMT_EXTENTS: 249 *nextents = xfs_bmap_count_leaves(ifp, count); 250 break; 251 } 252 253 return 0; 254} 255 256static int 257xfs_getbmap_report_one( 258 struct xfs_inode *ip, 259 struct getbmapx *bmv, 260 struct kgetbmap *out, 261 int64_t bmv_end, 262 struct xfs_bmbt_irec *got) 263{ 264 struct kgetbmap *p = out + bmv->bmv_entries; 265 bool shared = false; 266 int error; 267 268 error = xfs_reflink_trim_around_shared(ip, got, &shared); 269 if (error) 270 return error; 271 272 if (isnullstartblock(got->br_startblock) || 273 got->br_startblock == DELAYSTARTBLOCK) { 274 /* 275 * Delalloc extents that start beyond EOF can occur due to 276 * speculative EOF allocation when the delalloc extent is larger 277 * than the largest freespace extent at conversion time. These 278 * extents cannot be converted by data writeback, so can exist 279 * here even if we are not supposed to be finding delalloc 280 * extents. 281 */ 282 if (got->br_startoff < XFS_B_TO_FSB(ip->i_mount, XFS_ISIZE(ip))) 283 ASSERT((bmv->bmv_iflags & BMV_IF_DELALLOC) != 0); 284 285 p->bmv_oflags |= BMV_OF_DELALLOC; 286 p->bmv_block = -2; 287 } else { 288 p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock); 289 } 290 291 if (got->br_state == XFS_EXT_UNWRITTEN && 292 (bmv->bmv_iflags & BMV_IF_PREALLOC)) 293 p->bmv_oflags |= BMV_OF_PREALLOC; 294 295 if (shared) 296 p->bmv_oflags |= BMV_OF_SHARED; 297 298 p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff); 299 p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount); 300 301 bmv->bmv_offset = p->bmv_offset + p->bmv_length; 302 bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset); 303 bmv->bmv_entries++; 304 return 0; 305} 306 307static void 308xfs_getbmap_report_hole( 309 struct xfs_inode *ip, 310 struct getbmapx *bmv, 311 struct kgetbmap *out, 312 int64_t bmv_end, 313 xfs_fileoff_t bno, 314 xfs_fileoff_t end) 315{ 316 struct kgetbmap *p = out + bmv->bmv_entries; 317 318 if (bmv->bmv_iflags & BMV_IF_NO_HOLES) 319 return; 320 321 p->bmv_block = -1; 322 p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno); 323 p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno); 324 325 bmv->bmv_offset = p->bmv_offset + p->bmv_length; 326 bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset); 327 bmv->bmv_entries++; 328} 329 330static inline bool 331xfs_getbmap_full( 332 struct getbmapx *bmv) 333{ 334 return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1; 335} 336 337static bool 338xfs_getbmap_next_rec( 339 struct xfs_bmbt_irec *rec, 340 xfs_fileoff_t total_end) 341{ 342 xfs_fileoff_t end = rec->br_startoff + rec->br_blockcount; 343 344 if (end == total_end) 345 return false; 346 347 rec->br_startoff += rec->br_blockcount; 348 if (!isnullstartblock(rec->br_startblock) && 349 rec->br_startblock != DELAYSTARTBLOCK) 350 rec->br_startblock += rec->br_blockcount; 351 rec->br_blockcount = total_end - end; 352 return true; 353} 354 355/* 356 * Get inode's extents as described in bmv, and format for output. 357 * Calls formatter to fill the user's buffer until all extents 358 * are mapped, until the passed-in bmv->bmv_count slots have 359 * been filled, or until the formatter short-circuits the loop, 360 * if it is tracking filled-in extents on its own. 361 */ 362int /* error code */ 363xfs_getbmap( 364 struct xfs_inode *ip, 365 struct getbmapx *bmv, /* user bmap structure */ 366 struct kgetbmap *out) 367{ 368 struct xfs_mount *mp = ip->i_mount; 369 int iflags = bmv->bmv_iflags; 370 int whichfork, lock, error = 0; 371 int64_t bmv_end, max_len; 372 xfs_fileoff_t bno, first_bno; 373 struct xfs_ifork *ifp; 374 struct xfs_bmbt_irec got, rec; 375 xfs_filblks_t len; 376 struct xfs_iext_cursor icur; 377 378 if (bmv->bmv_iflags & ~BMV_IF_VALID) 379 return -EINVAL; 380#ifndef DEBUG 381 /* Only allow CoW fork queries if we're debugging. */ 382 if (iflags & BMV_IF_COWFORK) 383 return -EINVAL; 384#endif 385 if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK)) 386 return -EINVAL; 387 388 if (bmv->bmv_length < -1) 389 return -EINVAL; 390 bmv->bmv_entries = 0; 391 if (bmv->bmv_length == 0) 392 return 0; 393 394 if (iflags & BMV_IF_ATTRFORK) 395 whichfork = XFS_ATTR_FORK; 396 else if (iflags & BMV_IF_COWFORK) 397 whichfork = XFS_COW_FORK; 398 else 399 whichfork = XFS_DATA_FORK; 400 ifp = XFS_IFORK_PTR(ip, whichfork); 401 402 xfs_ilock(ip, XFS_IOLOCK_SHARED); 403 switch (whichfork) { 404 case XFS_ATTR_FORK: 405 if (!XFS_IFORK_Q(ip)) 406 goto out_unlock_iolock; 407 408 max_len = 1LL << 32; 409 lock = xfs_ilock_attr_map_shared(ip); 410 break; 411 case XFS_COW_FORK: 412 /* No CoW fork? Just return */ 413 if (!ifp) 414 goto out_unlock_iolock; 415 416 if (xfs_get_cowextsz_hint(ip)) 417 max_len = mp->m_super->s_maxbytes; 418 else 419 max_len = XFS_ISIZE(ip); 420 421 lock = XFS_ILOCK_SHARED; 422 xfs_ilock(ip, lock); 423 break; 424 case XFS_DATA_FORK: 425 if (!(iflags & BMV_IF_DELALLOC) && 426 (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size)) { 427 error = filemap_write_and_wait(VFS_I(ip)->i_mapping); 428 if (error) 429 goto out_unlock_iolock; 430 431 /* 432 * Even after flushing the inode, there can still be 433 * delalloc blocks on the inode beyond EOF due to 434 * speculative preallocation. These are not removed 435 * until the release function is called or the inode 436 * is inactivated. Hence we cannot assert here that 437 * ip->i_delayed_blks == 0. 438 */ 439 } 440 441 if (xfs_get_extsz_hint(ip) || 442 (ip->i_d.di_flags & 443 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))) 444 max_len = mp->m_super->s_maxbytes; 445 else 446 max_len = XFS_ISIZE(ip); 447 448 lock = xfs_ilock_data_map_shared(ip); 449 break; 450 } 451 452 switch (ifp->if_format) { 453 case XFS_DINODE_FMT_EXTENTS: 454 case XFS_DINODE_FMT_BTREE: 455 break; 456 case XFS_DINODE_FMT_LOCAL: 457 /* Local format inode forks report no extents. */ 458 goto out_unlock_ilock; 459 default: 460 error = -EINVAL; 461 goto out_unlock_ilock; 462 } 463 464 if (bmv->bmv_length == -1) { 465 max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len)); 466 bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset); 467 } 468 469 bmv_end = bmv->bmv_offset + bmv->bmv_length; 470 471 first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset); 472 len = XFS_BB_TO_FSB(mp, bmv->bmv_length); 473 474 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 475 error = xfs_iread_extents(NULL, ip, whichfork); 476 if (error) 477 goto out_unlock_ilock; 478 } 479 480 if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) { 481 /* 482 * Report a whole-file hole if the delalloc flag is set to 483 * stay compatible with the old implementation. 484 */ 485 if (iflags & BMV_IF_DELALLOC) 486 xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno, 487 XFS_B_TO_FSB(mp, XFS_ISIZE(ip))); 488 goto out_unlock_ilock; 489 } 490 491 while (!xfs_getbmap_full(bmv)) { 492 xfs_trim_extent(&got, first_bno, len); 493 494 /* 495 * Report an entry for a hole if this extent doesn't directly 496 * follow the previous one. 497 */ 498 if (got.br_startoff > bno) { 499 xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno, 500 got.br_startoff); 501 if (xfs_getbmap_full(bmv)) 502 break; 503 } 504 505 /* 506 * In order to report shared extents accurately, we report each 507 * distinct shared / unshared part of a single bmbt record with 508 * an individual getbmapx record. 509 */ 510 bno = got.br_startoff + got.br_blockcount; 511 rec = got; 512 do { 513 error = xfs_getbmap_report_one(ip, bmv, out, bmv_end, 514 &rec); 515 if (error || xfs_getbmap_full(bmv)) 516 goto out_unlock_ilock; 517 } while (xfs_getbmap_next_rec(&rec, bno)); 518 519 if (!xfs_iext_next_extent(ifp, &icur, &got)) { 520 xfs_fileoff_t end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip)); 521 522 out[bmv->bmv_entries - 1].bmv_oflags |= BMV_OF_LAST; 523 524 if (whichfork != XFS_ATTR_FORK && bno < end && 525 !xfs_getbmap_full(bmv)) { 526 xfs_getbmap_report_hole(ip, bmv, out, bmv_end, 527 bno, end); 528 } 529 break; 530 } 531 532 if (bno >= first_bno + len) 533 break; 534 } 535 536out_unlock_ilock: 537 xfs_iunlock(ip, lock); 538out_unlock_iolock: 539 xfs_iunlock(ip, XFS_IOLOCK_SHARED); 540 return error; 541} 542 543/* 544 * Dead simple method of punching delalyed allocation blocks from a range in 545 * the inode. This will always punch out both the start and end blocks, even 546 * if the ranges only partially overlap them, so it is up to the caller to 547 * ensure that partial blocks are not passed in. 548 */ 549int 550xfs_bmap_punch_delalloc_range( 551 struct xfs_inode *ip, 552 xfs_fileoff_t start_fsb, 553 xfs_fileoff_t length) 554{ 555 struct xfs_ifork *ifp = &ip->i_df; 556 xfs_fileoff_t end_fsb = start_fsb + length; 557 struct xfs_bmbt_irec got, del; 558 struct xfs_iext_cursor icur; 559 int error = 0; 560 561 ASSERT(ifp->if_flags & XFS_IFEXTENTS); 562 563 xfs_ilock(ip, XFS_ILOCK_EXCL); 564 if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got)) 565 goto out_unlock; 566 567 while (got.br_startoff + got.br_blockcount > start_fsb) { 568 del = got; 569 xfs_trim_extent(&del, start_fsb, length); 570 571 /* 572 * A delete can push the cursor forward. Step back to the 573 * previous extent on non-delalloc or extents outside the 574 * target range. 575 */ 576 if (!del.br_blockcount || 577 !isnullstartblock(del.br_startblock)) { 578 if (!xfs_iext_prev_extent(ifp, &icur, &got)) 579 break; 580 continue; 581 } 582 583 error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur, 584 &got, &del); 585 if (error || !xfs_iext_get_extent(ifp, &icur, &got)) 586 break; 587 } 588 589out_unlock: 590 xfs_iunlock(ip, XFS_ILOCK_EXCL); 591 return error; 592} 593 594/* 595 * Test whether it is appropriate to check an inode for and free post EOF 596 * blocks. The 'force' parameter determines whether we should also consider 597 * regular files that are marked preallocated or append-only. 598 */ 599bool 600xfs_can_free_eofblocks(struct xfs_inode *ip, bool force) 601{ 602 /* prealloc/delalloc exists only on regular files */ 603 if (!S_ISREG(VFS_I(ip)->i_mode)) 604 return false; 605 606 /* 607 * Zero sized files with no cached pages and delalloc blocks will not 608 * have speculative prealloc/delalloc blocks to remove. 609 */ 610 if (VFS_I(ip)->i_size == 0 && 611 VFS_I(ip)->i_mapping->nrpages == 0 && 612 ip->i_delayed_blks == 0) 613 return false; 614 615 /* If we haven't read in the extent list, then don't do it now. */ 616 if (!(ip->i_df.if_flags & XFS_IFEXTENTS)) 617 return false; 618 619 /* 620 * Do not free real preallocated or append-only files unless the file 621 * has delalloc blocks and we are forced to remove them. 622 */ 623 if (ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) 624 if (!force || ip->i_delayed_blks == 0) 625 return false; 626 627 return true; 628} 629 630/* 631 * This is called to free any blocks beyond eof. The caller must hold 632 * IOLOCK_EXCL unless we are in the inode reclaim path and have the only 633 * reference to the inode. 634 */ 635int 636xfs_free_eofblocks( 637 struct xfs_inode *ip) 638{ 639 struct xfs_trans *tp; 640 int error; 641 xfs_fileoff_t end_fsb; 642 xfs_fileoff_t last_fsb; 643 xfs_filblks_t map_len; 644 int nimaps; 645 struct xfs_bmbt_irec imap; 646 struct xfs_mount *mp = ip->i_mount; 647 648 /* 649 * Figure out if there are any blocks beyond the end 650 * of the file. If not, then there is nothing to do. 651 */ 652 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip)); 653 last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes); 654 if (last_fsb <= end_fsb) 655 return 0; 656 map_len = last_fsb - end_fsb; 657 658 nimaps = 1; 659 xfs_ilock(ip, XFS_ILOCK_SHARED); 660 error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0); 661 xfs_iunlock(ip, XFS_ILOCK_SHARED); 662 663 /* 664 * If there are blocks after the end of file, truncate the file to its 665 * current size to free them up. 666 */ 667 if (!error && (nimaps != 0) && 668 (imap.br_startblock != HOLESTARTBLOCK || 669 ip->i_delayed_blks)) { 670 /* 671 * Attach the dquots to the inode up front. 672 */ 673 error = xfs_qm_dqattach(ip); 674 if (error) 675 return error; 676 677 /* wait on dio to ensure i_size has settled */ 678 inode_dio_wait(VFS_I(ip)); 679 680 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, 681 &tp); 682 if (error) { 683 ASSERT(XFS_FORCED_SHUTDOWN(mp)); 684 return error; 685 } 686 687 xfs_ilock(ip, XFS_ILOCK_EXCL); 688 xfs_trans_ijoin(tp, ip, 0); 689 690 /* 691 * Do not update the on-disk file size. If we update the 692 * on-disk file size and then the system crashes before the 693 * contents of the file are flushed to disk then the files 694 * may be full of holes (ie NULL files bug). 695 */ 696 error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK, 697 XFS_ISIZE(ip), XFS_BMAPI_NODISCARD); 698 if (error) { 699 /* 700 * If we get an error at this point we simply don't 701 * bother truncating the file. 702 */ 703 xfs_trans_cancel(tp); 704 } else { 705 error = xfs_trans_commit(tp); 706 if (!error) 707 xfs_inode_clear_eofblocks_tag(ip); 708 } 709 710 xfs_iunlock(ip, XFS_ILOCK_EXCL); 711 } 712 return error; 713} 714 715int 716xfs_alloc_file_space( 717 struct xfs_inode *ip, 718 xfs_off_t offset, 719 xfs_off_t len, 720 int alloc_type) 721{ 722 xfs_mount_t *mp = ip->i_mount; 723 xfs_off_t count; 724 xfs_filblks_t allocated_fsb; 725 xfs_filblks_t allocatesize_fsb; 726 xfs_extlen_t extsz, temp; 727 xfs_fileoff_t startoffset_fsb; 728 xfs_fileoff_t endoffset_fsb; 729 int nimaps; 730 int quota_flag; 731 int rt; 732 xfs_trans_t *tp; 733 xfs_bmbt_irec_t imaps[1], *imapp; 734 uint qblocks, resblks, resrtextents; 735 int error; 736 737 trace_xfs_alloc_file_space(ip); 738 739 if (XFS_FORCED_SHUTDOWN(mp)) 740 return -EIO; 741 742 error = xfs_qm_dqattach(ip); 743 if (error) 744 return error; 745 746 if (len <= 0) 747 return -EINVAL; 748 749 rt = XFS_IS_REALTIME_INODE(ip); 750 extsz = xfs_get_extsz_hint(ip); 751 752 count = len; 753 imapp = &imaps[0]; 754 nimaps = 1; 755 startoffset_fsb = XFS_B_TO_FSBT(mp, offset); 756 endoffset_fsb = XFS_B_TO_FSB(mp, offset + count); 757 allocatesize_fsb = endoffset_fsb - startoffset_fsb; 758 759 /* 760 * Allocate file space until done or until there is an error 761 */ 762 while (allocatesize_fsb && !error) { 763 xfs_fileoff_t s, e; 764 765 /* 766 * Determine space reservations for data/realtime. 767 */ 768 if (unlikely(extsz)) { 769 s = startoffset_fsb; 770 do_div(s, extsz); 771 s *= extsz; 772 e = startoffset_fsb + allocatesize_fsb; 773 div_u64_rem(startoffset_fsb, extsz, &temp); 774 if (temp) 775 e += temp; 776 div_u64_rem(e, extsz, &temp); 777 if (temp) 778 e += extsz - temp; 779 } else { 780 s = 0; 781 e = allocatesize_fsb; 782 } 783 784 /* 785 * The transaction reservation is limited to a 32-bit block 786 * count, hence we need to limit the number of blocks we are 787 * trying to reserve to avoid an overflow. We can't allocate 788 * more than @nimaps extents, and an extent is limited on disk 789 * to MAXEXTLEN (21 bits), so use that to enforce the limit. 790 */ 791 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps)); 792 if (unlikely(rt)) { 793 resrtextents = qblocks = resblks; 794 resrtextents /= mp->m_sb.sb_rextsize; 795 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0); 796 quota_flag = XFS_QMOPT_RES_RTBLKS; 797 } else { 798 resrtextents = 0; 799 resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks); 800 quota_flag = XFS_QMOPT_RES_REGBLKS; 801 } 802 803 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 804 resrtextents, 0, &tp); 805 806 /* 807 * Check for running out of space 808 */ 809 if (error) { 810 /* 811 * Free the transaction structure. 812 */ 813 ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp)); 814 break; 815 } 816 xfs_ilock(ip, XFS_ILOCK_EXCL); 817 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 818 0, quota_flag); 819 if (error) 820 goto error1; 821 822 xfs_trans_ijoin(tp, ip, 0); 823 824 error = xfs_bmapi_write(tp, ip, startoffset_fsb, 825 allocatesize_fsb, alloc_type, 0, imapp, 826 &nimaps); 827 if (error) 828 goto error0; 829 830 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC; 831 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 832 833 error = xfs_trans_commit(tp); 834 xfs_iunlock(ip, XFS_ILOCK_EXCL); 835 if (error) 836 break; 837 838 allocated_fsb = imapp->br_blockcount; 839 840 if (nimaps == 0) { 841 error = -ENOSPC; 842 break; 843 } 844 845 startoffset_fsb += allocated_fsb; 846 allocatesize_fsb -= allocated_fsb; 847 } 848 849 return error; 850 851error0: /* unlock inode, unreserve quota blocks, cancel trans */ 852 xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag); 853 854error1: /* Just cancel transaction */ 855 xfs_trans_cancel(tp); 856 xfs_iunlock(ip, XFS_ILOCK_EXCL); 857 return error; 858} 859 860static int 861xfs_unmap_extent( 862 struct xfs_inode *ip, 863 xfs_fileoff_t startoffset_fsb, 864 xfs_filblks_t len_fsb, 865 int *done) 866{ 867 struct xfs_mount *mp = ip->i_mount; 868 struct xfs_trans *tp; 869 uint resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0); 870 int error; 871 872 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp); 873 if (error) { 874 ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp)); 875 return error; 876 } 877 878 xfs_ilock(ip, XFS_ILOCK_EXCL); 879 error = xfs_trans_reserve_quota(tp, mp, ip->i_udquot, ip->i_gdquot, 880 ip->i_pdquot, resblks, 0, XFS_QMOPT_RES_REGBLKS); 881 if (error) 882 goto out_trans_cancel; 883 884 xfs_trans_ijoin(tp, ip, 0); 885 886 error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done); 887 if (error) 888 goto out_trans_cancel; 889 890 error = xfs_trans_commit(tp); 891out_unlock: 892 xfs_iunlock(ip, XFS_ILOCK_EXCL); 893 return error; 894 895out_trans_cancel: 896 xfs_trans_cancel(tp); 897 goto out_unlock; 898} 899 900/* Caller must first wait for the completion of any pending DIOs if required. */ 901int 902xfs_flush_unmap_range( 903 struct xfs_inode *ip, 904 xfs_off_t offset, 905 xfs_off_t len) 906{ 907 struct xfs_mount *mp = ip->i_mount; 908 struct inode *inode = VFS_I(ip); 909 xfs_off_t rounding, start, end; 910 int error; 911 912 rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_SIZE); 913 start = round_down(offset, rounding); 914 end = round_up(offset + len, rounding) - 1; 915 916 error = filemap_write_and_wait_range(inode->i_mapping, start, end); 917 if (error) 918 return error; 919 truncate_pagecache_range(inode, start, end); 920 return 0; 921} 922 923int 924xfs_free_file_space( 925 struct xfs_inode *ip, 926 xfs_off_t offset, 927 xfs_off_t len) 928{ 929 struct xfs_mount *mp = ip->i_mount; 930 xfs_fileoff_t startoffset_fsb; 931 xfs_fileoff_t endoffset_fsb; 932 int done = 0, error; 933 934 trace_xfs_free_file_space(ip); 935 936 error = xfs_qm_dqattach(ip); 937 if (error) 938 return error; 939 940 if (len <= 0) /* if nothing being freed */ 941 return 0; 942 943 startoffset_fsb = XFS_B_TO_FSB(mp, offset); 944 endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len); 945 946 /* We can only free complete realtime extents. */ 947 if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) { 948 startoffset_fsb = roundup_64(startoffset_fsb, 949 mp->m_sb.sb_rextsize); 950 endoffset_fsb = rounddown_64(endoffset_fsb, 951 mp->m_sb.sb_rextsize); 952 } 953 954 /* 955 * Need to zero the stuff we're not freeing, on disk. 956 */ 957 if (endoffset_fsb > startoffset_fsb) { 958 while (!done) { 959 error = xfs_unmap_extent(ip, startoffset_fsb, 960 endoffset_fsb - startoffset_fsb, &done); 961 if (error) 962 return error; 963 } 964 } 965 966 /* 967 * Now that we've unmap all full blocks we'll have to zero out any 968 * partial block at the beginning and/or end. iomap_zero_range is smart 969 * enough to skip any holes, including those we just created, but we 970 * must take care not to zero beyond EOF and enlarge i_size. 971 */ 972 if (offset >= XFS_ISIZE(ip)) 973 return 0; 974 if (offset + len > XFS_ISIZE(ip)) 975 len = XFS_ISIZE(ip) - offset; 976 error = iomap_zero_range(VFS_I(ip), offset, len, NULL, 977 &xfs_buffered_write_iomap_ops); 978 if (error) 979 return error; 980 981 /* 982 * If we zeroed right up to EOF and EOF straddles a page boundary we 983 * must make sure that the post-EOF area is also zeroed because the 984 * page could be mmap'd and iomap_zero_range doesn't do that for us. 985 * Writeback of the eof page will do this, albeit clumsily. 986 */ 987 if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) { 988 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping, 989 round_down(offset + len, PAGE_SIZE), LLONG_MAX); 990 } 991 992 return error; 993} 994 995static int 996xfs_prepare_shift( 997 struct xfs_inode *ip, 998 loff_t offset) 999{ 1000 struct xfs_mount *mp = ip->i_mount; 1001 int error; 1002 1003 /* 1004 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation 1005 * into the accessible region of the file. 1006 */ 1007 if (xfs_can_free_eofblocks(ip, true)) { 1008 error = xfs_free_eofblocks(ip); 1009 if (error) 1010 return error; 1011 } 1012 1013 /* 1014 * Shift operations must stabilize the start block offset boundary along 1015 * with the full range of the operation. If we don't, a COW writeback 1016 * completion could race with an insert, front merge with the start 1017 * extent (after split) during the shift and corrupt the file. Start 1018 * with the block just prior to the start to stabilize the boundary. 1019 */ 1020 offset = round_down(offset, 1 << mp->m_sb.sb_blocklog); 1021 if (offset) 1022 offset -= (1 << mp->m_sb.sb_blocklog); 1023 1024 /* 1025 * Writeback and invalidate cache for the remainder of the file as we're 1026 * about to shift down every extent from offset to EOF. 1027 */ 1028 error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip)); 1029 if (error) 1030 return error; 1031 1032 /* 1033 * Clean out anything hanging around in the cow fork now that 1034 * we've flushed all the dirty data out to disk to avoid having 1035 * CoW extents at the wrong offsets. 1036 */ 1037 if (xfs_inode_has_cow_data(ip)) { 1038 error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF, 1039 true); 1040 if (error) 1041 return error; 1042 } 1043 1044 return 0; 1045} 1046 1047/* 1048 * xfs_collapse_file_space() 1049 * This routine frees disk space and shift extent for the given file. 1050 * The first thing we do is to free data blocks in the specified range 1051 * by calling xfs_free_file_space(). It would also sync dirty data 1052 * and invalidate page cache over the region on which collapse range 1053 * is working. And Shift extent records to the left to cover a hole. 1054 * RETURNS: 1055 * 0 on success 1056 * errno on error 1057 * 1058 */ 1059int 1060xfs_collapse_file_space( 1061 struct xfs_inode *ip, 1062 xfs_off_t offset, 1063 xfs_off_t len) 1064{ 1065 struct xfs_mount *mp = ip->i_mount; 1066 struct xfs_trans *tp; 1067 int error; 1068 xfs_fileoff_t next_fsb = XFS_B_TO_FSB(mp, offset + len); 1069 xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len); 1070 bool done = false; 1071 1072 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 1073 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL)); 1074 1075 trace_xfs_collapse_file_space(ip); 1076 1077 error = xfs_free_file_space(ip, offset, len); 1078 if (error) 1079 return error; 1080 1081 error = xfs_prepare_shift(ip, offset); 1082 if (error) 1083 return error; 1084 1085 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp); 1086 if (error) 1087 return error; 1088 1089 xfs_ilock(ip, XFS_ILOCK_EXCL); 1090 xfs_trans_ijoin(tp, ip, 0); 1091 1092 while (!done) { 1093 error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb, 1094 &done); 1095 if (error) 1096 goto out_trans_cancel; 1097 if (done) 1098 break; 1099 1100 /* finish any deferred frees and roll the transaction */ 1101 error = xfs_defer_finish(&tp); 1102 if (error) 1103 goto out_trans_cancel; 1104 } 1105 1106 error = xfs_trans_commit(tp); 1107 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1108 return error; 1109 1110out_trans_cancel: 1111 xfs_trans_cancel(tp); 1112 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1113 return error; 1114} 1115 1116/* 1117 * xfs_insert_file_space() 1118 * This routine create hole space by shifting extents for the given file. 1119 * The first thing we do is to sync dirty data and invalidate page cache 1120 * over the region on which insert range is working. And split an extent 1121 * to two extents at given offset by calling xfs_bmap_split_extent. 1122 * And shift all extent records which are laying between [offset, 1123 * last allocated extent] to the right to reserve hole range. 1124 * RETURNS: 1125 * 0 on success 1126 * errno on error 1127 */ 1128int 1129xfs_insert_file_space( 1130 struct xfs_inode *ip, 1131 loff_t offset, 1132 loff_t len) 1133{ 1134 struct xfs_mount *mp = ip->i_mount; 1135 struct xfs_trans *tp; 1136 int error; 1137 xfs_fileoff_t stop_fsb = XFS_B_TO_FSB(mp, offset); 1138 xfs_fileoff_t next_fsb = NULLFSBLOCK; 1139 xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len); 1140 bool done = false; 1141 1142 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 1143 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL)); 1144 1145 trace_xfs_insert_file_space(ip); 1146 1147 error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb); 1148 if (error) 1149 return error; 1150 1151 error = xfs_prepare_shift(ip, offset); 1152 if (error) 1153 return error; 1154 1155 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 1156 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 1157 if (error) 1158 return error; 1159 1160 xfs_ilock(ip, XFS_ILOCK_EXCL); 1161 xfs_trans_ijoin(tp, ip, 0); 1162 1163 /* 1164 * The extent shifting code works on extent granularity. So, if stop_fsb 1165 * is not the starting block of extent, we need to split the extent at 1166 * stop_fsb. 1167 */ 1168 error = xfs_bmap_split_extent(tp, ip, stop_fsb); 1169 if (error) 1170 goto out_trans_cancel; 1171 1172 do { 1173 error = xfs_defer_finish(&tp); 1174 if (error) 1175 goto out_trans_cancel; 1176 1177 error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb, 1178 &done, stop_fsb); 1179 if (error) 1180 goto out_trans_cancel; 1181 } while (!done); 1182 1183 error = xfs_trans_commit(tp); 1184 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1185 return error; 1186 1187out_trans_cancel: 1188 xfs_trans_cancel(tp); 1189 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1190 return error; 1191} 1192 1193/* 1194 * We need to check that the format of the data fork in the temporary inode is 1195 * valid for the target inode before doing the swap. This is not a problem with 1196 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized 1197 * data fork depending on the space the attribute fork is taking so we can get 1198 * invalid formats on the target inode. 1199 * 1200 * E.g. target has space for 7 extents in extent format, temp inode only has 1201 * space for 6. If we defragment down to 7 extents, then the tmp format is a 1202 * btree, but when swapped it needs to be in extent format. Hence we can't just 1203 * blindly swap data forks on attr2 filesystems. 1204 * 1205 * Note that we check the swap in both directions so that we don't end up with 1206 * a corrupt temporary inode, either. 1207 * 1208 * Note that fixing the way xfs_fsr sets up the attribute fork in the source 1209 * inode will prevent this situation from occurring, so all we do here is 1210 * reject and log the attempt. basically we are putting the responsibility on 1211 * userspace to get this right. 1212 */ 1213static int 1214xfs_swap_extents_check_format( 1215 struct xfs_inode *ip, /* target inode */ 1216 struct xfs_inode *tip) /* tmp inode */ 1217{ 1218 struct xfs_ifork *ifp = &ip->i_df; 1219 struct xfs_ifork *tifp = &tip->i_df; 1220 1221 /* User/group/project quota ids must match if quotas are enforced. */ 1222 if (XFS_IS_QUOTA_ON(ip->i_mount) && 1223 (!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) || 1224 !gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) || 1225 ip->i_d.di_projid != tip->i_d.di_projid)) 1226 return -EINVAL; 1227 1228 /* Should never get a local format */ 1229 if (ifp->if_format == XFS_DINODE_FMT_LOCAL || 1230 tifp->if_format == XFS_DINODE_FMT_LOCAL) 1231 return -EINVAL; 1232 1233 /* 1234 * if the target inode has less extents that then temporary inode then 1235 * why did userspace call us? 1236 */ 1237 if (ifp->if_nextents < tifp->if_nextents) 1238 return -EINVAL; 1239 1240 /* 1241 * If we have to use the (expensive) rmap swap method, we can 1242 * handle any number of extents and any format. 1243 */ 1244 if (xfs_sb_version_hasrmapbt(&ip->i_mount->m_sb)) 1245 return 0; 1246 1247 /* 1248 * if the target inode is in extent form and the temp inode is in btree 1249 * form then we will end up with the target inode in the wrong format 1250 * as we already know there are less extents in the temp inode. 1251 */ 1252 if (ifp->if_format == XFS_DINODE_FMT_EXTENTS && 1253 tifp->if_format == XFS_DINODE_FMT_BTREE) 1254 return -EINVAL; 1255 1256 /* Check temp in extent form to max in target */ 1257 if (tifp->if_format == XFS_DINODE_FMT_EXTENTS && 1258 tifp->if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK)) 1259 return -EINVAL; 1260 1261 /* Check target in extent form to max in temp */ 1262 if (ifp->if_format == XFS_DINODE_FMT_EXTENTS && 1263 ifp->if_nextents > XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK)) 1264 return -EINVAL; 1265 1266 /* 1267 * If we are in a btree format, check that the temp root block will fit 1268 * in the target and that it has enough extents to be in btree format 1269 * in the target. 1270 * 1271 * Note that we have to be careful to allow btree->extent conversions 1272 * (a common defrag case) which will occur when the temp inode is in 1273 * extent format... 1274 */ 1275 if (tifp->if_format == XFS_DINODE_FMT_BTREE) { 1276 if (XFS_IFORK_Q(ip) && 1277 XFS_BMAP_BMDR_SPACE(tifp->if_broot) > XFS_IFORK_BOFF(ip)) 1278 return -EINVAL; 1279 if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK)) 1280 return -EINVAL; 1281 } 1282 1283 /* Reciprocal target->temp btree format checks */ 1284 if (ifp->if_format == XFS_DINODE_FMT_BTREE) { 1285 if (XFS_IFORK_Q(tip) && 1286 XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip)) 1287 return -EINVAL; 1288 if (ifp->if_nextents <= XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK)) 1289 return -EINVAL; 1290 } 1291 1292 return 0; 1293} 1294 1295static int 1296xfs_swap_extent_flush( 1297 struct xfs_inode *ip) 1298{ 1299 int error; 1300 1301 error = filemap_write_and_wait(VFS_I(ip)->i_mapping); 1302 if (error) 1303 return error; 1304 truncate_pagecache_range(VFS_I(ip), 0, -1); 1305 1306 /* Verify O_DIRECT for ftmp */ 1307 if (VFS_I(ip)->i_mapping->nrpages) 1308 return -EINVAL; 1309 return 0; 1310} 1311 1312/* 1313 * Move extents from one file to another, when rmap is enabled. 1314 */ 1315STATIC int 1316xfs_swap_extent_rmap( 1317 struct xfs_trans **tpp, 1318 struct xfs_inode *ip, 1319 struct xfs_inode *tip) 1320{ 1321 struct xfs_trans *tp = *tpp; 1322 struct xfs_bmbt_irec irec; 1323 struct xfs_bmbt_irec uirec; 1324 struct xfs_bmbt_irec tirec; 1325 xfs_fileoff_t offset_fsb; 1326 xfs_fileoff_t end_fsb; 1327 xfs_filblks_t count_fsb; 1328 int error; 1329 xfs_filblks_t ilen; 1330 xfs_filblks_t rlen; 1331 int nimaps; 1332 uint64_t tip_flags2; 1333 1334 /* 1335 * If the source file has shared blocks, we must flag the donor 1336 * file as having shared blocks so that we get the shared-block 1337 * rmap functions when we go to fix up the rmaps. The flags 1338 * will be switch for reals later. 1339 */ 1340 tip_flags2 = tip->i_d.di_flags2; 1341 if (ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK) 1342 tip->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK; 1343 1344 offset_fsb = 0; 1345 end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip))); 1346 count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb); 1347 1348 while (count_fsb) { 1349 /* Read extent from the donor file */ 1350 nimaps = 1; 1351 error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec, 1352 &nimaps, 0); 1353 if (error) 1354 goto out; 1355 ASSERT(nimaps == 1); 1356 ASSERT(tirec.br_startblock != DELAYSTARTBLOCK); 1357 1358 trace_xfs_swap_extent_rmap_remap(tip, &tirec); 1359 ilen = tirec.br_blockcount; 1360 1361 /* Unmap the old blocks in the source file. */ 1362 while (tirec.br_blockcount) { 1363 ASSERT(tp->t_firstblock == NULLFSBLOCK); 1364 trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec); 1365 1366 /* Read extent from the source file */ 1367 nimaps = 1; 1368 error = xfs_bmapi_read(ip, tirec.br_startoff, 1369 tirec.br_blockcount, &irec, 1370 &nimaps, 0); 1371 if (error) 1372 goto out; 1373 ASSERT(nimaps == 1); 1374 ASSERT(tirec.br_startoff == irec.br_startoff); 1375 trace_xfs_swap_extent_rmap_remap_piece(ip, &irec); 1376 1377 /* Trim the extent. */ 1378 uirec = tirec; 1379 uirec.br_blockcount = rlen = min_t(xfs_filblks_t, 1380 tirec.br_blockcount, 1381 irec.br_blockcount); 1382 trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec); 1383 1384 /* Remove the mapping from the donor file. */ 1385 xfs_bmap_unmap_extent(tp, tip, &uirec); 1386 1387 /* Remove the mapping from the source file. */ 1388 xfs_bmap_unmap_extent(tp, ip, &irec); 1389 1390 /* Map the donor file's blocks into the source file. */ 1391 xfs_bmap_map_extent(tp, ip, &uirec); 1392 1393 /* Map the source file's blocks into the donor file. */ 1394 xfs_bmap_map_extent(tp, tip, &irec); 1395 1396 error = xfs_defer_finish(tpp); 1397 tp = *tpp; 1398 if (error) 1399 goto out; 1400 1401 tirec.br_startoff += rlen; 1402 if (tirec.br_startblock != HOLESTARTBLOCK && 1403 tirec.br_startblock != DELAYSTARTBLOCK) 1404 tirec.br_startblock += rlen; 1405 tirec.br_blockcount -= rlen; 1406 } 1407 1408 /* Roll on... */ 1409 count_fsb -= ilen; 1410 offset_fsb += ilen; 1411 } 1412 1413 tip->i_d.di_flags2 = tip_flags2; 1414 return 0; 1415 1416out: 1417 trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_); 1418 tip->i_d.di_flags2 = tip_flags2; 1419 return error; 1420} 1421 1422/* Swap the extents of two files by swapping data forks. */ 1423STATIC int 1424xfs_swap_extent_forks( 1425 struct xfs_trans *tp, 1426 struct xfs_inode *ip, 1427 struct xfs_inode *tip, 1428 int *src_log_flags, 1429 int *target_log_flags) 1430{ 1431 xfs_filblks_t aforkblks = 0; 1432 xfs_filblks_t taforkblks = 0; 1433 xfs_extnum_t junk; 1434 uint64_t tmp; 1435 int error; 1436 1437 /* 1438 * Count the number of extended attribute blocks 1439 */ 1440 if (XFS_IFORK_Q(ip) && ip->i_afp->if_nextents > 0 && 1441 ip->i_afp->if_format != XFS_DINODE_FMT_LOCAL) { 1442 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk, 1443 &aforkblks); 1444 if (error) 1445 return error; 1446 } 1447 if (XFS_IFORK_Q(tip) && tip->i_afp->if_nextents > 0 && 1448 tip->i_afp->if_format != XFS_DINODE_FMT_LOCAL) { 1449 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, &junk, 1450 &taforkblks); 1451 if (error) 1452 return error; 1453 } 1454 1455 /* 1456 * Btree format (v3) inodes have the inode number stamped in the bmbt 1457 * block headers. We can't start changing the bmbt blocks until the 1458 * inode owner change is logged so recovery does the right thing in the 1459 * event of a crash. Set the owner change log flags now and leave the 1460 * bmbt scan as the last step. 1461 */ 1462 if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) { 1463 if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE) 1464 (*target_log_flags) |= XFS_ILOG_DOWNER; 1465 if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE) 1466 (*src_log_flags) |= XFS_ILOG_DOWNER; 1467 } 1468 1469 /* 1470 * Swap the data forks of the inodes 1471 */ 1472 swap(ip->i_df, tip->i_df); 1473 1474 /* 1475 * Fix the on-disk inode values 1476 */ 1477 tmp = (uint64_t)ip->i_d.di_nblocks; 1478 ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks; 1479 tip->i_d.di_nblocks = tmp + taforkblks - aforkblks; 1480 1481 /* 1482 * The extents in the source inode could still contain speculative 1483 * preallocation beyond EOF (e.g. the file is open but not modified 1484 * while defrag is in progress). In that case, we need to copy over the 1485 * number of delalloc blocks the data fork in the source inode is 1486 * tracking beyond EOF so that when the fork is truncated away when the 1487 * temporary inode is unlinked we don't underrun the i_delayed_blks 1488 * counter on that inode. 1489 */ 1490 ASSERT(tip->i_delayed_blks == 0); 1491 tip->i_delayed_blks = ip->i_delayed_blks; 1492 ip->i_delayed_blks = 0; 1493 1494 switch (ip->i_df.if_format) { 1495 case XFS_DINODE_FMT_EXTENTS: 1496 (*src_log_flags) |= XFS_ILOG_DEXT; 1497 break; 1498 case XFS_DINODE_FMT_BTREE: 1499 ASSERT(!xfs_sb_version_has_v3inode(&ip->i_mount->m_sb) || 1500 (*src_log_flags & XFS_ILOG_DOWNER)); 1501 (*src_log_flags) |= XFS_ILOG_DBROOT; 1502 break; 1503 } 1504 1505 switch (tip->i_df.if_format) { 1506 case XFS_DINODE_FMT_EXTENTS: 1507 (*target_log_flags) |= XFS_ILOG_DEXT; 1508 break; 1509 case XFS_DINODE_FMT_BTREE: 1510 (*target_log_flags) |= XFS_ILOG_DBROOT; 1511 ASSERT(!xfs_sb_version_has_v3inode(&ip->i_mount->m_sb) || 1512 (*target_log_flags & XFS_ILOG_DOWNER)); 1513 break; 1514 } 1515 1516 return 0; 1517} 1518 1519/* 1520 * Fix up the owners of the bmbt blocks to refer to the current inode. The 1521 * change owner scan attempts to order all modified buffers in the current 1522 * transaction. In the event of ordered buffer failure, the offending buffer is 1523 * physically logged as a fallback and the scan returns -EAGAIN. We must roll 1524 * the transaction in this case to replenish the fallback log reservation and 1525 * restart the scan. This process repeats until the scan completes. 1526 */ 1527static int 1528xfs_swap_change_owner( 1529 struct xfs_trans **tpp, 1530 struct xfs_inode *ip, 1531 struct xfs_inode *tmpip) 1532{ 1533 int error; 1534 struct xfs_trans *tp = *tpp; 1535 1536 do { 1537 error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino, 1538 NULL); 1539 /* success or fatal error */ 1540 if (error != -EAGAIN) 1541 break; 1542 1543 error = xfs_trans_roll(tpp); 1544 if (error) 1545 break; 1546 tp = *tpp; 1547 1548 /* 1549 * Redirty both inodes so they can relog and keep the log tail 1550 * moving forward. 1551 */ 1552 xfs_trans_ijoin(tp, ip, 0); 1553 xfs_trans_ijoin(tp, tmpip, 0); 1554 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 1555 xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE); 1556 } while (true); 1557 1558 return error; 1559} 1560 1561int 1562xfs_swap_extents( 1563 struct xfs_inode *ip, /* target inode */ 1564 struct xfs_inode *tip, /* tmp inode */ 1565 struct xfs_swapext *sxp) 1566{ 1567 struct xfs_mount *mp = ip->i_mount; 1568 struct xfs_trans *tp; 1569 struct xfs_bstat *sbp = &sxp->sx_stat; 1570 int src_log_flags, target_log_flags; 1571 int error = 0; 1572 int lock_flags; 1573 uint64_t f; 1574 int resblks = 0; 1575 unsigned int flags = 0; 1576 1577 /* 1578 * Lock the inodes against other IO, page faults and truncate to 1579 * begin with. Then we can ensure the inodes are flushed and have no 1580 * page cache safely. Once we have done this we can take the ilocks and 1581 * do the rest of the checks. 1582 */ 1583 lock_two_nondirectories(VFS_I(ip), VFS_I(tip)); 1584 lock_flags = XFS_MMAPLOCK_EXCL; 1585 xfs_lock_two_inodes(ip, XFS_MMAPLOCK_EXCL, tip, XFS_MMAPLOCK_EXCL); 1586 1587 /* Verify that both files have the same format */ 1588 if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) { 1589 error = -EINVAL; 1590 goto out_unlock; 1591 } 1592 1593 /* Verify both files are either real-time or non-realtime */ 1594 if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) { 1595 error = -EINVAL; 1596 goto out_unlock; 1597 } 1598 1599 error = xfs_qm_dqattach(ip); 1600 if (error) 1601 goto out_unlock; 1602 1603 error = xfs_qm_dqattach(tip); 1604 if (error) 1605 goto out_unlock; 1606 1607 error = xfs_swap_extent_flush(ip); 1608 if (error) 1609 goto out_unlock; 1610 error = xfs_swap_extent_flush(tip); 1611 if (error) 1612 goto out_unlock; 1613 1614 if (xfs_inode_has_cow_data(tip)) { 1615 error = xfs_reflink_cancel_cow_range(tip, 0, NULLFILEOFF, true); 1616 if (error) 1617 goto out_unlock; 1618 } 1619 1620 /* 1621 * Extent "swapping" with rmap requires a permanent reservation and 1622 * a block reservation because it's really just a remap operation 1623 * performed with log redo items! 1624 */ 1625 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) { 1626 int w = XFS_DATA_FORK; 1627 uint32_t ipnext = ip->i_df.if_nextents; 1628 uint32_t tipnext = tip->i_df.if_nextents; 1629 1630 /* 1631 * Conceptually this shouldn't affect the shape of either bmbt, 1632 * but since we atomically move extents one by one, we reserve 1633 * enough space to rebuild both trees. 1634 */ 1635 resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w); 1636 resblks += XFS_SWAP_RMAP_SPACE_RES(mp, tipnext, w); 1637 1638 /* 1639 * If either inode straddles a bmapbt block allocation boundary, 1640 * the rmapbt algorithm triggers repeated allocs and frees as 1641 * extents are remapped. This can exhaust the block reservation 1642 * prematurely and cause shutdown. Return freed blocks to the 1643 * transaction reservation to counter this behavior. 1644 */ 1645 flags |= XFS_TRANS_RES_FDBLKS; 1646 } 1647 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags, 1648 &tp); 1649 if (error) 1650 goto out_unlock; 1651 1652 /* 1653 * Lock and join the inodes to the tansaction so that transaction commit 1654 * or cancel will unlock the inodes from this point onwards. 1655 */ 1656 xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL); 1657 lock_flags |= XFS_ILOCK_EXCL; 1658 xfs_trans_ijoin(tp, ip, 0); 1659 xfs_trans_ijoin(tp, tip, 0); 1660 1661 1662 /* Verify all data are being swapped */ 1663 if (sxp->sx_offset != 0 || 1664 sxp->sx_length != ip->i_d.di_size || 1665 sxp->sx_length != tip->i_d.di_size) { 1666 error = -EFAULT; 1667 goto out_trans_cancel; 1668 } 1669 1670 trace_xfs_swap_extent_before(ip, 0); 1671 trace_xfs_swap_extent_before(tip, 1); 1672 1673 /* check inode formats now that data is flushed */ 1674 error = xfs_swap_extents_check_format(ip, tip); 1675 if (error) { 1676 xfs_notice(mp, 1677 "%s: inode 0x%llx format is incompatible for exchanging.", 1678 __func__, ip->i_ino); 1679 goto out_trans_cancel; 1680 } 1681 1682 /* 1683 * Compare the current change & modify times with that 1684 * passed in. If they differ, we abort this swap. 1685 * This is the mechanism used to ensure the calling 1686 * process that the file was not changed out from 1687 * under it. 1688 */ 1689 if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) || 1690 (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) || 1691 (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) || 1692 (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) { 1693 error = -EBUSY; 1694 goto out_trans_cancel; 1695 } 1696 1697 /* 1698 * Note the trickiness in setting the log flags - we set the owner log 1699 * flag on the opposite inode (i.e. the inode we are setting the new 1700 * owner to be) because once we swap the forks and log that, log 1701 * recovery is going to see the fork as owned by the swapped inode, 1702 * not the pre-swapped inodes. 1703 */ 1704 src_log_flags = XFS_ILOG_CORE; 1705 target_log_flags = XFS_ILOG_CORE; 1706 1707 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) 1708 error = xfs_swap_extent_rmap(&tp, ip, tip); 1709 else 1710 error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags, 1711 &target_log_flags); 1712 if (error) 1713 goto out_trans_cancel; 1714 1715 /* Do we have to swap reflink flags? */ 1716 if ((ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK) ^ 1717 (tip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK)) { 1718 f = ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK; 1719 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK; 1720 ip->i_d.di_flags2 |= tip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK; 1721 tip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK; 1722 tip->i_d.di_flags2 |= f & XFS_DIFLAG2_REFLINK; 1723 } 1724 1725 /* Swap the cow forks. */ 1726 if (xfs_sb_version_hasreflink(&mp->m_sb)) { 1727 ASSERT(!ip->i_cowfp || 1728 ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS); 1729 ASSERT(!tip->i_cowfp || 1730 tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS); 1731 1732 swap(ip->i_cowfp, tip->i_cowfp); 1733 1734 if (ip->i_cowfp && ip->i_cowfp->if_bytes) 1735 xfs_inode_set_cowblocks_tag(ip); 1736 else 1737 xfs_inode_clear_cowblocks_tag(ip); 1738 if (tip->i_cowfp && tip->i_cowfp->if_bytes) 1739 xfs_inode_set_cowblocks_tag(tip); 1740 else 1741 xfs_inode_clear_cowblocks_tag(tip); 1742 } 1743 1744 xfs_trans_log_inode(tp, ip, src_log_flags); 1745 xfs_trans_log_inode(tp, tip, target_log_flags); 1746 1747 /* 1748 * The extent forks have been swapped, but crc=1,rmapbt=0 filesystems 1749 * have inode number owner values in the bmbt blocks that still refer to 1750 * the old inode. Scan each bmbt to fix up the owner values with the 1751 * inode number of the current inode. 1752 */ 1753 if (src_log_flags & XFS_ILOG_DOWNER) { 1754 error = xfs_swap_change_owner(&tp, ip, tip); 1755 if (error) 1756 goto out_trans_cancel; 1757 } 1758 if (target_log_flags & XFS_ILOG_DOWNER) { 1759 error = xfs_swap_change_owner(&tp, tip, ip); 1760 if (error) 1761 goto out_trans_cancel; 1762 } 1763 1764 /* 1765 * If this is a synchronous mount, make sure that the 1766 * transaction goes to disk before returning to the user. 1767 */ 1768 if (mp->m_flags & XFS_MOUNT_WSYNC) 1769 xfs_trans_set_sync(tp); 1770 1771 error = xfs_trans_commit(tp); 1772 1773 trace_xfs_swap_extent_after(ip, 0); 1774 trace_xfs_swap_extent_after(tip, 1); 1775 1776out_unlock: 1777 xfs_iunlock(ip, lock_flags); 1778 xfs_iunlock(tip, lock_flags); 1779 unlock_two_nondirectories(VFS_I(ip), VFS_I(tip)); 1780 return error; 1781 1782out_trans_cancel: 1783 xfs_trans_cancel(tp); 1784 goto out_unlock; 1785} 1786