1#[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
45pub 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
52pub(crate) fn dump_futex_stats_if_enabled() {
54 helpers::dump_futex_stats_if_enabled();
55}
56
57pub(crate) fn dump_boundary_stats_if_enabled() {
59 boundary_stats::dump_if_enabled();
60}
61
62pub 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 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 match args.number {
83 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 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 let mut hex = String::new();
192 if pc != 0 {
193 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)); 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, 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)); 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 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)); 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)); 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)); 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 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}