1 /* FUSE: Filesystem in Userspace 2 Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu> 3 4 This program can be distributed under the terms of the GNU LGPLv2. 5 See the file COPYING.LIB. 6 */ 7 8 /** @file */ 9 10 #if !defined(FUSE_H_) && !defined(FUSE_LOWLEVEL_H_) 11 #error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead." 12 #endif 13 14 #ifndef FUSE_COMMON_H_ 15 #define FUSE_COMMON_H_ 16 17 #include "fuse_opt.h" 18 #include "fuse_log.h" 19 #include <stdint.h> 20 #include <sys/types.h> 21 22 /** Major version of FUSE library interface */ 23 #define FUSE_MAJOR_VERSION 3 24 25 /** Minor version of FUSE library interface */ 26 #define FUSE_MINOR_VERSION 2 27 28 #define FUSE_MAKE_VERSION(maj, min) ((maj) * 10 + (min)) 29 #define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION) 30 31 #ifdef __cplusplus 32 extern "C" { 33 #endif 34 35 /** 36 * Information about an open file. 37 * 38 * File Handles are created by the open, opendir, and create methods and closed 39 * by the release and releasedir methods. Multiple file handles may be 40 * concurrently open for the same file. Generally, a client will create one 41 * file handle per file descriptor, though in some cases multiple file 42 * descriptors can share a single file handle. 43 */ 44 struct fuse_file_info { 45 /** Open flags. Available in open() and release() */ 46 int flags; 47 48 /** In case of a write operation indicates if this was caused 49 by a delayed write from the page cache. If so, then the 50 context's pid, uid, and gid fields will not be valid, and 51 the *fh* value may not match the *fh* value that would 52 have been sent with the corresponding individual write 53 requests if write caching had been disabled. */ 54 unsigned int writepage : 1; 55 56 /** Can be filled in by open, to use direct I/O on this file. */ 57 unsigned int direct_io : 1; 58 59 /** Can be filled in by open. It signals the kernel that any 60 currently cached file data (ie., data that the filesystem 61 provided the last time the file was open) need not be 62 invalidated. Has no effect when set in other contexts (in 63 particular it does nothing when set by opendir()). */ 64 unsigned int keep_cache : 1; 65 66 /** Indicates a flush operation. Set in flush operation, also 67 maybe set in highlevel lock operation and lowlevel release 68 operation. */ 69 unsigned int flush : 1; 70 71 /** Can be filled in by open, to indicate that the file is not 72 seekable. */ 73 unsigned int nonseekable : 1; 74 75 /* Indicates that flock locks for this file should be 76 released. If set, lock_owner shall contain a valid value. 77 May only be set in ->release(). */ 78 unsigned int flock_release : 1; 79 80 /** Can be filled in by opendir. It signals the kernel to 81 enable caching of entries returned by readdir(). Has no 82 effect when set in other contexts (in particular it does 83 nothing when set by open()). */ 84 unsigned int cache_readdir : 1; 85 86 /** Padding. Reserved for future use*/ 87 unsigned int padding : 25; 88 unsigned int padding2 : 32; 89 90 /** File handle id. May be filled in by filesystem in create, 91 * open, and opendir(). Available in most other file operations on the 92 * same file handle. */ 93 uint64_t fh; 94 95 /** Lock owner id. Available in locking operations and flush */ 96 uint64_t lock_owner; 97 98 /** Requested poll events. Available in ->poll. Only set on kernels 99 which support it. If unsupported, this field is set to zero. */ 100 uint32_t poll_events; 101 }; 102 103 /** 104 * Configuration parameters passed to fuse_session_loop_mt() and 105 * fuse_loop_mt(). 106 */ 107 struct fuse_loop_config { 108 /** 109 * whether to use separate device fds for each thread 110 * (may increase performance) 111 */ 112 int clone_fd; 113 114 /** 115 * The maximum number of available worker threads before they 116 * start to get deleted when they become idle. If not 117 * specified, the default is 10. 118 * 119 * Adjusting this has performance implications; a very small number 120 * of threads in the pool will cause a lot of thread creation and 121 * deletion overhead and performance may suffer. When set to 0, a new 122 * thread will be created to service every operation. 123 */ 124 unsigned int max_idle_threads; 125 }; 126 127 /************************************************************************** 128 * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' * 129 **************************************************************************/ 130 131 /** 132 * Indicates that the filesystem supports asynchronous read requests. 133 * 134 * If this capability is not requested/available, the kernel will 135 * ensure that there is at most one pending read request per 136 * file-handle at any time, and will attempt to order read requests by 137 * increasing offset. 138 * 139 * This feature is enabled by default when supported by the kernel. 140 */ 141 #define FUSE_CAP_ASYNC_READ (1 << 0) 142 143 /** 144 * Indicates that the filesystem supports "remote" locking. 145 * 146 * This feature is enabled by default when supported by the kernel, 147 * and if getlk() and setlk() handlers are implemented. 148 */ 149 #define FUSE_CAP_POSIX_LOCKS (1 << 1) 150 151 /** 152 * Indicates that the filesystem supports the O_TRUNC open flag. If 153 * disabled, and an application specifies O_TRUNC, fuse first calls 154 * truncate() and then open() with O_TRUNC filtered out. 155 * 156 * This feature is enabled by default when supported by the kernel. 157 */ 158 #define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3) 159 160 /** 161 * Indicates that the filesystem supports lookups of "." and "..". 162 * 163 * This feature is disabled by default. 164 */ 165 #define FUSE_CAP_EXPORT_SUPPORT (1 << 4) 166 167 /** 168 * Indicates that the kernel should not apply the umask to the 169 * file mode on create operations. 170 * 171 * This feature is disabled by default. 172 */ 173 #define FUSE_CAP_DONT_MASK (1 << 6) 174 175 /** 176 * Indicates that libfuse should try to use splice() when writing to 177 * the fuse device. This may improve performance. 178 * 179 * This feature is disabled by default. 180 */ 181 #define FUSE_CAP_SPLICE_WRITE (1 << 7) 182 183 /** 184 * Indicates that libfuse should try to move pages instead of copying when 185 * writing to / reading from the fuse device. This may improve performance. 186 * 187 * This feature is disabled by default. 188 */ 189 #define FUSE_CAP_SPLICE_MOVE (1 << 8) 190 191 /** 192 * Indicates that libfuse should try to use splice() when reading from 193 * the fuse device. This may improve performance. 194 * 195 * This feature is enabled by default when supported by the kernel and 196 * if the filesystem implements a write_buf() handler. 197 */ 198 #define FUSE_CAP_SPLICE_READ (1 << 9) 199 200 /** 201 * If set, the calls to flock(2) will be emulated using POSIX locks and must 202 * then be handled by the filesystem's setlock() handler. 203 * 204 * If not set, flock(2) calls will be handled by the FUSE kernel module 205 * internally (so any access that does not go through the kernel cannot be taken 206 * into account). 207 * 208 * This feature is enabled by default when supported by the kernel and 209 * if the filesystem implements a flock() handler. 210 */ 211 #define FUSE_CAP_FLOCK_LOCKS (1 << 10) 212 213 /** 214 * Indicates that the filesystem supports ioctl's on directories. 215 * 216 * This feature is enabled by default when supported by the kernel. 217 */ 218 #define FUSE_CAP_IOCTL_DIR (1 << 11) 219 220 /** 221 * Traditionally, while a file is open the FUSE kernel module only 222 * asks the filesystem for an update of the file's attributes when a 223 * client attempts to read beyond EOF. This is unsuitable for 224 * e.g. network filesystems, where the file contents may change 225 * without the kernel knowing about it. 226 * 227 * If this flag is set, FUSE will check the validity of the attributes 228 * on every read. If the attributes are no longer valid (i.e., if the 229 * *attr_timeout* passed to fuse_reply_attr() or set in `struct 230 * fuse_entry_param` has passed), it will first issue a `getattr` 231 * request. If the new mtime differs from the previous value, any 232 * cached file *contents* will be invalidated as well. 233 * 234 * This flag should always be set when available. If all file changes 235 * go through the kernel, *attr_timeout* should be set to a very large 236 * number to avoid unnecessary getattr() calls. 237 * 238 * This feature is enabled by default when supported by the kernel. 239 */ 240 #define FUSE_CAP_AUTO_INVAL_DATA (1 << 12) 241 242 /** 243 * Indicates that the filesystem supports readdirplus. 244 * 245 * This feature is enabled by default when supported by the kernel and if the 246 * filesystem implements a readdirplus() handler. 247 */ 248 #define FUSE_CAP_READDIRPLUS (1 << 13) 249 250 /** 251 * Indicates that the filesystem supports adaptive readdirplus. 252 * 253 * If FUSE_CAP_READDIRPLUS is not set, this flag has no effect. 254 * 255 * If FUSE_CAP_READDIRPLUS is set and this flag is not set, the kernel 256 * will always issue readdirplus() requests to retrieve directory 257 * contents. 258 * 259 * If FUSE_CAP_READDIRPLUS is set and this flag is set, the kernel 260 * will issue both readdir() and readdirplus() requests, depending on 261 * how much information is expected to be required. 262 * 263 * As of Linux 4.20, the algorithm is as follows: when userspace 264 * starts to read directory entries, issue a READDIRPLUS request to 265 * the filesystem. If any entry attributes have been looked up by the 266 * time userspace requests the next batch of entries continue with 267 * READDIRPLUS, otherwise switch to plain READDIR. This will reasult 268 * in eg plain "ls" triggering READDIRPLUS first then READDIR after 269 * that because it doesn't do lookups. "ls -l" should result in all 270 * READDIRPLUS, except if dentries are already cached. 271 * 272 * This feature is enabled by default when supported by the kernel and 273 * if the filesystem implements both a readdirplus() and a readdir() 274 * handler. 275 */ 276 #define FUSE_CAP_READDIRPLUS_AUTO (1 << 14) 277 278 /** 279 * Indicates that the filesystem supports asynchronous direct I/O submission. 280 * 281 * If this capability is not requested/available, the kernel will ensure that 282 * there is at most one pending read and one pending write request per direct 283 * I/O file-handle at any time. 284 * 285 * This feature is enabled by default when supported by the kernel. 286 */ 287 #define FUSE_CAP_ASYNC_DIO (1 << 15) 288 289 /** 290 * Indicates that writeback caching should be enabled. This means that 291 * individual write request may be buffered and merged in the kernel 292 * before they are send to the filesystem. 293 * 294 * This feature is disabled by default. 295 */ 296 #define FUSE_CAP_WRITEBACK_CACHE (1 << 16) 297 298 /** 299 * Indicates support for zero-message opens. If this flag is set in 300 * the `capable` field of the `fuse_conn_info` structure, then the 301 * filesystem may return `ENOSYS` from the open() handler to indicate 302 * success. Further attempts to open files will be handled in the 303 * kernel. (If this flag is not set, returning ENOSYS will be treated 304 * as an error and signaled to the caller). 305 * 306 * Setting (or unsetting) this flag in the `want` field has *no 307 * effect*. 308 */ 309 #define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17) 310 311 /** 312 * Indicates support for parallel directory operations. If this flag 313 * is unset, the FUSE kernel module will ensure that lookup() and 314 * readdir() requests are never issued concurrently for the same 315 * directory. 316 * 317 * This feature is enabled by default when supported by the kernel. 318 */ 319 #define FUSE_CAP_PARALLEL_DIROPS (1 << 18) 320 321 /** 322 * Indicates support for POSIX ACLs. 323 * 324 * If this feature is enabled, the kernel will cache and have 325 * responsibility for enforcing ACLs. ACL will be stored as xattrs and 326 * passed to userspace, which is responsible for updating the ACLs in 327 * the filesystem, keeping the file mode in sync with the ACL, and 328 * ensuring inheritance of default ACLs when new filesystem nodes are 329 * created. Note that this requires that the file system is able to 330 * parse and interpret the xattr representation of ACLs. 331 * 332 * Enabling this feature implicitly turns on the 333 * ``default_permissions`` mount option (even if it was not passed to 334 * mount(2)). 335 * 336 * This feature is disabled by default. 337 */ 338 #define FUSE_CAP_POSIX_ACL (1 << 19) 339 340 /** 341 * Indicates that the filesystem is responsible for unsetting 342 * setuid and setgid bits when a file is written, truncated, or 343 * its owner is changed. 344 * 345 * This feature is enabled by default when supported by the kernel. 346 */ 347 #define FUSE_CAP_HANDLE_KILLPRIV (1 << 20) 348 349 /** 350 * Indicates support for zero-message opendirs. If this flag is set in 351 * the `capable` field of the `fuse_conn_info` structure, then the filesystem 352 * may return `ENOSYS` from the opendir() handler to indicate success. Further 353 * opendir and releasedir messages will be handled in the kernel. (If this 354 * flag is not set, returning ENOSYS will be treated as an error and signalled 355 * to the caller.) 356 * 357 * Setting (or unsetting) this flag in the `want` field has *no effect*. 358 */ 359 #define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24) 360 361 /** 362 * Ioctl flags 363 * 364 * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine 365 * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed 366 * FUSE_IOCTL_RETRY: retry with new iovecs 367 * FUSE_IOCTL_DIR: is a directory 368 * 369 * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs 370 */ 371 #define FUSE_IOCTL_COMPAT (1 << 0) 372 #define FUSE_IOCTL_UNRESTRICTED (1 << 1) 373 #define FUSE_IOCTL_RETRY (1 << 2) 374 #define FUSE_IOCTL_DIR (1 << 4) 375 376 #define FUSE_IOCTL_MAX_IOV 256 377 378 /** 379 * Connection information, passed to the ->init() method 380 * 381 * Some of the elements are read-write, these can be changed to 382 * indicate the value requested by the filesystem. The requested 383 * value must usually be smaller than the indicated value. 384 */ 385 struct fuse_conn_info { 386 /** 387 * Major version of the protocol (read-only) 388 */ 389 unsigned proto_major; 390 391 /** 392 * Minor version of the protocol (read-only) 393 */ 394 unsigned proto_minor; 395 396 /** 397 * Maximum size of the write buffer 398 */ 399 unsigned max_write; 400 401 /** 402 * Maximum size of read requests. A value of zero indicates no 403 * limit. However, even if the filesystem does not specify a 404 * limit, the maximum size of read requests will still be 405 * limited by the kernel. 406 * 407 * NOTE: For the time being, the maximum size of read requests 408 * must be set both here *and* passed to fuse_session_new() 409 * using the ``-o max_read=<n>`` mount option. At some point 410 * in the future, specifying the mount option will no longer 411 * be necessary. 412 */ 413 unsigned max_read; 414 415 /** 416 * Maximum readahead 417 */ 418 unsigned max_readahead; 419 420 /** 421 * Capability flags that the kernel supports (read-only) 422 */ 423 unsigned capable; 424 425 /** 426 * Capability flags that the filesystem wants to enable. 427 * 428 * libfuse attempts to initialize this field with 429 * reasonable default values before calling the init() handler. 430 */ 431 unsigned want; 432 433 /** 434 * Maximum number of pending "background" requests. A 435 * background request is any type of request for which the 436 * total number is not limited by other means. As of kernel 437 * 4.8, only two types of requests fall into this category: 438 * 439 * 1. Read-ahead requests 440 * 2. Asynchronous direct I/O requests 441 * 442 * Read-ahead requests are generated (if max_readahead is 443 * non-zero) by the kernel to preemptively fill its caches 444 * when it anticipates that userspace will soon read more 445 * data. 446 * 447 * Asynchronous direct I/O requests are generated if 448 * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large 449 * direct I/O request. In this case the kernel will internally 450 * split it up into multiple smaller requests and submit them 451 * to the filesystem concurrently. 452 * 453 * Note that the following requests are *not* background 454 * requests: writeback requests (limited by the kernel's 455 * flusher algorithm), regular (i.e., synchronous and 456 * buffered) userspace read/write requests (limited to one per 457 * thread), asynchronous read requests (Linux's io_submit(2) 458 * call actually blocks, so these are also limited to one per 459 * thread). 460 */ 461 unsigned max_background; 462 463 /** 464 * Kernel congestion threshold parameter. If the number of pending 465 * background requests exceeds this number, the FUSE kernel module will 466 * mark the filesystem as "congested". This instructs the kernel to 467 * expect that queued requests will take some time to complete, and to 468 * adjust its algorithms accordingly (e.g. by putting a waiting thread 469 * to sleep instead of using a busy-loop). 470 */ 471 unsigned congestion_threshold; 472 473 /** 474 * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible 475 * for updating mtime and ctime when write requests are received. The 476 * updated values are passed to the filesystem with setattr() requests. 477 * However, if the filesystem does not support the full resolution of 478 * the kernel timestamps (nanoseconds), the mtime and ctime values used 479 * by kernel and filesystem will differ (and result in an apparent 480 * change of times after a cache flush). 481 * 482 * To prevent this problem, this variable can be used to inform the 483 * kernel about the timestamp granularity supported by the file-system. 484 * The value should be power of 10. The default is 1, i.e. full 485 * nano-second resolution. Filesystems supporting only second resolution 486 * should set this to 1000000000. 487 */ 488 unsigned time_gran; 489 490 /** 491 * For future use. 492 */ 493 unsigned reserved[22]; 494 }; 495 496 struct fuse_session; 497 struct fuse_pollhandle; 498 struct fuse_conn_info_opts; 499 500 /** 501 * This function parses several command-line options that can be used 502 * to override elements of struct fuse_conn_info. The pointer returned 503 * by this function should be passed to the 504 * fuse_apply_conn_info_opts() method by the file system's init() 505 * handler. 506 * 507 * Before using this function, think twice if you really want these 508 * parameters to be adjustable from the command line. In most cases, 509 * they should be determined by the file system internally. 510 * 511 * The following options are recognized: 512 * 513 * -o max_write=N sets conn->max_write 514 * -o max_readahead=N sets conn->max_readahead 515 * -o max_background=N sets conn->max_background 516 * -o congestion_threshold=N sets conn->congestion_threshold 517 * -o async_read sets FUSE_CAP_ASYNC_READ in conn->want 518 * -o sync_read unsets FUSE_CAP_ASYNC_READ in conn->want 519 * -o atomic_o_trunc sets FUSE_CAP_ATOMIC_O_TRUNC in conn->want 520 * -o no_remote_lock Equivalent to -o no_remote_flock,no_remote_posix_lock 521 * -o no_remote_flock Unsets FUSE_CAP_FLOCK_LOCKS in conn->want 522 * -o no_remote_posix_lock Unsets FUSE_CAP_POSIX_LOCKS in conn->want 523 * -o [no_]splice_write (un-)sets FUSE_CAP_SPLICE_WRITE in conn->want 524 * -o [no_]splice_move (un-)sets FUSE_CAP_SPLICE_MOVE in conn->want 525 * -o [no_]splice_read (un-)sets FUSE_CAP_SPLICE_READ in conn->want 526 * -o [no_]auto_inval_data (un-)sets FUSE_CAP_AUTO_INVAL_DATA in conn->want 527 * -o readdirplus=no unsets FUSE_CAP_READDIRPLUS in conn->want 528 * -o readdirplus=yes sets FUSE_CAP_READDIRPLUS and unsets 529 * FUSE_CAP_READDIRPLUS_AUTO in conn->want 530 * -o readdirplus=auto sets FUSE_CAP_READDIRPLUS and 531 * FUSE_CAP_READDIRPLUS_AUTO in conn->want 532 * -o [no_]async_dio (un-)sets FUSE_CAP_ASYNC_DIO in conn->want 533 * -o [no_]writeback_cache (un-)sets FUSE_CAP_WRITEBACK_CACHE in conn->want 534 * -o time_gran=N sets conn->time_gran 535 * 536 * Known options will be removed from *args*, unknown options will be 537 * passed through unchanged. 538 * 539 * @param args argument vector (input+output) 540 * @return parsed options 541 **/ 542 struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args); 543 544 /** 545 * This function applies the (parsed) parameters in *opts* to the 546 * *conn* pointer. It may modify the following fields: wants, 547 * max_write, max_readahead, congestion_threshold, max_background, 548 * time_gran. A field is only set (or unset) if the corresponding 549 * option has been explicitly set. 550 */ 551 void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts, 552 struct fuse_conn_info *conn); 553 554 /** 555 * Go into the background 556 * 557 * @param foreground if true, stay in the foreground 558 * @return 0 on success, -1 on failure 559 */ 560 int fuse_daemonize(int foreground); 561 562 /** 563 * Get the version of the library 564 * 565 * @return the version 566 */ 567 int fuse_version(void); 568 569 /** 570 * Get the full package version string of the library 571 * 572 * @return the package version 573 */ 574 const char *fuse_pkgversion(void); 575 576 /** 577 * Destroy poll handle 578 * 579 * @param ph the poll handle 580 */ 581 void fuse_pollhandle_destroy(struct fuse_pollhandle *ph); 582 583 /* ----------------------------------------------------------- * 584 * Data buffer * 585 * ----------------------------------------------------------- */ 586 587 /** 588 * Buffer flags 589 */ 590 enum fuse_buf_flags { 591 /** 592 * Buffer contains a file descriptor 593 * 594 * If this flag is set, the .fd field is valid, otherwise the 595 * .mem fields is valid. 596 */ 597 FUSE_BUF_IS_FD = (1 << 1), 598 599 /** 600 * Seek on the file descriptor 601 * 602 * If this flag is set then the .pos field is valid and is 603 * used to seek to the given offset before performing 604 * operation on file descriptor. 605 */ 606 FUSE_BUF_FD_SEEK = (1 << 2), 607 608 /** 609 * Retry operation on file descriptor 610 * 611 * If this flag is set then retry operation on file descriptor 612 * until .size bytes have been copied or an error or EOF is 613 * detected. 614 */ 615 FUSE_BUF_FD_RETRY = (1 << 3), 616 }; 617 618 /** 619 * Buffer copy flags 620 */ 621 enum fuse_buf_copy_flags { 622 /** 623 * Don't use splice(2) 624 * 625 * Always fall back to using read and write instead of 626 * splice(2) to copy data from one file descriptor to another. 627 * 628 * If this flag is not set, then only fall back if splice is 629 * unavailable. 630 */ 631 FUSE_BUF_NO_SPLICE = (1 << 1), 632 633 /** 634 * Force splice 635 * 636 * Always use splice(2) to copy data from one file descriptor 637 * to another. If splice is not available, return -EINVAL. 638 */ 639 FUSE_BUF_FORCE_SPLICE = (1 << 2), 640 641 /** 642 * Try to move data with splice. 643 * 644 * If splice is used, try to move pages from the source to the 645 * destination instead of copying. See documentation of 646 * SPLICE_F_MOVE in splice(2) man page. 647 */ 648 FUSE_BUF_SPLICE_MOVE = (1 << 3), 649 650 /** 651 * Don't block on the pipe when copying data with splice 652 * 653 * Makes the operations on the pipe non-blocking (if the pipe 654 * is full or empty). See SPLICE_F_NONBLOCK in the splice(2) 655 * man page. 656 */ 657 FUSE_BUF_SPLICE_NONBLOCK= (1 << 4), 658 }; 659 660 /** 661 * Single data buffer 662 * 663 * Generic data buffer for I/O, extended attributes, etc... Data may 664 * be supplied as a memory pointer or as a file descriptor 665 */ 666 struct fuse_buf { 667 /** 668 * Size of data in bytes 669 */ 670 size_t size; 671 672 /** 673 * Buffer flags 674 */ 675 enum fuse_buf_flags flags; 676 677 /** 678 * Memory pointer 679 * 680 * Used unless FUSE_BUF_IS_FD flag is set. 681 */ 682 void *mem; 683 684 /** 685 * File descriptor 686 * 687 * Used if FUSE_BUF_IS_FD flag is set. 688 */ 689 int fd; 690 691 /** 692 * File position 693 * 694 * Used if FUSE_BUF_FD_SEEK flag is set. 695 */ 696 off_t pos; 697 }; 698 699 /** 700 * Data buffer vector 701 * 702 * An array of data buffers, each containing a memory pointer or a 703 * file descriptor. 704 * 705 * Allocate dynamically to add more than one buffer. 706 */ 707 struct fuse_bufvec { 708 /** 709 * Number of buffers in the array 710 */ 711 size_t count; 712 713 /** 714 * Index of current buffer within the array 715 */ 716 size_t idx; 717 718 /** 719 * Current offset within the current buffer 720 */ 721 size_t off; 722 723 /** 724 * Array of buffers 725 */ 726 struct fuse_buf buf[1]; 727 }; 728 729 /* Initialize bufvec with a single buffer of given size */ 730 #define FUSE_BUFVEC_INIT(size__) \ 731 ((struct fuse_bufvec) { \ 732 /* .count= */ 1, \ 733 /* .idx = */ 0, \ 734 /* .off = */ 0, \ 735 /* .buf = */ { /* [0] = */ { \ 736 /* .size = */ (size__), \ 737 /* .flags = */ (enum fuse_buf_flags) 0, \ 738 /* .mem = */ NULL, \ 739 /* .fd = */ -1, \ 740 /* .pos = */ 0, \ 741 } } \ 742 } ) 743 744 /** 745 * Get total size of data in a fuse buffer vector 746 * 747 * @param bufv buffer vector 748 * @return size of data 749 */ 750 size_t fuse_buf_size(const struct fuse_bufvec *bufv); 751 752 /** 753 * Copy data from one buffer vector to another 754 * 755 * @param dst destination buffer vector 756 * @param src source buffer vector 757 * @param flags flags controlling the copy 758 * @return actual number of bytes copied or -errno on error 759 */ 760 ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src, 761 enum fuse_buf_copy_flags flags); 762 763 /* ----------------------------------------------------------- * 764 * Signal handling * 765 * ----------------------------------------------------------- */ 766 767 /** 768 * Exit session on HUP, TERM and INT signals and ignore PIPE signal 769 * 770 * Stores session in a global variable. May only be called once per 771 * process until fuse_remove_signal_handlers() is called. 772 * 773 * Once either of the POSIX signals arrives, the signal handler calls 774 * fuse_session_exit(). 775 * 776 * @param se the session to exit 777 * @return 0 on success, -1 on failure 778 * 779 * See also: 780 * fuse_remove_signal_handlers() 781 */ 782 int fuse_set_signal_handlers(struct fuse_session *se); 783 784 /** 785 * Restore default signal handlers 786 * 787 * Resets global session. After this fuse_set_signal_handlers() may 788 * be called again. 789 * 790 * @param se the same session as given in fuse_set_signal_handlers() 791 * 792 * See also: 793 * fuse_set_signal_handlers() 794 */ 795 void fuse_remove_signal_handlers(struct fuse_session *se); 796 797 /* ----------------------------------------------------------- * 798 * Compatibility stuff * 799 * ----------------------------------------------------------- */ 800 801 #if !defined(FUSE_USE_VERSION) || FUSE_USE_VERSION < 30 802 # error only API version 30 or greater is supported 803 #endif 804 805 #ifdef __cplusplus 806 } 807 #endif 808 809 810 /* 811 * This interface uses 64 bit off_t. 812 * 813 * On 32bit systems please add -D_FILE_OFFSET_BITS=64 to your compile flags! 814 */ 815 816 #if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus 817 _Static_assert(sizeof(off_t) == 8, "fuse: off_t must be 64bit"); 818 #else 819 struct _fuse_off_t_must_be_64bit_dummy_struct \ 820 { unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); }; 821 #endif 822 823 #endif /* FUSE_COMMON_H_ */ 824