fix: get rid of host function probe

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

Author: andreiltd

docs/picolibc.md

@@ -13,25 +13,35 @@ script compiles picolibc from source using the vendored submodule at
 `src/hyperlight_guest_bin/third_party/picolibc`.
 
 The build uses a sparse checkout to exclude GPL/AGPL-licensed test and script
-files — only BSD/MIT/permissive-licensed source files are included. See
+files and only BSD/MIT/permissive-licensed source files are included. See
 `NOTICE.txt` for full licensing details.
 
 ## Host Function Stubs
 
 When the `libc` feature is enabled, the POSIX stubs in
-`src/hyperlight_guest_bin/src/host_bridge.rs` provide C-compatible
+`src/hyperlight_guest_bin/src/libc.rs` provide C-compatible
 implementations of `read`, `write`, `clock_gettime`, `gettimeofday`, and
 other functions that picolibc calls internally.
 
-These stubs can optionally delegate to host functions. If the host registers
-these functions, the corresponding libc functionality becomes available to
-guest code. If not registered, the stubs return appropriate errors.
+### Read (stdin)
 
-| Host Function   | Parameters             | Return Type | Description |
-|-----------------|------------------------|-------------|-------------|
-| `HostPrint`     | `String`               | `Int`       | Used by the `write()` stub. Only stdout (fd 1) and stderr (fd 2) are supported; both delegate to this single host function. Other file descriptors return `EBADF`. |
-| `HostRead`      | `ULong` (byte count)   | `VecBytes`  | Used by the `read()` stub. Only stdin (fd 0) is supported; other file descriptors return `EBADF`. |
-| `CurrentTime`   | _(none)_               | `VecBytes`  | Used by `clock_gettime()` and `gettimeofday()`. Should return 16 bytes: 8 bytes of seconds + 8 bytes of nanoseconds. If not provided, a monotonic fallback starting at Unix timestamp `1609459200` (2021-01-01) is used. |
+The `read()` stub returns **EOF (0)** immediately for stdin (fd 0) without
+contacting the host. Other file descriptors return `EBADF`.
+
+### Write (stdout / stderr)
+
+The `write()` stub delegates to the `HostPrint` host function. Only stdout
+(fd 1) and stderr (fd 2) are supported; both map to the same `HostPrint`
+call, which accepts a `String` parameter and returns an `Int`. Other file
+descriptors return `EBADF`.
+
+### Time
+
+The `clock_gettime()`, `gettimeofday()`, and `_current_time()` stubs do
+**not** call out to the host. Instead they return a synthetic
+monotonically-increasing timestamp: the first call returns Unix epoch + 1 s
+(`1970-01-01 00:00:01`), the second returns epoch + 2 s, and so on. The
+nanosecond/microsecond component is always zero.
 
 ## Build Configuration
 

src/hyperlight_guest_bin/src/host_comm.rs

@@ -14,10 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use alloc::string::{String, ToString};
+use alloc::string::ToString;
 use alloc::vec::Vec;
-use core::ffi::{CStr, c_char};
-use core::mem;
 
 use hyperlight_common::flatbuffer_wrappers::function_call::FunctionCall;
 use hyperlight_common::flatbuffer_wrappers::function_types::{
@@ -28,9 +26,6 @@ use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
 use hyperlight_common::func::{ParameterTuple, SupportedReturnType};
 use hyperlight_guest::error::{HyperlightGuestError, Result};
 
-const BUFFER_SIZE: usize = 1000;
-static mut MESSAGE_BUFFER: Vec<u8> = Vec::new();
-
 use crate::GUEST_HANDLE;
 
 pub fn call_host_function<T>(
@@ -97,47 +92,3 @@ pub fn print_output_with_host_print(function_call: FunctionCall) -> Result<Vec<u
         ))
     }
 }
