1mod 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
42pub fn reset_syscall_state(max_syscalls: usize) {
44 proc_state::reset_run(max_syscalls);
45 helpers::reset_futex_stats();
46}
47
48pub(crate) fn dump_futex_stats_if_enabled() {
50 helpers::dump_futex_stats_if_enabled();
51}
52
53pub fn dispatch(args: SyscallArgs) -> SyscallResult {
55 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 match args.number {
67 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 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)); 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, 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)); 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 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)); 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)); 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)); 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 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}