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