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 * 7.29 166 * - add FUSE_NO_OPENDIR_SUPPORT flag 167 * 168 * 7.30 169 * - add FUSE_EXPLICIT_INVAL_DATA 170 * - add FUSE_IOCTL_COMPAT_X32 171 * 172 * 7.31 173 * - add FUSE_WRITE_KILL_PRIV flag 174 * - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING 175 * - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag 176 * 177 * 7.32 178 * - add flags to fuse_attr, add FUSE_ATTR_SUBMOUNT, add FUSE_SUBMOUNTS 179 */ 180 181 #ifndef _FUSE_FUSE_KERNEL_H 182 #define _FUSE_FUSE_KERNEL_H 183 184 #ifdef __linux__ 185 #include <linux/types.h> 186 #else 187 #include <sys/types.h> 188 #endif 189 190 /* 191 * Version negotiation: 192 * 193 * Both the kernel and userspace send the version they support in the 194 * INIT request and reply respectively. 195 * 196 * If the major versions match then both shall use the smallest 197 * of the two minor versions for communication. 198 * 199 * If the kernel supports a larger major version, then userspace shall 200 * reply with the major version it supports, ignore the rest of the 201 * INIT message and expect a new INIT message from the kernel with a 202 * matching major version. 203 * 204 * If the library supports a larger major version, then it shall fall 205 * back to the major protocol version sent by the kernel for 206 * communication and reply with that major version (and an arbitrary 207 * supported minor version). 208 */ 209 210 /** Version number of this interface */ 211 #define FUSE_KERNEL_VERSION 7 212 213 /** Minor version number of this interface */ 214 #define FUSE_KERNEL_MINOR_VERSION 32 215 216 /** The node ID of the root inode */ 217 #define FUSE_ROOT_ID 1 218 219 /* Make sure all structures are padded to 64bit boundary, so 32bit 220 userspace works under 64bit kernels */ 221 222 struct fuse_attr { 223 uint64_t ino; 224 uint64_t size; 225 uint64_t blocks; 226 uint64_t atime; 227 uint64_t mtime; 228 uint64_t ctime; 229 uint32_t atimensec; 230 uint32_t mtimensec; 231 uint32_t ctimensec; 232 uint32_t mode; 233 uint32_t nlink; 234 uint32_t uid; 235 uint32_t gid; 236 uint32_t rdev; 237 uint32_t blksize; 238 uint32_t flags; 239 }; 240 241 struct fuse_kstatfs { 242 uint64_t blocks; 243 uint64_t bfree; 244 uint64_t bavail; 245 uint64_t files; 246 uint64_t ffree; 247 uint32_t bsize; 248 uint32_t namelen; 249 uint32_t frsize; 250 uint32_t padding; 251 uint32_t spare[6]; 252 }; 253 254 struct fuse_file_lock { 255 uint64_t start; 256 uint64_t end; 257 uint32_t type; 258 uint32_t pid; /* tgid */ 259 }; 260 261 /** 262 * Bitmasks for fuse_setattr_in.valid 263 */ 264 #define FATTR_MODE (1 << 0) 265 #define FATTR_UID (1 << 1) 266 #define FATTR_GID (1 << 2) 267 #define FATTR_SIZE (1 << 3) 268 #define FATTR_ATIME (1 << 4) 269 #define FATTR_MTIME (1 << 5) 270 #define FATTR_FH (1 << 6) 271 #define FATTR_ATIME_NOW (1 << 7) 272 #define FATTR_MTIME_NOW (1 << 8) 273 #define FATTR_LOCKOWNER (1 << 9) 274 #define FATTR_CTIME (1 << 10) 275 276 /** 277 * Flags returned by the OPEN request 278 * 279 * FOPEN_DIRECT_IO: bypass page cache for this open file 280 * FOPEN_KEEP_CACHE: don't invalidate the data cache on open 281 * FOPEN_NONSEEKABLE: the file is not seekable 282 * FOPEN_CACHE_DIR: allow caching this directory 283 * FOPEN_STREAM: the file is stream-like (no file position at all) 284 */ 285 #define FOPEN_DIRECT_IO (1 << 0) 286 #define FOPEN_KEEP_CACHE (1 << 1) 287 #define FOPEN_NONSEEKABLE (1 << 2) 288 #define FOPEN_CACHE_DIR (1 << 3) 289 #define FOPEN_STREAM (1 << 4) 290 291 /** 292 * INIT request/reply flags 293 * 294 * FUSE_ASYNC_READ: asynchronous read requests 295 * FUSE_POSIX_LOCKS: remote locking for POSIX file locks 296 * FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported) 297 * FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem 298 * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".." 299 * FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB 300 * FUSE_DONT_MASK: don't apply umask to file mode on create operations 301 * FUSE_SPLICE_WRITE: kernel supports splice write on the device 302 * FUSE_SPLICE_MOVE: kernel supports splice move on the device 303 * FUSE_SPLICE_READ: kernel supports splice read on the device 304 * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks 305 * FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories 306 * FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages 307 * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one) 308 * FUSE_READDIRPLUS_AUTO: adaptive readdirplus 309 * FUSE_ASYNC_DIO: asynchronous direct I/O submission 310 * FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes 311 * FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens 312 * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir 313 * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc 314 * FUSE_POSIX_ACL: filesystem supports posix acls 315 * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED 316 * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages 317 * FUSE_CACHE_SYMLINKS: cache READLINK responses 318 * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir 319 * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request 320 * FUSE_MAP_ALIGNMENT: init_out.map_alignment contains log2(byte alignment) for 321 * foffset and moffset fields in struct 322 * fuse_setupmapping_out and fuse_removemapping_one. 323 * FUSE_SUBMOUNTS: kernel supports auto-mounting directory submounts 324 */ 325 #define FUSE_ASYNC_READ (1 << 0) 326 #define FUSE_POSIX_LOCKS (1 << 1) 327 #define FUSE_FILE_OPS (1 << 2) 328 #define FUSE_ATOMIC_O_TRUNC (1 << 3) 329 #define FUSE_EXPORT_SUPPORT (1 << 4) 330 #define FUSE_BIG_WRITES (1 << 5) 331 #define FUSE_DONT_MASK (1 << 6) 332 #define FUSE_SPLICE_WRITE (1 << 7) 333 #define FUSE_SPLICE_MOVE (1 << 8) 334 #define FUSE_SPLICE_READ (1 << 9) 335 #define FUSE_FLOCK_LOCKS (1 << 10) 336 #define FUSE_HAS_IOCTL_DIR (1 << 11) 337 #define FUSE_AUTO_INVAL_DATA (1 << 12) 338 #define FUSE_DO_READDIRPLUS (1 << 13) 339 #define FUSE_READDIRPLUS_AUTO (1 << 14) 340 #define FUSE_ASYNC_DIO (1 << 15) 341 #define FUSE_WRITEBACK_CACHE (1 << 16) 342 #define FUSE_NO_OPEN_SUPPORT (1 << 17) 343 #define FUSE_PARALLEL_DIROPS (1 << 18) 344 #define FUSE_HANDLE_KILLPRIV (1 << 19) 345 #define FUSE_POSIX_ACL (1 << 20) 346 #define FUSE_ABORT_ERROR (1 << 21) 347 #define FUSE_MAX_PAGES (1 << 22) 348 #define FUSE_CACHE_SYMLINKS (1 << 23) 349 #define FUSE_NO_OPENDIR_SUPPORT (1 << 24) 350 #define FUSE_EXPLICIT_INVAL_DATA (1 << 25) 351 #define FUSE_MAP_ALIGNMENT (1 << 26) 352 #define FUSE_SUBMOUNTS (1 << 27) 353 354 #ifdef linux 355 /** 356 * CUSE INIT request/reply flags 357 * 358 * CUSE_UNRESTRICTED_IOCTL: use unrestricted ioctl 359 */ 360 #define CUSE_UNRESTRICTED_IOCTL (1 << 0) 361 #endif /* linux */ 362 363 /** 364 * Release flags 365 */ 366 #define FUSE_RELEASE_FLUSH (1 << 0) 367 #define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1) 368 369 /** 370 * Getattr flags 371 */ 372 #define FUSE_GETATTR_FH (1 << 0) 373 374 /** 375 * Lock flags 376 */ 377 #define FUSE_LK_FLOCK (1 << 0) 378 379 /** 380 * WRITE flags 381 * 382 * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed 383 * FUSE_WRITE_LOCKOWNER: lock_owner field is valid 384 * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits 385 */ 386 #define FUSE_WRITE_CACHE (1 << 0) 387 #define FUSE_WRITE_LOCKOWNER (1 << 1) 388 #define FUSE_WRITE_KILL_PRIV (1 << 2) 389 390 /** 391 * Read flags 392 */ 393 #define FUSE_READ_LOCKOWNER (1 << 1) 394 395 /** 396 * Ioctl flags 397 * 398 * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine 399 * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed 400 * FUSE_IOCTL_RETRY: retry with new iovecs 401 * FUSE_IOCTL_32BIT: 32bit ioctl 402 * FUSE_IOCTL_DIR: is a directory 403 * FUSE_IOCTL_COMPAT_X32: x32 compat ioctl on 64bit machine (64bit time_t) 404 * 405 * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs 406 */ 407 #define FUSE_IOCTL_COMPAT (1 << 0) 408 #define FUSE_IOCTL_UNRESTRICTED (1 << 1) 409 #define FUSE_IOCTL_RETRY (1 << 2) 410 #define FUSE_IOCTL_32BIT (1 << 3) 411 #define FUSE_IOCTL_DIR (1 << 4) 412 #define FUSE_IOCTL_COMPAT_X32 (1 << 5) 413 414 #define FUSE_IOCTL_MAX_IOV 256 415 416 /** 417 * Poll flags 418 * 419 * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify 420 */ 421 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0) 422 423 /** 424 * Fsync flags 425 * 426 * FUSE_FSYNC_FDATASYNC: Sync data only, not metadata 427 */ 428 #define FUSE_FSYNC_FDATASYNC (1 << 0) 429 430 /** 431 * Fallocate flags. 432 */ 433 #define FUSE_FALLOC_FL_KEEP_SIZE 0x1 434 #define FUSE_FALLOC_FL_PUNCH_HOLE 0x2 435 436 /** 437 * fuse_attr flags 438 * 439 * FUSE_ATTR_SUBMOUNT: Object is a submount root 440 */ 441 #define FUSE_ATTR_SUBMOUNT (1 << 0) 442 443 enum fuse_opcode { 444 FUSE_LOOKUP = 1, 445 FUSE_FORGET = 2, /* no reply */ 446 FUSE_GETATTR = 3, 447 FUSE_SETATTR = 4, 448 FUSE_READLINK = 5, 449 FUSE_SYMLINK = 6, 450 FUSE_MKNOD = 8, 451 FUSE_MKDIR = 9, 452 FUSE_UNLINK = 10, 453 FUSE_RMDIR = 11, 454 FUSE_RENAME = 12, 455 FUSE_LINK = 13, 456 FUSE_OPEN = 14, 457 FUSE_READ = 15, 458 FUSE_WRITE = 16, 459 FUSE_STATFS = 17, 460 FUSE_RELEASE = 18, 461 FUSE_FSYNC = 20, 462 FUSE_SETXATTR = 21, 463 FUSE_GETXATTR = 22, 464 FUSE_LISTXATTR = 23, 465 FUSE_REMOVEXATTR = 24, 466 FUSE_FLUSH = 25, 467 FUSE_INIT = 26, 468 FUSE_OPENDIR = 27, 469 FUSE_READDIR = 28, 470 FUSE_RELEASEDIR = 29, 471 FUSE_FSYNCDIR = 30, 472 FUSE_GETLK = 31, 473 FUSE_SETLK = 32, 474 FUSE_SETLKW = 33, 475 FUSE_ACCESS = 34, 476 FUSE_CREATE = 35, 477 FUSE_INTERRUPT = 36, 478 FUSE_BMAP = 37, 479 FUSE_DESTROY = 38, 480 FUSE_IOCTL = 39, 481 FUSE_POLL = 40, 482 FUSE_NOTIFY_REPLY = 41, 483 FUSE_BATCH_FORGET = 42, 484 FUSE_FALLOCATE = 43, 485 FUSE_READDIRPLUS = 44, 486 FUSE_RENAME2 = 45, 487 FUSE_LSEEK = 46, 488 FUSE_COPY_FILE_RANGE = 47, 489 FUSE_SETUPMAPPING = 48, 490 FUSE_REMOVEMAPPING = 49, 491 492 #ifdef linux 493 /* CUSE specific operations */ 494 CUSE_INIT = 4096, 495 /* Reserved opcodes: helpful to detect structure endian-ness */ 496 CUSE_INIT_BSWAP_RESERVED = 1048576, /* CUSE_INIT << 8 */ 497 FUSE_INIT_BSWAP_RESERVED = 436207616, /* FUSE_INIT << 24 */ 498 #endif /* linux */ 499 }; 500 501 enum fuse_notify_code { 502 FUSE_NOTIFY_POLL = 1, 503 FUSE_NOTIFY_INVAL_INODE = 2, 504 FUSE_NOTIFY_INVAL_ENTRY = 3, 505 FUSE_NOTIFY_STORE = 4, 506 FUSE_NOTIFY_RETRIEVE = 5, 507 FUSE_NOTIFY_DELETE = 6, 508 FUSE_NOTIFY_CODE_MAX, 509 }; 510 511 /* The read buffer is required to be at least 8k, but may be much larger */ 512 #define FUSE_MIN_READ_BUFFER 8192 513 514 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120 515 516 struct fuse_entry_out { 517 uint64_t nodeid; /* Inode ID */ 518 uint64_t generation; /* Inode generation: nodeid:gen must 519 be unique for the fs's lifetime */ 520 uint64_t entry_valid; /* Cache timeout for the name */ 521 uint64_t attr_valid; /* Cache timeout for the attributes */ 522 uint32_t entry_valid_nsec; 523 uint32_t attr_valid_nsec; 524 struct fuse_attr attr; 525 }; 526 527 struct fuse_forget_in { 528 uint64_t nlookup; 529 }; 530 531 struct fuse_forget_one { 532 uint64_t nodeid; 533 uint64_t nlookup; 534 }; 535 536 struct fuse_batch_forget_in { 537 uint32_t count; 538 uint32_t dummy; 539 }; 540 541 struct fuse_getattr_in { 542 uint32_t getattr_flags; 543 uint32_t dummy; 544 uint64_t fh; 545 }; 546 547 #define FUSE_COMPAT_ATTR_OUT_SIZE 96 548 549 struct fuse_attr_out { 550 uint64_t attr_valid; /* Cache timeout for the attributes */ 551 uint32_t attr_valid_nsec; 552 uint32_t dummy; 553 struct fuse_attr attr; 554 }; 555 556 #define FUSE_COMPAT_MKNOD_IN_SIZE 8 557 558 struct fuse_mknod_in { 559 uint32_t mode; 560 uint32_t rdev; 561 uint32_t umask; 562 uint32_t padding; 563 }; 564 565 struct fuse_mkdir_in { 566 uint32_t mode; 567 uint32_t umask; 568 }; 569 570 struct fuse_rename_in { 571 uint64_t newdir; 572 }; 573 574 struct fuse_rename2_in { 575 uint64_t newdir; 576 uint32_t flags; 577 uint32_t padding; 578 }; 579 580 struct fuse_link_in { 581 uint64_t oldnodeid; 582 }; 583 584 struct fuse_setattr_in { 585 uint32_t valid; 586 uint32_t padding; 587 uint64_t fh; 588 uint64_t size; 589 uint64_t lock_owner; 590 uint64_t atime; 591 uint64_t mtime; 592 uint64_t ctime; 593 uint32_t atimensec; 594 uint32_t mtimensec; 595 uint32_t ctimensec; 596 uint32_t mode; 597 uint32_t unused4; 598 uint32_t uid; 599 uint32_t gid; 600 uint32_t unused5; 601 }; 602 603 struct fuse_open_in { 604 uint32_t flags; 605 uint32_t unused; 606 }; 607 608 struct fuse_create_in { 609 uint32_t flags; 610 uint32_t mode; 611 uint32_t umask; 612 uint32_t padding; 613 }; 614 615 struct fuse_open_out { 616 uint64_t fh; 617 uint32_t open_flags; 618 uint32_t padding; 619 }; 620 621 struct fuse_release_in { 622 uint64_t fh; 623 uint32_t flags; 624 uint32_t release_flags; 625 uint64_t lock_owner; 626 }; 627 628 struct fuse_flush_in { 629 uint64_t fh; 630 uint32_t unused; 631 uint32_t padding; 632 uint64_t lock_owner; 633 }; 634 635 struct fuse_read_in { 636 uint64_t fh; 637 uint64_t offset; 638 uint32_t size; 639 uint32_t read_flags; 640 uint64_t lock_owner; 641 uint32_t flags; 642 uint32_t padding; 643 }; 644 645 #define FUSE_COMPAT_WRITE_IN_SIZE 24 646 647 struct fuse_write_in { 648 uint64_t fh; 649 uint64_t offset; 650 uint32_t size; 651 uint32_t write_flags; 652 uint64_t lock_owner; 653 uint32_t flags; 654 uint32_t padding; 655 }; 656 657 struct fuse_write_out { 658 uint32_t size; 659 uint32_t padding; 660 }; 661 662 #define FUSE_COMPAT_STATFS_SIZE 48 663 664 struct fuse_statfs_out { 665 struct fuse_kstatfs st; 666 }; 667 668 struct fuse_fsync_in { 669 uint64_t fh; 670 uint32_t fsync_flags; 671 uint32_t padding; 672 }; 673 674 struct fuse_setxattr_in { 675 uint32_t size; 676 uint32_t flags; 677 }; 678 679 struct fuse_listxattr_in { 680 uint32_t size; 681 uint32_t padding; 682 }; 683 684 struct fuse_listxattr_out { 685 uint32_t size; 686 uint32_t padding; 687 }; 688 689 struct fuse_getxattr_in { 690 uint32_t size; 691 uint32_t padding; 692 }; 693 694 struct fuse_getxattr_out { 695 uint32_t size; 696 uint32_t padding; 697 }; 698 699 struct fuse_lk_in { 700 uint64_t fh; 701 uint64_t owner; 702 struct fuse_file_lock lk; 703 uint32_t lk_flags; 704 uint32_t padding; 705 }; 706 707 struct fuse_lk_out { 708 struct fuse_file_lock lk; 709 }; 710 711 struct fuse_access_in { 712 uint32_t mask; 713 uint32_t padding; 714 }; 715 716 struct fuse_init_in { 717 uint32_t major; 718 uint32_t minor; 719 uint32_t max_readahead; 720 uint32_t flags; 721 }; 722 723 #define FUSE_COMPAT_INIT_OUT_SIZE 8 724 #define FUSE_COMPAT_22_INIT_OUT_SIZE 24 725 726 struct fuse_init_out { 727 uint32_t major; 728 uint32_t minor; 729 uint32_t max_readahead; 730 uint32_t flags; 731 uint16_t max_background; 732 uint16_t congestion_threshold; 733 uint32_t max_write; 734 uint32_t time_gran; 735 uint16_t max_pages; 736 uint16_t map_alignment; 737 uint32_t unused[8]; 738 }; 739 740 #ifdef linux 741 #define CUSE_INIT_INFO_MAX 4096 742 743 struct cuse_init_in { 744 uint32_t major; 745 uint32_t minor; 746 uint32_t unused; 747 uint32_t flags; 748 }; 749 750 struct cuse_init_out { 751 uint32_t major; 752 uint32_t minor; 753 uint32_t unused; 754 uint32_t flags; 755 uint32_t max_read; 756 uint32_t max_write; 757 uint32_t dev_major; /* chardev major */ 758 uint32_t dev_minor; /* chardev minor */ 759 uint32_t spare[10]; 760 }; 761 #endif /* linux */ 762 763 struct fuse_interrupt_in { 764 uint64_t unique; 765 }; 766 767 struct fuse_bmap_in { 768 uint64_t block; 769 uint32_t blocksize; 770 uint32_t padding; 771 }; 772 773 struct fuse_bmap_out { 774 uint64_t block; 775 }; 776 777 struct fuse_ioctl_in { 778 uint64_t fh; 779 uint32_t flags; 780 uint32_t cmd; 781 uint64_t arg; 782 uint32_t in_size; 783 uint32_t out_size; 784 }; 785 786 struct fuse_ioctl_iovec { 787 uint64_t base; 788 uint64_t len; 789 }; 790 791 struct fuse_ioctl_out { 792 int32_t result; 793 uint32_t flags; 794 uint32_t in_iovs; 795 uint32_t out_iovs; 796 }; 797 798 struct fuse_poll_in { 799 uint64_t fh; 800 uint64_t kh; 801 uint32_t flags; 802 uint32_t events; 803 }; 804 805 struct fuse_poll_out { 806 uint32_t revents; 807 uint32_t padding; 808 }; 809 810 struct fuse_notify_poll_wakeup_out { 811 uint64_t kh; 812 }; 813 814 struct fuse_fallocate_in { 815 uint64_t fh; 816 uint64_t offset; 817 uint64_t length; 818 uint32_t mode; 819 uint32_t padding; 820 }; 821 822 struct fuse_in_header { 823 uint32_t len; 824 uint32_t opcode; 825 uint64_t unique; 826 uint64_t nodeid; 827 uint32_t uid; 828 uint32_t gid; 829 uint32_t pid; 830 uint32_t padding; 831 }; 832 833 struct fuse_out_header { 834 uint32_t len; 835 int32_t error; 836 uint64_t unique; 837 }; 838 839 struct fuse_dirent { 840 uint64_t ino; 841 uint64_t off; 842 uint32_t namelen; 843 uint32_t type; 844 char name[]; 845 }; 846 847 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name) 848 #define FUSE_DIRENT_ALIGN(x) \ 849 (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1)) 850 #define FUSE_DIRENT_SIZE(d) \ 851 FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen) 852 853 struct fuse_direntplus { 854 struct fuse_entry_out entry_out; 855 struct fuse_dirent dirent; 856 }; 857 858 #define FUSE_NAME_OFFSET_DIRENTPLUS \ 859 offsetof(struct fuse_direntplus, dirent.name) 860 #define FUSE_DIRENTPLUS_SIZE(d) \ 861 FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen) 862 863 struct fuse_notify_inval_inode_out { 864 uint64_t ino; 865 int64_t off; 866 int64_t len; 867 }; 868 869 struct fuse_notify_inval_entry_out { 870 uint64_t parent; 871 uint32_t namelen; 872 uint32_t padding; 873 }; 874 875 struct fuse_notify_delete_out { 876 uint64_t parent; 877 uint64_t child; 878 uint32_t namelen; 879 uint32_t padding; 880 }; 881 882 struct fuse_notify_store_out { 883 uint64_t nodeid; 884 uint64_t offset; 885 uint32_t size; 886 uint32_t padding; 887 }; 888 889 struct fuse_notify_retrieve_out { 890 uint64_t notify_unique; 891 uint64_t nodeid; 892 uint64_t offset; 893 uint32_t size; 894 uint32_t padding; 895 }; 896 897 /* Matches the size of fuse_write_in */ 898 struct fuse_notify_retrieve_in { 899 uint64_t dummy1; 900 uint64_t offset; 901 uint32_t size; 902 uint32_t dummy2; 903 uint64_t dummy3; 904 uint64_t dummy4; 905 }; 906 907 /* Device ioctls: */ 908 #define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t) 909 910 struct fuse_lseek_in { 911 uint64_t fh; 912 uint64_t offset; 913 uint32_t whence; 914 uint32_t padding; 915 }; 916 917 struct fuse_lseek_out { 918 uint64_t offset; 919 }; 920 921 struct fuse_copy_file_range_in { 922 uint64_t fh_in; 923 uint64_t off_in; 924 uint64_t nodeid_out; 925 uint64_t fh_out; 926 uint64_t off_out; 927 uint64_t len; 928 uint64_t flags; 929 }; 930 931 932 #define FUSE_SETUPMAPPING_FLAG_WRITE (1ull << 0) 933 #define FUSE_SETUPMAPPING_FLAG_READ (1ull << 1) 934 struct fuse_setupmapping_in { 935 /* An already open handle */ 936 uint64_t fh; 937 /* Offset into the file to start the mapping */ 938 uint64_t foffset; 939 /* Length of mapping required */ 940 uint64_t len; 941 /* Flags, FUSE_SETUPMAPPING_FLAG_* */ 942 uint64_t flags; 943 /* Offset in Memory Window */ 944 uint64_t moffset; 945 }; 946 947 struct fuse_removemapping_in { 948 /* number of fuse_removemapping_one follows */ 949 uint32_t count; 950 }; 951 952 struct fuse_removemapping_one { 953 /* Offset into the dax window start the unmapping */ 954 uint64_t moffset; 955 /* Length of mapping required */ 956 uint64_t len; 957 }; 958 959 #define FUSE_REMOVEMAPPING_MAX_ENTRY \ 960 (PAGE_SIZE / sizeof(struct fuse_removemapping_one)) 961 962 #endif /* _FUSE_FUSE_KERNEL_H */ 963