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 86 struct 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 105 struct 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 118 struct 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 222 enum 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 266 enum 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 278 struct 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 289 struct fuse_forget_in { 290 __u64 nlookup; 291 }; 292 293 struct fuse_getattr_in { 294 __u32 getattr_flags; 295 __u32 dummy; 296 __u64 fh; 297 }; 298 299 #define FUSE_COMPAT_ATTR_OUT_SIZE 96 300 301 struct 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 310 struct fuse_mknod_in { 311 __u32 mode; 312 __u32 rdev; 313 __u32 umask; 314 __u32 padding; 315 }; 316 317 struct fuse_mkdir_in { 318 __u32 mode; 319 __u32 umask; 320 }; 321 322 struct fuse_rename_in { 323 __u64 newdir; 324 }; 325 326 struct fuse_link_in { 327 __u64 oldnodeid; 328 }; 329 330 struct 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 349 struct fuse_open_in { 350 __u32 flags; 351 __u32 unused; 352 }; 353 354 struct fuse_create_in { 355 __u32 flags; 356 __u32 mode; 357 __u32 umask; 358 __u32 padding; 359 }; 360 361 struct fuse_open_out { 362 __u64 fh; 363 __u32 open_flags; 364 __u32 padding; 365 }; 366 367 struct fuse_release_in { 368 __u64 fh; 369 __u32 flags; 370 __u32 release_flags; 371 __u64 lock_owner; 372 }; 373 374 struct fuse_flush_in { 375 __u64 fh; 376 __u32 unused; 377 __u32 padding; 378 __u64 lock_owner; 379 }; 380 381 struct 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 393 struct 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 403 struct fuse_write_out { 404 __u32 size; 405 __u32 padding; 406 }; 407 408 #define FUSE_COMPAT_STATFS_SIZE 48 409 410 struct fuse_statfs_out { 411 struct fuse_kstatfs st; 412 }; 413 414 struct fuse_fsync_in { 415 __u64 fh; 416 __u32 fsync_flags; 417 __u32 padding; 418 }; 419 420 struct fuse_setxattr_in { 421 __u32 size; 422 __u32 flags; 423 }; 424 425 struct fuse_getxattr_in { 426 __u32 size; 427 __u32 padding; 428 }; 429 430 struct fuse_getxattr_out { 431 __u32 size; 432 __u32 padding; 433 }; 434 435 struct fuse_lk_in { 436 __u64 fh; 437 __u64 owner; 438 struct fuse_file_lock lk; 439 __u32 lk_flags; 440 __u32 padding; 441 }; 442 443 struct fuse_lk_out { 444 struct fuse_file_lock lk; 445 }; 446 447 struct fuse_access_in { 448 __u32 mask; 449 __u32 padding; 450 }; 451 452 struct fuse_init_in { 453 __u32 major; 454 __u32 minor; 455 __u32 max_readahead; 456 __u32 flags; 457 }; 458 459 struct 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 471 struct cuse_init_in { 472 __u32 major; 473 __u32 minor; 474 __u32 unused; 475 __u32 flags; 476 }; 477 478 struct 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 490 struct fuse_interrupt_in { 491 __u64 unique; 492 }; 493 494 struct fuse_bmap_in { 495 __u64 block; 496 __u32 blocksize; 497 __u32 padding; 498 }; 499 500 struct fuse_bmap_out { 501 __u64 block; 502 }; 503 504 struct 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 513 struct fuse_ioctl_out { 514 __s32 result; 515 __u32 flags; 516 __u32 in_iovs; 517 __u32 out_iovs; 518 }; 519 520 struct fuse_poll_in { 521 __u64 fh; 522 __u64 kh; 523 __u32 flags; 524 __u32 padding; 525 }; 526 527 struct fuse_poll_out { 528 __u32 revents; 529 __u32 padding; 530 }; 531 532 struct fuse_notify_poll_wakeup_out { 533 __u64 kh; 534 }; 535 536 struct 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 547 struct fuse_out_header { 548 __u32 len; 549 __s32 error; 550 __u64 unique; 551 }; 552 553 struct 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 566 struct fuse_notify_inval_inode_out { 567 __u64 ino; 568 __s64 off; 569 __s64 len; 570 }; 571 572 struct fuse_notify_inval_entry_out { 573 __u64 parent; 574 __u32 namelen; 575 __u32 padding; 576 }; 577 578 #endif /* _LINUX_FUSE_H */ 579