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