* Copyright (c) 2009, 2010, 2011 Antti Kantee. All Rights Reserved.

/* $NetBSD: rumpfs.c,v 1.167 2023/06/27 19:30:27 andvar Exp $ */

/*
* Copyright (c) 2009, 2010, 2011 Antti Kantee. 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.
* 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.167 2023/06/27 19:30:27 andvar Exp $");

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/buf.h>
#include <sys/dirent.h>
#include <sys/errno.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/kauth.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/lock.h>
#include <sys/lockf.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <sys/syscallargs.h>
#include <sys/vnode.h>
#include <sys/fstrans.h>
#include <sys/unistd.h>

#include <miscfs/specfs/specdev.h>
#include <miscfs/genfs/genfs.h>
#include <miscfs/genfs/genfs_node.h>

#include <uvm/uvm_extern.h>

#include <rump-sys/kern.h>
#include <rump-sys/vfs.h>

#include <rump/rumpfs.h>
#include <rump/rumpuser.h>

static int rump_vop_parsepath(void *);
static int rump_vop_lookup(void *);
static int rump_vop_getattr(void *);
static int rump_vop_setattr(void *);
static int rump_vop_mkdir(void *);
static int rump_vop_rmdir(void *);
static int rump_vop_remove(void *);
static int rump_vop_mknod(void *);
static int rump_vop_create(void *);
static int rump_vop_inactive(void *);
static int rump_vop_reclaim(void *);
static int rump_vop_success(void *);
static int rump_vop_readdir(void *);
static int rump_vop_spec(void *);
static int rump_vop_read(void *);
static int rump_vop_write(void *);
static int rump_vop_open(void *);
static int rump_vop_symlink(void *);
static int rump_vop_readlink(void *);
static int rump_vop_whiteout(void *);
static int rump_vop_pathconf(void *);
static int rump_vop_bmap(void *);
static int rump_vop_strategy(void *);
static int rump_vop_advlock(void *);
static int rump_vop_access(void *);
static int rump_vop_fcntl(void *);

int (**rump_vnodeop_p)(void *);
const struct vnodeopv_entry_desc rump_vnodeop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_parsepath_desc, rump_vop_parsepath },
{ &vop_lookup_desc, rump_vop_lookup },
{ &vop_getattr_desc, rump_vop_getattr },
{ &vop_setattr_desc, rump_vop_setattr },
{ &vop_mkdir_desc, rump_vop_mkdir },
{ &vop_rmdir_desc, rump_vop_rmdir },
{ &vop_remove_desc, rump_vop_remove },
{ &vop_mknod_desc, rump_vop_mknod },
{ &vop_create_desc, rump_vop_create },
{ &vop_symlink_desc, rump_vop_symlink },
{ &vop_readlink_desc, rump_vop_readlink },
{ &vop_access_desc, rump_vop_access },
{ &vop_accessx_desc, genfs_accessx },
{ &vop_readdir_desc, rump_vop_readdir },
{ &vop_read_desc, rump_vop_read },
{ &vop_write_desc, rump_vop_write },
{ &vop_open_desc, rump_vop_open },
{ &vop_close_desc, genfs_nullop },
{ &vop_seek_desc, genfs_seek },
{ &vop_getpages_desc, genfs_getpages },
{ &vop_putpages_desc, genfs_putpages },
{ &vop_whiteout_desc, rump_vop_whiteout },
{ &vop_fsync_desc, rump_vop_success },
{ &vop_lock_desc, genfs_lock },
{ &vop_unlock_desc, genfs_unlock },
{ &vop_islocked_desc, genfs_islocked },
{ &vop_inactive_desc, rump_vop_inactive },
{ &vop_reclaim_desc, rump_vop_reclaim },
{ &vop_link_desc, genfs_eopnotsupp },
{ &vop_pathconf_desc, rump_vop_pathconf },
{ &vop_bmap_desc, rump_vop_bmap },
{ &vop_strategy_desc, rump_vop_strategy },
{ &vop_advlock_desc, rump_vop_advlock },
{ &vop_fcntl_desc, rump_vop_fcntl },
{ NULL, NULL }
};
const struct vnodeopv_desc rump_vnodeop_opv_desc =
{ &rump_vnodeop_p, rump_vnodeop_entries };

int (**rump_specop_p)(void *);
const struct vnodeopv_entry_desc rump_specop_entries[] = {
{ &vop_default_desc, rump_vop_spec },
{ NULL, NULL }
};
const struct vnodeopv_desc rump_specop_opv_desc =
{ &rump_specop_p, rump_specop_entries };

const struct vnodeopv_desc * const rump_opv_descs[] = {
&rump_vnodeop_opv_desc,
&rump_specop_opv_desc,
NULL
};

#define RUMPFS_WHITEOUT ((void *)-1)
#define RDENT_ISWHITEOUT(rdp) (rdp->rd_node == RUMPFS_WHITEOUT)
struct rumpfs_dent {
char *rd_name;
int rd_namelen;
struct rumpfs_node *rd_node;

LIST_ENTRY(rumpfs_dent) rd_entries;
};

struct genfs_ops rumpfs_genfsops = {
.gop_size = genfs_size,
.gop_write = genfs_gop_write,
.gop_putrange = genfs_gop_putrange,

/* optional */
.gop_alloc = NULL,
.gop_markupdate = NULL,
};

struct rumpfs_node {
struct genfs_node rn_gn;
struct vattr rn_va;
struct vnode *rn_vp;
char *rn_hostpath;
int rn_flags;
struct lockf *rn_lockf;

union {
struct { /* VREG */
int readfd;
int writefd;
uint64_t offset;
} reg;
struct {
void *data;
size_t dlen;
} reg_noet;
struct { /* VDIR */
LIST_HEAD(, rumpfs_dent) dents;
struct rumpfs_node *parent;
int flags;
} dir;
struct {
char *target;
size_t len;
} link;
} rn_u;
};
#define rn_readfd rn_u.reg.readfd
#define rn_writefd rn_u.reg.writefd
#define rn_offset rn_u.reg.offset
#define rn_data rn_u.reg_noet.data
#define rn_dlen rn_u.reg_noet.dlen
#define rn_dir rn_u.dir.dents
#define rn_parent rn_u.dir.parent
#define rn_linktarg rn_u.link.target
#define rn_linklen rn_u.link.len

#define RUMPNODE_CANRECLAIM 0x01
#define RUMPNODE_DIR_ET 0x02
#define RUMPNODE_DIR_ETSUBS 0x04
#define RUMPNODE_ET_PHONE_HOST 0x10
#define RUMPNODE_EXTSTORAGE 0x20

