feat: syscall adaption

.vscode/launch.json

@@ -3,7 +3,7 @@
         {
             "type": "cppdbg",
             "request": "launch",
-            "name": "Launch Kernel",
+            "name": "Launch Kernel (riscv64)",
             "program": "${workspaceFolder}/build/kernel.sym",
             "args": [],
             "stopAtEntry": false,
@@ -14,11 +14,6 @@
             "miDebuggerPath": "/Users/david/.local/riscv64-unknown-elf-gcc-8.3.0-2020.04.1-x86_64-apple-darwin/bin/riscv64-unknown-elf-gdb",
             "miDebuggerServerAddress": "127.0.0.1:1234",
             "setupCommands": [
-                // {
-                //     "text": "source ${env:HOME}/.rustup/toolchains/nightly-aarch64-apple-darwin/lib/rustlib/etc/gdb_load_rust_pretty_printers.py",
-                //     "description": "Load Rust pretty printers",
-                //     "ignoreFailures": false
-                // },
                 {
                     "text": "-enable-pretty-printing",
                     "description": "Enable GDB pretty printing",
@@ -30,13 +25,13 @@
                 //     "ignoreFailures": false
                 // },
             ],
-            "preLaunchTask": "debug run",
-            "postDebugTask": "kill qemu"
+            "preLaunchTask": "debug run riscv64",
+            "postDebugTask": "kill qemu riscv64"
         },
         {
             "type": "cppdbg",
             "request": "launch",
-            "name": "Attach Kernel",
+            "name": "Attach Kernel (x86_64)",
             "program": "${workspaceFolder}/build/kernel.sym",
             "args": [],
             "stopAtEntry": false,

.vscode/tasks.json

@@ -4,9 +4,9 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "debug run",
+            "label": "debug run riscv64",
             "type": "shell",
-            "command": "make srun",
+            "command": "make srun ARCH=riscv64",
             "isBackground": true,
             "problemMatcher": [
                 {
@@ -44,7 +44,7 @@
             }
         },
         {
-            "label": "kill qemu",
+            "label": "kill qemu riscv64",
             "type": "shell",
             "command": "killall qemu-system-riscv64",
             "presentation": {
@@ -58,6 +58,62 @@
             "group": {
                 "kind": "none",
             }
+        },
+        {
+            "label": "debug run x86_64",
+            "type": "shell",
+            "command": "make srun ARCH=x86_64",
+            "isBackground": true,
+            "problemMatcher": [
+                {
+                    "owner": "rustc",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceFolder}"
+                    ],
+                    "pattern": {
+                        "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
+                        "file": 1,
+                        "line": 2,
+                        "column": 3,
+                        "severity": 4,
+                        "message": 5
+                    },
+                    "background": {
+                        "activeOnStart": true,
+                        "beginsPattern": "cargo build",
+                        "endsPattern": "qemu"
+                    }
+                }
+            ],
+            "presentation": {
+                "echo": false,
+                "reveal": "always",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": false,
+                "clear": true
+            },
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "kill qemu x86_64",
+            "type": "shell",
+            "command": "killall qemu-system-x86_64",
+            "presentation": {
+                "echo": false,
+                "reveal": "never",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": false,
+                "clear": true
+            },
+            "group": {
+                "kind": "none",
+            }
         }
     ]
 }

Cargo.lock

@@ -341,6 +341,9 @@ version = "0.1.0"
 [[package]]
 name = "posix_types"
 version = "0.1.0"
+dependencies = [
+ "cfg-if",
+]
 
 [[package]]
 name = "proc-macro2"

crates/posix_types/Cargo.toml

@@ -4,3 +4,4 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+cfg-if = "1.0"

crates/posix_types/src/constants.rs

@@ -0,0 +1,29 @@
+/// Wait for any child process
+pub const P_ALL: u32 = 0;
+
+/// Wait for a specific process by PID
+pub const P_PID: u32 = 1;
+
+/// Wait for a specific process group by PGID
+pub const P_PGID: u32 = 2;
+
+/// Wait for a specific process by PID file descriptor
+pub const P_PIDFD: u32 = 3;
+
+/// Child exited normally
+pub const CLD_EXITED: u32 = 1;
+
+/// Child was killed by a signal
+pub const CLD_KILLED: u32 = 2;
+
+/// Child terminated and dumped core
+pub const CLD_DUMPED: u32 = 3;
+
+/// Child was traced by a signal
+pub const CLD_TRAPPED: u32 = 4;
+
+/// Child was stopped by a signal
+pub const CLD_STOPPED: u32 = 5;
+
+/// Child was continued by a signal
+pub const CLD_CONTINUED: u32 = 6;

crates/posix_types/src/lib.rs

@@ -1,4 +1,6 @@
 #![no_std]
 
+pub mod constants;
 pub mod result;
 pub mod signal;
+pub mod syscall_no;

crates/posix_types/src/signal.rs

@@ -1,3 +1,5 @@
 mod sig_action;
+mod siginfo;
 
 pub use sig_action::{SigAction, TryFromSigAction};
+pub use siginfo::SigInfo;

crates/posix_types/src/signal/siginfo.rs

@@ -0,0 +1,28 @@
+#[repr(C)]
+#[derive(Default, Clone, Copy)]
+pub struct SigInfo {
+    pub si_signo: u32,       // Signal number
+    pub si_errno: u32,       // Error number
+    pub si_code: u32,        // Signal code
+    pub si_trapno: u32,      // Trap number that caused the signal (unused)
+    pub si_pid: u32,         // Sending process ID
+    pub si_uid: u32,         // Sending user ID
+    pub si_status: u32,      // Exit status or signal
+    pub si_utime: u64,       // User time consumed
+    pub si_stime: u64,       // System time consumed
+    pub si_value: u64,       // Signal value (union sigval)
+    pub si_int: u32,         // Integer value
+    pub si_ptr: usize,       // Pointer value
+    pub si_overrun: u32,     // Timer overrun count
+    pub si_timerid: u32,     // Timer ID (POSIX.1b timers)
+    pub si_addr: usize,      // Address that caused the fault
+    pub si_band: u64,        // Band event for SIGPOLL
+    pub si_fd: u32,          // File descriptor
+    pub si_addr_lsb: u16,    // Least significant bit of address
+    pub si_lower: usize,     // Lower bound when address violation occurred
+    pub si_upper: usize,     // Upper bound when address violation occurred
+    pub si_pkey: u32,        // Protection key on PTE that caused fault
+    pub si_call_addr: usize, // Address of system call instruction
+    pub si_syscall: u32,     // Number of attempted system call
+    pub si_arch: u32,        // Architecture of attempted system call
+}

crates/posix_types/src/syscall_no.rs

@@ -0,0 +1,13 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    if #[cfg(target_arch = "riscv64")] {
+        mod riscv64;
+        pub use riscv64::*;
+    } else if #[cfg(target_arch = "x86_64")] {
+        mod x86_64;
+        pub use x86_64::*;
+    } else {
+        compile_error!("Unsupported architecture for syscall numbers");
+    }
+}

crates/posix_types/src/syscall_no/riscv64.rs

