Merge branch 'coconut-svsm:main' into main

Author: stefano-garzarella

kernel/src/cpu/idt/common.rs

@@ -4,22 +4,19 @@
 //
 // Author: Joerg Roedel <jroedel@suse.de>
 
-extern crate alloc;
-
 use crate::address::{Address, VirtAddr};
 use crate::cpu::control_regs::{read_cr0, read_cr4};
 use crate::cpu::efer::read_efer;
 use crate::cpu::gdt::GLOBAL_GDT;
 use crate::cpu::registers::{X86GeneralRegs, X86InterruptFrame};
 use crate::cpu::shadow_stack::is_cet_ss_enabled;
 use crate::error::SvsmError;
-use crate::insn_decode::{InsnError, InsnMachineCtx, InsnMachineMem, Register, SegRegister};
+use crate::insn_decode::{InsnError, InsnMachineCtx, Register, SegRegister};
 use crate::mm::ro_after_init::make_ro;
 use crate::mm::{GuestPtr, PAGE_SIZE, PageBox};
 use crate::platform::SVSM_PLATFORM;
 use crate::types::{Bytes, SVSM_CS};
 use crate::utils::{MemoryRegion, is_aligned};
-use alloc::boxed::Box;
 use core::arch::asm;
 use core::mem;
 use zerocopy::{FromBytes, IntoBytes};
