* Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.

/* $NetBSD: puffs_msgif.h,v 1.87 2021/12/03 13:08:10 pho Exp $ */

/*
* Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
*
* Development of this software was supported by the
* Google Summer of Code program and the Ulla Tuominen Foundation.
* The Google SoC project was mentored by Bill Studenmund.
*
* 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.
*/

#ifndef _FS_PUFFS_PUFFS_MSGIF_H_
#define _FS_PUFFS_PUFFS_MSGIF_H_

#include <sys/param.h>
#include <sys/time.h>
#include <sys/ioccom.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <sys/ucred.h>
#include <sys/statvfs.h>
#include <sys/dirent.h>
#include <sys/fcntl.h>

#include <dev/putter/putter.h>

#include <uvm/uvm_prot.h>

#define PUFFSOP_VFS 0x01 /* kernel-> */
#define PUFFSOP_VN 0x02 /* kernel-> */
#define PUFFSOP_CACHE 0x03 /* only kernel-> */
#define PUFFSOP_ERROR 0x04 /* only kernel-> */
#define PUFFSOP_FLUSH 0x05 /* ->kernel */
#define PUFFSOP_SUSPEND 0x06 /* ->kernel */
#define PUFFSOP_UNMOUNT 0x07 /* ->kernel */

#define PUFFSOPFLAG_FAF 0x10 /* fire-and-forget */
#define PUFFSOPFLAG_ISRESPONSE 0x20 /* req is actually a resp */

#define PUFFSOP_OPCMASK 0x07
#define PUFFSOP_OPCLASS(a) ((a) & PUFFSOP_OPCMASK)
#define PUFFSOP_WANTREPLY(a) (((a) & PUFFSOPFLAG_FAF) == 0)

enum puffs_vfs {
PUFFS_VFS_MOUNT, PUFFS_VFS_START, PUFFS_VFS_UNMOUNT,
PUFFS_VFS_ROOT, PUFFS_VFS_QUOTACTL, PUFFS_VFS_STATVFS,
PUFFS_VFS_SYNC, PUFFS_VFS_VGET, PUFFS_VFS_FHTOVP,
PUFFS_VFS_VPTOFH, PUFFS_VFS_INIT, PUFFS_VFS_DONE,
PUFFS_VFS_SNAPSHOT, PUFFS_VFS_EXTATTRCTL, PUFFS_VFS_SUSPEND
};
#define PUFFS_VFS_MAX PUFFS_VFS_SUSPEND

enum puffs_vn {
PUFFS_VN_LOOKUP, PUFFS_VN_CREATE, PUFFS_VN_MKNOD,
PUFFS_VN_OPEN, PUFFS_VN_CLOSE, PUFFS_VN_ACCESS,
PUFFS_VN_GETATTR, PUFFS_VN_SETATTR, PUFFS_VN_READ,
PUFFS_VN_WRITE, PUFFS_VN_IOCTL, PUFFS_VN_FCNTL,
PUFFS_VN_POLL, PUFFS_VN_KQFILTER, PUFFS_VN_REVOKE,
PUFFS_VN_MMAP, PUFFS_VN_FSYNC, PUFFS_VN_SEEK,
PUFFS_VN_REMOVE, PUFFS_VN_LINK, PUFFS_VN_RENAME,
PUFFS_VN_MKDIR, PUFFS_VN_RMDIR, PUFFS_VN_SYMLINK,
PUFFS_VN_READDIR, PUFFS_VN_READLINK, PUFFS_VN_ABORTOP,
PUFFS_VN_INACTIVE, PUFFS_VN_RECLAIM, PUFFS_VN_LOCK,
PUFFS_VN_UNLOCK, PUFFS_VN_BMAP, PUFFS_VN_STRATEGY,
PUFFS_VN_PRINT, PUFFS_VN_ISLOCKED, PUFFS_VN_PATHCONF,
PUFFS_VN_ADVLOCK, PUFFS_VN_LEASE, PUFFS_VN_WHITEOUT,
PUFFS_VN_GETPAGES, PUFFS_VN_PUTPAGES, PUFFS_VN_GETEXTATTR,
PUFFS_VN_LISTEXTATTR, PUFFS_VN_OPENEXTATTR, PUFFS_VN_DELETEEXTATTR,
PUFFS_VN_SETEXTATTR, PUFFS_VN_CLOSEEXTATTR, PUFFS_VN_FALLOCATE,
PUFFS_VN_FDISCARD,
/* NOTE: If you add an op, decrement PUFFS_VN_SPARE accordingly */
};
#define PUFFS_VN_MAX PUFFS_VN_FDISCARD
#define PUFFS_VN_SPARE 30

