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