[guest,guest_bin] created GuestHandle and moved entrypoint + guest_logger + exceptions + guest function logic + guest_err

- moved entrypoint to guest_bin library. W/ this, I also moved a lot of things that were only used via the entrypoint:
-- IDT/GDT setup for exceptions.
-- guest_logger.

- w/ the entrypoint fxn from the guest lib having moved, I re-named that module to 'exit' as it still contains stuff for
aborting guest execution. I also moved OUT functions there like 'outb' and 'out32'.

- a lot of our public functions in the guest lib, like, for example, push_shared_output_data relied on a pub(crate) global
(i.e., P_PEB) being set. W/ that only ever being set in the entrypoint and w/ it not being appropriate as pub, I created a
GuestHandle struct. This struct houses a *mut HyperlightPEB that operations like push_shared_output_data can leverage.
bin-like crates can then create their own GuestHandle globals and use its functionality like self.push_shared_output_data(...).

- moved all out guest function defintion, registration and so on to the guest_bin crate.

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

Author: danbugs

Cargo.lock

@@ -20,10 +20,7 @@ printf = [] # compile printf
 [dependencies]
 anyhow = { version = "1.0.98", default-features = false }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
-buddy_system_allocator = "0.11.0"
 hyperlight-common = { workspace = true }
-spin = "0.10.0"
-log = { version = "0.4", default-features = false }
 
 [build-dependencies]
 cc = "1.2"

src/hyperlight_guest/Cargo.toml

@@ -0,0 +1,100 @@
+/*
+Copyright 2024 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use core::arch::asm;
+use core::ffi::{c_char, CStr};
+
+use hyperlight_common::outb::OutBAction;
+
+/// Halt the execution of the guest and returns control to the host.
+#[inline(never)]
+pub fn halt() {
+    unsafe { asm!("hlt", options(nostack)) }
+}
+
+/// Exits the VM with an Abort OUT action and code 0.
+#[unsafe(no_mangle)]
+pub extern "C" fn abort() -> ! {
+    abort_with_code(&[0, 0xFF])
+}
+
+/// Exits the VM with an Abort OUT action and a specific code.
+pub fn abort_with_code(code: &[u8]) -> ! {
+    outb(OutBAction::Abort as u16, code);
+    outb(OutBAction::Abort as u16, &[0xFF]); // send abort terminator (if not included in code)
+    unreachable!()
+}
+
+/// Aborts the program with a code and a message.
+///
+/// # Safety
+/// This function is unsafe because it dereferences a raw pointer.
+pub unsafe fn abort_with_code_and_message(code: &[u8], message_ptr: *const c_char) -> ! {
+    unsafe {
+        // Step 1: Send abort code (typically 1 byte, but `code` allows flexibility)
+        outb(OutBAction::Abort as u16, code);
+
+        // Step 2: Convert the C string to bytes
+        let message_bytes = CStr::from_ptr(message_ptr).to_bytes(); // excludes null terminator
+
+        // Step 3: Send the message itself in chunks
+        outb(OutBAction::Abort as u16, message_bytes);
+
+        // Step 4: Send abort terminator to signal completion (e.g., 0xFF)
+        outb(OutBAction::Abort as u16, &[0xFF]);
+
+        // This function never returns
+        unreachable!()
+    }
+}
+
+/// OUT bytes to the host through multiple exits.
+pub(crate) fn outb(port: u16, data: &[u8]) {
+    unsafe {
+        let mut i = 0;
+        while i < data.len() {
+            let remaining = data.len() - i;
+            let chunk_len = remaining.min(3);
+            let mut chunk = [0u8; 4];
+            chunk[0] = chunk_len as u8;
+            chunk[1..1 + chunk_len].copy_from_slice(&data[i..i + chunk_len]);
+            let val = u32::from_le_bytes(chunk);
+            out32(port, val);
+            i += chunk_len;
+        }
+    }
+}
+
+/// OUT function for sending a 32-bit value to the host.
+pub(crate) unsafe fn out32(port: u16, val: u32) {
+    unsafe {
+        asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack));
+    }
+}
+
+/// Prints a message using `OutBAction::DebugPrint`. It transmits bytes of a message
+/// through several VMExists and, with such, it is slower than
+/// `print_output_with_host_print`.
+///
+/// This function should be used in debug mode only. This function does not
+/// require memory to be setup to be used.
+pub fn debug_print(msg: &str) {
+    for byte in msg.bytes() {
+        unsafe {
+            out32(OutBAction::DebugPrint as u16, byte as u32);
+        }
+    }
+}

src/hyperlight_guest/src/entrypoint.rs

@@ -0,0 +1,48 @@
+/*
+Copyright 2024 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use hyperlight_common::mem::HyperlightPEB;
+
+/// A guest handle holds the `HyperlightPEB` and enables the guest to perform
+/// operations like:
+/// - calling host functions,
+/// - accessing shared input and output buffers,
+/// - writing errors,
+/// - etc.
+///
+/// Guests are expected to initialize this and store it. For example, you
+/// could store it in a global variable.
+#[derive(Debug, Clone, Copy)]
+pub struct GuestHandle {
+    peb: Option<*mut HyperlightPEB>,
+}
+
+impl GuestHandle {
+    /// Creates a new uninitialized guest state.
+    pub const fn new() -> Self {
+        Self { peb: None }
+    }
+
+    /// Initializes the guest state with a given PEB pointer.
+    pub fn init(peb: *mut HyperlightPEB) -> Self {
+        Self { peb: Some(peb) }
+    }
+
+    /// Returns the PEB pointer
+    pub fn peb(&self) -> Option<*mut HyperlightPEB> {
+        self.peb
+    }
+}