Enum polyfuse::Operation

pub enum Operation<'a, T> {
    Lookup(Lookup<'a>),
    Forget(&'a [Forget]),
    Getattr(Getattr<'a>),
    Setattr(Setattr<'a>),
    Readlink(Readlink<'a>),
    Symlink(Symlink<'a>),
    Mknod(Mknod<'a>),
    Mkdir(Mkdir<'a>),
    Unlink(Unlink<'a>),
    Rmdir(Rmdir<'a>),
    Rename(Rename<'a>),
    Link(Link<'a>),
    Open(Open<'a>),
    Read(Read<'a>),
    Write(Write<'a>, T),
    Release(Release<'a>),
    Statfs(Statfs<'a>),
    Fsync(Fsync<'a>),
    Setxattr(Setxattr<'a>),
    Getxattr(Getxattr<'a>),
    Listxattr(Listxattr<'a>),
    Removexattr(Removexattr<'a>),
    Flush(Flush<'a>),
    Opendir(Opendir<'a>),
    Readdir(Readdir<'a>),
    Releasedir(Releasedir<'a>),
    Fsyncdir(Fsyncdir<'a>),
    Getlk(Getlk<'a>),
    Setlk(Setlk<'a>),
    Flock(Flock<'a>),
    Access(Access<'a>),
    Create(Create<'a>),
    Bmap(Bmap<'a>),
    Fallocate(Fallocate<'a>),
    CopyFileRange(CopyFileRange<'a>),
    Poll(Poll<'a>),
}

The kind of FUSE requests received from the kernel.

Variants

Lookup(Lookup<'a>)

Look up a directory entry by name.

Forget(&'a [Forget])

Forget about inodes removed from the kernel's internal caches.

Getattr(Getattr<'a>)

Get file attributes.

Setattr(Setattr<'a>)

Set file attributes.

Readlink(Readlink<'a>)

Read a symbolic link.

Symlink(Symlink<'a>)

Create a symbolic link

Mknod(Mknod<'a>)

Create a file node.

Mkdir(Mkdir<'a>)

Create a directory.

Unlink(Unlink<'a>)

Remove a file.

Rmdir(Rmdir<'a>)

Remove a directory.

Rename(Rename<'a>)

Rename a file.

Link(Link<'a>)

Create a hard link.

Open(Open<'a>)

Open a file.

Read(Read<'a>)

Read data from an opened file.

Write(Write<'a>, T)

Write data to an opened file.

Release(Release<'a>)

Release an opened file.

Statfs(Statfs<'a>)

Get the filesystem statistics.

Fsync(Fsync<'a>)

Synchronize the file contents of an opened file.

When the parameter datasync is true, only the file contents should be flushed and the metadata does not have to be flushed.

Setxattr(Setxattr<'a>)

Set an extended attribute.

Getxattr(Getxattr<'a>)

Get an extended attribute.

The operation should send the length of attribute's value with reply.size(n) when size is equal to zero.

Listxattr(Listxattr<'a>)

List extended attribute names.

The attribute names must be seperated by a null character (i.e. b'\0').

The operation should send the length of attribute names with reply.size(n) when size is equal to zero.

Removexattr(Removexattr<'a>)

Remove an extended attribute.

Flush(Flush<'a>)

Close a file descriptor.

Opendir(Opendir<'a>)

Open a directory.

Readdir(Readdir<'a>)

Read contents from an opened directory.

Releasedir(Releasedir<'a>)

Release an opened directory.

Fsyncdir(Fsyncdir<'a>)

Synchronize an opened directory contents.

When the parameter datasync is true, only the directory contents should be flushed and the metadata does not have to be flushed.

Getlk(Getlk<'a>)

Test for a POSIX file lock.

Setlk(Setlk<'a>)

Acquire, modify or release a POSIX file lock.

Flock(Flock<'a>)

Acquire, modify or release a BSD file lock.

Access(Access<'a>)

Check file access permissions.

Create(Create<'a>)

Create and open a file.

Bmap(Bmap<'a>)

Map block index within a file to block index within device.

This operation makes sense only for filesystems that use block devices, and is called only when the mount options contains blkdev.

Fallocate(Fallocate<'a>)

Allocate requested space to an opened file.

CopyFileRange(CopyFileRange<'a>)

Copy a range of data from an opened file to another.

Poll(Poll<'a>)

Poll for readiness.

When kh is not None, the filesystem should send the notification about I/O readiness to the kernel.

Trait Implementations

impl<'a, T: Debug> Debug for Operation<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.