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