/* $NetBSD: p2k.c,v 1.75 2022/05/24 20:50:17 andvar Exp $ */
/*
* Copyright (c) 2007, 2008, 2009 Antti Kantee. All Rights Reserved.
*
* Development of this software was supported by the
* Finnish Cultural Foundation.
*
* 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.
*
* 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 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.
*/
/*
* puffs 2k, i.e. puffs 2 kernel. Converts the puffs protocol to
* the kernel vfs protocol and vice versa.
*
* A word about reference counting: puffs in the kernel is the king of
* reference counting. We must maintain a vnode alive and kicking
* until the kernel tells us to reclaim it. Therefore we make sure
* we never accidentally lose a vnode. Before calling operations which
* decrease the refcount we always bump the refcount up to compensate.
* Come inactive, if the file system thinks that the vnode should be
* put out of its misery, it will set the recycle flag. We use this
* to tell the kernel to reclaim the vnode. Only in reclaim do we
* really nuke the last reference.
*/
#include <sys/cdefs.h>
#include <sys/mount.h>
#include <sys/param.h>
#include <sys/lock.h>
#include <sys/namei.h>
#include <sys/dirent.h>
#include <sys/hash.h>
#include <assert.h>
#include <errno.h>
#include <puffs.h>
#include <stdlib.h>
#include <stdio.h>
#include <rump/rump.h>
#include <rump/rumpvnode_if.h>
#include <rump/p2k.h>
#include <rump/ukfs.h>
#include <uvm/uvm_pager.h>
/* NetBSD-5 compat */
#ifndef MOUNT_RUMPFS
#define MOUNT_RUMPFS "rumpfs"
#endif
PUFFSOP_PROTOS(p2k)
LIST_HEAD(p2k_vp_hash, p2k_node);
#define NHASHBUCK (1<<16)
struct p2k_mount {
struct vnode *p2m_rvp;
struct puffs_usermount *p2m_pu;
struct ukfs *p2m_ukfs;
struct p2k_vp_hash p2m_vphash[NHASHBUCK];
struct mount *p2m_mp;
int p2m_nvnodes;
int p2m_imtmpfsman;
bool p2m_hasdebug;
};
struct p2k_node {
struct puffs_node p2n_pn;
struct vnode *p2n_vp;
LIST_ENTRY(p2k_node) p2n_entries;
};
#define OPC2VP(opc) (((struct p2k_node *)opc)->p2n_vp)
static int haswizard;
static uid_t wizarduid;
static struct kauth_cred *
cred_create(const struct puffs_cred *pcr)
{
gid_t groups[NGROUPS];
uid_t uid;
gid_t gid;
short ngroups = __arraycount(groups);
if (haswizard) {
uid = wizarduid;
} else {
if (puffs_cred_getuid(pcr, &uid) == -1)
uid = 0;
}
if (puffs_cred_getgid(pcr, &gid) == -1)
gid = 0;
puffs_cred_getgroups(pcr, groups, &ngroups);
/* LINTED: ngroups is ok */
return rump_pub_cred_create(uid, gid, ngroups, groups);
}
static __inline void
cred_destroy(struct kauth_cred *cred)
{
rump_pub_cred_put(cred);
}
static struct componentname *
makecn(const struct puffs_cn *pcn)
{
struct kauth_cred *cred;
cred = cred_create(pcn->pcn_cred);
/* LINTED: prehistoric types in first two args */
return rump_pub_makecn(pcn->pcn_nameiop, pcn->pcn_flags,
pcn->pcn_name, pcn->pcn_namelen, cred, rump_pub_lwproc_curlwp());
}
static __inline void
freecn(struct componentname *cnp)
{
rump_pub_freecn(cnp, RUMPCN_FREECRED);
}
static void
makelwp(struct puffs_usermount *pu)
{
pid_t pid;
lwpid_t lid;
puffs_cc_getcaller(puffs_cc_getcc(pu), &pid, &lid);
rump_pub_allbetsareoff_setid(pid, lid);
}
static volatile sig_atomic_t dodump;
static void
dumpmp(struct puffs_usermount *pu)
{
struct puffs_statvfs svfsb;
if (dodump && p2k_fs_statvfs(pu, &svfsb) == 0) {
rump_pub_vfs_mount_print(svfsb.f_mntonname, dodump-1);
}
dodump = 0;
}
static void
sighand(int sig)
{
if (sig == SIGINFO)
dodump = 1;
else if (sig == SIGUSR1)
dodump = 2;
}
static __inline struct p2k_vp_hash *
gethash(struct p2k_mount *p2m, struct vnode *vp)
{
uint32_t hash;
hash = hash32_buf(&vp, sizeof(vp), HASH32_BUF_INIT);
return &p2m->p2m_vphash[hash % NHASHBUCK];
}
/*
* Find node based on hash of vnode pointer. If vnode is found,
* releases one reference to vnode based on the fact that we just
* performed a lookup for it.
*
* If the optinal p2n_storage parameter is passed, it is used instead
* of allocating more memory. This allows for easier error recovery.
*/
static struct p2k_node *
getp2n(struct p2k_mount *p2m, struct vnode *vp, bool initial,
struct p2k_node *p2n_storage)
{
struct p2k_vp_hash *hl;
struct p2k_node *p2n = NULL;
/* p2n_storage => initial */
assert(!p2n_storage || initial);
hl = gethash(p2m, vp);
if (!initial)
LIST_FOREACH(p2n, hl, p2n_entries)
if (p2n->p2n_vp == vp)
break;
hl = gethash(p2m, vp);
if (p2n) {
rump_pub_vp_rele(vp);
} else {
if (p2n_storage)
p2n = p2n_storage;
else
p2n = malloc(sizeof(*p2n));
if (!p2n) {
rump_pub_vp_rele(vp);
return NULL;
}
memset(p2n, 0, sizeof(*p2n));
LIST_INSERT_HEAD(hl, p2n, p2n_entries);
p2n->p2n_vp = vp;
}
return p2n;
}
static void
freep2n(struct p2k_node *p2n)
{
assert(p2n->p2n_vp == NULL);
LIST_REMOVE(p2n, p2n_entries);
free(p2n);
}
/*ARGSUSED*/
static void
p2k_errcatcher(struct puffs_usermount *pu, uint8_t type, int error,
const char *str, puffs_cookie_t cook)
{
fprintf(stderr, "type %d, error %d, cookie %p (%s)\n",
type, error, cook, str);
/*
* Trap all EINVAL responses to lookup. It most likely means
* that we supplied VNON/VBAD as the type. The real kernel
* doesn't panic from this either, but just handles it.
*/
if (type != PUFFS_VN_LOOKUP && error == EINVAL)
abort();
}
/* just to avoid annoying loop when singlestepping */
static struct p2k_mount *
allocp2m(void)
{
struct p2k_mount *p2m;
int i;
p2m = malloc(sizeof(*p2m));
if (p2m == NULL)
return NULL;
memset(p2m, 0, sizeof(*p2m));
for (i = 0; i < NHASHBUCK; i++)
LIST_INIT(&p2m->p2m_vphash[i]);
return p2m;
}
struct p2k_mount *
p2k_init(uint32_t puffs_flags)
{
struct puffs_ops *pops;
struct p2k_mount *p2m;
char *envbuf;
bool dodaemon;
bool hasdebug;
PUFFSOP_INIT(pops);
PUFFSOP_SET(pops, p2k, fs, statvfs);
PUFFSOP_SET(pops, p2k, fs, unmount);
PUFFSOP_SET(pops, p2k, fs, sync);
PUFFSOP_SET(pops, p2k, fs, fhtonode);
PUFFSOP_SET(pops, p2k, fs, nodetofh);
PUFFSOP_SET(pops, p2k, fs, extattrctl);
PUFFSOP_SET(pops, p2k, node, lookup);
PUFFSOP_SET(pops, p2k, node, create);
PUFFSOP_SET(pops, p2k, node, mknod);
PUFFSOP_SET(pops, p2k, node, open);
PUFFSOP_SET(pops, p2k, node, close);
PUFFSOP_SET(pops, p2k, node, access);
PUFFSOP_SET(pops, p2k, node, getattr);
PUFFSOP_SET(pops, p2k, node, setattr);
#if 0
PUFFSOP_SET(pops, p2k, node, poll);
#endif
PUFFSOP_SET(pops, p2k, node, mmap);
PUFFSOP_SET(pops, p2k, node, fsync);
PUFFSOP_SET(pops, p2k, node, seek);
PUFFSOP_SET(pops, p2k, node, remove);
PUFFSOP_SET(pops, p2k, node, link);
PUFFSOP_SET(pops, p2k, node, rename);
PUFFSOP_SET(pops, p2k, node, mkdir);
PUFFSOP_SET(pops, p2k, node, rmdir);
PUFFSOP_SET(pops, p2k, node, symlink);
PUFFSOP_SET(pops, p2k, node, readdir);
PUFFSOP_SET(pops, p2k, node, readlink);
PUFFSOP_SET(pops, p2k, node, read);
PUFFSOP_SET(pops, p2k, node, write);
PUFFSOP_SET(pops, p2k, node, pathconf);
PUFFSOP_SET(pops, p2k, node, inactive);
PUFFSOP_SET(pops, p2k, node, reclaim);
PUFFSOP_SET(pops, p2k, node, getextattr);
PUFFSOP_SET(pops, p2k, node, setextattr);
PUFFSOP_SET(pops, p2k, node, listextattr);
PUFFSOP_SET(pops, p2k, node, deleteextattr);
dodaemon = true;
hasdebug = false;
if (getenv("P2K_DEBUG") != NULL) {
puffs_flags |= PUFFS_FLAG_OPDUMP;
dodaemon = false;
hasdebug = true;
}
if (getenv("P2K_NODETACH") != NULL) {
dodaemon = false;
}
if (getenv("P2K_NOCACHE_PAGE") != NULL) {
puffs_flags |= PUFFS_KFLAG_NOCACHE_PAGE;
}
if (getenv("P2K_NOCACHE_NAME") != NULL) {
puffs_flags |= PUFFS_KFLAG_NOCACHE_NAME;
}
if (getenv("P2K_NOCACHE") != NULL) {
puffs_flags |= PUFFS_KFLAG_NOCACHE;
}
if ((envbuf = getenv("P2K_WIZARDUID")) != NULL) {
char *ep;
wizarduid = strtoul(envbuf, &ep, 10);
if (envbuf[0] == '\0' || *ep != '\0') {
printf("P2K_WIZARDUID: invalid uid %s\n", envbuf);
} else if (wizarduid > UID_MAX) {
printf("P2K_WIZARDUID: uid %s out-of-range\n", envbuf);
} else {
haswizard = 1;
printf("P2K WIZARD MODE: using uid %d\n", wizarduid);
}
}
/*
* Explicitly tell that our cookies can be treated as
* puffs_node, since we never let libpuffs know by
* calling call puffs_pn_new()
*/
puffs_flags |= PUFFS_FLAG_PNCOOKIE;
p2m = allocp2m();
if (p2m == NULL)
return NULL;
p2m->p2m_pu = puffs_init(pops, PUFFS_DEFER, PUFFS_DEFER,
PUFFS_DEFER, puffs_flags);
if (p2m->p2m_pu == NULL) {
int sverrno = errno;
free(p2m);
errno = sverrno;
return NULL;
}
p2m->p2m_hasdebug = hasdebug;
if (dodaemon) {
if (puffs_daemon(p2m->p2m_pu, 1, 1) == -1) {
int sverrno = errno;
p2k_cancel(p2m, sverrno);
errno = sverrno;
p2m = NULL;
}
}
if (p2m)
rump_init();
rump_pub_lwproc_rfork(RUMP_RFCFDG);
return p2m;
}
void
p2k_cancel(struct p2k_mount *p2m, int error)
{
puffs_cancel(p2m->p2m_pu, error);
free(p2m);
}
static int
setupfs(struct p2k_mount *p2m, const char *vfsname, const char *devpath,
struct ukfs_part *part, const char *mountpath, int mntflags,
void *arg, size_t alen)
{
char partpath[UKFS_DEVICE_MAXPATHLEN];
char partbuf[UKFS_DEVICE_MAXSTR];
char typebuf[PUFFS_TYPELEN];
struct puffs_usermount *pu = p2m->p2m_pu;
struct p2k_node *p2n_root;
struct ukfs *ukfs = NULL;
extern int puffs_fakecc;
int rv = -1, sverrno;
strcpy(typebuf, "p2k|");
if (strcmp(vfsname, "puffs") == 0) { /* XXX */
struct puffs_kargs *args = arg;
strlcat(typebuf, args->pa_typename, sizeof(typebuf));
} else {
strlcat(typebuf, vfsname, sizeof(typebuf));
}
strlcpy(partpath, devpath, sizeof(partpath));
if (ukfs_part_tostring(part, partbuf, sizeof(partbuf))) {
strlcat(partpath, partbuf, sizeof(partpath));
}
puffs_setmntinfo(pu, partpath, typebuf);
if (ukfs_init() == -1)
goto out;
/*
* If we're mounting rumpfs, actually do no mount and redirect
* requests to rump fs namespace root. Strictly speaking, this
* is not correct, but I don't think anyone will notice.
* After all, we're mostly interested in things which reside
* specifically on the rootfs, namely the contents of /dev
*/
if (strcmp(vfsname, MOUNT_RUMPFS) == 0) {
if ((rv = rump_pub_vfs_getmp("/", &p2m->p2m_mp)) != 0) {
errno = rv;
rv = -1;
goto out;
}
} else {
if (part != ukfs_part_na)
ukfs = ukfs_mount_disk(vfsname, devpath, part,
mountpath, mntflags, arg, alen);
else
ukfs = ukfs_mount(vfsname, devpath, mountpath, mntflags,
arg, alen);
if (ukfs == NULL)
goto out;
ukfs_setspecific(ukfs, p2m);
p2m->p2m_ukfs = ukfs;
p2m->p2m_mp = ukfs_getmp(ukfs);
}
if ((rv = rump_pub_vfs_root(p2m->p2m_mp, &p2m->p2m_rvp, 0)) != 0) {
errno = rv;
rv = -1;
goto out;
}
p2m->p2m_pu = pu;
/*
* Detect tmpfs. XXX: this is a kludge. See inactive().
*
* In reality we'd want "does file system use anon objects
* for storage?". But since tmpfs hides the anon object from
* the public interface, we can't actually detect it sanely.
* Therefore, use this kludge.
*/
p2m->p2m_imtmpfsman = strcmp(vfsname, MOUNT_TMPFS) == 0;
p2n_root = getp2n(p2m, p2m->p2m_rvp, true, NULL);
puffs_setfhsize(pu, 0, PUFFS_FHFLAG_PASSTHROUGH);
puffs_setstacksize(pu, PUFFS_STACKSIZE_MIN);
puffs_fakecc = 1;
puffs_set_prepost(pu, makelwp, NULL);
if (p2m->p2m_hasdebug) {
struct timespec ts;
signal(SIGINFO, sighand);
signal(SIGUSR1, sighand);
ts.tv_sec = 0;
ts.tv_nsec = 1000*1000*10; /* 10ms */
puffs_ml_setloopfn(pu, dumpmp);
puffs_ml_settimeout(pu, &ts);
}
puffs_set_errnotify(pu, p2k_errcatcher);
puffs_setspecific(pu, p2m);
rv = puffs_mount(pu, mountpath, mntflags, p2n_root);
out:
if (rv == -1) {
sverrno = errno;
puffs_cancel(pu, sverrno);
if (ukfs)
ukfs_release(p2m->p2m_ukfs, UKFS_RELFLAG_FORCE);
free(p2m);
errno = sverrno;
}
return rv;
}
int
p2k_mainloop(struct p2k_mount *p2m)
{
int rv, sverrno;
rv = puffs_mainloop(p2m->p2m_pu);
sverrno = errno;
puffs_exit(p2m->p2m_pu, 1);
if (p2m->p2m_ukfs)
ukfs_release(p2m->p2m_ukfs, UKFS_RELFLAG_FORCE);
free(p2m);
if (rv == -1)
errno = sverrno;
return rv;
}
int
p2k_run_fs(const char *vfsname, const char *devpath, const char *mountpath,
int mntflags, void *arg, size_t alen, uint32_t puffs_flags)
{
struct p2k_mount *p2m;
int rv;
p2m = p2k_init(puffs_flags);
if (p2m == NULL)
return -1;
rv = setupfs(p2m, vfsname, devpath, ukfs_part_na, mountpath,
mntflags, arg, alen);
if (rv == -1)
return rv;
return p2k_mainloop(p2m);
}
int
p2k_run_diskfs(const char *vfsname, const char *devpath, struct ukfs_part *part,
const char *mountpath, int mntflags, void *arg, size_t alen,
uint32_t puffs_flags)
{
struct p2k_mount *p2m;
int rv;
p2m = p2k_init(puffs_flags);
if (p2m == NULL)
return -1;
rv = setupfs(p2m, vfsname, devpath, part, mountpath, mntflags,
arg, alen);
if (rv == -1)
return rv;
return p2k_mainloop(p2m);
}
int
p2k_setup_fs(struct p2k_mount *p2m, const char *vfsname, const char *devpath,
const char *mountpath, int mntflags, void *arg, size_t alen)
{
return setupfs(p2m, vfsname, devpath, ukfs_part_na, mountpath,
mntflags, arg, alen);
}
int
p2k_setup_diskfs(struct p2k_mount *p2m, const char *vfsname,
const char *devpath, struct ukfs_part *part, const char *mountpath,
int mntflags, void *arg, size_t alen)
{
return setupfs(p2m, vfsname, devpath, part, mountpath, mntflags,
arg, alen);
}
int
p2k_fs_statvfs(struct puffs_usermount *pu, struct puffs_statvfs *sbp)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct mount *mp = p2m->p2m_mp;
struct statvfs sb;
puffs_statvfs_to_statvfs(sbp, &sb);
return rump_pub_vfs_statvfs(mp, &sb);
}
/*ARGSUSED*/
int
p2k_fs_unmount(struct puffs_usermount *pu, int flags)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct ukfs *fs = p2m->p2m_ukfs;
int error = 0;
rump_pub_vp_rele(p2m->p2m_rvp);
if (fs) {
if (ukfs_release(fs, 0) != 0) {
struct puffs_statvfs svfsb;
if (p2m->p2m_hasdebug
&& p2k_fs_statvfs(pu, &svfsb) == 0) {
printf("\nSOFT UNMOUNT FAILED, MP INFO DUMP\n");
rump_pub_vfs_mount_print(svfsb.f_mntonname, 1);
}
ukfs_release(fs, UKFS_RELFLAG_FORCE);
error = 0;
}
}
p2m->p2m_ukfs = NULL;
if (p2m->p2m_hasdebug) {
printf("-- rump kernel event counters --\n");
rump_printevcnts();
printf("-- end of event counters --\n");
}
return error;
}
int
p2k_fs_sync(struct puffs_usermount *pu, int waitfor,
const struct puffs_cred *pcr)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct mount *mp = p2m->p2m_mp;
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
rv = rump_pub_vfs_sync(mp, waitfor, cred);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_fs_fhtonode(struct puffs_usermount *pu, void *fid, size_t fidsize,
struct puffs_newinfo *pni)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct mount *mp = p2m->p2m_mp;
struct p2k_node *p2n;
struct vnode *vp;
enum rump_vtype vtype;
voff_t vsize;
uint64_t rdev; /* XXX: allows running this on NetBSD 5.0 */
int rv;
rv = rump_pub_vfs_fhtovp(mp, fid, &vp);
if (rv)
return rv;
RUMP_VOP_UNLOCK(vp);
p2n = getp2n(p2m, vp, false, NULL);
if (p2n == NULL)
return ENOMEM;
puffs_newinfo_setcookie(pni, p2n);
rump_pub_getvninfo(vp, &vtype, &vsize, (void *)&rdev);
puffs_newinfo_setvtype(pni, (enum vtype)vtype);
puffs_newinfo_setsize(pni, vsize);
/* LINTED: yea, it'll lose accuracy, but that's life */
puffs_newinfo_setrdev(pni, rdev);
return 0;
}
/*ARGSUSED*/
int
p2k_fs_nodetofh(struct puffs_usermount *pu, puffs_cookie_t cookie, void *fid,
size_t *fidsize)
{
struct vnode *vp = OPC2VP(cookie);
return rump_pub_vfs_vptofh(vp, fid, fidsize);
}
int
p2k_fs_extattrctl(struct puffs_usermount *pu, int cmd,
puffs_cookie_t cookie, int flags,
int attrnamespace, const char *attrname)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct mount *mp = p2m->p2m_mp;
struct vnode *vp;
if (flags & PUFFS_EXTATTRCTL_HASNODE) {
vp = OPC2VP(cookie);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE | LK_RETRY);
} else {
vp = NULL;
}
/* vfsop unlocks (but doesn't release) vnode, so we're done here */
return rump_pub_vfs_extattrctl(mp, cmd, vp, attrnamespace, attrname);
}
/*ARGSUSED*/
int
p2k_node_lookup(struct puffs_usermount *pu, puffs_cookie_t opc,
struct puffs_newinfo *pni, const struct puffs_cn *pcn)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct p2k_node *p2n_dir = opc, *p2n;
struct componentname *cn;
struct vnode *dvp = p2n_dir->p2n_vp, *vp;
enum rump_vtype vtype;
voff_t vsize;
uint64_t rdev; /* XXX: uint64_t because of stack overwrite in compat */
int rv;
cn = makecn(pcn);
RUMP_VOP_LOCK(dvp, LK_EXCLUSIVE);
rv = RUMP_VOP_LOOKUP(dvp, &vp, cn);
RUMP_VOP_UNLOCK(dvp);
freecn(cn);
if (rv) {
if (rv == RUMP_EJUSTRETURN) {
rv = ENOENT;
}
return rv;
}
p2n = getp2n(p2m, vp, false, NULL);
if (p2n == NULL) {
return ENOMEM;
}
puffs_newinfo_setcookie(pni, p2n);
rump_pub_getvninfo(vp, &vtype, &vsize, (void *)&rdev);
puffs_newinfo_setvtype(pni, (enum vtype)vtype);
puffs_newinfo_setsize(pni, vsize);
/* LINTED: yea, it'll lose accuracy, but that's life */
puffs_newinfo_setrdev(pni, rdev);
return 0;
}
#define VERS_TIMECHANGE 599000700
static int
needcompat(void)
{
/*LINTED*/
return __NetBSD_Version__ < VERS_TIMECHANGE
&& rump_getversion() >= VERS_TIMECHANGE;
}
#define DOCOMPAT(va, va_compat) \
do { \
if (needcompat()) { \
va_compat = rump_pub_vattr_init(); \
rump_pub_vattr50_to_vattr(va, va_compat); \
} else { \
va_compat = __UNCONST(va); \
} \
} while (0)
#define UNDOCOMPAT(va_compat) \
do { \
if (needcompat()) \
rump_pub_vattr_free(va_compat); \
} while (0)
static int
do_makenode(struct puffs_usermount *pu, struct p2k_node *p2n_dir,
struct puffs_newinfo *pni, const struct puffs_cn *pcn,
const struct vattr *vap, char *link_target,
int (*makefn)(struct vnode *, struct vnode **, struct componentname *,
struct vattr *),
int (*symfn)(struct vnode *, struct vnode **, struct componentname *,
struct vattr *, char *))
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct vnode *dvp = p2n_dir->p2n_vp;
struct p2k_node *p2n;
struct componentname *cn;
struct vattr *va_x;
struct vnode *vp = NULL;
int rv;
p2n = malloc(sizeof(*p2n));
if (p2n == NULL)
return ENOMEM;
DOCOMPAT(vap, va_x);
cn = makecn(pcn);
RUMP_VOP_LOCK(dvp, LK_EXCLUSIVE);
rump_pub_vp_incref(dvp);
if (makefn) {
rv = makefn(dvp, &vp, cn, va_x);
} else {
rv = symfn(dvp, &vp, cn, va_x, link_target);
}
rump_pub_vp_rele(dvp);
RUMP_VOP_UNLOCK(dvp);
freecn(cn);
if (rv == 0) {
p2n = getp2n(p2m, vp, true, p2n);
puffs_newinfo_setcookie(pni, p2n);
} else {
free(p2n);
}
UNDOCOMPAT(va_x);
return rv;
}
/*ARGSUSED*/
int
p2k_node_create(struct puffs_usermount *pu, puffs_cookie_t opc,
struct puffs_newinfo *pni, const struct puffs_cn *pcn,
const struct vattr *vap)
{
return do_makenode(pu, opc, pni, pcn, vap, NULL, RUMP_VOP_CREATE, NULL);
}
/*ARGSUSED*/
int
p2k_node_mknod(struct puffs_usermount *pu, puffs_cookie_t opc,
struct puffs_newinfo *pni, const struct puffs_cn *pcn,
const struct vattr *vap)
{
return do_makenode(pu, opc, pni, pcn, vap, NULL, RUMP_VOP_MKNOD, NULL);
}
/*ARGSUSED*/
int
p2k_node_open(struct puffs_usermount *pu, puffs_cookie_t opc, int mode,
const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_OPEN(vp, mode, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_close(struct puffs_usermount *pu, puffs_cookie_t opc, int flags,
const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
RUMP_VOP_CLOSE(vp, flags, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return 0;
}
/*ARGSUSED*/
int
p2k_node_access(struct puffs_usermount *pu, puffs_cookie_t opc, int mode,
const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_ACCESS(vp, mode, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_getattr(struct puffs_usermount *pu, puffs_cookie_t opc,
struct vattr *vap, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct vattr *va_x;
int rv;
/* "deadfs" */
if (!vp)
return 0;
if (needcompat()) {
va_x = rump_pub_vattr_init();
} else {
va_x = vap;
}
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_GETATTR(vp, va_x, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
if (needcompat()) {
rump_pub_vattr_to_vattr50(va_x, vap);
rump_pub_vattr_free(va_x);
}
return rv;
}
/*ARGSUSED*/
int
p2k_node_setattr(struct puffs_usermount *pu, puffs_cookie_t opc,
const struct vattr *vap, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct vattr *va_x;
int rv;
/* "deadfs" */
if (!vp)
return 0;
DOCOMPAT(vap, va_x);
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_SETATTR(vp, va_x, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
UNDOCOMPAT(va_x);
return rv;
}
/*ARGSUSED*/
int
p2k_node_fsync(struct puffs_usermount *pu, puffs_cookie_t opc,
const struct puffs_cred *pcr, int flags, off_t offlo, off_t offhi)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
int rv;
/* "deadfs" */
if (!vp)
return 0;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_FSYNC(vp, cred, flags, offlo, offhi);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_mmap(struct puffs_usermount *pu, puffs_cookie_t opc, vm_prot_t flags,
const struct puffs_cred *pcr)
{
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
rv = RUMP_VOP_MMAP(OPC2VP(opc), flags, cred);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_seek(struct puffs_usermount *pu, puffs_cookie_t opc,
off_t oldoff, off_t newoff, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_SEEK(vp, oldoff, newoff, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return rv;
}
static int
do_nukenode(struct p2k_node *p2n_dir, struct p2k_node *p2n,
const struct puffs_cn *pcn,
int (*nukefn)(struct vnode *, struct vnode *, struct componentname *))
{
struct vnode *dvp = p2n_dir->p2n_vp, *vp = p2n->p2n_vp;
struct componentname *cn;
int rv;
cn = makecn(pcn);
RUMP_VOP_LOCK(dvp, LK_EXCLUSIVE);
rump_pub_vp_incref(dvp);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rump_pub_vp_incref(vp);
rv = nukefn(dvp, vp, cn);
assert(dvp != vp);
assert(RUMP_VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
assert(RUMP_VOP_ISLOCKED(vp) == 0);
rump_pub_vp_rele(dvp);
RUMP_VOP_UNLOCK(dvp);
freecn(cn);
return rv;
}
/*ARGSUSED*/
int
p2k_node_remove(struct puffs_usermount *pu, puffs_cookie_t opc,
puffs_cookie_t targ, const struct puffs_cn *pcn)
{
return do_nukenode(opc, targ, pcn, RUMP_VOP_REMOVE);
}
/*ARGSUSED*/
int
p2k_node_link(struct puffs_usermount *pu, puffs_cookie_t opc,
puffs_cookie_t targ, const struct puffs_cn *pcn)
{
struct vnode *dvp = OPC2VP(opc);
struct componentname *cn;
int rv;
cn = makecn(pcn);
RUMP_VOP_LOCK(dvp, LK_EXCLUSIVE);
rump_pub_vp_incref(dvp);
rv = RUMP_VOP_LINK(dvp, OPC2VP(targ), cn);
rump_pub_vp_rele(dvp);
RUMP_VOP_UNLOCK(dvp);
freecn(cn);
return rv;
}
/*ARGSUSED*/
int
p2k_node_rename(struct puffs_usermount *pu,
puffs_cookie_t src_dir, puffs_cookie_t src,
const struct puffs_cn *pcn_src,
puffs_cookie_t targ_dir, puffs_cookie_t targ,
const struct puffs_cn *pcn_targ)
{
struct vnode *dvp, *vp, *tdvp, *tvp = NULL;
struct componentname *cn_src, *cn_targ;
int rv;
cn_src = makecn(pcn_src);
cn_targ = makecn(pcn_targ);
dvp = OPC2VP(src_dir);
vp = OPC2VP(src);
tdvp = OPC2VP(targ_dir);
if (targ) {
tvp = OPC2VP(targ);
}
rump_pub_vp_incref(dvp);
rump_pub_vp_incref(vp);
RUMP_VOP_LOCK(tdvp, LK_EXCLUSIVE);
rump_pub_vp_incref(tdvp);
if (tvp) {
RUMP_VOP_LOCK(tvp, LK_EXCLUSIVE);
rump_pub_vp_incref(tvp);
}
rv = RUMP_VOP_RENAME(dvp, vp, cn_src, tdvp, tvp, cn_targ);
assert(RUMP_VOP_ISLOCKED(tdvp) == 0);
if (tvp) {
assert(RUMP_VOP_ISLOCKED(tvp) == 0);
}
freecn(cn_src);
freecn(cn_targ);
return rv;
}
/*ARGSUSED*/
int
p2k_node_mkdir(struct puffs_usermount *pu, puffs_cookie_t opc,
struct puffs_newinfo *pni, const struct puffs_cn *pcn,
const struct vattr *vap)
{
return do_makenode(pu, opc, pni, pcn, vap, NULL, RUMP_VOP_MKDIR, NULL);
}
/*ARGSUSED*/
int
p2k_node_rmdir(struct puffs_usermount *pu, puffs_cookie_t opc,
puffs_cookie_t targ, const struct puffs_cn *pcn)
{
return do_nukenode(opc, targ, pcn, RUMP_VOP_RMDIR);
}
/*ARGSUSED*/
int
p2k_node_symlink(struct puffs_usermount *pu, puffs_cookie_t opc,
struct puffs_newinfo *pni, const struct puffs_cn *pcn,
const struct vattr *vap, const char *link_target)
{
return do_makenode(pu, opc, pni, pcn, vap,
__UNCONST(link_target), NULL, RUMP_VOP_SYMLINK);
}
/*ARGSUSED*/
int
p2k_node_readdir(struct puffs_usermount *pu, puffs_cookie_t opc,
struct dirent *dent, off_t *readoff, size_t *reslen,
const struct puffs_cred *pcr, int *eofflag,
off_t *cookies, size_t *ncookies)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
off_t *vop_cookies;
int vop_ncookies;
int rv;
cred = cred_create(pcr);
uio = rump_pub_uio_setup(dent, *reslen, *readoff, RUMPUIO_READ);
RUMP_VOP_LOCK(vp, LK_SHARED);
if (cookies) {
rv = RUMP_VOP_READDIR(vp, uio, cred, eofflag,
&vop_cookies, &vop_ncookies);
memcpy(cookies, vop_cookies, vop_ncookies * sizeof(*cookies));
*ncookies = vop_ncookies;
free(vop_cookies);
} else {
rv = RUMP_VOP_READDIR(vp, uio, cred, eofflag, NULL, NULL);
}
RUMP_VOP_UNLOCK(vp);
if (rv == 0) {
*reslen = rump_pub_uio_getresid(uio);
*readoff = rump_pub_uio_getoff(uio);
}
rump_pub_uio_free(uio);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_readlink(struct puffs_usermount *pu, puffs_cookie_t opc,
const struct puffs_cred *pcr, char *linkname, size_t *linklen)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
cred = cred_create(pcr);
uio = rump_pub_uio_setup(linkname, *linklen, 0, RUMPUIO_READ);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_READLINK(vp, uio, cred);
RUMP_VOP_UNLOCK(vp);
*linklen -= rump_pub_uio_free(uio);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_read(struct puffs_usermount *pu, puffs_cookie_t opc,
uint8_t *buf, off_t offset, size_t *resid,
const struct puffs_cred *pcr, int ioflag)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
cred = cred_create(pcr);
uio = rump_pub_uio_setup(buf, *resid, offset, RUMPUIO_READ);
RUMP_VOP_LOCK(vp, LK_SHARED);
rv = RUMP_VOP_READ(vp, uio, ioflag, cred);
RUMP_VOP_UNLOCK(vp);
*resid = rump_pub_uio_free(uio);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_write(struct puffs_usermount *pu, puffs_cookie_t opc,
uint8_t *buf, off_t offset, size_t *resid,
const struct puffs_cred *pcr, int ioflag)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
/* "deadfs" */
if (!vp)
return 0;
cred = cred_create(pcr);
uio = rump_pub_uio_setup(buf, *resid, offset, RUMPUIO_WRITE);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_WRITE(vp, uio, ioflag, cred);
RUMP_VOP_UNLOCK(vp);
*resid = rump_pub_uio_free(uio);
cred_destroy(cred);
return rv;
}
/*ARGSUSED*/
int
p2k_node_pathconf(struct puffs_usermount *pu, puffs_cookie_t opc,
int name, register_t *retval)
{
struct vnode *vp = OPC2VP(opc);
int rv;
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_PATHCONF(vp, name, retval);
RUMP_VOP_UNLOCK(vp);
return rv;
}
/*ARGSUSED*/
int
p2k_node_getextattr(struct puffs_usermount *pu, puffs_cookie_t opc,
int attrnamespace, const char *attrname, size_t *attrsize,
uint8_t *attr, size_t *resid, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
if (attr)
uio = rump_pub_uio_setup(attr, *resid, 0, RUMPUIO_READ);
else
uio = NULL;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_GETEXTATTR(vp, attrnamespace, attrname, uio,
attrsize, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
if (uio)
*resid = rump_pub_uio_free(uio);
return rv;
}
/*ARGSUSED*/
int
p2k_node_setextattr(struct puffs_usermount *pu, puffs_cookie_t opc,
int attrnamespace, const char *attrname,
uint8_t *attr, size_t *resid, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
if (attr)
uio = rump_pub_uio_setup(attr, *resid, 0, RUMPUIO_READ);
else
uio = NULL;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_SETEXTATTR(vp, attrnamespace, attrname, uio, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
if (uio)
*resid = rump_pub_uio_free(uio);
return rv;
}
/*ARGSUSED*/
int
p2k_node_listextattr(struct puffs_usermount *pu, puffs_cookie_t opc,
int attrnamespace, size_t *attrsize, uint8_t *attrs,
size_t *resid, int flags, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
struct uio *uio;
int rv;
if (attrs)
uio = rump_pub_uio_setup(attrs, *resid, 0, RUMPUIO_READ);
else
uio = NULL;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_LISTEXTATTR(vp, attrnamespace, uio, attrsize,
flags, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
if (uio)
*resid = rump_pub_uio_free(uio);
return rv;
}
/*ARGSUSED*/
int
p2k_node_deleteextattr(struct puffs_usermount *pu, puffs_cookie_t opc,
int attrnamespace, const char *attrname, const struct puffs_cred *pcr)
{
struct vnode *vp = OPC2VP(opc);
struct kauth_cred *cred;
int rv;
cred = cred_create(pcr);
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_DELETEEXTATTR(vp, attrnamespace, attrname, cred);
RUMP_VOP_UNLOCK(vp);
cred_destroy(cred);
return rv;
}
/* the kernel releases its last reference here */
int
p2k_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
{
struct p2k_mount *p2m = puffs_getspecific(pu);
struct p2k_node *p2n = opc;
struct vnode *vp = OPC2VP(opc);
bool recycle = false;
int rv;
/* deadfs */
if (!vp)
return 0;
/*
* Flush all cached vnode pages from the rump kernel -- they
* are kept in puffs for all things that matter. However,
* don't do this for tmpfs (vnodes are backed by an aobj), since that
* would cause us to clear the backing storage leaving us without
* a way to regain the data from "stable storage".
*/
if (!p2m->p2m_imtmpfsman) {
rump_pub_vp_vmobjlock(vp, 1);
RUMP_VOP_PUTPAGES(vp, 0, 0,
PGO_ALLPAGES|PGO_CLEANIT|PGO_FREE);
}
/*
* Ok, this is where we get nasty. We pretend the vnode is
* inactive and already tell the file system that. However,
* we are allowed to pretend it also grows a reference immediately
* after per vget(), so this does not do harm. Cheap trick, but ...
*
* If the file system thinks the inode is done for, we release
* our reference and clear all knowledge of the vnode. If,
* however, the inode is still active, we retain our reference
* until reclaim, since puffs might be flushing out some data
* later.
*/
RUMP_VOP_LOCK(vp, LK_EXCLUSIVE);
rv = RUMP_VOP_INACTIVE(vp, &recycle);
RUMP_VOP_UNLOCK(vp);
if (recycle) {
puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
rump_pub_vp_rele(p2n->p2n_vp);
p2n->p2n_vp = NULL;
}
return rv;
}
/*ARGSUSED*/
int
p2k_node_reclaim(struct puffs_usermount *pu, puffs_croissant_t opc)
{
struct p2k_node *p2n = opc;
if (p2n->p2n_vp) {
rump_pub_vp_rele(p2n->p2n_vp);
p2n->p2n_vp = NULL;
}
freep2n(p2n);
return 0;
}
