aarch64: pass bootinfo from bootloader to kernel

Author: equation314

bootloader/Cargo.lock

@@ -7,10 +7,8 @@ edition = "2018"
 [dependencies]
 xmas-elf = "0.6.2"
 fixedvec = "0.2.3"
+bootinfo = { path = "bootinfo" }
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
 aarch64 = { git = "https://github.com/rcore-os/aarch64", version = "2.7.0" }
-bcm2837 = { git = "https://github.com/rcore-os/bcm2837", version = "2.0.0" }
-
-[build-dependencies]
-cc = "1.0"
+bcm2837 = { git = "https://github.com/rcore-os/bcm2837", version = "2.1.0", features = ["bare_metal"] }

bootloader/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "bootinfo"
+version = "0.1.0"
+authors = ["equation314 <equation618@gmail.com>"]
+edition = "2018"
+
+[dependencies]

bootloader/bootinfo/Cargo.toml

@@ -0,0 +1,18 @@
+//! Provides boot information to the kernel.
+#![no_std]
+
+#[cfg(target_arch = "aarch64")]
+#[derive(Debug)]
+#[repr(C)]
+pub struct BootInfo {
+    pub physical_memory_start: usize,
+    pub physical_memory_end: usize,
+    pub physical_memory_offset: usize,
+}
+
+#[cfg(target_arch = "mips")]
+#[derive(Debug)]
+#[repr(C)]
+pub struct BootInfo {
+    pub dtb: usize,
+}

bootloader/bootinfo/src/lib.rs