struct rumpfs_mount {
struct vnode *rfsmp_rvp;
};

#define INO_WHITEOUT 1
static int lastino = 2;
static kmutex_t reclock;

#define RUMPFS_DEFAULTMODE 0755
static void freedir(struct rumpfs_node *, struct componentname *);
static struct rumpfs_node *makeprivate(enum vtype, mode_t, dev_t, off_t, bool);
static void freeprivate(struct rumpfs_node *);

/*
* 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];
size_t et_keylen;
bool et_prefixkey;
bool et_removing;
devminor_t et_blkmin;

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;
case RUMP_ETFS_DIR:
vt = VDIR;
break;
case RUMP_ETFS_DIR_SUBDIRS:
vt = VDIR;
break;
default:
panic("invalid et type: %d", et);
}

return vt;
}

static enum vtype
hft_to_vtype(int hft)
{
enum vtype vt;

switch (hft) {
case RUMPUSER_FT_OTHER:
vt = VNON;
break;
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 = VNON;
break;
}

return vt;
}

static bool
etfs_find(const char *key, struct etfs **etp, bool forceprefix)
{
struct etfs *et;
size_t keylen = strlen(key);

KASSERT(mutex_owned(&etfs_lock));

LIST_FOREACH(et, &etfs_list, et_entries) {
if ((keylen == et->et_keylen || et->et_prefixkey || forceprefix)
&& strncmp(key, et->et_key, et->et_keylen) == 0) {
if (etp)
*etp = et;
return true;
}
}

return false;
}

#define REGDIR(ftype) \
((ftype) == RUMP_ETFS_DIR || (ftype) == RUMP_ETFS_DIR_SUBDIRS)
static int
etfsregister(const char *key, const char *hostpath,
enum rump_etfs_type ftype, uint64_t begin, uint64_t size)
{
char buf[9];
struct etfs *et;
struct rumpfs_node *rn;
uint64_t fsize;
dev_t rdev = NODEV;
devminor_t dmin = -1;
int hft, error;

if (key[0] != '/') {
return EINVAL;
}
while (key[0] == '/') {
key++;
}

if ((error = rumpuser_getfileinfo(hostpath, &fsize, &hft)) != 0)
return error;

/* etfs directory requires a directory on the host */
if (REGDIR(ftype)) {
if (hft != RUMPUSER_FT_DIR)
return ENOTDIR;
if (begin != 0)
return EISDIR;
if (size != RUMP_ETFS_SIZE_ENDOFF)
return EISDIR;
size = fsize;
} else {
if (begin > fsize)
return EINVAL;
if (size == RUMP_ETFS_SIZE_ENDOFF)
size = fsize - begin;
if (begin + size > fsize)
return EINVAL;
}

if (ftype == RUMP_ETFS_BLK || ftype == RUMP_ETFS_CHR) {
error = rumpblk_register(hostpath, &dmin, begin, size);
if (error != 0) {
return error;
}
rdev = makedev(RUMPBLK_DEVMAJOR, dmin);
}

et = kmem_alloc(sizeof(*et), KM_SLEEP);
strcpy(et->et_key, key);
et->et_keylen = strlen(et->et_key);
et->et_rn = rn = makeprivate(ettype_to_vtype(ftype), RUMPFS_DEFAULTMODE,
rdev, size, true);
et->et_removing = false;
et->et_blkmin = dmin;

rn->rn_flags |= RUMPNODE_ET_PHONE_HOST;

if (ftype == RUMP_ETFS_REG || REGDIR(ftype) || et->et_blkmin != -1) {
size_t len = strlen(hostpath)+1;

rn->rn_hostpath = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
memcpy(rn->rn_hostpath, hostpath, len);
rn->rn_offset = begin;
}

if (REGDIR(ftype)) {
rn->rn_flags |= RUMPNODE_DIR_ET;
et->et_prefixkey = true;
} else {
et->et_prefixkey = false;
}

if (ftype == RUMP_ETFS_DIR_SUBDIRS)
rn->rn_flags |= RUMPNODE_DIR_ETSUBS;

mutex_enter(&etfs_lock);
if (etfs_find(key, NULL, REGDIR(ftype))) {
mutex_exit(&etfs_lock);
if (et->et_blkmin != -1)
rumpblk_deregister(hostpath);
if (et->et_rn->rn_hostpath != NULL)
free(et->et_rn->rn_hostpath, M_TEMP);
freeprivate(et->et_rn);
kmem_free(et, sizeof(*et));
return EEXIST;
}
LIST_INSERT_HEAD(&etfs_list, et, et_entries);
mutex_exit(&etfs_lock);

if (ftype == RUMP_ETFS_BLK) {
format_bytes(buf, sizeof(buf), size);
aprint_verbose("/%s: hostpath %s (%s)\n", key, hostpath, buf);
}

return 0;
}
#undef REGDIR

/* remove etfs mapping. caller's responsibility to make sure it's not in use */
static int
etfsremove(const char *key)
{
struct etfs *et;
size_t keylen;
int rv __diagused;

if (key[0] != '/') {
return EINVAL;
}
while (key[0] == '/') {
key++;
}

keylen = strlen(key);

mutex_enter(&etfs_lock);
LIST_FOREACH(et, &etfs_list, et_entries) {
if (keylen == et->et_keylen && strcmp(et->et_key, key) == 0) {
if (et->et_removing)
et = NULL;
else
et->et_removing = true;
break;
}
}
mutex_exit(&etfs_lock);
if (!et)
return ENOENT;

/*
* ok, we know what we want to remove and have signalled there
* actually are men at work. first, unregister from rumpblk
*/
if (et->et_blkmin != -1) {
rv = rumpblk_deregister(et->et_rn->rn_hostpath);
} else {
rv = 0;
}
KASSERT(rv == 0);

/* then do the actual removal */
mutex_enter(&etfs_lock);
LIST_REMOVE(et, et_entries);
mutex_exit(&etfs_lock);

/* node is unreachable, safe to nuke all device copies */
if (et->et_blkmin != -1) {
vdevgone(RUMPBLK_DEVMAJOR, et->et_blkmin, et->et_blkmin, VBLK);
} else {
struct vnode *vp;
struct mount *mp;
struct rumpfs_node *rn;

mutex_enter(&reclock);
if ((vp = et->et_rn->rn_vp) != NULL) {
mp = vp->v_mount;
rn = vp->v_data;
KASSERT(rn == et->et_rn);
} else {
mp = NULL;
}
mutex_exit(&reclock);
if (mp && vcache_get(mp, &rn, sizeof(rn), &vp) == 0) {
rv = vfs_suspend(mp, 0);
KASSERT(rv == 0);
vgone(vp);
vfs_resume(mp);
}
}

if (et->et_rn->rn_hostpath != NULL)
free(et->et_rn->rn_hostpath, M_TEMP);
freeprivate(et->et_rn);
kmem_free(et, sizeof(*et));

return 0;
}

