fuse
|
#include "fuse_common.h"
#include <fcntl.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/uio.h>
Data Structures | |
struct | fuse_operations |
struct | fuse_context |
Macros | |
#define | fuse_main(argc, argv, op, user_data) fuse_main_real(argc, argv, op, sizeof(*(op)), user_data) |
#define | FUSE_REGISTER_MODULE(name_, factory_) fuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_; |
Typedefs | |
typedef int(* | fuse_fill_dir_t )(void *buf, const char *name, const struct stat *stbuf, off_t off, enum fuse_fill_dir_flags flags) |
typedef struct fuse_fs *(* | fuse_module_factory_t )(struct fuse_args *args, struct fuse_fs *fs[]) |
Enumerations | |
enum | fuse_readdir_flags { FUSE_READDIR_PLUS = (1 << 0) } |
enum | fuse_fill_dir_flags { FUSE_FILL_DIR_PLUS = (1 << 1) } |
Functions | |
struct fuse * | fuse_new (struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *user_data) |
int | fuse_mount (struct fuse *f, const char *mountpoint) |
void | fuse_unmount (struct fuse *f) |
void | fuse_destroy (struct fuse *f) |
int | fuse_loop (struct fuse *f) |
void | fuse_exit (struct fuse *f) |
int | fuse_loop_mt (struct fuse *f) |
struct fuse_context * | fuse_get_context (void) |
int | fuse_getgroups (int size, gid_t list[]) |
int | fuse_interrupted (void) |
int | fuse_main_real (int argc, char *argv[], const struct fuse_operations *op, size_t op_size, void *user_data) |
int | fuse_start_cleanup_thread (struct fuse *fuse) |
void | fuse_stop_cleanup_thread (struct fuse *fuse) |
int | fuse_clean_cache (struct fuse *fuse) |
struct fuse_fs * | fuse_fs_new (const struct fuse_operations *op, size_t op_size, void *user_data) |
struct fuse_session * | fuse_get_session (struct fuse *f) |
This file defines the library interface of FUSE
IMPORTANT: you should define FUSE_USE_VERSION before including this header.
#define fuse_main | ( | argc, | |
argv, | |||
op, | |||
user_data | |||
) | fuse_main_real(argc, argv, op, sizeof(*(op)), user_data) |
Main function of FUSE.
This is for the lazy. This is all that has to be called from the main() function.
This function does the following:
Note: this is currently implemented as a macro.
argc | the argument counter passed to the main() function |
argv | the argument vector passed to the main() function |
op | the file system operation |
user_data | user data supplied in the context during the init() method |
Example usage, see hello.c
#define FUSE_REGISTER_MODULE | ( | name_, | |
factory_ | |||
) | fuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_; |
Register filesystem module
If the "-omodules=@name_:..." option is present, filesystem objects are created and pushed onto the stack with the function.
the name of this filesystem module the factory function for this filesystem module
typedef int(* fuse_fill_dir_t)(void *buf, const char *name, const struct stat *stbuf, off_t off, enum fuse_fill_dir_flags flags) |
Function to add an entry in a readdir() operation
buf | the buffer passed to the readdir() operation |
name | the file name of the directory entry |
stat | file attributes, can be NULL |
off | offset of the next entry or zero |
flags | fill flags |
typedef struct fuse_fs*(* fuse_module_factory_t)(struct fuse_args *args, struct fuse_fs *fs[]) |
Factory for creating filesystem objects
The function may use and remove options from 'args' that belong to this module.
For now the 'fs' vector always contains exactly one filesystem. This is the filesystem which will be below the newly created filesystem in the stack.
args | the command line arguments |
fs | NULL terminated filesystem object vector |
enum fuse_fill_dir_flags |
enum fuse_readdir_flags |
Readdir flags, passed to ->readdir()
int fuse_clean_cache | ( | struct fuse * | fuse | ) |
Iterate over cache removing stale entries use in conjunction with "-oremember"
NOTE: This is already done for the standard sessions
fuse | struct fuse pointer for fuse instance |
void fuse_destroy | ( | struct fuse * | f | ) |
Destroy the FUSE handle.
NOTE: This function does not unmount the filesystem. If this is needed, call fuse_unmount() before calling this function.
f | the FUSE handle |
void fuse_exit | ( | struct fuse * | f | ) |
Flag session as terminated
This function will cause any running event loops to exit on the next opportunity.
f | the FUSE handle |
struct fuse_fs* fuse_fs_new | ( | const struct fuse_operations * | op, |
size_t | op_size, | ||
void * | user_data | ||
) |
Create a new fuse filesystem object
This is usually called from the factory of a fuse module to create a new instance of a filesystem.
op | the filesystem operations |
op_size | the size of the fuse_operations structure |
user_data | user data supplied in the context during the init() method |
struct fuse_context* fuse_get_context | ( | void | ) |
Get the current context
The context is only valid for the duration of a filesystem operation, and thus must not be stored and used later.
struct fuse_session* fuse_get_session | ( | struct fuse * | f | ) |
Get session from fuse object
int fuse_getgroups | ( | int | size, |
gid_t | list[] | ||
) |
Get the current supplementary group IDs for the current request
Similar to the getgroups(2) system call, except the return value is always the total number of group IDs, even if it is larger than the specified size.
The current fuse kernel module in linux (as of 2.6.30) doesn't pass the group list to userspace, hence this function needs to parse "/proc/$TID/task/$TID/status" to get the group IDs.
This feature may not be supported on all operating systems. In such a case this function will return -ENOSYS.
size | size of given array |
list | array of group IDs to be filled in |
int fuse_interrupted | ( | void | ) |
Check if the current request has already been interrupted
int fuse_loop | ( | struct fuse * | f | ) |
FUSE event loop.
Requests from the kernel are processed, and the appropriate operations are called.
f | the FUSE handle |
See also: fuse_loop()
int fuse_loop_mt | ( | struct fuse * | f | ) |
FUSE event loop with multiple threads
Requests from the kernel are processed, and the appropriate operations are called. Request are processed in parallel by distributing them between multiple threads.
Calling this function requires the pthreads library to be linked to the application.
Note: using fuse_loop() instead of fuse_loop_mt() means you are running in single-threaded mode, and that you will not have to worry about reentrancy, though you will have to worry about recursive lookups. In single-threaded mode, FUSE will wait for one callback to return before calling another.
Enabling multiple threads, by using fuse_loop_mt(), will cause FUSE to make multiple simultaneous calls into the various callback functions given by your fuse_operations record.
If you are using multiple threads, you can enjoy all the parallel execution and interactive response benefits of threads, and you get to enjoy all the benefits of race conditions and locking bugs, too. Ensure that any code used in the callback function of fuse_operations is also thread-safe.
f | the FUSE handle |
See also: fuse_loop()
int fuse_main_real | ( | int | argc, |
char * | argv[], | ||
const struct fuse_operations * | op, | ||
size_t | op_size, | ||
void * | user_data | ||
) |
The real main function
Do not call this directly, use fuse_main()
int fuse_mount | ( | struct fuse * | f, |
const char * | mountpoint | ||
) |
Mount a FUSE file system.
mountpoint | the mount point path |
f | the FUSE handle |
struct fuse* fuse_new | ( | struct fuse_args * | args, |
const struct fuse_operations * | op, | ||
size_t | op_size, | ||
void * | user_data | ||
) |
Create a new FUSE filesystem.
Known options are defined in struct fuse_opt fuse_lib_opts[]
, struct fuse_opt fuse_mount_opts[]
, and struct fuse_opt fuse_ll_opts[]
. If not all options are known, an error message is written to stderr and the function returns NULL.
If the –help option is specified, the function writes a help text to stdout and returns NULL.
args | argument vector |
op | the filesystem operations |
op_size | the size of the fuse_operations structure |
user_data | user data supplied in the context during the init() method |
int fuse_start_cleanup_thread | ( | struct fuse * | fuse | ) |
Start the cleanup thread when using option "remember".
This is done automatically by fuse_loop_mt()
fuse | struct fuse pointer for fuse instance |
void fuse_stop_cleanup_thread | ( | struct fuse * | fuse | ) |
Stop the cleanup thread when using option "remember".
This is done automatically by fuse_loop_mt()
fuse | struct fuse pointer for fuse instance |
void fuse_unmount | ( | struct fuse * | f | ) |
Unmount a FUSE file system.
f | the FUSE handle |