Hi,
For explanatation/discussion please see related post in [EMAIL PROTECTED]
Patch from signature till bottom.
Csaba
# HG changeset patch
# User csaba@
# Node ID 6db92777ea99902079b1f31fe330b0a5aac96d88
# Parent 820a1f1d791e95af17294ccd87e5f76dbc1be68c
imported patch cachecoh
diff -r 820a1f1d791e -r 6db92777ea99 sys/emulation/linux/linux_stats.c
--- a/sys/emulation/linux/linux_stats.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/emulation/linux/linux_stats.c Mon Jan 23 05:16:56 2006 +0100
@@ -250,8 +250,8 @@ linux_statfs(struct linux_statfs_args *a
if (error == 0)
error = kern_statfs(&nd, &statfs);
if (error == 0) {
- if (nd.nl_ncp->nc_vp != NULL)
- error = vn_get_namelen(nd.nl_ncp->nc_vp, &namelen);
+ if (cache_grphead_l(nd.nl_ncp)->nc_vp != NULL)
+ error =
vn_get_namelen(cache_grphead_l(nd.nl_ncp)->nc_vp, &namelen);
else
error = EINVAL;
}
diff -r 820a1f1d791e -r 6db92777ea99 sys/emulation/svr4/svr4_misc.c
--- a/sys/emulation/svr4/svr4_misc.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/emulation/svr4/svr4_misc.c Mon Jan 23 05:16:56 2006 +0100
@@ -1395,8 +1395,8 @@ svr4_sys_statvfs(struct svr4_sys_statvfs
if (error == 0)
error = kern_statfs(&nd, &bfs);
if (error == 0) {
- if (nd.nl_ncp->nc_vp != NULL)
- error = vn_get_namelen(nd.nl_ncp->nc_vp, &namelen);
+ if (cache_grphead_l(nd.nl_ncp)->nc_vp != NULL)
+ error =
vn_get_namelen(cache_grphead_l(nd.nl_ncp)->nc_vp, &namelen);
else
error = EINVAL;
}
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/uipc_usrreq.c
--- a/sys/kern/uipc_usrreq.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/uipc_usrreq.c Mon Jan 23 05:16:56 2006 +0100
@@ -600,7 +600,7 @@ unp_bind(struct unpcb *unp, struct socka
error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_LOCKVP|NLC_CREATE);
if (error == 0)
error = nlookup(&nd);
- if (error == 0 && nd.nl_ncp->nc_vp != NULL)
+ if (error == 0 && cache_grphead_l(nd.nl_ncp)->nc_vp != NULL)
error = EADDRINUSE;
if (error)
goto done;
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_cache.c
--- a/sys/kern/vfs_cache.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_cache.c Mon Jan 23 05:16:56 2006 +0100
@@ -198,6 +198,25 @@ SYSCTL_PROC(_vfs_cache, OID_AUTO, nchsta
static void cache_zap(struct namecache *ncp);
+static __inline
+struct namecache *
+_cache_grphead_l(struct namecache *ncp)
+{
+#ifdef INVARIANTS
+ struct namecache *startncp = ncp;
+#endif
+
+ while (ncp->nc_shadowed) {
+ ncp = ncp->nc_shadowed;
+ KKASSERT(startncp != ncp);
+ KKASSERT(ncp->nc_refs > 0);
+ }
+
+ KKASSERT(ncp->nc_exlocks > 0);
+ KKASSERT(ncp->nc_locktd == curthread);
+ return(ncp);
+}
+
/*
* cache_hold() and cache_drop() prevent the premature deletion of a
* namecache entry but do not prevent operations (such as zapping) on
@@ -222,15 +241,60 @@ _cache_drop(struct namecache *ncp)
{
KKASSERT(ncp->nc_refs > 0);
if (ncp->nc_refs == 1 &&
- (ncp->nc_flag & NCF_UNRESOLVED) &&
+ (ncp->nc_flag & NCF_UNRESOLVED || ncp->nc_shadowed) &&
TAILQ_EMPTY(&ncp->nc_list)
) {
- KKASSERT(ncp->nc_exlocks == 0);
cache_lock(ncp);
- cache_zap(ncp);
- } else {
+ KKASSERT(_cache_grphead_l(ncp)->nc_exlocks == 1);
+ if (_cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) {
+ cache_zap(ncp);
+ return;
+ }
+ cache_unlock(ncp);
+ }
+ --ncp->nc_refs;
+}
+
+static __inline
+struct namecache *
+_cache_grphead(struct namecache *ncp)
+{
+ if (ncp->nc_shadowed) {
+ /*
+ * We need a ref to please the locking routine, but
+ * we get rid of that ASAP. Doing that directly saves
+ * us from a lot of headache (and some CPU cycles).
+ */
+ cache_get(ncp);
--ncp->nc_refs;
- }
+ ncp = _cache_grphead_l(ncp);
+ cache_unlock(ncp);
+ }
+
+ return(ncp);
+}
+
+/*
+ * Get the head of the shadow group when it's known to be locked.
+ *
+ * (XXX We need this routine in the API only if recursive locking
+ * is considered bad. The additional costs of the general grphead
+ * routine seem to be negligible, especially for "normal"
+ * (nc_shadowless) namecache entries.)
+ */
+struct namecache *
+cache_grphead_l(struct namecache *ncp)
+{
+ return(_cache_grphead_l(ncp));
+}
+
+/*
+ * Get the head of the shadow group.
+ */
+struct namecache *
+cache_grphead(struct namecache *ncp)
+{
+ return(_cache_grphead(ncp));
}
/*
@@ -324,6 +388,9 @@ cache_drop(struct namecache *ncp)
_cache_drop(ncp);
}
+static void cache_lock_one(struct namecache *ncp);
+static void cache_unlock_one(struct namecache *ncp);
+
/*
* Namespace locking. The caller must already hold a reference to the
* namecache structure in order to lock/unlock it. This function prevents
@@ -346,6 +413,29 @@ cache_drop(struct namecache *ncp)
*/
void
cache_lock(struct namecache *ncp)
+{
+ struct namecache *oncp;
+#ifdef INVARIANTS
+ struct namecache *startncp = ncp;
+#endif
+
+ for (;;) {
+ cache_lock_one(ncp);
+ oncp = ncp;
+ if (! (ncp = ncp->nc_shadowed))
+ break;
+ KKASSERT(ncp != startncp);
+ /*
+ * The individual lock was used just to protect the transition.
+ * Now that we safely know who's next, unlock the entry
+ * and move on.
+ */
+ cache_unlock_one(oncp);
+ }
+}
+
+static void
+cache_lock_one(struct namecache *ncp)
{
thread_t td;
int didwarn;
@@ -398,12 +488,27 @@ cache_lock_nonblock(struct namecache *nc
cache_lock_nonblock(struct namecache *ncp)
{
thread_t td;
-
+ struct namecache *oncp;
+#ifdef INVARIANTS
+ struct namecache *startncp = ncp;
+#endif
+
+ td = curthread;
+
+step_one:
KKASSERT(ncp->nc_refs != 0);
- td = curthread;
if (ncp->nc_exlocks == 0) {
ncp->nc_exlocks = 1;
ncp->nc_locktd = td;
+
+ if (ncp->nc_shadowed) {
+ oncp = ncp;
+ ncp = ncp->nc_shadowed;
+ KKASSERT(startncp != ncp);
+ cache_unlock_one(oncp);
+ goto step_one;
+ }
+
/*
* The vp associated with a locked ncp must be held
* to prevent it from being recycled (which would
@@ -422,6 +527,12 @@ void
void
cache_unlock(struct namecache *ncp)
{
+ cache_unlock_one(_cache_grphead_l(ncp));
+}
+
+static void
+cache_unlock_one(struct namecache *ncp)
+{
thread_t td = curthread;
KKASSERT(ncp->nc_refs > 0);
@@ -452,13 +563,17 @@ int
int
cache_get_nonblock(struct namecache *ncp)
{
+ int error;
+
/* XXX MP */
- if (ncp->nc_exlocks == 0 || ncp->nc_locktd == curthread) {
- _cache_hold(ncp);
- cache_lock(ncp);
- return(0);
- }
- return(EWOULDBLOCK);
+ _cache_hold(ncp);
+ /*
+ * We can't test easily whether locking would block
+ * so we just make a try to get the lock.
+ */
+ if ((error = cache_lock_nonblock(ncp)))
+ _cache_drop(ncp);
+ return(error);
}
void
@@ -469,6 +584,61 @@ cache_put(struct namecache *ncp)
}
/*
+ * Join ncp into the shadow group of sncp.
+ *
+ * Both entries must be locked on entry. Caller also has to hold a dedicated
+ * reference of sncp.
+ *
+ * The routine will fail and return ELOOP if the intended shadowing association
+ * yielded a loop in the shadow chain.
+ *
+ * - On success ncp will be a representative of the joint shadow group, which
+ * then will be locked.
+ * - On failure the namecache entries will exist separately just as they did
+ * before, in the same state.
+ */
+int
+cache_shadow_attach(struct namecache *ncp, struct namecache *sncp)
+{
+ KKASSERT(! ncp->nc_shadowed);
+ KKASSERT(! ncp->nc_vp);
+ KKASSERT(ncp->nc_flag & NCF_UNRESOLVED);
+
+ if (_cache_grphead_l(sncp) == ncp) {
+ /* ncp->nc_error = ELOOP; */
+ return(ELOOP);
+ }
+
+ ncp->nc_shadowed = sncp;
+ cache_unlock_one(ncp);
+ return(0);
+}
+
+/*
+ * Take out namecache entry from its shadow group.
+ *
+ * ncp must really shadow someone, and the shadow group must be locked
+ * upon entry.
+ *
+ * After the routine returns, ncp will be the head of a new (possibly
singleton)
+ * shadow group. The routine returns the former successor of ncp in the
original
+ * shadow group in a locked+ref'd state.
+ */
+struct namecache *
+cache_shadow_detach(struct namecache *ncp)
+{
+ struct namecache *sncp = ncp->nc_shadowed;
+
+ KKASSERT(sncp);
+
+ cache_lock_one(ncp);
+ ncp->nc_shadowed = NULL;
+ cache_setunresolved(ncp);
+
+ return(sncp);
+}
+
+/*
* Resolve an unresolved ncp by associating a vnode with it. If the
* vnode is NULL, a negative cache entry is created.
*
@@ -477,6 +647,8 @@ void
void
cache_setvp(struct namecache *ncp, struct vnode *vp)
{
+ ncp = _cache_grphead_l(ncp);
+
KKASSERT(ncp->nc_flag & NCF_UNRESOLVED);
ncp->nc_vp = vp;
if (vp != NULL) {
@@ -517,6 +689,8 @@ void
void
cache_settimeout(struct namecache *ncp, int nticks)
{
+ ncp = _cache_grphead_l(ncp);
+
if ((ncp->nc_timeout = ticks + nticks) == 0)
ncp->nc_timeout = 1;
}
@@ -542,6 +716,8 @@ cache_setunresolved(struct namecache *nc
cache_setunresolved(struct namecache *ncp)
{
struct vnode *vp;
+
+ ncp = _cache_grphead_l(ncp);
if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
ncp->nc_flag |= NCF_UNRESOLVED;
@@ -619,11 +795,11 @@ cache_inval(struct namecache *ncp, int f
struct namecache *nextkid;
int rcnt = 0;
- KKASSERT(ncp->nc_exlocks);
+ KKASSERT(_cache_grphead_l(ncp)->nc_exlocks);
cache_setunresolved(ncp);
if (flags & CINV_DESTROY)
- ncp->nc_flag |= NCF_DESTROYED;
+ _cache_grphead_l(ncp)->nc_flag |= NCF_DESTROYED;
if ((flags & CINV_CHILDREN) &&
(kid = TAILQ_FIRST(&ncp->nc_list)) != NULL
@@ -634,7 +810,8 @@ cache_inval(struct namecache *ncp, int f
if ((nextkid = TAILQ_NEXT(kid, nc_entry)) != NULL)
cache_hold(nextkid);
if ((kid->nc_flag & NCF_UNRESOLVED) == 0 ||
- TAILQ_FIRST(&kid->nc_list)
+ TAILQ_FIRST(&kid->nc_list) ||
+ kid->nc_shadowed
) {
cache_lock(kid);
rcnt += cache_inval(kid, flags & ~CINV_DESTROY);
@@ -650,7 +827,7 @@ cache_inval(struct namecache *ncp, int f
* Someone could have gotten in there while ncp was unlocked,
* retry if so.
*/
- if ((ncp->nc_flag & NCF_UNRESOLVED) == 0)
+ if ((_cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) == 0)
++rcnt;
return (rcnt);
}
@@ -774,6 +951,8 @@ cache_vget(struct namecache *ncp, struct
struct vnode *vp;
int error;
+ ncp = _cache_grphead(ncp);
+
again:
vp = NULL;
if (ncp->nc_flag & NCF_UNRESOLVED) {
@@ -805,6 +984,8 @@ cache_vref(struct namecache *ncp, struct
{
struct vnode *vp;
int error;
+
+ ncp = _cache_grphead(ncp);
again:
vp = NULL;
@@ -1121,9 +1302,10 @@ again:
goto again;
}
if (rncp) {
+ struct namecache *srncp = _cache_grphead_l(rncp);
vrele(pvp);
- if (rncp->nc_flag & NCF_UNRESOLVED) {
- cache_setvp(rncp, dvp);
+ if (srncp->nc_flag & NCF_UNRESOLVED) {
+ cache_setvp(srncp, dvp);
if (ncvp_debug >= 2) {
printf("cache_inefficient_scan: setvp %s/%s =
%p\n",
ncp->nc_name, rncp->nc_name, dvp);
@@ -1132,11 +1314,11 @@ again:
if (ncvp_debug >= 2) {
printf("cache_inefficient_scan: setvp %s/%s
already set %p/%p\n",
ncp->nc_name, rncp->nc_name, dvp,
- rncp->nc_vp);
+ srncp->nc_vp);
}
}
- if (rncp->nc_vp == NULL)
- error = rncp->nc_error;
+ if (srncp->nc_vp == NULL)
+ error = srncp->nc_error;
cache_put(rncp);
} else {
printf("cache_inefficient_scan: dvp %p NOT FOUND in %s\n",
@@ -1179,7 +1361,7 @@ cache_zap(struct namecache *ncp)
* We only scrap unref'd (other then our ref) unresolved entries,
* we do not scrap 'live' entries.
*/
- while (ncp->nc_flag & NCF_UNRESOLVED) {
+ while (_cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) {
/*
* Someone other then us has a ref, stop.
*/
@@ -1206,6 +1388,9 @@ cache_zap(struct namecache *ncp)
if (par->nc_vp && TAILQ_EMPTY(&par->nc_list))
vdrop(par->nc_vp);
}
+
+ if (ncp->nc_shadowed)
+ cache_put(cache_shadow_detach(ncp));
/*
* ncp should not have picked up any refs. Physically
@@ -1303,6 +1488,7 @@ cache_nlookup(struct namecache *par, str
cache_nlookup(struct namecache *par, struct nlcomponent *nlc)
{
struct namecache *ncp;
+ struct namecache *sncp;
struct namecache *new_ncp;
struct nchashhead *nchpp;
u_int32_t hash;
@@ -1319,15 +1505,16 @@ cache_nlookup(struct namecache *par, str
new_ncp = NULL;
restart:
LIST_FOREACH(ncp, (NCHHASH(hash)), nc_hash) {
+ sncp = _cache_grphead(ncp);
numchecks++;
/*
* Zap entries that have timed out.
*/
- if (ncp->nc_timeout &&
- (int)(ncp->nc_timeout - ticks) < 0 &&
- (ncp->nc_flag & NCF_UNRESOLVED) == 0 &&
- ncp->nc_exlocks == 0
+ if (sncp->nc_timeout &&
+ (int)(sncp->nc_timeout - ticks) < 0 &&
+ (sncp->nc_flag & NCF_UNRESOLVED) == 0 &&
+ sncp->nc_exlocks == 0
) {
cache_zap(cache_get(ncp));
goto restart;
@@ -1341,7 +1528,7 @@ restart:
if (ncp->nc_parent == par &&
ncp->nc_nlen == nlc->nlc_namelen &&
bcmp(ncp->nc_name, nlc->nlc_nameptr, ncp->nc_nlen) == 0 &&
- (ncp->nc_flag & NCF_DESTROYED) == 0
+ (sncp->nc_flag & NCF_DESTROYED) == 0
) {
if (cache_get_nonblock(ncp) == 0) {
if (new_ncp)
@@ -1414,15 +1601,15 @@ int
int
cache_resolve(struct namecache *ncp, struct ucred *cred)
{
- struct namecache *par;
+ struct namecache *par, *sncp;
int error;
restart:
/*
* If the ncp is already resolved we have nothing to do.
*/
- if ((ncp->nc_flag & NCF_UNRESOLVED) == 0)
- return (ncp->nc_error);
+ if ((_cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) == 0)
+ return (_cache_grphead_l(ncp)->nc_error);
/*
* Mount points need special handling because the parent does not
@@ -1461,17 +1648,20 @@ restart:
* not occur all that often, or if it does not have to go back too
* many nodes to resolve the ncp.
*/
- while (ncp->nc_parent->nc_vp == NULL) {
+ while (_cache_grphead(ncp->nc_parent)->nc_vp == NULL) {
+ struct namecache *spar;
+
/*
* This case can occur if a process is CD'd into a
* directory which is then rmdir'd. If the parent is marked
* destroyed there is no point trying to resolve it.
*/
- if (ncp->nc_parent->nc_flag & NCF_DESTROYED)
+ if (_cache_grphead(ncp->nc_parent)->nc_flag & NCF_DESTROYED)
return(ENOENT);
par = ncp->nc_parent;
- while (par->nc_parent && par->nc_parent->nc_vp == NULL)
+ while (par->nc_parent &&
+ _cache_grphead(par->nc_parent)->nc_vp == NULL)
par = par->nc_parent;
if (par->nc_parent == NULL) {
printf("EXDEV case 2 %*.*s\n",
@@ -1488,20 +1678,23 @@ restart:
* will handle any moves.
*/
cache_get(par);
+ spar = _cache_grphead_l(par);
if (par->nc_flag & NCF_MOUNTPT) {
cache_resolve_mp(par);
- } else if (par->nc_parent->nc_vp == NULL) {
+ } else if (_cache_grphead(par->nc_parent)->nc_vp == NULL) {
printf("[diagnostic] cache_resolve: raced on %*.*s\n",
par->nc_nlen, par->nc_nlen, par->nc_name);
cache_put(par);
continue;
- } else if (par->nc_flag & NCF_UNRESOLVED) {
- par->nc_error = VOP_NRESOLVE(par, cred);
- }
- if ((error = par->nc_error) != 0) {
- if (par->nc_error != EAGAIN) {
+ } else if (spar->nc_flag & NCF_UNRESOLVED) {
+ error = VOP_NRESOLVE(par, cred);
+ spar = _cache_grphead_l(par);
+ spar->nc_error = error;
+ }
+ if ((error = spar->nc_error) != 0) {
+ if (spar->nc_error != EAGAIN) {
printf("EXDEV case 3 %*.*s error %d\n",
par->nc_nlen, par->nc_nlen, par->nc_name,
- par->nc_error);
+ spar->nc_error);
cache_put(par);
return(error);
}
@@ -1521,14 +1714,16 @@ restart:
* ncp must already be resolved.
*/
KKASSERT((ncp->nc_flag & NCF_MOUNTPT) == 0);
- ncp->nc_error = VOP_NRESOLVE(ncp, cred);
- /*vop_nresolve(*ncp->nc_parent->nc_vp->v_ops, ncp, cred);*/
- if (ncp->nc_error == EAGAIN) {
+ error = VOP_NRESOLVE(ncp, cred);
+ sncp = _cache_grphead_l(ncp);
+ sncp->nc_error = error;
+ /*vop_nresolve(*_cache_grphead_unlokced(ncp->nc_parent)->nc_vp->v_ops,
ncp, cred);*/
+ if (error == EAGAIN) {
printf("[diagnostic] cache_resolve: EAGAIN ncp %p %*.*s\n",
ncp, ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name);
goto restart;
}
- return(ncp->nc_error);
+ return(error);
}
/*
@@ -1549,6 +1744,8 @@ cache_resolve_mp(struct namecache *ncp)
struct vnode *vp;
struct mount *mp = ncp->nc_mount;
int error;
+
+ ncp = _cache_grphead_l(ncp);
KKASSERT(mp != NULL);
if (ncp->nc_flag & NCF_UNRESOLVED) {
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_default.c
--- a/sys/kern/vfs_default.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_default.c Mon Jan 23 05:16:56 2006 +0100
@@ -203,7 +203,7 @@ vop_compat_nresolve(struct vop_nresolve_
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
/*
@@ -234,7 +234,7 @@ vop_compat_nresolve(struct vop_nresolve_
VOP_UNLOCK(vp, 0, curthread);
if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
VOP_UNLOCK(dvp, 0, curthread);
- if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
+ if ((cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) == 0) {
/* was resolved by another process while we were unlocked */
if (error == 0)
vrele(vp);
@@ -245,7 +245,7 @@ vop_compat_nresolve(struct vop_nresolve_
} else if (error == ENOENT) {
KKASSERT(vp == NULL);
if (cnp.cn_flags & CNP_ISWHITEOUT)
- ncp->nc_flag |= NCF_WHITEOUT;
+ cache_grphead_l(ncp)->nc_flag |= NCF_WHITEOUT;
cache_setvp(ncp, NULL);
}
vrele(dvp);
@@ -338,7 +338,7 @@ vop_compat_ncreate(struct vop_ncreate_ar
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -421,7 +421,7 @@ vop_compat_nmkdir(struct vop_nmkdir_args
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -504,7 +504,7 @@ vop_compat_nmknod(struct vop_nmknod_args
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -586,7 +586,7 @@ vop_compat_nlink(struct vop_nlink_args *
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -660,7 +660,7 @@ vop_compat_nsymlink(struct vop_nsymlink_
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -746,7 +746,7 @@ vop_compat_nwhiteout(struct vop_nwhiteou
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -836,7 +836,7 @@ vop_compat_nremove(struct vop_nremove_ar
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -912,7 +912,7 @@ vop_compat_nrmdir(struct vop_nrmdir_args
return(EPERM);
if (ncp->nc_parent == NULL)
return(EPERM);
- if ((dvp = ncp->nc_parent->nc_vp) == NULL)
+ if ((dvp = cache_grphead(ncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
if ((error = vget(dvp, LK_EXCLUSIVE, td)) != 0) {
@@ -1005,7 +1005,7 @@ vop_compat_nrename(struct vop_nrename_ar
return(EPERM);
if (fncp->nc_parent == NULL)
return(EPERM);
- if ((fdvp = fncp->nc_parent->nc_vp) == NULL)
+ if ((fdvp = cache_grphead(fncp->nc_parent)->nc_vp) == NULL)
return(EPERM);
/*
@@ -1064,7 +1064,7 @@ vop_compat_nrename(struct vop_nrename_ar
error = EPERM;
if (tncp->nc_parent == NULL)
error = EPERM;
- if ((tdvp = tncp->nc_parent->nc_vp) == NULL)
+ if ((tdvp = cache_grphead(tncp->nc_parent)->nc_vp) == NULL)
error = EPERM;
if (error) {
vrele(fdvp);
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_journal.c
--- a/sys/kern/vfs_journal.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_journal.c Mon Jan 23 05:16:56 2006 +0100
@@ -1824,7 +1824,7 @@ jrecord_write_vnode_ref(struct jrecord *
struct namecache *ncp;
TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) {
- if ((ncp->nc_flag & (NCF_UNRESOLVED|NCF_DESTROYED)) == 0)
+ if ((cache_grphead(ncp)->nc_flag & (NCF_UNRESOLVED|NCF_DESTROYED)) == 0)
break;
}
if (ncp)
@@ -1840,7 +1840,7 @@ jrecord_write_vnode_link(struct jrecord
TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) {
if (ncp == notncp)
continue;
- if ((ncp->nc_flag & (NCF_UNRESOLVED|NCF_DESTROYED)) == 0)
+ if ((cache_grphead(ncp)->nc_flag & (NCF_UNRESOLVED|NCF_DESTROYED)) == 0)
break;
}
if (ncp)
@@ -2533,7 +2533,7 @@ journal_nremove(struct vop_nremove_args
mp = ap->a_head.a_ops->vv_mount;
if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_REMOVE) &&
- ap->a_ncp->nc_vp
+ cache_grphead(ap->a_ncp)->nc_vp
) {
jreclist_undo_file(&jreclist, ap->a_ncp->nc_vp,
JRUNDO_ALL|JRUNDO_GETVP|JRUNDO_CONDLINK, 0, -1);
@@ -2599,7 +2599,7 @@ journal_nrmdir(struct vop_nrmdir_args *a
mp = ap->a_head.a_ops->vv_mount;
if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_RMDIR)) {
- jreclist_undo_file(&jreclist, ap->a_ncp->nc_vp,
+ jreclist_undo_file(&jreclist, cache_grphead(ap->a_ncp)->nc_vp,
JRUNDO_VATTR|JRUNDO_GETVP, 0, 0);
}
error = vop_journal_operate_ap(&ap->a_head);
@@ -2628,9 +2628,9 @@ journal_nrename(struct vop_nrename_args
mp = ap->a_head.a_ops->vv_mount;
if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_RENAME) &&
- ap->a_tncp->nc_vp
+ cache_grphead(ap->a_tncp)->nc_vp
) {
- jreclist_undo_file(&jreclist, ap->a_tncp->nc_vp,
+ jreclist_undo_file(&jreclist, cache_grphead(ap->a_tncp)->nc_vp,
JRUNDO_ALL|JRUNDO_GETVP|JRUNDO_CONDLINK, 0, -1);
}
error = vop_journal_operate_ap(&ap->a_head);
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_nlookup.c
--- a/sys/kern/vfs_nlookup.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_nlookup.c Mon Jan 23 05:16:56 2006 +0100
@@ -381,13 +381,15 @@ nlookup(struct nlookupdata *nd)
ncp = cache_get(ncp);
} else {
while ((ncp->nc_flag & NCF_MOUNTPT) && ncp != nd->nl_rootncp) {
- if (ncp->nc_parent->nc_flag & NCF_DESTROYED)
+ if (cache_grphead(ncp->nc_parent)->nc_flag &
+ NCF_DESTROYED)
break;
ncp = ncp->nc_parent; /* get to underlying node */
KKASSERT(ncp != NULL && 1);
}
if (ncp != nd->nl_rootncp) {
- if (ncp->nc_parent->nc_flag & NCF_DESTROYED) {
+ if (cache_grphead(ncp->nc_parent)->nc_flag &
+ NCF_DESTROYED) {
error = EINVAL;
break;
}
@@ -421,11 +423,11 @@ nlookup(struct nlookupdata *nd)
* XXX neither '.' nor '..' should return EAGAIN since they were
* previously resolved and thus cannot be newly created ncp's.
*/
- if (ncp->nc_flag & NCF_UNRESOLVED) {
+ if (cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) {
error = cache_resolve(ncp, nd->nl_cred);
KKASSERT(error != EAGAIN);
} else {
- error = ncp->nc_error;
+ error = cache_grphead_l(ncp)->nc_error;
}
/*
@@ -459,7 +461,7 @@ nlookup(struct nlookupdata *nd)
* element or it is the last element and we are allowed to
* follow symlinks, resolve the symlink.
*/
- if ((ncp->nc_flag & NCF_ISSYMLINK) &&
+ if ((cache_grphead_l(ncp)->nc_flag & NCF_ISSYMLINK) &&
(*ptr || (nd->nl_flags & NLC_FOLLOW))
) {
if (nd->nl_loopcnt++ >= MAXSYMLINKS) {
@@ -509,24 +511,31 @@ nlookup(struct nlookupdata *nd)
*
* XXX NOCROSSMOUNT
*/
- while ((ncp->nc_flag & NCF_ISDIR) && ncp->nc_vp->v_mountedhere &&
+ while ((cache_grphead_l(ncp)->nc_flag & NCF_ISDIR) &&
+ cache_grphead_l(ncp)->nc_vp->v_mountedhere &&
(nd->nl_flags & NLC_NOCROSSMOUNT) == 0
) {
struct mount *mp;
struct vnode *tdp;
- mp = ncp->nc_vp->v_mountedhere;
+ mp = cache_grphead_l(ncp)->nc_vp->v_mountedhere;
cache_put(ncp);
ncp = cache_get(mp->mnt_ncp);
- if (ncp->nc_flag & NCF_UNRESOLVED) {
+ if (cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) {
while (vfs_busy(mp, 0, nd->nl_td))
;
error = VFS_ROOT(mp, &tdp);
vfs_unbusy(mp, nd->nl_td);
if (error)
break;
- cache_setvp(ncp, tdp);
+ /*
+ * The VFS_ROOT call might have the side effect of
+ * resolving the ncp. Or is that declared a sin
+ * anywhere?
+ */
+ if (cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED)
+ cache_setvp(ncp, tdp);
vput(tdp);
}
}
@@ -543,7 +552,7 @@ nlookup(struct nlookupdata *nd)
* to the failure case below.
*/
while (*ptr == '/') {
- if ((ncp->nc_flag & NCF_ISDIR) == 0 &&
+ if ((cache_grphead_l(ncp)->nc_flag & NCF_ISDIR) == 0 &&
!(nd->nl_flags & NLC_WILLBEDIR)
) {
break;
@@ -555,7 +564,7 @@ nlookup(struct nlookupdata *nd)
* Continuation case: additional elements and the current
* element is a directory.
*/
- if (*ptr && (ncp->nc_flag & NCF_ISDIR)) {
+ if (*ptr && (cache_grphead_l(ncp)->nc_flag & NCF_ISDIR)) {
cache_drop(nd->nl_ncp);
cache_unlock(ncp);
nd->nl_ncp = ncp;
@@ -619,7 +628,7 @@ nlookup_mp(struct mount *mp, struct name
error = 0;
ncp = mp->mnt_ncp;
cache_get(ncp);
- if (ncp->nc_flag & NCF_UNRESOLVED) {
+ if (cache_grphead_l(ncp)->nc_flag & NCF_UNRESOLVED) {
while (vfs_busy(mp, 0, curthread))
;
error = VFS_ROOT(mp, &vp);
@@ -655,7 +664,7 @@ nreadsymlink(struct nlookupdata *nd, str
nlc->nlc_nameptr = NULL;
nlc->nlc_namelen = 0;
- if (ncp->nc_vp == NULL)
+ if (cache_grphead_l(ncp)->nc_vp == NULL)
return(ENOENT);
if ((error = cache_vget(ncp, nd->nl_cred, LK_SHARED, &vp)) != 0)
return(error);
@@ -713,13 +722,14 @@ int
int
naccess(struct namecache *ncp, int vmode, struct ucred *cred)
{
- struct namecache *par;
+ struct namecache *par, *oncp = ncp;
struct vnode *vp;
struct vattr va;
int error;
- if (ncp->nc_flag & NCF_UNRESOLVED) {
+ if (ncp->nc_flag & NCF_UNRESOLVED || ncp->nc_shadowed) {
cache_lock(ncp);
+ ncp = cache_grphead_l(ncp);
cache_resolve(ncp, cred);
cache_unlock(ncp);
}
@@ -728,7 +738,7 @@ naccess(struct namecache *ncp, int vmode
if (((vmode & VCREATE) && ncp->nc_vp == NULL) ||
((vmode & VDELETE) && ncp->nc_vp != NULL)
) {
- if ((par = ncp->nc_parent) == NULL) {
+ if ((par = oncp->nc_parent) == NULL) {
if (error != EAGAIN)
error = EINVAL;
} else {
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_syscalls.c
--- a/sys/kern/vfs_syscalls.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_syscalls.c Mon Jan 23 05:16:56 2006 +0100
@@ -140,7 +140,7 @@ mount(struct mount_args *uap)
error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
if (error == 0) {
if ((error = nlookup(&nd)) == 0) {
- if (nd.nl_ncp->nc_vp == NULL)
+ if (cache_grphead_l(nd.nl_ncp)->nc_vp == NULL)
error = ENOENT;
}
}
@@ -159,7 +159,7 @@ mount(struct mount_args *uap)
/*
* now we have the locked ref'd ncp and unreferenced vnode.
*/
- vp = ncp->nc_vp;
+ vp = cache_grphead_l(ncp)->nc_vp;
if ((error = vget(vp, LK_EXCLUSIVE, td)) != 0) {
cache_put(ncp);
return (error);
@@ -1050,9 +1050,9 @@ fchdir(struct fchdir_args *uap)
while (!error && (mp = vp->v_mountedhere) != NULL) {
error = nlookup_mp(mp, &nct);
if (error == 0) {
+ vput(vp);
+ vp = cache_grphead_l(nct)->nc_vp;
cache_unlock(nct); /* leave ref intact */
- vput(vp);
- vp = nct->nc_vp;
error = vget(vp, LK_SHARED, td);
KKASSERT(error == 0);
cache_drop(ncp);
@@ -1086,7 +1086,7 @@ kern_chdir(struct nlookupdata *nd)
if ((error = nlookup(nd)) != 0)
return (error);
- if ((vp = nd->nl_ncp->nc_vp) == NULL)
+ if ((vp = cache_grphead_l(nd->nl_ncp)->nc_vp) == NULL)
return (ENOENT);
if ((error = vget(vp, LK_SHARED, td)) != 0)
return (error);
@@ -1192,7 +1192,7 @@ kern_chroot(struct namecache *ncp)
if ((error = chroot_refuse_vdir_fds(fdp)) != 0)
return (error);
}
- if ((vp = ncp->nc_vp) == NULL)
+ if ((vp = cache_grphead_l(ncp)->nc_vp) == NULL)
return (ENOENT);
if ((error = vget(vp, LK_SHARED, td)) != 0)
@@ -1464,7 +1464,7 @@ kern_mknod(struct nlookupdata *nd, int m
if ((error = nlookup(nd)) != 0)
return (error);
ncp = nd->nl_ncp;
- if (ncp->nc_vp)
+ if (cache_grphead_l(ncp)->nc_vp)
return (EEXIST);
VATTR_NULL(&vattr);
@@ -1536,7 +1536,7 @@ kern_mkfifo(struct nlookupdata *nd, int
if ((error = nlookup(nd)) != 0)
return (error);
ncp = nd->nl_ncp;
- if (ncp->nc_vp)
+ if (cache_grphead_l(ncp)->nc_vp)
return (EEXIST);
VATTR_NULL(&vattr);
@@ -1633,7 +1633,7 @@ kern_link(struct nlookupdata *nd, struct
bwillwrite();
if ((error = nlookup(nd)) != 0)
return (error);
- vp = nd->nl_ncp->nc_vp;
+ vp = cache_grphead_l(nd->nl_ncp)->nc_vp;
KKASSERT(vp != NULL);
if (vp->v_type == VDIR)
return (EPERM); /* POSIX */
@@ -1654,7 +1654,7 @@ kern_link(struct nlookupdata *nd, struct
vput(vp);
return (error);
}
- if (linknd->nl_ncp->nc_vp) {
+ if (cache_grphead_l(linknd->nl_ncp)->nc_vp) {
vput(vp);
return (EEXIST);
}
@@ -1704,7 +1704,7 @@ kern_symlink(struct nlookupdata *nd, cha
if ((error = nlookup(nd)) != 0)
return (error);
ncp = nd->nl_ncp;
- if (ncp->nc_vp)
+ if (cache_grphead_l(ncp)->nc_vp)
return (EEXIST);
VATTR_NULL(&vattr);
@@ -1922,7 +1922,7 @@ kern_stat(struct nlookupdata *nd, struct
if ((error = nlookup(nd)) != 0)
return (error);
again:
- if ((vp = nd->nl_ncp->nc_vp) == NULL)
+ if ((vp = cache_grphead_l(nd->nl_ncp)->nc_vp) == NULL)
return (ENOENT);
td = curthread;
@@ -2718,13 +2718,17 @@ kern_rename(struct nlookupdata *fromnd,
* Due to relocking of the source, fromnd->nl_ncp->nc_vp might have
* become NULL.
*/
- if (tond->nl_ncp->nc_vp) {
- if (fromnd->nl_ncp->nc_vp == NULL) {
+ /*
+ * XXX I was lazy to find out who is locked exactly, so just dumbly
+ * cache_grphead() the parties...
+ */
+ if (cache_grphead(tond->nl_ncp)->nc_vp) {
+ if (cache_grphead(fromnd->nl_ncp)->nc_vp == NULL) {
error = ENOENT;
- } else if (fromnd->nl_ncp->nc_vp->v_type == VDIR) {
- if (tond->nl_ncp->nc_vp->v_type != VDIR)
+ } else if (cache_grphead(fromnd->nl_ncp)->nc_vp->v_type ==
VDIR) {
+ if (cache_grphead(tond->nl_ncp)->nc_vp->v_type != VDIR)
error = ENOTDIR;
- } else if (tond->nl_ncp->nc_vp->v_type == VDIR) {
+ } else if (cache_grphead(tond->nl_ncp)->nc_vp->v_type == VDIR) {
error = EISDIR;
}
}
@@ -2753,7 +2757,7 @@ kern_rename(struct nlookupdata *fromnd,
* when we detect the situation.
*/
if (error == 0) {
- if (fromnd->nl_ncp->nc_vp == tond->nl_ncp->nc_vp) {
+ if (cache_grphead(fromnd->nl_ncp)->nc_vp ==
cache_grphead(tond->nl_ncp)->nc_vp) {
error = VOP_NREMOVE(fromnd->nl_ncp, fromnd->nl_cred);
} else {
error = VOP_NRENAME(fromnd->nl_ncp, tond->nl_ncp,
@@ -2802,7 +2806,7 @@ kern_mkdir(struct nlookupdata *nd, int m
return (error);
ncp = nd->nl_ncp;
- if (ncp->nc_vp)
+ if (cache_grphead_l(ncp)->nc_vp)
return (EEXIST);
VATTR_NULL(&vattr);
diff -r 820a1f1d791e -r 6db92777ea99 sys/kern/vfs_vnops.c
--- a/sys/kern/vfs_vnops.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/kern/vfs_vnops.c Mon Jan 23 05:16:56 2006 +0100
@@ -169,7 +169,7 @@ vn_open(struct nlookupdata *nd, struct f
*/
again:
if (fmode & O_CREAT) {
- if (ncp->nc_vp == NULL) {
+ if (cache_grphead_l(ncp)->nc_vp == NULL) {
VATTR_NULL(vap);
vap->va_type = VREG;
vap->va_mode = cmode;
diff -r 820a1f1d791e -r 6db92777ea99 sys/sys/namecache.h
--- a/sys/sys/namecache.h Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/sys/namecache.h Mon Jan 23 05:16:56 2006 +0100
@@ -102,6 +102,7 @@ struct namecache {
TAILQ_ENTRY(namecache) nc_vnode; /* scan via vnode->v_namecache */
struct namecache_list nc_list; /* list of children */
struct namecache *nc_parent; /* namecache entry for parent */
+ struct namecache *nc_shadowed; /* lower layer entry in layered fs */
struct vnode *nc_vp; /* vnode representing name or NULL */
int nc_refs; /* ref count prevents deletion
*/
u_short nc_flag;
@@ -150,6 +151,10 @@ void cache_lock(struct namecache *ncp);
void cache_lock(struct namecache *ncp);
int cache_lock_nonblock(struct namecache *ncp);
void cache_unlock(struct namecache *ncp);
+struct namecache *cache_grphead_l(struct namecache *ncp);
+struct namecache *cache_grphead(struct namecache *ncp);
+int cache_shadow_attach(struct namecache *ncp, struct namecache *sncp);
+struct namecache *cache_shadow_detach(struct namecache *ncp);
void cache_setvp(struct namecache *ncp, struct vnode *vp);
void cache_settimeout(struct namecache *ncp, int nticks);
void cache_setunresolved(struct namecache *ncp);
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nfs/nfs_serv.c
--- a/sys/vfs/nfs/nfs_serv.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nfs/nfs_serv.c Mon Jan 23 05:16:56 2006 +0100
@@ -2183,8 +2183,8 @@ nfsrv_rename(struct nfsrv_descript *nfsd
}
fromnd.nl_flags |= NLC_NCPISLOCKED;
- tvp = tond.nl_ncp->nc_vp;
- fvp = fromnd.nl_ncp->nc_vp;
+ tvp = cache_grphead_l(tond.nl_ncp)->nc_vp;
+ fvp = cache_grphead_l(fromnd.nl_ncp)->nc_vp;
if (tvp != NULL) {
if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nfs/nfs_subs.c
--- a/sys/vfs/nfs/nfs_subs.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nfs/nfs_subs.c Mon Jan 23 05:16:56 2006 +0100
@@ -1671,7 +1671,7 @@ nfs_namei(struct nlookupdata *nd, struct
error = ENXIO;
}
}
- if (vpp && ncp->nc_vp) {
+ if (vpp && cache_grphead_l(ncp)->nc_vp) {
error = cache_vget(ncp, nd->nl_cred, LK_EXCLUSIVE, vpp);
}
if (error) {
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nfs/nfs_vnops.c
--- a/sys/vfs/nfs/nfs_vnops.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nfs/nfs_vnops.c Mon Jan 23 05:16:56 2006 +0100
@@ -883,8 +883,8 @@ nfs_nresolve(struct vop_nresolve_args *a
cred = ap->a_cred;
ncp = ap->a_ncp;
- KKASSERT(ncp->nc_parent && ncp->nc_parent->nc_vp);
- dvp = ncp->nc_parent->nc_vp;
+ KKASSERT(ncp->nc_parent && cache_grphead(ncp->nc_parent)->nc_vp);
+ dvp = cache_grphead(ncp->nc_parent)->nc_vp;
if ((error = vget(dvp, LK_SHARED, td)) != 0)
return (error);
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nullfs/null.h
--- a/sys/vfs/nullfs/null.h Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nullfs/null.h Mon Jan 23 05:16:56 2006 +0100
@@ -43,18 +43,19 @@ struct null_args {
char *target; /* Target of loopback */
};
-struct null_mount {
- struct mount *nullm_vfs;
- struct vnode *nullm_rootvp; /* Reference to root null_node */
-};
-
#ifdef _KERNEL
-#define MOUNTTONULLMOUNT(mp) ((struct null_mount *)((mp)->mnt_data))
#ifdef NULLFS_DEBUG
-#define NULLFSDEBUG(format, args...) printf(format ,## args)
+#define NULLFSDEBUG(format, args...) \
+ printf("[nullfs] %s:%d: " format, __func__, __LINE__, ## args)
+#define NULLNCDEBUG(ncp) \
+ NULLFSDEBUG(#ncp " %p: name %s, refs %d, exlocks %d, " \
+ "nc_mount %p, nc_shadowed %p\n", \
+ (ncp), (ncp)->nc_name, (ncp)->nc_refs, (ncp)->nc_exlocks, \
+ (ncp)->nc_mount, (ncp)->nc_shadowed);
#else
#define NULLFSDEBUG(format, args...)
+#define NULLNCDEBUG(ncp)
#endif /* NULLFS_DEBUG */
#endif /* _KERNEL */
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nullfs/null_vfsops.c
--- a/sys/vfs/nullfs/null_vfsops.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nullfs/null_vfsops.c Mon Jan 23 05:16:56 2006 +0100
@@ -80,12 +80,10 @@ nullfs_mount(struct mount *mp, char *pat
{
int error = 0;
struct null_args args;
- struct vnode *rootvp;
- struct null_mount *xmp;
u_int size;
struct nlookupdata nd;
- NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
+ NULLFSDEBUG("mp %p\n", (void *)mp);
/*
* Update is a no-op
@@ -98,118 +96,118 @@ nullfs_mount(struct mount *mp, char *pat
* Get argument
*/
error = copyin(data, (caddr_t)&args, sizeof(struct null_args));
- if (error)
- return (error);
-
- /*
- * Find lower node
- */
- rootvp = NULL;
- error = nlookup_init(&nd, args.target, UIO_USERSPACE, NLC_FOLLOW);
+
+ /*
+ * Do a lookup just to see if things are not fundamentally broken...
+ * but it's too early to make a proper use of the result.
+ */
+ if (error == 0)
+ error = nlookup_init(&nd, args.target, UIO_USERSPACE,
+ NLC_FOLLOW);
if (error == 0)
error = nlookup(&nd);
- if (error == 0) {
- error = cache_vget(nd.nl_ncp, nd.nl_cred, LK_EXCLUSIVE,
- &rootvp);
- }
-
- xmp = (struct null_mount *) malloc(sizeof(struct null_mount),
- M_NULLFSMNT, M_WAITOK); /* XXX */
-
- /*
- * Save reference to underlying FS
- */
- /*
- * As lite stacking enters the scene, the old way of doing this
- * -- via the vnode -- is not good enough anymore...
- */
- xmp->nullm_vfs = nd.nl_ncp->nc_mount;
+ if (error)
+ return(error);
+
nlookup_done(&nd);
- vfs_add_vnodeops(mp, &mp->mnt_vn_norm_ops,
- null_vnodeop_entries, 0);
-
- VOP_UNLOCK(rootvp, 0, td);
-
- /*
- * Keep a held reference to the root vnode.
- * It is vrele'd in nullfs_unmount.
- */
- xmp->nullm_rootvp = rootvp;
- /*
- * XXX What's the proper safety condition for querying
- * the underlying mount? Is this flag tuning necessary
- * at all?
- */
- if (xmp->nullm_vfs->mnt_flag & MNT_LOCAL)
- mp->mnt_flag |= MNT_LOCAL;
- mp->mnt_data = (qaddr_t) xmp;
- vfs_getnewfsid(mp);
+ vfs_add_vnodeops(mp, &mp->mnt_vn_norm_ops, null_vnodeop_entries, 0);
+
+ /*
+ * Heck it, let it just be local. I bet I need only five minutes to
+ * find out a sound sounding meaning for "local" by which null mounts
+ * are always local.
+ */
+ mp->mnt_flag |= MNT_LOCAL; vfs_getnewfsid(mp);
(void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
&size);
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
- (void)nullfs_statfs(mp, &mp->mnt_stat, td);
- NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
- mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntfromname);
+ NULLFSDEBUG("lower %s, alias at %s\n",
+ mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
return (0);
}
-/*
- * Free reference to null layer
- */
static int
nullfs_unmount(struct mount *mp, int mntflags, struct thread *td)
{
- void *mntdata;
- int flags = 0;
-
- NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
-
- if (mntflags & MNT_FORCE)
- flags |= FORCECLOSE;
-
- /*
- * Finally, throw away the null_mount structure
- */
- mntdata = mp->mnt_data;
- mp->mnt_data = 0;
- free(mntdata, M_NULLFSMNT);
+ NULLFSDEBUG("mp %p\n", (void *)mp);
+
+ cache_lock(mp->mnt_ncp);
+ cache_put(cache_shadow_detach(mp->mnt_ncp));
+ cache_unlock(mp->mnt_ncp);
+
return 0;
}
static int
+nullfs_start(struct mount *mp, int flags, struct thread *td)
+{
+ int error;
+ struct nlookupdata nd;
+
+ NULLFSDEBUG("nlookup %s\n", mp->mnt_stat.f_mntfromname);
+
+ error = nlookup_init(&nd, mp->mnt_stat.f_mntfromname,
+ UIO_SYSSPACE, NLC_FOLLOW);
+ if (error == 0)
+ error = nlookup(&nd);
+ if (error)
+ return(error);
+
+ cache_hold(nd.nl_ncp);
+ cache_lock(mp->mnt_ncp);
+
+ error = mp->mnt_ncp->nc_shadowed ?
+ EINVAL :
+ cache_shadow_attach(mp->mnt_ncp, nd.nl_ncp);
+
+ nlookup_done(&nd);
+
+ NULLNCDEBUG(mp->mnt_ncp);
+#ifdef NULLFS_DEBUG
+ if (mp->mnt_ncp->nc_shadowed)
+ NULLNCDEBUG(mp->mnt_ncp->nc_shadowed);
+#endif
+
+ return (error);
+}
+
+/*
+ * As the mount won't get aborted if VFS_START fails, we have to check in each
+ * VFS call whether it has succeeded...
+ */
+
+static int
nullfs_root(struct mount *mp, struct vnode **vpp)
{
- struct thread *td = curthread; /* XXX */
- struct vnode *vp;
-
- NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
- (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
-
- /*
- * Return locked reference to root.
- */
- vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
- vref(vp);
-
-#ifdef NULLFS_DEBUG
- if (VOP_ISLOCKED(vp, NULL)) {
- Debugger("root vnode is locked.\n");
- vrele(vp);
- return (EDEADLK);
- }
-#endif
- vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
- *vpp = vp;
- return 0;
+ int error;
+
+ if (! mp->mnt_ncp || ! mp->mnt_ncp->nc_shadowed)
+ return (ENXIO);
+
+ error = cache_vget(mp->mnt_ncp, crhold(proc0.p_ucred),
+ LK_EXCLUSIVE | LK_RETRY, vpp);
+ crfree(proc0.p_ucred);
+
+ return (error);
+}
+
+static __inline
+struct mount *
+nullfs_lowermount_0(struct mount *mp)
+{
+ return (mp->mnt_ncp->nc_shadowed->nc_mount);
}
static int
nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
struct thread *td)
{
- return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, td);
+ if (! mp->mnt_ncp || ! mp->mnt_ncp->nc_shadowed)
+ return (ENXIO);
+
+ return VFS_QUOTACTL(nullfs_lowermount_0(mp), cmd, uid, arg, td);
}
static int
@@ -218,12 +216,15 @@ nullfs_statfs(struct mount *mp, struct s
int error;
struct statfs mstat;
- NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
- (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
+ if (! mp->mnt_ncp || ! mp->mnt_ncp->nc_shadowed)
+ return (ENXIO);
+
+ NULLFSDEBUG("mp %p, ncp %p, lower mp %p\n",
+ mp, mp->mnt_ncp, nullfs_lowermount_0(mp));
bzero(&mstat, sizeof(mstat));
- error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, td);
+ error = VFS_STATFS(nullfs_lowermount_0(mp), &mstat, td);
if (error)
return (error);
@@ -248,23 +249,27 @@ nullfs_checkexp(struct mount *mp, struct
nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
struct ucred **credanonp)
{
-
- return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam,
- extflagsp, credanonp);
+ if (! mp->mnt_ncp || ! mp->mnt_ncp->nc_shadowed)
+ return (ENXIO);
+
+ return VFS_CHECKEXP(nullfs_lowermount_0(mp), nam, extflagsp, credanonp);
}
static int
nullfs_extattrctl(struct mount *mp, int cmd, const char *attrname, caddr_t arg,
struct thread *td)
{
- return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, attrname,
- arg, td);
+ if (! mp->mnt_ncp || ! mp->mnt_ncp->nc_shadowed)
+ return (ENXIO);
+
+ return VFS_EXTATTRCTL(nullfs_lowermount_0(mp), cmd, attrname, arg, td);
}
static struct vfsops null_vfsops = {
.vfs_mount = nullfs_mount,
.vfs_unmount = nullfs_unmount,
+ .vfs_start = nullfs_start,
.vfs_root = nullfs_root,
.vfs_quotactl = nullfs_quotactl,
.vfs_statfs = nullfs_statfs,
diff -r 820a1f1d791e -r 6db92777ea99 sys/vfs/nullfs/null_vnops.c
--- a/sys/vfs/nullfs/null_vnops.c Mon Jan 23 02:56:43 2006 +0000
+++ b/sys/vfs/nullfs/null_vnops.c Mon Jan 23 05:16:56 2006 +0100
@@ -109,6 +109,8 @@
#include <sys/namei.h>
#include <sys/malloc.h>
#include <sys/buf.h>
+#include <sys/namecache.h>
+#include <sys/nlookup.h>
#include "null.h"
static int null_nresolve(struct vop_nresolve_args *ap);
@@ -122,18 +124,93 @@ static int null_nrmdir(struct vop_nrmdir
static int null_nrmdir(struct vop_nrmdir_args *ap);
static int null_nrename(struct vop_nrename_args *ap);
+static __inline
+struct mount *
+nullfs_lowermount_l(struct namecache *ncp)
+{
+ /*
+ * The code in use below allows allows passing through lower mounts.
+ * If we didn't want to do that, we could use
+ *
+ * ncp->nc_mount->mnt_ncp->nc_shadowed->nc_mount
+ *
+ * Eventually, the choice might be configurable.
+ *
+ * - - -
+ *
+ * Matt says in
+ * http://leaf.dragonflybsd.org/mailarchive/kernel/2006-01/msg00023.html
+ * :
+
+ The ncp->nc_mount field was never meant to be used by the VFS code...
+ only to be used internally by cache_*(). It looks like I broke my own
+ rule... I have two references in NFS, but that's for later.
+
+ * Note that both approaches still use nc_mount:
+ *
+ * - If we wanna pass through lower mounts, we do have to find the
+ * the lower fs ncp-wise, we simply don't have choice.
+ *
+ * - If we just work with a fixed lower fs, we are able to access
+ * that if we are willing to use nc_mount. Hence it just seems to be
+ * stupid to keep around a direct reference to the lower fs, but
+ * that's of course feasible.
+ */
+ return (ncp->nc_shadowed->nc_mount);
+}
+
static int
null_nresolve(struct vop_nresolve_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
-
- return vop_nresolve_ap(ap);
+ struct namecache *ncp = ap->a_ncp;
+ struct mount *lmp;
+
+ if (! ncp->nc_shadowed) {
+ struct nlcomponent nlc;
+ struct namecache *sncp;
+
+ nlc.nlc_nameptr = ncp->nc_name;
+ nlc.nlc_namelen = ncp->nc_nlen;
+
+ KKASSERT(ncp->nc_parent->nc_shadowed);
+ sncp = cache_nlookup(ncp->nc_parent->nc_shadowed, &nlc);
+
+ if ((ncp->nc_error = cache_shadow_attach(ncp, sncp))) {
+ cache_put(sncp);
+ cache_setvp(ncp, NULL);
+ return (ncp->nc_error);
+ }
+
+ NULLNCDEBUG(ncp);
+ NULLNCDEBUG(ncp->nc_shadowed);
+ }
+
+ /*
+ * XXX Querying/ensuring usability of lower fs still not got right.
+ * As a quick hack, we do a simple test here, that will do for
+ * avoiding most obvious fallacies.
+ */
+ if ((lmp = nullfs_lowermount_l(ncp)) &&
+ (ap->a_head.a_ops = lmp->mnt_vn_use_ops)) {
+ /*
+ * Moving down in the shadow chain is for avoiding a recursed
+ * loop (ending up in exhausting the kernel stack).
+ *
+ * Otherwise it's the same whether we use ncp or
+ * ncp->nc_shadowed -- we go for group shared ncp attributes.
+ */
+ ap->a_ncp = ncp->nc_shadowed;
+ return vop_nresolve_ap(ap);
+ }
+
+ return (ENXIO);
}
static int
null_ncreate(struct vop_ncreate_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_ncreate_ap(ap);
}
@@ -141,7 +218,8 @@ static int
static int
null_nmkdir(struct vop_nmkdir_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nmkdir_ap(ap);
}
@@ -149,7 +227,8 @@ static int
static int
null_nmknod(struct vop_nmknod_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nmknod_ap(ap);
}
@@ -157,7 +236,8 @@ static int
static int
null_nlink(struct vop_nlink_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nlink_ap(ap);
}
@@ -165,7 +245,8 @@ static int
static int
null_nsymlink(struct vop_nsymlink_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nsymlink_ap(ap);
}
@@ -173,7 +254,8 @@ static int
static int
null_nwhiteout(struct vop_nwhiteout_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nwhiteout_ap(ap);
}
@@ -181,7 +263,8 @@ static int
static int
null_nremove(struct vop_nremove_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nremove_ap(ap);
}
@@ -189,7 +272,8 @@ static int
static int
null_nrmdir(struct vop_nrmdir_args *ap)
{
- ap->a_head.a_ops =
MOUNTTONULLMOUNT(ap->a_ncp->nc_mount)->nullm_vfs->mnt_vn_norm_ops;
+ ap->a_head.a_ops = nullfs_lowermount_l(ap->a_ncp)->mnt_vn_use_ops;
+ ap->a_ncp = ap->a_ncp->nc_shadowed;
return vop_nrmdir_ap(ap);
}
@@ -197,15 +281,32 @@ static int
static int
null_nrename(struct vop_nrename_args *ap)
{
+ struct namecache *fncp = ap->a_fncp;
+ struct namecache *tncp = ap->a_tncp;
struct mount *lmp;
-
- lmp = MOUNTTONULLMOUNT(ap->a_fncp->nc_mount)->nullm_vfs;
- if (lmp != MOUNTTONULLMOUNT(ap->a_tncp->nc_mount)->nullm_vfs)
- return (EINVAL);
-
- ap->a_head.a_ops = lmp->mnt_vn_norm_ops;
-
- return vop_nrename_ap(ap);
+ int error;
+
+ lmp = nullfs_lowermount_l(fncp);
+ if (lmp != nullfs_lowermount_l(tncp))
+ return (EXDEV);
+
+ ap->a_head.a_ops = lmp->mnt_vn_use_ops;
+
+ /*
+ * Parent-children relations are not subject to shadowing, therefore
+ * we can't just dumbassly delegate, we have some work in both layers.
+ * However, shadowing still saves us from locking or dealing with
+ * vnodes.
+ */
+ ap->a_fncp = fncp->nc_shadowed;
+ ap->a_tncp = tncp->nc_shadowed;
+
+ if ((error = vop_nrename_ap(ap)))
+ return (error);
+
+ cache_rename(fncp, tncp);
+
+ return (error);
}
/*
@@ -224,4 +325,3 @@ struct vnodeopv_entry_desc null_vnodeop_
{ &vop_nrename_desc, (vnodeopv_entry_t) null_nrename },
{ NULL, NULL }
};
-
