sys/fs/fuse/fuse_kernel.h

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