[customguest,host/{hypervisor/{mod,kvm},mem/{layout,memory_region,mgr},sandbox/config},testing/lib,Justfile,Cargo.toml,.gitignore]

added custom guest memory region and tmp custom guest

Context: Instead of having a static memory layout set by the host, we want to provide the guest w/ a custom sized
allocated undifferentiated memory region for it address in any way it wants. This commit starts that by adding the
custom guest memory region.

Changes:
- added new section to SandboxMemoryLayout, and made getters for its offset and size.
- changed get_total_page_table_size calculation to account for custom section.
- added new section to builder in get_memory_regions.
- wrote address of custom guest memory region to custom guest memory offset.
- added new memory section to page table setup (i.e., set_up_shared_memory).
- added function to get custom guest memory region as Vec<u8>.
- made custom guest memory section size configurable via SandboxConfiguration.
- fixed existing tests.
- added new guest (customguest) to test custom setup. Modified Justfile to include it for easy builds too.
- added new test for custom init with the new customguest.

Signed-off-by: danbugs <[email protected]>

Author: danbugs

.gitignore

@@ -468,3 +468,6 @@ hyperlight_guest.h
 .mono
 
 !.gitkeep
+
+# gdb
+.gdbinit

Cargo.toml

@@ -21,6 +21,12 @@ exclude = [
     "src/tests/rust_guests/callbackguest",
     "src/tests/rust_guests/dummyguest",
     "src/tests/rust_guests/simpleguest",
+    # Note: This is a temporary guest to test
+    # the new memory layout. Once I'm done w/
+    # the work, I'll delete it. `simpleguest`
+    # and `callbackguest` will be demonstrative
+    # of the work by themselves.
+    "src/tests/rust_guests/customguest",
 ]
 
 [workspace.package]

Justfile

@@ -14,6 +14,7 @@ default-target := "debug"
 simpleguest_source := "src/tests/rust_guests/simpleguest/target/x86_64-unknown-none"
 simpleguest_msvc_source := "src/tests/rust_guests/simpleguest/target/x86_64-pc-windows-msvc"
 dummyguest_source := "src/tests/rust_guests/dummyguest/target/x86_64-unknown-none"
+customguest_source := "src/tests/rust_guests/customguest/target/x86_64-unknown-none"
 callbackguest_source := "src/tests/rust_guests/callbackguest/target/x86_64-unknown-none"
 callbackguest_msvc_source := "src/tests/rust_guests/callbackguest/target/x86_64-pc-windows-msvc"
 rust_guests_bin_dir := "src/tests/rust_guests/bin"
@@ -39,14 +40,16 @@ build-rust-guests target=default-target:
     cd src/tests/rust_guests/callbackguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }}  --target=x86_64-pc-windows-msvc
     cd src/tests/rust_guests/simpleguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }} 
     cd src/tests/rust_guests/simpleguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }} --target=x86_64-pc-windows-msvc
-    cd src/tests/rust_guests/dummyguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }} 
+    cd src/tests/rust_guests/dummyguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }}
+    cd src/tests/rust_guests/customguest && cargo build --profile={{ if target == "debug" { "dev" } else { target } }}
 
 @move-rust-guests target=default-target:
     cp {{ callbackguest_source }}/{{ target }}/callbackguest* {{ rust_guests_bin_dir }}/{{ target }}/
     cp {{ callbackguest_msvc_source }}/{{ target }}/callbackguest* {{ rust_guests_bin_dir }}/{{ target }}/
     cp {{ simpleguest_source }}/{{ target }}/simpleguest* {{ rust_guests_bin_dir }}/{{ target }}/
     cp {{ simpleguest_msvc_source }}/{{ target }}/simpleguest* {{ rust_guests_bin_dir }}/{{ target }}/
     cp {{ dummyguest_source }}/{{ target }}/dummyguest* {{ rust_guests_bin_dir }}/{{ target }}/
+    cp {{ customguest_source }}/{{ target }}/customguest* {{ rust_guests_bin_dir }}/{{ target }}/
 
 build-and-move-rust-guests: (build-rust-guests "debug") (move-rust-guests "debug") (build-rust-guests "release") (move-rust-guests "release")
 build-and-move-c-guests: (build-c-guests "debug") (move-c-guests "debug") (build-c-guests "release") (move-c-guests "release")
@@ -69,6 +72,7 @@ clean-rust:
     cargo clean
     cd src/tests/rust_guests/simpleguest && cargo clean
     cd src/tests/rust_guests/dummyguest && cargo clean
+    cd src/tests/rust_guests/customguest && cargo clean
     cd src/tests/rust_guests/callbackguest && cargo clean
     git clean -fdx src/tests/c_guests/bin src/tests/rust_guests/bin
 
@@ -126,13 +130,15 @@ fmt-check:
     cargo +nightly fmt --manifest-path src/tests/rust_guests/callbackguest/Cargo.toml -- --check
     cargo +nightly fmt --manifest-path src/tests/rust_guests/simpleguest/Cargo.toml -- --check
     cargo +nightly fmt --manifest-path src/tests/rust_guests/dummyguest/Cargo.toml -- --check
+    cargo +nightly fmt --manifest-path src/tests/rust_guests/customguest/Cargo.toml -- --check
     cargo +nightly fmt --manifest-path src/hyperlight_guest_capi/Cargo.toml -- --check
 
 fmt-apply:
     cargo +nightly fmt --all
     cargo +nightly fmt --manifest-path src/tests/rust_guests/callbackguest/Cargo.toml
     cargo +nightly fmt --manifest-path src/tests/rust_guests/simpleguest/Cargo.toml
     cargo +nightly fmt --manifest-path src/tests/rust_guests/dummyguest/Cargo.toml
