Non-retentive resume

Author: luojia65

rustsbi-qemu/src/execute.rs

@@ -16,9 +16,22 @@ pub fn execute_supervisor(supervisor_mepc: usize, a0: usize, a1: usize, hsm: Qem
                 let ctx = rt.context_mut();
                 let param = [ctx.a0, ctx.a1, ctx.a2, ctx.a3, ctx.a4, ctx.a5];
                 let ans = rustsbi::ecall(ctx.a7, ctx.a6, param);
-                ctx.a0 = ans.error;
-                ctx.a1 = ans.value;
-                ctx.mepc = ctx.mepc.wrapping_add(4);
+                if ans.error == 0x233 { // hart non-retentive resume
+                    if let Some(HsmCommand::Start(start_paddr, opaque)) = hsm.last_command() {
+                        unsafe {
+                            riscv::register::satp::write(0);
+                            riscv::register::sstatus::clear_sie();
+                        }
+                        hsm.record_current_start_finished();
+                        ctx.mstatus = riscv::register::mstatus::read(); // get from modified sstatus
+                        ctx.a0 = opaque;
+                        ctx.mepc = start_paddr;
+                    }
+                } else {
+                    ctx.a0 = ans.error;
+                    ctx.a1 = ans.value;
+                    ctx.mepc = ctx.mepc.wrapping_add(4);
+                }
             }
             GeneratorState::Yielded(MachineTrap::IllegalInstruction()) => {
                 let ctx = rt.context_mut();

rustsbi-qemu/src/qemu_hsm.rs

@@ -248,31 +248,11 @@ impl rustsbi::Hsm for QemuHsm {
                 // retentive suspend
                 suspend_current_hart(&self);
                 // begin wake process
-                unsafe {
-                    riscv::register::satp::write(0);
-                    riscv::register::sstatus::clear_sie();
-                }
-                // when wake, mark current hart as started
-                let mut state_lock = self.state.lock();
-                state_lock.entry(hart_id).insert(AtomicU8::new(HsmState::Started as u8));
-                drop(state_lock);
-                match () {
-                    #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
-                    () => unsafe {
-                        asm!(
-                            "csrr   a0, mhartid",
-                            "jr     {resume_addr}",
-                            resume_addr = in(reg) resume_addr,
-                            in("a1") opaque,
-                            options(noreturn)
-                        )
-                    },
-                    #[cfg(not(any(target_arch = "riscv32", target_arch = "riscv64")))]
-                    () => {
-                        drop((resume_addr, opaque));
-                        unimplemented!("not RISC-V instruction set architecture")
-                    }
-                };
+                // send start command to runtime of current hart
+                let mut config_lock = self.last_command.lock();
+                config_lock.entry(hart_id).insert(HsmCommand::Start(resume_addr, opaque));
+                drop(config_lock);
+                SbiRet { error: 0x233, value: 0x0 } // unreachable, the runtime identifies start command and perform the hart resume
             },
             // There could be other platform specific suspend types; RustSBI-QEMU does not define any
             // platform suspend types. It gives SBI return value as not supported.

test-kernel/src/main.rs

@@ -37,32 +37,46 @@ pub extern "C" fn rust_main(hartid: usize, dtb_pa: usize) -> ! {
             let sbi_ret = sbi::hart_get_status(i);
             println!(">> Hart {} state return value: {:?}", i, sbi_ret);
         }
-    } else if hartid == 1 || hartid == 2 {
+    } else if hartid == 1 {
         let sbi_ret = sbi::hart_suspend(0x00000000, 0, 0);
-        println!(">> Start test for hart {}, suspend return value {:?}", hartid, sbi_ret);
+        println!(">> Start test for hart {}, retentive suspend return value {:?}", hartid, sbi_ret);
+    } else if hartid == 2 {
+        /* resume_addr should be physical address, and here pa == va */
+        let sbi_ret = sbi::hart_suspend(0x80000000, hart_2_resume as usize, 0x4567890a);
+        println!(">> Error for non-retentive suspend: {:?}", sbi_ret);
+        loop {}
     } else { // hartid == 3
         loop {}
     }
-    if hartid == 0 || hartid == 1 {
+    if hartid == 0 {
         println!("<< Test-kernel: test for hart {} success, wake another hart", hartid);
         let bv: usize = 0b10;
         let sbi_ret = sbi::send_ipi(&bv as *const _ as usize, hartid); // wake hartid + 1
-        println!(">> Wake, sbi return value {:?}", sbi_ret);
+        println!(">> Wake hart 1, sbi return value {:?}", sbi_ret);
         loop {} // wait for machine shutdown
-    } else if hartid == 2 {
-        let param = 0x12345678;
-        println!(">> Start hart 3 with parameter {:#x}", param);
-        /* start_addr should be physical address, and here pa == va */
-        let sbi_ret = sbi::hart_start(3, hart_3_start as usize, param);
-        println!(">> SBI return value: {:?}", sbi_ret);
-        loop {} // wait for machine shutdown
-    } else { // hartid == 3
+    } else if hartid == 1 {
+        // send software IPI to activate hart 2
+        let bv: usize = 0b10;
+        let sbi_ret = sbi::send_ipi(&bv as *const _ as usize, hartid); // wake hartid + 1
+        println!(">> Wake hart 2, sbi return value {:?}", sbi_ret);
+        loop {}
+    } else { // hartid == 2 || hartid == 3
         unreachable!()
     }
 }
 
+extern "C" fn hart_2_resume(param: usize) {
+    println!("<< The parameter passed to hart 2 resume is: {:#x}", param);
+    let param = 0x12345678;
+    println!(">> Start hart 3 with parameter {:#x}", param);
+    /* start_addr should be physical address, and here pa == va */
+    let sbi_ret = sbi::hart_start(3, hart_3_start as usize, param);
+    println!(">> SBI return value: {:?}", sbi_ret);
+    loop {} // wait for machine shutdown
+}
+
 extern "C" fn hart_3_start(param: usize) {
-    println!("<< The parameter passed to hart start is: {:#x}", param);
+    println!("<< The parameter passed to hart 3 start is: {:#x}", param);
     println!("<< Test-kernel: All hart SBI test SUCCESS, shutdown");
     sbi::shutdown()
 }