storage/nvmed: Use DiskWrapper

Cargo.lock

@@ -854,7 +854,6 @@ dependencies = [
  "futures",
  "libredox",
  "log",
- "partitionlib",
  "pcid",
  "redox-daemon",
  "redox-scheme 0.3.0",

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
-    }
 }

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)
     }
 

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
                 }
             },
         ))

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))
             }
         }
     }

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
-    }
 }

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<Option<usize>>;
     fn write(&mut self, block: u64, buffer: &[u8]) -> syscall::Result<Option<usize>>;
 }
 
 impl<T: Disk + ?Sized> Disk for Box<T> {
-    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<T> {
 
 impl<T: Disk> DiskWrapper<T> {
     pub fn pt(disk: &mut T) -> Option<PartitionTable> {
-        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<T: Disk> DiskWrapper<T> {
         // 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<usize> {
-                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;

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
-    }
 }

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))
             }
         }
     }

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" }

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<Nvme>, 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<PartitionTable>,
-}
-
-impl AsRef<NvmeNamespace> for DiskWrapper {
-    fn as_ref(&self) -> &NvmeNamespace {
-        &self.inner
-    }
-}
-
-impl DiskWrapper {
-    fn pt(disk: NvmeNamespace, nvme: &Nvme) -> Option<PartitionTable> {
-        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<Nvme>,
-    disks: BTreeMap<u32, DiskWrapper>,
+    disks: BTreeMap<u32, DiskWrapper<NvmeDisk>>,
     handles: BTreeMap<usize, Handle>,
     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())
                 }
             },
         ))

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<Option<usize>> {
         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)
             }