Module Name: src
Committed By: pooka
Date: Mon Aug 3 14:23:30 UTC 2009
Modified Files:
src/sys/rump/include/rump: rump.h
src/sys/rump/librump/rumpvfs: rump_vfs.c rump_vfs_private.h rumpblk.c
rumpfs.c
Log Message:
* get rid of the old fakeblk registration interface. Instead,
introduce a new and improved "etfs" interface, which can be used
to register host files accessible from rump fs namespace. This
new interface is not restriced to block devices, and neither does
it require the same pathname in host namespace and rump namespace.
Therefore, the same host file can be represented both as a char
and block device in rump namespace.
* adjust rumpblk to make the above possible
* improve rumpfs: nodes are now created properly and not implicitly
tied to the vnode lifecycle
To generate a diff of this commit:
cvs rdiff -u -r1.23 -r1.24 src/sys/rump/include/rump/rump.h
cvs rdiff -u -r1.23 -r1.24 src/sys/rump/librump/rumpvfs/rump_vfs.c \
src/sys/rump/librump/rumpvfs/rumpblk.c
cvs rdiff -u -r1.2 -r1.3 src/sys/rump/librump/rumpvfs/rump_vfs_private.h
cvs rdiff -u -r1.20 -r1.21 src/sys/rump/librump/rumpvfs/rumpfs.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/rump/include/rump/rump.h
diff -u src/sys/rump/include/rump/rump.h:1.23 src/sys/rump/include/rump/rump.h:1.24
--- src/sys/rump/include/rump/rump.h:1.23 Tue May 26 15:44:35 2009
+++ src/sys/rump/include/rump/rump.h Mon Aug 3 14:23:30 2009
@@ -1,4 +1,4 @@
-/* $NetBSD: rump.h,v 1.23 2009/05/26 15:44:35 pooka Exp $ */
+/* $NetBSD: rump.h,v 1.24 2009/08/03 14:23:30 pooka Exp $ */
/*
* Copyright (c) 2007 Antti Kantee. All Rights Reserved.
@@ -93,9 +93,9 @@
void rump_getvninfo(struct vnode *, enum vtype *, off_t * /*XXX*/, dev_t *);
-int rump_fakeblk_register(const char *);
-int rump_fakeblk_find(const char *);
-void rump_fakeblk_deregister(const char *);
+enum rump_etfs_type { RUMP_ETFS_REG, RUMP_ETFS_BLK, RUMP_ETFS_CHR };
+int rump_etfs_register(const char *, const char *, enum rump_etfs_type);
+int rump_etfs_remove(const char *);
struct vfsops *rump_vfslist_iterate(struct vfsops *);
struct vfsops *rump_vfs_getopsbyname(const char *);
Index: src/sys/rump/librump/rumpvfs/rump_vfs.c
diff -u src/sys/rump/librump/rumpvfs/rump_vfs.c:1.23 src/sys/rump/librump/rumpvfs/rump_vfs.c:1.24
--- src/sys/rump/librump/rumpvfs/rump_vfs.c:1.23 Mon Jun 29 07:11:06 2009
+++ src/sys/rump/librump/rumpvfs/rump_vfs.c Mon Aug 3 14:23:30 2009
@@ -1,4 +1,4 @@
-/* $NetBSD: rump_vfs.c,v 1.23 2009/06/29 07:11:06 dholland Exp $ */
+/* $NetBSD: rump_vfs.c,v 1.24 2009/08/03 14:23:30 pooka Exp $ */
/*
* Copyright (c) 2008 Antti Kantee. All Rights Reserved.
@@ -29,7 +29,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rump_vfs.c,v 1.23 2009/06/29 07:11:06 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rump_vfs.c,v 1.24 2009/08/03 14:23:30 pooka Exp $");
#include <sys/param.h>
#include <sys/buf.h>
@@ -54,12 +54,6 @@
#include "rump_private.h"
#include "rump_vfs_private.h"
-struct fakeblk {
- char path[MAXPATHLEN];
- LIST_ENTRY(fakeblk) entries;
-};
-static LIST_HEAD(, fakeblk) fakeblks = LIST_HEAD_INITIALIZER(fakeblks);
-
static struct cwdinfo rump_cwdi;
static void rump_rcvp_lwpset(struct vnode *, struct vnode *, struct lwp *);
@@ -271,66 +265,6 @@
return rv;
}
-static struct fakeblk *
-_rump_fakeblk_find(const char *path)
-{
- char buf[MAXPATHLEN];
- struct fakeblk *fblk;
- int error;
-
- if (rumpuser_realpath(path, buf, &error) == NULL)
- return NULL;
-
- LIST_FOREACH(fblk, &fakeblks, entries)
- if (strcmp(fblk->path, buf) == 0)
- return fblk;
-
- return NULL;
-}
-
-int
-rump_fakeblk_register(const char *path)
-{
- char buf[MAXPATHLEN];
- struct fakeblk *fblk;
- int error;
-
- if (_rump_fakeblk_find(path))
- return EEXIST;
-
- if (rumpuser_realpath(path, buf, &error) == NULL)
- return error;
-
- fblk = kmem_alloc(sizeof(struct fakeblk), KM_NOSLEEP);
- if (fblk == NULL)
- return ENOMEM;
-
- strlcpy(fblk->path, buf, MAXPATHLEN);
- LIST_INSERT_HEAD(&fakeblks, fblk, entries);
-
- return 0;
-}
-
-int
-rump_fakeblk_find(const char *path)
-{
-
- return _rump_fakeblk_find(path) != NULL;
-}
-
-void
-rump_fakeblk_deregister(const char *path)
-{
- struct fakeblk *fblk;
-
- fblk = _rump_fakeblk_find(path);
- if (fblk == NULL)
- return;
-
- LIST_REMOVE(fblk, entries);
- kmem_free(fblk, sizeof(*fblk));
-}
-
void
rump_getvninfo(struct vnode *vp, enum vtype *vtype, voff_t *vsize, dev_t *vdev)
{
Index: src/sys/rump/librump/rumpvfs/rumpblk.c
diff -u src/sys/rump/librump/rumpvfs/rumpblk.c:1.23 src/sys/rump/librump/rumpvfs/rumpblk.c:1.24
--- src/sys/rump/librump/rumpvfs/rumpblk.c:1.23 Thu Apr 30 17:43:07 2009
+++ src/sys/rump/librump/rumpvfs/rumpblk.c Mon Aug 3 14:23:30 2009
@@ -1,4 +1,4 @@
-/* $NetBSD: rumpblk.c,v 1.23 2009/04/30 17:43:07 pooka Exp $ */
+/* $NetBSD: rumpblk.c,v 1.24 2009/08/03 14:23:30 pooka Exp $ */
/*
* Copyright (c) 2009 Antti Kantee. All Rights Reserved.
@@ -43,7 +43,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rumpblk.c,v 1.23 2009/04/30 17:43:07 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpblk.c,v 1.24 2009/08/03 14:23:30 pooka Exp $");
#include <sys/param.h>
#include <sys/buf.h>
@@ -89,6 +89,7 @@
static struct rblkdev {
char *rblk_path;
int rblk_fd;
+ int rblk_refcnt;
#ifdef HAS_ODIRECT
int rblk_dfd;
#endif
@@ -145,6 +146,7 @@
#define BLKFAIL_MAX 10000
static int blkfail;
static unsigned randstate;
+static kmutex_t rumpblk_lock;
static struct blkwin *
getwindow(struct rblkdev *rblk, off_t off, int *wsize, int *error)
@@ -253,6 +255,8 @@
unsigned tmp;
int error, i;
+ mutex_init(&rumpblk_lock, MUTEX_DEFAULT, IPL_NONE);
+
if (rumpuser_getenv("RUMP_BLKFAIL", buf, sizeof(buf), &error) == 0) {
blkfail = strtoul(buf, NULL, 10);
/* fail everything */
@@ -321,27 +325,47 @@
}
}
+/* XXX: no deregister */
int
-rumpblk_register(const char *path)
+rumpblk_register(const char *path, devminor_t *dmin)
{
+ uint64_t flen;
size_t len;
- int i;
+ int ftype, error, i;
- for (i = 0; i < RUMPBLK_SIZE; i++)
- if (minors[i].rblk_path && strcmp(minors[i].rblk_path, path)==0)
- return i;
+ if (rumpuser_getfileinfo(path, &flen, &ftype, &error))
+ return error;
+ /* verify host file is of supported type */
+ if (!(ftype == RUMPUSER_FT_REG
+ || ftype == RUMPUSER_FT_BLK
+ || ftype == RUMPUSER_FT_CHR))
+ return EINVAL;
+
+ mutex_enter(&rumpblk_lock);
+ for (i = 0; i < RUMPBLK_SIZE; i++) {
+ if (minors[i].rblk_path&&strcmp(minors[i].rblk_path, path)==0) {
+ mutex_exit(&rumpblk_lock);
+ *dmin = i;
+ return 0;
+ }
+ }
for (i = 0; i < RUMPBLK_SIZE; i++)
if (minors[i].rblk_path == NULL)
break;
- if (i == RUMPBLK_SIZE)
- return -1;
+ if (i == RUMPBLK_SIZE) {
+ mutex_exit(&rumpblk_lock);
+ return EBUSY;
+ }
len = strlen(path);
minors[i].rblk_path = malloc(len + 1, M_TEMP, M_WAITOK);
strcpy(minors[i].rblk_path, path);
minors[i].rblk_fd = -1;
- return i;
+ mutex_exit(&rumpblk_lock);
+
+ *dmin = i;
+ return 0;
}
int
@@ -352,7 +376,7 @@
int ft, dummy;
int error, fd;
- KASSERT(rblk->rblk_fd == -1);
+ KASSERT(rblk->rblk_fd == -1); /* XXX */
fd = rumpuser_open(rblk->rblk_path, OFLAGS(flag), &error);
if (error)
return error;
Index: src/sys/rump/librump/rumpvfs/rump_vfs_private.h
diff -u src/sys/rump/librump/rumpvfs/rump_vfs_private.h:1.2 src/sys/rump/librump/rumpvfs/rump_vfs_private.h:1.3
--- src/sys/rump/librump/rumpvfs/rump_vfs_private.h:1.2 Tue Jan 13 01:57:35 2009
+++ src/sys/rump/librump/rumpvfs/rump_vfs_private.h Mon Aug 3 14:23:30 2009
@@ -1,4 +1,4 @@
-/* $NetBSD: rump_vfs_private.h,v 1.2 2009/01/13 01:57:35 pooka Exp $ */
+/* $NetBSD: rump_vfs_private.h,v 1.3 2009/08/03 14:23:30 pooka Exp $ */
/*
* Copyright (c) 2008 Antti Kantee. All Rights Reserved.
@@ -28,11 +28,13 @@
#ifndef _SYS_RUMP_VFS_PRIVATE_H_
#define _SYS_RUMP_VFS_PRIVATE_H_
+#include <sys/types.h>
+
void rump_vfs_init(void);
void rumpfs_init(void);
#define RUMPBLK 254
-int rumpblk_register(const char *);
+int rumpblk_register(const char *, devminor_t *);
int rumpblk_init(void);
void rump_biodone(void *, size_t, int);
Index: src/sys/rump/librump/rumpvfs/rumpfs.c
diff -u src/sys/rump/librump/rumpvfs/rumpfs.c:1.20 src/sys/rump/librump/rumpvfs/rumpfs.c:1.21
--- src/sys/rump/librump/rumpvfs/rumpfs.c:1.20 Wed Jul 22 21:06:56 2009
+++ src/sys/rump/librump/rumpvfs/rumpfs.c Mon Aug 3 14:23:30 2009
@@ -1,4 +1,4 @@
-/* $NetBSD: rumpfs.c,v 1.20 2009/07/22 21:06:56 pooka Exp $ */
+/* $NetBSD: rumpfs.c,v 1.21 2009/08/03 14:23:30 pooka Exp $ */
/*
* Copyright (c) 2007 Antti Kantee. All Rights Reserved.
@@ -28,7 +28,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.20 2009/07/22 21:06:56 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.21 2009/08/03 14:23:30 pooka Exp $");
#include <sys/param.h>
#include <sys/mount.h>
@@ -103,10 +103,6 @@
NULL
};
-static struct mount rump_mnt;
-static int lastino = 1;
-static kmutex_t reclock;
-
struct rumpfs_dent {
char *rd_name;
struct rumpfs_node *rd_node;
@@ -122,8 +118,137 @@
LIST_HEAD(, rumpfs_dent) rn_dir;
};
+static struct rumpfs_node *makeprivate(enum vtype, dev_t, off_t);
+
+/*
+ * Extra Terrestrial stuff. We map a given key (pathname) to a file on
+ * the host FS. ET phones home only from the root node of rumpfs.
+ *
+ * When an etfs node is removed, a vnode potentially behind it is not
+ * immediately recycled.
+ */
+
+struct etfs {
+ char et_key[MAXPATHLEN];
+ LIST_ENTRY(etfs) et_entries;
+
+ struct rumpfs_node *et_rn;
+};
+static kmutex_t etfs_lock;
+static LIST_HEAD(, etfs) etfs_list = LIST_HEAD_INITIALIZER(etfs_list);
+
+static enum vtype
+ettype_to_vtype(enum rump_etfs_type et)
+{
+ enum vtype vt;
+
+ switch (et) {
+ case RUMP_ETFS_REG:
+ vt = VREG;
+ break;
+ case RUMP_ETFS_BLK:
+ vt = VBLK;
+ break;
+ case RUMP_ETFS_CHR:
+ vt = VCHR;
+ break;
+ default:
+ panic("invalid et type: %d", et);
+ }
+
+ return vt;
+}
+
+static bool
+etfs_find(const char *key, struct rumpfs_node **rnp)
+{
+ struct etfs *et;
+ bool rv = false;
+
+ KASSERT(mutex_owned(&etfs_lock));
+
+ LIST_FOREACH(et, &etfs_list, et_entries) {
+ if (strcmp(key, et->et_key) == 0) {
+ *rnp = et->et_rn;
+ rv = true;
+ break;
+ }
+ }
+
+ return rv;
+}
+
+int
+rump_etfs_register(const char *key, const char *hostpath,
+ enum rump_etfs_type ftype)
+{
+ struct etfs *et;
+ struct rumpfs_node *rn_dummy;
+ uint64_t fsize;
+ dev_t rdev;
+ devminor_t dmin;
+ int hft, error;
+
+ /* not supported for now, need r/w VOPs ... */
+ if (ftype == RUMP_ETFS_REG)
+ return EOPNOTSUPP;
+
+ if (rumpuser_getfileinfo(hostpath, &fsize, &hft, &error))
+ return error;
+
+ error = rumpblk_register(hostpath, &dmin);
+ if (error != 0) {
+ return error;
+ }
+ rdev = makedev(RUMPBLK, dmin);
+
+ et = kmem_alloc(sizeof(*et), KM_SLEEP);
+ strcpy(et->et_key, key);
+ et->et_rn = makeprivate(ettype_to_vtype(ftype), rdev, fsize);
+
+ mutex_enter(&etfs_lock);
+ if (etfs_find(key, &rn_dummy)) {
+ mutex_exit(&etfs_lock);
+ kmem_free(et, sizeof(*et));
+ /* XXX: rumpblk_deregister(hostpath); */
+ return EEXIST;
+ }
+ LIST_INSERT_HEAD(&etfs_list, et, et_entries);
+ mutex_exit(&etfs_lock);
+
+ return 0;
+}
+
+int
+rump_etfs_remove(const char *key)
+{
+ struct etfs *et;
+
+ mutex_enter(&etfs_lock);
+ LIST_FOREACH(et, &etfs_list, et_entries) {
+ if (strcmp(et->et_key, key) == 0) {
+ LIST_REMOVE(et, et_entries);
+ kmem_free(et, sizeof(*et));
+ break;
+ }
+ }
+ mutex_exit(&etfs_lock);
+
+ if (!et)
+ return ENOENT;
+ return 0;
+}
+
+/*
+ * rumpfs
+ */
+
+static struct mount rump_mnt;
+static int lastino = 1;
+static kmutex_t reclock;
+
static struct rumpfs_node *
-makeprivate(enum vtype vt, dev_t rdev, voff_t size)
+makeprivate(enum vtype vt, dev_t rdev, off_t size)
{
struct rumpfs_node *rn;
struct vattr *va;
@@ -161,46 +286,37 @@
}
static int
-rump_makevnode(const char *path, voff_t size, enum vtype vt, dev_t rdev,
- struct vnode **vpp, bool regrumpblk)
+makevnode(struct rumpfs_node *rn, struct vnode **vpp)
{
struct vnode *vp;
- struct rumpfs_node *rn;
int (**vpops)(void *);
+ struct vattr *va = &rn->rn_va;
int rv;
- if (vt == VREG || vt == VCHR || vt == VBLK) {
- vt = VBLK;
+ KASSERT(mutex_owned(&reclock));
+
+ if (va->va_type == VCHR || va->va_type == VBLK) {
vpops = rump_specop_p;
} else {
vpops = rump_vnodeop_p;
}
- if (vt != VBLK && vt != VDIR)
- panic("rump_makevnode: only VBLK/VDIR vnodes supported");
+ if (vpops != rump_specop_p && va->va_type != VDIR)
+ return EOPNOTSUPP;
rv = getnewvnode(VT_RUMP, &rump_mnt, vpops, &vp);
if (rv)
return rv;
- vp->v_size = vp->v_writesize = size;
- vp->v_type = vt;
+ vp->v_size = vp->v_writesize = va->va_size;
+ vp->v_type = va->va_type;
- if (vp->v_type == VBLK) {
- if (regrumpblk) {
- rv = rumpblk_register(path);
- if (rv == -1)
- panic("rump_makevnode: lazy bum");
- rdev = makedev(RUMPBLK, rv);
- spec_node_init(vp, rdev);
- } else {
- spec_node_init(vp, rdev);
- }
+ if (vpops == rump_specop_p) {
+ spec_node_init(vp, va->va_rdev);
}
- rn = makeprivate(vp->v_type, rdev, size);
- rn->rn_vp = vp;
vp->v_data = rn;
vn_lock(vp, LK_RETRY | LK_EXCLUSIVE);
+ rn->rn_vp = vp;
*vpp = vp;
return 0;
@@ -210,6 +326,8 @@
* Simple lookup for faking lookup of device entry for rump file systems
* and for locating/creating directories. Yes, this will panic if you
* call it with the wrong arguments.
+ *
+ * uhm, this is twisted. C F C C, hope of C C F C looming
*/
static int
rump_vop_lookup(void *v)
@@ -223,11 +341,9 @@
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct vnode *vp;
- struct rumpfs_node *rn = dvp->v_data;
- struct rumpfs_dent *rd;
- uint64_t fsize;
- enum vtype vt;
- int rv, error, ft;
+ struct rumpfs_node *rnd = dvp->v_data, *rn;
+ struct rumpfs_dent *rd = NULL;
+ int rv;
/* we handle only some "non-special" cases */
if (!(((cnp->cn_flags & ISLASTCN) == 0)
@@ -240,44 +356,23 @@
/* check if we are returning a faked block device */
if (dvp == rootvnode && cnp->cn_nameiop == LOOKUP) {
- if (rump_fakeblk_find(cnp->cn_pnbuf)) {
- rv = rumpuser_getfileinfo(cnp->cn_pnbuf, &fsize,
- &ft, &error);
- if (rv)
- return rv;
- switch (ft) {
- case RUMPUSER_FT_DIR:
- vt = VDIR;
- break;
- case RUMPUSER_FT_REG:
- vt = VREG;
- break;
- case RUMPUSER_FT_BLK:
- vt = VBLK;
- break;
- case RUMPUSER_FT_CHR:
- vt = VCHR;
- break;
- default:
- vt = VBAD;
- break;
- }
- error = rump_makevnode(cnp->cn_pnbuf, fsize, vt, -1,
- vpp, true);
- if (error)
- return error;
+ mutex_enter(&etfs_lock);
+ if (etfs_find(cnp->cn_pnbuf, &rn)) {
+ mutex_exit(&etfs_lock);
cnp->cn_consume = strlen(cnp->cn_nameptr
+ cnp->cn_namelen);
cnp->cn_flags &= ~REQUIREDIR;
-
- return 0;
+ goto getvnode;
}
+ mutex_exit(&etfs_lock);
}
- LIST_FOREACH(rd, &rn->rn_dir, rd_entries) {
- if (strncmp(rd->rd_name, cnp->cn_nameptr,
- cnp->cn_namelen) == 0)
- break;
+ if (!rd) {
+ LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) {
+ if (strncmp(rd->rd_name, cnp->cn_nameptr,
+ cnp->cn_namelen) == 0)
+ break;
+ }
}
if (!rd && ((cnp->cn_flags & ISLASTCN) == 0||cnp->cn_nameiop != CREATE))
@@ -287,19 +382,22 @@
cnp->cn_flags |= SAVENAME;
return EJUSTRETURN;
}
- KASSERT(rd);
+ rn = rd->rd_node;
+ rd = NULL;
- retry:
+ getvnode:
+ KASSERT(rn);
mutex_enter(&reclock);
- if ((vp = rd->rd_node->rn_vp)) {
+ if ((vp = rn->rn_vp)) {
mutex_enter(&vp->v_interlock);
mutex_exit(&reclock);
if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
- goto retry;
+ goto getvnode;
*vpp = vp;
} else {
- rv = rump_makevnode(cnp->cn_nameptr, DEV_BSIZE, VDIR, -1,
- vpp, false);
+ rv = makevnode(rn, vpp);
+ rn->rn_vp = *vpp;
+ mutex_exit(&reclock);
if (rv)
return rv;
}
@@ -333,12 +431,15 @@
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
- struct rumpfs_node *rnd = dvp->v_data;
+ struct rumpfs_node *rnd = dvp->v_data, *rn;
struct rumpfs_dent *rdent;
int rv = 0;
- if ((rv = rump_makevnode(cnp->cn_nameptr, DEV_BSIZE, VDIR, -1,
- vpp, false)) != 0)
+ rn = makeprivate(VDIR, NODEV, DEV_BSIZE);
+ mutex_enter(&reclock);
+ rv = makevnode(rn, vpp);
+ mutex_exit(&reclock);
+ if (rv)
goto out;
rdent = kmem_alloc(sizeof(*rdent), KM_SLEEP);
@@ -366,12 +467,15 @@
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vattr *va = ap->a_vap;
- struct rumpfs_node *rnd = dvp->v_data;
+ struct rumpfs_node *rnd = dvp->v_data, *rn;
struct rumpfs_dent *rdent;
int rv;
- if ((rv = rump_makevnode(cnp->cn_nameptr, DEV_BSIZE, va->va_type,
- va->va_rdev, vpp, false)) != 0)
+ rn = makeprivate(va->va_type, va->va_rdev, DEV_BSIZE);
+ mutex_enter(&reclock);
+ rv = makevnode(rn, vpp);
+ mutex_exit(&reclock);
+ if (rv)
goto out;
rdent = kmem_alloc(sizeof(*rdent), KM_SLEEP);
@@ -442,9 +546,11 @@
void
rumpfs_init(void)
{
+ struct rumpfs_node *rn;
int rv;
mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE);
+ mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE);
/* XXX: init properly instead of this crap */
rump_mnt.mnt_refcnt = 1;
@@ -453,7 +559,10 @@
TAILQ_INIT(&rump_mnt.mnt_vnodelist);
vfs_opv_init(rump_opv_descs);
- rv = rump_makevnode("/", 0, VDIR, -1, &rootvnode, false);
+ rn = makeprivate(VDIR, NODEV, DEV_BSIZE);
+ mutex_enter(&reclock);
+ rv = makevnode(rn, &rootvnode);
+ mutex_exit(&reclock);
if (rv)
panic("could not create root vnode: %d", rv);
rootvnode->v_vflag |= VV_ROOT;
