validate elf header

README.md

@@ -14,7 +14,7 @@ Current focus is on exanding applications and porting software, finding bugs in
 - **`userlib_sys/`** – C FFI bindings for kernel syscall
 - **`userlib/`** – Rust wrapper on top of `userlib_sys` 
 - **`picolib/`** – Built with ```just newlib```, and provides libc symbols when linking with C libraries 
-- **`user-apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.)
+- **`user_apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.)
 
 ## Features
 

kernel/src/audio.rs

@@ -1,5 +1,5 @@
 use crate::Audio;
-use core::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use embassy_futures::{join::join, yield_now};
 use embassy_rp::{
     Peri,
@@ -23,9 +23,12 @@ const SILENCE: u8 = u8::MAX / 2;
 pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2];
 static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2];
 
+// atomics for user applications to signal changes to audio buffers
 pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true);
 pub static AUDIO_BUFFER_WRITTEN: AtomicBool = AtomicBool::new(false);
+pub static AUDIO_BUFFER_SAMPLE_RATE: AtomicU32 = AtomicU32::new(SAMPLE_RATE_HZ);
 
+/// resets audio buffers after user applications are unloaded
 pub fn clear_audio_buffers() {
     unsafe {
         AUDIO_BUFFER.fill(SILENCE);
@@ -41,8 +44,29 @@ pub async fn audio_handler(mut audio: Audio) {
     let mut pwm_pio_right =
         PioPwmAudio::new(audio.dma1, &mut audio.pio, audio.sm1, audio.right, &prg);
 
+    // enable sms at the same time to ensure they are synced
+    audio.pio.apply_sm_batch(|pio| {
+        pio.set_enable(&mut pwm_pio_right.sm, true);
+        pio.set_enable(&mut pwm_pio_left.sm, true);
+    });
+
+    let mut sample_rate = SAMPLE_RATE_HZ;
+
     loop {
         unsafe {
+            let new_sample_rate = AUDIO_BUFFER_SAMPLE_RATE.load(Ordering::Acquire);
+            if new_sample_rate != sample_rate {
+                sample_rate = new_sample_rate;
+                pwm_pio_left.reconfigure(sample_rate);
+                pwm_pio_right.reconfigure(sample_rate);
+
+                // restart sms at the same time to ensure they are synced
+                audio.pio.apply_sm_batch(|pio| {
+                    pio.restart(&mut pwm_pio_right.sm);
+                    pio.restart(&mut pwm_pio_left.sm);
+                });
+            }
+
             if AUDIO_BUFFER_WRITTEN.load(Ordering::Acquire) {
                 write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await;
                 AUDIO_BUFFER_1.fill(SILENCE);
@@ -130,6 +154,11 @@ struct PioPwmAudio<'d, PIO: Instance, const SM: usize> {
 }
 
 impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> {
+    fn get_sm_divider(sample_rate: u32) -> u32 {
+        let target_clock = (u8::MAX as u32 + 1) * sample_rate;
+        clk_sys_freq() / target_clock
+    }
+
     fn new(
         dma: Peri<'d, impl Channel>,
         pio: &mut Common<'d, PIO>,
@@ -151,17 +180,18 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> {
         cfg.use_program(&prg.0, &[&pin]);
         sm.set_config(&cfg);
 
-        let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ;
-        let divider = (clk_sys_freq() / target_clock).to_fixed();
-        sm.set_clock_divider(divider);
-
-        sm.set_enable(true);
+        sm.set_clock_divider(Self::get_sm_divider(SAMPLE_RATE_HZ).to_fixed());
 
         Self {
             dma: dma.into(),
             sm,
         }
     }
+
+    fn reconfigure(&mut self, sample_rate: u32) {
+        self.sm
+            .set_clock_divider(Self::get_sm_divider(sample_rate).to_fixed());
+    }
 }
 
 /// packs two u8 samples into 32bit word

kernel/src/elf.rs

@@ -8,81 +8,100 @@ use core::ptr;
 use embedded_sdmmc::ShortFileName;
 use goblin::{
     elf::{
-        header::header32::Header,
+        header::{EM_ARM, ET_DYN, EV_CURRENT, header32::Header},
         program_header::program_header32::{PT_LOAD, ProgramHeader},
         reloc::R_ARM_RELATIVE,
         section_header::{SHT_REL, SHT_SYMTAB},
     },
-    elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym},
+    elf32::{reloc::Rel, section_header::SectionHeader, sym::Sym},
 };
 use strum::IntoEnumIterator;
 use userlib_sys::{EntryFn, SyscallTable};
 
 const ELF32_HDR_SIZE: usize = 52;
 
-pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> {
+#[derive(Debug)]
+pub enum LoadError {
+    WrongMachine,
+    InvalidElf,
+    FailedToReadFile,
+    ElfIsNotPie,
+    UnknownRelocationType,
+    SyscallTableNotFound,
+}
+
+pub async unsafe fn load_binary(name: &ShortFileName) -> Result<(EntryFn, Bump), LoadError> {
     let mut sd_lock = SDCARD.get().lock().await;
-    let sd = sd_lock.as_mut().unwrap();
+    let sd = sd_lock.as_mut().expect("Sdcard locked");
 
     let mut header_buf = [0; ELF32_HDR_SIZE];
 
-    let (entry, bump) = sd
-        .read_file(name, |mut file| {
-            file.read(&mut header_buf).unwrap();
-            let elf_header = Header::from_bytes(&header_buf);
+    sd.read_file(name, |mut file| {
+        file.read(&mut header_buf)
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        let elf_header = Header::from_bytes(&header_buf);
 
-            // reject non-PIE
-            if elf_header.e_type != header::ET_DYN {
-                return None;
+        validate_header(&elf_header)?;
+
+        let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
+
+        let (total_size, min_vaddr, _max_vaddr) =
+            total_loadable_size(&mut file, elf_header, &mut ph_buf)?;
+
+        let bump = Bump::with_capacity(total_size);
+        let base = bump.alloc_slice_fill_default::<u8>(total_size);
+
+        // load each segment into bump, relative to base_ptr
+        for i in 0..elf_header.e_phnum {
+            file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
+                .map_err(|_| LoadError::FailedToReadFile)?;
+            file.read(&mut ph_buf)
+                .map_err(|_| LoadError::FailedToReadFile)?;
+            let ph = cast_phdr(&ph_buf);
+
+            let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
+            let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
+
+            if ph.p_type == PT_LOAD {
+                load_segment(&mut file, &ph, segment)?;
             }
+        }
 
-            let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
+        for i in 0..elf_header.e_shnum {
+            let sh = read_section(&mut file, elf_header, i.into())?;
 
-            let (total_size, min_vaddr, _max_vaddr) =
-                total_loadable_size(&mut file, elf_header, &mut ph_buf);
-
-            let bump = Bump::with_capacity(total_size);
-            let base = bump.alloc_slice_fill_default::<u8>(total_size);
-
-            // load each segment into bump, relative to base_ptr
-            for i in 0..elf_header.e_phnum {
-                file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-                    .unwrap();
-                file.read(&mut ph_buf).unwrap();
-                let ph = cast_phdr(&ph_buf);
-
-                let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
-                let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
-
-                if ph.p_type == PT_LOAD {
-                    load_segment(&mut file, &ph, segment).unwrap();
-                }
+            if sh.sh_type == SHT_REL {
+                apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file)?;
             }
+        }
 
-            for i in 0..elf_header.e_shnum {
-                let sh = read_section(&mut file, elf_header, i.into());
+        patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file)?;
 
-                if sh.sh_type == SHT_REL {
-                    apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap();
-                }
-            }
+        // entry pointer is base_ptr + (entry - min_vaddr)
+        let entry_ptr: EntryFn = unsafe {
+            core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
+        };
 
-            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 {
-                core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
-            };
-
-            Some((entry_ptr, bump))
-        })
-        .await
-        .expect("Failed to read file")?;
-
-    Some((entry, bump))
+        Ok((entry_ptr, bump))
+    })
+    .await
+    .map_err(|_| LoadError::FailedToReadFile)?
 }
 
-fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), ()> {
+fn validate_header(h: &Header) -> Result<(), LoadError> {
+    if h.e_type != ET_DYN {
+        return Err(LoadError::ElfIsNotPie);
+    }
+    if h.e_machine != EM_ARM {
+        return Err(LoadError::WrongMachine);
+    }
+    if h.e_version as u8 != EV_CURRENT {
+        return Err(LoadError::InvalidElf);
+    }
+    Ok(())
+}
+
+fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), LoadError> {
     let filesz = ph.p_filesz as usize;
     let memsz = ph.p_memsz as usize;
 
@@ -94,8 +113,10 @@ fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Resu
 
     while remaining > 0 {
         let to_read = core::cmp::min(remaining, buf.len());
-        file.seek_from_start(file_offset).unwrap();
-        file.read(&mut buf[..to_read]).unwrap();
+        file.seek_from_start(file_offset)
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        file.read(&mut buf[..to_read])
+            .map_err(|_| LoadError::FailedToReadFile)?;
 
         segment[dst_offset..dst_offset + to_read].copy_from_slice(&buf[..to_read]);
 
@@ -117,14 +138,16 @@ fn apply_relocations(
     min_vaddr: u32,
     base: *mut u8,
     file: &mut File,
-) -> Result<(), ()> {
+) -> Result<(), LoadError> {
     let mut reloc = [0_u8; 8];
 
     let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize;
 
     for i in 0..num_relocs {
-        file.seek_from_start(sh.sh_offset + (i as u32 * 8)).unwrap();
-        file.read(&mut reloc).unwrap();
+        file.seek_from_start(sh.sh_offset + (i as u32 * 8))
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        file.read(&mut reloc)
+            .map_err(|_| LoadError::FailedToReadFile)?;
 
         let rel = cast_rel(&reloc);
 
@@ -140,7 +163,7 @@ fn apply_relocations(
                 }
             }
             _ => {
-                return Err(());
+                return Err(LoadError::UnknownRelocationType);
             }
         }
     }
@@ -152,15 +175,17 @@ fn patch_syscalls(
     base: *mut u8,
     min_vaddr: u32,
     file: &mut File,
-) -> Result<(), ()> {
+) -> Result<(), LoadError> {
     for i in 1..=elf_header.e_shnum {
-        let sh = read_section(file, elf_header, i.into());
+        let sh = read_section(file, elf_header, i.into())?;
 
         // find the symbol table
         if sh.sh_type == SHT_SYMTAB {
             let mut symtab_buf = vec![0u8; sh.sh_size as usize];
-            file.seek_from_start(sh.sh_offset).unwrap();
-            file.read(&mut symtab_buf).unwrap();
+            file.seek_from_start(sh.sh_offset)
+                .map_err(|_| LoadError::FailedToReadFile)?;
+            file.read(&mut symtab_buf)
+                .map_err(|_| LoadError::FailedToReadFile)?;
 
             // Cast buffer into symbols
             let sym_count = sh.sh_size as usize / sh.sh_entsize as usize;
@@ -169,22 +194,23 @@ fn patch_syscalls(
                     &symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize];
                 let sym = cast_sym(sym_bytes);
 
-                let str_sh = read_section(file, elf_header, sh.sh_link);
+                let str_sh = read_section(file, elf_header, sh.sh_link)?;
 
                 let mut name = Vec::new();
                 file.seek_from_start(str_sh.sh_offset + sym.st_name)
-                    .unwrap();
+                    .map_err(|_| LoadError::FailedToReadFile)?;
 
                 loop {
                     let mut byte = [0u8; 1];
-                    file.read(&mut byte).unwrap();
+                    file.read(&mut byte)
+                        .map_err(|_| LoadError::FailedToReadFile)?;
                     if byte[0] == 0 {
                         break;
                     }
                     name.push(byte[0]);
                 }
 
-                let symbol_name = core::str::from_utf8(&name).unwrap();
+                let symbol_name = core::str::from_utf8(&name).expect("symbol was not utf8");
                 if symbol_name == stringify!(SYS_CALL_TABLE) {
                     let table_base =
                         unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
@@ -204,6 +230,9 @@ fn patch_syscalls(
                             SyscallTable::ReadFile => syscalls::read_file as usize,
                             SyscallTable::WriteFile => syscalls::write_file as usize,
                             SyscallTable::FileLen => syscalls::file_len as usize,
+                            SyscallTable::ReconfigureAudioSampleRate => {
+                                syscalls::reconfigure_audio_sample_rate as usize
+                            }
                             SyscallTable::AudioBufferReady => syscalls::audio_buffer_ready as usize,
                             SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize,
                         };
@@ -216,20 +245,20 @@ fn patch_syscalls(
             }
         }
     }
-    Err(())
+    Err(LoadError::SyscallTableNotFound)
 }
 
 fn total_loadable_size(
     file: &mut File,
     elf_header: &Header,
     ph_buf: &mut [u8],
-) -> (usize, u32, u32) {
+) -> Result<(usize, u32, u32), LoadError> {
     let mut min_vaddr = u32::MAX;
     let mut max_vaddr = 0u32;
     for i in 0..elf_header.e_phnum {
         file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-            .unwrap();
-        file.read(ph_buf).unwrap();
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        file.read(ph_buf).map_err(|_| LoadError::FailedToReadFile)?;
         let ph = cast_phdr(ph_buf);
 
         if ph.p_type == PT_LOAD {
@@ -243,17 +272,22 @@ fn total_loadable_size(
     }
 
     let total_size = (max_vaddr - min_vaddr) as usize;
-    (total_size, min_vaddr, max_vaddr)
+    Ok((total_size, min_vaddr, max_vaddr))
 }
 
-fn read_section(file: &mut File, elf_header: &Header, section: u32) -> SectionHeader {
+fn read_section(
+    file: &mut File,
+    elf_header: &Header,
+    section: u32,
+) -> Result<SectionHeader, LoadError> {
     let mut sh_buf = vec![0_u8; elf_header.e_shentsize as usize];
 
     file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
-        .unwrap();
-    file.read(&mut sh_buf).unwrap();
+        .map_err(|_| LoadError::FailedToReadFile)?;
+    file.read(&mut sh_buf)
+        .map_err(|_| LoadError::FailedToReadFile)?;
 
-    cast_shdr(&sh_buf)
+    Ok(cast_shdr(&sh_buf))
 }
 
 fn cast_phdr(buf: &[u8]) -> ProgramHeader {

kernel/src/main.rs

@@ -5,6 +5,9 @@
 #![allow(static_mut_refs)]
 #![feature(allocator_api)]
 #![feature(slice_ptr_get)]
+#![deny(warnings)]
+#![deny(clippy::redundant_clone)]
+#![deny(clippy::unwrap_used)]
 
 extern crate alloc;
 

kernel/src/storage.rs

@@ -52,6 +52,13 @@ impl Ord for FileName {
     }
 }
 
+#[derive(Debug)]
+pub enum SdCardError {
+    Volume0Missing,
+    RootDirMissing,
+    FileOpenFailed,
+}
+
 pub struct SdCard {
     det: Input<'static>,
     volume_mgr: VolMgr,
@@ -104,30 +111,37 @@ impl SdCard {
         res.map_err(|_| ())
     }
 
-    pub fn access_root_dir(&mut self, mut access: impl FnMut(Dir)) {
-        let volume0 = self.volume_mgr.open_volume(VolumeIdx(0)).unwrap();
-        let root_dir = volume0.open_root_dir().unwrap();
+    pub fn access_root_dir<R>(
+        &mut self,
+        mut access: impl FnMut(Dir) -> R,
+    ) -> Result<R, SdCardError> {
+        let volume0 = self
+            .volume_mgr
+            .open_volume(VolumeIdx(0))
+            .map_err(|_| SdCardError::Volume0Missing)?;
+        let root_dir = volume0
+            .open_root_dir()
+            .map_err(|_| SdCardError::RootDirMissing)?;
 
-        access(root_dir);
+        Ok(access(root_dir))
     }
 
-    pub async fn read_file<T>(
+    pub async fn read_file<R>(
         &mut self,
         name: &ShortFileName,
-        mut access: impl FnMut(File) -> T,
-    ) -> Result<T, ()> {
-        let mut res = Err(());
+        mut access: impl FnMut(File) -> R,
+    ) -> Result<R, SdCardError> {
         self.access_root_dir(|root_dir| {
-            if let Ok(file) = root_dir.open_file_in_dir(name, Mode::ReadOnly) {
-                res = Ok(access(file));
-            }
-        });
+            let file = root_dir
+                .open_file_in_dir(name, Mode::ReadOnly)
+                .map_err(|_| SdCardError::FileOpenFailed)?;
 
-        res
+            Ok(access(file))
+        })?
     }
 
     /// Returns a Vec of file names (long format) that match the given extension (e.g., "BIN")
-    pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, ()> {
+    pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, SdCardError> {
         let mut result = Vec::new();
 
         // Only proceed if card is inserted
@@ -151,7 +165,7 @@ impl SdCard {
                 }
             })
             .unwrap()
-        });
+        })?;
 
         Ok(result)
     }

kernel/src/syscalls.rs

@@ -7,8 +7,8 @@ use embedded_sdmmc::LfnBuffer;
 use heapless::spsc::Queue;
 use userlib_sys::{
     AUDIO_BUFFER_SAMPLES, Alloc, AudioBufferReady, CLayout, CPixel, Dealloc, DrawIter, FileLen,
-    GenRand, GetMs, ListDir, Print, ReadFile, RngRequest, SendAudioBuffer, SleepMs, WriteFile,
-    keyboard::*,
+    GenRand, GetMs, ListDir, Print, ReadFile, ReconfigureAudioSampleRate, RngRequest,
+    SendAudioBuffer, SleepMs, WriteFile, keyboard::*,
 };
 
 #[cfg(feature = "psram")]
@@ -18,7 +18,7 @@ use crate::heap::HEAP;
 use core::alloc::GlobalAlloc;
 
 use crate::{
-    audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_WRITTEN},
+    audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_SAMPLE_RATE, AUDIO_BUFFER_WRITTEN},
     display::FRAMEBUFFER,
     framebuffer::FB_PAUSED,
     storage::{Dir, File, SDCARD},
@@ -190,7 +190,7 @@ pub extern "C" fn list_dir(
     let sd = guard.as_mut().unwrap();
 
     let mut wrote = 0;
-    sd.access_root_dir(|root| {
+    let _ = sd.access_root_dir(|root| {
         if dirs[0].is_empty() && dirs.len() >= 2 {
             unsafe {
                 if dir == "/" {
@@ -264,7 +264,7 @@ pub extern "C" fn read_file(
     let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
-        sd.access_root_dir(|root| {
+        let _ = sd.access_root_dir(|root| {
             if let Ok(result) = recurse_file(&root, &components[1..count], |file| {
                 file.seek_from_start(start_from as u32).unwrap_or(());
                 file.read(buf).unwrap()
@@ -303,7 +303,7 @@ pub extern "C" fn write_file(
     let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
-        sd.access_root_dir(|root| {
+        let _ = sd.access_root_dir(|root| {
             recurse_file(&root, &components[1..count], |file| {
                 file.seek_from_start(start_from as u32).unwrap();
                 file.write(buf).unwrap()
@@ -324,7 +324,7 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
-        sd.access_root_dir(|root| {
+        let _ = sd.access_root_dir(|root| {
             if let Ok(result) = recurse_file(&root, &file[1..], |file| file.length()) {
                 len = result
             }
@@ -333,6 +333,11 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     len as usize
 }
 
+const _: ReconfigureAudioSampleRate = reconfigure_audio_sample_rate;
+pub extern "C" fn reconfigure_audio_sample_rate(sample_rate: u32) {
+    AUDIO_BUFFER_SAMPLE_RATE.store(sample_rate, Ordering::Release);
+}
+
 const _: AudioBufferReady = audio_buffer_ready;
 pub extern "C" fn audio_buffer_ready() -> bool {
     AUDIO_BUFFER_READY.load(Ordering::Acquire)

kernel/src/ui.rs

@@ -44,9 +44,10 @@ pub async fn ui_handler() {
                         selections.selections[selections.current_selection as usize].clone();
 
                     let entry = unsafe {
-                        load_binary(&selection.short_name)
-                            .await
-                            .expect("unable to load binary")
+                        match load_binary(&selection.short_name).await {
+                            Ok(entry) => entry,
+                            Err(e) => panic!("unable to load binary: {:?}", e),
+                        }
                     };
                     BINARY_CH.send(entry).await;
                 }

userlib_sys/src/lib.rs

@@ -12,7 +12,7 @@ use strum::{EnumCount, EnumIter};
 
 pub type EntryFn = fn();
 
-pub const SYS_CALL_TABLE_COUNT: usize = 14;
+pub const SYS_CALL_TABLE_COUNT: usize = 15;
 const _: () = assert!(SYS_CALL_TABLE_COUNT == SyscallTable::COUNT);
 
 #[derive(Clone, Copy, EnumIter, EnumCount)]
@@ -30,8 +30,9 @@ pub enum SyscallTable {
     ReadFile = 9,
     WriteFile = 10,
     FileLen = 11,
-    AudioBufferReady = 12,
-    SendAudioBuffer = 13,
+    ReconfigureAudioSampleRate = 12,
+    AudioBufferReady = 13,
+    SendAudioBuffer = 14,
 }
 
 #[unsafe(no_mangle)]
@@ -217,7 +218,7 @@ pub mod keyboard {
                 1 => KeyState::Pressed,
                 2 => KeyState::Hold,
                 3 => KeyState::Released,
-                0 | _ => KeyState::Idle,
+                _ => KeyState::Idle,
             }
         }
     }
@@ -473,6 +474,17 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     }
 }
 
+pub type ReconfigureAudioSampleRate = extern "C" fn(sample_rate: u32);
+
+#[allow(unused)]
+pub fn reconfigure_audio_sample_rate(sample_rate: u32) {
+    unsafe {
+        let ptr = SYS_CALL_TABLE[SyscallTable::ReconfigureAudioSampleRate as usize];
+        let f: ReconfigureAudioSampleRate = core::mem::transmute(ptr);
+        f(sample_rate)
+    }
+}
+
 pub type AudioBufferReady = extern "C" fn() -> bool;
 
 #[allow(unused)]