Merge pull request rustsbi#40 from rustsbi/instance-rustsbi

rustsbi-qemu: instance based RustSBI interface with separate functions for legacy stdio

Author: luojia65

CHANGELOG.md

@@ -13,6 +13,7 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Modified
 
+- Use instance based RustSBI interface, with separate functions for legacy stdio
 - Update sbi-testing to version 0.0.1
 - Use crate os-xtask-utils version 0.0.0 in xtask builder
 

Cargo.lock

@@ -17,7 +17,8 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustsbi = { version = "0.3.0-rc.1", features = ["legacy"] }
+rustsbi = "0.3.0-rc.2"
+sbi-spec = { version = "0.0.4", features = ["legacy"] }
 riscv = "0.9.0"
 spin = "0.9"
 r0 = "1"

rustsbi-qemu/Cargo.toml

@@ -0,0 +1,30 @@
+use crate::ns16550a::Ns16550a;
+use core::fmt::{Arguments, Write};
+use spin::Once;
+
+pub(crate) static STDOUT: Once<Ns16550a> = Once::new();
+
+pub(crate) fn init(out: Ns16550a) {
+    STDOUT.call_once(|| out);
+}
+
+#[doc(hidden)]
+pub fn _print(args: Arguments) {
+    STDOUT.wait().write_fmt(args).unwrap();
+}
+
+/// Prints to the debug output.
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::console::_print(core::format_args!($($arg)*)));
+}
+
+/// Prints to the debug output with a new line.
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\r\n"));
+    ($($arg:tt)*) => {
+        $crate::console::_print(core::format_args!($($arg)*));
+        $crate::print!("\r\n");
+    }
+}

rustsbi-qemu/src/console.rs

@@ -1,17 +1,19 @@
-use crate::{clint, hart_id, qemu_hsm::QemuHsm, Supervisor};
+use crate::{clint, hart_id, qemu_hsm::QemuHsm, FixedRustSBI, Supervisor};
 use core::arch::asm;
 use riscv::register::*;
+use rustsbi::spec::binary::SbiRet;
 
 #[repr(usize)]
 pub(crate) enum Operation {
     Stop = 0,
     SystemReset = 1,
 }
 
