validate elf header

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "picolibc"]
 	path = picolibc
 	url = https://github.com/picolibc/picolibc
-[submodule "user_apps/gboy/Peanut-GB"]
-	path = user_apps/gboy/Peanut-GB
+[submodule "user-apps/gboy/Peanut-GB"]
+	path = user-apps/gboy/Peanut-GB
 	url = https://github.com/deltabeard/Peanut-GB

Cargo.lock

@@ -110,26 +110,6 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
-[[package]]
-name = "bindgen"
-version = "0.71.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
-dependencies = [
- "bitflags 2.10.0",
- "cexpr",
- "clang-sys",
- "itertools 0.10.5",
- "log",
- "prettyplease",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash",
- "shlex",
- "syn 2.0.110",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -266,42 +246,12 @@ dependencies = [
  "toml",
 ]
 
-[[package]]
-name = "cc"
-version = "1.2.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37521ac7aabe3d13122dc382493e20c9416f299d2ccd5b3a5340a2570cdeb0f3"
-dependencies = [
- "find-msvc-tools",
- "shlex",
-]
-
-[[package]]
-name = "cexpr"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
-dependencies = [
- "nom",
-]
-
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
-[[package]]
-name = "clang-sys"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
-dependencies = [
- "glob",
- "libc",
- "libloading",
-]
-
 [[package]]
 name = "clap"
 version = "3.2.25"
@@ -1127,12 +1077,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
-
 [[package]]
 name = "fixed"
 version = "1.29.0"
@@ -1270,17 +1214,6 @@ dependencies = [
  "userlib",
 ]
 
-[[package]]
-name = "gboy"
-version = "0.1.0"
-dependencies = [
- "bindgen",
- "cc",
- "embedded-graphics",
- "selection_ui",
- "userlib",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -1324,12 +1257,6 @@ dependencies = [
  "userlib",
 ]
 
-[[package]]
-name = "glob"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
-
 [[package]]
 name = "goblin"
 version = "0.10.3"
@@ -1622,16 +1549,6 @@ version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
-[[package]]
-name = "libloading"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
-dependencies = [
- "cfg-if",
- "windows-link",
-]
-
 [[package]]
 name = "libredox"
 version = "0.1.10"
@@ -1687,12 +1604,6 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"
 
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -1714,16 +1625,6 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1987,16 +1888,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
-[[package]]
-name = "prettyplease"
-version = "0.2.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
-dependencies = [
- "proc-macro2",
- "syn 2.0.110",
-]
-
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -2186,12 +2077,6 @@ dependencies = [
  "crc-any",
 ]
 
-[[package]]
-name = "rustc-hash"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
-
 [[package]]
 name = "rustc_version"
 version = "0.2.3"
@@ -2331,12 +2216,6 @@ dependencies = [
  "keccak",
 ]
 
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
 [[package]]
 name = "siphasher"
 version = "1.0.1"

Cargo.toml

@@ -10,7 +10,6 @@ members = [
   "user_apps/gallery",
   "user_apps/gif",
   "user_apps/wav_player",
-  "user_apps/gboy",
 ]
 
 [profile.release]

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
 

justfile

@@ -42,7 +42,6 @@ userapps: cbindgen
     just userapp gallery
     just userapp gif
     just userapp wav_player
-    just userapp gboy
 
 copy-userapp app:
     cp ./target/{{target}}/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin
@@ -55,7 +54,6 @@ copy-userapps:
     just copy-userapp gallery
     just copy-userapp gif
     just copy-userapp wav_player
-    just copy-userapp gboy
 
     DEV=$(lsblk -o LABEL,NAME -nr | awk -v L="PICOCALC" '$1==L {print "/dev/" $2}')
     udisksctl unmount -b "$DEV"

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) }
@@ -219,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 {
@@ -246,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

@@ -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
             }

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;
                 }

user_apps/gboy/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "gboy"
-version = "0.1.0"
-edition = "2024"
-
-[build-dependencies]
-bindgen = "0.71.0"
-cc = "1.2.44"
-
-[dependencies]
-userlib = { path = "../../userlib" }
-selection_ui = { path = "../../selection_ui" }
-embedded-graphics = "0.8.1"

user_apps/gboy/build.rs

