fuse_common.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.
*/
 
#include <stdbool.h>
#if !defined(FUSE_H_) && !defined(FUSE_LOWLEVEL_H_)
#error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
#endif
 
#ifndef FUSE_COMMON_H_
#define FUSE_COMMON_H_
 
#ifdef HAVE_LIBFUSE_PRIVATE_CONFIG_H
#include "fuse_config.h"
#endif
 
#include "libfuse_config.h"
 
#include "fuse_opt.h"
#include "fuse_log.h"
#include <stdint.h>
#include <sys/types.h>
#include <assert.h>
 
#define FUSE_MAKE_VERSION(maj, min)  ((maj) * 100 + (min))
#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)
 
#if (defined(__cplusplus) && __cplusplus >= 201103L) ||        \
        (!defined(__cplusplus) && defined(__STDC_VERSION__) && \
         __STDC_VERSION__ >= 201112L)
#define fuse_static_assert(condition, message) static_assert(condition, message)
#else
#define fuse_static_assert(condition, message)
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct fuse_file_info {
        int32_t flags;
 
        uint32_t writepage : 1;
 
        uint32_t direct_io : 1;
 
        uint32_t keep_cache : 1;
 
        uint32_t flush : 1;
 
        uint32_t nonseekable : 1;
 
        /* Indicates that flock locks for this file should be
           released.  If set, lock_owner shall contain a valid value.
           May only be set in ->release(). */
        uint32_t flock_release : 1;
 
        uint32_t cache_readdir : 1;
 
        uint32_t noflush : 1;
 
        uint32_t parallel_direct_writes : 1;
 
        uint32_t padding : 23;
        uint32_t padding2 : 32;
        uint32_t padding3 : 32;
 
        uint64_t fh;
 
        uint64_t lock_owner;
 
        uint32_t poll_events;
 
        int32_t backing_id;
 
        uint64_t compat_flags;
 
        uint64_t reserved[2];
};
fuse_static_assert(sizeof(struct fuse_file_info) == 64,
                   "fuse_file_info size mismatch");
 
#if FUSE_USE_VERSION < FUSE_MAKE_VERSION(3, 12)
struct fuse_loop_config_v1; /* forward declaration */
struct fuse_loop_config {
#else
struct fuse_loop_config_v1 {
#endif
        int clone_fd;
 
        unsigned int max_idle_threads;
};
 
 
/**************************************************************************
 * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' *
 **************************************************************************/
 
#define FUSE_CAP_ASYNC_READ (1 << 0)
 
#define FUSE_CAP_POSIX_LOCKS (1 << 1)
 
#define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3)
 
#define FUSE_CAP_EXPORT_SUPPORT (1 << 4)
 
#define FUSE_CAP_DONT_MASK (1 << 6)
 
#define FUSE_CAP_SPLICE_WRITE (1 << 7)
 
#define FUSE_CAP_SPLICE_MOVE (1 << 8)
 
#define FUSE_CAP_SPLICE_READ (1 << 9)
 
#define FUSE_CAP_FLOCK_LOCKS (1 << 10)
 
#define FUSE_CAP_IOCTL_DIR (1 << 11)
 
#define FUSE_CAP_AUTO_INVAL_DATA (1 << 12)
 
#define FUSE_CAP_READDIRPLUS (1 << 13)
 
#define FUSE_CAP_READDIRPLUS_AUTO (1 << 14)
 
#define FUSE_CAP_ASYNC_DIO (1 << 15)
 
#define FUSE_CAP_WRITEBACK_CACHE (1 << 16)
 
#define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17)
 
#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
 
#define FUSE_CAP_POSIX_ACL (1 << 19)
 
#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20)
 
#define FUSE_CAP_HANDLE_KILLPRIV_V2 (1 << 21)
 
#define FUSE_CAP_CACHE_SYMLINKS (1 << 23)
 
#define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24)
 
#define FUSE_CAP_EXPLICIT_INVAL_DATA (1 << 25)
 
#define FUSE_CAP_EXPIRE_ONLY (1 << 26)
 
#define FUSE_CAP_SETXATTR_EXT (1 << 27)
 
#define FUSE_CAP_DIRECT_IO_ALLOW_MMAP (1 << 28)
 
#define FUSE_CAP_PASSTHROUGH (1 << 29)
 
#define FUSE_CAP_NO_EXPORT_SUPPORT (1 << 30)
 
#define FUSE_IOCTL_COMPAT       (1 << 0)
#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
#define FUSE_IOCTL_RETRY        (1 << 2)
#define FUSE_IOCTL_DIR          (1 << 4)
 
#define FUSE_IOCTL_MAX_IOV      256
 
struct fuse_conn_info {
        uint32_t proto_major;
 
        uint32_t proto_minor;
 
        uint32_t max_write;
 
        uint32_t max_read;
 
        uint32_t max_readahead;
 
        uint32_t capable;
 
        uint32_t want;
 
        uint32_t max_background;
 
        uint32_t congestion_threshold;
 
