install: Use Device::list_parents for parent traversal

Replace the loop over dev.parents.take() with the new
Device::list_parents() API. The inverse lsblk tree is walked to the
root, with multi-parent detection preserved.

Once the root device is found, refresh it via lsblk to populate its
actual children (partitions). Devices from the inverse tree only carry
parent links, not real children, so without this the bwrap container
would lack partition device bind mounts.

With no remaining consumers of the parents field, remove it from the
Device struct.

Assisted-by: Claude Code (Opus 4)
Signed-off-by: ckyrouac <ckyrouac@redhat.com>

Author: ckyrouac

crates/blockdev/src/blockdev.rs

@@ -44,10 +44,6 @@ pub struct Device {
     pub path: Option<String>,
     /// Partition table type (e.g., "gpt", "dos"). Only present on whole disk devices.
     pub pttype: Option<String>,
-
-    /// Parent devices. Deprecated: use [`Device::list_parents`] instead.
-    #[serde(skip)]
-    pub parents: Option<Vec<Device>>,
 }
 
 impl Device {

crates/lib/src/install.rs

@@ -2442,27 +2442,42 @@ pub(crate) async fn install_to_filesystem(
     // Find the real underlying backing device for the root.  This is currently just required
     // for GRUB (BIOS) and in the future zipl (I think).
     let device_info = {
-        let mut dev = bootc_blockdev::list_dev(Utf8Path::new(&inspect.source))?;
-        loop {
-            tracing::debug!("Finding parents for {}", dev.path());
-            let Some(parents) = dev.parents.take() else {
-                break;
-            };
-            let mut parents_iter = parents.into_iter();
-            let Some(parent) = parents_iter.next() else {
-                break;
-            };
-            if let Some(next) = parents_iter.next() {
-                anyhow::bail!(
-                    "Found multiple parent devices {} and {}; not currently supported",
-                    parent.path(),
-                    next.path()
-                );
+        let dev = bootc_blockdev::list_dev(Utf8Path::new(&inspect.source))?;
+        // Walk the inverse tree to the root device.
+        // In inverse lsblk output, "children" are actually parents.
+        match dev.list_parents()? {
+            None => {
+                tracing::debug!("Backing device: {}", dev.path());
+                dev
+            }
+            Some(parents) => {
+                let mut current = parents;
+                loop {
+                    if current.len() > 1 {
+                        anyhow::bail!(
+                            "Found multiple parent devices {} and {}; not currently supported",
+                            current[0].path(),
+                            current[1].path()
+                        );
+                    }
+                    let mut parent = current.into_iter().next().unwrap();
+                    // In inverse output, children = grandparents
+                    match parent.children.take() {
+                        Some(grandparents) if !grandparents.is_empty() => {
+                            current = grandparents;
+                        }
+                        _ => {
+                            tracing::debug!("Backing device: {}", parent.path());
+                            // Re-query the root device to populate its actual
+                            // children (partitions). The inverse tree only
+                            // carries parent links, not real children.
+                            parent.refresh()?;
+                            break parent;
+                        }
+                    }
+                }
             }
-            dev = parent;
         }
-        tracing::debug!("Backing device: {}", dev.path());
-        dev
     };
 
     let rootarg = format!("root={}", root_info.mount_spec);