Add basic partition enumeration

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

Author: ikeycode

crates/disks/src/lib.rs

@@ -7,7 +7,10 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use partition::Partition;
+
 pub mod nvme;
+pub mod partition;
 pub mod scsi;
 mod sysfs;
 
@@ -19,6 +22,7 @@ const DEVFS_DIR: &str = "/dev";
 pub enum BlockDevice {
     /// A physical disk device
     Disk(Box<Disk>),
+    Unknown,
 }
 
 /// Represents the type of disk device.
@@ -46,23 +50,26 @@ pub struct BasicDisk {
     pub model: Option<String>,
     /// Optional disk vendor name
     pub vendor: Option<String>,
+    /// Partitions
+    pub partitions: Vec<Partition>,
 }
 
 impl Disk {
     /// Returns the name of the disk device.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// // Returns strings like "sda" or "nvme0n1"
-    /// let name = disk.name();
-    /// ```
     pub fn name(&self) -> &str {
         match self {
             Disk::Scsi(disk) => disk.name(),
             Disk::Nvme(disk) => disk.name(),
         }
     }
+
+    /// Returns the partitions on the disk.
+    pub fn partitions(&self) -> &[Partition] {
+        match self {
+            Disk::Scsi(disk) => disk.partitions(),
+            Disk::Nvme(disk) => disk.partitions(),
+        }
+    }
 }
 
 /// Trait for initializing different types of disk devices from sysfs.
@@ -83,12 +90,25 @@ pub(crate) trait DiskInit: Sized {
 impl DiskInit for BasicDisk {
     fn from_sysfs_path(sysroot: &Path, name: &str) -> Option<Self> {
         let node = sysroot.join(name);
+
+        // Read the partitions of the disk if any
+        let mut partitions: Vec<_> = fs::read_dir(&node)
+            .ok()?
+            .filter_map(Result::ok)
+            .filter_map(|e| {
+                let name = e.file_name().to_string_lossy().to_string();
+                Partition::from_sysfs_path(sysroot, &name)
+            })
+            .collect();
+        partitions.sort_by_key(|p| p.number);
+
         Some(Self {
             name: name.to_owned(),
             sectors: sysfs::sysfs_read(sysroot, &node, "size").unwrap_or(0),
             device: PathBuf::from(DEVFS_DIR).join(name),
             model: sysfs::sysfs_read(sysroot, &node, "device/model"),
             vendor: sysfs::sysfs_read(sysroot, &node, "device/vendor"),
+            partitions,
             node,
         })
     }
@@ -100,15 +120,6 @@ impl BlockDevice {
     /// # Returns
     ///
     /// A vector of discovered block devices or an IO error if the discovery fails.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let devices = BlockDevice::discover()?;
-    /// for device in devices {
-    ///     println!("Found device: {:?}", device);
-    /// }
-    /// ```
     pub fn discover() -> io::Result<Vec<BlockDevice>> {
         Self::discover_in_sysroot("/")
     }
@@ -157,7 +168,13 @@ mod tests {
     #[test]
     fn test_discover() {
         let devices = BlockDevice::discover().unwrap();
-        assert!(!devices.is_empty());
-        eprintln!("devices: {devices:?}");
+        for device in &devices {
+            if let BlockDevice::Disk(disk) = device {
+                println!("{}:", disk.name());
+                for partition in disk.partitions() {
+                    println!("├─{}", partition.name);
+                }
+            }
+        }
     }
 }

crates/disks/src/nvme.rs

@@ -7,9 +7,9 @@
 //! This module provides functionality to enumerate and handle NVMe (Non-Volatile Memory Express)
 //! storage devices by parsing sysfs paths and device names.
 
-use std::{path::Path, sync::OnceLock};
+use crate::{partition::Partition, BasicDisk, DiskInit};
 use regex::Regex;
-use crate::{BasicDisk, DiskInit};
+use std::{path::Path, sync::OnceLock};
 
 /// Regex pattern to match valid NVMe device names (e.g. nvme0n1)
 static NVME_PATTERN: OnceLock<Regex> = OnceLock::new();
@@ -52,4 +52,9 @@ impl Disk {
     pub fn name(&self) -> &str {
         &self.disk.name
     }
+
+    /// Returns the partitions on the disk
+    pub fn partitions(&self) -> &[Partition] {
+        &self.disk.partitions
+    }
 }

crates/disks/src/partition.rs

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::path::{Path, PathBuf};
+
+use crate::{sysfs::sysfs_read, DEVFS_DIR, SYSFS_DIR};
+
+/// Represents a partition on a disk device
+/// - Size in sectors
+#[derive(Debug)]
+pub struct Partition {
+    /// Name of the partition
+    pub name: String,
+    /// Partition number on the disk
+    pub number: u32,
+    /// Starting sector of the partition
+    pub start: u64,
+    /// Ending sector of the partition
+    pub end: u64,
+    /// Size of partition in sectors
+    pub size: u64,
+    /// Path to the partition node in sysfs
+    pub node: PathBuf,
+    /// Path to the partition device in /dev
+    pub device: PathBuf,
+}
+
+impl Partition {
+    /// Creates a new Partition instance from a sysfs path and partition name.
+    ///
+    /// # Arguments
+    /// * `sysroot` - Base path to sysfs
+    /// * `name` - Name of the partition
+    ///
+    /// # Returns
+    /// * `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")?;
+        Some(Self {
+            name: name.to_owned(),
+            number: partition_no,
+            start,
+            size,
+            end: start + size,
+            node,
+            device: sysroot.join(DEVFS_DIR).join(name),
+        })
+    }
+}

crates/disks/src/scsi.rs

@@ -10,7 +10,7 @@
 
 use std::path::Path;
 
-use crate::{BasicDisk, DiskInit};
+use crate::{partition::Partition, BasicDisk, DiskInit};
 
 /// Represents a SCSI disk device.
 ///
@@ -53,4 +53,9 @@ impl Disk {
     pub fn name(&self) -> &str {
         &self.disk.name
     }
+
+    /// Returns the partitions on the disk.
+    pub fn partitions(&self) -> &[Partition] {
+        &self.disk.partitions
+    }
 }