/*
* These signal invalid parameters the file system returned.
*/
enum puffs_err {
PUFFS_ERR_ERROR,
PUFFS_ERR_MAKENODE, PUFFS_ERR_LOOKUP, PUFFS_ERR_READDIR,
PUFFS_ERR_READLINK, PUFFS_ERR_READ, PUFFS_ERR_WRITE,
PUFFS_ERR_VPTOFH, PUFFS_ERR_GETEXTATTR, PUFFS_ERR_LISTEXTATTR
};
#define PUFFS_ERR_MAX PUFFS_ERR_LISTEXTATTR

#define PUFFSVERSION 30
#define PUFFSNAMESIZE 32

#define PUFFS_TYPEPREFIX "puffs|"

#define PUFFS_TYPELEN (_VFS_NAMELEN - (sizeof(PUFFS_TYPEPREFIX)+1))
#define PUFFS_NAMELEN (_VFS_MNAMELEN-1)

/* really statvfs90 */
struct puffs_statvfs {
unsigned long f_flag; /* copy of mount exported flags */
unsigned long f_bsize; /* file system block size */
unsigned long f_frsize; /* fundamental file system block size */
unsigned long f_iosize; /* optimal file system block size */

/* The following are in units of f_frsize */
fsblkcnt_t f_blocks; /* number of blocks in file system, */
fsblkcnt_t f_bfree; /* free blocks avail in file system */
fsblkcnt_t f_bavail; /* free blocks avail to non-root */
fsblkcnt_t f_bresvd; /* blocks reserved for root */

fsfilcnt_t f_files; /* total file nodes in file system */
fsfilcnt_t f_ffree; /* free file nodes in file system */
fsfilcnt_t f_favail; /* free file nodes avail to non-root */
fsfilcnt_t f_fresvd; /* file nodes reserved for root */

uint64_t f_syncreads; /* count of sync reads since mount */
uint64_t f_syncwrites; /* count of sync writes since mount */

uint64_t f_asyncreads; /* count of async reads since mount */
uint64_t f_asyncwrites; /* count of async writes since mount */

fsid_t f_fsidx; /* NetBSD compatible fsid */
unsigned long f_fsid; /* Posix compatible fsid */
unsigned long f_namemax; /* maximum filename length */
uid_t f_owner; /* user that mounted the file system */

uint32_t f_spare[4]; /* spare space */

char f_fstypename[_VFS_NAMELEN]; /* fs type name */
char f_mntonname[_VFS_MNAMELEN]; /* directory on which mounted */
char f_mntfromname[_VFS_MNAMELEN]; /* mounted file system */
};

#ifndef _KERNEL
#include <string.h>
#endif

