Skip to content

Commit 99de614

Browse files
danbugsdanbugs
committed
tmp
Signed-off-by: danbugs <[email protected]>
1 parent 0d400cf commit 99de614

File tree

23 files changed

+3104
-5039
lines changed

23 files changed

+3104
-5039
lines changed

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

Lines changed: 140 additions & 129 deletions
Original file line numberDiff line numberDiff line change
@@ -31,9 +31,8 @@ use log::error;
3131
use mshv_bindings::hv_message;
3232
use mshv_bindings::{
3333
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, hv_register_assoc,
35-
hv_register_name_HV_X64_REGISTER_RIP, hv_register_value, mshv_user_mem_region,
36-
FloatingPointUnit, SegmentRegister, SpecialRegisters, StandardRegisters,
34+
hv_message_type_HVMSG_X64_HALT, hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT, mshv_user_mem_region,
35+
SegmentRegister, SpecialRegisters, StandardRegisters,
3736
};
3837
#[cfg(mshv3)]
3938
use mshv_bindings::{
@@ -43,19 +42,18 @@ use mshv_bindings::{
4342
use mshv_ioctls::{Mshv, VcpuFd, VmFd};
4443
use tracing::{instrument, Span};
4544

46-
use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
4745
#[cfg(gdb)]
4846
use super::handlers::DbgMemAccessHandlerWrapper;
49-
use super::handlers::{MemAccessHandlerWrapper, OutBHandlerWrapper};
47+
use super::handlers::MemAccessHandlerWrapper;
5048
use super::{
5149
Hypervisor, VirtualCPU, CR0_AM, CR0_ET, CR0_MP, CR0_NE, CR0_PE, CR0_PG, CR0_WP, CR4_OSFXSR,
5250
CR4_OSXMMEXCPT, CR4_PAE, EFER_LMA, EFER_LME, EFER_NX, EFER_SCE,
5351
};
5452
use crate::hypervisor::hypervisor_handler::HypervisorHandler;
5553
use crate::hypervisor::HyperlightExit;
5654
use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
57-
use crate::mem::ptr::{GuestPtr, RawPtr};
58-
use crate::{log_then_return, new_error, Result};
55+
use crate::mem::ptr::GuestPtr;
56+
use crate::{log_then_return, Result};
5957

6058
/// Determine whether the HyperV for Linux hypervisor API is present
6159
/// and functional.
@@ -199,10 +197,9 @@ impl Hypervisor for HypervLinuxDriver {
199197
#[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
200198
fn initialise(
201199
&mut self,
202-
peb_addr: RawPtr,
203-
seed: u64,
200+
custom_guest_memory_region_addr: u64,
201+
custom_guest_memory_region_size: u64,
204202
page_size: u32,
205-
outb_hdl: OutBHandlerWrapper,
206203
mem_access_hdl: MemAccessHandlerWrapper,
207204
hv_handler: Option<HypervisorHandler>,
208205
#[cfg(gdb)] dbg_mem_access_fn: DbgMemAccessHandlerWrapper,
@@ -213,8 +210,8 @@ impl Hypervisor for HypervLinuxDriver {
213210
rflags: 2, //bit 1 of rlags is required to be set
214211

215212
// function args
216-
rcx: peb_addr.into(),
217-
rdx: seed,
213+
rcx: custom_guest_memory_region_addr.into(),
214+
rdx: custom_guest_memory_region_size.into(),
218215
r8: page_size.into(),
219216
r9: self.get_max_log_level().into(),
220217

@@ -225,80 +222,93 @@ impl Hypervisor for HypervLinuxDriver {
225222
VirtualCPU::run(
226223
self.as_mut_hypervisor(),
227224
hv_handler,
228-
outb_hdl,
229225
mem_access_hdl,
230226
#[cfg(gdb)]
231227
dbg_mem_access_fn,
232228
)?;
233229

234-
Ok(())
235-
}
236-
237-
#[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
238-
fn dispatch_call_from_host(
239-
&mut self,
240-
dispatch_func_addr: RawPtr,
241-
outb_handle_fn: OutBHandlerWrapper,
242-
mem_access_fn: MemAccessHandlerWrapper,
243-
hv_handler: Option<HypervisorHandler>,
244-
#[cfg(gdb)] dbg_mem_access_fn: DbgMemAccessHandlerWrapper,
245-
) -> Result<()> {
246-
// Reset general purpose registers, then set RIP and RSP
247-
let regs = StandardRegisters {
248-
rip: dispatch_func_addr.into(),
230+
// reset RSP to what it was before initialise
231+
self.vcpu_fd.set_regs(&StandardRegisters {
249232
rsp: self.orig_rsp.absolute()?,
250233
rflags: 2, //bit 1 of rlags is required to be set
251234
..Default::default()
252-
};
253-
self.vcpu_fd.set_regs(&regs)?;
254-
255-
// reset fpu state
256-
let fpu = FloatingPointUnit {
257-
fcw: FP_CONTROL_WORD_DEFAULT,
258-
ftwx: FP_TAG_WORD_DEFAULT,
259-
mxcsr: MXCSR_DEFAULT,
260-
..Default::default() // zero out the rest
261-
};
262-
self.vcpu_fd.set_fpu(&fpu)?;
263-
264-
// run
265-
VirtualCPU::run(
266-
self.as_mut_hypervisor(),
267-
hv_handler,
268-
outb_handle_fn,
269-
mem_access_fn,
270-
#[cfg(gdb)]
271-
dbg_mem_access_fn,
272-
)?;
273-
235+
})?;
274236
Ok(())
275237
}
276238

277-
#[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
278-
fn handle_io(
279-
&mut self,
280-
port: u16,
281-
data: Vec<u8>,
282-
rip: u64,
283-
instruction_length: u64,
284-
outb_handle_fn: OutBHandlerWrapper,
285-
) -> Result<()> {
286-
let payload = data[..8].try_into()?;
287-
outb_handle_fn
288-
.try_lock()
289-
.map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
290-
.call(port, u64::from_le_bytes(payload))?;
291-
292-
// update rip
293-
self.vcpu_fd.set_reg(&[hv_register_assoc {
294-
name: hv_register_name_HV_X64_REGISTER_RIP,
295-
value: hv_register_value {
296-
reg64: rip + instruction_length,
297-
},
298-
..Default::default()
299-
}])?;
300-
Ok(())
301-
}
239+
// TODO(danbugs:297): bring back
240+
// #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
241+
// fn dispatch_call_from_host(
242+
// &mut self,
243+
// dispatch_func_addr: RawPtr,
244+
// outb_handle_fn: OutBHandlerWrapper,
245+
// mem_access_fn: MemAccessHandlerWrapper,
246+
// hv_handler: Option<HypervisorHandler>,
247+
// #[cfg(gdb)] dbg_mem_access_fn: DbgMemAccessHandlerWrapper,
248+
// ) -> Result<()> {
249+
// // Reset general purpose registers except RSP, then set RIP
250+
// let rsp_before = self.vcpu_fd.get_regs()?.rsp;
251+
// let regs = StandardRegisters {
252+
// rip: dispatch_func_addr.into(),
253+
// rsp: rsp_before,
254+
// rflags: 2, //bit 1 of rlags is required to be set
255+
// ..Default::default()
256+
// };
257+
// self.vcpu_fd.set_regs(&regs)?;
258+
//
259+
// // reset fpu state
260+
// let fpu = FloatingPointUnit {
261+
// fcw: FP_CONTROL_WORD_DEFAULT,
262+
// ftwx: FP_TAG_WORD_DEFAULT,
263+
// mxcsr: MXCSR_DEFAULT,
264+
// ..Default::default() // zero out the rest
265+
// };
266+
// self.vcpu_fd.set_fpu(&fpu)?;
267+
//
268+
// // run
269+
// VirtualCPU::run(
270+
// self.as_mut_hypervisor(),
271+
// hv_handler,
272+
// outb_handle_fn,
273+
// mem_access_fn,
274+
// #[cfg(gdb)]
275+
// dbg_mem_access_fn,
276+
// )?;
277+
//
278+
// // reset RSP to what it was before function call
279+
// self.vcpu_fd.set_regs(&StandardRegisters {
280+
// rsp: rsp_before,
281+
// rflags: 2, //bit 1 of rlags is required to be set
282+
// ..Default::default()
283+
// })?;
284+
// Ok(())
285+
// }
286+
//
287+
// #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
288+
// fn handle_io(
289+
// &mut self,
290+
// port: u16,
291+
// data: Vec<u8>,
292+
// rip: u64,
293+
// instruction_length: u64,
294+
// outb_handle_fn: OutBHandlerWrapper,
295+
// ) -> Result<()> {
296+
// let payload = data[..8].try_into()?;
297+
// outb_handle_fn
298+
// .try_lock()
299+
// .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
300+
// .call(port, u64::from_le_bytes(payload))?;
301+
//
302+
// // update rip
303+
// self.vcpu_fd.set_reg(&[hv_register_assoc {
304+
// name: hv_register_name_HV_X64_REGISTER_RIP,
305+
// value: hv_register_value {
306+
// reg64: rip + instruction_length,
307+
// },
308+
// ..Default::default()
309+
// }])?;
310+
// Ok(())
311+
// }
302312

303313
#[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
304314
fn run(&mut self) -> Result<super::HyperlightExit> {
@@ -406,57 +416,58 @@ impl Drop for HypervLinuxDriver {
406416
}
407417
}
408418

409-
#[cfg(test)]
410-
mod tests {
411-
use super::*;
412-
use crate::mem::memory_region::MemoryRegionVecBuilder;
413-
use crate::mem::shared_mem::{ExclusiveSharedMemory, SharedMemory};
414-
415-
#[rustfmt::skip]
416-
const CODE: [u8; 12] = [
417-
0xba, 0xf8, 0x03, /* mov $0x3f8, %dx */
418-
0x00, 0xd8, /* add %bl, %al */
419-
0x04, b'0', /* add $'0', %al */
420-
0xee, /* out %al, (%dx) */
421-
/* send a 0 to indicate we're done */
422-
0xb0, b'\0', /* mov $'\0', %al */
423-
0xee, /* out %al, (%dx) */
424-
0xf4, /* HLT */
425-
];
426-
427-
fn shared_mem_with_code(
428-
code: &[u8],
429-
mem_size: usize,
430-
load_offset: usize,
431-
) -> Result<Box<ExclusiveSharedMemory>> {
432-
if load_offset > mem_size {
433-
log_then_return!(
434-
"code load offset ({}) > memory size ({})",
435-
load_offset,
436-
mem_size
437-
);
438-
}
439-
let mut shared_mem = ExclusiveSharedMemory::new(mem_size)?;
440-
shared_mem.copy_from_slice(code, load_offset)?;
441-
Ok(Box::new(shared_mem))
442-
}
443-
444-
#[test]
445-
fn create_driver() {
446-
if !super::is_hypervisor_present() {
447-
return;
448-
}
449-
const MEM_SIZE: usize = 0x3000;
450-
let gm = shared_mem_with_code(CODE.as_slice(), MEM_SIZE, 0).unwrap();
451-
let rsp_ptr = GuestPtr::try_from(0).unwrap();
452-
let pml4_ptr = GuestPtr::try_from(0).unwrap();
453-
let entrypoint_ptr = GuestPtr::try_from(0).unwrap();
454-
let mut regions = MemoryRegionVecBuilder::new(0, gm.base_addr());
455-
regions.push_page_aligned(
456-
MEM_SIZE,
457-
MemoryRegionFlags::READ | MemoryRegionFlags::WRITE | MemoryRegionFlags::EXECUTE,
458-
crate::mem::memory_region::MemoryRegionType::Code,
459-
);
460-
super::HypervLinuxDriver::new(regions.build(), entrypoint_ptr, rsp_ptr, pml4_ptr).unwrap();
461-
}
462-
}
419+
// TODO(danbugs:297): bring back
420+
// #[cfg(test)]
421+
// mod tests {
422+
// use super::*;
423+
// use crate::mem::memory_region::MemoryRegionVecBuilder;
424+
// use crate::mem::shared_mem::{ExclusiveSharedMemory, SharedMemory};
425+
//
426+
// #[rustfmt::skip]
427+
// const CODE: [u8; 12] = [
428+
// 0xba, 0xf8, 0x03, /* mov $0x3f8, %dx */
429+
// 0x00, 0xd8, /* add %bl, %al */
430+
// 0x04, b'0', /* add $'0', %al */
431+
// 0xee, /* out %al, (%dx) */
432+
// /* send a 0 to indicate we're done */
433+
// 0xb0, b'\0', /* mov $'\0', %al */
434+
// 0xee, /* out %al, (%dx) */
435+
// 0xf4, /* HLT */
436+
// ];
437+
//
438+
// fn shared_mem_with_code(
439+
// code: &[u8],
440+
// mem_size: usize,
441+
// load_offset: usize,
442+
// ) -> Result<Box<ExclusiveSharedMemory>> {
443+
// if load_offset > mem_size {
444+
// log_then_return!(
445+
// "code load offset ({}) > memory size ({})",
446+
// load_offset,
447+
// mem_size
448+
// );
449+
// }
450+
// let mut shared_mem = ExclusiveSharedMemory::new(mem_size)?;
451+
// shared_mem.copy_from_slice(code, load_offset)?;
452+
// Ok(Box::new(shared_mem))
453+
// }
454+
//
455+
// #[test]
456+
// fn create_driver() {
457+
// if !super::is_hypervisor_present() {
458+
// return;
459+
// }
460+
// const MEM_SIZE: usize = 0x3000;
461+
// let gm = shared_mem_with_code(CODE.as_slice(), MEM_SIZE, 0).unwrap();
462+
// let rsp_ptr = GuestPtr::try_from(0).unwrap();
463+
// let pml4_ptr = GuestPtr::try_from(0).unwrap();
464+
// let entrypoint_ptr = GuestPtr::try_from(0).unwrap();
465+
// let mut regions = MemoryRegionVecBuilder::new(0, gm.base_addr());
466+
// regions.push_page_aligned(
467+
// MEM_SIZE,
468+
// MemoryRegionFlags::READ | MemoryRegionFlags::WRITE | MemoryRegionFlags::EXECUTE,
469+
// crate::mem::memory_region::MemoryRegionType::Code,
470+
// );
471+
// super::HypervLinuxDriver::new(regions.build(), entrypoint_ptr, rsp_ptr, pml4_ptr).unwrap();
472+
// }
473+
// }

0 commit comments

Comments
 (0)