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