fuse_lowlevel.h

Go to the documentation of this file.

/*
  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_
 
#ifndef FUSE_USE_VERSION
#error FUSE_USE_VERSION not defined
#endif
 
#include "fuse_common.h"
 
#include <stddef.h>
#include <utime.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/uio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ----------------------------------------------------------- *
 * Miscellaneous definitions                                   *
 * ----------------------------------------------------------- */
 
#define FUSE_ROOT_ID 1
 
typedef uint64_t fuse_ino_t;
 
typedef struct fuse_req *fuse_req_t;
 
struct fuse_session;
 
struct fuse_entry_param {
        fuse_ino_t ino;
 
        uint64_t generation;
 
        struct stat attr;
 
        double attr_timeout;
 
        double entry_timeout;
};
 
struct fuse_ctx {
        uid_t uid;
 
        gid_t gid;
 
        pid_t pid;
 
        mode_t umask;
};
 
struct fuse_forget_data {
        fuse_ino_t ino;
        uint64_t nlookup;
};
 
struct fuse_custom_io {
        ssize_t (*writev)(int fd, struct iovec *iov, int count, void *userdata);
        ssize_t (*read)(int fd, void *buf, size_t buf_len, void *userdata);
        ssize_t (*splice_receive)(int fdin, off_t *offin, int fdout,
                                          off_t *offout, size_t len,
                                          unsigned int flags, void *userdata);
        ssize_t (*splice_send)(int fdin, off_t *offin, int fdout,
                                     off_t *offout, size_t len,
                                   unsigned int flags, void *userdata);
        int (*clone_fd)(int master_fd);
};
 
enum fuse_notify_entry_flags {
        FUSE_LL_INVALIDATE = 0,
        FUSE_LL_EXPIRE_ONLY     = (1 << 0),
};
 
/* '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_FORCE     (1 << 9)
#define FUSE_SET_ATTR_CTIME     (1 << 10)
#define FUSE_SET_ATTR_KILL_SUID (1 << 11)
#define FUSE_SET_ATTR_KILL_SGID (1 << 12)
#define FUSE_SET_ATTR_FILE      (1 << 13)
#define FUSE_SET_ATTR_KILL_PRIV (1 << 14)
#define FUSE_SET_ATTR_OPEN      (1 << 15)
#define FUSE_SET_ATTR_TIMES_SET (1 << 16)
#define FUSE_SET_ATTR_TOUCH     (1 << 17)
 
/* ----------------------------------------------------------- *
 * Request methods and replies                                 *
 * ----------------------------------------------------------- */
 
struct fuse_lowlevel_ops {
        void (*init) (void *userdata, struct fuse_conn_info *conn);
 
        void (*destroy) (void *userdata);
 
        void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
 
        void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);
 
        void (*getattr) (fuse_req_t req, fuse_ino_t ino,
                         struct fuse_file_info *fi);
 
        void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,
                         int to_set, struct fuse_file_info *fi);
 
        void (*readlink) (fuse_req_t req, fuse_ino_t ino);
 
        void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,
                       mode_t mode, dev_t rdev);
 
        void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,
                       mode_t mode);
 
        void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);
 
        void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);
 
        void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,
                         const char *name);
 
        void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,
                        fuse_ino_t newparent, const char *newname,
                        unsigned int flags);
 
        void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
                      const char *newname);
 
        void (*open) (fuse_req_t req, fuse_ino_t ino,
                      struct fuse_file_info *fi);
 
        void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                      struct fuse_file_info *fi);
 
        void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,
                       size_t size, off_t off, struct fuse_file_info *fi);
 
        void (*flush) (fuse_req_t req, fuse_ino_t ino,
                       struct fuse_file_info *fi);
 
        void (*release) (fuse_req_t req, fuse_ino_t ino,
                         struct fuse_file_info *fi);
 
        void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,
                       struct fuse_file_info *fi);
 
        void (*opendir) (fuse_req_t req, fuse_ino_t ino,
                         struct fuse_file_info *fi);
 
        void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                         struct fuse_file_info *fi);
 
        void (*releasedir) (fuse_req_t req, fuse_ino_t ino,
                            struct fuse_file_info *fi);
 
        void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,
                          struct fuse_file_info *fi);
 
        void (*statfs) (fuse_req_t req, fuse_ino_t ino);
 
        void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
                          const char *value, size_t size, int flags);
 
        void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
                          size_t size);
 
        void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);
 
        void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);
 
        void (*access) (fuse_req_t req, fuse_ino_t ino, int mask);
 
        void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,
                        mode_t mode, struct fuse_file_info *fi);
 
        void (*getlk) (fuse_req_t req, fuse_ino_t ino,
                       struct fuse_file_info *fi, struct flock *lock);
 
        void (*setlk) (fuse_req_t req, fuse_ino_t ino,
                       struct fuse_file_info *fi,
                       struct flock *lock, int sleep);
 
        void (*bmap) (fuse_req_t req, fuse_ino_t ino, size_t blocksize,
                      uint64_t idx);
 