static __inline void
statvfs_to_puffs_statvfs(const struct statvfs *s, struct puffs_statvfs *ps)
{
ps->f_flag = s->f_flag;
ps->f_bsize = s->f_bsize;
ps->f_frsize = s->f_frsize;
ps->f_iosize = s->f_iosize;

ps->f_blocks = s->f_blocks;
ps->f_bfree = s->f_bfree;
ps->f_bavail = s->f_bavail;
ps->f_bresvd = s->f_bresvd;

ps->f_files = s->f_files;
ps->f_ffree = s->f_ffree;
ps->f_favail = s->f_favail;
ps->f_fresvd = s->f_fresvd;

ps->f_syncreads = s->f_syncreads;
ps->f_syncwrites = s->f_syncwrites;

ps->f_asyncreads = s->f_asyncreads;
ps->f_asyncwrites = s->f_asyncwrites;

ps->f_fsidx = s->f_fsidx;
ps->f_fsid = s->f_fsid;
ps->f_namemax = s->f_namemax;
ps->f_owner = s->f_owner;

memset(ps->f_spare, 0, sizeof(ps->f_spare));

memcpy(ps->f_fstypename, s->f_fstypename, sizeof(ps->f_fstypename));
memcpy(ps->f_mntonname, s->f_mntonname, sizeof(ps->f_mntonname));
memcpy(ps->f_mntfromname, s->f_mntfromname, sizeof(ps->f_mntfromname));
}

static __inline void
puffs_statvfs_to_statvfs(const struct puffs_statvfs *ps, struct statvfs *s)
{
s->f_flag = ps->f_flag;
s->f_bsize = ps->f_bsize;
s->f_frsize = ps->f_frsize;
s->f_iosize = ps->f_iosize;

s->f_blocks = ps->f_blocks;
s->f_bfree = ps->f_bfree;
s->f_bavail = ps->f_bavail;
s->f_bresvd = ps->f_bresvd;

s->f_files = ps->f_files;
s->f_ffree = ps->f_ffree;
s->f_favail = ps->f_favail;
s->f_fresvd = ps->f_fresvd;

s->f_syncreads = ps->f_syncreads;
s->f_syncwrites = ps->f_syncwrites;

s->f_asyncreads = ps->f_asyncreads;
s->f_asyncwrites = ps->f_asyncwrites;

s->f_fsidx = ps->f_fsidx;
s->f_fsid = ps->f_fsid;
s->f_namemax = ps->f_namemax;
s->f_owner = ps->f_owner;

memset(s->f_spare, 0, sizeof(s->f_spare));

memcpy(s->f_fstypename, ps->f_fstypename, sizeof(s->f_fstypename));
memcpy(s->f_mntonname, ps->f_mntonname, sizeof(s->f_mntonname));
memcpy(s->f_mntfromname, ps->f_mntfromname, sizeof(s->f_mntfromname));
memset(s->f_mntfromlabel, 0, sizeof(s->f_mntfromlabel));
}

/*
* Just a weak typedef for code clarity. Additionally, we have a
* more appropriate vanity type for puffs:
* <uep> it should be croissant, not cookie.
*/
typedef void *puffs_cookie_t;
typedef puffs_cookie_t puffs_croissant_t;

struct puffs_kargs {
unsigned int pa_vers;
int pa_fd;

uint32_t pa_flags;

size_t pa_maxmsglen;
int pa_nhashbuckets;

size_t pa_fhsize;
int pa_fhflags;

uint8_t pa_vnopmask[PUFFS_VN_MAX + PUFFS_VN_SPARE];

char pa_typename[_VFS_NAMELEN];
char pa_mntfromname[_VFS_MNAMELEN];

puffs_cookie_t pa_root_cookie;
enum vtype pa_root_vtype;
voff_t pa_root_vsize;
union {
dev_t dev;
uint64_t container;
} devunion;

struct puffs_statvfs pa_svfsb;

uint32_t pa_time32;

uint32_t pa_spare[127];
};
#define pa_root_rdev devunion.dev

#define PUFFS_KFLAG_NOCACHE_NAME 0x001 /* don't use name cache */
#define PUFFS_KFLAG_NOCACHE_PAGE 0x002 /* don't use page cache */
#define PUFFS_KFLAG_NOCACHE 0x003 /* no cache whatsoever */
#define PUFFS_KFLAG_ALLOPS 0x004 /* ignore pa_vnopmask */
#define PUFFS_KFLAG_WTCACHE 0x008 /* write-through page cache */
#define PUFFS_KFLAG_IAONDEMAND 0x010 /* inactive only on demand */
#define PUFFS_KFLAG_LOOKUP_FULLPNBUF 0x020 /* full pnbuf in lookup */
#define PUFFS_KFLAG_NOCACHE_ATTR 0x040 /* no attrib cache (unused) */
#define PUFFS_KFLAG_CACHE_FS_TTL 0x080 /* cache use TTL from FS */
#define PUFFS_KFLAG_CACHE_DOTDOT 0x100 /* don't send lookup for .. */
#define PUFFS_KFLAG_NOFLUSH_META 0x200 /* don't flush metadata cache*/
#define PUFFS_KFLAG_MASK 0x3bf

