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