@@ -0,0 +1,298 @@
+// RISC-V 64-bit syscall numbers
+pub const SYS_IO_SETUP: usize = 0;
+pub const SYS_IO_DESTROY: usize = 1;
+pub const SYS_IO_SUBMIT: usize = 2;
+pub const SYS_IO_CANCEL: usize = 3;
+pub const SYS_IO_GETEVENTS: usize = 4;
+pub const SYS_SETXATTR: usize = 5;
+pub const SYS_LSETXATTR: usize = 6;
+pub const SYS_FSETXATTR: usize = 7;
+pub const SYS_GETXATTR: usize = 8;
+pub const SYS_LGETXATTR: usize = 9;
+pub const SYS_FGETXATTR: usize = 10;
+pub const SYS_LISTXATTR: usize = 11;
+pub const SYS_LLISTXATTR: usize = 12;
+pub const SYS_FLISTXATTR: usize = 13;
+pub const SYS_REMOVEXATTR: usize = 14;
+pub const SYS_LREMOVEXATTR: usize = 15;
+pub const SYS_FREMOVEXATTR: usize = 16;
+pub const SYS_GETCWD: usize = 17;
+pub const SYS_LOOKUP_DCOOKIE: usize = 18;
+pub const SYS_EVENTFD2: usize = 19;
+pub const SYS_EPOLL_CREATE1: usize = 20;
+pub const SYS_EPOLL_CTL: usize = 21;
+pub const SYS_EPOLL_PWAIT: usize = 22;
+pub const SYS_DUP: usize = 23;
+pub const SYS_DUP3: usize = 24;
+pub const SYS_FCNTL64: usize = 25;
+pub const SYS_INOTIFY_INIT1: usize = 26;
+pub const SYS_INOTIFY_ADD_WATCH: usize = 27;
+pub const SYS_INOTIFY_RM_WATCH: usize = 28;
+pub const SYS_IOCTL: usize = 29;
+pub const SYS_IOPRIO_SET: usize = 30;
+pub const SYS_IOPRIO_GET: usize = 31;
+pub const SYS_FLOCK: usize = 32;
+pub const SYS_MKNODAT: usize = 33;
+pub const SYS_MKDIRAT: usize = 34;
+pub const SYS_UNLINKAT: usize = 35;
+pub const SYS_SYMLINKAT: usize = 36;
+pub const SYS_LINKAT: usize = 37;
+pub const SYS_RENAMEAT: usize = 38;
+pub const SYS_UMOUNT: usize = 39;
+pub const SYS_MOUNT: usize = 40;
+pub const SYS_PIVOT_ROOT: usize = 41;
+pub const SYS_NI_SYSCALL: usize = 42;
+pub const SYS_STATFS64: usize = 43;
+pub const SYS_FSTATFS64: usize = 44;
+pub const SYS_TRUNCATE64: usize = 45;
+pub const SYS_FTRUNCATE64: usize = 46;
+pub const SYS_FALLOCATE: usize = 47;
+pub const SYS_FACCESSAT: usize = 48;
+pub const SYS_CHDIR: usize = 49;
+pub const SYS_FCHDIR: usize = 50;
+pub const SYS_CHROOT: usize = 51;
+pub const SYS_FCHMOD: usize = 52;
+pub const SYS_FCHMODAT: usize = 53;
+pub const SYS_FCHOWNAT: usize = 54;
+pub const SYS_FCHOWN: usize = 55;
+pub const SYS_OPENAT: usize = 56;
+pub const SYS_CLOSE: usize = 57;
+pub const SYS_VHANGUP: usize = 58;
+pub const SYS_PIPE2: usize = 59;
+pub const SYS_QUOTACTL: usize = 60;
+pub const SYS_GETDENTS64: usize = 61;
+pub const SYS_LSEEK: usize = 62;
+pub const SYS_READ: usize = 63;
+pub const SYS_WRITE: usize = 64;
+pub const SYS_READV: usize = 65;
+pub const SYS_WRITEV: usize = 66;
+pub const SYS_PREAD64: usize = 67;
+pub const SYS_PWRITE64: usize = 68;
+pub const SYS_PREADV: usize = 69;
+pub const SYS_PWRITEV: usize = 70;
+pub const SYS_SENDFILE64: usize = 71;
+pub const SYS_PSELECT6_TIME32: usize = 72;
+pub const SYS_PPOLL_TIME32: usize = 73;
+pub const SYS_SIGNALFD4: usize = 74;
+pub const SYS_VMSPLICE: usize = 75;
+pub const SYS_SPLICE: usize = 76;
+pub const SYS_TEE: usize = 77;
+pub const SYS_READLINKAT: usize = 78;
+pub const SYS_NEWFSTATAT: usize = 79;
+pub const SYS_NEWFSTAT: usize = 80;
+pub const SYS_SYNC: usize = 81;
+pub const SYS_FSYNC: usize = 82;
+pub const SYS_FDATASYNC: usize = 83;
+pub const SYS_SYNC_FILE_RANGE2: usize = 84;
+pub const SYS_SYNC_FILE_RANGE: usize = 84;
+pub const SYS_TIMERFD_CREATE: usize = 85;
+pub const SYS_TIMERFD_SETTIME: usize = 411;
+pub const SYS_TIMERFD_GETTIME: usize = 410;
+pub const SYS_UTIMENSAT: usize = 412;
+pub const SYS_ACCT: usize = 89;
+pub const SYS_CAPGET: usize = 90;
+pub const SYS_CAPSET: usize = 91;
+pub const SYS_PERSONALITY: usize = 92;
+pub const SYS_EXIT: usize = 93;
+pub const SYS_EXIT_GROUP: usize = 94;
+pub const SYS_WAITID: usize = 95;
+pub const SYS_SET_TID_ADDRESS: usize = 96;
+pub const SYS_UNSHARE: usize = 97;
+pub const SYS_FUTEX: usize = 422;
+pub const SYS_SET_ROBUST_LIST: usize = 99;
+pub const SYS_GET_ROBUST_LIST: usize = 100;
+pub const SYS_NANOSLEEP: usize = 101;
+pub const SYS_GETITIMER: usize = 102;
+pub const SYS_SETITIMER: usize = 103;
+pub const SYS_KEXEC_LOAD: usize = 104;
+pub const SYS_INIT_MODULE: usize = 105;
+pub const SYS_DELETE_MODULE: usize = 106;
+pub const SYS_TIMER_CREATE: usize = 107;
+pub const SYS_TIMER_GETTIME: usize = 408;
+pub const SYS_TIMER_GETOVERRUN: usize = 109;
+pub const SYS_TIMER_SETTIME: usize = 409;
+pub const SYS_TIMER_DELETE: usize = 111;
+pub const SYS_CLOCK_SETTIME: usize = 404;
+pub const SYS_CLOCK_GETTIME: usize = 403;
+pub const SYS_CLOCK_GETTIME64: usize = 403;
+pub const SYS_CLOCK_GETRES: usize = 406;
+pub const SYS_CLOCK_NANOSLEEP: usize = 407;
+pub const SYS_SYSLOG: usize = 116;
+pub const SYS_PTRACE: usize = 117;
+pub const SYS_SCHED_SETPARAM: usize = 118;
+pub const SYS_SCHED_SETSCHEDULER: usize = 119;
+pub const SYS_SCHED_GETSCHEDULER: usize = 120;
+pub const SYS_SCHED_GETPARAM: usize = 121;
+pub const SYS_SCHED_SETAFFINITY: usize = 122;
+pub const SYS_SCHED_GETAFFINITY: usize = 123;
+pub const SYS_SCHED_YIELD: usize = 124;
+pub const SYS_SCHED_GET_PRIORITY_MAX: usize = 125;
+pub const SYS_SCHED_GET_PRIORITY_MIN: usize = 126;
+pub const SYS_SCHED_RR_GET_INTERVAL: usize = 423;
+pub const SYS_RESTART_SYSCALL: usize = 128;
+pub const SYS_KILL: usize = 129;
+pub const SYS_TKILL: usize = 130;
+pub const SYS_TGKILL: usize = 131;
+pub const SYS_SIGALTSTACK: usize = 132;
+pub const SYS_RT_SIGSUSPEND: usize = 133;
+pub const SYS_RT_SIGACTION: usize = 134;
+pub const SYS_RT_SIGPROCMASK: usize = 135;
+pub const SYS_RT_SIGPENDING: usize = 136;
+pub const SYS_RT_SIGTIMEDWAIT_TIME32: usize = 137;
+pub const SYS_RT_SIGQUEUEINFO: usize = 138;
+pub const SYS_SETPRIORITY: usize = 140;
+pub const SYS_GETPRIORITY: usize = 141;
+pub const SYS_REBOOT: usize = 142;
+pub const SYS_SETREGID: usize = 143;
+pub const SYS_SETGID: usize = 144;
+pub const SYS_SETREUID: usize = 145;
+pub const SYS_SETUID: usize = 146;
+pub const SYS_SETRESUID: usize = 147;
+pub const SYS_GETRESUID: usize = 148;
+pub const SYS_SETRESGID: usize = 149;
+pub const SYS_GETRESGID: usize = 150;
+pub const SYS_SETFSUID: usize = 151;
+pub const SYS_SETFSGID: usize = 152;
+pub const SYS_TIMES: usize = 153;
+pub const SYS_SETPGID: usize = 154;
+pub const SYS_GETPGID: usize = 155;
+pub const SYS_GETSID: usize = 156;
+pub const SYS_SETSID: usize = 157;
+pub const SYS_GETGROUPS: usize = 158;
+pub const SYS_SETGROUPS: usize = 159;
+pub const SYS_NEWUNAME: usize = 160;
+pub const SYS_SETHOSTNAME: usize = 161;
+pub const SYS_SETDOMAINNAME: usize = 162;
+pub const SYS_GETRLIMIT: usize = 163;
+pub const SYS_SETRLIMIT: usize = 164;
+pub const SYS_GETRUSAGE: usize = 165;
+pub const SYS_UMASK: usize = 166;
+pub const SYS_PRCTL: usize = 167;
+pub const SYS_GETCPU: usize = 168;
+pub const SYS_GETTIMEOFDAY: usize = 169;
+pub const SYS_SETTIMEOFDAY: usize = 170;
+pub const SYS_ADJTIMEX: usize = 171;
+pub const SYS_GETPID: usize = 172;
+pub const SYS_GETPPID: usize = 173;
+pub const SYS_GETUID: usize = 174;
+pub const SYS_GETEUID: usize = 175;
+pub const SYS_GETGID: usize = 176;
+pub const SYS_GETEGID: usize = 177;
+pub const SYS_GETTID: usize = 178;
+pub const SYS_SYSINFO: usize = 179;
+pub const SYS_MQ_OPEN: usize = 180;
+pub const SYS_MQ_UNLINK: usize = 181;
+pub const SYS_MQ_TIMEDSEND: usize = 418;
+pub const SYS_MQ_TIMEDRECEIVE: usize = 419;
+pub const SYS_MQ_NOTIFY: usize = 184;
+pub const SYS_MQ_GETSETATTR: usize = 185;
+pub const SYS_MSGGET: usize = 186;
+pub const SYS_MSGCTL: usize = 187;
+pub const SYS_MSGRCV: usize = 188;
+pub const SYS_MSGSND: usize = 189;
+pub const SYS_SEMGET: usize = 190;
+pub const SYS_SEMCTL: usize = 191;
+pub const SYS_SEMTIMEDOP: usize = 420;
+pub const SYS_SEMOP: usize = 193;
+pub const SYS_SHMGET: usize = 194;
+pub const SYS_SHMCTL: usize = 195;
+pub const SYS_SHMAT: usize = 196;
+pub const SYS_SHMDT: usize = 197;
+pub const SYS_SOCKET: usize = 198;
+pub const SYS_SOCKETPAIR: usize = 199;
+pub const SYS_BIND: usize = 200;
+pub const SYS_LISTEN: usize = 201;
+pub const SYS_ACCEPT: usize = 202;
+pub const SYS_CONNECT: usize = 203;
+pub const SYS_GETSOCKNAME: usize = 204;
+pub const SYS_GETPEERNAME: usize = 205;
+pub const SYS_SENDTO: usize = 206;
+pub const SYS_RECVFROM: usize = 207;
+pub const SYS_SETSOCKOPT: usize = 208;
+pub const SYS_GETSOCKOPT: usize = 209;
+pub const SYS_SHUTDOWN: usize = 210;
+pub const SYS_SENDMSG: usize = 211;
+pub const SYS_RECVMSG: usize = 212;
+pub const SYS_READAHEAD: usize = 213;
+pub const SYS_BRK: usize = 214;
+pub const SYS_MUNMAP: usize = 215;
+pub const SYS_MREMAP: usize = 216;
+pub const SYS_ADD_KEY: usize = 217;
+pub const SYS_REQUEST_KEY: usize = 218;
+pub const SYS_KEYCTL: usize = 219;
+pub const SYS_CLONE: usize = 220;
+pub const SYS_EXECVE: usize = 221;
+pub const SYS_MMAP: usize = 222;
+pub const SYS_FADVISE64_64: usize = 223;
+pub const SYS_SWAPON: usize = 224;
+pub const SYS_SWAPOFF: usize = 225;
+pub const SYS_MPROTECT: usize = 226;
+pub const SYS_MSYNC: usize = 227;
+pub const SYS_MLOCK: usize = 228;
+pub const SYS_MUNLOCK: usize = 229;
+pub const SYS_MLOCKALL: usize = 230;
+pub const SYS_MUNLOCKALL: usize = 231;
+pub const SYS_MINCORE: usize = 232;
+pub const SYS_MADVISE: usize = 233;
+pub const SYS_REMAP_FILE_PAGES: usize = 234;
+pub const SYS_MBIND: usize = 235;
+pub const SYS_GET_MEMPOLICY: usize = 236;
+pub const SYS_SET_MEMPOLICY: usize = 237;
+pub const SYS_MIGRATE_PAGES: usize = 238;
+pub const SYS_MOVE_PAGES: usize = 239;
+pub const SYS_RT_TGSIGQUEUEINFO: usize = 240;
+pub const SYS_PERF_EVENT_OPEN: usize = 241;
+pub const SYS_ACCEPT4: usize = 242;
+pub const SYS_RECVMMSG_TIME32: usize = 243;
+pub const SYS_WAIT4: usize = 260;
+pub const SYS_PRLIMIT64: usize = 261;
+pub const SYS_FANOTIFY_INIT: usize = 262;
+pub const SYS_FANOTIFY_MARK: usize = 263;
+pub const SYS_NAME_TO_HANDLE_AT: usize = 264;
+pub const SYS_OPEN_BY_HANDLE_AT: usize = 265;
+pub const SYS_CLOCK_ADJTIME: usize = 405;
+pub const SYS_SYNCFS: usize = 267;
+pub const SYS_SETNS: usize = 268;
+pub const SYS_SENDMMSG: usize = 269;
+pub const SYS_PROCESS_VM_READV: usize = 270;
+pub const SYS_PROCESS_VM_WRITEV: usize = 271;
+pub const SYS_KCMP: usize = 272;
+pub const SYS_FINIT_MODULE: usize = 273;
+pub const SYS_SCHED_SETATTR: usize = 274;
+pub const SYS_SCHED_GETATTR: usize = 275;
+pub const SYS_RENAMEAT2: usize = 276;
+pub const SYS_SECCOMP: usize = 277;
+pub const SYS_GETRANDOM: usize = 278;
+pub const SYS_MEMFD_CREATE: usize = 279;
+pub const SYS_BPF: usize = 280;
+pub const SYS_EXECVEAT: usize = 281;
+pub const SYS_USERFAULTFD: usize = 282;
+pub const SYS_MEMBARRIER: usize = 283;
+pub const SYS_MLOCK2: usize = 284;
+pub const SYS_COPY_FILE_RANGE: usize = 285;
+pub const SYS_PREADV2: usize = 286;
+pub const SYS_PWRITEV2: usize = 287;
+pub const SYS_PKEY_MPROTECT: usize = 288;
+pub const SYS_PKEY_ALLOC: usize = 289;
+pub const SYS_PKEY_FREE: usize = 290;
+pub const SYS_STATX: usize = 291;
+pub const SYS_IO_PGETEVENTS: usize = 416;
+pub const SYS_RSEQ: usize = 293;
+pub const SYS_KEXEC_FILE_LOAD: usize = 294;
+pub const SYS_PIDFD_SEND_SIGNAL: usize = 424;
+pub const SYS_IO_URING_SETUP: usize = 425;
+pub const SYS_IO_URING_ENTER: usize = 426;
+pub const SYS_IO_URING_REGISTER: usize = 427;
+pub const SYS_OPEN_TREE: usize = 428;
+pub const SYS_MOVE_MOUNT: usize = 429;
+pub const SYS_FSOPEN: usize = 430;
+pub const SYS_FSCONFIG: usize = 431;
+pub const SYS_FSMOUNT: usize = 432;
+pub const SYS_FSPICK: usize = 433;
+pub const SYS_PIDFD_OPEN: usize = 434;
+pub const SYS_CLONE3: usize = 435;
+pub const SYS_CLOSE_RANGE: usize = 436;
+pub const SYS_OPENAT2: usize = 437;
+pub const SYS_PIDFD_GETFD: usize = 438;
+pub const SYS_FACCESSAT2: usize = 439;
+pub const SYS_PROCESS_MADVISE: usize = 440;