#if FUSE_USE_VERSION < 35
        void (*ioctl) (fuse_req_t req, fuse_ino_t ino, int cmd,
                       void *arg, struct fuse_file_info *fi, unsigned flags,
                       const void *in_buf, size_t in_bufsz, size_t out_bufsz);
#else
        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);
#endif
 
        void (*poll) (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
                      struct fuse_pollhandle *ph);
 
        void (*write_buf) (fuse_req_t req, fuse_ino_t ino,
                           struct fuse_bufvec *bufv, off_t off,
                           struct fuse_file_info *fi);
 
        void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino,
                                off_t offset, struct fuse_bufvec *bufv);
 
        void (*forget_multi) (fuse_req_t req, size_t count,
                              struct fuse_forget_data *forgets);
 
        void (*flock) (fuse_req_t req, fuse_ino_t ino,
                       struct fuse_file_info *fi, int op);
 
        void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode,
                       off_t offset, off_t length, struct fuse_file_info *fi);
 
        void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
                         struct fuse_file_info *fi);
 
        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);
 
        void (*lseek) (fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
                       struct fuse_file_info *fi);
 
 
        void (*tmpfile) (fuse_req_t req, fuse_ino_t parent,
                        mode_t mode, struct fuse_file_info *fi);
 
};
 
int fuse_reply_err(fuse_req_t req, int err);
 
void fuse_reply_none(fuse_req_t req);
 
int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
 
int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
                      const struct fuse_file_info *fi);
 
int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
                    double attr_timeout);
 
int fuse_reply_readlink(fuse_req_t req, const char *link);
 
int fuse_passthrough_open(fuse_req_t req, int fd);
int fuse_passthrough_close(fuse_req_t req, int backing_id);
 
int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi);
 
int fuse_reply_write(fuse_req_t req, size_t count);
 
int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
 
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
                    enum fuse_buf_copy_flags flags);
 
int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count);
 
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf);
 
int fuse_reply_xattr(fuse_req_t req, size_t count);
 
int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
 
int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
 
/* ----------------------------------------------------------- *
 * Filling a buffer in readdir                                 *
 * ----------------------------------------------------------- */
 
size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
                         const char *name, const struct stat *stbuf,
                         off_t off);
 
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);
 
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);
 
int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size);
 
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
                         int count);
 
int fuse_reply_poll(fuse_req_t req, unsigned revents);
 
int fuse_reply_lseek(fuse_req_t req, off_t off);
 
/* ----------------------------------------------------------- *
 * Notification                                                *
 * ----------------------------------------------------------- */
 
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
 
int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
                                     off_t off, off_t len);
 
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
                                     const char *name, size_t namelen);
 
int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
                                      const char *name, size_t namelen);
 
int fuse_lowlevel_notify_delete(struct fuse_session *se,
                                fuse_ino_t parent, fuse_ino_t child,
                                const char *name, size_t namelen);
 
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
                               off_t offset, struct fuse_bufvec *bufv,
                               enum fuse_buf_copy_flags flags);
int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
                                  size_t size, off_t offset, void *cookie);
 
 
/* ----------------------------------------------------------- *
 * Utility functions                                           *
 * ----------------------------------------------------------- */
 
void *fuse_req_userdata(fuse_req_t req);
 
const struct fuse_ctx *fuse_req_ctx(fuse_req_t req);
 
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
 
typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
 
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
                             void *data);
 
int fuse_req_interrupted(fuse_req_t req);
 
 
/* ----------------------------------------------------------- *
 * Inquiry functions                                           *
 * ----------------------------------------------------------- */
 
void fuse_lowlevel_version(void);
 
void fuse_lowlevel_help(void);
 
void fuse_cmdline_help(void);
 
/* ----------------------------------------------------------- *
 * Filesystem setup & teardown                                 *
 * ----------------------------------------------------------- */
 
