fs_management/
filesystem.rs

1// Copyright 2021 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//! Contains the asynchronous version of [`Filesystem`][`crate::Filesystem`].
6
7use crate::error::{QueryError, ShutdownError};
8use crate::{ComponentType, FSConfig, Options};
9use anyhow::{anyhow, bail, ensure, Context, Error};
10use fidl::endpoints::{create_endpoints, create_proxy, ClientEnd, ServerEnd};
11use fidl_fuchsia_component::{self as fcomponent, RealmMarker};
12use fidl_fuchsia_fs::AdminMarker;
13use fidl_fuchsia_fs_startup::{CheckOptions, CreateOptions, MountOptions, StartupMarker};
14use fidl_fuchsia_hardware_block_volume::VolumeMarker;
15use fuchsia_component::client::{
16    connect_to_named_protocol_at_dir_root, connect_to_protocol, connect_to_protocol_at_dir_root,
17    connect_to_protocol_at_dir_svc, open_childs_exposed_directory,
18};
19use std::collections::HashMap;
20use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
21use std::sync::Arc;
22use zx::{self as zx, AsHandleRef as _, Status};
23use {fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_io as fio};
24
25/// An abstract connector for things that speak fuchsia.hardware.block.Block and similar protocols.
26pub trait BlockConnector: Send + Sync {
27    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error>;
28    fn connect_volume(&self) -> Result<ClientEnd<VolumeMarker>, Error> {
29        let (client, server) = fidl::endpoints::create_endpoints();
30        self.connect_channel_to_volume(server)?;
31        Ok(client)
32    }
33    fn connect_partition(
34        &self,
35    ) -> Result<ClientEnd<fidl_fuchsia_hardware_block_partition::PartitionMarker>, Error> {
36        self.connect_volume().map(|v| ClientEnd::new(v.into_channel()))
37    }
38    fn connect_block(&self) -> Result<ClientEnd<fidl_fuchsia_hardware_block::BlockMarker>, Error> {
39        self.connect_volume().map(|v| ClientEnd::new(v.into_channel()))
40    }
41}
42
43/// Implements `BlockConnector` via a service dir.  Wraps `connect_to_named_protocol_at_dir_root`.
44#[derive(Clone, Debug)]
45pub struct DirBasedBlockConnector(fio::DirectoryProxy, String);
46
47impl DirBasedBlockConnector {
48    pub fn new(dir: fio::DirectoryProxy, path: String) -> Self {
49        Self(dir, path)
50    }
51
52    pub fn path(&self) -> &str {
53        &self.1
54    }
55}
56
57impl BlockConnector for DirBasedBlockConnector {
58    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error> {
59        self.0.open(
60            self.path(),
61            fio::Flags::PROTOCOL_SERVICE,
62            &fio::Options::default(),
63            server_end.into_channel(),
64        )?;
65        Ok(())
66    }
67}
68
69impl BlockConnector for fidl_fuchsia_device::ControllerProxy {
70    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error> {
71        let () = self.connect_to_device_fidl(server_end.into_channel())?;
72        Ok(())
73    }
74}
75
76impl BlockConnector for fidl_fuchsia_storage_partitions::PartitionServiceProxy {
77    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error> {
78        self.connect_channel_to_volume(server_end)?;
79        Ok(())
80    }
81}
82
83// NB: We have to be specific here; we cannot do a blanket impl for AsRef<T: BlockConnector> because
84// that would conflict with a downstream crate that implements AsRef for a concrete BlockConnector
85// defined here already.
86impl<T: BlockConnector> BlockConnector for Arc<T> {
87    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error> {
88        self.as_ref().connect_channel_to_volume(server_end)
89    }
90}
91
92impl<F> BlockConnector for F
93where
94    F: Fn(ServerEnd<VolumeMarker>) -> Result<(), Error> + Send + Sync,
95{
96    fn connect_channel_to_volume(&self, server_end: ServerEnd<VolumeMarker>) -> Result<(), Error> {
97        self(server_end)
98    }
99}
100
101/// Asynchronously manages a block device for filesystem operations.
102pub struct Filesystem {
103    /// The filesystem struct keeps the FSConfig in a Box<dyn> instead of holding it directly for
104    /// code size reasons. Using a type parameter instead would make monomorphized versions of the
105    /// Filesystem impl block for each filesystem type, which duplicates several multi-kilobyte
106    /// functions (get_component_exposed_dir and serve in particular) that are otherwise quite
107    /// generic over config. Clients that want to be generic over filesystem type also pay the
108    /// monomorphization cost, with some, like fshost, paying a lot.
109    config: Box<dyn FSConfig>,
110    block_connector: Box<dyn BlockConnector>,
111    component: Option<Arc<DynamicComponentInstance>>,
112}
113
114// Used to disambiguate children in our component collection.
115static COLLECTION_COUNTER: AtomicU64 = AtomicU64::new(0);
116
117impl Filesystem {
118    pub fn config(&self) -> &dyn FSConfig {
119        self.config.as_ref()
120    }
121
122    pub fn into_config(self) -> Box<dyn FSConfig> {
123        self.config
124    }
125
126    /// Creates a new `Filesystem`.
127    pub fn new<B: BlockConnector + 'static, FSC: FSConfig>(
128        block_connector: B,
129        config: FSC,
130    ) -> Self {
131        Self::from_boxed_config(Box::new(block_connector), Box::new(config))
132    }
133
134    /// Creates a new `Filesystem`.
135    pub fn from_boxed_config(
136        block_connector: Box<dyn BlockConnector>,
137        config: Box<dyn FSConfig>,
138    ) -> Self {
139        Self { config, block_connector, component: None }
140    }
141
142    /// If the filesystem is a currently running component, returns its (relative) moniker.
143    pub fn get_component_moniker(&self) -> Option<String> {
144        Some(match self.config.options().component_type {
145            ComponentType::StaticChild => self.config.options().component_name.to_string(),
146            ComponentType::DynamicChild { .. } => {
147                let component = self.component.as_ref()?;
148                format!("{}:{}", component.collection, component.name)
149            }
150        })
151    }
152
153    async fn get_component_exposed_dir(&mut self) -> Result<fio::DirectoryProxy, Error> {
154        let options = self.config.options();
155        let component_name = options.component_name;
156        match options.component_type {
157            ComponentType::StaticChild => open_childs_exposed_directory(component_name, None).await,
158            ComponentType::DynamicChild { collection_name } => {
159                if let Some(component) = &self.component {
160                    return open_childs_exposed_directory(
161                        component.name.clone(),
162                        Some(component.collection.clone()),
163                    )
164                    .await;
165                }
166
167                // We need a unique name, so we pull in the process Koid here since it's possible
168                // for the same binary in a component to be launched multiple times and we don't
169                // want to collide with children created by other processes.
170                let name = format!(
171                    "{}-{}-{}",
172                    component_name,
173                    fuchsia_runtime::process_self().get_koid().unwrap().raw_koid(),
174                    COLLECTION_COUNTER.fetch_add(1, Ordering::Relaxed)
175                );
176
177                let collection_ref = fdecl::CollectionRef { name: collection_name };
178                let child_decls = vec![
179                    fdecl::Child {
180                        name: Some(format!("{}-relative", name)),
181                        url: Some(format!("#meta/{}.cm", component_name)),
182                        startup: Some(fdecl::StartupMode::Lazy),
183                        ..Default::default()
184                    },
185                    fdecl::Child {
186                        name: Some(name),
187                        url: Some(format!(
188                            "fuchsia-boot:///{}#meta/{}.cm",
189                            component_name, component_name
190                        )),
191                        startup: Some(fdecl::StartupMode::Lazy),
192                        ..Default::default()
193                    },
194                ];
195                let realm_proxy = connect_to_protocol::<RealmMarker>()?;
196                for child_decl in child_decls {
197                    // Launch a new component in our collection.
198                    realm_proxy
199                        .create_child(
200                            &collection_ref,
201                            &child_decl,
202                            fcomponent::CreateChildArgs::default(),
203                        )
204                        .await?
205                        .map_err(|e| anyhow!("create_child failed: {:?}", e))?;
206
207                    let component = Arc::new(DynamicComponentInstance {
208                        name: child_decl.name.unwrap(),
209                        collection: collection_ref.name.clone(),
210                        should_not_drop: AtomicBool::new(false),
211                    });
212
213                    if let Ok(proxy) = open_childs_exposed_directory(
214                        component.name.clone(),
215                        Some(component.collection.clone()),
216                    )
217                    .await
218                    {
219                        self.component = Some(component);
220                        return Ok(proxy);
221                    }
222                }
223                Err(anyhow!("Failed to open exposed directory"))
224            }
225        }
226    }
227
228    /// Calls fuchsia.fs.startup/Startup.Format on the configured filesystem component.
229    ///
230    /// Which component is used and the options passed to it are controlled by the config this
231    /// `Filesystem` was created with.
232    ///
233    /// See [`FSConfig`].
234    ///
235    /// # Errors
236    ///
237    /// Returns any errors from the Format method. Also returns an error if the startup protocol is
238    /// not found, if it couldn't launch or find the filesystem component, or if it couldn't get
239    /// the block device channel.
240    pub async fn format(&mut self) -> Result<(), Error> {
241        let channel = self.block_connector.connect_block()?;
242
243        let exposed_dir = self.get_component_exposed_dir().await?;
244        let proxy = connect_to_protocol_at_dir_root::<StartupMarker>(&exposed_dir)?;
245        proxy
246            .format(channel, &self.config().options().format_options)
247            .await?
248            .map_err(Status::from_raw)?;
249
250        Ok(())
251    }
252
253    /// Calls fuchsia.fs.startup/Startup.Check on the configured filesystem component.
254    ///
255    /// Which component is used and the options passed to it are controlled by the config this
256    /// `Filesystem` was created with.
257    ///
258    /// See [`FSConfig`].
259    ///
260    /// # Errors
261    ///
262    /// Returns any errors from the Check method. Also returns an error if the startup protocol is
263    /// not found, if it couldn't launch or find the filesystem component, or if it couldn't get
264    /// the block device channel.
265    pub async fn fsck(&mut self) -> Result<(), Error> {
266        let channel = self.block_connector.connect_block()?;
267        let exposed_dir = self.get_component_exposed_dir().await?;
268        let proxy = connect_to_protocol_at_dir_root::<StartupMarker>(&exposed_dir)?;
269        proxy.check(channel, CheckOptions::default()).await?.map_err(Status::from_raw)?;
270        Ok(())
271    }
272
273    /// Serves the filesystem on the block device and returns a [`ServingSingleVolumeFilesystem`]
274    /// representing the running filesystem component.
275    ///
276    /// # Errors
277    ///
278    /// Returns [`Err`] if serving the filesystem failed.
279    pub async fn serve(&mut self) -> Result<ServingSingleVolumeFilesystem, Error> {
280        if self.config.is_multi_volume() {
281            bail!("Can't serve a multivolume filesystem; use serve_multi_volume");
282        }
283        let Options { start_options, reuse_component_after_serving, .. } = self.config.options();
284
285        let exposed_dir = self.get_component_exposed_dir().await?;
286        let proxy = connect_to_protocol_at_dir_root::<StartupMarker>(&exposed_dir)?;
287        proxy
288            .start(self.block_connector.connect_block()?, start_options)
289            .await?
290            .map_err(Status::from_raw)?;
291
292        let (root_dir, server_end) = create_endpoints::<fio::NodeMarker>();
293        exposed_dir.deprecated_open(
294            fio::OpenFlags::RIGHT_READABLE
295                | fio::OpenFlags::POSIX_EXECUTABLE
296                | fio::OpenFlags::POSIX_WRITABLE,
297            fio::ModeType::empty(),
298            "root",
299            server_end,
300        )?;
301        let component = self.component.clone();
302        if !reuse_component_after_serving {
303            self.component = None;
304        }
305        Ok(ServingSingleVolumeFilesystem {
306            component,
307            exposed_dir: Some(exposed_dir),
308            root_dir: ClientEnd::<fio::DirectoryMarker>::new(root_dir.into_channel()).into_proxy(),
309            binding: None,
310        })
311    }
312
313    /// Serves the filesystem on the block device and returns a [`ServingMultiVolumeFilesystem`]
314    /// representing the running filesystem component.  No volumes are opened; clients have to do
315    /// that explicitly.
316    ///
317    /// # Errors
318    ///
319    /// Returns [`Err`] if serving the filesystem failed.
320    pub async fn serve_multi_volume(&mut self) -> Result<ServingMultiVolumeFilesystem, Error> {
321        if !self.config.is_multi_volume() {
322            bail!("Can't serve_multi_volume a single-volume filesystem; use serve");
323        }
324
325        let exposed_dir = self.get_component_exposed_dir().await?;
326        let proxy = connect_to_protocol_at_dir_root::<StartupMarker>(&exposed_dir)?;
327        proxy
328            .start(self.block_connector.connect_block()?, self.config.options().start_options)
329            .await?
330            .map_err(Status::from_raw)?;
331
332        Ok(ServingMultiVolumeFilesystem {
333            component: self.component.clone(),
334            exposed_dir: Some(exposed_dir),
335            volumes: HashMap::default(),
336        })
337    }
338}
339
340// Destroys the child when dropped.
341struct DynamicComponentInstance {
342    name: String,
343    collection: String,
344    should_not_drop: AtomicBool,
345}
346
347impl DynamicComponentInstance {
348    fn forget(&self) {
349        self.should_not_drop.store(true, Ordering::Relaxed);
350    }
351}
352
353impl Drop for DynamicComponentInstance {
354    fn drop(&mut self) {
355        if self.should_not_drop.load(Ordering::Relaxed) {
356            return;
357        }
358        if let Ok(realm_proxy) = connect_to_protocol::<RealmMarker>() {
359            let _ = realm_proxy.destroy_child(&fdecl::ChildRef {
360                name: self.name.clone(),
361                collection: Some(self.collection.clone()),
362            });
363        }
364    }
365}
366
367/// Manages the binding of a `fuchsia_io::DirectoryProxy` into the local namespace.  When the object
368/// is dropped, the binding is removed.
369#[derive(Default)]
370pub struct NamespaceBinding(String);
371
372impl NamespaceBinding {
373    pub fn create(root_dir: &fio::DirectoryProxy, path: String) -> Result<NamespaceBinding, Error> {
374        let (client_end, server_end) = create_endpoints();
375        root_dir.clone(ServerEnd::new(server_end.into_channel()))?;
376        let namespace = fdio::Namespace::installed()?;
377        namespace.bind(&path, client_end)?;
378        Ok(Self(path))
379    }
380}
381
382impl std::ops::Deref for NamespaceBinding {
383    type Target = str;
384    fn deref(&self) -> &Self::Target {
385        &self.0
386    }
387}
388
389impl Drop for NamespaceBinding {
390    fn drop(&mut self) {
391        if let Ok(namespace) = fdio::Namespace::installed() {
392            let _ = namespace.unbind(&self.0);
393        }
394    }
395}
396
397// TODO(https://fxbug.dev/42174810): Soft migration; remove this after completion
398pub type ServingFilesystem = ServingSingleVolumeFilesystem;
399
400/// Asynchronously manages a serving filesystem. Created from [`Filesystem::serve()`].
401pub struct ServingSingleVolumeFilesystem {
402    component: Option<Arc<DynamicComponentInstance>>,
403    // exposed_dir will always be Some, except when the filesystem is shutting down.
404    exposed_dir: Option<fio::DirectoryProxy>,
405    root_dir: fio::DirectoryProxy,
406
407    // The path in the local namespace that this filesystem is bound to (optional).
408    binding: Option<NamespaceBinding>,
409}
410
411impl ServingSingleVolumeFilesystem {
412    /// Returns a proxy to the exposed directory of the serving filesystem.
413    pub fn exposed_dir(&self) -> &fio::DirectoryProxy {
414        self.exposed_dir.as_ref().unwrap()
415    }
416
417    /// Returns a proxy to the root directory of the serving filesystem.
418    pub fn root(&self) -> &fio::DirectoryProxy {
419        &self.root_dir
420    }
421
422    /// Binds the root directory being served by this filesystem to a path in the local namespace.
423    /// The path must be absolute, containing no "." nor ".." entries.  The binding will be dropped
424    /// when self is dropped.  Only one binding is supported.
425    ///
426    /// # Errors
427    ///
428    /// Returns [`Err`] if binding failed.
429    pub fn bind_to_path(&mut self, path: &str) -> Result<(), Error> {
430        ensure!(self.binding.is_none(), "Already bound");
431        self.binding = Some(NamespaceBinding::create(&self.root_dir, path.to_string())?);
432        Ok(())
433    }
434
435    pub fn bound_path(&self) -> Option<&str> {
436        self.binding.as_deref()
437    }
438
439    /// Returns a [`FilesystemInfo`] object containing information about the serving filesystem.
440    ///
441    /// # Errors
442    ///
443    /// Returns [`Err`] if querying the filesystem failed.
444    pub async fn query(&self) -> Result<Box<fio::FilesystemInfo>, QueryError> {
445        let (status, info) = self.root_dir.query_filesystem().await?;
446        Status::ok(status).map_err(QueryError::DirectoryQuery)?;
447        info.ok_or(QueryError::DirectoryEmptyResult)
448    }
449
450    /// Take the exposed dir from this filesystem instance, dropping the management struct without
451    /// shutting the filesystem down. This leaves the caller with the responsibility of shutting
452    /// down the filesystem, and the filesystem component if necessary.
453    pub fn take_exposed_dir(mut self) -> fio::DirectoryProxy {
454        self.component.take().expect("BUG: component missing").forget();
455        self.exposed_dir.take().expect("BUG: exposed dir missing")
456    }
457
458    /// Attempts to shutdown the filesystem using the
459    /// [`fidl_fuchsia_fs::AdminProxy::shutdown()`] FIDL method and waiting for the filesystem
460    /// process to terminate.
461    ///
462    /// # Errors
463    ///
464    /// Returns [`Err`] if the shutdown failed or the filesystem process did not terminate.
465    pub async fn shutdown(mut self) -> Result<(), ShutdownError> {
466        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(
467            &self.exposed_dir.take().expect("BUG: exposed dir missing"),
468        )?
469        .shutdown()
470        .await?;
471        Ok(())
472    }
473
474    /// Attempts to kill the filesystem process and waits for the process to terminate.
475    ///
476    /// # Errors
477    ///
478    /// Returns [`Err`] if the filesystem process could not be terminated. There is no way to
479    /// recover the [`Filesystem`] from this error.
480    pub async fn kill(self) -> Result<(), Error> {
481        // For components, just shut down the filesystem.
482        // TODO(https://fxbug.dev/293949323): Figure out a way to make this more abrupt - the use-cases are
483        // either testing or when the filesystem isn't responding.
484        self.shutdown().await?;
485        Ok(())
486    }
487}
488
489impl Drop for ServingSingleVolumeFilesystem {
490    fn drop(&mut self) {
491        // Make a best effort attempt to shut down to the filesystem, if we need to.
492        if let Some(exposed_dir) = self.exposed_dir.take() {
493            if let Ok(proxy) =
494                connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(&exposed_dir)
495            {
496                let _ = proxy.shutdown();
497            }
498        }
499    }
500}
501
502/// Asynchronously manages a serving multivolume filesystem. Created from
503/// [`Filesystem::serve_multi_volume()`].
504pub struct ServingMultiVolumeFilesystem {
505    component: Option<Arc<DynamicComponentInstance>>,
506    // exposed_dir will always be Some, except in Self::shutdown.
507    exposed_dir: Option<fio::DirectoryProxy>,
508    volumes: HashMap<String, ServingVolume>,
509}
510
511/// Represents an opened volume in a [`ServingMultiVolumeFilesystem'] instance.
512pub struct ServingVolume {
513    root_dir: fio::DirectoryProxy,
514    binding: Option<NamespaceBinding>,
515    exposed_dir: fio::DirectoryProxy,
516}
517
518impl ServingVolume {
519    /// Returns a proxy to the root directory of the serving volume.
520    pub fn root(&self) -> &fio::DirectoryProxy {
521        &self.root_dir
522    }
523
524    /// Returns a proxy to the exposed directory of the serving volume.
525    pub fn exposed_dir(&self) -> &fio::DirectoryProxy {
526        &self.exposed_dir
527    }
528
529    /// Binds the root directory being served by this filesystem to a path in the local namespace.
530    /// The path must be absolute, containing no "." nor ".." entries.  The binding will be dropped
531    /// when self is dropped, or when unbind_path is called.  Only one binding is supported.
532    ///
533    /// # Errors
534    ///
535    /// Returns [`Err`] if binding failed, or if a binding already exists.
536    pub fn bind_to_path(&mut self, path: &str) -> Result<(), Error> {
537        ensure!(self.binding.is_none(), "Already bound");
538        self.binding = Some(NamespaceBinding::create(&self.root_dir, path.to_string())?);
539        Ok(())
540    }
541
542    /// Remove the namespace binding to the root directory being served by this volume, if there is
543    /// one. If there is no binding, this function does nothing. After this, it is safe to call
544    /// bind_to_path again.
545    pub fn unbind_path(&mut self) {
546        let _ = self.binding.take();
547    }
548
549    pub fn bound_path(&self) -> Option<&str> {
550        self.binding.as_deref()
551    }
552
553    /// Returns a [`FilesystemInfo`] object containing information about the serving volume.
554    ///
555    /// # Errors
556    ///
557    /// Returns [`Err`] if querying the filesystem failed.
558    pub async fn query(&self) -> Result<Box<fio::FilesystemInfo>, QueryError> {
559        let (status, info) = self.root_dir.query_filesystem().await?;
560        Status::ok(status).map_err(QueryError::DirectoryQuery)?;
561        info.ok_or(QueryError::DirectoryEmptyResult)
562    }
563}
564
565impl ServingMultiVolumeFilesystem {
566    /// Gets a reference to the given volume, if it's already open.
567    pub fn volume(&self, volume: &str) -> Option<&ServingVolume> {
568        self.volumes.get(volume)
569    }
570
571    /// Gets a mutable reference to the given volume, if it's already open.
572    pub fn volume_mut(&mut self, volume: &str) -> Option<&mut ServingVolume> {
573        self.volumes.get_mut(volume)
574    }
575
576    pub fn close_volume(&mut self, volume: &str) {
577        self.volumes.remove(volume);
578    }
579
580    /// Attempts to shutdown the filesystem using the [`fidl_fuchsia_fs::AdminProxy::shutdown()`]
581    /// FIDL method. Fails if the volume is not already open.
582    pub async fn shutdown_volume(&mut self, volume: &str) -> Result<(), Error> {
583        ensure!(self.volumes.contains_key(volume), "Volume not mounted");
584        let serving_vol = self.volume(volume).unwrap();
585        let admin_proxy = connect_to_protocol_at_dir_svc::<AdminMarker>(serving_vol.exposed_dir())?;
586        admin_proxy.shutdown().await.context("failed to shutdown volume")?;
587        self.close_volume(volume);
588        Ok(())
589    }
590
591    /// Returns whether the given volume exists.
592    pub async fn has_volume(&mut self, volume: &str) -> Result<bool, Error> {
593        if self.volumes.contains_key(volume) {
594            return Ok(true);
595        }
596        let path = format!("volumes/{}", volume);
597        fuchsia_fs::directory::open_node(
598            self.exposed_dir.as_ref().unwrap(),
599            &path,
600            fio::Flags::PROTOCOL_NODE,
601        )
602        .await
603        .map(|_| true)
604        .or_else(|e| {
605            if let fuchsia_fs::node::OpenError::OpenError(status) = &e {
606                if *status == zx::Status::NOT_FOUND {
607                    return Ok(false);
608                }
609            }
610            Err(e.into())
611        })
612    }
613
614    /// Creates and mounts the volume.  Fails if the volume already exists.
615    /// If `options.crypt` is set, the volume will be encrypted using the provided Crypt instance.
616    /// If `options.as_blob` is set, creates a blob volume that is mounted as a blob filesystem.
617    pub async fn create_volume(
618        &mut self,
619        volume: &str,
620        create_options: CreateOptions,
621        options: MountOptions,
622    ) -> Result<&mut ServingVolume, Error> {
623        ensure!(!self.volumes.contains_key(volume), "Already bound");
624        let (exposed_dir, server) = create_proxy::<fio::DirectoryMarker>();
625        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs_startup::VolumesMarker>(
626            self.exposed_dir.as_ref().unwrap(),
627        )?
628        .create(volume, server, create_options, options)
629        .await?
630        .map_err(|e| anyhow!(zx::Status::from_raw(e)))?;
631        self.insert_volume(volume.to_string(), exposed_dir).await
632    }
633
634    /// Deletes the volume. Fails if the volume is already mounted.
635    pub async fn remove_volume(&mut self, volume: &str) -> Result<(), Error> {
636        ensure!(!self.volumes.contains_key(volume), "Already bound");
637        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs_startup::VolumesMarker>(
638            self.exposed_dir.as_ref().unwrap(),
639        )?
640        .remove(volume)
641        .await?
642        .map_err(|e| anyhow!(zx::Status::from_raw(e)))
643    }
644
645    /// Mounts an existing volume.  Fails if the volume is already mounted or doesn't exist.
646    /// If `crypt` is set, the volume will be decrypted using the provided Crypt instance.
647    pub async fn open_volume(
648        &mut self,
649        volume: &str,
650        options: MountOptions,
651    ) -> Result<&mut ServingVolume, Error> {
652        ensure!(!self.volumes.contains_key(volume), "Already bound");
653        let (exposed_dir, server) = create_proxy::<fio::DirectoryMarker>();
654        let path = format!("volumes/{}", volume);
655        connect_to_named_protocol_at_dir_root::<fidl_fuchsia_fs_startup::VolumeMarker>(
656            self.exposed_dir.as_ref().unwrap(),
657            &path,
658        )?
659        .mount(server, options)
660        .await?
661        .map_err(|e| anyhow!(zx::Status::from_raw(e)))?;
662
663        self.insert_volume(volume.to_string(), exposed_dir).await
664    }
665
666    /// Sets the max byte limit for a volume. Fails if the volume is not mounted.
667    pub async fn set_byte_limit(&self, volume: &str, byte_limit: u64) -> Result<(), Error> {
668        ensure!(self.volumes.contains_key(volume), "Volume not mounted");
669        if byte_limit == 0 {
670            return Ok(());
671        }
672        let path = format!("volumes/{}", volume);
673        connect_to_named_protocol_at_dir_root::<fidl_fuchsia_fs_startup::VolumeMarker>(
674            self.exposed_dir.as_ref().unwrap(),
675            &path,
676        )?
677        .set_limit(byte_limit)
678        .await?
679        .map_err(|e| anyhow!(zx::Status::from_raw(e)))
680    }
681
682    pub async fn check_volume(
683        &mut self,
684        volume: &str,
685        crypt: Option<ClientEnd<fidl_fuchsia_fxfs::CryptMarker>>,
686    ) -> Result<(), Error> {
687        ensure!(!self.volumes.contains_key(volume), "Already bound");
688        let path = format!("volumes/{}", volume);
689        connect_to_named_protocol_at_dir_root::<fidl_fuchsia_fs_startup::VolumeMarker>(
690            self.exposed_dir.as_ref().unwrap(),
691            &path,
692        )?
693        .check(fidl_fuchsia_fs_startup::CheckOptions { crypt, ..Default::default() })
694        .await?
695        .map_err(|e| anyhow!(zx::Status::from_raw(e)))?;
696        Ok(())
697    }
698
699    async fn insert_volume(
700        &mut self,
701        volume: String,
702        exposed_dir: fio::DirectoryProxy,
703    ) -> Result<&mut ServingVolume, Error> {
704        let (root_dir, server_end) = create_endpoints::<fio::NodeMarker>();
705        exposed_dir.deprecated_open(
706            fio::OpenFlags::RIGHT_READABLE
707                | fio::OpenFlags::POSIX_EXECUTABLE
708                | fio::OpenFlags::POSIX_WRITABLE,
709            fio::ModeType::empty(),
710            "root",
711            server_end,
712        )?;
713        Ok(self.volumes.entry(volume).or_insert(ServingVolume {
714            root_dir: ClientEnd::<fio::DirectoryMarker>::new(root_dir.into_channel()).into_proxy(),
715            binding: None,
716            exposed_dir,
717        }))
718    }
719
720    /// Provides access to the internal |exposed_dir| for use in testing
721    /// callsites which need directory access.
722    pub fn exposed_dir(&self) -> &fio::DirectoryProxy {
723        self.exposed_dir.as_ref().expect("BUG: exposed dir missing")
724    }
725
726    /// Attempts to shutdown the filesystem using the [`fidl_fuchsia_fs::AdminProxy::shutdown()`]
727    /// FIDL method.
728    ///
729    /// # Errors
730    ///
731    /// Returns [`Err`] if the shutdown failed.
732    pub async fn shutdown(mut self) -> Result<(), ShutdownError> {
733        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(
734            // Take exposed_dir so we don't attempt to shut down again in Drop.
735            &self.exposed_dir.take().expect("BUG: exposed dir missing"),
736        )?
737        .shutdown()
738        .await?;
739        Ok(())
740    }
741
742    /// Take the exposed dir from this filesystem instance, dropping the management struct without
743    /// shutting the filesystem down. This leaves the caller with the responsibility of shutting
744    /// down the filesystem, and the filesystem component if necessary.
745    pub fn take_exposed_dir(mut self) -> fio::DirectoryProxy {
746        self.component.take().expect("BUG: missing component").forget();
747        self.exposed_dir.take().expect("BUG: exposed dir missing")
748    }
749}
750
751impl Drop for ServingMultiVolumeFilesystem {
752    fn drop(&mut self) {
753        if let Some(exposed_dir) = self.exposed_dir.take() {
754            // Make a best effort attempt to shut down to the filesystem.
755            if let Ok(proxy) =
756                connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(&exposed_dir)
757            {
758                let _ = proxy.shutdown();
759            }
760        }
761    }
762}
763
764#[cfg(test)]
765mod tests {
766    use super::*;
767    use crate::{BlobCompression, BlobEvictionPolicy, Blobfs, F2fs, Fxfs, Minfs};
768    use fuchsia_async as fasync;
769    use ramdevice_client::RamdiskClient;
770    use std::io::{Read as _, Write as _};
771    use std::time::Duration;
772
773    async fn ramdisk(block_size: u64) -> RamdiskClient {
774        RamdiskClient::create(block_size, 1 << 16).await.unwrap()
775    }
776
777    async fn new_fs<FSC: FSConfig>(ramdisk: &mut RamdiskClient, config: FSC) -> Filesystem {
778        Filesystem::new(ramdisk.take_controller().unwrap(), config)
779    }
780
781    #[fuchsia::test]
782    async fn blobfs_custom_config() {
783        let block_size = 512;
784        let mut ramdisk = ramdisk(block_size).await;
785        let config = Blobfs {
786            verbose: true,
787            readonly: true,
788            write_compression_algorithm: BlobCompression::Uncompressed,
789            cache_eviction_policy_override: BlobEvictionPolicy::EvictImmediately,
790            ..Default::default()
791        };
792        let mut blobfs = new_fs(&mut ramdisk, config).await;
793
794        blobfs.format().await.expect("failed to format blobfs");
795        blobfs.fsck().await.expect("failed to fsck blobfs");
796        let _ = blobfs.serve().await.expect("failed to serve blobfs");
797
798        ramdisk.destroy().await.expect("failed to destroy ramdisk");
799    }
800
801    #[fuchsia::test]
802    async fn blobfs_format_fsck_success() {
803        let block_size = 512;
804        let mut ramdisk = ramdisk(block_size).await;
805        let mut blobfs = new_fs(&mut ramdisk, Blobfs::default()).await;
806
807        blobfs.format().await.expect("failed to format blobfs");
808        blobfs.fsck().await.expect("failed to fsck blobfs");
809
810        ramdisk.destroy().await.expect("failed to destroy ramdisk");
811    }
812
813    #[fuchsia::test]
814    async fn blobfs_format_serve_write_query_restart_read_shutdown() {
815        let block_size = 512;
816        let mut ramdisk = ramdisk(block_size).await;
817        let mut blobfs = new_fs(&mut ramdisk, Blobfs::default()).await;
818
819        blobfs.format().await.expect("failed to format blobfs");
820
821        let serving = blobfs.serve().await.expect("failed to serve blobfs the first time");
822
823        // snapshot of FilesystemInfo
824        let fs_info1 =
825            serving.query().await.expect("failed to query filesystem info after first serving");
826
827        // pre-generated merkle test fixture data
828        let merkle = "be901a14ec42ee0a8ee220eb119294cdd40d26d573139ee3d51e4430e7d08c28";
829        let content = String::from("test content").into_bytes();
830
831        {
832            let test_file = fuchsia_fs::directory::open_file(
833                serving.root(),
834                merkle,
835                fio::Flags::FLAG_MAYBE_CREATE | fio::PERM_WRITABLE,
836            )
837            .await
838            .expect("failed to create test file");
839            let () = test_file
840                .resize(content.len() as u64)
841                .await
842                .expect("failed to send resize FIDL")
843                .map_err(Status::from_raw)
844                .expect("failed to resize file");
845            let _: u64 = test_file
846                .write(&content)
847                .await
848                .expect("failed to write to test file")
849                .map_err(Status::from_raw)
850                .expect("write error");
851        }
852
853        // check against the snapshot FilesystemInfo
854        let fs_info2 = serving.query().await.expect("failed to query filesystem info after write");
855        assert_eq!(
856            fs_info2.used_bytes - fs_info1.used_bytes,
857            fs_info2.block_size as u64 // assuming content < 8K
858        );
859
860        serving.shutdown().await.expect("failed to shutdown blobfs the first time");
861        let serving = blobfs.serve().await.expect("failed to serve blobfs the second time");
862        {
863            let test_file =
864                fuchsia_fs::directory::open_file(serving.root(), merkle, fio::PERM_READABLE)
865                    .await
866                    .expect("failed to open test file");
867            let read_content =
868                fuchsia_fs::file::read(&test_file).await.expect("failed to read from test file");
869            assert_eq!(content, read_content);
870        }
871
872        // once more check against the snapshot FilesystemInfo
873        let fs_info3 = serving.query().await.expect("failed to query filesystem info after read");
874        assert_eq!(
875            fs_info3.used_bytes - fs_info1.used_bytes,
876            fs_info3.block_size as u64 // assuming content < 8K
877        );
878
879        serving.shutdown().await.expect("failed to shutdown blobfs the second time");
880
881        ramdisk.destroy().await.expect("failed to destroy ramdisk");
882    }
883
884    #[fuchsia::test]
885    async fn blobfs_bind_to_path() {
886        let block_size = 512;
887        let merkle = "be901a14ec42ee0a8ee220eb119294cdd40d26d573139ee3d51e4430e7d08c28";
888        let test_content = b"test content";
889        let mut ramdisk = ramdisk(block_size).await;
890        let mut blobfs = new_fs(&mut ramdisk, Blobfs::default()).await;
891
892        blobfs.format().await.expect("failed to format blobfs");
893        let mut serving = blobfs.serve().await.expect("failed to serve blobfs");
894        serving.bind_to_path("/test-blobfs-path").expect("bind_to_path failed");
895        let test_path = format!("/test-blobfs-path/{}", merkle);
896
897        {
898            let mut file = std::fs::File::create(&test_path).expect("failed to create test file");
899            file.set_len(test_content.len() as u64).expect("failed to set size");
900            file.write_all(test_content).expect("write bytes");
901        }
902
903        {
904            let mut file = std::fs::File::open(&test_path).expect("failed to open test file");
905            let mut buf = Vec::new();
906            file.read_to_end(&mut buf).expect("failed to read test file");
907            assert_eq!(buf, test_content);
908        }
909
910        serving.shutdown().await.expect("failed to shutdown blobfs");
911
912        std::fs::File::open(&test_path).expect_err("test file was not unbound");
913    }
914
915    #[fuchsia::test]
916    async fn minfs_custom_config() {
917        let block_size = 512;
918        let mut ramdisk = ramdisk(block_size).await;
919        let config = Minfs {
920            verbose: true,
921            readonly: true,
922            fsck_after_every_transaction: true,
923            ..Default::default()
924        };
925        let mut minfs = new_fs(&mut ramdisk, config).await;
926
927        minfs.format().await.expect("failed to format minfs");
928        minfs.fsck().await.expect("failed to fsck minfs");
929        let _ = minfs.serve().await.expect("failed to serve minfs");
930
931        ramdisk.destroy().await.expect("failed to destroy ramdisk");
932    }
933
934    #[fuchsia::test]
935    async fn minfs_format_fsck_success() {
936        let block_size = 8192;
937        let mut ramdisk = ramdisk(block_size).await;
938        let mut minfs = new_fs(&mut ramdisk, Minfs::default()).await;
939
940        minfs.format().await.expect("failed to format minfs");
941        minfs.fsck().await.expect("failed to fsck minfs");
942
943        ramdisk.destroy().await.expect("failed to destroy ramdisk");
944    }
945
946    #[fuchsia::test]
947    async fn minfs_format_serve_write_query_restart_read_shutdown() {
948        let block_size = 8192;
949        let mut ramdisk = ramdisk(block_size).await;
950        let mut minfs = new_fs(&mut ramdisk, Minfs::default()).await;
951
952        minfs.format().await.expect("failed to format minfs");
953        let serving = minfs.serve().await.expect("failed to serve minfs the first time");
954
955        // snapshot of FilesystemInfo
956        let fs_info1 =
957            serving.query().await.expect("failed to query filesystem info after first serving");
958
959        let filename = "test_file";
960        let content = String::from("test content").into_bytes();
961
962        {
963            let test_file = fuchsia_fs::directory::open_file(
964                serving.root(),
965                filename,
966                fio::Flags::FLAG_MAYBE_CREATE | fio::PERM_WRITABLE,
967            )
968            .await
969            .expect("failed to create test file");
970            let _: u64 = test_file
971                .write(&content)
972                .await
973                .expect("failed to write to test file")
974                .map_err(Status::from_raw)
975                .expect("write error");
976        }
977
978        // check against the snapshot FilesystemInfo
979        let fs_info2 = serving.query().await.expect("failed to query filesystem info after write");
980        assert_eq!(
981            fs_info2.used_bytes - fs_info1.used_bytes,
982            fs_info2.block_size as u64 // assuming content < 8K
983        );
984
985        serving.shutdown().await.expect("failed to shutdown minfs the first time");
986        let serving = minfs.serve().await.expect("failed to serve minfs the second time");
987
988        {
989            let test_file =
990                fuchsia_fs::directory::open_file(serving.root(), filename, fio::PERM_READABLE)
991                    .await
992                    .expect("failed to open test file");
993            let read_content =
994                fuchsia_fs::file::read(&test_file).await.expect("failed to read from test file");
995            assert_eq!(content, read_content);
996        }
997
998        // once more check against the snapshot FilesystemInfo
999        let fs_info3 = serving.query().await.expect("failed to query filesystem info after read");
1000        assert_eq!(
1001            fs_info3.used_bytes - fs_info1.used_bytes,
1002            fs_info3.block_size as u64 // assuming content < 8K
1003        );
1004
1005        let _ = serving.shutdown().await.expect("failed to shutdown minfs the second time");
1006
1007        ramdisk.destroy().await.expect("failed to destroy ramdisk");
1008    }
1009
1010    #[fuchsia::test]
1011    async fn minfs_bind_to_path() {
1012        let block_size = 8192;
1013        let test_content = b"test content";
1014        let mut ramdisk = ramdisk(block_size).await;
1015        let mut minfs = new_fs(&mut ramdisk, Minfs::default()).await;
1016
1017        minfs.format().await.expect("failed to format minfs");
1018        let mut serving = minfs.serve().await.expect("failed to serve minfs");
1019        serving.bind_to_path("/test-minfs-path").expect("bind_to_path failed");
1020        let test_path = "/test-minfs-path/test_file";
1021
1022        {
1023            let mut file = std::fs::File::create(test_path).expect("failed to create test file");
1024            file.write_all(test_content).expect("write bytes");
1025        }
1026
1027        {
1028            let mut file = std::fs::File::open(test_path).expect("failed to open test file");
1029            let mut buf = Vec::new();
1030            file.read_to_end(&mut buf).expect("failed to read test file");
1031            assert_eq!(buf, test_content);
1032        }
1033
1034        serving.shutdown().await.expect("failed to shutdown minfs");
1035
1036        std::fs::File::open(test_path).expect_err("test file was not unbound");
1037    }
1038
1039    #[fuchsia::test]
1040    async fn minfs_take_exposed_dir_does_not_drop() {
1041        let block_size = 512;
1042        let test_content = b"test content";
1043        let test_file_name = "test-file";
1044        let mut ramdisk = ramdisk(block_size).await;
1045        let mut minfs = new_fs(&mut ramdisk, Minfs::default()).await;
1046
1047        minfs.format().await.expect("failed to format fxfs");
1048
1049        let fs = minfs.serve().await.expect("failed to serve fxfs");
1050        let file = {
1051            let file = fuchsia_fs::directory::open_file(
1052                fs.root(),
1053                test_file_name,
1054                fio::Flags::FLAG_MAYBE_CREATE | fio::PERM_READABLE | fio::PERM_WRITABLE,
1055            )
1056            .await
1057            .unwrap();
1058            fuchsia_fs::file::write(&file, test_content).await.unwrap();
1059            file.close().await.expect("close fidl error").expect("close error");
1060            fuchsia_fs::directory::open_file(fs.root(), test_file_name, fio::PERM_READABLE)
1061                .await
1062                .unwrap()
1063        };
1064
1065        let exposed_dir = fs.take_exposed_dir();
1066
1067        assert_eq!(fuchsia_fs::file::read(&file).await.unwrap(), test_content);
1068
1069        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(&exposed_dir)
1070            .expect("connecting to admin marker")
1071            .shutdown()
1072            .await
1073            .expect("shutdown failed");
1074    }
1075
1076    #[fuchsia::test]
1077    async fn f2fs_format_fsck_success() {
1078        let block_size = 4096;
1079        let mut ramdisk = ramdisk(block_size).await;
1080        let mut f2fs = new_fs(&mut ramdisk, F2fs::default()).await;
1081
1082        f2fs.format().await.expect("failed to format f2fs");
1083        f2fs.fsck().await.expect("failed to fsck f2fs");
1084
1085        ramdisk.destroy().await.expect("failed to destroy ramdisk");
1086    }
1087
1088    #[fuchsia::test]
1089    async fn f2fs_format_serve_write_query_restart_read_shutdown() {
1090        let block_size = 4096;
1091        let mut ramdisk = ramdisk(block_size).await;
1092        let mut f2fs = new_fs(&mut ramdisk, F2fs::default()).await;
1093
1094        f2fs.format().await.expect("failed to format f2fs");
1095        let serving = f2fs.serve().await.expect("failed to serve f2fs the first time");
1096
1097        // snapshot of FilesystemInfo
1098        let fs_info1 =
1099            serving.query().await.expect("failed to query filesystem info after first serving");
1100
1101        let filename = "test_file";
1102        let content = String::from("test content").into_bytes();
1103
1104        {
1105            let test_file = fuchsia_fs::directory::open_file(
1106                serving.root(),
1107                filename,
1108                fio::Flags::FLAG_MAYBE_CREATE | fio::PERM_WRITABLE,
1109            )
1110            .await
1111            .expect("failed to create test file");
1112            let _: u64 = test_file
1113                .write(&content)
1114                .await
1115                .expect("failed to write to test file")
1116                .map_err(Status::from_raw)
1117                .expect("write error");
1118        }
1119
1120        // check against the snapshot FilesystemInfo
1121        let fs_info2 = serving.query().await.expect("failed to query filesystem info after write");
1122        // With zx::stream, f2fs doesn't support the inline data feature allowing file
1123        // inode blocks to include small data. This way requires keeping two copies of VMOs
1124        // for the same inline data
1125        // assuming content < 4K and its inode block.
1126        let expected_size2 = fs_info2.block_size * 2;
1127        assert_eq!(fs_info2.used_bytes - fs_info1.used_bytes, expected_size2 as u64);
1128
1129        serving.shutdown().await.expect("failed to shutdown f2fs the first time");
1130        let serving = f2fs.serve().await.expect("failed to serve f2fs the second time");
1131
1132        {
1133            let test_file =
1134                fuchsia_fs::directory::open_file(serving.root(), filename, fio::PERM_READABLE)
1135                    .await
1136                    .expect("failed to open test file");
1137            let read_content =
1138                fuchsia_fs::file::read(&test_file).await.expect("failed to read from test file");
1139            assert_eq!(content, read_content);
1140        }
1141
1142        // once more check against the snapshot FilesystemInfo
1143        let fs_info3 = serving.query().await.expect("failed to query filesystem info after read");
1144        // assuming content < 4K and its inode block.
1145        let expected_size3 = fs_info3.block_size * 2;
1146        assert_eq!(fs_info3.used_bytes - fs_info1.used_bytes, expected_size3 as u64);
1147
1148        serving.shutdown().await.expect("failed to shutdown f2fs the second time");
1149        f2fs.fsck().await.expect("failed to fsck f2fs after shutting down the second time");
1150
1151        ramdisk.destroy().await.expect("failed to destroy ramdisk");
1152    }
1153
1154    #[fuchsia::test]
1155    async fn f2fs_bind_to_path() {
1156        let block_size = 4096;
1157        let test_content = b"test content";
1158        let mut ramdisk = ramdisk(block_size).await;
1159        let mut f2fs = new_fs(&mut ramdisk, F2fs::default()).await;
1160
1161        f2fs.format().await.expect("failed to format f2fs");
1162        let mut serving = f2fs.serve().await.expect("failed to serve f2fs");
1163        serving.bind_to_path("/test-f2fs-path").expect("bind_to_path failed");
1164        let test_path = "/test-f2fs-path/test_file";
1165
1166        {
1167            let mut file = std::fs::File::create(test_path).expect("failed to create test file");
1168            file.write_all(test_content).expect("write bytes");
1169        }
1170
1171        {
1172            let mut file = std::fs::File::open(test_path).expect("failed to open test file");
1173            let mut buf = Vec::new();
1174            file.read_to_end(&mut buf).expect("failed to read test file");
1175            assert_eq!(buf, test_content);
1176        }
1177
1178        serving.shutdown().await.expect("failed to shutdown f2fs");
1179
1180        std::fs::File::open(test_path).expect_err("test file was not unbound");
1181    }
1182
1183    // TODO(https://fxbug.dev/42174810): Re-enable this test; it depends on Fxfs failing repeated calls to
1184    // Start.
1185    #[ignore]
1186    #[fuchsia::test]
1187    async fn fxfs_shutdown_component_when_dropped() {
1188        let block_size = 512;
1189        let mut ramdisk = ramdisk(block_size).await;
1190        let mut fxfs = new_fs(&mut ramdisk, Fxfs::default()).await;
1191
1192        fxfs.format().await.expect("failed to format fxfs");
1193        {
1194            let _fs = fxfs.serve_multi_volume().await.expect("failed to serve fxfs");
1195
1196            // Serve should fail for the second time.
1197            assert!(
1198                fxfs.serve_multi_volume().await.is_err(),
1199                "serving succeeded when already mounted"
1200            );
1201        }
1202
1203        // Fxfs should get shut down when dropped, but it's asynchronous, so we need to loop here.
1204        let mut attempts = 0;
1205        loop {
1206            if let Ok(_) = fxfs.serve_multi_volume().await {
1207                break;
1208            }
1209            attempts += 1;
1210            assert!(attempts < 10);
1211            fasync::Timer::new(Duration::from_secs(1)).await;
1212        }
1213    }
1214
1215    #[fuchsia::test]
1216    async fn fxfs_open_volume() {
1217        let block_size = 512;
1218        let mut ramdisk = ramdisk(block_size).await;
1219        let mut fxfs = new_fs(&mut ramdisk, Fxfs::default()).await;
1220
1221        fxfs.format().await.expect("failed to format fxfs");
1222
1223        let mut fs = fxfs.serve_multi_volume().await.expect("failed to serve fxfs");
1224
1225        assert_eq!(fs.has_volume("foo").await.expect("has_volume"), false);
1226        assert!(
1227            fs.open_volume("foo", MountOptions::default()).await.is_err(),
1228            "Opening nonexistent volume should fail"
1229        );
1230
1231        let vol = fs
1232            .create_volume("foo", CreateOptions::default(), MountOptions::default())
1233            .await
1234            .expect("Create volume failed");
1235        vol.query().await.expect("Query volume failed");
1236        fs.close_volume("foo");
1237        // TODO(https://fxbug.dev/42057878) Closing the volume is not synchronous. Immediately reopening the
1238        // volume will race with the asynchronous close and sometimes fail because the volume is
1239        // still mounted.
1240        // fs.open_volume("foo", MountOptions{crypt: None, as_blob: false}).await
1241        //    .expect("Open volume failed");
1242        assert_eq!(fs.has_volume("foo").await.expect("has_volume"), true);
1243    }
1244
1245    #[fuchsia::test]
1246    async fn fxfs_take_exposed_dir_does_not_drop() {
1247        let block_size = 512;
1248        let test_content = b"test content";
1249        let test_file_name = "test-file";
1250        let mut ramdisk = ramdisk(block_size).await;
1251        let mut fxfs = new_fs(&mut ramdisk, Fxfs::default()).await;
1252
1253        fxfs.format().await.expect("failed to format fxfs");
1254
1255        let mut fs = fxfs.serve_multi_volume().await.expect("failed to serve fxfs");
1256        let file = {
1257            let vol = fs
1258                .create_volume("foo", CreateOptions::default(), MountOptions::default())
1259                .await
1260                .expect("Create volume failed");
1261            let file = fuchsia_fs::directory::open_file(
1262                vol.root(),
1263                test_file_name,
1264                fio::Flags::FLAG_MAYBE_CREATE | fio::PERM_READABLE | fio::PERM_WRITABLE,
1265            )
1266            .await
1267            .unwrap();
1268            fuchsia_fs::file::write(&file, test_content).await.unwrap();
1269            file.close().await.expect("close fidl error").expect("close error");
1270            fuchsia_fs::directory::open_file(vol.root(), test_file_name, fio::PERM_READABLE)
1271                .await
1272                .unwrap()
1273        };
1274
1275        let exposed_dir = fs.take_exposed_dir();
1276
1277        assert_eq!(fuchsia_fs::file::read(&file).await.unwrap(), test_content);
1278
1279        connect_to_protocol_at_dir_root::<fidl_fuchsia_fs::AdminMarker>(&exposed_dir)
1280            .expect("connecting to admin marker")
1281            .shutdown()
1282            .await
1283            .expect("shutdown failed");
1284    }
1285}
fs_management/filesystem.rs

fs_management/
filesystem.rs
