block_adapter/
lib.rs

1// Copyright 2022 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// This launches the binary specified in the arguments and takes the block device that is passed via
6// the usual startup handle and makes it appear to the child process as an object that will work
7// with POSIX I/O.  The object will exist in the child's namespace under /device/block.  At the time
8// of writing, this is used to run the fsck-msdosfs and mkfs-msdosfs tools which use POSIX I/O to
9// interact with block devices.
10
11use anyhow::Error;
12use block_client::{BlockClient as _, BufferSlice, MutableBufferSlice, RemoteBlockClient};
13use fidl::endpoints::{create_endpoints, ServerEnd};
14use std::sync::Arc;
15use vfs::directory::entry::{DirectoryEntry, EntryInfo, GetEntryInfo, OpenRequest};
16use vfs::directory::entry_container::Directory;
17use vfs::execution_scope::ExecutionScope;
18use vfs::file::{FidlIoConnection, File, FileIo, FileLike, FileOptions, SyncMode};
19use vfs::node::Node;
20use vfs::path::Path;
21use vfs::{immutable_attributes, pseudo_directory, ObjectRequestRef};
22use {
23    fidl_fuchsia_hardware_block as fhardware_block, fidl_fuchsia_io as fio, fuchsia_async as fasync,
24};
25
26struct BlockFile {
27    block_client: RemoteBlockClient,
28}
29
30impl DirectoryEntry for BlockFile {
31    fn open_entry(self: Arc<Self>, request: OpenRequest<'_>) -> Result<(), zx::Status> {
32        request.open_file(self)
33    }
34}
35
36impl GetEntryInfo for BlockFile {
37    fn entry_info(&self) -> EntryInfo {
38        EntryInfo::new(0, fio::DirentType::File)
39    }
40}
41
42impl Node for BlockFile {
43    async fn get_attributes(
44        &self,
45        requested_attributes: fio::NodeAttributesQuery,
46    ) -> Result<fio::NodeAttributes2, zx::Status> {
47        let block_size = self.block_client.block_size();
48        let block_count = self.block_client.block_count();
49        let device_size = block_count.checked_mul(block_size.into()).unwrap();
50        Ok(immutable_attributes!(
51            requested_attributes,
52            Immutable {
53                protocols: fio::NodeProtocolKinds::FILE,
54                abilities: fio::Operations::GET_ATTRIBUTES
55                    | fio::Operations::UPDATE_ATTRIBUTES
56                    | fio::Operations::READ_BYTES
57                    | fio::Operations::WRITE_BYTES,
58                content_size: device_size,
59                storage_size: device_size,
60            }
61        ))
62    }
63}
64
65impl File for BlockFile {
66    fn writable(&self) -> bool {
67        true
68    }
69
70    async fn open_file(&self, _options: &FileOptions) -> Result<(), zx::Status> {
71        Ok(())
72    }
73
74    async fn truncate(&self, _length: u64) -> Result<(), zx::Status> {
75        Err(zx::Status::NOT_SUPPORTED)
76    }
77
78    async fn get_backing_memory(&self, _flags: fio::VmoFlags) -> Result<zx::Vmo, zx::Status> {
79        Err(zx::Status::NOT_SUPPORTED)
80    }
81
82    async fn get_size(&self) -> Result<u64, zx::Status> {
83        let block_size = self.block_client.block_size();
84        let block_count = self.block_client.block_count();
85        Ok(block_count.checked_mul(block_size.into()).unwrap())
86    }
87
88    async fn update_attributes(
89        &self,
90        _attributes: fio::MutableNodeAttributes,
91    ) -> Result<(), zx::Status> {
92        Err(zx::Status::NOT_SUPPORTED)
93    }
94
95    async fn sync(&self, _mode: SyncMode) -> Result<(), zx::Status> {
96        self.block_client.flush().await
97    }
98}
99
100impl FileIo for BlockFile {
101    async fn read_at(&self, offset: u64, buffer: &mut [u8]) -> Result<u64, zx::Status> {
102        let () = self.block_client.read_at(MutableBufferSlice::Memory(buffer), offset).await?;
103        Ok(buffer.len().try_into().unwrap())
104    }
105
106    async fn write_at(&self, offset: u64, content: &[u8]) -> Result<u64, zx::Status> {
107        let () = self.block_client.write_at(BufferSlice::Memory(content), offset).await?;
108        Ok(content.len().try_into().unwrap())
109    }
110
111    async fn append(&self, _content: &[u8]) -> Result<(u64, u64), zx::Status> {
112        Err(zx::Status::NOT_SUPPORTED)
113    }
114}
115
116impl FileLike for BlockFile {
117    fn open(
118        self: Arc<Self>,
119        scope: ExecutionScope,
120        options: FileOptions,
121        object_request: ObjectRequestRef<'_>,
122    ) -> Result<(), zx::Status> {
123        FidlIoConnection::create_sync(scope, self, options, object_request.take());
124        Ok(())
125    }
126}
127
128// This launches the binary specified in the arguments and takes a block device and makes it appear
129// to the child process as an object that will work with POSIX I/O.  The object will exist in the
130// child's namespace under /device/block.  At the time of writing, this is used to run the
131// fsck-msdosfs and mkfs-msdosfs tools which use POSIX I/O to interact with block devices.
132pub async fn run(
133    block_proxy: fhardware_block::BlockProxy,
134    binary: &str,
135    args: impl Iterator<Item = String>,
136) -> Result<i64, Error> {
137    let (client, server) = create_endpoints::<fio::DirectoryMarker>();
138
139    let server_fut = {
140        let block_client = RemoteBlockClient::new(block_proxy).await?;
141        let dir = pseudo_directory! {
142            "block" => Arc::new(BlockFile {
143                block_client,
144            }),
145        };
146
147        let scope = ExecutionScope::new();
148        let () = dir.open(
149            scope.clone(),
150            fio::OpenFlags::RIGHT_READABLE | fio::OpenFlags::RIGHT_WRITABLE,
151            Path::dot(),
152            ServerEnd::new(server.into_channel()),
153        );
154        async move { scope.wait().await }
155    };
156
157    let client_fut = {
158        let mut builder = fdio::SpawnBuilder::new()
159            .options(fdio::SpawnOptions::CLONE_ALL)
160            .add_directory_to_namespace("/device", client)?
161            .arg(binary)?;
162        for arg in args {
163            builder = builder.arg(arg)?;
164        }
165        builder = builder.arg("/device/block")?;
166        let process = builder.spawn_from_path(binary, &fuchsia_runtime::job_default())?;
167
168        async move {
169            let _: zx::Signals =
170                fasync::OnSignals::new(&process, zx::Signals::PROCESS_TERMINATED).await?;
171            let info = process.info()?;
172            Ok::<_, Error>(info.return_code)
173        }
174    };
175
176    futures::future::join(server_fut, client_fut).await.1
177}
block_adapter/lib.rs

block_adapter/
lib.rs