/*
* rumpfs
*/

static struct rumpfs_node *
makeprivate(enum vtype vt, mode_t mode, dev_t rdev, off_t size, bool et)
{
struct rumpfs_node *rn;
struct vattr *va;
struct timespec ts;

KASSERT((mode & ~ALLPERMS) == 0);
rn = kmem_zalloc(sizeof(*rn), KM_SLEEP);

switch (vt) {
case VDIR:
LIST_INIT(&rn->rn_dir);
break;
case VREG:
if (et) {
rn->rn_readfd = -1;
rn->rn_writefd = -1;
}
break;
default:
break;
}

nanotime(&ts);

va = &rn->rn_va;
va->va_type = vt;
va->va_mode = mode;
if (vt == VDIR)
va->va_nlink = 2;
else
va->va_nlink = 1;
va->va_uid = 0;
va->va_gid = 0;
va->va_fsid =
va->va_fileid = atomic_inc_uint_nv(&lastino);
va->va_size = size;
va->va_blocksize = 512;
va->va_atime = ts;
va->va_mtime = ts;
va->va_ctime = ts;
va->va_birthtime = ts;
va->va_gen = 0;
va->va_flags = 0;
va->va_rdev = rdev;
va->va_bytes = 512;
va->va_filerev = 0;
va->va_vaflags = 0;

return rn;
}

static void
freeprivate(struct rumpfs_node *rn)
{

kmem_free(rn, sizeof(*rn));
}

static void
makedir(struct rumpfs_node *rnd,
struct componentname *cnp, struct rumpfs_node *rn)
{
struct rumpfs_dent *rdent;

rdent = kmem_alloc(sizeof(*rdent), KM_SLEEP);
rdent->rd_name = kmem_alloc(cnp->cn_namelen+1, KM_SLEEP);
rdent->rd_node = rn;
strlcpy(rdent->rd_name, cnp->cn_nameptr, cnp->cn_namelen+1);
rdent->rd_namelen = strlen(rdent->rd_name);

if ((cnp->cn_flags & ISWHITEOUT) != 0) {
KASSERT((cnp->cn_flags & DOWHITEOUT) == 0);
freedir(rnd, cnp);
}
LIST_INSERT_HEAD(&rnd->rn_dir, rdent, rd_entries);
}

static void
freedir(struct rumpfs_node *rnd, struct componentname *cnp)
{
struct rumpfs_dent *rd = NULL;

LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) {
if (rd->rd_namelen == cnp->cn_namelen &&
strncmp(rd->rd_name, cnp->cn_nameptr,
cnp->cn_namelen) == 0)
break;
}
if (rd == NULL)
panic("could not find directory entry: %s", cnp->cn_nameptr);

if (cnp->cn_flags & DOWHITEOUT) {
rd->rd_node = RUMPFS_WHITEOUT;
} else {
LIST_REMOVE(rd, rd_entries);
kmem_free(rd->rd_name, rd->rd_namelen+1);
kmem_free(rd, sizeof(*rd));
}
}

#define RUMPFS_ACCESS 1
#define RUMPFS_MODIFY 2
#define RUMPFS_CHANGE 4

static int
rumpfs_update(int flags, struct vnode *vp, const struct timespec *acc,
const struct timespec *mod, const struct timespec *chg)
{
struct rumpfs_node *rn = vp->v_data;

if (flags == 0)
return 0;

if (vp->v_mount->mnt_flag & MNT_RDONLY)
return EROFS;

if (flags & RUMPFS_ACCESS)
rn->rn_va.va_atime = *acc;
if (flags & RUMPFS_MODIFY)
rn->rn_va.va_mtime = *mod;
if (flags & RUMPFS_CHANGE)
rn->rn_va.va_ctime = *chg;

return 0;
}

/*
* parsepath for rump file systems - check for etfs entries.
*/
static int
rump_vop_parsepath(void *v)
{
struct vop_parsepath_args /* {
struct vnode *a_dvp;
const char *a_name;
size_t *a_retval;
}; */ *ap = v;
struct etfs *et;
bool found;

/* check for etfs */
if (ap->a_dvp == rootvnode) {
mutex_enter(&etfs_lock);
found = etfs_find(ap->a_name, &et, false);
mutex_exit(&etfs_lock);
if (found) {
*ap->a_retval = et->et_keylen;
return 0;
}
}
return genfs_parsepath(v);
}

/*
* Simple lookup for rump file systems.
*
* uhm, this is twisted. C F C C, hope of C C F C looming
*/
static int
rump_vop_lookup(void *v)
{
struct vop_lookup_v2_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
}; */ *ap = v;
struct componentname *cnp = ap->a_cnp;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct rumpfs_node *rnd = dvp->v_data, *rn;
struct rumpfs_dent *rd = NULL;
struct etfs *et;
bool dotdot = (cnp->cn_flags & ISDOTDOT) != 0;
int rv = 0;

*vpp = NULL;

rv = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
if (rv)
return rv;

