libfuse: include/fuse_kernel.h Source File

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