sys/fs/fuse/fuse_kernel.h

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