Struct fuse_backend_rs::passthrough::PassthroughFs

pub struct PassthroughFs<S: BitmapSlice + Send + Sync = ()> { /* private fields */ }

A file system that simply “passes through” all requests it receives to the underlying file system.

To keep the implementation simple it servers the contents of its root directory. Users that wish to serve only a specific directory should set up the environment so that that directory ends up as the root of the file system process. One way to accomplish this is via a combination of mount namespaces and the pivot_root system call.

Implementations

impl<S: BitmapSlice + Send + Sync> PassthroughFs<S>

pub fn new(cfg: Config) -> Result<PassthroughFs<S>>

Create a Passthrough file system instance.

pub fn import(&self) -> Result<()>

Initialize the Passthrough file system.

pub fn keep_fds(&self) -> Vec<RawFd>

Get the list of file descriptors which should be reserved across live upgrade.

pub fn readlinkat_proc_file(&self, inode: u64) -> Result<PathBuf>

Get the file pathname corresponding to the Inode This function is used by Nydus blobfs

Trait Implementations

impl<S: BitmapSlice + Send + Sync> AsyncFileSystem for PassthroughFs<S>

fn async_lookup<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    parent: <Self as FileSystem>::Inode,
    name: &'life2 CStr
) -> Pin<Box<dyn Future<Output = Result<Entry>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

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

fn async_getattr<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    handle: Option<<Self as FileSystem>::Handle>
) -> Pin<Box<dyn Future<Output = Result<(stat64, Duration)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Get attributes for a file / directory.

fn async_setattr<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    attr: stat64,
    handle: Option<<Self as FileSystem>::Handle>,
    valid: SetattrValid
) -> Pin<Box<dyn Future<Output = Result<(stat64, Duration)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Set attributes for a file / directory.

fn async_open<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    flags: u32,
    fuse_flags: u32
) -> Pin<Box<dyn Future<Output = Result<(Option<<Self as FileSystem>::Handle>, OpenOptions)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Open a file.

fn async_create<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    parent: <Self as FileSystem>::Inode,
    name: &'life2 CStr,
    args: CreateIn
) -> Pin<Box<dyn Future<Output = Result<(Entry, Option<<Self as FileSystem>::Handle>, OpenOptions)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Create and open a file.

fn async_read<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    handle: <Self as FileSystem>::Handle,
    w: &'life2 mut (dyn AsyncZeroCopyWriter + Send),
    size: u32,
    offset: u64,
    _lock_owner: Option<u64>,
    _flags: u32
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Read data from a file.

fn async_write<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    handle: <Self as FileSystem>::Handle,
    r: &'life2 mut (dyn AsyncZeroCopyReader + Send),
    size: u32,
    offset: u64,
    _lock_owner: Option<u64>,
    _delayed_write: bool,
    _flags: u32,
    fuse_flags: u32
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Write data to a file.

fn async_fsync<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    datasync: bool,
    handle: <Self as FileSystem>::Handle
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Synchronize file contents.

fn async_fallocate<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    handle: <Self as FileSystem>::Handle,
    mode: u32,
    offset: u64,
    length: u64
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Allocate requested space for file data.

fn async_fsyncdir<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    inode: <Self as FileSystem>::Inode,
    datasync: bool,
    handle: <Self as FileSystem>::Handle
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Synchronize the contents of a directory.

impl<S: BitmapSlice + Send + Sync + 'static> BackendFileSystem for PassthroughFs<S>

fn mount(&self) -> Result<(Entry, u64)>

mount returns the backend file system root inode entry and the largest inode number it has.

fn as_any(&self) -> &dyn Any

Provides a reference to the Any trait. This is useful to let the caller have access to the underlying type behind the trait.

impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S>

type Inode = u64

Represents a location in the filesystem tree and can be used to perform operations that act on the metadata of a file/directory (e.g., getattr and setattr). Can also be used as the starting point for looking up paths in the filesystem tree. An Inode may support operating directly on the content of the path that to which it points. FileSystem implementations that support this should set the FsOptions::ZERO_MESSAGE_OPEN option in the return value of the init function. On linux based systems, an Inode is equivalent to opening a file or directory with the libc::O_PATH flag.

type Handle = u64

Represents a file or directory that is open for reading/writing.

fn init(&self, capable: FsOptions) -> Result<FsOptions>

Initialize the file system.

fn destroy(&self)

Clean up the file system.

fn statfs(&self, _ctx: &Context, inode: u64) -> Result<statvfs64>

Get information about the file system.

fn lookup(&self, _ctx: &Context, parent: u64, name: &CStr) -> Result<Entry>

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

fn forget(&self, _ctx: &Context, inode: u64, count: u64)

Forget about an inode.

fn batch_forget(&self, _ctx: &Context, requests: Vec<(u64, u64)>)

Forget about multiple inodes.

fn opendir(
    &self,
    _ctx: &Context,
    inode: u64,
    flags: u32
) -> Result<(Option<u64>, OpenOptions)>

Open a directory for reading.

fn releasedir(
    &self,
    _ctx: &Context,
    inode: u64,
    _flags: u32,
    handle: u64
) -> Result<()>

Release an open directory.

fn mkdir(
    &self,
    ctx: &Context,
    parent: u64,
    name: &CStr,
    mode: u32,
    umask: u32
) -> Result<Entry>

Create a directory.

fn rmdir(&self, _ctx: &Context, parent: u64, name: &CStr) -> Result<()>

Remove a directory.

