From b1dcda4cf770110b30b9af2591bdfef3a4239188 Mon Sep 17 00:00:00 2001 From: bjorn3 <17426603+bjorn3@users.noreply.github.com> Date: Fri, 7 Mar 2025 22:35:01 +0100 Subject: [PATCH] storage/nvmed: Use DiskWrapper --- Cargo.lock | 1 - storage/ahcid/src/ahci/disk_ata.rs | 10 ++-- storage/ahcid/src/ahci/disk_atapi.rs | 4 +- storage/ahcid/src/scheme.rs | 16 +++--- storage/bcm2835-sdhcid/src/scheme.rs | 16 +++--- storage/bcm2835-sdhcid/src/sd/mod.rs | 10 ++-- storage/driver-block/src/lib.rs | 14 ++--- storage/ided/src/ide.rs | 10 ++-- storage/ided/src/scheme.rs | 16 +++--- storage/nvmed/Cargo.toml | 1 - storage/nvmed/src/scheme.rs | 80 ++++++++-------------------- storage/virtio-blkd/src/scheme.rs | 8 +-- 12 files changed, 74 insertions(+), 112 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 537432f9cd..7f304690ff 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -854,7 +854,6 @@ dependencies = [ "futures", "libredox", "log", - "partitionlib", "pcid", "redox-daemon", "redox-scheme 0.3.0", diff --git a/storage/ahcid/src/ahci/disk_ata.rs b/storage/ahcid/src/ahci/disk_ata.rs index ee3b32a8b6..bb52a4571d 100644 --- a/storage/ahcid/src/ahci/disk_ata.rs +++ b/storage/ahcid/src/ahci/disk_ata.rs @@ -154,7 +154,11 @@ impl DiskATA { } impl Disk for DiskATA { - fn size(&mut self) -> u64 { + fn block_size(&self) -> u32 { + 512 + } + + fn size(&self) -> u64 { self.size } @@ -177,8 +181,4 @@ impl Disk for DiskATA { } } } - - fn block_length(&mut self) -> u32 { - 512 - } } diff --git a/storage/ahcid/src/ahci/disk_atapi.rs b/storage/ahcid/src/ahci/disk_atapi.rs index ce3ce0b962..b92112c36e 100644 --- a/storage/ahcid/src/ahci/disk_atapi.rs +++ b/storage/ahcid/src/ahci/disk_atapi.rs @@ -69,11 +69,11 @@ impl DiskATAPI { } impl Disk for DiskATAPI { - fn block_length(&mut self) -> u32 { + fn block_size(&self) -> u32 { self.blk_size } - fn size(&mut self) -> u64 { + fn size(&self) -> u64 { u64::from(self.blk_count) * u64::from(self.blk_size) } diff --git a/storage/ahcid/src/scheme.rs b/storage/ahcid/src/scheme.rs index 437f70bd2c..63d432e9a8 100644 --- a/storage/ahcid/src/scheme.rs +++ b/storage/ahcid/src/scheme.rs @@ -175,7 +175,7 @@ impl SchemeBlock for DiskScheme { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; stat.st_mode = MODE_FILE; stat.st_size = disk.size(); - stat.st_blksize = disk.block_length(); + stat.st_blksize = disk.block_size(); Ok(Some(0)) } Handle::Partition(disk_id, part_num) => { @@ -190,8 +190,8 @@ impl SchemeBlock for DiskScheme { }; stat.st_mode = MODE_FILE; // TODO: Block device? - stat.st_size = size * u64::from(disk.block_length()); - stat.st_blksize = disk.block_length(); + stat.st_size = size * u64::from(disk.block_size()); + stat.st_blksize = disk.block_size(); stat.st_blocks = size; Ok(Some(0)) } @@ -263,12 +263,12 @@ impl SchemeBlock for DiskScheme { } Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.read(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize); @@ -304,12 +304,12 @@ impl SchemeBlock for DiskScheme { Handle::List(_) => Err(Error::new(EBADF)), Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.write(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize); @@ -351,7 +351,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))? .size; - u64::from(disk.block_length()) * block_count + u64::from(disk.block_size()) * block_count } }, )) diff --git a/storage/bcm2835-sdhcid/src/scheme.rs b/storage/bcm2835-sdhcid/src/scheme.rs index 66f469a943..ebe0612346 100644 --- a/storage/bcm2835-sdhcid/src/scheme.rs +++ b/storage/bcm2835-sdhcid/src/scheme.rs @@ -164,7 +164,7 @@ impl SchemeBlock for DiskScheme { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; stat.st_mode = MODE_FILE; stat.st_size = disk.size(); - stat.st_blksize = disk.block_length(); + stat.st_blksize = disk.block_size(); Ok(Some(0)) } Handle::Partition(disk_id, part_num) => { @@ -179,8 +179,8 @@ impl SchemeBlock for DiskScheme { }; stat.st_mode = MODE_FILE; // TODO: Block device? - stat.st_size = size * u64::from(disk.block_length()); - stat.st_blksize = disk.block_length(); + stat.st_size = size * u64::from(disk.block_size()); + stat.st_blksize = disk.block_size(); stat.st_blocks = size; Ok(Some(0)) } @@ -251,12 +251,12 @@ impl SchemeBlock for DiskScheme { } Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.read(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize); @@ -285,12 +285,12 @@ impl SchemeBlock for DiskScheme { Handle::List(_) => Err(Error::new(EBADF)), Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.write(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize as u64); @@ -331,7 +331,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))? .size; - Ok(Some(u64::from(disk.block_length()) * block_count)) + Ok(Some(u64::from(disk.block_size()) * block_count)) } } } diff --git a/storage/bcm2835-sdhcid/src/sd/mod.rs b/storage/bcm2835-sdhcid/src/sd/mod.rs index deb3839f81..f8e9ab351b 100644 --- a/storage/bcm2835-sdhcid/src/sd/mod.rs +++ b/storage/bcm2835-sdhcid/src/sd/mod.rs @@ -733,7 +733,11 @@ impl SdHostCtrl { } impl Disk for SdHostCtrl { - fn size(&mut self) -> u64 { + fn block_size(&self) -> u32 { + 512 + } + + fn size(&self) -> u64 { //assert 512MiB self.size } @@ -773,8 +777,4 @@ impl Disk for SdHostCtrl { Err(err) => Err(err), } } - - fn block_length(&mut self) -> u32 { - 512 - } } diff --git a/storage/driver-block/src/lib.rs b/storage/driver-block/src/lib.rs index 12d0926204..1eb165d185 100644 --- a/storage/driver-block/src/lib.rs +++ b/storage/driver-block/src/lib.rs @@ -53,19 +53,19 @@ fn block_read( } pub trait Disk { - fn block_length(&mut self) -> u32; - fn size(&mut self) -> u64; + fn block_size(&self) -> u32; + fn size(&self) -> u64; fn read(&mut self, block: u64, buffer: &mut [u8]) -> syscall::Result>; fn write(&mut self, block: u64, buffer: &[u8]) -> syscall::Result>; } impl Disk for Box { - fn block_length(&mut self) -> u32 { - (**self).block_length() + fn block_size(&self) -> u32 { + (**self).block_size() } - fn size(&mut self) -> u64 { + fn size(&self) -> u64 { (**self).size() } @@ -85,7 +85,7 @@ pub struct DiskWrapper { impl DiskWrapper { pub fn pt(disk: &mut T) -> Option { - let bs = match disk.block_length() { + let bs = match disk.block_size() { 512 => LogicalBlockSize::Lb512, 4096 => LogicalBlockSize::Lb4096, _ => return None, @@ -116,7 +116,7 @@ impl DiskWrapper { // TODO: Perhaps this impl should be used in the rest of the scheme. impl<'a> Read for Device<'a> { fn read(&mut self, buf: &mut [u8]) -> io::Result { - let blksize = self.disk.block_length(); + let blksize = self.disk.block_size(); let size_in_blocks = self.disk.size() / u64::from(blksize); let disk = &mut self.disk; diff --git a/storage/ided/src/ide.rs b/storage/ided/src/ide.rs index 94584a9dfb..9748b46b93 100644 --- a/storage/ided/src/ide.rs +++ b/storage/ided/src/ide.rs @@ -169,7 +169,11 @@ pub struct AtaDisk { } impl Disk for AtaDisk { - fn size(&mut self) -> u64 { + fn block_size(&self) -> u32 { + 512 + } + + fn size(&self) -> u64 { self.size } @@ -460,8 +464,4 @@ impl Disk for AtaDisk { Ok(Some(count)) } - - fn block_length(&mut self) -> u32 { - 512 - } } diff --git a/storage/ided/src/scheme.rs b/storage/ided/src/scheme.rs index fb0fa26169..167eb78a80 100644 --- a/storage/ided/src/scheme.rs +++ b/storage/ided/src/scheme.rs @@ -178,7 +178,7 @@ impl SchemeBlock for DiskScheme { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; stat.st_mode = MODE_FILE; stat.st_size = disk.size(); - stat.st_blksize = disk.block_length(); + stat.st_blksize = disk.block_size(); Ok(Some(0)) } Handle::Partition(disk_id, part_num) => { @@ -193,8 +193,8 @@ impl SchemeBlock for DiskScheme { }; stat.st_mode = MODE_FILE; // TODO: Block device? - stat.st_size = size * u64::from(disk.block_length()); - stat.st_blksize = disk.block_length(); + stat.st_size = size * u64::from(disk.block_size()); + stat.st_blksize = disk.block_size(); stat.st_blocks = size; Ok(Some(0)) } @@ -265,12 +265,12 @@ impl SchemeBlock for DiskScheme { } Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.read(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize); @@ -299,12 +299,12 @@ impl SchemeBlock for DiskScheme { Handle::List(_) => Err(Error::new(EBADF)), Handle::Disk(number) => { let disk = self.disks.get_mut(number).ok_or(Error::new(EBADF))?; - let blk_len = disk.block_length(); + let blk_len = disk.block_size(); disk.write(offset / u64::from(blk_len), buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(disk_num).ok_or(Error::new(EBADF))?; - let blksize = disk.block_length(); + let blksize = disk.block_size(); // validate that we're actually reading within the bounds of the partition let rel_block = offset / u64::from(blksize as u64); @@ -345,7 +345,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))? .size; - Ok(Some(u64::from(disk.block_length()) * block_count)) + Ok(Some(u64::from(disk.block_size()) * block_count)) } } } diff --git a/storage/nvmed/Cargo.toml b/storage/nvmed/Cargo.toml index 04cf4bb27c..8a6d1c6663 100644 --- a/storage/nvmed/Cargo.toml +++ b/storage/nvmed/Cargo.toml @@ -13,7 +13,6 @@ redox-daemon = "0.1" redox_syscall = { version = "0.5", features = ["std"] } redox-scheme = { git = "https://gitlab.redox-os.org/redox-os/redox-scheme.git" } redox_event = "0.4" -partitionlib = { path = "../partitionlib" } smallvec = "1" common = { path = "../../common" } diff --git a/storage/nvmed/src/scheme.rs b/storage/nvmed/src/scheme.rs index 1a730920c9..48018b33e5 100644 --- a/storage/nvmed/src/scheme.rs +++ b/storage/nvmed/src/scheme.rs @@ -4,8 +4,7 @@ use std::fmt::Write; use std::str; use std::sync::Arc; -use driver_block::Disk; -use partitionlib::PartitionTable; +use driver_block::{Disk, DiskWrapper}; use redox_scheme::{CallerCtx, OpenResult, SchemeBlock}; use syscall::schemev2::NewFdFlags; use syscall::{ @@ -21,14 +20,14 @@ enum Handle { Partition(u32, u32), // disk num, part num } -struct NamespaceAndNvme<'a>(&'a Nvme, NvmeNamespace); +struct NvmeDisk(Arc, NvmeNamespace); -impl Disk for NamespaceAndNvme<'_> { - fn block_length(&mut self) -> u32 { +impl Disk for NvmeDisk { + fn block_size(&self) -> u32 { self.1.block_size.try_into().unwrap() } - fn size(&mut self) -> u64 { + fn size(&self) -> u64 { self.1.blocks * self.1.block_size } @@ -41,33 +40,9 @@ impl Disk for NamespaceAndNvme<'_> { } } -pub struct DiskWrapper { - inner: NvmeNamespace, - pt: Option, -} - -impl AsRef for DiskWrapper { - fn as_ref(&self) -> &NvmeNamespace { - &self.inner - } -} - -impl DiskWrapper { - fn pt(disk: NvmeNamespace, nvme: &Nvme) -> Option { - driver_block::DiskWrapper::pt(&mut NamespaceAndNvme(nvme, disk)) - } - fn new(inner: NvmeNamespace, nvme: &Nvme) -> Self { - Self { - pt: Self::pt(inner, nvme), - inner, - } - } -} - pub struct DiskScheme { scheme_name: String, - nvme: Arc, - disks: BTreeMap, + disks: BTreeMap>, handles: BTreeMap, next_id: usize, } @@ -82,9 +57,8 @@ impl DiskScheme { scheme_name, disks: disks .into_iter() - .map(|(k, v)| (k, DiskWrapper::new(v, &nvme))) + .map(|(k, ns)| (k, DiskWrapper::new(NvmeDisk(nvme.clone(), ns)))) .collect(), - nvme, handles: BTreeMap::new(), next_id: 0, } @@ -209,13 +183,9 @@ impl SchemeBlock for DiskScheme { Handle::Disk(number) => { let disk = self.disks.get_mut(&number).ok_or(Error::new(EBADF))?; stat.st_mode = MODE_FILE; - stat.st_blocks = disk.as_ref().blocks; - stat.st_blksize = disk - .as_ref() - .block_size - .try_into() - .expect("Unreasonable block size of over 2^32 bytes"); - stat.st_size = disk.as_ref().blocks * disk.as_ref().block_size; + stat.st_blocks = disk.1.blocks; + stat.st_blksize = disk.block_size(); + stat.st_size = disk.size(); Ok(Some(0)) } Handle::Partition(disk_num, part_num) => { @@ -228,13 +198,9 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))?; stat.st_mode = MODE_FILE; - stat.st_size = part.size * disk.as_ref().block_size; + stat.st_size = part.size * u64::from(disk.block_size()); stat.st_blocks = part.size; - stat.st_blksize = disk - .as_ref() - .block_size - .try_into() - .expect("Unreasonable block size of over 2^32 bytes"); + stat.st_blksize = disk.block_size(); Ok(Some(0)) } } @@ -304,9 +270,8 @@ impl SchemeBlock for DiskScheme { } Handle::Disk(number) => { let disk = self.disks.get_mut(&number).ok_or(Error::new(EBADF))?; - let block_size = disk.as_ref().block_size; - self.nvme - .namespace_read(*disk.as_ref(), offset / block_size, buf) + let block_size = u64::from(disk.block_size()); + disk.read(offset / block_size, buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(&disk_num).ok_or(Error::new(EBADF))?; @@ -318,7 +283,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))?; - let block_size = disk.as_ref().block_size; + let block_size = u64::from(disk.block_size()); let rel_block = offset / block_size; if rel_block >= part.size { return Err(Error::new(EOVERFLOW)); @@ -326,7 +291,7 @@ impl SchemeBlock for DiskScheme { let abs_block = part.start_lba + rel_block; - self.nvme.namespace_read(*disk.as_ref(), abs_block, buf) + disk.read(abs_block, buf) } } } @@ -342,9 +307,8 @@ impl SchemeBlock for DiskScheme { Handle::List(_) => Err(Error::new(EBADF)), Handle::Disk(number) => { let disk = self.disks.get_mut(&number).ok_or(Error::new(EBADF))?; - let block_size = disk.as_ref().block_size; - self.nvme - .namespace_write(*disk.as_ref(), offset / block_size, buf) + let block_size = u64::from(disk.block_size()); + disk.write(offset / block_size, buf) } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(&disk_num).ok_or(Error::new(EBADF))?; @@ -356,7 +320,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))?; - let block_size = disk.as_ref().block_size; + let block_size = u64::from(disk.block_size()); let rel_block = offset / block_size; if rel_block >= part.size { return Err(Error::new(EOVERFLOW)); @@ -364,7 +328,7 @@ impl SchemeBlock for DiskScheme { let abs_block = part.start_lba + rel_block; - self.nvme.namespace_write(*disk.as_ref(), abs_block, buf) + disk.write(abs_block, buf) } } } @@ -375,7 +339,7 @@ impl SchemeBlock for DiskScheme { Handle::List(ref handle) => handle.len() as u64, Handle::Disk(number) => { let disk = self.disks.get_mut(&number).ok_or(Error::new(EBADF))?; - disk.as_ref().blocks * disk.as_ref().block_size + disk.size() } Handle::Partition(disk_num, part_num) => { let disk = self.disks.get_mut(&disk_num).ok_or(Error::new(EBADF))?; @@ -387,7 +351,7 @@ impl SchemeBlock for DiskScheme { .get(part_num as usize) .ok_or(Error::new(EBADF))?; - part.size * disk.as_ref().block_size + part.size * u64::from(disk.block_size()) } }, )) diff --git a/storage/virtio-blkd/src/scheme.rs b/storage/virtio-blkd/src/scheme.rs index e498798556..f47abc33c6 100644 --- a/storage/virtio-blkd/src/scheme.rs +++ b/storage/virtio-blkd/src/scheme.rs @@ -98,11 +98,11 @@ impl<'a> VirtioDisk<'a> { } impl driver_block::Disk for VirtioDisk<'_> { - fn block_length(&mut self) -> u32 { + fn block_size(&self) -> u32 { self.cfg.block_size() } - fn size(&mut self) -> u64 { + fn size(&self) -> u64 { self.cfg.capacity() * u64::from(self.cfg.block_size()) } @@ -259,7 +259,7 @@ impl<'a> SchemeBlock for DiskScheme<'a> { } Handle::Disk => { - let block = offset / u64::from(self.disk.block_length()); + let block = offset / u64::from(self.disk.block_size()); self.disk.read(block, buf) } } @@ -274,7 +274,7 @@ impl<'a> SchemeBlock for DiskScheme<'a> { ) -> syscall::Result> { match *self.handles.get_mut(&id).ok_or(Error::new(EBADF))? { Handle::Disk => { - let block = offset / u64::from(self.disk.block_length()); + let block = offset / u64::from(self.disk.block_size()); self.disk.write(block, buf) }