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