feat(prototyper): allocate the patched fdt on the heap. (rustsbi#155)

* feat(prototyper): allocate the patched fdt on the heap.

Signed-off-by: jackfiled <[email protected]>

* fix(prototyper): add more comments for the buffer leaking operation and fix typo.

Signed-off-by: jackfiled <[email protected]>

* feat(prototyper): extend the heap size to 1M.

Signed-off-by: jackfiled <[email protected]>

* feat(prototyper): update serde-device-tree version.

Signed-off-by: jackfiled <[email protected]>

---------

Signed-off-by: jackfiled <[email protected]>

Author: luojia65

prototyper/prototyper/Cargo.toml

@@ -24,7 +24,7 @@ sbi-spec = { version = "0.0.8", features = [
 serde = { version = "1.0.202", default-features = false, features = ["derive"] }
 aclint = { git = "https://github.com/rustsbi/aclint", rev = "b2136a66" }
 fast-trap = { git = "https://github.com/rustsbi/fast-trap", rev = "8d855afa", features = ["riscv-m"] }
-serde-device-tree = { git = "https://github.com/rustsbi/serde-device-tree", rev = "805718b", default-features = false, features = ["ser"] }
+serde-device-tree = { git = "https://github.com/rustsbi/serde-device-tree", rev = "f051687", default-features = false, features = ["ser"] }
 uart_xilinx = { git = "https://github.com/duskmoon314/uart-rs/", rev = "12be9142" }
 xuantie-riscv = { git = "https://github.com/rustsbi/xuantie", rev = "7a521c04" }
 bouffalo-hal = { git = "https://github.com/rustsbi/bouffalo-hal", rev = "968b949", features = [

prototyper/prototyper/build.rs

@@ -80,7 +80,6 @@ SECTIONS {
 
     .text : ALIGN(0x1000) {
         *(.fdt)
-        *(.patched_fdt)
     }
     . = ALIGN(4);
     sbi_end = .;

prototyper/prototyper/config/default.toml

@@ -1,6 +1,6 @@
 num_hart_max = 8
 stack_size_per_hart = 16384 # 16 * 1024
-heap_size = 32768 # 32 * 1024
+heap_size = 1048576 # 1024 * 1024
 page_size = 4096
 log_level = "INFO"
 jump_address = 0x80200000

prototyper/prototyper/src/firmware/mod.rs

@@ -11,7 +11,7 @@ cfg_if::cfg_if! {
     }
 }
 
-use alloc::format;
+use alloc::{format, vec};
 #[allow(unused)]
 use core::arch::{asm, naked_asm};
 use core::ops::Range;
@@ -38,9 +38,6 @@ pub struct BootHart {
 pub extern "C" fn raw_fdt() {
     naked_asm!(concat!(".incbin \"", env!("PROTOTYPER_FDT_PATH"), "\""),)
 }
-const DEVICE_TREE_BUFFER_LENGTH: usize = 0x10000;
-#[unsafe(link_section = ".patched_fdt")]
-static mut DEVICE_TREE_BUFFER: [u8; DEVICE_TREE_BUFFER_LENGTH] = [0u8; DEVICE_TREE_BUFFER_LENGTH];
 
 #[inline]
 #[cfg(feature = "fdt")]
@@ -71,16 +68,12 @@ pub fn get_boot_hart(opaque: usize, nonstandard_a2: usize) -> BootHart {
 pub fn patch_device_tree(device_tree_ptr: usize) -> usize {
     use serde_device_tree::buildin::Node;
     use serde_device_tree::ser::serializer::ValueType;
-    use serde_device_tree::*;
+    use serde_device_tree::{Dtb, DtbPtr};
     let Ok(ptr) = DtbPtr::from_raw(device_tree_ptr as *mut _) else {
         panic!("Can not parse device tree!");
     };
-    let origin_size = ptr.align();
+    let original_length = ptr.align();
     let dtb = Dtb::from(ptr);
-    // TODO: use probe length instead of a magic const number.
-    if origin_size + 2048 > DEVICE_TREE_BUFFER_LENGTH {
-        panic!("dtb file is too big!");
-    }
 
     // Update const
     unsafe {
@@ -91,7 +84,7 @@ pub fn patch_device_tree(device_tree_ptr: usize) -> usize {
     let sbi_end = unsafe { SBI_END_ADDRESS };
 
     let dtb = dtb.share();
-    let root: serde_device_tree::buildin::Node =
+    let root: Node =
         serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize_root);
     let tree: Node = root.deserialize();
 
@@ -129,17 +122,38 @@ pub fn patch_device_tree(device_tree_ptr: usize) -> usize {
     let patch2 =
         serde_device_tree::ser::patch::Patch::new(&path_name, &new_base_2 as _, ValueType::Node);
     let raw_list = [patch1, patch2];
-    // Only patch `reserved-memory` when it not exists.
+    // Only add `reserved-memory` section when it not exists.
     let list = if tree.find("/reserved-memory").is_some() {
         &raw_list[1..]
     } else {
         &raw_list[..]
     };
 
-    unsafe {
-        serde_device_tree::ser::to_dtb(&tree, &list, &mut DEVICE_TREE_BUFFER).unwrap();
-        DEVICE_TREE_BUFFER.as_ptr() as _
-    }
+    // Firstly, allocate a temporary buffer to store the fdt and get the real total size of the patched fdt.
+    // TODO: The serde_device_tree can provide a function to calculate the accuracy size of patched fdt.
+    debug!(
+        "Allocate temporary DTB buffer with length 0x{:x}.",
+        original_length + 2048
+    );
+    let mut temporary_buffer = vec![0u8; original_length + 2048];
+    serde_device_tree::ser::to_dtb(&tree, &list, &mut temporary_buffer).unwrap();
+    let Ok(patched_dtb_ptr) = DtbPtr::from_raw(temporary_buffer.as_mut_ptr()) else {
+        panic!("Failed to parse the patched dtb.")
+    };
+    let patched_length = patched_dtb_ptr.align();
+
+    // Secondly, allocate the exactly buffer to store the fdt.
+    let mut patched_dtb_buffer = vec![0u8; patched_length];
+    serde_device_tree::ser::to_dtb(&tree, &list, &mut patched_dtb_buffer).unwrap();
+    // Intentionally leak the buffer so that the patched DTB remains valid for the lifetime of the firmware.
+    // This is required because the returned pointer is used elsewhere and must not be deallocated.
+    let patched_dtb = patched_dtb_buffer.leak();
+    info!(
+        "The patched dtb is located at 0x{:x} with length 0x{:x}.",
+        patched_dtb.as_ptr() as usize,
+        patched_length
+    );
+    patched_dtb.as_ptr() as usize
 }
 
 static mut SBI_START_ADDRESS: usize = 0;

prototyper/prototyper/src/sbi/heap.rs

@@ -4,8 +4,9 @@ use buddy_system_allocator::LockedHeap;
 #[unsafe(link_section = ".bss.heap")]
 static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE];
 
+const BUDDY_MAX_ORDER: usize = 20;
 #[global_allocator]
-static HEAP_ALLOCATOR: LockedHeap<15> = LockedHeap::<15>::empty();
+static HEAP_ALLOCATOR: LockedHeap<BUDDY_MAX_ORDER> = LockedHeap::<BUDDY_MAX_ORDER>::empty();
 
 pub fn sbi_heap_init() {
     unsafe {
@@ -17,5 +18,16 @@ pub fn sbi_heap_init() {
 
 #[alloc_error_handler]
 pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
+    error!("Heap stats:");
+    {
+        let heap = HEAP_ALLOCATOR.lock();
+        error!("\tTotal size: {}", heap.stats_total_bytes());
+        error!("\tRequested size: {}", heap.stats_alloc_user());
+        error!("\tAllocated size: {}", heap.stats_alloc_actual());
+        error!(
+            "Currently the heap only support allocate buffer with max length {} bytes.",
+            1 << (BUDDY_MAX_ORDER - 1)
+        );
+    }
     panic!("Heap allocation error, layout = {:?}", layout);
 }