Trait DynFileSystem 

pub trait DynFileSystem: Send + Sync {
    // Provided methods
    fn init(&self, capable: FsOptions) -> Result<FsOptions, Error> { ... }
    fn destroy(&self) { ... }
    fn lookup(
        &self,
        ctx: Context,
        parent: u64,
        name: &CStr,
    ) -> Result<Entry, Error> { ... }
    fn forget(&self, ctx: Context, inode: u64, count: u64) { ... }
    fn batch_forget(&self, ctx: Context, requests: Vec<(u64, u64)>) { ... }
    fn getattr(
        &self,
        ctx: Context,
        inode: u64,
        handle: Option<u64>,
    ) -> Result<(stat64, Duration), Error> { ... }
    fn setattr(
        &self,
        ctx: Context,
        inode: u64,
        attr: stat64,
        handle: Option<u64>,
        valid: SetattrValid,
    ) -> Result<(stat64, Duration), Error> { ... }
    fn readlink(&self, ctx: Context, inode: u64) -> Result<Vec<u8>, Error> { ... }
    fn symlink(
        &self,
        ctx: Context,
        linkname: &CStr,
        parent: u64,
        name: &CStr,
        extensions: Extensions,
    ) -> Result<Entry, Error> { ... }
    fn mknod(
        &self,
        ctx: Context,
        inode: u64,
        name: &CStr,
        mode: u32,
        rdev: u32,
        umask: u32,
        extensions: Extensions,
    ) -> Result<Entry, Error> { ... }
    fn mkdir(
        &self,
        ctx: Context,
        parent: u64,
        name: &CStr,
        mode: u32,
        umask: u32,
        extensions: Extensions,
    ) -> Result<Entry, Error> { ... }
    fn unlink(
        &self,
        ctx: Context,
        parent: u64,
        name: &CStr,
    ) -> Result<(), Error> { ... }
    fn rmdir(&self, ctx: Context, parent: u64, name: &CStr) -> Result<(), Error> { ... }
    fn rename(
        &self,
        ctx: Context,
        olddir: u64,
        oldname: &CStr,
        newdir: u64,
        newname: &CStr,
        flags: u32,
    ) -> Result<(), Error> { ... }
    fn link(
        &self,
        ctx: Context,
        inode: u64,
        newparent: u64,
        newname: &CStr,
    ) -> Result<Entry, Error> { ... }
    fn open(
        &self,
        ctx: Context,
        inode: u64,
        kill_priv: bool,
        flags: u32,
    ) -> Result<(Option<u64>, OpenOptions), Error> { ... }
    fn create(
        &self,
        ctx: Context,
        parent: u64,
        name: &CStr,
        mode: u32,
        kill_priv: bool,
        flags: u32,
        umask: u32,
        extensions: Extensions,
    ) -> Result<(Entry, Option<u64>, OpenOptions), Error> { ... }
    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, Error> { ... }
    fn write(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        r: &mut dyn ZeroCopyReader,
        size: u32,
        offset: u64,
        lock_owner: Option<u64>,
        delayed_write: bool,
        kill_priv: bool,
        flags: u32,
    ) -> Result<usize, Error> { ... }
    fn flush(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        lock_owner: u64,
    ) -> Result<(), Error> { ... }
    fn fsync(
        &self,
        ctx: Context,
        inode: u64,
        datasync: bool,
        handle: u64,
    ) -> Result<(), Error> { ... }
    fn fallocate(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        mode: u32,
        offset: u64,
        length: u64,
    ) -> Result<(), Error> { ... }
    fn release(
        &self,
        ctx: Context,
        inode: u64,
        flags: u32,
        handle: u64,
        flush: bool,
        flock_release: bool,
        lock_owner: Option<u64>,
    ) -> Result<(), Error> { ... }
    fn statfs(&self, ctx: Context, inode: u64) -> Result<statvfs64, Error> { ... }
    fn setxattr(
        &self,
        ctx: Context,
        inode: u64,
        name: &CStr,
        value: &[u8],
        flags: u32,
    ) -> Result<(), Error> { ... }
    fn getxattr(
        &self,
        ctx: Context,
        inode: u64,
        name: &CStr,
        size: u32,
    ) -> Result<GetxattrReply, Error> { ... }
    fn listxattr(
        &self,
        ctx: Context,
        inode: u64,
        size: u32,
    ) -> Result<ListxattrReply, Error> { ... }
    fn removexattr(
        &self,
        ctx: Context,
        inode: u64,
        name: &CStr,
    ) -> Result<(), Error> { ... }
    fn opendir(
        &self,
        ctx: Context,
        inode: u64,
        flags: u32,
    ) -> Result<(Option<u64>, OpenOptions), Error> { ... }
    fn readdir(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        size: u32,
        offset: u64,
    ) -> Result<Vec<DirEntry<'static>>, Error> { ... }
    fn readdirplus(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        size: u32,
        offset: u64,
    ) -> Result<Vec<(DirEntry<'static>, Entry)>, Error> { ... }
    fn fsyncdir(
        &self,
        ctx: Context,
        inode: u64,
        datasync: bool,
        handle: u64,
    ) -> Result<(), Error> { ... }
    fn releasedir(
        &self,
        ctx: Context,
        inode: u64,
        flags: u32,
        handle: u64,
    ) -> Result<(), Error> { ... }
    fn access(&self, ctx: Context, inode: u64, mask: u32) -> Result<(), Error> { ... }
    fn lseek(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        offset: u64,
        whence: u32,
    ) -> Result<u64, Error> { ... }
    fn copyfilerange(
        &self,
        ctx: Context,
        inode_in: u64,
        handle_in: u64,
        offset_in: u64,
        inode_out: u64,
        handle_out: u64,
        offset_out: u64,
        len: u64,
        flags: u64,
    ) -> Result<usize, Error> { ... }
    fn setupmapping(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        foffset: u64,
        len: u64,
        flags: u64,
        moffset: u64,
        host_shm_base: u64,
        shm_size: u64,
    ) -> Result<(), Error> { ... }
    fn removemapping(
        &self,
        ctx: Context,
        requests: Vec<RemovemappingOne>,
        host_shm_base: u64,
        shm_size: u64,
    ) -> Result<(), Error> { ... }
    fn ioctl(
        &self,
        ctx: Context,
        inode: u64,
        handle: u64,
        flags: u32,
        cmd: u32,
        arg: u64,
        in_size: u32,
        out_size: u32,
        exit_code: &Arc<Atomic<i32>>,
    ) -> Result<Vec<u8>, Error> { ... }
    fn getlk(&self) -> Result<(), Error> { ... }
    fn setlk(&self) -> Result<(), Error> { ... }
    fn setlkw(&self) -> Result<(), Error> { ... }
    fn bmap(&self) -> Result<(), Error> { ... }
    fn poll(&self) -> Result<(), Error> { ... }
    fn notify_reply(&self) -> Result<(), Error> { ... }
}

Object-safe filesystem trait for dynamic dispatch.

This trait mirrors the FileSystem trait but uses u64 directly for Inode and Handle instead of associated types, enabling object safety.

Most methods have default implementations that return ENOSYS, allowing implementations to only override the methods they need.

Provided Methods

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

Initialize the file system.

fn destroy(&self)

Clean up the file system.

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

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 getattr( &self, ctx: Context, inode: u64, handle: Option<u64>, ) -> Result<(stat64, Duration), Error>

Get attributes for a file / directory.

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

Set attributes for a file / directory.

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

Read a symbolic link.

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

Create a symbolic link.

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

Create a file node.

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

Create a directory.

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

Remove a file.

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

Remove a directory.

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

Rename a file / directory.

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

Create a hard link.

fn open( &self, ctx: Context, inode: u64, kill_priv: bool, flags: u32, ) -> Result<(Option<u64>, OpenOptions), Error>

Open a file.

fn create( &self, ctx: Context, parent: u64, name: &CStr, mode: u32, kill_priv: bool, flags: u32, umask: u32, extensions: Extensions, ) -> Result<(Entry, Option<u64>, OpenOptions), Error>

Create and open a file.

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, Error>

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, kill_priv: bool, flags: u32, ) -> Result<usize, Error>

