caculate dtb_addr

Author: szy

src/vmm/config.rs

@@ -1,11 +1,7 @@
 use axaddrspace::GuestPhysAddr;
 use axerrno::AxResult;
-use axvm::{
-    VMMemoryRegion,
-    config::{AxVMConfig, AxVMCrateConfig, VmMemMappingType},
-};
+use axvm::config::{AxVMConfig, AxVMCrateConfig, VmMemMappingType};
 use core::alloc::Layout;
-use memory_addr::MemoryAddr;
 
 use crate::vmm::{VM, images::ImageLoader, vm_list::push_vm};
 
@@ -129,8 +125,6 @@ pub fn init_guest_vm(raw_cfg: &str) -> AxResult {
         .cloned()
         .expect("VM must have at least one memory region");
 
-    config_guest_address(&vm, &main_mem);
-
     // Load corresponding images for VM.
     info!("VM[{}] created success, loading images...", vm.id());
 
@@ -144,29 +138,6 @@ pub fn init_guest_vm(raw_cfg: &str) -> AxResult {
     Ok(())
 }
 
-fn config_guest_address(vm: &VM, main_memory: &VMMemoryRegion) {
-    const MB: usize = 1024 * 1024;
-    vm.with_config(|config| {
-        if main_memory.is_identical() {
-            debug!(
-                "Adjusting kernel load address from {:#x} to {:#x}",
-                config.image_config.kernel_load_gpa, main_memory.gpa
-            );
-            let mut kernel_addr = main_memory.gpa;
-            if config.image_config.bios_load_gpa.is_some() {
-                kernel_addr += MB * 2; // leave 2MB for BIOS
-            }
-            let dtb_addr = (main_memory.gpa + (main_memory.size().min(512 * MB) / 2).max(64 * MB))
-                .align_up(2 * MB);
-
-            config.image_config.kernel_load_gpa = kernel_addr;
-            config.cpu_config.bsp_entry = kernel_addr;
-            config.cpu_config.ap_entry = kernel_addr;
-            config.image_config.dtb_load_gpa = Some(dtb_addr);
-        }
-    });
-}
-
 fn vm_alloc_memorys(vm_create_config: &AxVMCrateConfig, vm: &VM) {
     const MB: usize = 1024 * 1024;
     const ALIGN: usize = 2 * MB;

src/vmm/fdt/create.rs

@@ -7,6 +7,7 @@ use core::ptr::NonNull;
 use axaddrspace::GuestPhysAddr;
 use axvm::{VMMemoryRegion, config::AxVMCrateConfig};
 use fdt_parser::{Fdt, Node};
+use memory_addr::MemoryAddr;
 use vm_fdt::{FdtWriter, FdtWriterNode};
 
 use crate::vmm::{VMRef, images::load_vm_image_from_memory};
@@ -259,7 +260,7 @@ fn add_memory_node(new_memory: &[VMMemoryRegion], new_fdt: &mut FdtWriter) {
     new_fdt.property_string("device_type", "memory").unwrap();
 }
 
-pub fn update_fdt(dest_addr: GuestPhysAddr, fdt_src: NonNull<u8>, dtb_size: usize, vm: VMRef) {
+pub fn update_fdt(fdt_src: NonNull<u8>, dtb_size: usize, vm: VMRef) {
     let mut new_fdt = FdtWriter::new().unwrap();
     let mut previous_node_level = 0;
     let mut node_stack: Vec<FdtWriterNode> = Vec::new();
@@ -315,12 +316,54 @@ pub fn update_fdt(dest_addr: GuestPhysAddr, fdt_src: NonNull<u8>, dtb_size: usiz
     let new_fdt_bytes = new_fdt.finish().unwrap();
 
     // crate::vmm::fdt::print::print_guest_fdt(new_fdt_bytes.as_slice());
-
+    let vm_clone = vm.clone();
+    let dest_addr = calculate_dtb_load_addr(vm, new_fdt_bytes.len());
+    info!("New FDT will be loaded at {:x}", dest_addr);
     // Load the updated FDT into VM
-    load_vm_image_from_memory(&new_fdt_bytes, dest_addr, vm.clone())
+    load_vm_image_from_memory(&new_fdt_bytes, dest_addr, vm_clone)
         .expect("Failed to load VM images");
 }
 
+fn calculate_dtb_load_addr(vm: VMRef, fdt_size: usize) -> GuestPhysAddr {
+    const MB: usize = 1024 * 1024;
+
+    // Get main memory from VM memory regions outside the closure
+    let main_memory = vm
+        .memory_regions()
+        .first()
+        .cloned()
+        .expect("VM must have at least one memory region");
+
+    vm.with_config(|config| {
+        let dtb_addr = if let Some(addr) = config.image_config.dtb_load_gpa {
+            // If dtb_load_gpa is already set, use the original value
+            addr
+        } else {
+            // If dtb_load_gpa is None, calculate based on memory size and FDT size
+            if main_memory.size() > 512 * MB {
+                // When memory size is greater than 512MB, place in the last area of the first 512MB
+                let available_space = 2 * MB;
+                if fdt_size <= available_space {
+                    (main_memory.gpa + 512 * MB - available_space).align_down(2 * MB)
+                } else {
+                    // If FDT is larger than available space, place it at the end of main memory
+                    (main_memory.gpa + main_memory.size() - fdt_size).align_down(2 * MB)
+                }
+            } else {
+                // When memory size is less than or equal to 512MB, place at the end of main_memory
+                if fdt_size <= main_memory.size() {
+                    (main_memory.gpa + main_memory.size() - fdt_size).align_down(2 * MB)
+                } else {
+                    // This shouldn't happen, but just in case
+                    main_memory.gpa.align_down(2 * MB)
+                }
+            }
+        };
+        config.image_config.dtb_load_gpa = Some(dtb_addr);
+        dtb_addr
+    })
+}
+
 pub fn update_cpu_node(fdt: &Fdt, host_fdt: &Fdt, crate_config: &AxVMCrateConfig) -> Vec<u8> {
     let mut new_fdt = FdtWriter::new().unwrap();
     let mut previous_node_level = 0;

src/vmm/images/mod.rs

@@ -10,10 +10,10 @@ use crate::vmm::VMRef;
 use crate::vmm::config::{config, get_vm_dtb_arc};
 
 #[cfg(target_arch = "aarch64")]
-use crate::vmm::fdt::update_fdt;
+use core::ptr::NonNull;
 
 #[cfg(target_arch = "aarch64")]
-use core::ptr::NonNull;
+use crate::vmm::fdt::update_fdt;
 
 mod linux;
 
@@ -107,23 +107,17 @@ impl ImageLoader {
             .expect("Failed to load VM images");
         // Load DTB image
         let vm_config = axvm::config::AxVMConfig::from(self.config.clone());
-        if let Some(dtb_arc) = get_vm_dtb_arc(&vm_config)
-            && let Some(dtb_load_gpa) = self.dtb_load_gpa
-        {
-            let dtb_slice: &[u8] = &dtb_arc;
-            debug!(
-                "DTB buffer addr: {:x}, size: {:#}",
-                dtb_load_gpa,
-                Byte::from(dtb_slice.len())
-            );
 
+        if let Some(dtb_arc) = get_vm_dtb_arc(&vm_config) {
+            let _dtb_slice: &[u8] = &dtb_arc;
             #[cfg(target_arch = "aarch64")]
             update_fdt(
-                dtb_load_gpa,
-                NonNull::new(dtb_slice.as_ptr() as *mut u8).unwrap(),
-                dtb_slice.len(),
+                NonNull::new(_dtb_slice.as_ptr() as *mut u8).unwrap(),
+                _dtb_slice.len(),
                 self.vm.clone(),
             );
+        } else {
+            info!("dtb_load_gpa not provided");
         }
 
         // Load BIOS image
@@ -256,21 +250,12 @@ pub mod fs {
         };
         // Load DTB image if needed.
         let vm_config = axvm::config::AxVMConfig::from(loader.config.clone());
-        if let Some(dtb_arc) = get_vm_dtb_arc(&vm_config)
-            && let Some(dtb_load_gpa) = loader.dtb_load_gpa
-        {
-            let dtb_slice: &[u8] = &dtb_arc;
-            debug!(
-                "DTB buffer addr: {:x}, size: {:#}",
-                dtb_load_gpa,
-                Byte::from(dtb_slice.len())
-            );
-
+        if let Some(dtb_arc) = get_vm_dtb_arc(&vm_config) {
+            let _dtb_slice: &[u8] = &dtb_arc;
             #[cfg(target_arch = "aarch64")]
             update_fdt(
-                dtb_load_gpa,
-                NonNull::new(dtb_slice.as_ptr() as *mut u8).unwrap(),
-                dtb_slice.len(),
+                NonNull::new(_dtb_slice.as_ptr() as *mut u8).unwrap(),
+                _dtb_slice.len(),
                 loader.vm.clone(),
             );
         }