composefs: Soft Reboot after update/switch if specified

Signed-off-by: Pragyan Poudyal <pragyanpoudyal41999@gmail.com>

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/boot.rs

@@ -1268,7 +1268,7 @@ pub(crate) async fn setup_composefs_boot(
 
     write_composefs_state(
         &root_setup.physical_root_path,
-        id,
+        &id,
         &crate::spec::ImageReference::from(state.target_imgref.clone()),
         false,
         boot_type,

crates/lib/src/bootc_composefs/soft_reboot.rs

@@ -10,20 +10,30 @@ use bootc_initramfs_setup::setup_root;
 use bootc_kernel_cmdline::utf8::Cmdline;
 use bootc_mount::{bind_mount_from_pidns, PID1};
 use camino::Utf8Path;
+use fn_error_context::context;
+use ostree_ext::systemd_has_soft_reboot;
 use std::{fs::create_dir_all, os::unix::process::CommandExt, path::PathBuf, process::Command};
 
 const NEXTROOT: &str = "/run/nextroot";
 
-pub(crate) async fn soft_reboot_to_deployment(
+/// Checks if the provided deployment is soft reboot capable, and soft reboots the system if
+/// argument `reboot` is true
+#[context("Soft rebooting")]
+pub(crate) async fn prepare_soft_reboot_composefs(
     storage: &Storage,
     booted_cfs: &BootedComposefs,
     deployment_id: &String,
     reboot: bool,
 ) -> Result<()> {
+    if !systemd_has_soft_reboot() {
+        anyhow::bail!("System does not support soft reboots")
+    }
+
     if *deployment_id == *booted_cfs.cmdline.digest {
         anyhow::bail!("Cannot soft-reboot to currently booted deployment");
     }
 
+    // We definitely need to re-query the state as some deployment might've been staged
     let host = composefs_deployment_status_from(storage, booted_cfs.cmdline).await?;
 
     let all_deployments = host.all_composefs_deployments()?;

crates/lib/src/bootc_composefs/state.rs

@@ -180,7 +180,7 @@ pub(crate) fn update_target_imgref_in_origin(
 #[context("Writing composefs state")]
 pub(crate) async fn write_composefs_state(
     root_path: &Utf8PathBuf,
-    deployment_id: Sha512HashValue,
+    deployment_id: &Sha512HashValue,
     target_imgref: &ImageReference,
     staged: bool,
     boot_type: BootType,

crates/lib/src/bootc_composefs/switch.rs

@@ -5,7 +5,7 @@ use crate::{
     bootc_composefs::{
         state::update_target_imgref_in_origin,
         status::get_composefs_status,
-        update::{do_upgrade, is_image_pulled, validate_update, UpdateAction},
+        update::{do_upgrade, is_image_pulled, validate_update, DoUpgradeOpts, UpdateAction},
     },
     cli::{imgref_for_switch, SwitchOpts},
     store::{BootedComposefs, Storage},
@@ -42,6 +42,11 @@ pub(crate) async fn switch_composefs(
     let repo = &*booted_cfs.repo;
     let (image, img_config) = is_image_pulled(repo, &target_imgref).await?;
 
+    let do_upgrade_opts = DoUpgradeOpts {
+        soft_reboot: opts.soft_reboot,
+        apply: opts.apply,
+    };
+
     if let Some(cfg_verity) = image {
         let action = validate_update(
             storage,
@@ -59,7 +64,15 @@ pub(crate) async fn switch_composefs(
             }
 
             UpdateAction::Proceed => {
-                return do_upgrade(storage, &host, &target_imgref, &img_config).await;
+                return do_upgrade(
+                    storage,
+                    booted_cfs,
+                    &host,
+                    &target_imgref,
+                    &img_config,
+                    &do_upgrade_opts,
+                )
+                .await;
             }
 
             UpdateAction::UpdateOrigin => {
@@ -71,7 +84,15 @@ pub(crate) async fn switch_composefs(
         }
     }
 
-    do_upgrade(storage, &host, &target_imgref, &img_config).await?;
+    do_upgrade(
+        storage,
+        booted_cfs,
+        &host,
+        &target_imgref,
+        &img_config,
+        &do_upgrade_opts,
+    )
+    .await?;
 
     Ok(())
 }

crates/lib/src/bootc_composefs/update.rs

@@ -15,13 +15,14 @@ use crate::{
         boot::{setup_composefs_bls_boot, setup_composefs_uki_boot, BootSetupType, BootType},
         repo::{get_imgref, pull_composefs_repo},
         service::start_finalize_stated_svc,
+        soft_reboot::prepare_soft_reboot_composefs,
         state::write_composefs_state,
         status::{
             get_bootloader, get_composefs_status, get_container_manifest_and_config, get_imginfo,
             ImgConfigManifest,
         },
     },
-    cli::UpgradeOpts,
+    cli::{SoftRebootMode, UpgradeOpts},
     composefs_consts::{STATE_DIR_RELATIVE, TYPE1_ENT_PATH_STAGED, USER_CFG_STAGED},
     spec::{Bootloader, Host, ImageReference},
     store::{BootedComposefs, ComposefsRepository, Storage},
@@ -208,13 +209,21 @@ pub(crate) fn validate_update(
     Ok(UpdateAction::Proceed)
 }
 
+/// This is just an intersection of SwitchOpts and UpgradeOpts
+pub(crate) struct DoUpgradeOpts {
+    pub(crate) apply: bool,
+    pub(crate) soft_reboot: Option<SoftRebootMode>,
+}
+
 /// Performs the Update or Switch operation
 #[context("Performing Upgrade Operation")]
 pub(crate) async fn do_upgrade(
     storage: &Storage,
+    booted_cfs: &BootedComposefs,
     host: &Host,
     imgref: &ImageReference,
     img_manifest_config: &ImgConfigManifest,
+    opts: &DoUpgradeOpts,
 ) -> Result<()> {
     start_finalize_stated_svc()?;
 
@@ -254,7 +263,7 @@ pub(crate) async fn do_upgrade(
 
     write_composefs_state(
         &Utf8PathBuf::from("/sysroot"),
-        id,
+        &id,
         imgref,
         true,
         boot_type,
@@ -263,6 +272,14 @@ pub(crate) async fn do_upgrade(
     )
     .await?;
 
+    if opts.apply {
+        return crate::reboot::reboot();
+    }
+
+    if opts.soft_reboot.is_some() {
+        prepare_soft_reboot_composefs(storage, booted_cfs, &id.to_hex(), true).await?;
+    }
+
     Ok(())
 }
 
@@ -299,6 +316,11 @@ pub(crate) async fn upgrade_composefs(
     // Or if we have another staged deployment with a different image
     let staged_image = host.status.staged.as_ref().and_then(|i| i.image.as_ref());
 
+    let do_upgrade_opts = DoUpgradeOpts {
+        soft_reboot: opts.soft_reboot,
+        apply: opts.apply,
+    };
+
     if let Some(staged_image) = staged_image {
         // We have a staged image and it has the same digest as the currently booted image's latest
         // digest
@@ -337,7 +359,15 @@ pub(crate) async fn upgrade_composefs(
                 }
 
                 UpdateAction::Proceed => {
-                    return do_upgrade(storage, &host, booted_imgref, &img_config).await;
+                    return do_upgrade(
+                        storage,
+                        composefs,
+                        &host,
+                        booted_imgref,
+                        &img_config,
+                        &do_upgrade_opts,
+                    )
+                    .await;
                 }
 
                 UpdateAction::UpdateOrigin => {
@@ -365,7 +395,15 @@ pub(crate) async fn upgrade_composefs(
             }
 
             UpdateAction::Proceed => {
-                return do_upgrade(storage, &host, booted_imgref, &img_config).await;
+                return do_upgrade(
+                    storage,
+                    composefs,
+                    &host,
+                    booted_imgref,
+                    &img_config,
+                    &do_upgrade_opts,
+                )
+                .await;
             }
 
             UpdateAction::UpdateOrigin => {
@@ -382,11 +420,15 @@ pub(crate) async fn upgrade_composefs(
         return Ok(());
     }
 
-    do_upgrade(storage, &host, booted_imgref, &img_config).await?;
-
-    if opts.apply {
-        return crate::reboot::reboot();
-    }
+    do_upgrade(
+        storage,
+        composefs,
+        &host,
+        booted_imgref,
+        &img_config,
+        &do_upgrade_opts,
+    )
+    .await?;
 
     Ok(())
 }

crates/lib/src/cli.rs

@@ -35,7 +35,7 @@ use serde::{Deserialize, Serialize};
 use tempfile::tempdir_in;
 
 use crate::bootc_composefs::delete::delete_composefs_deployment;
-use crate::bootc_composefs::soft_reboot::soft_reboot_to_deployment;
+use crate::bootc_composefs::soft_reboot::prepare_soft_reboot_composefs;
 use crate::bootc_composefs::{
     finalize::{composefs_backend_finalize, get_etc_diff},
     rollback::composefs_rollback,
@@ -1779,7 +1779,8 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                         anyhow::bail!("soft-reboot only implemented for composefs")
                     }
                     BootedStorageKind::Composefs(booted_cfs) => {
-                        soft_reboot_to_deployment(&storage, &booted_cfs, &deployment, reboot).await
+                        prepare_soft_reboot_composefs(&storage, &booted_cfs, &deployment, reboot)
+                            .await
                     }
                 }
             }