Struct FuseFs 

pub struct FuseFs { /* private fields */ }

Implementations

impl FuseFs

pub fn new(virtual_fs: Arc<dyn VirtualFs>) -> Self

Trait Implementations

impl FileSystem for FuseFs

fn init<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Initialize filesystem. Called before any other filesystem method.

fn destroy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Clean up filesystem. Called on filesystem exit.

fn lookup<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: INum, name: &'life3 str, reply: ReplyEntry<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Look up a directory entry by name and get its attributes.

fn getattr<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, reply: ReplyAttr<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get file attributes.

fn open<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, flags: u32, reply: ReplyOpen<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Open a file. Open flags (with the exception of O_CREAT, O_EXCL, O_NOCTTY and O_TRUNC) are available in flags. Filesystem may store an arbitrary file handle (pointer, index, etc) in fh, and use self in other all other file operations (read, write, flush, release, fsync). Filesystem may also implement stateless file I/O and not store anything in fh. There are also some flags (direct_io, keep_cache) which the filesystem may set, to change the way the file is opened. See fuse_file_info structure in fuse_common.h for more details.

fn forget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, nlookup: u64, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Forget about an inode. The nlookup parameter indicates the number of lookups previously performed on self inode. If the filesystem implements inode lifetimes, it is recommended that inodes acquire a single reference on each lookup, and lose nlookup references on each forget. The filesystem may ignore forget calls, if the inodes don’t need to have a limited lifetime. On unmount it is not guaranteed, that all referenced inodes will receive a forget message.

fn setattr<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, param: SetAttrParam, reply: ReplyAttr<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set file attributes.

fn mknod<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, param: CreateParam, reply: ReplyEntry<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create file node. Create a regular file, character device, block device, fifo or socket node.

fn mkdir<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: INum, name: &'life3 str, mode: u32, reply: ReplyEntry<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Create a directory.

fn unlink<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: INum, name: &'life3 str, reply: ReplyEmpty<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Remove a file.

fn rmdir<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: INum, dir_name: &'life3 str, reply: ReplyEmpty<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Remove a directory.

fn rename<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, param: RenameParam, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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).

flags may be RENAME_EXCHANGE or RENAME_NOREPLACE. If RENAME_NOREPLACE is specified, the filesystem must not overwrite newname if it exists and return an error instead. If RENAME_EXCHANGE is specified, the filesystem must atomically exchange the two files, i.e. both must exist and neither may be deleted.

fn read<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, offset: i64, size: u32, reply: ReplyData<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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 self 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 self operation. fh will contain the value set by the open method, or will be undefined if the open method didn’t set any value.

fn write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, offset: i64, data: Vec<u8>, flags: u32, reply: ReplyWrite<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Write data. Write should return exactly the number of bytes requested except on error. An exception to self 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 self operation. fh will contain the value set by the open method, or will be undefined if the open method did not set any value.

fn flush<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, lock_owner: u64, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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 should not assume that flush will always be called after some writes, or that if will be called at all. fh will contain the value set by the open method, or will be undefined if the open method did not 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 lock_owner.

fn release<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, flags: u32, lock_owner: u64, flush: bool, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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. fh will contain the value set by the open method, or will be undefined if the open method didn’t set any value. flags will contain the same flags as for open.

fn fsync<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, datasync: bool, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Synchronize file contents. If the datasync parameter is non-zero, then only the user data should be flushed, not the meta data.

fn opendir<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, flags: u32, reply: ReplyOpen<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Open a directory. Filesystem may store an arbitrary file handle (pointer, index, etc) in fh, and use self in other all other directory stream operations (readdir, releasedir, fsyncdir). Filesystem may also implement stateless directory I/O and not store anything in 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.

fn readdir<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, offset: i64, reply: ReplyDirectory<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read directory. Send a buffer filled using buffer.fill(), with size not exceeding the requested size. Send an empty buffer on end of stream. fh will contain the value set by the opendir method, or will be undefined if the opendir method didn’t set any value.

fn releasedir<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, flags: u32, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Release an open directory. For every opendir call there will be exactly one releasedir call. fh will contain the value set by the opendir method, or will be undefined if the opendir method didn’t set any value.

fn fsyncdir<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, fh: u64, datasync: bool, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Synchronize directory contents. If the datasync parameter is set, then only the directory contents should be flushed, not the meta data. fh will contain the value set by the opendir method, or will be undefined if the opendir method didn’t set any value.

fn statfs<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, reply: ReplyStatFs<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get file system statistics. The f_favail, f_fsid and f_flag fields are ignored

fn readlink<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, reply: ReplyData<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read symbolic link.

fn symlink<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: INum, name: &'life3 str, target_path: &'life4 Path, reply: ReplyEntry<'life5>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Create a symbolic link.

fn interrupt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, unique: u64, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Interrupt another FUSE request

fn link<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, newparent: u64, newname: &'life3 str, reply: ReplyEntry<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Create a hard link.

fn setxattr<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, name: &'life3 str, value: &'life4 [u8], flags: u32, position: u32, reply: ReplyEmpty<'life5>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Set an extended attribute.

fn getxattr<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, name: &'life3 str, size: u32, reply: ReplyXAttr<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Get an extended attribute. If size is 0, the size of the value should be sent with reply.size(). If size is not 0, and the value fits, send it with reply.data(), or reply.error(ERANGE) if it doesn’t.

fn listxattr<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, size: u32, reply: ReplyXAttr<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

List extended attribute names. If size is 0, the size of the value should be sent with reply.size(). If size is not 0, and the value fits, send it with reply.data(), or reply.error(ERANGE) if it doesn’t.

fn removexattr<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, name: &'life3 str, reply: ReplyEmpty<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Remove an extended attribute.

fn access<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, mask: u32, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Check file access permissions. This will be called for the access() system call. If the default_permissions mount option is given, self method is not called. This method is not called under Linux kernel versions 2.4.x

fn create<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, parent: u64, name: &'life3 str, mode: u32, flags: u32, reply: ReplyCreate<'life4>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

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 flags. Filesystem may store an arbitrary file handle (pointer, index, etc) in fh, and use self 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, to change the way the file is opened. See fuse_file_info structure in fuse_common.h for more details. If self method is not implemented or under Linux kernel versions earlier than 2.6.15, the mknod() and open() methods will be called instead.

fn getlk<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, lk_param: FileLockParam, reply: ReplyLock<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Test for a POSIX file lock.

fn setlk<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, lk_param: FileLockParam, sleep: bool, reply: ReplyEmpty<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Acquire, modify or release a POSIX file lock. For POSIX threads (NPTL) there’s a 1-1 relation between pid and owner, but otherwise self 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 self 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.

fn bmap<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, req: &'life1 Request<'life2>, blocksize: u32, idx: u64, reply: ReplyBMap<'life3>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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