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