Remove host function definition regions

syntactically · syntactically · commit 2bf2fa6abc31 · 2026-01-19T11:01:56.000Z
Former users of this region will replace it with a higher-level
protocol.

Hopefully, we can entirely get rid of string names for host/guest
function calls in the near future.

Signed-off-by: Lucy Menon &lt;168595099+syntactically@users.noreply.github.com&gt;
diff --git a/src/hyperlight_common/src/mem.rs b/src/hyperlight_common/src/mem.rs
@@ -48,5 +48,4 @@ pub struct HyperlightPEB {
     pub init_data: GuestMemoryRegion,
     pub guest_heap: GuestMemoryRegion,
     pub guest_stack: GuestStack,
-    pub host_function_definitions: GuestMemoryRegion,
 }
diff --git a/src/hyperlight_guest/src/guest_handle/host_comm.rs b/src/hyperlight_guest/src/guest_handle/host_comm.rs
@@ -17,7 +17,6 @@ limitations under the License.
 use alloc::format;
 use alloc::string::ToString;
 use alloc::vec::Vec;
-use core::slice::from_raw_parts;
 
 use flatbuffers::FlatBufferBuilder;
 use hyperlight_common::flatbuffer_wrappers::function_call::{FunctionCall, FunctionCallType};
@@ -27,7 +26,6 @@ use hyperlight_common::flatbuffer_wrappers::function_types::{
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
 use hyperlight_common::flatbuffer_wrappers::guest_log_level::LogLevel;
-use hyperlight_common::flatbuffer_wrappers::host_function_details::HostFunctionDetails;
 use hyperlight_common::flatbuffer_wrappers::util::estimate_flatbuffer_capacity;
 use hyperlight_common::outb::OutBAction;
 use tracing::instrument;
@@ -152,22 +150,6 @@ impl GuestHandle {
         self.get_host_return_value::<T>()
     }
 
-    #[instrument(skip_all, level = "Trace")]
-    pub fn get_host_function_details(&self) -> HostFunctionDetails {
-        let peb_ptr = self.peb().unwrap();
-        let host_function_details_buffer =
-            unsafe { (*peb_ptr).host_function_definitions.ptr as *const u8 };
-        let host_function_details_size =
-            unsafe { (*peb_ptr).host_function_definitions.size as usize };
-
-        let host_function_details_slice: &[u8] =
-            unsafe { from_raw_parts(host_function_details_buffer, host_function_details_size) };
-
-        host_function_details_slice
-            .try_into()
-            .expect("Failed to convert buffer to HostFunctionDetails")
-    }
-
     /// Log a message with the specified log level, source, caller, source file, and line number.
     pub fn log_message(
         &self,
diff --git a/src/hyperlight_guest_bin/src/host_comm.rs b/src/hyperlight_guest_bin/src/host_comm.rs
@@ -24,7 +24,6 @@ use hyperlight_common::flatbuffer_wrappers::function_types::{
     ParameterValue, ReturnType, ReturnValue,
 };
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
-use hyperlight_common::flatbuffer_wrappers::host_function_details::HostFunctionDetails;
 use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
 use hyperlight_common::func::{ParameterTuple, SupportedReturnType};
 use hyperlight_guest::error::{HyperlightGuestError, Result};
@@ -72,12 +71,6 @@ pub fn get_host_return_value<T: TryFrom<ReturnValue>>() -> Result<T> {
     handle.get_host_return_value::<T>()
 }
 
-pub fn get_host_function_details() -> HostFunctionDetails {
-    let handle = unsafe { GUEST_HANDLE };
-
-    handle.get_host_function_details()
-}
-
 pub fn read_n_bytes_from_user_memory(num: u64) -> Result<Vec<u8>> {
     let handle = unsafe { GUEST_HANDLE };
     handle.read_n_bytes_from_user_memory(num)
diff --git a/src/hyperlight_host/src/func/host_functions.rs b/src/hyperlight_host/src/func/host_functions.rs
@@ -52,7 +52,7 @@ impl Registerable for UninitializedSandbox {
             return_type: Output::TYPE,
         };
 
-        (*hfs).register_host_function(name.to_string(), entry, &mut self.mgr)
+        (*hfs).register_host_function(name.to_string(), entry)
     }
 }
 
@@ -196,7 +196,7 @@ pub(crate) fn register_host_function<Args: ParameterTuple, Output: SupportedRetu
         .host_funcs
         .try_lock()
         .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-        .register_host_function(name.to_string(), entry, &mut sandbox.mgr)?;
+        .register_host_function(name.to_string(), entry)?;
 
     Ok(())
 }
