fix loading of kernel into memory

xenclient/examples/boot.rs

@@ -3,7 +3,7 @@ use xencall::domctl::DomainControl;
 use xencall::memory::MemoryControl;
 use xencall::sys::CreateDomain;
 use xencall::XenCall;
-use xenclient::boot::{BootImageLoader, BootSetup};
+use xenclient::boot::BootSetup;
 use xenclient::elfloader::ElfImageLoader;
 use xenclient::XenClientError;
 
@@ -17,14 +17,11 @@ fn main() -> Result<(), XenClientError> {
     let call = XenCall::open()?;
     let domctl = DomainControl::new(&call);
     let domid = domctl.create_domain(CreateDomain::default())?;
-    let domain = domctl.get_domain_info(domid)?;
-    println!("domain created: {:?}", domain);
+    println!("domain created: {:?}", domid);
     let image_loader = ElfImageLoader::load_file_kernel(kernel_image_path.as_str())?;
-    let image_info = image_loader.parse()?;
-    println!("loaded kernel image into memory: {:?}", image_info);
     let memctl = MemoryControl::new(&call);
     let mut boot = BootSetup::new(&call, &domctl, &memctl, domid);
-    boot.initialize(image_info, 512 * 1024)?;
+    boot.initialize(&image_loader, 512 * 1024)?;
     domctl.destroy_domain(domid)?;
     println!("domain destroyed: {}", domid);
     Ok(())

xenclient/src/boot.rs

@@ -5,6 +5,7 @@ use crate::sys::{
 use crate::XenClientError;
 use libc::memset;
 use std::ffi::c_void;
+use std::slice;
 use xencall::domctl::DomainControl;
 use xencall::memory::MemoryControl;
 use xencall::XenCall;
@@ -39,6 +40,8 @@ struct DomainSegment {
     _vstart: u64,
     _vend: u64,
     pfn: u64,
+    addr: u64,
+    size: u64,
     _pages: u64,
 }
 
@@ -178,13 +181,17 @@ impl BootSetup<'_> {
 
     pub fn initialize(
         &mut self,
-        image_info: BootImageInfo,
+        image_loader: &dyn BootImageLoader,
         memkb: u64,
     ) -> Result<(), XenClientError> {
+        let image_info = image_loader.parse()?;
         self.domctl.set_max_mem(self.domid, memkb)?;
         self.initialize_memory(memkb)?;
         let kernel_segment = self.alloc_segment(image_info.virt_kend - image_info.virt_kstart)?;
-        println!("kernel_segment: {:?}", kernel_segment);
+        let kernel_segment_ptr = kernel_segment.addr as *mut u8;
+        let slice =
+            unsafe { slice::from_raw_parts_mut(kernel_segment_ptr, kernel_segment.size as usize) };
+        image_loader.load(image_info, slice)?;
         Ok(())
     }
 
@@ -196,9 +203,12 @@ impl BootSetup<'_> {
             _vstart: start,
             _vend: 0,
             pfn: self.pfn_alloc_end,
+            addr: 0,
+            size,
             _pages: pages,
         };
         let ptr = self.phys.pfn_to_ptr(segment.pfn, pages)?;
+        segment.addr = ptr;
         unsafe {
             memset(ptr as *mut c_void, 0, (pages * page_size) as usize);
         }

xenclient/src/elfloader.rs

@@ -264,19 +264,19 @@ impl BootImageLoader for ElfImageLoader {
             ));
         }
 
-        let virt_base = if virt_base == XEN_UNSET_ADDR {
+        let _virt_base = if virt_base == XEN_UNSET_ADDR {
             0
         } else {
             virt_base
         };
 
-        let paddr_offset = if paddr_offset == XEN_UNSET_ADDR {
+        let _paddr_offset = if paddr_offset == XEN_UNSET_ADDR {
             0
         } else {
             paddr_offset
         };
 
-        let virt_offset = virt_base - paddr_offset;
+        let virt_offset = 0;
         let virt_kstart = start + virt_offset;
         let virt_kend = end + virt_offset;
         let virt_entry = if entry == XEN_UNSET_ADDR {