Differential D21110 Diff 60506 sys/fs/fuse/fuse_kernel.h

Changeset View

Standalone View

sys/fs/fuse/fuse_kernel.h

/*--		/*--
* This file defines the kernel interface of FUSE		* This file defines the kernel interface of FUSE
* Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>		* Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
*		*
* This program can be distributed under the terms of the GNU GPL.		* This program can be distributed under the terms of the GNU GPL.
* See the file COPYING.		* See the file COPYING.
*		*
* This -- and only this -- header file may also be distributed under		* This -- and only this -- header file may also be distributed under
* the terms of the BSD Licence as follows:		* the terms of the BSD Licence as follows:
*		*
* Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.		* Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.
Show All 17 Lines
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY		* 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		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.		* SUCH DAMAGE.
*		*
* $FreeBSD$		* $FreeBSD$
*/		*/

#ifndef linux		/*
#include <sys/types.h>		* This file defines the kernel interface of FUSE
#define __u64 uint64_t		*
#define __u32 uint32_t		* Protocol changelog:
#define __s32 int32_t		*
		* 7.9:
		* - new fuse_getattr_in input argument of GETATTR
		* - add lk_flags in fuse_lk_in
		* - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
		* - add blksize field to fuse_attr
		* - add file flags field to fuse_read_in and fuse_write_in
		*
		* 7.10
		* - add nonseekable open flag
		*
		* 7.11
		* - add IOCTL message
		* - add unsolicited notification support
		*
		* 7.12
		* - add umask flag to input argument of open, mknod and mkdir
		* - add notification messages for invalidation of inodes and
		* directory entries
		*
		* 7.13
		* - make max number of background requests and congestion threshold
		* tunables
		*
		* 7.14
		* - add splice support to fuse device
		*
		* 7.15
		* - add store notify
		* - add retrieve notify
		*
		* 7.16
		* - add BATCH_FORGET request
		* - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
		* fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
		* - add FUSE_IOCTL_32BIT flag
		*
		* 7.17
		* - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
		*
		* 7.18
		* - add FUSE_IOCTL_DIR flag
		* - add FUSE_NOTIFY_DELETE
		*
		* 7.19
		* - add FUSE_FALLOCATE
		*
		* 7.20
		* - add FUSE_AUTO_INVAL_DATA
		* 7.21
		* - add FUSE_READDIRPLUS
		* - send the requested events in POLL request
		*
		* 7.22
		* - add FUSE_ASYNC_DIO
		*
		* 7.23
		* - add FUSE_WRITEBACK_CACHE
		* - add time_gran to fuse_init_out
		* - add reserved space to fuse_init_out
		* - add FATTR_CTIME
		* - add ctime and ctimensec to fuse_setattr_in
		* - add FUSE_RENAME2 request
		* - add FUSE_NO_OPEN_SUPPORT flag
		*/

		#ifndef _FUSE_FUSE_KERNEL_H
		#define _FUSE_FUSE_KERNEL_H

		#ifdef __linux__
		#include <linux/types.h>
#else		#else
#include <asm/types.h>		#include <sys/types.h>
#include <linux/major.h>
#endif		#endif

/** Version number of this interface */		/** Version number of this interface */
#define FUSE_KERNEL_VERSION 7		#define FUSE_KERNEL_VERSION 7

/** Minor version number of this interface */		/** Minor version number of this interface */
#define FUSE_KERNEL_MINOR_VERSION 8		#define FUSE_KERNEL_MINOR_VERSION 23

/** The node ID of the root inode */		/** The node ID of the root inode */
#define FUSE_ROOT_ID 1		#define FUSE_ROOT_ID 1

/** The major number of the fuse character device */
#define FUSE_MAJOR MISC_MAJOR

/** The minor number of the fuse character device */
#define FUSE_MINOR 229

/* Make sure all structures are padded to 64bit boundary, so 32bit		/* Make sure all structures are padded to 64bit boundary, so 32bit
userspace works under 64bit kernels */		userspace works under 64bit kernels */

