Minor fixed

Author: memN0ps

driver/src/virtualize.rs

@@ -4,18 +4,15 @@ use {
     hypervisor::{
         intel::{
             capture::GuestRegisters, page::Page,
-            ept::paging::{Ept, AccessType},
             shared_data::SharedData,
         },
         vmm::start_hypervisor,
-        error::HypervisorError,
     },
     log::debug,
     uefi::{
         proto::loaded_image::LoadedImage,
         table::{Boot, SystemTable},
     },
-    alloc::boxed::Box,
 };
 
 pub fn virtualize_system(guest_registers: &GuestRegisters, shared_data: &mut SharedData, system_table: &SystemTable<Boot>) {

hypervisor/src/intel/descriptor.rs

@@ -146,5 +146,5 @@ impl Default for TaskStateSegment {
 }
 
 /// See: Figure 8-11. 64-Bit TSS Format
-
+#[allow(dead_code)]
 struct TaskStateSegmentRaw([u8; 104]);

hypervisor/src/intel/paging.rs

@@ -112,15 +112,15 @@ impl PageTables {
 ///
 /// Reference: Intel® 64 and IA-32 Architectures Software Developer's Manual: 4.5 Paging
 #[derive(Debug, Clone, Copy)]
-struct Pml4(Table);
+pub struct Pml4(Table);
 
 /// Represents a Page-Directory-Pointer-Table Entry (PDPTE) that references a Page Directory.
 ///
 /// PDPTEs are part of the second level in the standard x86-64 paging hierarchy.
 ///
 /// Reference: Intel® 64 and IA-32 Architectures Software Developer's Manual: 4.5 Paging
 #[derive(Debug, Clone, Copy)]
-struct Pdpt(Table);
+pub struct Pdpt(Table);
 
 /// Represents a Page-Directory Entry (PDE) that references a Page Table.
 ///
@@ -130,22 +130,24 @@ struct Pdpt(Table);
 #[derive(Debug, Clone, Copy)]
 struct Pd(Table);
 
+/*
 /// Represents a Page-Table Entry (PTE) that maps a 4-KByte Page.
 ///
 /// PTEs are the lowest level in the standard x86-64 paging hierarchy and are used to map individual
 /// pages to physical addresses.
 ///
 /// Reference: Intel® 64 and IA-32 Architectures Software Developer's Manual: 4.5 Paging
 #[derive(Debug, Clone, Copy)]
-struct Pt(Table);
+pub struct Pt(Table);
+*/
 
 /// General struct to represent a table in the standard paging structure.
 ///
 /// This struct is used as a basis for PML4, PDPT, PD, and PT. It contains an array of entries
 /// where each entry can represent different levels of the paging hierarchy.
 #[repr(C, align(4096))]
 #[derive(Debug, Clone, Copy)]
-struct Table {
+pub struct Table {
     entries: [Entry; 512],
 }
 

hypervisor/src/intel/vm.rs

@@ -20,7 +20,7 @@ use {
 
 pub struct Vm {
     /// The VMCS (Virtual Machine Control Structure) for the VM.
-    pub vmcs_region: Vmcs,
+    pub vmcs_region: Box<Vmcs>,
 
     /// The guest's descriptor tables.
     pub guest_descriptor: Descriptors,
@@ -45,7 +45,7 @@ impl Vm {
     pub fn new(guest_registers: &GuestRegisters, shared_data: &mut SharedData) -> Self {
         log::debug!("Creating VM");
 
-        let vmcs = Vmcs::default();
+        let vmcs_region = Box::new(Vmcs::default());
         let guest_descriptor_table = Descriptors::new_from_current();
         let host_descriptor_table =  Descriptors::new_for_host();
         let mut host_paging = unsafe { Box::<PageTables>::new_zeroed().assume_init() };
@@ -57,7 +57,7 @@ impl Vm {
         log::debug!("VM created");
 
         Self {
-            vmcs_region: vmcs,
+            vmcs_region,
             host_paging,
             host_descriptor: host_descriptor_table,
             guest_descriptor: guest_descriptor_table,
@@ -72,11 +72,11 @@ impl Vm {
         self.vmcs_region.revision_id.set_bit(31, false);
 
         // Clear the VMCS region.
-        vmclear(&mut self.vmcs_region as *mut _ as _);
+        vmclear(self.vmcs_region.as_ref() as *const _ as _);
         log::trace!("VMCLEAR successful!");
 
         // Load current VMCS pointer.
-        vmptrld(&mut self.vmcs_region as *mut _ as _);
+        vmptrld(self.vmcs_region.as_ref() as *const _ as _);
         log::trace!("VMPTRLD successful!");
 
         self.setup_vmcs()?;

hypervisor/src/intel/vmcs.rs

@@ -4,18 +4,17 @@ use {
         fmt,
         ptr::NonNull,
     },
-    bit_field::BitField,
     x86::{
         bits64::{
             paging::BASE_PAGE_SIZE,
             rflags,
         },
-        controlregs, dtables, msr, task,
+        controlregs, dtables, msr,
         segmentation::{cs, ds, es, fs, gs, SegmentSelector, ss},
         vmx::vmcs,
         debugregs::dr7,
     },
-    x86_64::registers::control::{Cr0, Cr3, Cr4},
+    x86_64::registers::control::Cr4,
     crate::{
         error::HypervisorError,
         intel::{
@@ -25,10 +24,7 @@ use {
             paging::PageTables,
             segmentation::SegmentDescriptor,
             shared_data::SharedData,
-            support::{rdmsr, sidt, vmclear, vmptrld, vmread, vmwrite},
-            vm::Vm,
-            vmx::Vmx,
-            vmxon::Vmxon,
+            support::{rdmsr, sidt, vmread, vmwrite},
             invvpid::{invvpid_single_context, VPID_TAG},
             invept::invept_single_context,
             page::Page,

hypervisor/src/intel/vmx.rs

@@ -1,5 +1,4 @@
 use {
-    alloc::boxed::Box,
     bit_field::BitField,
     crate::{
         error::HypervisorError,
@@ -8,16 +7,17 @@ use {
             vmxon::Vmxon,
         },
     },
+    alloc::boxed::Box,
 };
 
 pub struct Vmx {
-    pub vmxon_region: Vmxon,
+    pub vmxon_region: Box<Vmxon>,
 }
 
 impl Vmx {
     pub fn new() -> Self {
         Self {
-            vmxon_region: Vmxon::default(),
+            vmxon_region: Box::new(Vmxon::default()),
         }
     }
 
@@ -27,7 +27,7 @@ impl Vmx {
         log::trace!("VMXON region setup successfully!");
 
         log::trace!("Executing VMXON instruction");
-        vmxon(&mut self.vmxon_region as *mut _ as _);
+        vmxon(self.vmxon_region.as_ref() as *const _ as _);
         log::trace!("VMXON executed successfully!");
 
         Ok(())