gpt_component/
partition.rs1use crate::gpt::GptPartition;
5use anyhow::Error;
6use block_client::{VmoId, WriteOptions};
7use block_server::async_interface::{PassthroughSession, SessionManager};
8use block_server::OffsetMap;
9use fidl_fuchsia_hardware_block as fblock;
10
11use fuchsia_sync::Mutex;
12use std::borrow::Cow;
13use std::collections::BTreeMap;
14use std::num::NonZero;
15use std::sync::Arc;
16
17pub struct PartitionBackend {
20 partition: Arc<GptPartition>,
21 vmo_keys_to_vmoids_map: Mutex<BTreeMap<usize, Arc<VmoId>>>,
22}
23
24impl block_server::async_interface::Interface for PartitionBackend {
25 async fn open_session(
26 &self,
27 session_manager: Arc<SessionManager<Self>>,
28 stream: fblock::SessionRequestStream,
29 offset_map: OffsetMap,
30 block_size: u32,
31 ) -> Result<(), Error> {
32 if !offset_map.is_empty() {
33 return session_manager.serve_session(stream, offset_map, block_size).await;
36 }
37 let (proxy, server_end) = fidl::endpoints::create_proxy::<fblock::SessionMarker>();
38 self.partition.open_passthrough_session(server_end);
39 let passthrough = PassthroughSession::new(proxy);
40 passthrough.serve(stream).await
41 }
42
43 async fn on_attach_vmo(&self, vmo: &zx::Vmo) -> Result<(), zx::Status> {
44 let key = std::ptr::from_ref(vmo) as usize;
45 let vmoid = self.partition.attach_vmo(vmo).await?;
46 let old = self.vmo_keys_to_vmoids_map.lock().insert(key, Arc::new(vmoid));
47 if let Some(vmoid) = old {
48 let _ = Arc::try_unwrap(vmoid)
53 .map(|vmoid| vmoid.into_id())
54 .expect("VMO removed while in use");
55 }
56 Ok(())
57 }
58
59 async fn get_info(&self) -> Result<Cow<'_, block_server::DeviceInfo>, zx::Status> {
60 Ok(Cow::Owned(self.partition.get_info().await?))
61 }
62
63 fn barrier(&self) -> Result<(), zx::Status> {
64 self.partition.barrier();
65 Ok(())
66 }
67
68 async fn read(
69 &self,
70 device_block_offset: u64,
71 block_count: u32,
72 vmo: &Arc<zx::Vmo>,
73 vmo_offset: u64, trace_flow_id: Option<NonZero<u64>>,
75 ) -> Result<(), zx::Status> {
76 let vmoid = self.get_vmoid(vmo)?;
77 self.partition
78 .read(device_block_offset, block_count, vmoid.as_ref(), vmo_offset, trace_flow_id)
79 .await
80 }
81
82 async fn write(
83 &self,
84 device_block_offset: u64,
85 length: u32,
86 vmo: &Arc<zx::Vmo>,
87 vmo_offset: u64, opts: WriteOptions,
89 trace_flow_id: Option<NonZero<u64>>,
90 ) -> Result<(), zx::Status> {
91 let vmoid = self.get_vmoid(vmo)?;
92 self.partition
93 .write(device_block_offset, length, vmoid.as_ref(), vmo_offset, opts, trace_flow_id)
94 .await
95 }
96
97 async fn flush(&self, trace_flow_id: Option<NonZero<u64>>) -> Result<(), zx::Status> {
98 self.partition.flush(trace_flow_id).await
99 }
100
101 async fn trim(
102 &self,
103 device_block_offset: u64,
104 block_count: u32,
105 trace_flow_id: Option<NonZero<u64>>,
106 ) -> Result<(), zx::Status> {
107 self.partition.trim(device_block_offset, block_count, trace_flow_id).await
108 }
109}
110
111impl PartitionBackend {
112 pub fn new(partition: Arc<GptPartition>) -> Arc<Self> {
113 Arc::new(Self { partition, vmo_keys_to_vmoids_map: Mutex::new(BTreeMap::new()) })
114 }
115
116 fn get_vmoid(&self, vmo: &zx::Vmo) -> Result<Arc<VmoId>, zx::Status> {
117 let key = std::ptr::from_ref(vmo) as usize;
118 self.vmo_keys_to_vmoids_map.lock().get(&key).map(Arc::clone).ok_or(zx::Status::NOT_FOUND)
119 }
120}
121
122impl Drop for PartitionBackend {
123 fn drop(&mut self) {
124 for vmoid in std::mem::take(&mut *self.vmo_keys_to_vmoids_map.lock()).into_values() {
125 let _ = Arc::try_unwrap(vmoid)
128 .map(|vmoid| vmoid.into_id())
129 .expect("VMO removed while in use");
130 }
131 }
132}