struct fuse_attr {		struct fuse_attr {
__u64 ino;		uint64_t ino;
__u64 size;		uint64_t size;
__u64 blocks;		uint64_t blocks;
__u64 atime;		uint64_t atime;
__u64 mtime;		uint64_t mtime;
__u64 ctime;		uint64_t ctime;
__u32 atimensec;		uint32_t atimensec;
__u32 mtimensec;		uint32_t mtimensec;
__u32 ctimensec;		uint32_t ctimensec;
__u32 mode;		uint32_t mode;
__u32 nlink;		uint32_t nlink;
__u32 uid;		uint32_t uid;
__u32 gid;		uint32_t gid;
__u32 rdev;		uint32_t rdev;
		uint32_t blksize;
		uint32_t padding;
};		};

struct fuse_kstatfs {		struct fuse_kstatfs {
__u64 blocks;		uint64_t blocks;
__u64 bfree;		uint64_t bfree;
__u64 bavail;		uint64_t bavail;
__u64 files;		uint64_t files;
__u64 ffree;		uint64_t ffree;
__u32 bsize;		uint32_t bsize;
__u32 namelen;		uint32_t namelen;
__u32 frsize;		uint32_t frsize;
__u32 padding;		uint32_t padding;
__u32 spare[6];		uint32_t spare[6];
};		};

struct fuse_file_lock {		struct fuse_file_lock {
__u64 start;		uint64_t start;
__u64 end;		uint64_t end;
__u32 type;		uint32_t type;
__u32 pid; /* tgid */		uint32_t pid; /* tgid */
};		};

/**		/**
* Bitmasks for fuse_setattr_in.valid		* Bitmasks for fuse_setattr_in.valid
*/		*/
#define FATTR_MODE (1 << 0)		#define FATTR_MODE (1 << 0)
#define FATTR_UID (1 << 1)		#define FATTR_UID (1 << 1)
#define FATTR_GID (1 << 2)		#define FATTR_GID (1 << 2)
#define FATTR_SIZE (1 << 3)		#define FATTR_SIZE (1 << 3)
#define FATTR_ATIME (1 << 4)		#define FATTR_ATIME (1 << 4)
#define FATTR_MTIME (1 << 5)		#define FATTR_MTIME (1 << 5)
#define FATTR_FH (1 << 6)		#define FATTR_FH (1 << 6)
		#define FATTR_ATIME_NOW (1 << 7)
		#define FATTR_MTIME_NOW (1 << 8)
		#define FATTR_LOCKOWNER (1 << 9)
		#define FATTR_CTIME (1 << 10)

/**		/**
* Flags returned by the OPEN request		* Flags returned by the OPEN request
*		*
* FOPEN_DIRECT_IO: bypass page cache for this open file		* FOPEN_DIRECT_IO: bypass page cache for this open file
* FOPEN_KEEP_CACHE: don't invalidate the data cache on open		* FOPEN_KEEP_CACHE: don't invalidate the data cache on open
		* FOPEN_NONSEEKABLE: the file is not seekable
*/		*/
#define FOPEN_DIRECT_IO (1 << 0)		#define FOPEN_DIRECT_IO (1 << 0)
#define FOPEN_KEEP_CACHE (1 << 1)		#define FOPEN_KEEP_CACHE (1 << 1)
		#define FOPEN_NONSEEKABLE (1 << 2)

/**		/**
* INIT request/reply flags		* INIT request/reply flags
		*
		* FUSE_ASYNC_READ: asynchronous read requests
		* FUSE_POSIX_LOCKS: remote locking for POSIX file locks
		* FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported)
		* FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem
		* FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
		* FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB
		* FUSE_DONT_MASK: don't apply umask to file mode on create operations
		* FUSE_SPLICE_WRITE: kernel supports splice write on the device
		* FUSE_SPLICE_MOVE: kernel supports splice move on the device
		* FUSE_SPLICE_READ: kernel supports splice read on the device
		* FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
		* FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories
		* FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages
		* FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one)
		* FUSE_READDIRPLUS_AUTO: adaptive readdirplus
		* FUSE_ASYNC_DIO: asynchronous direct I/O submission
		* FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes
		* FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens
*/		*/
#define FUSE_ASYNC_READ (1 << 0)		#define FUSE_ASYNC_READ (1 << 0)
#define FUSE_POSIX_LOCKS (1 << 1)		#define FUSE_POSIX_LOCKS (1 << 1)
		#define FUSE_FILE_OPS (1 << 2)
		#define FUSE_ATOMIC_O_TRUNC (1 << 3)
		#define FUSE_EXPORT_SUPPORT (1 << 4)
		#define FUSE_BIG_WRITES (1 << 5)
		#define FUSE_DONT_MASK (1 << 6)
		#define FUSE_SPLICE_WRITE (1 << 7)
		#define FUSE_SPLICE_MOVE (1 << 8)
		#define FUSE_SPLICE_READ (1 << 9)
		#define FUSE_FLOCK_LOCKS (1 << 10)
		#define FUSE_HAS_IOCTL_DIR (1 << 11)
		#define FUSE_AUTO_INVAL_DATA (1 << 12)
		#define FUSE_DO_READDIRPLUS (1 << 13)
		#define FUSE_READDIRPLUS_AUTO (1 << 14)
		#define FUSE_ASYNC_DIO (1 << 15)
		#define FUSE_WRITEBACK_CACHE (1 << 16)
		#define FUSE_NO_OPEN_SUPPORT (1 << 17)

		#ifdef linux
