Skip to content

Commit 2bf79f8

Browse files
arnabcs17b006arnabcs17b006
committed
made this crate mockable
1 parent 2dff256 commit 2bf79f8

File tree

2 files changed

+105
-45
lines changed

2 files changed

+105
-45
lines changed

‎Cargo.toml

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ license = "GPL-3.0-only"
1212
[dependencies]
1313
libloading = "0.6.1"
1414
log = "0.4.8"
15-
xenctrl-sys = { git = "https://github.com/Wenzel/xenctrl-sys.git" }
16-
xenvmevent-sys = { git = "https://github.com/Wenzel/xenvmevent-sys.git" }
15+
xenctrl-sys = { git = "https://github.com/arnabcs17b006/xenctrl-sys.git", branch = "default_derive" }
16+
xenvmevent-sys = { git = "https://github.com/arnabcs17b006/xenvmevent-sys.git", branch="derive_default" }
1717
enum-primitive-derive = "0.1.2"
1818
num-traits = "0.2.8"

‎src/lib.rs

Lines changed: 103 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -23,14 +23,16 @@ use std::{
2323
ptr::{null_mut, NonNull},
2424
slice,
2525
};
26-
pub use xenctrl_sys::{hvm_hw_cpu, hvm_save_descriptor, __HVM_SAVE_TYPE_CPU};
27-
use xenctrl_sys::{xc_error_code, xc_interface, xenmem_access_t, xentoollog_logger};
26+
pub use xenctrl_sys::{hvm_hw_cpu, hvm_save_descriptor, xentoollog_logger, __HVM_SAVE_TYPE_CPU};
27+
use xenctrl_sys::{xc_error_code, xc_interface, xenmem_access_t};
28+
pub use xenvmevent_sys::{
29+
vm_event_back_ring, vm_event_request_t, vm_event_response_t, vm_event_sring,
30+
};
2831
use xenvmevent_sys::{
29-
vm_event_back_ring, vm_event_request_t, vm_event_response_t, vm_event_sring, MEM_ACCESS_R,
30-
MEM_ACCESS_RW, MEM_ACCESS_RWX, MEM_ACCESS_RX, MEM_ACCESS_W, MEM_ACCESS_WX, MEM_ACCESS_X,
31-
VM_EVENT_REASON_MEM_ACCESS, VM_EVENT_REASON_MOV_TO_MSR, VM_EVENT_REASON_SINGLESTEP,
32-
VM_EVENT_REASON_SOFTWARE_BREAKPOINT, VM_EVENT_REASON_WRITE_CTRLREG, VM_EVENT_X86_CR0,
33-
VM_EVENT_X86_CR3, VM_EVENT_X86_CR4,
32+
MEM_ACCESS_R, MEM_ACCESS_RW, MEM_ACCESS_RWX, MEM_ACCESS_RX, MEM_ACCESS_W, MEM_ACCESS_WX,
33+
MEM_ACCESS_X, VM_EVENT_REASON_MEM_ACCESS, VM_EVENT_REASON_MOV_TO_MSR,
34+
VM_EVENT_REASON_SINGLESTEP, VM_EVENT_REASON_SOFTWARE_BREAKPOINT, VM_EVENT_REASON_WRITE_CTRLREG,
35+
VM_EVENT_X86_CR0, VM_EVENT_X86_CR3, VM_EVENT_X86_CR4,
3436
};
3537

3638
#[derive(Copy, Clone, Debug)]
@@ -134,38 +136,96 @@ pub struct XenControl {
134136
libxenctrl: LibXenCtrl,
135137
}
136138

