Struct FileSystem 

pub struct FileSystem {
    pub kernel: Weak<Kernel>,
    pub options: FileSystemOptions,
    pub dev_id: DeviceType,
    pub rename_mutex: Mutex<()>,
    pub security_state: FileSystemState,
    /* private fields */
}

A file system that can be mounted in a namespace.

Fields

kernel: Weak<Kernel>

options: FileSystemOptions

The options specified when mounting the filesystem. Saved here for display in /proc/[pid]/mountinfo.

dev_id: DeviceType

The device ID of this filesystem. Returned in the st_dev field when stating an inode in this filesystem.

rename_mutex: Mutex<()>

A file-system global mutex to serialize rename operations.

This mutex is useful because the invariants enforced during a rename operation involve many DirEntry objects. In the future, we might be able to remove this mutex, but we will need to think carefully about how rename operations can interleave.

See DirEntry::rename.

security_state: FileSystemState

Holds security state for this file system, which is created and used by the Linux Security Modules subsystem hooks.

Implementations

impl FileSystem

pub fn new<L>( locked: &mut Locked<L>, kernel: &Kernel, cache_mode: CacheMode, ops: impl FileSystemOps, options: FileSystemOptions, ) -> Result<FileSystemHandle, Errno>

where L: LockEqualOrBefore<FileOpsCore>,

Create a new filesystem.

pub fn has_permanent_entries(&self) -> bool

pub fn root(&self) -> &DirEntryHandle

The root directory entry of this file system.

Panics if this file system does not have a root directory.

pub fn maybe_root(&self) -> Option<&DirEntryHandle>

The root directory entry of this FileSystem, if it has one.

pub fn get_or_create_node<F>( &self, node_key: ino_t, create_fn: F, ) -> Result<FsNodeHandle, Errno>

where F: FnOnce() -> Result<FsNodeHandle, Errno>,

pub fn get_and_validate_or_create_node<V, C>( &self, node_key: ino_t, validate_fn: V, create_fn: C, ) -> Result<FsNodeHandle, Errno>

where V: FnOnce(&FsNodeHandle) -> bool, C: FnOnce() -> Result<FsNodeHandle, Errno>,

Get a node that is validated with the callback, or create an FsNode for this file system.

If node_id is Some, then this function checks the node cache to determine whether this node is already open. If so, the function returns the existing FsNode if it passes the validation check. If no node exists, or a node does but fails the validation check, the function calls the given create_fn function to create the FsNode.

If node_id is None, then this function assigns a new identifier number and calls the given create_fn function to create the FsNode with the assigned number.

Returns Err only if create_fn returns Err.

pub fn create_node( self: &Arc<Self>, ino: ino_t, ops: impl Into<Box<dyn FsNodeOps>>, info: FsNodeInfo, ) -> FsNodeHandle

File systems that produce their own IDs for nodes should invoke this function. The ones who leave to this object to assign the IDs should call |create_node_and_allocate_node_id|.

pub fn create_node_and_allocate_node_id( self: &Arc<Self>, ops: impl Into<Box<dyn FsNodeOps>>, info: FsNodeInfo, ) -> FsNodeHandle

pub fn create_detached_node( self: &Arc<Self>, ino: ino_t, ops: impl Into<Box<dyn FsNodeOps>>, info: FsNodeInfo, ) -> FsNodeHandle

Create a node for a directory that has no parent.

pub fn create_root( self: &Arc<Self>, ino: ino_t, ops: impl Into<Box<dyn FsNodeOps>>, )

Create a root node for the filesystem.

This is a convenience function that creates a root node with the default directory mode and root credentials.

pub fn create_root_with_info( self: &Arc<Self>, ino: ino_t, ops: impl Into<Box<dyn FsNodeOps>>, info: FsNodeInfo, )

pub fn remove_node(&self, node: &FsNode)

Remove the given FsNode from the node cache.

Called from the Release trait of FsNode.

pub fn allocate_ino(&self) -> ino_t

pub fn allocate_ino_range(&self, size: usize) -> Range<ino_t>

Allocate a contiguous block of node ids.

pub fn rename<L>( &self, locked: &mut Locked<L>, current_task: &CurrentTask, old_parent: &FsNodeHandle, old_name: &FsStr, new_parent: &FsNodeHandle, new_name: &FsStr, renamed: &FsNodeHandle, replaced: Option<&FsNodeHandle>, ) -> Result<(), Errno>

where L: LockEqualOrBefore<FileOpsCore>,

Move |renamed| that is at |old_name| in |old_parent| to |new_name| in |new_parent| replacing |replaced|. If |replaced| exists and is a directory, this function must check that |renamed| is n directory and that |replaced| is empty.

pub fn exchange( &self, current_task: &CurrentTask, node1: &FsNodeHandle, parent1: &FsNodeHandle, name1: &FsStr, node2: &FsNodeHandle, parent2: &FsNodeHandle, name2: &FsStr, ) -> Result<(), Errno>

Exchanges node1 and node2. Parent directory node and the corresponding names for the two exchanged nodes are passed as parent1, name1, parent2, name2.

pub fn force_unmount_ops(&self)

Forces a FileSystem unmount.

pub fn statfs<L>( &self, locked: &mut Locked<L>, current_task: &CurrentTask, ) -> Result<statfs, Errno>

where L: LockEqualOrBefore<FileOpsCore>,

Returns the statfs for this filesystem.

Each FileSystemOps impl is expected to override this to return the specific statfs for the filesystem.

Returns ENOSYS if the FileSystemOps don’t implement stat.

pub fn did_create_dir_entry(&self, entry: &DirEntryHandle)

pub fn will_destroy_dir_entry(&self, entry: &DirEntryHandle)

pub fn did_access_dir_entry(&self, entry: &DirEntryHandle)

Informs the cache that the entry was used.

pub fn purge_old_entries(&self)

Purges old entries from the cache. This is done as a separate step to avoid potential deadlocks that could occur if done at admission time (where locks might be held that are required when dropping old entries). This should be called after any new entries are admitted with no locks held that might be required for dropping entries.

pub fn downcast_ops<T: 'static>(&self) -> Option<&T>

Returns the FileSystem’s FileSystemOps as a &T, or None if the downcast fails.

pub fn name(&self) -> &'static FsStr

pub fn manages_timestamps(&self) -> bool

pub fn crypt_service(&self) -> Option<Arc<CryptService>>

Returns the crypt service associated with this filesystem, if any. The crypt service implements the fuchsia.fxfs.Crypt protocol and maintains an internal structure that maps each encryption key id to the actual key.

Trait Implementations

impl Debug for FileSystem

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

Formats the value using the given formatter.

impl Drop for FileSystem

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a FileSystem> for Auditable<'a>

fn from(value: &'a FileSystem) -> Self

Converts to this type from the input type.