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