/**		/**
		* CUSE INIT request/reply flags
		*
		* CUSE_UNRESTRICTED_IOCTL: use unrestricted ioctl
		*/
		#define CUSE_UNRESTRICTED_IOCTL (1 << 0)
		#endif /* linux */

		/**
* Release flags		* Release flags
*/		*/
#define FUSE_RELEASE_FLUSH (1 << 0)		#define FUSE_RELEASE_FLUSH (1 << 0)
		#define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1)

		/**
		* Getattr flags
		*/
		#define FUSE_GETATTR_FH (1 << 0)

		/**
		* Lock flags
		*/
		#define FUSE_LK_FLOCK (1 << 0)

		/**
		* WRITE flags
		*
		* FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
		* FUSE_WRITE_LOCKOWNER: lock_owner field is valid
		*/
		#define FUSE_WRITE_CACHE (1 << 0)
		#define FUSE_WRITE_LOCKOWNER (1 << 1)

		/**
		* Read flags
		*/
		#define FUSE_READ_LOCKOWNER (1 << 1)

		/**
		* Ioctl flags
		*
		* FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
		* FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
		* FUSE_IOCTL_RETRY: retry with new iovecs
		* FUSE_IOCTL_32BIT: 32bit ioctl
		* FUSE_IOCTL_DIR: is a directory
		*
		* FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
		*/
		#define FUSE_IOCTL_COMPAT (1 << 0)
		#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
		#define FUSE_IOCTL_RETRY (1 << 2)
		#define FUSE_IOCTL_32BIT (1 << 3)
		#define FUSE_IOCTL_DIR (1 << 4)

		#define FUSE_IOCTL_MAX_IOV 256

		/**
		* Poll flags
		*
		* FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
		*/
		#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)

enum fuse_opcode {		enum fuse_opcode {
FUSE_LOOKUP = 1,		FUSE_LOOKUP = 1,
FUSE_FORGET = 2, /* no reply */		FUSE_FORGET = 2, /* no reply */
FUSE_GETATTR = 3,		FUSE_GETATTR = 3,
FUSE_SETATTR = 4,		FUSE_SETATTR = 4,
FUSE_READLINK = 5,		FUSE_READLINK = 5,
FUSE_SYMLINK = 6,		FUSE_SYMLINK = 6,
FUSE_MKNOD = 8,		FUSE_MKNOD = 8,
Show All 21 Lines	enum fuse_opcode {
FUSE_GETLK = 31,		FUSE_GETLK = 31,
FUSE_SETLK = 32,		FUSE_SETLK = 32,
FUSE_SETLKW = 33,		FUSE_SETLKW = 33,
FUSE_ACCESS = 34,		FUSE_ACCESS = 34,
FUSE_CREATE = 35,		FUSE_CREATE = 35,
FUSE_INTERRUPT = 36,		FUSE_INTERRUPT = 36,
FUSE_BMAP = 37,		FUSE_BMAP = 37,
FUSE_DESTROY = 38,		FUSE_DESTROY = 38,
		FUSE_IOCTL = 39,
		FUSE_POLL = 40,
		FUSE_NOTIFY_REPLY = 41,
		FUSE_BATCH_FORGET = 42,
		FUSE_FALLOCATE = 43,
		FUSE_READDIRPLUS = 44,
		FUSE_RENAME2 = 45,

		#ifdef linux
		/* CUSE specific operations */
		CUSE_INIT = 4096,
		#endif /* linux */
};		};