@@ -1,64 +0,0 @@
-//! This build script copies the `memory.x` file from the crate root into
-//! a directory where the linker can always find it at build time.
-//! For many projects this is optional, as the linker always searches the
-//! project root directory -- wherever `Cargo.toml` is. However, if you
-//! are using a workspace or have a more complicated build setup, this
-//! build script becomes required. Additionally, by requesting that
-//! Cargo re-run the build script whenever `memory.x` is changed,
-//! updating `memory.x` ensures a rebuild of the application with the
-//! new memory settings.
-
-use std::env;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-
-fn main() {
-    bindgen();
-
-    // Put `memory.x` in our output directory and ensure it's
-    // on the linker search path.
-    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    File::create(out.join("memory.x"))
-        .unwrap()
-        .write_all(include_bytes!("../memory.x"))
-        .unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-
-    println!("cargo:rerun-if-changed=memory.x");
-    println!("cargo:rustc-link-arg-bins=-Tmemory.x");
-}
-
-fn bindgen() {
-    let bindings = bindgen::Builder::default()
-        .header("Peanut-GB/peanut_gb.h")
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
-        .disable_nested_struct_naming()
-        .clang_arg("-I../../picolibc/newlib/libc/include/")
-        .clang_arg("-I../../picolibc/build/")
-        .use_core()
-        .generate()
-        .expect("Unable to generate bindings");
-
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
-    bindings
-        .write_to_file(out_path.join("bindings.rs"))
-        .expect("Couldn't write bindings!");
-
-    cc::Build::new()
-        .define("PEANUT_GB_IS_LITTLE_ENDIAN", None)
-        .define("ENABLE_LCD", None)
-        .file("peanut_gb_stub.c")
-        .include("Peanut-GB")
-        // optimization flags
-        .flag("-Ofast")
-        .flag("-fdata-sections")
-        .flag("-ffunction-sections")
-        .flag("-mcpu=cortex-m33")
-        .flag("-mthumb")
-        .flag("-g0")
-        .compile("peanut_gb");
-
-    println!("cargo:rustc-link-search=Peanut-GB");
-    println!("cargo:rustc-link-lib=peanut_gb");
-}

user_apps/gboy/peanut_gb_stub.c

@@ -1 +0,0 @@
-#include <peanut_gb.h>

user_apps/gboy/src/main.rs

