#include <rev_endian_fs.h>
#include <vm/vm_pager.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mount_internal.h>
#include <sys/proc_internal.h>
#include <sys/file.h>
#include <sys/buf_internal.h>
#include <sys/vnode_internal.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/trace.h>
#include <sys/resourcevar.h>
#include <sys/ubc.h>
#include <sys/quota.h>
#include <sys/vm.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/ufsmount.h>
#include <ufs/ufs/ufs_extern.h>
#include <ufs/ffs/fs.h>
#include <ufs/ffs/ffs_extern.h>
#if REV_ENDIAN_FS
#include <ufs/ufs/ufs_byte_order.h>
#include <libkern/OSByteOrder.h>
#endif
static int ffs_indirtrunc(struct inode *, ufs_daddr_t, ufs_daddr_t,
ufs_daddr_t, int, long *);
int
ffs_update(struct vnode *vp, struct timeval *access, struct timeval *modify, int waitfor)
{
register struct fs *fs;
struct buf *bp;
struct inode *ip;
struct timeval tv;
errno_t error;
#if REV_ENDIAN_FS
struct mount *mp=(vp)->v_mount;
int rev_endian=(mp->mnt_flag & MNT_REVEND);
#endif
ip = VTOI(vp);
if (vp->v_mount->mnt_flag & MNT_RDONLY) {
ip->i_flag &=
~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
return (0);
}
if ((ip->i_flag &
(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0)
return (0);
if (ip->i_flag & IN_ACCESS)
ip->i_atime = access->tv_sec;
if (ip->i_flag & IN_UPDATE) {
ip->i_mtime = modify->tv_sec;
ip->i_modrev++;
}
if (ip->i_flag & IN_CHANGE) {
microtime(&tv);
ip->i_ctime = tv.tv_sec;
}
ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
fs = ip->i_fs;
if (fs->fs_inodefmt < FS_44INODEFMT) {
ip->i_din.di_ouid = ip->i_uid;
ip->i_din.di_ogid = ip->i_gid;
}
if (error = buf_bread(ip->i_devvp,
(daddr64_t)((unsigned)fsbtodb(fs, ino_to_fsba(fs, ip->i_number))),
(int)fs->fs_bsize, NOCRED, &bp)) {
buf_brelse(bp);
return ((int)error);
}
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_inode_out(ip, ((struct dinode *)buf_dataptr(bp) + ino_to_fsbo(fs, ip->i_number)));
else {
#endif
*((struct dinode *)buf_dataptr(bp) + ino_to_fsbo(fs, ip->i_number)) = ip->i_din;
#if REV_ENDIAN_FS
}
#endif
if (waitfor && (vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
return ((int)buf_bwrite(bp));
else {
buf_bdwrite(bp);
return (0);
}
}
#define SINGLE 0
#define DOUBLE 1
#define TRIPLE 2
int
ffs_truncate_internal(vnode_t ovp, off_t length, int flags, ucred_t cred)
{
struct inode *oip;
struct fs *fs;
ufs_daddr_t lastblock;
ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
buf_t bp;
int offset, size, level, i;
long count, nblocks, vflags, blocksreleased = 0;
struct timeval tv;
int aflags, error, allerror;
off_t osize;
int devBlockSize=0;
#if QUOTA
int64_t change;
#endif
if (length < 0)
return (EINVAL);
oip = VTOI(ovp);
fs = oip->i_fs;
if (length > fs->fs_maxfilesize)
return (EFBIG);
microtime(&tv);
if (ovp->v_type == VLNK &&
oip->i_size < ovp->v_mount->mnt_maxsymlinklen) {
#if DIAGNOSTIC
if (length != 0)
panic("ffs_truncate: partial truncate of symlink");
#endif
bzero((char *)&oip->i_shortlink, (u_int)oip->i_size);
oip->i_size = 0;
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, &tv, &tv, 1));
}
if (oip->i_size == length) {
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, &tv, &tv, 0));
}
#if QUOTA
if (error = getinoquota(oip))
return (error);
#endif
osize = oip->i_size;
if (osize < length) {
offset = blkoff(fs, length - 1);
lbn = lblkno(fs, length - 1);
aflags = B_CLRBUF;
if (flags & IO_SYNC)
aflags |= B_SYNC;
if (error = ffs_balloc(oip, lbn, offset + 1, cred, &bp, aflags, 0))
return (error);
oip->i_size = length;
if (UBCINFOEXISTS(ovp)) {
buf_markinvalid(bp);
buf_bwrite(bp);
ubc_setsize(ovp, (off_t)length);
} else {
if (aflags & B_SYNC)
buf_bwrite(bp);
else
buf_bawrite(bp);
}
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (ffs_update(ovp, &tv, &tv, 1));
}
if (UBCINFOEXISTS(ovp))
ubc_setsize(ovp, (off_t)length);
vflags = ((length > 0) ? BUF_WRITE_DATA : 0) | BUF_SKIP_META;
if (vflags & BUF_WRITE_DATA)
ffs_fsync_internal(ovp, MNT_WAIT);
allerror = buf_invalidateblks(ovp, vflags, 0, 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;
if (error = ffs_balloc(oip, lbn, offset, cred, &bp, aflags, 0))
return (error);
oip->i_size = length;
size = blksize(fs, oip, lbn);
bzero((char *)buf_dataptr(bp) + offset, (u_int)(size - offset));
allocbuf(bp, size);
if (UBCINFOEXISTS(ovp)) {
buf_markinvalid(bp);
buf_bwrite(bp);
} else {
if (aflags & B_SYNC)
buf_bwrite(bp);
else
buf_bawrite(bp);
}
}
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);
devBlockSize = vfs_devblocksize(vnode_mount(ovp));
nblocks = btodb(fs->fs_bsize, devBlockSize);
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;
if (error = ffs_update(ovp, &tv, &tv, MNT_WAIT))
allerror = error;
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;
vflags = ((length > 0) ? BUF_WRITE_DATA : 0) | BUF_SKIP_META;
if (vflags & BUF_WRITE_DATA)
ffs_fsync_internal(ovp, MNT_WAIT);
allerror = buf_invalidateblks(ovp, vflags, 0, 0);
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;
}
for (i = NDADDR - 1; i > lastblock; i--) {
register 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, devBlockSize);
}
if (lastblock < 0)
goto done;
bn = oip->i_db[lastblock];
if (bn != 0) {
long oldspace, newspace;
oldspace = blksize(fs, oip, lastblock);
oip->i_size = length;
newspace = blksize(fs, oip, lastblock);
if (newspace == 0)
panic("itrunc: newspace");
if (oldspace - newspace > 0) {
bn += numfrags(fs, newspace);
ffs_blkfree(oip, bn, oldspace - newspace);
blocksreleased += btodb(oldspace - newspace, devBlockSize);
}
}
done:
#if DIAGNOSTIC
for (level = SINGLE; level <= TRIPLE; level++)
if (newblks[NDADDR + level] != oip->i_ib[level])
panic("itrunc1");
for (i = 0; i < NDADDR; i++)
if (newblks[i] != oip->i_db[i])
panic("itrunc2");
if (length == 0 &&
(vnode_hasdirtyblks(ovp) || vnode_hascleanblks(ovp)))
panic("itrunc3");
#endif
oip->i_size = length;
oip->i_blocks -= blocksreleased;
if (oip->i_blocks < 0)
oip->i_blocks = 0;
oip->i_flag |= IN_CHANGE;
#if QUOTA
change = dbtob((int64_t)blocksreleased,devBlockSize);
(void) chkdq(oip, -change, NOCRED, 0);
#endif
return (allerror);
}
static int
ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
register struct inode *ip;
ufs_daddr_t lbn, lastbn;
ufs_daddr_t dbn;
int level;
long *countp;
{
register int i;
struct buf *bp;
struct buf *tbp;
register struct fs *fs = ip->i_fs;
register ufs_daddr_t *bap;
struct vnode *vp=ITOV(ip);
ufs_daddr_t *copy, nb, nlbn, last;
long blkcount, factor;
int nblocks, blocksreleased = 0;
errno_t error = 0, allerror = 0;
int devBlockSize=0;
struct mount *mp=vp->v_mount;
#if REV_ENDIAN_FS
int rev_endian=(mp->mnt_flag & MNT_REVEND);
#endif
factor = 1;
for (i = SINGLE; i < level; i++)
factor *= NINDIR(fs);
last = lastbn;
if (lastbn > 0)
last /= factor;
devBlockSize = vfs_devblocksize(mp);
nblocks = btodb(fs->fs_bsize, devBlockSize);
tbp = buf_geteblk(fs->fs_bsize);
copy = (ufs_daddr_t *)buf_dataptr(tbp);
vp = ITOV(ip);
bp = buf_getblk(vp, (daddr64_t)((unsigned)lbn), (int)fs->fs_bsize, 0, 0, BLK_META);
if (buf_valid(bp)) {
trace(TR_BREADHIT, pack(vp, fs->fs_bsize), lbn);
} else {
trace(TR_BREADMISS, pack(vp, fs->fs_bsize), lbn);
current_proc()->p_stats->p_ru.ru_inblock++;
buf_setflags(bp, B_READ);
if (buf_count(bp) > buf_size(bp))
panic("ffs_indirtrunc: bad buffer size");
buf_setblkno(bp, (daddr64_t)((unsigned)dbn));
VNOP_STRATEGY(bp);
error = buf_biowait(bp);
}
if (error) {
buf_brelse(bp);
*countp = 0;
buf_brelse(tbp);
return ((int)error);
}
bap = (ufs_daddr_t *)buf_dataptr(bp);
bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);
bzero((caddr_t)&bap[last + 1],
(u_int)(NINDIR(fs) - (last + 1)) * sizeof (ufs_daddr_t));
if (last == -1)
buf_markinvalid(bp);
if (last != -1 && (vp)->v_mount->mnt_flag & MNT_ASYNC) {
error = 0;
buf_bdwrite(bp);
} else {
error = buf_bwrite(bp);
if (error)
allerror = error;
}
bap = copy;
for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
i--, nlbn += factor) {
#if REV_ENDIAN_FS
if (rev_endian)
nb = OSSwapInt32(bap[i]);
else {
#endif
nb = bap[i];
#if REV_ENDIAN_FS
}
#endif
if (nb == 0)
continue;
if (level > SINGLE) {
if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
(ufs_daddr_t)-1, level - 1, &blkcount))
allerror = error;
blocksreleased += blkcount;
}
ffs_blkfree(ip, nb, fs->fs_bsize);
blocksreleased += nblocks;
}
if (level > SINGLE && lastbn >= 0) {
last = lastbn % factor;
#if REV_ENDIAN_FS
if (rev_endian)
nb = OSSwapInt32(bap[i]);
else {
#endif
nb = bap[i];
#if REV_ENDIAN_FS
}
#endif
if (nb != 0) {
if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
last, level - 1, &blkcount))
allerror = error;
blocksreleased += blkcount;
}
}
buf_brelse(tbp);
*countp = blocksreleased;
return ((int)allerror);
}