storage_isolated_driver_manager/
lib.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
5use anyhow::{anyhow, Context, Result};
6use fidl_fuchsia_device::ControllerProxy;
7use fidl_fuchsia_hardware_block_partition::{PartitionMarker, PartitionProxy};
8use fs_management::filesystem::BlockConnector;
9use fs_management::format::{detect_disk_format, DiskFormat};
10use fuchsia_component::client::{connect_to_protocol_at_path, ServiceInstanceStream};
11use fuchsia_fs::directory::{WatchEvent, Watcher};
12use futures::TryStreamExt;
13use std::path::{Path, PathBuf};
14use {fidl_fuchsia_io as fio, fidl_fuchsia_storage_partitions as fpartitions};
15
16pub mod fvm;
17pub mod zxcrypt;
18
19pub type Guid = [u8; 16];
20
21pub fn into_guid(guid: Guid) -> fidl_fuchsia_hardware_block_partition::Guid {
22    fidl_fuchsia_hardware_block_partition::Guid { value: guid }
23}
24
25pub fn create_random_guid() -> Guid {
26    *uuid::Uuid::new_v4().as_bytes()
27}
28
29pub async fn bind_fvm(proxy: &ControllerProxy) -> Result<()> {
30    fvm::bind_fvm_driver(proxy).await
31}
32
33async fn partition_type_guid_matches(guid: &Guid, partition: &PartitionProxy) -> Result<bool> {
34    let (status, type_guid) =
35        partition.get_type_guid().await.context("Failed to get type guid (fidl error")?;
36    zx::ok(status).context("Failed to get type guid")?;
37    let type_guid = if let Some(guid) = type_guid { guid } else { return Ok(false) };
38    let matched = type_guid.value == *guid;
39    log::info!(matched, type_guid:?, target_guid:?=guid; "matching type guid");
40    Ok(matched)
41}
42
43async fn partition_instance_guid_matches(guid: &Guid, partition: &PartitionProxy) -> Result<bool> {
44    let (status, instance_guid) =
45        partition.get_instance_guid().await.context("Failed to get instance guid (fidl error")?;
46    zx::ok(status).context("Failed to get instance guid")?;
47    let instance_guid = if let Some(guid) = instance_guid { guid } else { return Ok(false) };
48    let matched = instance_guid.value == *guid;
49    log::info!(matched, instance_guid:?, target_guid:?=guid; "matching instance guid");
50    Ok(matched)
51}
52
53async fn partition_name_matches(name: &str, partition: &PartitionProxy) -> Result<bool> {
54    let (status, partition_name) =
55        partition.get_name().await.context("Failed to get partition name (fidl error")?;
56    zx::ok(status).context("Failed to get partition name")?;
57    let partition_name = if let Some(name) = partition_name { name } else { return Ok(false) };
58    let matched = partition_name == name;
59    log::info!(matched, partition_name = partition_name.as_str(), target_name = name; "matching name");
60    Ok(matched)
61}
62
63async fn block_contents_match(format: DiskFormat, block: &PartitionProxy) -> Result<bool> {
64    let content_format = detect_disk_format(block).await;
65    Ok(format == content_format)
66}
67
68/// A constraint for the block device being waited for in `wait_for_block_device`.
69#[derive(Debug)]
70pub enum BlockDeviceMatcher<'a> {
71    /// Only matches block devices that have this type Guid.
72    TypeGuid(&'a Guid),
73
74    /// Only matches block devices that have this instance Guid.
75    InstanceGuid(&'a Guid),
76
77    /// Only matches block devices that have this name.
78    Name(&'a str),
79
80    /// Only matches block devices whose contents match the given format.
81    ContentsMatch(DiskFormat),
82}
83
84impl BlockDeviceMatcher<'_> {
85    async fn matches(&self, partition: &PartitionProxy) -> Result<bool> {
86        match self {
87            Self::TypeGuid(guid) => partition_type_guid_matches(guid, partition).await,
88            Self::InstanceGuid(guid) => partition_instance_guid_matches(guid, partition).await,
89            Self::Name(name) => partition_name_matches(name, partition).await,
90            Self::ContentsMatch(format) => block_contents_match(*format, partition).await,
91        }
92    }
93}
94
95async fn matches_all(partition: &PartitionProxy, matchers: &[BlockDeviceMatcher<'_>]) -> bool {
96    for matcher in matchers {
97        if !matcher.matches(partition).await.unwrap_or(false) {
98            return false;
99        }
100    }
101    true
102}
103
104/// Waits for a block device to appear in `/dev/class/block` that meets all of the requirements of
105/// `matchers`. Returns the path to the matched block device.
106/// TODO(https://fxbug.dev/339491886): Remove when all clients are ported to
107/// `wait_for_block_device`.
108pub async fn wait_for_block_device_devfs(matchers: &[BlockDeviceMatcher<'_>]) -> Result<PathBuf> {
109    const DEV_CLASS_BLOCK: &str = "/dev/class/block";
110    assert!(!matchers.is_empty());
111    let block_dev_dir =
112        fuchsia_fs::directory::open_in_namespace(DEV_CLASS_BLOCK, fio::PERM_READABLE)?;
113    let mut watcher = Watcher::new(&block_dev_dir).await?;
114    while let Some(msg) = watcher.try_next().await? {
115        if msg.event != WatchEvent::ADD_FILE && msg.event != WatchEvent::EXISTING {
116            continue;
117        }
118        if msg.filename.to_str() == Some(".") {
119            continue;
120        }
121        let path = Path::new(DEV_CLASS_BLOCK).join(msg.filename);
122        let partition = connect_to_protocol_at_path::<PartitionMarker>(path.to_str().unwrap())?;
123        if matches_all(&partition, matchers).await {
124            return Ok(path);
125        }
126    }
127    Err(anyhow!("Failed to wait for block device"))
128}
129
130/// Waits for the first partition service instance that meets all of the requirements of `matchers`.
131/// Returns the path to the matched block device.
132/// TODO(https://fxbug.dev/339491886): Remove when all clients are ported to
133/// `wait_for_block_device_devfs.
134pub async fn wait_for_block_device(
135    matchers: &[BlockDeviceMatcher<'_>],
136    mut stream: ServiceInstanceStream<fpartitions::PartitionServiceMarker>,
137) -> Result<fpartitions::PartitionServiceProxy> {
138    while let Some(proxy) = stream.try_next().await? {
139        let partition = proxy.connect_partition()?.into_proxy();
140        if matches_all(&partition, matchers).await {
141            return Ok(proxy);
142        }
143    }
144    unreachable!()
145}
146
147/// Looks for a block device already in `/dev/class/block` that meets all of the requirements of
148/// `matchers`. Returns the path to the matched block device.
149/// TODO(https://fxbug.dev/339491886): Remove when all clients are ported to `find_block_device`.
150pub async fn find_block_device_devfs(matchers: &[BlockDeviceMatcher<'_>]) -> Result<PathBuf> {
151    const DEV_CLASS_BLOCK: &str = "/dev/class/block";
152    assert!(!matchers.is_empty());
153    let block_dev_dir =
154        fuchsia_fs::directory::open_in_namespace(DEV_CLASS_BLOCK, fio::PERM_READABLE)?;
155    let entries = fuchsia_fs::directory::readdir(&block_dev_dir)
156        .await
157        .context("Failed to readdir /dev/class/block")?;
158    for entry in entries {
159        let path = Path::new(DEV_CLASS_BLOCK).join(entry.name);
160        let partition = connect_to_protocol_at_path::<PartitionMarker>(path.to_str().unwrap())?;
161        if matches_all(&partition, matchers).await {
162            return Ok(path);
163        }
164    }
165    Err(anyhow!("Failed to find matching block device"))
166}
167
168/// Returns the first partition in `partitions` matching all of `matchers.`  Ok(None) indicates no
169/// partitions matched.
170pub async fn find_block_device<C, Iter>(
171    matchers: &[BlockDeviceMatcher<'_>],
172    partitions: Iter,
173) -> Result<Option<C>>
174where
175    C: BlockConnector,
176    Iter: Iterator<Item = C>,
177{
178    for connector in partitions {
179        let partition = connector.connect_partition()?.into_proxy();
180        if matches_all(&partition, matchers).await {
181            return Ok(Some(connector));
182        }
183    }
184    Ok(None)
185}
186
187#[cfg(test)]
188mod tests {
189    use super::*;
190    use fidl_fuchsia_hardware_block_volume::ALLOCATE_PARTITION_FLAG_INACTIVE;
191    use ramdevice_client::RamdiskClient;
192    const BLOCK_SIZE: u64 = 512;
193    const BLOCK_COUNT: u64 = 64 * 1024 * 1024 / BLOCK_SIZE;
194    const FVM_SLICE_SIZE: usize = 1024 * 1024;
195    const INSTANCE_GUID: Guid = [
196        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
197        0x0f,
198    ];
199    const TYPE_GUID: Guid = [
200        0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0,
201        0xf0,
202    ];
203    const VOLUME_NAME: &str = "volume-name";
204
205    #[fuchsia::test]
206    async fn wait_for_block_device_devfs_with_all_match_criteria() {
207        let ramdisk = RamdiskClient::create(BLOCK_SIZE, BLOCK_COUNT).await.unwrap();
208        let fvm = fvm::set_up_fvm(
209            ramdisk.as_controller().expect("invalid controller"),
210            ramdisk.as_dir().expect("invalid directory proxy"),
211            FVM_SLICE_SIZE,
212        )
213        .await
214        .expect("Failed to format ramdisk with FVM");
215        fvm::create_fvm_volume(
216            &fvm,
217            VOLUME_NAME,
218            &TYPE_GUID,
219            &INSTANCE_GUID,
220            None,
221            ALLOCATE_PARTITION_FLAG_INACTIVE,
222        )
223        .await
224        .expect("Failed to create fvm volume");
225
226        wait_for_block_device_devfs(&[
227            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
228            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
229            BlockDeviceMatcher::Name(VOLUME_NAME),
230        ])
231        .await
232        .expect("Failed to find block device");
233
234        find_block_device_devfs(&[
235            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
236            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
237            BlockDeviceMatcher::Name(VOLUME_NAME),
238        ])
239        .await
240        .expect("Failed to find block device");
241
242        find_block_device_devfs(&[
243            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
244            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
245            BlockDeviceMatcher::Name("something else"),
246        ])
247        .await
248        .expect_err("Unexpected match for block device");
249    }
250
251    #[fuchsia::test]
252    async fn wait_for_block_device_with_all_match_criteria() {
253        let ramdisk = RamdiskClient::create(BLOCK_SIZE, BLOCK_COUNT).await.unwrap();
254        let fvm = fvm::set_up_fvm(
255            ramdisk.as_controller().expect("invalid controller"),
256            ramdisk.as_dir().expect("invalid directory proxy"),
257            FVM_SLICE_SIZE,
258        )
259        .await
260        .expect("Failed to format ramdisk with FVM");
261        fvm::create_fvm_volume(
262            &fvm,
263            VOLUME_NAME,
264            &TYPE_GUID,
265            &INSTANCE_GUID,
266            None,
267            ALLOCATE_PARTITION_FLAG_INACTIVE,
268        )
269        .await
270        .expect("Failed to create fvm volume");
271
272        wait_for_block_device_devfs(&[
273            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
274            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
275            BlockDeviceMatcher::Name(VOLUME_NAME),
276        ])
277        .await
278        .expect("Failed to find block device");
279
280        find_block_device_devfs(&[
281            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
282            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
283            BlockDeviceMatcher::Name(VOLUME_NAME),
284        ])
285        .await
286        .expect("Failed to find block device");
287
288        find_block_device_devfs(&[
289            BlockDeviceMatcher::TypeGuid(&TYPE_GUID),
290            BlockDeviceMatcher::InstanceGuid(&INSTANCE_GUID),
291            BlockDeviceMatcher::Name("something else"),
292        ])
293        .await
294        .expect_err("Unexpected match for block device");
295    }
296}
storage_isolated_driver_manager/lib.rs

storage_isolated_driver_manager/
lib.rs