crates/posix_types/src/syscall_no/x86_64.rs

@@ -0,0 +1,433 @@
+// i386 (32-bit x86) syscall numbers - used even on x86_64 builds
+pub const SYS_RESTART_SYSCALL: usize = 0;
+pub const SYS_EXIT: usize = 1;
+pub const SYS_FORK: usize = 2;
+pub const SYS_READ: usize = 3;
+pub const SYS_WRITE: usize = 4;
+pub const SYS_OPEN: usize = 5;
+pub const SYS_CLOSE: usize = 6;
+pub const SYS_WAITPID: usize = 7;
+pub const SYS_CREAT: usize = 8;
+pub const SYS_LINK: usize = 9;
+pub const SYS_UNLINK: usize = 10;
+pub const SYS_EXECVE: usize = 11;
+pub const SYS_CHDIR: usize = 12;
+pub const SYS_TIME: usize = 13;
+pub const SYS_MKNOD: usize = 14;
+pub const SYS_CHMOD: usize = 15;
+pub const SYS_LCHOWN: usize = 16;
+pub const SYS_BREAK: usize = 17;
+pub const SYS_OLDSTAT: usize = 18;
+pub const SYS_LSEEK: usize = 19;
+pub const SYS_GETPID: usize = 20;
+pub const SYS_MOUNT: usize = 21;
+pub const SYS_UMOUNT: usize = 22;
+pub const SYS_SETUID: usize = 23;
+pub const SYS_GETUID: usize = 24;
+pub const SYS_STIME: usize = 25;
+pub const SYS_PTRACE: usize = 26;
+pub const SYS_ALARM: usize = 27;
+pub const SYS_OLDFSTAT: usize = 28;
+pub const SYS_PAUSE: usize = 29;
+pub const SYS_UTIME: usize = 30;
+pub const SYS_STTY: usize = 31;
+pub const SYS_GTTY: usize = 32;
+pub const SYS_ACCESS: usize = 33;
+pub const SYS_NICE: usize = 34;
+pub const SYS_FTIME: usize = 35;
+pub const SYS_SYNC: usize = 36;
+pub const SYS_KILL: usize = 37;
+pub const SYS_RENAME: usize = 38;
+pub const SYS_MKDIR: usize = 39;
+pub const SYS_RMDIR: usize = 40;
+pub const SYS_DUP: usize = 41;
+pub const SYS_PIPE: usize = 42;
+pub const SYS_TIMES: usize = 43;
+pub const SYS_PROF: usize = 44;
+pub const SYS_BRK: usize = 45;
+pub const SYS_SETGID: usize = 46;
+pub const SYS_GETGID: usize = 47;
+pub const SYS_SIGNAL: usize = 48;
+pub const SYS_GETEUID: usize = 49;
+pub const SYS_GETEGID: usize = 50;
+pub const SYS_ACCT: usize = 51;
+pub const SYS_UMOUNT2: usize = 52;
+pub const SYS_LOCK: usize = 53;
+pub const SYS_IOCTL: usize = 54;
+pub const SYS_FCNTL: usize = 55;
+pub const SYS_MPX: usize = 56;
+pub const SYS_SETPGID: usize = 57;
+pub const SYS_ULIMIT: usize = 58;
+pub const SYS_OLDOLDUNAME: usize = 59;
+pub const SYS_UMASK: usize = 60;
+pub const SYS_CHROOT: usize = 61;
+pub const SYS_USTAT: usize = 62;
+pub const SYS_DUP2: usize = 63;
+pub const SYS_GETPPID: usize = 64;
+pub const SYS_GETPGRP: usize = 65;
+pub const SYS_SETSID: usize = 66;
+pub const SYS_SIGACTION: usize = 67;
+pub const SYS_SGETMASK: usize = 68;
+pub const SYS_SSETMASK: usize = 69;
+pub const SYS_SETREUID: usize = 70;
+pub const SYS_SETREGID: usize = 71;
+pub const SYS_SIGSUSPEND: usize = 72;
+pub const SYS_SIGPENDING: usize = 73;
+pub const SYS_SETHOSTNAME: usize = 74;
+pub const SYS_SETRLIMIT: usize = 75;
+pub const SYS_GETRLIMIT: usize = 76;
+pub const SYS_GETRUSAGE: usize = 77;
+pub const SYS_GETTIMEOFDAY: usize = 78;
+pub const SYS_SETTIMEOFDAY: usize = 79;
+pub const SYS_GETGROUPS: usize = 80;
+pub const SYS_SETGROUPS: usize = 81;
+pub const SYS_SELECT: usize = 82;
+pub const SYS_SYMLINK: usize = 83;
+pub const SYS_OLDLSTAT: usize = 84;
+pub const SYS_READLINK: usize = 85;
+pub const SYS_USELIB: usize = 86;
+pub const SYS_SWAPON: usize = 87;
+pub const SYS_REBOOT: usize = 88;
+pub const SYS_READDIR: usize = 89;
+pub const SYS_MMAP: usize = 90;
+pub const SYS_MUNMAP: usize = 91;
+pub const SYS_TRUNCATE: usize = 92;
+pub const SYS_FTRUNCATE: usize = 93;
+pub const SYS_FCHMOD: usize = 94;
+pub const SYS_FCHOWN: usize = 95;
+pub const SYS_GETPRIORITY: usize = 96;
+pub const SYS_SETPRIORITY: usize = 97;
+pub const SYS_PROFIL: usize = 98;
+pub const SYS_STATFS: usize = 99;
+pub const SYS_FSTATFS: usize = 100;
+pub const SYS_IOPERM: usize = 101;
+pub const SYS_SOCKETCALL: usize = 102;
+pub const SYS_SYSLOG: usize = 103;
+pub const SYS_SETITIMER: usize = 104;
+pub const SYS_GETITIMER: usize = 105;
+pub const SYS_STAT: usize = 106;
+pub const SYS_LSTAT: usize = 107;
+pub const SYS_FSTAT: usize = 108;
+pub const SYS_OLDUNAME: usize = 109;
+pub const SYS_IOPL: usize = 110;
+pub const SYS_VHANGUP: usize = 111;
+pub const SYS_IDLE: usize = 112;
+pub const SYS_VM86OLD: usize = 113;
+pub const SYS_WAIT4: usize = 114;
+pub const SYS_SWAPOFF: usize = 115;
+pub const SYS_SYSINFO: usize = 116;
+pub const SYS_IPC: usize = 117;
+pub const SYS_FSYNC: usize = 118;
+pub const SYS_SIGRETURN: usize = 119;
+pub const SYS_CLONE: usize = 120;
+pub const SYS_SETDOMAINNAME: usize = 121;
+pub const SYS_NEWUNAME: usize = 122;
+pub const SYS_MODIFY_LDT: usize = 123;
+pub const SYS_ADJTIMEX: usize = 124;
+pub const SYS_MPROTECT: usize = 125;
+pub const SYS_SIGPROCMASK: usize = 126;
+pub const SYS_CREATE_MODULE: usize = 127;
+pub const SYS_INIT_MODULE: usize = 128;
+pub const SYS_DELETE_MODULE: usize = 129;
+pub const SYS_GET_KERNEL_SYMS: usize = 130;
+pub const SYS_QUOTACTL: usize = 131;
+pub const SYS_GETPGID: usize = 132;
+pub const SYS_FCHDIR: usize = 133;
+pub const SYS_BDFLUSH: usize = 134;
+pub const SYS_SYSFS: usize = 135;
+pub const SYS_PERSONALITY: usize = 136;
+pub const SYS_AFS_SYSCALL: usize = 137;
+pub const SYS_SETFSUID: usize = 138;
+pub const SYS_SETFSGID: usize = 139;
+pub const SYS_LLSEEK: usize = 140;
+pub const SYS_GETDENTS: usize = 141;
+pub const SYS__NEWSELECT: usize = 142;
+pub const SYS_FLOCK: usize = 143;
+pub const SYS_MSYNC: usize = 144;
+pub const SYS_READV: usize = 145;
+pub const SYS_WRITEV: usize = 146;
+pub const SYS_GETSID: usize = 147;
+pub const SYS_FDATASYNC: usize = 148;
+pub const SYS__SYSCTL: usize = 149;
+pub const SYS_MLOCK: usize = 150;
+pub const SYS_MUNLOCK: usize = 151;
+pub const SYS_MLOCKALL: usize = 152;
+pub const SYS_MUNLOCKALL: usize = 153;
+pub const SYS_SCHED_SETPARAM: usize = 154;
+pub const SYS_SCHED_GETPARAM: usize = 155;
+pub const SYS_SCHED_SETSCHEDULER: usize = 156;
+pub const SYS_SCHED_GETSCHEDULER: usize = 157;
+pub const SYS_SCHED_YIELD: usize = 158;
+pub const SYS_SCHED_GET_PRIORITY_MAX: usize = 159;
+pub const SYS_SCHED_GET_PRIORITY_MIN: usize = 160;
+pub const SYS_SCHED_RR_GET_INTERVAL: usize = 161;
+pub const SYS_NANOSLEEP: usize = 162;
+pub const SYS_MREMAP: usize = 163;
+pub const SYS_SETRESUID: usize = 164;
+pub const SYS_GETRESUID: usize = 165;
+pub const SYS_VM86: usize = 166;
+pub const SYS_QUERY_MODULE: usize = 167;
+pub const SYS_POLL: usize = 168;
+pub const SYS_NFSSERVCTL: usize = 169;
+pub const SYS_SETRESGID: usize = 170;
+pub const SYS_GETRESGID: usize = 171;
+pub const SYS_PRCTL: usize = 172;
+pub const SYS_RT_SIGRETURN: usize = 173;
+pub const SYS_RT_SIGACTION: usize = 174;
+pub const SYS_RT_SIGPROCMASK: usize = 175;
+pub const SYS_RT_SIGPENDING: usize = 176;
+pub const SYS_RT_SIGTIMEDWAIT: usize = 177;
+pub const SYS_RT_SIGQUEUEINFO: usize = 178;
+pub const SYS_RT_SIGSUSPEND: usize = 179;
+pub const SYS_PREAD64: usize = 180;
+pub const SYS_PWRITE64: usize = 181;
+pub const SYS_CHOWN: usize = 182;
+pub const SYS_GETCWD: usize = 183;
+pub const SYS_CAPGET: usize = 184;
+pub const SYS_CAPSET: usize = 185;
+pub const SYS_SIGALTSTACK: usize = 186;
+pub const SYS_SENDFILE: usize = 187;
+pub const SYS_GETPMSG: usize = 188;
+pub const SYS_PUTPMSG: usize = 189;
+pub const SYS_VFORK: usize = 190;
+pub const SYS_UGETRLIMIT: usize = 191;
+pub const SYS_MMAP2: usize = 192;
+pub const SYS_TRUNCATE64: usize = 193;
+pub const SYS_FTRUNCATE64: usize = 194;
+pub const SYS_STAT64: usize = 195;
+pub const SYS_LSTAT64: usize = 196;
+pub const SYS_FSTAT64: usize = 197;
+pub const SYS_LCHOWN32: usize = 198;
+pub const SYS_GETUID32: usize = 199;
+pub const SYS_GETGID32: usize = 200;
+pub const SYS_GETEUID32: usize = 201;
+pub const SYS_GETEGID32: usize = 202;
+pub const SYS_SETREUID32: usize = 203;
+pub const SYS_SETREGID32: usize = 204;
+pub const SYS_GETGROUPS32: usize = 205;
+pub const SYS_SETGROUPS32: usize = 206;
+pub const SYS_FCHOWN32: usize = 207;
+pub const SYS_SETRESUID32: usize = 208;
+pub const SYS_GETRESUID32: usize = 209;
+pub const SYS_SETRESGID32: usize = 210;
+pub const SYS_GETRESGID32: usize = 211;
+pub const SYS_CHOWN32: usize = 212;
+pub const SYS_SETUID32: usize = 213;
+pub const SYS_SETGID32: usize = 214;
+pub const SYS_SETFSUID32: usize = 215;
+pub const SYS_SETFSGID32: usize = 216;
+pub const SYS_PIVOT_ROOT: usize = 217;
+pub const SYS_MINCORE: usize = 218;
+pub const SYS_MADVISE: usize = 219;
+pub const SYS_GETDENTS64: usize = 220;
+pub const SYS_FCNTL64: usize = 221;
+pub const SYS_GETTID: usize = 224;
+pub const SYS_READAHEAD: usize = 225;
+pub const SYS_SETXATTR: usize = 226;
+pub const SYS_LSETXATTR: usize = 227;
+pub const SYS_FSETXATTR: usize = 228;
+pub const SYS_GETXATTR: usize = 229;
+pub const SYS_LGETXATTR: usize = 230;
+pub const SYS_FGETXATTR: usize = 231;
+pub const SYS_LISTXATTR: usize = 232;
+pub const SYS_LLISTXATTR: usize = 233;
+pub const SYS_FLISTXATTR: usize = 234;
+pub const SYS_REMOVEXATTR: usize = 235;
+pub const SYS_LREMOVEXATTR: usize = 236;
+pub const SYS_FREMOVEXATTR: usize = 237;
+pub const SYS_TKILL: usize = 238;
+pub const SYS_SENDFILE64: usize = 239;
+pub const SYS_FUTEX: usize = 240;
+pub const SYS_SCHED_SETAFFINITY: usize = 241;
+pub const SYS_SCHED_GETAFFINITY: usize = 242;
+pub const SYS_SET_THREAD_AREA: usize = 243;
+pub const SYS_GET_THREAD_AREA: usize = 244;
+pub const SYS_IO_SETUP: usize = 245;
+pub const SYS_IO_DESTROY: usize = 246;
+pub const SYS_IO_GETEVENTS: usize = 247;
+pub const SYS_IO_SUBMIT: usize = 248;
+pub const SYS_IO_CANCEL: usize = 249;
+pub const SYS_FADVISE64: usize = 250;
+pub const SYS_EXIT_GROUP: usize = 252;
+pub const SYS_LOOKUP_DCOOKIE: usize = 253;
+pub const SYS_EPOLL_CREATE: usize = 254;
+pub const SYS_EPOLL_CTL: usize = 255;
+pub const SYS_EPOLL_WAIT: usize = 256;
+pub const SYS_REMAP_FILE_PAGES: usize = 257;
+pub const SYS_SET_TID_ADDRESS: usize = 258;
+pub const SYS_TIMER_CREATE: usize = 259;
+pub const SYS_TIMER_SETTIME: usize = 260;
+pub const SYS_TIMER_GETTIME: usize = 261;
+pub const SYS_TIMER_GETOVERRUN: usize = 262;
+pub const SYS_TIMER_DELETE: usize = 263;
+pub const SYS_CLOCK_SETTIME: usize = 264;
+pub const SYS_CLOCK_GETTIME: usize = 265;
+pub const SYS_CLOCK_GETRES: usize = 266;
+pub const SYS_CLOCK_NANOSLEEP: usize = 267;
+pub const SYS_STATFS64: usize = 268;
+pub const SYS_FSTATFS64: usize = 269;
+pub const SYS_TGKILL: usize = 270;
+pub const SYS_UTIMES: usize = 271;
+pub const SYS_FADVISE64_64: usize = 272;
+pub const SYS_VSERVER: usize = 273;
+pub const SYS_MBIND: usize = 274;
+pub const SYS_GET_MEMPOLICY: usize = 275;
+pub const SYS_SET_MEMPOLICY: usize = 276;
+pub const SYS_MQ_OPEN: usize = 277;
+pub const SYS_MQ_UNLINK: usize = 278;
+pub const SYS_MQ_TIMEDSEND: usize = 279;
+pub const SYS_MQ_TIMEDRECEIVE: usize = 280;
+pub const SYS_MQ_NOTIFY: usize = 281;
+pub const SYS_MQ_GETSETATTR: usize = 282;
+pub const SYS_KEXEC_LOAD: usize = 283;
+pub const SYS_WAITID: usize = 284;
+pub const SYS_ADD_KEY: usize = 286;
+pub const SYS_REQUEST_KEY: usize = 287;
+pub const SYS_KEYCTL: usize = 288;
+pub const SYS_IOPRIO_SET: usize = 289;
+pub const SYS_IOPRIO_GET: usize = 290;
+pub const SYS_INOTIFY_INIT: usize = 291;
+pub const SYS_INOTIFY_ADD_WATCH: usize = 292;
+pub const SYS_INOTIFY_RM_WATCH: usize = 293;
+pub const SYS_MIGRATE_PAGES: usize = 294;
+pub const SYS_OPENAT: usize = 295;
+pub const SYS_MKDIRAT: usize = 296;
+pub const SYS_MKNODAT: usize = 297;
+pub const SYS_FCHOWNAT: usize = 298;
+pub const SYS_FUTIMESAT: usize = 299;
+pub const SYS_FSTATAT64: usize = 300;
+pub const SYS_UNLINKAT: usize = 301;
+pub const SYS_RENAMEAT: usize = 302;
+pub const SYS_LINKAT: usize = 303;
+pub const SYS_SYMLINKAT: usize = 304;
+pub const SYS_READLINKAT: usize = 305;
+pub const SYS_FCHMODAT: usize = 306;
+pub const SYS_FACCESSAT: usize = 307;
+pub const SYS_PSELECT6: usize = 308;
+pub const SYS_PPOLL: usize = 309;
+pub const SYS_UNSHARE: usize = 310;
+pub const SYS_SET_ROBUST_LIST: usize = 311;
+pub const SYS_GET_ROBUST_LIST: usize = 312;
+pub const SYS_SPLICE: usize = 313;
+pub const SYS_SYNC_FILE_RANGE: usize = 314;
+pub const SYS_TEE: usize = 315;
+pub const SYS_VMSPLICE: usize = 316;
+pub const SYS_MOVE_PAGES: usize = 317;
+pub const SYS_GETCPU: usize = 318;
+pub const SYS_EPOLL_PWAIT: usize = 319;
+pub const SYS_UTIMENSAT: usize = 320;
+pub const SYS_SIGNALFD: usize = 321;
+pub const SYS_TIMERFD_CREATE: usize = 322;
+pub const SYS_EVENTFD: usize = 323;
+pub const SYS_FALLOCATE: usize = 324;
+pub const SYS_TIMERFD_SETTIME: usize = 325;
+pub const SYS_TIMERFD_GETTIME: usize = 326;
+pub const SYS_SIGNALFD4: usize = 327;
+pub const SYS_EVENTFD2: usize = 328;
+pub const SYS_EPOLL_CREATE1: usize = 329;
+pub const SYS_DUP3: usize = 330;
+pub const SYS_PIPE2: usize = 331;
+pub const SYS_INOTIFY_INIT1: usize = 332;
+pub const SYS_PREADV: usize = 333;
+pub const SYS_PWRITEV: usize = 334;
+pub const SYS_RT_TGSIGQUEUEINFO: usize = 335;
+pub const SYS_PERF_EVENT_OPEN: usize = 336;
+pub const SYS_RECVMMSG: usize = 337;
+pub const SYS_FANOTIFY_INIT: usize = 338;
+pub const SYS_FANOTIFY_MARK: usize = 339;
+pub const SYS_PRLIMIT64: usize = 340;
+pub const SYS_NAME_TO_HANDLE_AT: usize = 341;
+pub const SYS_OPEN_BY_HANDLE_AT: usize = 342;
+pub const SYS_CLOCK_ADJTIME: usize = 343;
+pub const SYS_SYNCFS: usize = 344;
+pub const SYS_SENDMMSG: usize = 345;
+pub const SYS_SETNS: usize = 346;
+pub const SYS_PROCESS_VM_READV: usize = 347;
+pub const SYS_PROCESS_VM_WRITEV: usize = 348;
+pub const SYS_KCMP: usize = 349;
+pub const SYS_FINIT_MODULE: usize = 350;
+pub const SYS_SCHED_SETATTR: usize = 351;
+pub const SYS_SCHED_GETATTR: usize = 352;
+pub const SYS_RENAMEAT2: usize = 353;
+pub const SYS_SECCOMP: usize = 354;
+pub const SYS_GETRANDOM: usize = 355;
+pub const SYS_MEMFD_CREATE: usize = 356;
+pub const SYS_BPF: usize = 357;
+pub const SYS_EXECVEAT: usize = 358;
+pub const SYS_SOCKET: usize = 359;
+pub const SYS_SOCKETPAIR: usize = 360;
+pub const SYS_BIND: usize = 361;
+pub const SYS_CONNECT: usize = 362;
+pub const SYS_LISTEN: usize = 363;
+pub const SYS_ACCEPT4: usize = 364;
+pub const SYS_GETSOCKOPT: usize = 365;
+pub const SYS_SETSOCKOPT: usize = 366;
+pub const SYS_GETSOCKNAME: usize = 367;
+pub const SYS_GETPEERNAME: usize = 368;
+pub const SYS_SENDTO: usize = 369;
+pub const SYS_SENDMSG: usize = 370;
+pub const SYS_RECVFROM: usize = 371;
+pub const SYS_RECVMSG: usize = 372;
+pub const SYS_SHUTDOWN: usize = 373;
+pub const SYS_USERFAULTFD: usize = 374;
+pub const SYS_MEMBARRIER: usize = 375;
+pub const SYS_MLOCK2: usize = 376;
+pub const SYS_COPY_FILE_RANGE: usize = 377;
+pub const SYS_PREADV2: usize = 378;
+pub const SYS_PWRITEV2: usize = 379;
+pub const SYS_PKEY_MPROTECT: usize = 380;
+pub const SYS_PKEY_ALLOC: usize = 381;
+pub const SYS_PKEY_FREE: usize = 382;
+pub const SYS_STATX: usize = 383;
+pub const SYS_ARCH_PRCTL: usize = 384;
+pub const SYS_IO_PGETEVENTS: usize = 385;
+pub const SYS_RSEQ: usize = 386;
+pub const SYS_SEMGET: usize = 393;
+pub const SYS_SEMCTL: usize = 394;
+pub const SYS_SHMGET: usize = 395;
+pub const SYS_SHMCTL: usize = 396;
+pub const SYS_SHMAT: usize = 397;
+pub const SYS_SHMDT: usize = 398;
+pub const SYS_MSGGET: usize = 399;
+pub const SYS_MSGSND: usize = 400;
+pub const SYS_MSGRCV: usize = 401;
+pub const SYS_MSGCTL: usize = 402;
+pub const SYS_CLOCK_GETTIME64: usize = 403;
+pub const SYS_CLOCK_SETTIME64: usize = 404;
+pub const SYS_CLOCK_ADJTIME64: usize = 405;
+pub const SYS_CLOCK_GETRES_TIME64: usize = 406;
+pub const SYS_CLOCK_NANOSLEEP_TIME64: usize = 407;
+pub const SYS_TIMER_GETTIME64: usize = 408;
+pub const SYS_TIMER_SETTIME64: usize = 409;
+pub const SYS_TIMERFD_GETTIME64: usize = 410;
+pub const SYS_TIMERFD_SETTIME64: usize = 411;
+pub const SYS_UTIMENSAT_TIME64: usize = 412;
+pub const SYS_PSELECT6_TIME64: usize = 413;
+pub const SYS_PPOLL_TIME64: usize = 414;
+pub const SYS_IO_PGETEVENTS_TIME64: usize = 416;
+pub const SYS_RECVMMSG_TIME64: usize = 417;
+pub const SYS_MQ_TIMEDSEND_TIME64: usize = 418;
+pub const SYS_MQ_TIMEDRECEIVE_TIME64: usize = 419;
+pub const SYS_SEMTIMEDOP_TIME64: usize = 420;
+pub const SYS_RT_SIGTIMEDWAIT_TIME64: usize = 421;
+pub const SYS_FUTEX_TIME64: usize = 422;
+pub const SYS_SCHED_RR_GET_INTERVAL_TIME64: usize = 423;
+pub const SYS_PIDFD_SEND_SIGNAL: usize = 424;
+pub const SYS_IO_URING_SETUP: usize = 425;
+pub const SYS_IO_URING_ENTER: usize = 426;
+pub const SYS_IO_URING_REGISTER: usize = 427;
+pub const SYS_OPEN_TREE: usize = 428;
+pub const SYS_MOVE_MOUNT: usize = 429;
+pub const SYS_FSOPEN: usize = 430;
+pub const SYS_FSCONFIG: usize = 431;
+pub const SYS_FSMOUNT: usize = 432;
+pub const SYS_FSPICK: usize = 433;
+pub const SYS_PIDFD_OPEN: usize = 434;
+pub const SYS_CLONE3: usize = 435;
+pub const SYS_CLOSE_RANGE: usize = 436;
+pub const SYS_OPENAT2: usize = 437;
+pub const SYS_PIDFD_GETFD: usize = 438;
+pub const SYS_FACCESSAT2: usize = 439;
+pub const SYS_PROCESS_MADVISE: usize = 440;
+pub const SYS_EPOLL_PWAIT2: usize = 441;
+pub const SYS_MOUNT_SETATTR: usize = 442;

