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