@@ -1,62 +1,11 @@
-extern crate cc;
-
-use std::fs::File;
-use std::io::{Result, Write};
-use std::path::Path;
-
 fn main() {
-    if let Ok(file_path) = gen_payload_asm() {
-        cc::Build::new().file(&file_path).compile("payload");
-    }
-}
-
-/// include payload and dtb in sections of asm
-fn gen_payload_asm() -> Result<std::path::PathBuf> {
-    let out_dir = std::env::var("OUT_DIR").unwrap();
-    let payload = std::env::var("PAYLOAD").unwrap();
-    let dtb = std::env::var("DTB").unwrap();
-
-    if !Path::new(&payload).is_file() {
-        panic!("Kernel payload `{}` not found", payload)
-    }
-
-    let mut has_dtb = true;
-
-    if !Path::new(&dtb).is_file() {
-        has_dtb = false;
-    }
-
-    let file_path = Path::new(&out_dir).join("payload.S");
-    let mut f = File::create(&file_path).unwrap();
-
-    println!("{:x?} {:x?}", payload, file_path);
-
-    write!(f, "# generated by build.rs - do not edit")?;
-    write!(f, r#"
-    .section .payload,"a"
-    .align 12
-    .global _kernel_payload_start, _kernel_payload_end
-_kernel_payload_start:
-    .incbin "{}"
-_kernel_payload_end:
-    "#, payload)?;
-
-    println!("cargo:rerun-if-changed={}", payload);
     println!("cargo:rerun-if-env-changed=PAYLOAD");
+    println!("cargo:rerun-if-env-changed=DTB");
 
-    if has_dtb {
-        write!(f, r#"
-    .section .dtb,"a"
-    .align 12
-    .global _dtb_start, _dtb_end
-_dtb_start:
-    .incbin "{}"
-_dtb_end:
-    "#, dtb)?;
-        println!("{:x?} {:x?}", dtb, file_path);
+    if let Ok(payload) = std::env::var("PAYLOAD") {
+        println!("cargo:rerun-if-changed={}", payload);
+    }
+    if let Ok(dtb) = std::env::var("DTB") {
         println!("cargo:rerun-if-changed={}", dtb);
-        println!("cargo:rerun-if-env-changed=DTB");
     }
-
-    Ok(file_path)
 }

bootloader/build.rs

@@ -1,8 +1,11 @@
 use aarch64::addr::{PhysAddr, VirtAddr};
-use aarch64::paging::{memory_attribute::*, Page, PageTable, PageTableAttribute, PageTableFlags as EF, PhysFrame};
-use aarch64::paging::{Size1GiB, Size2MiB, Size4KiB};
+use aarch64::paging::{memory_attribute::*, PageTable, PageTableAttribute, PageTableFlags as EF};
+use aarch64::paging::{Page, PhysFrame, Size1GiB, Size2MiB, Size4KiB};
 use aarch64::{asm::*, barrier, regs::*};
-use bcm2837::addr::{phys_to_virt, virt_to_phys, PHYSICAL_IO_BASE};
+use bcm2837::addr::{phys_to_virt, virt_to_phys};
+use bcm2837::addr::{PHYSICAL_IO_START, PHYSICAL_IO_END, PHYSICAL_MEMORY_OFFSET};
+use bcm2837::atags::Atags;
+use bootinfo::BootInfo;
 use core::ptr;
 use fixedvec::FixedVec;
 use xmas_elf::program::{ProgramHeader64, Type};
@@ -39,15 +42,15 @@ fn create_page_table(start_paddr: usize, end_paddr: usize) {
         p2[page.p2_index()].set_block::<Size2MiB>(paddr, block_flags, MairNormal::attr_value());
     }
     // device memory
-    for frame in PhysFrame::<Size2MiB>::range_of(PHYSICAL_IO_BASE as u64, 0x4000_0000) {
+    for frame in PhysFrame::<Size2MiB>::range_of(PHYSICAL_IO_START as u64, PHYSICAL_IO_END as u64) {
         let paddr = frame.start_address();
         let vaddr = VirtAddr::new(phys_to_virt(paddr.as_u64() as usize) as u64);
         let page = Page::<Size2MiB>::containing_address(vaddr);
         p2[page.p2_index()].set_block::<Size2MiB>(paddr, block_flags | EF::PXN, MairDevice::attr_value());
     }
 
     p3[0].set_frame(frame_lvl2, EF::default_table(), PageTableAttribute::new(0, 0, 0));
-    p3[1].set_block::<Size1GiB>(PhysAddr::new(0x4000_0000), block_flags | EF::PXN, MairDevice::attr_value());
+    p3[1].set_block::<Size1GiB>(PhysAddr::new(PHYSICAL_IO_END as u64), block_flags | EF::PXN, MairDevice::attr_value());
 
     p4[0].set_frame(frame_lvl3, EF::default_table(), PageTableAttribute::new(0, 0, 0));
 
@@ -101,7 +104,21 @@ fn enable_mmu() {
     unsafe { barrier::isb(barrier::SY) }
 }
 
-pub fn map_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader64>) {
+/// Returns the (start address, end address) of the physical memory on this
+/// system if it can be determined. If it cannot, `None` is returned.
+///
+/// This function is expected to return `Some` under all normal cirumstances.
+fn probe_memory() -> Option<(usize, usize)> {
+    let mut atags: Atags = Atags::get();
+    while let Some(atag) = atags.next() {
+        if let Some(mem) = atag.mem() {
+            return Some((mem.start as usize, (mem.start + mem.size) as usize));
+        }
+    }
+    None
+}
+
+pub fn copy_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader64>) -> (BootInfo, usize) {
     // reverse program headers to avoid overlapping in memory copying
     let mut space = alloc_stack!([ProgramHeader64; 32]);
     let mut rev_segments = FixedVec::new(&mut space);
@@ -134,6 +151,16 @@ pub fn map_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader64>) {
         }
     }
 
-    create_page_table(0, PHYSICAL_IO_BASE);
+    let (start, end) = probe_memory().expect("failed to find memory map");
+    create_page_table(start, end);
     enable_mmu();
+
+    (
+        BootInfo {
+            physical_memory_start: start,
+            physical_memory_end: end,
+            physical_memory_offset: PHYSICAL_MEMORY_OFFSET,
+        },
+        end_vaddr.as_u64() as usize,
+    )
 }

bootloader/src/arch/aarch64/mod.rs

@@ -1,3 +1,4 @@
+use bootinfo::BootInfo;
 use core::ptr;
 use fixedvec::FixedVec;
 use xmas_elf::program::{ProgramHeader32, Type};
@@ -6,14 +7,15 @@ const KERNEL_OFFSET: u32 = 0x80000000;
 
 global_asm!(include_str!("boot.S"));
 
-pub fn copy_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader32>) {
+pub fn copy_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader32>) -> (BootInfo, usize) {
     // reverse program headers to avoid overlapping in memory copying
     let mut space = alloc_stack!([ProgramHeader32; 32]);
     let mut rev_segments = FixedVec::new(&mut space);
     for i in (0..segments.len()).rev() {
         rev_segments.push(segments[i]).unwrap();
     }
 
+    let mut end_vaddr = 0;
     for segment in &rev_segments {
         if segment.get_type() != Ok(Type::Load) {
             continue;
@@ -29,6 +31,15 @@ pub fn copy_kernel(kernel_start: usize, segments: &FixedVec<ProgramHeader32>) {
             ptr::copy(src, dst, file_size as usize);
             ptr::write_bytes(dst.offset(file_size as isize), 0, (mem_size - file_size) as usize);
         }
+        if virt_addr + mem_size > end_vaddr {
+            end_vaddr = virt_addr + mem_size;
+        }
     }
 
+    (
+        BootInfo {
+            dtb: include_bytes!(concat!("../../../", env!("DTB"))).as_ptr() as usize,
+        },
+        end_vaddr as usize,
+    )
 }