feat(opentmk): opentmk framework with first testcase

Cargo.lock

@@ -3547,6 +3547,9 @@ name = "lazy_static"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+dependencies = [
+ "spin 0.5.2",
+]
 
 [[package]]
 name = "libc"
@@ -3609,6 +3612,15 @@ dependencies = [
  "escape8259",
 ]
 
+[[package]]
+name = "linked_list_allocator"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afa463f5405ee81cdb9cc2baf37e08ec7e4c8209442b5d72c04cfb2cd6e6286"
+dependencies = [
+ "spinning_top",
+]
+
 [[package]]
 name = "linkme"
 version = "0.3.31"
@@ -4769,6 +4781,27 @@ dependencies = [
  "thiserror 2.0.0",
 ]
 
+[[package]]
+name = "opentmk"
+version = "0.0.0"
+dependencies = [
+ "arrayvec",
+ "bitfield-struct",
+ "cfg-if",
+ "hvdef",
+ "lazy_static",
+ "linked_list_allocator",
+ "memory_range",
+ "minimal_rt",
+ "minimal_rt_build",
+ "serde",
+ "serde_json",
+ "spin 0.10.0",
+ "uefi",
+ "x86_64",
+ "zerocopy 0.8.14",
+]
+
 [[package]]
 name = "openvmm"
 version = "0.0.0"
@@ -6360,6 +6393,30 @@ dependencies = [
  "zerocopy 0.8.14",
 ]
 
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spin"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spinning_top"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b9eb1a2f4c41445a3a0ff9abc5221c5fcd28e1f13cd7c0397706f9ac938ddb0"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "stackfuture"
 version = "0.3.0"
@@ -8736,6 +8793,12 @@ dependencies = [
  "vmsocket",
 ]
 
+[[package]]
+name = "volatile"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442887c63f2c839b346c192d047a7c87e73d0689c9157b00b53dcc27dd5ea793"
+
 [[package]]
 name = "vpci"
 version = "0.0.0"
@@ -9313,6 +9376,18 @@ dependencies = [
  "tap",
 ]
 
+[[package]]
+name = "x86_64"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f042214de98141e9c8706e8192b73f56494087cc55ebec28ce10f26c5c364ae"
+dependencies = [
+ "bit_field",
+ "bitflags 2.6.0",
+ "rustversion",
+ "volatile",
+]
+
 [[package]]
 name = "x86defs"
 version = "0.0.0"

Cargo.toml

@@ -42,6 +42,7 @@ members = [
   "vm/loader/igvmfilegen",
   "vm/vmgs/vmgs_lib",
   "vm/vmgs/vmgstool",
+  "opentmk"
 ]
 exclude = [
   "xsync",
@@ -525,6 +526,7 @@ xshell-macros = "0.2"
 # We add the derive feature here since the vast majority of our crates use it.
 #zerocopy = { version = "0.7.32", features = ["derive"]}
 zerocopy = { version = "0.8.14", features = ["derive"]}
+linked_list_allocator = "0.10.5"
 
 [workspace.metadata.xtask.unused-deps]
 # Pulled in through "tracing", but we need to pin the version

opentmk/Cargo.toml

@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+[package]
+name = "opentmk"
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+uefi = { workspace = true, features = ["alloc"] }
+minimal_rt.workspace = true
+linked_list_allocator = { workspace = true }
+hvdef = {workspace = true}
+zerocopy = {workspace = true}
+memory_range = { workspace = true }
+arrayvec = {workspace = true}
+cfg-if.workspace  = true
+bitfield-struct.workspace = true
+x86_64 = "0.15.2"
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+spin = "0.10.0"
+serde = {version = "1.0", default-features = false}
+[lints]
+workspace = true
+
+[build-dependencies]
+minimal_rt_build.workspace = true
+
+[profile.release]
+debug = false
+strip = "debuginfo"

opentmk/README.md

@@ -0,0 +1,3 @@
+# `guest_test_uefi`
+
+See the guide for more info on how to build/run the code in this crate.

opentmk/build_deploy.sh

@@ -0,0 +1,3 @@
+RUST_BACKTRACE=1 cargo build -p opentmk --target x86_64-unknown-uefi
+cargo xtask guest-test uefi --bootx64 ./target/x86_64-unknown-uefi/debug/opentmk.efi
+qemu-img convert -f raw -O vhdx ./target/x86_64-unknown-uefi/debug/opentmk.img  ~/projects/opentmk.vhdx

opentmk/src/arch/aarch64/hypercall.rs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/// Writes a synthehtic register to tell the hypervisor the OS ID for the boot shim.
+fn report_os_id(guest_os_id: u64) {
+    // On ARM64, to be able to make hypercalls, one needs first to set the Guest OS ID
+    // synthetic register using a hypercall. Can't use `Hvcall::set_register` at that will
+    // lead to the infinite recursion as that function will first try initializing hypercalls
+    // with setting a register.
+    //
+    // Only one very specific HvSetVpRegisters hypercall is allowed to set the Guest OS ID
+    // (this is TLFS section 17.4.4.1.1 and 5.3), and that must be the fast hypercall.
+    let _ = minimal_rt::arch::hypercall::set_register_fast(
+        hvdef::HvArm64RegisterName::GuestOsId.into(),
+        guest_os_id.into(),
+    );
+}
+
+pub(crate) fn initialize(guest_os_id: u64) {
+    // We are assuming we are running under a Microsoft hypervisor.
+    report_os_id(guest_os_id);
+}
+
+/// Call before jumping to kernel.
+pub(crate) fn uninitialize() {
+    report_os_id(0);
+}

opentmk/src/arch/aarch64/mod.rs

@@ -0,0 +1,3 @@
+pub use minimal_rt::arch::aarch64::serial;
+
+pub mod hypercall;

opentmk/src/arch/mod.rs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+//! Imports and re-exports architecture-specific implementations.
+
+mod x86_64;
+
+cfg_if::cfg_if!(
+    if #[cfg(target_arch = "x86_64")] {
+        pub use x86_64::*;
+    } else if #[cfg(target_arch = "aarch64")] {
+        pub use aarch64::*;
+    } else {
+        compile_error!("target_arch is not supported");
+    }
+);

