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 UFS_INODE_SET_FLAG(ip, 158 IN_SIZEMOD | IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 159 if (flags & IO_SYNC) 160 bwrite(bp); 161 else if (DOINGASYNC(vp)) 162 bdwrite(bp); 163 else 164 bawrite(bp); 165 } 166 } 167 /* 168 * The first UFS_NDADDR blocks are direct blocks 169 */ 170 if (lbn < UFS_NDADDR) { 171 if (flags & BA_METAONLY) 172 panic("ffs_balloc_ufs1: BA_METAONLY for direct block"); 173 nb = dp->di_db[lbn]; 174 if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) { 175 error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp); 176 if (error) { 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 return (error); 193 } 194 bp->b_blkno = fsbtodb(fs, nb); 195 } else { 196 UFS_LOCK(ump); 197 error = ffs_realloccg(ip, lbn, dp->di_db[lbn], 198 ffs_blkpref_ufs1(ip, lbn, (int)lbn, 199 &dp->di_db[0]), osize, nsize, flags, 200 cred, &bp); 201 if (error) 202 return (error); 203 if (DOINGSOFTDEP(vp)) 204 softdep_setup_allocdirect(ip, lbn, 205 dbtofsb(fs, bp->b_blkno), nb, 206 nsize, osize, bp); 207 } 208 } else { 209 if (ip->i_size < smalllblktosize(fs, lbn + 1)) 210 nsize = fragroundup(fs, size); 211 else 212 nsize = fs->fs_bsize; 213 UFS_LOCK(ump); 214 error = ffs_alloc(ip, lbn, 215 ffs_blkpref_ufs1(ip, lbn, (int)lbn, &dp->di_db[0]), 216 nsize, flags, cred, &newb); 217 if (error) 218 return (error); 219 bp = getblk(vp, lbn, nsize, 0, 0, gbflags); 220 bp->b_blkno = fsbtodb(fs, newb); 221 if (flags & BA_CLRBUF) 222 vfs_bio_clrbuf(bp); 223 if (DOINGSOFTDEP(vp)) 224 softdep_setup_allocdirect(ip, lbn, newb, 0, 225 nsize, 0, bp); 226 } 227 dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno); 228 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 229 *bpp = bp; 230 return (0); 231 } 232 /* 233 * Determine the number of levels of indirection. 234 */ 235 pref = 0; 236 if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0) 237 return(error); 238 #ifdef INVARIANTS 239 if (num < 1) 240 panic ("ffs_balloc_ufs1: ufs_getlbns returned indirect block"); 241 #endif 242 saved_inbdflush = curthread_pflags_set(TDP_INBDFLUSH); 243 /* 244 * Fetch the first indirect block allocating if necessary. 245 */ 246 --num; 247 nb = dp->di_ib[indirs[0].in_off]; 248 allocib = NULL; 249 allocblk = allociblk; 250 lbns_remfree = lbns; 251 if (nb == 0) { 252 UFS_LOCK(ump); 253 pref = ffs_blkpref_ufs1(ip, lbn, -indirs[0].in_off - 1, 254 (ufs1_daddr_t *)0); 255 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 256 flags, cred, &newb)) != 0) { 257 curthread_pflags_restore(saved_inbdflush); 258 return (error); 259 } 260 pref = newb + fs->fs_frag; 261 nb = newb; 262 MPASS(allocblk < allociblk + nitems(allociblk)); 263 MPASS(lbns_remfree < lbns + nitems(lbns)); 264 *allocblk++ = nb; 265 *lbns_remfree++ = indirs[1].in_lbn; 266 bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, gbflags); 267 bp->b_blkno = fsbtodb(fs, nb); 268 vfs_bio_clrbuf(bp); 269 if (DOINGSOFTDEP(vp)) { 270 softdep_setup_allocdirect(ip, 271 UFS_NDADDR + indirs[0].in_off, newb, 0, 272 fs->fs_bsize, 0, bp); 273 bdwrite(bp); 274 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 275 if (bp->b_bufsize == fs->fs_bsize) 276 bp->b_flags |= B_CLUSTEROK; 277 bdwrite(bp); 278 } else { 279 if ((error = bwrite(bp)) != 0) 280 goto fail; 281 } 282 allocib = &dp->di_ib[indirs[0].in_off]; 283 *allocib = nb; 284 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 285 } 286 /* 287 * Fetch through the indirect blocks, allocating as necessary. 288 */ 289 retry: 290 for (i = 1;;) { 291 error = bread(vp, 292 indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp); 293 if (error) { 294 goto fail; 295 } 296 bap = (ufs1_daddr_t *)bp->b_data; 297 nb = bap[indirs[i].in_off]; 298 if ((error = UFS_CHECK_BLKNO(mp, ip->i_number, nb, 299 fs->fs_bsize)) != 0) { 300 brelse(bp); 301 goto fail; 302 } 303 if (i == num) 304 break; 305 i += 1; 306 if (nb != 0) { 307 bqrelse(bp); 308 continue; 309 } 310 UFS_LOCK(ump); 311 /* 312 * If parent indirect has just been allocated, try to cluster 313 * immediately following it. 314 */ 315 if (pref == 0) 316 pref = ffs_blkpref_ufs1(ip, lbn, i - num - 1, 317 (ufs1_daddr_t *)0); 318 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 319 flags | IO_BUFLOCKED, cred, &newb)) != 0) { 320 brelse(bp); 321 UFS_LOCK(ump); 322 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 323 softdep_request_cleanup(fs, vp, cred, 324 FLUSH_BLOCKS_WAIT); 325 UFS_UNLOCK(ump); 326 goto retry; 327 } 328 if (!ffs_fsfail_cleanup_locked(ump, error) && 329 ppsratecheck(&ump->um_last_fullmsg, 330 &ump->um_secs_fullmsg, 1)) { 331 UFS_UNLOCK(ump); 332 ffs_fserr(fs, ip->i_number, "filesystem full"); 333 uprintf("\n%s: write failed, filesystem " 334 "is full\n", fs->fs_fsmnt); 335 } else { 336 UFS_UNLOCK(ump); 337 } 338 goto fail; 339 } 340 pref = newb + fs->fs_frag; 341 nb = newb; 342 MPASS(allocblk < allociblk + nitems(allociblk)); 343 MPASS(lbns_remfree < lbns + nitems(lbns)); 344 *allocblk++ = nb; 345 *lbns_remfree++ = indirs[i].in_lbn; 346 nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 0); 347 nbp->b_blkno = fsbtodb(fs, nb); 348 vfs_bio_clrbuf(nbp); 349 if (DOINGSOFTDEP(vp)) { 350 softdep_setup_allocindir_meta(nbp, ip, bp, 351 indirs[i - 1].in_off, nb); 352 bdwrite(nbp); 353 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 354 if (nbp->b_bufsize == fs->fs_bsize) 355 nbp->b_flags |= B_CLUSTEROK; 356 bdwrite(nbp); 357 } else { 358 if ((error = bwrite(nbp)) != 0) { 359 brelse(bp); 360 goto fail; 361 } 362 } 363 bap[indirs[i - 1].in_off] = nb; 364 if (allocib == NULL && unwindidx < 0) 365 unwindidx = i - 1; 366 /* 367 * If required, write synchronously, otherwise use 368 * delayed write. 369 */ 370 if (flags & IO_SYNC) { 371 bwrite(bp); 372 } else { 373 if (bp->b_bufsize == fs->fs_bsize) 374 bp->b_flags |= B_CLUSTEROK; 375 bdwrite(bp); 376 } 377 } 378 /* 379 * If asked only for the indirect block, then return it. 380 */ 381 if (flags & BA_METAONLY) { 382 curthread_pflags_restore(saved_inbdflush); 383 *bpp = bp; 384 return (0); 385 } 386 /* 387 * Get the data block, allocating if necessary. 388 */ 389 if (nb == 0) { 390 UFS_LOCK(ump); 391 /* 392 * If allocating metadata at the front of the cylinder 393 * group and parent indirect block has just been allocated, 394 * then cluster next to it if it is the first indirect in 395 * the file. Otherwise it has been allocated in the metadata 396 * area, so we want to find our own place out in the data area. 397 */ 398 if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0)) 399 pref = ffs_blkpref_ufs1(ip, lbn, indirs[i].in_off, 400 &bap[0]); 401 error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 402 flags | IO_BUFLOCKED, cred, &newb); 403 if (error) { 404 brelse(bp); 405 UFS_LOCK(ump); 406 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 407 softdep_request_cleanup(fs, vp, cred, 408 FLUSH_BLOCKS_WAIT); 409 UFS_UNLOCK(ump); 410 goto retry; 411 } 412 if (!ffs_fsfail_cleanup_locked(ump, error) && 413 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 UFS_INODE_SET_FLAG(ip, 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 UFS_INODE_SET_FLAG(ip, 652 IN_SIZEMOD | IN_CHANGE | IN_IBLKDATA); 653 if (flags & IO_SYNC) 654 bwrite(bp); 655 else 656 bawrite(bp); 657 } 658 } 659 /* 660 * All blocks are direct blocks 661 */ 662 if (flags & BA_METAONLY) 663 panic("ffs_balloc_ufs2: BA_METAONLY for ext block"); 664 nb = dp->di_extb[lbn]; 665 if (nb != 0 && dp->di_extsize >= smalllblktosize(fs, lbn + 1)) { 666 error = bread_gb(vp, -1 - lbn, fs->fs_bsize, NOCRED, 667 gbflags, &bp); 668 if (error) { 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 return (error); 687 } 688 bp->b_blkno = fsbtodb(fs, nb); 689 bp->b_xflags |= BX_ALTDATA; 690 } else { 691 UFS_LOCK(ump); 692 error = ffs_realloccg(ip, -1 - lbn, 693 dp->di_extb[lbn], 694 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 695 &dp->di_extb[0]), osize, nsize, flags, 696 cred, &bp); 697 if (error) 698 return (error); 699 bp->b_xflags |= BX_ALTDATA; 700 if (DOINGSOFTDEP(vp)) 701 softdep_setup_allocext(ip, lbn, 702 dbtofsb(fs, bp->b_blkno), nb, 703 nsize, osize, bp); 704 } 705 } else { 706 if (dp->di_extsize < smalllblktosize(fs, lbn + 1)) 707 nsize = fragroundup(fs, size); 708 else 709 nsize = fs->fs_bsize; 710 UFS_LOCK(ump); 711 error = ffs_alloc(ip, lbn, 712 ffs_blkpref_ufs2(ip, lbn, (int)lbn, &dp->di_extb[0]), 713 nsize, flags, cred, &newb); 714 if (error) 715 return (error); 716 bp = getblk(vp, -1 - lbn, nsize, 0, 0, gbflags); 717 bp->b_blkno = fsbtodb(fs, newb); 718 bp->b_xflags |= BX_ALTDATA; 719 if (flags & BA_CLRBUF) 720 vfs_bio_clrbuf(bp); 721 if (DOINGSOFTDEP(vp)) 722 softdep_setup_allocext(ip, lbn, newb, 0, 723 nsize, 0, bp); 724 } 725 dp->di_extb[lbn] = dbtofsb(fs, bp->b_blkno); 726 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_IBLKDATA); 727 *bpp = bp; 728 return (0); 729 } 730 /* 731 * If the next write will extend the file into a new block, 732 * and the file is currently composed of a fragment 733 * this fragment has to be extended to be a full block. 734 */ 735 lastlbn = lblkno(fs, ip->i_size); 736 if (lastlbn < UFS_NDADDR && lastlbn < lbn) { 737 nb = lastlbn; 738 osize = blksize(fs, ip, nb); 739 if (osize < fs->fs_bsize && osize > 0) { 740 UFS_LOCK(ump); 741 error = ffs_realloccg(ip, nb, dp->di_db[nb], 742 ffs_blkpref_ufs2(ip, lastlbn, (int)nb, 743 &dp->di_db[0]), osize, (int)fs->fs_bsize, 744 flags, cred, &bp); 745 if (error) 746 return (error); 747 if (DOINGSOFTDEP(vp)) 748 softdep_setup_allocdirect(ip, nb, 749 dbtofsb(fs, bp->b_blkno), 750 dp->di_db[nb], 751 fs->fs_bsize, osize, bp); 752 ip->i_size = smalllblktosize(fs, nb + 1); 753 dp->di_size = ip->i_size; 754 dp->di_db[nb] = dbtofsb(fs, bp->b_blkno); 755 UFS_INODE_SET_FLAG(ip, 756 IN_SIZEMOD |IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 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 return (error); 775 } 776 bp->b_blkno = fsbtodb(fs, nb); 777 *bpp = bp; 778 return (0); 779 } 780 if (nb != 0) { 781 /* 782 * Consider need to reallocate a fragment. 783 */ 784 osize = fragroundup(fs, blkoff(fs, ip->i_size)); 785 nsize = fragroundup(fs, size); 786 if (nsize <= osize) { 787 error = bread_gb(vp, lbn, osize, NOCRED, 788 gbflags, &bp); 789 if (error) { 790 return (error); 791 } 792 bp->b_blkno = fsbtodb(fs, nb); 793 } else { 794 UFS_LOCK(ump); 795 error = ffs_realloccg(ip, lbn, dp->di_db[lbn], 796 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 797 &dp->di_db[0]), osize, nsize, flags, 798 cred, &bp); 799 if (error) 800 return (error); 801 if (DOINGSOFTDEP(vp)) 802 softdep_setup_allocdirect(ip, lbn, 803 dbtofsb(fs, bp->b_blkno), nb, 804 nsize, osize, bp); 805 } 806 } else { 807 if (ip->i_size < smalllblktosize(fs, lbn + 1)) 808 nsize = fragroundup(fs, size); 809 else 810 nsize = fs->fs_bsize; 811 UFS_LOCK(ump); 812 error = ffs_alloc(ip, lbn, 813 ffs_blkpref_ufs2(ip, lbn, (int)lbn, 814 &dp->di_db[0]), nsize, flags, cred, &newb); 815 if (error) 816 return (error); 817 bp = getblk(vp, lbn, nsize, 0, 0, gbflags); 818 bp->b_blkno = fsbtodb(fs, newb); 819 if (flags & BA_CLRBUF) 820 vfs_bio_clrbuf(bp); 821 if (DOINGSOFTDEP(vp)) 822 softdep_setup_allocdirect(ip, lbn, newb, 0, 823 nsize, 0, bp); 824 } 825 dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno); 826 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 827 *bpp = bp; 828 return (0); 829 } 830 /* 831 * Determine the number of levels of indirection. 832 */ 833 pref = 0; 834 if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0) 835 return(error); 836 #ifdef INVARIANTS 837 if (num < 1) 838 panic ("ffs_balloc_ufs2: ufs_getlbns returned indirect block"); 839 #endif 840 saved_inbdflush = curthread_pflags_set(TDP_INBDFLUSH); 841 /* 842 * Fetch the first indirect block allocating if necessary. 843 */ 844 --num; 845 nb = dp->di_ib[indirs[0].in_off]; 846 allocib = NULL; 847 allocblk = allociblk; 848 lbns_remfree = lbns; 849 if (nb == 0) { 850 UFS_LOCK(ump); 851 pref = ffs_blkpref_ufs2(ip, lbn, -indirs[0].in_off - 1, 852 (ufs2_daddr_t *)0); 853 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 854 flags, cred, &newb)) != 0) { 855 curthread_pflags_restore(saved_inbdflush); 856 return (error); 857 } 858 pref = newb + fs->fs_frag; 859 nb = newb; 860 MPASS(allocblk < allociblk + nitems(allociblk)); 861 MPASS(lbns_remfree < lbns + nitems(lbns)); 862 *allocblk++ = nb; 863 *lbns_remfree++ = indirs[1].in_lbn; 864 bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, 865 GB_UNMAPPED); 866 bp->b_blkno = fsbtodb(fs, nb); 867 vfs_bio_clrbuf(bp); 868 if (DOINGSOFTDEP(vp)) { 869 softdep_setup_allocdirect(ip, 870 UFS_NDADDR + indirs[0].in_off, newb, 0, 871 fs->fs_bsize, 0, bp); 872 bdwrite(bp); 873 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 874 if (bp->b_bufsize == fs->fs_bsize) 875 bp->b_flags |= B_CLUSTEROK; 876 bdwrite(bp); 877 } else { 878 if ((error = bwrite(bp)) != 0) 879 goto fail; 880 } 881 allocib = &dp->di_ib[indirs[0].in_off]; 882 *allocib = nb; 883 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE | IN_IBLKDATA); 884 } 885 /* 886 * Fetch through the indirect blocks, allocating as necessary. 887 */ 888 retry: 889 for (i = 1;;) { 890 error = bread(vp, 891 indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp); 892 if (error) { 893 goto fail; 894 } 895 bap = (ufs2_daddr_t *)bp->b_data; 896 nb = bap[indirs[i].in_off]; 897 if ((error = UFS_CHECK_BLKNO(mp, ip->i_number, nb, 898 fs->fs_bsize)) != 0) { 899 brelse(bp); 900 goto fail; 901 } 902 if (i == num) 903 break; 904 i += 1; 905 if (nb != 0) { 906 bqrelse(bp); 907 continue; 908 } 909 UFS_LOCK(ump); 910 /* 911 * If parent indirect has just been allocated, try to cluster 912 * immediately following it. 913 */ 914 if (pref == 0) 915 pref = ffs_blkpref_ufs2(ip, lbn, i - num - 1, 916 (ufs2_daddr_t *)0); 917 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 918 flags | IO_BUFLOCKED, cred, &newb)) != 0) { 919 brelse(bp); 920 UFS_LOCK(ump); 921 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 922 softdep_request_cleanup(fs, vp, cred, 923 FLUSH_BLOCKS_WAIT); 924 UFS_UNLOCK(ump); 925 goto retry; 926 } 927 if (!ffs_fsfail_cleanup_locked(ump, error) && 928 ppsratecheck(&ump->um_last_fullmsg, 929 &ump->um_secs_fullmsg, 1)) { 930 UFS_UNLOCK(ump); 931 ffs_fserr(fs, ip->i_number, "filesystem full"); 932 uprintf("\n%s: write failed, filesystem " 933 "is full\n", fs->fs_fsmnt); 934 } else { 935 UFS_UNLOCK(ump); 936 } 937 goto fail; 938 } 939 pref = newb + fs->fs_frag; 940 nb = newb; 941 MPASS(allocblk < allociblk + nitems(allociblk)); 942 MPASS(lbns_remfree < lbns + nitems(lbns)); 943 *allocblk++ = nb; 944 *lbns_remfree++ = indirs[i].in_lbn; 945 nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 946 GB_UNMAPPED); 947 nbp->b_blkno = fsbtodb(fs, nb); 948 vfs_bio_clrbuf(nbp); 949 if (DOINGSOFTDEP(vp)) { 950 softdep_setup_allocindir_meta(nbp, ip, bp, 951 indirs[i - 1].in_off, nb); 952 bdwrite(nbp); 953 } else if ((flags & IO_SYNC) == 0 && DOINGASYNC(vp)) { 954 if (nbp->b_bufsize == fs->fs_bsize) 955 nbp->b_flags |= B_CLUSTEROK; 956 bdwrite(nbp); 957 } else { 958 if ((error = bwrite(nbp)) != 0) { 959 brelse(bp); 960 goto fail; 961 } 962 } 963 bap[indirs[i - 1].in_off] = nb; 964 if (allocib == NULL && unwindidx < 0) 965 unwindidx = i - 1; 966 /* 967 * If required, write synchronously, otherwise use 968 * delayed write. 969 */ 970 if (flags & IO_SYNC) { 971 bwrite(bp); 972 } else { 973 if (bp->b_bufsize == fs->fs_bsize) 974 bp->b_flags |= B_CLUSTEROK; 975 bdwrite(bp); 976 } 977 } 978 /* 979 * If asked only for the indirect block, then return it. 980 */ 981 if (flags & BA_METAONLY) { 982 curthread_pflags_restore(saved_inbdflush); 983 *bpp = bp; 984 return (0); 985 } 986 /* 987 * Get the data block, allocating if necessary. 988 */ 989 if (nb == 0) { 990 UFS_LOCK(ump); 991 /* 992 * If allocating metadata at the front of the cylinder 993 * group and parent indirect block has just been allocated, 994 * then cluster next to it if it is the first indirect in 995 * the file. Otherwise it has been allocated in the metadata 996 * area, so we want to find our own place out in the data area. 997 */ 998 if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0)) 999 pref = ffs_blkpref_ufs2(ip, lbn, indirs[i].in_off, 1000 &bap[0]); 1001 error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, 1002 flags | IO_BUFLOCKED, cred, &newb); 1003 if (error) { 1004 brelse(bp); 1005 UFS_LOCK(ump); 1006 if (DOINGSOFTDEP(vp) && ++reclaimed == 1) { 1007 softdep_request_cleanup(fs, vp, cred, 1008 FLUSH_BLOCKS_WAIT); 1009 UFS_UNLOCK(ump); 1010 goto retry; 1011 } 1012 if (!ffs_fsfail_cleanup_locked(ump, error) && 1013 ppsratecheck(&ump->um_last_fullmsg, 1014 &ump->um_secs_fullmsg, 1)) { 1015 UFS_UNLOCK(ump); 1016 ffs_fserr(fs, ip->i_number, "filesystem full"); 1017 uprintf("\n%s: write failed, filesystem " 1018 "is full\n", fs->fs_fsmnt); 1019 } else { 1020 UFS_UNLOCK(ump); 1021 } 1022 goto fail; 1023 } 1024 nb = newb; 1025 MPASS(allocblk < allociblk + nitems(allociblk)); 1026 MPASS(lbns_remfree < lbns + nitems(lbns)); 1027 *allocblk++ = nb; 1028 *lbns_remfree++ = lbn; 1029 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 1030 nbp->b_blkno = fsbtodb(fs, nb); 1031 if (flags & BA_CLRBUF) 1032 vfs_bio_clrbuf(nbp); 1033 if (DOINGSOFTDEP(vp)) 1034 softdep_setup_allocindir_page(ip, lbn, bp, 1035 indirs[i].in_off, nb, 0, nbp); 1036 bap[indirs[i].in_off] = nb; 1037 /* 1038 * If required, write synchronously, otherwise use 1039 * delayed write. 1040 */ 1041 if (flags & IO_SYNC) { 1042 bwrite(bp); 1043 } else { 1044 if (bp->b_bufsize == fs->fs_bsize) 1045 bp->b_flags |= B_CLUSTEROK; 1046 bdwrite(bp); 1047 } 1048 curthread_pflags_restore(saved_inbdflush); 1049 *bpp = nbp; 1050 return (0); 1051 } 1052 brelse(bp); 1053 /* 1054 * If requested clear invalid portions of the buffer. If we 1055 * have to do a read-before-write (typical if BA_CLRBUF is set), 1056 * try to do some read-ahead in the sequential case to reduce 1057 * the number of I/O transactions. 1058 */ 1059 if (flags & BA_CLRBUF) { 1060 int seqcount = (flags & BA_SEQMASK) >> BA_SEQSHIFT; 1061 if (seqcount != 0 && 1062 (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0 && 1063 !(vm_page_count_severe() || buf_dirty_count_severe())) { 1064 error = cluster_read(vp, ip->i_size, lbn, 1065 (int)fs->fs_bsize, NOCRED, 1066 MAXBSIZE, seqcount, gbflags, &nbp); 1067 } else { 1068 error = bread_gb(vp, lbn, (int)fs->fs_bsize, 1069 NOCRED, gbflags, &nbp); 1070 } 1071 if (error) { 1072 brelse(nbp); 1073 goto fail; 1074 } 1075 } else { 1076 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags); 1077 nbp->b_blkno = fsbtodb(fs, nb); 1078 } 1079 curthread_pflags_restore(saved_inbdflush); 1080 *bpp = nbp; 1081 return (0); 1082 fail: 1083 curthread_pflags_restore(saved_inbdflush); 1084 /* 1085 * If we have failed to allocate any blocks, simply return the error. 1086 * This is the usual case and avoids the need to fsync the file. 1087 */ 1088 if (allocblk == allociblk && allocib == NULL && unwindidx == -1) 1089 return (error); 1090 /* 1091 * If we have failed part way through block allocation, we 1092 * have to deallocate any indirect blocks that we have allocated. 1093 * We have to fsync the file before we start to get rid of all 1094 * of its dependencies so that we do not leave them dangling. 1095 * We have to sync it at the end so that the soft updates code 1096 * does not find any untracked changes. Although this is really 1097 * slow, running out of disk space is not expected to be a common 1098 * occurrence. The error return from fsync is ignored as we already 1099 * have an error to return to the user. 1100 * 1101 * XXX Still have to journal the free below 1102 */ 1103 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 1104 for (deallocated = 0, blkp = allociblk, lbns_remfree = lbns; 1105 blkp < allocblk; blkp++, lbns_remfree++) { 1106 /* 1107 * We shall not leave the freed blocks on the vnode 1108 * buffer object lists. 1109 */ 1110 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 1111 GB_NOCREAT | GB_UNMAPPED); 1112 if (bp != NULL) { 1113 KASSERT(bp->b_blkno == fsbtodb(fs, *blkp), 1114 ("mismatch2 l %jd %jd b %ju %ju", 1115 (intmax_t)bp->b_lblkno, (uintmax_t)*lbns_remfree, 1116 (uintmax_t)bp->b_blkno, 1117 (uintmax_t)fsbtodb(fs, *blkp))); 1118 bp->b_flags |= B_INVAL | B_RELBUF | B_NOCACHE; 1119 bp->b_flags &= ~(B_ASYNC | B_CACHE); 1120 brelse(bp); 1121 } 1122 deallocated += fs->fs_bsize; 1123 } 1124 if (allocib != NULL) { 1125 *allocib = 0; 1126 } else if (unwindidx >= 0) { 1127 int r; 1128 1129 r = bread(vp, indirs[unwindidx].in_lbn, 1130 (int)fs->fs_bsize, NOCRED, &bp); 1131 if (r) { 1132 panic("Could not unwind indirect block, error %d", r); 1133 brelse(bp); 1134 } else { 1135 bap = (ufs2_daddr_t *)bp->b_data; 1136 bap[indirs[unwindidx].in_off] = 0; 1137 if (flags & IO_SYNC) { 1138 bwrite(bp); 1139 } else { 1140 if (bp->b_bufsize == fs->fs_bsize) 1141 bp->b_flags |= B_CLUSTEROK; 1142 bdwrite(bp); 1143 } 1144 } 1145 } 1146 if (deallocated) { 1147 #ifdef QUOTA 1148 /* 1149 * Restore user's disk quota because allocation failed. 1150 */ 1151 (void) chkdq(ip, -btodb(deallocated), cred, FORCE); 1152 #endif 1153 dp->di_blocks -= btodb(deallocated); 1154 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE); 1155 } 1156 (void) ffs_syncvnode(vp, MNT_WAIT, 0); 1157 /* 1158 * After the buffers are invalidated and on-disk pointers are 1159 * cleared, free the blocks. 1160 */ 1161 for (blkp = allociblk; blkp < allocblk; blkp++) { 1162 #ifdef INVARIANTS 1163 if (blkp == allociblk) 1164 lbns_remfree = lbns; 1165 bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0, 1166 GB_NOCREAT | GB_UNMAPPED); 1167 if (bp != NULL) { 1168 panic("zombie2 %jd %ju %ju", 1169 (intmax_t)bp->b_lblkno, (uintmax_t)bp->b_blkno, 1170 (uintmax_t)fsbtodb(fs, *blkp)); 1171 } 1172 lbns_remfree++; 1173 #endif 1174 ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize, 1175 ip->i_number, vp->v_type, NULL, SINGLETON_KEY); 1176 } 1177 return (error); 1178 } 1179