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