stracers-core 0.1.0

use nix::libc::{self, user_regs_struct};
use nix::unistd::Pid;

use crate::event::DecodedArg;
use crate::memory;

// On aarch64, `user_regs_struct` is `{ regs: [u64; 31], sp, pc, pstate }`.
// Linux syscall ABI: x8 = number, x0..x5 = args, x0 = return.
// Unlike x86_64 there is no `orig_x0` exposed via NT_PRSTATUS, but we capture
// args at syscall-entry-stop so x0 is still the original argument there.

/// Extract syscall number and arguments from registers at syscall entry.
pub fn extract_syscall_entry(regs: &user_regs_struct) -> (u64, [u64; 6]) {
    let number = regs.regs[8];
    let args = [
        regs.regs[0],
        regs.regs[1],
        regs.regs[2],
        regs.regs[3],
        regs.regs[4],
        regs.regs[5],
    ];
    (number, args)
}

/// Extract return value from registers at syscall exit.
pub fn extract_return_value(regs: &user_regs_struct) -> i64 {
    regs.regs[0] as i64
}

/// Look up syscall name by number. Returns None for unknown syscalls.
pub fn syscall_name(number: u64) -> Option<&'static str> {
    SYSCALL_NAMES.get(number as usize).copied().flatten()
}

/// Decode syscall arguments at entry (before the syscall executes).
pub fn decode_entry_args(pid: Pid, number: u64, args: &[u64; 6]) -> Vec<DecodedArg> {
    match number {
        // getcwd(buf, size)
        17 => vec![DecodedArg::Addr(args[0]), DecodedArg::Size(args[1])],
        // dup(fd)
        23 => vec![DecodedArg::Fd(args[0] as i32)],
        // dup3(oldfd, newfd, flags)
        24 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Fd(args[1] as i32),
            DecodedArg::Raw(args[2]),
        ],
        // fcntl(fd, cmd, ...)
        25 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Int(args[1] as i64),
            DecodedArg::Raw(args[2]),
        ],
        // ioctl(fd, request, ...)
        29 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Raw(args[1]),
            DecodedArg::Addr(args[2]),
        ],
        // faccessat(dirfd, pathname, mode)
        48 => vec![
            DecodedArg::Fd(args[0] as i32),
            read_path(pid, args[1]),
            decode_access_mode(args[2]),
        ],
        // chdir(path)
        49 => vec![read_path(pid, args[0])],
        // openat(dirfd, pathname, flags, mode)
        56 => vec![
            DecodedArg::Fd(args[0] as i32),
            read_path(pid, args[1]),
            decode_open_flags(args[2]),
            DecodedArg::Int(args[3] as i64),
        ],
        // close(fd)
        57 => vec![DecodedArg::Fd(args[0] as i32)],
        // lseek(fd, offset, whence)
        62 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Int(args[1] as i64),
            decode_whence(args[2]),
        ],
        // read(fd, buf, count) — buf decoded at exit
        63 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Addr(args[1]),
            DecodedArg::Size(args[2]),
        ],
        // write(fd, buf, count)
        64 => {
            let count = args[2] as usize;
            let buf = read_buf(pid, args[1], count.min(32));
            vec![
                DecodedArg::Fd(args[0] as i32),
                DecodedArg::Buf(buf, count),
                DecodedArg::Size(args[2]),
            ]
        }
        // pread64(fd, buf, count, offset)
        67 => vec![
            DecodedArg::Fd(args[0] as i32),
            DecodedArg::Addr(args[1]),
            DecodedArg::Size(args[2]),
            DecodedArg::Int(args[3] as i64),
        ],
        // readlinkat(dirfd, pathname, buf, bufsiz)
        78 => vec![
            DecodedArg::Fd(args[0] as i32),
            read_path(pid, args[1]),
            DecodedArg::Addr(args[2]),
            DecodedArg::Size(args[3]),
        ],
        // newfstatat(dirfd, pathname, statbuf, flag)
        79 => vec![
            DecodedArg::Fd(args[0] as i32),
            read_path(pid, args[1]),
            DecodedArg::Addr(args[2]),
            DecodedArg::Raw(args[3]),
        ],
        // fstat(fd, statbuf)
        80 => vec![DecodedArg::Fd(args[0] as i32), DecodedArg::Addr(args[1])],
        // exit(status)
        93 => vec![DecodedArg::Int(args[0] as i64)],
        // exit_group(status)
        94 => vec![DecodedArg::Int(args[0] as i64)],
        // set_tid_address(tidptr)
        96 => vec![DecodedArg::Addr(args[0])],
        // set_robust_list(head, len)
        99 => vec![DecodedArg::Addr(args[0]), DecodedArg::Size(args[1])],
        // rt_sigaction(signum, act, oldact, sigsetsize)
        134 => vec![
            DecodedArg::Int(args[0] as i64),
            DecodedArg::Addr(args[1]),
            DecodedArg::Addr(args[2]),
            DecodedArg::Size(args[3]),
        ],
        // rt_sigprocmask(how, set, oldset, sigsetsize)
        135 => vec![
            DecodedArg::Int(args[0] as i64),
            DecodedArg::Addr(args[1]),
            DecodedArg::Addr(args[2]),
            DecodedArg::Size(args[3]),
        ],
        // getpid/getppid/getuid/geteuid/getgid/getegid/gettid (no args)
        172 | 173 | 174 | 175 | 176 | 177 | 178 => vec![],
        // brk(addr)
        214 => vec![DecodedArg::Addr(args[0])],
        // munmap(addr, length)
        215 => vec![DecodedArg::Addr(args[0]), DecodedArg::Size(args[1])],
        // execve(filename, argv, envp)
        221 => vec![
            read_path(pid, args[0]),
            DecodedArg::Addr(args[1]),
            DecodedArg::Addr(args[2]),
        ],
        // mmap(addr, length, prot, flags, fd, offset)
        222 => vec![
            DecodedArg::Addr(args[0]),
            DecodedArg::Size(args[1]),
            decode_mmap_prot(args[2]),
            decode_mmap_flags(args[3]),
            DecodedArg::Fd(args[4] as i32),
            DecodedArg::Int(args[5] as i64),
        ],
        // mprotect(addr, len, prot)
        226 => vec![
            DecodedArg::Addr(args[0]),
            DecodedArg::Size(args[1]),
            decode_mmap_prot(args[2]),
        ],
        // prlimit64(pid, resource, new_limit, old_limit)
        261 => vec![
            DecodedArg::Int(args[0] as i64),
            DecodedArg::Int(args[1] as i64),
            DecodedArg::Addr(args[2]),
            DecodedArg::Addr(args[3]),
        ],
        // getrandom(buf, buflen, flags)
        278 => vec![
            DecodedArg::Addr(args[0]),
            DecodedArg::Size(args[1]),
            DecodedArg::Raw(args[2]),
        ],
        // rseq(rseq, rseq_len, flags, sig)
        293 => vec![
            DecodedArg::Addr(args[0]),
            DecodedArg::Size(args[1]),
            DecodedArg::Raw(args[2]),
            DecodedArg::Raw(args[3]),
        ],
        // Unknown syscall — show all 6 args as raw hex.
        _ => args.iter().map(|&a| DecodedArg::Raw(a)).collect(),
    }
}

