Skip to main content

jit/
setup.rs

1use super::*;
2
3impl<L> JitRuntime<L>
4where
5    L: Fn(&GuestMemory, u64) -> JitResult<Nnil>,
6{
7    pub fn init_runtime(
8        program: ProgramImage,
9        mut process: RemuConfig,
10        jit_output_dir: PathBuf,
11        lift_region: L,
12    ) -> JitResult<Self> {
13        if process.jit_opt_level > 2 {
14            return Err(io::Error::other("JIT optimization level ist entweder 0, 1 oder 2").into());
15        }
16
17        if process.raw_jit && !cfg!(all(target_os = "linux", target_arch = "x86_64")) {
18            return Err(io::Error::other("--raw-jit läuft nur auf Linux x86-64!!").into());
19        }
20
21        if let Some(cache_dir) = &process.jit_cache_dir {
22            fs::create_dir_all(cache_dir)?;
23        }
24
25        let mut memory = Box::new(GuestMemory::from_program(&program)?);
26
27        if let Some(sysroot) = &process.sysroot {
28            process.sysroot = Some(
29                fs::canonicalize(sysroot)
30                    .map_err(|err| io::Error::other(format!("cannot open sysroot in {}: {err}", sysroot.display())))?,
31            );
32        }
33
34        let workdir = process.workdir.clone().unwrap_or(std::env::current_dir()?);
35        let workdir = fs::canonicalize(&workdir)
36            .map_err(|err| io::Error::other(format!("cannot open workdir in {}: {err}", workdir.display())))?;
37
38        if !workdir.is_dir() {
39            return Err(io::Error::other("workdir is not a directory").into());
40        }
41
42        process.workdir = Some(workdir);
43
44        let mut loader_base = 0;
45        let mut initial_pc = program.entry_pc;
46
47        if let Some(interp) = &program.interp {
48            let sysroot = process.sysroot.as_ref().ok_or_else(|| {
49                io::Error::other(format!("WICHTIG - dynamic ELF requires --sysroot containing {interp}"))
50            })?;
51
52            let mut loader_bytes = Vec::new();
53
54            // todo -
55            use std::io::Read;
56
57            open_beneath(&fs::File::open(sysroot)?, Path::new(interp), 0, 0)?
58                .take(crate::MAX_GUEST_MEMORY + 1)
59                .read_to_end(&mut loader_bytes)?;
60
61            let loader = ProgramImage::from_elf_bytes(&loader_bytes)?;
62
63            // if loader.elf_type != 3 {
64            //     return Err(io::Error::other("ist nich ET_DYN").into());
65            // }
66
67            loader_base = DYNAMIC_LOADER_BIAS;
68
69            for segment in &loader.segments {
70                if segment.mem_size == 0 {
71                    continue;
72                }
73
74                let base = loader_base
75                    .checked_add(segment.vaddr)
76                    .ok_or_else(|| io::Error::other("interpreter address overflow"))?;
77
78                let start = align_down(base, PAGE_SIZE as u64);
79
80                let end = align_up(
81                    base.checked_add(segment.mem_size)
82                        .ok_or_else(|| io::Error::other("interpreter address overflow"))?,
83                    PAGE_SIZE as u64,
84                )
85                .ok_or_else(|| io::Error::other("interpreter address overflow"))?;
86
87                if !memory.range_is_free(start, end - start) {
88                    return Err(io::Error::other("??").into());
89                }
90            }
91
92            memory.map_program_at(&loader, loader_base)?;
93
94            initial_pc =
95                loader_base.checked_add(loader.entry_pc).ok_or_else(|| io::Error::other("interpreter entry error"))?;
96        }
97
98        let mut state = GuestState::default();
99        let pause = Arc::new(AtomicBool::new(false));
100
101        state.memory = memory.as_abi_mut();
102        state.regs[2] = memory.stack_top - DEFAULT_STACK_POINTER_OFFSET;
103
104        let host_process = Process::new(
105            process.sysroot.clone(),
106            process.workdir.clone().unwrap(),
107            process.argv.first().cloned().unwrap_or_default(),
108            None,
109        )?;
110
111        let mut runtime = Self {
112            program,
113            process,
114            memory,
115            cache: BTreeMap::new(),
116            jit_entries: Vec::new(),
117            initial_pc,
118            loader_base,
119            state,
120            host_process,
121            mmap_base: MMAP_BASE,
122            jit_output_dir,
123            verbose: false,
124
125            compile_count: 0,
126            compile_time: Duration::ZERO,
127            execute_time: Duration::ZERO,
128
129            breakpoints: Vec::new(),
130            control: Box::new(GuestControl {
131                pause: Arc::as_ptr(&pause),
132                breakpoints: std::ptr::NonNull::<u64>::dangling().as_ptr(),
133                breakpoint_count: 0,
134                skip_breakpoint: u64::MAX,
135                blocks_left: 0,
136                limited: 0,
137                trace: [0; DEBUG_SLOTS],
138                trace_pos: 0,
139            }),
140            pause,
141            initial_snapshot: None,
142            last_syscall: None,
143            lift_region,
144        };
145
146        //runtime.initialize_shim_data()?;
147        //runtime.install_shims()?;
148
149        runtime.initialize_process_state()?;
150
151        runtime.state.pc = runtime.initial_pc;
152        runtime.state.memory = runtime.memory.as_abi_mut();
153        runtime.initial_snapshot = Some(runtime.snapshot()?);
154
155        Ok(runtime)
156    }
157
158    pub fn snapshot(&mut self) -> JitResult<RuntimeSnapshot> {
159        let host_process = self.host_process.snapshot()?;
160        let mut state = self.state.clone();
161
162        state.memory = std::ptr::null_mut();
163        state.control = std::ptr::null_mut();
164        state.jit_entries = std::ptr::null();
165        state.jit_entry_count = 0;
166
167        let memory = self.memory.snapshot();
168
169        Ok(RuntimeSnapshot { memory, state, host_process, mmap_base: self.mmap_base })
170    }
171
172    pub fn restore(&mut self, snapshot: &RuntimeSnapshot) -> JitResult<()> {
173        self.host_process.restore(&snapshot.host_process)?;
174
175        if !self.memory.restore_dirty_from(&snapshot.memory) {
176            let code_changed = self.memory.take_code_dirty()
177                || !self
178                    .memory
179                    .mapped_pages()
180                    .filter(|(_, perms, _)| perms.contains(PagePerms::EXEC))
181                    .eq(snapshot.memory.mapped_pages().filter(|(_, perms, _)| perms.contains(PagePerms::EXEC)));
182
183            *self.memory = snapshot.memory.clone();
184
185            self.memory.take_code_dirty();
186
187            if code_changed {
188                self.invalidate_cache();
189            }
190        }
191
192        self.state = snapshot.state.clone();
193        self.state.memory = self.memory.as_abi_mut();
194
195        self.state.control = std::ptr::null_mut();
196        self.sync_jit_entries();
197
198        // self.sync_jit_entries();
199
200        self.mmap_base = snapshot.mmap_base;
201        self.last_syscall = None;
202        Ok(())
203    }
204
205    pub fn reset(&mut self) -> JitResult<()> {
206        let snapshot = self.initial_snapshot.take().ok_or_else(|| io::Error::other(" snapshot missing"))?;
207
208        let result = self.restore(&snapshot);
209
210        self.initial_snapshot = Some(snapshot);
211        result
212    }
213
214    pub(super) fn initialize_process_state(&mut self) -> JitResult<()> {
215        self.state.regs[2] = self.memory.stack_top - DEFAULT_STACK_POINTER_OFFSET;
216
217        self.state.regs[3] = self.program.find_symbol("__global_pointer$").map(|symbol| symbol.value).unwrap_or(0);
218
219        self.state.regs[4] = 0;
220
221        self.build_elf_entry_state()?;
222        self.state.pc = self.initial_pc;
223        Ok(())
224    }
225
226    pub(super) fn build_elf_entry_state(&mut self) -> JitResult<()> {
227        let mut sp = self.memory.stack_top - DEFAULT_STACK_POINTER_OFFSET;
228
229        let argv_values = self.process.argv.clone();
230        let envp_values = self.process.envp.clone();
231
232        let argv = self.push_guest_strings(&mut sp, &argv_values)?;
233        let envp = self.push_guest_strings(&mut sp, &envp_values)?;
234
235        let random_addr = self.push_guest_stack_bytes(&mut sp, &ELF_AUX_RANDOM, 16)?;
236
237        let argc = argv.len() as u64;
238        let execfn_ptr = argv.first().copied().unwrap_or(0);
239
240        let auxv = self.build_elf_auxv(random_addr, execfn_ptr)?;
241
242        let table_size = 8 + ((argv.len() + 1) as u64 * 8) + ((envp.len() + 1) as u64 * 8) + (auxv.len() as u64 * 16);
243
244        let table_addr = self.reserve_guest_stack(&mut sp, table_size, 16)?;
245
246        self.write_elf_entry_table(table_addr, argc, &argv, &envp, &auxv)?;
247
248        self.state.regs[1] = 0;
249        self.state.regs[2] = table_addr;
250        self.state.regs[10] = 0;
251        self.state.regs[11] = 0;
252        self.state.regs[12] = 0;
253
254        Ok(())
255    }
256
257    pub(super) fn build_elf_auxv(&self, random_addr: u64, execfn_ptr: u64) -> JitResult<Vec<AuxEntry>> {
258        let phdr_addr =
259            self.program.elf_phdr_addr.ok_or_else(|| io::Error::other("missing ELF program header address"))?;
260
261        Ok(vec![
262            (AT_PHDR, phdr_addr),
263            (AT_PHENT, self.program.elf_phent_size as u64),
264            (AT_PHNUM, self.program.elf_phnum as u64),
265            (AT_PAGESZ, PAGE_SIZE as u64),
266            (AT_BASE, self.loader_base),
267            (AT_FLAGS, 0),
268            (AT_ENTRY, self.program.entry_pc),
269            (AT_UID, 1000),
270            (AT_EUID, 1000),
271            (AT_GID, 1000),
272            (AT_EGID, 1000),
273            (AT_HWCAP, RISCV_HWCAP),
274            (AT_CLKTCK, 100),
275            (AT_SECURE, 0),
276            (AT_RANDOM, random_addr),
277            (AT_HWCAP2, 0),
278            (AT_EXECFN, execfn_ptr),
279            (AT_NULL, 0),
280        ])
281    }
282
283    pub(super) fn write_elf_entry_table(
284        &mut self,
285        table_addr: u64,
286        argc: u64,
287        argv: &[u64],
288        envp: &[u64],
289        auxv: &[AuxEntry],
290    ) -> JitResult<()> {
291        let words = std::iter::once(argc)
292            .chain(argv.iter().copied())
293            .chain([0])
294            .chain(envp.iter().copied())
295            .chain([0])
296            .chain(auxv.iter().flat_map(|&(kind, value)| [kind, value]));
297
298        for (index, value) in words.enumerate() {
299            if !self.memory.store_le(table_addr + index as u64 * 8, 8, value) {
300                return Err(io::Error::other("failed to write ELF entry table").into());
301            }
302        }
303
304        Ok(())
305    }
306
307    pub(super) fn push_guest_strings(&mut self, sp: &mut u64, values: &[String]) -> JitResult<Vec<u64>> {
308        let mut addresses = Vec::with_capacity(values.len());
309
310        for value in values.iter().rev() {
311            let mut bytes = value.as_bytes().to_vec();
312            bytes.push(0);
313
314            let addr = self.push_guest_stack_bytes(sp, &bytes, 1)?;
315            addresses.push(addr);
316        }
317
318        addresses.reverse();
319        Ok(addresses)
320    }
321
322    pub(super) fn push_guest_stack_bytes(&mut self, sp: &mut u64, bytes: &[u8], align: u64) -> JitResult<u64> {
323        let addr = self.reserve_guest_stack(sp, bytes.len() as u64, align)?;
324
325        if !self.memory.store_bytes(addr, bytes) {
326            return Err(io::Error::other("failed to write guest stack bytes").into());
327        }
328
329        Ok(addr)
330    }
331
332    pub(super) fn reserve_guest_stack(&mut self, sp: &mut u64, size: u64, align: u64) -> JitResult<u64> {
333        let next = sp.checked_sub(size).ok_or_else(|| io::Error::other("guest stack underflow"))?;
334
335        let aligned = align_down(next, align.max(1));
336
337        if aligned < DEFAULT_STACK_TOP - DEFAULT_STACK_SIZE {
338            return Err(io::Error::other("overflow!").into());
339        }
340
341        *sp = aligned;
342        Ok(aligned)
343    }
344}
345
346impl Default for GuestState {
347    fn default() -> Self {
348        Self {
349            exit_reason: ExitReason::None,
350            pc: 0,
351            regs: [0; GUEST_REG_COUNT],
352            tmps: [0; GUEST_TMP_COUNT],
353            memory: core::ptr::null_mut(),
354            fault_addr: 0,
355            fault_access: AccessKind::None,
356            control: core::ptr::null_mut(),
357            jit_entries: core::ptr::null(),
358            jit_entry_count: 0,
359        }
360    }
361}