[interrupt-handlers] added GDT/GDTR

- added GdtEntry struct for GDT static mut global var,
- added null, kernel code, and kernel data segments to GDT,
- added code to load the GDT, and
- added calls to init_idt, load_idt, and load_gdt to entrypoint.

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

Author: danbugs

src/hyperlight_guest/src/entrypoint.rs

@@ -30,6 +30,9 @@ use crate::{
     __security_cookie, HEAP_ALLOCATOR, MIN_STACK_ADDRESS, OS_PAGE_SIZE, OUTB_PTR,
     OUTB_PTR_WITH_CONTEXT, P_PEB, RUNNING_MODE,
 };
+use crate::gdt::load_gdt;
+use crate::idt::init_idt;
+use crate::idtr::load_idt;
 
 #[inline(never)]
 pub fn halt() {
@@ -86,6 +89,14 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
             let peb_ptr = P_PEB.unwrap();
             __security_cookie = peb_address ^ seed;
 
+            // Set up GDT/IDT
+            load_gdt();
+            init_idt();
+            load_idt();
+
+            // Enable interrupts
+            asm!("sti", options(nostack));
+
             let srand_seed = ((peb_address << 8 ^ seed >> 4) >> 32) as u32;
 
             // Set the seed for the random number generator for C code using rand;

src/hyperlight_guest/src/gdt.rs

@@ -0,0 +1,90 @@
+/*
+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::ptr::addr_of;
+
+/// Entry in the Global Descriptor Table (GDT)
+/// For reference, see: https://wiki.osdev.org/Global_Descriptor_Table
+#[repr(C, align(8))]
+pub struct GdtEntry {
+    limit_low: u16,
+    base_low: u16,
+    base_middle: u8,
+    access: u8,
+    flags_limit: u8,
+    base_high: u8,
+}
+
+impl GdtEntry {
+    /// Creates a new GDT entry.
+    pub const fn new(base: u32, limit: u32, access: u8, flags: u8) -> Self {
+        Self {
+            base_low: (base & 0xffff) as u16,
+            base_middle: ((base >> 16) & 0xff) as u8,
+            base_high: ((base >> 24) & 0xff) as u8,
+            limit_low: (limit & 0xffff) as u16,
+            flags_limit: (((limit >> 16) & 0x0f) as u8) | ((flags & 0x0f) << 4),
+            access,
+        }
+    }
+}
+
+// Global Descriptor Table (GDT)
+// For reference, see: https://wiki.osdev.org/GDT_Tutorial#What_to_Put_In_a_GDT
+static mut GDT: [GdtEntry; 3] = [
+    // Null descriptor
+    GdtEntry::new(0, 0, 0, 0),
+
+    // Kernel Code Segment (0x08)
+    GdtEntry::new(0, 0, 0x9A, 0xA),
+
+    // Kernel Data Segment (0x10)
+    GdtEntry::new(0, 0, 0x92, 0xC),
+];
+
+/// GDTR (GDT pointer)
+#[repr(C, packed)]
+struct GdtPointer {
+    size: u16,
+    base: u64,
+}
+
+/// Load the GDT
+pub unsafe fn load_gdt() {
+    let gdt_ptr = GdtPointer {
+        size: (core::mem::size_of::<[GdtEntry; 3]>() - 1) as u16,
+        base: addr_of!(GDT) as *const _ as u64,
+    };
+
+    asm!(
+    "lgdt [{0}]",
+    "mov ax, 0x10",        // Load data segment registers
+    "mov ds, ax",
+    "mov es, ax",
+    "mov fs, ax",
+    "mov gs, ax",
+    "mov ss, ax",
+    "push 0x08",            // Push CS (kernel code segment)
+    "lea rax, [2f + rip]",  // Load the next instruction's address
+    "push rax",             // Push address onto stack
+    "retfq",                // Far return to update CS
+    "2:",                   // Label for continued execution
+    in(reg) &gdt_ptr,
+    options(nostack, preserves_flags)
+    );
+}
+

src/hyperlight_guest/src/lib.rs

@@ -55,6 +55,7 @@ pub mod interrupt_entry;
 pub mod interrupt_handlers;
 pub mod idt;
 pub mod idtr;
+pub mod gdt;
 
 // Unresolved symbols
 ///cbindgen:ignore