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