fs_management/
lib.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Library for filesystem management in rust.
6//!
7//! This library is analogous to the fs-management library in zircon. It provides support for
8//! formatting, mounting, unmounting, and fsck-ing. It is implemented in a similar way to the C++
9//! version.  For components v2, add `/svc/fuchsia.process.Launcher` to `use` and add the
10//! binaries as dependencies to your component.
11
12mod error;
13pub mod filesystem;
14pub mod format;
15pub mod partition;
16
17use crate::filesystem::BlockConnector;
18use fidl_fuchsia_fs_startup::{
19    CompressionAlgorithm, EvictionPolicyOverride, FormatOptions, StartOptions,
20};
21use std::convert::From;
22use std::sync::Arc;
23
24// Re-export errors as public.
25pub use error::{QueryError, ShutdownError};
26
27pub const BLOBFS_TYPE_GUID: [u8; 16] = [
28    0x0e, 0x38, 0x67, 0x29, 0x4c, 0x13, 0xbb, 0x4c, 0xb6, 0xda, 0x17, 0xe7, 0xce, 0x1c, 0xa4, 0x5d,
29];
30pub const DATA_TYPE_GUID: [u8; 16] = [
31    0x0c, 0x5f, 0x18, 0x08, 0x2d, 0x89, 0x8a, 0x42, 0xa7, 0x89, 0xdb, 0xee, 0xc8, 0xf5, 0x5e, 0x6a,
32];
33pub const FVM_TYPE_GUID: [u8; 16] = [
34    0xb8, 0x7c, 0xfd, 0x49, 0x15, 0xdf, 0x73, 0x4e, 0xb9, 0xd9, 0x99, 0x20, 0x70, 0x12, 0x7f, 0x0f,
35];
36
37pub const FVM_TYPE_GUID_STR: &str = "49fd7cb8-df15-4e73-b9d9-992070127f0f";
38
39pub const FS_COLLECTION_NAME: &'static str = "fs-collection";
40
41#[derive(Clone)]
42pub enum ComponentType {
43    /// Launch the filesystem as a static child, using the configured name in the options as the
44    /// child name. If the child doesn't exist, this will fail.
45    StaticChild,
46
47    /// Launch the filesystem as a dynamic child, in the configured collection. By default, the
48    /// collection is "fs-collection".
49    DynamicChild { collection_name: String },
50}
51
52impl Default for ComponentType {
53    fn default() -> Self {
54        ComponentType::DynamicChild { collection_name: "fs-collection".to_string() }
55    }
56}
57
58pub struct Options<'a> {
59    /// For static children, the name specifies the name of the child.  For dynamic children, the
60    /// component URL is "fuchsia-boot:///{component-name}#meta/{component-name}.cm" or
61    /// "#meta/{component-name}.cm".  The library will attempt to connect to a static child first,
62    /// and if that fails, it will launch the filesystem within a collection. It will try to
63    /// create a child component via the absolute URL and then fallback to the relative URL.
64    pub component_name: &'a str,
65
66    /// It should be possible to reuse components after serving them, but it's not universally
67    /// supported.
68    pub reuse_component_after_serving: bool,
69
70    /// Format options as defined by the startup protocol
71    pub format_options: FormatOptions,
72
73    /// Start options as defined by the startup protocol
74    pub start_options: StartOptions,
75
76    /// Whether to launch this filesystem as a dynamic or static child.
77    pub component_type: ComponentType,
78}
79
80/// Describes the configuration for a particular filesystem.
81pub trait FSConfig: Send + Sync + 'static {
82    /// Returns the options specifying how to run this filesystem.
83    fn options(&self) -> Options<'_>;
84
85    /// Whether the filesystem supports multiple volumes.
86    fn is_multi_volume(&self) -> bool {
87        false
88    }
89
90    fn disk_format(&self) -> format::DiskFormat {
91        format::DiskFormat::Unknown
92    }
93}
94
95///
96/// FILESYSTEMS
97///
98
99/// Layout of blobs in blobfs
100#[derive(Clone)]
101pub enum BlobLayout {
102    /// Merkle tree is stored in a separate block. This is deprecated and used only on Astro
103    /// devices (it takes more space).
104    DeprecatedPadded,
105
106    /// Merkle tree is appended to the last block of data
107    Compact,
108}
109
110/// Compression used for blobs in blobfs
111#[derive(Clone, Default)]
112pub enum BlobCompression {
113    #[default]
114    ZSTDChunked,
115    Uncompressed,
116}
117
118impl From<&str> for BlobCompression {
119    fn from(value: &str) -> Self {
120        match value {
121            "zstd_chunked" => Self::ZSTDChunked,
122            "uncompressed" => Self::Uncompressed,
123            _ => Default::default(),
124        }
125    }
126}
127
128/// Eviction policy used for blobs in blobfs
129#[derive(Clone, Default)]
130pub enum BlobEvictionPolicy {
131    #[default]
132    NeverEvict,
133    EvictImmediately,
134}
135
136impl From<&str> for BlobEvictionPolicy {
137    fn from(value: &str) -> Self {
138        match value {
139            "never_evict" => Self::NeverEvict,
140            "evict_immediately" => Self::EvictImmediately,
141            _ => Default::default(),
142        }
143    }
144}
145
146/// Blobfs Filesystem Configuration
147/// If fields are None or false, they will not be set in arguments.
148#[derive(Clone, Default)]
149pub struct Blobfs {
150    // Format options
151    pub verbose: bool,
152    pub deprecated_padded_blobfs_format: bool,
153    pub num_inodes: u64,
154    // Start Options
155    pub readonly: bool,
156    pub write_compression_algorithm: BlobCompression,
157    pub write_compression_level: Option<i32>,
158    pub cache_eviction_policy_override: BlobEvictionPolicy,
159    pub component_type: ComponentType,
160}
161
162impl Blobfs {
163    /// Manages a block device using the default configuration.
164    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
165        filesystem::Filesystem::new(block_connector, Self::default())
166    }
167
168    /// Launch blobfs, with the default configuration, as a dynamic child in the fs-collection.
169    pub fn dynamic_child() -> Self {
170        Self {
171            component_type: ComponentType::DynamicChild {
172                collection_name: FS_COLLECTION_NAME.to_string(),
173            },
174            ..Default::default()
175        }
176    }
177}
178
179impl FSConfig for Blobfs {
180    fn options(&self) -> Options<'_> {
181        Options {
182            component_name: "blobfs",
183            reuse_component_after_serving: false,
184            format_options: FormatOptions {
185                verbose: Some(self.verbose),
186                deprecated_padded_blobfs_format: Some(self.deprecated_padded_blobfs_format),
187                num_inodes: if self.num_inodes > 0 { Some(self.num_inodes) } else { None },
188                ..Default::default()
189            },
190            start_options: {
191                let mut start_options = StartOptions {
192                    read_only: self.readonly,
193                    verbose: self.verbose,
194                    fsck_after_every_transaction: false,
195                    write_compression_level: self.write_compression_level.unwrap_or(-1),
196                    write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
197                    cache_eviction_policy_override: EvictionPolicyOverride::None,
198                    startup_profiling_seconds: 0,
199                };
200                start_options.write_compression_algorithm = match &self.write_compression_algorithm
201                {
202                    BlobCompression::ZSTDChunked => CompressionAlgorithm::ZstdChunked,
203                    BlobCompression::Uncompressed => CompressionAlgorithm::Uncompressed,
204                };
205                start_options.cache_eviction_policy_override =
206                    match &self.cache_eviction_policy_override {
207                        BlobEvictionPolicy::NeverEvict => EvictionPolicyOverride::NeverEvict,
208                        BlobEvictionPolicy::EvictImmediately => {
209                            EvictionPolicyOverride::EvictImmediately
210                        }
211                    };
212                start_options
213            },
214            component_type: self.component_type.clone(),
215        }
216    }
217
218    fn disk_format(&self) -> format::DiskFormat {
219        format::DiskFormat::Blobfs
220    }
221}
222
223/// Minfs Filesystem Configuration
224/// If fields are None or false, they will not be set in arguments.
225#[derive(Clone, Default)]
226pub struct Minfs {
227    // TODO(xbhatnag): Add support for fvm_data_slices
228    // Format options
229    pub verbose: bool,
230    pub fvm_data_slices: u32,
231    // Start Options
232    pub readonly: bool,
233    pub fsck_after_every_transaction: bool,
234    pub component_type: ComponentType,
235}
236
237impl Minfs {
238    /// Manages a block device using the default configuration.
239    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
240        filesystem::Filesystem::new(block_connector, Self::default())
241    }
242
243    /// Launch minfs, with the default configuration, as a dynamic child in the fs-collection.
244    pub fn dynamic_child() -> Self {
245        Self {
246            component_type: ComponentType::DynamicChild {
247                collection_name: FS_COLLECTION_NAME.to_string(),
248            },
249            ..Default::default()
250        }
251    }
252}
253
254impl FSConfig for Minfs {
255    fn options(&self) -> Options<'_> {
256        Options {
257            component_name: "minfs",
258            reuse_component_after_serving: false,
259            format_options: FormatOptions {
260                verbose: Some(self.verbose),
261                fvm_data_slices: Some(self.fvm_data_slices),
262                ..Default::default()
263            },
264            start_options: StartOptions {
265                read_only: self.readonly,
266                verbose: self.verbose,
267                fsck_after_every_transaction: self.fsck_after_every_transaction,
268                write_compression_level: -1,
269                write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
270                cache_eviction_policy_override: EvictionPolicyOverride::None,
271                startup_profiling_seconds: 0,
272            },
273            component_type: self.component_type.clone(),
274        }
275    }
276
277    fn disk_format(&self) -> format::DiskFormat {
278        format::DiskFormat::Minfs
279    }
280}
281
282pub type CryptClientFn = Arc<dyn Fn() -> zx::Channel + Send + Sync>;
283
284/// Fxfs Filesystem Configuration
285#[derive(Clone)]
286pub struct Fxfs {
287    // Start Options
288    pub readonly: bool,
289    pub fsck_after_every_transaction: bool,
290    pub component_type: ComponentType,
291    pub startup_profiling_seconds: Option<u32>,
292}
293
294impl Default for Fxfs {
295    fn default() -> Self {
296        Self {
297            readonly: false,
298            fsck_after_every_transaction: false,
299            component_type: Default::default(),
300            startup_profiling_seconds: None,
301        }
302    }
303}
304
305impl Fxfs {
306    /// Manages a block device using the default configuration.
307    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
308        filesystem::Filesystem::new(block_connector, Self::default())
309    }
310
311    /// Launch Fxfs, with the default configuration, as a dynamic child in the fs-collection.
312    pub fn dynamic_child() -> Self {
313        Self {
314            component_type: ComponentType::DynamicChild {
315                collection_name: FS_COLLECTION_NAME.to_string(),
316            },
317            ..Default::default()
318        }
319    }
320}
321
322impl FSConfig for Fxfs {
323    fn options(&self) -> Options<'_> {
324        Options {
325            component_name: "fxfs",
326            reuse_component_after_serving: true,
327            format_options: FormatOptions { verbose: Some(false), ..Default::default() },
328            start_options: StartOptions {
329                read_only: self.readonly,
330                verbose: false,
331                fsck_after_every_transaction: self.fsck_after_every_transaction,
332                write_compression_level: -1,
333                write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
334                cache_eviction_policy_override: EvictionPolicyOverride::None,
335                startup_profiling_seconds: self.startup_profiling_seconds.unwrap_or(0),
336            },
337            component_type: self.component_type.clone(),
338        }
339    }
340
341    fn is_multi_volume(&self) -> bool {
342        true
343    }
344
345    fn disk_format(&self) -> format::DiskFormat {
346        format::DiskFormat::Fxfs
347    }
348}
349
350/// F2fs Filesystem Configuration
351/// If fields are None or false, they will not be set in arguments.
352#[derive(Clone, Default)]
353pub struct F2fs {
354    pub component_type: ComponentType,
355}
356
357impl F2fs {
358    /// Manages a block device using the default configuration.
359    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
360        filesystem::Filesystem::new(block_connector, Self::default())
361    }
362
363    /// Launch f2fs, with the default configuration, as a dynamic child in the fs-collection.
364    pub fn dynamic_child() -> Self {
365        Self {
366            component_type: ComponentType::DynamicChild {
367                collection_name: FS_COLLECTION_NAME.to_string(),
368            },
369            ..Default::default()
370        }
371    }
372}
373
374impl FSConfig for F2fs {
375    fn options(&self) -> Options<'_> {
376        Options {
377            component_name: "f2fs",
378            reuse_component_after_serving: false,
379            format_options: FormatOptions::default(),
380            start_options: StartOptions {
381                read_only: false,
382                verbose: false,
383                fsck_after_every_transaction: false,
384                write_compression_level: -1,
385                write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
386                cache_eviction_policy_override: EvictionPolicyOverride::None,
387                startup_profiling_seconds: 0,
388            },
389            component_type: self.component_type.clone(),
390        }
391    }
392    fn is_multi_volume(&self) -> bool {
393        false
394    }
395
396    fn disk_format(&self) -> format::DiskFormat {
397        format::DiskFormat::F2fs
398    }
399}
400
401/// FvmFilesystem Configuration
402#[derive(Clone)]
403pub struct Fvm {
404    pub component_type: ComponentType,
405}
406
407impl Default for Fvm {
408    fn default() -> Self {
409        Self { component_type: Default::default() }
410    }
411}
412
413impl Fvm {
414    /// Manages a block device using the default configuration.
415    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
416        filesystem::Filesystem::new(block_connector, Self::default())
417    }
418
419    /// Launch Fvm, with the default configuration, as a dynamic child in the fs-collection.
420    pub fn dynamic_child() -> Self {
421        Self {
422            component_type: ComponentType::DynamicChild {
423                collection_name: FS_COLLECTION_NAME.to_string(),
424            },
425            ..Default::default()
426        }
427    }
428}
429
430impl FSConfig for Fvm {
431    fn options(&self) -> Options<'_> {
432        Options {
433            component_name: "fvm2",
434            reuse_component_after_serving: true,
435            format_options: FormatOptions::default(),
436            start_options: StartOptions {
437                read_only: false,
438                verbose: false,
439                fsck_after_every_transaction: false,
440                write_compression_level: -1,
441                write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
442                cache_eviction_policy_override: EvictionPolicyOverride::None,
443                startup_profiling_seconds: 0,
444            },
445            component_type: self.component_type.clone(),
446        }
447    }
448
449    fn is_multi_volume(&self) -> bool {
450        true
451    }
452
453    fn disk_format(&self) -> format::DiskFormat {
454        format::DiskFormat::Fvm
455    }
456}
457
458/// Gpt Configuration
459#[derive(Clone)]
460pub struct Gpt {
461    pub component_type: ComponentType,
462}
463
464impl Default for Gpt {
465    fn default() -> Self {
466        Self { component_type: Default::default() }
467    }
468}
469
470impl Gpt {
471    /// Manages a block device using the default configuration.
472    pub fn new<B: BlockConnector + 'static>(block_connector: B) -> filesystem::Filesystem {
473        filesystem::Filesystem::new(block_connector, Self::default())
474    }
475
476    /// Launch Gpt, with the default configuration, as a dynamic child in the fs-collection.
477    pub fn dynamic_child() -> Self {
478        Self {
479            component_type: ComponentType::DynamicChild {
480                collection_name: FS_COLLECTION_NAME.to_string(),
481            },
482            ..Default::default()
483        }
484    }
485}
486
487impl FSConfig for Gpt {
488    fn options(&self) -> Options<'_> {
489        Options {
490            component_name: "gpt2",
491            reuse_component_after_serving: true,
492            format_options: FormatOptions::default(),
493            start_options: StartOptions {
494                read_only: false,
495                verbose: false,
496                fsck_after_every_transaction: false,
497                write_compression_level: -1,
498                write_compression_algorithm: CompressionAlgorithm::ZstdChunked,
499                cache_eviction_policy_override: EvictionPolicyOverride::None,
500                startup_profiling_seconds: 0,
501            },
502            component_type: self.component_type.clone(),
503        }
504    }
505
506    fn is_multi_volume(&self) -> bool {
507        true
508    }
509
510    fn disk_format(&self) -> format::DiskFormat {
511        format::DiskFormat::Gpt
512    }
513}
fs_management/lib.rs

fs_management/
lib.rs