+    cargo +nightly fmt --manifest-path src/tests/rust_guests/customguest/Cargo.toml
     cargo +nightly fmt --manifest-path src/hyperlight_guest_capi/Cargo.toml
 
 clippy target=default-target:

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -937,7 +937,7 @@ mod tests {
     #[cfg(gdb)]
     use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
     use crate::hypervisor::handlers::{MemAccessHandler, OutBHandler};
-    use crate::hypervisor::tests::test_initialise;
+    use crate::hypervisor::tests::{test_custom_initialise, test_initialise};
     use crate::Result;
 
     #[cfg(gdb)]
@@ -984,4 +984,31 @@ mod tests {
         )
         .unwrap();
     }
+
+    #[test]
+    fn test_custom_init() {
+        if !super::is_hypervisor_present() {
+            return;
+        }
+
+        let outb_handler: Arc<Mutex<OutBHandler>> = {
+            let func: Box<dyn FnMut(u16, u64) -> Result<()> + Send> =
+                Box::new(|_, _| -> Result<()> { Ok(()) });
+            Arc::new(Mutex::new(OutBHandler::from(func)))
+        };
+        let mem_access_handler = {
+            let func: Box<dyn FnMut() -> Result<()> + Send> = Box::new(|| -> Result<()> { Ok(()) });
+            Arc::new(Mutex::new(MemAccessHandler::from(func)))
+        };
+        #[cfg(gdb)]
+        let dbg_mem_access_handler = Arc::new(Mutex::new(DbgMemAccessHandler {}));
+
+        test_custom_initialise(
+            outb_handler,
+            mem_access_handler,
+            #[cfg(gdb)]
+            dbg_mem_access_handler,
+        )
+        .unwrap();
+    }
 }

src/hyperlight_host/src/hypervisor/mod.rs

@@ -307,7 +307,7 @@ pub(crate) mod tests {
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
-    use hyperlight_testing::dummy_guest_as_string;
+    use hyperlight_testing::{custom_guest_as_string, dummy_guest_as_string};
 
     #[cfg(gdb)]
     use super::handlers::DbgMemAccessHandlerWrapper;
@@ -320,6 +320,67 @@ pub(crate) mod tests {
     use crate::sandbox::{SandboxConfiguration, UninitializedSandbox};
     use crate::{new_error, Result};
 
+    pub(crate) fn test_custom_initialise(
+        outb_hdl: OutBHandlerWrapper,
+        mem_access_hdl: MemAccessHandlerWrapper,
+        #[cfg(gdb)] dbg_mem_access_fn: DbgMemAccessHandlerWrapper,
+    ) -> Result<()> {
+        let filename = custom_guest_as_string().map_err(|e| new_error!("{}", e))?;
+        let mut sbox_config = SandboxConfiguration::default();
+        sbox_config.set_custom_guest_memory_size(0x2_000_000);
+        let uninitialized_sandbox = UninitializedSandbox::new(
+            GuestBinary::FilePath(filename.clone()),
+            Some(sbox_config),
+            None,
+            None,
+        )?;
+
+        let (hshm, gshm) = uninitialized_sandbox.mgr.build();
+
+        let custom_memory_offset = gshm.layout.get_custom_guest_memory_offset();
+        let custom_memory_size = gshm.layout.get_custom_guest_memory_size();
+        dbg!(&custom_memory_offset);
+
+        let custom_memory = hshm.as_ref().get_custom_guest_memory()?;
+        assert_eq!(custom_memory[0], 0);
+
+        let hv_handler_config = HvHandlerConfig {
+            outb_handler: outb_hdl,
+            mem_access_handler: mem_access_hdl,
+            #[cfg(gdb)]
+            dbg_mem_access_handler: dbg_mem_access_fn,
+            seed: custom_memory_size as u64, // re-using seed as custom_memory_size
+            page_size: 4096,
+            peb_addr: RawPtr::from(custom_memory_offset as u64),
+            dispatch_function_addr: Arc::new(Mutex::new(None)),
+            max_init_time: Duration::from_millis(
+                SandboxConfiguration::DEFAULT_MAX_INITIALIZATION_TIME as u64,
+            ),
+            max_exec_time: Duration::from_millis(
+                SandboxConfiguration::DEFAULT_MAX_EXECUTION_TIME as u64,
+            ),
+            max_wait_for_cancellation: Duration::from_millis(
+                SandboxConfiguration::DEFAULT_MAX_WAIT_FOR_CANCELLATION as u64,
+            ),
+        };
+
+        let mut hv_handler = HypervisorHandler::new(hv_handler_config);
+
+        hv_handler.start_hypervisor_handler(
+            gshm,
+            #[cfg(gdb)]
+            None,
+        )?;
+
+        hv_handler.execute_hypervisor_handler_action(HypervisorHandlerAction::Initialise)?;
+
+        let custom_memory = hshm.as_ref().get_custom_guest_memory()?;
+
+        assert_eq!(custom_memory[0], 1);
+
+        Ok(())
+    }
+
     pub(crate) fn test_initialise(
         outb_hdl: OutBHandlerWrapper,
         mem_access_hdl: MemAccessHandlerWrapper,