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