Add support for minor nodes, extend deviceslots example

Author: smklein

Cargo.toml

@@ -7,3 +7,6 @@ edition = "2021"
 anyhow = "1.0.62"
 libc = "0.2.132"
 num_enum = "0.5.7"
+
+[dev-dependencies]
+clap = { version = "4.1.1", features = [ "derive" ] }

examples/deviceslots.rs

@@ -1,6 +1,8 @@
-use anyhow::Result;
+use anyhow::{anyhow, Result};
+use clap::{Parser, ValueEnum};
 use illumos_devinfo::*;
 use std::collections::BTreeMap;
+use std::path::PathBuf;
 
 fn slot_to_device(slot: i64) -> Option<&'static str> {
     match slot {
@@ -22,7 +24,42 @@ fn slot_to_device(slot: i64) -> Option<&'static str> {
     }
 }
 
+fn get_whole_disk_dev_link(node: &Node<'_>) -> Result<PathBuf> {
+    // Each of the letter-indexed references into block device
+    // slices are represented as minor nodes.
+    let mut wm = node.minors();
+    while let Some(m) = wm.next().transpose()? {
+        // Find the minor of the "whole disk"
+        if m.name() == "wd" {
+            let links = DevLinks::new(false)?;
+            for l in links.links_for_path(m.devfs_path()?)? {
+                return Ok(l.path().to_path_buf());
+            }
+        }
+    }
+    Err(anyhow!("No whole disk minor found"))
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
+enum PathFlavor {
+    /// Emit the path within "/devices"
+    Devfs,
+    /// Emit the path within "/dev"
+    Dev,
+}
+
+/// Progam to identify disks, their types, and their paths.
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// The type of path to emit
+    #[arg(short, long, value_enum, default_value_t = PathFlavor::Devfs)]
+    flavor: PathFlavor,
+}
+
 fn main() -> Result<()> {
+    let args = Args::parse();
+
     let mut device_info = DevInfo::new()?;
     let mut node_walker = device_info.walk_node();
 
@@ -31,8 +68,9 @@ fn main() -> Result<()> {
     while let Some(mut node) = node_walker.next().transpose()? {
         if let Some(driver_name) = node.driver_name() {
             if driver_name == "blkdev" {
-                let devfs_path = node.devfs_path()?;
-                while let Some(parent) = node.parent() {
+                let dev_path = get_whole_disk_dev_link(&node)?;
+                let devfs_path = PathBuf::from(format!("/devices{}", node.devfs_path()?));
+                while let Ok(Some(parent)) = node.parent() {
                     node = parent;
                     if let Some(Ok(slot_prop)) = node.props().into_iter().find(|prop| {
                         if let Ok(prop) = prop {
@@ -44,16 +82,23 @@ fn main() -> Result<()> {
                         let slot = slot_prop.as_i64().expect("Expected i64");
                         let device = slot_to_device(slot).unwrap_or("Not found");
 
-                        device_descriptions
-                            .insert(slot, format!("{slot:>4}\t{device:>6}\t{devfs_path}"));
+                        let path = match args.flavor {
+                            PathFlavor::Devfs => devfs_path,
+                            PathFlavor::Dev => dev_path,
+                        };
+
+                        device_descriptions.insert(
+                            slot,
+                            format!("{slot:>4}\t{device:>6}\t{path}", path = path.display()),
+                        );
                         break;
                     }
                 }
             }
         }
     }
 
-    println!("Slot\tDevice\tDevfs Path");
+    println!("Slot\tDevice\tPath");
     for device in device_descriptions.values() {
         println!("{device}");
     }

examples/disks.rs

@@ -0,0 +1,37 @@
+use anyhow::Result;
+use illumos_devinfo::*;
+
+fn main() -> Result<()> {
+    let mut di = DevInfo::new()?;
+
+    let mut w = di.walk_node();
+    while let Some(n) = w.next().transpose()? {
+        let mut wm = n.minors();
+        while let Some(m) = wm.next().transpose()? {
+            /*
+             * Disks will either have the DDI_NT_BLOCK node type, or one of the
+             * more specific DDI_NT_BLOCK* subtypes (with a suffix after the
+             * colon):
+             */
+            if m.node_type() != "ddi_block" && !m.node_type().starts_with("ddi_block:") {
+                continue;
+            }
+
+            /*
+             * Just look for raw (not block) disk devices.
+             */
+            if m.spec_type() != SpecType::Char {
+                continue;
+            }
+
+            println!("{}: {}", m.node_type(), m.devfs_path()?);
+
+            let links = DevLinks::new(false)?;
+            for l in links.links_for_path(m.devfs_path()?)? {
+                println!("    {:?}", l.path());
+            }
+        }
+    }
+
+    Ok(())
+}