disks: Add some logging, fix sysfs resolution, type expansion

We need to use generic BlockDevice from the partitions crate rather
than a specific disk implementation, in order to allow not only mocking
but loopback device use.

We've also fixed up the sysfs vs system_root resolution to ensure we're
doing proper path discovery. As a bonus one can now initialise a loop
device disk from a given `/dev/loopX` path.

Signed-off-by: Ikey Doherty <[email protected]>

Author: ikeycode

Cargo.lock

@@ -6,3 +6,4 @@ description = "A library for working with disks and partitions"
 
 [dependencies]
 regex = "1"
+log.workspace = true

crates/disks/Cargo.toml

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use core::fmt;
+use std::fs;
 use std::{
-    fs,
     ops::Deref,
     path::{Path, PathBuf},
 };
@@ -146,6 +146,8 @@ impl DiskInit for BasicDisk {
     fn from_sysfs_path(sysroot: &Path, name: &str) -> Option<Self> {
         let node = sysroot.join(name);
 
+        log::debug!("Initializing disk at sysfs path: {:?}", node);
+
         // Read the partitions of the disk if any
         let mut partitions: Vec<_> = fs::read_dir(&node)
             .ok()?
@@ -157,12 +159,24 @@ impl DiskInit for BasicDisk {
             .collect();
         partitions.sort_by_key(|p| p.number);
 
+        let sectors = sysfs::read(&node, "size").unwrap_or(0);
+        log::debug!("Read {} sectors for disk {}", sectors, name);
+
+        let device = PathBuf::from(DEVFS_DIR).join(name);
+        log::debug!("Device path: {:?}", device);
+
+        let model = sysfs::read(&node, "device/model");
+        log::debug!("Model: {:?}", model);
+
+        let vendor = sysfs::read(&node, "device/vendor");
+        log::debug!("Vendor: {:?}", vendor);
+
         Some(Self {
             name: name.to_owned(),
-            sectors: sysfs::read(sysroot, &node, "size").unwrap_or(0),
-            device: PathBuf::from(DEVFS_DIR).join(name),
-            model: sysfs::read(sysroot, &node, "device/model"),
-            vendor: sysfs::read(sysroot, &node, "device/vendor"),
+            sectors,
+            device,
+            model,
+            vendor,
             partitions,
         })
     }

crates/disks/src/disk.rs

@@ -9,6 +9,7 @@ use std::{
 };
 
 pub use disk::*;
+use partition::Partition;
 pub mod loopback;
 pub mod mmc;
 pub mod mock;
@@ -18,8 +19,8 @@ pub mod scsi;
 mod sysfs;
 pub mod virt;
 
-const SYSFS_DIR: &str = "/sys/class/block";
-const DEVFS_DIR: &str = "/dev";
+const SYSFS_DIR: &str = "sys/class/block";
+const DEVFS_DIR: &str = "dev";
 
 /// A block device on the system which can be either a physical disk or a partition.
 #[derive(Debug)]
@@ -39,6 +40,65 @@ impl BlockDevice {
         Self::discover_in_sysroot("/")
     }
 
+    /// Returns the total number of sectors on the block device.
+    pub fn sectors(&self) -> u64 {
+        match self {
+            BlockDevice::Disk(disk) => disk.sectors(),
+            BlockDevice::Loopback(device) => device.disk().map_or(0, |d| d.sectors()),
+        }
+    }
+
+    /// Returns the total size of the block device in bytes.
+    pub fn size(&self) -> u64 {
+        self.sectors() * 512
+    }
+
+    /// Returns the partitions on the block device.
+    pub fn partitions(&self) -> &[Partition] {
+        match self {
+            BlockDevice::Disk(disk) => disk.partitions(),
+            BlockDevice::Loopback(device) => device.disk().map_or(&[], |d| d.partitions()),
+        }
+    }
+
+    /// Creates a mock block device with a specified number of sectors.
+    pub fn mock_device(disk: mock::MockDisk) -> Self {
+        BlockDevice::Disk(Box::new(Disk::Mock(disk)))
+    }
+
+    /// Creates a loopback block device from a file path.
+    pub fn loopback_device(device: loopback::Device) -> Self {
+        BlockDevice::Loopback(Box::new(device))
+    }
+
+    /// Creates a BlockDevice from a specific device path
+    ///
+    /// # Arguments
+    ///
+    /// * `device_path` - Path to the block device (e.g. "/dev/sda")
+    ///
+    /// # Returns
+    ///
+    /// The block device or an IO error if creation fails.
+    pub fn from_sysfs_path(sysfs_root: impl AsRef<Path>, name: impl AsRef<str>) -> io::Result<BlockDevice> {
+        let name = name.as_ref();
+        let sysfs_dir = sysfs_root.as_ref();
+
+        if let Some(disk) = scsi::Disk::from_sysfs_path(sysfs_dir, name) {
+            return Ok(BlockDevice::Disk(Box::new(Disk::Scsi(disk))));
+        } else if let Some(disk) = nvme::Disk::from_sysfs_path(sysfs_dir, name) {
+            return Ok(BlockDevice::Disk(Box::new(Disk::Nvme(disk))));
+        } else if let Some(disk) = mmc::Disk::from_sysfs_path(sysfs_dir, name) {
+            return Ok(BlockDevice::Disk(Box::new(Disk::Mmc(disk))));
+        } else if let Some(device) = virt::Disk::from_sysfs_path(sysfs_dir, name) {
+            return Ok(BlockDevice::Disk(Box::new(Disk::Virtual(device))));
+        } else if let Some(device) = loopback::Device::from_sysfs_path(sysfs_dir, name) {
+            return Ok(BlockDevice::Loopback(Box::new(device)));
+        }
+
+        Err(io::Error::new(io::ErrorKind::NotFound, "Device not found"))
+    }
+
     /// Returns the name of the block device.
     pub fn name(&self) -> &str {
         match self {
@@ -79,21 +139,9 @@ impl BlockDevice {
         // For all the discovered block devices, try to create a Disk instance
         // At this point we completely ignore partitions. They come later.
         for entry in entries {
-            let device = if let Some(disk) = scsi::Disk::from_sysfs_path(&sysfs_dir, &entry) {
-                BlockDevice::Disk(Box::new(Disk::Scsi(disk)))
-            } else if let Some(disk) = nvme::Disk::from_sysfs_path(&sysfs_dir, &entry) {
-                BlockDevice::Disk(Box::new(Disk::Nvme(disk)))
-            } else if let Some(disk) = mmc::Disk::from_sysfs_path(&sysfs_dir, &entry) {
-                BlockDevice::Disk(Box::new(Disk::Mmc(disk)))
-            } else if let Some(device) = virt::Disk::from_sysfs_path(&sysfs_dir, &entry) {
-                BlockDevice::Disk(Box::new(Disk::Virtual(device)))
-            } else if let Some(device) = loopback::Device::from_sysfs_path(&sysfs_dir, &entry) {
-                BlockDevice::Loopback(Box::new(device))
-            } else {
-                continue;
-            };
-
-            devices.push(device);
+            if let Ok(device) = BlockDevice::from_sysfs_path(&sysfs_dir, &entry) {
+                devices.push(device);
+            }
         }
 
         Ok(devices)

crates/disks/src/lib.rs

@@ -40,10 +40,10 @@ impl Device {
     ///
     /// * `Some(Device)` if the name matches loop pattern (starts with "loop" followed by numbers)
     /// * `None` if the name doesn't match or the device can't be initialized
-    pub(crate) fn from_sysfs_path(sysroot: &Path, name: &str) -> Option<Self> {
+    pub fn from_sysfs_path(sysroot: &Path, name: &str) -> Option<Self> {
         let matching = name.starts_with("loop") && name[4..].chars().all(char::is_numeric);
-        let node = sysroot.join(SYSFS_DIR).join(name);
-        let file = sysfs::read::<PathBuf>(sysroot, &node, "loop/backing_file");
+        let node = sysroot.join(name);
+        let file = sysfs::read::<PathBuf>(&node, "loop/backing_file");
         let disk = file.as_ref().and_then(|_| BasicDisk::from_sysfs_path(sysroot, name));
         if matching {
             Some(Self {
@@ -57,6 +57,12 @@ impl Device {
         }
     }
 
+    /// Creates a new Device instance from a device path.
+    pub fn from_device_path(device: &Path) -> Option<Self> {
+        let name = device.file_name()?.to_string_lossy().to_string();
+        Self::from_sysfs_path(&PathBuf::from("/").join(SYSFS_DIR), &name)
+    }
+
     /// Returns the device name.
     pub fn name(&self) -> &str {
         &self.name

crates/disks/src/loopback.rs

@@ -5,7 +5,7 @@
 use std::fmt;
 use std::path::{Path, PathBuf};
 
-use crate::{sysfs, DEVFS_DIR, SYSFS_DIR};
+use crate::{sysfs, DEVFS_DIR};
 
 /// Represents a partition on a disk device
 /// - Size in sectors
@@ -49,10 +49,10 @@ impl Partition {
     /// * `Some(Partition)` if partition exists and is valid
     /// * `None` if partition doesn't exist or is invalid
     pub fn from_sysfs_path(sysroot: &Path, name: &str) -> Option<Self> {
-        let node = sysroot.join(SYSFS_DIR).join(name);
-        let partition_no: u32 = sysfs::read(sysroot, &node, "partition")?;
-        let start = sysfs::read(sysroot, &node, "start")?;
-        let size = sysfs::read(sysroot, &node, "size")?;
+        let node = sysroot.join(name);
+        let partition_no: u32 = sysfs::read(&node, "partition")?;
+        let start = sysfs::read(&node, "start")?;
+        let size = sysfs::read(&node, "size")?;
         Some(Self {
             name: name.to_owned(),
             number: partition_no,

crates/disks/src/partition.rs

@@ -10,8 +10,7 @@ use std::{fs, path::Path, str::FromStr};
 ///
 /// # Arguments
 ///
-/// * `sysroot` - Base path of the sysfs mount point
-/// * `node` - Path to specific sysfs node relative to sysroot
+/// * `node` - Fully qualified path to specific sysfs node
 /// * `key` - Name of the sysfs attribute to read
 ///
 /// # Returns
@@ -22,10 +21,9 @@ use std::{fs, path::Path, str::FromStr};
 /// # Type Parameters
 ///
 /// * `T` - Target type that implements FromStr for parsing the raw value
-pub(crate) fn read<T>(sysroot: &Path, node: &Path, key: &str) -> Option<T>
+pub(crate) fn read<T>(node: &Path, key: &str) -> Option<T>
 where
     T: FromStr,
 {
-    let path = sysroot.join(node).join(key);
-    fs::read_to_string(&path).ok()?.trim().parse().ok()
+    fs::read_to_string(node.join(key)).ok()?.trim().parse().ok()
 }