/// Decode output arguments at syscall exit (e.g. read buffer).
pub fn decode_exit_args(
    pid: Pid,
    number: u64,
    args: &[u64; 6],
    ret: i64,
    decoded: &mut Vec<DecodedArg>,
) {
    match number {
        // read(fd, buf, count) — buf is now filled, ret is bytes read
        63 if ret > 0 => {
            let count = ret as usize;
            let buf = read_buf(pid, args[1], count.min(32));
            if decoded.len() > 1 {
                decoded[1] = DecodedArg::Buf(buf, count);
            }
        }
        _ => {}
    }
}

// --- Helpers ---

fn read_path(pid: Pid, addr: u64) -> DecodedArg {
    match memory::read_string(pid, addr, 256) {
        Ok(s) => DecodedArg::Path(s),
        Err(_) => DecodedArg::Addr(addr),
    }
}

fn read_buf(pid: Pid, addr: u64, len: usize) -> Vec<u8> {
    memory::read_bytes(pid, addr, len).unwrap_or_default()
}

fn decode_open_flags(flags: u64) -> DecodedArg {
    let access = flags & 0o3;
    let mut parts = vec![match access {
        0 => "O_RDONLY",
        1 => "O_WRONLY",
        2 => "O_RDWR",
        _ => "O_???",
    }];

    // Use libc constants so values match the kernel ABI on this arch.
    let bits: [(u64, &str); 14] = [
        (libc::O_CREAT as u64, "O_CREAT"),
        (libc::O_EXCL as u64, "O_EXCL"),
        (libc::O_NOCTTY as u64, "O_NOCTTY"),
        (libc::O_TRUNC as u64, "O_TRUNC"),
        (libc::O_APPEND as u64, "O_APPEND"),
        (libc::O_NONBLOCK as u64, "O_NONBLOCK"),
        (libc::O_DSYNC as u64, "O_DSYNC"),
        (libc::O_DIRECT as u64, "O_DIRECT"),
        (libc::O_DIRECTORY as u64, "O_DIRECTORY"),
        (libc::O_NOFOLLOW as u64, "O_NOFOLLOW"),
        (libc::O_NOATIME as u64, "O_NOATIME"),
        (libc::O_CLOEXEC as u64, "O_CLOEXEC"),
        (libc::O_SYNC as u64, "O_SYNC"),
        (libc::O_PATH as u64, "O_PATH"),
    ];

    for (bit, name) in bits {
        if bit != 0 && (flags & bit) == bit {
            parts.push(name);
        }
    }

    DecodedArg::Flags(parts.join("|"))
}

