github-mirror/mergerfs
2
0
Fork 0
mirror of https://github.com/trapexit/mergerfs.git synced 2025-06-18 18:36:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move fuse.c and fuse_lowlevel.c to C++

Browse Source
This commit is contained in:
Antonio SJ Musumeci
2024-04-15 19:12:08 -05:00
parent 5e584f246a
commit 9056898bbf
10 changed files with 403 additions and 1190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libfuse/Makefile
View File

@ -71,6 +71,8 @@ CFLAGS := \
-Wall \ -Wall \
-pipe \ -pipe \
-MMD -MMD
CXXFLAGS ?= \
$(OPT_FLAGS)
CXXFLAGS := \ CXXFLAGS := \
${CXXFLAGS} \ ${CXXFLAGS} \
$(LTO_FLAGS) \ $(LTO_FLAGS) \

2
libfuse/include/fuse_kernel.h
View File

@ -442,7 +442,7 @@ struct fuse_file_lock {
#define FUSE_HANDLE_KILLPRIV_V2 (1 << 28) #define FUSE_HANDLE_KILLPRIV_V2 (1 << 28)
#define FUSE_SETXATTR_EXT (1 << 29) #define FUSE_SETXATTR_EXT (1 << 29)
#define FUSE_INIT_EXT (1 << 30) #define FUSE_INIT_EXT (1 << 30)
#define FUSE_INIT_RESERVED (1 << 31) #define FUSE_INIT_RESERVED (1ULL << 31)
/* bits 32..63 get shifted down 32 bits into the flags2 field */ /* bits 32..63 get shifted down 32 bits into the flags2 field */
#define FUSE_SECURITY_CTX (1ULL << 32) #define FUSE_SECURITY_CTX (1ULL << 32)
#define FUSE_HAS_INODE_DAX (1ULL << 33) #define FUSE_HAS_INODE_DAX (1ULL << 33)

932
libfuse/include/fuse_lowlevel.h
View File

@ -131,891 +131,55 @@ struct fuse_ctx
*/ */
struct fuse_lowlevel_ops struct fuse_lowlevel_ops
{ {
/** void (*access)(fuse_req_t req, struct fuse_in_header *hdr);
* Initialize filesystem void (*bmap)(fuse_req_t req, const struct fuse_in_header *hdr);
* void (*copy_file_range)(fuse_req_t req, const struct fuse_in_header *hdr);
* Called before any other filesystem method void (*create)(fuse_req_t req, struct fuse_in_header *hdr);
*
* There's no reply to this function
*
* @param userdata the user data passed to fuse_lowlevel_new()
*/
void (*init)(void *userdata, struct fuse_conn_info *conn);
/**
* Clean up filesystem
*
* Called on filesystem exit
*
* There's no reply to this function
*
* @param userdata the user data passed to fuse_lowlevel_new()
*/
void (*destroy)(void *userdata); void (*destroy)(void *userdata);
void (*fallocate)(fuse_req_t req, const struct fuse_in_header *hdr);
/** void (*flock)(fuse_req_t req, uint64_t ino, fuse_file_info_t *fi, int op);
* Look up a directory entry by name and get its attributes. void (*flush)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*forget)(fuse_req_t req, struct fuse_in_header *hdr);
* Valid replies: void (*forget_multi)(fuse_req_t req, struct fuse_in_header *hdr);
* fuse_reply_entry void (*fsync)(fuse_req_t req, struct fuse_in_header *hdr);
* fuse_reply_err void (*fsyncdir)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*getattr)(fuse_req_t req, struct fuse_in_header *hdr);
* @param req request handle void (*getlk)(fuse_req_t req, const struct fuse_in_header *hdr);
* @param parent inode number of the parent directory void (*getxattr)(fuse_req_t req, struct fuse_in_header *hdr);
* @param name the name to look up void (*init)(void *userdata, struct fuse_conn_info *conn);
*/ void (*ioctl)(fuse_req_t req, const struct fuse_in_header *hdr);
void (*lookup)(fuse_req_t req, void (*link)(fuse_req_t req, struct fuse_in_header *hdr);
struct fuse_in_header *hdr); void (*listxattr)(fuse_req_t req, struct fuse_in_header *hdr);
void (*lookup)(fuse_req_t req, struct fuse_in_header *hdr);
/** void (*lseek)(fuse_req_t req, struct fuse_in_header *hdr);
* Forget about an inode void (*mkdir)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*mknod)(fuse_req_t req, struct fuse_in_header *hdr);
* This function is called when the kernel removes an inode void (*open)(fuse_req_t req, struct fuse_in_header *hdr);
* from its internal caches. void (*opendir)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*poll)(fuse_req_t req, const struct fuse_in_header *hdr);
* The inode's lookup count increases by one for every call to void (*read)(fuse_req_t req, struct fuse_in_header *hdr);
* fuse_reply_entry and fuse_reply_create. The nlookup parameter void (*readdir)(fuse_req_t req, struct fuse_in_header *hdr);
* indicates by how much the lookup count should be decreased. void (*readdir_plus)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*readlink)(fuse_req_t req, struct fuse_in_header *hdr);
* Inodes with a non-zero lookup count may receive request from void (*release)(fuse_req_t req, struct fuse_in_header *hdr);
* the kernel even after calls to unlink, rmdir or (when void (*releasedir)(fuse_req_t req, struct fuse_in_header *hdr);
* overwriting an existing file) rename. Filesystems must handle void (*removemapping)(fuse_req_t req, const struct fuse_in_header *hdr);
* such requests properly and it is recommended to defer removal void (*removexattr)(fuse_req_t req, const struct fuse_in_header *hdr);
* of the inode until the lookup count reaches zero. Calls to void (*rename)(fuse_req_t req, struct fuse_in_header *hdr);
* unlink, remdir or rename will be followed closely by forget void (*rename2)(fuse_req_t req, struct fuse_in_header *hdr);
* unless the file or directory is open, in which case the void (*retrieve_reply)(fuse_req_t req, void *cookie, uint64_t ino, off_t offset);
* kernel issues forget only after the release or releasedir void (*rmdir)(fuse_req_t req, struct fuse_in_header *hdr);
* calls. void (*setattr)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*setlk)(fuse_req_t req, uint64_t ino, fuse_file_info_t *fi, struct flock *lock, int sleep);
* Note that if a file system will be exported over NFS the void (*setupmapping)(fuse_req_t req, const struct fuse_in_header *hdr);
* inodes lifetime must extend even beyond forget. See the void (*setxattr)(fuse_req_t req, struct fuse_in_header *hdr);
* generation field in struct fuse_entry_param above. void (*statfs)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*statx)(fuse_req_t req, struct fuse_in_header *hdr);
* On unmount the lookup count for all inodes implicitly drops void (*symlink)(fuse_req_t req, struct fuse_in_header *hdr);
* to zero. It is not guaranteed that the file system will void (*syncfs)(fuse_req_t req, const struct fuse_in_header *hdr);
* receive corresponding forget messages for the affected void (*tmpfile)(fuse_req_t req, const struct fuse_in_header *hdr);
* inodes. void (*unlink)(fuse_req_t req, struct fuse_in_header *hdr);
* void (*write)(fuse_req_t req, struct fuse_in_header *hdr);
* Valid replies:
* fuse_reply_none
*
* @param req request handle
* @param ino the inode number
* @param nlookup the number of lookups to forget
*/
void (*forget)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Get file attributes
*
* Valid replies:
* fuse_reply_attr
* fuse_reply_err
*/
void (*getattr)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Set file attributes
*
* In the 'attr' argument only members indicated by the 'to_set'
* bitmask contain valid values. Other members contain undefined
* values.
*
* If the setattr was invoked from the ftruncate() system call
* under Linux kernel versions 2.6.15 or later, the fi->fh will
* contain the value set by the open method or will be undefined
* if the open method didn't set any value. Otherwise (not
* ftruncate call, or kernel version earlier than 2.6.15) the fi
* parameter will be NULL.
*
* Valid replies:
* fuse_reply_attr
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param attr the attributes
* @param to_set bit mask of attributes which should be set
* @param fi file information, or NULL
*
* Changed in version 2.5:
* file information filled in for ftruncate
*/
void (*setattr)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Read symbolic link
*
* Valid replies:
* fuse_reply_readlink
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
*/
void (*readlink)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Create file node
*
* Create a regular file, character device, block device, fifo or
* socket node.
*
* Valid replies:
* fuse_reply_entry
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the parent directory
* @param name to create
* @param mode file type and mode with which to create the new file
* @param rdev the device number (only valid if created file is a device)
*/
void (*mknod)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Create a directory
*
* Valid replies:
* fuse_reply_entry
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the parent directory
* @param name to create
* @param mode with which to create the new file
*/
void (*mkdir)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Remove a file
*
* If the file's inode's lookup count is non-zero, the file
* system is expected to postpone any removal of the inode
* until the lookup count reaches zero (see description of the
* forget function).
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the parent directory
* @param name to remove
*/
void (*unlink)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Remove a directory
*
* If the directory's inode's lookup count is non-zero, the
* file system is expected to postpone any removal of the
* inode until the lookup count reaches zero (see description
* of the forget function).
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the parent directory
* @param name to remove
*/
void (*rmdir)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Create a symbolic link
*
* Valid replies:
* fuse_reply_entry
* fuse_reply_err
*
* @param req request handle
* @param link the contents of the symbolic link
* @param parent inode number of the parent directory
* @param name to create
*/
void (*symlink)(fuse_req_t req,
struct fuse_in_header *hdr);
/** Rename a file
*
* If the target exists it should be atomically replaced. If
* the target's inode's lookup count is non-zero, the file
* system is expected to postpone any removal of the inode
* until the lookup count reaches zero (see description of the
* forget function).
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the old parent directory
* @param name old name
* @param newparent inode number of the new parent directory
* @param newname new name
*/
void (*rename)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Create a hard link
*
* Valid replies:
* fuse_reply_entry
* fuse_reply_err
*
* @param req request handle
* @param ino the old inode number
* @param newparent inode number of the new parent directory
* @param newname new name to create
*/
void (*link)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Open a file
*
* Open flags (with the exception of O_CREAT, O_EXCL, O_NOCTTY and
* O_TRUNC) are available in fi->flags.
*
* Filesystem may store an arbitrary file handle (pointer, index,
* etc) in fi->fh, and use this in other all other file operations
* (read, write, flush, release, fsync).
*
* Filesystem may also implement stateless file I/O and not store
* anything in fi->fh.
*
* There are also some flags (direct_io, keep_cache) which the
* filesystem may set in fi, to change the way the file is opened.
* See fuse_file_info structure in <fuse_common.h> for more details.
*
* Valid replies:
* fuse_reply_open
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
*/
void (*open)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Read data
*
* Read should send exactly the number of bytes requested except
* on EOF or error, otherwise the rest of the data will be
* substituted with zeroes. An exception to this is when the file
* has been opened in 'direct_io' mode, in which case the return
* value of the read system call will reflect the return value of
* this operation.
*
* fi->fh will contain the value set by the open method, or will
* be undefined if the open method didn't set any value.
*
* Valid replies:
* fuse_reply_buf
* fuse_reply_iov
* fuse_reply_data
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param size number of bytes to read
* @param off offset to read from
* @param fi file information
*/
void (*read)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Write data
*
* Write should return exactly the number of bytes requested
* except on error. An exception to this is when the file has
* been opened in 'direct_io' mode, in which case the return value
* of the write system call will reflect the return value of this
* operation.
*
* fi->fh will contain the value set by the open method, or will
* be undefined if the open method didn't set any value.
*
* Valid replies:
* fuse_reply_write
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param buf data to write
* @param size number of bytes to write
* @param off offset to write to
* @param fi file information
*/
void (*write)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Flush method
*
* This is called on each close() of the opened file.
*
* Since file descriptors can be duplicated (dup, dup2, fork), for
* one open call there may be many flush calls.
*
* Filesystems shouldn't assume that flush will always be called
* after some writes, or that if will be called at all.
*
* fi->fh will contain the value set by the open method, or will
* be undefined if the open method didn't set any value.
*
* NOTE: the name of the method is misleading, since (unlike
* fsync) the filesystem is not forced to flush pending writes.
* One reason to flush data, is if the filesystem wants to return
* write errors.
*
* If the filesystem supports file locking operations (setlk,
* getlk) it should remove all locks belonging to 'fi->owner'.
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
*/
void (*flush)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Release an open file
*
* Release is called when there are no more references to an open
* file: all file descriptors are closed and all memory mappings
* are unmapped.
*
* For every open call there will be exactly one release call.
*
* The filesystem may reply with an error, but error values are
* not returned to close() or munmap() which triggered the
* release.
*
* fi->fh will contain the value set by the open method, or will
* be undefined if the open method didn't set any value.
* fi->flags will contain the same flags as for open.
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
*/
void (*release)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Synchronize file contents
*
* If the datasync parameter is non-zero, then only the user data
* should be flushed, not the meta data.
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param datasync flag indicating if only data should be flushed
* @param fi file information
*/
void (*fsync)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Open a directory
*
* Filesystem may store an arbitrary file handle (pointer, index,
* etc) in fi->fh, and use this in other all other directory
* stream operations (readdir, releasedir, fsyncdir).
*
* Filesystem may also implement stateless directory I/O and not
* store anything in fi->fh, though that makes it impossible to
* implement standard conforming directory stream operations in
* case the contents of the directory can change between opendir
* and releasedir.
*
* Valid replies:
* fuse_reply_open
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
*/
void (*opendir)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Read directory
*
* Send a buffer filled using fuse_add_direntry(), with size not
* exceeding the requested size. Send an empty buffer on end of
* stream.
*
* fi->fh will contain the value set by the opendir method, or
* will be undefined if the opendir method didn't set any value.
*
* Valid replies:
* fuse_reply_buf
* fuse_reply_data
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param size maximum number of bytes to send
* @param off offset to continue reading the directory stream
* @param fi file information
*/
void (*readdir)(fuse_req_t req,
struct fuse_in_header *hdr);
void (*readdir_plus)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Release an open directory
*
* For every opendir call there will be exactly one releasedir
* call.
*
* fi->fh will contain the value set by the opendir method, or
* will be undefined if the opendir method didn't set any value.
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
*/
void (*releasedir)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Synchronize directory contents
*
* If the datasync parameter is non-zero, then only the directory
* contents should be flushed, not the meta data.
*
* fi->fh will contain the value set by the opendir method, or
* will be undefined if the opendir method didn't set any value.
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param datasync flag indicating if only data should be flushed
* @param fi file information
*/
void (*fsyncdir)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Get file system statistics
*
* Valid replies:
* fuse_reply_statfs
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number, zero means "undefined"
*/
void (*statfs)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Set an extended attribute
*
* Valid replies:
* fuse_reply_err
*/
void (*setxattr)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Get an extended attribute
*
* If size is zero, the size of the value should be sent with
* fuse_reply_xattr.
*
* If the size is non-zero, and the value fits in the buffer, the
* value should be sent with fuse_reply_buf.
*
* If the size is too small for the value, the ERANGE error should
* be sent.
*
* Valid replies:
* fuse_reply_buf
* fuse_reply_data
* fuse_reply_xattr
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param name of the extended attribute
* @param size maximum size of the value to send
*/
void (*getxattr)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* List extended attribute names
*
* If size is zero, the total size of the attribute list should be
* sent with fuse_reply_xattr.
*
* If the size is non-zero, and the null character separated
* attribute list fits in the buffer, the list should be sent with
* fuse_reply_buf.
*
* If the size is too small for the list, the ERANGE error should
* be sent.
*
* Valid replies:
* fuse_reply_buf
* fuse_reply_data
* fuse_reply_xattr
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param size maximum size of the list to send
*/
void (*listxattr)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Remove an extended attribute
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param name of the extended attribute
*/
void (*removexattr)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Check file access permissions
*
* This will be called for the access() system call. If the
* 'default_permissions' mount option is given, this method is not
* called.
*
* This method is not called under Linux kernel versions 2.4.x
*
* Introduced in version 2.5
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param mask requested access mode
*/
void (*access)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Create and open a file
*
* If the file does not exist, first create it with the specified
* mode, and then open it.
*
* Open flags (with the exception of O_NOCTTY) are available in
* fi->flags.
*
* Filesystem may store an arbitrary file handle (pointer, index,
* etc) in fi->fh, and use this in other all other file operations
* (read, write, flush, release, fsync).
*
* There are also some flags (direct_io, keep_cache) which the
* filesystem may set in fi, to change the way the file is opened.
* See fuse_file_info structure in <fuse_common.h> for more details.
*
* If this method is not implemented or under Linux kernel
* versions earlier than 2.6.15, the mknod() and open() methods
* will be called instead.
*
* Introduced in version 2.5
*
* Valid replies:
* fuse_reply_create
* fuse_reply_err
*
* @param req request handle
* @param parent inode number of the parent directory
* @param name to create
* @param mode file type and mode with which to create the new file
* @param fi file information
*/
void (*create)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Test for a POSIX file lock
*
* Introduced in version 2.6
*
* Valid replies:
* fuse_reply_lock
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
* @param lock the region/type to test
*/
void (*getlk)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Acquire, modify or release a POSIX file lock
*
* For POSIX threads (NPTL) there's a 1-1 relation between pid and
* owner, but otherwise this is not always the case. For checking
* lock ownership, 'fi->owner' must be used. The l_pid field in
* 'struct flock' should only be used to fill in this field in
* getlk().
*
* Note: if the locking methods are not implemented, the kernel
* will still allow file locking to work locally. Hence these are
* only interesting for network filesystems and similar.
*
* Introduced in version 2.6
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
* @param lock the region/type to set
* @param sleep locking operation may sleep
*/
void (*setlk)(fuse_req_t req, uint64_t ino,
fuse_file_info_t *fi,
struct flock *lock, int sleep);
/**
* Map block index within file to block index within device
*
* Note: This makes sense only for block device backed filesystems
* mounted with the 'blkdev' option
*
* Introduced in version 2.6
*
* Valid replies:
* fuse_reply_bmap
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param blocksize unit of block index
* @param idx block index within file
*/
void (*bmap)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Ioctl
*
* Note: For unrestricted ioctls (not allowed for FUSE
* servers), data in and out areas can be discovered by giving
* iovs and setting FUSE_IOCTL_RETRY in @flags. For
* restricted ioctls, kernel prepares in/out data area
* according to the information encoded in cmd.
*
* Introduced in version 2.8
*
* Valid replies:
* fuse_reply_ioctl_retry
* fuse_reply_ioctl
* fuse_reply_ioctl_iov
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param cmd ioctl command
* @param arg ioctl argument
* @param fi file information
* @param flags for FUSE_IOCTL_* flags
* @param in_buf data fetched from the caller
* @param in_bufsz number of fetched bytes
* @param out_bufsz maximum size of output data
*/
void (*ioctl)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Poll for IO readiness
*
* Introduced in version 2.8
*
* Note: If ph is non-NULL, the client should notify
* when IO readiness events occur by calling
* fuse_lowelevel_notify_poll() with the specified ph.
*
* Regardless of the number of times poll with a non-NULL ph
* is received, single notification is enough to clear all.
* Notifying more times incurs overhead but doesn't harm
* correctness.
*
* The callee is responsible for destroying ph with
* fuse_pollhandle_destroy() when no longer in use.
*
* Valid replies:
* fuse_reply_poll
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
* @param ph poll handle to be used for notification
*/
void (*poll)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Callback function for the retrieve request
*
* Introduced in version 2.9
*
* Valid replies:
* fuse_reply_none
*
* @param req request handle
* @param cookie user data supplied to fuse_lowlevel_notify_retrieve()
* @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
* @param offset the offset supplied to fuse_lowlevel_notify_retrieve()
* @param bufv the buffer containing the returned data
*/
void (*retrieve_reply)(fuse_req_t req,
void *cookie,
uint64_t ino,
off_t offset);
/**
* Forget about multiple inodes
*
* See description of the forget function for more
* information.
*
* Introduced in version 2.9
*
* Valid replies:
* fuse_reply_none
*
* @param req request handle
*/
void (*forget_multi)(fuse_req_t req,
struct fuse_in_header *hdr);
/**
* Acquire, modify or release a BSD file lock
*
* Note: if the locking methods are not implemented, the kernel
* will still allow file locking to work locally. Hence these are
* only interesting for network filesystems and similar.
*
* Introduced in version 2.9
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param fi file information
* @param op the locking operation, see flock(2)
*/
void (*flock)(fuse_req_t req, uint64_t ino,
fuse_file_info_t *fi, int op);
/**
* Allocate requested space. If this function returns success then
* subsequent writes to the specified range shall not fail due to the lack
* of free space on the file system storage media.
*
* Introduced in version 2.9
*
* Valid replies:
* fuse_reply_err
*
* @param req request handle
* @param ino the inode number
* @param offset starting point for allocated region
* @param length size of allocated region
* @param mode determines the operation to be performed on the given range,
* see fallocate(2)
*/
void (*fallocate)(fuse_req_t req,
const struct fuse_in_header *hdr);
/**
* Copy a range of data from one file to another
*
* Performs an optimized copy between two file descriptors without
* the
* additional cost of transferring data through the FUSE kernel
* module
* to user space (glibc) and then back into the FUSE filesystem
* again.
*
* In case this method is not implemented, glibc falls back to
* reading
* data from the source and writing to the destination. Effectively
* doing an inefficient copy of the data.
*
* If this request is answered with an error code of ENOSYS, this is
* treated as a permanent failure with error code EOPNOTSUPP,
* i.e. all
* future copy_file_range() requests will fail with EOPNOTSUPP
* without
* being send to the filesystem process.
*
* Valid replies:
* fuse_reply_write
* fuse_reply_err
*
* @param req request handle
* @param ino_in the inode number of the source file
* @param off_in starting point from were the data should be read
* @param fi_in file information of the source file
* @param ino_out the inode number of the destination file
* @param off_out starting point where the data should be written
* @param fi_out file information of the destination file
* @param len maximum size of the data to copy
* @param flags passed along with the copy_file_range() syscall
*/
void (*copy_file_range)(fuse_req_t req,
const struct fuse_in_header *hdr);
void (*setupmapping)(fuse_req_t req,
const struct fuse_in_header *hdr);
void (*removemapping)(fuse_req_t req,
const struct fuse_in_header *hdr);
void (*syncfs)(fuse_req_t req,
const struct fuse_in_header *hdr);
void (*tmpfile)(fuse_req_t req,
const struct fuse_in_header *hdr);
}; };
/** /**

9
libfuse/lib/crc32b.h
View File

@ -19,6 +19,11 @@
#ifndef CRC32B_H_INCLUDED #ifndef CRC32B_H_INCLUDED
#define CRC32B_H_INCLUDED #define CRC32B_H_INCLUDED
#ifdef __cplusplus
extern "C"
{
#endif
typedef unsigned int crc32b_t; typedef unsigned int crc32b_t;
crc32b_t crc32b_start(void); crc32b_t crc32b_start(void);
@ -29,4 +34,8 @@ crc32b_t crc32b_finish(const crc32b_t crc);
crc32b_t crc32b(const void *buf, crc32b_t len); crc32b_t crc32b(const void *buf, crc32b_t len);
#ifdef __cplusplus
}
#endif
#endif #endif

155
libfuse/lib/debug.c → libfuse/lib/debug.cpp
View File

@ -16,7 +16,9 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/ */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE #define _GNU_SOURCE
#endif
#include "fuse_kernel.h" #include "fuse_kernel.h"
@ -211,7 +213,7 @@ void
debug_open_flags(const uint32_t flags_) debug_open_flags(const uint32_t flags_)
{ {
fprintf(stderr,"%s, ",open_accmode_to_str(flags_)); fprintf(stderr,"%s, ",open_accmode_to_str(flags_));
for(int i = 0; i < (sizeof(flags_) * 8); i++) for(size_t i = 0; i < (sizeof(flags_) * 8); i++)
{ {
const char *str; const char *str;
@ -256,7 +258,7 @@ debug_fuse_open_out(const struct fuse_open_out *arg_)
" open_flags=0x%X (", " open_flags=0x%X (",
arg_->fh, arg_->fh,
arg_->open_flags); arg_->open_flags);
for(int i = 0; i < (sizeof(arg_->open_flags) * 8); i++) for(size_t i = 0; i < (sizeof(arg_->open_flags) * 8); i++)
{ {
const char *str; const char *str;
@ -276,7 +278,7 @@ static
void void
debug_fuse_lookup(const void *arg_) debug_fuse_lookup(const void *arg_)
{ {
const char *name = arg_; const char *name = (const char*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_lookup:" "fuse_lookup:"
@ -290,7 +292,7 @@ static
void void
debug_fuse_getattr_in(const void *arg_) debug_fuse_getattr_in(const void *arg_)
{ {
const struct fuse_getattr_in *arg = arg_; const struct fuse_getattr_in *arg = (const fuse_getattr_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_getattr_in:" "fuse_getattr_in:"
@ -304,7 +306,7 @@ static
void void
debug_fuse_setattr_in(const void *arg_) debug_fuse_setattr_in(const void *arg_)
{ {
const struct fuse_setattr_in *arg = arg_; const struct fuse_setattr_in *arg = (const fuse_setattr_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_setattr_in:" "fuse_setattr_in:"
@ -342,7 +344,7 @@ static
void void
debug_fuse_access_in(const void *arg_) debug_fuse_access_in(const void *arg_)
{ {
const struct fuse_access_in *arg = arg_; const struct fuse_access_in *arg = (const fuse_access_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_access_in:" "fuse_access_in:"
@ -356,7 +358,7 @@ static
void void
debug_fuse_mknod_in(const void *arg_) debug_fuse_mknod_in(const void *arg_)
{ {
const struct fuse_mknod_in *arg = arg_; const struct fuse_mknod_in *arg = (const fuse_mknod_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_mknod_in:" "fuse_mknod_in:"
@ -374,7 +376,7 @@ static
void void
debug_fuse_mkdir_in(const void *arg_) debug_fuse_mkdir_in(const void *arg_)
{ {
const struct fuse_mkdir_in *arg = arg_; const struct fuse_mkdir_in *arg = (const fuse_mkdir_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_mkdir_in:" "fuse_mkdir_in:"
@ -392,7 +394,7 @@ static
void void
debug_fuse_unlink(const void *arg_) debug_fuse_unlink(const void *arg_)
{ {
const char *name = arg_; const char *name = (const char*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_unlink:" "fuse_unlink:"
@ -406,7 +408,7 @@ static
void void
debug_fuse_rmdir(const void *arg_) debug_fuse_rmdir(const void *arg_)
{ {
const char *name = arg_; const char *name = (const char*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_mkdir:" "fuse_mkdir:"
@ -423,7 +425,7 @@ debug_fuse_symlink(const void *arg_)
const char *name; const char *name;
const char *linkname; const char *linkname;
name = arg_; name = (const char*)arg_;
linkname = (name + (strlen(name) + 1)); linkname = (name + (strlen(name) + 1));
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
@ -442,7 +444,7 @@ debug_fuse_rename_in(const void *arg_)
{ {
const char *oldname; const char *oldname;
const char *newname; const char *newname;
const struct fuse_rename_in *arg = arg_; const struct fuse_rename_in *arg = (const fuse_rename_in*)arg_;
oldname = PARAM(arg); oldname = PARAM(arg);
newname = (oldname + strlen(oldname) + 1); newname = (oldname + strlen(oldname) + 1);
@ -464,7 +466,7 @@ void
debug_fuse_link_in(const void *arg_) debug_fuse_link_in(const void *arg_)
{ {
const char *name; const char *name;
const struct fuse_link_in *arg = arg_; const struct fuse_link_in *arg = (const fuse_link_in*)arg_;
name = PARAM(arg); name = PARAM(arg);
@ -483,7 +485,7 @@ void
debug_fuse_create_in(const void *arg_) debug_fuse_create_in(const void *arg_)
{ {
const char *name; const char *name;
const struct fuse_create_in *arg = arg_; const struct fuse_create_in *arg = (const fuse_create_in*)arg_;
name = PARAM(arg); name = PARAM(arg);
@ -505,7 +507,7 @@ static
void void
debug_fuse_open_in(const void *arg_) debug_fuse_open_in(const void *arg_)
{ {
const struct fuse_open_in *arg = arg_; const struct fuse_open_in *arg = (const fuse_open_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_open_in:" "fuse_open_in:"
@ -519,7 +521,7 @@ static
void void
debug_fuse_read_in(const void *arg_) debug_fuse_read_in(const void *arg_)
{ {
const struct fuse_read_in *arg = arg_; const struct fuse_read_in *arg = (const fuse_read_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_read_in:" "fuse_read_in:"
@ -544,7 +546,7 @@ static
void void
debug_fuse_write_in(const void *arg_) debug_fuse_write_in(const void *arg_)
{ {
const struct fuse_write_in *arg = arg_; const struct fuse_write_in *arg = (const fuse_write_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_write_in:" "fuse_write_in:"
@ -563,7 +565,7 @@ debug_fuse_write_in(const void *arg_)
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"); write_flags=0x%X (", "); write_flags=0x%X (",
arg->write_flags); arg->write_flags);
for(int i = 0; i < (sizeof(arg->write_flags) * 8); i++) for(size_t i = 0; i < (sizeof(arg->write_flags) * 8); i++)
{ {
const char *str; const char *str;
@ -583,7 +585,7 @@ static
void void
debug_fuse_flush_in(const void *arg_) debug_fuse_flush_in(const void *arg_)
{ {
const struct fuse_flush_in *arg = arg_; const struct fuse_flush_in *arg = (const fuse_flush_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_flush_in:" "fuse_flush_in:"
@ -599,7 +601,7 @@ static
void void
debug_fuse_release_in(const void *arg_) debug_fuse_release_in(const void *arg_)
{ {
const struct fuse_release_in *arg = arg_; const struct fuse_release_in *arg = (const fuse_release_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_release_in:" "fuse_release_in:"
@ -620,7 +622,7 @@ static
void void
debug_fuse_fsync_in(const void *arg_) debug_fuse_fsync_in(const void *arg_)
{ {
const struct fuse_fsync_in *arg = arg_; const struct fuse_fsync_in *arg = (const fuse_fsync_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_fsync_in:" "fuse_fsync_in:"
@ -638,7 +640,7 @@ debug_fuse_setxattr_in(const void *arg_)
{ {
const char *name; const char *name;
const char *value; const char *value;
const struct fuse_setxattr_in *arg = arg_; const struct fuse_setxattr_in *arg = (const fuse_setxattr_in*)arg_;
name = PARAM(arg); name = PARAM(arg);
value = (name + strlen(name) + 1); value = (name + strlen(name) + 1);
@ -662,7 +664,7 @@ void
debug_fuse_getxattr_in(const void *arg_) debug_fuse_getxattr_in(const void *arg_)
{ {
const char *name; const char *name;
const struct fuse_getxattr_in *arg = arg_; const struct fuse_getxattr_in *arg = (const fuse_getxattr_in*)arg_;
name = PARAM(arg); name = PARAM(arg);
@ -680,7 +682,7 @@ static
void void
debug_fuse_listxattr(const void *arg_) debug_fuse_listxattr(const void *arg_)
{ {
const struct fuse_getxattr_in *arg = arg_; const struct fuse_getxattr_in *arg = (const fuse_getxattr_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_listxattr:" "fuse_listxattr:"
@ -694,7 +696,7 @@ static
void void
debug_fuse_removexattr(const void *arg_) debug_fuse_removexattr(const void *arg_)
{ {
const char *name = arg_; const char *name = (const char*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_removexattr:" "fuse_removexattr:"
@ -708,7 +710,7 @@ static
void void
debug_fuse_fallocate_in(const void *arg_) debug_fuse_fallocate_in(const void *arg_)
{ {
const struct fuse_fallocate_in *arg = arg_; const struct fuse_fallocate_in *arg = (const fuse_fallocate_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_fallocate_in:" "fuse_fallocate_in:"
@ -945,7 +947,7 @@ static
void void
debug_fuse_interrupt_in(const void *arg_) debug_fuse_interrupt_in(const void *arg_)
{ {
const struct fuse_interrupt_in *arg = arg_; const struct fuse_interrupt_in *arg = (const fuse_interrupt_in*)arg_;
fprintf(g_OUTPUT, fprintf(g_OUTPUT,
"fuse_interrupt_in:" "fuse_interrupt_in:"
@ -962,53 +964,54 @@ opcode_name(enum fuse_opcode op_)
{ {
static const char *names[] = static const char *names[] =
{ {
[FUSE_LOOKUP] = "LOOKUP", "INVALID",
[FUSE_FORGET] = "FORGET", "LOOKUP",
[FUSE_GETATTR] = "GETATTR", "FORGET",
[FUSE_SETATTR] = "SETATTR", "GETATTR",
[FUSE_READLINK] = "READLINK", "SETATTR",
[FUSE_SYMLINK] = "SYMLINK", "READLINK",
[FUSE_MKNOD] = "MKNOD", "SYMLINK",
[FUSE_MKDIR] = "MKDIR", "MKNOD",
[FUSE_UNLINK] = "UNLINK", "MKDIR",
[FUSE_RMDIR] = "RMDIR", "UNLINK",
[FUSE_RENAME] = "RENAME", "RMDIR",
[FUSE_LINK] = "LINK", "RENAME",
[FUSE_OPEN] = "OPEN", "LINK",
[FUSE_READ] = "READ", "OPEN",
[FUSE_WRITE] = "WRITE", "READ",
[FUSE_STATFS] = "STATFS", "WRITE",
[FUSE_RELEASE] = "RELEASE", "STATFS",
[FUSE_FSYNC] = "FSYNC", "RELEASE",
[FUSE_SETXATTR] = "SETXATTR", "FSYNC",
[FUSE_GETXATTR] = "GETXATTR", "SETXATTR",
[FUSE_LISTXATTR] = "LISTXATTR", "GETXATTR",
[FUSE_REMOVEXATTR] = "REMOVEXATTR", "LISTXATTR",
[FUSE_FLUSH] = "FLUSH", "REMOVEXATTR",
[FUSE_INIT] = "INIT", "FLUSH",
[FUSE_OPENDIR] = "OPENDIR", "INIT",
[FUSE_READDIR] = "READDIR", "OPENDIR",
[FUSE_RELEASEDIR] = "RELEASEDIR", "READDIR",
[FUSE_FSYNCDIR] = "FSYNCDIR", "RELEASEDIR",
[FUSE_GETLK] = "GETLK", "FSYNCDIR",
[FUSE_SETLK] = "SETLK", "GETLK",
[FUSE_SETLKW] = "SETLKW", "SETLK",
[FUSE_ACCESS] = "ACCESS", "SETLKW",
[FUSE_CREATE] = "CREATE", "ACCESS",
[FUSE_INTERRUPT] = "INTERRUPT", "CREATE",
[FUSE_BMAP] = "BMAP", "INTERRUPT",
[FUSE_DESTROY] = "DESTROY", "BMAP",
[FUSE_IOCTL] = "IOCTL", "DESTROY",
[FUSE_POLL] = "POLL", "IOCTL",
[FUSE_NOTIFY_REPLY] = "NOTIFY_REPLY", "POLL",
[FUSE_BATCH_FORGET] = "BATCH_FORGET", "NOTIFY_REPLY",
[FUSE_FALLOCATE] = "FALLOCATE", "BATCH_FORGET",
[FUSE_READDIRPLUS] = "READDIRPLUS", "FALLOCATE",
[FUSE_RENAME2] = "RENAME2", "READDIRPLUS",
[FUSE_LSEEK] = "LSEEK", "RENAME2",
[FUSE_COPY_FILE_RANGE] = "COPY_FILE_RANGE", "LSEEK",
[FUSE_SETUPMAPPING] = "SETUPMAPPING", "COPY_FILE_RANGE",
[FUSE_REMOVEMAPPING] = "REMOVEMAPPING" "SETUPMAPPING",
"REMOVEMAPPING"
}; };
if(op_ >= (sizeof(names) / sizeof(names[0]))) if(op_ >= (sizeof(names) / sizeof(names[0])))
@ -1030,7 +1033,7 @@ debug_fuse_in_header(const struct fuse_in_header *hdr_)
" gid=%u;" " gid=%u;"
" pid=%u; || ", " pid=%u; || ",
hdr_->unique, hdr_->unique,
opcode_name(hdr_->opcode), opcode_name((fuse_opcode)hdr_->opcode),
hdr_->opcode, hdr_->opcode,
hdr_->nodeid, hdr_->nodeid,
hdr_->uid, hdr_->uid,
@ -1043,7 +1046,7 @@ debug_fuse_in_header(const struct fuse_in_header *hdr_)
debug_fuse_lookup(arg); debug_fuse_lookup(arg);
break; break;
case FUSE_INIT: case FUSE_INIT:
debug_fuse_init_in(arg); debug_fuse_init_in((const fuse_init_in*)arg);
break; break;
case FUSE_GETATTR: case FUSE_GETATTR:
debug_fuse_getattr_in(arg); debug_fuse_getattr_in(arg);

0
libfuse/lib/debug.h → libfuse/lib/debug.hpp
View File

2
libfuse/lib/fmp.h
View File

@ -328,7 +328,7 @@ fmp_gc_slab(fmp_t *fmp_,
slab_idx_ = (slab_idx_ % kv_size(fmp_->slabs)); slab_idx_ = (slab_idx_ % kv_size(fmp_->slabs));
slab = kv_A(fmp_->slabs,slab_idx_); slab = (char*)kv_A(fmp_->slabs,slab_idx_);
objs_per_slab = fmp_objs_per_slab(fmp_); objs_per_slab = fmp_objs_per_slab(fmp_);
objs_in_slab = fmp_objs_in_slab(fmp_,slab); objs_in_slab = fmp_objs_in_slab(fmp_,slab);

157
libfuse/lib/fuse.c → libfuse/lib/fuse.cpp
View File

@ -7,7 +7,9 @@
*/ */
/* For pthread_rwlock_t */ /* For pthread_rwlock_t */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE #define _GNU_SOURCE
#endif
#include "crc32b.h" #include "crc32b.h"
#include "fuse_node.h" #include "fuse_node.h"
@ -104,13 +106,6 @@ struct node_table
size_t split; size_t split;
}; };
#define container_of(ptr,type,member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
#define list_entry(ptr,type,member) \
container_of(ptr,type,member)
struct list_head struct list_head
{ {
struct list_head *next; struct list_head *next;
@ -218,32 +213,32 @@ fuse_hdr_arg(const struct fuse_in_header *hdr_)
static static
void void
list_add(struct list_head *new, list_add(struct list_head *new_,
struct list_head *prev, struct list_head *prev_,
struct list_head *next) struct list_head *next_)
{ {
next->prev = new; next_->prev = new_;
new->next = next; new_->next = next_;
new->prev = prev; new_->prev = prev_;
prev->next = new; prev_->next = new_;
} }
static static
inline inline
void void
list_add_head(struct list_head *new, list_add_head(struct list_head *new_,
struct list_head *head) struct list_head *head_)
{ {
list_add(new,head,head->next); list_add(new_,head_,head_->next);
} }
static static
inline inline
void void
list_add_tail(struct list_head *new, list_add_tail(struct list_head *new_,
struct list_head *head) struct list_head *head_)
{ {
list_add(new,head->prev,head); list_add(new_,head_->prev,head_);
} }
static static
@ -384,7 +379,7 @@ node_table_reduce(struct node_table *t)
newarray = realloc(t->array,sizeof(node_t*) * newsize); newarray = realloc(t->array,sizeof(node_t*) * newsize);
if(newarray != NULL) if(newarray != NULL)
t->array = newarray; t->array = (node_t**)newarray;
t->size = newsize; t->size = newsize;
t->split = t->size / 2; t->split = t->size / 2;
@ -450,7 +445,7 @@ node_table_resize(struct node_table *t)
if(newarray == NULL) if(newarray == NULL)
return -1; return -1;
t->array = newarray; t->array = (node_t**)newarray;
memset(t->array + t->size,0,t->size * sizeof(node_t*)); memset(t->array + t->size,0,t->size * sizeof(node_t*));
t->size = newsize; t->size = newsize;
t->split = 0; t->split = 0;
@ -795,7 +790,7 @@ add_name(char **buf,
newbufsize *= 2; newbufsize *= 2;
} }
newbuf = realloc(*buf,newbufsize); newbuf = (char*)realloc(*buf,newbufsize);
if(newbuf == NULL) if(newbuf == NULL)
return NULL; return NULL;
@ -857,7 +852,7 @@ try_get_path(struct fuse *f,
*path = NULL; *path = NULL;
err = -ENOMEM; err = -ENOMEM;
buf = malloc(bufsize); buf = (char*)malloc(bufsize);
if(buf == NULL) if(buf == NULL)
goto out_err; goto out_err;
@ -1562,7 +1557,7 @@ fuse_lib_lookup(fuse_req_t req,
node_t *dot = NULL; node_t *dot = NULL;
struct fuse_entry_param e = {0}; struct fuse_entry_param e = {0};
name = fuse_hdr_arg(hdr_); name = (const char*)fuse_hdr_arg(hdr_);
nodeid = hdr_->nodeid; nodeid = hdr_->nodeid;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -1628,7 +1623,7 @@ fuse_lib_forget(fuse_req_t req,
struct fuse_forget_in *arg; struct fuse_forget_in *arg;
f = req_fuse(req); f = req_fuse(req);
arg = fuse_hdr_arg(hdr_); arg = (fuse_forget_in*)fuse_hdr_arg(hdr_);
forget_node(f,hdr_->nodeid,arg->nlookup); forget_node(f,hdr_->nodeid,arg->nlookup);
@ -1645,8 +1640,8 @@ fuse_lib_forget_multi(fuse_req_t req,
struct fuse_forget_one *entry; struct fuse_forget_one *entry;
f = req_fuse(req); f = req_fuse(req);
arg = fuse_hdr_arg(hdr_); arg = (fuse_batch_forget_in*)fuse_hdr_arg(hdr_);
entry = PARAM(arg); entry = (fuse_forget_one*)PARAM(arg);
for(uint32_t i = 0; i < arg->count; i++) for(uint32_t i = 0; i < arg->count; i++)
{ {
@ -1673,7 +1668,7 @@ fuse_lib_getattr(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
const struct fuse_getattr_in *arg; const struct fuse_getattr_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_getattr_in*)fuse_hdr_arg(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
if(arg->getattr_flags & FUSE_GETATTR_FH) if(arg->getattr_flags & FUSE_GETATTR_FH)
@ -1735,7 +1730,7 @@ fuse_lib_setattr(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
struct fuse_setattr_in *arg; struct fuse_setattr_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_setattr_in*)fuse_hdr_arg(hdr_);
fi = NULL; fi = NULL;
if(arg->valid & FATTR_FH) if(arg->valid & FATTR_FH)
@ -1796,12 +1791,12 @@ fuse_lib_setattr(fuse_req_t req,
if(arg->valid & FATTR_ATIME_NOW) if(arg->valid & FATTR_ATIME_NOW)
tv[0].tv_nsec = UTIME_NOW; tv[0].tv_nsec = UTIME_NOW;
else if(arg->valid & FATTR_ATIME) else if(arg->valid & FATTR_ATIME)
tv[0] = (struct timespec){ arg->atime, arg->atimensec }; tv[0] = (struct timespec){ static_cast<time_t>(arg->atime), arg->atimensec };
if(arg->valid & FATTR_MTIME_NOW) if(arg->valid & FATTR_MTIME_NOW)
tv[1].tv_nsec = UTIME_NOW; tv[1].tv_nsec = UTIME_NOW;
else if(arg->valid & FATTR_MTIME) else if(arg->valid & FATTR_MTIME)
tv[1] = (struct timespec){ arg->mtime, arg->mtimensec }; tv[1] = (struct timespec){ static_cast<time_t>(arg->mtime), arg->mtimensec };
err = ((fi == NULL) ? err = ((fi == NULL) ?
f->fs->op.utimens(path,tv) : f->fs->op.utimens(path,tv) :
@ -1853,7 +1848,7 @@ fuse_lib_access(fuse_req_t req,
struct fuse *f; struct fuse *f;
struct fuse_access_in *arg; struct fuse_access_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_access_in*)fuse_hdr_arg(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -1909,8 +1904,8 @@ fuse_lib_mknod(fuse_req_t req,
struct fuse_entry_param e; struct fuse_entry_param e;
struct fuse_mknod_in *arg; struct fuse_mknod_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_mknod_in*)fuse_hdr_arg(hdr_);
name = PARAM(arg); name = (const char*)PARAM(arg);
if(req->f->conn.proto_minor >= 12) if(req->f->conn.proto_minor >= 12)
req->ctx.umask = arg->umask; req->ctx.umask = arg->umask;
else else
@ -1961,8 +1956,8 @@ fuse_lib_mkdir(fuse_req_t req,
struct fuse_entry_param e; struct fuse_entry_param e;
struct fuse_mkdir_in *arg; struct fuse_mkdir_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_mkdir_in*)fuse_hdr_arg(hdr_);
name = PARAM(arg); name = (const char*)PARAM(arg);
if(req->f->conn.proto_minor >= 12) if(req->f->conn.proto_minor >= 12)
req->ctx.umask = arg->umask; req->ctx.umask = arg->umask;
@ -1991,7 +1986,7 @@ fuse_lib_unlink(fuse_req_t req,
const char *name; const char *name;
node_t *wnode; node_t *wnode;
name = PARAM(hdr_); name = (const char*)PARAM(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
err = get_path_wrlock(f,hdr_->nodeid,name,&path,&wnode); err = get_path_wrlock(f,hdr_->nodeid,name,&path,&wnode);
@ -2024,7 +2019,7 @@ fuse_lib_rmdir(fuse_req_t req,
const char *name; const char *name;
node_t *wnode; node_t *wnode;
name = PARAM(hdr_); name = (const char*)PARAM(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2052,7 +2047,7 @@ fuse_lib_symlink(fuse_req_t req_,
const char *linkname; const char *linkname;
struct fuse_entry_param e = {0}; struct fuse_entry_param e = {0};
name = fuse_hdr_arg(hdr_); name = (const char*)fuse_hdr_arg(hdr_);
linkname = (name + strlen(name) + 1); linkname = (name + strlen(name) + 1);
f = req_fuse_prepare(req_); f = req_fuse_prepare(req_);
@ -2084,8 +2079,8 @@ fuse_lib_rename(fuse_req_t req,
node_t *wnode2; node_t *wnode2;
struct fuse_rename_in *arg; struct fuse_rename_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_rename_in*)fuse_hdr_arg(hdr_);
oldname = PARAM(arg); oldname = (const char*)PARAM(arg);
newname = (oldname + strlen(oldname) + 1); newname = (oldname + strlen(oldname) + 1);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2122,8 +2117,8 @@ fuse_lib_link(fuse_req_t req,
struct fuse_link_in *arg; struct fuse_link_in *arg;
struct fuse_entry_param e = {0}; struct fuse_entry_param e = {0};
arg = fuse_hdr_arg(hdr_); arg = (fuse_link_in*)fuse_hdr_arg(hdr_);
newname = PARAM(arg); newname = (const char*)PARAM(arg);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2186,8 +2181,8 @@ fuse_lib_create(fuse_req_t req,
struct fuse_entry_param e; struct fuse_entry_param e;
struct fuse_create_in *arg; struct fuse_create_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_create_in*)fuse_hdr_arg(hdr_);
name = PARAM(arg); name = (const char*)PARAM(arg);
ffi.flags = arg->flags; ffi.flags = arg->flags;
@ -2287,7 +2282,7 @@ fuse_lib_open(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
struct fuse_open_in *arg; struct fuse_open_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_open_in*)fuse_hdr_arg(hdr_);
ffi.flags = arg->flags; ffi.flags = arg->flags;
@ -2332,7 +2327,7 @@ fuse_lib_read(fuse_req_t req,
struct fuse_read_in *arg; struct fuse_read_in *arg;
fuse_msgbuf_t *msgbuf; fuse_msgbuf_t *msgbuf;
arg = fuse_hdr_arg(hdr_); arg = (fuse_read_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
if(req->f->conn.proto_minor >= 9) if(req->f->conn.proto_minor >= 9)
{ {
@ -2365,7 +2360,7 @@ fuse_lib_write(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
struct fuse_write_in *arg; struct fuse_write_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_write_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
ffi.writepage = !!(arg->write_flags & 1); ffi.writepage = !!(arg->write_flags & 1);
if(req->f->conn.proto_minor < 9) if(req->f->conn.proto_minor < 9)
@ -2376,7 +2371,7 @@ fuse_lib_write(fuse_req_t req,
{ {
ffi.flags = arg->flags; ffi.flags = arg->flags;
ffi.lock_owner = arg->lock_owner; ffi.lock_owner = arg->lock_owner;
data = PARAM(arg); data = (char*)PARAM(arg);
} }
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2400,7 +2395,7 @@ fuse_lib_fsync(fuse_req_t req,
struct fuse_fsync_in *arg; struct fuse_fsync_in *arg;
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
arg = fuse_hdr_arg(hdr_); arg = (fuse_fsync_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2435,7 +2430,7 @@ fuse_lib_opendir(fuse_req_t req,
struct fuse *f; struct fuse *f;
struct fuse_open_in *arg; struct fuse_open_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_open_in*)fuse_hdr_arg(hdr_);
llffi.flags = arg->flags; llffi.flags = arg->flags;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2522,7 +2517,7 @@ fuse_lib_readdir(fuse_req_t req_,
fuse_file_info_t llffi = {0}; fuse_file_info_t llffi = {0};
struct fuse_read_in *arg; struct fuse_read_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_read_in*)fuse_hdr_arg(hdr_);
size = arg->size; size = arg->size;
llffi.fh = arg->fh; llffi.fh = arg->fh;
@ -2566,7 +2561,7 @@ fuse_lib_readdir_plus(fuse_req_t req_,
fuse_file_info_t llffi = {0}; fuse_file_info_t llffi = {0};
struct fuse_read_in *arg; struct fuse_read_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_read_in*)fuse_hdr_arg(hdr_);
size = arg->size; size = arg->size;
llffi.fh = arg->fh; llffi.fh = arg->fh;
@ -2607,7 +2602,7 @@ fuse_lib_releasedir(fuse_req_t req_,
fuse_file_info_t llffi = {0}; fuse_file_info_t llffi = {0};
struct fuse_release_in *arg; struct fuse_release_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_release_in*)fuse_hdr_arg(hdr_);
llffi.fh = arg->fh; llffi.fh = arg->fh;
llffi.flags = arg->flags; llffi.flags = arg->flags;
@ -2636,7 +2631,7 @@ fuse_lib_fsyncdir(fuse_req_t req,
fuse_file_info_t llffi = {0}; fuse_file_info_t llffi = {0};
struct fuse_fsync_in *arg; struct fuse_fsync_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_fsync_in*)fuse_hdr_arg(hdr_);
llffi.fh = arg->fh; llffi.fh = arg->fh;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2688,9 +2683,9 @@ fuse_lib_setxattr(fuse_req_t req,
struct fuse *f; struct fuse *f;
struct fuse_setxattr_in *arg; struct fuse_setxattr_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_setxattr_in*)fuse_hdr_arg(hdr_);
if((req->f->conn.capable & FUSE_SETXATTR_EXT) && (req->f->conn.want & FUSE_SETXATTR_EXT)) if((req->f->conn.capable & FUSE_SETXATTR_EXT) && (req->f->conn.want & FUSE_SETXATTR_EXT))
name = PARAM(arg); name = (const char*)PARAM(arg);
else else
name = (((char*)arg) + FUSE_COMPAT_SETXATTR_IN_SIZE); name = (((char*)arg) + FUSE_COMPAT_SETXATTR_IN_SIZE);
@ -2741,8 +2736,8 @@ fuse_lib_getxattr(fuse_req_t req,
const char* name; const char* name;
struct fuse_getxattr_in *arg; struct fuse_getxattr_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_getxattr_in*)fuse_hdr_arg(hdr_);
name = PARAM(arg); name = (const char*)PARAM(arg);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2802,7 +2797,7 @@ fuse_lib_listxattr(fuse_req_t req,
struct fuse *f; struct fuse *f;
struct fuse_getxattr_in *arg; struct fuse_getxattr_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_getxattr_in*)fuse_hdr_arg(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2842,7 +2837,7 @@ fuse_lib_removexattr(fuse_req_t req,
const char *name; const char *name;
struct fuse *f; struct fuse *f;
name = fuse_hdr_arg(hdr_); name = (const char*)fuse_hdr_arg(hdr_);
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -2867,7 +2862,7 @@ fuse_lib_copy_file_range(fuse_req_t req_,
fuse_file_info_t ffi_out = {0}; fuse_file_info_t ffi_out = {0};
const struct fuse_copy_file_range_in *arg; const struct fuse_copy_file_range_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_copy_file_range_in*)fuse_hdr_arg(hdr_);
ffi_in.fh = arg->fh_in; ffi_in.fh = arg->fh_in;
ffi_out.fh = arg->fh_out; ffi_out.fh = arg->fh_out;
@ -2927,8 +2922,8 @@ fuse_lib_tmpfile(fuse_req_t req_,
struct fuse_entry_param e; struct fuse_entry_param e;
struct fuse_create_in *arg; struct fuse_create_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_create_in*)fuse_hdr_arg(hdr_);
name = PARAM(arg); name = (const char*)PARAM(arg);
ffi.flags = arg->flags; ffi.flags = arg->flags;
@ -3026,8 +3021,8 @@ locks_insert(node_t *node,
if(lock->type != F_UNLCK || lock->start != 0 || lock->end != OFFSET_MAX) if(lock->type != F_UNLCK || lock->start != 0 || lock->end != OFFSET_MAX)
{ {
newl1 = malloc(sizeof(lock_t)); newl1 = (lock_t*)malloc(sizeof(lock_t));
newl2 = malloc(sizeof(lock_t)); newl2 = (lock_t*)malloc(sizeof(lock_t));
if(!newl1 || !newl2) if(!newl1 || !newl2)
{ {
@ -3055,7 +3050,7 @@ locks_insert(node_t *node,
lock->start = l->start; lock->start = l->start;
if(lock->end < l->end) if(lock->end < l->end)
lock->end = l->end; lock->end = l->end;
goto delete; goto delete_lock;
} }
else else
{ {
@ -3064,7 +3059,7 @@ locks_insert(node_t *node,
if(lock->end < l->start) if(lock->end < l->start)
break; break;
if(lock->start <= l->start && l->end <= lock->end) if(lock->start <= l->start && l->end <= lock->end)
goto delete; goto delete_lock;
if(l->end <= lock->end) if(l->end <= lock->end)
{ {
l->end = lock->start - 1; l->end = lock->start - 1;
@ -3085,7 +3080,7 @@ locks_insert(node_t *node,
lp = &l->next; lp = &l->next;
continue; continue;
delete: delete_lock:
delete_lock(lp); delete_lock(lp);
} }
if(lock->type != F_UNLCK) if(lock->type != F_UNLCK)
@ -3168,7 +3163,7 @@ fuse_lib_release(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
struct fuse_release_in *arg; struct fuse_release_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_release_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
ffi.flags = arg->flags; ffi.flags = arg->flags;
if(req->f->conn.proto_minor >= 8) if(req->f->conn.proto_minor >= 8)
@ -3206,7 +3201,7 @@ fuse_lib_flush(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
struct fuse_flush_in *arg; struct fuse_flush_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_flush_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
ffi.flush = 1; ffi.flush = 1;
@ -3265,7 +3260,7 @@ fuse_lib_getlk(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
const struct fuse_lk_in *arg; const struct fuse_lk_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_lk_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
ffi.lock_owner = arg->owner; ffi.lock_owner = arg->owner;
@ -3341,7 +3336,7 @@ fuse_lib_bmap(fuse_req_t req,
uint64_t block; uint64_t block;
const struct fuse_bmap_in *arg; const struct fuse_bmap_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_bmap_in*)fuse_hdr_arg(hdr_);
block = arg->block; block = arg->block;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -3373,7 +3368,7 @@ fuse_lib_ioctl(fuse_req_t req,
uint32_t out_size; uint32_t out_size;
const struct fuse_ioctl_in *arg; const struct fuse_ioctl_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_ioctl_in*)fuse_hdr_arg(hdr_);
if((arg->flags & FUSE_IOCTL_DIR) && !(req->f->conn.want & FUSE_CAP_IOCTL_DIR)) if((arg->flags & FUSE_IOCTL_DIR) && !(req->f->conn.want & FUSE_CAP_IOCTL_DIR))
{ {
fuse_reply_err(req,ENOTTY); fuse_reply_err(req,ENOTTY);
@ -3403,7 +3398,7 @@ fuse_lib_ioctl(fuse_req_t req,
if(out_size) if(out_size)
{ {
err = -ENOMEM; err = -ENOMEM;
out_buf = malloc(out_size); out_buf = (char*)malloc(out_size);
if(!out_buf) if(!out_buf)
goto err; goto err;
} }
@ -3441,7 +3436,7 @@ fuse_lib_poll(fuse_req_t req,
fuse_pollhandle_t *ph = NULL; fuse_pollhandle_t *ph = NULL;
const struct fuse_poll_in *arg; const struct fuse_poll_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_poll_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
if(arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) if(arg->flags & FUSE_POLL_SCHEDULE_NOTIFY)
@ -3476,7 +3471,7 @@ fuse_lib_fallocate(fuse_req_t req,
fuse_file_info_t ffi = {0}; fuse_file_info_t ffi = {0};
const struct fuse_fallocate_in *arg; const struct fuse_fallocate_in *arg;
arg = fuse_hdr_arg(hdr_); arg = (fuse_fallocate_in*)fuse_hdr_arg(hdr_);
ffi.fh = arg->fh; ffi.fh = arg->fh;
f = req_fuse_prepare(req); f = req_fuse_prepare(req);
@ -3494,8 +3489,8 @@ int
remembered_node_cmp(const void *a_, remembered_node_cmp(const void *a_,
const void *b_) const void *b_)
{ {
const remembered_node_t *a = a_; const remembered_node_t *a = (const remembered_node_t*)a_;
const remembered_node_t *b = b_; const remembered_node_t *b = (const remembered_node_t*)b_;
return (a->time - b->time); return (a->time - b->time);
} }
@ -3911,7 +3906,7 @@ fuse_invalidate_all_nodes()
syslog(LOG_INFO,"invalidating file entries"); syslog(LOG_INFO,"invalidating file entries");
pthread_mutex_lock(&f->lock); pthread_mutex_lock(&f->lock);
for(int i = 0; i < f->id_table.size; i++) for(size_t i = 0; i < f->id_table.size; i++)
{ {
node_t *node; node_t *node;

182
libfuse/lib/fuse_lowlevel.c → libfuse/lib/fuse_lowlevel.cpp
View File

@ -6,12 +6,14 @@
See the file COPYING.LIB See the file COPYING.LIB
*/ */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE #define _GNU_SOURCE
#endif
#include "lfmp.h" #include "lfmp.h"
#include "config.h" #include "config.h"
#include "debug.h" #include "debug.hpp"
#include "fuse_i.h" #include "fuse_i.h"
#include "fuse_kernel.h" #include "fuse_kernel.h"
#include "fuse_opt.h" #include "fuse_opt.h"
@ -41,7 +43,7 @@
#define OFFSET_MAX 0x7fffffffffffffffLL #define OFFSET_MAX 0x7fffffffffffffffLL
#define container_of(ptr, type, member) ({ \ #define container_of(ptr, type, member) ({ \
const typeof( ((type*)0)->member ) *__mptr = (ptr); \ const decltype( ((type*)0)->member ) *__mptr = (ptr); \
(type *)( (char*)__mptr - offsetof(type,member) );}) (type *)( (char*)__mptr - offsetof(type,member) );})
static size_t pagesize; static size_t pagesize;
@ -135,7 +137,7 @@ fuse_send_msg(struct fuse_ll *f,
int count) int count)
{ {
int rv; int rv;
struct fuse_out_header *out = iov[0].iov_base; struct fuse_out_header *out = (fuse_out_header*)iov[0].iov_base;
out->len = iov_length(iov, count); out->len = iov_length(iov, count);
@ -410,7 +412,7 @@ fuse_send_data_iov_fallback(struct fuse_ll *f,
return -ENOMEM; return -ENOMEM;
mem_buf.buf[0].mem = msgbuf->mem; mem_buf.buf[0].mem = msgbuf->mem;
res = fuse_buf_copy(&mem_buf, buf, 0); res = fuse_buf_copy(&mem_buf, buf, (fuse_buf_copy_flags)0);
if(res < 0) if(res < 0)
{ {
msgbuf_free(msgbuf); msgbuf_free(msgbuf);
@ -550,7 +552,7 @@ fuse_ioctl_iovec_copy(const struct iovec *iov,
struct fuse_ioctl_iovec *fiov; struct fuse_ioctl_iovec *fiov;
size_t i; size_t i;
fiov = malloc(sizeof(fiov[0]) * count); fiov = (fuse_ioctl_iovec*)malloc(sizeof(fiov[0]) * count);
if(!fiov) if(!fiov)
return NULL; return NULL;
@ -683,7 +685,7 @@ fuse_reply_ioctl_iov(fuse_req_t req,
struct fuse_ioctl_out arg = {0}; struct fuse_ioctl_out arg = {0};
int res; int res;
padded_iov = malloc((count + 2) * sizeof(struct iovec)); padded_iov = (iovec*)malloc((count + 2) * sizeof(struct iovec));
if(padded_iov == NULL) if(padded_iov == NULL)
return fuse_reply_err(req, ENOMEM); return fuse_reply_err(req, ENOMEM);
@ -896,7 +898,7 @@ do_readdir(fuse_req_t req,
static static
void void
do_readdir_plus(fuse_req_t req_, do_readdirplus(fuse_req_t req_,
struct fuse_in_header *hdr_) struct fuse_in_header *hdr_)
{ {
req_->f->op.readdir_plus(req_,hdr_); req_->f->op.readdir_plus(req_,hdr_);
@ -1372,7 +1374,6 @@ void
do_setupmapping(fuse_req_t req_, do_setupmapping(fuse_req_t req_,
struct fuse_in_header *hdr_) struct fuse_in_header *hdr_)
{ {
printf("setupmapping\n");
req_->f->op.setupmapping(req_,hdr_); req_->f->op.setupmapping(req_,hdr_);
} }
@ -1381,7 +1382,6 @@ void
do_removemapping(fuse_req_t req_, do_removemapping(fuse_req_t req_,
struct fuse_in_header *hdr_) struct fuse_in_header *hdr_)
{ {
printf("removemapping\n");
req_->f->op.removemapping(req_,hdr_); req_->f->op.removemapping(req_,hdr_);
} }
@ -1390,7 +1390,6 @@ void
do_syncfs(fuse_req_t req_, do_syncfs(fuse_req_t req_,
struct fuse_in_header *hdr_) struct fuse_in_header *hdr_)
{ {
printf("syncfs\n");
req_->f->op.syncfs(req_,hdr_); req_->f->op.syncfs(req_,hdr_);
} }
@ -1399,10 +1398,33 @@ void
do_tmpfile(fuse_req_t req_, do_tmpfile(fuse_req_t req_,
struct fuse_in_header *hdr_) struct fuse_in_header *hdr_)
{ {
printf("tmpfile\n");
req_->f->op.tmpfile(req_,hdr_); req_->f->op.tmpfile(req_,hdr_);
} }
static
void
do_statx(fuse_req_t req_,
struct fuse_in_header *hdr_)
{
req_->f->op.statx(req_,hdr_);
}
static
void
do_rename2(fuse_req_t req_,
struct fuse_in_header *hdr_)
{
req_->f->op.rename2(req_,hdr_);
}
static
void
do_lseek(fuse_req_t req_,
struct fuse_in_header *hdr_)
{
req_->f->op.lseek(req_,hdr_);
}
static static
int int
send_notify_iov(struct fuse_ll *f, send_notify_iov(struct fuse_ll *f,
@ -1624,7 +1646,7 @@ fuse_lowlevel_notify_retrieve(struct fuse_chan *ch,
if(f->conn.proto_minor < 15) if(f->conn.proto_minor < 15)
return -ENOSYS; return -ENOSYS;
rreq = malloc(sizeof(*rreq)); rreq = (fuse_retrieve_req*)malloc(sizeof(*rreq));
if(rreq == NULL) if(rreq == NULL)
return -ENOMEM; return -ENOMEM;
@ -1668,61 +1690,69 @@ fuse_req_ctx(fuse_req_t req)
return &req->ctx; return &req->ctx;
} }
static struct { #define FUSE_OPCODE_LEN (FUSE_STATX + 1)
void (*func)(fuse_req_t, struct fuse_in_header *);
const char *name; typedef void (*fuse_ll_func)(fuse_req_t, struct fuse_in_header *);
} fuse_ll_ops[] = const
fuse_ll_func
fuse_ll_funcs[FUSE_OPCODE_LEN] =
{ {
[FUSE_LOOKUP] = { do_lookup, "LOOKUP" }, NULL,
[FUSE_FORGET] = { do_forget, "FORGET" }, do_lookup,
[FUSE_GETATTR] = { do_getattr, "GETATTR" }, do_forget,
[FUSE_SETATTR] = { do_setattr, "SETATTR" }, do_getattr,
[FUSE_READLINK] = { do_readlink, "READLINK" }, do_setattr,
[FUSE_SYMLINK] = { do_symlink, "SYMLINK" }, do_readlink,
[FUSE_MKNOD] = { do_mknod, "MKNOD" }, do_symlink,
[FUSE_MKDIR] = { do_mkdir, "MKDIR" }, NULL,
[FUSE_UNLINK] = { do_unlink, "UNLINK" }, do_mknod,
[FUSE_RMDIR] = { do_rmdir, "RMDIR" }, do_mkdir,
[FUSE_RENAME] = { do_rename, "RENAME" }, do_unlink,
[FUSE_LINK] = { do_link, "LINK" }, do_rmdir,
[FUSE_OPEN] = { do_open, "OPEN" }, do_rename,
[FUSE_READ] = { do_read, "READ" }, do_link,
[FUSE_WRITE] = { do_write, "WRITE" }, do_open,
[FUSE_STATFS] = { do_statfs, "STATFS" }, do_read,
[FUSE_RELEASE] = { do_release, "RELEASE" }, do_write,
[FUSE_FSYNC] = { do_fsync, "FSYNC" }, do_statfs,
[FUSE_SETXATTR] = { do_setxattr, "SETXATTR" }, do_release,
[FUSE_GETXATTR] = { do_getxattr, "GETXATTR" }, NULL,
[FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" }, do_fsync,
[FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" }, do_setxattr,
[FUSE_FLUSH] = { do_flush, "FLUSH" }, do_getxattr,
[FUSE_INIT] = { do_init, "INIT" }, do_listxattr,
[FUSE_OPENDIR] = { do_opendir, "OPENDIR" }, do_removexattr,
[FUSE_READDIR] = { do_readdir, "READDIR" }, do_flush,
[FUSE_READDIRPLUS] = { do_readdir_plus, "READDIR_PLUS" }, do_init,
[FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" }, do_opendir,
[FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" }, do_readdir,
[FUSE_GETLK] = { do_getlk, "GETLK" }, do_releasedir,
[FUSE_SETLK] = { do_setlk, "SETLK" }, do_fsyncdir,
[FUSE_SETLKW] = { do_setlkw, "SETLKW" }, do_getlk,
[FUSE_ACCESS] = { do_access, "ACCESS" }, do_setlk,
[FUSE_CREATE] = { do_create, "CREATE" }, do_setlkw,
[FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" }, do_access,
[FUSE_BMAP] = { do_bmap, "BMAP" }, do_create,
[FUSE_IOCTL] = { do_ioctl, "IOCTL" }, do_interrupt,
[FUSE_POLL] = { do_poll, "POLL" }, do_bmap,
[FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" }, do_destroy,
[FUSE_DESTROY] = { do_destroy, "DESTROY" }, do_ioctl,
[FUSE_NOTIFY_REPLY] = { do_notify_reply, "NOTIFY_REPLY" }, do_poll,
[FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" }, do_notify_reply,
[FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" }, do_batch_forget,
[FUSE_SETUPMAPPING] = { do_setupmapping, "SETUPMAPPING" }, do_fallocate,
[FUSE_REMOVEMAPPING] = { do_removemapping, "REMOVEMAPPING" }, do_readdirplus,
[FUSE_SYNCFS] = { do_syncfs, "SYNCFS" }, do_rename2,
[FUSE_TMPFILE] = { do_tmpfile, "TMPFILE" } do_lseek,
do_copy_file_range,
do_setupmapping,
do_removemapping,
do_syncfs,
do_tmpfile,
do_statx
}; };
#define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0])) #define FUSE_MAXOPS (sizeof(fuse_ll_funcs) / sizeof(fuse_ll_funcs[0]))
enum { enum {
KEY_HELP, KEY_HELP,
@ -1816,7 +1846,7 @@ fuse_ll_destroy(void *data)
f->op.destroy(f->userdata); f->op.destroy(f->userdata);
} }
llp = pthread_getspecific(f->pipe_key); llp = (fuse_ll_pipe*)pthread_getspecific(f->pipe_key);
if(llp != NULL) if(llp != NULL)
fuse_ll_pipe_free(llp); fuse_ll_pipe_free(llp);
pthread_key_delete(f->pipe_key); pthread_key_delete(f->pipe_key);
@ -1830,7 +1860,7 @@ static
void void
fuse_ll_pipe_destructor(void *data) fuse_ll_pipe_destructor(void *data)
{ {
struct fuse_ll_pipe *llp = data; struct fuse_ll_pipe *llp = (fuse_ll_pipe*)data;
fuse_ll_pipe_free(llp); fuse_ll_pipe_free(llp);
} }
@ -1872,7 +1902,7 @@ fuse_ll_buf_receive_read(struct fuse_session *se_,
if(rv == -1) if(rv == -1)
return -errno; return -errno;
if(rv < sizeof(struct fuse_in_header)) if(rv < (int)sizeof(struct fuse_in_header))
{ {
fprintf(stderr, "short read from fuse device\n"); fprintf(stderr, "short read from fuse device\n");
return -EIO; return -EIO;
@ -1892,8 +1922,6 @@ fuse_ll_buf_process_read(struct fuse_session *se_,
in = (struct fuse_in_header*)msgbuf_->mem; in = (struct fuse_in_header*)msgbuf_->mem;
// printf("%d\n",in->opcode);
req = fuse_ll_alloc_req(se_->f); req = fuse_ll_alloc_req(se_->f);
if(req == NULL) if(req == NULL)
return fuse_send_enomem(se_->f,se_->ch,in->unique); return fuse_send_enomem(se_->f,se_->ch,in->unique);
@ -1905,12 +1933,12 @@ fuse_ll_buf_process_read(struct fuse_session *se_,
req->ch = se_->ch; req->ch = se_->ch;
err = ENOSYS; err = ENOSYS;
if(in->opcode >= FUSE_MAXOP) if(in->opcode >= FUSE_MAXOPS)
goto reply_err; goto reply_err;
if(fuse_ll_ops[in->opcode].func == NULL) if(fuse_ll_funcs[in->opcode] == NULL)
goto reply_err; goto reply_err;
fuse_ll_ops[in->opcode].func(req, in); fuse_ll_funcs[in->opcode](req, in);
return; return;
@ -1943,12 +1971,12 @@ fuse_ll_buf_process_read_init(struct fuse_session *se_,
err = EIO; err = EIO;
if(in->opcode != FUSE_INIT) if(in->opcode != FUSE_INIT)
goto reply_err; goto reply_err;
if(fuse_ll_ops[in->opcode].func == NULL) if(fuse_ll_funcs[FUSE_INIT] == NULL)
goto reply_err; goto reply_err;
se_->process_buf = fuse_ll_buf_process_read; se_->process_buf = fuse_ll_buf_process_read;
fuse_ll_ops[in->opcode].func(req, in); fuse_ll_funcs[in->opcode](req,in);
return; return;
@ -2007,9 +2035,9 @@ fuse_lowlevel_new_common(struct fuse_args *args,
f->userdata = userdata; f->userdata = userdata;
se = fuse_session_new(f, se = fuse_session_new(f,
fuse_ll_buf_receive_read, (void*)fuse_ll_buf_receive_read,
fuse_ll_buf_process_read_init, (void*)fuse_ll_buf_process_read_init,
fuse_ll_destroy); (void*)fuse_ll_destroy);
if(!se) if(!se)
goto out_key_destroy; goto out_key_destroy;

12
libfuse/lib/node.h
View File

@ -1,3 +1,5 @@
#pragma once
#include "lock.h" #include "lock.h"
#include "lfmp.h" #include "lfmp.h"
@ -23,8 +25,18 @@ struct node_s
uint8_t is_stat_cache_valid:1; uint8_t is_stat_cache_valid:1;
}; };
#ifdef __cplusplus
extern "C"
{
#endif
node_t *node_alloc(); node_t *node_alloc();
void node_free(node_t*); void node_free(node_t*);
int node_gc1(); int node_gc1();
void node_gc(); void node_gc();
lfmp_t *node_lfmp(); lfmp_t *node_lfmp();
#ifdef __cplusplus
}
#endif