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