Skip to main content

jit/
process.rs

1use crate::DEFAULT_STACK_SIZE;
2use crate::{GuestMemory, PAGE_SIZE};
3
4use std::{
5    collections::BTreeMap,
6    ffi::CString,
7    fs::{self, File},
8    io::{self, IsTerminal as _, Read as _, Seek as _, SeekFrom, Write as _}, // todo -
9    os::unix::fs::{FileExt as _, MetadataExt as _},
10    os::{
11        fd::{AsRawFd, FromRawFd},
12        unix::ffi::OsStrExt,
13    },
14    path::{Path, PathBuf},
15};
16
17const O_ACCMODE: u64 = 3;
18const O_RDWR: u64 = 2;
19const O_CREAT: u64 = 0x40;
20const O_TRUNC: u64 = 0x200;
21const O_APPEND: u64 = 0x400;
22const O_CLOEXEC: u64 = 0x80000;
23
24const F_GETFD: u64 = 1;
25const F_SETFD: u64 = 2;
26
27const FD_CLOEXEC: u64 = 1;
28
29pub trait SyscallMemory {
30    fn load_bytes(&mut self, address: u64, size: usize) -> Option<Vec<u8>>;
31    fn store_bytes(&mut self, address: u64, bytes: &[u8]) -> bool;
32    fn can_write(&mut self, address: u64, size: usize) -> bool;
33    fn read_string(&mut self, address: u64, max: usize) -> Result<String, i32>;
34}
35
36impl SyscallMemory for GuestMemory {
37    fn can_write(&mut self, address: u64, size: usize) -> bool {
38        self.check_range(address, size, crate::PagePerms::WRITE)
39    }
40
41    fn load_bytes(&mut self, address: u64, size: usize) -> Option<Vec<u8>> {
42        GuestMemory::load_bytes(self, address, size)
43    }
44
45    fn store_bytes(&mut self, address: u64, bytes: &[u8]) -> bool {
46        GuestMemory::store_bytes(self, address, bytes)
47    }
48
49    fn read_string(&mut self, addr: u64, max: usize) -> Result<String, i32> {
50        let mut bytes = Vec::new();
51        let mut current = addr;
52
53        while bytes.len() < max {
54            let page_left = PAGE_SIZE - (current as usize & (PAGE_SIZE - 1));
55
56            let count = page_left.min(max - bytes.len());
57            let chunk = self.load_bytes(current, count).ok_or(14)?;
58
59            if let Some(end) = chunk.iter().position(|byte| *byte == 0) {
60                bytes.extend_from_slice(&chunk[..end]);
61                return String::from_utf8(bytes).map_err(|_| 22);
62            }
63
64            bytes.extend_from_slice(&chunk);
65            current = current.checked_add(count as u64).ok_or(14)?;
66        }
67
68        Err(22)
69    }
70}
71
72pub struct GuestFile {
73    pub file: File,
74    fd_flags: u64,
75}
76
77struct SnapshotFile {
78    file: File,
79    offset: u64,
80    fd_flags: u64,
81}
82
83pub struct ProcessSnapshot {
84    files: BTreeMap<i32, SnapshotFile>,
85    next_fd: i32,
86}
87
88pub struct Process {
89    pub files: BTreeMap<i32, GuestFile>,
90    next_fd: i32,
91    sysroot: Option<File>,
92    workdir: File,
93    executable: String,
94    lane: Option<usize>,
95}
96
97impl Process {
98    pub fn new(
99        sysroot: Option<PathBuf>,
100        workdir: PathBuf,
101        executable: String,
102        lane: Option<usize>,
103    ) -> io::Result<Self> {
104        Self::with_directory(sysroot, File::open(workdir)?, executable, lane)
105    }
106
107    pub fn with_directory(
108        sysroot: Option<PathBuf>,
109        workdir: File,
110        executable: String,
111        lane: Option<usize>,
112    ) -> io::Result<Self> {
113        Ok(Self {
114            files: BTreeMap::new(),
115            next_fd: 3,
116            sysroot: sysroot.map(File::open).transpose()?,
117            workdir,
118            executable,
119            lane,
120        })
121    }
122
123    pub fn snapshot(&mut self) -> io::Result<ProcessSnapshot> {
124        let mut files = BTreeMap::new();
125
126        for (&fd, guest) in &mut self.files {
127            files.insert(
128                fd,
129                SnapshotFile {
130                    file: guest.file.try_clone()?,
131                    offset: guest.file.stream_position()?,
132                    fd_flags: guest.fd_flags,
133                },
134            );
135        }
136
137        Ok(ProcessSnapshot { files, next_fd: self.next_fd })
138    }
139
140    pub fn restore(&mut self, snapshot: &ProcessSnapshot) -> io::Result<()> {
141        let mut files = BTreeMap::new();
142
143        for (&fd, saved) in &snapshot.files {
144            // geklonte Unix descriptors teilen sich den cursor!
145            let mut file = saved.file.try_clone()?;
146
147            file.seek(SeekFrom::Start(saved.offset))?;
148
149            files.insert(fd, GuestFile { file, fd_flags: saved.fd_flags });
150        }
151
152        self.files = files;
153        self.next_fd = snapshot.next_fd;
154        Ok(())
155    }
156
157    pub fn dispatch(&mut self, nr: u64, args: [u64; 6], memory: &mut impl SyscallMemory) -> Option<Result<u64, i32>> {
158        let result = match nr {
159            17 => self.sys_getcwd(memory, &args),
160            25 => self.sys_fcntl(&args),
161            29 => Err(25),
162
163            35 => self.sys_unlinkat(memory, &args),
164            48 | 439 => self.sys_faccessat(memory, &args),
165
166            56 => self.sys_openat(memory, &args),
167            57 => self.sys_close(&args),
168            62 => self.sys_lseek(&args),
169            63 => self.sys_read(memory, &args),
170            64 => self.sys_write(memory, &args),
171            66 => self.sys_writev(memory, &args),
172            67 => self.sys_pread64(memory, &args),
173            78 => self.sys_readlinkat(memory, &args),
174            79 => self.sys_newfstatat(memory, &args),
175            80 => self.sys_fstat(memory, &args),
176
177            96 => Ok(1),
178            99 | 233 | 259 => Ok(0),
179            113 => self.sys_clock_gettime(memory, &args),
180            123 => self.sys_sched_getaffinity(memory, &args),
181            160 => self.sys_uname(memory, &args),
182            163 => self.sys_getrlimit(memory, &args),
183
184            172 | 178 => Ok(1),
185            174..=177 => Ok(1000),
186
187            258 => Err(38),
188            261 => self.sys_prlimit64(memory, &args),
189            278 => self.sys_getrandom(memory, &args),
190
191            293 => Err(38),
192            _ => return None,
193        };
194
195        Some(result)
196    }
197
198    fn sys_openat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
199        let dirfd = args[0] as i64;
200        let path = memory.read_string(args[1], 4096)?;
201        let flags = args[2];
202
203        if dirfd != -100 {
204            return Err(22);
205        }
206
207        let access = flags & O_ACCMODE;
208
209        if access > O_RDWR {
210            return Err(22);
211        }
212
213        let writable = access != 0 || flags & (O_CREAT | O_TRUNC | O_APPEND) != 0;
214
215        if path.starts_with('/') && writable {
216            return Err(30);
217        }
218
219        // die open flags sind gleich in RISC-V und x86-64
220        if self.files.len() >= 1024 {
221            return Err(24);
222        }
223
224        let mode = if flags & O_CREAT != 0 { args[3] & 0o7777 } else { 0 };
225
226        let file = self.open_path(&path, flags | O_CLOEXEC, mode)?;
227
228        let fd = self.next_fd;
229        self.next_fd += 1;
230
231        self.files.insert(fd, GuestFile { file, fd_flags: if flags & O_CLOEXEC != 0 { FD_CLOEXEC } else { 0 } });
232
233        Ok(fd as u64)
234    }
235
236    fn sys_unlinkat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
237        if args[0] as i64 != -100 || args[2] != 0 {
238            return Err(22);
239        }
240
241        let path = memory.read_string(args[1], 4096)?;
242
243        if path.starts_with('/') {
244            return Err(30);
245        }
246
247        let path = Path::new(&path);
248
249        let parent = path.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new("."));
250
251        let directory = open_beneath(&self.workdir, parent, libc::O_PATH as u64 | libc::O_DIRECTORY as u64, 0)
252            .map_err(host_errno)?;
253
254        let name = CString::new(path.file_name().ok_or(22)?.as_bytes()).map_err(|_| 22)?;
255
256        // todo -
257        if unsafe { libc::unlinkat(directory.as_raw_fd(), name.as_ptr(), 0) } != 0 {
258            return Err(host_errno(io::Error::last_os_error()));
259        }
260
261        Ok(0)
262    }
263
264    fn sys_fcntl(&mut self, args: &[u64; 6]) -> Result<u64, i32> {
265        let fd = args[0] as i32;
266        let command = args[1];
267        let argument = args[2];
268
269        let file = self.files.get_mut(&fd).ok_or(9)?;
270
271        match command {
272            F_GETFD => Ok(file.fd_flags),
273            F_SETFD => {
274                file.fd_flags = argument & FD_CLOEXEC;
275                Ok(0)
276            }
277            _ => Err(22),
278        }
279    }
280
281    fn sys_close(&mut self, args: &[u64; 6]) -> Result<u64, i32> {
282        let fd = args[0] as i32;
283
284        if (0..=2).contains(&fd) || self.files.remove(&fd).is_some() { Ok(0) } else { Err(9) }
285    }
286
287    fn sys_read(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
288        let fd = args[0] as i32;
289        let addr = args[1];
290
291        if fd != 0 && !self.files.contains_key(&fd) {
292            return Err(9);
293        }
294
295        let size = (args[2].min(crate::MAX_SYSCALL_BYTES as u64)) as usize;
296
297        if !memory.can_write(addr, size) {
298            return Err(14);
299        }
300
301        let mut bytes = vec![0; size];
302
303        let count = if fd == 0 {
304            io::stdin().read(&mut bytes).map_err(host_errno)?
305        } else {
306            let file = self.files.get_mut(&fd).ok_or(9)?;
307            file.file.read(&mut bytes).map_err(host_errno)?
308        };
309
310        if !memory.store_bytes(addr, &bytes[..count]) {
311            return Err(14);
312        }
313
314        Ok(count as u64)
315    }
316
317    fn sys_write(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
318        let fd = args[0] as i32;
319
320        let size = (args[2].min(crate::MAX_SYSCALL_BYTES as u64)) as usize;
321        let bytes = memory.load_bytes(args[1], size).ok_or(14)?;
322
323        let count = self.write_fd(fd, &bytes)?;
324        Ok(count as u64)
325    }
326
327    fn sys_writev(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
328        let fd = args[0] as i32;
329
330        let iov = args[1];
331        let count = usize::try_from(args[2]).map_err(|_| 22)?;
332
333        if count > 1024 {
334            return Err(22);
335        }
336
337        let mut bytes = Vec::new();
338
339        for index in 0..count {
340            let entry = memory.load_bytes(iov.checked_add((index * 16) as u64).ok_or(14)?, 16).ok_or(14)?;
341
342            let addr = u64::from_le_bytes(entry[..8].try_into().unwrap());
343            let size = u64::from_le_bytes(entry[8..].try_into().unwrap());
344
345            let size = size.min((crate::MAX_SYSCALL_BYTES - bytes.len()) as u64) as usize;
346
347            bytes.extend(memory.load_bytes(addr, size).ok_or(14)?);
348
349            if bytes.len() == crate::MAX_SYSCALL_BYTES {
350                break;
351            }
352        }
353
354        Ok(self.write_fd(fd, &bytes)? as u64)
355    }
356
357    fn sys_pread64(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
358        let fd = args[0] as i32;
359        let addr = args[1];
360
361        if fd != 0 && !self.files.contains_key(&fd) {
362            return Err(9);
363        }
364
365        let size = (args[2].min(crate::MAX_SYSCALL_BYTES as u64)) as usize;
366        let offset = args[3];
367
368        let file = self.files.get(&fd).ok_or(9)?;
369
370        if !memory.can_write(addr, size) {
371            return Err(14);
372        }
373
374        let mut bytes = vec![0; size];
375
376        let count = file.file.read_at(&mut bytes, offset).map_err(host_errno)?;
377
378        if !memory.store_bytes(addr, &bytes[..count]) {
379            return Err(14);
380        }
381
382        Ok(count as u64)
383    }
384
385    fn sys_lseek(&mut self, args: &[u64; 6]) -> Result<u64, i32> {
386        let fd = args[0] as i32;
387        let offset = args[1] as i64;
388        let whence = args[2];
389
390        let file = self.files.get_mut(&fd).ok_or(9)?;
391
392        let position = match whence {
393            0 if offset >= 0 => SeekFrom::Start(offset as u64),
394            0 => return Err(22),
395            1 => SeekFrom::Current(offset),
396            2 => SeekFrom::End(offset),
397            _ => return Err(22),
398        };
399
400        file.file.seek(position).map_err(host_errno)
401    }
402
403    fn sys_faccessat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
404        if args[0] as i64 != -100 {
405            return Err(22);
406        }
407
408        let path = memory.read_string(args[1], 4096)?;
409
410        self.open_path(&path, libc::O_PATH as u64, 0).map(|_| 0)
411    }
412
413    fn sys_fstat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
414        let fd = args[0] as i32;
415
416        let metadata = if (0..=2).contains(&fd) {
417            None
418        } else {
419            Some(self.files.get(&fd).ok_or(9)?.file.metadata().map_err(host_errno)?)
420        };
421
422        self.write_guest_stat(memory, args[1], metadata.as_ref())
423    }
424
425    fn sys_newfstatat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
426        if args[0] as i64 != -100 || args[3] & !0x100 != 0 {
427            return Err(22);
428        }
429
430        let path = memory.read_string(args[1], 4096)?;
431
432        let flags = libc::O_PATH | if args[3] & 0x100 != 0 { libc::O_NOFOLLOW } else { 0 };
433
434        let metadata = self.open_path(&path, flags as u64, 0)?.metadata().map_err(host_errno)?;
435
436        self.write_guest_stat(memory, args[2], Some(&metadata))
437    }
438
439    fn sys_readlinkat(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
440        // if path != "/proc/self/exe" {
441        //     return Err(2);
442        // }
443
444        let size = usize::try_from(args[3]).map_err(|_| 22)?;
445        let bytes = self.executable.as_bytes();
446
447        let count = size.min(bytes.len());
448
449        if !memory.store_bytes(args[2], &bytes[..count]) {
450            return Err(14);
451        }
452
453        Ok(count as u64)
454    }
455
456    fn sys_getcwd(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
457        let addr = args[0];
458
459        if args[1] < 2 || !memory.store_bytes(addr, b"/\0") {
460            return Err(14);
461        }
462
463        Ok(addr)
464    }
465
466    fn sys_getrandom(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
467        let size = args[1].min(crate::MAX_SYSCALL_BYTES as u64) as usize;
468
469        if !memory.can_write(args[0], size) {
470            return Err(14);
471        }
472
473        let bytes = (0..size).map(|idx| (idx as u8).wrapping_mul(31).wrapping_add(17)).collect::<Vec<_>>();
474
475        if !memory.store_bytes(args[0], &bytes) {
476            return Err(14);
477        }
478
479        Ok(size as u64)
480    }
481
482    fn sys_clock_gettime(
483        &mut self,
484        _memory: &mut impl SyscallMemory, // todo sep
485        _args: &[u64; 6],                 // todo sep
486    ) -> Result<u64, i32> {
487        // if !memory.store_bytes(args[1], &[0; 16]) {
488        //     return Err(14);
489        // }
490
491        Ok(0)
492    }
493
494    fn sys_sched_getaffinity(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
495        let size = usize::try_from(args[1]).map_err(|_| 22)?;
496
497        if size == 0 || !memory.store_bytes(args[2], &[1]) {
498            return Err(14);
499        }
500
501        Ok(1)
502    }
503
504    fn sys_uname(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
505        let mut uts = [0u8; 65 * 6];
506
507        // todo -- !!!jbm
508        for (index, value) in ["Linux", "remu", "6.0.0", "#1", "riscv64", ""].iter().enumerate() {
509            let start = index * 65;
510            uts[start..start + value.len()].copy_from_slice(value.as_bytes());
511        }
512
513        if !memory.store_bytes(args[0], &uts) {
514            return Err(14);
515        }
516
517        Ok(0)
518    }
519
520    fn sys_getrlimit(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
521        self.write_guest_rlimit(memory, args[1], args[0])
522    }
523
524    fn sys_prlimit64(&mut self, memory: &mut impl SyscallMemory, args: &[u64; 6]) -> Result<u64, i32> {
525        if args[2] != 0 {
526            return Err(22);
527        }
528
529        if args[3] != 0 {
530            self.write_guest_rlimit(memory, args[3], args[1])?;
531        }
532
533        Ok(0)
534    }
535
536    fn write_fd(&mut self, fd: i32, bytes: &[u8]) -> Result<usize, i32> {
537        match fd {
538            1 => write_marked_output(
539                io::stdout().lock(),
540                bytes,
541                self.lane,
542                "stdout",
543                "\x1b[1;36m",
544                io::stdout().is_terminal(),
545            ),
546
547            2 => write_marked_output(
548                io::stderr().lock(),
549                bytes,
550                self.lane,
551                "stderr",
552                "\x1b[1;31m",
553                io::stderr().is_terminal(),
554            ),
555
556            _ => self.files.get_mut(&fd).ok_or(9)?.file.write(bytes).map_err(host_errno),
557        }
558    }
559
560    fn write_guest_stat(
561        &mut self,
562        memory: &mut impl SyscallMemory,
563        addr: u64,
564        metadata: Option<&fs::Metadata>,
565    ) -> Result<u64, i32> {
566        let mut stat = [0u8; 128];
567
568        if let Some(metadata) = metadata {
569            put_u64(&mut stat, 0, metadata.dev());
570            put_u64(&mut stat, 8, metadata.ino());
571            put_u32(&mut stat, 16, metadata.mode());
572            put_u32(&mut stat, 20, metadata.nlink() as u32);
573            put_u32(&mut stat, 24, metadata.uid());
574            put_u32(&mut stat, 28, metadata.gid());
575            put_u64(&mut stat, 32, metadata.rdev());
576            put_u64(&mut stat, 48, metadata.size());
577            put_u32(&mut stat, 56, metadata.blksize() as u32);
578            put_u64(&mut stat, 64, metadata.blocks());
579            put_u64(&mut stat, 72, metadata.atime() as u64);
580            put_u64(&mut stat, 80, metadata.atime_nsec() as u64);
581            put_u64(&mut stat, 88, metadata.mtime() as u64);
582            put_u64(&mut stat, 96, metadata.mtime_nsec() as u64);
583            put_u64(&mut stat, 104, metadata.ctime() as u64);
584            put_u64(&mut stat, 112, metadata.ctime_nsec() as u64);
585        } else {
586            put_u32(&mut stat, 16, 0o020666);
587            put_u32(&mut stat, 20, 1);
588            put_u32(&mut stat, 24, 1000);
589            put_u32(&mut stat, 28, 1000);
590            put_u32(&mut stat, 56, PAGE_SIZE as u32);
591        }
592
593        if !memory.store_bytes(addr, &stat) {
594            return Err(14);
595        }
596
597        Ok(0)
598    }
599
600    fn open_path(&self, path: &str, flags: u64, mode: u64) -> Result<File, i32> {
601        let root = if path.starts_with('/') { self.sysroot.as_ref().ok_or(2)? } else { &self.workdir };
602
603        open_beneath(root, Path::new(path), flags, mode).map_err(host_errno)
604    }
605
606    fn write_guest_rlimit(&mut self, memory: &mut impl SyscallMemory, addr: u64, resource: u64) -> Result<u64, i32> {
607        let value = match resource {
608            3 => DEFAULT_STACK_SIZE,
609            7 => 1024,
610            _ => u64::MAX,
611        };
612
613        // 1 buffer lets the memory backend check the complete record
614        if !memory.store_bytes(addr, [value.to_le_bytes(); 2].as_flattened()) {
615            return Err(14);
616        }
617
618        Ok(0)
619    }
620}
621
622// todo -- fix für race condition --
623pub fn open_beneath(root: &File, path: &Path, flags: u64, mode: u64) -> io::Result<File> {
624    let name = CString::new(path.as_os_str().as_bytes())?;
625
626    let resolve = if path.is_absolute() { 0x10 } else { 0x08 }; // IN_ROOT / BENEATH
627    let how = [flags | libc::O_CLOEXEC as u64, mode, resolve | 0x02]; // NO_MAGICLINKS
628
629    let fd =
630        unsafe { libc::syscall(libc::SYS_openat2, root.as_raw_fd(), name.as_ptr(), how.as_ptr(), size_of_val(&how)) };
631
632    if fd < 0 { Err(io::Error::last_os_error()) } else { Ok(unsafe { File::from_raw_fd(fd as i32) }) }
633}
634
635pub fn host_errno(err: io::Error) -> i32 {
636    if let Some(errno) = err.raw_os_error() {
637        return errno;
638    }
639
640    match err.kind() {
641        io::ErrorKind::NotFound => 2,
642        io::ErrorKind::PermissionDenied => 13,
643        io::ErrorKind::AlreadyExists => 17,
644        io::ErrorKind::InvalidInput | io::ErrorKind::InvalidData => 22,
645        _ => 5,
646    }
647}
648
649pub fn guest_errno(errno: i32) -> u64 {
650    (-(errno as i64)) as u64
651}
652
653fn write_marked_output(
654    mut output: impl io::Write,
655    bytes: &[u8],
656    lane: Option<usize>,
657    name: &str,
658    color: &str,
659    colored: bool,
660) -> Result<usize, i32> {
661    let label = lane.map(|lane| format!("lane {lane} ")).unwrap_or_default();
662
663    let (color, reset) = if colored { (color, "\x1b[0m") } else { ("", "") };
664
665    writeln!(output, "\n{color}----- {label}guest {name} -----{reset}").map_err(host_errno)?;
666
667    let count = output.write(bytes).map_err(host_errno)?;
668
669    if bytes.get(..count).is_none_or(|written| !written.ends_with(b"\n")) {
670        writeln!(output).map_err(host_errno)?;
671    }
672
673    writeln!(output, "{color}----- end {label}guest {name} -----{reset}").map_err(host_errno)?;
674
675    output.flush().map_err(host_errno)?;
676
677    Ok(count)
678}
679
680fn put_u32(bytes: &mut [u8], offset: usize, value: u32) {
681    bytes[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
682}
683
684fn put_u64(bytes: &mut [u8], offset: usize, value: u64) {
685    bytes[offset..offset + 8].copy_from_slice(&value.to_le_bytes());
686}