Skip to content

Commit cd7e211

Browse files
danbugsdanbugs
committed
tmp (x2)
Signed-off-by: danbugs <[email protected]>
1 parent 8e184b5 commit cd7e211

File tree

18 files changed

+1245
-1402
lines changed

18 files changed

+1245
-1402
lines changed

‎src/hyperlight_host/src/hypervisor/hyperv_linux.rs‎

Lines changed: 44 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -26,12 +26,11 @@ extern crate mshv_ioctls3 as mshv_ioctls;
2626

2727
use std::fmt::{Debug, Formatter};
2828

29-
use log::error;
3029
#[cfg(mshv2)]
3130
use mshv_bindings::hv_message;
3231
use mshv_bindings::{
3332
hv_message_type, hv_message_type_HVMSG_GPA_INTERCEPT, hv_message_type_HVMSG_UNMAPPED_GPA,
34-
hv_message_type_HVMSG_X64_HALT, hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT, mshv_user_mem_region,
33+
hv_message_type_HVMSG_X64_HALT, hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT,
3534
SegmentRegister, SpecialRegisters, StandardRegisters,
3635
};
3736
#[cfg(mshv3)]
@@ -51,9 +50,9 @@ use super::{
5150
};
5251
use crate::hypervisor::hypervisor_handler::HypervisorHandler;
5352
use crate::hypervisor::HyperlightExit;
54-
use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
5553
use crate::mem::ptr::GuestPtr;
5654
use crate::{log_then_return, Result};
55+
use crate::sandbox::sandbox_builder::SandboxMemorySections;
5756

