Home | History | Annotate | Line # | Download | only in ext2fs
ext2fs_inode.c revision 1.8
      1  1.8     perry /*	$NetBSD: ext2fs_inode.c,v 1.8 1998/08/09 20:15:38 perry Exp $	*/
      2  1.1    bouyer 
      3  1.1    bouyer /*
      4  1.1    bouyer  * Copyright (c) 1997 Manuel Bouyer.
      5  1.1    bouyer  * Copyright (c) 1982, 1986, 1989, 1993
      6  1.1    bouyer  *	The Regents of the University of California.  All rights reserved.
      7  1.1    bouyer  *
      8  1.1    bouyer  * Redistribution and use in source and binary forms, with or without
      9  1.1    bouyer  * modification, are permitted provided that the following conditions
     10  1.1    bouyer  * are met:
     11  1.1    bouyer  * 1. Redistributions of source code must retain the above copyright
     12  1.1    bouyer  *    notice, this list of conditions and the following disclaimer.
     13  1.1    bouyer  * 2. Redistributions in binary form must reproduce the above copyright
     14  1.1    bouyer  *    notice, this list of conditions and the following disclaimer in the
     15  1.1    bouyer  *    documentation and/or other materials provided with the distribution.
     16  1.1    bouyer  * 3. All advertising materials mentioning features or use of this software
     17  1.1    bouyer  *    must display the following acknowledgement:
     18  1.1    bouyer  *	This product includes software developed by the University of
     19  1.1    bouyer  *	California, Berkeley and its contributors.
     20  1.1    bouyer  * 4. Neither the name of the University nor the names of its contributors
     21  1.1    bouyer  *    may be used to endorse or promote products derived from this software
     22  1.1    bouyer  *    without specific prior written permission.
     23  1.1    bouyer  *
     24  1.1    bouyer  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25  1.1    bouyer  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26  1.1    bouyer  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27  1.1    bouyer  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28  1.1    bouyer  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29  1.1    bouyer  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30  1.1    bouyer  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31  1.1    bouyer  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32  1.1    bouyer  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33  1.1    bouyer  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34  1.1    bouyer  * SUCH DAMAGE.
     35  1.1    bouyer  *
     36  1.1    bouyer  *	@(#)ffs_inode.c	8.8 (Berkeley) 10/19/94
     37  1.1    bouyer  * Modified for ext2fs by Manuel Bouyer.
     38  1.1    bouyer  */
     39  1.5       mrg 
     40  1.5       mrg #include "opt_uvm.h"
     41  1.1    bouyer 
     42  1.1    bouyer #include <sys/param.h>
     43  1.1    bouyer #include <sys/systm.h>
     44  1.1    bouyer #include <sys/mount.h>
     45  1.1    bouyer #include <sys/proc.h>
     46  1.1    bouyer #include <sys/file.h>
     47  1.1    bouyer #include <sys/buf.h>
     48  1.1    bouyer #include <sys/vnode.h>
     49  1.1    bouyer #include <sys/kernel.h>
     50  1.1    bouyer #include <sys/malloc.h>
     51  1.1    bouyer #include <sys/trace.h>
     52  1.1    bouyer #include <sys/resourcevar.h>
     53  1.1    bouyer 
     54  1.1    bouyer #include <vm/vm.h>
     55  1.4       mrg #if defined(UVM)
     56  1.4       mrg #include <uvm/uvm_extern.h>
     57  1.4       mrg #endif
     58  1.1    bouyer 
     59  1.1    bouyer #include <ufs/ufs/quota.h>
     60  1.1    bouyer #include <ufs/ufs/inode.h>
     61  1.1    bouyer #include <ufs/ufs/ufsmount.h>
     62  1.1    bouyer #include <ufs/ufs/ufs_extern.h>
     63  1.1    bouyer 
     64  1.1    bouyer #include <ufs/ext2fs/ext2fs.h>
     65  1.1    bouyer #include <ufs/ext2fs/ext2fs_extern.h>
     66  1.1    bouyer 
     67  1.6      fvdl static int ext2fs_indirtrunc __P((struct inode *, ufs_daddr_t, ufs_daddr_t,
     68  1.6      fvdl 				  ufs_daddr_t, int, long *));
     69  1.1    bouyer 
     70  1.1    bouyer /*
     71  1.1    bouyer  * Last reference to an inode.  If necessary, write or delete it.
     72  1.1    bouyer  */
     73  1.1    bouyer int
     74  1.1    bouyer ext2fs_inactive(v)
     75  1.1    bouyer 	void *v;
     76  1.1    bouyer {
     77  1.1    bouyer 	struct vop_inactive_args /* {
     78  1.1    bouyer 		struct vnode *a_vp;
     79  1.6      fvdl 		struct proc *a_p;
     80  1.1    bouyer 	} */ *ap = v;
     81  1.6      fvdl 	struct vnode *vp = ap->a_vp;
     82  1.6      fvdl 	struct inode *ip = VTOI(vp);
     83  1.6      fvdl 	struct proc *p = ap->a_p;
     84  1.1    bouyer 	struct timespec ts;
     85  1.6      fvdl 	int error = 0;
     86  1.1    bouyer 	extern int prtactive;
     87  1.1    bouyer 
     88  1.1    bouyer 	if (prtactive && vp->v_usecount != 0)
     89  1.7     mikel 		vprint("ext2fs_inactive: pushing active", vp);
     90  1.1    bouyer 	/* Get rid of inodes related to stale file handles. */
     91  1.6      fvdl 	if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0)
     92  1.6      fvdl 		goto out;
     93  1.1    bouyer 
     94  1.1    bouyer 	error = 0;
     95  1.1    bouyer 	if (ip->i_e2fs_nlink == 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
     96  1.1    bouyer 		error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
     97  1.1    bouyer 		TIMEVAL_TO_TIMESPEC(&time, &ts);
     98  1.1    bouyer 		ip->i_e2fs_dtime = ts.tv_sec;
     99  1.1    bouyer 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
    100  1.1    bouyer 		VOP_VFREE(vp, ip->i_number, ip->i_e2fs_mode);
    101  1.1    bouyer 	}
    102  1.1    bouyer 	if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) {
    103  1.1    bouyer 		TIMEVAL_TO_TIMESPEC(&time, &ts);
    104  1.1    bouyer 		VOP_UPDATE(vp, &ts, &ts, 0);
    105  1.1    bouyer 	}
    106  1.6      fvdl out:
    107  1.6      fvdl 	VOP_UNLOCK(vp, 0);
    108  1.1    bouyer 	/*
    109  1.1    bouyer 	 * If we are done with the inode, reclaim it
    110  1.1    bouyer 	 * so that it can be reused immediately.
    111  1.1    bouyer 	 */
    112  1.6      fvdl 	if (ip->i_e2fs_dtime != 0)
    113  1.6      fvdl 		vrecycle(vp, (struct simplelock *)0, p);
    114  1.1    bouyer 	return (error);
    115  1.1    bouyer }
    116  1.1    bouyer 
    117  1.1    bouyer 
    118  1.1    bouyer /*
    119  1.1    bouyer  * Update the access, modified, and inode change times as specified by the
    120  1.1    bouyer  * IACCESS, IUPDATE, and ICHANGE flags respectively. The IMODIFIED flag is
    121  1.1    bouyer  * used to specify that the inode needs to be updated but that the times have
    122  1.1    bouyer  * already been set. The access and modified times are taken from the second
    123  1.1    bouyer  * and third parameters; the inode change time is always taken from the current
    124  1.1    bouyer  * time. If waitfor is set, then wait for the disk write of the inode to
    125  1.1    bouyer  * complete.
    126  1.1    bouyer  */
    127  1.1    bouyer int
    128  1.1    bouyer ext2fs_update(v)
    129  1.1    bouyer 	void *v;
    130  1.1    bouyer {
    131  1.1    bouyer 	struct vop_update_args /* {
    132  1.1    bouyer 		struct vnode *a_vp;
    133  1.1    bouyer 		struct timespec *a_access;
    134  1.1    bouyer 		struct timespec *a_modify;
    135  1.1    bouyer 		int a_waitfor;
    136  1.1    bouyer 	} */ *ap = v;
    137  1.1    bouyer 	register struct m_ext2fs *fs;
    138  1.1    bouyer 	struct buf *bp;
    139  1.1    bouyer 	struct inode *ip;
    140  1.1    bouyer 	int error;
    141  1.1    bouyer 	struct timespec ts;
    142  1.1    bouyer 
    143  1.1    bouyer 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
    144  1.1    bouyer 		return (0);
    145  1.1    bouyer 	ip = VTOI(ap->a_vp);
    146  1.1    bouyer 	TIMEVAL_TO_TIMESPEC(&time, &ts);
    147  1.1    bouyer 	EXT2FS_ITIMES(ip, ap->a_access, ap->a_modify, &ts);
    148  1.1    bouyer 	if ((ip->i_flag & IN_MODIFIED) == 0)
    149  1.1    bouyer 		return (0);
    150  1.1    bouyer 	ip->i_flag &= ~IN_MODIFIED;
    151  1.1    bouyer 	fs = ip->i_e2fs;
    152  1.1    bouyer 	error = bread(ip->i_devvp,
    153  1.1    bouyer 			  fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
    154  1.1    bouyer 			  (int)fs->e2fs_bsize, NOCRED, &bp);
    155  1.1    bouyer 	if (error) {
    156  1.1    bouyer 		brelse(bp);
    157  1.1    bouyer 		return (error);
    158  1.1    bouyer 	}
    159  1.3    bouyer 	e2fs_isave(&ip->i_din.e2fs_din,
    160  1.3    bouyer 		(struct ext2fs_dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number));
    161  1.6      fvdl 	if (ap->a_waitfor && (ap->a_vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
    162  1.1    bouyer 		return (bwrite(bp));
    163  1.1    bouyer 	else {
    164  1.1    bouyer 		bdwrite(bp);
    165  1.1    bouyer 		return (0);
    166  1.1    bouyer 	}
    167  1.1    bouyer }
    168  1.1    bouyer 
    169  1.1    bouyer #define	SINGLE	0	/* index of single indirect block */
    170  1.1    bouyer #define	DOUBLE	1	/* index of double indirect block */
    171  1.1    bouyer #define	TRIPLE	2	/* index of triple indirect block */
    172  1.1    bouyer /*
    173  1.1    bouyer  * Truncate the inode oip to at most length size, freeing the
    174  1.1    bouyer  * disk blocks.
    175  1.1    bouyer  */
    176  1.1    bouyer int
    177  1.1    bouyer ext2fs_truncate(v)
    178  1.1    bouyer 	void *v;
    179  1.1    bouyer {
    180  1.1    bouyer 	struct vop_truncate_args /* {
    181  1.1    bouyer 		struct vnode *a_vp;
    182  1.1    bouyer 		off_t a_length;
    183  1.1    bouyer 		int a_flags;
    184  1.1    bouyer 		struct ucred *a_cred;
    185  1.1    bouyer 		struct proc *a_p;
    186  1.1    bouyer 	} */ *ap = v;
    187  1.1    bouyer 	register struct vnode *ovp = ap->a_vp;
    188  1.6      fvdl 	register ufs_daddr_t lastblock;
    189  1.1    bouyer 	register struct inode *oip;
    190  1.6      fvdl 	ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
    191  1.6      fvdl 	ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
    192  1.1    bouyer 	off_t length = ap->a_length;
    193  1.1    bouyer 	register struct m_ext2fs *fs;
    194  1.1    bouyer 	struct buf *bp;
    195  1.1    bouyer 	int offset, size, level;
    196  1.1    bouyer 	long count, nblocks, vflags, blocksreleased = 0;
    197  1.1    bouyer 	struct timespec ts;
    198  1.1    bouyer 	register int i;
    199  1.1    bouyer 	int aflags, error, allerror;
    200  1.1    bouyer 	off_t osize;
    201  1.1    bouyer 
    202  1.1    bouyer 	if (length < 0)
    203  1.1    bouyer 		return (EINVAL);
    204  1.1    bouyer 
    205  1.1    bouyer 	oip = VTOI(ovp);
    206  1.1    bouyer 	TIMEVAL_TO_TIMESPEC(&time, &ts);
    207  1.1    bouyer 	if (ovp->v_type == VLNK &&
    208  1.1    bouyer 		(oip->i_e2fs_size < ovp->v_mount->mnt_maxsymlinklen ||
    209  1.1    bouyer 		 (ovp->v_mount->mnt_maxsymlinklen == 0 &&
    210  1.1    bouyer 		  oip->i_e2fs_nblock == 0))) {
    211  1.1    bouyer #ifdef DIAGNOSTIC
    212  1.1    bouyer 		if (length != 0)
    213  1.1    bouyer 			panic("ext2fs_truncate: partial truncate of symlink");
    214  1.1    bouyer #endif
    215  1.8     perry 		memset((char *)&oip->i_din.e2fs_din.e2di_shortlink, 0,
    216  1.1    bouyer 			(u_int)oip->i_e2fs_size);
    217  1.1    bouyer 		oip->i_e2fs_size = 0;
    218  1.1    bouyer 		oip->i_flag |= IN_CHANGE | IN_UPDATE;
    219  1.1    bouyer 		return (VOP_UPDATE(ovp, &ts, &ts, 1));
    220  1.1    bouyer 	}
    221  1.1    bouyer 	if (oip->i_e2fs_size == length) {
    222  1.1    bouyer 		oip->i_flag |= IN_CHANGE | IN_UPDATE;
    223  1.1    bouyer 		return (VOP_UPDATE(ovp, &ts, &ts, 0));
    224  1.1    bouyer 	}
    225  1.1    bouyer 	fs = oip->i_e2fs;
    226  1.1    bouyer 	osize = oip->i_e2fs_size;
    227  1.1    bouyer 	/*
    228  1.1    bouyer 	 * Lengthen the size of the file. We must ensure that the
    229  1.1    bouyer 	 * last byte of the file is allocated. Since the smallest
    230  1.1    bouyer 	 * value of osize is 0, length will be at least 1.
    231  1.1    bouyer 	 */
    232  1.1    bouyer 	if (osize < length) {
    233  1.1    bouyer #if 0 /* XXX */
    234  1.1    bouyer 		if (length > fs->fs_maxfilesize)
    235  1.1    bouyer 			return (EFBIG);
    236  1.1    bouyer #endif
    237  1.1    bouyer 		offset = blkoff(fs, length - 1);
    238  1.1    bouyer 		lbn = lblkno(fs, length - 1);
    239  1.1    bouyer 		aflags = B_CLRBUF;
    240  1.1    bouyer 		if (ap->a_flags & IO_SYNC)
    241  1.1    bouyer 			aflags |= B_SYNC;
    242  1.1    bouyer 		error = ext2fs_balloc(oip, lbn, offset + 1, ap->a_cred, &bp,
    243  1.1    bouyer 				   aflags);
    244  1.1    bouyer 		if (error)
    245  1.1    bouyer 			return (error);
    246  1.1    bouyer 		oip->i_e2fs_size = length;
    247  1.4       mrg #if defined(UVM)
    248  1.4       mrg 		uvm_vnp_setsize(ovp, length);
    249  1.4       mrg 		(void) uvm_vnp_uncache(ovp);
    250  1.4       mrg #else
    251  1.2  drochner 		vnode_pager_setsize(ovp, length);
    252  1.1    bouyer 		(void) vnode_pager_uncache(ovp);
    253  1.4       mrg #endif
    254  1.1    bouyer 		if (aflags & B_SYNC)
    255  1.1    bouyer 			bwrite(bp);
    256  1.1    bouyer 		else
    257  1.1    bouyer 			bawrite(bp);
    258  1.1    bouyer 		oip->i_flag |= IN_CHANGE | IN_UPDATE;
    259  1.1    bouyer 		return (VOP_UPDATE(ovp, &ts, &ts, 1));
    260  1.1    bouyer 	}
    261  1.1    bouyer 	/*
    262  1.1    bouyer 	 * Shorten the size of the file. If the file is not being
    263  1.1    bouyer 	 * truncated to a block boundry, the contents of the
    264  1.1    bouyer 	 * partial block following the end of the file must be
    265  1.1    bouyer 	 * zero'ed in case it ever become accessable again because
    266  1.1    bouyer 	 * of subsequent file growth.
    267  1.1    bouyer 	 */
    268  1.1    bouyer 	offset = blkoff(fs, length);
    269  1.1    bouyer 	if (offset == 0) {
    270  1.1    bouyer 		oip->i_e2fs_size = length;
    271  1.1    bouyer 	} else {
    272  1.1    bouyer 		lbn = lblkno(fs, length);
    273  1.1    bouyer 		aflags = B_CLRBUF;
    274  1.1    bouyer 		if (ap->a_flags & IO_SYNC)
    275  1.1    bouyer 			aflags |= B_SYNC;
    276  1.1    bouyer 		error = ext2fs_balloc(oip, lbn, offset, ap->a_cred, &bp, aflags);
    277  1.1    bouyer 		if (error)
    278  1.1    bouyer 			return (error);
    279  1.1    bouyer 		oip->i_e2fs_size = length;
    280  1.1    bouyer 		size = fs->e2fs_bsize;
    281  1.4       mrg #if defined(UVM)
    282  1.4       mrg 		(void) uvm_vnp_uncache(ovp);
    283  1.4       mrg #else
    284  1.1    bouyer 		(void) vnode_pager_uncache(ovp);
    285  1.4       mrg #endif
    286  1.8     perry 		memset((char *)bp->b_data + offset, 0,  (u_int)(size - offset));
    287  1.1    bouyer 		allocbuf(bp, size);
    288  1.1    bouyer 		if (aflags & B_SYNC)
    289  1.1    bouyer 			bwrite(bp);
    290  1.1    bouyer 		else
    291  1.1    bouyer 			bawrite(bp);
    292  1.1    bouyer 	}
    293  1.6      fvdl #if defined(UVM)
    294  1.6      fvdl 	uvm_vnp_setsize(ovp, length);
    295  1.6      fvdl #else
    296  1.6      fvdl 	vnode_pager_setsize(ovp, length);
    297  1.6      fvdl #endif
    298  1.1    bouyer 	/*
    299  1.1    bouyer 	 * Calculate index into inode's block list of
    300  1.1    bouyer 	 * last direct and indirect blocks (if any)
    301  1.1    bouyer 	 * which we want to keep.  Lastblock is -1 when
    302  1.1    bouyer 	 * the file is truncated to 0.
    303  1.1    bouyer 	 */
    304  1.1    bouyer 	lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;
    305  1.1    bouyer 	lastiblock[SINGLE] = lastblock - NDADDR;
    306  1.1    bouyer 	lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
    307  1.1    bouyer 	lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
    308  1.1    bouyer 	nblocks = btodb(fs->e2fs_bsize);
    309  1.1    bouyer 	/*
    310  1.1    bouyer 	 * Update file and block pointers on disk before we start freeing
    311  1.1    bouyer 	 * blocks.  If we crash before free'ing blocks below, the blocks
    312  1.1    bouyer 	 * will be returned to the free list.  lastiblock values are also
    313  1.1    bouyer 	 * normalized to -1 for calls to ext2fs_indirtrunc below.
    314  1.1    bouyer 	 */
    315  1.8     perry 	memcpy((caddr_t)oldblks, (caddr_t)&oip->i_e2fs_blocks[0], sizeof oldblks);
    316  1.1    bouyer 	for (level = TRIPLE; level >= SINGLE; level--)
    317  1.1    bouyer 		if (lastiblock[level] < 0) {
    318  1.1    bouyer 			oip->i_e2fs_blocks[NDADDR + level] = 0;
    319  1.1    bouyer 			lastiblock[level] = -1;
    320  1.1    bouyer 		}
    321  1.1    bouyer 	for (i = NDADDR - 1; i > lastblock; i--)
    322  1.1    bouyer 		oip->i_e2fs_blocks[i] = 0;
    323  1.1    bouyer 	oip->i_flag |= IN_CHANGE | IN_UPDATE;
    324  1.1    bouyer 	if ((error = VOP_UPDATE(ovp, &ts, &ts, 1)) != 0)
    325  1.1    bouyer 		allerror = error;
    326  1.1    bouyer 	/*
    327  1.1    bouyer 	 * Having written the new inode to disk, save its new configuration
    328  1.1    bouyer 	 * and put back the old block pointers long enough to process them.
    329  1.1    bouyer 	 * Note that we save the new block configuration so we can check it
    330  1.1    bouyer 	 * when we are done.
    331  1.1    bouyer 	 */
    332  1.8     perry 	memcpy((caddr_t)newblks, (caddr_t)&oip->i_e2fs_blocks[0], sizeof newblks);
    333  1.8     perry 	memcpy((caddr_t)&oip->i_e2fs_blocks[0], (caddr_t)oldblks, sizeof oldblks);
    334  1.1    bouyer 	oip->i_e2fs_size = osize;
    335  1.1    bouyer 	vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA;
    336  1.1    bouyer 	allerror = vinvalbuf(ovp, vflags, ap->a_cred, ap->a_p, 0, 0);
    337  1.1    bouyer 
    338  1.1    bouyer 	/*
    339  1.1    bouyer 	 * Indirect blocks first.
    340  1.1    bouyer 	 */
    341  1.1    bouyer 	indir_lbn[SINGLE] = -NDADDR;
    342  1.1    bouyer 	indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) -1;
    343  1.1    bouyer 	indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
    344  1.1    bouyer 	for (level = TRIPLE; level >= SINGLE; level--) {
    345  1.3    bouyer 		bn = fs2h32(oip->i_e2fs_blocks[NDADDR + level]);
    346  1.1    bouyer 		if (bn != 0) {
    347  1.1    bouyer 			error = ext2fs_indirtrunc(oip, indir_lbn[level],
    348  1.1    bouyer 				fsbtodb(fs, bn), lastiblock[level], level, &count);
    349  1.1    bouyer 			if (error)
    350  1.1    bouyer 				allerror = error;
    351  1.1    bouyer 			blocksreleased += count;
    352  1.1    bouyer 			if (lastiblock[level] < 0) {
    353  1.1    bouyer 				oip->i_e2fs_blocks[NDADDR + level] = 0;
    354  1.1    bouyer 				ext2fs_blkfree(oip, bn);
    355  1.1    bouyer 				blocksreleased += nblocks;
    356  1.1    bouyer 			}
    357  1.1    bouyer 		}
    358  1.1    bouyer 		if (lastiblock[level] >= 0)
    359  1.1    bouyer 			goto done;
    360  1.1    bouyer 	}
    361  1.1    bouyer 
    362  1.1    bouyer 	/*
    363  1.1    bouyer 	 * All whole direct blocks or frags.
    364  1.1    bouyer 	 */
    365  1.1    bouyer 	for (i = NDADDR - 1; i > lastblock; i--) {
    366  1.3    bouyer 		bn = fs2h32(oip->i_e2fs_blocks[i]);
    367  1.1    bouyer 		if (bn == 0)
    368  1.1    bouyer 			continue;
    369  1.1    bouyer 		oip->i_e2fs_blocks[i] = 0;
    370  1.1    bouyer 		ext2fs_blkfree(oip, bn);
    371  1.1    bouyer 		blocksreleased += btodb(fs->e2fs_bsize);
    372  1.1    bouyer 	}
    373  1.1    bouyer 	if (lastblock < 0)
    374  1.1    bouyer 		goto done;
    375  1.1    bouyer 
    376  1.1    bouyer done:
    377  1.1    bouyer #ifdef DIAGNOSTIC
    378  1.1    bouyer 	for (level = SINGLE; level <= TRIPLE; level++)
    379  1.3    bouyer 		if (newblks[NDADDR + level] !=
    380  1.3    bouyer 			fs2h32(oip->i_e2fs_blocks[NDADDR + level]))
    381  1.1    bouyer 			panic("itrunc1");
    382  1.1    bouyer 	for (i = 0; i < NDADDR; i++)
    383  1.3    bouyer 		if (newblks[i] != fs2h32(oip->i_e2fs_blocks[i]))
    384  1.1    bouyer 			panic("itrunc2");
    385  1.1    bouyer 	if (length == 0 &&
    386  1.1    bouyer 		(ovp->v_dirtyblkhd.lh_first || ovp->v_cleanblkhd.lh_first))
    387  1.1    bouyer 		panic("itrunc3");
    388  1.1    bouyer #endif /* DIAGNOSTIC */
    389  1.1    bouyer 	/*
    390  1.1    bouyer 	 * Put back the real size.
    391  1.1    bouyer 	 */
    392  1.1    bouyer 	oip->i_e2fs_size = length;
    393  1.1    bouyer 	oip->i_e2fs_nblock -= blocksreleased;
    394  1.1    bouyer 	if (oip->i_e2fs_nblock < 0)			/* sanity */
    395  1.1    bouyer 		oip->i_e2fs_nblock = 0;
    396  1.1    bouyer 	oip->i_flag |= IN_CHANGE;
    397  1.1    bouyer 	return (allerror);
    398  1.1    bouyer }
    399  1.1    bouyer 
    400  1.1    bouyer /*
    401  1.1    bouyer  * Release blocks associated with the inode ip and stored in the indirect
    402  1.1    bouyer  * block bn.  Blocks are free'd in LIFO order up to (but not including)
    403  1.1    bouyer  * lastbn.  If level is greater than SINGLE, the block is an indirect block
    404  1.1    bouyer  * and recursive calls to indirtrunc must be used to cleanse other indirect
    405  1.1    bouyer  * blocks.
    406  1.1    bouyer  *
    407  1.1    bouyer  * NB: triple indirect blocks are untested.
    408  1.1    bouyer  */
    409  1.1    bouyer static int
    410  1.1    bouyer ext2fs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
    411  1.1    bouyer 	register struct inode *ip;
    412  1.6      fvdl 	ufs_daddr_t lbn, lastbn;
    413  1.6      fvdl 	ufs_daddr_t dbn;
    414  1.1    bouyer 	int level;
    415  1.1    bouyer 	long *countp;
    416  1.1    bouyer {
    417  1.1    bouyer 	register int i;
    418  1.1    bouyer 	struct buf *bp;
    419  1.1    bouyer 	register struct m_ext2fs *fs = ip->i_e2fs;
    420  1.6      fvdl 	register ufs_daddr_t *bap;
    421  1.1    bouyer 	struct vnode *vp;
    422  1.6      fvdl 	ufs_daddr_t *copy = NULL, nb, nlbn, last;
    423  1.1    bouyer 	long blkcount, factor;
    424  1.1    bouyer 	int nblocks, blocksreleased = 0;
    425  1.1    bouyer 	int error = 0, allerror = 0;
    426  1.1    bouyer 
    427  1.1    bouyer 	/*
    428  1.1    bouyer 	 * Calculate index in current block of last
    429  1.1    bouyer 	 * block to be kept.  -1 indicates the entire
    430  1.1    bouyer 	 * block so we need not calculate the index.
    431  1.1    bouyer 	 */
    432  1.1    bouyer 	factor = 1;
    433  1.1    bouyer 	for (i = SINGLE; i < level; i++)
    434  1.1    bouyer 		factor *= NINDIR(fs);
    435  1.1    bouyer 	last = lastbn;
    436  1.1    bouyer 	if (lastbn > 0)
    437  1.1    bouyer 		last /= factor;
    438  1.1    bouyer 	nblocks = btodb(fs->e2fs_bsize);
    439  1.1    bouyer 	/*
    440  1.1    bouyer 	 * Get buffer of block pointers, zero those entries corresponding
    441  1.1    bouyer 	 * to blocks to be free'd, and update on disk copy first.  Since
    442  1.1    bouyer 	 * double(triple) indirect before single(double) indirect, calls
    443  1.1    bouyer 	 * to bmap on these blocks will fail.  However, we already have
    444  1.1    bouyer 	 * the on disk address, so we have to set the b_blkno field
    445  1.1    bouyer 	 * explicitly instead of letting bread do everything for us.
    446  1.1    bouyer 	 */
    447  1.1    bouyer 	vp = ITOV(ip);
    448  1.1    bouyer 	bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0);
    449  1.1    bouyer 	if (bp->b_flags & (B_DONE | B_DELWRI)) {
    450  1.1    bouyer 		/* Braces must be here in case trace evaluates to nothing. */
    451  1.1    bouyer 		trace(TR_BREADHIT, pack(vp, fs->e2fs_bsize), lbn);
    452  1.1    bouyer 	} else {
    453  1.1    bouyer 		trace(TR_BREADMISS, pack(vp, fs->e2fs_bsize), lbn);
    454  1.1    bouyer 		curproc->p_stats->p_ru.ru_inblock++;	/* pay for read */
    455  1.1    bouyer 		bp->b_flags |= B_READ;
    456  1.1    bouyer 		if (bp->b_bcount > bp->b_bufsize)
    457  1.1    bouyer 			panic("ext2fs_indirtrunc: bad buffer size");
    458  1.1    bouyer 		bp->b_blkno = dbn;
    459  1.1    bouyer 		VOP_STRATEGY(bp);
    460  1.1    bouyer 		error = biowait(bp);
    461  1.1    bouyer 	}
    462  1.1    bouyer 	if (error) {
    463  1.1    bouyer 		brelse(bp);
    464  1.1    bouyer 		*countp = 0;
    465  1.1    bouyer 		return (error);
    466  1.1    bouyer 	}
    467  1.1    bouyer 
    468  1.6      fvdl 	bap = (ufs_daddr_t *)bp->b_data;
    469  1.1    bouyer 	if (lastbn != -1) {
    470  1.6      fvdl 		MALLOC(copy, ufs_daddr_t *, fs->e2fs_bsize, M_TEMP, M_WAITOK);
    471  1.8     perry 		memcpy((caddr_t)copy, (caddr_t)bap, (u_int)fs->e2fs_bsize);
    472  1.8     perry 		memset((caddr_t)&bap[last + 1], 0,
    473  1.1    bouyer 			(u_int)(NINDIR(fs) - (last + 1)) * sizeof (u_int32_t));
    474  1.1    bouyer 		error = bwrite(bp);
    475  1.1    bouyer 		if (error)
    476  1.1    bouyer 			allerror = error;
    477  1.1    bouyer 		bap = copy;
    478  1.1    bouyer 	}
    479  1.1    bouyer 
    480  1.1    bouyer 	/*
    481  1.1    bouyer 	 * Recursively free totally unused blocks.
    482  1.1    bouyer 	 */
    483  1.1    bouyer 	for (i = NINDIR(fs) - 1,
    484  1.1    bouyer 		nlbn = lbn + 1 - i * factor; i > last;
    485  1.1    bouyer 		i--, nlbn += factor) {
    486  1.3    bouyer 		nb = fs2h32(bap[i]);
    487  1.1    bouyer 		if (nb == 0)
    488  1.1    bouyer 			continue;
    489  1.1    bouyer 		if (level > SINGLE) {
    490  1.1    bouyer 			error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
    491  1.6      fvdl 						   (ufs_daddr_t)-1, level - 1,
    492  1.1    bouyer 						   &blkcount);
    493  1.1    bouyer 			if (error)
    494  1.1    bouyer 				allerror = error;
    495  1.1    bouyer 			blocksreleased += blkcount;
    496  1.1    bouyer 		}
    497  1.1    bouyer 		ext2fs_blkfree(ip, nb);
    498  1.1    bouyer 		blocksreleased += nblocks;
    499  1.1    bouyer 	}
    500  1.1    bouyer 
    501  1.1    bouyer 	/*
    502  1.1    bouyer 	 * Recursively free last partial block.
    503  1.1    bouyer 	 */
    504  1.1    bouyer 	if (level > SINGLE && lastbn >= 0) {
    505  1.1    bouyer 		last = lastbn % factor;
    506  1.3    bouyer 		nb = fs2h32(bap[i]);
    507  1.1    bouyer 		if (nb != 0) {
    508  1.1    bouyer 			error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
    509  1.1    bouyer 						   last, level - 1, &blkcount);
    510  1.1    bouyer 			if (error)
    511  1.1    bouyer 				allerror = error;
    512  1.1    bouyer 			blocksreleased += blkcount;
    513  1.1    bouyer 		}
    514  1.1    bouyer 	}
    515  1.1    bouyer 
    516  1.1    bouyer 	if (copy != NULL) {
    517  1.1    bouyer 		FREE(copy, M_TEMP);
    518  1.1    bouyer 	} else {
    519  1.1    bouyer 		bp->b_flags |= B_INVAL;
    520  1.1    bouyer 		brelse(bp);
    521  1.1    bouyer 	}
    522  1.1    bouyer 
    523  1.1    bouyer 	*countp = blocksreleased;
    524  1.1    bouyer 	return (allerror);
    525  1.1    bouyer }
    526