fn readdir(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    size: u32,
    offset: u64,
    add_entry: &mut dyn FnMut(DirEntry<'_>) -> Result<usize>
) -> Result<()>

Read a directory.

fn readdirplus(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    size: u32,
    offset: u64,
    add_entry: &mut dyn FnMut(DirEntry<'_>, Entry) -> Result<usize>
) -> Result<()>

Read a directory with entry attributes.

fn open(
    &self,
    _ctx: &Context,
    inode: u64,
    flags: u32,
    fuse_flags: u32
) -> Result<(Option<u64>, OpenOptions)>

Open a file.

fn release(
    &self,
    _ctx: &Context,
    inode: u64,
    _flags: u32,
    handle: u64,
    _flush: bool,
    _flock_release: bool,
    _lock_owner: Option<u64>
) -> Result<()>

Release an open file.

fn create(
    &self,
    ctx: &Context,
    parent: u64,
    name: &CStr,
    args: CreateIn
) -> Result<(Entry, Option<u64>, OpenOptions)>

Create and open a file.

fn unlink(&self, _ctx: &Context, parent: u64, name: &CStr) -> Result<()>

Remove a file.

fn setupmapping(
    &self,
    _ctx: &Context,
    inode: u64,
    _handle: u64,
    foffset: u64,
    len: u64,
    flags: u64,
    moffset: u64,
    vu_req: &mut dyn FsCacheReqHandler
) -> Result<()>

Setup a mapping so that guest can access files in DAX style.

fn removemapping(
    &self,
    _ctx: &Context,
    _inode: u64,
    requests: Vec<RemovemappingOne>,
    vu_req: &mut dyn FsCacheReqHandler
) -> Result<()>

Teardown a mapping which was setup for guest DAX style access.

fn read(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    w: &mut dyn ZeroCopyWriter,
    size: u32,
    offset: u64,
    _lock_owner: Option<u64>,
    _flags: u32
) -> Result<usize>

Read data from a file.

fn write(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    r: &mut dyn ZeroCopyReader,
    size: u32,
    offset: u64,
    _lock_owner: Option<u64>,
    _delayed_write: bool,
    _flags: u32,
    fuse_flags: u32
) -> Result<usize>

Write data to a file.

fn getattr(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: Option<u64>
) -> Result<(stat64, Duration)>

Get attributes for a file / directory.

fn setattr(
    &self,
    _ctx: &Context,
    inode: u64,
    attr: stat64,
    handle: Option<u64>,
    valid: SetattrValid
) -> Result<(stat64, Duration)>

Set attributes for a file / directory.

fn rename(
    &self,
    _ctx: &Context,
    olddir: u64,
    oldname: &CStr,
    newdir: u64,
    newname: &CStr,
    flags: u32
) -> Result<()>

Rename a file / directory.

fn mknod(
    &self,
    ctx: &Context,
    parent: u64,
    name: &CStr,
    mode: u32,
    rdev: u32,
    umask: u32
) -> Result<Entry>

Create a file node.

fn link(
    &self,
    _ctx: &Context,
    inode: u64,
    newparent: u64,
    newname: &CStr
) -> Result<Entry>

Create a hard link.

fn symlink(
    &self,
    ctx: &Context,
    linkname: &CStr,
    parent: u64,
    name: &CStr
) -> Result<Entry>

Create a symbolic link.

fn readlink(&self, _ctx: &Context, inode: u64) -> Result<Vec<u8>>

Read a symbolic link.

fn flush(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    _lock_owner: u64
) -> Result<()>

Flush the contents of a file.

fn fsync(
    &self,
    _ctx: &Context,
    inode: u64,
    datasync: bool,
    handle: u64
) -> Result<()>

Synchronize file contents.

fn fsyncdir(
    &self,
    ctx: &Context,
    inode: u64,
    datasync: bool,
    handle: u64
) -> Result<()>

Synchronize the contents of a directory.

fn access(&self, ctx: &Context, inode: u64, mask: u32) -> Result<()>

Check file access permissions.

fn setxattr(
    &self,
    _ctx: &Context,
    inode: u64,
    name: &CStr,
    value: &[u8],
    flags: u32
) -> Result<()>

Set an extended attribute.

fn getxattr(
    &self,
    _ctx: &Context,
    inode: u64,
    name: &CStr,
    size: u32
) -> Result<GetxattrReply>

Get an extended attribute.

fn listxattr(
    &self,
    _ctx: &Context,
    inode: u64,
    size: u32
) -> Result<ListxattrReply>

List extended attribute names.

fn removexattr(&self, _ctx: &Context, inode: u64, name: &CStr) -> Result<()>

Remove an extended attribute.

fn fallocate(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    mode: u32,
    offset: u64,
    length: u64
) -> Result<()>

Allocate requested space for file data.

fn lseek(
    &self,
    _ctx: &Context,
    inode: u64,
    handle: u64,
    offset: u64,
    whence: u32
) -> Result<u64>

Reposition read/write file offset.

fn getlk(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    handle: Self::Handle,
    owner: u64,
    lock: FileLock,
    flags: u32
) -> Result<FileLock>

Query file lock status

fn setlk(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    handle: Self::Handle,
    owner: u64,
    lock: FileLock,
    flags: u32
) -> Result<()>

Grab a file read lock

fn setlkw(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    handle: Self::Handle,
    owner: u64,
    lock: FileLock,
    flags: u32
) -> Result<()>

Grab a file write lock

fn ioctl(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    handle: Self::Handle,
    flags: u32,
    cmd: u32,
    data: IoctlData<'_>,
    out_size: u32
) -> Result<IoctlData<'_>>

send ioctl to the file

fn bmap(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    block: u64,
    blocksize: u32
) -> Result<u64>

Query a file’s block mapping info

fn poll(
    &self,
    ctx: &Context,
    inode: Self::Inode,
    handle: Self::Handle,
    khandle: Self::Handle,
    flags: u32,
    events: u32
) -> Result<u32>

Poll a file’s events

fn notify_reply(&self) -> Result<()>

TODO: support this