if ((cnp->cn_flags & ISLASTCN)
&& (dvp->v_mount->mnt_flag & MNT_RDONLY)
&& (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
return EROFS;

/* check for dot, return directly if the case */
if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
vref(dvp);
*vpp = dvp;
return 0;
}

/* we don't do rename */
if (!(((cnp->cn_flags & ISLASTCN) == 0) || (cnp->cn_nameiop != RENAME)))
return EOPNOTSUPP;

/* check for etfs */
if (dvp == rootvnode &&
(cnp->cn_nameiop == LOOKUP || cnp->cn_nameiop == CREATE)) {
bool found;
mutex_enter(&etfs_lock);
found = etfs_find(cnp->cn_nameptr, &et, false);
mutex_exit(&etfs_lock);

if (found) {
if (et->et_keylen != cnp->cn_namelen) {
/*
* This can theoretically happen if an
* etfs entry is added or removed
* while lookups are being done as we
* don't hold etfs_lock across here
* and parsepath. Won't ordinarily be
* the case. No biggie, just retry.
*/
return ERESTART;
}
rn = et->et_rn;
goto getvnode;
}
}

if (rnd->rn_flags & RUMPNODE_DIR_ET) {
uint64_t fsize;
char *newpath;
size_t newpathlen;
int hft, error;

if (dotdot)
return EOPNOTSUPP;

newpathlen = strlen(rnd->rn_hostpath) + 1 + cnp->cn_namelen + 1;
newpath = malloc(newpathlen, M_TEMP, M_WAITOK);

strlcpy(newpath, rnd->rn_hostpath, newpathlen);
strlcat(newpath, "/", newpathlen);
strlcat(newpath, cnp->cn_nameptr, newpathlen);

if ((error = rumpuser_getfileinfo(newpath, &fsize, &hft)) != 0){
free(newpath, M_TEMP);
return error;
}

/* allow only dirs and regular files */
if (hft != RUMPUSER_FT_REG && hft != RUMPUSER_FT_DIR) {
free(newpath, M_TEMP);
return ENOENT;
}

rn = makeprivate(hft_to_vtype(hft), RUMPFS_DEFAULTMODE,
NODEV, fsize, true);
rn->rn_flags |= RUMPNODE_CANRECLAIM;
if (rnd->rn_flags & RUMPNODE_DIR_ETSUBS) {
rn->rn_flags |= RUMPNODE_DIR_ET | RUMPNODE_DIR_ETSUBS;
rn->rn_flags |= RUMPNODE_ET_PHONE_HOST;
}
rn->rn_hostpath = newpath;

goto getvnode;
} else {
if (dotdot) {
if ((rn = rnd->rn_parent) != NULL)
goto getvnode;
} else {
LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) {
if (rd->rd_namelen == cnp->cn_namelen &&
strncmp(rd->rd_name, cnp->cn_nameptr,
cnp->cn_namelen) == 0)
break;
}
}
}

if (!rd && ((cnp->cn_flags & ISLASTCN) == 0||cnp->cn_nameiop != CREATE))
return ENOENT;

if (!rd && (cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) {
if (dvp->v_mount->mnt_flag & MNT_RDONLY)
return EROFS;
rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
if (rv)
return rv;
return EJUSTRETURN;
}

if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == DELETE) {
rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
if (rv)
return rv;
}

if (RDENT_ISWHITEOUT(rd)) {
cnp->cn_flags |= ISWHITEOUT;
if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE)
return EJUSTRETURN;
return ENOENT;
}

rn = rd->rd_node;

getvnode:
KASSERT(rn);
rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
if (rv) {
if (rnd->rn_flags & RUMPNODE_DIR_ET)
freeprivate(rn);
return rv;
}

return 0;
}

static int
rump_check_possible(struct vnode *vp, struct rumpfs_node *rnode,
mode_t mode)
{

if ((mode & VWRITE) == 0)
return 0;

switch (vp->v_type) {
case VDIR:
case VLNK:
case VREG:
break;
default:
/* special file is always writable. */
return 0;
}

return vp->v_mount->mnt_flag & MNT_RDONLY ? EROFS : 0;
}

static int
rump_check_permitted(struct vnode *vp, struct rumpfs_node *rnode,
accmode_t accmode, kauth_cred_t cred)
{
struct vattr *attr = &rnode->rn_va;

return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
vp->v_type, attr->va_mode), vp, NULL, genfs_can_access(vp, cred,
attr->va_uid, attr->va_gid, attr->va_mode, NULL, accmode));
}

int
rump_vop_access(void *v)
{
struct vop_access_args /* {
const struct vnodeop_desc *a_desc;
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
int error;

error = rump_check_possible(vp, rn, ap->a_accmode);
if (error)
return error;

error = rump_check_permitted(vp, rn, ap->a_accmode, ap->a_cred);

return error;
}

static int
rump_vop_getattr(void *v)
{
struct vop_getattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
struct vattr *vap = ap->a_vap;

memcpy(vap, &rn->rn_va, sizeof(struct vattr));
vap->va_size = vp->v_size;
return 0;
}

static int
rump_vop_setattr(void *v)
{
struct vop_setattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct vattr *vap = ap->a_vap;
struct rumpfs_node *rn = vp->v_data;
struct vattr *attr = &rn->rn_va;
struct timespec now;
kauth_cred_t cred = ap->a_cred;
int error;

#define CHANGED(a, t) (vap->a != (t)VNOVAL)
#define SETIFVAL(a,t) if (CHANGED(a, t)) rn->rn_va.a = vap->a
if (CHANGED(va_atime.tv_sec, time_t) ||
CHANGED(va_ctime.tv_sec, time_t) ||
CHANGED(va_mtime.tv_sec, time_t) ||
CHANGED(va_birthtime.tv_sec, time_t) ||
CHANGED(va_atime.tv_nsec, long) ||
CHANGED(va_ctime.tv_nsec, long) ||
CHANGED(va_mtime.tv_nsec, long) ||
CHANGED(va_birthtime.tv_nsec, long)) {
error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
NULL, genfs_can_chtimes(vp, cred, attr->va_uid,
vap->va_vaflags));
if (error)
return error;
}

int flags = 0;
getnanotime(&now);
if (vap->va_atime.tv_sec != VNOVAL)
if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
flags |= RUMPFS_ACCESS;
if (vap->va_mtime.tv_sec != VNOVAL) {
flags |= RUMPFS_CHANGE | RUMPFS_MODIFY;
if (vp->v_mount->mnt_flag & MNT_RELATIME)
flags |= RUMPFS_ACCESS;
} else if (vap->va_size == 0) {
flags |= RUMPFS_MODIFY;
vap->va_mtime = now;
}
SETIFVAL(va_birthtime.tv_sec, time_t);
SETIFVAL(va_birthtime.tv_nsec, long);
flags |= RUMPFS_CHANGE;
error = rumpfs_update(flags, vp, &vap->va_atime, &vap->va_mtime, &now);
if (error)
return error;

if (CHANGED(va_flags, u_long)) {
/* XXX Can we handle system flags here...? */
error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_FLAGS, vp,
NULL, genfs_can_chflags(vp, cred, attr->va_uid, false));
if (error)
return error;
}

SETIFVAL(va_flags, u_long);
#undef SETIFVAL
#undef CHANGED

