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