/*
* Allocate len bytes at offset off.
*/
int
ulfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
kauth_cred_t cred)
{
struct inode *ip = VTOI(vp);
int error, delta, bshift, bsize;
UVMHIST_FUNC("ulfs_gop_alloc"); UVMHIST_CALLED(ubchist);
error = 0;
bshift = vp->v_mount->mnt_fs_bshift;
bsize = 1 << bshift;
delta = off & (bsize - 1);
off -= delta;
len += delta;
while (len > 0) {
bsize = MIN(bsize, len);
error = lfs_balloc(vp, off, bsize, cred, flags, NULL);
if (error) {
goto out;
}
/*
* increase file size now, lfs_balloc() requires that
* EOF be up-to-date before each call.
*/
if (ip->i_size < off + bsize) {
UVMHIST_LOG(ubchist, "vp %p old 0x%x new 0x%x",
vp, ip->i_size, off + bsize, 0);
ip->i_size = off + bsize;
DIP_ASSIGN(ip, size, ip->i_size);
}
off += bsize;
len -= bsize;
}
out:
return error;
}
/*
* Load the appropriate indirect block, and change the appropriate pointer.
* Mark the block dirty. Do segment and avail accounting.
*/
static int
update_meta(struct lfs *fs, ino_t ino, int vers, daddr_t lbn,
daddr_t ndaddr, size_t size, struct lwp *l)
{
int error;
struct vnode *vp;
struct inode *ip;
#ifdef DEBUG
daddr_t odaddr;
struct indir a[NIADDR];
int num;
int i;
#endif /* DEBUG */
struct buf *bp;
SEGUSE *sup;
KASSERT(lbn >= 0); /* no indirect blocks */
if ((error = lfs_rf_valloc(fs, ino, vers, l, &vp)) != 0) {
DLOG((DLOG_RF, "update_meta: ino %d: lfs_rf_valloc"
" returned %d\n", ino, error));
return error;
}
if ((error = lfs_balloc(vp, (lbn << fs->lfs_bshift), size,
NOCRED, 0, &bp)) != 0) {
vput(vp);
return (error);
}
/* No need to write, the block is already on disk */
if (bp->b_oflags & BO_DELWRI) {
LFS_UNLOCK_BUF(bp);
fs->lfs_avail += btofsb(fs, bp->b_bcount);
}
brelse(bp, BC_INVAL);
/*
* Extend the file, if it is not large enough already.
* XXX this is not exactly right, we don't know how much of the
* XXX last block is actually used. We hope that an inode will
* XXX appear later to give the correct size.
*/
ip = VTOI(vp);
if (ip->i_size <= (lbn << fs->lfs_bshift)) {
u_int64_t newsize;
if (lbn < NDADDR)
newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) +
(size - fs->lfs_fsize) + 1;
else
newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) + 1;
if (ip->i_size < newsize) {
ip->i_size = newsize;
/*
* tell vm our new size for the case the inode won't
* appear later.
*/
uvm_vnp_setsize(vp, newsize);
}
}
lfs_update_single(fs, NULL, vp, lbn, ndaddr, size);
LFS_SEGENTRY(sup, fs, dtosn(fs, ndaddr), bp);
sup->su_nbytes += size;
LFS_WRITESEGENTRY(sup, fs, dtosn(fs, ndaddr), bp);
/* differences here should be due to UNWRITTEN indirect blocks. */
KASSERT((lblkno(fs, ip->i_size) > NDADDR &&
ip->i_lfs_effnblks == ip->i_ffs1_blocks) ||
ip->i_lfs_effnblks >= ip->i_ffs1_blocks);
#ifdef DEBUG
/* Now look again to make sure it worked */
ufs_bmaparray(vp, lbn, &odaddr, &a[0], &num, NULL, NULL);
for (i = num; i > 0; i--) {
if (!a[i].in_exists)
panic("update_meta: absent %d lv indirect block", i);
}
if (dbtofsb(fs, odaddr) != ndaddr)
DLOG((DLOG_RF, "update_meta: failed setting ino %d lbn %"
PRId64 " to %" PRId64 "\n", ino, lbn, ndaddr));
#endif /* DEBUG */
vput(vp);
return 0;
}
int
ulfs_mkdir(void *v)
{
struct vop_mkdir_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp, *tvp;
struct vattr *vap = ap->a_vap;
struct componentname *cnp = ap->a_cnp;
struct inode *ip, *dp = VTOI(dvp);
struct buf *bp;
struct lfs_dirtemplate dirtemplate;
struct lfs_direct *newdir;
int error, dmode;
struct ulfsmount *ump = dp->i_ump;
struct lfs *fs = ump->um_lfs;
int dirblksiz = fs->um_dirblksiz;
struct ulfs_lookup_results *ulr;
fstrans_start(dvp->v_mount, FSTRANS_SHARED);
/* XXX should handle this material another way */
ulr = &dp->i_crap;
ULFS_CHECK_CRAPCOUNTER(dp);
if ((nlink_t)dp->i_nlink >= LINK_MAX) {
error = EMLINK;
goto out;
}
dmode = vap->va_mode & ACCESSPERMS;
dmode |= LFS_IFDIR;
/*
* Must simulate part of ulfs_makeinode here to acquire the inode,
* but not have it entered in the parent directory. The entry is
* made later after writing "." and ".." entries.
*/
if ((error = lfs_valloc(dvp, dmode, cnp->cn_cred, ap->a_vpp)) != 0)
goto out;
tvp = *ap->a_vpp;
ip = VTOI(tvp);
ip->i_uid = kauth_cred_geteuid(cnp->cn_cred);
DIP_ASSIGN(ip, uid, ip->i_uid);
ip->i_gid = dp->i_gid;
DIP_ASSIGN(ip, gid, ip->i_gid);
#if defined(LFS_QUOTA) || defined(LFS_QUOTA2)
if ((error = lfs_chkiq(ip, 1, cnp->cn_cred, 0))) {
lfs_vfree(tvp, ip->i_number, dmode);
fstrans_done(dvp->v_mount);
vput(tvp);
return (error);
}
#endif
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
ip->i_mode = dmode;
DIP_ASSIGN(ip, mode, dmode);
tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */
ip->i_nlink = 2;
DIP_ASSIGN(ip, nlink, 2);
if (cnp->cn_flags & ISWHITEOUT) {
ip->i_flags |= UF_OPAQUE;
DIP_ASSIGN(ip, flags, ip->i_flags);
}
/*
* Bump link count in parent directory to reflect work done below.
* Should be done before reference is created so cleanup is
* possible if we crash.
*/
dp->i_nlink++;
DIP_ASSIGN(dp, nlink, dp->i_nlink);
dp->i_flag |= IN_CHANGE;
if ((error = lfs_update(dvp, NULL, NULL, UPDATE_DIROP)) != 0)
goto bad;
/*
* Initialize directory with "." and ".." from static template.
*/
dirtemplate = mastertemplate;
dirtemplate.dotdot_reclen = dirblksiz - dirtemplate.dot_reclen;
dirtemplate.dot_ino = ulfs_rw32(ip->i_number, ULFS_MPNEEDSWAP(fs));
dirtemplate.dotdot_ino = ulfs_rw32(dp->i_number, ULFS_MPNEEDSWAP(fs));
dirtemplate.dot_reclen = ulfs_rw16(dirtemplate.dot_reclen,
ULFS_MPNEEDSWAP(fs));
dirtemplate.dotdot_reclen = ulfs_rw16(dirtemplate.dotdot_reclen,
ULFS_MPNEEDSWAP(fs));
if (fs->um_maxsymlinklen <= 0) {
#if BYTE_ORDER == LITTLE_ENDIAN
if (ULFS_MPNEEDSWAP(fs) == 0)
#else
if (ULFS_MPNEEDSWAP(fs) != 0)
#endif
{
dirtemplate.dot_type = dirtemplate.dot_namlen;
dirtemplate.dotdot_type = dirtemplate.dotdot_namlen;
dirtemplate.dot_namlen = dirtemplate.dotdot_namlen = 0;
} else
dirtemplate.dot_type = dirtemplate.dotdot_type = 0;
}
if ((error = lfs_balloc(tvp, (off_t)0, dirblksiz, cnp->cn_cred,
B_CLRBUF, &bp)) != 0)
goto bad;
ip->i_size = dirblksiz;
DIP_ASSIGN(ip, size, dirblksiz);
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
uvm_vnp_setsize(tvp, ip->i_size);
memcpy((void *)bp->b_data, (void *)&dirtemplate, sizeof dirtemplate);
/*
* Directory set up, now install it's entry in the parent directory.
* We must write out the buffer containing the new directory body
* before entering the new name in the parent.
*/
if ((error = VOP_BWRITE(bp->b_vp, bp)) != 0)
goto bad;
if ((error = lfs_update(tvp, NULL, NULL, UPDATE_DIROP)) != 0) {
goto bad;
}
newdir = pool_cache_get(ulfs_direct_cache, PR_WAITOK);
ulfs_makedirentry(ip, cnp, newdir);
error = ulfs_direnter(dvp, ulr, tvp, newdir, cnp, bp);
pool_cache_put(ulfs_direct_cache, newdir);
bad:
if (error == 0) {
VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
VOP_UNLOCK(tvp);
} else {
dp->i_nlink--;
DIP_ASSIGN(dp, nlink, dp->i_nlink);
dp->i_flag |= IN_CHANGE;
/*
* No need to do an explicit lfs_truncate here, vrele will
* do this for us because we set the link count to 0.
*/
ip->i_nlink = 0;
DIP_ASSIGN(ip, nlink, 0);
ip->i_flag |= IN_CHANGE;
/* If IN_ADIROP, account for it */
lfs_unmark_vnode(tvp);
vput(tvp);
}
out:
fstrans_done(dvp->v_mount);
return (error);
}
int
lfs_truncate(struct vnode *ovp, off_t length, int ioflag, kauth_cred_t cred)
{
daddr_t lastblock;
struct inode *oip = VTOI(ovp);
daddr_t bn, lbn, lastiblock[ULFS_NIADDR], indir_lbn[ULFS_NIADDR];
/* XXX ondisk32 */
int32_t newblks[ULFS_NDADDR + ULFS_NIADDR];
struct lfs *fs;
struct buf *bp;
int offset, size, level;
daddr_t count, rcount;
daddr_t blocksreleased = 0, real_released = 0;
int i, nblocks;
int aflags, error, allerror = 0;
off_t osize;
long lastseg;
size_t bc;
int obufsize, odb;
int usepc;
if (ovp->v_type == VCHR || ovp->v_type == VBLK ||
ovp->v_type == VFIFO || ovp->v_type == VSOCK) {
KASSERT(oip->i_size == 0);
return 0;
}
if (length < 0)
return (EINVAL);
/*
* Just return and not update modification times.
*/
if (oip->i_size == length) {
/* still do a uvm_vnp_setsize() as writesize may be larger */
uvm_vnp_setsize(ovp, length);
return (0);
}
fs = oip->i_lfs;
if (ovp->v_type == VLNK &&
(oip->i_size < fs->um_maxsymlinklen ||
(fs->um_maxsymlinklen == 0 &&
oip->i_ffs1_blocks == 0))) {
#ifdef DIAGNOSTIC
if (length != 0)
panic("lfs_truncate: partial truncate of symlink");
#endif
memset((char *)SHORTLINK(oip), 0, (u_int)oip->i_size);
oip->i_size = oip->i_ffs1_size = 0;
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (lfs_update(ovp, NULL, NULL, 0));
}
if (oip->i_size == length) {
oip->i_flag |= IN_CHANGE | IN_UPDATE;
return (lfs_update(ovp, NULL, NULL, 0));
}
lfs_imtime(fs);
osize = oip->i_size;
usepc = (ovp->v_type == VREG && ovp != fs->lfs_ivnode);
ASSERT_NO_SEGLOCK(fs);
/*
* 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.
*/
if (osize < length) {
if (length > fs->um_maxfilesize)
return (EFBIG);
aflags = B_CLRBUF;
if (ioflag & IO_SYNC)
aflags |= B_SYNC;
if (usepc) {
if (lfs_lblkno(fs, osize) < ULFS_NDADDR &&
lfs_lblkno(fs, osize) != lfs_lblkno(fs, length) &&
lfs_blkroundup(fs, osize) != osize) {
off_t eob;
eob = lfs_blkroundup(fs, osize);
uvm_vnp_setwritesize(ovp, eob);
error = ulfs_balloc_range(ovp, osize,
eob - osize, cred, aflags);
if (error) {
(void) lfs_truncate(ovp, osize,
ioflag & IO_SYNC, cred);
return error;
}
if (ioflag & IO_SYNC) {
mutex_enter(ovp->v_interlock);
VOP_PUTPAGES(ovp,
trunc_page(osize & lfs_sb_getbmask(fs)),
round_page(eob),
PGO_CLEANIT | PGO_SYNCIO);
}
}
uvm_vnp_setwritesize(ovp, length);
error = ulfs_balloc_range(ovp, length - 1, 1, cred,
aflags);
if (error) {
(void) lfs_truncate(ovp, osize,
ioflag & IO_SYNC, cred);
return error;
}
uvm_vnp_setsize(ovp, length);
oip->i_flag |= IN_CHANGE | IN_UPDATE;
KASSERT(ovp->v_size == oip->i_size);
oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
return (lfs_update(ovp, NULL, NULL, 0));
} else {
error = lfs_reserve(fs, ovp, NULL,
lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));
if (error)
return (error);
error = lfs_balloc(ovp, length - 1, 1, cred,
aflags, &bp);
lfs_reserve(fs, ovp, NULL,
-lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));
if (error)
return (error);
oip->i_ffs1_size = oip->i_size = length;
uvm_vnp_setsize(ovp, length);
(void) VOP_BWRITE(bp->b_vp, bp);
oip->i_flag |= IN_CHANGE | IN_UPDATE;
oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
return (lfs_update(ovp, NULL, NULL, 0));
}
}
if ((error = lfs_reserve(fs, ovp, NULL,
lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)))) != 0)
return (error);
/*
* Shorten the size of the file. If the file is not being
* truncated to a block boundary, the contents of the
* partial block following the end of the file must be
* zero'ed in case it ever becomes accessible again because
* of subsequent file growth. Directories however are not
* zero'ed as they should grow back initialized to empty.
*/
offset = lfs_blkoff(fs, length);
lastseg = -1;
bc = 0;
if (ovp != fs->lfs_ivnode)
lfs_seglock(fs, SEGM_PROT);
if (offset == 0) {
oip->i_size = oip->i_ffs1_size = length;
} else if (!usepc) {
lbn = lfs_lblkno(fs, length);
aflags = B_CLRBUF;
if (ioflag & IO_SYNC)
aflags |= B_SYNC;
error = lfs_balloc(ovp, length - 1, 1, cred, aflags, &bp);
if (error) {
lfs_reserve(fs, ovp, NULL,
-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
obufsize = bp->b_bufsize;
odb = lfs_btofsb(fs, bp->b_bcount);
oip->i_size = oip->i_ffs1_size = length;
size = lfs_blksize(fs, oip, lbn);
if (ovp->v_type != VDIR)
memset((char *)bp->b_data + offset, 0,
(u_int)(size - offset));
allocbuf(bp, size, 1);
if ((bp->b_flags & B_LOCKED) != 0 && bp->b_iodone == NULL) {
mutex_enter(&lfs_lock);
locked_queue_bytes -= obufsize - bp->b_bufsize;
mutex_exit(&lfs_lock);
}
if (bp->b_oflags & BO_DELWRI) {
lfs_sb_addavail(fs, odb - lfs_btofsb(fs, size));
/* XXX shouldn't this wake up on lfs_availsleep? */
}
(void) VOP_BWRITE(bp->b_vp, bp);
} else { /* vp->v_type == VREG && length < osize && offset != 0 */
/*
* When truncating a regular file down to a non-block-aligned
* size, we must zero the part of last block which is past
* the new EOF. We must synchronously flush the zeroed pages
* to disk since the new pages will be invalidated as soon
* as we inform the VM system of the new, smaller size.
* We must do this before acquiring the GLOCK, since fetching
* the pages will acquire the GLOCK internally.
* So there is a window where another thread could see a whole
* zeroed page past EOF, but that's life.
*/
daddr_t xlbn;
voff_t eoz;
aflags = ioflag & IO_SYNC ? B_SYNC : 0;
error = ulfs_balloc_range(ovp, length - 1, 1, cred, aflags);
if (error) {
lfs_reserve(fs, ovp, NULL,
-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
xlbn = lfs_lblkno(fs, length);
size = lfs_blksize(fs, oip, xlbn);
eoz = MIN(lfs_lblktosize(fs, xlbn) + size, osize);
ubc_zerorange(&ovp->v_uobj, length, eoz - length,
UBC_UNMAP_FLAG(ovp));
if (round_page(eoz) > round_page(length)) {
mutex_enter(ovp->v_interlock);
error = VOP_PUTPAGES(ovp, round_page(length),
round_page(eoz),
PGO_CLEANIT | PGO_DEACTIVATE |
((ioflag & IO_SYNC) ? PGO_SYNCIO : 0));
if (error) {
lfs_reserve(fs, ovp, NULL,
-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
}
}
genfs_node_wrlock(ovp);
oip->i_size = oip->i_ffs1_size = length;
uvm_vnp_setsize(ovp, length);
/*
* 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.
*/
/* Avoid sign overflow - XXX assumes that off_t is a quad_t. */
if (length > QUAD_MAX - lfs_sb_getbsize(fs))
lastblock = lfs_lblkno(fs, QUAD_MAX - lfs_sb_getbsize(fs));
else
lastblock = lfs_lblkno(fs, length + lfs_sb_getbsize(fs) - 1) - 1;
lastiblock[SINGLE] = lastblock - ULFS_NDADDR;
lastiblock[DOUBLE] = lastiblock[SINGLE] - LFS_NINDIR(fs);
lastiblock[TRIPLE] = lastiblock[DOUBLE] - LFS_NINDIR(fs) * LFS_NINDIR(fs);
nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));
/*
* Record changed file and block pointers before we start
* freeing blocks. lastiblock values are also normalized to -1
* for calls to lfs_indirtrunc below.
*/
memcpy((void *)newblks, (void *)&oip->i_ffs1_db[0], sizeof newblks);
for (level = TRIPLE; level >= SINGLE; level--)
if (lastiblock[level] < 0) {
newblks[ULFS_NDADDR+level] = 0;
lastiblock[level] = -1;
}
for (i = ULFS_NDADDR - 1; i > lastblock; i--)
newblks[i] = 0;
oip->i_size = oip->i_ffs1_size = osize;
error = lfs_vtruncbuf(ovp, lastblock + 1, false, 0);
if (error && !allerror)
allerror = error;
/*
* Indirect blocks first.
*/
indir_lbn[SINGLE] = -ULFS_NDADDR;
indir_lbn[DOUBLE] = indir_lbn[SINGLE] - LFS_NINDIR(fs) - 1;
indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - LFS_NINDIR(fs) * LFS_NINDIR(fs) - 1;
for (level = TRIPLE; level >= SINGLE; level--) {
bn = oip->i_ffs1_ib[level];
if (bn != 0) {
error = lfs_indirtrunc(oip, indir_lbn[level],
bn, lastiblock[level],
level, &count, &rcount,
&lastseg, &bc);
if (error)
allerror = error;
real_released += rcount;
blocksreleased += count;
if (lastiblock[level] < 0) {
if (oip->i_ffs1_ib[level] > 0)
real_released += nblocks;
blocksreleased += nblocks;
oip->i_ffs1_ib[level] = 0;
lfs_blkfree(fs, oip, bn, lfs_sb_getbsize(fs),
&lastseg, &bc);
lfs_deregister_block(ovp, bn);
}
}
if (lastiblock[level] >= 0)
goto done;
}
/*
* All whole direct blocks or frags.
*/
for (i = ULFS_NDADDR - 1; i > lastblock; i--) {
long bsize, obsize;
bn = oip->i_ffs1_db[i];
if (bn == 0)
continue;
bsize = lfs_blksize(fs, oip, i);
if (oip->i_ffs1_db[i] > 0) {
/* Check for fragment size changes */
obsize = oip->i_lfs_fragsize[i];
real_released += lfs_btofsb(fs, obsize);
oip->i_lfs_fragsize[i] = 0;
} else
obsize = 0;
blocksreleased += lfs_btofsb(fs, bsize);
oip->i_ffs1_db[i] = 0;
lfs_blkfree(fs, oip, bn, obsize, &lastseg, &bc);
lfs_deregister_block(ovp, bn);
}
if (lastblock < 0)
goto done;
/*
* Finally, look for a change in size of the
* last direct block; release any frags.
*/
bn = oip->i_ffs1_db[lastblock];
if (bn != 0) {
long oldspace, newspace;
#if 0
long olddspace;
#endif
/*
* Calculate amount of space we're giving
* back as old block size minus new block size.
*/
oldspace = lfs_blksize(fs, oip, lastblock);
#if 0
olddspace = oip->i_lfs_fragsize[lastblock];
#endif
oip->i_size = oip->i_ffs1_size = length;
newspace = lfs_blksize(fs, oip, lastblock);
if (newspace == 0)
panic("itrunc: newspace");
if (oldspace - newspace > 0) {
blocksreleased += lfs_btofsb(fs, oldspace - newspace);
}
#if 0
if (bn > 0 && olddspace - newspace > 0) {
/* No segment accounting here, just vnode */
real_released += lfs_btofsb(fs, olddspace - newspace);
}
#endif
}
done:
/* Finish segment accounting corrections */
lfs_update_seguse(fs, oip, lastseg, bc);
#ifdef DIAGNOSTIC
for (level = SINGLE; level <= TRIPLE; level++)
if ((newblks[ULFS_NDADDR + level] == 0) !=
((oip->i_ffs1_ib[level]) == 0)) {
panic("lfs itrunc1");
}
for (i = 0; i < ULFS_NDADDR; i++)
if ((newblks[i] == 0) != (oip->i_ffs1_db[i] == 0)) {
panic("lfs itrunc2");
}
if (length == 0 &&
(!LIST_EMPTY(&ovp->v_cleanblkhd) || !LIST_EMPTY(&ovp->v_dirtyblkhd)))
panic("lfs itrunc3");
#endif /* DIAGNOSTIC */
/*
* Put back the real size.
*/
oip->i_size = oip->i_ffs1_size = length;
oip->i_lfs_effnblks -= blocksreleased;
oip->i_ffs1_blocks -= real_released;
mutex_enter(&lfs_lock);
lfs_sb_addbfree(fs, blocksreleased);
mutex_exit(&lfs_lock);
#ifdef DIAGNOSTIC
if (oip->i_size == 0 &&
(oip->i_ffs1_blocks != 0 || oip->i_lfs_effnblks != 0)) {
printf("lfs_truncate: truncate to 0 but %d blks/%jd effblks\n",
oip->i_ffs1_blocks, (intmax_t)oip->i_lfs_effnblks);
panic("lfs_truncate: persistent blocks");
}
#endif
/*
* If we truncated to zero, take us off the paging queue.
*/
mutex_enter(&lfs_lock);
if (oip->i_size == 0 && oip->i_flags & IN_PAGING) {
oip->i_flags &= ~IN_PAGING;
TAILQ_REMOVE(&fs->lfs_pchainhd, oip, i_lfs_pchain);
}
mutex_exit(&lfs_lock);
oip->i_flag |= IN_CHANGE;
#if defined(LFS_QUOTA) || defined(LFS_QUOTA2)
(void) lfs_chkdq(oip, -blocksreleased, NOCRED, 0);
#endif
lfs_reserve(fs, ovp, NULL,
-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
genfs_node_unlock(ovp);
errout:
oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
if (ovp != fs->lfs_ivnode)
lfs_segunlock(fs);
return (allerror ? allerror : error);
}
/*
* Write a directory entry after a call to namei, using the parameters
* that ulfs_lookup left in nameidata and in the ulfs_lookup_results.
*
* DVP is the directory to be updated. It must be locked.
* ULR is the ulfs_lookup_results structure from the final lookup step.
* TVP is not used. (XXX: why is it here? remove it)
* DIRP is the new directory entry contents.
* CNP is the componentname from the final lookup step.
* NEWDIRBP is not used and (XXX) should be removed. The previous
* comment here said it was used by the now-removed softupdates code.
*
* The link count of the target inode is *not* incremented; the
* caller does that.
*
* If ulr->ulr_count is 0, ulfs_lookup did not find space to insert the
* directory entry. ulr_offset, which is the place to put the entry,
* should be on a block boundary (and should be at the end of the
* directory AFAIK) and a fresh block is allocated to put the new
* directory entry in.
*
* If ulr->ulr_count is not zero, ulfs_lookup found a slot to insert
* the entry into. This slot ranges from ulr_offset to ulr_offset +
* ulr_count. However, this slot may already be partially populated
* requiring compaction. See notes below.
*
* Furthermore, if ulr_count is not zero and ulr_endoff is not the
* same as i_size, the directory is truncated to size ulr_endoff.
*/
int
ulfs_direnter(struct vnode *dvp, const struct ulfs_lookup_results *ulr,
struct vnode *tvp, struct lfs_direct *dirp,
struct componentname *cnp, struct buf *newdirbp)
{
kauth_cred_t cr;
int newentrysize;
struct inode *dp;
struct buf *bp;
u_int dsize;
struct lfs_direct *ep, *nep;
int error, ret, lfs_blkoff, loc, spacefree;
char *dirbuf;
struct timespec ts;
struct ulfsmount *ump = VFSTOULFS(dvp->v_mount);
struct lfs *fs = ump->um_lfs;
const int needswap = ULFS_MPNEEDSWAP(fs);
int dirblksiz = fs->um_dirblksiz;
error = 0;
cr = cnp->cn_cred;
dp = VTOI(dvp);
newentrysize = LFS_DIRSIZ(0, dirp, 0);
if (ulr->ulr_count == 0) {
/*
* If ulr_count is 0, then namei could find no
* space in the directory. Here, ulr_offset will
* be on a directory block boundary and we will write the
* new entry into a fresh block.
*/
if (ulr->ulr_offset & (dirblksiz - 1))
panic("ulfs_direnter: newblk");
if ((error = lfs_balloc(dvp, (off_t)ulr->ulr_offset, dirblksiz,
cr, B_CLRBUF | B_SYNC, &bp)) != 0) {
return (error);
}
dp->i_size = ulr->ulr_offset + dirblksiz;
DIP_ASSIGN(dp, size, dp->i_size);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
uvm_vnp_setsize(dvp, dp->i_size);
dirp->d_reclen = ulfs_rw16(dirblksiz, needswap);
dirp->d_ino = ulfs_rw32(dirp->d_ino, needswap);
if (FSFMT(dvp)) {
#if (BYTE_ORDER == LITTLE_ENDIAN)
if (needswap == 0) {
#else
if (needswap != 0) {
#endif
u_char tmp = dirp->d_namlen;
dirp->d_namlen = dirp->d_type;
dirp->d_type = tmp;
}
}
lfs_blkoff = ulr->ulr_offset & (ump->um_mountp->mnt_stat.f_iosize - 1);
memcpy((char *)bp->b_data + lfs_blkoff, dirp, newentrysize);
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL) {
ulfsdirhash_newblk(dp, ulr->ulr_offset);
ulfsdirhash_add(dp, dirp, ulr->ulr_offset);
ulfsdirhash_checkblock(dp, (char *)bp->b_data + lfs_blkoff,
ulr->ulr_offset);
}
#endif
error = VOP_BWRITE(bp->b_vp, bp);
vfs_timestamp(&ts);
ret = lfs_update(dvp, &ts, &ts, UPDATE_DIROP);
if (error == 0)
return (ret);
return (error);
}
/*
* If ulr_count is non-zero, then namei found space for the new
* entry in the range ulr_offset to ulr_offset + ulr_count
* in the directory. To use this space, we may have to compact
* the entries located there, by copying them together towards the
* beginning of the block, leaving the free space in one usable
* chunk at the end.
*/
/*
* Increase size of directory if entry eats into new space.
* This should never push the size past a new multiple of
* DIRBLKSIZ.
*
* N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
*/
if (ulr->ulr_offset + ulr->ulr_count > dp->i_size) {
#ifdef DIAGNOSTIC
printf("ulfs_direnter: reached 4.2-only block, "
"not supposed to happen\n");
#endif
dp->i_size = ulr->ulr_offset + ulr->ulr_count;
DIP_ASSIGN(dp, size, dp->i_size);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
}
/*
* Get the block containing the space for the new directory entry.
*/
error = ulfs_blkatoff(dvp, (off_t)ulr->ulr_offset, &dirbuf, &bp, true);
if (error) {
return (error);
}
/*
* Find space for the new entry. In the simple case, the entry at
* offset base will have the space. If it does not, then namei
* arranged that compacting the region ulr_offset to
* ulr_offset + ulr_count would yield the space.
*/
ep = (struct lfs_direct *)dirbuf;
dsize = (ep->d_ino != 0) ? LFS_DIRSIZ(FSFMT(dvp), ep, needswap) : 0;
spacefree = ulfs_rw16(ep->d_reclen, needswap) - dsize;
for (loc = ulfs_rw16(ep->d_reclen, needswap); loc < ulr->ulr_count; ) {
uint16_t reclen;
nep = (struct lfs_direct *)(dirbuf + loc);
/* Trim the existing slot (NB: dsize may be zero). */
ep->d_reclen = ulfs_rw16(dsize, needswap);
ep = (struct lfs_direct *)((char *)ep + dsize);
reclen = ulfs_rw16(nep->d_reclen, needswap);
loc += reclen;
if (nep->d_ino == 0) {
/*
* A mid-block unused entry. Such entries are
* never created by the kernel, but fsck_ffs
* can create them (and it doesn't fix them).
*
* Add up the free space, and initialise the
* relocated entry since we don't memcpy it.
*/
spacefree += reclen;
ep->d_ino = 0;
dsize = 0;
continue;
}
dsize = LFS_DIRSIZ(FSFMT(dvp), nep, needswap);
spacefree += reclen - dsize;
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL)
ulfsdirhash_move(dp, nep,
ulr->ulr_offset + ((char *)nep - dirbuf),
ulr->ulr_offset + ((char *)ep - dirbuf));
#endif
memcpy((void *)ep, (void *)nep, dsize);
}
/*
* Here, `ep' points to a directory entry containing `dsize' in-use
* bytes followed by `spacefree' unused bytes. If ep->d_ino == 0,
* then the entry is completely unused (dsize == 0). The value
* of ep->d_reclen is always indeterminate.
*
* Update the pointer fields in the previous entry (if any),
* copy in the new entry, and write out the block.
*/
if (ep->d_ino == 0 ||
(ulfs_rw32(ep->d_ino, needswap) == ULFS_WINO &&
memcmp(ep->d_name, dirp->d_name, dirp->d_namlen) == 0)) {
if (spacefree + dsize < newentrysize)
panic("ulfs_direnter: compact1");
dirp->d_reclen = spacefree + dsize;
} else {
if (spacefree < newentrysize)
panic("ulfs_direnter: compact2");
dirp->d_reclen = spacefree;
ep->d_reclen = ulfs_rw16(dsize, needswap);
ep = (struct lfs_direct *)((char *)ep + dsize);
}
dirp->d_reclen = ulfs_rw16(dirp->d_reclen, needswap);
dirp->d_ino = ulfs_rw32(dirp->d_ino, needswap);
if (FSFMT(dvp)) {
#if (BYTE_ORDER == LITTLE_ENDIAN)
if (needswap == 0) {
#else
if (needswap != 0) {
#endif
u_char tmp = dirp->d_namlen;
dirp->d_namlen = dirp->d_type;
dirp->d_type = tmp;
}
}
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL && (ep->d_ino == 0 ||
dirp->d_reclen == spacefree))
ulfsdirhash_add(dp, dirp, ulr->ulr_offset + ((char *)ep - dirbuf));
#endif
memcpy((void *)ep, (void *)dirp, (u_int)newentrysize);
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL)
ulfsdirhash_checkblock(dp, dirbuf -
(ulr->ulr_offset & (dirblksiz - 1)),
ulr->ulr_offset & ~(dirblksiz - 1));
#endif
error = VOP_BWRITE(bp->b_vp, bp);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
/*
* If all went well, and the directory can be shortened, proceed
* with the truncation. Note that we have to unlock the inode for
* the entry that we just entered, as the truncation may need to
* lock other inodes which can lead to deadlock if we also hold a
* lock on the newly entered node.
*/
if (error == 0 && ulr->ulr_endoff && ulr->ulr_endoff < dp->i_size) {
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL)
ulfsdirhash_dirtrunc(dp, ulr->ulr_endoff);
#endif
(void) lfs_truncate(dvp, (off_t)ulr->ulr_endoff, IO_SYNC, cr);
}
return (error);
}
/*
* Remove a directory entry after a call to namei, using the
* parameters that ulfs_lookup left in nameidata and in the
* ulfs_lookup_results.
*
* DVP is the directory to be updated. It must be locked.
* ULR is the ulfs_lookup_results structure from the final lookup step.
* IP, if not null, is the inode being unlinked.
* FLAGS may contain DOWHITEOUT.
* ISRMDIR is not used and (XXX) should be removed.
*
* If FLAGS contains DOWHITEOUT the entry is replaced with a whiteout
* instead of being cleared.
*
* ulr->ulr_offset contains the position of the directory entry
* to be removed.
*
* ulr->ulr_reclen contains the size of the directory entry to be
* removed.
*
* ulr->ulr_count contains the size of the *previous* directory
* entry. This allows finding it, for free space management. If
* ulr_count is 0, the target entry is at the beginning of the
* directory. (Does this ever happen? The first entry should be ".",
* which should only be removed at rmdir time. Does rmdir come here
* to clear out the "." and ".." entries? Perhaps, but I doubt it.)
*
* The space is marked free by adding it to the record length (not
* name length) of the preceding entry. If the first entry becomes
* free, it is marked free by setting the inode number to 0.
*
* The link count of IP is decremented. Note that this is not the
* inverse behavior of ulfs_direnter, which does not adjust link
* counts. Sigh.
*/
int
ulfs_dirremove(struct vnode *dvp, const struct ulfs_lookup_results *ulr,
struct inode *ip, int flags, int isrmdir)
{
struct inode *dp = VTOI(dvp);
struct lfs_direct *ep;
struct buf *bp;
int error;
const int needswap = ULFS_MPNEEDSWAP(dp->i_lfs);
if (flags & DOWHITEOUT) {
/*
* Whiteout entry: set d_ino to ULFS_WINO.
*/
error = ulfs_blkatoff(dvp, (off_t)ulr->ulr_offset, (void *)&ep,
&bp, true);
if (error)
return (error);
ep->d_ino = ulfs_rw32(ULFS_WINO, needswap);
ep->d_type = LFS_DT_WHT;
goto out;
}
if ((error = ulfs_blkatoff(dvp,
(off_t)(ulr->ulr_offset - ulr->ulr_count), (void *)&ep, &bp, true)) != 0)
return (error);
#ifdef LFS_DIRHASH
/*
* Remove the dirhash entry. This is complicated by the fact
* that `ep' is the previous entry when ulr_count != 0.
*/
if (dp->i_dirhash != NULL)
ulfsdirhash_remove(dp, (ulr->ulr_count == 0) ? ep :
(struct lfs_direct *)((char *)ep +
ulfs_rw16(ep->d_reclen, needswap)), ulr->ulr_offset);
#endif
if (ulr->ulr_count == 0) {
/*
* First entry in block: set d_ino to zero.
*/
ep->d_ino = 0;
} else {
/*
* Collapse new free space into previous entry.
*/
ep->d_reclen =
ulfs_rw16(ulfs_rw16(ep->d_reclen, needswap) + ulr->ulr_reclen,
needswap);
}
#ifdef LFS_DIRHASH
if (dp->i_dirhash != NULL) {
int dirblksiz = ip->i_lfs->um_dirblksiz;
ulfsdirhash_checkblock(dp, (char *)ep -
((ulr->ulr_offset - ulr->ulr_count) & (dirblksiz - 1)),
ulr->ulr_offset & ~(dirblksiz - 1));
}
#endif
out:
if (ip) {
ip->i_nlink--;
DIP_ASSIGN(ip, nlink, ip->i_nlink);
ip->i_flag |= IN_CHANGE;
}
/*
* XXX did it ever occur to anyone that it might be a good
* idea to restore ip->i_nlink if this fails? Or something?
* Currently on error return from this function the state of
* ip->i_nlink depends on what happened, and callers
* definitely do not take this into account.
*/
error = VOP_BWRITE(bp->b_vp, bp);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
/*
* If the last named reference to a snapshot goes away,
* drop its snapshot reference so that it will be reclaimed
* when last open reference goes away.
*/
if (ip != 0 && (ip->i_flags & SF_SNAPSHOT) != 0 &&
ip->i_nlink == 0)
ulfs_snapgone(ip);
return (error);
}
/*
* Rewrite an existing directory entry to point at the inode supplied.
*
* DP is the directory to update.
* OFFSET is the position of the entry in question. It may come
* from ulr_offset of a ulfs_lookup_results.
* OIP is the old inode the directory previously pointed to.
* NEWINUM is the number of the new inode.
* NEWTYPE is the new value for the type field of the directory entry.
* (This is ignored if the fs doesn't support that.)
* ISRMDIR is not used and (XXX) should be removed.
* IFLAGS are added to DP's inode flags.
*
* The link count of OIP is decremented. Note that the link count of
* the new inode is *not* incremented. Yay for symmetry.
*/
int
ulfs_dirrewrite(struct inode *dp, off_t offset,
struct inode *oip, ino_t newinum, int newtype,
int isrmdir, int iflags)
{
struct buf *bp;
struct lfs_direct *ep;
struct vnode *vdp = ITOV(dp);
int error;
error = ulfs_blkatoff(vdp, offset, (void *)&ep, &bp, true);
if (error)
return (error);
ep->d_ino = ulfs_rw32(newinum, ULFS_IPNEEDSWAP(dp));
if (!FSFMT(vdp))
ep->d_type = newtype;
oip->i_nlink--;
DIP_ASSIGN(oip, nlink, oip->i_nlink);
oip->i_flag |= IN_CHANGE;
error = VOP_BWRITE(bp->b_vp, bp);
dp->i_flag |= iflags;
/*
* If the last named reference to a snapshot goes away,
* drop its snapshot reference so that it will be reclaimed
* when last open reference goes away.
*/
if ((oip->i_flags & SF_SNAPSHOT) != 0 && oip->i_nlink == 0)
ulfs_snapgone(oip);
return (error);
}
/*
* Check if a directory is empty or not.
* Inode supplied must be locked.
*
* Using a struct lfs_dirtemplate here is not precisely
* what we want, but better than using a struct lfs_direct.
*
* NB: does not handle corrupted directories.
*/
int
ulfs_dirempty(struct inode *ip, ino_t parentino, kauth_cred_t cred)
{
doff_t off;
struct lfs_dirtemplate dbuf;
struct lfs_direct *dp = (struct lfs_direct *)&dbuf;
int error, namlen;
size_t count;
const int needswap = ULFS_IPNEEDSWAP(ip);
#define MINDIRSIZ (sizeof (struct lfs_dirtemplate) / 2)
for (off = 0; off < ip->i_size;
off += ulfs_rw16(dp->d_reclen, needswap)) {
error = vn_rdwr(UIO_READ, ITOV(ip), (void *)dp, MINDIRSIZ, off,
UIO_SYSSPACE, IO_NODELOCKED, cred, &count, NULL);
/*
* Since we read MINDIRSIZ, residual must
* be 0 unless we're at end of file.
*/
if (error || count != 0)
return (0);
/* avoid infinite loops */
if (dp->d_reclen == 0)
return (0);
/* skip empty entries */
if (dp->d_ino == 0 || ulfs_rw32(dp->d_ino, needswap) == ULFS_WINO)
continue;
/* accept only "." and ".." */
#if (BYTE_ORDER == LITTLE_ENDIAN)
if (FSFMT(ITOV(ip)) && needswap == 0)
namlen = dp->d_type;
else
namlen = dp->d_namlen;
#else
if (FSFMT(ITOV(ip)) && needswap != 0)
namlen = dp->d_type;
else
namlen = dp->d_namlen;
#endif
if (namlen > 2)
return (0);
if (dp->d_name[0] != '.')
return (0);
/*
* At this point namlen must be 1 or 2.
* 1 implies ".", 2 implies ".." if second
* char is also "."
*/
if (namlen == 1 &&
ulfs_rw32(dp->d_ino, needswap) == ip->i_number)
continue;
if (dp->d_name[1] == '.' &&
ulfs_rw32(dp->d_ino, needswap) == parentino)
continue;
return (0);
}
return (1);
}
#define ULFS_DIRRABLKS 0
int ulfs_dirrablks = ULFS_DIRRABLKS;
/*
* ulfs_blkatoff: Return buffer with the contents of block "offset" from
* the beginning of directory "vp". If "res" is non-NULL, fill it in with
* a pointer to the remaining space in the directory. If the caller intends
* to modify the buffer returned, "modify" must be true.
*/
int
ulfs_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp,
bool modify)
{
struct inode *ip __diagused;
struct buf *bp;
daddr_t lbn;
const int dirrablks = ulfs_dirrablks;
daddr_t *blks;
int *blksizes;
int run, error;
struct mount *mp = vp->v_mount;
const int bshift = mp->mnt_fs_bshift;
const int bsize = 1 << bshift;
off_t eof;
blks = kmem_alloc((1 + dirrablks) * sizeof(daddr_t), KM_SLEEP);
blksizes = kmem_alloc((1 + dirrablks) * sizeof(int), KM_SLEEP);
ip = VTOI(vp);
KASSERT(vp->v_size == ip->i_size);
GOP_SIZE(vp, vp->v_size, &eof, 0);
lbn = offset >> bshift;
for (run = 0; run <= dirrablks;) {
const off_t curoff = lbn << bshift;
const int size = MIN(eof - curoff, bsize);
if (size == 0) {
break;
}
KASSERT(curoff < eof);
blks[run] = lbn;
blksizes[run] = size;
lbn++;
run++;
if (size != bsize) {
break;
}
}
KASSERT(run >= 1);
error = breadn(vp, blks[0], blksizes[0], &blks[1], &blksizes[1],
run - 1, NOCRED, (modify ? B_MODIFY : 0), &bp);
if (error != 0) {
*bpp = NULL;
goto out;
}
if (res) {
*res = (char *)bp->b_data + (offset & (bsize - 1));
}
*bpp = bp;
out:
kmem_free(blks, (1 + dirrablks) * sizeof(daddr_t));
kmem_free(blksizes, (1 + dirrablks) * sizeof(int));
return error;
}
