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