        uint32_t time_gran;
 
#define FUSE_BACKING_STACKED_UNDER      (0)
#define FUSE_BACKING_STACKED_OVER       (1)
        uint32_t max_backing_stack_depth;
 
        uint32_t no_interrupt : 1;
 
        /* reserved bits for future use */
        uint32_t padding : 31;
 
        uint64_t capable_ext;
 
        uint64_t want_ext;
 
        uint32_t reserved[16];
};
fuse_static_assert(sizeof(struct fuse_conn_info) == 128,
                   "Size of struct fuse_conn_info must be 128 bytes");
 
struct fuse_session;
struct fuse_pollhandle;
struct fuse_conn_info_opts;
 
struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args);
 
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
                          struct fuse_conn_info *conn);
 
int fuse_daemonize(int foreground);
 
int fuse_version(void);
 
const char *fuse_pkgversion(void);
 
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
 
/* ----------------------------------------------------------- *
 * Data buffer                                                 *
 * ----------------------------------------------------------- */
 
enum fuse_buf_flags {
        FUSE_BUF_IS_FD          = (1 << 1),
 
        FUSE_BUF_FD_SEEK        = (1 << 2),
 
        FUSE_BUF_FD_RETRY       = (1 << 3)
};
 
enum fuse_buf_copy_flags {
        FUSE_BUF_NO_SPLICE      = (1 << 1),
 
        FUSE_BUF_FORCE_SPLICE   = (1 << 2),
 
        FUSE_BUF_SPLICE_MOVE    = (1 << 3),
 
        FUSE_BUF_SPLICE_NONBLOCK= (1 << 4)
};
 
struct fuse_buf {
        size_t size;
 
        enum fuse_buf_flags flags;
 
        void *mem;
 
        int fd;
 
        off_t pos;
 
        size_t mem_size;
};
 
struct fuse_bufvec {
        size_t count;
 
        size_t idx;
 
        size_t off;
 
        struct fuse_buf buf[1];
};
 
struct libfuse_version
{
        uint32_t major;
        uint32_t minor;
        uint32_t hotfix;
        uint32_t padding;
};
 
/* Initialize bufvec with a single buffer of given size */
#define FUSE_BUFVEC_INIT(size__)                                \
        ((struct fuse_bufvec) {                                 \
                /* .count= */ 1,                                \
                /* .idx =  */ 0,                                \
                /* .off =  */ 0,                                \
                /* .buf =  */ { /* [0] = */ {                   \
                        /* .size =  */ (size__),                \
                        /* .flags = */ (enum fuse_buf_flags) 0, \
                        /* .mem =   */ NULL,                    \
                        /* .fd =    */ -1,                      \
                        /* .pos =   */ 0,                       \
                        /* .mem_size = */ 0,                    \
                } }                                             \
        } )
 
size_t fuse_buf_size(const struct fuse_bufvec *bufv);
 
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
                      enum fuse_buf_copy_flags flags);
 
/* ----------------------------------------------------------- *
 * Signal handling                                             *
 * ----------------------------------------------------------- */
 
int fuse_set_signal_handlers(struct fuse_session *se);
 
int fuse_set_fail_signal_handlers(struct fuse_session *se);
 
void fuse_remove_signal_handlers(struct fuse_session *se);
 
#if FUSE_USE_VERSION >= FUSE_MAKE_VERSION(3, 12)
struct fuse_loop_config *fuse_loop_cfg_create(void);
 
void fuse_loop_cfg_destroy(struct fuse_loop_config *config);
 
void fuse_loop_cfg_set_idle_threads(struct fuse_loop_config *config,
                                    unsigned int value);
 
void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config,
                                   unsigned int value);
 
void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config,
                                unsigned int value);
 
void fuse_loop_cfg_convert(struct fuse_loop_config *config,
                           struct fuse_loop_config_v1 *v1_conf);
#endif
 
 
static inline bool fuse_set_feature_flag(struct fuse_conn_info *conn,
                                         uint64_t flag)
{
        if (conn->capable_ext & flag) {
                conn->want_ext |= flag;
                return true;
        }
        return false;
}
 
static inline void fuse_unset_feature_flag(struct fuse_conn_info *conn,
                                         uint64_t flag)
{
        conn->want_ext &= ~flag;
}
 
static inline bool fuse_get_feature_flag(struct fuse_conn_info *conn,
                                             uint64_t flag)
{
        return conn->capable_ext & flag ? true : false;
}
 
/* ----------------------------------------------------------- *
 * Compatibility stuff                                         *
 * ----------------------------------------------------------- */
 
#if !defined(FUSE_USE_VERSION) || FUSE_USE_VERSION < 30
#  error only API version 30 or greater is supported
#endif
 
#ifdef __cplusplus
}
#endif
 
 
/*
 * This interface uses 64 bit off_t.
 *
 * On 32bit systems please add -D_FILE_OFFSET_BITS=64 to your compile flags!
 */
 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
_Static_assert(sizeof(off_t) == 8, "fuse: off_t must be 64bit");
#else
struct _fuse_off_t_must_be_64bit_dummy_struct \
        { unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); };
#endif
 
#endif /* FUSE_COMMON_H_ */