feat(virtq): remove input output regions from ABI

Signed-off-by: Tomasz Andrzejak <andreiltd@gmail.com>

Author: andreiltd

fuzz/fuzz_targets/host_call.rs

@@ -33,9 +33,9 @@ static SANDBOX: OnceLock<Mutex<MultiUseSandbox>> = OnceLock::new();
 fuzz_target!(
     init: {
         let mut cfg = SandboxConfiguration::default();
-        cfg.set_output_data_size(64 * 1024); // 64 KB output buffer
-        cfg.set_input_data_size(64 * 1024); // 64 KB input buffer
-        cfg.set_scratch_size(512 * 1024); // large scratch region to contain those buffers, any data copies, etc.
+        cfg.set_g2h_pool_pages(16); // 64 KB / 4096 = 16 pages
+        cfg.set_h2g_pool_pages(16); // 64 KB / 4096 = 16 pages
+        cfg.set_scratch_size(512 * 1024); // large scratch region
         let u_sbox = UninitializedSandbox::new(
             GuestBinary::FilePath(simple_guest_for_fuzzing_as_string().expect("Guest Binary Missing")),
             Some(cfg)

src/hyperlight_common/src/arch/aarch64/layout.rs

@@ -20,11 +20,6 @@ pub const SNAPSHOT_PT_GVA_MIN: usize = 0xffff_8000_0000_0000;
 pub const SNAPSHOT_PT_GVA_MAX: usize = 0xffff_80ff_ffff_ffff;
 pub const MAX_GPA: usize = 0x0000_000f_ffff_ffff;
 
-pub fn min_scratch_size(
-    _input_data_size: usize,
-    _output_data_size: usize,
-    _g2h_num_descs: usize,
-    _h2g_num_descs: usize,
-) -> usize {
+pub fn min_scratch_size(_g2h_num_descs: usize, _h2g_num_descs: usize) -> usize {
     unimplemented!("min_scratch_size")
 }

src/hyperlight_common/src/arch/amd64/layout.rs

@@ -37,17 +37,11 @@ pub const MAX_GPA: usize = 0x0000_000f_ffff_ffff;
 /// - A page for the smallest possible non-exception stack
 /// - (up to) 3 pages for mapping that
 /// - Two pages for the exception stack and metadata
-/// - A page-aligned amount of memory for I/O buffers and virtqueue rings
-pub fn min_scratch_size(
-    input_data_size: usize,
-    output_data_size: usize,
-    g2h_num_descs: usize,
-    h2g_num_descs: usize,
-) -> usize {
+/// - A page-aligned amount of memory for virtqueue rings
+pub fn min_scratch_size(g2h_num_descs: usize, h2g_num_descs: usize) -> usize {
     let g2h_ring_size = crate::virtq::Layout::query_size(g2h_num_descs);
     let h2g_ring_size = crate::virtq::Layout::query_size(h2g_num_descs);
 
-    (input_data_size + output_data_size + g2h_ring_size + h2g_ring_size)
-        .next_multiple_of(crate::vmem::PAGE_SIZE)
+    (g2h_ring_size + h2g_ring_size).next_multiple_of(crate::vmem::PAGE_SIZE)
         + 12 * crate::vmem::PAGE_SIZE
 }

src/hyperlight_common/src/arch/i686/layout.rs

@@ -20,11 +20,6 @@ limitations under the License.
 pub const MAX_GVA: usize = 0xffff_ffff;
 pub const MAX_GPA: usize = 0xffff_ffff;
 
-pub fn min_scratch_size(
-    _input_data_size: usize,
-    _output_data_size: usize,
-    _g2h_num_descs: usize,
-    _h2g_num_descs: usize,
-) -> usize {
+pub fn min_scratch_size(_g2h_num_descs: usize, _h2g_num_descs: usize) -> usize {
     crate::vmem::PAGE_SIZE
 }

src/hyperlight_common/src/layout.rs

@@ -83,27 +83,20 @@ pub const fn scratch_top_ptr<T>(offset: u64) -> *mut T {
 
 /// Compute the byte offset from the scratch base to the G2H ring.
 ///
-/// TODO(virtq): Remove input/output
-pub const fn g2h_ring_scratch_offset(input_data_size: usize, output_data_size: usize) -> usize {
-    let io_off = input_data_size + output_data_size;
-    let align = crate::virtq::Descriptor::ALIGN;
-
-    (io_off + align - 1) & !(align - 1)
+/// The G2H ring starts at offset 0, aligned to descriptor alignment.
+pub const fn g2h_ring_scratch_offset() -> usize {
+    0
 }
 
 /// Compute the byte offset from the scratch base to the H2G ring.
 ///
-/// TODO(ring): Remove input/output
-pub const fn h2g_ring_scratch_offset(
-    input_data_size: usize,
-    output_data_size: usize,
-    g2h_num_descs: usize,
-) -> usize {
-    let g2h_offset = g2h_ring_scratch_offset(input_data_size, output_data_size);
+/// The H2G ring follows immediately after the G2H ring, aligned to
+/// descriptor alignment.
+pub const fn h2g_ring_scratch_offset(g2h_num_descs: usize) -> usize {
     let g2h_size = crate::virtq::Layout::query_size(g2h_num_descs);
     let align = crate::virtq::Descriptor::ALIGN;
 
-    (g2h_offset + g2h_size + align - 1) & !(align - 1)
+    (g2h_size + align - 1) & !(align - 1)
 }
 
 /// Compute the minimum scratch region size needed for a sandbox.

src/hyperlight_common/src/mem.rs

@@ -68,8 +68,6 @@ impl Default for FileMappingInfo {
 #[derive(Debug, Clone, Copy)]
 #[repr(C)]
 pub struct HyperlightPEB {
-    pub input_stack: GuestMemoryRegion,
-    pub output_stack: GuestMemoryRegion,
     pub init_data: GuestMemoryRegion,
     pub guest_heap: GuestMemoryRegion,
     /// File mappings array descriptor.

src/hyperlight_guest_capi/src/dispatch.rs

@@ -109,10 +109,22 @@ pub extern "C" fn hl_call_host_function(function_call: &FfiFunctionCall) {
     let return_type = unsafe { function_call.copy_return_type() };
 
     virtq::with_context(|ctx| {
-        let result: ReturnValue = ctx
-            .call_host_function(&func_name, Some(parameters), return_type)
-            .expect("Failed to call host function");
-        ctx.stash_host_return(result);
+        match ctx.call_host_function::<ReturnValue>(&func_name, Some(parameters), return_type) {
+            Ok(result) => ctx.stash_host_return(result),
+            Err(e) => {
+                // Host function returned an error. Abort with the error
+                // message so the host can capture it via the abort buffer.
+                let msg = alloc::ffi::CString::new(e.message)
+                    .unwrap_or_else(|_| alloc::ffi::CString::new("host error").unwrap());
+
+                unsafe {
+                    hyperlight_guest::exit::abort_with_code_and_message(
+                        &[e.kind as u8],
+                        msg.as_ptr(),
+                    );
+                }
+            }
+        }
     });
 }
 

src/hyperlight_host/benches/benchmarks.rs

@@ -385,9 +385,9 @@ fn guest_call_benchmark_large_param(c: &mut Criterion) {
         let large_string = String::from_utf8(large_vec.clone()).unwrap();
 
         let mut config = SandboxConfiguration::default();
-        config.set_input_data_size(2 * SIZE + (1024 * 1024)); // 2 * SIZE + 1 MB, to allow 1MB for the rest of the serialized function call
+        config.set_h2g_pool_pages((2 * SIZE + (1024 * 1024)) / 4096); // pool pages for the large input
         config.set_heap_size(SIZE as u64 * 15);
-        config.set_scratch_size(6 * SIZE + 4 * (1024 * 1024)); // Big enough for the IO data regions and enough of the heap to be used
+        config.set_scratch_size(6 * SIZE + 4 * (1024 * 1024)); // Big enough for any data copies, etc.
 
         let sandbox = UninitializedSandbox::new(
             GuestBinary::FilePath(simple_guest_as_string().unwrap()),
@@ -470,7 +470,7 @@ fn sample_workloads_benchmark(c: &mut Criterion) {
 
     fn bench_24k_in_8k_out(b: &mut criterion::Bencher, guest_path: String) {
         let mut cfg = SandboxConfiguration::default();
-        cfg.set_input_data_size(25 * 1024);
+        cfg.set_h2g_pool_pages(7); // 25 * 1024 / 4096 ~= 7 pages
 
         let mut sandbox = UninitializedSandbox::new(GuestBinary::FilePath(guest_path), Some(cfg))
             .unwrap()

src/hyperlight_host/src/hypervisor/hyperlight_vm/x86_64.rs

@@ -2125,17 +2125,18 @@ mod tests {
         }
 
         /// Creates VM with guest code that: dirtys FPU (if flag==0), does FXSAVE to buffer, sets flag=1.
-        /// Uses output_data region for FXSAVE buffer (like regular guest output), scratch for stack.
+        /// Uses scratch region after rings for FXSAVE buffer.
         fn hyperlight_vm_with_mem_mgr_fxsave() -> FxsaveTestContext {
             use iced_x86::code_asm::*;
 
             // Compute fixed addresses for FXSAVE buffer and flag.
-            // These are in the output_data region which starts at a known offset.
-            // We use a default SandboxConfiguration to get the same layout as create_test_vm_context.
+            // We use the page-table area in scratch after rings as a
+            // convenient 512-byte aligned buffer for FXSAVE.
             let config: SandboxConfiguration = Default::default();
             let layout = SandboxMemoryLayout::new(config, 512, 4096, None).unwrap();
-            let fxsave_offset = layout.get_output_data_buffer_scratch_host_offset();
-            let fxsave_gva = layout.get_output_data_buffer_gva();
+            let fxsave_offset = layout.get_pt_base_scratch_offset();
+            let fxsave_gva = hyperlight_common::layout::scratch_base_gva(config.get_scratch_size())
+                + fxsave_offset as u64;
             let flag_gva = fxsave_gva + 512;
 
             let mut a = CodeAssembler::new(64).unwrap();