"Fossies" - the Fresh Open Source Software Archive

Member "fuse-3.2.1/include/fuse_kernel.h" (14 Nov 2017, 17343 Bytes) of package /linux/misc/fuse-3.2.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "fuse_kernel.h" see the Fossies "Dox" file reference documentation.

    1 /*
    2     This file defines the kernel interface of FUSE
    3     Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
    4 
    5     This program can be distributed under the terms of the GNU GPL.
    6     See the file COPYING.
    7 
    8     This -- and only this -- header file may also be distributed under
    9     the terms of the BSD Licence as follows:
   10 
   11     Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.
   12 
   13     Redistribution and use in source and binary forms, with or without
   14     modification, are permitted provided that the following conditions
   15     are met:
   16     1. Redistributions of source code must retain the above copyright
   17        notice, this list of conditions and the following disclaimer.
   18     2. Redistributions in binary form must reproduce the above copyright
   19        notice, this list of conditions and the following disclaimer in the
   20        documentation and/or other materials provided with the distribution.
   21 
   22     THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   23     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25     ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
   26     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28     OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31     OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32     SUCH DAMAGE.
   33 */
   34 
   35 /*
   36  * This file defines the kernel interface of FUSE
   37  *
   38  * Protocol changelog:
   39  *
   40  * 7.9:
   41  *  - new fuse_getattr_in input argument of GETATTR
   42  *  - add lk_flags in fuse_lk_in
   43  *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
   44  *  - add blksize field to fuse_attr
   45  *  - add file flags field to fuse_read_in and fuse_write_in
   46  *
   47  * 7.10
   48  *  - add nonseekable open flag
   49  *
   50  * 7.11
   51  *  - add IOCTL message
   52  *  - add unsolicited notification support
   53  *  - add POLL message and NOTIFY_POLL notification
   54  *
   55  * 7.12
   56  *  - add umask flag to input argument of open, mknod and mkdir
   57  *  - add notification messages for invalidation of inodes and
   58  *    directory entries
   59  *
   60  * 7.13
   61  *  - make max number of background requests and congestion threshold
   62  *    tunables
   63  *
   64  * 7.14
   65  *  - add splice support to fuse device
   66  *
   67  * 7.15
   68  *  - add store notify
   69  *  - add retrieve notify
   70  *
   71  * 7.16
   72  *  - add BATCH_FORGET request
   73  *  - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
   74  *    fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
   75  *  - add FUSE_IOCTL_32BIT flag
   76  *
   77  * 7.17
   78  *  - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
   79  *
   80  * 7.18
   81  *  - add FUSE_IOCTL_DIR flag
   82  *  - add FUSE_NOTIFY_DELETE
   83  *
   84  * 7.19
   85  *  - add FUSE_FALLOCATE
   86  *
   87  * 7.20
   88  *  - add FUSE_AUTO_INVAL_DATA
   89  *
   90  * 7.21
   91  *  - add FUSE_READDIRPLUS
   92  *  - send the requested events in POLL request
   93  *
   94  * 7.22
   95  *  - add FUSE_ASYNC_DIO
   96  *
   97  * 7.23
   98  *  - add FUSE_WRITEBACK_CACHE
   99  *  - add time_gran to fuse_init_out
  100  *  - add reserved space to fuse_init_out
  101  *  - add FATTR_CTIME
  102  *  - add ctime and ctimensec to fuse_setattr_in
  103  *  - add FUSE_RENAME2 request
  104  *  - add FUSE_NO_OPEN_SUPPORT flag
  105  *
  106  *  7.24
  107  *  - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support
  108  *
  109  *  7.25
  110  *  - add FUSE_PARALLEL_DIROPS
  111  *
  112  *  7.26
  113  *  - add FUSE_HANDLE_KILLPRIV
  114  *  - add FUSE_POSIX_ACL
  115  */
  116 
  117 #ifndef _LINUX_FUSE_H
  118 #define _LINUX_FUSE_H
  119 
  120 #ifdef __KERNEL__
  121 #include <linux/types.h>
  122 #else
  123 #include <stdint.h>
  124 #endif
  125 
  126 /*
  127  * Version negotiation:
  128  *
  129  * Both the kernel and userspace send the version they support in the
  130  * INIT request and reply respectively.
  131  *
  132  * If the major versions match then both shall use the smallest
  133  * of the two minor versions for communication.
  134  *
  135  * If the kernel supports a larger major version, then userspace shall
  136  * reply with the major version it supports, ignore the rest of the
  137  * INIT message and expect a new INIT message from the kernel with a
  138  * matching major version.
  139  *
  140  * If the library supports a larger major version, then it shall fall
  141  * back to the major protocol version sent by the kernel for
  142  * communication and reply with that major version (and an arbitrary
  143  * supported minor version).
  144  */
  145 
  146 /** Version number of this interface */
  147 #define FUSE_KERNEL_VERSION 7
  148 
  149 /** Minor version number of this interface */
  150 #define FUSE_KERNEL_MINOR_VERSION 26
  151 
  152 /** The node ID of the root inode */
  153 #define FUSE_ROOT_ID 1
  154 
  155 /* Make sure all structures are padded to 64bit boundary, so 32bit
  156    userspace works under 64bit kernels */
  157 
  158 struct fuse_attr {
  159     uint64_t    ino;
  160     uint64_t    size;
  161     uint64_t    blocks;
  162     uint64_t    atime;
  163     uint64_t    mtime;
  164     uint64_t    ctime;
  165     uint32_t    atimensec;
  166     uint32_t    mtimensec;
  167     uint32_t    ctimensec;
  168     uint32_t    mode;
  169     uint32_t    nlink;
  170     uint32_t    uid;
  171     uint32_t    gid;
  172     uint32_t    rdev;
  173     uint32_t    blksize;
  174     uint32_t    padding;
  175 };
  176 
  177 struct fuse_kstatfs {
  178     uint64_t    blocks;
  179     uint64_t    bfree;
  180     uint64_t    bavail;
  181     uint64_t    files;
  182     uint64_t    ffree;
  183     uint32_t    bsize;
  184     uint32_t    namelen;
  185     uint32_t    frsize;
  186     uint32_t    padding;
  187     uint32_t    spare[6];
  188 };
  189 
  190 struct fuse_file_lock {
  191     uint64_t    start;
  192     uint64_t    end;
  193     uint32_t    type;
  194     uint32_t    pid; /* tgid */
  195 };
  196 
  197 /**
  198  * Bitmasks for fuse_setattr_in.valid
  199  */
  200 #define FATTR_MODE  (1 << 0)
  201 #define FATTR_UID   (1 << 1)
  202 #define FATTR_GID   (1 << 2)
  203 #define FATTR_SIZE  (1 << 3)
  204 #define FATTR_ATIME (1 << 4)
  205 #define FATTR_MTIME (1 << 5)
  206 #define FATTR_FH    (1 << 6)
  207 #define FATTR_ATIME_NOW (1 << 7)
  208 #define FATTR_MTIME_NOW (1 << 8)
  209 #define FATTR_LOCKOWNER (1 << 9)
  210 #define FATTR_CTIME (1 << 10)
  211 
  212 /**
  213  * Flags returned by the OPEN request
  214  *
  215  * FOPEN_DIRECT_IO: bypass page cache for this open file
  216  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
  217  * FOPEN_NONSEEKABLE: the file is not seekable
  218  */
  219 #define FOPEN_DIRECT_IO     (1 << 0)
  220 #define FOPEN_KEEP_CACHE    (1 << 1)
  221 #define FOPEN_NONSEEKABLE   (1 << 2)
  222 
  223 /**
  224  * INIT request/reply flags
  225  *
  226  * FUSE_ASYNC_READ: asynchronous read requests
  227  * FUSE_POSIX_LOCKS: remote locking for POSIX file locks
  228  * FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported)
  229  * FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem
  230  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
  231  * FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB
  232  * FUSE_DONT_MASK: don't apply umask to file mode on create operations
  233  * FUSE_SPLICE_WRITE: kernel supports splice write on the device
  234  * FUSE_SPLICE_MOVE: kernel supports splice move on the device
  235  * FUSE_SPLICE_READ: kernel supports splice read on the device
  236  * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
  237  * FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories
  238  * FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages
  239  * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one)
  240  * FUSE_READDIRPLUS_AUTO: adaptive readdirplus
  241  * FUSE_ASYNC_DIO: asynchronous direct I/O submission
  242  * FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes
  243  * FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens
  244  * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir
  245  * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
  246  * FUSE_POSIX_ACL: filesystem supports posix acls
  247  */
  248 #define FUSE_ASYNC_READ     (1 << 0)
  249 #define FUSE_POSIX_LOCKS    (1 << 1)
  250 #define FUSE_FILE_OPS       (1 << 2)
  251 #define FUSE_ATOMIC_O_TRUNC (1 << 3)
  252 #define FUSE_EXPORT_SUPPORT (1 << 4)
  253 #define FUSE_BIG_WRITES     (1 << 5)
  254 #define FUSE_DONT_MASK      (1 << 6)
  255 #define FUSE_SPLICE_WRITE   (1 << 7)
  256 #define FUSE_SPLICE_MOVE    (1 << 8)
  257 #define FUSE_SPLICE_READ    (1 << 9)
  258 #define FUSE_FLOCK_LOCKS    (1 << 10)
  259 #define FUSE_HAS_IOCTL_DIR  (1 << 11)
  260 #define FUSE_AUTO_INVAL_DATA    (1 << 12)
  261 #define FUSE_DO_READDIRPLUS (1 << 13)
  262 #define FUSE_READDIRPLUS_AUTO   (1 << 14)
  263 #define FUSE_ASYNC_DIO      (1 << 15)
  264 #define FUSE_WRITEBACK_CACHE    (1 << 16)
  265 #define FUSE_NO_OPEN_SUPPORT    (1 << 17)
  266 #define FUSE_PARALLEL_DIROPS    (1 << 18)
  267 #define FUSE_HANDLE_KILLPRIV    (1 << 19)
  268 #define FUSE_POSIX_ACL      (1 << 20)
  269 
  270 /**
  271  * CUSE INIT request/reply flags
  272  *
  273  * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
  274  */
  275 #define CUSE_UNRESTRICTED_IOCTL (1 << 0)
  276 
  277 /**
  278  * Release flags
  279  */
  280 #define FUSE_RELEASE_FLUSH  (1 << 0)
  281 #define FUSE_RELEASE_FLOCK_UNLOCK   (1 << 1)
  282 
  283 /**
  284  * Getattr flags
  285  */
  286 #define FUSE_GETATTR_FH     (1 << 0)
  287 
  288 /**
  289  * Lock flags
  290  */
  291 #define FUSE_LK_FLOCK       (1 << 0)
  292 
  293 /**
  294  * WRITE flags
  295  *
  296  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
  297  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
  298  */
  299 #define FUSE_WRITE_CACHE    (1 << 0)
  300 #define FUSE_WRITE_LOCKOWNER    (1 << 1)
  301 
  302 /**
  303  * Read flags
  304  */
  305 #define FUSE_READ_LOCKOWNER (1 << 1)
  306 
  307 /**
  308  * Ioctl flags
  309  *
  310  * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
  311  * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
  312  * FUSE_IOCTL_RETRY: retry with new iovecs
  313  * FUSE_IOCTL_32BIT: 32bit ioctl
  314  * FUSE_IOCTL_DIR: is a directory
  315  *
  316  * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
  317  */
  318 #define FUSE_IOCTL_COMPAT   (1 << 0)
  319 #define FUSE_IOCTL_UNRESTRICTED (1 << 1)
  320 #define FUSE_IOCTL_RETRY    (1 << 2)
  321 #define FUSE_IOCTL_32BIT    (1 << 3)
  322 #define FUSE_IOCTL_DIR      (1 << 4)
  323 
  324 #define FUSE_IOCTL_MAX_IOV  256
  325 
  326 /**
  327  * Poll flags
  328  *
  329  * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
  330  */
  331 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
  332 
  333 enum fuse_opcode {
  334     FUSE_LOOKUP    = 1,
  335     FUSE_FORGET    = 2,  /* no reply */
  336     FUSE_GETATTR       = 3,
  337     FUSE_SETATTR       = 4,
  338     FUSE_READLINK      = 5,
  339     FUSE_SYMLINK       = 6,
  340     FUSE_MKNOD     = 8,
  341     FUSE_MKDIR     = 9,
  342     FUSE_UNLINK    = 10,
  343     FUSE_RMDIR     = 11,
  344     FUSE_RENAME    = 12,
  345     FUSE_LINK      = 13,
  346     FUSE_OPEN      = 14,
  347     FUSE_READ      = 15,
  348     FUSE_WRITE     = 16,
  349     FUSE_STATFS    = 17,
  350     FUSE_RELEASE       = 18,
  351     FUSE_FSYNC         = 20,
  352     FUSE_SETXATTR      = 21,
  353     FUSE_GETXATTR      = 22,
  354     FUSE_LISTXATTR     = 23,
  355     FUSE_REMOVEXATTR   = 24,
  356     FUSE_FLUSH         = 25,
  357     FUSE_INIT          = 26,
  358     FUSE_OPENDIR       = 27,
  359     FUSE_READDIR       = 28,
  360     FUSE_RELEASEDIR    = 29,
  361     FUSE_FSYNCDIR      = 30,
  362     FUSE_GETLK         = 31,
  363     FUSE_SETLK         = 32,
  364     FUSE_SETLKW        = 33,
  365     FUSE_ACCESS        = 34,
  366     FUSE_CREATE        = 35,
  367     FUSE_INTERRUPT     = 36,
  368     FUSE_BMAP          = 37,
  369     FUSE_DESTROY       = 38,
  370     FUSE_IOCTL         = 39,
  371     FUSE_POLL          = 40,
  372     FUSE_NOTIFY_REPLY  = 41,
  373     FUSE_BATCH_FORGET  = 42,
  374     FUSE_FALLOCATE     = 43,
  375     FUSE_READDIRPLUS   = 44,
  376     FUSE_RENAME2       = 45,
  377     FUSE_LSEEK         = 46,
  378 
  379     /* CUSE specific operations */
  380     CUSE_INIT          = 4096,
  381 };
  382 
  383 enum fuse_notify_code {
  384     FUSE_NOTIFY_POLL   = 1,
  385     FUSE_NOTIFY_INVAL_INODE = 2,
  386     FUSE_NOTIFY_INVAL_ENTRY = 3,
  387     FUSE_NOTIFY_STORE = 4,
  388     FUSE_NOTIFY_RETRIEVE = 5,
  389     FUSE_NOTIFY_DELETE = 6,
  390     FUSE_NOTIFY_CODE_MAX,
  391 };
  392 
  393 /* The read buffer is required to be at least 8k, but may be much larger */
  394 #define FUSE_MIN_READ_BUFFER 8192
  395 
  396 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
  397 
  398 struct fuse_entry_out {
  399     uint64_t    nodeid;     /* Inode ID */
  400     uint64_t    generation; /* Inode generation: nodeid:gen must
  401                        be unique for the fs's lifetime */
  402     uint64_t    entry_valid;    /* Cache timeout for the name */
  403     uint64_t    attr_valid; /* Cache timeout for the attributes */
  404     uint32_t    entry_valid_nsec;
  405     uint32_t    attr_valid_nsec;
  406     struct fuse_attr attr;
  407 };
  408 
  409 struct fuse_forget_in {
  410     uint64_t    nlookup;
  411 };
  412 
  413 struct fuse_forget_one {
  414     uint64_t    nodeid;
  415     uint64_t    nlookup;
  416 };
  417 
  418 struct fuse_batch_forget_in {
  419     uint32_t    count;
  420     uint32_t    dummy;
  421 };
  422 
  423 struct fuse_getattr_in {
  424     uint32_t    getattr_flags;
  425     uint32_t    dummy;
  426     uint64_t    fh;
  427 };
  428 
  429 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
  430 
  431 struct fuse_attr_out {
  432     uint64_t    attr_valid; /* Cache timeout for the attributes */
  433     uint32_t    attr_valid_nsec;
  434     uint32_t    dummy;
  435     struct fuse_attr attr;
  436 };
  437 
  438 #define FUSE_COMPAT_MKNOD_IN_SIZE 8
  439 
  440 struct fuse_mknod_in {
  441     uint32_t    mode;
  442     uint32_t    rdev;
  443     uint32_t    umask;
  444     uint32_t    padding;
  445 };
  446 
  447 struct fuse_mkdir_in {
  448     uint32_t    mode;
  449     uint32_t    umask;
  450 };
  451 
  452 struct fuse_rename_in {
  453     uint64_t    newdir;
  454 };
  455 
  456 struct fuse_rename2_in {
  457     uint64_t    newdir;
  458     uint32_t    flags;
  459     uint32_t    padding;
  460 };
  461 
  462 struct fuse_link_in {
  463     uint64_t    oldnodeid;
  464 };
  465 
  466 struct fuse_setattr_in {
  467     uint32_t    valid;
  468     uint32_t    padding;
  469     uint64_t    fh;
  470     uint64_t    size;
  471     uint64_t    lock_owner;
  472     uint64_t    atime;
  473     uint64_t    mtime;
  474     uint64_t    ctime;
  475     uint32_t    atimensec;
  476     uint32_t    mtimensec;
  477     uint32_t    ctimensec;
  478     uint32_t    mode;
  479     uint32_t    unused4;
  480     uint32_t    uid;
  481     uint32_t    gid;
  482     uint32_t    unused5;
  483 };
  484 
  485 struct fuse_open_in {
  486     uint32_t    flags;
  487     uint32_t    unused;
  488 };
  489 
  490 struct fuse_create_in {
  491     uint32_t    flags;
  492     uint32_t    mode;
  493     uint32_t    umask;
  494     uint32_t    padding;
  495 };
  496 
  497 struct fuse_open_out {
  498     uint64_t    fh;
  499     uint32_t    open_flags;
  500     uint32_t    padding;
  501 };
  502 
  503 struct fuse_release_in {
  504     uint64_t    fh;
  505     uint32_t    flags;
  506     uint32_t    release_flags;
  507     uint64_t    lock_owner;
  508 };
  509 
  510 struct fuse_flush_in {
  511     uint64_t    fh;
  512     uint32_t    unused;
  513     uint32_t    padding;
  514     uint64_t    lock_owner;
  515 };
  516 
  517 struct fuse_read_in {
  518     uint64_t    fh;
  519     uint64_t    offset;
  520     uint32_t    size;
  521     uint32_t    read_flags;
  522     uint64_t    lock_owner;
  523     uint32_t    flags;
  524     uint32_t    padding;
  525 };
  526 
  527 #define FUSE_COMPAT_WRITE_IN_SIZE 24
  528 
  529 struct fuse_write_in {
  530     uint64_t    fh;
  531     uint64_t    offset;
  532     uint32_t    size;
  533     uint32_t    write_flags;
  534     uint64_t    lock_owner;
  535     uint32_t    flags;
  536     uint32_t    padding;
  537 };
  538 
  539 struct fuse_write_out {
  540     uint32_t    size;
  541     uint32_t    padding;
  542 };
  543 
  544 #define FUSE_COMPAT_STATFS_SIZE 48
  545 
  546 struct fuse_statfs_out {
  547     struct fuse_kstatfs st;
  548 };
  549 
  550 struct fuse_fsync_in {
  551     uint64_t    fh;
  552     uint32_t    fsync_flags;
  553     uint32_t    padding;
  554 };
  555 
  556 struct fuse_setxattr_in {
  557     uint32_t    size;
  558     uint32_t    flags;
  559 };
  560 
  561 struct fuse_getxattr_in {
  562     uint32_t    size;
  563     uint32_t    padding;
  564 };
  565 
  566 struct fuse_getxattr_out {
  567     uint32_t    size;
  568     uint32_t    padding;
  569 };
  570 
  571 struct fuse_lk_in {
  572     uint64_t    fh;
  573     uint64_t    owner;
  574     struct fuse_file_lock lk;
  575     uint32_t    lk_flags;
  576     uint32_t    padding;
  577 };
  578 
  579 struct fuse_lk_out {
  580     struct fuse_file_lock lk;
  581 };
  582 
  583 struct fuse_access_in {
  584     uint32_t    mask;
  585     uint32_t    padding;
  586 };
  587 
  588 struct fuse_init_in {
  589     uint32_t    major;
  590     uint32_t    minor;
  591     uint32_t    max_readahead;
  592     uint32_t    flags;
  593 };
  594 
  595 #define FUSE_COMPAT_INIT_OUT_SIZE 8
  596 #define FUSE_COMPAT_22_INIT_OUT_SIZE 24
  597 
  598 struct fuse_init_out {
  599     uint32_t    major;
  600     uint32_t    minor;
  601     uint32_t    max_readahead;
  602     uint32_t    flags;
  603     uint16_t    max_background;
  604     uint16_t    congestion_threshold;
  605     uint32_t    max_write;
  606     uint32_t    time_gran;
  607     uint32_t    unused[9];
  608 };
  609 
  610 #define CUSE_INIT_INFO_MAX 4096
  611 
  612 struct cuse_init_in {
  613     uint32_t    major;
  614     uint32_t    minor;
  615     uint32_t    unused;
  616     uint32_t    flags;
  617 };
  618 
  619 struct cuse_init_out {
  620     uint32_t    major;
  621     uint32_t    minor;
  622     uint32_t    unused;
  623     uint32_t    flags;
  624     uint32_t    max_read;
  625     uint32_t    max_write;
  626     uint32_t    dev_major;      /* chardev major */
  627     uint32_t    dev_minor;      /* chardev minor */
  628     uint32_t    spare[10];
  629 };
  630 
  631 struct fuse_interrupt_in {
  632     uint64_t    unique;
  633 };
  634 
  635 struct fuse_bmap_in {
  636     uint64_t    block;
  637     uint32_t    blocksize;
  638     uint32_t    padding;
  639 };
  640 
  641 struct fuse_bmap_out {
  642     uint64_t    block;
  643 };
  644 
  645 struct fuse_ioctl_in {
  646     uint64_t    fh;
  647     uint32_t    flags;
  648     uint32_t    cmd;
  649     uint64_t    arg;
  650     uint32_t    in_size;
  651     uint32_t    out_size;
  652 };
  653 
  654 struct fuse_ioctl_iovec {
  655     uint64_t    base;
  656     uint64_t    len;
  657 };
  658 
  659 struct fuse_ioctl_out {
  660     int32_t     result;
  661     uint32_t    flags;
  662     uint32_t    in_iovs;
  663     uint32_t    out_iovs;
  664 };
  665 
  666 struct fuse_poll_in {
  667     uint64_t    fh;
  668     uint64_t    kh;
  669     uint32_t    flags;
  670     uint32_t    events;
  671 };
  672 
  673 struct fuse_poll_out {
  674     uint32_t    revents;
  675     uint32_t    padding;
  676 };
  677 
  678 struct fuse_notify_poll_wakeup_out {
  679     uint64_t    kh;
  680 };
  681 
  682 struct fuse_fallocate_in {
  683     uint64_t    fh;
  684     uint64_t    offset;
  685     uint64_t    length;
  686     uint32_t    mode;
  687     uint32_t    padding;
  688 };
  689 
  690 struct fuse_in_header {
  691     uint32_t    len;
  692     uint32_t    opcode;
  693     uint64_t    unique;
  694     uint64_t    nodeid;
  695     uint32_t    uid;
  696     uint32_t    gid;
  697     uint32_t    pid;
  698     uint32_t    padding;
  699 };
  700 
  701 struct fuse_out_header {
  702     uint32_t    len;
  703     int32_t     error;
  704     uint64_t    unique;
  705 };
  706 
  707 struct fuse_dirent {
  708     uint64_t    ino;
  709     uint64_t    off;
  710     uint32_t    namelen;
  711     uint32_t    type;
  712     char name[];
  713 };
  714 
  715 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
  716 #define FUSE_DIRENT_ALIGN(x) \
  717     (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
  718 #define FUSE_DIRENT_SIZE(d) \
  719     FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
  720 
  721 struct fuse_direntplus {
  722     struct fuse_entry_out entry_out;
  723     struct fuse_dirent dirent;
  724 };
  725 
  726 #define FUSE_NAME_OFFSET_DIRENTPLUS \
  727     offsetof(struct fuse_direntplus, dirent.name)
  728 #define FUSE_DIRENTPLUS_SIZE(d) \
  729     FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
  730 
  731 struct fuse_notify_inval_inode_out {
  732     uint64_t    ino;
  733     int64_t     off;
  734     int64_t     len;
  735 };
  736 
  737 struct fuse_notify_inval_entry_out {
  738     uint64_t    parent;
  739     uint32_t    namelen;
  740     uint32_t    padding;
  741 };
  742 
  743 struct fuse_notify_delete_out {
  744     uint64_t    parent;
  745     uint64_t    child;
  746     uint32_t    namelen;
  747     uint32_t    padding;
  748 };
  749 
  750 struct fuse_notify_store_out {
  751     uint64_t    nodeid;
  752     uint64_t    offset;
  753     uint32_t    size;
  754     uint32_t    padding;
  755 };
  756 
  757 struct fuse_notify_retrieve_out {
  758     uint64_t    notify_unique;
  759     uint64_t    nodeid;
  760     uint64_t    offset;
  761     uint32_t    size;
  762     uint32_t    padding;
  763 };
  764 
  765 /* Matches the size of fuse_write_in */
  766 struct fuse_notify_retrieve_in {
  767     uint64_t    dummy1;
  768     uint64_t    offset;
  769     uint32_t    size;
  770     uint32_t    dummy2;
  771     uint64_t    dummy3;
  772     uint64_t    dummy4;
  773 };
  774 
  775 /* Device ioctls: */
  776 #define FUSE_DEV_IOC_CLONE  _IOR(229, 0, uint32_t)
  777 
  778 struct fuse_lseek_in {
  779     uint64_t    fh;
  780     uint64_t    offset;
  781     uint32_t    whence;
  782     uint32_t    padding;
  783 };
  784 
  785 struct fuse_lseek_out {
  786     uint64_t    offset;
  787 };
  788 
  789 #endif /* _LINUX_FUSE_H */