#define PUFFS_FHFLAG_DYNAMIC 0x01
#define PUFFS_FHFLAG_NFSV2 0x02
#define PUFFS_FHFLAG_NFSV3 0x04
#define PUFFS_FHFLAG_PROTOMASK 0x06
#define PUFFS_FHFLAG_PASSTHROUGH 0x08
#define PUFFS_FHFLAG_MASK 0x0f

#define PUFFS_FHSIZE_MAX 1020 /* FHANDLE_SIZE_MAX - 4 */

struct puffs_req {
struct putter_hdr preq_pth;

uint64_t preq_id;
puffs_cookie_t preq_cookie;

uint16_t preq_opclass;
uint16_t preq_optype;
int preq_rv;

uint32_t preq_setbacks;

/* Who is making the call? Eventually host id is also needed. */
pid_t preq_pid;
lwpid_t preq_lid;

/*
* the following helper pads the struct size to md alignment
* multiple (should size_t not cut it). it makes sure that
* whatever comes after this struct is aligned
*/
size_t preq_buflen;
uint8_t preq_buf[0] __aligned(ALIGNBYTES+1);
};

#define PUFFS_SETBACK_INACT_N1 0x01 /* set VOP_INACTIVE for node 1 */
#define PUFFS_SETBACK_INACT_N2 0x02 /* set VOP_INACTIVE for node 2 */
#define PUFFS_SETBACK_NOREF_N1 0x04 /* set pn PN_NOREFS for node 1 */
#define PUFFS_SETBACK_NOREF_N2 0x08 /* set pn PN_NOREFS for node 2 */
#define PUFFS_SETBACK_MASK 0x0f

/*
* Flush operation. This can be used to invalidate:
* 1) name cache for one node
* 2) name cache for all children
* 3) name cache for the entire mount
* 4) page cache for a set of ranges in one node
* 5) page cache for one entire node
*
* It can be used to flush:
* 1) page cache for a set of ranges in one node
* 2) page cache for one entire node
*/

struct puffs_flush {
struct puffs_req pf_req;

puffs_cookie_t pf_cookie;

int pf_op;
off_t pf_start;
off_t pf_end;
};
#define PUFFS_INVAL_NAMECACHE_NODE 0
#define PUFFS_INVAL_NAMECACHE_DIR 1
#define PUFFS_INVAL_NAMECACHE_ALL 2
#define PUFFS_INVAL_PAGECACHE_NODE_RANGE 3
#define PUFFS_FLUSH_PAGECACHE_NODE_RANGE 4

/*
* Credentials for an operation. Can be either struct uucred for
* ops called from a credential context or NOCRED/FSCRED for ops
* called from within the kernel. It is up to the implementation
* if it makes a difference between these two and the super-user.
*/
struct puffs_kcred {
struct uucred pkcr_uuc;
uint8_t pkcr_type;
uint8_t pkcr_internal;
};
#define PUFFCRED_TYPE_UUC 1
#define PUFFCRED_TYPE_INTERNAL 2
#define PUFFCRED_CRED_NOCRED 1
#define PUFFCRED_CRED_FSCRED 2

/*
* 2*MAXPHYS is the max size the system will attempt to copy,
* else treated as garbage
*/
#define PUFFS_MSG_MAXSIZE 2*MAXPHYS
#define PUFFS_MSGSTRUCT_MAX 4096 /* approximate */

#define PUFFS_EXTNAMELEN KERNEL_NAME_MAX /* currently same as EXTATTR_MAXNAMELEN */