macros/src/lib.rs

@@ -2,20 +2,14 @@ extern crate proc_macro;
 
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
-use syn::{parse2, FnArg, Ident, ItemFn, LitInt, LitStr};
+use syn::{parse2, FnArg, Ident, ItemFn, LitStr};
 
 fn define_syscall_impl(attrs: TokenStream, item: TokenStream) -> TokenStream {
     if attrs.is_empty() {
         panic!("`define_syscall` attribute should take one argument: `syscall_no`");
     }
 
-    let syscall_no = parse2::<LitInt>(attrs).expect("Invalid syscall number");
-    let syscall_no = syscall_no
-        .base10_parse::<usize>()
-        .expect("Invalid syscall number");
-
-    assert!(syscall_no < 512, "Syscall number must be less than 512");
-
+    let syscall_no = parse2::<Ident>(attrs).expect("Invalid syscall number");
     let item = parse2::<ItemFn>(item).unwrap();
 
     let attrs = item.attrs;
@@ -57,7 +51,7 @@ fn define_syscall_impl(attrs: TokenStream, item: TokenStream) -> TokenStream {
 
     let helper_fn = Ident::new(&format!("_do_syscall_{}", syscall_name), Span::call_site());
     let helper_fn_pointer = Ident::new(
-        &format!("_SYSCALL_ENTRY_{:03}", syscall_no),
+        &format!("_SYSCALL_ENTRY_{}", syscall_name.to_string().to_uppercase()),
         Span::call_site(),
     );
 

pretty-print.py

@@ -185,5 +185,4 @@ gdb.execute('skip -rfu ^alloc::([a-zA-Z0-9_]+::)*[a-zA-Z0-9_<>]+')
 gdb.execute('skip -rfu ^std::([a-zA-Z0-9_]+::)*[a-zA-Z0-9_<>]+')
 gdb.execute('skip -rfu "^gbos_rust_part::sync::lock::Lock<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>::new<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>"')
 gdb.execute('skip -rfu "^gbos_rust_part::sync::locked::Locked<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>::new<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>"')
-# gdb.execute('source ' + environ['HOME'] + '/.rustup/toolchains/nightly-aarch64-apple-darwin/lib/rustlib/etc/gdb_load_rust_pretty_printers.py')
 gdb.pretty_printers.append(build_pretty_printer)

src/kernel/syscall/file_rw.rs

@@ -1,7 +1,8 @@
 use crate::kernel::constants::{
-    AT_FDCWD, AT_STATX_SYNC_AS_STAT, AT_STATX_SYNC_TYPE, AT_SYMLINK_NOFOLLOW, EBADF, SEEK_CUR,
-    SEEK_END, SEEK_SET, S_IFBLK, S_IFCHR,
+    AT_FDCWD, AT_STATX_SYNC_AS_STAT, AT_STATX_SYNC_TYPE, AT_SYMLINK_NOFOLLOW, EBADF, ENOTDIR,
+    SEEK_CUR, SEEK_END, SEEK_SET, S_IFBLK, S_IFCHR,
 };
+use crate::kernel::task::Thread;
 use crate::{
     io::{Buffer, BufferFill},
     kernel::{
@@ -18,8 +19,38 @@ use crate::{
     path::Path,
     prelude::*,
 };
+use alloc::sync::Arc;
 use core::mem::MaybeUninit;
 use eonix_runtime::task::Task;
+use posix_types::syscall_no::*;
+
+fn dentry_from(
+    thread: &Thread,
+    dirfd: u32,
+    pathname: *const u8,
+    follow_symlink: bool,
+) -> KResult<Arc<Dentry>> {
+    const _AT_FDCWD: u32 = AT_FDCWD as u32;
+    let path = UserString::new(pathname)?;
+
+    match (path.as_cstr().to_bytes_with_nul()[0], dirfd) {
+        (b'/', _) | (_, _AT_FDCWD) => {
+            let path = Path::new(path.as_cstr().to_bytes())?;
+            Dentry::open(&thread.fs_context, path, follow_symlink)
+        }
+        (0, dirfd) => {
+            let dir_file = thread.files.get(dirfd).ok_or(EBADF)?;
+            dir_file.as_path().ok_or(EBADF).cloned()
+        }
+        (_, dirfd) => {
+            let path = Path::new(path.as_cstr().to_bytes())?;
+            let dir_file = thread.files.get(dirfd).ok_or(EBADF)?;
+            let dir_dentry = dir_file.as_path().ok_or(ENOTDIR)?;
+
+            Dentry::open_at(&thread.fs_context, dir_dentry, path, follow_symlink)
+        }
+    }
+}
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -56,21 +87,22 @@ pub struct StatX {
     pub stx_dio_alignment: [u64; 13usize],
 }
 
-#[eonix_macros::define_syscall(0x03)]
+#[eonix_macros::define_syscall(SYS_READ)]
 fn read(fd: u32, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
 
     Task::block_on(thread.files.get(fd).ok_or(EBADF)?.read(&mut buffer))
 }
 
-#[eonix_macros::define_syscall(0x04)]
+#[eonix_macros::define_syscall(SYS_WRITE)]
 fn write(fd: u32, buffer: *const u8, count: usize) -> KResult<usize> {
     let data = unsafe { core::slice::from_raw_parts(buffer, count) };
 
     Task::block_on(thread.files.get(fd).ok_or(EBADF)?.write(data))
 }
 
-#[eonix_macros::define_syscall(0x05)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_OPEN)]
 fn open(path: *const u8, flags: u32, mode: u32) -> KResult<u32> {
     let path = UserString::new(path)?;
     let path = Path::new(path.as_cstr().to_bytes())?;
@@ -80,22 +112,23 @@ fn open(path: *const u8, flags: u32, mode: u32) -> KResult<u32> {
     thread.files.open(&thread.fs_context, path, flags, mode)
 }
 
-#[eonix_macros::define_syscall(0x06)]
+#[eonix_macros::define_syscall(SYS_CLOSE)]
 fn close(fd: u32) -> KResult<()> {
     thread.files.close(fd)
 }
 
-#[eonix_macros::define_syscall(0x29)]
+#[eonix_macros::define_syscall(SYS_DUP)]
 fn dup(fd: u32) -> KResult<u32> {
     thread.files.dup(fd)
 }
 
-#[eonix_macros::define_syscall(0x3f)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_DUP2)]
 fn dup2(old_fd: u32, new_fd: u32) -> KResult<u32> {
     thread.files.dup_to(old_fd, new_fd, 0)
 }
 
-#[eonix_macros::define_syscall(0x14b)]
+#[eonix_macros::define_syscall(SYS_PIPE2)]
 fn pipe2(pipe_fd: *mut [u32; 2], flags: u32) -> KResult<()> {
     let mut buffer = UserBuffer::new(pipe_fd as *mut u8, core::mem::size_of::<[u32; 2]>())?;
     let (read_fd, write_fd) = thread.files.pipe(flags)?;
@@ -103,12 +136,14 @@ fn pipe2(pipe_fd: *mut [u32; 2], flags: u32) -> KResult<()> {
     buffer.copy(&[read_fd, write_fd])?.ok_or(EFAULT)
 }
 
-#[eonix_macros::define_syscall(0x2a)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_PIPE)]
 fn pipe(pipe_fd: *mut [u32; 2]) -> KResult<()> {
     sys_pipe2(thread, pipe_fd, 0)
 }
 
-#[eonix_macros::define_syscall(0x8d)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_GETDENTS)]
 fn getdents(fd: u32, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
 
@@ -116,7 +151,7 @@ fn getdents(fd: u32, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     Ok(buffer.wrote())
 }
 
-#[eonix_macros::define_syscall(0xdc)]
+#[eonix_macros::define_syscall(SYS_GETDENTS64)]
 fn getdents64(fd: u32, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
 
@@ -124,7 +159,7 @@ fn getdents64(fd: u32, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     Ok(buffer.wrote())
 }
 
-#[eonix_macros::define_syscall(0x17f)]
+#[eonix_macros::define_syscall(SYS_STATX)]
 fn statx(dirfd: u32, path: *const u8, flags: u32, mask: u32, buffer: *mut u8) -> KResult<()> {
     if (flags & AT_STATX_SYNC_TYPE) != AT_STATX_SYNC_AS_STAT {
         unimplemented!("AT_STATX_SYNC_TYPE={:x}", flags & AT_STATX_SYNC_TYPE);
@@ -163,20 +198,23 @@ fn statx(dirfd: u32, path: *const u8, flags: u32, mask: u32, buffer: *mut u8) ->
     buffer.copy(&stat)?.ok_or(EFAULT)
 }
 
-#[eonix_macros::define_syscall(0x27)]
-fn mkdir(pathname: *const u8, mode: u32) -> KResult<()> {
-    let path = UserString::new(pathname)?;
-    let path = Path::new(path.as_cstr().to_bytes())?;
-
+#[eonix_macros::define_syscall(SYS_MKDIRAT)]
+fn mkdirat(dirfd: u32, pathname: *const u8, mode: u32) -> KResult<()> {
     let umask = *thread.fs_context.umask.lock();
     let mode = mode & !umask & 0o777;
 
-    let dentry = Dentry::open(&thread.fs_context, path, true)?;
-
+    let dentry = dentry_from(thread, dirfd, pathname, true)?;
     dentry.mkdir(mode)
 }
 
-#[eonix_macros::define_syscall(0x5c)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_MKDIR)]
+fn mkdir(pathname: *const u8, mode: u32) -> KResult<()> {
+    sys_mkdirat(thread, AT_FDCWD as u32, pathname, mode)
+}
+
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_TRUNCATE)]
 fn truncate(pathname: *const u8, length: usize) -> KResult<()> {
     let path = UserString::new(pathname)?;
     let path = Path::new(path.as_cstr().to_bytes())?;
@@ -186,52 +224,63 @@ fn truncate(pathname: *const u8, length: usize) -> KResult<()> {
     dentry.truncate(length)
 }
 
-#[eonix_macros::define_syscall(0x0a)]
-fn unlink(pathname: *const u8) -> KResult<()> {
-    let path = UserString::new(pathname)?;
-    let path = Path::new(path.as_cstr().to_bytes())?;
-
-    let dentry = Dentry::open(&thread.fs_context, path, false)?;
+#[eonix_macros::define_syscall(SYS_UNLINKAT)]
+fn unlinkat(dirfd: u32, pathname: *const u8) -> KResult<()> {
+    dentry_from(thread, dirfd, pathname, false)?.unlink()
+}
 
-    dentry.unlink()
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_UNLINK)]
+fn unlink(pathname: *const u8) -> KResult<()> {
+    sys_unlinkat(thread, AT_FDCWD as u32, pathname)
 }
 
-#[eonix_macros::define_syscall(0x53)]
-fn symlink(target: *const u8, linkpath: *const u8) -> KResult<()> {
+#[eonix_macros::define_syscall(SYS_SYMLINKAT)]
+fn symlinkat(dirfd: u32, target: *const u8, linkpath: *const u8) -> KResult<()> {
     let target = UserString::new(target)?;
-    let linkpath = UserString::new(linkpath)?;
-    let linkpath = Path::new(linkpath.as_cstr().to_bytes())?;
-
-    let dentry = Dentry::open(&thread.fs_context, linkpath, false)?;
+    let dentry = dentry_from(thread, dirfd, linkpath, false)?;
 
     dentry.symlink(target.as_cstr().to_bytes())
 }
 
-#[eonix_macros::define_syscall(0x0e)]
-fn mknod(pathname: *const u8, mode: u32, dev: u32) -> KResult<()> {
-    let path = UserString::new(pathname)?;
-    let path = Path::new(path.as_cstr().to_bytes())?;
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_SYMLINK)]
+fn symlink(target: *const u8, linkpath: *const u8) -> KResult<()> {
+    sys_symlinkat(thread, AT_FDCWD as u32, target, linkpath)
+}
+
+#[eonix_macros::define_syscall(SYS_MKNODAT)]
+fn mknodat(dirfd: u32, pathname: *const u8, mode: u32, dev: u32) -> KResult<()> {
+    let dentry = dentry_from(thread, dirfd, pathname, true)?;
 
     let umask = *thread.fs_context.umask.lock();
     let mode = mode & ((!umask & 0o777) | (S_IFBLK | S_IFCHR));
 
-    let dentry = Dentry::open(&thread.fs_context, path, true)?;
-
     dentry.mknod(mode, dev)
 }
 
-#[eonix_macros::define_syscall(0x55)]
-fn readlink(pathname: *const u8, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
-    let path = UserString::new(pathname)?;
-    let path = Path::new(path.as_cstr().to_bytes())?;
-
-    let dentry = Dentry::open(&thread.fs_context, path, false)?;
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_MKNOD)]
+fn mknod(pathname: *const u8, mode: u32, dev: u32) -> KResult<()> {
+    sys_mknodat(thread, AT_FDCWD as u32, pathname, mode, dev)
+}
 
+#[eonix_macros::define_syscall(SYS_READLINKAT)]
+fn readlinkat(dirfd: u32, pathname: *const u8, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
+    let dentry = dentry_from(thread, dirfd, pathname, false)?;
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
+
     dentry.readlink(&mut buffer)
 }
 
-#[eonix_macros::define_syscall(0x8c)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_READLINK)]
+fn readlink(pathname: *const u8, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
+    sys_readlinkat(thread, AT_FDCWD as u32, pathname, buffer, bufsize)
+}
+
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_LLSEEK)]
 fn llseek(
     fd: u32,
     offset_high: u32,
@@ -261,7 +310,7 @@ struct IoVec32 {
     len: u32,
 }
 
-#[eonix_macros::define_syscall(0x91)]
+#[eonix_macros::define_syscall(SYS_READV)]
 fn readv(fd: u32, iov_user: *const IoVec32, iovcnt: u32) -> KResult<usize> {
     let file = thread.files.get(fd).ok_or(EBADF)?;
 
@@ -293,7 +342,7 @@ fn readv(fd: u32, iov_user: *const IoVec32, iovcnt: u32) -> KResult<usize> {
     Ok(tot)
 }
 
-#[eonix_macros::define_syscall(0x92)]
+#[eonix_macros::define_syscall(SYS_WRITEV)]
 fn writev(fd: u32, iov_user: *const u8, iovcnt: u32) -> KResult<usize> {
     let file = thread.files.get(fd).ok_or(EBADF)?;
 
@@ -330,7 +379,8 @@ fn writev(fd: u32, iov_user: *const u8, iovcnt: u32) -> KResult<usize> {
     Ok(tot)
 }
 
-#[eonix_macros::define_syscall(0x21)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_ACCESS)]
 fn access(pathname: *const u8, _mode: u32) -> KResult<()> {
     let path = UserString::new(pathname)?;
     let path = Path::new(path.as_cstr().to_bytes())?;
@@ -352,7 +402,7 @@ fn access(pathname: *const u8, _mode: u32) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0xef)]
+#[eonix_macros::define_syscall(SYS_SENDFILE64)]
 fn sendfile64(out_fd: u32, in_fd: u32, offset: *mut u8, count: usize) -> KResult<usize> {
     let in_file = thread.files.get(in_fd).ok_or(EBADF)?;
     let out_file = thread.files.get(out_fd).ok_or(EBADF)?;
@@ -364,14 +414,14 @@ fn sendfile64(out_fd: u32, in_fd: u32, offset: *mut u8, count: usize) -> KResult
     Task::block_on(in_file.sendfile(&out_file, count))
 }
 
-#[eonix_macros::define_syscall(0x36)]
+#[eonix_macros::define_syscall(SYS_IOCTL)]
 fn ioctl(fd: u32, request: usize, arg3: usize) -> KResult<usize> {
     let file = thread.files.get(fd).ok_or(EBADF)?;
 
     file.ioctl(request, arg3)
 }
 
-#[eonix_macros::define_syscall(0xdd)]
+#[eonix_macros::define_syscall(SYS_FCNTL64)]
 fn fcntl64(fd: u32, cmd: u32, arg: usize) -> KResult<usize> {
     thread.files.fcntl(fd, cmd, arg)
 }
@@ -384,7 +434,8 @@ struct UserPollFd {
     revents: u16,
 }
 
-#[eonix_macros::define_syscall(0xa8)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_POLL)]
 fn poll(fds: *mut UserPollFd, nfds: u32, _timeout: u32) -> KResult<u32> {
     match nfds {
         0 => Ok(0),

src/kernel/syscall/mm.rs

@@ -1,5 +1,6 @@
 use super::FromSyscallArg;
 use crate::kernel::constants::{EINVAL, ENOMEM};
+use crate::kernel::task::Thread;
 use crate::{
     kernel::{
         constants::{UserMmapFlags, UserMmapProtocol},
@@ -11,6 +12,7 @@ use align_ext::AlignExt;
 use eonix_mm::address::{Addr as _, AddrOps as _, VAddr};
 use eonix_mm::paging::PAGE_SIZE;
 use eonix_runtime::task::Task;
+use posix_types::syscall_no::*;
 
 impl FromSyscallArg for UserMmapProtocol {
     fn from_arg(value: usize) -> UserMmapProtocol {
@@ -34,8 +36,8 @@ fn check_impl(condition: bool, err: u32) -> KResult<()> {
     }
 }
 
-#[eonix_macros::define_syscall(0xc0)]
-fn mmap_pgoff(
+fn do_mmap2(
+    thread: &Thread,
     addr: usize,
     len: usize,
     prot: UserMmapProtocol,
@@ -93,7 +95,33 @@ fn mmap_pgoff(
     addr.map(|addr| addr.addr())
 }
 
-#[eonix_macros::define_syscall(0x5b)]
+#[cfg(target_arch = "riscv64")]
+#[eonix_macros::define_syscall(SYS_MMAP)]
+fn mmap(
+    addr: usize,
+    len: usize,
+    prot: UserMmapProtocol,
+    flags: UserMmapFlags,
+    fd: u32,
+    offset: usize,
+) -> KResult<usize> {
+    do_mmap2(thread, addr, len, prot, flags, fd, offset / PAGE_SIZE)
+}
+
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_MMAP2)]
+fn mmap2(
+    addr: usize,
+    len: usize,
+    prot: UserMmapProtocol,
+    flags: UserMmapFlags,
+    fd: u32,
+    pgoffset: usize,
+) -> KResult<usize> {
+    do_mmap2(addr, len, prot, flags, fd, pgoffset)
+}
+
+#[eonix_macros::define_syscall(SYS_MUNMAP)]
 fn munmap(addr: usize, len: usize) -> KResult<usize> {
     let addr = VAddr::from(addr);
     if !addr.is_page_aligned() || len == 0 {
@@ -104,18 +132,18 @@ fn munmap(addr: usize, len: usize) -> KResult<usize> {
     Task::block_on(thread.process.mm_list.unmap(addr, len)).map(|_| 0)
 }
 
-#[eonix_macros::define_syscall(0x2d)]
+#[eonix_macros::define_syscall(SYS_BRK)]
 fn brk(addr: usize) -> KResult<usize> {
     let vaddr = if addr == 0 { None } else { Some(VAddr::from(addr)) };
     Ok(thread.process.mm_list.set_break(vaddr).addr())
 }
 
-#[eonix_macros::define_syscall(0xdb)]
+#[eonix_macros::define_syscall(SYS_MADVISE)]
 fn madvise(_addr: usize, _len: usize, _advice: u32) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x7d)]
+#[eonix_macros::define_syscall(SYS_MPROTECT)]
 fn mprotect(addr: usize, len: usize, prot: UserMmapProtocol) -> KResult<()> {
     let addr = VAddr::from(addr);
     if !addr.is_page_aligned() || len == 0 {

src/kernel/syscall/net.rs

@@ -1,7 +1,8 @@
 use crate::kernel::constants::EINVAL;
 use crate::prelude::*;
+use posix_types::syscall_no::*;
 
-#[eonix_macros::define_syscall(0x167)]
+#[eonix_macros::define_syscall(SYS_SOCKET)]
 fn socket(_domain: u32, _socket_type: u32, _protocol: u32) -> KResult<u32> {
     Err(EINVAL)
 }

src/kernel/syscall/procops.rs

@@ -1,3 +1,5 @@
+use core::ptr::NonNull;
+
 use super::sysinfo::TimeVal;
 use super::SyscallNoReturn;
 use crate::io::Buffer;
@@ -8,7 +10,7 @@ use crate::kernel::constants::{
 use crate::kernel::mem::PageBuffer;
 use crate::kernel::task::{
     new_thread_runnable, KernelStack, ProcessBuilder, ProcessList, ProgramLoader, Signal,
-    SignalAction, SignalMask, ThreadBuilder, UserDescriptor, WaitObject, WaitType,
+    SignalAction, SignalMask, Thread, ThreadBuilder, UserDescriptor, WaitObject, WaitType,
 };
 use crate::kernel::user::dataflow::UserString;
 use crate::kernel::user::{UserPointer, UserPointerMut};
@@ -24,7 +26,9 @@ use eonix_mm::address::Addr as _;
 use eonix_runtime::scheduler::Scheduler;
 use eonix_runtime::task::Task;
 use eonix_sync::AsProof as _;
-use posix_types::signal::SigAction;
+use posix_types::constants::{P_ALL, P_PID};
+use posix_types::signal::{SigAction, SigInfo};
+use posix_types::syscall_no::*;
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
@@ -41,7 +45,7 @@ bitflags! {
     }
 }
 
-#[eonix_macros::define_syscall(0x3c)]
+#[eonix_macros::define_syscall(SYS_UMASK)]
 fn umask(mask: u32) -> KResult<u32> {
     let mut umask = thread.fs_context.umask.lock();
 
@@ -50,7 +54,7 @@ fn umask(mask: u32) -> KResult<u32> {
     Ok(old)
 }
 
-#[eonix_macros::define_syscall(0xb7)]
+#[eonix_macros::define_syscall(SYS_GETCWD)]
 fn getcwd(buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let mut user_buffer = UserBuffer::new(buffer, bufsize)?;
     let mut buffer = PageBuffer::new();
@@ -66,7 +70,7 @@ fn getcwd(buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     Ok(buffer.wrote())
 }
 
-#[eonix_macros::define_syscall(0x0c)]
+#[eonix_macros::define_syscall(SYS_CHDIR)]
 fn chdir(path: *const u8) -> KResult<()> {
     let path = UserString::new(path)?;
     let path = Path::new(path.as_cstr().to_bytes())?;
@@ -84,7 +88,7 @@ fn chdir(path: *const u8) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x15)]
+#[eonix_macros::define_syscall(SYS_MOUNT)]
 fn mount(source: *const u8, target: *const u8, fstype: *const u8, flags: usize) -> KResult<()> {
     let source = UserString::new(source)?;
     let target = UserString::new(target)?;
@@ -126,7 +130,7 @@ fn get_strings(mut ptr_strings: UserPointer<'_, u32>) -> KResult<Vec<CString>> {
     Ok(strings)
 }
 
-#[eonix_macros::define_syscall(0x0b)]
+#[eonix_macros::define_syscall(SYS_EXECVE)]
 fn execve(exec: *const u8, argv: *const u32, envp: *const u32) -> KResult<()> {
     let exec = UserString::new(exec)?;
     let argv = get_strings(UserPointer::new(argv)?)?;
@@ -164,7 +168,7 @@ fn execve(exec: *const u8, argv: *const u32, envp: *const u32) -> KResult<()> {
     }
 }
 
-#[eonix_macros::define_syscall(0x01)]
+#[eonix_macros::define_syscall(SYS_EXIT)]
 fn exit(status: u32) -> SyscallNoReturn {
     unsafe {
         let mut procs = Task::block_on(ProcessList::get().write());
@@ -174,53 +178,122 @@ fn exit(status: u32) -> SyscallNoReturn {
     SyscallNoReturn
 }
 
-#[eonix_macros::define_syscall(0xfc)]
+#[eonix_macros::define_syscall(SYS_EXIT_GROUP)]
 fn exit_group(status: u32) -> SyscallNoReturn {
     sys_exit(thread, status)
 }
 
-#[eonix_macros::define_syscall(0x07)]
-fn waitpid(_waitpid: u32, arg1: *mut u32, options: u32) -> KResult<u32> {
-    // if waitpid != u32::MAX {
-    //     unimplemented!("waitpid with pid {waitpid}")
-    // }
+enum WaitInfo {
+    SigInfo(NonNull<SigInfo>),
+    Status(NonNull<u32>),
+    None,
+}
+
+fn do_waitid(
+    thread: &Thread,
+    id_type: u32,
+    _id: u32,
+    info: WaitInfo,
+    options: u32,
+    rusage: *mut RUsage,
+) -> KResult<u32> {
+    if id_type != P_ALL {
+        unimplemented!("waitid with id_type {id_type}");
+    }
+
+    if !rusage.is_null() {
+        unimplemented!("waitid with rusage pointer");
+    }
+
     let options = match UserWaitOptions::from_bits(options) {
         None => unimplemented!("waitpid with options {options}"),
         Some(options) => options,
     };
 
-    let wait_object = Task::block_on(thread.process.wait(
+    let Some(wait_object) = Task::block_on(thread.process.wait(
         options.contains(UserWaitOptions::WNOHANG),
         options.contains(UserWaitOptions::WUNTRACED),
         options.contains(UserWaitOptions::WCONTINUED),
-    ))?;
+    ))?
+    else {
+        return Ok(0);
+    };
 
-    match wait_object {
-        None => Ok(0),
-        Some(WaitObject { pid, code }) => {
-            if !arg1.is_null() {
-                UserPointerMut::new(arg1)?.write(code.to_wstatus())?;
-            }
-            Ok(pid)
+    match info {
+        WaitInfo::SigInfo(siginfo_ptr) => {
+            let (status, code) = wait_object.code.to_status_code();
+
+            let mut siginfo = SigInfo::default();
+            siginfo.si_pid = wait_object.pid;
+            siginfo.si_uid = 0; // All users are root for now.
+            siginfo.si_signo = u32::from(Signal::SIGCHLD);
+            siginfo.si_status = status;
+            siginfo.si_code = code;
+
+            UserPointerMut::new(siginfo_ptr.as_ptr())?.write(siginfo)?;
+            Ok(0)
+        }
+        WaitInfo::Status(status_ptr) => {
+            UserPointerMut::new(status_ptr.as_ptr())?.write(wait_object.code.to_wstatus())?;
+            Ok(wait_object.pid)
         }
+        WaitInfo::None => Ok(wait_object.pid),
     }
 }
 
-#[eonix_macros::define_syscall(0x72)]
-fn wait4(waitpid: u32, arg1: *mut u32, options: u32, rusage: *mut ()) -> KResult<u32> {
-    if rusage.is_null() {
-        sys_waitpid(thread, waitpid, arg1, options)
+#[eonix_macros::define_syscall(SYS_WAITID)]
+fn waitid(
+    id_type: u32,
+    id: u32,
+    info: *mut SigInfo,
+    options: u32,
+    rusage: *mut RUsage,
+) -> KResult<u32> {
+    if let Some(info) = NonNull::new(info) {
+        do_waitid(
+            thread,
+            id_type,
+            id,
+            WaitInfo::SigInfo(info),
+            options,
+            rusage,
+        )
     } else {
-        unimplemented!("wait4 with rusage")
+        /*
+         * According to POSIX.1-2008, an application calling waitid() must
+         * ensure that infop points to a siginfo_t structure (i.e., that it
+         * is a non-null pointer).  On Linux, if infop is NULL, waitid()
+         * succeeds, and returns the process ID of the waited-for child.
+         * Applications should avoid relying on this inconsistent,
+         * nonstandard, and unnecessary feature.
+         */
+        unimplemented!("waitid with null info pointer");
     }
 }
 
-#[eonix_macros::define_syscall(0x42)]
+#[eonix_macros::define_syscall(SYS_WAIT4)]
+fn wait4(waitpid: u32, arg1: *mut u32, options: u32, rusage: *mut RUsage) -> KResult<u32> {
+    let waitinfo = if let Some(status) = NonNull::new(arg1) {
+        WaitInfo::Status(status)
+    } else {
+        WaitInfo::None
+    };
+
+    do_waitid(thread, P_PID, waitpid, waitinfo, options, rusage)
+}
+
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_WAITPID)]
+fn waitpid(waitpid: u32, arg1: *mut u32, options: u32) -> KResult<u32> {
+    sys_wait4(thread, waitpid, arg1, options, core::ptr::null_mut())
+}
+
+#[eonix_macros::define_syscall(SYS_SETSID)]
 fn setsid() -> KResult<u32> {
     thread.process.setsid()
 }
 
-#[eonix_macros::define_syscall(0x39)]
+#[eonix_macros::define_syscall(SYS_SETPGID)]
 fn setpgid(pid: u32, pgid: i32) -> KResult<()> {
     let pid = if pid == 0 { thread.process.pid } else { pid };
 
@@ -233,7 +306,7 @@ fn setpgid(pid: u32, pgid: i32) -> KResult<()> {
     thread.process.setpgid(pid, pgid)
 }
 
-#[eonix_macros::define_syscall(0x93)]
+#[eonix_macros::define_syscall(SYS_GETSID)]
 fn getsid(pid: u32) -> KResult<u32> {
     if pid == 0 {
         Ok(thread.process.session_rcu().sid)
@@ -246,7 +319,7 @@ fn getsid(pid: u32) -> KResult<u32> {
     }
 }
 
-#[eonix_macros::define_syscall(0x84)]
+#[eonix_macros::define_syscall(SYS_GETPGID)]
 fn getpgid(pid: u32) -> KResult<u32> {
     if pid == 0 {
         Ok(thread.process.pgroup_rcu().pgid)
@@ -259,45 +332,47 @@ fn getpgid(pid: u32) -> KResult<u32> {
     }
 }
 
-#[eonix_macros::define_syscall(0x14)]
+#[eonix_macros::define_syscall(SYS_GETPID)]
 fn getpid() -> KResult<u32> {
     Ok(thread.process.pid)
 }
 
-#[eonix_macros::define_syscall(0x40)]
+#[eonix_macros::define_syscall(SYS_GETPPID)]
 fn getppid() -> KResult<u32> {
     Ok(thread.process.parent_rcu().map_or(0, |x| x.pid))
 }
 
-#[eonix_macros::define_syscall(0xc7)]
+#[eonix_macros::define_syscall(SYS_GETUID)]
 fn getuid() -> KResult<u32> {
     // All users are root for now.
     Ok(0)
 }
 
-#[eonix_macros::define_syscall(0xc9)]
+#[eonix_macros::define_syscall(SYS_GETEUID)]
 fn geteuid() -> KResult<u32> {
     // All users are root for now.
     Ok(0)
 }
 
-#[eonix_macros::define_syscall(0x2f)]
+#[eonix_macros::define_syscall(SYS_GETGID)]
 fn getgid() -> KResult<u32> {
     // All users are root for now.
     Ok(0)
 }
 
-#[eonix_macros::define_syscall(0xc8)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_GETGID32)]
 fn getgid32() -> KResult<u32> {
     sys_getgid(thread)
 }
 
-#[eonix_macros::define_syscall(0xe0)]
+#[eonix_macros::define_syscall(SYS_GETTID)]
 fn gettid() -> KResult<u32> {
     Ok(thread.tid)
 }
 
-#[eonix_macros::define_syscall(0xf3)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_SET_THREAD_AREA)]
 fn set_thread_area(desc: *mut UserDescriptor) -> KResult<()> {
     let desc_pointer = UserPointerMut::new(desc)?;
     let mut desc = desc_pointer.read()?;
@@ -315,14 +390,14 @@ fn set_thread_area(desc: *mut UserDescriptor) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x102)]
+#[eonix_macros::define_syscall(SYS_SET_TID_ADDRESS)]
 fn set_tid_address(tidptr: *mut u32) -> KResult<u32> {
     // TODO!!!: Implement this. We don't use it for now.
     let _tidptr = UserPointerMut::new(tidptr)?;
     Ok(thread.tid)
 }
 
-#[eonix_macros::define_syscall(0xac)]
+#[eonix_macros::define_syscall(SYS_PRCTL)]
 fn prctl(option: u32, arg2: usize) -> KResult<()> {
     match option {
         PR_SET_NAME => {
@@ -342,7 +417,7 @@ fn prctl(option: u32, arg2: usize) -> KResult<()> {
     }
 }
 
-#[eonix_macros::define_syscall(0x25)]
+#[eonix_macros::define_syscall(SYS_KILL)]
 fn kill(pid: i32, sig: u32) -> KResult<()> {
     let procs = Task::block_on(ProcessList::get().read());
     match pid {
@@ -369,7 +444,7 @@ fn kill(pid: i32, sig: u32) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0xee)]
+#[eonix_macros::define_syscall(SYS_TKILL)]
 fn tkill(tid: u32, sig: u32) -> KResult<()> {
     Task::block_on(ProcessList::get().read())
         .try_find_thread(tid)
@@ -378,7 +453,7 @@ fn tkill(tid: u32, sig: u32) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0xaf)]
+#[eonix_macros::define_syscall(SYS_RT_SIGPROCMASK)]
 fn rt_sigprocmask(how: u32, set: *mut u64, oldset: *mut u64, sigsetsize: usize) -> KResult<()> {
     if sigsetsize != size_of::<u64>() {
         return Err(EINVAL);
@@ -405,7 +480,7 @@ fn rt_sigprocmask(how: u32, set: *mut u64, oldset: *mut u64, sigsetsize: usize)
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0xae)]
+#[eonix_macros::define_syscall(SYS_RT_SIGACTION)]
 fn rt_sigaction(
     signum: u32,
     act: *const SigAction,
@@ -437,7 +512,7 @@ fn rt_sigaction(
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x154)]
+#[eonix_macros::define_syscall(SYS_PRLIMIT64)]
 fn prlimit64(
     pid: u32,
     resource: u32,
@@ -468,7 +543,7 @@ fn prlimit64(
     }
 }
 
-#[eonix_macros::define_syscall(0xbf)]
+#[eonix_macros::define_syscall(SYS_GETRLIMIT)]
 fn getrlimit(resource: u32, rlimit: *mut RLimit) -> KResult<()> {
     sys_prlimit64(thread, 0, resource, core::ptr::null(), rlimit)
 }
@@ -494,7 +569,7 @@ struct RUsage {
     ru_nivcsw: u32,
 }
 
-#[eonix_macros::define_syscall(0x4d)]
+#[eonix_macros::define_syscall(SYS_GETRUSAGE)]
 fn getrusage(who: u32, rusage: *mut RUsage) -> KResult<()> {
     if who != 0 {
         return Err(ENOSYS);
@@ -523,7 +598,7 @@ fn getrusage(who: u32, rusage: *mut RUsage) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x0f)]
+#[eonix_macros::define_syscall(SYS_FCHMOD)]
 fn chmod(pathname: *const u8, mode: u32) -> KResult<()> {
     let path = UserString::new(pathname)?;
     let path = Path::new(path.as_cstr().to_bytes())?;
@@ -536,12 +611,14 @@ fn chmod(pathname: *const u8, mode: u32) -> KResult<()> {
     dentry.chmod(mode)
 }
 
-#[eonix_macros::define_syscall(0xbe)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_VFORK)]
 fn vfork() -> u32 {
     sys_fork(thread)
 }
 
-#[eonix_macros::define_syscall(0x02)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_FORK)]
 fn fork() -> u32 {
     let mut procs = Task::block_on(ProcessList::get().write());
 
@@ -563,7 +640,8 @@ fn fork() -> u32 {
     new_process.pid
 }
 
-#[eonix_macros::define_syscall(0x77)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_SIGRETURN)]
 fn sigreturn() -> KResult<SyscallNoReturn> {
     thread
         .signal_list
@@ -582,8 +660,8 @@ fn sigreturn() -> KResult<SyscallNoReturn> {
     Ok(SyscallNoReturn)
 }
 
-// TODO: This should be for x86 only.
-#[eonix_macros::define_syscall(0x180)]
+#[cfg(target_arch = "x86_64")]
+#[eonix_macros::define_syscall(SYS_ARCH_PRCTL)]
 fn arch_prctl(option: u32, addr: u32) -> KResult<u32> {
     sys_arch_prctl(thread, option, addr)
 }

src/kernel/syscall/sysinfo.rs

@@ -6,6 +6,7 @@ use crate::{
     },
     prelude::*,
 };
+use posix_types::syscall_no::*;
 
 #[derive(Clone, Copy)]
 struct NewUTSName {
@@ -23,7 +24,7 @@ fn copy_cstr_to_array(cstr: &[u8], array: &mut [u8]) {
     array[len] = 0;
 }
 
-#[eonix_macros::define_syscall(0x7a)]
+#[eonix_macros::define_syscall(SYS_NEWUNAME)]
 fn newuname(buffer: *mut NewUTSName) -> KResult<()> {
     let buffer = UserPointerMut::new(buffer)?;
     let mut uname = NewUTSName {
@@ -60,7 +61,7 @@ pub struct TimeSpec {
     nsec: u64,
 }
 
-#[eonix_macros::define_syscall(0x4e)]
+#[eonix_macros::define_syscall(SYS_GETTIMEOFDAY)]
 fn gettimeofday(timeval: *mut TimeVal, timezone: *mut ()) -> KResult<()> {
     if !timezone.is_null() {
         return Err(EINVAL);
@@ -78,7 +79,7 @@ fn gettimeofday(timeval: *mut TimeVal, timezone: *mut ()) -> KResult<()> {
     Ok(())
 }
 
-#[eonix_macros::define_syscall(0x193)]
+#[eonix_macros::define_syscall(SYS_CLOCK_GETTIME64)]
 fn clock_gettime64(clock_id: u32, timespec: *mut TimeSpec) -> KResult<()> {
     if clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC {
         unimplemented!("Unsupported clock_id: {}", clock_id);
@@ -110,7 +111,7 @@ struct Sysinfo {
     _padding: [u8; 8],
 }
 
-#[eonix_macros::define_syscall(0x74)]
+#[eonix_macros::define_syscall(SYS_SYSINFO)]
 fn sysinfo(info: *mut Sysinfo) -> KResult<()> {
     let info = UserPointerMut::new(info)?;
     info.write(Sysinfo {
@@ -139,7 +140,7 @@ struct TMS {
     tms_cstime: u32,
 }
 
-#[eonix_macros::define_syscall(0x2b)]
+#[eonix_macros::define_syscall(SYS_TIMES)]
 fn times(tms: *mut TMS) -> KResult<()> {
     let tms = UserPointerMut::new(tms)?;
     tms.write(TMS {

src/kernel/task/process.rs

@@ -21,6 +21,7 @@ use eonix_sync::{
     UnlockableGuard as _, UnlockedGuard as _,
 };
 use pointers::BorrowedArc;
+use posix_types::constants::{CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED};
 
 pub struct ProcessBuilder {
     mm_list: Option<MMList>,
@@ -118,6 +119,17 @@ impl WaitType {
             WaitType::Continued => 0xffff,
         }
     }
+
+    pub fn to_status_code(self) -> (u32, u32) {
+        // TODO: CLD_TRAPPED
+        match self {
+            WaitType::Exited(status) => (status, CLD_EXITED),
+            WaitType::Signaled(signal @ SIGNAL_COREDUMP!()) => (u32::from(signal), CLD_DUMPED),
+            WaitType::Signaled(signal) => (u32::from(signal), CLD_KILLED),
+            WaitType::Stopped(signal) => (u32::from(signal), CLD_STOPPED),
+            WaitType::Continued => (u32::from(Signal::SIGCONT), CLD_CONTINUED),
+        }
+    }
 }
 
 impl WaitObject {

src/kernel/task/thread.rs

@@ -390,7 +390,14 @@ impl Thread {
                 }
                 TrapType::Syscall { no, args } => {
                     if let Some(retval) = self.handle_syscall(no, args) {
-                        self.trap_ctx.borrow().set_user_return_value(retval);
+                        let mut trap_ctx = self.trap_ctx.borrow();
+                        trap_ctx.set_user_return_value(retval);
+
+                        #[cfg(target_arch = "riscv64")]
+                        {
+                            let pc = trap_ctx.get_program_counter();
+                            trap_ctx.set_program_counter(pc + 4);
+                        }
                     }
                 }
             }