if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (uid_t)VNOVAL) {
uid_t uid =
(vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->va_uid;
gid_t gid =
(vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->va_gid;
error = kauth_authorize_vnode(cred,
KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
genfs_can_chown(vp, cred, attr->va_uid, attr->va_gid, uid,
gid));
if (error)
return error;
attr->va_uid = uid;
attr->va_gid = gid;
}

if (vap->va_mode != (mode_t)VNOVAL) {
mode_t mode = vap->va_mode;
error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY,
vp, NULL, genfs_can_chmod(vp, cred, attr->va_uid,
attr->va_gid, mode));
if (error)
return error;
attr->va_mode = mode;
}

if (vp->v_type == VREG &&
vap->va_size != VSIZENOTSET &&
vap->va_size != rn->rn_dlen &&
(rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) {
void *newdata;
size_t copylen, newlen;

newlen = vap->va_size;
newdata = rump_hypermalloc(newlen, 0, false, "rumpfs");
if (newdata == NULL)
return ENOSPC;

copylen = MIN(rn->rn_dlen, newlen);
if (copylen > 0)
memcpy(newdata, rn->rn_data, copylen);
memset((char *)newdata + copylen, 0, newlen - copylen);

if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
rump_hyperfree(rn->rn_data, rn->rn_dlen);
} else {
rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
}

rn->rn_data = newdata;
rn->rn_dlen = newlen;
uvm_vnp_setsize(vp, newlen);
}
return 0;
}

static int
rump_vop_mkdir(void *v)
{
struct vop_mkdir_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
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, *rn;
int rv = 0;

rn = makeprivate(VDIR, va->va_mode & ALLPERMS, NODEV, DEV_BSIZE, false);
if ((cnp->cn_flags & ISWHITEOUT) != 0)
rn->rn_va.va_flags |= UF_OPAQUE;
rn->rn_parent = rnd;
rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
if (rv) {
freeprivate(rn);
return rv;
}

makedir(rnd, cnp, rn);

return rv;
}

static int
rump_vop_rmdir(void *v)
{
struct vop_rmdir_v2_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct componentname *cnp = ap->a_cnp;
struct rumpfs_node *rnd = dvp->v_data;
struct rumpfs_node *rn = vp->v_data;
struct rumpfs_dent *rd;
int rv = 0;

LIST_FOREACH(rd, &rn->rn_dir, rd_entries) {
if (rd->rd_node != RUMPFS_WHITEOUT) {
rv = ENOTEMPTY;
goto out;
}
}
while ((rd = LIST_FIRST(&rn->rn_dir)) != NULL) {
KASSERT(rd->rd_node == RUMPFS_WHITEOUT);
LIST_REMOVE(rd, rd_entries);
kmem_free(rd->rd_name, rd->rd_namelen+1);
kmem_free(rd, sizeof(*rd));
}

freedir(rnd, cnp);
rn->rn_flags |= RUMPNODE_CANRECLAIM;
rn->rn_parent = NULL;
rn->rn_va.va_nlink = 0;

out:
vput(vp);
return rv;
}

static int
rump_vop_remove(void *v)
{
struct vop_remove_v3_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
nlink_t ctx_vp_new_nlink;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct componentname *cnp = ap->a_cnp;
struct rumpfs_node *rnd = dvp->v_data;
struct rumpfs_node *rn = vp->v_data;
int rv = 0;

if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
return EOPNOTSUPP;

freedir(rnd, cnp);
rn->rn_flags |= RUMPNODE_CANRECLAIM;
rn->rn_va.va_nlink = 0;

vput(vp);
return rv;
}

static int
rump_vop_mknod(void *v)
{
struct vop_mknod_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
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, *rn;
int rv;

rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, va->va_rdev,
DEV_BSIZE, false);
if ((cnp->cn_flags & ISWHITEOUT) != 0)
rn->rn_va.va_flags |= UF_OPAQUE;
rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
if (rv) {
freeprivate(rn);
return rv;
}

makedir(rnd, cnp, rn);

return rv;
}

static int
rump_vop_create(void *v)
{
struct vop_create_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
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, *rn;
off_t newsize;
int rv;

newsize = va->va_type == VSOCK ? DEV_BSIZE : 0;
rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, NODEV,
newsize, false);
if ((cnp->cn_flags & ISWHITEOUT) != 0)
rn->rn_va.va_flags |= UF_OPAQUE;
rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
if (rv) {
freeprivate(rn);
return rv;
}

makedir(rnd, cnp, rn);

return rv;
}

static int
rump_vop_symlink(void *v)
{
struct vop_symlink_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
char *a_target;
}; */ *ap = v;
struct vnode *dvp = ap->a_dvp;
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, *rn;
const char *target = ap->a_target;
size_t linklen;
int rv;

linklen = strlen(target);
KASSERT(linklen < MAXPATHLEN);
rn = makeprivate(VLNK, va->va_mode & ALLPERMS, NODEV, linklen, false);
if ((cnp->cn_flags & ISWHITEOUT) != 0)
rn->rn_va.va_flags |= UF_OPAQUE;
rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
if (rv) {
freeprivate(rn);
return rv;
}

makedir(rnd, cnp, rn);

KASSERT(linklen < MAXPATHLEN);
rn->rn_linktarg = PNBUF_GET();
rn->rn_linklen = linklen;
strcpy(rn->rn_linktarg, target);

return rv;
}

static int
rump_vop_readlink(void *v)
{
struct vop_readlink_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
}; */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
struct uio *uio = ap->a_uio;

return uiomove(rn->rn_linktarg, rn->rn_linklen, uio);
}

static int
rump_vop_whiteout(void *v)
{
struct vop_whiteout_args /* {
struct vnode *a_dvp;
struct componentname *a_cnp;
int a_flags;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct rumpfs_node *rnd = dvp->v_data;
struct componentname *cnp = ap->a_cnp;
int flags = ap->a_flags;

switch (flags) {
case LOOKUP:
break;
case CREATE:
makedir(rnd, cnp, RUMPFS_WHITEOUT);
break;
case DELETE:
cnp->cn_flags &= ~DOWHITEOUT; /* cargo culting never fails ? */
freedir(rnd, cnp);
break;
default:
panic("unknown whiteout op %d", flags);
}

return 0;
}

