ahrightos-kernel 0.1.0

RISC-V 64 Rust teaching kernel for AhRightOS.
Documentation
//! ELF64 parser for user program loading.
//!
//! Parses ELF64 Executable and Linkable Format files, extracting LOAD
//! segments and the program entry point for the user-mode loader.

use crate::println;

/// ELF identification index constants
const EI_MAG0: usize = 0;
const EI_MAG3: usize = 3;
const EI_CLASS: usize = 4;
const EI_DATA: usize = 5;

/// ELF magic bytes
const ELF_MAGIC: [u8; 4] = [0x7f, b'E', b'L', b'F'];
const ELFCLASS64: u8 = 2;
const ELFDATA2LSB: u8 = 1;

/// ELF file type
const ET_EXEC: u16 = 2; // Executable file

/// RISC-V machine ID
const EM_RISCV: u16 = 243;

/// Program header type: loadable segment
const PT_LOAD: u32 = 1;

/// A parsed LOAD segment from an ELF64 file.
#[derive(Debug, Clone)]
pub struct ElfSegment {
    /// File offset of the segment data
    pub offset: usize,
    /// Virtual address where this segment should be loaded
    pub vaddr: usize,
    /// Size of the segment in the file
    pub filesz: usize,
    /// Size of the segment in memory (may be larger than filesz for .bss)
    pub memsz: usize,
    /// Segment flags (PF_R=4, PF_W=2, PF_X=1)
    pub flags: u32,
}

/// A parsed ELF64 executable.
#[derive(Debug, Clone)]
pub struct Elf {
    /// Program entry point virtual address
    pub entry: usize,
    /// All PT_LOAD segments
    pub segments: alloc::vec::Vec<ElfSegment>,
}

/// Read a little-endian u16 from bytes at `offset`.
fn read_u16(data: &[u8], offset: usize) -> u16 {
    u16::from_le_bytes([data[offset], data[offset + 1]])
}

/// Read a little-endian u32 from bytes at `offset`.
fn read_u32(data: &[u8], offset: usize) -> u32 {
    u32::from_le_bytes([
        data[offset],
        data[offset + 1],
        data[offset + 2],
        data[offset + 3],
    ])
}

/// Read a little-endian u64 from bytes at `offset`.
fn read_u64(data: &[u8], offset: usize) -> u64 {
    u64::from_le_bytes([
        data[offset],
        data[offset + 1],
        data[offset + 2],
        data[offset + 3],
        data[offset + 4],
        data[offset + 5],
        data[offset + 6],
        data[offset + 7],
    ])
}

impl Elf {
    /// Parse an ELF64 executable from raw bytes.
    ///
    /// Returns `Err` if the data is not a valid RISC-V ELF64 executable.
    pub fn parse(data: &[u8]) -> Result<Self, &'static str> {
        // --- Validate ELF header (must be at least 64 bytes) ---
        if data.len() < 64 {
            return Err("ELF: file too small for header");
        }

        // Magic
        if data[EI_MAG0..=EI_MAG3] != ELF_MAGIC {
            return Err("ELF: bad magic");
        }
        // 64-bit
        if data[EI_CLASS] != ELFCLASS64 {
            return Err("ELF: not 64-bit");
        }
        // Little-endian
        if data[EI_DATA] != ELFDATA2LSB {
            return Err("ELF: not little-endian");
        }

        let e_type = read_u16(data, 16);
        if e_type != ET_EXEC {
            return Err("ELF: not executable");
        }

        let e_machine = read_u16(data, 18);
        if e_machine != EM_RISCV {
            return Err("ELF: not RISC-V");
        }

        let entry = read_u64(data, 24) as usize;
        let phoff = read_u64(data, 32) as usize;
        let phentsize = read_u16(data, 54) as usize;
        let phnum = read_u16(data, 56) as usize;

        println!(
            "[ELF] entry={:#x} phoff={} phentsize={} phnum={}",
            entry, phoff, phentsize, phnum
        );

