fix bad ffi

Author: smklein

examples/deviceslots.rs

@@ -24,20 +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.
+fn get_dev_path(node: &Node<'_>) -> Result<Option<PathBuf>> {
     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());
+        if m.name() != "wd" {
+            continue;
+        }
+        let links = {
+            match DevLinks::new(true) {
+                Ok(links) => links,
+                Err(_) => DevLinks::new(false)?,
             }
+        };
+        let devfs_path = m.devfs_path()?;
+
+        let paths = links
+            .links_for_path(&devfs_path)?
+            .into_iter()
+            .filter(|l| {
+                l.linktype() == DevLinkType::Primary
+                    && l.path()
+                        .file_name()
+                        .map(|f| f.to_string_lossy().ends_with("d0"))
+                        .unwrap_or(false)
+            })
+            .collect::<Vec<_>>();
+
+        if paths.is_empty() {
+            return Err(anyhow!("no links for {}", devfs_path));
         }
+
+        if paths.len() != 1 {
+            return Err(anyhow!("got weird paths {:?} for {}", paths, devfs_path));
+        }
+        return Ok(Some(paths[0].path().to_path_buf()));
     }
-    Err(anyhow!("No whole disk minor found"))
+    Ok(None)
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
@@ -60,15 +82,20 @@ struct Args {
 fn main() -> Result<()> {
     let args = Args::parse();
 
-    let mut device_info = DevInfo::new()?;
-    let mut node_walker = device_info.walk_node();
+    let mut device_info = {
+        match DevInfo::new_force_load() {
+            Ok(di) => di,
+            Err(_) => DevInfo::new()?,
+        }
+    };
+    let mut node_walker = device_info.walk_driver("blkdev");
 
     let mut device_descriptions = BTreeMap::new();
 
     while let Some(mut node) = node_walker.next().transpose()? {
         if let Some(driver_name) = node.driver_name() {
             if driver_name == "blkdev" {
-                let dev_path = get_whole_disk_dev_link(&node)?;
+                let dev_path = get_dev_path(&node)?;
                 let devfs_path = PathBuf::from(format!("/devices{}", node.devfs_path()?));
                 while let Ok(Some(parent)) = node.parent() {
                     node = parent;
@@ -83,14 +110,14 @@ fn main() -> Result<()> {
                         let device = slot_to_device(slot).unwrap_or("Not found");
 
                         let path = match args.flavor {
-                            PathFlavor::Devfs => devfs_path,
-                            PathFlavor::Dev => dev_path,
+                            PathFlavor::Devfs => devfs_path.to_string_lossy(),
+                            PathFlavor::Dev => dev_path
+                                .map(|p| String::from(p.to_string_lossy()))
+                                .unwrap_or(String::from("none"))
+                                .into(),
                         };
 
-                        device_descriptions.insert(
-                            slot,
-                            format!("{slot:>4}\t{device:>6}\t{path}", path = path.display()),
-                        );
+                        device_descriptions.insert(slot, format!("{slot:>4}\t{device:>6}\t{path}"));
                         break;
                     }
                 }

src/lib.rs

@@ -111,7 +111,7 @@ extern "C" {
     fn di_minor_spectype(minor: *mut DiMinor) -> c_int;
 
     fn di_devlink_init(name: *const c_char, flags: c_uint) -> *mut DiDevlinkHandle;
-    fn di_devlink_fini(hdlp: *mut DiDevlinkHandle);
+    fn di_devlink_fini(hdlp: &*mut DiDevlinkHandle) -> c_int;
 
     fn di_devlink_walk(
         hdl: *mut DiDevlinkHandle,
@@ -702,7 +702,7 @@ extern "C" fn devlink_accumulate(link: *const DiDevlink, arg: *mut c_void) -> c_
 
 impl DevLinks {
     fn new_common(make_link: bool) -> Result<DevLinks> {
-        let mut flags = 0;
+        let mut flags: c_uint = 0;
         if make_link {
             flags |= DI_MAKE_LINK;
         }
@@ -752,6 +752,6 @@ impl DevLinks {
 
 impl Drop for DevLinks {
     fn drop(&mut self) {
-        unsafe { di_devlink_fini(self.handle) };
+        unsafe { di_devlink_fini(&self.handle) };
     }
 }