fn decode_mmap_prot(prot: u64) -> DecodedArg {
    if prot == 0 {
        return DecodedArg::Flags("PROT_NONE".to_string());
    }
    let mut parts = Vec::new();
    if prot & libc::PROT_READ as u64 != 0 { parts.push("PROT_READ"); }
    if prot & libc::PROT_WRITE as u64 != 0 { parts.push("PROT_WRITE"); }
    if prot & libc::PROT_EXEC as u64 != 0 { parts.push("PROT_EXEC"); }
    DecodedArg::Flags(parts.join("|"))
}

fn decode_mmap_flags(flags: u64) -> DecodedArg {
    let mut parts = Vec::new();
    if flags & libc::MAP_SHARED as u64 != 0 { parts.push("MAP_SHARED"); }
    if flags & libc::MAP_PRIVATE as u64 != 0 { parts.push("MAP_PRIVATE"); }
    if flags & libc::MAP_FIXED as u64 != 0 { parts.push("MAP_FIXED"); }
    if flags & libc::MAP_ANONYMOUS as u64 != 0 { parts.push("MAP_ANONYMOUS"); }
    if flags & libc::MAP_GROWSDOWN as u64 != 0 { parts.push("MAP_GROWSDOWN"); }
    if flags & libc::MAP_DENYWRITE as u64 != 0 { parts.push("MAP_DENYWRITE"); }
    if flags & libc::MAP_STACK as u64 != 0 { parts.push("MAP_STACK"); }
    if parts.is_empty() {
        DecodedArg::Raw(flags)
    } else {
        DecodedArg::Flags(parts.join("|"))
    }
}

fn decode_access_mode(mode: u64) -> DecodedArg {
    if mode == 0 {
        return DecodedArg::Flags("F_OK".to_string());
    }
    let mut parts = Vec::new();
    if mode & libc::R_OK as u64 != 0 { parts.push("R_OK"); }
    if mode & libc::W_OK as u64 != 0 { parts.push("W_OK"); }
    if mode & libc::X_OK as u64 != 0 { parts.push("X_OK"); }
    DecodedArg::Flags(parts.join("|"))
}