static int
rump_vop_open(void *v)
{
struct vop_open_args /* {
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
int mode = ap->a_mode;
int error = EINVAL;

if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0)
return 0;

if (mode & FREAD) {
if (rn->rn_readfd != -1)
return 0;
error = rumpuser_open(rn->rn_hostpath,
RUMPUSER_OPEN_RDONLY, &rn->rn_readfd);
}

if (mode & FWRITE) {
if (rn->rn_writefd != -1)
return 0;
error = rumpuser_open(rn->rn_hostpath,
RUMPUSER_OPEN_WRONLY, &rn->rn_writefd);
}

return error;
}

/* simple readdir. even omits dotstuff and periods */
static int
rump_vop_readdir(void *v)
{
struct vop_readdir_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
int *a_eofflag;
off_t **a_cookies;
int *a_ncookies;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct rumpfs_node *rnd = vp->v_data;
struct rumpfs_dent *rdent;
struct dirent *dentp = NULL;
unsigned i;
int rv = 0;

/* seek to current entry */
for (i = 0, rdent = LIST_FIRST(&rnd->rn_dir);
(i < uio->uio_offset) && rdent;
i++, rdent = LIST_NEXT(rdent, rd_entries))
continue;
if (!rdent)
goto out;

/* copy entries */
dentp = kmem_alloc(sizeof(*dentp), KM_SLEEP);
for (; rdent && uio->uio_resid > 0;
rdent = LIST_NEXT(rdent, rd_entries), i++) {
strlcpy(dentp->d_name, rdent->rd_name, sizeof(dentp->d_name));
dentp->d_namlen = strlen(dentp->d_name);
dentp->d_reclen = _DIRENT_RECLEN(dentp, dentp->d_namlen);

if (__predict_false(RDENT_ISWHITEOUT(rdent))) {
dentp->d_fileno = INO_WHITEOUT;
dentp->d_type = DT_WHT;
} else {
dentp->d_fileno = rdent->rd_node->rn_va.va_fileid;
dentp->d_type = vtype2dt(rdent->rd_node->rn_va.va_type);
}

if (uio->uio_resid < dentp->d_reclen) {
i--;
break;
}

rv = uiomove(dentp, dentp->d_reclen, uio);
if (rv) {
i--;
break;
}
}
kmem_free(dentp, sizeof(*dentp));
dentp = NULL;

out:
KASSERT(dentp == NULL);
if (ap->a_cookies) {
*ap->a_ncookies = 0;
*ap->a_cookies = NULL;
}
if (rdent)
*ap->a_eofflag = 0;
else
*ap->a_eofflag = 1;
uio->uio_offset = i;

return rv;
}

static int
etread(struct rumpfs_node *rn, struct uio *uio)
{
struct rumpuser_iovec iov;
uint8_t *buf;
size_t bufsize, n;
int error = 0;

bufsize = uio->uio_resid;
if (bufsize == 0)
return 0;
buf = kmem_alloc(bufsize, KM_SLEEP);

iov.iov_base = buf;
iov.iov_len = bufsize;
if ((error = rumpuser_iovread(rn->rn_readfd, &iov, 1,
uio->uio_offset + rn->rn_offset, &n)) == 0) {
KASSERT(n <= bufsize);
error = uiomove(buf, n, uio);
}

kmem_free(buf, bufsize);
return error;
}

static int
rump_vop_read(void *v)
{
struct vop_read_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int ioflags a_ioflag;
kauth_cred_t a_cred;
}; */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
struct uio *uio = ap->a_uio;
const int advice = IO_ADV_DECODE(ap->a_ioflag);
off_t chunk;
int error = 0;
struct timespec ts;

if (vp->v_type == VDIR)
return EISDIR;

/* et op? */
if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
return etread(rn, uio);

getnanotime(&ts);
(void)rumpfs_update(RUMPFS_ACCESS, vp, &ts, &ts, &ts);

/* otherwise, it's off to ubc with us */
while (uio->uio_resid > 0) {
chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset);
if (chunk == 0)
break;
error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice,
UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
if (error)
break;
}

return error;
}

static int
etwrite(struct rumpfs_node *rn, struct uio *uio)
{
struct rumpuser_iovec iov;
uint8_t *buf;
size_t bufsize, n;
int error = 0;

bufsize = uio->uio_resid;
if (bufsize == 0)
return 0;
buf = kmem_alloc(bufsize, KM_SLEEP);
error = uiomove(buf, bufsize, uio);
if (error)
goto out;

KASSERT(uio->uio_resid == 0);
iov.iov_base = buf;
iov.iov_len = bufsize;
if ((error = rumpuser_iovwrite(rn->rn_writefd, &iov, 1,
(uio->uio_offset-bufsize) + rn->rn_offset, &n)) == 0) {
KASSERT(n <= bufsize);
uio->uio_resid = bufsize - n;
}

out:
kmem_free(buf, bufsize);
return error;
}

static int
rump_vop_write(void *v)
{
struct vop_write_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int ioflags a_ioflag;
kauth_cred_t a_cred;
}; */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
struct uio *uio = ap->a_uio;
const int advice = IO_ADV_DECODE(ap->a_ioflag);
void *olddata;
size_t oldlen, newlen;
off_t chunk;
int error = 0;
bool allocd = false;
struct timespec ts;

getnanotime(&ts);
(void)rumpfs_update(RUMPFS_MODIFY, vp, &ts, &ts, &ts);

if (ap->a_ioflag & IO_APPEND)
uio->uio_offset = vp->v_size;

/* consult et? */
if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
return etwrite(rn, uio);

/*
* Otherwise, it's a case of ubcmove.
*/

/*
* First, make sure we have enough storage.
*
* No, you don't need to tell me it's not very efficient.
* No, it doesn't really support sparse files, just fakes it.
*/
newlen = uio->uio_offset + uio->uio_resid;
oldlen = 0; /* XXXgcc */
olddata = NULL;
if (rn->rn_dlen < newlen) {
oldlen = rn->rn_dlen;
olddata = rn->rn_data;

rn->rn_data = rump_hypermalloc(newlen, 0, false, "rumpfs");
if (rn->rn_data == NULL)
return ENOSPC;
rn->rn_dlen = newlen;
memset(rn->rn_data, 0, newlen);
if (oldlen > 0)
memcpy(rn->rn_data, olddata, oldlen);
allocd = true;
uvm_vnp_setsize(vp, newlen);
}

/* ok, we have enough storage. write */
while (uio->uio_resid > 0) {
chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset);
if (chunk == 0)
break;
error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice,
UBC_WRITE | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
if (error)
break;
}

if (allocd) {
if (error) {
rump_hyperfree(rn->rn_data, newlen);
rn->rn_data = olddata;
rn->rn_dlen = oldlen;
uvm_vnp_setsize(vp, oldlen);
} else {
if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
rump_hyperfree(olddata, oldlen);
} else {
rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
}
}
}

return error;
}

static int
rump_vop_bmap(void *v)
{
struct vop_bmap_args /* {
struct vnode *a_vp;
daddr_t a_bn;
struct vnode **a_vpp;
daddr_t *a_bnp;
int *a_runp;
} */ *ap = v;

/* 1:1 mapping */
if (ap->a_vpp)
*ap->a_vpp = ap->a_vp;
if (ap->a_bnp)
*ap->a_bnp = ap->a_bn;
if (ap->a_runp)
*ap->a_runp = 16;

return 0;
}

