1 /* 2 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include <linux/log2.h> 19 20 #include "xfs.h" 21 #include "xfs_fs.h" 22 #include "xfs_types.h" 23 #include "xfs_bit.h" 24 #include "xfs_log.h" 25 #include "xfs_inum.h" 26 #include "xfs_imap.h" 27 #include "xfs_trans.h" 28 #include "xfs_trans_priv.h" 29 #include "xfs_sb.h" 30 #include "xfs_ag.h" 31 #include "xfs_dir2.h" 32 #include "xfs_dmapi.h" 33 #include "xfs_mount.h" 34 #include "xfs_bmap_btree.h" 35 #include "xfs_alloc_btree.h" 36 #include "xfs_ialloc_btree.h" 37 #include "xfs_dir2_sf.h" 38 #include "xfs_attr_sf.h" 39 #include "xfs_dinode.h" 40 #include "xfs_inode.h" 41 #include "xfs_buf_item.h" 42 #include "xfs_inode_item.h" 43 #include "xfs_btree.h" 44 #include "xfs_alloc.h" 45 #include "xfs_ialloc.h" 46 #include "xfs_bmap.h" 47 #include "xfs_rw.h" 48 #include "xfs_error.h" 49 #include "xfs_utils.h" 50 #include "xfs_dir2_trace.h" 51 #include "xfs_quota.h" 52 #include "xfs_acl.h" 53 #include "xfs_filestream.h" 54 #include "xfs_vnodeops.h" 55 56 kmem_zone_t *xfs_ifork_zone; 57 kmem_zone_t *xfs_inode_zone; 58 59 /* 60 * Used in xfs_itruncate(). This is the maximum number of extents 61 * freed from a file in a single transaction. 62 */ 63 #define XFS_ITRUNC_MAX_EXTENTS 2 64 65 STATIC int xfs_iflush_int(xfs_inode_t *, xfs_buf_t *); 66 STATIC int xfs_iformat_local(xfs_inode_t *, xfs_dinode_t *, int, int); 67 STATIC int xfs_iformat_extents(xfs_inode_t *, xfs_dinode_t *, int); 68 STATIC int xfs_iformat_btree(xfs_inode_t *, xfs_dinode_t *, int); 69 70 #ifdef DEBUG 71 /* 72 * Make sure that the extents in the given memory buffer 73 * are valid. 74 */ 75 STATIC void 76 xfs_validate_extents( 77 xfs_ifork_t *ifp, 78 int nrecs, 79 xfs_exntfmt_t fmt) 80 { 81 xfs_bmbt_irec_t irec; 82 xfs_bmbt_rec_host_t rec; 83 int i; 84 85 for (i = 0; i < nrecs; i++) { 86 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i); 87 rec.l0 = get_unaligned(&ep->l0); 88 rec.l1 = get_unaligned(&ep->l1); 89 xfs_bmbt_get_all(&rec, &irec); 90 if (fmt == XFS_EXTFMT_NOSTATE) 91 ASSERT(irec.br_state == XFS_EXT_NORM); 92 } 93 } 94 #else /* DEBUG */ 95 #define xfs_validate_extents(ifp, nrecs, fmt) 96 #endif /* DEBUG */ 97 98 /* 99 * Check that none of the inode's in the buffer have a next 100 * unlinked field of 0. 101 */ 102 #if defined(DEBUG) 103 void 104 xfs_inobp_check( 105 xfs_mount_t *mp, 106 xfs_buf_t *bp) 107 { 108 int i; 109 int j; 110 xfs_dinode_t *dip; 111 112 j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog; 113 114 for (i = 0; i < j; i++) { 115 dip = (xfs_dinode_t *)xfs_buf_offset(bp, 116 i * mp->m_sb.sb_inodesize); 117 if (!dip->di_next_unlinked) { 118 xfs_fs_cmn_err(CE_ALERT, mp, 119 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.", 120 bp); 121 ASSERT(dip->di_next_unlinked); 122 } 123 } 124 } 125 #endif 126 127 /* 128 * Find the buffer associated with the given inode map 129 * We do basic validation checks on the buffer once it has been 130 * retrieved from disk. 131 */ 132 STATIC int 133 xfs_imap_to_bp( 134 xfs_mount_t *mp, 135 xfs_trans_t *tp, 136 xfs_imap_t *imap, 137 xfs_buf_t **bpp, 138 uint buf_flags, 139 uint imap_flags) 140 { 141 int error; 142 int i; 143 int ni; 144 xfs_buf_t *bp; 145 146 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno, 147 (int)imap->im_len, buf_flags, &bp); 148 if (error) { 149 if (error != EAGAIN) { 150 cmn_err(CE_WARN, 151 "xfs_imap_to_bp: xfs_trans_read_buf()returned " 152 "an error %d on %s. Returning error.", 153 error, mp->m_fsname); 154 } else { 155 ASSERT(buf_flags & XFS_BUF_TRYLOCK); 156 } 157 return error; 158 } 159 160 /* 161 * Validate the magic number and version of every inode in the buffer 162 * (if DEBUG kernel) or the first inode in the buffer, otherwise. 163 */ 164 #ifdef DEBUG 165 ni = BBTOB(imap->im_len) >> mp->m_sb.sb_inodelog; 166 #else /* usual case */ 167 ni = 1; 168 #endif 169 170 for (i = 0; i < ni; i++) { 171 int di_ok; 172 xfs_dinode_t *dip; 173 174 dip = (xfs_dinode_t *)xfs_buf_offset(bp, 175 (i << mp->m_sb.sb_inodelog)); 176 di_ok = be16_to_cpu(dip->di_core.di_magic) == XFS_DINODE_MAGIC && 177 XFS_DINODE_GOOD_VERSION(dip->di_core.di_version); 178 if (unlikely(XFS_TEST_ERROR(!di_ok, mp, 179 XFS_ERRTAG_ITOBP_INOTOBP, 180 XFS_RANDOM_ITOBP_INOTOBP))) { 181 if (imap_flags & XFS_IMAP_BULKSTAT) { 182 xfs_trans_brelse(tp, bp); 183 return XFS_ERROR(EINVAL); 184 } 185 XFS_CORRUPTION_ERROR("xfs_imap_to_bp", 186 XFS_ERRLEVEL_HIGH, mp, dip); 187 #ifdef DEBUG 188 cmn_err(CE_PANIC, 189 "Device %s - bad inode magic/vsn " 190 "daddr %lld #%d (magic=%x)", 191 XFS_BUFTARG_NAME(mp->m_ddev_targp), 192 (unsigned long long)imap->im_blkno, i, 193 be16_to_cpu(dip->di_core.di_magic)); 194 #endif 195 xfs_trans_brelse(tp, bp); 196 return XFS_ERROR(EFSCORRUPTED); 197 } 198 } 199 200 xfs_inobp_check(mp, bp); 201 202 /* 203 * Mark the buffer as an inode buffer now that it looks good 204 */ 205 XFS_BUF_SET_VTYPE(bp, B_FS_INO); 206 207 *bpp = bp; 208 return 0; 209 } 210 211 /* 212 * This routine is called to map an inode number within a file 213 * system to the buffer containing the on-disk version of the 214 * inode. It returns a pointer to the buffer containing the 215 * on-disk inode in the bpp parameter, and in the dip parameter 216 * it returns a pointer to the on-disk inode within that buffer. 217 * 218 * If a non-zero error is returned, then the contents of bpp and 219 * dipp are undefined. 220 * 221 * Use xfs_imap() to determine the size and location of the 222 * buffer to read from disk. 223 */ 224 STATIC int 225 xfs_inotobp( 226 xfs_mount_t *mp, 227 xfs_trans_t *tp, 228 xfs_ino_t ino, 229 xfs_dinode_t **dipp, 230 xfs_buf_t **bpp, 231 int *offset) 232 { 233 xfs_imap_t imap; 234 xfs_buf_t *bp; 235 int error; 236 237 imap.im_blkno = 0; 238 error = xfs_imap(mp, tp, ino, &imap, XFS_IMAP_LOOKUP); 239 if (error) 240 return error; 241 242 error = xfs_imap_to_bp(mp, tp, &imap, &bp, XFS_BUF_LOCK, 0); 243 if (error) 244 return error; 245 246 *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset); 247 *bpp = bp; 248 *offset = imap.im_boffset; 249 return 0; 250 } 251 252 253 /* 254 * This routine is called to map an inode to the buffer containing 255 * the on-disk version of the inode. It returns a pointer to the 256 * buffer containing the on-disk inode in the bpp parameter, and in 257 * the dip parameter it returns a pointer to the on-disk inode within 258 * that buffer. 259 * 260 * If a non-zero error is returned, then the contents of bpp and 261 * dipp are undefined. 262 * 263 * If the inode is new and has not yet been initialized, use xfs_imap() 264 * to determine the size and location of the buffer to read from disk. 265 * If the inode has already been mapped to its buffer and read in once, 266 * then use the mapping information stored in the inode rather than 267 * calling xfs_imap(). This allows us to avoid the overhead of looking 268 * at the inode btree for small block file systems (see xfs_dilocate()). 269 * We can tell whether the inode has been mapped in before by comparing 270 * its disk block address to 0. Only uninitialized inodes will have 271 * 0 for the disk block address. 272 */ 273 int 274 xfs_itobp( 275 xfs_mount_t *mp, 276 xfs_trans_t *tp, 277 xfs_inode_t *ip, 278 xfs_dinode_t **dipp, 279 xfs_buf_t **bpp, 280 xfs_daddr_t bno, 281 uint imap_flags, 282 uint buf_flags) 283 { 284 xfs_imap_t imap; 285 xfs_buf_t *bp; 286 int error; 287 288 if (ip->i_blkno == (xfs_daddr_t)0) { 289 imap.im_blkno = bno; 290 error = xfs_imap(mp, tp, ip->i_ino, &imap, 291 XFS_IMAP_LOOKUP | imap_flags); 292 if (error) 293 return error; 294 295 /* 296 * Fill in the fields in the inode that will be used to 297 * map the inode to its buffer from now on. 298 */ 299 ip->i_blkno = imap.im_blkno; 300 ip->i_len = imap.im_len; 301 ip->i_boffset = imap.im_boffset; 302 } else { 303 /* 304 * We've already mapped the inode once, so just use the 305 * mapping that we saved the first time. 306 */ 307 imap.im_blkno = ip->i_blkno; 308 imap.im_len = ip->i_len; 309 imap.im_boffset = ip->i_boffset; 310 } 311 ASSERT(bno == 0 || bno == imap.im_blkno); 312 313 error = xfs_imap_to_bp(mp, tp, &imap, &bp, buf_flags, imap_flags); 314 if (error) 315 return error; 316 317 if (!bp) { 318 ASSERT(buf_flags & XFS_BUF_TRYLOCK); 319 ASSERT(tp == NULL); 320 *bpp = NULL; 321 return EAGAIN; 322 } 323 324 *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset); 325 *bpp = bp; 326 return 0; 327 } 328 329 /* 330 * Move inode type and inode format specific information from the 331 * on-disk inode to the in-core inode. For fifos, devs, and sockets 332 * this means set if_rdev to the proper value. For files, directories, 333 * and symlinks this means to bring in the in-line data or extent 334 * pointers. For a file in B-tree format, only the root is immediately 335 * brought in-core. The rest will be in-lined in if_extents when it 336 * is first referenced (see xfs_iread_extents()). 337 */ 338 STATIC int 339 xfs_iformat( 340 xfs_inode_t *ip, 341 xfs_dinode_t *dip) 342 { 343 xfs_attr_shortform_t *atp; 344 int size; 345 int error; 346 xfs_fsize_t di_size; 347 ip->i_df.if_ext_max = 348 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t); 349 error = 0; 350 351 if (unlikely(be32_to_cpu(dip->di_core.di_nextents) + 352 be16_to_cpu(dip->di_core.di_anextents) > 353 be64_to_cpu(dip->di_core.di_nblocks))) { 354 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 355 "corrupt dinode %Lu, extent total = %d, nblocks = %Lu.", 356 (unsigned long long)ip->i_ino, 357 (int)(be32_to_cpu(dip->di_core.di_nextents) + 358 be16_to_cpu(dip->di_core.di_anextents)), 359 (unsigned long long) 360 be64_to_cpu(dip->di_core.di_nblocks)); 361 XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW, 362 ip->i_mount, dip); 363 return XFS_ERROR(EFSCORRUPTED); 364 } 365 366 if (unlikely(dip->di_core.di_forkoff > ip->i_mount->m_sb.sb_inodesize)) { 367 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 368 "corrupt dinode %Lu, forkoff = 0x%x.", 369 (unsigned long long)ip->i_ino, 370 dip->di_core.di_forkoff); 371 XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW, 372 ip->i_mount, dip); 373 return XFS_ERROR(EFSCORRUPTED); 374 } 375 376 switch (ip->i_d.di_mode & S_IFMT) { 377 case S_IFIFO: 378 case S_IFCHR: 379 case S_IFBLK: 380 case S_IFSOCK: 381 if (unlikely(dip->di_core.di_format != XFS_DINODE_FMT_DEV)) { 382 XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW, 383 ip->i_mount, dip); 384 return XFS_ERROR(EFSCORRUPTED); 385 } 386 ip->i_d.di_size = 0; 387 ip->i_size = 0; 388 ip->i_df.if_u2.if_rdev = be32_to_cpu(dip->di_u.di_dev); 389 break; 390 391 case S_IFREG: 392 case S_IFLNK: 393 case S_IFDIR: 394 switch (dip->di_core.di_format) { 395 case XFS_DINODE_FMT_LOCAL: 396 /* 397 * no local regular files yet 398 */ 399 if (unlikely((be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFREG)) { 400 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 401 "corrupt inode %Lu " 402 "(local format for regular file).", 403 (unsigned long long) ip->i_ino); 404 XFS_CORRUPTION_ERROR("xfs_iformat(4)", 405 XFS_ERRLEVEL_LOW, 406 ip->i_mount, dip); 407 return XFS_ERROR(EFSCORRUPTED); 408 } 409 410 di_size = be64_to_cpu(dip->di_core.di_size); 411 if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) { 412 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 413 "corrupt inode %Lu " 414 "(bad size %Ld for local inode).", 415 (unsigned long long) ip->i_ino, 416 (long long) di_size); 417 XFS_CORRUPTION_ERROR("xfs_iformat(5)", 418 XFS_ERRLEVEL_LOW, 419 ip->i_mount, dip); 420 return XFS_ERROR(EFSCORRUPTED); 421 } 422 423 size = (int)di_size; 424 error = xfs_iformat_local(ip, dip, XFS_DATA_FORK, size); 425 break; 426 case XFS_DINODE_FMT_EXTENTS: 427 error = xfs_iformat_extents(ip, dip, XFS_DATA_FORK); 428 break; 429 case XFS_DINODE_FMT_BTREE: 430 error = xfs_iformat_btree(ip, dip, XFS_DATA_FORK); 431 break; 432 default: 433 XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW, 434 ip->i_mount); 435 return XFS_ERROR(EFSCORRUPTED); 436 } 437 break; 438 439 default: 440 XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount); 441 return XFS_ERROR(EFSCORRUPTED); 442 } 443 if (error) { 444 return error; 445 } 446 if (!XFS_DFORK_Q(dip)) 447 return 0; 448 ASSERT(ip->i_afp == NULL); 449 ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 450 ip->i_afp->if_ext_max = 451 XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t); 452 switch (dip->di_core.di_aformat) { 453 case XFS_DINODE_FMT_LOCAL: 454 atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip); 455 size = be16_to_cpu(atp->hdr.totsize); 456 error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size); 457 break; 458 case XFS_DINODE_FMT_EXTENTS: 459 error = xfs_iformat_extents(ip, dip, XFS_ATTR_FORK); 460 break; 461 case XFS_DINODE_FMT_BTREE: 462 error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK); 463 break; 464 default: 465 error = XFS_ERROR(EFSCORRUPTED); 466 break; 467 } 468 if (error) { 469 kmem_zone_free(xfs_ifork_zone, ip->i_afp); 470 ip->i_afp = NULL; 471 xfs_idestroy_fork(ip, XFS_DATA_FORK); 472 } 473 return error; 474 } 475 476 /* 477 * The file is in-lined in the on-disk inode. 478 * If it fits into if_inline_data, then copy 479 * it there, otherwise allocate a buffer for it 480 * and copy the data there. Either way, set 481 * if_data to point at the data. 482 * If we allocate a buffer for the data, make 483 * sure that its size is a multiple of 4 and 484 * record the real size in i_real_bytes. 485 */ 486 STATIC int 487 xfs_iformat_local( 488 xfs_inode_t *ip, 489 xfs_dinode_t *dip, 490 int whichfork, 491 int size) 492 { 493 xfs_ifork_t *ifp; 494 int real_size; 495 496 /* 497 * If the size is unreasonable, then something 498 * is wrong and we just bail out rather than crash in 499 * kmem_alloc() or memcpy() below. 500 */ 501 if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) { 502 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 503 "corrupt inode %Lu " 504 "(bad size %d for local fork, size = %d).", 505 (unsigned long long) ip->i_ino, size, 506 XFS_DFORK_SIZE(dip, ip->i_mount, whichfork)); 507 XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW, 508 ip->i_mount, dip); 509 return XFS_ERROR(EFSCORRUPTED); 510 } 511 ifp = XFS_IFORK_PTR(ip, whichfork); 512 real_size = 0; 513 if (size == 0) 514 ifp->if_u1.if_data = NULL; 515 else if (size <= sizeof(ifp->if_u2.if_inline_data)) 516 ifp->if_u1.if_data = ifp->if_u2.if_inline_data; 517 else { 518 real_size = roundup(size, 4); 519 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP); 520 } 521 ifp->if_bytes = size; 522 ifp->if_real_bytes = real_size; 523 if (size) 524 memcpy(ifp->if_u1.if_data, XFS_DFORK_PTR(dip, whichfork), size); 525 ifp->if_flags &= ~XFS_IFEXTENTS; 526 ifp->if_flags |= XFS_IFINLINE; 527 return 0; 528 } 529 530 /* 531 * The file consists of a set of extents all 532 * of which fit into the on-disk inode. 533 * If there are few enough extents to fit into 534 * the if_inline_ext, then copy them there. 535 * Otherwise allocate a buffer for them and copy 536 * them into it. Either way, set if_extents 537 * to point at the extents. 538 */ 539 STATIC int 540 xfs_iformat_extents( 541 xfs_inode_t *ip, 542 xfs_dinode_t *dip, 543 int whichfork) 544 { 545 xfs_bmbt_rec_t *dp; 546 xfs_ifork_t *ifp; 547 int nex; 548 int size; 549 int i; 550 551 ifp = XFS_IFORK_PTR(ip, whichfork); 552 nex = XFS_DFORK_NEXTENTS(dip, whichfork); 553 size = nex * (uint)sizeof(xfs_bmbt_rec_t); 554 555 /* 556 * If the number of extents is unreasonable, then something 557 * is wrong and we just bail out rather than crash in 558 * kmem_alloc() or memcpy() below. 559 */ 560 if (unlikely(size < 0 || size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) { 561 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 562 "corrupt inode %Lu ((a)extents = %d).", 563 (unsigned long long) ip->i_ino, nex); 564 XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW, 565 ip->i_mount, dip); 566 return XFS_ERROR(EFSCORRUPTED); 567 } 568 569 ifp->if_real_bytes = 0; 570 if (nex == 0) 571 ifp->if_u1.if_extents = NULL; 572 else if (nex <= XFS_INLINE_EXTS) 573 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext; 574 else 575 xfs_iext_add(ifp, 0, nex); 576 577 ifp->if_bytes = size; 578 if (size) { 579 dp = (xfs_bmbt_rec_t *) XFS_DFORK_PTR(dip, whichfork); 580 xfs_validate_extents(ifp, nex, XFS_EXTFMT_INODE(ip)); 581 for (i = 0; i < nex; i++, dp++) { 582 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i); 583 ep->l0 = be64_to_cpu(get_unaligned(&dp->l0)); 584 ep->l1 = be64_to_cpu(get_unaligned(&dp->l1)); 585 } 586 XFS_BMAP_TRACE_EXLIST(ip, nex, whichfork); 587 if (whichfork != XFS_DATA_FORK || 588 XFS_EXTFMT_INODE(ip) == XFS_EXTFMT_NOSTATE) 589 if (unlikely(xfs_check_nostate_extents( 590 ifp, 0, nex))) { 591 XFS_ERROR_REPORT("xfs_iformat_extents(2)", 592 XFS_ERRLEVEL_LOW, 593 ip->i_mount); 594 return XFS_ERROR(EFSCORRUPTED); 595 } 596 } 597 ifp->if_flags |= XFS_IFEXTENTS; 598 return 0; 599 } 600 601 /* 602 * The file has too many extents to fit into 603 * the inode, so they are in B-tree format. 604 * Allocate a buffer for the root of the B-tree 605 * and copy the root into it. The i_extents 606 * field will remain NULL until all of the 607 * extents are read in (when they are needed). 608 */ 609 STATIC int 610 xfs_iformat_btree( 611 xfs_inode_t *ip, 612 xfs_dinode_t *dip, 613 int whichfork) 614 { 615 xfs_bmdr_block_t *dfp; 616 xfs_ifork_t *ifp; 617 /* REFERENCED */ 618 int nrecs; 619 int size; 620 621 ifp = XFS_IFORK_PTR(ip, whichfork); 622 dfp = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork); 623 size = XFS_BMAP_BROOT_SPACE(dfp); 624 nrecs = XFS_BMAP_BROOT_NUMRECS(dfp); 625 626 /* 627 * blow out if -- fork has less extents than can fit in 628 * fork (fork shouldn't be a btree format), root btree 629 * block has more records than can fit into the fork, 630 * or the number of extents is greater than the number of 631 * blocks. 632 */ 633 if (unlikely(XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max 634 || XFS_BMDR_SPACE_CALC(nrecs) > 635 XFS_DFORK_SIZE(dip, ip->i_mount, whichfork) 636 || XFS_IFORK_NEXTENTS(ip, whichfork) > ip->i_d.di_nblocks)) { 637 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount, 638 "corrupt inode %Lu (btree).", 639 (unsigned long long) ip->i_ino); 640 XFS_ERROR_REPORT("xfs_iformat_btree", XFS_ERRLEVEL_LOW, 641 ip->i_mount); 642 return XFS_ERROR(EFSCORRUPTED); 643 } 644 645 ifp->if_broot_bytes = size; 646 ifp->if_broot = kmem_alloc(size, KM_SLEEP); 647 ASSERT(ifp->if_broot != NULL); 648 /* 649 * Copy and convert from the on-disk structure 650 * to the in-memory structure. 651 */ 652 xfs_bmdr_to_bmbt(dfp, XFS_DFORK_SIZE(dip, ip->i_mount, whichfork), 653 ifp->if_broot, size); 654 ifp->if_flags &= ~XFS_IFEXTENTS; 655 ifp->if_flags |= XFS_IFBROOT; 656 657 return 0; 658 } 659 660 void 661 xfs_dinode_from_disk( 662 xfs_icdinode_t *to, 663 xfs_dinode_core_t *from) 664 { 665 to->di_magic = be16_to_cpu(from->di_magic); 666 to->di_mode = be16_to_cpu(from->di_mode); 667 to->di_version = from ->di_version; 668 to->di_format = from->di_format; 669 to->di_onlink = be16_to_cpu(from->di_onlink); 670 to->di_uid = be32_to_cpu(from->di_uid); 671 to->di_gid = be32_to_cpu(from->di_gid); 672 to->di_nlink = be32_to_cpu(from->di_nlink); 673 to->di_projid = be16_to_cpu(from->di_projid); 674 memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad)); 675 to->di_flushiter = be16_to_cpu(from->di_flushiter); 676 to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec); 677 to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec); 678 to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec); 679 to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec); 680 to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec); 681 to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec); 682 to->di_size = be64_to_cpu(from->di_size); 683 to->di_nblocks = be64_to_cpu(from->di_nblocks); 684 to->di_extsize = be32_to_cpu(from->di_extsize); 685 to->di_nextents = be32_to_cpu(from->di_nextents); 686 to->di_anextents = be16_to_cpu(from->di_anextents); 687 to->di_forkoff = from->di_forkoff; 688 to->di_aformat = from->di_aformat; 689 to->di_dmevmask = be32_to_cpu(from->di_dmevmask); 690 to->di_dmstate = be16_to_cpu(from->di_dmstate); 691 to->di_flags = be16_to_cpu(from->di_flags); 692 to->di_gen = be32_to_cpu(from->di_gen); 693 } 694 695 void 696 xfs_dinode_to_disk( 697 xfs_dinode_core_t *to, 698 xfs_icdinode_t *from) 699 { 700 to->di_magic = cpu_to_be16(from->di_magic); 701 to->di_mode = cpu_to_be16(from->di_mode); 702 to->di_version = from ->di_version; 703 to->di_format = from->di_format; 704 to->di_onlink = cpu_to_be16(from->di_onlink); 705 to->di_uid = cpu_to_be32(from->di_uid); 706 to->di_gid = cpu_to_be32(from->di_gid); 707 to->di_nlink = cpu_to_be32(from->di_nlink); 708 to->di_projid = cpu_to_be16(from->di_projid); 709 memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad)); 710 to->di_flushiter = cpu_to_be16(from->di_flushiter); 711 to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec); 712 to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec); 713 to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec); 714 to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec); 715 to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec); 716 to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec); 717 to->di_size = cpu_to_be64(from->di_size); 718 to->di_nblocks = cpu_to_be64(from->di_nblocks); 719 to->di_extsize = cpu_to_be32(from->di_extsize); 720 to->di_nextents = cpu_to_be32(from->di_nextents); 721 to->di_anextents = cpu_to_be16(from->di_anextents); 722 to->di_forkoff = from->di_forkoff; 723 to->di_aformat = from->di_aformat; 724 to->di_dmevmask = cpu_to_be32(from->di_dmevmask); 725 to->di_dmstate = cpu_to_be16(from->di_dmstate); 726 to->di_flags = cpu_to_be16(from->di_flags); 727 to->di_gen = cpu_to_be32(from->di_gen); 728 } 729 730 STATIC uint 731 _xfs_dic2xflags( 732 __uint16_t di_flags) 733 { 734 uint flags = 0; 735 736 if (di_flags & XFS_DIFLAG_ANY) { 737 if (di_flags & XFS_DIFLAG_REALTIME) 738 flags |= XFS_XFLAG_REALTIME; 739 if (di_flags & XFS_DIFLAG_PREALLOC) 740 flags |= XFS_XFLAG_PREALLOC; 741 if (di_flags & XFS_DIFLAG_IMMUTABLE) 742 flags |= XFS_XFLAG_IMMUTABLE; 743 if (di_flags & XFS_DIFLAG_APPEND) 744 flags |= XFS_XFLAG_APPEND; 745 if (di_flags & XFS_DIFLAG_SYNC) 746 flags |= XFS_XFLAG_SYNC; 747 if (di_flags & XFS_DIFLAG_NOATIME) 748 flags |= XFS_XFLAG_NOATIME; 749 if (di_flags & XFS_DIFLAG_NODUMP) 750 flags |= XFS_XFLAG_NODUMP; 751 if (di_flags & XFS_DIFLAG_RTINHERIT) 752 flags |= XFS_XFLAG_RTINHERIT; 753 if (di_flags & XFS_DIFLAG_PROJINHERIT) 754 flags |= XFS_XFLAG_PROJINHERIT; 755 if (di_flags & XFS_DIFLAG_NOSYMLINKS) 756 flags |= XFS_XFLAG_NOSYMLINKS; 757 if (di_flags & XFS_DIFLAG_EXTSIZE) 758 flags |= XFS_XFLAG_EXTSIZE; 759 if (di_flags & XFS_DIFLAG_EXTSZINHERIT) 760 flags |= XFS_XFLAG_EXTSZINHERIT; 761 if (di_flags & XFS_DIFLAG_NODEFRAG) 762 flags |= XFS_XFLAG_NODEFRAG; 763 if (di_flags & XFS_DIFLAG_FILESTREAM) 764 flags |= XFS_XFLAG_FILESTREAM; 765 } 766 767 return flags; 768 } 769 770 uint 771 xfs_ip2xflags( 772 xfs_inode_t *ip) 773 { 774 xfs_icdinode_t *dic = &ip->i_d; 775 776 return _xfs_dic2xflags(dic->di_flags) | 777 (XFS_IFORK_Q(ip) ? XFS_XFLAG_HASATTR : 0); 778 } 779 780 uint 781 xfs_dic2xflags( 782 xfs_dinode_t *dip) 783 { 784 xfs_dinode_core_t *dic = &dip->di_core; 785 786 return _xfs_dic2xflags(be16_to_cpu(dic->di_flags)) | 787 (XFS_DFORK_Q(dip) ? XFS_XFLAG_HASATTR : 0); 788 } 789 790 /* 791 * Given a mount structure and an inode number, return a pointer 792 * to a newly allocated in-core inode corresponding to the given 793 * inode number. 794 * 795 * Initialize the inode's attributes and extent pointers if it 796 * already has them (it will not if the inode has no links). 797 */ 798 int 799 xfs_iread( 800 xfs_mount_t *mp, 801 xfs_trans_t *tp, 802 xfs_ino_t ino, 803 xfs_inode_t **ipp, 804 xfs_daddr_t bno, 805 uint imap_flags) 806 { 807 xfs_buf_t *bp; 808 xfs_dinode_t *dip; 809 xfs_inode_t *ip; 810 int error; 811 812 ASSERT(xfs_inode_zone != NULL); 813 814 ip = kmem_zone_zalloc(xfs_inode_zone, KM_SLEEP); 815 ip->i_ino = ino; 816 ip->i_mount = mp; 817 atomic_set(&ip->i_iocount, 0); 818 spin_lock_init(&ip->i_flags_lock); 819 820 /* 821 * Get pointer's to the on-disk inode and the buffer containing it. 822 * If the inode number refers to a block outside the file system 823 * then xfs_itobp() will return NULL. In this case we should 824 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will 825 * know that this is a new incore inode. 826 */ 827 error = xfs_itobp(mp, tp, ip, &dip, &bp, bno, imap_flags, XFS_BUF_LOCK); 828 if (error) { 829 kmem_zone_free(xfs_inode_zone, ip); 830 return error; 831 } 832 833 /* 834 * Initialize inode's trace buffers. 835 * Do this before xfs_iformat in case it adds entries. 836 */ 837 #ifdef XFS_INODE_TRACE 838 ip->i_trace = ktrace_alloc(INODE_TRACE_SIZE, KM_SLEEP); 839 #endif 840 #ifdef XFS_BMAP_TRACE 841 ip->i_xtrace = ktrace_alloc(XFS_BMAP_KTRACE_SIZE, KM_SLEEP); 842 #endif 843 #ifdef XFS_BMBT_TRACE 844 ip->i_btrace = ktrace_alloc(XFS_BMBT_KTRACE_SIZE, KM_SLEEP); 845 #endif 846 #ifdef XFS_RW_TRACE 847 ip->i_rwtrace = ktrace_alloc(XFS_RW_KTRACE_SIZE, KM_SLEEP); 848 #endif 849 #ifdef XFS_ILOCK_TRACE 850 ip->i_lock_trace = ktrace_alloc(XFS_ILOCK_KTRACE_SIZE, KM_SLEEP); 851 #endif 852 #ifdef XFS_DIR2_TRACE 853 ip->i_dir_trace = ktrace_alloc(XFS_DIR2_KTRACE_SIZE, KM_SLEEP); 854 #endif 855 856 /* 857 * If we got something that isn't an inode it means someone 858 * (nfs or dmi) has a stale handle. 859 */ 860 if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC) { 861 kmem_zone_free(xfs_inode_zone, ip); 862 xfs_trans_brelse(tp, bp); 863 #ifdef DEBUG 864 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: " 865 "dip->di_core.di_magic (0x%x) != " 866 "XFS_DINODE_MAGIC (0x%x)", 867 be16_to_cpu(dip->di_core.di_magic), 868 XFS_DINODE_MAGIC); 869 #endif /* DEBUG */ 870 return XFS_ERROR(EINVAL); 871 } 872 873 /* 874 * If the on-disk inode is already linked to a directory 875 * entry, copy all of the inode into the in-core inode. 876 * xfs_iformat() handles copying in the inode format 877 * specific information. 878 * Otherwise, just get the truly permanent information. 879 */ 880 if (dip->di_core.di_mode) { 881 xfs_dinode_from_disk(&ip->i_d, &dip->di_core); 882 error = xfs_iformat(ip, dip); 883 if (error) { 884 kmem_zone_free(xfs_inode_zone, ip); 885 xfs_trans_brelse(tp, bp); 886 #ifdef DEBUG 887 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: " 888 "xfs_iformat() returned error %d", 889 error); 890 #endif /* DEBUG */ 891 return error; 892 } 893 } else { 894 ip->i_d.di_magic = be16_to_cpu(dip->di_core.di_magic); 895 ip->i_d.di_version = dip->di_core.di_version; 896 ip->i_d.di_gen = be32_to_cpu(dip->di_core.di_gen); 897 ip->i_d.di_flushiter = be16_to_cpu(dip->di_core.di_flushiter); 898 /* 899 * Make sure to pull in the mode here as well in 900 * case the inode is released without being used. 901 * This ensures that xfs_inactive() will see that 902 * the inode is already free and not try to mess 903 * with the uninitialized part of it. 904 */ 905 ip->i_d.di_mode = 0; 906 /* 907 * Initialize the per-fork minima and maxima for a new 908 * inode here. xfs_iformat will do it for old inodes. 909 */ 910 ip->i_df.if_ext_max = 911 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t); 912 } 913 914 INIT_LIST_HEAD(&ip->i_reclaim); 915 916 /* 917 * The inode format changed when we moved the link count and 918 * made it 32 bits long. If this is an old format inode, 919 * convert it in memory to look like a new one. If it gets 920 * flushed to disk we will convert back before flushing or 921 * logging it. We zero out the new projid field and the old link 922 * count field. We'll handle clearing the pad field (the remains 923 * of the old uuid field) when we actually convert the inode to 924 * the new format. We don't change the version number so that we 925 * can distinguish this from a real new format inode. 926 */ 927 if (ip->i_d.di_version == XFS_DINODE_VERSION_1) { 928 ip->i_d.di_nlink = ip->i_d.di_onlink; 929 ip->i_d.di_onlink = 0; 930 ip->i_d.di_projid = 0; 931 } 932 933 ip->i_delayed_blks = 0; 934 ip->i_size = ip->i_d.di_size; 935 936 /* 937 * Mark the buffer containing the inode as something to keep 938 * around for a while. This helps to keep recently accessed 939 * meta-data in-core longer. 940 */ 941 XFS_BUF_SET_REF(bp, XFS_INO_REF); 942 943 /* 944 * Use xfs_trans_brelse() to release the buffer containing the 945 * on-disk inode, because it was acquired with xfs_trans_read_buf() 946 * in xfs_itobp() above. If tp is NULL, this is just a normal 947 * brelse(). If we're within a transaction, then xfs_trans_brelse() 948 * will only release the buffer if it is not dirty within the 949 * transaction. It will be OK to release the buffer in this case, 950 * because inodes on disk are never destroyed and we will be 951 * locking the new in-core inode before putting it in the hash 952 * table where other processes can find it. Thus we don't have 953 * to worry about the inode being changed just because we released 954 * the buffer. 955 */ 956 xfs_trans_brelse(tp, bp); 957 *ipp = ip; 958 return 0; 959 } 960 961 /* 962 * Read in extents from a btree-format inode. 963 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c. 964 */ 965 int 966 xfs_iread_extents( 967 xfs_trans_t *tp, 968 xfs_inode_t *ip, 969 int whichfork) 970 { 971 int error; 972 xfs_ifork_t *ifp; 973 xfs_extnum_t nextents; 974 size_t size; 975 976 if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 977 XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW, 978 ip->i_mount); 979 return XFS_ERROR(EFSCORRUPTED); 980 } 981 nextents = XFS_IFORK_NEXTENTS(ip, whichfork); 982 size = nextents * sizeof(xfs_bmbt_rec_t); 983 ifp = XFS_IFORK_PTR(ip, whichfork); 984 985 /* 986 * We know that the size is valid (it's checked in iformat_btree) 987 */ 988 ifp->if_lastex = NULLEXTNUM; 989 ifp->if_bytes = ifp->if_real_bytes = 0; 990 ifp->if_flags |= XFS_IFEXTENTS; 991 xfs_iext_add(ifp, 0, nextents); 992 error = xfs_bmap_read_extents(tp, ip, whichfork); 993 if (error) { 994 xfs_iext_destroy(ifp); 995 ifp->if_flags &= ~XFS_IFEXTENTS; 996 return error; 997 } 998 xfs_validate_extents(ifp, nextents, XFS_EXTFMT_INODE(ip)); 999 return 0; 1000 } 1001 1002 /* 1003 * Allocate an inode on disk and return a copy of its in-core version. 1004 * The in-core inode is locked exclusively. Set mode, nlink, and rdev 1005 * appropriately within the inode. The uid and gid for the inode are 1006 * set according to the contents of the given cred structure. 1007 * 1008 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc() 1009 * has a free inode available, call xfs_iget() 1010 * to obtain the in-core version of the allocated inode. Finally, 1011 * fill in the inode and log its initial contents. In this case, 1012 * ialloc_context would be set to NULL and call_again set to false. 1013 * 1014 * If xfs_dialloc() does not have an available inode, 1015 * it will replenish its supply by doing an allocation. Since we can 1016 * only do one allocation within a transaction without deadlocks, we 1017 * must commit the current transaction before returning the inode itself. 1018 * In this case, therefore, we will set call_again to true and return. 1019 * The caller should then commit the current transaction, start a new 1020 * transaction, and call xfs_ialloc() again to actually get the inode. 1021 * 1022 * To ensure that some other process does not grab the inode that 1023 * was allocated during the first call to xfs_ialloc(), this routine 1024 * also returns the [locked] bp pointing to the head of the freelist 1025 * as ialloc_context. The caller should hold this buffer across 1026 * the commit and pass it back into this routine on the second call. 1027 * 1028 * If we are allocating quota inodes, we do not have a parent inode 1029 * to attach to or associate with (i.e. pip == NULL) because they 1030 * are not linked into the directory structure - they are attached 1031 * directly to the superblock - and so have no parent. 1032 */ 1033 int 1034 xfs_ialloc( 1035 xfs_trans_t *tp, 1036 xfs_inode_t *pip, 1037 mode_t mode, 1038 xfs_nlink_t nlink, 1039 xfs_dev_t rdev, 1040 cred_t *cr, 1041 xfs_prid_t prid, 1042 int okalloc, 1043 xfs_buf_t **ialloc_context, 1044 boolean_t *call_again, 1045 xfs_inode_t **ipp) 1046 { 1047 xfs_ino_t ino; 1048 xfs_inode_t *ip; 1049 bhv_vnode_t *vp; 1050 uint flags; 1051 int error; 1052 1053 /* 1054 * Call the space management code to pick 1055 * the on-disk inode to be allocated. 1056 */ 1057 error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc, 1058 ialloc_context, call_again, &ino); 1059 if (error != 0) { 1060 return error; 1061 } 1062 if (*call_again || ino == NULLFSINO) { 1063 *ipp = NULL; 1064 return 0; 1065 } 1066 ASSERT(*ialloc_context == NULL); 1067 1068 /* 1069 * Get the in-core inode with the lock held exclusively. 1070 * This is because we're setting fields here we need 1071 * to prevent others from looking at until we're done. 1072 */ 1073 error = xfs_trans_iget(tp->t_mountp, tp, ino, 1074 XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip); 1075 if (error != 0) { 1076 return error; 1077 } 1078 ASSERT(ip != NULL); 1079 1080 vp = XFS_ITOV(ip); 1081 ip->i_d.di_mode = (__uint16_t)mode; 1082 ip->i_d.di_onlink = 0; 1083 ip->i_d.di_nlink = nlink; 1084 ASSERT(ip->i_d.di_nlink == nlink); 1085 ip->i_d.di_uid = current_fsuid(cr); 1086 ip->i_d.di_gid = current_fsgid(cr); 1087 ip->i_d.di_projid = prid; 1088 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad)); 1089 1090 /* 1091 * If the superblock version is up to where we support new format 1092 * inodes and this is currently an old format inode, then change 1093 * the inode version number now. This way we only do the conversion 1094 * here rather than here and in the flush/logging code. 1095 */ 1096 if (xfs_sb_version_hasnlink(&tp->t_mountp->m_sb) && 1097 ip->i_d.di_version == XFS_DINODE_VERSION_1) { 1098 ip->i_d.di_version = XFS_DINODE_VERSION_2; 1099 /* 1100 * We've already zeroed the old link count, the projid field, 1101 * and the pad field. 1102 */ 1103 } 1104 1105 /* 1106 * Project ids won't be stored on disk if we are using a version 1 inode. 1107 */ 1108 if ((prid != 0) && (ip->i_d.di_version == XFS_DINODE_VERSION_1)) 1109 xfs_bump_ino_vers2(tp, ip); 1110 1111 if (pip && XFS_INHERIT_GID(pip)) { 1112 ip->i_d.di_gid = pip->i_d.di_gid; 1113 if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) { 1114 ip->i_d.di_mode |= S_ISGID; 1115 } 1116 } 1117 1118 /* 1119 * If the group ID of the new file does not match the effective group 1120 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared 1121 * (and only if the irix_sgid_inherit compatibility variable is set). 1122 */ 1123 if ((irix_sgid_inherit) && 1124 (ip->i_d.di_mode & S_ISGID) && 1125 (!in_group_p((gid_t)ip->i_d.di_gid))) { 1126 ip->i_d.di_mode &= ~S_ISGID; 1127 } 1128 1129 ip->i_d.di_size = 0; 1130 ip->i_size = 0; 1131 ip->i_d.di_nextents = 0; 1132 ASSERT(ip->i_d.di_nblocks == 0); 1133 xfs_ichgtime(ip, XFS_ICHGTIME_CHG|XFS_ICHGTIME_ACC|XFS_ICHGTIME_MOD); 1134 /* 1135 * di_gen will have been taken care of in xfs_iread. 1136 */ 1137 ip->i_d.di_extsize = 0; 1138 ip->i_d.di_dmevmask = 0; 1139 ip->i_d.di_dmstate = 0; 1140 ip->i_d.di_flags = 0; 1141 flags = XFS_ILOG_CORE; 1142 switch (mode & S_IFMT) { 1143 case S_IFIFO: 1144 case S_IFCHR: 1145 case S_IFBLK: 1146 case S_IFSOCK: 1147 ip->i_d.di_format = XFS_DINODE_FMT_DEV; 1148 ip->i_df.if_u2.if_rdev = rdev; 1149 ip->i_df.if_flags = 0; 1150 flags |= XFS_ILOG_DEV; 1151 break; 1152 case S_IFREG: 1153 if (pip && xfs_inode_is_filestream(pip)) { 1154 error = xfs_filestream_associate(pip, ip); 1155 if (error < 0) 1156 return -error; 1157 if (!error) 1158 xfs_iflags_set(ip, XFS_IFILESTREAM); 1159 } 1160 /* fall through */ 1161 case S_IFDIR: 1162 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) { 1163 uint di_flags = 0; 1164 1165 if ((mode & S_IFMT) == S_IFDIR) { 1166 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) 1167 di_flags |= XFS_DIFLAG_RTINHERIT; 1168 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) { 1169 di_flags |= XFS_DIFLAG_EXTSZINHERIT; 1170 ip->i_d.di_extsize = pip->i_d.di_extsize; 1171 } 1172 } else if ((mode & S_IFMT) == S_IFREG) { 1173 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) 1174 di_flags |= XFS_DIFLAG_REALTIME; 1175 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) { 1176 di_flags |= XFS_DIFLAG_EXTSIZE; 1177 ip->i_d.di_extsize = pip->i_d.di_extsize; 1178 } 1179 } 1180 if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) && 1181 xfs_inherit_noatime) 1182 di_flags |= XFS_DIFLAG_NOATIME; 1183 if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) && 1184 xfs_inherit_nodump) 1185 di_flags |= XFS_DIFLAG_NODUMP; 1186 if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) && 1187 xfs_inherit_sync) 1188 di_flags |= XFS_DIFLAG_SYNC; 1189 if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) && 1190 xfs_inherit_nosymlinks) 1191 di_flags |= XFS_DIFLAG_NOSYMLINKS; 1192 if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) 1193 di_flags |= XFS_DIFLAG_PROJINHERIT; 1194 if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) && 1195 xfs_inherit_nodefrag) 1196 di_flags |= XFS_DIFLAG_NODEFRAG; 1197 if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM) 1198 di_flags |= XFS_DIFLAG_FILESTREAM; 1199 ip->i_d.di_flags |= di_flags; 1200 } 1201 /* FALLTHROUGH */ 1202 case S_IFLNK: 1203 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS; 1204 ip->i_df.if_flags = XFS_IFEXTENTS; 1205 ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0; 1206 ip->i_df.if_u1.if_extents = NULL; 1207 break; 1208 default: 1209 ASSERT(0); 1210 } 1211 /* 1212 * Attribute fork settings for new inode. 1213 */ 1214 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 1215 ip->i_d.di_anextents = 0; 1216 1217 /* 1218 * Log the new values stuffed into the inode. 1219 */ 1220 xfs_trans_log_inode(tp, ip, flags); 1221 1222 /* now that we have an i_mode we can setup inode ops and unlock */ 1223 xfs_initialize_vnode(tp->t_mountp, vp, ip); 1224 1225 *ipp = ip; 1226 return 0; 1227 } 1228 1229 /* 1230 * Check to make sure that there are no blocks allocated to the 1231 * file beyond the size of the file. We don't check this for 1232 * files with fixed size extents or real time extents, but we 1233 * at least do it for regular files. 1234 */ 1235 #ifdef DEBUG 1236 void 1237 xfs_isize_check( 1238 xfs_mount_t *mp, 1239 xfs_inode_t *ip, 1240 xfs_fsize_t isize) 1241 { 1242 xfs_fileoff_t map_first; 1243 int nimaps; 1244 xfs_bmbt_irec_t imaps[2]; 1245 1246 if ((ip->i_d.di_mode & S_IFMT) != S_IFREG) 1247 return; 1248 1249 if (XFS_IS_REALTIME_INODE(ip)) 1250 return; 1251 1252 if (ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) 1253 return; 1254 1255 nimaps = 2; 1256 map_first = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize); 1257 /* 1258 * The filesystem could be shutting down, so bmapi may return 1259 * an error. 1260 */ 1261 if (xfs_bmapi(NULL, ip, map_first, 1262 (XFS_B_TO_FSB(mp, 1263 (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) - 1264 map_first), 1265 XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps, 1266 NULL, NULL)) 1267 return; 1268 ASSERT(nimaps == 1); 1269 ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK); 1270 } 1271 #endif /* DEBUG */ 1272 1273 /* 1274 * Calculate the last possible buffered byte in a file. This must 1275 * include data that was buffered beyond the EOF by the write code. 1276 * This also needs to deal with overflowing the xfs_fsize_t type 1277 * which can happen for sizes near the limit. 1278 * 1279 * We also need to take into account any blocks beyond the EOF. It 1280 * may be the case that they were buffered by a write which failed. 1281 * In that case the pages will still be in memory, but the inode size 1282 * will never have been updated. 1283 */ 1284 xfs_fsize_t 1285 xfs_file_last_byte( 1286 xfs_inode_t *ip) 1287 { 1288 xfs_mount_t *mp; 1289 xfs_fsize_t last_byte; 1290 xfs_fileoff_t last_block; 1291 xfs_fileoff_t size_last_block; 1292 int error; 1293 1294 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)); 1295 1296 mp = ip->i_mount; 1297 /* 1298 * Only check for blocks beyond the EOF if the extents have 1299 * been read in. This eliminates the need for the inode lock, 1300 * and it also saves us from looking when it really isn't 1301 * necessary. 1302 */ 1303 if (ip->i_df.if_flags & XFS_IFEXTENTS) { 1304 error = xfs_bmap_last_offset(NULL, ip, &last_block, 1305 XFS_DATA_FORK); 1306 if (error) { 1307 last_block = 0; 1308 } 1309 } else { 1310 last_block = 0; 1311 } 1312 size_last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)ip->i_size); 1313 last_block = XFS_FILEOFF_MAX(last_block, size_last_block); 1314 1315 last_byte = XFS_FSB_TO_B(mp, last_block); 1316 if (last_byte < 0) { 1317 return XFS_MAXIOFFSET(mp); 1318 } 1319 last_byte += (1 << mp->m_writeio_log); 1320 if (last_byte < 0) { 1321 return XFS_MAXIOFFSET(mp); 1322 } 1323 return last_byte; 1324 } 1325 1326 #if defined(XFS_RW_TRACE) 1327 STATIC void 1328 xfs_itrunc_trace( 1329 int tag, 1330 xfs_inode_t *ip, 1331 int flag, 1332 xfs_fsize_t new_size, 1333 xfs_off_t toss_start, 1334 xfs_off_t toss_finish) 1335 { 1336 if (ip->i_rwtrace == NULL) { 1337 return; 1338 } 1339 1340 ktrace_enter(ip->i_rwtrace, 1341 (void*)((long)tag), 1342 (void*)ip, 1343 (void*)(unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff), 1344 (void*)(unsigned long)(ip->i_d.di_size & 0xffffffff), 1345 (void*)((long)flag), 1346 (void*)(unsigned long)((new_size >> 32) & 0xffffffff), 1347 (void*)(unsigned long)(new_size & 0xffffffff), 1348 (void*)(unsigned long)((toss_start >> 32) & 0xffffffff), 1349 (void*)(unsigned long)(toss_start & 0xffffffff), 1350 (void*)(unsigned long)((toss_finish >> 32) & 0xffffffff), 1351 (void*)(unsigned long)(toss_finish & 0xffffffff), 1352 (void*)(unsigned long)current_cpu(), 1353 (void*)(unsigned long)current_pid(), 1354 (void*)NULL, 1355 (void*)NULL, 1356 (void*)NULL); 1357 } 1358 #else 1359 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish) 1360 #endif 1361 1362 /* 1363 * Start the truncation of the file to new_size. The new size 1364 * must be smaller than the current size. This routine will 1365 * clear the buffer and page caches of file data in the removed 1366 * range, and xfs_itruncate_finish() will remove the underlying 1367 * disk blocks. 1368 * 1369 * The inode must have its I/O lock locked EXCLUSIVELY, and it 1370 * must NOT have the inode lock held at all. This is because we're 1371 * calling into the buffer/page cache code and we can't hold the 1372 * inode lock when we do so. 1373 * 1374 * We need to wait for any direct I/Os in flight to complete before we 1375 * proceed with the truncate. This is needed to prevent the extents 1376 * being read or written by the direct I/Os from being removed while the 1377 * I/O is in flight as there is no other method of synchronising 1378 * direct I/O with the truncate operation. Also, because we hold 1379 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being 1380 * started until the truncate completes and drops the lock. Essentially, 1381 * the vn_iowait() call forms an I/O barrier that provides strict ordering 1382 * between direct I/Os and the truncate operation. 1383 * 1384 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE 1385 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used 1386 * in the case that the caller is locking things out of order and 1387 * may not be able to call xfs_itruncate_finish() with the inode lock 1388 * held without dropping the I/O lock. If the caller must drop the 1389 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start() 1390 * must be called again with all the same restrictions as the initial 1391 * call. 1392 */ 1393 int 1394 xfs_itruncate_start( 1395 xfs_inode_t *ip, 1396 uint flags, 1397 xfs_fsize_t new_size) 1398 { 1399 xfs_fsize_t last_byte; 1400 xfs_off_t toss_start; 1401 xfs_mount_t *mp; 1402 bhv_vnode_t *vp; 1403 int error = 0; 1404 1405 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 1406 ASSERT((new_size == 0) || (new_size <= ip->i_size)); 1407 ASSERT((flags == XFS_ITRUNC_DEFINITE) || 1408 (flags == XFS_ITRUNC_MAYBE)); 1409 1410 mp = ip->i_mount; 1411 vp = XFS_ITOV(ip); 1412 1413 /* wait for the completion of any pending DIOs */ 1414 if (new_size < ip->i_size) 1415 vn_iowait(ip); 1416 1417 /* 1418 * Call toss_pages or flushinval_pages to get rid of pages 1419 * overlapping the region being removed. We have to use 1420 * the less efficient flushinval_pages in the case that the 1421 * caller may not be able to finish the truncate without 1422 * dropping the inode's I/O lock. Make sure 1423 * to catch any pages brought in by buffers overlapping 1424 * the EOF by searching out beyond the isize by our 1425 * block size. We round new_size up to a block boundary 1426 * so that we don't toss things on the same block as 1427 * new_size but before it. 1428 * 1429 * Before calling toss_page or flushinval_pages, make sure to 1430 * call remapf() over the same region if the file is mapped. 1431 * This frees up mapped file references to the pages in the 1432 * given range and for the flushinval_pages case it ensures 1433 * that we get the latest mapped changes flushed out. 1434 */ 1435 toss_start = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size); 1436 toss_start = XFS_FSB_TO_B(mp, toss_start); 1437 if (toss_start < 0) { 1438 /* 1439 * The place to start tossing is beyond our maximum 1440 * file size, so there is no way that the data extended 1441 * out there. 1442 */ 1443 return 0; 1444 } 1445 last_byte = xfs_file_last_byte(ip); 1446 xfs_itrunc_trace(XFS_ITRUNC_START, ip, flags, new_size, toss_start, 1447 last_byte); 1448 if (last_byte > toss_start) { 1449 if (flags & XFS_ITRUNC_DEFINITE) { 1450 xfs_tosspages(ip, toss_start, 1451 -1, FI_REMAPF_LOCKED); 1452 } else { 1453 error = xfs_flushinval_pages(ip, toss_start, 1454 -1, FI_REMAPF_LOCKED); 1455 } 1456 } 1457 1458 #ifdef DEBUG 1459 if (new_size == 0) { 1460 ASSERT(VN_CACHED(vp) == 0); 1461 } 1462 #endif 1463 return error; 1464 } 1465 1466 /* 1467 * Shrink the file to the given new_size. The new size must be smaller than 1468 * the current size. This will free up the underlying blocks in the removed 1469 * range after a call to xfs_itruncate_start() or xfs_atruncate_start(). 1470 * 1471 * The transaction passed to this routine must have made a permanent log 1472 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the 1473 * given transaction and start new ones, so make sure everything involved in 1474 * the transaction is tidy before calling here. Some transaction will be 1475 * returned to the caller to be committed. The incoming transaction must 1476 * already include the inode, and both inode locks must be held exclusively. 1477 * The inode must also be "held" within the transaction. On return the inode 1478 * will be "held" within the returned transaction. This routine does NOT 1479 * require any disk space to be reserved for it within the transaction. 1480 * 1481 * The fork parameter must be either xfs_attr_fork or xfs_data_fork, and it 1482 * indicates the fork which is to be truncated. For the attribute fork we only 1483 * support truncation to size 0. 1484 * 1485 * We use the sync parameter to indicate whether or not the first transaction 1486 * we perform might have to be synchronous. For the attr fork, it needs to be 1487 * so if the unlink of the inode is not yet known to be permanent in the log. 1488 * This keeps us from freeing and reusing the blocks of the attribute fork 1489 * before the unlink of the inode becomes permanent. 1490 * 1491 * For the data fork, we normally have to run synchronously if we're being 1492 * called out of the inactive path or we're being called out of the create path 1493 * where we're truncating an existing file. Either way, the truncate needs to 1494 * be sync so blocks don't reappear in the file with altered data in case of a 1495 * crash. wsync filesystems can run the first case async because anything that 1496 * shrinks the inode has to run sync so by the time we're called here from 1497 * inactive, the inode size is permanently set to 0. 1498 * 1499 * Calls from the truncate path always need to be sync unless we're in a wsync 1500 * filesystem and the file has already been unlinked. 1501 * 1502 * The caller is responsible for correctly setting the sync parameter. It gets 1503 * too hard for us to guess here which path we're being called out of just 1504 * based on inode state. 1505 * 1506 * If we get an error, we must return with the inode locked and linked into the 1507 * current transaction. This keeps things simple for the higher level code, 1508 * because it always knows that the inode is locked and held in the transaction 1509 * that returns to it whether errors occur or not. We don't mark the inode 1510 * dirty on error so that transactions can be easily aborted if possible. 1511 */ 1512 int 1513 xfs_itruncate_finish( 1514 xfs_trans_t **tp, 1515 xfs_inode_t *ip, 1516 xfs_fsize_t new_size, 1517 int fork, 1518 int sync) 1519 { 1520 xfs_fsblock_t first_block; 1521 xfs_fileoff_t first_unmap_block; 1522 xfs_fileoff_t last_block; 1523 xfs_filblks_t unmap_len=0; 1524 xfs_mount_t *mp; 1525 xfs_trans_t *ntp; 1526 int done; 1527 int committed; 1528 xfs_bmap_free_t free_list; 1529 int error; 1530 1531 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL)); 1532 ASSERT((new_size == 0) || (new_size <= ip->i_size)); 1533 ASSERT(*tp != NULL); 1534 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); 1535 ASSERT(ip->i_transp == *tp); 1536 ASSERT(ip->i_itemp != NULL); 1537 ASSERT(ip->i_itemp->ili_flags & XFS_ILI_HOLD); 1538 1539 1540 ntp = *tp; 1541 mp = (ntp)->t_mountp; 1542 ASSERT(! XFS_NOT_DQATTACHED(mp, ip)); 1543 1544 /* 1545 * We only support truncating the entire attribute fork. 1546 */ 1547 if (fork == XFS_ATTR_FORK) { 1548 new_size = 0LL; 1549 } 1550 first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size); 1551 xfs_itrunc_trace(XFS_ITRUNC_FINISH1, ip, 0, new_size, 0, 0); 1552 /* 1553 * The first thing we do is set the size to new_size permanently 1554 * on disk. This way we don't have to worry about anyone ever 1555 * being able to look at the data being freed even in the face 1556 * of a crash. What we're getting around here is the case where 1557 * we free a block, it is allocated to another file, it is written 1558 * to, and then we crash. If the new data gets written to the 1559 * file but the log buffers containing the free and reallocation 1560 * don't, then we'd end up with garbage in the blocks being freed. 1561 * As long as we make the new_size permanent before actually 1562 * freeing any blocks it doesn't matter if they get writtten to. 1563 * 1564 * The callers must signal into us whether or not the size 1565 * setting here must be synchronous. There are a few cases 1566 * where it doesn't have to be synchronous. Those cases 1567 * occur if the file is unlinked and we know the unlink is 1568 * permanent or if the blocks being truncated are guaranteed 1569 * to be beyond the inode eof (regardless of the link count) 1570 * and the eof value is permanent. Both of these cases occur 1571 * only on wsync-mounted filesystems. In those cases, we're 1572 * guaranteed that no user will ever see the data in the blocks 1573 * that are being truncated so the truncate can run async. 1574 * In the free beyond eof case, the file may wind up with 1575 * more blocks allocated to it than it needs if we crash 1576 * and that won't get fixed until the next time the file 1577 * is re-opened and closed but that's ok as that shouldn't 1578 * be too many blocks. 1579 * 1580 * However, we can't just make all wsync xactions run async 1581 * because there's one call out of the create path that needs 1582 * to run sync where it's truncating an existing file to size 1583 * 0 whose size is > 0. 1584 * 1585 * It's probably possible to come up with a test in this 1586 * routine that would correctly distinguish all the above 1587 * cases from the values of the function parameters and the 1588 * inode state but for sanity's sake, I've decided to let the 1589 * layers above just tell us. It's simpler to correctly figure 1590 * out in the layer above exactly under what conditions we 1591 * can run async and I think it's easier for others read and 1592 * follow the logic in case something has to be changed. 1593 * cscope is your friend -- rcc. 1594 * 1595 * The attribute fork is much simpler. 1596 * 1597 * For the attribute fork we allow the caller to tell us whether 1598 * the unlink of the inode that led to this call is yet permanent 1599 * in the on disk log. If it is not and we will be freeing extents 1600 * in this inode then we make the first transaction synchronous 1601 * to make sure that the unlink is permanent by the time we free 1602 * the blocks. 1603 */ 1604 if (fork == XFS_DATA_FORK) { 1605 if (ip->i_d.di_nextents > 0) { 1606 /* 1607 * If we are not changing the file size then do 1608 * not update the on-disk file size - we may be 1609 * called from xfs_inactive_free_eofblocks(). If we 1610 * update the on-disk file size and then the system 1611 * crashes before the contents of the file are 1612 * flushed to disk then the files may be full of 1613 * holes (ie NULL files bug). 1614 */ 1615 if (ip->i_size != new_size) { 1616 ip->i_d.di_size = new_size; 1617 ip->i_size = new_size; 1618 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE); 1619 } 1620 } 1621 } else if (sync) { 1622 ASSERT(!(mp->m_flags & XFS_MOUNT_WSYNC)); 1623 if (ip->i_d.di_anextents > 0) 1624 xfs_trans_set_sync(ntp); 1625 } 1626 ASSERT(fork == XFS_DATA_FORK || 1627 (fork == XFS_ATTR_FORK && 1628 ((sync && !(mp->m_flags & XFS_MOUNT_WSYNC)) || 1629 (sync == 0 && (mp->m_flags & XFS_MOUNT_WSYNC))))); 1630 1631 /* 1632 * Since it is possible for space to become allocated beyond 1633 * the end of the file (in a crash where the space is allocated 1634 * but the inode size is not yet updated), simply remove any 1635 * blocks which show up between the new EOF and the maximum 1636 * possible file size. If the first block to be removed is 1637 * beyond the maximum file size (ie it is the same as last_block), 1638 * then there is nothing to do. 1639 */ 1640 last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp)); 1641 ASSERT(first_unmap_block <= last_block); 1642 done = 0; 1643 if (last_block == first_unmap_block) { 1644 done = 1; 1645 } else { 1646 unmap_len = last_block - first_unmap_block + 1; 1647 } 1648 while (!done) { 1649 /* 1650 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi() 1651 * will tell us whether it freed the entire range or 1652 * not. If this is a synchronous mount (wsync), 1653 * then we can tell bunmapi to keep all the 1654 * transactions asynchronous since the unlink 1655 * transaction that made this inode inactive has 1656 * already hit the disk. There's no danger of 1657 * the freed blocks being reused, there being a 1658 * crash, and the reused blocks suddenly reappearing 1659 * in this file with garbage in them once recovery 1660 * runs. 1661 */ 1662 XFS_BMAP_INIT(&free_list, &first_block); 1663 error = xfs_bunmapi(ntp, ip, 1664 first_unmap_block, unmap_len, 1665 XFS_BMAPI_AFLAG(fork) | 1666 (sync ? 0 : XFS_BMAPI_ASYNC), 1667 XFS_ITRUNC_MAX_EXTENTS, 1668 &first_block, &free_list, 1669 NULL, &done); 1670 if (error) { 1671 /* 1672 * If the bunmapi call encounters an error, 1673 * return to the caller where the transaction 1674 * can be properly aborted. We just need to 1675 * make sure we're not holding any resources 1676 * that we were not when we came in. 1677 */ 1678 xfs_bmap_cancel(&free_list); 1679 return error; 1680 } 1681 1682 /* 1683 * Duplicate the transaction that has the permanent 1684 * reservation and commit the old transaction. 1685 */ 1686 error = xfs_bmap_finish(tp, &free_list, &committed); 1687 ntp = *tp; 1688 if (committed) { 1689 /* link the inode into the next xact in the chain */ 1690 xfs_trans_ijoin(ntp, ip, 1691 XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 1692 xfs_trans_ihold(ntp, ip); 1693 } 1694 1695 if (error) { 1696 /* 1697 * If the bmap finish call encounters an error, return 1698 * to the caller where the transaction can be properly 1699 * aborted. We just need to make sure we're not 1700 * holding any resources that we were not when we came 1701 * in. 1702 * 1703 * Aborting from this point might lose some blocks in 1704 * the file system, but oh well. 1705 */ 1706 xfs_bmap_cancel(&free_list); 1707 return error; 1708 } 1709 1710 if (committed) { 1711 /* 1712 * Mark the inode dirty so it will be logged and 1713 * moved forward in the log as part of every commit. 1714 */ 1715 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE); 1716 } 1717 1718 ntp = xfs_trans_dup(ntp); 1719 error = xfs_trans_commit(*tp, 0); 1720 *tp = ntp; 1721 1722 /* link the inode into the next transaction in the chain */ 1723 xfs_trans_ijoin(ntp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 1724 xfs_trans_ihold(ntp, ip); 1725 1726 if (!error) 1727 error = xfs_trans_reserve(ntp, 0, 1728 XFS_ITRUNCATE_LOG_RES(mp), 0, 1729 XFS_TRANS_PERM_LOG_RES, 1730 XFS_ITRUNCATE_LOG_COUNT); 1731 if (error) 1732 return error; 1733 } 1734 /* 1735 * Only update the size in the case of the data fork, but 1736 * always re-log the inode so that our permanent transaction 1737 * can keep on rolling it forward in the log. 1738 */ 1739 if (fork == XFS_DATA_FORK) { 1740 xfs_isize_check(mp, ip, new_size); 1741 /* 1742 * If we are not changing the file size then do 1743 * not update the on-disk file size - we may be 1744 * called from xfs_inactive_free_eofblocks(). If we 1745 * update the on-disk file size and then the system 1746 * crashes before the contents of the file are 1747 * flushed to disk then the files may be full of 1748 * holes (ie NULL files bug). 1749 */ 1750 if (ip->i_size != new_size) { 1751 ip->i_d.di_size = new_size; 1752 ip->i_size = new_size; 1753 } 1754 } 1755 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE); 1756 ASSERT((new_size != 0) || 1757 (fork == XFS_ATTR_FORK) || 1758 (ip->i_delayed_blks == 0)); 1759 ASSERT((new_size != 0) || 1760 (fork == XFS_ATTR_FORK) || 1761 (ip->i_d.di_nextents == 0)); 1762 xfs_itrunc_trace(XFS_ITRUNC_FINISH2, ip, 0, new_size, 0, 0); 1763 return 0; 1764 } 1765 1766 1767 /* 1768 * xfs_igrow_start 1769 * 1770 * Do the first part of growing a file: zero any data in the last 1771 * block that is beyond the old EOF. We need to do this before 1772 * the inode is joined to the transaction to modify the i_size. 1773 * That way we can drop the inode lock and call into the buffer 1774 * cache to get the buffer mapping the EOF. 1775 */ 1776 int 1777 xfs_igrow_start( 1778 xfs_inode_t *ip, 1779 xfs_fsize_t new_size, 1780 cred_t *credp) 1781 { 1782 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL)); 1783 ASSERT(new_size > ip->i_size); 1784 1785 /* 1786 * Zero any pages that may have been created by 1787 * xfs_write_file() beyond the end of the file 1788 * and any blocks between the old and new file sizes. 1789 */ 1790 return xfs_zero_eof(ip, new_size, ip->i_size); 1791 } 1792 1793 /* 1794 * xfs_igrow_finish 1795 * 1796 * This routine is called to extend the size of a file. 1797 * The inode must have both the iolock and the ilock locked 1798 * for update and it must be a part of the current transaction. 1799 * The xfs_igrow_start() function must have been called previously. 1800 * If the change_flag is not zero, the inode change timestamp will 1801 * be updated. 1802 */ 1803 void 1804 xfs_igrow_finish( 1805 xfs_trans_t *tp, 1806 xfs_inode_t *ip, 1807 xfs_fsize_t new_size, 1808 int change_flag) 1809 { 1810 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL)); 1811 ASSERT(ip->i_transp == tp); 1812 ASSERT(new_size > ip->i_size); 1813 1814 /* 1815 * Update the file size. Update the inode change timestamp 1816 * if change_flag set. 1817 */ 1818 ip->i_d.di_size = new_size; 1819 ip->i_size = new_size; 1820 if (change_flag) 1821 xfs_ichgtime(ip, XFS_ICHGTIME_CHG); 1822 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 1823 1824 } 1825 1826 1827 /* 1828 * This is called when the inode's link count goes to 0. 1829 * We place the on-disk inode on a list in the AGI. It 1830 * will be pulled from this list when the inode is freed. 1831 */ 1832 int 1833 xfs_iunlink( 1834 xfs_trans_t *tp, 1835 xfs_inode_t *ip) 1836 { 1837 xfs_mount_t *mp; 1838 xfs_agi_t *agi; 1839 xfs_dinode_t *dip; 1840 xfs_buf_t *agibp; 1841 xfs_buf_t *ibp; 1842 xfs_agnumber_t agno; 1843 xfs_daddr_t agdaddr; 1844 xfs_agino_t agino; 1845 short bucket_index; 1846 int offset; 1847 int error; 1848 int agi_ok; 1849 1850 ASSERT(ip->i_d.di_nlink == 0); 1851 ASSERT(ip->i_d.di_mode != 0); 1852 ASSERT(ip->i_transp == tp); 1853 1854 mp = tp->t_mountp; 1855 1856 agno = XFS_INO_TO_AGNO(mp, ip->i_ino); 1857 agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)); 1858 1859 /* 1860 * Get the agi buffer first. It ensures lock ordering 1861 * on the list. 1862 */ 1863 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr, 1864 XFS_FSS_TO_BB(mp, 1), 0, &agibp); 1865 if (error) 1866 return error; 1867 1868 /* 1869 * Validate the magic number of the agi block. 1870 */ 1871 agi = XFS_BUF_TO_AGI(agibp); 1872 agi_ok = 1873 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC && 1874 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum)); 1875 if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK, 1876 XFS_RANDOM_IUNLINK))) { 1877 XFS_CORRUPTION_ERROR("xfs_iunlink", XFS_ERRLEVEL_LOW, mp, agi); 1878 xfs_trans_brelse(tp, agibp); 1879 return XFS_ERROR(EFSCORRUPTED); 1880 } 1881 /* 1882 * Get the index into the agi hash table for the 1883 * list this inode will go on. 1884 */ 1885 agino = XFS_INO_TO_AGINO(mp, ip->i_ino); 1886 ASSERT(agino != 0); 1887 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS; 1888 ASSERT(agi->agi_unlinked[bucket_index]); 1889 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino); 1890 1891 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO) { 1892 /* 1893 * There is already another inode in the bucket we need 1894 * to add ourselves to. Add us at the front of the list. 1895 * Here we put the head pointer into our next pointer, 1896 * and then we fall through to point the head at us. 1897 */ 1898 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK); 1899 if (error) 1900 return error; 1901 1902 ASSERT(be32_to_cpu(dip->di_next_unlinked) == NULLAGINO); 1903 /* both on-disk, don't endian flip twice */ 1904 dip->di_next_unlinked = agi->agi_unlinked[bucket_index]; 1905 offset = ip->i_boffset + 1906 offsetof(xfs_dinode_t, di_next_unlinked); 1907 xfs_trans_inode_buf(tp, ibp); 1908 xfs_trans_log_buf(tp, ibp, offset, 1909 (offset + sizeof(xfs_agino_t) - 1)); 1910 xfs_inobp_check(mp, ibp); 1911 } 1912 1913 /* 1914 * Point the bucket head pointer at the inode being inserted. 1915 */ 1916 ASSERT(agino != 0); 1917 agi->agi_unlinked[bucket_index] = cpu_to_be32(agino); 1918 offset = offsetof(xfs_agi_t, agi_unlinked) + 1919 (sizeof(xfs_agino_t) * bucket_index); 1920 xfs_trans_log_buf(tp, agibp, offset, 1921 (offset + sizeof(xfs_agino_t) - 1)); 1922 return 0; 1923 } 1924 1925 /* 1926 * Pull the on-disk inode from the AGI unlinked list. 1927 */ 1928 STATIC int 1929 xfs_iunlink_remove( 1930 xfs_trans_t *tp, 1931 xfs_inode_t *ip) 1932 { 1933 xfs_ino_t next_ino; 1934 xfs_mount_t *mp; 1935 xfs_agi_t *agi; 1936 xfs_dinode_t *dip; 1937 xfs_buf_t *agibp; 1938 xfs_buf_t *ibp; 1939 xfs_agnumber_t agno; 1940 xfs_daddr_t agdaddr; 1941 xfs_agino_t agino; 1942 xfs_agino_t next_agino; 1943 xfs_buf_t *last_ibp; 1944 xfs_dinode_t *last_dip = NULL; 1945 short bucket_index; 1946 int offset, last_offset = 0; 1947 int error; 1948 int agi_ok; 1949 1950 /* 1951 * First pull the on-disk inode from the AGI unlinked list. 1952 */ 1953 mp = tp->t_mountp; 1954 1955 agno = XFS_INO_TO_AGNO(mp, ip->i_ino); 1956 agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)); 1957 1958 /* 1959 * Get the agi buffer first. It ensures lock ordering 1960 * on the list. 1961 */ 1962 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr, 1963 XFS_FSS_TO_BB(mp, 1), 0, &agibp); 1964 if (error) { 1965 cmn_err(CE_WARN, 1966 "xfs_iunlink_remove: xfs_trans_read_buf() returned an error %d on %s. Returning error.", 1967 error, mp->m_fsname); 1968 return error; 1969 } 1970 /* 1971 * Validate the magic number of the agi block. 1972 */ 1973 agi = XFS_BUF_TO_AGI(agibp); 1974 agi_ok = 1975 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC && 1976 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum)); 1977 if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK_REMOVE, 1978 XFS_RANDOM_IUNLINK_REMOVE))) { 1979 XFS_CORRUPTION_ERROR("xfs_iunlink_remove", XFS_ERRLEVEL_LOW, 1980 mp, agi); 1981 xfs_trans_brelse(tp, agibp); 1982 cmn_err(CE_WARN, 1983 "xfs_iunlink_remove: XFS_TEST_ERROR() returned an error on %s. Returning EFSCORRUPTED.", 1984 mp->m_fsname); 1985 return XFS_ERROR(EFSCORRUPTED); 1986 } 1987 /* 1988 * Get the index into the agi hash table for the 1989 * list this inode will go on. 1990 */ 1991 agino = XFS_INO_TO_AGINO(mp, ip->i_ino); 1992 ASSERT(agino != 0); 1993 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS; 1994 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO); 1995 ASSERT(agi->agi_unlinked[bucket_index]); 1996 1997 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) { 1998 /* 1999 * We're at the head of the list. Get the inode's 2000 * on-disk buffer to see if there is anyone after us 2001 * on the list. Only modify our next pointer if it 2002 * is not already NULLAGINO. This saves us the overhead 2003 * of dealing with the buffer when there is no need to 2004 * change it. 2005 */ 2006 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK); 2007 if (error) { 2008 cmn_err(CE_WARN, 2009 "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.", 2010 error, mp->m_fsname); 2011 return error; 2012 } 2013 next_agino = be32_to_cpu(dip->di_next_unlinked); 2014 ASSERT(next_agino != 0); 2015 if (next_agino != NULLAGINO) { 2016 dip->di_next_unlinked = cpu_to_be32(NULLAGINO); 2017 offset = ip->i_boffset + 2018 offsetof(xfs_dinode_t, di_next_unlinked); 2019 xfs_trans_inode_buf(tp, ibp); 2020 xfs_trans_log_buf(tp, ibp, offset, 2021 (offset + sizeof(xfs_agino_t) - 1)); 2022 xfs_inobp_check(mp, ibp); 2023 } else { 2024 xfs_trans_brelse(tp, ibp); 2025 } 2026 /* 2027 * Point the bucket head pointer at the next inode. 2028 */ 2029 ASSERT(next_agino != 0); 2030 ASSERT(next_agino != agino); 2031 agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino); 2032 offset = offsetof(xfs_agi_t, agi_unlinked) + 2033 (sizeof(xfs_agino_t) * bucket_index); 2034 xfs_trans_log_buf(tp, agibp, offset, 2035 (offset + sizeof(xfs_agino_t) - 1)); 2036 } else { 2037 /* 2038 * We need to search the list for the inode being freed. 2039 */ 2040 next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]); 2041 last_ibp = NULL; 2042 while (next_agino != agino) { 2043 /* 2044 * If the last inode wasn't the one pointing to 2045 * us, then release its buffer since we're not 2046 * going to do anything with it. 2047 */ 2048 if (last_ibp != NULL) { 2049 xfs_trans_brelse(tp, last_ibp); 2050 } 2051 next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino); 2052 error = xfs_inotobp(mp, tp, next_ino, &last_dip, 2053 &last_ibp, &last_offset); 2054 if (error) { 2055 cmn_err(CE_WARN, 2056 "xfs_iunlink_remove: xfs_inotobp() returned an error %d on %s. Returning error.", 2057 error, mp->m_fsname); 2058 return error; 2059 } 2060 next_agino = be32_to_cpu(last_dip->di_next_unlinked); 2061 ASSERT(next_agino != NULLAGINO); 2062 ASSERT(next_agino != 0); 2063 } 2064 /* 2065 * Now last_ibp points to the buffer previous to us on 2066 * the unlinked list. Pull us from the list. 2067 */ 2068 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK); 2069 if (error) { 2070 cmn_err(CE_WARN, 2071 "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.", 2072 error, mp->m_fsname); 2073 return error; 2074 } 2075 next_agino = be32_to_cpu(dip->di_next_unlinked); 2076 ASSERT(next_agino != 0); 2077 ASSERT(next_agino != agino); 2078 if (next_agino != NULLAGINO) { 2079 dip->di_next_unlinked = cpu_to_be32(NULLAGINO); 2080 offset = ip->i_boffset + 2081 offsetof(xfs_dinode_t, di_next_unlinked); 2082 xfs_trans_inode_buf(tp, ibp); 2083 xfs_trans_log_buf(tp, ibp, offset, 2084 (offset + sizeof(xfs_agino_t) - 1)); 2085 xfs_inobp_check(mp, ibp); 2086 } else { 2087 xfs_trans_brelse(tp, ibp); 2088 } 2089 /* 2090 * Point the previous inode on the list to the next inode. 2091 */ 2092 last_dip->di_next_unlinked = cpu_to_be32(next_agino); 2093 ASSERT(next_agino != 0); 2094 offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked); 2095 xfs_trans_inode_buf(tp, last_ibp); 2096 xfs_trans_log_buf(tp, last_ibp, offset, 2097 (offset + sizeof(xfs_agino_t) - 1)); 2098 xfs_inobp_check(mp, last_ibp); 2099 } 2100 return 0; 2101 } 2102 2103 STATIC void 2104 xfs_ifree_cluster( 2105 xfs_inode_t *free_ip, 2106 xfs_trans_t *tp, 2107 xfs_ino_t inum) 2108 { 2109 xfs_mount_t *mp = free_ip->i_mount; 2110 int blks_per_cluster; 2111 int nbufs; 2112 int ninodes; 2113 int i, j, found, pre_flushed; 2114 xfs_daddr_t blkno; 2115 xfs_buf_t *bp; 2116 xfs_inode_t *ip, **ip_found; 2117 xfs_inode_log_item_t *iip; 2118 xfs_log_item_t *lip; 2119 xfs_perag_t *pag = xfs_get_perag(mp, inum); 2120 2121 if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) { 2122 blks_per_cluster = 1; 2123 ninodes = mp->m_sb.sb_inopblock; 2124 nbufs = XFS_IALLOC_BLOCKS(mp); 2125 } else { 2126 blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) / 2127 mp->m_sb.sb_blocksize; 2128 ninodes = blks_per_cluster * mp->m_sb.sb_inopblock; 2129 nbufs = XFS_IALLOC_BLOCKS(mp) / blks_per_cluster; 2130 } 2131 2132 ip_found = kmem_alloc(ninodes * sizeof(xfs_inode_t *), KM_NOFS); 2133 2134 for (j = 0; j < nbufs; j++, inum += ninodes) { 2135 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum), 2136 XFS_INO_TO_AGBNO(mp, inum)); 2137 2138 2139 /* 2140 * Look for each inode in memory and attempt to lock it, 2141 * we can be racing with flush and tail pushing here. 2142 * any inode we get the locks on, add to an array of 2143 * inode items to process later. 2144 * 2145 * The get the buffer lock, we could beat a flush 2146 * or tail pushing thread to the lock here, in which 2147 * case they will go looking for the inode buffer 2148 * and fail, we need some other form of interlock 2149 * here. 2150 */ 2151 found = 0; 2152 for (i = 0; i < ninodes; i++) { 2153 read_lock(&pag->pag_ici_lock); 2154 ip = radix_tree_lookup(&pag->pag_ici_root, 2155 XFS_INO_TO_AGINO(mp, (inum + i))); 2156 2157 /* Inode not in memory or we found it already, 2158 * nothing to do 2159 */ 2160 if (!ip || xfs_iflags_test(ip, XFS_ISTALE)) { 2161 read_unlock(&pag->pag_ici_lock); 2162 continue; 2163 } 2164 2165 if (xfs_inode_clean(ip)) { 2166 read_unlock(&pag->pag_ici_lock); 2167 continue; 2168 } 2169 2170 /* If we can get the locks then add it to the 2171 * list, otherwise by the time we get the bp lock 2172 * below it will already be attached to the 2173 * inode buffer. 2174 */ 2175 2176 /* This inode will already be locked - by us, lets 2177 * keep it that way. 2178 */ 2179 2180 if (ip == free_ip) { 2181 if (xfs_iflock_nowait(ip)) { 2182 xfs_iflags_set(ip, XFS_ISTALE); 2183 if (xfs_inode_clean(ip)) { 2184 xfs_ifunlock(ip); 2185 } else { 2186 ip_found[found++] = ip; 2187 } 2188 } 2189 read_unlock(&pag->pag_ici_lock); 2190 continue; 2191 } 2192 2193 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) { 2194 if (xfs_iflock_nowait(ip)) { 2195 xfs_iflags_set(ip, XFS_ISTALE); 2196 2197 if (xfs_inode_clean(ip)) { 2198 xfs_ifunlock(ip); 2199 xfs_iunlock(ip, XFS_ILOCK_EXCL); 2200 } else { 2201 ip_found[found++] = ip; 2202 } 2203 } else { 2204 xfs_iunlock(ip, XFS_ILOCK_EXCL); 2205 } 2206 } 2207 read_unlock(&pag->pag_ici_lock); 2208 } 2209 2210 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno, 2211 mp->m_bsize * blks_per_cluster, 2212 XFS_BUF_LOCK); 2213 2214 pre_flushed = 0; 2215 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *); 2216 while (lip) { 2217 if (lip->li_type == XFS_LI_INODE) { 2218 iip = (xfs_inode_log_item_t *)lip; 2219 ASSERT(iip->ili_logged == 1); 2220 lip->li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done; 2221 spin_lock(&mp->m_ail_lock); 2222 iip->ili_flush_lsn = iip->ili_item.li_lsn; 2223 spin_unlock(&mp->m_ail_lock); 2224 xfs_iflags_set(iip->ili_inode, XFS_ISTALE); 2225 pre_flushed++; 2226 } 2227 lip = lip->li_bio_list; 2228 } 2229 2230 for (i = 0; i < found; i++) { 2231 ip = ip_found[i]; 2232 iip = ip->i_itemp; 2233 2234 if (!iip) { 2235 ip->i_update_core = 0; 2236 xfs_ifunlock(ip); 2237 xfs_iunlock(ip, XFS_ILOCK_EXCL); 2238 continue; 2239 } 2240 2241 iip->ili_last_fields = iip->ili_format.ilf_fields; 2242 iip->ili_format.ilf_fields = 0; 2243 iip->ili_logged = 1; 2244 spin_lock(&mp->m_ail_lock); 2245 iip->ili_flush_lsn = iip->ili_item.li_lsn; 2246 spin_unlock(&mp->m_ail_lock); 2247 2248 xfs_buf_attach_iodone(bp, 2249 (void(*)(xfs_buf_t*,xfs_log_item_t*)) 2250 xfs_istale_done, (xfs_log_item_t *)iip); 2251 if (ip != free_ip) { 2252 xfs_iunlock(ip, XFS_ILOCK_EXCL); 2253 } 2254 } 2255 2256 if (found || pre_flushed) 2257 xfs_trans_stale_inode_buf(tp, bp); 2258 xfs_trans_binval(tp, bp); 2259 } 2260 2261 kmem_free(ip_found, ninodes * sizeof(xfs_inode_t *)); 2262 xfs_put_perag(mp, pag); 2263 } 2264 2265 /* 2266 * This is called to return an inode to the inode free list. 2267 * The inode should already be truncated to 0 length and have 2268 * no pages associated with it. This routine also assumes that 2269 * the inode is already a part of the transaction. 2270 * 2271 * The on-disk copy of the inode will have been added to the list 2272 * of unlinked inodes in the AGI. We need to remove the inode from 2273 * that list atomically with respect to freeing it here. 2274 */ 2275 int 2276 xfs_ifree( 2277 xfs_trans_t *tp, 2278 xfs_inode_t *ip, 2279 xfs_bmap_free_t *flist) 2280 { 2281 int error; 2282 int delete; 2283 xfs_ino_t first_ino; 2284 xfs_dinode_t *dip; 2285 xfs_buf_t *ibp; 2286 2287 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 2288 ASSERT(ip->i_transp == tp); 2289 ASSERT(ip->i_d.di_nlink == 0); 2290 ASSERT(ip->i_d.di_nextents == 0); 2291 ASSERT(ip->i_d.di_anextents == 0); 2292 ASSERT((ip->i_d.di_size == 0 && ip->i_size == 0) || 2293 ((ip->i_d.di_mode & S_IFMT) != S_IFREG)); 2294 ASSERT(ip->i_d.di_nblocks == 0); 2295 2296 /* 2297 * Pull the on-disk inode from the AGI unlinked list. 2298 */ 2299 error = xfs_iunlink_remove(tp, ip); 2300 if (error != 0) { 2301 return error; 2302 } 2303 2304 error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino); 2305 if (error != 0) { 2306 return error; 2307 } 2308 ip->i_d.di_mode = 0; /* mark incore inode as free */ 2309 ip->i_d.di_flags = 0; 2310 ip->i_d.di_dmevmask = 0; 2311 ip->i_d.di_forkoff = 0; /* mark the attr fork not in use */ 2312 ip->i_df.if_ext_max = 2313 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t); 2314 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS; 2315 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 2316 /* 2317 * Bump the generation count so no one will be confused 2318 * by reincarnations of this inode. 2319 */ 2320 ip->i_d.di_gen++; 2321 2322 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 2323 2324 error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK); 2325 if (error) 2326 return error; 2327 2328 /* 2329 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat 2330 * from picking up this inode when it is reclaimed (its incore state 2331 * initialzed but not flushed to disk yet). The in-core di_mode is 2332 * already cleared and a corresponding transaction logged. 2333 * The hack here just synchronizes the in-core to on-disk 2334 * di_mode value in advance before the actual inode sync to disk. 2335 * This is OK because the inode is already unlinked and would never 2336 * change its di_mode again for this inode generation. 2337 * This is a temporary hack that would require a proper fix 2338 * in the future. 2339 */ 2340 dip->di_core.di_mode = 0; 2341 2342 if (delete) { 2343 xfs_ifree_cluster(ip, tp, first_ino); 2344 } 2345 2346 return 0; 2347 } 2348 2349 /* 2350 * Reallocate the space for if_broot based on the number of records 2351 * being added or deleted as indicated in rec_diff. Move the records 2352 * and pointers in if_broot to fit the new size. When shrinking this 2353 * will eliminate holes between the records and pointers created by 2354 * the caller. When growing this will create holes to be filled in 2355 * by the caller. 2356 * 2357 * The caller must not request to add more records than would fit in 2358 * the on-disk inode root. If the if_broot is currently NULL, then 2359 * if we adding records one will be allocated. The caller must also 2360 * not request that the number of records go below zero, although 2361 * it can go to zero. 2362 * 2363 * ip -- the inode whose if_broot area is changing 2364 * ext_diff -- the change in the number of records, positive or negative, 2365 * requested for the if_broot array. 2366 */ 2367 void 2368 xfs_iroot_realloc( 2369 xfs_inode_t *ip, 2370 int rec_diff, 2371 int whichfork) 2372 { 2373 int cur_max; 2374 xfs_ifork_t *ifp; 2375 xfs_bmbt_block_t *new_broot; 2376 int new_max; 2377 size_t new_size; 2378 char *np; 2379 char *op; 2380 2381 /* 2382 * Handle the degenerate case quietly. 2383 */ 2384 if (rec_diff == 0) { 2385 return; 2386 } 2387 2388 ifp = XFS_IFORK_PTR(ip, whichfork); 2389 if (rec_diff > 0) { 2390 /* 2391 * If there wasn't any memory allocated before, just 2392 * allocate it now and get out. 2393 */ 2394 if (ifp->if_broot_bytes == 0) { 2395 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(rec_diff); 2396 ifp->if_broot = (xfs_bmbt_block_t*)kmem_alloc(new_size, 2397 KM_SLEEP); 2398 ifp->if_broot_bytes = (int)new_size; 2399 return; 2400 } 2401 2402 /* 2403 * If there is already an existing if_broot, then we need 2404 * to realloc() it and shift the pointers to their new 2405 * location. The records don't change location because 2406 * they are kept butted up against the btree block header. 2407 */ 2408 cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes); 2409 new_max = cur_max + rec_diff; 2410 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max); 2411 ifp->if_broot = (xfs_bmbt_block_t *) 2412 kmem_realloc(ifp->if_broot, 2413 new_size, 2414 (size_t)XFS_BMAP_BROOT_SPACE_CALC(cur_max), /* old size */ 2415 KM_SLEEP); 2416 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1, 2417 ifp->if_broot_bytes); 2418 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1, 2419 (int)new_size); 2420 ifp->if_broot_bytes = (int)new_size; 2421 ASSERT(ifp->if_broot_bytes <= 2422 XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ); 2423 memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t)); 2424 return; 2425 } 2426 2427 /* 2428 * rec_diff is less than 0. In this case, we are shrinking the 2429 * if_broot buffer. It must already exist. If we go to zero 2430 * records, just get rid of the root and clear the status bit. 2431 */ 2432 ASSERT((ifp->if_broot != NULL) && (ifp->if_broot_bytes > 0)); 2433 cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes); 2434 new_max = cur_max + rec_diff; 2435 ASSERT(new_max >= 0); 2436 if (new_max > 0) 2437 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max); 2438 else 2439 new_size = 0; 2440 if (new_size > 0) { 2441 new_broot = (xfs_bmbt_block_t *)kmem_alloc(new_size, KM_SLEEP); 2442 /* 2443 * First copy over the btree block header. 2444 */ 2445 memcpy(new_broot, ifp->if_broot, sizeof(xfs_bmbt_block_t)); 2446 } else { 2447 new_broot = NULL; 2448 ifp->if_flags &= ~XFS_IFBROOT; 2449 } 2450 2451 /* 2452 * Only copy the records and pointers if there are any. 2453 */ 2454 if (new_max > 0) { 2455 /* 2456 * First copy the records. 2457 */ 2458 op = (char *)XFS_BMAP_BROOT_REC_ADDR(ifp->if_broot, 1, 2459 ifp->if_broot_bytes); 2460 np = (char *)XFS_BMAP_BROOT_REC_ADDR(new_broot, 1, 2461 (int)new_size); 2462 memcpy(np, op, new_max * (uint)sizeof(xfs_bmbt_rec_t)); 2463 2464 /* 2465 * Then copy the pointers. 2466 */ 2467 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1, 2468 ifp->if_broot_bytes); 2469 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(new_broot, 1, 2470 (int)new_size); 2471 memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t)); 2472 } 2473 kmem_free(ifp->if_broot, ifp->if_broot_bytes); 2474 ifp->if_broot = new_broot; 2475 ifp->if_broot_bytes = (int)new_size; 2476 ASSERT(ifp->if_broot_bytes <= 2477 XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ); 2478 return; 2479 } 2480 2481 2482 /* 2483 * This is called when the amount of space needed for if_data 2484 * is increased or decreased. The change in size is indicated by 2485 * the number of bytes that need to be added or deleted in the 2486 * byte_diff parameter. 2487 * 2488 * If the amount of space needed has decreased below the size of the 2489 * inline buffer, then switch to using the inline buffer. Otherwise, 2490 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer 2491 * to what is needed. 2492 * 2493 * ip -- the inode whose if_data area is changing 2494 * byte_diff -- the change in the number of bytes, positive or negative, 2495 * requested for the if_data array. 2496 */ 2497 void 2498 xfs_idata_realloc( 2499 xfs_inode_t *ip, 2500 int byte_diff, 2501 int whichfork) 2502 { 2503 xfs_ifork_t *ifp; 2504 int new_size; 2505 int real_size; 2506 2507 if (byte_diff == 0) { 2508 return; 2509 } 2510 2511 ifp = XFS_IFORK_PTR(ip, whichfork); 2512 new_size = (int)ifp->if_bytes + byte_diff; 2513 ASSERT(new_size >= 0); 2514 2515 if (new_size == 0) { 2516 if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) { 2517 kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes); 2518 } 2519 ifp->if_u1.if_data = NULL; 2520 real_size = 0; 2521 } else if (new_size <= sizeof(ifp->if_u2.if_inline_data)) { 2522 /* 2523 * If the valid extents/data can fit in if_inline_ext/data, 2524 * copy them from the malloc'd vector and free it. 2525 */ 2526 if (ifp->if_u1.if_data == NULL) { 2527 ifp->if_u1.if_data = ifp->if_u2.if_inline_data; 2528 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) { 2529 ASSERT(ifp->if_real_bytes != 0); 2530 memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data, 2531 new_size); 2532 kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes); 2533 ifp->if_u1.if_data = ifp->if_u2.if_inline_data; 2534 } 2535 real_size = 0; 2536 } else { 2537 /* 2538 * Stuck with malloc/realloc. 2539 * For inline data, the underlying buffer must be 2540 * a multiple of 4 bytes in size so that it can be 2541 * logged and stay on word boundaries. We enforce 2542 * that here. 2543 */ 2544 real_size = roundup(new_size, 4); 2545 if (ifp->if_u1.if_data == NULL) { 2546 ASSERT(ifp->if_real_bytes == 0); 2547 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP); 2548 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) { 2549 /* 2550 * Only do the realloc if the underlying size 2551 * is really changing. 2552 */ 2553 if (ifp->if_real_bytes != real_size) { 2554 ifp->if_u1.if_data = 2555 kmem_realloc(ifp->if_u1.if_data, 2556 real_size, 2557 ifp->if_real_bytes, 2558 KM_SLEEP); 2559 } 2560 } else { 2561 ASSERT(ifp->if_real_bytes == 0); 2562 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP); 2563 memcpy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data, 2564 ifp->if_bytes); 2565 } 2566 } 2567 ifp->if_real_bytes = real_size; 2568 ifp->if_bytes = new_size; 2569 ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork)); 2570 } 2571 2572 2573 2574 2575 /* 2576 * Map inode to disk block and offset. 2577 * 2578 * mp -- the mount point structure for the current file system 2579 * tp -- the current transaction 2580 * ino -- the inode number of the inode to be located 2581 * imap -- this structure is filled in with the information necessary 2582 * to retrieve the given inode from disk 2583 * flags -- flags to pass to xfs_dilocate indicating whether or not 2584 * lookups in the inode btree were OK or not 2585 */ 2586 int 2587 xfs_imap( 2588 xfs_mount_t *mp, 2589 xfs_trans_t *tp, 2590 xfs_ino_t ino, 2591 xfs_imap_t *imap, 2592 uint flags) 2593 { 2594 xfs_fsblock_t fsbno; 2595 int len; 2596 int off; 2597 int error; 2598 2599 fsbno = imap->im_blkno ? 2600 XFS_DADDR_TO_FSB(mp, imap->im_blkno) : NULLFSBLOCK; 2601 error = xfs_dilocate(mp, tp, ino, &fsbno, &len, &off, flags); 2602 if (error) 2603 return error; 2604 2605 imap->im_blkno = XFS_FSB_TO_DADDR(mp, fsbno); 2606 imap->im_len = XFS_FSB_TO_BB(mp, len); 2607 imap->im_agblkno = XFS_FSB_TO_AGBNO(mp, fsbno); 2608 imap->im_ioffset = (ushort)off; 2609 imap->im_boffset = (ushort)(off << mp->m_sb.sb_inodelog); 2610 2611 /* 2612 * If the inode number maps to a block outside the bounds 2613 * of the file system then return NULL rather than calling 2614 * read_buf and panicing when we get an error from the 2615 * driver. 2616 */ 2617 if ((imap->im_blkno + imap->im_len) > 2618 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) { 2619 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: " 2620 "(imap->im_blkno (0x%llx) + imap->im_len (0x%llx)) > " 2621 " XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) (0x%llx)", 2622 (unsigned long long) imap->im_blkno, 2623 (unsigned long long) imap->im_len, 2624 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)); 2625 return EINVAL; 2626 } 2627 return 0; 2628 } 2629 2630 void 2631 xfs_idestroy_fork( 2632 xfs_inode_t *ip, 2633 int whichfork) 2634 { 2635 xfs_ifork_t *ifp; 2636 2637 ifp = XFS_IFORK_PTR(ip, whichfork); 2638 if (ifp->if_broot != NULL) { 2639 kmem_free(ifp->if_broot, ifp->if_broot_bytes); 2640 ifp->if_broot = NULL; 2641 } 2642 2643 /* 2644 * If the format is local, then we can't have an extents 2645 * array so just look for an inline data array. If we're 2646 * not local then we may or may not have an extents list, 2647 * so check and free it up if we do. 2648 */ 2649 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 2650 if ((ifp->if_u1.if_data != ifp->if_u2.if_inline_data) && 2651 (ifp->if_u1.if_data != NULL)) { 2652 ASSERT(ifp->if_real_bytes != 0); 2653 kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes); 2654 ifp->if_u1.if_data = NULL; 2655 ifp->if_real_bytes = 0; 2656 } 2657 } else if ((ifp->if_flags & XFS_IFEXTENTS) && 2658 ((ifp->if_flags & XFS_IFEXTIREC) || 2659 ((ifp->if_u1.if_extents != NULL) && 2660 (ifp->if_u1.if_extents != ifp->if_u2.if_inline_ext)))) { 2661 ASSERT(ifp->if_real_bytes != 0); 2662 xfs_iext_destroy(ifp); 2663 } 2664 ASSERT(ifp->if_u1.if_extents == NULL || 2665 ifp->if_u1.if_extents == ifp->if_u2.if_inline_ext); 2666 ASSERT(ifp->if_real_bytes == 0); 2667 if (whichfork == XFS_ATTR_FORK) { 2668 kmem_zone_free(xfs_ifork_zone, ip->i_afp); 2669 ip->i_afp = NULL; 2670 } 2671 } 2672 2673 /* 2674 * This is called free all the memory associated with an inode. 2675 * It must free the inode itself and any buffers allocated for 2676 * if_extents/if_data and if_broot. It must also free the lock 2677 * associated with the inode. 2678 */ 2679 void 2680 xfs_idestroy( 2681 xfs_inode_t *ip) 2682 { 2683 switch (ip->i_d.di_mode & S_IFMT) { 2684 case S_IFREG: 2685 case S_IFDIR: 2686 case S_IFLNK: 2687 xfs_idestroy_fork(ip, XFS_DATA_FORK); 2688 break; 2689 } 2690 if (ip->i_afp) 2691 xfs_idestroy_fork(ip, XFS_ATTR_FORK); 2692 mrfree(&ip->i_lock); 2693 mrfree(&ip->i_iolock); 2694 freesema(&ip->i_flock); 2695 2696 #ifdef XFS_INODE_TRACE 2697 ktrace_free(ip->i_trace); 2698 #endif 2699 #ifdef XFS_BMAP_TRACE 2700 ktrace_free(ip->i_xtrace); 2701 #endif 2702 #ifdef XFS_BMBT_TRACE 2703 ktrace_free(ip->i_btrace); 2704 #endif 2705 #ifdef XFS_RW_TRACE 2706 ktrace_free(ip->i_rwtrace); 2707 #endif 2708 #ifdef XFS_ILOCK_TRACE 2709 ktrace_free(ip->i_lock_trace); 2710 #endif 2711 #ifdef XFS_DIR2_TRACE 2712 ktrace_free(ip->i_dir_trace); 2713 #endif 2714 if (ip->i_itemp) { 2715 /* 2716 * Only if we are shutting down the fs will we see an 2717 * inode still in the AIL. If it is there, we should remove 2718 * it to prevent a use-after-free from occurring. 2719 */ 2720 xfs_mount_t *mp = ip->i_mount; 2721 xfs_log_item_t *lip = &ip->i_itemp->ili_item; 2722 2723 ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) || 2724 XFS_FORCED_SHUTDOWN(ip->i_mount)); 2725 if (lip->li_flags & XFS_LI_IN_AIL) { 2726 spin_lock(&mp->m_ail_lock); 2727 if (lip->li_flags & XFS_LI_IN_AIL) 2728 xfs_trans_delete_ail(mp, lip); 2729 else 2730 spin_unlock(&mp->m_ail_lock); 2731 } 2732 xfs_inode_item_destroy(ip); 2733 } 2734 kmem_zone_free(xfs_inode_zone, ip); 2735 } 2736 2737 2738 /* 2739 * Increment the pin count of the given buffer. 2740 * This value is protected by ipinlock spinlock in the mount structure. 2741 */ 2742 void 2743 xfs_ipin( 2744 xfs_inode_t *ip) 2745 { 2746 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 2747 2748 atomic_inc(&ip->i_pincount); 2749 } 2750 2751 /* 2752 * Decrement the pin count of the given inode, and wake up 2753 * anyone in xfs_iwait_unpin() if the count goes to 0. The 2754 * inode must have been previously pinned with a call to xfs_ipin(). 2755 */ 2756 void 2757 xfs_iunpin( 2758 xfs_inode_t *ip) 2759 { 2760 ASSERT(atomic_read(&ip->i_pincount) > 0); 2761 2762 if (atomic_dec_and_test(&ip->i_pincount)) 2763 wake_up(&ip->i_ipin_wait); 2764 } 2765 2766 /* 2767 * This is called to unpin an inode. It can be directed to wait or to return 2768 * immediately without waiting for the inode to be unpinned. The caller must 2769 * have the inode locked in at least shared mode so that the buffer cannot be 2770 * subsequently pinned once someone is waiting for it to be unpinned. 2771 */ 2772 STATIC void 2773 __xfs_iunpin_wait( 2774 xfs_inode_t *ip, 2775 int wait) 2776 { 2777 xfs_inode_log_item_t *iip = ip->i_itemp; 2778 2779 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)); 2780 if (atomic_read(&ip->i_pincount) == 0) 2781 return; 2782 2783 /* Give the log a push to start the unpinning I/O */ 2784 xfs_log_force(ip->i_mount, (iip && iip->ili_last_lsn) ? 2785 iip->ili_last_lsn : 0, XFS_LOG_FORCE); 2786 if (wait) 2787 wait_event(ip->i_ipin_wait, (atomic_read(&ip->i_pincount) == 0)); 2788 } 2789 2790 static inline void 2791 xfs_iunpin_wait( 2792 xfs_inode_t *ip) 2793 { 2794 __xfs_iunpin_wait(ip, 1); 2795 } 2796 2797 static inline void 2798 xfs_iunpin_nowait( 2799 xfs_inode_t *ip) 2800 { 2801 __xfs_iunpin_wait(ip, 0); 2802 } 2803 2804 2805 /* 2806 * xfs_iextents_copy() 2807 * 2808 * This is called to copy the REAL extents (as opposed to the delayed 2809 * allocation extents) from the inode into the given buffer. It 2810 * returns the number of bytes copied into the buffer. 2811 * 2812 * If there are no delayed allocation extents, then we can just 2813 * memcpy() the extents into the buffer. Otherwise, we need to 2814 * examine each extent in turn and skip those which are delayed. 2815 */ 2816 int 2817 xfs_iextents_copy( 2818 xfs_inode_t *ip, 2819 xfs_bmbt_rec_t *dp, 2820 int whichfork) 2821 { 2822 int copied; 2823 int i; 2824 xfs_ifork_t *ifp; 2825 int nrecs; 2826 xfs_fsblock_t start_block; 2827 2828 ifp = XFS_IFORK_PTR(ip, whichfork); 2829 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)); 2830 ASSERT(ifp->if_bytes > 0); 2831 2832 nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 2833 XFS_BMAP_TRACE_EXLIST(ip, nrecs, whichfork); 2834 ASSERT(nrecs > 0); 2835 2836 /* 2837 * There are some delayed allocation extents in the 2838 * inode, so copy the extents one at a time and skip 2839 * the delayed ones. There must be at least one 2840 * non-delayed extent. 2841 */ 2842 copied = 0; 2843 for (i = 0; i < nrecs; i++) { 2844 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i); 2845 start_block = xfs_bmbt_get_startblock(ep); 2846 if (ISNULLSTARTBLOCK(start_block)) { 2847 /* 2848 * It's a delayed allocation extent, so skip it. 2849 */ 2850 continue; 2851 } 2852 2853 /* Translate to on disk format */ 2854 put_unaligned(cpu_to_be64(ep->l0), &dp->l0); 2855 put_unaligned(cpu_to_be64(ep->l1), &dp->l1); 2856 dp++; 2857 copied++; 2858 } 2859 ASSERT(copied != 0); 2860 xfs_validate_extents(ifp, copied, XFS_EXTFMT_INODE(ip)); 2861 2862 return (copied * (uint)sizeof(xfs_bmbt_rec_t)); 2863 } 2864 2865 /* 2866 * Each of the following cases stores data into the same region 2867 * of the on-disk inode, so only one of them can be valid at 2868 * any given time. While it is possible to have conflicting formats 2869 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is 2870 * in EXTENTS format, this can only happen when the fork has 2871 * changed formats after being modified but before being flushed. 2872 * In these cases, the format always takes precedence, because the 2873 * format indicates the current state of the fork. 2874 */ 2875 /*ARGSUSED*/ 2876 STATIC void 2877 xfs_iflush_fork( 2878 xfs_inode_t *ip, 2879 xfs_dinode_t *dip, 2880 xfs_inode_log_item_t *iip, 2881 int whichfork, 2882 xfs_buf_t *bp) 2883 { 2884 char *cp; 2885 xfs_ifork_t *ifp; 2886 xfs_mount_t *mp; 2887 #ifdef XFS_TRANS_DEBUG 2888 int first; 2889 #endif 2890 static const short brootflag[2] = 2891 { XFS_ILOG_DBROOT, XFS_ILOG_ABROOT }; 2892 static const short dataflag[2] = 2893 { XFS_ILOG_DDATA, XFS_ILOG_ADATA }; 2894 static const short extflag[2] = 2895 { XFS_ILOG_DEXT, XFS_ILOG_AEXT }; 2896 2897 if (!iip) 2898 return; 2899 ifp = XFS_IFORK_PTR(ip, whichfork); 2900 /* 2901 * This can happen if we gave up in iformat in an error path, 2902 * for the attribute fork. 2903 */ 2904 if (!ifp) { 2905 ASSERT(whichfork == XFS_ATTR_FORK); 2906 return; 2907 } 2908 cp = XFS_DFORK_PTR(dip, whichfork); 2909 mp = ip->i_mount; 2910 switch (XFS_IFORK_FORMAT(ip, whichfork)) { 2911 case XFS_DINODE_FMT_LOCAL: 2912 if ((iip->ili_format.ilf_fields & dataflag[whichfork]) && 2913 (ifp->if_bytes > 0)) { 2914 ASSERT(ifp->if_u1.if_data != NULL); 2915 ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork)); 2916 memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes); 2917 } 2918 break; 2919 2920 case XFS_DINODE_FMT_EXTENTS: 2921 ASSERT((ifp->if_flags & XFS_IFEXTENTS) || 2922 !(iip->ili_format.ilf_fields & extflag[whichfork])); 2923 ASSERT((xfs_iext_get_ext(ifp, 0) != NULL) || 2924 (ifp->if_bytes == 0)); 2925 ASSERT((xfs_iext_get_ext(ifp, 0) == NULL) || 2926 (ifp->if_bytes > 0)); 2927 if ((iip->ili_format.ilf_fields & extflag[whichfork]) && 2928 (ifp->if_bytes > 0)) { 2929 ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) > 0); 2930 (void)xfs_iextents_copy(ip, (xfs_bmbt_rec_t *)cp, 2931 whichfork); 2932 } 2933 break; 2934 2935 case XFS_DINODE_FMT_BTREE: 2936 if ((iip->ili_format.ilf_fields & brootflag[whichfork]) && 2937 (ifp->if_broot_bytes > 0)) { 2938 ASSERT(ifp->if_broot != NULL); 2939 ASSERT(ifp->if_broot_bytes <= 2940 (XFS_IFORK_SIZE(ip, whichfork) + 2941 XFS_BROOT_SIZE_ADJ)); 2942 xfs_bmbt_to_bmdr(ifp->if_broot, ifp->if_broot_bytes, 2943 (xfs_bmdr_block_t *)cp, 2944 XFS_DFORK_SIZE(dip, mp, whichfork)); 2945 } 2946 break; 2947 2948 case XFS_DINODE_FMT_DEV: 2949 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) { 2950 ASSERT(whichfork == XFS_DATA_FORK); 2951 dip->di_u.di_dev = cpu_to_be32(ip->i_df.if_u2.if_rdev); 2952 } 2953 break; 2954 2955 case XFS_DINODE_FMT_UUID: 2956 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) { 2957 ASSERT(whichfork == XFS_DATA_FORK); 2958 memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid, 2959 sizeof(uuid_t)); 2960 } 2961 break; 2962 2963 default: 2964 ASSERT(0); 2965 break; 2966 } 2967 } 2968 2969 STATIC int 2970 xfs_iflush_cluster( 2971 xfs_inode_t *ip, 2972 xfs_buf_t *bp) 2973 { 2974 xfs_mount_t *mp = ip->i_mount; 2975 xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino); 2976 unsigned long first_index, mask; 2977 int ilist_size; 2978 xfs_inode_t **ilist; 2979 xfs_inode_t *iq; 2980 int nr_found; 2981 int clcount = 0; 2982 int bufwasdelwri; 2983 int i; 2984 2985 ASSERT(pag->pagi_inodeok); 2986 ASSERT(pag->pag_ici_init); 2987 2988 ilist_size = XFS_INODE_CLUSTER_SIZE(mp) * sizeof(xfs_inode_t *); 2989 ilist = kmem_alloc(ilist_size, KM_MAYFAIL); 2990 if (!ilist) 2991 return 0; 2992 2993 mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1); 2994 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask; 2995 read_lock(&pag->pag_ici_lock); 2996 /* really need a gang lookup range call here */ 2997 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)ilist, 2998 first_index, 2999 XFS_INODE_CLUSTER_SIZE(mp)); 3000 if (nr_found == 0) 3001 goto out_free; 3002 3003 for (i = 0; i < nr_found; i++) { 3004 iq = ilist[i]; 3005 if (iq == ip) 3006 continue; 3007 /* if the inode lies outside this cluster, we're done. */ 3008 if ((XFS_INO_TO_AGINO(mp, iq->i_ino) & mask) != first_index) 3009 break; 3010 /* 3011 * Do an un-protected check to see if the inode is dirty and 3012 * is a candidate for flushing. These checks will be repeated 3013 * later after the appropriate locks are acquired. 3014 */ 3015 if (xfs_inode_clean(iq) && xfs_ipincount(iq) == 0) 3016 continue; 3017 3018 /* 3019 * Try to get locks. If any are unavailable or it is pinned, 3020 * then this inode cannot be flushed and is skipped. 3021 */ 3022 3023 if (!xfs_ilock_nowait(iq, XFS_ILOCK_SHARED)) 3024 continue; 3025 if (!xfs_iflock_nowait(iq)) { 3026 xfs_iunlock(iq, XFS_ILOCK_SHARED); 3027 continue; 3028 } 3029 if (xfs_ipincount(iq)) { 3030 xfs_ifunlock(iq); 3031 xfs_iunlock(iq, XFS_ILOCK_SHARED); 3032 continue; 3033 } 3034 3035 /* 3036 * arriving here means that this inode can be flushed. First 3037 * re-check that it's dirty before flushing. 3038 */ 3039 if (!xfs_inode_clean(iq)) { 3040 int error; 3041 error = xfs_iflush_int(iq, bp); 3042 if (error) { 3043 xfs_iunlock(iq, XFS_ILOCK_SHARED); 3044 goto cluster_corrupt_out; 3045 } 3046 clcount++; 3047 } else { 3048 xfs_ifunlock(iq); 3049 } 3050 xfs_iunlock(iq, XFS_ILOCK_SHARED); 3051 } 3052 3053 if (clcount) { 3054 XFS_STATS_INC(xs_icluster_flushcnt); 3055 XFS_STATS_ADD(xs_icluster_flushinode, clcount); 3056 } 3057 3058 out_free: 3059 read_unlock(&pag->pag_ici_lock); 3060 kmem_free(ilist, ilist_size); 3061 return 0; 3062 3063 3064 cluster_corrupt_out: 3065 /* 3066 * Corruption detected in the clustering loop. Invalidate the 3067 * inode buffer and shut down the filesystem. 3068 */ 3069 read_unlock(&pag->pag_ici_lock); 3070 /* 3071 * Clean up the buffer. If it was B_DELWRI, just release it -- 3072 * brelse can handle it with no problems. If not, shut down the 3073 * filesystem before releasing the buffer. 3074 */ 3075 bufwasdelwri = XFS_BUF_ISDELAYWRITE(bp); 3076 if (bufwasdelwri) 3077 xfs_buf_relse(bp); 3078 3079 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 3080 3081 if (!bufwasdelwri) { 3082 /* 3083 * Just like incore_relse: if we have b_iodone functions, 3084 * mark the buffer as an error and call them. Otherwise 3085 * mark it as stale and brelse. 3086 */ 3087 if (XFS_BUF_IODONE_FUNC(bp)) { 3088 XFS_BUF_CLR_BDSTRAT_FUNC(bp); 3089 XFS_BUF_UNDONE(bp); 3090 XFS_BUF_STALE(bp); 3091 XFS_BUF_SHUT(bp); 3092 XFS_BUF_ERROR(bp,EIO); 3093 xfs_biodone(bp); 3094 } else { 3095 XFS_BUF_STALE(bp); 3096 xfs_buf_relse(bp); 3097 } 3098 } 3099 3100 /* 3101 * Unlocks the flush lock 3102 */ 3103 xfs_iflush_abort(iq); 3104 kmem_free(ilist, ilist_size); 3105 return XFS_ERROR(EFSCORRUPTED); 3106 } 3107 3108 /* 3109 * xfs_iflush() will write a modified inode's changes out to the 3110 * inode's on disk home. The caller must have the inode lock held 3111 * in at least shared mode and the inode flush semaphore must be 3112 * held as well. The inode lock will still be held upon return from 3113 * the call and the caller is free to unlock it. 3114 * The inode flush lock will be unlocked when the inode reaches the disk. 3115 * The flags indicate how the inode's buffer should be written out. 3116 */ 3117 int 3118 xfs_iflush( 3119 xfs_inode_t *ip, 3120 uint flags) 3121 { 3122 xfs_inode_log_item_t *iip; 3123 xfs_buf_t *bp; 3124 xfs_dinode_t *dip; 3125 xfs_mount_t *mp; 3126 int error; 3127 int noblock = (flags == XFS_IFLUSH_ASYNC_NOBLOCK); 3128 enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) }; 3129 3130 XFS_STATS_INC(xs_iflush_count); 3131 3132 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)); 3133 ASSERT(issemalocked(&(ip->i_flock))); 3134 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE || 3135 ip->i_d.di_nextents > ip->i_df.if_ext_max); 3136 3137 iip = ip->i_itemp; 3138 mp = ip->i_mount; 3139 3140 /* 3141 * If the inode isn't dirty, then just release the inode 3142 * flush lock and do nothing. 3143 */ 3144 if (xfs_inode_clean(ip)) { 3145 ASSERT((iip != NULL) ? 3146 !(iip->ili_item.li_flags & XFS_LI_IN_AIL) : 1); 3147 xfs_ifunlock(ip); 3148 return 0; 3149 } 3150 3151 /* 3152 * We can't flush the inode until it is unpinned, so wait for it if we 3153 * are allowed to block. We know noone new can pin it, because we are 3154 * holding the inode lock shared and you need to hold it exclusively to 3155 * pin the inode. 3156 * 3157 * If we are not allowed to block, force the log out asynchronously so 3158 * that when we come back the inode will be unpinned. If other inodes 3159 * in the same cluster are dirty, they will probably write the inode 3160 * out for us if they occur after the log force completes. 3161 */ 3162 if (noblock && xfs_ipincount(ip)) { 3163 xfs_iunpin_nowait(ip); 3164 xfs_ifunlock(ip); 3165 return EAGAIN; 3166 } 3167 xfs_iunpin_wait(ip); 3168 3169 /* 3170 * This may have been unpinned because the filesystem is shutting 3171 * down forcibly. If that's the case we must not write this inode 3172 * to disk, because the log record didn't make it to disk! 3173 */ 3174 if (XFS_FORCED_SHUTDOWN(mp)) { 3175 ip->i_update_core = 0; 3176 if (iip) 3177 iip->ili_format.ilf_fields = 0; 3178 xfs_ifunlock(ip); 3179 return XFS_ERROR(EIO); 3180 } 3181 3182 /* 3183 * Decide how buffer will be flushed out. This is done before 3184 * the call to xfs_iflush_int because this field is zeroed by it. 3185 */ 3186 if (iip != NULL && iip->ili_format.ilf_fields != 0) { 3187 /* 3188 * Flush out the inode buffer according to the directions 3189 * of the caller. In the cases where the caller has given 3190 * us a choice choose the non-delwri case. This is because 3191 * the inode is in the AIL and we need to get it out soon. 3192 */ 3193 switch (flags) { 3194 case XFS_IFLUSH_SYNC: 3195 case XFS_IFLUSH_DELWRI_ELSE_SYNC: 3196 flags = 0; 3197 break; 3198 case XFS_IFLUSH_ASYNC_NOBLOCK: 3199 case XFS_IFLUSH_ASYNC: 3200 case XFS_IFLUSH_DELWRI_ELSE_ASYNC: 3201 flags = INT_ASYNC; 3202 break; 3203 case XFS_IFLUSH_DELWRI: 3204 flags = INT_DELWRI; 3205 break; 3206 default: 3207 ASSERT(0); 3208 flags = 0; 3209 break; 3210 } 3211 } else { 3212 switch (flags) { 3213 case XFS_IFLUSH_DELWRI_ELSE_SYNC: 3214 case XFS_IFLUSH_DELWRI_ELSE_ASYNC: 3215 case XFS_IFLUSH_DELWRI: 3216 flags = INT_DELWRI; 3217 break; 3218 case XFS_IFLUSH_ASYNC_NOBLOCK: 3219 case XFS_IFLUSH_ASYNC: 3220 flags = INT_ASYNC; 3221 break; 3222 case XFS_IFLUSH_SYNC: 3223 flags = 0; 3224 break; 3225 default: 3226 ASSERT(0); 3227 flags = 0; 3228 break; 3229 } 3230 } 3231 3232 /* 3233 * Get the buffer containing the on-disk inode. 3234 */ 3235 error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0, 3236 noblock ? XFS_BUF_TRYLOCK : XFS_BUF_LOCK); 3237 if (error || !bp) { 3238 xfs_ifunlock(ip); 3239 return error; 3240 } 3241 3242 /* 3243 * First flush out the inode that xfs_iflush was called with. 3244 */ 3245 error = xfs_iflush_int(ip, bp); 3246 if (error) 3247 goto corrupt_out; 3248 3249 /* 3250 * If the buffer is pinned then push on the log now so we won't 3251 * get stuck waiting in the write for too long. 3252 */ 3253 if (XFS_BUF_ISPINNED(bp)) 3254 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE); 3255 3256 /* 3257 * inode clustering: 3258 * see if other inodes can be gathered into this write 3259 */ 3260 error = xfs_iflush_cluster(ip, bp); 3261 if (error) 3262 goto cluster_corrupt_out; 3263 3264 if (flags & INT_DELWRI) { 3265 xfs_bdwrite(mp, bp); 3266 } else if (flags & INT_ASYNC) { 3267 error = xfs_bawrite(mp, bp); 3268 } else { 3269 error = xfs_bwrite(mp, bp); 3270 } 3271 return error; 3272 3273 corrupt_out: 3274 xfs_buf_relse(bp); 3275 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 3276 cluster_corrupt_out: 3277 /* 3278 * Unlocks the flush lock 3279 */ 3280 xfs_iflush_abort(ip); 3281 return XFS_ERROR(EFSCORRUPTED); 3282 } 3283 3284 3285 STATIC int 3286 xfs_iflush_int( 3287 xfs_inode_t *ip, 3288 xfs_buf_t *bp) 3289 { 3290 xfs_inode_log_item_t *iip; 3291 xfs_dinode_t *dip; 3292 xfs_mount_t *mp; 3293 #ifdef XFS_TRANS_DEBUG 3294 int first; 3295 #endif 3296 3297 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)); 3298 ASSERT(issemalocked(&(ip->i_flock))); 3299 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE || 3300 ip->i_d.di_nextents > ip->i_df.if_ext_max); 3301 3302 iip = ip->i_itemp; 3303 mp = ip->i_mount; 3304 3305 3306 /* 3307 * If the inode isn't dirty, then just release the inode 3308 * flush lock and do nothing. 3309 */ 3310 if (xfs_inode_clean(ip)) { 3311 xfs_ifunlock(ip); 3312 return 0; 3313 } 3314 3315 /* set *dip = inode's place in the buffer */ 3316 dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_boffset); 3317 3318 /* 3319 * Clear i_update_core before copying out the data. 3320 * This is for coordination with our timestamp updates 3321 * that don't hold the inode lock. They will always 3322 * update the timestamps BEFORE setting i_update_core, 3323 * so if we clear i_update_core after they set it we 3324 * are guaranteed to see their updates to the timestamps. 3325 * I believe that this depends on strongly ordered memory 3326 * semantics, but we have that. We use the SYNCHRONIZE 3327 * macro to make sure that the compiler does not reorder 3328 * the i_update_core access below the data copy below. 3329 */ 3330 ip->i_update_core = 0; 3331 SYNCHRONIZE(); 3332 3333 /* 3334 * Make sure to get the latest atime from the Linux inode. 3335 */ 3336 xfs_synchronize_atime(ip); 3337 3338 if (XFS_TEST_ERROR(be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC, 3339 mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) { 3340 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3341 "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p", 3342 ip->i_ino, be16_to_cpu(dip->di_core.di_magic), dip); 3343 goto corrupt_out; 3344 } 3345 if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC, 3346 mp, XFS_ERRTAG_IFLUSH_2, XFS_RANDOM_IFLUSH_2)) { 3347 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3348 "xfs_iflush: Bad inode %Lu, ptr 0x%p, magic number 0x%x", 3349 ip->i_ino, ip, ip->i_d.di_magic); 3350 goto corrupt_out; 3351 } 3352 if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) { 3353 if (XFS_TEST_ERROR( 3354 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) && 3355 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE), 3356 mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) { 3357 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3358 "xfs_iflush: Bad regular inode %Lu, ptr 0x%p", 3359 ip->i_ino, ip); 3360 goto corrupt_out; 3361 } 3362 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) { 3363 if (XFS_TEST_ERROR( 3364 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) && 3365 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) && 3366 (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL), 3367 mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) { 3368 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3369 "xfs_iflush: Bad directory inode %Lu, ptr 0x%p", 3370 ip->i_ino, ip); 3371 goto corrupt_out; 3372 } 3373 } 3374 if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents > 3375 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5, 3376 XFS_RANDOM_IFLUSH_5)) { 3377 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3378 "xfs_iflush: detected corrupt incore inode %Lu, total extents = %d, nblocks = %Ld, ptr 0x%p", 3379 ip->i_ino, 3380 ip->i_d.di_nextents + ip->i_d.di_anextents, 3381 ip->i_d.di_nblocks, 3382 ip); 3383 goto corrupt_out; 3384 } 3385 if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize, 3386 mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) { 3387 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3388 "xfs_iflush: bad inode %Lu, forkoff 0x%x, ptr 0x%p", 3389 ip->i_ino, ip->i_d.di_forkoff, ip); 3390 goto corrupt_out; 3391 } 3392 /* 3393 * bump the flush iteration count, used to detect flushes which 3394 * postdate a log record during recovery. 3395 */ 3396 3397 ip->i_d.di_flushiter++; 3398 3399 /* 3400 * Copy the dirty parts of the inode into the on-disk 3401 * inode. We always copy out the core of the inode, 3402 * because if the inode is dirty at all the core must 3403 * be. 3404 */ 3405 xfs_dinode_to_disk(&dip->di_core, &ip->i_d); 3406 3407 /* Wrap, we never let the log put out DI_MAX_FLUSH */ 3408 if (ip->i_d.di_flushiter == DI_MAX_FLUSH) 3409 ip->i_d.di_flushiter = 0; 3410 3411 /* 3412 * If this is really an old format inode and the superblock version 3413 * has not been updated to support only new format inodes, then 3414 * convert back to the old inode format. If the superblock version 3415 * has been updated, then make the conversion permanent. 3416 */ 3417 ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 || 3418 xfs_sb_version_hasnlink(&mp->m_sb)); 3419 if (ip->i_d.di_version == XFS_DINODE_VERSION_1) { 3420 if (!xfs_sb_version_hasnlink(&mp->m_sb)) { 3421 /* 3422 * Convert it back. 3423 */ 3424 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1); 3425 dip->di_core.di_onlink = cpu_to_be16(ip->i_d.di_nlink); 3426 } else { 3427 /* 3428 * The superblock version has already been bumped, 3429 * so just make the conversion to the new inode 3430 * format permanent. 3431 */ 3432 ip->i_d.di_version = XFS_DINODE_VERSION_2; 3433 dip->di_core.di_version = XFS_DINODE_VERSION_2; 3434 ip->i_d.di_onlink = 0; 3435 dip->di_core.di_onlink = 0; 3436 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad)); 3437 memset(&(dip->di_core.di_pad[0]), 0, 3438 sizeof(dip->di_core.di_pad)); 3439 ASSERT(ip->i_d.di_projid == 0); 3440 } 3441 } 3442 3443 xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp); 3444 if (XFS_IFORK_Q(ip)) 3445 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp); 3446 xfs_inobp_check(mp, bp); 3447 3448 /* 3449 * We've recorded everything logged in the inode, so we'd 3450 * like to clear the ilf_fields bits so we don't log and 3451 * flush things unnecessarily. However, we can't stop 3452 * logging all this information until the data we've copied 3453 * into the disk buffer is written to disk. If we did we might 3454 * overwrite the copy of the inode in the log with all the 3455 * data after re-logging only part of it, and in the face of 3456 * a crash we wouldn't have all the data we need to recover. 3457 * 3458 * What we do is move the bits to the ili_last_fields field. 3459 * When logging the inode, these bits are moved back to the 3460 * ilf_fields field. In the xfs_iflush_done() routine we 3461 * clear ili_last_fields, since we know that the information 3462 * those bits represent is permanently on disk. As long as 3463 * the flush completes before the inode is logged again, then 3464 * both ilf_fields and ili_last_fields will be cleared. 3465 * 3466 * We can play with the ilf_fields bits here, because the inode 3467 * lock must be held exclusively in order to set bits there 3468 * and the flush lock protects the ili_last_fields bits. 3469 * Set ili_logged so the flush done 3470 * routine can tell whether or not to look in the AIL. 3471 * Also, store the current LSN of the inode so that we can tell 3472 * whether the item has moved in the AIL from xfs_iflush_done(). 3473 * In order to read the lsn we need the AIL lock, because 3474 * it is a 64 bit value that cannot be read atomically. 3475 */ 3476 if (iip != NULL && iip->ili_format.ilf_fields != 0) { 3477 iip->ili_last_fields = iip->ili_format.ilf_fields; 3478 iip->ili_format.ilf_fields = 0; 3479 iip->ili_logged = 1; 3480 3481 ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */ 3482 spin_lock(&mp->m_ail_lock); 3483 iip->ili_flush_lsn = iip->ili_item.li_lsn; 3484 spin_unlock(&mp->m_ail_lock); 3485 3486 /* 3487 * Attach the function xfs_iflush_done to the inode's 3488 * buffer. This will remove the inode from the AIL 3489 * and unlock the inode's flush lock when the inode is 3490 * completely written to disk. 3491 */ 3492 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*)) 3493 xfs_iflush_done, (xfs_log_item_t *)iip); 3494 3495 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL); 3496 ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL); 3497 } else { 3498 /* 3499 * We're flushing an inode which is not in the AIL and has 3500 * not been logged but has i_update_core set. For this 3501 * case we can use a B_DELWRI flush and immediately drop 3502 * the inode flush lock because we can avoid the whole 3503 * AIL state thing. It's OK to drop the flush lock now, 3504 * because we've already locked the buffer and to do anything 3505 * you really need both. 3506 */ 3507 if (iip != NULL) { 3508 ASSERT(iip->ili_logged == 0); 3509 ASSERT(iip->ili_last_fields == 0); 3510 ASSERT((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0); 3511 } 3512 xfs_ifunlock(ip); 3513 } 3514 3515 return 0; 3516 3517 corrupt_out: 3518 return XFS_ERROR(EFSCORRUPTED); 3519 } 3520 3521 3522 /* 3523 * Flush all inactive inodes in mp. 3524 */ 3525 void 3526 xfs_iflush_all( 3527 xfs_mount_t *mp) 3528 { 3529 xfs_inode_t *ip; 3530 bhv_vnode_t *vp; 3531 3532 again: 3533 XFS_MOUNT_ILOCK(mp); 3534 ip = mp->m_inodes; 3535 if (ip == NULL) 3536 goto out; 3537 3538 do { 3539 /* Make sure we skip markers inserted by sync */ 3540 if (ip->i_mount == NULL) { 3541 ip = ip->i_mnext; 3542 continue; 3543 } 3544 3545 vp = XFS_ITOV_NULL(ip); 3546 if (!vp) { 3547 XFS_MOUNT_IUNLOCK(mp); 3548 xfs_finish_reclaim(ip, 0, XFS_IFLUSH_ASYNC); 3549 goto again; 3550 } 3551 3552 ASSERT(vn_count(vp) == 0); 3553 3554 ip = ip->i_mnext; 3555 } while (ip != mp->m_inodes); 3556 out: 3557 XFS_MOUNT_IUNLOCK(mp); 3558 } 3559 3560 #ifdef XFS_ILOCK_TRACE 3561 ktrace_t *xfs_ilock_trace_buf; 3562 3563 void 3564 xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags, inst_t *ra) 3565 { 3566 ktrace_enter(ip->i_lock_trace, 3567 (void *)ip, 3568 (void *)(unsigned long)lock, /* 1 = LOCK, 3=UNLOCK, etc */ 3569 (void *)(unsigned long)lockflags, /* XFS_ILOCK_EXCL etc */ 3570 (void *)ra, /* caller of ilock */ 3571 (void *)(unsigned long)current_cpu(), 3572 (void *)(unsigned long)current_pid(), 3573 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL); 3574 } 3575 #endif 3576 3577 /* 3578 * Return a pointer to the extent record at file index idx. 3579 */ 3580 xfs_bmbt_rec_host_t * 3581 xfs_iext_get_ext( 3582 xfs_ifork_t *ifp, /* inode fork pointer */ 3583 xfs_extnum_t idx) /* index of target extent */ 3584 { 3585 ASSERT(idx >= 0); 3586 if ((ifp->if_flags & XFS_IFEXTIREC) && (idx == 0)) { 3587 return ifp->if_u1.if_ext_irec->er_extbuf; 3588 } else if (ifp->if_flags & XFS_IFEXTIREC) { 3589 xfs_ext_irec_t *erp; /* irec pointer */ 3590 int erp_idx = 0; /* irec index */ 3591 xfs_extnum_t page_idx = idx; /* ext index in target list */ 3592 3593 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0); 3594 return &erp->er_extbuf[page_idx]; 3595 } else if (ifp->if_bytes) { 3596 return &ifp->if_u1.if_extents[idx]; 3597 } else { 3598 return NULL; 3599 } 3600 } 3601 3602 /* 3603 * Insert new item(s) into the extent records for incore inode 3604 * fork 'ifp'. 'count' new items are inserted at index 'idx'. 3605 */ 3606 void 3607 xfs_iext_insert( 3608 xfs_ifork_t *ifp, /* inode fork pointer */ 3609 xfs_extnum_t idx, /* starting index of new items */ 3610 xfs_extnum_t count, /* number of inserted items */ 3611 xfs_bmbt_irec_t *new) /* items to insert */ 3612 { 3613 xfs_extnum_t i; /* extent record index */ 3614 3615 ASSERT(ifp->if_flags & XFS_IFEXTENTS); 3616 xfs_iext_add(ifp, idx, count); 3617 for (i = idx; i < idx + count; i++, new++) 3618 xfs_bmbt_set_all(xfs_iext_get_ext(ifp, i), new); 3619 } 3620 3621 /* 3622 * This is called when the amount of space required for incore file 3623 * extents needs to be increased. The ext_diff parameter stores the 3624 * number of new extents being added and the idx parameter contains 3625 * the extent index where the new extents will be added. If the new 3626 * extents are being appended, then we just need to (re)allocate and 3627 * initialize the space. Otherwise, if the new extents are being 3628 * inserted into the middle of the existing entries, a bit more work 3629 * is required to make room for the new extents to be inserted. The 3630 * caller is responsible for filling in the new extent entries upon 3631 * return. 3632 */ 3633 void 3634 xfs_iext_add( 3635 xfs_ifork_t *ifp, /* inode fork pointer */ 3636 xfs_extnum_t idx, /* index to begin adding exts */ 3637 int ext_diff) /* number of extents to add */ 3638 { 3639 int byte_diff; /* new bytes being added */ 3640 int new_size; /* size of extents after adding */ 3641 xfs_extnum_t nextents; /* number of extents in file */ 3642 3643 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3644 ASSERT((idx >= 0) && (idx <= nextents)); 3645 byte_diff = ext_diff * sizeof(xfs_bmbt_rec_t); 3646 new_size = ifp->if_bytes + byte_diff; 3647 /* 3648 * If the new number of extents (nextents + ext_diff) 3649 * fits inside the inode, then continue to use the inline 3650 * extent buffer. 3651 */ 3652 if (nextents + ext_diff <= XFS_INLINE_EXTS) { 3653 if (idx < nextents) { 3654 memmove(&ifp->if_u2.if_inline_ext[idx + ext_diff], 3655 &ifp->if_u2.if_inline_ext[idx], 3656 (nextents - idx) * sizeof(xfs_bmbt_rec_t)); 3657 memset(&ifp->if_u2.if_inline_ext[idx], 0, byte_diff); 3658 } 3659 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext; 3660 ifp->if_real_bytes = 0; 3661 ifp->if_lastex = nextents + ext_diff; 3662 } 3663 /* 3664 * Otherwise use a linear (direct) extent list. 3665 * If the extents are currently inside the inode, 3666 * xfs_iext_realloc_direct will switch us from 3667 * inline to direct extent allocation mode. 3668 */ 3669 else if (nextents + ext_diff <= XFS_LINEAR_EXTS) { 3670 xfs_iext_realloc_direct(ifp, new_size); 3671 if (idx < nextents) { 3672 memmove(&ifp->if_u1.if_extents[idx + ext_diff], 3673 &ifp->if_u1.if_extents[idx], 3674 (nextents - idx) * sizeof(xfs_bmbt_rec_t)); 3675 memset(&ifp->if_u1.if_extents[idx], 0, byte_diff); 3676 } 3677 } 3678 /* Indirection array */ 3679 else { 3680 xfs_ext_irec_t *erp; 3681 int erp_idx = 0; 3682 int page_idx = idx; 3683 3684 ASSERT(nextents + ext_diff > XFS_LINEAR_EXTS); 3685 if (ifp->if_flags & XFS_IFEXTIREC) { 3686 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 1); 3687 } else { 3688 xfs_iext_irec_init(ifp); 3689 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 3690 erp = ifp->if_u1.if_ext_irec; 3691 } 3692 /* Extents fit in target extent page */ 3693 if (erp && erp->er_extcount + ext_diff <= XFS_LINEAR_EXTS) { 3694 if (page_idx < erp->er_extcount) { 3695 memmove(&erp->er_extbuf[page_idx + ext_diff], 3696 &erp->er_extbuf[page_idx], 3697 (erp->er_extcount - page_idx) * 3698 sizeof(xfs_bmbt_rec_t)); 3699 memset(&erp->er_extbuf[page_idx], 0, byte_diff); 3700 } 3701 erp->er_extcount += ext_diff; 3702 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3703 } 3704 /* Insert a new extent page */ 3705 else if (erp) { 3706 xfs_iext_add_indirect_multi(ifp, 3707 erp_idx, page_idx, ext_diff); 3708 } 3709 /* 3710 * If extent(s) are being appended to the last page in 3711 * the indirection array and the new extent(s) don't fit 3712 * in the page, then erp is NULL and erp_idx is set to 3713 * the next index needed in the indirection array. 3714 */ 3715 else { 3716 int count = ext_diff; 3717 3718 while (count) { 3719 erp = xfs_iext_irec_new(ifp, erp_idx); 3720 erp->er_extcount = count; 3721 count -= MIN(count, (int)XFS_LINEAR_EXTS); 3722 if (count) { 3723 erp_idx++; 3724 } 3725 } 3726 } 3727 } 3728 ifp->if_bytes = new_size; 3729 } 3730 3731 /* 3732 * This is called when incore extents are being added to the indirection 3733 * array and the new extents do not fit in the target extent list. The 3734 * erp_idx parameter contains the irec index for the target extent list 3735 * in the indirection array, and the idx parameter contains the extent 3736 * index within the list. The number of extents being added is stored 3737 * in the count parameter. 3738 * 3739 * |-------| |-------| 3740 * | | | | idx - number of extents before idx 3741 * | idx | | count | 3742 * | | | | count - number of extents being inserted at idx 3743 * |-------| |-------| 3744 * | count | | nex2 | nex2 - number of extents after idx + count 3745 * |-------| |-------| 3746 */ 3747 void 3748 xfs_iext_add_indirect_multi( 3749 xfs_ifork_t *ifp, /* inode fork pointer */ 3750 int erp_idx, /* target extent irec index */ 3751 xfs_extnum_t idx, /* index within target list */ 3752 int count) /* new extents being added */ 3753 { 3754 int byte_diff; /* new bytes being added */ 3755 xfs_ext_irec_t *erp; /* pointer to irec entry */ 3756 xfs_extnum_t ext_diff; /* number of extents to add */ 3757 xfs_extnum_t ext_cnt; /* new extents still needed */ 3758 xfs_extnum_t nex2; /* extents after idx + count */ 3759 xfs_bmbt_rec_t *nex2_ep = NULL; /* temp list for nex2 extents */ 3760 int nlists; /* number of irec's (lists) */ 3761 3762 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 3763 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 3764 nex2 = erp->er_extcount - idx; 3765 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 3766 3767 /* 3768 * Save second part of target extent list 3769 * (all extents past */ 3770 if (nex2) { 3771 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t); 3772 nex2_ep = (xfs_bmbt_rec_t *) kmem_alloc(byte_diff, KM_SLEEP); 3773 memmove(nex2_ep, &erp->er_extbuf[idx], byte_diff); 3774 erp->er_extcount -= nex2; 3775 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -nex2); 3776 memset(&erp->er_extbuf[idx], 0, byte_diff); 3777 } 3778 3779 /* 3780 * Add the new extents to the end of the target 3781 * list, then allocate new irec record(s) and 3782 * extent buffer(s) as needed to store the rest 3783 * of the new extents. 3784 */ 3785 ext_cnt = count; 3786 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS - erp->er_extcount); 3787 if (ext_diff) { 3788 erp->er_extcount += ext_diff; 3789 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3790 ext_cnt -= ext_diff; 3791 } 3792 while (ext_cnt) { 3793 erp_idx++; 3794 erp = xfs_iext_irec_new(ifp, erp_idx); 3795 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS); 3796 erp->er_extcount = ext_diff; 3797 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3798 ext_cnt -= ext_diff; 3799 } 3800 3801 /* Add nex2 extents back to indirection array */ 3802 if (nex2) { 3803 xfs_extnum_t ext_avail; 3804 int i; 3805 3806 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t); 3807 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount; 3808 i = 0; 3809 /* 3810 * If nex2 extents fit in the current page, append 3811 * nex2_ep after the new extents. 3812 */ 3813 if (nex2 <= ext_avail) { 3814 i = erp->er_extcount; 3815 } 3816 /* 3817 * Otherwise, check if space is available in the 3818 * next page. 3819 */ 3820 else if ((erp_idx < nlists - 1) && 3821 (nex2 <= (ext_avail = XFS_LINEAR_EXTS - 3822 ifp->if_u1.if_ext_irec[erp_idx+1].er_extcount))) { 3823 erp_idx++; 3824 erp++; 3825 /* Create a hole for nex2 extents */ 3826 memmove(&erp->er_extbuf[nex2], erp->er_extbuf, 3827 erp->er_extcount * sizeof(xfs_bmbt_rec_t)); 3828 } 3829 /* 3830 * Final choice, create a new extent page for 3831 * nex2 extents. 3832 */ 3833 else { 3834 erp_idx++; 3835 erp = xfs_iext_irec_new(ifp, erp_idx); 3836 } 3837 memmove(&erp->er_extbuf[i], nex2_ep, byte_diff); 3838 kmem_free(nex2_ep, byte_diff); 3839 erp->er_extcount += nex2; 3840 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2); 3841 } 3842 } 3843 3844 /* 3845 * This is called when the amount of space required for incore file 3846 * extents needs to be decreased. The ext_diff parameter stores the 3847 * number of extents to be removed and the idx parameter contains 3848 * the extent index where the extents will be removed from. 3849 * 3850 * If the amount of space needed has decreased below the linear 3851 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous 3852 * extent array. Otherwise, use kmem_realloc() to adjust the 3853 * size to what is needed. 3854 */ 3855 void 3856 xfs_iext_remove( 3857 xfs_ifork_t *ifp, /* inode fork pointer */ 3858 xfs_extnum_t idx, /* index to begin removing exts */ 3859 int ext_diff) /* number of extents to remove */ 3860 { 3861 xfs_extnum_t nextents; /* number of extents in file */ 3862 int new_size; /* size of extents after removal */ 3863 3864 ASSERT(ext_diff > 0); 3865 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3866 new_size = (nextents - ext_diff) * sizeof(xfs_bmbt_rec_t); 3867 3868 if (new_size == 0) { 3869 xfs_iext_destroy(ifp); 3870 } else if (ifp->if_flags & XFS_IFEXTIREC) { 3871 xfs_iext_remove_indirect(ifp, idx, ext_diff); 3872 } else if (ifp->if_real_bytes) { 3873 xfs_iext_remove_direct(ifp, idx, ext_diff); 3874 } else { 3875 xfs_iext_remove_inline(ifp, idx, ext_diff); 3876 } 3877 ifp->if_bytes = new_size; 3878 } 3879 3880 /* 3881 * This removes ext_diff extents from the inline buffer, beginning 3882 * at extent index idx. 3883 */ 3884 void 3885 xfs_iext_remove_inline( 3886 xfs_ifork_t *ifp, /* inode fork pointer */ 3887 xfs_extnum_t idx, /* index to begin removing exts */ 3888 int ext_diff) /* number of extents to remove */ 3889 { 3890 int nextents; /* number of extents in file */ 3891 3892 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 3893 ASSERT(idx < XFS_INLINE_EXTS); 3894 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3895 ASSERT(((nextents - ext_diff) > 0) && 3896 (nextents - ext_diff) < XFS_INLINE_EXTS); 3897 3898 if (idx + ext_diff < nextents) { 3899 memmove(&ifp->if_u2.if_inline_ext[idx], 3900 &ifp->if_u2.if_inline_ext[idx + ext_diff], 3901 (nextents - (idx + ext_diff)) * 3902 sizeof(xfs_bmbt_rec_t)); 3903 memset(&ifp->if_u2.if_inline_ext[nextents - ext_diff], 3904 0, ext_diff * sizeof(xfs_bmbt_rec_t)); 3905 } else { 3906 memset(&ifp->if_u2.if_inline_ext[idx], 0, 3907 ext_diff * sizeof(xfs_bmbt_rec_t)); 3908 } 3909 } 3910 3911 /* 3912 * This removes ext_diff extents from a linear (direct) extent list, 3913 * beginning at extent index idx. If the extents are being removed 3914 * from the end of the list (ie. truncate) then we just need to re- 3915 * allocate the list to remove the extra space. Otherwise, if the 3916 * extents are being removed from the middle of the existing extent 3917 * entries, then we first need to move the extent records beginning 3918 * at idx + ext_diff up in the list to overwrite the records being 3919 * removed, then remove the extra space via kmem_realloc. 3920 */ 3921 void 3922 xfs_iext_remove_direct( 3923 xfs_ifork_t *ifp, /* inode fork pointer */ 3924 xfs_extnum_t idx, /* index to begin removing exts */ 3925 int ext_diff) /* number of extents to remove */ 3926 { 3927 xfs_extnum_t nextents; /* number of extents in file */ 3928 int new_size; /* size of extents after removal */ 3929 3930 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 3931 new_size = ifp->if_bytes - 3932 (ext_diff * sizeof(xfs_bmbt_rec_t)); 3933 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3934 3935 if (new_size == 0) { 3936 xfs_iext_destroy(ifp); 3937 return; 3938 } 3939 /* Move extents up in the list (if needed) */ 3940 if (idx + ext_diff < nextents) { 3941 memmove(&ifp->if_u1.if_extents[idx], 3942 &ifp->if_u1.if_extents[idx + ext_diff], 3943 (nextents - (idx + ext_diff)) * 3944 sizeof(xfs_bmbt_rec_t)); 3945 } 3946 memset(&ifp->if_u1.if_extents[nextents - ext_diff], 3947 0, ext_diff * sizeof(xfs_bmbt_rec_t)); 3948 /* 3949 * Reallocate the direct extent list. If the extents 3950 * will fit inside the inode then xfs_iext_realloc_direct 3951 * will switch from direct to inline extent allocation 3952 * mode for us. 3953 */ 3954 xfs_iext_realloc_direct(ifp, new_size); 3955 ifp->if_bytes = new_size; 3956 } 3957 3958 /* 3959 * This is called when incore extents are being removed from the 3960 * indirection array and the extents being removed span multiple extent 3961 * buffers. The idx parameter contains the file extent index where we 3962 * want to begin removing extents, and the count parameter contains 3963 * how many extents need to be removed. 3964 * 3965 * |-------| |-------| 3966 * | nex1 | | | nex1 - number of extents before idx 3967 * |-------| | count | 3968 * | | | | count - number of extents being removed at idx 3969 * | count | |-------| 3970 * | | | nex2 | nex2 - number of extents after idx + count 3971 * |-------| |-------| 3972 */ 3973 void 3974 xfs_iext_remove_indirect( 3975 xfs_ifork_t *ifp, /* inode fork pointer */ 3976 xfs_extnum_t idx, /* index to begin removing extents */ 3977 int count) /* number of extents to remove */ 3978 { 3979 xfs_ext_irec_t *erp; /* indirection array pointer */ 3980 int erp_idx = 0; /* indirection array index */ 3981 xfs_extnum_t ext_cnt; /* extents left to remove */ 3982 xfs_extnum_t ext_diff; /* extents to remove in current list */ 3983 xfs_extnum_t nex1; /* number of extents before idx */ 3984 xfs_extnum_t nex2; /* extents after idx + count */ 3985 int nlists; /* entries in indirection array */ 3986 int page_idx = idx; /* index in target extent list */ 3987 3988 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 3989 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0); 3990 ASSERT(erp != NULL); 3991 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 3992 nex1 = page_idx; 3993 ext_cnt = count; 3994 while (ext_cnt) { 3995 nex2 = MAX((erp->er_extcount - (nex1 + ext_cnt)), 0); 3996 ext_diff = MIN(ext_cnt, (erp->er_extcount - nex1)); 3997 /* 3998 * Check for deletion of entire list; 3999 * xfs_iext_irec_remove() updates extent offsets. 4000 */ 4001 if (ext_diff == erp->er_extcount) { 4002 xfs_iext_irec_remove(ifp, erp_idx); 4003 ext_cnt -= ext_diff; 4004 nex1 = 0; 4005 if (ext_cnt) { 4006 ASSERT(erp_idx < ifp->if_real_bytes / 4007 XFS_IEXT_BUFSZ); 4008 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4009 nex1 = 0; 4010 continue; 4011 } else { 4012 break; 4013 } 4014 } 4015 /* Move extents up (if needed) */ 4016 if (nex2) { 4017 memmove(&erp->er_extbuf[nex1], 4018 &erp->er_extbuf[nex1 + ext_diff], 4019 nex2 * sizeof(xfs_bmbt_rec_t)); 4020 } 4021 /* Zero out rest of page */ 4022 memset(&erp->er_extbuf[nex1 + nex2], 0, (XFS_IEXT_BUFSZ - 4023 ((nex1 + nex2) * sizeof(xfs_bmbt_rec_t)))); 4024 /* Update remaining counters */ 4025 erp->er_extcount -= ext_diff; 4026 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -ext_diff); 4027 ext_cnt -= ext_diff; 4028 nex1 = 0; 4029 erp_idx++; 4030 erp++; 4031 } 4032 ifp->if_bytes -= count * sizeof(xfs_bmbt_rec_t); 4033 xfs_iext_irec_compact(ifp); 4034 } 4035 4036 /* 4037 * Create, destroy, or resize a linear (direct) block of extents. 4038 */ 4039 void 4040 xfs_iext_realloc_direct( 4041 xfs_ifork_t *ifp, /* inode fork pointer */ 4042 int new_size) /* new size of extents */ 4043 { 4044 int rnew_size; /* real new size of extents */ 4045 4046 rnew_size = new_size; 4047 4048 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC) || 4049 ((new_size >= 0) && (new_size <= XFS_IEXT_BUFSZ) && 4050 (new_size != ifp->if_real_bytes))); 4051 4052 /* Free extent records */ 4053 if (new_size == 0) { 4054 xfs_iext_destroy(ifp); 4055 } 4056 /* Resize direct extent list and zero any new bytes */ 4057 else if (ifp->if_real_bytes) { 4058 /* Check if extents will fit inside the inode */ 4059 if (new_size <= XFS_INLINE_EXTS * sizeof(xfs_bmbt_rec_t)) { 4060 xfs_iext_direct_to_inline(ifp, new_size / 4061 (uint)sizeof(xfs_bmbt_rec_t)); 4062 ifp->if_bytes = new_size; 4063 return; 4064 } 4065 if (!is_power_of_2(new_size)){ 4066 rnew_size = roundup_pow_of_two(new_size); 4067 } 4068 if (rnew_size != ifp->if_real_bytes) { 4069 ifp->if_u1.if_extents = 4070 kmem_realloc(ifp->if_u1.if_extents, 4071 rnew_size, 4072 ifp->if_real_bytes, 4073 KM_SLEEP); 4074 } 4075 if (rnew_size > ifp->if_real_bytes) { 4076 memset(&ifp->if_u1.if_extents[ifp->if_bytes / 4077 (uint)sizeof(xfs_bmbt_rec_t)], 0, 4078 rnew_size - ifp->if_real_bytes); 4079 } 4080 } 4081 /* 4082 * Switch from the inline extent buffer to a direct 4083 * extent list. Be sure to include the inline extent 4084 * bytes in new_size. 4085 */ 4086 else { 4087 new_size += ifp->if_bytes; 4088 if (!is_power_of_2(new_size)) { 4089 rnew_size = roundup_pow_of_two(new_size); 4090 } 4091 xfs_iext_inline_to_direct(ifp, rnew_size); 4092 } 4093 ifp->if_real_bytes = rnew_size; 4094 ifp->if_bytes = new_size; 4095 } 4096 4097 /* 4098 * Switch from linear (direct) extent records to inline buffer. 4099 */ 4100 void 4101 xfs_iext_direct_to_inline( 4102 xfs_ifork_t *ifp, /* inode fork pointer */ 4103 xfs_extnum_t nextents) /* number of extents in file */ 4104 { 4105 ASSERT(ifp->if_flags & XFS_IFEXTENTS); 4106 ASSERT(nextents <= XFS_INLINE_EXTS); 4107 /* 4108 * The inline buffer was zeroed when we switched 4109 * from inline to direct extent allocation mode, 4110 * so we don't need to clear it here. 4111 */ 4112 memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents, 4113 nextents * sizeof(xfs_bmbt_rec_t)); 4114 kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes); 4115 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext; 4116 ifp->if_real_bytes = 0; 4117 } 4118 4119 /* 4120 * Switch from inline buffer to linear (direct) extent records. 4121 * new_size should already be rounded up to the next power of 2 4122 * by the caller (when appropriate), so use new_size as it is. 4123 * However, since new_size may be rounded up, we can't update 4124 * if_bytes here. It is the caller's responsibility to update 4125 * if_bytes upon return. 4126 */ 4127 void 4128 xfs_iext_inline_to_direct( 4129 xfs_ifork_t *ifp, /* inode fork pointer */ 4130 int new_size) /* number of extents in file */ 4131 { 4132 ifp->if_u1.if_extents = kmem_alloc(new_size, KM_SLEEP); 4133 memset(ifp->if_u1.if_extents, 0, new_size); 4134 if (ifp->if_bytes) { 4135 memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext, 4136 ifp->if_bytes); 4137 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS * 4138 sizeof(xfs_bmbt_rec_t)); 4139 } 4140 ifp->if_real_bytes = new_size; 4141 } 4142 4143 /* 4144 * Resize an extent indirection array to new_size bytes. 4145 */ 4146 void 4147 xfs_iext_realloc_indirect( 4148 xfs_ifork_t *ifp, /* inode fork pointer */ 4149 int new_size) /* new indirection array size */ 4150 { 4151 int nlists; /* number of irec's (ex lists) */ 4152 int size; /* current indirection array size */ 4153 4154 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4155 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4156 size = nlists * sizeof(xfs_ext_irec_t); 4157 ASSERT(ifp->if_real_bytes); 4158 ASSERT((new_size >= 0) && (new_size != size)); 4159 if (new_size == 0) { 4160 xfs_iext_destroy(ifp); 4161 } else { 4162 ifp->if_u1.if_ext_irec = (xfs_ext_irec_t *) 4163 kmem_realloc(ifp->if_u1.if_ext_irec, 4164 new_size, size, KM_SLEEP); 4165 } 4166 } 4167 4168 /* 4169 * Switch from indirection array to linear (direct) extent allocations. 4170 */ 4171 void 4172 xfs_iext_indirect_to_direct( 4173 xfs_ifork_t *ifp) /* inode fork pointer */ 4174 { 4175 xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 4176 xfs_extnum_t nextents; /* number of extents in file */ 4177 int size; /* size of file extents */ 4178 4179 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4180 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4181 ASSERT(nextents <= XFS_LINEAR_EXTS); 4182 size = nextents * sizeof(xfs_bmbt_rec_t); 4183 4184 xfs_iext_irec_compact_full(ifp); 4185 ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ); 4186 4187 ep = ifp->if_u1.if_ext_irec->er_extbuf; 4188 kmem_free(ifp->if_u1.if_ext_irec, sizeof(xfs_ext_irec_t)); 4189 ifp->if_flags &= ~XFS_IFEXTIREC; 4190 ifp->if_u1.if_extents = ep; 4191 ifp->if_bytes = size; 4192 if (nextents < XFS_LINEAR_EXTS) { 4193 xfs_iext_realloc_direct(ifp, size); 4194 } 4195 } 4196 4197 /* 4198 * Free incore file extents. 4199 */ 4200 void 4201 xfs_iext_destroy( 4202 xfs_ifork_t *ifp) /* inode fork pointer */ 4203 { 4204 if (ifp->if_flags & XFS_IFEXTIREC) { 4205 int erp_idx; 4206 int nlists; 4207 4208 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4209 for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) { 4210 xfs_iext_irec_remove(ifp, erp_idx); 4211 } 4212 ifp->if_flags &= ~XFS_IFEXTIREC; 4213 } else if (ifp->if_real_bytes) { 4214 kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes); 4215 } else if (ifp->if_bytes) { 4216 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS * 4217 sizeof(xfs_bmbt_rec_t)); 4218 } 4219 ifp->if_u1.if_extents = NULL; 4220 ifp->if_real_bytes = 0; 4221 ifp->if_bytes = 0; 4222 } 4223 4224 /* 4225 * Return a pointer to the extent record for file system block bno. 4226 */ 4227 xfs_bmbt_rec_host_t * /* pointer to found extent record */ 4228 xfs_iext_bno_to_ext( 4229 xfs_ifork_t *ifp, /* inode fork pointer */ 4230 xfs_fileoff_t bno, /* block number to search for */ 4231 xfs_extnum_t *idxp) /* index of target extent */ 4232 { 4233 xfs_bmbt_rec_host_t *base; /* pointer to first extent */ 4234 xfs_filblks_t blockcount = 0; /* number of blocks in extent */ 4235 xfs_bmbt_rec_host_t *ep = NULL; /* pointer to target extent */ 4236 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */ 4237 int high; /* upper boundary in search */ 4238 xfs_extnum_t idx = 0; /* index of target extent */ 4239 int low; /* lower boundary in search */ 4240 xfs_extnum_t nextents; /* number of file extents */ 4241 xfs_fileoff_t startoff = 0; /* start offset of extent */ 4242 4243 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4244 if (nextents == 0) { 4245 *idxp = 0; 4246 return NULL; 4247 } 4248 low = 0; 4249 if (ifp->if_flags & XFS_IFEXTIREC) { 4250 /* Find target extent list */ 4251 int erp_idx = 0; 4252 erp = xfs_iext_bno_to_irec(ifp, bno, &erp_idx); 4253 base = erp->er_extbuf; 4254 high = erp->er_extcount - 1; 4255 } else { 4256 base = ifp->if_u1.if_extents; 4257 high = nextents - 1; 4258 } 4259 /* Binary search extent records */ 4260 while (low <= high) { 4261 idx = (low + high) >> 1; 4262 ep = base + idx; 4263 startoff = xfs_bmbt_get_startoff(ep); 4264 blockcount = xfs_bmbt_get_blockcount(ep); 4265 if (bno < startoff) { 4266 high = idx - 1; 4267 } else if (bno >= startoff + blockcount) { 4268 low = idx + 1; 4269 } else { 4270 /* Convert back to file-based extent index */ 4271 if (ifp->if_flags & XFS_IFEXTIREC) { 4272 idx += erp->er_extoff; 4273 } 4274 *idxp = idx; 4275 return ep; 4276 } 4277 } 4278 /* Convert back to file-based extent index */ 4279 if (ifp->if_flags & XFS_IFEXTIREC) { 4280 idx += erp->er_extoff; 4281 } 4282 if (bno >= startoff + blockcount) { 4283 if (++idx == nextents) { 4284 ep = NULL; 4285 } else { 4286 ep = xfs_iext_get_ext(ifp, idx); 4287 } 4288 } 4289 *idxp = idx; 4290 return ep; 4291 } 4292 4293 /* 4294 * Return a pointer to the indirection array entry containing the 4295 * extent record for filesystem block bno. Store the index of the 4296 * target irec in *erp_idxp. 4297 */ 4298 xfs_ext_irec_t * /* pointer to found extent record */ 4299 xfs_iext_bno_to_irec( 4300 xfs_ifork_t *ifp, /* inode fork pointer */ 4301 xfs_fileoff_t bno, /* block number to search for */ 4302 int *erp_idxp) /* irec index of target ext list */ 4303 { 4304 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */ 4305 xfs_ext_irec_t *erp_next; /* next indirection array entry */ 4306 int erp_idx; /* indirection array index */ 4307 int nlists; /* number of extent irec's (lists) */ 4308 int high; /* binary search upper limit */ 4309 int low; /* binary search lower limit */ 4310 4311 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4312 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4313 erp_idx = 0; 4314 low = 0; 4315 high = nlists - 1; 4316 while (low <= high) { 4317 erp_idx = (low + high) >> 1; 4318 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4319 erp_next = erp_idx < nlists - 1 ? erp + 1 : NULL; 4320 if (bno < xfs_bmbt_get_startoff(erp->er_extbuf)) { 4321 high = erp_idx - 1; 4322 } else if (erp_next && bno >= 4323 xfs_bmbt_get_startoff(erp_next->er_extbuf)) { 4324 low = erp_idx + 1; 4325 } else { 4326 break; 4327 } 4328 } 4329 *erp_idxp = erp_idx; 4330 return erp; 4331 } 4332 4333 /* 4334 * Return a pointer to the indirection array entry containing the 4335 * extent record at file extent index *idxp. Store the index of the 4336 * target irec in *erp_idxp and store the page index of the target 4337 * extent record in *idxp. 4338 */ 4339 xfs_ext_irec_t * 4340 xfs_iext_idx_to_irec( 4341 xfs_ifork_t *ifp, /* inode fork pointer */ 4342 xfs_extnum_t *idxp, /* extent index (file -> page) */ 4343 int *erp_idxp, /* pointer to target irec */ 4344 int realloc) /* new bytes were just added */ 4345 { 4346 xfs_ext_irec_t *prev; /* pointer to previous irec */ 4347 xfs_ext_irec_t *erp = NULL; /* pointer to current irec */ 4348 int erp_idx; /* indirection array index */ 4349 int nlists; /* number of irec's (ex lists) */ 4350 int high; /* binary search upper limit */ 4351 int low; /* binary search lower limit */ 4352 xfs_extnum_t page_idx = *idxp; /* extent index in target list */ 4353 4354 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4355 ASSERT(page_idx >= 0 && page_idx <= 4356 ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)); 4357 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4358 erp_idx = 0; 4359 low = 0; 4360 high = nlists - 1; 4361 4362 /* Binary search extent irec's */ 4363 while (low <= high) { 4364 erp_idx = (low + high) >> 1; 4365 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4366 prev = erp_idx > 0 ? erp - 1 : NULL; 4367 if (page_idx < erp->er_extoff || (page_idx == erp->er_extoff && 4368 realloc && prev && prev->er_extcount < XFS_LINEAR_EXTS)) { 4369 high = erp_idx - 1; 4370 } else if (page_idx > erp->er_extoff + erp->er_extcount || 4371 (page_idx == erp->er_extoff + erp->er_extcount && 4372 !realloc)) { 4373 low = erp_idx + 1; 4374 } else if (page_idx == erp->er_extoff + erp->er_extcount && 4375 erp->er_extcount == XFS_LINEAR_EXTS) { 4376 ASSERT(realloc); 4377 page_idx = 0; 4378 erp_idx++; 4379 erp = erp_idx < nlists ? erp + 1 : NULL; 4380 break; 4381 } else { 4382 page_idx -= erp->er_extoff; 4383 break; 4384 } 4385 } 4386 *idxp = page_idx; 4387 *erp_idxp = erp_idx; 4388 return(erp); 4389 } 4390 4391 /* 4392 * Allocate and initialize an indirection array once the space needed 4393 * for incore extents increases above XFS_IEXT_BUFSZ. 4394 */ 4395 void 4396 xfs_iext_irec_init( 4397 xfs_ifork_t *ifp) /* inode fork pointer */ 4398 { 4399 xfs_ext_irec_t *erp; /* indirection array pointer */ 4400 xfs_extnum_t nextents; /* number of extents in file */ 4401 4402 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 4403 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4404 ASSERT(nextents <= XFS_LINEAR_EXTS); 4405 4406 erp = (xfs_ext_irec_t *) 4407 kmem_alloc(sizeof(xfs_ext_irec_t), KM_SLEEP); 4408 4409 if (nextents == 0) { 4410 ifp->if_u1.if_extents = kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP); 4411 } else if (!ifp->if_real_bytes) { 4412 xfs_iext_inline_to_direct(ifp, XFS_IEXT_BUFSZ); 4413 } else if (ifp->if_real_bytes < XFS_IEXT_BUFSZ) { 4414 xfs_iext_realloc_direct(ifp, XFS_IEXT_BUFSZ); 4415 } 4416 erp->er_extbuf = ifp->if_u1.if_extents; 4417 erp->er_extcount = nextents; 4418 erp->er_extoff = 0; 4419 4420 ifp->if_flags |= XFS_IFEXTIREC; 4421 ifp->if_real_bytes = XFS_IEXT_BUFSZ; 4422 ifp->if_bytes = nextents * sizeof(xfs_bmbt_rec_t); 4423 ifp->if_u1.if_ext_irec = erp; 4424 4425 return; 4426 } 4427 4428 /* 4429 * Allocate and initialize a new entry in the indirection array. 4430 */ 4431 xfs_ext_irec_t * 4432 xfs_iext_irec_new( 4433 xfs_ifork_t *ifp, /* inode fork pointer */ 4434 int erp_idx) /* index for new irec */ 4435 { 4436 xfs_ext_irec_t *erp; /* indirection array pointer */ 4437 int i; /* loop counter */ 4438 int nlists; /* number of irec's (ex lists) */ 4439 4440 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4441 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4442 4443 /* Resize indirection array */ 4444 xfs_iext_realloc_indirect(ifp, ++nlists * 4445 sizeof(xfs_ext_irec_t)); 4446 /* 4447 * Move records down in the array so the 4448 * new page can use erp_idx. 4449 */ 4450 erp = ifp->if_u1.if_ext_irec; 4451 for (i = nlists - 1; i > erp_idx; i--) { 4452 memmove(&erp[i], &erp[i-1], sizeof(xfs_ext_irec_t)); 4453 } 4454 ASSERT(i == erp_idx); 4455 4456 /* Initialize new extent record */ 4457 erp = ifp->if_u1.if_ext_irec; 4458 erp[erp_idx].er_extbuf = kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP); 4459 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ; 4460 memset(erp[erp_idx].er_extbuf, 0, XFS_IEXT_BUFSZ); 4461 erp[erp_idx].er_extcount = 0; 4462 erp[erp_idx].er_extoff = erp_idx > 0 ? 4463 erp[erp_idx-1].er_extoff + erp[erp_idx-1].er_extcount : 0; 4464 return (&erp[erp_idx]); 4465 } 4466 4467 /* 4468 * Remove a record from the indirection array. 4469 */ 4470 void 4471 xfs_iext_irec_remove( 4472 xfs_ifork_t *ifp, /* inode fork pointer */ 4473 int erp_idx) /* irec index to remove */ 4474 { 4475 xfs_ext_irec_t *erp; /* indirection array pointer */ 4476 int i; /* loop counter */ 4477 int nlists; /* number of irec's (ex lists) */ 4478 4479 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4480 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4481 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4482 if (erp->er_extbuf) { 4483 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, 4484 -erp->er_extcount); 4485 kmem_free(erp->er_extbuf, XFS_IEXT_BUFSZ); 4486 } 4487 /* Compact extent records */ 4488 erp = ifp->if_u1.if_ext_irec; 4489 for (i = erp_idx; i < nlists - 1; i++) { 4490 memmove(&erp[i], &erp[i+1], sizeof(xfs_ext_irec_t)); 4491 } 4492 /* 4493 * Manually free the last extent record from the indirection 4494 * array. A call to xfs_iext_realloc_indirect() with a size 4495 * of zero would result in a call to xfs_iext_destroy() which 4496 * would in turn call this function again, creating a nasty 4497 * infinite loop. 4498 */ 4499 if (--nlists) { 4500 xfs_iext_realloc_indirect(ifp, 4501 nlists * sizeof(xfs_ext_irec_t)); 4502 } else { 4503 kmem_free(ifp->if_u1.if_ext_irec, 4504 sizeof(xfs_ext_irec_t)); 4505 } 4506 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ; 4507 } 4508 4509 /* 4510 * This is called to clean up large amounts of unused memory allocated 4511 * by the indirection array. Before compacting anything though, verify 4512 * that the indirection array is still needed and switch back to the 4513 * linear extent list (or even the inline buffer) if possible. The 4514 * compaction policy is as follows: 4515 * 4516 * Full Compaction: Extents fit into a single page (or inline buffer) 4517 * Full Compaction: Extents occupy less than 10% of allocated space 4518 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space 4519 * No Compaction: Extents occupy at least 50% of allocated space 4520 */ 4521 void 4522 xfs_iext_irec_compact( 4523 xfs_ifork_t *ifp) /* inode fork pointer */ 4524 { 4525 xfs_extnum_t nextents; /* number of extents in file */ 4526 int nlists; /* number of irec's (ex lists) */ 4527 4528 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4529 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4530 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4531 4532 if (nextents == 0) { 4533 xfs_iext_destroy(ifp); 4534 } else if (nextents <= XFS_INLINE_EXTS) { 4535 xfs_iext_indirect_to_direct(ifp); 4536 xfs_iext_direct_to_inline(ifp, nextents); 4537 } else if (nextents <= XFS_LINEAR_EXTS) { 4538 xfs_iext_indirect_to_direct(ifp); 4539 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 3) { 4540 xfs_iext_irec_compact_full(ifp); 4541 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 1) { 4542 xfs_iext_irec_compact_pages(ifp); 4543 } 4544 } 4545 4546 /* 4547 * Combine extents from neighboring extent pages. 4548 */ 4549 void 4550 xfs_iext_irec_compact_pages( 4551 xfs_ifork_t *ifp) /* inode fork pointer */ 4552 { 4553 xfs_ext_irec_t *erp, *erp_next;/* pointers to irec entries */ 4554 int erp_idx = 0; /* indirection array index */ 4555 int nlists; /* number of irec's (ex lists) */ 4556 4557 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4558 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4559 while (erp_idx < nlists - 1) { 4560 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4561 erp_next = erp + 1; 4562 if (erp_next->er_extcount <= 4563 (XFS_LINEAR_EXTS - erp->er_extcount)) { 4564 memmove(&erp->er_extbuf[erp->er_extcount], 4565 erp_next->er_extbuf, erp_next->er_extcount * 4566 sizeof(xfs_bmbt_rec_t)); 4567 erp->er_extcount += erp_next->er_extcount; 4568 /* 4569 * Free page before removing extent record 4570 * so er_extoffs don't get modified in 4571 * xfs_iext_irec_remove. 4572 */ 4573 kmem_free(erp_next->er_extbuf, XFS_IEXT_BUFSZ); 4574 erp_next->er_extbuf = NULL; 4575 xfs_iext_irec_remove(ifp, erp_idx + 1); 4576 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4577 } else { 4578 erp_idx++; 4579 } 4580 } 4581 } 4582 4583 /* 4584 * Fully compact the extent records managed by the indirection array. 4585 */ 4586 void 4587 xfs_iext_irec_compact_full( 4588 xfs_ifork_t *ifp) /* inode fork pointer */ 4589 { 4590 xfs_bmbt_rec_host_t *ep, *ep_next; /* extent record pointers */ 4591 xfs_ext_irec_t *erp, *erp_next; /* extent irec pointers */ 4592 int erp_idx = 0; /* extent irec index */ 4593 int ext_avail; /* empty entries in ex list */ 4594 int ext_diff; /* number of exts to add */ 4595 int nlists; /* number of irec's (ex lists) */ 4596 4597 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4598 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4599 erp = ifp->if_u1.if_ext_irec; 4600 ep = &erp->er_extbuf[erp->er_extcount]; 4601 erp_next = erp + 1; 4602 ep_next = erp_next->er_extbuf; 4603 while (erp_idx < nlists - 1) { 4604 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount; 4605 ext_diff = MIN(ext_avail, erp_next->er_extcount); 4606 memcpy(ep, ep_next, ext_diff * sizeof(xfs_bmbt_rec_t)); 4607 erp->er_extcount += ext_diff; 4608 erp_next->er_extcount -= ext_diff; 4609 /* Remove next page */ 4610 if (erp_next->er_extcount == 0) { 4611 /* 4612 * Free page before removing extent record 4613 * so er_extoffs don't get modified in 4614 * xfs_iext_irec_remove. 4615 */ 4616 kmem_free(erp_next->er_extbuf, 4617 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t)); 4618 erp_next->er_extbuf = NULL; 4619 xfs_iext_irec_remove(ifp, erp_idx + 1); 4620 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4621 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4622 /* Update next page */ 4623 } else { 4624 /* Move rest of page up to become next new page */ 4625 memmove(erp_next->er_extbuf, ep_next, 4626 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t)); 4627 ep_next = erp_next->er_extbuf; 4628 memset(&ep_next[erp_next->er_extcount], 0, 4629 (XFS_LINEAR_EXTS - erp_next->er_extcount) * 4630 sizeof(xfs_bmbt_rec_t)); 4631 } 4632 if (erp->er_extcount == XFS_LINEAR_EXTS) { 4633 erp_idx++; 4634 if (erp_idx < nlists) 4635 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4636 else 4637 break; 4638 } 4639 ep = &erp->er_extbuf[erp->er_extcount]; 4640 erp_next = erp + 1; 4641 ep_next = erp_next->er_extbuf; 4642 } 4643 } 4644 4645 /* 4646 * This is called to update the er_extoff field in the indirection 4647 * array when extents have been added or removed from one of the 4648 * extent lists. erp_idx contains the irec index to begin updating 4649 * at and ext_diff contains the number of extents that were added 4650 * or removed. 4651 */ 4652 void 4653 xfs_iext_irec_update_extoffs( 4654 xfs_ifork_t *ifp, /* inode fork pointer */ 4655 int erp_idx, /* irec index to update */ 4656 int ext_diff) /* number of new extents */ 4657 { 4658 int i; /* loop counter */ 4659 int nlists; /* number of irec's (ex lists */ 4660 4661 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4662 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4663 for (i = erp_idx; i < nlists; i++) { 4664 ifp->if_u1.if_ext_irec[i].er_extoff += ext_diff; 4665 } 4666 } 4667