Merge pull request #5097 from openanolis/dbg-console

runtime-rs: debug console support in runtime

src/runtime-rs/crates/hypervisor/src/dragonball/inner.rs

@@ -91,6 +91,7 @@ impl DragonballInner {
         kernel_params.append(&mut KernelParams::from_string(
             &self.config.boot_info.kernel_params,
         ));
+        info!(sl!(), "prepared kernel_params={:?}", kernel_params);
 
         // set boot source
         let kernel_path = self.config.boot_info.kernel.clone();

src/runtime-rs/crates/hypervisor/src/kernel_param.rs

@@ -7,6 +7,7 @@
 use anyhow::{anyhow, Result};
 
 use crate::{VM_ROOTFS_DRIVER_BLK, VM_ROOTFS_DRIVER_PMEM};
+use kata_types::config::LOG_VPORT_OPTION;
 
 // Port where the agent will send the logs. Logs are sent through the vsock in cases
 // where the hypervisor has no console.sock, i.e dragonball
@@ -28,6 +29,18 @@ impl Param {
             value: value.to_owned(),
         }
     }
+
+    pub fn to_string(&self) -> Result<String> {
+        if self.key.is_empty() && self.value.is_empty() {
+            Err(anyhow!("Empty key and value"))
+        } else if self.key.is_empty() {
+            Err(anyhow!("Empty key"))
+        } else if self.value.is_empty() {
+            Ok(self.key.to_string())
+        } else {
+            Ok(format!("{}{}{}", self.key, KERNEL_KV_DELIMITER, self.value))
+        }
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -48,7 +61,7 @@ impl KernelParams {
         ];
 
         if debug {
-            params.push(Param::new("agent.log_vport", VSOCK_LOGS_PORT));
+            params.push(Param::new(LOG_VPORT_OPTION, VSOCK_LOGS_PORT));
         }
 
         Self { params }
@@ -129,18 +142,7 @@ impl KernelParams {
         let mut parameters: Vec<String> = Vec::new();
 
         for param in &self.params {
-            if param.key.is_empty() && param.value.is_empty() {
-                return Err(anyhow!("Empty key and value"));
-            } else if param.key.is_empty() {
-                return Err(anyhow!("Empty key"));
-            } else if param.value.is_empty() {
-                parameters.push(param.key.to_string());
-            } else {
-                parameters.push(format!(
-                    "{}{}{}",
-                    param.key, KERNEL_KV_DELIMITER, param.value
-                ));
-            }
+            parameters.push(param.to_string()?);
         }
 
         Ok(parameters.join(KERNEL_PARAM_DELIMITER))
@@ -153,6 +155,20 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_params() {
+        let param1 = Param::new("", "");
+        let param2 = Param::new("", "foo");
+        let param3 = Param::new("foo", "");
+
+        assert!(param1.to_string().is_err());
+        assert!(param2.to_string().is_err());
+        assert_eq!(param3.to_string().unwrap(), String::from("foo"));
+
+        let param4 = Param::new("foo", "bar");
+        assert_eq!(param4.to_string().unwrap(), String::from("foo=bar"));
+    }
+
     #[test]
     fn test_kernel_params() -> Result<()> {
         let expect_params_string = "k1=v1 k2=v2 k3=v3".to_string();

src/runtime-rs/crates/runtimes/Cargo.toml

@@ -19,6 +19,7 @@ kata-types = { path = "../../../libs/kata-types" }
 logging = { path = "../../../libs/logging"}
 oci = { path = "../../../libs/oci" }
 persist = { path = "../persist" }
+hypervisor = { path = "../hypervisor" }
 # runtime handler
 linux_container = { path = "./linux_container", optional = true }
 virt_container = { path = "./virt_container", optional = true }

src/runtime-rs/crates/runtimes/src/manager.rs

@@ -14,6 +14,7 @@ use common::{
     types::{Request, Response},
     RuntimeHandler, RuntimeInstance, Sandbox,
 };
+use hypervisor::Param;
 use kata_types::{annotations::Annotation, config::TomlConfig};
 #[cfg(feature = "linux")]
 use linux_container::LinuxContainer;
@@ -335,6 +336,7 @@ fn load_config(spec: &oci::Spec, option: &Option<Vec<u8>>) -> Result<TomlConfig>
     let (mut toml_config, _) =
         TomlConfig::load_from_file(&config_path).context("load toml config")?;
     annotation.update_config_by_annotation(&mut toml_config)?;
+    update_agent_kernel_params(&mut toml_config)?;
 
     // validate configuration and return the error
     toml_config.validate()?;
@@ -358,3 +360,20 @@ fn load_config(spec: &oci::Spec, option: &Option<Vec<u8>>) -> Result<TomlConfig>
     info!(sl!(), "get config content {:?}", &toml_config);
     Ok(toml_config)
 }
+
+// this update the agent-specfic kernel parameters into hypervisor's bootinfo
+// the agent inside the VM will read from file cmdline to get the params and function
+fn update_agent_kernel_params(config: &mut TomlConfig) -> Result<()> {
+    let mut params = vec![];
+    if let Ok(kv) = config.get_agent_kernel_params() {
+        for (k, v) in kv.into_iter() {
+            if let Ok(s) = Param::new(k.as_str(), v.as_str()).to_string() {
+                params.push(s);
+            }
+        }
+        if let Some(h) = config.hypervisor.get_mut(&config.runtime.hypervisor_name) {
+            h.boot_info.add_kernel_params(params);
+        }
+    }
+    Ok(())
+}