libfuse
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  * 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  * 7.22
95  * - add FUSE_ASYNC_DIO
96  *
97  * 7.23
98  * - add FUSE_WRITEBACK_CACHE
99  * - add time_gran to fuse_init_out
100  * - add reserved space to fuse_init_out
101  * - add FATTR_CTIME
102  * - add ctime and ctimensec to fuse_setattr_in
103  * - add FUSE_RENAME2 request
104  * - add FUSE_NO_OPEN_SUPPORT flag
105  *
106  * 7.24
107  * - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support
108  *
109  * 7.25
110  * - add FUSE_PARALLEL_DIROPS
111  *
112  * 7.26
113  * - add FUSE_HANDLE_KILLPRIV
114  * - add FUSE_POSIX_ACL
115  */
116 
117 #ifndef _LINUX_FUSE_H
118 #define _LINUX_FUSE_H
119 
120 #ifdef __KERNEL__
121 #include <linux/types.h>
122 #else
123 #include <stdint.h>
124 #endif
125 
126 /*
127  * Version negotiation:
128  *
129  * Both the kernel and userspace send the version they support in the
130  * INIT request and reply respectively.
131  *
132  * If the major versions match then both shall use the smallest
133  * of the two minor versions for communication.
134  *
135  * If the kernel supports a larger major version, then userspace shall
136  * reply with the major version it supports, ignore the rest of the
137  * INIT message and expect a new INIT message from the kernel with a
138  * matching major version.
139  *
140  * If the library supports a larger major version, then it shall fall
141  * back to the major protocol version sent by the kernel for
142  * communication and reply with that major version (and an arbitrary
143  * supported minor version).
144  */
145 
147 #define FUSE_KERNEL_VERSION 7
148 
150 #define FUSE_KERNEL_MINOR_VERSION 26
151 
153 #define FUSE_ROOT_ID 1
154 
155 /* Make sure all structures are padded to 64bit boundary, so 32bit
156  userspace works under 64bit kernels */
157 
158 struct fuse_attr {
159  uint64_t ino;
160  uint64_t size;
161  uint64_t blocks;
162  uint64_t atime;
163  uint64_t mtime;
164  uint64_t ctime;
165  uint32_t atimensec;
166  uint32_t mtimensec;
167  uint32_t ctimensec;
168  uint32_t mode;
169  uint32_t nlink;
170  uint32_t uid;
171  uint32_t gid;
172  uint32_t rdev;
173  uint32_t blksize;
174  uint32_t padding;
175 };
176 
177 struct fuse_kstatfs {
178  uint64_t blocks;
179  uint64_t bfree;
180  uint64_t bavail;
181  uint64_t files;
182  uint64_t ffree;
183  uint32_t bsize;
184  uint32_t namelen;
185  uint32_t frsize;
186  uint32_t padding;
187  uint32_t spare[6];
188 };
189 
190 struct fuse_file_lock {
191  uint64_t start;
192  uint64_t end;
193  uint32_t type;
194  uint32_t pid; /* tgid */
195 };
196 
200 #define FATTR_MODE (1 << 0)
201 #define FATTR_UID (1 << 1)
202 #define FATTR_GID (1 << 2)
203 #define FATTR_SIZE (1 << 3)
204 #define FATTR_ATIME (1 << 4)
205 #define FATTR_MTIME (1 << 5)
206 #define FATTR_FH (1 << 6)
207 #define FATTR_ATIME_NOW (1 << 7)
208 #define FATTR_MTIME_NOW (1 << 8)
209 #define FATTR_LOCKOWNER (1 << 9)
210 #define FATTR_CTIME (1 << 10)
211 
219 #define FOPEN_DIRECT_IO (1 << 0)
220 #define FOPEN_KEEP_CACHE (1 << 1)
221 #define FOPEN_NONSEEKABLE (1 << 2)
222 
248 #define FUSE_ASYNC_READ (1 << 0)
249 #define FUSE_POSIX_LOCKS (1 << 1)
250 #define FUSE_FILE_OPS (1 << 2)
251 #define FUSE_ATOMIC_O_TRUNC (1 << 3)
252 #define FUSE_EXPORT_SUPPORT (1 << 4)
253 #define FUSE_BIG_WRITES (1 << 5)
254 #define FUSE_DONT_MASK (1 << 6)
255 #define FUSE_SPLICE_WRITE (1 << 7)
256 #define FUSE_SPLICE_MOVE (1 << 8)
257 #define FUSE_SPLICE_READ (1 << 9)
258 #define FUSE_FLOCK_LOCKS (1 << 10)
259 #define FUSE_HAS_IOCTL_DIR (1 << 11)
260 #define FUSE_AUTO_INVAL_DATA (1 << 12)
261 #define FUSE_DO_READDIRPLUS (1 << 13)
262 #define FUSE_READDIRPLUS_AUTO (1 << 14)
263 #define FUSE_ASYNC_DIO (1 << 15)
264 #define FUSE_WRITEBACK_CACHE (1 << 16)
265 #define FUSE_NO_OPEN_SUPPORT (1 << 17)
266 #define FUSE_PARALLEL_DIROPS (1 << 18)
267 #define FUSE_HANDLE_KILLPRIV (1 << 19)
268 #define FUSE_POSIX_ACL (1 << 20)
269 
275 #define CUSE_UNRESTRICTED_IOCTL (1 << 0)
276 
280 #define FUSE_RELEASE_FLUSH (1 << 0)
281 #define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1)
282 
286 #define FUSE_GETATTR_FH (1 << 0)
287 
291 #define FUSE_LK_FLOCK (1 << 0)
292 
299 #define FUSE_WRITE_CACHE (1 << 0)
300 #define FUSE_WRITE_LOCKOWNER (1 << 1)
301 
305 #define FUSE_READ_LOCKOWNER (1 << 1)
306 
318 #define FUSE_IOCTL_COMPAT (1 << 0)
319 #define FUSE_IOCTL_UNRESTRICTED (1 << 1)
320 #define FUSE_IOCTL_RETRY (1 << 2)
321 #define FUSE_IOCTL_32BIT (1 << 3)
322 #define FUSE_IOCTL_DIR (1 << 4)
323 
324 #define FUSE_IOCTL_MAX_IOV 256
325 
331 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
332 
333 enum fuse_opcode {
334  FUSE_LOOKUP = 1,
335  FUSE_FORGET = 2, /* no reply */
336  FUSE_GETATTR = 3,
337  FUSE_SETATTR = 4,
338  FUSE_READLINK = 5,
339  FUSE_SYMLINK = 6,
340  FUSE_MKNOD = 8,
341  FUSE_MKDIR = 9,
342  FUSE_UNLINK = 10,
343  FUSE_RMDIR = 11,
344  FUSE_RENAME = 12,
345  FUSE_LINK = 13,
346  FUSE_OPEN = 14,
347  FUSE_READ = 15,
348  FUSE_WRITE = 16,
349  FUSE_STATFS = 17,
350  FUSE_RELEASE = 18,
351  FUSE_FSYNC = 20,
352  FUSE_SETXATTR = 21,
353  FUSE_GETXATTR = 22,
354  FUSE_LISTXATTR = 23,
355  FUSE_REMOVEXATTR = 24,
356  FUSE_FLUSH = 25,
357  FUSE_INIT = 26,
358  FUSE_OPENDIR = 27,
359  FUSE_READDIR = 28,
360  FUSE_RELEASEDIR = 29,
361  FUSE_FSYNCDIR = 30,
362  FUSE_GETLK = 31,
363  FUSE_SETLK = 32,
364  FUSE_SETLKW = 33,
365  FUSE_ACCESS = 34,
366  FUSE_CREATE = 35,
367  FUSE_INTERRUPT = 36,
368  FUSE_BMAP = 37,
369  FUSE_DESTROY = 38,
370  FUSE_IOCTL = 39,
371  FUSE_POLL = 40,
372  FUSE_NOTIFY_REPLY = 41,
373  FUSE_BATCH_FORGET = 42,
374  FUSE_FALLOCATE = 43,
375  FUSE_READDIRPLUS = 44,
376  FUSE_RENAME2 = 45,
377  FUSE_LSEEK = 46,
378 
379  /* CUSE specific operations */
380  CUSE_INIT = 4096,
381 };
382 
383 enum fuse_notify_code {
384  FUSE_NOTIFY_POLL = 1,
385  FUSE_NOTIFY_INVAL_INODE = 2,
386  FUSE_NOTIFY_INVAL_ENTRY = 3,
387  FUSE_NOTIFY_STORE = 4,
388  FUSE_NOTIFY_RETRIEVE = 5,
389  FUSE_NOTIFY_DELETE = 6,
390  FUSE_NOTIFY_CODE_MAX,
391 };
392 
393 /* The read buffer is required to be at least 8k, but may be much larger */
394 #define FUSE_MIN_READ_BUFFER 8192
395 
396 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
397 
398 struct fuse_entry_out {
399  uint64_t nodeid; /* Inode ID */
400  uint64_t generation; /* Inode generation: nodeid:gen must
401  be unique for the fs's lifetime */
402  uint64_t entry_valid; /* Cache timeout for the name */
403  uint64_t attr_valid; /* Cache timeout for the attributes */
404  uint32_t entry_valid_nsec;
405  uint32_t attr_valid_nsec;
406  struct fuse_attr attr;
407 };
408 
409 struct fuse_forget_in {
410  uint64_t nlookup;
411 };
412 
413 struct fuse_forget_one {
414  uint64_t nodeid;
415  uint64_t nlookup;
416 };
417 
418 struct fuse_batch_forget_in {
419  uint32_t count;
420  uint32_t dummy;
421 };
422 
423 struct fuse_getattr_in {
424  uint32_t getattr_flags;
425  uint32_t dummy;
426  uint64_t fh;
427 };
428 
429 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
430 
431 struct fuse_attr_out {
432  uint64_t attr_valid; /* Cache timeout for the attributes */
433  uint32_t attr_valid_nsec;
434  uint32_t dummy;
435  struct fuse_attr attr;
436 };
437 
438 #define FUSE_COMPAT_MKNOD_IN_SIZE 8
439 
440 struct fuse_mknod_in {
441  uint32_t mode;
442  uint32_t rdev;
443  uint32_t umask;
444  uint32_t padding;
445 };
446 
447 struct fuse_mkdir_in {
448  uint32_t mode;
449  uint32_t umask;
450 };
451 
452 struct fuse_rename_in {
453  uint64_t newdir;
454 };
455 
456 struct fuse_rename2_in {
457  uint64_t newdir;
458  uint32_t flags;
459  uint32_t padding;
460 };
461 
462 struct fuse_link_in {
463  uint64_t oldnodeid;
464 };
465 
466 struct fuse_setattr_in {
467  uint32_t valid;
468  uint32_t padding;
469  uint64_t fh;
470  uint64_t size;
471  uint64_t lock_owner;
472  uint64_t atime;
473  uint64_t mtime;
474  uint64_t ctime;
475  uint32_t atimensec;
476  uint32_t mtimensec;
477  uint32_t ctimensec;
478  uint32_t mode;
479  uint32_t unused4;
480  uint32_t uid;
481  uint32_t gid;
482  uint32_t unused5;
483 };
484 
485 struct fuse_open_in {
486  uint32_t flags;
487  uint32_t unused;
488 };
489 
490 struct fuse_create_in {
491  uint32_t flags;
492  uint32_t mode;
493  uint32_t umask;
494  uint32_t padding;
495 };
496 
497 struct fuse_open_out {
498  uint64_t fh;
499  uint32_t open_flags;
500  uint32_t padding;
501 };
502 
503 struct fuse_release_in {
504  uint64_t fh;
505  uint32_t flags;
506  uint32_t release_flags;
507  uint64_t lock_owner;
508 };
509 
510 struct fuse_flush_in {
511  uint64_t fh;
512  uint32_t unused;
513  uint32_t padding;
514  uint64_t lock_owner;
515 };
516 
517 struct fuse_read_in {
518  uint64_t fh;
519  uint64_t offset;
520  uint32_t size;
521  uint32_t read_flags;
522  uint64_t lock_owner;
523  uint32_t flags;
524  uint32_t padding;
525 };
526 
527 #define FUSE_COMPAT_WRITE_IN_SIZE 24
528 
529 struct fuse_write_in {
530  uint64_t fh;
531  uint64_t offset;
532  uint32_t size;
533  uint32_t write_flags;
534  uint64_t lock_owner;
535  uint32_t flags;
536  uint32_t padding;
537 };
538 
539 struct fuse_write_out {
540  uint32_t size;
541  uint32_t padding;
542 };
543 
544 #define FUSE_COMPAT_STATFS_SIZE 48
545 
546 struct fuse_statfs_out {
547  struct fuse_kstatfs st;
548 };
549 
550 struct fuse_fsync_in {
551  uint64_t fh;
552  uint32_t fsync_flags;
553  uint32_t padding;
554 };
555 
556 struct fuse_setxattr_in {
557  uint32_t size;
558  uint32_t flags;
559 };
560 
561 struct fuse_getxattr_in {
562  uint32_t size;
563  uint32_t padding;
564 };
565 
566 struct fuse_getxattr_out {
567  uint32_t size;
568  uint32_t padding;
569 };
570 
571 struct fuse_lk_in {
572  uint64_t fh;
573  uint64_t owner;
574  struct fuse_file_lock lk;
575  uint32_t lk_flags;
576  uint32_t padding;
577 };
578 
579 struct fuse_lk_out {
580  struct fuse_file_lock lk;
581 };
582 
583 struct fuse_access_in {
584  uint32_t mask;
585  uint32_t padding;
586 };
587 
588 struct fuse_init_in {
589  uint32_t major;
590  uint32_t minor;
591  uint32_t max_readahead;
592  uint32_t flags;
593 };
594 
595 #define FUSE_COMPAT_INIT_OUT_SIZE 8
596 #define FUSE_COMPAT_22_INIT_OUT_SIZE 24
597 
598 struct fuse_init_out {
599  uint32_t major;
600  uint32_t minor;
601  uint32_t max_readahead;
602  uint32_t flags;
603  uint16_t max_background;
604  uint16_t congestion_threshold;
605  uint32_t max_write;
606  uint32_t time_gran;
607  uint32_t unused[9];
608 };
609 
610 #define CUSE_INIT_INFO_MAX 4096
611 
612 struct cuse_init_in {
613  uint32_t major;
614  uint32_t minor;
615  uint32_t unused;
616  uint32_t flags;
617 };
618 
619 struct cuse_init_out {
620  uint32_t major;
621  uint32_t minor;
622  uint32_t unused;
623  uint32_t flags;
624  uint32_t max_read;
625  uint32_t max_write;
626  uint32_t dev_major; /* chardev major */
627  uint32_t dev_minor; /* chardev minor */
628  uint32_t spare[10];
629 };
630 
631 struct fuse_interrupt_in {
632  uint64_t unique;
633 };
634 
635 struct fuse_bmap_in {
636  uint64_t block;
637  uint32_t blocksize;
638  uint32_t padding;
639 };
640 
641 struct fuse_bmap_out {
642  uint64_t block;
643 };
644 
645 struct fuse_ioctl_in {
646  uint64_t fh;
647  uint32_t flags;
648  uint32_t cmd;
649  uint64_t arg;
650  uint32_t in_size;
651  uint32_t out_size;
652 };
653 
654 struct fuse_ioctl_iovec {
655  uint64_t base;
656  uint64_t len;
657 };
658 
659 struct fuse_ioctl_out {
660  int32_t result;
661  uint32_t flags;
662  uint32_t in_iovs;
663  uint32_t out_iovs;
664 };
665 
666 struct fuse_poll_in {
667  uint64_t fh;
668  uint64_t kh;
669  uint32_t flags;
670  uint32_t events;
671 };
672 
673 struct fuse_poll_out {
674  uint32_t revents;
675  uint32_t padding;
676 };
677 
678 struct fuse_notify_poll_wakeup_out {
679  uint64_t kh;
680 };
681 
682 struct fuse_fallocate_in {
683  uint64_t fh;
684  uint64_t offset;
685  uint64_t length;
686  uint32_t mode;
687  uint32_t padding;
688 };
689 
690 struct fuse_in_header {
691  uint32_t len;
692  uint32_t opcode;
693  uint64_t unique;
694  uint64_t nodeid;
695  uint32_t uid;
696  uint32_t gid;
697  uint32_t pid;
698  uint32_t padding;
699 };
700 
701 struct fuse_out_header {
702  uint32_t len;
703  int32_t error;
704  uint64_t unique;
705 };
706 
707 struct fuse_dirent {
708  uint64_t ino;
709  uint64_t off;
710  uint32_t namelen;
711  uint32_t type;
712  char name[];
713 };
714 
715 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
716 #define FUSE_DIRENT_ALIGN(x) \
717  (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
718 #define FUSE_DIRENT_SIZE(d) \
719  FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
720 
721 struct fuse_direntplus {
722  struct fuse_entry_out entry_out;
723  struct fuse_dirent dirent;
724 };
725 
726 #define FUSE_NAME_OFFSET_DIRENTPLUS \
727  offsetof(struct fuse_direntplus, dirent.name)
728 #define FUSE_DIRENTPLUS_SIZE(d) \
729  FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
730 
731 struct fuse_notify_inval_inode_out {
732  uint64_t ino;
733  int64_t off;
734  int64_t len;
735 };
736 
737 struct fuse_notify_inval_entry_out {
738  uint64_t parent;
739  uint32_t namelen;
740  uint32_t padding;
741 };
742 
743 struct fuse_notify_delete_out {
744  uint64_t parent;
745  uint64_t child;
746  uint32_t namelen;
747  uint32_t padding;
748 };
749 
750 struct fuse_notify_store_out {
751  uint64_t nodeid;
752  uint64_t offset;
753  uint32_t size;
754  uint32_t padding;
755 };
756 
757 struct fuse_notify_retrieve_out {
758  uint64_t notify_unique;
759  uint64_t nodeid;
760  uint64_t offset;
761  uint32_t size;
762  uint32_t padding;
763 };
764 
765 /* Matches the size of fuse_write_in */
766 struct fuse_notify_retrieve_in {
767  uint64_t dummy1;
768  uint64_t offset;
769  uint32_t size;
770  uint32_t dummy2;
771  uint64_t dummy3;
772  uint64_t dummy4;
773 };
774 
775 /* Device ioctls: */
776 #define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t)
777 
778 struct fuse_lseek_in {
779  uint64_t fh;
780  uint64_t offset;
781  uint32_t whence;
782  uint32_t padding;
783 };
784 
785 struct fuse_lseek_out {
786  uint64_t offset;
787 };
788 
789 #endif /* _LINUX_FUSE_H */
Generated by   doxygen 1.8.13