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