@@ -1,206 +0,0 @@
-#![no_std]
-#![no_main]
-#![allow(static_mut_refs)]
-
-extern crate alloc;
-use alloc::{vec, vec::Vec};
-use core::{cell::LazyCell, mem::MaybeUninit, panic::PanicInfo};
-use embedded_graphics::{
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
-    pixelcolor::Rgb565,
-    prelude::RgbColor,
-};
-use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
-use userlib::{
-    display::Display,
-    format,
-    fs::{Entries, file_len, list_dir, read_file, write_file},
-    get_key,
-    keyboard::{KeyCode, KeyState},
-    println,
-};
-
-mod peanut;
-use peanut::gb_run_frame;
-
-use crate::peanut::{
-    JOYPAD_A, JOYPAD_B, JOYPAD_DOWN, JOYPAD_LEFT, JOYPAD_RIGHT, JOYPAD_SELECT, JOYPAD_START,
-    JOYPAD_UP, gb_cart_ram_read, gb_cart_ram_write, gb_error, gb_get_rom_name, gb_get_save_size,
-    gb_init, gb_init_lcd, gb_reset, gb_rom_read, gb_s, lcd_draw_line,
-};
-
-static mut DISPLAY: LazyCell<Display> = LazyCell::new(|| Display::take().unwrap());
-
-const RAM_SIZE: usize = 32 * 1024; // largest ram size is 32k
-static mut RAM: [u8; RAM_SIZE] = [0; RAM_SIZE];
-
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    println!("user panic: {} @ {:?}", info.message(), info.location(),);
-    loop {}
-}
-
-#[unsafe(no_mangle)]
-pub extern "Rust" fn _start() {
-    main()
-}
-
-const GAME_PATH: &'static str = "/games/gameboy";
-
-static mut GAME_ROM: Option<Vec<u8>> = None;
-
-pub fn main() {
-    println!("Starting Gameboy app");
-
-    let mut entries = Entries::new();
-    list_dir(GAME_PATH, &mut entries);
-
-    let mut files = entries.entries();
-    files.retain(|e| {
-        let ext = e.extension().unwrap_or("");
-        ext == "gb" || ext == "GB"
-    });
-    let mut roms = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
-    roms.sort();
-
-    let selection = {
-        let display = unsafe { &mut *DISPLAY };
-        let mut selection_ui = SelectionUi::new(&roms);
-        match selection_ui.run_selection_ui(display) {
-            Ok(maybe_sel) => maybe_sel,
-            Err(e) => match e {
-                SelectionUiError::SelectionListEmpty => {
-                    draw_text_center(
-                        display,
-                        &format!("No Roms were found in {}", GAME_PATH),
-                        MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
-                    )
-                    .expect("Display Error");
-                    None
-                }
-                SelectionUiError::DisplayError(_) => panic!("Display Error"),
-            },
-        }
-    };
-
-    assert!(selection.is_some());
-
-    let file_name = format!("{}/{}", GAME_PATH, roms[selection.unwrap()]);
-    let size = file_len(&file_name);
-    unsafe { GAME_ROM = Some(vec![0_u8; size]) };
-    let read = read_file(&file_name, 0, unsafe { GAME_ROM.as_mut().unwrap() });
-    assert!(size == read);
-    println!("Rom size: {}", read);
-
-    let mut gb = MaybeUninit::<gb_s>::uninit();
-
-    let init_status = unsafe {
-        gb_init(
-            gb.as_mut_ptr(),
-            Some(gb_rom_read),
-            Some(gb_cart_ram_read),
-            Some(gb_cart_ram_write),
-            Some(gb_error),
-            core::ptr::null_mut(),
-        )
-    };
-    println!("gb init status: {}", init_status);
-
-    unsafe {
-        load_save(&mut gb.assume_init());
-    }
-
-    unsafe {
-        gb_init_lcd(gb.as_mut_ptr(), Some(lcd_draw_line));
-
-        // enable frame skip
-        // gb.assume_init().direct.set_frame_skip(!true); // active low
-    };
-
-    loop {
-        let event = get_key();
-        let button = match event.key {
-            KeyCode::Esc => {
-                unsafe { write_save(&mut gb.assume_init()) };
-                break;
-            }
-            KeyCode::Char('r') => {
-                unsafe { gb_reset(gb.as_mut_ptr()) };
-                continue;
-            }
-            KeyCode::Tab => JOYPAD_START as u8,
-            KeyCode::Del => JOYPAD_SELECT as u8,
-            KeyCode::Enter => JOYPAD_A as u8,
-            KeyCode::Backspace => JOYPAD_B as u8,
-            KeyCode::Up => JOYPAD_UP as u8,
-            KeyCode::Down => JOYPAD_DOWN as u8,
-            KeyCode::Left => JOYPAD_LEFT as u8,
-            KeyCode::Right => JOYPAD_RIGHT as u8,
-            _ => 0,
-        };
-
-        if button != 0 {
-            unsafe {
-                // bindgen incorrectly generates direct so manual manipulation is required :(
-                let direct_ptr = &mut gb.assume_init().direct as *mut _ as *mut u8;
-                let joypad_ptr = direct_ptr.add(2); // this is the joypad bitfield byte
-
-                if let KeyState::Pressed = event.state {
-                    *joypad_ptr &= !button;
-                } else if let KeyState::Released = event.state {
-                    *joypad_ptr |= button;
-                }
-
-                println!("joypad: {:b}", *joypad_ptr);
-            }
-        }
-
-        unsafe {
-            gb_run_frame(gb.as_mut_ptr());
-        }
-    }
-}
-
-unsafe fn load_save(gb: &mut gb_s) {
-    let mut buf = [0; 16];
-
-    unsafe {
-        gb_get_rom_name(gb, buf.as_mut_ptr());
-
-        let save_size = gb_get_save_size(gb);
-
-        if save_size > 0 {
-            read_file(
-                &format!(
-                    "{}/saves/{}.sav",
-                    GAME_PATH,
-                    str::from_utf8(&buf).expect("bad rom name")
-                ),
-                0,
-                &mut RAM,
-            );
-        }
-    }
-}
-
-unsafe fn write_save(gb: &mut gb_s) {
-    let mut buf = [0; 16];
-
-    unsafe {
-        gb_get_rom_name(gb, buf.as_mut_ptr());
-
-        let save_size = gb_get_save_size(gb);
-
-        if save_size > 0 {
-            write_file(
-                &format!(
-                    "{}/saves/{}.sav",
-                    GAME_PATH,
-                    str::from_utf8(&buf).expect("bad rom name")
-                ),
-                0,
-                &mut RAM,
-            );
-        }
-    }
-}

