1mod common;
20mod fd;
21mod fs;
22mod helpers;
23mod io;
24mod mem_sys;
25mod process;
26mod signal;
27mod sysctl;
28mod table;
29mod thread_sys;
30mod time_sys;
31
32use crate::process as proc_state;
33use crate::trap::TrapOutcome;
34
35pub use common::{
36 EBADF, EEXIST, EFAULT, EINVAL, ENOENT, ENOMEM, ENOSYS, EPERM, SyscallArgs, SyscallResult,
37};
38pub use table::{BsdSyscall, known_syscalls, lookup, name_of};
39
40pub fn reset_syscall_state(max_syscalls: usize) {
42 proc_state::reset_run(max_syscalls);
43 helpers::reset_futex_stats();
44}
45
46pub(crate) fn dump_futex_stats_if_enabled() {
48 helpers::dump_futex_stats_if_enabled();
49}
50
51pub fn dispatch(args: SyscallArgs) -> SyscallResult {
53 if proc_state::tick_syscall() {
55 return SyscallResult {
56 name: "max_syscalls",
57 outcome: TrapOutcome::Exit { code: 1 },
58 retval: Some(1),
59 error: false,
60 };
61 }
62
63 match args.number {
65 n if helpers::is_helper(n) => return helpers::dispatch_helper(args),
67 3 | 396 => return io::handle_read(args),
68 4 | 397 => return io::handle_write(args),
69 5 | 398 => return fd::handle_open(args),
70 6 | 399 => return fd::handle_close(args),
71 199 => return fd::handle_lseek(args),
72 92 => return fd::handle_fcntl(args),
73 _ => {}
74 }
75
76 match lookup(args.number) {
77 Some(BsdSyscall::Exit) => process::handle_exit(args),
78 Some(BsdSyscall::Write) => io::handle_write(args),
79 Some(BsdSyscall::Read) => io::handle_read(args),
80 Some(BsdSyscall::Open) => fd::handle_open(args),
81 Some(BsdSyscall::Close) => fd::handle_close(args),
82 Some(BsdSyscall::Getpid) => process::handle_getpid(),
83 Some(BsdSyscall::Getppid) => process::handle_getppid(),
84 Some(BsdSyscall::Access) => fs::handle_access(args),
85 Some(BsdSyscall::Issetugid) => process::handle_issetugid(),
86 Some(BsdSyscall::Munmap) => mem_sys::handle_munmap(args),
87 Some(BsdSyscall::Mprotect) => mem_sys::handle_mprotect(args),
88 Some(BsdSyscall::Mmap) => mem_sys::handle_mmap(args),
89 Some(BsdSyscall::Msync) => mem_sys::handle_msync(args),
90 Some(BsdSyscall::Dup) => fd::handle_dup(args),
91 Some(BsdSyscall::Fcntl) => fd::handle_fcntl(args),
92 Some(BsdSyscall::Lseek) => fd::handle_lseek(args),
93 Some(BsdSyscall::Stat) => fs::handle_stat(args),
94 Some(BsdSyscall::Fstat) => fs::handle_fstat(args),
95 Some(BsdSyscall::Lstat) => fs::handle_lstat(args),
96 Some(BsdSyscall::Unlink) => fs::handle_unlink(args),
97 Some(BsdSyscall::Link) => fs::handle_link(args),
98 Some(BsdSyscall::Symlink) => fs::handle_symlink(args),
99 Some(BsdSyscall::Readlink) => fs::handle_readlink(args),
100 Some(BsdSyscall::Mkdir) => fs::handle_mkdir(args),
101 Some(BsdSyscall::Rmdir) => fs::handle_rmdir(args),
102 Some(BsdSyscall::Rename) => fs::handle_rename(args),
103 Some(BsdSyscall::Ftruncate) => fs::handle_ftruncate(args),
104 Some(BsdSyscall::Fsync) => fs::handle_fsync(args),
105 Some(BsdSyscall::Openat) => fd::handle_openat(args),
106 Some(BsdSyscall::Fstatat) => fs::handle_fstatat(args),
107 Some(BsdSyscall::Gettimeofday) => time_sys::handle_gettimeofday(args),
108 Some(BsdSyscall::ClockGettime) => time_sys::handle_clock_gettime(args),
109 Some(BsdSyscall::Sysctl) => sysctl::handle_sysctl(args),
110 Some(BsdSyscall::Sysctlbyname) => sysctl::handle_sysctlbyname(args),
111 Some(BsdSyscall::Sigprocmask) => signal::handle_sigprocmask(args),
112 Some(BsdSyscall::Sigaction) => signal::handle_sigaction(args),
113 Some(BsdSyscall::BsdthreadCreate) => thread_sys::handle_bsdthread_create(args),
114 Some(BsdSyscall::BsdthreadTerminate) => thread_sys::handle_bsdthread_terminate(args),
115 Some(BsdSyscall::BsdthreadRegister) => thread_sys::handle_bsdthread_register(args),
116 Some(BsdSyscall::ThreadSelfid) => thread_sys::handle_thread_selfid(),
117 None => {
118 log_unknown_syscall(args.number, args.x0, args.x1, args.x2);
121 SyscallResult::err("unknown", ENOSYS)
122 }
123 }
124}
125
126fn log_unknown_syscall(number: u32, x0: u64, x1: u64, x2: u64) {
127 use std::sync::atomic::{AtomicU32, Ordering};
128 static SEEN: AtomicU32 = AtomicU32::new(0);
129 let n = SEEN.fetch_add(1, Ordering::Relaxed);
130 if n >= 32 {
131 return;
132 }
133 let msg = format!("kh: unknown BSD syscall #{number} x0={x0:#x} x1={x1:#x} x2={x2:#x}\n");
134 drop(std::io::Write::write_all(
135 &mut std::io::stderr(),
136 msg.as_bytes(),
137 ));
138}
139
140#[cfg(test)]
141#[allow(clippy::expect_used, clippy::unwrap_used)]
142mod tests {
143 use super::common::{guest_read_i32, guest_read_u64, guest_slice, guest_write};
144 use super::mem_sys::{DARWIN_MAP_ANON, DARWIN_MAP_PRIVATE, DARWIN_MAP_SHARED, host_page_size};
145 use super::*;
146 use crate::mem::{
147 HostPageSize, VM_PROT_EXECUTE, VM_PROT_READ, VM_PROT_WRITE, map_stack, register_borrowed,
148 registry_clear,
149 };
150 use std::io::Write;
151
152 fn lock_syscalls() -> std::sync::MutexGuard<'static, ()> {
153 proc_state::test_lock()
154 }
155
156 fn args(number: u32, x0: u64, x1: u64, x2: u64) -> SyscallArgs {
157 SyscallArgs {
158 pc: 0,
159 number,
160 x0,
161 x1,
162 x2,
163 x3: 0,
164 x4: 0,
165 x5: 0,
166 x6: 0,
167 }
168 }
169
170 fn guest_va(base: u64, off: usize) -> u64 {
171 base.wrapping_add(u64::try_from(off).unwrap())
172 }
173
174 fn write_cstr(base: u64, off: usize, s: &str) -> u64 {
175 let va = guest_va(base, off);
176 guest_write(va, s.as_bytes());
177 guest_write(va.wrapping_add(u64::try_from(s.len()).unwrap()), &[0]);
178 va
179 }
180
181 #[test]
182 fn lookup_common_numbers() {
183 assert_eq!(lookup(1), Some(BsdSyscall::Exit));
184 assert_eq!(lookup(4), Some(BsdSyscall::Write));
185 assert_eq!(lookup(5), Some(BsdSyscall::Open));
186 assert_eq!(lookup(20), Some(BsdSyscall::Getpid));
187 assert_eq!(lookup(41), Some(BsdSyscall::Dup));
188 assert_eq!(lookup(46), Some(BsdSyscall::Sigaction));
189 assert_eq!(lookup(48), Some(BsdSyscall::Sigprocmask));
190 assert_eq!(lookup(65), Some(BsdSyscall::Msync));
191 assert_eq!(lookup(92), Some(BsdSyscall::Fcntl));
192 assert_eq!(lookup(116), Some(BsdSyscall::Gettimeofday));
193 assert_eq!(lookup(199), Some(BsdSyscall::Lseek));
194 assert_eq!(lookup(202), Some(BsdSyscall::Sysctl));
195 assert_eq!(lookup(266), Some(BsdSyscall::ClockGettime));
196 assert_eq!(lookup(274), Some(BsdSyscall::Sysctlbyname));
197 assert_eq!(lookup(360), Some(BsdSyscall::BsdthreadCreate));
198 assert_eq!(lookup(361), Some(BsdSyscall::BsdthreadTerminate));
199 assert_eq!(lookup(366), Some(BsdSyscall::BsdthreadRegister));
200 assert_eq!(lookup(372), Some(BsdSyscall::ThreadSelfid));
201 assert_eq!(lookup(463), Some(BsdSyscall::Openat));
202 assert_eq!(lookup(9999), None);
203 }
204
205 #[test]
206 fn name_table_stable() {
207 assert_eq!(name_of(1), Some("exit"));
208 assert_eq!(name_of(4), Some("write"));
209 assert_eq!(name_of(339), Some("fstat"));
210 assert_eq!(name_of(42), None);
211 }
212
213 #[test]
214 fn exit_dispatch() {
215 let _g = lock_syscalls();
216 reset_syscall_state(256);
217 let r = dispatch(args(1, 7, 0, 0));
218 assert_eq!(r.name, "exit");
219 assert_eq!(r.outcome, TrapOutcome::Exit { code: 7 });
220 assert!(!r.error);
221 }
222
223 #[test]
224 fn unknown_returns_enosys_with_error_flag() {
225 let _g = lock_syscalls();
226 reset_syscall_state(256);
227 let r = dispatch(args(0xDEAD, 0, 0, 0));
228 assert_eq!(r.name, "unknown");
229 assert!(r.error);
230 assert_eq!(r.retval, Some(u64::try_from(ENOSYS).unwrap_or(0)));
231 }
232
233 #[test]
234 fn max_syscalls_trips() {
235 let _g = lock_syscalls();
236 reset_syscall_state(2);
237 let a = args(20, 0, 0, 0);
238 assert_eq!(dispatch(a).name, "getpid");
239 assert_eq!(dispatch(a).name, "getpid");
240 let r = dispatch(a);
241 assert_eq!(r.name, "max_syscalls");
242 assert_eq!(r.outcome, TrapOutcome::Exit { code: 1 });
243 }
244
245 #[test]
246 fn getpid_positive() {
247 let _g = lock_syscalls();
248 reset_syscall_state(256);
249 let r = dispatch(args(20, 0, 0, 0));
250 assert_eq!(r.name, "getpid");
251 assert!(!r.error);
252 assert!(r.retval.unwrap_or(0) > 0);
253 }
254
255 #[test]
256 fn getppid_positive() {
257 let _g = lock_syscalls();
258 reset_syscall_state(256);
259 let r = dispatch(args(39, 0, 0, 0));
260 assert_eq!(r.name, "getppid");
261 assert!(!r.error);
262 assert!(r.retval.unwrap_or(0) > 0);
263 }
264
265 #[test]
266 fn ok_err_helpers() {
267 let ok = SyscallResult::ok("write", 3);
268 assert!(!ok.error);
269 assert_eq!(ok.retval, Some(3));
270 let err = SyscallResult::err("write", EBADF);
271 assert!(err.error);
272 assert_eq!(err.retval, Some(9));
273 }
274
275 #[test]
276 fn mmap_anon_private_roundtrip() {
277 let _g = lock_syscalls();
278 reset_syscall_state(256);
279 registry_clear();
280 let page = host_page_size();
281 let page_u = u64::try_from(page).unwrap_or(4096);
282 let r = dispatch(SyscallArgs {
283 pc: 0,
284 number: 197,
285 x0: 0,
286 x1: page_u,
287 x2: u64::from(VM_PROT_READ | VM_PROT_WRITE),
288 x3: DARWIN_MAP_ANON | DARWIN_MAP_PRIVATE,
289 x4: u64::MAX,
290 x5: 0,
291 x6: 0,
292 });
293 assert_eq!(r.name, "mmap");
294 assert!(!r.error, "mmap failed: {:?}", r.retval);
295 let addr = r.retval.expect("addr");
296 assert_ne!(addr, u64::MAX);
297 assert_ne!(addr, 0);
298
299 let r2 = dispatch(SyscallArgs {
300 pc: 0,
301 number: 74,
302 x0: addr,
303 x1: page_u,
304 x2: u64::from(VM_PROT_READ | VM_PROT_EXECUTE),
305 x3: 0,
306 x4: 0,
307 x5: 0,
308 x6: 0,
309 });
310 assert!(!r2.error);
311
312 let r3 = dispatch(SyscallArgs {
313 pc: 0,
314 number: 73,
315 x0: addr,
316 x1: page_u,
317 x2: 0,
318 x3: 0,
319 x4: 0,
320 x5: 0,
321 x6: 0,
322 });
323 assert!(!r3.error);
324 registry_clear();
325 }
326
327 #[test]
328 fn mmap_file_backed_shared_msync() {
329 let _g = lock_syscalls();
330 reset_syscall_state(256);
331 registry_clear();
332 let host = HostPageSize::detect().expect("host");
333 let stack = map_stack(host, 256 * 1024).expect("stack");
334 register_borrowed(&stack);
335
336 let dir = std::env::temp_dir().join(format!("kh-mmap-file-{}", std::process::id()));
337 drop(std::fs::create_dir_all(&dir));
338 let path = dir.join("payload.bin");
339 std::fs::write(&path, b"KAKEMAP01\n").expect("write payload");
340
341 let base = stack.guest_addr;
342 let path_str = path.to_str().unwrap();
343 let path_va = write_cstr(base, 0x1000, path_str);
344 let open = dispatch(args(5, path_va, 2, 0)); assert!(!open.error, "open: {:?}", open.retval);
346 let gfd = open.retval.expect("fd");
347
348 let page = host_page_size();
349 let page_u = u64::try_from(page).unwrap();
350 let map = dispatch(SyscallArgs {
351 pc: 0,
352 number: 197,
353 x0: 0,
354 x1: page_u,
355 x2: u64::from(VM_PROT_READ | VM_PROT_WRITE),
356 x3: DARWIN_MAP_SHARED,
357 x4: gfd,
358 x5: 0,
359 x6: 0,
360 });
361 assert!(!map.error, "mmap file: {:?}", map.retval);
362 let addr = map.retval.expect("map");
363 assert_eq!(guest_slice(addr, 9), b"KAKEMAP01");
364 guest_write(addr, b"X");
365
366 let sync = dispatch(SyscallArgs {
367 pc: 0,
368 number: 65,
369 x0: addr,
370 x1: page_u,
371 x2: 0x10, x3: 0,
373 x4: 0,
374 x5: 0,
375 x6: 0,
376 });
377 assert!(!sync.error, "msync: {:?}", sync.retval);
378
379 let unmap = dispatch(SyscallArgs {
380 pc: 0,
381 number: 73,
382 x0: addr,
383 x1: page_u,
384 x2: 0,
385 x3: 0,
386 x4: 0,
387 x5: 0,
388 x6: 0,
389 });
390 assert!(!unmap.error);
391 assert!(!dispatch(args(6, gfd, 0, 0)).error);
392
393 let on_disk = std::fs::read(&path).expect("reread");
394 assert_eq!(on_disk.first().copied(), Some(b'X'));
395 assert_eq!(on_disk.get(1..9), Some(b"AKEMAP01".as_slice()));
396
397 registry_clear();
398 drop(stack);
399 drop(std::fs::remove_file(&path));
400 drop(std::fs::remove_dir(&dir));
401 }
402
403 #[test]
404 fn gettimeofday_and_clock_gettime() {
405 let _g = lock_syscalls();
406 reset_syscall_state(256);
407 registry_clear();
408 let host = HostPageSize::detect().expect("host");
409 let stack = map_stack(host, 64 * 1024).expect("stack");
410 register_borrowed(&stack);
411 let base = stack.guest_addr;
412 let tv_va = guest_va(base, 0x400);
413 let ts_va = guest_va(base, 0x500);
414
415 let r = dispatch(args(116, tv_va, 0, 0));
416 assert!(!r.error, "gettimeofday: {:?}", r.retval);
417 let sec = guest_read_u64(tv_va);
418 let sec = i64::from_ne_bytes(sec.to_ne_bytes());
419 assert!(sec > 1_600_000_000, "tv_sec={sec}");
420
421 let r2 = dispatch(args(266, 0, ts_va, 0)); assert!(!r2.error, "clock_gettime: {:?}", r2.retval);
423 let sec2 = guest_read_u64(ts_va);
424 let sec2 = i64::from_ne_bytes(sec2.to_ne_bytes());
425 assert!((sec2 - sec).abs() < 5);
426
427 registry_clear();
428 drop(stack);
429 }
430
431 #[test]
432 fn sysctlbyname_hw_ncpu() {
433 let _g = lock_syscalls();
434 reset_syscall_state(256);
435 registry_clear();
436 let host = HostPageSize::detect().expect("host");
437 let stack = map_stack(host, 64 * 1024).expect("stack");
438 register_borrowed(&stack);
439 let base = stack.guest_addr;
440 let key_va = write_cstr(base, 0x200, "hw.ncpu");
441 let val_va = guest_va(base, 0x300);
442 let len_va = guest_va(base, 0x310);
443 guest_write(len_va, &8_u64.to_le_bytes());
444
445 let r = dispatch(SyscallArgs {
446 pc: 0,
447 number: 274,
448 x0: key_va,
449 x1: val_va,
450 x2: len_va,
451 x3: 0,
452 x4: 0,
453 x5: 0,
454 x6: 0,
455 });
456 assert!(!r.error, "sysctlbyname: {:?}", r.retval);
457 let ncpu = guest_read_i32(val_va);
458 assert!(ncpu >= 1);
459
460 registry_clear();
461 drop(stack);
462 }
463
464 #[test]
465 fn sigprocmask_soft_roundtrip() {
466 let _g = lock_syscalls();
467 reset_syscall_state(256);
468 registry_clear();
469 let host = HostPageSize::detect().expect("host");
470 let stack = map_stack(host, 64 * 1024).expect("stack");
471 register_borrowed(&stack);
472 let base = stack.guest_addr;
473 let set_va = guest_va(base, 0x100);
474 let oset_va = guest_va(base, 0x110);
475 guest_write(set_va, &0x00FF_u32.to_le_bytes());
476 let r = dispatch(SyscallArgs {
478 pc: 0,
479 number: 48,
480 x0: 3,
481 x1: set_va,
482 x2: oset_va,
483 x3: 0,
484 x4: 0,
485 x5: 0,
486 x6: 0,
487 });
488 assert!(!r.error, "sigprocmask: {:?}", r.retval);
489
490 registry_clear();
491 drop(stack);
492 }
493
494 #[test]
495 fn write_efault_when_registry_active_and_bad_ptr() {
496 let _g = lock_syscalls();
497 reset_syscall_state(256);
498 registry_clear();
499 let host = HostPageSize::detect().expect("host");
500 let stack = map_stack(host, 64 * 1024).expect("stack");
501 register_borrowed(&stack);
502
503 let r = dispatch(args(4, 1, 0x1, 4));
504 assert_eq!(r.name, "write");
505 assert!(r.error);
506 assert_eq!(r.retval, Some(u64::try_from(EFAULT).unwrap_or(0)));
507 registry_clear();
508 drop(stack);
509 }
510
511 #[test]
512 fn open_read_lseek_fstat_dup_roundtrip() {
513 let _g = lock_syscalls();
514 reset_syscall_state(256);
515 registry_clear();
516 let host = HostPageSize::detect().expect("host");
517 let stack = map_stack(host, 256 * 1024).expect("stack");
518 register_borrowed(&stack);
519
520 let dir = std::env::temp_dir().join(format!("kh-fd-test-{}", std::process::id()));
521 drop(std::fs::create_dir_all(&dir));
522 let path = dir.join("data.txt");
523 {
524 let mut f = std::fs::File::create(&path).expect("create");
525 f.write_all(b"hello-DEF").expect("write");
526 }
527
528 let base = stack.guest_addr;
529 let path_str = path.to_str().expect("utf8 path");
530 let path_va = write_cstr(base, 0x1000, path_str);
531 let open = dispatch(args(5, path_va, 0, 0)); assert!(!open.error, "open: {:?}", open.retval);
533 let gfd = open.retval.expect("fd");
534
535 let read_va = guest_va(base, 0x2000);
536 let rd = dispatch(args(3, gfd, read_va, 5)); assert!(!rd.error, "read: {:?}", rd.retval);
538 assert_eq!(rd.retval, Some(5));
539 assert_eq!(guest_slice(read_va, 5), b"hello");
540
541 let seek = dispatch(args(199, gfd, 0, 0)); assert!(!seek.error);
543 assert_eq!(seek.retval, Some(0));
544
545 let stat_va = guest_va(base, 0x3000);
546 let st = dispatch(args(339, gfd, stat_va, 0));
547 assert!(!st.error, "fstat: {:?}", st.retval);
548 let size = guest_read_u64(stat_va + 96);
550 let size = i64::from_ne_bytes(size.to_ne_bytes());
551 assert_eq!(size, 9);
552
553 let dup = dispatch(args(41, gfd, 0, 0));
554 assert!(!dup.error);
555 let gfd2 = dup.retval.expect("dup fd");
556 assert_ne!(gfd2, gfd);
557
558 let fl = dispatch(args(92, gfd, 3, 0));
559 assert!(!fl.error);
560
561 assert!(!dispatch(args(6, gfd, 0, 0)).error);
562 assert!(!dispatch(args(6, gfd2, 0, 0)).error);
563
564 registry_clear();
565 drop(stack);
566 drop(std::fs::remove_file(&path));
567 drop(std::fs::remove_dir(&dir));
568 }
569
570 #[test]
571 fn openat_at_fdcwd() {
572 let _g = lock_syscalls();
573 reset_syscall_state(256);
574 registry_clear();
575 let host = HostPageSize::detect().expect("host");
576 let stack = map_stack(host, 64 * 1024).expect("stack");
577 register_borrowed(&stack);
578
579 let dir = std::env::temp_dir().join(format!("kh-openat-{}", std::process::id()));
580 drop(std::fs::create_dir_all(&dir));
581 let path = dir.join("x.txt");
582 std::fs::write(&path, b"z").expect("write");
583
584 let base = stack.guest_addr;
585 let path_str = path.to_str().unwrap();
586 let path_va = write_cstr(base, 0x800, path_str);
587 let r = dispatch(SyscallArgs {
588 pc: 0,
589 number: 463,
590 x0: u64::from_ne_bytes(i64::from(fd::AT_FDCWD).to_ne_bytes()),
591 x1: path_va,
592 x2: 0,
593 x3: 0,
594 x4: 0,
595 x5: 0,
596 x6: 0,
597 });
598 assert!(!r.error, "openat: {:?}", r.retval);
599 let gfd = r.retval.unwrap();
600 assert!(!dispatch(args(6, gfd, 0, 0)).error);
601
602 registry_clear();
603 drop(stack);
604 drop(std::fs::remove_file(&path));
605 drop(std::fs::remove_dir(&dir));
606 }
607}