Mirror
/
mergerfs
mirror of https://github.com/trapexit/mergerfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

libfuse cleanup: extern cplusplus cleanup

pull/809/head
Antonio SJ Musumeci 4 years ago
parent
dc1b698847
commit
a925fbe59c
6 changed files with 2898 additions and 2923 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      libfuse/include/extern_c.h
  2. 237
      libfuse/include/fuse.h
  3. 106
      libfuse/include/fuse_common.h
  4. 351
      libfuse/include/fuse_lowlevel.h
  5. 72
      libfuse/include/fuse_opt.h
  6. 24
      libfuse/include/ulockmgr.h

9
libfuse/include/extern_c.h
View File

@ -0,0 +1,9 @@
#pragma once
#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#define EXTERN_C_END }
#else
#define EXTERN_C_BEGIN
#define EXTERN_C_END
#endif

237
libfuse/include/fuse.h
View File

@ -23,6 +23,7 @@
#define FUSE_USE_VERSION 21 #define FUSE_USE_VERSION 21
#endif #endif
#include "extern_c.h"
#include "fuse_common.h" #include "fuse_common.h"
#include "fuse_dirents.h" #include "fuse_dirents.h"
@ -34,21 +35,19 @@
#include <sys/statvfs.h> #include <sys/statvfs.h>
#include <sys/uio.h> #include <sys/uio.h>
#ifdef __cplusplus
extern "C" {
#endif
EXTERN_C_BEGIN
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Basic FUSE API * * Basic FUSE API *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/** Handle for a FUSE filesystem */
struct fuse;
/** Handle for a FUSE filesystem */
struct fuse;
/** Structure containing a raw command */
struct fuse_cmd;
/** Structure containing a raw command */
struct fuse_cmd;
/**
/**
* The file system operations: * The file system operations:
* *
* Most of these should work very similarly to the well known UNIX * Most of these should work very similarly to the well known UNIX
@ -70,8 +69,8 @@ extern "C" {
* See http://fuse.sourceforge.net/wiki/ for more information. There * See http://fuse.sourceforge.net/wiki/ for more information. There
* is also a snapshot of the relevant wiki pages in the doc/ folder. * is also a snapshot of the relevant wiki pages in the doc/ folder.
*/ */
struct fuse_operations
{
struct fuse_operations
{
/** Get file attributes. /** Get file attributes.
* *
* Similar to stat(). The 'st_dev' and 'st_blksize' fields are * Similar to stat(). The 'st_dev' and 'st_blksize' fields are
@ -576,15 +575,15 @@ extern "C" {
off_t offset_out, off_t offset_out,
size_t size, size_t size,
int flags); int flags);
};
};
/** Extra context that may be needed by some filesystems
/** Extra context that may be needed by some filesystems
* *
* The uid, gid and pid fields are not filled in case of a writepage * The uid, gid and pid fields are not filled in case of a writepage
* operation. * operation.
*/ */
struct fuse_context
{
struct fuse_context
{
/** Pointer to the fuse object */ /** Pointer to the fuse object */
struct fuse *fuse; struct fuse *fuse;
@ -602,9 +601,9 @@ extern "C" {
/** Umask of the calling process (introduced in version 2.8) */ /** Umask of the calling process (introduced in version 2.8) */
mode_t umask; mode_t umask;
};
};
/**
/**
* Main function of FUSE. * Main function of FUSE.
* *
* This is for the lazy. This is all that has to be called from the * This is for the lazy. This is all that has to be called from the
@ -627,18 +626,18 @@ extern "C" {
* @param user_data user data supplied in the context during the init() method * @param user_data user data supplied in the context during the init() method
* @return 0 on success, nonzero on failure * @return 0 on success, nonzero on failure
*/ */
/*
/*
int fuse_main(int argc, char *argv[], const struct fuse_operations *op, int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
void *user_data); void *user_data);
*/
*/
#define fuse_main(argc, argv, op, user_data) \ #define fuse_main(argc, argv, op, user_data) \
fuse_main_real(argc, argv, op, sizeof(*(op)), user_data) fuse_main_real(argc, argv, op, sizeof(*(op)), user_data)
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* More detailed API * * More detailed API *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Create a new FUSE filesystem. * Create a new FUSE filesystem.
* *
* @param ch the communication channel * @param ch the communication channel
@ -648,11 +647,11 @@ extern "C" {
* @param user_data user data supplied in the context during the init() method * @param user_data user data supplied in the context during the init() method
* @return the created FUSE handle * @return the created FUSE handle
*/ */
struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
const struct fuse_operations *op, size_t op_size, const struct fuse_operations *op, size_t op_size,
void *user_data); void *user_data);
/**
/**
* Destroy the FUSE handle. * Destroy the FUSE handle.
* *
* The communication channel attached to the handle is also destroyed. * The communication channel attached to the handle is also destroyed.
@ -662,18 +661,18 @@ extern "C" {
* *
* @param f the FUSE handle * @param f the FUSE handle
*/ */
void fuse_destroy(struct fuse *f);
void fuse_destroy(struct fuse *f);
/**
/**
* Exit from event loop * Exit from event loop
* *
* @param f the FUSE handle * @param f the FUSE handle
*/ */
void fuse_exit(struct fuse *f);
void fuse_exit(struct fuse *f);
int fuse_config_num_threads(const struct fuse *fuse_);
int fuse_config_num_threads(const struct fuse *fuse_);
/**
/**
* FUSE event loop with multiple threads * FUSE event loop with multiple threads
* *
* Requests from the kernel are processed, and the appropriate * Requests from the kernel are processed, and the appropriate
@ -686,9 +685,9 @@ extern "C" {
* @param f the FUSE handle * @param f the FUSE handle
* @return 0 if no error occurred, -1 otherwise * @return 0 if no error occurred, -1 otherwise
*/ */
int fuse_loop_mt(struct fuse *f);
int fuse_loop_mt(struct fuse *f);
/**
/**
* Get the current context * Get the current context
* *
* The context is only valid for the duration of a filesystem * The context is only valid for the duration of a filesystem
@ -696,51 +695,51 @@ extern "C" {
* *
* @return the context * @return the context
*/ */
struct fuse_context *fuse_get_context(void);
struct fuse_context *fuse_get_context(void);
/**
/**
* Check if the current request has already been interrupted * Check if the current request has already been interrupted
* *
* @return 1 if the request has been interrupted, 0 otherwise * @return 1 if the request has been interrupted, 0 otherwise
*/ */
int fuse_interrupted(void);
int fuse_interrupted(void);
/**
/**
* Obsolete, doesn't do anything * Obsolete, doesn't do anything
* *
* @return -EINVAL * @return -EINVAL
*/ */
int fuse_invalidate(struct fuse *f, const char *path);
int fuse_invalidate(struct fuse *f, const char *path);
/* Deprecated, don't use */
int fuse_is_lib_option(const char *opt);
/* Deprecated, don't use */
int fuse_is_lib_option(const char *opt);
/**
/**
* The real main function * The real main function
* *
* Do not call this directly, use fuse_main() * Do not call this directly, use fuse_main()
*/ */
int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
size_t op_size, void *user_data); size_t op_size, void *user_data);
/**
/**
* Start the cleanup thread when using option "remember". * Start the cleanup thread when using option "remember".
* *
* This is done automatically by fuse_loop_mt() * This is done automatically by fuse_loop_mt()
* @param fuse struct fuse pointer for fuse instance * @param fuse struct fuse pointer for fuse instance
* @return 0 on success and -1 on error * @return 0 on success and -1 on error
*/ */
int fuse_start_cleanup_thread(struct fuse *fuse);
int fuse_start_cleanup_thread(struct fuse *fuse);
/**
/**
* Stop the cleanup thread when using option "remember". * Stop the cleanup thread when using option "remember".
* *
* This is done automatically by fuse_loop_mt() * This is done automatically by fuse_loop_mt()
* @param fuse struct fuse pointer for fuse instance * @param fuse struct fuse pointer for fuse instance
*/ */
void fuse_stop_cleanup_thread(struct fuse *fuse);
void fuse_stop_cleanup_thread(struct fuse *fuse);
/**
/**
* Iterate over cache removing stale entries * Iterate over cache removing stale entries
* use in conjunction with "-oremember" * use in conjunction with "-oremember"
* *
@ -749,20 +748,20 @@ extern "C" {
* @param fuse struct fuse pointer for fuse instance * @param fuse struct fuse pointer for fuse instance
* @return the number of seconds until the next cleanup * @return the number of seconds until the next cleanup
*/ */
int fuse_clean_cache(struct fuse *fuse);
int fuse_clean_cache(struct fuse *fuse);
/*
/*
* Stacking API * Stacking API
*/ */
/**
/**
* Fuse filesystem object * Fuse filesystem object
* *
* This is opaque object represents a filesystem layer * This is opaque object represents a filesystem layer
*/ */
struct fuse_fs;
struct fuse_fs;
/*
/*
* These functions call the relevant filesystem operation, and return * These functions call the relevant filesystem operation, and return
* the result. * the result.
* *
@ -771,101 +770,101 @@ extern "C" {
* fuse_fs_releasedir and fuse_fs_statfs, which return 0. * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
*/ */
int fuse_fs_getattr(struct fuse_fs *fs,
int fuse_fs_getattr(struct fuse_fs *fs,
const char *path, const char *path,
struct stat *buf, struct stat *buf,
fuse_timeouts_t *timeout); fuse_timeouts_t *timeout);
int fuse_fs_fgetattr(struct fuse_fs *fs,
int fuse_fs_fgetattr(struct fuse_fs *fs,
struct stat *buf, struct stat *buf,
struct fuse_file_info *fi, struct fuse_file_info *fi,
fuse_timeouts_t *timeout); fuse_timeouts_t *timeout);
int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
const char *newpath); const char *newpath);
int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
const char *path); const char *path);
int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
int fuse_fs_release(struct fuse_fs *fs,
int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
int fuse_fs_release(struct fuse_fs *fs,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_open(struct fuse_fs *fs, const char *path,
int fuse_fs_open(struct fuse_fs *fs, const char *path,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_read(struct fuse_fs *fs, char *buf, size_t size,
int fuse_fs_read(struct fuse_fs *fs, char *buf, size_t size,
off_t off, struct fuse_file_info *fi); off_t off, struct fuse_file_info *fi);
int fuse_fs_read_buf(struct fuse_fs *fs,
int fuse_fs_read_buf(struct fuse_fs *fs,
struct fuse_bufvec **bufp, size_t size, off_t off, struct fuse_bufvec **bufp, size_t size, off_t off,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_write(struct fuse_fs *fs, const char *buf,
int fuse_fs_write(struct fuse_fs *fs, const char *buf,
size_t size, off_t off, struct fuse_file_info *fi); size_t size, off_t off, struct fuse_file_info *fi);
int fuse_fs_write_buf(struct fuse_fs *fs,
int fuse_fs_write_buf(struct fuse_fs *fs,
struct fuse_bufvec *buf, off_t off, struct fuse_bufvec *buf, off_t off,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_fsync(struct fuse_fs *fs, int datasync,
int fuse_fs_fsync(struct fuse_fs *fs, int datasync,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_flush(struct fuse_fs *fs,
int fuse_fs_flush(struct fuse_fs *fs,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_readdir(struct fuse_fs *fs,
int fuse_fs_readdir(struct fuse_fs *fs,
struct fuse_file_info *fi, struct fuse_file_info *fi,
fuse_dirents_t *buf); fuse_dirents_t *buf);
int fuse_fs_fsyncdir(struct fuse_fs *fs, int datasync,
int fuse_fs_fsyncdir(struct fuse_fs *fs, int datasync,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_releasedir(struct fuse_fs *fs,
int fuse_fs_releasedir(struct fuse_fs *fs,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_lock(struct fuse_fs *fs,
int fuse_fs_lock(struct fuse_fs *fs,
struct fuse_file_info *fi, int cmd, struct flock *lock); struct fuse_file_info *fi, int cmd, struct flock *lock);
int fuse_fs_flock(struct fuse_fs *fs,
int fuse_fs_flock(struct fuse_fs *fs,
struct fuse_file_info *fi, int op); struct fuse_file_info *fi, int op);
int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode);
int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);
int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size);
int fuse_fs_ftruncate(struct fuse_fs *fs, off_t size,
int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode);
int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);
int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size);
int fuse_fs_ftruncate(struct fuse_fs *fs, off_t size,
struct fuse_file_info *fi); struct fuse_file_info *fi);
int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
const struct timespec tv[2]); const struct timespec tv[2]);
int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
size_t len); size_t len);
int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
dev_t rdev); dev_t rdev);
int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
const char *value, size_t size, int flags); const char *value, size_t size, int flags);
int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
char *value, size_t size); char *value, size_t size);
int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
size_t size); size_t size);
int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
const char *name); const char *name);
int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
uint64_t *idx); uint64_t *idx);
int fuse_fs_ioctl(struct fuse_fs *fs, unsigned long cmd, void *arg,
int fuse_fs_ioctl(struct fuse_fs *fs, unsigned long cmd, void *arg,
struct fuse_file_info *fi, unsigned int flags, struct fuse_file_info *fi, unsigned int flags,
void *data, uint32_t *out_bufsz); void *data, uint32_t *out_bufsz);
int fuse_fs_poll(struct fuse_fs *fs,
int fuse_fs_poll(struct fuse_fs *fs,
struct fuse_file_info *fi, struct fuse_pollhandle *ph, struct fuse_file_info *fi, struct fuse_pollhandle *ph,
unsigned *reventsp); unsigned *reventsp);
int fuse_fs_fallocate(struct fuse_fs *fs, int mode,
int fuse_fs_fallocate(struct fuse_fs *fs, int mode,
off_t offset, off_t length, struct fuse_file_info *fi); off_t offset, off_t length, struct fuse_file_info *fi);
void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn);
void fuse_fs_destroy(struct fuse_fs *fs);
void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn);
void fuse_fs_destroy(struct fuse_fs *fs);
int fuse_fs_prepare_hide(struct fuse_fs *fs, const char *path, uint64_t *fh);
int fuse_fs_free_hide(struct fuse_fs *fs, uint64_t fh);
ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs,
int fuse_fs_prepare_hide(struct fuse_fs *fs, const char *path, uint64_t *fh);
int fuse_fs_free_hide(struct fuse_fs *fs, uint64_t fh);
ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs,
struct fuse_file_info *fi_in, off_t off_in, struct fuse_file_info *fi_in, off_t off_in,
struct fuse_file_info *fi_out, off_t off_out, struct fuse_file_info *fi_out, off_t off_out,
size_t len, int flags); size_t len, int flags);
int fuse_notify_poll(struct fuse_pollhandle *ph);
int fuse_notify_poll(struct fuse_pollhandle *ph);
/**
/**
* Create a new fuse filesystem object * Create a new fuse filesystem object
* *
* This is usually called from the factory of a fuse module to create * This is usually called from the factory of a fuse module to create
@ -876,50 +875,48 @@ extern "C" {
* @param user_data user data supplied in the context during the init() method * @param user_data user data supplied in the context during the init() method
* @return a new filesystem object * @return a new filesystem object
*/ */
struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
void *user_data); void *user_data);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Advanced API for event handling, don't worry about this... * * Advanced API for event handling, don't worry about this... *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/* NOTE: the following functions are deprecated, and will be removed
/* NOTE: the following functions are deprecated, and will be removed
from the 3.0 API. Use the lowlevel session functions instead */ from the 3.0 API. Use the lowlevel session functions instead */
/** Function type used to process commands */
typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
/** Function type used to process commands */
typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
/** This is the part of fuse_main() before the event loop */
struct fuse *fuse_setup(int argc, char *argv[],
/** This is the part of fuse_main() before the event loop */
struct fuse *fuse_setup(int argc, char *argv[],
const struct fuse_operations *op, size_t op_size, const struct fuse_operations *op, size_t op_size,
char **mountpoint, char **mountpoint,
void *user_data); void *user_data);
/** This is the part of fuse_main() after the event loop */
void fuse_teardown(struct fuse *fuse, char *mountpoint);
/** This is the part of fuse_main() after the event loop */
void fuse_teardown(struct fuse *fuse, char *mountpoint);
/** Read a single command. If none are read, return NULL */
struct fuse_cmd *fuse_read_cmd(struct fuse *f);
/** Read a single command. If none are read, return NULL */
struct fuse_cmd *fuse_read_cmd(struct fuse *f);
/** Process a single command */
void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd);
/** Process a single command */
void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd);
/** Multi threaded event loop, which calls the custom command
/** Multi threaded event loop, which calls the custom command
processor function */ processor function */
int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data);
int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data);
/** Return the exited flag, which indicates if fuse_exit() has been
/** Return the exited flag, which indicates if fuse_exit() has been
called */ called */
int fuse_exited(struct fuse *f);
int fuse_exited(struct fuse *f);
/** This function is obsolete and implemented as a no-op */
void fuse_set_getcontext_func(struct fuse_context *(*func)(void));
/** This function is obsolete and implemented as a no-op */
void fuse_set_getcontext_func(struct fuse_context *(*func)(void));
/** Get session from fuse object */
struct fuse_session *fuse_get_session(struct fuse *f);
/** Get session from fuse object */
struct fuse_session *fuse_get_session(struct fuse *f);
#ifdef __cplusplus
}
#endif
EXTERN_C_END
#endif /* _FUSE_H_ */ #endif /* _FUSE_H_ */

