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