Skip to main content

os/process/
elf.rs

1//! ELF64 parser for user program loading.
2//!
3//! Parses ELF64 Executable and Linkable Format files, extracting LOAD
4//! segments and the program entry point for the user-mode loader.
5
6use crate::println;
7
8/// ELF identification index constants
9const EI_MAG0: usize = 0;
10const EI_MAG3: usize = 3;
11const EI_CLASS: usize = 4;
12const EI_DATA: usize = 5;
13
14/// ELF magic bytes
15const ELF_MAGIC: [u8; 4] = [0x7f, b'E', b'L', b'F'];
16const ELFCLASS64: u8 = 2;
17const ELFDATA2LSB: u8 = 1;
18
19/// ELF file type
20const ET_EXEC: u16 = 2; // Executable file
21
22/// RISC-V machine ID
23const EM_RISCV: u16 = 243;
24
25/// Program header type: loadable segment
26const PT_LOAD: u32 = 1;
27
28/// A parsed LOAD segment from an ELF64 file.
29#[derive(Debug, Clone)]
30pub struct ElfSegment {
31    /// File offset of the segment data
32    pub offset: usize,
33    /// Virtual address where this segment should be loaded
34    pub vaddr: usize,
35    /// Size of the segment in the file
36    pub filesz: usize,
37    /// Size of the segment in memory (may be larger than filesz for .bss)
38    pub memsz: usize,
39    /// Segment flags (PF_R=4, PF_W=2, PF_X=1)
40    pub flags: u32,
41}
42
43/// A parsed ELF64 executable.
44#[derive(Debug, Clone)]
45pub struct Elf {
46    /// Program entry point virtual address
47    pub entry: usize,
48    /// All PT_LOAD segments
49    pub segments: alloc::vec::Vec<ElfSegment>,
50}
51
52/// Read a little-endian u16 from bytes at `offset`.
53fn read_u16(data: &[u8], offset: usize) -> u16 {
54    u16::from_le_bytes([data[offset], data[offset + 1]])
55}
56
57/// Read a little-endian u32 from bytes at `offset`.
58fn read_u32(data: &[u8], offset: usize) -> u32 {
59    u32::from_le_bytes([
60        data[offset],
61        data[offset + 1],
62        data[offset + 2],
63        data[offset + 3],
64    ])
65}
66
67/// Read a little-endian u64 from bytes at `offset`.
68fn read_u64(data: &[u8], offset: usize) -> u64 {
69    u64::from_le_bytes([
70        data[offset],
71        data[offset + 1],
72        data[offset + 2],
73        data[offset + 3],
74        data[offset + 4],
75        data[offset + 5],
76        data[offset + 6],
77        data[offset + 7],
78    ])
79}
80
81impl Elf {
82    /// Parse an ELF64 executable from raw bytes.
83    ///
84    /// Returns `Err` if the data is not a valid RISC-V ELF64 executable.
85    pub fn parse(data: &[u8]) -> Result<Self, &'static str> {
86        // --- Validate ELF header (must be at least 64 bytes) ---
87        if data.len() < 64 {
88            return Err("ELF: file too small for header");
89        }
90
91        // Magic
92        if data[EI_MAG0..=EI_MAG3] != ELF_MAGIC {
93            return Err("ELF: bad magic");
94        }
95        // 64-bit
96        if data[EI_CLASS] != ELFCLASS64 {
97            return Err("ELF: not 64-bit");
98        }
99        // Little-endian
100        if data[EI_DATA] != ELFDATA2LSB {
101            return Err("ELF: not little-endian");
102        }
103
104        let e_type = read_u16(data, 16);
105        if e_type != ET_EXEC {
106            return Err("ELF: not executable");
107        }
108
109        let e_machine = read_u16(data, 18);
110        if e_machine != EM_RISCV {
111            return Err("ELF: not RISC-V");
112        }
113
114        let entry = read_u64(data, 24) as usize;
115        let phoff = read_u64(data, 32) as usize;
116        let phentsize = read_u16(data, 54) as usize;
117        let phnum = read_u16(data, 56) as usize;
118
119        println!(
120            "[ELF] entry={:#x} phoff={} phentsize={} phnum={}",
121            entry, phoff, phentsize, phnum
122        );
123
124        if phentsize < 56 {
125            return Err("ELF: program header entry too small");
126        }
127        let ph_table_size = phentsize
128            .checked_mul(phnum)
129            .ok_or("ELF: program header table overflow")?;
130        let ph_table_end = phoff
131            .checked_add(ph_table_size)
132            .ok_or("ELF: program header table overflow")?;
133        if ph_table_end > data.len() {
134            return Err("ELF: program header table out of bounds");
135        }
136
137        // --- Parse program headers ---
138        let mut segments = alloc::vec::Vec::new();
139
140        for i in 0..phnum {
141            let offset = phoff
142                .checked_add(
143                    i.checked_mul(phentsize)
144                        .ok_or("ELF: program header offset overflow")?,
145                )
146                .ok_or("ELF: program header offset overflow")?;
147            let header_end = offset
148                .checked_add(56)
149                .ok_or("ELF: program header offset overflow")?;
150            if header_end > data.len() {
151                return Err("ELF: program header out of bounds");
152            }
153
154            let p_type = read_u32(data, offset);
155            let p_flags = read_u32(data, offset + 4);
156            let p_offset = read_u64(data, offset + 8) as usize;
157            let p_vaddr = read_u64(data, offset + 16) as usize;
158            let p_filesz = read_u64(data, offset + 32) as usize;
159            let p_memsz = read_u64(data, offset + 40) as usize;
160
161            if p_type == PT_LOAD {
162                println!(
163                    "[ELF] LOAD seg: vaddr={:#x} offset={:#x} filesz={} memsz={} flags={}",
164                    p_vaddr, p_offset, p_filesz, p_memsz, p_flags
165                );
166
167                if p_filesz > p_memsz {
168                    return Err("ELF: segment file size exceeds memory size");
169                }
170                let file_end = p_offset
171                    .checked_add(p_filesz)
172                    .ok_or("ELF: segment file range overflow")?;
173                if file_end > data.len() {
174                    return Err("ELF: segment data out of bounds");
175                }
176                p_vaddr
177                    .checked_add(p_memsz)
178                    .ok_or("ELF: segment memory range overflow")?;
179
180                segments.push(ElfSegment {
181                    offset: p_offset,
182                    vaddr: p_vaddr,
183                    filesz: p_filesz,
184                    memsz: p_memsz,
185                    flags: p_flags,
186                });
187            }
188        }
189
190        if segments.is_empty() {
191            return Err("ELF: no LOAD segments");
192        }
193        let entry_is_loadable = segments.iter().any(|seg| {
194            seg.vaddr <= entry && entry < seg.vaddr.checked_add(seg.memsz).unwrap_or(seg.vaddr)
195        });
196        if !entry_is_loadable {
197            return Err("ELF: entry outside LOAD segments");
198        }
199
200        Ok(Elf { entry, segments })
201    }
202
203    /// Get a reference to the segment data within the raw ELF bytes.
204    pub fn segment_data<'a>(&self, seg: &ElfSegment, raw: &'a [u8]) -> &'a [u8] {
205        &raw[seg.offset..seg.offset + seg.filesz]
206    }
207}
208
209#[cfg(test)]
210mod tests {
211    use super::*;
212    use crate::process::user_elf::build_user_elf;
213
214    #[test_case]
215    fn elf_parser_accepts_embedded_user_elf_contract() {
216        let (elf, entry) = build_user_elf();
217        let parsed = Elf::parse(&elf).expect("embedded user ELF should parse");
218        assert_eq!(parsed.entry, entry);
219        assert_eq!(parsed.segments.len(), 1);
220    }
221
222    #[test_case]
223    fn elf_parser_rejects_non_executable_type() {
224        let (mut elf, _) = build_user_elf();
225        elf[16..18].copy_from_slice(&3u16.to_le_bytes()); // ET_DYN
226        assert!(matches!(Elf::parse(&elf), Err("ELF: not executable")));
227    }
228
229    #[test_case]
230    fn elf_parser_rejects_entry_outside_load_segments() {
231        let (mut elf, _) = build_user_elf();
232        elf[24..32].copy_from_slice(&0x9000_0000u64.to_le_bytes());
233        assert!(matches!(
234            Elf::parse(&elf),
235            Err("ELF: entry outside LOAD segments")
236        ));
237    }
238}