-
-/// Exposes a C API to allow the guest to print a string
-///
-/// # Safety
-/// This function is not thread safe
-#[unsafe(no_mangle)]
-#[allow(static_mut_refs)]
-pub unsafe extern "C" fn _putchar(c: c_char) {
-    let handle = unsafe { GUEST_HANDLE };
-    let char = c as u8;
-    let message_buffer = unsafe { &mut MESSAGE_BUFFER };
-
-    // Extend buffer capacity if it's empty (like `with_capacity` in lazy_static).
-    // TODO: replace above Vec::new() with Vec::with_capacity once it's stable in const contexts.
-    if message_buffer.capacity() == 0 {
-        message_buffer.reserve(BUFFER_SIZE);
-    }
-
-    message_buffer.push(char);
-
-    if message_buffer.len() == BUFFER_SIZE || char == b'\0' {
-        let str = if char == b'\0' {
-            CStr::from_bytes_until_nul(message_buffer)
-                .expect("No null byte in buffer")
-                .to_string_lossy()
-                .into_owned()
-        } else {
-            String::from_utf8(mem::take(message_buffer))
-                .expect("Failed to convert buffer to string")
-        };
-
-        // HostPrint returns an i32, but we don't care about the return value
-        let _ = handle
-            .call_host_function::<i32>(
-                "HostPrint",
-                Some(Vec::from(&[ParameterValue::String(str)])),
-                ReturnType::Int,
-            )
-            .expect("Failed to call HostPrint");
-
-        // Clear the buffer after sending
-        message_buffer.clear();
-    }
-}

src/hyperlight_guest_bin/src/lib.rs

@@ -53,7 +53,7 @@ pub mod paging;
 
 /// Bridge between picolibc's POSIX expectations and the Hyperlight host.
 #[cfg(feature = "libc")]
-mod host_bridge;
+mod libc;
 
 // Globals
 #[cfg(feature = "mem_profile")]

…/hyperlight_guest_bin/src/host_bridge.rs src/hyperlight_guest_bin/src/libc.rssrc/hyperlight_guest_bin/src/host_bridge.rs renamed to src/hyperlight_guest_bin/src/libc.rs src/hyperlight_guest_bin/src/host_bridge.rs renamed to src/hyperlight_guest_bin/src/libc.rs

@@ -16,7 +16,6 @@ limitations under the License.
 
 use alloc::string::String;
 use alloc::vec;
-use alloc::vec::Vec;
 use core::ffi::*;
 use core::sync::atomic::{AtomicU64, Ordering};
 
@@ -45,33 +44,25 @@ const CLOCK_MONOTONIC: c_ulong = 4;
 
 static CURRENT_TIME: AtomicU64 = AtomicU64::new(0);
 
-/// Matches picolibc `struct timespec` layout for x86_64.
+/// Matches picolibc `struct timespec` layout for x86_64 and aarch64.
 #[repr(C)]
 pub(crate) struct Timespec {
     tv_sec: c_long,
     tv_nsec: c_long,
 }
 
-/// Matches picolibc `struct timeval` layout for x86_64.
+/// Matches picolibc `struct timeval` layout for x86_64 and aarch64.
 #[repr(C)]
 pub(crate) struct Timeval {
     tv_sec: c_long,
     tv_usec: c_long,
 }
 
-/// Retrieves the current time from the host as (seconds, nanoseconds).
+/// Returns a synthetic monotonically-increasing time starting at Unix epoch
+/// increasing 1s each call.
 fn current_time() -> (u64, u64) {
-    let bytes = call_host_function::<Vec<u8>>("CurrentTime", Some(vec![]), ReturnType::VecBytes)
-        .unwrap_or_default();
-
-    if bytes.len() == 16 {
-        let secs = u64::from_ne_bytes(bytes[0..8].try_into().unwrap());
-        let nanos = u64::from_ne_bytes(bytes[8..16].try_into().unwrap());
-        (secs, nanos)
-    } else {
-        let secs = 1609459200 + CURRENT_TIME.fetch_add(1, Ordering::Relaxed);
-        (secs, 0)
-    }
+    let call_count = CURRENT_TIME.fetch_add(1, Ordering::Relaxed) + 1;
+    (call_count, 0)
 }
 
 #[unsafe(no_mangle)]
@@ -86,23 +77,9 @@ pub extern "C" fn read(fd: c_int, buf: *mut c_void, count: usize) -> isize {
         return -1;
     }
 
-    match call_host_function::<Vec<u8>>(
-        "HostRead",
-        Some(vec![ParameterValue::ULong(count as u64)]),
-        ReturnType::VecBytes,
-    ) {
-        Ok(bytes) => {
-            let n = bytes.len().min(count);
-            unsafe {
-                core::ptr::copy_nonoverlapping(bytes.as_ptr(), buf as *mut u8, n);
-            }
-            n as isize
-        }
-        Err(_) => {
-            set_errno(EIO);
-            -1
-        }
-    }
+    // Return EOF immediately — no host round-trip required.
+    let _ = (buf, count);
+    0
 }
 
 #[unsafe(no_mangle)]