#define PUFFS_TOMOVE(a,b) (MIN((a), b->pmp_msg_maxsize - PUFFS_MSGSTRUCT_MAX))

/* puffs struct componentname built by kernel */
struct puffs_kcn {
/* args */
uint32_t pkcn_nameiop; /* namei operation */
uint32_t pkcn_flags; /* flags */

char pkcn_name[MAXPATHLEN]; /* nulterminated path component */
size_t pkcn_namelen; /* current component length */
size_t pkcn_consume; /* IN: extra chars server ate */
};

/*
* Next come the individual requests. They are all subclassed from
* puffs_req and contain request-specific fields in addition. Note
* that there are some requests which have to handle arbitrary-length
* buffers.
*
* The division is the following: puffs_req is to be touched only
* by generic routines while the other stuff is supposed to be
* modified only by specific routines.
*/

/*
* aux structures for vfs operations.
*/
struct puffs_vfsmsg_unmount {
struct puffs_req pvfsr_pr;

int pvfsr_flags;
};

struct puffs_vfsmsg_statvfs {
struct puffs_req pvfsr_pr;

struct puffs_statvfs pvfsr_sb;
};

struct puffs_vfsmsg_sync {
struct puffs_req pvfsr_pr;

struct puffs_kcred pvfsr_cred;
int pvfsr_waitfor;
};

struct puffs_vfsmsg_fhtonode {
struct puffs_req pvfsr_pr;

void *pvfsr_fhcookie; /* IN */
enum vtype pvfsr_vtype; /* IN */
voff_t pvfsr_size; /* IN */
dev_t pvfsr_rdev; /* IN */

size_t pvfsr_dsize; /* OUT */
uint8_t pvfsr_data[0] /* OUT, XXX */
__aligned(ALIGNBYTES+1);
};

struct puffs_vfsmsg_nodetofh {
struct puffs_req pvfsr_pr;

void *pvfsr_fhcookie; /* OUT */

size_t pvfsr_dsize; /* OUT/IN */
uint8_t pvfsr_data[0] /* IN, XXX */
__aligned(ALIGNBYTES+1);
};

struct puffs_vfsmsg_suspend {
struct puffs_req pvfsr_pr;

int pvfsr_status;
};
#define PUFFS_SUSPEND_START 0
#define PUFFS_SUSPEND_SUSPENDED 1
#define PUFFS_SUSPEND_RESUME 2
#define PUFFS_SUSPEND_ERROR 3

#define PUFFS_EXTATTRCTL_HASNODE 0x01
#define PUFFS_EXTATTRCTL_HASATTRNAME 0x02

#define PUFFS_OPEN_IO_DIRECT 0x01

struct puffs_vfsmsg_extattrctl {
struct puffs_req pvfsr_pr;

int pvfsr_cmd; /* OUT */
int pvfsr_attrnamespace; /* OUT */
int pvfsr_flags; /* OUT */
char pvfsr_attrname[PUFFS_EXTNAMELEN]; /* OUT */
};

/*
* aux structures for vnode operations.
*/

struct puffs_vnmsg_lookup {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

puffs_cookie_t pvnr_newnode; /* IN */
enum vtype pvnr_vtype; /* IN */
voff_t pvnr_size; /* IN */
dev_t pvnr_rdev; /* IN */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct vattr pvnr_va; /* IN */
struct timespec pvnr_va_ttl; /* IN */
struct timespec pvnr_cn_ttl; /* IN */
};

struct puffs_vnmsg_create {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

struct vattr pvnr_va; /* OUT */
puffs_cookie_t pvnr_newnode; /* IN */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct timespec pvnr_va_ttl; /* IN */
struct timespec pvnr_cn_ttl; /* IN */
};

struct puffs_vnmsg_mknod {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

struct vattr pvnr_va; /* OUT */
puffs_cookie_t pvnr_newnode; /* IN */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct timespec pvnr_va_ttl; /* IN */
struct timespec pvnr_cn_ttl; /* IN */
};

