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