/*
* Last reference to an inode. If necessary, write or delete it.
*/
int
ufs_inactive(void *v)
{
struct vop_inactive_args /* {
struct vnode *a_vp;
struct bool *a_recycle;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct inode *ip = VTOI(vp);
struct mount *transmp;
mode_t mode;
int error = 0;
int logged = 0;
UFS_WAPBL_JUNLOCK_ASSERT(vp->v_mount);
transmp = vp->v_mount;
fstrans_start(transmp, FSTRANS_SHARED);
/*
* Ignore inodes related to stale file handles.
*/
if (ip->i_mode == 0)
goto out;
if (ip->i_ffs_effnlink == 0 && DOINGSOFTDEP(vp))
softdep_releasefile(ip);
if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
error = UFS_WAPBL_BEGIN(vp->v_mount);
if (error)
goto out;
logged = 1;
#ifdef QUOTA
(void)chkiq(ip, -1, NOCRED, 0);
#endif
#ifdef UFS_EXTATTR
ufs_extattr_vnode_inactive(vp, curlwp);
#endif
if (ip->i_size != 0) {
/*
* When journaling, only truncate one indirect block
* at a time
*/
if (vp->v_mount->mnt_wapbl) {
uint64_t incr = MNINDIR(ip->i_ump) <<
vp->v_mount->mnt_fs_bshift; /* Power of 2 */
uint64_t base = NDADDR <<
vp->v_mount->mnt_fs_bshift;
while (!error && ip->i_size > base + incr) {
/*
* round down to next full indirect
* block boundary.
*/
uint64_t nsize = base +
((ip->i_size - base - 1) &
~(incr - 1));
error = UFS_TRUNCATE(vp, nsize, 0,
NOCRED);
if (error)
break;
UFS_WAPBL_END(vp->v_mount);
error = UFS_WAPBL_BEGIN(vp->v_mount);
if (error)
goto out;
}
}
if (!error)
error = UFS_TRUNCATE(vp, (off_t)0, 0, NOCRED);
}
/*
* Setting the mode to zero needs to wait for the inode
* to be written just as does a change to the link count.
* So, rather than creating a new entry point to do the
* same thing, we just use softdep_change_linkcnt().
*/
DIP_ASSIGN(ip, rdev, 0);
mode = ip->i_mode;
ip->i_mode = 0;
DIP_ASSIGN(ip, mode, 0);
ip->i_flag |= IN_CHANGE | IN_UPDATE;
mutex_enter(&vp->v_interlock);
vp->v_iflag |= VI_FREEING;
mutex_exit(&vp->v_interlock);
if (DOINGSOFTDEP(vp))
softdep_change_linkcnt(ip);
UFS_VFREE(vp, ip->i_number, mode);
}
if (ip->i_flag & (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) {
if (!logged++) {
int err;
err = UFS_WAPBL_BEGIN(vp->v_mount);
if (err)
goto out;
}
UFS_UPDATE(vp, NULL, NULL, 0);
}
if (logged)
UFS_WAPBL_END(vp->v_mount);
out:
/*
* If we are done with the inode, reclaim it
* so that it can be reused immediately.
*/
*ap->a_recycle = (ip->i_mode == 0);
VOP_UNLOCK(vp, 0);
fstrans_done(transmp);
return (error);
}
/*
* Allocate a new inode.
*/
int
ufs_makeinode(int mode, struct vnode *dvp, const struct ufs_lookup_results *ulr,
struct vnode **vpp, struct componentname *cnp)
{
struct inode *ip, *pdir;
struct direct *newdir;
struct vnode *tvp;
int error;
UFS_WAPBL_JUNLOCK_ASSERT(dvp->v_mount);
pdir = VTOI(dvp);
if ((mode & IFMT) == 0)
mode |= IFREG;
if ((error = UFS_VALLOC(dvp, mode, cnp->cn_cred, vpp)) != 0) {
return (error);
}
tvp = *vpp;
ip = VTOI(tvp);
ip->i_gid = pdir->i_gid;
DIP_ASSIGN(ip, gid, ip->i_gid);
ip->i_uid = kauth_cred_geteuid(cnp->cn_cred);
DIP_ASSIGN(ip, uid, ip->i_uid);
error = UFS_WAPBL_BEGIN1(dvp->v_mount, dvp);
if (error) {
/*
* Note, we can't VOP_VFREE(tvp) here like we should
* because we can't write to the disk. Instead, we leave
* the vnode dangling from the journal.
*/
vput(tvp);
return (error);
}
#if defined(QUOTA) || defined(QUOTA2)
if ((error = chkiq(ip, 1, cnp->cn_cred, 0))) {
UFS_VFREE(tvp, ip->i_number, mode);
UFS_WAPBL_END1(dvp->v_mount, dvp);
vput(tvp);
return (error);
}
#endif
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
ip->i_mode = mode;
DIP_ASSIGN(ip, mode, mode);
tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */
ip->i_nlink = 1;
DIP_ASSIGN(ip, nlink, 1);
/* Authorize setting SGID if needed. */
if (ip->i_mode & ISGID) {
error = kauth_authorize_vnode(cnp->cn_cred, KAUTH_VNODE_WRITE_SECURITY,
tvp, NULL, genfs_can_chmod(tvp->v_type, cnp->cn_cred, ip->i_uid,
ip->i_gid, mode));
if (error) {
ip->i_mode &= ~ISGID;
DIP_ASSIGN(ip, mode, ip->i_mode);
}
}
if (cnp->cn_flags & ISWHITEOUT) {
ip->i_flags |= UF_OPAQUE;
DIP_ASSIGN(ip, flags, ip->i_flags);
}
/*
* Make sure inode goes to disk before directory entry.
*/
if ((error = UFS_UPDATE(tvp, NULL, NULL, UPDATE_DIROP)) != 0)
goto bad;
newdir = pool_cache_get(ufs_direct_cache, PR_WAITOK);
ufs_makedirentry(ip, cnp, newdir);
error = ufs_direnter(dvp, ulr, tvp, newdir, cnp, NULL);
pool_cache_put(ufs_direct_cache, newdir);
if (error)
goto bad;
*vpp = tvp;
return (0);
bad:
/*
* Write error occurred trying to update the inode
* or the directory so must deallocate the inode.
*/
ip->i_nlink = 0;
DIP_ASSIGN(ip, nlink, 0);
ip->i_flag |= IN_CHANGE;
UFS_WAPBL_UPDATE(tvp, NULL, NULL, 0);
tvp->v_type = VNON; /* explodes later if VBLK */
UFS_WAPBL_END1(dvp->v_mount, dvp);
vput(tvp);
return (error);
}
/*
* Last reference to an inode. If necessary, write or delete it.
*/
int
ufs_inactive(void *v)
{
struct vop_inactive_args *ap = v;
struct vnode *vp = ap->a_vp;
struct inode *ip = VTOI(vp);
struct fs *fs = ip->i_fs;
struct proc *p = curproc;
mode_t mode;
int error = 0, logged = 0, truncate_error = 0;
#ifdef DIAGNOSTIC
extern int prtactive;
if (prtactive && vp->v_usecount != 0)
vprint("ufs_inactive: pushing active", vp);
#endif
UFS_WAPBL_JUNLOCK_ASSERT(vp->v_mount);
/*
* Ignore inodes related to stale file handles.
*/
if (ip->i_din1 == NULL || DIP(ip, mode) == 0)
goto out;
if (DIP(ip, nlink) <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
error = UFS_WAPBL_BEGIN(vp->v_mount);
if (error)
goto out;
logged = 1;
if (getinoquota(ip) == 0)
(void)ufs_quota_free_inode(ip, NOCRED);
if (DIP(ip, size) != 0 && vp->v_mount->mnt_wapbl) {
/*
* When journaling, only truncate one indirect block at
* a time.
*/
uint64_t incr = MNINDIR(ip->i_ump) << fs->fs_bshift;
uint64_t base = NDADDR << fs->fs_bshift;
while (!error && DIP(ip, size) > base + incr) {
/*
* round down to next full indirect block
* boundary.
*/
uint64_t nsize = base +
((DIP(ip, size) - base - 1) &
~(incr - 1));
error = UFS_TRUNCATE(ip, nsize, 0, NOCRED);
if (error)
break;
UFS_WAPBL_END(vp->v_mount);
error = UFS_WAPBL_BEGIN(vp->v_mount);
if (error)
goto out;
}
}
if (error == 0) {
truncate_error = UFS_TRUNCATE(ip, (off_t)0, 0, NOCRED);
/* XXX pedro: remove me */
if (truncate_error)
printf("UFS_TRUNCATE()=%d\n", truncate_error);
}
DIP_ASSIGN(ip, rdev, 0);
mode = DIP(ip, mode);
DIP_ASSIGN(ip, mode, 0);
ip->i_flag |= IN_CHANGE | IN_UPDATE;
/*
* Setting the mode to zero needs to wait for the inode to be
* written just as does a change to the link count. So, rather
* than creating a new entry point to do the same thing, we
* just use softdep_change_linkcnt(). Also, we can't let
* softdep co-opt us to help on its worklist, as we may end up
* trying to recycle vnodes and getting to this same point a
* couple of times, blowing the kernel stack. However, this
* could be optimized by checking if we are coming from
* vrele(), vput() or vclean() (by checking for VXLOCK) and
* just avoiding the co-opt to happen in the last case.
*/
if (DOINGSOFTDEP(vp))
softdep_change_linkcnt(ip, 1);
UFS_INODE_FREE(ip, ip->i_number, mode);
}
if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) {
if (!logged++) {
int err;
err = UFS_WAPBL_BEGIN(vp->v_mount);
if (err) {
error = err;
goto out;
}
}
UFS_UPDATE(ip, 0);
}
if (logged)
UFS_WAPBL_END(vp->v_mount);
out:
VOP_UNLOCK(vp, 0);
/*
* If we are done with the inode, reclaim it
* so that it can be reused immediately.
*/
if (error == 0 && truncate_error == 0 &&
(ip->i_din1 == NULL || DIP(ip, mode) == 0))
vrecycle(vp, p);
return (truncate_error ? truncate_error : error);
}
