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