static int
rump_vop_strategy(void *v)
{
struct vop_strategy_args /* {
struct vnode *a_vp;
struct buf *a_bp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
struct buf *bp = ap->a_bp;
off_t copylen, copyoff;
int error;

if (vp->v_type != VREG || rn->rn_flags & RUMPNODE_ET_PHONE_HOST) {
error = EINVAL;
goto out;
}

copyoff = bp->b_blkno << DEV_BSHIFT;
copylen = MIN(rn->rn_dlen - copyoff, bp->b_bcount);
if (BUF_ISWRITE(bp)) {
memcpy((uint8_t *)rn->rn_data + copyoff, bp->b_data, copylen);
} else {
memset((uint8_t*)bp->b_data + copylen, 0, bp->b_bcount-copylen);
memcpy(bp->b_data, (uint8_t *)rn->rn_data + copyoff, copylen);
}
bp->b_resid = 0;
error = 0;

out:
bp->b_error = error;
biodone(bp);
return 0;
}

static int
rump_vop_pathconf(void *v)
{
struct vop_pathconf_args /* {
struct vnode *a_vp;
int a_name;
register_t *a_retval;
}; */ *ap = v;
int name = ap->a_name;
register_t *retval = ap->a_retval;

switch (name) {
case _PC_LINK_MAX:
*retval = LINK_MAX;
return 0;
case _PC_NAME_MAX:
*retval = RUMPFS_MAXNAMLEN;
return 0;
case _PC_PATH_MAX:
*retval = PATH_MAX;
return 0;
case _PC_PIPE_BUF:
*retval = PIPE_BUF;
return 0;
case _PC_CHOWN_RESTRICTED:
*retval = 1;
return 0;
case _PC_NO_TRUNC:
*retval = 1;
return 0;
case _PC_SYNC_IO:
*retval = 1;
return 0;
case _PC_FILESIZEBITS:
*retval = 43; /* this one goes to 11 */
return 0;
case _PC_SYMLINK_MAX:
*retval = MAXPATHLEN;
return 0;
case _PC_2_SYMLINKS:
*retval = 1;
return 0;
default:
return EINVAL;
}
}

static int
rump_vop_success(void *v)
{

return 0;
}

static int
rump_vop_inactive(void *v)
{
struct vop_inactive_v2_args /* {
struct vnode *a_vp;
bool *a_recycle;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;

if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST && vp->v_type == VREG) {
if (rn->rn_readfd != -1) {
rumpuser_close(rn->rn_readfd);
rn->rn_readfd = -1;
}
if (rn->rn_writefd != -1) {
rumpuser_close(rn->rn_writefd);
rn->rn_writefd = -1;
}
}
*ap->a_recycle = (rn->rn_flags & RUMPNODE_CANRECLAIM) ? true : false;

return 0;
}

static int
rump_vop_reclaim(void *v)
{
struct vop_reclaim_v2_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;

VOP_UNLOCK(vp);

mutex_enter(&reclock);
rn->rn_vp = NULL;
mutex_exit(&reclock);
genfs_node_destroy(vp);
vp->v_data = NULL;

if (rn->rn_flags & RUMPNODE_CANRECLAIM) {
if (vp->v_type == VREG
&& (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0
&& rn->rn_data) {
if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
rump_hyperfree(rn->rn_data, rn->rn_dlen);
} else {
rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
}
rn->rn_data = NULL;
}

if (vp->v_type == VLNK)
PNBUF_PUT(rn->rn_linktarg);
if (rn->rn_hostpath)
free(rn->rn_hostpath, M_TEMP);
freeprivate(rn);
}

return 0;
}

static int
rump_vop_spec(void *v)
{
struct vop_generic_args *ap = v;
int (**opvec)(void *);

switch (ap->a_desc->vdesc_offset) {
case VOP_ACCESS_DESCOFFSET:
case VOP_ACCESSX_DESCOFFSET:
case VOP_GETATTR_DESCOFFSET:
case VOP_SETATTR_DESCOFFSET:
case VOP_LOCK_DESCOFFSET:
case VOP_UNLOCK_DESCOFFSET:
case VOP_ISLOCKED_DESCOFFSET:
case VOP_INACTIVE_DESCOFFSET:
case VOP_RECLAIM_DESCOFFSET:
opvec = rump_vnodeop_p;
break;
default:
opvec = spec_vnodeop_p;
break;
}

return VOCALL(opvec, ap->a_desc->vdesc_offset, v);
}

static int
rump_vop_advlock(void *v)
{
struct vop_advlock_args /* {
const struct vnodeop_desc *a_desc;
struct vnode *a_vp;
void *a_id;
int a_op;
struct flock *a_fl;
int a_flags;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;

return lf_advlock(ap, &rn->rn_lockf, vp->v_size);
}

static int
rump_vop_fcntl(void *v)
{
struct vop_fcntl_args /* {
struct vnode *a_vp;
u_int a_command;
void *a_data;
int a_fflag;
kauth_cred_t a_cred;
} */ *ap = v;
struct proc *p = curproc;
struct vnode *vp = ap->a_vp;
struct rumpfs_node *rn = vp->v_data;
u_int cmd = ap->a_command;
int fflag = ap->a_fflag;
struct rumpfs_extstorage *rfse = ap->a_data;
int error = 0;

/* none of the current rumpfs fcntlops are defined for remotes */
if (!RUMP_LOCALPROC_P(p))
return EINVAL;

switch (cmd) {
case RUMPFS_FCNTL_EXTSTORAGE_ADD:
break;
default:
return EINVAL;
}

if ((fflag & FWRITE) == 0)
return EBADF;

if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST))
return EINVAL;

if (rfse->rfse_flags != 0)
return EINVAL;

/*
* Ok, we are good to go. Process.
*/

vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);

KASSERT(cmd == RUMPFS_FCNTL_EXTSTORAGE_ADD);
if (rn->rn_data && (rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
rump_hyperfree(rn->rn_data, rn->rn_dlen);
}

rn->rn_data = rfse->rfse_data;
rn->rn_dlen = rfse->rfse_dlen;
uvm_vnp_setsize(vp, rn->rn_dlen);
rn->rn_flags |= RUMPNODE_EXTSTORAGE;

VOP_UNLOCK(vp);

return error;
}

/*
* Begin vfs-level stuff
*/