Write data to a file.

fn flush( &self, ctx: Context, inode: u64, handle: u64, lock_owner: u64, ) -> Result<(), Error>

Flush the contents of a file.

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

Synchronize file contents.

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

Allocate requested space for file data.

fn release( &self, ctx: Context, inode: u64, flags: u32, handle: u64, flush: bool, flock_release: bool, lock_owner: Option<u64>, ) -> Result<(), Error>

Release an open file.

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

Get information about the file system.

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

Set an extended attribute.

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

Get an extended attribute.

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

List extended attribute names.

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

Remove an extended attribute.

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

Open a directory for reading.

fn readdir( &self, ctx: Context, inode: u64, handle: u64, size: u32, offset: u64, ) -> Result<Vec<DirEntry<'static>>, Error>

Read a directory.

Returns a vector of directory entries. Unlike the original FileSystem trait which uses a callback, this returns entries directly for object safety.

fn readdirplus( &self, ctx: Context, inode: u64, handle: u64, size: u32, offset: u64, ) -> Result<Vec<(DirEntry<'static>, Entry)>, Error>

Read a directory with entry attributes.

Returns a vector of (DirEntry, Entry) pairs. Unlike the original FileSystem trait which uses a callback, this returns entries directly for object safety.

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

Synchronize the contents of a directory.

fn releasedir( &self, ctx: Context, inode: u64, flags: u32, handle: u64, ) -> Result<(), Error>

Release an open directory.

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

Check file access permissions.

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

Reposition read/write file offset.

fn copyfilerange( &self, ctx: Context, inode_in: u64, handle_in: u64, offset_in: u64, inode_out: u64, handle_out: u64, offset_out: u64, len: u64, flags: u64, ) -> Result<usize, Error>

Copy a range of data from one file to another.

fn setupmapping( &self, ctx: Context, inode: u64, handle: u64, foffset: u64, len: u64, flags: u64, moffset: u64, host_shm_base: u64, shm_size: u64, ) -> Result<(), Error>

Setup a mapping for DAX.

fn removemapping( &self, ctx: Context, requests: Vec<RemovemappingOne>, host_shm_base: u64, shm_size: u64, ) -> Result<(), Error>

Remove a DAX mapping.

fn ioctl( &self, ctx: Context, inode: u64, handle: u64, flags: u32, cmd: u32, arg: u64, in_size: u32, out_size: u32, exit_code: &Arc<Atomic<i32>>, ) -> Result<Vec<u8>, Error>

Perform an ioctl on a file.

fn getlk(&self) -> Result<(), Error>

Get file lock (not yet supported).

fn setlk(&self) -> Result<(), Error>

Set file lock (not yet supported).

fn setlkw(&self) -> Result<(), Error>

Set file lock and wait (not yet supported).

fn bmap(&self) -> Result<(), Error>

Map block index to block number (not yet supported).

fn poll(&self) -> Result<(), Error>

Poll for events (not yet supported).

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

Reply to a notification (not yet supported).

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors