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