		enum fuse_notify_code {
		FUSE_NOTIFY_POLL = 1,
		FUSE_NOTIFY_INVAL_INODE = 2,
		FUSE_NOTIFY_INVAL_ENTRY = 3,
		FUSE_NOTIFY_STORE = 4,
		FUSE_NOTIFY_RETRIEVE = 5,
		FUSE_NOTIFY_DELETE = 6,
		FUSE_NOTIFY_CODE_MAX,
		};

/* The read buffer is required to be at least 8k, but may be much larger */		/* The read buffer is required to be at least 8k, but may be much larger */
#define FUSE_MIN_READ_BUFFER 8192		#define FUSE_MIN_READ_BUFFER 8192

		#define FUSE_COMPAT_ENTRY_OUT_SIZE 120

struct fuse_entry_out {		struct fuse_entry_out {
__u64 nodeid; /* Inode ID */		uint64_t nodeid; /* Inode ID */
__u64 generation; /* Inode generation: nodeid:gen must		uint64_t generation; /* Inode generation: nodeid:gen must
be unique for the fs's lifetime */		be unique for the fs's lifetime */
__u64 entry_valid; /* Cache timeout for the name */		uint64_t entry_valid; /* Cache timeout for the name */
__u64 attr_valid; /* Cache timeout for the attributes */		uint64_t attr_valid; /* Cache timeout for the attributes */
__u32 entry_valid_nsec;		uint32_t entry_valid_nsec;
__u32 attr_valid_nsec;		uint32_t attr_valid_nsec;
struct fuse_attr attr;		struct fuse_attr attr;
};		};

struct fuse_forget_in {		struct fuse_forget_in {
__u64 nlookup;		uint64_t nlookup;
};		};

		struct fuse_forget_one {
		uint64_t nodeid;
		uint64_t nlookup;
		};

		struct fuse_batch_forget_in {
		uint32_t count;
		uint32_t dummy;
		};

		struct fuse_getattr_in {
		uint32_t getattr_flags;
		uint32_t dummy;
		uint64_t fh;
		};

		#define FUSE_COMPAT_ATTR_OUT_SIZE 96

struct fuse_attr_out {		struct fuse_attr_out {
__u64 attr_valid; /* Cache timeout for the attributes */		uint64_t attr_valid; /* Cache timeout for the attributes */
__u32 attr_valid_nsec;		uint32_t attr_valid_nsec;
__u32 dummy;		uint32_t dummy;
struct fuse_attr attr;		struct fuse_attr attr;
};		};

		#define FUSE_COMPAT_MKNOD_IN_SIZE 8

		struct fuse_mknod_in {
		uint32_t mode;
		uint32_t rdev;
		uint32_t umask;
		uint32_t padding;
		};

struct fuse_mkdir_in {		struct fuse_mkdir_in {
__u32 mode;		uint32_t mode;
__u32 padding;		uint32_t umask;
};		};

struct fuse_rename_in {		struct fuse_rename_in {
__u64 newdir;		uint64_t newdir;
};		};

		struct fuse_rename2_in {
		uint64_t newdir;
		uint32_t flags;
		uint32_t padding;
		};

struct fuse_link_in {		struct fuse_link_in {
__u64 oldnodeid;		uint64_t oldnodeid;
};		};

struct fuse_setattr_in {		struct fuse_setattr_in {
__u32 valid;		uint32_t valid;
__u32 padding;		uint32_t padding;
__u64 fh;		uint64_t fh;
__u64 size;		uint64_t size;
__u64 unused1;		uint64_t lock_owner;
__u64 atime;		uint64_t atime;
__u64 mtime;		uint64_t mtime;
__u64 unused2;		uint64_t ctime;
__u32 atimensec;		uint32_t atimensec;
__u32 mtimensec;		uint32_t mtimensec;
__u32 unused3;		uint32_t ctimensec;
__u32 mode;		uint32_t mode;
__u32 unused4;		uint32_t unused4;
__u32 uid;		uint32_t uid;
__u32 gid;		uint32_t gid;
__u32 unused5;		uint32_t unused5;
};		};

struct fuse_open_in {		struct fuse_open_in {
__u32 flags;		uint32_t flags;
__u32 mode;		uint32_t unused;
};		};

