libfuse

fuse_kernel.h
1 /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
2 /*
3 This file defines the kernel interface of FUSE
4 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
5
6 This program can be distributed under the terms of the GNU GPL.
7 See the file COPYING.
8
9 This -- and only this -- header file may also be distributed under
10 the terms of the BSD Licence as follows:
11
12 Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.
13
14 Redistribution and use in source and binary forms, with or without
15 modification, are permitted provided that the following conditions
16 are met:
17 1. Redistributions of source code must retain the above copyright
18 notice, this list of conditions and the following disclaimer.
19 2. Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in the
21 documentation and/or other materials provided with the distribution.
22
23 THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
27 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 SUCH DAMAGE.
34 */
35
36 /*
37 * This file defines the kernel interface of FUSE
38 *
39 * Protocol changelog:
40 *
41 * 7.9:
42 * - new fuse_getattr_in input argument of GETATTR
43 * - add lk_flags in fuse_lk_in
44 * - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
45 * - add blksize field to fuse_attr
46 * - add file flags field to fuse_read_in and fuse_write_in
47 *
48 * 7.10
49 * - add nonseekable open flag
50 *
51 * 7.11
52 * - add IOCTL message
53 * - add unsolicited notification support
54 * - add POLL message and NOTIFY_POLL notification
55 *
56 * 7.12
57 * - add umask flag to input argument of create, mknod and mkdir
58 * - add notification messages for invalidation of inodes and
59 * directory entries
60 *
61 * 7.13
62 * - make max number of background requests and congestion threshold
63 * tunables
64 *
65 * 7.14
66 * - add splice support to fuse device
67 *
68 * 7.15
69 * - add store notify
70 * - add retrieve notify
71 *
72 * 7.16
73 * - add BATCH_FORGET request
74 * - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
75 * fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
76 * - add FUSE_IOCTL_32BIT flag
77 *
78 * 7.17
79 * - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
80 *
81 * 7.18
82 * - add FUSE_IOCTL_DIR flag
83 * - add FUSE_NOTIFY_DELETE
84 *
85 * 7.19
86 * - add FUSE_FALLOCATE
87 *
88 * 7.20
89 * - add FUSE_AUTO_INVAL_DATA
90 *
91 * 7.21
92 * - add FUSE_READDIRPLUS
93 * - send the requested events in POLL request
94 *
95 * 7.22
96 * - add FUSE_ASYNC_DIO
97 *
98 * 7.23
99 * - add FUSE_WRITEBACK_CACHE
100 * - add time_gran to fuse_init_out
101 * - add reserved space to fuse_init_out
102 * - add FATTR_CTIME
103 * - add ctime and ctimensec to fuse_setattr_in
104 * - add FUSE_RENAME2 request
105 * - add FUSE_NO_OPEN_SUPPORT flag
106 *
107 * 7.24
108 * - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support
109 *
110 * 7.25
111 * - add FUSE_PARALLEL_DIROPS
112 *
113 * 7.26
114 * - add FUSE_HANDLE_KILLPRIV
115 * - add FUSE_POSIX_ACL
116 *
117 * 7.27
118 * - add FUSE_ABORT_ERROR
119 *
120 * 7.28
121 * - add FUSE_COPY_FILE_RANGE
122 * - add FOPEN_CACHE_DIR
123 * - add FUSE_MAX_PAGES, add max_pages to init_out
124 * - add FUSE_CACHE_SYMLINKS
125 *
126 * 7.29
127 * - add FUSE_NO_OPENDIR_SUPPORT flag
128 */
129
130 #ifndef _LINUX_FUSE_H
131 #define _LINUX_FUSE_H
132
133 #ifdef __KERNEL__
134 #include <linux/types.h>
135 #else
136 #include <stdint.h>
137 #endif
138
139 /*
140 * Version negotiation:
141 *
142 * Both the kernel and userspace send the version they support in the
143 * INIT request and reply respectively.
144 *
145 * If the major versions match then both shall use the smallest
146 * of the two minor versions for communication.
147 *
148 * If the kernel supports a larger major version, then userspace shall
149 * reply with the major version it supports, ignore the rest of the
150 * INIT message and expect a new INIT message from the kernel with a
151 * matching major version.
152 *
153 * If the library supports a larger major version, then it shall fall
154 * back to the major protocol version sent by the kernel for
155 * communication and reply with that major version (and an arbitrary
156 * supported minor version).
157 */
158
160 #define FUSE_KERNEL_VERSION 7
161
163 #define FUSE_KERNEL_MINOR_VERSION 29
164
166 #define FUSE_ROOT_ID 1
167
168 /* Make sure all structures are padded to 64bit boundary, so 32bit
169 userspace works under 64bit kernels */
170
171 struct fuse_attr {
172 uint64_t ino;
173 uint64_t size;
174 uint64_t blocks;
175 uint64_t atime;
176 uint64_t mtime;
177 uint64_t ctime;
178 uint32_t atimensec;
179 uint32_t mtimensec;
180 uint32_t ctimensec;
181 uint32_t mode;
182 uint32_t nlink;
183 uint32_t uid;
184 uint32_t gid;
185 uint32_t rdev;
186 uint32_t blksize;
187 uint32_t padding;
188 };
189
190 struct fuse_kstatfs {
191 uint64_t blocks;
192 uint64_t bfree;
193 uint64_t bavail;
194 uint64_t files;
195 uint64_t ffree;
196 uint32_t bsize;
197 uint32_t namelen;
198 uint32_t frsize;
199 uint32_t padding;
200 uint32_t spare[6];
201 };
202
203 struct fuse_file_lock {
204 uint64_t start;
205 uint64_t end;
206 uint32_t type;
207 uint32_t pid; /* tgid */
208 };
209
213 #define FATTR_MODE (1 << 0)
214 #define FATTR_UID (1 << 1)
215 #define FATTR_GID (1 << 2)
216 #define FATTR_SIZE (1 << 3)
217 #define FATTR_ATIME (1 << 4)
218 #define FATTR_MTIME (1 << 5)
219 #define FATTR_FH (1 << 6)
220 #define FATTR_ATIME_NOW (1 << 7)
221 #define FATTR_MTIME_NOW (1 << 8)
222 #define FATTR_LOCKOWNER (1 << 9)
223 #define FATTR_CTIME (1 << 10)
224
233 #define FOPEN_DIRECT_IO (1 << 0)
234 #define FOPEN_KEEP_CACHE (1 << 1)
235 #define FOPEN_NONSEEKABLE (1 << 2)
236 #define FOPEN_CACHE_DIR (1 << 3)
237
267 #define FUSE_ASYNC_READ (1 << 0)
268 #define FUSE_POSIX_LOCKS (1 << 1)
269 #define FUSE_FILE_OPS (1 << 2)
270 #define FUSE_ATOMIC_O_TRUNC (1 << 3)
271 #define FUSE_EXPORT_SUPPORT (1 << 4)
272 #define FUSE_BIG_WRITES (1 << 5)
273 #define FUSE_DONT_MASK (1 << 6)
274 #define FUSE_SPLICE_WRITE (1 << 7)
275 #define FUSE_SPLICE_MOVE (1 << 8)
276 #define FUSE_SPLICE_READ (1 << 9)
277 #define FUSE_FLOCK_LOCKS (1 << 10)
278 #define FUSE_HAS_IOCTL_DIR (1 << 11)
279 #define FUSE_AUTO_INVAL_DATA (1 << 12)
280 #define FUSE_DO_READDIRPLUS (1 << 13)
281 #define FUSE_READDIRPLUS_AUTO (1 << 14)
282 #define FUSE_ASYNC_DIO (1 << 15)
283 #define FUSE_WRITEBACK_CACHE (1 << 16)
284 #define FUSE_NO_OPEN_SUPPORT (1 << 17)
285 #define FUSE_PARALLEL_DIROPS (1 << 18)
286 #define FUSE_HANDLE_KILLPRIV (1 << 19)
287 #define FUSE_POSIX_ACL (1 << 20)
288 #define FUSE_ABORT_ERROR (1 << 21)
289 #define FUSE_MAX_PAGES (1 << 22)
290 #define FUSE_CACHE_SYMLINKS (1 << 23)
291 #define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
292
298 #define CUSE_UNRESTRICTED_IOCTL (1 << 0)
299
303 #define FUSE_RELEASE_FLUSH (1 << 0)
304 #define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1)
305
309 #define FUSE_GETATTR_FH (1 << 0)
310
314 #define FUSE_LK_FLOCK (1 << 0)
315
322 #define FUSE_WRITE_CACHE (1 << 0)
323 #define FUSE_WRITE_LOCKOWNER (1 << 1)
324
328 #define FUSE_READ_LOCKOWNER (1 << 1)
329
341 #define FUSE_IOCTL_COMPAT (1 << 0)
342 #define FUSE_IOCTL_UNRESTRICTED (1 << 1)
343 #define FUSE_IOCTL_RETRY (1 << 2)
344 #define FUSE_IOCTL_32BIT (1 << 3)
345 #define FUSE_IOCTL_DIR (1 << 4)
346
347 #define FUSE_IOCTL_MAX_IOV 256
348
354 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
355
356 enum fuse_opcode {
357 FUSE_LOOKUP = 1,
358 FUSE_FORGET = 2, /* no reply */
359 FUSE_GETATTR = 3,
360 FUSE_SETATTR = 4,
361 FUSE_READLINK = 5,
362 FUSE_SYMLINK = 6,
363 FUSE_MKNOD = 8,
364 FUSE_MKDIR = 9,
365 FUSE_UNLINK = 10,
366 FUSE_RMDIR = 11,
367 FUSE_RENAME = 12,
368 FUSE_LINK = 13,
369 FUSE_OPEN = 14,
370 FUSE_READ = 15,
371 FUSE_WRITE = 16,
372 FUSE_STATFS = 17,
373 FUSE_RELEASE = 18,
374 FUSE_FSYNC = 20,
375 FUSE_SETXATTR = 21,
376 FUSE_GETXATTR = 22,
377 FUSE_LISTXATTR = 23,
378 FUSE_REMOVEXATTR = 24,
379 FUSE_FLUSH = 25,
380 FUSE_INIT = 26,
381 FUSE_OPENDIR = 27,
382 FUSE_READDIR = 28,
383 FUSE_RELEASEDIR = 29,
384 FUSE_FSYNCDIR = 30,
385 FUSE_GETLK = 31,
386 FUSE_SETLK = 32,
387 FUSE_SETLKW = 33,
388 FUSE_ACCESS = 34,
389 FUSE_CREATE = 35,
390 FUSE_INTERRUPT = 36,
391 FUSE_BMAP = 37,
392 FUSE_DESTROY = 38,
393 FUSE_IOCTL = 39,
394 FUSE_POLL = 40,
395 FUSE_NOTIFY_REPLY = 41,
396 FUSE_BATCH_FORGET = 42,
397 FUSE_FALLOCATE = 43,
398 FUSE_READDIRPLUS = 44,
399 FUSE_RENAME2 = 45,
400 FUSE_LSEEK = 46,
401 FUSE_COPY_FILE_RANGE = 47,
402
403 /* CUSE specific operations */
404 CUSE_INIT = 4096,
405 };
406
407 enum fuse_notify_code {
408 FUSE_NOTIFY_POLL = 1,
409 FUSE_NOTIFY_INVAL_INODE = 2,
410 FUSE_NOTIFY_INVAL_ENTRY = 3,
411 FUSE_NOTIFY_STORE = 4,
412 FUSE_NOTIFY_RETRIEVE = 5,
413 FUSE_NOTIFY_DELETE = 6,
414 FUSE_NOTIFY_CODE_MAX,
415 };
416
417 /* The read buffer is required to be at least 8k, but may be much larger */
418 #define FUSE_MIN_READ_BUFFER 8192
419
420 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
421
422 struct fuse_entry_out {
423 uint64_t nodeid; /* Inode ID */
424 uint64_t generation; /* Inode generation: nodeid:gen must
425 be unique for the fs's lifetime */
426 uint64_t entry_valid; /* Cache timeout for the name */
427 uint64_t attr_valid; /* Cache timeout for the attributes */
428 uint32_t entry_valid_nsec;
429 uint32_t attr_valid_nsec;
430 struct fuse_attr attr;
431 };
432
433 struct fuse_forget_in {
434 uint64_t nlookup;
435 };
436
437 struct fuse_forget_one {
438 uint64_t nodeid;
439 uint64_t nlookup;
440 };
441
442 struct fuse_batch_forget_in {
443 uint32_t count;
444 uint32_t dummy;
445 };
446
447 struct fuse_getattr_in {
448 uint32_t getattr_flags;
449 uint32_t dummy;
450 uint64_t fh;
451 };
452
453 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
454
455 struct fuse_attr_out {
456 uint64_t attr_valid; /* Cache timeout for the attributes */
457 uint32_t attr_valid_nsec;
458 uint32_t dummy;
459 struct fuse_attr attr;
460 };
461
462 #define FUSE_COMPAT_MKNOD_IN_SIZE 8
463
464 struct fuse_mknod_in {
465 uint32_t mode;
466 uint32_t rdev;
467 uint32_t umask;
468 uint32_t padding;
469 };
470
471 struct fuse_mkdir_in {
472 uint32_t mode;
473 uint32_t umask;
474 };
475
476 struct fuse_rename_in {
477 uint64_t newdir;
478 };
479
480 struct fuse_rename2_in {
481 uint64_t newdir;
482 uint32_t flags;
483 uint32_t padding;
484 };
485
486 struct fuse_link_in {
487 uint64_t oldnodeid;
488 };
489
490 struct fuse_setattr_in {
491 uint32_t valid;
492 uint32_t padding;
493 uint64_t fh;
494 uint64_t size;
495 uint64_t lock_owner;
496 uint64_t atime;
497 uint64_t mtime;
498 uint64_t ctime;
499 uint32_t atimensec;
500 uint32_t mtimensec;
501 uint32_t ctimensec;
502 uint32_t mode;
503 uint32_t unused4;
504 uint32_t uid;
505 uint32_t gid;
506 uint32_t unused5;
507 };
508
509 struct fuse_open_in {
510 uint32_t flags;
511 uint32_t unused;
512 };
513
514 struct fuse_create_in {
515 uint32_t flags;
516 uint32_t mode;
517 uint32_t umask;
518 uint32_t padding;
519 };
520
521 struct fuse_open_out {
522 uint64_t fh;
523 uint32_t open_flags;
524 uint32_t padding;
525 };
526
527 struct fuse_release_in {
528 uint64_t fh;
529 uint32_t flags;
530 uint32_t release_flags;
531 uint64_t lock_owner;
532 };
533
534 struct fuse_flush_in {
535 uint64_t fh;
536 uint32_t unused;
537 uint32_t padding;
538 uint64_t lock_owner;
539 };
540
541 struct fuse_read_in {
542 uint64_t fh;
543 uint64_t offset;
544 uint32_t size;
545 uint32_t read_flags;
546 uint64_t lock_owner;
547 uint32_t flags;
548 uint32_t padding;
549 };
550
551 #define FUSE_COMPAT_WRITE_IN_SIZE 24
552
553 struct fuse_write_in {
554 uint64_t fh;
555 uint64_t offset;
556 uint32_t size;
557 uint32_t write_flags;
558 uint64_t lock_owner;
559 uint32_t flags;
560 uint32_t padding;
561 };
562
563 struct fuse_write_out {
564 uint32_t size;
565 uint32_t padding;
566 };
567
568 #define FUSE_COMPAT_STATFS_SIZE 48
569
570 struct fuse_statfs_out {
571 struct fuse_kstatfs st;
572 };
573
574 struct fuse_fsync_in {
575 uint64_t fh;
576 uint32_t fsync_flags;
577 uint32_t padding;
578 };
579
580 struct fuse_setxattr_in {
581 uint32_t size;
582 uint32_t flags;
583 };
584
585 struct fuse_getxattr_in {
586 uint32_t size;
587 uint32_t padding;
588 };
589
590 struct fuse_getxattr_out {
591 uint32_t size;
592 uint32_t padding;
593 };
594
595 struct fuse_lk_in {
596 uint64_t fh;
597 uint64_t owner;
598 struct fuse_file_lock lk;
599 uint32_t lk_flags;
600 uint32_t padding;
601 };
602
603 struct fuse_lk_out {
604 struct fuse_file_lock lk;
605 };
606
607 struct fuse_access_in {
608 uint32_t mask;
609 uint32_t padding;
610 };
611
612 struct fuse_init_in {
613 uint32_t major;
614 uint32_t minor;
615 uint32_t max_readahead;
616 uint32_t flags;
617 };
618
619 #define FUSE_COMPAT_INIT_OUT_SIZE 8
620 #define FUSE_COMPAT_22_INIT_OUT_SIZE 24
621
622 struct fuse_init_out {
623 uint32_t major;
624 uint32_t minor;
625 uint32_t max_readahead;
626 uint32_t flags;
627 uint16_t max_background;
628 uint16_t congestion_threshold;
629 uint32_t max_write;
630 uint32_t time_gran;
631 uint16_t max_pages;
632 uint16_t padding;
633 uint32_t unused[8];
634 };
635
636 #define CUSE_INIT_INFO_MAX 4096
637
638 struct cuse_init_in {
639 uint32_t major;
640 uint32_t minor;
641 uint32_t unused;
642 uint32_t flags;
643 };
644
645 struct cuse_init_out {
646 uint32_t major;
647 uint32_t minor;
648 uint32_t unused;
649 uint32_t flags;
650 uint32_t max_read;
651 uint32_t max_write;
652 uint32_t dev_major; /* chardev major */
653 uint32_t dev_minor; /* chardev minor */
654 uint32_t spare[10];
655 };
656
657 struct fuse_interrupt_in {
658 uint64_t unique;
659 };
660
661 struct fuse_bmap_in {
662 uint64_t block;
663 uint32_t blocksize;
664 uint32_t padding;
665 };
666
667 struct fuse_bmap_out {
668 uint64_t block;
669 };
670
671 struct fuse_ioctl_in {
672 uint64_t fh;
673 uint32_t flags;
674 uint32_t cmd;
675 uint64_t arg;
676 uint32_t in_size;
677 uint32_t out_size;
678 };
679
680 struct fuse_ioctl_iovec {
681 uint64_t base;
682 uint64_t len;
683 };
684
685 struct fuse_ioctl_out {
686 int32_t result;
687 uint32_t flags;
688 uint32_t in_iovs;
689 uint32_t out_iovs;
690 };
691
692 struct fuse_poll_in {
693 uint64_t fh;
694 uint64_t kh;
695 uint32_t flags;
696 uint32_t events;
697 };
698
699 struct fuse_poll_out {
700 uint32_t revents;
701 uint32_t padding;
702 };
703
704 struct fuse_notify_poll_wakeup_out {
705 uint64_t kh;
706 };
707
708 struct fuse_fallocate_in {
709 uint64_t fh;
710 uint64_t offset;
711 uint64_t length;
712 uint32_t mode;
713 uint32_t padding;
714 };
715
716 struct fuse_in_header {
717 uint32_t len;
718 uint32_t opcode;
719 uint64_t unique;
720 uint64_t nodeid;
721 uint32_t uid;
722 uint32_t gid;
723 uint32_t pid;
724 uint32_t padding;
725 };
726
727 struct fuse_out_header {
728 uint32_t len;
729 int32_t error;
730 uint64_t unique;
731 };
732
733 struct fuse_dirent {
734 uint64_t ino;
735 uint64_t off;
736 uint32_t namelen;
737 uint32_t type;
738 char name[];
739 };
740
741 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
742 #define FUSE_DIRENT_ALIGN(x) \
743 (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
744 #define FUSE_DIRENT_SIZE(d) \
745 FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
746
747 struct fuse_direntplus {
748 struct fuse_entry_out entry_out;
749 struct fuse_dirent dirent;
750 };
751
752 #define FUSE_NAME_OFFSET_DIRENTPLUS \
753 offsetof(struct fuse_direntplus, dirent.name)
754 #define FUSE_DIRENTPLUS_SIZE(d) \
755 FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
756
757 struct fuse_notify_inval_inode_out {
758 uint64_t ino;
759 int64_t off;
760 int64_t len;
761 };
762
763 struct fuse_notify_inval_entry_out {
764 uint64_t parent;
765 uint32_t namelen;
766 uint32_t padding;
767 };
768
769 struct fuse_notify_delete_out {
770 uint64_t parent;
771 uint64_t child;
772 uint32_t namelen;
773 uint32_t padding;
774 };
775
776 struct fuse_notify_store_out {
777 uint64_t nodeid;
778 uint64_t offset;
779 uint32_t size;
780 uint32_t padding;
781 };
782
783 struct fuse_notify_retrieve_out {
784 uint64_t notify_unique;
785 uint64_t nodeid;
786 uint64_t offset;
787 uint32_t size;
788 uint32_t padding;
789 };
790
791 /* Matches the size of fuse_write_in */
792 struct fuse_notify_retrieve_in {
793 uint64_t dummy1;
794 uint64_t offset;
795 uint32_t size;
796 uint32_t dummy2;
797 uint64_t dummy3;
798 uint64_t dummy4;
799 };
800
801 /* Device ioctls: */
802 #define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t)
803
804 struct fuse_lseek_in {
805 uint64_t fh;
806 uint64_t offset;
807 uint32_t whence;
808 uint32_t padding;
809 };
810
811 struct fuse_lseek_out {
812 uint64_t offset;
813 };
814
815 struct fuse_copy_file_range_in {
816 uint64_t fh_in;
817 uint64_t off_in;
818 uint64_t nodeid_out;
819 uint64_t fh_out;
820 uint64_t off_out;
821 uint64_t len;
822 uint64_t flags;
823 };
824
825 #endif /* _LINUX_FUSE_H */