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

163
kernel/src/elf.rs
View File

@@ -20,69 +20,76 @@ 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 {
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;
// reject non-PIE
if elf_header.e_type != header::ET_DYN {
return Err(LoadError::ElfIsNotPie);
}
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 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 +101,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 +126,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 +151,7 @@ fn apply_relocations(
}
}
_ => {
return Err(());
return Err(LoadError::UnknownRelocationType);
}
}
}
@@ -152,15 +163,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 +182,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 +233,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 +260,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 {