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 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 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_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.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}