-pub(crate) fn execute_supervisor(hsm: &QemuHsm, supervisor: Supervisor) -> Operation {
-    let mut ctx = SupervisorContext::new(supervisor);
-    mscratch::write(&mut ctx as *mut _ as _);
-
+pub(crate) fn execute_supervisor(
+    sbi: FixedRustSBI,
+    hsm: &QemuHsm,
+    supervisor: Supervisor,
+) -> Operation {
     clint::msip::clear();
     clint::mtimecmp::clear();
     unsafe {
@@ -26,6 +28,10 @@ pub(crate) fn execute_supervisor(hsm: &QemuHsm, supervisor: Supervisor) -> Opera
         mie::set_msoft();
         mie::set_mtimer();
     }
+    let ctx = SupervisorContext::new(supervisor);
+
+    let mut env = Environment { ctx, sbi };
+    mscratch::write(&mut env.ctx as *mut _ as _);
 
     hsm.record_current_start_finished();
     loop {
@@ -34,15 +40,87 @@ pub(crate) fn execute_supervisor(hsm: &QemuHsm, supervisor: Supervisor) -> Opera
         use mcause::{Exception, Trap};
         match mcause::read().cause() {
             Trap::Exception(Exception::SupervisorEnvCall) => {
-                if let Some(op) = ctx.handle_ecall() {
+                if let Some(op) = env.handle_ecall() {
                     break op;
                 }
             }
-            t => ctx.trap_stop(t),
+            t => env.trap_stop(t),
         }
     }
 }
 
+struct Environment<'a> {
+    ctx: SupervisorContext,
+    sbi: FixedRustSBI<'a>,
+}
+
+impl<'a> Environment<'a> {
+    fn handle_ecall(&mut self) -> Option<Operation> {
+        use rustsbi::spec::{binary::*, hsm::*, srst::*};
+        if self.ctx.sbi_extension() == sbi_spec::legacy::LEGACY_CONSOLE_PUTCHAR {
+            let ch = self.ctx.a(0);
+            crate::console::STDOUT.wait().putchar((ch & 0xFF) as u8);
+            self.ctx.mepc = self.ctx.mepc.wrapping_add(4);
+            return None;
+        } else if self.ctx.sbi_extension() == sbi_spec::legacy::LEGACY_CONSOLE_GETCHAR {
+            let ch = crate::console::STDOUT.wait().getchar();
+            *self.ctx.a_mut(0) = ch as usize;
+            self.ctx.mepc = self.ctx.mepc.wrapping_add(4);
+            return None;
+        }
+        let ans = self.sbi.handle_ecall(
+            self.ctx.sbi_extension(),
+            self.ctx.sbi_function(),
+            self.ctx.sbi_param(),
+        );
+        // 判断导致退出执行流程的调用
+        if ans.error == RET_SUCCESS {
+            match (self.ctx.sbi_extension(), self.ctx.sbi_function()) {
+                // 核状态
+                (EID_HSM, HART_STOP) => return Some(Operation::Stop),
+                (EID_HSM, HART_SUSPEND)
+                    if matches!(
+                        u32::try_from(self.ctx.a(0)),
+                        Ok(HART_SUSPEND_TYPE_NON_RETENTIVE)
+                    ) =>
+                {
+                    return Some(Operation::Stop)
+                }
+                // 系统重置
+                (EID_SRST, SYSTEM_RESET)
+                    if matches!(
+                        u32::try_from(self.ctx.a(0)),
+                        Ok(RESET_TYPE_COLD_REBOOT) | Ok(RESET_TYPE_WARM_REBOOT)
+                    ) =>
+                {
+                    return Some(Operation::SystemReset)
+                }
+                _ => {}
+            }
+        }
+        self.ctx.fill_in(ans);
+        self.ctx.mepc = self.ctx.mepc.wrapping_add(4);
+        None
+    }
+
+    fn trap_stop(&self, trap: mcause::Trap) -> ! {
+        println!(
+            "
+-----------------------------
+> trap:    {trap:?}
+> mstatus: {:#018x}
+> mepc:    {:#018x}
+> mtval:   {:#018x}
+-----------------------------
+",
+            self.ctx.mstatus,
+            self.ctx.mepc,
+            mtval::read()
+        );
+        panic!("stopped with unsupported trap")
+    }
+}
+
 #[repr(C)]
 #[derive(Debug)]
 struct SupervisorContext {
@@ -72,6 +150,34 @@ impl SupervisorContext {
         ctx
     }
 
+    #[inline]
+    fn sbi_extension(&self) -> usize {
+        self.a(7)
+    }
+
+    #[inline]
+    fn sbi_function(&self) -> usize {
+        self.a(6)
+    }
+
+    #[inline]
+    fn sbi_param(&self) -> [usize; 6] {
+        [
+            self.a(0),
+            self.a(1),
+            self.a(2),
+            self.a(3),
+            self.a(4),
+            self.a(5),
+        ]
+    }
+
+    #[inline]
+    fn fill_in(&mut self, ans: SbiRet) {
+        *self.a_mut(0) = ans.error;
+        *self.a_mut(1) = ans.value;
+    }
+
     #[inline]
     fn x(&self, n: usize) -> usize {
         self.x[n - 1]
@@ -92,60 +198,6 @@ impl SupervisorContext {
         self.x_mut(n + 10)
     }
 
-    fn handle_ecall(&mut self) -> Option<Operation> {
-        use rustsbi::spec::{binary::*, hsm::*, srst::*};
-        let extension = self.a(7);
-        let function = self.a(6);
-        let ans = rustsbi::ecall(
-            extension,
-            function,
-            [
-                self.a(0),
-                self.a(1),
-                self.a(2),
-                self.a(3),
-                self.a(4),
-                self.a(5),
-            ],
-        );
-        // 判断导致退出执行流程的调用
-        if ans.error == RET_SUCCESS {
-            match extension {
-                // 核状态
-                EID_HSM => match function {
-                    HART_STOP => return Some(Operation::Stop),
-                    HART_SUSPEND
-                        if matches!(
-                            u32::try_from(self.a(0)),
-                            Ok(HART_SUSPEND_TYPE_NON_RETENTIVE)
-                        ) =>
-                    {
-                        return Some(Operation::Stop);
-                    }
-                    _ => {}
-                },
-                // 系统重置
-                EID_SRST => match function {
-                    SYSTEM_RESET
-                        if matches!(
-                            u32::try_from(self.a(0)),
-                            Ok(RESET_TYPE_COLD_REBOOT) | Ok(RESET_TYPE_WARM_REBOOT)
-                        ) =>
-                    {
-                        return Some(Operation::SystemReset)
-                    }
-                    _ => {}
-                },
-
-                _ => {}
-            }
-        }
-        *self.a_mut(0) = ans.error;
-        *self.a_mut(1) = ans.value;
-        self.mepc = self.mepc.wrapping_add(4);
-        None
-    }
-
     #[allow(unused)]
     fn do_transfer_trap(&mut self, cause: scause::Trap) {
         unsafe {
@@ -178,23 +230,6 @@ impl SupervisorContext {
             self.mepc = stvec::read().address();
         }
     }
-
-    fn trap_stop(&self, trap: mcause::Trap) -> ! {
-        println!(
-            "
------------------------------
-> trap:    {trap:?}
-> mstatus: {:#018x}
-> mepc:    {:#018x}
-> mtval:   {:#018x}
------------------------------
-",
-            self.mstatus,
-            self.mepc,
-            mtval::read()
-        );
-        panic!("stopped with unsupported trap")
-    }
 }
 
 /// M 态转到 S 态。