fuchsia_storage_benchmarks/filesystems/
pkgdir.rs

1// Copyright 2023 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
5use crate::filesystems::{BlobFilesystem, Blobfs, CacheClearableFilesystem, DeliveryBlob, Fxblob};
6use async_trait::async_trait;
7use fidl::endpoints::DiscoverableProtocolMarker;
8use fidl_fuchsia_io as fio;
9use fuchsia_component_test::{Capability, ChildOptions, RealmBuilder, RealmInstance, Ref, Route};
10use futures::future::FutureExt;
11use std::path::Path;
12use storage_benchmarks::{BlockDeviceFactory, Filesystem, FilesystemConfig};
13/// Config object for starting a `PkgDirInstance`. The `PkgDirInstance` allows blob benchmarks to
14/// open and read a blob through its package directory as opposed to talking directly to the
15/// filesystem.
16#[derive(Clone)]
17pub struct PkgDirTest {
18    use_fxblob: bool,
19}
20
21impl PkgDirTest {
22    pub fn new_fxblob() -> Self {
23        PkgDirTest { use_fxblob: true }
24    }
25
26    pub fn new_blobfs() -> Self {
27        PkgDirTest { use_fxblob: false }
28    }
29}
30
31#[async_trait]
32impl FilesystemConfig for PkgDirTest {
33    type Filesystem = PkgDirInstance;
34
35    async fn start_filesystem(
36        &self,
37        block_device_factory: &dyn BlockDeviceFactory,
38    ) -> PkgDirInstance {
39        let fs = if self.use_fxblob {
40            Box::new(Fxblob.start_filesystem(block_device_factory).await) as Box<dyn BlobFilesystem>
41        } else {
42            Box::new(Blobfs.start_filesystem(block_device_factory).await) as Box<dyn BlobFilesystem>
43        };
44
45        let (clone, server_end) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>();
46        fs.exposed_dir()
47            .clone(server_end.into_channel().into())
48            .expect("connect to blob volume exposed dir");
49        let realm = PkgDirRealm::new(self.use_fxblob, clone).await;
50        PkgDirInstance { fs, realm, use_fxblob: self.use_fxblob }
51    }
52
53    fn name(&self) -> String {
54        let fs = if self.use_fxblob { "fxblob" } else { "blobfs" };
55        format!("{}-pkgdir", fs)
56    }
57}
58
59pub struct PkgDirInstance {
60    fs: Box<dyn BlobFilesystem>,
61    realm: PkgDirRealm,
62    use_fxblob: bool,
63}
64
65impl PkgDirInstance {
66    pub fn pkgdir_proxy(&self) -> fidl_test_pkgdir::PkgDirProxy {
67        self.realm
68            .realm()
69            .root
70            .connect_to_protocol_at_exposed_dir::<fidl_test_pkgdir::PkgDirMarker>()
71            .unwrap()
72    }
73}
74
75#[async_trait]
76impl Filesystem for PkgDirInstance {
77    async fn shutdown(self) {
78        self.fs.shutdown_boxed().await
79    }
80
81    fn benchmark_dir(&self) -> &Path {
82        self.fs.benchmark_dir()
83    }
84}
85
86#[async_trait]
87impl CacheClearableFilesystem for PkgDirInstance {
88    async fn clear_cache(&mut self) {
89        self.fs.clear_cache().await;
90        let (clone, server_end) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>();
91        self.fs
92            .exposed_dir()
93            .clone(server_end.into_channel().into())
94            .expect("connect to blob volume exposed dir");
95        self.realm = PkgDirRealm::new(self.use_fxblob, clone).await
96    }
97}
98
99#[async_trait]
100impl BlobFilesystem for PkgDirInstance {
101    async fn get_vmo(&self, blob: &DeliveryBlob) -> zx::Vmo {
102        self.fs.get_vmo(blob).await
103    }
104
105    async fn write_blob(&self, blob: &DeliveryBlob) {
106        self.fs.write_blob(blob).await
107    }
108
109    fn exposed_dir(&self) -> &fio::DirectoryProxy {
110        self.fs.exposed_dir()
111    }
112}
113
114pub struct PkgDirRealm {
115    pub realm: RealmInstance,
116}
117
118impl PkgDirRealm {
119    pub async fn new(fxblob: bool, exposed_dir: fio::DirectoryProxy) -> Self {
120        let builder = RealmBuilder::new().await.unwrap();
121        let pkgdir = builder
122            .add_child("pkgdir-component", "#meta/pkgdir-component.cm", ChildOptions::new())
123            .await
124            .unwrap();
125        builder.init_mutable_config_from_package(&pkgdir).await.unwrap();
126        let exposed_dir = vfs::pseudo_directory! {
127            "blob" => vfs::remote::remote_dir(exposed_dir),
128        };
129        let service_reflector = builder
130            .add_local_child(
131                "service_reflector",
132                move |handles| {
133                    let scope = vfs::execution_scope::ExecutionScope::new();
134                    vfs::directory::serve_on(
135                        exposed_dir.clone(),
136                        fio::PERM_READABLE,
137                        scope.clone(),
138                        handles.outgoing_dir,
139                    );
140                    async move {
141                        scope.wait().await;
142                        Ok(())
143                    }
144                    .boxed()
145                },
146                ChildOptions::new(),
147            )
148            .await
149            .unwrap();
150        builder
151            .add_route(
152                Route::new()
153                    .capability(Capability::protocol::<fidl_test_pkgdir::PkgDirMarker>())
154                    .from(&pkgdir)
155                    .to(Ref::parent()),
156            )
157            .await
158            .unwrap();
159        builder
160            .add_route(
161                Route::new()
162                    .capability(
163                        Capability::protocol::<fidl_fuchsia_tracing_provider::RegistryMarker>(),
164                    )
165                    .from(Ref::parent())
166                    .to(&pkgdir),
167            )
168            .await
169            .unwrap();
170        builder
171            .add_route(
172                Route::new()
173                    .capability(
174                        Capability::directory("blob-exec")
175                            .path("/blob/root")
176                            .rights(fio::R_STAR_DIR),
177                    )
178                    .from(&service_reflector)
179                    .to(&pkgdir),
180            )
181            .await
182            .unwrap();
183        let svc_path = if fxblob {
184            format!("/blob/svc/{}", fidl_fuchsia_fxfs::BlobReaderMarker::PROTOCOL_NAME)
185        } else {
186            format!("/blob/{}", fidl_fuchsia_fxfs::BlobReaderMarker::PROTOCOL_NAME)
187        };
188        builder
189            .add_route(
190                Route::new()
191                    .capability(
192                        Capability::protocol::<fidl_fuchsia_fxfs::BlobReaderMarker>()
193                            .path(svc_path),
194                    )
195                    .from(&service_reflector)
196                    .to(&pkgdir),
197            )
198            .await
199            .unwrap();
200        let realm = builder.build().await.expect("realm build failed");
201        Self { realm }
202    }
203
204    fn realm(&self) -> &RealmInstance {
205        &self.realm
206    }
207}
fuchsia_storage_benchmarks/filesystems/pkgdir.rs

fuchsia_storage_benchmarks/filesystems/
pkgdir.rs