opentmk/src/arch/x86_64/hypercall.rs

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use core::ptr::addr_of;
+use hvdef::HV_PAGE_SIZE;
+use minimal_rt::arch::hypercall::HYPERCALL_PAGE;
+use minimal_rt::arch::msr::read_msr;
+use minimal_rt::arch::msr::write_msr;
+#[expect(unsafe_code)]
+/// Writes an MSR to tell the hypervisor the OS ID for the boot shim.
+fn report_os_id(guest_os_id: u64) {
+    // SAFETY: Using the contract established in the Hyper-V TLFS.
+    unsafe {
+        write_msr(hvdef::HV_X64_MSR_GUEST_OS_ID, guest_os_id);
+    };
+}
+
+#[expect(unsafe_code)]
+/// Writes an MSR to tell the hypervisor where the hypercall page is
+pub fn write_hypercall_msr(enable: bool) {
+    // SAFETY: Using the contract established in the Hyper-V TLFS.
+    let hypercall_contents = hvdef::hypercall::MsrHypercallContents::from(unsafe {
+        read_msr(hvdef::HV_X64_MSR_HYPERCALL)
+    });
+
+    let hypercall_page_num = addr_of!(HYPERCALL_PAGE) as u64 / HV_PAGE_SIZE;
+
+    if!(!enable || !hypercall_contents.enable()) {
+        return;
+    }
+    let new_hv_contents: hvdef::hypercall::MsrHypercallContents = hypercall_contents.with_enable(enable).with_gpn(if enable {
+        hypercall_page_num
+    } else {
+        0
+    });
+
+    // SAFETY: Using the contract established in the Hyper-V TLFS.
+    unsafe { write_msr(hvdef::HV_X64_MSR_HYPERCALL, new_hv_contents.into()) };
+}
+
+/// Has to be called before using hypercalls.
+pub(crate) fn initialize(guest_os_id: u64) {
+    // We are assuming we are running under a Microsoft hypervisor, so there is
+    // no need to check any cpuid leaves.
+    report_os_id(guest_os_id);
+    write_hypercall_msr(true);
+}
+
+/// Call before jumping to kernel.
+pub(crate) fn uninitialize() {
+    write_hypercall_msr(false);
+    report_os_id(0);
+}

opentmk/src/arch/x86_64/interrupt.rs

@@ -0,0 +1,50 @@
+
+use alloc::boxed::Box;
+use alloc::sync::Arc;
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
+use lazy_static::lazy_static;
+use core::cell::{Ref, RefCell};
+use core::concat_idents;
+use crate::sync::Mutex;
+
+use crate::{criticallog, infolog};
+
+use super::interrupt_handler_register::{register_interrupt_handler, set_common_handler};
+
+lazy_static! {
+    static ref IDT: InterruptDescriptorTable = {
+        let mut idt = InterruptDescriptorTable::new();
+        register_interrupt_handler(&mut idt);
+        idt.double_fault.set_handler_fn(handler_double_fault);
+        idt
+    };
+}
+
+static mut HANDLERS : [fn(); 256] = [no_op; 256];
+static MUTEX: Mutex<()> = Mutex::new(());
+fn no_op() {}
+
+fn common_handler(stack_frame: InterruptStackFrame, interrupt: u8) {
+    unsafe { HANDLERS[interrupt as usize](); }
+}
+
+pub fn set_handler(interrupt: u8, handler: fn()) {
+    let _lock = MUTEX.lock();
+    unsafe { HANDLERS[interrupt as usize] = handler; }
+}
+
+
+extern "x86-interrupt" fn handler_double_fault(
+    stack_frame: InterruptStackFrame,
+    _error_code: u64,
+) -> ! {
+    criticallog!("EXCEPTION:\n\tERROR_CODE: {}\n\tDOUBLE FAULT\n{:#?}", _error_code, stack_frame);
+    loop {}
+}
+
+// Initialize the IDT
+pub fn init() {
+    unsafe { IDT.load() };
+    set_common_handler(common_handler);
+    unsafe { x86_64::instructions::interrupts::enable() };
+}