adopt_update: pass RootContext as parameter

Author: HuijingHei

src/bios.rs

@@ -97,6 +97,7 @@ impl Bios {
     }
 
     // check bios_boot partition on gpt type disk
+    #[allow(dead_code)]
     fn get_bios_boot_partition(&self) -> Option<String> {
         match blockdev::get_single_device("/") {
             Ok(device) => {
@@ -147,24 +148,37 @@ impl Component for Bios {
         Ok(meta)
     }
 
-    fn query_adopt(&self) -> Result<Option<Adoptable>> {
+    fn query_adopt(&self, devices: &Option<Vec<String>>) -> Result<Option<Adoptable>> {
         #[cfg(target_arch = "x86_64")]
-        if crate::efi::is_efi_booted()? && self.get_bios_boot_partition().is_none() {
+        if crate::efi::is_efi_booted()? && devices.is_none() {
             log::debug!("Skip BIOS adopt");
             return Ok(None);
         }
         crate::component::query_adopt_state()
     }
 
-    fn adopt_update(&self, _: &openat::Dir, update: &ContentMetadata) -> Result<InstalledContent> {
-        let Some(meta) = self.query_adopt()? else {
+    fn adopt_update(
+        &self,
+        sysroot: &RootContext,
+        update: &ContentMetadata,
+    ) -> Result<InstalledContent> {
+        let bios_devices = blockdev::find_colocated_bios_boot(&sysroot.devices)?;
+        let Some(meta) = self.query_adopt(&bios_devices)? else {
             anyhow::bail!("Failed to find adoptable system")
         };
 
-        let target_root = "/";
-        let device = blockdev::get_single_device(&target_root)?;
-        self.run_grub_install(target_root, &device)?;
-        log::debug!("Install grub modules on {device}");
+        let mut parent_devices = sysroot.devices.iter();
+        let Some(parent) = parent_devices.next() else {
+            anyhow::bail!("Failed to find parent device");
+        };
+
+        if let Some(next) = parent_devices.next() {
+            anyhow::bail!(
+                "Found multiple parent devices {parent} and {next}; not currently supported"
+            );
+        }
+        self.run_grub_install(sysroot.path.as_str(), &parent)?;
+        log::debug!("Install grub modules on {parent}");
         Ok(InstalledContent {
             meta: update.clone(),
             filetree: None,

src/bootupd.rs

@@ -276,7 +276,7 @@ pub(crate) fn adopt_and_update(name: &str, rootcxt: &RootContext) -> Result<Cont
         SavedState::acquire_write_lock(sysroot).context("Failed to acquire write lock")?;
 
     let inst = component
-        .adopt_update(&state_guard.sysroot, &update)
+        .adopt_update(&rootcxt, &update)
         .context("Failed adopt and update")?;
     state.installed.insert(component.name().into(), inst);
 
@@ -327,8 +327,10 @@ pub(crate) fn status() -> Result<Status> {
 
     // Process the remaining components not installed
     log::trace!("Remaining known components: {}", known_components.len());
-    for (name, component) in known_components {
-        if let Some(adopt_ver) = component.query_adopt()? {
+    for (name, _) in known_components {
+        // Only run `query_adopt_state()` is enough
+        // When do adopt and update for each component, will check more
+        if let Some(adopt_ver) = crate::component::query_adopt_state()? {
             ret.adoptable.insert(name.to_string(), adopt_ver);
         } else {
             log::trace!("Not adoptable: {}", name);

src/component.rs

@@ -29,12 +29,12 @@ pub(crate) trait Component {
     /// In an operating system whose initially booted disk image is not
     /// using bootupd, detect whether it looks like the component exists
     /// and "synthesize" content metadata from it.
-    fn query_adopt(&self) -> Result<Option<Adoptable>>;
+    fn query_adopt(&self, devices: &Option<Vec<String>>) -> Result<Option<Adoptable>>;
 
     /// Given an adoptable system and an update, perform the update.
     fn adopt_update(
         &self,
-        sysroot: &openat::Dir,
+        sysroot: &RootContext,
         update: &ContentMetadata,
     ) -> Result<InstalledContent>;
 

src/efi.rs

@@ -264,9 +264,8 @@ impl Component for Efi {
         "EFI"
     }
 
-    fn query_adopt(&self) -> Result<Option<Adoptable>> {
-        let esp = self.open_esp_optional()?;
-        if esp.is_none() {
+    fn query_adopt(&self, devices: &Option<Vec<String>>) -> Result<Option<Adoptable>> {
+        if devices.is_none() {
             log::trace!("No ESP detected");
             return Ok(None);
         };
@@ -282,23 +281,41 @@ impl Component for Efi {
     /// Given an adoptable system and an update, perform the update.
     fn adopt_update(
         &self,
-        sysroot: &openat::Dir,
+        sysroot: &RootContext,
         updatemeta: &ContentMetadata,
     ) -> Result<InstalledContent> {
-        let Some(meta) = self.query_adopt()? else {
+        let esp_devices = blockdev::find_colocated_esps(&sysroot.devices)?;
+        let Some(meta) = self.query_adopt(&esp_devices)? else {
             anyhow::bail!("Failed to find adoptable system")
         };
 
-        let esp = self.open_esp()?;
-        validate_esp(&esp)?;
+        // Confirm that esp_devices is Some(value)
+        let esp_devices = esp_devices.unwrap();
+        let mut devices = esp_devices.iter();
+        let Some(esp) = devices.next() else {
+            anyhow::bail!("Failed to find esp device");
+        };
+
+        if let Some(next_esp) = devices.next() {
+            anyhow::bail!(
+                "Found multiple esp devices {esp} and {next_esp}; not currently supported"
+            );
+        }
+        let destpath = &self.ensure_mounted_esp(sysroot.path.as_ref(), Path::new(&esp))?;
+
+        let destdir = &openat::Dir::open(&destpath.join("EFI"))
+            .with_context(|| format!("opening EFI dir {}", destpath.display()))?;
+        validate_esp(&destdir)?;
         let updated = sysroot
+            .sysroot
             .sub_dir(&component_updatedirname(self))
             .context("opening update dir")?;
         let updatef = filetree::FileTree::new_from_dir(&updated).context("reading update dir")?;
         // For adoption, we should only touch files that we know about.
-        let diff = updatef.relative_diff_to(&esp)?;
+        let diff = updatef.relative_diff_to(&destdir)?;
         log::trace!("applying adoption diff: {}", &diff);
-        filetree::apply_diff(&updated, &esp, &diff, None).context("applying filesystem changes")?;
+        filetree::apply_diff(&updated, &destdir, &diff, None)
+            .context("applying filesystem changes")?;
         Ok(InstalledContent {
             meta: updatemeta.clone(),
             filetree: Some(updatef),