kernel/fuse_kernel.h

   1 /*
   2     This file defines the kernel interface of FUSE
   3     Copyright (C) 2001-2007  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
  48 #ifndef linux
  49 #include <sys/types.h>
  50 #define __u64 uint64_t
  51 #define __u32 uint32_t
  52 #define __s32 int32_t
  53 #else
  54 #include <asm/types.h>
  55 #include <linux/major.h>
  56 #endif
  57
  58 /** Version number of this interface */
  59 #define FUSE_KERNEL_VERSION 7
  60
  61 /** Minor version number of this interface */
  62 #define FUSE_KERNEL_MINOR_VERSION 9
  63
  64 /** The node ID of the root inode */
  65 #define FUSE_ROOT_ID 1
  66
  67 /** The major number of the fuse character device */
  68 #define FUSE_MAJOR MISC_MAJOR
  69
  70 /** The minor number of the fuse character device */
  71 #define FUSE_MINOR 229
  72
  73 /* Make sure all structures are padded to 64bit boundary, so 32bit
  74    userspace works under 64bit kernels */
  75
  76 struct fuse_attr {
  77         __u64   ino;
  78         __u64   size;
  79         __u64   blocks;
  80         __u64   atime;
  81         __u64   mtime;
  82         __u64   ctime;
  83         __u32   atimensec;
  84         __u32   mtimensec;
  85         __u32   ctimensec;
  86         __u32   mode;
  87         __u32   nlink;
  88         __u32   uid;
  89         __u32   gid;
  90         __u32   rdev;
  91         __u32   blksize;
  92         __u32   padding;
  93 };
  94
  95 struct fuse_kstatfs {
  96         __u64   blocks;
  97         __u64   bfree;
  98         __u64   bavail;
  99         __u64   files;
 100         __u64   ffree;
 101         __u32   bsize;
 102         __u32   namelen;
 103         __u32   frsize;
 104         __u32   padding;
 105         __u32   spare[6];
 106 };
 107
 108 struct fuse_file_lock {
 109         __u64   start;
 110         __u64   end;
 111         __u32   type;
 112         __u32   pid; /* tgid */
 113 };
 114
 115 /**
 116  * Bitmasks for fuse_setattr_in.valid
 117  */
 118 #define FATTR_MODE      (1 << 0)
 119 #define FATTR_UID       (1 << 1)
 120 #define FATTR_GID       (1 << 2)
 121 #define FATTR_SIZE      (1 << 3)
 122 #define FATTR_ATIME     (1 << 4)
 123 #define FATTR_MTIME     (1 << 5)
 124 #define FATTR_FH        (1 << 6)
 125 #define FATTR_ATIME_NOW (1 << 7)
 126 #define FATTR_MTIME_NOW (1 << 8)
 127 #define FATTR_LOCKOWNER (1 << 9)
 128
 129 /**
 130  * Flags returned by the OPEN request
 131  *
 132  * FOPEN_DIRECT_IO: bypass page cache for this open file
 133  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
 134  */
 135 #define FOPEN_DIRECT_IO         (1 << 0)
 136 #define FOPEN_KEEP_CACHE        (1 << 1)
 137
 138 /**
 139  * INIT request/reply flags
 140  */
 141 #define FUSE_ASYNC_READ         (1 << 0)
 142 #define FUSE_POSIX_LOCKS        (1 << 1)
 143 #define FUSE_FILE_OPS           (1 << 2)
 144 #define FUSE_ATOMIC_O_TRUNC     (1 << 3)
 145 #define FUSE_BIG_WRITES         (1 << 5)
 146
 147 /**
 148  * Release flags
 149  */
 150 #define FUSE_RELEASE_FLUSH      (1 << 0)
 151
 152 /**
 153  * Getattr flags
 154  */
 155 #define FUSE_GETATTR_FH         (1 << 0)
 156
 157 /**
 158  * Lock flags
 159  */
 160 #define FUSE_LK_FLOCK           (1 << 0)
 161
 162 /**
 163  * WRITE flags
 164  *
 165  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
 166  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
 167  */
 168 #define FUSE_WRITE_CACHE        (1 << 0)
 169 #define FUSE_WRITE_LOCKOWNER    (1 << 1)
 170
 171 /**
 172  * Read flags
 173  */
 174 #define FUSE_READ_LOCKOWNER     (1 << 1)
 175
 176 enum fuse_opcode {
 177         FUSE_LOOKUP        = 1,
 178         FUSE_FORGET        = 2,  /* no reply */
 179         FUSE_GETATTR       = 3,
 180         FUSE_SETATTR       = 4,
 181         FUSE_READLINK      = 5,
 182         FUSE_SYMLINK       = 6,
 183         FUSE_MKNOD         = 8,
 184         FUSE_MKDIR         = 9,
 185         FUSE_UNLINK        = 10,
 186         FUSE_RMDIR         = 11,
 187         FUSE_RENAME        = 12,
 188         FUSE_LINK          = 13,
 189         FUSE_OPEN          = 14,
 190         FUSE_READ          = 15,
 191         FUSE_WRITE         = 16,
 192         FUSE_STATFS        = 17,
 193         FUSE_RELEASE       = 18,
 194         FUSE_FSYNC         = 20,
 195         FUSE_SETXATTR      = 21,
 196         FUSE_GETXATTR      = 22,
 197         FUSE_LISTXATTR     = 23,
 198         FUSE_REMOVEXATTR   = 24,
 199         FUSE_FLUSH         = 25,
 200         FUSE_INIT          = 26,
 201         FUSE_OPENDIR       = 27,
 202         FUSE_READDIR       = 28,
 203         FUSE_RELEASEDIR    = 29,
 204         FUSE_FSYNCDIR      = 30,
 205         FUSE_GETLK         = 31,
 206         FUSE_SETLK         = 32,
 207         FUSE_SETLKW        = 33,
 208         FUSE_ACCESS        = 34,
 209         FUSE_CREATE        = 35,
 210         FUSE_INTERRUPT     = 36,
 211         FUSE_BMAP          = 37,
 212         FUSE_DESTROY       = 38,
 213 };
 214
 215 /* The read buffer is required to be at least 8k, but may be much larger */
 216 #define FUSE_MIN_READ_BUFFER 8192
 217
 218 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
 219
 220 struct fuse_entry_out {
 221         __u64   nodeid;         /* Inode ID */
 222         __u64   generation;     /* Inode generation: nodeid:gen must
 223                                    be unique for the fs's lifetime */
 224         __u64   entry_valid;    /* Cache timeout for the name */
 225         __u64   attr_valid;     /* Cache timeout for the attributes */
 226         __u32   entry_valid_nsec;
 227         __u32   attr_valid_nsec;
 228         struct fuse_attr attr;
 229 };
 230
 231 struct fuse_forget_in {
 232         __u64   nlookup;
 233 };
 234
 235 struct fuse_getattr_in {
 236         __u32   getattr_flags;
 237         __u32   dummy;
 238         __u64   fh;
 239 };
 240
 241 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
 242
 243 struct fuse_attr_out {
 244         __u64   attr_valid;     /* Cache timeout for the attributes */
 245         __u32   attr_valid_nsec;
 246         __u32   dummy;
 247         struct fuse_attr attr;
 248 };
 249
 250 struct fuse_mknod_in {
 251         __u32   mode;
 252         __u32   rdev;
 253 };
 254
 255 struct fuse_mkdir_in {
 256         __u32   mode;
 257         __u32   padding;
 258 };
 259
 260 struct fuse_rename_in {
 261         __u64   newdir;
 262 };
 263
 264 struct fuse_link_in {
 265         __u64   oldnodeid;
 266 };
 267
 268 struct fuse_setattr_in {
 269         __u32   valid;
 270         __u32   padding;
 271         __u64   fh;
 272         __u64   size;
 273         __u64   lock_owner;
 274         __u64   atime;
 275         __u64   mtime;
 276         __u64   unused2;
 277         __u32   atimensec;
 278         __u32   mtimensec;
 279         __u32   unused3;
 280         __u32   mode;
 281         __u32   unused4;
 282         __u32   uid;
 283         __u32   gid;
 284         __u32   unused5;
 285 };
 286
 287 struct fuse_open_in {
 288         __u32   flags;
 289         __u32   mode;
 290 };
 291
 292 struct fuse_open_out {
 293         __u64   fh;
 294         __u32   open_flags;
 295         __u32   padding;
 296 };
 297
 298 struct fuse_release_in {
 299         __u64   fh;
 300         __u32   flags;
 301         __u32   release_flags;
 302         __u64   lock_owner;
 303 };
 304
 305 struct fuse_flush_in {
 306         __u64   fh;
 307         __u32   unused;
 308         __u32   padding;
 309         __u64   lock_owner;
 310 };
 311
 312 struct fuse_read_in {
 313         __u64   fh;
 314         __u64   offset;
 315         __u32   size;
 316         __u32   read_flags;
 317         __u64   lock_owner;
 318         __u32   flags;
 319         __u32   padding;
 320 };
 321
 322 #define FUSE_COMPAT_WRITE_IN_SIZE 24
 323
 324 struct fuse_write_in {
 325         __u64   fh;
 326         __u64   offset;
 327         __u32   size;
 328         __u32   write_flags;
 329         __u64   lock_owner;
 330         __u32   flags;
 331         __u32   padding;
 332 };
 333
 334 struct fuse_write_out {
 335         __u32   size;
 336         __u32   padding;
 337 };
 338
 339 #define FUSE_COMPAT_STATFS_SIZE 48
 340
 341 struct fuse_statfs_out {
 342         struct fuse_kstatfs st;
 343 };
 344
 345 struct fuse_fsync_in {
 346         __u64   fh;
 347         __u32   fsync_flags;
 348         __u32   padding;
 349 };
 350
 351 struct fuse_setxattr_in {
 352         __u32   size;
 353         __u32   flags;
 354 };
 355
 356 struct fuse_getxattr_in {
 357         __u32   size;
 358         __u32   padding;
 359 };
 360
 361 struct fuse_getxattr_out {
 362         __u32   size;
 363         __u32   padding;
 364 };
 365
 366 struct fuse_lk_in {
 367         __u64   fh;
 368         __u64   owner;
 369         struct fuse_file_lock lk;
 370         __u32   lk_flags;
 371         __u32   padding;
 372 };
 373
 374 struct fuse_lk_out {
 375         struct fuse_file_lock lk;
 376 };
 377
 378 struct fuse_access_in {
 379         __u32   mask;
 380         __u32   padding;
 381 };
 382
 383 struct fuse_init_in {
 384         __u32   major;
 385         __u32   minor;
 386         __u32   max_readahead;
 387         __u32   flags;
 388 };
 389
 390 struct fuse_init_out {
 391         __u32   major;
 392         __u32   minor;
 393         __u32   max_readahead;
 394         __u32   flags;
 395         __u32   unused;
 396         __u32   max_write;
 397 };
 398
 399 struct fuse_interrupt_in {
 400         __u64   unique;
 401 };
 402
 403 struct fuse_bmap_in {
 404         __u64   block;
 405         __u32   blocksize;
 406         __u32   padding;
 407 };
 408
 409 struct fuse_bmap_out {
 410         __u64   block;
 411 };
 412
 413 struct fuse_in_header {
 414         __u32   len;
 415         __u32   opcode;
 416         __u64   unique;
 417         __u64   nodeid;
 418         __u32   uid;
 419         __u32   gid;
 420         __u32   pid;
 421         __u32   padding;
 422 };
 423
 424 struct fuse_out_header {
 425         __u32   len;
 426         __s32   error;
 427         __u64   unique;
 428 };
 429
 430 struct fuse_dirent {
 431         __u64   ino;
 432         __u64   off;
 433         __u32   namelen;
 434         __u32   type;
 435         char name[0];
 436 };
 437
 438 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
 439 #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
 440 #define FUSE_DIRENT_SIZE(d) \
 441         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)