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