add map_alloc update fdt

Cargo.toml

@@ -45,8 +45,8 @@ axaddrspace = { git = "https://github.com/arceos-hypervisor/axaddrspace.git" }
 crate_interface = "0.1"
 axerrno = "0.1.0"
 memory_addr = "0.3"
-page_table_entry = { version = "0.5", features = ["arm-el2"] }
-page_table_multiarch = "0.5"
+page_table_entry = { version = "0.5.3", features = ["arm-el2"] }
+page_table_multiarch = "0.5.3"
 # percpu = { version = "0.2.0", features = ["arm-el2"] }
 percpu = { git = "https://github.com/arceos-hypervisor/percpu.git", branch = "custom-base" }
 

configs/platforms/aarch64-dyn.toml

@@ -9,6 +9,8 @@ platform = "aarch64-dyn"      # str
 [plat]
 # Platform family.
 family = "aarch64-dyn" # str
+# different from the physical address.
+phys-bus-offset = 0
 
 # Not used.
 kernel-base-vaddr = "0x0"     # uint

src/vmm/fdt.rs

@@ -1,18 +1,16 @@
-use crate::vmm::{VMRef, images::LoadRange};
+use crate::vmm::{VMRef, images::{LoadRange, load_vm_image_from_memory}};
 use alloc::vec::Vec;
 use axvm::config::{AxVMCrateConfig, VmMemConfig};
 use fdt_parser::Fdt;
 use vm_fdt::{FdtWriter, FdtWriterNode};
 use axerrno::AxResult;
 
-
-pub fn updated_fdt(config: AxVMCrateConfig, dtb_size: usize, vm: VMRef) -> AxResult<Vec<LoadRange>>  {
-    let dtb_addr = config.kernel.dtb_load_addr.unwrap();
+pub fn updated_fdt(config: AxVMCrateConfig, fdt_addr: usize, dtb_size: usize, vm: VMRef) -> AxResult<Vec<LoadRange>> {
     let mut new_fdt = FdtWriter::new().unwrap();
     let mut old_node_level = 0;
     let mut child_node: Vec<FdtWriterNode> = Vec::new();
 
-    let fdt_bytes = unsafe { core::slice::from_raw_parts(dtb_addr as *const u8, dtb_size) };
+    let fdt_bytes = unsafe { core::slice::from_raw_parts(fdt_addr as *const u8, dtb_size) };
     let fdt = Fdt::from_bytes(fdt_bytes)
         .map_err(|e| format!("Failed to parse FDT: {:#?}", e))
         .expect("Failed to parse FDT");
@@ -46,17 +44,16 @@ pub fn updated_fdt(config: AxVMCrateConfig, dtb_size: usize, vm: VMRef) -> AxRes
 
         // add memory node
         if old_node_level == 1 {
-            info!("Adding memory node with regions: {:?}", config.kernel.memory_regions);
+            info!("Adding memory node with regions: 0x{:x?}", config.kernel.memory_regions);
             let memory_node = new_fdt.begin_node("memory").unwrap();
             add_memory_node(&config.kernel.memory_regions, &mut new_fdt);
             new_fdt.end_node(memory_node).unwrap();
         }
     }
     assert_eq!(old_node_level , 0);
     let new_fdt = new_fdt.finish().unwrap();
-    let load_ranges = copy_new_fdt_to_new_addr(new_fdt, dtb_addr, vm);
+    let load_ranges = copy_new_fdt_to_new_addr(new_fdt, config.kernel.dtb_load_addr.unwrap(), vm);
 
-    // panic!("FDT parsing complete, starting to update FDT...");
     Ok(load_ranges)
 }
 
@@ -79,23 +76,11 @@ fn add_memory_node(new_memory: &Vec<VmMemConfig>, new_fdt: &mut FdtWriter) {
         .unwrap();
 }
 
