1 /* 2 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 3 * Copyright (c) 2012 Red Hat, Inc. 4 * All Rights Reserved. 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 as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it would be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 #include "xfs.h" 20 #include "xfs_fs.h" 21 #include "xfs_shared.h" 22 #include "xfs_format.h" 23 #include "xfs_log_format.h" 24 #include "xfs_trans_resv.h" 25 #include "xfs_bit.h" 26 #include "xfs_mount.h" 27 #include "xfs_da_format.h" 28 #include "xfs_inode.h" 29 #include "xfs_btree.h" 30 #include "xfs_trans.h" 31 #include "xfs_extfree_item.h" 32 #include "xfs_alloc.h" 33 #include "xfs_bmap.h" 34 #include "xfs_bmap_util.h" 35 #include "xfs_bmap_btree.h" 36 #include "xfs_rtalloc.h" 37 #include "xfs_error.h" 38 #include "xfs_quota.h" 39 #include "xfs_trans_space.h" 40 #include "xfs_trace.h" 41 #include "xfs_icache.h" 42 #include "xfs_log.h" 43 44 /* Kernel only BMAP related definitions and functions */ 45 46 /* 47 * Convert the given file system block to a disk block. We have to treat it 48 * differently based on whether the file is a real time file or not, because the 49 * bmap code does. 50 */ 51 xfs_daddr_t 52 xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb) 53 { 54 return (XFS_IS_REALTIME_INODE(ip) ? \ 55 (xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \ 56 XFS_FSB_TO_DADDR((ip)->i_mount, (fsb))); 57 } 58 59 /* 60 * Routine to zero an extent on disk allocated to the specific inode. 61 * 62 * The VFS functions take a linearised filesystem block offset, so we have to 63 * convert the sparse xfs fsb to the right format first. 64 * VFS types are real funky, too. 65 */ 66 int 67 xfs_zero_extent( 68 struct xfs_inode *ip, 69 xfs_fsblock_t start_fsb, 70 xfs_off_t count_fsb) 71 { 72 struct xfs_mount *mp = ip->i_mount; 73 xfs_daddr_t sector = xfs_fsb_to_db(ip, start_fsb); 74 sector_t block = XFS_BB_TO_FSBT(mp, sector); 75 ssize_t size = XFS_FSB_TO_B(mp, count_fsb); 76 77 if (IS_DAX(VFS_I(ip))) 78 return dax_clear_sectors(xfs_find_bdev_for_inode(VFS_I(ip)), 79 sector, size); 80 81 /* 82 * let the block layer decide on the fastest method of 83 * implementing the zeroing. 84 */ 85 return sb_issue_zeroout(mp->m_super, block, count_fsb, GFP_NOFS); 86 87 } 88 89 /* 90 * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi 91 * caller. Frees all the extents that need freeing, which must be done 92 * last due to locking considerations. We never free any extents in 93 * the first transaction. 94 * 95 * If an inode *ip is provided, rejoin it to the transaction if 96 * the transaction was committed. 97 */ 98 int /* error */ 99 xfs_bmap_finish( 100 struct xfs_trans **tp, /* transaction pointer addr */ 101 struct xfs_bmap_free *flist, /* i/o: list extents to free */ 102 struct xfs_inode *ip) 103 { 104 struct xfs_efd_log_item *efd; /* extent free data */ 105 struct xfs_efi_log_item *efi; /* extent free intention */ 106 int error; /* error return value */ 107 int committed;/* xact committed or not */ 108 struct xfs_bmap_free_item *free; /* free extent item */ 109 struct xfs_bmap_free_item *next; /* next item on free list */ 110 111 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); 112 if (flist->xbf_count == 0) 113 return 0; 114 115 efi = xfs_trans_get_efi(*tp, flist->xbf_count); 116 for (free = flist->xbf_first; free; free = free->xbfi_next) 117 xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock, 118 free->xbfi_blockcount); 119 120 error = __xfs_trans_roll(tp, ip, &committed); 121 if (error) { 122 /* 123 * If the transaction was committed, drop the EFD reference 124 * since we're bailing out of here. The other reference is 125 * dropped when the EFI hits the AIL. 126 * 127 * If the transaction was not committed, the EFI is freed by the 128 * EFI item unlock handler on abort. Also, we have a new 129 * transaction so we should return committed=1 even though we're 130 * returning an error. 131 */ 132 if (committed) { 133 xfs_efi_release(efi); 134 xfs_force_shutdown((*tp)->t_mountp, 135 (error == -EFSCORRUPTED) ? 136 SHUTDOWN_CORRUPT_INCORE : 137 SHUTDOWN_META_IO_ERROR); 138 } 139 return error; 140 } 141 142 /* 143 * Get an EFD and free each extent in the list, logging to the EFD in 144 * the process. The remaining bmap free list is cleaned up by the caller 145 * on error. 146 */ 147 efd = xfs_trans_get_efd(*tp, efi, flist->xbf_count); 148 for (free = flist->xbf_first; free != NULL; free = next) { 149 next = free->xbfi_next; 150 151 error = xfs_trans_free_extent(*tp, efd, free->xbfi_startblock, 152 free->xbfi_blockcount); 153 if (error) 154 return error; 155 156 xfs_bmap_del_free(flist, NULL, free); 157 } 158 159 return 0; 160 } 161 162 int 163 xfs_bmap_rtalloc( 164 struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 165 { 166 xfs_alloctype_t atype = 0; /* type for allocation routines */ 167 int error; /* error return value */ 168 xfs_mount_t *mp; /* mount point structure */ 169 xfs_extlen_t prod = 0; /* product factor for allocators */ 170 xfs_extlen_t ralen = 0; /* realtime allocation length */ 171 xfs_extlen_t align; /* minimum allocation alignment */ 172 xfs_rtblock_t rtb; 173 174 mp = ap->ip->i_mount; 175 align = xfs_get_extsz_hint(ap->ip); 176 prod = align / mp->m_sb.sb_rextsize; 177 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 178 align, 1, ap->eof, 0, 179 ap->conv, &ap->offset, &ap->length); 180 if (error) 181 return error; 182 ASSERT(ap->length); 183 ASSERT(ap->length % mp->m_sb.sb_rextsize == 0); 184 185 /* 186 * If the offset & length are not perfectly aligned 187 * then kill prod, it will just get us in trouble. 188 */ 189 if (do_mod(ap->offset, align) || ap->length % align) 190 prod = 1; 191 /* 192 * Set ralen to be the actual requested length in rtextents. 193 */ 194 ralen = ap->length / mp->m_sb.sb_rextsize; 195 /* 196 * If the old value was close enough to MAXEXTLEN that 197 * we rounded up to it, cut it back so it's valid again. 198 * Note that if it's a really large request (bigger than 199 * MAXEXTLEN), we don't hear about that number, and can't 200 * adjust the starting point to match it. 201 */ 202 if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN) 203 ralen = MAXEXTLEN / mp->m_sb.sb_rextsize; 204 205 /* 206 * Lock out modifications to both the RT bitmap and summary inodes 207 */ 208 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL); 209 xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL); 210 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL); 211 xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL); 212 213 /* 214 * If it's an allocation to an empty file at offset 0, 215 * pick an extent that will space things out in the rt area. 216 */ 217 if (ap->eof && ap->offset == 0) { 218 xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */ 219 220 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx); 221 if (error) 222 return error; 223 ap->blkno = rtx * mp->m_sb.sb_rextsize; 224 } else { 225 ap->blkno = 0; 226 } 227 228 xfs_bmap_adjacent(ap); 229 230 /* 231 * Realtime allocation, done through xfs_rtallocate_extent. 232 */ 233 atype = ap->blkno == 0 ? XFS_ALLOCTYPE_ANY_AG : XFS_ALLOCTYPE_NEAR_BNO; 234 do_div(ap->blkno, mp->m_sb.sb_rextsize); 235 rtb = ap->blkno; 236 ap->length = ralen; 237 if ((error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, ap->length, 238 &ralen, atype, ap->wasdel, prod, &rtb))) 239 return error; 240 if (rtb == NULLFSBLOCK && prod > 1 && 241 (error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, 242 ap->length, &ralen, atype, 243 ap->wasdel, 1, &rtb))) 244 return error; 245 ap->blkno = rtb; 246 if (ap->blkno != NULLFSBLOCK) { 247 ap->blkno *= mp->m_sb.sb_rextsize; 248 ralen *= mp->m_sb.sb_rextsize; 249 ap->length = ralen; 250 ap->ip->i_d.di_nblocks += ralen; 251 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 252 if (ap->wasdel) 253 ap->ip->i_delayed_blks -= ralen; 254 /* 255 * Adjust the disk quota also. This was reserved 256 * earlier. 257 */ 258 xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 259 ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT : 260 XFS_TRANS_DQ_RTBCOUNT, (long) ralen); 261 262 /* Zero the extent if we were asked to do so */ 263 if (ap->userdata & XFS_ALLOC_USERDATA_ZERO) { 264 error = xfs_zero_extent(ap->ip, ap->blkno, ap->length); 265 if (error) 266 return error; 267 } 268 } else { 269 ap->length = 0; 270 } 271 return 0; 272 } 273 274 /* 275 * Check if the endoff is outside the last extent. If so the caller will grow 276 * the allocation to a stripe unit boundary. All offsets are considered outside 277 * the end of file for an empty fork, so 1 is returned in *eof in that case. 278 */ 279 int 280 xfs_bmap_eof( 281 struct xfs_inode *ip, 282 xfs_fileoff_t endoff, 283 int whichfork, 284 int *eof) 285 { 286 struct xfs_bmbt_irec rec; 287 int error; 288 289 error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, eof); 290 if (error || *eof) 291 return error; 292 293 *eof = endoff >= rec.br_startoff + rec.br_blockcount; 294 return 0; 295 } 296 297 /* 298 * Extent tree block counting routines. 299 */ 300 301 /* 302 * Count leaf blocks given a range of extent records. 303 */ 304 STATIC void 305 xfs_bmap_count_leaves( 306 xfs_ifork_t *ifp, 307 xfs_extnum_t idx, 308 int numrecs, 309 int *count) 310 { 311 int b; 312 313 for (b = 0; b < numrecs; b++) { 314 xfs_bmbt_rec_host_t *frp = xfs_iext_get_ext(ifp, idx + b); 315 *count += xfs_bmbt_get_blockcount(frp); 316 } 317 } 318 319 /* 320 * Count leaf blocks given a range of extent records originally 321 * in btree format. 322 */ 323 STATIC void 324 xfs_bmap_disk_count_leaves( 325 struct xfs_mount *mp, 326 struct xfs_btree_block *block, 327 int numrecs, 328 int *count) 329 { 330 int b; 331 xfs_bmbt_rec_t *frp; 332 333 for (b = 1; b <= numrecs; b++) { 334 frp = XFS_BMBT_REC_ADDR(mp, block, b); 335 *count += xfs_bmbt_disk_get_blockcount(frp); 336 } 337 } 338 339 /* 340 * Recursively walks each level of a btree 341 * to count total fsblocks in use. 342 */ 343 STATIC int /* error */ 344 xfs_bmap_count_tree( 345 xfs_mount_t *mp, /* file system mount point */ 346 xfs_trans_t *tp, /* transaction pointer */ 347 xfs_ifork_t *ifp, /* inode fork pointer */ 348 xfs_fsblock_t blockno, /* file system block number */ 349 int levelin, /* level in btree */ 350 int *count) /* Count of blocks */ 351 { 352 int error; 353 xfs_buf_t *bp, *nbp; 354 int level = levelin; 355 __be64 *pp; 356 xfs_fsblock_t bno = blockno; 357 xfs_fsblock_t nextbno; 358 struct xfs_btree_block *block, *nextblock; 359 int numrecs; 360 361 error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF, 362 &xfs_bmbt_buf_ops); 363 if (error) 364 return error; 365 *count += 1; 366 block = XFS_BUF_TO_BLOCK(bp); 367 368 if (--level) { 369 /* Not at node above leaves, count this level of nodes */ 370 nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 371 while (nextbno != NULLFSBLOCK) { 372 error = xfs_btree_read_bufl(mp, tp, nextbno, 0, &nbp, 373 XFS_BMAP_BTREE_REF, 374 &xfs_bmbt_buf_ops); 375 if (error) 376 return error; 377 *count += 1; 378 nextblock = XFS_BUF_TO_BLOCK(nbp); 379 nextbno = be64_to_cpu(nextblock->bb_u.l.bb_rightsib); 380 xfs_trans_brelse(tp, nbp); 381 } 382 383 /* Dive to the next level */ 384 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 385 bno = be64_to_cpu(*pp); 386 if (unlikely((error = 387 xfs_bmap_count_tree(mp, tp, ifp, bno, level, count)) < 0)) { 388 xfs_trans_brelse(tp, bp); 389 XFS_ERROR_REPORT("xfs_bmap_count_tree(1)", 390 XFS_ERRLEVEL_LOW, mp); 391 return -EFSCORRUPTED; 392 } 393 xfs_trans_brelse(tp, bp); 394 } else { 395 /* count all level 1 nodes and their leaves */ 396 for (;;) { 397 nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 398 numrecs = be16_to_cpu(block->bb_numrecs); 399 xfs_bmap_disk_count_leaves(mp, block, numrecs, count); 400 xfs_trans_brelse(tp, bp); 401 if (nextbno == NULLFSBLOCK) 402 break; 403 bno = nextbno; 404 error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 405 XFS_BMAP_BTREE_REF, 406 &xfs_bmbt_buf_ops); 407 if (error) 408 return error; 409 *count += 1; 410 block = XFS_BUF_TO_BLOCK(bp); 411 } 412 } 413 return 0; 414 } 415 416 /* 417 * Count fsblocks of the given fork. 418 */ 419 int /* error */ 420 xfs_bmap_count_blocks( 421 xfs_trans_t *tp, /* transaction pointer */ 422 xfs_inode_t *ip, /* incore inode */ 423 int whichfork, /* data or attr fork */ 424 int *count) /* out: count of blocks */ 425 { 426 struct xfs_btree_block *block; /* current btree block */ 427 xfs_fsblock_t bno; /* block # of "block" */ 428 xfs_ifork_t *ifp; /* fork structure */ 429 int level; /* btree level, for checking */ 430 xfs_mount_t *mp; /* file system mount structure */ 431 __be64 *pp; /* pointer to block address */ 432 433 bno = NULLFSBLOCK; 434 mp = ip->i_mount; 435 ifp = XFS_IFORK_PTR(ip, whichfork); 436 if ( XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS ) { 437 xfs_bmap_count_leaves(ifp, 0, 438 ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t), 439 count); 440 return 0; 441 } 442 443 /* 444 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 445 */ 446 block = ifp->if_broot; 447 level = be16_to_cpu(block->bb_level); 448 ASSERT(level > 0); 449 pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 450 bno = be64_to_cpu(*pp); 451 ASSERT(bno != NULLFSBLOCK); 452 ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 453 ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 454 455 if (unlikely(xfs_bmap_count_tree(mp, tp, ifp, bno, level, count) < 0)) { 456 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW, 457 mp); 458 return -EFSCORRUPTED; 459 } 460 461 return 0; 462 } 463 464 /* 465 * returns 1 for success, 0 if we failed to map the extent. 466 */ 467 STATIC int 468 xfs_getbmapx_fix_eof_hole( 469 xfs_inode_t *ip, /* xfs incore inode pointer */ 470 struct getbmapx *out, /* output structure */ 471 int prealloced, /* this is a file with 472 * preallocated data space */ 473 __int64_t end, /* last block requested */ 474 xfs_fsblock_t startblock) 475 { 476 __int64_t fixlen; 477 xfs_mount_t *mp; /* file system mount point */ 478 xfs_ifork_t *ifp; /* inode fork pointer */ 479 xfs_extnum_t lastx; /* last extent pointer */ 480 xfs_fileoff_t fileblock; 481 482 if (startblock == HOLESTARTBLOCK) { 483 mp = ip->i_mount; 484 out->bmv_block = -1; 485 fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, XFS_ISIZE(ip))); 486 fixlen -= out->bmv_offset; 487 if (prealloced && out->bmv_offset + out->bmv_length == end) { 488 /* Came to hole at EOF. Trim it. */ 489 if (fixlen <= 0) 490 return 0; 491 out->bmv_length = fixlen; 492 } 493 } else { 494 if (startblock == DELAYSTARTBLOCK) 495 out->bmv_block = -2; 496 else 497 out->bmv_block = xfs_fsb_to_db(ip, startblock); 498 fileblock = XFS_BB_TO_FSB(ip->i_mount, out->bmv_offset); 499 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 500 if (xfs_iext_bno_to_ext(ifp, fileblock, &lastx) && 501 (lastx == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))-1)) 502 out->bmv_oflags |= BMV_OF_LAST; 503 } 504 505 return 1; 506 } 507 508 /* 509 * Get inode's extents as described in bmv, and format for output. 510 * Calls formatter to fill the user's buffer until all extents 511 * are mapped, until the passed-in bmv->bmv_count slots have 512 * been filled, or until the formatter short-circuits the loop, 513 * if it is tracking filled-in extents on its own. 514 */ 515 int /* error code */ 516 xfs_getbmap( 517 xfs_inode_t *ip, 518 struct getbmapx *bmv, /* user bmap structure */ 519 xfs_bmap_format_t formatter, /* format to user */ 520 void *arg) /* formatter arg */ 521 { 522 __int64_t bmvend; /* last block requested */ 523 int error = 0; /* return value */ 524 __int64_t fixlen; /* length for -1 case */ 525 int i; /* extent number */ 526 int lock; /* lock state */ 527 xfs_bmbt_irec_t *map; /* buffer for user's data */ 528 xfs_mount_t *mp; /* file system mount point */ 529 int nex; /* # of user extents can do */ 530 int nexleft; /* # of user extents left */ 531 int subnex; /* # of bmapi's can do */ 532 int nmap; /* number of map entries */ 533 struct getbmapx *out; /* output structure */ 534 int whichfork; /* data or attr fork */ 535 int prealloced; /* this is a file with 536 * preallocated data space */ 537 int iflags; /* interface flags */ 538 int bmapi_flags; /* flags for xfs_bmapi */ 539 int cur_ext = 0; 540 541 mp = ip->i_mount; 542 iflags = bmv->bmv_iflags; 543 whichfork = iflags & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK; 544 545 if (whichfork == XFS_ATTR_FORK) { 546 if (XFS_IFORK_Q(ip)) { 547 if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS && 548 ip->i_d.di_aformat != XFS_DINODE_FMT_BTREE && 549 ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL) 550 return -EINVAL; 551 } else if (unlikely( 552 ip->i_d.di_aformat != 0 && 553 ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS)) { 554 XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW, 555 ip->i_mount); 556 return -EFSCORRUPTED; 557 } 558 559 prealloced = 0; 560 fixlen = 1LL << 32; 561 } else { 562 if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS && 563 ip->i_d.di_format != XFS_DINODE_FMT_BTREE && 564 ip->i_d.di_format != XFS_DINODE_FMT_LOCAL) 565 return -EINVAL; 566 567 if (xfs_get_extsz_hint(ip) || 568 ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){ 569 prealloced = 1; 570 fixlen = mp->m_super->s_maxbytes; 571 } else { 572 prealloced = 0; 573 fixlen = XFS_ISIZE(ip); 574 } 575 } 576 577 if (bmv->bmv_length == -1) { 578 fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, fixlen)); 579 bmv->bmv_length = 580 max_t(__int64_t, fixlen - bmv->bmv_offset, 0); 581 } else if (bmv->bmv_length == 0) { 582 bmv->bmv_entries = 0; 583 return 0; 584 } else if (bmv->bmv_length < 0) { 585 return -EINVAL; 586 } 587 588 nex = bmv->bmv_count - 1; 589 if (nex <= 0) 590 return -EINVAL; 591 bmvend = bmv->bmv_offset + bmv->bmv_length; 592 593 594 if (bmv->bmv_count > ULONG_MAX / sizeof(struct getbmapx)) 595 return -ENOMEM; 596 out = kmem_zalloc_large(bmv->bmv_count * sizeof(struct getbmapx), 0); 597 if (!out) 598 return -ENOMEM; 599 600 xfs_ilock(ip, XFS_IOLOCK_SHARED); 601 if (whichfork == XFS_DATA_FORK) { 602 if (!(iflags & BMV_IF_DELALLOC) && 603 (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size)) { 604 error = filemap_write_and_wait(VFS_I(ip)->i_mapping); 605 if (error) 606 goto out_unlock_iolock; 607 608 /* 609 * Even after flushing the inode, there can still be 610 * delalloc blocks on the inode beyond EOF due to 611 * speculative preallocation. These are not removed 612 * until the release function is called or the inode 613 * is inactivated. Hence we cannot assert here that 614 * ip->i_delayed_blks == 0. 615 */ 616 } 617 618 lock = xfs_ilock_data_map_shared(ip); 619 } else { 620 lock = xfs_ilock_attr_map_shared(ip); 621 } 622 623 /* 624 * Don't let nex be bigger than the number of extents 625 * we can have assuming alternating holes and real extents. 626 */ 627 if (nex > XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1) 628 nex = XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1; 629 630 bmapi_flags = xfs_bmapi_aflag(whichfork); 631 if (!(iflags & BMV_IF_PREALLOC)) 632 bmapi_flags |= XFS_BMAPI_IGSTATE; 633 634 /* 635 * Allocate enough space to handle "subnex" maps at a time. 636 */ 637 error = -ENOMEM; 638 subnex = 16; 639 map = kmem_alloc(subnex * sizeof(*map), KM_MAYFAIL | KM_NOFS); 640 if (!map) 641 goto out_unlock_ilock; 642 643 bmv->bmv_entries = 0; 644 645 if (XFS_IFORK_NEXTENTS(ip, whichfork) == 0 && 646 (whichfork == XFS_ATTR_FORK || !(iflags & BMV_IF_DELALLOC))) { 647 error = 0; 648 goto out_free_map; 649 } 650 651 nexleft = nex; 652 653 do { 654 nmap = (nexleft > subnex) ? subnex : nexleft; 655 error = xfs_bmapi_read(ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset), 656 XFS_BB_TO_FSB(mp, bmv->bmv_length), 657 map, &nmap, bmapi_flags); 658 if (error) 659 goto out_free_map; 660 ASSERT(nmap <= subnex); 661 662 for (i = 0; i < nmap && nexleft && bmv->bmv_length; i++) { 663 out[cur_ext].bmv_oflags = 0; 664 if (map[i].br_state == XFS_EXT_UNWRITTEN) 665 out[cur_ext].bmv_oflags |= BMV_OF_PREALLOC; 666 else if (map[i].br_startblock == DELAYSTARTBLOCK) 667 out[cur_ext].bmv_oflags |= BMV_OF_DELALLOC; 668 out[cur_ext].bmv_offset = 669 XFS_FSB_TO_BB(mp, map[i].br_startoff); 670 out[cur_ext].bmv_length = 671 XFS_FSB_TO_BB(mp, map[i].br_blockcount); 672 out[cur_ext].bmv_unused1 = 0; 673 out[cur_ext].bmv_unused2 = 0; 674 675 /* 676 * delayed allocation extents that start beyond EOF can 677 * occur due to speculative EOF allocation when the 678 * delalloc extent is larger than the largest freespace 679 * extent at conversion time. These extents cannot be 680 * converted by data writeback, so can exist here even 681 * if we are not supposed to be finding delalloc 682 * extents. 683 */ 684 if (map[i].br_startblock == DELAYSTARTBLOCK && 685 map[i].br_startoff <= XFS_B_TO_FSB(mp, XFS_ISIZE(ip))) 686 ASSERT((iflags & BMV_IF_DELALLOC) != 0); 687 688 if (map[i].br_startblock == HOLESTARTBLOCK && 689 whichfork == XFS_ATTR_FORK) { 690 /* came to the end of attribute fork */ 691 out[cur_ext].bmv_oflags |= BMV_OF_LAST; 692 goto out_free_map; 693 } 694 695 if (!xfs_getbmapx_fix_eof_hole(ip, &out[cur_ext], 696 prealloced, bmvend, 697 map[i].br_startblock)) 698 goto out_free_map; 699 700 bmv->bmv_offset = 701 out[cur_ext].bmv_offset + 702 out[cur_ext].bmv_length; 703 bmv->bmv_length = 704 max_t(__int64_t, 0, bmvend - bmv->bmv_offset); 705 706 /* 707 * In case we don't want to return the hole, 708 * don't increase cur_ext so that we can reuse 709 * it in the next loop. 710 */ 711 if ((iflags & BMV_IF_NO_HOLES) && 712 map[i].br_startblock == HOLESTARTBLOCK) { 713 memset(&out[cur_ext], 0, sizeof(out[cur_ext])); 714 continue; 715 } 716 717 nexleft--; 718 bmv->bmv_entries++; 719 cur_ext++; 720 } 721 } while (nmap && nexleft && bmv->bmv_length); 722 723 out_free_map: 724 kmem_free(map); 725 out_unlock_ilock: 726 xfs_iunlock(ip, lock); 727 out_unlock_iolock: 728 xfs_iunlock(ip, XFS_IOLOCK_SHARED); 729 730 for (i = 0; i < cur_ext; i++) { 731 int full = 0; /* user array is full */ 732 733 /* format results & advance arg */ 734 error = formatter(&arg, &out[i], &full); 735 if (error || full) 736 break; 737 } 738 739 kmem_free(out); 740 return error; 741 } 742 743 /* 744 * dead simple method of punching delalyed allocation blocks from a range in 745 * the inode. Walks a block at a time so will be slow, but is only executed in 746 * rare error cases so the overhead is not critical. This will always punch out 747 * both the start and end blocks, even if the ranges only partially overlap 748 * them, so it is up to the caller to ensure that partial blocks are not 749 * passed in. 750 */ 751 int 752 xfs_bmap_punch_delalloc_range( 753 struct xfs_inode *ip, 754 xfs_fileoff_t start_fsb, 755 xfs_fileoff_t length) 756 { 757 xfs_fileoff_t remaining = length; 758 int error = 0; 759 760 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 761 762 do { 763 int done; 764 xfs_bmbt_irec_t imap; 765 int nimaps = 1; 766 xfs_fsblock_t firstblock; 767 xfs_bmap_free_t flist; 768 769 /* 770 * Map the range first and check that it is a delalloc extent 771 * before trying to unmap the range. Otherwise we will be 772 * trying to remove a real extent (which requires a 773 * transaction) or a hole, which is probably a bad idea... 774 */ 775 error = xfs_bmapi_read(ip, start_fsb, 1, &imap, &nimaps, 776 XFS_BMAPI_ENTIRE); 777 778 if (error) { 779 /* something screwed, just bail */ 780 if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { 781 xfs_alert(ip->i_mount, 782 "Failed delalloc mapping lookup ino %lld fsb %lld.", 783 ip->i_ino, start_fsb); 784 } 785 break; 786 } 787 if (!nimaps) { 788 /* nothing there */ 789 goto next_block; 790 } 791 if (imap.br_startblock != DELAYSTARTBLOCK) { 792 /* been converted, ignore */ 793 goto next_block; 794 } 795 WARN_ON(imap.br_blockcount == 0); 796 797 /* 798 * Note: while we initialise the firstblock/flist pair, they 799 * should never be used because blocks should never be 800 * allocated or freed for a delalloc extent and hence we need 801 * don't cancel or finish them after the xfs_bunmapi() call. 802 */ 803 xfs_bmap_init(&flist, &firstblock); 804 error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock, 805 &flist, &done); 806 if (error) 807 break; 808 809 ASSERT(!flist.xbf_count && !flist.xbf_first); 810 next_block: 811 start_fsb++; 812 remaining--; 813 } while(remaining > 0); 814 815 return error; 816 } 817 818 /* 819 * Test whether it is appropriate to check an inode for and free post EOF 820 * blocks. The 'force' parameter determines whether we should also consider 821 * regular files that are marked preallocated or append-only. 822 */ 823 bool 824 xfs_can_free_eofblocks(struct xfs_inode *ip, bool force) 825 { 826 /* prealloc/delalloc exists only on regular files */ 827 if (!S_ISREG(VFS_I(ip)->i_mode)) 828 return false; 829 830 /* 831 * Zero sized files with no cached pages and delalloc blocks will not 832 * have speculative prealloc/delalloc blocks to remove. 833 */ 834 if (VFS_I(ip)->i_size == 0 && 835 VFS_I(ip)->i_mapping->nrpages == 0 && 836 ip->i_delayed_blks == 0) 837 return false; 838 839 /* If we haven't read in the extent list, then don't do it now. */ 840 if (!(ip->i_df.if_flags & XFS_IFEXTENTS)) 841 return false; 842 843 /* 844 * Do not free real preallocated or append-only files unless the file 845 * has delalloc blocks and we are forced to remove them. 846 */ 847 if (ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) 848 if (!force || ip->i_delayed_blks == 0) 849 return false; 850 851 return true; 852 } 853 854 /* 855 * This is called by xfs_inactive to free any blocks beyond eof 856 * when the link count isn't zero and by xfs_dm_punch_hole() when 857 * punching a hole to EOF. 858 */ 859 int 860 xfs_free_eofblocks( 861 xfs_mount_t *mp, 862 xfs_inode_t *ip, 863 bool need_iolock) 864 { 865 xfs_trans_t *tp; 866 int error; 867 xfs_fileoff_t end_fsb; 868 xfs_fileoff_t last_fsb; 869 xfs_filblks_t map_len; 870 int nimaps; 871 xfs_bmbt_irec_t imap; 872 873 /* 874 * Figure out if there are any blocks beyond the end 875 * of the file. If not, then there is nothing to do. 876 */ 877 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip)); 878 last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes); 879 if (last_fsb <= end_fsb) 880 return 0; 881 map_len = last_fsb - end_fsb; 882 883 nimaps = 1; 884 xfs_ilock(ip, XFS_ILOCK_SHARED); 885 error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0); 886 xfs_iunlock(ip, XFS_ILOCK_SHARED); 887 888 if (!error && (nimaps != 0) && 889 (imap.br_startblock != HOLESTARTBLOCK || 890 ip->i_delayed_blks)) { 891 /* 892 * Attach the dquots to the inode up front. 893 */ 894 error = xfs_qm_dqattach(ip, 0); 895 if (error) 896 return error; 897 898 /* 899 * There are blocks after the end of file. 900 * Free them up now by truncating the file to 901 * its current size. 902 */ 903 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE); 904 905 if (need_iolock) { 906 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) { 907 xfs_trans_cancel(tp); 908 return -EAGAIN; 909 } 910 } 911 912 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0); 913 if (error) { 914 ASSERT(XFS_FORCED_SHUTDOWN(mp)); 915 xfs_trans_cancel(tp); 916 if (need_iolock) 917 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 918 return error; 919 } 920 921 xfs_ilock(ip, XFS_ILOCK_EXCL); 922 xfs_trans_ijoin(tp, ip, 0); 923 924 /* 925 * Do not update the on-disk file size. If we update the 926 * on-disk file size and then the system crashes before the 927 * contents of the file are flushed to disk then the files 928 * may be full of holes (ie NULL files bug). 929 */ 930 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 931 XFS_ISIZE(ip)); 932 if (error) { 933 /* 934 * If we get an error at this point we simply don't 935 * bother truncating the file. 936 */ 937 xfs_trans_cancel(tp); 938 } else { 939 error = xfs_trans_commit(tp); 940 if (!error) 941 xfs_inode_clear_eofblocks_tag(ip); 942 } 943 944 xfs_iunlock(ip, XFS_ILOCK_EXCL); 945 if (need_iolock) 946 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 947 } 948 return error; 949 } 950 951 int 952 xfs_alloc_file_space( 953 struct xfs_inode *ip, 954 xfs_off_t offset, 955 xfs_off_t len, 956 int alloc_type) 957 { 958 xfs_mount_t *mp = ip->i_mount; 959 xfs_off_t count; 960 xfs_filblks_t allocated_fsb; 961 xfs_filblks_t allocatesize_fsb; 962 xfs_extlen_t extsz, temp; 963 xfs_fileoff_t startoffset_fsb; 964 xfs_fsblock_t firstfsb; 965 int nimaps; 966 int quota_flag; 967 int rt; 968 xfs_trans_t *tp; 969 xfs_bmbt_irec_t imaps[1], *imapp; 970 xfs_bmap_free_t free_list; 971 uint qblocks, resblks, resrtextents; 972 int error; 973 974 trace_xfs_alloc_file_space(ip); 975 976 if (XFS_FORCED_SHUTDOWN(mp)) 977 return -EIO; 978 979 error = xfs_qm_dqattach(ip, 0); 980 if (error) 981 return error; 982 983 if (len <= 0) 984 return -EINVAL; 985 986 rt = XFS_IS_REALTIME_INODE(ip); 987 extsz = xfs_get_extsz_hint(ip); 988 989 count = len; 990 imapp = &imaps[0]; 991 nimaps = 1; 992 startoffset_fsb = XFS_B_TO_FSBT(mp, offset); 993 allocatesize_fsb = XFS_B_TO_FSB(mp, count); 994 995 /* 996 * Allocate file space until done or until there is an error 997 */ 998 while (allocatesize_fsb && !error) { 999 xfs_fileoff_t s, e; 1000 1001 /* 1002 * Determine space reservations for data/realtime. 1003 */ 1004 if (unlikely(extsz)) { 1005 s = startoffset_fsb; 1006 do_div(s, extsz); 1007 s *= extsz; 1008 e = startoffset_fsb + allocatesize_fsb; 1009 if ((temp = do_mod(startoffset_fsb, extsz))) 1010 e += temp; 1011 if ((temp = do_mod(e, extsz))) 1012 e += extsz - temp; 1013 } else { 1014 s = 0; 1015 e = allocatesize_fsb; 1016 } 1017 1018 /* 1019 * The transaction reservation is limited to a 32-bit block 1020 * count, hence we need to limit the number of blocks we are 1021 * trying to reserve to avoid an overflow. We can't allocate 1022 * more than @nimaps extents, and an extent is limited on disk 1023 * to MAXEXTLEN (21 bits), so use that to enforce the limit. 1024 */ 1025 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps)); 1026 if (unlikely(rt)) { 1027 resrtextents = qblocks = resblks; 1028 resrtextents /= mp->m_sb.sb_rextsize; 1029 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0); 1030 quota_flag = XFS_QMOPT_RES_RTBLKS; 1031 } else { 1032 resrtextents = 0; 1033 resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks); 1034 quota_flag = XFS_QMOPT_RES_REGBLKS; 1035 } 1036 1037 /* 1038 * Allocate and setup the transaction. 1039 */ 1040 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); 1041 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, 1042 resblks, resrtextents); 1043 /* 1044 * Check for running out of space 1045 */ 1046 if (error) { 1047 /* 1048 * Free the transaction structure. 1049 */ 1050 ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp)); 1051 xfs_trans_cancel(tp); 1052 break; 1053 } 1054 xfs_ilock(ip, XFS_ILOCK_EXCL); 1055 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 1056 0, quota_flag); 1057 if (error) 1058 goto error1; 1059 1060 xfs_trans_ijoin(tp, ip, 0); 1061 1062 xfs_bmap_init(&free_list, &firstfsb); 1063 error = xfs_bmapi_write(tp, ip, startoffset_fsb, 1064 allocatesize_fsb, alloc_type, &firstfsb, 1065 resblks, imapp, &nimaps, &free_list); 1066 if (error) 1067 goto error0; 1068 1069 /* 1070 * Complete the transaction 1071 */ 1072 error = xfs_bmap_finish(&tp, &free_list, NULL); 1073 if (error) 1074 goto error0; 1075 1076 error = xfs_trans_commit(tp); 1077 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1078 if (error) 1079 break; 1080 1081 allocated_fsb = imapp->br_blockcount; 1082 1083 if (nimaps == 0) { 1084 error = -ENOSPC; 1085 break; 1086 } 1087 1088 startoffset_fsb += allocated_fsb; 1089 allocatesize_fsb -= allocated_fsb; 1090 } 1091 1092 return error; 1093 1094 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */ 1095 xfs_bmap_cancel(&free_list); 1096 xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag); 1097 1098 error1: /* Just cancel transaction */ 1099 xfs_trans_cancel(tp); 1100 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1101 return error; 1102 } 1103 1104 /* 1105 * Zero file bytes between startoff and endoff inclusive. 1106 * The iolock is held exclusive and no blocks are buffered. 1107 * 1108 * This function is used by xfs_free_file_space() to zero 1109 * partial blocks when the range to free is not block aligned. 1110 * When unreserving space with boundaries that are not block 1111 * aligned we round up the start and round down the end 1112 * boundaries and then use this function to zero the parts of 1113 * the blocks that got dropped during the rounding. 1114 */ 1115 STATIC int 1116 xfs_zero_remaining_bytes( 1117 xfs_inode_t *ip, 1118 xfs_off_t startoff, 1119 xfs_off_t endoff) 1120 { 1121 xfs_bmbt_irec_t imap; 1122 xfs_fileoff_t offset_fsb; 1123 xfs_off_t lastoffset; 1124 xfs_off_t offset; 1125 xfs_buf_t *bp; 1126 xfs_mount_t *mp = ip->i_mount; 1127 int nimap; 1128 int error = 0; 1129 1130 /* 1131 * Avoid doing I/O beyond eof - it's not necessary 1132 * since nothing can read beyond eof. The space will 1133 * be zeroed when the file is extended anyway. 1134 */ 1135 if (startoff >= XFS_ISIZE(ip)) 1136 return 0; 1137 1138 if (endoff > XFS_ISIZE(ip)) 1139 endoff = XFS_ISIZE(ip); 1140 1141 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) { 1142 uint lock_mode; 1143 1144 offset_fsb = XFS_B_TO_FSBT(mp, offset); 1145 nimap = 1; 1146 1147 lock_mode = xfs_ilock_data_map_shared(ip); 1148 error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0); 1149 xfs_iunlock(ip, lock_mode); 1150 1151 if (error || nimap < 1) 1152 break; 1153 ASSERT(imap.br_blockcount >= 1); 1154 ASSERT(imap.br_startoff == offset_fsb); 1155 ASSERT(imap.br_startblock != DELAYSTARTBLOCK); 1156 1157 if (imap.br_startblock == HOLESTARTBLOCK || 1158 imap.br_state == XFS_EXT_UNWRITTEN) { 1159 /* skip the entire extent */ 1160 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1161 imap.br_blockcount) - 1; 1162 continue; 1163 } 1164 1165 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1; 1166 if (lastoffset > endoff) 1167 lastoffset = endoff; 1168 1169 /* DAX can just zero the backing device directly */ 1170 if (IS_DAX(VFS_I(ip))) { 1171 error = dax_zero_page_range(VFS_I(ip), offset, 1172 lastoffset - offset + 1, 1173 xfs_get_blocks_direct); 1174 if (error) 1175 return error; 1176 continue; 1177 } 1178 1179 error = xfs_buf_read_uncached(XFS_IS_REALTIME_INODE(ip) ? 1180 mp->m_rtdev_targp : mp->m_ddev_targp, 1181 xfs_fsb_to_db(ip, imap.br_startblock), 1182 BTOBB(mp->m_sb.sb_blocksize), 1183 0, &bp, NULL); 1184 if (error) 1185 return error; 1186 1187 memset(bp->b_addr + 1188 (offset - XFS_FSB_TO_B(mp, imap.br_startoff)), 1189 0, lastoffset - offset + 1); 1190 1191 error = xfs_bwrite(bp); 1192 xfs_buf_relse(bp); 1193 if (error) 1194 return error; 1195 } 1196 return error; 1197 } 1198 1199 int 1200 xfs_free_file_space( 1201 struct xfs_inode *ip, 1202 xfs_off_t offset, 1203 xfs_off_t len) 1204 { 1205 int done; 1206 xfs_fileoff_t endoffset_fsb; 1207 int error; 1208 xfs_fsblock_t firstfsb; 1209 xfs_bmap_free_t free_list; 1210 xfs_bmbt_irec_t imap; 1211 xfs_off_t ioffset; 1212 xfs_off_t iendoffset; 1213 xfs_extlen_t mod=0; 1214 xfs_mount_t *mp; 1215 int nimap; 1216 uint resblks; 1217 xfs_off_t rounding; 1218 int rt; 1219 xfs_fileoff_t startoffset_fsb; 1220 xfs_trans_t *tp; 1221 1222 mp = ip->i_mount; 1223 1224 trace_xfs_free_file_space(ip); 1225 1226 error = xfs_qm_dqattach(ip, 0); 1227 if (error) 1228 return error; 1229 1230 error = 0; 1231 if (len <= 0) /* if nothing being freed */ 1232 return error; 1233 rt = XFS_IS_REALTIME_INODE(ip); 1234 startoffset_fsb = XFS_B_TO_FSB(mp, offset); 1235 endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len); 1236 1237 /* wait for the completion of any pending DIOs */ 1238 inode_dio_wait(VFS_I(ip)); 1239 1240 rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE); 1241 ioffset = round_down(offset, rounding); 1242 iendoffset = round_up(offset + len, rounding) - 1; 1243 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping, ioffset, 1244 iendoffset); 1245 if (error) 1246 goto out; 1247 truncate_pagecache_range(VFS_I(ip), ioffset, iendoffset); 1248 1249 /* 1250 * Need to zero the stuff we're not freeing, on disk. 1251 * If it's a realtime file & can't use unwritten extents then we 1252 * actually need to zero the extent edges. Otherwise xfs_bunmapi 1253 * will take care of it for us. 1254 */ 1255 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 1256 nimap = 1; 1257 error = xfs_bmapi_read(ip, startoffset_fsb, 1, 1258 &imap, &nimap, 0); 1259 if (error) 1260 goto out; 1261 ASSERT(nimap == 0 || nimap == 1); 1262 if (nimap && imap.br_startblock != HOLESTARTBLOCK) { 1263 xfs_daddr_t block; 1264 1265 ASSERT(imap.br_startblock != DELAYSTARTBLOCK); 1266 block = imap.br_startblock; 1267 mod = do_div(block, mp->m_sb.sb_rextsize); 1268 if (mod) 1269 startoffset_fsb += mp->m_sb.sb_rextsize - mod; 1270 } 1271 nimap = 1; 1272 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1, 1273 &imap, &nimap, 0); 1274 if (error) 1275 goto out; 1276 ASSERT(nimap == 0 || nimap == 1); 1277 if (nimap && imap.br_startblock != HOLESTARTBLOCK) { 1278 ASSERT(imap.br_startblock != DELAYSTARTBLOCK); 1279 mod++; 1280 if (mod && (mod != mp->m_sb.sb_rextsize)) 1281 endoffset_fsb -= mod; 1282 } 1283 } 1284 if ((done = (endoffset_fsb <= startoffset_fsb))) 1285 /* 1286 * One contiguous piece to clear 1287 */ 1288 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1); 1289 else { 1290 /* 1291 * Some full blocks, possibly two pieces to clear 1292 */ 1293 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb)) 1294 error = xfs_zero_remaining_bytes(ip, offset, 1295 XFS_FSB_TO_B(mp, startoffset_fsb) - 1); 1296 if (!error && 1297 XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len) 1298 error = xfs_zero_remaining_bytes(ip, 1299 XFS_FSB_TO_B(mp, endoffset_fsb), 1300 offset + len - 1); 1301 } 1302 1303 /* 1304 * free file space until done or until there is an error 1305 */ 1306 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0); 1307 while (!error && !done) { 1308 1309 /* 1310 * allocate and setup the transaction. Allow this 1311 * transaction to dip into the reserve blocks to ensure 1312 * the freeing of the space succeeds at ENOSPC. 1313 */ 1314 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); 1315 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, resblks, 0); 1316 1317 /* 1318 * check for running out of space 1319 */ 1320 if (error) { 1321 /* 1322 * Free the transaction structure. 1323 */ 1324 ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp)); 1325 xfs_trans_cancel(tp); 1326 break; 1327 } 1328 xfs_ilock(ip, XFS_ILOCK_EXCL); 1329 error = xfs_trans_reserve_quota(tp, mp, 1330 ip->i_udquot, ip->i_gdquot, ip->i_pdquot, 1331 resblks, 0, XFS_QMOPT_RES_REGBLKS); 1332 if (error) 1333 goto error1; 1334 1335 xfs_trans_ijoin(tp, ip, 0); 1336 1337 /* 1338 * issue the bunmapi() call to free the blocks 1339 */ 1340 xfs_bmap_init(&free_list, &firstfsb); 1341 error = xfs_bunmapi(tp, ip, startoffset_fsb, 1342 endoffset_fsb - startoffset_fsb, 1343 0, 2, &firstfsb, &free_list, &done); 1344 if (error) 1345 goto error0; 1346 1347 /* 1348 * complete the transaction 1349 */ 1350 error = xfs_bmap_finish(&tp, &free_list, NULL); 1351 if (error) 1352 goto error0; 1353 1354 error = xfs_trans_commit(tp); 1355 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1356 } 1357 1358 out: 1359 return error; 1360 1361 error0: 1362 xfs_bmap_cancel(&free_list); 1363 error1: 1364 xfs_trans_cancel(tp); 1365 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1366 goto out; 1367 } 1368 1369 /* 1370 * Preallocate and zero a range of a file. This mechanism has the allocation 1371 * semantics of fallocate and in addition converts data in the range to zeroes. 1372 */ 1373 int 1374 xfs_zero_file_space( 1375 struct xfs_inode *ip, 1376 xfs_off_t offset, 1377 xfs_off_t len) 1378 { 1379 struct xfs_mount *mp = ip->i_mount; 1380 uint blksize; 1381 int error; 1382 1383 trace_xfs_zero_file_space(ip); 1384 1385 blksize = 1 << mp->m_sb.sb_blocklog; 1386 1387 /* 1388 * Punch a hole and prealloc the range. We use hole punch rather than 1389 * unwritten extent conversion for two reasons: 1390 * 1391 * 1.) Hole punch handles partial block zeroing for us. 1392 * 1393 * 2.) If prealloc returns ENOSPC, the file range is still zero-valued 1394 * by virtue of the hole punch. 1395 */ 1396 error = xfs_free_file_space(ip, offset, len); 1397 if (error) 1398 goto out; 1399 1400 error = xfs_alloc_file_space(ip, round_down(offset, blksize), 1401 round_up(offset + len, blksize) - 1402 round_down(offset, blksize), 1403 XFS_BMAPI_PREALLOC); 1404 out: 1405 return error; 1406 1407 } 1408 1409 /* 1410 * @next_fsb will keep track of the extent currently undergoing shift. 1411 * @stop_fsb will keep track of the extent at which we have to stop. 1412 * If we are shifting left, we will start with block (offset + len) and 1413 * shift each extent till last extent. 1414 * If we are shifting right, we will start with last extent inside file space 1415 * and continue until we reach the block corresponding to offset. 1416 */ 1417 static int 1418 xfs_shift_file_space( 1419 struct xfs_inode *ip, 1420 xfs_off_t offset, 1421 xfs_off_t len, 1422 enum shift_direction direction) 1423 { 1424 int done = 0; 1425 struct xfs_mount *mp = ip->i_mount; 1426 struct xfs_trans *tp; 1427 int error; 1428 struct xfs_bmap_free free_list; 1429 xfs_fsblock_t first_block; 1430 xfs_fileoff_t stop_fsb; 1431 xfs_fileoff_t next_fsb; 1432 xfs_fileoff_t shift_fsb; 1433 1434 ASSERT(direction == SHIFT_LEFT || direction == SHIFT_RIGHT); 1435 1436 if (direction == SHIFT_LEFT) { 1437 next_fsb = XFS_B_TO_FSB(mp, offset + len); 1438 stop_fsb = XFS_B_TO_FSB(mp, VFS_I(ip)->i_size); 1439 } else { 1440 /* 1441 * If right shift, delegate the work of initialization of 1442 * next_fsb to xfs_bmap_shift_extent as it has ilock held. 1443 */ 1444 next_fsb = NULLFSBLOCK; 1445 stop_fsb = XFS_B_TO_FSB(mp, offset); 1446 } 1447 1448 shift_fsb = XFS_B_TO_FSB(mp, len); 1449 1450 /* 1451 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation 1452 * into the accessible region of the file. 1453 */ 1454 if (xfs_can_free_eofblocks(ip, true)) { 1455 error = xfs_free_eofblocks(mp, ip, false); 1456 if (error) 1457 return error; 1458 } 1459 1460 /* 1461 * Writeback and invalidate cache for the remainder of the file as we're 1462 * about to shift down every extent from offset to EOF. 1463 */ 1464 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping, 1465 offset, -1); 1466 if (error) 1467 return error; 1468 error = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping, 1469 offset >> PAGE_CACHE_SHIFT, -1); 1470 if (error) 1471 return error; 1472 1473 /* 1474 * The extent shiting code works on extent granularity. So, if 1475 * stop_fsb is not the starting block of extent, we need to split 1476 * the extent at stop_fsb. 1477 */ 1478 if (direction == SHIFT_RIGHT) { 1479 error = xfs_bmap_split_extent(ip, stop_fsb); 1480 if (error) 1481 return error; 1482 } 1483 1484 while (!error && !done) { 1485 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); 1486 /* 1487 * We would need to reserve permanent block for transaction. 1488 * This will come into picture when after shifting extent into 1489 * hole we found that adjacent extents can be merged which 1490 * may lead to freeing of a block during record update. 1491 */ 1492 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, 1493 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0); 1494 if (error) { 1495 xfs_trans_cancel(tp); 1496 break; 1497 } 1498 1499 xfs_ilock(ip, XFS_ILOCK_EXCL); 1500 error = xfs_trans_reserve_quota(tp, mp, ip->i_udquot, 1501 ip->i_gdquot, ip->i_pdquot, 1502 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 1503 XFS_QMOPT_RES_REGBLKS); 1504 if (error) 1505 goto out_trans_cancel; 1506 1507 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 1508 1509 xfs_bmap_init(&free_list, &first_block); 1510 1511 /* 1512 * We are using the write transaction in which max 2 bmbt 1513 * updates are allowed 1514 */ 1515 error = xfs_bmap_shift_extents(tp, ip, &next_fsb, shift_fsb, 1516 &done, stop_fsb, &first_block, &free_list, 1517 direction, XFS_BMAP_MAX_SHIFT_EXTENTS); 1518 if (error) 1519 goto out_bmap_cancel; 1520 1521 error = xfs_bmap_finish(&tp, &free_list, NULL); 1522 if (error) 1523 goto out_bmap_cancel; 1524 1525 error = xfs_trans_commit(tp); 1526 } 1527 1528 return error; 1529 1530 out_bmap_cancel: 1531 xfs_bmap_cancel(&free_list); 1532 out_trans_cancel: 1533 xfs_trans_cancel(tp); 1534 return error; 1535 } 1536 1537 /* 1538 * xfs_collapse_file_space() 1539 * This routine frees disk space and shift extent for the given file. 1540 * The first thing we do is to free data blocks in the specified range 1541 * by calling xfs_free_file_space(). It would also sync dirty data 1542 * and invalidate page cache over the region on which collapse range 1543 * is working. And Shift extent records to the left to cover a hole. 1544 * RETURNS: 1545 * 0 on success 1546 * errno on error 1547 * 1548 */ 1549 int 1550 xfs_collapse_file_space( 1551 struct xfs_inode *ip, 1552 xfs_off_t offset, 1553 xfs_off_t len) 1554 { 1555 int error; 1556 1557 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 1558 trace_xfs_collapse_file_space(ip); 1559 1560 error = xfs_free_file_space(ip, offset, len); 1561 if (error) 1562 return error; 1563 1564 return xfs_shift_file_space(ip, offset, len, SHIFT_LEFT); 1565 } 1566 1567 /* 1568 * xfs_insert_file_space() 1569 * This routine create hole space by shifting extents for the given file. 1570 * The first thing we do is to sync dirty data and invalidate page cache 1571 * over the region on which insert range is working. And split an extent 1572 * to two extents at given offset by calling xfs_bmap_split_extent. 1573 * And shift all extent records which are laying between [offset, 1574 * last allocated extent] to the right to reserve hole range. 1575 * RETURNS: 1576 * 0 on success 1577 * errno on error 1578 */ 1579 int 1580 xfs_insert_file_space( 1581 struct xfs_inode *ip, 1582 loff_t offset, 1583 loff_t len) 1584 { 1585 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 1586 trace_xfs_insert_file_space(ip); 1587 1588 return xfs_shift_file_space(ip, offset, len, SHIFT_RIGHT); 1589 } 1590 1591 /* 1592 * We need to check that the format of the data fork in the temporary inode is 1593 * valid for the target inode before doing the swap. This is not a problem with 1594 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized 1595 * data fork depending on the space the attribute fork is taking so we can get 1596 * invalid formats on the target inode. 1597 * 1598 * E.g. target has space for 7 extents in extent format, temp inode only has 1599 * space for 6. If we defragment down to 7 extents, then the tmp format is a 1600 * btree, but when swapped it needs to be in extent format. Hence we can't just 1601 * blindly swap data forks on attr2 filesystems. 1602 * 1603 * Note that we check the swap in both directions so that we don't end up with 1604 * a corrupt temporary inode, either. 1605 * 1606 * Note that fixing the way xfs_fsr sets up the attribute fork in the source 1607 * inode will prevent this situation from occurring, so all we do here is 1608 * reject and log the attempt. basically we are putting the responsibility on 1609 * userspace to get this right. 1610 */ 1611 static int 1612 xfs_swap_extents_check_format( 1613 xfs_inode_t *ip, /* target inode */ 1614 xfs_inode_t *tip) /* tmp inode */ 1615 { 1616 1617 /* Should never get a local format */ 1618 if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL || 1619 tip->i_d.di_format == XFS_DINODE_FMT_LOCAL) 1620 return -EINVAL; 1621 1622 /* 1623 * if the target inode has less extents that then temporary inode then 1624 * why did userspace call us? 1625 */ 1626 if (ip->i_d.di_nextents < tip->i_d.di_nextents) 1627 return -EINVAL; 1628 1629 /* 1630 * if the target inode is in extent form and the temp inode is in btree 1631 * form then we will end up with the target inode in the wrong format 1632 * as we already know there are less extents in the temp inode. 1633 */ 1634 if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 1635 tip->i_d.di_format == XFS_DINODE_FMT_BTREE) 1636 return -EINVAL; 1637 1638 /* Check temp in extent form to max in target */ 1639 if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 1640 XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) > 1641 XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK)) 1642 return -EINVAL; 1643 1644 /* Check target in extent form to max in temp */ 1645 if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 1646 XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > 1647 XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK)) 1648 return -EINVAL; 1649 1650 /* 1651 * If we are in a btree format, check that the temp root block will fit 1652 * in the target and that it has enough extents to be in btree format 1653 * in the target. 1654 * 1655 * Note that we have to be careful to allow btree->extent conversions 1656 * (a common defrag case) which will occur when the temp inode is in 1657 * extent format... 1658 */ 1659 if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) { 1660 if (XFS_IFORK_BOFF(ip) && 1661 XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip)) 1662 return -EINVAL; 1663 if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <= 1664 XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK)) 1665 return -EINVAL; 1666 } 1667 1668 /* Reciprocal target->temp btree format checks */ 1669 if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) { 1670 if (XFS_IFORK_BOFF(tip) && 1671 XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip)) 1672 return -EINVAL; 1673 if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <= 1674 XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK)) 1675 return -EINVAL; 1676 } 1677 1678 return 0; 1679 } 1680 1681 static int 1682 xfs_swap_extent_flush( 1683 struct xfs_inode *ip) 1684 { 1685 int error; 1686 1687 error = filemap_write_and_wait(VFS_I(ip)->i_mapping); 1688 if (error) 1689 return error; 1690 truncate_pagecache_range(VFS_I(ip), 0, -1); 1691 1692 /* Verify O_DIRECT for ftmp */ 1693 if (VFS_I(ip)->i_mapping->nrpages) 1694 return -EINVAL; 1695 return 0; 1696 } 1697 1698 int 1699 xfs_swap_extents( 1700 xfs_inode_t *ip, /* target inode */ 1701 xfs_inode_t *tip, /* tmp inode */ 1702 xfs_swapext_t *sxp) 1703 { 1704 xfs_mount_t *mp = ip->i_mount; 1705 xfs_trans_t *tp; 1706 xfs_bstat_t *sbp = &sxp->sx_stat; 1707 xfs_ifork_t *tempifp, *ifp, *tifp; 1708 int src_log_flags, target_log_flags; 1709 int error = 0; 1710 int aforkblks = 0; 1711 int taforkblks = 0; 1712 __uint64_t tmp; 1713 int lock_flags; 1714 1715 tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL); 1716 if (!tempifp) { 1717 error = -ENOMEM; 1718 goto out; 1719 } 1720 1721 /* 1722 * Lock the inodes against other IO, page faults and truncate to 1723 * begin with. Then we can ensure the inodes are flushed and have no 1724 * page cache safely. Once we have done this we can take the ilocks and 1725 * do the rest of the checks. 1726 */ 1727 lock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL; 1728 xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL); 1729 xfs_lock_two_inodes(ip, tip, XFS_MMAPLOCK_EXCL); 1730 1731 /* Verify that both files have the same format */ 1732 if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) { 1733 error = -EINVAL; 1734 goto out_unlock; 1735 } 1736 1737 /* Verify both files are either real-time or non-realtime */ 1738 if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) { 1739 error = -EINVAL; 1740 goto out_unlock; 1741 } 1742 1743 error = xfs_swap_extent_flush(ip); 1744 if (error) 1745 goto out_unlock; 1746 error = xfs_swap_extent_flush(tip); 1747 if (error) 1748 goto out_unlock; 1749 1750 tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT); 1751 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0); 1752 if (error) { 1753 xfs_trans_cancel(tp); 1754 goto out_unlock; 1755 } 1756 1757 /* 1758 * Lock and join the inodes to the tansaction so that transaction commit 1759 * or cancel will unlock the inodes from this point onwards. 1760 */ 1761 xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL); 1762 lock_flags |= XFS_ILOCK_EXCL; 1763 xfs_trans_ijoin(tp, ip, lock_flags); 1764 xfs_trans_ijoin(tp, tip, lock_flags); 1765 1766 1767 /* Verify all data are being swapped */ 1768 if (sxp->sx_offset != 0 || 1769 sxp->sx_length != ip->i_d.di_size || 1770 sxp->sx_length != tip->i_d.di_size) { 1771 error = -EFAULT; 1772 goto out_trans_cancel; 1773 } 1774 1775 trace_xfs_swap_extent_before(ip, 0); 1776 trace_xfs_swap_extent_before(tip, 1); 1777 1778 /* check inode formats now that data is flushed */ 1779 error = xfs_swap_extents_check_format(ip, tip); 1780 if (error) { 1781 xfs_notice(mp, 1782 "%s: inode 0x%llx format is incompatible for exchanging.", 1783 __func__, ip->i_ino); 1784 goto out_trans_cancel; 1785 } 1786 1787 /* 1788 * Compare the current change & modify times with that 1789 * passed in. If they differ, we abort this swap. 1790 * This is the mechanism used to ensure the calling 1791 * process that the file was not changed out from 1792 * under it. 1793 */ 1794 if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) || 1795 (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) || 1796 (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) || 1797 (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) { 1798 error = -EBUSY; 1799 goto out_trans_cancel; 1800 } 1801 /* 1802 * Count the number of extended attribute blocks 1803 */ 1804 if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) && 1805 (ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) { 1806 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks); 1807 if (error) 1808 goto out_trans_cancel; 1809 } 1810 if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) && 1811 (tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) { 1812 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, 1813 &taforkblks); 1814 if (error) 1815 goto out_trans_cancel; 1816 } 1817 1818 /* 1819 * Before we've swapped the forks, lets set the owners of the forks 1820 * appropriately. We have to do this as we are demand paging the btree 1821 * buffers, and so the validation done on read will expect the owner 1822 * field to be correctly set. Once we change the owners, we can swap the 1823 * inode forks. 1824 * 1825 * Note the trickiness in setting the log flags - we set the owner log 1826 * flag on the opposite inode (i.e. the inode we are setting the new 1827 * owner to be) because once we swap the forks and log that, log 1828 * recovery is going to see the fork as owned by the swapped inode, 1829 * not the pre-swapped inodes. 1830 */ 1831 src_log_flags = XFS_ILOG_CORE; 1832 target_log_flags = XFS_ILOG_CORE; 1833 if (ip->i_d.di_version == 3 && 1834 ip->i_d.di_format == XFS_DINODE_FMT_BTREE) { 1835 target_log_flags |= XFS_ILOG_DOWNER; 1836 error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, 1837 tip->i_ino, NULL); 1838 if (error) 1839 goto out_trans_cancel; 1840 } 1841 1842 if (tip->i_d.di_version == 3 && 1843 tip->i_d.di_format == XFS_DINODE_FMT_BTREE) { 1844 src_log_flags |= XFS_ILOG_DOWNER; 1845 error = xfs_bmbt_change_owner(tp, tip, XFS_DATA_FORK, 1846 ip->i_ino, NULL); 1847 if (error) 1848 goto out_trans_cancel; 1849 } 1850 1851 /* 1852 * Swap the data forks of the inodes 1853 */ 1854 ifp = &ip->i_df; 1855 tifp = &tip->i_df; 1856 *tempifp = *ifp; /* struct copy */ 1857 *ifp = *tifp; /* struct copy */ 1858 *tifp = *tempifp; /* struct copy */ 1859 1860 /* 1861 * Fix the on-disk inode values 1862 */ 1863 tmp = (__uint64_t)ip->i_d.di_nblocks; 1864 ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks; 1865 tip->i_d.di_nblocks = tmp + taforkblks - aforkblks; 1866 1867 tmp = (__uint64_t) ip->i_d.di_nextents; 1868 ip->i_d.di_nextents = tip->i_d.di_nextents; 1869 tip->i_d.di_nextents = tmp; 1870 1871 tmp = (__uint64_t) ip->i_d.di_format; 1872 ip->i_d.di_format = tip->i_d.di_format; 1873 tip->i_d.di_format = tmp; 1874 1875 /* 1876 * The extents in the source inode could still contain speculative 1877 * preallocation beyond EOF (e.g. the file is open but not modified 1878 * while defrag is in progress). In that case, we need to copy over the 1879 * number of delalloc blocks the data fork in the source inode is 1880 * tracking beyond EOF so that when the fork is truncated away when the 1881 * temporary inode is unlinked we don't underrun the i_delayed_blks 1882 * counter on that inode. 1883 */ 1884 ASSERT(tip->i_delayed_blks == 0); 1885 tip->i_delayed_blks = ip->i_delayed_blks; 1886 ip->i_delayed_blks = 0; 1887 1888 switch (ip->i_d.di_format) { 1889 case XFS_DINODE_FMT_EXTENTS: 1890 /* If the extents fit in the inode, fix the 1891 * pointer. Otherwise it's already NULL or 1892 * pointing to the extent. 1893 */ 1894 if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) { 1895 ifp->if_u1.if_extents = 1896 ifp->if_u2.if_inline_ext; 1897 } 1898 src_log_flags |= XFS_ILOG_DEXT; 1899 break; 1900 case XFS_DINODE_FMT_BTREE: 1901 ASSERT(ip->i_d.di_version < 3 || 1902 (src_log_flags & XFS_ILOG_DOWNER)); 1903 src_log_flags |= XFS_ILOG_DBROOT; 1904 break; 1905 } 1906 1907 switch (tip->i_d.di_format) { 1908 case XFS_DINODE_FMT_EXTENTS: 1909 /* If the extents fit in the inode, fix the 1910 * pointer. Otherwise it's already NULL or 1911 * pointing to the extent. 1912 */ 1913 if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) { 1914 tifp->if_u1.if_extents = 1915 tifp->if_u2.if_inline_ext; 1916 } 1917 target_log_flags |= XFS_ILOG_DEXT; 1918 break; 1919 case XFS_DINODE_FMT_BTREE: 1920 target_log_flags |= XFS_ILOG_DBROOT; 1921 ASSERT(tip->i_d.di_version < 3 || 1922 (target_log_flags & XFS_ILOG_DOWNER)); 1923 break; 1924 } 1925 1926 xfs_trans_log_inode(tp, ip, src_log_flags); 1927 xfs_trans_log_inode(tp, tip, target_log_flags); 1928 1929 /* 1930 * If this is a synchronous mount, make sure that the 1931 * transaction goes to disk before returning to the user. 1932 */ 1933 if (mp->m_flags & XFS_MOUNT_WSYNC) 1934 xfs_trans_set_sync(tp); 1935 1936 error = xfs_trans_commit(tp); 1937 1938 trace_xfs_swap_extent_after(ip, 0); 1939 trace_xfs_swap_extent_after(tip, 1); 1940 out: 1941 kmem_free(tempifp); 1942 return error; 1943 1944 out_unlock: 1945 xfs_iunlock(ip, lock_flags); 1946 xfs_iunlock(tip, lock_flags); 1947 goto out; 1948 1949 out_trans_cancel: 1950 xfs_trans_cancel(tp); 1951 goto out; 1952 } 1953