regulator: tps65090: convert regualtor_init_data as pointer
[linux-2.6.git] / include / linux / fuse.h
index acbeb96..464cff5 100644 (file)
@@ -1,30 +1,91 @@
 /*
     FUSE: Filesystem in Userspace
-    Copyright (C) 2001-2005  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.
     See the file COPYING.
 */
 
-/* This file defines the kernel interface of FUSE */
+/*
+ * This file defines the kernel interface of FUSE
+ *
+ * Protocol changelog:
+ *
+ * 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
+ *  - add POLL message and NOTIFY_POLL notification
+ *
+ * 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
+ */
+
+#ifndef _LINUX_FUSE_H
+#define _LINUX_FUSE_H
 
-#include <asm/types.h>
+#include <linux/types.h>
+
+/*
+ * Version negotiation:
+ *
+ * Both the kernel and userspace send the version they support in the
+ * INIT request and reply respectively.
+ *
+ * If the major versions match then both shall use the smallest
+ * of the two minor versions for communication.
+ *
+ * If the kernel supports a larger major version, then userspace shall
+ * reply with the major version it supports, ignore the rest of the
+ * INIT message and expect a new INIT message from the kernel with a
+ * matching major version.
+ *
+ * If the library supports a larger major version, then it shall fall
+ * back to the major protocol version sent by the kernel for
+ * communication and reply with that major version (and an arbitrary
+ * supported minor version).
+ */
 
 /** Version number of this interface */
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 2
+#define FUSE_KERNEL_MINOR_VERSION 17
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
 
-/** The major number of the fuse character device */
-#define FUSE_MAJOR 10
-
-/** The minor number of the fuse character device */
-#define FUSE_MINOR 229
-
 /* Make sure all structures are padded to 64bit boundary, so 32bit
    userspace works under 64bit kernels */
 
