Exceptions

AArch64 defines an exception vector table with 16 entries, for 4 types of exceptions (synchronous, IRQ, FIQ, SError) from 4 states (current EL with SP0, current EL with SPx, lower EL using AArch64, lower EL using AArch32). We implement this in assembly to save volatile registers to the stack before calling into Rust code:

  1. use log::error;
  2. use smccc::psci::system_off;
  3. use smccc::Hvc;
  5. // SAFETY: There is no other global function of this name.
  6. #[unsafe(no_mangle)]
  7. extern "C" fn sync_exception_current(_elr: u64, _spsr: u64) {
  8.     error!("sync_exception_current");
  9.     system_off::<Hvc>().unwrap();
  10. }
  12. // SAFETY: There is no other global function of this name.
  13. #[unsafe(no_mangle)]
  14. extern "C" fn irq_current(_elr: u64, _spsr: u64) {
  15.     error!("irq_current");
  16.     system_off::<Hvc>().unwrap();
  17. }
  19. // SAFETY: There is no other global function of this name.
  20. #[unsafe(no_mangle)]
  21. extern "C" fn fiq_current(_elr: u64, _spsr: u64) {
  22.     error!("fiq_current");
  23.     system_off::<Hvc>().unwrap();
  24. }
  26. // SAFETY: There is no other global function of this name.
  27. #[unsafe(no_mangle)]
  28. extern "C" fn serr_current(_elr: u64, _spsr: u64) {
  29.     error!("serr_current");
  30.     system_off::<Hvc>().unwrap();
  31. }
  33. // SAFETY: There is no other global function of this name.
  34. #[unsafe(no_mangle)]
  35. extern "C" fn sync_lower(_elr: u64, _spsr: u64) {
  36.     error!("sync_lower");
  37.     system_off::<Hvc>().unwrap();
  38. }
  40. // SAFETY: There is no other global function of this name.
  41. #[unsafe(no_mangle)]
  42. extern "C" fn irq_lower(_elr: u64, _spsr: u64) {
  43.     error!("irq_lower");
  44.     system_off::<Hvc>().unwrap();
  45. }
  47. // SAFETY: There is no other global function of this name.
  48. #[unsafe(no_mangle)]
  49. extern "C" fn fiq_lower(_elr: u64, _spsr: u64) {
  50.     error!("fiq_lower");
  51.     system_off::<Hvc>().unwrap();
  52. }
  54. // SAFETY: There is no other global function of this name.
  55. #[unsafe(no_mangle)]
  56. extern "C" fn serr_lower(_elr: u64, _spsr: u64) {
  57.     error!("serr_lower");
  58.     system_off::<Hvc>().unwrap();
  59. }
  • EL is exception level; all our examples this afternoon run in EL1.
  • For simplicity we aren’t distinguishing between SP0 and SPx for the current EL exceptions, or between AArch32 and AArch64 for the lower EL exceptions.
  • For this example we just log the exception and power down, as we don’t expect any of them to actually happen.
  • We can think of exception handlers and our main execution context more or less like different threads. Send and Sync will control what we can share between them, just like with threads. For example, if we want to share some value between exception handlers and the rest of the program, and it’s Send but not Sync, then we’ll need to wrap it in something like a Mutex and put it in a static.