1 /* $NetBSD: lfs_bio.c,v 1.142 2018/06/09 18:48:31 zafer Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant@hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /* 32 * Copyright (c) 1991, 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 * 3. 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 * @(#)lfs_bio.c 8.10 (Berkeley) 6/10/95 60 */ 61 62 #include <sys/cdefs.h> 63 __KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.142 2018/06/09 18:48:31 zafer Exp $"); 64 65 #include <sys/param.h> 66 #include <sys/systm.h> 67 #include <sys/proc.h> 68 #include <sys/buf.h> 69 #include <sys/vnode.h> 70 #include <sys/resourcevar.h> 71 #include <sys/mount.h> 72 #include <sys/kernel.h> 73 #include <sys/kauth.h> 74 75 #include <ufs/lfs/ulfs_inode.h> 76 #include <ufs/lfs/ulfsmount.h> 77 #include <ufs/lfs/ulfs_extern.h> 78 79 #include <ufs/lfs/lfs.h> 80 #include <ufs/lfs/lfs_accessors.h> 81 #include <ufs/lfs/lfs_extern.h> 82 #include <ufs/lfs/lfs_kernel.h> 83 84 #include <uvm/uvm.h> 85 86 /* 87 * LFS block write function. 88 * 89 * XXX 90 * No write cost accounting is done. 91 * This is almost certainly wrong for synchronous operations and NFS. 92 * 93 * protected by lfs_lock. 94 */ 95 int locked_queue_count = 0; /* Count of locked-down buffers. */ 96 long locked_queue_bytes = 0L; /* Total size of locked buffers. */ 97 int lfs_subsys_pages = 0L; /* Total number LFS-written pages */ 98 int lfs_fs_pagetrip = 0; /* # of pages to trip per-fs write */ 99 int lfs_writing = 0; /* Set if already kicked off a writer 100 because of buffer space */ 101 int locked_queue_waiters = 0; /* Number of processes waiting on lq */ 102 103 /* Lock and condition variables for above. */ 104 kcondvar_t locked_queue_cv; 105 kcondvar_t lfs_writing_cv; 106 kmutex_t lfs_lock; 107 108 extern int lfs_dostats; 109 110 /* 111 * reserved number/bytes of locked buffers 112 */ 113 int locked_queue_rcount = 0; 114 long locked_queue_rbytes = 0L; 115 116 static int lfs_fits_buf(struct lfs *, int, int); 117 static int lfs_reservebuf(struct lfs *, struct vnode *vp, struct vnode *vp2, 118 int, int); 119 static int lfs_reserveavail(struct lfs *, struct vnode *vp, struct vnode *vp2, 120 int); 121 122 static int 123 lfs_fits_buf(struct lfs *fs, int n, int bytes) 124 { 125 int count_fit, bytes_fit; 126 127 ASSERT_NO_SEGLOCK(fs); 128 KASSERT(mutex_owned(&lfs_lock)); 129 130 count_fit = 131 (locked_queue_count + locked_queue_rcount + n <= LFS_WAIT_BUFS); 132 bytes_fit = 133 (locked_queue_bytes + locked_queue_rbytes + bytes <= LFS_WAIT_BYTES); 134 135 #ifdef DEBUG 136 if (!count_fit) { 137 DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit count: %d + %d + %d >= %d\n", 138 locked_queue_count, locked_queue_rcount, 139 n, LFS_WAIT_BUFS)); 140 } 141 if (!bytes_fit) { 142 DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit bytes: %ld + %ld + %d >= %ld\n", 143 locked_queue_bytes, locked_queue_rbytes, 144 bytes, LFS_WAIT_BYTES)); 145 } 146 #endif /* DEBUG */ 147 148 return (count_fit && bytes_fit); 149 } 150 151 /* ARGSUSED */ 152 static int 153 lfs_reservebuf(struct lfs *fs, struct vnode *vp, 154 struct vnode *vp2, int n, int bytes) 155 { 156 int cantwait; 157 158 ASSERT_MAYBE_SEGLOCK(fs); 159 KASSERT(locked_queue_rcount >= 0); 160 KASSERT(locked_queue_rbytes >= 0); 161 162 cantwait = (VTOI(vp)->i_state & IN_ADIROP) || fs->lfs_unlockvp == vp; 163 mutex_enter(&lfs_lock); 164 while (!cantwait && n > 0 && !lfs_fits_buf(fs, n, bytes)) { 165 int error; 166 167 lfs_flush(fs, 0, 0); 168 169 DLOG((DLOG_AVAIL, "lfs_reservebuf: waiting: count=%d, bytes=%ld\n", 170 locked_queue_count, locked_queue_bytes)); 171 ++locked_queue_waiters; 172 error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock, 173 hz * LFS_BUFWAIT); 174 --locked_queue_waiters; 175 if (error && error != EWOULDBLOCK) { 176 mutex_exit(&lfs_lock); 177 return error; 178 } 179 } 180 181 locked_queue_rcount += n; 182 locked_queue_rbytes += bytes; 183 184 if (n < 0 && locked_queue_waiters > 0) { 185 DLOG((DLOG_AVAIL, "lfs_reservebuf: broadcast: count=%d, bytes=%ld\n", 186 locked_queue_count, locked_queue_bytes)); 187 cv_broadcast(&locked_queue_cv); 188 } 189 190 mutex_exit(&lfs_lock); 191 192 KASSERT(locked_queue_rcount >= 0); 193 KASSERT(locked_queue_rbytes >= 0); 194 195 return 0; 196 } 197 198 /* 199 * Try to reserve some blocks, prior to performing a sensitive operation that 200 * requires the vnode lock to be honored. If there is not enough space, wait 201 * for the space to become available. 202 * 203 * Called with vp locked. (Note nowever that if fsb < 0, vp is ignored.) 204 */ 205 static int 206 lfs_reserveavail(struct lfs *fs, struct vnode *vp, 207 struct vnode *vp2, int fsb) 208 { 209 CLEANERINFO *cip; 210 struct buf *bp; 211 int error, slept; 212 int cantwait; 213 214 ASSERT_MAYBE_SEGLOCK(fs); 215 slept = 0; 216 mutex_enter(&lfs_lock); 217 cantwait = (VTOI(vp)->i_state & IN_ADIROP) || fs->lfs_unlockvp == vp; 218 while (!cantwait && fsb > 0 && 219 !lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) { 220 mutex_exit(&lfs_lock); 221 222 if (!slept) { 223 DLOG((DLOG_AVAIL, "lfs_reserve: waiting for %ld (bfree = %jd," 224 " est_bfree = %jd)\n", 225 fsb + fs->lfs_ravail + fs->lfs_favail, 226 (intmax_t)lfs_sb_getbfree(fs), 227 (intmax_t)LFS_EST_BFREE(fs))); 228 } 229 ++slept; 230 231 /* Wake up the cleaner */ 232 LFS_CLEANERINFO(cip, fs, bp); 233 LFS_SYNC_CLEANERINFO(cip, fs, bp, 0); 234 lfs_wakeup_cleaner(fs); 235 236 mutex_enter(&lfs_lock); 237 /* Cleaner might have run while we were reading, check again */ 238 if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) 239 break; 240 241 error = mtsleep(&fs->lfs_availsleep, PCATCH | PUSER, 242 "lfs_reserve", 0, &lfs_lock); 243 if (error) { 244 mutex_exit(&lfs_lock); 245 return error; 246 } 247 } 248 #ifdef DEBUG 249 if (slept) { 250 DLOG((DLOG_AVAIL, "lfs_reserve: woke up\n")); 251 } 252 #endif 253 fs->lfs_ravail += fsb; 254 mutex_exit(&lfs_lock); 255 256 return 0; 257 } 258 259 #ifdef DIAGNOSTIC 260 int lfs_rescount; 261 int lfs_rescountdirop; 262 #endif 263 264 int 265 lfs_reserve(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb) 266 { 267 int error; 268 269 ASSERT_MAYBE_SEGLOCK(fs); 270 if (vp2) { 271 /* Make sure we're not in the process of reclaiming vp2 */ 272 mutex_enter(&lfs_lock); 273 while(fs->lfs_flags & LFS_UNDIROP) { 274 mtsleep(&fs->lfs_flags, PRIBIO + 1, "lfsrundirop", 0, 275 &lfs_lock); 276 } 277 mutex_exit(&lfs_lock); 278 } 279 280 KASSERT(fsb < 0 || VOP_ISLOCKED(vp)); 281 KASSERT(vp2 == NULL || fsb < 0 || VOP_ISLOCKED(vp2)); 282 KASSERT(vp2 == NULL || vp2 != fs->lfs_unlockvp); 283 284 #ifdef DIAGNOSTIC 285 mutex_enter(&lfs_lock); 286 if (fsb > 0) 287 lfs_rescount++; 288 else if (fsb < 0) 289 lfs_rescount--; 290 if (lfs_rescount < 0) 291 panic("lfs_rescount"); 292 mutex_exit(&lfs_lock); 293 #endif 294 295 error = lfs_reserveavail(fs, vp, vp2, fsb); 296 if (error) 297 return error; 298 299 /* 300 * XXX just a guess. should be more precise. 301 */ 302 error = lfs_reservebuf(fs, vp, vp2, fsb, lfs_fsbtob(fs, fsb)); 303 if (error) 304 lfs_reserveavail(fs, vp, vp2, -fsb); 305 306 return error; 307 } 308 309 int 310 lfs_max_bufs(void) 311 { 312 313 return LFS_MAX_RESOURCE(buf_nbuf(), 1); 314 } 315 316 int 317 lfs_wait_bufs(void) 318 { 319 320 return LFS_WAIT_RESOURCE(buf_nbuf(), 1); 321 } 322 323 int 324 lfs_bwrite(void *v) 325 { 326 struct vop_bwrite_args /* { 327 struct vnode *a_vp; 328 struct buf *a_bp; 329 } */ *ap = v; 330 struct buf *bp = ap->a_bp; 331 332 KASSERTMSG((VTOI(bp->b_vp)->i_lfs->lfs_ronly || 333 !(bp->b_flags & B_ASYNC)), 334 "bawrite LFS buffer"); 335 return lfs_bwrite_ext(bp, 0); 336 } 337 338 /* 339 * Determine if there is enough room currently available to write fsb 340 * blocks. We need enough blocks for the new blocks, the current 341 * inode blocks (including potentially the ifile inode), a summary block, 342 * and the segment usage table, plus an ifile block. 343 */ 344 int 345 lfs_fits(struct lfs *fs, int fsb) 346 { 347 int64_t needed; 348 349 ASSERT_NO_SEGLOCK(fs); 350 needed = fsb + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + 351 ((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) + 352 lfs_sb_getsegtabsz(fs) + 353 1) << (lfs_sb_getbshift(fs) - lfs_sb_getffshift(fs))); 354 355 if (needed >= lfs_sb_getavail(fs)) { 356 #ifdef DEBUG 357 DLOG((DLOG_AVAIL, "lfs_fits: no fit: fsb = %ld, uinodes = %ld, " 358 "needed = %jd, avail = %jd\n", 359 (long)fsb, (long)lfs_sb_getuinodes(fs), (intmax_t)needed, 360 (intmax_t)lfs_sb_getavail(fs))); 361 #endif 362 return 0; 363 } 364 return 1; 365 } 366 367 int 368 lfs_availwait(struct lfs *fs, int fsb) 369 { 370 int error; 371 CLEANERINFO *cip; 372 struct buf *cbp; 373 374 ASSERT_NO_SEGLOCK(fs); 375 /* Push cleaner blocks through regardless */ 376 mutex_enter(&lfs_lock); 377 if (LFS_SEGLOCK_HELD(fs) && 378 fs->lfs_sp->seg_flags & (SEGM_CLEAN | SEGM_FORCE_CKP)) { 379 mutex_exit(&lfs_lock); 380 return 0; 381 } 382 mutex_exit(&lfs_lock); 383 384 while (!lfs_fits(fs, fsb)) { 385 /* 386 * Out of space, need cleaner to run. 387 * Update the cleaner info, then wake it up. 388 * Note the cleanerinfo block is on the ifile 389 * so it CANT_WAIT. 390 */ 391 LFS_CLEANERINFO(cip, fs, cbp); 392 LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0); 393 394 #ifdef DEBUG 395 DLOG((DLOG_AVAIL, "lfs_availwait: out of available space, " 396 "waiting on cleaner\n")); 397 #endif 398 399 lfs_wakeup_cleaner(fs); 400 KASSERTMSG(!LFS_SEGLOCK_HELD(fs), "lfs_availwait: deadlock"); 401 error = tsleep(&fs->lfs_availsleep, PCATCH | PUSER, 402 "cleaner", 0); 403 if (error) 404 return (error); 405 } 406 return 0; 407 } 408 409 int 410 lfs_bwrite_ext(struct buf *bp, int flags) 411 { 412 struct lfs *fs; 413 struct inode *ip; 414 struct vnode *vp; 415 int fsb; 416 417 vp = bp->b_vp; 418 fs = VFSTOULFS(vp->v_mount)->um_lfs; 419 420 ASSERT_MAYBE_SEGLOCK(fs); 421 KASSERT(bp->b_cflags & BC_BUSY); 422 KASSERT(flags & BW_CLEAN || !LFS_IS_MALLOC_BUF(bp)); 423 KASSERT((bp->b_flags & B_LOCKED) || !(bp->b_oflags & BO_DELWRI)); 424 425 /* 426 * Don't write *any* blocks if we're mounted read-only, or 427 * if we are "already unmounted". 428 * 429 * In particular the cleaner can't write blocks either. 430 */ 431 if (fs->lfs_ronly || (lfs_sb_getpflags(fs) & LFS_PF_CLEAN)) { 432 bp->b_oflags &= ~BO_DELWRI; 433 bp->b_flags |= B_READ; /* XXX is this right? --ks */ 434 bp->b_error = 0; 435 mutex_enter(&bufcache_lock); 436 LFS_UNLOCK_BUF(bp); 437 if (LFS_IS_MALLOC_BUF(bp)) 438 bp->b_cflags &= ~BC_BUSY; 439 else 440 brelsel(bp, 0); 441 mutex_exit(&bufcache_lock); 442 return (fs->lfs_ronly ? EROFS : 0); 443 } 444 445 /* 446 * Set the delayed write flag and use reassignbuf to move the buffer 447 * from the clean list to the dirty one. 448 * 449 * Set the B_LOCKED flag and unlock the buffer, causing brelse to move 450 * the buffer onto the LOCKED free list. This is necessary, otherwise 451 * getnewbuf() would try to reclaim the buffers using bawrite, which 452 * isn't going to work. 453 * 454 * XXX we don't let meta-data writes run out of space because they can 455 * come from the segment writer. We need to make sure that there is 456 * enough space reserved so that there's room to write meta-data 457 * blocks. 458 */ 459 if ((bp->b_flags & B_LOCKED) == 0) { 460 fsb = lfs_numfrags(fs, bp->b_bcount); 461 462 ip = VTOI(vp); 463 mutex_enter(&lfs_lock); 464 if (flags & BW_CLEAN) { 465 LFS_SET_UINO(ip, IN_CLEANING); 466 } else { 467 LFS_SET_UINO(ip, IN_MODIFIED); 468 } 469 mutex_exit(&lfs_lock); 470 lfs_sb_subavail(fs, fsb); 471 472 mutex_enter(&bufcache_lock); 473 mutex_enter(vp->v_interlock); 474 bp->b_oflags = (bp->b_oflags | BO_DELWRI) & ~BO_DONE; 475 LFS_LOCK_BUF(bp); 476 bp->b_flags &= ~B_READ; 477 bp->b_error = 0; 478 reassignbuf(bp, bp->b_vp); 479 mutex_exit(vp->v_interlock); 480 } else { 481 mutex_enter(&bufcache_lock); 482 } 483 484 if (bp->b_iodone != NULL) 485 bp->b_cflags &= ~BC_BUSY; 486 else 487 brelsel(bp, 0); 488 mutex_exit(&bufcache_lock); 489 490 return (0); 491 } 492 493 /* 494 * Called and return with the lfs_lock held. 495 */ 496 void 497 lfs_flush_fs(struct lfs *fs, int flags) 498 { 499 ASSERT_NO_SEGLOCK(fs); 500 KASSERT(mutex_owned(&lfs_lock)); 501 if (fs->lfs_ronly) 502 return; 503 504 if (lfs_dostats) 505 ++lfs_stats.flush_invoked; 506 507 fs->lfs_pdflush = 0; 508 mutex_exit(&lfs_lock); 509 lfs_writer_enter(fs, "fldirop"); 510 lfs_segwrite(fs->lfs_ivnode->v_mount, flags); 511 lfs_writer_leave(fs); 512 mutex_enter(&lfs_lock); 513 fs->lfs_favail = 0; /* XXX */ 514 } 515 516 /* 517 * This routine initiates segment writes when LFS is consuming too many 518 * resources. Ideally the pageout daemon would be able to direct LFS 519 * more subtly. 520 * XXX We have one static count of locked buffers; 521 * XXX need to think more about the multiple filesystem case. 522 * 523 * Called and return with lfs_lock held. 524 * If fs != NULL, we hold the segment lock for fs. 525 */ 526 void 527 lfs_flush(struct lfs *fs, int flags, int only_onefs) 528 { 529 extern u_int64_t locked_fakequeue_count; 530 mount_iterator_t *iter; 531 struct mount *mp; 532 struct lfs *tfs; 533 534 KASSERT(mutex_owned(&lfs_lock)); 535 KDASSERT(fs == NULL || !LFS_SEGLOCK_HELD(fs)); 536 537 if (lfs_dostats) 538 ++lfs_stats.write_exceeded; 539 /* XXX should we include SEGM_CKP here? */ 540 if (lfs_writing && !(flags & SEGM_SYNC)) { 541 DLOG((DLOG_FLUSH, "lfs_flush: not flushing because another flush is active\n")); 542 return; 543 } 544 while (lfs_writing) 545 cv_wait(&lfs_writing_cv, &lfs_lock); 546 lfs_writing = 1; 547 548 mutex_exit(&lfs_lock); 549 550 if (only_onefs) { 551 KASSERT(fs != NULL); 552 if (vfs_busy(fs->lfs_ivnode->v_mount)) 553 goto errout; 554 mutex_enter(&lfs_lock); 555 lfs_flush_fs(fs, flags); 556 mutex_exit(&lfs_lock); 557 vfs_unbusy(fs->lfs_ivnode->v_mount); 558 } else { 559 locked_fakequeue_count = 0; 560 mountlist_iterator_init(&iter); 561 while ((mp = mountlist_iterator_next(iter)) != NULL) { 562 if (strncmp(&mp->mnt_stat.f_fstypename[0], MOUNT_LFS, 563 sizeof(mp->mnt_stat.f_fstypename)) == 0) { 564 tfs = VFSTOULFS(mp)->um_lfs; 565 mutex_enter(&lfs_lock); 566 lfs_flush_fs(tfs, flags); 567 mutex_exit(&lfs_lock); 568 } 569 } 570 mountlist_iterator_destroy(iter); 571 } 572 wakeup(&lfs_subsys_pages); 573 574 errout: 575 mutex_enter(&lfs_lock); 576 KASSERT(lfs_writing); 577 lfs_writing = 0; 578 wakeup(&lfs_writing); 579 } 580 581 #define INOCOUNT(fs) howmany(lfs_sb_getuinodes(fs), LFS_INOPB(fs)) 582 #define INOBYTES(fs) (lfs_sb_getuinodes(fs) * DINOSIZE(fs)) 583 584 /* 585 * make sure that we don't have too many locked buffers. 586 * flush buffers if needed. 587 */ 588 int 589 lfs_check(struct vnode *vp, daddr_t blkno, int flags) 590 { 591 int error; 592 struct lfs *fs; 593 struct inode *ip; 594 extern kcondvar_t lfs_writerd_cv; 595 596 error = 0; 597 ip = VTOI(vp); 598 599 /* If out of buffers, wait on writer */ 600 /* XXX KS - if it's the Ifile, we're probably the cleaner! */ 601 if (ip->i_number == LFS_IFILE_INUM) 602 return 0; 603 /* If we're being called from inside a dirop, don't sleep */ 604 if (ip->i_state & IN_ADIROP) 605 return 0; 606 607 fs = ip->i_lfs; 608 609 ASSERT_NO_SEGLOCK(fs); 610 611 /* 612 * If we would flush below, but dirops are active, sleep. 613 * Note that a dirop cannot ever reach this code! 614 */ 615 mutex_enter(&lfs_lock); 616 while (fs->lfs_dirops > 0 && 617 (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS || 618 locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES || 619 lfs_subsys_pages > LFS_MAX_PAGES || 620 fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) || 621 lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0)) 622 { 623 ++fs->lfs_diropwait; 624 mtsleep(&fs->lfs_writer, PRIBIO+1, "bufdirop", 0, 625 &lfs_lock); 626 --fs->lfs_diropwait; 627 } 628 629 #ifdef DEBUG 630 if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS) 631 DLOG((DLOG_FLUSH, "lfs_check: lqc = %d, max %d\n", 632 locked_queue_count + INOCOUNT(fs), LFS_MAX_BUFS)); 633 if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES) 634 DLOG((DLOG_FLUSH, "lfs_check: lqb = %ld, max %ld\n", 635 locked_queue_bytes + INOBYTES(fs), LFS_MAX_BYTES)); 636 if (lfs_subsys_pages > LFS_MAX_PAGES) 637 DLOG((DLOG_FLUSH, "lfs_check: lssp = %d, max %d\n", 638 lfs_subsys_pages, LFS_MAX_PAGES)); 639 if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) 640 DLOG((DLOG_FLUSH, "lfs_check: fssp = %d, trip at %d\n", 641 fs->lfs_pages, lfs_fs_pagetrip)); 642 if (lfs_dirvcount > LFS_MAX_DIROP) 643 DLOG((DLOG_FLUSH, "lfs_check: ldvc = %d, max %d\n", 644 lfs_dirvcount, LFS_MAX_DIROP)); 645 if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs)) 646 DLOG((DLOG_FLUSH, "lfs_check: lfdvc = %d, max %d\n", 647 fs->lfs_dirvcount, LFS_MAX_FSDIROP(fs))); 648 if (fs->lfs_diropwait > 0) 649 DLOG((DLOG_FLUSH, "lfs_check: ldvw = %d\n", 650 fs->lfs_diropwait)); 651 #endif 652 653 /* If there are too many pending dirops, we have to flush them. */ 654 if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) || 655 lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) { 656 mutex_exit(&lfs_lock); 657 lfs_flush_dirops(fs); 658 mutex_enter(&lfs_lock); 659 } else if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS || 660 locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES || 661 lfs_subsys_pages > LFS_MAX_PAGES || 662 fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) || 663 lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) { 664 lfs_flush(fs, flags, 0); 665 } else if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) { 666 /* 667 * If we didn't flush the whole thing, some filesystems 668 * still might want to be flushed. 669 */ 670 ++fs->lfs_pdflush; 671 cv_broadcast(&lfs_writerd_cv); 672 } 673 674 while (locked_queue_count + INOCOUNT(fs) >= LFS_WAIT_BUFS || 675 locked_queue_bytes + INOBYTES(fs) >= LFS_WAIT_BYTES || 676 lfs_subsys_pages > LFS_WAIT_PAGES || 677 fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) || 678 lfs_dirvcount > LFS_MAX_DIROP) { 679 680 if (lfs_dostats) 681 ++lfs_stats.wait_exceeded; 682 DLOG((DLOG_AVAIL, "lfs_check: waiting: count=%d, bytes=%ld\n", 683 locked_queue_count, locked_queue_bytes)); 684 ++locked_queue_waiters; 685 error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock, 686 hz * LFS_BUFWAIT); 687 --locked_queue_waiters; 688 if (error != EWOULDBLOCK) 689 break; 690 691 /* 692 * lfs_flush might not flush all the buffers, if some of the 693 * inodes were locked or if most of them were Ifile blocks 694 * and we weren't asked to checkpoint. Try flushing again 695 * to keep us from blocking indefinitely. 696 */ 697 if (locked_queue_count + INOCOUNT(fs) >= LFS_MAX_BUFS || 698 locked_queue_bytes + INOBYTES(fs) >= LFS_MAX_BYTES) { 699 lfs_flush(fs, flags | SEGM_CKP, 0); 700 } 701 } 702 mutex_exit(&lfs_lock); 703 return (error); 704 } 705 706 /* 707 * Allocate a new buffer header. 708 */ 709 struct buf * 710 lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int type) 711 { 712 struct buf *bp; 713 size_t nbytes; 714 715 ASSERT_MAYBE_SEGLOCK(fs); 716 nbytes = roundup(size, lfs_fsbtob(fs, 1)); 717 718 bp = getiobuf(NULL, true); 719 if (nbytes) { 720 bp->b_data = lfs_malloc(fs, nbytes, type); 721 /* memset(bp->b_data, 0, nbytes); */ 722 } 723 KASSERT(vp != NULL); 724 KASSERT(bp != NULL); 725 726 bp->b_bufsize = size; 727 bp->b_bcount = size; 728 bp->b_lblkno = daddr; 729 bp->b_blkno = daddr; 730 bp->b_error = 0; 731 bp->b_resid = 0; 732 bp->b_iodone = lfs_callback; 733 bp->b_cflags = BC_BUSY | BC_NOCACHE; 734 bp->b_private = fs; 735 736 mutex_enter(&bufcache_lock); 737 mutex_enter(vp->v_interlock); 738 bgetvp(vp, bp); 739 mutex_exit(vp->v_interlock); 740 mutex_exit(&bufcache_lock); 741 742 return (bp); 743 } 744 745 void 746 lfs_freebuf(struct lfs *fs, struct buf *bp) 747 { 748 struct vnode *vp; 749 750 if ((vp = bp->b_vp) != NULL) { 751 mutex_enter(&bufcache_lock); 752 mutex_enter(vp->v_interlock); 753 brelvp(bp); 754 mutex_exit(vp->v_interlock); 755 mutex_exit(&bufcache_lock); 756 } 757 if (!(bp->b_cflags & BC_INVAL)) { /* BC_INVAL indicates a "fake" buffer */ 758 lfs_free(fs, bp->b_data, LFS_NB_UNKNOWN); 759 bp->b_data = NULL; 760 } 761 putiobuf(bp); 762 } 763 764 int 765 lfs_wait_pages(void) 766 { 767 int active, inactive; 768 769 uvm_estimatepageable(&active, &inactive); 770 return LFS_WAIT_RESOURCE(active + inactive + uvmexp.free, 1); 771 } 772 773 int 774 lfs_max_pages(void) 775 { 776 int active, inactive; 777 778 uvm_estimatepageable(&active, &inactive); 779 return LFS_MAX_RESOURCE(active + inactive + uvmexp.free, 1); 780 } 781