composefs/bls: Get cmdline from usr/lib/bootc/kargs.d

Parse toml files in usr/lib/bootc/kargs.d and append them to kernel
cmdline on install and upgrade/switch. Also, copy over current
deployment's cmdline args on upgrade/switch to another deployment

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/boot.rs

@@ -5,7 +5,7 @@ use std::path::Path;
 
 use anyhow::{anyhow, Context, Result};
 use bootc_blockdev::find_parent_devices;
-use bootc_kernel_cmdline::utf8::Cmdline;
+use bootc_kernel_cmdline::utf8::{Cmdline, Parameter};
 use bootc_mount::inspect_filesystem_of_dir;
 use bootc_mount::tempmount::TempMount;
 use camino::{Utf8Path, Utf8PathBuf};
@@ -33,6 +33,7 @@ use rustix::{mount::MountFlags, path::Arg};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::bootc_kargs::kargs_from_composefs_filesystem;
 use crate::composefs_consts::{TYPE1_ENT_PATH, TYPE1_ENT_PATH_STAGED};
 use crate::parsers::bls_config::{BLSConfig, BLSConfigType};
 use crate::parsers::grub_menuconfig::MenuEntry;
@@ -51,7 +52,6 @@ use crate::{
         BOOT_LOADER_ENTRIES, COMPOSEFS_CMDLINE, ORIGIN_KEY_BOOT, ORIGIN_KEY_BOOT_DIGEST,
         STAGED_BOOT_LOADER_ENTRIES, STATE_DIR_ABS, USER_CFG, USER_CFG_STAGED,
     },
-    install::RW_KARG,
     spec::{Bootloader, Host},
 };
 
@@ -384,7 +384,7 @@ pub(crate) fn setup_composefs_bls_boot(
 ) -> Result<String> {
     let id_hex = id.to_hex();
 
-    let (root_path, esp_device, cmdline_refs, fs, bootloader) = match setup_type {
+    let (root_path, esp_device, mut cmdline_refs, fs, bootloader) = match setup_type {
         BootSetupType::Setup((root_setup, state, postfetch, fs)) => {
             // root_setup.kargs has [root=UUID=<UUID>, "rw"]
             let mut cmdline_options = Cmdline::new();
@@ -415,16 +415,53 @@ pub(crate) fn setup_composefs_bls_boot(
             let sysroot_parent = get_sysroot_parent_dev(&storage.physical_root)?;
             let bootloader = host.require_composefs_booted()?.bootloader.clone();
 
+            let current_cfg = match bootloader {
+                Bootloader::Grub => {
+                    let boot_dir = storage
+                        .physical_root
+                        .open_dir("boot")
+                        .context("Opening boot")?;
+
+                    get_booted_bls(&boot_dir)?
+                }
+
+                Bootloader::Systemd => {
+                    let esp = get_esp_partition(&sysroot_parent)?.0;
+                    let esp_mnt = mount_esp(&esp)?;
+
+                    get_booted_bls(&esp_mnt.fd)?
+                }
+            };
+
+            let mut cmdline = match current_cfg.cfg_type {
+                BLSConfigType::NonEFI { options, .. } => {
+                    let options = options
+                        .ok_or_else(|| anyhow::anyhow!("No 'options' found in BLS Config"))?;
+
+                    Cmdline::from(options)
+                }
+
+                _ => anyhow::bail!("Found NonEFI config"),
+            };
+
+            // Copy all cmdline args, replacing only `composefs=`
+            let param = format!("{COMPOSEFS_CMDLINE}={id_hex}");
+            let param =
+                Parameter::parse(&param).context("Failed to create 'composefs=' parameter")?;
+            cmdline.add_or_modify(&param);
+
             (
                 Utf8PathBuf::from("/sysroot"),
                 get_esp_partition(&sysroot_parent)?.0,
-                Cmdline::from(format!("{RW_KARG} {COMPOSEFS_CMDLINE}={id_hex}")),
+                cmdline,
                 fs,
                 bootloader,
             )
         }
     };
 
+    kargs_from_composefs_filesystem(fs, &repo, &mut cmdline_refs)?;
+
     let is_upgrade = matches!(setup_type, BootSetupType::Upgrade(..));
 
     let (entry_paths, _tmpdir_guard) = match bootloader {

crates/lib/src/bootc_kargs.rs

@@ -6,16 +6,20 @@ use cap_std_ext::cap_std::fs::Dir;
 use cap_std_ext::cap_std::fs_utf8::Dir as DirUtf8;
 use cap_std_ext::dirext::CapStdExtDirExt;
 use cap_std_ext::dirext::CapStdExtDirExtUtf8;
+use composefs::fs::read_file;
+use composefs::generic_tree::Inode;
 use ostree::gio;
 use ostree_ext::ostree;
 use ostree_ext::ostree::Deployment;
 use ostree_ext::prelude::Cast;
 use ostree_ext::prelude::FileEnumeratorExt;
 use ostree_ext::prelude::FileExt;
 use serde::Deserialize;
+use std::ffi::OsStr;
 
 use crate::deploy::ImageState;
 use crate::store::Storage;
+use crate::store::{ComposefsFilesystem, ComposefsRepository};
 
 /// The relative path to the kernel arguments which may be embedded in an image.
 const KARGS_PATH: &str = "usr/lib/bootc/kargs.d";
@@ -45,6 +49,48 @@ impl Config {
     }
 }
 
+/// Looks for files in usr/lib/bootc/kargs.d and parses cmdline agruments
+pub(crate) fn kargs_from_composefs_filesystem(
+    fs: &ComposefsFilesystem,
+    repo: &ComposefsRepository,
+    cmdline: &mut Cmdline,
+) -> Result<()> {
+    let kargs_d = fs
+        .root
+        .get_directory_opt(OsStr::new(KARGS_PATH))
+        .with_context(|| format!("Getting {KARGS_PATH}"))?;
+
+    let Some(kargs_d) = kargs_d else {
+        return Ok(());
+    };
+
+    for (fname, inode) in kargs_d.sorted_entries() {
+        let Inode::Leaf(..) = inode else { continue };
+
+        let fname_str = fname
+            .to_str()
+            .ok_or_else(|| anyhow::anyhow!("Failed to get filename as string"))?;
+
+        if !Config::filename_matches(fname_str) {
+            continue;
+        }
+
+        let file = kargs_d
+            .get_file(fname)
+            .with_context(|| format!("Getting file {fname_str}"))?;
+
+        let contents = read_file(&file, &repo)?;
+        let contents = std::str::from_utf8(&contents)
+            .with_context(|| format!("File {fname_str} is not a valid UTF-8"))?;
+
+        if let Some(kargs) = parse_kargs_toml(contents, std::env::consts::ARCH)? {
+            cmdline.extend(&kargs);
+        };
+    }
+
+    Ok(())
+}
+
 /// Load and parse all bootc kargs.d files in the specified root, returning
 /// a combined list.
 pub(crate) fn get_kargs_in_root(d: &Dir, sys_arch: &str) -> Result<CmdlineOwned> {