VFS_PROTOS(rumpfs);
struct vfsops rumpfs_vfsops = {
.vfs_name = MOUNT_RUMPFS,
.vfs_min_mount_data = 0,
.vfs_mount = rumpfs_mount,
.vfs_start = (void *)nullop,
.vfs_unmount = rumpfs_unmount,
.vfs_root = rumpfs_root,
.vfs_quotactl = (void *)eopnotsupp,
.vfs_statvfs = genfs_statvfs,
.vfs_sync = (void *)nullop,
.vfs_vget = rumpfs_vget,
.vfs_loadvnode = rumpfs_loadvnode,
.vfs_fhtovp = (void *)eopnotsupp,
.vfs_vptofh = (void *)eopnotsupp,
.vfs_init = rumpfs_init,
.vfs_reinit = NULL,
.vfs_done = rumpfs_done,
.vfs_mountroot = rumpfs_mountroot,
.vfs_snapshot = (void *)eopnotsupp,
.vfs_extattrctl = (void *)eopnotsupp,
.vfs_suspendctl = genfs_suspendctl,
.vfs_renamelock_enter = genfs_renamelock_enter,
.vfs_renamelock_exit = genfs_renamelock_exit,
.vfs_opv_descs = rump_opv_descs,
/* vfs_refcount */
/* vfs_list */
};

static int
rumpfs_mountfs(struct mount *mp)
{
struct rumpfs_mount *rfsmp;
struct rumpfs_node *rn;
int error;

rfsmp = kmem_alloc(sizeof(*rfsmp), KM_SLEEP);

rn = makeprivate(VDIR, RUMPFS_DEFAULTMODE, NODEV, DEV_BSIZE, false);
rn->rn_parent = rn;
if ((error = vcache_get(mp, &rn, sizeof(rn), &rfsmp->rfsmp_rvp))
!= 0) {
freeprivate(rn);
kmem_free(rfsmp, sizeof(*rfsmp));
return error;
}

rfsmp->rfsmp_rvp->v_vflag |= VV_ROOT;

mp->mnt_data = rfsmp;
mp->mnt_stat.f_namemax = RUMPFS_MAXNAMLEN;
mp->mnt_stat.f_iosize = 512;
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_iflag |= IMNT_MPSAFE | IMNT_CAN_RWTORO;
mp->mnt_fs_bshift = DEV_BSHIFT;
vfs_getnewfsid(mp);

return 0;
}

int
rumpfs_mount(struct mount *mp, const char *mntpath, void *arg, size_t *alen)
{
int error, flags;

if (mp->mnt_flag & MNT_GETARGS) {
return 0;
}
if (mp->mnt_flag & MNT_UPDATE) {
if ((mp->mnt_iflag & IMNT_WANTRDONLY)) {
/* Changing from read/write to read-only. */
flags = WRITECLOSE;
if ((mp->mnt_flag & MNT_FORCE))
flags |= FORCECLOSE;
error = vflush(mp, NULL, flags);
if (error)
return error;
}
return 0;
}

error = set_statvfs_info(mntpath, UIO_USERSPACE, "rumpfs", UIO_SYSSPACE,
mp->mnt_op->vfs_name, mp, curlwp);
if (error)
return error;

return rumpfs_mountfs(mp);
}

int
rumpfs_unmount(struct mount *mp, int mntflags)
{
struct rumpfs_mount *rfsmp = mp->mnt_data;
int flags = 0, error;

if (panicstr || mntflags & MNT_FORCE)
flags |= FORCECLOSE;

if (vrefcnt(rfsmp->rfsmp_rvp) > 1 && (flags & FORCECLOSE) == 0)
return EBUSY;

if ((error = vflush(mp, rfsmp->rfsmp_rvp, flags)) != 0)
return error;
vgone(rfsmp->rfsmp_rvp);

kmem_free(rfsmp, sizeof(*rfsmp));

return 0;
}

int
rumpfs_root(struct mount *mp, int lktype, struct vnode **vpp)
{
struct rumpfs_mount *rfsmp = mp->mnt_data;

vref(rfsmp->rfsmp_rvp);
vn_lock(rfsmp->rfsmp_rvp, lktype | LK_RETRY);
*vpp = rfsmp->rfsmp_rvp;
return 0;
}

int
rumpfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp)
{

return EOPNOTSUPP;
}

int
rumpfs_loadvnode(struct mount *mp, struct vnode *vp,
const void *key, size_t key_len, const void **new_key)
{
struct rumpfs_node *rn;
struct vattr *va;

KASSERT(!mutex_owned(&reclock));

KASSERT(key_len == sizeof(rn));
memcpy(&rn, key, key_len);

va = &rn->rn_va;

vp->v_tag = VT_RUMP;
vp->v_type = va->va_type;
switch (vp->v_type) {
case VCHR:
case VBLK:
vp->v_op = rump_specop_p;
spec_node_init(vp, va->va_rdev);
break;
default:
vp->v_op = rump_vnodeop_p;
break;
}
vp->v_size = vp->v_writesize = va->va_size;
vp->v_data = rn;

genfs_node_init(vp, &rumpfs_genfsops);
mutex_enter(&reclock);
rn->rn_vp = vp;
mutex_exit(&reclock);

*new_key = &vp->v_data;

return 0;
}

void
rumpfs_init()
{
extern rump_etfs_register_withsize_fn rump__etfs_register;
extern rump_etfs_remove_fn rump__etfs_remove;
extern struct rump_boot_etfs *ebstart;
struct rump_boot_etfs *eb;

CTASSERT(RUMP_ETFS_SIZE_ENDOFF == RUMPBLK_SIZENOTSET);

mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE);

rump__etfs_register = etfsregister;
rump__etfs_remove = etfsremove;

for (eb = ebstart; eb; eb = eb->_eb_next) {
eb->eb_status = etfsregister(eb->eb_key, eb->eb_hostpath,
eb->eb_type, eb->eb_begin, eb->eb_size);
}
}

void
rumpfs_done()
{

mutex_destroy(&reclock);
mutex_destroy(&etfs_lock);
}

int
rumpfs_mountroot()
{
struct mount *mp;
int error;

if ((error = vfs_rootmountalloc(MOUNT_RUMPFS, "rootdev", &mp)) != 0) {
vrele(rootvp);
return error;
}

if ((error = rumpfs_mountfs(mp)) != 0)
panic("mounting rootfs failed: %d", error);

mountlist_append(mp);

error = set_statvfs_info("/", UIO_SYSSPACE, "rumpfs", UIO_SYSSPACE,
mp->mnt_op->vfs_name, mp, curlwp);
if (error)
panic("set_statvfs_info failed for rootfs: %d", error);

mp->mnt_flag &= ~MNT_RDONLY;
vfs_unbusy(mp);

return 0;
}