LXR linux/include/linux/fuse.h

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