added rv32 smp booting, with slight modification to bbl

kernel/src/arch/riscv32/consts.rs

@@ -0,0 +1,14 @@
+// Physical address available on THINPAD:
+// [0x80000000, 0x80800000]
+const P2_SIZE: usize = 1 << 22;
+const P2_MASK: usize = 0x3ff << 22;
+pub const RECURSIVE_PAGE_PML4: usize = 0x3fe;
+pub const KERNEL_OFFSET: usize = 0;
+pub const KERNEL_PML4: usize = 0x8000_0000 >> 22;
+pub const KERNEL_HEAP_OFFSET: usize = 0x8020_0000;
+pub const KERNEL_HEAP_SIZE: usize = 0x0020_0000;
+pub const MEMORY_OFFSET: usize = 0x8000_0000;
+pub const MEMORY_END: usize = 0x8080_0000;
+pub const USER_STACK_OFFSET: usize = 0x70000000;
+pub const USER_STACK_SIZE: usize = 0x10000;
+pub const USER32_STACK_OFFSET: usize = USER_STACK_OFFSET;

kernel/src/arch/riscv32/memory.rs

@@ -3,6 +3,8 @@ use memory::{active_table, FRAME_ALLOCATOR, init_heap, MemoryArea, MemoryAttr, M
 use super::riscv::{addr::*, register::sstatus};
 use ucore_memory::PAGE_SIZE;
 
+// static mut KERNEL_MS: Option<MemorySet> = None;
+
 pub fn init() {
     #[repr(align(4096))]
     struct PageData([u8; PAGE_SIZE]);

kernel/src/arch/riscv32/mod.rs

@@ -7,15 +7,34 @@ pub mod timer;
 pub mod paging;
 pub mod memory;
 pub mod compiler_rt;
+pub mod consts;
 pub mod smp;
 
+use self::smp::*;
+
+fn others_main(hartid: usize) -> ! {
+    println!("hart {} is booting", hartid);
+    loop { }
+}
+
 #[no_mangle]
-pub extern fn rust_main(hartid: usize) -> ! {
+pub extern fn rust_main(hartid: usize, dtb: usize, hart_mask: usize) -> ! {
-    println!("Hello RISCV! {}", hartid);
+    unsafe { set_cpu_id(hartid); } 
+
+    if hartid != 0 {
+        while unsafe { !has_started(hartid) }  { }
+        others_main(hartid);
+        // others_main should not return
+    }
+
+    println!("Hello RISCV! in hart {}, {}, {}", hartid, dtb, hart_mask);
+
     ::logging::init();
     interrupt::init();
     memory::init();
     timer::init();
+
+    unsafe { start_others(hart_mask); }
     ::kmain();
 }
 

kernel/src/arch/riscv32/smp.rs

@@ -0,0 +1,31 @@
+use consts::MAX_CPU_NUM;
+use core::ptr::{read_volatile, write_volatile};
+use memory::*;
+
+static mut STARTED: [bool; MAX_CPU_NUM] = [false; MAX_CPU_NUM];
+
+pub unsafe fn set_cpu_id(cpu_id: usize) {
+    unsafe {
+        asm!("mv tp, $0" : : "r"(cpu_id));
+    }
+}
+
+pub unsafe fn get_cpu_id() -> usize {
+    let mut cpu_id = 0;
+    unsafe {
+        asm!("mv $0, tp" : : "r" (cpu_id));
+    }
+    cpu_id
+}
+
+pub unsafe fn has_started(cpu_id: usize) -> bool {
+    read_volatile(&STARTED[cpu_id])
+}
+
+pub unsafe fn start_others(hart_mask: usize) {
+    for cpu_id in 0..MAX_CPU_NUM {
+        if (hart_mask >> cpu_id) & 1 != 0 {
+            write_volatile(&mut STARTED[cpu_id], true);
+        }
+    }
+}

kernel/src/arch/x86_64/consts.rs

@@ -0,0 +1,97 @@
+// Copy from Redox consts.rs:
+
+// Because the memory map is so important to not be aliased, it is defined here, in one place
+// The lower 256 PML4 entries are reserved for userspace
+// Each PML4 entry references up to 512 GB of memory
+// The top (511) PML4 is reserved for recursive mapping
+// The second from the top (510) PML4 is reserved for the kernel
+/// The size of a single PML4
+pub const PML4_SIZE: usize = 0x0000_0080_0000_0000;
+pub const PML4_MASK: usize = 0x0000_ff80_0000_0000;
+
+/// Offset of recursive paging
+pub const RECURSIVE_PAGE_OFFSET: usize = (-(PML4_SIZE as isize)) as usize;
+pub const RECURSIVE_PAGE_PML4: usize = (RECURSIVE_PAGE_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset of kernel
+pub const KERNEL_OFFSET: usize = RECURSIVE_PAGE_OFFSET - PML4_SIZE;
+pub const KERNEL_PML4: usize = (KERNEL_OFFSET & PML4_MASK) / PML4_SIZE;
+
+pub const KERNEL_SIZE: usize = PML4_SIZE;
+
+/// Offset to kernel heap
+pub const KERNEL_HEAP_OFFSET: usize = KERNEL_OFFSET - PML4_SIZE;
+pub const KERNEL_HEAP_PML4: usize = (KERNEL_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
+/// Size of kernel heap
+pub const KERNEL_HEAP_SIZE: usize = 8 * 1024 * 1024; // 8 MB
+
+pub const MEMORY_OFFSET: usize = 0;
+
+/// Offset to kernel percpu variables
+//TODO: Use 64-bit fs offset to enable this pub const KERNEL_PERCPU_OFFSET: usize = KERNEL_HEAP_OFFSET - PML4_SIZE;
+pub const KERNEL_PERCPU_OFFSET: usize = 0xC000_0000;
+/// Size of kernel percpu variables
+pub const KERNEL_PERCPU_SIZE: usize = 64 * 1024; // 64 KB
+
+/// Offset to user image
+pub const USER_OFFSET: usize = 0;
+pub const USER_PML4: usize = (USER_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user TCB
+pub const USER_TCB_OFFSET: usize = 0xB000_0000;
+
+/// Offset to user arguments
+pub const USER_ARG_OFFSET: usize = USER_OFFSET + PML4_SIZE / 2;
+
+/// Offset to user heap
+pub const USER_HEAP_OFFSET: usize = USER_OFFSET + PML4_SIZE;
+pub const USER_HEAP_PML4: usize = (USER_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user grants
+pub const USER_GRANT_OFFSET: usize = USER_HEAP_OFFSET + PML4_SIZE;
+pub const USER_GRANT_PML4: usize = (USER_GRANT_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user stack
+pub const USER_STACK_OFFSET: usize = USER_GRANT_OFFSET + PML4_SIZE;
+pub const USER32_STACK_OFFSET: usize = 0xB000_0000;
+pub const USER_STACK_PML4: usize = (USER_STACK_OFFSET & PML4_MASK) / PML4_SIZE;
+/// Size of user stack
+pub const USER_STACK_SIZE: usize = 1024 * 1024; // 1 MB
+
+/// Offset to user sigstack
+pub const USER_SIGSTACK_OFFSET: usize = USER_STACK_OFFSET + PML4_SIZE;
+pub const USER_SIGSTACK_PML4: usize = (USER_SIGSTACK_OFFSET & PML4_MASK) / PML4_SIZE;
+/// Size of user sigstack
+pub const USER_SIGSTACK_SIZE: usize = 256 * 1024; // 256 KB
+
+/// Offset to user TLS
+pub const USER_TLS_OFFSET: usize = USER_SIGSTACK_OFFSET + PML4_SIZE;
+pub const USER_TLS_PML4: usize = (USER_TLS_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary image (used when cloning)
+pub const USER_TMP_OFFSET: usize = USER_TLS_OFFSET + PML4_SIZE;
+pub const USER_TMP_PML4: usize = (USER_TMP_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary heap (used when cloning)
+pub const USER_TMP_HEAP_OFFSET: usize = USER_TMP_OFFSET + PML4_SIZE;
+pub const USER_TMP_HEAP_PML4: usize = (USER_TMP_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary page for grants
+pub const USER_TMP_GRANT_OFFSET: usize = USER_TMP_HEAP_OFFSET + PML4_SIZE;
+pub const USER_TMP_GRANT_PML4: usize = (USER_TMP_GRANT_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary stack (used when cloning)
+pub const USER_TMP_STACK_OFFSET: usize = USER_TMP_GRANT_OFFSET + PML4_SIZE;
+pub const USER_TMP_STACK_PML4: usize = (USER_TMP_STACK_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary sigstack (used when cloning)
+pub const USER_TMP_SIGSTACK_OFFSET: usize = USER_TMP_STACK_OFFSET + PML4_SIZE;
+pub const USER_TMP_SIGSTACK_PML4: usize = (USER_TMP_SIGSTACK_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset to user temporary tls (used when cloning)
+pub const USER_TMP_TLS_OFFSET: usize = USER_TMP_SIGSTACK_OFFSET + PML4_SIZE;
+pub const USER_TMP_TLS_PML4: usize = (USER_TMP_TLS_OFFSET & PML4_MASK) / PML4_SIZE;
+
+/// Offset for usage in other temporary pages
+pub const USER_TMP_MISC_OFFSET: usize = USER_TMP_TLS_OFFSET + PML4_SIZE;
+pub const USER_TMP_MISC_PML4: usize = (USER_TMP_MISC_OFFSET & PML4_MASK) / PML4_SIZE;

kernel/src/arch/x86_64/mod.rs

@@ -12,6 +12,7 @@ pub mod idt;
 //pub mod smp;
 pub mod memory;
 pub mod io;
+pub mod consts;
 
 /// The entry point of kernel
 #[no_mangle] // don't mangle the name of this function

kernel/src/consts.rs

@@ -1,128 +1,6 @@
 #![allow(dead_code)]
 
-#[cfg(target_arch = "riscv32")]
+pub use arch::consts::*;
-pub use self::riscv::*;
-#[cfg(target_arch = "x86_64")]
-pub use self::x86_64::*;
 
 pub const MAX_CPU_NUM: usize = 8;
 pub const MAX_PROCESS_NUM: usize = 48;
-
-#[cfg(target_arch = "riscv32")]
-mod riscv {
-    // Physical address available on THINPAD:
-    // [0x80000000, 0x80800000]
-    const P2_SIZE: usize = 1 << 22;
-    const P2_MASK: usize = 0x3ff << 22;
-    pub const RECURSIVE_PAGE_PML4: usize = 0x3fe;
-    pub const KERNEL_OFFSET: usize = 0;
-    pub const KERNEL_PML4: usize = 0x8000_0000 >> 22;
-    pub const KERNEL_HEAP_OFFSET: usize = 0x8020_0000;
-    pub const KERNEL_HEAP_SIZE: usize = 0x0020_0000;
-    pub const MEMORY_OFFSET: usize = 0x8000_0000;
-    pub const MEMORY_END: usize = 0x8080_0000;
-    pub const USER_STACK_OFFSET: usize = 0x70000000;
-    pub const USER_STACK_SIZE: usize = 0x10000;
-    pub const USER32_STACK_OFFSET: usize = USER_STACK_OFFSET;
-}
-
-#[cfg(target_arch = "x86_64")]
-mod x86_64 {
-    // Copy from Redox consts.rs:
-
-    // Because the memory map is so important to not be aliased, it is defined here, in one place
-    // The lower 256 PML4 entries are reserved for userspace
-    // Each PML4 entry references up to 512 GB of memory
-    // The top (511) PML4 is reserved for recursive mapping
-    // The second from the top (510) PML4 is reserved for the kernel
-    /// The size of a single PML4
-    pub const PML4_SIZE: usize = 0x0000_0080_0000_0000;
-    pub const PML4_MASK: usize = 0x0000_ff80_0000_0000;
-
-    /// Offset of recursive paging
-    pub const RECURSIVE_PAGE_OFFSET: usize = (-(PML4_SIZE as isize)) as usize;
-    pub const RECURSIVE_PAGE_PML4: usize = (RECURSIVE_PAGE_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset of kernel
-    pub const KERNEL_OFFSET: usize = RECURSIVE_PAGE_OFFSET - PML4_SIZE;
-    pub const KERNEL_PML4: usize = (KERNEL_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    pub const KERNEL_SIZE: usize = PML4_SIZE;
-
-    /// Offset to kernel heap
-    pub const KERNEL_HEAP_OFFSET: usize = KERNEL_OFFSET - PML4_SIZE;
-    pub const KERNEL_HEAP_PML4: usize = (KERNEL_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
-    /// Size of kernel heap
-    pub const KERNEL_HEAP_SIZE: usize = 8 * 1024 * 1024; // 8 MB
-
-    pub const MEMORY_OFFSET: usize = 0;
-
-    /// Offset to kernel percpu variables
-    //TODO: Use 64-bit fs offset to enable this pub const KERNEL_PERCPU_OFFSET: usize = KERNEL_HEAP_OFFSET - PML4_SIZE;
-    pub const KERNEL_PERCPU_OFFSET: usize = 0xC000_0000;
-    /// Size of kernel percpu variables
-    pub const KERNEL_PERCPU_SIZE: usize = 64 * 1024; // 64 KB
-
-    /// Offset to user image
-    pub const USER_OFFSET: usize = 0;
-    pub const USER_PML4: usize = (USER_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user TCB
-    pub const USER_TCB_OFFSET: usize = 0xB000_0000;
-
-    /// Offset to user arguments
-    pub const USER_ARG_OFFSET: usize = USER_OFFSET + PML4_SIZE / 2;
-
-    /// Offset to user heap
-    pub const USER_HEAP_OFFSET: usize = USER_OFFSET + PML4_SIZE;
-    pub const USER_HEAP_PML4: usize = (USER_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user grants
-    pub const USER_GRANT_OFFSET: usize = USER_HEAP_OFFSET + PML4_SIZE;
-    pub const USER_GRANT_PML4: usize = (USER_GRANT_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user stack
-    pub const USER_STACK_OFFSET: usize = USER_GRANT_OFFSET + PML4_SIZE;
-    pub const USER32_STACK_OFFSET: usize = 0xB000_0000;
-    pub const USER_STACK_PML4: usize = (USER_STACK_OFFSET & PML4_MASK) / PML4_SIZE;
-    /// Size of user stack
-    pub const USER_STACK_SIZE: usize = 1024 * 1024; // 1 MB
-
-    /// Offset to user sigstack
-    pub const USER_SIGSTACK_OFFSET: usize = USER_STACK_OFFSET + PML4_SIZE;
-    pub const USER_SIGSTACK_PML4: usize = (USER_SIGSTACK_OFFSET & PML4_MASK) / PML4_SIZE;
-    /// Size of user sigstack
-    pub const USER_SIGSTACK_SIZE: usize = 256 * 1024; // 256 KB
-
-    /// Offset to user TLS
-    pub const USER_TLS_OFFSET: usize = USER_SIGSTACK_OFFSET + PML4_SIZE;
-    pub const USER_TLS_PML4: usize = (USER_TLS_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary image (used when cloning)
-    pub const USER_TMP_OFFSET: usize = USER_TLS_OFFSET + PML4_SIZE;
-    pub const USER_TMP_PML4: usize = (USER_TMP_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary heap (used when cloning)
-    pub const USER_TMP_HEAP_OFFSET: usize = USER_TMP_OFFSET + PML4_SIZE;
-    pub const USER_TMP_HEAP_PML4: usize = (USER_TMP_HEAP_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary page for grants
-    pub const USER_TMP_GRANT_OFFSET: usize = USER_TMP_HEAP_OFFSET + PML4_SIZE;
-    pub const USER_TMP_GRANT_PML4: usize = (USER_TMP_GRANT_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary stack (used when cloning)
-    pub const USER_TMP_STACK_OFFSET: usize = USER_TMP_GRANT_OFFSET + PML4_SIZE;
-    pub const USER_TMP_STACK_PML4: usize = (USER_TMP_STACK_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary sigstack (used when cloning)
-    pub const USER_TMP_SIGSTACK_OFFSET: usize = USER_TMP_STACK_OFFSET + PML4_SIZE;
-    pub const USER_TMP_SIGSTACK_PML4: usize = (USER_TMP_SIGSTACK_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset to user temporary tls (used when cloning)
-    pub const USER_TMP_TLS_OFFSET: usize = USER_TMP_SIGSTACK_OFFSET + PML4_SIZE;
-    pub const USER_TMP_TLS_PML4: usize = (USER_TMP_TLS_OFFSET & PML4_MASK) / PML4_SIZE;
-
-    /// Offset for usage in other temporary pages
-    pub const USER_TMP_MISC_OFFSET: usize = USER_TMP_TLS_OFFSET + PML4_SIZE;
-    pub const USER_TMP_MISC_PML4: usize = (USER_TMP_MISC_OFFSET & PML4_MASK) / PML4_SIZE;
-}

kernel/src/smp.rs

@@ -0,0 +1,4 @@
+pub struct cpu {
+    pub id: usize
+}
+

riscv-pk/bbl/bbl.c

@@ -48,7 +48,7 @@ void boot_other_hart(uintptr_t unused __attribute__((unused)))
     }
   }
 
-  enter_supervisor_mode(entry, hartid, dtb_output());
+  enter_supervisor_mode(entry, hartid, dtb_output(), ~disabled_hart_mask & hart_mask);
 }
 
 void boot_loader(uintptr_t dtb)

riscv-pk/machine/minit.c

@@ -172,7 +172,7 @@ void init_other_hart(uintptr_t hartid, uintptr_t dtb)
   boot_other_hart(dtb);
 }
 
-void enter_supervisor_mode(void (*fn)(uintptr_t), uintptr_t arg0, uintptr_t arg1)
+void enter_supervisor_mode(void (*fn)(uintptr_t), uintptr_t arg0, uintptr_t arg1, uintptr_t arg2)
 {
   // Set up a PMP to permit access to all of memory.
   // Ignore the illegal-instruction trap if PMPs aren't supported.
@@ -194,6 +194,7 @@ void enter_supervisor_mode(void (*fn)(uintptr_t), uintptr_t arg0, uintptr_t arg1
 
   register uintptr_t a0 asm ("a0") = arg0;
   register uintptr_t a1 asm ("a1") = arg1;
-  asm volatile ("mret" : : "r" (a0), "r" (a1));
+  register uintptr_t a2 asm ("a2") = arg2;
+  asm volatile ("mret" : : "r" (a0), "r" (a1), "r" (a2));
   __builtin_unreachable();
 }

riscv-pk/machine/mtrap.h

@@ -63,7 +63,7 @@ void putstring(const char* s);
 #define assert(x) ({ if (!(x)) die("assertion failed: %s", #x); })
 #define die(str, ...) ({ printm("%s:%d: " str "\n", __FILE__, __LINE__, ##__VA_ARGS__); poweroff(-1); })
 
-void enter_supervisor_mode(void (*fn)(uintptr_t), uintptr_t arg0, uintptr_t arg1)
+void enter_supervisor_mode(void (*fn)(uintptr_t), uintptr_t arg0, uintptr_t arg1, uintptr_t arg2)
   __attribute__((noreturn));
 void boot_loader(uintptr_t dtb);
 void boot_other_hart(uintptr_t dtb);