@@ -43,6 +104,8 @@ struct fuse_attr {
        __u32   uid;
        __u32   gid;
        __u32   rdev;
+       __u32   blksize;
+       __u32   padding;
 };
 
 struct fuse_kstatfs {
@@ -53,24 +116,120 @@ struct fuse_kstatfs {
        __u64   ffree;
        __u32   bsize;
        __u32   namelen;
+       __u32   frsize;
+       __u32   padding;
+       __u32   spare[6];
+};
+
+struct fuse_file_lock {
+       __u64   start;
+       __u64   end;
+       __u32   type;
+       __u32   pid; /* tgid */
 };
 
+/**
+ * Bitmasks for fuse_setattr_in.valid
+ */
 #define FATTR_MODE     (1 << 0)
 #define FATTR_UID      (1 << 1)
 #define FATTR_GID      (1 << 2)
 #define FATTR_SIZE     (1 << 3)
 #define FATTR_ATIME    (1 << 4)
 #define FATTR_MTIME    (1 << 5)
-#define FATTR_CTIME    (1 << 6)
+#define FATTR_FH       (1 << 6)
+#define FATTR_ATIME_NOW        (1 << 7)
+#define FATTR_MTIME_NOW        (1 << 8)
+#define FATTR_LOCKOWNER        (1 << 9)
 
 /**
  * Flags returned by the OPEN request
  *
  * FOPEN_DIRECT_IO: bypass page cache for this open file
  * 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_KEEP_CACHE       (1 << 1)
+#define FOPEN_NONSEEKABLE      (1 << 2)
+
+/**
+ * INIT request/reply flags
+ *
+ * FUSE_POSIX_LOCKS: remote locking for POSIX file locks
+ * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
+ * FUSE_DONT_MASK: don't apply umask to file mode on create operations
+ * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
+ */
+#define FUSE_ASYNC_READ                (1 << 0)
+#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_FLOCK_LOCKS       (1 << 10)
+
+/**
+ * CUSE INIT request/reply flags
+ *
+ * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
+ */
+#define CUSE_UNRESTRICTED_IOCTL        (1 << 0)
+
+/**
+ * Release flags
+ */
+#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_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_MAX_IOV     256
+
+/**
+ * Poll flags
+ *
+ * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
+ */
+#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
 
 enum fuse_opcode {
        FUSE_LOOKUP        = 1,
@@ -100,15 +259,37 @@ enum fuse_opcode {
        FUSE_OPENDIR       = 27,
        FUSE_READDIR       = 28,
        FUSE_RELEASEDIR    = 29,
-       FUSE_FSYNCDIR      = 30
+       FUSE_FSYNCDIR      = 30,
+       FUSE_GETLK         = 31,
+       FUSE_SETLK         = 32,
+       FUSE_SETLKW        = 33,
+       FUSE_ACCESS        = 34,
+       FUSE_CREATE        = 35,
+       FUSE_INTERRUPT     = 36,
+       FUSE_BMAP          = 37,
+       FUSE_DESTROY       = 38,
+       FUSE_IOCTL         = 39,
+       FUSE_POLL          = 40,
+       FUSE_NOTIFY_REPLY  = 41,
+       FUSE_BATCH_FORGET  = 42,
+
+       /* CUSE specific operations */
+       CUSE_INIT          = 4096,
 };
 
-/* Conservative buffer size for the client */
-#define FUSE_MAX_IN 8192
+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_CODE_MAX,
+};
 
-#define FUSE_NAME_MAX 1024
-#define FUSE_SYMLINK_MAX 4096
-#define FUSE_XATTR_SIZE_MAX 4096
+/* The read buffer is required to be at least 8k, but may be much larger */
+#define FUSE_MIN_READ_BUFFER 8192
+
+#define FUSE_COMPAT_ENTRY_OUT_SIZE 120
 
 struct fuse_entry_out {
        __u64   nodeid;         /* Inode ID */
@@ -125,6 +306,24 @@ struct fuse_forget_in {
        __u64   nlookup;
 };
 
+struct fuse_forget_one {
+       __u64   nodeid;
+       __u64   nlookup;
+};
+
+struct fuse_batch_forget_in {
+       __u32   count;
+       __u32   dummy;
+};
+
+struct fuse_getattr_in {
+       __u32   getattr_flags;
+       __u32   dummy;
+       __u64   fh;
+};
+
+#define FUSE_COMPAT_ATTR_OUT_SIZE 96
+
 struct fuse_attr_out {
        __u64   attr_valid;     /* Cache timeout for the attributes */
        __u32   attr_valid_nsec;
@@ -132,14 +331,18 @@ struct fuse_attr_out {
        struct fuse_attr attr;
 };
 
+#define FUSE_COMPAT_MKNOD_IN_SIZE 8
+
 struct fuse_mknod_in {
        __u32   mode;
        __u32   rdev;
+       __u32   umask;
+       __u32   padding;
 };
 
 struct fuse_mkdir_in {
        __u32   mode;
-       __u32   padding;
+       __u32   umask;
 };
 
 struct fuse_rename_in {
@@ -153,11 +356,31 @@ struct fuse_link_in {
 struct fuse_setattr_in {
        __u32   valid;
        __u32   padding;
-       struct fuse_attr attr;
+       __u64   fh;
+       __u64   size;
+       __u64   lock_owner;
+       __u64   atime;
+       __u64   mtime;
+       __u64   unused2;
+       __u32   atimensec;
+       __u32   mtimensec;
+       __u32   unused3;
+       __u32   mode;
+       __u32   unused4;
+       __u32   uid;
+       __u32   gid;
+       __u32   unused5;
 };
 
 struct fuse_open_in {
        __u32   flags;
+       __u32   unused;
+};
+
+struct fuse_create_in {
+       __u32   flags;
+       __u32   mode;
+       __u32   umask;
        __u32   padding;
 };
 
@@ -170,27 +393,37 @@ struct fuse_open_out {
 struct fuse_release_in {
        __u64   fh;
        __u32   flags;
-       __u32   padding;
+       __u32   release_flags;
+       __u64   lock_owner;
 };
 
 struct fuse_flush_in {
        __u64   fh;
-       __u32   flush_flags;
+       __u32   unused;
        __u32   padding;
+       __u64   lock_owner;
 };
 
 struct fuse_read_in {
        __u64   fh;
        __u64   offset;
        __u32   size;
+       __u32   read_flags;
+       __u64   lock_owner;
+       __u32   flags;
        __u32   padding;
 };
 
+#define FUSE_COMPAT_WRITE_IN_SIZE 24
+
 struct fuse_write_in {
        __u64   fh;
        __u64   offset;
        __u32   size;
        __u32   write_flags;
+       __u64   lock_owner;
+       __u32   flags;
+       __u32   padding;
 };
 
 struct fuse_write_out {
@@ -198,6 +431,8 @@ struct fuse_write_out {
        __u32   padding;
 };
 
+#define FUSE_COMPAT_STATFS_SIZE 48
+
 struct fuse_statfs_out {
        struct fuse_kstatfs st;
 };
@@ -223,9 +458,110 @@ struct fuse_getxattr_out {
        __u32   padding;
 };
 
-struct fuse_init_in_out {
+struct fuse_lk_in {
+       __u64   fh;
+       __u64   owner;
+       struct fuse_file_lock lk;
+       __u32   lk_flags;
+       __u32   padding;
+};
+
+struct fuse_lk_out {
+       struct fuse_file_lock lk;
+};
+
+struct fuse_access_in {
+       __u32   mask;
+       __u32   padding;
+};
+
+struct fuse_init_in {
+       __u32   major;
+       __u32   minor;
+       __u32   max_readahead;
+       __u32   flags;
+};
+
+struct fuse_init_out {
+       __u32   major;
+       __u32   minor;
+       __u32   max_readahead;
+       __u32   flags;
+       __u16   max_background;
+       __u16   congestion_threshold;
+       __u32   max_write;
+};
+
+#define CUSE_INIT_INFO_MAX 4096
+
+struct cuse_init_in {
+       __u32   major;
+       __u32   minor;
+       __u32   unused;
+       __u32   flags;
+};
+
+struct cuse_init_out {
        __u32   major;
        __u32   minor;
+       __u32   unused;
+       __u32   flags;
+       __u32   max_read;
+       __u32   max_write;
+       __u32   dev_major;              /* chardev major */
+       __u32   dev_minor;              /* chardev minor */
+       __u32   spare[10];
+};
+
+struct fuse_interrupt_in {
+       __u64   unique;
+};
+
+struct fuse_bmap_in {
+       __u64   block;
+       __u32   blocksize;
+       __u32   padding;
+};
+
+struct fuse_bmap_out {
+       __u64   block;
+};
+
+struct fuse_ioctl_in {
+       __u64   fh;
+       __u32   flags;
+       __u32   cmd;
+       __u64   arg;
+       __u32   in_size;
+       __u32   out_size;
+};
+
+struct fuse_ioctl_iovec {
+       __u64   base;
+       __u64   len;
+};
+
+struct fuse_ioctl_out {
+       __s32   result;
+       __u32   flags;
+       __u32   in_iovs;
+       __u32   out_iovs;
+};
+
+struct fuse_poll_in {
+       __u64   fh;
+       __u64   kh;
+       __u32   flags;
+       __u32   padding;
+};
+
+struct fuse_poll_out {
+       __u32   revents;
+       __u32   padding;
+};
+
+struct fuse_notify_poll_wakeup_out {
+       __u64   kh;
 };
 
 struct fuse_in_header {
@@ -253,7 +589,46 @@ struct fuse_dirent {
        char name[0];
 };
 
-#define FUSE_NAME_OFFSET ((unsigned) ((struct fuse_dirent *) 0)->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_SIZE(d) \
        FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
+
+struct fuse_notify_inval_inode_out {
+       __u64   ino;
+       __s64   off;
+       __s64   len;
+};
+
+struct fuse_notify_inval_entry_out {
+       __u64   parent;
+       __u32   namelen;
+       __u32   padding;
+};
+
+struct fuse_notify_store_out {
+       __u64   nodeid;
+       __u64   offset;
+       __u32   size;
+       __u32   padding;
+};
+
+struct fuse_notify_retrieve_out {
+       __u64   notify_unique;
+       __u64   nodeid;
+       __u64   offset;
+       __u32   size;
+       __u32   padding;
+};
+
+/* Matches the size of fuse_write_in */
+struct fuse_notify_retrieve_in {
+       __u64   dummy1;
+       __u64   offset;
+       __u32   size;
+       __u32   dummy2;
+       __u64   dummy3;
+       __u64   dummy4;
+};
+
+#endif /* _LINUX_FUSE_H */