static int
ufs_quotaon_scan(struct mount *mp, struct vnode *vp, void *data)
{
int error;
/*struct scaninfo *info = data;*/
if (vp->v_writecount == 0)
return(0);
error = ufs_getinoquota(VTOI(vp));
return(error);
}
/*
* Last reference to an inode. If necessary, write or delete it.
*
* ufs_inactive(struct vnode *a_vp)
*/
int
ufs_inactive(struct vop_inactive_args *ap)
{
struct vnode *vp = ap->a_vp;
struct inode *ip = VTOI(vp);
int mode, error = 0;
if (prtactive && VREFCNT(vp) > 1)
vprint("ufs_inactive: pushing active", vp);
/*
* Ignore inodes related to stale file handles.
*/
if (ip == NULL || ip->i_mode == 0)
goto out;
if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
#ifdef QUOTA
if (!ufs_getinoquota(ip))
(void)ufs_chkiq(ip, -1, NOCRED, FORCE);
#endif
/* Must have a VM object to truncate */
error = ffs_truncate(vp, (off_t)0, 0, NOCRED);
ip->i_rdev = 0;
mode = ip->i_mode;
ip->i_mode = 0;
ip->i_flag |= IN_CHANGE | IN_UPDATE;
ffs_vfree(vp, ip->i_number, mode);
}
if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE))
ffs_update(vp, 0);
out:
/*
* If we are done with the inode, reclaim it
* so that it can be reused immediately.
*/
if (ip == NULL || ip->i_mode == 0)
vrecycle(vp);
return (error);
}
/*
* Truncate the inode oip to at most length size, freeing the
* disk blocks.
*/
int
ffs_truncate(struct vnode *vp, off_t length, int flags, struct ucred *cred)
{
struct vnode *ovp = vp;
ufs_daddr_t lastblock;
struct inode *oip;
ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
struct fs *fs;
struct buf *bp;
int offset, size, level;
long count, nblocks, blocksreleased = 0;
int i;
int aflags, error, allerror;
off_t osize;
oip = VTOI(ovp);
fs = oip->i_fs;
if (length < 0)
return (EINVAL);
if (length > fs->fs_maxfilesize)
return (EFBIG);
if (ovp->v_type == VLNK &&
(oip->i_size < ovp->v_mount->mnt_maxsymlinklen || oip->i_din.di_blocks == 0)) {
#ifdef DIAGNOSTIC
if (length != 0)
panic("ffs_truncate: partial truncate of symlink");
#endif /* DIAGNOSTIC */
bzero((char *)&oip->i_shortlink, (uint)oip->i_size);
oip->i_size = 0;
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, 1));
}
if (oip->i_size == length) {
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, 0));
}
if (fs->fs_ronly)
panic("ffs_truncate: read-only filesystem");
#ifdef QUOTA
error = ufs_getinoquota(oip);
if (error)
return (error);
#endif
ovp->v_lasta = ovp->v_clen = ovp->v_cstart = ovp->v_lastw = 0;
if (DOINGSOFTDEP(ovp)) {
if (length > 0 || softdep_slowdown(ovp)) {
/*
* If a file is only partially truncated, then
* we have to clean up the data structures
* describing the allocation past the truncation
* point. Finding and deallocating those structures
* is a lot of work. Since partial truncation occurs
* rarely, we solve the problem by syncing the file
* so that it will have no data structures left.
*/
if ((error = VOP_FSYNC(ovp, MNT_WAIT, 0)) != 0)
return (error);
} else {
#ifdef QUOTA
(void) ufs_chkdq(oip, -oip->i_blocks, NOCRED, 0);
#endif
softdep_setup_freeblocks(oip, length);
vinvalbuf(ovp, 0, 0, 0);
nvnode_pager_setsize(ovp, 0, fs->fs_bsize, 0);
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, 0));
}
}
osize = oip->i_size;
/*
* Lengthen the size of the file. We must ensure that the
* last byte of the file is allocated. Since the smallest
* value of osize is 0, length will be at least 1.
*
* nvextendbuf() only breads the old buffer. The blocksize
* of the new buffer must be specified so it knows how large
* to make the VM object.
*/
if (osize < length) {
nvextendbuf(vp, osize, length,
blkoffsize(fs, oip, osize), /* oblksize */
blkoffresize(fs, length), /* nblksize */
blkoff(fs, osize),
blkoff(fs, length),
0);
aflags = B_CLRBUF;
if (flags & IO_SYNC)
aflags |= B_SYNC;
/* BALLOC will reallocate the fragment at the old EOF */
error = VOP_BALLOC(ovp, length - 1, 1, cred, aflags, &bp);
if (error)
return (error);
oip->i_size = length;
if (bp->b_bufsize == fs->fs_bsize)
bp->b_flags |= B_CLUSTEROK;
if (aflags & B_SYNC)
bwrite(bp);
else
bawrite(bp);
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, 1));
}
/*
* Shorten the size of the file.
*
* NOTE: The block size specified in nvtruncbuf() is the blocksize
* of the buffer containing length prior to any reallocation
* of the block.
*/
allerror = nvtruncbuf(ovp, length, blkoffsize(fs, oip, length),
blkoff(fs, length), 0);
offset = blkoff(fs, length);
if (offset == 0) {
oip->i_size = length;
} else {
lbn = lblkno(fs, length);
aflags = B_CLRBUF;
if (flags & IO_SYNC)
aflags |= B_SYNC;
error = VOP_BALLOC(ovp, length - 1, 1, cred, aflags, &bp);
if (error)
return (error);
/*
* When we are doing soft updates and the UFS_BALLOC
* above fills in a direct block hole with a full sized
* block that will be truncated down to a fragment below,
* we must flush out the block dependency with an FSYNC
* so that we do not get a soft updates inconsistency
* when we create the fragment below.
*
* nvtruncbuf() may have re-dirtied the underlying block
* as part of its truncation zeroing code. To avoid a
* 'locking against myself' panic in the second fsync we
* can simply undirty the bp since the redirtying was
* related to areas of the buffer that we are going to
* throw away anyway, and we will b*write() the remainder
* anyway down below.
*/
if (DOINGSOFTDEP(ovp) && lbn < NDADDR &&
fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize) {
bundirty(bp);
error = VOP_FSYNC(ovp, MNT_WAIT, 0);
if (error) {
bdwrite(bp);
return (error);
}
}
oip->i_size = length;
size = blksize(fs, oip, lbn);
#if 0
/* remove - nvtruncbuf deals with this */
if (ovp->v_type != VDIR)
bzero((char *)bp->b_data + offset,
(uint)(size - offset));
#endif
/* Kirk's code has reallocbuf(bp, size, 1) here */
allocbuf(bp, size);
if (bp->b_bufsize == fs->fs_bsize)
bp->b_flags |= B_CLUSTEROK;
if (aflags & B_SYNC)
bwrite(bp);
else
bawrite(bp);
}
/*
* Calculate index into inode's block list of
* last direct and indirect blocks (if any)
* which we want to keep. Lastblock is -1 when
* the file is truncated to 0.
*/
lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
lastiblock[SINGLE] = lastblock - NDADDR;
lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
nblocks = btodb(fs->fs_bsize);
/*
* Update file and block pointers on disk before we start freeing
* blocks. If we crash before free'ing blocks below, the blocks
* will be returned to the free list. lastiblock values are also
* normalized to -1 for calls to ffs_indirtrunc below.
*/
bcopy((caddr_t)&oip->i_db[0], (caddr_t)oldblks, sizeof oldblks);
for (level = TRIPLE; level >= SINGLE; level--)
if (lastiblock[level] < 0) {
oip->i_ib[level] = 0;
lastiblock[level] = -1;
}
for (i = NDADDR - 1; i > lastblock; i--)
oip->i_db[i] = 0;
oip->i_flag |= IN_CHANGE | IN_UPDATE;
error = ffs_update(ovp, 1);
if (error && allerror == 0)
allerror = error;
/*
* Having written the new inode to disk, save its new configuration
* and put back the old block pointers long enough to process them.
* Note that we save the new block configuration so we can check it
* when we are done.
*/
bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks);
bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks);
oip->i_size = osize;
if (error && allerror == 0)
allerror = error;
/*
* Indirect blocks first.
*/
indir_lbn[SINGLE] = -NDADDR;
indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
for (level = TRIPLE; level >= SINGLE; level--) {
bn = oip->i_ib[level];
if (bn != 0) {
error = ffs_indirtrunc(oip, indir_lbn[level],
fsbtodb(fs, bn), lastiblock[level], level, &count);
if (error)
allerror = error;
blocksreleased += count;
if (lastiblock[level] < 0) {
oip->i_ib[level] = 0;
ffs_blkfree(oip, bn, fs->fs_bsize);
blocksreleased += nblocks;
}
}
if (lastiblock[level] >= 0)
goto done;
}
/*
* All whole direct blocks or frags.
*/
for (i = NDADDR - 1; i > lastblock; i--) {
long bsize;
bn = oip->i_db[i];
if (bn == 0)
continue;
oip->i_db[i] = 0;
bsize = blksize(fs, oip, i);
ffs_blkfree(oip, bn, bsize);
blocksreleased += btodb(bsize);
}
if (lastblock < 0)
goto done;
/*
* Finally, look for a change in size of the
* last direct block; release any frags.
*/
bn = oip->i_db[lastblock];
if (bn != 0) {
long oldspace, newspace;
/*
* Calculate amount of space we're giving
* back as old block size minus new block size.
*/
oldspace = blksize(fs, oip, lastblock);
oip->i_size = length;
newspace = blksize(fs, oip, lastblock);
if (newspace == 0)
panic("ffs_truncate: newspace");
if (oldspace - newspace > 0) {
/*
* Block number of space to be free'd is
* the old block # plus the number of frags
* required for the storage we're keeping.
*/
bn += numfrags(fs, newspace);
ffs_blkfree(oip, bn, oldspace - newspace);
blocksreleased += btodb(oldspace - newspace);
}
}
done:
#ifdef DIAGNOSTIC
for (level = SINGLE; level <= TRIPLE; level++)
if (newblks[NDADDR + level] != oip->i_ib[level])
panic("ffs_truncate1");
for (i = 0; i < NDADDR; i++)
if (newblks[i] != oip->i_db[i])
panic("ffs_truncate2");
if (length == 0 && !RB_EMPTY(&ovp->v_rbdirty_tree))
panic("ffs_truncate3");
#endif /* DIAGNOSTIC */
/*
* Put back the real size.
*/
oip->i_size = length;
oip->i_blocks -= blocksreleased;
if (oip->i_blocks < 0) /* sanity */
oip->i_blocks = 0;
oip->i_flag |= IN_CHANGE;
#ifdef QUOTA
(void) ufs_chkdq(oip, -blocksreleased, NOCRED, 0);
#endif
return (allerror);
}
