crashdump: allow crashdump toggle at sandbox level

- this allows a user to configure the crash dump feature at sandbox level
- create a SandboxRuntimeConfig struct to contain all the configuration
a sandbox would need at runtime to avoid passing the information as multiple
functions arguments

Signed-off-by: Doru Blânzeanu <[email protected]>

Author: dblnz

src/hyperlight_host/src/hypervisor/crashdump.rs

@@ -251,47 +251,51 @@ pub(crate) fn crashdump_to_tempfile(hv: &dyn Hypervisor) -> Result<()> {
         .crashdump_context()
         .map_err(|e| new_error!("Failed to get crashdump context: {:?}", e))?;
 
-    // Set up data sources for the core dump
-    let guest_view = GuestView::new(&ctx);
-    let memory_reader = GuestMemReader::new(&ctx);
-
-    // Create and write core dump
-    let core_builder = CoreDumpBuilder::from_source(guest_view, memory_reader);
-
-    // Generate timestamp string for the filename using chrono
-    let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S").to_string();
-
-    // Determine the output directory based on environment variable
-    let output_dir = if let Ok(dump_dir) = std::env::var("HYPERLIGHT_CORE_DUMP_DIR") {
-        // Create the directory if it doesn't exist
-        let path = std::path::Path::new(&dump_dir);
-        if !path.exists() {
-            std::fs::create_dir_all(path)
-                .map_err(|e| new_error!("Failed to create core dump directory: {:?}", e))?;
-        }
-        std::path::PathBuf::from(dump_dir)
-    } else {
-        // Fall back to the system temp directory
-        std::env::temp_dir()
-    };
+    // If the returned a context it means we can create a core dump
+    // This is the case when the sandbox has been configured at runtime to allow core dumps
+    if let Some(ctx) = ctx {
+        // Set up data sources for the core dump
+        let guest_view = GuestView::new(&ctx);
+        let memory_reader = GuestMemReader::new(&ctx);
+
+        // Create and write core dump
+        let core_builder = CoreDumpBuilder::from_source(guest_view, memory_reader);
+
+        // Generate timestamp string for the filename using chrono
+        let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S").to_string();
+
+        // Determine the output directory based on environment variable
+        let output_dir = if let Ok(dump_dir) = std::env::var("HYPERLIGHT_CORE_DUMP_DIR") {
+            // Create the directory if it doesn't exist
+            let path = std::path::Path::new(&dump_dir);
+            if !path.exists() {
+                std::fs::create_dir_all(path)
+                    .map_err(|e| new_error!("Failed to create core dump directory: {:?}", e))?;
+            }
+            std::path::PathBuf::from(dump_dir)
+        } else {
+            // Fall back to the system temp directory
+            std::env::temp_dir()
+        };
 
-    // Create the filename with timestamp
-    let filename = format!("hl_core_{}.elf", timestamp);
-    let file_path = output_dir.join(filename);
+        // Create the filename with timestamp
+        let filename = format!("hl_core_{}.elf", timestamp);
+        let file_path = output_dir.join(filename);
 
-    // Create the file
-    let file = std::fs::File::create(&file_path)
-        .map_err(|e| new_error!("Failed to create core dump file: {:?}", e))?;
+        // Create the file
+        let file = std::fs::File::create(&file_path)
+            .map_err(|e| new_error!("Failed to create core dump file: {:?}", e))?;
 
-    // Write the core dump directly to the file
-    core_builder
-        .write(&file)
-        .map_err(|e| new_error!("Failed to write core dump: {:?}", e))?;
+        // Write the core dump directly to the file
+        core_builder
+            .write(&file)
+            .map_err(|e| new_error!("Failed to write core dump: {:?}", e))?;
 
-    let path_string = file_path.to_string_lossy().to_string();
+        let path_string = file_path.to_string_lossy().to_string();
 
-    println!("Core dump created successfully: {}", path_string);
-    log::error!("Core dump file: {}", path_string);
+        println!("Core dump created successfully: {}", path_string);
+        log::error!("Core dump file: {}", path_string);
+    }
 
     Ok(())
 }

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -49,7 +49,7 @@ use mshv_bindings::{
 use mshv_ioctls::{Mshv, VcpuFd, VmFd};
 use tracing::{instrument, Span};
 #[cfg(crashdump)]
-use {super::crashdump, crate::sandbox::uninitialized::SandboxMetadata, std::path::Path};
+use {super::crashdump, crate::sandbox::uninitialized::SandboxRuntimeConfig, std::path::Path};
 
 use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
 #[cfg(gdb)]
@@ -301,7 +301,7 @@ pub(super) struct HypervLinuxDriver {
     #[cfg(gdb)]
     gdb_conn: Option<DebugCommChannel<DebugResponse, DebugMsg>>,
     #[cfg(crashdump)]
-    metadata: SandboxMetadata,
+    rt_cfg: SandboxRuntimeConfig,
 }
 
 impl HypervLinuxDriver {
@@ -320,7 +320,7 @@ impl HypervLinuxDriver {
         rsp_ptr: GuestPtr,
         pml4_ptr: GuestPtr,
         #[cfg(gdb)] gdb_conn: Option<DebugCommChannel<DebugResponse, DebugMsg>>,
-        #[cfg(crashdump)] metadata: SandboxMetadata,
+        #[cfg(crashdump)] rt_cfg: SandboxRuntimeConfig,
     ) -> Result<Self> {
         let mshv = Mshv::new()?;
         let pr = Default::default();
@@ -401,7 +401,7 @@ impl HypervLinuxDriver {
             #[cfg(gdb)]
             gdb_conn,
             #[cfg(crashdump)]
-            metadata,
+            rt_cfg,
         })
     }
 
@@ -686,57 +686,61 @@ impl Hypervisor for HypervLinuxDriver {
     }
 
     #[cfg(crashdump)]
-    fn crashdump_context(&self) -> Result<super::crashdump::CrashDumpContext> {
-        let mut regs = [0; 27];
-
-        let vcpu_regs = self.vcpu_fd.get_regs()?;
-        let sregs = self.vcpu_fd.get_sregs()?;
-        let xsave = self.vcpu_fd.get_xsave()?;
-
-        // Set up the registers for the crash dump
-        regs[0] = vcpu_regs.r15; // r15
-        regs[1] = vcpu_regs.r14; // r14
-        regs[2] = vcpu_regs.r13; // r13
-        regs[3] = vcpu_regs.r12; // r12
-        regs[4] = vcpu_regs.rbp; // rbp
-        regs[5] = vcpu_regs.rbx; // rbx
-        regs[6] = vcpu_regs.r11; // r11
-        regs[7] = vcpu_regs.r10; // r10
-        regs[8] = vcpu_regs.r9; // r9
-        regs[9] = vcpu_regs.r8; // r8
-        regs[10] = vcpu_regs.rax; // rax
-        regs[11] = vcpu_regs.rcx; // rcx
-        regs[12] = vcpu_regs.rdx; // rdx
-        regs[13] = vcpu_regs.rsi; // rsi
-        regs[14] = vcpu_regs.rdi; // rdi
-        regs[15] = 0; // orig rax
-        regs[16] = vcpu_regs.rip; // rip
-        regs[17] = sregs.cs.selector as u64; // cs
-        regs[18] = vcpu_regs.rflags; // eflags
-        regs[19] = vcpu_regs.rsp; // rsp
-        regs[20] = sregs.ss.selector as u64; // ss
-        regs[21] = sregs.fs.base; // fs_base
-        regs[22] = sregs.gs.base; // gs_base
-        regs[23] = sregs.ds.selector as u64; // ds
-        regs[24] = sregs.es.selector as u64; // es
-        regs[25] = sregs.fs.selector as u64; // fs
-        regs[26] = sregs.gs.selector as u64; // gs
-
-        // Get the filename from the binary path
-        let filename = self.metadata.binary_path.clone().and_then(|path| {
-            Path::new(&path)
-                .file_name()
-                .and_then(|name| name.to_os_string().into_string().ok())
-        });
-
-        Ok(crashdump::CrashDumpContext::new(
-            &self.mem_regions,
-            regs,
-            xsave.buffer.to_vec(),
-            self.entrypoint,
-            self.metadata.binary_path.clone(),
-            filename,
-        ))
+    fn crashdump_context(&self) -> Result<Option<super::crashdump::CrashDumpContext>> {
+        if self.rt_cfg.guest_core_dump {
+            let mut regs = [0; 27];
+
+            let vcpu_regs = self.vcpu_fd.get_regs()?;
+            let sregs = self.vcpu_fd.get_sregs()?;
+            let xsave = self.vcpu_fd.get_xsave()?;
+
+            // Set up the registers for the crash dump
+            regs[0] = vcpu_regs.r15; // r15
+            regs[1] = vcpu_regs.r14; // r14
+            regs[2] = vcpu_regs.r13; // r13
+            regs[3] = vcpu_regs.r12; // r12
+            regs[4] = vcpu_regs.rbp; // rbp
+            regs[5] = vcpu_regs.rbx; // rbx
+            regs[6] = vcpu_regs.r11; // r11
+            regs[7] = vcpu_regs.r10; // r10
+            regs[8] = vcpu_regs.r9; // r9
+            regs[9] = vcpu_regs.r8; // r8
+            regs[10] = vcpu_regs.rax; // rax
+            regs[11] = vcpu_regs.rcx; // rcx
+            regs[12] = vcpu_regs.rdx; // rdx
+            regs[13] = vcpu_regs.rsi; // rsi
+            regs[14] = vcpu_regs.rdi; // rdi
+            regs[15] = 0; // orig rax
+            regs[16] = vcpu_regs.rip; // rip
+            regs[17] = sregs.cs.selector as u64; // cs
+            regs[18] = vcpu_regs.rflags; // eflags
+            regs[19] = vcpu_regs.rsp; // rsp
+            regs[20] = sregs.ss.selector as u64; // ss
+            regs[21] = sregs.fs.base; // fs_base
+            regs[22] = sregs.gs.base; // gs_base
+            regs[23] = sregs.ds.selector as u64; // ds
+            regs[24] = sregs.es.selector as u64; // es
+            regs[25] = sregs.fs.selector as u64; // fs
+            regs[26] = sregs.gs.selector as u64; // gs
+
+            // Get the filename from the binary path
+            let filename = self.rt_cfg.binary_path.clone().and_then(|path| {
+                Path::new(&path)
+                    .file_name()
+                    .and_then(|name| name.to_os_string().into_string().ok())
+            });
+
+            Ok(Some(crashdump::CrashDumpContext::new(
+                &self.mem_regions,
+                regs,
+                xsave.buffer.to_vec(),
+                self.entrypoint,
+                self.rt_cfg.binary_path.clone(),
+                filename,
+            )))
+        } else {
+            Ok(None)
+        }
     }
 
     #[cfg(gdb)]
@@ -856,8 +860,15 @@ mod tests {
             pml4_ptr,
             #[cfg(gdb)]
             None,
-            #[cfg(crashdump)]
-            SandboxMetadata { binary_path: None },
+            #[cfg(any(crashdump, gdb))]
+            SandboxRuntimeConfig {
+                #[cfg(crashdump)]
+                binary_path: None,
+                #[cfg(gdb)]
+                debug_info: None,
+                #[cfg(crashdump)]
+                guest_core_dump: true,
+            },
         )
         .unwrap();
     }