rename syscall table from abi

kernel/src/elf.rs

@@ -1,8 +1,7 @@
 use crate::{
-    abi,
     storage::{File, SDCARD},
+    syscalls,
 };
-use userlib_sys::{CallTable, EntryFn};
 use alloc::{vec, vec::Vec};
 use bumpalo::Bump;
 use core::ptr;
@@ -17,6 +16,7 @@ use goblin::{
     elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym},
 };
 use strum::IntoEnumIterator;
+use userlib_sys::{EntryFn, SyscallTable};
 
 const ELF32_HDR_SIZE: usize = 52;
 
@@ -70,7 +70,7 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)>
                 }
             }
 
-            patch_abi(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap();
+            patch_syscalls(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap();
 
             // entry pointer is base_ptr + (entry - min_vaddr)
             let entry_ptr: EntryFn = unsafe {
@@ -150,7 +150,7 @@ fn apply_relocations(
     Ok(())
 }
 
-fn patch_abi(
+fn patch_syscalls(
     elf_header: &Header,
     base: *mut u8,
     min_vaddr: u32,
@@ -188,27 +188,27 @@ fn patch_abi(
                 }
 
                 let symbol_name = core::str::from_utf8(&name).unwrap();
-                if symbol_name == "CALL_ABI_TABLE" {
+                if symbol_name == stringify!(SYS_CALL_TABLE) {
                     let table_base =
                         unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
                             as *mut usize;
 
-                    for (idx, call) in CallTable::iter().enumerate() {
+                    for (idx, call) in SyscallTable::iter().enumerate() {
                         let ptr = match call {
-                            CallTable::Alloc => abi::alloc as usize,
-                            CallTable::Dealloc => abi::dealloc as usize,
-                            CallTable::PrintString => abi::print as usize,
-                            CallTable::SleepMs => abi::sleep as usize,
-                            CallTable::GetMs => abi::get_ms as usize,
-                            CallTable::DrawIter => abi::draw_iter as usize,
-                            CallTable::GetKey => abi::get_key as usize,
-                            CallTable::GenRand => abi::gen_rand as usize,
-                            CallTable::ListDir => abi::list_dir as usize,
-                            CallTable::ReadFile => abi::read_file as usize,
-                            CallTable::WriteFile => abi::write_file as usize,
-                            CallTable::FileLen => abi::file_len as usize,
-                            CallTable::AudioBufferReady => abi::audio_buffer_ready as usize,
-                            CallTable::SendAudioBuffer => abi::send_audio_buffer as usize,
+                            SyscallTable::Alloc => syscalls::alloc as usize,
+                            SyscallTable::Dealloc => syscalls::dealloc as usize,
+                            SyscallTable::PrintString => syscalls::print as usize,
+                            SyscallTable::SleepMs => syscalls::sleep as usize,
+                            SyscallTable::GetMs => syscalls::get_ms as usize,
+                            SyscallTable::DrawIter => syscalls::draw_iter as usize,
+                            SyscallTable::GetKey => syscalls::get_key as usize,
+                            SyscallTable::GenRand => syscalls::gen_rand as usize,
+                            SyscallTable::ListDir => syscalls::list_dir as usize,
+                            SyscallTable::ReadFile => syscalls::read_file as usize,
+                            SyscallTable::WriteFile => syscalls::write_file as usize,
+                            SyscallTable::FileLen => syscalls::file_len as usize,
+                            SyscallTable::AudioBufferReady => syscalls::audio_buffer_ready as usize,
+                            SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize,
                         };
                         unsafe {
                             table_base.add(idx as usize).write(ptr);

kernel/src/main.rs

@@ -8,7 +8,6 @@
 
 extern crate alloc;
 
-mod abi;
 mod audio;
 mod display;
 mod elf;
@@ -16,6 +15,7 @@ mod framebuffer;
 mod peripherals;
 mod scsi;
 mod storage;
+mod syscalls;
 mod ui;
 mod usb;
 mod utils;
@@ -31,12 +31,12 @@ mod psram;
 use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi};
 
 use crate::{
-    abi::{KEY_CACHE, MS_SINCE_LAUNCH},
     audio::audio_handler,
     display::{FRAMEBUFFER, display_handler, init_display},
     peripherals::{conf_peripherals, keyboard::read_keyboard_fifo},
     scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
+    syscalls::{KEY_CACHE, MS_SINCE_LAUNCH},
     ui::{SELECTIONS, clear_selection, ui_handler},
 };
 use bumpalo::Bump;

kernel/src/syscalls.rs

@@ -1,14 +1,14 @@
 use alloc::{string::ToString, vec::Vec};
 use core::{ffi::c_char, ptr, sync::atomic::Ordering};
-use embassy_rp::clocks::{clk_sys_freq, RoscRng};
+use embassy_rp::clocks::{RoscRng, clk_sys_freq};
 use embassy_time::Instant;
 use embedded_graphics::draw_target::DrawTarget;
 use embedded_sdmmc::LfnBuffer;
 use heapless::spsc::Queue;
 use userlib_sys::{
-    keyboard::*, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen,
-    GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, SleepMsAbi,
-    WriteFile, AUDIO_BUFFER_SAMPLES,
+    AUDIO_BUFFER_SAMPLES, Alloc, AudioBufferReady, CLayout, CPixel, Dealloc, DrawIter, FileLen,
+    GenRand, GetMs, ListDir, Print, ReadFile, RngRequest, SendAudioBuffer, SleepMs, WriteFile,
+    keyboard::*,
 };
 
 #[cfg(feature = "psram")]
@@ -24,7 +24,7 @@ use crate::{
     storage::{Dir, File, SDCARD},
 };
 
-const _: AllocAbi = alloc;
+const _: Alloc = alloc;
 pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
     // SAFETY: caller guarantees layout is valid
     unsafe {
@@ -40,7 +40,7 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
     }
 }
 
-const _: DeallocAbi = dealloc;
+const _: Dealloc = dealloc;
 pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) {
     // SAFETY: caller guarantees ptr and layout are valid
     #[cfg(feature = "psram")]
@@ -54,7 +54,7 @@ pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) {
     }
 }
 
-const _: PrintAbi = print;
+const _: Print = print;
 pub extern "C" fn print(ptr: *const u8, len: usize) {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let slice = unsafe { core::slice::from_raw_parts(ptr, len) };
@@ -68,7 +68,7 @@ pub extern "C" fn print(ptr: *const u8, len: usize) {
     }
 }
 
-const _: SleepMsAbi = sleep;
+const _: SleepMs = sleep;
 pub extern "C" fn sleep(ms: u64) {
     let cycles_per_ms = clk_sys_freq() / 1000;
     let total_cycles = ms * cycles_per_ms as u64;
@@ -80,14 +80,14 @@ pub extern "C" fn sleep(ms: u64) {
 
 pub static mut MS_SINCE_LAUNCH: Option<Instant> = None;
 
-const _: GetMsAbi = get_ms;
+const _: GetMs = get_ms;
 pub extern "C" fn get_ms() -> u64 {
     Instant::now()
         .duration_since(unsafe { MS_SINCE_LAUNCH.unwrap() })
         .as_millis()
 }
 
-const _: DrawIterAbi = draw_iter;
+const _: DrawIter = draw_iter;
 pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let cpixels = unsafe { core::slice::from_raw_parts(cpixels, len) };
@@ -101,7 +101,7 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
 
 pub static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
 
-const _: GetKeyAbi = get_key;
+const _: GetKey = get_key;
 pub extern "C" fn get_key() -> KeyEventC {
     if let Some(event) = unsafe { KEY_CACHE.dequeue() } {
         event.into()