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 _}, 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 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 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 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 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, _args: &[u64; 6], ) -> Result<u64, i32> {
487 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 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 if !memory.store_bytes(addr, [value.to_le_bytes(); 2].as_flattened()) {
615 return Err(14);
616 }
617
618 Ok(0)
619 }
620}
621
622pub 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 }; let how = [flags | libc::O_CLOEXEC as u64, mode, resolve | 0x02]; 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}