Skip to main content

kh_runtime/syscall/
mod.rs

1//! Table-driven Darwin BSD syscall dispatch (arm64, number in `x16`).
2//!
3//! Error ABI (Darwin arm64): success clears `PSTATE.C` and places the return
4//! value in `x0`; failure sets `PSTATE.C` and places a **positive** errno in
5//! `x0`. The trap handler applies the carry bit from [`SyscallResult::error`].
6//!
7//! Modules:
8//! - [`table`] — numbers / names
9//! - [`fd`] — FD table, open/close/dup/lseek/fcntl/openat
10//! - [`io`] — read/write
11//! - [`fs`] — access/stat/fstat
12//! - [`mem_sys`] — mmap/mprotect/munmap/msync
13//! - [`process`] — exit/getpid/getppid/issetugid
14//! - [`thread_sys`] — bsdthread_*/thread_selfid
15//! - [`time_sys`] — gettimeofday/clock_gettime
16//! - [`sysctl`] — sysctl/sysctlbyname
17//! - [`signal`] — sigprocmask/sigaction (soft)
18//! - [`net`] — pipe/socket/connect/poll/select (curl G3)
19
20#[cfg(test)]
21mod boundary_bench;
22mod boundary_stats;
23mod common;
24mod fd;
25mod fs;
26mod helpers;
27mod io;
28mod mem_sys;
29mod net;
30mod process;
31mod signal;
32mod sysctl;
33mod table;
34mod thread_sys;
35mod time_sys;
36
37use crate::process as proc_state;
38use crate::trap::TrapOutcome;
39
40pub use common::{
41    EBADF, EEXIST, EFAULT, EINVAL, ENOENT, ENOMEM, ENOSYS, EPERM, SyscallArgs, SyscallResult,
42};
43pub use table::{BsdSyscall, known_syscalls, lookup, name_of};
44
45/// Resets FD table, soft signal state, and syscall counter for a new run.
46pub fn reset_syscall_state(max_syscalls: usize) {
47    proc_state::reset_run(max_syscalls);
48    helpers::reset_futex_stats();
49    boundary_stats::reset();
50}
51
52/// Print guest park/wake helper counters when `KAKEHASHI_FUTEX_STATS` is set.
53pub(crate) fn dump_futex_stats_if_enabled() {
54    helpers::dump_futex_stats_if_enabled();
55}
56
57/// Print hypercall dispatch counters when `KAKEHASHI_BOUNDARY_STATS` is set.
58pub(crate) fn dump_boundary_stats_if_enabled() {
59    boundary_stats::dump_if_enabled();
60}
61
62/// Dispatches a Darwin BSD syscall by number.
63pub fn dispatch(args: SyscallArgs) -> SyscallResult {
64    let stats = boundary_stats::begin();
65    let result = dispatch_inner(args);
66    boundary_stats::end(stats, args.number);
67    result
68}
69
70fn dispatch_inner(args: SyscallArgs) -> SyscallResult {
71    // Atomic tick — do not take the process lock on every SVC.
72    if proc_state::tick_syscall() {
73        return SyscallResult {
74            name: "max_syscalls",
75            outcome: TrapOutcome::Exit { code: 1 },
76            retval: Some(1),
77            error: false,
78        };
79    }
80
81    // Hot numbers first (archive I/O + helpers) — avoid enum match churn.
82    match args.number {
83        // helpers: 0x4B48_xxxx
84        n if helpers::is_helper(n) => return helpers::dispatch_helper(args),
85        3 | 396 => return io::handle_read(args),
86        4 | 397 => return io::handle_write(args),
87        5 | 398 => return fd::handle_open(args),
88        6 | 399 => return fd::handle_close(args),
89        199 => return fd::handle_lseek(args),
90        92 => return fd::handle_fcntl(args),
91        _ => {}
92    }
93
94    match lookup(args.number) {
95        Some(BsdSyscall::Exit) => process::handle_exit(args),
96        Some(BsdSyscall::Fork | BsdSyscall::Vfork) => process::handle_fork(args),
97        Some(BsdSyscall::Wait4) => process::handle_wait4(args),
98        Some(BsdSyscall::Execve) => process::handle_execve(args),
99        Some(BsdSyscall::Setsid) => process::handle_setsid(),
100        Some(BsdSyscall::Setpgid) => process::handle_setpgid(args),
101        Some(BsdSyscall::Getpgrp) => process::handle_getpgrp(),
102        Some(BsdSyscall::Kill) => process::handle_kill(args),
103        Some(BsdSyscall::Write) => io::handle_write(args),
104        Some(BsdSyscall::Read) => io::handle_read(args),
105        Some(BsdSyscall::Open) => fd::handle_open(args),
106        Some(BsdSyscall::Close) => fd::handle_close(args),
107        Some(BsdSyscall::Getpid) => process::handle_getpid(),
108        Some(BsdSyscall::Getppid) => process::handle_getppid(),
109        Some(BsdSyscall::Getuid) => process::handle_getuid(),
110        Some(BsdSyscall::Geteuid) => process::handle_geteuid(),
111        Some(BsdSyscall::Getgid) => process::handle_getgid(),
112        Some(BsdSyscall::Getegid) => process::handle_getegid(),
113        Some(BsdSyscall::Access) => fs::handle_access(args),
114        Some(BsdSyscall::Issetugid) => process::handle_issetugid(),
115        Some(BsdSyscall::Munmap) => mem_sys::handle_munmap(args),
116        Some(BsdSyscall::Mprotect) => mem_sys::handle_mprotect(args),
117        Some(BsdSyscall::Mmap) => mem_sys::handle_mmap(args),
118        Some(BsdSyscall::Msync) => mem_sys::handle_msync(args),
119        Some(BsdSyscall::Dup) => fd::handle_dup(args),
120        Some(BsdSyscall::Dup2) => fd::handle_dup2(args),
121        Some(BsdSyscall::Fcntl) => fd::handle_fcntl(args),
122        Some(BsdSyscall::Lseek) => fd::handle_lseek(args),
123        Some(BsdSyscall::Pread) => io::handle_pread(args),
124        Some(BsdSyscall::Pwrite) => io::handle_pwrite(args),
125        Some(BsdSyscall::Stat) => fs::handle_stat(args),
126        Some(BsdSyscall::Fstat) => fs::handle_fstat(args),
127        Some(BsdSyscall::Lstat) => fs::handle_lstat(args),
128        Some(BsdSyscall::Unlink) => fs::handle_unlink(args),
129        Some(BsdSyscall::Link) => fs::handle_link(args),
130        Some(BsdSyscall::Symlink) => fs::handle_symlink(args),
131        Some(BsdSyscall::Readlink) => fs::handle_readlink(args),
132        Some(BsdSyscall::Mkdir) => fs::handle_mkdir(args),
133        Some(BsdSyscall::Rmdir) => fs::handle_rmdir(args),
134        Some(BsdSyscall::Chdir) => fs::handle_chdir(args),
135        Some(BsdSyscall::Getcwd) => fs::handle_getcwd(args),
136        Some(BsdSyscall::Rename) => fs::handle_rename(args),
137        Some(BsdSyscall::Ftruncate) => fs::handle_ftruncate(args),
138        Some(BsdSyscall::Fchmod) => fs::handle_fchmod(args),
139        Some(BsdSyscall::Fsync) => fs::handle_fsync(args),
140        Some(BsdSyscall::Openat) => fd::handle_openat(args),
141        Some(BsdSyscall::Fstatat) => fs::handle_fstatat(args),
142        Some(BsdSyscall::Gettimeofday) => time_sys::handle_gettimeofday(args),
143        Some(BsdSyscall::ClockGettime) => time_sys::handle_clock_gettime(args),
144        Some(BsdSyscall::Sysctl) => sysctl::handle_sysctl(args),
145        Some(BsdSyscall::Sysctlbyname) => sysctl::handle_sysctlbyname(args),
146        Some(BsdSyscall::Sigprocmask) => signal::handle_sigprocmask(args),
147        Some(BsdSyscall::Sigaction) => signal::handle_sigaction(args),
148        Some(BsdSyscall::BsdthreadCreate) => thread_sys::handle_bsdthread_create(args),
149        Some(BsdSyscall::BsdthreadTerminate) => thread_sys::handle_bsdthread_terminate(args),
150        Some(BsdSyscall::BsdthreadRegister) => thread_sys::handle_bsdthread_register(args),
151        Some(BsdSyscall::ThreadSelfid) => thread_sys::handle_thread_selfid(),
152        Some(BsdSyscall::Pipe) => net::handle_pipe(args),
153        Some(BsdSyscall::Socket) => net::handle_socket(args),
154        Some(BsdSyscall::Socketpair) => net::handle_socketpair(args),
155        Some(BsdSyscall::Connect) => net::handle_connect(args),
156        Some(BsdSyscall::Bind) => net::handle_bind(args),
157        Some(BsdSyscall::Listen) => net::handle_listen(args),
158        Some(BsdSyscall::Accept) => net::handle_accept(args),
159        Some(BsdSyscall::Setsockopt) => net::handle_setsockopt(args),
160        Some(BsdSyscall::Getsockopt) => net::handle_getsockopt(args),
161        Some(BsdSyscall::Shutdown) => net::handle_shutdown(args),
162        Some(BsdSyscall::Sendto | BsdSyscall::Send) => net::handle_sendto(args),
163        Some(BsdSyscall::Recvfrom | BsdSyscall::Recv) => net::handle_recvfrom(args),
164        Some(BsdSyscall::Sendmsg) => net::handle_sendmsg(args),
165        Some(BsdSyscall::Recvmsg) => net::handle_recvmsg(args),
166        Some(BsdSyscall::Poll) => net::handle_poll(args),
167        Some(BsdSyscall::Select) => net::handle_select(args),
168        Some(BsdSyscall::Getsockname) => net::handle_getsockname(args),
169        Some(BsdSyscall::Getpeername) => net::handle_getpeername(args),
170        None => {
171            // Rate-limited diagnostic so hangs (e.g. 7zz archive) show the
172            // missing Darwin number without flooding when guests spin.
173            log_unknown_syscall(args);
174            SyscallResult::err("unknown", ENOSYS)
175        }
176    }
177}
178
179fn log_unknown_syscall(args: SyscallArgs) {
180    use std::sync::atomic::{AtomicU32, Ordering};
181    static SEEN: AtomicU32 = AtomicU32::new(0);
182    let n = SEEN.fetch_add(1, Ordering::Relaxed);
183    if n >= 32 {
184        return;
185    }
186    let number = args.number;
187    let pc = args.pc;
188    let path = if pc == 0 { "hypercall" } else { "residual-brk" };
189    // Peek guest text around PC: residual sites often set x16 far above the
190    // svc; dump pc-28..pc+4 as hex words for offline decode.
191    let mut hex = String::new();
192    if pc != 0 {
193        // Words at pc-28..pc+4 (7 before, 1 at pc, 1 after) for offline decode.
194        let base = pc.wrapping_sub(28);
195        for i in 0_u64..9 {
196            let va = base.wrapping_add(i.wrapping_mul(4));
197            let w = if crate::mem::registry_check_range(va, 4, false) {
198                common::guest_read_u32(va)
199            } else {
200                0
201            };
202            if !hex.is_empty() {
203                hex.push(' ');
204            }
205            let _ = std::fmt::Write::write_fmt(&mut hex, format_args!("{w:08x}"));
206        }
207    }
208    tracing::warn!(
209        number,
210        number_hex = format_args!("{number:#x}"),
211        pc = format_args!("{pc:#x}"),
212        path,
213        x0 = format_args!("{:#x}", args.x0),
214        x1 = format_args!("{:#x}", args.x1),
215        x2 = format_args!("{:#x}", args.x2),
216        x3 = format_args!("{:#x}", args.x3),
217        x4 = format_args!("{:#x}", args.x4),
218        x5 = format_args!("{:#x}", args.x5),
219        words = hex.as_str(),
220        "unknown BSD syscall"
221    );
222}
223
224#[cfg(test)]
225#[allow(clippy::expect_used, clippy::unwrap_used)]
226mod tests {
227    use super::common::{guest_read_i32, guest_read_u64, guest_slice, guest_write};
228    use super::mem_sys::{DARWIN_MAP_ANON, DARWIN_MAP_PRIVATE, DARWIN_MAP_SHARED, host_page_size};
229    use super::*;
230    use crate::mem::{
231        HostPageSize, VM_PROT_EXECUTE, VM_PROT_READ, VM_PROT_WRITE, map_stack, register_borrowed,
232        registry_clear,
233    };
234    use std::io::Write;
235
236    fn lock_syscalls() -> std::sync::MutexGuard<'static, ()> {
237        proc_state::test_lock()
238    }
239
240    fn args(number: u32, x0: u64, x1: u64, x2: u64) -> SyscallArgs {
241        SyscallArgs {
242            pc: 0,
243            number,
244            x0,
245            x1,
246            x2,
247            x3: 0,
248            x4: 0,
249            x5: 0,
250            x6: 0,
251        }
252    }
253
254    fn guest_va(base: u64, off: usize) -> u64 {
255        base.wrapping_add(u64::try_from(off).unwrap())
256    }
257
258    fn write_cstr(base: u64, off: usize, s: &str) -> u64 {
259        let va = guest_va(base, off);
260        guest_write(va, s.as_bytes());
261        guest_write(va.wrapping_add(u64::try_from(s.len()).unwrap()), &[0]);
262        va
263    }
264
265    #[test]
266    fn lookup_common_numbers() {
267        assert_eq!(lookup(1), Some(BsdSyscall::Exit));
268        assert_eq!(lookup(4), Some(BsdSyscall::Write));
269        assert_eq!(lookup(5), Some(BsdSyscall::Open));
270        assert_eq!(lookup(20), Some(BsdSyscall::Getpid));
271        assert_eq!(lookup(41), Some(BsdSyscall::Dup));
272        assert_eq!(lookup(46), Some(BsdSyscall::Sigaction));
273        assert_eq!(lookup(48), Some(BsdSyscall::Sigprocmask));
274        assert_eq!(lookup(65), Some(BsdSyscall::Msync));
275        assert_eq!(lookup(92), Some(BsdSyscall::Fcntl));
276        assert_eq!(lookup(116), Some(BsdSyscall::Gettimeofday));
277        assert_eq!(lookup(199), Some(BsdSyscall::Lseek));
278        assert_eq!(lookup(202), Some(BsdSyscall::Sysctl));
279        assert_eq!(lookup(266), Some(BsdSyscall::ClockGettime));
280        assert_eq!(lookup(274), Some(BsdSyscall::Sysctlbyname));
281        assert_eq!(lookup(360), Some(BsdSyscall::BsdthreadCreate));
282        assert_eq!(lookup(361), Some(BsdSyscall::BsdthreadTerminate));
283        assert_eq!(lookup(366), Some(BsdSyscall::BsdthreadRegister));
284        assert_eq!(lookup(372), Some(BsdSyscall::ThreadSelfid));
285        assert_eq!(lookup(463), Some(BsdSyscall::Openat));
286        assert_eq!(lookup(9999), None);
287    }
288
289    #[test]
290    fn name_table_stable() {
291        assert_eq!(name_of(1), Some("exit"));
292        assert_eq!(name_of(4), Some("write"));
293        assert_eq!(name_of(339), Some("fstat"));
294        assert_eq!(name_of(42), Some("pipe"));
295        assert_eq!(name_of(97), Some("socket"));
296        assert_eq!(name_of(98), Some("connect"));
297        assert_eq!(name_of(9999), None);
298    }
299
300    #[test]
301    fn exit_dispatch() {
302        let _g = lock_syscalls();
303        reset_syscall_state(256);
304        let r = dispatch(args(1, 7, 0, 0));
305        assert_eq!(r.name, "exit");
306        assert_eq!(r.outcome, TrapOutcome::Exit { code: 7 });
307        assert!(!r.error);
308    }
309
310    #[test]
311    fn unknown_returns_enosys_with_error_flag() {
312        let _g = lock_syscalls();
313        reset_syscall_state(256);
314        let r = dispatch(args(0xDEAD, 0, 0, 0));
315        assert_eq!(r.name, "unknown");
316        assert!(r.error);
317        assert_eq!(r.retval, Some(u64::try_from(ENOSYS).unwrap_or(0)));
318    }
319
320    #[test]
321    fn max_syscalls_trips() {
322        let _g = lock_syscalls();
323        reset_syscall_state(2);
324        let a = args(20, 0, 0, 0);
325        assert_eq!(dispatch(a).name, "getpid");
326        assert_eq!(dispatch(a).name, "getpid");
327        let r = dispatch(a);
328        assert_eq!(r.name, "max_syscalls");
329        assert_eq!(r.outcome, TrapOutcome::Exit { code: 1 });
330    }
331
332    #[test]
333    fn getpid_positive() {
334        let _g = lock_syscalls();
335        reset_syscall_state(256);
336        let r = dispatch(args(20, 0, 0, 0));
337        assert_eq!(r.name, "getpid");
338        assert!(!r.error);
339        assert!(r.retval.unwrap_or(0) > 0);
340    }
341
342    #[test]
343    fn getppid_positive() {
344        let _g = lock_syscalls();
345        reset_syscall_state(256);
346        let r = dispatch(args(39, 0, 0, 0));
347        assert_eq!(r.name, "getppid");
348        assert!(!r.error);
349        assert!(r.retval.unwrap_or(0) > 0);
350    }
351
352    #[test]
353    fn ok_err_helpers() {
354        let ok = SyscallResult::ok("write", 3);
355        assert!(!ok.error);
356        assert_eq!(ok.retval, Some(3));
357        let err = SyscallResult::err("write", EBADF);
358        assert!(err.error);
359        assert_eq!(err.retval, Some(9));
360    }
361
362    #[test]
363    fn mmap_anon_private_roundtrip() {
364        let _g = lock_syscalls();
365        reset_syscall_state(256);
366        registry_clear();
367        let page = host_page_size();
368        let page_u = u64::try_from(page).unwrap_or(4096);
369        let r = dispatch(SyscallArgs {
370            pc: 0,
371            number: 197,
372            x0: 0,
373            x1: page_u,
374            x2: u64::from(VM_PROT_READ | VM_PROT_WRITE),
375            x3: DARWIN_MAP_ANON | DARWIN_MAP_PRIVATE,
376            x4: u64::MAX,
377            x5: 0,
378            x6: 0,
379        });
380        assert_eq!(r.name, "mmap");
381        assert!(!r.error, "mmap failed: {:?}", r.retval);
382        let addr = r.retval.expect("addr");
383        assert_ne!(addr, u64::MAX);
384        assert_ne!(addr, 0);
385
386        let r2 = dispatch(SyscallArgs {
387            pc: 0,
388            number: 74,
389            x0: addr,
390            x1: page_u,
391            x2: u64::from(VM_PROT_READ | VM_PROT_EXECUTE),
392            x3: 0,
393            x4: 0,
394            x5: 0,
395            x6: 0,
396        });
397        assert!(!r2.error);
398
399        let r3 = dispatch(SyscallArgs {
400            pc: 0,
401            number: 73,
402            x0: addr,
403            x1: page_u,
404            x2: 0,
405            x3: 0,
406            x4: 0,
407            x5: 0,
408            x6: 0,
409        });
410        assert!(!r3.error);
411        registry_clear();
412    }
413
414    #[test]
415    fn mmap_file_backed_shared_msync() {
416        let _g = lock_syscalls();
417        reset_syscall_state(256);
418        registry_clear();
419        let host = HostPageSize::detect().expect("host");
420        let stack = map_stack(host, 256 * 1024).expect("stack");
421        register_borrowed(&stack);
422
423        let dir = std::env::temp_dir().join(format!("kh-mmap-file-{}", std::process::id()));
424        drop(std::fs::create_dir_all(&dir));
425        let path = dir.join("payload.bin");
426        std::fs::write(&path, b"KAKEMAP01\n").expect("write payload");
427
428        let base = stack.guest_addr;
429        let path_str = path.to_str().unwrap();
430        let path_va = write_cstr(base, 0x1000, path_str);
431        let open = dispatch(args(5, path_va, 2, 0)); // O_RDWR
432        assert!(!open.error, "open: {:?}", open.retval);
433        let gfd = open.retval.expect("fd");
434
435        let page = host_page_size();
436        let page_u = u64::try_from(page).unwrap();
437        let map = dispatch(SyscallArgs {
438            pc: 0,
439            number: 197,
440            x0: 0,
441            x1: page_u,
442            x2: u64::from(VM_PROT_READ | VM_PROT_WRITE),
443            x3: DARWIN_MAP_SHARED,
444            x4: gfd,
445            x5: 0,
446            x6: 0,
447        });
448        assert!(!map.error, "mmap file: {:?}", map.retval);
449        let addr = map.retval.expect("map");
450        assert_eq!(guest_slice(addr, 9), b"KAKEMAP01");
451        guest_write(addr, b"X");
452
453        let sync = dispatch(SyscallArgs {
454            pc: 0,
455            number: 65,
456            x0: addr,
457            x1: page_u,
458            x2: 0x10, // MS_SYNC
459            x3: 0,
460            x4: 0,
461            x5: 0,
462            x6: 0,
463        });
464        assert!(!sync.error, "msync: {:?}", sync.retval);
465
466        let unmap = dispatch(SyscallArgs {
467            pc: 0,
468            number: 73,
469            x0: addr,
470            x1: page_u,
471            x2: 0,
472            x3: 0,
473            x4: 0,
474            x5: 0,
475            x6: 0,
476        });
477        assert!(!unmap.error);
478        assert!(!dispatch(args(6, gfd, 0, 0)).error);
479
480        let on_disk = std::fs::read(&path).expect("reread");
481        assert_eq!(on_disk.first().copied(), Some(b'X'));
482        assert_eq!(on_disk.get(1..9), Some(b"AKEMAP01".as_slice()));
483
484        registry_clear();
485        drop(stack);
486        drop(std::fs::remove_file(&path));
487        drop(std::fs::remove_dir(&dir));
488    }
489
490    #[test]
491    fn gettimeofday_and_clock_gettime() {
492        let _g = lock_syscalls();
493        reset_syscall_state(256);
494        registry_clear();
495        let host = HostPageSize::detect().expect("host");
496        let stack = map_stack(host, 64 * 1024).expect("stack");
497        register_borrowed(&stack);
498        let base = stack.guest_addr;
499        let tv_va = guest_va(base, 0x400);
500        let ts_va = guest_va(base, 0x500);
501
502        let r = dispatch(args(116, tv_va, 0, 0));
503        assert!(!r.error, "gettimeofday: {:?}", r.retval);
504        let sec = guest_read_u64(tv_va);
505        let sec = i64::from_ne_bytes(sec.to_ne_bytes());
506        assert!(sec > 1_600_000_000, "tv_sec={sec}");
507
508        let r2 = dispatch(args(266, 0, ts_va, 0)); // CLOCK_REALTIME
509        assert!(!r2.error, "clock_gettime: {:?}", r2.retval);
510        let sec2 = guest_read_u64(ts_va);
511        let sec2 = i64::from_ne_bytes(sec2.to_ne_bytes());
512        assert!((sec2 - sec).abs() < 5);
513
514        registry_clear();
515        drop(stack);
516    }
517
518    #[test]
519    fn sysctlbyname_hw_ncpu() {
520        let _g = lock_syscalls();
521        reset_syscall_state(256);
522        registry_clear();
523        let host = HostPageSize::detect().expect("host");
524        let stack = map_stack(host, 64 * 1024).expect("stack");
525        register_borrowed(&stack);
526        let base = stack.guest_addr;
527        let key_va = write_cstr(base, 0x200, "hw.ncpu");
528        let val_va = guest_va(base, 0x300);
529        let len_va = guest_va(base, 0x310);
530        guest_write(len_va, &8_u64.to_le_bytes());
531
532        let r = dispatch(SyscallArgs {
533            pc: 0,
534            number: 274,
535            x0: key_va,
536            x1: val_va,
537            x2: len_va,
538            x3: 0,
539            x4: 0,
540            x5: 0,
541            x6: 0,
542        });
543        assert!(!r.error, "sysctlbyname: {:?}", r.retval);
544        let ncpu = guest_read_i32(val_va);
545        assert!(ncpu >= 1);
546
547        registry_clear();
548        drop(stack);
549    }
550
551    #[test]
552    fn sigprocmask_soft_roundtrip() {
553        let _g = lock_syscalls();
554        reset_syscall_state(256);
555        registry_clear();
556        let host = HostPageSize::detect().expect("host");
557        let stack = map_stack(host, 64 * 1024).expect("stack");
558        register_borrowed(&stack);
559        let base = stack.guest_addr;
560        let set_va = guest_va(base, 0x100);
561        let oset_va = guest_va(base, 0x110);
562        guest_write(set_va, &0x00FF_u32.to_le_bytes());
563        // SIG_SETMASK = 3
564        let r = dispatch(SyscallArgs {
565            pc: 0,
566            number: 48,
567            x0: 3,
568            x1: set_va,
569            x2: oset_va,
570            x3: 0,
571            x4: 0,
572            x5: 0,
573            x6: 0,
574        });
575        assert!(!r.error, "sigprocmask: {:?}", r.retval);
576
577        registry_clear();
578        drop(stack);
579    }
580
581    #[test]
582    fn write_efault_when_registry_active_and_bad_ptr() {
583        let _g = lock_syscalls();
584        reset_syscall_state(256);
585        registry_clear();
586        let host = HostPageSize::detect().expect("host");
587        let stack = map_stack(host, 64 * 1024).expect("stack");
588        register_borrowed(&stack);
589
590        let r = dispatch(args(4, 1, 0x1, 4));
591        assert_eq!(r.name, "write");
592        assert!(r.error);
593        assert_eq!(r.retval, Some(u64::try_from(EFAULT).unwrap_or(0)));
594        registry_clear();
595        drop(stack);
596    }
597
598    #[test]
599    fn open_read_lseek_fstat_dup_roundtrip() {
600        let _g = lock_syscalls();
601        reset_syscall_state(256);
602        registry_clear();
603        let host = HostPageSize::detect().expect("host");
604        let stack = map_stack(host, 256 * 1024).expect("stack");
605        register_borrowed(&stack);
606
607        let dir = std::env::temp_dir().join(format!("kh-fd-test-{}", std::process::id()));
608        drop(std::fs::create_dir_all(&dir));
609        let path = dir.join("data.txt");
610        {
611            let mut f = std::fs::File::create(&path).expect("create");
612            f.write_all(b"hello-DEF").expect("write");
613        }
614
615        let base = stack.guest_addr;
616        let path_str = path.to_str().expect("utf8 path");
617        let path_va = write_cstr(base, 0x1000, path_str);
618        let open = dispatch(args(5, path_va, 0, 0)); // O_RDONLY
619        assert!(!open.error, "open: {:?}", open.retval);
620        let gfd = open.retval.expect("fd");
621
622        let read_va = guest_va(base, 0x2000);
623        let rd = dispatch(args(3, gfd, read_va, 5)); // read 5
624        assert!(!rd.error, "read: {:?}", rd.retval);
625        assert_eq!(rd.retval, Some(5));
626        assert_eq!(guest_slice(read_va, 5), b"hello");
627
628        let seek = dispatch(args(199, gfd, 0, 0)); // lseek SET 0
629        assert!(!seek.error);
630        assert_eq!(seek.retval, Some(0));
631
632        let stat_va = guest_va(base, 0x3000);
633        let st = dispatch(args(339, gfd, stat_va, 0));
634        assert!(!st.error, "fstat: {:?}", st.retval);
635        // Darwin stat64: st_size at offset 96.
636        let size = guest_read_u64(stat_va + 96);
637        let size = i64::from_ne_bytes(size.to_ne_bytes());
638        assert_eq!(size, 9);
639
640        let dup = dispatch(args(41, gfd, 0, 0));
641        assert!(!dup.error);
642        let gfd2 = dup.retval.expect("dup fd");
643        assert_ne!(gfd2, gfd);
644
645        let fl = dispatch(args(92, gfd, 3, 0));
646        assert!(!fl.error);
647
648        assert!(!dispatch(args(6, gfd, 0, 0)).error);
649        assert!(!dispatch(args(6, gfd2, 0, 0)).error);
650
651        registry_clear();
652        drop(stack);
653        drop(std::fs::remove_file(&path));
654        drop(std::fs::remove_dir(&dir));
655    }
656
657    #[test]
658    fn openat_at_fdcwd() {
659        let _g = lock_syscalls();
660        reset_syscall_state(256);
661        registry_clear();
662        let host = HostPageSize::detect().expect("host");
663        let stack = map_stack(host, 64 * 1024).expect("stack");
664        register_borrowed(&stack);
665
666        let dir = std::env::temp_dir().join(format!("kh-openat-{}", std::process::id()));
667        drop(std::fs::create_dir_all(&dir));
668        let path = dir.join("x.txt");
669        std::fs::write(&path, b"z").expect("write");
670
671        let base = stack.guest_addr;
672        let path_str = path.to_str().unwrap();
673        let path_va = write_cstr(base, 0x800, path_str);
674        let r = dispatch(SyscallArgs {
675            pc: 0,
676            number: 463,
677            x0: u64::from_ne_bytes(i64::from(fd::AT_FDCWD).to_ne_bytes()),
678            x1: path_va,
679            x2: 0,
680            x3: 0,
681            x4: 0,
682            x5: 0,
683            x6: 0,
684        });
685        assert!(!r.error, "openat: {:?}", r.retval);
686        let gfd = r.retval.unwrap();
687        assert!(!dispatch(args(6, gfd, 0, 0)).error);
688
689        registry_clear();
690        drop(stack);
691        drop(std::fs::remove_file(&path));
692        drop(std::fs::remove_dir(&dir));
693    }
694}