106
libfuse/include/fuse_common.h
View File

@ -15,8 +15,10 @@
#ifndef _FUSE_COMMON_H_ #ifndef _FUSE_COMMON_H_
#define _FUSE_COMMON_H_ #define _FUSE_COMMON_H_
#include "extern_c.h"
#include "fuse_opt.h" #include "fuse_opt.h"
#include "fuse_timeouts.h" #include "fuse_timeouts.h"
#include <stdint.h> #include <stdint.h>
#include <sys/types.h> #include <sys/types.h>
@ -37,18 +39,16 @@
#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32 #define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
#define FUSE_MAX_MAX_PAGES 256 #define FUSE_MAX_MAX_PAGES 256
#ifdef __cplusplus
extern "C" {
#endif
EXTERN_C_BEGIN
/**
/**
* Information about open files * Information about open files
* *
* Changed in version 2.5 * Changed in version 2.5
*/ */
struct
fuse_file_info
{
struct
fuse_file_info
{
/** Open flags. Available in open() and release() */ /** Open flags. Available in open() and release() */
int flags; int flags;
@ -90,9 +90,9 @@ extern "C" {
/** Lock owner id. Available in locking operations and flush */ /** Lock owner id. Available in locking operations and flush */
uint64_t lock_owner; uint64_t lock_owner;
};
};
/**
/**
* Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want'
* *
* FUSE_CAP_ASYNC_READ: filesystem supports asynchronous read requests * FUSE_CAP_ASYNC_READ: filesystem supports asynchronous read requests
@ -127,7 +127,7 @@ extern "C" {
#define FUSE_CAP_CACHE_SYMLINKS (1 << 20) #define FUSE_CAP_CACHE_SYMLINKS (1 << 20)
#define FUSE_CAP_MAX_PAGES (1 << 21) #define FUSE_CAP_MAX_PAGES (1 << 21)
/**
/**
* Ioctl flags * Ioctl flags
* *
* FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
@ -144,14 +144,14 @@ extern "C" {
#define FUSE_IOCTL_MAX_IOV 256 #define FUSE_IOCTL_MAX_IOV 256
/**
/**
* Connection information, passed to the ->init() method * Connection information, passed to the ->init() method
* *
* Some of the elements are read-write, these can be changed to * Some of the elements are read-write, these can be changed to
* indicate the value requested by the filesystem. The requested * indicate the value requested by the filesystem. The requested
* value must usually be smaller than the indicated value. * value must usually be smaller than the indicated value.
*/ */
struct fuse_conn_info {
struct fuse_conn_info {
/** /**
* Major version of the protocol (read-only) * Major version of the protocol (read-only)
*/ */
@ -201,13 +201,13 @@ extern "C" {
* For future use. * For future use.
*/ */
unsigned reserved[22]; unsigned reserved[22];
};
};
struct fuse_session;
struct fuse_chan;
struct fuse_pollhandle;
struct fuse_session;
struct fuse_chan;
struct fuse_pollhandle;
/**
/**
* Create a FUSE mountpoint * Create a FUSE mountpoint
* *
* Returns a control file descriptor suitable for passing to * Returns a control file descriptor suitable for passing to
@ -217,18 +217,18 @@ extern "C" {
* @param args argument vector * @param args argument vector
* @return the communication channel on success, NULL on failure * @return the communication channel on success, NULL on failure
*/ */
struct fuse_chan *fuse_mount(const char *mountpoint,
struct fuse_chan *fuse_mount(const char *mountpoint,
struct fuse_args *args); struct fuse_args *args);
/**
/**
* Umount a FUSE mountpoint * Umount a FUSE mountpoint
* *
* @param mountpoint the mount point path * @param mountpoint the mount point path
* @param ch the communication channel * @param ch the communication channel
*/ */
void fuse_unmount(const char *mountpoint, struct fuse_chan *ch);
void fuse_unmount(const char *mountpoint, struct fuse_chan *ch);
/**
/**
* Parse common options * Parse common options
* *
* The following options are parsed: * The following options are parsed:
@ -247,40 +247,40 @@ extern "C" {
* @param foreground set to 1 if one of the relevant options is present * @param foreground set to 1 if one of the relevant options is present
* @return 0 on success, -1 on failure * @return 0 on success, -1 on failure
*/ */
int fuse_parse_cmdline(struct fuse_args *args,
int fuse_parse_cmdline(struct fuse_args *args,
char **mountpoint, char **mountpoint,
int *foreground); int *foreground);
/**
/**
* Go into the background * Go into the background
* *
* @param foreground if true, stay in the foreground * @param foreground if true, stay in the foreground
* @return 0 on success, -1 on failure * @return 0 on success, -1 on failure
*/ */
int fuse_daemonize(int foreground);
int fuse_daemonize(int foreground);
/**
/**
* Get the version of the library * Get the version of the library
* *
* @return the version * @return the version
*/ */
int fuse_version(void);
int fuse_version(void);
/**
/**
* Destroy poll handle * Destroy poll handle
* *
* @param ph the poll handle * @param ph the poll handle
*/ */
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Data buffer * * Data buffer *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Buffer flags * Buffer flags
*/ */
enum fuse_buf_flags {
enum fuse_buf_flags {
/** /**
* Buffer contains a file descriptor * Buffer contains a file descriptor
* *
@ -306,12 +306,12 @@ extern "C" {
* detected. * detected.
*/ */
FUSE_BUF_FD_RETRY = (1 << 3), FUSE_BUF_FD_RETRY = (1 << 3),
};
};
/**
/**
* Buffer copy flags * Buffer copy flags
*/ */
enum fuse_buf_copy_flags {
enum fuse_buf_copy_flags {
/** /**
* Don't use splice(2) * Don't use splice(2)
* *
@ -348,15 +348,15 @@ extern "C" {
* man page. * man page.
*/ */
FUSE_BUF_SPLICE_NONBLOCK= (1 << 4), FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
};
};
/**
/**
* Single data buffer * Single data buffer
* *
* Generic data buffer for I/O, extended attributes, etc... Data may * Generic data buffer for I/O, extended attributes, etc... Data may
* be supplied as a memory pointer or as a file descriptor * be supplied as a memory pointer or as a file descriptor
*/ */
struct fuse_buf {
struct fuse_buf {
/** /**
* Size of data in bytes * Size of data in bytes
*/ */
@ -387,9 +387,9 @@ extern "C" {
* Used if FUSE_BUF_FD_SEEK flag is set. * Used if FUSE_BUF_FD_SEEK flag is set.
*/ */
off_t pos; off_t pos;
};
};
/**
/**
* Data buffer vector * Data buffer vector
* *
* An array of data buffers, each containing a memory pointer or a * An array of data buffers, each containing a memory pointer or a
@ -397,7 +397,7 @@ extern "C" {
* *
* Allocate dynamically to add more than one buffer. * Allocate dynamically to add more than one buffer.
*/ */
struct fuse_bufvec {
struct fuse_bufvec {
/** /**
* Number of buffers in the array * Number of buffers in the array
*/ */
@ -417,9 +417,9 @@ extern "C" {
* Array of buffers * Array of buffers
*/ */
struct fuse_buf buf[1]; struct fuse_buf buf[1];
};
};
/* Initialize bufvec with a single buffer of given size */
/* Initialize bufvec with a single buffer of given size */
#define FUSE_BUFVEC_INIT(size__) \ #define FUSE_BUFVEC_INIT(size__) \
((struct fuse_bufvec) { \ ((struct fuse_bufvec) { \
/* .count= */ 1, \ /* .count= */ 1, \
@ -434,15 +434,15 @@ extern "C" {
} } \ } } \
} ) } )
/**
/**
* Get total size of data in a fuse buffer vector * Get total size of data in a fuse buffer vector
* *
* @param bufv buffer vector * @param bufv buffer vector
* @return size of data * @return size of data
*/ */
size_t fuse_buf_size(const struct fuse_bufvec *bufv);
size_t fuse_buf_size(const struct fuse_bufvec *bufv);
/**
/**
* Copy data from one buffer vector to another * Copy data from one buffer vector to another
* *
* @param dst destination buffer vector * @param dst destination buffer vector
@ -450,14 +450,14 @@ extern "C" {
* @param flags flags controlling the copy * @param flags flags controlling the copy
* @return actual number of bytes copied or -errno on error * @return actual number of bytes copied or -errno on error
*/ */
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
enum fuse_buf_copy_flags flags); enum fuse_buf_copy_flags flags);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Signal handling * * Signal handling *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Exit session on HUP, TERM and INT signals and ignore PIPE signal * Exit session on HUP, TERM and INT signals and ignore PIPE signal
* *
* Stores session in a global variable. May only be called once per * Stores session in a global variable. May only be called once per
@ -466,9 +466,9 @@ extern "C" {
* @param se the session to exit * @param se the session to exit
* @return 0 on success, -1 on failure * @return 0 on success, -1 on failure
*/ */
int fuse_set_signal_handlers(struct fuse_session *se);
int fuse_set_signal_handlers(struct fuse_session *se);
/**
/**
* Restore default signal handlers * Restore default signal handlers
* *
* Resets global session. After this fuse_set_signal_handlers() may * Resets global session. After this fuse_set_signal_handlers() may
@ -476,10 +476,8 @@ extern "C" {
* *
* @param se the same session as given in fuse_set_signal_handlers() * @param se the same session as given in fuse_set_signal_handlers()
*/ */
void fuse_remove_signal_handlers(struct fuse_session *se);
void fuse_remove_signal_handlers(struct fuse_session *se);
#ifdef __cplusplus
}
#endif
EXTERN_C_END
#endif /* _FUSE_COMMON_H_ */ #endif /* _FUSE_COMMON_H_ */

