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