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  * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one)
 222  * FUSE_READDIRPLUS_AUTO: adaptive readdirplus
 223  */
 224 #define FUSE_ASYNC_READ         (1 << 0)
 225 #define FUSE_POSIX_LOCKS        (1 << 1)
 226 #define FUSE_FILE_OPS           (1 << 2)
 227 #define FUSE_ATOMIC_O_TRUNC     (1 << 3)
 228 #define FUSE_EXPORT_SUPPORT     (1 << 4)
 229 #define FUSE_BIG_WRITES         (1 << 5)
 230 #define FUSE_DONT_MASK          (1 << 6)
 231 #define FUSE_SPLICE_WRITE       (1 << 7)
 232 #define FUSE_SPLICE_MOVE        (1 << 8)
 233 #define FUSE_SPLICE_READ        (1 << 9)
 234 #define FUSE_FLOCK_LOCKS        (1 << 10)
 235 #define FUSE_HAS_IOCTL_DIR      (1 << 11)
 236 #define FUSE_AUTO_INVAL_DATA    (1 << 12)
 237 #define FUSE_DO_READDIRPLUS     (1 << 13)
 238 #define FUSE_READDIRPLUS_AUTO   (1 << 14)
 239
 240 /**
 241  * CUSE INIT request/reply flags
 242  *
 243  * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
 244  */
 245 #define CUSE_UNRESTRICTED_IOCTL (1 << 0)
 246
 247 /**
 248  * Release flags
 249  */
 250 #define FUSE_RELEASE_FLUSH      (1 << 0)
 251 #define FUSE_RELEASE_FLOCK_UNLOCK       (1 << 1)
 252
 253 /**
 254  * Getattr flags
 255  */
 256 #define FUSE_GETATTR_FH         (1 << 0)
 257
 258 /**
 259  * Lock flags
 260  */
 261 #define FUSE_LK_FLOCK           (1 << 0)
 262
 263 /**
 264  * WRITE flags
 265  *
 266  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
 267  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
 268  */
 269 #define FUSE_WRITE_CACHE        (1 << 0)
 270 #define FUSE_WRITE_LOCKOWNER    (1 << 1)
 271
 272 /**
 273  * Read flags
 274  */
 275 #define FUSE_READ_LOCKOWNER     (1 << 1)
 276
 277 /**
 278  * Ioctl flags
 279  *
 280  * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
 281  * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
 282  * FUSE_IOCTL_RETRY: retry with new iovecs
 283  * FUSE_IOCTL_32BIT: 32bit ioctl
 284  * FUSE_IOCTL_DIR: is a directory
 285  *
 286  * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
 287  */
 288 #define FUSE_IOCTL_COMPAT       (1 << 0)
 289 #define FUSE_IOCTL_UNRESTRICTED (1 << 1)
 290 #define FUSE_IOCTL_RETRY        (1 << 2)
 291 #define FUSE_IOCTL_32BIT        (1 << 3)
 292 #define FUSE_IOCTL_DIR          (1 << 4)
 293
 294 #define FUSE_IOCTL_MAX_IOV      256
 295
 296 /**
 297  * Poll flags
 298  *
 299  * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
 300  */
 301 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
 302
 303 enum fuse_opcode {
 304         FUSE_LOOKUP        = 1,
 305         FUSE_FORGET        = 2,  /* no reply */
 306         FUSE_GETATTR       = 3,
 307         FUSE_SETATTR       = 4,
 308         FUSE_READLINK      = 5,
 309         FUSE_SYMLINK       = 6,
 310         FUSE_MKNOD         = 8,
 311         FUSE_MKDIR         = 9,
 312         FUSE_UNLINK        = 10,
 313         FUSE_RMDIR         = 11,
 314         FUSE_RENAME        = 12,
 315         FUSE_LINK          = 13,
 316         FUSE_OPEN          = 14,
 317         FUSE_READ          = 15,
 318         FUSE_WRITE         = 16,
 319         FUSE_STATFS        = 17,
 320         FUSE_RELEASE       = 18,
 321         FUSE_FSYNC         = 20,
 322         FUSE_SETXATTR      = 21,
 323         FUSE_GETXATTR      = 22,
 324         FUSE_LISTXATTR     = 23,
 325         FUSE_REMOVEXATTR   = 24,
 326         FUSE_FLUSH         = 25,
 327         FUSE_INIT          = 26,
 328         FUSE_OPENDIR       = 27,
 329         FUSE_READDIR       = 28,
 330         FUSE_RELEASEDIR    = 29,
 331         FUSE_FSYNCDIR      = 30,
 332         FUSE_GETLK         = 31,
 333         FUSE_SETLK         = 32,
 334         FUSE_SETLKW        = 33,
 335         FUSE_ACCESS        = 34,
 336         FUSE_CREATE        = 35,
 337         FUSE_INTERRUPT     = 36,
 338         FUSE_BMAP          = 37,
 339         FUSE_DESTROY       = 38,
 340         FUSE_IOCTL         = 39,
 341         FUSE_POLL          = 40,
 342         FUSE_NOTIFY_REPLY  = 41,
 343         FUSE_BATCH_FORGET  = 42,
 344         FUSE_FALLOCATE     = 43,
 345         FUSE_READDIRPLUS   = 44,
 346
 347         /* CUSE specific operations */
 348         CUSE_INIT          = 4096,
 349 };
 350
 351 enum fuse_notify_code {
 352         FUSE_NOTIFY_POLL   = 1,
 353         FUSE_NOTIFY_INVAL_INODE = 2,
 354         FUSE_NOTIFY_INVAL_ENTRY = 3,
 355         FUSE_NOTIFY_STORE = 4,
 356         FUSE_NOTIFY_RETRIEVE = 5,
 357         FUSE_NOTIFY_DELETE = 6,
 358         FUSE_NOTIFY_CODE_MAX,
 359 };
 360
 361 /* The read buffer is required to be at least 8k, but may be much larger */
 362 #define FUSE_MIN_READ_BUFFER 8192
 363
 364 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
 365
 366 struct fuse_entry_out {
 367         __u64   nodeid;         /* Inode ID */
 368         __u64   generation;     /* Inode generation: nodeid:gen must
 369                                    be unique for the fs's lifetime */
 370         __u64   entry_valid;    /* Cache timeout for the name */
 371         __u64   attr_valid;     /* Cache timeout for the attributes */
 372         __u32   entry_valid_nsec;
 373         __u32   attr_valid_nsec;
 374         struct fuse_attr attr;
 375 };
 376
 377 struct fuse_forget_in {
 378         __u64   nlookup;
 379 };
 380
 381 struct fuse_forget_one {
 382         __u64   nodeid;
 383         __u64   nlookup;
 384 };
 385
 386 struct fuse_batch_forget_in {
 387         __u32   count;
 388         __u32   dummy;
 389 };
 390
 391 struct fuse_getattr_in {
 392         __u32   getattr_flags;
 393         __u32   dummy;
 394         __u64   fh;
 395 };
 396
 397 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
 398
 399 struct fuse_attr_out {
 400         __u64   attr_valid;     /* Cache timeout for the attributes */
 401         __u32   attr_valid_nsec;
 402         __u32   dummy;
 403         struct fuse_attr attr;
 404 };
 405
 406 #define FUSE_COMPAT_MKNOD_IN_SIZE 8
 407
 408 struct fuse_mknod_in {
 409         __u32   mode;
 410         __u32   rdev;
 411         __u32   umask;
 412         __u32   padding;
 413 };
 414
 415 struct fuse_mkdir_in {
 416         __u32   mode;
 417         __u32   umask;
 418 };
 419
 420 struct fuse_rename_in {
 421         __u64   newdir;
 422 };
 423
 424 struct fuse_link_in {
 425         __u64   oldnodeid;
 426 };
 427
 428 struct fuse_setattr_in {
 429         __u32   valid;
 430         __u32   padding;
 431         __u64   fh;
 432         __u64   size;
 433         __u64   lock_owner;
 434         __u64   atime;
 435         __u64   mtime;
 436         __u64   unused2;
 437         __u32   atimensec;
 438         __u32   mtimensec;
 439         __u32   unused3;
 440         __u32   mode;
 441         __u32   unused4;
 442         __u32   uid;
 443         __u32   gid;
 444         __u32   unused5;
 445 };
 446
 447 struct fuse_open_in {
 448         __u32   flags;
 449         __u32   unused;
 450 };
 451
 452 struct fuse_create_in {
 453         __u32   flags;
 454         __u32   mode;
 455         __u32   umask;
 456         __u32   padding;
 457 };
 458
 459 struct fuse_open_out {
 460         __u64   fh;
 461         __u32   open_flags;
 462         __u32   padding;
 463 };
 464
 465 struct fuse_release_in {
 466         __u64   fh;
 467         __u32   flags;
 468         __u32   release_flags;
 469         __u64   lock_owner;
 470 };
 471
 472 struct fuse_flush_in {
 473         __u64   fh;
 474         __u32   unused;
 475         __u32   padding;
 476         __u64   lock_owner;
 477 };
 478
 479 struct fuse_read_in {
 480         __u64   fh;
 481         __u64   offset;
 482         __u32   size;
 483         __u32   read_flags;
 484         __u64   lock_owner;
 485         __u32   flags;
 486         __u32   padding;
 487 };
 488
 489 #define FUSE_COMPAT_WRITE_IN_SIZE 24
 490
 491 struct fuse_write_in {
 492         __u64   fh;
 493         __u64   offset;
 494         __u32   size;
 495         __u32   write_flags;
 496         __u64   lock_owner;
 497         __u32   flags;
 498         __u32   padding;
 499 };
 500
 501 struct fuse_write_out {
 502         __u32   size;
 503         __u32   padding;
 504 };
 505
 506 #define FUSE_COMPAT_STATFS_SIZE 48
 507
 508 struct fuse_statfs_out {
 509         struct fuse_kstatfs st;
 510 };
 511
 512 struct fuse_fsync_in {
 513         __u64   fh;
 514         __u32   fsync_flags;
 515         __u32   padding;
 516 };
 517
 518 struct fuse_setxattr_in {
 519         __u32   size;
 520         __u32   flags;
 521 };
 522
 523 struct fuse_getxattr_in {
 524         __u32   size;
 525         __u32   padding;
 526 };
 527
 528 struct fuse_getxattr_out {
 529         __u32   size;
 530         __u32   padding;
 531 };
 532
 533 struct fuse_lk_in {
 534         __u64   fh;
 535         __u64   owner;
 536         struct fuse_file_lock lk;
 537         __u32   lk_flags;
 538         __u32   padding;
 539 };
 540
 541 struct fuse_lk_out {
 542         struct fuse_file_lock lk;
 543 };
 544
 545 struct fuse_access_in {
 546         __u32   mask;
 547         __u32   padding;
 548 };
 549
 550 struct fuse_init_in {
 551         __u32   major;
 552         __u32   minor;
 553         __u32   max_readahead;
 554         __u32   flags;
 555 };
 556
 557 struct fuse_init_out {
 558         __u32   major;
 559         __u32   minor;
 560         __u32   max_readahead;
 561         __u32   flags;
 562         __u16   max_background;
 563         __u16   congestion_threshold;
 564         __u32   max_write;
 565 };
 566
 567 #define CUSE_INIT_INFO_MAX 4096
 568
 569 struct cuse_init_in {
 570         __u32   major;
 571         __u32   minor;
 572         __u32   unused;
 573         __u32   flags;
 574 };
 575
 576 struct cuse_init_out {
 577         __u32   major;
 578         __u32   minor;
 579         __u32   unused;
 580         __u32   flags;
 581         __u32   max_read;
 582         __u32   max_write;
 583         __u32   dev_major;              /* chardev major */
 584         __u32   dev_minor;              /* chardev minor */
 585         __u32   spare[10];
 586 };
 587
 588 struct fuse_interrupt_in {
 589         __u64   unique;
 590 };
 591
 592 struct fuse_bmap_in {
 593         __u64   block;
 594         __u32   blocksize;
 595         __u32   padding;
 596 };
 597
 598 struct fuse_bmap_out {
 599         __u64   block;
 600 };
 601
 602 struct fuse_ioctl_in {
 603         __u64   fh;
 604         __u32   flags;
 605         __u32   cmd;
 606         __u64   arg;
 607         __u32   in_size;
 608         __u32   out_size;
 609 };
 610
 611 struct fuse_ioctl_iovec {
 612         __u64   base;
 613         __u64   len;
 614 };
 615
 616 struct fuse_ioctl_out {
 617         __s32   result;
 618         __u32   flags;
 619         __u32   in_iovs;
 620         __u32   out_iovs;
 621 };
 622
 623 struct fuse_poll_in {
 624         __u64   fh;
 625         __u64   kh;
 626         __u32   flags;
 627         __u32   events;
 628 };
 629
 630 struct fuse_poll_out {
 631         __u32   revents;
 632         __u32   padding;
 633 };
 634
 635 struct fuse_notify_poll_wakeup_out {
 636         __u64   kh;
 637 };
 638
 639 struct fuse_fallocate_in {
 640         __u64   fh;
 641         __u64   offset;
 642         __u64   length;
 643         __u32   mode;
 644         __u32   padding;
 645 };
 646
 647 struct fuse_in_header {
 648         __u32   len;
 649         __u32   opcode;
 650         __u64   unique;
 651         __u64   nodeid;
 652         __u32   uid;
 653         __u32   gid;
 654         __u32   pid;
 655         __u32   padding;
 656 };
 657
 658 struct fuse_out_header {
 659         __u32   len;
 660         __s32   error;
 661         __u64   unique;
 662 };
 663
 664 struct fuse_dirent {
 665         __u64   ino;
 666         __u64   off;
 667         __u32   namelen;
 668         __u32   type;
 669         char name[];
 670 };
 671
 672 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
 673 #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
 674 #define FUSE_DIRENT_SIZE(d) \
 675         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
 676
 677 struct fuse_direntplus {
 678         struct fuse_entry_out entry_out;
 679         struct fuse_dirent dirent;
 680 };
 681
 682 #define FUSE_NAME_OFFSET_DIRENTPLUS \
 683         offsetof(struct fuse_direntplus, dirent.name)
 684 #define FUSE_DIRENTPLUS_SIZE(d) \
 685         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
 686
 687 struct fuse_notify_inval_inode_out {
 688         __u64   ino;
 689         __s64   off;
 690         __s64   len;
 691 };
 692
 693 struct fuse_notify_inval_entry_out {
 694         __u64   parent;
 695         __u32   namelen;
 696         __u32   padding;
 697 };
 698
 699 struct fuse_notify_delete_out {
 700         __u64   parent;
 701         __u64   child;
 702         __u32   namelen;
 703         __u32   padding;
 704 };
 705
 706 struct fuse_notify_store_out {
 707         __u64   nodeid;
 708         __u64   offset;
 709         __u32   size;
 710         __u32   padding;
 711 };
 712
 713 struct fuse_notify_retrieve_out {
 714         __u64   notify_unique;
 715         __u64   nodeid;
 716         __u64   offset;
 717         __u32   size;
 718         __u32   padding;
 719 };
 720
 721 /* Matches the size of fuse_write_in */
 722 struct fuse_notify_retrieve_in {
 723         __u64   dummy1;
 724         __u64   offset;
 725         __u32   size;
 726         __u32   dummy2;
 727         __u64   dummy3;
 728         __u64   dummy4;
 729 };
 730
 731 #endif /* _LINUX_FUSE_H */