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