5857
/// Determine whether the HyperV for Linux hypervisor API is present
5958
/// and functional.
@@ -77,10 +76,11 @@ pub(crate) fn is_hypervisor_present() -> bool {
7776
/// called the Microsoft Hypervisor (MSHV)
7877
pub(super) struct HypervLinuxDriver {
7978
_mshv: Mshv,
80-
vm_fd: VmFd,
79+
// TODO(danbugs:297): bring back
80+
_vm_fd: VmFd,
8181
vcpu_fd: VcpuFd,
8282
entrypoint: u64,
83-
mem_regions: Vec<MemoryRegion>,
83+
mem_sections: SandboxMemorySections,
8484
orig_rsp: GuestPtr,
8585
}
8686

@@ -95,17 +95,17 @@ impl HypervLinuxDriver {
9595
/// `initialise` to do it for you.
9696
#[instrument(skip_all, parent = Span::current(), level = "Trace")]
9797
pub(super) fn new(
98-
mem_regions: Vec<MemoryRegion>,
98+
mem_sections: SandboxMemorySections,
9999
entrypoint_ptr: GuestPtr,
100100
rsp_ptr: GuestPtr,
101101
pml4_ptr: GuestPtr,
102102
) -> Result<Self> {
103103
let mshv = Mshv::new()?;
104104
let pr = Default::default();
105105
#[cfg(mshv2)]
106-
let vm_fd = mshv.create_vm_with_config(&pr)?;
106+
let _vm_fd = mshv.create_vm_with_config(&pr)?;
107107
#[cfg(mshv3)]
108-
let vm_fd = {
108+
let _vm_fd = {
109109
// It's important to avoid create_vm() and explicitly use
110110
// create_vm_with_args() with an empty arguments structure
111111
// here, because otherwise the partition is set up with a SynIC.
@@ -120,20 +120,21 @@ impl HypervLinuxDriver {
120120
vm_fd
121121
};
122122

123-
let mut vcpu_fd = vm_fd.create_vcpu(0)?;
123+
let mut vcpu_fd = _vm_fd.create_vcpu(0)?;
124124

125-
mem_regions.iter().try_for_each(|region| {
126-
let mshv_region = region.to_owned().into();
127-
vm_fd.map_user_memory(mshv_region)
128-
})?;
125+
// TODO(danbugs:297): bring back
126+
// mem_sections.iter().try_for_each(|region| {
127+
// let mshv_region = region.to_owned().into();
128+
// vm_fd.map_user_memory(mshv_region)
129+
// })?;
129130

130131
Self::setup_initial_sregs(&mut vcpu_fd, pml4_ptr.absolute()?)?;
131132

132133
Ok(Self {
133134
_mshv: mshv,
134-
vm_fd,
135+
_vm_fd,
135136
vcpu_fd,
136-
mem_regions,
137+
mem_sections,
137138
entrypoint: entrypoint_ptr.absolute()?,
138139
orig_rsp: rsp_ptr,
139140
})
@@ -173,7 +174,7 @@ impl Debug for HypervLinuxDriver {
173174
f.field("Entrypoint", &self.entrypoint)
174175
.field("Original RSP", &self.orig_rsp);
175176

176-
for region in &self.mem_regions {
177+
for region in self.mem_sections.iter() {
177178
f.field("Memory Region", &region);
178179
}
179180

@@ -359,20 +360,24 @@ impl Hypervisor for HypervLinuxDriver {
359360
INVALID_GPA_ACCESS_MESSAGE => {
360361
let mimo_message = m.to_memory_info()?;
361362
let gpa = mimo_message.guest_physical_address;
362-
let access_info = MemoryRegionFlags::try_from(mimo_message)?;
363+
// TODO(danbugs:297): bring back
364+
// let access_info = MemoryRegionFlags::try_from(mimo_message)?;
363365
crate::debug!(
364366
"mshv MMIO invalid GPA access -Details: Address: {} \n {:#?}",
365367
gpa,
366368
&self
367369
);
368-
match self.get_memory_access_violation(
369-
gpa as usize,
370-
&self.mem_regions,
371-
access_info,
372-
) {
373-
Some(access_info_violation) => access_info_violation,
374-
None => HyperlightExit::Mmio(gpa),
375-
}
370+
// TODO(danbugs:297): bring back
371+
// match self.get_memory_access_violation(
372+
// gpa as usize,
373+
// &self.mem_regions,
374+
// access_info,
375+
// ) {
376+
// Some(access_info_violation) => access_info_violation,
377+
// None => HyperlightExit::Mmio(gpa),
378+
// }
379+
380+
HyperlightExit::Mmio(gpa)
376381
}
377382
other => {
378383
crate::debug!("mshv Other Exit: Exit: {:#?} \n {:#?}", other, &self);
@@ -399,22 +404,23 @@ impl Hypervisor for HypervLinuxDriver {
399404

400405
#[cfg(crashdump)]
401406
fn get_memory_regions(&self) -> &[MemoryRegion] {
402-
&self.mem_regions
407+
&self.mem_sections
403408
}
404409
}
405410

406-
impl Drop for HypervLinuxDriver {
407-
#[instrument(skip_all, parent = Span::current(), level = "Trace")]
408-
fn drop(&mut self) {
409-
for region in &self.mem_regions {
410-
let mshv_region: mshv_user_mem_region = region.to_owned().into();
411-
match self.vm_fd.unmap_user_memory(mshv_region) {
412-
Ok(_) => (),
413-
Err(e) => error!("Failed to unmap user memory in HyperVOnLinux ({:?})", e),
414-
}
415-
}
416-
}
417-
}
411+
// TODO(danbugs:297): bring back
412+
// impl Drop for HypervLinuxDriver {
413+
// #[instrument(skip_all, parent = Span::current(), level = "Trace")]
414+
// fn drop(&mut self) {
415+
// for region in self.mem_sections.iter() {
416+
// let mshv_region: mshv_user_mem_region = region.to_owned().into();
417+
// match self.vm_fd.unmap_user_memory(mshv_region) {
418+
// Ok(_) => (),
419+
// Err(e) => error!("Failed to unmap user memory in HyperVOnLinux ({:?})", e),
420+
// }
421+
// }
422+
// }
423+
// }
418424

419425
// TODO(danbugs:297): bring back
420426
// #[cfg(test)]

‎src/hyperlight_host/src/hypervisor/hypervisor_handler.rs‎

Lines changed: 9 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ use crate::hypervisor::wrappers::HandleWrapper;
4747
use crate::hypervisor::Hypervisor;
4848
use crate::mem::mgr::SandboxMemoryManager;
4949
use crate::mem::ptr::{GuestPtr, RawPtr};
50-
use crate::mem::shared_mem::{GuestSharedMemory, HostSharedMemory, SharedMemory};
50+
use crate::mem::shared_mem::{GuestSharedMemory, HostSharedMemory};
5151
#[cfg(gdb)]
5252
use crate::sandbox::config::DebugInfo;
5353
use crate::sandbox::hypervisor::{get_available_hypervisor, HypervisorType};
@@ -853,15 +853,13 @@ fn set_up_hypervisor_partition(
853853
mgr: &mut SandboxMemoryManager<GuestSharedMemory>,
854854
#[cfg(gdb)] debug_info: &Option<DebugInfo>,
855855
) -> Result<Box<dyn Hypervisor>> {
856-
let mem_size = u64::try_from(mgr.shared_mem.mem_size())?;
857-
let mut regions = mgr.layout.get_memory_regions(&mgr.shared_mem)?;
858-
mgr.set_up_shared_memory(mem_size, &mut regions)?;
856+
mgr.set_up_shared_memory()?;
857+
let memory_sections = mgr.memory_sections.clone();
859858

860-
// TODO(danbugs:297) rsp is set at the top of custom guest memory, we should potentially still
861-
// set this up.
862-
let rsp_ptr = GuestPtr::try_from(RawPtr::from((mgr.layout.custom_guest_memory_offset + mgr.layout.custom_guest_memory_size) as u64))?;
859+
let rsp_ptr = GuestPtr::try_from(RawPtr::from(mgr.init_rsp))?;
863860

864-
let pml4_ptr = GuestPtr::try_from(Offset::from(mgr.layout.get_pml4_offset() as u64))?;
861+
// TODO(danbugs:297): change unwrap to proper error handling informing paging isn't set up.
862+
let pml4_ptr = GuestPtr::try_from(Offset::from(mgr.memory_sections.get_paging_structures_offset().unwrap() as u64))?;
865863
let entrypoint_ptr = {
866864
let entrypoint_total_offset = mgr.load_addr.clone() + mgr.entrypoint_exe_offset;
867865
GuestPtr::try_from(entrypoint_total_offset)
@@ -915,7 +913,7 @@ fn set_up_hypervisor_partition(
915913
#[cfg(mshv)]
916914
Some(HypervisorType::Mshv) => {
917915
let hv = crate::hypervisor::hyperv_linux::HypervLinuxDriver::new(
918-
regions,
916+
memory_sections,
919917
entrypoint_ptr,
920918
rsp_ptr,
921919
pml4_ptr,
@@ -926,7 +924,7 @@ fn set_up_hypervisor_partition(
926924
#[cfg(kvm)]
927925
Some(HypervisorType::Kvm) => {
928926
let hv = crate::hypervisor::kvm::KVMDriver::new(
929-
regions,
927+
memory_sections,
930928
pml4_ptr.absolute()?,
931929
entrypoint_ptr.absolute()?,
932930
rsp_ptr.absolute()?,
@@ -942,7 +940,7 @@ fn set_up_hypervisor_partition(
942940
.shared_mem
943941
.with_exclusivity(|e| e.get_mmap_file_handle())?;
944942
let hv = crate::hypervisor::hyperv_windows::HypervWindowsDriver::new(
945-
regions,
943+
memory_sections,
946944
mgr.shared_mem.raw_mem_size(), // we use raw_* here because windows driver requires 64K aligned addresses,
947945
mgr.shared_mem.raw_ptr() as *mut c_void, // and instead convert it to base_addr where needed in the driver itself
948946
pml4_ptr.absolute()?,

‎src/hyperlight_host/src/hypervisor/kvm.rs‎

Lines changed: 37 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -33,11 +33,12 @@ use super::{
3333
CR4_OSFXSR, CR4_OSXMMEXCPT, CR4_PAE, EFER_LMA, EFER_LME, EFER_NX, EFER_SCE,
3434
};
3535
use crate::hypervisor::hypervisor_handler::HypervisorHandler;
36-
use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
36+
use crate::mem::memory_region::MemoryRegionFlags;
3737
use crate::mem::ptr::{GuestPtr, RawPtr};
3838
#[cfg(gdb)]
3939
use crate::HyperlightError;
4040
use crate::{log_then_return, Result};
41+
use crate::sandbox::sandbox_builder::SandboxMemorySections;
4142

4243
/// Return `true` if the KVM API is available, version 12, and has UserMemory capability, or `false` otherwise
4344
#[instrument(skip_all, parent = Span::current(), level = "Trace")]
@@ -76,8 +77,8 @@ mod debug {
7677
use super::KVMDriver;
7778
use crate::hypervisor::gdb::{DebugMsg, DebugResponse, VcpuStopReason, X86_64Regs};
7879
use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
79-
use crate::mem::layout::SandboxMemoryLayout;
8080
use crate::{new_error, HyperlightError, Result};
81+
use crate::sandbox::sandbox_builder::BASE_ADDRESS;
8182

8283
/// Software Breakpoint size in memory
8384
pub const SW_BP_SIZE: usize = 1;
@@ -244,7 +245,7 @@ mod debug {
244245
data.len(),
245246
(PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
246247
);
247-
let offset = gpa as usize - SandboxMemoryLayout::BASE_ADDRESS;
248+
let offset = gpa as usize - BASE_ADDRESS;
248249

249250
dbg_mem_access_fn
250251
.try_lock()
@@ -274,7 +275,7 @@ mod debug {
274275
data.len(),
275276
(PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
276277
);
277-
let offset = gpa as usize - SandboxMemoryLayout::BASE_ADDRESS;
278+
let offset = gpa as usize - BASE_ADDRESS;
278279

279280
dbg_mem_access_fn
280281
.try_lock()
@@ -576,7 +577,7 @@ pub(super) struct KVMDriver {
576577
vcpu_fd: VcpuFd,
577578
orig_rsp: GuestPtr,
578579
entrypoint_ptr: u64,
579-
mem_regions: Vec<MemoryRegion>,
580+
mem_sections: SandboxMemorySections,
580581

581582
#[cfg(gdb)]
582583
debug: Option<debug::KvmDebug>,
@@ -590,7 +591,7 @@ impl KVMDriver {
590591
/// be called to do so.
591592
#[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
592593
pub(super) fn new(
593-
mem_regions: Vec<MemoryRegion>,
594+
mem_sections: SandboxMemorySections,
594595
rsp_ptr: u64,
595596
pml4_addr: u64,
596597
entrypoint: u64,
@@ -603,13 +604,13 @@ impl KVMDriver {
603604
let perm_flags =
604605
MemoryRegionFlags::READ | MemoryRegionFlags::WRITE | MemoryRegionFlags::EXECUTE;
605606

606-
mem_regions.iter().enumerate().try_for_each(|(i, region)| {
607-
let perm_flags = perm_flags.intersection(region.flags);
607+
mem_sections.iter().enumerate().try_for_each(|(i, region)| {
608+
let perm_flags = perm_flags.intersection(region.1.flags);
608609
let kvm_region = kvm_userspace_memory_region {
609610
slot: i as u32,
610-
guest_phys_addr: region.guest_region.start as u64,
611-
memory_size: (region.guest_region.end - region.guest_region.start) as u64,
612-
userspace_addr: region.host_region.start as u64,
611+
guest_phys_addr: region.1.page_aligned_guest_offset as u64,
612+
memory_size: region.1.page_aligned_size as u64,
613+
userspace_addr: region.1.host_address.unwrap() as u64,
613614
flags: match perm_flags {
614615
MemoryRegionFlags::READ => KVM_MEM_READONLY,
615616
_ => 0, // normal, RWX
@@ -636,7 +637,7 @@ impl KVMDriver {
636637
orig_rsp: rsp_gp,
637638
vcpu_fd,
638639
entrypoint_ptr: entrypoint,
639-
mem_regions,
640+
mem_sections: mem_sections,
640641

641642
#[cfg(gdb)]
642643
debug,
@@ -669,7 +670,7 @@ impl Debug for KVMDriver {
669670
let mut f = f.debug_struct("KVM Driver");
670671
// Output each memory region
671672

672-
for region in &self.mem_regions {
673+
for region in self.mem_sections.sections.iter() {
673674
f.field("Memory Region", &region);
674675
}
675676
let regs = self.vcpu_fd.get_regs();
@@ -822,26 +823,32 @@ impl Hypervisor for KVMDriver {
822823
Ok(VcpuExit::MmioRead(addr, _)) => {
823824
crate::debug!("KVM MMIO Read -Details: Address: {} \n {:#?}", addr, &self);
824825

825-
match self.get_memory_access_violation(
826-
addr as usize,
827-
&self.mem_regions,
828-
MemoryRegionFlags::READ,
829-
) {
830-
Some(access_violation_exit) => access_violation_exit,
831-
None => HyperlightExit::Mmio(addr),
832-
}
826+
// TODO(danbugs:297): bring back
827+
// match self.get_memory_access_violation(
828+
// addr as usize,
829+
// &self.mem_sections,
830+
// MemoryRegionFlags::READ,
831+
// ) {
832+
// Some(access_violation_exit) => access_violation_exit,
833+
// None => HyperlightExit::Mmio(addr),
834+
// }
835+
836+
HyperlightExit::Mmio(addr)
833837
}
834838
Ok(VcpuExit::MmioWrite(addr, _)) => {
835839
crate::debug!("KVM MMIO Write -Details: Address: {} \n {:#?}", addr, &self);
836840

837-
match self.get_memory_access_violation(
838-
addr as usize,
839-
&self.mem_regions,
840-
MemoryRegionFlags::WRITE,
841-
) {
842-
Some(access_violation_exit) => access_violation_exit,
843-
None => HyperlightExit::Mmio(addr),
844-
}
841+
// TODO(danbugs:297): bring back
842+
// match self.get_memory_access_violation(
843+
// addr as usize,
844+
// &self.mem_sections,
845+
// MemoryRegionFlags::WRITE,
846+
// ) {
847+
// Some(access_violation_exit) => access_violation_exit,
848+
// None => HyperlightExit::Mmio(addr),
849+
// }
850+
851+
HyperlightExit::Mmio(addr)
845852
}
846853
#[cfg(gdb)]
847854
Ok(VcpuExit::Debug(_)) => match self.get_stop_reason() {
@@ -880,7 +887,7 @@ impl Hypervisor for KVMDriver {
880887

881888
#[cfg(crashdump)]
882889
fn get_memory_regions(&self) -> &[MemoryRegion] {
883-
&self.mem_regions
890+
&self.mem_sections
884891
}
885892

886893
#[cfg(gdb)]

0 commit comments

Comments
 (0)