Home | History | Annotate | Line # | Download | only in lfs
lfs_bio.c revision 1.120.6.1
      1  1.120.6.1       mrg /*	$NetBSD: lfs_bio.c,v 1.120.6.1 2012/02/18 07:35:54 mrg 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.120.6.1       mrg __KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.120.6.1 2012/02/18 07:35:54 mrg 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.1   mycroft #include <ufs/ufs/inode.h>
     76        1.1   mycroft #include <ufs/ufs/ufsmount.h>
     77        1.5  christos #include <ufs/ufs/ufs_extern.h>
     78        1.1   mycroft 
     79        1.1   mycroft #include <ufs/lfs/lfs.h>
     80        1.1   mycroft #include <ufs/lfs/lfs_extern.h>
     81        1.1   mycroft 
     82       1.58  perseant #include <uvm/uvm.h>
     83       1.58  perseant 
     84        1.1   mycroft /*
     85        1.1   mycroft  * LFS block write function.
     86        1.1   mycroft  *
     87        1.1   mycroft  * XXX
     88        1.1   mycroft  * No write cost accounting is done.
     89        1.1   mycroft  * This is almost certainly wrong for synchronous operations and NFS.
     90       1.71      yamt  *
     91      1.107        ad  * protected by lfs_lock.
     92        1.1   mycroft  */
     93       1.58  perseant int	locked_queue_count   = 0;	/* Count of locked-down buffers. */
     94       1.58  perseant long	locked_queue_bytes   = 0L;	/* Total size of locked buffers. */
     95       1.61  perseant int	lfs_subsys_pages     = 0L;	/* Total number LFS-written pages */
     96       1.78  perseant int	lfs_fs_pagetrip	     = 0;	/* # of pages to trip per-fs write */
     97       1.61  perseant int	lfs_writing	     = 0;	/* Set if already kicked off a writer
     98        1.1   mycroft 					   because of buffer space */
     99  1.120.6.1       mrg int	locked_queue_waiters = 0;	/* Number of processes waiting on lq */
    100      1.107        ad 
    101      1.107        ad /* Lock and condition variables for above. */
    102      1.107        ad kcondvar_t	locked_queue_cv;
    103      1.107        ad kcondvar_t	lfs_writing_cv;
    104      1.107        ad kmutex_t	lfs_lock;
    105       1.64  perseant 
    106        1.7  perseant extern int lfs_dostats;
    107        1.7  perseant 
    108       1.27  perseant /*
    109       1.51      yamt  * reserved number/bytes of locked buffers
    110       1.51      yamt  */
    111       1.51      yamt int locked_queue_rcount = 0;
    112       1.51      yamt long locked_queue_rbytes = 0L;
    113       1.51      yamt 
    114      1.117   mlelstv static int lfs_fits_buf(struct lfs *, int, int);
    115      1.117   mlelstv static int lfs_reservebuf(struct lfs *, struct vnode *vp, struct vnode *vp2,
    116       1.52      yamt     int, int);
    117      1.117   mlelstv static int lfs_reserveavail(struct lfs *, struct vnode *vp, struct vnode *vp2,
    118      1.117   mlelstv     int);
    119       1.51      yamt 
    120      1.117   mlelstv static int
    121       1.51      yamt lfs_fits_buf(struct lfs *fs, int n, int bytes)
    122       1.51      yamt {
    123       1.71      yamt 	int count_fit, bytes_fit;
    124       1.71      yamt 
    125       1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    126      1.107        ad 	KASSERT(mutex_owned(&lfs_lock));
    127       1.71      yamt 
    128       1.71      yamt 	count_fit =
    129      1.117   mlelstv 	    (locked_queue_count + locked_queue_rcount + n <= LFS_WAIT_BUFS);
    130       1.71      yamt 	bytes_fit =
    131      1.117   mlelstv 	    (locked_queue_bytes + locked_queue_rbytes + bytes <= LFS_WAIT_BYTES);
    132       1.51      yamt 
    133       1.80  perseant #ifdef DEBUG
    134       1.51      yamt 	if (!count_fit) {
    135       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit count: %d + %d + %d >= %d\n",
    136       1.80  perseant 		      locked_queue_count, locked_queue_rcount,
    137       1.80  perseant 		      n, LFS_WAIT_BUFS));
    138       1.51      yamt 	}
    139       1.51      yamt 	if (!bytes_fit) {
    140       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit bytes: %ld + %ld + %d >= %ld\n",
    141       1.80  perseant 		      locked_queue_bytes, locked_queue_rbytes,
    142       1.80  perseant 		      bytes, LFS_WAIT_BYTES));
    143       1.51      yamt 	}
    144       1.80  perseant #endif /* DEBUG */
    145       1.51      yamt 
    146       1.51      yamt 	return (count_fit && bytes_fit);
    147       1.51      yamt }
    148       1.51      yamt 
    149       1.52      yamt /* ARGSUSED */
    150      1.117   mlelstv static int
    151       1.98  christos lfs_reservebuf(struct lfs *fs, struct vnode *vp,
    152       1.98  christos     struct vnode *vp2, int n, int bytes)
    153       1.51      yamt {
    154  1.120.6.1       mrg 	int cantwait;
    155  1.120.6.1       mrg 
    156       1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    157       1.51      yamt 	KASSERT(locked_queue_rcount >= 0);
    158       1.51      yamt 	KASSERT(locked_queue_rbytes >= 0);
    159       1.51      yamt 
    160  1.120.6.1       mrg 	cantwait = (VTOI(vp)->i_flag & IN_ADIROP) || fs->lfs_unlockvp == vp;
    161      1.107        ad 	mutex_enter(&lfs_lock);
    162  1.120.6.1       mrg 	while (!cantwait && n > 0 && !lfs_fits_buf(fs, n, bytes)) {
    163       1.51      yamt 		int error;
    164       1.51      yamt 
    165       1.78  perseant 		lfs_flush(fs, 0, 0);
    166       1.51      yamt 
    167  1.120.6.1       mrg 		DLOG((DLOG_AVAIL, "lfs_reservebuf: waiting: count=%d, bytes=%ld\n",
    168  1.120.6.1       mrg 		      locked_queue_count, locked_queue_bytes));
    169  1.120.6.1       mrg 		++locked_queue_waiters;
    170      1.107        ad 		error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock,
    171      1.107        ad 		    hz * LFS_BUFWAIT);
    172  1.120.6.1       mrg 		--locked_queue_waiters;
    173       1.71      yamt 		if (error && error != EWOULDBLOCK) {
    174      1.107        ad 			mutex_exit(&lfs_lock);
    175       1.51      yamt 			return error;
    176       1.71      yamt 		}
    177       1.51      yamt 	}
    178       1.51      yamt 
    179       1.51      yamt 	locked_queue_rcount += n;
    180       1.51      yamt 	locked_queue_rbytes += bytes;
    181       1.51      yamt 
    182  1.120.6.1       mrg 	if (n < 0 && locked_queue_waiters > 0) {
    183  1.120.6.1       mrg 		DLOG((DLOG_AVAIL, "lfs_reservebuf: broadcast: count=%d, bytes=%ld\n",
    184  1.120.6.1       mrg 		      locked_queue_count, locked_queue_bytes));
    185      1.117   mlelstv 		cv_broadcast(&locked_queue_cv);
    186  1.120.6.1       mrg 	}
    187      1.117   mlelstv 
    188      1.107        ad 	mutex_exit(&lfs_lock);
    189       1.71      yamt 
    190       1.51      yamt 	KASSERT(locked_queue_rcount >= 0);
    191       1.51      yamt 	KASSERT(locked_queue_rbytes >= 0);
    192       1.51      yamt 
    193       1.51      yamt 	return 0;
    194       1.51      yamt }
    195       1.51      yamt 
    196       1.51      yamt /*
    197       1.27  perseant  * Try to reserve some blocks, prior to performing a sensitive operation that
    198       1.27  perseant  * requires the vnode lock to be honored.  If there is not enough space, give
    199       1.27  perseant  * up the vnode lock temporarily and wait for the space to become available.
    200       1.27  perseant  *
    201       1.44  perseant  * Called with vp locked.  (Note nowever that if fsb < 0, vp is ignored.)
    202       1.46      yamt  *
    203       1.47      yamt  * XXX YAMT - it isn't safe to unlock vp here
    204       1.47      yamt  * because the node might be modified while we sleep.
    205       1.47      yamt  * (eg. cached states like i_offset might be stale,
    206       1.47      yamt  *  the vnode might be truncated, etc..)
    207       1.55      yamt  * maybe we should have a way to restart the vnodeop (EVOPRESTART?)
    208       1.55      yamt  * or rearrange vnodeop interface to leave vnode locking to file system
    209       1.55      yamt  * specific code so that each file systems can have their own vnode locking and
    210       1.55      yamt  * vnode re-using strategies.
    211       1.27  perseant  */
    212      1.117   mlelstv static int
    213       1.98  christos lfs_reserveavail(struct lfs *fs, struct vnode *vp,
    214       1.98  christos     struct vnode *vp2, int fsb)
    215       1.27  perseant {
    216       1.27  perseant 	CLEANERINFO *cip;
    217       1.27  perseant 	struct buf *bp;
    218       1.27  perseant 	int error, slept;
    219  1.120.6.1       mrg 	int cantwait;
    220       1.27  perseant 
    221       1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    222       1.27  perseant 	slept = 0;
    223      1.107        ad 	mutex_enter(&lfs_lock);
    224  1.120.6.1       mrg 	cantwait = (VTOI(vp)->i_flag & IN_ADIROP) || fs->lfs_unlockvp == vp;
    225  1.120.6.1       mrg 	while (!cantwait && fsb > 0 &&
    226  1.120.6.1       mrg 	       !lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) {
    227      1.107        ad 		mutex_exit(&lfs_lock);
    228       1.27  perseant 
    229       1.30  perseant 		if (!slept) {
    230       1.80  perseant 			DLOG((DLOG_AVAIL, "lfs_reserve: waiting for %ld (bfree = %d,"
    231       1.80  perseant 			      " est_bfree = %d)\n",
    232       1.80  perseant 			      fsb + fs->lfs_ravail + fs->lfs_favail,
    233       1.80  perseant 			      fs->lfs_bfree, LFS_EST_BFREE(fs)));
    234       1.80  perseant 		}
    235       1.27  perseant 		++slept;
    236       1.27  perseant 
    237       1.27  perseant 		/* Wake up the cleaner */
    238       1.27  perseant 		LFS_CLEANERINFO(cip, fs, bp);
    239       1.31  perseant 		LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);
    240       1.94  perseant 		lfs_wakeup_cleaner(fs);
    241       1.79     perry 
    242      1.107        ad 		mutex_enter(&lfs_lock);
    243       1.82  perseant 		/* Cleaner might have run while we were reading, check again */
    244       1.82  perseant 		if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail))
    245       1.82  perseant 			break;
    246       1.82  perseant 
    247      1.107        ad 		error = mtsleep(&fs->lfs_avail, PCATCH | PUSER, "lfs_reserve",
    248      1.107        ad 				0, &lfs_lock);
    249       1.91  perseant 		if (error) {
    250      1.107        ad 			mutex_exit(&lfs_lock);
    251       1.27  perseant 			return error;
    252       1.91  perseant 		}
    253       1.27  perseant 	}
    254       1.80  perseant #ifdef DEBUG
    255       1.80  perseant 	if (slept) {
    256       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_reserve: woke up\n"));
    257       1.80  perseant 	}
    258       1.44  perseant #endif
    259       1.44  perseant 	fs->lfs_ravail += fsb;
    260      1.107        ad 	mutex_exit(&lfs_lock);
    261       1.51      yamt 
    262       1.27  perseant 	return 0;
    263       1.27  perseant }
    264       1.27  perseant 
    265       1.51      yamt #ifdef DIAGNOSTIC
    266       1.51      yamt int lfs_rescount;
    267       1.51      yamt int lfs_rescountdirop;
    268       1.51      yamt #endif
    269       1.51      yamt 
    270       1.51      yamt int
    271       1.52      yamt lfs_reserve(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb)
    272       1.51      yamt {
    273       1.51      yamt 	int error;
    274       1.51      yamt 
    275       1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    276       1.82  perseant 	if (vp2) {
    277       1.82  perseant 		/* Make sure we're not in the process of reclaiming vp2 */
    278      1.107        ad 		mutex_enter(&lfs_lock);
    279       1.82  perseant 		while(fs->lfs_flags & LFS_UNDIROP) {
    280      1.107        ad 			mtsleep(&fs->lfs_flags, PRIBIO + 1, "lfsrundirop", 0,
    281      1.107        ad 			    &lfs_lock);
    282       1.82  perseant 		}
    283      1.107        ad 		mutex_exit(&lfs_lock);
    284       1.82  perseant 	}
    285       1.82  perseant 
    286       1.52      yamt 	KASSERT(fsb < 0 || VOP_ISLOCKED(vp));
    287       1.52      yamt 	KASSERT(vp2 == NULL || fsb < 0 || VOP_ISLOCKED(vp2));
    288       1.55      yamt 	KASSERT(vp2 == NULL || vp2 != fs->lfs_unlockvp);
    289       1.52      yamt 
    290       1.51      yamt #ifdef DIAGNOSTIC
    291  1.120.6.1       mrg 	mutex_enter(&lfs_lock);
    292  1.120.6.1       mrg 	if (fsb > 0)
    293  1.120.6.1       mrg 		lfs_rescount++;
    294  1.120.6.1       mrg 	else if (fsb < 0)
    295  1.120.6.1       mrg 		lfs_rescount--;
    296  1.120.6.1       mrg 	if (lfs_rescount < 0)
    297  1.120.6.1       mrg 		panic("lfs_rescount");
    298  1.120.6.1       mrg 	mutex_exit(&lfs_lock);
    299       1.51      yamt #endif
    300       1.53      yamt 
    301       1.53      yamt 	/*
    302       1.53      yamt 	 * XXX
    303       1.53      yamt 	 * vref vnodes here so that cleaner doesn't try to reuse them.
    304       1.55      yamt 	 * (see XXX comment in lfs_reserveavail)
    305       1.53      yamt 	 */
    306      1.116     pooka 	vhold(vp);
    307       1.53      yamt 	if (vp2 != NULL) {
    308      1.116     pooka 		vhold(vp2);
    309       1.53      yamt 	}
    310       1.51      yamt 
    311       1.52      yamt 	error = lfs_reserveavail(fs, vp, vp2, fsb);
    312       1.51      yamt 	if (error)
    313       1.52      yamt 		goto done;
    314       1.51      yamt 
    315       1.51      yamt 	/*
    316       1.51      yamt 	 * XXX just a guess. should be more precise.
    317       1.51      yamt 	 */
    318      1.117   mlelstv 	error = lfs_reservebuf(fs, vp, vp2, fsb, fsbtob(fs, fsb));
    319       1.51      yamt 	if (error)
    320       1.52      yamt 		lfs_reserveavail(fs, vp, vp2, -fsb);
    321       1.52      yamt 
    322       1.52      yamt done:
    323      1.116     pooka 	holdrele(vp);
    324       1.52      yamt 	if (vp2 != NULL) {
    325      1.116     pooka 		holdrele(vp2);
    326       1.52      yamt 	}
    327       1.51      yamt 
    328       1.51      yamt 	return error;
    329       1.51      yamt }
    330        1.1   mycroft 
    331        1.1   mycroft int
    332       1.36  perseant lfs_bwrite(void *v)
    333        1.5  christos {
    334        1.1   mycroft 	struct vop_bwrite_args /* {
    335      1.120   hannken 		struct vnode *a_vp;
    336        1.1   mycroft 		struct buf *a_bp;
    337        1.5  christos 	} */ *ap = v;
    338       1.17  augustss 	struct buf *bp = ap->a_bp;
    339        1.7  perseant 
    340        1.7  perseant #ifdef DIAGNOSTIC
    341       1.61  perseant 	if (VTOI(bp->b_vp)->i_lfs->lfs_ronly == 0 && (bp->b_flags & B_ASYNC)) {
    342        1.7  perseant 		panic("bawrite LFS buffer");
    343       1.16  perseant 	}
    344        1.7  perseant #endif /* DIAGNOSTIC */
    345       1.85  perseant 	return lfs_bwrite_ext(bp, 0);
    346        1.7  perseant }
    347        1.7  perseant 
    348       1.79     perry /*
    349       1.44  perseant  * Determine if there is enough room currently available to write fsb
    350       1.44  perseant  * blocks.  We need enough blocks for the new blocks, the current
    351       1.44  perseant  * inode blocks (including potentially the ifile inode), a summary block,
    352       1.44  perseant  * and the segment usage table, plus an ifile block.
    353        1.7  perseant  */
    354       1.32  perseant int
    355       1.36  perseant lfs_fits(struct lfs *fs, int fsb)
    356        1.7  perseant {
    357       1.26  perseant 	int needed;
    358       1.26  perseant 
    359       1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    360       1.36  perseant 	needed = fsb + btofsb(fs, fs->lfs_sumsize) +
    361       1.44  perseant 		 ((howmany(fs->lfs_uinodes + 1, INOPB(fs)) + fs->lfs_segtabsz +
    362      1.117   mlelstv 		   1) << (fs->lfs_bshift - fs->lfs_ffshift));
    363       1.27  perseant 
    364       1.26  perseant 	if (needed >= fs->lfs_avail) {
    365       1.80  perseant #ifdef DEBUG
    366       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits: no fit: fsb = %ld, uinodes = %ld, "
    367       1.80  perseant 		      "needed = %ld, avail = %ld\n",
    368       1.80  perseant 		      (long)fsb, (long)fs->lfs_uinodes, (long)needed,
    369       1.80  perseant 		      (long)fs->lfs_avail));
    370       1.26  perseant #endif
    371        1.7  perseant 		return 0;
    372        1.7  perseant 	}
    373        1.7  perseant 	return 1;
    374        1.7  perseant }
    375        1.7  perseant 
    376        1.7  perseant int
    377       1.44  perseant lfs_availwait(struct lfs *fs, int fsb)
    378       1.32  perseant {
    379       1.32  perseant 	int error;
    380       1.32  perseant 	CLEANERINFO *cip;
    381       1.32  perseant 	struct buf *cbp;
    382       1.63  perseant 
    383       1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    384       1.63  perseant 	/* Push cleaner blocks through regardless */
    385      1.107        ad 	mutex_enter(&lfs_lock);
    386       1.82  perseant 	if (LFS_SEGLOCK_HELD(fs) &&
    387       1.64  perseant 	    fs->lfs_sp->seg_flags & (SEGM_CLEAN | SEGM_FORCE_CKP)) {
    388      1.107        ad 		mutex_exit(&lfs_lock);
    389       1.63  perseant 		return 0;
    390       1.64  perseant 	}
    391      1.107        ad 	mutex_exit(&lfs_lock);
    392       1.32  perseant 
    393       1.44  perseant 	while (!lfs_fits(fs, fsb)) {
    394       1.32  perseant 		/*
    395       1.32  perseant 		 * Out of space, need cleaner to run.
    396       1.32  perseant 		 * Update the cleaner info, then wake it up.
    397       1.32  perseant 		 * Note the cleanerinfo block is on the ifile
    398       1.32  perseant 		 * so it CANT_WAIT.
    399       1.32  perseant 		 */
    400       1.32  perseant 		LFS_CLEANERINFO(cip, fs, cbp);
    401       1.32  perseant 		LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);
    402       1.79     perry 
    403       1.80  perseant #ifdef DEBUG
    404       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_availwait: out of available space, "
    405       1.80  perseant 		      "waiting on cleaner\n"));
    406       1.78  perseant #endif
    407       1.79     perry 
    408       1.94  perseant 		lfs_wakeup_cleaner(fs);
    409       1.32  perseant #ifdef DIAGNOSTIC
    410       1.82  perseant 		if (LFS_SEGLOCK_HELD(fs))
    411       1.32  perseant 			panic("lfs_availwait: deadlock");
    412       1.32  perseant #endif
    413       1.32  perseant 		error = tsleep(&fs->lfs_avail, PCATCH | PUSER, "cleaner", 0);
    414       1.32  perseant 		if (error)
    415       1.32  perseant 			return (error);
    416       1.32  perseant 	}
    417       1.32  perseant 	return 0;
    418       1.32  perseant }
    419       1.32  perseant 
    420       1.32  perseant int
    421       1.36  perseant lfs_bwrite_ext(struct buf *bp, int flags)
    422        1.7  perseant {
    423        1.1   mycroft 	struct lfs *fs;
    424        1.1   mycroft 	struct inode *ip;
    425      1.107        ad 	struct vnode *vp;
    426      1.107        ad 	int fsb;
    427       1.48      yamt 
    428      1.107        ad 	vp = bp->b_vp;
    429      1.107        ad 	fs = VFSTOUFS(vp->v_mount)->um_lfs;
    430       1.85  perseant 
    431       1.85  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    432      1.107        ad 	KASSERT(bp->b_cflags & BC_BUSY);
    433       1.58  perseant 	KASSERT(flags & BW_CLEAN || !LFS_IS_MALLOC_BUF(bp));
    434      1.109        ad 	KASSERT(((bp->b_oflags | bp->b_flags) & (BO_DELWRI|B_LOCKED))
    435      1.107        ad 	    != BO_DELWRI);
    436       1.48      yamt 
    437        1.1   mycroft 	/*
    438       1.85  perseant 	 * Don't write *any* blocks if we're mounted read-only, or
    439       1.85  perseant 	 * if we are "already unmounted".
    440       1.85  perseant 	 *
    441       1.16  perseant 	 * In particular the cleaner can't write blocks either.
    442       1.16  perseant 	 */
    443       1.85  perseant 	if (fs->lfs_ronly || (fs->lfs_pflags & LFS_PF_CLEAN)) {
    444      1.107        ad 		bp->b_oflags &= ~BO_DELWRI;
    445  1.120.6.1       mrg 		bp->b_flags |= B_READ; /* XXX is this right? --ks */
    446      1.103        ad 		bp->b_error = 0;
    447      1.107        ad 		mutex_enter(&bufcache_lock);
    448       1.32  perseant 		LFS_UNLOCK_BUF(bp);
    449       1.58  perseant 		if (LFS_IS_MALLOC_BUF(bp))
    450      1.107        ad 			bp->b_cflags &= ~BC_BUSY;
    451       1.16  perseant 		else
    452      1.107        ad 			brelsel(bp, 0);
    453      1.107        ad 		mutex_exit(&bufcache_lock);
    454       1.85  perseant 		return (fs->lfs_ronly ? EROFS : 0);
    455       1.16  perseant 	}
    456       1.16  perseant 
    457       1.16  perseant 	/*
    458        1.1   mycroft 	 * Set the delayed write flag and use reassignbuf to move the buffer
    459        1.1   mycroft 	 * from the clean list to the dirty one.
    460        1.1   mycroft 	 *
    461      1.109        ad 	 * Set the B_LOCKED flag and unlock the buffer, causing brelse to move
    462        1.1   mycroft 	 * the buffer onto the LOCKED free list.  This is necessary, otherwise
    463        1.1   mycroft 	 * getnewbuf() would try to reclaim the buffers using bawrite, which
    464        1.1   mycroft 	 * isn't going to work.
    465        1.1   mycroft 	 *
    466        1.1   mycroft 	 * XXX we don't let meta-data writes run out of space because they can
    467        1.1   mycroft 	 * come from the segment writer.  We need to make sure that there is
    468        1.1   mycroft 	 * enough space reserved so that there's room to write meta-data
    469        1.1   mycroft 	 * blocks.
    470        1.1   mycroft 	 */
    471      1.109        ad 	if ((bp->b_flags & B_LOCKED) == 0) {
    472      1.117   mlelstv 		fsb = numfrags(fs, bp->b_bcount);
    473       1.79     perry 
    474      1.107        ad 		ip = VTOI(vp);
    475      1.107        ad 		mutex_enter(&lfs_lock);
    476       1.48      yamt 		if (flags & BW_CLEAN) {
    477       1.26  perseant 			LFS_SET_UINO(ip, IN_CLEANING);
    478        1.7  perseant 		} else {
    479       1.36  perseant 			LFS_SET_UINO(ip, IN_MODIFIED);
    480        1.7  perseant 		}
    481      1.107        ad 		mutex_exit(&lfs_lock);
    482       1.36  perseant 		fs->lfs_avail -= fsb;
    483       1.32  perseant 
    484      1.107        ad 		mutex_enter(&bufcache_lock);
    485      1.119     rmind 		mutex_enter(vp->v_interlock);
    486      1.107        ad 		bp->b_oflags = (bp->b_oflags | BO_DELWRI) & ~BO_DONE;
    487       1.32  perseant 		LFS_LOCK_BUF(bp);
    488      1.107        ad 		bp->b_flags &= ~B_READ;
    489      1.103        ad 		bp->b_error = 0;
    490        1.1   mycroft 		reassignbuf(bp, bp->b_vp);
    491      1.119     rmind 		mutex_exit(vp->v_interlock);
    492      1.107        ad 	} else {
    493      1.107        ad 		mutex_enter(&bufcache_lock);
    494        1.1   mycroft 	}
    495       1.79     perry 
    496      1.107        ad 	if (bp->b_iodone != NULL)
    497      1.107        ad 		bp->b_cflags &= ~BC_BUSY;
    498        1.7  perseant 	else
    499      1.107        ad 		brelsel(bp, 0);
    500      1.107        ad 	mutex_exit(&bufcache_lock);
    501       1.79     perry 
    502        1.1   mycroft 	return (0);
    503        1.1   mycroft }
    504        1.1   mycroft 
    505       1.82  perseant /*
    506      1.107        ad  * Called and return with the lfs_lock held.
    507       1.82  perseant  */
    508       1.24  perseant void
    509       1.36  perseant lfs_flush_fs(struct lfs *fs, int flags)
    510       1.11  perseant {
    511       1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    512      1.107        ad 	KASSERT(mutex_owned(&lfs_lock));
    513       1.58  perseant 	if (fs->lfs_ronly)
    514       1.58  perseant 		return;
    515       1.11  perseant 
    516       1.82  perseant 	if (lfs_dostats)
    517       1.82  perseant 		++lfs_stats.flush_invoked;
    518       1.78  perseant 
    519  1.120.6.1       mrg 	fs->lfs_pdflush = 0;
    520      1.107        ad 	mutex_exit(&lfs_lock);
    521       1.67      yamt 	lfs_writer_enter(fs, "fldirop");
    522       1.58  perseant 	lfs_segwrite(fs->lfs_ivnode->v_mount, flags);
    523       1.82  perseant 	lfs_writer_leave(fs);
    524      1.107        ad 	mutex_enter(&lfs_lock);
    525       1.78  perseant 	fs->lfs_favail = 0; /* XXX */
    526       1.11  perseant }
    527       1.11  perseant 
    528        1.1   mycroft /*
    529       1.81  perseant  * This routine initiates segment writes when LFS is consuming too many
    530       1.81  perseant  * resources.  Ideally the pageout daemon would be able to direct LFS
    531       1.81  perseant  * more subtly.
    532       1.81  perseant  * XXX We have one static count of locked buffers;
    533       1.81  perseant  * XXX need to think more about the multiple filesystem case.
    534       1.71      yamt  *
    535      1.107        ad  * Called and return with lfs_lock held.
    536       1.83  perseant  * If fs != NULL, we hold the segment lock for fs.
    537        1.1   mycroft  */
    538        1.1   mycroft void
    539       1.78  perseant lfs_flush(struct lfs *fs, int flags, int only_onefs)
    540        1.1   mycroft {
    541       1.78  perseant 	extern u_int64_t locked_fakequeue_count;
    542       1.17  augustss 	struct mount *mp, *nmp;
    543       1.83  perseant 	struct lfs *tfs;
    544       1.67      yamt 
    545      1.107        ad 	KASSERT(mutex_owned(&lfs_lock));
    546       1.67      yamt 	KDASSERT(fs == NULL || !LFS_SEGLOCK_HELD(fs));
    547       1.79     perry 
    548       1.79     perry 	if (lfs_dostats)
    549        1.7  perseant 		++lfs_stats.write_exceeded;
    550       1.81  perseant 	/* XXX should we include SEGM_CKP here? */
    551       1.84  perseant 	if (lfs_writing && !(flags & SEGM_SYNC)) {
    552       1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_flush: not flushing because another flush is active\n"));
    553        1.1   mycroft 		return;
    554       1.16  perseant 	}
    555       1.81  perseant 	while (lfs_writing)
    556      1.107        ad 		cv_wait(&lfs_writing_cv, &lfs_lock);
    557        1.1   mycroft 	lfs_writing = 1;
    558       1.79     perry 
    559      1.107        ad 	mutex_exit(&lfs_lock);
    560       1.58  perseant 
    561       1.78  perseant 	if (only_onefs) {
    562       1.83  perseant 		KASSERT(fs != NULL);
    563      1.114        ad 		if (vfs_busy(fs->lfs_ivnode->v_mount, NULL))
    564       1.78  perseant 			goto errout;
    565      1.107        ad 		mutex_enter(&lfs_lock);
    566       1.78  perseant 		lfs_flush_fs(fs, flags);
    567      1.107        ad 		mutex_exit(&lfs_lock);
    568      1.113        ad 		vfs_unbusy(fs->lfs_ivnode->v_mount, false, NULL);
    569       1.78  perseant 	} else {
    570       1.78  perseant 		locked_fakequeue_count = 0;
    571      1.105        ad 		mutex_enter(&mountlist_lock);
    572       1.78  perseant 		for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist;
    573       1.78  perseant 		     mp = nmp) {
    574      1.114        ad 			if (vfs_busy(mp, &nmp)) {
    575       1.80  perseant 				DLOG((DLOG_FLUSH, "lfs_flush: fs vfs_busy\n"));
    576       1.78  perseant 				continue;
    577       1.78  perseant 			}
    578      1.107        ad 			if (strncmp(&mp->mnt_stat.f_fstypename[0], MOUNT_LFS,
    579      1.102  christos 			    sizeof(mp->mnt_stat.f_fstypename)) == 0) {
    580       1.83  perseant 				tfs = VFSTOUFS(mp)->um_lfs;
    581      1.107        ad 				mutex_enter(&lfs_lock);
    582       1.83  perseant 				lfs_flush_fs(tfs, flags);
    583      1.107        ad 				mutex_exit(&lfs_lock);
    584       1.83  perseant 			}
    585      1.113        ad 			vfs_unbusy(mp, false, &nmp);
    586        1.6      fvdl 		}
    587      1.105        ad 		mutex_exit(&mountlist_lock);
    588        1.1   mycroft 	}
    589       1.43  perseant 	LFS_DEBUG_COUNTLOCKED("flush");
    590       1.78  perseant 	wakeup(&lfs_subsys_pages);
    591        1.7  perseant 
    592       1.78  perseant     errout:
    593      1.107        ad 	mutex_enter(&lfs_lock);
    594       1.71      yamt 	KASSERT(lfs_writing);
    595        1.1   mycroft 	lfs_writing = 0;
    596       1.60      yamt 	wakeup(&lfs_writing);
    597        1.1   mycroft }
    598        1.1   mycroft 
    599       1.41  perseant #define INOCOUNT(fs) howmany((fs)->lfs_uinodes, INOPB(fs))
    600       1.65      fvdl #define INOBYTES(fs) ((fs)->lfs_uinodes * sizeof (struct ufs1_dinode))
    601       1.41  perseant 
    602       1.70      yamt /*
    603       1.70      yamt  * make sure that we don't have too many locked buffers.
    604       1.70      yamt  * flush buffers if needed.
    605       1.70      yamt  */
    606        1.1   mycroft int
    607       1.98  christos lfs_check(struct vnode *vp, daddr_t blkno, int flags)
    608        1.1   mycroft {
    609        1.1   mycroft 	int error;
    610       1.10  perseant 	struct lfs *fs;
    611       1.20  perseant 	struct inode *ip;
    612       1.78  perseant 	extern pid_t lfs_writer_daemon;
    613       1.10  perseant 
    614        1.1   mycroft 	error = 0;
    615       1.20  perseant 	ip = VTOI(vp);
    616       1.79     perry 
    617        1.7  perseant 	/* If out of buffers, wait on writer */
    618        1.7  perseant 	/* XXX KS - if it's the Ifile, we're probably the cleaner! */
    619       1.20  perseant 	if (ip->i_number == LFS_IFILE_INUM)
    620       1.20  perseant 		return 0;
    621       1.20  perseant 	/* If we're being called from inside a dirop, don't sleep */
    622       1.20  perseant 	if (ip->i_flag & IN_ADIROP)
    623        1.7  perseant 		return 0;
    624        1.7  perseant 
    625       1.20  perseant 	fs = ip->i_lfs;
    626       1.20  perseant 
    627       1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    628       1.82  perseant 
    629       1.20  perseant 	/*
    630       1.20  perseant 	 * If we would flush below, but dirops are active, sleep.
    631       1.20  perseant 	 * Note that a dirop cannot ever reach this code!
    632       1.20  perseant 	 */
    633      1.107        ad 	mutex_enter(&lfs_lock);
    634       1.20  perseant 	while (fs->lfs_dirops > 0 &&
    635       1.41  perseant 	       (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
    636       1.61  perseant 		locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
    637       1.58  perseant 		lfs_subsys_pages > LFS_MAX_PAGES ||
    638       1.92  perseant 		fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
    639       1.61  perseant 		lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0))
    640       1.20  perseant 	{
    641       1.20  perseant 		++fs->lfs_diropwait;
    642      1.107        ad 		mtsleep(&fs->lfs_writer, PRIBIO+1, "bufdirop", 0,
    643      1.107        ad 			&lfs_lock);
    644       1.20  perseant 		--fs->lfs_diropwait;
    645       1.20  perseant 	}
    646       1.10  perseant 
    647       1.80  perseant #ifdef DEBUG
    648       1.58  perseant 	if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS)
    649       1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lqc = %d, max %d\n",
    650       1.80  perseant 		      locked_queue_count + INOCOUNT(fs), LFS_MAX_BUFS));
    651       1.58  perseant 	if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES)
    652       1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lqb = %ld, max %ld\n",
    653       1.80  perseant 		      locked_queue_bytes + INOBYTES(fs), LFS_MAX_BYTES));
    654       1.58  perseant 	if (lfs_subsys_pages > LFS_MAX_PAGES)
    655       1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lssp = %d, max %d\n",
    656       1.82  perseant 		      lfs_subsys_pages, LFS_MAX_PAGES));
    657       1.78  perseant 	if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip)
    658       1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: fssp = %d, trip at %d\n",
    659       1.82  perseant 		      fs->lfs_pages, lfs_fs_pagetrip));
    660       1.58  perseant 	if (lfs_dirvcount > LFS_MAX_DIROP)
    661       1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: ldvc = %d, max %d\n",
    662       1.82  perseant 		      lfs_dirvcount, LFS_MAX_DIROP));
    663       1.92  perseant 	if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs))
    664       1.92  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lfdvc = %d, max %d\n",
    665       1.92  perseant 		      fs->lfs_dirvcount, LFS_MAX_FSDIROP(fs)));
    666       1.58  perseant 	if (fs->lfs_diropwait > 0)
    667       1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: ldvw = %d\n",
    668       1.82  perseant 		      fs->lfs_diropwait));
    669       1.58  perseant #endif
    670       1.64  perseant 
    671       1.99  perseant 	/* If there are too many pending dirops, we have to flush them. */
    672       1.99  perseant 	if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
    673       1.99  perseant 	    lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {
    674  1.120.6.1       mrg 		mutex_exit(&lfs_lock);
    675  1.120.6.1       mrg 		lfs_flush_dirops(fs);
    676  1.120.6.1       mrg 		mutex_enter(&lfs_lock);
    677  1.120.6.1       mrg 	} else if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
    678       1.41  perseant 	    locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
    679       1.58  perseant 	    lfs_subsys_pages > LFS_MAX_PAGES ||
    680       1.92  perseant 	    fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
    681       1.71      yamt 	    lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {
    682       1.78  perseant 		lfs_flush(fs, flags, 0);
    683       1.80  perseant 	} else if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) {
    684       1.80  perseant 		/*
    685       1.80  perseant 		 * If we didn't flush the whole thing, some filesystems
    686       1.80  perseant 		 * still might want to be flushed.
    687       1.80  perseant 		 */
    688       1.78  perseant 		++fs->lfs_pdflush;
    689       1.78  perseant 		wakeup(&lfs_writer_daemon);
    690      1.107        ad 	}
    691       1.11  perseant 
    692      1.117   mlelstv 	while (locked_queue_count + INOCOUNT(fs) >= LFS_WAIT_BUFS ||
    693      1.117   mlelstv 		locked_queue_bytes + INOBYTES(fs) >= LFS_WAIT_BYTES ||
    694       1.58  perseant 		lfs_subsys_pages > LFS_WAIT_PAGES ||
    695       1.92  perseant 		fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
    696       1.71      yamt 		lfs_dirvcount > LFS_MAX_DIROP) {
    697       1.82  perseant 
    698       1.40       chs 		if (lfs_dostats)
    699        1.7  perseant 			++lfs_stats.wait_exceeded;
    700       1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_check: waiting: count=%d, bytes=%ld\n",
    701       1.80  perseant 		      locked_queue_count, locked_queue_bytes));
    702  1.120.6.1       mrg 		++locked_queue_waiters;
    703      1.107        ad 		error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock,
    704      1.107        ad 		    hz * LFS_BUFWAIT);
    705  1.120.6.1       mrg 		--locked_queue_waiters;
    706       1.82  perseant 		if (error != EWOULDBLOCK)
    707       1.33  perseant 			break;
    708       1.82  perseant 
    709       1.18  perseant 		/*
    710       1.18  perseant 		 * lfs_flush might not flush all the buffers, if some of the
    711       1.33  perseant 		 * inodes were locked or if most of them were Ifile blocks
    712       1.61  perseant 		 * and we weren't asked to checkpoint.	Try flushing again
    713       1.33  perseant 		 * to keep us from blocking indefinitely.
    714       1.18  perseant 		 */
    715      1.117   mlelstv 		if (locked_queue_count + INOCOUNT(fs) >= LFS_MAX_BUFS ||
    716      1.117   mlelstv 		    locked_queue_bytes + INOBYTES(fs) >= LFS_MAX_BYTES) {
    717       1.78  perseant 			lfs_flush(fs, flags | SEGM_CKP, 0);
    718       1.18  perseant 		}
    719        1.7  perseant 	}
    720      1.107        ad 	mutex_exit(&lfs_lock);
    721        1.7  perseant 	return (error);
    722        1.7  perseant }
    723        1.1   mycroft 
    724        1.7  perseant /*
    725        1.7  perseant  * Allocate a new buffer header.
    726        1.7  perseant  */
    727       1.34  perseant struct buf *
    728       1.58  perseant lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int type)
    729        1.7  perseant {
    730        1.7  perseant 	struct buf *bp;
    731        1.7  perseant 	size_t nbytes;
    732       1.79     perry 
    733       1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    734       1.36  perseant 	nbytes = roundup(size, fsbtob(fs, 1));
    735       1.79     perry 
    736      1.107        ad 	bp = getiobuf(NULL, true);
    737       1.43  perseant 	if (nbytes) {
    738       1.58  perseant 		bp->b_data = lfs_malloc(fs, nbytes, type);
    739       1.58  perseant 		/* memset(bp->b_data, 0, nbytes); */
    740        1.7  perseant 	}
    741       1.79     perry #ifdef DIAGNOSTIC
    742       1.40       chs 	if (vp == NULL)
    743        1.7  perseant 		panic("vp is NULL in lfs_newbuf");
    744       1.40       chs 	if (bp == NULL)
    745        1.7  perseant 		panic("bp is NULL after malloc in lfs_newbuf");
    746        1.1   mycroft #endif
    747       1.57        pk 
    748        1.7  perseant 	bp->b_bufsize = size;
    749        1.7  perseant 	bp->b_bcount = size;
    750        1.7  perseant 	bp->b_lblkno = daddr;
    751        1.7  perseant 	bp->b_blkno = daddr;
    752        1.7  perseant 	bp->b_error = 0;
    753        1.7  perseant 	bp->b_resid = 0;
    754        1.7  perseant 	bp->b_iodone = lfs_callback;
    755      1.107        ad 	bp->b_cflags = BC_BUSY | BC_NOCACHE;
    756       1.76      yamt 	bp->b_private = fs;
    757       1.79     perry 
    758      1.107        ad 	mutex_enter(&bufcache_lock);
    759      1.119     rmind 	mutex_enter(vp->v_interlock);
    760      1.107        ad 	bgetvp(vp, bp);
    761      1.119     rmind 	mutex_exit(vp->v_interlock);
    762      1.107        ad 	mutex_exit(&bufcache_lock);
    763      1.107        ad 
    764        1.7  perseant 	return (bp);
    765        1.7  perseant }
    766        1.7  perseant 
    767        1.7  perseant void
    768       1.58  perseant lfs_freebuf(struct lfs *fs, struct buf *bp)
    769        1.7  perseant {
    770      1.107        ad 	struct vnode *vp;
    771       1.79     perry 
    772      1.107        ad 	if ((vp = bp->b_vp) != NULL) {
    773      1.107        ad 		mutex_enter(&bufcache_lock);
    774      1.119     rmind 		mutex_enter(vp->v_interlock);
    775        1.7  perseant 		brelvp(bp);
    776      1.119     rmind 		mutex_exit(vp->v_interlock);
    777      1.107        ad 		mutex_exit(&bufcache_lock);
    778      1.107        ad 	}
    779      1.107        ad 	if (!(bp->b_cflags & BC_INVAL)) { /* BC_INVAL indicates a "fake" buffer */
    780       1.58  perseant 		lfs_free(fs, bp->b_data, LFS_NB_UNKNOWN);
    781        1.7  perseant 		bp->b_data = NULL;
    782        1.1   mycroft 	}
    783       1.88      yamt 	putiobuf(bp);
    784        1.7  perseant }
    785        1.1   mycroft 
    786        1.7  perseant /*
    787       1.80  perseant  * Count buffers on the "locked" queue, and compare it to a pro-forma count.
    788       1.27  perseant  * Don't count malloced buffers, since they don't detract from the total.
    789        1.7  perseant  */
    790        1.7  perseant void
    791       1.98  christos lfs_countlocked(int *count, long *bytes, const char *msg)
    792        1.7  perseant {
    793       1.17  augustss 	struct buf *bp;
    794       1.17  augustss 	int n = 0;
    795       1.17  augustss 	long int size = 0L;
    796        1.7  perseant 
    797      1.107        ad 	mutex_enter(&bufcache_lock);
    798      1.110      matt 	TAILQ_FOREACH(bp, &bufqueues[BQ_LOCKED].bq_queue, b_freelist) {
    799      1.107        ad 		KASSERT(bp->b_iodone == NULL);
    800        1.7  perseant 		n++;
    801        1.7  perseant 		size += bp->b_bufsize;
    802       1.80  perseant #ifdef DIAGNOSTIC
    803       1.27  perseant 		if (n > nbuf)
    804       1.27  perseant 			panic("lfs_countlocked: this can't happen: more"
    805       1.27  perseant 			      " buffers locked than exist");
    806       1.27  perseant #endif
    807        1.7  perseant 	}
    808       1.80  perseant 	/*
    809       1.80  perseant 	 * Theoretically this function never really does anything.
    810       1.80  perseant 	 * Give a warning if we have to fix the accounting.
    811       1.80  perseant 	 */
    812       1.96  christos 	if (n != *count) {
    813       1.80  perseant 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted buf count"
    814       1.80  perseant 		      " from %d to %d\n", msg, *count, n));
    815       1.96  christos 	}
    816       1.96  christos 	if (size != *bytes) {
    817       1.80  perseant 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted byte count"
    818       1.80  perseant 		      " from %ld to %ld\n", msg, *bytes, size));
    819       1.96  christos 	}
    820        1.7  perseant 	*count = n;
    821        1.7  perseant 	*bytes = size;
    822      1.107        ad 	mutex_exit(&bufcache_lock);
    823        1.7  perseant 	return;
    824        1.1   mycroft }
    825       1.95      yamt 
    826       1.95      yamt int
    827       1.95      yamt lfs_wait_pages(void)
    828       1.95      yamt {
    829       1.95      yamt 	int active, inactive;
    830       1.95      yamt 
    831       1.95      yamt 	uvm_estimatepageable(&active, &inactive);
    832       1.95      yamt 	return LFS_WAIT_RESOURCE(active + inactive + uvmexp.free, 1);
    833       1.95      yamt }
    834       1.95      yamt 
    835       1.95      yamt int
    836       1.95      yamt lfs_max_pages(void)
    837       1.95      yamt {
    838       1.95      yamt 	int active, inactive;
    839       1.95      yamt 
    840       1.95      yamt 	uvm_estimatepageable(&active, &inactive);
    841       1.95      yamt 	return LFS_MAX_RESOURCE(active + inactive + uvmexp.free, 1);
    842       1.95      yamt }
    843