struct puffs_vnmsg_open {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
int pvnr_mode; /* OUT */
int pvnr_oflags; /* IN */
};

struct puffs_vnmsg_close {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
int pvnr_fflag; /* OUT */
};

struct puffs_vnmsg_access {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
int pvnr_mode; /* OUT */
};

#define puffs_vnmsg_setattr puffs_vnmsg_setgetattr
#define puffs_vnmsg_getattr puffs_vnmsg_setgetattr
struct puffs_vnmsg_setgetattr {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
struct vattr pvnr_va; /* IN/OUT (op depend) */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct timespec pvnr_va_ttl; /* IN */
};

#define puffs_vnmsg_read puffs_vnmsg_rw
#define puffs_vnmsg_write puffs_vnmsg_rw
struct puffs_vnmsg_rw {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
off_t pvnr_offset; /* OUT */
size_t pvnr_resid; /* IN/OUT */
int pvnr_ioflag; /* OUT */

uint8_t pvnr_data[0]; /* IN/OUT (wr/rd) */
};

#define puffs_vnmsg_ioctl puffs_vnreq_fcnioctl
#define puffs_vnmsg_fcntl puffs_vnreq_fcnioctl
struct puffs_vnmsg_fcnioctl {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred;
u_long pvnr_command;
pid_t pvnr_pid;
int pvnr_fflag;

void *pvnr_data;
size_t pvnr_datalen;
int pvnr_copyback;
};

struct puffs_vnmsg_poll {
struct puffs_req pvn_pr;

int pvnr_events; /* IN/OUT */
};

struct puffs_vnmsg_fsync {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
off_t pvnr_offlo; /* OUT */
off_t pvnr_offhi; /* OUT */
int pvnr_flags; /* OUT */
};

struct puffs_vnmsg_seek {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
off_t pvnr_oldoff; /* OUT */
off_t pvnr_newoff; /* OUT */
};

struct puffs_vnmsg_remove {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

puffs_cookie_t pvnr_cookie_targ; /* OUT */
};

struct puffs_vnmsg_mkdir {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

struct vattr pvnr_va; /* OUT */
puffs_cookie_t pvnr_newnode; /* IN */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct timespec pvnr_va_ttl; /* IN */
struct timespec pvnr_cn_ttl; /* IN */
};

struct puffs_vnmsg_rmdir {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

puffs_cookie_t pvnr_cookie_targ; /* OUT */
};

struct puffs_vnmsg_link {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

puffs_cookie_t pvnr_cookie_targ; /* OUT */
};

struct puffs_vnmsg_rename {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn_src; /* OUT */
struct puffs_kcred pvnr_cn_src_cred; /* OUT */
struct puffs_kcn pvnr_cn_targ; /* OUT */
struct puffs_kcred pvnr_cn_targ_cred; /* OUT */

puffs_cookie_t pvnr_cookie_src; /* OUT */
puffs_cookie_t pvnr_cookie_targ; /* OUT */
puffs_cookie_t pvnr_cookie_targdir; /* OUT */
};

struct puffs_vnmsg_symlink {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */

struct vattr pvnr_va; /* OUT */
puffs_cookie_t pvnr_newnode; /* IN */
char pvnr_link[MAXPATHLEN]; /* OUT */
/* Used only if PUFFS_KFLAG_CACHE_USE_TTL */
struct timespec pvnr_va_ttl; /* IN */
struct timespec pvnr_cn_ttl; /* IN */
};

struct puffs_vnmsg_readdir {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
off_t pvnr_offset; /* IN/OUT */
size_t pvnr_resid; /* IN/OUT */
size_t pvnr_ncookies; /* IN/OUT */
int pvnr_eofflag; /* IN */

size_t pvnr_dentoff; /* OUT */
uint8_t pvnr_data[0] /* IN */
__aligned(ALIGNBYTES+1);
};

struct puffs_vnmsg_readlink {
struct puffs_req pvn_pr;

struct puffs_kcred pvnr_cred; /* OUT */
size_t pvnr_linklen; /* IN */
char pvnr_link[MAXPATHLEN]; /* IN */
};

