[trace] Add instrumentation of hyperlight-wasm code

dblnz · dblnz · commit 70af69b178b0 · 2025-08-06T10:21:26.000+03:00
- generate tracing records for `wasm_runtime` to produce
  timing information at runtime
diff --git a/src/wasm_runtime/src/component.rs b/src/wasm_runtime/src/component.rs
@@ -43,10 +43,12 @@ static CUR_INSTANCE: Mutex<Option<Instance>> = Mutex::new(None);
 hyperlight_wasm_macro::wasm_guest_bindgen!();
 
 // dummy for compatibility with the module loading approach
+#[hyperlight_guest_tracing::trace_function]
 fn init_wasm_runtime(_function_call: &FunctionCall) -> Result<Vec<u8>> {
     Ok(get_flatbuffer_result::<i32>(0))
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn load_component_common(engine: &Engine, component: Component) -> Result<()> {
     let mut store = Store::new(engine, ());
     let instance = (*CUR_LINKER.lock())
@@ -58,6 +60,7 @@ fn load_component_common(engine: &Engine, component: Component) -> Result<()> {
     Ok(())
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if let (
         ParameterValue::VecBytes(ref wasm_bytes),
@@ -79,6 +82,7 @@ fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if let (ParameterValue::ULong(ref phys), ParameterValue::ULong(ref len), Some(ref engine)) = (
         &function_call.parameters.as_ref().unwrap()[0],
@@ -98,6 +102,7 @@ fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn hyperlight_main() {
     platform::register_page_fault_handler();
 
@@ -131,6 +136,7 @@ pub extern "C" fn hyperlight_main() {
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
     Err(HyperlightGuestError::new(
         ErrorCode::GuestFunctionNotFound,
diff --git a/src/wasm_runtime/src/hostfuncs.rs b/src/wasm_runtime/src/hostfuncs.rs
@@ -36,6 +36,7 @@ pub(crate) fn get_host_function_details() -> HostFunctionDetails {
     hyperlight_guest_bin::host_comm::get_host_function_details()
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub(crate) fn hostfunc_type(d: &HostFunctionDefinition, e: &Engine) -> Result<FuncType> {
     let mut params = Vec::new();
     let mut last_was_vec = false;
@@ -79,6 +80,7 @@ pub(crate) fn hostfunc_type(d: &HostFunctionDefinition, e: &Engine) -> Result<Fu
     Ok(FuncType::new(e, params, results))
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub(crate) fn call(
     d: &HostFunctionDefinition,
     mut c: Caller<'_, ()>,
@@ -115,6 +117,7 @@ pub(crate) fn call(
     Ok(())
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn return_type_from_val(val: &ReturnValue) -> ReturnType {
     match val {
         ReturnValue::Int(_) => ReturnType::Int,
diff --git a/src/wasm_runtime/src/marshal.rs b/src/wasm_runtime/src/marshal.rs
@@ -29,6 +29,7 @@ use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
 use hyperlight_guest::error::{HyperlightGuestError, Result};
 use wasmtime::{AsContextMut, Extern, Val};
 
+#[hyperlight_guest_tracing::trace_function]
 fn malloc<C: AsContextMut>(
     ctx: &mut C,
     get_export: &impl Fn(&mut C, &str) -> Option<Extern>,
@@ -46,6 +47,7 @@ fn malloc<C: AsContextMut>(
     Ok(addr)
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn write<C: AsContextMut>(
     ctx: &mut C,
     get_export: &impl Fn(&mut C, &str) -> Option<Extern>,
@@ -67,6 +69,7 @@ fn write<C: AsContextMut>(
     Ok(())
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn read<C: AsContextMut>(
     ctx: &mut C,
     get_export: &impl Fn(&mut C, &str) -> Option<Extern>,
@@ -88,6 +91,7 @@ fn read<C: AsContextMut>(
     Ok(())
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn read_cstr<C: AsContextMut>(
     ctx: &mut C,
     get_export: &impl Fn(&mut C, &str) -> Option<Extern>,
@@ -126,6 +130,7 @@ fn read_cstr<C: AsContextMut>(
     })
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub fn hl_param_to_val<C: AsContextMut>(
     mut ctx: C,
     get_export: impl Fn(&mut C, &str) -> Option<Extern>,
@@ -155,6 +160,7 @@ pub fn hl_param_to_val<C: AsContextMut>(
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub fn val_to_hl_result<C: AsContextMut>(
     mut ctx: C,
     get_export: impl Fn(&mut C, &str) -> Option<Extern>,
@@ -198,6 +204,7 @@ pub fn val_to_hl_result<C: AsContextMut>(
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub fn val_to_hl_param<'a, C: AsContextMut>(
     ctx: &mut C,
     get_export: impl Fn(&mut C, &str) -> Option<Extern>,
@@ -248,6 +255,7 @@ pub fn val_to_hl_param<'a, C: AsContextMut>(
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub fn hl_return_to_val<C: AsContextMut>(
     ctx: &mut C,
     get_export: impl Fn(&mut C, &str) -> Option<Extern>,
diff --git a/src/wasm_runtime/src/module.rs b/src/wasm_runtime/src/module.rs
@@ -39,6 +39,7 @@ static CUR_LINKER: Mutex<Option<Linker<()>>> = Mutex::new(None);
 static CUR_MODULE: Mutex<Option<Module>> = Mutex::new(None);
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub fn guest_dispatch_function(function_call: &FunctionCall) -> Result<Vec<u8>> {
     let engine = CUR_ENGINE.lock();
     let engine = engine.deref().as_ref().ok_or(HyperlightGuestError::new(
@@ -87,6 +88,7 @@ pub fn guest_dispatch_function(function_call: &FunctionCall) -> Result<Vec<u8>>
     )
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn init_wasm_runtime() -> Result<Vec<u8>> {
     let mut config = Config::new();
     config.with_custom_code_memory(Some(alloc::sync::Arc::new(platform::WasmtimeCodeMemory {})));
@@ -114,6 +116,7 @@ fn init_wasm_runtime() -> Result<Vec<u8>> {
     Ok(get_flatbuffer_result::<i32>(0))
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if let (
         ParameterValue::VecBytes(ref wasm_bytes),
@@ -135,6 +138,7 @@ fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if let (ParameterValue::ULong(ref phys), ParameterValue::ULong(ref len), Some(ref engine)) = (
         &function_call.parameters.as_ref().unwrap()[0],
@@ -154,6 +158,7 @@ fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {
 
 #[no_mangle]
 #[allow(clippy::fn_to_numeric_cast)] // GuestFunctionDefinition expects a function pointer as i64
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn hyperlight_main() {
     platform::register_page_fault_handler();
 
diff --git a/src/wasm_runtime/src/platform.rs b/src/wasm_runtime/src/platform.rs
@@ -26,6 +26,8 @@ use hyperlight_guest_bin::paging;
 // we start at
 // 0x100_0000_0000 and go up from there
 static FIRST_VADDR: AtomicU64 = AtomicU64::new(0x100_0000_0000u64);
+
+#[hyperlight_guest_tracing::trace_function]
 fn page_fault_handler(
     _exception_number: u64,
     info: *mut handler::ExceptionInfo,
@@ -54,6 +56,8 @@ fn page_fault_handler(
     }
     false
 }
+
+#[hyperlight_guest_tracing::trace_function]
 pub(crate) fn register_page_fault_handler() {
     // On amd64, vector 14 is #PF
     // See AMD64 Architecture Programmer's Manual, Volume 2
@@ -70,6 +74,7 @@ pub(crate) fn register_page_fault_handler() {
  * page-fault handling to hardcoded check if memory is in this region
  * (see above) */
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_mmap_new(_size: usize, _prot_flags: u32, ret: &mut *mut u8) -> i32 {
     if _size > 0x100_0000_0000 {
         panic!("wasmtime_mmap_{:x} {:x}", _size, _prot_flags);
@@ -83,6 +88,7 @@ pub extern "C" fn wasmtime_mmap_new(_size: usize, _prot_flags: u32, ret: &mut *m
  * the same), or possibly for changing permissions, which will be a no-op
  * as we don't properly implement permissions at the moment. */
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_mmap_remap(addr: *mut u8, size: usize, prot_flags: u32) -> i32 {
     if size > 0x100_0000_0000 {
         panic!(
@@ -94,12 +100,14 @@ pub extern "C" fn wasmtime_mmap_remap(addr: *mut u8, size: usize, prot_flags: u3
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_munmap(_ptr: *mut u8, _size: usize) -> i32 {
     0
 }
 
 /* TODO: implement permissions properly */
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_mprotect(_ptr: *mut u8, _size: usize, prot_flags: u32) -> i32 {
     /* currently all memory is allocated RWX; we assume that
      * restricting to R or RX can be ignored */
@@ -110,6 +118,7 @@ pub extern "C" fn wasmtime_mprotect(_ptr: *mut u8, _size: usize, prot_flags: u32
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_page_size() -> usize {
     unsafe { hyperlight_guest_bin::OS_PAGE_SIZE as usize }
 }
@@ -118,6 +127,8 @@ pub extern "C" fn wasmtime_page_size() -> usize {
 type wasmtime_trap_handler_t =
     extern "C" fn(ip: usize, fp: usize, has_faulting_addr: bool, faulting_addr: usize);
 static WASMTIME_REQUESTED_TRAP_HANDLER: AtomicU64 = AtomicU64::new(0);
+
+#[hyperlight_guest_tracing::trace_function]
 fn wasmtime_trap_handler(
     exception_number: u64,
     info: *mut handler::ExceptionInfo,
@@ -149,6 +160,7 @@ fn wasmtime_trap_handler(
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_init_traps(handler: wasmtime_trap_handler_t) -> i32 {
     WASMTIME_REQUESTED_TRAP_HANDLER.store(handler as usize as u64, Ordering::Relaxed);
     // On amd64, vector 6 is #UD
@@ -168,6 +180,7 @@ pub extern "C" fn wasmtime_init_traps(handler: wasmtime_trap_handler_t) -> i32 {
 
 // The wasmtime_memory_image APIs are not yet supported.
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_memory_image_new(
     _ptr: *const u8,
     _len: usize,
@@ -178,6 +191,7 @@ pub extern "C" fn wasmtime_memory_image_new(
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_memory_image_map_at(
     _image: *mut c_void,
     _addr: *mut u8,
@@ -189,6 +203,7 @@ pub extern "C" fn wasmtime_memory_image_map_at(
 }
 
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_memory_image_free(_image: *mut c_void) {
     /* This should never be called because wasmtime_memory_image_new
      * returns NULL */
@@ -198,11 +213,15 @@ pub extern "C" fn wasmtime_memory_image_free(_image: *mut c_void) {
 /* Because we only have a single thread in the guest at the moment, we
  * don't need real thread-local storage. */
 static FAKE_TLS: AtomicPtr<u8> = AtomicPtr::new(core::ptr::null_mut());
+
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_tls_get() -> *mut u8 {
     FAKE_TLS.load(Ordering::Acquire)
 }
+
 #[no_mangle]
+#[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn wasmtime_tls_set(ptr: *mut u8) {
     FAKE_TLS.store(ptr, Ordering::Release)
 }
@@ -229,6 +248,7 @@ impl wasmtime::CustomCodeMemory for WasmtimeCodeMemory {
     }
 }
 
+#[hyperlight_guest_tracing::trace_function]
 pub(crate) unsafe fn map_buffer(phys: u64, len: u64) -> NonNull<[u8]> {
     // TODO: Use a VA allocator
     let virt = phys as *mut u8;

Original file line number	Diff line number	Diff line change
`@@ -43,10 +43,12 @@ static CUR_INSTANCE: Mutex<Option<Instance>> = Mutex::new(None);`
`43`	`43`	`hyperlight_wasm_macro::wasm_guest_bindgen!();`
`44`	`44`
`45`	`45`	`// dummy for compatibility with the module loading approach`
	`46`	`+#[hyperlight_guest_tracing::trace_function]`
`46`	`47`	`fn init_wasm_runtime(_function_call: &FunctionCall) -> Result<Vec<u8>> {`
`47`	`48`	`Ok(get_flatbuffer_result::<i32>(0))`
`48`	`49`	`}`
`49`	`50`
	`51`	`+#[hyperlight_guest_tracing::trace_function]`
`50`	`52`	`fn load_component_common(engine: &Engine, component: Component) -> Result<()> {`
`51`	`53`	`let mut store = Store::new(engine, ());`
`52`	`54`	`let instance = (*CUR_LINKER.lock())`
`@@ -58,6 +60,7 @@ fn load_component_common(engine: &Engine, component: Component) -> Result<()> {`
`58`	`60`	`Ok(())`
`59`	`61`	`}`
`60`	`62`
	`63`	`+#[hyperlight_guest_tracing::trace_function]`
`61`	`64`	`fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {`
`62`	`65`	`if let (`
`63`	`66`	`ParameterValue::VecBytes(ref wasm_bytes),`
`@@ -79,6 +82,7 @@ fn load_wasm_module(function_call: &FunctionCall) -> Result<Vec<u8>> {`
`79`	`82`	`}`
`80`	`83`	`}`
`81`	`84`
	`85`	`+#[hyperlight_guest_tracing::trace_function]`
`82`	`86`	`fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {`
`83`	`87`	`if let (ParameterValue::ULong(ref phys), ParameterValue::ULong(ref len), Some(ref engine)) = (`
`84`	`88`	`&function_call.parameters.as_ref().unwrap()[0],`
`@@ -98,6 +102,7 @@ fn load_wasm_module_phys(function_call: &FunctionCall) -> Result<Vec<u8>> {`
`98`	`102`	`}`
`99`	`103`
`100`	`104`	`#[no_mangle]`
	`105`	`+#[hyperlight_guest_tracing::trace_function]`
`101`	`106`	`pub extern "C" fn hyperlight_main() {`
`102`	`107`	`platform::register_page_fault_handler();`
`103`	`108`
`@@ -131,6 +136,7 @@ pub extern "C" fn hyperlight_main() {`
`131`	`136`	`}`
`132`	`137`
`133`	`138`	`#[no_mangle]`
	`139`	`+#[hyperlight_guest_tracing::trace_function]`
`134`	`140`	`pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {`
`135`	`141`	`Err(HyperlightGuestError::new(`
`136`	`142`	`ErrorCode::GuestFunctionNotFound,`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ pub(crate) fn get_host_function_details() -> HostFunctionDetails {`
`36`	`36`	`hyperlight_guest_bin::host_comm::get_host_function_details()`
`37`	`37`	`}`
`38`	`38`
	`39`	`+#[hyperlight_guest_tracing::trace_function]`
`39`	`40`	`pub(crate) fn hostfunc_type(d: &HostFunctionDefinition, e: &Engine) -> Result<FuncType> {`
`40`	`41`	`let mut params = Vec::new();`
`41`	`42`	`let mut last_was_vec = false;`
`@@ -79,6 +80,7 @@ pub(crate) fn hostfunc_type(d: &HostFunctionDefinition, e: &Engine) -> Result<Fu`
`79`	`80`	`Ok(FuncType::new(e, params, results))`
`80`	`81`	`}`
`81`	`82`
	`83`	`+#[hyperlight_guest_tracing::trace_function]`
`82`	`84`	`pub(crate) fn call(`
`83`	`85`	`d: &HostFunctionDefinition,`
`84`	`86`	`mut c: Caller<'_, ()>,`
`@@ -115,6 +117,7 @@ pub(crate) fn call(`
`115`	`117`	`Ok(())`
`116`	`118`	`}`
`117`	`119`
	`120`	`+#[hyperlight_guest_tracing::trace_function]`
`118`	`121`	`fn return_type_from_val(val: &ReturnValue) -> ReturnType {`
`119`	`122`	`match val {`
`120`	`123`	`ReturnValue::Int(_) => ReturnType::Int,`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;`
`29`	`29`	`use hyperlight_guest::error::{HyperlightGuestError, Result};`
`30`	`30`	`use wasmtime::{AsContextMut, Extern, Val};`
`31`	`31`
	`32`	`+#[hyperlight_guest_tracing::trace_function]`
`32`	`33`	`fn malloc<C: AsContextMut>(`
`33`	`34`	`ctx: &mut C,`
`34`	`35`	`get_export: &impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -46,6 +47,7 @@ fn malloc<C: AsContextMut>(`
`46`	`47`	`Ok(addr)`
`47`	`48`	`}`
`48`	`49`
	`50`	`+#[hyperlight_guest_tracing::trace_function]`
`49`	`51`	`fn write<C: AsContextMut>(`
`50`	`52`	`ctx: &mut C,`
`51`	`53`	`get_export: &impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -67,6 +69,7 @@ fn write<C: AsContextMut>(`
`67`	`69`	`Ok(())`
`68`	`70`	`}`
`69`	`71`
	`72`	`+#[hyperlight_guest_tracing::trace_function]`
`70`	`73`	`fn read<C: AsContextMut>(`
`71`	`74`	`ctx: &mut C,`
`72`	`75`	`get_export: &impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -88,6 +91,7 @@ fn read<C: AsContextMut>(`
`88`	`91`	`Ok(())`
`89`	`92`	`}`
`90`	`93`
	`94`	`+#[hyperlight_guest_tracing::trace_function]`
`91`	`95`	`fn read_cstr<C: AsContextMut>(`
`92`	`96`	`ctx: &mut C,`
`93`	`97`	`get_export: &impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -126,6 +130,7 @@ fn read_cstr<C: AsContextMut>(`
`126`	`130`	`})`
`127`	`131`	`}`
`128`	`132`
	`133`	`+#[hyperlight_guest_tracing::trace_function]`
`129`	`134`	`pub fn hl_param_to_val<C: AsContextMut>(`
`130`	`135`	`mut ctx: C,`
`131`	`136`	`get_export: impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -155,6 +160,7 @@ pub fn hl_param_to_val<C: AsContextMut>(`
`155`	`160`	`}`
`156`	`161`	`}`
`157`	`162`
	`163`	`+#[hyperlight_guest_tracing::trace_function]`
`158`	`164`	`pub fn val_to_hl_result<C: AsContextMut>(`
`159`	`165`	`mut ctx: C,`
`160`	`166`	`get_export: impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -198,6 +204,7 @@ pub fn val_to_hl_result<C: AsContextMut>(`
`198`	`204`	`}`
`199`	`205`	`}`
`200`	`206`
	`207`	`+#[hyperlight_guest_tracing::trace_function]`
`201`	`208`	`pub fn val_to_hl_param<'a, C: AsContextMut>(`
`202`	`209`	`ctx: &mut C,`
`203`	`210`	`get_export: impl Fn(&mut C, &str) -> Option<Extern>,`
`@@ -248,6 +255,7 @@ pub fn val_to_hl_param<'a, C: AsContextMut>(`
`248`	`255`	`}`
`249`	`256`	`}`
`250`	`257`
	`258`	`+#[hyperlight_guest_tracing::trace_function]`
`251`	`259`	`pub fn hl_return_to_val<C: AsContextMut>(`
`252`	`260`	`ctx: &mut C,`
`253`	`261`	`get_export: impl Fn(&mut C, &str) -> Option<Extern>,`