Struct StartOptions

pub struct StartOptions {
    pub read_only: Option<bool>,
    pub verbose: Option<bool>,
    pub fsck_after_every_transaction: Option<bool>,
    pub write_compression_algorithm: Option<CompressionAlgorithm>,
    pub write_compression_level: Option<i32>,
    pub cache_eviction_policy_override: Option<EvictionPolicyOverride>,
    pub startup_profiling_seconds: Option<u32>,
    pub inline_crypto_enabled: Option<bool>,
    pub barriers_enabled: Option<bool>,
    /* private fields */
}

Options for starting a filesystem.

Fields

read_only: Option<bool>

Start the filesystem in read-only mode.

verbose: Option<bool>

Enable verbose logging.

fsck_after_every_transaction: Option<bool>

If true, run fsck after every transaction. This is for testing purposes only - it’s very slow to run a filesystem like this.

write_compression_algorithm: Option<CompressionAlgorithm>

A compression algorithm specifier for the filesystem to use when storing files (if the filesystem supports it). Defaults to ZSTD_CHUNKED.

write_compression_level: Option<i32>

An optional compression level for the filesystem to use when storing files (if the filesystem and the configured |write_compression_algorithm| supports it). Setting to < 0 indicates no value (the filesystem chooses a default if necessary).

cache_eviction_policy_override: Option<EvictionPolicyOverride>

An optional eviction policy specifier for the filesystem to use for in-memory structures (if the filesystem supports it), specifically for pager-backed files.

startup_profiling_seconds: Option<u32>

Use profiling for the first N seconds after filesystem start. Records the access patterns of objects for N seconds and if the profile already exists, prefetch data and hold the vmos in cache for N seconds. Functionally this means that the first launch with this option records the profile and all other launches with this option will replay that profile.

inline_crypto_enabled: Option<bool>

If true, configures the filesystem to use the hardware’s inline encryption engine when writing encrypted data. This allows the filesystem to store user-encrypted data without being able to read or write the plaintext contents, which enhances security and privacy. Requires the block device to support inline encryption and for barriers_enabled to be true. TODO(https://fxbug.dev/393196849): For now, this flag only prevents the filesystem from computing checksums. Update this comment when the filesystem actually uses inline encryption.

barriers_enabled: Option<bool>

Configures the filesystem to use barriers instead of checksums to ensure consistency. If set, barriers will be used to enforce proper ordering of data and metadata writes, which is otherwise provided by computing and verifying data checksums. Requires filesystem support; at the time of writing, only Fxfs uses this argument. Must be set to true if inline_crypto_enabled is true.

Trait Implementations

impl Clone for StartOptions

fn clone(&self) -> StartOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StartOptions

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

Formats the value using the given formatter.

impl<D> Decode<StartOptions, D> for StartOptions

where D: ResourceDialect,

fn new_empty() -> StartOptions

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_, D>, offset: usize, depth: Depth, ) -> Result<(), Error>

Decodes an object of type T from the decoder’s buffers into self.

impl Default for StartOptions

fn default() -> StartOptions

Returns the “default value” for a type.

impl<D> Encode<StartOptions, D> for &StartOptions

where D: ResourceDialect,

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, depth: Depth, ) -> Result<(), Error>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for StartOptions

fn eq(&self, other: &StartOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeMarker for StartOptions

type Owned = StartOptions

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for StartOptions

type Borrowed<'a> = &'a StartOptions

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow( value: &<StartOptions as TypeMarker>::Owned, ) -> <StartOptions as ValueTypeMarker>::Borrowed<'_>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Persistable for StartOptions

impl StructuralPartialEq for StartOptions