fix(aarch64): pseudo implementation

Author: AsakuraMizu

src/aarch64/context.rs

@@ -34,6 +34,11 @@ impl fmt::Debug for TrapFrame {
 }
 
 impl TrapFrame {
+    /// Creates an empty context with all registers set to zero.
+    pub const fn new() -> Self {
+        unsafe { core::mem::zeroed() }
+    }
+
     /// Gets the 0th syscall argument.
     pub const fn arg0(&self) -> usize {
         self.r[0] as _

src/aarch64/trap.S

@@ -73,20 +73,18 @@
     b       .Lexception_return
 .endm
 
-.macro HANDLE_SYNC, source
+.macro HANDLE_SYNC
 .p2align 7
     SAVE_REGS
     mov     x0, sp
-    mov     x1, \source
     bl      handle_sync_exception
     b       .Lexception_return
 .endm
 
-.macro HANDLE_IRQ, source
+.macro HANDLE_IRQ
 .p2align 7
     SAVE_REGS
     mov     x0, sp
-    mov     x1, \source
     bl      handle_irq_exception
     b       .Lexception_return
 .endm
@@ -102,14 +100,15 @@ exception_vector_base:
     INVALID_EXCP 3 0
 
     // current EL, with SP_ELx
-    HANDLE_SYNC 1
-    HANDLE_IRQ 1
+    HANDLE_SYNC
+    HANDLE_IRQ
     INVALID_EXCP 2 1
     INVALID_EXCP 3 1
 
+    // TODO: handle user trap
     // lower EL, aarch64
-    HANDLE_SYNC 2
-    HANDLE_IRQ 2
+    HANDLE_SYNC
+    HANDLE_IRQ
     INVALID_EXCP 2 2
     INVALID_EXCP 3 2
 

src/aarch64/trap.rs

@@ -29,12 +29,6 @@ enum TrapSource {
     LowerAArch32 = 3,
 }
 
-impl TrapSource {
-    fn is_from_user(&self) -> bool {
-        matches!(self, TrapSource::LowerAArch64 | TrapSource::LowerAArch32)
-    }
-}
-
 #[unsafe(no_mangle)]
 fn invalid_exception(tf: &TrapFrame, kind: TrapKind, source: TrapSource) {
     panic!(
@@ -44,26 +38,21 @@ fn invalid_exception(tf: &TrapFrame, kind: TrapKind, source: TrapSource) {
 }
 
 #[unsafe(no_mangle)]
-fn handle_irq_exception(tf: &mut TrapFrame, source: TrapSource) {
-    crate::trap::pre_trap_callback(tf, source.is_from_user());
+fn handle_irq_exception(_tf: &mut TrapFrame) {
     handle_trap!(IRQ, 0);
-    crate::trap::post_trap_callback(tf, source.is_from_user());
 }
 
-fn handle_instruction_abort(tf: &TrapFrame, iss: u64, is_user: bool) {
-    let mut access_flags = PageFaultFlags::EXECUTE;
-    if is_user {
-        access_flags |= PageFaultFlags::USER;
-    }
+fn handle_instruction_abort(tf: &TrapFrame, iss: u64) {
+    let access_flags = PageFaultFlags::EXECUTE;
     let vaddr = va!(FAR_EL1.get() as usize);
 
+    // TODO: fixup_exception
     // Only handle Translation fault and Permission fault
     if !matches!(iss & 0b111100, 0b0100 | 0b1100) // IFSC or DFSC bits
-        || !handle_trap!(PAGE_FAULT, vaddr, access_flags, is_user)
+        || !handle_trap!(PAGE_FAULT, vaddr, access_flags)
     {
         panic!(
-            "Unhandled {} Instruction Abort @ {:#x}, fault_vaddr={:#x}, ESR={:#x} ({:?}):\n{:#x?}\n{}",
-            if is_user { "EL0" } else { "EL1" },
+            "Unhandled EL1 Instruction Abort @ {:#x}, fault_vaddr={:#x}, ESR={:#x} ({:?}):\n{:#x?}\n{}",
             tf.elr,
             vaddr,
             ESR_EL1.get(),
@@ -74,26 +63,23 @@ fn handle_instruction_abort(tf: &TrapFrame, iss: u64, is_user: bool) {
     }
 }
 
-fn handle_data_abort(tf: &TrapFrame, iss: u64, is_user: bool) {
+fn handle_data_abort(tf: &TrapFrame, iss: u64) {
     let wnr = (iss & (1 << 6)) != 0; // WnR: Write not Read
     let cm = (iss & (1 << 8)) != 0; // CM: Cache maintenance
-    let mut access_flags = if wnr & !cm {
+    let access_flags = if wnr & !cm {
         PageFaultFlags::WRITE
     } else {
         PageFaultFlags::READ
     };
-    if is_user {
-        access_flags |= PageFaultFlags::USER;
-    }
     let vaddr = va!(FAR_EL1.get() as usize);
 
+    // TODO: fixup_exception
     // Only handle Translation fault and Permission fault
     if !matches!(iss & 0b111100, 0b0100 | 0b1100) // IFSC or DFSC bits
-        || !handle_trap!(PAGE_FAULT, vaddr, access_flags, is_user)
+        || !handle_trap!(PAGE_FAULT, vaddr, access_flags)
     {
         panic!(
-            "Unhandled {} Data Abort @ {:#x}, fault_vaddr={:#x}, ESR={:#x} ({:?}):\n{:#x?}\n{}",
-            if is_user { "EL0" } else { "EL1" },
+            "Unhandled EL1 Data Abort @ {:#x}, fault_vaddr={:#x}, ESR={:#x} ({:?}):\n{:#x?}\n{}",
             tf.elr,
             vaddr,
             ESR_EL1.get(),
@@ -105,19 +91,12 @@ fn handle_data_abort(tf: &TrapFrame, iss: u64, is_user: bool) {
 }
 
 #[unsafe(no_mangle)]
-fn handle_sync_exception(tf: &mut TrapFrame, source: TrapSource) {
+fn handle_sync_exception(tf: &mut TrapFrame) {
     let esr = ESR_EL1.extract();
     let iss = esr.read(ESR_EL1::ISS);
-    crate::trap::pre_trap_callback(tf, source.is_from_user());
     match esr.read_as_enum(ESR_EL1::EC) {
-        #[cfg(feature = "uspace")]
-        Some(ESR_EL1::EC::Value::SVC64) => {
-            tf.r[0] = crate::trap::handle_syscall(tf, tf.r[8] as usize) as u64;
-        }
-        Some(ESR_EL1::EC::Value::InstrAbortLowerEL) => handle_instruction_abort(tf, iss, true),
-        Some(ESR_EL1::EC::Value::InstrAbortCurrentEL) => handle_instruction_abort(tf, iss, false),
-        Some(ESR_EL1::EC::Value::DataAbortLowerEL) => handle_data_abort(tf, iss, true),
-        Some(ESR_EL1::EC::Value::DataAbortCurrentEL) => handle_data_abort(tf, iss, false),
+        Some(ESR_EL1::EC::Value::InstrAbortCurrentEL) => handle_instruction_abort(tf, iss),
+        Some(ESR_EL1::EC::Value::DataAbortCurrentEL) => handle_data_abort(tf, iss),
         Some(ESR_EL1::EC::Value::Brk64) => {
             debug!("BRK #{:#x} @ {:#x} ", iss, tf.elr);
             tf.elr += 4;
@@ -128,10 +107,9 @@ fn handle_sync_exception(tf: &mut TrapFrame, source: TrapSource) {
                 tf.elr,
                 esr.get(),
                 esr.read(ESR_EL1::EC),
-                esr.read(ESR_EL1::ISS),
+                iss,
                 tf.backtrace()
             );
         }
     }
-    crate::trap::post_trap_callback(tf, source.is_from_user());
 }

src/aarch64/uspace.rs

@@ -1,16 +1,22 @@
 //! Structures and functions for user space.
 
+use core::ops::{Deref, DerefMut};
+
+use aarch64_cpu::registers::ESR_EL1;
 use memory_addr::VirtAddr;
 
-use crate::TrapFrame;
+use crate::{
+    trap::{ExceptionKind, ReturnReason},
+    TrapFrame,
+};
 
 /// Context to enter user space.
-pub struct UspaceContext(TrapFrame);
+pub struct UserContext(TrapFrame);
 
-impl UspaceContext {
+impl UserContext {
     /// Creates an empty context with all registers set to zero.
     pub const fn empty() -> Self {
-        unsafe { core::mem::MaybeUninit::zeroed().assume_init() }
+        Self(TrapFrame::new())
     }
 
     /// Creates a new context with the given entry point, user stack pointer,
@@ -42,68 +48,44 @@ impl UspaceContext {
     ///
     /// It restores the user registers and jumps to the user entry point
     /// (saved in `elr`).
-    /// When an exception or syscall occurs, the kernel stack pointer is
-    /// switched to `kstack_top`.
-    ///
-    /// # Safety
     ///
-    /// This function is unsafe because it changes processor mode and the stack.
-    pub unsafe fn enter_uspace(&self, kstack_top: VirtAddr) -> ! {
-        crate::asm::disable_irqs();
-        // We do not handle traps that occur at the current exception level,
-        // so the kstack ptr(`sp_el1`) will not change during running in user space.
-        // Then we don't need to save the `sp_el1` to the taskctx.
-        unsafe {
-            core::arch::asm!(
-                "
-                mov     sp, x1
-                
-                // backup kernel tpidr_el0
-                mrs     x1, tpidr_el0
-                msr     tpidrro_el0, x1
-                
-                ldp     x11, x12, [x0, 33 * 8]
-                ldp     x9, x10, [x0, 31 * 8]
-                msr     sp_el0, x9
-                msr     tpidr_el0, x10
-                msr     elr_el1, x11
-                msr     spsr_el1, x12
-
-                ldr     x30, [x0, 30 * 8]
-                ldp     x28, x29, [x0, 28 * 8]
-                ldp     x26, x27, [x0, 26 * 8]
-                ldp     x24, x25, [x0, 24 * 8]
-                ldp     x22, x23, [x0, 22 * 8]
-                ldp     x20, x21, [x0, 20 * 8]
-                ldp     x18, x19, [x0, 18 * 8]
-                ldp     x16, x17, [x0, 16 * 8]
-                ldp     x14, x15, [x0, 14 * 8]
-                ldp     x12, x13, [x0, 12 * 8]
-                ldp     x10, x11, [x0, 10 * 8]
-                ldp     x8, x9, [x0, 8 * 8]
-                ldp     x6, x7, [x0, 6 * 8]
-                ldp     x4, x5, [x0, 4 * 8]
-                ldp     x2, x3, [x0, 2 * 8]
-                ldp     x0, x1, [x0]
-                eret",
-                in("x0") &self.0,
-                in("x1") kstack_top.as_usize() ,
-                options(noreturn),
-            )
-        }
+    /// This function returns when an exception or syscall occurs.
+    pub fn run(&mut self) -> ReturnReason {
+        // TODO: implement
+        ReturnReason::Unknown
     }
 }
 
-impl core::ops::Deref for UspaceContext {
+impl Deref for UserContext {
     type Target = TrapFrame;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl core::ops::DerefMut for UspaceContext {
+impl DerefMut for UserContext {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
+
+impl From<TrapFrame> for UserContext {
+    fn from(tf: TrapFrame) -> Self {
+        Self(tf)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ExceptionInfo {
+    pub ec: ESR_EL1::EC::Value,
+    pub il: bool,
+    pub iss: u32,
+}
+
+impl ExceptionInfo {
+    pub fn kind(&self) -> ExceptionKind {
+        // TODO: implement
+        ExceptionKind::Other
+    }
+}