Revert "always use krun_config.json instead of krun_set_exec"

This reverts commit 026efc8.

Author: nohajc

anylinuxfs/src/diskutil.rs

@@ -809,11 +809,11 @@ fn get_lsblk_info(
         }
     );
     // println!("lsblk script: {}", &script);
-    let lsblk_args = [
-        "/bin/busybox".into(),
-        "sh".into(),
-        "-c".into(),
-        script.into(),
+    let lsblk_args = vec![
+        c"/bin/busybox".to_owned(),
+        c"sh".to_owned(),
+        c"-c".to_owned(),
+        CString::new(script.as_str()).unwrap(),
     ];
     let prompt_fn = enc_partitions.map(|partitions| {
         let mut passphrase_prompts = Vec::new();
@@ -841,7 +841,7 @@ fn get_lsblk_info(
         dev_info,
         false,
         VMOpts::new().read_only_disks(true),
-        &lsblk_args,
+        lsblk_args,
         prompt_fn,
     )
     .context("Failed to run command in microVM")?;

anylinuxfs/src/main.rs

@@ -44,6 +44,7 @@ use crate::settings::{
     Config, CustomActionEnvironment, ImageSource, KernelConfig, KernelPage, KrunLogLevel,
     MountConfig, PassphrasePromptConfig, Preferences,
 };
+use crate::utils::{ToCStringVec, ToPtrVec};
 use crate::vm_image::IsoAdd;
 
 mod api;
@@ -697,11 +698,10 @@ impl Default for VMOpts {
 
 static KRUN_LOG_LEVEL_INIT: Once = Once::new();
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 struct VMContext {
     id: u32,
     os: OSType,
-    root_path: Option<PathBuf>,
 }
 
 fn setup_vm(
@@ -830,20 +830,11 @@ fn setup_vm(
     }
     .context("Failed to set kernel")?;
 
-    let root_path = match os {
-        OSType::Linux => Some(config.root_path.clone()),
-        OSType::FreeBSD => None, // no virtiofs => no root path
-    };
-
-    Ok(VMContext {
-        id: ctx_id,
-        os,
-        root_path,
-    })
+    Ok(VMContext { id: ctx_id, os })
 }
 
 fn start_vmproxy(
-    ctx: &VMContext,
+    ctx: VMContext,
     config: &MountConfig,
     service_status: &ServiceStatus,
     env: &[BString],
@@ -946,27 +937,26 @@ struct KrunConfig<'a, 'b> {
     process: KrunConfigProcess<'a, 'b>,
 }
 
-fn set_vm_cmdline(ctx: &VMContext, args: &[BString], env: &[BString]) -> anyhow::Result<()> {
+fn set_vm_cmdline(ctx: VMContext, args: &[BString], env: &[BString]) -> anyhow::Result<()> {
+    let cargs = args.to_cstring_vec();
+    let cenv = env.to_cstring_vec();
+
     let krun_config_tmp_dir;
     let mut deferred = Deferred::new();
 
-    let krun_config = serde_json::to_string(&KrunConfig {
-        process: KrunConfigProcess { args, env },
-    })
-    .context("Failed to serialize krun config")?;
-
     match ctx.os {
         OSType::Linux => {
-            let krun_config_file_name = ".krun_config.json";
-            let krun_config_file = ctx.root_path.as_ref().unwrap().join(krun_config_file_name);
-            fs::write(&krun_config_file, krun_config.as_bytes()).with_context(|| {
-                format!(
-                    "Failed to write krun config file {}",
-                    krun_config_file.display()
-                )
-            })?;
+            let argv = cargs.to_ptr_vec();
+            let envp = cenv.to_ptr_vec();
+            unsafe { bindings::krun_set_exec(ctx.id, argv[0], argv[1..].as_ptr(), envp.as_ptr()) }
+                .context("Failed to set exec")?;
         }
         OSType::FreeBSD => {
+            let krun_config = serde_json::to_string(&KrunConfig {
+                process: KrunConfigProcess { args, env },
+            })
+            .context("Failed to serialize krun config")?;
+
             krun_config_tmp_dir = PathBuf::from("/tmp").join(format!("alfs-{}", rand_string(8)));
             fs::create_dir_all(&krun_config_tmp_dir)
                 .context("Failed to create krun config temp directory")?;
@@ -1014,7 +1004,7 @@ fn set_vm_cmdline(ctx: &VMContext, args: &[BString], env: &[BString]) -> anyhow:
     Ok(())
 }
 
-fn start_vm_forked(ctx: &VMContext, cmdline: &[BString], env: &[BString]) -> anyhow::Result<i32> {
+fn start_vm_forked(ctx: VMContext, cmdline: &[BString], env: &[BString]) -> anyhow::Result<i32> {
     let pid = unsafe { libc::fork() };
     if pid < 0 {
         return Err(io::Error::last_os_error()).context("Failed to fork process");
@@ -1032,7 +1022,7 @@ fn start_vm_forked(ctx: &VMContext, cmdline: &[BString], env: &[BString]) -> any
     }
 }
 
-fn start_vm(ctx: &VMContext, cmdline: &[BString], env: &[BString]) -> anyhow::Result<()> {
+fn start_vm(ctx: VMContext, cmdline: &[BString], env: &[BString]) -> anyhow::Result<()> {
     set_vm_cmdline(ctx, cmdline, env)?;
     unsafe { bindings::krun_start_enter(ctx.id) }.context("Failed to start VM")?;
 
@@ -1069,14 +1059,22 @@ fn run_vmcommand_short(
     dev_info: &[DevInfo],
     use_gvproxy: bool,
     opts: VMOpts,
-    args: &[BString],
+    args: Vec<CString>,
     process_stdin: Option<impl FnOnce(libc::c_int) -> anyhow::Result<()>>,
 ) -> anyhow::Result<VMOutput> {
     let forked = utils::fork_with_piped_output()?;
     if forked.pid == 0 {
         // child process
         let ctx = setup_vm(config, dev_info, use_gvproxy, false, opts)?;
-        start_vm(&ctx, &args, &[])?;
+
+        let argv = args.to_ptr_vec();
+        let envp = vec![std::ptr::null()];
+
+        // this is only used with Linux so far; no need to call set_vm_cmdline
+        unsafe { bindings::krun_set_exec(ctx.id, argv[0], argv[1..].as_ptr(), envp.as_ptr()) }
+            .context("Failed to set exec")?;
+
+        unsafe { bindings::krun_start_enter(ctx.id) }.context("Failed to start VM")?;
         unreachable!();
     } else {
         // parent process
@@ -1667,15 +1665,15 @@ impl AppRunner {
             } else {
                 cmdline.push((vm_prelude + " && /bin/bash -l").into());
             }
-            start_vm(&ctx, &cmdline, &vm_env).context("Failed to start microVM shell")?;
+            start_vm(ctx, &cmdline, &vm_env).context("Failed to start microVM shell")?;
         } else {
             let cmdline: Vec<BString> = if let Some(command) = cmd.command {
                 vec!["/bin/sh".into(), "-c".into(), command.into()]
             } else {
                 vec!["/start-shell.sh".into()]
             };
             vm_image::setup_gvproxy(&config.common, || {
-                start_vm_forked(&ctx, &cmdline, &vm_env).context("Failed to start microVM shell")
+                start_vm_forked(ctx, &cmdline, &vm_env).context("Failed to start microVM shell")
             })?;
         }
 
@@ -1767,7 +1765,7 @@ impl AppRunner {
         let opts = VMOpts::new().read_only_disks(true);
         let ctx = setup_vm(&config, &[], false, false, opts).context("Failed to setup microVM")?;
         let status =
-            start_vm_forked(&ctx, &cmdline, &[]).context("Failed to start microVM shell")?;
+            start_vm_forked(ctx, &cmdline, &[]).context("Failed to start microVM shell")?;
 
         if status != 0 {
             return Err(anyhow::anyhow!(
@@ -2141,7 +2139,7 @@ impl AppRunner {
                 .collect();
 
             start_vmproxy(
-                &ctx,
+                ctx,
                 &config,
                 &service_status,
                 &vm_env,

anylinuxfs/src/utils.rs

@@ -2,7 +2,7 @@ use std::{
     cell::Cell,
     collections::HashSet,
     error::Error,
-    ffi::c_void,
+    ffi::{CString, c_void},
     fs::{File, Permissions},
     io::{self, BufRead, BufReader, Read, Write},
     mem::ManuallyDrop,
@@ -595,38 +595,38 @@ pub fn inspect_cf_dictionary_values(dict: &CFDictionary) {
     }
 }
 
-// pub trait ToPtrVec {
-//     fn to_ptr_vec(self) -> Vec<*const libc::c_char>;
-// }
-
-// impl ToPtrVec for &[CString] {
-//     fn to_ptr_vec(self) -> Vec<*const libc::c_char> {
-//         self.iter()
-//             .map(|s| s.as_ptr())
-//             .chain([std::ptr::null()])
-//             .collect()
-//     }
-// }
-
-// pub trait ToCStringVec {
-//     fn to_cstring_vec(self) -> Vec<CString>;
-// }
-
-// impl ToCStringVec for &[String] {
-//     fn to_cstring_vec(self) -> Vec<CString> {
-//         self.iter()
-//             .map(|s| CString::new(s.as_str()).unwrap())
-//             .collect()
-//     }
-// }
-
-// impl ToCStringVec for &[BString] {
-//     fn to_cstring_vec(self) -> Vec<CString> {
-//         self.iter()
-//             .map(|s| CString::new(s.as_slice()).unwrap())
-//             .collect()
-//     }
-// }
+pub trait ToPtrVec {
+    fn to_ptr_vec(self) -> Vec<*const libc::c_char>;
+}
+
+impl ToPtrVec for &[CString] {
+    fn to_ptr_vec(self) -> Vec<*const libc::c_char> {
+        self.iter()
+            .map(|s| s.as_ptr())
+            .chain([std::ptr::null()])
+            .collect()
+    }
+}
+
+pub trait ToCStringVec {
+    fn to_cstring_vec(self) -> Vec<CString>;
+}
+
+impl ToCStringVec for &[String] {
+    fn to_cstring_vec(self) -> Vec<CString> {
+        self.iter()
+            .map(|s| CString::new(s.as_str()).unwrap())
+            .collect()
+    }
+}
+
+impl ToCStringVec for &[BString] {
+    fn to_cstring_vec(self) -> Vec<CString> {
+        self.iter()
+            .map(|s| CString::new(s.as_slice()).unwrap())
+            .collect()
+    }
+}
 
 pub fn find_env_vars(expression: impl AsRef<BStr>) -> HashSet<BString> {
     let mut vars = HashSet::new();

anylinuxfs/src/vm_image.rs

@@ -519,7 +519,7 @@ mod freebsd {
             .root_device("cd9660:/dev/vtbd0")
             .legacy_console(true);
         let ctx = setup_vm(&config, devices, true, false, opts)?;
-        let bstrap_status = start_vm_forked(&ctx, &["/freebsd-bootstrap".into()], &[])
+        let bstrap_status = start_vm_forked(ctx, &["/freebsd-bootstrap".into()], &[])
             .context("Failed to start FreeBSD bootstrap VM")?;
 
         if bstrap_status != 0 {
@@ -542,7 +542,7 @@ mod freebsd {
             .legacy_console(true);
         let ctx = setup_vm(&config, devices, use_gvproxy, false, opts)?;
         let setup_status =
-            start_vm_forked(&ctx, cmdline, &[]).context("Failed to start FreeBSD VM setup")?;
+            start_vm_forked(ctx, cmdline, &[]).context("Failed to start FreeBSD VM setup")?;
 
         if setup_status != 0 {
             return Err(anyhow::anyhow!(