qemu

fuse_lowlevel.h (66092B)

---

 /*
  * FUSE: Filesystem in Userspace
  * Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
  *
  * This program can be distributed under the terms of the GNU LGPLv2.
  * See the file COPYING.LIB.
  */
 
 #ifndef FUSE_LOWLEVEL_H_
 #define FUSE_LOWLEVEL_H_
 
 /**
  * @file
  *
  * Low level API
  *
  * IMPORTANT: you should define FUSE_USE_VERSION before including this
  * header.  To use the newest API define it to 31 (recommended for any
  * new application).
  */
 
 #ifndef FUSE_USE_VERSION
 #error FUSE_USE_VERSION not defined
 #endif
 
 #include "fuse_common.h"
 
 #include <sys/statvfs.h>
 #include <sys/uio.h>
 #include <utime.h>
 
 /*
  * Miscellaneous definitions
  */
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
 
 /** Inode number type */
 typedef uint64_t fuse_ino_t;
 
 /** Request pointer type */
 typedef struct fuse_req *fuse_req_t;
 
 /**
  * Session
  *
  * This provides hooks for processing requests, and exiting
  */
 struct fuse_session;
 
 /** Directory entry parameters supplied to fuse_reply_entry() */
 struct fuse_entry_param {
     /**
      * Unique inode number
      *
      * In lookup, zero means negative entry (from version 2.5)
      * Returning ENOENT also means negative entry, but by setting zero
      * ino the kernel may cache negative entries for entry_timeout
      * seconds.
      */
     fuse_ino_t ino;
 
     /**
      * Generation number for this entry.
      *
      * If the file system will be exported over NFS, the
      * ino/generation pairs need to be unique over the file
      * system's lifetime (rather than just the mount time). So if
      * the file system reuses an inode after it has been deleted,
      * it must assign a new, previously unused generation number
      * to the inode at the same time.
      *
      */
     uint64_t generation;
 
     /**
      * Inode attributes.
      *
      * Even if attr_timeout == 0, attr must be correct. For example,
      * for open(), FUSE uses attr.st_size from lookup() to determine
      * how many bytes to request. If this value is not correct,
      * incorrect data will be returned.
      */
     struct stat attr;
 
     /**
      * Validity timeout (in seconds) for inode attributes. If
      *  attributes only change as a result of requests that come
      *  through the kernel, this should be set to a very large
      *  value.
      */
     double attr_timeout;
 
     /**
      * Validity timeout (in seconds) for the name. If directory
      *  entries are changed/deleted only as a result of requests
      *  that come through the kernel, this should be set to a very
      *  large value.
      */
     double entry_timeout;
 
     /**
      * Flags for fuse_attr.flags that do not fit into attr.
      */
     uint32_t attr_flags;
 };
 
 /**
  * Additional context associated with requests.
  *
  * Note that the reported client uid, gid and pid may be zero in some
  * situations. For example, if the FUSE file system is running in a
  * PID or user namespace but then accessed from outside the namespace,
  * there is no valid uid/pid/gid that could be reported.
  */
 struct fuse_ctx {
     /** User ID of the calling process */
     uid_t uid;
 
     /** Group ID of the calling process */
     gid_t gid;
 
     /** Thread ID of the calling process */
     pid_t pid;
 
     /** Umask of the calling process */
     mode_t umask;
 };
 
 struct fuse_forget_data {
     fuse_ino_t ino;
     uint64_t nlookup;
 };
 
 /* 'to_set' flags in setattr */
 #define FUSE_SET_ATTR_MODE (1 << 0)
 #define FUSE_SET_ATTR_UID (1 << 1)
 #define FUSE_SET_ATTR_GID (1 << 2)
 #define FUSE_SET_ATTR_SIZE (1 << 3)
 #define FUSE_SET_ATTR_ATIME (1 << 4)
 #define FUSE_SET_ATTR_MTIME (1 << 5)
 #define FUSE_SET_ATTR_ATIME_NOW (1 << 7)
 #define FUSE_SET_ATTR_MTIME_NOW (1 << 8)
 #define FUSE_SET_ATTR_CTIME (1 << 10)
 #define FUSE_SET_ATTR_KILL_SUIDGID (1 << 11)
 
 /*
  * Request methods and replies
  */
 
 /**
  * Low level filesystem operations
  *
  * Most of the methods (with the exception of init and destroy)
  * receive a request handle (fuse_req_t) as their first argument.
  * This handle must be passed to one of the specified reply functions.
  *
  * This may be done inside the method invocation, or after the call
  * has returned.  The request handle is valid until one of the reply
  * functions is called.
  *
  * Other pointer arguments (name, fuse_file_info, etc) are not valid
  * after the call has returned, so if they are needed later, their
  * contents have to be copied.
  *
  * In general, all methods are expected to perform any necessary
  * permission checking. However, a filesystem may delegate this task
  * to the kernel by passing the `default_permissions` mount option to
  * `fuse_session_new()`. In this case, methods will only be called if
  * the kernel's permission check has succeeded.
  *
  * The filesystem sometimes needs to handle a return value of -ENOENT
  * from the reply function, which means, that the request was
  * interrupted, and the reply discarded.  For example if
  * fuse_reply_open() return -ENOENT means, that the release method for
  * this file will not be called.
  */
 struct fuse_lowlevel_ops {
     /**
      * Initialize filesystem
      *
      * This function is called when libfuse establishes
      * communication with the FUSE kernel module. The file system
      * should use this module to inspect and/or modify the
      * connection parameters provided in the `conn` structure.
      *
      * Note that some parameters may be overwritten by options
      * passed to fuse_session_new() which take precedence over the
      * values set in this handler.
      *
      * There's no reply to this function
      *
      * @param userdata the user data passed to fuse_session_new()
      */
     void (*init)(void *userdata, struct fuse_conn_info *conn);
 
     /**
      * Clean up filesystem.
      *
      * Called on filesystem exit. When this method is called, the
      * connection to the kernel may be gone already, so that eg. calls
      * to fuse_lowlevel_notify_* will fail.
      *
      * There's no reply to this function
      *
      * @param userdata the user data passed to fuse_session_new()
      */
     void (*destroy)(void *userdata);
 
     /**
      * Look up a directory entry by name and get its attributes.
      *
      * Valid replies:
      *   fuse_reply_entry
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name the name to look up
      */
     void (*lookup)(fuse_req_t req, fuse_ino_t parent, const char *name);
 
     /**
      * Forget about an inode
      *
      * This function is called when the kernel removes an inode
      * from its internal caches.
      *
      * The inode's lookup count increases by one for every call to
      * fuse_reply_entry and fuse_reply_create. The nlookup parameter
      * indicates by how much the lookup count should be decreased.
      *
      * Inodes with a non-zero lookup count may receive request from
      * the kernel even after calls to unlink, rmdir or (when
      * overwriting an existing file) rename. Filesystems must handle
      * such requests properly and it is recommended to defer removal
      * of the inode until the lookup count reaches zero. Calls to
      * unlink, rmdir or rename will be followed closely by forget
      * unless the file or directory is open, in which case the
      * kernel issues forget only after the release or releasedir
      * calls.
      *
      * Note that if a file system will be exported over NFS the
      * inodes lifetime must extend even beyond forget. See the
      * generation field in struct fuse_entry_param above.
      *
      * On unmount the lookup count for all inodes implicitly drops
      * to zero. It is not guaranteed that the file system will
      * receive corresponding forget messages for the affected
      * inodes.
      *
      * Valid replies:
      *   fuse_reply_none
      *
      * @param req request handle
      * @param ino the inode number
      * @param nlookup the number of lookups to forget
      */
     void (*forget)(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);
 
     /**
      * Get file attributes.
      *
      * If writeback caching is enabled, the kernel may have a
      * better idea of a file's length than the FUSE file system
      * (eg if there has been a write that extended the file size,
      * but that has not yet been passed to the filesystem.n
      *
      * In this case, the st_size value provided by the file system
      * will be ignored.
      *
      * Valid replies:
      *   fuse_reply_attr
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi for future use, currently always NULL
      */
     void (*getattr)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
 
     /**
      * Set file attributes
      *
      * In the 'attr' argument only members indicated by the 'to_set'
      * bitmask contain valid values.  Other members contain undefined
      * values.
      *
      * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
      * expected to reset the setuid and setgid bits if the file
      * size or owner is being changed.
      *
      * If the setattr was invoked from the ftruncate() system call
      * under Linux kernel versions 2.6.15 or later, the fi->fh will
      * contain the value set by the open method or will be undefined
      * if the open method didn't set any value.  Otherwise (not
      * ftruncate call, or kernel version earlier than 2.6.15) the fi
      * parameter will be NULL.
      *
      * Valid replies:
      *   fuse_reply_attr
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param attr the attributes
      * @param to_set bit mask of attributes which should be set
      * @param fi file information, or NULL
      */
     void (*setattr)(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
                     int to_set, struct fuse_file_info *fi);
 
     /**
      * Read symbolic link
      *
      * Valid replies:
      *   fuse_reply_readlink
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      */
     void (*readlink)(fuse_req_t req, fuse_ino_t ino);
 
     /**
      * Create file node
      *
      * Create a regular file, character device, block device, fifo or
      * socket node.
      *
      * Valid replies:
      *   fuse_reply_entry
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name to create
      * @param mode file type and mode with which to create the new file
      * @param rdev the device number (only valid if created file is a device)
      */
     void (*mknod)(fuse_req_t req, fuse_ino_t parent, const char *name,
                   mode_t mode, dev_t rdev);
 
     /**
      * Create a directory
      *
      * Valid replies:
      *   fuse_reply_entry
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name to create
      * @param mode with which to create the new file
      */
     void (*mkdir)(fuse_req_t req, fuse_ino_t parent, const char *name,
                   mode_t mode);
 
     /**
      * Remove a file
      *
      * If the file's inode's lookup count is non-zero, the file
      * system is expected to postpone any removal of the inode
      * until the lookup count reaches zero (see description of the
      * forget function).
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name to remove
      */
     void (*unlink)(fuse_req_t req, fuse_ino_t parent, const char *name);
 
     /**
      * Remove a directory
      *
      * If the directory's inode's lookup count is non-zero, the
      * file system is expected to postpone any removal of the
      * inode until the lookup count reaches zero (see description
      * of the forget function).
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name to remove
      */
     void (*rmdir)(fuse_req_t req, fuse_ino_t parent, const char *name);
 
     /**
      * Create a symbolic link
      *
      * Valid replies:
      *   fuse_reply_entry
      *   fuse_reply_err
      *
      * @param req request handle
      * @param link the contents of the symbolic link
      * @param parent inode number of the parent directory
      * @param name to create
      */
     void (*symlink)(fuse_req_t req, const char *link, fuse_ino_t parent,
                     const char *name);
 
     /**
      * Rename a file
      *
      * If the target exists it should be atomically replaced. If
      * the target's inode's lookup count is non-zero, the file
      * system is expected to postpone any removal of the inode
      * until the lookup count reaches zero (see description of the
      * forget function).
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EINVAL, i.e. all
      * future bmap requests will fail with EINVAL without being
      * send to the filesystem process.
      *
      * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
      * RENAME_NOREPLACE is specified, the filesystem must not
      * overwrite *newname* if it exists and return an error
      * instead. If `RENAME_EXCHANGE` is specified, the filesystem
      * must atomically exchange the two files, i.e. both must
      * exist and neither may be deleted.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the old parent directory
      * @param name old name
      * @param newparent inode number of the new parent directory
      * @param newname new name
      */
     void (*rename)(fuse_req_t req, fuse_ino_t parent, const char *name,
                    fuse_ino_t newparent, const char *newname,
                    unsigned int flags);
 
     /**
      * Create a hard link
      *
      * Valid replies:
      *   fuse_reply_entry
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the old inode number
      * @param newparent inode number of the new parent directory
      * @param newname new name to create
      */
     void (*link)(fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
                  const char *newname);
 
     /**
      * Open a file
      *
      * Open flags are available in fi->flags. The following rules
      * apply.
      *
      *  - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
      *    filtered out / handled by the kernel.
      *
      *  - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used
      *    by the filesystem to check if the operation is
      *    permitted.  If the ``-o default_permissions`` mount
      *    option is given, this check is already done by the
      *    kernel before calling open() and may thus be omitted by
      *    the filesystem.
      *
      *  - When writeback caching is enabled, the kernel may send
      *    read requests even for files opened with O_WRONLY. The
      *    filesystem should be prepared to handle this.
      *
      *  - When writeback caching is disabled, the filesystem is
      *    expected to properly handle the O_APPEND flag and ensure
      *    that each write is appending to the end of the file.
      *
      *  - When writeback caching is enabled, the kernel will
      *    handle O_APPEND. However, unless all changes to the file
      *    come through the kernel this will not work reliably. The
      *    filesystem should thus either ignore the O_APPEND flag
      *    (and let the kernel handle it), or return an error
      *    (indicating that reliably O_APPEND is not available).
      *
      * Filesystem may store an arbitrary file handle (pointer,
      * index, etc) in fi->fh, and use this in other all other file
      * operations (read, write, flush, release, fsync).
      *
      * Filesystem may also implement stateless file I/O and not store
      * anything in fi->fh.
      *
      * There are also some flags (direct_io, keep_cache) which the
      * filesystem may set in fi, to change the way the file is opened.
      * See fuse_file_info structure in <fuse_common.h> for more details.
      *
      * If this request is answered with an error code of ENOSYS
      * and FUSE_CAP_NO_OPEN_SUPPORT is set in
      * `fuse_conn_info.capable`, this is treated as success and
      * future calls to open and release will also succeed without being
      * sent to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_open
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      */
     void (*open)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
 
     /**
      * Read data
      *
      * Read should send exactly the number of bytes requested except
      * on EOF or error, otherwise the rest of the data will be
      * substituted with zeroes.  An exception to this is when the file
      * has been opened in 'direct_io' mode, in which case the return
      * value of the read system call will reflect the return value of
      * this operation.
      *
      * fi->fh will contain the value set by the open method, or will
      * be undefined if the open method didn't set any value.
      *
      * Valid replies:
      *   fuse_reply_buf
      *   fuse_reply_iov
      *   fuse_reply_data
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param size number of bytes to read
      * @param off offset to read from
      * @param fi file information
      */
     void (*read)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                  struct fuse_file_info *fi);
 
     /**
      * Write data
      *
      * Write should return exactly the number of bytes requested
      * except on error.  An exception to this is when the file has
      * been opened in 'direct_io' mode, in which case the return value
      * of the write system call will reflect the return value of this
      * operation.
      *
      * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
      * expected to reset the setuid and setgid bits.
      *
      * fi->fh will contain the value set by the open method, or will
      * be undefined if the open method didn't set any value.
      *
      * Valid replies:
      *   fuse_reply_write
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param buf data to write
      * @param size number of bytes to write
      * @param off offset to write to
      * @param fi file information
      */
     void (*write)(fuse_req_t req, fuse_ino_t ino, const char *buf, size_t size,
                   off_t off, struct fuse_file_info *fi);
 
     /**
      * Flush method
      *
      * This is called on each close() of the opened file.
      *
      * Since file descriptors can be duplicated (dup, dup2, fork), for
      * one open call there may be many flush calls.
      *
      * Filesystems shouldn't assume that flush will always be called
      * after some writes, or that if will be called at all.
      *
      * fi->fh will contain the value set by the open method, or will
      * be undefined if the open method didn't set any value.
      *
      * NOTE: the name of the method is misleading, since (unlike
      * fsync) the filesystem is not forced to flush pending writes.
      * One reason to flush data is if the filesystem wants to return
      * write errors during close.  However, such use is non-portable
      * because POSIX does not require [close] to wait for delayed I/O to
      * complete.
      *
      * If the filesystem supports file locking operations (setlk,
      * getlk) it should remove all locks belonging to 'fi->owner'.
      *
      * If this request is answered with an error code of ENOSYS,
      * this is treated as success and future calls to flush() will
      * succeed automatically without being send to the filesystem
      * process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      *
      * [close]:
      * http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
      */
     void (*flush)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
 
     /**
      * Release an open file
      *
      * Release is called when there are no more references to an open
      * file: all file descriptors are closed and all memory mappings
      * are unmapped.
      *
      * For every open call there will be exactly one release call (unless
      * the filesystem is force-unmounted).
      *
      * The filesystem may reply with an error, but error values are
      * not returned to close() or munmap() which triggered the
      * release.
      *
      * fi->fh will contain the value set by the open method, or will
      * be undefined if the open method didn't set any value.
      * fi->flags will contain the same flags as for open.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      */
     void (*release)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
 
     /**
      * Synchronize file contents
      *
      * If the datasync parameter is non-zero, then only the user data
      * should be flushed, not the meta data.
      *
      * If this request is answered with an error code of ENOSYS,
      * this is treated as success and future calls to fsync() will
      * succeed automatically without being send to the filesystem
      * process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param datasync flag indicating if only data should be flushed
      * @param fi file information
      */
     void (*fsync)(fuse_req_t req, fuse_ino_t ino, int datasync,
                   struct fuse_file_info *fi);
 
     /**
      * Open a directory
      *
      * Filesystem may store an arbitrary file handle (pointer, index,
      * etc) in fi->fh, and use this in other all other directory
      * stream operations (readdir, releasedir, fsyncdir).
      *
      * If this request is answered with an error code of ENOSYS and
      * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`,
      * this is treated as success and future calls to opendir and
      * releasedir will also succeed without being sent to the filesystem
      * process. In addition, the kernel will cache readdir results
      * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR.
      *
      * Valid replies:
      *   fuse_reply_open
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      */
     void (*opendir)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
 
     /**
      * Read directory
      *
      * Send a buffer filled using fuse_add_direntry(), with size not
      * exceeding the requested size.  Send an empty buffer on end of
      * stream.
      *
      * fi->fh will contain the value set by the opendir method, or
      * will be undefined if the opendir method didn't set any value.
      *
      * Returning a directory entry from readdir() does not affect
      * its lookup count.
      *
      * If off_t is non-zero, then it will correspond to one of the off_t
      * values that was previously returned by readdir() for the same
      * directory handle. In this case, readdir() should skip over entries
      * coming before the position defined by the off_t value. If entries
      * are added or removed while the directory handle is open, they filesystem
      * may still include the entries that have been removed, and may not
      * report the entries that have been created. However, addition or
      * removal of entries must never cause readdir() to skip over unrelated
      * entries or to report them more than once. This means
      * that off_t can not be a simple index that enumerates the entries
      * that have been returned but must contain sufficient information to
      * uniquely determine the next directory entry to return even when the
      * set of entries is changing.
      *
      * The function does not have to report the '.' and '..'
      * entries, but is allowed to do so. Note that, if readdir does
      * not return '.' or '..', they will not be implicitly returned,
      * and this behavior is observable by the caller.
      *
      * Valid replies:
      *   fuse_reply_buf
      *   fuse_reply_data
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param size maximum number of bytes to send
      * @param off offset to continue reading the directory stream
      * @param fi file information
      */
     void (*readdir)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                     struct fuse_file_info *fi);
 
     /**
      * Release an open directory
      *
      * For every opendir call there will be exactly one releasedir
      * call (unless the filesystem is force-unmounted).
      *
      * fi->fh will contain the value set by the opendir method, or
      * will be undefined if the opendir method didn't set any value.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      */
     void (*releasedir)(fuse_req_t req, fuse_ino_t ino,
                        struct fuse_file_info *fi);
 
     /**
      * Synchronize directory contents
      *
      * If the datasync parameter is non-zero, then only the directory
      * contents should be flushed, not the meta data.
      *
      * fi->fh will contain the value set by the opendir method, or
      * will be undefined if the opendir method didn't set any value.
      *
      * If this request is answered with an error code of ENOSYS,
      * this is treated as success and future calls to fsyncdir() will
      * succeed automatically without being send to the filesystem
      * process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param datasync flag indicating if only data should be flushed
      * @param fi file information
      */
     void (*fsyncdir)(fuse_req_t req, fuse_ino_t ino, int datasync,
                      struct fuse_file_info *fi);
 
     /**
      * Get file system statistics
      *
      * Valid replies:
      *   fuse_reply_statfs
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number, zero means "undefined"
      */
     void (*statfs)(fuse_req_t req, fuse_ino_t ino);
 
     /**
      * Set an extended attribute
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future setxattr() requests will fail with EOPNOTSUPP without being
      * send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_err
      */
     void (*setxattr)(fuse_req_t req, fuse_ino_t ino, const char *name,
                      const char *value, size_t size, int flags,
                      uint32_t setxattr_flags);
 
     /**
      * Get an extended attribute
      *
      * If size is zero, the size of the value should be sent with
      * fuse_reply_xattr.
      *
      * If the size is non-zero, and the value fits in the buffer, the
      * value should be sent with fuse_reply_buf.
      *
      * If the size is too small for the value, the ERANGE error should
      * be sent.
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future getxattr() requests will fail with EOPNOTSUPP without being
      * send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_buf
      *   fuse_reply_data
      *   fuse_reply_xattr
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param name of the extended attribute
      * @param size maximum size of the value to send
      */
     void (*getxattr)(fuse_req_t req, fuse_ino_t ino, const char *name,
                      size_t size);
 
     /**
      * List extended attribute names
      *
      * If size is zero, the total size of the attribute list should be
      * sent with fuse_reply_xattr.
      *
      * If the size is non-zero, and the null character separated
      * attribute list fits in the buffer, the list should be sent with
      * fuse_reply_buf.
      *
      * If the size is too small for the list, the ERANGE error should
      * be sent.
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future listxattr() requests will fail with EOPNOTSUPP without being
      * send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_buf
      *   fuse_reply_data
      *   fuse_reply_xattr
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param size maximum size of the list to send
      */
     void (*listxattr)(fuse_req_t req, fuse_ino_t ino, size_t size);
 
     /**
      * Remove an extended attribute
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future removexattr() requests will fail with EOPNOTSUPP without being
      * send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param name of the extended attribute
      */
     void (*removexattr)(fuse_req_t req, fuse_ino_t ino, const char *name);
 
     /**
      * Check file access permissions
      *
      * This will be called for the access() and chdir() system
      * calls.  If the 'default_permissions' mount option is given,
      * this method is not called.
      *
      * This method is not called under Linux kernel versions 2.4.x
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent success, i.e. this and all future access()
      * requests will succeed without being send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param mask requested access mode
      */
     void (*access)(fuse_req_t req, fuse_ino_t ino, int mask);
 
     /**
      * Create and open a file
      *
      * If the file does not exist, first create it with the specified
      * mode, and then open it.
      *
      * See the description of the open handler for more
      * information.
      *
      * If this method is not implemented or under Linux kernel
      * versions earlier than 2.6.15, the mknod() and open() methods
      * will be called instead.
      *
      * If this request is answered with an error code of ENOSYS, the handler
      * is treated as not implemented (i.e., for this and future requests the
      * mknod() and open() handlers will be called instead).
      *
      * Valid replies:
      *   fuse_reply_create
      *   fuse_reply_err
      *
      * @param req request handle
      * @param parent inode number of the parent directory
      * @param name to create
      * @param mode file type and mode with which to create the new file
      * @param fi file information
      */
     void (*create)(fuse_req_t req, fuse_ino_t parent, const char *name,
                    mode_t mode, struct fuse_file_info *fi);
 
     /**
      * Test for a POSIX file lock
      *
      * Valid replies:
      *   fuse_reply_lock
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      * @param lock the region/type to test
      */
     void (*getlk)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
                   struct flock *lock);
 
     /**
      * Acquire, modify or release a POSIX file lock
      *
      * For POSIX threads (NPTL) there's a 1-1 relation between pid and
      * owner, but otherwise this is not always the case.  For checking
      * lock ownership, 'fi->owner' must be used.  The l_pid field in
      * 'struct flock' should only be used to fill in this field in
      * getlk().
      *
      * Note: if the locking methods are not implemented, the kernel
      * will still allow file locking to work locally.  Hence these are
      * only interesting for network filesystems and similar.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      * @param lock the region/type to set
      * @param sleep locking operation may sleep
      */
     void (*setlk)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
                   struct flock *lock, int sleep);
 
     /**
      * Map block index within file to block index within device
      *
      * Note: This makes sense only for block device backed filesystems
      * mounted with the 'blkdev' option
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure, i.e. all future bmap() requests will
      * fail with the same error code without being send to the filesystem
      * process.
      *
      * Valid replies:
      *   fuse_reply_bmap
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param blocksize unit of block index
      * @param idx block index within file
      */
     void (*bmap)(fuse_req_t req, fuse_ino_t ino, size_t blocksize,
                  uint64_t idx);
 
     /**
      * Ioctl
      *
      * Note: For unrestricted ioctls (not allowed for FUSE
      * servers), data in and out areas can be discovered by giving
      * iovs and setting FUSE_IOCTL_RETRY in *flags*.  For
      * restricted ioctls, kernel prepares in/out data area
      * according to the information encoded in cmd.
      *
      * Valid replies:
      *   fuse_reply_ioctl_retry
      *   fuse_reply_ioctl
      *   fuse_reply_ioctl_iov
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param cmd ioctl command
      * @param arg ioctl argument
      * @param fi file information
      * @param flags for FUSE_IOCTL_* flags
      * @param in_buf data fetched from the caller
      * @param in_bufsz number of fetched bytes
      * @param out_bufsz maximum size of output data
      *
      * Note : the unsigned long request submitted by the application
      * is truncated to 32 bits.
      */
     void (*ioctl)(fuse_req_t req, fuse_ino_t ino, unsigned int cmd, void *arg,
                   struct fuse_file_info *fi, unsigned flags, const void *in_buf,
                   size_t in_bufsz, size_t out_bufsz);
 
     /**
      * Poll for IO readiness
      *
      * Note: If ph is non-NULL, the client should notify
      * when IO readiness events occur by calling
      * fuse_lowlevel_notify_poll() with the specified ph.
      *
      * Regardless of the number of times poll with a non-NULL ph
      * is received, single notification is enough to clear all.
      * Notifying more times incurs overhead but doesn't harm
      * correctness.
      *
      * The callee is responsible for destroying ph with
      * fuse_pollhandle_destroy() when no longer in use.
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as success (with a kernel-defined default poll-mask) and
      * future calls to pull() will succeed the same way without being send
      * to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_poll
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      * @param ph poll handle to be used for notification
      */
     void (*poll)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
                  struct fuse_pollhandle *ph);
 
     /**
      * Write data made available in a buffer
      *
      * This is a more generic version of the ->write() method.  If
      * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the
      * kernel supports splicing from the fuse device, then the
      * data will be made available in pipe for supporting zero
      * copy data transfer.
      *
      * buf->count is guaranteed to be one (and thus buf->idx is
      * always zero). The write_buf handler must ensure that
      * bufv->off is correctly updated (reflecting the number of
      * bytes read from bufv->buf[0]).
      *
      * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
      * expected to reset the setuid and setgid bits.
      *
      * Valid replies:
      *   fuse_reply_write
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param bufv buffer containing the data
      * @param off offset to write to
      * @param fi file information
      */
     void (*write_buf)(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv,
                       off_t off, struct fuse_file_info *fi);
 
     /**
      * Forget about multiple inodes
      *
      * See description of the forget function for more
      * information.
      *
      * Valid replies:
      *   fuse_reply_none
      *
      * @param req request handle
      */
     void (*forget_multi)(fuse_req_t req, size_t count,
                          struct fuse_forget_data *forgets);
 
     /**
      * Acquire, modify or release a BSD file lock
      *
      * Note: if the locking methods are not implemented, the kernel
      * will still allow file locking to work locally.  Hence these are
      * only interesting for network filesystems and similar.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param fi file information
      * @param op the locking operation, see flock(2)
      */
     void (*flock)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
                   int op);
 
     /**
      * Allocate requested space. If this function returns success then
      * subsequent writes to the specified range shall not fail due to the lack
      * of free space on the file system storage media.
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future fallocate() requests will fail with EOPNOTSUPP without being
      * send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param offset starting point for allocated region
      * @param length size of allocated region
      * @param mode determines the operation to be performed on the given range,
      *             see fallocate(2)
      */
     void (*fallocate)(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
                       off_t length, struct fuse_file_info *fi);
 
     /**
      * Read directory with attributes
      *
      * Send a buffer filled using fuse_add_direntry_plus(), with size not
      * exceeding the requested size.  Send an empty buffer on end of
      * stream.
      *
      * fi->fh will contain the value set by the opendir method, or
      * will be undefined if the opendir method didn't set any value.
      *
      * In contrast to readdir() (which does not affect the lookup counts),
      * the lookup count of every entry returned by readdirplus(), except "."
      * and "..", is incremented by one.
      *
      * Valid replies:
      *   fuse_reply_buf
      *   fuse_reply_data
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param size maximum number of bytes to send
      * @param off offset to continue reading the directory stream
      * @param fi file information
      */
     void (*readdirplus)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                         struct fuse_file_info *fi);
 
     /**
      * Copy a range of data from one file to another
      *
      * Performs an optimized copy between two file descriptors without the
      * additional cost of transferring data through the FUSE kernel module
      * to user space (glibc) and then back into the FUSE filesystem again.
      *
      * In case this method is not implemented, glibc falls back to reading
      * data from the source and writing to the destination. Effectively
      * doing an inefficient copy of the data.
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
      * future copy_file_range() requests will fail with EOPNOTSUPP without
      * being send to the filesystem process.
      *
      * Valid replies:
      *   fuse_reply_write
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino_in the inode number or the source file
      * @param off_in starting point from were the data should be read
      * @param fi_in file information of the source file
      * @param ino_out the inode number or the destination file
      * @param off_out starting point where the data should be written
      * @param fi_out file information of the destination file
      * @param len maximum size of the data to copy
      * @param flags passed along with the copy_file_range() syscall
      */
     void (*copy_file_range)(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
                             struct fuse_file_info *fi_in, fuse_ino_t ino_out,
                             off_t off_out, struct fuse_file_info *fi_out,
                             size_t len, int flags);
 
     /**
      * Find next data or hole after the specified offset
      *
      * If this request is answered with an error code of ENOSYS, this is
      * treated as a permanent failure, i.e. all future lseek() requests will
      * fail with the same error code without being send to the filesystem
      * process.
      *
      * Valid replies:
      *   fuse_reply_lseek
      *   fuse_reply_err
      *
      * @param req request handle
      * @param ino the inode number
      * @param off offset to start search from
      * @param whence either SEEK_DATA or SEEK_HOLE
      * @param fi file information
      */
     void (*lseek)(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
                   struct fuse_file_info *fi);
 
     /**
      * Synchronize file system content
      *
      * If this request is answered with an error code of ENOSYS,
      * this is treated as success and future calls to syncfs() will
      * succeed automatically without being sent to the filesystem
      * process.
      *
      * @param req request handle
      * @param ino the inode number
      */
     void (*syncfs)(fuse_req_t req, fuse_ino_t ino);
 };
 
 /**
  * Reply with an error code or success.
  *
  * Possible requests:
  *   all except forget
  *
  * Whereever possible, error codes should be chosen from the list of
  * documented error conditions in the corresponding system calls
  * manpage.
  *
  * An error code of ENOSYS is sometimes treated specially. This is
  * indicated in the documentation of the affected handler functions.
  *
  * The following requests may be answered with a zero error code:
  * unlink, rmdir, rename, flush, release, fsync, fsyncdir, setxattr,
  * removexattr, setlk.
  *
  * @param req request handle
  * @param err the positive error value, or zero for success
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_err(fuse_req_t req, int err);
 
 /**
  * Don't send reply
  *
  * Possible requests:
  *   forget
  *   forget_multi
  *   retrieve_reply
  *
  * @param req request handle
  */
 void fuse_reply_none(fuse_req_t req);
 
 /**
  * Reply with a directory entry
  *
  * Possible requests:
  *   lookup, mknod, mkdir, symlink, link
  *
  * Side effects:
  *   increments the lookup count on success
  *
  * @param req request handle
  * @param e the entry parameters
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
 
 /**
  * Reply with a directory entry and open parameters
  *
  * currently the following members of 'fi' are used:
  *   fh, direct_io, keep_cache
  *
  * Possible requests:
  *   create
  *
  * Side effects:
  *   increments the lookup count on success
  *
  * @param req request handle
  * @param e the entry parameters
  * @param fi file information
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
                       const struct fuse_file_info *fi);
 
 /**
  * Reply with attributes
  *
  * Possible requests:
  *   getattr, setattr
  *
  * @param req request handle
  * @param attr the attributes
  * @param attr_timeout validity timeout (in seconds) for the attributes
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
                     double attr_timeout);
 
 /**
  * Reply with the contents of a symbolic link
  *
  * Possible requests:
  *   readlink
  *
  * @param req request handle
  * @param link symbolic link contents
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_readlink(fuse_req_t req, const char *link);
 
 /**
  * Reply with open parameters
  *
  * currently the following members of 'fi' are used:
  *   fh, direct_io, keep_cache
  *
  * Possible requests:
  *   open, opendir
  *
  * @param req request handle
  * @param fi file information
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi);
 
 /**
  * Reply with number of bytes written
  *
  * Possible requests:
  *   write
  *
  * @param req request handle
  * @param count the number of bytes written
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_write(fuse_req_t req, size_t count);
 
 /**
  * Reply with data
  *
  * Possible requests:
  *   read, readdir, getxattr, listxattr
  *
  * @param req request handle
  * @param buf buffer containing data
  * @param size the size of data in bytes
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
 
 /**
  * Reply with data copied/moved from buffer(s)
  *
  * Possible requests:
  *   read, readdir, getxattr, listxattr
  *
  * Side effects:
  *   when used to return data from a readdirplus() (but not readdir())
  *   call, increments the lookup count of each returned entry by one
  *   on success.
  *
  * @param req request handle
  * @param bufv buffer vector
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv);
 
 /**
  * Reply with data vector
  *
  * Possible requests:
  *   read, readdir, getxattr, listxattr
  *
  * @param req request handle
  * @param iov the vector containing the data
  * @param count the size of vector
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count);
 
 /**
  * Reply with filesystem statistics
  *
  * Possible requests:
  *   statfs
  *
  * @param req request handle
  * @param stbuf filesystem statistics
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf);
 
 /**
  * Reply with needed buffer size
  *
  * Possible requests:
  *   getxattr, listxattr
  *
  * @param req request handle
  * @param count the buffer size needed in bytes
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_xattr(fuse_req_t req, size_t count);
 
 /**
  * Reply with file lock information
  *
  * Possible requests:
  *   getlk
  *
  * @param req request handle
  * @param lock the lock information
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
 
 /**
  * Reply with block index
  *
  * Possible requests:
  *   bmap
  *
  * @param req request handle
  * @param idx block index within device
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
 
 /*
  * Filling a buffer in readdir
  */
 
 /**
  * Add a directory entry to the buffer
  *
  * Buffer needs to be large enough to hold the entry.  If it's not,
  * then the entry is not filled in but the size of the entry is still
  * returned.  The caller can check this by comparing the bufsize
  * parameter with the returned entry size.  If the entry size is
  * larger than the buffer size, the operation failed.
  *
  * From the 'stbuf' argument the st_ino field and bits 12-15 of the
  * st_mode field are used.  The other fields are ignored.
  *
  * *off* should be any non-zero value that the filesystem can use to
  * identify the current point in the directory stream. It does not
  * need to be the actual physical position. A value of zero is
  * reserved to mean "from the beginning", and should therefore never
  * be used (the first call to fuse_add_direntry should be passed the
  * offset of the second directory entry).
  *
  * @param req request handle
  * @param buf the point where the new entry will be added to the buffer
  * @param bufsize remaining size of the buffer
  * @param name the name of the entry
  * @param stbuf the file attributes
  * @param off the offset of the next entry
  * @return the space needed for the entry
  */
 size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
                          const char *name, const struct stat *stbuf, off_t off);
 
 /**
  * Add a directory entry to the buffer with the attributes
  *
  * See documentation of `fuse_add_direntry()` for more details.
  *
  * @param req request handle
  * @param buf the point where the new entry will be added to the buffer
  * @param bufsize remaining size of the buffer
  * @param name the name of the entry
  * @param e the directory entry
  * @param off the offset of the next entry
  * @return the space needed for the entry
  */
 size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,
                               const char *name,
                               const struct fuse_entry_param *e, off_t off);
 
 /**
  * Reply to ask for data fetch and output buffer preparation.  ioctl
  * will be retried with the specified input data fetched and output
  * buffer prepared.
  *
  * Possible requests:
  *   ioctl
  *
  * @param req request handle
  * @param in_iov iovec specifying data to fetch from the caller
  * @param in_count number of entries in in_iov
  * @param out_iov iovec specifying addresses to write output to
  * @param out_count number of entries in out_iov
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov,
                            size_t in_count, const struct iovec *out_iov,
                            size_t out_count);
 
 /**
  * Reply to finish ioctl
  *
  * Possible requests:
  *   ioctl
  *
  * @param req request handle
  * @param result result to be passed to the caller
  * @param buf buffer containing output data
  * @param size length of output data
  */
 int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size);
 
 /**
  * Reply to finish ioctl with iov buffer
  *
  * Possible requests:
  *   ioctl
  *
  * @param req request handle
  * @param result result to be passed to the caller
  * @param iov the vector containing the data
  * @param count the size of vector
  */
 int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
                          int count);
 
 /**
  * Reply with poll result event mask
  *
  * @param req request handle
  * @param revents poll result event mask
  */
 int fuse_reply_poll(fuse_req_t req, unsigned revents);
 
 /**
  * Reply with offset
  *
  * Possible requests:
  *   lseek
  *
  * @param req request handle
  * @param off offset of next data or hole
  * @return zero for success, -errno for failure to send reply
  */
 int fuse_reply_lseek(fuse_req_t req, off_t off);
 
 /*
  * Notification
  */
 
 /**
  * Notify IO readiness event
  *
  * For more information, please read comment for poll operation.
  *
  * @param ph poll handle to notify IO readiness event for
  */
 int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
 
 /**
  * Notify to invalidate cache for an inode.
  *
  * Added in FUSE protocol version 7.12. If the kernel does not support
  * this (or a newer) version, the function will return -ENOSYS and do
  * nothing.
  *
  * If the filesystem has writeback caching enabled, invalidating an
  * inode will first trigger a writeback of all dirty pages. The call
  * will block until all writeback requests have completed and the
  * inode has been invalidated. It will, however, not wait for
  * completion of pending writeback requests that have been issued
  * before.
  *
  * If there are no dirty pages, this function will never block.
  *
  * @param se the session object
  * @param ino the inode number
  * @param off the offset in the inode where to start invalidating
  *            or negative to invalidate attributes only
  * @param len the amount of cache to invalidate or 0 for all
  * @return zero for success, -errno for failure
  */
 int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
                                      off_t off, off_t len);
 
 /**
  * Notify to invalidate parent attributes and the dentry matching
  * parent/name
  *
  * To avoid a deadlock this function must not be called in the
  * execution path of a related filesystem operation or within any code
  * that could hold a lock that could be needed to execute such an
  * operation. As of kernel 4.18, a "related operation" is a lookup(),
  * symlink(), mknod(), mkdir(), unlink(), rename(), link() or create()
  * request for the parent, and a setattr(), unlink(), rmdir(),
  * rename(), setxattr(), removexattr(), readdir() or readdirplus()
  * request for the inode itself.
  *
  * When called correctly, this function will never block.
  *
  * Added in FUSE protocol version 7.12. If the kernel does not support
  * this (or a newer) version, the function will return -ENOSYS and do
  * nothing.
  *
  * @param se the session object
  * @param parent inode number
  * @param name file name
  * @param namelen strlen() of file name
  * @return zero for success, -errno for failure
  */
 int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
                                      const char *name, size_t namelen);
 
 /**
  * This function behaves like fuse_lowlevel_notify_inval_entry() with
  * the following additional effect (at least as of Linux kernel 4.8):
  *
  * If the provided *child* inode matches the inode that is currently
  * associated with the cached dentry, and if there are any inotify
  * watches registered for the dentry, then the watchers are informed
  * that the dentry has been deleted.
  *
  * To avoid a deadlock this function must not be called while
  * executing a related filesystem operation or while holding a lock
  * that could be needed to execute such an operation (see the
  * description of fuse_lowlevel_notify_inval_entry() for more
  * details).
  *
  * When called correctly, this function will never block.
  *
  * Added in FUSE protocol version 7.18. If the kernel does not support
  * this (or a newer) version, the function will return -ENOSYS and do
  * nothing.
  *
  * @param se the session object
  * @param parent inode number
  * @param child inode number
  * @param name file name
  * @param namelen strlen() of file name
  * @return zero for success, -errno for failure
  */
 int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
                                 fuse_ino_t child, const char *name,
                                 size_t namelen);
 
 /**
  * Store data to the kernel buffers
  *
  * Synchronously store data in the kernel buffers belonging to the
  * given inode.  The stored data is marked up-to-date (no read will be
  * performed against it, unless it's invalidated or evicted from the
  * cache).
  *
  * If the stored data overflows the current file size, then the size
  * is extended, similarly to a write(2) on the filesystem.
  *
  * If this function returns an error, then the store wasn't fully
  * completed, but it may have been partially completed.
  *
  * Added in FUSE protocol version 7.15. If the kernel does not support
  * this (or a newer) version, the function will return -ENOSYS and do
  * nothing.
  *
  * @param se the session object
  * @param ino the inode number
  * @param offset the starting offset into the file to store to
  * @param bufv buffer vector
  * @return zero for success, -errno for failure
  */
 int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
                                off_t offset, struct fuse_bufvec *bufv);
 
 /*
  * Utility functions
  */
 
 /**
  * Get the userdata from the request
  *
  * @param req request handle
  * @return the user data passed to fuse_session_new()
  */
 void *fuse_req_userdata(fuse_req_t req);
 
 /**
  * Get the context from the request
  *
  * The pointer returned by this function will only be valid for the
  * request's lifetime
  *
  * @param req request handle
  * @return the context structure
  */
 const struct fuse_ctx *fuse_req_ctx(fuse_req_t req);
 
 /**
  * Callback function for an interrupt
  *
  * @param req interrupted request
  * @param data user data
  */
 typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
 
 /**
  * Register/unregister callback for an interrupt
  *
  * If an interrupt has already happened, then the callback function is
  * called from within this function, hence it's not possible for
  * interrupts to be lost.
  *
  * @param req request handle
  * @param func the callback function or NULL for unregister
  * @param data user data passed to the callback function
  */
 void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
                              void *data);
 
 /**
  * Check if a request has already been interrupted
  *
  * @param req request handle
  * @return 1 if the request has been interrupted, 0 otherwise
  */
 int fuse_req_interrupted(fuse_req_t req);
 
 /**
  * Check if the session is connected via virtio
  *
  * @param se session object
  * @return 1 if the session is a virtio session
  */
 int fuse_lowlevel_is_virtio(struct fuse_session *se);
 
 /*
  * Inquiry functions
  */
 
 /**
  * Print low-level version information to stdout.
  */
 void fuse_lowlevel_version(void);
 
 /**
  * Print available low-level options to stdout. This is not an
  * exhaustive list, but includes only those options that may be of
  * interest to an end-user of a file system.
  */
 void fuse_lowlevel_help(void);
 
 /**
  * Print available options for `fuse_parse_cmdline()`.
  */
 void fuse_cmdline_help(void);
 
 /*
  * Filesystem setup & teardown
  */
 
 struct fuse_cmdline_opts {
     int foreground;
     int debug;
     int nodefault_subtype;
     int show_version;
     int show_help;
     int print_capabilities;
     int syslog;
     int log_level;
     unsigned int max_idle_threads;
     unsigned long rlimit_nofile;
 };
 
 /**
  * Utility function to parse common options for simple file systems
  * using the low-level API. A help text that describes the available
  * options can be printed with `fuse_cmdline_help`. A single
  * non-option argument is treated as the mountpoint. Multiple
  * non-option arguments will result in an error.
  *
  * If neither -o subtype= or -o fsname= options are given, a new
  * subtype option will be added and set to the basename of the program
  * (the fsname will remain unset, and then defaults to "fuse").
  *
  * Known options will be removed from *args*, unknown options will
  * remain.
  *
  * @param args argument vector (input+output)
  * @param opts output argument for parsed options
  * @return 0 on success, -1 on failure
  */
 int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts);
 
 /**
  * Create a low level session.
  *
  * Returns a session structure suitable for passing to
  * fuse_session_mount() and fuse_session_loop().
  *
  * This function accepts most file-system independent mount options
  * (like context, nodev, ro - see mount(8)), as well as the general
  * fuse mount options listed in mount.fuse(8) (e.g. -o allow_root and
  * -o default_permissions, but not ``-o use_ino``).  Instead of `-o
  * debug`, debugging may also enabled with `-d` or `--debug`.
  *
  * If not all options are known, an error message is written to stderr
  * and the function returns NULL.
  *
  * Option parsing skips argv[0], which is assumed to contain the
  * program name. To prevent accidentally passing an option in
  * argv[0], this element must always be present (even if no options
  * are specified). It may be set to the empty string ('\0') if no
  * reasonable value can be provided.
  *
  * @param args argument vector
  * @param op the (low-level) filesystem operations
  * @param op_size sizeof(struct fuse_lowlevel_ops)
  * @param userdata user data
  *
  * @return the fuse session on success, NULL on failure
  **/
 struct fuse_session *fuse_session_new(struct fuse_args *args,
                                       const struct fuse_lowlevel_ops *op,
                                       size_t op_size, void *userdata);
 
 /**
  * Mount a FUSE file system.
  *
  * @param se session object
  *
  * @return 0 on success, -1 on failure.
  **/
 int fuse_session_mount(struct fuse_session *se);
 
 /**
  * Enter a single threaded, blocking event loop.
  *
  * When the event loop terminates because the connection to the FUSE
  * kernel module has been closed, this function returns zero. This
  * happens when the filesystem is unmounted regularly (by the
  * filesystem owner or root running the umount(8) or fusermount(1)
  * command), or if connection is explicitly severed by writing ``1``
  * to the``abort`` file in ``/sys/fs/fuse/connections/NNN``. The only
  * way to distinguish between these two conditions is to check if the
  * filesystem is still mounted after the session loop returns.
  *
  * When some error occurs during request processing, the function
  * returns a negated errno(3) value.
  *
  * If the loop has been terminated because of a signal handler
  * installed by fuse_set_signal_handlers(), this function returns the
  * (positive) signal value that triggered the exit.
  *
  * @param se the session
  * @return 0, -errno, or a signal value
  */
 int fuse_session_loop(struct fuse_session *se);
 
 /**
  * Flag a session as terminated.
  *
  * This function is invoked by the POSIX signal handlers, when
  * registered using fuse_set_signal_handlers(). It will cause any
  * running event loops to terminate on the next opportunity.
  *
  * @param se the session
  */
 void fuse_session_exit(struct fuse_session *se);
 
 /**
  * Reset the terminated flag of a session
  *
  * @param se the session
  */
 void fuse_session_reset(struct fuse_session *se);
 
 /**
  * Query the terminated flag of a session
  *
  * @param se the session
  * @return 1 if exited, 0 if not exited
  */
 int fuse_session_exited(struct fuse_session *se);
 
 /**
  * Ensure that file system is unmounted.
  *
  * In regular operation, the file system is typically unmounted by the
  * user calling umount(8) or fusermount(1), which then terminates the
  * FUSE session loop. However, the session loop may also terminate as
  * a result of an explicit call to fuse_session_exit() (e.g. by a
  * signal handler installed by fuse_set_signal_handler()). In this
  * case the filesystem remains mounted, but any attempt to access it
  * will block (while the filesystem process is still running) or give
  * an ESHUTDOWN error (after the filesystem process has terminated).
  *
  * If the communication channel with the FUSE kernel module is still
  * open (i.e., if the session loop was terminated by an explicit call
  * to fuse_session_exit()), this function will close it and unmount
  * the filesystem. If the communication channel has been closed by the
  * kernel, this method will do (almost) nothing.
  *
  * NOTE: The above semantics mean that if the connection to the kernel
  * is terminated via the ``/sys/fs/fuse/connections/NNN/abort`` file,
  * this method will *not* unmount the filesystem.
  *
  * @param se the session
  */
 void fuse_session_unmount(struct fuse_session *se);
 
 /**
  * Destroy a session
  *
  * @param se the session
  */
 void fuse_session_destroy(struct fuse_session *se);
 
 /*
  * Custom event loop support
  */
 
 /**
  * Return file descriptor for communication with kernel.
  *
  * The file selector can be used to integrate FUSE with a custom event
  * loop. Whenever data is available for reading on the provided fd,
  * the event loop should call `fuse_session_receive_buf` followed by
  * `fuse_session_process_buf` to process the request.
  *
  * The returned file descriptor is valid until `fuse_session_unmount`
  * is called.
  *
  * @param se the session
  * @return a file descriptor
  */
 int fuse_session_fd(struct fuse_session *se);
 
 /**
  * Process a raw request supplied in a generic buffer
  *
  * The fuse_buf may contain a memory buffer or a pipe file descriptor.
  *
  * @param se the session
  * @param buf the fuse_buf containing the request
  */
 void fuse_session_process_buf(struct fuse_session *se,
                               const struct fuse_buf *buf);
 
 /**
  * Read a raw request from the kernel into the supplied buffer.
  *
  * Depending on file system options, system capabilities, and request
  * size the request is either read into a memory buffer or spliced
  * into a temporary pipe.
  *
  * @param se the session
  * @param buf the fuse_buf to store the request in
  * @return the actual size of the raw request, or -errno on error
  */
 int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf);
 
 #endif /* FUSE_LOWLEVEL_H_ */