2001-04-07 19:51:12 +00:00
|
|
|
|
/*-
|
|
|
|
|
* Copyright (c) 2001 Dag-Erling Co<EFBFBD>dan Sm<EFBFBD>rgrav
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* 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
|
|
|
|
|
* in this position and unchanged.
|
|
|
|
|
* 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.
|
|
|
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2005-03-14 15:54:11 +00:00
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
|
|
#include "opt_pseudofs.h"
|
|
|
|
|
|
2001-04-07 19:51:12 +00:00
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
#include <sys/systm.h>
|
2003-03-24 21:15:35 +00:00
|
|
|
|
#include <sys/eventhandler.h>
|
2001-06-11 15:04:48 +00:00
|
|
|
|
#include <sys/lock.h>
|
2001-04-07 19:51:12 +00:00
|
|
|
|
#include <sys/malloc.h>
|
2001-06-10 10:36:16 +00:00
|
|
|
|
#include <sys/mutex.h>
|
2001-10-01 04:22:20 +00:00
|
|
|
|
#include <sys/proc.h>
|
2001-04-07 19:51:12 +00:00
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
|
|
|
|
|
|
#include <fs/pseudofs/pseudofs.h>
|
|
|
|
|
#include <fs/pseudofs/pseudofs_internal.h>
|
|
|
|
|
|
2001-06-10 18:39:21 +00:00
|
|
|
|
static MALLOC_DEFINE(M_PFSVNCACHE, "pfs_vncache", "pseudofs vnode cache");
|
2001-04-07 19:51:12 +00:00
|
|
|
|
|
|
|
|
|
static struct mtx pfs_vncache_mutex;
|
2002-01-08 11:15:57 +00:00
|
|
|
|
static struct pfs_vdata *pfs_vncache;
|
2003-03-24 21:15:35 +00:00
|
|
|
|
static eventhandler_tag pfs_exit_tag;
|
|
|
|
|
static void pfs_exit(void *arg, struct proc *p);
|
2001-04-07 19:51:12 +00:00
|
|
|
|
|
|
|
|
|
SYSCTL_NODE(_vfs_pfs, OID_AUTO, vncache, CTLFLAG_RW, 0,
|
|
|
|
|
"pseudofs vnode cache");
|
|
|
|
|
|
2001-10-01 04:22:20 +00:00
|
|
|
|
static int pfs_vncache_entries;
|
|
|
|
|
SYSCTL_INT(_vfs_pfs_vncache, OID_AUTO, entries, CTLFLAG_RD,
|
|
|
|
|
&pfs_vncache_entries, 0,
|
|
|
|
|
"number of entries in the vnode cache");
|
|
|
|
|
|
|
|
|
|
static int pfs_vncache_maxentries;
|
|
|
|
|
SYSCTL_INT(_vfs_pfs_vncache, OID_AUTO, maxentries, CTLFLAG_RD,
|
|
|
|
|
&pfs_vncache_maxentries, 0,
|
|
|
|
|
"highest number of entries in the vnode cache");
|
|
|
|
|
|
2001-04-07 19:51:12 +00:00
|
|
|
|
static int pfs_vncache_hits;
|
2001-10-01 04:22:20 +00:00
|
|
|
|
SYSCTL_INT(_vfs_pfs_vncache, OID_AUTO, hits, CTLFLAG_RD,
|
|
|
|
|
&pfs_vncache_hits, 0,
|
2001-04-07 19:51:12 +00:00
|
|
|
|
"number of cache hits since initialization");
|
|
|
|
|
|
|
|
|
|
static int pfs_vncache_misses;
|
2001-10-01 04:22:20 +00:00
|
|
|
|
SYSCTL_INT(_vfs_pfs_vncache, OID_AUTO, misses, CTLFLAG_RD,
|
|
|
|
|
&pfs_vncache_misses, 0,
|
2001-04-07 19:51:12 +00:00
|
|
|
|
"number of cache misses since initialization");
|
|
|
|
|
|
2004-12-01 23:16:38 +00:00
|
|
|
|
extern struct vop_vector pfs_vnodeops; /* XXX -> .h file */
|
2001-04-07 19:51:12 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Initialize vnode cache
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
pfs_vncache_load(void)
|
|
|
|
|
{
|
2007-04-14 14:08:30 +00:00
|
|
|
|
|
|
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
|
|
|
|
mtx_init(&pfs_vncache_mutex, "pfs_vncache", NULL, MTX_DEF);
|
2003-03-24 21:15:35 +00:00
|
|
|
|
pfs_exit_tag = EVENTHANDLER_REGISTER(process_exit, pfs_exit, NULL,
|
|
|
|
|
EVENTHANDLER_PRI_ANY);
|
2001-04-07 19:51:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tear down vnode cache
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
pfs_vncache_unload(void)
|
|
|
|
|
{
|
2007-04-14 14:08:30 +00:00
|
|
|
|
|
|
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2003-03-24 21:15:35 +00:00
|
|
|
|
EVENTHANDLER_DEREGISTER(process_exit, pfs_exit_tag);
|
2007-04-14 14:08:30 +00:00
|
|
|
|
KASSERT(pfs_vncache_entries == 0,
|
|
|
|
|
("%d vncache entries remaining", pfs_vncache_entries));
|
2001-04-07 19:51:12 +00:00
|
|
|
|
mtx_destroy(&pfs_vncache_mutex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate a vnode
|
|
|
|
|
*/
|
|
|
|
|
int
|
2001-06-10 18:39:21 +00:00
|
|
|
|
pfs_vncache_alloc(struct mount *mp, struct vnode **vpp,
|
|
|
|
|
struct pfs_node *pn, pid_t pid)
|
2001-04-07 19:51:12 +00:00
|
|
|
|
{
|
2001-06-10 18:39:21 +00:00
|
|
|
|
struct pfs_vdata *pvd;
|
2007-01-02 17:27:52 +00:00
|
|
|
|
struct vnode *vp;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
int error;
|
2001-12-19 23:58:09 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2002-06-06 16:59:24 +00:00
|
|
|
|
* See if the vnode is in the cache.
|
2001-12-19 23:58:09 +00:00
|
|
|
|
* XXX linear search is not very efficient.
|
|
|
|
|
*/
|
2007-01-02 17:27:52 +00:00
|
|
|
|
retry:
|
2001-06-10 18:39:21 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
for (pvd = pfs_vncache; pvd; pvd = pvd->pvd_next) {
|
2003-01-28 09:21:42 +00:00
|
|
|
|
if (pvd->pvd_pn == pn && pvd->pvd_pid == pid &&
|
|
|
|
|
pvd->pvd_vnode->v_mount == mp) {
|
2007-01-02 17:27:52 +00:00
|
|
|
|
vp = pvd->pvd_vnode;
|
|
|
|
|
VI_LOCK(vp);
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
|
|
|
|
if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, curthread) == 0) {
|
2001-04-07 19:51:12 +00:00
|
|
|
|
++pfs_vncache_hits;
|
2007-01-02 17:27:52 +00:00
|
|
|
|
*vpp = vp;
|
Add a flag to struct pfs_vdata to mark the vnode as dead (e.g. process-
specific nodes when the process exits)
Move the vnode-cache-walking loop which was duplicated in pfs_exit() and
pfs_disable() into its own function, pfs_purge(), which looks for vnodes
marked as dead and / or belonging to the specified pfs_node and reclaims
them. Note that this loop is still extremely inefficient.
Add a comment in pfs_vncache_alloc() explaining why we have to purge the
vnode from the vnode cache before returning, in case anyone should be
tempted to remove the call to cache_purge().
Move the special handling for pfstype_root nodes into pfs_fileno_alloc()
and pfs_fileno_free() (the root node's fileno must always be 2). This
also fixes a bug where pfs_fileno_free() would reclaim the root node's
fileno, triggering a panic in the unr code, as that fileno was never
allocated from unr to begin with.
When destroying a pfs_node, release its fileno and purge it from the
vnode cache. I wish we could put off the call to pfs_purge() until
after the entire tree had been destroyed, but then we'd have vnodes
referencing freed pfs nodes. This probably doesn't matter while we're
still under Giant, but might become an issue later.
When destroying a pseudofs instance, destroy the tree before tearing
down the fileno allocator.
In pfs_mount(), acquire the mountpoint interlock when required.
MFC after: 3 weeks
2007-04-11 22:40:57 +00:00
|
|
|
|
/*
|
|
|
|
|
* Some callers cache_enter(vp) later, so
|
|
|
|
|
* we have to make sure it's not in the
|
|
|
|
|
* VFS cache so it doesn't get entered
|
|
|
|
|
* twice. A better solution would be to
|
|
|
|
|
* make pfs_vncache_alloc() responsible
|
|
|
|
|
* for entering the vnode in the VFS
|
|
|
|
|
* cache.
|
|
|
|
|
*/
|
|
|
|
|
cache_purge(vp);
|
2001-04-07 19:51:12 +00:00
|
|
|
|
return (0);
|
|
|
|
|
}
|
2007-01-02 17:27:52 +00:00
|
|
|
|
goto retry;
|
2001-06-10 18:39:21 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2001-04-07 19:51:12 +00:00
|
|
|
|
++pfs_vncache_misses;
|
|
|
|
|
|
|
|
|
|
/* nope, get a new one */
|
2003-02-19 05:47:46 +00:00
|
|
|
|
MALLOC(pvd, struct pfs_vdata *, sizeof *pvd, M_PFSVNCACHE, M_WAITOK);
|
2007-04-23 19:17:01 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
if (++pfs_vncache_entries > pfs_vncache_maxentries)
|
|
|
|
|
pfs_vncache_maxentries = pfs_vncache_entries;
|
2007-04-23 19:17:01 +00:00
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2004-12-01 23:16:38 +00:00
|
|
|
|
error = getnewvnode("pseudofs", mp, &pfs_vnodeops, vpp);
|
2002-10-15 18:51:02 +00:00
|
|
|
|
if (error) {
|
2007-04-23 19:17:01 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
|
|
|
|
--pfs_vncache_entries;
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2002-10-15 18:51:02 +00:00
|
|
|
|
FREE(pvd, M_PFSVNCACHE);
|
2001-04-07 19:51:12 +00:00
|
|
|
|
return (error);
|
2002-10-15 18:51:02 +00:00
|
|
|
|
}
|
2001-06-10 18:39:21 +00:00
|
|
|
|
pvd->pvd_pn = pn;
|
|
|
|
|
pvd->pvd_pid = pid;
|
|
|
|
|
(*vpp)->v_data = pvd;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
switch (pn->pn_type) {
|
|
|
|
|
case pfstype_root:
|
2002-08-04 10:29:36 +00:00
|
|
|
|
(*vpp)->v_vflag = VV_ROOT;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
#if 0
|
|
|
|
|
printf("root vnode allocated\n");
|
|
|
|
|
#endif
|
2001-10-01 04:22:20 +00:00
|
|
|
|
/* fall through */
|
2001-04-07 19:51:12 +00:00
|
|
|
|
case pfstype_dir:
|
|
|
|
|
case pfstype_this:
|
|
|
|
|
case pfstype_parent:
|
2001-06-10 18:39:21 +00:00
|
|
|
|
case pfstype_procdir:
|
2001-04-07 19:51:12 +00:00
|
|
|
|
(*vpp)->v_type = VDIR;
|
|
|
|
|
break;
|
|
|
|
|
case pfstype_file:
|
|
|
|
|
(*vpp)->v_type = VREG;
|
|
|
|
|
break;
|
|
|
|
|
case pfstype_symlink:
|
|
|
|
|
(*vpp)->v_type = VLNK;
|
|
|
|
|
break;
|
2001-06-10 18:39:21 +00:00
|
|
|
|
case pfstype_none:
|
|
|
|
|
KASSERT(0, ("pfs_vncache_alloc called for null node\n"));
|
2001-04-07 19:51:12 +00:00
|
|
|
|
default:
|
|
|
|
|
panic("%s has unexpected type: %d", pn->pn_name, pn->pn_type);
|
|
|
|
|
}
|
2002-09-14 09:02:28 +00:00
|
|
|
|
/*
|
|
|
|
|
* Propagate flag through to vnode so users know it can change
|
|
|
|
|
* if the process changes (i.e. execve)
|
|
|
|
|
*/
|
|
|
|
|
if ((pn->pn_flags & PFS_PROCDEP) != 0)
|
|
|
|
|
(*vpp)->v_vflag |= VV_PROCDEP;
|
2001-10-01 04:22:20 +00:00
|
|
|
|
pvd->pvd_vnode = *vpp;
|
2008-02-24 16:38:58 +00:00
|
|
|
|
VN_LOCK_AREC(*vpp);
|
2008-01-10 01:10:58 +00:00
|
|
|
|
vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
|
2007-03-13 01:50:27 +00:00
|
|
|
|
error = insmntque(*vpp, mp);
|
|
|
|
|
if (error != 0) {
|
2007-04-23 19:17:01 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
|
|
|
|
--pfs_vncache_entries;
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2007-03-13 01:50:27 +00:00
|
|
|
|
FREE(pvd, M_PFSVNCACHE);
|
|
|
|
|
*vpp = NULLVP;
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
2001-06-10 18:39:21 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
pvd->pvd_prev = NULL;
|
|
|
|
|
pvd->pvd_next = pfs_vncache;
|
|
|
|
|
if (pvd->pvd_next)
|
|
|
|
|
pvd->pvd_next->pvd_prev = pvd;
|
|
|
|
|
pfs_vncache = pvd;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Free a vnode
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
pfs_vncache_free(struct vnode *vp)
|
|
|
|
|
{
|
2001-06-10 18:39:21 +00:00
|
|
|
|
struct pfs_vdata *pvd;
|
2001-12-19 23:58:09 +00:00
|
|
|
|
|
2001-04-07 19:51:12 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
pvd = (struct pfs_vdata *)vp->v_data;
|
|
|
|
|
KASSERT(pvd != NULL, ("pfs_vncache_free(): no vnode data\n"));
|
|
|
|
|
if (pvd->pvd_next)
|
|
|
|
|
pvd->pvd_next->pvd_prev = pvd->pvd_prev;
|
|
|
|
|
if (pvd->pvd_prev)
|
|
|
|
|
pvd->pvd_prev->pvd_next = pvd->pvd_next;
|
2001-06-10 18:39:21 +00:00
|
|
|
|
else
|
2001-10-01 04:22:20 +00:00
|
|
|
|
pfs_vncache = pvd->pvd_next;
|
2007-04-23 19:17:01 +00:00
|
|
|
|
--pfs_vncache_entries;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
|
2001-06-10 18:39:21 +00:00
|
|
|
|
FREE(pvd, M_PFSVNCACHE);
|
|
|
|
|
vp->v_data = NULL;
|
2001-04-07 19:51:12 +00:00
|
|
|
|
return (0);
|
|
|
|
|
}
|
2001-10-01 04:22:20 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2007-04-15 17:10:01 +00:00
|
|
|
|
* Purge the cache of dead entries
|
2005-01-08 04:56:38 +00:00
|
|
|
|
*
|
Add a flag to struct pfs_vdata to mark the vnode as dead (e.g. process-
specific nodes when the process exits)
Move the vnode-cache-walking loop which was duplicated in pfs_exit() and
pfs_disable() into its own function, pfs_purge(), which looks for vnodes
marked as dead and / or belonging to the specified pfs_node and reclaims
them. Note that this loop is still extremely inefficient.
Add a comment in pfs_vncache_alloc() explaining why we have to purge the
vnode from the vnode cache before returning, in case anyone should be
tempted to remove the call to cache_purge().
Move the special handling for pfstype_root nodes into pfs_fileno_alloc()
and pfs_fileno_free() (the root node's fileno must always be 2). This
also fixes a bug where pfs_fileno_free() would reclaim the root node's
fileno, triggering a panic in the unr code, as that fileno was never
allocated from unr to begin with.
When destroying a pfs_node, release its fileno and purge it from the
vnode cache. I wish we could put off the call to pfs_purge() until
after the entire tree had been destroyed, but then we'd have vnodes
referencing freed pfs nodes. This probably doesn't matter while we're
still under Giant, but might become an issue later.
When destroying a pseudofs instance, destroy the tree before tearing
down the fileno allocator.
In pfs_mount(), acquire the mountpoint interlock when required.
MFC after: 3 weeks
2007-04-11 22:40:57 +00:00
|
|
|
|
* This is extremely inefficient due to the fact that vgone() not only
|
|
|
|
|
* indirectly modifies the vnode cache, but may also sleep. We can
|
|
|
|
|
* neither hold pfs_vncache_mutex across a vgone() call, nor make any
|
|
|
|
|
* assumptions about the state of the cache after vgone() returns. In
|
|
|
|
|
* consequence, we must start over after every vgone() call, and keep
|
|
|
|
|
* trying until we manage to traverse the entire cache.
|
|
|
|
|
*
|
|
|
|
|
* The only way to improve this situation is to change the data structure
|
|
|
|
|
* used to implement the cache.
|
2001-10-01 04:22:20 +00:00
|
|
|
|
*/
|
Add a flag to struct pfs_vdata to mark the vnode as dead (e.g. process-
specific nodes when the process exits)
Move the vnode-cache-walking loop which was duplicated in pfs_exit() and
pfs_disable() into its own function, pfs_purge(), which looks for vnodes
marked as dead and / or belonging to the specified pfs_node and reclaims
them. Note that this loop is still extremely inefficient.
Add a comment in pfs_vncache_alloc() explaining why we have to purge the
vnode from the vnode cache before returning, in case anyone should be
tempted to remove the call to cache_purge().
Move the special handling for pfstype_root nodes into pfs_fileno_alloc()
and pfs_fileno_free() (the root node's fileno must always be 2). This
also fixes a bug where pfs_fileno_free() would reclaim the root node's
fileno, triggering a panic in the unr code, as that fileno was never
allocated from unr to begin with.
When destroying a pfs_node, release its fileno and purge it from the
vnode cache. I wish we could put off the call to pfs_purge() until
after the entire tree had been destroyed, but then we'd have vnodes
referencing freed pfs nodes. This probably doesn't matter while we're
still under Giant, but might become an issue later.
When destroying a pseudofs instance, destroy the tree before tearing
down the fileno allocator.
In pfs_mount(), acquire the mountpoint interlock when required.
MFC after: 3 weeks
2007-04-11 22:40:57 +00:00
|
|
|
|
void
|
|
|
|
|
pfs_purge(struct pfs_node *pn)
|
2001-10-01 04:22:20 +00:00
|
|
|
|
{
|
2004-08-15 21:58:02 +00:00
|
|
|
|
struct pfs_vdata *pvd;
|
|
|
|
|
struct vnode *vnp;
|
2001-10-01 04:22:20 +00:00
|
|
|
|
|
2004-08-15 21:58:02 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
|
|
|
|
pvd = pfs_vncache;
|
|
|
|
|
while (pvd != NULL) {
|
Add a flag to struct pfs_vdata to mark the vnode as dead (e.g. process-
specific nodes when the process exits)
Move the vnode-cache-walking loop which was duplicated in pfs_exit() and
pfs_disable() into its own function, pfs_purge(), which looks for vnodes
marked as dead and / or belonging to the specified pfs_node and reclaims
them. Note that this loop is still extremely inefficient.
Add a comment in pfs_vncache_alloc() explaining why we have to purge the
vnode from the vnode cache before returning, in case anyone should be
tempted to remove the call to cache_purge().
Move the special handling for pfstype_root nodes into pfs_fileno_alloc()
and pfs_fileno_free() (the root node's fileno must always be 2). This
also fixes a bug where pfs_fileno_free() would reclaim the root node's
fileno, triggering a panic in the unr code, as that fileno was never
allocated from unr to begin with.
When destroying a pfs_node, release its fileno and purge it from the
vnode cache. I wish we could put off the call to pfs_purge() until
after the entire tree had been destroyed, but then we'd have vnodes
referencing freed pfs nodes. This probably doesn't matter while we're
still under Giant, but might become an issue later.
When destroying a pseudofs instance, destroy the tree before tearing
down the fileno allocator.
In pfs_mount(), acquire the mountpoint interlock when required.
MFC after: 3 weeks
2007-04-11 22:40:57 +00:00
|
|
|
|
if (pvd->pvd_dead || (pn != NULL && pvd->pvd_pn == pn)) {
|
2004-08-15 21:58:02 +00:00
|
|
|
|
vnp = pvd->pvd_vnode;
|
2005-07-07 07:33:10 +00:00
|
|
|
|
vhold(vnp);
|
2004-08-15 21:58:02 +00:00
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
2008-01-13 14:44:15 +00:00
|
|
|
|
VOP_LOCK(vnp, LK_EXCLUSIVE);
|
2004-08-15 21:58:02 +00:00
|
|
|
|
vgone(vnp);
|
2008-01-13 14:44:15 +00:00
|
|
|
|
VOP_UNLOCK(vnp, 0);
|
2005-07-07 07:33:10 +00:00
|
|
|
|
vdrop(vnp);
|
2004-08-15 21:58:02 +00:00
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
|
|
|
|
pvd = pfs_vncache;
|
|
|
|
|
} else {
|
|
|
|
|
pvd = pvd->pvd_next;
|
2001-10-01 04:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
Add a flag to struct pfs_vdata to mark the vnode as dead (e.g. process-
specific nodes when the process exits)
Move the vnode-cache-walking loop which was duplicated in pfs_exit() and
pfs_disable() into its own function, pfs_purge(), which looks for vnodes
marked as dead and / or belonging to the specified pfs_node and reclaims
them. Note that this loop is still extremely inefficient.
Add a comment in pfs_vncache_alloc() explaining why we have to purge the
vnode from the vnode cache before returning, in case anyone should be
tempted to remove the call to cache_purge().
Move the special handling for pfstype_root nodes into pfs_fileno_alloc()
and pfs_fileno_free() (the root node's fileno must always be 2). This
also fixes a bug where pfs_fileno_free() would reclaim the root node's
fileno, triggering a panic in the unr code, as that fileno was never
allocated from unr to begin with.
When destroying a pfs_node, release its fileno and purge it from the
vnode cache. I wish we could put off the call to pfs_purge() until
after the entire tree had been destroyed, but then we'd have vnodes
referencing freed pfs nodes. This probably doesn't matter while we're
still under Giant, but might become an issue later.
When destroying a pseudofs instance, destroy the tree before tearing
down the fileno allocator.
In pfs_mount(), acquire the mountpoint interlock when required.
MFC after: 3 weeks
2007-04-11 22:40:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Free all vnodes associated with a defunct process
|
|
|
|
|
*
|
|
|
|
|
* XXXRW: It is unfortunate that pfs_exit() always acquires and releases two
|
|
|
|
|
* mutexes (one of which is Giant) for every process exit, even if procfs
|
|
|
|
|
* isn't mounted.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
pfs_exit(void *arg, struct proc *p)
|
|
|
|
|
{
|
|
|
|
|
struct pfs_vdata *pvd;
|
|
|
|
|
int dead;
|
|
|
|
|
|
|
|
|
|
if (pfs_vncache == NULL)
|
|
|
|
|
return;
|
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
|
mtx_lock(&pfs_vncache_mutex);
|
|
|
|
|
for (pvd = pfs_vncache, dead = 0; pvd != NULL; pvd = pvd->pvd_next)
|
|
|
|
|
if (pvd->pvd_pid == p->p_pid)
|
|
|
|
|
dead = pvd->pvd_dead = 1;
|
|
|
|
|
mtx_unlock(&pfs_vncache_mutex);
|
|
|
|
|
if (dead)
|
|
|
|
|
pfs_purge(NULL);
|
2004-03-14 15:57:45 +00:00
|
|
|
|
mtx_unlock(&Giant);
|
2001-10-01 04:22:20 +00:00
|
|
|
|
}
|