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