fn decode_whence(whence: u64) -> DecodedArg {
    DecodedArg::Flags(match whence as i32 {
        libc::SEEK_SET => "SEEK_SET".to_string(),
        libc::SEEK_CUR => "SEEK_CUR".to_string(),
        libc::SEEK_END => "SEEK_END".to_string(),
        _ => format!("{}", whence),
    })
}

// Sparse table indexed by syscall number, generated from
// <asm-generic/unistd.h>. aarch64 uses the asm-generic numbering.
static SYSCALL_NAMES: &[Option<&str>] = &[
    /* 0 */ Some("io_setup"),
    /* 1 */ Some("io_destroy"),
    /* 2 */ Some("io_submit"),
    /* 3 */ Some("io_cancel"),
    /* 4 */ Some("io_getevents"),
    /* 5 */ Some("setxattr"),
    /* 6 */ Some("lsetxattr"),
    /* 7 */ Some("fsetxattr"),
    /* 8 */ Some("getxattr"),
    /* 9 */ Some("lgetxattr"),
    /* 10 */ Some("fgetxattr"),
    /* 11 */ Some("listxattr"),
    /* 12 */ Some("llistxattr"),
    /* 13 */ Some("flistxattr"),
    /* 14 */ Some("removexattr"),
    /* 15 */ Some("lremovexattr"),
    /* 16 */ Some("fremovexattr"),
    /* 17 */ Some("getcwd"),
    /* 18 */ Some("lookup_dcookie"),
    /* 19 */ Some("eventfd2"),
    /* 20 */ Some("epoll_create1"),
    /* 21 */ Some("epoll_ctl"),
    /* 22 */ Some("epoll_pwait"),
    /* 23 */ Some("dup"),
    /* 24 */ Some("dup3"),
    /* 25 */ Some("fcntl"),
    /* 26 */ Some("inotify_init1"),
    /* 27 */ Some("inotify_add_watch"),
    /* 28 */ Some("inotify_rm_watch"),
    /* 29 */ Some("ioctl"),
    /* 30 */ Some("ioprio_set"),
    /* 31 */ Some("ioprio_get"),
    /* 32 */ Some("flock"),
    /* 33 */ Some("mknodat"),
    /* 34 */ Some("mkdirat"),
    /* 35 */ Some("unlinkat"),
    /* 36 */ Some("symlinkat"),
    /* 37 */ Some("linkat"),
    /* 38 */ Some("renameat"),
    /* 39 */ Some("umount2"),
    /* 40 */ Some("mount"),
    /* 41 */ Some("pivot_root"),
    /* 42 */ Some("nfsservctl"),
    /* 43 */ Some("statfs"),
    /* 44 */ Some("fstatfs"),
    /* 45 */ Some("truncate"),
    /* 46 */ Some("ftruncate"),
    /* 47 */ Some("fallocate"),
    /* 48 */ Some("faccessat"),
    /* 49 */ Some("chdir"),
    /* 50 */ Some("fchdir"),
    /* 51 */ Some("chroot"),
    /* 52 */ Some("fchmod"),
    /* 53 */ Some("fchmodat"),
    /* 54 */ Some("fchownat"),
    /* 55 */ Some("fchown"),
    /* 56 */ Some("openat"),
    /* 57 */ Some("close"),
    /* 58 */ Some("vhangup"),
    /* 59 */ Some("pipe2"),
    /* 60 */ Some("quotactl"),
    /* 61 */ Some("getdents64"),
    /* 62 */ Some("lseek"),
    /* 63 */ Some("read"),
    /* 64 */ Some("write"),
    /* 65 */ Some("readv"),
    /* 66 */ Some("writev"),
    /* 67 */ Some("pread64"),
    /* 68 */ Some("pwrite64"),
    /* 69 */ Some("preadv"),
    /* 70 */ Some("pwritev"),
    /* 71 */ Some("sendfile"),
    /* 72 */ Some("pselect6"),
    /* 73 */ Some("ppoll"),
    /* 74 */ Some("signalfd4"),
    /* 75 */ Some("vmsplice"),
    /* 76 */ Some("splice"),
    /* 77 */ Some("tee"),
    /* 78 */ Some("readlinkat"),
    /* 79 */ Some("newfstatat"),
    /* 80 */ Some("fstat"),
    /* 81 */ Some("sync"),
    /* 82 */ Some("fsync"),
    /* 83 */ Some("fdatasync"),
    /* 84 */ Some("sync_file_range2"),
    /* 85 */ Some("timerfd_create"),
    /* 86 */ Some("timerfd_settime"),
    /* 87 */ Some("timerfd_gettime"),
    /* 88 */ Some("utimensat"),
    /* 89 */ Some("acct"),
    /* 90 */ Some("capget"),
    /* 91 */ Some("capset"),
    /* 92 */ Some("personality"),
    /* 93 */ Some("exit"),
    /* 94 */ Some("exit_group"),
    /* 95 */ Some("waitid"),
    /* 96 */ Some("set_tid_address"),
    /* 97 */ Some("unshare"),
    /* 98 */ Some("futex"),
    /* 99 */ Some("set_robust_list"),
    /* 100 */ Some("get_robust_list"),
    /* 101 */ Some("nanosleep"),
    /* 102 */ Some("getitimer"),
    /* 103 */ Some("setitimer"),
    /* 104 */ Some("kexec_load"),
    /* 105 */ Some("init_module"),
    /* 106 */ Some("delete_module"),
    /* 107 */ Some("timer_create"),
    /* 108 */ Some("timer_gettime"),
    /* 109 */ Some("timer_getoverrun"),
    /* 110 */ Some("timer_settime"),
    /* 111 */ Some("timer_delete"),
    /* 112 */ Some("clock_settime"),
    /* 113 */ Some("clock_gettime"),
    /* 114 */ Some("clock_getres"),
    /* 115 */ Some("clock_nanosleep"),
    /* 116 */ Some("syslog"),
    /* 117 */ Some("ptrace"),
    /* 118 */ Some("sched_setparam"),
    /* 119 */ Some("sched_setscheduler"),
    /* 120 */ Some("sched_getscheduler"),
    /* 121 */ Some("sched_getparam"),
    /* 122 */ Some("sched_setaffinity"),
    /* 123 */ Some("sched_getaffinity"),
    /* 124 */ Some("sched_yield"),
    /* 125 */ Some("sched_get_priority_max"),
    /* 126 */ Some("sched_get_priority_min"),
    /* 127 */ Some("sched_rr_get_interval"),
    /* 128 */ Some("restart_syscall"),
    /* 129 */ Some("kill"),
    /* 130 */ Some("tkill"),
    /* 131 */ Some("tgkill"),
    /* 132 */ Some("sigaltstack"),
    /* 133 */ Some("rt_sigsuspend"),
    /* 134 */ Some("rt_sigaction"),
    /* 135 */ Some("rt_sigprocmask"),
    /* 136 */ Some("rt_sigpending"),
    /* 137 */ Some("rt_sigtimedwait"),
    /* 138 */ Some("rt_sigqueueinfo"),
    /* 139 */ Some("rt_sigreturn"),
    /* 140 */ Some("setpriority"),
    /* 141 */ Some("getpriority"),
    /* 142 */ Some("reboot"),
    /* 143 */ Some("setregid"),
    /* 144 */ Some("setgid"),
    /* 145 */ Some("setreuid"),
    /* 146 */ Some("setuid"),
    /* 147 */ Some("setresuid"),
    /* 148 */ Some("getresuid"),
    /* 149 */ Some("setresgid"),
    /* 150 */ Some("getresgid"),
    /* 151 */ Some("setfsuid"),
    /* 152 */ Some("setfsgid"),
    /* 153 */ Some("times"),
    /* 154 */ Some("setpgid"),
    /* 155 */ Some("getpgid"),
    /* 156 */ Some("getsid"),
    /* 157 */ Some("setsid"),
    /* 158 */ Some("getgroups"),
    /* 159 */ Some("setgroups"),
    /* 160 */ Some("uname"),
    /* 161 */ Some("sethostname"),
    /* 162 */ Some("setdomainname"),
    /* 163 */ Some("getrlimit"),
    /* 164 */ Some("setrlimit"),
    /* 165 */ Some("getrusage"),
    /* 166 */ Some("umask"),
    /* 167 */ Some("prctl"),
    /* 168 */ Some("getcpu"),
    /* 169 */ Some("gettimeofday"),
    /* 170 */ Some("settimeofday"),
    /* 171 */ Some("adjtimex"),
    /* 172 */ Some("getpid"),
    /* 173 */ Some("getppid"),
    /* 174 */ Some("getuid"),
    /* 175 */ Some("geteuid"),
    /* 176 */ Some("getgid"),
    /* 177 */ Some("getegid"),
    /* 178 */ Some("gettid"),
    /* 179 */ Some("sysinfo"),
    /* 180 */ Some("mq_open"),
    /* 181 */ Some("mq_unlink"),
    /* 182 */ Some("mq_timedsend"),
    /* 183 */ Some("mq_timedreceive"),
    /* 184 */ Some("mq_notify"),
    /* 185 */ Some("mq_getsetattr"),
    /* 186 */ Some("msgget"),
    /* 187 */ Some("msgctl"),
    /* 188 */ Some("msgrcv"),
    /* 189 */ Some("msgsnd"),
    /* 190 */ Some("semget"),
    /* 191 */ Some("semctl"),
    /* 192 */ Some("semtimedop"),
    /* 193 */ Some("semop"),
    /* 194 */ Some("shmget"),
    /* 195 */ Some("shmctl"),
    /* 196 */ Some("shmat"),
    /* 197 */ Some("shmdt"),
    /* 198 */ Some("socket"),
    /* 199 */ Some("socketpair"),
    /* 200 */ Some("bind"),
    /* 201 */ Some("listen"),
    /* 202 */ Some("accept"),
    /* 203 */ Some("connect"),
    /* 204 */ Some("getsockname"),
    /* 205 */ Some("getpeername"),
    /* 206 */ Some("sendto"),
    /* 207 */ Some("recvfrom"),
    /* 208 */ Some("setsockopt"),
    /* 209 */ Some("getsockopt"),
    /* 210 */ Some("shutdown"),
    /* 211 */ Some("sendmsg"),
    /* 212 */ Some("recvmsg"),
    /* 213 */ Some("readahead"),
    /* 214 */ Some("brk"),
    /* 215 */ Some("munmap"),
    /* 216 */ Some("mremap"),
    /* 217 */ Some("add_key"),
    /* 218 */ Some("request_key"),
    /* 219 */ Some("keyctl"),
    /* 220 */ Some("clone"),
    /* 221 */ Some("execve"),
    /* 222 */ Some("mmap"),
    /* 223 */ Some("fadvise64"),
    /* 224 */ Some("swapon"),
    /* 225 */ Some("swapoff"),
    /* 226 */ Some("mprotect"),
    /* 227 */ Some("msync"),
    /* 228 */ Some("mlock"),
    /* 229 */ Some("munlock"),
    /* 230 */ Some("mlockall"),
    /* 231 */ Some("munlockall"),
    /* 232 */ Some("mincore"),
    /* 233 */ Some("madvise"),
    /* 234 */ Some("remap_file_pages"),
    /* 235 */ Some("mbind"),
    /* 236 */ Some("get_mempolicy"),
    /* 237 */ Some("set_mempolicy"),
    /* 238 */ Some("migrate_pages"),
    /* 239 */ Some("move_pages"),
    /* 240 */ Some("rt_tgsigqueueinfo"),
    /* 241 */ Some("perf_event_open"),
    /* 242 */ Some("accept4"),
    /* 243 */ Some("recvmmsg"),
    /* 244 */ None,
    /* 245 */ None,
    /* 246 */ None,
    /* 247 */ None,
    /* 248 */ None,
    /* 249 */ None,
    /* 250 */ None,
    /* 251 */ None,
    /* 252 */ None,
    /* 253 */ None,
    /* 254 */ None,
    /* 255 */ None,
    /* 256 */ None,
    /* 257 */ None,
    /* 258 */ None,
    /* 259 */ None,
    /* 260 */ Some("wait4"),
    /* 261 */ Some("prlimit64"),
    /* 262 */ Some("fanotify_init"),
    /* 263 */ Some("fanotify_mark"),
    /* 264 */ Some("name_to_handle_at"),
    /* 265 */ Some("open_by_handle_at"),
    /* 266 */ Some("clock_adjtime"),
    /* 267 */ Some("syncfs"),
    /* 268 */ Some("setns"),
    /* 269 */ Some("sendmmsg"),
    /* 270 */ Some("process_vm_readv"),
    /* 271 */ Some("process_vm_writev"),
    /* 272 */ Some("kcmp"),
    /* 273 */ Some("finit_module"),
    /* 274 */ Some("sched_setattr"),
    /* 275 */ Some("sched_getattr"),
    /* 276 */ Some("renameat2"),
    /* 277 */ Some("seccomp"),
    /* 278 */ Some("getrandom"),
    /* 279 */ Some("memfd_create"),
    /* 280 */ Some("bpf"),
    /* 281 */ Some("execveat"),
    /* 282 */ Some("userfaultfd"),
    /* 283 */ Some("membarrier"),
    /* 284 */ Some("mlock2"),
    /* 285 */ Some("copy_file_range"),
    /* 286 */ Some("preadv2"),
    /* 287 */ Some("pwritev2"),
    /* 288 */ Some("pkey_mprotect"),
    /* 289 */ Some("pkey_alloc"),
    /* 290 */ Some("pkey_free"),
    /* 291 */ Some("statx"),
    /* 292 */ Some("io_pgetevents"),
    /* 293 */ Some("rseq"),
    /* 294 */ Some("kexec_file_load"),
    /* 295 */ None,
    /* 296 */ None,
    /* 297 */ None,
    /* 298 */ None,
    /* 299 */ None,
    /* 300 */ None,
    /* 301 */ None,
    /* 302 */ None,
    /* 303 */ None,
    /* 304 */ None,
    /* 305 */ None,
    /* 306 */ None,
    /* 307 */ None,
    /* 308 */ None,
    /* 309 */ None,
    /* 310 */ None,
    /* 311 */ None,
    /* 312 */ None,
    /* 313 */ None,
    /* 314 */ None,
    /* 315 */ None,
    /* 316 */ None,
    /* 317 */ None,
    /* 318 */ None,
    /* 319 */ None,
    /* 320 */ None,
    /* 321 */ None,
    /* 322 */ None,
    /* 323 */ None,
    /* 324 */ None,
    /* 325 */ None,
    /* 326 */ None,
    /* 327 */ None,
    /* 328 */ None,
    /* 329 */ None,
    /* 330 */ None,
    /* 331 */ None,
    /* 332 */ None,
    /* 333 */ None,
    /* 334 */ None,
    /* 335 */ None,
    /* 336 */ None,
    /* 337 */ None,
    /* 338 */ None,
    /* 339 */ None,
    /* 340 */ None,
    /* 341 */ None,
    /* 342 */ None,
    /* 343 */ None,
    /* 344 */ None,
    /* 345 */ None,
    /* 346 */ None,
    /* 347 */ None,
    /* 348 */ None,
    /* 349 */ None,
    /* 350 */ None,
    /* 351 */ None,
    /* 352 */ None,
    /* 353 */ None,
    /* 354 */ None,
    /* 355 */ None,
    /* 356 */ None,
    /* 357 */ None,
    /* 358 */ None,
    /* 359 */ None,
    /* 360 */ None,
    /* 361 */ None,
    /* 362 */ None,
    /* 363 */ None,
    /* 364 */ None,
    /* 365 */ None,
    /* 366 */ None,
    /* 367 */ None,
    /* 368 */ None,
    /* 369 */ None,
    /* 370 */ None,
    /* 371 */ None,
    /* 372 */ None,
    /* 373 */ None,
    /* 374 */ None,
    /* 375 */ None,
    /* 376 */ None,
    /* 377 */ None,
    /* 378 */ None,
    /* 379 */ None,
    /* 380 */ None,
    /* 381 */ None,
    /* 382 */ None,
    /* 383 */ None,
    /* 384 */ None,
    /* 385 */ None,
    /* 386 */ None,
    /* 387 */ None,
    /* 388 */ None,
    /* 389 */ None,
    /* 390 */ None,
    /* 391 */ None,
    /* 392 */ None,
    /* 393 */ None,
    /* 394 */ None,
    /* 395 */ None,
    /* 396 */ None,
    /* 397 */ None,
    /* 398 */ None,
    /* 399 */ None,
    /* 400 */ None,
    /* 401 */ None,
    /* 402 */ None,
    /* 403 */ Some("clock_gettime64"),
    /* 404 */ Some("clock_settime64"),
    /* 405 */ Some("clock_adjtime64"),
    /* 406 */ Some("clock_getres_time64"),
    /* 407 */ Some("clock_nanosleep_time64"),
    /* 408 */ Some("timer_gettime64"),
    /* 409 */ Some("timer_settime64"),
    /* 410 */ Some("timerfd_gettime64"),
    /* 411 */ Some("timerfd_settime64"),
    /* 412 */ Some("utimensat_time64"),
    /* 413 */ Some("pselect6_time64"),
    /* 414 */ Some("ppoll_time64"),
    /* 415 */ None,
    /* 416 */ Some("io_pgetevents_time64"),
    /* 417 */ Some("recvmmsg_time64"),
    /* 418 */ Some("mq_timedsend_time64"),
    /* 419 */ Some("mq_timedreceive_time64"),
    /* 420 */ Some("semtimedop_time64"),
    /* 421 */ Some("rt_sigtimedwait_time64"),
    /* 422 */ Some("futex_time64"),
    /* 423 */ Some("sched_rr_get_interval_time64"),
    /* 424 */ Some("pidfd_send_signal"),
    /* 425 */ Some("io_uring_setup"),
    /* 426 */ Some("io_uring_enter"),
    /* 427 */ Some("io_uring_register"),
    /* 428 */ Some("open_tree"),
    /* 429 */ Some("move_mount"),
    /* 430 */ Some("fsopen"),
    /* 431 */ Some("fsconfig"),
    /* 432 */ Some("fsmount"),
    /* 433 */ Some("fspick"),
    /* 434 */ Some("pidfd_open"),
    /* 435 */ Some("clone3"),
    /* 436 */ Some("close_range"),
    /* 437 */ Some("openat2"),
    /* 438 */ Some("pidfd_getfd"),
    /* 439 */ Some("faccessat2"),
    /* 440 */ Some("process_madvise"),
    /* 441 */ Some("epoll_pwait2"),
    /* 442 */ Some("mount_setattr"),
    /* 443 */ Some("quotactl_fd"),
    /* 444 */ Some("landlock_create_ruleset"),
    /* 445 */ Some("landlock_add_rule"),
    /* 446 */ Some("landlock_restrict_self"),
    /* 447 */ Some("memfd_secret"),
    /* 448 */ Some("process_mrelease"),
    /* 449 */ Some("futex_waitv"),
    /* 450 */ Some("set_mempolicy_home_node"),
    /* 451 */ Some("cachestat"),
    /* 452 */ Some("fchmodat2"),
    /* 453 */ Some("map_shadow_stack"),
    /* 454 */ Some("futex_wake"),
    /* 455 */ Some("futex_wait"),
    /* 456 */ Some("futex_requeue"),
    /* 457 */ Some("statmount"),
    /* 458 */ Some("listmount"),
    /* 459 */ Some("lsm_get_self_attr"),
    /* 460 */ Some("lsm_set_self_attr"),
    /* 461 */ Some("lsm_list_modules"),
    /* 462 */ Some("mseal"),
    /* 463 */ Some("setxattrat"),
    /* 464 */ Some("getxattrat"),
    /* 465 */ Some("listxattrat"),
    /* 466 */ Some("removexattrat"),
    /* 467 */ Some("open_tree_attr"),
    /* 468 */ Some("file_getattr"),
    /* 469 */ Some("file_setattr"),
    /* 470 */ Some("listns"),
];