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 /* 2736 * If the inode is currently being reclaimed, the 2737 * linux inode _and_ the xfs vnode may have been 2738 * freed so we cannot reference either of them safely. 2739 * Hence we should not try to do anything to them 2740 * if the xfs inode is currently in the reclaim 2741 * path. 2742 * 2743 * However, we still need to issue the unpin wakeup 2744 * call as the inode reclaim may be blocked waiting for 2745 * the inode to become unpinned. 2746 */ 2747 if (!(ip->i_flags & (XFS_IRECLAIM|XFS_IRECLAIMABLE))) { 2748 vnode_t *vp = XFS_ITOV_NULL(ip); 2749 2750 /* make sync come back and flush this inode */ 2751 if (vp) { 2752 struct inode *inode = vn_to_inode(vp); 2753 2754 if (!(inode->i_state & I_NEW)) 2755 mark_inode_dirty_sync(inode); 2756 } 2757 } 2758 wake_up(&ip->i_ipin_wait); 2759 } 2760 } 2761 2762 /* 2763 * This is called to wait for the given inode to be unpinned. 2764 * It will sleep until this happens. The caller must have the 2765 * inode locked in at least shared mode so that the buffer cannot 2766 * be subsequently pinned once someone is waiting for it to be 2767 * unpinned. 2768 */ 2769 STATIC void 2770 xfs_iunpin_wait( 2771 xfs_inode_t *ip) 2772 { 2773 xfs_inode_log_item_t *iip; 2774 xfs_lsn_t lsn; 2775 2776 ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE | MR_ACCESS)); 2777 2778 if (atomic_read(&ip->i_pincount) == 0) { 2779 return; 2780 } 2781 2782 iip = ip->i_itemp; 2783 if (iip && iip->ili_last_lsn) { 2784 lsn = iip->ili_last_lsn; 2785 } else { 2786 lsn = (xfs_lsn_t)0; 2787 } 2788 2789 /* 2790 * Give the log a push so we don't wait here too long. 2791 */ 2792 xfs_log_force(ip->i_mount, lsn, XFS_LOG_FORCE); 2793 2794 wait_event(ip->i_ipin_wait, (atomic_read(&ip->i_pincount) == 0)); 2795 } 2796 2797 2798 /* 2799 * xfs_iextents_copy() 2800 * 2801 * This is called to copy the REAL extents (as opposed to the delayed 2802 * allocation extents) from the inode into the given buffer. It 2803 * returns the number of bytes copied into the buffer. 2804 * 2805 * If there are no delayed allocation extents, then we can just 2806 * memcpy() the extents into the buffer. Otherwise, we need to 2807 * examine each extent in turn and skip those which are delayed. 2808 */ 2809 int 2810 xfs_iextents_copy( 2811 xfs_inode_t *ip, 2812 xfs_bmbt_rec_t *buffer, 2813 int whichfork) 2814 { 2815 int copied; 2816 xfs_bmbt_rec_t *dest_ep; 2817 xfs_bmbt_rec_t *ep; 2818 #ifdef XFS_BMAP_TRACE 2819 static char fname[] = "xfs_iextents_copy"; 2820 #endif 2821 int i; 2822 xfs_ifork_t *ifp; 2823 int nrecs; 2824 xfs_fsblock_t start_block; 2825 2826 ifp = XFS_IFORK_PTR(ip, whichfork); 2827 ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS)); 2828 ASSERT(ifp->if_bytes > 0); 2829 2830 nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 2831 xfs_bmap_trace_exlist(fname, ip, nrecs, whichfork); 2832 ASSERT(nrecs > 0); 2833 2834 /* 2835 * There are some delayed allocation extents in the 2836 * inode, so copy the extents one at a time and skip 2837 * the delayed ones. There must be at least one 2838 * non-delayed extent. 2839 */ 2840 dest_ep = buffer; 2841 copied = 0; 2842 for (i = 0; i < nrecs; i++) { 2843 ep = xfs_iext_get_ext(ifp, i); 2844 start_block = xfs_bmbt_get_startblock(ep); 2845 if (ISNULLSTARTBLOCK(start_block)) { 2846 /* 2847 * It's a delayed allocation extent, so skip it. 2848 */ 2849 continue; 2850 } 2851 2852 /* Translate to on disk format */ 2853 put_unaligned(INT_GET(ep->l0, ARCH_CONVERT), 2854 (__uint64_t*)&dest_ep->l0); 2855 put_unaligned(INT_GET(ep->l1, ARCH_CONVERT), 2856 (__uint64_t*)&dest_ep->l1); 2857 dest_ep++; 2858 copied++; 2859 } 2860 ASSERT(copied != 0); 2861 xfs_validate_extents(ifp, copied, 1, XFS_EXTFMT_INODE(ip)); 2862 2863 return (copied * (uint)sizeof(xfs_bmbt_rec_t)); 2864 } 2865 2866 /* 2867 * Each of the following cases stores data into the same region 2868 * of the on-disk inode, so only one of them can be valid at 2869 * any given time. While it is possible to have conflicting formats 2870 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is 2871 * in EXTENTS format, this can only happen when the fork has 2872 * changed formats after being modified but before being flushed. 2873 * In these cases, the format always takes precedence, because the 2874 * format indicates the current state of the fork. 2875 */ 2876 /*ARGSUSED*/ 2877 STATIC int 2878 xfs_iflush_fork( 2879 xfs_inode_t *ip, 2880 xfs_dinode_t *dip, 2881 xfs_inode_log_item_t *iip, 2882 int whichfork, 2883 xfs_buf_t *bp) 2884 { 2885 char *cp; 2886 xfs_ifork_t *ifp; 2887 xfs_mount_t *mp; 2888 #ifdef XFS_TRANS_DEBUG 2889 int first; 2890 #endif 2891 static const short brootflag[2] = 2892 { XFS_ILOG_DBROOT, XFS_ILOG_ABROOT }; 2893 static const short dataflag[2] = 2894 { XFS_ILOG_DDATA, XFS_ILOG_ADATA }; 2895 static const short extflag[2] = 2896 { XFS_ILOG_DEXT, XFS_ILOG_AEXT }; 2897 2898 if (iip == NULL) 2899 return 0; 2900 ifp = XFS_IFORK_PTR(ip, whichfork); 2901 /* 2902 * This can happen if we gave up in iformat in an error path, 2903 * for the attribute fork. 2904 */ 2905 if (ifp == NULL) { 2906 ASSERT(whichfork == XFS_ATTR_FORK); 2907 return 0; 2908 } 2909 cp = XFS_DFORK_PTR(dip, whichfork); 2910 mp = ip->i_mount; 2911 switch (XFS_IFORK_FORMAT(ip, whichfork)) { 2912 case XFS_DINODE_FMT_LOCAL: 2913 if ((iip->ili_format.ilf_fields & dataflag[whichfork]) && 2914 (ifp->if_bytes > 0)) { 2915 ASSERT(ifp->if_u1.if_data != NULL); 2916 ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork)); 2917 memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes); 2918 } 2919 if (whichfork == XFS_DATA_FORK) { 2920 if (unlikely(XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp, dip))) { 2921 XFS_ERROR_REPORT("xfs_iflush_fork", 2922 XFS_ERRLEVEL_LOW, mp); 2923 return XFS_ERROR(EFSCORRUPTED); 2924 } 2925 } 2926 break; 2927 2928 case XFS_DINODE_FMT_EXTENTS: 2929 ASSERT((ifp->if_flags & XFS_IFEXTENTS) || 2930 !(iip->ili_format.ilf_fields & extflag[whichfork])); 2931 ASSERT((xfs_iext_get_ext(ifp, 0) != NULL) || 2932 (ifp->if_bytes == 0)); 2933 ASSERT((xfs_iext_get_ext(ifp, 0) == NULL) || 2934 (ifp->if_bytes > 0)); 2935 if ((iip->ili_format.ilf_fields & extflag[whichfork]) && 2936 (ifp->if_bytes > 0)) { 2937 ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) > 0); 2938 (void)xfs_iextents_copy(ip, (xfs_bmbt_rec_t *)cp, 2939 whichfork); 2940 } 2941 break; 2942 2943 case XFS_DINODE_FMT_BTREE: 2944 if ((iip->ili_format.ilf_fields & brootflag[whichfork]) && 2945 (ifp->if_broot_bytes > 0)) { 2946 ASSERT(ifp->if_broot != NULL); 2947 ASSERT(ifp->if_broot_bytes <= 2948 (XFS_IFORK_SIZE(ip, whichfork) + 2949 XFS_BROOT_SIZE_ADJ)); 2950 xfs_bmbt_to_bmdr(ifp->if_broot, ifp->if_broot_bytes, 2951 (xfs_bmdr_block_t *)cp, 2952 XFS_DFORK_SIZE(dip, mp, whichfork)); 2953 } 2954 break; 2955 2956 case XFS_DINODE_FMT_DEV: 2957 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) { 2958 ASSERT(whichfork == XFS_DATA_FORK); 2959 INT_SET(dip->di_u.di_dev, ARCH_CONVERT, ip->i_df.if_u2.if_rdev); 2960 } 2961 break; 2962 2963 case XFS_DINODE_FMT_UUID: 2964 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) { 2965 ASSERT(whichfork == XFS_DATA_FORK); 2966 memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid, 2967 sizeof(uuid_t)); 2968 } 2969 break; 2970 2971 default: 2972 ASSERT(0); 2973 break; 2974 } 2975 2976 return 0; 2977 } 2978 2979 /* 2980 * xfs_iflush() will write a modified inode's changes out to the 2981 * inode's on disk home. The caller must have the inode lock held 2982 * in at least shared mode and the inode flush semaphore must be 2983 * held as well. The inode lock will still be held upon return from 2984 * the call and the caller is free to unlock it. 2985 * The inode flush lock will be unlocked when the inode reaches the disk. 2986 * The flags indicate how the inode's buffer should be written out. 2987 */ 2988 int 2989 xfs_iflush( 2990 xfs_inode_t *ip, 2991 uint flags) 2992 { 2993 xfs_inode_log_item_t *iip; 2994 xfs_buf_t *bp; 2995 xfs_dinode_t *dip; 2996 xfs_mount_t *mp; 2997 int error; 2998 /* REFERENCED */ 2999 xfs_chash_t *ch; 3000 xfs_inode_t *iq; 3001 int clcount; /* count of inodes clustered */ 3002 int bufwasdelwri; 3003 enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) }; 3004 SPLDECL(s); 3005 3006 XFS_STATS_INC(xs_iflush_count); 3007 3008 ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS)); 3009 ASSERT(valusema(&ip->i_flock) <= 0); 3010 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE || 3011 ip->i_d.di_nextents > ip->i_df.if_ext_max); 3012 3013 iip = ip->i_itemp; 3014 mp = ip->i_mount; 3015 3016 /* 3017 * If the inode isn't dirty, then just release the inode 3018 * flush lock and do nothing. 3019 */ 3020 if ((ip->i_update_core == 0) && 3021 ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL))) { 3022 ASSERT((iip != NULL) ? 3023 !(iip->ili_item.li_flags & XFS_LI_IN_AIL) : 1); 3024 xfs_ifunlock(ip); 3025 return 0; 3026 } 3027 3028 /* 3029 * We can't flush the inode until it is unpinned, so 3030 * wait for it. We know noone new can pin it, because 3031 * we are holding the inode lock shared and you need 3032 * to hold it exclusively to pin the inode. 3033 */ 3034 xfs_iunpin_wait(ip); 3035 3036 /* 3037 * This may have been unpinned because the filesystem is shutting 3038 * down forcibly. If that's the case we must not write this inode 3039 * to disk, because the log record didn't make it to disk! 3040 */ 3041 if (XFS_FORCED_SHUTDOWN(mp)) { 3042 ip->i_update_core = 0; 3043 if (iip) 3044 iip->ili_format.ilf_fields = 0; 3045 xfs_ifunlock(ip); 3046 return XFS_ERROR(EIO); 3047 } 3048 3049 /* 3050 * Get the buffer containing the on-disk inode. 3051 */ 3052 error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0); 3053 if (error) { 3054 xfs_ifunlock(ip); 3055 return error; 3056 } 3057 3058 /* 3059 * Decide how buffer will be flushed out. This is done before 3060 * the call to xfs_iflush_int because this field is zeroed by it. 3061 */ 3062 if (iip != NULL && iip->ili_format.ilf_fields != 0) { 3063 /* 3064 * Flush out the inode buffer according to the directions 3065 * of the caller. In the cases where the caller has given 3066 * us a choice choose the non-delwri case. This is because 3067 * the inode is in the AIL and we need to get it out soon. 3068 */ 3069 switch (flags) { 3070 case XFS_IFLUSH_SYNC: 3071 case XFS_IFLUSH_DELWRI_ELSE_SYNC: 3072 flags = 0; 3073 break; 3074 case XFS_IFLUSH_ASYNC: 3075 case XFS_IFLUSH_DELWRI_ELSE_ASYNC: 3076 flags = INT_ASYNC; 3077 break; 3078 case XFS_IFLUSH_DELWRI: 3079 flags = INT_DELWRI; 3080 break; 3081 default: 3082 ASSERT(0); 3083 flags = 0; 3084 break; 3085 } 3086 } else { 3087 switch (flags) { 3088 case XFS_IFLUSH_DELWRI_ELSE_SYNC: 3089 case XFS_IFLUSH_DELWRI_ELSE_ASYNC: 3090 case XFS_IFLUSH_DELWRI: 3091 flags = INT_DELWRI; 3092 break; 3093 case XFS_IFLUSH_ASYNC: 3094 flags = INT_ASYNC; 3095 break; 3096 case XFS_IFLUSH_SYNC: 3097 flags = 0; 3098 break; 3099 default: 3100 ASSERT(0); 3101 flags = 0; 3102 break; 3103 } 3104 } 3105 3106 /* 3107 * First flush out the inode that xfs_iflush was called with. 3108 */ 3109 error = xfs_iflush_int(ip, bp); 3110 if (error) { 3111 goto corrupt_out; 3112 } 3113 3114 /* 3115 * inode clustering: 3116 * see if other inodes can be gathered into this write 3117 */ 3118 3119 ip->i_chash->chl_buf = bp; 3120 3121 ch = XFS_CHASH(mp, ip->i_blkno); 3122 s = mutex_spinlock(&ch->ch_lock); 3123 3124 clcount = 0; 3125 for (iq = ip->i_cnext; iq != ip; iq = iq->i_cnext) { 3126 /* 3127 * Do an un-protected check to see if the inode is dirty and 3128 * is a candidate for flushing. These checks will be repeated 3129 * later after the appropriate locks are acquired. 3130 */ 3131 iip = iq->i_itemp; 3132 if ((iq->i_update_core == 0) && 3133 ((iip == NULL) || 3134 !(iip->ili_format.ilf_fields & XFS_ILOG_ALL)) && 3135 xfs_ipincount(iq) == 0) { 3136 continue; 3137 } 3138 3139 /* 3140 * Try to get locks. If any are unavailable, 3141 * then this inode cannot be flushed and is skipped. 3142 */ 3143 3144 /* get inode locks (just i_lock) */ 3145 if (xfs_ilock_nowait(iq, XFS_ILOCK_SHARED)) { 3146 /* get inode flush lock */ 3147 if (xfs_iflock_nowait(iq)) { 3148 /* check if pinned */ 3149 if (xfs_ipincount(iq) == 0) { 3150 /* arriving here means that 3151 * this inode can be flushed. 3152 * first re-check that it's 3153 * dirty 3154 */ 3155 iip = iq->i_itemp; 3156 if ((iq->i_update_core != 0)|| 3157 ((iip != NULL) && 3158 (iip->ili_format.ilf_fields & XFS_ILOG_ALL))) { 3159 clcount++; 3160 error = xfs_iflush_int(iq, bp); 3161 if (error) { 3162 xfs_iunlock(iq, 3163 XFS_ILOCK_SHARED); 3164 goto cluster_corrupt_out; 3165 } 3166 } else { 3167 xfs_ifunlock(iq); 3168 } 3169 } else { 3170 xfs_ifunlock(iq); 3171 } 3172 } 3173 xfs_iunlock(iq, XFS_ILOCK_SHARED); 3174 } 3175 } 3176 mutex_spinunlock(&ch->ch_lock, s); 3177 3178 if (clcount) { 3179 XFS_STATS_INC(xs_icluster_flushcnt); 3180 XFS_STATS_ADD(xs_icluster_flushinode, clcount); 3181 } 3182 3183 /* 3184 * If the buffer is pinned then push on the log so we won't 3185 * get stuck waiting in the write for too long. 3186 */ 3187 if (XFS_BUF_ISPINNED(bp)){ 3188 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE); 3189 } 3190 3191 if (flags & INT_DELWRI) { 3192 xfs_bdwrite(mp, bp); 3193 } else if (flags & INT_ASYNC) { 3194 xfs_bawrite(mp, bp); 3195 } else { 3196 error = xfs_bwrite(mp, bp); 3197 } 3198 return error; 3199 3200 corrupt_out: 3201 xfs_buf_relse(bp); 3202 xfs_force_shutdown(mp, XFS_CORRUPT_INCORE); 3203 xfs_iflush_abort(ip); 3204 /* 3205 * Unlocks the flush lock 3206 */ 3207 return XFS_ERROR(EFSCORRUPTED); 3208 3209 cluster_corrupt_out: 3210 /* Corruption detected in the clustering loop. Invalidate the 3211 * inode buffer and shut down the filesystem. 3212 */ 3213 mutex_spinunlock(&ch->ch_lock, s); 3214 3215 /* 3216 * Clean up the buffer. If it was B_DELWRI, just release it -- 3217 * brelse can handle it with no problems. If not, shut down the 3218 * filesystem before releasing the buffer. 3219 */ 3220 if ((bufwasdelwri= XFS_BUF_ISDELAYWRITE(bp))) { 3221 xfs_buf_relse(bp); 3222 } 3223 3224 xfs_force_shutdown(mp, XFS_CORRUPT_INCORE); 3225 3226 if(!bufwasdelwri) { 3227 /* 3228 * Just like incore_relse: if we have b_iodone functions, 3229 * mark the buffer as an error and call them. Otherwise 3230 * mark it as stale and brelse. 3231 */ 3232 if (XFS_BUF_IODONE_FUNC(bp)) { 3233 XFS_BUF_CLR_BDSTRAT_FUNC(bp); 3234 XFS_BUF_UNDONE(bp); 3235 XFS_BUF_STALE(bp); 3236 XFS_BUF_SHUT(bp); 3237 XFS_BUF_ERROR(bp,EIO); 3238 xfs_biodone(bp); 3239 } else { 3240 XFS_BUF_STALE(bp); 3241 xfs_buf_relse(bp); 3242 } 3243 } 3244 3245 xfs_iflush_abort(iq); 3246 /* 3247 * Unlocks the flush lock 3248 */ 3249 return XFS_ERROR(EFSCORRUPTED); 3250 } 3251 3252 3253 STATIC int 3254 xfs_iflush_int( 3255 xfs_inode_t *ip, 3256 xfs_buf_t *bp) 3257 { 3258 xfs_inode_log_item_t *iip; 3259 xfs_dinode_t *dip; 3260 xfs_mount_t *mp; 3261 #ifdef XFS_TRANS_DEBUG 3262 int first; 3263 #endif 3264 SPLDECL(s); 3265 3266 ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS)); 3267 ASSERT(valusema(&ip->i_flock) <= 0); 3268 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE || 3269 ip->i_d.di_nextents > ip->i_df.if_ext_max); 3270 3271 iip = ip->i_itemp; 3272 mp = ip->i_mount; 3273 3274 3275 /* 3276 * If the inode isn't dirty, then just release the inode 3277 * flush lock and do nothing. 3278 */ 3279 if ((ip->i_update_core == 0) && 3280 ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL))) { 3281 xfs_ifunlock(ip); 3282 return 0; 3283 } 3284 3285 /* set *dip = inode's place in the buffer */ 3286 dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_boffset); 3287 3288 /* 3289 * Clear i_update_core before copying out the data. 3290 * This is for coordination with our timestamp updates 3291 * that don't hold the inode lock. They will always 3292 * update the timestamps BEFORE setting i_update_core, 3293 * so if we clear i_update_core after they set it we 3294 * are guaranteed to see their updates to the timestamps. 3295 * I believe that this depends on strongly ordered memory 3296 * semantics, but we have that. We use the SYNCHRONIZE 3297 * macro to make sure that the compiler does not reorder 3298 * the i_update_core access below the data copy below. 3299 */ 3300 ip->i_update_core = 0; 3301 SYNCHRONIZE(); 3302 3303 /* 3304 * Make sure to get the latest atime from the Linux inode. 3305 */ 3306 xfs_synchronize_atime(ip); 3307 3308 if (XFS_TEST_ERROR(INT_GET(dip->di_core.di_magic,ARCH_CONVERT) != XFS_DINODE_MAGIC, 3309 mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) { 3310 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3311 "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p", 3312 ip->i_ino, (int) INT_GET(dip->di_core.di_magic, ARCH_CONVERT), dip); 3313 goto corrupt_out; 3314 } 3315 if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC, 3316 mp, XFS_ERRTAG_IFLUSH_2, XFS_RANDOM_IFLUSH_2)) { 3317 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3318 "xfs_iflush: Bad inode %Lu, ptr 0x%p, magic number 0x%x", 3319 ip->i_ino, ip, ip->i_d.di_magic); 3320 goto corrupt_out; 3321 } 3322 if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) { 3323 if (XFS_TEST_ERROR( 3324 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) && 3325 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE), 3326 mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) { 3327 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3328 "xfs_iflush: Bad regular inode %Lu, ptr 0x%p", 3329 ip->i_ino, ip); 3330 goto corrupt_out; 3331 } 3332 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) { 3333 if (XFS_TEST_ERROR( 3334 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) && 3335 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) && 3336 (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL), 3337 mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) { 3338 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3339 "xfs_iflush: Bad directory inode %Lu, ptr 0x%p", 3340 ip->i_ino, ip); 3341 goto corrupt_out; 3342 } 3343 } 3344 if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents > 3345 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5, 3346 XFS_RANDOM_IFLUSH_5)) { 3347 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3348 "xfs_iflush: detected corrupt incore inode %Lu, total extents = %d, nblocks = %Ld, ptr 0x%p", 3349 ip->i_ino, 3350 ip->i_d.di_nextents + ip->i_d.di_anextents, 3351 ip->i_d.di_nblocks, 3352 ip); 3353 goto corrupt_out; 3354 } 3355 if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize, 3356 mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) { 3357 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp, 3358 "xfs_iflush: bad inode %Lu, forkoff 0x%x, ptr 0x%p", 3359 ip->i_ino, ip->i_d.di_forkoff, ip); 3360 goto corrupt_out; 3361 } 3362 /* 3363 * bump the flush iteration count, used to detect flushes which 3364 * postdate a log record during recovery. 3365 */ 3366 3367 ip->i_d.di_flushiter++; 3368 3369 /* 3370 * Copy the dirty parts of the inode into the on-disk 3371 * inode. We always copy out the core of the inode, 3372 * because if the inode is dirty at all the core must 3373 * be. 3374 */ 3375 xfs_xlate_dinode_core((xfs_caddr_t)&(dip->di_core), &(ip->i_d), -1); 3376 3377 /* Wrap, we never let the log put out DI_MAX_FLUSH */ 3378 if (ip->i_d.di_flushiter == DI_MAX_FLUSH) 3379 ip->i_d.di_flushiter = 0; 3380 3381 /* 3382 * If this is really an old format inode and the superblock version 3383 * has not been updated to support only new format inodes, then 3384 * convert back to the old inode format. If the superblock version 3385 * has been updated, then make the conversion permanent. 3386 */ 3387 ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 || 3388 XFS_SB_VERSION_HASNLINK(&mp->m_sb)); 3389 if (ip->i_d.di_version == XFS_DINODE_VERSION_1) { 3390 if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) { 3391 /* 3392 * Convert it back. 3393 */ 3394 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1); 3395 INT_SET(dip->di_core.di_onlink, ARCH_CONVERT, ip->i_d.di_nlink); 3396 } else { 3397 /* 3398 * The superblock version has already been bumped, 3399 * so just make the conversion to the new inode 3400 * format permanent. 3401 */ 3402 ip->i_d.di_version = XFS_DINODE_VERSION_2; 3403 INT_SET(dip->di_core.di_version, ARCH_CONVERT, XFS_DINODE_VERSION_2); 3404 ip->i_d.di_onlink = 0; 3405 dip->di_core.di_onlink = 0; 3406 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad)); 3407 memset(&(dip->di_core.di_pad[0]), 0, 3408 sizeof(dip->di_core.di_pad)); 3409 ASSERT(ip->i_d.di_projid == 0); 3410 } 3411 } 3412 3413 if (xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp) == EFSCORRUPTED) { 3414 goto corrupt_out; 3415 } 3416 3417 if (XFS_IFORK_Q(ip)) { 3418 /* 3419 * The only error from xfs_iflush_fork is on the data fork. 3420 */ 3421 (void) xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp); 3422 } 3423 xfs_inobp_check(mp, bp); 3424 3425 /* 3426 * We've recorded everything logged in the inode, so we'd 3427 * like to clear the ilf_fields bits so we don't log and 3428 * flush things unnecessarily. However, we can't stop 3429 * logging all this information until the data we've copied 3430 * into the disk buffer is written to disk. If we did we might 3431 * overwrite the copy of the inode in the log with all the 3432 * data after re-logging only part of it, and in the face of 3433 * a crash we wouldn't have all the data we need to recover. 3434 * 3435 * What we do is move the bits to the ili_last_fields field. 3436 * When logging the inode, these bits are moved back to the 3437 * ilf_fields field. In the xfs_iflush_done() routine we 3438 * clear ili_last_fields, since we know that the information 3439 * those bits represent is permanently on disk. As long as 3440 * the flush completes before the inode is logged again, then 3441 * both ilf_fields and ili_last_fields will be cleared. 3442 * 3443 * We can play with the ilf_fields bits here, because the inode 3444 * lock must be held exclusively in order to set bits there 3445 * and the flush lock protects the ili_last_fields bits. 3446 * Set ili_logged so the flush done 3447 * routine can tell whether or not to look in the AIL. 3448 * Also, store the current LSN of the inode so that we can tell 3449 * whether the item has moved in the AIL from xfs_iflush_done(). 3450 * In order to read the lsn we need the AIL lock, because 3451 * it is a 64 bit value that cannot be read atomically. 3452 */ 3453 if (iip != NULL && iip->ili_format.ilf_fields != 0) { 3454 iip->ili_last_fields = iip->ili_format.ilf_fields; 3455 iip->ili_format.ilf_fields = 0; 3456 iip->ili_logged = 1; 3457 3458 ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */ 3459 AIL_LOCK(mp,s); 3460 iip->ili_flush_lsn = iip->ili_item.li_lsn; 3461 AIL_UNLOCK(mp, s); 3462 3463 /* 3464 * Attach the function xfs_iflush_done to the inode's 3465 * buffer. This will remove the inode from the AIL 3466 * and unlock the inode's flush lock when the inode is 3467 * completely written to disk. 3468 */ 3469 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*)) 3470 xfs_iflush_done, (xfs_log_item_t *)iip); 3471 3472 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL); 3473 ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL); 3474 } else { 3475 /* 3476 * We're flushing an inode which is not in the AIL and has 3477 * not been logged but has i_update_core set. For this 3478 * case we can use a B_DELWRI flush and immediately drop 3479 * the inode flush lock because we can avoid the whole 3480 * AIL state thing. It's OK to drop the flush lock now, 3481 * because we've already locked the buffer and to do anything 3482 * you really need both. 3483 */ 3484 if (iip != NULL) { 3485 ASSERT(iip->ili_logged == 0); 3486 ASSERT(iip->ili_last_fields == 0); 3487 ASSERT((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0); 3488 } 3489 xfs_ifunlock(ip); 3490 } 3491 3492 return 0; 3493 3494 corrupt_out: 3495 return XFS_ERROR(EFSCORRUPTED); 3496 } 3497 3498 3499 /* 3500 * Flush all inactive inodes in mp. 3501 */ 3502 void 3503 xfs_iflush_all( 3504 xfs_mount_t *mp) 3505 { 3506 xfs_inode_t *ip; 3507 vnode_t *vp; 3508 3509 again: 3510 XFS_MOUNT_ILOCK(mp); 3511 ip = mp->m_inodes; 3512 if (ip == NULL) 3513 goto out; 3514 3515 do { 3516 /* Make sure we skip markers inserted by sync */ 3517 if (ip->i_mount == NULL) { 3518 ip = ip->i_mnext; 3519 continue; 3520 } 3521 3522 vp = XFS_ITOV_NULL(ip); 3523 if (!vp) { 3524 XFS_MOUNT_IUNLOCK(mp); 3525 xfs_finish_reclaim(ip, 0, XFS_IFLUSH_ASYNC); 3526 goto again; 3527 } 3528 3529 ASSERT(vn_count(vp) == 0); 3530 3531 ip = ip->i_mnext; 3532 } while (ip != mp->m_inodes); 3533 out: 3534 XFS_MOUNT_IUNLOCK(mp); 3535 } 3536 3537 /* 3538 * xfs_iaccess: check accessibility of inode for mode. 3539 */ 3540 int 3541 xfs_iaccess( 3542 xfs_inode_t *ip, 3543 mode_t mode, 3544 cred_t *cr) 3545 { 3546 int error; 3547 mode_t orgmode = mode; 3548 struct inode *inode = vn_to_inode(XFS_ITOV(ip)); 3549 3550 if (mode & S_IWUSR) { 3551 umode_t imode = inode->i_mode; 3552 3553 if (IS_RDONLY(inode) && 3554 (S_ISREG(imode) || S_ISDIR(imode) || S_ISLNK(imode))) 3555 return XFS_ERROR(EROFS); 3556 3557 if (IS_IMMUTABLE(inode)) 3558 return XFS_ERROR(EACCES); 3559 } 3560 3561 /* 3562 * If there's an Access Control List it's used instead of 3563 * the mode bits. 3564 */ 3565 if ((error = _ACL_XFS_IACCESS(ip, mode, cr)) != -1) 3566 return error ? XFS_ERROR(error) : 0; 3567 3568 if (current_fsuid(cr) != ip->i_d.di_uid) { 3569 mode >>= 3; 3570 if (!in_group_p((gid_t)ip->i_d.di_gid)) 3571 mode >>= 3; 3572 } 3573 3574 /* 3575 * If the DACs are ok we don't need any capability check. 3576 */ 3577 if ((ip->i_d.di_mode & mode) == mode) 3578 return 0; 3579 /* 3580 * Read/write DACs are always overridable. 3581 * Executable DACs are overridable if at least one exec bit is set. 3582 */ 3583 if (!(orgmode & S_IXUSR) || 3584 (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode)) 3585 if (capable_cred(cr, CAP_DAC_OVERRIDE)) 3586 return 0; 3587 3588 if ((orgmode == S_IRUSR) || 3589 (S_ISDIR(inode->i_mode) && (!(orgmode & S_IWUSR)))) { 3590 if (capable_cred(cr, CAP_DAC_READ_SEARCH)) 3591 return 0; 3592 #ifdef NOISE 3593 cmn_err(CE_NOTE, "Ick: mode=%o, orgmode=%o", mode, orgmode); 3594 #endif /* NOISE */ 3595 return XFS_ERROR(EACCES); 3596 } 3597 return XFS_ERROR(EACCES); 3598 } 3599 3600 /* 3601 * xfs_iroundup: round up argument to next power of two 3602 */ 3603 uint 3604 xfs_iroundup( 3605 uint v) 3606 { 3607 int i; 3608 uint m; 3609 3610 if ((v & (v - 1)) == 0) 3611 return v; 3612 ASSERT((v & 0x80000000) == 0); 3613 if ((v & (v + 1)) == 0) 3614 return v + 1; 3615 for (i = 0, m = 1; i < 31; i++, m <<= 1) { 3616 if (v & m) 3617 continue; 3618 v |= m; 3619 if ((v & (v + 1)) == 0) 3620 return v + 1; 3621 } 3622 ASSERT(0); 3623 return( 0 ); 3624 } 3625 3626 #ifdef XFS_ILOCK_TRACE 3627 ktrace_t *xfs_ilock_trace_buf; 3628 3629 void 3630 xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags, inst_t *ra) 3631 { 3632 ktrace_enter(ip->i_lock_trace, 3633 (void *)ip, 3634 (void *)(unsigned long)lock, /* 1 = LOCK, 3=UNLOCK, etc */ 3635 (void *)(unsigned long)lockflags, /* XFS_ILOCK_EXCL etc */ 3636 (void *)ra, /* caller of ilock */ 3637 (void *)(unsigned long)current_cpu(), 3638 (void *)(unsigned long)current_pid(), 3639 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL); 3640 } 3641 #endif 3642 3643 /* 3644 * Return a pointer to the extent record at file index idx. 3645 */ 3646 xfs_bmbt_rec_t * 3647 xfs_iext_get_ext( 3648 xfs_ifork_t *ifp, /* inode fork pointer */ 3649 xfs_extnum_t idx) /* index of target extent */ 3650 { 3651 ASSERT(idx >= 0); 3652 if ((ifp->if_flags & XFS_IFEXTIREC) && (idx == 0)) { 3653 return ifp->if_u1.if_ext_irec->er_extbuf; 3654 } else if (ifp->if_flags & XFS_IFEXTIREC) { 3655 xfs_ext_irec_t *erp; /* irec pointer */ 3656 int erp_idx = 0; /* irec index */ 3657 xfs_extnum_t page_idx = idx; /* ext index in target list */ 3658 3659 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0); 3660 return &erp->er_extbuf[page_idx]; 3661 } else if (ifp->if_bytes) { 3662 return &ifp->if_u1.if_extents[idx]; 3663 } else { 3664 return NULL; 3665 } 3666 } 3667 3668 /* 3669 * Insert new item(s) into the extent records for incore inode 3670 * fork 'ifp'. 'count' new items are inserted at index 'idx'. 3671 */ 3672 void 3673 xfs_iext_insert( 3674 xfs_ifork_t *ifp, /* inode fork pointer */ 3675 xfs_extnum_t idx, /* starting index of new items */ 3676 xfs_extnum_t count, /* number of inserted items */ 3677 xfs_bmbt_irec_t *new) /* items to insert */ 3678 { 3679 xfs_bmbt_rec_t *ep; /* extent record pointer */ 3680 xfs_extnum_t i; /* extent record index */ 3681 3682 ASSERT(ifp->if_flags & XFS_IFEXTENTS); 3683 xfs_iext_add(ifp, idx, count); 3684 for (i = idx; i < idx + count; i++, new++) { 3685 ep = xfs_iext_get_ext(ifp, i); 3686 xfs_bmbt_set_all(ep, new); 3687 } 3688 } 3689 3690 /* 3691 * This is called when the amount of space required for incore file 3692 * extents needs to be increased. The ext_diff parameter stores the 3693 * number of new extents being added and the idx parameter contains 3694 * the extent index where the new extents will be added. If the new 3695 * extents are being appended, then we just need to (re)allocate and 3696 * initialize the space. Otherwise, if the new extents are being 3697 * inserted into the middle of the existing entries, a bit more work 3698 * is required to make room for the new extents to be inserted. The 3699 * caller is responsible for filling in the new extent entries upon 3700 * return. 3701 */ 3702 void 3703 xfs_iext_add( 3704 xfs_ifork_t *ifp, /* inode fork pointer */ 3705 xfs_extnum_t idx, /* index to begin adding exts */ 3706 int ext_diff) /* number of extents to add */ 3707 { 3708 int byte_diff; /* new bytes being added */ 3709 int new_size; /* size of extents after adding */ 3710 xfs_extnum_t nextents; /* number of extents in file */ 3711 3712 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3713 ASSERT((idx >= 0) && (idx <= nextents)); 3714 byte_diff = ext_diff * sizeof(xfs_bmbt_rec_t); 3715 new_size = ifp->if_bytes + byte_diff; 3716 /* 3717 * If the new number of extents (nextents + ext_diff) 3718 * fits inside the inode, then continue to use the inline 3719 * extent buffer. 3720 */ 3721 if (nextents + ext_diff <= XFS_INLINE_EXTS) { 3722 if (idx < nextents) { 3723 memmove(&ifp->if_u2.if_inline_ext[idx + ext_diff], 3724 &ifp->if_u2.if_inline_ext[idx], 3725 (nextents - idx) * sizeof(xfs_bmbt_rec_t)); 3726 memset(&ifp->if_u2.if_inline_ext[idx], 0, byte_diff); 3727 } 3728 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext; 3729 ifp->if_real_bytes = 0; 3730 ifp->if_lastex = nextents + ext_diff; 3731 } 3732 /* 3733 * Otherwise use a linear (direct) extent list. 3734 * If the extents are currently inside the inode, 3735 * xfs_iext_realloc_direct will switch us from 3736 * inline to direct extent allocation mode. 3737 */ 3738 else if (nextents + ext_diff <= XFS_LINEAR_EXTS) { 3739 xfs_iext_realloc_direct(ifp, new_size); 3740 if (idx < nextents) { 3741 memmove(&ifp->if_u1.if_extents[idx + ext_diff], 3742 &ifp->if_u1.if_extents[idx], 3743 (nextents - idx) * sizeof(xfs_bmbt_rec_t)); 3744 memset(&ifp->if_u1.if_extents[idx], 0, byte_diff); 3745 } 3746 } 3747 /* Indirection array */ 3748 else { 3749 xfs_ext_irec_t *erp; 3750 int erp_idx = 0; 3751 int page_idx = idx; 3752 3753 ASSERT(nextents + ext_diff > XFS_LINEAR_EXTS); 3754 if (ifp->if_flags & XFS_IFEXTIREC) { 3755 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 1); 3756 } else { 3757 xfs_iext_irec_init(ifp); 3758 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 3759 erp = ifp->if_u1.if_ext_irec; 3760 } 3761 /* Extents fit in target extent page */ 3762 if (erp && erp->er_extcount + ext_diff <= XFS_LINEAR_EXTS) { 3763 if (page_idx < erp->er_extcount) { 3764 memmove(&erp->er_extbuf[page_idx + ext_diff], 3765 &erp->er_extbuf[page_idx], 3766 (erp->er_extcount - page_idx) * 3767 sizeof(xfs_bmbt_rec_t)); 3768 memset(&erp->er_extbuf[page_idx], 0, byte_diff); 3769 } 3770 erp->er_extcount += ext_diff; 3771 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3772 } 3773 /* Insert a new extent page */ 3774 else if (erp) { 3775 xfs_iext_add_indirect_multi(ifp, 3776 erp_idx, page_idx, ext_diff); 3777 } 3778 /* 3779 * If extent(s) are being appended to the last page in 3780 * the indirection array and the new extent(s) don't fit 3781 * in the page, then erp is NULL and erp_idx is set to 3782 * the next index needed in the indirection array. 3783 */ 3784 else { 3785 int count = ext_diff; 3786 3787 while (count) { 3788 erp = xfs_iext_irec_new(ifp, erp_idx); 3789 erp->er_extcount = count; 3790 count -= MIN(count, (int)XFS_LINEAR_EXTS); 3791 if (count) { 3792 erp_idx++; 3793 } 3794 } 3795 } 3796 } 3797 ifp->if_bytes = new_size; 3798 } 3799 3800 /* 3801 * This is called when incore extents are being added to the indirection 3802 * array and the new extents do not fit in the target extent list. The 3803 * erp_idx parameter contains the irec index for the target extent list 3804 * in the indirection array, and the idx parameter contains the extent 3805 * index within the list. The number of extents being added is stored 3806 * in the count parameter. 3807 * 3808 * |-------| |-------| 3809 * | | | | idx - number of extents before idx 3810 * | idx | | count | 3811 * | | | | count - number of extents being inserted at idx 3812 * |-------| |-------| 3813 * | count | | nex2 | nex2 - number of extents after idx + count 3814 * |-------| |-------| 3815 */ 3816 void 3817 xfs_iext_add_indirect_multi( 3818 xfs_ifork_t *ifp, /* inode fork pointer */ 3819 int erp_idx, /* target extent irec index */ 3820 xfs_extnum_t idx, /* index within target list */ 3821 int count) /* new extents being added */ 3822 { 3823 int byte_diff; /* new bytes being added */ 3824 xfs_ext_irec_t *erp; /* pointer to irec entry */ 3825 xfs_extnum_t ext_diff; /* number of extents to add */ 3826 xfs_extnum_t ext_cnt; /* new extents still needed */ 3827 xfs_extnum_t nex2; /* extents after idx + count */ 3828 xfs_bmbt_rec_t *nex2_ep = NULL; /* temp list for nex2 extents */ 3829 int nlists; /* number of irec's (lists) */ 3830 3831 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 3832 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 3833 nex2 = erp->er_extcount - idx; 3834 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 3835 3836 /* 3837 * Save second part of target extent list 3838 * (all extents past */ 3839 if (nex2) { 3840 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t); 3841 nex2_ep = (xfs_bmbt_rec_t *) kmem_alloc(byte_diff, KM_SLEEP); 3842 memmove(nex2_ep, &erp->er_extbuf[idx], byte_diff); 3843 erp->er_extcount -= nex2; 3844 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -nex2); 3845 memset(&erp->er_extbuf[idx], 0, byte_diff); 3846 } 3847 3848 /* 3849 * Add the new extents to the end of the target 3850 * list, then allocate new irec record(s) and 3851 * extent buffer(s) as needed to store the rest 3852 * of the new extents. 3853 */ 3854 ext_cnt = count; 3855 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS - erp->er_extcount); 3856 if (ext_diff) { 3857 erp->er_extcount += ext_diff; 3858 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3859 ext_cnt -= ext_diff; 3860 } 3861 while (ext_cnt) { 3862 erp_idx++; 3863 erp = xfs_iext_irec_new(ifp, erp_idx); 3864 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS); 3865 erp->er_extcount = ext_diff; 3866 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff); 3867 ext_cnt -= ext_diff; 3868 } 3869 3870 /* Add nex2 extents back to indirection array */ 3871 if (nex2) { 3872 xfs_extnum_t ext_avail; 3873 int i; 3874 3875 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t); 3876 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount; 3877 i = 0; 3878 /* 3879 * If nex2 extents fit in the current page, append 3880 * nex2_ep after the new extents. 3881 */ 3882 if (nex2 <= ext_avail) { 3883 i = erp->er_extcount; 3884 } 3885 /* 3886 * Otherwise, check if space is available in the 3887 * next page. 3888 */ 3889 else if ((erp_idx < nlists - 1) && 3890 (nex2 <= (ext_avail = XFS_LINEAR_EXTS - 3891 ifp->if_u1.if_ext_irec[erp_idx+1].er_extcount))) { 3892 erp_idx++; 3893 erp++; 3894 /* Create a hole for nex2 extents */ 3895 memmove(&erp->er_extbuf[nex2], erp->er_extbuf, 3896 erp->er_extcount * sizeof(xfs_bmbt_rec_t)); 3897 } 3898 /* 3899 * Final choice, create a new extent page for 3900 * nex2 extents. 3901 */ 3902 else { 3903 erp_idx++; 3904 erp = xfs_iext_irec_new(ifp, erp_idx); 3905 } 3906 memmove(&erp->er_extbuf[i], nex2_ep, byte_diff); 3907 kmem_free(nex2_ep, byte_diff); 3908 erp->er_extcount += nex2; 3909 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2); 3910 } 3911 } 3912 3913 /* 3914 * This is called when the amount of space required for incore file 3915 * extents needs to be decreased. The ext_diff parameter stores the 3916 * number of extents to be removed and the idx parameter contains 3917 * the extent index where the extents will be removed from. 3918 * 3919 * If the amount of space needed has decreased below the linear 3920 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous 3921 * extent array. Otherwise, use kmem_realloc() to adjust the 3922 * size to what is needed. 3923 */ 3924 void 3925 xfs_iext_remove( 3926 xfs_ifork_t *ifp, /* inode fork pointer */ 3927 xfs_extnum_t idx, /* index to begin removing exts */ 3928 int ext_diff) /* number of extents to remove */ 3929 { 3930 xfs_extnum_t nextents; /* number of extents in file */ 3931 int new_size; /* size of extents after removal */ 3932 3933 ASSERT(ext_diff > 0); 3934 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3935 new_size = (nextents - ext_diff) * sizeof(xfs_bmbt_rec_t); 3936 3937 if (new_size == 0) { 3938 xfs_iext_destroy(ifp); 3939 } else if (ifp->if_flags & XFS_IFEXTIREC) { 3940 xfs_iext_remove_indirect(ifp, idx, ext_diff); 3941 } else if (ifp->if_real_bytes) { 3942 xfs_iext_remove_direct(ifp, idx, ext_diff); 3943 } else { 3944 xfs_iext_remove_inline(ifp, idx, ext_diff); 3945 } 3946 ifp->if_bytes = new_size; 3947 } 3948 3949 /* 3950 * This removes ext_diff extents from the inline buffer, beginning 3951 * at extent index idx. 3952 */ 3953 void 3954 xfs_iext_remove_inline( 3955 xfs_ifork_t *ifp, /* inode fork pointer */ 3956 xfs_extnum_t idx, /* index to begin removing exts */ 3957 int ext_diff) /* number of extents to remove */ 3958 { 3959 int nextents; /* number of extents in file */ 3960 3961 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 3962 ASSERT(idx < XFS_INLINE_EXTS); 3963 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3964 ASSERT(((nextents - ext_diff) > 0) && 3965 (nextents - ext_diff) < XFS_INLINE_EXTS); 3966 3967 if (idx + ext_diff < nextents) { 3968 memmove(&ifp->if_u2.if_inline_ext[idx], 3969 &ifp->if_u2.if_inline_ext[idx + ext_diff], 3970 (nextents - (idx + ext_diff)) * 3971 sizeof(xfs_bmbt_rec_t)); 3972 memset(&ifp->if_u2.if_inline_ext[nextents - ext_diff], 3973 0, ext_diff * sizeof(xfs_bmbt_rec_t)); 3974 } else { 3975 memset(&ifp->if_u2.if_inline_ext[idx], 0, 3976 ext_diff * sizeof(xfs_bmbt_rec_t)); 3977 } 3978 } 3979 3980 /* 3981 * This removes ext_diff extents from a linear (direct) extent list, 3982 * beginning at extent index idx. If the extents are being removed 3983 * from the end of the list (ie. truncate) then we just need to re- 3984 * allocate the list to remove the extra space. Otherwise, if the 3985 * extents are being removed from the middle of the existing extent 3986 * entries, then we first need to move the extent records beginning 3987 * at idx + ext_diff up in the list to overwrite the records being 3988 * removed, then remove the extra space via kmem_realloc. 3989 */ 3990 void 3991 xfs_iext_remove_direct( 3992 xfs_ifork_t *ifp, /* inode fork pointer */ 3993 xfs_extnum_t idx, /* index to begin removing exts */ 3994 int ext_diff) /* number of extents to remove */ 3995 { 3996 xfs_extnum_t nextents; /* number of extents in file */ 3997 int new_size; /* size of extents after removal */ 3998 3999 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 4000 new_size = ifp->if_bytes - 4001 (ext_diff * sizeof(xfs_bmbt_rec_t)); 4002 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4003 4004 if (new_size == 0) { 4005 xfs_iext_destroy(ifp); 4006 return; 4007 } 4008 /* Move extents up in the list (if needed) */ 4009 if (idx + ext_diff < nextents) { 4010 memmove(&ifp->if_u1.if_extents[idx], 4011 &ifp->if_u1.if_extents[idx + ext_diff], 4012 (nextents - (idx + ext_diff)) * 4013 sizeof(xfs_bmbt_rec_t)); 4014 } 4015 memset(&ifp->if_u1.if_extents[nextents - ext_diff], 4016 0, ext_diff * sizeof(xfs_bmbt_rec_t)); 4017 /* 4018 * Reallocate the direct extent list. If the extents 4019 * will fit inside the inode then xfs_iext_realloc_direct 4020 * will switch from direct to inline extent allocation 4021 * mode for us. 4022 */ 4023 xfs_iext_realloc_direct(ifp, new_size); 4024 ifp->if_bytes = new_size; 4025 } 4026 4027 /* 4028 * This is called when incore extents are being removed from the 4029 * indirection array and the extents being removed span multiple extent 4030 * buffers. The idx parameter contains the file extent index where we 4031 * want to begin removing extents, and the count parameter contains 4032 * how many extents need to be removed. 4033 * 4034 * |-------| |-------| 4035 * | nex1 | | | nex1 - number of extents before idx 4036 * |-------| | count | 4037 * | | | | count - number of extents being removed at idx 4038 * | count | |-------| 4039 * | | | nex2 | nex2 - number of extents after idx + count 4040 * |-------| |-------| 4041 */ 4042 void 4043 xfs_iext_remove_indirect( 4044 xfs_ifork_t *ifp, /* inode fork pointer */ 4045 xfs_extnum_t idx, /* index to begin removing extents */ 4046 int count) /* number of extents to remove */ 4047 { 4048 xfs_ext_irec_t *erp; /* indirection array pointer */ 4049 int erp_idx = 0; /* indirection array index */ 4050 xfs_extnum_t ext_cnt; /* extents left to remove */ 4051 xfs_extnum_t ext_diff; /* extents to remove in current list */ 4052 xfs_extnum_t nex1; /* number of extents before idx */ 4053 xfs_extnum_t nex2; /* extents after idx + count */ 4054 int nlists; /* entries in indirection array */ 4055 int page_idx = idx; /* index in target extent list */ 4056 4057 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4058 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0); 4059 ASSERT(erp != NULL); 4060 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4061 nex1 = page_idx; 4062 ext_cnt = count; 4063 while (ext_cnt) { 4064 nex2 = MAX((erp->er_extcount - (nex1 + ext_cnt)), 0); 4065 ext_diff = MIN(ext_cnt, (erp->er_extcount - nex1)); 4066 /* 4067 * Check for deletion of entire list; 4068 * xfs_iext_irec_remove() updates extent offsets. 4069 */ 4070 if (ext_diff == erp->er_extcount) { 4071 xfs_iext_irec_remove(ifp, erp_idx); 4072 ext_cnt -= ext_diff; 4073 nex1 = 0; 4074 if (ext_cnt) { 4075 ASSERT(erp_idx < ifp->if_real_bytes / 4076 XFS_IEXT_BUFSZ); 4077 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4078 nex1 = 0; 4079 continue; 4080 } else { 4081 break; 4082 } 4083 } 4084 /* Move extents up (if needed) */ 4085 if (nex2) { 4086 memmove(&erp->er_extbuf[nex1], 4087 &erp->er_extbuf[nex1 + ext_diff], 4088 nex2 * sizeof(xfs_bmbt_rec_t)); 4089 } 4090 /* Zero out rest of page */ 4091 memset(&erp->er_extbuf[nex1 + nex2], 0, (XFS_IEXT_BUFSZ - 4092 ((nex1 + nex2) * sizeof(xfs_bmbt_rec_t)))); 4093 /* Update remaining counters */ 4094 erp->er_extcount -= ext_diff; 4095 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -ext_diff); 4096 ext_cnt -= ext_diff; 4097 nex1 = 0; 4098 erp_idx++; 4099 erp++; 4100 } 4101 ifp->if_bytes -= count * sizeof(xfs_bmbt_rec_t); 4102 xfs_iext_irec_compact(ifp); 4103 } 4104 4105 /* 4106 * Create, destroy, or resize a linear (direct) block of extents. 4107 */ 4108 void 4109 xfs_iext_realloc_direct( 4110 xfs_ifork_t *ifp, /* inode fork pointer */ 4111 int new_size) /* new size of extents */ 4112 { 4113 int rnew_size; /* real new size of extents */ 4114 4115 rnew_size = new_size; 4116 4117 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC) || 4118 ((new_size >= 0) && (new_size <= XFS_IEXT_BUFSZ) && 4119 (new_size != ifp->if_real_bytes))); 4120 4121 /* Free extent records */ 4122 if (new_size == 0) { 4123 xfs_iext_destroy(ifp); 4124 } 4125 /* Resize direct extent list and zero any new bytes */ 4126 else if (ifp->if_real_bytes) { 4127 /* Check if extents will fit inside the inode */ 4128 if (new_size <= XFS_INLINE_EXTS * sizeof(xfs_bmbt_rec_t)) { 4129 xfs_iext_direct_to_inline(ifp, new_size / 4130 (uint)sizeof(xfs_bmbt_rec_t)); 4131 ifp->if_bytes = new_size; 4132 return; 4133 } 4134 if ((new_size & (new_size - 1)) != 0) { 4135 rnew_size = xfs_iroundup(new_size); 4136 } 4137 if (rnew_size != ifp->if_real_bytes) { 4138 ifp->if_u1.if_extents = (xfs_bmbt_rec_t *) 4139 kmem_realloc(ifp->if_u1.if_extents, 4140 rnew_size, 4141 ifp->if_real_bytes, 4142 KM_SLEEP); 4143 } 4144 if (rnew_size > ifp->if_real_bytes) { 4145 memset(&ifp->if_u1.if_extents[ifp->if_bytes / 4146 (uint)sizeof(xfs_bmbt_rec_t)], 0, 4147 rnew_size - ifp->if_real_bytes); 4148 } 4149 } 4150 /* 4151 * Switch from the inline extent buffer to a direct 4152 * extent list. Be sure to include the inline extent 4153 * bytes in new_size. 4154 */ 4155 else { 4156 new_size += ifp->if_bytes; 4157 if ((new_size & (new_size - 1)) != 0) { 4158 rnew_size = xfs_iroundup(new_size); 4159 } 4160 xfs_iext_inline_to_direct(ifp, rnew_size); 4161 } 4162 ifp->if_real_bytes = rnew_size; 4163 ifp->if_bytes = new_size; 4164 } 4165 4166 /* 4167 * Switch from linear (direct) extent records to inline buffer. 4168 */ 4169 void 4170 xfs_iext_direct_to_inline( 4171 xfs_ifork_t *ifp, /* inode fork pointer */ 4172 xfs_extnum_t nextents) /* number of extents in file */ 4173 { 4174 ASSERT(ifp->if_flags & XFS_IFEXTENTS); 4175 ASSERT(nextents <= XFS_INLINE_EXTS); 4176 /* 4177 * The inline buffer was zeroed when we switched 4178 * from inline to direct extent allocation mode, 4179 * so we don't need to clear it here. 4180 */ 4181 memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents, 4182 nextents * sizeof(xfs_bmbt_rec_t)); 4183 kmem_free(ifp->if_u1.if_extents, KM_SLEEP); 4184 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext; 4185 ifp->if_real_bytes = 0; 4186 } 4187 4188 /* 4189 * Switch from inline buffer to linear (direct) extent records. 4190 * new_size should already be rounded up to the next power of 2 4191 * by the caller (when appropriate), so use new_size as it is. 4192 * However, since new_size may be rounded up, we can't update 4193 * if_bytes here. It is the caller's responsibility to update 4194 * if_bytes upon return. 4195 */ 4196 void 4197 xfs_iext_inline_to_direct( 4198 xfs_ifork_t *ifp, /* inode fork pointer */ 4199 int new_size) /* number of extents in file */ 4200 { 4201 ifp->if_u1.if_extents = (xfs_bmbt_rec_t *) 4202 kmem_alloc(new_size, KM_SLEEP); 4203 memset(ifp->if_u1.if_extents, 0, new_size); 4204 if (ifp->if_bytes) { 4205 memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext, 4206 ifp->if_bytes); 4207 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS * 4208 sizeof(xfs_bmbt_rec_t)); 4209 } 4210 ifp->if_real_bytes = new_size; 4211 } 4212 4213 /* 4214 * Resize an extent indirection array to new_size bytes. 4215 */ 4216 void 4217 xfs_iext_realloc_indirect( 4218 xfs_ifork_t *ifp, /* inode fork pointer */ 4219 int new_size) /* new indirection array size */ 4220 { 4221 int nlists; /* number of irec's (ex lists) */ 4222 int size; /* current indirection array size */ 4223 4224 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4225 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4226 size = nlists * sizeof(xfs_ext_irec_t); 4227 ASSERT(ifp->if_real_bytes); 4228 ASSERT((new_size >= 0) && (new_size != size)); 4229 if (new_size == 0) { 4230 xfs_iext_destroy(ifp); 4231 } else { 4232 ifp->if_u1.if_ext_irec = (xfs_ext_irec_t *) 4233 kmem_realloc(ifp->if_u1.if_ext_irec, 4234 new_size, size, KM_SLEEP); 4235 } 4236 } 4237 4238 /* 4239 * Switch from indirection array to linear (direct) extent allocations. 4240 */ 4241 void 4242 xfs_iext_indirect_to_direct( 4243 xfs_ifork_t *ifp) /* inode fork pointer */ 4244 { 4245 xfs_bmbt_rec_t *ep; /* extent record pointer */ 4246 xfs_extnum_t nextents; /* number of extents in file */ 4247 int size; /* size of file extents */ 4248 4249 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4250 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4251 ASSERT(nextents <= XFS_LINEAR_EXTS); 4252 size = nextents * sizeof(xfs_bmbt_rec_t); 4253 4254 xfs_iext_irec_compact_full(ifp); 4255 ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ); 4256 4257 ep = ifp->if_u1.if_ext_irec->er_extbuf; 4258 kmem_free(ifp->if_u1.if_ext_irec, sizeof(xfs_ext_irec_t)); 4259 ifp->if_flags &= ~XFS_IFEXTIREC; 4260 ifp->if_u1.if_extents = ep; 4261 ifp->if_bytes = size; 4262 if (nextents < XFS_LINEAR_EXTS) { 4263 xfs_iext_realloc_direct(ifp, size); 4264 } 4265 } 4266 4267 /* 4268 * Free incore file extents. 4269 */ 4270 void 4271 xfs_iext_destroy( 4272 xfs_ifork_t *ifp) /* inode fork pointer */ 4273 { 4274 if (ifp->if_flags & XFS_IFEXTIREC) { 4275 int erp_idx; 4276 int nlists; 4277 4278 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4279 for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) { 4280 xfs_iext_irec_remove(ifp, erp_idx); 4281 } 4282 ifp->if_flags &= ~XFS_IFEXTIREC; 4283 } else if (ifp->if_real_bytes) { 4284 kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes); 4285 } else if (ifp->if_bytes) { 4286 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS * 4287 sizeof(xfs_bmbt_rec_t)); 4288 } 4289 ifp->if_u1.if_extents = NULL; 4290 ifp->if_real_bytes = 0; 4291 ifp->if_bytes = 0; 4292 } 4293 4294 /* 4295 * Return a pointer to the extent record for file system block bno. 4296 */ 4297 xfs_bmbt_rec_t * /* pointer to found extent record */ 4298 xfs_iext_bno_to_ext( 4299 xfs_ifork_t *ifp, /* inode fork pointer */ 4300 xfs_fileoff_t bno, /* block number to search for */ 4301 xfs_extnum_t *idxp) /* index of target extent */ 4302 { 4303 xfs_bmbt_rec_t *base; /* pointer to first extent */ 4304 xfs_filblks_t blockcount = 0; /* number of blocks in extent */ 4305 xfs_bmbt_rec_t *ep = NULL; /* pointer to target extent */ 4306 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */ 4307 int high; /* upper boundary in search */ 4308 xfs_extnum_t idx = 0; /* index of target extent */ 4309 int low; /* lower boundary in search */ 4310 xfs_extnum_t nextents; /* number of file extents */ 4311 xfs_fileoff_t startoff = 0; /* start offset of extent */ 4312 4313 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4314 if (nextents == 0) { 4315 *idxp = 0; 4316 return NULL; 4317 } 4318 low = 0; 4319 if (ifp->if_flags & XFS_IFEXTIREC) { 4320 /* Find target extent list */ 4321 int erp_idx = 0; 4322 erp = xfs_iext_bno_to_irec(ifp, bno, &erp_idx); 4323 base = erp->er_extbuf; 4324 high = erp->er_extcount - 1; 4325 } else { 4326 base = ifp->if_u1.if_extents; 4327 high = nextents - 1; 4328 } 4329 /* Binary search extent records */ 4330 while (low <= high) { 4331 idx = (low + high) >> 1; 4332 ep = base + idx; 4333 startoff = xfs_bmbt_get_startoff(ep); 4334 blockcount = xfs_bmbt_get_blockcount(ep); 4335 if (bno < startoff) { 4336 high = idx - 1; 4337 } else if (bno >= startoff + blockcount) { 4338 low = idx + 1; 4339 } else { 4340 /* Convert back to file-based extent index */ 4341 if (ifp->if_flags & XFS_IFEXTIREC) { 4342 idx += erp->er_extoff; 4343 } 4344 *idxp = idx; 4345 return ep; 4346 } 4347 } 4348 /* Convert back to file-based extent index */ 4349 if (ifp->if_flags & XFS_IFEXTIREC) { 4350 idx += erp->er_extoff; 4351 } 4352 if (bno >= startoff + blockcount) { 4353 if (++idx == nextents) { 4354 ep = NULL; 4355 } else { 4356 ep = xfs_iext_get_ext(ifp, idx); 4357 } 4358 } 4359 *idxp = idx; 4360 return ep; 4361 } 4362 4363 /* 4364 * Return a pointer to the indirection array entry containing the 4365 * extent record for filesystem block bno. Store the index of the 4366 * target irec in *erp_idxp. 4367 */ 4368 xfs_ext_irec_t * /* pointer to found extent record */ 4369 xfs_iext_bno_to_irec( 4370 xfs_ifork_t *ifp, /* inode fork pointer */ 4371 xfs_fileoff_t bno, /* block number to search for */ 4372 int *erp_idxp) /* irec index of target ext list */ 4373 { 4374 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */ 4375 xfs_ext_irec_t *erp_next; /* next indirection array entry */ 4376 int erp_idx; /* indirection array index */ 4377 int nlists; /* number of extent irec's (lists) */ 4378 int high; /* binary search upper limit */ 4379 int low; /* binary search lower limit */ 4380 4381 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4382 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4383 erp_idx = 0; 4384 low = 0; 4385 high = nlists - 1; 4386 while (low <= high) { 4387 erp_idx = (low + high) >> 1; 4388 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4389 erp_next = erp_idx < nlists - 1 ? erp + 1 : NULL; 4390 if (bno < xfs_bmbt_get_startoff(erp->er_extbuf)) { 4391 high = erp_idx - 1; 4392 } else if (erp_next && bno >= 4393 xfs_bmbt_get_startoff(erp_next->er_extbuf)) { 4394 low = erp_idx + 1; 4395 } else { 4396 break; 4397 } 4398 } 4399 *erp_idxp = erp_idx; 4400 return erp; 4401 } 4402 4403 /* 4404 * Return a pointer to the indirection array entry containing the 4405 * extent record at file extent index *idxp. Store the index of the 4406 * target irec in *erp_idxp and store the page index of the target 4407 * extent record in *idxp. 4408 */ 4409 xfs_ext_irec_t * 4410 xfs_iext_idx_to_irec( 4411 xfs_ifork_t *ifp, /* inode fork pointer */ 4412 xfs_extnum_t *idxp, /* extent index (file -> page) */ 4413 int *erp_idxp, /* pointer to target irec */ 4414 int realloc) /* new bytes were just added */ 4415 { 4416 xfs_ext_irec_t *prev; /* pointer to previous irec */ 4417 xfs_ext_irec_t *erp = NULL; /* pointer to current irec */ 4418 int erp_idx; /* indirection array index */ 4419 int nlists; /* number of irec's (ex lists) */ 4420 int high; /* binary search upper limit */ 4421 int low; /* binary search lower limit */ 4422 xfs_extnum_t page_idx = *idxp; /* extent index in target list */ 4423 4424 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4425 ASSERT(page_idx >= 0 && page_idx <= 4426 ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)); 4427 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4428 erp_idx = 0; 4429 low = 0; 4430 high = nlists - 1; 4431 4432 /* Binary search extent irec's */ 4433 while (low <= high) { 4434 erp_idx = (low + high) >> 1; 4435 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4436 prev = erp_idx > 0 ? erp - 1 : NULL; 4437 if (page_idx < erp->er_extoff || (page_idx == erp->er_extoff && 4438 realloc && prev && prev->er_extcount < XFS_LINEAR_EXTS)) { 4439 high = erp_idx - 1; 4440 } else if (page_idx > erp->er_extoff + erp->er_extcount || 4441 (page_idx == erp->er_extoff + erp->er_extcount && 4442 !realloc)) { 4443 low = erp_idx + 1; 4444 } else if (page_idx == erp->er_extoff + erp->er_extcount && 4445 erp->er_extcount == XFS_LINEAR_EXTS) { 4446 ASSERT(realloc); 4447 page_idx = 0; 4448 erp_idx++; 4449 erp = erp_idx < nlists ? erp + 1 : NULL; 4450 break; 4451 } else { 4452 page_idx -= erp->er_extoff; 4453 break; 4454 } 4455 } 4456 *idxp = page_idx; 4457 *erp_idxp = erp_idx; 4458 return(erp); 4459 } 4460 4461 /* 4462 * Allocate and initialize an indirection array once the space needed 4463 * for incore extents increases above XFS_IEXT_BUFSZ. 4464 */ 4465 void 4466 xfs_iext_irec_init( 4467 xfs_ifork_t *ifp) /* inode fork pointer */ 4468 { 4469 xfs_ext_irec_t *erp; /* indirection array pointer */ 4470 xfs_extnum_t nextents; /* number of extents in file */ 4471 4472 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC)); 4473 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4474 ASSERT(nextents <= XFS_LINEAR_EXTS); 4475 4476 erp = (xfs_ext_irec_t *) 4477 kmem_alloc(sizeof(xfs_ext_irec_t), KM_SLEEP); 4478 4479 if (nextents == 0) { 4480 ifp->if_u1.if_extents = (xfs_bmbt_rec_t *) 4481 kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP); 4482 } else if (!ifp->if_real_bytes) { 4483 xfs_iext_inline_to_direct(ifp, XFS_IEXT_BUFSZ); 4484 } else if (ifp->if_real_bytes < XFS_IEXT_BUFSZ) { 4485 xfs_iext_realloc_direct(ifp, XFS_IEXT_BUFSZ); 4486 } 4487 erp->er_extbuf = ifp->if_u1.if_extents; 4488 erp->er_extcount = nextents; 4489 erp->er_extoff = 0; 4490 4491 ifp->if_flags |= XFS_IFEXTIREC; 4492 ifp->if_real_bytes = XFS_IEXT_BUFSZ; 4493 ifp->if_bytes = nextents * sizeof(xfs_bmbt_rec_t); 4494 ifp->if_u1.if_ext_irec = erp; 4495 4496 return; 4497 } 4498 4499 /* 4500 * Allocate and initialize a new entry in the indirection array. 4501 */ 4502 xfs_ext_irec_t * 4503 xfs_iext_irec_new( 4504 xfs_ifork_t *ifp, /* inode fork pointer */ 4505 int erp_idx) /* index for new irec */ 4506 { 4507 xfs_ext_irec_t *erp; /* indirection array pointer */ 4508 int i; /* loop counter */ 4509 int nlists; /* number of irec's (ex lists) */ 4510 4511 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4512 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4513 4514 /* Resize indirection array */ 4515 xfs_iext_realloc_indirect(ifp, ++nlists * 4516 sizeof(xfs_ext_irec_t)); 4517 /* 4518 * Move records down in the array so the 4519 * new page can use erp_idx. 4520 */ 4521 erp = ifp->if_u1.if_ext_irec; 4522 for (i = nlists - 1; i > erp_idx; i--) { 4523 memmove(&erp[i], &erp[i-1], sizeof(xfs_ext_irec_t)); 4524 } 4525 ASSERT(i == erp_idx); 4526 4527 /* Initialize new extent record */ 4528 erp = ifp->if_u1.if_ext_irec; 4529 erp[erp_idx].er_extbuf = (xfs_bmbt_rec_t *) 4530 kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP); 4531 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ; 4532 memset(erp[erp_idx].er_extbuf, 0, XFS_IEXT_BUFSZ); 4533 erp[erp_idx].er_extcount = 0; 4534 erp[erp_idx].er_extoff = erp_idx > 0 ? 4535 erp[erp_idx-1].er_extoff + erp[erp_idx-1].er_extcount : 0; 4536 return (&erp[erp_idx]); 4537 } 4538 4539 /* 4540 * Remove a record from the indirection array. 4541 */ 4542 void 4543 xfs_iext_irec_remove( 4544 xfs_ifork_t *ifp, /* inode fork pointer */ 4545 int erp_idx) /* irec index to remove */ 4546 { 4547 xfs_ext_irec_t *erp; /* indirection array pointer */ 4548 int i; /* loop counter */ 4549 int nlists; /* number of irec's (ex lists) */ 4550 4551 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4552 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4553 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4554 if (erp->er_extbuf) { 4555 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, 4556 -erp->er_extcount); 4557 kmem_free(erp->er_extbuf, XFS_IEXT_BUFSZ); 4558 } 4559 /* Compact extent records */ 4560 erp = ifp->if_u1.if_ext_irec; 4561 for (i = erp_idx; i < nlists - 1; i++) { 4562 memmove(&erp[i], &erp[i+1], sizeof(xfs_ext_irec_t)); 4563 } 4564 /* 4565 * Manually free the last extent record from the indirection 4566 * array. A call to xfs_iext_realloc_indirect() with a size 4567 * of zero would result in a call to xfs_iext_destroy() which 4568 * would in turn call this function again, creating a nasty 4569 * infinite loop. 4570 */ 4571 if (--nlists) { 4572 xfs_iext_realloc_indirect(ifp, 4573 nlists * sizeof(xfs_ext_irec_t)); 4574 } else { 4575 kmem_free(ifp->if_u1.if_ext_irec, 4576 sizeof(xfs_ext_irec_t)); 4577 } 4578 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ; 4579 } 4580 4581 /* 4582 * This is called to clean up large amounts of unused memory allocated 4583 * by the indirection array. Before compacting anything though, verify 4584 * that the indirection array is still needed and switch back to the 4585 * linear extent list (or even the inline buffer) if possible. The 4586 * compaction policy is as follows: 4587 * 4588 * Full Compaction: Extents fit into a single page (or inline buffer) 4589 * Full Compaction: Extents occupy less than 10% of allocated space 4590 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space 4591 * No Compaction: Extents occupy at least 50% of allocated space 4592 */ 4593 void 4594 xfs_iext_irec_compact( 4595 xfs_ifork_t *ifp) /* inode fork pointer */ 4596 { 4597 xfs_extnum_t nextents; /* number of extents in file */ 4598 int nlists; /* number of irec's (ex lists) */ 4599 4600 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4601 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4602 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4603 4604 if (nextents == 0) { 4605 xfs_iext_destroy(ifp); 4606 } else if (nextents <= XFS_INLINE_EXTS) { 4607 xfs_iext_indirect_to_direct(ifp); 4608 xfs_iext_direct_to_inline(ifp, nextents); 4609 } else if (nextents <= XFS_LINEAR_EXTS) { 4610 xfs_iext_indirect_to_direct(ifp); 4611 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 3) { 4612 xfs_iext_irec_compact_full(ifp); 4613 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 1) { 4614 xfs_iext_irec_compact_pages(ifp); 4615 } 4616 } 4617 4618 /* 4619 * Combine extents from neighboring extent pages. 4620 */ 4621 void 4622 xfs_iext_irec_compact_pages( 4623 xfs_ifork_t *ifp) /* inode fork pointer */ 4624 { 4625 xfs_ext_irec_t *erp, *erp_next;/* pointers to irec entries */ 4626 int erp_idx = 0; /* indirection array index */ 4627 int nlists; /* number of irec's (ex lists) */ 4628 4629 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4630 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4631 while (erp_idx < nlists - 1) { 4632 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4633 erp_next = erp + 1; 4634 if (erp_next->er_extcount <= 4635 (XFS_LINEAR_EXTS - erp->er_extcount)) { 4636 memmove(&erp->er_extbuf[erp->er_extcount], 4637 erp_next->er_extbuf, erp_next->er_extcount * 4638 sizeof(xfs_bmbt_rec_t)); 4639 erp->er_extcount += erp_next->er_extcount; 4640 /* 4641 * Free page before removing extent record 4642 * so er_extoffs don't get modified in 4643 * xfs_iext_irec_remove. 4644 */ 4645 kmem_free(erp_next->er_extbuf, XFS_IEXT_BUFSZ); 4646 erp_next->er_extbuf = NULL; 4647 xfs_iext_irec_remove(ifp, erp_idx + 1); 4648 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4649 } else { 4650 erp_idx++; 4651 } 4652 } 4653 } 4654 4655 /* 4656 * Fully compact the extent records managed by the indirection array. 4657 */ 4658 void 4659 xfs_iext_irec_compact_full( 4660 xfs_ifork_t *ifp) /* inode fork pointer */ 4661 { 4662 xfs_bmbt_rec_t *ep, *ep_next; /* extent record pointers */ 4663 xfs_ext_irec_t *erp, *erp_next; /* extent irec pointers */ 4664 int erp_idx = 0; /* extent irec index */ 4665 int ext_avail; /* empty entries in ex list */ 4666 int ext_diff; /* number of exts to add */ 4667 int nlists; /* number of irec's (ex lists) */ 4668 4669 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4670 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4671 erp = ifp->if_u1.if_ext_irec; 4672 ep = &erp->er_extbuf[erp->er_extcount]; 4673 erp_next = erp + 1; 4674 ep_next = erp_next->er_extbuf; 4675 while (erp_idx < nlists - 1) { 4676 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount; 4677 ext_diff = MIN(ext_avail, erp_next->er_extcount); 4678 memcpy(ep, ep_next, ext_diff * sizeof(xfs_bmbt_rec_t)); 4679 erp->er_extcount += ext_diff; 4680 erp_next->er_extcount -= ext_diff; 4681 /* Remove next page */ 4682 if (erp_next->er_extcount == 0) { 4683 /* 4684 * Free page before removing extent record 4685 * so er_extoffs don't get modified in 4686 * xfs_iext_irec_remove. 4687 */ 4688 kmem_free(erp_next->er_extbuf, 4689 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t)); 4690 erp_next->er_extbuf = NULL; 4691 xfs_iext_irec_remove(ifp, erp_idx + 1); 4692 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4693 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4694 /* Update next page */ 4695 } else { 4696 /* Move rest of page up to become next new page */ 4697 memmove(erp_next->er_extbuf, ep_next, 4698 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t)); 4699 ep_next = erp_next->er_extbuf; 4700 memset(&ep_next[erp_next->er_extcount], 0, 4701 (XFS_LINEAR_EXTS - erp_next->er_extcount) * 4702 sizeof(xfs_bmbt_rec_t)); 4703 } 4704 if (erp->er_extcount == XFS_LINEAR_EXTS) { 4705 erp_idx++; 4706 if (erp_idx < nlists) 4707 erp = &ifp->if_u1.if_ext_irec[erp_idx]; 4708 else 4709 break; 4710 } 4711 ep = &erp->er_extbuf[erp->er_extcount]; 4712 erp_next = erp + 1; 4713 ep_next = erp_next->er_extbuf; 4714 } 4715 } 4716 4717 /* 4718 * This is called to update the er_extoff field in the indirection 4719 * array when extents have been added or removed from one of the 4720 * extent lists. erp_idx contains the irec index to begin updating 4721 * at and ext_diff contains the number of extents that were added 4722 * or removed. 4723 */ 4724 void 4725 xfs_iext_irec_update_extoffs( 4726 xfs_ifork_t *ifp, /* inode fork pointer */ 4727 int erp_idx, /* irec index to update */ 4728 int ext_diff) /* number of new extents */ 4729 { 4730 int i; /* loop counter */ 4731 int nlists; /* number of irec's (ex lists */ 4732 4733 ASSERT(ifp->if_flags & XFS_IFEXTIREC); 4734 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ; 4735 for (i = erp_idx; i < nlists; i++) { 4736 ifp->if_u1.if_ext_irec[i].er_extoff += ext_diff; 4737 } 4738 } 4739