2005-01-06 18:10:42 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1992, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
* John Heidemann of the UCLA Ficus project.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-24 10:09:53 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)null_vnops.c 8.6 (Berkeley) 5/27/95
|
|
|
|
*
|
|
|
|
* Ancestors:
|
|
|
|
* @(#)lofs_vnops.c 1.2 (Berkeley) 6/18/92
|
|
|
|
* ...and...
|
|
|
|
* @(#)null_vnodeops.c 1.20 92/07/07 UCLA Ficus project
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Null Layer
|
|
|
|
*
|
2001-05-24 13:17:47 +00:00
|
|
|
* (See mount_nullfs(8) for more information.)
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
2002-05-16 21:28:32 +00:00
|
|
|
* The null layer duplicates a portion of the filesystem
|
1994-05-24 10:09:53 +00:00
|
|
|
* name space under a new name. In this respect, it is
|
2002-05-16 21:28:32 +00:00
|
|
|
* similar to the loopback filesystem. It differs from
|
1994-05-24 10:09:53 +00:00
|
|
|
* the loopback fs in two respects: it is implemented using
|
1998-04-17 22:37:19 +00:00
|
|
|
* a stackable layers techniques, and its "null-node"s stack above
|
1994-05-24 10:09:53 +00:00
|
|
|
* all lower-layer vnodes, not just over directory vnodes.
|
|
|
|
*
|
|
|
|
* The null layer has two purposes. First, it serves as a demonstration
|
|
|
|
* of layering by proving a layer which does nothing. (It actually
|
2002-05-16 21:28:32 +00:00
|
|
|
* does everything the loopback filesystem does, which is slightly
|
1994-05-24 10:09:53 +00:00
|
|
|
* more than nothing.) Second, the null layer can serve as a prototype
|
|
|
|
* layer. Since it provides all necessary layer framework,
|
2002-05-16 21:28:32 +00:00
|
|
|
* new filesystem layers can be created very easily be starting
|
1994-05-24 10:09:53 +00:00
|
|
|
* with a null layer.
|
|
|
|
*
|
|
|
|
* The remainder of this man page examines the null layer as a basis
|
|
|
|
* for constructing new layers.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* INSTANTIATING NEW NULL LAYERS
|
|
|
|
*
|
2001-05-24 13:17:47 +00:00
|
|
|
* New null layers are created with mount_nullfs(8).
|
|
|
|
* Mount_nullfs(8) takes two arguments, the pathname
|
1994-05-24 10:09:53 +00:00
|
|
|
* of the lower vfs (target-pn) and the pathname where the null
|
|
|
|
* layer will appear in the namespace (alias-pn). After
|
|
|
|
* the null layer is put into place, the contents
|
|
|
|
* of target-pn subtree will be aliased under alias-pn.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* OPERATION OF A NULL LAYER
|
|
|
|
*
|
2002-05-16 21:28:32 +00:00
|
|
|
* The null layer is the minimum filesystem layer,
|
1994-05-24 10:09:53 +00:00
|
|
|
* simply bypassing all possible operations to the lower layer
|
|
|
|
* for processing there. The majority of its activity centers
|
1997-06-26 16:13:56 +00:00
|
|
|
* on the bypass routine, through which nearly all vnode operations
|
1994-05-24 10:09:53 +00:00
|
|
|
* pass.
|
|
|
|
*
|
|
|
|
* The bypass routine accepts arbitrary vnode operations for
|
|
|
|
* handling by the lower layer. It begins by examing vnode
|
|
|
|
* operation arguments and replacing any null-nodes by their
|
|
|
|
* lower-layer equivlants. It then invokes the operation
|
|
|
|
* on the lower layer. Finally, it replaces the null-nodes
|
|
|
|
* in the arguments and, if a vnode is return by the operation,
|
|
|
|
* stacks a null-node on top of the returned vnode.
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Although bypass handles most operations, vop_getattr, vop_lock,
|
|
|
|
* vop_unlock, vop_inactive, vop_reclaim, and vop_print are not
|
|
|
|
* bypassed. Vop_getattr must change the fsid being returned.
|
|
|
|
* Vop_lock and vop_unlock must handle any locking for the
|
|
|
|
* current vnode as well as pass the lock request down.
|
1994-05-24 10:09:53 +00:00
|
|
|
* Vop_inactive and vop_reclaim are not bypassed so that
|
1997-02-10 02:22:35 +00:00
|
|
|
* they can handle freeing null-layer specific data. Vop_print
|
|
|
|
* is not bypassed to avoid excessive debugging information.
|
|
|
|
* Also, certain vnode operations change the locking state within
|
|
|
|
* the operation (create, mknod, remove, link, rename, mkdir, rmdir,
|
|
|
|
* and symlink). Ideally these operations should not change the
|
|
|
|
* lock state, but should be changed to let the caller of the
|
|
|
|
* function unlock them. Otherwise all intermediate vnode layers
|
|
|
|
* (such as union, umapfs, etc) must catch these functions to do
|
|
|
|
* the necessary locking at their layer.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* INSTANTIATING VNODE STACKS
|
|
|
|
*
|
|
|
|
* Mounting associates the null layer with a lower layer,
|
|
|
|
* effect stacking two VFSes. Vnode stacks are instead
|
|
|
|
* created on demand as files are accessed.
|
|
|
|
*
|
|
|
|
* The initial mount creates a single vnode stack for the
|
|
|
|
* root of the new null layer. All other vnode stacks
|
|
|
|
* are created as a result of vnode operations on
|
|
|
|
* this or other null vnode stacks.
|
|
|
|
*
|
2016-04-29 20:51:24 +00:00
|
|
|
* New vnode stacks come into existence as a result of
|
1995-05-30 08:16:23 +00:00
|
|
|
* an operation which returns a vnode.
|
1994-05-24 10:09:53 +00:00
|
|
|
* The bypass routine stacks a null-node above the new
|
|
|
|
* vnode before returning it to the caller.
|
|
|
|
*
|
|
|
|
* For example, imagine mounting a null layer with
|
2001-05-24 13:17:47 +00:00
|
|
|
* "mount_nullfs /usr/include /dev/layer/null".
|
1994-05-24 10:09:53 +00:00
|
|
|
* Changing directory to /dev/layer/null will assign
|
|
|
|
* the root null-node (which was created when the null layer was mounted).
|
|
|
|
* Now consider opening "sys". A vop_lookup would be
|
|
|
|
* done on the root null-node. This operation would bypass through
|
1995-05-30 08:16:23 +00:00
|
|
|
* to the lower layer which would return a vnode representing
|
1994-05-24 10:09:53 +00:00
|
|
|
* the UFS "sys". Null_bypass then builds a null-node
|
|
|
|
* aliasing the UFS "sys" and returns this to the caller.
|
|
|
|
* Later operations on the null-node "sys" will repeat this
|
|
|
|
* process when constructing other vnode stacks.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* CREATING OTHER FILE SYSTEM LAYERS
|
|
|
|
*
|
2002-05-16 21:28:32 +00:00
|
|
|
* One of the easiest ways to construct new filesystem layers is to make
|
1994-05-24 10:09:53 +00:00
|
|
|
* a copy of the null layer, rename all files and variables, and
|
|
|
|
* then begin modifing the copy. Sed can be used to easily rename
|
|
|
|
* all variables.
|
|
|
|
*
|
1995-05-30 08:16:23 +00:00
|
|
|
* The umap layer is an example of a layer descended from the
|
1994-05-24 10:09:53 +00:00
|
|
|
* null layer.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* INVOKING OPERATIONS ON LOWER LAYERS
|
|
|
|
*
|
1995-05-30 08:16:23 +00:00
|
|
|
* There are two techniques to invoke operations on a lower layer
|
1994-05-24 10:09:53 +00:00
|
|
|
* when the operation cannot be completely bypassed. Each method
|
|
|
|
* is appropriate in different situations. In both cases,
|
|
|
|
* it is the responsibility of the aliasing layer to make
|
|
|
|
* the operation arguments "correct" for the lower layer
|
2002-12-30 21:18:15 +00:00
|
|
|
* by mapping a vnode arguments to the lower layer.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
* The first approach is to call the aliasing layer's bypass routine.
|
|
|
|
* This method is most suitable when you wish to invoke the operation
|
1997-06-26 17:12:59 +00:00
|
|
|
* currently being handled on the lower layer. It has the advantage
|
1994-05-24 10:09:53 +00:00
|
|
|
* that the bypass routine already must do argument mapping.
|
|
|
|
* An example of this is null_getattrs in the null layer.
|
|
|
|
*
|
1997-06-26 17:12:59 +00:00
|
|
|
* A second approach is to directly invoke vnode operations on
|
1994-05-24 10:09:53 +00:00
|
|
|
* the lower layer with the VOP_OPERATIONNAME interface.
|
|
|
|
* The advantage of this method is that it is easy to invoke
|
|
|
|
* arbitrary operations on the lower layer. The disadvantage
|
1997-06-26 17:12:59 +00:00
|
|
|
* is that vnode arguments must be manualy mapped.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2000-09-25 15:38:32 +00:00
|
|
|
#include <sys/conf.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mount.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/mutex.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/namei.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
|
2001-05-23 09:42:29 +00:00
|
|
|
#include <fs/nullfs/null.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-09-25 15:38:32 +00:00
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/vm_extern.h>
|
|
|
|
#include <vm/vm_object.h>
|
|
|
|
#include <vm/vnode_pager.h>
|
|
|
|
|
1995-12-11 09:24:58 +00:00
|
|
|
static int null_bug_bypass = 0; /* for debugging: enables bypass printf'ing */
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, nullfs_bug_bypass, CTLFLAG_RW,
|
|
|
|
&null_bug_bypass, 0, "");
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the 10-Apr-92 bypass routine.
|
|
|
|
* This version has been optimized for speed, throwing away some
|
|
|
|
* safety checks. It should still always work, but it's not as
|
|
|
|
* robust to programmer errors.
|
|
|
|
*
|
|
|
|
* In general, we map all vnodes going down and unmap them on the way back.
|
|
|
|
* As an exception to this, vnodes can be marked "unmapped" by setting
|
|
|
|
* the Nth bit in operation's vdesc_flags.
|
|
|
|
*
|
|
|
|
* Also, some BSD vnode operations have the side effect of vrele'ing
|
|
|
|
* their arguments. With stacking, the reference counts are held
|
|
|
|
* by the upper node, not the lower one, so we must handle these
|
|
|
|
* side-effects here. This is not of concern in Sun-derived systems
|
|
|
|
* since there are no such side-effects.
|
|
|
|
*
|
|
|
|
* This makes the following assumptions:
|
|
|
|
* - only one returned vpp
|
|
|
|
* - no INOUT vpp's (Sun's vop_open has one of these)
|
|
|
|
* - the vnode operation vector of the first vnode should be used
|
|
|
|
* to determine what implementation of the op should be invoked
|
|
|
|
* - all mapped vnodes are of our vnode-type (NEEDSWORK:
|
|
|
|
* problems on rmdir'ing mount points and renaming?)
|
1995-05-30 08:16:23 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_bypass(struct vop_generic_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-01-24 12:37:51 +00:00
|
|
|
struct vnode **this_vp_p;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct vnode *old_vps[VDESC_MAX_VPS];
|
|
|
|
struct vnode **vps_p[VDESC_MAX_VPS];
|
|
|
|
struct vnode ***vppp;
|
|
|
|
struct vnodeop_desc *descp = ap->a_desc;
|
|
|
|
int reles, i;
|
|
|
|
|
|
|
|
if (null_bug_bypass)
|
|
|
|
printf ("null_bypass: %s\n", descp->vdesc_name);
|
|
|
|
|
1999-08-30 07:08:04 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* We require at least one vp.
|
|
|
|
*/
|
|
|
|
if (descp->vdesc_vp_offsets == NULL ||
|
|
|
|
descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET)
|
1999-08-30 07:08:04 +00:00
|
|
|
panic ("null_bypass: no vp's in map");
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the vnodes going in.
|
|
|
|
* Later, we'll invoke the operation based on
|
|
|
|
* the first mapped vnode's operation vector.
|
|
|
|
*/
|
|
|
|
reles = descp->vdesc_flags;
|
|
|
|
for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
|
|
|
|
if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
|
|
|
|
break; /* bail out at end of list */
|
1995-05-30 08:16:23 +00:00
|
|
|
vps_p[i] = this_vp_p =
|
1994-05-24 10:09:53 +00:00
|
|
|
VOPARG_OFFSETTO(struct vnode**,descp->vdesc_vp_offsets[i],ap);
|
|
|
|
/*
|
|
|
|
* We're not guaranteed that any but the first vnode
|
|
|
|
* are of our type. Check for and don't map any
|
|
|
|
* that aren't. (We must always map first vp or vclean fails.)
|
|
|
|
*/
|
1997-04-17 11:17:30 +00:00
|
|
|
if (i && (*this_vp_p == NULLVP ||
|
2004-12-01 23:16:38 +00:00
|
|
|
(*this_vp_p)->v_op != &null_vnodeops)) {
|
1997-04-17 11:17:30 +00:00
|
|
|
old_vps[i] = NULLVP;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
|
|
|
old_vps[i] = *this_vp_p;
|
|
|
|
*(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p);
|
|
|
|
/*
|
|
|
|
* XXX - Several operations have the side effect
|
|
|
|
* of vrele'ing their vp's. We must account for
|
|
|
|
* that. (This should go away in the future.)
|
|
|
|
*/
|
2000-09-25 15:38:32 +00:00
|
|
|
if (reles & VDESC_VP0_WILLRELE)
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(*this_vp_p);
|
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call the operation on the lower layer
|
|
|
|
* with the modified argument structure.
|
|
|
|
*/
|
2000-09-25 15:38:32 +00:00
|
|
|
if (vps_p[0] && *vps_p[0])
|
2005-01-13 07:53:01 +00:00
|
|
|
error = VCALL(ap);
|
2000-09-25 15:38:32 +00:00
|
|
|
else {
|
|
|
|
printf("null_bypass: no map for %s\n", descp->vdesc_name);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Maintain the illusion of call-by-value
|
|
|
|
* by restoring vnodes in the argument structure
|
|
|
|
* to their original value.
|
|
|
|
*/
|
|
|
|
reles = descp->vdesc_flags;
|
|
|
|
for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
|
|
|
|
if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
|
|
|
|
break; /* bail out at end of list */
|
|
|
|
if (old_vps[i]) {
|
|
|
|
*(vps_p[i]) = old_vps[i];
|
2000-09-25 15:38:32 +00:00
|
|
|
#if 0
|
|
|
|
if (reles & VDESC_VP0_WILLUNLOCK)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(*(vps_p[i]), 0);
|
2000-09-25 15:38:32 +00:00
|
|
|
#endif
|
|
|
|
if (reles & VDESC_VP0_WILLRELE)
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(*(vps_p[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the possible out-going vpp
|
|
|
|
* (Assumes that the lower layer always returns
|
|
|
|
* a VREF'ed vpp unless it gets an error.)
|
|
|
|
*/
|
|
|
|
if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
|
|
|
|
!(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
|
|
|
|
!error) {
|
|
|
|
/*
|
|
|
|
* XXX - even though some ops have vpp returned vp's,
|
|
|
|
* several ops actually vrele this before returning.
|
|
|
|
* We must avoid these ops.
|
|
|
|
* (This should go away when these ops are regularized.)
|
|
|
|
*/
|
|
|
|
if (descp->vdesc_flags & VDESC_VPP_WILLRELE)
|
|
|
|
goto out;
|
|
|
|
vppp = VOPARG_OFFSETTO(struct vnode***,
|
|
|
|
descp->vdesc_vpp_offset,ap);
|
1997-09-18 18:33:23 +00:00
|
|
|
if (*vppp)
|
2002-06-13 21:49:09 +00:00
|
|
|
error = null_nodeget(old_vps[0]->v_mount, **vppp, *vppp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2012-11-02 13:56:36 +00:00
|
|
|
static int
|
|
|
|
null_add_writecount(struct vop_add_writecount_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *lvp, *vp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
lvp = NULLVPTOLOWERVP(vp);
|
|
|
|
KASSERT(vp->v_writecount + ap->a_inc >= 0, ("wrong writecount inc"));
|
|
|
|
if (vp->v_writecount > 0 && vp->v_writecount + ap->a_inc == 0)
|
|
|
|
error = VOP_ADD_WRITECOUNT(lvp, -1);
|
|
|
|
else if (vp->v_writecount == 0 && vp->v_writecount + ap->a_inc > 0)
|
|
|
|
error = VOP_ADD_WRITECOUNT(lvp, 1);
|
|
|
|
else
|
|
|
|
error = 0;
|
|
|
|
if (error == 0)
|
|
|
|
vp->v_writecount += ap->a_inc;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* We have to carry on the locking protocol on the null layer vnodes
|
|
|
|
* as we progress through the tree. We also have to enforce read-only
|
|
|
|
* if this layer is mounted read-only.
|
|
|
|
*/
|
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_lookup(struct vop_lookup_args *ap)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
2000-09-25 15:38:32 +00:00
|
|
|
struct vnode *dvp = ap->a_dvp;
|
1997-02-10 02:22:35 +00:00
|
|
|
int flags = cnp->cn_flags;
|
2000-09-25 15:38:32 +00:00
|
|
|
struct vnode *vp, *ldvp, *lvp;
|
2014-08-08 11:39:05 +00:00
|
|
|
struct mount *mp;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error;
|
|
|
|
|
2014-08-08 11:39:05 +00:00
|
|
|
mp = dvp->v_mount;
|
|
|
|
if ((flags & ISLASTCN) != 0 && (mp->mnt_flag & MNT_RDONLY) != 0 &&
|
1997-02-10 02:22:35 +00:00
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
|
|
|
|
return (EROFS);
|
2000-09-25 15:38:32 +00:00
|
|
|
/*
|
|
|
|
* Although it is possible to call null_bypass(), we'll do
|
|
|
|
* a direct call to reduce overhead
|
|
|
|
*/
|
|
|
|
ldvp = NULLVPTOLOWERVP(dvp);
|
|
|
|
vp = lvp = NULL;
|
2014-07-28 14:20:31 +00:00
|
|
|
KASSERT((ldvp->v_vflag & VV_ROOT) == 0 ||
|
|
|
|
((dvp->v_vflag & VV_ROOT) != 0 && (flags & ISDOTDOT) == 0),
|
|
|
|
("ldvp %p fl %#x dvp %p fl %#x flags %#x", ldvp, ldvp->v_vflag,
|
|
|
|
dvp, dvp->v_vflag, flags));
|
2014-08-08 11:39:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hold ldvp. The reference on it, owned by dvp, is lost in
|
|
|
|
* case of dvp reclamation, and we need ldvp to move our lock
|
|
|
|
* from ldvp to dvp.
|
|
|
|
*/
|
|
|
|
vhold(ldvp);
|
|
|
|
|
2000-09-25 15:38:32 +00:00
|
|
|
error = VOP_LOOKUP(ldvp, &lvp, cnp);
|
2014-08-08 11:39:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* VOP_LOOKUP() on lower vnode may unlock ldvp, which allows
|
|
|
|
* dvp to be reclaimed due to shared v_vnlock. Check for the
|
|
|
|
* doomed state and return error.
|
|
|
|
*/
|
|
|
|
if ((error == 0 || error == EJUSTRETURN) &&
|
|
|
|
(dvp->v_iflag & VI_DOOMED) != 0) {
|
|
|
|
error = ENOENT;
|
|
|
|
if (lvp != NULL)
|
|
|
|
vput(lvp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If vgone() did reclaimed dvp before curthread
|
|
|
|
* relocked ldvp, the locks of dvp and ldpv are no
|
|
|
|
* longer shared. In this case, relock of ldvp in
|
|
|
|
* lower fs VOP_LOOKUP() does not restore the locking
|
|
|
|
* state of dvp. Compensate for this by unlocking
|
|
|
|
* ldvp and locking dvp, which is also correct if the
|
|
|
|
* locks are still shared.
|
|
|
|
*/
|
|
|
|
VOP_UNLOCK(ldvp, 0);
|
|
|
|
vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
|
|
|
|
}
|
|
|
|
vdrop(ldvp);
|
|
|
|
|
|
|
|
if (error == EJUSTRETURN && (flags & ISLASTCN) != 0 &&
|
|
|
|
(mp->mnt_flag & MNT_RDONLY) != 0 &&
|
1997-02-10 02:22:35 +00:00
|
|
|
(cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME))
|
|
|
|
error = EROFS;
|
2000-09-25 15:38:32 +00:00
|
|
|
|
|
|
|
if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) {
|
|
|
|
if (ldvp == lvp) {
|
|
|
|
*ap->a_vpp = dvp;
|
|
|
|
VREF(dvp);
|
|
|
|
vrele(lvp);
|
|
|
|
} else {
|
2014-08-08 11:39:05 +00:00
|
|
|
error = null_nodeget(mp, lvp, &vp);
|
2012-01-03 21:09:07 +00:00
|
|
|
if (error == 0)
|
2008-11-26 13:41:15 +00:00
|
|
|
*ap->a_vpp = vp;
|
2000-09-25 15:38:32 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2005-01-24 22:56:24 +00:00
|
|
|
static int
|
|
|
|
null_open(struct vop_open_args *ap)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
struct vnode *vp, *ldvp;
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
ldvp = NULLVPTOLOWERVP(vp);
|
|
|
|
retval = null_bypass(&ap->a_gen);
|
|
|
|
if (retval == 0)
|
|
|
|
vp->v_object = ldvp->v_object;
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* Setattr call. Disallow write attempts if the layer is mounted read-only.
|
|
|
|
*/
|
2002-10-16 08:00:32 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_setattr(struct vop_setattr_args *ap)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
|
|
|
|
if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
|
1997-02-12 14:55:01 +00:00
|
|
|
vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
|
|
|
|
vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
|
1997-02-10 02:22:35 +00:00
|
|
|
(vp->v_mount->mnt_flag & MNT_RDONLY))
|
|
|
|
return (EROFS);
|
|
|
|
if (vap->va_size != VNOVAL) {
|
|
|
|
switch (vp->v_type) {
|
|
|
|
case VDIR:
|
|
|
|
return (EISDIR);
|
|
|
|
case VCHR:
|
|
|
|
case VBLK:
|
|
|
|
case VSOCK:
|
|
|
|
case VFIFO:
|
1998-06-10 06:34:57 +00:00
|
|
|
if (vap->va_flags != VNOVAL)
|
|
|
|
return (EOPNOTSUPP);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (0);
|
|
|
|
case VREG:
|
|
|
|
case VLNK:
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* Disallow write attempts if the filesystem is
|
|
|
|
* mounted read-only.
|
|
|
|
*/
|
|
|
|
if (vp->v_mount->mnt_flag & MNT_RDONLY)
|
|
|
|
return (EROFS);
|
|
|
|
}
|
|
|
|
}
|
2000-09-25 15:38:32 +00:00
|
|
|
|
1997-02-12 18:06:08 +00:00
|
|
|
return (null_bypass((struct vop_generic_args *)ap));
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We handle getattr only to change the fsid.
|
|
|
|
*/
|
1995-12-11 09:24:58 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_getattr(struct vop_getattr_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1999-01-28 00:57:57 +00:00
|
|
|
if ((error = null_bypass((struct vop_generic_args *)ap)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2000-09-05 09:02:07 +00:00
|
|
|
|
|
|
|
ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2000-09-25 15:38:32 +00:00
|
|
|
/*
|
|
|
|
* Handle to disallow write access if mounted read-only.
|
|
|
|
*/
|
1995-12-11 09:24:58 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_access(struct vop_access_args *ap)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
2008-10-28 13:44:11 +00:00
|
|
|
accmode_t accmode = ap->a_accmode;
|
1997-02-10 02:22:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Disallow write attempts on read-only layers;
|
|
|
|
* unless the file is a socket, fifo, or a block or
|
2002-05-16 21:28:32 +00:00
|
|
|
* character device resident on the filesystem.
|
1997-02-10 02:22:35 +00:00
|
|
|
*/
|
2008-10-28 13:44:11 +00:00
|
|
|
if (accmode & VWRITE) {
|
1997-02-10 02:22:35 +00:00
|
|
|
switch (vp->v_type) {
|
|
|
|
case VDIR:
|
|
|
|
case VLNK:
|
|
|
|
case VREG:
|
|
|
|
if (vp->v_mount->mnt_flag & MNT_RDONLY)
|
|
|
|
return (EROFS);
|
|
|
|
break;
|
1999-01-27 22:42:27 +00:00
|
|
|
default:
|
|
|
|
break;
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
}
|
1997-02-12 18:06:08 +00:00
|
|
|
return (null_bypass((struct vop_generic_args *)ap));
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
|
2009-05-30 13:59:05 +00:00
|
|
|
static int
|
|
|
|
null_accessx(struct vop_accessx_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
accmode_t accmode = ap->a_accmode;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disallow write attempts on read-only layers;
|
|
|
|
* unless the file is a socket, fifo, or a block or
|
|
|
|
* character device resident on the filesystem.
|
|
|
|
*/
|
|
|
|
if (accmode & VWRITE) {
|
|
|
|
switch (vp->v_type) {
|
|
|
|
case VDIR:
|
|
|
|
case VLNK:
|
|
|
|
case VREG:
|
|
|
|
if (vp->v_mount->mnt_flag & MNT_RDONLY)
|
|
|
|
return (EROFS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (null_bypass((struct vop_generic_args *)ap));
|
|
|
|
}
|
|
|
|
|
2010-08-31 01:16:45 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2015-12-30 19:49:22 +00:00
|
|
|
struct vnode *lvp, *vp;
|
2010-08-31 01:16:45 +00:00
|
|
|
|
2015-12-30 19:49:22 +00:00
|
|
|
vp = ap->a_vp;
|
|
|
|
if (vrefcnt(vp) > 1) {
|
|
|
|
lvp = NULLVPTOLOWERVP(vp);
|
2010-08-31 01:16:45 +00:00
|
|
|
VREF(lvp);
|
|
|
|
vreleit = 1;
|
|
|
|
} else
|
|
|
|
vreleit = 0;
|
2015-12-30 19:49:22 +00:00
|
|
|
VTONULL(vp)->null_flags |= NULLV_DROP;
|
2010-08-31 01:16:45 +00:00
|
|
|
retval = null_bypass(&ap->a_gen);
|
|
|
|
if (vreleit != 0)
|
|
|
|
vrele(lvp);
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
2000-09-05 09:02:07 +00:00
|
|
|
/*
|
|
|
|
* 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
|
2005-01-24 11:49:41 +00:00
|
|
|
null_rename(struct vop_rename_args *ap)
|
2000-09-05 09:02:07 +00:00
|
|
|
{
|
|
|
|
struct vnode *tdvp = ap->a_tdvp;
|
|
|
|
struct vnode *fvp = ap->a_fvp;
|
|
|
|
struct vnode *fdvp = ap->a_fdvp;
|
|
|
|
struct vnode *tvp = ap->a_tvp;
|
2013-07-04 19:01:18 +00:00
|
|
|
struct null_node *tnn;
|
2000-09-05 09:02:07 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
}
|
2013-07-04 19:01:18 +00:00
|
|
|
|
|
|
|
if (tvp != NULL) {
|
|
|
|
tnn = VTONULL(tvp);
|
|
|
|
tnn->null_flags |= NULLV_DROP;
|
|
|
|
}
|
2000-09-05 09:02:07 +00:00
|
|
|
return (null_bypass((struct vop_generic_args *)ap));
|
|
|
|
}
|
|
|
|
|
2016-02-17 19:43:03 +00:00
|
|
|
static int
|
|
|
|
null_rmdir(struct vop_rmdir_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
VTONULL(ap->a_vp)->null_flags |= NULLV_DROP;
|
|
|
|
return (null_bypass(&ap->a_gen));
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
1997-02-12 14:55:01 +00:00
|
|
|
static int
|
2007-05-18 13:02:13 +00:00
|
|
|
null_lock(struct vop_lock1_args *ap)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
2000-09-25 15:38:32 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
int flags = ap->a_flags;
|
2005-03-15 13:49:33 +00:00
|
|
|
struct null_node *nn;
|
2000-09-25 15:38:32 +00:00
|
|
|
struct vnode *lvp;
|
|
|
|
int error;
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2000-09-25 15:38:32 +00:00
|
|
|
|
2005-03-13 12:18:25 +00:00
|
|
|
if ((flags & LK_INTERLOCK) == 0) {
|
|
|
|
VI_LOCK(vp);
|
2005-03-15 13:49:33 +00:00
|
|
|
ap->a_flags = flags |= LK_INTERLOCK;
|
2005-03-13 12:18:25 +00:00
|
|
|
}
|
2005-03-15 13:49:33 +00:00
|
|
|
nn = VTONULL(vp);
|
|
|
|
/*
|
|
|
|
* If we're still active we must ask the lower layer to
|
2016-11-08 23:59:41 +00:00
|
|
|
* lock as ffs has special lock considerations in its
|
2005-03-15 13:49:33 +00:00
|
|
|
* vop lock.
|
|
|
|
*/
|
|
|
|
if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) {
|
2005-04-22 22:42:44 +00:00
|
|
|
VI_LOCK_FLAGS(lvp, MTX_DUPOK);
|
2003-06-17 08:52:45 +00:00
|
|
|
VI_UNLOCK(vp);
|
2000-09-25 15:38:32 +00:00
|
|
|
/*
|
2005-03-15 13:49:33 +00:00
|
|
|
* 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,
|
2016-11-08 23:59:41 +00:00
|
|
|
* in which case it is not legal to be sleeping in its VOP.
|
2005-03-15 13:49:33 +00:00
|
|
|
* We prevent it from being recycled by holding the vnode
|
|
|
|
* here.
|
2000-09-25 15:38:32 +00:00
|
|
|
*/
|
2005-03-15 13:49:33 +00:00
|
|
|
vholdl(lvp);
|
2008-01-13 14:44:15 +00:00
|
|
|
error = VOP_LOCK(lvp, flags);
|
2005-09-15 19:21:26 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(lvp, 0);
|
2005-09-15 19:21:26 +00:00
|
|
|
error = vop_stdlock(ap);
|
|
|
|
}
|
2005-03-15 13:49:33 +00:00
|
|
|
vdrop(lvp);
|
|
|
|
} else
|
|
|
|
error = vop_stdlock(ap);
|
|
|
|
|
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
1997-02-12 14:55:01 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_unlock(struct vop_unlock_args *ap)
|
1997-02-10 02:22:35 +00:00
|
|
|
{
|
2000-09-25 15:38:32 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
int flags = ap->a_flags;
|
2007-10-14 13:57:11 +00:00
|
|
|
int mtxlkflag = 0;
|
2005-03-15 13:49:33 +00:00
|
|
|
struct null_node *nn;
|
2000-10-03 04:25:53 +00:00
|
|
|
struct vnode *lvp;
|
2005-03-15 13:49:33 +00:00
|
|
|
int error;
|
2000-09-25 15:38:32 +00:00
|
|
|
|
2007-10-14 13:57:11 +00:00
|
|
|
if ((flags & LK_INTERLOCK) != 0)
|
|
|
|
mtxlkflag = 1;
|
|
|
|
else if (mtx_owned(VI_MTX(vp)) == 0) {
|
|
|
|
VI_LOCK(vp);
|
|
|
|
mtxlkflag = 2;
|
2000-09-25 15:38:32 +00:00
|
|
|
}
|
2005-03-15 13:49:33 +00:00
|
|
|
nn = VTONULL(vp);
|
2007-10-14 13:57:11 +00:00
|
|
|
if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) {
|
|
|
|
VI_LOCK_FLAGS(lvp, MTX_DUPOK);
|
|
|
|
flags |= LK_INTERLOCK;
|
|
|
|
vholdl(lvp);
|
|
|
|
VI_UNLOCK(vp);
|
2008-01-13 14:44:15 +00:00
|
|
|
error = VOP_UNLOCK(lvp, flags);
|
2007-10-14 13:57:11 +00:00
|
|
|
vdrop(lvp);
|
|
|
|
if (mtxlkflag == 0)
|
|
|
|
VI_LOCK(vp);
|
|
|
|
} else {
|
|
|
|
if (mtxlkflag == 2)
|
|
|
|
VI_UNLOCK(vp);
|
2005-03-15 13:49:33 +00:00
|
|
|
error = vop_stdunlock(ap);
|
2007-10-14 13:57:11 +00:00
|
|
|
}
|
2005-03-15 13:49:33 +00:00
|
|
|
|
|
|
|
return (error);
|
2000-09-25 15:38:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-10-14 18:13:33 +00:00
|
|
|
* 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.
|
2000-09-25 15:38:32 +00:00
|
|
|
*/
|
1997-02-12 14:55:01 +00:00
|
|
|
static int
|
Allow shared lookups for nullfs mounts, if lower filesystem supports
it. There are two problems which shall be addressed for shared
lookups use to have measurable effect on nullfs scalability:
1. When vfs_lookup() calls VOP_LOOKUP() for nullfs, which passes lookup
operation to lower fs, resulting vnode is often only shared-locked. Then
null_nodeget() cannot instantiate covering vnode for lower vnode, since
insmntque1() and null_hashins() require exclusive lock on the lower.
Change the assert that lower vnode is exclusively locked to only
require any lock. If null hash failed to find pre-existing nullfs
vnode for lower vnode and the vnode is shared-locked, the lower vnode
lock is upgraded.
2. Nullfs reclaims its vnodes on deactivation. This is due to nullfs
inability to detect reclamation of the lower vnode. Reclamation of a
nullfs vnode at deactivation time prevents a reference to the lower
vnode to become stale.
Change nullfs VOP_INACTIVE to not reclaim the vnode, instead use the
VFS_RECLAIM_LOWERVP to get notification and reclaim upper vnode
together with the reclamation of the lower vnode.
Note that nullfs reclamation procedure calls vput() on the lowervp
vnode, temporary unlocking the vnode being reclaimed. This seems to be
fine for MPSAFE filesystems, but not-MPSAFE code often put partially
initialized vnode on some globally visible list, and later can decide
that half-constructed vnode is not needed. If nullfs mount is created
above such filesystem, then other threads might catch such not
properly initialized vnode. Instead of trying to overcome this case,
e.g. by recursing the lower vnode lock in null_reclaim_lowervp(), I
decided to rely on nearby removal of the support for non-MPSAFE
filesystems.
In collaboration with: pho
MFC after: 3 weeks
2012-09-09 19:20:23 +00:00
|
|
|
null_inactive(struct vop_inactive_args *ap __unused)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2013-05-11 11:17:44 +00:00
|
|
|
struct vnode *vp, *lvp;
|
|
|
|
struct null_node *xp;
|
2013-01-03 19:17:57 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct null_mount *xmp;
|
2002-06-13 17:30:40 +00:00
|
|
|
|
2013-01-03 19:17:57 +00:00
|
|
|
vp = ap->a_vp;
|
2013-05-11 11:17:44 +00:00
|
|
|
xp = VTONULL(vp);
|
|
|
|
lvp = NULLVPTOLOWERVP(vp);
|
2013-01-03 19:17:57 +00:00
|
|
|
mp = vp->v_mount;
|
|
|
|
xmp = MOUNTTONULLMOUNT(mp);
|
2013-05-11 11:17:44 +00:00
|
|
|
if ((xmp->nullm_flags & NULLM_CACHE) == 0 ||
|
|
|
|
(xp->null_flags & NULLV_DROP) != 0 ||
|
|
|
|
(lvp->v_vflag & VV_NOSYNC) != 0) {
|
2013-01-03 19:17:57 +00:00
|
|
|
/*
|
|
|
|
* If this is the last reference and caching of the
|
2013-05-11 11:17:44 +00:00
|
|
|
* 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.
|
2013-01-03 19:17:57 +00:00
|
|
|
*/
|
|
|
|
vp->v_object = NULL;
|
|
|
|
vrecycle(vp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2000-09-25 15:38:32 +00:00
|
|
|
/*
|
Allow shared lookups for nullfs mounts, if lower filesystem supports
it. There are two problems which shall be addressed for shared
lookups use to have measurable effect on nullfs scalability:
1. When vfs_lookup() calls VOP_LOOKUP() for nullfs, which passes lookup
operation to lower fs, resulting vnode is often only shared-locked. Then
null_nodeget() cannot instantiate covering vnode for lower vnode, since
insmntque1() and null_hashins() require exclusive lock on the lower.
Change the assert that lower vnode is exclusively locked to only
require any lock. If null hash failed to find pre-existing nullfs
vnode for lower vnode and the vnode is shared-locked, the lower vnode
lock is upgraded.
2. Nullfs reclaims its vnodes on deactivation. This is due to nullfs
inability to detect reclamation of the lower vnode. Reclamation of a
nullfs vnode at deactivation time prevents a reference to the lower
vnode to become stale.
Change nullfs VOP_INACTIVE to not reclaim the vnode, instead use the
VFS_RECLAIM_LOWERVP to get notification and reclaim upper vnode
together with the reclamation of the lower vnode.
Note that nullfs reclamation procedure calls vput() on the lowervp
vnode, temporary unlocking the vnode being reclaimed. This seems to be
fine for MPSAFE filesystems, but not-MPSAFE code often put partially
initialized vnode on some globally visible list, and later can decide
that half-constructed vnode is not needed. If nullfs mount is created
above such filesystem, then other threads might catch such not
properly initialized vnode. Instead of trying to overcome this case,
e.g. by recursing the lower vnode lock in null_reclaim_lowervp(), I
decided to rely on nearby removal of the support for non-MPSAFE
filesystems.
In collaboration with: pho
MFC after: 3 weeks
2012-09-09 19:20:23 +00:00
|
|
|
* Now, the nullfs vnode and, due to the sharing lock, the lower
|
|
|
|
* vnode, are exclusively locked, and we shall destroy the null vnode.
|
2000-09-25 15:38:32 +00:00
|
|
|
*/
|
1995-12-11 09:24:58 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_reclaim(struct vop_reclaim_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2012-02-29 15:15:36 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct null_node *xp;
|
|
|
|
struct vnode *lowervp;
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
xp = VTONULL(vp);
|
|
|
|
lowervp = xp->null_lowervp;
|
|
|
|
|
|
|
|
KASSERT(lowervp != NULL && vp->v_vnlock != &vp->v_lock,
|
2014-07-24 23:14:03 +00:00
|
|
|
("Reclaiming incomplete null vnode %p", vp));
|
2002-03-18 05:39:04 +00:00
|
|
|
|
2012-02-29 15:15:36 +00:00
|
|
|
null_hashrem(xp);
|
2005-03-17 12:00:05 +00:00
|
|
|
/*
|
|
|
|
* Use the interlock to protect the clearing of v_data to
|
|
|
|
* prevent faults in null_lock().
|
|
|
|
*/
|
2009-05-31 14:52:45 +00:00
|
|
|
lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL);
|
2005-03-17 12:00:05 +00:00
|
|
|
VI_LOCK(vp);
|
|
|
|
vp->v_data = NULL;
|
2006-02-22 06:17:31 +00:00
|
|
|
vp->v_object = NULL;
|
2005-09-15 19:21:26 +00:00
|
|
|
vp->v_vnlock = &vp->v_lock;
|
2009-05-31 14:52:45 +00:00
|
|
|
VI_UNLOCK(vp);
|
2013-01-10 18:24:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we were opened for write, we leased one write reference
|
|
|
|
* to the lower vnode. If this is a reclamation due to the
|
|
|
|
* forced unmount, undo the reference now.
|
|
|
|
*/
|
|
|
|
if (vp->v_writecount > 0)
|
|
|
|
VOP_ADD_WRITECOUNT(lowervp, -1);
|
2013-05-11 11:17:44 +00:00
|
|
|
if ((xp->null_flags & NULLV_NOUNLOCK) != 0)
|
|
|
|
vunref(lowervp);
|
|
|
|
else
|
|
|
|
vput(lowervp);
|
2008-10-23 15:53:51 +00:00
|
|
|
free(xp, M_NULLFSNODE);
|
2000-09-25 15:38:32 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1995-12-11 09:24:58 +00:00
|
|
|
static int
|
2005-01-24 11:49:41 +00:00
|
|
|
null_print(struct vop_print_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-01-24 12:37:51 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
2006-02-22 06:17:31 +00:00
|
|
|
|
2011-11-19 07:41:37 +00:00
|
|
|
printf("\tvp=%p, lowervp=%p\n", vp, VTONULL(vp)->null_lowervp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2006-03-12 04:58:18 +00:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
2007-02-15 22:08:35 +00:00
|
|
|
static int
|
|
|
|
null_vptofh(struct vop_vptofh_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *lvp;
|
|
|
|
|
|
|
|
lvp = NULLVPTOLOWERVP(ap->a_vp);
|
|
|
|
return VOP_VPTOFH(lvp, ap->a_fhp);
|
|
|
|
}
|
|
|
|
|
2009-05-31 14:58:43 +00:00
|
|
|
static int
|
|
|
|
null_vptocnp(struct vop_vptocnp_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vnode **dvp = ap->a_vpp;
|
|
|
|
struct vnode *lvp, *ldvp;
|
2009-06-21 19:21:01 +00:00
|
|
|
struct ucred *cred = ap->a_cred;
|
2009-05-31 14:58:43 +00:00
|
|
|
int error, locked;
|
|
|
|
|
|
|
|
locked = VOP_ISLOCKED(vp);
|
|
|
|
lvp = NULLVPTOLOWERVP(vp);
|
|
|
|
vhold(lvp);
|
|
|
|
VOP_UNLOCK(vp, 0); /* vp is held by vn_vptocnp_locked that called us */
|
|
|
|
ldvp = lvp;
|
2011-11-19 07:50:49 +00:00
|
|
|
vref(lvp);
|
2009-06-21 19:21:01 +00:00
|
|
|
error = vn_vptocnp(&ldvp, cred, ap->a_buf, ap->a_buflen);
|
2009-05-31 14:58:43 +00:00
|
|
|
vdrop(lvp);
|
|
|
|
if (error != 0) {
|
|
|
|
vn_lock(vp, locked | LK_RETRY);
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Exclusive lock is required by insmntque1 call in
|
|
|
|
* null_nodeget()
|
|
|
|
*/
|
|
|
|
error = vn_lock(ldvp, LK_EXCLUSIVE);
|
|
|
|
if (error != 0) {
|
2011-11-19 07:50:49 +00:00
|
|
|
vrele(ldvp);
|
2009-05-31 14:58:43 +00:00
|
|
|
vn_lock(vp, locked | LK_RETRY);
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
error = null_nodeget(vp->v_mount, ldvp, dvp);
|
|
|
|
if (error == 0) {
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
NULLVPTOLOWERVP(*dvp);
|
|
|
|
#endif
|
2011-11-19 07:50:49 +00:00
|
|
|
VOP_UNLOCK(*dvp, 0); /* keep reference on *dvp */
|
2012-01-03 21:09:07 +00:00
|
|
|
}
|
2009-05-31 14:58:43 +00:00
|
|
|
vn_lock(vp, locked | LK_RETRY);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Global vfs data structures
|
|
|
|
*/
|
2004-12-01 23:16:38 +00:00
|
|
|
struct vop_vector null_vnodeops = {
|
|
|
|
.vop_bypass = null_bypass,
|
|
|
|
.vop_access = null_access,
|
2009-05-30 13:59:05 +00:00
|
|
|
.vop_accessx = null_accessx,
|
2010-05-16 05:00:29 +00:00
|
|
|
.vop_advlockpurge = vop_stdadvlockpurge,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_bmap = VOP_EOPNOTSUPP,
|
|
|
|
.vop_getattr = null_getattr,
|
2006-03-12 04:58:18 +00:00
|
|
|
.vop_getwritemount = null_getwritemount,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_inactive = null_inactive,
|
2009-03-18 13:54:35 +00:00
|
|
|
.vop_islocked = vop_stdislocked,
|
2007-05-18 13:02:13 +00:00
|
|
|
.vop_lock1 = null_lock,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_lookup = null_lookup,
|
2005-01-24 22:56:24 +00:00
|
|
|
.vop_open = null_open,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_print = null_print,
|
|
|
|
.vop_reclaim = null_reclaim,
|
2010-08-31 01:16:45 +00:00
|
|
|
.vop_remove = null_remove,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_rename = null_rename,
|
2016-02-17 19:43:03 +00:00
|
|
|
.vop_rmdir = null_rmdir,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_setattr = null_setattr,
|
|
|
|
.vop_strategy = VOP_EOPNOTSUPP,
|
|
|
|
.vop_unlock = null_unlock,
|
2009-05-31 14:58:43 +00:00
|
|
|
.vop_vptocnp = null_vptocnp,
|
2007-02-15 22:08:35 +00:00
|
|
|
.vop_vptofh = null_vptofh,
|
2012-11-02 13:56:36 +00:00
|
|
|
.vop_add_writecount = null_add_writecount,
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|