351
libfuse/include/fuse_lowlevel.h
View File

@ -23,6 +23,7 @@
#define FUSE_USE_VERSION 24 #define FUSE_USE_VERSION 24
#endif #endif
#include "extern_c.h"
#include "fuse_common.h" #include "fuse_common.h"
#include <fcntl.h> #include <fcntl.h>
@ -33,51 +34,49 @@
#include <sys/uio.h> #include <sys/uio.h>
#include <utime.h> #include <utime.h>
#ifdef __cplusplus
extern "C" {
#endif
EXTERN_C_BEGIN
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Miscellaneous definitions * * Miscellaneous definitions *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/** The node ID of the root inode */
/** The node ID of the root inode */
#define FUSE_ROOT_ID 1 #define FUSE_ROOT_ID 1
/** Inode number type */
typedef uint64_t fuse_ino_t;
/** Inode number type */
typedef uint64_t fuse_ino_t;
/** Request pointer type */
typedef struct fuse_req *fuse_req_t;
/** Request pointer type */
typedef struct fuse_req *fuse_req_t;
/**
/**
* Session * Session
* *
* This provides hooks for processing requests, and exiting * This provides hooks for processing requests, and exiting
*/ */
struct fuse_session;
struct fuse_session;
/**
/**
* Channel * Channel
* *
* A communication channel, providing hooks for sending and receiving * A communication channel, providing hooks for sending and receiving
* messages * messages
*/ */
struct fuse_chan;
struct fuse_chan;
/** Directory entry parameters supplied to fuse_reply_entry() */
struct fuse_entry_param
{
/** Unique inode number
/** 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) * In lookup, zero means negative entry (from version 2.5)
* Returning ENOENT also means negative entry, but by setting zero * Returning ENOENT also means negative entry, but by setting zero
* ino the kernel may cache negative entries for entry_timeout * ino the kernel may cache negative entries for entry_timeout
* seconds. * seconds.
*/ */
fuse_ino_t ino;
fuse_ino_t ino;
/** Generation number for this entry.
/** Generation number for this entry.
* *
* If the file system will be exported over NFS, the * If the file system will be exported over NFS, the
* ino/generation pairs need to be unique over the file * ino/generation pairs need to be unique over the file
@ -90,48 +89,48 @@ extern "C" {
* it as an error. * it as an error.
* *
*/ */
uint64_t generation;
uint64_t generation;
/** Inode attributes.
/** Inode attributes.
* *
* Even if attr_timeout == 0, attr must be correct. For example, * Even if attr_timeout == 0, attr must be correct. For example,
* for open(), FUSE uses attr.st_size from lookup() to determine * for open(), FUSE uses attr.st_size from lookup() to determine
* how many bytes to request. If this value is not correct, * how many bytes to request. If this value is not correct,
* incorrect data will be returned. * incorrect data will be returned.
*/ */
struct stat attr;
struct stat attr;
fuse_timeouts_t timeout;
};
fuse_timeouts_t timeout;
};
/** Additional context associated with requests */
struct fuse_ctx
{
/** User ID of the calling process */
uid_t uid;
/** Additional context associated with requests */
struct fuse_ctx
{
/** User ID of the calling process */
uid_t uid;
/** Group ID of the calling process */
gid_t gid;
/** Group ID of the calling process */
gid_t gid;
/** Thread ID of the calling process */
pid_t pid;
/** Thread ID of the calling process */
pid_t pid;
/** Umask of the calling process (introduced in version 2.8) */
mode_t umask;
};
/** Umask of the calling process (introduced in version 2.8) */
mode_t umask;
};
struct fuse_forget_data
{
fuse_ino_t ino;
uint64_t nlookup;
};
struct fuse_forget_data
{
fuse_ino_t ino;
uint64_t nlookup;
};
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Request methods and replies * * Request methods and replies *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Low level filesystem operations * Low level filesystem operations
* *
* Most of the methods (with the exception of init and destroy) * Most of the methods (with the exception of init and destroy)
@ -152,9 +151,9 @@ extern "C" {
* fuse_reply_open() return -ENOENT means, that the release method for * fuse_reply_open() return -ENOENT means, that the release method for
* this file will not be called. * this file will not be called.
*/ */
struct fuse_lowlevel_ops
{
/**
struct fuse_lowlevel_ops
{
/**
* Initialize filesystem * Initialize filesystem
* *
* Called before any other filesystem method * Called before any other filesystem method
@ -163,9 +162,9 @@ extern "C" {
* *
* @param userdata the user data passed to fuse_lowlevel_new() * @param userdata the user data passed to fuse_lowlevel_new()
*/ */
void (*init) (void *userdata, struct fuse_conn_info *conn);
void (*init) (void *userdata, struct fuse_conn_info *conn);
/**
/**
* Clean up filesystem * Clean up filesystem
* *
* Called on filesystem exit * Called on filesystem exit
@ -174,9 +173,9 @@ extern "C" {
* *
* @param userdata the user data passed to fuse_lowlevel_new() * @param userdata the user data passed to fuse_lowlevel_new()
*/ */
void (*destroy) (void *userdata);
void (*destroy) (void *userdata);
/**
/**
* Look up a directory entry by name and get its attributes. * Look up a directory entry by name and get its attributes.
* *
* Valid replies: * Valid replies:
@ -187,9 +186,9 @@ extern "C" {
* @param parent inode number of the parent directory * @param parent inode number of the parent directory
* @param name the name to look up * @param name the name to look up
*/ */
void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
/**
/**
* Forget about an inode * Forget about an inode
* *
* This function is called when the kernel removes an inode * This function is called when the kernel removes an inode
@ -1063,9 +1062,9 @@ extern "C" {
struct fuse_file_info *fi_out, struct fuse_file_info *fi_out,
size_t len, size_t len,
int flags); int flags);
};
};
/**
/**
* Reply with an error code or success * Reply with an error code or success
* *
* Possible requests: * Possible requests:
@ -1078,9 +1077,9 @@ extern "C" {
* @param err the positive error value, or zero for success * @param err the positive error value, or zero for success
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_err(fuse_req_t req, int err);
int fuse_reply_err(fuse_req_t req, int err);
/**
/**
* Don't send reply * Don't send reply
* *
* Possible requests: * Possible requests:
@ -1088,9 +1087,9 @@ extern "C" {
* *
* @param req request handle * @param req request handle
*/ */
void fuse_reply_none(fuse_req_t req);
void fuse_reply_none(fuse_req_t req);
/**
/**
* Reply with a directory entry * Reply with a directory entry
* *
* Possible requests: * Possible requests:
@ -1103,9 +1102,9 @@ extern "C" {
* @param e the entry parameters * @param e the entry parameters
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
/**
/**
* Reply with a directory entry and open parameters * Reply with a directory entry and open parameters
* *
* currently the following members of 'fi' are used: * currently the following members of 'fi' are used:
@ -1122,10 +1121,10 @@ extern "C" {
* @param fi file information * @param fi file information
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_create(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); const struct fuse_file_info *fi);
/**
/**
* Reply with attributes * Reply with attributes
* *
* Possible requests: * Possible requests:
@ -1136,11 +1135,11 @@ extern "C" {
* @param attr_timeout validity timeout (in seconds) for the attributes * @param attr_timeout validity timeout (in seconds) for the attributes
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_attr(fuse_req_t req,
int fuse_reply_attr(fuse_req_t req,
const struct stat *attr, const struct stat *attr,
const uint64_t timeout); const uint64_t timeout);
/**
/**
* Reply with the contents of a symbolic link * Reply with the contents of a symbolic link
* *
* Possible requests: * Possible requests:
@ -1150,9 +1149,9 @@ extern "C" {
* @param link symbolic link contents * @param link symbolic link contents
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_readlink(fuse_req_t req, const char *link);
int fuse_reply_readlink(fuse_req_t req, const char *link);
/**
/**
* Reply with open parameters * Reply with open parameters
* *
* currently the following members of 'fi' are used: * currently the following members of 'fi' are used:
@ -1165,9 +1164,9 @@ extern "C" {
* @param fi file information * @param fi file information
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi);
int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi);
/**
/**
* Reply with number of bytes written * Reply with number of bytes written
* *
* Possible requests: * Possible requests:
@ -1177,9 +1176,9 @@ extern "C" {
* @param count the number of bytes written * @param count the number of bytes written
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_write(fuse_req_t req, size_t count);
int fuse_reply_write(fuse_req_t req, size_t count);
/**
/**
* Reply with data * Reply with data
* *
* Possible requests: * Possible requests:
@ -1190,9 +1189,9 @@ extern "C" {
* @param size the size of data in bytes * @param size the size of data in bytes
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
/**
/**
* Reply with data copied/moved from buffer(s) * Reply with data copied/moved from buffer(s)
* *
* Possible requests: * Possible requests:
@ -1203,10 +1202,10 @@ extern "C" {
* @param flags flags controlling the copy * @param flags flags controlling the copy
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags); enum fuse_buf_copy_flags flags);
/**
/**
* Reply with data vector * Reply with data vector
* *
* Possible requests: * Possible requests:
@ -1217,9 +1216,9 @@ extern "C" {
* @param count the size of vector * @param count the size of vector
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count);
int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count);
/**
/**
* Reply with filesystem statistics * Reply with filesystem statistics
* *
* Possible requests: * Possible requests:
@ -1229,9 +1228,9 @@ extern "C" {
* @param stbuf filesystem statistics * @param stbuf filesystem statistics
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf);
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf);
/**
/**
* Reply with needed buffer size * Reply with needed buffer size
* *
* Possible requests: * Possible requests:
@ -1241,9 +1240,9 @@ extern "C" {
* @param count the buffer size needed in bytes * @param count the buffer size needed in bytes
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_xattr(fuse_req_t req, size_t count);
int fuse_reply_xattr(fuse_req_t req, size_t count);
/**
/**
* Reply with file lock information * Reply with file lock information
* *
* Possible requests: * Possible requests:
@ -1253,9 +1252,9 @@ extern "C" {
* @param lock the lock information * @param lock the lock information
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
/**
/**
* Reply with block index * Reply with block index
* *
* Possible requests: * Possible requests:
@ -1265,9 +1264,9 @@ extern "C" {
* @param idx block index within device * @param idx block index within device
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
/**
/**
* Reply to ask for data fetch and output buffer preparation. ioctl * Reply to ask for data fetch and output buffer preparation. ioctl
* will be retried with the specified input data fetched and output * will be retried with the specified input data fetched and output
* buffer prepared. * buffer prepared.
@ -1282,11 +1281,11 @@ extern "C" {
* @param out_count number of entries in out_iov * @param out_count number of entries in out_iov
* @return zero for success, -errno for failure to send reply * @return zero for success, -errno for failure to send reply
*/ */
int fuse_reply_ioctl_retry(fuse_req_t req,
int fuse_reply_ioctl_retry(fuse_req_t req,
const struct iovec *in_iov, size_t in_count, const struct iovec *in_iov, size_t in_count,
const struct iovec *out_iov, size_t out_count); const struct iovec *out_iov, size_t out_count);
/**
/**
* Reply to finish ioctl * Reply to finish ioctl
* *
* Possible requests: * Possible requests:
@ -1297,9 +1296,9 @@ extern "C" {
* @param buf buffer containing output data * @param buf buffer containing output data
* @param size length of output data * @param size length of output data
*/ */
int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, uint32_t size);
int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, uint32_t size);
/**
/**
* Reply to finish ioctl with iov buffer * Reply to finish ioctl with iov buffer
* *
* Possible requests: * Possible requests:
@ -1310,31 +1309,31 @@ extern "C" {
* @param iov the vector containing the data * @param iov the vector containing the data
* @param count the size of vector * @param count the size of vector
*/ */
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
int count); int count);
/**
/**
* Reply with poll result event mask * Reply with poll result event mask
* *
* @param req request handle * @param req request handle
* @param revents poll result event mask * @param revents poll result event mask
*/ */
int fuse_reply_poll(fuse_req_t req, unsigned revents);
int fuse_reply_poll(fuse_req_t req, unsigned revents);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Notification * * Notification *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Notify IO readiness event * Notify IO readiness event
* *
* For more information, please read comment for poll operation. * For more information, please read comment for poll operation.
* *
* @param ph poll handle to notify IO readiness event for * @param ph poll handle to notify IO readiness event for
*/ */
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
/**
/**
* Notify to invalidate cache for an inode * Notify to invalidate cache for an inode
* *
* @param ch the channel through which to send the invalidation * @param ch the channel through which to send the invalidation
@ -1344,10 +1343,10 @@ extern "C" {
* @param len the amount of cache to invalidate or 0 for all * @param len the amount of cache to invalidate or 0 for all
* @return zero for success, -errno for failure * @return zero for success, -errno for failure
*/ */
int fuse_lowlevel_notify_inval_inode(struct fuse_chan *ch, fuse_ino_t ino,
int fuse_lowlevel_notify_inval_inode(struct fuse_chan *ch, fuse_ino_t ino,
off_t off, off_t len); off_t off, off_t len);
/**
/**
* Notify to invalidate parent attributes and the dentry matching * Notify to invalidate parent attributes and the dentry matching
* parent/name * parent/name
* *
@ -1361,10 +1360,10 @@ extern "C" {
* @param namelen strlen() of file name * @param namelen strlen() of file name
* @return zero for success, -errno for failure * @return zero for success, -errno for failure
*/ */
int fuse_lowlevel_notify_inval_entry(struct fuse_chan *ch, fuse_ino_t parent,
int fuse_lowlevel_notify_inval_entry(struct fuse_chan *ch, fuse_ino_t parent,
const char *name, size_t namelen); const char *name, size_t namelen);
/**
/**
* Notify to invalidate parent attributes and delete the dentry matching * Notify to invalidate parent attributes and delete the dentry matching
* parent/name if the dentry's inode number matches child (otherwise it * parent/name if the dentry's inode number matches child (otherwise it
* will invalidate the matching dentry). * will invalidate the matching dentry).
@ -1380,11 +1379,11 @@ extern "C" {
* @param namelen strlen() of file name * @param namelen strlen() of file name
* @return zero for success, -errno for failure * @return zero for success, -errno for failure
*/ */
int fuse_lowlevel_notify_delete(struct fuse_chan *ch,
int fuse_lowlevel_notify_delete(struct fuse_chan *ch,
fuse_ino_t parent, fuse_ino_t child, fuse_ino_t parent, fuse_ino_t child,
const char *name, size_t namelen); const char *name, size_t namelen);
/**
/**
* Store data to the kernel buffers * Store data to the kernel buffers
* *
* Synchronously store data in the kernel buffers belonging to the * Synchronously store data in the kernel buffers belonging to the
@ -1405,10 +1404,10 @@ extern "C" {
* @param flags flags controlling the copy * @param flags flags controlling the copy
* @return zero for success, -errno for failure * @return zero for success, -errno for failure
*/ */
int fuse_lowlevel_notify_store(struct fuse_chan *ch, fuse_ino_t ino,
int fuse_lowlevel_notify_store(struct fuse_chan *ch, fuse_ino_t ino,
off_t offset, struct fuse_bufvec *bufv, off_t offset, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags); enum fuse_buf_copy_flags flags);
/**
/**
* Retrieve data from the kernel buffers * Retrieve data from the kernel buffers
* *
* Retrieve data in the kernel buffers belonging to the given inode. * Retrieve data in the kernel buffers belonging to the given inode.
@ -1433,23 +1432,23 @@ extern "C" {
* @param cookie user data to supply to the reply callback * @param cookie user data to supply to the reply callback
* @return zero for success, -errno for failure * @return zero for success, -errno for failure
*/ */
int fuse_lowlevel_notify_retrieve(struct fuse_chan *ch, fuse_ino_t ino,
int fuse_lowlevel_notify_retrieve(struct fuse_chan *ch, fuse_ino_t ino,
size_t size, off_t offset, void *cookie); size_t size, off_t offset, void *cookie);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Utility functions * * Utility functions *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Get the userdata from the request * Get the userdata from the request
* *
* @param req request handle * @param req request handle
* @return the user data passed to fuse_lowlevel_new() * @return the user data passed to fuse_lowlevel_new()
*/ */
void *fuse_req_userdata(fuse_req_t req);
void *fuse_req_userdata(fuse_req_t req);
/**
/**
* Get the context from the request * Get the context from the request
* *
* The pointer returned by this function will only be valid for the * The pointer returned by this function will only be valid for the
@ -1458,9 +1457,9 @@ extern "C" {
* @param req request handle * @param req request handle
* @return the context structure * @return the context structure
*/ */
const struct fuse_ctx *fuse_req_ctx(fuse_req_t req);
const struct fuse_ctx *fuse_req_ctx(fuse_req_t req);
/**
/**
* Get the current supplementary group IDs for the specified request * Get the current supplementary group IDs for the specified request
* *
* Similar to the getgroups(2) system call, except the return value is * Similar to the getgroups(2) system call, except the return value is
@ -1479,17 +1478,17 @@ extern "C" {
* @param list array of group IDs to be filled in * @param list array of group IDs to be filled in
* @return the total number of supplementary group IDs or -errno on failure * @return the total number of supplementary group IDs or -errno on failure
*/ */
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
/**
/**
* Callback function for an interrupt * Callback function for an interrupt
* *
* @param req interrupted request * @param req interrupted request
* @param data user data * @param data user data
*/ */
typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
/**
/**
* Register/unregister callback for an interrupt * Register/unregister callback for an interrupt
* *
* If an interrupt has already happened, then the callback function is * If an interrupt has already happened, then the callback function is
@ -1500,25 +1499,25 @@ extern "C" {
* @param func the callback function or NULL for unregister * @param func the callback function or NULL for unregister
* @param data user data passed to the callback function * @param data user data passed to the callback function
*/ */
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
void *data); void *data);
/**
/**
* Check if a request has already been interrupted * Check if a request has already been interrupted
* *
* @param req request handle * @param req request handle
* @return 1 if the request has been interrupted, 0 otherwise * @return 1 if the request has been interrupted, 0 otherwise
*/ */
int fuse_req_interrupted(fuse_req_t req);
int fuse_req_interrupted(fuse_req_t req);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Filesystem setup * * Filesystem setup *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/* Deprecated, don't use */
int fuse_lowlevel_is_lib_option(const char *opt);
/* Deprecated, don't use */
int fuse_lowlevel_is_lib_option(const char *opt);
/**
/**
* Create a low level session * Create a low level session
* *
* @param args argument vector * @param args argument vector
@ -1527,21 +1526,21 @@ extern "C" {
* @param userdata user data * @param userdata user data
* @return the created session object, or NULL on failure * @return the created session object, or NULL on failure
*/ */
struct fuse_session *fuse_lowlevel_new(struct fuse_args *args,
struct fuse_session *fuse_lowlevel_new(struct fuse_args *args,
const struct fuse_lowlevel_ops *op, const struct fuse_lowlevel_ops *op,
size_t op_size, void *userdata); size_t op_size, void *userdata);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Session interface * * Session interface *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Session operations * Session operations
* *
* This is used in session creation * This is used in session creation
*/ */
struct fuse_session_ops
{
struct fuse_session_ops
{
/** /**
* Hook to process a request (mandatory) * Hook to process a request (mandatory)
* *
@ -1575,18 +1574,18 @@ extern "C" {
* @param data user data passed to fuse_session_new() * @param data user data passed to fuse_session_new()
*/ */
void (*destroy) (void *data); void (*destroy) (void *data);
};
};
/**
/**
* Create a new session * Create a new session
* *
* @param op session operations * @param op session operations
* @param data user data * @param data user data
* @return new session object, or NULL on failure * @return new session object, or NULL on failure
*/ */
struct fuse_session *fuse_session_new(struct fuse_session_ops *op, void *data);
struct fuse_session *fuse_session_new(struct fuse_session_ops *op, void *data);
/**
/**
* Assign a channel to a session * Assign a channel to a session
* *
* Note: currently only a single channel may be assigned. This may * Note: currently only a single channel may be assigned. This may
@ -1597,18 +1596,18 @@ extern "C" {
* @param se the session * @param se the session
* @param ch the channel * @param ch the channel
*/ */
void fuse_session_add_chan(struct fuse_session *se, struct fuse_chan *ch);
void fuse_session_add_chan(struct fuse_session *se, struct fuse_chan *ch);
/**
/**
* Remove a channel from a session * Remove a channel from a session
* *
* If the channel is not assigned to a session, then this is a no-op * If the channel is not assigned to a session, then this is a no-op
* *
* @param ch the channel to remove * @param ch the channel to remove
*/ */
void fuse_session_remove_chan(struct fuse_chan *ch);
void fuse_session_remove_chan(struct fuse_chan *ch);
/**
/**
* Iterate over the channels assigned to a session * Iterate over the channels assigned to a session
* *
* The iterating function needs to start with a NULL channel, and * The iterating function needs to start with a NULL channel, and
@ -1619,10 +1618,10 @@ extern "C" {
* @param ch the previous channel, or NULL * @param ch the previous channel, or NULL
* @return the next channel, or NULL if no more channels exist * @return the next channel, or NULL if no more channels exist
*/ */
struct fuse_chan *fuse_session_next_chan(struct fuse_session *se,
struct fuse_chan *fuse_session_next_chan(struct fuse_session *se,
struct fuse_chan *ch); struct fuse_chan *ch);
/**
/**
* Process a raw request * Process a raw request
* *
* @param se the session * @param se the session
@ -1630,10 +1629,10 @@ extern "C" {
* @param len request length * @param len request length
* @param ch channel on which the request was received * @param ch channel on which the request was received
*/ */
void fuse_session_process(struct fuse_session *se, const char *buf, size_t len,
void fuse_session_process(struct fuse_session *se, const char *buf, size_t len,
struct fuse_chan *ch); struct fuse_chan *ch);
/**
/**
* Process a raw request supplied in a generic buffer * Process a raw request supplied in a generic buffer
* *
* This is a more generic version of fuse_session_process(). The * This is a more generic version of fuse_session_process(). The
@ -1643,10 +1642,10 @@ extern "C" {
* @param buf the fuse_buf containing the request * @param buf the fuse_buf containing the request
* @param ch channel on which the request was received * @param ch channel on which the request was received
*/ */
void fuse_session_process_buf(struct fuse_session *se,
void fuse_session_process_buf(struct fuse_session *se,
const struct fuse_buf *buf, struct fuse_chan *ch); const struct fuse_buf *buf, struct fuse_chan *ch);
/**
/**
* Receive a raw request supplied in a generic buffer * Receive a raw request supplied in a generic buffer
* *
* This is a more generic version of fuse_chan_recv(). The fuse_buf * This is a more generic version of fuse_chan_recv(). The fuse_buf
@ -1658,65 +1657,65 @@ extern "C" {
* @param chp pointer to the channel * @param chp pointer to the channel
* @return the actual size of the raw request, or -errno on error * @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,
int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
struct fuse_chan **chp); struct fuse_chan **chp);
/**
/**
* Destroy a session * Destroy a session
* *
* @param se the session * @param se the session
*/ */
void fuse_session_destroy(struct fuse_session *se);
void fuse_session_destroy(struct fuse_session *se);
/**
/**
* Exit a session * Exit a session
* *
* @param se the session * @param se the session
*/ */
void fuse_session_exit(struct fuse_session *se);
void fuse_session_exit(struct fuse_session *se);
/**
/**
* Reset the exited status of a session * Reset the exited status of a session
* *
* @param se the session * @param se the session
*/ */
void fuse_session_reset(struct fuse_session *se);
void fuse_session_reset(struct fuse_session *se);
/**
/**
* Query the exited status of a session * Query the exited status of a session
* *
* @param se the session * @param se the session
* @return 1 if exited, 0 if not exited * @return 1 if exited, 0 if not exited
*/ */
int fuse_session_exited(struct fuse_session *se);
int fuse_session_exited(struct fuse_session *se);
/**
/**
* Get the user data provided to the session * Get the user data provided to the session
* *
* @param se the session * @param se the session
* @return the user data * @return the user data
*/ */
void *fuse_session_data(struct fuse_session *se);
void *fuse_session_data(struct fuse_session *se);
/**
/**
* Enter a multi-threaded event loop * Enter a multi-threaded event loop
* *
* @param se the session * @param se the session
* @return 0 on success, -1 on error * @return 0 on success, -1 on error
*/ */
int fuse_session_loop_mt(struct fuse_session *se, const int threads);
int fuse_session_loop_mt(struct fuse_session *se, const int threads);
/* ----------------------------------------------------------- *
/* ----------------------------------------------------------- *
* Channel interface * * Channel interface *
* ----------------------------------------------------------- */ * ----------------------------------------------------------- */
/**
/**
* Channel operations * Channel operations
* *
* This is used in channel creation * This is used in channel creation
*/ */
struct fuse_chan_ops
{
struct fuse_chan_ops
{
/** /**
* Hook for receiving a raw request * Hook for receiving a raw request
* *
@ -1747,9 +1746,9 @@ extern "C" {
* @param ch the channel * @param ch the channel
*/ */
void (*destroy)(struct fuse_chan *ch); void (*destroy)(struct fuse_chan *ch);
};
};
/**
/**
* Create a new channel * Create a new channel
* *
* @param op channel operations * @param op channel operations
@ -1758,42 +1757,42 @@ extern "C" {
* @param data user data * @param data user data
* @return the new channel object, or NULL on failure * @return the new channel object, or NULL on failure
*/ */
struct fuse_chan *fuse_chan_new(struct fuse_chan_ops *op, int fd,
struct fuse_chan *fuse_chan_new(struct fuse_chan_ops *op, int fd,
size_t bufsize, void *data); size_t bufsize, void *data);
/**
/**
* Query the file descriptor of the channel * Query the file descriptor of the channel
* *
* @param ch the channel * @param ch the channel
* @return the file descriptor passed to fuse_chan_new() * @return the file descriptor passed to fuse_chan_new()
*/ */
int fuse_chan_fd(struct fuse_chan *ch);
int fuse_chan_fd(struct fuse_chan *ch);
/**
/**
* Query the minimal receive buffer size * Query the minimal receive buffer size
* *
* @param ch the channel * @param ch the channel
* @return the buffer size passed to fuse_chan_new() * @return the buffer size passed to fuse_chan_new()
*/ */
size_t fuse_chan_bufsize(struct fuse_chan *ch);
size_t fuse_chan_bufsize(struct fuse_chan *ch);
/**
/**
* Query the user data * Query the user data
* *
* @param ch the channel * @param ch the channel
* @return the user data passed to fuse_chan_new() * @return the user data passed to fuse_chan_new()
*/ */
void *fuse_chan_data(struct fuse_chan *ch);
void *fuse_chan_data(struct fuse_chan *ch);
/**
/**
* Query the session to which this channel is assigned * Query the session to which this channel is assigned
* *
* @param ch the channel * @param ch the channel
* @return the session, or NULL if the channel is not assigned * @return the session, or NULL if the channel is not assigned
*/ */
struct fuse_session *fuse_chan_session(struct fuse_chan *ch);
struct fuse_session *fuse_chan_session(struct fuse_chan *ch);
/**
/**
* Receive a raw request * Receive a raw request
* *
* A return value of -ENODEV means, that the filesystem was unmounted * A return value of -ENODEV means, that the filesystem was unmounted
@ -1803,9 +1802,9 @@ extern "C" {
* @param size the size of the buffer * @param size the size of the buffer
* @return the actual size of the raw request, or -errno on error * @return the actual size of the raw request, or -errno on error
*/ */
int fuse_chan_recv(struct fuse_chan **ch, char *buf, size_t size);
int fuse_chan_recv(struct fuse_chan **ch, char *buf, size_t size);
/**
/**
* Send a raw reply * Send a raw reply
* *
* A return value of -ENOENT means, that the request was * A return value of -ENOENT means, that the request was
@ -1816,18 +1815,16 @@ extern "C" {
* @param count the number of blocks in vector * @param count the number of blocks in vector
* @return zero on success, -errno on failure * @return zero on success, -errno on failure
*/ */
int fuse_chan_send(struct fuse_chan *ch, const struct iovec iov[],
int fuse_chan_send(struct fuse_chan *ch, const struct iovec iov[],
size_t count); size_t count);
/**
/**
* Destroy a channel * Destroy a channel
* *
* @param ch the channel * @param ch the channel
*/ */
void fuse_chan_destroy(struct fuse_chan *ch);
void fuse_chan_destroy(struct fuse_chan *ch);
#ifdef __cplusplus
}
#endif
EXTERN_C_END
#endif /* _FUSE_LOWLEVEL_H_ */ #endif /* _FUSE_LOWLEVEL_H_ */

