Home | History | Annotate | Line # | Download | only in lfs
lfs_bio.c revision 1.89.6.2
      1  1.89.6.2      yamt /*	$NetBSD: lfs_bio.c,v 1.89.6.2 2006/03/13 09:07:43 yamt Exp $	*/
      2       1.2       cgd 
      3       1.7  perseant /*-
      4      1.58  perseant  * Copyright (c) 1999, 2000, 2001, 2002, 2003 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  * 3. All advertising materials mentioning features or use of this software
     19       1.7  perseant  *    must display the following acknowledgement:
     20      1.61  perseant  *	This product includes software developed by the NetBSD
     21      1.61  perseant  *	Foundation, Inc. and its contributors.
     22       1.7  perseant  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23       1.7  perseant  *    contributors may be used to endorse or promote products derived
     24       1.7  perseant  *    from this software without specific prior written permission.
     25       1.7  perseant  *
     26       1.7  perseant  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27       1.7  perseant  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28       1.7  perseant  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29       1.7  perseant  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30       1.7  perseant  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31       1.7  perseant  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32       1.7  perseant  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33       1.7  perseant  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34       1.7  perseant  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35       1.7  perseant  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36       1.7  perseant  * POSSIBILITY OF SUCH DAMAGE.
     37       1.7  perseant  */
     38       1.1   mycroft /*
     39       1.1   mycroft  * Copyright (c) 1991, 1993
     40       1.1   mycroft  *	The Regents of the University of California.  All rights reserved.
     41       1.1   mycroft  *
     42       1.1   mycroft  * Redistribution and use in source and binary forms, with or without
     43       1.1   mycroft  * modification, are permitted provided that the following conditions
     44       1.1   mycroft  * are met:
     45       1.1   mycroft  * 1. Redistributions of source code must retain the above copyright
     46       1.1   mycroft  *    notice, this list of conditions and the following disclaimer.
     47       1.1   mycroft  * 2. Redistributions in binary form must reproduce the above copyright
     48       1.1   mycroft  *    notice, this list of conditions and the following disclaimer in the
     49       1.1   mycroft  *    documentation and/or other materials provided with the distribution.
     50      1.72       agc  * 3. Neither the name of the University nor the names of its contributors
     51       1.1   mycroft  *    may be used to endorse or promote products derived from this software
     52       1.1   mycroft  *    without specific prior written permission.
     53       1.1   mycroft  *
     54       1.1   mycroft  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     55       1.1   mycroft  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     56       1.1   mycroft  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     57       1.1   mycroft  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     58       1.1   mycroft  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     59       1.1   mycroft  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     60       1.1   mycroft  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     61       1.1   mycroft  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     62       1.1   mycroft  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     63       1.1   mycroft  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     64       1.1   mycroft  * SUCH DAMAGE.
     65       1.1   mycroft  *
     66       1.6      fvdl  *	@(#)lfs_bio.c	8.10 (Berkeley) 6/10/95
     67       1.1   mycroft  */
     68      1.39     lukem 
     69      1.39     lukem #include <sys/cdefs.h>
     70  1.89.6.2      yamt __KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.89.6.2 2006/03/13 09:07:43 yamt Exp $");
     71       1.1   mycroft 
     72       1.1   mycroft #include <sys/param.h>
     73       1.5  christos #include <sys/systm.h>
     74       1.1   mycroft #include <sys/proc.h>
     75       1.1   mycroft #include <sys/buf.h>
     76       1.1   mycroft #include <sys/vnode.h>
     77       1.1   mycroft #include <sys/resourcevar.h>
     78       1.1   mycroft #include <sys/mount.h>
     79       1.1   mycroft #include <sys/kernel.h>
     80       1.1   mycroft 
     81       1.1   mycroft #include <ufs/ufs/inode.h>
     82       1.1   mycroft #include <ufs/ufs/ufsmount.h>
     83       1.5  christos #include <ufs/ufs/ufs_extern.h>
     84       1.1   mycroft 
     85       1.1   mycroft #include <ufs/lfs/lfs.h>
     86       1.1   mycroft #include <ufs/lfs/lfs_extern.h>
     87       1.1   mycroft 
     88      1.58  perseant #include <uvm/uvm.h>
     89      1.58  perseant 
     90       1.1   mycroft /*
     91       1.1   mycroft  * LFS block write function.
     92       1.1   mycroft  *
     93       1.1   mycroft  * XXX
     94       1.1   mycroft  * No write cost accounting is done.
     95       1.1   mycroft  * This is almost certainly wrong for synchronous operations and NFS.
     96      1.71      yamt  *
     97      1.71      yamt  * protected by lfs_subsys_lock.
     98       1.1   mycroft  */
     99      1.58  perseant int	locked_queue_count   = 0;	/* Count of locked-down buffers. */
    100      1.58  perseant long	locked_queue_bytes   = 0L;	/* Total size of locked buffers. */
    101      1.61  perseant int	lfs_subsys_pages     = 0L;	/* Total number LFS-written pages */
    102      1.78  perseant int	lfs_fs_pagetrip	     = 0;	/* # of pages to trip per-fs write */
    103      1.61  perseant int	lfs_writing	     = 0;	/* Set if already kicked off a writer
    104       1.1   mycroft 					   because of buffer space */
    105      1.71      yamt /* Lock for aboves */
    106      1.64  perseant struct simplelock lfs_subsys_lock = SIMPLELOCK_INITIALIZER;
    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.51      yamt int lfs_fits_buf(struct lfs *, int, int);
    117      1.52      yamt int lfs_reservebuf(struct lfs *, struct vnode *vp, struct vnode *vp2,
    118      1.52      yamt     int, int);
    119      1.52      yamt int lfs_reserveavail(struct lfs *, struct vnode *vp, struct vnode *vp2, int);
    120      1.51      yamt 
    121      1.51      yamt int
    122      1.51      yamt lfs_fits_buf(struct lfs *fs, int n, int bytes)
    123      1.51      yamt {
    124      1.71      yamt 	int count_fit, bytes_fit;
    125      1.71      yamt 
    126      1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    127      1.71      yamt 	LOCK_ASSERT(simple_lock_held(&lfs_subsys_lock));
    128      1.71      yamt 
    129      1.71      yamt 	count_fit =
    130      1.51      yamt 	    (locked_queue_count + locked_queue_rcount + n < LFS_WAIT_BUFS);
    131      1.71      yamt 	bytes_fit =
    132      1.51      yamt 	    (locked_queue_bytes + locked_queue_rbytes + bytes < LFS_WAIT_BYTES);
    133      1.51      yamt 
    134      1.80  perseant #ifdef DEBUG
    135      1.51      yamt 	if (!count_fit) {
    136      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit count: %d + %d + %d >= %d\n",
    137      1.80  perseant 		      locked_queue_count, locked_queue_rcount,
    138      1.80  perseant 		      n, LFS_WAIT_BUFS));
    139      1.51      yamt 	}
    140      1.51      yamt 	if (!bytes_fit) {
    141      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit bytes: %ld + %ld + %d >= %ld\n",
    142      1.80  perseant 		      locked_queue_bytes, locked_queue_rbytes,
    143      1.80  perseant 		      bytes, LFS_WAIT_BYTES));
    144      1.51      yamt 	}
    145      1.80  perseant #endif /* DEBUG */
    146      1.51      yamt 
    147      1.51      yamt 	return (count_fit && bytes_fit);
    148      1.51      yamt }
    149      1.51      yamt 
    150      1.52      yamt /* ARGSUSED */
    151      1.51      yamt int
    152      1.52      yamt lfs_reservebuf(struct lfs *fs, struct vnode *vp, struct vnode *vp2,
    153      1.52      yamt     int n, int bytes)
    154      1.51      yamt {
    155      1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    156      1.51      yamt 	KASSERT(locked_queue_rcount >= 0);
    157      1.51      yamt 	KASSERT(locked_queue_rbytes >= 0);
    158      1.51      yamt 
    159      1.71      yamt 	simple_lock(&lfs_subsys_lock);
    160      1.51      yamt 	while (n > 0 && !lfs_fits_buf(fs, n, bytes)) {
    161      1.51      yamt 		int error;
    162      1.51      yamt 
    163      1.78  perseant 		lfs_flush(fs, 0, 0);
    164      1.51      yamt 
    165      1.71      yamt 		error = ltsleep(&locked_queue_count, PCATCH | PUSER,
    166      1.71      yamt 		    "lfsresbuf", hz * LFS_BUFWAIT, &lfs_subsys_lock);
    167      1.71      yamt 		if (error && error != EWOULDBLOCK) {
    168      1.71      yamt 			simple_unlock(&lfs_subsys_lock);
    169      1.51      yamt 			return error;
    170      1.71      yamt 		}
    171      1.51      yamt 	}
    172      1.51      yamt 
    173      1.51      yamt 	locked_queue_rcount += n;
    174      1.51      yamt 	locked_queue_rbytes += bytes;
    175      1.51      yamt 
    176      1.71      yamt 	simple_unlock(&lfs_subsys_lock);
    177      1.71      yamt 
    178      1.51      yamt 	KASSERT(locked_queue_rcount >= 0);
    179      1.51      yamt 	KASSERT(locked_queue_rbytes >= 0);
    180      1.51      yamt 
    181      1.51      yamt 	return 0;
    182      1.51      yamt }
    183      1.51      yamt 
    184      1.51      yamt /*
    185      1.27  perseant  * Try to reserve some blocks, prior to performing a sensitive operation that
    186      1.27  perseant  * requires the vnode lock to be honored.  If there is not enough space, give
    187      1.27  perseant  * up the vnode lock temporarily and wait for the space to become available.
    188      1.27  perseant  *
    189      1.44  perseant  * Called with vp locked.  (Note nowever that if fsb < 0, vp is ignored.)
    190      1.46      yamt  *
    191      1.47      yamt  * XXX YAMT - it isn't safe to unlock vp here
    192      1.47      yamt  * because the node might be modified while we sleep.
    193      1.47      yamt  * (eg. cached states like i_offset might be stale,
    194      1.47      yamt  *  the vnode might be truncated, etc..)
    195      1.55      yamt  * maybe we should have a way to restart the vnodeop (EVOPRESTART?)
    196      1.55      yamt  * or rearrange vnodeop interface to leave vnode locking to file system
    197      1.55      yamt  * specific code so that each file systems can have their own vnode locking and
    198      1.55      yamt  * vnode re-using strategies.
    199      1.27  perseant  */
    200      1.27  perseant int
    201      1.52      yamt lfs_reserveavail(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb)
    202      1.27  perseant {
    203      1.27  perseant 	CLEANERINFO *cip;
    204      1.27  perseant 	struct buf *bp;
    205      1.27  perseant 	int error, slept;
    206      1.27  perseant 
    207      1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    208      1.27  perseant 	slept = 0;
    209      1.82  perseant 	simple_lock(&fs->lfs_interlock);
    210      1.78  perseant 	while (fsb > 0 && !lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) {
    211      1.82  perseant 		simple_unlock(&fs->lfs_interlock);
    212      1.49      yamt #if 0
    213      1.49      yamt 		/*
    214      1.49      yamt 		 * XXX ideally, we should unlock vnodes here
    215      1.49      yamt 		 * because we might sleep very long time.
    216      1.49      yamt 		 */
    217      1.27  perseant 		VOP_UNLOCK(vp, 0);
    218      1.52      yamt 		if (vp2 != NULL) {
    219      1.52      yamt 			VOP_UNLOCK(vp2, 0);
    220      1.52      yamt 		}
    221      1.50      yamt #else
    222      1.50      yamt 		/*
    223      1.50      yamt 		 * XXX since we'll sleep for cleaner with vnode lock holding,
    224      1.55      yamt 		 * deadlock will occur if cleaner tries to lock the vnode.
    225      1.50      yamt 		 * (eg. lfs_markv -> lfs_fastvget -> getnewvnode -> vclean)
    226      1.50      yamt 		 */
    227      1.49      yamt #endif
    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.27  perseant 		wakeup(&lfs_allclean_wakeup);
    241      1.27  perseant 		wakeup(&fs->lfs_nextseg);
    242      1.79     perry 
    243      1.82  perseant 		simple_lock(&fs->lfs_interlock);
    244      1.82  perseant 		/* Cleaner might have run while we were reading, check again */
    245      1.82  perseant 		if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail))
    246      1.82  perseant 			break;
    247      1.82  perseant 
    248      1.82  perseant 		error = ltsleep(&fs->lfs_avail, PCATCH | PUSER, "lfs_reserve",
    249      1.82  perseant 				0, &fs->lfs_interlock);
    250      1.49      yamt #if 0
    251      1.27  perseant 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); /* XXX use lockstatus */
    252      1.52      yamt 		vn_lock(vp2, LK_EXCLUSIVE | LK_RETRY); /* XXX use lockstatus */
    253      1.49      yamt #endif
    254      1.27  perseant 		if (error)
    255      1.27  perseant 			return error;
    256      1.27  perseant 	}
    257      1.80  perseant #ifdef DEBUG
    258      1.80  perseant 	if (slept) {
    259      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_reserve: woke up\n"));
    260      1.80  perseant 	}
    261      1.44  perseant #endif
    262      1.44  perseant 	fs->lfs_ravail += fsb;
    263      1.82  perseant 	simple_unlock(&fs->lfs_interlock);
    264      1.51      yamt 
    265      1.27  perseant 	return 0;
    266      1.27  perseant }
    267      1.27  perseant 
    268      1.51      yamt #ifdef DIAGNOSTIC
    269      1.51      yamt int lfs_rescount;
    270      1.51      yamt int lfs_rescountdirop;
    271      1.51      yamt #endif
    272      1.51      yamt 
    273      1.51      yamt int
    274      1.52      yamt lfs_reserve(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb)
    275      1.51      yamt {
    276      1.51      yamt 	int error;
    277      1.51      yamt 	int cantwait;
    278      1.51      yamt 
    279      1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    280      1.82  perseant 	if (vp2) {
    281      1.82  perseant 		/* Make sure we're not in the process of reclaiming vp2 */
    282      1.82  perseant 		simple_lock(&fs->lfs_interlock);
    283      1.82  perseant 		while(fs->lfs_flags & LFS_UNDIROP) {
    284      1.82  perseant 			ltsleep(&fs->lfs_flags, PRIBIO + 1, "lfsrundirop", 0,
    285      1.82  perseant 			    &fs->lfs_interlock);
    286      1.82  perseant 		}
    287      1.82  perseant 		simple_unlock(&fs->lfs_interlock);
    288      1.82  perseant 	}
    289      1.82  perseant 
    290      1.52      yamt 	KASSERT(fsb < 0 || VOP_ISLOCKED(vp));
    291      1.52      yamt 	KASSERT(vp2 == NULL || fsb < 0 || VOP_ISLOCKED(vp2));
    292      1.55      yamt 	KASSERT(vp2 == NULL || !(VTOI(vp2)->i_flag & IN_ADIROP));
    293      1.55      yamt 	KASSERT(vp2 == NULL || vp2 != fs->lfs_unlockvp);
    294      1.52      yamt 
    295      1.54      yamt 	cantwait = (VTOI(vp)->i_flag & IN_ADIROP) || fs->lfs_unlockvp == vp;
    296      1.51      yamt #ifdef DIAGNOSTIC
    297      1.51      yamt 	if (cantwait) {
    298      1.51      yamt 		if (fsb > 0)
    299      1.51      yamt 			lfs_rescountdirop++;
    300      1.51      yamt 		else if (fsb < 0)
    301      1.51      yamt 			lfs_rescountdirop--;
    302      1.51      yamt 		if (lfs_rescountdirop < 0)
    303      1.51      yamt 			panic("lfs_rescountdirop");
    304      1.51      yamt 	}
    305      1.51      yamt 	else {
    306      1.51      yamt 		if (fsb > 0)
    307      1.51      yamt 			lfs_rescount++;
    308      1.51      yamt 		else if (fsb < 0)
    309      1.51      yamt 			lfs_rescount--;
    310      1.51      yamt 		if (lfs_rescount < 0)
    311      1.51      yamt 			panic("lfs_rescount");
    312      1.51      yamt 	}
    313      1.51      yamt #endif
    314      1.51      yamt 	if (cantwait)
    315      1.51      yamt 		return 0;
    316      1.53      yamt 
    317      1.53      yamt 	/*
    318      1.53      yamt 	 * XXX
    319      1.53      yamt 	 * vref vnodes here so that cleaner doesn't try to reuse them.
    320      1.55      yamt 	 * (see XXX comment in lfs_reserveavail)
    321      1.53      yamt 	 */
    322      1.53      yamt 	lfs_vref(vp);
    323      1.53      yamt 	if (vp2 != NULL) {
    324      1.53      yamt 		lfs_vref(vp2);
    325      1.53      yamt 	}
    326      1.51      yamt 
    327      1.52      yamt 	error = lfs_reserveavail(fs, vp, vp2, fsb);
    328      1.51      yamt 	if (error)
    329      1.52      yamt 		goto done;
    330      1.51      yamt 
    331      1.51      yamt 	/*
    332      1.51      yamt 	 * XXX just a guess. should be more precise.
    333      1.51      yamt 	 */
    334      1.52      yamt 	error = lfs_reservebuf(fs, vp, vp2,
    335      1.52      yamt 	    fragstoblks(fs, fsb), fsbtob(fs, fsb));
    336      1.51      yamt 	if (error)
    337      1.52      yamt 		lfs_reserveavail(fs, vp, vp2, -fsb);
    338      1.52      yamt 
    339      1.52      yamt done:
    340      1.52      yamt 	lfs_vunref(vp);
    341      1.52      yamt 	if (vp2 != NULL) {
    342      1.52      yamt 		lfs_vunref(vp2);
    343      1.52      yamt 	}
    344      1.51      yamt 
    345      1.51      yamt 	return error;
    346      1.51      yamt }
    347       1.1   mycroft 
    348       1.1   mycroft int
    349      1.36  perseant lfs_bwrite(void *v)
    350       1.5  christos {
    351       1.1   mycroft 	struct vop_bwrite_args /* {
    352       1.1   mycroft 		struct buf *a_bp;
    353       1.5  christos 	} */ *ap = v;
    354      1.17  augustss 	struct buf *bp = ap->a_bp;
    355       1.7  perseant 
    356       1.7  perseant #ifdef DIAGNOSTIC
    357      1.61  perseant 	if (VTOI(bp->b_vp)->i_lfs->lfs_ronly == 0 && (bp->b_flags & B_ASYNC)) {
    358       1.7  perseant 		panic("bawrite LFS buffer");
    359      1.16  perseant 	}
    360       1.7  perseant #endif /* DIAGNOSTIC */
    361      1.85  perseant 	return lfs_bwrite_ext(bp, 0);
    362       1.7  perseant }
    363       1.7  perseant 
    364      1.79     perry /*
    365      1.44  perseant  * Determine if there is enough room currently available to write fsb
    366      1.44  perseant  * blocks.  We need enough blocks for the new blocks, the current
    367      1.44  perseant  * inode blocks (including potentially the ifile inode), a summary block,
    368      1.44  perseant  * and the segment usage table, plus an ifile block.
    369       1.7  perseant  */
    370      1.32  perseant int
    371      1.36  perseant lfs_fits(struct lfs *fs, int fsb)
    372       1.7  perseant {
    373      1.26  perseant 	int needed;
    374      1.26  perseant 
    375      1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    376      1.36  perseant 	needed = fsb + btofsb(fs, fs->lfs_sumsize) +
    377      1.44  perseant 		 ((howmany(fs->lfs_uinodes + 1, INOPB(fs)) + fs->lfs_segtabsz +
    378      1.44  perseant 		   1) << (fs->lfs_blktodb - fs->lfs_fsbtodb));
    379      1.27  perseant 
    380      1.26  perseant 	if (needed >= fs->lfs_avail) {
    381      1.80  perseant #ifdef DEBUG
    382      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_fits: no fit: fsb = %ld, uinodes = %ld, "
    383      1.80  perseant 		      "needed = %ld, avail = %ld\n",
    384      1.80  perseant 		      (long)fsb, (long)fs->lfs_uinodes, (long)needed,
    385      1.80  perseant 		      (long)fs->lfs_avail));
    386      1.26  perseant #endif
    387       1.7  perseant 		return 0;
    388       1.7  perseant 	}
    389       1.7  perseant 	return 1;
    390       1.7  perseant }
    391       1.7  perseant 
    392       1.7  perseant int
    393      1.44  perseant lfs_availwait(struct lfs *fs, int fsb)
    394      1.32  perseant {
    395      1.32  perseant 	int error;
    396      1.32  perseant 	CLEANERINFO *cip;
    397      1.32  perseant 	struct buf *cbp;
    398      1.63  perseant 
    399      1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    400      1.63  perseant 	/* Push cleaner blocks through regardless */
    401      1.64  perseant 	simple_lock(&fs->lfs_interlock);
    402      1.82  perseant 	if (LFS_SEGLOCK_HELD(fs) &&
    403      1.64  perseant 	    fs->lfs_sp->seg_flags & (SEGM_CLEAN | SEGM_FORCE_CKP)) {
    404      1.64  perseant 		simple_unlock(&fs->lfs_interlock);
    405      1.63  perseant 		return 0;
    406      1.64  perseant 	}
    407      1.64  perseant 	simple_unlock(&fs->lfs_interlock);
    408      1.32  perseant 
    409      1.44  perseant 	while (!lfs_fits(fs, fsb)) {
    410      1.32  perseant 		/*
    411      1.32  perseant 		 * Out of space, need cleaner to run.
    412      1.32  perseant 		 * Update the cleaner info, then wake it up.
    413      1.32  perseant 		 * Note the cleanerinfo block is on the ifile
    414      1.32  perseant 		 * so it CANT_WAIT.
    415      1.32  perseant 		 */
    416      1.32  perseant 		LFS_CLEANERINFO(cip, fs, cbp);
    417      1.32  perseant 		LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);
    418      1.79     perry 
    419      1.80  perseant #ifdef DEBUG
    420      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_availwait: out of available space, "
    421      1.80  perseant 		      "waiting on cleaner\n"));
    422      1.78  perseant #endif
    423      1.79     perry 
    424      1.32  perseant 		wakeup(&lfs_allclean_wakeup);
    425      1.32  perseant 		wakeup(&fs->lfs_nextseg);
    426      1.32  perseant #ifdef DIAGNOSTIC
    427      1.82  perseant 		if (LFS_SEGLOCK_HELD(fs))
    428      1.32  perseant 			panic("lfs_availwait: deadlock");
    429      1.32  perseant #endif
    430      1.32  perseant 		error = tsleep(&fs->lfs_avail, PCATCH | PUSER, "cleaner", 0);
    431      1.32  perseant 		if (error)
    432      1.32  perseant 			return (error);
    433      1.32  perseant 	}
    434      1.32  perseant 	return 0;
    435      1.32  perseant }
    436      1.32  perseant 
    437      1.32  perseant int
    438      1.36  perseant lfs_bwrite_ext(struct buf *bp, int flags)
    439       1.7  perseant {
    440       1.1   mycroft 	struct lfs *fs;
    441       1.1   mycroft 	struct inode *ip;
    442      1.51      yamt 	int fsb, s;
    443      1.48      yamt 
    444      1.85  perseant 	fs = VFSTOUFS(bp->b_vp->v_mount)->um_lfs;
    445      1.85  perseant 
    446      1.85  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    447      1.48      yamt 	KASSERT(bp->b_flags & B_BUSY);
    448      1.58  perseant 	KASSERT(flags & BW_CLEAN || !LFS_IS_MALLOC_BUF(bp));
    449      1.75      yamt 	KASSERT((bp->b_flags & (B_DELWRI|B_LOCKED)) != B_DELWRI);
    450      1.75      yamt 	KASSERT((bp->b_flags & (B_DELWRI|B_LOCKED)) != B_LOCKED);
    451      1.48      yamt 
    452       1.1   mycroft 	/*
    453      1.85  perseant 	 * Don't write *any* blocks if we're mounted read-only, or
    454      1.85  perseant 	 * if we are "already unmounted".
    455      1.85  perseant 	 *
    456      1.16  perseant 	 * In particular the cleaner can't write blocks either.
    457      1.16  perseant 	 */
    458      1.85  perseant 	if (fs->lfs_ronly || (fs->lfs_pflags & LFS_PF_CLEAN)) {
    459      1.32  perseant 		bp->b_flags &= ~(B_DELWRI | B_READ | B_ERROR);
    460      1.32  perseant 		LFS_UNLOCK_BUF(bp);
    461      1.58  perseant 		if (LFS_IS_MALLOC_BUF(bp))
    462      1.16  perseant 			bp->b_flags &= ~B_BUSY;
    463      1.16  perseant 		else
    464      1.16  perseant 			brelse(bp);
    465      1.85  perseant 		return (fs->lfs_ronly ? EROFS : 0);
    466      1.16  perseant 	}
    467      1.16  perseant 
    468      1.16  perseant 	/*
    469       1.1   mycroft 	 * Set the delayed write flag and use reassignbuf to move the buffer
    470       1.1   mycroft 	 * from the clean list to the dirty one.
    471       1.1   mycroft 	 *
    472       1.1   mycroft 	 * Set the B_LOCKED flag and unlock the buffer, causing brelse to move
    473       1.1   mycroft 	 * the buffer onto the LOCKED free list.  This is necessary, otherwise
    474       1.1   mycroft 	 * getnewbuf() would try to reclaim the buffers using bawrite, which
    475       1.1   mycroft 	 * isn't going to work.
    476       1.1   mycroft 	 *
    477       1.1   mycroft 	 * XXX we don't let meta-data writes run out of space because they can
    478       1.1   mycroft 	 * come from the segment writer.  We need to make sure that there is
    479       1.1   mycroft 	 * enough space reserved so that there's room to write meta-data
    480       1.1   mycroft 	 * blocks.
    481       1.1   mycroft 	 */
    482       1.1   mycroft 	if (!(bp->b_flags & B_LOCKED)) {
    483      1.36  perseant 		fsb = fragstofsb(fs, numfrags(fs, bp->b_bcount));
    484      1.79     perry 
    485       1.7  perseant 		ip = VTOI(bp->b_vp);
    486      1.48      yamt 		if (flags & BW_CLEAN) {
    487      1.26  perseant 			LFS_SET_UINO(ip, IN_CLEANING);
    488       1.7  perseant 		} else {
    489      1.36  perseant 			LFS_SET_UINO(ip, IN_MODIFIED);
    490       1.7  perseant 		}
    491      1.36  perseant 		fs->lfs_avail -= fsb;
    492      1.32  perseant 		bp->b_flags |= B_DELWRI;
    493      1.32  perseant 
    494      1.32  perseant 		LFS_LOCK_BUF(bp);
    495      1.43  perseant 		bp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
    496      1.14      fvdl 		s = splbio();
    497       1.1   mycroft 		reassignbuf(bp, bp->b_vp);
    498       1.1   mycroft 		splx(s);
    499       1.1   mycroft 	}
    500      1.79     perry 
    501      1.40       chs 	if (bp->b_flags & B_CALL)
    502       1.7  perseant 		bp->b_flags &= ~B_BUSY;
    503       1.7  perseant 	else
    504       1.7  perseant 		brelse(bp);
    505      1.79     perry 
    506       1.1   mycroft 	return (0);
    507       1.1   mycroft }
    508       1.1   mycroft 
    509      1.82  perseant /*
    510      1.82  perseant  * Called and return with the lfs_interlock held, but the lfs_subsys_lock
    511      1.82  perseant  * not held.
    512      1.82  perseant  */
    513      1.24  perseant void
    514      1.36  perseant lfs_flush_fs(struct lfs *fs, int flags)
    515      1.11  perseant {
    516      1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    517      1.82  perseant 	LOCK_ASSERT(simple_lock_held(&fs->lfs_interlock));
    518      1.82  perseant 	LOCK_ASSERT(!simple_lock_held(&lfs_subsys_lock));
    519      1.58  perseant 	if (fs->lfs_ronly)
    520      1.58  perseant 		return;
    521      1.11  perseant 
    522      1.82  perseant 	simple_lock(&lfs_subsys_lock);
    523      1.82  perseant 	if (lfs_dostats)
    524      1.82  perseant 		++lfs_stats.flush_invoked;
    525      1.82  perseant 	simple_unlock(&lfs_subsys_lock);
    526      1.78  perseant 
    527      1.82  perseant 	simple_unlock(&fs->lfs_interlock);
    528      1.67      yamt 	lfs_writer_enter(fs, "fldirop");
    529      1.58  perseant 	lfs_segwrite(fs->lfs_ivnode->v_mount, flags);
    530      1.82  perseant 	lfs_writer_leave(fs);
    531      1.82  perseant 	simple_lock(&fs->lfs_interlock);
    532      1.78  perseant 	fs->lfs_favail = 0; /* XXX */
    533      1.11  perseant }
    534      1.11  perseant 
    535       1.1   mycroft /*
    536      1.81  perseant  * This routine initiates segment writes when LFS is consuming too many
    537      1.81  perseant  * resources.  Ideally the pageout daemon would be able to direct LFS
    538      1.81  perseant  * more subtly.
    539      1.81  perseant  * XXX We have one static count of locked buffers;
    540      1.81  perseant  * XXX need to think more about the multiple filesystem case.
    541      1.71      yamt  *
    542      1.81  perseant  * Called and return with lfs_subsys_lock held.
    543      1.83  perseant  * If fs != NULL, we hold the segment lock for fs.
    544       1.1   mycroft  */
    545       1.1   mycroft void
    546      1.78  perseant lfs_flush(struct lfs *fs, int flags, int only_onefs)
    547       1.1   mycroft {
    548      1.78  perseant 	extern u_int64_t locked_fakequeue_count;
    549      1.17  augustss 	struct mount *mp, *nmp;
    550      1.83  perseant 	struct lfs *tfs;
    551      1.67      yamt 
    552      1.71      yamt 	LOCK_ASSERT(simple_lock_held(&lfs_subsys_lock));
    553      1.67      yamt 	KDASSERT(fs == NULL || !LFS_SEGLOCK_HELD(fs));
    554      1.79     perry 
    555      1.79     perry 	if (lfs_dostats)
    556       1.7  perseant 		++lfs_stats.write_exceeded;
    557      1.81  perseant 	/* XXX should we include SEGM_CKP here? */
    558      1.84  perseant 	if (lfs_writing && !(flags & SEGM_SYNC)) {
    559      1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_flush: not flushing because another flush is active\n"));
    560       1.1   mycroft 		return;
    561      1.16  perseant 	}
    562      1.81  perseant 	while (lfs_writing)
    563      1.71      yamt 		ltsleep(&lfs_writing, PRIBIO + 1, "lfsflush", 0,
    564      1.82  perseant 			&lfs_subsys_lock);
    565       1.1   mycroft 	lfs_writing = 1;
    566      1.79     perry 
    567      1.64  perseant 	simple_unlock(&lfs_subsys_lock);
    568      1.58  perseant 
    569      1.78  perseant 	if (only_onefs) {
    570      1.83  perseant 		KASSERT(fs != NULL);
    571      1.83  perseant 		if (vfs_busy(fs->lfs_ivnode->v_mount, LK_NOWAIT,
    572      1.83  perseant 			     &mountlist_slock))
    573      1.78  perseant 			goto errout;
    574      1.83  perseant 		simple_lock(&fs->lfs_interlock);
    575      1.78  perseant 		lfs_flush_fs(fs, flags);
    576      1.83  perseant 		simple_unlock(&fs->lfs_interlock);
    577      1.78  perseant 		vfs_unbusy(fs->lfs_ivnode->v_mount);
    578      1.78  perseant 	} else {
    579      1.78  perseant 		locked_fakequeue_count = 0;
    580      1.78  perseant 		simple_lock(&mountlist_slock);
    581      1.78  perseant 		for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist;
    582      1.78  perseant 		     mp = nmp) {
    583      1.78  perseant 			if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock)) {
    584      1.80  perseant 				DLOG((DLOG_FLUSH, "lfs_flush: fs vfs_busy\n"));
    585      1.78  perseant 				nmp = CIRCLEQ_NEXT(mp, mnt_list);
    586      1.78  perseant 				continue;
    587      1.78  perseant 			}
    588      1.78  perseant 			if (strncmp(&mp->mnt_stat.f_fstypename[0], MOUNT_LFS,
    589      1.83  perseant 			    MFSNAMELEN) == 0) {
    590      1.83  perseant 				tfs = VFSTOUFS(mp)->um_lfs;
    591      1.83  perseant 				simple_lock(&tfs->lfs_interlock);
    592      1.83  perseant 				lfs_flush_fs(tfs, flags);
    593      1.83  perseant 				simple_unlock(&tfs->lfs_interlock);
    594      1.83  perseant 			}
    595      1.78  perseant 			simple_lock(&mountlist_slock);
    596      1.69      yamt 			nmp = CIRCLEQ_NEXT(mp, mnt_list);
    597      1.78  perseant 			vfs_unbusy(mp);
    598       1.6      fvdl 		}
    599      1.78  perseant 		simple_unlock(&mountlist_slock);
    600       1.1   mycroft 	}
    601      1.43  perseant 	LFS_DEBUG_COUNTLOCKED("flush");
    602      1.78  perseant 	wakeup(&lfs_subsys_pages);
    603       1.7  perseant 
    604      1.78  perseant     errout:
    605      1.71      yamt 	simple_lock(&lfs_subsys_lock);
    606      1.71      yamt 	KASSERT(lfs_writing);
    607       1.1   mycroft 	lfs_writing = 0;
    608      1.60      yamt 	wakeup(&lfs_writing);
    609       1.1   mycroft }
    610       1.1   mycroft 
    611      1.41  perseant #define INOCOUNT(fs) howmany((fs)->lfs_uinodes, INOPB(fs))
    612      1.65      fvdl #define INOBYTES(fs) ((fs)->lfs_uinodes * sizeof (struct ufs1_dinode))
    613      1.41  perseant 
    614      1.70      yamt /*
    615      1.70      yamt  * make sure that we don't have too many locked buffers.
    616      1.70      yamt  * flush buffers if needed.
    617      1.70      yamt  */
    618       1.1   mycroft int
    619      1.56      fvdl lfs_check(struct vnode *vp, daddr_t blkno, int flags)
    620       1.1   mycroft {
    621       1.1   mycroft 	int error;
    622      1.10  perseant 	struct lfs *fs;
    623      1.20  perseant 	struct inode *ip;
    624      1.78  perseant 	extern pid_t lfs_writer_daemon;
    625      1.10  perseant 
    626       1.1   mycroft 	error = 0;
    627      1.20  perseant 	ip = VTOI(vp);
    628      1.79     perry 
    629       1.7  perseant 	/* If out of buffers, wait on writer */
    630       1.7  perseant 	/* XXX KS - if it's the Ifile, we're probably the cleaner! */
    631      1.20  perseant 	if (ip->i_number == LFS_IFILE_INUM)
    632      1.20  perseant 		return 0;
    633      1.20  perseant 	/* If we're being called from inside a dirop, don't sleep */
    634      1.20  perseant 	if (ip->i_flag & IN_ADIROP)
    635       1.7  perseant 		return 0;
    636       1.7  perseant 
    637      1.20  perseant 	fs = ip->i_lfs;
    638      1.20  perseant 
    639      1.82  perseant 	ASSERT_NO_SEGLOCK(fs);
    640      1.82  perseant 	LOCK_ASSERT(!simple_lock_held(&fs->lfs_interlock));
    641      1.82  perseant 
    642      1.20  perseant 	/*
    643      1.20  perseant 	 * If we would flush below, but dirops are active, sleep.
    644      1.20  perseant 	 * Note that a dirop cannot ever reach this code!
    645      1.20  perseant 	 */
    646      1.82  perseant 	simple_lock(&fs->lfs_interlock);
    647      1.64  perseant 	simple_lock(&lfs_subsys_lock);
    648      1.20  perseant 	while (fs->lfs_dirops > 0 &&
    649      1.41  perseant 	       (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
    650      1.61  perseant 		locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
    651      1.58  perseant 		lfs_subsys_pages > LFS_MAX_PAGES ||
    652      1.61  perseant 		lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0))
    653      1.20  perseant 	{
    654      1.82  perseant 		simple_unlock(&lfs_subsys_lock);
    655      1.20  perseant 		++fs->lfs_diropwait;
    656      1.64  perseant 		ltsleep(&fs->lfs_writer, PRIBIO+1, "bufdirop", 0,
    657      1.82  perseant 			&fs->lfs_interlock);
    658      1.20  perseant 		--fs->lfs_diropwait;
    659      1.82  perseant 		simple_lock(&lfs_subsys_lock);
    660      1.20  perseant 	}
    661      1.10  perseant 
    662      1.80  perseant #ifdef DEBUG
    663      1.58  perseant 	if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS)
    664      1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lqc = %d, max %d\n",
    665      1.80  perseant 		      locked_queue_count + INOCOUNT(fs), LFS_MAX_BUFS));
    666      1.58  perseant 	if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES)
    667      1.80  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lqb = %ld, max %ld\n",
    668      1.80  perseant 		      locked_queue_bytes + INOBYTES(fs), LFS_MAX_BYTES));
    669      1.58  perseant 	if (lfs_subsys_pages > LFS_MAX_PAGES)
    670      1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: lssp = %d, max %d\n",
    671      1.82  perseant 		      lfs_subsys_pages, LFS_MAX_PAGES));
    672      1.78  perseant 	if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip)
    673      1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: fssp = %d, trip at %d\n",
    674      1.82  perseant 		      fs->lfs_pages, lfs_fs_pagetrip));
    675      1.58  perseant 	if (lfs_dirvcount > LFS_MAX_DIROP)
    676      1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: ldvc = %d, max %d\n",
    677      1.82  perseant 		      lfs_dirvcount, LFS_MAX_DIROP));
    678      1.58  perseant 	if (fs->lfs_diropwait > 0)
    679      1.82  perseant 		DLOG((DLOG_FLUSH, "lfs_check: ldvw = %d\n",
    680      1.82  perseant 		      fs->lfs_diropwait));
    681      1.58  perseant #endif
    682      1.64  perseant 
    683      1.41  perseant 	if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
    684      1.41  perseant 	    locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
    685      1.58  perseant 	    lfs_subsys_pages > LFS_MAX_PAGES ||
    686      1.71      yamt 	    lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {
    687      1.83  perseant 		simple_unlock(&fs->lfs_interlock);
    688      1.78  perseant 		lfs_flush(fs, flags, 0);
    689      1.80  perseant 	} else if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) {
    690      1.80  perseant 		/*
    691      1.80  perseant 		 * If we didn't flush the whole thing, some filesystems
    692      1.80  perseant 		 * still might want to be flushed.
    693      1.80  perseant 		 */
    694      1.78  perseant 		++fs->lfs_pdflush;
    695      1.78  perseant 		wakeup(&lfs_writer_daemon);
    696      1.83  perseant 		simple_unlock(&fs->lfs_interlock);
    697      1.83  perseant 	} else
    698      1.83  perseant 		simple_unlock(&fs->lfs_interlock);
    699      1.11  perseant 
    700      1.58  perseant 	while (locked_queue_count + INOCOUNT(fs) > LFS_WAIT_BUFS ||
    701      1.58  perseant 		locked_queue_bytes + INOBYTES(fs) > LFS_WAIT_BYTES ||
    702      1.58  perseant 		lfs_subsys_pages > LFS_WAIT_PAGES ||
    703      1.71      yamt 		lfs_dirvcount > LFS_MAX_DIROP) {
    704      1.82  perseant 
    705      1.40       chs 		if (lfs_dostats)
    706       1.7  perseant 			++lfs_stats.wait_exceeded;
    707      1.80  perseant 		DLOG((DLOG_AVAIL, "lfs_check: waiting: count=%d, bytes=%ld\n",
    708      1.80  perseant 		      locked_queue_count, locked_queue_bytes));
    709      1.82  perseant 		error = ltsleep(&locked_queue_count, PCATCH | PUSER,
    710      1.82  perseant 				"buffers", hz * LFS_BUFWAIT, &lfs_subsys_lock);
    711      1.82  perseant 		if (error != EWOULDBLOCK)
    712      1.33  perseant 			break;
    713      1.82  perseant 
    714      1.18  perseant 		/*
    715      1.18  perseant 		 * lfs_flush might not flush all the buffers, if some of the
    716      1.33  perseant 		 * inodes were locked or if most of them were Ifile blocks
    717      1.61  perseant 		 * and we weren't asked to checkpoint.	Try flushing again
    718      1.33  perseant 		 * to keep us from blocking indefinitely.
    719      1.18  perseant 		 */
    720      1.41  perseant 		if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
    721      1.71      yamt 		    locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES) {
    722      1.78  perseant 			lfs_flush(fs, flags | SEGM_CKP, 0);
    723      1.18  perseant 		}
    724       1.7  perseant 	}
    725      1.64  perseant 	simple_unlock(&lfs_subsys_lock);
    726       1.7  perseant 	return (error);
    727       1.7  perseant }
    728       1.1   mycroft 
    729       1.7  perseant /*
    730       1.7  perseant  * Allocate a new buffer header.
    731       1.7  perseant  */
    732      1.34  perseant struct buf *
    733      1.58  perseant lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int type)
    734       1.7  perseant {
    735       1.7  perseant 	struct buf *bp;
    736       1.7  perseant 	size_t nbytes;
    737       1.7  perseant 	int s;
    738      1.79     perry 
    739      1.82  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    740      1.36  perseant 	nbytes = roundup(size, fsbtob(fs, 1));
    741      1.79     perry 
    742      1.88      yamt 	bp = getiobuf();
    743      1.43  perseant 	if (nbytes) {
    744      1.58  perseant 		bp->b_data = lfs_malloc(fs, nbytes, type);
    745      1.58  perseant 		/* memset(bp->b_data, 0, nbytes); */
    746       1.7  perseant 	}
    747      1.79     perry #ifdef DIAGNOSTIC
    748      1.40       chs 	if (vp == NULL)
    749       1.7  perseant 		panic("vp is NULL in lfs_newbuf");
    750      1.40       chs 	if (bp == NULL)
    751       1.7  perseant 		panic("bp is NULL after malloc in lfs_newbuf");
    752       1.1   mycroft #endif
    753      1.89      yamt 	bp->b_vp = NULL;
    754       1.7  perseant 	s = splbio();
    755       1.7  perseant 	bgetvp(vp, bp);
    756       1.7  perseant 	splx(s);
    757      1.57        pk 
    758       1.7  perseant 	bp->b_bufsize = size;
    759       1.7  perseant 	bp->b_bcount = size;
    760       1.7  perseant 	bp->b_lblkno = daddr;
    761       1.7  perseant 	bp->b_blkno = daddr;
    762       1.7  perseant 	bp->b_error = 0;
    763       1.7  perseant 	bp->b_resid = 0;
    764       1.7  perseant 	bp->b_iodone = lfs_callback;
    765      1.89      yamt 	bp->b_flags = B_BUSY | B_CALL | B_NOCACHE;
    766      1.76      yamt 	bp->b_private = fs;
    767      1.79     perry 
    768       1.7  perseant 	return (bp);
    769       1.7  perseant }
    770       1.7  perseant 
    771       1.7  perseant void
    772      1.58  perseant lfs_freebuf(struct lfs *fs, struct buf *bp)
    773       1.7  perseant {
    774       1.7  perseant 	int s;
    775      1.79     perry 
    776       1.7  perseant 	s = splbio();
    777      1.40       chs 	if (bp->b_vp)
    778       1.7  perseant 		brelvp(bp);
    779       1.7  perseant 	if (!(bp->b_flags & B_INVAL)) { /* B_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.58  perseant 	splx(s);
    784      1.88      yamt 	putiobuf(bp);
    785       1.7  perseant }
    786       1.1   mycroft 
    787       1.7  perseant /*
    788       1.7  perseant  * Definitions for the buffer free lists.
    789       1.7  perseant  */
    790       1.7  perseant #define BQUEUES		4		/* number of free buffer queues */
    791      1.79     perry 
    792       1.7  perseant #define BQ_LOCKED	0		/* super-blocks &c */
    793       1.7  perseant #define BQ_LRU		1		/* lru, useful buffers */
    794      1.79     perry #define BQ_AGE		2		/* rubbish */
    795       1.7  perseant #define BQ_EMPTY	3		/* buffer headers with no memory */
    796      1.79     perry 
    797       1.7  perseant extern TAILQ_HEAD(bqueues, buf) bufqueues[BQUEUES];
    798      1.73      yamt extern struct simplelock bqueue_slock;
    799       1.7  perseant 
    800       1.7  perseant /*
    801      1.80  perseant  * Count buffers on the "locked" queue, and compare it to a pro-forma count.
    802      1.27  perseant  * Don't count malloced buffers, since they don't detract from the total.
    803       1.7  perseant  */
    804       1.7  perseant void
    805      1.86  christos lfs_countlocked(int *count, long *bytes, const char *msg)
    806       1.7  perseant {
    807      1.17  augustss 	struct buf *bp;
    808      1.17  augustss 	int n = 0;
    809      1.17  augustss 	long int size = 0L;
    810      1.73      yamt 	int s;
    811       1.7  perseant 
    812      1.73      yamt 	s = splbio();
    813      1.73      yamt 	simple_lock(&bqueue_slock);
    814      1.69      yamt 	TAILQ_FOREACH(bp, &bufqueues[BQ_LOCKED], b_freelist) {
    815      1.73      yamt 		KASSERT(!(bp->b_flags & B_CALL));
    816       1.7  perseant 		n++;
    817       1.7  perseant 		size += bp->b_bufsize;
    818      1.80  perseant #ifdef DIAGNOSTIC
    819      1.27  perseant 		if (n > nbuf)
    820      1.27  perseant 			panic("lfs_countlocked: this can't happen: more"
    821      1.27  perseant 			      " buffers locked than exist");
    822      1.27  perseant #endif
    823       1.7  perseant 	}
    824      1.80  perseant 	/*
    825      1.80  perseant 	 * Theoretically this function never really does anything.
    826      1.80  perseant 	 * Give a warning if we have to fix the accounting.
    827      1.80  perseant 	 */
    828      1.27  perseant 	if (n != *count)
    829      1.80  perseant 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted buf count"
    830      1.80  perseant 		      " from %d to %d\n", msg, *count, n));
    831      1.27  perseant 	if (size != *bytes)
    832      1.80  perseant 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted byte count"
    833      1.80  perseant 		      " from %ld to %ld\n", msg, *bytes, size));
    834       1.7  perseant 	*count = n;
    835       1.7  perseant 	*bytes = size;
    836      1.73      yamt 	simple_unlock(&bqueue_slock);
    837      1.73      yamt 	splx(s);
    838       1.7  perseant 	return;
    839       1.1   mycroft }
    840  1.89.6.1      yamt 
    841  1.89.6.1      yamt int
    842  1.89.6.1      yamt lfs_wait_pages(void)
    843  1.89.6.1      yamt {
    844  1.89.6.1      yamt 	int active, inactive;
    845  1.89.6.1      yamt 
    846  1.89.6.1      yamt 	uvm_estimatepageable(&active, &inactive);
    847  1.89.6.1      yamt 	return LFS_WAIT_RESOURCE(active + inactive + uvmexp.free, 1);
    848  1.89.6.1      yamt }
    849  1.89.6.1      yamt 
    850  1.89.6.1      yamt int
    851  1.89.6.1      yamt lfs_max_pages(void)
    852  1.89.6.1      yamt {
    853  1.89.6.1      yamt 	int active, inactive;
    854  1.89.6.1      yamt 
    855  1.89.6.1      yamt 	uvm_estimatepageable(&active, &inactive);
    856  1.89.6.1      yamt 	return LFS_MAX_RESOURCE(active + inactive + uvmexp.free, 1);
    857  1.89.6.1      yamt }
    858