user_apps/gboy/src/peanut.rs

@@ -1,102 +0,0 @@
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-
-use crate::{DISPLAY, GAME_ROM, RAM};
-
-#[allow(unused)]
-include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
-
-use embedded_graphics::{pixelcolor::Rgb565, prelude::Point, Drawable};
-use userlib::{display::Pixel565, println};
-
-pub const GBOY_WIDTH: usize = 160;
-pub const GBOY_HEIGHT: usize = 144;
-
-pub unsafe extern "C" fn gb_rom_read(_gb: *mut gb_s, addr: u32) -> u8 {
-    unsafe { GAME_ROM.as_ref().unwrap()[addr as usize] }
-}
-
-pub unsafe extern "C" fn gb_cart_ram_read(_gb: *mut gb_s, addr: u32) -> u8 {
-    unsafe { RAM[addr as usize] }
-}
-
-pub unsafe extern "C" fn gb_cart_ram_write(_gb: *mut gb_s, addr: u32, val: u8) {
-    unsafe { RAM[addr as usize] = val }
-}
-
-pub unsafe extern "C" fn gb_error(_gb: *mut gb_s, err: gb_error_e, addr: u16) {
-    let e = match err {
-        0 => "UNKNOWN ERROR",
-        1 => "INVALID OPCODE",
-        2 => "INVALID READ",
-        3 => "INVALID WRITE",
-        4 => "HALT FOREVER",
-        5 => "INVALID MAX",
-        _ => unreachable!(),
-    };
-
-    println!("PeanutGB error: {}, addr: {}", e, addr);
-}
-
-const NUM_PALETTES: usize = 3;
-const SHADES_PER_PALETTE: usize = 4;
-
-const PALETTES: [[Rgb565; SHADES_PER_PALETTE]; NUM_PALETTES] = [
-    [
-        Rgb565::new(8, 24, 32),
-        Rgb565::new(52, 104, 86),
-        Rgb565::new(136, 192, 112),
-        Rgb565::new(224, 248, 208),
-    ], // BG
-    [
-        Rgb565::new(8, 24, 32),
-        Rgb565::new(52, 104, 86),
-        Rgb565::new(136, 192, 112),
-        Rgb565::new(224, 248, 208),
-    ], // OBJ0
-    [
-        Rgb565::new(8, 24, 32),
-        Rgb565::new(52, 104, 86),
-        Rgb565::new(136, 192, 112),
-        Rgb565::new(224, 248, 208),
-    ], // OBJ1
-];
-
-pub unsafe extern "C" fn lcd_draw_line(_gb: *mut gb_s, pixels: *const u8, line: u8) {
-    if line < GBOY_HEIGHT as u8 {
-        let pixels = unsafe { core::slice::from_raw_parts(pixels, GBOY_WIDTH) };
-        let y = line as u16;
-
-        for (x, &p) in pixels.iter().enumerate() {
-            let palette_idx = ((p & 0xF0) >> 4) as usize;
-            let shade_idx = (p & 0x03) as usize;
-
-            let color = PALETTES
-                .get(palette_idx)
-                .and_then(|pal| pal.get(shade_idx))
-                .copied()
-                .unwrap_or(Rgb565::new(0, 0, 0));
-
-            // let sx = (x as u16) * 2;
-            // let sy = y * 2;
-
-            // draw_color(color, sx, sy);
-            // draw_color(color, sx + 1, sy);
-            // draw_color(color, sx, sy + 1);
-            // draw_color(color, sx + 1, sy + 1);
-            //
-            draw_color(color, x as u16, y as u16);
-        }
-    }
-}
-
-fn draw_color(color: Rgb565, x: u16, y: u16) {
-    let mut pixel = Pixel565::default();
-    pixel.0 = Point::new(x.into(), y.into());
-    pixel.1 = color;
-
-    unsafe {
-        pixel.draw(&mut *DISPLAY).unwrap();
-    }
-}