diff --git a/src/hyperlight_host/src/mem/layout.rs b/src/hyperlight_host/src/mem/layout.rs
@@ -35,8 +35,6 @@ limitations under the License.
 //! +-------------------------------------------+
 //! |              Input Data                   |
 //! +-------------------------------------------+
-//! |        Host Function Definitions          |
-//! +-------------------------------------------+
 //! |                PEB Struct                 | (HyperlightPEB size)
 //! +-------------------------------------------+
 //! |               Guest Code                  |
@@ -73,14 +71,14 @@ limitations under the License.
 use std::fmt::Debug;
 use std::mem::{offset_of, size_of};
 
-use hyperlight_common::mem::{GuestMemoryRegion, HyperlightPEB, PAGE_SIZE_USIZE};
+use hyperlight_common::mem::{GuestStack, HyperlightPEB, PAGE_SIZE_USIZE};
 use rand::{RngCore, rng};
 use tracing::{Span, instrument};
 
 #[cfg(feature = "init-paging")]
 use super::memory_region::MemoryRegionType::PageTables;
 use super::memory_region::MemoryRegionType::{
-    Code, GuardPage, Heap, HostFunctionDefinitions, InitData, InputData, OutputData, Peb, Stack,
+    Code, GuardPage, Heap, InitData, InputData, OutputData, Peb, Stack,
 };
 use super::memory_region::{
     DEFAULT_GUEST_BLOB_MEM_FLAGS, MemoryRegion, MemoryRegion_, MemoryRegionFlags, MemoryRegionKind,
@@ -105,7 +103,6 @@ pub(crate) struct SandboxMemoryLayout {
     peb_offset: usize,
     peb_security_cookie_seed_offset: usize,
     peb_guest_dispatch_function_ptr_offset: usize, // set by guest in guest entrypoint
-    pub(super) peb_host_function_definitions_offset: usize,
     peb_input_data_offset: usize,
     peb_output_data_offset: usize,
     peb_init_data_offset: usize,
@@ -114,7 +111,6 @@ pub(crate) struct SandboxMemoryLayout {
 
     // The following are the actual values
     // that are written to the PEB struct
-    pub(crate) host_function_definitions_buffer_offset: usize,
     pub(super) input_data_buffer_offset: usize,
     pub(super) output_data_buffer_offset: usize,
     guest_heap_buffer_offset: usize,
@@ -156,10 +152,6 @@ impl Debug for SandboxMemoryLayout {
                 "Guest Dispatch Function Pointer Offset",
                 &format_args!("{:#x}", self.peb_guest_dispatch_function_ptr_offset),
             )
-            .field(
-                "Host Function Definitions Offset",
-                &format_args!("{:#x}", self.peb_host_function_definitions_offset),
-            )
             .field(
                 "Input Data Offset",
                 &format_args!("{:#x}", self.peb_input_data_offset),
@@ -180,10 +172,6 @@ impl Debug for SandboxMemoryLayout {
                 "Guest Stack Offset",
                 &format_args!("{:#x}", self.peb_guest_stack_data_offset),
             )
-            .field(
-                "Host Function Definitions Buffer Offset",
-                &format_args!("{:#x}", self.host_function_definitions_buffer_offset),
-            )
             .field(
                 "Input Data Buffer Offset",
                 &format_args!("{:#x}", self.input_data_buffer_offset),
@@ -256,19 +244,13 @@ impl SandboxMemoryLayout {
         let peb_init_data_offset = peb_offset + offset_of!(HyperlightPEB, init_data);
         let peb_heap_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_heap);
         let peb_guest_stack_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_stack);
-        let peb_host_function_definitions_offset =
-            peb_offset + offset_of!(HyperlightPEB, host_function_definitions);
 
         // The following offsets are the actual values that relate to memory layout,
         // which are written to PEB struct
         let peb_address = Self::BASE_ADDRESS + peb_offset;
-        // make sure host function definitions buffer starts at 4K boundary
-        let host_function_definitions_buffer_offset = round_up_to(
-            peb_host_function_definitions_offset + size_of::<GuestMemoryRegion>(),
-            PAGE_SIZE_USIZE,
-        );
+        // make sure input data buffer starts at 4K boundary
         let input_data_buffer_offset = round_up_to(
-            host_function_definitions_buffer_offset + cfg.get_host_function_definition_size(),
+            peb_guest_stack_data_offset + size_of::<GuestStack>(),
             PAGE_SIZE_USIZE,
         );
         let output_data_buffer_offset = round_up_to(
@@ -294,15 +276,13 @@ impl SandboxMemoryLayout {
             heap_size,
             peb_security_cookie_seed_offset,
             peb_guest_dispatch_function_ptr_offset,
-            peb_host_function_definitions_offset,
             peb_input_data_offset,
             peb_output_data_offset,
             peb_init_data_offset,
             peb_heap_data_offset,
             peb_guest_stack_data_offset,
             sandbox_memory_config: cfg,
             code_size,
-            host_function_definitions_buffer_offset,
             input_data_buffer_offset,
             output_data_buffer_offset,
             guest_heap_buffer_offset,
@@ -325,22 +305,6 @@ impl SandboxMemoryLayout {
         self.peb_output_data_offset
     }
 
-    /// Get the offset in guest memory to the host function definitions
-    /// size
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(super) fn get_host_function_definitions_size_offset(&self) -> usize {
-        // The size field is the first field in the `HostFunctions` struct
-        self.peb_host_function_definitions_offset
-    }
-
-    /// Get the offset in guest memory to the host function definitions
-    /// pointer.
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    fn get_host_function_definitions_pointer_offset(&self) -> usize {
-        // The size field is the field after the size field in the `HostFunctions` struct which is a u64
-        self.peb_host_function_definitions_offset + size_of::<u64>()
-    }
-
     /// Get the offset in guest memory to the init data size
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(super) fn get_init_data_size_offset(&self) -> usize {
@@ -526,31 +490,12 @@ impl SandboxMemoryLayout {
         }
 
         // PEB
-        let host_functions_definitions_offset = builder.push_page_aligned(
+        let input_data_offset = builder.push_page_aligned(
             size_of::<HyperlightPEB>(),
             MemoryRegionFlags::READ | MemoryRegionFlags::WRITE,
             Peb,
         );
 
-        let expected_host_functions_definitions_offset =
-            TryInto::<usize>::try_into(self.host_function_definitions_buffer_offset)?;
-
-        if host_functions_definitions_offset != expected_host_functions_definitions_offset {
-            return Err(new_error!(
-                "Host Function Definitions offset does not match expected Host Function Definitions offset expected:  {}, actual:  {}",
-                expected_host_functions_definitions_offset,
-                host_functions_definitions_offset
-            ));
-        }
-
-        // host function definitions
-        let input_data_offset = builder.push_page_aligned(
-            self.sandbox_memory_config
-                .get_host_function_definition_size(),
-            MemoryRegionFlags::READ,
-            HostFunctionDefinitions,
-        );
-
         let expected_input_data_offset = TryInto::<usize>::try_into(self.input_data_buffer_offset)?;
 
         if input_data_offset != expected_input_data_offset {
@@ -744,16 +689,6 @@ impl SandboxMemoryLayout {
 
         // Skip guest_dispatch_function_ptr_offset because it is set by the guest
 
-        // Set up Host Function Definition
-        shared_mem.write_u64(
-            self.get_host_function_definitions_size_offset(),
-            self.sandbox_memory_config
-                .get_host_function_definition_size()
-                .try_into()?,
-        )?;
-        let addr = get_address!(host_function_definitions_buffer_offset);
-        shared_mem.write_u64(self.get_host_function_definitions_pointer_offset(), addr)?;
-
         // Skip code, is set when loading binary
         // skip outb and outb context, is set when running in_proc
 
@@ -861,8 +796,6 @@ mod tests {
 
         expected_size += round_up_to(size_of::<HyperlightPEB>(), PAGE_SIZE_USIZE);
 
-        expected_size += round_up_to(cfg.get_host_function_definition_size(), PAGE_SIZE_USIZE);
-
         expected_size += round_up_to(cfg.get_input_data_size(), PAGE_SIZE_USIZE);
 
         expected_size += round_up_to(cfg.get_output_data_size(), PAGE_SIZE_USIZE);
diff --git a/src/hyperlight_host/src/mem/mgr.rs b/src/hyperlight_host/src/mem/mgr.rs
@@ -22,7 +22,6 @@ use hyperlight_common::flatbuffer_wrappers::function_call::{
 };
 use hyperlight_common::flatbuffer_wrappers::function_types::FunctionCallResult;
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
-use hyperlight_common::flatbuffer_wrappers::host_function_details::HostFunctionDetails;
 #[cfg(feature = "init-paging")]
 use hyperlight_common::vmem;
 #[cfg(feature = "init-paging")]
@@ -35,7 +34,7 @@ use super::ptr::{GuestPtr, RawPtr};
 use super::ptr_offset::Offset;
 use super::shared_mem::{ExclusiveSharedMemory, GuestSharedMemory, HostSharedMemory, SharedMemory};
 use crate::sandbox::snapshot::Snapshot;
-use crate::{Result, log_then_return, new_error};
+use crate::{Result, new_error};
 
 /// The size of stack guard cookies
 pub(crate) const STACK_COOKIE_LEN: usize = 16;
@@ -218,42 +217,6 @@ impl SandboxMemoryManager<ExclusiveSharedMemory> {
         ))
     }
 
-    /// Writes host function details to memory
-    #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn write_buffer_host_function_details(&mut self, buffer: &[u8]) -> Result<()> {
-        let host_function_details = HostFunctionDetails::try_from(buffer).map_err(|e| {
-            new_error!(
-                "write_buffer_host_function_details: failed to convert buffer to HostFunctionDetails: {}",
-                e
-            )
-        })?;
-
-        let host_function_call_buffer: Vec<u8> = (&host_function_details).try_into().map_err(|_| {
-            new_error!(
-                "write_buffer_host_function_details: failed to convert HostFunctionDetails to Vec<u8>"
-            )
-        })?;
-
-        let buffer_size = {
-            let size_u64 = self
-                .shared_mem
-                .read_u64(self.layout.get_host_function_definitions_size_offset())?;
-            usize::try_from(size_u64)
-        }?;
-
-        if host_function_call_buffer.len() > buffer_size {
-            log_then_return!(
-                "Host Function Details buffer is too big for the host_function_definitions buffer"
-            );
-        }
-
-        self.shared_mem.copy_from_slice(
-            host_function_call_buffer.as_slice(),
-            self.layout.host_function_definitions_buffer_offset,
-        )?;
-        Ok(())
-    }
-
     /// Write memory layout
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn write_memory_layout(&mut self) -> Result<()> {
diff --git a/src/hyperlight_host/src/sandbox/config.rs b/src/hyperlight_host/src/sandbox/config.rs
diff --git a/src/hyperlight_host/src/sandbox/host_funcs.rs b/src/hyperlight_host/src/sandbox/host_funcs.rs

Original file line number	Diff line number	Diff line change
`@@ -48,5 +48,4 @@ pub struct HyperlightPEB {`
`48`	`48`	`pub init_data: GuestMemoryRegion,`
`49`	`49`	`pub guest_heap: GuestMemoryRegion,`
`50`	`50`	`pub guest_stack: GuestStack,`
`51`		`- pub host_function_definitions: GuestMemoryRegion,`
`52`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ impl Registerable for UninitializedSandbox {`
`52`	`52`	`return_type: Output::TYPE,`
`53`	`53`	`};`
`54`	`54`
`55`		`- (*hfs).register_host_function(name.to_string(), entry, &mut self.mgr)`
	`55`	`+ (*hfs).register_host_function(name.to_string(), entry)`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`@@ -196,7 +196,7 @@ pub(crate) fn register_host_function<Args: ParameterTuple, Output: SupportedRetu`
`196`	`196`	`.host_funcs`
`197`	`197`	`.try_lock()`
`198`	`198`	`.map_err(\|e\| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?`
`199`		`- .register_host_function(name.to_string(), entry, &mut sandbox.mgr)?;`
	`199`	`+ .register_host_function(name.to_string(), entry)?;`
`200`	`200`
`201`	`201`	`Ok(())`
`202`	`202`	`}`