fix flush dcache bug (#146)

* fix

* fmt code

* bug: when the kernel is in the filesystem, ​the kernel address cache is not flushed.

---------

Co-authored-by: songzhy <[email protected]>

Author: ZR233

src/utils/mod.rs

@@ -1,12 +1,13 @@
 mod arch;
 
 pub mod cache {
+    #[allow(unused)]
     /// Invalidate the data cache.
     pub unsafe fn cache_invalidate_d(start: usize, len: usize) {
-        super::arch::cache::cache_invalidate_d(start, len);
+        unsafe { super::arch::cache::cache_invalidate_d(start, len) };
     }
     /// Clean and invalidate the data cache.
     pub unsafe fn cache_clean_invalidate_d(start: usize, len: usize) {
-        super::arch::cache::cache_clean_invalidate_d(start, len);
+        unsafe { super::arch::cache::cache_clean_invalidate_d(start, len) };
     }
 }

src/vmm/images.rs

@@ -1,68 +1,92 @@
+use alloc::vec::Vec;
+
 use axaddrspace::GuestPhysAddr;
 use axerrno::AxResult;
 
 use axvm::config::AxVMCrateConfig;
+use memory_addr::PhysAddr;
 
-#[cfg(target_arch = "aarch64")]
-use crate::utils::cache::cache_clean_invalidate_d;
 use crate::vmm::VMRef;
 use crate::vmm::config::config;
 
 /// Loads the VM image files.
 pub fn load_vm_images(config: AxVMCrateConfig, vm: VMRef) -> AxResult {
-    match config.kernel.image_location.as_deref() {
-        Some("memory") => load_vm_images_from_memory(config, vm),
+    let load_ranges = match config.kernel.image_location.as_deref() {
+        Some("memory") => load_vm_images_from_memory(config, vm.clone()),
         #[cfg(feature = "fs")]
-        Some("fs") => fs::load_vm_images_from_filesystem(config, vm),
+        Some("fs") => fs::load_vm_images_from_filesystem(config, vm.clone()),
         _ => unimplemented!(
             "Check your \"image_location\" in config.toml, \"memory\" and \"fs\" are supported,\n NOTE: \"fs\" feature should be enabled if you want to load images from filesystem. (APP_FEATURES=fs)"
         ),
+    }?;
+    flush_vm_images(&load_ranges);
+    Ok(())
+}
+
+fn flush_vm_images(ls: &[LoadRange]) {
+    for l in ls {
+        unsafe {
+            crate::utils::cache::cache_clean_invalidate_d(l.start.as_usize(), l.size);
+        }
     }
 }
 
+struct LoadRange {
+    start: PhysAddr,
+    size: usize,
+}
+
 /// 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 {
+fn load_vm_images_from_memory(config: AxVMCrateConfig, vm: VMRef) -> AxResult<Vec<LoadRange>> {
     info!("Loading VM[{}] images from memory", config.base.id);
+    let mut load_ranges = Vec::new();
 
     let vm_imags = config::get_memory_images()
         .iter()
         .find(|&v| v.id == config.base.id)
         .expect("VM images is missed, Perhaps add `VM_CONFIGS=PATH/CONFIGS/FILE` command.");
 
-    load_vm_image_from_memory(vm_imags.kernel, config.kernel.kernel_load_addr, vm.clone())
-        .expect("Failed to load VM images");
+    load_ranges.append(
+        &mut load_vm_image_from_memory(vm_imags.kernel, config.kernel.kernel_load_addr, vm.clone())
+            .expect("Failed to load VM images"),
+    );
 
     // Load DTB image
     if let Some(buffer) = vm_imags.dtb {
-        load_vm_image_from_memory(buffer, config.kernel.dtb_load_addr.unwrap(), vm.clone())
-            .expect("Failed to load DTB images");
+        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 BIOS image
     if let Some(buffer) = vm_imags.bios {
-        load_vm_image_from_memory(buffer, config.kernel.bios_load_addr.unwrap(), vm.clone())
-            .expect("Failed to load BIOS images");
-    }
-    #[cfg(target_arch = "aarch64")]
-    {
-        for mem_region in &config.kernel.memory_regions {
-            debug!(
-                "flush all guest cache GPA: 0x{:x}, Size: 0x{:x}",
-                mem_region.gpa, mem_region.size
-            );
-            unsafe {
-                cache_clean_invalidate_d(mem_region.gpa, mem_region.size);
-            }
-        }
+        load_ranges.append(
+            &mut load_vm_image_from_memory(
+                buffer,
+                config.kernel.bios_load_addr.unwrap(),
+                vm.clone(),
+            )
+            .expect("Failed to load BIOS images"),
+        );
     }
 
-    Ok(())
+    Ok(load_ranges)
 }
 
-fn load_vm_image_from_memory(image_buffer: &[u8], load_addr: usize, vm: VMRef) -> AxResult {
+fn load_vm_image_from_memory(
+    image_buffer: &[u8],
+    load_addr: usize,
+    vm: VMRef,
+) -> AxResult<Vec<LoadRange>> {
     let mut buffer_pos = 0;
     let image_load_gpa = GuestPhysAddr::from(load_addr);
+    let mut load_ranges = alloc::vec![];
 
     let image_size = image_buffer.len();
 
@@ -86,7 +110,10 @@ fn load_vm_image_from_memory(image_buffer: &[u8], load_addr: usize, vm: VMRef) -
                 bytes_to_write,
             );
         }
-
+        load_ranges.push(LoadRange {
+            start: (region.as_ptr() as usize).into(),
+            size: bytes_to_write,
+        });
         // Update the position of the buffer.
         buffer_pos += bytes_to_write;
 
@@ -97,7 +124,7 @@ fn load_vm_image_from_memory(image_buffer: &[u8], load_addr: usize, vm: VMRef) -
         }
     }
 
-    Ok(())
+    Ok(load_ranges)
 }
 
 #[cfg(feature = "fs")]
