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