137-
impl XenControl {
138-
pub fn new(
139+
pub trait XenIntrospectable: std::fmt::Debug {
140+
fn init(
141+
&mut self,
139142
logger: Option<&mut xentoollog_logger>,
140143
dombuild_logger: Option<&mut xentoollog_logger>,
141144
open_flags: u32,
142-
) -> Result<Self, XcError> {
143-
let libxenctrl = unsafe { LibXenCtrl::new() };
145+
) -> Result<(), XcError>;
146+
fn domain_hvm_getcontext_partial(&self, domid: u32, vcpu: u16) -> Result<hvm_hw_cpu, XcError>;
147+
fn domain_hvm_setcontext(
148+
&self,
149+
domid: u32,
150+
buffer: *mut c_uint,
151+
size: usize,
152+
) -> Result<(), XcError>;
153+
fn domain_hvm_getcontext(
154+
&self,
155+
domid: u32,
156+
vcpu: u16,
157+
) -> Result<(*mut c_uint, hvm_hw_cpu, u32), XcError>;
158+
fn monitor_enable(
159+
&mut self,
160+
domid: u32,
161+
) -> Result<(vm_event_sring, vm_event_back_ring, u32), XcError>;
162+
fn get_request(
163+
&self,
164+
back_ring: &mut vm_event_back_ring,
165+
) -> Result<vm_event_request_t, XcError>;
166+
fn put_response(
167+
&self,
168+
rsp: &mut vm_event_response_t,
169+
back_ring: &mut vm_event_back_ring,
170+
) -> Result<(), XcError>;
171+
fn get_event_type(&self, req: vm_event_request_t) -> Result<XenEventType, XcError>;
172+
fn monitor_disable(&self, domid: u32) -> Result<(), XcError>;
173+
fn domain_pause(&self, domid: u32) -> Result<(), XcError>;
174+
fn domain_unpause(&self, domid: u32) -> Result<(), XcError>;
175+
fn monitor_software_breakpoint(&self, domid: u32, enable: bool) -> Result<(), XcError>;
176+
fn monitor_singlestep(&self, domid: u32, enable: bool) -> Result<(), XcError>;
177+
fn monitor_mov_to_msr(&self, domid: u32, msr: u32, enable: bool) -> Result<(), XcError>;
178+
fn monitor_write_ctrlreg(
179+
&self,
180+
domid: u32,
181+
index: XenCr,
182+
enable: bool,
183+
sync: bool,
184+
onchangeonly: bool,
185+
) -> Result<(), XcError>;
186+
fn set_mem_access(
187+
&self,
188+
domid: u32,
189+
access: XenPageAccess,
190+
first_pfn: u64,
191+
) -> Result<(), XcError>;
192+
fn get_mem_access(&self, domid: u32, pfn: u64) -> Result<XenPageAccess, XcError>;
193+
fn domain_maximum_gpfn(&self, domid: u32) -> Result<u64, XcError>;
194+
fn close(&mut self) -> Result<(), XcError>;
195+
}
196+
197+
pub fn create_xen_control() -> XenControl {
198+
XenControl::new(unsafe { LibXenCtrl::new() })
199+
}
200+
201+
impl XenControl {
202+
fn new(libxenctrl: LibXenCtrl) -> XenControl {
203+
XenControl {
204+
handle: NonNull::dangling(),
205+
libxenctrl,
206+
}
207+
}
208+
}
144209

210+
impl XenIntrospectable for XenControl {
211+
fn init(
212+
&mut self,
213+
logger: Option<&mut xentoollog_logger>,
214+
dombuild_logger: Option<&mut xentoollog_logger>,
215+
open_flags: u32,
216+
) -> Result<(), XcError> {
145217
#[allow(clippy::redundant_closure)]
146-
let xc_handle = (libxenctrl.interface_open)(
218+
let xc_handle = (self.libxenctrl.interface_open)(
147219
logger.map_or_else(|| null_mut(), |l| l as *mut _),
148220
dombuild_logger.map_or_else(|| null_mut(), |l| l as *mut _),
149221
open_flags,
150222
);
151223

152-
NonNull::new(xc_handle)
153-
.ok_or_else(|| {
154-
let desc = (libxenctrl.error_code_to_desc)(xc_error_code::XC_INTERNAL_ERROR as _);
155-
XcError::new(unsafe { ffi::CStr::from_ptr(desc) }.to_str().unwrap())
156-
})
157-
.map(|handle| XenControl { handle, libxenctrl })
158-
}
159-
160-
pub fn default() -> Result<Self, XcError> {
161-
Self::new(None, None, 0)
224+
self.handle = NonNull::new(xc_handle).unwrap();
225+
last_error!(self, ())
162226
}
163227

164-
pub fn domain_hvm_getcontext_partial(
165-
&self,
166-
domid: u32,
167-
vcpu: u16,
168-
) -> Result<hvm_hw_cpu, XcError> {
228+
fn domain_hvm_getcontext_partial(&self, domid: u32, vcpu: u16) -> Result<hvm_hw_cpu, XcError> {
169229
let xc = self.handle.as_ptr();
170230
let mut hvm_cpu: hvm_hw_cpu =
171231
unsafe { mem::MaybeUninit::<hvm_hw_cpu>::zeroed().assume_init() };
@@ -188,7 +248,7 @@ impl XenControl {
188248
last_error!(self, hvm_cpu)
189249
}
190250

191-
pub fn domain_hvm_setcontext(
251+
fn domain_hvm_setcontext(
192252
&self,
193253
domid: u32,
194254
buffer: *mut c_uint,
@@ -200,7 +260,7 @@ impl XenControl {
200260
last_error!(self, ())
201261
}
202262

203-
pub fn domain_hvm_getcontext(
263+
fn domain_hvm_getcontext(
204264
&self,
205265
domid: u32,
206266
vcpu: u16,
@@ -238,7 +298,7 @@ impl XenControl {
238298
last_error!(self, (buffer, *cpu_ptr, size.try_into().unwrap()))
239299
}
240300

241-
pub fn monitor_enable(
301+
fn monitor_enable(
242302
&mut self,
243303
domid: u32,
244304
) -> Result<(vm_event_sring, vm_event_back_ring, u32), XcError> {
@@ -266,7 +326,7 @@ impl XenControl {
266326
last_error!(self, (*ring_page, back_ring, remote_port))
267327
}
268328

269-
pub fn get_request(
329+
fn get_request(
270330
&self,
271331
back_ring: &mut vm_event_back_ring,
272332
) -> Result<vm_event_request_t, XcError> {
@@ -280,7 +340,7 @@ impl XenControl {
280340
last_error!(self, req_from_ring)
281341
}
282342

283-
pub fn put_response(
343+
fn put_response(
284344
&self,
285345
rsp: &mut vm_event_response_t,
286346
back_ring: &mut vm_event_back_ring,
@@ -294,7 +354,7 @@ impl XenControl {
294354
last_error!(self, ())
295355
}
296356

297-
pub fn get_event_type(&self, req: vm_event_request_t) -> Result<XenEventType, XcError> {
357+
fn get_event_type(&self, req: vm_event_request_t) -> Result<XenEventType, XcError> {
298358
let ev_type: XenEventType;
299359
unsafe {
300360
ev_type = match req.reason {
@@ -338,28 +398,28 @@ impl XenControl {
338398
last_error!(self, ev_type)
339399
}
340400

341-
pub fn monitor_disable(&self, domid: u32) -> Result<(), XcError> {
401+
fn monitor_disable(&self, domid: u32) -> Result<(), XcError> {
342402
let xc = self.handle.as_ptr();
343403
(self.libxenctrl.clear_last_error)(xc);
344404
(self.libxenctrl.monitor_disable)(xc, domid.try_into().unwrap());
345405
last_error!(self, ())
346406
}
347407

348-
pub fn domain_pause(&self, domid: u32) -> Result<(), XcError> {
408+
fn domain_pause(&self, domid: u32) -> Result<(), XcError> {
349409
let xc = self.handle.as_ptr();
350410
(self.libxenctrl.clear_last_error)(xc);
351411
(self.libxenctrl.domain_pause)(xc, domid);
352412
last_error!(self, ())
353413
}
354414

355-
pub fn domain_unpause(&self, domid: u32) -> Result<(), XcError> {
415+
fn domain_unpause(&self, domid: u32) -> Result<(), XcError> {
356416
let xc = self.handle.as_ptr();
357417
(self.libxenctrl.clear_last_error)(xc);
358418
(self.libxenctrl.domain_unpause)(xc, domid);
359419
last_error!(self, ())
360420
}
361421

362-
pub fn monitor_software_breakpoint(&self, domid: u32, enable: bool) -> Result<(), XcError> {
422+
fn monitor_software_breakpoint(&self, domid: u32, enable: bool) -> Result<(), XcError> {
363423
let xc = self.handle.as_ptr();
364424
(self.libxenctrl.clear_last_error)(xc);
365425
let rc = (self.libxenctrl.monitor_software_breakpoint)(xc, domid, enable);
@@ -369,7 +429,7 @@ impl XenControl {
369429
last_error!(self, ())
370430
}
371431

372-
pub fn monitor_singlestep(&self, domid: u32, enable: bool) -> Result<(), XcError> {
432+
fn monitor_singlestep(&self, domid: u32, enable: bool) -> Result<(), XcError> {
373433
let xc = self.handle.as_ptr();
374434
(self.libxenctrl.clear_last_error)(xc);
375435
let rc = (self.libxenctrl.monitor_singlestep)(xc, domid, enable);
@@ -379,7 +439,7 @@ impl XenControl {
379439
last_error!(self, ())
380440
}
381441

382-
pub fn monitor_mov_to_msr(&self, domid: u32, msr: u32, enable: bool) -> Result<(), XcError> {
442+
fn monitor_mov_to_msr(&self, domid: u32, msr: u32, enable: bool) -> Result<(), XcError> {
383443
let xc = self.handle.as_ptr();
384444
(self.libxenctrl.clear_last_error)(xc);
385445
let rc = (self.libxenctrl.monitor_mov_to_msr)(xc, domid.try_into().unwrap(), msr, enable);
@@ -389,7 +449,7 @@ impl XenControl {
389449
last_error!(self, ())
390450
}
391451

392-
pub fn monitor_write_ctrlreg(
452+
fn monitor_write_ctrlreg(
393453
&self,
394454
domid: u32,
395455
index: XenCr,
@@ -413,7 +473,7 @@ impl XenControl {
413473
last_error!(self, ())
414474
}
415475

416-
pub fn set_mem_access(
476+
fn set_mem_access(
417477
&self,
418478
domid: u32,
419479
access: XenPageAccess,
@@ -431,15 +491,15 @@ impl XenControl {
431491
last_error!(self, ())
432492
}
433493

434-
pub fn get_mem_access(&self, domid: u32, pfn: u64) -> Result<XenPageAccess, XcError> {
494+
fn get_mem_access(&self, domid: u32, pfn: u64) -> Result<XenPageAccess, XcError> {
435495
let xc = self.handle.as_ptr();
436496
let mut access: xenmem_access_t = xenmem_access_t::XENMEM_access_n;
437497
(self.libxenctrl.clear_last_error)(xc);
438498
(self.libxenctrl.get_mem_access)(xc, domid.try_into().unwrap(), pfn, &mut access);
439499
last_error!(self, access.try_into().unwrap())
440500
}
441501

442-
pub fn domain_maximum_gpfn(&self, domid: u32) -> Result<u64, XcError> {
502+
fn domain_maximum_gpfn(&self, domid: u32) -> Result<u64, XcError> {
443503
let xc = self.handle.as_ptr();
444504
#[allow(unused_assignments)]
445505
let mut max_gpfn = mem::MaybeUninit::<u64>::uninit();

0 commit comments

Comments
 (0)