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