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