struct fuse_cmdline_opts {
        int singlethread;
        int foreground;
        int debug;
        int nodefault_subtype;
        char *mountpoint;
        int show_version;
        int show_help;
        int clone_fd;
        unsigned int max_idle_threads; /* discouraged, due to thread
                                        * destruct overhead */
 
        /* Added in libfuse-3.12 */
        unsigned int max_threads;
};
 
#if (defined(LIBFUSE_BUILT_WITH_VERSIONED_SYMBOLS))
int fuse_parse_cmdline(struct fuse_args *args,
                       struct fuse_cmdline_opts *opts);
#else
#if FUSE_USE_VERSION < FUSE_MAKE_VERSION(3, 12)
int fuse_parse_cmdline_30(struct fuse_args *args,
                           struct fuse_cmdline_opts *opts);
#define fuse_parse_cmdline(args, opts) fuse_parse_cmdline_30(args, opts)
#else
int fuse_parse_cmdline_312(struct fuse_args *args,
                           struct fuse_cmdline_opts *opts);
#define fuse_parse_cmdline(args, opts) fuse_parse_cmdline_312(args, opts)
#endif
#endif
 
/* Do not call this directly, use fuse_session_new() instead */
struct fuse_session *
fuse_session_new_versioned(struct fuse_args *args,
                           const struct fuse_lowlevel_ops *op, size_t op_size,
                           struct libfuse_version *version, void *userdata);
 
static inline struct fuse_session *
fuse_session_new_fn(struct fuse_args *args, const struct fuse_lowlevel_ops *op,
                    size_t op_size, void *userdata)
{
        struct libfuse_version version = {
                .major = FUSE_MAJOR_VERSION,
                .minor = FUSE_MINOR_VERSION,
                .hotfix = FUSE_HOTFIX_VERSION,
                .padding = 0
        };
 
        return fuse_session_new_versioned(args, op, op_size, &version,
                                          userdata);
}
#define fuse_session_new(args, op, op_size, userdata) \
        fuse_session_new_fn(args, op, op_size, userdata)
 
/*
 * This should mostly not be called directly, but instead the
 * fuse_session_custom_io() should be used.
 */
int fuse_session_custom_io_317(struct fuse_session *se,
                        const struct fuse_custom_io *io, size_t op_size, int fd);
 
#if FUSE_MAKE_VERSION(3, 17) <= FUSE_USE_VERSION
static inline int fuse_session_custom_io(struct fuse_session *se,
                                        const struct fuse_custom_io *io, size_t op_size, int fd)
{
        return fuse_session_custom_io_317(se, io, op_size, fd);
}
#else
static inline int fuse_session_custom_io(struct fuse_session *se,
                                        const struct fuse_custom_io *io, int fd)
{
        return fuse_session_custom_io_317(se, io,
                                offsetof(struct fuse_custom_io, clone_fd), fd);
}
#endif
 
int fuse_session_mount(struct fuse_session *se, const char *mountpoint);
 
int fuse_session_loop(struct fuse_session *se);
 
#if FUSE_USE_VERSION < 32
        int fuse_session_loop_mt_31(struct fuse_session *se, int clone_fd);
        #define fuse_session_loop_mt(se, clone_fd) fuse_session_loop_mt_31(se, clone_fd)
#elif FUSE_USE_VERSION < FUSE_MAKE_VERSION(3, 12)
        int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config);
        #define fuse_session_loop_mt(se, config) fuse_session_loop_mt_32(se, config)
#else
        #if (defined(LIBFUSE_BUILT_WITH_VERSIONED_SYMBOLS))
                int fuse_session_loop_mt(struct fuse_session *se, struct fuse_loop_config *config);
        #else
                int fuse_session_loop_mt_312(struct fuse_session *se, struct fuse_loop_config *config);
                #define fuse_session_loop_mt(se, config) fuse_session_loop_mt_312(se, config)
        #endif
#endif
 
void fuse_session_exit(struct fuse_session *se);
 
void fuse_session_reset(struct fuse_session *se);
 
int fuse_session_exited(struct fuse_session *se);
 
void fuse_session_unmount(struct fuse_session *se);
 
void fuse_session_destroy(struct fuse_session *se);
 
/* ----------------------------------------------------------- *
 * Custom event loop support                                   *
 * ----------------------------------------------------------- */
 
int fuse_session_fd(struct fuse_session *se);
 
void fuse_session_process_buf(struct fuse_session *se,
                              const struct fuse_buf *buf);
 
int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FUSE_LOWLEVEL_H_ */