        if phentsize < 56 {
            return Err("ELF: program header entry too small");
        }
        let ph_table_size = phentsize
            .checked_mul(phnum)
            .ok_or("ELF: program header table overflow")?;
        let ph_table_end = phoff
            .checked_add(ph_table_size)
            .ok_or("ELF: program header table overflow")?;
        if ph_table_end > data.len() {
            return Err("ELF: program header table out of bounds");
        }

        // --- Parse program headers ---
        let mut segments = alloc::vec::Vec::new();

        for i in 0..phnum {
            let offset = phoff
                .checked_add(
                    i.checked_mul(phentsize)
                        .ok_or("ELF: program header offset overflow")?,
                )
                .ok_or("ELF: program header offset overflow")?;
            let header_end = offset
                .checked_add(56)
                .ok_or("ELF: program header offset overflow")?;
            if header_end > data.len() {
                return Err("ELF: program header out of bounds");
            }

            let p_type = read_u32(data, offset);
            let p_flags = read_u32(data, offset + 4);
            let p_offset = read_u64(data, offset + 8) as usize;
            let p_vaddr = read_u64(data, offset + 16) as usize;
            let p_filesz = read_u64(data, offset + 32) as usize;
            let p_memsz = read_u64(data, offset + 40) as usize;

            if p_type == PT_LOAD {
                println!(
                    "[ELF] LOAD seg: vaddr={:#x} offset={:#x} filesz={} memsz={} flags={}",
                    p_vaddr, p_offset, p_filesz, p_memsz, p_flags
                );

                if p_filesz > p_memsz {
                    return Err("ELF: segment file size exceeds memory size");
                }
                let file_end = p_offset
                    .checked_add(p_filesz)
                    .ok_or("ELF: segment file range overflow")?;
                if file_end > data.len() {
                    return Err("ELF: segment data out of bounds");
                }
                p_vaddr
                    .checked_add(p_memsz)
                    .ok_or("ELF: segment memory range overflow")?;

                segments.push(ElfSegment {
                    offset: p_offset,
                    vaddr: p_vaddr,
                    filesz: p_filesz,
                    memsz: p_memsz,
                    flags: p_flags,
                });
            }
        }

        if segments.is_empty() {
            return Err("ELF: no LOAD segments");
        }
        let entry_is_loadable = segments.iter().any(|seg| {
            seg.vaddr <= entry && entry < seg.vaddr.checked_add(seg.memsz).unwrap_or(seg.vaddr)
        });
        if !entry_is_loadable {
            return Err("ELF: entry outside LOAD segments");
        }

        Ok(Elf { entry, segments })
    }

    /// Get a reference to the segment data within the raw ELF bytes.
    pub fn segment_data<'a>(&self, seg: &ElfSegment, raw: &'a [u8]) -> &'a [u8] {
        &raw[seg.offset..seg.offset + seg.filesz]
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::process::user_elf::build_user_elf;

    #[test_case]
    fn elf_parser_accepts_embedded_user_elf_contract() {
        let (elf, entry) = build_user_elf();
        let parsed = Elf::parse(&elf).expect("embedded user ELF should parse");
        assert_eq!(parsed.entry, entry);
        assert_eq!(parsed.segments.len(), 1);
    }

    #[test_case]
    fn elf_parser_rejects_non_executable_type() {
        let (mut elf, _) = build_user_elf();
        elf[16..18].copy_from_slice(&3u16.to_le_bytes()); // ET_DYN
        assert!(matches!(Elf::parse(&elf), Err("ELF: not executable")));
    }

    #[test_case]
    fn elf_parser_rejects_entry_outside_load_segments() {
        let (mut elf, _) = build_user_elf();
        elf[24..32].copy_from_slice(&0x9000_0000u64.to_le_bytes());
        assert!(matches!(
            Elf::parse(&elf),
            Err("ELF: entry outside LOAD segments")
        ));
    }
}