struct puffs_vnmsg_reclaim {
struct puffs_req pvn_pr;

int pvnr_nlookup; /* OUT */
};

struct puffs_vnmsg_inactive {
struct puffs_req pvn_pr;
};

struct puffs_vnmsg_print {
struct puffs_req pvn_pr;

/* empty */
};

struct puffs_vnmsg_pathconf {
struct puffs_req pvn_pr;

int pvnr_name; /* OUT */
__register_t pvnr_retval; /* IN */
};

struct puffs_vnmsg_advlock {
struct puffs_req pvn_pr;

struct flock pvnr_fl; /* OUT */
void *pvnr_id; /* OUT */
int pvnr_op; /* OUT */
int pvnr_flags; /* OUT */
};

struct puffs_vnmsg_mmap {
struct puffs_req pvn_pr;

vm_prot_t pvnr_prot; /* OUT */
struct puffs_kcred pvnr_cred; /* OUT */
};

struct puffs_vnmsg_abortop {
struct puffs_req pvn_pr;

struct puffs_kcn pvnr_cn; /* OUT */
struct puffs_kcred pvnr_cn_cred; /* OUT */
};

struct puffs_vnmsg_getextattr {
struct puffs_req pvn_pr;

int pvnr_attrnamespace; /* OUT */
char pvnr_attrname[PUFFS_EXTNAMELEN];/* OUT */

struct puffs_kcred pvnr_cred; /* OUT */
size_t pvnr_datasize; /* IN */

size_t pvnr_resid; /* IN/OUT */
uint8_t pvnr_data[0] /* IN */
__aligned(ALIGNBYTES+1);
};

struct puffs_vnmsg_setextattr {
struct puffs_req pvn_pr;

int pvnr_attrnamespace; /* OUT */
char pvnr_attrname[PUFFS_EXTNAMELEN];/* OUT */

struct puffs_kcred pvnr_cred; /* OUT */

size_t pvnr_resid; /* IN/OUT */
uint8_t pvnr_data[0] /* OUT */
__aligned(ALIGNBYTES+1);
};

struct puffs_vnmsg_listextattr {
struct puffs_req pvn_pr;

int pvnr_attrnamespace; /* OUT */

struct puffs_kcred pvnr_cred; /* OUT */
size_t pvnr_datasize; /* IN */

size_t pvnr_resid; /* IN/OUT */
int pvnr_flag; /* OUT */
uint8_t pvnr_data[0] /* IN */
__aligned(ALIGNBYTES+1);
};

struct puffs_vnmsg_deleteextattr {
struct puffs_req pvn_pr;

int pvnr_attrnamespace; /* OUT */
char pvnr_attrname[PUFFS_EXTNAMELEN];/* OUT */

struct puffs_kcred pvnr_cred; /* OUT */
};

#define PUFFS_HAVE_FALLOCATE 1
struct puffs_vnmsg_fallocate {
struct puffs_req pvn_pr;
off_t pvnr_off; /* OUT */
off_t pvnr_len; /* OUT */
};

struct puffs_vnmsg_fdiscard {
struct puffs_req pvn_pr;
off_t pvnr_off; /* OUT */
off_t pvnr_len; /* OUT */
};

/*
* For cache reports. Everything is always out-out-out, no replies
*/

struct puffs_cacherun {
off_t pcache_runstart;
off_t pcache_runend;
};

/* cache info. old used for write now */
struct puffs_cacheinfo {
struct puffs_req pcache_pr;

int pcache_type;
size_t pcache_nruns;
struct puffs_cacherun pcache_runs[0];
};
#define PCACHE_TYPE_READ 0
#define PCACHE_TYPE_WRITE 1

/*
* Error notification. Always outgoing, no response, no remorse.
*/
struct puffs_error {
struct puffs_req perr_pr;

int perr_error;
char perr_str[256];
};

#endif /* _FS_PUFFS_PUFFS_MSGIF_H_ */