sawyer/picocalc-os-rs
1
1
Fork 0
mirror of https://github.com/LegitCamper/picocalc-os-rs.git synced 2025-12-27 07:45:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

loader errors

Browse Source
This commit is contained in:
sawyer bristol
2025-11-21 11:24:31 -07:00
parent b20439e1d7
commit 6e88feb9a7
5 changed files with 131 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
kernel/src/elf.rs
View File

@@ -20,26 +20,34 @@ use userlib_sys::{EntryFn, SyscallTable};
const ELF32_HDR_SIZE: usize = 52; const ELF32_HDR_SIZE: usize = 52;
pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> { #[derive(Debug)]
pub enum LoadError {
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 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 mut header_buf = [0; ELF32_HDR_SIZE];
let (entry, bump) = sd sd.read_file(name, |mut file| {
.read_file(name, |mut file| { file.read(&mut header_buf)
file.read(&mut header_buf).unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
let elf_header = Header::from_bytes(&header_buf); let elf_header = Header::from_bytes(&header_buf);
// reject non-PIE // reject non-PIE
if elf_header.e_type != header::ET_DYN { if elf_header.e_type != header::ET_DYN {
return None; return Err(LoadError::ElfIsNotPie);
} }
let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize]; let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
let (total_size, min_vaddr, _max_vaddr) = let (total_size, min_vaddr, _max_vaddr) =
total_loadable_size(&mut file, elf_header, &mut ph_buf); total_loadable_size(&mut file, elf_header, &mut ph_buf)?;
let bump = Bump::with_capacity(total_size); let bump = Bump::with_capacity(total_size);
let base = bump.alloc_slice_fill_default::<u8>(total_size); let base = bump.alloc_slice_fill_default::<u8>(total_size);
@@ -47,42 +55,41 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)>
// load each segment into bump, relative to base_ptr // load each segment into bump, relative to base_ptr
for i in 0..elf_header.e_phnum { for i in 0..elf_header.e_phnum {
file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32) file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
.unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
file.read(&mut ph_buf).unwrap(); file.read(&mut ph_buf)
.map_err(|_| LoadError::FailedToReadFile)?;
let ph = cast_phdr(&ph_buf); let ph = cast_phdr(&ph_buf);
let seg_offset = (ph.p_vaddr - min_vaddr) as usize; let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize]; let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
if ph.p_type == PT_LOAD { if ph.p_type == PT_LOAD {
load_segment(&mut file, &ph, segment).unwrap(); load_segment(&mut file, &ph, segment)?;
} }
} }
for i in 0..elf_header.e_shnum { for i in 0..elf_header.e_shnum {
let sh = read_section(&mut file, elf_header, i.into()); let sh = read_section(&mut file, elf_header, i.into())?;
if sh.sh_type == SHT_REL { if sh.sh_type == SHT_REL {
apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap(); apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file)?;
} }
} }
patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file)?;
// entry pointer is base_ptr + (entry - min_vaddr) // entry pointer is base_ptr + (entry - min_vaddr)
let entry_ptr: EntryFn = unsafe { let entry_ptr: EntryFn = unsafe {
core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize)) core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
}; };
Some((entry_ptr, bump)) Ok((entry_ptr, bump))
}) })
.await .await
.expect("Failed to read file")?; .map_err(|_| LoadError::FailedToReadFile)?
Some((entry, bump))
} }
fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), ()> { fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), LoadError> {
let filesz = ph.p_filesz as usize; let filesz = ph.p_filesz as usize;
let memsz = ph.p_memsz as usize; let memsz = ph.p_memsz as usize;
@@ -94,8 +101,10 @@ fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Resu
while remaining > 0 { while remaining > 0 {
let to_read = core::cmp::min(remaining, buf.len()); let to_read = core::cmp::min(remaining, buf.len());
file.seek_from_start(file_offset).unwrap(); file.seek_from_start(file_offset)
file.read(&mut buf[..to_read]).unwrap(); .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]); segment[dst_offset..dst_offset + to_read].copy_from_slice(&buf[..to_read]);
@@ -117,14 +126,16 @@ fn apply_relocations(
min_vaddr: u32, min_vaddr: u32,
base: *mut u8, base: *mut u8,
file: &mut File, file: &mut File,
) -> Result<(), ()> { ) -> Result<(), LoadError> {
let mut reloc = [0_u8; 8]; let mut reloc = [0_u8; 8];
let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize; let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize;
for i in 0..num_relocs { for i in 0..num_relocs {
file.seek_from_start(sh.sh_offset + (i as u32 * 8)).unwrap(); file.seek_from_start(sh.sh_offset + (i as u32 * 8))
file.read(&mut reloc).unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
file.read(&mut reloc)
.map_err(|_| LoadError::FailedToReadFile)?;
let rel = cast_rel(&reloc); let rel = cast_rel(&reloc);
@@ -140,7 +151,7 @@ fn apply_relocations(
} }
} }
_ => { _ => {
return Err(()); return Err(LoadError::UnknownRelocationType);
} }
} }
} }
@@ -152,15 +163,17 @@ fn patch_syscalls(
base: *mut u8, base: *mut u8,
min_vaddr: u32, min_vaddr: u32,
file: &mut File, file: &mut File,
) -> Result<(), ()> { ) -> Result<(), LoadError> {
for i in 1..=elf_header.e_shnum { 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 // find the symbol table
if sh.sh_type == SHT_SYMTAB { if sh.sh_type == SHT_SYMTAB {
let mut symtab_buf = vec![0u8; sh.sh_size as usize]; let mut symtab_buf = vec![0u8; sh.sh_size as usize];
file.seek_from_start(sh.sh_offset).unwrap(); file.seek_from_start(sh.sh_offset)
file.read(&mut symtab_buf).unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
file.read(&mut symtab_buf)
.map_err(|_| LoadError::FailedToReadFile)?;
// Cast buffer into symbols // Cast buffer into symbols
let sym_count = sh.sh_size as usize / sh.sh_entsize as usize; let sym_count = sh.sh_size as usize / sh.sh_entsize as usize;
@@ -169,22 +182,23 @@ fn patch_syscalls(
&symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize]; &symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize];
let sym = cast_sym(sym_bytes); 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(); let mut name = Vec::new();
file.seek_from_start(str_sh.sh_offset + sym.st_name) file.seek_from_start(str_sh.sh_offset + sym.st_name)
.unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
loop { loop {
let mut byte = [0u8; 1]; let mut byte = [0u8; 1];
file.read(&mut byte).unwrap(); file.read(&mut byte)
.map_err(|_| LoadError::FailedToReadFile)?;
if byte[0] == 0 { if byte[0] == 0 {
break; break;
} }
name.push(byte[0]); 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) { if symbol_name == stringify!(SYS_CALL_TABLE) {
let table_base = let table_base =
unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) } unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
@@ -219,20 +233,20 @@ fn patch_syscalls(
} }
} }
} }
Err(()) Err(LoadError::SyscallTableNotFound)
} }
fn total_loadable_size( fn total_loadable_size(
file: &mut File, file: &mut File,
elf_header: &Header, elf_header: &Header,
ph_buf: &mut [u8], ph_buf: &mut [u8],
) -> (usize, u32, u32) { ) -> Result<(usize, u32, u32), LoadError> {
let mut min_vaddr = u32::MAX; let mut min_vaddr = u32::MAX;
let mut max_vaddr = 0u32; let mut max_vaddr = 0u32;
for i in 0..elf_header.e_phnum { for i in 0..elf_header.e_phnum {
file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32) file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
.unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
file.read(ph_buf).unwrap(); file.read(ph_buf).map_err(|_| LoadError::FailedToReadFile)?;
let ph = cast_phdr(ph_buf); let ph = cast_phdr(ph_buf);
if ph.p_type == PT_LOAD { if ph.p_type == PT_LOAD {
@@ -246,17 +260,22 @@ fn total_loadable_size(
} }
let total_size = (max_vaddr - min_vaddr) as usize; 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]; 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)) file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
.unwrap(); .map_err(|_| LoadError::FailedToReadFile)?;
file.read(&mut sh_buf).unwrap(); file.read(&mut sh_buf)
.map_err(|_| LoadError::FailedToReadFile)?;
cast_shdr(&sh_buf) Ok(cast_shdr(&sh_buf))
} }
fn cast_phdr(buf: &[u8]) -> ProgramHeader { fn cast_phdr(buf: &[u8]) -> ProgramHeader {

3
kernel/src/main.rs
View File

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

44
kernel/src/storage.rs
View File

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

8
kernel/src/syscalls.rs
View File

@@ -190,7 +190,7 @@ pub extern "C" fn list_dir(
let sd = guard.as_mut().unwrap(); let sd = guard.as_mut().unwrap();
let mut wrote = 0; let mut wrote = 0;
sd.access_root_dir(|root| { let _ = sd.access_root_dir(|root| {
if dirs[0].is_empty() && dirs.len() >= 2 { if dirs[0].is_empty() && dirs.len() >= 2 {
unsafe { unsafe {
if dir == "/" { 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 mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
let sd = guard.as_mut().unwrap(); let sd = guard.as_mut().unwrap();
if !file.is_empty() { 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| { if let Ok(result) = recurse_file(&root, &components[1..count], |file| {
file.seek_from_start(start_from as u32).unwrap_or(()); file.seek_from_start(start_from as u32).unwrap_or(());
file.read(buf).unwrap() 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 mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
let sd = guard.as_mut().unwrap(); let sd = guard.as_mut().unwrap();
if !file.is_empty() { if !file.is_empty() {
sd.access_root_dir(|root| { let _ = sd.access_root_dir(|root| {
recurse_file(&root, &components[1..count], |file| { recurse_file(&root, &components[1..count], |file| {
file.seek_from_start(start_from as u32).unwrap(); file.seek_from_start(start_from as u32).unwrap();
file.write(buf).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 mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
let sd = guard.as_mut().unwrap(); let sd = guard.as_mut().unwrap();
if !file.is_empty() { 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()) { if let Ok(result) = recurse_file(&root, &file[1..], |file| file.length()) {
len = result len = result
} }

7
kernel/src/ui.rs
View File

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