Struct FxFilesystem 

pub struct FxFilesystem { /* private fields */ }

Implementations

impl FxFilesystem

pub async fn new_empty(device: DeviceHolder) -> Result<OpenFxFilesystem, Error>

pub async fn open(device: DeviceHolder) -> Result<OpenFxFilesystem, Error>

pub fn root_parent_store(&self) -> Arc<ObjectStore>

pub fn layer_pager(&self) -> Option<&Arc<dyn LayerPager>>

pub async fn close(&self) -> Result<(), Error>

pub fn device(&self) -> Arc<dyn Device>

pub fn root_store(&self) -> Arc<ObjectStore>

pub fn allocator(&self) -> Arc<Allocator>

pub fn enable_allocations(&self)

Enables allocations for the allocator. This is only used in image_builder_mode where it must be called before any allocations can take place.

pub fn object_manager(&self) -> &Arc<ObjectManager>

pub fn journal(&self) -> &Arc<Journal>

pub async fn sync(&self, options: SyncOptions<'_>) -> Result<(), Error>

pub fn block_size(&self) -> BlockSize

pub fn get_info(&self) -> Info

pub fn super_block_header(&self) -> SuperBlockHeader

pub fn graveyard(&self) -> &Arc<Graveyard>

pub fn trace(&self) -> bool

pub fn options(&self) -> &Options

pub fn scope(&self) -> &Scope

pub async fn lock_commits(&self) -> MutexGuard<'_, ()>

Returns a guard that must be taken before any transaction can commence. This guard takes a shared lock on the filesystem. fsck will take an exclusive lock so that it can get a consistent picture of the filesystem that it can verify. It is important that this lock is acquired before all other locks. It is also important that this lock is not taken twice by the same task since that can lead to deadlocks if another task tries to take a write lock.

pub async fn commit_transaction<R: Send>( &self, transaction: &mut Transaction<'_>, callback: impl FnOnce(u64) -> R + Send, ) -> Result<R, Error>

pub fn lock_manager(&self) -> &LockManager

pub fn hooks(&self) -> &Arc<HooksHandle>

impl FxFilesystem

pub async fn truncate_guard( &self, store_id: u64, object_id: u64, ) -> TruncateGuard<'_>

pub async fn truncate_guard_owned( self: &Arc<Self>, store_id: u64, object_id: u64, ) -> TruncateGuard<'static>

pub async fn tombstone_object( &self, store_id: u64, object_id: u64, truncate_guard: Option<&TruncateGuard<'_>>, ) -> Result<(), Error>

Immediately tombstones (purges) an object in the graveyard, deallocating its extents, removing its graveyard entry, and inserting an LSM-tree tombstone record (ObjectValue::None) that deletes all remaining records for the object during compaction.

Use this when space should be reclaimed immediately (e.g. when deleting a volume or unlinking a file with no open references) or when the background graveyard reaper is not running. Use Graveyard::queue_tombstone_object instead when tombstoning from a non-async context (such as Drop) or when work can be deferred to the background (such as initial mount-time reaping).

pub async fn tombstone_attribute( &self, store_id: u64, object_id: u64, attribute_id: AttributeId, ) -> Result<(), Error>

Immediately tombstones (purges) an attribute in the graveyard, deallocating its extents, removing its graveyard entry, and inserting an LSM-tree tombstone record (ObjectValue::None) that deletes the attribute record during compaction.

See FxFilesystem::tombstone_object for when to use this vs. Graveyard::queue_tombstone_attribute.

Trait Implementations

impl Filesystem for FxFilesystem

fn is_remote(&self) -> bool

Returns true if the filesystem is remote. Some functionality is not supported in this case (e.g. the allocator, graveyard, or journal).

fn ensure_local(&self) -> &FxFilesystem

Returns a reference to the local FxFilesystem instance.

fn layer_pager(&self) -> Option<&Arc<dyn LayerPager>>

Returns the layer pager if one is configured for this filesystem.

fn queue_tombstone_object(&self, store_object_id: u64, object_id: u64)

Queues a graveyard object for tombstoning.

fn tombstone_object<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, store_object_id: u64, object_id: u64, truncate_guard: Option<&'life1 TruncateGuard<'life2>>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Tombstones a graveyard object synchronously.

fn block_size(&self) -> BlockSize

Returns the block size of the underlying device.

fn get_info(&self) -> Info

Returns info about the filesystem.

fn sync<'life0, 'life1, 'async_trait>( &'life0 self, options: SyncOptions<'life1>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Syncs the filesystem.

fn options(&self) -> &Options

Returns the options used to configure the filesystem.

fn truncate_guard<'life0, 'async_trait>( &'life0 self, store_id: u64, object_id: u64, ) -> Pin<Box<dyn Future<Output = TruncateGuard<'_>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Takes a truncate guard for the given store and object.

fn hooks(&self) -> &Arc<HooksHandle>

Returns the hooks handle for this filesystem.

impl TransactionSink for FxFilesystem

fn new_transaction<'a, 'async_trait>( self: Arc<Self>, txn_locks: LockKeys, options: Options<'a>, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'a>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Creates a new transaction, acquiring txn_locks. See Options for details.

fn check_space<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Checks that there is sufficient space in the journal to write a transaction, blocking if necessary until space is available.

fn reserve( &self, owner_object_id: Option<u64>, amount: u64, ) -> Option<Reservation>

Reserves space for a transaction’s metadata. Returns None if there is insufficient space.

fn image_builder_mode(&self) -> bool

Returns true if the sink is in image builder mode.

fn commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, transaction: &'life1 mut Transaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>

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

Commits a transaction. Returns a monotonically increasing offset (usually, the journal offset of the transaction) on success.

fn commit_with_callback<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, transaction: &'life1 mut Transaction<'life2>, callback: Box<dyn FnOnce(u64) + Send + 'a>, ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>

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

Like Self::commit, but invokes a callback upon completion, before dropping locks.

fn downgrade_locks(&self, lock_keys: &LockKeys)

Downgrades locks from the WriteLock state to Locked state. This will panic if the locks are not in the WriteLock state.

fn drop_transaction(&self, transaction: &mut Transaction<'_>)

A function to be called by Transaction::drop, allowing for additional work to be performed on drop.

fn lock_manager(&self) -> &LockManager

Returns the lock manager instance.

fn transaction_limiter(&self) -> &TransactionConcurrencyLimiter

Returns the transaction concurrency limiter.

fn metadata_reservation(&self) -> Option<&Reservation>

Returns the global metadata reservation if supported by this sink.

fn is_system_store(&self, store_id: u64) -> bool

Returns true if store_id is a system store (root_store or root_parent_store).