-fn copy_new_fdt_to_new_addr(
-    new_fdt: Vec<u8>,
-    new_dtb_addr: usize,
-    vm: VMRef
-) -> Vec<LoadRange> {
-    unsafe {
-        core::ptr::copy_nonoverlapping(new_fdt.as_ptr(), new_dtb_addr as *mut u8, new_fdt.len());
-    }
-    let new_fdt_regions = vm
-        .get_image_load_region(new_dtb_addr.into(), new_fdt.len())
-        .unwrap();
+fn copy_new_fdt_to_new_addr(new_fdt: Vec<u8>, new_dtb_addr: usize, vm: VMRef) -> Vec<LoadRange> {
     let mut load_ranges = alloc::vec![];
-    for buffer in new_fdt_regions {
-        load_ranges.push(LoadRange {
-            start: (buffer.as_ptr() as usize).into(),
-            size: buffer.len(),
-        });
-    }
+    load_ranges.append(
+        &mut load_vm_image_from_memory(&new_fdt, new_dtb_addr, vm.clone())
+            .expect("Failed to load VM images"),
+    );
     load_ranges
 }

src/vmm/images.rs

@@ -48,7 +48,6 @@ pub struct LoadRange {
 /// Load VM images from memory
 /// into the guest VM's memory space based on the VM configuration.
 fn load_vm_images_from_memory(config: AxVMCrateConfig, vm: VMRef) -> AxResult<Vec<LoadRange>> {
-    let vm_config = config.clone();
     info!("Loading VM[{}] images from memory", config.base.id);
     let mut load_ranges = Vec::new();
 
@@ -64,16 +63,11 @@ fn load_vm_images_from_memory(config: AxVMCrateConfig, vm: VMRef) -> AxResult<Ve
 
     // Load DTB image
     if let Some(buffer) = vm_imags.dtb {
-        load_ranges.append(
-            &mut load_vm_image_from_memory(
-                buffer,
-                config.kernel.dtb_load_addr.unwrap(),
-                vm.clone(),
-            )
-            .expect("Failed to load DTB images"),
-        );
-
-        load_ranges.append(&mut updated_fdt(vm_config, buffer.len(), vm.clone())?);
+        let mut dtb_buffer = Vec::with_capacity(buffer.len());
+        dtb_buffer.extend_from_slice(&buffer); 
+        let dtb_buffer_addr = dtb_buffer.as_ptr() as usize;
+        debug!("dtb_buffer_addr: 0x{:x}, size:{}", dtb_buffer_addr, dtb_buffer.len());
+        load_ranges.append(&mut updated_fdt(config.clone(), dtb_buffer_addr, buffer.len(), vm.clone())?);
     }
 
     // Load BIOS image
@@ -91,7 +85,7 @@ fn load_vm_images_from_memory(config: AxVMCrateConfig, vm: VMRef) -> AxResult<Ve
     Ok(load_ranges)
 }
 
-fn load_vm_image_from_memory(
+pub fn load_vm_image_from_memory(
     image_buffer: &[u8],
     load_addr: usize,
     vm: VMRef,
@@ -148,7 +142,7 @@ mod fs {
     use axerrno::{AxResult, ax_err, ax_err_type};
 
     use super::*;
-
+    use std::io::{BufReader, Read};
     /// Loads the VM image files from the filesystem
     /// into the guest VM's memory space based on the VM configuration.
     pub(crate) fn load_vm_images_from_filesystem(
@@ -191,21 +185,20 @@ mod fs {
         // Load DTB image if needed.
         // Todo: generate DTB file for guest VM.
         if let Some(dtb_path) = config.kernel.dtb_path {
-            let (_, dtb_size) = open_image_file(dtb_path.as_str())?;
-            info!("DTB file size {}", dtb_size);
-            if let Some(dtb_load_addr) = config.kernel.dtb_load_addr {
-                info!("DTB load addr 0x{:x}", dtb_load_addr);
-                load_ranges.append(&mut load_vm_image(
-                    dtb_path,
-                    GuestPhysAddr::from(dtb_load_addr),
-                    vm.clone(),
-                )?);
-            } else {
-                return ax_err!(NotFound, "DTB load addr is missed");
-            }
-
-            load_ranges.append(&mut updated_fdt(vm_config, dtb_size, vm.clone())?);
+            let (dtb_file, dtb_size) = open_image_file(dtb_path.as_str())?;
+            let mut file = BufReader::new(dtb_file);
+            let mut dtb_buffer = vec![0; dtb_size];
+
+            file.read_exact(&mut dtb_buffer).map_err(|err| {
+                ax_err_type!(
+                    Io,
+                    format!("Failed in reading from file {}, err {:?}", dtb_path, err)
+                )
+            })?;
 
+            let dtb_buffer_addr = dtb_buffer.as_ptr() as usize;
+            debug!("DTB buffer addr: 0x{:x}, size: {}", dtb_buffer_addr, dtb_size);
+            load_ranges.append(&mut updated_fdt(vm_config, dtb_buffer_addr, dtb_size, vm.clone())?);
         };
         Ok(load_ranges)
     }