		struct fuse_create_in {
		uint32_t flags;
		uint32_t mode;
		uint32_t umask;
		uint32_t padding;
		};

struct fuse_open_out {		struct fuse_open_out {
__u64 fh;		uint64_t fh;
__u32 open_flags;		uint32_t open_flags;
__u32 padding;		uint32_t padding;
};		};

struct fuse_release_in {		struct fuse_release_in {
__u64 fh;		uint64_t fh;
__u32 flags;		uint32_t flags;
__u32 release_flags;		uint32_t release_flags;
__u64 lock_owner;		uint64_t lock_owner;
};		};

struct fuse_flush_in {		struct fuse_flush_in {
__u64 fh;		uint64_t fh;
__u32 unused;		uint32_t unused;
__u32 padding;		uint32_t padding;
__u64 lock_owner;		uint64_t lock_owner;
};		};

struct fuse_read_in {		struct fuse_read_in {
__u64 fh;		uint64_t fh;
__u64 offset;		uint64_t offset;
__u32 size;		uint32_t size;
__u32 padding;		uint32_t read_flags;
		uint64_t lock_owner;
		uint32_t flags;
		uint32_t padding;
};		};

		#define FUSE_COMPAT_WRITE_IN_SIZE 24

struct fuse_write_in {		struct fuse_write_in {
__u64 fh;		uint64_t fh;
__u64 offset;		uint64_t offset;
__u32 size;		uint32_t size;
__u32 write_flags;		uint32_t write_flags;
		uint64_t lock_owner;
		uint32_t flags;
		uint32_t padding;
};		};

struct fuse_write_out {		struct fuse_write_out {
__u32 size;		uint32_t size;
__u32 padding;		uint32_t padding;
};		};

#define FUSE_COMPAT_STATFS_SIZE 48		#define FUSE_COMPAT_STATFS_SIZE 48

struct fuse_statfs_out {		struct fuse_statfs_out {
struct fuse_kstatfs st;		struct fuse_kstatfs st;
};		};

struct fuse_fsync_in {		struct fuse_fsync_in {
__u64 fh;		uint64_t fh;
__u32 fsync_flags;		uint32_t fsync_flags;
__u32 padding;		uint32_t padding;
};		};

		struct fuse_setxattr_in {
		uint32_t size;
		uint32_t flags;
		};

struct fuse_listxattr_in {		struct fuse_listxattr_in {
__u32 size;		uint32_t size;
__u32 flags;		uint32_t padding;
};		};

struct fuse_listxattr_out {		struct fuse_listxattr_out {
__u32 size;		uint32_t size;
__u32 flags;		uint32_t padding;
};		};

struct fuse_getxattr_in {		struct fuse_getxattr_in {
__u32 size;		uint32_t size;
__u32 padding;		uint32_t padding;
};		};

struct fuse_getxattr_out {		struct fuse_getxattr_out {
__u32 size;		uint32_t size;
__u32 padding;		uint32_t padding;
};		};

struct fuse_setxattr_in {
__u32 size;
__u32 flags;
};

struct fuse_lk_in {		struct fuse_lk_in {
__u64 fh;		uint64_t fh;
__u64 owner;		uint64_t owner;
struct fuse_file_lock lk;		struct fuse_file_lock lk;
		uint32_t lk_flags;
		uint32_t padding;
};		};

struct fuse_lk_out {		struct fuse_lk_out {
struct fuse_file_lock lk;		struct fuse_file_lock lk;
};		};

struct fuse_access_in {		struct fuse_access_in {
__u32 mask;		uint32_t mask;
__u32 padding;		uint32_t padding;
};		};

struct fuse_init_in {		struct fuse_init_in {
__u32 major;		uint32_t major;
__u32 minor;		uint32_t minor;
__u32 max_readahead;		uint32_t max_readahead;
__u32 flags;		uint32_t flags;
};		};

		#define FUSE_COMPAT_INIT_OUT_SIZE 8
		#define FUSE_COMPAT_22_INIT_OUT_SIZE 24

struct fuse_init_out {		struct fuse_init_out {
__u32 major;		uint32_t major;
__u32 minor;		uint32_t minor;
__u32 max_readahead;		uint32_t max_readahead;
__u32 flags;		uint32_t flags;
__u32 unused;		uint16_t max_background;
__u32 max_write;		uint16_t congestion_threshold;
		uint32_t max_write;
		uint32_t time_gran;
		uint32_t unused[9];
};		};

		#ifdef linux
		#define CUSE_INIT_INFO_MAX 4096

