Skip to main content

jit/
image.rs

1use crate::mmu::align_up;
2use crate::{JitResult, PAGE_SIZE, PagePerms};
3
4use goblin::elf::{
5    Elf,
6    header::EM_RISCV,
7    program_header::{PF_R, PF_W, PF_X, PT_LOAD, PT_PHDR},
8};
9
10use std::{collections::BTreeMap, io};
11
12#[derive(Debug, Clone)]
13pub struct LoadSegment {
14    pub vaddr: u64,
15    pub mem_size: u64,
16    pub file_size: u64,
17    pub perms: PagePerms,
18    pub bytes: Vec<u8>,
19}
20
21#[derive(Debug, Clone)]
22pub struct ProgramSymbol {
23    pub name: String,
24    pub value: u64,
25}
26
27#[derive(Debug, Clone)]
28pub struct ProgramImage {
29    pub entry_pc: u64,
30    pub segments: Vec<LoadSegment>,
31    pub symbols: BTreeMap<String, ProgramSymbol>,
32    pub interp: Option<String>,
33    pub brk_base: u64,
34    pub elf_phdr_addr: Option<u64>,
35    pub elf_phent_size: u16,
36    pub elf_phnum: u16,
37}
38
39impl ProgramImage {
40    pub fn from_elf_bytes(bytes: &[u8]) -> JitResult<Self> {
41        if bytes.len() as u64 > crate::MAX_GUEST_MEMORY {
42            return Err(io::Error::other("ELF exceeds guest memory limit!!").into());
43        }
44
45        let elf = Elf::parse(bytes)?;
46
47        if !elf.is_64 || !elf.little_endian || elf.header.e_machine != EM_RISCV {
48            return Err(io::Error::other("expected a little-endian RISC-V ELF64 file").into());
49        }
50
51        let mut load_size = 0u64;
52        let mut segments = Vec::new();
53        let mut headers_in_load = None;
54        let mut brk_base = 0;
55
56        for ph in elf.program_headers.iter().filter(|ph| ph.p_type == PT_LOAD) {
57            load_size = load_size
58                .checked_add(ph.p_memsz)
59                .filter(|size| *size <= crate::MAX_GUEST_MEMORY)
60                .ok_or_else(|| io::Error::other("ELF exceeds guest memory limit"))?;
61
62            let file_end =
63                ph.p_offset.checked_add(ph.p_filesz).ok_or_else(|| io::Error::other("ELF file range overflow"))?;
64
65            let memory_end =
66                ph.p_vaddr.checked_add(ph.p_memsz).ok_or_else(|| io::Error::other("ELF memory range overflow"))?;
67
68            if ph.p_filesz > ph.p_memsz || memory_end > u64::MAX - (PAGE_SIZE as u64 - 1) {
69                return Err(io::Error::other("invalid ELF load segment").into());
70            }
71
72            let data = bytes
73                .get(usize::try_from(ph.p_offset)?..usize::try_from(file_end)?)
74                .ok_or_else(|| io::Error::other("truncated ELF segment"))?;
75
76            let mut perms = PagePerms::empty();
77
78            for (flag, perm) in [(PF_R, PagePerms::READ), (PF_W, PagePerms::WRITE), (PF_X, PagePerms::EXEC)] {
79                if ph.p_flags & flag != 0 {
80                    perms |= perm;
81                }
82            }
83
84            // static binarys can omit PT_PHDR but still map  ELF headers
85            if headers_in_load.is_none() && (ph.p_offset..file_end).contains(&elf.header.e_phoff) {
86                headers_in_load = ph.p_vaddr.checked_add(elf.header.e_phoff - ph.p_offset);
87            }
88
89            brk_base = brk_base
90                .max(align_up(memory_end, PAGE_SIZE as u64).ok_or_else(|| io::Error::other("ELF address overflow"))?);
91
92            segments.push(LoadSegment {
93                vaddr: ph.p_vaddr,
94                mem_size: ph.p_memsz,
95                file_size: ph.p_filesz,
96                perms,
97                bytes: data.to_vec(),
98            });
99        }
100
101        let elf_phdr_addr = elf
102            .program_headers
103            .iter()
104            .find(|ph| ph.p_type == PT_PHDR)
105            .map(|ph| ph.p_vaddr)
106            .or(headers_in_load)
107            .ok_or_else(|| io::Error::other("ELF program headers are not mapped"))?;
108
109        let mut symbols = BTreeMap::<String, ProgramSymbol>::new();
110
111        for (table, strings) in [(&elf.syms, &elf.strtab), (&elf.dynsyms, &elf.dynstrtab)] {
112            for symbol in table.iter().filter(|symbol| symbol.st_shndx != 0) {
113                let Some(name) = strings.get_at(symbol.st_name).filter(|name| !name.is_empty()) else {
114                    continue;
115                };
116
117                let entry = symbols
118                    .entry(name.to_owned())
119                    .or_insert_with(|| ProgramSymbol { name: name.to_owned(), value: symbol.st_value });
120
121                if entry.value == 0 {
122                    entry.value = symbol.st_value;
123                }
124            }
125        }
126
127        Ok(Self {
128            entry_pc: elf.entry,
129            segments,
130            symbols,
131            interp: elf.interpreter.map(str::to_owned),
132            brk_base,
133            elf_phdr_addr: Some(elf_phdr_addr),
134            elf_phent_size: elf.header.e_phentsize,
135            elf_phnum: elf.header.e_phnum,
136        })
137    }
138
139    pub fn find_symbol(&self, name: &str) -> Option<&ProgramSymbol> {
140        self.symbols.get(name)
141    }
142
143    pub fn symbol_at(&self, address: u64) -> Option<&ProgramSymbol> {
144        if !self
145            .segments
146            .iter()
147            .any(|segment| address >= segment.vaddr && address < segment.vaddr.saturating_add(segment.mem_size))
148        {
149            return None;
150        }
151
152        self.symbols.values().filter(|symbol| symbol.value <= address).max_by_key(|symbol| symbol.value)
153    }
154}