72
libfuse/include/fuse_opt.h
View File

@ -9,16 +9,16 @@
#ifndef _FUSE_OPT_H_ #ifndef _FUSE_OPT_H_
#define _FUSE_OPT_H_ #define _FUSE_OPT_H_
#include "extern_c.h"
/** @file /** @file
* *
* This file defines the option parsing interface of FUSE * This file defines the option parsing interface of FUSE
*/ */
#ifdef __cplusplus
extern "C" {
#endif
EXTERN_C_BEGIN
/**
/**
* Option description * Option description
* *
* This structure describes a single option, and action associated * This structure describes a single option, and action associated
@ -73,8 +73,8 @@ extern "C" {
* If the format is "%s", memory is allocated for the string unlike * If the format is "%s", memory is allocated for the string unlike
* with scanf(). * with scanf().
*/ */
struct fuse_opt
{
struct fuse_opt
{
/** Matching template and optional parameter formatting */ /** Matching template and optional parameter formatting */
const char *templ; const char *templ;
@ -89,25 +89,25 @@ extern "C" {
* processing function. Ignored if template has a format * processing function. Ignored if template has a format
*/ */
int value; int value;
};
};
/**
/**
* Key option. In case of a match, the processing function will be * Key option. In case of a match, the processing function will be
* called with the specified key. * called with the specified key.
*/ */
#define FUSE_OPT_KEY(templ, key) { templ, -1U, key } #define FUSE_OPT_KEY(templ, key) { templ, -1U, key }
/**
/**
* Last option. An array of 'struct fuse_opt' must end with a NULL * Last option. An array of 'struct fuse_opt' must end with a NULL
* template value * template value
*/ */
#define FUSE_OPT_END { NULL, 0, 0 } #define FUSE_OPT_END { NULL, 0, 0 }
/**
/**
* Argument list * Argument list
*/ */
struct fuse_args
{
struct fuse_args
{
/** Argument count */ /** Argument count */
int argc; int argc;
@ -116,20 +116,20 @@ extern "C" {
/** Is 'argv' allocated? */ /** Is 'argv' allocated? */
int allocated; int allocated;
};
};
/**
/**
* Initializer for 'struct fuse_args' * Initializer for 'struct fuse_args'
*/ */
#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 } #define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 }
/**
/**
* Key value passed to the processing function if an option did not * Key value passed to the processing function if an option did not
* match any template * match any template
*/ */
#define FUSE_OPT_KEY_OPT -1 #define FUSE_OPT_KEY_OPT -1
/**
/**
* Key value passed to the processing function for all non-options * Key value passed to the processing function for all non-options
* *
* Non-options are the arguments beginning with a character other than * Non-options are the arguments beginning with a character other than
@ -137,7 +137,7 @@ extern "C" {
*/ */
#define FUSE_OPT_KEY_NONOPT -2 #define FUSE_OPT_KEY_NONOPT -2
/**
/**
* Special key value for options to keep * Special key value for options to keep
* *
* Argument is not passed to processing function, but behave as if the * Argument is not passed to processing function, but behave as if the
@ -145,7 +145,7 @@ extern "C" {
*/ */
#define FUSE_OPT_KEY_KEEP -3 #define FUSE_OPT_KEY_KEEP -3
/**
/**
* Special key value for options to discard * Special key value for options to discard
* *
* Argument is not passed to processing function, but behave as if the * Argument is not passed to processing function, but behave as if the
@ -153,7 +153,7 @@ extern "C" {
*/ */
#define FUSE_OPT_KEY_DISCARD -4 #define FUSE_OPT_KEY_DISCARD -4
/**
/**
* Processing function * Processing function
* *
* This function is called if * This function is called if
@ -178,10 +178,10 @@ extern "C" {
* @param outargs the current output argument list * @param outargs the current output argument list
* @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
*/ */
typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
struct fuse_args *outargs); struct fuse_args *outargs);
/**
/**
* Option parsing function * Option parsing function
* *
* If 'args' was returned from a previous call to fuse_opt_parse() or * If 'args' was returned from a previous call to fuse_opt_parse() or
@ -201,37 +201,37 @@ extern "C" {
* @param proc is the processing function * @param proc is the processing function
* @return -1 on error, 0 on success * @return -1 on error, 0 on success
*/ */
int fuse_opt_parse(struct fuse_args *args, void *data,
int fuse_opt_parse(struct fuse_args *args, void *data,
const struct fuse_opt opts[], fuse_opt_proc_t proc); const struct fuse_opt opts[], fuse_opt_proc_t proc);
/**
/**
* Add an option to a comma separated option list * Add an option to a comma separated option list
* *
* @param opts is a pointer to an option list, may point to a NULL value * @param opts is a pointer to an option list, may point to a NULL value
* @param opt is the option to add * @param opt is the option to add
* @return -1 on allocation error, 0 on success * @return -1 on allocation error, 0 on success
*/ */
int fuse_opt_add_opt(char **opts, const char *opt);
int fuse_opt_add_opt(char **opts, const char *opt);
/**
/**
* Add an option, escaping commas, to a comma separated option list * Add an option, escaping commas, to a comma separated option list
* *
* @param opts is a pointer to an option list, may point to a NULL value * @param opts is a pointer to an option list, may point to a NULL value
* @param opt is the option to add * @param opt is the option to add
* @return -1 on allocation error, 0 on success * @return -1 on allocation error, 0 on success
*/ */
int fuse_opt_add_opt_escaped(char **opts, const char *opt);
int fuse_opt_add_opt_escaped(char **opts, const char *opt);
/**
/**
* Add an argument to a NULL terminated argument vector * Add an argument to a NULL terminated argument vector
* *
* @param args is the structure containing the current argument list * @param args is the structure containing the current argument list
* @param arg is the new argument to add * @param arg is the new argument to add
* @return -1 on allocation error, 0 on success * @return -1 on allocation error, 0 on success
*/ */
int fuse_opt_add_arg(struct fuse_args *args, const char *arg);
int fuse_opt_add_arg(struct fuse_args *args, const char *arg);
/**
/**
* Add an argument at the specified position in a NULL terminated * Add an argument at the specified position in a NULL terminated
* argument vector * argument vector
* *
@ -244,29 +244,27 @@ extern "C" {
* @param arg is the new argument to add * @param arg is the new argument to add
* @return -1 on allocation error, 0 on success * @return -1 on allocation error, 0 on success
*/ */
int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg);
int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg);
/**
/**
* Free the contents of argument list * Free the contents of argument list
* *
* The structure itself is not freed * The structure itself is not freed
* *
* @param args is the structure containing the argument list * @param args is the structure containing the argument list
*/ */
void fuse_opt_free_args(struct fuse_args *args);
void fuse_opt_free_args(struct fuse_args *args);
/**
/**
* Check if an option matches * Check if an option matches
* *
* @param opts is the option description array * @param opts is the option description array
* @param opt is the option to match * @param opt is the option to match
* @return 1 if a match is found, 0 if not * @return 1 if a match is found, 0 if not
*/ */
int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
#ifdef __cplusplus
}
#endif
EXTERN_C_END
#endif /* _FUSE_OPT_H_ */ #endif /* _FUSE_OPT_H_ */

24
libfuse/include/ulockmgr.h
View File

@ -1,24 +0,0 @@
/*
libulockmgr: Userspace Lock Manager Library
Copyright (C) 2006 Miklos Szeredi <miklos@szeredi.hu>
This program can be distributed under the terms of the GNU LGPLv2.
See the file COPYING.LIB.
*/
#include <stdint.h>
#include <fcntl.h>
#include <sys/types.h>
/**
* Perform POSIX locking operation
*
* @param fd the file descriptor
* @param cmd the locking command (F_GETFL, F_SETLK or F_SETLKW)
* @param lock the lock parameters
* @param owner the lock owner ID cookie
* @param owner_len length of the lock owner ID cookie
* @return 0 on success -errno on error
*/
int ulockmgr_op(int fd, int cmd, struct flock *lock, const void *owner,
size_t owner_len);
Write Preview
Loading…
Cancel
Save