Home | History | Annotate | Line # | Download | only in lfs
lfs_segment.c revision 1.177
      1  1.177  perseant /*	$NetBSD: lfs_segment.c,v 1.177 2006/05/01 19:47:29 perseant Exp $	*/
      2    1.2       cgd 
      3   1.15  perseant /*-
      4  1.101  perseant  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
      5   1.15  perseant  * All rights reserved.
      6   1.15  perseant  *
      7   1.15  perseant  * This code is derived from software contributed to The NetBSD Foundation
      8   1.15  perseant  * by Konrad E. Schroder <perseant (at) hhhh.org>.
      9   1.15  perseant  *
     10   1.15  perseant  * Redistribution and use in source and binary forms, with or without
     11   1.15  perseant  * modification, are permitted provided that the following conditions
     12   1.15  perseant  * are met:
     13   1.15  perseant  * 1. Redistributions of source code must retain the above copyright
     14   1.15  perseant  *    notice, this list of conditions and the following disclaimer.
     15   1.15  perseant  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.15  perseant  *    notice, this list of conditions and the following disclaimer in the
     17   1.15  perseant  *    documentation and/or other materials provided with the distribution.
     18   1.15  perseant  * 3. All advertising materials mentioning features or use of this software
     19   1.15  perseant  *    must display the following acknowledgement:
     20  1.103  perseant  *	This product includes software developed by the NetBSD
     21  1.103  perseant  *	Foundation, Inc. and its contributors.
     22   1.15  perseant  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23   1.15  perseant  *    contributors may be used to endorse or promote products derived
     24   1.15  perseant  *    from this software without specific prior written permission.
     25   1.15  perseant  *
     26   1.15  perseant  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27   1.15  perseant  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28   1.15  perseant  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29   1.15  perseant  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30   1.15  perseant  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31   1.15  perseant  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32   1.15  perseant  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33   1.15  perseant  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34   1.15  perseant  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35   1.15  perseant  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36   1.15  perseant  * POSSIBILITY OF SUCH DAMAGE.
     37   1.15  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.131       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.10      fvdl  *	@(#)lfs_segment.c	8.10 (Berkeley) 6/10/95
     67    1.1   mycroft  */
     68   1.72     lukem 
     69   1.72     lukem #include <sys/cdefs.h>
     70  1.177  perseant __KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.177 2006/05/01 19:47:29 perseant Exp $");
     71    1.1   mycroft 
     72  1.158  perseant #ifdef DEBUG
     73  1.158  perseant # define vndebug(vp, str) do {						\
     74  1.158  perseant 	if (VTOI(vp)->i_flag & IN_CLEANING)				\
     75  1.158  perseant 		DLOG((DLOG_WVNODE, "not writing ino %d because %s (op %d)\n", \
     76  1.158  perseant 		     VTOI(vp)->i_number, (str), op));			\
     77  1.158  perseant } while(0)
     78  1.158  perseant #else
     79  1.158  perseant # define vndebug(vp, str)
     80  1.158  perseant #endif
     81  1.158  perseant #define ivndebug(vp, str) \
     82  1.158  perseant 	DLOG((DLOG_WVNODE, "ino %d: %s\n", VTOI(vp)->i_number, (str)))
     83   1.16  perseant 
     84   1.68       mrg #if defined(_KERNEL_OPT)
     85   1.30  perseant #include "opt_ddb.h"
     86   1.65  jdolecek #endif
     87   1.65  jdolecek 
     88    1.1   mycroft #include <sys/param.h>
     89    1.1   mycroft #include <sys/systm.h>
     90    1.1   mycroft #include <sys/namei.h>
     91    1.1   mycroft #include <sys/kernel.h>
     92    1.1   mycroft #include <sys/resourcevar.h>
     93    1.1   mycroft #include <sys/file.h>
     94    1.1   mycroft #include <sys/stat.h>
     95    1.1   mycroft #include <sys/buf.h>
     96    1.1   mycroft #include <sys/proc.h>
     97    1.1   mycroft #include <sys/vnode.h>
     98    1.1   mycroft #include <sys/mount.h>
     99    1.1   mycroft 
    100    1.1   mycroft #include <miscfs/specfs/specdev.h>
    101    1.1   mycroft #include <miscfs/fifofs/fifo.h>
    102    1.1   mycroft 
    103    1.1   mycroft #include <ufs/ufs/inode.h>
    104    1.1   mycroft #include <ufs/ufs/dir.h>
    105    1.1   mycroft #include <ufs/ufs/ufsmount.h>
    106    1.1   mycroft #include <ufs/ufs/ufs_extern.h>
    107    1.1   mycroft 
    108    1.1   mycroft #include <ufs/lfs/lfs.h>
    109    1.1   mycroft #include <ufs/lfs/lfs_extern.h>
    110    1.1   mycroft 
    111   1.79  perseant #include <uvm/uvm.h>
    112   1.74  perseant #include <uvm/uvm_extern.h>
    113   1.99   thorpej 
    114   1.99   thorpej MALLOC_DEFINE(M_SEGMENT, "LFS segment", "Segment for LFS");
    115   1.74  perseant 
    116   1.69  perseant extern int count_lock_queue(void);
    117   1.10      fvdl extern struct simplelock vnode_free_list_slock;		/* XXX */
    118  1.132      yamt extern struct simplelock bqueue_slock;			/* XXX */
    119    1.1   mycroft 
    120   1.79  perseant static void lfs_generic_callback(struct buf *, void (*)(struct buf *));
    121   1.79  perseant static void lfs_super_aiodone(struct buf *);
    122   1.79  perseant static void lfs_cluster_aiodone(struct buf *);
    123   1.74  perseant static void lfs_cluster_callback(struct buf *);
    124   1.74  perseant 
    125    1.1   mycroft /*
    126    1.1   mycroft  * Determine if it's OK to start a partial in this segment, or if we need
    127    1.1   mycroft  * to go on to a new segment.
    128    1.1   mycroft  */
    129    1.1   mycroft #define	LFS_PARTIAL_FITS(fs) \
    130   1.69  perseant 	((fs)->lfs_fsbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \
    131   1.69  perseant 	fragstofsb((fs), (fs)->lfs_frag))
    132    1.1   mycroft 
    133  1.171  perseant /*
    134  1.171  perseant  * Figure out whether we should do a checkpoint write or go ahead with
    135  1.171  perseant  * an ordinary write.
    136  1.171  perseant  */
    137  1.171  perseant #define LFS_SHOULD_CHECKPOINT(fs, flags) \
    138  1.171  perseant 	(fs->lfs_nactive > LFS_MAX_ACTIVE ||				\
    139  1.171  perseant 	 (flags & SEGM_CKP) ||						\
    140  1.171  perseant 	 fs->lfs_nclean < LFS_MAX_ACTIVE)
    141  1.171  perseant 
    142   1.69  perseant int	 lfs_match_fake(struct lfs *, struct buf *);
    143   1.69  perseant void	 lfs_newseg(struct lfs *);
    144   1.91      fvdl /* XXX ondisk32 */
    145  1.104  perseant void	 lfs_shellsort(struct buf **, int32_t *, int, int);
    146   1.69  perseant void	 lfs_supercallback(struct buf *);
    147   1.69  perseant void	 lfs_updatemeta(struct segment *);
    148   1.69  perseant void	 lfs_writesuper(struct lfs *, daddr_t);
    149   1.69  perseant int	 lfs_writevnodes(struct lfs *fs, struct mount *mp,
    150   1.69  perseant 	    struct segment *sp, int dirops);
    151    1.1   mycroft 
    152    1.1   mycroft int	lfs_allclean_wakeup;		/* Cleaner wakeup address. */
    153  1.103  perseant int	lfs_writeindir = 1;		/* whether to flush indir on non-ckp */
    154   1.25  perseant int	lfs_clean_vnhead = 0;		/* Allow freeing to head of vn list */
    155   1.32  perseant int	lfs_dirvcount = 0;		/* # active dirops */
    156    1.1   mycroft 
    157    1.1   mycroft /* Statistics Counters */
    158   1.15  perseant int lfs_dostats = 1;
    159    1.1   mycroft struct lfs_stats lfs_stats;
    160    1.1   mycroft 
    161    1.1   mycroft /* op values to lfs_writevnodes */
    162  1.103  perseant #define	VN_REG		0
    163    1.1   mycroft #define	VN_DIROP	1
    164    1.1   mycroft #define	VN_EMPTY	2
    165  1.103  perseant #define VN_CLEAN	3
    166   1.15  perseant 
    167   1.15  perseant /*
    168   1.15  perseant  * XXX KS - Set modification time on the Ifile, so the cleaner can
    169   1.15  perseant  * read the fs mod time off of it.  We don't set IN_UPDATE here,
    170   1.15  perseant  * since we don't really need this to be flushed to disk (and in any
    171   1.15  perseant  * case that wouldn't happen to the Ifile until we checkpoint).
    172   1.15  perseant  */
    173   1.15  perseant void
    174   1.69  perseant lfs_imtime(struct lfs *fs)
    175   1.15  perseant {
    176   1.15  perseant 	struct timespec ts;
    177   1.15  perseant 	struct inode *ip;
    178  1.157     perry 
    179  1.159  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    180  1.167      yamt 	nanotime(&ts);
    181   1.15  perseant 	ip = VTOI(fs->lfs_ivnode);
    182  1.119      fvdl 	ip->i_ffs1_mtime = ts.tv_sec;
    183  1.119      fvdl 	ip->i_ffs1_mtimensec = ts.tv_nsec;
    184   1.15  perseant }
    185    1.1   mycroft 
    186    1.1   mycroft /*
    187    1.1   mycroft  * Ifile and meta data blocks are not marked busy, so segment writes MUST be
    188    1.1   mycroft  * single threaded.  Currently, there are two paths into lfs_segwrite, sync()
    189    1.1   mycroft  * and getnewbuf().  They both mark the file system busy.  Lfs_vflush()
    190    1.1   mycroft  * explicitly marks the file system busy.  So lfs_segwrite is safe.  I think.
    191    1.1   mycroft  */
    192    1.1   mycroft 
    193   1.15  perseant #define IS_FLUSHING(fs,vp)  ((fs)->lfs_flushvp == (vp))
    194   1.15  perseant 
    195    1.1   mycroft int
    196   1.69  perseant lfs_vflush(struct vnode *vp)
    197    1.1   mycroft {
    198    1.1   mycroft 	struct inode *ip;
    199    1.1   mycroft 	struct lfs *fs;
    200    1.1   mycroft 	struct segment *sp;
    201   1.38  perseant 	struct buf *bp, *nbp, *tbp, *tnbp;
    202   1.30  perseant 	int error, s;
    203  1.101  perseant 	int flushed;
    204  1.171  perseant 	int relock;
    205   1.19  perseant 
    206   1.22  perseant 	ip = VTOI(vp);
    207   1.22  perseant 	fs = VFSTOUFS(vp->v_mount)->um_lfs;
    208  1.171  perseant 	relock = 0;
    209   1.22  perseant 
    210  1.171  perseant     top:
    211  1.159  perseant 	ASSERT_NO_SEGLOCK(fs);
    212   1.73       chs 	if (ip->i_flag & IN_CLEANING) {
    213   1.19  perseant 		ivndebug(vp,"vflush/in_cleaning");
    214   1.56  perseant 		LFS_CLR_UINO(ip, IN_CLEANING);
    215   1.56  perseant 		LFS_SET_UINO(ip, IN_MODIFIED);
    216   1.56  perseant 
    217   1.38  perseant 		/*
    218   1.38  perseant 		 * Toss any cleaning buffers that have real counterparts
    219  1.101  perseant 		 * to avoid losing new data.
    220   1.38  perseant 		 */
    221   1.38  perseant 		s = splbio();
    222   1.75  perseant 		for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
    223   1.75  perseant 			nbp = LIST_NEXT(bp, b_vnbufs);
    224  1.101  perseant 			if (!LFS_IS_MALLOC_BUF(bp))
    225  1.101  perseant 				continue;
    226  1.101  perseant 			/*
    227  1.106  perseant 			 * Look for pages matching the range covered
    228  1.106  perseant 			 * by cleaning blocks.  It's okay if more dirty
    229  1.106  perseant 			 * pages appear, so long as none disappear out
    230  1.106  perseant 			 * from under us.
    231  1.101  perseant 			 */
    232  1.101  perseant 			if (bp->b_lblkno > 0 && vp->v_type == VREG &&
    233  1.101  perseant 			    vp != fs->lfs_ivnode) {
    234  1.101  perseant 				struct vm_page *pg;
    235  1.101  perseant 				voff_t off;
    236  1.101  perseant 
    237  1.106  perseant 				simple_lock(&vp->v_interlock);
    238  1.101  perseant 				for (off = lblktosize(fs, bp->b_lblkno);
    239  1.101  perseant 				     off < lblktosize(fs, bp->b_lblkno + 1);
    240  1.101  perseant 				     off += PAGE_SIZE) {
    241  1.101  perseant 					pg = uvm_pagelookup(&vp->v_uobj, off);
    242  1.106  perseant 					if (pg == NULL)
    243  1.106  perseant 						continue;
    244  1.106  perseant 					if ((pg->flags & PG_CLEAN) == 0 ||
    245  1.106  perseant 					    pmap_is_modified(pg)) {
    246  1.101  perseant 						fs->lfs_avail += btofsb(fs,
    247  1.101  perseant 							bp->b_bcount);
    248   1.62  perseant 						wakeup(&fs->lfs_avail);
    249  1.101  perseant 						lfs_freebuf(fs, bp);
    250   1.69  perseant 						bp = NULL;
    251  1.173  perseant 						simple_unlock(&vp->v_interlock);
    252  1.101  perseant 						goto nextbp;
    253   1.38  perseant 					}
    254   1.38  perseant 				}
    255  1.106  perseant 				simple_unlock(&vp->v_interlock);
    256   1.38  perseant 			}
    257  1.101  perseant 			for (tbp = LIST_FIRST(&vp->v_dirtyblkhd); tbp;
    258  1.101  perseant 			    tbp = tnbp)
    259  1.101  perseant 			{
    260  1.101  perseant 				tnbp = LIST_NEXT(tbp, b_vnbufs);
    261  1.101  perseant 				if (tbp->b_vp == bp->b_vp
    262  1.101  perseant 				   && tbp->b_lblkno == bp->b_lblkno
    263  1.101  perseant 				   && tbp != bp)
    264  1.101  perseant 				{
    265  1.101  perseant 					fs->lfs_avail += btofsb(fs,
    266  1.101  perseant 						bp->b_bcount);
    267  1.101  perseant 					wakeup(&fs->lfs_avail);
    268  1.101  perseant 					lfs_freebuf(fs, bp);
    269  1.101  perseant 					bp = NULL;
    270  1.101  perseant 					break;
    271  1.101  perseant 				}
    272  1.101  perseant 			}
    273  1.101  perseant 		    nextbp:
    274  1.110  kristerw 			;
    275   1.38  perseant 		}
    276   1.38  perseant 		splx(s);
    277   1.19  perseant 	}
    278   1.19  perseant 
    279   1.19  perseant 	/* If the node is being written, wait until that is done */
    280  1.159  perseant 	simple_lock(&vp->v_interlock);
    281   1.74  perseant 	s = splbio();
    282   1.73       chs 	if (WRITEINPROG(vp)) {
    283   1.19  perseant 		ivndebug(vp,"vflush/writeinprog");
    284  1.159  perseant 		ltsleep(vp, (PRIBIO+1), "lfs_vw", 0, &vp->v_interlock);
    285   1.19  perseant 	}
    286   1.74  perseant 	splx(s);
    287  1.159  perseant 	simple_unlock(&vp->v_interlock);
    288    1.1   mycroft 
    289   1.15  perseant 	/* Protect against VXLOCK deadlock in vinvalbuf() */
    290    1.1   mycroft 	lfs_seglock(fs, SEGM_SYNC);
    291   1.30  perseant 
    292   1.30  perseant 	/* If we're supposed to flush a freed inode, just toss it */
    293   1.30  perseant 	/* XXX - seglock, so these buffers can't be gathered, right? */
    294  1.119      fvdl 	if (ip->i_mode == 0) {
    295  1.158  perseant 		DLOG((DLOG_VNODE, "lfs_vflush: ino %d freed, not flushing\n",
    296  1.158  perseant 		      ip->i_number));
    297   1.30  perseant 		s = splbio();
    298   1.75  perseant 		for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
    299   1.75  perseant 			nbp = LIST_NEXT(bp, b_vnbufs);
    300   1.62  perseant 			if (bp->b_flags & B_DELWRI) { /* XXX always true? */
    301   1.69  perseant 				fs->lfs_avail += btofsb(fs, bp->b_bcount);
    302   1.62  perseant 				wakeup(&fs->lfs_avail);
    303   1.62  perseant 			}
    304   1.30  perseant 			/* Copied from lfs_writeseg */
    305   1.30  perseant 			if (bp->b_flags & B_CALL) {
    306  1.101  perseant 				biodone(bp);
    307   1.30  perseant 			} else {
    308   1.30  perseant 				bremfree(bp);
    309   1.62  perseant 				LFS_UNLOCK_BUF(bp);
    310   1.30  perseant 				bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI |
    311  1.103  perseant 					 B_GATHERED);
    312   1.30  perseant 				bp->b_flags |= B_DONE;
    313   1.30  perseant 				reassignbuf(bp, vp);
    314  1.157     perry 				brelse(bp);
    315   1.30  perseant 			}
    316   1.30  perseant 		}
    317   1.30  perseant 		splx(s);
    318   1.56  perseant 		LFS_CLR_UINO(ip, IN_CLEANING);
    319   1.56  perseant 		LFS_CLR_UINO(ip, IN_MODIFIED | IN_ACCESSED);
    320   1.47  perseant 		ip->i_flag &= ~IN_ALLMOD;
    321  1.158  perseant 		DLOG((DLOG_VNODE, "lfs_vflush: done not flushing ino %d\n",
    322  1.158  perseant 		      ip->i_number));
    323   1.30  perseant 		lfs_segunlock(fs);
    324   1.30  perseant 		return 0;
    325   1.30  perseant 	}
    326   1.30  perseant 
    327  1.173  perseant 	fs->lfs_flushvp = vp;
    328  1.171  perseant 	if (LFS_SHOULD_CHECKPOINT(fs, fs->lfs_sp->seg_flags)) {
    329   1.79  perseant 		error = lfs_segwrite(vp->v_mount, SEGM_CKP | SEGM_SYNC);
    330  1.173  perseant 		fs->lfs_flushvp = NULL;
    331  1.173  perseant 		KASSERT(fs->lfs_flushvp_fakevref == 0);
    332   1.15  perseant 		lfs_segunlock(fs);
    333   1.15  perseant 		return error;
    334   1.15  perseant 	}
    335    1.1   mycroft 	sp = fs->lfs_sp;
    336    1.1   mycroft 
    337  1.101  perseant 	flushed = 0;
    338  1.101  perseant 	if (VPISEMPTY(vp)) {
    339    1.1   mycroft 		lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY);
    340  1.101  perseant 		++flushed;
    341   1.73       chs 	} else if ((ip->i_flag & IN_CLEANING) &&
    342   1.58  perseant 		  (fs->lfs_sp->seg_flags & SEGM_CLEAN)) {
    343   1.19  perseant 		ivndebug(vp,"vflush/clean");
    344   1.19  perseant 		lfs_writevnodes(fs, vp->v_mount, sp, VN_CLEAN);
    345  1.101  perseant 		++flushed;
    346   1.74  perseant 	} else if (lfs_dostats) {
    347  1.101  perseant 		if (!VPISEMPTY(vp) || (VTOI(vp)->i_flag & IN_ALLMOD))
    348   1.15  perseant 			++lfs_stats.vflush_invoked;
    349   1.19  perseant 		ivndebug(vp,"vflush");
    350   1.15  perseant 	}
    351   1.15  perseant 
    352   1.19  perseant #ifdef DIAGNOSTIC
    353   1.73       chs 	if (vp->v_flag & VDIROP) {
    354  1.158  perseant 		DLOG((DLOG_VNODE, "lfs_vflush: flushing VDIROP\n"));
    355  1.158  perseant 		/* panic("lfs_vflush: VDIROP being flushed...this can\'t happen"); */
    356   1.19  perseant 	}
    357   1.73       chs 	if (vp->v_usecount < 0) {
    358   1.69  perseant 		printf("usecount=%ld\n", (long)vp->v_usecount);
    359   1.19  perseant 		panic("lfs_vflush: usecount<0");
    360   1.19  perseant 	}
    361   1.15  perseant #endif
    362    1.1   mycroft 
    363    1.1   mycroft 	do {
    364    1.1   mycroft 		do {
    365  1.171  perseant 			if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL) {
    366  1.171  perseant 				relock = lfs_writefile(fs, sp, vp);
    367  1.171  perseant 				if (relock) {
    368  1.171  perseant 					/*
    369  1.171  perseant 					 * Might have to wait for the
    370  1.171  perseant 					 * cleaner to run; but we're
    371  1.171  perseant 					 * still not done with this vnode.
    372  1.171  perseant 					 */
    373  1.176  perseant 					lfs_writeinode(fs, sp, ip);
    374  1.176  perseant 					LFS_SET_UINO(ip, IN_MODIFIED);
    375  1.171  perseant 					lfs_writeseg(fs, sp);
    376  1.171  perseant 					lfs_segunlock(fs);
    377  1.171  perseant 					lfs_segunlock_relock(fs);
    378  1.171  perseant 					goto top;
    379  1.171  perseant 				}
    380  1.171  perseant 			}
    381  1.174  perseant 			/*
    382  1.174  perseant 			 * If we begin a new segment in the middle of writing
    383  1.174  perseant 			 * the Ifile, it creates an inconsistent checkpoint,
    384  1.174  perseant 			 * since the Ifile information for the new segment
    385  1.174  perseant 			 * is not up-to-date.  Take care of this here by
    386  1.174  perseant 			 * sending the Ifile through again in case there
    387  1.174  perseant 			 * are newly dirtied blocks.  But wait, there's more!
    388  1.174  perseant 			 * This second Ifile write could *also* cross a segment
    389  1.174  perseant 			 * boundary, if the first one was large.  The second
    390  1.174  perseant 			 * one is guaranteed to be no more than 8 blocks,
    391  1.174  perseant 			 * though (two segment blocks and supporting indirects)
    392  1.174  perseant 			 * so the third write *will not* cross the boundary.
    393  1.174  perseant 			 */
    394  1.174  perseant 			if (vp == fs->lfs_ivnode) {
    395  1.174  perseant 				lfs_writefile(fs, sp, vp);
    396  1.174  perseant 				lfs_writefile(fs, sp, vp);
    397  1.174  perseant 			}
    398    1.1   mycroft 		} while (lfs_writeinode(fs, sp, ip));
    399    1.1   mycroft 	} while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM);
    400  1.171  perseant 
    401   1.73       chs 	if (lfs_dostats) {
    402   1.15  perseant 		++lfs_stats.nwrites;
    403   1.15  perseant 		if (sp->seg_flags & SEGM_SYNC)
    404   1.15  perseant 			++lfs_stats.nsync_writes;
    405   1.15  perseant 		if (sp->seg_flags & SEGM_CKP)
    406   1.15  perseant 			++lfs_stats.ncheckpoints;
    407   1.15  perseant 	}
    408   1.74  perseant 	/*
    409   1.74  perseant 	 * If we were called from somewhere that has already held the seglock
    410   1.74  perseant 	 * (e.g., lfs_markv()), the lfs_segunlock will not wait for
    411   1.74  perseant 	 * the write to complete because we are still locked.
    412   1.74  perseant 	 * Since lfs_vflush() must return the vnode with no dirty buffers,
    413   1.74  perseant 	 * we must explicitly wait, if that is the case.
    414   1.74  perseant 	 *
    415   1.74  perseant 	 * We compare the iocount against 1, not 0, because it is
    416   1.74  perseant 	 * artificially incremented by lfs_seglock().
    417   1.74  perseant 	 */
    418  1.111  perseant 	simple_lock(&fs->lfs_interlock);
    419   1.74  perseant 	if (fs->lfs_seglock > 1) {
    420   1.74  perseant 		while (fs->lfs_iocount > 1)
    421  1.159  perseant 			(void)ltsleep(&fs->lfs_iocount, PRIBIO + 1,
    422  1.159  perseant 				     "lfs_vflush", 0, &fs->lfs_interlock);
    423  1.159  perseant 	}
    424  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
    425  1.111  perseant 
    426   1.15  perseant 	lfs_segunlock(fs);
    427    1.1   mycroft 
    428  1.120  perseant 	/* Wait for these buffers to be recovered by aiodoned */
    429  1.120  perseant 	s = splbio();
    430  1.120  perseant 	simple_lock(&global_v_numoutput_slock);
    431  1.120  perseant 	while (vp->v_numoutput > 0) {
    432  1.146      yamt 		vp->v_flag |= VBWAIT;
    433  1.120  perseant 		ltsleep(&vp->v_numoutput, PRIBIO + 1, "lfs_vf2", 0,
    434  1.120  perseant 			&global_v_numoutput_slock);
    435  1.120  perseant 	}
    436  1.120  perseant 	simple_unlock(&global_v_numoutput_slock);
    437  1.120  perseant 	splx(s);
    438  1.120  perseant 
    439  1.173  perseant 	fs->lfs_flushvp = NULL;
    440  1.173  perseant 	KASSERT(fs->lfs_flushvp_fakevref == 0);
    441  1.173  perseant 
    442    1.1   mycroft 	return (0);
    443    1.1   mycroft }
    444    1.1   mycroft 
    445   1.15  perseant int
    446   1.69  perseant lfs_writevnodes(struct lfs *fs, struct mount *mp, struct segment *sp, int op)
    447    1.1   mycroft {
    448    1.1   mycroft 	struct inode *ip;
    449   1.77  perseant 	struct vnode *vp, *nvp;
    450   1.73       chs 	int inodes_written = 0, only_cleaning;
    451  1.171  perseant 	int error = 0;
    452    1.1   mycroft 
    453  1.159  perseant 	ASSERT_SEGLOCK(fs);
    454   1.15  perseant #ifndef LFS_NO_BACKVP_HACK
    455   1.15  perseant 	/* BEGIN HACK */
    456  1.128      yamt #define	VN_OFFSET	\
    457  1.128      yamt 	(((caddr_t)&LIST_NEXT(vp, v_mntvnodes)) - (caddr_t)vp)
    458  1.128      yamt #define	BACK_VP(VP)	\
    459  1.128      yamt 	((struct vnode *)(((caddr_t)(VP)->v_mntvnodes.le_prev) - VN_OFFSET))
    460  1.128      yamt #define	BEG_OF_VLIST	\
    461  1.128      yamt 	((struct vnode *)(((caddr_t)&LIST_FIRST(&mp->mnt_vnodelist)) \
    462  1.128      yamt 	- VN_OFFSET))
    463  1.157     perry 
    464   1.15  perseant 	/* Find last vnode. */
    465   1.75  perseant  loop:	for (vp = LIST_FIRST(&mp->mnt_vnodelist);
    466   1.75  perseant 	     vp && LIST_NEXT(vp, v_mntvnodes) != NULL;
    467   1.75  perseant 	     vp = LIST_NEXT(vp, v_mntvnodes));
    468   1.77  perseant 	for (; vp && vp != BEG_OF_VLIST; vp = nvp) {
    469   1.77  perseant 		nvp = BACK_VP(vp);
    470   1.15  perseant #else
    471   1.15  perseant 	loop:
    472   1.77  perseant 	for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
    473   1.77  perseant 		nvp = LIST_NEXT(vp, v_mntvnodes);
    474   1.15  perseant #endif
    475    1.1   mycroft 		/*
    476    1.1   mycroft 		 * If the vnode that we are about to sync is no longer
    477    1.1   mycroft 		 * associated with this mount point, start over.
    478    1.1   mycroft 		 */
    479   1.58  perseant 		if (vp->v_mount != mp) {
    480  1.158  perseant 			DLOG((DLOG_VNODE, "lfs_writevnodes: starting over\n"));
    481  1.113      yamt 			/*
    482  1.113      yamt 			 * After this, pages might be busy
    483  1.113      yamt 			 * due to our own previous putpages.
    484  1.113      yamt 			 * Start actual segment write here to avoid deadlock.
    485  1.113      yamt 			 */
    486  1.113      yamt 			(void)lfs_writeseg(fs, sp);
    487    1.1   mycroft 			goto loop;
    488   1.58  perseant 		}
    489  1.157     perry 
    490   1.85      yamt 		if (vp->v_type == VNON) {
    491   1.85      yamt 			continue;
    492   1.85      yamt 		}
    493    1.1   mycroft 
    494   1.15  perseant 		ip = VTOI(vp);
    495   1.15  perseant 		if ((op == VN_DIROP && !(vp->v_flag & VDIROP)) ||
    496  1.128      yamt 		    (op != VN_DIROP && op != VN_CLEAN &&
    497  1.128      yamt 		    (vp->v_flag & VDIROP))) {
    498   1.15  perseant 			vndebug(vp,"dirop");
    499   1.15  perseant 			continue;
    500   1.15  perseant 		}
    501  1.157     perry 
    502  1.101  perseant 		if (op == VN_EMPTY && !VPISEMPTY(vp)) {
    503   1.15  perseant 			vndebug(vp,"empty");
    504   1.15  perseant 			continue;
    505   1.15  perseant 		}
    506    1.1   mycroft 
    507   1.73       chs 		if (op == VN_CLEAN && ip->i_number != LFS_IFILE_INUM
    508   1.38  perseant 		   && vp != fs->lfs_flushvp
    509   1.15  perseant 		   && !(ip->i_flag & IN_CLEANING)) {
    510   1.15  perseant 			vndebug(vp,"cleaning");
    511    1.1   mycroft 			continue;
    512   1.15  perseant 		}
    513    1.1   mycroft 
    514   1.15  perseant 		if (lfs_vref(vp)) {
    515   1.15  perseant 			vndebug(vp,"vref");
    516    1.1   mycroft 			continue;
    517   1.15  perseant 		}
    518    1.1   mycroft 
    519   1.23  perseant 		only_cleaning = 0;
    520    1.1   mycroft 		/*
    521   1.55  perseant 		 * Write the inode/file if dirty and it's not the IFILE.
    522    1.1   mycroft 		 */
    523  1.101  perseant 		if ((ip->i_flag & IN_ALLMOD) || !VPISEMPTY(vp)) {
    524  1.128      yamt 			only_cleaning =
    525  1.128      yamt 			    ((ip->i_flag & IN_ALLMOD) == IN_CLEANING);
    526   1.20  perseant 
    527  1.159  perseant 			if (ip->i_number != LFS_IFILE_INUM) {
    528  1.171  perseant 				error = lfs_writefile(fs, sp, vp);
    529  1.171  perseant 				if (error) {
    530  1.171  perseant 					lfs_vunref(vp);
    531  1.171  perseant 					if (error == EAGAIN) {
    532  1.171  perseant 						/*
    533  1.171  perseant 						 * This error from lfs_putpages
    534  1.171  perseant 						 * indicates we need to drop
    535  1.171  perseant 						 * the segment lock and start
    536  1.171  perseant 						 * over after the cleaner has
    537  1.171  perseant 						 * had a chance to run.
    538  1.171  perseant 						 */
    539  1.176  perseant 						lfs_writeinode(fs, sp, ip);
    540  1.171  perseant 						lfs_writeseg(fs, sp);
    541  1.172  perseant 						if (!VPISEMPTY(vp) &&
    542  1.172  perseant 						    !WRITEINPROG(vp) &&
    543  1.172  perseant 						    !(ip->i_flag & IN_ALLMOD))
    544  1.172  perseant 							LFS_SET_UINO(ip, IN_MODIFIED);
    545  1.171  perseant 						break;
    546  1.171  perseant 					}
    547  1.171  perseant 					error = 0; /* XXX not quite right */
    548  1.171  perseant 					continue;
    549  1.171  perseant 				}
    550  1.171  perseant 
    551  1.159  perseant 				if (!VPISEMPTY(vp)) {
    552  1.159  perseant 					if (WRITEINPROG(vp)) {
    553  1.159  perseant 						ivndebug(vp,"writevnodes/write2");
    554  1.159  perseant 					} else if (!(ip->i_flag & IN_ALLMOD)) {
    555  1.159  perseant 						LFS_SET_UINO(ip, IN_MODIFIED);
    556  1.159  perseant 					}
    557   1.15  perseant 				}
    558  1.159  perseant 				(void) lfs_writeinode(fs, sp, ip);
    559  1.159  perseant 				inodes_written++;
    560   1.15  perseant 			}
    561   1.15  perseant 		}
    562   1.43  perseant 
    563   1.52  perseant 		if (lfs_clean_vnhead && only_cleaning)
    564   1.20  perseant 			lfs_vunref_head(vp);
    565   1.20  perseant 		else
    566   1.20  perseant 			lfs_vunref(vp);
    567    1.1   mycroft 	}
    568  1.171  perseant 	return error;
    569    1.1   mycroft }
    570    1.1   mycroft 
    571   1.69  perseant /*
    572   1.69  perseant  * Do a checkpoint.
    573   1.69  perseant  */
    574    1.1   mycroft int
    575   1.69  perseant lfs_segwrite(struct mount *mp, int flags)
    576    1.1   mycroft {
    577    1.1   mycroft 	struct buf *bp;
    578    1.1   mycroft 	struct inode *ip;
    579    1.1   mycroft 	struct lfs *fs;
    580    1.1   mycroft 	struct segment *sp;
    581    1.1   mycroft 	struct vnode *vp;
    582    1.1   mycroft 	SEGUSE *segusep;
    583  1.117      fvdl 	int do_ckp, did_ckp, error, s;
    584  1.117      fvdl 	unsigned n, segleft, maxseg, sn, i, curseg;
    585   1.15  perseant 	int writer_set = 0;
    586   1.61  perseant 	int dirty;
    587   1.74  perseant 	int redo;
    588  1.171  perseant 	int um_error;
    589  1.157     perry 
    590    1.1   mycroft 	fs = VFSTOUFS(mp)->um_lfs;
    591  1.159  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
    592    1.1   mycroft 
    593   1.53  perseant 	if (fs->lfs_ronly)
    594   1.53  perseant 		return EROFS;
    595   1.53  perseant 
    596   1.15  perseant 	lfs_imtime(fs);
    597   1.58  perseant 
    598    1.1   mycroft 	/*
    599    1.1   mycroft 	 * Allocate a segment structure and enough space to hold pointers to
    600    1.1   mycroft 	 * the maximum possible number of buffers which can be described in a
    601    1.1   mycroft 	 * single summary block.
    602    1.1   mycroft 	 */
    603  1.171  perseant 	do_ckp = LFS_SHOULD_CHECKPOINT(fs, flags);
    604  1.171  perseant 
    605    1.1   mycroft 	lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0));
    606    1.1   mycroft 	sp = fs->lfs_sp;
    607    1.1   mycroft 
    608   1.15  perseant 	/*
    609   1.16  perseant 	 * If lfs_flushvp is non-NULL, we are called from lfs_vflush,
    610   1.16  perseant 	 * in which case we have to flush *all* buffers off of this vnode.
    611   1.37  perseant 	 * We don't care about other nodes, but write any non-dirop nodes
    612   1.37  perseant 	 * anyway in anticipation of another getnewvnode().
    613   1.37  perseant 	 *
    614   1.37  perseant 	 * If we're cleaning we only write cleaning and ifile blocks, and
    615   1.37  perseant 	 * no dirops, since otherwise we'd risk corruption in a crash.
    616   1.15  perseant 	 */
    617   1.73       chs 	if (sp->seg_flags & SEGM_CLEAN)
    618   1.15  perseant 		lfs_writevnodes(fs, mp, sp, VN_CLEAN);
    619  1.105  perseant 	else if (!(sp->seg_flags & SEGM_FORCE_CKP)) {
    620  1.171  perseant 		do {
    621  1.171  perseant 			um_error = lfs_writevnodes(fs, mp, sp, VN_REG);
    622  1.171  perseant 			if (!fs->lfs_dirops || !fs->lfs_flushvp) {
    623  1.171  perseant 				if (!writer_set) {
    624  1.171  perseant 					lfs_writer_enter(fs, "lfs writer");
    625  1.171  perseant 					writer_set = 1;
    626  1.171  perseant 				}
    627  1.171  perseant 				error = lfs_writevnodes(fs, mp, sp, VN_DIROP);
    628  1.171  perseant 				if (um_error == 0)
    629  1.171  perseant 					um_error = error;
    630  1.177  perseant 				/* In case writevnodes errored out */
    631  1.177  perseant 				lfs_flush_dirops(fs);
    632  1.171  perseant 				((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
    633  1.176  perseant 				lfs_finalize_fs_seguse(fs);
    634  1.171  perseant 			}
    635  1.171  perseant 			if (do_ckp && um_error) {
    636  1.171  perseant 				lfs_segunlock_relock(fs);
    637  1.171  perseant 				sp = fs->lfs_sp;
    638  1.171  perseant 			}
    639  1.171  perseant 		} while (do_ckp && um_error != 0);
    640  1.157     perry 	}
    641    1.1   mycroft 
    642    1.1   mycroft 	/*
    643    1.1   mycroft 	 * If we are doing a checkpoint, mark everything since the
    644    1.1   mycroft 	 * last checkpoint as no longer ACTIVE.
    645    1.1   mycroft 	 */
    646   1.15  perseant 	if (do_ckp) {
    647  1.117      fvdl 		segleft = fs->lfs_nseg;
    648  1.117      fvdl 		curseg = 0;
    649  1.117      fvdl 		for (n = 0; n < fs->lfs_segtabsz; n++) {
    650   1.61  perseant 			dirty = 0;
    651  1.157     perry 			if (bread(fs->lfs_ivnode,
    652  1.117      fvdl 			    fs->lfs_cleansz + n, fs->lfs_bsize, NOCRED, &bp))
    653   1.15  perseant 				panic("lfs_segwrite: ifile read");
    654    1.1   mycroft 			segusep = (SEGUSE *)bp->b_data;
    655  1.117      fvdl 			maxseg = min(segleft, fs->lfs_sepb);
    656  1.117      fvdl 			for (i = 0; i < maxseg; i++) {
    657  1.117      fvdl 				sn = curseg + i;
    658  1.134      yamt 				if (sn != dtosn(fs, fs->lfs_curseg) &&
    659  1.117      fvdl 				    segusep->su_flags & SEGUSE_ACTIVE) {
    660   1.61  perseant 					segusep->su_flags &= ~SEGUSE_ACTIVE;
    661  1.105  perseant 					--fs->lfs_nactive;
    662   1.61  perseant 					++dirty;
    663   1.61  perseant 				}
    664  1.105  perseant 				fs->lfs_suflags[fs->lfs_activesb][sn] =
    665  1.105  perseant 					segusep->su_flags;
    666   1.69  perseant 				if (fs->lfs_version > 1)
    667   1.69  perseant 					++segusep;
    668   1.69  perseant 				else
    669   1.69  perseant 					segusep = (SEGUSE *)
    670   1.69  perseant 						((SEGUSE_V1 *)segusep + 1);
    671   1.61  perseant 			}
    672  1.157     perry 
    673   1.61  perseant 			if (dirty)
    674   1.74  perseant 				error = LFS_BWRITE_LOG(bp); /* Ifile */
    675   1.61  perseant 			else
    676   1.61  perseant 				brelse(bp);
    677  1.117      fvdl 			segleft -= fs->lfs_sepb;
    678  1.117      fvdl 			curseg += fs->lfs_sepb;
    679    1.1   mycroft 		}
    680   1.15  perseant 	}
    681   1.61  perseant 
    682  1.159  perseant 	LOCK_ASSERT(LFS_SEGLOCK_HELD(fs));
    683  1.159  perseant 
    684   1.61  perseant 	did_ckp = 0;
    685    1.1   mycroft 	if (do_ckp || fs->lfs_doifile) {
    686  1.159  perseant 		vp = fs->lfs_ivnode;
    687  1.159  perseant 		vn_lock(vp, LK_EXCLUSIVE);
    688   1.63  perseant 		do {
    689   1.74  perseant #ifdef DEBUG
    690  1.159  perseant 			LFS_ENTER_LOG("pretend", __FILE__, __LINE__, 0, 0, curproc->p_pid);
    691   1.74  perseant #endif
    692  1.159  perseant 			simple_lock(&fs->lfs_interlock);
    693   1.74  perseant 			fs->lfs_flags &= ~LFS_IFDIRTY;
    694  1.159  perseant 			simple_unlock(&fs->lfs_interlock);
    695   1.55  perseant 
    696   1.63  perseant 			ip = VTOI(vp);
    697  1.101  perseant 
    698  1.171  perseant 			if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL) {
    699  1.171  perseant 				/*
    700  1.171  perseant 				 * Ifile has no pages, so we don't need
    701  1.171  perseant 				 * to check error return here.
    702  1.171  perseant 				 */
    703   1.63  perseant 				lfs_writefile(fs, sp, vp);
    704  1.174  perseant 				/*
    705  1.174  perseant 				 * Ensure the Ifile takes the current segment
    706  1.174  perseant 				 * into account.  See comment in lfs_vflush.
    707  1.174  perseant 				 */
    708  1.174  perseant 				lfs_writefile(fs, sp, vp);
    709  1.174  perseant 				lfs_writefile(fs, sp, vp);
    710  1.171  perseant 			}
    711  1.101  perseant 
    712   1.63  perseant 			if (ip->i_flag & IN_ALLMOD)
    713   1.63  perseant 				++did_ckp;
    714   1.74  perseant 			redo = lfs_writeinode(fs, sp, ip);
    715  1.101  perseant 			redo += lfs_writeseg(fs, sp);
    716  1.159  perseant 			simple_lock(&fs->lfs_interlock);
    717   1.74  perseant 			redo += (fs->lfs_flags & LFS_IFDIRTY);
    718  1.159  perseant 			simple_unlock(&fs->lfs_interlock);
    719  1.112  perseant 		} while (redo && do_ckp);
    720  1.112  perseant 
    721  1.112  perseant 		/*
    722  1.112  perseant 		 * Unless we are unmounting, the Ifile may continue to have
    723  1.112  perseant 		 * dirty blocks even after a checkpoint, due to changes to
    724  1.112  perseant 		 * inodes' atime.  If we're checkpointing, it's "impossible"
    725  1.112  perseant 		 * for other parts of the Ifile to be dirty after the loop
    726  1.112  perseant 		 * above, since we hold the segment lock.
    727  1.112  perseant 		 */
    728  1.114  perseant 		s = splbio();
    729  1.112  perseant 		if (LIST_EMPTY(&vp->v_dirtyblkhd)) {
    730  1.112  perseant 			LFS_CLR_UINO(ip, IN_ALLMOD);
    731  1.112  perseant 		}
    732  1.112  perseant #ifdef DIAGNOSTIC
    733  1.112  perseant 		else if (do_ckp) {
    734  1.159  perseant 			int do_panic = 0;
    735  1.112  perseant 			LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
    736  1.112  perseant 				if (bp->b_lblkno < fs->lfs_cleansz +
    737  1.112  perseant 				    fs->lfs_segtabsz &&
    738  1.112  perseant 				    !(bp->b_flags & B_GATHERED)) {
    739  1.159  perseant 					printf("ifile lbn %ld still dirty (flags %lx)\n",
    740  1.159  perseant 						(long)bp->b_lblkno,
    741  1.159  perseant 						(long)bp->b_flags);
    742  1.159  perseant 					++do_panic;
    743   1.74  perseant 				}
    744   1.74  perseant 			}
    745  1.159  perseant 			if (do_panic)
    746  1.159  perseant 				panic("dirty blocks");
    747   1.74  perseant 		}
    748  1.112  perseant #endif
    749  1.114  perseant 		splx(s);
    750  1.159  perseant 		VOP_UNLOCK(vp, 0);
    751   1.15  perseant 	} else {
    752    1.1   mycroft 		(void) lfs_writeseg(fs, sp);
    753   1.15  perseant 	}
    754  1.157     perry 
    755  1.112  perseant 	/* Note Ifile no longer needs to be written */
    756  1.112  perseant 	fs->lfs_doifile = 0;
    757  1.125      yamt 	if (writer_set)
    758  1.125      yamt 		lfs_writer_leave(fs);
    759   1.61  perseant 
    760   1.61  perseant 	/*
    761   1.61  perseant 	 * If we didn't write the Ifile, we didn't really do anything.
    762   1.61  perseant 	 * That means that (1) there is a checkpoint on disk and (2)
    763   1.61  perseant 	 * nothing has changed since it was written.
    764   1.61  perseant 	 *
    765   1.61  perseant 	 * Take the flags off of the segment so that lfs_segunlock
    766   1.61  perseant 	 * doesn't have to write the superblock either.
    767   1.61  perseant 	 */
    768   1.79  perseant 	if (do_ckp && !did_ckp) {
    769   1.79  perseant 		sp->seg_flags &= ~SEGM_CKP;
    770   1.61  perseant 	}
    771   1.61  perseant 
    772   1.73       chs 	if (lfs_dostats) {
    773   1.15  perseant 		++lfs_stats.nwrites;
    774   1.15  perseant 		if (sp->seg_flags & SEGM_SYNC)
    775   1.15  perseant 			++lfs_stats.nsync_writes;
    776   1.15  perseant 		if (sp->seg_flags & SEGM_CKP)
    777   1.15  perseant 			++lfs_stats.ncheckpoints;
    778   1.15  perseant 	}
    779    1.1   mycroft 	lfs_segunlock(fs);
    780    1.1   mycroft 	return (0);
    781    1.1   mycroft }
    782    1.1   mycroft 
    783    1.1   mycroft /*
    784    1.1   mycroft  * Write the dirty blocks associated with a vnode.
    785    1.1   mycroft  */
    786  1.171  perseant int
    787   1.69  perseant lfs_writefile(struct lfs *fs, struct segment *sp, struct vnode *vp)
    788    1.1   mycroft {
    789    1.1   mycroft 	struct buf *bp;
    790    1.1   mycroft 	struct finfo *fip;
    791   1.80  perseant 	struct inode *ip;
    792    1.1   mycroft 	IFILE *ifp;
    793   1.80  perseant 	int i, frag;
    794  1.171  perseant 	int error;
    795  1.157     perry 
    796  1.159  perseant 	ASSERT_SEGLOCK(fs);
    797  1.171  perseant 	error = 0;
    798   1.80  perseant 	ip = VTOI(vp);
    799   1.80  perseant 
    800    1.1   mycroft 	if (sp->seg_bytes_left < fs->lfs_bsize ||
    801    1.1   mycroft 	    sp->sum_bytes_left < sizeof(struct finfo))
    802    1.1   mycroft 		(void) lfs_writeseg(fs, sp);
    803  1.157     perry 
    804   1.98      yamt 	sp->sum_bytes_left -= FINFOSIZE;
    805    1.1   mycroft 	++((SEGSUM *)(sp->segsum))->ss_nfinfo;
    806    1.1   mycroft 
    807   1.73       chs 	if (vp->v_flag & VDIROP)
    808   1.15  perseant 		((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
    809  1.157     perry 
    810    1.1   mycroft 	fip = sp->fip;
    811    1.1   mycroft 	fip->fi_nblocks = 0;
    812   1.80  perseant 	fip->fi_ino = ip->i_number;
    813    1.1   mycroft 	LFS_IENTRY(ifp, fs, fip->fi_ino, bp);
    814    1.1   mycroft 	fip->fi_version = ifp->if_version;
    815    1.1   mycroft 	brelse(bp);
    816  1.157     perry 
    817   1.74  perseant 	if (sp->seg_flags & SEGM_CLEAN) {
    818   1.38  perseant 		lfs_gather(fs, sp, vp, lfs_match_fake);
    819   1.38  perseant 		/*
    820   1.38  perseant 		 * For a file being flushed, we need to write *all* blocks.
    821   1.38  perseant 		 * This means writing the cleaning blocks first, and then
    822   1.38  perseant 		 * immediately following with any non-cleaning blocks.
    823   1.38  perseant 		 * The same is true of the Ifile since checkpoints assume
    824   1.38  perseant 		 * that all valid Ifile blocks are written.
    825   1.38  perseant 		 */
    826  1.103  perseant 		if (IS_FLUSHING(fs,vp) || vp == fs->lfs_ivnode) {
    827   1.38  perseant 			lfs_gather(fs, sp, vp, lfs_match_data);
    828  1.101  perseant 			/*
    829  1.101  perseant 			 * Don't call VOP_PUTPAGES: if we're flushing,
    830  1.101  perseant 			 * we've already done it, and the Ifile doesn't
    831  1.101  perseant 			 * use the page cache.
    832  1.101  perseant 			 */
    833  1.101  perseant 		}
    834  1.101  perseant 	} else {
    835   1.38  perseant 		lfs_gather(fs, sp, vp, lfs_match_data);
    836  1.101  perseant 		/*
    837  1.101  perseant 		 * If we're flushing, we've already called VOP_PUTPAGES
    838  1.101  perseant 		 * so don't do it again.  Otherwise, we want to write
    839  1.101  perseant 		 * everything we've got.
    840  1.101  perseant 		 */
    841  1.101  perseant 		if (!IS_FLUSHING(fs, vp)) {
    842  1.102      yamt 			simple_lock(&vp->v_interlock);
    843  1.171  perseant 			error = VOP_PUTPAGES(vp, 0, 0,
    844  1.171  perseant 				PGO_CLEANIT | PGO_ALLPAGES | PGO_LOCKED);
    845  1.101  perseant 		}
    846  1.101  perseant 	}
    847   1.38  perseant 
    848    1.1   mycroft 	/*
    849    1.1   mycroft 	 * It may not be necessary to write the meta-data blocks at this point,
    850    1.1   mycroft 	 * as the roll-forward recovery code should be able to reconstruct the
    851    1.1   mycroft 	 * list.
    852   1.15  perseant 	 *
    853   1.15  perseant 	 * We have to write them anyway, though, under two conditions: (1) the
    854   1.15  perseant 	 * vnode is being flushed (for reuse by vinvalbuf); or (2) we are
    855   1.15  perseant 	 * checkpointing.
    856   1.80  perseant 	 *
    857   1.80  perseant 	 * BUT if we are cleaning, we might have indirect blocks that refer to
    858   1.80  perseant 	 * new blocks not being written yet, in addition to fragments being
    859   1.80  perseant 	 * moved out of a cleaned segment.  If that is the case, don't
    860   1.80  perseant 	 * write the indirect blocks, or the finfo will have a small block
    861   1.80  perseant 	 * in the middle of it!
    862   1.80  perseant 	 * XXX in this case isn't the inode size wrong too?
    863    1.1   mycroft 	 */
    864   1.80  perseant 	frag = 0;
    865   1.80  perseant 	if (sp->seg_flags & SEGM_CLEAN) {
    866   1.80  perseant 		for (i = 0; i < NDADDR; i++)
    867   1.80  perseant 			if (ip->i_lfs_fragsize[i] > 0 &&
    868   1.80  perseant 			    ip->i_lfs_fragsize[i] < fs->lfs_bsize)
    869   1.80  perseant 				++frag;
    870   1.80  perseant 	}
    871   1.80  perseant #ifdef DIAGNOSTIC
    872   1.80  perseant 	if (frag > 1)
    873   1.80  perseant 		panic("lfs_writefile: more than one fragment!");
    874   1.80  perseant #endif
    875   1.80  perseant 	if (IS_FLUSHING(fs, vp) ||
    876   1.80  perseant 	    (frag == 0 && (lfs_writeindir || (sp->seg_flags & SEGM_CKP)))) {
    877   1.15  perseant 		lfs_gather(fs, sp, vp, lfs_match_indir);
    878   1.15  perseant 		lfs_gather(fs, sp, vp, lfs_match_dindir);
    879   1.15  perseant 		lfs_gather(fs, sp, vp, lfs_match_tindir);
    880   1.15  perseant 	}
    881    1.1   mycroft 	fip = sp->fip;
    882    1.1   mycroft 	if (fip->fi_nblocks != 0) {
    883   1.98      yamt 		sp->fip = (FINFO*)((caddr_t)fip + FINFOSIZE +
    884   1.98      yamt 				   sizeof(int32_t) * (fip->fi_nblocks));
    885    1.1   mycroft 		sp->start_lbp = &sp->fip->fi_blocks[0];
    886    1.1   mycroft 	} else {
    887   1.98      yamt 		sp->sum_bytes_left += FINFOSIZE;
    888    1.1   mycroft 		--((SEGSUM *)(sp->segsum))->ss_nfinfo;
    889    1.1   mycroft 	}
    890  1.171  perseant 
    891  1.171  perseant 	return error;
    892    1.1   mycroft }
    893    1.1   mycroft 
    894    1.1   mycroft int
    895   1.69  perseant lfs_writeinode(struct lfs *fs, struct segment *sp, struct inode *ip)
    896    1.1   mycroft {
    897    1.1   mycroft 	struct buf *bp, *ibp;
    898  1.119      fvdl 	struct ufs1_dinode *cdp;
    899    1.1   mycroft 	IFILE *ifp;
    900    1.1   mycroft 	SEGUSE *sup;
    901   1.91      fvdl 	daddr_t daddr;
    902   1.91      fvdl 	int32_t *daddrp;	/* XXX ondisk32 */
    903    1.1   mycroft 	ino_t ino;
    904   1.69  perseant 	int error, i, ndx, fsb = 0;
    905    1.1   mycroft 	int redo_ifile = 0;
    906   1.69  perseant 	int gotblk = 0;
    907  1.157     perry 
    908  1.159  perseant 	ASSERT_SEGLOCK(fs);
    909   1.47  perseant 	if (!(ip->i_flag & IN_ALLMOD))
    910   1.73       chs 		return (0);
    911  1.157     perry 
    912    1.1   mycroft 	/* Allocate a new inode block if necessary. */
    913  1.128      yamt 	if ((ip->i_number != LFS_IFILE_INUM || sp->idp == NULL) &&
    914  1.128      yamt 	    sp->ibp == NULL) {
    915    1.1   mycroft 		/* Allocate a new segment if necessary. */
    916   1.69  perseant 		if (sp->seg_bytes_left < fs->lfs_ibsize ||
    917   1.98      yamt 		    sp->sum_bytes_left < sizeof(int32_t))
    918    1.1   mycroft 			(void) lfs_writeseg(fs, sp);
    919    1.1   mycroft 
    920    1.1   mycroft 		/* Get next inode block. */
    921    1.1   mycroft 		daddr = fs->lfs_offset;
    922   1.69  perseant 		fs->lfs_offset += btofsb(fs, fs->lfs_ibsize);
    923    1.1   mycroft 		sp->ibp = *sp->cbpp++ =
    924  1.128      yamt 			getblk(VTOI(fs->lfs_ivnode)->i_devvp,
    925  1.128      yamt 			    fsbtodb(fs, daddr), fs->lfs_ibsize, 0, 0);
    926   1.24  perseant 		gotblk++;
    927   1.24  perseant 
    928    1.1   mycroft 		/* Zero out inode numbers */
    929    1.1   mycroft 		for (i = 0; i < INOPB(fs); ++i)
    930  1.128      yamt 			((struct ufs1_dinode *)sp->ibp->b_data)[i].di_inumber =
    931  1.128      yamt 			    0;
    932   1.15  perseant 
    933    1.1   mycroft 		++sp->start_bpp;
    934   1.69  perseant 		fs->lfs_avail -= btofsb(fs, fs->lfs_ibsize);
    935    1.1   mycroft 		/* Set remaining space counters. */
    936   1.69  perseant 		sp->seg_bytes_left -= fs->lfs_ibsize;
    937   1.98      yamt 		sp->sum_bytes_left -= sizeof(int32_t);
    938   1.98      yamt 		ndx = fs->lfs_sumsize / sizeof(int32_t) -
    939   1.15  perseant 			sp->ninodes / INOPB(fs) - 1;
    940   1.98      yamt 		((int32_t *)(sp->segsum))[ndx] = daddr;
    941    1.1   mycroft 	}
    942   1.27  perseant 
    943    1.1   mycroft 	/* Update the inode times and copy the inode onto the inode page. */
    944   1.74  perseant 	/* XXX kludge --- don't redirty the ifile just to put times on it */
    945   1.74  perseant 	if (ip->i_number != LFS_IFILE_INUM)
    946  1.166  christos 		LFS_ITIMES(ip, NULL, NULL, NULL);
    947   1.16  perseant 
    948   1.27  perseant 	/*
    949   1.27  perseant 	 * If this is the Ifile, and we've already written the Ifile in this
    950   1.27  perseant 	 * partial segment, just overwrite it (it's not on disk yet) and
    951   1.27  perseant 	 * continue.
    952   1.27  perseant 	 *
    953   1.27  perseant 	 * XXX we know that the bp that we get the second time around has
    954   1.27  perseant 	 * already been gathered.
    955   1.27  perseant 	 */
    956   1.73       chs 	if (ip->i_number == LFS_IFILE_INUM && sp->idp) {
    957  1.119      fvdl 		*(sp->idp) = *ip->i_din.ffs1_din;
    958  1.119      fvdl 		ip->i_lfs_osize = ip->i_size;
    959   1.27  perseant 		return 0;
    960   1.27  perseant 	}
    961   1.27  perseant 
    962    1.1   mycroft 	bp = sp->ibp;
    963  1.119      fvdl 	cdp = ((struct ufs1_dinode *)bp->b_data) + (sp->ninodes % INOPB(fs));
    964  1.119      fvdl 	*cdp = *ip->i_din.ffs1_din;
    965   1.53  perseant 
    966  1.176  perseant 	/* We can finish the segment accounting for truncations now */
    967  1.176  perseant 	lfs_finalize_ino_seguse(fs, ip);
    968  1.176  perseant 
    969   1.53  perseant 	/*
    970   1.53  perseant 	 * If we are cleaning, ensure that we don't write UNWRITTEN disk
    971  1.160  perseant 	 * addresses to disk; possibly change the on-disk record of
    972  1.160  perseant 	 * the inode size, either by reverting to the previous size
    973  1.160  perseant 	 * (in the case of cleaning) or by verifying the inode's block
    974  1.160  perseant 	 * holdings (in the case of files being allocated as they are being
    975  1.160  perseant 	 * written).
    976  1.160  perseant 	 * XXX By not writing UNWRITTEN blocks, we are making the lfs_avail
    977  1.103  perseant 	 * XXX count on disk wrong by the same amount.	We should be
    978  1.101  perseant 	 * XXX able to "borrow" from lfs_avail and return it after the
    979  1.101  perseant 	 * XXX Ifile is written.  See also in lfs_writeseg.
    980   1.53  perseant 	 */
    981  1.160  perseant 
    982  1.160  perseant 	/* Check file size based on highest allocated block */
    983  1.160  perseant 	if (((ip->i_ffs1_mode & IFMT) == IFREG ||
    984  1.161  perseant 	     (ip->i_ffs1_mode & IFMT) == IFDIR) &&
    985  1.160  perseant 	    ip->i_size > ((ip->i_lfs_hiblk + 1) << fs->lfs_bshift)) {
    986  1.160  perseant 		cdp->di_size = (ip->i_lfs_hiblk + 1) << fs->lfs_bshift;
    987  1.160  perseant 		DLOG((DLOG_SEG, "lfs_writeinode: ino %d size %" PRId64 " -> %"
    988  1.160  perseant 		      PRId64 "\n", (int)ip->i_number, ip->i_size, cdp->di_size));
    989  1.160  perseant 	}
    990  1.119      fvdl 	if (ip->i_lfs_effnblks != ip->i_ffs1_blocks) {
    991  1.160  perseant 		if (ip->i_flags & IN_CLEANING)
    992  1.160  perseant 			cdp->di_size = ip->i_lfs_osize;
    993  1.160  perseant 		DLOG((DLOG_SEG, "lfs_writeinode: cleansing ino %d eff %d != nblk %d)"
    994  1.160  perseant 		      " at %x\n", ip->i_number, ip->i_lfs_effnblks,
    995  1.160  perseant 		      ip->i_ffs1_blocks, fs->lfs_offset));
    996   1.53  perseant 		for (daddrp = cdp->di_db; daddrp < cdp->di_ib + NIADDR;
    997   1.53  perseant 		     daddrp++) {
    998   1.53  perseant 			if (*daddrp == UNWRITTEN) {
    999  1.158  perseant 				DLOG((DLOG_SEG, "lfs_writeinode: wiping UNWRITTEN\n"));
   1000   1.53  perseant 				*daddrp = 0;
   1001   1.53  perseant 			}
   1002   1.53  perseant 		}
   1003   1.80  perseant 	} else {
   1004  1.160  perseant 		/* If all blocks are going to disk, update "size on disk" */
   1005  1.119      fvdl 		ip->i_lfs_osize = ip->i_size;
   1006   1.53  perseant 	}
   1007  1.157     perry 
   1008  1.160  perseant #ifdef DIAGNOSTIC
   1009  1.160  perseant 	/*
   1010  1.160  perseant 	 * Check dinode held blocks against dinode size.
   1011  1.160  perseant 	 * This should be identical to the check in lfs_vget().
   1012  1.160  perseant 	 */
   1013  1.160  perseant 	for (i = (cdp->di_size + fs->lfs_bsize - 1) >> fs->lfs_bshift;
   1014  1.160  perseant 	     i < NDADDR; i++) {
   1015  1.160  perseant 		KASSERT(i >= 0);
   1016  1.160  perseant 		if ((cdp->di_mode & IFMT) == IFLNK)
   1017  1.160  perseant 			continue;
   1018  1.160  perseant 		if (((cdp->di_mode & IFMT) == IFBLK ||
   1019  1.160  perseant 		     (cdp->di_mode & IFMT) == IFCHR) && i == 0)
   1020  1.160  perseant 			continue;
   1021  1.160  perseant 		if (cdp->di_db[i] != 0) {
   1022  1.160  perseant # ifdef DEBUG
   1023  1.160  perseant 			lfs_dump_dinode(cdp);
   1024  1.160  perseant # endif
   1025  1.160  perseant 			panic("writing inconsistent inode");
   1026  1.160  perseant 		}
   1027  1.160  perseant 	}
   1028  1.160  perseant #endif /* DIAGNOSTIC */
   1029  1.160  perseant 
   1030   1.73       chs 	if (ip->i_flag & IN_CLEANING)
   1031   1.56  perseant 		LFS_CLR_UINO(ip, IN_CLEANING);
   1032   1.55  perseant 	else {
   1033   1.56  perseant 		/* XXX IN_ALLMOD */
   1034   1.56  perseant 		LFS_CLR_UINO(ip, IN_ACCESSED | IN_ACCESS | IN_CHANGE |
   1035  1.154   mycroft 			     IN_UPDATE | IN_MODIFY);
   1036  1.119      fvdl 		if (ip->i_lfs_effnblks == ip->i_ffs1_blocks)
   1037   1.56  perseant 			LFS_CLR_UINO(ip, IN_MODIFIED);
   1038   1.63  perseant 		else
   1039  1.158  perseant 			DLOG((DLOG_VNODE, "lfs_writeinode: ino %d: real blks=%d, "
   1040  1.158  perseant 			      "eff=%d\n", ip->i_number, ip->i_ffs1_blocks,
   1041  1.158  perseant 			      ip->i_lfs_effnblks));
   1042   1.55  perseant 	}
   1043   1.55  perseant 
   1044   1.73       chs 	if (ip->i_number == LFS_IFILE_INUM) /* We know sp->idp == NULL */
   1045  1.157     perry 		sp->idp = ((struct ufs1_dinode *)bp->b_data) +
   1046   1.53  perseant 			(sp->ninodes % INOPB(fs));
   1047   1.73       chs 	if (gotblk) {
   1048   1.62  perseant 		LFS_LOCK_BUF(bp);
   1049   1.24  perseant 		brelse(bp);
   1050   1.24  perseant 	}
   1051  1.157     perry 
   1052    1.1   mycroft 	/* Increment inode count in segment summary block. */
   1053    1.1   mycroft 	++((SEGSUM *)(sp->segsum))->ss_ninos;
   1054  1.157     perry 
   1055    1.1   mycroft 	/* If this page is full, set flag to allocate a new page. */
   1056    1.1   mycroft 	if (++sp->ninodes % INOPB(fs) == 0)
   1057    1.1   mycroft 		sp->ibp = NULL;
   1058  1.157     perry 
   1059    1.1   mycroft 	/*
   1060    1.1   mycroft 	 * If updating the ifile, update the super-block.  Update the disk
   1061    1.1   mycroft 	 * address and access times for this inode in the ifile.
   1062    1.1   mycroft 	 */
   1063    1.1   mycroft 	ino = ip->i_number;
   1064    1.1   mycroft 	if (ino == LFS_IFILE_INUM) {
   1065    1.1   mycroft 		daddr = fs->lfs_idaddr;
   1066   1.69  perseant 		fs->lfs_idaddr = dbtofsb(fs, bp->b_blkno);
   1067    1.1   mycroft 	} else {
   1068    1.1   mycroft 		LFS_IENTRY(ifp, fs, ino, ibp);
   1069    1.1   mycroft 		daddr = ifp->if_daddr;
   1070   1.69  perseant 		ifp->if_daddr = dbtofsb(fs, bp->b_blkno) + fsb;
   1071   1.74  perseant 		error = LFS_BWRITE_LOG(ibp); /* Ifile */
   1072    1.1   mycroft 	}
   1073  1.157     perry 
   1074    1.1   mycroft 	/*
   1075   1.60    toshii 	 * The inode's last address should not be in the current partial
   1076   1.60    toshii 	 * segment, except under exceptional circumstances (lfs_writevnodes
   1077   1.60    toshii 	 * had to start over, and in the meantime more blocks were written
   1078  1.103  perseant 	 * to a vnode).	 Both inodes will be accounted to this segment
   1079   1.80  perseant 	 * in lfs_writeseg so we need to subtract the earlier version
   1080  1.103  perseant 	 * here anyway.	 The segment count can temporarily dip below
   1081  1.157     perry 	 * zero here; keep track of how many duplicates we have in
   1082   1.80  perseant 	 * "dupino" so we don't panic below.
   1083   1.60    toshii 	 */
   1084   1.80  perseant 	if (daddr >= fs->lfs_lastpseg && daddr <= dbtofsb(fs, bp->b_blkno)) {
   1085   1.80  perseant 		++sp->ndupino;
   1086  1.158  perseant 		DLOG((DLOG_SEG, "lfs_writeinode: last inode addr in current pseg "
   1087  1.158  perseant 		      "(ino %d daddr 0x%llx) ndupino=%d\n", ino,
   1088  1.158  perseant 		      (long long)daddr, sp->ndupino));
   1089   1.80  perseant 	}
   1090   1.80  perseant 	/*
   1091   1.80  perseant 	 * Account the inode: it no longer belongs to its former segment,
   1092   1.80  perseant 	 * though it will not belong to the new segment until that segment
   1093   1.80  perseant 	 * is actually written.
   1094   1.80  perseant 	 */
   1095   1.49  perseant 	if (daddr != LFS_UNUSED_DADDR) {
   1096   1.83      yamt 		u_int32_t oldsn = dtosn(fs, daddr);
   1097    1.1   mycroft #ifdef DIAGNOSTIC
   1098   1.83      yamt 		int ndupino = (sp->seg_number == oldsn) ? sp->ndupino : 0;
   1099   1.83      yamt #endif
   1100   1.83      yamt 		LFS_SEGENTRY(sup, fs, oldsn, bp);
   1101   1.83      yamt #ifdef DIAGNOSTIC
   1102  1.119      fvdl 		if (sup->su_nbytes +
   1103  1.119      fvdl 		    sizeof (struct ufs1_dinode) * ndupino
   1104  1.119      fvdl 		      < sizeof (struct ufs1_dinode)) {
   1105   1.53  perseant 			printf("lfs_writeinode: negative bytes "
   1106   1.96      yamt 			       "(segment %" PRIu32 " short by %d, "
   1107   1.96      yamt 			       "oldsn=%" PRIu32 ", cursn=%" PRIu32
   1108   1.96      yamt 			       ", daddr=%" PRId64 ", su_nbytes=%u, "
   1109   1.83      yamt 			       "ndupino=%d)\n",
   1110   1.69  perseant 			       dtosn(fs, daddr),
   1111  1.128      yamt 			       (int)sizeof (struct ufs1_dinode) *
   1112  1.128      yamt 				   (1 - sp->ndupino) - sup->su_nbytes,
   1113   1.96      yamt 			       oldsn, sp->seg_number, daddr,
   1114   1.83      yamt 			       (unsigned int)sup->su_nbytes,
   1115   1.83      yamt 			       sp->ndupino);
   1116   1.27  perseant 			panic("lfs_writeinode: negative bytes");
   1117  1.119      fvdl 			sup->su_nbytes = sizeof (struct ufs1_dinode);
   1118    1.1   mycroft 		}
   1119    1.1   mycroft #endif
   1120  1.158  perseant 		DLOG((DLOG_SU, "seg %d -= %d for ino %d inode\n",
   1121  1.158  perseant 		      dtosn(fs, daddr), sizeof (struct ufs1_dinode), ino));
   1122  1.119      fvdl 		sup->su_nbytes -= sizeof (struct ufs1_dinode);
   1123    1.1   mycroft 		redo_ifile =
   1124   1.15  perseant 			(ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED));
   1125  1.159  perseant 		if (redo_ifile) {
   1126  1.159  perseant 			simple_lock(&fs->lfs_interlock);
   1127   1.74  perseant 			fs->lfs_flags |= LFS_IFDIRTY;
   1128  1.159  perseant 			simple_unlock(&fs->lfs_interlock);
   1129  1.159  perseant 		}
   1130  1.101  perseant 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
   1131    1.1   mycroft 	}
   1132    1.1   mycroft 	return (redo_ifile);
   1133    1.1   mycroft }
   1134    1.1   mycroft 
   1135    1.1   mycroft int
   1136   1.69  perseant lfs_gatherblock(struct segment *sp, struct buf *bp, int *sptr)
   1137    1.1   mycroft {
   1138    1.1   mycroft 	struct lfs *fs;
   1139  1.164  christos 	int vers;
   1140  1.101  perseant 	int j, blksinblk;
   1141  1.101  perseant 
   1142  1.159  perseant 	ASSERT_SEGLOCK(sp->fs);
   1143    1.1   mycroft 	/*
   1144    1.1   mycroft 	 * If full, finish this segment.  We may be doing I/O, so
   1145    1.1   mycroft 	 * release and reacquire the splbio().
   1146    1.1   mycroft 	 */
   1147    1.1   mycroft #ifdef DIAGNOSTIC
   1148    1.1   mycroft 	if (sp->vp == NULL)
   1149    1.1   mycroft 		panic ("lfs_gatherblock: Null vp in segment");
   1150    1.1   mycroft #endif
   1151    1.1   mycroft 	fs = sp->fs;
   1152  1.101  perseant 	blksinblk = howmany(bp->b_bcount, fs->lfs_bsize);
   1153  1.101  perseant 	if (sp->sum_bytes_left < sizeof(int32_t) * blksinblk ||
   1154   1.10      fvdl 	    sp->seg_bytes_left < bp->b_bcount) {
   1155    1.1   mycroft 		if (sptr)
   1156    1.1   mycroft 			splx(*sptr);
   1157    1.1   mycroft 		lfs_updatemeta(sp);
   1158  1.157     perry 
   1159  1.164  christos 		vers = sp->fip->fi_version;
   1160    1.1   mycroft 		(void) lfs_writeseg(fs, sp);
   1161  1.157     perry 
   1162  1.164  christos 		sp->fip->fi_version = vers;
   1163    1.1   mycroft 		sp->fip->fi_ino = VTOI(sp->vp)->i_number;
   1164    1.1   mycroft 		/* Add the current file to the segment summary. */
   1165    1.1   mycroft 		++((SEGSUM *)(sp->segsum))->ss_nfinfo;
   1166   1.98      yamt 		sp->sum_bytes_left -= FINFOSIZE;
   1167  1.157     perry 
   1168    1.1   mycroft 		if (sptr)
   1169    1.1   mycroft 			*sptr = splbio();
   1170   1.73       chs 		return (1);
   1171    1.1   mycroft 	}
   1172  1.157     perry 
   1173   1.73       chs 	if (bp->b_flags & B_GATHERED) {
   1174  1.158  perseant 		DLOG((DLOG_SEG, "lfs_gatherblock: already gathered! Ino %d,"
   1175  1.158  perseant 		      " lbn %" PRId64 "\n",
   1176  1.158  perseant 		      sp->fip->fi_ino, bp->b_lblkno));
   1177   1.73       chs 		return (0);
   1178   1.15  perseant 	}
   1179  1.158  perseant 
   1180    1.1   mycroft 	/* Insert into the buffer list, update the FINFO block. */
   1181    1.1   mycroft 	bp->b_flags |= B_GATHERED;
   1182   1.74  perseant 
   1183    1.1   mycroft 	*sp->cbpp++ = bp;
   1184  1.162  perseant 	for (j = 0; j < blksinblk; j++) {
   1185  1.104  perseant 		sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno + j;
   1186  1.162  perseant 		/* This block's accounting moves from lfs_favail to lfs_avail */
   1187  1.162  perseant 		lfs_deregister_block(sp->vp, bp->b_lblkno + j);
   1188  1.162  perseant 	}
   1189  1.157     perry 
   1190  1.104  perseant 	sp->sum_bytes_left -= sizeof(int32_t) * blksinblk;
   1191   1.10      fvdl 	sp->seg_bytes_left -= bp->b_bcount;
   1192   1.73       chs 	return (0);
   1193    1.1   mycroft }
   1194    1.1   mycroft 
   1195   1.15  perseant int
   1196  1.128      yamt lfs_gather(struct lfs *fs, struct segment *sp, struct vnode *vp,
   1197  1.128      yamt     int (*match)(struct lfs *, struct buf *))
   1198    1.1   mycroft {
   1199   1.77  perseant 	struct buf *bp, *nbp;
   1200   1.73       chs 	int s, count = 0;
   1201  1.157     perry 
   1202  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1203  1.172  perseant 	if (vp->v_type == VBLK)
   1204  1.172  perseant 		return 0;
   1205  1.141      yamt 	KASSERT(sp->vp == NULL);
   1206    1.1   mycroft 	sp->vp = vp;
   1207    1.1   mycroft 	s = splbio();
   1208   1.15  perseant 
   1209   1.15  perseant #ifndef LFS_NO_BACKBUF_HACK
   1210   1.10      fvdl /* This is a hack to see if ordering the blocks in LFS makes a difference. */
   1211  1.128      yamt # define	BUF_OFFSET	\
   1212  1.128      yamt 	(((caddr_t)&LIST_NEXT(bp, b_vnbufs)) - (caddr_t)bp)
   1213  1.128      yamt # define	BACK_BUF(BP)	\
   1214  1.128      yamt 	((struct buf *)(((caddr_t)(BP)->b_vnbufs.le_prev) - BUF_OFFSET))
   1215  1.128      yamt # define	BEG_OF_LIST	\
   1216  1.128      yamt 	((struct buf *)(((caddr_t)&LIST_FIRST(&vp->v_dirtyblkhd)) - BUF_OFFSET))
   1217  1.128      yamt 
   1218  1.128      yamt loop:
   1219  1.128      yamt 	/* Find last buffer. */
   1220  1.128      yamt 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
   1221  1.128      yamt 	     bp && LIST_NEXT(bp, b_vnbufs) != NULL;
   1222  1.128      yamt 	     bp = LIST_NEXT(bp, b_vnbufs))
   1223  1.128      yamt 		/* nothing */;
   1224   1.77  perseant 	for (; bp && bp != BEG_OF_LIST; bp = nbp) {
   1225   1.77  perseant 		nbp = BACK_BUF(bp);
   1226   1.77  perseant #else /* LFS_NO_BACKBUF_HACK */
   1227  1.128      yamt loop:
   1228  1.128      yamt 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
   1229   1.77  perseant 		nbp = LIST_NEXT(bp, b_vnbufs);
   1230   1.15  perseant #endif /* LFS_NO_BACKBUF_HACK */
   1231   1.74  perseant 		if ((bp->b_flags & (B_BUSY|B_GATHERED)) || !match(fs, bp)) {
   1232  1.158  perseant #ifdef DEBUG
   1233  1.128      yamt 			if (vp == fs->lfs_ivnode &&
   1234  1.128      yamt 			    (bp->b_flags & (B_BUSY|B_GATHERED)) == B_BUSY)
   1235  1.158  perseant 				DLOG((DLOG_SEG, "lfs_gather: ifile lbn %"
   1236  1.158  perseant 				      PRId64 " busy (%x)",
   1237  1.158  perseant 				      bp->b_lblkno, bp->b_flags));
   1238   1.74  perseant #endif
   1239    1.1   mycroft 			continue;
   1240   1.74  perseant 		}
   1241    1.1   mycroft #ifdef DIAGNOSTIC
   1242  1.109  perseant # ifdef LFS_USE_B_INVAL
   1243  1.172  perseant 		if ((bp->b_flags & (B_CALL|B_INVAL)) == B_INVAL) {
   1244  1.172  perseant 			DLOG((DLOG_SEG, "lfs_gather: lbn %" PRId64
   1245  1.172  perseant 			      " is B_INVAL\n", bp->b_lblkno));
   1246  1.172  perseant 			VOP_PRINT(bp->b_vp);
   1247  1.172  perseant 		}
   1248  1.109  perseant # endif /* LFS_USE_B_INVAL */
   1249  1.172  perseant 		if (!(bp->b_flags & B_DELWRI))
   1250  1.172  perseant 			panic("lfs_gather: bp not B_DELWRI");
   1251  1.172  perseant 		if (!(bp->b_flags & B_LOCKED)) {
   1252  1.172  perseant 			DLOG((DLOG_SEG, "lfs_gather: lbn %" PRId64
   1253  1.172  perseant 			      " blk %" PRId64 " not B_LOCKED\n",
   1254  1.172  perseant 			      bp->b_lblkno,
   1255  1.172  perseant 			      dbtofsb(fs, bp->b_blkno)));
   1256  1.172  perseant 			VOP_PRINT(bp->b_vp);
   1257  1.172  perseant 			panic("lfs_gather: bp not B_LOCKED");
   1258  1.172  perseant 		}
   1259    1.1   mycroft #endif
   1260  1.172  perseant 		if (lfs_gatherblock(sp, bp, &s)) {
   1261  1.172  perseant 			goto loop;
   1262   1.30  perseant 		}
   1263   1.15  perseant 		count++;
   1264    1.1   mycroft 	}
   1265    1.1   mycroft 	splx(s);
   1266    1.1   mycroft 	lfs_updatemeta(sp);
   1267  1.141      yamt 	KASSERT(sp->vp == vp);
   1268    1.1   mycroft 	sp->vp = NULL;
   1269   1.15  perseant 	return count;
   1270    1.1   mycroft }
   1271    1.1   mycroft 
   1272  1.101  perseant #if DEBUG
   1273  1.101  perseant # define DEBUG_OOFF(n) do {						\
   1274  1.101  perseant 	if (ooff == 0) {						\
   1275  1.158  perseant 		DLOG((DLOG_SEG, "lfs_updatemeta[%d]: warning: writing " \
   1276  1.105  perseant 			"ino %d lbn %" PRId64 " at 0x%" PRIx32		\
   1277  1.105  perseant 			", was 0x0 (or %" PRId64 ")\n",			\
   1278  1.158  perseant 			(n), ip->i_number, lbn, ndaddr, daddr));	\
   1279  1.101  perseant 	}								\
   1280  1.115  perseant } while (0)
   1281  1.101  perseant #else
   1282  1.101  perseant # define DEBUG_OOFF(n)
   1283  1.101  perseant #endif
   1284  1.101  perseant 
   1285  1.101  perseant /*
   1286  1.101  perseant  * Change the given block's address to ndaddr, finding its previous
   1287  1.101  perseant  * location using ufs_bmaparray().
   1288  1.101  perseant  *
   1289  1.101  perseant  * Account for this change in the segment table.
   1290  1.143      yamt  *
   1291  1.143      yamt  * called with sp == NULL by roll-forwarding code.
   1292  1.101  perseant  */
   1293  1.101  perseant void
   1294  1.143      yamt lfs_update_single(struct lfs *fs, struct segment *sp, struct vnode *vp,
   1295  1.143      yamt     daddr_t lbn, int32_t ndaddr, int size)
   1296  1.101  perseant {
   1297  1.101  perseant 	SEGUSE *sup;
   1298  1.101  perseant 	struct buf *bp;
   1299  1.101  perseant 	struct indir a[NIADDR + 2], *ap;
   1300  1.101  perseant 	struct inode *ip;
   1301  1.101  perseant 	daddr_t daddr, ooff;
   1302  1.104  perseant 	int num, error;
   1303  1.101  perseant 	int bb, osize, obb;
   1304  1.157     perry 
   1305  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1306  1.143      yamt 	KASSERT(sp == NULL || sp->vp == vp);
   1307  1.101  perseant 	ip = VTOI(vp);
   1308  1.101  perseant 
   1309  1.121      yamt 	error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL, NULL);
   1310  1.101  perseant 	if (error)
   1311  1.101  perseant 		panic("lfs_updatemeta: ufs_bmaparray returned %d", error);
   1312  1.116  perseant 
   1313  1.156  perseant 	daddr = (daddr_t)((int32_t)daddr); /* XXX ondisk32 */
   1314  1.116  perseant 	KASSERT(daddr <= LFS_MAX_DADDR);
   1315  1.101  perseant 	if (daddr > 0)
   1316  1.101  perseant 		daddr = dbtofsb(fs, daddr);
   1317  1.157     perry 
   1318  1.101  perseant 	bb = fragstofsb(fs, numfrags(fs, size));
   1319  1.101  perseant 	switch (num) {
   1320  1.101  perseant 	    case 0:
   1321  1.119      fvdl 		    ooff = ip->i_ffs1_db[lbn];
   1322  1.101  perseant 		    DEBUG_OOFF(0);
   1323  1.101  perseant 		    if (ooff == UNWRITTEN)
   1324  1.119      fvdl 			    ip->i_ffs1_blocks += bb;
   1325  1.101  perseant 		    else {
   1326  1.101  perseant 			    /* possible fragment truncation or extension */
   1327  1.101  perseant 			    obb = btofsb(fs, ip->i_lfs_fragsize[lbn]);
   1328  1.119      fvdl 			    ip->i_ffs1_blocks += (bb - obb);
   1329  1.101  perseant 		    }
   1330  1.119      fvdl 		    ip->i_ffs1_db[lbn] = ndaddr;
   1331  1.101  perseant 		    break;
   1332  1.101  perseant 	    case 1:
   1333  1.119      fvdl 		    ooff = ip->i_ffs1_ib[a[0].in_off];
   1334  1.101  perseant 		    DEBUG_OOFF(1);
   1335  1.101  perseant 		    if (ooff == UNWRITTEN)
   1336  1.119      fvdl 			    ip->i_ffs1_blocks += bb;
   1337  1.119      fvdl 		    ip->i_ffs1_ib[a[0].in_off] = ndaddr;
   1338  1.101  perseant 		    break;
   1339  1.101  perseant 	    default:
   1340  1.101  perseant 		    ap = &a[num - 1];
   1341  1.101  perseant 		    if (bread(vp, ap->in_lbn, fs->lfs_bsize, NOCRED, &bp))
   1342  1.101  perseant 			    panic("lfs_updatemeta: bread bno %" PRId64,
   1343  1.101  perseant 				  ap->in_lbn);
   1344  1.101  perseant 
   1345  1.101  perseant 		    /* XXX ondisk32 */
   1346  1.101  perseant 		    ooff = ((int32_t *)bp->b_data)[ap->in_off];
   1347  1.101  perseant 		    DEBUG_OOFF(num);
   1348  1.101  perseant 		    if (ooff == UNWRITTEN)
   1349  1.119      fvdl 			    ip->i_ffs1_blocks += bb;
   1350  1.101  perseant 		    /* XXX ondisk32 */
   1351  1.101  perseant 		    ((int32_t *)bp->b_data)[ap->in_off] = ndaddr;
   1352  1.101  perseant 		    (void) VOP_BWRITE(bp);
   1353  1.101  perseant 	}
   1354  1.106  perseant 
   1355  1.150      yamt 	KASSERT(ooff == 0 || ooff == UNWRITTEN || ooff == daddr);
   1356  1.150      yamt 
   1357  1.160  perseant 	/* Update hiblk when extending the file */
   1358  1.160  perseant 	if (lbn > ip->i_lfs_hiblk)
   1359  1.160  perseant 		ip->i_lfs_hiblk = lbn;
   1360  1.160  perseant 
   1361  1.106  perseant 	/*
   1362  1.106  perseant 	 * Though we'd rather it couldn't, this *can* happen right now
   1363  1.106  perseant 	 * if cleaning blocks and regular blocks coexist.
   1364  1.106  perseant 	 */
   1365  1.106  perseant 	/* KASSERT(daddr < fs->lfs_lastpseg || daddr > ndaddr); */
   1366  1.101  perseant 
   1367  1.101  perseant 	/*
   1368  1.101  perseant 	 * Update segment usage information, based on old size
   1369  1.101  perseant 	 * and location.
   1370  1.101  perseant 	 */
   1371  1.101  perseant 	if (daddr > 0) {
   1372  1.101  perseant 		u_int32_t oldsn = dtosn(fs, daddr);
   1373  1.101  perseant #ifdef DIAGNOSTIC
   1374  1.143      yamt 		int ndupino;
   1375  1.143      yamt 
   1376  1.143      yamt 		if (sp && sp->seg_number == oldsn) {
   1377  1.143      yamt 			ndupino = sp->ndupino;
   1378  1.143      yamt 		} else {
   1379  1.143      yamt 			ndupino = 0;
   1380  1.143      yamt 		}
   1381  1.101  perseant #endif
   1382  1.116  perseant 		KASSERT(oldsn >= 0 && oldsn < fs->lfs_nseg);
   1383  1.101  perseant 		if (lbn >= 0 && lbn < NDADDR)
   1384  1.101  perseant 			osize = ip->i_lfs_fragsize[lbn];
   1385  1.101  perseant 		else
   1386  1.101  perseant 			osize = fs->lfs_bsize;
   1387  1.101  perseant 		LFS_SEGENTRY(sup, fs, oldsn, bp);
   1388  1.101  perseant #ifdef DIAGNOSTIC
   1389  1.119      fvdl 		if (sup->su_nbytes + sizeof (struct ufs1_dinode) * ndupino
   1390  1.119      fvdl 		    < osize) {
   1391  1.101  perseant 			printf("lfs_updatemeta: negative bytes "
   1392  1.101  perseant 			       "(segment %" PRIu32 " short by %" PRId64
   1393  1.101  perseant 			       ")\n", dtosn(fs, daddr),
   1394  1.101  perseant 			       (int64_t)osize -
   1395  1.143      yamt 			       (sizeof (struct ufs1_dinode) * ndupino +
   1396  1.101  perseant 				sup->su_nbytes));
   1397  1.165  christos 			printf("lfs_updatemeta: ino %llu, lbn %" PRId64
   1398  1.101  perseant 			       ", addr = 0x%" PRIx64 "\n",
   1399  1.165  christos 			       (unsigned long long)ip->i_number, lbn, daddr);
   1400  1.101  perseant 			printf("lfs_updatemeta: ndupino=%d\n", ndupino);
   1401  1.101  perseant 			panic("lfs_updatemeta: negative bytes");
   1402  1.119      fvdl 			sup->su_nbytes = osize -
   1403  1.143      yamt 			    sizeof (struct ufs1_dinode) * ndupino;
   1404  1.101  perseant 		}
   1405  1.101  perseant #endif
   1406  1.158  perseant 		DLOG((DLOG_SU, "seg %" PRIu32 " -= %d for ino %d lbn %" PRId64
   1407  1.158  perseant 		      " db 0x%" PRIx64 "\n",
   1408  1.158  perseant 		      dtosn(fs, daddr), osize,
   1409  1.158  perseant 		      ip->i_number, lbn, daddr));
   1410  1.101  perseant 		sup->su_nbytes -= osize;
   1411  1.159  perseant 		if (!(bp->b_flags & B_GATHERED)) {
   1412  1.159  perseant 			simple_lock(&fs->lfs_interlock);
   1413  1.101  perseant 			fs->lfs_flags |= LFS_IFDIRTY;
   1414  1.159  perseant 			simple_unlock(&fs->lfs_interlock);
   1415  1.159  perseant 		}
   1416  1.101  perseant 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp);
   1417  1.101  perseant 	}
   1418  1.101  perseant 	/*
   1419  1.101  perseant 	 * Now that this block has a new address, and its old
   1420  1.101  perseant 	 * segment no longer owns it, we can forget about its
   1421  1.101  perseant 	 * old size.
   1422  1.101  perseant 	 */
   1423  1.101  perseant 	if (lbn >= 0 && lbn < NDADDR)
   1424  1.101  perseant 		ip->i_lfs_fragsize[lbn] = size;
   1425  1.101  perseant }
   1426  1.101  perseant 
   1427    1.1   mycroft /*
   1428    1.1   mycroft  * Update the metadata that points to the blocks listed in the FINFO
   1429    1.1   mycroft  * array.
   1430    1.1   mycroft  */
   1431    1.1   mycroft void
   1432   1.69  perseant lfs_updatemeta(struct segment *sp)
   1433    1.1   mycroft {
   1434  1.101  perseant 	struct buf *sbp;
   1435    1.1   mycroft 	struct lfs *fs;
   1436    1.1   mycroft 	struct vnode *vp;
   1437  1.101  perseant 	daddr_t lbn;
   1438  1.101  perseant 	int i, nblocks, num;
   1439  1.101  perseant 	int bb;
   1440  1.101  perseant 	int bytesleft, size;
   1441  1.157     perry 
   1442  1.159  perseant 	ASSERT_SEGLOCK(sp->fs);
   1443    1.1   mycroft 	vp = sp->vp;
   1444    1.1   mycroft 	nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp;
   1445  1.101  perseant 	KASSERT(nblocks >= 0);
   1446  1.141      yamt 	KASSERT(vp != NULL);
   1447  1.141      yamt 	if (nblocks == 0)
   1448    1.1   mycroft 		return;
   1449  1.104  perseant 
   1450  1.104  perseant 	/*
   1451  1.104  perseant 	 * This count may be high due to oversize blocks from lfs_gop_write.
   1452  1.104  perseant 	 * Correct for this. (XXX we should be able to keep track of these.)
   1453  1.104  perseant 	 */
   1454  1.104  perseant 	fs = sp->fs;
   1455  1.104  perseant 	for (i = 0; i < nblocks; i++) {
   1456  1.104  perseant 		if (sp->start_bpp[i] == NULL) {
   1457  1.158  perseant 			DLOG((DLOG_SEG, "lfs_updatemeta: nblocks = %d, not %d\n", i, nblocks));
   1458  1.104  perseant 			nblocks = i;
   1459  1.104  perseant 			break;
   1460  1.104  perseant 		}
   1461  1.104  perseant 		num = howmany(sp->start_bpp[i]->b_bcount, fs->lfs_bsize);
   1462  1.118      yamt 		KASSERT(sp->start_bpp[i]->b_lblkno >= 0 || num == 1);
   1463  1.104  perseant 		nblocks -= num - 1;
   1464  1.104  perseant 	}
   1465  1.118      yamt 
   1466  1.118      yamt 	KASSERT(vp->v_type == VREG ||
   1467  1.118      yamt 	   nblocks == &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp);
   1468  1.118      yamt 	KASSERT(nblocks == sp->cbpp - sp->start_bpp);
   1469  1.157     perry 
   1470   1.15  perseant 	/*
   1471  1.101  perseant 	 * Sort the blocks.
   1472  1.101  perseant 	 *
   1473  1.101  perseant 	 * We have to sort even if the blocks come from the
   1474   1.15  perseant 	 * cleaner, because there might be other pending blocks on the
   1475   1.15  perseant 	 * same inode...and if we don't sort, and there are fragments
   1476   1.15  perseant 	 * present, blocks may be written in the wrong place.
   1477   1.15  perseant 	 */
   1478  1.104  perseant 	lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks, fs->lfs_bsize);
   1479  1.157     perry 
   1480    1.1   mycroft 	/*
   1481   1.10      fvdl 	 * Record the length of the last block in case it's a fragment.
   1482   1.10      fvdl 	 * If there are indirect blocks present, they sort last.  An
   1483   1.10      fvdl 	 * indirect block will be lfs_bsize and its presence indicates
   1484   1.10      fvdl 	 * that you cannot have fragments.
   1485   1.80  perseant 	 *
   1486   1.80  perseant 	 * XXX This last is a lie.  A cleaned fragment can coexist with
   1487  1.103  perseant 	 * XXX a later indirect block.	This will continue to be
   1488   1.80  perseant 	 * XXX true until lfs_markv is fixed to do everything with
   1489   1.80  perseant 	 * XXX fake blocks (including fake inodes and fake indirect blocks).
   1490   1.10      fvdl 	 */
   1491  1.101  perseant 	sp->fip->fi_lastlength = ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &
   1492  1.101  perseant 		fs->lfs_bmask) + 1;
   1493  1.157     perry 
   1494   1.10      fvdl 	/*
   1495    1.1   mycroft 	 * Assign disk addresses, and update references to the logical
   1496    1.1   mycroft 	 * block and the segment usage information.
   1497    1.1   mycroft 	 */
   1498    1.1   mycroft 	for (i = nblocks; i--; ++sp->start_bpp) {
   1499  1.101  perseant 		sbp = *sp->start_bpp;
   1500  1.104  perseant 		lbn = *sp->start_lbp;
   1501  1.118      yamt 		KASSERT(sbp->b_lblkno == lbn);
   1502  1.104  perseant 
   1503   1.80  perseant 		sbp->b_blkno = fsbtodb(fs, fs->lfs_offset);
   1504   1.80  perseant 
   1505   1.80  perseant 		/*
   1506   1.80  perseant 		 * If we write a frag in the wrong place, the cleaner won't
   1507   1.80  perseant 		 * be able to correctly identify its size later, and the
   1508  1.103  perseant 		 * segment will be uncleanable.	 (Even worse, it will assume
   1509   1.80  perseant 		 * that the indirect block that actually ends the list
   1510   1.80  perseant 		 * is of a smaller size!)
   1511   1.80  perseant 		 */
   1512  1.101  perseant 		if ((sbp->b_bcount & fs->lfs_bmask) && i != 0)
   1513   1.82    provos 			panic("lfs_updatemeta: fragment is not last block");
   1514  1.119      fvdl 
   1515   1.80  perseant 		/*
   1516  1.101  perseant 		 * For each subblock in this possibly oversized block,
   1517  1.101  perseant 		 * update its address on disk.
   1518   1.80  perseant 		 */
   1519  1.101  perseant 		KASSERT(lbn >= 0 || sbp->b_bcount == fs->lfs_bsize);
   1520  1.141      yamt 		KASSERT(vp == sbp->b_vp);
   1521  1.101  perseant 		for (bytesleft = sbp->b_bcount; bytesleft > 0;
   1522  1.101  perseant 		     bytesleft -= fs->lfs_bsize) {
   1523  1.101  perseant 			size = MIN(bytesleft, fs->lfs_bsize);
   1524  1.101  perseant 			bb = fragstofsb(fs, numfrags(fs, size));
   1525  1.104  perseant 			lbn = *sp->start_lbp++;
   1526  1.143      yamt 			lfs_update_single(fs, sp, sp->vp, lbn, fs->lfs_offset,
   1527  1.143      yamt 			    size);
   1528  1.101  perseant 			fs->lfs_offset += bb;
   1529    1.1   mycroft 		}
   1530  1.101  perseant 
   1531    1.1   mycroft 	}
   1532    1.1   mycroft }
   1533    1.1   mycroft 
   1534    1.1   mycroft /*
   1535  1.163  perseant  * Move lfs_offset to a segment earlier than sn.
   1536  1.163  perseant  */
   1537  1.163  perseant int
   1538  1.163  perseant lfs_rewind(struct lfs *fs, int newsn)
   1539  1.163  perseant {
   1540  1.163  perseant 	int sn, osn, isdirty;
   1541  1.163  perseant 	struct buf *bp;
   1542  1.163  perseant 	SEGUSE *sup;
   1543  1.163  perseant 
   1544  1.163  perseant 	ASSERT_SEGLOCK(fs);
   1545  1.163  perseant 
   1546  1.163  perseant 	osn = dtosn(fs, fs->lfs_offset);
   1547  1.163  perseant 	if (osn < newsn)
   1548  1.163  perseant 		return 0;
   1549  1.163  perseant 
   1550  1.163  perseant 	/* lfs_avail eats the remaining space in this segment */
   1551  1.163  perseant 	fs->lfs_avail -= fs->lfs_fsbpseg - (fs->lfs_offset - fs->lfs_curseg);
   1552  1.163  perseant 
   1553  1.163  perseant 	/* Find a low-numbered segment */
   1554  1.163  perseant 	for (sn = 0; sn < fs->lfs_nseg; ++sn) {
   1555  1.163  perseant 		LFS_SEGENTRY(sup, fs, sn, bp);
   1556  1.163  perseant 		isdirty = sup->su_flags & SEGUSE_DIRTY;
   1557  1.163  perseant 		brelse(bp);
   1558  1.163  perseant 
   1559  1.163  perseant 		if (!isdirty)
   1560  1.163  perseant 			break;
   1561  1.163  perseant 	}
   1562  1.163  perseant 	if (sn == fs->lfs_nseg)
   1563  1.163  perseant 		panic("lfs_rewind: no clean segments");
   1564  1.163  perseant 	if (sn >= newsn)
   1565  1.163  perseant 		return ENOENT;
   1566  1.163  perseant 	fs->lfs_nextseg = sn;
   1567  1.163  perseant 	lfs_newseg(fs);
   1568  1.163  perseant 	fs->lfs_offset = fs->lfs_curseg;
   1569  1.163  perseant 
   1570  1.163  perseant 	return 0;
   1571  1.163  perseant }
   1572  1.163  perseant 
   1573  1.163  perseant /*
   1574  1.139      yamt  * Start a new partial segment.
   1575  1.139      yamt  *
   1576  1.139      yamt  * Return 1 when we entered to a new segment.
   1577  1.139      yamt  * Otherwise, return 0.
   1578    1.1   mycroft  */
   1579    1.1   mycroft int
   1580   1.69  perseant lfs_initseg(struct lfs *fs)
   1581    1.1   mycroft {
   1582  1.139      yamt 	struct segment *sp = fs->lfs_sp;
   1583    1.1   mycroft 	SEGSUM *ssp;
   1584  1.139      yamt 	struct buf *sbp;	/* buffer for SEGSUM */
   1585  1.139      yamt 	int repeat = 0;		/* return value */
   1586  1.107  perseant 
   1587  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1588    1.1   mycroft 	/* Advance to the next segment. */
   1589    1.1   mycroft 	if (!LFS_PARTIAL_FITS(fs)) {
   1590  1.139      yamt 		SEGUSE *sup;
   1591  1.139      yamt 		struct buf *bp;
   1592  1.139      yamt 
   1593   1.55  perseant 		/* lfs_avail eats the remaining space */
   1594   1.69  perseant 		fs->lfs_avail -= fs->lfs_fsbpseg - (fs->lfs_offset -
   1595   1.55  perseant 						   fs->lfs_curseg);
   1596    1.1   mycroft 		/* Wake up any cleaning procs waiting on this file system. */
   1597    1.1   mycroft 		wakeup(&lfs_allclean_wakeup);
   1598   1.10      fvdl 		wakeup(&fs->lfs_nextseg);
   1599    1.1   mycroft 		lfs_newseg(fs);
   1600    1.1   mycroft 		repeat = 1;
   1601    1.1   mycroft 		fs->lfs_offset = fs->lfs_curseg;
   1602  1.157     perry 
   1603   1.69  perseant 		sp->seg_number = dtosn(fs, fs->lfs_curseg);
   1604   1.69  perseant 		sp->seg_bytes_left = fsbtob(fs, fs->lfs_fsbpseg);
   1605  1.101  perseant 
   1606    1.1   mycroft 		/*
   1607    1.1   mycroft 		 * If the segment contains a superblock, update the offset
   1608    1.1   mycroft 		 * and summary address to skip over it.
   1609    1.1   mycroft 		 */
   1610    1.1   mycroft 		LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
   1611    1.1   mycroft 		if (sup->su_flags & SEGUSE_SUPERBLOCK) {
   1612   1.69  perseant 			fs->lfs_offset += btofsb(fs, LFS_SBPAD);
   1613    1.1   mycroft 			sp->seg_bytes_left -= LFS_SBPAD;
   1614    1.1   mycroft 		}
   1615    1.1   mycroft 		brelse(bp);
   1616   1.69  perseant 		/* Segment zero could also contain the labelpad */
   1617   1.69  perseant 		if (fs->lfs_version > 1 && sp->seg_number == 0 &&
   1618   1.69  perseant 		    fs->lfs_start < btofsb(fs, LFS_LABELPAD)) {
   1619  1.128      yamt 			fs->lfs_offset +=
   1620  1.128      yamt 			    btofsb(fs, LFS_LABELPAD) - fs->lfs_start;
   1621  1.128      yamt 			sp->seg_bytes_left -=
   1622  1.128      yamt 			    LFS_LABELPAD - fsbtob(fs, fs->lfs_start);
   1623   1.69  perseant 		}
   1624    1.1   mycroft 	} else {
   1625   1.69  perseant 		sp->seg_number = dtosn(fs, fs->lfs_curseg);
   1626   1.69  perseant 		sp->seg_bytes_left = fsbtob(fs, fs->lfs_fsbpseg -
   1627   1.58  perseant 				      (fs->lfs_offset - fs->lfs_curseg));
   1628    1.1   mycroft 	}
   1629    1.1   mycroft 	fs->lfs_lastpseg = fs->lfs_offset;
   1630  1.157     perry 
   1631  1.107  perseant 	/* Record first address of this partial segment */
   1632  1.107  perseant 	if (sp->seg_flags & SEGM_CLEAN) {
   1633  1.107  perseant 		fs->lfs_cleanint[fs->lfs_cleanind] = fs->lfs_offset;
   1634  1.107  perseant 		if (++fs->lfs_cleanind >= LFS_MAX_CLEANIND) {
   1635  1.107  perseant 			/* "1" is the artificial inc in lfs_seglock */
   1636  1.159  perseant 			simple_lock(&fs->lfs_interlock);
   1637  1.107  perseant 			while (fs->lfs_iocount > 1) {
   1638  1.159  perseant 				ltsleep(&fs->lfs_iocount, PRIBIO + 1,
   1639  1.159  perseant 				    "lfs_initseg", 0, &fs->lfs_interlock);
   1640  1.107  perseant 			}
   1641  1.159  perseant 			simple_unlock(&fs->lfs_interlock);
   1642  1.107  perseant 			fs->lfs_cleanind = 0;
   1643  1.107  perseant 		}
   1644  1.107  perseant 	}
   1645  1.107  perseant 
   1646    1.1   mycroft 	sp->fs = fs;
   1647    1.1   mycroft 	sp->ibp = NULL;
   1648   1.27  perseant 	sp->idp = NULL;
   1649    1.1   mycroft 	sp->ninodes = 0;
   1650   1.80  perseant 	sp->ndupino = 0;
   1651   1.69  perseant 
   1652    1.1   mycroft 	sp->cbpp = sp->bpp;
   1653  1.139      yamt 
   1654  1.139      yamt 	/* Get a new buffer for SEGSUM */
   1655  1.145      yamt 	sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
   1656  1.128      yamt 	    fsbtodb(fs, fs->lfs_offset), fs->lfs_sumsize, LFS_NB_SUMMARY);
   1657  1.139      yamt 
   1658  1.139      yamt 	/* ... and enter it into the buffer list. */
   1659  1.139      yamt 	*sp->cbpp = sbp;
   1660  1.139      yamt 	sp->cbpp++;
   1661   1.69  perseant 	fs->lfs_offset += btofsb(fs, fs->lfs_sumsize);
   1662  1.139      yamt 
   1663  1.139      yamt 	sp->start_bpp = sp->cbpp;
   1664  1.157     perry 
   1665    1.1   mycroft 	/* Set point to SEGSUM, initialize it. */
   1666  1.139      yamt 	ssp = sp->segsum = sbp->b_data;
   1667  1.139      yamt 	memset(ssp, 0, fs->lfs_sumsize);
   1668    1.1   mycroft 	ssp->ss_next = fs->lfs_nextseg;
   1669    1.1   mycroft 	ssp->ss_nfinfo = ssp->ss_ninos = 0;
   1670   1.10      fvdl 	ssp->ss_magic = SS_MAGIC;
   1671    1.1   mycroft 
   1672    1.1   mycroft 	/* Set pointer to first FINFO, initialize it. */
   1673   1.69  perseant 	sp->fip = (struct finfo *)((caddr_t)sp->segsum + SEGSUM_SIZE(fs));
   1674    1.1   mycroft 	sp->fip->fi_nblocks = 0;
   1675    1.1   mycroft 	sp->start_lbp = &sp->fip->fi_blocks[0];
   1676   1.10      fvdl 	sp->fip->fi_lastlength = 0;
   1677  1.157     perry 
   1678   1.69  perseant 	sp->seg_bytes_left -= fs->lfs_sumsize;
   1679   1.69  perseant 	sp->sum_bytes_left = fs->lfs_sumsize - SEGSUM_SIZE(fs);
   1680  1.104  perseant 
   1681   1.73       chs 	return (repeat);
   1682    1.1   mycroft }
   1683    1.1   mycroft 
   1684    1.1   mycroft /*
   1685  1.163  perseant  * Remove SEGUSE_INVAL from all segments.
   1686  1.163  perseant  */
   1687  1.163  perseant void
   1688  1.163  perseant lfs_unset_inval_all(struct lfs *fs)
   1689  1.163  perseant {
   1690  1.163  perseant 	SEGUSE *sup;
   1691  1.163  perseant 	struct buf *bp;
   1692  1.163  perseant 	int i;
   1693  1.163  perseant 
   1694  1.163  perseant 	for (i = 0; i < fs->lfs_nseg; i++) {
   1695  1.163  perseant 		LFS_SEGENTRY(sup, fs, i, bp);
   1696  1.163  perseant 		if (sup->su_flags & SEGUSE_INVAL) {
   1697  1.163  perseant 			sup->su_flags &= ~SEGUSE_INVAL;
   1698  1.163  perseant 			VOP_BWRITE(bp);
   1699  1.163  perseant 		} else
   1700  1.163  perseant 			brelse(bp);
   1701  1.163  perseant 	}
   1702  1.163  perseant }
   1703  1.163  perseant 
   1704  1.163  perseant /*
   1705    1.1   mycroft  * Return the next segment to write.
   1706    1.1   mycroft  */
   1707    1.1   mycroft void
   1708   1.69  perseant lfs_newseg(struct lfs *fs)
   1709    1.1   mycroft {
   1710    1.1   mycroft 	CLEANERINFO *cip;
   1711    1.1   mycroft 	SEGUSE *sup;
   1712    1.1   mycroft 	struct buf *bp;
   1713  1.163  perseant 	int curseg, isdirty, sn, skip_inval;
   1714  1.157     perry 
   1715  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1716  1.175  perseant 
   1717  1.175  perseant 	/* Honor LFCNWRAPSTOP */
   1718  1.175  perseant 	simple_lock(&fs->lfs_interlock);
   1719  1.175  perseant 	if (fs->lfs_nowrap && fs->lfs_nextseg < fs->lfs_curseg) {
   1720  1.175  perseant 		wakeup(&fs->lfs_nowrap);
   1721  1.175  perseant 		ltsleep(&fs->lfs_nowrap, PVFS, "newseg", 0,
   1722  1.175  perseant 			&fs->lfs_interlock);
   1723  1.175  perseant 	}
   1724  1.175  perseant 	simple_unlock(&fs->lfs_interlock);
   1725  1.175  perseant 
   1726   1.69  perseant 	LFS_SEGENTRY(sup, fs, dtosn(fs, fs->lfs_nextseg), bp);
   1727  1.158  perseant 	DLOG((DLOG_SU, "lfs_newseg: seg %d := 0 in newseg\n",
   1728  1.158  perseant 	      dtosn(fs, fs->lfs_nextseg)));
   1729   1.15  perseant 	sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;
   1730    1.1   mycroft 	sup->su_nbytes = 0;
   1731    1.1   mycroft 	sup->su_nsums = 0;
   1732    1.1   mycroft 	sup->su_ninos = 0;
   1733  1.101  perseant 	LFS_WRITESEGENTRY(sup, fs, dtosn(fs, fs->lfs_nextseg), bp);
   1734    1.1   mycroft 
   1735    1.1   mycroft 	LFS_CLEANERINFO(cip, fs, bp);
   1736    1.1   mycroft 	--cip->clean;
   1737    1.1   mycroft 	++cip->dirty;
   1738   1.15  perseant 	fs->lfs_nclean = cip->clean;
   1739   1.61  perseant 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
   1740  1.101  perseant 
   1741    1.1   mycroft 	fs->lfs_lastseg = fs->lfs_curseg;
   1742    1.1   mycroft 	fs->lfs_curseg = fs->lfs_nextseg;
   1743  1.163  perseant 	skip_inval = 1;
   1744   1.69  perseant 	for (sn = curseg = dtosn(fs, fs->lfs_curseg) + fs->lfs_interleave;;) {
   1745    1.1   mycroft 		sn = (sn + 1) % fs->lfs_nseg;
   1746  1.174  perseant 
   1747  1.163  perseant 		if (sn == curseg) {
   1748  1.163  perseant 			if (skip_inval)
   1749  1.163  perseant 				skip_inval = 0;
   1750  1.163  perseant 			else
   1751  1.163  perseant 				panic("lfs_nextseg: no clean segments");
   1752  1.163  perseant 		}
   1753    1.1   mycroft 		LFS_SEGENTRY(sup, fs, sn, bp);
   1754  1.163  perseant 		isdirty = sup->su_flags & (SEGUSE_DIRTY | (skip_inval ? SEGUSE_INVAL : 0));
   1755  1.101  perseant 		/* Check SEGUSE_EMPTY as we go along */
   1756  1.128      yamt 		if (isdirty && sup->su_nbytes == 0 &&
   1757  1.128      yamt 		    !(sup->su_flags & SEGUSE_EMPTY))
   1758  1.101  perseant 			LFS_WRITESEGENTRY(sup, fs, sn, bp);
   1759  1.101  perseant 		else
   1760  1.101  perseant 			brelse(bp);
   1761  1.101  perseant 
   1762    1.1   mycroft 		if (!isdirty)
   1763    1.1   mycroft 			break;
   1764    1.1   mycroft 	}
   1765  1.163  perseant 	if (skip_inval == 0)
   1766  1.163  perseant 		lfs_unset_inval_all(fs);
   1767  1.157     perry 
   1768    1.1   mycroft 	++fs->lfs_nactive;
   1769   1.69  perseant 	fs->lfs_nextseg = sntod(fs, sn);
   1770   1.73       chs 	if (lfs_dostats) {
   1771   1.15  perseant 		++lfs_stats.segsused;
   1772   1.15  perseant 	}
   1773    1.1   mycroft }
   1774    1.1   mycroft 
   1775   1.74  perseant static struct buf *
   1776   1.74  perseant lfs_newclusterbuf(struct lfs *fs, struct vnode *vp, daddr_t addr, int n)
   1777   1.74  perseant {
   1778   1.74  perseant 	struct lfs_cluster *cl;
   1779   1.74  perseant 	struct buf **bpp, *bp;
   1780   1.74  perseant 
   1781  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1782  1.101  perseant 	cl = (struct lfs_cluster *)pool_get(&fs->lfs_clpool, PR_WAITOK);
   1783  1.101  perseant 	bpp = (struct buf **)pool_get(&fs->lfs_bpppool, PR_WAITOK);
   1784   1.79  perseant 	memset(cl, 0, sizeof(*cl));
   1785   1.74  perseant 	cl->fs = fs;
   1786   1.74  perseant 	cl->bpp = bpp;
   1787   1.74  perseant 	cl->bufcount = 0;
   1788   1.74  perseant 	cl->bufsize = 0;
   1789   1.74  perseant 
   1790   1.79  perseant 	/* If this segment is being written synchronously, note that */
   1791   1.79  perseant 	if (fs->lfs_sp->seg_flags & SEGM_SYNC) {
   1792   1.79  perseant 		cl->flags |= LFS_CL_SYNC;
   1793   1.79  perseant 		cl->seg = fs->lfs_sp;
   1794   1.79  perseant 		++cl->seg->seg_iocount;
   1795   1.79  perseant 	}
   1796   1.79  perseant 
   1797   1.74  perseant 	/* Get an empty buffer header, or maybe one with something on it */
   1798  1.169      yamt 	bp = getiobuf();
   1799  1.130      yamt 	bp->b_flags = B_BUSY | B_CALL;
   1800  1.130      yamt 	bp->b_dev = NODEV;
   1801   1.74  perseant 	bp->b_blkno = bp->b_lblkno = addr;
   1802   1.74  perseant 	bp->b_iodone = lfs_cluster_callback;
   1803  1.144      yamt 	bp->b_private = cl;
   1804  1.130      yamt 	bp->b_vp = vp;
   1805   1.74  perseant 
   1806   1.74  perseant 	return bp;
   1807   1.74  perseant }
   1808   1.74  perseant 
   1809    1.1   mycroft int
   1810   1.69  perseant lfs_writeseg(struct lfs *fs, struct segment *sp)
   1811    1.1   mycroft {
   1812  1.109  perseant 	struct buf **bpp, *bp, *cbp, *newbp;
   1813    1.1   mycroft 	SEGUSE *sup;
   1814    1.1   mycroft 	SEGSUM *ssp;
   1815  1.101  perseant 	int i, s;
   1816  1.101  perseant 	int do_again, nblocks, byteoffset;
   1817   1.70  jdolecek 	size_t el_size;
   1818  1.103  perseant 	struct lfs_cluster *cl;
   1819    1.1   mycroft 	u_short ninos;
   1820   1.15  perseant 	struct vnode *devvp;
   1821  1.142  christos 	char *p = NULL;
   1822   1.69  perseant 	struct vnode *vp;
   1823   1.91      fvdl 	int32_t *daddrp;	/* XXX ondisk32 */
   1824   1.55  perseant 	int changed;
   1825  1.152      yamt 	u_int32_t sum;
   1826   1.74  perseant 
   1827  1.159  perseant 	ASSERT_SEGLOCK(fs);
   1828    1.1   mycroft 	/*
   1829    1.1   mycroft 	 * If there are no buffers other than the segment summary to write
   1830    1.1   mycroft 	 * and it is not a checkpoint, don't do anything.  On a checkpoint,
   1831    1.1   mycroft 	 * even if there aren't any buffers, you need to write the superblock.
   1832    1.1   mycroft 	 */
   1833    1.1   mycroft 	if ((nblocks = sp->cbpp - sp->bpp) == 1)
   1834    1.1   mycroft 		return (0);
   1835  1.157     perry 
   1836   1.27  perseant 	devvp = VTOI(fs->lfs_ivnode)->i_devvp;
   1837   1.27  perseant 
   1838   1.10      fvdl 	/* Update the segment usage information. */
   1839   1.10      fvdl 	LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
   1840  1.157     perry 
   1841   1.10      fvdl 	/* Loop through all blocks, except the segment summary. */
   1842   1.27  perseant 	for (bpp = sp->bpp; ++bpp < sp->cbpp; ) {
   1843   1.73       chs 		if ((*bpp)->b_vp != devvp) {
   1844   1.27  perseant 			sup->su_nbytes += (*bpp)->b_bcount;
   1845  1.158  perseant 			DLOG((DLOG_SU, "seg %" PRIu32 " += %ld for ino %d"
   1846  1.158  perseant 			      " lbn %" PRId64 " db 0x%" PRIx64 "\n",
   1847  1.158  perseant 			      sp->seg_number, (*bpp)->b_bcount,
   1848  1.158  perseant 			      VTOI((*bpp)->b_vp)->i_number, (*bpp)->b_lblkno,
   1849  1.158  perseant 			      (*bpp)->b_blkno));
   1850   1.69  perseant 		}
   1851   1.27  perseant 	}
   1852  1.157     perry 
   1853    1.1   mycroft 	ssp = (SEGSUM *)sp->segsum;
   1854  1.157     perry 
   1855    1.1   mycroft 	ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs);
   1856  1.158  perseant 	DLOG((DLOG_SU, "seg %d += %d for %d inodes\n",
   1857  1.158  perseant 	      sp->seg_number, ssp->ss_ninos * sizeof (struct ufs1_dinode),
   1858  1.158  perseant 	      ssp->ss_ninos));
   1859  1.119      fvdl 	sup->su_nbytes += ssp->ss_ninos * sizeof (struct ufs1_dinode);
   1860   1.69  perseant 	/* sup->su_nbytes += fs->lfs_sumsize; */
   1861   1.69  perseant 	if (fs->lfs_version == 1)
   1862   1.69  perseant 		sup->su_olastmod = time.tv_sec;
   1863   1.69  perseant 	else
   1864   1.69  perseant 		sup->su_lastmod = time.tv_sec;
   1865    1.1   mycroft 	sup->su_ninos += ninos;
   1866    1.1   mycroft 	++sup->su_nsums;
   1867   1.69  perseant 	fs->lfs_avail -= btofsb(fs, fs->lfs_sumsize);
   1868   1.15  perseant 
   1869    1.1   mycroft 	do_again = !(bp->b_flags & B_GATHERED);
   1870  1.101  perseant 	LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */
   1871  1.101  perseant 
   1872    1.1   mycroft 	/*
   1873   1.53  perseant 	 * Mark blocks B_BUSY, to prevent then from being changed between
   1874   1.53  perseant 	 * the checksum computation and the actual write.
   1875   1.53  perseant 	 *
   1876   1.53  perseant 	 * If we are cleaning, check indirect blocks for UNWRITTEN, and if
   1877   1.53  perseant 	 * there are any, replace them with copies that have UNASSIGNED
   1878   1.53  perseant 	 * instead.
   1879   1.53  perseant 	 */
   1880   1.53  perseant 	for (bpp = sp->bpp, i = nblocks - 1; i--;) {
   1881   1.53  perseant 		++bpp;
   1882  1.101  perseant 		bp = *bpp;
   1883  1.101  perseant 		if (bp->b_flags & B_CALL) { /* UBC or malloced buffer */
   1884  1.101  perseant 			bp->b_flags |= B_BUSY;
   1885   1.53  perseant 			continue;
   1886  1.101  perseant 		}
   1887  1.159  perseant 
   1888  1.159  perseant 		simple_lock(&bp->b_interlock);
   1889   1.53  perseant 		s = splbio();
   1890  1.159  perseant 		while (bp->b_flags & B_BUSY) {
   1891  1.158  perseant 			DLOG((DLOG_SEG, "lfs_writeseg: avoiding potential"
   1892  1.158  perseant 			      " data summary corruption for ino %d, lbn %"
   1893  1.158  perseant 			      PRId64 "\n",
   1894  1.158  perseant 			      VTOI(bp->b_vp)->i_number, bp->b_lblkno));
   1895   1.53  perseant 			bp->b_flags |= B_WANTED;
   1896  1.159  perseant 			ltsleep(bp, (PRIBIO + 1), "lfs_writeseg", 0,
   1897  1.159  perseant 				&bp->b_interlock);
   1898   1.53  perseant 			splx(s);
   1899  1.159  perseant 			s = splbio();
   1900   1.53  perseant 		}
   1901   1.53  perseant 		bp->b_flags |= B_BUSY;
   1902   1.53  perseant 		splx(s);
   1903  1.159  perseant 		simple_unlock(&bp->b_interlock);
   1904  1.159  perseant 
   1905  1.101  perseant 		/*
   1906  1.101  perseant 		 * Check and replace indirect block UNWRITTEN bogosity.
   1907  1.101  perseant 		 * XXX See comment in lfs_writefile.
   1908  1.101  perseant 		 */
   1909   1.73       chs 		if (bp->b_lblkno < 0 && bp->b_vp != devvp && bp->b_vp &&
   1910  1.119      fvdl 		   VTOI(bp->b_vp)->i_ffs1_blocks !=
   1911   1.53  perseant 		   VTOI(bp->b_vp)->i_lfs_effnblks) {
   1912  1.158  perseant 			DLOG((DLOG_VNODE, "lfs_writeseg: cleansing ino %d (%d != %d)\n",
   1913  1.158  perseant 			      VTOI(bp->b_vp)->i_number,
   1914  1.158  perseant 			      VTOI(bp->b_vp)->i_lfs_effnblks,
   1915  1.158  perseant 			      VTOI(bp->b_vp)->i_ffs1_blocks));
   1916   1.53  perseant 			/* Make a copy we'll make changes to */
   1917   1.69  perseant 			newbp = lfs_newbuf(fs, bp->b_vp, bp->b_lblkno,
   1918  1.101  perseant 					   bp->b_bcount, LFS_NB_IBLOCK);
   1919   1.53  perseant 			newbp->b_blkno = bp->b_blkno;
   1920   1.53  perseant 			memcpy(newbp->b_data, bp->b_data,
   1921   1.53  perseant 			       newbp->b_bcount);
   1922   1.53  perseant 
   1923   1.55  perseant 			changed = 0;
   1924   1.91      fvdl 			/* XXX ondisk32 */
   1925   1.91      fvdl 			for (daddrp = (int32_t *)(newbp->b_data);
   1926   1.91      fvdl 			     daddrp < (int32_t *)(newbp->b_data +
   1927   1.53  perseant 						  newbp->b_bcount); daddrp++) {
   1928   1.53  perseant 				if (*daddrp == UNWRITTEN) {
   1929   1.55  perseant 					++changed;
   1930   1.53  perseant 					*daddrp = 0;
   1931   1.53  perseant 				}
   1932   1.53  perseant 			}
   1933   1.55  perseant 			/*
   1934   1.55  perseant 			 * Get rid of the old buffer.  Don't mark it clean,
   1935   1.55  perseant 			 * though, if it still has dirty data on it.
   1936   1.55  perseant 			 */
   1937   1.55  perseant 			if (changed) {
   1938  1.158  perseant 				DLOG((DLOG_SEG, "lfs_writeseg: replacing UNWRITTEN(%d):"
   1939  1.158  perseant 				      " bp = %p newbp = %p\n", changed, bp,
   1940  1.158  perseant 				      newbp));
   1941  1.101  perseant 				*bpp = newbp;
   1942  1.120  perseant 				bp->b_flags &= ~(B_ERROR | B_GATHERED);
   1943   1.69  perseant 				if (bp->b_flags & B_CALL) {
   1944  1.158  perseant 					DLOG((DLOG_SEG, "lfs_writeseg: "
   1945  1.158  perseant 					      "indir bp should not be B_CALL\n"));
   1946  1.101  perseant 					s = splbio();
   1947  1.101  perseant 					biodone(bp);
   1948  1.101  perseant 					splx(s);
   1949   1.69  perseant 					bp = NULL;
   1950   1.69  perseant 				} else {
   1951   1.57  perseant 					/* Still on free list, leave it there */
   1952   1.57  perseant 					s = splbio();
   1953   1.57  perseant 					bp->b_flags &= ~B_BUSY;
   1954   1.57  perseant 					if (bp->b_flags & B_WANTED)
   1955   1.57  perseant 						wakeup(bp);
   1956  1.103  perseant 					splx(s);
   1957   1.62  perseant 					/*
   1958   1.62  perseant 					 * We have to re-decrement lfs_avail
   1959   1.62  perseant 					 * since this block is going to come
   1960   1.62  perseant 					 * back around to us in the next
   1961   1.62  perseant 					 * segment.
   1962   1.62  perseant 					 */
   1963  1.128      yamt 					fs->lfs_avail -=
   1964  1.128      yamt 					    btofsb(fs, bp->b_bcount);
   1965   1.57  perseant 				}
   1966   1.55  perseant 			} else {
   1967  1.101  perseant 				lfs_freebuf(fs, newbp);
   1968   1.55  perseant 			}
   1969   1.53  perseant 		}
   1970   1.53  perseant 	}
   1971   1.53  perseant 	/*
   1972    1.1   mycroft 	 * Compute checksum across data and then across summary; the first
   1973    1.1   mycroft 	 * block (the summary block) is skipped.  Set the create time here
   1974    1.1   mycroft 	 * so that it's guaranteed to be later than the inode mod times.
   1975    1.1   mycroft 	 */
   1976  1.152      yamt 	sum = 0;
   1977   1.69  perseant 	if (fs->lfs_version == 1)
   1978   1.69  perseant 		el_size = sizeof(u_long);
   1979   1.69  perseant 	else
   1980   1.69  perseant 		el_size = sizeof(u_int32_t);
   1981  1.101  perseant 	for (bpp = sp->bpp, i = nblocks - 1; i--; ) {
   1982  1.101  perseant 		++bpp;
   1983  1.101  perseant 		/* Loop through gop_write cluster blocks */
   1984  1.101  perseant 		for (byteoffset = 0; byteoffset < (*bpp)->b_bcount;
   1985  1.101  perseant 		     byteoffset += fs->lfs_bsize) {
   1986  1.109  perseant #ifdef LFS_USE_B_INVAL
   1987  1.101  perseant 			if (((*bpp)->b_flags & (B_CALL | B_INVAL)) ==
   1988  1.101  perseant 			    (B_CALL | B_INVAL)) {
   1989  1.101  perseant 				if (copyin((caddr_t)(*bpp)->b_saveaddr +
   1990  1.101  perseant 					   byteoffset, dp, el_size)) {
   1991  1.128      yamt 					panic("lfs_writeseg: copyin failed [1]:"
   1992  1.128      yamt 						" ino %d blk %" PRId64,
   1993  1.101  perseant 						VTOI((*bpp)->b_vp)->i_number,
   1994  1.101  perseant 						(*bpp)->b_lblkno);
   1995  1.101  perseant 				}
   1996  1.109  perseant 			} else
   1997  1.109  perseant #endif /* LFS_USE_B_INVAL */
   1998  1.109  perseant 			{
   1999  1.152      yamt 				sum = lfs_cksum_part(
   2000  1.152      yamt 				    (*bpp)->b_data + byteoffset, el_size, sum);
   2001  1.101  perseant 			}
   2002  1.101  perseant 		}
   2003   1.69  perseant 	}
   2004   1.69  perseant 	if (fs->lfs_version == 1)
   2005   1.69  perseant 		ssp->ss_ocreate = time.tv_sec;
   2006   1.69  perseant 	else {
   2007   1.69  perseant 		ssp->ss_create = time.tv_sec;
   2008   1.69  perseant 		ssp->ss_serial = ++fs->lfs_serial;
   2009   1.69  perseant 		ssp->ss_ident  = fs->lfs_ident;
   2010    1.1   mycroft 	}
   2011  1.152      yamt 	ssp->ss_datasum = lfs_cksum_fold(sum);
   2012  1.152      yamt 	ssp->ss_sumsum = cksum(&ssp->ss_datasum,
   2013  1.152      yamt 	    fs->lfs_sumsize - sizeof(ssp->ss_sumsum));
   2014  1.156  perseant 
   2015  1.159  perseant 	simple_lock(&fs->lfs_interlock);
   2016   1.69  perseant 	fs->lfs_bfree -= (btofsb(fs, ninos * fs->lfs_ibsize) +
   2017   1.69  perseant 			  btofsb(fs, fs->lfs_sumsize));
   2018  1.170       tls 	fs->lfs_dmeta += (btofsb(fs, ninos * fs->lfs_ibsize) +
   2019  1.170       tls 			  btofsb(fs, fs->lfs_sumsize));
   2020  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
   2021    1.1   mycroft 
   2022    1.1   mycroft 	/*
   2023  1.103  perseant 	 * When we simply write the blocks we lose a rotation for every block
   2024  1.109  perseant 	 * written.  To avoid this problem, we cluster the buffers into a
   2025  1.109  perseant 	 * chunk and write the chunk.  MAXPHYS is the largest size I/O
   2026  1.109  perseant 	 * devices can handle, use that for the size of the chunks.
   2027  1.103  perseant 	 *
   2028  1.109  perseant 	 * Blocks that are already clusters (from GOP_WRITE), however, we
   2029  1.109  perseant 	 * don't bother to copy into other clusters.
   2030    1.1   mycroft 	 */
   2031   1.15  perseant 
   2032   1.15  perseant #define CHUNKSIZE MAXPHYS
   2033   1.15  perseant 
   2034   1.73       chs 	if (devvp == NULL)
   2035   1.15  perseant 		panic("devvp is NULL");
   2036   1.74  perseant 	for (bpp = sp->bpp, i = nblocks; i;) {
   2037   1.74  perseant 		cbp = lfs_newclusterbuf(fs, devvp, (*bpp)->b_blkno, i);
   2038  1.144      yamt 		cl = cbp->b_private;
   2039   1.74  perseant 
   2040    1.1   mycroft 		cbp->b_flags |= B_ASYNC | B_BUSY;
   2041   1.10      fvdl 		cbp->b_bcount = 0;
   2042    1.1   mycroft 
   2043   1.74  perseant #if defined(DEBUG) && defined(DIAGNOSTIC)
   2044  1.104  perseant 		if (bpp - sp->bpp > (fs->lfs_sumsize - SEGSUM_SIZE(fs))
   2045  1.104  perseant 		    / sizeof(int32_t)) {
   2046  1.104  perseant 			panic("lfs_writeseg: real bpp overwrite");
   2047  1.104  perseant 		}
   2048  1.151      yamt 		if (bpp - sp->bpp > segsize(fs) / fs->lfs_fsize) {
   2049  1.104  perseant 			panic("lfs_writeseg: theoretical bpp overwrite");
   2050  1.104  perseant 		}
   2051   1.17  perseant #endif
   2052   1.17  perseant 
   2053   1.74  perseant 		/*
   2054   1.74  perseant 		 * Construct the cluster.
   2055   1.74  perseant 		 */
   2056  1.159  perseant 		simple_lock(&fs->lfs_interlock);
   2057    1.1   mycroft 		++fs->lfs_iocount;
   2058  1.159  perseant 		simple_unlock(&fs->lfs_interlock);
   2059  1.115  perseant 		while (i && cbp->b_bcount < CHUNKSIZE) {
   2060   1.10      fvdl 			bp = *bpp;
   2061   1.15  perseant 
   2062   1.15  perseant 			if (bp->b_bcount > (CHUNKSIZE - cbp->b_bcount))
   2063   1.10      fvdl 				break;
   2064  1.109  perseant 			if (cbp->b_bcount > 0 && !(cl->flags & LFS_CL_MALLOC))
   2065  1.109  perseant 				break;
   2066   1.10      fvdl 
   2067  1.109  perseant 			/* Clusters from GOP_WRITE are expedited */
   2068  1.109  perseant 			if (bp->b_bcount > fs->lfs_bsize) {
   2069  1.109  perseant 				if (cbp->b_bcount > 0)
   2070  1.109  perseant 					/* Put in its own buffer */
   2071  1.109  perseant 					break;
   2072  1.109  perseant 				else {
   2073  1.109  perseant 					cbp->b_data = bp->b_data;
   2074  1.109  perseant 				}
   2075  1.109  perseant 			} else if (cbp->b_bcount == 0) {
   2076  1.109  perseant 				p = cbp->b_data = lfs_malloc(fs, CHUNKSIZE,
   2077  1.109  perseant 							     LFS_NB_CLUSTER);
   2078  1.109  perseant 				cl->flags |= LFS_CL_MALLOC;
   2079  1.109  perseant 			}
   2080  1.101  perseant #ifdef DIAGNOSTIC
   2081  1.101  perseant 			if (dtosn(fs, dbtofsb(fs, bp->b_blkno +
   2082  1.101  perseant 					      btodb(bp->b_bcount - 1))) !=
   2083  1.101  perseant 			    sp->seg_number) {
   2084  1.155      yamt 				printf("blk size %d daddr %" PRIx64
   2085  1.128      yamt 				    " not in seg %d\n",
   2086  1.128      yamt 				    bp->b_bcount, bp->b_blkno,
   2087  1.128      yamt 				    sp->seg_number);
   2088  1.101  perseant 				panic("segment overwrite");
   2089  1.101  perseant 			}
   2090  1.101  perseant #endif
   2091  1.101  perseant 
   2092  1.109  perseant #ifdef LFS_USE_B_INVAL
   2093    1.1   mycroft 			/*
   2094    1.1   mycroft 			 * Fake buffers from the cleaner are marked as B_INVAL.
   2095    1.1   mycroft 			 * We need to copy the data from user space rather than
   2096    1.1   mycroft 			 * from the buffer indicated.
   2097    1.1   mycroft 			 * XXX == what do I do on an error?
   2098    1.1   mycroft 			 */
   2099  1.128      yamt 			if ((bp->b_flags & (B_CALL|B_INVAL)) ==
   2100  1.128      yamt 			    (B_CALL|B_INVAL)) {
   2101    1.1   mycroft 				if (copyin(bp->b_saveaddr, p, bp->b_bcount))
   2102  1.128      yamt 					panic("lfs_writeseg: "
   2103  1.128      yamt 					    "copyin failed [2]");
   2104  1.109  perseant 			} else
   2105  1.109  perseant #endif /* LFS_USE_B_INVAL */
   2106  1.109  perseant 			if (cl->flags & LFS_CL_MALLOC) {
   2107  1.137      yamt 				/* copy data into our cluster. */
   2108  1.137      yamt 				memcpy(p, bp->b_data, bp->b_bcount);
   2109  1.137      yamt 				p += bp->b_bcount;
   2110  1.103  perseant 			}
   2111  1.157     perry 
   2112  1.109  perseant 			cbp->b_bcount += bp->b_bcount;
   2113  1.109  perseant 			cl->bufsize += bp->b_bcount;
   2114  1.109  perseant 
   2115   1.74  perseant 			bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | B_DONE);
   2116   1.74  perseant 			cl->bpp[cl->bufcount++] = bp;
   2117   1.74  perseant 			vp = bp->b_vp;
   2118   1.79  perseant 			s = splbio();
   2119  1.135      yamt 			reassignbuf(bp, vp);
   2120  1.100        pk 			V_INCR_NUMOUTPUT(vp);
   2121   1.79  perseant 			splx(s);
   2122   1.26  perseant 
   2123   1.26  perseant 			bpp++;
   2124  1.109  perseant 			i--;
   2125    1.1   mycroft 		}
   2126  1.147      yamt 		if (fs->lfs_sp->seg_flags & SEGM_SYNC)
   2127  1.147      yamt 			BIO_SETPRIO(cbp, BPRIO_TIMECRITICAL);
   2128  1.147      yamt 		else
   2129  1.147      yamt 			BIO_SETPRIO(cbp, BPRIO_TIMELIMITED);
   2130   1.79  perseant 		s = splbio();
   2131  1.109  perseant 		V_INCR_NUMOUTPUT(devvp);
   2132    1.1   mycroft 		splx(s);
   2133  1.149      yamt 		VOP_STRATEGY(devvp, cbp);
   2134  1.109  perseant 		curproc->p_stats->p_ru.ru_oublock++;
   2135    1.1   mycroft 	}
   2136   1.74  perseant 
   2137   1.73       chs 	if (lfs_dostats) {
   2138   1.15  perseant 		++lfs_stats.psegwrites;
   2139   1.15  perseant 		lfs_stats.blocktot += nblocks - 1;
   2140   1.15  perseant 		if (fs->lfs_sp->seg_flags & SEGM_SYNC)
   2141   1.15  perseant 			++lfs_stats.psyncwrites;
   2142   1.15  perseant 		if (fs->lfs_sp->seg_flags & SEGM_CLEAN) {
   2143   1.15  perseant 			++lfs_stats.pcleanwrites;
   2144   1.15  perseant 			lfs_stats.cleanblocks += nblocks - 1;
   2145   1.15  perseant 		}
   2146    1.1   mycroft 	}
   2147    1.1   mycroft 	return (lfs_initseg(fs) || do_again);
   2148    1.1   mycroft }
   2149    1.1   mycroft 
   2150    1.1   mycroft void
   2151   1.69  perseant lfs_writesuper(struct lfs *fs, daddr_t daddr)
   2152    1.1   mycroft {
   2153    1.1   mycroft 	struct buf *bp;
   2154    1.1   mycroft 	int s;
   2155  1.149      yamt 	struct vnode *devvp = VTOI(fs->lfs_ivnode)->i_devvp;
   2156    1.1   mycroft 
   2157  1.159  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
   2158  1.156  perseant #ifdef DIAGNOSTIC
   2159  1.156  perseant 	KASSERT(fs->lfs_magic == LFS_MAGIC);
   2160  1.156  perseant #endif
   2161   1.15  perseant 	/*
   2162   1.15  perseant 	 * If we can write one superblock while another is in
   2163   1.15  perseant 	 * progress, we risk not having a complete checkpoint if we crash.
   2164   1.15  perseant 	 * So, block here if a superblock write is in progress.
   2165   1.15  perseant 	 */
   2166  1.159  perseant 	simple_lock(&fs->lfs_interlock);
   2167   1.36  perseant 	s = splbio();
   2168   1.73       chs 	while (fs->lfs_sbactive) {
   2169  1.159  perseant 		ltsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0,
   2170  1.159  perseant 			&fs->lfs_interlock);
   2171   1.15  perseant 	}
   2172   1.15  perseant 	fs->lfs_sbactive = daddr;
   2173   1.36  perseant 	splx(s);
   2174  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
   2175    1.1   mycroft 
   2176   1.15  perseant 	/* Set timestamp of this version of the superblock */
   2177   1.69  perseant 	if (fs->lfs_version == 1)
   2178   1.69  perseant 		fs->lfs_otstamp = time.tv_sec;
   2179   1.15  perseant 	fs->lfs_tstamp = time.tv_sec;
   2180   1.15  perseant 
   2181    1.1   mycroft 	/* Checksum the superblock and copy it into a buffer. */
   2182   1.12        pk 	fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
   2183  1.149      yamt 	bp = lfs_newbuf(fs, devvp,
   2184  1.128      yamt 	    fsbtodb(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);
   2185  1.128      yamt 	memset(bp->b_data + sizeof(struct dlfs), 0,
   2186  1.128      yamt 	    LFS_SBPAD - sizeof(struct dlfs));
   2187   1.12        pk 	*(struct dlfs *)bp->b_data = fs->lfs_dlfs;
   2188  1.157     perry 
   2189    1.1   mycroft 	bp->b_flags |= B_BUSY | B_CALL | B_ASYNC;
   2190    1.1   mycroft 	bp->b_flags &= ~(B_DONE | B_ERROR | B_READ | B_DELWRI);
   2191    1.1   mycroft 	bp->b_iodone = lfs_supercallback;
   2192   1.15  perseant 
   2193  1.147      yamt 	if (fs->lfs_sp != NULL && fs->lfs_sp->seg_flags & SEGM_SYNC)
   2194  1.147      yamt 		BIO_SETPRIO(bp, BPRIO_TIMECRITICAL);
   2195  1.147      yamt 	else
   2196  1.147      yamt 		BIO_SETPRIO(bp, BPRIO_TIMELIMITED);
   2197  1.109  perseant 	curproc->p_stats->p_ru.ru_oublock++;
   2198    1.1   mycroft 	s = splbio();
   2199  1.100        pk 	V_INCR_NUMOUTPUT(bp->b_vp);
   2200   1.79  perseant 	splx(s);
   2201  1.159  perseant 	simple_lock(&fs->lfs_interlock);
   2202   1.52  perseant 	++fs->lfs_iocount;
   2203  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
   2204  1.149      yamt 	VOP_STRATEGY(devvp, bp);
   2205    1.1   mycroft }
   2206    1.1   mycroft 
   2207    1.1   mycroft /*
   2208    1.1   mycroft  * Logical block number match routines used when traversing the dirty block
   2209    1.1   mycroft  * chain.
   2210    1.1   mycroft  */
   2211    1.1   mycroft int
   2212   1.69  perseant lfs_match_fake(struct lfs *fs, struct buf *bp)
   2213   1.15  perseant {
   2214  1.129      yamt 
   2215  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2216  1.101  perseant 	return LFS_IS_MALLOC_BUF(bp);
   2217   1.15  perseant }
   2218   1.15  perseant 
   2219  1.101  perseant #if 0
   2220  1.101  perseant int
   2221  1.101  perseant lfs_match_real(struct lfs *fs, struct buf *bp)
   2222  1.101  perseant {
   2223  1.129      yamt 
   2224  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2225  1.101  perseant 	return (lfs_match_data(fs, bp) && !lfs_match_fake(fs, bp));
   2226  1.101  perseant }
   2227  1.101  perseant #endif
   2228  1.101  perseant 
   2229   1.15  perseant int
   2230   1.69  perseant lfs_match_data(struct lfs *fs, struct buf *bp)
   2231    1.1   mycroft {
   2232  1.129      yamt 
   2233  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2234    1.1   mycroft 	return (bp->b_lblkno >= 0);
   2235    1.1   mycroft }
   2236    1.1   mycroft 
   2237    1.1   mycroft int
   2238   1.69  perseant lfs_match_indir(struct lfs *fs, struct buf *bp)
   2239    1.1   mycroft {
   2240   1.91      fvdl 	daddr_t lbn;
   2241    1.1   mycroft 
   2242  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2243    1.1   mycroft 	lbn = bp->b_lblkno;
   2244    1.1   mycroft 	return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 0);
   2245    1.1   mycroft }
   2246    1.1   mycroft 
   2247    1.1   mycroft int
   2248   1.69  perseant lfs_match_dindir(struct lfs *fs, struct buf *bp)
   2249    1.1   mycroft {
   2250   1.91      fvdl 	daddr_t lbn;
   2251    1.1   mycroft 
   2252  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2253    1.1   mycroft 	lbn = bp->b_lblkno;
   2254    1.1   mycroft 	return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 1);
   2255    1.1   mycroft }
   2256    1.1   mycroft 
   2257    1.1   mycroft int
   2258   1.69  perseant lfs_match_tindir(struct lfs *fs, struct buf *bp)
   2259    1.1   mycroft {
   2260   1.91      fvdl 	daddr_t lbn;
   2261    1.1   mycroft 
   2262  1.159  perseant 	ASSERT_SEGLOCK(fs);
   2263    1.1   mycroft 	lbn = bp->b_lblkno;
   2264    1.1   mycroft 	return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 2);
   2265    1.1   mycroft }
   2266    1.1   mycroft 
   2267    1.1   mycroft /*
   2268   1.15  perseant  * XXX - The only buffers that are going to hit these functions are the
   2269   1.15  perseant  * segment write blocks, or the segment summaries, or the superblocks.
   2270  1.157     perry  *
   2271   1.15  perseant  * All of the above are created by lfs_newbuf, and so do not need to be
   2272   1.15  perseant  * released via brelse.
   2273    1.1   mycroft  */
   2274    1.1   mycroft void
   2275   1.69  perseant lfs_callback(struct buf *bp)
   2276    1.1   mycroft {
   2277  1.101  perseant 	struct lfs *fs;
   2278  1.101  perseant 
   2279  1.144      yamt 	fs = bp->b_private;
   2280  1.159  perseant 	ASSERT_NO_SEGLOCK(fs);
   2281  1.101  perseant 	lfs_freebuf(fs, bp);
   2282    1.1   mycroft }
   2283    1.1   mycroft 
   2284   1.79  perseant static void
   2285   1.79  perseant lfs_super_aiodone(struct buf *bp)
   2286    1.1   mycroft {
   2287   1.15  perseant 	struct lfs *fs;
   2288   1.15  perseant 
   2289  1.144      yamt 	fs = bp->b_private;
   2290  1.159  perseant 	ASSERT_NO_SEGLOCK(fs);
   2291  1.159  perseant 	simple_lock(&fs->lfs_interlock);
   2292   1.45   thorpej 	fs->lfs_sbactive = 0;
   2293  1.107  perseant 	if (--fs->lfs_iocount <= 1)
   2294   1.52  perseant 		wakeup(&fs->lfs_iocount);
   2295  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
   2296  1.159  perseant 	wakeup(&fs->lfs_sbactive);
   2297  1.101  perseant 	lfs_freebuf(fs, bp);
   2298   1.74  perseant }
   2299   1.74  perseant 
   2300   1.74  perseant static void
   2301   1.79  perseant lfs_cluster_aiodone(struct buf *bp)
   2302   1.74  perseant {
   2303   1.74  perseant 	struct lfs_cluster *cl;
   2304   1.74  perseant 	struct lfs *fs;
   2305  1.109  perseant 	struct buf *tbp, *fbp;
   2306  1.101  perseant 	struct vnode *vp, *devvp;
   2307  1.109  perseant 	struct inode *ip;
   2308   1.79  perseant 	int s, error=0;
   2309   1.74  perseant 
   2310  1.115  perseant 	if (bp->b_flags & B_ERROR)
   2311   1.74  perseant 		error = bp->b_error;
   2312   1.74  perseant 
   2313  1.144      yamt 	cl = bp->b_private;
   2314   1.74  perseant 	fs = cl->fs;
   2315  1.101  perseant 	devvp = VTOI(fs->lfs_ivnode)->i_devvp;
   2316  1.159  perseant 	ASSERT_NO_SEGLOCK(fs);
   2317   1.74  perseant 
   2318   1.74  perseant 	/* Put the pages back, and release the buffer */
   2319  1.115  perseant 	while (cl->bufcount--) {
   2320   1.74  perseant 		tbp = cl->bpp[cl->bufcount];
   2321  1.153      yamt 		KASSERT(tbp->b_flags & B_BUSY);
   2322  1.115  perseant 		if (error) {
   2323   1.74  perseant 			tbp->b_flags |= B_ERROR;
   2324   1.74  perseant 			tbp->b_error = error;
   2325   1.74  perseant 		}
   2326   1.74  perseant 
   2327   1.74  perseant 		/*
   2328  1.103  perseant 		 * We're done with tbp.	 If it has not been re-dirtied since
   2329   1.74  perseant 		 * the cluster was written, free it.  Otherwise, keep it on
   2330   1.74  perseant 		 * the locked list to be written again.
   2331   1.74  perseant 		 */
   2332  1.101  perseant 		vp = tbp->b_vp;
   2333  1.114  perseant 
   2334   1.74  perseant 		tbp->b_flags &= ~B_GATHERED;
   2335   1.74  perseant 
   2336   1.74  perseant 		LFS_BCLEAN_LOG(fs, tbp);
   2337   1.74  perseant 
   2338  1.115  perseant 		if (!(tbp->b_flags & B_CALL)) {
   2339  1.136      yamt 			KASSERT(tbp->b_flags & B_LOCKED);
   2340  1.132      yamt 			s = splbio();
   2341  1.132      yamt 			simple_lock(&bqueue_slock);
   2342   1.74  perseant 			bremfree(tbp);
   2343  1.132      yamt 			simple_unlock(&bqueue_slock);
   2344  1.115  perseant 			if (vp)
   2345   1.74  perseant 				reassignbuf(tbp, vp);
   2346   1.79  perseant 			splx(s);
   2347   1.74  perseant 			tbp->b_flags |= B_ASYNC; /* for biodone */
   2348   1.74  perseant 		}
   2349  1.132      yamt 
   2350  1.132      yamt 		if ((tbp->b_flags & (B_LOCKED | B_DELWRI)) == B_LOCKED)
   2351  1.132      yamt 			LFS_UNLOCK_BUF(tbp);
   2352  1.132      yamt 
   2353   1.74  perseant 		if (tbp->b_flags & B_DONE) {
   2354  1.158  perseant 			DLOG((DLOG_SEG, "blk %d biodone already (flags %lx)\n",
   2355  1.158  perseant 				cl->bufcount, (long)tbp->b_flags));
   2356   1.74  perseant 		}
   2357  1.109  perseant 
   2358  1.153      yamt 		if ((tbp->b_flags & B_CALL) && !LFS_IS_MALLOC_BUF(tbp)) {
   2359  1.109  perseant 			/*
   2360  1.153      yamt 			 * A buffer from the page daemon.
   2361  1.153      yamt 			 * We use the same iodone as it does,
   2362  1.153      yamt 			 * so we must manually disassociate its
   2363  1.153      yamt 			 * buffers from the vp.
   2364  1.109  perseant 			 */
   2365  1.153      yamt 			if (tbp->b_vp) {
   2366  1.153      yamt 				/* This is just silly */
   2367  1.153      yamt 				s = splbio();
   2368  1.153      yamt 				brelvp(tbp);
   2369  1.153      yamt 				tbp->b_vp = vp;
   2370  1.153      yamt 				splx(s);
   2371  1.153      yamt 			}
   2372  1.153      yamt 			/* Put it back the way it was */
   2373  1.153      yamt 			tbp->b_flags |= B_ASYNC;
   2374  1.153      yamt 			/* Master buffers have B_AGE */
   2375  1.153      yamt 			if (tbp->b_private == tbp)
   2376  1.153      yamt 				tbp->b_flags |= B_AGE;
   2377  1.153      yamt 		}
   2378  1.153      yamt 		s = splbio();
   2379  1.153      yamt 		biodone(tbp);
   2380  1.153      yamt 
   2381  1.153      yamt 		/*
   2382  1.153      yamt 		 * If this is the last block for this vnode, but
   2383  1.153      yamt 		 * there are other blocks on its dirty list,
   2384  1.153      yamt 		 * set IN_MODIFIED/IN_CLEANING depending on what
   2385  1.153      yamt 		 * sort of block.  Only do this for our mount point,
   2386  1.153      yamt 		 * not for, e.g., inode blocks that are attached to
   2387  1.153      yamt 		 * the devvp.
   2388  1.153      yamt 		 * XXX KS - Shouldn't we set *both* if both types
   2389  1.153      yamt 		 * of blocks are present (traverse the dirty list?)
   2390  1.153      yamt 		 */
   2391  1.153      yamt 		simple_lock(&global_v_numoutput_slock);
   2392  1.153      yamt 		if (vp != devvp && vp->v_numoutput == 0 &&
   2393  1.153      yamt 		    (fbp = LIST_FIRST(&vp->v_dirtyblkhd)) != NULL) {
   2394  1.153      yamt 			ip = VTOI(vp);
   2395  1.158  perseant 			DLOG((DLOG_SEG, "lfs_cluster_aiodone: mark ino %d\n",
   2396  1.158  perseant 			       ip->i_number));
   2397  1.153      yamt 			if (LFS_IS_MALLOC_BUF(fbp))
   2398  1.153      yamt 				LFS_SET_UINO(ip, IN_CLEANING);
   2399  1.153      yamt 			else
   2400  1.153      yamt 				LFS_SET_UINO(ip, IN_MODIFIED);
   2401   1.74  perseant 		}
   2402  1.153      yamt 		simple_unlock(&global_v_numoutput_slock);
   2403  1.153      yamt 		splx(s);
   2404  1.153      yamt 		wakeup(vp);
   2405   1.74  perseant 	}
   2406   1.74  perseant 
   2407   1.74  perseant 	/* Fix up the cluster buffer, and release it */
   2408  1.109  perseant 	if (cl->flags & LFS_CL_MALLOC)
   2409  1.101  perseant 		lfs_free(fs, bp->b_data, LFS_NB_CLUSTER);
   2410  1.169      yamt 	putiobuf(bp);
   2411   1.74  perseant 
   2412   1.79  perseant 	/* Note i/o done */
   2413   1.79  perseant 	if (cl->flags & LFS_CL_SYNC) {
   2414  1.157     perry 		if (--cl->seg->seg_iocount == 0)
   2415   1.79  perseant 			wakeup(&cl->seg->seg_iocount);
   2416   1.79  perseant 	}
   2417  1.159  perseant 	simple_lock(&fs->lfs_interlock);
   2418   1.74  perseant #ifdef DIAGNOSTIC
   2419   1.74  perseant 	if (fs->lfs_iocount == 0)
   2420   1.82    provos 		panic("lfs_cluster_aiodone: zero iocount");
   2421   1.74  perseant #endif
   2422  1.107  perseant 	if (--fs->lfs_iocount <= 1)
   2423   1.74  perseant 		wakeup(&fs->lfs_iocount);
   2424  1.159  perseant 	simple_unlock(&fs->lfs_interlock);
   2425   1.79  perseant 
   2426  1.101  perseant 	pool_put(&fs->lfs_bpppool, cl->bpp);
   2427  1.101  perseant 	cl->bpp = NULL;
   2428  1.101  perseant 	pool_put(&fs->lfs_clpool, cl);
   2429   1.79  perseant }
   2430   1.79  perseant 
   2431   1.79  perseant static void
   2432   1.79  perseant lfs_generic_callback(struct buf *bp, void (*aiodone)(struct buf *))
   2433   1.79  perseant {
   2434   1.79  perseant 	/* reset b_iodone for when this is a single-buf i/o. */
   2435   1.79  perseant 	bp->b_iodone = aiodone;
   2436   1.79  perseant 
   2437  1.103  perseant 	simple_lock(&uvm.aiodoned_lock);	/* locks uvm.aio_done */
   2438   1.79  perseant 	TAILQ_INSERT_TAIL(&uvm.aio_done, bp, b_freelist);
   2439   1.79  perseant 	wakeup(&uvm.aiodoned);
   2440   1.79  perseant 	simple_unlock(&uvm.aiodoned_lock);
   2441   1.79  perseant }
   2442   1.79  perseant 
   2443   1.79  perseant static void
   2444   1.79  perseant lfs_cluster_callback(struct buf *bp)
   2445   1.79  perseant {
   2446  1.129      yamt 
   2447   1.79  perseant 	lfs_generic_callback(bp, lfs_cluster_aiodone);
   2448   1.79  perseant }
   2449   1.79  perseant 
   2450   1.79  perseant void
   2451   1.79  perseant lfs_supercallback(struct buf *bp)
   2452   1.79  perseant {
   2453  1.129      yamt 
   2454   1.79  perseant 	lfs_generic_callback(bp, lfs_super_aiodone);
   2455    1.1   mycroft }
   2456    1.1   mycroft 
   2457    1.1   mycroft /*
   2458    1.1   mycroft  * Shellsort (diminishing increment sort) from Data Structures and
   2459    1.1   mycroft  * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290;
   2460    1.1   mycroft  * see also Knuth Vol. 3, page 84.  The increments are selected from
   2461    1.1   mycroft  * formula (8), page 95.  Roughly O(N^3/2).
   2462    1.1   mycroft  */
   2463    1.1   mycroft /*
   2464    1.1   mycroft  * This is our own private copy of shellsort because we want to sort
   2465    1.1   mycroft  * two parallel arrays (the array of buffer pointers and the array of
   2466    1.1   mycroft  * logical block numbers) simultaneously.  Note that we cast the array
   2467    1.1   mycroft  * of logical block numbers to a unsigned in this routine so that the
   2468    1.1   mycroft  * negative block numbers (meta data blocks) sort AFTER the data blocks.
   2469    1.1   mycroft  */
   2470   1.15  perseant 
   2471    1.1   mycroft void
   2472  1.104  perseant lfs_shellsort(struct buf **bp_array, int32_t *lb_array, int nmemb, int size)
   2473    1.1   mycroft {
   2474    1.1   mycroft 	static int __rsshell_increments[] = { 4, 1, 0 };
   2475   1.42  augustss 	int incr, *incrp, t1, t2;
   2476    1.1   mycroft 	struct buf *bp_temp;
   2477  1.118      yamt 
   2478  1.118      yamt #ifdef DEBUG
   2479  1.118      yamt 	incr = 0;
   2480  1.118      yamt 	for (t1 = 0; t1 < nmemb; t1++) {
   2481  1.118      yamt 		for (t2 = 0; t2 * size < bp_array[t1]->b_bcount; t2++) {
   2482  1.118      yamt 			if (lb_array[incr++] != bp_array[t1]->b_lblkno + t2) {
   2483  1.118      yamt 				/* dump before panic */
   2484  1.118      yamt 				printf("lfs_shellsort: nmemb=%d, size=%d\n",
   2485  1.118      yamt 				    nmemb, size);
   2486  1.118      yamt 				incr = 0;
   2487  1.118      yamt 				for (t1 = 0; t1 < nmemb; t1++) {
   2488  1.118      yamt 					const struct buf *bp = bp_array[t1];
   2489  1.118      yamt 
   2490  1.118      yamt 					printf("bp[%d]: lbn=%" PRIu64 ", size=%"
   2491  1.118      yamt 					    PRIu64 "\n", t1,
   2492  1.118      yamt 					    (uint64_t)bp->b_bcount,
   2493  1.118      yamt 					    (uint64_t)bp->b_lblkno);
   2494  1.118      yamt 					printf("lbns:");
   2495  1.118      yamt 					for (t2 = 0; t2 * size < bp->b_bcount;
   2496  1.118      yamt 					    t2++) {
   2497  1.118      yamt 						printf(" %" PRId32,
   2498  1.118      yamt 						    lb_array[incr++]);
   2499  1.118      yamt 					}
   2500  1.118      yamt 					printf("\n");
   2501  1.118      yamt 				}
   2502  1.118      yamt 				panic("lfs_shellsort: inconsistent input");
   2503  1.118      yamt 			}
   2504  1.118      yamt 		}
   2505  1.118      yamt 	}
   2506  1.118      yamt #endif
   2507    1.1   mycroft 
   2508    1.4  christos 	for (incrp = __rsshell_increments; (incr = *incrp++) != 0;)
   2509    1.1   mycroft 		for (t1 = incr; t1 < nmemb; ++t1)
   2510    1.1   mycroft 			for (t2 = t1 - incr; t2 >= 0;)
   2511  1.104  perseant 				if ((u_int32_t)bp_array[t2]->b_lblkno >
   2512  1.104  perseant 				    (u_int32_t)bp_array[t2 + incr]->b_lblkno) {
   2513    1.1   mycroft 					bp_temp = bp_array[t2];
   2514    1.1   mycroft 					bp_array[t2] = bp_array[t2 + incr];
   2515    1.1   mycroft 					bp_array[t2 + incr] = bp_temp;
   2516    1.1   mycroft 					t2 -= incr;
   2517    1.1   mycroft 				} else
   2518    1.1   mycroft 					break;
   2519  1.104  perseant 
   2520  1.104  perseant 	/* Reform the list of logical blocks */
   2521  1.104  perseant 	incr = 0;
   2522  1.104  perseant 	for (t1 = 0; t1 < nmemb; t1++) {
   2523  1.104  perseant 		for (t2 = 0; t2 * size < bp_array[t1]->b_bcount; t2++) {
   2524  1.104  perseant 			lb_array[incr++] = bp_array[t1]->b_lblkno + t2;
   2525  1.104  perseant 		}
   2526  1.104  perseant 	}
   2527    1.1   mycroft }
   2528    1.1   mycroft 
   2529    1.1   mycroft /*
   2530  1.173  perseant  * Call vget with LK_NOWAIT.  If we are the one who holds VXLOCK/VFREEING,
   2531  1.173  perseant  * however, we must press on.  Just fake success in that case.
   2532    1.1   mycroft  */
   2533    1.4  christos int
   2534   1.69  perseant lfs_vref(struct vnode *vp)
   2535    1.1   mycroft {
   2536  1.173  perseant 	int error;
   2537  1.173  perseant 	struct lfs *fs;
   2538  1.173  perseant 
   2539  1.173  perseant 	fs = VTOI(vp)->i_lfs;
   2540  1.173  perseant 
   2541  1.173  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
   2542  1.173  perseant 
   2543   1.15  perseant 	/*
   2544   1.15  perseant 	 * If we return 1 here during a flush, we risk vinvalbuf() not
   2545   1.15  perseant 	 * being able to flush all of the pages from this vnode, which
   2546   1.15  perseant 	 * will cause it to panic.  So, return 0 if a flush is in progress.
   2547   1.15  perseant 	 */
   2548  1.173  perseant 	error = vget(vp, LK_NOWAIT);
   2549  1.173  perseant 	if (error == EBUSY && IS_FLUSHING(VTOI(vp)->i_lfs, vp)) {
   2550  1.173  perseant 		++fs->lfs_flushvp_fakevref;
   2551  1.173  perseant 		return 0;
   2552   1.15  perseant 	}
   2553  1.173  perseant 	return error;
   2554    1.1   mycroft }
   2555    1.1   mycroft 
   2556   1.10      fvdl /*
   2557   1.10      fvdl  * This is vrele except that we do not want to VOP_INACTIVE this vnode. We
   2558   1.10      fvdl  * inline vrele here to avoid the vn_lock and VOP_INACTIVE call at the end.
   2559   1.10      fvdl  */
   2560    1.1   mycroft void
   2561   1.69  perseant lfs_vunref(struct vnode *vp)
   2562    1.1   mycroft {
   2563  1.173  perseant 	struct lfs *fs;
   2564  1.173  perseant 
   2565  1.173  perseant 	fs = VTOI(vp)->i_lfs;
   2566  1.173  perseant 	ASSERT_MAYBE_SEGLOCK(fs);
   2567  1.173  perseant 
   2568   1.17  perseant 	/*
   2569   1.17  perseant 	 * Analogous to lfs_vref, if the node is flushing, fake it.
   2570   1.17  perseant 	 */
   2571  1.173  perseant 	if (IS_FLUSHING(fs, vp) && fs->lfs_flushvp_fakevref) {
   2572  1.173  perseant 		--fs->lfs_flushvp_fakevref;
   2573   1.17  perseant 		return;
   2574   1.17  perseant 	}
   2575   1.17  perseant 
   2576   1.10      fvdl 	simple_lock(&vp->v_interlock);
   2577   1.15  perseant #ifdef DIAGNOSTIC
   2578   1.73       chs 	if (vp->v_usecount <= 0) {
   2579  1.165  christos 		printf("lfs_vunref: inum is %llu\n", (unsigned long long)
   2580  1.165  christos 		    VTOI(vp)->i_number);
   2581   1.69  perseant 		printf("lfs_vunref: flags are 0x%lx\n", (u_long)vp->v_flag);
   2582   1.69  perseant 		printf("lfs_vunref: usecount = %ld\n", (long)vp->v_usecount);
   2583  1.158  perseant 		panic("lfs_vunref: v_usecount < 0");
   2584   1.15  perseant 	}
   2585   1.15  perseant #endif
   2586   1.10      fvdl 	vp->v_usecount--;
   2587   1.10      fvdl 	if (vp->v_usecount > 0) {
   2588   1.15  perseant 		simple_unlock(&vp->v_interlock);
   2589   1.15  perseant 		return;
   2590   1.15  perseant 	}
   2591   1.15  perseant 	/*
   2592   1.10      fvdl 	 * insert at tail of LRU list
   2593    1.1   mycroft 	 */
   2594   1.10      fvdl 	simple_lock(&vnode_free_list_slock);
   2595   1.40  perseant 	if (vp->v_holdcnt > 0)
   2596   1.40  perseant 		TAILQ_INSERT_TAIL(&vnode_hold_list, vp, v_freelist);
   2597   1.40  perseant 	else
   2598   1.40  perseant 		TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
   2599   1.10      fvdl 	simple_unlock(&vnode_free_list_slock);
   2600   1.10      fvdl 	simple_unlock(&vp->v_interlock);
   2601    1.1   mycroft }
   2602   1.15  perseant 
   2603   1.15  perseant /*
   2604   1.15  perseant  * We use this when we have vnodes that were loaded in solely for cleaning.
   2605   1.15  perseant  * There is no reason to believe that these vnodes will be referenced again
   2606   1.15  perseant  * soon, since the cleaning process is unrelated to normal filesystem
   2607   1.15  perseant  * activity.  Putting cleaned vnodes at the tail of the list has the effect
   2608   1.15  perseant  * of flushing the vnode LRU.  So, put vnodes that were loaded only for
   2609   1.15  perseant  * cleaning at the head of the list, instead.
   2610   1.15  perseant  */
   2611   1.15  perseant void
   2612   1.69  perseant lfs_vunref_head(struct vnode *vp)
   2613   1.15  perseant {
   2614  1.129      yamt 
   2615  1.159  perseant 	ASSERT_SEGLOCK(VTOI(vp)->i_lfs);
   2616   1.15  perseant 	simple_lock(&vp->v_interlock);
   2617   1.15  perseant #ifdef DIAGNOSTIC
   2618   1.73       chs 	if (vp->v_usecount == 0) {
   2619   1.15  perseant 		panic("lfs_vunref: v_usecount<0");
   2620   1.15  perseant 	}
   2621   1.15  perseant #endif
   2622   1.15  perseant 	vp->v_usecount--;
   2623   1.15  perseant 	if (vp->v_usecount > 0) {
   2624   1.15  perseant 		simple_unlock(&vp->v_interlock);
   2625   1.15  perseant 		return;
   2626   1.15  perseant 	}
   2627   1.15  perseant 	/*
   2628   1.15  perseant 	 * insert at head of LRU list
   2629   1.15  perseant 	 */
   2630   1.15  perseant 	simple_lock(&vnode_free_list_slock);
   2631   1.77  perseant 	if (vp->v_holdcnt > 0)
   2632   1.77  perseant 		TAILQ_INSERT_TAIL(&vnode_hold_list, vp, v_freelist);
   2633   1.77  perseant 	else
   2634   1.77  perseant 		TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
   2635   1.15  perseant 	simple_unlock(&vnode_free_list_slock);
   2636   1.15  perseant 	simple_unlock(&vp->v_interlock);
   2637   1.15  perseant }
   2638   1.15  perseant 
   2639