/*
* We need to process our own vnode unlock and then clear the
* interlock flag as it applies only to our vnode, not the
* vnodes below us on the stack.
*/
static int
null_unlock(struct vop_unlock_args *ap)
{
struct vnode *vp = ap->a_vp;
int flags = ap->a_flags;
int mtxlkflag = 0;
struct null_node *nn;
struct vnode *lvp;
int error;
if ((flags & LK_INTERLOCK) != 0)
mtxlkflag = 1;
else if (mtx_owned(VI_MTX(vp)) == 0) {
VI_LOCK(vp);
mtxlkflag = 2;
}
nn = VTONULL(vp);
if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) {
VI_LOCK_FLAGS(lvp, MTX_DUPOK);
flags |= LK_INTERLOCK;
vholdl(lvp);
VI_UNLOCK(vp);
error = VOP_UNLOCK(lvp, flags);
vdrop(lvp);
if (mtxlkflag == 0)
VI_LOCK(vp);
} else {
if (mtxlkflag == 2)
VI_UNLOCK(vp);
error = vop_stdunlock(ap);
}
return (error);
}
/*
* We handle this to eliminate null FS to lower FS
* file moving. Don't know why we don't allow this,
* possibly we should.
*/
static int
null_rename(struct vop_rename_args *ap)
{
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
struct vnode *fdvp = ap->a_fdvp;
struct vnode *tvp = ap->a_tvp;
struct null_node *tnn;
/* Check for cross-device rename. */
if ((fvp->v_mount != tdvp->v_mount) ||
(tvp && (fvp->v_mount != tvp->v_mount))) {
if (tdvp == tvp)
vrele(tdvp);
else
vput(tdvp);
if (tvp)
vput(tvp);
vrele(fdvp);
vrele(fvp);
return (EXDEV);
}
if (tvp != NULL) {
tnn = VTONULL(tvp);
tnn->null_flags |= NULLV_DROP;
}
return (null_bypass((struct vop_generic_args *)ap));
}
/*
* Now, the VXLOCK is in force and we're free to destroy the null vnode.
*/
static int
null_reclaim(struct vop_reclaim_args *ap)
{
struct vnode *vp = ap->a_vp;
struct null_node *xp = VTONULL(vp);
struct vnode *lowervp = xp->null_lowervp;
if (lowervp)
null_hashrem(xp);
/*
* Use the interlock to protect the clearing of v_data to
* prevent faults in null_lock().
*/
lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL);
VI_LOCK(vp);
vp->v_data = NULL;
vp->v_object = NULL;
vp->v_vnlock = &vp->v_lock;
VI_UNLOCK(vp);
if (lowervp)
vput(lowervp);
else
panic("null_reclaim: reclaiming a node with no lowervp");
free(xp, M_NULLFSNODE);
return (0);
}
static int
null_rmdir(struct vop_rmdir_args *ap)
{
VTONULL(ap->a_vp)->null_flags |= NULLV_DROP;
return (null_bypass(&ap->a_gen));
}
static int
crypto_rmdir(struct vop_rmdir_args *ap)
{
VTONULL(ap->a_vp)->crypto_flags |= NULLV_DROP;
return (crypto_bypass(&ap->a_gen));
}
/*
* Make a new or get existing nullfs node.
* Vp is the alias vnode, lowervp is the lower vnode.
*
* lowervp is assumed to have an iocount on it from the caller
*/
int
null_nodeget(
struct mount * mp, struct vnode * lowervp, struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp, int root)
{
struct vnode * vp;
int error;
/* Lookup the hash firstly. */
error = null_hashget(mp, lowervp, vpp);
/* ENOENT means it wasn't found, EIO is a failure we should bail from, 0 is it
* was found */
if (error != ENOENT) {
/* null_hashget checked the vid, so if we got something here its legit to
* the best of our knowledge*/
/* if we found something then there is an iocount on vpp,
if we didn't find something then vpp shouldn't be used by the caller */
return error;
}
/*
* We do not serialize vnode creation, instead we will check for
* duplicates later, when adding new vnode to hash.
*/
error = vnode_ref(lowervp); // take a ref on lowervp so we let the system know we care about it
if(error)
{
// Failed to get a reference on the lower vp so bail. Lowervp may be gone already.
return error;
}
error = null_getnewvnode(mp, lowervp, dvp, &vp, cnp, root);
if (error) {
vnode_rele(lowervp);
return (error);
}
/*
* Atomically insert our new node into the hash or vget existing
* if someone else has beaten us to it.
*/
error = null_hashins(mp, VTONULL(vp), vpp);
if (error || *vpp != NULL) {
/* recycle will call reclaim which will get rid of the internals */
vnode_recycle(vp);
vnode_put(vp);
/* if we found vpp, then null_hashins put an iocount on it */
return error;
}
/* vp has an iocount from null_getnewvnode */
*vpp = vp;
return (0);
}
static int
null_reclaim(struct vnop_reclaim_args * ap)
{
struct vnode * vp;
struct null_node * xp;
struct vnode * lowervp;
struct null_mount * null_mp = MOUNTTONULLMOUNT(vnode_mount(ap->a_vp));
NULLFSDEBUG("%s %p\n", __FUNCTION__, ap->a_vp);
vp = ap->a_vp;
xp = VTONULL(vp);
lowervp = xp->null_lowervp;
lck_mtx_lock(&null_mp->nullm_lock);
vnode_removefsref(vp);
if (lowervp != NULL) {
/* root and second don't have a lowervp, so nothing to release and nothing
* got hashed */
if (xp->null_flags & NULL_FLAG_HASHED) {
/* only call this if we actually made it into the hash list. reclaim gets
called also to
clean up a vnode that got created when it didn't need to under race
conditions */
null_hashrem(xp);
}
vnode_getwithref(lowervp);
vnode_rele(lowervp);
vnode_put(lowervp);
}
if (vp == null_mp->nullm_rootvp) {
null_mp->nullm_rootvp = NULL;
} else if (vp == null_mp->nullm_secondvp) {
null_mp->nullm_secondvp = NULL;
} else if (vp == null_mp->nullm_thirdcovervp) {
null_mp->nullm_thirdcovervp = NULL;
}
lck_mtx_unlock(&null_mp->nullm_lock);
cache_purge(vp);
vnode_clearfsnode(vp);
FREE(xp, M_TEMP);
return 0;
}
/*
* Increasing refcount of lower vnode is needed at least for the case
* when lower FS is NFS to do sillyrename if the file is in use.
* Unfortunately v_usecount is incremented in many places in
* the kernel and, as such, there may be races that result in
* the NFS client doing an extraneous silly rename, but that seems
* preferable to not doing a silly rename when it is needed.
*/
static int
null_remove(struct vop_remove_args *ap)
{
int retval, vreleit;
struct vnode *lvp, *vp;
vp = ap->a_vp;
if (vrefcnt(vp) > 1) {
lvp = NULLVPTOLOWERVP(vp);
VREF(lvp);
vreleit = 1;
} else
vreleit = 0;
VTONULL(vp)->null_flags |= NULLV_DROP;
retval = null_bypass(&ap->a_gen);
if (vreleit != 0)
vrele(lvp);
return (retval);
}
/* ARGSUSED */
static int
null_getwritemount(struct vop_getwritemount_args *ap)
{
struct null_node *xp;
struct vnode *lowervp;
struct vnode *vp;
vp = ap->a_vp;
VI_LOCK(vp);
xp = VTONULL(vp);
if (xp && (lowervp = xp->null_lowervp)) {
VI_LOCK_FLAGS(lowervp, MTX_DUPOK);
VI_UNLOCK(vp);
vholdl(lowervp);
VI_UNLOCK(lowervp);
VOP_GETWRITEMOUNT(lowervp, ap->a_mpp);
vdrop(lowervp);
} else {
VI_UNLOCK(vp);
*(ap->a_mpp) = NULL;
}
return (0);
}
/*
* Mount null layer
*/
static int
nullfs_mount(struct mount *mp)
{
int error = 0;
struct vnode *lowerrootvp, *vp;
struct vnode *nullm_rootvp;
struct null_mount *xmp;
struct thread *td = curthread;
char *target;
int isvnunlocked = 0, len;
struct nameidata nd, *ndp = &nd;
NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
if (!prison_allow(td->td_ucred, PR_ALLOW_MOUNT_NULLFS))
return (EPERM);
if (mp->mnt_flag & MNT_ROOTFS)
return (EOPNOTSUPP);
/*
* Update is a no-op
*/
if (mp->mnt_flag & MNT_UPDATE) {
/*
* Only support update mounts for NFS export.
*/
if (vfs_flagopt(mp->mnt_optnew, "export", NULL, 0))
return (0);
else
return (EOPNOTSUPP);
}
/*
* Get argument
*/
error = vfs_getopt(mp->mnt_optnew, "target", (void **)&target, &len);
if (error || target[len - 1] != '\0')
return (EINVAL);
/*
* Unlock lower node to avoid possible deadlock.
*/
if ((mp->mnt_vnodecovered->v_op == &null_vnodeops) &&
VOP_ISLOCKED(mp->mnt_vnodecovered) == LK_EXCLUSIVE) {
VOP_UNLOCK(mp->mnt_vnodecovered, 0);
isvnunlocked = 1;
}
/*
* Find lower node
*/
NDINIT(ndp, LOOKUP, FOLLOW|LOCKLEAF, UIO_SYSSPACE, target, curthread);
error = namei(ndp);
/*
* Re-lock vnode.
* XXXKIB This is deadlock-prone as well.
*/
if (isvnunlocked)
vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY);
if (error)
return (error);
NDFREE(ndp, NDF_ONLY_PNBUF);
/*
* Sanity check on lower vnode
*/
lowerrootvp = ndp->ni_vp;
/*
* Check multi null mount to avoid `lock against myself' panic.
*/
if (lowerrootvp == VTONULL(mp->mnt_vnodecovered)->null_lowervp) {
NULLFSDEBUG("nullfs_mount: multi null mount?\n");
vput(lowerrootvp);
return (EDEADLK);
}
xmp = (struct null_mount *) malloc(sizeof(struct null_mount),
M_NULLFSMNT, M_WAITOK | M_ZERO);
/*
* Save reference to underlying FS
*/
xmp->nullm_vfs = lowerrootvp->v_mount;
/*
* Save reference. Each mount also holds
* a reference on the root vnode.
*/
error = null_nodeget(mp, lowerrootvp, &vp);
/*
* Make sure the node alias worked
*/
if (error) {
free(xmp, M_NULLFSMNT);
return (error);
}
/*
* Keep a held reference to the root vnode.
* It is vrele'd in nullfs_unmount.
*/
nullm_rootvp = vp;
nullm_rootvp->v_vflag |= VV_ROOT;
xmp->nullm_rootvp = nullm_rootvp;
/*
* Unlock the node (either the lower or the alias)
*/
VOP_UNLOCK(vp, 0);
if (NULLVPTOLOWERVP(nullm_rootvp)->v_mount->mnt_flag & MNT_LOCAL) {
MNT_ILOCK(mp);
mp->mnt_flag |= MNT_LOCAL;
MNT_IUNLOCK(mp);
}
xmp->nullm_flags |= NULLM_CACHE;
if (vfs_getopt(mp->mnt_optnew, "nocache", NULL, NULL) == 0)
xmp->nullm_flags &= ~NULLM_CACHE;
MNT_ILOCK(mp);
if ((xmp->nullm_flags & NULLM_CACHE) != 0) {
mp->mnt_kern_flag |= lowerrootvp->v_mount->mnt_kern_flag &
(MNTK_SHARED_WRITES | MNTK_LOOKUP_SHARED |
MNTK_EXTENDED_SHARED);
}
mp->mnt_kern_flag |= MNTK_LOOKUP_EXCL_DOTDOT;
MNT_IUNLOCK(mp);
mp->mnt_data = xmp;
vfs_getnewfsid(mp);
if ((xmp->nullm_flags & NULLM_CACHE) != 0) {
MNT_ILOCK(xmp->nullm_vfs);
TAILQ_INSERT_TAIL(&xmp->nullm_vfs->mnt_uppers, mp,
mnt_upper_link);
MNT_IUNLOCK(xmp->nullm_vfs);
}
vfs_mountedfrom(mp, target);
NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
return (0);
}
/*
* We need to process our own vnode lock and then clear the
* interlock flag as it applies only to our vnode, not the
* vnodes below us on the stack.
*/
static int
null_lock(struct vop_lock1_args *ap)
{
struct vnode *vp = ap->a_vp;
int flags = ap->a_flags;
struct null_node *nn;
struct vnode *lvp;
int error;
if ((flags & LK_INTERLOCK) == 0) {
VI_LOCK(vp);
ap->a_flags = flags |= LK_INTERLOCK;
}
nn = VTONULL(vp);
/*
* If we're still active we must ask the lower layer to
* lock as ffs has special lock considerations in it's
* vop lock.
*/
if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) {
VI_LOCK_FLAGS(lvp, MTX_DUPOK);
VI_UNLOCK(vp);
/*
* We have to hold the vnode here to solve a potential
* reclaim race. If we're forcibly vgone'd while we
* still have refs, a thread could be sleeping inside
* the lowervp's vop_lock routine. When we vgone we will
* drop our last ref to the lowervp, which would allow it
* to be reclaimed. The lowervp could then be recycled,
* in which case it is not legal to be sleeping in it's VOP.
* We prevent it from being recycled by holding the vnode
* here.
*/
vholdl(lvp);
error = VOP_LOCK(lvp, flags);
/*
* We might have slept to get the lock and someone might have
* clean our vnode already, switching vnode lock from one in
* lowervp to v_lock in our own vnode structure. Handle this
* case by reacquiring correct lock in requested mode.
*/
if (VTONULL(vp) == NULL && error == 0) {
ap->a_flags &= ~(LK_TYPE_MASK | LK_INTERLOCK);
switch (flags & LK_TYPE_MASK) {
case LK_SHARED:
ap->a_flags |= LK_SHARED;
break;
case LK_UPGRADE:
case LK_EXCLUSIVE:
ap->a_flags |= LK_EXCLUSIVE;
break;
default:
panic("Unsupported lock request %d\n",
ap->a_flags);
}
VOP_UNLOCK(lvp, 0);
error = vop_stdlock(ap);
}
vdrop(lvp);
} else
error = vop_stdlock(ap);
return (error);
}
/*
* Do not allow the VOP_INACTIVE to be passed to the lower layer,
* since the reference count on the lower vnode is not related to
* ours.
*/
static int
null_inactive(struct vop_inactive_args *ap __unused)
{
struct vnode *vp, *lvp;
struct null_node *xp;
struct mount *mp;
struct null_mount *xmp;
vp = ap->a_vp;
xp = VTONULL(vp);
lvp = NULLVPTOLOWERVP(vp);
mp = vp->v_mount;
xmp = MOUNTTONULLMOUNT(mp);
if ((xmp->nullm_flags & NULLM_CACHE) == 0 ||
(xp->null_flags & NULLV_DROP) != 0 ||
(lvp->v_vflag & VV_NOSYNC) != 0) {
/*
* If this is the last reference and caching of the
* nullfs vnodes is not enabled, or the lower vnode is
* deleted, then free up the vnode so as not to tie up
* the lower vnodes.
*/
vp->v_object = NULL;
vrecycle(vp, curthread);
}
int
null_filestat(struct vnode *vp, struct filestat *fsp)
{
struct null_node node;
struct filestat fst;
struct vnode vn;
int fail = 1;
memset(&fst, 0, sizeof fst);
if (!KVM_READ(VTONULL(vp), &node, sizeof (node))) {
dprintf("can't read node at %p for pid %ld",
VTONULL(vp), (long)Pid);
return 0;
}
/*
* Attempt to find information that might be useful.
*/
if (node.null_lowervp) {
if (!KVM_READ(node.null_lowervp, &vn, sizeof (vn))) {
dprintf("can't read vnode at %p for pid %ld",
node.null_lowervp, (long)Pid);
return 0;
}
fail = 0;
if (vn.v_type == VNON || vn.v_tag == VT_NON)
fail = 1;
else if (vn.v_type == VBAD)
fail = 1;
else
switch (vn.v_tag) {
case VT_UFS:
case VT_MFS:
if (!ufs_filestat(&vn, &fst))
fail = 1;
break;
case VT_NFS:
if (!nfs_filestat(&vn, &fst))
fail = 1;
break;
case VT_EXT2FS:
if (!ext2fs_filestat(&vn, &fst))
fail = 1;
break;
case VT_ISOFS:
if (!isofs_filestat(&vn, &fst))
fail = 1;
break;
case VT_MSDOSFS:
if (!msdos_filestat(&vn, &fst))
fail = 1;
break;
case VT_XFS:
if (!xfs_filestat(&vn, &fst))
fail = 1;
break;
default:
break;
}
}
fsp->fsid = (long)node.null_vnode;
if (fail)
fsp->fileid = (long)node.null_lowervp;
else
fsp->fileid = fst.fileid;
fsp->mode = fst.mode;
fsp->size = fst.mode;
fsp->rdev = fst.mode;
return 1;
}
/*
* Mount null layer
*/
static int
nullfs_mount(struct mount *mp)
{
int error = 0;
struct vnode *lowerrootvp, *vp;
struct vnode *nullm_rootvp;
struct null_mount *xmp;
char *target;
int isvnunlocked = 0, len;
struct nameidata nd, *ndp = &nd;
NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
if (mp->mnt_flag & MNT_ROOTFS)
return (EOPNOTSUPP);
/*
* Update is a no-op
*/
if (mp->mnt_flag & MNT_UPDATE) {
/*
* Only support update mounts for NFS export.
*/
if (vfs_flagopt(mp->mnt_optnew, "export", NULL, 0))
return (0);
else
return (EOPNOTSUPP);
}
/*
* Get argument
*/
error = vfs_getopt(mp->mnt_optnew, "target", (void **)&target, &len);
if (error || target[len - 1] != '\0')
return (EINVAL);
/*
* Unlock lower node to avoid deadlock.
* (XXX) VOP_ISLOCKED is needed?
*/
if ((mp->mnt_vnodecovered->v_op == &null_vnodeops) &&
VOP_ISLOCKED(mp->mnt_vnodecovered)) {
VOP_UNLOCK(mp->mnt_vnodecovered, 0);
isvnunlocked = 1;
}
/*
* Find lower node
*/
NDINIT(ndp, LOOKUP, FOLLOW|LOCKLEAF, UIO_SYSSPACE, target, curthread);
error = namei(ndp);
/*
* Re-lock vnode.
*/
if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered))
vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY);
if (error)
return (error);
NDFREE(ndp, NDF_ONLY_PNBUF);
/*
* Sanity check on lower vnode
*/
lowerrootvp = ndp->ni_vp;
/*
* Check multi null mount to avoid `lock against myself' panic.
*/
if (lowerrootvp == VTONULL(mp->mnt_vnodecovered)->null_lowervp) {
NULLFSDEBUG("nullfs_mount: multi null mount?\n");
vput(lowerrootvp);
return (EDEADLK);
}
xmp = (struct null_mount *) malloc(sizeof(struct null_mount),
M_NULLFSMNT, M_WAITOK); /* XXX */
/*
* Save reference to underlying FS
*/
xmp->nullm_vfs = lowerrootvp->v_mount;
/*
* Save reference. Each mount also holds
* a reference on the root vnode.
*/
error = null_nodeget(mp, lowerrootvp, &vp);
/*
* Make sure the node alias worked
*/
if (error) {
VOP_UNLOCK(vp, 0);
vrele(lowerrootvp);
free(xmp, M_NULLFSMNT); /* XXX */
return (error);
}
/*
* Keep a held reference to the root vnode.
* It is vrele'd in nullfs_unmount.
*/
nullm_rootvp = vp;
nullm_rootvp->v_vflag |= VV_ROOT;
xmp->nullm_rootvp = nullm_rootvp;
/*
* Unlock the node (either the lower or the alias)
*/
VOP_UNLOCK(vp, 0);
if (NULLVPTOLOWERVP(nullm_rootvp)->v_mount->mnt_flag & MNT_LOCAL) {
MNT_ILOCK(mp);
mp->mnt_flag |= MNT_LOCAL;
MNT_IUNLOCK(mp);
}
MNT_ILOCK(mp);
mp->mnt_kern_flag |= lowerrootvp->v_mount->mnt_kern_flag & MNTK_MPSAFE;
MNT_IUNLOCK(mp);
mp->mnt_data = xmp;
vfs_getnewfsid(mp);
vfs_mountedfrom(mp, target);
NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
return (0);
}
