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