		struct cuse_init_in {
		uint32_t major;
		uint32_t minor;
		uint32_t unused;
		uint32_t flags;
		};

		struct cuse_init_out {
		uint32_t major;
		uint32_t minor;
		uint32_t unused;
		uint32_t flags;
		uint32_t max_read;
		uint32_t max_write;
		uint32_t dev_major; /* chardev major */
		uint32_t dev_minor; /* chardev minor */
		uint32_t spare[10];
		};
		#endif /* linux */

struct fuse_interrupt_in {		struct fuse_interrupt_in {
__u64 unique;		uint64_t unique;
};		};

struct fuse_bmap_in {		struct fuse_bmap_in {
__u64 block;		uint64_t block;
__u32 blocksize;		uint32_t blocksize;
__u32 padding;		uint32_t padding;
};		};

struct fuse_bmap_out {		struct fuse_bmap_out {
__u64 block;		uint64_t block;
};		};

		struct fuse_ioctl_in {
		uint64_t fh;
		uint32_t flags;
		uint32_t cmd;
		uint64_t arg;
		uint32_t in_size;
		uint32_t out_size;
		};

		struct fuse_ioctl_iovec {
		uint64_t base;
		uint64_t len;
		};

		struct fuse_ioctl_out {
		int32_t result;
		uint32_t flags;
		uint32_t in_iovs;
		uint32_t out_iovs;
		};

		struct fuse_poll_in {
		uint64_t fh;
		uint64_t kh;
		uint32_t flags;
		uint32_t events;
		};

		struct fuse_poll_out {
		uint32_t revents;
		uint32_t padding;
		};

		struct fuse_notify_poll_wakeup_out {
		uint64_t kh;
		};

		struct fuse_fallocate_in {
		uint64_t fh;
		uint64_t offset;
		uint64_t length;
		uint32_t mode;
		uint32_t padding;
		};

struct fuse_in_header {		struct fuse_in_header {
__u32 len;		uint32_t len;
__u32 opcode;		uint32_t opcode;
__u64 unique;		uint64_t unique;
__u64 nodeid;		uint64_t nodeid;
__u32 uid;		uint32_t uid;
__u32 gid;		uint32_t gid;
__u32 pid;		uint32_t pid;
__u32 padding;		uint32_t padding;
};		};

struct fuse_out_header {		struct fuse_out_header {
__u32 len;		uint32_t len;
__s32 error;		int32_t error;
__u64 unique;		uint64_t unique;
};		};

struct fuse_dirent {		struct fuse_dirent {
__u64 ino;		uint64_t ino;
__u64 off;		uint64_t off;
__u32 namelen;		uint32_t namelen;
__u32 type;		uint32_t type;
char name[0];		char name[];
};		};

#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)		#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
#define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))		#define FUSE_DIRENT_ALIGN(x) \
		(((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
#define FUSE_DIRENT_SIZE(d) \		#define FUSE_DIRENT_SIZE(d) \
FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)		FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)

		struct fuse_direntplus {
		struct fuse_entry_out entry_out;
		struct fuse_dirent dirent;
		};

		#define FUSE_NAME_OFFSET_DIRENTPLUS \
		offsetof(struct fuse_direntplus, dirent.name)
		#define FUSE_DIRENTPLUS_SIZE(d) \
		FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)

		struct fuse_notify_inval_inode_out {
		uint64_t ino;
		int64_t off;
		int64_t len;
		};

		struct fuse_notify_inval_entry_out {
		uint64_t parent;
		uint32_t namelen;
		uint32_t padding;
		};

		struct fuse_notify_delete_out {
		uint64_t parent;
		uint64_t child;
		uint32_t namelen;
		uint32_t padding;
		};

		struct fuse_notify_store_out {
		uint64_t nodeid;
		uint64_t offset;
		uint32_t size;
		uint32_t padding;
		};

		struct fuse_notify_retrieve_out {
		uint64_t notify_unique;
		uint64_t nodeid;
		uint64_t offset;
		uint32_t size;
		uint32_t padding;
		};

		/* Matches the size of fuse_write_in */
		struct fuse_notify_retrieve_in {
		uint64_t dummy1;
		uint64_t offset;
		uint32_t size;
		uint32_t dummy2;
		uint64_t dummy3;
		uint64_t dummy4;
		};

		#endif /* _FUSE_FUSE_KERNEL_H */