@@ -112,30 +139,38 @@ mod fs {
 
     /// 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(config: AxVMCrateConfig, vm: VMRef) -> AxResult {
+    pub(crate) fn load_vm_images_from_filesystem(
+        config: AxVMCrateConfig,
+        vm: VMRef,
+    ) -> AxResult<Vec<LoadRange>> {
         info!("Loading VM images from filesystem");
+        let mut load_ranges = Vec::new();
         // Load kernel image.
-        load_vm_image(
+        load_ranges.append(&mut load_vm_image(
             config.kernel.kernel_path,
             GuestPhysAddr::from(config.kernel.kernel_load_addr),
             vm.clone(),
-        )?;
+        )?);
         // Load BIOS image if needed.
         if let Some(bios_path) = config.kernel.bios_path {
             if let Some(bios_load_addr) = config.kernel.bios_load_addr {
-                load_vm_image(bios_path, GuestPhysAddr::from(bios_load_addr), vm.clone())?;
+                load_ranges.append(&mut load_vm_image(
+                    bios_path,
+                    GuestPhysAddr::from(bios_load_addr),
+                    vm.clone(),
+                )?);
             } else {
                 return ax_err!(NotFound, "BIOS load addr is missed");
             }
         };
         // Load Ramdisk image if needed.
         if let Some(ramdisk_path) = config.kernel.ramdisk_path {
             if let Some(ramdisk_load_addr) = config.kernel.ramdisk_load_addr {
-                load_vm_image(
+                load_ranges.append(&mut load_vm_image(
                     ramdisk_path,
                     GuestPhysAddr::from(ramdisk_load_addr),
                     vm.clone(),
-                )?;
+                )?);
             } else {
                 return ax_err!(NotFound, "Ramdisk load addr is missed");
             }
@@ -144,22 +179,36 @@ mod fs {
         // Todo: generate DTB file for guest VM.
         if let Some(dtb_path) = config.kernel.dtb_path {
             if let Some(dtb_load_addr) = config.kernel.dtb_load_addr {
-                load_vm_image(dtb_path, GuestPhysAddr::from(dtb_load_addr), vm.clone())?;
+                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");
             }
         };
-        Ok(())
+        Ok(load_ranges)
     }
 
-    fn load_vm_image(image_path: String, image_load_gpa: GuestPhysAddr, vm: VMRef) -> AxResult {
+    fn load_vm_image(
+        image_path: String,
+        image_load_gpa: GuestPhysAddr,
+        vm: VMRef,
+    ) -> AxResult<Vec<LoadRange>> {
         use std::io::{BufReader, Read};
         let (image_file, image_size) = open_image_file(image_path.as_str())?;
 
         let image_load_regions = vm.get_image_load_region(image_load_gpa, image_size)?;
+        let mut load_ranges = Vec::with_capacity(image_load_regions.len());
+
         let mut file = BufReader::new(image_file);
 
         for buffer in image_load_regions {
+            load_ranges.push(LoadRange {
+                start: (buffer.as_ptr() as usize).into(),
+                size: buffer.len(),
+            });
             file.read_exact(buffer).map_err(|err| {
                 ax_err_type!(
                     Io,
@@ -168,7 +217,7 @@ mod fs {
             })?
         }
 
-        Ok(())
+        Ok(load_ranges)
     }
 
     fn open_image_file(file_name: &str) -> AxResult<(File, usize)> {