@@ -100,6 +97,8 @@ impl X86ExceptionContext {
 }
 
 impl InsnMachineCtx for X86ExceptionContext {
+    type Ptr<T: FromBytes + IntoBytes> = GuestPtr<T>;
+
     fn read_efer(&self) -> u64 {
         read_efer().bits()
     }
@@ -171,16 +170,16 @@ impl InsnMachineCtx for X86ExceptionContext {
         self.frame.cs & 3
     }
 
-    fn map_linear_addr<T: FromBytes + IntoBytes + 'static>(
+    fn map_linear_addr<T: FromBytes + IntoBytes>(
         &self,
         la: usize,
         _write: bool,
         _fetch: bool,
-    ) -> Result<Box<dyn InsnMachineMem<Item = T>>, InsnError> {
+    ) -> Result<Self::Ptr<T>, InsnError> {
         if user_mode(self) {
             todo!();
         } else {
-            Ok(Box::new(GuestPtr::<T>::new(VirtAddr::from(la))))
+            Ok(GuestPtr::<T>::new(VirtAddr::from(la)))
         }
     }
 

kernel/src/insn_decode/decode.rs

@@ -39,16 +39,13 @@
 // https://github.com/projectacrn/acrn-hypervisor/blob/master/hypervisor/
 // arch/x86/guest/instr_emul.c
 
-extern crate alloc;
-
 use super::insn::{DecodedInsn, Immediate, MAX_INSN_SIZE, Operand};
 use super::opcode::{OpCodeClass, OpCodeDesc, OpCodeFlags};
 use super::{InsnError, Register, SegRegister};
 use crate::cpu::control_regs::{CR0Flags, CR4Flags};
 use crate::cpu::efer::EFERFlags;
 use crate::cpu::registers::{RFlags, SegDescAttrFlags};
 use crate::types::Bytes;
-use alloc::boxed::Box;
 use bitflags::bitflags;
 use zerocopy::{FromBytes, IntoBytes};
 
@@ -139,6 +136,8 @@ struct DecodedBytes(InsnBytes);
 /// instruction decoder can access specific registers and state that may
 /// influence the decoding from the machine (such as a CPU or VMM).
 pub trait InsnMachineCtx: core::fmt::Debug {
+    type Ptr<T: FromBytes + IntoBytes>: InsnMachineMem<T>;
+
     /// Read EFER register
     fn read_efer(&self) -> u64;
     /// Read a code segment register
@@ -179,14 +178,14 @@ pub trait InsnMachineCtx: core::fmt::Debug {
     ///
     /// # Returns
     ///
-    /// A `Result` containing a boxed trait object representing the mapped
-    /// memory, or an `InsnError` if mapping fails.
-    fn map_linear_addr<T: FromBytes + IntoBytes + 'static>(
+    /// A pointer-like type that allows reading and writing via [`InsnMachineMem`],
+    /// or an `InsnError` if mapping fails.
+    fn map_linear_addr<T: FromBytes + IntoBytes>(
         &self,
         _la: usize,
         _write: bool,
         _fetch: bool,
-    ) -> Result<Box<dyn InsnMachineMem<Item = T>>, InsnError> {
+    ) -> Result<Self::Ptr<T>, InsnError> {
         Err(InsnError::MapLinearAddr)
     }
 
@@ -312,9 +311,7 @@ pub trait InsnMachineCtx: core::fmt::Debug {
 }
 
 /// Trait representing a machine memory for instruction decoding.
-pub trait InsnMachineMem {
-    type Item;
-
+pub trait InsnMachineMem<T: FromBytes + IntoBytes> {
     /// Read data from the memory at the specified offset.
     ///
     /// # Safety
@@ -326,7 +323,7 @@ pub trait InsnMachineMem {
     ///
     /// Returns the read data on success, or an `InsnError` if the read
     /// operation fails.
-    unsafe fn mem_read(&self) -> Result<Self::Item, InsnError> {
+    unsafe fn mem_read(&self) -> Result<T, InsnError> {
         Err(InsnError::MemRead)
     }
 
@@ -344,7 +341,7 @@ pub trait InsnMachineMem {
     /// # Returns
     ///
     /// Returns `Ok`on success, or an `InsnError` if the write operation fails.
-    unsafe fn mem_write(&mut self, _data: Self::Item) -> Result<(), InsnError> {
+    unsafe fn mem_write(&mut self, _data: T) -> Result<(), InsnError> {
         Err(InsnError::MemWrite)
     }
 }

kernel/src/insn_decode/insn.rs

@@ -100,13 +100,10 @@ impl Instruction {
 
 #[cfg(any(test, fuzzing))]
 pub mod test_utils {
-    extern crate alloc;
-
     use crate::cpu::control_regs::{CR0Flags, CR4Flags};
     use crate::cpu::efer::EFERFlags;
     use crate::insn_decode::*;
     use crate::types::Bytes;
-    use alloc::boxed::Box;
     use zerocopy::{FromBytes, IntoBytes};
 
     pub const TEST_PORT: u16 = 0xE0;
@@ -174,12 +171,15 @@ pub mod test_utils {
         }
     }
 
+    #[derive(Debug, Clone, Copy)]
     #[cfg_attr(not(test), expect(dead_code))]
-    struct TestMem<T> {
+    pub struct TestMem<T> {
         ptr: *mut T,
     }
 
     impl InsnMachineCtx for TestCtx {
+        type Ptr<T: FromBytes + IntoBytes> = TestMem<T>;
+
         fn read_efer(&self) -> u64 {
             self.efer
         }
@@ -251,13 +251,13 @@ pub mod test_utils {
             self.flags
         }
 
-        fn map_linear_addr<T: FromBytes + IntoBytes + 'static>(
+        fn map_linear_addr<T: FromBytes + IntoBytes>(
             &self,
             la: usize,
             _write: bool,
             _fetch: bool,
-        ) -> Result<Box<dyn InsnMachineMem<Item = T>>, InsnError> {
-            Ok(Box::new(TestMem { ptr: la as *mut T }))
+        ) -> Result<Self::Ptr<T>, InsnError> {
+            Ok(TestMem { ptr: la as *mut T })
         }
 
         fn ioio_in(&self, _port: u16, size: Bytes) -> Result<u64, InsnError> {
@@ -345,13 +345,11 @@ pub mod test_utils {
     }
 
     #[cfg(test)]
-    impl<T: FromBytes + IntoBytes> InsnMachineMem for TestMem<T> {
-        type Item = T;
-
+    impl<T: FromBytes + IntoBytes> InsnMachineMem<T> for TestMem<T> {
         /// # Safety
         /// The caller is required to ensure the validity of the address
         /// this object was initialized with.
-        unsafe fn mem_read(&self) -> Result<Self::Item, InsnError> {
+        unsafe fn mem_read(&self) -> Result<T, InsnError> {
             // SAFETY: caller must ensure `ptr` was initialized with a valid
             // address.
             Ok(unsafe { self.ptr.read() })
@@ -360,7 +358,7 @@ pub mod test_utils {
         /// # Safety
         /// The caller is required to ensure the validity of the address
         /// this object was initialized with.
-        unsafe fn mem_write(&mut self, data: Self::Item) -> Result<(), InsnError> {
+        unsafe fn mem_write(&mut self, data: T) -> Result<(), InsnError> {
             // SAFETY: caller must ensure `ptr` was initialized with a valid
             // address.
             unsafe {
@@ -371,12 +369,10 @@ pub mod test_utils {
     }
 
     #[cfg(fuzzing)]
-    impl<T: FromBytes + IntoBytes> InsnMachineMem for TestMem<T> {
-        type Item = T;
-
+    impl<T: FromBytes + IntoBytes> InsnMachineMem<T> for TestMem<T> {
         /// # Safety
         /// No safety concerns under fuzzing.
-        unsafe fn mem_write(&mut self, _data: Self::Item) -> Result<(), InsnError> {
+        unsafe fn mem_write(&mut self, _data: T) -> Result<(), InsnError> {
             Ok(())
         }
     }

kernel/src/mm/guestmem.rs

@@ -418,21 +418,19 @@ impl<T> From<NonNull<T>> for GuestPtr<T> {
     }
 }
 
-impl<T: FromBytes + IntoBytes> InsnMachineMem for GuestPtr<T> {
-    type Item = T;
-
+impl<T: FromBytes + IntoBytes> InsnMachineMem<T> for GuestPtr<T> {
     /// # Safety
     ///
     /// See the GuestPtr's read() method documentation for safety requirements.
-    unsafe fn mem_read(&self) -> Result<Self::Item, InsnError> {
+    unsafe fn mem_read(&self) -> Result<T, InsnError> {
         // SAFETY: Safe when GuestPtr::read safety requirements are met.
         unsafe { self.read().map_err(|_| InsnError::MemRead) }
     }
 
     /// # Safety
     ///
     /// See the GuestPtr's write() method documentation for safety requirements.
-    unsafe fn mem_write(&mut self, data: Self::Item) -> Result<(), InsnError> {
+    unsafe fn mem_write(&mut self, data: T) -> Result<(), InsnError> {
         // SAFETY: Safe when GuestPtr::write safety requirements are met.
         unsafe { self.write(data).map_err(|_| InsnError::MemWrite) }
     }