Skip to main content

kh_runtime/syscall/
table.rs

1//! Darwin BSD syscall numbers used by the micro translator (arm64).
2
3/// Known BSD syscalls we dispatch (subset of XNU `syscalls.master`).
4#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
5pub enum BsdSyscall {
6    /// `exit`.
7    Exit,
8    /// `fork`.
9    Fork,
10    /// `vfork` (translator: same as `fork`).
11    Vfork,
12    /// `wait4` / `waitpid`.
13    Wait4,
14    /// `execve`.
15    Execve,
16    /// `dup2`.
17    Dup2,
18    /// `setsid`.
19    Setsid,
20    /// `setpgid`.
21    Setpgid,
22    /// `getpgrp`.
23    Getpgrp,
24    /// `kill`.
25    Kill,
26    /// `read`.
27    Read,
28    /// `write`.
29    Write,
30    /// `open`.
31    Open,
32    /// `close`.
33    Close,
34    /// `getpid`.
35    Getpid,
36    /// `getppid`.
37    Getppid,
38    /// `getuid`.
39    Getuid,
40    /// `geteuid`.
41    Geteuid,
42    /// `getgid`.
43    Getgid,
44    /// `getegid`.
45    Getegid,
46    /// `access`.
47    Access,
48    /// `issetugid`.
49    Issetugid,
50    /// `munmap`.
51    Munmap,
52    /// `mprotect`.
53    Mprotect,
54    /// `mmap`.
55    Mmap,
56    /// `msync`.
57    Msync,
58    /// `dup`.
59    Dup,
60    /// `fcntl`.
61    Fcntl,
62    /// `lseek`.
63    Lseek,
64    /// `pread`.
65    Pread,
66    /// `pwrite`.
67    Pwrite,
68    /// `stat` / `stat64`.
69    Stat,
70    /// `fstat` / `fstat64`.
71    Fstat,
72    /// `lstat` / `lstat64`.
73    Lstat,
74    /// `unlink`.
75    Unlink,
76    /// `link` (hard link).
77    Link,
78    /// `symlink`.
79    Symlink,
80    /// `readlink`.
81    Readlink,
82    /// `mkdir`.
83    Mkdir,
84    /// `rmdir`.
85    Rmdir,
86    /// `chdir`.
87    Chdir,
88    /// `__getcwd` (fills absolute path buffer).
89    Getcwd,
90    /// `rename`.
91    Rename,
92    /// `ftruncate`.
93    Ftruncate,
94    /// `fchmod`.
95    Fchmod,
96    /// `fsync`.
97    Fsync,
98    /// `openat`.
99    Openat,
100    /// `fstatat` / `fstatat64`.
101    Fstatat,
102    /// `gettimeofday`.
103    Gettimeofday,
104    /// `clock_gettime`.
105    ClockGettime,
106    /// `sysctl`.
107    Sysctl,
108    /// `sysctlbyname`.
109    Sysctlbyname,
110    /// `sigprocmask`.
111    Sigprocmask,
112    /// `sigaction`.
113    Sigaction,
114    /// `bsdthread_create`.
115    BsdthreadCreate,
116    /// `bsdthread_terminate`.
117    BsdthreadTerminate,
118    /// `bsdthread_register`.
119    BsdthreadRegister,
120    /// `thread_selfid`.
121    ThreadSelfid,
122    /// `pipe`.
123    Pipe,
124    /// `socket`.
125    Socket,
126    /// `socketpair`.
127    Socketpair,
128    /// `connect`.
129    Connect,
130    /// `bind`.
131    Bind,
132    /// `listen`.
133    Listen,
134    /// `accept`.
135    Accept,
136    /// `setsockopt`.
137    Setsockopt,
138    /// `getsockopt`.
139    Getsockopt,
140    /// `shutdown`.
141    Shutdown,
142    /// `sendto`.
143    Sendto,
144    /// `recvfrom`.
145    Recvfrom,
146    /// `sendmsg`.
147    Sendmsg,
148    /// `recvmsg`.
149    Recvmsg,
150    /// `send` (often libc → sendto).
151    Send,
152    /// `recv`.
153    Recv,
154    /// `poll`.
155    Poll,
156    /// `select`.
157    Select,
158    /// `getsockname`.
159    Getsockname,
160    /// `getpeername`.
161    Getpeername,
162}
163
164impl BsdSyscall {
165    /// Trace / CLI label.
166    #[must_use]
167    pub const fn name(self) -> &'static str {
168        match self {
169            Self::Exit => "exit",
170            Self::Fork => "fork",
171            Self::Vfork => "vfork",
172            Self::Wait4 => "wait4",
173            Self::Execve => "execve",
174            Self::Dup2 => "dup2",
175            Self::Setsid => "setsid",
176            Self::Setpgid => "setpgid",
177            Self::Getpgrp => "getpgrp",
178            Self::Kill => "kill",
179            Self::Read => "read",
180            Self::Write => "write",
181            Self::Open => "open",
182            Self::Close => "close",
183            Self::Getpid => "getpid",
184            Self::Getppid => "getppid",
185            Self::Getuid => "getuid",
186            Self::Geteuid => "geteuid",
187            Self::Getgid => "getgid",
188            Self::Getegid => "getegid",
189            Self::Access => "access",
190            Self::Issetugid => "issetugid",
191            Self::Munmap => "munmap",
192            Self::Mprotect => "mprotect",
193            Self::Mmap => "mmap",
194            Self::Msync => "msync",
195            Self::Dup => "dup",
196            Self::Fcntl => "fcntl",
197            Self::Lseek => "lseek",
198            Self::Pread => "pread",
199            Self::Pwrite => "pwrite",
200            Self::Stat => "stat",
201            Self::Fstat => "fstat",
202            Self::Lstat => "lstat",
203            Self::Unlink => "unlink",
204            Self::Link => "link",
205            Self::Symlink => "symlink",
206            Self::Readlink => "readlink",
207            Self::Mkdir => "mkdir",
208            Self::Rmdir => "rmdir",
209            Self::Chdir => "chdir",
210            Self::Getcwd => "__getcwd",
211            Self::Rename => "rename",
212            Self::Ftruncate => "ftruncate",
213            Self::Fchmod => "fchmod",
214            Self::Fsync => "fsync",
215            Self::Openat => "openat",
216            Self::Fstatat => "fstatat",
217            Self::Gettimeofday => "gettimeofday",
218            Self::ClockGettime => "clock_gettime",
219            Self::Sysctl => "sysctl",
220            Self::Sysctlbyname => "sysctlbyname",
221            Self::Sigprocmask => "sigprocmask",
222            Self::Sigaction => "sigaction",
223            Self::BsdthreadCreate => "bsdthread_create",
224            Self::BsdthreadTerminate => "bsdthread_terminate",
225            Self::BsdthreadRegister => "bsdthread_register",
226            Self::ThreadSelfid => "thread_selfid",
227            Self::Pipe => "pipe",
228            Self::Socket => "socket",
229            Self::Socketpair => "socketpair",
230            Self::Connect => "connect",
231            Self::Bind => "bind",
232            Self::Listen => "listen",
233            Self::Accept => "accept",
234            Self::Setsockopt => "setsockopt",
235            Self::Getsockopt => "getsockopt",
236            Self::Shutdown => "shutdown",
237            Self::Sendto => "sendto",
238            Self::Recvfrom => "recvfrom",
239            Self::Sendmsg => "sendmsg",
240            Self::Recvmsg => "recvmsg",
241            Self::Send => "send",
242            Self::Recv => "recv",
243            Self::Poll => "poll",
244            Self::Select => "select",
245            Self::Getsockname => "getsockname",
246            Self::Getpeername => "getpeername",
247        }
248    }
249
250    /// Primary Darwin syscall number.
251    #[must_use]
252    pub const fn number(self) -> u32 {
253        match self {
254            Self::Exit => 1,
255            Self::Fork => 2,
256            Self::Read => 3,
257            Self::Write => 4,
258            Self::Open => 5,
259            Self::Close => 6,
260            Self::Wait4 => 7,
261            Self::Unlink => 10,
262            Self::Execve => 59,
263            Self::Vfork => 66,
264            Self::Dup2 => 90,
265            Self::Setsid => 147,
266            Self::Setpgid => 82,
267            Self::Getpgrp => 81,
268            Self::Kill => 37,
269            Self::Link => 9,
270            Self::Getpid => 20,
271            Self::Getuid => 24,
272            Self::Geteuid => 25,
273            Self::Getgid => 47,
274            Self::Getegid => 43,
275            Self::Getppid => 39,
276            Self::Access => 33,
277            Self::Dup => 41,
278            Self::Symlink => 57,
279            Self::Readlink => 58,
280            Self::Sigaction => 46,
281            Self::Sigprocmask => 48,
282            Self::Msync => 65,
283            Self::Munmap => 73,
284            Self::Mprotect => 74,
285            Self::Fcntl => 92,
286            Self::Fsync => 95,
287            Self::Gettimeofday => 116,
288            Self::Rename => 128,
289            Self::Mkdir => 136,
290            Self::Rmdir => 137,
291            Self::Chdir => 12,
292            Self::Getcwd => 344,
293            Self::Mmap => 197,
294            Self::Lseek => 199,
295            Self::Pread => 153,
296            Self::Pwrite => 154,
297            Self::Ftruncate => 201,
298            Self::Fchmod => 124,
299            Self::Sysctl => 202,
300            Self::ClockGettime => 266,
301            Self::Sysctlbyname => 274,
302            Self::Issetugid => 327,
303            // Prefer 64-bit variants as primary; aliases in lookup.
304            Self::Stat => 338,
305            Self::Fstat => 339,
306            Self::Lstat => 340,
307            Self::BsdthreadCreate => 360,
308            Self::BsdthreadTerminate => 361,
309            Self::BsdthreadRegister => 366,
310            Self::ThreadSelfid => 372,
311            Self::Openat => 463,
312            Self::Fstatat => 470,
313            Self::Pipe => 42,
314            Self::Accept => 30,
315            Self::Recvmsg => 27,
316            Self::Sendmsg => 28,
317            Self::Recvfrom | Self::Recv => 29,
318            Self::Socket => 97,
319            Self::Socketpair => 135,
320            Self::Connect => 98,
321            Self::Bind => 104,
322            Self::Setsockopt => 105,
323            Self::Listen => 106,
324            Self::Getsockopt => 118,
325            Self::Sendto | Self::Send => 133,
326            Self::Shutdown => 134,
327            Self::Select => 93,
328            Self::Poll => 230,
329            Self::Getpeername => 31,
330            Self::Getsockname => 32,
331        }
332    }
333}
334
335/// Looks up a syscall by Darwin number (includes NOCANCEL / 64-bit aliases).
336#[must_use]
337pub const fn lookup(number: u32) -> Option<BsdSyscall> {
338    match number {
339        1 => Some(BsdSyscall::Exit),
340        2 => Some(BsdSyscall::Fork),
341        3 | 396 => Some(BsdSyscall::Read),
342        4 | 397 => Some(BsdSyscall::Write),
343        5 | 398 => Some(BsdSyscall::Open),
344        6 | 399 => Some(BsdSyscall::Close),
345        7 | 400 => Some(BsdSyscall::Wait4), // wait4 / wait4_nocancel-ish
346        9 => Some(BsdSyscall::Link),
347        10 | 401 => Some(BsdSyscall::Unlink),
348        12 => Some(BsdSyscall::Chdir),
349        20 => Some(BsdSyscall::Getpid),
350        24 => Some(BsdSyscall::Getuid),
351        25 => Some(BsdSyscall::Geteuid),
352        33 => Some(BsdSyscall::Access),
353        37 => Some(BsdSyscall::Kill),
354        39 => Some(BsdSyscall::Getppid),
355        43 => Some(BsdSyscall::Getegid),
356        47 => Some(BsdSyscall::Getgid),
357        81 => Some(BsdSyscall::Getpgrp),
358        82 => Some(BsdSyscall::Setpgid),
359        147 => Some(BsdSyscall::Setsid),
360        27 | 402 => Some(BsdSyscall::Recvmsg),  // recvmsg / nocancel
361        28 | 408 => Some(BsdSyscall::Sendmsg),  // sendmsg / nocancel-ish
362        29 | 403 => Some(BsdSyscall::Recvfrom), // recvfrom / nocancel
363        30 | 404 => Some(BsdSyscall::Accept),   // accept / nocancel
364        31 => Some(BsdSyscall::Getpeername),
365        32 => Some(BsdSyscall::Getsockname),
366        41 => Some(BsdSyscall::Dup),
367        42 | 405 => Some(BsdSyscall::Pipe), // pipe / nocancel-ish
368        46 => Some(BsdSyscall::Sigaction),
369        48 => Some(BsdSyscall::Sigprocmask),
370        57 => Some(BsdSyscall::Symlink),
371        58 => Some(BsdSyscall::Readlink),
372        59 => Some(BsdSyscall::Execve),
373        65 => Some(BsdSyscall::Msync),
374        66 => Some(BsdSyscall::Vfork),
375        73 => Some(BsdSyscall::Munmap),
376        74 => Some(BsdSyscall::Mprotect),
377        90 => Some(BsdSyscall::Dup2),
378        92 => Some(BsdSyscall::Fcntl),
379        93 | 394 => Some(BsdSyscall::Select), // select / select_nocancel
380        95 | 406 => Some(BsdSyscall::Fsync),
381        97 => Some(BsdSyscall::Socket),
382        135 => Some(BsdSyscall::Socketpair),
383        98 => Some(BsdSyscall::Connect),
384        104 => Some(BsdSyscall::Bind),
385        105 => Some(BsdSyscall::Setsockopt),
386        106 => Some(BsdSyscall::Listen),
387        116 => Some(BsdSyscall::Gettimeofday),
388        118 => Some(BsdSyscall::Getsockopt),
389        124 => Some(BsdSyscall::Fchmod),
390        128 => Some(BsdSyscall::Rename),
391        153 | 474 => Some(BsdSyscall::Pread),  // pread / pread_nocancel-ish
392        154 | 475 => Some(BsdSyscall::Pwrite), // pwrite
393        133 | 407 => Some(BsdSyscall::Sendto), // sendto / nocancel
394        134 => Some(BsdSyscall::Shutdown),
395        136 => Some(BsdSyscall::Mkdir),
396        137 => Some(BsdSyscall::Rmdir),
397        188 | 338 => Some(BsdSyscall::Stat),  // stat / stat64
398        189 | 339 => Some(BsdSyscall::Fstat), // fstat / fstat64
399        190 | 340 => Some(BsdSyscall::Lstat), // lstat / lstat64
400        197 => Some(BsdSyscall::Mmap),
401        199 => Some(BsdSyscall::Lseek),
402        201 => Some(BsdSyscall::Ftruncate),
403        202 => Some(BsdSyscall::Sysctl),
404        230 => Some(BsdSyscall::Poll),
405        266 => Some(BsdSyscall::ClockGettime),
406        274 => Some(BsdSyscall::Sysctlbyname),
407        327 => Some(BsdSyscall::Issetugid),
408        344 => Some(BsdSyscall::Getcwd),
409        360 => Some(BsdSyscall::BsdthreadCreate),
410        361 => Some(BsdSyscall::BsdthreadTerminate),
411        366 => Some(BsdSyscall::BsdthreadRegister),
412        372 => Some(BsdSyscall::ThreadSelfid),
413        463 => Some(BsdSyscall::Openat),
414        470 | 471 => Some(BsdSyscall::Fstatat), // fstatat / nocancel
415        _ => None,
416    }
417}
418
419/// Name for a raw number, if known.
420#[must_use]
421pub const fn name_of(number: u32) -> Option<&'static str> {
422    match lookup(number) {
423        Some(s) => Some(s.name()),
424        None => None,
425    }
426}
427
428/// Snapshot of the table used by unit tests / docs.
429#[must_use]
430pub fn known_syscalls() -> &'static [(u32, &'static str)] {
431    &[
432        (1, "exit"),
433        (2, "fork"),
434        (3, "read"),
435        (4, "write"),
436        (5, "open"),
437        (6, "close"),
438        (7, "wait4"),
439        (20, "getpid"),
440        (59, "execve"),
441        (66, "vfork"),
442        (90, "dup2"),
443        (24, "getuid"),
444        (25, "geteuid"),
445        (33, "access"),
446        (39, "getppid"),
447        (43, "getegid"),
448        (47, "getgid"),
449        (41, "dup"),
450        (46, "sigaction"),
451        (48, "sigprocmask"),
452        (57, "symlink"),
453        (58, "readlink"),
454        (65, "msync"),
455        (73, "munmap"),
456        (74, "mprotect"),
457        (92, "fcntl"),
458        (116, "gettimeofday"),
459        (197, "mmap"),
460        (153, "pread"),
461        (154, "pwrite"),
462        (199, "lseek"),
463        (202, "sysctl"),
464        (266, "clock_gettime"),
465        (274, "sysctlbyname"),
466        (327, "issetugid"),
467        (9, "link"),
468        (10, "unlink"),
469        (95, "fsync"),
470        (128, "rename"),
471        (12, "chdir"),
472        (136, "mkdir"),
473        (137, "rmdir"),
474        (344, "__getcwd"),
475        (201, "ftruncate"),
476        (124, "fchmod"),
477        (338, "stat"),
478        (339, "fstat"),
479        (340, "lstat"),
480        (463, "openat"),
481        (470, "fstatat"),
482        (360, "bsdthread_create"),
483        (361, "bsdthread_terminate"),
484        (366, "bsdthread_register"),
485        (372, "thread_selfid"),
486        (463, "openat"),
487        (42, "pipe"),
488        (97, "socket"),
489        (98, "connect"),
490        (104, "bind"),
491        (105, "setsockopt"),
492        (106, "listen"),
493        (118, "getsockopt"),
494        (133, "sendto"),
495        (134, "shutdown"),
496        (29, "recvfrom"),
497        (30, "accept"),
498        (93, "select"),
499        (230, "poll"),
500        (31, "getpeername"),
501        (32, "getsockname"),
502    ]
503}
504
505#[cfg(test)]
506mod tests {
507    use super::*;
508
509    #[test]
510    fn snapshot_table_consistent() {
511        for &(num, name) in known_syscalls() {
512            assert_eq!(name_of(num), Some(name));
513            assert_eq!(lookup(num).map(BsdSyscall::name), Some(name));
514        }
515    }
516
517    #[test]
518    fn nocancel_and_stat_aliases() {
519        assert_eq!(lookup(396), Some(BsdSyscall::Read));
520        assert_eq!(lookup(397), Some(BsdSyscall::Write));
521        assert_eq!(lookup(398), Some(BsdSyscall::Open));
522        assert_eq!(lookup(399), Some(BsdSyscall::Close));
523        assert_eq!(lookup(188), Some(BsdSyscall::Stat));
524        assert_eq!(lookup(189), Some(BsdSyscall::Fstat));
525    }
526}