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