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