1 /*- 2 * SPDX-License-Identifier: (BSD-2-Clause-FreeBSD AND BSD-3-Clause) 3 * 4 * Copyright (c) 2002 Networks Associates Technology, Inc. 5 * All rights reserved. 6 * 7 * This software was developed for the FreeBSD Project by Marshall 8 * Kirk McKusick and Network Associates Laboratories, the Security 9 * Research Division of Network Associates, Inc. under DARPA/SPAWAR 10 * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS 11 * research program 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * Copyright (c) 1982, 1986, 1989, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. Neither the name of the University nor the names of its contributors 46 * may be used to endorse or promote products derived from this software 47 * without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 59 * SUCH DAMAGE. 60 * 61 * @(#)ffs_balloc.c 8.8 (Berkeley) 6/16/95 62 */ 63 64 #include <sys/cdefs.h> 65 __FBSDID("$FreeBSD$"); 66 67 #include <sys/param.h> 68 #include <sys/systm.h> 69 #include <sys/bio.h> 70 #include <sys/buf.h> 71 #include <sys/lock.h> 72 #include <sys/mount.h> 73 #include <sys/vnode.h> 74 #include <sys/vmmeter.h> 75 76 #include <ufs/ufs/quota.h> 77 #include <ufs/ufs/inode.h> 78 #include <ufs/ufs/ufs_extern.h> 79 #include <ufs/ufs/extattr.h> 80 #include <ufs/ufs/ufsmount.h> 81 82 #include <ufs/ffs/fs.h> 83 #include <ufs/ffs/ffs_extern.h> 84 85 /* 86 * Balloc defines the structure of filesystem storage 87 * by allocating the physical blocks on a device given 88 * the inode and the logical block number in a file. 89 * This is the allocation strategy for UFS1. Below is 90 * the allocation strategy for UFS2. 91 */ 92 int 93 ffs_balloc_ufs1(struct vnode *vp, off_t startoffset, int size, 94 struct ucred *cred, int flags, struct buf **bpp) 95 { 96 struct inode *ip; 97 struct ufs1_dinode *dp; 98 ufs_lbn_t lbn, lastlbn; 99 struct fs *fs; 100 ufs1_daddr_t nb; 101 struct buf *bp, *nbp; 102 struct mount *mp; 103 struct ufsmount *ump; 104 struct indir indirs[UFS_NIADDR + 2]; 105 int deallocated, osize, nsize, num, i, error; 106 ufs2_daddr_t newb; 107 ufs1_daddr_t *bap, pref; 108 ufs1_daddr_t *allocib, *blkp, *allocblk, allociblk[UFS_NIADDR + 1]; 109 ufs2_daddr_t *lbns_remfree, lbns[UFS_NIADDR + 1]; 110 int unwindidx = -1; 111 int saved_inbdflush; 112 int gbflags, reclaimed; 113 114 ip = VTOI(vp); 115 dp = ip->i_din1; 116 fs = ITOFS(ip); 117 mp = ITOVFS(ip); 118 ump = ITOUMP(ip); 119 lbn = lblkno(fs, startoffset); 120 size = blkoff(fs, startoffset) + size; 121 reclaimed = 0; 122 if (size > fs->fs_bsize) 123 panic("ffs_balloc_ufs1: blk too big"); 124 *bpp = NULL; 125 if (flags & IO_EXT) 126 return (EOPNOTSUPP); 127 if (lbn < 0) 128 return (EFBIG); 129 gbflags = (flags & BA_UNMAPPED) != 0 ? GB_UNMAPPED : 0; 130 131 if (DOINGSOFTDEP(vp)) 132 softdep_prealloc(vp, MNT_WAIT); 133 /* 134 * If the next write will extend the file into a new block, 135 * and the file is currently composed of a fragment 136 * this fragment has to be extended to be a full block. 137 */ 138 lastlbn = lblkno(fs, ip->i_size); 139 if (lastlbn < UFS_NDADDR && lastlbn < lbn) { 140 nb = lastlbn; 141 osize = blksize(fs, ip, nb); 142 if (osize < fs->fs_bsize && osize > 0) { 143 UFS_LOCK(ump); 144 error = ffs_realloccg(ip, nb, dp->di_db[nb], 145 ffs_blkpref_ufs1(ip, lastlbn, (int)nb, 146 &dp->di_db[0]), osize, (int)fs->fs_bsize, flags, 147 cred, &bp); 148 if (error) 149 return (error); 150 if (DOINGSOFTDEP(vp)) 151 softdep_setup_allocdirect(ip, nb, 152 dbtofsb(fs, bp->b_blkno), dp->di_db[nb], 153 fs->fs_bsize, osize, bp); 154 ip->i_size = smalllblktosize(fs, nb + 1); 155 dp->di_size = ip->i_size; 156 dp->di_db[nb] = dbtofsb(fs, bp->b_blkno); 157 ip->i_flag |= IN_CHANGE | IN_UPDATE; 158 if (flags & IO_SYNC) 159 bwrite(bp); 160 else if (DOINGASYNC(vp)) 161 bdwrite(bp); 162 else 163 bawrite(bp); 164 } 165 } 166 /* 167 * The first UFS_NDADDR blocks are direct blocks 168 */ 169 if (lbn < UFS_NDADDR) { 170 if (flags & BA_METAONLY) 171 panic("ffs_balloc_ufs1: BA_METAONLY for direct block"); 172 nb = dp->di_db[lbn]; 173 if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) { 174 error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp); 175 if (error) { 176 brelse(bp); 177 return (error); 178 } 179 bp->b_blkno = fsbtodb(fs, nb); 180 *bpp = bp; 181 return (0); 182 } 183 if (nb != 0) { 184 /* 185 * Consider need to reallocate a fragment. 186 */ 187 osize = fragroundup(fs, blkoff(fs, ip->i_size)); 188 nsize = fragroundup(fs, size); 189 if (nsize <= osize) { 190 error = bread(vp, lbn, osize, NOCRED, &bp); 191 if (error) { 192 brelse(bp); 193 return (error); 194 } 195 bp->b_blkno = fsbtodb(fs, nb); 196 } else { 197 UFS_LOCK(ump); 198 error = ffs_realloccg(ip, lbn, dp->di_db[lbn], 199 ffs_blkpref_ufs1(ip, lbn, (int)lbn, 200 &dp->di_db[0]), osize, nsize, flags, 201 cred, &bp); 202 if (error) 203 return (error); 204 if (DOINGSOFTDEP(vp)) 205 softdep_setup_allocdirect(ip, lbn, 206 dbtofsb(fs, bp->b_blkno), nb, 207 nsize, osize, bp); 208 } 209 } else { 210 if (ip->i_size < smalllblktosize(fs, lbn + 1)) 211 nsize = fragroundup(fs, size); 212 else 213 nsize = fs->fs_bsize; 214 UFS_LOCK(ump); 215 error = ffs_alloc(ip, lbn, 216 ffs_blkpref_ufs1(ip, lbn, (int)lbn, &dp->di_db[0]), 217 nsize, flags, cred, &newb); 218 if (error) 219 return (error); 220 bp = getblk(vp, lbn, nsize, 0, 0, gbflags); 221 bp->b_blkno = fsbtodb(fs, newb); 222 if (flags & BA_CLRBUF) 223 vfs_bio_clrbuf(bp); 224 if (DOINGSOFTDEP(vp)) 225 softdep_setup_allocdirect(ip, lbn, newb, 0, 226 nsize, 0, bp); 227 } 228 dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno); 229 ip->i_flag |= IN_CHANGE | IN_UPDATE; 230 *bpp = bp; 231 return (0); 232 } 233 /* 234 * Determine the number of levels of indirection. 235 */ 236 pref = 0; 237 if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0) 238 return(error); 239 #ifdef INVARIANTS 240 if (num < 1) 241 panic ("ffs_balloc_ufs1: ufs_getlbns returned indirect block"); 242 #endif 243 saved_inbdflush = curthread_pflags_set(TDP_INBDFLUSH); 244 /* 245 * Fetch the first indirect block allocating if necessary. 246 */ 247 --num; 248 nb = dp->di_ib[indirs[0].in_off]; 249 allocib = NULL; 250 allocblk = allociblk; 251 lbns_remfree = lbns; 252 if (nb == 0) { 253 UFS_LOCK(ump); 254 pref = ffs_blkpref_ufs1(ip, lbn, -indirs[0].in_off - 1, 255 (ufs1_daddr_t *)0); 256 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 257 flags, cred, &newb)) != 0) { 258 curthread_pflags_restore(saved_inbdflush); 259 return (error); 260 } 261 pref = newb + fs->fs_frag; 262 nb = newb; 263 MPASS(allocblk < allociblk + nitems(allociblk)); 264 MPASS(lbns_remfree < lbns + nitems(lbns)); 265 *allocblk++ = nb; 266 *lbns_remfree++ = indirs[1].in_lbn; 267 bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, gbflags); 268 bp->b_blkno = fsbtodb(fs, nb); 269 vfs_bio_clrbuf(bp); 270 if (DOINGSOFTDEP(vp)) { 271 softdep_setup_allocdirect(ip, 272 UFS_NDADDR + indirs[0].in_off, newb, 0, 273 fs->fs_bsize, 0, bp); 274 bdwrite(bp); 275 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 276 if (bp->b_bufsize == fs->fs_bsize) 277 bp->b_flags |= B_CLUSTEROK; 278 bdwrite(bp); 279 } else { 280 if ((error = bwrite(bp)) != 0) 281 goto fail; 282 } 283 allocib = &dp->di_ib[indirs[0].in_off]; 284 *allocib = nb; 285 ip->i_flag |= IN_CHANGE | IN_UPDATE; 286 } 287 /* 288 * Fetch through the indirect blocks, allocating as necessary. 289 */ 290 retry: 291 for (i = 1;;) { 292 error = bread(vp, 293 indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp); 294 if (error) { 295 brelse(bp); 296 goto fail; 297 } 298 bap = (ufs1_daddr_t *)bp->b_data; 299 nb = bap[indirs[i].in_off]; 300 if ((error = UFS_CHECK_BLKNO(mp, ip->i_number, nb, 301 fs->fs_bsize)) != 0) { 302 brelse(bp); 303 goto fail; 304 } 305 if (i == num) 306 break; 307 i += 1; 308 if (nb != 0) { 309 bqrelse(bp); 310 continue; 311 } 312 UFS_LOCK(ump); 313 /* 314 * If parent indirect has just been allocated, try to cluster 315 * immediately following it. 316 */ 317 if (pref == 0) 318 pref = ffs_blkpref_ufs1(ip, lbn, i - num - 1, 319 (ufs1_daddr_t *)0); 320 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 321 flags | IO_BUFLOCKED, cred, &newb)) != 0) { 322 brelse(bp); 323 UFS_LOCK(ump); 324 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 325 softdep_request_cleanup(fs, vp, cred, 326 FLUSH_BLOCKS_WAIT); 327 UFS_UNLOCK(ump); 328 goto retry; 329 } 330 if (ppsratecheck(&ump->um_last_fullmsg, 331 &ump->um_secs_fullmsg, 1)) { 332 UFS_UNLOCK(ump); 333 ffs_fserr(fs, ip->i_number, "filesystem full"); 334 uprintf("\n%s: write failed, filesystem " 335 "is full\n", fs->fs_fsmnt); 336 } else { 337 UFS_UNLOCK(ump); 338 } 339 goto fail; 340 } 341 pref = newb + fs->fs_frag; 342 nb = newb; 343 MPASS(allocblk < allociblk + nitems(allociblk)); 344 MPASS(lbns_remfree < lbns + nitems(lbns)); 345 *allocblk++ = nb; 346 *lbns_remfree++ = indirs[i].in_lbn; 347 nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 0); 348 nbp->b_blkno = fsbtodb(fs, nb); 349 vfs_bio_clrbuf(nbp); 350 if (DOINGSOFTDEP(vp)) { 351 softdep_setup_allocindir_meta(nbp, ip, bp, 352 indirs[i - 1].in_off, nb); 353 bdwrite(nbp); 354 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 355 if (nbp->b_bufsize == fs->fs_bsize) 356 nbp->b_flags |= B_CLUSTEROK; 357 bdwrite(nbp); 358 } else { 359 if ((error = bwrite(nbp)) != 0) { 360 brelse(bp); 361 goto fail; 362 } 363 } 364 bap[indirs[i - 1].in_off] = nb; 365 if (allocib == NULL && unwindidx < 0) 366 unwindidx = i - 1; 367 /* 368 * If required, write synchronously, otherwise use 369 * delayed write. 370 */ 371 if (flags & IO_SYNC) { 372 bwrite(bp); 373 } else { 374 if (bp->b_bufsize == fs->fs_bsize) 375 bp->b_flags |= B_CLUSTEROK; 376 bdwrite(bp); 377 } 378 } 379 /* 380 * If asked only for the indirect block, then return it. 381 */ 382 if (flags & BA_METAONLY) { 383 curthread_pflags_restore(saved_inbdflush); 384 *bpp = bp; 385 return (0); 386 } 387 /* 388 * Get the data block, allocating if necessary. 389 */ 390 if (nb == 0) { 391 UFS_LOCK(ump); 392 /* 393 * If allocating metadata at the front of the cylinder 394 * group and parent indirect block has just been allocated, 395 * then cluster next to it if it is the first indirect in 396 * the file. Otherwise it has been allocated in the metadata 397 * area, so we want to find our own place out in the data area. 398 */ 399 if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0)) 400 pref = ffs_blkpref_ufs1(ip, lbn, indirs[i].in_off, 401 &bap[0]); 402 error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 403 flags | IO_BUFLOCKED, cred, &newb); 404 if (error) { 405 brelse(bp); 406 UFS_LOCK(ump); 407 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 408 softdep_request_cleanup(fs, vp, cred, 409 FLUSH_BLOCKS_WAIT); 410 UFS_UNLOCK(ump); 411 goto retry; 412 } 413 if (ppsratecheck(&ump->um_last_fullmsg, 414 &ump->um_secs_fullmsg, 1)) { 415 UFS_UNLOCK(ump); 416 ffs_fserr(fs, ip->i_number, "filesystem full"); 417 uprintf("\n%s: write failed, filesystem " 418 "is full\n", fs->fs_fsmnt); 419 } else { 420 UFS_UNLOCK(ump); 421 } 422 goto fail; 423 } 424 nb = newb; 425 MPASS(allocblk < allociblk + nitems(allociblk)); 426 MPASS(lbns_remfree < lbns + nitems(lbns)); 427 *allocblk++ = nb; 428 *lbns_remfree++ = lbn; 429 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 430 nbp->b_blkno = fsbtodb(fs, nb); 431 if (flags & BA_CLRBUF) 432 vfs_bio_clrbuf(nbp); 433 if (DOINGSOFTDEP(vp)) 434 softdep_setup_allocindir_page(ip, lbn, bp, 435 indirs[i].in_off, nb, 0, nbp); 436 bap[indirs[i].in_off] = nb; 437 /* 438 * If required, write synchronously, otherwise use 439 * delayed write. 440 */ 441 if (flags & IO_SYNC) { 442 bwrite(bp); 443 } else { 444 if (bp->b_bufsize == fs->fs_bsize) 445 bp->b_flags |= B_CLUSTEROK; 446 bdwrite(bp); 447 } 448 curthread_pflags_restore(saved_inbdflush); 449 *bpp = nbp; 450 return (0); 451 } 452 brelse(bp); 453 if (flags & BA_CLRBUF) { 454 int seqcount = (flags & BA_SEQMASK) >> BA_SEQSHIFT; 455 if (seqcount != 0 && 456 (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0 && 457 !(vm_page_count_severe() || buf_dirty_count_severe())) { 458 error = cluster_read(vp, ip->i_size, lbn, 459 (int)fs->fs_bsize, NOCRED, 460 MAXBSIZE, seqcount, gbflags, &nbp); 461 } else { 462 error = bread_gb(vp, lbn, (int)fs->fs_bsize, NOCRED, 463 gbflags, &nbp); 464 } 465 if (error) { 466 brelse(nbp); 467 goto fail; 468 } 469 } else { 470 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 471 nbp->b_blkno = fsbtodb(fs, nb); 472 } 473 curthread_pflags_restore(saved_inbdflush); 474 *bpp = nbp; 475 return (0); 476 fail: 477 curthread_pflags_restore(saved_inbdflush); 478 /* 479 * If we have failed to allocate any blocks, simply return the error. 480 * This is the usual case and avoids the need to fsync the file. 481 */ 482 if (allocblk == allociblk && allocib == NULL && unwindidx == -1) 483 return (error); 484 /* 485 * If we have failed part way through block allocation, we 486 * have to deallocate any indirect blocks that we have allocated. 487 * We have to fsync the file before we start to get rid of all 488 * of its dependencies so that we do not leave them dangling. 489 * We have to sync it at the end so that the soft updates code 490 * does not find any untracked changes. Although this is really 491 * slow, running out of disk space is not expected to be a common 492 * occurrence. The error return from fsync is ignored as we already 493 * have an error to return to the user. 494 * 495 * XXX Still have to journal the free below 496 */ 497 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 498 for (deallocated = 0, blkp = allociblk, lbns_remfree = lbns; 499 blkp < allocblk; blkp++, lbns_remfree++) { 500 /* 501 * We shall not leave the freed blocks on the vnode 502 * buffer object lists. 503 */ 504 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 505 GB_NOCREAT | GB_UNMAPPED); 506 if (bp != NULL) { 507 KASSERT(bp->b_blkno == fsbtodb(fs, *blkp), 508 ("mismatch1 l %jd %jd b %ju %ju", 509 (intmax_t)bp->b_lblkno, (uintmax_t)*lbns_remfree, 510 (uintmax_t)bp->b_blkno, 511 (uintmax_t)fsbtodb(fs, *blkp))); 512 bp->b_flags |= B_INVAL | B_RELBUF | B_NOCACHE; 513 bp->b_flags &= ~(B_ASYNC | B_CACHE); 514 brelse(bp); 515 } 516 deallocated += fs->fs_bsize; 517 } 518 if (allocib != NULL) { 519 *allocib = 0; 520 } else if (unwindidx >= 0) { 521 int r; 522 523 r = bread(vp, indirs[unwindidx].in_lbn, 524 (int)fs->fs_bsize, NOCRED, &bp); 525 if (r) { 526 panic("Could not unwind indirect block, error %d", r); 527 brelse(bp); 528 } else { 529 bap = (ufs1_daddr_t *)bp->b_data; 530 bap[indirs[unwindidx].in_off] = 0; 531 if (flags & IO_SYNC) { 532 bwrite(bp); 533 } else { 534 if (bp->b_bufsize == fs->fs_bsize) 535 bp->b_flags |= B_CLUSTEROK; 536 bdwrite(bp); 537 } 538 } 539 } 540 if (deallocated) { 541 #ifdef QUOTA 542 /* 543 * Restore user's disk quota because allocation failed. 544 */ 545 (void) chkdq(ip, -btodb(deallocated), cred, FORCE); 546 #endif 547 dp->di_blocks -= btodb(deallocated); 548 ip->i_flag |= IN_CHANGE | IN_UPDATE; 549 } 550 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 551 /* 552 * After the buffers are invalidated and on-disk pointers are 553 * cleared, free the blocks. 554 */ 555 for (blkp = allociblk; blkp < allocblk; blkp++) { 556 #ifdef INVARIANTS 557 if (blkp == allociblk) 558 lbns_remfree = lbns; 559 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 560 GB_NOCREAT | GB_UNMAPPED); 561 if (bp != NULL) { 562 panic("zombie1 %jd %ju %ju", 563 (intmax_t)bp->b_lblkno, (uintmax_t)bp->b_blkno, 564 (uintmax_t)fsbtodb(fs, *blkp)); 565 } 566 lbns_remfree++; 567 #endif 568 ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize, 569 ip->i_number, vp->v_type, NULL, SINGLETON_KEY); 570 } 571 return (error); 572 } 573 574 /* 575 * Balloc defines the structure of file system storage 576 * by allocating the physical blocks on a device given 577 * the inode and the logical block number in a file. 578 * This is the allocation strategy for UFS2. Above is 579 * the allocation strategy for UFS1. 580 */ 581 int 582 ffs_balloc_ufs2(struct vnode *vp, off_t startoffset, int size, 583 struct ucred *cred, int flags, struct buf **bpp) 584 { 585 struct inode *ip; 586 struct ufs2_dinode *dp; 587 ufs_lbn_t lbn, lastlbn; 588 struct fs *fs; 589 struct buf *bp, *nbp; 590 struct mount *mp; 591 struct ufsmount *ump; 592 struct indir indirs[UFS_NIADDR + 2]; 593 ufs2_daddr_t nb, newb, *bap, pref; 594 ufs2_daddr_t *allocib, *blkp, *allocblk, allociblk[UFS_NIADDR + 1]; 595 ufs2_daddr_t *lbns_remfree, lbns[UFS_NIADDR + 1]; 596 int deallocated, osize, nsize, num, i, error; 597 int unwindidx = -1; 598 int saved_inbdflush; 599 int gbflags, reclaimed; 600 601 ip = VTOI(vp); 602 dp = ip->i_din2; 603 fs = ITOFS(ip); 604 mp = ITOVFS(ip); 605 ump = ITOUMP(ip); 606 lbn = lblkno(fs, startoffset); 607 size = blkoff(fs, startoffset) + size; 608 reclaimed = 0; 609 if (size > fs->fs_bsize) 610 panic("ffs_balloc_ufs2: blk too big"); 611 *bpp = NULL; 612 if (lbn < 0) 613 return (EFBIG); 614 gbflags = (flags & BA_UNMAPPED) != 0 ? GB_UNMAPPED : 0; 615 616 if (DOINGSOFTDEP(vp)) 617 softdep_prealloc(vp, MNT_WAIT); 618 619 /* 620 * Check for allocating external data. 621 */ 622 if (flags & IO_EXT) { 623 if (lbn >= UFS_NXADDR) 624 return (EFBIG); 625 /* 626 * If the next write will extend the data into a new block, 627 * and the data is currently composed of a fragment 628 * this fragment has to be extended to be a full block. 629 */ 630 lastlbn = lblkno(fs, dp->di_extsize); 631 if (lastlbn < lbn) { 632 nb = lastlbn; 633 osize = sblksize(fs, dp->di_extsize, nb); 634 if (osize < fs->fs_bsize && osize > 0) { 635 UFS_LOCK(ump); 636 error = ffs_realloccg(ip, -1 - nb, 637 dp->di_extb[nb], 638 ffs_blkpref_ufs2(ip, lastlbn, (int)nb, 639 &dp->di_extb[0]), osize, 640 (int)fs->fs_bsize, flags, cred, &bp); 641 if (error) 642 return (error); 643 if (DOINGSOFTDEP(vp)) 644 softdep_setup_allocext(ip, nb, 645 dbtofsb(fs, bp->b_blkno), 646 dp->di_extb[nb], 647 fs->fs_bsize, osize, bp); 648 dp->di_extsize = smalllblktosize(fs, nb + 1); 649 dp->di_extb[nb] = dbtofsb(fs, bp->b_blkno); 650 bp->b_xflags |= BX_ALTDATA; 651 ip->i_flag |= IN_CHANGE; 652 if (flags & IO_SYNC) 653 bwrite(bp); 654 else 655 bawrite(bp); 656 } 657 } 658 /* 659 * All blocks are direct blocks 660 */ 661 if (flags & BA_METAONLY) 662 panic("ffs_balloc_ufs2: BA_METAONLY for ext block"); 663 nb = dp->di_extb[lbn]; 664 if (nb != 0 && dp->di_extsize >= smalllblktosize(fs, lbn + 1)) { 665 error = bread_gb(vp, -1 - lbn, fs->fs_bsize, NOCRED, 666 gbflags, &bp); 667 if (error) { 668 brelse(bp); 669 return (error); 670 } 671 bp->b_blkno = fsbtodb(fs, nb); 672 bp->b_xflags |= BX_ALTDATA; 673 *bpp = bp; 674 return (0); 675 } 676 if (nb != 0) { 677 /* 678 * Consider need to reallocate a fragment. 679 */ 680 osize = fragroundup(fs, blkoff(fs, dp->di_extsize)); 681 nsize = fragroundup(fs, size); 682 if (nsize <= osize) { 683 error = bread_gb(vp, -1 - lbn, osize, NOCRED, 684 gbflags, &bp); 685 if (error) { 686 brelse(bp); 687 return (error); 688 } 689 bp->b_blkno = fsbtodb(fs, nb); 690 bp->b_xflags |= BX_ALTDATA; 691 } else { 692 UFS_LOCK(ump); 693 error = ffs_realloccg(ip, -1 - lbn, 694 dp->di_extb[lbn], 695 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 696 &dp->di_extb[0]), osize, nsize, flags, 697 cred, &bp); 698 if (error) 699 return (error); 700 bp->b_xflags |= BX_ALTDATA; 701 if (DOINGSOFTDEP(vp)) 702 softdep_setup_allocext(ip, lbn, 703 dbtofsb(fs, bp->b_blkno), nb, 704 nsize, osize, bp); 705 } 706 } else { 707 if (dp->di_extsize < smalllblktosize(fs, lbn + 1)) 708 nsize = fragroundup(fs, size); 709 else 710 nsize = fs->fs_bsize; 711 UFS_LOCK(ump); 712 error = ffs_alloc(ip, lbn, 713 ffs_blkpref_ufs2(ip, lbn, (int)lbn, &dp->di_extb[0]), 714 nsize, flags, cred, &newb); 715 if (error) 716 return (error); 717 bp = getblk(vp, -1 - lbn, nsize, 0, 0, gbflags); 718 bp->b_blkno = fsbtodb(fs, newb); 719 bp->b_xflags |= BX_ALTDATA; 720 if (flags & BA_CLRBUF) 721 vfs_bio_clrbuf(bp); 722 if (DOINGSOFTDEP(vp)) 723 softdep_setup_allocext(ip, lbn, newb, 0, 724 nsize, 0, bp); 725 } 726 dp->di_extb[lbn] = dbtofsb(fs, bp->b_blkno); 727 ip->i_flag |= IN_CHANGE; 728 *bpp = bp; 729 return (0); 730 } 731 /* 732 * If the next write will extend the file into a new block, 733 * and the file is currently composed of a fragment 734 * this fragment has to be extended to be a full block. 735 */ 736 lastlbn = lblkno(fs, ip->i_size); 737 if (lastlbn < UFS_NDADDR && lastlbn < lbn) { 738 nb = lastlbn; 739 osize = blksize(fs, ip, nb); 740 if (osize < fs->fs_bsize && osize > 0) { 741 UFS_LOCK(ump); 742 error = ffs_realloccg(ip, nb, dp->di_db[nb], 743 ffs_blkpref_ufs2(ip, lastlbn, (int)nb, 744 &dp->di_db[0]), osize, (int)fs->fs_bsize, 745 flags, cred, &bp); 746 if (error) 747 return (error); 748 if (DOINGSOFTDEP(vp)) 749 softdep_setup_allocdirect(ip, nb, 750 dbtofsb(fs, bp->b_blkno), 751 dp->di_db[nb], 752 fs->fs_bsize, osize, bp); 753 ip->i_size = smalllblktosize(fs, nb + 1); 754 dp->di_size = ip->i_size; 755 dp->di_db[nb] = dbtofsb(fs, bp->b_blkno); 756 ip->i_flag |= IN_CHANGE | IN_UPDATE; 757 if (flags & IO_SYNC) 758 bwrite(bp); 759 else 760 bawrite(bp); 761 } 762 } 763 /* 764 * The first UFS_NDADDR blocks are direct blocks 765 */ 766 if (lbn < UFS_NDADDR) { 767 if (flags & BA_METAONLY) 768 panic("ffs_balloc_ufs2: BA_METAONLY for direct block"); 769 nb = dp->di_db[lbn]; 770 if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) { 771 error = bread_gb(vp, lbn, fs->fs_bsize, NOCRED, 772 gbflags, &bp); 773 if (error) { 774 brelse(bp); 775 return (error); 776 } 777 bp->b_blkno = fsbtodb(fs, nb); 778 *bpp = bp; 779 return (0); 780 } 781 if (nb != 0) { 782 /* 783 * Consider need to reallocate a fragment. 784 */ 785 osize = fragroundup(fs, blkoff(fs, ip->i_size)); 786 nsize = fragroundup(fs, size); 787 if (nsize <= osize) { 788 error = bread_gb(vp, lbn, osize, NOCRED, 789 gbflags, &bp); 790 if (error) { 791 brelse(bp); 792 return (error); 793 } 794 bp->b_blkno = fsbtodb(fs, nb); 795 } else { 796 UFS_LOCK(ump); 797 error = ffs_realloccg(ip, lbn, dp->di_db[lbn], 798 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 799 &dp->di_db[0]), osize, nsize, flags, 800 cred, &bp); 801 if (error) 802 return (error); 803 if (DOINGSOFTDEP(vp)) 804 softdep_setup_allocdirect(ip, lbn, 805 dbtofsb(fs, bp->b_blkno), nb, 806 nsize, osize, bp); 807 } 808 } else { 809 if (ip->i_size < smalllblktosize(fs, lbn + 1)) 810 nsize = fragroundup(fs, size); 811 else 812 nsize = fs->fs_bsize; 813 UFS_LOCK(ump); 814 error = ffs_alloc(ip, lbn, 815 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 816 &dp->di_db[0]), nsize, flags, cred, &newb); 817 if (error) 818 return (error); 819 bp = getblk(vp, lbn, nsize, 0, 0, gbflags); 820 bp->b_blkno = fsbtodb(fs, newb); 821 if (flags & BA_CLRBUF) 822 vfs_bio_clrbuf(bp); 823 if (DOINGSOFTDEP(vp)) 824 softdep_setup_allocdirect(ip, lbn, newb, 0, 825 nsize, 0, bp); 826 } 827 dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno); 828 ip->i_flag |= IN_CHANGE | IN_UPDATE; 829 *bpp = bp; 830 return (0); 831 } 832 /* 833 * Determine the number of levels of indirection. 834 */ 835 pref = 0; 836 if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0) 837 return(error); 838 #ifdef INVARIANTS 839 if (num < 1) 840 panic ("ffs_balloc_ufs2: ufs_getlbns returned indirect block"); 841 #endif 842 saved_inbdflush = curthread_pflags_set(TDP_INBDFLUSH); 843 /* 844 * Fetch the first indirect block allocating if necessary. 845 */ 846 --num; 847 nb = dp->di_ib[indirs[0].in_off]; 848 allocib = NULL; 849 allocblk = allociblk; 850 lbns_remfree = lbns; 851 if (nb == 0) { 852 UFS_LOCK(ump); 853 pref = ffs_blkpref_ufs2(ip, lbn, -indirs[0].in_off - 1, 854 (ufs2_daddr_t *)0); 855 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 856 flags, cred, &newb)) != 0) { 857 curthread_pflags_restore(saved_inbdflush); 858 return (error); 859 } 860 pref = newb + fs->fs_frag; 861 nb = newb; 862 MPASS(allocblk < allociblk + nitems(allociblk)); 863 MPASS(lbns_remfree < lbns + nitems(lbns)); 864 *allocblk++ = nb; 865 *lbns_remfree++ = indirs[1].in_lbn; 866 bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, 867 GB_UNMAPPED); 868 bp->b_blkno = fsbtodb(fs, nb); 869 vfs_bio_clrbuf(bp); 870 if (DOINGSOFTDEP(vp)) { 871 softdep_setup_allocdirect(ip, 872 UFS_NDADDR + indirs[0].in_off, newb, 0, 873 fs->fs_bsize, 0, bp); 874 bdwrite(bp); 875 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 876 if (bp->b_bufsize == fs->fs_bsize) 877 bp->b_flags |= B_CLUSTEROK; 878 bdwrite(bp); 879 } else { 880 if ((error = bwrite(bp)) != 0) 881 goto fail; 882 } 883 allocib = &dp->di_ib[indirs[0].in_off]; 884 *allocib = nb; 885 ip->i_flag |= IN_CHANGE | IN_UPDATE; 886 } 887 /* 888 * Fetch through the indirect blocks, allocating as necessary. 889 */ 890 retry: 891 for (i = 1;;) { 892 error = bread(vp, 893 indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp); 894 if (error) { 895 brelse(bp); 896 goto fail; 897 } 898 bap = (ufs2_daddr_t *)bp->b_data; 899 nb = bap[indirs[i].in_off]; 900 if ((error = UFS_CHECK_BLKNO(mp, ip->i_number, nb, 901 fs->fs_bsize)) != 0) { 902 brelse(bp); 903 goto fail; 904 } 905 if (i == num) 906 break; 907 i += 1; 908 if (nb != 0) { 909 bqrelse(bp); 910 continue; 911 } 912 UFS_LOCK(ump); 913 /* 914 * If parent indirect has just been allocated, try to cluster 915 * immediately following it. 916 */ 917 if (pref == 0) 918 pref = ffs_blkpref_ufs2(ip, lbn, i - num - 1, 919 (ufs2_daddr_t *)0); 920 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 921 flags | IO_BUFLOCKED, cred, &newb)) != 0) { 922 brelse(bp); 923 UFS_LOCK(ump); 924 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 925 softdep_request_cleanup(fs, vp, cred, 926 FLUSH_BLOCKS_WAIT); 927 UFS_UNLOCK(ump); 928 goto retry; 929 } 930 if (ppsratecheck(&ump->um_last_fullmsg, 931 &ump->um_secs_fullmsg, 1)) { 932 UFS_UNLOCK(ump); 933 ffs_fserr(fs, ip->i_number, "filesystem full"); 934 uprintf("\n%s: write failed, filesystem " 935 "is full\n", fs->fs_fsmnt); 936 } else { 937 UFS_UNLOCK(ump); 938 } 939 goto fail; 940 } 941 pref = newb + fs->fs_frag; 942 nb = newb; 943 MPASS(allocblk < allociblk + nitems(allociblk)); 944 MPASS(lbns_remfree < lbns + nitems(lbns)); 945 *allocblk++ = nb; 946 *lbns_remfree++ = indirs[i].in_lbn; 947 nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 948 GB_UNMAPPED); 949 nbp->b_blkno = fsbtodb(fs, nb); 950 vfs_bio_clrbuf(nbp); 951 if (DOINGSOFTDEP(vp)) { 952 softdep_setup_allocindir_meta(nbp, ip, bp, 953 indirs[i - 1].in_off, nb); 954 bdwrite(nbp); 955 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 956 if (nbp->b_bufsize == fs->fs_bsize) 957 nbp->b_flags |= B_CLUSTEROK; 958 bdwrite(nbp); 959 } else { 960 if ((error = bwrite(nbp)) != 0) { 961 brelse(bp); 962 goto fail; 963 } 964 } 965 bap[indirs[i - 1].in_off] = nb; 966 if (allocib == NULL && unwindidx < 0) 967 unwindidx = i - 1; 968 /* 969 * If required, write synchronously, otherwise use 970 * delayed write. 971 */ 972 if (flags & IO_SYNC) { 973 bwrite(bp); 974 } else { 975 if (bp->b_bufsize == fs->fs_bsize) 976 bp->b_flags |= B_CLUSTEROK; 977 bdwrite(bp); 978 } 979 } 980 /* 981 * If asked only for the indirect block, then return it. 982 */ 983 if (flags & BA_METAONLY) { 984 curthread_pflags_restore(saved_inbdflush); 985 *bpp = bp; 986 return (0); 987 } 988 /* 989 * Get the data block, allocating if necessary. 990 */ 991 if (nb == 0) { 992 UFS_LOCK(ump); 993 /* 994 * If allocating metadata at the front of the cylinder 995 * group and parent indirect block has just been allocated, 996 * then cluster next to it if it is the first indirect in 997 * the file. Otherwise it has been allocated in the metadata 998 * area, so we want to find our own place out in the data area. 999 */ 1000 if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0)) 1001 pref = ffs_blkpref_ufs2(ip, lbn, indirs[i].in_off, 1002 &bap[0]); 1003 error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 1004 flags | IO_BUFLOCKED, cred, &newb); 1005 if (error) { 1006 brelse(bp); 1007 UFS_LOCK(ump); 1008 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 1009 softdep_request_cleanup(fs, vp, cred, 1010 FLUSH_BLOCKS_WAIT); 1011 UFS_UNLOCK(ump); 1012 goto retry; 1013 } 1014 if (ppsratecheck(&ump->um_last_fullmsg, 1015 &ump->um_secs_fullmsg, 1)) { 1016 UFS_UNLOCK(ump); 1017 ffs_fserr(fs, ip->i_number, "filesystem full"); 1018 uprintf("\n%s: write failed, filesystem " 1019 "is full\n", fs->fs_fsmnt); 1020 } else { 1021 UFS_UNLOCK(ump); 1022 } 1023 goto fail; 1024 } 1025 nb = newb; 1026 MPASS(allocblk < allociblk + nitems(allociblk)); 1027 MPASS(lbns_remfree < lbns + nitems(lbns)); 1028 *allocblk++ = nb; 1029 *lbns_remfree++ = lbn; 1030 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 1031 nbp->b_blkno = fsbtodb(fs, nb); 1032 if (flags & BA_CLRBUF) 1033 vfs_bio_clrbuf(nbp); 1034 if (DOINGSOFTDEP(vp)) 1035 softdep_setup_allocindir_page(ip, lbn, bp, 1036 indirs[i].in_off, nb, 0, nbp); 1037 bap[indirs[i].in_off] = nb; 1038 /* 1039 * If required, write synchronously, otherwise use 1040 * delayed write. 1041 */ 1042 if (flags & IO_SYNC) { 1043 bwrite(bp); 1044 } else { 1045 if (bp->b_bufsize == fs->fs_bsize) 1046 bp->b_flags |= B_CLUSTEROK; 1047 bdwrite(bp); 1048 } 1049 curthread_pflags_restore(saved_inbdflush); 1050 *bpp = nbp; 1051 return (0); 1052 } 1053 brelse(bp); 1054 /* 1055 * If requested clear invalid portions of the buffer. If we 1056 * have to do a read-before-write (typical if BA_CLRBUF is set), 1057 * try to do some read-ahead in the sequential case to reduce 1058 * the number of I/O transactions. 1059 */ 1060 if (flags & BA_CLRBUF) { 1061 int seqcount = (flags & BA_SEQMASK) >> BA_SEQSHIFT; 1062 if (seqcount != 0 && 1063 (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0 && 1064 !(vm_page_count_severe() || buf_dirty_count_severe())) { 1065 error = cluster_read(vp, ip->i_size, lbn, 1066 (int)fs->fs_bsize, NOCRED, 1067 MAXBSIZE, seqcount, gbflags, &nbp); 1068 } else { 1069 error = bread_gb(vp, lbn, (int)fs->fs_bsize, 1070 NOCRED, gbflags, &nbp); 1071 } 1072 if (error) { 1073 brelse(nbp); 1074 goto fail; 1075 } 1076 } else { 1077 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 1078 nbp->b_blkno = fsbtodb(fs, nb); 1079 } 1080 curthread_pflags_restore(saved_inbdflush); 1081 *bpp = nbp; 1082 return (0); 1083 fail: 1084 curthread_pflags_restore(saved_inbdflush); 1085 /* 1086 * If we have failed to allocate any blocks, simply return the error. 1087 * This is the usual case and avoids the need to fsync the file. 1088 */ 1089 if (allocblk == allociblk && allocib == NULL && unwindidx == -1) 1090 return (error); 1091 /* 1092 * If we have failed part way through block allocation, we 1093 * have to deallocate any indirect blocks that we have allocated. 1094 * We have to fsync the file before we start to get rid of all 1095 * of its dependencies so that we do not leave them dangling. 1096 * We have to sync it at the end so that the soft updates code 1097 * does not find any untracked changes. Although this is really 1098 * slow, running out of disk space is not expected to be a common 1099 * occurrence. The error return from fsync is ignored as we already 1100 * have an error to return to the user. 1101 * 1102 * XXX Still have to journal the free below 1103 */ 1104 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 1105 for (deallocated = 0, blkp = allociblk, lbns_remfree = lbns; 1106 blkp < allocblk; blkp++, lbns_remfree++) { 1107 /* 1108 * We shall not leave the freed blocks on the vnode 1109 * buffer object lists. 1110 */ 1111 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 1112 GB_NOCREAT | GB_UNMAPPED); 1113 if (bp != NULL) { 1114 KASSERT(bp->b_blkno == fsbtodb(fs, *blkp), 1115 ("mismatch2 l %jd %jd b %ju %ju", 1116 (intmax_t)bp->b_lblkno, (uintmax_t)*lbns_remfree, 1117 (uintmax_t)bp->b_blkno, 1118 (uintmax_t)fsbtodb(fs, *blkp))); 1119 bp->b_flags |= B_INVAL | B_RELBUF | B_NOCACHE; 1120 bp->b_flags &= ~(B_ASYNC | B_CACHE); 1121 brelse(bp); 1122 } 1123 deallocated += fs->fs_bsize; 1124 } 1125 if (allocib != NULL) { 1126 *allocib = 0; 1127 } else if (unwindidx >= 0) { 1128 int r; 1129 1130 r = bread(vp, indirs[unwindidx].in_lbn, 1131 (int)fs->fs_bsize, NOCRED, &bp); 1132 if (r) { 1133 panic("Could not unwind indirect block, error %d", r); 1134 brelse(bp); 1135 } else { 1136 bap = (ufs2_daddr_t *)bp->b_data; 1137 bap[indirs[unwindidx].in_off] = 0; 1138 if (flags & IO_SYNC) { 1139 bwrite(bp); 1140 } else { 1141 if (bp->b_bufsize == fs->fs_bsize) 1142 bp->b_flags |= B_CLUSTEROK; 1143 bdwrite(bp); 1144 } 1145 } 1146 } 1147 if (deallocated) { 1148 #ifdef QUOTA 1149 /* 1150 * Restore user's disk quota because allocation failed. 1151 */ 1152 (void) chkdq(ip, -btodb(deallocated), cred, FORCE); 1153 #endif 1154 dp->di_blocks -= btodb(deallocated); 1155 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1156 } 1157 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 1158 /* 1159 * After the buffers are invalidated and on-disk pointers are 1160 * cleared, free the blocks. 1161 */ 1162 for (blkp = allociblk; blkp < allocblk; blkp++) { 1163 #ifdef INVARIANTS 1164 if (blkp == allociblk) 1165 lbns_remfree = lbns; 1166 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 1167 GB_NOCREAT | GB_UNMAPPED); 1168 if (bp != NULL) { 1169 panic("zombie2 %jd %ju %ju", 1170 (intmax_t)bp->b_lblkno, (uintmax_t)bp->b_blkno, 1171 (uintmax_t)fsbtodb(fs, *blkp)); 1172 } 1173 lbns_remfree++; 1174 #endif 1175 ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize, 1176 ip->i_number, vp->v_type, NULL, SINGLETON_KEY); 1177 } 1178 return (error); 1179 } 1180