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