Compare commits

..
Author SHA1 Message Date
Ole André Vadla Ravnås e0ada4a9ff [WIP] Toy around with a potential Softwall feature 2026-02-12 23:13:19 +01:00
Ole André Vadla Ravnås 690d7005fa syscall-tracer: Capture more structured args
Log non-primitive in/out syscall arguments for a broader set of calls.

This extends the eBPF tracer to attach common structured arguments
(strings, paths, timespec/stat buffers, and socket addresses) on enter
and exit, including multi-argument cases like two-path operations and
mount(2) (source/target/fstype).

Userspace decoding is now guided by syscall signature arg types (e.g.
only attempt sockaddr parsing for "struct sockaddr *"), reducing
per-syscall special-casing.
2026-02-12 20:44:54 +01:00
Ole André Vadla Ravnås b68585027b syscall-tracer: Expose ABI and track file mappings
Also clamp arguments based on signatures.
2026-02-12 15:54:04 +01:00
Ole André Vadla Ravnås eb457fddba meson: Add libbpf to the toplevel deps and reqs 2026-02-12 14:18:06 +01:00
Ole André Vadla Ravnås e9c1ead852 linux: Omit trailing newline from eBPF kernel log 2026-02-09 22:21:24 +01:00
Ole André Vadla Ravnås e2826c9d38 subprojects: Bump outdated 2026-02-07 21:19:39 +01:00
Ole André Vadla Ravnås 66c517b76a linux: Fix syscall-trace signatures response 2026-02-07 21:15:07 +01:00
Ole André Vadla Ravnås 3b05c631f9 linux: Migrate to libbpf
So we can start using BTF relocations, for true CO-RE.
2026-02-07 21:12:48 +01:00
Ole André Vadla Ravnås 3ae919fb97 api: Fix .gir filtering
Apparently AgentMessageSink either ends up in Frida or FridaBase,
depending on the build environment. Hmm. Rabbit hole for another day.
2026-02-07 13:34:16 +01:00
Ole André Vadla Ravnås bbe4872c73 Revert "api: Fix a .gir filtering regression"
Makes no sense that this would change namespace.

This reverts commit 01665c9e1a.
2026-02-06 23:35:27 +01:00
Ole André Vadla Ravnås f114e92502 linux: Add SyscallTracer and ActivitySampler
Only SyscallTracer is exposed for now. It is exposed as a Service.
2026-02-06 14:00:48 +01:00
Ole André Vadla Ravnås de03a755b1 linux: Add API for retrieving syscall signatures 2026-02-06 14:00:41 +01:00
Ole André Vadla Ravnås b62d5f9f83 linux: Add Bpf.PercpuArrayMap.foreach_value() 2026-01-29 16:46:05 +01:00
Ole André Vadla Ravnås 67d9423e90 icons: Use uint16 for width and height
Both as it makes more sense than int64, and so these don't end up as
BigInt values in frida-node.
2026-01-29 12:13:00 +01:00
Ole André Vadla Ravnås 06a28acc76 macos: Omit width and height for PNG icons 2026-01-29 12:12:52 +01:00
Ole André Vadla Ravnås 144ec84483 api: Omit the new Bpf.RingbufReader enum names 2026-01-28 23:29:31 +01:00
Ole André Vadla Ravnås 623531a385 linux: Improve the Bpf.RingbufReader.drain() API
- Let the caller know whether it got fully drained.
- Rename DrainResult to RecordAction.
2026-01-28 22:20:46 +01:00
Ole André Vadla Ravnås f365831c05 droidy: Support consuming remote services 2026-01-27 15:24:09 +01:00
Ole André Vadla Ravnås e5efd8ba89 local-host-session: Support implementing services 2026-01-27 15:24:09 +01:00
Ole André Vadla Ravnås 01665c9e1a api: Fix a .gir filtering regression
Due to AgentMessageSink now being in the Frida namespace.
2026-01-27 15:23:34 +01:00
Ole André Vadla Ravnås 944c7acaec api: Omit the internal DrainResult enum 2026-01-27 14:42:42 +01:00
Ole André Vadla Ravnås 9a3ee39e78 linux: Add Bpf.RingbufReader drain stop support 2026-01-27 13:59:02 +01:00
Ole André Vadla Ravnås 97cf8dc68d linux: Add Bpf.HashMap.remove() 2026-01-27 13:58:57 +01:00
Ole André Vadla Ravnås 09cab2e08c linux: Fix some stylistic inconsistencies 2026-01-27 13:58:50 +01:00
Ole André Vadla RavnåsandHåvard Sørbø e4372b42f3 linux-syscalls: Emit .h with preprocessor defines
Instead of enum values. In this way we can check for syscall
availability at the preprocessor level.

Co-authored-by: Håvard Sørbø <[email protected]>
2026-01-26 19:30:25 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 52b93ce299 linux: Add Bpf.HashMap
Co-authored-by: Håvard Sørbø <[email protected]>
2026-01-26 19:30:19 +01:00
Ole André Vadla Ravnås 58d3bd1251 linux-syscalls: Support --abi=armbe 2026-01-26 17:49:45 +01:00
Ole André Vadla Ravnås c4c101972e linux-syscalls: Refactor generate-bindings.py
To remove an unused function and fix a stylistic inconsistency.
2026-01-26 17:49:41 +01:00
Ole André Vadla Ravnås 8463e7514f linux: Improve the Bpf.RingbufReader API 2026-01-26 17:49:34 +01:00
Ole André Vadla Ravnås dd06ba6c54 linux: Improve the Bpf.StackTraceMap API 2026-01-26 17:49:29 +01:00
Ole André Vadla Ravnås 542c7a4014 linux: Add Bpf.PercpuArrayMap 2026-01-26 17:49:24 +01:00
Ole André Vadla Ravnås ea16ec8ea7 linux: Improve eBPF relocation error message 2026-01-26 17:49:20 +01:00
Ole André Vadla Ravnås d7a866af47 linux: Re-organize helper artifacts 2026-01-26 01:49:43 +01:00
Ole André Vadla Ravnås 3686e0e5c3 base: Improve the linux-syscalls autogen
- Move capabilities logic into the generator.
- Support C header output.
- Support remaining ABIs.
2026-01-26 01:48:32 +01:00
Ole André Vadla Ravnås 9d91e52490 base: Add auto-generated LinuxSyscall enum 2026-01-25 21:50:26 +01:00
Ole André Vadla Ravnås f055550e38 linux: Add eBPF and perf_event_open() helpers 2026-01-25 01:03:32 +01:00
96 changed files with 14663 additions and 343 deletions

No files matched your search

+27
View File
@@ -0,0 +1,27 @@
#ifndef __FRIDA_ATOMICS_H__
#define __FRIDA_ATOMICS_H__
#ifdef _MSC_VER
/* TODO: Add once needed. */
#else
static inline guint64 frida_atomics_load_u64_acquire (volatile guint64 * p)
{
return __atomic_load_n (p, __ATOMIC_ACQUIRE);
}
static inline void frida_atomics_store_u64_release (volatile guint64 * p, guint64 v)
{
__atomic_store_n (p, v, __ATOMIC_RELEASE);
}
static inline guint32 frida_atomics_load_u32_acquire (volatile guint32 * p)
{
return __atomic_load_n (p, __ATOMIC_ACQUIRE);
}
#endif
#endif
+6
View File
@@ -0,0 +1,6 @@
[CCode (cheader_filename = "frida-atomics.h")]
namespace Frida.Atomics {
public static uint64 load_u64_acquire (void * p);
public static void store_u64_release (void * p, uint64 v);
public static uint32 load_u32_acquire (void * p);
}
+20
View File
@@ -0,0 +1,20 @@
#ifndef __FRIDA_LINUX_BPF_H__
#define __FRIDA_LINUX_BPF_H__
#include <glib.h>
G_BEGIN_DECLS
#define FRIDA_BPF_RINGBUF_HEADER_SIZE 8
typedef guint32 FridaBpfRingbufFlags;
enum _FridaBpfRingbufFlags
{
FRIDA_BPF_RINGBUF_BUSY = (1U << 31),
FRIDA_BPF_RINGBUF_DISCARD = (1U << 30),
};
G_END_DECLS
#endif
+54
View File
@@ -0,0 +1,54 @@
#ifndef __FRIDA_LINUX_PERF_EVENT_H__
#define __FRIDA_LINUX_PERF_EVENT_H__
#include <glib.h>
G_BEGIN_DECLS
#define FRIDA_PERF_EVENT_COUNT_SW_CPU_CLOCK 0
typedef struct _FridaPerfEventAttr FridaPerfEventAttr;
typedef guint32 FridaPerfEventType;
struct _FridaPerfEventAttr
{
FridaPerfEventType event_type;
guint32 size;
guint64 config;
union
{
guint64 sample_period;
guint64 sample_freq;
};
guint64 sample_type;
guint64 read_format;
guint64 flags;
guint32 wakeup_events;
guint32 bp_type;
union
{
guint64 bp_addr;
guint64 config1;
};
union
{
guint64 bp_len;
guint64 config2;
};
};
enum _FridaPerfEventType
{
FRIDA_PERF_EVENT_TYPE_HARDWARE,
FRIDA_PERF_EVENT_TYPE_SOFTWARE,
};
G_END_DECLS
#endif
+58
View File
@@ -0,0 +1,58 @@
namespace Frida {
[CCode (cheader_filename = "dlfcn.h", cname = "dlopen")]
public void * dlopen (string filename, int flags);
[CCode (cheader_filename = "dlfcn.h", cname = "dlclose")]
public int dlclose (void * handle);
[CCode (cheader_filename = "dlfcn.h", cname = "dlsym")]
public void * dlsym (void * handle, string symbol);
[CCode (cheader_filename = "dlfcn.h", cname = "dlerror")]
public unowned string dlerror ();
[CCode (cheader_filename = "sys/mman.h", cname = "MAP_ANONYMOUS")]
public const int MAP_ANONYMOUS;
[CCode (cheader_filename = "frida-linux-bpf.h", cprefix = "FRIDA_BPF_RINGBUF_", has_type_id = false)]
[Flags]
public enum BpfRingbufFlags {
BUSY,
DISCARD,
}
[CCode (cheader_filename = "frida-linux-bpf.h")]
public const uint32 BPF_RINGBUF_HEADER_SIZE;
[CCode (cheader_filename = "frida-linux-perf-event.h")]
public const int PERF_EVENT_TYPE_SOFTWARE;
[CCode (cheader_filename = "frida-linux-perf-event.h")]
public const int PERF_EVENT_COUNT_SW_CPU_CLOCK;
[CCode (cheader_filename = "frida-linux-perf-event.h", has_type_id = false)]
public struct PerfEventAttr {
public PerfEventType event_type;
public uint32 size;
public uint64 config;
public uint64 sample_period;
public uint64 sample_type;
public uint64 read_format;
public uint64 flags;
public uint32 wakeup_events;
public uint32 bp_type;
public uint64 config1;
public uint64 config2;
}
[CCode (cheader_filename = "frida-linux-perf-event.h", has_type_id = false)]
public enum PerfEventType {
HARDWARE,
SOFTWARE,
}
}
-73
View File
@@ -1,73 +0,0 @@
#ifndef __FRIDA_LINUX_SYSCALL_H__
#define __FRIDA_LINUX_SYSCALL_H__
#include <linux/unistd.h>
#include <sys/syscall.h>
#undef SYS_process_vm_readv
#undef SYS_process_vm_writev
#undef SYS_memfd_create
#undef SYS_pidfd_open
#undef SYS_pidfd_getfd
#if defined (HAVE_I386) && GLIB_SIZEOF_VOID_P == 4
# define SYS_process_vm_readv 347
# define SYS_process_vm_writev 348
# define SYS_memfd_create 356
# define SYS_pidfd_open 434
# define SYS_pidfd_getfd 438
#elif defined (HAVE_I386) && GLIB_SIZEOF_VOID_P == 8
# define SYS_process_vm_readv 310
# define SYS_process_vm_writev 311
# define SYS_memfd_create 319
# define SYS_pidfd_open 434
# define SYS_pidfd_getfd 438
#elif defined (HAVE_ARM)
# define SYS_process_vm_readv (__NR_SYSCALL_BASE + 376)
# define SYS_process_vm_writev (__NR_SYSCALL_BASE + 377)
# define SYS_memfd_create (__NR_SYSCALL_BASE + 385)
# define SYS_pidfd_open (__NR_SYSCALL_BASE + 434)
# define SYS_pidfd_getfd (__NR_SYSCALL_BASE + 438)
#elif defined (HAVE_ARM64)
# define SYS_process_vm_readv 270
# define SYS_process_vm_writev 271
# define SYS_memfd_create 279
# define SYS_pidfd_open 434
# define SYS_pidfd_getfd 438
#elif defined (HAVE_MIPS)
# if _MIPS_SIM == _MIPS_SIM_ABI32
# define SYS_process_vm_readv (__NR_Linux + 345)
# define SYS_process_vm_writev (__NR_Linux + 346)
# define SYS_memfd_create (__NR_Linux + 354)
# define SYS_pidfd_open (__NR_Linux + 434)
# define SYS_pidfd_getfd (__NR_Linux + 438)
# elif _MIPS_SIM == _MIPS_SIM_ABI64
# define SYS_process_vm_readv (__NR_Linux + 304)
# define SYS_process_vm_writev (__NR_Linux + 305)
# define SYS_memfd_create (__NR_Linux + 314)
# define SYS_pidfd_open (__NR_Linux + 434)
# define SYS_pidfd_getfd (__NR_Linux + 438)
# elif _MIPS_SIM == _MIPS_SIM_NABI32
# define SYS_process_vm_readv (__NR_Linux + 309)
# define SYS_process_vm_writev (__NR_Linux + 310)
# define SYS_memfd_create (__NR_Linux + 318)
# define SYS_pidfd_open (__NR_Linux + 434)
# define SYS_pidfd_getfd (__NR_Linux + 438)
# else
# error Unexpected MIPS ABI
# endif
#elif defined (HAVE_RISCV)
# if GLIB_SIZEOF_VOID_P == 8
# define SYS_process_vm_readv 270
# define SYS_process_vm_writev 271
# define SYS_memfd_create 279
# define SYS_pidfd_open 434
# define SYS_pidfd_getfd 438
# else
# error RISC-V 32-bit not yet supported
# endif
#else
# error FIXME
#endif
#endif
+25
View File
@@ -0,0 +1,25 @@
KERNEL_TREE ?= $(HOME)/src/linux
archs := \
x86 \
x86_64 \
arm \
arm64 \
mips \
mips64 \
s390x \
$(NULL)
all: $(foreach arch,$(archs),$(arch).vala)
clean:
$(RM) $(foreach arch,$(archs),$(arch).vala $(arch)-glue.c)
%.vala %-glue.c:
./generate-bindings.py \
--abi=$* \
--kernel-tree=$(KERNEL_TREE) \
--out-vala=$*.vala \
--out-c=$*-glue.c
.PHONY: all clean
+451
View File
@@ -0,0 +1,451 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 0, "restart_syscall", 0, {} },
{ 1, "exit", 1, { { "int", "error_code" } } },
{ 2, "fork", 0, {} },
{ 3, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 6, "close", 1, { { "unsigned int", "fd" } } },
{ 8, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 9, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 10, "unlink", 1, { { "const char *", "pathname" } } },
{ 11, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 12, "chdir", 1, { { "const char *", "filename" } } },
{ 13, "time", 1, { { "old_time32_t *", "tloc" } } },
{ 14, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 15, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 16, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 19, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 20, "getpid", 0, {} },
{ 21, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 22, "umount", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 23, "setuid", 1, { { "uid_t", "uid" } } },
{ 24, "getuid", 0, {} },
{ 25, "stime", 1, { { "old_time32_t *", "tptr" } } },
{ 26, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 27, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 29, "pause", 0, {} },
{ 30, "utime", 2, { { "const char *", "filename" }, { "struct old_utimbuf32 *", "t" } } },
{ 33, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 34, "nice", 1, { { "int", "increment" } } },
{ 36, "sync", 0, {} },
{ 37, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 38, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 39, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 40, "rmdir", 1, { { "const char *", "pathname" } } },
{ 41, "dup", 1, { { "unsigned int", "fildes" } } },
{ 42, "pipe", 1, { { "int *", "fildes" } } },
{ 43, "times", 1, { { "struct tms *", "tbuf" } } },
{ 45, "brk", 1, { { "unsigned long", "brk" } } },
{ 46, "setgid", 1, { { "gid_t", "gid" } } },
{ 47, "getgid", 0, {} },
{ 49, "geteuid", 0, {} },
{ 50, "getegid", 0, {} },
{ 51, "acct", 1, { { "const char *", "name" } } },
{ 52, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 54, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 55, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 57, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 60, "umask", 1, { { "int", "mask" } } },
{ 61, "chroot", 1, { { "const char *", "filename" } } },
{ 62, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 63, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 64, "getppid", 0, {} },
{ 65, "getpgrp", 0, {} },
{ 66, "setsid", 0, {} },
{ 67, "sigaction", 3, { { "int", "sig" }, { "const struct old_sigaction *", "act" }, { "struct old_sigaction *", "oact" } } },
{ 70, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 71, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 72, "sigsuspend", 3, { { "int", "unused1" }, { "int", "unused2" }, { "old_sigset_t", "mask" } } },
{ 73, "sigpending", 1, { { "old_sigset_t *", "uset" } } },
{ 74, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 75, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 76, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 77, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 78, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 79, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 80, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 81, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 82, "select", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 83, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 85, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 86, "uselib", 1, { { "const char *", "library" } } },
{ 87, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 88, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 89, "readdir", 3, { { "unsigned", "int" }, { "struct old_linux_dirent *", "arg1" }, { "unsigned", "int" } } },
{ 90, "mmap", 1, { { "struct mmap_arg_struct *", "arg" } } },
{ 91, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 92, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 93, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 94, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 95, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 96, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 97, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 99, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 102, "socketcall", 2, { { "int", "call" }, { "unsigned long *", "args" } } },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 105, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 106, "stat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 107, "lstat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 108, "fstat", 2, { { "unsigned int", "fd" }, { "struct stat *", "statbuf" } } },
{ 111, "vhangup", 0, {} },
{ 114, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 116, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 117, "ipc", 6, { { "unsigned int", "call" }, { "int", "first" }, { "unsigned long", "second" }, { "unsigned long", "third" }, { "void *", "ptr" }, { "long", "fifth" } } },
{ 118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 122, "uname", 1, { { "struct new_utsname *", "name" } } },
{ 124, "adjtimex", 1, { { "struct old_timex32 *", "txc_p" } } },
{ 125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 126, "sigprocmask", 3, { { "int", "how" }, { "old_sigset_t *", "nset" }, { "old_sigset_t *", "oset" } } },
{ 128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 134, "bdflush", 0, {} },
{ 135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 136, "personality", 1, { { "unsigned int", "personality" } } },
{ 138, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 139, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 140, "_llseek", 5, { { "unsigned int", "fd" }, { "unsigned long", "offset_high" }, { "unsigned long", "offset_low" }, { "loff_t *", "result" }, { "unsigned int", "whence" } } },
{ 141, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 142, "_newselect", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 147, "getsid", 1, { { "pid_t", "pid" } } },
{ 148, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 149, "_sysctl", 0, {} },
{ 150, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 152, "mlockall", 1, { { "int", "flags" } } },
{ 153, "munlockall", 0, {} },
{ 154, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 155, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 156, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 157, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 158, "sched_yield", 0, {} },
{ 159, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 160, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 161, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 162, "nanosleep", 2, { { "struct old_timespec32 *", "rqtp" }, { "struct old_timespec32 *", "rmtp" } } },
{ 163, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 164, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 165, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 168, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 170, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 171, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 172, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 174, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 175, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 176, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 177, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 178, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 179, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 180, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 181, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 182, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 183, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 184, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 185, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 186, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 187, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 190, "vfork", 0, {} },
{ 191, "ugetrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 193, "truncate64", 2, { { "const char *", "path" }, { "loff_t", "length" } } },
{ 194, "ftruncate64", 2, { { "unsigned int", "fd" }, { "loff_t", "length" } } },
{ 195, "stat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 196, "lstat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 197, "fstat64", 2, { { "unsigned long", "fd" }, { "struct stat64 *", "statbuf" } } },
{ 198, "lchown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 199, "getuid32", 0, {} },
{ 200, "getgid32", 0, {} },
{ 201, "geteuid32", 0, {} },
{ 202, "getegid32", 0, {} },
{ 203, "setreuid32", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 204, "setregid32", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 205, "getgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 206, "setgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 207, "fchown32", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 208, "setresuid32", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 209, "getresuid32", 3, { { "uid_t *", "ruid" }, { "uid_t *", "euid" }, { "uid_t *", "suid" } } },
{ 210, "setresgid32", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 211, "getresgid32", 3, { { "gid_t *", "rgid" }, { "gid_t *", "egid" }, { "gid_t *", "sgid" } } },
{ 212, "chown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 213, "setuid32", 1, { { "uid_t", "uid" } } },
{ 214, "setgid32", 1, { { "gid_t", "gid" } } },
{ 215, "setfsuid32", 1, { { "uid_t", "uid" } } },
{ 216, "setfsgid32", 1, { { "gid_t", "gid" } } },
{ 217, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 218, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 219, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 220, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 221, "fcntl64", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 224, "gettid", 0, {} },
{ 225, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 226, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 227, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 228, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 229, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 230, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 231, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 232, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 233, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 234, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 235, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 236, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 237, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 238, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 239, "sendfile64", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "loff_t *", "offset" }, { "size_t", "count" } } },
{ 240, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 241, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 242, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 243, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 244, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 245, "io_getevents", 5, { { "__u32", "ctx_id" }, { "__s32", "min_nr" }, { "__s32", "nr" }, { "struct io_event *", "events" }, { "struct old_timespec32 *", "timeout" } } },
{ 246, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 247, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 248, "exit_group", 1, { { "int", "error_code" } } },
{ 249, "lookup_dcookie", 0, {} },
{ 250, "epoll_create", 1, { { "int", "size" } } },
{ 251, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 252, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 253, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 256, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 257, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 258, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 259, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 260, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 261, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 262, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 263, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 264, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 265, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 266, "statfs64", 3, { { "const char *", "pathname" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 267, "fstatfs64", 3, { { "unsigned int", "fd" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 268, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 269, "utimes", 2, { { "const char *", "filename" }, { "struct old_timeval32 *", "t" } } },
{ 271, "pciconfig_iobase", 3, { { "long", "which" }, { "unsigned long", "bus" }, { "unsigned long", "devfn" } } },
{ 272, "pciconfig_read", 5, { { "unsigned long", "bus" }, { "unsigned long", "dfn" }, { "unsigned long", "off" }, { "unsigned long", "len" }, { "void *", "buf" } } },
{ 273, "pciconfig_write", 5, { { "unsigned long", "bus" }, { "unsigned long", "dfn" }, { "unsigned long", "off" }, { "unsigned long", "len" }, { "void *", "buf" } } },
{ 274, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 275, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 276, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 277, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 278, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 279, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 280, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 281, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 282, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 283, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 284, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 285, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 286, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 287, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 288, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 289, "send", 4, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 290, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 291, "recv", 4, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" } } },
{ 292, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 293, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 294, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 295, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 296, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 297, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 298, "semop", 3, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned", "nsops" } } },
{ 299, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 300, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 301, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 302, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 303, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 304, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 305, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 306, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 307, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 308, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 309, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 310, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 311, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 312, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 314, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 315, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 316, "inotify_init", 0, {} },
{ 317, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 318, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 319, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 320, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 321, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 322, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 323, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 324, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 325, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 326, "futimesat", 3, { { "unsigned int", "dfd" }, { "const char *", "filename" }, { "struct old_timeval32 *", "t" } } },
{ 327, "fstatat64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat64 *", "statbuf" }, { "int", "flag" } } },
{ 328, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 329, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 330, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 331, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 332, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 333, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 334, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 335, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 336, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 337, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 338, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 339, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 340, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 341, "arm_sync_file_range", 4, { { "int", "fd" }, { "unsigned int", "flags" }, { "loff_t", "offset" }, { "loff_t", "nbytes" } } },
{ 342, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 343, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 344, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 345, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 346, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 347, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 348, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 349, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 350, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 351, "eventfd", 1, { { "unsigned int", "count" } } },
{ 352, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 353, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 354, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 355, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 356, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 357, "epoll_create1", 1, { { "int", "flags" } } },
{ 358, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 359, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 360, "inotify_init1", 1, { { "int", "flags" } } },
{ 361, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 362, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 363, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 364, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 365, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 366, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 367, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 368, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 369, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 370, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 371, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 372, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 373, "syncfs", 1, { { "int", "fd" } } },
{ 374, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 375, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 376, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 377, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 378, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 379, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 380, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 381, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 382, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 383, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 384, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 385, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 386, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 387, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 388, "userfaultfd", 1, { { "int", "flags" } } },
{ 389, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 390, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 391, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 392, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 393, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 394, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 395, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 396, "pkey_free", 1, { { "int", "pkey" } } },
{ 397, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 398, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 399, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 400, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 401, "kexec_file_load", 5, { { "int", "kernel_fd" }, { "int", "initrd_fd" }, { "unsigned long", "cmdline_len" }, { "const char *", "cmdline_ptr" }, { "unsigned long", "flags" } } },
{ 403, "clock_gettime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 404, "clock_settime64", 2, { { "clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 405, "clock_adjtime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timex *", "tx" } } },
{ 406, "clock_getres_time64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 407, "clock_nanosleep_time64", 4, { { "clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 408, "timer_gettime64", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 409, "timer_settime64", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 410, "timerfd_gettime64", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 411, "timerfd_settime64", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 412, "utimensat_time64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 413, "pselect6_time64", 6, { { "int", "arg0" }, { "fd_set *", "arg1" }, { "fd_set *", "arg2" }, { "fd_set *", "arg3" }, { "struct __kernel_timespec *", "arg4" }, { "void *", "arg5" } } },
{ 414, "ppoll_time64", 5, { { "struct pollfd *", "arg0" }, { "unsigned", "int" }, { "struct __kernel_timespec *", "arg2" }, { "const sigset_t *", "arg3" }, { "size_t", "arg4" } } },
{ 416, "io_pgetevents_time64", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "sig" } } },
{ 417, "recvmmsg_time64", 5, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 418, "mq_timedsend_time64", 5, { { "mqd_t", "mqdes" }, { "const char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 419, "mq_timedreceive_time64", 5, { { "mqd_t", "mqdes" }, { "char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 420, "semtimedop_time64", 4, { { "int", "semid" }, { "struct sembuf *", "sops" }, { "unsigned", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 421, "rt_sigtimedwait_time64", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 422, "futex_time64", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 423, "sched_rr_get_interval_time64", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = 0;
return NULL;
}
+434
View File
@@ -0,0 +1,434 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
RESTART_SYSCALL = 0,
EXIT = 1,
FORK = 2,
READ = 3,
WRITE = 4,
OPEN = 5,
CLOSE = 6,
CREAT = 8,
LINK = 9,
UNLINK = 10,
EXECVE = 11,
CHDIR = 12,
TIME = 13,
MKNOD = 14,
CHMOD = 15,
LCHOWN = 16,
LSEEK = 19,
GETPID = 20,
MOUNT = 21,
UMOUNT = 22,
SETUID = 23,
GETUID = 24,
STIME = 25,
PTRACE = 26,
ALARM = 27,
PAUSE = 29,
UTIME = 30,
ACCESS = 33,
NICE = 34,
SYNC = 36,
KILL = 37,
RENAME = 38,
MKDIR = 39,
RMDIR = 40,
DUP = 41,
PIPE = 42,
TIMES = 43,
BRK = 45,
SETGID = 46,
GETGID = 47,
GETEUID = 49,
GETEGID = 50,
ACCT = 51,
UMOUNT2 = 52,
IOCTL = 54,
FCNTL = 55,
SETPGID = 57,
UMASK = 60,
CHROOT = 61,
USTAT = 62,
DUP2 = 63,
GETPPID = 64,
GETPGRP = 65,
SETSID = 66,
SIGACTION = 67,
SETREUID = 70,
SETREGID = 71,
SIGSUSPEND = 72,
SIGPENDING = 73,
SETHOSTNAME = 74,
SETRLIMIT = 75,
GETRLIMIT = 76,
GETRUSAGE = 77,
GETTIMEOFDAY = 78,
SETTIMEOFDAY = 79,
GETGROUPS = 80,
SETGROUPS = 81,
SELECT = 82,
SYMLINK = 83,
READLINK = 85,
USELIB = 86,
SWAPON = 87,
REBOOT = 88,
READDIR = 89,
MMAP = 90,
MUNMAP = 91,
TRUNCATE = 92,
FTRUNCATE = 93,
FCHMOD = 94,
FCHOWN = 95,
GETPRIORITY = 96,
SETPRIORITY = 97,
STATFS = 99,
FSTATFS = 100,
SOCKETCALL = 102,
SYSLOG = 103,
SETITIMER = 104,
GETITIMER = 105,
STAT = 106,
LSTAT = 107,
FSTAT = 108,
VHANGUP = 111,
WAIT4 = 114,
SWAPOFF = 115,
SYSINFO = 116,
IPC = 117,
FSYNC = 118,
CLONE = 120,
SETDOMAINNAME = 121,
UNAME = 122,
ADJTIMEX = 124,
MPROTECT = 125,
SIGPROCMASK = 126,
INIT_MODULE = 128,
DELETE_MODULE = 129,
QUOTACTL = 131,
GETPGID = 132,
FCHDIR = 133,
BDFLUSH = 134,
SYSFS = 135,
PERSONALITY = 136,
SETFSUID = 138,
SETFSGID = 139,
_LLSEEK = 140,
GETDENTS = 141,
_NEWSELECT = 142,
FLOCK = 143,
MSYNC = 144,
READV = 145,
WRITEV = 146,
GETSID = 147,
FDATASYNC = 148,
_SYSCTL = 149,
MLOCK = 150,
MUNLOCK = 151,
MLOCKALL = 152,
MUNLOCKALL = 153,
SCHED_SETPARAM = 154,
SCHED_GETPARAM = 155,
SCHED_SETSCHEDULER = 156,
SCHED_GETSCHEDULER = 157,
SCHED_YIELD = 158,
SCHED_GET_PRIORITY_MAX = 159,
SCHED_GET_PRIORITY_MIN = 160,
SCHED_RR_GET_INTERVAL = 161,
NANOSLEEP = 162,
MREMAP = 163,
SETRESUID = 164,
GETRESUID = 165,
POLL = 168,
SETRESGID = 170,
GETRESGID = 171,
PRCTL = 172,
RT_SIGACTION = 174,
RT_SIGPROCMASK = 175,
RT_SIGPENDING = 176,
RT_SIGTIMEDWAIT = 177,
RT_SIGQUEUEINFO = 178,
RT_SIGSUSPEND = 179,
PREAD64 = 180,
PWRITE64 = 181,
CHOWN = 182,
GETCWD = 183,
CAPGET = 184,
CAPSET = 185,
SIGALTSTACK = 186,
SENDFILE = 187,
VFORK = 190,
UGETRLIMIT = 191,
TRUNCATE64 = 193,
FTRUNCATE64 = 194,
STAT64 = 195,
LSTAT64 = 196,
FSTAT64 = 197,
LCHOWN32 = 198,
GETUID32 = 199,
GETGID32 = 200,
GETEUID32 = 201,
GETEGID32 = 202,
SETREUID32 = 203,
SETREGID32 = 204,
GETGROUPS32 = 205,
SETGROUPS32 = 206,
FCHOWN32 = 207,
SETRESUID32 = 208,
GETRESUID32 = 209,
SETRESGID32 = 210,
GETRESGID32 = 211,
CHOWN32 = 212,
SETUID32 = 213,
SETGID32 = 214,
SETFSUID32 = 215,
SETFSGID32 = 216,
GETDENTS64 = 217,
PIVOT_ROOT = 218,
MINCORE = 219,
MADVISE = 220,
FCNTL64 = 221,
GETTID = 224,
READAHEAD = 225,
SETXATTR = 226,
LSETXATTR = 227,
FSETXATTR = 228,
GETXATTR = 229,
LGETXATTR = 230,
FGETXATTR = 231,
LISTXATTR = 232,
LLISTXATTR = 233,
FLISTXATTR = 234,
REMOVEXATTR = 235,
LREMOVEXATTR = 236,
FREMOVEXATTR = 237,
TKILL = 238,
SENDFILE64 = 239,
FUTEX = 240,
SCHED_SETAFFINITY = 241,
SCHED_GETAFFINITY = 242,
IO_SETUP = 243,
IO_DESTROY = 244,
IO_GETEVENTS = 245,
IO_SUBMIT = 246,
IO_CANCEL = 247,
EXIT_GROUP = 248,
LOOKUP_DCOOKIE = 249,
EPOLL_CREATE = 250,
EPOLL_CTL = 251,
EPOLL_WAIT = 252,
REMAP_FILE_PAGES = 253,
SET_TID_ADDRESS = 256,
TIMER_CREATE = 257,
TIMER_SETTIME = 258,
TIMER_GETTIME = 259,
TIMER_GETOVERRUN = 260,
TIMER_DELETE = 261,
CLOCK_SETTIME = 262,
CLOCK_GETTIME = 263,
CLOCK_GETRES = 264,
CLOCK_NANOSLEEP = 265,
STATFS64 = 266,
FSTATFS64 = 267,
TGKILL = 268,
UTIMES = 269,
PCICONFIG_IOBASE = 271,
PCICONFIG_READ = 272,
PCICONFIG_WRITE = 273,
MQ_OPEN = 274,
MQ_UNLINK = 275,
MQ_TIMEDSEND = 276,
MQ_TIMEDRECEIVE = 277,
MQ_NOTIFY = 278,
MQ_GETSETATTR = 279,
WAITID = 280,
SOCKET = 281,
BIND = 282,
CONNECT = 283,
LISTEN = 284,
ACCEPT = 285,
GETSOCKNAME = 286,
GETPEERNAME = 287,
SOCKETPAIR = 288,
SEND = 289,
SENDTO = 290,
RECV = 291,
RECVFROM = 292,
SHUTDOWN = 293,
SETSOCKOPT = 294,
GETSOCKOPT = 295,
SENDMSG = 296,
RECVMSG = 297,
SEMOP = 298,
SEMGET = 299,
SEMCTL = 300,
MSGSND = 301,
MSGRCV = 302,
MSGGET = 303,
MSGCTL = 304,
SHMAT = 305,
SHMDT = 306,
SHMGET = 307,
SHMCTL = 308,
ADD_KEY = 309,
REQUEST_KEY = 310,
KEYCTL = 311,
SEMTIMEDOP = 312,
IOPRIO_SET = 314,
IOPRIO_GET = 315,
INOTIFY_INIT = 316,
INOTIFY_ADD_WATCH = 317,
INOTIFY_RM_WATCH = 318,
MBIND = 319,
GET_MEMPOLICY = 320,
SET_MEMPOLICY = 321,
OPENAT = 322,
MKDIRAT = 323,
MKNODAT = 324,
FCHOWNAT = 325,
FUTIMESAT = 326,
FSTATAT64 = 327,
UNLINKAT = 328,
RENAMEAT = 329,
LINKAT = 330,
SYMLINKAT = 331,
READLINKAT = 332,
FCHMODAT = 333,
FACCESSAT = 334,
PSELECT6 = 335,
PPOLL = 336,
UNSHARE = 337,
SET_ROBUST_LIST = 338,
GET_ROBUST_LIST = 339,
SPLICE = 340,
ARM_SYNC_FILE_RANGE = 341,
TEE = 342,
VMSPLICE = 343,
MOVE_PAGES = 344,
GETCPU = 345,
EPOLL_PWAIT = 346,
KEXEC_LOAD = 347,
UTIMENSAT = 348,
SIGNALFD = 349,
TIMERFD_CREATE = 350,
EVENTFD = 351,
FALLOCATE = 352,
TIMERFD_SETTIME = 353,
TIMERFD_GETTIME = 354,
SIGNALFD4 = 355,
EVENTFD2 = 356,
EPOLL_CREATE1 = 357,
DUP3 = 358,
PIPE2 = 359,
INOTIFY_INIT1 = 360,
PREADV = 361,
PWRITEV = 362,
RT_TGSIGQUEUEINFO = 363,
PERF_EVENT_OPEN = 364,
RECVMMSG = 365,
ACCEPT4 = 366,
FANOTIFY_INIT = 367,
FANOTIFY_MARK = 368,
PRLIMIT64 = 369,
NAME_TO_HANDLE_AT = 370,
OPEN_BY_HANDLE_AT = 371,
CLOCK_ADJTIME = 372,
SYNCFS = 373,
SENDMMSG = 374,
SETNS = 375,
PROCESS_VM_READV = 376,
PROCESS_VM_WRITEV = 377,
KCMP = 378,
FINIT_MODULE = 379,
SCHED_SETATTR = 380,
SCHED_GETATTR = 381,
RENAMEAT2 = 382,
SECCOMP = 383,
GETRANDOM = 384,
MEMFD_CREATE = 385,
BPF = 386,
EXECVEAT = 387,
USERFAULTFD = 388,
MEMBARRIER = 389,
MLOCK2 = 390,
COPY_FILE_RANGE = 391,
PREADV2 = 392,
PWRITEV2 = 393,
PKEY_MPROTECT = 394,
PKEY_ALLOC = 395,
PKEY_FREE = 396,
STATX = 397,
RSEQ = 398,
IO_PGETEVENTS = 399,
MIGRATE_PAGES = 400,
KEXEC_FILE_LOAD = 401,
CLOCK_GETTIME64 = 403,
CLOCK_SETTIME64 = 404,
CLOCK_ADJTIME64 = 405,
CLOCK_GETRES_TIME64 = 406,
CLOCK_NANOSLEEP_TIME64 = 407,
TIMER_GETTIME64 = 408,
TIMER_SETTIME64 = 409,
TIMERFD_GETTIME64 = 410,
TIMERFD_SETTIME64 = 411,
UTIMENSAT_TIME64 = 412,
PSELECT6_TIME64 = 413,
PPOLL_TIME64 = 414,
IO_PGETEVENTS_TIME64 = 416,
RECVMMSG_TIME64 = 417,
MQ_TIMEDSEND_TIME64 = 418,
MQ_TIMEDRECEIVE_TIME64 = 419,
SEMTIMEDOP_TIME64 = 420,
RT_SIGTIMEDWAIT_TIME64 = 421,
FUTEX_TIME64 = 422,
SCHED_RR_GET_INTERVAL_TIME64 = 423,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
}
+790
View File
@@ -0,0 +1,790 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 0, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 1, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 2, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 3, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 4, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 5, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 6, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 7, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 8, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 9, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 10, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 11, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 12, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 13, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 14, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 15, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 16, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 17, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 18, "lookup_dcookie", 0, {} },
{ 19, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 20, "epoll_create1", 1, { { "int", "flags" } } },
{ 21, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 22, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 23, "dup", 1, { { "unsigned int", "fildes" } } },
{ 24, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 25, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 26, "inotify_init1", 1, { { "int", "flags" } } },
{ 27, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 28, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 29, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 30, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 31, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 32, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 33, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 34, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 35, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 36, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 37, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 39, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 40, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 41, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 42, "nfsservctl", 0, {} },
{ 43, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 44, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 45, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 46, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 47, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 48, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 49, "chdir", 1, { { "const char *", "filename" } } },
{ 50, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 51, "chroot", 1, { { "const char *", "filename" } } },
{ 52, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 53, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 54, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 55, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 56, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 57, "close", 1, { { "unsigned int", "fd" } } },
{ 58, "vhangup", 0, {} },
{ 59, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 60, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 61, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 62, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 63, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 64, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 65, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 66, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 67, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 68, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 69, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 70, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 71, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 72, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 73, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 74, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 75, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 76, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 77, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 78, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 79, "newfstatat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat *", "statbuf" }, { "int", "flag" } } },
{ 80, "fstat", 2, { { "unsigned int", "fd" }, { "struct stat *", "statbuf" } } },
{ 81, "sync", 0, {} },
{ 82, "fsync", 1, { { "unsigned int", "fd" } } },
{ 83, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 84, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 85, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 86, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 87, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 88, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 89, "acct", 1, { { "const char *", "name" } } },
{ 90, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 91, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 92, "personality", 1, { { "unsigned int", "personality" } } },
{ 93, "exit", 1, { { "int", "error_code" } } },
{ 94, "exit_group", 1, { { "int", "error_code" } } },
{ 95, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 96, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 97, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 98, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 99, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 100, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 101, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 102, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 103, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 104, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 105, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 106, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 107, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 108, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 109, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 110, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 111, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 112, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 113, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 114, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 115, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 116, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 117, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 118, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 119, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 120, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 121, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 122, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 123, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 124, "sched_yield", 0, {} },
{ 125, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 126, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 127, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 128, "restart_syscall", 0, {} },
{ 129, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 130, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 131, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 132, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 133, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 134, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 135, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 136, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 137, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 138, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 139, "rt_sigreturn", 0, {} },
{ 140, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 141, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 142, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 143, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 144, "setgid", 1, { { "gid_t", "gid" } } },
{ 145, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 146, "setuid", 1, { { "uid_t", "uid" } } },
{ 147, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 148, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 149, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 150, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 151, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 152, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 153, "times", 1, { { "struct tms *", "tbuf" } } },
{ 154, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 155, "getpgid", 1, { { "pid_t", "pid" } } },
{ 156, "getsid", 1, { { "pid_t", "pid" } } },
{ 157, "setsid", 0, {} },
{ 158, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 159, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 160, "uname", 1, { { "struct new_utsname *", "name" } } },
{ 161, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 162, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 163, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 164, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 165, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 166, "umask", 1, { { "int", "mask" } } },
{ 167, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 168, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 169, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 170, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 171, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 172, "getpid", 0, {} },
{ 173, "getppid", 0, {} },
{ 174, "getuid", 0, {} },
{ 175, "geteuid", 0, {} },
{ 176, "getgid", 0, {} },
{ 177, "getegid", 0, {} },
{ 178, "gettid", 0, {} },
{ 179, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 180, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 181, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 182, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 183, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 184, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 185, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 186, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 187, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 188, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 189, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 190, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 191, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 192, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 193, "semop", 3, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned", "nsops" } } },
{ 194, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 195, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 196, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 197, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 198, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 199, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 200, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 201, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 202, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 203, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 204, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 205, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 206, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 207, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 208, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 209, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 210, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 211, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 212, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 213, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 214, "brk", 1, { { "unsigned long", "brk" } } },
{ 215, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 216, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 217, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 218, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 219, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 220, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 221, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 222, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "off" } } },
{ 223, "fadvise64", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "len" }, { "int", "advice" } } },
{ 224, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 225, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 226, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 227, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 228, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 229, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 230, "mlockall", 1, { { "int", "flags" } } },
{ 231, "munlockall", 0, {} },
{ 232, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 233, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 234, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 235, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 236, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 237, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 238, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 239, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 240, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 241, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 242, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 243, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 260, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 261, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 262, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 263, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 264, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 265, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 266, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 267, "syncfs", 1, { { "int", "fd" } } },
{ 268, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 269, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 270, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 271, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 272, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 273, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 274, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 275, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 276, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 277, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 278, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 279, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 280, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 281, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 282, "userfaultfd", 1, { { "int", "flags" } } },
{ 283, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 284, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 285, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 286, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 287, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 288, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 289, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 290, "pkey_free", 1, { { "int", "pkey" } } },
{ 291, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 292, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 293, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 294, "kexec_file_load", 5, { { "int", "kernel_fd" }, { "int", "initrd_fd" }, { "unsigned long", "cmdline_len" }, { "const char *", "cmdline_ptr" }, { "unsigned long", "flags" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
static const FridaLinuxSyscallSignature frida_compat32_syscall_signatures[] =
{
{ 0, "restart_syscall", 0, {} },
{ 1, "exit", 1, { { "int", "error_code" } } },
{ 2, "fork", 0, {} },
{ 3, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 6, "close", 1, { { "unsigned int", "fd" } } },
{ 8, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 9, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 10, "unlink", 1, { { "const char *", "pathname" } } },
{ 11, "execve", 3, { { "const char *", "filename" }, { "const compat_uptr_t *", "argv" }, { "const compat_uptr_t *", "envp" } } },
{ 12, "chdir", 1, { { "const char *", "filename" } } },
{ 14, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 15, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 16, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 19, "lseek", 3, { { "unsigned int", "fd" }, { "compat_off_t", "offset" }, { "unsigned int", "whence" } } },
{ 20, "getpid", 0, {} },
{ 21, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 23, "setuid", 1, { { "uid_t", "uid" } } },
{ 24, "getuid", 0, {} },
{ 26, "ptrace", 4, { { "compat_long_t", "request" }, { "compat_long_t", "pid" }, { "compat_long_t", "addr" }, { "compat_long_t", "data" } } },
{ 29, "pause", 0, {} },
{ 33, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 34, "nice", 1, { { "int", "increment" } } },
{ 36, "sync", 0, {} },
{ 37, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 38, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 39, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 40, "rmdir", 1, { { "const char *", "pathname" } } },
{ 41, "dup", 1, { { "unsigned int", "fildes" } } },
{ 42, "pipe", 1, { { "int *", "fildes" } } },
{ 43, "times", 1, { { "struct compat_tms *", "tbuf" } } },
{ 45, "brk", 1, { { "unsigned long", "brk" } } },
{ 46, "setgid", 1, { { "gid_t", "gid" } } },
{ 47, "getgid", 0, {} },
{ 49, "geteuid", 0, {} },
{ 50, "getegid", 0, {} },
{ 51, "acct", 1, { { "const char *", "name" } } },
{ 52, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 54, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 55, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 57, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 60, "umask", 1, { { "int", "mask" } } },
{ 61, "chroot", 1, { { "const char *", "filename" } } },
{ 62, "ustat", 2, { { "unsigned", "dev" }, { "struct compat_ustat *", "u" } } },
{ 63, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 64, "getppid", 0, {} },
{ 65, "getpgrp", 0, {} },
{ 66, "setsid", 0, {} },
{ 67, "sigaction", 3, { { "int", "sig" }, { "const struct compat_old_sigaction *", "act" }, { "struct compat_old_sigaction *", "oact" } } },
{ 70, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 71, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 72, "sigsuspend", 3, { { "int", "unused1" }, { "int", "unused2" }, { "old_sigset_t", "mask" } } },
{ 73, "sigpending", 1, { { "compat_old_sigset_t *", "set32" } } },
{ 74, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 75, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct compat_rlimit *", "rlim" } } },
{ 77, "getrusage", 2, { { "int", "who" }, { "struct compat_rusage *", "ru" } } },
{ 78, "gettimeofday", 2, { { "struct old_timeval32 *", "tv" }, { "struct timezone *", "tz" } } },
{ 79, "settimeofday", 2, { { "struct old_timeval32 *", "tv" }, { "struct timezone *", "tz" } } },
{ 80, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 81, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 83, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 85, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 86, "uselib", 1, { { "const char *", "library" } } },
{ 87, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 88, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 91, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 92, "truncate", 2, { { "const char *", "path" }, { "compat_off_t", "length" } } },
{ 93, "ftruncate", 2, { { "unsigned int", "fd" }, { "compat_off_t", "length" } } },
{ 94, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 95, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 96, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 97, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 99, "statfs", 2, { { "const char *", "pathname" }, { "struct compat_statfs *", "buf" } } },
{ 100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct compat_statfs *", "buf" } } },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "setitimer", 3, { { "int", "which" }, { "struct old_itimerval32 *", "value" }, { "struct old_itimerval32 *", "ovalue" } } },
{ 105, "getitimer", 2, { { "int", "which" }, { "struct old_itimerval32 *", "value" } } },
{ 106, "stat", 2, { { "const char *", "filename" }, { "struct compat_stat *", "statbuf" } } },
{ 107, "lstat", 2, { { "const char *", "filename" }, { "struct compat_stat *", "statbuf" } } },
{ 108, "fstat", 2, { { "unsigned int", "fd" }, { "struct compat_stat *", "statbuf" } } },
{ 111, "vhangup", 0, {} },
{ 114, "wait4", 4, { { "compat_pid_t", "pid" }, { "compat_uint_t *", "stat_addr" }, { "int", "options" }, { "struct compat_rusage *", "ru" } } },
{ 115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 116, "sysinfo", 1, { { "struct compat_sysinfo *", "info" } } },
{ 118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 119, "sigreturn", 0, {} },
{ 120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 122, "uname", 1, { { "struct new_utsname *", "name" } } },
{ 124, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 126, "sigprocmask", 3, { { "int", "how" }, { "compat_old_sigset_t *", "nset" }, { "compat_old_sigset_t *", "oset" } } },
{ 128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 134, "bdflush", 0, {} },
{ 135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 136, "personality", 1, { { "unsigned int", "personality" } } },
{ 138, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 139, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 140, "_llseek", 5, { { "unsigned int", "fd" }, { "unsigned long", "offset_high" }, { "unsigned long", "offset_low" }, { "loff_t *", "result" }, { "unsigned int", "whence" } } },
{ 141, "getdents", 3, { { "unsigned int", "fd" }, { "struct compat_linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 142, "_newselect", 5, { { "int", "n" }, { "compat_ulong_t *", "inp" }, { "compat_ulong_t *", "outp" }, { "compat_ulong_t *", "exp" }, { "struct old_timeval32 *", "tvp" } } },
{ 143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 147, "getsid", 1, { { "pid_t", "pid" } } },
{ 148, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 149, "_sysctl", 0, {} },
{ 150, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 152, "mlockall", 1, { { "int", "flags" } } },
{ 153, "munlockall", 0, {} },
{ 154, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 155, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 156, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 157, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 158, "sched_yield", 0, {} },
{ 159, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 160, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 161, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 162, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 163, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 164, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 165, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 168, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 169, "nfsservctl", 0, {} },
{ 170, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 171, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 172, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 173, "rt_sigreturn", 0, {} },
{ 174, "rt_sigaction", 4, { { "int", "sig" }, { "const struct compat_sigaction *", "act" }, { "struct compat_sigaction *", "oact" }, { "compat_size_t", "sigsetsize" } } },
{ 175, "rt_sigprocmask", 4, { { "int", "how" }, { "compat_sigset_t *", "nset" }, { "compat_sigset_t *", "oset" }, { "compat_size_t", "sigsetsize" } } },
{ 176, "rt_sigpending", 2, { { "compat_sigset_t *", "uset" }, { "compat_size_t", "sigsetsize" } } },
{ 177, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 178, "rt_sigqueueinfo", 3, { { "compat_pid_t", "pid" }, { "int", "sig" }, { "struct compat_siginfo *", "uinfo" } } },
{ 179, "rt_sigsuspend", 2, { { "compat_sigset_t *", "unewset" }, { "compat_size_t", "sigsetsize" } } },
{ 180, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 181, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 182, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 183, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 184, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 185, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 186, "sigaltstack", 2, { { "const compat_stack_t *", "uss_ptr" }, { "compat_stack_t *", "uoss_ptr" } } },
{ 187, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "compat_off_t *", "offset" }, { "compat_size_t", "count" } } },
{ 190, "vfork", 0, {} },
{ 191, "ugetrlimit", 2, { { "unsigned int", "resource" }, { "struct compat_rlimit *", "rlim" } } },
{ 192, "mmap2", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "off_4k" } } },
#if G_BYTE_ORDER == G_BIG_ENDIAN
{ 193, "truncate64", 4, { { "const char *", "pathname" }, { "u32", "__pad" }, { "u32", "length_hi" }, { "u32", "length_lo" } } },
#else
{ 193, "truncate64", 4, { { "const char *", "pathname" }, { "u32", "__pad" }, { "u32", "length_lo" }, { "u32", "length_hi" } } },
#endif
#if G_BYTE_ORDER == G_BIG_ENDIAN
{ 194, "ftruncate64", 4, { { "unsigned int", "fd" }, { "u32", "__pad" }, { "u32", "length_hi" }, { "u32", "length_lo" } } },
#else
{ 194, "ftruncate64", 4, { { "unsigned int", "fd" }, { "u32", "__pad" }, { "u32", "length_lo" }, { "u32", "length_hi" } } },
#endif
{ 195, "stat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 196, "lstat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 197, "fstat64", 2, { { "unsigned long", "fd" }, { "struct stat64 *", "statbuf" } } },
{ 198, "lchown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 199, "getuid32", 0, {} },
{ 200, "getgid32", 0, {} },
{ 201, "geteuid32", 0, {} },
{ 202, "getegid32", 0, {} },
{ 203, "setreuid32", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 204, "setregid32", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 205, "getgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 206, "setgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 207, "fchown32", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 208, "setresuid32", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 209, "getresuid32", 3, { { "uid_t *", "ruid" }, { "uid_t *", "euid" }, { "uid_t *", "suid" } } },
{ 210, "setresgid32", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 211, "getresgid32", 3, { { "gid_t *", "rgid" }, { "gid_t *", "egid" }, { "gid_t *", "sgid" } } },
{ 212, "chown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 213, "setuid32", 1, { { "uid_t", "uid" } } },
{ 214, "setgid32", 1, { { "gid_t", "gid" } } },
{ 215, "setfsuid32", 1, { { "uid_t", "uid" } } },
{ 216, "setfsgid32", 1, { { "gid_t", "gid" } } },
{ 217, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 218, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 219, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 220, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 221, "fcntl64", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 224, "gettid", 0, {} },
{ 225, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 226, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 227, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 228, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 229, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 230, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 231, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 232, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 233, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 234, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 235, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 236, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 237, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 238, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 239, "sendfile64", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "compat_loff_t *", "offset" }, { "compat_size_t", "count" } } },
{ 240, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 241, "sched_setaffinity", 3, { { "compat_pid_t", "pid" }, { "unsigned int", "len" }, { "compat_ulong_t *", "user_mask_ptr" } } },
{ 242, "sched_getaffinity", 3, { { "compat_pid_t", "pid" }, { "unsigned int", "len" }, { "compat_ulong_t *", "user_mask_ptr" } } },
{ 243, "io_setup", 2, { { "unsigned", "nr_events" }, { "u32 *", "ctx32p" } } },
{ 244, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 245, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 246, "io_submit", 3, { { "compat_aio_context_t", "ctx_id" }, { "int", "nr" }, { "compat_uptr_t *", "iocbpp" } } },
{ 247, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 248, "exit_group", 1, { { "int", "error_code" } } },
{ 249, "lookup_dcookie", 0, {} },
{ 250, "epoll_create", 1, { { "int", "size" } } },
{ 251, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 252, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 253, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 256, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 257, "timer_create", 3, { { "clockid_t", "which_clock" }, { "struct compat_sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 258, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 259, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 260, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 261, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 262, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 263, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 264, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 265, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 266, "statfs64", 3, { { "const char *", "pathname" }, { "compat_size_t", "sz" }, { "struct compat_statfs64 *", "buf" } } },
{ 267, "fstatfs64", 3, { { "unsigned int", "fd" }, { "compat_size_t", "sz" }, { "struct compat_statfs64 *", "buf" } } },
{ 268, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 269, "utimes", 2, { { "const char *", "filename" }, { "struct old_timeval32 *", "t" } } },
#if G_BYTE_ORDER == G_BIG_ENDIAN
{ 270, "arm_fadvise64_64", 6, { { "int", "fd" }, { "int", "advice" }, { "u32", "offset_hi" }, { "u32", "offset_lo" }, { "u32", "len_hi" }, { "u32", "len_lo" } } },
#else
{ 270, "arm_fadvise64_64", 6, { { "int", "fd" }, { "int", "advice" }, { "u32", "offset_lo" }, { "u32", "offset_hi" }, { "u32", "len_lo" }, { "u32", "len_hi" } } },
#endif
{ 271, "pciconfig_iobase", 3, { { "long", "which" }, { "unsigned long", "bus" }, { "unsigned long", "devfn" } } },
{ 272, "pciconfig_read", 5, { { "unsigned long", "bus" }, { "unsigned long", "dfn" }, { "unsigned long", "off" }, { "unsigned long", "len" }, { "void *", "buf" } } },
{ 273, "pciconfig_write", 5, { { "unsigned long", "bus" }, { "unsigned long", "dfn" }, { "unsigned long", "off" }, { "unsigned long", "len" }, { "void *", "buf" } } },
{ 274, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "compat_mode_t", "mode" }, { "struct compat_mq_attr *", "u_attr" } } },
{ 275, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 276, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 277, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 278, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct compat_sigevent *", "u_notification" } } },
{ 279, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct compat_mq_attr *", "u_mqstat" }, { "struct compat_mq_attr *", "u_omqstat" } } },
{ 280, "waitid", 5, { { "int", "which" }, { "compat_pid_t", "pid" }, { "struct compat_siginfo *", "infop" }, { "int", "options" }, { "struct compat_rusage *", "uru" } } },
{ 281, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 282, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 283, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 284, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 285, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 286, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 287, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 288, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 289, "send", 4, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 290, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 291, "recv", 4, { { "int", "fd" }, { "void *", "buf" }, { "compat_size_t", "len" }, { "unsigned int", "flags" } } },
{ 292, "recvfrom", 6, { { "int", "fd" }, { "void *", "buf" }, { "compat_size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addrlen" } } },
{ 293, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 294, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 295, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 296, "sendmsg", 3, { { "int", "fd" }, { "struct compat_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 297, "recvmsg", 3, { { "int", "fd" }, { "struct compat_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 298, "semop", 3, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned", "nsops" } } },
{ 299, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 300, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "int", "arg" } } },
{ 301, "msgsnd", 4, { { "int", "msqid" }, { "compat_uptr_t", "msgp" }, { "compat_ssize_t", "msgsz" }, { "int", "msgflg" } } },
{ 302, "msgrcv", 5, { { "int", "msqid" }, { "compat_uptr_t", "msgp" }, { "compat_ssize_t", "msgsz" }, { "compat_long_t", "msgtyp" }, { "int", "msgflg" } } },
{ 303, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 304, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "void *", "uptr" } } },
{ 305, "shmat", 3, { { "int", "shmid" }, { "compat_uptr_t", "shmaddr" }, { "int", "shmflg" } } },
{ 306, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 307, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 308, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "void *", "uptr" } } },
{ 309, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 310, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 311, "keyctl", 5, { { "u32", "option" }, { "u32", "arg2" }, { "u32", "arg3" }, { "u32", "arg4" }, { "u32", "arg5" } } },
{ 312, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 313, "vserver", 0, {} },
{ 314, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 315, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 316, "inotify_init", 0, {} },
{ 317, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 318, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 319, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 320, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 321, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 322, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 323, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 324, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 325, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 326, "futimesat", 3, { { "unsigned int", "dfd" }, { "const char *", "filename" }, { "struct old_timeval32 *", "t" } } },
{ 327, "fstatat64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat64 *", "statbuf" }, { "int", "flag" } } },
{ 328, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 329, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 330, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 331, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 332, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 333, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 334, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 335, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 336, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 337, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 338, "set_robust_list", 2, { { "struct compat_robust_list_head *", "head" }, { "compat_size_t", "len" } } },
{ 339, "get_robust_list", 3, { { "int", "pid" }, { "compat_uptr_t *", "head_ptr" }, { "compat_size_t *", "len_ptr" } } },
{ 340, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
#if G_BYTE_ORDER == G_BIG_ENDIAN
{ 341, "arm_sync_file_range", 6, { { "int", "fd" }, { "unsigned int", "flags" }, { "u32", "offset_hi" }, { "u32", "offset_lo" }, { "u32", "nbytes_hi" }, { "u32", "nbytes_lo" } } },
#else
{ 341, "arm_sync_file_range", 6, { { "int", "fd" }, { "unsigned int", "flags" }, { "u32", "offset_lo" }, { "u32", "offset_hi" }, { "u32", "nbytes_lo" }, { "u32", "nbytes_hi" } } },
#endif
{ 342, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 343, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 344, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 345, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 346, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 347, "kexec_load", 4, { { "compat_ulong_t", "entry" }, { "compat_ulong_t", "nr_segments" }, { "struct compat_kexec_segment *", "segments" }, { "compat_ulong_t", "flags" } } },
{ 348, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 349, "signalfd", 3, { { "int", "ufd" }, { "const compat_sigset_t *", "user_mask" }, { "compat_size_t", "sigsetsize" } } },
{ 350, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 351, "eventfd", 1, { { "unsigned int", "count" } } },
{ 352, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 353, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 354, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 355, "signalfd4", 4, { { "int", "ufd" }, { "const compat_sigset_t *", "user_mask" }, { "compat_size_t", "sigsetsize" }, { "int", "flags" } } },
{ 356, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 357, "epoll_create1", 1, { { "int", "flags" } } },
{ 358, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 359, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 360, "inotify_init1", 1, { { "int", "flags" } } },
{ 361, "preadv", 5, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" } } },
{ 362, "pwritev", 5, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" } } },
{ 363, "rt_tgsigqueueinfo", 4, { { "compat_pid_t", "tgid" }, { "compat_pid_t", "pid" }, { "int", "sig" }, { "struct compat_siginfo *", "uinfo" } } },
{ 364, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 365, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 366, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 367, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 368, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 369, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 370, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 371, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 372, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 373, "syncfs", 1, { { "int", "fd" } } },
{ 374, "sendmmsg", 4, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 375, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 376, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 377, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 378, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 379, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 380, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 381, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 382, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 383, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 384, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 385, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 386, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 387, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const compat_uptr_t *", "argv" }, { "const compat_uptr_t *", "envp" }, { "int", "flags" } } },
{ 388, "userfaultfd", 1, { { "int", "flags" } } },
{ 389, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 390, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 391, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 392, "preadv2", 6, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" }, { "rwf_t", "flags" } } },
{ 393, "pwritev2", 6, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" }, { "rwf_t", "flags" } } },
{ 394, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 395, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 396, "pkey_free", 1, { { "int", "pkey" } } },
{ 397, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 398, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 399, "io_pgetevents", 6, { { "compat_aio_context_t", "ctx_id" }, { "compat_long_t", "min_nr" }, { "compat_long_t", "nr" }, { "struct io_event *", "events" }, { "struct old_timespec32 *", "timeout" }, { "const struct __compat_aio_sigset *", "usig" } } },
{ 400, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 401, "kexec_file_load", 5, { { "int", "kernel_fd" }, { "int", "initrd_fd" }, { "unsigned long", "cmdline_len" }, { "const char *", "cmdline_ptr" }, { "unsigned long", "flags" } } },
{ 403, "clock_gettime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 404, "clock_settime64", 2, { { "clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 405, "clock_adjtime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timex *", "tx" } } },
{ 406, "clock_getres_time64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 407, "clock_nanosleep_time64", 4, { { "clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 408, "timer_gettime64", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 409, "timer_settime64", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 410, "timerfd_gettime64", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 411, "timerfd_settime64", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 412, "utimensat_time64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 413, "pselect6_time64", 6, { { "int", "n" }, { "compat_ulong_t *", "inp" }, { "compat_ulong_t *", "outp" }, { "compat_ulong_t *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 414, "ppoll_time64", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 416, "io_pgetevents_time64", 6, { { "compat_aio_context_t", "ctx_id" }, { "compat_long_t", "min_nr" }, { "compat_long_t", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __compat_aio_sigset *", "usig" } } },
{ 417, "recvmmsg_time64", 5, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 418, "mq_timedsend_time64", 5, { { "mqd_t", "mqdes" }, { "const char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 419, "mq_timedreceive_time64", 5, { { "mqd_t", "mqdes" }, { "char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 420, "semtimedop_time64", 4, { { "int", "semid" }, { "struct sembuf *", "sops" }, { "unsigned", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 421, "rt_sigtimedwait_time64", 4, { { "compat_sigset_t *", "uthese" }, { "struct compat_siginfo *", "uinfo" }, { "struct __kernel_timespec *", "uts" }, { "compat_size_t", "sigsetsize" } } },
{ 422, "futex_time64", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 423, "sched_rr_get_interval_time64", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_compat32_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_compat32_syscall_signatures;
}
+756
View File
@@ -0,0 +1,756 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
IO_SETUP = 0,
IO_DESTROY = 1,
IO_SUBMIT = 2,
IO_CANCEL = 3,
IO_GETEVENTS = 4,
SETXATTR = 5,
LSETXATTR = 6,
FSETXATTR = 7,
GETXATTR = 8,
LGETXATTR = 9,
FGETXATTR = 10,
LISTXATTR = 11,
LLISTXATTR = 12,
FLISTXATTR = 13,
REMOVEXATTR = 14,
LREMOVEXATTR = 15,
FREMOVEXATTR = 16,
GETCWD = 17,
LOOKUP_DCOOKIE = 18,
EVENTFD2 = 19,
EPOLL_CREATE1 = 20,
EPOLL_CTL = 21,
EPOLL_PWAIT = 22,
DUP = 23,
DUP3 = 24,
FCNTL = 25,
INOTIFY_INIT1 = 26,
INOTIFY_ADD_WATCH = 27,
INOTIFY_RM_WATCH = 28,
IOCTL = 29,
IOPRIO_SET = 30,
IOPRIO_GET = 31,
FLOCK = 32,
MKNODAT = 33,
MKDIRAT = 34,
UNLINKAT = 35,
SYMLINKAT = 36,
LINKAT = 37,
UMOUNT2 = 39,
MOUNT = 40,
PIVOT_ROOT = 41,
NFSSERVCTL = 42,
STATFS = 43,
FSTATFS = 44,
TRUNCATE = 45,
FTRUNCATE = 46,
FALLOCATE = 47,
FACCESSAT = 48,
CHDIR = 49,
FCHDIR = 50,
CHROOT = 51,
FCHMOD = 52,
FCHMODAT = 53,
FCHOWNAT = 54,
FCHOWN = 55,
OPENAT = 56,
CLOSE = 57,
VHANGUP = 58,
PIPE2 = 59,
QUOTACTL = 60,
GETDENTS64 = 61,
LSEEK = 62,
READ = 63,
WRITE = 64,
READV = 65,
WRITEV = 66,
PREAD64 = 67,
PWRITE64 = 68,
PREADV = 69,
PWRITEV = 70,
SENDFILE = 71,
PSELECT6 = 72,
PPOLL = 73,
SIGNALFD4 = 74,
VMSPLICE = 75,
SPLICE = 76,
TEE = 77,
READLINKAT = 78,
NEWFSTATAT = 79,
FSTAT = 80,
SYNC = 81,
FSYNC = 82,
FDATASYNC = 83,
SYNC_FILE_RANGE = 84,
TIMERFD_CREATE = 85,
TIMERFD_SETTIME = 86,
TIMERFD_GETTIME = 87,
UTIMENSAT = 88,
ACCT = 89,
CAPGET = 90,
CAPSET = 91,
PERSONALITY = 92,
EXIT = 93,
EXIT_GROUP = 94,
WAITID = 95,
SET_TID_ADDRESS = 96,
UNSHARE = 97,
FUTEX = 98,
SET_ROBUST_LIST = 99,
GET_ROBUST_LIST = 100,
NANOSLEEP = 101,
GETITIMER = 102,
SETITIMER = 103,
KEXEC_LOAD = 104,
INIT_MODULE = 105,
DELETE_MODULE = 106,
TIMER_CREATE = 107,
TIMER_GETTIME = 108,
TIMER_GETOVERRUN = 109,
TIMER_SETTIME = 110,
TIMER_DELETE = 111,
CLOCK_SETTIME = 112,
CLOCK_GETTIME = 113,
CLOCK_GETRES = 114,
CLOCK_NANOSLEEP = 115,
SYSLOG = 116,
PTRACE = 117,
SCHED_SETPARAM = 118,
SCHED_SETSCHEDULER = 119,
SCHED_GETSCHEDULER = 120,
SCHED_GETPARAM = 121,
SCHED_SETAFFINITY = 122,
SCHED_GETAFFINITY = 123,
SCHED_YIELD = 124,
SCHED_GET_PRIORITY_MAX = 125,
SCHED_GET_PRIORITY_MIN = 126,
SCHED_RR_GET_INTERVAL = 127,
RESTART_SYSCALL = 128,
KILL = 129,
TKILL = 130,
TGKILL = 131,
SIGALTSTACK = 132,
RT_SIGSUSPEND = 133,
RT_SIGACTION = 134,
RT_SIGPROCMASK = 135,
RT_SIGPENDING = 136,
RT_SIGTIMEDWAIT = 137,
RT_SIGQUEUEINFO = 138,
RT_SIGRETURN = 139,
SETPRIORITY = 140,
GETPRIORITY = 141,
REBOOT = 142,
SETREGID = 143,
SETGID = 144,
SETREUID = 145,
SETUID = 146,
SETRESUID = 147,
GETRESUID = 148,
SETRESGID = 149,
GETRESGID = 150,
SETFSUID = 151,
SETFSGID = 152,
TIMES = 153,
SETPGID = 154,
GETPGID = 155,
GETSID = 156,
SETSID = 157,
GETGROUPS = 158,
SETGROUPS = 159,
UNAME = 160,
SETHOSTNAME = 161,
SETDOMAINNAME = 162,
GETRLIMIT = 163,
SETRLIMIT = 164,
GETRUSAGE = 165,
UMASK = 166,
PRCTL = 167,
GETCPU = 168,
GETTIMEOFDAY = 169,
SETTIMEOFDAY = 170,
ADJTIMEX = 171,
GETPID = 172,
GETPPID = 173,
GETUID = 174,
GETEUID = 175,
GETGID = 176,
GETEGID = 177,
GETTID = 178,
SYSINFO = 179,
MQ_OPEN = 180,
MQ_UNLINK = 181,
MQ_TIMEDSEND = 182,
MQ_TIMEDRECEIVE = 183,
MQ_NOTIFY = 184,
MQ_GETSETATTR = 185,
MSGGET = 186,
MSGCTL = 187,
MSGRCV = 188,
MSGSND = 189,
SEMGET = 190,
SEMCTL = 191,
SEMTIMEDOP = 192,
SEMOP = 193,
SHMGET = 194,
SHMCTL = 195,
SHMAT = 196,
SHMDT = 197,
SOCKET = 198,
SOCKETPAIR = 199,
BIND = 200,
LISTEN = 201,
ACCEPT = 202,
CONNECT = 203,
GETSOCKNAME = 204,
GETPEERNAME = 205,
SENDTO = 206,
RECVFROM = 207,
SETSOCKOPT = 208,
GETSOCKOPT = 209,
SHUTDOWN = 210,
SENDMSG = 211,
RECVMSG = 212,
READAHEAD = 213,
BRK = 214,
MUNMAP = 215,
MREMAP = 216,
ADD_KEY = 217,
REQUEST_KEY = 218,
KEYCTL = 219,
CLONE = 220,
EXECVE = 221,
MMAP = 222,
FADVISE64 = 223,
SWAPON = 224,
SWAPOFF = 225,
MPROTECT = 226,
MSYNC = 227,
MLOCK = 228,
MUNLOCK = 229,
MLOCKALL = 230,
MUNLOCKALL = 231,
MINCORE = 232,
MADVISE = 233,
REMAP_FILE_PAGES = 234,
MBIND = 235,
GET_MEMPOLICY = 236,
SET_MEMPOLICY = 237,
MIGRATE_PAGES = 238,
MOVE_PAGES = 239,
RT_TGSIGQUEUEINFO = 240,
PERF_EVENT_OPEN = 241,
ACCEPT4 = 242,
RECVMMSG = 243,
WAIT4 = 260,
PRLIMIT64 = 261,
FANOTIFY_INIT = 262,
FANOTIFY_MARK = 263,
NAME_TO_HANDLE_AT = 264,
OPEN_BY_HANDLE_AT = 265,
CLOCK_ADJTIME = 266,
SYNCFS = 267,
SETNS = 268,
SENDMMSG = 269,
PROCESS_VM_READV = 270,
PROCESS_VM_WRITEV = 271,
KCMP = 272,
FINIT_MODULE = 273,
SCHED_SETATTR = 274,
SCHED_GETATTR = 275,
RENAMEAT2 = 276,
SECCOMP = 277,
GETRANDOM = 278,
MEMFD_CREATE = 279,
BPF = 280,
EXECVEAT = 281,
USERFAULTFD = 282,
MEMBARRIER = 283,
MLOCK2 = 284,
COPY_FILE_RANGE = 285,
PREADV2 = 286,
PWRITEV2 = 287,
PKEY_MPROTECT = 288,
PKEY_ALLOC = 289,
PKEY_FREE = 290,
STATX = 291,
IO_PGETEVENTS = 292,
RSEQ = 293,
KEXEC_FILE_LOAD = 294,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
public enum LinuxCompat32Syscall {
RESTART_SYSCALL = 0,
EXIT = 1,
FORK = 2,
READ = 3,
WRITE = 4,
OPEN = 5,
CLOSE = 6,
CREAT = 8,
LINK = 9,
UNLINK = 10,
EXECVE = 11,
CHDIR = 12,
MKNOD = 14,
CHMOD = 15,
LCHOWN = 16,
LSEEK = 19,
GETPID = 20,
MOUNT = 21,
SETUID = 23,
GETUID = 24,
PTRACE = 26,
PAUSE = 29,
ACCESS = 33,
NICE = 34,
SYNC = 36,
KILL = 37,
RENAME = 38,
MKDIR = 39,
RMDIR = 40,
DUP = 41,
PIPE = 42,
TIMES = 43,
BRK = 45,
SETGID = 46,
GETGID = 47,
GETEUID = 49,
GETEGID = 50,
ACCT = 51,
UMOUNT2 = 52,
IOCTL = 54,
FCNTL = 55,
SETPGID = 57,
UMASK = 60,
CHROOT = 61,
USTAT = 62,
DUP2 = 63,
GETPPID = 64,
GETPGRP = 65,
SETSID = 66,
SIGACTION = 67,
SETREUID = 70,
SETREGID = 71,
SIGSUSPEND = 72,
SIGPENDING = 73,
SETHOSTNAME = 74,
SETRLIMIT = 75,
GETRUSAGE = 77,
GETTIMEOFDAY = 78,
SETTIMEOFDAY = 79,
GETGROUPS = 80,
SETGROUPS = 81,
SYMLINK = 83,
READLINK = 85,
USELIB = 86,
SWAPON = 87,
REBOOT = 88,
MUNMAP = 91,
TRUNCATE = 92,
FTRUNCATE = 93,
FCHMOD = 94,
FCHOWN = 95,
GETPRIORITY = 96,
SETPRIORITY = 97,
STATFS = 99,
FSTATFS = 100,
SYSLOG = 103,
SETITIMER = 104,
GETITIMER = 105,
STAT = 106,
LSTAT = 107,
FSTAT = 108,
VHANGUP = 111,
WAIT4 = 114,
SWAPOFF = 115,
SYSINFO = 116,
FSYNC = 118,
SIGRETURN = 119,
CLONE = 120,
SETDOMAINNAME = 121,
UNAME = 122,
ADJTIMEX = 124,
MPROTECT = 125,
SIGPROCMASK = 126,
INIT_MODULE = 128,
DELETE_MODULE = 129,
QUOTACTL = 131,
GETPGID = 132,
FCHDIR = 133,
BDFLUSH = 134,
SYSFS = 135,
PERSONALITY = 136,
SETFSUID = 138,
SETFSGID = 139,
_LLSEEK = 140,
GETDENTS = 141,
_NEWSELECT = 142,
FLOCK = 143,
MSYNC = 144,
READV = 145,
WRITEV = 146,
GETSID = 147,
FDATASYNC = 148,
_SYSCTL = 149,
MLOCK = 150,
MUNLOCK = 151,
MLOCKALL = 152,
MUNLOCKALL = 153,
SCHED_SETPARAM = 154,
SCHED_GETPARAM = 155,
SCHED_SETSCHEDULER = 156,
SCHED_GETSCHEDULER = 157,
SCHED_YIELD = 158,
SCHED_GET_PRIORITY_MAX = 159,
SCHED_GET_PRIORITY_MIN = 160,
SCHED_RR_GET_INTERVAL = 161,
NANOSLEEP = 162,
MREMAP = 163,
SETRESUID = 164,
GETRESUID = 165,
POLL = 168,
NFSSERVCTL = 169,
SETRESGID = 170,
GETRESGID = 171,
PRCTL = 172,
RT_SIGRETURN = 173,
RT_SIGACTION = 174,
RT_SIGPROCMASK = 175,
RT_SIGPENDING = 176,
RT_SIGTIMEDWAIT = 177,
RT_SIGQUEUEINFO = 178,
RT_SIGSUSPEND = 179,
PREAD64 = 180,
PWRITE64 = 181,
CHOWN = 182,
GETCWD = 183,
CAPGET = 184,
CAPSET = 185,
SIGALTSTACK = 186,
SENDFILE = 187,
VFORK = 190,
UGETRLIMIT = 191,
MMAP2 = 192,
TRUNCATE64 = 193,
FTRUNCATE64 = 194,
STAT64 = 195,
LSTAT64 = 196,
FSTAT64 = 197,
LCHOWN32 = 198,
GETUID32 = 199,
GETGID32 = 200,
GETEUID32 = 201,
GETEGID32 = 202,
SETREUID32 = 203,
SETREGID32 = 204,
GETGROUPS32 = 205,
SETGROUPS32 = 206,
FCHOWN32 = 207,
SETRESUID32 = 208,
GETRESUID32 = 209,
SETRESGID32 = 210,
GETRESGID32 = 211,
CHOWN32 = 212,
SETUID32 = 213,
SETGID32 = 214,
SETFSUID32 = 215,
SETFSGID32 = 216,
GETDENTS64 = 217,
PIVOT_ROOT = 218,
MINCORE = 219,
MADVISE = 220,
FCNTL64 = 221,
GETTID = 224,
READAHEAD = 225,
SETXATTR = 226,
LSETXATTR = 227,
FSETXATTR = 228,
GETXATTR = 229,
LGETXATTR = 230,
FGETXATTR = 231,
LISTXATTR = 232,
LLISTXATTR = 233,
FLISTXATTR = 234,
REMOVEXATTR = 235,
LREMOVEXATTR = 236,
FREMOVEXATTR = 237,
TKILL = 238,
SENDFILE64 = 239,
FUTEX = 240,
SCHED_SETAFFINITY = 241,
SCHED_GETAFFINITY = 242,
IO_SETUP = 243,
IO_DESTROY = 244,
IO_GETEVENTS = 245,
IO_SUBMIT = 246,
IO_CANCEL = 247,
EXIT_GROUP = 248,
LOOKUP_DCOOKIE = 249,
EPOLL_CREATE = 250,
EPOLL_CTL = 251,
EPOLL_WAIT = 252,
REMAP_FILE_PAGES = 253,
SET_TID_ADDRESS = 256,
TIMER_CREATE = 257,
TIMER_SETTIME = 258,
TIMER_GETTIME = 259,
TIMER_GETOVERRUN = 260,
TIMER_DELETE = 261,
CLOCK_SETTIME = 262,
CLOCK_GETTIME = 263,
CLOCK_GETRES = 264,
CLOCK_NANOSLEEP = 265,
STATFS64 = 266,
FSTATFS64 = 267,
TGKILL = 268,
UTIMES = 269,
ARM_FADVISE64_64 = 270,
PCICONFIG_IOBASE = 271,
PCICONFIG_READ = 272,
PCICONFIG_WRITE = 273,
MQ_OPEN = 274,
MQ_UNLINK = 275,
MQ_TIMEDSEND = 276,
MQ_TIMEDRECEIVE = 277,
MQ_NOTIFY = 278,
MQ_GETSETATTR = 279,
WAITID = 280,
SOCKET = 281,
BIND = 282,
CONNECT = 283,
LISTEN = 284,
ACCEPT = 285,
GETSOCKNAME = 286,
GETPEERNAME = 287,
SOCKETPAIR = 288,
SEND = 289,
SENDTO = 290,
RECV = 291,
RECVFROM = 292,
SHUTDOWN = 293,
SETSOCKOPT = 294,
GETSOCKOPT = 295,
SENDMSG = 296,
RECVMSG = 297,
SEMOP = 298,
SEMGET = 299,
SEMCTL = 300,
MSGSND = 301,
MSGRCV = 302,
MSGGET = 303,
MSGCTL = 304,
SHMAT = 305,
SHMDT = 306,
SHMGET = 307,
SHMCTL = 308,
ADD_KEY = 309,
REQUEST_KEY = 310,
KEYCTL = 311,
SEMTIMEDOP = 312,
VSERVER = 313,
IOPRIO_SET = 314,
IOPRIO_GET = 315,
INOTIFY_INIT = 316,
INOTIFY_ADD_WATCH = 317,
INOTIFY_RM_WATCH = 318,
MBIND = 319,
GET_MEMPOLICY = 320,
SET_MEMPOLICY = 321,
OPENAT = 322,
MKDIRAT = 323,
MKNODAT = 324,
FCHOWNAT = 325,
FUTIMESAT = 326,
FSTATAT64 = 327,
UNLINKAT = 328,
RENAMEAT = 329,
LINKAT = 330,
SYMLINKAT = 331,
READLINKAT = 332,
FCHMODAT = 333,
FACCESSAT = 334,
PSELECT6 = 335,
PPOLL = 336,
UNSHARE = 337,
SET_ROBUST_LIST = 338,
GET_ROBUST_LIST = 339,
SPLICE = 340,
ARM_SYNC_FILE_RANGE = 341,
TEE = 342,
VMSPLICE = 343,
MOVE_PAGES = 344,
GETCPU = 345,
EPOLL_PWAIT = 346,
KEXEC_LOAD = 347,
UTIMENSAT = 348,
SIGNALFD = 349,
TIMERFD_CREATE = 350,
EVENTFD = 351,
FALLOCATE = 352,
TIMERFD_SETTIME = 353,
TIMERFD_GETTIME = 354,
SIGNALFD4 = 355,
EVENTFD2 = 356,
EPOLL_CREATE1 = 357,
DUP3 = 358,
PIPE2 = 359,
INOTIFY_INIT1 = 360,
PREADV = 361,
PWRITEV = 362,
RT_TGSIGQUEUEINFO = 363,
PERF_EVENT_OPEN = 364,
RECVMMSG = 365,
ACCEPT4 = 366,
FANOTIFY_INIT = 367,
FANOTIFY_MARK = 368,
PRLIMIT64 = 369,
NAME_TO_HANDLE_AT = 370,
OPEN_BY_HANDLE_AT = 371,
CLOCK_ADJTIME = 372,
SYNCFS = 373,
SENDMMSG = 374,
SETNS = 375,
PROCESS_VM_READV = 376,
PROCESS_VM_WRITEV = 377,
KCMP = 378,
FINIT_MODULE = 379,
SCHED_SETATTR = 380,
SCHED_GETATTR = 381,
RENAMEAT2 = 382,
SECCOMP = 383,
GETRANDOM = 384,
MEMFD_CREATE = 385,
BPF = 386,
EXECVEAT = 387,
USERFAULTFD = 388,
MEMBARRIER = 389,
MLOCK2 = 390,
COPY_FILE_RANGE = 391,
PREADV2 = 392,
PWRITEV2 = 393,
PKEY_MPROTECT = 394,
PKEY_ALLOC = 395,
PKEY_FREE = 396,
STATX = 397,
RSEQ = 398,
IO_PGETEVENTS = 399,
MIGRATE_PAGES = 400,
KEXEC_FILE_LOAD = 401,
CLOCK_GETTIME64 = 403,
CLOCK_SETTIME64 = 404,
CLOCK_ADJTIME64 = 405,
CLOCK_GETRES_TIME64 = 406,
CLOCK_NANOSLEEP_TIME64 = 407,
TIMER_GETTIME64 = 408,
TIMER_SETTIME64 = 409,
TIMERFD_GETTIME64 = 410,
TIMERFD_SETTIME64 = 411,
UTIMENSAT_TIME64 = 412,
PSELECT6_TIME64 = 413,
PPOLL_TIME64 = 414,
IO_PGETEVENTS_TIME64 = 416,
RECVMMSG_TIME64 = 417,
MQ_TIMEDSEND_TIME64 = 418,
MQ_TIMEDRECEIVE_TIME64 = 419,
SEMTIMEDOP_TIME64 = 420,
RT_SIGTIMEDWAIT_TIME64 = 421,
FUTEX_TIME64 = 422,
SCHED_RR_GET_INTERVAL_TIME64 = 423,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
}
File diff suppressed because it is too large. Load diff
+462
View File
@@ -0,0 +1,462 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 4001, "exit", 1, { { "int", "error_code" } } },
{ 4002, "fork", 0, {} },
{ 4003, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4004, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 4005, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 4006, "close", 1, { { "unsigned int", "fd" } } },
{ 4007, "waitpid", 3, { { "pid_t", "pid" }, { "int *", "stat_addr" }, { "int", "options" } } },
{ 4008, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 4009, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 4010, "unlink", 1, { { "const char *", "pathname" } } },
{ 4011, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 4012, "chdir", 1, { { "const char *", "filename" } } },
{ 4013, "time", 1, { { "old_time32_t *", "tloc" } } },
{ 4014, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 4015, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 4016, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 4017, "break", 0, {} },
{ 4018, "unused18", 0, {} },
{ 4019, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 4020, "getpid", 0, {} },
{ 4021, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 4022, "umount", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 4023, "setuid", 1, { { "uid_t", "uid" } } },
{ 4024, "getuid", 0, {} },
{ 4025, "stime", 1, { { "old_time32_t *", "tptr" } } },
{ 4026, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 4027, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 4028, "unused28", 0, {} },
{ 4029, "pause", 0, {} },
{ 4030, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 4031, "stty", 0, {} },
{ 4032, "gtty", 0, {} },
{ 4033, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 4034, "nice", 1, { { "int", "increment" } } },
{ 4035, "ftime", 0, {} },
{ 4036, "sync", 0, {} },
{ 4037, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 4038, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 4039, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 4040, "rmdir", 1, { { "const char *", "pathname" } } },
{ 4041, "dup", 1, { { "unsigned int", "fildes" } } },
{ 4042, "pipe", 1, { { "int *", "fildes" } } },
{ 4043, "times", 1, { { "struct tms *", "tbuf" } } },
{ 4044, "prof", 0, {} },
{ 4045, "brk", 1, { { "unsigned long", "brk" } } },
{ 4046, "setgid", 1, { { "gid_t", "gid" } } },
{ 4047, "getgid", 0, {} },
{ 4048, "signal", 0, {} },
{ 4049, "geteuid", 0, {} },
{ 4050, "getegid", 0, {} },
{ 4051, "acct", 1, { { "const char *", "name" } } },
{ 4052, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 4053, "lock", 0, {} },
{ 4054, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 4055, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 4056, "mpx", 0, {} },
{ 4057, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 4058, "ulimit", 0, {} },
{ 4059, "unused59", 1, { { "struct oldold_utsname *", "arg0" } } },
{ 4060, "umask", 1, { { "int", "mask" } } },
{ 4061, "chroot", 1, { { "const char *", "filename" } } },
{ 4062, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 4063, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 4064, "getppid", 0, {} },
{ 4065, "getpgrp", 0, {} },
{ 4066, "setsid", 0, {} },
{ 4068, "sgetmask", 0, {} },
{ 4069, "ssetmask", 1, { { "int", "newmask" } } },
{ 4070, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 4071, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 4073, "sigpending", 1, { { "old_sigset_t *", "uset" } } },
{ 4074, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 4075, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 4076, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 4077, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 4078, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 4079, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 4080, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 4081, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 4082, "reserved82", 0, {} },
{ 4083, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 4084, "unused84", 0, {} },
{ 4085, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 4086, "uselib", 1, { { "const char *", "library" } } },
{ 4087, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 4088, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 4089, "readdir", 3, { { "unsigned", "int" }, { "struct old_linux_dirent *", "arg1" }, { "unsigned", "int" } } },
{ 4090, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "off_t", "offset" } } },
{ 4091, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 4092, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 4093, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 4094, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 4095, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 4096, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 4097, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 4098, "profil", 0, {} },
{ 4099, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 4100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 4101, "ioperm", 0, {} },
{ 4102, "socketcall", 2, { { "int", "call" }, { "unsigned long *", "args" } } },
{ 4103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 4104, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 4105, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 4106, "stat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 4107, "lstat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 4108, "fstat", 2, { { "unsigned int", "fd" }, { "struct stat *", "statbuf" } } },
{ 4109, "unused109", 1, { { "struct old_utsname *", "arg0" } } },
{ 4110, "iopl", 0, {} },
{ 4111, "vhangup", 0, {} },
{ 4112, "idle", 0, {} },
{ 4113, "vm86", 0, {} },
{ 4114, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 4115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 4116, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 4117, "ipc", 6, { { "unsigned int", "call" }, { "int", "first" }, { "unsigned long", "second" }, { "unsigned long", "third" }, { "void *", "ptr" }, { "long", "fifth" } } },
{ 4118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 4120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 4121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 4122, "uname", 1, { { "struct old_utsname *", "name" } } },
{ 4123, "modify_ldt", 0, {} },
{ 4124, "adjtimex", 1, { { "struct old_timex32 *", "txc_p" } } },
{ 4125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 4126, "sigprocmask", 3, { { "int", "how" }, { "old_sigset_t *", "nset" }, { "old_sigset_t *", "oset" } } },
{ 4127, "create_module", 0, {} },
{ 4128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 4129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 4130, "get_kernel_syms", 0, {} },
{ 4131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 4132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 4133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 4134, "bdflush", 0, {} },
{ 4135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 4136, "personality", 1, { { "unsigned int", "personality" } } },
{ 4137, "afs_syscall", 0, {} },
{ 4138, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 4139, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 4140, "_llseek", 5, { { "unsigned int", "fd" }, { "unsigned long", "offset_high" }, { "unsigned long", "offset_low" }, { "loff_t *", "result" }, { "unsigned int", "whence" } } },
{ 4141, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 4142, "_newselect", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 4143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 4144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 4145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 4146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 4147, "cacheflush", 3, { { "unsigned long", "addr" }, { "unsigned long", "bytes" }, { "unsigned int", "cache" } } },
{ 4148, "cachectl", 3, { { "char *", "addr" }, { "int", "nbytes" }, { "int", "op" } } },
{ 4149, "sysmips", 3, { { "long", "cmd" }, { "long", "arg1" }, { "long", "arg2" } } },
{ 4150, "unused150", 0, {} },
{ 4151, "getsid", 1, { { "pid_t", "pid" } } },
{ 4152, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 4153, "_sysctl", 0, {} },
{ 4154, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 4155, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 4156, "mlockall", 1, { { "int", "flags" } } },
{ 4157, "munlockall", 0, {} },
{ 4158, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 4159, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 4160, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 4161, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 4162, "sched_yield", 0, {} },
{ 4163, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 4164, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 4165, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 4166, "nanosleep", 2, { { "struct old_timespec32 *", "rqtp" }, { "struct old_timespec32 *", "rmtp" } } },
{ 4167, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 4168, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 4169, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 4170, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 4171, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 4172, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 4173, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 4174, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 4175, "recv", 4, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" } } },
{ 4176, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 4177, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 4178, "send", 4, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 4179, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 4180, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 4181, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 4182, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 4183, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 4184, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 4185, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 4186, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 4187, "query_module", 0, {} },
{ 4188, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 4189, "nfsservctl", 0, {} },
{ 4190, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 4191, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 4192, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 4194, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 4195, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 4196, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 4197, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 4198, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 4199, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 4200, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 4201, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 4202, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 4203, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 4204, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 4205, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 4206, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 4207, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 4208, "getpmsg", 0, {} },
{ 4209, "putpmsg", 0, {} },
{ 4210, "mmap2", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "pgoff" } } },
{ 4211, "truncate64", 2, { { "const char *", "path" }, { "loff_t", "length" } } },
{ 4212, "ftruncate64", 2, { { "unsigned int", "fd" }, { "loff_t", "length" } } },
{ 4213, "stat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 4214, "lstat64", 2, { { "const char *", "filename" }, { "struct stat64 *", "statbuf" } } },
{ 4215, "fstat64", 2, { { "unsigned long", "fd" }, { "struct stat64 *", "statbuf" } } },
{ 4216, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 4217, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 4218, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 4219, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 4220, "fcntl64", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 4221, "reserved221", 0, {} },
{ 4222, "gettid", 0, {} },
{ 4223, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 4224, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 4225, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 4226, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 4227, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 4228, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 4229, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 4230, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 4231, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 4232, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 4233, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 4234, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 4235, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 4236, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 4237, "sendfile64", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "loff_t *", "offset" }, { "size_t", "count" } } },
{ 4238, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 4239, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 4240, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 4241, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 4242, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 4243, "io_getevents", 5, { { "__u32", "ctx_id" }, { "__s32", "min_nr" }, { "__s32", "nr" }, { "struct io_event *", "events" }, { "struct old_timespec32 *", "timeout" } } },
{ 4244, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 4245, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 4246, "exit_group", 1, { { "int", "error_code" } } },
{ 4247, "lookup_dcookie", 0, {} },
{ 4248, "epoll_create", 1, { { "int", "size" } } },
{ 4249, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 4250, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 4251, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 4252, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 4253, "restart_syscall", 0, {} },
{ 4254, "fadvise64", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "len" }, { "int", "advice" } } },
{ 4255, "statfs64", 3, { { "const char *", "pathname" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 4256, "fstatfs64", 3, { { "unsigned int", "fd" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 4257, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 4258, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 4259, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 4260, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 4261, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 4262, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 4263, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 4264, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 4265, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 4266, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 4267, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 4268, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 4269, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 4270, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 4271, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 4272, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 4273, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 4274, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 4275, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 4276, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 4277, "vserver", 0, {} },
{ 4278, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 4280, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 4281, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 4282, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 4283, "set_thread_area", 1, { { "unsigned long", "addr" } } },
{ 4284, "inotify_init", 0, {} },
{ 4285, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 4286, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 4287, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 4288, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 4289, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 4290, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 4291, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 4292, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 4293, "fstatat64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat64 *", "statbuf" }, { "int", "flag" } } },
{ 4294, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 4295, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 4296, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 4297, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 4298, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 4299, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 4300, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 4301, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 4302, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 4303, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 4304, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 4305, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 4306, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 4307, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 4308, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 4309, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 4310, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 4311, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 4312, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 4313, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 4314, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 4315, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 4316, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 4317, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 4318, "timerfd", 0, {} },
{ 4319, "eventfd", 1, { { "unsigned int", "count" } } },
{ 4320, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 4321, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 4322, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 4323, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 4324, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 4325, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 4326, "epoll_create1", 1, { { "int", "flags" } } },
{ 4327, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 4328, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 4329, "inotify_init1", 1, { { "int", "flags" } } },
{ 4330, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 4331, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 4332, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 4333, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 4334, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 4335, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 4336, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 4337, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 4338, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 4339, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 4340, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 4341, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 4342, "syncfs", 1, { { "int", "fd" } } },
{ 4343, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 4344, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 4345, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 4346, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 4347, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 4348, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 4349, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 4350, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 4351, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 4352, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 4353, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 4354, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 4355, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 4356, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 4357, "userfaultfd", 1, { { "int", "flags" } } },
{ 4358, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 4359, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 4360, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 4361, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 4362, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 4363, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 4364, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 4365, "pkey_free", 1, { { "int", "pkey" } } },
{ 4366, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 4367, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 4368, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 4393, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 4394, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 4395, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 4396, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 4397, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 4398, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 4399, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 4400, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 4401, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 4402, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 4403, "clock_gettime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 4404, "clock_settime64", 2, { { "clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 4405, "clock_adjtime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timex *", "tx" } } },
{ 4406, "clock_getres_time64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 4407, "clock_nanosleep_time64", 4, { { "clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 4408, "timer_gettime64", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 4409, "timer_settime64", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 4410, "timerfd_gettime64", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 4411, "timerfd_settime64", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 4412, "utimensat_time64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 4413, "pselect6_time64", 6, { { "int", "arg0" }, { "fd_set *", "arg1" }, { "fd_set *", "arg2" }, { "fd_set *", "arg3" }, { "struct __kernel_timespec *", "arg4" }, { "void *", "arg5" } } },
{ 4414, "ppoll_time64", 5, { { "struct pollfd *", "arg0" }, { "unsigned", "int" }, { "struct __kernel_timespec *", "arg2" }, { "const sigset_t *", "arg3" }, { "size_t", "arg4" } } },
{ 4416, "io_pgetevents_time64", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "sig" } } },
{ 4417, "recvmmsg_time64", 5, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 4418, "mq_timedsend_time64", 5, { { "mqd_t", "mqdes" }, { "const char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 4419, "mq_timedreceive_time64", 5, { { "mqd_t", "mqdes" }, { "char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 4420, "semtimedop_time64", 4, { { "int", "semid" }, { "struct sembuf *", "sops" }, { "unsigned", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 4421, "rt_sigtimedwait_time64", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 4422, "futex_time64", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 4423, "sched_rr_get_interval_time64", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 4424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 4425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 4426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 4427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 4428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 4429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 4430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 4431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 4432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 4433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 4434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 4435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 4436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 4437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 4438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 4439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 4440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 4441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 4442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 4443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 4444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 4445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 4446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 4448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 4449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 4450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 4451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 4452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 4453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 4454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 4455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 4456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 4457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 4458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 4459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 4460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 4461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 4462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 4463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 4464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 4465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 4466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 4467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 4468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 4469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 4470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = 0;
return NULL;
}
+445
View File
@@ -0,0 +1,445 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
EXIT = 4001,
FORK = 4002,
READ = 4003,
WRITE = 4004,
OPEN = 4005,
CLOSE = 4006,
WAITPID = 4007,
CREAT = 4008,
LINK = 4009,
UNLINK = 4010,
EXECVE = 4011,
CHDIR = 4012,
TIME = 4013,
MKNOD = 4014,
CHMOD = 4015,
LCHOWN = 4016,
BREAK = 4017,
UNUSED18 = 4018,
LSEEK = 4019,
GETPID = 4020,
MOUNT = 4021,
UMOUNT = 4022,
SETUID = 4023,
GETUID = 4024,
STIME = 4025,
PTRACE = 4026,
ALARM = 4027,
UNUSED28 = 4028,
PAUSE = 4029,
UTIME = 4030,
STTY = 4031,
GTTY = 4032,
ACCESS = 4033,
NICE = 4034,
FTIME = 4035,
SYNC = 4036,
KILL = 4037,
RENAME = 4038,
MKDIR = 4039,
RMDIR = 4040,
DUP = 4041,
PIPE = 4042,
TIMES = 4043,
PROF = 4044,
BRK = 4045,
SETGID = 4046,
GETGID = 4047,
SIGNAL = 4048,
GETEUID = 4049,
GETEGID = 4050,
ACCT = 4051,
UMOUNT2 = 4052,
LOCK = 4053,
IOCTL = 4054,
FCNTL = 4055,
MPX = 4056,
SETPGID = 4057,
ULIMIT = 4058,
UNUSED59 = 4059,
UMASK = 4060,
CHROOT = 4061,
USTAT = 4062,
DUP2 = 4063,
GETPPID = 4064,
GETPGRP = 4065,
SETSID = 4066,
SGETMASK = 4068,
SSETMASK = 4069,
SETREUID = 4070,
SETREGID = 4071,
SIGPENDING = 4073,
SETHOSTNAME = 4074,
SETRLIMIT = 4075,
GETRLIMIT = 4076,
GETRUSAGE = 4077,
GETTIMEOFDAY = 4078,
SETTIMEOFDAY = 4079,
GETGROUPS = 4080,
SETGROUPS = 4081,
RESERVED82 = 4082,
SYMLINK = 4083,
UNUSED84 = 4084,
READLINK = 4085,
USELIB = 4086,
SWAPON = 4087,
REBOOT = 4088,
READDIR = 4089,
MMAP = 4090,
MUNMAP = 4091,
TRUNCATE = 4092,
FTRUNCATE = 4093,
FCHMOD = 4094,
FCHOWN = 4095,
GETPRIORITY = 4096,
SETPRIORITY = 4097,
PROFIL = 4098,
STATFS = 4099,
FSTATFS = 4100,
IOPERM = 4101,
SOCKETCALL = 4102,
SYSLOG = 4103,
SETITIMER = 4104,
GETITIMER = 4105,
STAT = 4106,
LSTAT = 4107,
FSTAT = 4108,
UNUSED109 = 4109,
IOPL = 4110,
VHANGUP = 4111,
IDLE = 4112,
VM86 = 4113,
WAIT4 = 4114,
SWAPOFF = 4115,
SYSINFO = 4116,
IPC = 4117,
FSYNC = 4118,
CLONE = 4120,
SETDOMAINNAME = 4121,
UNAME = 4122,
MODIFY_LDT = 4123,
ADJTIMEX = 4124,
MPROTECT = 4125,
SIGPROCMASK = 4126,
CREATE_MODULE = 4127,
INIT_MODULE = 4128,
DELETE_MODULE = 4129,
GET_KERNEL_SYMS = 4130,
QUOTACTL = 4131,
GETPGID = 4132,
FCHDIR = 4133,
BDFLUSH = 4134,
SYSFS = 4135,
PERSONALITY = 4136,
AFS_SYSCALL = 4137,
SETFSUID = 4138,
SETFSGID = 4139,
_LLSEEK = 4140,
GETDENTS = 4141,
_NEWSELECT = 4142,
FLOCK = 4143,
MSYNC = 4144,
READV = 4145,
WRITEV = 4146,
CACHEFLUSH = 4147,
CACHECTL = 4148,
SYSMIPS = 4149,
UNUSED150 = 4150,
GETSID = 4151,
FDATASYNC = 4152,
_SYSCTL = 4153,
MLOCK = 4154,
MUNLOCK = 4155,
MLOCKALL = 4156,
MUNLOCKALL = 4157,
SCHED_SETPARAM = 4158,
SCHED_GETPARAM = 4159,
SCHED_SETSCHEDULER = 4160,
SCHED_GETSCHEDULER = 4161,
SCHED_YIELD = 4162,
SCHED_GET_PRIORITY_MAX = 4163,
SCHED_GET_PRIORITY_MIN = 4164,
SCHED_RR_GET_INTERVAL = 4165,
NANOSLEEP = 4166,
MREMAP = 4167,
ACCEPT = 4168,
BIND = 4169,
CONNECT = 4170,
GETPEERNAME = 4171,
GETSOCKNAME = 4172,
GETSOCKOPT = 4173,
LISTEN = 4174,
RECV = 4175,
RECVFROM = 4176,
RECVMSG = 4177,
SEND = 4178,
SENDMSG = 4179,
SENDTO = 4180,
SETSOCKOPT = 4181,
SHUTDOWN = 4182,
SOCKET = 4183,
SOCKETPAIR = 4184,
SETRESUID = 4185,
GETRESUID = 4186,
QUERY_MODULE = 4187,
POLL = 4188,
NFSSERVCTL = 4189,
SETRESGID = 4190,
GETRESGID = 4191,
PRCTL = 4192,
RT_SIGACTION = 4194,
RT_SIGPROCMASK = 4195,
RT_SIGPENDING = 4196,
RT_SIGTIMEDWAIT = 4197,
RT_SIGQUEUEINFO = 4198,
RT_SIGSUSPEND = 4199,
PREAD64 = 4200,
PWRITE64 = 4201,
CHOWN = 4202,
GETCWD = 4203,
CAPGET = 4204,
CAPSET = 4205,
SIGALTSTACK = 4206,
SENDFILE = 4207,
GETPMSG = 4208,
PUTPMSG = 4209,
MMAP2 = 4210,
TRUNCATE64 = 4211,
FTRUNCATE64 = 4212,
STAT64 = 4213,
LSTAT64 = 4214,
FSTAT64 = 4215,
PIVOT_ROOT = 4216,
MINCORE = 4217,
MADVISE = 4218,
GETDENTS64 = 4219,
FCNTL64 = 4220,
RESERVED221 = 4221,
GETTID = 4222,
READAHEAD = 4223,
SETXATTR = 4224,
LSETXATTR = 4225,
FSETXATTR = 4226,
GETXATTR = 4227,
LGETXATTR = 4228,
FGETXATTR = 4229,
LISTXATTR = 4230,
LLISTXATTR = 4231,
FLISTXATTR = 4232,
REMOVEXATTR = 4233,
LREMOVEXATTR = 4234,
FREMOVEXATTR = 4235,
TKILL = 4236,
SENDFILE64 = 4237,
FUTEX = 4238,
SCHED_SETAFFINITY = 4239,
SCHED_GETAFFINITY = 4240,
IO_SETUP = 4241,
IO_DESTROY = 4242,
IO_GETEVENTS = 4243,
IO_SUBMIT = 4244,
IO_CANCEL = 4245,
EXIT_GROUP = 4246,
LOOKUP_DCOOKIE = 4247,
EPOLL_CREATE = 4248,
EPOLL_CTL = 4249,
EPOLL_WAIT = 4250,
REMAP_FILE_PAGES = 4251,
SET_TID_ADDRESS = 4252,
RESTART_SYSCALL = 4253,
FADVISE64 = 4254,
STATFS64 = 4255,
FSTATFS64 = 4256,
TIMER_CREATE = 4257,
TIMER_SETTIME = 4258,
TIMER_GETTIME = 4259,
TIMER_GETOVERRUN = 4260,
TIMER_DELETE = 4261,
CLOCK_SETTIME = 4262,
CLOCK_GETTIME = 4263,
CLOCK_GETRES = 4264,
CLOCK_NANOSLEEP = 4265,
TGKILL = 4266,
UTIMES = 4267,
MBIND = 4268,
GET_MEMPOLICY = 4269,
SET_MEMPOLICY = 4270,
MQ_OPEN = 4271,
MQ_UNLINK = 4272,
MQ_TIMEDSEND = 4273,
MQ_TIMEDRECEIVE = 4274,
MQ_NOTIFY = 4275,
MQ_GETSETATTR = 4276,
VSERVER = 4277,
WAITID = 4278,
ADD_KEY = 4280,
REQUEST_KEY = 4281,
KEYCTL = 4282,
SET_THREAD_AREA = 4283,
INOTIFY_INIT = 4284,
INOTIFY_ADD_WATCH = 4285,
INOTIFY_RM_WATCH = 4286,
MIGRATE_PAGES = 4287,
OPENAT = 4288,
MKDIRAT = 4289,
MKNODAT = 4290,
FCHOWNAT = 4291,
FUTIMESAT = 4292,
FSTATAT64 = 4293,
UNLINKAT = 4294,
RENAMEAT = 4295,
LINKAT = 4296,
SYMLINKAT = 4297,
READLINKAT = 4298,
FCHMODAT = 4299,
FACCESSAT = 4300,
PSELECT6 = 4301,
PPOLL = 4302,
UNSHARE = 4303,
SPLICE = 4304,
SYNC_FILE_RANGE = 4305,
TEE = 4306,
VMSPLICE = 4307,
MOVE_PAGES = 4308,
SET_ROBUST_LIST = 4309,
GET_ROBUST_LIST = 4310,
KEXEC_LOAD = 4311,
GETCPU = 4312,
EPOLL_PWAIT = 4313,
IOPRIO_SET = 4314,
IOPRIO_GET = 4315,
UTIMENSAT = 4316,
SIGNALFD = 4317,
TIMERFD = 4318,
EVENTFD = 4319,
FALLOCATE = 4320,
TIMERFD_CREATE = 4321,
TIMERFD_GETTIME = 4322,
TIMERFD_SETTIME = 4323,
SIGNALFD4 = 4324,
EVENTFD2 = 4325,
EPOLL_CREATE1 = 4326,
DUP3 = 4327,
PIPE2 = 4328,
INOTIFY_INIT1 = 4329,
PREADV = 4330,
PWRITEV = 4331,
RT_TGSIGQUEUEINFO = 4332,
PERF_EVENT_OPEN = 4333,
ACCEPT4 = 4334,
RECVMMSG = 4335,
FANOTIFY_INIT = 4336,
FANOTIFY_MARK = 4337,
PRLIMIT64 = 4338,
NAME_TO_HANDLE_AT = 4339,
OPEN_BY_HANDLE_AT = 4340,
CLOCK_ADJTIME = 4341,
SYNCFS = 4342,
SENDMMSG = 4343,
SETNS = 4344,
PROCESS_VM_READV = 4345,
PROCESS_VM_WRITEV = 4346,
KCMP = 4347,
FINIT_MODULE = 4348,
SCHED_SETATTR = 4349,
SCHED_GETATTR = 4350,
RENAMEAT2 = 4351,
SECCOMP = 4352,
GETRANDOM = 4353,
MEMFD_CREATE = 4354,
BPF = 4355,
EXECVEAT = 4356,
USERFAULTFD = 4357,
MEMBARRIER = 4358,
MLOCK2 = 4359,
COPY_FILE_RANGE = 4360,
PREADV2 = 4361,
PWRITEV2 = 4362,
PKEY_MPROTECT = 4363,
PKEY_ALLOC = 4364,
PKEY_FREE = 4365,
STATX = 4366,
RSEQ = 4367,
IO_PGETEVENTS = 4368,
SEMGET = 4393,
SEMCTL = 4394,
SHMGET = 4395,
SHMCTL = 4396,
SHMAT = 4397,
SHMDT = 4398,
MSGGET = 4399,
MSGSND = 4400,
MSGRCV = 4401,
MSGCTL = 4402,
CLOCK_GETTIME64 = 4403,
CLOCK_SETTIME64 = 4404,
CLOCK_ADJTIME64 = 4405,
CLOCK_GETRES_TIME64 = 4406,
CLOCK_NANOSLEEP_TIME64 = 4407,
TIMER_GETTIME64 = 4408,
TIMER_SETTIME64 = 4409,
TIMERFD_GETTIME64 = 4410,
TIMERFD_SETTIME64 = 4411,
UTIMENSAT_TIME64 = 4412,
PSELECT6_TIME64 = 4413,
PPOLL_TIME64 = 4414,
IO_PGETEVENTS_TIME64 = 4416,
RECVMMSG_TIME64 = 4417,
MQ_TIMEDSEND_TIME64 = 4418,
MQ_TIMEDRECEIVE_TIME64 = 4419,
SEMTIMEDOP_TIME64 = 4420,
RT_SIGTIMEDWAIT_TIME64 = 4421,
FUTEX_TIME64 = 4422,
SCHED_RR_GET_INTERVAL_TIME64 = 4423,
PIDFD_SEND_SIGNAL = 4424,
IO_URING_SETUP = 4425,
IO_URING_ENTER = 4426,
IO_URING_REGISTER = 4427,
OPEN_TREE = 4428,
MOVE_MOUNT = 4429,
FSOPEN = 4430,
FSCONFIG = 4431,
FSMOUNT = 4432,
FSPICK = 4433,
PIDFD_OPEN = 4434,
CLONE3 = 4435,
CLOSE_RANGE = 4436,
OPENAT2 = 4437,
PIDFD_GETFD = 4438,
FACCESSAT2 = 4439,
PROCESS_MADVISE = 4440,
EPOLL_PWAIT2 = 4441,
MOUNT_SETATTR = 4442,
QUOTACTL_FD = 4443,
LANDLOCK_CREATE_RULESET = 4444,
LANDLOCK_ADD_RULE = 4445,
LANDLOCK_RESTRICT_SELF = 4446,
PROCESS_MRELEASE = 4448,
FUTEX_WAITV = 4449,
SET_MEMPOLICY_HOME_NODE = 4450,
CACHESTAT = 4451,
FCHMODAT2 = 4452,
MAP_SHADOW_STACK = 4453,
FUTEX_WAKE = 4454,
FUTEX_WAIT = 4455,
FUTEX_REQUEUE = 4456,
STATMOUNT = 4457,
LISTMOUNT = 4458,
LSM_GET_SELF_ATTR = 4459,
LSM_SET_SELF_ATTR = 4460,
LSM_LIST_MODULES = 4461,
MSEAL = 4462,
SETXATTRAT = 4463,
GETXATTRAT = 4464,
LISTXATTRAT = 4465,
REMOVEXATTRAT = 4466,
OPEN_TREE_ATTR = 4467,
FILE_GETATTR = 4468,
FILE_SETATTR = 4469,
LISTNS = 4470,
}
}
+396
View File
@@ -0,0 +1,396 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 5000, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 5001, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5002, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 5003, "close", 1, { { "unsigned int", "fd" } } },
{ 5004, "stat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 5005, "fstat", 2, { { "unsigned int", "fd" }, { "struct stat *", "statbuf" } } },
{ 5006, "lstat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 5007, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 5008, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 5009, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "off_t", "offset" } } },
{ 5010, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 5011, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 5012, "brk", 1, { { "unsigned long", "brk" } } },
{ 5013, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 5014, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 5015, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 5016, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 5017, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 5018, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 5019, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 5020, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 5021, "pipe", 1, { { "int *", "fildes" } } },
{ 5022, "_newselect", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 5023, "sched_yield", 0, {} },
{ 5024, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 5025, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 5026, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 5027, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 5028, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 5029, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 5030, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 5031, "dup", 1, { { "unsigned int", "fildes" } } },
{ 5032, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 5033, "pause", 0, {} },
{ 5034, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 5035, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 5036, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 5037, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 5038, "getpid", 0, {} },
{ 5039, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 5040, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 5041, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 5042, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 5043, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 5044, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 5045, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 5046, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 5047, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 5048, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 5049, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 5050, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 5051, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 5052, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 5053, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 5054, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 5055, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 5056, "fork", 0, {} },
{ 5057, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 5058, "exit", 1, { { "int", "error_code" } } },
{ 5059, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 5060, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 5061, "uname", 1, { { "struct old_utsname *", "name" } } },
{ 5062, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 5063, "semop", 3, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned", "nsops" } } },
{ 5064, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 5065, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 5066, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 5067, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 5068, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 5069, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 5070, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 5071, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 5072, "fsync", 1, { { "unsigned int", "fd" } } },
{ 5073, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 5074, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 5075, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 5076, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 5077, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 5078, "chdir", 1, { { "const char *", "filename" } } },
{ 5079, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 5080, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 5081, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 5082, "rmdir", 1, { { "const char *", "pathname" } } },
{ 5083, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 5084, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 5085, "unlink", 1, { { "const char *", "pathname" } } },
{ 5086, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 5087, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 5088, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 5089, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 5090, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 5091, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 5092, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 5093, "umask", 1, { { "int", "mask" } } },
{ 5094, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 5095, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 5096, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 5097, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 5098, "times", 1, { { "struct tms *", "tbuf" } } },
{ 5099, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 5100, "getuid", 0, {} },
{ 5101, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 5102, "getgid", 0, {} },
{ 5103, "setuid", 1, { { "uid_t", "uid" } } },
{ 5104, "setgid", 1, { { "gid_t", "gid" } } },
{ 5105, "geteuid", 0, {} },
{ 5106, "getegid", 0, {} },
{ 5107, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 5108, "getppid", 0, {} },
{ 5109, "getpgrp", 0, {} },
{ 5110, "setsid", 0, {} },
{ 5111, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 5112, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 5113, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 5114, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 5115, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 5116, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 5117, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 5118, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 5119, "getpgid", 1, { { "pid_t", "pid" } } },
{ 5120, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 5121, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 5122, "getsid", 1, { { "pid_t", "pid" } } },
{ 5123, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 5124, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 5125, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 5126, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 5127, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 5128, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 5129, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 5130, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 5131, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 5132, "personality", 1, { { "unsigned int", "personality" } } },
{ 5133, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 5134, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 5135, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 5136, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 5137, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 5138, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 5139, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 5140, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 5141, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 5142, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 5143, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 5144, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 5145, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 5146, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 5147, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 5148, "mlockall", 1, { { "int", "flags" } } },
{ 5149, "munlockall", 0, {} },
{ 5150, "vhangup", 0, {} },
{ 5151, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 5152, "_sysctl", 0, {} },
{ 5153, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 5154, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 5155, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 5156, "chroot", 1, { { "const char *", "filename" } } },
{ 5157, "sync", 0, {} },
{ 5158, "acct", 1, { { "const char *", "name" } } },
{ 5159, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 5160, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 5161, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 5162, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 5163, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 5164, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 5165, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 5166, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 5167, "create_module", 0, {} },
{ 5168, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 5169, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 5170, "get_kernel_syms", 0, {} },
{ 5171, "query_module", 0, {} },
{ 5172, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 5173, "nfsservctl", 0, {} },
{ 5174, "getpmsg", 0, {} },
{ 5175, "putpmsg", 0, {} },
{ 5176, "afs_syscall", 0, {} },
{ 5177, "reserved177", 0, {} },
{ 5178, "gettid", 0, {} },
{ 5179, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 5180, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 5181, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 5182, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 5183, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 5184, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 5185, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 5186, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 5187, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 5188, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 5189, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 5190, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 5191, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 5192, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 5193, "reserved193", 0, {} },
{ 5194, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 5195, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 5196, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 5197, "cacheflush", 3, { { "unsigned long", "addr" }, { "unsigned long", "bytes" }, { "unsigned int", "cache" } } },
{ 5198, "cachectl", 3, { { "char *", "addr" }, { "int", "nbytes" }, { "int", "op" } } },
{ 5199, "sysmips", 3, { { "long", "cmd" }, { "long", "arg1" }, { "long", "arg2" } } },
{ 5200, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 5201, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 5202, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 5203, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 5204, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 5205, "exit_group", 1, { { "int", "error_code" } } },
{ 5206, "lookup_dcookie", 0, {} },
{ 5207, "epoll_create", 1, { { "int", "size" } } },
{ 5208, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 5209, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 5210, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 5212, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 5213, "restart_syscall", 0, {} },
{ 5214, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 5215, "fadvise64", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "len" }, { "int", "advice" } } },
{ 5216, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 5217, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 5218, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 5219, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 5220, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 5221, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 5222, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 5223, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 5224, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 5225, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 5226, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 5227, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 5228, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 5229, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 5230, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 5231, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 5232, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 5233, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 5234, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 5235, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 5236, "vserver", 0, {} },
{ 5237, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 5239, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 5240, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 5241, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 5242, "set_thread_area", 1, { { "unsigned long", "addr" } } },
{ 5243, "inotify_init", 0, {} },
{ 5244, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 5245, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 5246, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 5247, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 5248, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 5249, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 5250, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 5251, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 5252, "newfstatat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat *", "statbuf" }, { "int", "flag" } } },
{ 5253, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 5254, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 5255, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 5256, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 5257, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 5258, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 5259, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 5260, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 5261, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 5262, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 5263, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 5264, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 5265, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 5266, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 5267, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 5268, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 5269, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 5270, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 5271, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 5272, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 5273, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 5274, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 5275, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 5276, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 5277, "timerfd", 0, {} },
{ 5278, "eventfd", 1, { { "unsigned int", "count" } } },
{ 5279, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 5280, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 5281, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 5282, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 5283, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 5284, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 5285, "epoll_create1", 1, { { "int", "flags" } } },
{ 5286, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 5287, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 5288, "inotify_init1", 1, { { "int", "flags" } } },
{ 5289, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 5290, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 5291, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 5292, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 5293, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 5294, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 5295, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 5296, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 5297, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 5298, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 5299, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 5300, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 5301, "syncfs", 1, { { "int", "fd" } } },
{ 5302, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 5303, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 5304, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 5305, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 5306, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 5307, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 5308, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 5309, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 5310, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 5311, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 5312, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 5313, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 5314, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 5315, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 5316, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 5317, "userfaultfd", 1, { { "int", "flags" } } },
{ 5318, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 5319, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 5320, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 5321, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 5322, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 5323, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 5324, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 5325, "pkey_free", 1, { { "int", "pkey" } } },
{ 5326, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 5327, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 5328, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 5424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 5425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 5426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 5427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 5428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 5429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 5430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 5431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 5432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 5433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 5434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 5435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 5436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 5437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 5438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 5439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 5440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 5441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 5442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 5443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 5444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 5445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 5446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 5448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 5449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 5450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 5451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 5452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 5453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 5454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 5455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 5456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 5457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 5458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 5459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 5460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 5461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 5462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 5463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 5464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 5465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 5466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 5467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 5468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 5469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 5470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = 0;
return NULL;
}
+379
View File
@@ -0,0 +1,379 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
READ = 5000,
WRITE = 5001,
OPEN = 5002,
CLOSE = 5003,
STAT = 5004,
FSTAT = 5005,
LSTAT = 5006,
POLL = 5007,
LSEEK = 5008,
MMAP = 5009,
MPROTECT = 5010,
MUNMAP = 5011,
BRK = 5012,
RT_SIGACTION = 5013,
RT_SIGPROCMASK = 5014,
IOCTL = 5015,
PREAD64 = 5016,
PWRITE64 = 5017,
READV = 5018,
WRITEV = 5019,
ACCESS = 5020,
PIPE = 5021,
_NEWSELECT = 5022,
SCHED_YIELD = 5023,
MREMAP = 5024,
MSYNC = 5025,
MINCORE = 5026,
MADVISE = 5027,
SHMGET = 5028,
SHMAT = 5029,
SHMCTL = 5030,
DUP = 5031,
DUP2 = 5032,
PAUSE = 5033,
NANOSLEEP = 5034,
GETITIMER = 5035,
SETITIMER = 5036,
ALARM = 5037,
GETPID = 5038,
SENDFILE = 5039,
SOCKET = 5040,
CONNECT = 5041,
ACCEPT = 5042,
SENDTO = 5043,
RECVFROM = 5044,
SENDMSG = 5045,
RECVMSG = 5046,
SHUTDOWN = 5047,
BIND = 5048,
LISTEN = 5049,
GETSOCKNAME = 5050,
GETPEERNAME = 5051,
SOCKETPAIR = 5052,
SETSOCKOPT = 5053,
GETSOCKOPT = 5054,
CLONE = 5055,
FORK = 5056,
EXECVE = 5057,
EXIT = 5058,
WAIT4 = 5059,
KILL = 5060,
UNAME = 5061,
SEMGET = 5062,
SEMOP = 5063,
SEMCTL = 5064,
SHMDT = 5065,
MSGGET = 5066,
MSGSND = 5067,
MSGRCV = 5068,
MSGCTL = 5069,
FCNTL = 5070,
FLOCK = 5071,
FSYNC = 5072,
FDATASYNC = 5073,
TRUNCATE = 5074,
FTRUNCATE = 5075,
GETDENTS = 5076,
GETCWD = 5077,
CHDIR = 5078,
FCHDIR = 5079,
RENAME = 5080,
MKDIR = 5081,
RMDIR = 5082,
CREAT = 5083,
LINK = 5084,
UNLINK = 5085,
SYMLINK = 5086,
READLINK = 5087,
CHMOD = 5088,
FCHMOD = 5089,
CHOWN = 5090,
FCHOWN = 5091,
LCHOWN = 5092,
UMASK = 5093,
GETTIMEOFDAY = 5094,
GETRLIMIT = 5095,
GETRUSAGE = 5096,
SYSINFO = 5097,
TIMES = 5098,
PTRACE = 5099,
GETUID = 5100,
SYSLOG = 5101,
GETGID = 5102,
SETUID = 5103,
SETGID = 5104,
GETEUID = 5105,
GETEGID = 5106,
SETPGID = 5107,
GETPPID = 5108,
GETPGRP = 5109,
SETSID = 5110,
SETREUID = 5111,
SETREGID = 5112,
GETGROUPS = 5113,
SETGROUPS = 5114,
SETRESUID = 5115,
GETRESUID = 5116,
SETRESGID = 5117,
GETRESGID = 5118,
GETPGID = 5119,
SETFSUID = 5120,
SETFSGID = 5121,
GETSID = 5122,
CAPGET = 5123,
CAPSET = 5124,
RT_SIGPENDING = 5125,
RT_SIGTIMEDWAIT = 5126,
RT_SIGQUEUEINFO = 5127,
RT_SIGSUSPEND = 5128,
SIGALTSTACK = 5129,
UTIME = 5130,
MKNOD = 5131,
PERSONALITY = 5132,
USTAT = 5133,
STATFS = 5134,
FSTATFS = 5135,
SYSFS = 5136,
GETPRIORITY = 5137,
SETPRIORITY = 5138,
SCHED_SETPARAM = 5139,
SCHED_GETPARAM = 5140,
SCHED_SETSCHEDULER = 5141,
SCHED_GETSCHEDULER = 5142,
SCHED_GET_PRIORITY_MAX = 5143,
SCHED_GET_PRIORITY_MIN = 5144,
SCHED_RR_GET_INTERVAL = 5145,
MLOCK = 5146,
MUNLOCK = 5147,
MLOCKALL = 5148,
MUNLOCKALL = 5149,
VHANGUP = 5150,
PIVOT_ROOT = 5151,
_SYSCTL = 5152,
PRCTL = 5153,
ADJTIMEX = 5154,
SETRLIMIT = 5155,
CHROOT = 5156,
SYNC = 5157,
ACCT = 5158,
SETTIMEOFDAY = 5159,
MOUNT = 5160,
UMOUNT2 = 5161,
SWAPON = 5162,
SWAPOFF = 5163,
REBOOT = 5164,
SETHOSTNAME = 5165,
SETDOMAINNAME = 5166,
CREATE_MODULE = 5167,
INIT_MODULE = 5168,
DELETE_MODULE = 5169,
GET_KERNEL_SYMS = 5170,
QUERY_MODULE = 5171,
QUOTACTL = 5172,
NFSSERVCTL = 5173,
GETPMSG = 5174,
PUTPMSG = 5175,
AFS_SYSCALL = 5176,
RESERVED177 = 5177,
GETTID = 5178,
READAHEAD = 5179,
SETXATTR = 5180,
LSETXATTR = 5181,
FSETXATTR = 5182,
GETXATTR = 5183,
LGETXATTR = 5184,
FGETXATTR = 5185,
LISTXATTR = 5186,
LLISTXATTR = 5187,
FLISTXATTR = 5188,
REMOVEXATTR = 5189,
LREMOVEXATTR = 5190,
FREMOVEXATTR = 5191,
TKILL = 5192,
RESERVED193 = 5193,
FUTEX = 5194,
SCHED_SETAFFINITY = 5195,
SCHED_GETAFFINITY = 5196,
CACHEFLUSH = 5197,
CACHECTL = 5198,
SYSMIPS = 5199,
IO_SETUP = 5200,
IO_DESTROY = 5201,
IO_GETEVENTS = 5202,
IO_SUBMIT = 5203,
IO_CANCEL = 5204,
EXIT_GROUP = 5205,
LOOKUP_DCOOKIE = 5206,
EPOLL_CREATE = 5207,
EPOLL_CTL = 5208,
EPOLL_WAIT = 5209,
REMAP_FILE_PAGES = 5210,
SET_TID_ADDRESS = 5212,
RESTART_SYSCALL = 5213,
SEMTIMEDOP = 5214,
FADVISE64 = 5215,
TIMER_CREATE = 5216,
TIMER_SETTIME = 5217,
TIMER_GETTIME = 5218,
TIMER_GETOVERRUN = 5219,
TIMER_DELETE = 5220,
CLOCK_SETTIME = 5221,
CLOCK_GETTIME = 5222,
CLOCK_GETRES = 5223,
CLOCK_NANOSLEEP = 5224,
TGKILL = 5225,
UTIMES = 5226,
MBIND = 5227,
GET_MEMPOLICY = 5228,
SET_MEMPOLICY = 5229,
MQ_OPEN = 5230,
MQ_UNLINK = 5231,
MQ_TIMEDSEND = 5232,
MQ_TIMEDRECEIVE = 5233,
MQ_NOTIFY = 5234,
MQ_GETSETATTR = 5235,
VSERVER = 5236,
WAITID = 5237,
ADD_KEY = 5239,
REQUEST_KEY = 5240,
KEYCTL = 5241,
SET_THREAD_AREA = 5242,
INOTIFY_INIT = 5243,
INOTIFY_ADD_WATCH = 5244,
INOTIFY_RM_WATCH = 5245,
MIGRATE_PAGES = 5246,
OPENAT = 5247,
MKDIRAT = 5248,
MKNODAT = 5249,
FCHOWNAT = 5250,
FUTIMESAT = 5251,
NEWFSTATAT = 5252,
UNLINKAT = 5253,
RENAMEAT = 5254,
LINKAT = 5255,
SYMLINKAT = 5256,
READLINKAT = 5257,
FCHMODAT = 5258,
FACCESSAT = 5259,
PSELECT6 = 5260,
PPOLL = 5261,
UNSHARE = 5262,
SPLICE = 5263,
SYNC_FILE_RANGE = 5264,
TEE = 5265,
VMSPLICE = 5266,
MOVE_PAGES = 5267,
SET_ROBUST_LIST = 5268,
GET_ROBUST_LIST = 5269,
KEXEC_LOAD = 5270,
GETCPU = 5271,
EPOLL_PWAIT = 5272,
IOPRIO_SET = 5273,
IOPRIO_GET = 5274,
UTIMENSAT = 5275,
SIGNALFD = 5276,
TIMERFD = 5277,
EVENTFD = 5278,
FALLOCATE = 5279,
TIMERFD_CREATE = 5280,
TIMERFD_GETTIME = 5281,
TIMERFD_SETTIME = 5282,
SIGNALFD4 = 5283,
EVENTFD2 = 5284,
EPOLL_CREATE1 = 5285,
DUP3 = 5286,
PIPE2 = 5287,
INOTIFY_INIT1 = 5288,
PREADV = 5289,
PWRITEV = 5290,
RT_TGSIGQUEUEINFO = 5291,
PERF_EVENT_OPEN = 5292,
ACCEPT4 = 5293,
RECVMMSG = 5294,
FANOTIFY_INIT = 5295,
FANOTIFY_MARK = 5296,
PRLIMIT64 = 5297,
NAME_TO_HANDLE_AT = 5298,
OPEN_BY_HANDLE_AT = 5299,
CLOCK_ADJTIME = 5300,
SYNCFS = 5301,
SENDMMSG = 5302,
SETNS = 5303,
PROCESS_VM_READV = 5304,
PROCESS_VM_WRITEV = 5305,
KCMP = 5306,
FINIT_MODULE = 5307,
GETDENTS64 = 5308,
SCHED_SETATTR = 5309,
SCHED_GETATTR = 5310,
RENAMEAT2 = 5311,
SECCOMP = 5312,
GETRANDOM = 5313,
MEMFD_CREATE = 5314,
BPF = 5315,
EXECVEAT = 5316,
USERFAULTFD = 5317,
MEMBARRIER = 5318,
MLOCK2 = 5319,
COPY_FILE_RANGE = 5320,
PREADV2 = 5321,
PWRITEV2 = 5322,
PKEY_MPROTECT = 5323,
PKEY_ALLOC = 5324,
PKEY_FREE = 5325,
STATX = 5326,
RSEQ = 5327,
IO_PGETEVENTS = 5328,
PIDFD_SEND_SIGNAL = 5424,
IO_URING_SETUP = 5425,
IO_URING_ENTER = 5426,
IO_URING_REGISTER = 5427,
OPEN_TREE = 5428,
MOVE_MOUNT = 5429,
FSOPEN = 5430,
FSCONFIG = 5431,
FSMOUNT = 5432,
FSPICK = 5433,
PIDFD_OPEN = 5434,
CLONE3 = 5435,
CLOSE_RANGE = 5436,
OPENAT2 = 5437,
PIDFD_GETFD = 5438,
FACCESSAT2 = 5439,
PROCESS_MADVISE = 5440,
EPOLL_PWAIT2 = 5441,
MOUNT_SETATTR = 5442,
QUOTACTL_FD = 5443,
LANDLOCK_CREATE_RULESET = 5444,
LANDLOCK_ADD_RULE = 5445,
LANDLOCK_RESTRICT_SELF = 5446,
PROCESS_MRELEASE = 5448,
FUTEX_WAITV = 5449,
SET_MEMPOLICY_HOME_NODE = 5450,
CACHESTAT = 5451,
FCHMODAT2 = 5452,
MAP_SHADOW_STACK = 5453,
FUTEX_WAKE = 5454,
FUTEX_WAIT = 5455,
FUTEX_REQUEUE = 5456,
STATMOUNT = 5457,
LISTMOUNT = 5458,
LSM_GET_SELF_ATTR = 5459,
LSM_SET_SELF_ATTR = 5460,
LSM_LIST_MODULES = 5461,
MSEAL = 5462,
SETXATTRAT = 5463,
GETXATTRAT = 5464,
LISTXATTRAT = 5465,
REMOVEXATTRAT = 5466,
OPEN_TREE_ATTR = 5467,
FILE_GETATTR = 5468,
FILE_SETATTR = 5469,
LISTNS = 5470,
}
}
+410
View File
@@ -0,0 +1,410 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 1, "exit", 1, { { "int", "error_code" } } },
{ 2, "fork", 0, {} },
{ 3, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 6, "close", 1, { { "unsigned int", "fd" } } },
{ 7, "restart_syscall", 0, {} },
{ 8, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 9, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 10, "unlink", 1, { { "const char *", "pathname" } } },
{ 11, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 12, "chdir", 1, { { "const char *", "filename" } } },
{ 14, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 15, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 19, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 20, "getpid", 0, {} },
{ 21, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 22, "umount", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 26, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 27, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 29, "pause", 0, {} },
{ 30, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 33, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 34, "nice", 1, { { "int", "increment" } } },
{ 36, "sync", 0, {} },
{ 37, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 38, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 39, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 40, "rmdir", 1, { { "const char *", "pathname" } } },
{ 41, "dup", 1, { { "unsigned int", "fildes" } } },
{ 42, "pipe", 1, { { "int *", "fildes" } } },
{ 43, "times", 1, { { "struct tms *", "tbuf" } } },
{ 45, "brk", 1, { { "unsigned long", "brk" } } },
{ 48, "signal", 2, { { "int", "sig" }, { "__sighandler_t", "handler" } } },
{ 51, "acct", 1, { { "const char *", "name" } } },
{ 52, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 54, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 55, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 57, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 60, "umask", 1, { { "int", "mask" } } },
{ 61, "chroot", 1, { { "const char *", "filename" } } },
{ 62, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 63, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 64, "getppid", 0, {} },
{ 65, "getpgrp", 0, {} },
{ 66, "setsid", 0, {} },
{ 73, "sigpending", 1, { { "old_sigset_t *", "uset" } } },
{ 74, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 75, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 77, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 78, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 79, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 83, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 85, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 86, "uselib", 1, { { "const char *", "library" } } },
{ 87, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 88, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 89, "readdir", 0, {} },
{ 90, "mmap", 1, { { "struct mmap_arg_struct *", "arg" } } },
{ 91, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 92, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 93, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 94, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 96, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 97, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 99, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 102, "socketcall", 2, { { "int", "call" }, { "unsigned long *", "args" } } },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 105, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 106, "stat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 107, "lstat", 2, { { "const char *", "filename" }, { "struct stat *", "statbuf" } } },
{ 108, "fstat", 2, { { "unsigned int", "fd" }, { "struct stat *", "statbuf" } } },
{ 110, "lookup_dcookie", 0, {} },
{ 111, "vhangup", 0, {} },
{ 112, "idle", 0, {} },
{ 114, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 116, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 117, "ipc", 6, { { "unsigned int", "call" }, { "int", "first" }, { "unsigned long", "second" }, { "unsigned long", "third" }, { "void *", "ptr" }, { "long", "fifth" } } },
{ 118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 119, "sigreturn", 0, {} },
{ 120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 122, "uname", 1, { { "struct new_utsname *", "name" } } },
{ 124, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 126, "sigprocmask", 3, { { "int", "how" }, { "old_sigset_t *", "nset" }, { "old_sigset_t *", "oset" } } },
{ 127, "create_module", 0, {} },
{ 128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 130, "get_kernel_syms", 0, {} },
{ 131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 134, "bdflush", 0, {} },
{ 135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 136, "personality", 1, { { "unsigned int", "personality" } } },
{ 137, "afs_syscall", 0, {} },
{ 141, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 142, "select", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 147, "getsid", 1, { { "pid_t", "pid" } } },
{ 148, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 149, "_sysctl", 0, {} },
{ 150, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 152, "mlockall", 1, { { "int", "flags" } } },
{ 153, "munlockall", 0, {} },
{ 154, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 155, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 156, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 157, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 158, "sched_yield", 0, {} },
{ 159, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 160, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 161, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 162, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 163, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 167, "query_module", 0, {} },
{ 168, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 169, "nfsservctl", 0, {} },
{ 172, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 173, "rt_sigreturn", 0, {} },
{ 174, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 175, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 176, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 177, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 178, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 179, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 180, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 181, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 183, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 184, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 185, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 186, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 187, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 188, "getpmsg", 0, {} },
{ 189, "putpmsg", 0, {} },
{ 190, "vfork", 0, {} },
{ 191, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 198, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 199, "getuid", 0, {} },
{ 200, "getgid", 0, {} },
{ 201, "geteuid", 0, {} },
{ 202, "getegid", 0, {} },
{ 203, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 204, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 205, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 206, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 207, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 208, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 209, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 210, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 211, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 212, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 213, "setuid", 1, { { "uid_t", "uid" } } },
{ 214, "setgid", 1, { { "gid_t", "gid" } } },
{ 215, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 216, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 217, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 218, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 219, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 220, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 222, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 224, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 225, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 226, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 227, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 228, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 229, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 230, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 231, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 232, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 233, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 234, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 235, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 236, "gettid", 0, {} },
{ 237, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 238, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 239, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 240, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 241, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 243, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 244, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 245, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 246, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 247, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 248, "exit_group", 1, { { "int", "error_code" } } },
{ 249, "epoll_create", 1, { { "int", "size" } } },
{ 250, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 251, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 252, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 253, "fadvise64", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "len" }, { "int", "advice" } } },
{ 254, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 255, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 256, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 257, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 258, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 259, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 260, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 261, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 262, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 265, "statfs64", 3, { { "const char *", "pathname" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 266, "fstatfs64", 3, { { "unsigned int", "fd" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 267, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 268, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 269, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 270, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 271, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 272, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 273, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 274, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 275, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 276, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 277, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 278, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 279, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 280, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 281, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 282, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 283, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 284, "inotify_init", 0, {} },
{ 285, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 286, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 287, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 288, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 289, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 290, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 291, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 292, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 293, "newfstatat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat *", "statbuf" }, { "int", "flag" } } },
{ 294, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 295, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 296, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 297, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 298, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 299, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 300, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 301, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 302, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 303, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 304, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 305, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 306, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 307, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 308, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 309, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 310, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 311, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 312, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 313, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 314, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 315, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 316, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 317, "timerfd", 0, {} },
{ 318, "eventfd", 1, { { "unsigned int", "count" } } },
{ 319, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 320, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 321, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 322, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 323, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 324, "inotify_init1", 1, { { "int", "flags" } } },
{ 325, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 326, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 327, "epoll_create1", 1, { { "int", "flags" } } },
{ 328, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 329, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 330, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 331, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 332, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 333, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 334, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 335, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 336, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 337, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 338, "syncfs", 1, { { "int", "fd" } } },
{ 339, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 340, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 341, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 342, "s390_runtime_instr", 2, { { "int", "command" }, { "int", "signum" } } },
{ 343, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 344, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 345, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 346, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 347, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 348, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 349, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 350, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 351, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 352, "s390_pci_mmio_write", 3, { { "unsigned long", "mmio_addr" }, { "const void *", "user_buffer" }, { "size_t", "length" } } },
{ 353, "s390_pci_mmio_read", 3, { { "unsigned long", "mmio_addr" }, { "void *", "user_buffer" }, { "size_t", "length" } } },
{ 354, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 355, "userfaultfd", 1, { { "int", "flags" } } },
{ 356, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 357, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 358, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 359, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 360, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 361, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 362, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 363, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 364, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 365, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 366, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 367, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 368, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 369, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 370, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 371, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 372, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 373, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 374, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 375, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 376, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 377, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 378, "s390_guarded_storage", 2, { { "int", "command" }, { "struct gs_cb *", "gs_cb" } } },
{ 379, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 380, "s390_sthyi", 4, { { "unsigned long", "function_code" }, { "void *", "buffer" }, { "u64 *", "return_code" }, { "unsigned long", "flags" } } },
{ 381, "kexec_file_load", 5, { { "int", "kernel_fd" }, { "int", "initrd_fd" }, { "unsigned long", "cmdline_len" }, { "const char *", "cmdline_ptr" }, { "unsigned long", "flags" } } },
{ 382, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 383, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 384, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 385, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 386, "pkey_free", 1, { { "int", "pkey" } } },
{ 392, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 393, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 394, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 395, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 396, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 397, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 398, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 399, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 400, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 401, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 402, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 447, "memfd_secret", 1, { { "unsigned int", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = 0;
return NULL;
}
+393
View File
@@ -0,0 +1,393 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
EXIT = 1,
FORK = 2,
READ = 3,
WRITE = 4,
OPEN = 5,
CLOSE = 6,
RESTART_SYSCALL = 7,
CREAT = 8,
LINK = 9,
UNLINK = 10,
EXECVE = 11,
CHDIR = 12,
MKNOD = 14,
CHMOD = 15,
LSEEK = 19,
GETPID = 20,
MOUNT = 21,
UMOUNT = 22,
PTRACE = 26,
ALARM = 27,
PAUSE = 29,
UTIME = 30,
ACCESS = 33,
NICE = 34,
SYNC = 36,
KILL = 37,
RENAME = 38,
MKDIR = 39,
RMDIR = 40,
DUP = 41,
PIPE = 42,
TIMES = 43,
BRK = 45,
SIGNAL = 48,
ACCT = 51,
UMOUNT2 = 52,
IOCTL = 54,
FCNTL = 55,
SETPGID = 57,
UMASK = 60,
CHROOT = 61,
USTAT = 62,
DUP2 = 63,
GETPPID = 64,
GETPGRP = 65,
SETSID = 66,
SIGPENDING = 73,
SETHOSTNAME = 74,
SETRLIMIT = 75,
GETRUSAGE = 77,
GETTIMEOFDAY = 78,
SETTIMEOFDAY = 79,
SYMLINK = 83,
READLINK = 85,
USELIB = 86,
SWAPON = 87,
REBOOT = 88,
READDIR = 89,
MMAP = 90,
MUNMAP = 91,
TRUNCATE = 92,
FTRUNCATE = 93,
FCHMOD = 94,
GETPRIORITY = 96,
SETPRIORITY = 97,
STATFS = 99,
FSTATFS = 100,
SOCKETCALL = 102,
SYSLOG = 103,
SETITIMER = 104,
GETITIMER = 105,
STAT = 106,
LSTAT = 107,
FSTAT = 108,
LOOKUP_DCOOKIE = 110,
VHANGUP = 111,
IDLE = 112,
WAIT4 = 114,
SWAPOFF = 115,
SYSINFO = 116,
IPC = 117,
FSYNC = 118,
SIGRETURN = 119,
CLONE = 120,
SETDOMAINNAME = 121,
UNAME = 122,
ADJTIMEX = 124,
MPROTECT = 125,
SIGPROCMASK = 126,
CREATE_MODULE = 127,
INIT_MODULE = 128,
DELETE_MODULE = 129,
GET_KERNEL_SYMS = 130,
QUOTACTL = 131,
GETPGID = 132,
FCHDIR = 133,
BDFLUSH = 134,
SYSFS = 135,
PERSONALITY = 136,
AFS_SYSCALL = 137,
GETDENTS = 141,
SELECT = 142,
FLOCK = 143,
MSYNC = 144,
READV = 145,
WRITEV = 146,
GETSID = 147,
FDATASYNC = 148,
_SYSCTL = 149,
MLOCK = 150,
MUNLOCK = 151,
MLOCKALL = 152,
MUNLOCKALL = 153,
SCHED_SETPARAM = 154,
SCHED_GETPARAM = 155,
SCHED_SETSCHEDULER = 156,
SCHED_GETSCHEDULER = 157,
SCHED_YIELD = 158,
SCHED_GET_PRIORITY_MAX = 159,
SCHED_GET_PRIORITY_MIN = 160,
SCHED_RR_GET_INTERVAL = 161,
NANOSLEEP = 162,
MREMAP = 163,
QUERY_MODULE = 167,
POLL = 168,
NFSSERVCTL = 169,
PRCTL = 172,
RT_SIGRETURN = 173,
RT_SIGACTION = 174,
RT_SIGPROCMASK = 175,
RT_SIGPENDING = 176,
RT_SIGTIMEDWAIT = 177,
RT_SIGQUEUEINFO = 178,
RT_SIGSUSPEND = 179,
PREAD64 = 180,
PWRITE64 = 181,
GETCWD = 183,
CAPGET = 184,
CAPSET = 185,
SIGALTSTACK = 186,
SENDFILE = 187,
GETPMSG = 188,
PUTPMSG = 189,
VFORK = 190,
GETRLIMIT = 191,
LCHOWN = 198,
GETUID = 199,
GETGID = 200,
GETEUID = 201,
GETEGID = 202,
SETREUID = 203,
SETREGID = 204,
GETGROUPS = 205,
SETGROUPS = 206,
FCHOWN = 207,
SETRESUID = 208,
GETRESUID = 209,
SETRESGID = 210,
GETRESGID = 211,
CHOWN = 212,
SETUID = 213,
SETGID = 214,
SETFSUID = 215,
SETFSGID = 216,
PIVOT_ROOT = 217,
MINCORE = 218,
MADVISE = 219,
GETDENTS64 = 220,
READAHEAD = 222,
SETXATTR = 224,
LSETXATTR = 225,
FSETXATTR = 226,
GETXATTR = 227,
LGETXATTR = 228,
FGETXATTR = 229,
LISTXATTR = 230,
LLISTXATTR = 231,
FLISTXATTR = 232,
REMOVEXATTR = 233,
LREMOVEXATTR = 234,
FREMOVEXATTR = 235,
GETTID = 236,
TKILL = 237,
FUTEX = 238,
SCHED_SETAFFINITY = 239,
SCHED_GETAFFINITY = 240,
TGKILL = 241,
IO_SETUP = 243,
IO_DESTROY = 244,
IO_GETEVENTS = 245,
IO_SUBMIT = 246,
IO_CANCEL = 247,
EXIT_GROUP = 248,
EPOLL_CREATE = 249,
EPOLL_CTL = 250,
EPOLL_WAIT = 251,
SET_TID_ADDRESS = 252,
FADVISE64 = 253,
TIMER_CREATE = 254,
TIMER_SETTIME = 255,
TIMER_GETTIME = 256,
TIMER_GETOVERRUN = 257,
TIMER_DELETE = 258,
CLOCK_SETTIME = 259,
CLOCK_GETTIME = 260,
CLOCK_GETRES = 261,
CLOCK_NANOSLEEP = 262,
STATFS64 = 265,
FSTATFS64 = 266,
REMAP_FILE_PAGES = 267,
MBIND = 268,
GET_MEMPOLICY = 269,
SET_MEMPOLICY = 270,
MQ_OPEN = 271,
MQ_UNLINK = 272,
MQ_TIMEDSEND = 273,
MQ_TIMEDRECEIVE = 274,
MQ_NOTIFY = 275,
MQ_GETSETATTR = 276,
KEXEC_LOAD = 277,
ADD_KEY = 278,
REQUEST_KEY = 279,
KEYCTL = 280,
WAITID = 281,
IOPRIO_SET = 282,
IOPRIO_GET = 283,
INOTIFY_INIT = 284,
INOTIFY_ADD_WATCH = 285,
INOTIFY_RM_WATCH = 286,
MIGRATE_PAGES = 287,
OPENAT = 288,
MKDIRAT = 289,
MKNODAT = 290,
FCHOWNAT = 291,
FUTIMESAT = 292,
NEWFSTATAT = 293,
UNLINKAT = 294,
RENAMEAT = 295,
LINKAT = 296,
SYMLINKAT = 297,
READLINKAT = 298,
FCHMODAT = 299,
FACCESSAT = 300,
PSELECT6 = 301,
PPOLL = 302,
UNSHARE = 303,
SET_ROBUST_LIST = 304,
GET_ROBUST_LIST = 305,
SPLICE = 306,
SYNC_FILE_RANGE = 307,
TEE = 308,
VMSPLICE = 309,
MOVE_PAGES = 310,
GETCPU = 311,
EPOLL_PWAIT = 312,
UTIMES = 313,
FALLOCATE = 314,
UTIMENSAT = 315,
SIGNALFD = 316,
TIMERFD = 317,
EVENTFD = 318,
TIMERFD_CREATE = 319,
TIMERFD_SETTIME = 320,
TIMERFD_GETTIME = 321,
SIGNALFD4 = 322,
EVENTFD2 = 323,
INOTIFY_INIT1 = 324,
PIPE2 = 325,
DUP3 = 326,
EPOLL_CREATE1 = 327,
PREADV = 328,
PWRITEV = 329,
RT_TGSIGQUEUEINFO = 330,
PERF_EVENT_OPEN = 331,
FANOTIFY_INIT = 332,
FANOTIFY_MARK = 333,
PRLIMIT64 = 334,
NAME_TO_HANDLE_AT = 335,
OPEN_BY_HANDLE_AT = 336,
CLOCK_ADJTIME = 337,
SYNCFS = 338,
SETNS = 339,
PROCESS_VM_READV = 340,
PROCESS_VM_WRITEV = 341,
S390_RUNTIME_INSTR = 342,
KCMP = 343,
FINIT_MODULE = 344,
SCHED_SETATTR = 345,
SCHED_GETATTR = 346,
RENAMEAT2 = 347,
SECCOMP = 348,
GETRANDOM = 349,
MEMFD_CREATE = 350,
BPF = 351,
S390_PCI_MMIO_WRITE = 352,
S390_PCI_MMIO_READ = 353,
EXECVEAT = 354,
USERFAULTFD = 355,
MEMBARRIER = 356,
RECVMMSG = 357,
SENDMMSG = 358,
SOCKET = 359,
SOCKETPAIR = 360,
BIND = 361,
CONNECT = 362,
LISTEN = 363,
ACCEPT4 = 364,
GETSOCKOPT = 365,
SETSOCKOPT = 366,
GETSOCKNAME = 367,
GETPEERNAME = 368,
SENDTO = 369,
SENDMSG = 370,
RECVFROM = 371,
RECVMSG = 372,
SHUTDOWN = 373,
MLOCK2 = 374,
COPY_FILE_RANGE = 375,
PREADV2 = 376,
PWRITEV2 = 377,
S390_GUARDED_STORAGE = 378,
STATX = 379,
S390_STHYI = 380,
KEXEC_FILE_LOAD = 381,
IO_PGETEVENTS = 382,
RSEQ = 383,
PKEY_MPROTECT = 384,
PKEY_ALLOC = 385,
PKEY_FREE = 386,
SEMTIMEDOP = 392,
SEMGET = 393,
SEMCTL = 394,
SHMGET = 395,
SHMCTL = 396,
SHMAT = 397,
SHMDT = 398,
MSGGET = 399,
MSGSND = 400,
MSGRCV = 401,
MSGCTL = 402,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
MEMFD_SECRET = 447,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
}
+459
View File
@@ -0,0 +1,459 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 0, "restart_syscall", 0, {} },
{ 1, "exit", 1, { { "int", "error_code" } } },
{ 2, "fork", 0, {} },
{ 3, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 6, "close", 1, { { "unsigned int", "fd" } } },
{ 7, "waitpid", 3, { { "pid_t", "pid" }, { "int *", "stat_addr" }, { "int", "options" } } },
{ 8, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 9, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 10, "unlink", 1, { { "const char *", "pathname" } } },
{ 11, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 12, "chdir", 1, { { "const char *", "filename" } } },
{ 13, "time", 1, { { "__kernel_old_time_t *", "tloc" } } },
{ 14, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 15, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 16, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 18, "oldstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 19, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 20, "getpid", 0, {} },
{ 21, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 22, "umount", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 23, "setuid", 1, { { "uid_t", "uid" } } },
{ 24, "getuid", 0, {} },
{ 25, "stime", 1, { { "__kernel_old_time_t *", "tptr" } } },
{ 26, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 27, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 28, "oldfstat", 2, { { "unsigned int", "fd" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 29, "pause", 0, {} },
{ 30, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 33, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 34, "nice", 1, { { "int", "increment" } } },
{ 36, "sync", 0, {} },
{ 37, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 38, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 39, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 40, "rmdir", 1, { { "const char *", "pathname" } } },
{ 41, "dup", 1, { { "unsigned int", "fildes" } } },
{ 42, "pipe", 1, { { "int *", "fildes" } } },
{ 43, "times", 1, { { "struct tms *", "tbuf" } } },
{ 45, "brk", 1, { { "unsigned long", "brk" } } },
{ 46, "setgid", 1, { { "gid_t", "gid" } } },
{ 47, "getgid", 0, {} },
{ 48, "signal", 2, { { "int", "sig" }, { "__sighandler_t", "handler" } } },
{ 49, "geteuid", 0, {} },
{ 50, "getegid", 0, {} },
{ 51, "acct", 1, { { "const char *", "name" } } },
{ 52, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 54, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 55, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 57, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 59, "oldolduname", 1, { { "struct oldold_utsname *", "arg0" } } },
{ 60, "umask", 1, { { "int", "mask" } } },
{ 61, "chroot", 1, { { "const char *", "filename" } } },
{ 62, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 63, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 64, "getppid", 0, {} },
{ 65, "getpgrp", 0, {} },
{ 66, "setsid", 0, {} },
{ 67, "sigaction", 3, { { "int", "sig" }, { "const struct old_sigaction *", "act" }, { "struct old_sigaction *", "oact" } } },
{ 68, "sgetmask", 0, {} },
{ 69, "ssetmask", 1, { { "int", "newmask" } } },
{ 70, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 71, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 72, "sigsuspend", 3, { { "int", "unused1" }, { "int", "unused2" }, { "old_sigset_t", "mask" } } },
{ 73, "sigpending", 1, { { "old_sigset_t *", "uset" } } },
{ 74, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 75, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 76, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 77, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 78, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 79, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 80, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 81, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 82, "select", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 83, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 84, "oldlstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 85, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 86, "uselib", 1, { { "const char *", "library" } } },
{ 87, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 88, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 89, "readdir", 3, { { "unsigned", "int" }, { "struct old_linux_dirent *", "arg1" }, { "unsigned", "int" } } },
{ 90, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "off" } } },
{ 91, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 92, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 93, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 94, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 95, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 96, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 97, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 99, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 101, "ioperm", 3, { { "unsigned long", "from" }, { "unsigned long", "num" }, { "int", "turn_on" } } },
{ 102, "socketcall", 2, { { "int", "call" }, { "unsigned long *", "args" } } },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 105, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 106, "stat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 107, "lstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 108, "fstat", 2, { { "unsigned int", "fd" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 109, "olduname", 1, { { "struct oldold_utsname *", "name" } } },
{ 110, "iopl", 1, { { "unsigned int", "level" } } },
{ 111, "vhangup", 0, {} },
{ 113, "vm86old", 1, { { "struct vm86_struct *", "user_vm86" } } },
{ 114, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 116, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 117, "ipc", 6, { { "unsigned int", "call" }, { "int", "first" }, { "unsigned long", "second" }, { "unsigned long", "third" }, { "void *", "ptr" }, { "long", "fifth" } } },
{ 118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 122, "uname", 1, { { "struct old_utsname *", "name" } } },
{ 123, "modify_ldt", 3, { { "int", "func" }, { "void *", "ptr" }, { "unsigned long", "bytecount" } } },
{ 124, "adjtimex", 1, { { "struct old_timex32 *", "txc_p" } } },
{ 125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 126, "sigprocmask", 3, { { "int", "how" }, { "old_sigset_t *", "nset" }, { "old_sigset_t *", "oset" } } },
{ 128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 134, "bdflush", 0, {} },
{ 135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 136, "personality", 1, { { "unsigned int", "personality" } } },
{ 138, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 139, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 140, "_llseek", 5, { { "unsigned int", "fd" }, { "unsigned long", "offset_high" }, { "unsigned long", "offset_low" }, { "loff_t *", "result" }, { "unsigned int", "whence" } } },
{ 141, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 142, "_newselect", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 147, "getsid", 1, { { "pid_t", "pid" } } },
{ 148, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 149, "_sysctl", 0, {} },
{ 150, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 152, "mlockall", 1, { { "int", "flags" } } },
{ 153, "munlockall", 0, {} },
{ 154, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 155, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 156, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 157, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 158, "sched_yield", 0, {} },
{ 159, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 160, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 161, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 162, "nanosleep", 2, { { "struct old_timespec32 *", "rqtp" }, { "struct old_timespec32 *", "rmtp" } } },
{ 163, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 164, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 165, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 166, "vm86", 2, { { "unsigned long", "cmd" }, { "unsigned long", "arg" } } },
{ 168, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 170, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 171, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 172, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 173, "rt_sigreturn", 0, {} },
{ 174, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 175, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 176, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 177, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 178, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 179, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 180, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 181, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 182, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 183, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 184, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 185, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 186, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 187, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 190, "vfork", 0, {} },
{ 191, "ugetrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 192, "mmap2", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "pgoff" } } },
{ 193, "truncate64", 2, { { "const char *", "path" }, { "loff_t", "length" } } },
{ 194, "ftruncate64", 2, { { "unsigned int", "fd" }, { "loff_t", "length" } } },
{ 198, "lchown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 199, "getuid32", 0, {} },
{ 200, "getgid32", 0, {} },
{ 201, "geteuid32", 0, {} },
{ 202, "getegid32", 0, {} },
{ 203, "setreuid32", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 204, "setregid32", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 205, "getgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 206, "setgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 207, "fchown32", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 208, "setresuid32", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 209, "getresuid32", 3, { { "uid_t *", "ruid" }, { "uid_t *", "euid" }, { "uid_t *", "suid" } } },
{ 210, "setresgid32", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 211, "getresgid32", 3, { { "gid_t *", "rgid" }, { "gid_t *", "egid" }, { "gid_t *", "sgid" } } },
{ 212, "chown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 213, "setuid32", 1, { { "uid_t", "uid" } } },
{ 214, "setgid32", 1, { { "gid_t", "gid" } } },
{ 215, "setfsuid32", 1, { { "uid_t", "uid" } } },
{ 216, "setfsgid32", 1, { { "gid_t", "gid" } } },
{ 217, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 218, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 219, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 220, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 221, "fcntl64", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 224, "gettid", 0, {} },
{ 225, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 226, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 227, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 228, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 229, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 230, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 231, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 232, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 233, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 234, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 235, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 236, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 237, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 238, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 239, "sendfile64", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "loff_t *", "offset" }, { "size_t", "count" } } },
{ 240, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 241, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 242, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 243, "set_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 244, "get_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 245, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 246, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 247, "io_getevents", 5, { { "__u32", "ctx_id" }, { "__s32", "min_nr" }, { "__s32", "nr" }, { "struct io_event *", "events" }, { "struct old_timespec32 *", "timeout" } } },
{ 248, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 249, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 250, "fadvise64", 5, { { "int", "fd" }, { "unsigned int", "offset_lo" }, { "unsigned int", "offset_hi" }, { "size_t", "len" }, { "int", "advice" } } },
{ 252, "exit_group", 1, { { "int", "error_code" } } },
{ 254, "epoll_create", 1, { { "int", "size" } } },
{ 255, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 256, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 257, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 258, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 259, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 260, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 261, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 262, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 263, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 264, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 265, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 266, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 267, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 268, "statfs64", 3, { { "const char *", "pathname" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 269, "fstatfs64", 3, { { "unsigned int", "fd" }, { "size_t", "sz" }, { "struct statfs64 *", "buf" } } },
{ 270, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 271, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 272, "fadvise64_64", 6, { { "int", "fd" }, { "__u32", "offset_low" }, { "__u32", "offset_high" }, { "__u32", "len_low" }, { "__u32", "len_high" }, { "int", "advice" } } },
{ 274, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 275, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 276, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 277, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 278, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 279, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 280, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 281, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 282, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 283, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 284, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 286, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 287, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 288, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 289, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 290, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 291, "inotify_init", 0, {} },
{ 292, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 293, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 294, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 295, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 296, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 297, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 298, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 299, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 301, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 302, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 303, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 304, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 305, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 306, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 307, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 308, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 309, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 310, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 311, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 312, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 313, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 314, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 315, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 316, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 317, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 318, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 319, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 320, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 321, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 322, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 323, "eventfd", 1, { { "unsigned int", "count" } } },
{ 324, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 325, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 326, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 327, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 328, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 329, "epoll_create1", 1, { { "int", "flags" } } },
{ 330, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 331, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 332, "inotify_init1", 1, { { "int", "flags" } } },
{ 333, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 334, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 335, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 336, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 337, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 338, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 339, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 340, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 341, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 342, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 343, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 344, "syncfs", 1, { { "int", "fd" } } },
{ 345, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 346, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 347, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 348, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 349, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 350, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 351, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 352, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 353, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 354, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 355, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 356, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 357, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 358, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 359, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 360, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 361, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 362, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 363, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 364, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 365, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 366, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 367, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 368, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 369, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 370, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 371, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 372, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 373, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 374, "userfaultfd", 1, { { "int", "flags" } } },
{ 375, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 376, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 377, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 378, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 379, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 380, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 381, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 382, "pkey_free", 1, { { "int", "pkey" } } },
{ 383, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 384, "arch_prctl", 2, { { "int", "option" }, { "unsigned long", "arg2" } } },
{ 385, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 386, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 393, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 394, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 395, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 396, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 397, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 398, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 399, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 400, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 401, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 402, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 403, "clock_gettime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 404, "clock_settime64", 2, { { "clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 405, "clock_adjtime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timex *", "tx" } } },
{ 406, "clock_getres_time64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 407, "clock_nanosleep_time64", 4, { { "clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 408, "timer_gettime64", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 409, "timer_settime64", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 410, "timerfd_gettime64", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 411, "timerfd_settime64", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 412, "utimensat_time64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 413, "pselect6_time64", 6, { { "int", "arg0" }, { "fd_set *", "arg1" }, { "fd_set *", "arg2" }, { "fd_set *", "arg3" }, { "struct __kernel_timespec *", "arg4" }, { "void *", "arg5" } } },
{ 414, "ppoll_time64", 5, { { "struct pollfd *", "arg0" }, { "unsigned", "int" }, { "struct __kernel_timespec *", "arg2" }, { "const sigset_t *", "arg3" }, { "size_t", "arg4" } } },
{ 416, "io_pgetevents_time64", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "sig" } } },
{ 417, "recvmmsg_time64", 5, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 418, "mq_timedsend_time64", 5, { { "mqd_t", "mqdes" }, { "const char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 419, "mq_timedreceive_time64", 5, { { "mqd_t", "mqdes" }, { "char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 420, "semtimedop_time64", 4, { { "int", "semid" }, { "struct sembuf *", "sops" }, { "unsigned", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 421, "rt_sigtimedwait_time64", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 422, "futex_time64", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 423, "sched_rr_get_interval_time64", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 447, "memfd_secret", 1, { { "unsigned int", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = 0;
return NULL;
}
+442
View File
@@ -0,0 +1,442 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
RESTART_SYSCALL = 0,
EXIT = 1,
FORK = 2,
READ = 3,
WRITE = 4,
OPEN = 5,
CLOSE = 6,
WAITPID = 7,
CREAT = 8,
LINK = 9,
UNLINK = 10,
EXECVE = 11,
CHDIR = 12,
TIME = 13,
MKNOD = 14,
CHMOD = 15,
LCHOWN = 16,
OLDSTAT = 18,
LSEEK = 19,
GETPID = 20,
MOUNT = 21,
UMOUNT = 22,
SETUID = 23,
GETUID = 24,
STIME = 25,
PTRACE = 26,
ALARM = 27,
OLDFSTAT = 28,
PAUSE = 29,
UTIME = 30,
ACCESS = 33,
NICE = 34,
SYNC = 36,
KILL = 37,
RENAME = 38,
MKDIR = 39,
RMDIR = 40,
DUP = 41,
PIPE = 42,
TIMES = 43,
BRK = 45,
SETGID = 46,
GETGID = 47,
SIGNAL = 48,
GETEUID = 49,
GETEGID = 50,
ACCT = 51,
UMOUNT2 = 52,
IOCTL = 54,
FCNTL = 55,
SETPGID = 57,
OLDOLDUNAME = 59,
UMASK = 60,
CHROOT = 61,
USTAT = 62,
DUP2 = 63,
GETPPID = 64,
GETPGRP = 65,
SETSID = 66,
SIGACTION = 67,
SGETMASK = 68,
SSETMASK = 69,
SETREUID = 70,
SETREGID = 71,
SIGSUSPEND = 72,
SIGPENDING = 73,
SETHOSTNAME = 74,
SETRLIMIT = 75,
GETRLIMIT = 76,
GETRUSAGE = 77,
GETTIMEOFDAY = 78,
SETTIMEOFDAY = 79,
GETGROUPS = 80,
SETGROUPS = 81,
SELECT = 82,
SYMLINK = 83,
OLDLSTAT = 84,
READLINK = 85,
USELIB = 86,
SWAPON = 87,
REBOOT = 88,
READDIR = 89,
MMAP = 90,
MUNMAP = 91,
TRUNCATE = 92,
FTRUNCATE = 93,
FCHMOD = 94,
FCHOWN = 95,
GETPRIORITY = 96,
SETPRIORITY = 97,
STATFS = 99,
FSTATFS = 100,
IOPERM = 101,
SOCKETCALL = 102,
SYSLOG = 103,
SETITIMER = 104,
GETITIMER = 105,
STAT = 106,
LSTAT = 107,
FSTAT = 108,
OLDUNAME = 109,
IOPL = 110,
VHANGUP = 111,
VM86OLD = 113,
WAIT4 = 114,
SWAPOFF = 115,
SYSINFO = 116,
IPC = 117,
FSYNC = 118,
CLONE = 120,
SETDOMAINNAME = 121,
UNAME = 122,
MODIFY_LDT = 123,
ADJTIMEX = 124,
MPROTECT = 125,
SIGPROCMASK = 126,
INIT_MODULE = 128,
DELETE_MODULE = 129,
QUOTACTL = 131,
GETPGID = 132,
FCHDIR = 133,
BDFLUSH = 134,
SYSFS = 135,
PERSONALITY = 136,
SETFSUID = 138,
SETFSGID = 139,
_LLSEEK = 140,
GETDENTS = 141,
_NEWSELECT = 142,
FLOCK = 143,
MSYNC = 144,
READV = 145,
WRITEV = 146,
GETSID = 147,
FDATASYNC = 148,
_SYSCTL = 149,
MLOCK = 150,
MUNLOCK = 151,
MLOCKALL = 152,
MUNLOCKALL = 153,
SCHED_SETPARAM = 154,
SCHED_GETPARAM = 155,
SCHED_SETSCHEDULER = 156,
SCHED_GETSCHEDULER = 157,
SCHED_YIELD = 158,
SCHED_GET_PRIORITY_MAX = 159,
SCHED_GET_PRIORITY_MIN = 160,
SCHED_RR_GET_INTERVAL = 161,
NANOSLEEP = 162,
MREMAP = 163,
SETRESUID = 164,
GETRESUID = 165,
VM86 = 166,
POLL = 168,
SETRESGID = 170,
GETRESGID = 171,
PRCTL = 172,
RT_SIGRETURN = 173,
RT_SIGACTION = 174,
RT_SIGPROCMASK = 175,
RT_SIGPENDING = 176,
RT_SIGTIMEDWAIT = 177,
RT_SIGQUEUEINFO = 178,
RT_SIGSUSPEND = 179,
PREAD64 = 180,
PWRITE64 = 181,
CHOWN = 182,
GETCWD = 183,
CAPGET = 184,
CAPSET = 185,
SIGALTSTACK = 186,
SENDFILE = 187,
VFORK = 190,
UGETRLIMIT = 191,
MMAP2 = 192,
TRUNCATE64 = 193,
FTRUNCATE64 = 194,
LCHOWN32 = 198,
GETUID32 = 199,
GETGID32 = 200,
GETEUID32 = 201,
GETEGID32 = 202,
SETREUID32 = 203,
SETREGID32 = 204,
GETGROUPS32 = 205,
SETGROUPS32 = 206,
FCHOWN32 = 207,
SETRESUID32 = 208,
GETRESUID32 = 209,
SETRESGID32 = 210,
GETRESGID32 = 211,
CHOWN32 = 212,
SETUID32 = 213,
SETGID32 = 214,
SETFSUID32 = 215,
SETFSGID32 = 216,
PIVOT_ROOT = 217,
MINCORE = 218,
MADVISE = 219,
GETDENTS64 = 220,
FCNTL64 = 221,
GETTID = 224,
READAHEAD = 225,
SETXATTR = 226,
LSETXATTR = 227,
FSETXATTR = 228,
GETXATTR = 229,
LGETXATTR = 230,
FGETXATTR = 231,
LISTXATTR = 232,
LLISTXATTR = 233,
FLISTXATTR = 234,
REMOVEXATTR = 235,
LREMOVEXATTR = 236,
FREMOVEXATTR = 237,
TKILL = 238,
SENDFILE64 = 239,
FUTEX = 240,
SCHED_SETAFFINITY = 241,
SCHED_GETAFFINITY = 242,
SET_THREAD_AREA = 243,
GET_THREAD_AREA = 244,
IO_SETUP = 245,
IO_DESTROY = 246,
IO_GETEVENTS = 247,
IO_SUBMIT = 248,
IO_CANCEL = 249,
FADVISE64 = 250,
EXIT_GROUP = 252,
EPOLL_CREATE = 254,
EPOLL_CTL = 255,
EPOLL_WAIT = 256,
REMAP_FILE_PAGES = 257,
SET_TID_ADDRESS = 258,
TIMER_CREATE = 259,
TIMER_SETTIME = 260,
TIMER_GETTIME = 261,
TIMER_GETOVERRUN = 262,
TIMER_DELETE = 263,
CLOCK_SETTIME = 264,
CLOCK_GETTIME = 265,
CLOCK_GETRES = 266,
CLOCK_NANOSLEEP = 267,
STATFS64 = 268,
FSTATFS64 = 269,
TGKILL = 270,
UTIMES = 271,
FADVISE64_64 = 272,
MBIND = 274,
GET_MEMPOLICY = 275,
SET_MEMPOLICY = 276,
MQ_OPEN = 277,
MQ_UNLINK = 278,
MQ_TIMEDSEND = 279,
MQ_TIMEDRECEIVE = 280,
MQ_NOTIFY = 281,
MQ_GETSETATTR = 282,
KEXEC_LOAD = 283,
WAITID = 284,
ADD_KEY = 286,
REQUEST_KEY = 287,
KEYCTL = 288,
IOPRIO_SET = 289,
IOPRIO_GET = 290,
INOTIFY_INIT = 291,
INOTIFY_ADD_WATCH = 292,
INOTIFY_RM_WATCH = 293,
MIGRATE_PAGES = 294,
OPENAT = 295,
MKDIRAT = 296,
MKNODAT = 297,
FCHOWNAT = 298,
FUTIMESAT = 299,
UNLINKAT = 301,
RENAMEAT = 302,
LINKAT = 303,
SYMLINKAT = 304,
READLINKAT = 305,
FCHMODAT = 306,
FACCESSAT = 307,
PSELECT6 = 308,
PPOLL = 309,
UNSHARE = 310,
SET_ROBUST_LIST = 311,
GET_ROBUST_LIST = 312,
SPLICE = 313,
SYNC_FILE_RANGE = 314,
TEE = 315,
VMSPLICE = 316,
MOVE_PAGES = 317,
GETCPU = 318,
EPOLL_PWAIT = 319,
UTIMENSAT = 320,
SIGNALFD = 321,
TIMERFD_CREATE = 322,
EVENTFD = 323,
FALLOCATE = 324,
TIMERFD_SETTIME = 325,
TIMERFD_GETTIME = 326,
SIGNALFD4 = 327,
EVENTFD2 = 328,
EPOLL_CREATE1 = 329,
DUP3 = 330,
PIPE2 = 331,
INOTIFY_INIT1 = 332,
PREADV = 333,
PWRITEV = 334,
RT_TGSIGQUEUEINFO = 335,
PERF_EVENT_OPEN = 336,
RECVMMSG = 337,
FANOTIFY_INIT = 338,
FANOTIFY_MARK = 339,
PRLIMIT64 = 340,
NAME_TO_HANDLE_AT = 341,
OPEN_BY_HANDLE_AT = 342,
CLOCK_ADJTIME = 343,
SYNCFS = 344,
SENDMMSG = 345,
SETNS = 346,
PROCESS_VM_READV = 347,
PROCESS_VM_WRITEV = 348,
KCMP = 349,
FINIT_MODULE = 350,
SCHED_SETATTR = 351,
SCHED_GETATTR = 352,
RENAMEAT2 = 353,
SECCOMP = 354,
GETRANDOM = 355,
MEMFD_CREATE = 356,
BPF = 357,
EXECVEAT = 358,
SOCKET = 359,
SOCKETPAIR = 360,
BIND = 361,
CONNECT = 362,
LISTEN = 363,
ACCEPT4 = 364,
GETSOCKOPT = 365,
SETSOCKOPT = 366,
GETSOCKNAME = 367,
GETPEERNAME = 368,
SENDTO = 369,
SENDMSG = 370,
RECVFROM = 371,
RECVMSG = 372,
SHUTDOWN = 373,
USERFAULTFD = 374,
MEMBARRIER = 375,
MLOCK2 = 376,
COPY_FILE_RANGE = 377,
PREADV2 = 378,
PWRITEV2 = 379,
PKEY_MPROTECT = 380,
PKEY_ALLOC = 381,
PKEY_FREE = 382,
STATX = 383,
ARCH_PRCTL = 384,
IO_PGETEVENTS = 385,
RSEQ = 386,
SEMGET = 393,
SEMCTL = 394,
SHMGET = 395,
SHMCTL = 396,
SHMAT = 397,
SHMDT = 398,
MSGGET = 399,
MSGSND = 400,
MSGRCV = 401,
MSGCTL = 402,
CLOCK_GETTIME64 = 403,
CLOCK_SETTIME64 = 404,
CLOCK_ADJTIME64 = 405,
CLOCK_GETRES_TIME64 = 406,
CLOCK_NANOSLEEP_TIME64 = 407,
TIMER_GETTIME64 = 408,
TIMER_SETTIME64 = 409,
TIMERFD_GETTIME64 = 410,
TIMERFD_SETTIME64 = 411,
UTIMENSAT_TIME64 = 412,
PSELECT6_TIME64 = 413,
PPOLL_TIME64 = 414,
IO_PGETEVENTS_TIME64 = 416,
RECVMMSG_TIME64 = 417,
MQ_TIMEDSEND_TIME64 = 418,
MQ_TIMEDRECEIVE_TIME64 = 419,
SEMTIMEDOP_TIME64 = 420,
RT_SIGTIMEDWAIT_TIME64 = 421,
FUTEX_TIME64 = 422,
SCHED_RR_GET_INTERVAL_TIME64 = 423,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
MEMFD_SECRET = 447,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
}
+833
View File
@@ -0,0 +1,833 @@
/* AUTO-GENERATED FILE. DO NOT EDIT. */
#include "frida-base.h"
static const FridaLinuxSyscallSignature frida_syscall_signatures[] =
{
{ 0, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 1, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 2, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 3, "close", 1, { { "unsigned int", "fd" } } },
{ 4, "stat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 5, "fstat", 2, { { "unsigned int", "fd" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 6, "lstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 7, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 8, "lseek", 3, { { "unsigned int", "fd" }, { "off_t", "offset" }, { "unsigned int", "whence" } } },
{ 9, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "off" } } },
{ 10, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 11, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 12, "brk", 1, { { "unsigned long", "brk" } } },
{ 13, "rt_sigaction", 4, { { "int", "sig" }, { "const struct sigaction *", "act" }, { "struct sigaction *", "oact" }, { "size_t", "sigsetsize" } } },
{ 14, "rt_sigprocmask", 4, { { "int", "how" }, { "sigset_t *", "nset" }, { "sigset_t *", "oset" }, { "size_t", "sigsetsize" } } },
{ 15, "rt_sigreturn", 0, {} },
{ 16, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 17, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 18, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 19, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 20, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 21, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 22, "pipe", 1, { { "int *", "fildes" } } },
{ 23, "select", 5, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_old_timeval *", "tvp" } } },
{ 24, "sched_yield", 0, {} },
{ 25, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 26, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 27, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 28, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 29, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 30, "shmat", 3, { { "int", "shmid" }, { "char *", "shmaddr" }, { "int", "shmflg" } } },
{ 31, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "struct shmid_ds *", "buf" } } },
{ 32, "dup", 1, { { "unsigned int", "fildes" } } },
{ 33, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 34, "pause", 0, {} },
{ 35, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 36, "getitimer", 2, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" } } },
{ 37, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 38, "setitimer", 3, { { "int", "which" }, { "struct __kernel_old_itimerval *", "value" }, { "struct __kernel_old_itimerval *", "ovalue" } } },
{ 39, "getpid", 0, {} },
{ 40, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "off_t *", "offset" }, { "size_t", "count" } } },
{ 41, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 42, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 43, "accept", 3, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" } } },
{ 44, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 45, "recvfrom", 6, { { "int", "fd" }, { "void *", "ubuf" }, { "size_t", "size" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addr_len" } } },
{ 46, "sendmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 47, "recvmsg", 3, { { "int", "fd" }, { "struct user_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 48, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 49, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 50, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 51, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 52, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 53, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 54, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 55, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 56, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 57, "fork", 0, {} },
{ 58, "vfork", 0, {} },
{ 59, "execve", 3, { { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" } } },
{ 60, "exit", 1, { { "int", "error_code" } } },
{ 61, "wait4", 4, { { "pid_t", "upid" }, { "int *", "stat_addr" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 62, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 63, "uname", 1, { { "struct old_utsname *", "name" } } },
{ 64, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 65, "semop", 3, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned", "nsops" } } },
{ 66, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "unsigned long", "arg" } } },
{ 67, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 68, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 69, "msgsnd", 4, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "int", "msgflg" } } },
{ 70, "msgrcv", 5, { { "int", "msqid" }, { "struct msgbuf *", "msgp" }, { "size_t", "msgsz" }, { "long", "msgtyp" }, { "int", "msgflg" } } },
{ 71, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "struct msqid_ds *", "buf" } } },
{ 72, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "unsigned long", "arg" } } },
{ 73, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 74, "fsync", 1, { { "unsigned int", "fd" } } },
{ 75, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 76, "truncate", 2, { { "const char *", "path" }, { "long", "length" } } },
{ 77, "ftruncate", 2, { { "unsigned int", "fd" }, { "off_t", "length" } } },
{ 78, "getdents", 3, { { "unsigned int", "fd" }, { "struct linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 79, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 80, "chdir", 1, { { "const char *", "filename" } } },
{ 81, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 82, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 83, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 84, "rmdir", 1, { { "const char *", "pathname" } } },
{ 85, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 86, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 87, "unlink", 1, { { "const char *", "pathname" } } },
{ 88, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 89, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 90, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 91, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 92, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 93, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 94, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 95, "umask", 1, { { "int", "mask" } } },
{ 96, "gettimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 97, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 98, "getrusage", 2, { { "int", "who" }, { "struct rusage *", "ru" } } },
{ 99, "sysinfo", 1, { { "struct sysinfo *", "info" } } },
{ 100, "times", 1, { { "struct tms *", "tbuf" } } },
{ 101, "ptrace", 4, { { "long", "request" }, { "long", "pid" }, { "unsigned long", "addr" }, { "unsigned long", "data" } } },
{ 102, "getuid", 0, {} },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "getgid", 0, {} },
{ 105, "setuid", 1, { { "uid_t", "uid" } } },
{ 106, "setgid", 1, { { "gid_t", "gid" } } },
{ 107, "geteuid", 0, {} },
{ 108, "getegid", 0, {} },
{ 109, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 110, "getppid", 0, {} },
{ 111, "getpgrp", 0, {} },
{ 112, "setsid", 0, {} },
{ 113, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 114, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 115, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 116, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 117, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 118, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 119, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 120, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 121, "getpgid", 1, { { "pid_t", "pid" } } },
{ 122, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 123, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 124, "getsid", 1, { { "pid_t", "pid" } } },
{ 125, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 126, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 127, "rt_sigpending", 2, { { "sigset_t *", "uset" }, { "size_t", "sigsetsize" } } },
{ 128, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 129, "rt_sigqueueinfo", 3, { { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 130, "rt_sigsuspend", 2, { { "sigset_t *", "unewset" }, { "size_t", "sigsetsize" } } },
{ 131, "sigaltstack", 2, { { "const stack_t *", "uss" }, { "stack_t *", "uoss" } } },
{ 132, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 133, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 135, "personality", 1, { { "unsigned int", "personality" } } },
{ 136, "ustat", 2, { { "unsigned", "dev" }, { "struct ustat *", "ubuf" } } },
{ 137, "statfs", 2, { { "const char *", "pathname" }, { "struct statfs *", "buf" } } },
{ 138, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct statfs *", "buf" } } },
{ 139, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 140, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 141, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 142, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 143, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 144, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 145, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 146, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 147, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 148, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 149, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 150, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "mlockall", 1, { { "int", "flags" } } },
{ 152, "munlockall", 0, {} },
{ 153, "vhangup", 0, {} },
{ 154, "modify_ldt", 3, { { "int", "func" }, { "void *", "ptr" }, { "unsigned long", "bytecount" } } },
{ 155, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 156, "_sysctl", 0, {} },
{ 157, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 158, "arch_prctl", 2, { { "int", "option" }, { "unsigned long", "arg2" } } },
{ 159, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 160, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct rlimit *", "rlim" } } },
{ 161, "chroot", 1, { { "const char *", "filename" } } },
{ 162, "sync", 0, {} },
{ 163, "acct", 1, { { "const char *", "name" } } },
{ 164, "settimeofday", 2, { { "struct __kernel_old_timeval *", "tv" }, { "struct timezone *", "tz" } } },
{ 165, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 166, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 167, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 168, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 169, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 170, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 171, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 172, "iopl", 1, { { "unsigned int", "level" } } },
{ 173, "ioperm", 3, { { "unsigned long", "from" }, { "unsigned long", "num" }, { "int", "turn_on" } } },
{ 175, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 176, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 179, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 186, "gettid", 0, {} },
{ 187, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 188, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 189, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 190, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 191, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 192, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 193, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 194, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 195, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 196, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 197, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 198, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 199, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 200, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 201, "time", 1, { { "__kernel_old_time_t *", "tloc" } } },
{ 202, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 203, "sched_setaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 204, "sched_getaffinity", 3, { { "pid_t", "pid" }, { "unsigned int", "len" }, { "unsigned long *", "user_mask_ptr" } } },
{ 205, "set_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 206, "io_setup", 2, { { "unsigned", "nr_events" }, { "aio_context_t *", "ctxp" } } },
{ 207, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 208, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 209, "io_submit", 3, { { "aio_context_t", "ctx_id" }, { "long", "nr" }, { "struct iocb * *", "iocbpp" } } },
{ 210, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 211, "get_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 213, "epoll_create", 1, { { "int", "size" } } },
{ 216, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 217, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 218, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 219, "restart_syscall", 0, {} },
{ 220, "semtimedop", 4, { { "int", "semid" }, { "struct sembuf *", "tsops" }, { "unsigned int", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 221, "fadvise64", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "len" }, { "int", "advice" } } },
{ 222, "timer_create", 3, { { "const clockid_t", "which_clock" }, { "struct sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 223, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 224, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 225, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 226, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 227, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 228, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 229, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 230, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 231, "exit_group", 1, { { "int", "error_code" } } },
{ 232, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 233, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 234, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 235, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 237, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 238, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 239, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 240, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "umode_t", "mode" }, { "struct mq_attr *", "u_attr" } } },
{ 241, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 242, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 243, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 244, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct sigevent *", "u_notification" } } },
{ 245, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct mq_attr *", "u_mqstat" }, { "struct mq_attr *", "u_omqstat" } } },
{ 246, "kexec_load", 4, { { "unsigned long", "entry" }, { "unsigned long", "nr_segments" }, { "struct kexec_segment *", "segments" }, { "unsigned long", "flags" } } },
{ 247, "waitid", 5, { { "int", "which" }, { "pid_t", "upid" }, { "struct siginfo *", "infop" }, { "int", "options" }, { "struct rusage *", "ru" } } },
{ 248, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 249, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 250, "keyctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 251, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 252, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 253, "inotify_init", 0, {} },
{ 254, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 255, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 256, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 257, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 258, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 259, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 260, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 261, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 262, "newfstatat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct stat *", "statbuf" }, { "int", "flag" } } },
{ 263, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 264, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 265, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 266, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 267, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 268, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 269, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 270, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 271, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 272, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 273, "set_robust_list", 2, { { "struct robust_list_head *", "head" }, { "size_t", "len" } } },
{ 274, "get_robust_list", 3, { { "int", "pid" }, { "struct robust_list_head * *", "head_ptr" }, { "size_t *", "len_ptr" } } },
{ 275, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 276, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 277, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 278, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 279, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 280, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 281, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 282, "signalfd", 3, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" } } },
{ 283, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 284, "eventfd", 1, { { "unsigned int", "count" } } },
{ 285, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 286, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 287, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 288, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 289, "signalfd4", 4, { { "int", "ufd" }, { "sigset_t *", "user_mask" }, { "size_t", "sizemask" }, { "int", "flags" } } },
{ 290, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 291, "epoll_create1", 1, { { "int", "flags" } } },
{ 292, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 293, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 294, "inotify_init1", 1, { { "int", "flags" } } },
{ 295, "preadv", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 296, "pwritev", 5, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" } } },
{ 297, "rt_tgsigqueueinfo", 4, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" }, { "siginfo_t *", "uinfo" } } },
{ 298, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 299, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 300, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 301, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 302, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 303, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 304, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 305, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 306, "syncfs", 1, { { "int", "fd" } } },
{ 307, "sendmmsg", 4, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 308, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 309, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 310, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 311, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 312, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 313, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 314, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 315, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 316, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 317, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 318, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 319, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 320, "kexec_file_load", 5, { { "int", "kernel_fd" }, { "int", "initrd_fd" }, { "unsigned long", "cmdline_len" }, { "const char *", "cmdline_ptr" }, { "unsigned long", "flags" } } },
{ 321, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 322, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const char *const *", "argv" }, { "const char *const *", "envp" }, { "int", "flags" } } },
{ 323, "userfaultfd", 1, { { "int", "flags" } } },
{ 324, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 325, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 326, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 327, "preadv2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 328, "pwritev2", 6, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" }, { "unsigned long", "pos_l" }, { "unsigned long", "pos_h" }, { "rwf_t", "flags" } } },
{ 329, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 330, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 331, "pkey_free", 1, { { "int", "pkey" } } },
{ 332, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 333, "io_pgetevents", 6, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __aio_sigset *", "usig" } } },
{ 334, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 335, "uretprobe", 0, {} },
{ 336, "uprobe", 0, {} },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 447, "memfd_secret", 1, { { "unsigned int", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
static const FridaLinuxSyscallSignature frida_compat32_syscall_signatures[] =
{
{ 0, "restart_syscall", 0, {} },
{ 1, "exit", 1, { { "int", "error_code" } } },
{ 2, "fork", 0, {} },
{ 3, "read", 3, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" } } },
{ 4, "write", 3, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" } } },
{ 5, "open", 3, { { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 6, "close", 1, { { "unsigned int", "fd" } } },
{ 7, "waitpid", 3, { { "pid_t", "pid" }, { "int *", "stat_addr" }, { "int", "options" } } },
{ 8, "creat", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 9, "link", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 10, "unlink", 1, { { "const char *", "pathname" } } },
{ 11, "execve", 3, { { "const char *", "filename" }, { "const compat_uptr_t *", "argv" }, { "const compat_uptr_t *", "envp" } } },
{ 12, "chdir", 1, { { "const char *", "filename" } } },
{ 13, "time", 1, { { "__kernel_old_time_t *", "tloc" } } },
{ 14, "mknod", 3, { { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned", "dev" } } },
{ 15, "chmod", 2, { { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 16, "lchown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 18, "oldstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 19, "lseek", 3, { { "unsigned int", "fd" }, { "compat_off_t", "offset" }, { "unsigned int", "whence" } } },
{ 20, "getpid", 0, {} },
{ 21, "mount", 5, { { "char *", "dev_name" }, { "char *", "dir_name" }, { "char *", "type" }, { "unsigned long", "flags" }, { "void *", "data" } } },
{ 22, "umount", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 23, "setuid", 1, { { "uid_t", "uid" } } },
{ 24, "getuid", 0, {} },
{ 25, "stime", 1, { { "__kernel_old_time_t *", "tptr" } } },
{ 26, "ptrace", 4, { { "compat_long_t", "request" }, { "compat_long_t", "pid" }, { "compat_long_t", "addr" }, { "compat_long_t", "data" } } },
{ 27, "alarm", 1, { { "unsigned int", "seconds" } } },
{ 28, "oldfstat", 2, { { "unsigned int", "fd" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 29, "pause", 0, {} },
{ 30, "utime", 2, { { "char *", "filename" }, { "struct utimbuf *", "times" } } },
{ 33, "access", 2, { { "const char *", "filename" }, { "int", "mode" } } },
{ 34, "nice", 1, { { "int", "increment" } } },
{ 36, "sync", 0, {} },
{ 37, "kill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 38, "rename", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 39, "mkdir", 2, { { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 40, "rmdir", 1, { { "const char *", "pathname" } } },
{ 41, "dup", 1, { { "unsigned int", "fildes" } } },
{ 42, "pipe", 1, { { "int *", "fildes" } } },
{ 43, "times", 1, { { "struct compat_tms *", "tbuf" } } },
{ 45, "brk", 1, { { "unsigned long", "brk" } } },
{ 46, "setgid", 1, { { "gid_t", "gid" } } },
{ 47, "getgid", 0, {} },
{ 48, "signal", 2, { { "int", "sig" }, { "__sighandler_t", "handler" } } },
{ 49, "geteuid", 0, {} },
{ 50, "getegid", 0, {} },
{ 51, "acct", 1, { { "const char *", "name" } } },
{ 52, "umount2", 2, { { "char *", "name" }, { "int", "flags" } } },
{ 54, "ioctl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 55, "fcntl", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 57, "setpgid", 2, { { "pid_t", "pid" }, { "pid_t", "pgid" } } },
{ 59, "oldolduname", 1, { { "struct oldold_utsname *", "arg0" } } },
{ 60, "umask", 1, { { "int", "mask" } } },
{ 61, "chroot", 1, { { "const char *", "filename" } } },
{ 62, "ustat", 2, { { "unsigned", "dev" }, { "struct compat_ustat *", "u" } } },
{ 63, "dup2", 2, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" } } },
{ 64, "getppid", 0, {} },
{ 65, "getpgrp", 0, {} },
{ 66, "setsid", 0, {} },
{ 67, "sigaction", 3, { { "int", "sig" }, { "const struct compat_old_sigaction *", "act" }, { "struct compat_old_sigaction *", "oact" } } },
{ 68, "sgetmask", 0, {} },
{ 69, "ssetmask", 1, { { "int", "newmask" } } },
{ 70, "setreuid", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 71, "setregid", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 72, "sigsuspend", 3, { { "int", "unused1" }, { "int", "unused2" }, { "old_sigset_t", "mask" } } },
{ 73, "sigpending", 1, { { "compat_old_sigset_t *", "set32" } } },
{ 74, "sethostname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 75, "setrlimit", 2, { { "unsigned int", "resource" }, { "struct compat_rlimit *", "rlim" } } },
{ 76, "getrlimit", 2, { { "unsigned int", "resource" }, { "struct compat_rlimit *", "rlim" } } },
{ 77, "getrusage", 2, { { "int", "who" }, { "struct compat_rusage *", "ru" } } },
{ 78, "gettimeofday", 2, { { "struct old_timeval32 *", "tv" }, { "struct timezone *", "tz" } } },
{ 79, "settimeofday", 2, { { "struct old_timeval32 *", "tv" }, { "struct timezone *", "tz" } } },
{ 80, "getgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 81, "setgroups", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 82, "select", 5, { { "int", "n" }, { "compat_ulong_t *", "inp" }, { "compat_ulong_t *", "outp" }, { "compat_ulong_t *", "exp" }, { "struct old_timeval32 *", "tvp" } } },
{ 83, "symlink", 2, { { "const char *", "oldname" }, { "const char *", "newname" } } },
{ 84, "oldlstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 85, "readlink", 3, { { "const char *", "path" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 86, "uselib", 1, { { "const char *", "library" } } },
{ 87, "swapon", 2, { { "const char *", "specialfile" }, { "int", "swap_flags" } } },
{ 88, "reboot", 4, { { "int", "magic1" }, { "int", "magic2" }, { "unsigned int", "cmd" }, { "void *", "arg" } } },
{ 89, "readdir", 3, { { "unsigned int", "fd" }, { "struct compat_old_linux_dirent *", "arg1" }, { "unsigned int", "count" } } },
{ 90, "mmap", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "off" } } },
{ 91, "munmap", 2, { { "unsigned long", "addr" }, { "size_t", "len" } } },
{ 92, "truncate", 2, { { "const char *", "path" }, { "compat_off_t", "length" } } },
{ 93, "ftruncate", 2, { { "unsigned int", "fd" }, { "compat_off_t", "length" } } },
{ 94, "fchmod", 2, { { "unsigned int", "fd" }, { "umode_t", "mode" } } },
{ 95, "fchown", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 96, "getpriority", 2, { { "int", "which" }, { "int", "who" } } },
{ 97, "setpriority", 3, { { "int", "which" }, { "int", "who" }, { "int", "niceval" } } },
{ 99, "statfs", 2, { { "const char *", "pathname" }, { "struct compat_statfs *", "buf" } } },
{ 100, "fstatfs", 2, { { "unsigned int", "fd" }, { "struct compat_statfs *", "buf" } } },
{ 101, "ioperm", 3, { { "unsigned long", "from" }, { "unsigned long", "num" }, { "int", "turn_on" } } },
{ 102, "socketcall", 2, { { "int", "call" }, { "u32 *", "args" } } },
{ 103, "syslog", 3, { { "int", "type" }, { "char *", "buf" }, { "int", "len" } } },
{ 104, "setitimer", 3, { { "int", "which" }, { "struct old_itimerval32 *", "value" }, { "struct old_itimerval32 *", "ovalue" } } },
{ 105, "getitimer", 2, { { "int", "which" }, { "struct old_itimerval32 *", "value" } } },
{ 106, "stat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 107, "lstat", 2, { { "const char *", "filename" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 108, "fstat", 2, { { "unsigned int", "fd" }, { "struct __old_kernel_stat *", "statbuf" } } },
{ 109, "olduname", 1, { { "struct oldold_utsname *", "name" } } },
{ 110, "iopl", 1, { { "unsigned int", "level" } } },
{ 111, "vhangup", 0, {} },
{ 113, "vm86old", 1, { { "struct vm86_struct *", "user_vm86" } } },
{ 114, "wait4", 4, { { "compat_pid_t", "pid" }, { "compat_uint_t *", "stat_addr" }, { "int", "options" }, { "struct compat_rusage *", "ru" } } },
{ 115, "swapoff", 1, { { "const char *", "specialfile" } } },
{ 116, "sysinfo", 1, { { "struct compat_sysinfo *", "info" } } },
{ 117, "ipc", 6, { { "u32", "arg0" }, { "int", "arg1" }, { "int", "arg2" }, { "u32", "arg3" }, { "compat_uptr_t", "arg4" }, { "u32", "arg5" } } },
{ 118, "fsync", 1, { { "unsigned int", "fd" } } },
{ 120, "clone", 5, { { "unsigned long", "clone_flags" }, { "unsigned long", "newsp" }, { "int *", "parent_tidptr" }, { "int *", "child_tidptr" }, { "unsigned long", "tls" } } },
{ 121, "setdomainname", 2, { { "char *", "name" }, { "int", "len" } } },
{ 122, "uname", 1, { { "struct old_utsname *", "name" } } },
{ 123, "modify_ldt", 3, { { "int", "func" }, { "void *", "ptr" }, { "unsigned long", "bytecount" } } },
{ 124, "adjtimex", 1, { { "struct __kernel_timex *", "txc_p" } } },
{ 125, "mprotect", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" } } },
{ 126, "sigprocmask", 3, { { "int", "how" }, { "compat_old_sigset_t *", "nset" }, { "compat_old_sigset_t *", "oset" } } },
{ 128, "init_module", 3, { { "void *", "umod" }, { "unsigned long", "len" }, { "const char *", "uargs" } } },
{ 129, "delete_module", 2, { { "const char *", "name_user" }, { "unsigned int", "flags" } } },
{ 131, "quotactl", 4, { { "unsigned int", "cmd" }, { "const char *", "special" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 132, "getpgid", 1, { { "pid_t", "pid" } } },
{ 133, "fchdir", 1, { { "unsigned int", "fd" } } },
{ 134, "bdflush", 0, {} },
{ 135, "sysfs", 3, { { "int", "option" }, { "unsigned long", "arg1" }, { "unsigned long", "arg2" } } },
{ 136, "personality", 1, { { "unsigned int", "personality" } } },
{ 138, "setfsuid", 1, { { "uid_t", "uid" } } },
{ 139, "setfsgid", 1, { { "gid_t", "gid" } } },
{ 140, "_llseek", 5, { { "unsigned int", "fd" }, { "unsigned long", "offset_high" }, { "unsigned long", "offset_low" }, { "loff_t *", "result" }, { "unsigned int", "whence" } } },
{ 141, "getdents", 3, { { "unsigned int", "fd" }, { "struct compat_linux_dirent *", "dirent" }, { "unsigned int", "count" } } },
{ 142, "_newselect", 5, { { "int", "n" }, { "compat_ulong_t *", "inp" }, { "compat_ulong_t *", "outp" }, { "compat_ulong_t *", "exp" }, { "struct old_timeval32 *", "tvp" } } },
{ 143, "flock", 2, { { "unsigned int", "fd" }, { "unsigned int", "cmd" } } },
{ 144, "msync", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 145, "readv", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 146, "writev", 3, { { "unsigned long", "fd" }, { "const struct iovec *", "vec" }, { "unsigned long", "vlen" } } },
{ 147, "getsid", 1, { { "pid_t", "pid" } } },
{ 148, "fdatasync", 1, { { "unsigned int", "fd" } } },
{ 149, "_sysctl", 0, {} },
{ 150, "mlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 151, "munlock", 2, { { "unsigned long", "start" }, { "size_t", "len" } } },
{ 152, "mlockall", 1, { { "int", "flags" } } },
{ 153, "munlockall", 0, {} },
{ 154, "sched_setparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 155, "sched_getparam", 2, { { "pid_t", "pid" }, { "struct sched_param *", "param" } } },
{ 156, "sched_setscheduler", 3, { { "pid_t", "pid" }, { "int", "policy" }, { "struct sched_param *", "param" } } },
{ 157, "sched_getscheduler", 1, { { "pid_t", "pid" } } },
{ 158, "sched_yield", 0, {} },
{ 159, "sched_get_priority_max", 1, { { "int", "policy" } } },
{ 160, "sched_get_priority_min", 1, { { "int", "policy" } } },
{ 161, "sched_rr_get_interval", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 162, "nanosleep", 2, { { "struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 163, "mremap", 5, { { "unsigned long", "addr" }, { "unsigned long", "old_len" }, { "unsigned long", "new_len" }, { "unsigned long", "flags" }, { "unsigned long", "new_addr" } } },
{ 164, "setresuid", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 165, "getresuid", 3, { { "uid_t *", "ruidp" }, { "uid_t *", "euidp" }, { "uid_t *", "suidp" } } },
{ 166, "vm86", 2, { { "unsigned long", "cmd" }, { "unsigned long", "arg" } } },
{ 168, "poll", 3, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "int", "timeout_msecs" } } },
{ 170, "setresgid", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 171, "getresgid", 3, { { "gid_t *", "rgidp" }, { "gid_t *", "egidp" }, { "gid_t *", "sgidp" } } },
{ 172, "prctl", 5, { { "int", "option" }, { "unsigned long", "arg2" }, { "unsigned long", "arg3" }, { "unsigned long", "arg4" }, { "unsigned long", "arg5" } } },
{ 173, "rt_sigreturn", 0, {} },
{ 174, "rt_sigaction", 4, { { "int", "sig" }, { "const struct compat_sigaction *", "act" }, { "struct compat_sigaction *", "oact" }, { "compat_size_t", "sigsetsize" } } },
{ 175, "rt_sigprocmask", 4, { { "int", "how" }, { "compat_sigset_t *", "nset" }, { "compat_sigset_t *", "oset" }, { "compat_size_t", "sigsetsize" } } },
{ 176, "rt_sigpending", 2, { { "compat_sigset_t *", "uset" }, { "compat_size_t", "sigsetsize" } } },
{ 177, "rt_sigtimedwait", 4, { { "const sigset_t *", "uthese" }, { "siginfo_t *", "uinfo" }, { "const struct __kernel_timespec *", "uts" }, { "size_t", "sigsetsize" } } },
{ 178, "rt_sigqueueinfo", 3, { { "compat_pid_t", "pid" }, { "int", "sig" }, { "struct compat_siginfo *", "uinfo" } } },
{ 179, "rt_sigsuspend", 2, { { "compat_sigset_t *", "unewset" }, { "compat_size_t", "sigsetsize" } } },
{ 180, "pread64", 4, { { "unsigned int", "fd" }, { "char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 181, "pwrite64", 4, { { "unsigned int", "fd" }, { "const char *", "buf" }, { "size_t", "count" }, { "loff_t", "pos" } } },
{ 182, "chown", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 183, "getcwd", 2, { { "char *", "buf" }, { "unsigned long", "size" } } },
{ 184, "capget", 2, { { "cap_user_header_t", "header" }, { "cap_user_data_t", "dataptr" } } },
{ 185, "capset", 2, { { "cap_user_header_t", "header" }, { "const cap_user_data_t", "data" } } },
{ 186, "sigaltstack", 2, { { "const compat_stack_t *", "uss_ptr" }, { "compat_stack_t *", "uoss_ptr" } } },
{ 187, "sendfile", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "compat_off_t *", "offset" }, { "compat_size_t", "count" } } },
{ 190, "vfork", 0, {} },
{ 191, "ugetrlimit", 2, { { "unsigned int", "resource" }, { "struct compat_rlimit *", "rlim" } } },
{ 192, "mmap2", 6, { { "unsigned long", "addr" }, { "unsigned long", "len" }, { "unsigned long", "prot" }, { "unsigned long", "flags" }, { "unsigned long", "fd" }, { "unsigned long", "pgoff" } } },
{ 193, "truncate64", 3, { { "const char *", "filename" }, { "unsigned long", "offset_low" }, { "unsigned long", "offset_high" } } },
{ 194, "ftruncate64", 3, { { "unsigned int", "fd" }, { "unsigned long", "offset_low" }, { "unsigned long", "offset_high" } } },
{ 198, "lchown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 199, "getuid32", 0, {} },
{ 200, "getgid32", 0, {} },
{ 201, "geteuid32", 0, {} },
{ 202, "getegid32", 0, {} },
{ 203, "setreuid32", 2, { { "uid_t", "ruid" }, { "uid_t", "euid" } } },
{ 204, "setregid32", 2, { { "gid_t", "rgid" }, { "gid_t", "egid" } } },
{ 205, "getgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 206, "setgroups32", 2, { { "int", "gidsetsize" }, { "gid_t *", "grouplist" } } },
{ 207, "fchown32", 3, { { "unsigned int", "fd" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 208, "setresuid32", 3, { { "uid_t", "ruid" }, { "uid_t", "euid" }, { "uid_t", "suid" } } },
{ 209, "getresuid32", 3, { { "uid_t *", "ruid" }, { "uid_t *", "euid" }, { "uid_t *", "suid" } } },
{ 210, "setresgid32", 3, { { "gid_t", "rgid" }, { "gid_t", "egid" }, { "gid_t", "sgid" } } },
{ 211, "getresgid32", 3, { { "gid_t *", "rgid" }, { "gid_t *", "egid" }, { "gid_t *", "sgid" } } },
{ 212, "chown32", 3, { { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" } } },
{ 213, "setuid32", 1, { { "uid_t", "uid" } } },
{ 214, "setgid32", 1, { { "gid_t", "gid" } } },
{ 215, "setfsuid32", 1, { { "uid_t", "uid" } } },
{ 216, "setfsgid32", 1, { { "gid_t", "gid" } } },
{ 217, "pivot_root", 2, { { "const char *", "new_root" }, { "const char *", "put_old" } } },
{ 218, "mincore", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned char *", "vec" } } },
{ 219, "madvise", 3, { { "unsigned long", "start" }, { "size_t", "len_in" }, { "int", "behavior" } } },
{ 220, "getdents64", 3, { { "unsigned int", "fd" }, { "struct linux_dirent64 *", "dirent" }, { "unsigned int", "count" } } },
{ 221, "fcntl64", 3, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "compat_ulong_t", "arg" } } },
{ 224, "gettid", 0, {} },
{ 225, "readahead", 3, { { "int", "fd" }, { "loff_t", "offset" }, { "size_t", "count" } } },
{ 226, "setxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 227, "lsetxattr", 5, { { "const char *", "pathname" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 228, "fsetxattr", 5, { { "int", "fd" }, { "const char *", "name" }, { "const void *", "value" }, { "size_t", "size" }, { "int", "flags" } } },
{ 229, "getxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 230, "lgetxattr", 4, { { "const char *", "pathname" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 231, "fgetxattr", 4, { { "int", "fd" }, { "const char *", "name" }, { "void *", "value" }, { "size_t", "size" } } },
{ 232, "listxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 233, "llistxattr", 3, { { "const char *", "pathname" }, { "char *", "list" }, { "size_t", "size" } } },
{ 234, "flistxattr", 3, { { "int", "fd" }, { "char *", "list" }, { "size_t", "size" } } },
{ 235, "removexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 236, "lremovexattr", 2, { { "const char *", "pathname" }, { "const char *", "name" } } },
{ 237, "fremovexattr", 2, { { "int", "fd" }, { "const char *", "name" } } },
{ 238, "tkill", 2, { { "pid_t", "pid" }, { "int", "sig" } } },
{ 239, "sendfile64", 4, { { "int", "out_fd" }, { "int", "in_fd" }, { "compat_loff_t *", "offset" }, { "compat_size_t", "count" } } },
{ 240, "futex", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 241, "sched_setaffinity", 3, { { "compat_pid_t", "pid" }, { "unsigned int", "len" }, { "compat_ulong_t *", "user_mask_ptr" } } },
{ 242, "sched_getaffinity", 3, { { "compat_pid_t", "pid" }, { "unsigned int", "len" }, { "compat_ulong_t *", "user_mask_ptr" } } },
{ 243, "set_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 244, "get_thread_area", 1, { { "struct user_desc *", "user_desc" } } },
{ 245, "io_setup", 2, { { "unsigned", "nr_events" }, { "u32 *", "ctx32p" } } },
{ 246, "io_destroy", 1, { { "aio_context_t", "ctx" } } },
{ 247, "io_getevents", 5, { { "aio_context_t", "ctx_id" }, { "long", "min_nr" }, { "long", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" } } },
{ 248, "io_submit", 3, { { "compat_aio_context_t", "ctx_id" }, { "int", "nr" }, { "compat_uptr_t *", "iocbpp" } } },
{ 249, "io_cancel", 3, { { "aio_context_t", "ctx_id" }, { "struct iocb *", "iocb" }, { "struct io_event *", "result" } } },
{ 250, "fadvise64", 5, { { "int", "fd" }, { "unsigned int", "offset_lo" }, { "unsigned int", "offset_hi" }, { "size_t", "len" }, { "int", "advice" } } },
{ 252, "exit_group", 1, { { "int", "error_code" } } },
{ 254, "epoll_create", 1, { { "int", "size" } } },
{ 255, "epoll_ctl", 4, { { "int", "epfd" }, { "int", "op" }, { "int", "fd" }, { "struct epoll_event *", "event" } } },
{ 256, "epoll_wait", 4, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" } } },
{ 257, "remap_file_pages", 5, { { "unsigned long", "start" }, { "unsigned long", "size" }, { "unsigned long", "prot" }, { "unsigned long", "pgoff" }, { "unsigned long", "flags" } } },
{ 258, "set_tid_address", 1, { { "int *", "tidptr" } } },
{ 259, "timer_create", 3, { { "clockid_t", "which_clock" }, { "struct compat_sigevent *", "timer_event_spec" }, { "timer_t *", "created_timer_id" } } },
{ 260, "timer_settime", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 261, "timer_gettime", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 262, "timer_getoverrun", 1, { { "timer_t", "timer_id" } } },
{ 263, "timer_delete", 1, { { "timer_t", "timer_id" } } },
{ 264, "clock_settime", 2, { { "const clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 265, "clock_gettime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 266, "clock_getres", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 267, "clock_nanosleep", 4, { { "const clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 268, "statfs64", 3, { { "const char *", "pathname" }, { "compat_size_t", "sz" }, { "struct compat_statfs64 *", "buf" } } },
{ 269, "fstatfs64", 3, { { "unsigned int", "fd" }, { "compat_size_t", "sz" }, { "struct compat_statfs64 *", "buf" } } },
{ 270, "tgkill", 3, { { "pid_t", "tgid" }, { "pid_t", "pid" }, { "int", "sig" } } },
{ 271, "utimes", 2, { { "char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 272, "fadvise64_64", 6, { { "int", "fd" }, { "__u32", "offset_low" }, { "__u32", "offset_high" }, { "__u32", "len_low" }, { "__u32", "len_high" }, { "int", "advice" } } },
{ 274, "mbind", 6, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned int", "flags" } } },
{ 275, "get_mempolicy", 5, { { "int *", "policy" }, { "unsigned long *", "nmask" }, { "unsigned long", "maxnode" }, { "unsigned long", "addr" }, { "unsigned long", "flags" } } },
{ 276, "set_mempolicy", 3, { { "int", "mode" }, { "const unsigned long *", "nmask" }, { "unsigned long", "maxnode" } } },
{ 277, "mq_open", 4, { { "const char *", "u_name" }, { "int", "oflag" }, { "compat_mode_t", "mode" }, { "struct compat_mq_attr *", "u_attr" } } },
{ 278, "mq_unlink", 1, { { "const char *", "u_name" } } },
{ 279, "mq_timedsend", 5, { { "mqd_t", "mqdes" }, { "const char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 280, "mq_timedreceive", 5, { { "mqd_t", "mqdes" }, { "char *", "u_msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "u_msg_prio" }, { "const struct __kernel_timespec *", "u_abs_timeout" } } },
{ 281, "mq_notify", 2, { { "mqd_t", "mqdes" }, { "const struct compat_sigevent *", "u_notification" } } },
{ 282, "mq_getsetattr", 3, { { "mqd_t", "mqdes" }, { "const struct compat_mq_attr *", "u_mqstat" }, { "struct compat_mq_attr *", "u_omqstat" } } },
{ 283, "kexec_load", 4, { { "compat_ulong_t", "entry" }, { "compat_ulong_t", "nr_segments" }, { "struct compat_kexec_segment *", "segments" }, { "compat_ulong_t", "flags" } } },
{ 284, "waitid", 5, { { "int", "which" }, { "compat_pid_t", "pid" }, { "struct compat_siginfo *", "infop" }, { "int", "options" }, { "struct compat_rusage *", "uru" } } },
{ 286, "add_key", 5, { { "const char *", "_type" }, { "const char *", "_description" }, { "const void *", "_payload" }, { "size_t", "plen" }, { "key_serial_t", "ringid" } } },
{ 287, "request_key", 4, { { "const char *", "_type" }, { "const char *", "_description" }, { "const char *", "_callout_info" }, { "key_serial_t", "destringid" } } },
{ 288, "keyctl", 5, { { "u32", "option" }, { "u32", "arg2" }, { "u32", "arg3" }, { "u32", "arg4" }, { "u32", "arg5" } } },
{ 289, "ioprio_set", 3, { { "int", "which" }, { "int", "who" }, { "int", "ioprio" } } },
{ 290, "ioprio_get", 2, { { "int", "which" }, { "int", "who" } } },
{ 291, "inotify_init", 0, {} },
{ 292, "inotify_add_watch", 3, { { "int", "fd" }, { "const char *", "pathname" }, { "u32", "mask" } } },
{ 293, "inotify_rm_watch", 2, { { "int", "fd" }, { "__s32", "wd" } } },
{ 294, "migrate_pages", 4, { { "pid_t", "pid" }, { "unsigned long", "maxnode" }, { "const unsigned long *", "old_nodes" }, { "const unsigned long *", "new_nodes" } } },
{ 295, "openat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "flags" }, { "umode_t", "mode" } } },
{ 296, "mkdirat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "umode_t", "mode" } } },
{ 297, "mknodat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "dev" } } },
{ 298, "fchownat", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "uid_t", "user" }, { "gid_t", "group" }, { "int", "flag" } } },
{ 299, "futimesat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_old_timeval *", "utimes" } } },
{ 301, "unlinkat", 3, { { "int", "dfd" }, { "const char *", "pathname" }, { "int", "flag" } } },
{ 302, "renameat", 4, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 303, "linkat", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "int", "flags" } } },
{ 304, "symlinkat", 3, { { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" } } },
{ 305, "readlinkat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "char *", "buf" }, { "int", "bufsiz" } } },
{ 306, "fchmodat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" } } },
{ 307, "faccessat", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" } } },
{ 308, "pselect6", 6, { { "int", "n" }, { "fd_set *", "inp" }, { "fd_set *", "outp" }, { "fd_set *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 309, "ppoll", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const sigset_t *", "sigmask" }, { "size_t", "sigsetsize" } } },
{ 310, "unshare", 1, { { "unsigned long", "unshare_flags" } } },
{ 311, "set_robust_list", 2, { { "struct compat_robust_list_head *", "head" }, { "compat_size_t", "len" } } },
{ 312, "get_robust_list", 3, { { "int", "pid" }, { "compat_uptr_t *", "head_ptr" }, { "compat_size_t *", "len_ptr" } } },
{ 313, "splice", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 314, "sync_file_range", 4, { { "int", "fd" }, { "loff_t", "offset" }, { "loff_t", "nbytes" }, { "unsigned int", "flags" } } },
{ 315, "tee", 4, { { "int", "fdin" }, { "int", "fdout" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 316, "vmsplice", 4, { { "int", "fd" }, { "const struct iovec *", "uiov" }, { "unsigned long", "nr_segs" }, { "unsigned int", "flags" } } },
{ 317, "move_pages", 6, { { "pid_t", "pid" }, { "unsigned long", "nr_pages" }, { "const void * *", "pages" }, { "const int *", "nodes" }, { "int *", "status" }, { "int", "flags" } } },
{ 318, "getcpu", 3, { { "unsigned *", "cpup" }, { "unsigned *", "nodep" }, { "struct getcpu_cache *", "unused" } } },
{ 319, "epoll_pwait", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "int", "timeout" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 320, "utimensat", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 321, "signalfd", 3, { { "int", "ufd" }, { "const compat_sigset_t *", "user_mask" }, { "compat_size_t", "sigsetsize" } } },
{ 322, "timerfd_create", 2, { { "int", "clockid" }, { "int", "flags" } } },
{ 323, "eventfd", 1, { { "unsigned int", "count" } } },
{ 324, "fallocate", 4, { { "int", "fd" }, { "int", "mode" }, { "loff_t", "offset" }, { "loff_t", "len" } } },
{ 325, "timerfd_settime", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 326, "timerfd_gettime", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 327, "signalfd4", 4, { { "int", "ufd" }, { "const compat_sigset_t *", "user_mask" }, { "compat_size_t", "sigsetsize" }, { "int", "flags" } } },
{ 328, "eventfd2", 2, { { "unsigned int", "count" }, { "int", "flags" } } },
{ 329, "epoll_create1", 1, { { "int", "flags" } } },
{ 330, "dup3", 3, { { "unsigned int", "oldfd" }, { "unsigned int", "newfd" }, { "int", "flags" } } },
{ 331, "pipe2", 2, { { "int *", "fildes" }, { "int", "flags" } } },
{ 332, "inotify_init1", 1, { { "int", "flags" } } },
{ 333, "preadv", 5, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" } } },
{ 334, "pwritev", 5, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" } } },
{ 335, "rt_tgsigqueueinfo", 4, { { "compat_pid_t", "tgid" }, { "compat_pid_t", "pid" }, { "int", "sig" }, { "struct compat_siginfo *", "uinfo" } } },
{ 336, "perf_event_open", 5, { { "struct perf_event_attr *", "attr_uptr" }, { "pid_t", "pid" }, { "int", "cpu" }, { "int", "group_fd" }, { "unsigned long", "flags" } } },
{ 337, "recvmmsg", 5, { { "int", "fd" }, { "struct mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 338, "fanotify_init", 2, { { "unsigned int", "flags" }, { "unsigned int", "event_f_flags" } } },
{ 339, "fanotify_mark", 5, { { "int", "fanotify_fd" }, { "unsigned int", "flags" }, { "__u64", "mask" }, { "int", "dfd" }, { "const char *", "pathname" } } },
{ 340, "prlimit64", 4, { { "pid_t", "pid" }, { "unsigned int", "resource" }, { "const struct rlimit64 *", "new_rlim" }, { "struct rlimit64 *", "old_rlim" } } },
{ 341, "name_to_handle_at", 5, { { "int", "dfd" }, { "const char *", "name" }, { "struct file_handle *", "handle" }, { "void *", "mnt_id" }, { "int", "flag" } } },
{ 342, "open_by_handle_at", 3, { { "int", "mountdirfd" }, { "struct file_handle *", "handle" }, { "int", "flags" } } },
{ 343, "clock_adjtime", 2, { { "const clockid_t", "which_clock" }, { "struct __kernel_timex *", "utx" } } },
{ 344, "syncfs", 1, { { "int", "fd" } } },
{ 345, "sendmmsg", 4, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" } } },
{ 346, "setns", 2, { { "int", "fd" }, { "int", "flags" } } },
{ 347, "process_vm_readv", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 348, "process_vm_writev", 6, { { "pid_t", "pid" }, { "const struct iovec *", "lvec" }, { "unsigned long", "liovcnt" }, { "const struct iovec *", "rvec" }, { "unsigned long", "riovcnt" }, { "unsigned long", "flags" } } },
{ 349, "kcmp", 5, { { "pid_t", "pid1" }, { "pid_t", "pid2" }, { "int", "type" }, { "unsigned long", "idx1" }, { "unsigned long", "idx2" } } },
{ 350, "finit_module", 3, { { "int", "fd" }, { "const char *", "uargs" }, { "int", "flags" } } },
{ 351, "sched_setattr", 3, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "flags" } } },
{ 352, "sched_getattr", 4, { { "pid_t", "pid" }, { "struct sched_attr *", "uattr" }, { "unsigned int", "usize" }, { "unsigned int", "flags" } } },
{ 353, "renameat2", 5, { { "int", "olddfd" }, { "const char *", "oldname" }, { "int", "newdfd" }, { "const char *", "newname" }, { "unsigned int", "flags" } } },
{ 354, "seccomp", 3, { { "unsigned int", "op" }, { "unsigned int", "flags" }, { "void *", "uargs" } } },
{ 355, "getrandom", 3, { { "char *", "ubuf" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 356, "memfd_create", 2, { { "const char *", "uname" }, { "unsigned int", "flags" } } },
{ 357, "bpf", 3, { { "int", "cmd" }, { "union bpf_attr *", "uattr" }, { "unsigned int", "size" } } },
{ 358, "execveat", 5, { { "int", "fd" }, { "const char *", "filename" }, { "const compat_uptr_t *", "argv" }, { "const compat_uptr_t *", "envp" }, { "int", "flags" } } },
{ 359, "socket", 3, { { "int", "family" }, { "int", "type" }, { "int", "protocol" } } },
{ 360, "socketpair", 4, { { "int", "family" }, { "int", "type" }, { "int", "protocol" }, { "int *", "usockvec" } } },
{ 361, "bind", 3, { { "int", "fd" }, { "struct sockaddr *", "umyaddr" }, { "int", "addrlen" } } },
{ 362, "connect", 3, { { "int", "fd" }, { "struct sockaddr *", "uservaddr" }, { "int", "addrlen" } } },
{ 363, "listen", 2, { { "int", "fd" }, { "int", "backlog" } } },
{ 364, "accept4", 4, { { "int", "fd" }, { "struct sockaddr *", "upeer_sockaddr" }, { "int *", "upeer_addrlen" }, { "int", "flags" } } },
{ 365, "getsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int *", "optlen" } } },
{ 366, "setsockopt", 5, { { "int", "fd" }, { "int", "level" }, { "int", "optname" }, { "char *", "optval" }, { "int", "optlen" } } },
{ 367, "getsockname", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 368, "getpeername", 3, { { "int", "fd" }, { "struct sockaddr *", "usockaddr" }, { "int *", "usockaddr_len" } } },
{ 369, "sendto", 6, { { "int", "fd" }, { "void *", "buff" }, { "size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int", "addr_len" } } },
{ 370, "sendmsg", 3, { { "int", "fd" }, { "struct compat_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 371, "recvfrom", 6, { { "int", "fd" }, { "void *", "buf" }, { "compat_size_t", "len" }, { "unsigned int", "flags" }, { "struct sockaddr *", "addr" }, { "int *", "addrlen" } } },
{ 372, "recvmsg", 3, { { "int", "fd" }, { "struct compat_msghdr *", "msg" }, { "unsigned int", "flags" } } },
{ 373, "shutdown", 2, { { "int", "fd" }, { "int", "how" } } },
{ 374, "userfaultfd", 1, { { "int", "flags" } } },
{ 375, "membarrier", 3, { { "int", "cmd" }, { "unsigned int", "flags" }, { "int", "cpu_id" } } },
{ 376, "mlock2", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "int", "flags" } } },
{ 377, "copy_file_range", 6, { { "int", "fd_in" }, { "loff_t *", "off_in" }, { "int", "fd_out" }, { "loff_t *", "off_out" }, { "size_t", "len" }, { "unsigned int", "flags" } } },
{ 378, "preadv2", 6, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" }, { "rwf_t", "flags" } } },
{ 379, "pwritev2", 6, { { "compat_ulong_t", "fd" }, { "const struct iovec *", "vec" }, { "compat_ulong_t", "vlen" }, { "u32", "pos_low" }, { "u32", "pos_high" }, { "rwf_t", "flags" } } },
{ 380, "pkey_mprotect", 4, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "prot" }, { "int", "pkey" } } },
{ 381, "pkey_alloc", 2, { { "unsigned long", "flags" }, { "unsigned long", "init_val" } } },
{ 382, "pkey_free", 1, { { "int", "pkey" } } },
{ 383, "statx", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "unsigned int", "mask" }, { "struct statx *", "buffer" } } },
{ 384, "arch_prctl", 2, { { "int", "option" }, { "unsigned long", "arg2" } } },
{ 385, "io_pgetevents", 6, { { "compat_aio_context_t", "ctx_id" }, { "compat_long_t", "min_nr" }, { "compat_long_t", "nr" }, { "struct io_event *", "events" }, { "struct old_timespec32 *", "timeout" }, { "const struct __compat_aio_sigset *", "usig" } } },
{ 386, "rseq", 4, { { "struct rseq *", "rseq" }, { "u32", "rseq_len" }, { "int", "flags" }, { "u32", "sig" } } },
{ 393, "semget", 3, { { "key_t", "key" }, { "int", "nsems" }, { "int", "semflg" } } },
{ 394, "semctl", 4, { { "int", "semid" }, { "int", "semnum" }, { "int", "cmd" }, { "int", "arg" } } },
{ 395, "shmget", 3, { { "key_t", "key" }, { "size_t", "size" }, { "int", "shmflg" } } },
{ 396, "shmctl", 3, { { "int", "shmid" }, { "int", "cmd" }, { "void *", "uptr" } } },
{ 397, "shmat", 3, { { "int", "shmid" }, { "compat_uptr_t", "shmaddr" }, { "int", "shmflg" } } },
{ 398, "shmdt", 1, { { "char *", "shmaddr" } } },
{ 399, "msgget", 2, { { "key_t", "key" }, { "int", "msgflg" } } },
{ 400, "msgsnd", 4, { { "int", "msqid" }, { "compat_uptr_t", "msgp" }, { "compat_ssize_t", "msgsz" }, { "int", "msgflg" } } },
{ 401, "msgrcv", 5, { { "int", "msqid" }, { "compat_uptr_t", "msgp" }, { "compat_ssize_t", "msgsz" }, { "compat_long_t", "msgtyp" }, { "int", "msgflg" } } },
{ 402, "msgctl", 3, { { "int", "msqid" }, { "int", "cmd" }, { "void *", "uptr" } } },
{ 403, "clock_gettime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 404, "clock_settime64", 2, { { "clockid_t", "which_clock" }, { "const struct __kernel_timespec *", "tp" } } },
{ 405, "clock_adjtime64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timex *", "tx" } } },
{ 406, "clock_getres_time64", 2, { { "clockid_t", "which_clock" }, { "struct __kernel_timespec *", "tp" } } },
{ 407, "clock_nanosleep_time64", 4, { { "clockid_t", "which_clock" }, { "int", "flags" }, { "const struct __kernel_timespec *", "rqtp" }, { "struct __kernel_timespec *", "rmtp" } } },
{ 408, "timer_gettime64", 2, { { "timer_t", "timer_id" }, { "struct __kernel_itimerspec *", "setting" } } },
{ 409, "timer_settime64", 4, { { "timer_t", "timer_id" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "new_setting" }, { "struct __kernel_itimerspec *", "old_setting" } } },
{ 410, "timerfd_gettime64", 2, { { "int", "ufd" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 411, "timerfd_settime64", 4, { { "int", "ufd" }, { "int", "flags" }, { "const struct __kernel_itimerspec *", "utmr" }, { "struct __kernel_itimerspec *", "otmr" } } },
{ 412, "utimensat_time64", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct __kernel_timespec *", "utimes" }, { "int", "flags" } } },
{ 413, "pselect6_time64", 6, { { "int", "n" }, { "compat_ulong_t *", "inp" }, { "compat_ulong_t *", "outp" }, { "compat_ulong_t *", "exp" }, { "struct __kernel_timespec *", "tsp" }, { "void *", "sig" } } },
{ 414, "ppoll_time64", 5, { { "struct pollfd *", "ufds" }, { "unsigned int", "nfds" }, { "struct __kernel_timespec *", "tsp" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 416, "io_pgetevents_time64", 6, { { "compat_aio_context_t", "ctx_id" }, { "compat_long_t", "min_nr" }, { "compat_long_t", "nr" }, { "struct io_event *", "events" }, { "struct __kernel_timespec *", "timeout" }, { "const struct __compat_aio_sigset *", "usig" } } },
{ 417, "recvmmsg_time64", 5, { { "int", "fd" }, { "struct compat_mmsghdr *", "mmsg" }, { "unsigned int", "vlen" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" } } },
{ 418, "mq_timedsend_time64", 5, { { "mqd_t", "mqdes" }, { "const char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 419, "mq_timedreceive_time64", 5, { { "mqd_t", "mqdes" }, { "char *", "msg_ptr" }, { "size_t", "msg_len" }, { "unsigned int *", "msg_prio" }, { "const struct __kernel_timespec *", "abs_timeout" } } },
{ 420, "semtimedop_time64", 4, { { "int", "semid" }, { "struct sembuf *", "sops" }, { "unsigned", "nsops" }, { "const struct __kernel_timespec *", "timeout" } } },
{ 421, "rt_sigtimedwait_time64", 4, { { "compat_sigset_t *", "uthese" }, { "struct compat_siginfo *", "uinfo" }, { "struct __kernel_timespec *", "uts" }, { "compat_size_t", "sigsetsize" } } },
{ 422, "futex_time64", 6, { { "u32 *", "uaddr" }, { "int", "op" }, { "u32", "val" }, { "const struct __kernel_timespec *", "utime" }, { "u32 *", "uaddr2" }, { "u32", "val3" } } },
{ 423, "sched_rr_get_interval_time64", 2, { { "pid_t", "pid" }, { "struct __kernel_timespec *", "interval" } } },
{ 424, "pidfd_send_signal", 4, { { "int", "pidfd" }, { "int", "sig" }, { "siginfo_t *", "info" }, { "unsigned int", "flags" } } },
{ 425, "io_uring_setup", 2, { { "u32", "entries" }, { "struct io_uring_params *", "params" } } },
{ 426, "io_uring_enter", 6, { { "unsigned int", "fd" }, { "u32", "to_submit" }, { "u32", "min_complete" }, { "u32", "flags" }, { "const void *", "argp" }, { "size_t", "argsz" } } },
{ 427, "io_uring_register", 4, { { "unsigned int", "fd" }, { "unsigned int", "opcode" }, { "void *", "arg" }, { "unsigned int", "nr_args" } } },
{ 428, "open_tree", 3, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" } } },
{ 429, "move_mount", 5, { { "int", "from_dfd" }, { "const char *", "from_pathname" }, { "int", "to_dfd" }, { "const char *", "to_pathname" }, { "unsigned int", "flags" } } },
{ 430, "fsopen", 2, { { "const char *", "_fs_name" }, { "unsigned int", "flags" } } },
{ 431, "fsconfig", 5, { { "int", "fd" }, { "unsigned int", "cmd" }, { "const char *", "_key" }, { "const void *", "_value" }, { "int", "aux" } } },
{ 432, "fsmount", 3, { { "int", "fs_fd" }, { "unsigned int", "flags" }, { "unsigned int", "attr_flags" } } },
{ 433, "fspick", 3, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" } } },
{ 434, "pidfd_open", 2, { { "pid_t", "pid" }, { "unsigned int", "flags" } } },
{ 435, "clone3", 2, { { "struct clone_args *", "uargs" }, { "size_t", "size" } } },
{ 436, "close_range", 3, { { "unsigned int", "fd" }, { "unsigned int", "max_fd" }, { "unsigned int", "flags" } } },
{ 437, "openat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "struct open_how *", "how" }, { "size_t", "usize" } } },
{ 438, "pidfd_getfd", 3, { { "int", "pidfd" }, { "int", "fd" }, { "unsigned int", "flags" } } },
{ 439, "faccessat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "int", "mode" }, { "int", "flags" } } },
{ 440, "process_madvise", 5, { { "int", "pidfd" }, { "const struct iovec *", "vec" }, { "size_t", "vlen" }, { "int", "behavior" }, { "unsigned int", "flags" } } },
{ 441, "epoll_pwait2", 6, { { "int", "epfd" }, { "struct epoll_event *", "events" }, { "int", "maxevents" }, { "const struct __kernel_timespec *", "timeout" }, { "const compat_sigset_t *", "sigmask" }, { "compat_size_t", "sigsetsize" } } },
{ 442, "mount_setattr", 5, { { "int", "dfd" }, { "const char *", "path" }, { "unsigned int", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 443, "quotactl_fd", 4, { { "unsigned int", "fd" }, { "unsigned int", "cmd" }, { "qid_t", "id" }, { "void *", "addr" } } },
{ 444, "landlock_create_ruleset", 3, { { "const struct landlock_ruleset_attr *const", "attr" }, { "const size_t", "size" }, { "const __u32", "flags" } } },
{ 445, "landlock_add_rule", 4, { { "const int", "ruleset_fd" }, { "const enum landlock_rule_type", "rule_type" }, { "const void *const", "rule_attr" }, { "const __u32", "flags" } } },
{ 446, "landlock_restrict_self", 2, { { "const int", "ruleset_fd" }, { "const __u32", "flags" } } },
{ 447, "memfd_secret", 1, { { "unsigned int", "flags" } } },
{ 448, "process_mrelease", 2, { { "int", "pidfd" }, { "unsigned int", "flags" } } },
{ 449, "futex_waitv", 5, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "nr_futexes" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 450, "set_mempolicy_home_node", 4, { { "unsigned long", "start" }, { "unsigned long", "len" }, { "unsigned long", "home_node" }, { "unsigned long", "flags" } } },
{ 451, "cachestat", 4, { { "unsigned int", "fd" }, { "struct cachestat_range *", "cstat_range" }, { "struct cachestat *", "cstat" }, { "unsigned int", "flags" } } },
{ 452, "fchmodat2", 4, { { "int", "dfd" }, { "const char *", "filename" }, { "umode_t", "mode" }, { "unsigned int", "flags" } } },
{ 453, "map_shadow_stack", 3, { { "unsigned long", "addr" }, { "unsigned long", "size" }, { "unsigned int", "flags" } } },
{ 454, "futex_wake", 4, { { "void *", "uaddr" }, { "unsigned long", "mask" }, { "int", "nr" }, { "unsigned int", "flags" } } },
{ 455, "futex_wait", 6, { { "void *", "uaddr" }, { "unsigned long", "val" }, { "unsigned long", "mask" }, { "unsigned int", "flags" }, { "struct __kernel_timespec *", "timeout" }, { "clockid_t", "clockid" } } },
{ 456, "futex_requeue", 4, { { "struct futex_waitv *", "waiters" }, { "unsigned int", "flags" }, { "int", "nr_wake" }, { "int", "nr_requeue" } } },
{ 457, "statmount", 4, { { "const struct mnt_id_req *", "req" }, { "struct statmount *", "buf" }, { "size_t", "bufsize" }, { "unsigned int", "flags" } } },
{ 458, "listmount", 4, { { "const struct mnt_id_req *", "req" }, { "u64 *", "mnt_ids" }, { "size_t", "nr_mnt_ids" }, { "unsigned int", "flags" } } },
{ 459, "lsm_get_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 460, "lsm_set_self_attr", 4, { { "unsigned int", "attr" }, { "struct lsm_ctx *", "ctx" }, { "u32", "size" }, { "u32", "flags" } } },
{ 461, "lsm_list_modules", 3, { { "u64 *", "ids" }, { "u32 *", "size" }, { "u32", "flags" } } },
{ 462, "mseal", 3, { { "unsigned long", "start" }, { "size_t", "len" }, { "unsigned long", "flags" } } },
{ 463, "setxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "const struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 464, "getxattrat", 6, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" }, { "struct xattr_args *", "uargs" }, { "size_t", "usize" } } },
{ 465, "listxattrat", 5, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "char *", "list" }, { "size_t", "size" } } },
{ 466, "removexattrat", 4, { { "int", "dfd" }, { "const char *", "pathname" }, { "unsigned int", "at_flags" }, { "const char *", "name" } } },
{ 467, "open_tree_attr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "unsigned", "flags" }, { "struct mount_attr *", "uattr" }, { "size_t", "usize" } } },
{ 468, "file_getattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 469, "file_setattr", 5, { { "int", "dfd" }, { "const char *", "filename" }, { "struct file_attr *", "ufattr" }, { "size_t", "usize" }, { "unsigned int", "at_flags" } } },
{ 470, "listns", 4, { { "const struct ns_id_req *", "req" }, { "u64 *", "ns_ids" }, { "size_t", "nr_ns_ids" }, { "unsigned int", "flags" } } },
};
FridaLinuxSyscallSignature *
frida_get_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_syscall_signatures;
}
FridaLinuxSyscallSignature *
frida_get_compat32_syscall_signatures (int * len)
{
if (len != NULL)
*len = G_N_ELEMENTS (frida_compat32_syscall_signatures);
return (FridaLinuxSyscallSignature *) frida_compat32_syscall_signatures;
}
+815
View File
@@ -0,0 +1,815 @@
// AUTO-GENERATED FILE. DO NOT EDIT.
namespace Frida {
public enum LinuxSyscall {
READ = 0,
WRITE = 1,
OPEN = 2,
CLOSE = 3,
STAT = 4,
FSTAT = 5,
LSTAT = 6,
POLL = 7,
LSEEK = 8,
MMAP = 9,
MPROTECT = 10,
MUNMAP = 11,
BRK = 12,
RT_SIGACTION = 13,
RT_SIGPROCMASK = 14,
RT_SIGRETURN = 15,
IOCTL = 16,
PREAD64 = 17,
PWRITE64 = 18,
READV = 19,
WRITEV = 20,
ACCESS = 21,
PIPE = 22,
SELECT = 23,
SCHED_YIELD = 24,
MREMAP = 25,
MSYNC = 26,
MINCORE = 27,
MADVISE = 28,
SHMGET = 29,
SHMAT = 30,
SHMCTL = 31,
DUP = 32,
DUP2 = 33,
PAUSE = 34,
NANOSLEEP = 35,
GETITIMER = 36,
ALARM = 37,
SETITIMER = 38,
GETPID = 39,
SENDFILE = 40,
SOCKET = 41,
CONNECT = 42,
ACCEPT = 43,
SENDTO = 44,
RECVFROM = 45,
SENDMSG = 46,
RECVMSG = 47,
SHUTDOWN = 48,
BIND = 49,
LISTEN = 50,
GETSOCKNAME = 51,
GETPEERNAME = 52,
SOCKETPAIR = 53,
SETSOCKOPT = 54,
GETSOCKOPT = 55,
CLONE = 56,
FORK = 57,
VFORK = 58,
EXECVE = 59,
EXIT = 60,
WAIT4 = 61,
KILL = 62,
UNAME = 63,
SEMGET = 64,
SEMOP = 65,
SEMCTL = 66,
SHMDT = 67,
MSGGET = 68,
MSGSND = 69,
MSGRCV = 70,
MSGCTL = 71,
FCNTL = 72,
FLOCK = 73,
FSYNC = 74,
FDATASYNC = 75,
TRUNCATE = 76,
FTRUNCATE = 77,
GETDENTS = 78,
GETCWD = 79,
CHDIR = 80,
FCHDIR = 81,
RENAME = 82,
MKDIR = 83,
RMDIR = 84,
CREAT = 85,
LINK = 86,
UNLINK = 87,
SYMLINK = 88,
READLINK = 89,
CHMOD = 90,
FCHMOD = 91,
CHOWN = 92,
FCHOWN = 93,
LCHOWN = 94,
UMASK = 95,
GETTIMEOFDAY = 96,
GETRLIMIT = 97,
GETRUSAGE = 98,
SYSINFO = 99,
TIMES = 100,
PTRACE = 101,
GETUID = 102,
SYSLOG = 103,
GETGID = 104,
SETUID = 105,
SETGID = 106,
GETEUID = 107,
GETEGID = 108,
SETPGID = 109,
GETPPID = 110,
GETPGRP = 111,
SETSID = 112,
SETREUID = 113,
SETREGID = 114,
GETGROUPS = 115,
SETGROUPS = 116,
SETRESUID = 117,
GETRESUID = 118,
SETRESGID = 119,
GETRESGID = 120,
GETPGID = 121,
SETFSUID = 122,
SETFSGID = 123,
GETSID = 124,
CAPGET = 125,
CAPSET = 126,
RT_SIGPENDING = 127,
RT_SIGTIMEDWAIT = 128,
RT_SIGQUEUEINFO = 129,
RT_SIGSUSPEND = 130,
SIGALTSTACK = 131,
UTIME = 132,
MKNOD = 133,
PERSONALITY = 135,
USTAT = 136,
STATFS = 137,
FSTATFS = 138,
SYSFS = 139,
GETPRIORITY = 140,
SETPRIORITY = 141,
SCHED_SETPARAM = 142,
SCHED_GETPARAM = 143,
SCHED_SETSCHEDULER = 144,
SCHED_GETSCHEDULER = 145,
SCHED_GET_PRIORITY_MAX = 146,
SCHED_GET_PRIORITY_MIN = 147,
SCHED_RR_GET_INTERVAL = 148,
MLOCK = 149,
MUNLOCK = 150,
MLOCKALL = 151,
MUNLOCKALL = 152,
VHANGUP = 153,
MODIFY_LDT = 154,
PIVOT_ROOT = 155,
_SYSCTL = 156,
PRCTL = 157,
ARCH_PRCTL = 158,
ADJTIMEX = 159,
SETRLIMIT = 160,
CHROOT = 161,
SYNC = 162,
ACCT = 163,
SETTIMEOFDAY = 164,
MOUNT = 165,
UMOUNT2 = 166,
SWAPON = 167,
SWAPOFF = 168,
REBOOT = 169,
SETHOSTNAME = 170,
SETDOMAINNAME = 171,
IOPL = 172,
IOPERM = 173,
INIT_MODULE = 175,
DELETE_MODULE = 176,
QUOTACTL = 179,
GETTID = 186,
READAHEAD = 187,
SETXATTR = 188,
LSETXATTR = 189,
FSETXATTR = 190,
GETXATTR = 191,
LGETXATTR = 192,
FGETXATTR = 193,
LISTXATTR = 194,
LLISTXATTR = 195,
FLISTXATTR = 196,
REMOVEXATTR = 197,
LREMOVEXATTR = 198,
FREMOVEXATTR = 199,
TKILL = 200,
TIME = 201,
FUTEX = 202,
SCHED_SETAFFINITY = 203,
SCHED_GETAFFINITY = 204,
SET_THREAD_AREA = 205,
IO_SETUP = 206,
IO_DESTROY = 207,
IO_GETEVENTS = 208,
IO_SUBMIT = 209,
IO_CANCEL = 210,
GET_THREAD_AREA = 211,
EPOLL_CREATE = 213,
REMAP_FILE_PAGES = 216,
GETDENTS64 = 217,
SET_TID_ADDRESS = 218,
RESTART_SYSCALL = 219,
SEMTIMEDOP = 220,
FADVISE64 = 221,
TIMER_CREATE = 222,
TIMER_SETTIME = 223,
TIMER_GETTIME = 224,
TIMER_GETOVERRUN = 225,
TIMER_DELETE = 226,
CLOCK_SETTIME = 227,
CLOCK_GETTIME = 228,
CLOCK_GETRES = 229,
CLOCK_NANOSLEEP = 230,
EXIT_GROUP = 231,
EPOLL_WAIT = 232,
EPOLL_CTL = 233,
TGKILL = 234,
UTIMES = 235,
MBIND = 237,
SET_MEMPOLICY = 238,
GET_MEMPOLICY = 239,
MQ_OPEN = 240,
MQ_UNLINK = 241,
MQ_TIMEDSEND = 242,
MQ_TIMEDRECEIVE = 243,
MQ_NOTIFY = 244,
MQ_GETSETATTR = 245,
KEXEC_LOAD = 246,
WAITID = 247,
ADD_KEY = 248,
REQUEST_KEY = 249,
KEYCTL = 250,
IOPRIO_SET = 251,
IOPRIO_GET = 252,
INOTIFY_INIT = 253,
INOTIFY_ADD_WATCH = 254,
INOTIFY_RM_WATCH = 255,
MIGRATE_PAGES = 256,
OPENAT = 257,
MKDIRAT = 258,
MKNODAT = 259,
FCHOWNAT = 260,
FUTIMESAT = 261,
NEWFSTATAT = 262,
UNLINKAT = 263,
RENAMEAT = 264,
LINKAT = 265,
SYMLINKAT = 266,
READLINKAT = 267,
FCHMODAT = 268,
FACCESSAT = 269,
PSELECT6 = 270,
PPOLL = 271,
UNSHARE = 272,
SET_ROBUST_LIST = 273,
GET_ROBUST_LIST = 274,
SPLICE = 275,
TEE = 276,
SYNC_FILE_RANGE = 277,
VMSPLICE = 278,
MOVE_PAGES = 279,
UTIMENSAT = 280,
EPOLL_PWAIT = 281,
SIGNALFD = 282,
TIMERFD_CREATE = 283,
EVENTFD = 284,
FALLOCATE = 285,
TIMERFD_SETTIME = 286,
TIMERFD_GETTIME = 287,
ACCEPT4 = 288,
SIGNALFD4 = 289,
EVENTFD2 = 290,
EPOLL_CREATE1 = 291,
DUP3 = 292,
PIPE2 = 293,
INOTIFY_INIT1 = 294,
PREADV = 295,
PWRITEV = 296,
RT_TGSIGQUEUEINFO = 297,
PERF_EVENT_OPEN = 298,
RECVMMSG = 299,
FANOTIFY_INIT = 300,
FANOTIFY_MARK = 301,
PRLIMIT64 = 302,
NAME_TO_HANDLE_AT = 303,
OPEN_BY_HANDLE_AT = 304,
CLOCK_ADJTIME = 305,
SYNCFS = 306,
SENDMMSG = 307,
SETNS = 308,
GETCPU = 309,
PROCESS_VM_READV = 310,
PROCESS_VM_WRITEV = 311,
KCMP = 312,
FINIT_MODULE = 313,
SCHED_SETATTR = 314,
SCHED_GETATTR = 315,
RENAMEAT2 = 316,
SECCOMP = 317,
GETRANDOM = 318,
MEMFD_CREATE = 319,
KEXEC_FILE_LOAD = 320,
BPF = 321,
EXECVEAT = 322,
USERFAULTFD = 323,
MEMBARRIER = 324,
MLOCK2 = 325,
COPY_FILE_RANGE = 326,
PREADV2 = 327,
PWRITEV2 = 328,
PKEY_MPROTECT = 329,
PKEY_ALLOC = 330,
PKEY_FREE = 331,
STATX = 332,
IO_PGETEVENTS = 333,
RSEQ = 334,
URETPROBE = 335,
UPROBE = 336,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
MEMFD_SECRET = 447,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
public enum LinuxCompat32Syscall {
RESTART_SYSCALL = 0,
EXIT = 1,
FORK = 2,
READ = 3,
WRITE = 4,
OPEN = 5,
CLOSE = 6,
WAITPID = 7,
CREAT = 8,
LINK = 9,
UNLINK = 10,
EXECVE = 11,
CHDIR = 12,
TIME = 13,
MKNOD = 14,
CHMOD = 15,
LCHOWN = 16,
OLDSTAT = 18,
LSEEK = 19,
GETPID = 20,
MOUNT = 21,
UMOUNT = 22,
SETUID = 23,
GETUID = 24,
STIME = 25,
PTRACE = 26,
ALARM = 27,
OLDFSTAT = 28,
PAUSE = 29,
UTIME = 30,
ACCESS = 33,
NICE = 34,
SYNC = 36,
KILL = 37,
RENAME = 38,
MKDIR = 39,
RMDIR = 40,
DUP = 41,
PIPE = 42,
TIMES = 43,
BRK = 45,
SETGID = 46,
GETGID = 47,
SIGNAL = 48,
GETEUID = 49,
GETEGID = 50,
ACCT = 51,
UMOUNT2 = 52,
IOCTL = 54,
FCNTL = 55,
SETPGID = 57,
OLDOLDUNAME = 59,
UMASK = 60,
CHROOT = 61,
USTAT = 62,
DUP2 = 63,
GETPPID = 64,
GETPGRP = 65,
SETSID = 66,
SIGACTION = 67,
SGETMASK = 68,
SSETMASK = 69,
SETREUID = 70,
SETREGID = 71,
SIGSUSPEND = 72,
SIGPENDING = 73,
SETHOSTNAME = 74,
SETRLIMIT = 75,
GETRLIMIT = 76,
GETRUSAGE = 77,
GETTIMEOFDAY = 78,
SETTIMEOFDAY = 79,
GETGROUPS = 80,
SETGROUPS = 81,
SELECT = 82,
SYMLINK = 83,
OLDLSTAT = 84,
READLINK = 85,
USELIB = 86,
SWAPON = 87,
REBOOT = 88,
READDIR = 89,
MMAP = 90,
MUNMAP = 91,
TRUNCATE = 92,
FTRUNCATE = 93,
FCHMOD = 94,
FCHOWN = 95,
GETPRIORITY = 96,
SETPRIORITY = 97,
STATFS = 99,
FSTATFS = 100,
IOPERM = 101,
SOCKETCALL = 102,
SYSLOG = 103,
SETITIMER = 104,
GETITIMER = 105,
STAT = 106,
LSTAT = 107,
FSTAT = 108,
OLDUNAME = 109,
IOPL = 110,
VHANGUP = 111,
VM86OLD = 113,
WAIT4 = 114,
SWAPOFF = 115,
SYSINFO = 116,
IPC = 117,
FSYNC = 118,
CLONE = 120,
SETDOMAINNAME = 121,
UNAME = 122,
MODIFY_LDT = 123,
ADJTIMEX = 124,
MPROTECT = 125,
SIGPROCMASK = 126,
INIT_MODULE = 128,
DELETE_MODULE = 129,
QUOTACTL = 131,
GETPGID = 132,
FCHDIR = 133,
BDFLUSH = 134,
SYSFS = 135,
PERSONALITY = 136,
SETFSUID = 138,
SETFSGID = 139,
_LLSEEK = 140,
GETDENTS = 141,
_NEWSELECT = 142,
FLOCK = 143,
MSYNC = 144,
READV = 145,
WRITEV = 146,
GETSID = 147,
FDATASYNC = 148,
_SYSCTL = 149,
MLOCK = 150,
MUNLOCK = 151,
MLOCKALL = 152,
MUNLOCKALL = 153,
SCHED_SETPARAM = 154,
SCHED_GETPARAM = 155,
SCHED_SETSCHEDULER = 156,
SCHED_GETSCHEDULER = 157,
SCHED_YIELD = 158,
SCHED_GET_PRIORITY_MAX = 159,
SCHED_GET_PRIORITY_MIN = 160,
SCHED_RR_GET_INTERVAL = 161,
NANOSLEEP = 162,
MREMAP = 163,
SETRESUID = 164,
GETRESUID = 165,
VM86 = 166,
POLL = 168,
SETRESGID = 170,
GETRESGID = 171,
PRCTL = 172,
RT_SIGRETURN = 173,
RT_SIGACTION = 174,
RT_SIGPROCMASK = 175,
RT_SIGPENDING = 176,
RT_SIGTIMEDWAIT = 177,
RT_SIGQUEUEINFO = 178,
RT_SIGSUSPEND = 179,
PREAD64 = 180,
PWRITE64 = 181,
CHOWN = 182,
GETCWD = 183,
CAPGET = 184,
CAPSET = 185,
SIGALTSTACK = 186,
SENDFILE = 187,
VFORK = 190,
UGETRLIMIT = 191,
MMAP2 = 192,
TRUNCATE64 = 193,
FTRUNCATE64 = 194,
LCHOWN32 = 198,
GETUID32 = 199,
GETGID32 = 200,
GETEUID32 = 201,
GETEGID32 = 202,
SETREUID32 = 203,
SETREGID32 = 204,
GETGROUPS32 = 205,
SETGROUPS32 = 206,
FCHOWN32 = 207,
SETRESUID32 = 208,
GETRESUID32 = 209,
SETRESGID32 = 210,
GETRESGID32 = 211,
CHOWN32 = 212,
SETUID32 = 213,
SETGID32 = 214,
SETFSUID32 = 215,
SETFSGID32 = 216,
PIVOT_ROOT = 217,
MINCORE = 218,
MADVISE = 219,
GETDENTS64 = 220,
FCNTL64 = 221,
GETTID = 224,
READAHEAD = 225,
SETXATTR = 226,
LSETXATTR = 227,
FSETXATTR = 228,
GETXATTR = 229,
LGETXATTR = 230,
FGETXATTR = 231,
LISTXATTR = 232,
LLISTXATTR = 233,
FLISTXATTR = 234,
REMOVEXATTR = 235,
LREMOVEXATTR = 236,
FREMOVEXATTR = 237,
TKILL = 238,
SENDFILE64 = 239,
FUTEX = 240,
SCHED_SETAFFINITY = 241,
SCHED_GETAFFINITY = 242,
SET_THREAD_AREA = 243,
GET_THREAD_AREA = 244,
IO_SETUP = 245,
IO_DESTROY = 246,
IO_GETEVENTS = 247,
IO_SUBMIT = 248,
IO_CANCEL = 249,
FADVISE64 = 250,
EXIT_GROUP = 252,
EPOLL_CREATE = 254,
EPOLL_CTL = 255,
EPOLL_WAIT = 256,
REMAP_FILE_PAGES = 257,
SET_TID_ADDRESS = 258,
TIMER_CREATE = 259,
TIMER_SETTIME = 260,
TIMER_GETTIME = 261,
TIMER_GETOVERRUN = 262,
TIMER_DELETE = 263,
CLOCK_SETTIME = 264,
CLOCK_GETTIME = 265,
CLOCK_GETRES = 266,
CLOCK_NANOSLEEP = 267,
STATFS64 = 268,
FSTATFS64 = 269,
TGKILL = 270,
UTIMES = 271,
FADVISE64_64 = 272,
MBIND = 274,
GET_MEMPOLICY = 275,
SET_MEMPOLICY = 276,
MQ_OPEN = 277,
MQ_UNLINK = 278,
MQ_TIMEDSEND = 279,
MQ_TIMEDRECEIVE = 280,
MQ_NOTIFY = 281,
MQ_GETSETATTR = 282,
KEXEC_LOAD = 283,
WAITID = 284,
ADD_KEY = 286,
REQUEST_KEY = 287,
KEYCTL = 288,
IOPRIO_SET = 289,
IOPRIO_GET = 290,
INOTIFY_INIT = 291,
INOTIFY_ADD_WATCH = 292,
INOTIFY_RM_WATCH = 293,
MIGRATE_PAGES = 294,
OPENAT = 295,
MKDIRAT = 296,
MKNODAT = 297,
FCHOWNAT = 298,
FUTIMESAT = 299,
UNLINKAT = 301,
RENAMEAT = 302,
LINKAT = 303,
SYMLINKAT = 304,
READLINKAT = 305,
FCHMODAT = 306,
FACCESSAT = 307,
PSELECT6 = 308,
PPOLL = 309,
UNSHARE = 310,
SET_ROBUST_LIST = 311,
GET_ROBUST_LIST = 312,
SPLICE = 313,
SYNC_FILE_RANGE = 314,
TEE = 315,
VMSPLICE = 316,
MOVE_PAGES = 317,
GETCPU = 318,
EPOLL_PWAIT = 319,
UTIMENSAT = 320,
SIGNALFD = 321,
TIMERFD_CREATE = 322,
EVENTFD = 323,
FALLOCATE = 324,
TIMERFD_SETTIME = 325,
TIMERFD_GETTIME = 326,
SIGNALFD4 = 327,
EVENTFD2 = 328,
EPOLL_CREATE1 = 329,
DUP3 = 330,
PIPE2 = 331,
INOTIFY_INIT1 = 332,
PREADV = 333,
PWRITEV = 334,
RT_TGSIGQUEUEINFO = 335,
PERF_EVENT_OPEN = 336,
RECVMMSG = 337,
FANOTIFY_INIT = 338,
FANOTIFY_MARK = 339,
PRLIMIT64 = 340,
NAME_TO_HANDLE_AT = 341,
OPEN_BY_HANDLE_AT = 342,
CLOCK_ADJTIME = 343,
SYNCFS = 344,
SENDMMSG = 345,
SETNS = 346,
PROCESS_VM_READV = 347,
PROCESS_VM_WRITEV = 348,
KCMP = 349,
FINIT_MODULE = 350,
SCHED_SETATTR = 351,
SCHED_GETATTR = 352,
RENAMEAT2 = 353,
SECCOMP = 354,
GETRANDOM = 355,
MEMFD_CREATE = 356,
BPF = 357,
EXECVEAT = 358,
SOCKET = 359,
SOCKETPAIR = 360,
BIND = 361,
CONNECT = 362,
LISTEN = 363,
ACCEPT4 = 364,
GETSOCKOPT = 365,
SETSOCKOPT = 366,
GETSOCKNAME = 367,
GETPEERNAME = 368,
SENDTO = 369,
SENDMSG = 370,
RECVFROM = 371,
RECVMSG = 372,
SHUTDOWN = 373,
USERFAULTFD = 374,
MEMBARRIER = 375,
MLOCK2 = 376,
COPY_FILE_RANGE = 377,
PREADV2 = 378,
PWRITEV2 = 379,
PKEY_MPROTECT = 380,
PKEY_ALLOC = 381,
PKEY_FREE = 382,
STATX = 383,
ARCH_PRCTL = 384,
IO_PGETEVENTS = 385,
RSEQ = 386,
SEMGET = 393,
SEMCTL = 394,
SHMGET = 395,
SHMCTL = 396,
SHMAT = 397,
SHMDT = 398,
MSGGET = 399,
MSGSND = 400,
MSGRCV = 401,
MSGCTL = 402,
CLOCK_GETTIME64 = 403,
CLOCK_SETTIME64 = 404,
CLOCK_ADJTIME64 = 405,
CLOCK_GETRES_TIME64 = 406,
CLOCK_NANOSLEEP_TIME64 = 407,
TIMER_GETTIME64 = 408,
TIMER_SETTIME64 = 409,
TIMERFD_GETTIME64 = 410,
TIMERFD_SETTIME64 = 411,
UTIMENSAT_TIME64 = 412,
PSELECT6_TIME64 = 413,
PPOLL_TIME64 = 414,
IO_PGETEVENTS_TIME64 = 416,
RECVMMSG_TIME64 = 417,
MQ_TIMEDSEND_TIME64 = 418,
MQ_TIMEDRECEIVE_TIME64 = 419,
SEMTIMEDOP_TIME64 = 420,
RT_SIGTIMEDWAIT_TIME64 = 421,
FUTEX_TIME64 = 422,
SCHED_RR_GET_INTERVAL_TIME64 = 423,
PIDFD_SEND_SIGNAL = 424,
IO_URING_SETUP = 425,
IO_URING_ENTER = 426,
IO_URING_REGISTER = 427,
OPEN_TREE = 428,
MOVE_MOUNT = 429,
FSOPEN = 430,
FSCONFIG = 431,
FSMOUNT = 432,
FSPICK = 433,
PIDFD_OPEN = 434,
CLONE3 = 435,
CLOSE_RANGE = 436,
OPENAT2 = 437,
PIDFD_GETFD = 438,
FACCESSAT2 = 439,
PROCESS_MADVISE = 440,
EPOLL_PWAIT2 = 441,
MOUNT_SETATTR = 442,
QUOTACTL_FD = 443,
LANDLOCK_CREATE_RULESET = 444,
LANDLOCK_ADD_RULE = 445,
LANDLOCK_RESTRICT_SELF = 446,
MEMFD_SECRET = 447,
PROCESS_MRELEASE = 448,
FUTEX_WAITV = 449,
SET_MEMPOLICY_HOME_NODE = 450,
CACHESTAT = 451,
FCHMODAT2 = 452,
MAP_SHADOW_STACK = 453,
FUTEX_WAKE = 454,
FUTEX_WAIT = 455,
FUTEX_REQUEUE = 456,
STATMOUNT = 457,
LISTMOUNT = 458,
LSM_GET_SELF_ATTR = 459,
LSM_SET_SELF_ATTR = 460,
LSM_LIST_MODULES = 461,
MSEAL = 462,
SETXATTRAT = 463,
GETXATTRAT = 464,
LISTXATTRAT = 465,
REMOVEXATTRAT = 466,
OPEN_TREE_ATTR = 467,
FILE_GETATTR = 468,
FILE_SETATTR = 469,
LISTNS = 470,
}
}
-26
View File
@@ -1,26 +0,0 @@
namespace Frida {
[CCode (cheader_filename = "dlfcn.h", cname = "dlopen")]
public void * dlopen (string filename, int flags);
[CCode (cheader_filename = "dlfcn.h", cname = "dlclose")]
public int dlclose (void * handle);
[CCode (cheader_filename = "dlfcn.h", cname = "dlsym")]
public void * dlsym (void * handle, string symbol);
[CCode (cheader_filename = "dlfcn.h", cname = "dlerror")]
public unowned string dlerror ();
[CCode (cheader_filename = "sys/mman.h", cname = "MAP_ANONYMOUS")]
public const int MAP_ANONYMOUS;
[CCode (cheader_filename = "linux-syscall.h", cprefix = "SYS_", has_type_id = false)]
public enum SysCall {
memfd_create,
pidfd_getfd,
pidfd_open,
process_vm_readv,
process_vm_writev,
tgkill,
}
}
+449 -3
View File
@@ -11,6 +11,52 @@ namespace Frida {
return (linux_major == major && linux_minor >= minor) || linux_major > major;
}
public struct DevId {
public uint32 major;
public uint32 minor;
public DevId (uint32 major, uint32 minor) {
this.major = major;
this.minor = minor;
}
public uint64 pack () {
return ((uint64) major << 32) | minor;
}
public static DevId unpack (uint64 dev) {
return DevId ((uint32) (dev >> 32), (uint32) dev);
}
public bool equals (DevId other) {
return major == other.major && minor == other.minor;
}
public uint hash () {
return (uint) (major ^ (minor * 0x9e3779b9));
}
public string to_string () {
return "%x:%x".printf (major, minor);
}
}
public extern unowned LinuxSyscallSignature[] get_syscall_signatures ();
public extern unowned LinuxSyscallSignature[]? get_compat32_syscall_signatures ();
public struct LinuxSyscallSignature {
public uint nr;
public string name;
public uint8 nargs;
public LinuxSyscallArg args[6];
}
public struct LinuxSyscallArg {
public string? type;
public string? name;
}
public sealed class PidFileDescriptor : FileDescriptor {
private uint pid;
@@ -42,11 +88,11 @@ namespace Frida {
}
private static int pidfd_open (uint pid, uint flags) {
return Linux.syscall (SysCall.pidfd_open, pid, flags);
return Linux.syscall (LinuxSyscall.PIDFD_OPEN, pid, flags);
}
private static int pidfd_getfd (int pidfd, int targetfd, uint flags) {
return Linux.syscall (SysCall.pidfd_getfd, pidfd, targetfd, flags);
return Linux.syscall (LinuxSyscall.PIDFD_GETFD, pidfd, targetfd, flags);
}
[NoReturn]
@@ -78,7 +124,407 @@ namespace Frida {
}
private int memfd_create (string name, uint flags) {
return Linux.syscall (SysCall.memfd_create, name, flags);
return Linux.syscall (LinuxSyscall.MEMFD_CREATE, name, flags);
}
}
public sealed class BpfObject {
public Programs programs {
get;
}
public Maps maps {
get;
}
internal Libbpf.Object handle;
private char[] kernel_log_buf;
public static BpfObject open (string name, uint8[] blob) throws Error {
var log_buf = new char[64 * 1024];
var opts = Libbpf.Object.OpenOpts ();
opts.sz = sizeof (Libbpf.Object.OpenOpts);
opts.object_name = name;
opts.kernel_log_buf = log_buf;
var handle = Libbpf.Object.open_mem (blob, opts);
if (handle == null)
throw_libbpf_error (errno);
return new BpfObject ((owned) handle, (owned) log_buf);
}
private BpfObject (owned Libbpf.Object handle, owned char[] kernel_log_buf) {
this.handle = (owned) handle;
this.kernel_log_buf = (owned) kernel_log_buf;
_programs = new Programs (this);
_maps = new Maps (this);
}
public void prepare () throws Error {
check_libbpf_result (handle.prepare ());
}
public void load () throws Error {
check_libbpf_result (handle.load (), (string) kernel_log_buf);
}
public sealed class Programs {
private unowned BpfObject parent;
internal Programs (BpfObject parent) {
this.parent = parent;
}
public BpfProgram get_by_name (string name) throws Error {
var p = find_by_name (name);
if (p == null)
throw new Error.INVALID_ARGUMENT ("No program named '%s'", name);
return p;
}
public BpfProgram? find_by_name (string name) {
unowned Libbpf.Program? p = parent.handle.find_program_by_name (name);
if (p == null)
return null;
return new BpfProgram (p, parent);
}
public Iterator iterator () {
return new Iterator (parent);
}
public class Iterator {
private BpfObject parent;
private BpfProgram? current;
internal Iterator (BpfObject parent) {
this.parent = parent;
}
public BpfProgram? next_value () {
unowned Libbpf.Program? p = parent.handle.next_program (current?.handle);
if (p == null)
return null;
current = new BpfProgram (p, parent);
return current;
}
}
}
public sealed class Maps {
private unowned BpfObject parent;
internal Maps (BpfObject parent) {
this.parent = parent;
}
public BpfMap get_by_name (string name) throws Error {
var p = find_by_name (name);
if (p == null)
throw new Error.INVALID_ARGUMENT ("No map named '%s'", name);
return p;
}
public BpfMap? find_by_name (string name) {
unowned Libbpf.Map? p = parent.handle.find_map_by_name (name);
if (p == null)
return null;
return new BpfMap (p, parent);
}
public Iterator iterator () {
return new Iterator (parent);
}
public class Iterator {
private BpfObject parent;
private BpfMap? current;
internal Iterator (BpfObject parent) {
this.parent = parent;
}
public BpfMap? next_value () {
unowned Libbpf.Map? p = parent.handle.next_map (current?.handle);
if (p == null)
return null;
current = new BpfMap (p, parent);
return current;
}
}
}
}
public sealed class BpfProgram {
internal unowned Libbpf.Program handle;
private BpfObject parent;
public string name {
get {
return handle.name;
}
}
internal BpfProgram (Libbpf.Program handle, BpfObject parent) {
this.handle = handle;
this.parent = parent;
}
public BpfLink attach () throws Error {
return parse_attach_result (handle.attach ());
}
public BpfLink attach_perf_event (FileDescriptor pfd) throws Error {
return parse_attach_result (handle.attach_perf_event (pfd.handle));
}
private BpfLink parse_attach_result (owned Libbpf.Link? l) throws Error {
if (l == null)
throw_libbpf_error (errno);
return new BpfLink ((owned) l);
}
}
public sealed class BpfMap {
internal unowned Libbpf.Map handle;
private BpfObject parent;
public string name {
get {
return handle.name;
}
}
public int fd {
get {
return handle.fd;
}
}
public uint32 max_entries {
get {
return handle.max_entries;
}
set {
handle.max_entries = value;
}
}
public uint32 key_size {
get {
return handle.key_size;
}
set {
handle.key_size = value;
}
}
public uint32 value_size {
get {
return handle.value_size;
}
set {
handle.value_size = value;
}
}
internal BpfMap (Libbpf.Map handle, BpfObject parent) {
this.handle = handle;
this.parent = parent;
}
public void update_u32_u8 (uint32 key, uint8 val) throws Error {
update_raw ((uint8[]) &key, (uint8[]) &val);
}
public void update_u32_u32 (uint32 key, uint32 val) throws Error {
update_raw ((uint8[]) &key, (uint8[]) &val);
}
public void remove_u32 (uint32 key) throws Error {
remove_raw ((uint8[]) &key);
}
public void foreach_percpu_value<T> (uint8[] key, PercpuValueFunc<T> func) throws Error {
var ncpus = check_libbpf_result (Libbpf.num_possible_cpus ());
var percpu_stride = round_up_8 (value_size);
uint8[] buf = new uint8[ncpus * percpu_stride];
lookup_raw (key, buf);
for (int cpu = 0; cpu != ncpus; cpu++) {
unowned T val = (T) ((uint8 *) buf + (cpu * percpu_stride));
func (cpu, val);
}
}
public delegate void PercpuValueFunc<T> (uint32 cpu, T val);
public void lookup_raw (uint8[] key, uint8[] val) throws Error {
check_libbpf_result (handle.lookup_elem (key, val));
}
public void update_raw (uint8[] key, uint8[] val) throws Error {
check_libbpf_result (handle.update_elem (key, val));
}
public void remove_raw (uint8[] key) throws Error {
check_libbpf_result (handle.delete_elem (key));
}
}
public sealed class BpfLink {
private Libbpf.Link handle;
internal BpfLink (owned Libbpf.Link handle) {
this.handle = (owned) handle;
}
}
private int check_libbpf_result (int result, string details = "") throws Error {
if (result < 0)
throw_libbpf_error (result, details);
return result;
}
[NoReturn]
private void throw_libbpf_error (int err, string details = "") throws Error {
var message = new StringBuilder (error_message_for_libbpf_error (err));
if (details.length != 0) {
message
.append (":\n")
.append (details.chomp ());
}
if (err.abs () == Posix.EPERM)
throw new Error.PERMISSION_DENIED ("%s", message.str);
else
throw new Error.INVALID_ARGUMENT ("%s", message.str);
}
private string error_message_for_libbpf_error (int err) {
char message[256];
int result = Libbpf.strerror (err, message);
assert (result == 0);
return (string) message;
}
public sealed class BpfRingbufReader : Object {
private BpfMap map;
private uint8 * consumer_map;
private uint8 * producer_map;
private uint8 * producer_page;
private uint8 * data_base;
private uint64 * consumer_pos;
private uint64 * producer_pos;
public BpfRingbufReader (BpfMap map) throws Error {
this.map = map;
var page_size = (size_t) Posix.getpagesize ();
int fd = map.fd;
void * mem = Posix.mmap (null, page_size, Posix.PROT_READ | Posix.PROT_WRITE, Posix.MAP_SHARED, fd, 0);
if (mem == Posix.MAP_FAILED)
throw_errno ("mmap(consumer) failed");
consumer_map = mem;
size_t prod_len = page_size + (2 * map.max_entries);
mem = Posix.mmap (null, prod_len, Posix.PROT_READ, Posix.MAP_SHARED, fd, (Posix.off_t) page_size);
if (mem == Posix.MAP_FAILED)
throw_errno ("mmap(producer+data) failed");
producer_map = mem;
producer_page = producer_map;
data_base = producer_map + page_size;
consumer_pos = consumer_map;
producer_pos = producer_page;
}
~BpfRingbufReader () {
var page_size = (size_t) Posix.getpagesize ();
if (consumer_map != null)
Posix.munmap (consumer_map, page_size);
if (producer_map != null)
Posix.munmap (producer_map, page_size + (2 * map.max_entries));
}
public DrainStatus drain (RecordHandler on_record) {
while (true) {
uint64 prod = Atomics.load_u64_acquire (producer_pos);
uint64 cons = Atomics.load_u64_acquire (consumer_pos);
if (cons >= prod)
return DRAINED;
size_t data_size = map.max_entries;
uint64 mask = data_size - 1;
uint64 off = cons & mask;
uint8 * hdrp = data_base + off;
uint32 hdr_len = Atomics.load_u32_acquire ((uint32 *) hdrp);
uint32 flags_mask = BpfRingbufFlags.BUSY | BpfRingbufFlags.DISCARD;
uint32 flags = hdr_len & flags_mask;
uint32 sample_len = hdr_len & ~flags_mask;
if ((flags & BpfRingbufFlags.BUSY) != 0)
return DRAINED;
assert (sample_len <= data_size - BPF_RINGBUF_HEADER_SIZE);
var total_len = (uint32) round_up_8 (sample_len + BPF_RINGBUF_HEADER_SIZE);
if ((flags & BpfRingbufFlags.DISCARD) != 0) {
Atomics.store_u64_release (consumer_pos, cons + total_len);
continue;
}
unowned uint8[] payload = (uint8[]) (hdrp + BPF_RINGBUF_HEADER_SIZE);
var action = on_record (payload[:sample_len]);
Atomics.store_u64_release (consumer_pos, cons + total_len);
if (action == STOP)
return STOPPED;
}
}
public enum DrainStatus {
DRAINED,
STOPPED,
}
public delegate RecordAction RecordHandler (uint8[] payload);
public enum RecordAction {
CONTINUE,
STOP,
}
}
namespace PerfEvent {
public FileDescriptor open (PerfEventAttr * attr, int pid, int cpu, int group_fd, uint flags) throws Error {
int r = Linux.syscall (LinuxSyscall.PERF_EVENT_OPEN, attr, pid, cpu, group_fd, flags);
if (r == -1)
throw_errno ("perf_event_open() failed");
return new FileDescriptor (r);
}
}
private void throw_errno (string message) throws Error {
throw new Error.NOT_SUPPORTED ("%s (errno=%d: %s)".printf (message, Posix.errno, Posix.strerror (Posix.errno)));
}
private size_t round_up_8 (size_t x) {
return (x + 7) & ~((size_t) 7);
}
}
+25 -2
View File
@@ -39,10 +39,29 @@ if host_os_family == 'darwin'
endif
if host_os_family == 'linux'
base_sources += 'linux.vala'
base_sources += [
'linux.vala',
]
extra_vala_args += [
'--pkg=linux',
'--pkg=linux-system',
'--pkg=frida-atomics',
'--pkg=libbpf',
]
syscall_arch_from_abi = {
'armbe': 'arm',
'armbe8': 'arm',
'armhf': 'arm',
'armv6kz': 'arm',
'arm64be': 'arm64',
'arm64beilp32': 'arm64',
'mipsel': 'mips',
'mips64el': 'mips64',
}
syscall_arch = syscall_arch_from_abi.get(host_abi, host_abi)
base_sources += [
'linux-syscalls' / (syscall_arch + '.vala'),
'linux-syscalls' / (syscall_arch + '-glue.c'),
]
endif
@@ -54,6 +73,9 @@ extra_deps = []
if host_os_family != 'windows'
extra_deps += gio_unix_dep
endif
if host_os_family == 'linux'
extra_deps += libbpf_dep
endif
base_vala_args = [gum_vala_args, '--pkg=gio-2.0', '--pkg=json-glib-1.0']
if nice_dep.found()
@@ -74,6 +96,7 @@ endif
if host_os_family == 'linux'
base_vala_args += [
'--vapidir=' + meson.current_source_dir(),
'--pkg=frida-linux',
'--pkg=gio-unix-2.0',
]
endif
+9
View File
@@ -381,6 +381,10 @@ else
gio_unix_dep = dependency('gio-unix-2.0')
endif
if host_os_family == 'linux'
libbpf_dep = dependency('libbpf')
endif
if host_os == 'android'
minizip_dep = dependency('minizip', required: false, default_options: [
'zlib=enabled',
@@ -610,6 +614,11 @@ if lzfse_dep.found()
backend_reqs_private += 'lzfse'
endif
if host_os_family == 'linux'
backend_deps_private += libbpf_dep
backend_reqs_private += 'libbpf'
endif
if host_os_family in ['darwin', 'freebsd'] or (host_os_family == 'linux' and cc.has_function('openpty', prefix: '#include <pty.h>'))
vala_flags += '--define=HAVE_OPENPTY'
endif
+1 -1
Submodule releng updated: 60585cf5cf...7ed66fe687.
+10 -3
View File
@@ -238,7 +238,8 @@ def emit_gir(api: ApiSpec, core_gir: str, base_gir: str, output_dir: Path) -> st
for elem in core_elements + base_elements:
if tag_name == "class":
for child in list(elem):
if (child.tag == CORE_TAG_IMPLEMENTS and child.get("name") in {"Frida.HostSessionHub", "FridaBase.AgentMessageSink"}) \
if (child.tag == CORE_TAG_IMPLEMENTS and child.get("name") in {"Frida.HostSessionHub", "Frida.AgentMessageSink",
"FridaBase.AgentMessageSink"}) \
or child.tag == CORE_TAG_FIELD \
or child.get("name").startswith("_"):
elem.remove(child)
@@ -327,11 +328,15 @@ def parse_api(frida_version, frida_version_components, api_version, toplevel_cod
}
internal_type_prefixes = [
"AgentMessageKind",
"DrainStatus",
"Fruity",
"HostSession",
"LinuxCompat32Syscall",
"LinuxSyscall",
"MessageType",
"PeerSetup",
"PortConflictBehavior",
"RecordAction",
"ResultCode",
"SpawnStartState",
"State",
@@ -501,7 +506,7 @@ def parse_api(frida_version, frida_version_components, api_version, toplevel_cod
def function_is_public(name):
return not name.startswith("_") and \
not name.startswith("throw_") and \
name not in [
name not in {
"generate_certificate",
"get_dbus_context",
"invalidate_dbus_context",
@@ -512,9 +517,11 @@ def function_is_public(name):
"parse_socket_address",
"negotiate_connection",
"check_kernel_version",
"get_syscall_signatures",
"get_compat32_syscall_signatures",
"make_stdio_pipes",
"make_stdio_pipe",
]
}
def parse_vala_object_types(source) -> List[ApiObjectType]:
return [ApiObjectType(m.group(3), m.group(2)) for m in OBJECT_TYPE_PATTERN.finditer(source, re.MULTILINE)]
+4 -4
View File
@@ -73,8 +73,8 @@ _frida_icon_from_native_image_scaled_to (FridaNativeImage native_image, guint ta
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "format", g_variant_new_string ("rgba"));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_int64 (target_width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_int64 (target_height));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_uint16 (target_width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_uint16 (target_height));
g_variant_builder_add (&builder, "{sv}", "image",
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, rep.bitmapData, rowstride * target_height, sizeof (guint8)));
result = g_variant_ref_sink (g_variant_builder_end (&builder));
@@ -136,8 +136,8 @@ _frida_icon_from_native_image_scaled_to (FridaNativeImage native_image, guint ta
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "format", g_variant_new_string ("rgba"));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_int64 (target_width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_int64 (target_height));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_uint16 (target_width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_uint16 (target_height));
g_variant_builder_add (&builder, "{sv}", "image",
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, CGBitmapContextGetData (cgctx), pixel_buf_size, sizeof (guint8)));
result = g_variant_ref_sink (g_variant_builder_end (&builder));
-2
View File
@@ -529,8 +529,6 @@ frida_add_app_icons (GHashTable * parameters, NSImage * image)
g_variant_builder_open (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "format", g_variant_new_string ("png"));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_int64 (size));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_int64 (size));
g_variant_builder_add (&builder, "{sv}", "image",
g_variant_new_from_data (G_VARIANT_TYPE ("ay"), png.bytes, png.length, TRUE, (GDestroyNotify) CFRelease, [png retain]));
g_variant_builder_close (&builder);
+30 -4
View File
@@ -120,8 +120,8 @@ namespace Frida {
construct {
var builder = new VariantBuilder (VariantType.VARDICT);
builder.add ("{sv}", "format", new Variant.string ("rgba"));
builder.add ("{sv}", "width", new Variant.int64 (16));
builder.add ("{sv}", "height", new Variant.int64 (16));
builder.add ("{sv}", "width", new Variant.uint16 (16));
builder.add ("{sv}", "height", new Variant.uint16 (16));
var image = new Bytes (Base64.decode ("AAAAAAAAAAAAAAAAAAAAAP///0DS4pz/////MP///0D///9A////MNflqP////9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8QzN6Q/7vTa/+vy1L/r8tS/7vTa//O4JXv////EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1eSkz6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/9XkpM8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8vfjcKrIRf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+qyEX/8PXeYAAAAAAAAAAAAAAAAAAAAAAAAAAA////QNLinL+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/97qt6////9AAAAAAAAAAAAAAAAA2eatv7vTa//G2oP/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf/M3pD/u9Nr/9nmrb8AAAAAAAAAANLinP+kxDn/u9Nr/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/u9Nr/6TEOf/S4pz/AAAAAAAAAADS4pz/pMQ5/7vTa/+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/7vTa/+kxDn/0uKc/wAAAAAAAAAA0uKc/6TEOf+702v/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+702v/pMQ5/9LinP8AAAAAAAAAANLinP+kxDn/u9Nr/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/u9Nr/6TEOf/S4pz/AAAAAAAAAADO4JXvpMQ5/8DWd/+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/8DWd/+kxDn/zuCV7wAAAAAAAAAA7fPXUNLinIDl7sbfpMQ5/6TEOf+kxDn/pMQ5/6TEOf+kxDn/pMQ5/6TEOf/l7sbf0uKcgO3z11AAAAAAAAAAAAAAAAAAAAAA8PXeYMDWd/+qyEX/pMQ5/6/LUv+vy1L/pMQ5/6rIRf/A1nf/7fPXUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu9Nr/6TEOf/C2Hu/wth7v6TEOf+702v/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALvTa/+kxDn/wth7v8LYe7+kxDn/u9Nr/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADc6LPPu9Nr/+HrvY/h672Pu9Nr/9nmrb8AAAAAAAAAAAAAAAAAAAAAAAAAAA=="));
builder.add ("{sv}", "image", Variant.new_from_data (new VariantType ("ay"), image.get_data (), true, image));
_icon = builder.end ();
@@ -183,10 +183,17 @@ namespace Frida {
public async ServiceSession link_service_session (HostSession host_session, ServiceSessionId id, Cancellable? cancellable)
throws Error, IOError {
throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
if (host_session != this.host_session)
throw new Error.INVALID_ARGUMENT ("Invalid host session");
return yield this.host_session.link_service_session (id, cancellable);
}
public void unlink_service_session (HostSession host_session, ServiceSessionId id) {
if (host_session != this.host_session)
return;
this.host_session.unlink_service_session (id);
}
private void on_agent_session_detached (AgentSessionId id, SessionDetachReason reason, CrashInfo crash) {
@@ -244,6 +251,8 @@ namespace Frida {
private ChannelRegistry channel_registry = new ChannelRegistry ();
private ServiceSessionRegistry service_session_registry = new ServiceSessionRegistry ();
private Cancellable io_cancellable = new Cancellable ();
private const double MIN_SERVER_CHECK_INTERVAL = 5.0;
@@ -764,7 +773,24 @@ namespace Frida {
}
public async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
var server = yield get_remote_server (cancellable);
try {
return yield server.session.open_service (address, cancellable);
} catch (GLib.Error e) {
throw_dbus_error (e);
}
}
public async ServiceSession link_service_session (ServiceSessionId id, Cancellable? cancellable) throws Error, IOError {
var server = yield get_remote_server (cancellable);
ServiceSession session = yield server.connection.get_proxy (null, ObjectPath.for_service_session (id),
DO_NOT_LOAD_PROPERTIES, cancellable);
service_session_registry.register (id, session);
return session;
}
public void unlink_service_session (ServiceSessionId id) {
service_session_registry.unlink (id);
}
private void on_gadget_entry_detached (GadgetEntry entry, SessionDetachReason reason) {
+19 -2
View File
@@ -361,10 +361,17 @@ namespace Frida {
public async ServiceSession link_service_session (HostSession host_session, ServiceSessionId id, Cancellable? cancellable)
throws Error, IOError {
throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
if (host_session != this.host_session)
throw new Error.INVALID_ARGUMENT ("Invalid host session");
return this.host_session.link_service_session (id);
}
public void unlink_service_session (HostSession host_session, ServiceSessionId id) {
if (host_session != this.host_session)
return;
this.host_session.unlink_service_session (id);
}
private void on_agent_session_detached (AgentSessionId id, SessionDetachReason reason, CrashInfo crash) {
@@ -397,6 +404,8 @@ namespace Frida {
protected Injector injector;
protected Gee.HashMap<uint, uint> injectee_by_pid = new Gee.HashMap<uint, uint> ();
protected ServiceSessionRegistry service_session_registry = new ServiceSessionRegistry ();
protected Cancellable io_cancellable = new Cancellable ();
public virtual async void preload (Cancellable? cancellable) throws Error, IOError {
@@ -947,10 +956,18 @@ namespace Frida {
throw new Error.NOT_SUPPORTED ("Channels are not supported by this backend");
}
public async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
public virtual async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
}
public ServiceSession link_service_session (ServiceSessionId id) throws Error {
return service_session_registry.link (id);
}
public void unlink_service_session (ServiceSessionId id) {
service_session_registry.unlink (id);
}
#if !WINDOWS
public async HostChildId prepare_to_fork (uint parent_pid, Cancellable? cancellable, out uint parent_injectee_id,
out uint child_injectee_id, out GLib.Socket child_socket) throws Error, IOError {
+105
View File
@@ -0,0 +1,105 @@
public sealed class Frida.ActivitySampler : Object {
public uint pid {
get;
construct;
}
private BpfRingbufReader? events_reader;
private Source? events_source;
private Gee.Collection<FileDescriptor> perf_event_fds = new Gee.ArrayList<FileDescriptor> ();
private Gee.Collection<BpfLink> links = new Gee.ArrayList<BpfLink> ();
public ActivitySampler (uint pid) {
Object (pid: pid);
}
protected override void dispose () {
stop ();
base.dispose ();
}
public void start () throws Error {
var obj = BpfObject.open ("activity-sampler.elf", Frida.Data.HelperBackend.get_activity_sampler_elf_blob ().data);
var target_tgid = obj.maps.get_by_name ("target_tgid");
var events = obj.maps.get_by_name ("events");
obj.prepare ();
target_tgid.update_u32_u32 (0, pid);
events_reader = new BpfRingbufReader (events);
obj.load ();
BpfProgram program = obj.programs.get_by_name ("on_perf_event");
uint ncpus = get_num_processors ();
for (uint cpu = 0; cpu != ncpus; cpu++) {
var pea = PerfEventAttr ();
pea.event_type = SOFTWARE;
pea.size = (uint32) sizeof (PerfEventAttr);
pea.config = PERF_EVENT_COUNT_SW_CPU_CLOCK;
pea.sample_period = 1;
var pefd = PerfEvent.open (&pea, -1, (int) cpu, -1, 0);
perf_event_fds.add (pefd);
var link = program.attach_perf_event (pefd);
links.add (link);
}
var ch = new IOChannel.unix_new (events.fd);
var src = new IOSource (ch, IN);
var state = new WatchState (this, events_reader);
src.set_callback (state.on_ready);
src.attach (MainContext.get_thread_default ());
events_source = src;
}
public void stop () {
events_source?.destroy ();
events_source = null;
links.clear ();
events_reader = null;
}
private void handle_sample (SampleEvent * e) {
printerr ("[ActivitySampler %p] tgid=%u tid=%u time=%" + uint64.FORMAT + " stack_err=%d depth=%u\n",
this, e->tgid, e->tid, e->time_ns, e->stack_err, e->depth);
for (uint32 i = 0; i != e->depth; i++)
printerr ("\t0x%lx\n", (ulong) e->ips[i]);
}
private struct SampleEvent {
public uint64 time_ns;
public uint32 tgid;
public uint32 tid;
public int32 stack_err;
public uint32 depth;
public uint64 ips[16];
}
private class WatchState : Object {
public unowned ActivitySampler sampler;
public BpfRingbufReader reader;
public WatchState (ActivitySampler sampler, BpfRingbufReader reader) {
this.sampler = sampler;
this.reader = reader;
}
public bool on_ready (IOChannel ch, IOCondition cond) {
reader.drain (payload => {
assert (payload.length == sizeof (SampleEvent));
sampler.handle_sample ((SampleEvent *) payload);
return CONTINUE;
});
return Source.CONTINUE;
}
}
}
+10 -10
View File
@@ -3,17 +3,17 @@
#include <sys/syscall.h>
gboolean
_frida_syscall_satisfies (gint syscall_id, FridaLinuxSyscall mask)
_frida_syscall_satisfies (gint syscall_id, FridaLinuxSyscallMask mask)
{
switch (syscall_id)
{
case __NR_restart_syscall:
return (mask & FRIDA_LINUX_SYSCALL_RESTART) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_RESTART) != 0;
case __NR_ioctl:
return (mask & FRIDA_LINUX_SYSCALL_IOCTL) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_IOCTL) != 0;
case __NR_read:
case __NR_readv:
return (mask & FRIDA_LINUX_SYSCALL_READ) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_READ) != 0;
#ifdef __NR_select
case __NR_select:
#endif
@@ -44,7 +44,7 @@ _frida_syscall_satisfies (gint syscall_id, FridaLinuxSyscall mask)
#ifdef __NR_epoll_pwait2
case __NR_epoll_pwait2:
#endif
return (mask & FRIDA_LINUX_SYSCALL_POLL_LIKE) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_POLL_LIKE) != 0;
#ifdef __NR_wait4
case __NR_wait4:
#endif
@@ -52,21 +52,21 @@ _frida_syscall_satisfies (gint syscall_id, FridaLinuxSyscall mask)
case __NR_waitpid:
#endif
case __NR_waitid:
return (mask & FRIDA_LINUX_SYSCALL_WAIT) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_WAIT) != 0;
case __NR_rt_sigtimedwait:
#ifdef __NR_rt_sigtimedwait_time64
case __NR_rt_sigtimedwait_time64:
#endif
return (mask & FRIDA_LINUX_SYSCALL_SIGWAIT) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_SIGWAIT) != 0;
case __NR_futex:
return (mask & FRIDA_LINUX_SYSCALL_FUTEX) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_FUTEX) != 0;
#ifdef __NR_accept
case __NR_accept:
#endif
#ifdef __NR_accept4
case __NR_accept4:
#endif
return (mask & FRIDA_LINUX_SYSCALL_ACCEPT) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_ACCEPT) != 0;
#ifdef __NR_recv
case __NR_recv:
#endif
@@ -82,7 +82,7 @@ _frida_syscall_satisfies (gint syscall_id, FridaLinuxSyscall mask)
#ifdef __NR_recvmmsg_time64
case __NR_recvmmsg_time64:
#endif
return (mask & FRIDA_LINUX_SYSCALL_RECV) != 0;
return (mask & FRIDA_LINUX_SYSCALL_MASK_RECV) != 0;
default:
break;
}
+21 -178
View File
@@ -219,15 +219,15 @@ namespace Frida {
}
}
public async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError {
public async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError {
yield perform<PausedSyscallSession> (new AwaitSyscallTask (this, mask), pid, cancellable);
}
private class AwaitSyscallTask : Object, Task<PausedSyscallSession> {
private weak LinuxHelperBackend backend;
private LinuxSyscall mask;
private LinuxSyscallMask mask;
public AwaitSyscallTask (LinuxHelperBackend backend, LinuxSyscall mask) {
public AwaitSyscallTask (LinuxHelperBackend backend, LinuxSyscallMask mask) {
this.backend = backend;
this.mask = mask;
}
@@ -738,7 +738,7 @@ namespace Frida {
return session;
}
public async void wait_for_syscall (LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError {
public async void wait_for_syscall (LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError {
bool on_syscall_entry = true;
int pending_signal = 0;
while (state != SATISFIED) {
@@ -1055,15 +1055,15 @@ namespace Frida {
uint64 remote_munmap = 0;
ProcMapsSoEntry? remote_libc = ProcMapsSoEntry.find_by_path (pid, local_libc.path);
#if ANDROID
bool same_libc = false;
if (remote_libc != null) {
bool same_device = remote_libc.identity.split (":")[0] == local_libc.identity.split (":")[0];
bool same_inode = remote_libc.identity.split (" ")[1] == local_libc.identity.split (" ")[1];
bool same_path = remote_libc.path == local_libc.path;
same_libc = same_device && same_inode && same_path;
}
bool same_libc = remote_libc != null
&& remote_libc.device.major == local_libc.device.major
&& remote_libc.inode == local_libc.inode
&& remote_libc.path == local_libc.path;
#else
bool same_libc = remote_libc != null && remote_libc.identity == local_libc.identity;
bool same_libc = remote_libc != null
&& remote_libc.device.equals (local_libc.device)
&& remote_libc.inode == local_libc.inode
&& remote_libc.path == local_libc.path;
#endif
if (same_libc) {
remote_mmap = remote_libc.base_address + mmap_offset;
@@ -1166,7 +1166,9 @@ namespace Frida {
if (result.context.rtld_flavor == ANDROID && result.libc.dlopen == null) {
ProcMapsSoEntry? remote_ld = ProcMapsSoEntry.find_by_address (pid, (uintptr) result.context.rtld_base);
bool same_ld = remote_ld != null && local_android_ld != null && remote_ld.identity == local_android_ld.identity;
bool same_ld = remote_ld != null && local_android_ld != null
&& remote_ld.device.equals (local_android_ld.device)
&& remote_ld.inode == local_android_ld.inode;
if (!same_ld)
throw new Error.NOT_SUPPORTED ("Unable to locate Android dynamic linker; please file a bug");
result.libc.dlopen = rebase_pointer ((uintptr) dlopen, local_android_ld, remote_ld);
@@ -2225,8 +2227,8 @@ namespace Frida {
[CCode (array_length_type = "unsigned long")]
Posix.iovector[] remote_iov,
ulong flags) {
return Linux.syscall (SysCall.process_vm_readv, pid, local_iov, local_iov.length, remote_iov, remote_iov.length,
flags);
return Linux.syscall (LinuxSyscall.PROCESS_VM_READV, pid, local_iov, local_iov.length, remote_iov,
remote_iov.length, flags);
}
private static ssize_t process_vm_writev_impl (uint pid,
@@ -2235,8 +2237,8 @@ namespace Frida {
[CCode (array_length_type = "unsigned long")]
Posix.iovector[] remote_iov,
ulong flags) {
return Linux.syscall (SysCall.process_vm_writev, pid, local_iov, local_iov.length, remote_iov, remote_iov.length,
flags);
return Linux.syscall (LinuxSyscall.PROCESS_VM_WRITEV, pid, local_iov, local_iov.length, remote_iov,
remote_iov.length, flags);
}
}
@@ -3235,169 +3237,10 @@ namespace Frida {
}
private int tgkill (uint tgid, uint tid, Posix.Signal sig) {
return Linux.syscall (SysCall.tgkill, tgid, tid, sig);
return Linux.syscall (LinuxSyscall.TGKILL, tgid, tid, sig);
}
public extern bool _syscall_satisfies (int syscall_id, LinuxSyscall mask);
public class ProcMapsSoEntry {
public uint64 base_address;
public string path;
public string identity;
private ProcMapsSoEntry (uint64 base_address, string path, string identity) {
this.base_address = base_address;
this.path = path;
this.identity = identity;
}
public static ProcMapsSoEntry? find_by_address (uint pid, uint64 address) {
var iter = ProcMapsIter.for_pid (pid);
while (iter.next ()) {
uint64 start = iter.start_address;
uint64 end = iter.end_address;
if (address >= start && address < end)
return new ProcMapsSoEntry (start, iter.path, iter.identity);
}
return null;
}
public static ProcMapsSoEntry? find_by_path (uint pid, string path) {
var candidates = new Gee.ArrayList<Candidate> ();
Candidate? latest_candidate = null;
var iter = ProcMapsIter.for_pid (pid);
#if ANDROID
unowned string libc_path = Gum.Process.get_libc_module ().path;
#endif
while (iter.next ()) {
string current_path = iter.path;
if (current_path == "[page size compat]")
continue;
if (current_path != path) {
latest_candidate = null;
continue;
}
string flags = iter.flags;
#if ANDROID
if (current_path == libc_path && flags[3] == 's')
continue;
#endif
if (iter.file_offset == 0) {
latest_candidate = new Candidate () {
entry = new ProcMapsSoEntry (iter.start_address, current_path, iter.identity),
total_ranges = 0,
executable_ranges = 0,
};
candidates.add (latest_candidate);
}
if (latest_candidate != null) {
latest_candidate.total_ranges++;
if (flags[2] == 'x')
latest_candidate.executable_ranges++;
}
}
candidates.sort ((a, b) => b.score () - a.score ());
if (candidates.is_empty)
return null;
return candidates.first ().entry;
}
private class Candidate {
public ProcMapsSoEntry entry;
public uint total_ranges;
public uint executable_ranges;
public int score () {
int result = (int) total_ranges;
if (executable_ranges == 0)
result = -result;
return result;
}
}
}
public sealed class ProcMapsIter {
private string? contents;
private MatchInfo? info;
private uint offset = 0;
public uint64 start_address {
get {
return uint64.parse (info.fetch (1), 16);
}
}
public uint64 end_address {
get {
return uint64.parse (info.fetch (2), 16);
}
}
public string flags {
owned get {
return info.fetch (3);
}
}
public uint64 file_offset {
get {
return uint64.parse (info.fetch (4), 16);
}
}
public string identity {
owned get {
return info.fetch (5);
}
}
public string path {
owned get {
return info.fetch (6);
}
}
public static ProcMapsIter for_pid (uint pid) {
return new ProcMapsIter (pid);
}
private ProcMapsIter (uint pid) {
try {
FileUtils.get_contents ("/proc/%u/maps".printf (pid), out contents);
} catch (FileError e) {
return;
}
if (!/^([0-9a-f]+)-([0-9a-f]+) (\S{4}) ([0-9a-f]+) ([0-9a-f]{2,}:[0-9a-f]{2,} \d+) +([^\n]+)$/m.match (
contents, 0, out info)) {
assert_not_reached ();
}
}
public bool next () {
if (info == null)
return false;
if (offset > 0) {
try {
info.next ();
} catch (RegexError e) {
return false;
}
}
offset++;
return info.matches ();
}
}
public extern bool _syscall_satisfies (int syscall_id, LinuxSyscallMask mask);
private size_t round_size_to_page_size (size_t size) {
size_t page_size = Gum.query_page_size ();
+2 -2
View File
@@ -62,7 +62,7 @@ namespace Frida {
yield helper.cancel_exec_transition (pid, cancellable);
}
public async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError {
public async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError {
var helper = yield obtain_for_pid (pid, cancellable);
yield helper.await_syscall (pid, mask, cancellable);
}
@@ -514,7 +514,7 @@ namespace Frida {
}
}
public async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError {
public async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError {
try {
yield proxy.await_syscall (pid, mask, cancellable);
} catch (GLib.Error e) {
+1 -1
View File
@@ -136,7 +136,7 @@ namespace Frida {
yield backend.cancel_exec_transition (pid, cancellable);
}
public async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError {
public async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError {
yield backend.await_syscall (pid, mask, cancellable);
}
+3 -3
View File
@@ -9,7 +9,7 @@ namespace Frida {
public abstract async void prepare_exec_transition (uint pid, Cancellable? cancellable) throws Error, IOError;
public abstract async void await_exec_transition (uint pid, Cancellable? cancellable) throws Error, IOError;
public abstract async void cancel_exec_transition (uint pid, Cancellable? cancellable) throws Error, IOError;
public abstract async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws Error, IOError;
public abstract async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws Error, IOError;
public abstract async void resume_syscall (uint pid, Cancellable? cancellable) throws Error, IOError;
public abstract async void input (uint pid, uint8[] data, Cancellable? cancellable) throws Error, IOError;
public abstract async void resume (uint pid, Cancellable? cancellable) throws Error, IOError;
@@ -25,7 +25,7 @@ namespace Frida {
}
[Flags]
public enum LinuxSyscall {
public enum LinuxSyscallMask {
RESTART,
IOCTL,
READ,
@@ -53,7 +53,7 @@ namespace Frida {
public abstract async void prepare_exec_transition (uint pid, Cancellable? cancellable) throws GLib.Error;
public abstract async void await_exec_transition (uint pid, Cancellable? cancellable) throws GLib.Error;
public abstract async void cancel_exec_transition (uint pid, Cancellable? cancellable) throws GLib.Error;
public abstract async void await_syscall (uint pid, LinuxSyscall mask, Cancellable? cancellable) throws GLib.Error;
public abstract async void await_syscall (uint pid, LinuxSyscallMask mask, Cancellable? cancellable) throws GLib.Error;
public abstract async void resume_syscall (uint pid, Cancellable? cancellable) throws GLib.Error;
public abstract async void input (uint pid, uint8[] data, Cancellable? cancellable) throws GLib.Error;
public abstract async void resume (uint pid, Cancellable? cancellable) throws GLib.Error;
+151 -8
View File
@@ -4,6 +4,18 @@ releng := $(top_srcdir)/releng
BUILDDIR ?= $(top_srcdir)/build
MESON ?= $(releng)/meson/meson.py
ifeq ($(shell uname -s),Darwin)
KERNEL_MAKE ?= gmake
KERNEL_SED ?= gsed
KERNEL_AWK ?= gawk
BPF_CLANG ?= /Applications/AndroidNDK14206865.app/Contents/NDK/toolchains/llvm/prebuilt/darwin-x86_64/bin/clang
else
KERNEL_MAKE ?= make
KERNEL_SED ?= sed
KERNEL_AWK ?= awk
BPF_CLANG ?= clang
endif
ifdef FRIDA_HOST
host_machine := $(FRIDA_HOST)
else
@@ -11,17 +23,138 @@ host_machine := $(shell basename $$(ls -1 $(BUILDDIR)/frida-linux-*.txt | tail -
endif
host_arch := $(shell echo $(host_machine) | cut -d"-" -f2)
crossfile := $(BUILDDIR)/frida-$(host_machine).txt
crossfile := $(BUILDDIR)/$(host_machine)/frida-$(host_machine).txt
valac := $(shell grep "vala = " $(crossfile) | cut -c9- | sed -e "s/.$$//" -e "s/,//g")
build: ext/linux/tools/include/nolibc/nolibc.h
artifacts_dir := artifacts
build_dir := build
native_outdir := $(artifacts_dir)/native/$(host_arch)
bpf_outdir := $(artifacts_dir)/bpf
bpf_noarch_progs := \
activity-sampler \
softwall \
$(NULL)
bpf_arch_progs := \
syscall-tracer \
$(NULL)
bpf_noarch_pairs := \
big:bpfeb \
little:bpfel
bpf_arch_pairs := \
x86:bpfel x86_64:bpfel \
arm:bpfel armbe:bpfeb arm64:bpfel arm64be:bpfeb \
mips:bpfeb mipsel:bpfel mips64:bpfeb mips64el:bpfel \
$(NULL)
build-native: ext/linux/tools/include/nolibc/nolibc.h
rm -rf build
$(MESON) setup --cross-file $(crossfile) -Db_lto=true build
$(MESON) compile -C build
install -m644 build/bootstrapper.bin bootstrapper-$(host_arch).bin
install -m644 build/loader.bin loader-$(host_arch).bin
[ -f build/zymbiote.bin ] && install -m644 build/zymbiote.bin zymbiote-$(host_arch).bin || true
install -m644 build/bootstrapper.bin $(native_outdir)/bootstrapper.bin
install -m644 build/loader.bin $(native_outdir)/loader.bin
[ -f build/zymbiote.bin ] && install -m644 build/zymbiote.bin $(native_outdir)/zymbiote.bin || true
ext/linux/tools/include/nolibc/nolibc.h: nolibc-tweaks.patch
bpf_targets :=
bpf_obj := $(build_dir)/module.o
kernel_headers_dir := ext/kernel-headers
noarch_uapi_arch ?= x86
linux_uapi_arch = $(strip \
$(if $(filter x86 x86_64,$1),x86, \
$(if $(filter arm armbe,$1),arm, \
$(if $(filter arm64 arm64be,$1),arm64, \
$(if $(filter mips mipsel mips64 mips64el,$1),mips,unknown)))))
kernel_headers_stamp = $(kernel_headers_dir)/$(1)/.stamp
kernel_headers_for = $(call kernel_headers_stamp,$(call linux_uapi_arch,$(1)))
kernel_uapi_arches := x86 arm arm64 mips
kernel_uapi_stamps := $(foreach a,$(kernel_uapi_arches),$(call kernel_headers_stamp,$(a)))
$(call kernel_headers_stamp,%): ext/linux/tools/include/nolibc/nolibc.h
@mkdir -p $(kernel_headers_dir)/$*
@$(KERNEL_MAKE) -C ext/linux \
ARCH=$* \
SED=$(KERNEL_SED) \
AWK=$(KERNEL_AWK) \
headers_install INSTALL_HDR_PATH=$(abspath $(kernel_headers_dir)/$*)
@touch $@
libbpf_devel_url := https://kojipkgs.fedoraproject.org//packages/libbpf/1.6.3/1.fc44/x86_64/libbpf-devel-1.6.3-1.fc44.x86_64.rpm
libbpf_devel_rpm := $(notdir $(libbpf_devel_url))
libbpf_devel_dir := ext/libbpf
define recreate_build_dir
rm -rf $(build_dir)
mkdir -p $(build_dir)
endef
define bpf_compile
$(BPF_CLANG) \
-target $(1) \
-D__TARGET_ARCH_$(2) \
-O2 -g \
-I$(build_dir) \
-I$(libbpf_devel_dir) \
-isystem $(kernel_headers_dir)/$(2)/include \
-isystem $(kernel_headers_dir)/$(2)/include/uapi \
-isystem $(kernel_headers_dir)/$(2)/include/asm-generic \
$< \
-c \
-o $(bpf_obj)
mkdir -p $(@D)
install -m644 $(bpf_obj) $@
endef
define declare_bpf_noarch
bpf_targets += $(foreach p,$(bpf_noarch_progs),$(bpf_outdir)/noarch-$(1)/$(p).elf)
$(bpf_outdir)/noarch-$(1)/%.elf: %.bpf.c $(call kernel_headers_stamp,$(noarch_uapi_arch)) $(libbpf_devel_dir)
$$(call recreate_build_dir)
$$(call bpf_compile,$(2),$(noarch_uapi_arch))
endef
define declare_bpf_arch
bpf_targets += $(foreach p,$(bpf_arch_progs),$(bpf_outdir)/$(1)/$(p).elf)
$(bpf_outdir)/$(1)/%.elf: %.bpf.c $(call kernel_headers_for,$(1)) $(libbpf_devel_dir)
$$(call recreate_build_dir)
syscalls_dir=$$(realpath $(top_srcdir)/lib/base/linux-syscalls); \
cd build && \
$$(valac) \
-C \
--header=frida-linux-syscalls.h \
--profile=posix \
$$$${syscalls_dir}/$(shell echo $(1) | sed -e 's/be$$//' -e 's/el$$//').vala && \
$(KERNEL_AWK) ' \
/typedef[[:space:]]+enum[[:space:]]*\{/ { in_enum=1; next } \
in_enum && /^[[:space:]]*}/ { in_enum=0; next } \
in_enum { \
if (match($$$$0, /^[[:space:]]*([A-Z0-9_]+)[[:space:]]*=[[:space:]]*([^,[:space:]]+)[[:space:]]*,?[[:space:]]*$$$$/, m)) \
print "#define " m[1] " " m[2]; \
next; \
} \
{ print } \
' frida-linux-syscalls.h > frida-linux-syscalls.h.tmp && \
mv frida-linux-syscalls.h.tmp frida-linux-syscalls.h
$$(call bpf_compile,$(2),$$(call linux_uapi_arch,$(1)))
endef
pair_abi = $(word 1,$(subst :, ,$1))
pair_target = $(word 2,$(subst :, ,$1))
$(foreach pair,$(bpf_noarch_pairs), \
$(eval $(call declare_bpf_noarch,$(call pair_abi,$(pair)),$(call pair_target,$(pair)))))
$(foreach pair,$(bpf_arch_pairs), \
$(eval $(call declare_bpf_arch,$(call pair_abi,$(pair)),$(call pair_target,$(pair)))))
build-bpf: $(bpf_targets)
ext/linux/tools/include/nolibc/nolibc.h: patches/linux-headers-install-portability.patch patches/linux-nolibc-tweaks.patch
if [ -d ext/linux ]; then \
cd ext/linux; \
git reset --hard; \
@@ -29,7 +162,17 @@ ext/linux/tools/include/nolibc/nolibc.h: nolibc-tweaks.patch
else \
git clone --branch=v6.2 --depth=1 https://github.com/torvalds/linux.git ext/linux; \
fi
patch -d ext/linux -p1 < nolibc-tweaks.patch
for fix in $^; do \
patch -d ext/linux -p1 < $${fix}; \
done
@touch -c $@
.PHONY: build
$(libbpf_devel_dir):
mkdir -p $(libbpf_devel_dir)
curl -L -o $(libbpf_devel_rpm) $(libbpf_devel_url)
rpm2cpio -f pax $(libbpf_devel_rpm) | tar -xpf - \
-C $(libbpf_devel_dir) \
--strip-components=3
rm -f $(libbpf_devel_rpm)
.PHONY: build-native build-bpf
+75
View File
@@ -0,0 +1,75 @@
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#define MAX_DEPTH 16
struct
{
__uint (type, BPF_MAP_TYPE_ARRAY);
__uint (max_entries, 1);
__type (key, __u32);
__type (value, __u32);
}
target_tgid SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_RINGBUF);
__uint (max_entries, 1 << 22);
}
events SEC (".maps");
typedef struct _SampleEvent SampleEvent;
struct _SampleEvent
{
__u64 time_ns;
__u32 tgid;
__u32 tid;
__s32 stack_err;
__u32 depth;
__u64 ips[MAX_DEPTH];
};
SEC ("perf_event")
int
on_perf_event (struct bpf_perf_event_data * ctx)
{
__u32 k0 = 0;
__u32 * target = bpf_map_lookup_elem (&target_tgid, &k0);
if (target == NULL)
return 0;
__u64 pid_tgid = bpf_get_current_pid_tgid ();
__u32 tid = (__u32) pid_tgid;
__u32 tgid = pid_tgid >> 32;
if (tgid != *target)
return 0;
SampleEvent * e = bpf_ringbuf_reserve (&events, sizeof (SampleEvent), 0);
if (e == NULL)
return 0;
e->time_ns = bpf_ktime_get_ns ();
e->tgid = tgid;
e->tid = tid;
int nbytes = bpf_get_stack (ctx, e->ips, sizeof (e->ips), BPF_F_USER_STACK);
if (nbytes < 0)
{
e->stack_err = nbytes;
e->depth = 0;
bpf_ringbuf_submit (e, 0);
return 0;
}
e->stack_err = 0;
e->depth = (__u32) (nbytes / (int) sizeof (__u64));
bpf_ringbuf_submit (e, 0);
return 0;
}
char LICENSE[] SEC ("license") = "Dual BSD/GPL";
@@ -0,0 +1,33 @@
diff --git a/scripts/headers_install.sh b/scripts/headers_install.sh
index 404188174..6adb0a5b4 100755
--- a/scripts/headers_install.sh
+++ b/scripts/headers_install.sh
@@ -20,16 +20,17 @@ fi
INFILE=$1
OUTFILE=$2
TMPFILE=$OUTFILE.tmp
+: "${SED:=sed}"
trap 'rm -f $OUTFILE $TMPFILE' EXIT
# SPDX-License-Identifier with GPL variants must have "WITH Linux-syscall-note"
-if [ -n "$(sed -n -e "/SPDX-License-Identifier:.*GPL-/{/WITH Linux-syscall-note/!p}" $INFILE)" ]; then
+if [ -n "$("$SED" -n -e "/SPDX-License-Identifier:.*GPL-/{/WITH Linux-syscall-note/!p}" $INFILE)" ]; then
echo "error: $INFILE: missing \"WITH Linux-syscall-note\" for SPDX-License-Identifier" >&2
exit 1
fi
-sed -E -e '
+"$SED" -E -e '
s/([[:space:](])(__user|__force|__iomem)[[:space:]]/\1/g
s/__attribute_const__([[:space:]]|$)/\1/g
s@^#include <linux/compiler(|_types).h>@@
@@ -42,7 +43,7 @@ scripts/unifdef -U__KERNEL__ -D__EXPORTED_HEADERS__ $TMPFILE > $OUTFILE
[ $? -gt 1 ] && exit 1
# Remove /* ... */ style comments, and find CONFIG_ references in code
-configs=$(sed -e '
+configs=$("$SED" -e '
:comment
s:/\*[^*][^*]*:/*:
s:/\*\*\**\([^/]\):/*\1:
+275
View File
@@ -0,0 +1,275 @@
#include <stdbool.h>
#include <stdint.h>
#include <linux/bpf.h>
#include <bpf/bpf_core_read.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#define MAX_TARGET_TGIDS 4096
#define MAX_TARGET_UIDS 256
#define MAX_RULES 4096
#define MAX_INODE_INDEX 8192
#define MAX_AUDIT_EVENTS (1 << 20)
typedef struct _Event Event;
typedef __u16 EventType;
typedef struct _AuditEvent AuditEvent;
typedef struct _InodeKey InodeKey;
typedef struct _FileOpenRule FileOpenRule;
typedef struct _Stats Stats;
struct _Event
{
__u64 time_ns;
__u32 tgid;
__u32 tid;
EventType type;
__u16 _pad0;
};
enum _EventType
{
EVENT_TYPE_AUDIT
};
struct _AuditEvent
{
Event parent;
__u32 rule_id;
__u32 _pad0;
};
struct _InodeKey
{
__u64 dev;
__u64 ino;
};
struct _FileOpenRule
{
__u64 dev;
__u64 ino;
__s32 errno_neg;
__u32 _pad0;
};
struct _Stats
{
__u64 emitted_events;
__u64 emitted_bytes;
__u64 dropped_events;
__u64 dropped_bytes;
};
struct
{
__uint (type, BPF_MAP_TYPE_HASH);
__uint (max_entries, MAX_TARGET_TGIDS);
__type (key, __u32);
__type (value, __u8);
}
target_tgids SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_HASH);
__uint (max_entries, MAX_TARGET_UIDS);
__type (key, __u32);
__type (value, __u8);
}
target_uids SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_HASH);
__uint (max_entries, MAX_RULES);
__type (key, __u32);
__type (value, FileOpenRule);
}
rules_by_id SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_HASH);
__uint (max_entries, MAX_INODE_INDEX);
__type (key, InodeKey);
__type (value, __u32);
}
inode_index SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_RINGBUF);
__uint (max_entries, MAX_AUDIT_EVENTS);
}
audit_events SEC (".maps");
struct
{
__uint (type, BPF_MAP_TYPE_PERCPU_ARRAY);
__uint (max_entries, 1);
__type (key, __u32);
__type (value, Stats);
}
stats SEC (".maps");
typedef __u32 dev_t;
struct super_block
{
dev_t s_dev;
} __attribute__ ((preserve_access_index));
struct inode
{
struct super_block * i_sb;
unsigned long i_ino;
} __attribute__ ((preserve_access_index));
struct file
{
struct inode * f_inode;
} __attribute__ ((preserve_access_index));
static bool should_enforce_current (__u32 * out_tgid, __u32 * out_tid);
static Stats * get_ringbuf_stats (void);
static void note_emit (Stats * stats, __u64 bytes);
static void note_drop (Stats * stats, __u64 wanted_bytes);
static AuditEvent * reserve_audit_event (void);
static bool get_file_inode_key (struct file * file, InodeKey * out_key);
SEC ("lsm/file_open")
int
BPF_PROG (on_file_open, struct file * file)
{
__u32 tgid, tid;
if (!should_enforce_current (&tgid, &tid))
return 0;
InodeKey key;
if (!get_file_inode_key (file, &key))
return 0;
__u32 * rule_id = bpf_map_lookup_elem (&inode_index, &key);
if (rule_id == NULL)
return 0;
FileOpenRule * rule = bpf_map_lookup_elem (&rules_by_id, rule_id);
if (rule == NULL)
return 0;
AuditEvent * ev = reserve_audit_event ();
if (ev != NULL)
{
ev->parent.time_ns = bpf_ktime_get_ns ();
ev->parent.tgid = tgid;
ev->parent.tid = tid;
ev->parent.type = EVENT_TYPE_AUDIT;
ev->rule_id = *rule_id;
ev->_pad0 = 0;
bpf_ringbuf_submit (ev, 0);
}
return rule->errno_neg;
}
static bool
should_enforce_current (__u32 * out_tgid, __u32 * out_tid)
{
__u64 pid_tgid = bpf_get_current_pid_tgid ();
__u32 tgid = pid_tgid >> 32;
__u32 tid = (__u32) pid_tgid;
*out_tgid = tgid;
*out_tid = tid;
__u8 * tgid_enabled = bpf_map_lookup_elem (&target_tgids, &tgid);
if (tgid_enabled != NULL)
return true;
__u64 uid_gid = bpf_get_current_uid_gid ();
__u32 uid = (__u32) uid_gid;
__u8 * uid_enabled = bpf_map_lookup_elem (&target_uids, &uid);
if (uid_enabled != NULL)
return true;
return false;
}
static bool
get_file_inode_key (struct file * file, InodeKey * out_key)
{
if (file == NULL)
return false;
struct inode * inode = BPF_CORE_READ (file, f_inode);
if (inode == NULL)
return false;
out_key->dev = BPF_CORE_READ (inode, i_sb, s_dev);
out_key->ino = BPF_CORE_READ (inode, i_ino);
return true;
}
static AuditEvent *
reserve_audit_event (void)
{
void * event = bpf_ringbuf_reserve (&audit_events, sizeof (AuditEvent), 0);
Stats * stats = get_ringbuf_stats ();
if (event != NULL)
note_emit (stats, sizeof (AuditEvent));
else
note_drop (stats, sizeof (AuditEvent));
return (AuditEvent *) event;
}
static Stats *
get_ringbuf_stats (void)
{
__u32 key = 0;
return bpf_map_lookup_elem (&stats, &key);
}
static void
note_emit (Stats * stats, __u64 bytes)
{
if (stats == NULL)
return;
stats->emitted_events++;
stats->emitted_bytes += bytes;
}
static void
note_drop (Stats * stats, __u64 wanted_bytes)
{
if (stats == NULL)
return;
stats->dropped_events++;
stats->dropped_bytes += wanted_bytes;
}
char LICENSE[] SEC ("license") = "Dual BSD/GPL";
File diff suppressed because it is too large. Load diff
+741
View File
@@ -389,6 +389,28 @@ namespace Frida {
return resource.get_file ().path;
}
public override async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
var session = yield do_open_service (address, cancellable);
var id = ServiceSessionId.generate ();
service_session_registry.register (id, session);
return id;
}
private async ServiceSession do_open_service (string address, Cancellable? cancellable) throws Error, IOError {
string[] tokens = address.split (":", 2);
unowned string protocol = tokens[0];
if (protocol == "syscall-trace")
return new SyscallTraceServiceSession ();
if (protocol == "softwall")
return new SoftwallServiceSession ();
throw new Error.NOT_SUPPORTED ("Unsupported service address");
}
#if ANDROID
internal async AndroidHelperClient get_android_helper_client (Cancellable? cancellable) throws Error, IOError {
while (android_helper_request != null) {
@@ -761,6 +783,7 @@ namespace Frida {
ZymbioteConnection? connection;
if (!zymbiote_connections.unset (pid, out connection))
return false;
connection.resume.begin (io_cancellable);
HostSpawnInfo? info;
@@ -1769,4 +1792,722 @@ namespace Frida {
return state == 'T';
}
#endif
private sealed class SyscallTraceServiceSession : Object, ServiceSession {
private SyscallTracer? tracer = new SyscallTracer ();
private const size_t MAX_BATCH_BYTES = 4U * 1024U * 1024U;
construct {
tracer.events_available.connect (on_events_available);
}
public async void activate (Cancellable? cancellable) throws Error, IOError {
ensure_active ();
}
private void ensure_active () throws Error {
if (tracer == null)
throw new Error.INVALID_OPERATION ("Service is closed");
if (tracer.state == STOPPED)
tracer.start ();
}
public async void cancel (Cancellable? cancellable) throws IOError {
if (tracer == null)
return;
tracer.stop ();
tracer = null;
close ();
}
public async Variant request (Variant parameters, Cancellable? cancellable = null) throws Error, IOError {
ensure_active ();
var reader = new VariantReader (parameters);
string type = reader.read_member ("type").get_string_value ();
reader.end_member ();
var reply = new VariantBuilder (VariantType.VARDICT);
if (type == "read-events") {
var events = new VariantBuilder (new VariantType ("av"));
var processes = new VariantBuilder (new VariantType ("a(us)"));
var abi_by_tgid = new Gee.HashMap<uint32, SyscallTracer.Abi> ();
var expired_tgids = new Gee.HashSet<uint32> ();
size_t total = 0;
var drain_status = tracer.drain_events (ev => {
var event = ev.event;
uint32 tgid = event->tgid;
if (expired_tgids.contains (tgid))
return CONTINUE;
var abi = abi_by_tgid[tgid];
if (abi == INVALID) {
try {
abi = tracer.get_process_abi (tgid);
} catch (Error e) {
expired_tgids.add (tgid);
return CONTINUE;
}
abi_by_tgid[tgid] = abi;
}
unowned LinuxSyscallSignature[] sigs = (abi == COMPAT32)
? get_compat32_syscall_signatures ()
: get_syscall_signatures ();
LinuxSyscallSignature * sig = find_sig_by_nr (sigs, ev.se->syscall_nr);
Variant item = build_event_variant (ev, sig);
size_t item_size = (size_t) item.get_size ();
if (total != 0 && total + item_size > MAX_BATCH_BYTES)
return STOP;
events.add_value (new Variant.variant (item));
total += item_size;
return CONTINUE;
});
foreach (var e in abi_by_tgid.entries) {
unowned string abi = (e.value == COMPAT32) ? "compat32" : "native";
processes.add ("(us)", e.key, abi);
}
vardict_add (reply, "events", events.end ());
vardict_add (reply, "processes", processes.end ());
vardict_add (reply, "status",
(drain_status == SyscallTracer.DrainStatus.DRAINED) ? "drained" : "more");
return reply.end ();
}
if (type == "resolve-stacks") {
reader.read_member ("ids");
var ids = read_uint32_array (reader);
reader.end_member ();
var stacks = new VariantBuilder (new VariantType ("aat"));
tracer.resolve_stacks (ids, (sid, frames) => {
stacks.open (new VariantType ("at"));
foreach (var frame in frames)
stacks.add_value (frame);
stacks.close ();
});
vardict_add (reply, "stacks", stacks.end ());
return reply.end ();
}
if (type == "resolve-symbols") {
var pid = (uint) reader.read_member ("pid").get_int64_value ();
reader.end_member ();
var gen = (uint32) reader.read_member ("gen").get_int64_value ();
reader.end_member ();
reader.read_member ("addresses");
var addrs = read_uint64_array (reader);
reader.end_member ();
var symbols = new VariantBuilder (new VariantType ("a(uu)"));
var modules = new VariantBuilder (new VariantType ("as"));
tracer.resolver.resolve_addresses (pid, gen, addrs,
(addr, mod_idx, rel32) => {
symbols.add ("(uu)", mod_idx, rel32);
},
(module_list) => {
foreach (var path in module_list)
modules.add_value (path);
});
vardict_add (reply, "modules", modules.end ());
vardict_add (reply, "symbols", symbols.end ());
return reply.end ();
}
if (type == "read-stats") {
var stats = tracer.read_stats ();
vardict_add (reply, "emitted-events", stats.emitted_events);
vardict_add (reply, "emitted-bytes", stats.emitted_bytes);
vardict_add (reply, "dropped-events", stats.dropped_events);
vardict_add (reply, "dropped-bytes", stats.dropped_bytes);
return reply.end ();
}
if (type == "add-targets") {
if (reader.has_member ("pids")) {
reader.read_member ("pids");
foreach_uint32 (reader, pid => tracer.add_target_tgid (pid));
reader.end_member ();
}
if (reader.has_member ("uids")) {
reader.read_member ("uids");
foreach_uint32 (reader, uid => tracer.add_target_uid (uid));
reader.end_member ();
}
if (reader.has_member ("users")) {
reader.read_member ("users");
foreach_string (reader, username => {
var uid = resolve_uid_from_username (username);
tracer.add_target_uid (uid);
});
reader.end_member ();
}
return reply.end ();
}
if (type == "remove-targets") {
if (reader.has_member ("pids")) {
reader.read_member ("pids");
foreach_uint32 (reader, pid => tracer.remove_target_tgid (pid));
reader.end_member ();
}
if (reader.has_member ("uids")) {
reader.read_member ("uids");
foreach_uint32 (reader, uid => tracer.remove_target_uid (uid));
reader.end_member ();
}
if (reader.has_member ("users")) {
reader.read_member ("users");
foreach_string (reader, username => {
var uid = resolve_uid_from_username (username);
tracer.remove_target_uid (uid);
});
reader.end_member ();
}
return reply.end ();
}
if (type == "get-signatures") {
vardict_add (reply, "native", build_signatures_variant (get_syscall_signatures ()));
unowned LinuxSyscallSignature[]? compat = get_compat32_syscall_signatures ();
if (compat != null)
vardict_add (reply, "compat32", build_signatures_variant (compat));
return reply.end ();
}
throw new Error.INVALID_ARGUMENT ("Unsupported request type: %s", type);
}
private void on_events_available () {
var b = new VariantBuilder (VariantType.VARDICT);
vardict_add (b, "type", "events-available");
message (b.end ());
}
private static Variant build_event_variant (SyscallTracer.SyscallEventView ev, LinuxSyscallSignature * sig) {
var event = ev.event;
var type = (SyscallTracer.EventType) event->type;
unowned uint8[] buf = ev.bytes;
size_t event_size = buf.length;
uint8 * payload_end = (uint8 *) buf + event_size;
uint8 nargs = (sig != null) ? sig->nargs : (uint8) SyscallTracer.SYSCALL_NARGS;
var args = new uint64[nargs];
int64 retval = 0;
uint8 * a;
if (type == SYSCALL_ENTER) {
assert (event_size >= sizeof (SyscallTracer.SyscallEnterEvent));
var e = (SyscallTracer.SyscallEnterEvent *) buf;
for (int i = 0; i != nargs; i++)
args[i] = e->args[i];
a = (uint8 *) (e + 1);
} else {
assert (event_size >= sizeof (SyscallTracer.SyscallExitEvent));
var e = (SyscallTracer.SyscallExitEvent *) buf;
retval = e->retval;
a = (uint8 *) (e + 1);
}
var attachments = new VariantBuilder (new VariantType ("a(uv)"));
for (uint i = 0; i != event->attachment_count; i++) {
assert (payload_end - a >= sizeof (SyscallTracer.AttachmentHeader));
var h = (SyscallTracer.AttachmentHeader *) a;
a += sizeof (SyscallTracer.AttachmentHeader);
uint32 idx = h->arg_index;
assert (idx < nargs);
var len = h->len;
assert (a + len <= payload_end);
Variant v = decode_attachment_value (type, sig, idx, (SyscallTracer.AttachmentType) h->type, a, len);
attachments.add_value (new Variant.tuple ({ idx, new Variant.variant (v) }));
a += len;
}
Variant args_v;
{
var ab = new VariantBuilder (new VariantType ("at"));
for (int i = 0; i != nargs; i++)
ab.add_value (args[i]);
args_v = ab.end ();
}
var se = ev.se;
if (type == SYSCALL_ENTER) {
return new Variant.tuple ({
"enter",
event->time_ns,
event->tgid,
event->tid,
se->syscall_nr,
se->stack_id,
se->map_gen,
args_v,
attachments.end ()
});
} else {
return new Variant.tuple ({
"exit",
event->time_ns,
event->tgid,
event->tid,
se->syscall_nr,
se->stack_id,
se->map_gen,
retval,
attachments.end ()
});
}
}
private static Variant decode_attachment_value (SyscallTracer.EventType event_type, LinuxSyscallSignature * sig,
uint arg_index, SyscallTracer.AttachmentType attachment_type, uint8 * data, size_t len) {
unowned string? arg_type = null;
if (sig != null)
arg_type = sig->args[arg_index].type;
switch (attachment_type) {
case SyscallTracer.AttachmentType.STRING:
return (string) data;
case SyscallTracer.AttachmentType.BYTES: {
if (arg_type != null && arg_type == "struct sockaddr *") {
Variant? sa = try_decode_sockaddr (data, len);
if (sa != null)
return sa;
}
var b = new uint8[len];
if (len != 0)
Memory.copy (b, data, len);
return Variant.new_from_data<void> (new VariantType ("ay"), b, true);
}
default:
assert_not_reached ();
}
}
private static Variant? try_decode_sockaddr (uint8 * data, size_t len) {
if (len < 2)
return null;
uint16 fam = *((uint16 *) data);
switch ((int) fam) {
case Posix.AF_INET: {
if (len < sizeof (Posix.SockAddrIn))
return null;
var sa = (Posix.SockAddrIn *) data;
var port = uint16.from_network (sa->sin_port);
uint8 ip_bytes[4];
Memory.copy (ip_bytes, &sa->sin_addr.s_addr, 4);
string ip = inet_ntop_to_string (Posix.AF_INET, ip_bytes, 4);
return new Variant.tuple ({ "inet", ip, (uint32) port });
}
case Posix.AF_INET6: {
if (len < sizeof (Posix.SockAddrIn6))
return null;
var sa6 = (Posix.SockAddrIn6 *) data;
var port = uint16.from_network (sa6->sin6_port);
uint8 ip_bytes[16];
Memory.copy (ip_bytes, sa6->sin6_addr.s6_addr, 16);
string ip = inet_ntop_to_string (Posix.AF_INET6, ip_bytes, 16);
uint32 scope_id = sa6->sin6_scope_id;
return new Variant.tuple ({
"inet6",
ip,
(uint32) port,
scope_id
});
}
case Posix.AF_UNIX: {
if (len < 2)
return null;
var path = (char *) (data + 2);
size_t path_bytes = size_t.min (len - 2, 108);
if (path_bytes == 0)
return new Variant.tuple ({ "unix", "" });
if (path[0] == 0) {
size_t n = 1;
while (n < path_bytes && path[n] != 0)
n++;
size_t name_len = (n > 1) ? (n - 1) : 0;
var str = new uint8[name_len + 1];
if (name_len != 0)
Memory.copy (str, path + 1, name_len);
return new Variant.tuple ({ "unix-abstract", (string) str });
}
size_t n = 1;
while (n < path_bytes && path[n] != 0)
n++;
var str = new uint8[n + 1];
Memory.copy (str, path, n);
return new Variant.tuple ({ "unix", (string) str });
}
default:
return null;
}
}
private static Variant build_signatures_variant (LinuxSyscallSignature[] signatures) {
var result = new VariantBuilder (new VariantType ("a(usa(ss))"));
foreach (unowned LinuxSyscallSignature sig in signatures) {
if (sig.name != null) {
var args = new VariantBuilder (new VariantType ("a(ss)"));
for (uint8 i = 0; i != sig.nargs; i++) {
unowned LinuxSyscallArg arg = sig.args[i];
args.add_value (new Variant.tuple ({ arg.type, arg.name }));
}
result.add_value (new Variant.tuple ({ sig.nr, sig.name, args.end () }));
}
}
return result.end ();
}
private static LinuxSyscallSignature * find_sig_by_nr (LinuxSyscallSignature[] sigs, int32 nr) {
if (nr < 0)
return null;
uint lo = 0;
uint hi = (uint) sigs.length;
while (lo < hi) {
uint mid = lo + ((hi - lo) / 2);
LinuxSyscallSignature * sig = &sigs[mid];
if (sig->nr == nr)
return sig;
if (sig->nr < nr)
lo = mid + 1;
else
hi = mid;
}
return null;
}
}
private sealed class SoftwallServiceSession : Object, ServiceSession {
private Softwall? wall = new Softwall ();
private const size_t MAX_BATCH_BYTES = 4U * 1024U * 1024U;
construct {
wall.events_available.connect (on_events_available);
}
public async void activate (Cancellable? cancellable) throws Error, IOError {
ensure_active ();
}
private void ensure_active () throws Error {
if (wall == null)
throw new Error.INVALID_OPERATION ("Service is closed");
if (wall.state == Softwall.State.STOPPED)
wall.start ();
}
public async void cancel (Cancellable? cancellable) throws IOError {
if (wall == null)
return;
wall.stop ();
wall = null;
close ();
}
public async Variant request (Variant parameters, Cancellable? cancellable = null) throws Error, IOError {
ensure_active ();
var reader = new VariantReader (parameters);
string type = reader.read_member ("type").get_string_value ();
reader.end_member ();
var reply = new VariantBuilder (VariantType.VARDICT);
if (type == "read-events") {
var events = new VariantBuilder (new VariantType ("av"));
size_t total = 0;
var drain_status = wall.drain_events (ev => {
Variant item = new Variant.tuple ({
"audit",
ev->parent.time_ns,
ev->parent.tgid,
ev->parent.tid,
ev->rule_id
});
size_t item_size = (size_t) item.get_size ();
if (total != 0 && total + item_size > MAX_BATCH_BYTES)
return Softwall.EventFlow.STOP;
events.add_value (new Variant.variant (item));
total += item_size;
return Softwall.EventFlow.CONTINUE;
});
vardict_add (reply, "events", events.end ());
vardict_add (reply, "status",
(drain_status == Softwall.DrainStatus.DRAINED) ? "drained" : "more");
return reply.end ();
}
if (type == "read-stats") {
var stats = wall.read_stats ();
vardict_add (reply, "emitted-events", stats.emitted_events);
vardict_add (reply, "emitted-bytes", stats.emitted_bytes);
vardict_add (reply, "dropped-events", stats.dropped_events);
vardict_add (reply, "dropped-bytes", stats.dropped_bytes);
return reply.end ();
}
if (type == "add-targets") {
if (reader.has_member ("pids")) {
reader.read_member ("pids");
foreach_uint32 (reader, pid => wall.add_target_tgid (pid));
reader.end_member ();
}
if (reader.has_member ("uids")) {
reader.read_member ("uids");
foreach_uint32 (reader, uid => wall.add_target_uid (uid));
reader.end_member ();
}
if (reader.has_member ("users")) {
reader.read_member ("users");
foreach_string (reader, username => {
var uid = resolve_uid_from_username (username);
wall.add_target_uid (uid);
});
reader.end_member ();
}
return reply.end ();
}
if (type == "remove-targets") {
if (reader.has_member ("pids")) {
reader.read_member ("pids");
foreach_uint32 (reader, pid => wall.remove_target_tgid (pid));
reader.end_member ();
}
if (reader.has_member ("uids")) {
reader.read_member ("uids");
foreach_uint32 (reader, uid => wall.remove_target_uid (uid));
reader.end_member ();
}
if (reader.has_member ("users")) {
reader.read_member ("users");
foreach_string (reader, username => {
var uid = resolve_uid_from_username (username);
wall.remove_target_uid (uid);
});
reader.end_member ();
}
return reply.end ();
}
if (type == "add-rule") {
reader.read_member ("rule");
reader.read_member ("when");
if (!reader.has_member ("file_open"))
throw new Error.INVALID_ARGUMENT ("Unsupported rule.when (expected file_open)");
reader.read_member ("file_open");
string path = reader.read_member ("path").get_string_value ();
reader.end_member (); /* path */
reader.end_member (); /* file_open */
reader.end_member (); /* when */
string action_str = reader.read_member ("action").get_string_value ();
reader.end_member (); /* action */
reader.end_member (); /* rule */
var action = parse_action (action_str);
var id = wall.add_file_open_rule (path, action);
vardict_add (reply, "id", id);
return reply.end ();
}
if (type == "remove-rule") {
uint32 id = (uint32) reader.read_member ("id").get_int64_value ();
reader.end_member ();
wall.remove_rule (id);
return reply.end ();
}
throw new Error.INVALID_ARGUMENT ("Unsupported request type: %s", type);
}
private void on_events_available () {
var b = new VariantBuilder (VariantType.VARDICT);
vardict_add (b, "type", "events-available");
message (b.end ());
}
private static Softwall.Action parse_action (string s) throws Error {
switch (s) {
case "deny":
return Softwall.Action.DENY;
case "not-found":
return Softwall.Action.NOT_FOUND;
default:
throw new Error.INVALID_ARGUMENT ("Unsupported action: %s", s);
}
}
}
private string inet_ntop_to_string (int af, uint8 * src, size_t srclen) {
uint8 buf[46];
unowned string? res = Posix.inet_ntop (af, src, buf);
return (res != null) ? res : "?";
}
private uint32 resolve_uid_from_username (string name) throws Error {
unowned Posix.Passwd? pw = Posix.getpwnam (name);
if (pw == null)
throw new Error.INVALID_ARGUMENT ("Unknown user: %s", name);
return (uint32) pw.pw_uid;
}
private delegate void UInt32Handler (uint32 v) throws Error;
private delegate void StringHandler (string s) throws Error;
private uint32[] read_uint32_array (VariantReader reader) throws Error {
uint n = reader.count_elements ();
var arr = new uint32[n];
for (uint i = 0; i != n; i++) {
int64 v = reader.read_element (i).get_int64_value ();
if (v < 0 || v > uint32.MAX)
throw new Error.INVALID_ARGUMENT ("Value is out of range");
arr[i] = (uint32) v;
reader.end_element ();
}
return arr;
}
private uint64[] read_uint64_array (VariantReader reader) throws Error {
uint n = reader.count_elements ();
var arr = new uint64[n];
for (uint i = 0; i != n; i++) {
arr[i] = reader.read_element (i).get_uint64_value ();
reader.end_element ();
}
return arr;
}
private void foreach_uint32 (VariantReader reader, UInt32Handler cb) throws Error {
uint n = reader.count_elements ();
for (uint i = 0; i != n; i++) {
int64 v = reader.read_element (i).get_int64_value ();
if (v < 0 || v > uint32.MAX)
throw new Error.INVALID_ARGUMENT ("Value is out of range");
cb ((uint32) v);
reader.end_element ();
}
}
private void foreach_string (VariantReader reader, StringHandler cb) throws Error {
uint n = reader.count_elements ();
for (uint i = 0; i != n; i++) {
unowned string s = reader.read_element (i).get_string_value ();
cb (s);
reader.end_element ();
}
}
private void vardict_add (VariantBuilder b, string key, Variant val) {
b.add_value (new Variant.dict_entry (new Variant.string (key), new Variant.variant (val)));
}
}
+413
View File
@@ -0,0 +1,413 @@
namespace Frida {
public sealed class ProcMapsSnapshot : Object {
public uint32 gen {
get;
internal set;
default = 1;
}
private Gee.List<Mapping> maps = new Gee.ArrayList<Mapping> ();
public class Mapping {
public uint64 start;
public uint64 end;
public uint64 file_offset;
public DevId device;
public uint64 inode;
public string module_id;
public uint32 start_gen;
public uint32 end_gen;
}
public static ProcMapsSnapshot from_pid (uint32 pid) throws Error {
var snap = new ProcMapsSnapshot ();
snap.build_from_pid (pid);
return snap;
}
private void build_from_pid (uint32 pid) throws Error {
maps.clear ();
var it = ProcMapsIter.for_pid (pid);
while (it.next ()) {
var m = new Mapping ();
m.start = it.start_address;
m.end = it.end_address;
m.file_offset = it.file_offset;
m.device = it.device;
m.inode = it.inode;
m.module_id = normalize_module_id (it.path);
m.start_gen = 1;
m.end_gen = 0;
maps.add (m);
}
}
public void apply_create (uint32 new_gen, uint64 start, uint64 end, uint64 file_offset, DevId device, uint64 inode,
string module_id) {
end_range_at_gen (start, end, new_gen);
var m = new Mapping ();
m.start = start;
m.end = end;
m.file_offset = file_offset;
m.device = device;
m.inode = inode;
m.module_id = module_id;
m.start_gen = new_gen;
m.end_gen = 0;
insert_sorted (m);
gen = new_gen;
}
public void apply_destroy_range (uint32 new_gen, uint64 start, uint64 end) {
end_range_at_gen (start, end, new_gen);
gen = new_gen;
}
private void insert_sorted (Mapping m) {
int i = 0;
while (i < maps.size && maps[i].start < m.start)
i++;
maps.insert (i, m);
}
private void end_range_at_gen (uint64 start, uint64 end, uint32 gen) {
for (int i = maps.size - 1; i >= 0; i--) {
var m = maps[i];
bool active = m.end_gen == 0;
if (!active)
continue;
bool disjoint = end <= m.start || start >= m.end;
if (disjoint)
continue;
bool full_cover = start <= m.start && end >= m.end;
if (full_cover) {
m.end_gen = gen;
continue;
}
bool chop_head = start <= m.start && end < m.end;
if (chop_head) {
var dead = new Mapping ();
dead.start = m.start;
dead.end = end;
dead.file_offset = m.file_offset;
dead.device = m.device;
dead.inode = m.inode;
dead.module_id = m.module_id;
dead.start_gen = m.start_gen;
dead.end_gen = gen;
uint64 delta = end - m.start;
m.start = end;
m.file_offset += delta;
maps.insert (i + 1, dead);
continue;
}
bool chop_tail = start > m.start && end >= m.end;
if (chop_tail) {
var dead = new Mapping ();
dead.start = start;
dead.end = m.end;
dead.file_offset = m.file_offset + (start - m.start);
dead.device = m.device;
dead.inode = m.inode;
dead.module_id = m.module_id;
dead.start_gen = m.start_gen;
dead.end_gen = gen;
m.end = start;
maps.insert (i + 1, dead);
continue;
}
bool split_middle = start > m.start && end < m.end;
if (split_middle) {
var dead = new Mapping ();
dead.start = start;
dead.end = end;
dead.file_offset = m.file_offset + (start - m.start);
dead.device = m.device;
dead.inode = m.inode;
dead.module_id = m.module_id;
dead.start_gen = m.start_gen;
dead.end_gen = gen;
var right = new Mapping ();
right.start = end;
right.end = m.end;
right.file_offset = m.file_offset + (end - m.start);
right.device = m.device;
right.inode = m.inode;
right.module_id = m.module_id;
right.start_gen = m.start_gen;
right.end_gen = 0;
m.end = start;
maps.insert (i + 1, dead);
maps.insert (i + 2, right);
}
}
}
private static string normalize_module_id (string path) {
const string suffix = " (deleted)";
if (path.has_suffix (suffix))
return path.substring (0, path.length - suffix.length);
return path;
}
public Mapping? find_mapping_at_gen (uint64 addr, uint32 gen) {
int lo = 0;
int hi = maps.size - 1;
while (lo <= hi) {
int mid = lo + ((hi - lo) / 2);
var m = maps[mid];
if (addr < m.start)
hi = mid - 1;
else if (addr >= m.end)
lo = mid + 1;
else {
for (int i = mid; i >= 0; i--) {
var c = maps[i];
if (addr < c.start)
break;
bool match = mapping_contains (c, addr) && mapping_alive_at (c, gen);
if (match)
return c;
}
for (int i = mid + 1; i < maps.size; i++) {
var c = maps[i];
if (addr < c.start)
break;
bool match = mapping_contains (c, addr) && mapping_alive_at (c, gen);
if (match)
return c;
}
return null;
}
}
return null;
}
private bool mapping_contains (Mapping m, uint64 addr) {
return addr >= m.start && addr < m.end;
}
private bool mapping_alive_at (Mapping m, uint32 gen) {
bool started = m.start_gen <= gen;
bool not_ended = m.end_gen == 0 || gen < m.end_gen;
return started && not_ended;
}
}
public class ProcMapsSoEntry {
public uint64 base_address;
public string path;
public DevId device;
public uint64 inode;
private ProcMapsSoEntry (uint64 base_address, string path, DevId device, uint64 inode) {
this.base_address = base_address;
this.path = path;
this.device = device;
this.inode = inode;
}
public static ProcMapsSoEntry? find_by_address (uint pid, uint64 address) {
var iter = ProcMapsIter.for_pid (pid);
while (iter.next ()) {
uint64 start = iter.start_address;
uint64 end = iter.end_address;
if (address >= start && address < end)
return new ProcMapsSoEntry (start, iter.path, iter.device, iter.inode);
}
return null;
}
public static ProcMapsSoEntry? find_by_path (uint pid, string path) {
var candidates = new Gee.ArrayList<Candidate> ();
Candidate? latest_candidate = null;
var iter = ProcMapsIter.for_pid (pid);
#if ANDROID
unowned string libc_path = Gum.Process.get_libc_module ().path;
#endif
while (iter.next ()) {
string current_path = iter.path;
if (current_path == "[page size compat]")
continue;
if (current_path != path) {
latest_candidate = null;
continue;
}
string flags = iter.flags;
#if ANDROID
if (current_path == libc_path && flags[3] == 's')
continue;
#endif
if (iter.file_offset == 0) {
latest_candidate = new Candidate () {
entry = new ProcMapsSoEntry (iter.start_address, current_path, iter.device, iter.inode),
total_ranges = 0,
executable_ranges = 0,
};
candidates.add (latest_candidate);
}
if (latest_candidate != null) {
latest_candidate.total_ranges++;
if (flags[2] == 'x')
latest_candidate.executable_ranges++;
}
}
candidates.sort ((a, b) => b.score () - a.score ());
if (candidates.is_empty)
return null;
return candidates.first ().entry;
}
private class Candidate {
public ProcMapsSoEntry entry;
public uint total_ranges;
public uint executable_ranges;
public int score () {
int result = (int) total_ranges;
if (executable_ranges == 0)
result = -result;
return result;
}
}
}
public sealed class ProcMapsIter {
private string? contents;
private MatchInfo? info;
private uint offset = 0;
public uint64 start_address {
get {
return uint64.parse (info.fetch (1), 16);
}
}
public uint64 end_address {
get {
return uint64.parse (info.fetch (2), 16);
}
}
public string flags {
owned get {
return info.fetch (3);
}
}
public uint64 file_offset {
get {
return uint64.parse (info.fetch (4), 16);
}
}
public uint64 dev {
get {
var s = info.fetch (5);
int colon = s.index_of_char (':');
uint64 major = uint64.parse (s.substring (0, colon), 16);
uint64 minor = uint64.parse (s.substring (colon + 1), 16);
return (major << 32) | minor;
}
}
public DevId device {
get {
var s = info.fetch (5);
int colon = s.index_of_char (':');
uint32 major = (uint32) uint64.parse (s.substring (0, colon), 16);
uint32 minor = (uint32) uint64.parse (s.substring (colon + 1), 16);
return DevId (major, minor);
}
}
public uint64 inode {
get {
return uint64.parse (info.fetch (6));
}
}
public string path {
owned get {
return info.fetch (7);
}
}
public static ProcMapsIter for_pid (uint pid) {
return new ProcMapsIter (pid);
}
private ProcMapsIter (uint pid) {
try {
FileUtils.get_contents ("/proc/%u/maps".printf (pid), out contents);
} catch (FileError e) {
return;
}
if (!/^([0-9a-f]+)-([0-9a-f]+) (\S{4}) ([0-9a-f]+) ([0-9a-f]{2,}:[0-9a-f]{2,}) (\d+) +([^\n]+)$/m.match (
contents, 0, out info)) {
assert_not_reached ();
}
}
public bool next () {
if (info == null)
return false;
if (offset > 0) {
try {
info.next ();
} catch (RegexError e) {
return false;
}
}
offset++;
return info.matches ();
}
}
}
+298
View File
@@ -0,0 +1,298 @@
public sealed class Frida.Softwall : Object {
public signal void events_available ();
public State state {
get {
return _state;
}
}
public enum State {
STOPPED,
STARTED,
}
private State _state = STOPPED;
private BpfMap? target_tgids;
private BpfMap? target_uids;
private BpfMap? rules_by_id;
private BpfMap? inode_index;
private BpfMap? stats;
private BpfRingbufReader? events_reader;
private IOChannel? events_channel;
private Source? events_source;
private Gee.Collection<BpfLink> links = new Gee.ArrayList<BpfLink> ();
private uint32 next_rule_id = 1;
protected override void dispose () {
stop ();
base.dispose ();
}
public void start () throws Error {
assert (state == STOPPED);
var obj = BpfObject.open ("softwall.elf", Frida.Data.HelperBackend.get_softwall_elf_blob ().data);
target_tgids = obj.maps.get_by_name ("target_tgids");
target_uids = obj.maps.get_by_name ("target_uids");
rules_by_id = obj.maps.get_by_name ("rules_by_id");
inode_index = obj.maps.get_by_name ("inode_index");
var events = obj.maps.get_by_name ("audit_events");
stats = obj.maps.get_by_name ("stats");
obj.prepare ();
events_reader = new BpfRingbufReader (events);
obj.load ();
foreach (var program in obj.programs) {
var link = program.attach ();
links.add (link);
}
events_channel = new IOChannel.unix_new (events.fd);
arm_events_watch ();
_state = STARTED;
}
public void stop () {
events_source?.destroy ();
events_source = null;
events_channel = null;
events_reader = null;
links.clear ();
stats = null;
inode_index = null;
rules_by_id = null;
target_uids = null;
target_tgids = null;
next_rule_id = 1;
_state = STOPPED;
}
public void add_target_tgid (uint tgid) throws Error {
target_tgids.update_u32_u8 (tgid, 1);
}
public void remove_target_tgid (uint tgid) throws Error {
target_tgids.remove_u32 (tgid);
}
public void add_target_uid (uint uid) throws Error {
target_uids.update_u32_u8 (uid, 1);
}
public void remove_target_uid (uint uid) throws Error {
target_uids.remove_u32 (uid);
}
public enum Action {
DENY,
NOT_FOUND,
}
public uint32 add_file_open_rule (string path, Action action) throws Error {
assert (state == STARTED);
uint64 dev, ino;
resolve_path_to_inode (path, out dev, out ino);
var id = next_rule_id++;
var errno_neg = map_action_to_errno (action);
var rule = FileOpenRule ();
rule.dev = dev;
rule.ino = ino;
rule.errno_neg = errno_neg;
rule._pad0 = 0;
rules_by_id.update_raw ((uint8[]) &id, (uint8[]) &rule);
var key = InodeKey ();
key.dev = dev;
key.ino = ino;
inode_index.update_raw ((uint8[]) &key, (uint8[]) &id);
return id;
}
public void remove_rule (uint32 id) throws Error {
assert (state == STARTED);
var rule = FileOpenRule ();
try {
rules_by_id.lookup_raw ((uint8[]) &id, (uint8[]) &rule);
} catch (Error e) {
throw new Error.INVALID_ARGUMENT ("Unknown rule id: %u".printf (id));
}
var key = InodeKey ();
key.dev = rule.dev;
key.ino = rule.ino;
try {
inode_index.remove_raw ((uint8[]) &key);
} catch (Error e) {
}
rules_by_id.remove_u32 (id);
}
public DrainStatus drain_events (AuditEventHandler on_event) {
var status = events_reader.drain (payload => {
assert (payload.length >= sizeof (AuditEvent));
var e = (AuditEvent *) payload;
return (on_event (e) == CONTINUE)
? BpfRingbufReader.RecordAction.CONTINUE
: BpfRingbufReader.RecordAction.STOP;
});
if (status == DRAINED)
arm_events_watch ();
return (status == DRAINED)
? DrainStatus.DRAINED
: DrainStatus.STOPPED;
}
public enum DrainStatus {
DRAINED,
STOPPED,
}
public delegate EventFlow AuditEventHandler (AuditEvent * ev);
public enum EventFlow {
CONTINUE,
STOP,
}
private void arm_events_watch () {
if (events_source != null)
return;
var src = new IOSource (events_channel, IOCondition.IN);
var state = new AuditEventsWatchState (this);
src.set_callback (state.on_ready);
src.attach (MainContext.get_thread_default ());
events_source = src;
}
private class AuditEventsWatchState : Object {
public unowned Softwall wall;
public AuditEventsWatchState (Softwall wall) {
this.wall = wall;
}
public bool on_ready (IOChannel ch, IOCondition cond) {
wall.on_events_readable ();
return Source.REMOVE;
}
}
private void on_events_readable () {
events_source?.destroy ();
events_source = null;
events_available ();
}
public Stats read_stats () throws Error {
Stats total = Stats ();
uint32 key = 0;
stats.foreach_percpu_value<Stats?> ((uint8[]) &key, (cpu, s) => {
total.emitted_events += s.emitted_events;
total.emitted_bytes += s.emitted_bytes;
total.dropped_events += s.dropped_events;
total.dropped_bytes += s.dropped_bytes;
});
return total;
}
private static int32 map_action_to_errno (Action action) {
switch (action) {
case Action.NOT_FOUND:
return -Posix.ENOENT;
case Action.DENY:
default:
return -Posix.EACCES;
}
}
private static void resolve_path_to_inode (string path, out uint64 dev, out uint64 ino) throws Error {
Posix.Stat st;
if (Posix.stat (path, out st) != 0)
throw new Error.INVALID_ARGUMENT ("Unable to stat path: %s", path);
dev = (uint64) st.st_dev;
ino = (uint64) st.st_ino;
}
public struct Event {
public uint64 time_ns;
public uint32 tgid;
public uint32 tid;
public uint16 type;
public uint16 _pad0;
}
public enum EventType {
AUDIT
}
public struct AuditEvent {
public Event parent;
public uint32 rule_id;
public uint32 _pad0;
}
public struct InodeKey {
public uint64 dev;
public uint64 ino;
}
private struct FileOpenRule {
public uint64 dev;
public uint64 ino;
public int32 errno_neg;
public uint32 _pad0;
}
public struct Stats {
public uint64 emitted_events;
public uint64 emitted_bytes;
public uint64 dropped_events;
public uint64 dropped_bytes;
}
}
+168
View File
@@ -0,0 +1,168 @@
public sealed class Frida.SymbolResolver : Object {
private Gee.Map<uint, ProcMapsSnapshot> cache = new Gee.HashMap<uint, ProcMapsSnapshot> ();
private Gee.Map<uint, Gee.Map<uint32, PendingMapEvent>> pending = new Gee.HashMap<uint, Gee.Map<uint32, PendingMapEvent>> ();
private Gee.Set<uint> incomplete = new Gee.HashSet<uint> ();
private class PendingMapEvent {
public bool is_create;
public uint32 gen;
public uint64 start;
public uint64 end;
public uint64 file_offset;
public DevId device;
public uint64 inode;
public string? path;
}
private const uint MAX_PENDING = 256;
public void resolve_addresses (uint pid, uint32 gen, uint64[] addresses, AddressResolved on_symbol, ModulesReady on_modules)
throws Error {
var snap = get_snapshot (pid);
var used_index = new Gee.HashMap<string, uint> ();
var used_modules = new Gee.ArrayList<string> ();
foreach (var addr in addresses) {
ProcMapsSnapshot.Mapping? m = snap.find_mapping_at_gen (addr, gen);
if (m == null) {
on_symbol (addr, uint32.MAX, 0);
continue;
}
uint mod_idx;
if (!used_index.has_key (m.module_id)) {
mod_idx = used_modules.size;
used_index[m.module_id] = mod_idx;
used_modules.add (m.module_id);
} else {
mod_idx = used_index[m.module_id];
}
uint64 rel64 = (addr - m.start) + m.file_offset;
uint32 rel32 = (rel64 <= uint32.MAX) ? (uint32) rel64 : 0;
on_symbol (addr, mod_idx, rel32);
}
on_modules (used_modules);
}
public delegate void AddressResolved (uint64 address, uint module_index, uint32 rel);
public delegate void ModulesReady (Gee.List<string> modules);
private ProcMapsSnapshot get_snapshot (uint pid) throws Error {
var s = cache[pid];
if (s == null)
return refresh_snapshot (pid);
return s;
}
public ProcMapsSnapshot refresh_snapshot (uint pid) throws Error {
var s = ProcMapsSnapshot.from_pid (pid);
cache[pid] = s;
pending.unset (pid);
incomplete.remove (pid);
return s;
}
public void apply_map_create (uint32 pid, uint32 gen, uint64 start, uint64 end, uint64 file_offset, uint64 vm_flags, DevId device,
uint64 inode, string? path) {
var snap = cache[pid];
if (snap == null)
return;
if (gen <= snap.gen)
return;
var q = pending[pid];
if (q == null) {
q = new Gee.HashMap<uint32, PendingMapEvent> ();
pending[pid] = q;
}
var ev = new PendingMapEvent ();
ev.is_create = true;
ev.gen = gen;
ev.start = start;
ev.end = end;
ev.file_offset = file_offset;
ev.device = device;
ev.inode = inode;
ev.path = path;
q[gen] = ev;
drain_map_events (pid, snap, q);
}
public void apply_map_destroy_range (uint32 pid, uint32 gen, uint64 start, uint64 end) {
var snap = cache[pid];
if (snap == null)
return;
if (gen <= snap.gen)
return;
var q = pending[pid];
if (q == null) {
q = new Gee.HashMap<uint32, PendingMapEvent> ();
pending[pid] = q;
}
var ev = new PendingMapEvent ();
ev.is_create = false;
ev.gen = gen;
ev.start = start;
ev.end = end;
q[gen] = ev;
drain_map_events (pid, snap, q);
}
private void drain_map_events (uint32 pid, ProcMapsSnapshot snap, Gee.Map<uint32, PendingMapEvent> q) {
if (q.size > MAX_PENDING) {
incomplete.add (pid);
q.clear ();
return;
}
while (true) {
uint32 next_gen = snap.gen + 1;
PendingMapEvent? ev = q[next_gen];
if (ev == null)
break;
q.unset (next_gen);
if (ev.is_create) {
string module_id = make_module_id (ev.device, ev.inode, ev.path);
snap.apply_create (next_gen, ev.start, ev.end, ev.file_offset, ev.device, ev.inode, module_id);
} else {
snap.apply_destroy_range (next_gen, ev.start, ev.end);
}
}
}
public void invalidate (uint32 pid) {
cache.unset (pid);
}
public void clear () {
cache.clear ();
}
private static string make_module_id (DevId device, uint64 inode, string? path) {
if (path != null)
return path;
return ("<%x:%x:%" + uint64.FORMAT_MODIFIER + "u>").printf (device.major, device.minor, inode);
}
}
+438
View File
@@ -0,0 +1,438 @@
public sealed class Frida.SyscallTracer : Object {
public signal void events_available ();
public State state {
get {
return _state;
}
}
public SymbolResolver resolver {
get;
default = new SymbolResolver ();
}
public enum State {
STOPPED,
STARTED,
}
private State _state = STOPPED;
private BpfMap? target_tgids;
private BpfMap? target_uids;
private BpfRingbufReader? syscall_events_reader;
private IOChannel? syscall_events_channel;
private Source? syscall_events_source;
private BpfRingbufReader? map_events_reader;
private IOChannel? map_events_channel;
private Source? map_events_source;
private BpfMap? stacks;
private BpfMap? process_states;
private BpfMap? stats;
private Gee.Collection<BpfLink> links = new Gee.ArrayList<BpfLink> ();
public const size_t SYSCALL_NARGS = 6;
protected override void dispose () {
stop ();
base.dispose ();
}
public void start () throws Error {
assert (state == STOPPED);
var obj = BpfObject.open ("syscall-tracer.elf", Frida.Data.HelperBackend.get_syscall_tracer_elf_blob ().data);
target_tgids = obj.maps.get_by_name ("target_tgids");
target_uids = obj.maps.get_by_name ("target_uids");
var syscall_events = obj.maps.get_by_name ("syscall_events");
var map_events = obj.maps.get_by_name ("map_events");
stacks = obj.maps.get_by_name ("stacks");
process_states = obj.maps.get_by_name ("process_states");
stats = obj.maps.get_by_name ("stats");
obj.prepare ();
syscall_events_reader = new BpfRingbufReader (syscall_events);
map_events_reader = new BpfRingbufReader (map_events);
obj.load ();
foreach (var program in obj.programs) {
var link = program.attach ();
links.add (link);
}
syscall_events_channel = new IOChannel.unix_new (syscall_events.fd);
arm_syscall_events_watch ();
map_events_channel = new IOChannel.unix_new (map_events.fd);
arm_map_events_watch ();
_state = STARTED;
}
public void stop () {
syscall_events_source?.destroy ();
syscall_events_source = null;
syscall_events_channel = null;
syscall_events_reader = null;
map_events_source?.destroy ();
map_events_source = null;
map_events_channel = null;
map_events_reader = null;
links.clear ();
stats = null;
process_states = null;
stacks = null;
target_uids = null;
target_tgids = null;
_state = STOPPED;
}
public void add_target_tgid (uint tgid) throws Error {
target_tgids.update_u32_u8 (tgid, 1);
}
public void remove_target_tgid (uint tgid) throws Error {
target_tgids.remove_u32 (tgid);
}
public void add_target_uid (uint uid) throws Error {
target_uids.update_u32_u8 (uid, 1);
}
public void remove_target_uid (uint uid) throws Error {
target_uids.remove_u32 (uid);
}
public DrainStatus drain_events (SyscallEventHandler on_event) {
var status = syscall_events_reader.drain (payload => {
assert (payload.length >= sizeof (SyscallEvent));
var e = (Event *) payload;
var se = (SyscallEvent *) payload;
SyscallEventView ev = { e, se, payload };
return (on_event (ev) == CONTINUE)
? BpfRingbufReader.RecordAction.CONTINUE
: BpfRingbufReader.RecordAction.STOP;
});
if (status == DRAINED)
arm_syscall_events_watch ();
return (status == DRAINED)
? DrainStatus.DRAINED
: DrainStatus.STOPPED;
}
public enum DrainStatus {
DRAINED,
STOPPED,
}
public delegate EventFlow SyscallEventHandler (SyscallEventView ev);
public enum EventFlow {
CONTINUE,
STOP,
}
public struct SyscallEventView {
public Event * event;
public SyscallEvent * se;
public unowned uint8[] bytes;
}
private void arm_syscall_events_watch () {
if (syscall_events_source != null)
return;
var src = new IOSource (syscall_events_channel, IOCondition.IN);
var state = new SyscallEventsWatchState (this);
src.set_callback (state.on_ready);
src.attach (MainContext.get_thread_default ());
syscall_events_source = src;
}
private class SyscallEventsWatchState : Object {
public unowned SyscallTracer tracer;
public SyscallEventsWatchState (SyscallTracer tracer) {
this.tracer = tracer;
}
public bool on_ready (IOChannel ch, IOCondition cond) {
tracer.on_syscall_events_readable ();
return Source.REMOVE;
}
}
private void on_syscall_events_readable () {
syscall_events_source?.destroy ();
syscall_events_source = null;
events_available ();
}
private void arm_map_events_watch () {
assert (map_events_source == null);
var src = new IOSource (map_events_channel, IOCondition.IN);
var state = new MapEventsWatchState (this);
src.set_callback (state.on_ready);
src.attach (MainContext.get_thread_default ());
map_events_source = src;
}
private class MapEventsWatchState : Object {
public unowned SyscallTracer tracer;
public MapEventsWatchState (SyscallTracer tracer) {
this.tracer = tracer;
}
public bool on_ready (IOChannel ch, IOCondition cond) {
tracer.on_map_events_readable ();
return Source.CONTINUE;
}
}
private void on_map_events_readable () {
map_events_reader.drain (payload => {
assert (payload.length >= sizeof (Event));
on_map_event ((Event *) payload);
return CONTINUE;
});
}
private void on_map_event (Event * ev) {
var type = (EventType) ev->type;
switch (type) {
case NEED_SNAPSHOT: {
try {
resolver.refresh_snapshot (ev->tgid);
var s = ProcessState ();
s.abi = compute_abi_from_pid (ev->tgid);
s.map_gen = 1;
process_states.update_raw ((uint8[]) &ev->tgid, (uint8[]) &s);
} catch (GLib.Error e) {
try {
process_states.remove_u32 (ev->tgid);
} catch (Error _) {
}
}
Posix.kill ((Posix.pid_t) ev->tgid, Posix.Signal.CONT);
break;
}
case MAP_CREATE: {
var me = (MapCreateEvent *) ev;
unowned string? filename = null;
if (ev->attachment_count != 0) {
var h = (AttachmentHeader *) ((uint8 *) &me->gen + sizeof (uint32));
filename = (string) (h + 1);
}
uint64 file_offset = me->pgoff * Gum.query_page_size ();
resolver.apply_map_create (
me->parent.tgid,
me->gen,
me->start,
me->end,
file_offset,
me->vm_flags,
DevId.unpack (me->device),
me->inode,
filename
);
break;
}
case MAP_DESTROY_RANGE: {
var de = (MapDestroyRangeEvent *) ev;
resolver.apply_map_destroy_range (
de->parent.tgid,
de->gen,
de->start,
de->end
);
break;
}
default:
break;
}
}
private static Abi compute_abi_from_pid (uint32 tgid) {
#if X86_64 || ARM64
try {
var cpu = Gum.Linux.cpu_type_from_pid ((Posix.pid_t) tgid);
#if X86_64
return (cpu == IA32) ? Abi.COMPAT32 : Abi.NATIVE;
#elif ARM64
return (cpu == ARM) ? Abi.COMPAT32 : Abi.NATIVE;
#endif
} catch (Gum.Error e) {
return NATIVE;
}
#else
return NATIVE;
#endif
}
public struct Event {
public uint64 time_ns;
public uint32 tgid;
public uint32 tid;
public uint16 type;
public uint16 attachment_count;
}
public enum EventType {
SYSCALL_ENTER,
SYSCALL_EXIT,
NEED_SNAPSHOT,
MAP_CREATE,
MAP_DESTROY_RANGE,
}
public struct AttachmentHeader {
public uint16 type;
public uint16 arg_index;
public uint32 len;
}
public enum AttachmentType {
STRING,
BYTES,
}
public struct SyscallEvent {
public Event parent;
public int32 syscall_nr;
public int32 stack_id;
public uint32 map_gen;
}
public struct SyscallEnterEvent {
public SyscallEvent parent;
public uint64 args[6];
}
public struct SyscallExitEvent {
public SyscallEvent parent;
public int64 retval;
}
private struct MapCreateEvent {
public Event parent;
public uint64 start;
public uint64 end;
public uint64 pgoff;
public uint64 vm_flags;
public uint64 device;
public uint64 inode;
public uint32 gen;
}
private struct MapDestroyRangeEvent {
public Event parent;
public uint64 start;
public uint64 end;
public uint32 gen;
}
private struct ProcessState {
public uint8 abi;
public uint32 map_gen;
}
public enum Abi {
INVALID,
NATIVE,
COMPAT32,
}
public Abi get_process_abi (uint32 tgid) throws Error {
var s = ProcessState ();
process_states.lookup_raw ((uint8[]) &tgid, (uint8[]) &s);
return s.abi;
}
public void resolve_stacks (uint32[] stack_ids, StackFramesHandler on_frames) {
var tmp = new uint64[stacks.value_size / sizeof (uint64)];
foreach (var sid in stack_ids) {
uint n = 0;
try {
stacks.lookup_raw ((uint8[]) &sid, (uint8[]) tmp);
for (uint i = 0; i != tmp.length; i++) {
if (tmp[i] == 0)
break;
n++;
}
} catch (Error e) {
}
on_frames (sid, tmp[:n]);
}
}
public delegate void StackFramesHandler (uint32 stack_id, uint64[] frames);
public Stats read_stats () throws Error {
Stats total = Stats ();
uint32 key = 0;
stats.foreach_percpu_value<Stats?> ((uint8[]) &key, (cpu, s) => {
total.emitted_events += s.emitted_events;
total.emitted_bytes += s.emitted_bytes;
total.dropped_events += s.dropped_events;
total.dropped_bytes += s.dropped_bytes;
});
return total;
}
public struct Stats {
public uint64 emitted_events;
public uint64 emitted_bytes;
public uint64 dropped_events;
public uint64 dropped_bytes;
}
}
+31 -14
View File
@@ -32,14 +32,16 @@ backend_deps = []
if host_os == 'android' or have_droidy_backend
subdir('android-helper')
helpers_native_prefix = 'linux' / 'helpers' / 'artifacts' / 'native'
fs = import('fs')
android_data = custom_target('frida-data-android',
input: [
'android.resources',
android_helper_dex,
'linux' / 'helpers' / f'zymbiote-x86.bin',
'linux' / 'helpers' / f'zymbiote-x86_64.bin',
'linux' / 'helpers' / f'zymbiote-arm.bin',
'linux' / 'helpers' / f'zymbiote-arm64.bin',
fs.copyfile(helpers_native_prefix / 'x86' / 'zymbiote.bin', 'zymbiote-x86.bin'),
fs.copyfile(helpers_native_prefix / 'x86_64' / 'zymbiote.bin', 'zymbiote-x86_64.bin'),
fs.copyfile(helpers_native_prefix / 'arm' / 'zymbiote.bin', 'zymbiote-arm.bin'),
fs.copyfile(helpers_native_prefix / 'arm64' / 'zymbiote.bin', 'zymbiote-arm64.bin'),
],
output: [
'frida-data-android.vapi',
@@ -329,6 +331,11 @@ if have_local_backend
'linux' / 'frida-helper-backend-glue.c',
'linux' / 'frida-helper-backend-types.c',
'linux' / 'frida-helper-types.vala',
'linux' / 'activity-sampler.vala',
'linux' / 'syscall-tracer.vala',
'linux' / 'softwall.vala',
'linux' / 'symbol-resolver.vala',
'linux' / 'proc-maps.vala',
]
if host_abi == 'armhf'
host_lowlevel_abi = 'arm'
@@ -340,18 +347,25 @@ if have_local_backend
elif host_lowlevel_abi == 'arm64' and host_machine.endian() == 'big'
host_lowlevel_abi = 'arm64be'
endif
fs = import('fs')
bpf_arch_map = {
'armhf': 'arm',
'armv6kz': 'arm',
'armbe8': 'armbe',
'arm64beilp32': 'arm64be',
}
bpf_arch = bpf_arch_map.get(host_abi, host_abi)
helpers_artifacts_dir = 'linux' / 'helpers' / 'artifacts'
helpers_native_dir = helpers_artifacts_dir / 'native' / host_lowlevel_abi
helpers_bpf_noarch_dir = helpers_artifacts_dir / 'bpf' / ('noarch-' + host_machine.endian())
helpers_bpf_arch_dir = helpers_artifacts_dir / 'bpf' / bpf_arch
helper_backend_data = custom_target('frida-data-helper-backend',
input: [
'linux' / 'frida-helper-backend.resources',
fs.copyfile(
'linux' / 'helpers' / f'bootstrapper-@host_lowlevel_abi@.bin',
'bootstrapper.bin',
),
fs.copyfile(
'linux' / 'helpers' / f'loader-@[email protected]',
'loader.bin',
),
helpers_native_dir / 'bootstrapper.bin',
helpers_native_dir / 'loader.bin',
helpers_bpf_noarch_dir / 'activity-sampler.elf',
helpers_bpf_arch_dir / 'syscall-tracer.elf',
helpers_bpf_noarch_dir / 'softwall.elf',
],
output: [
'frida-data-helper-backend.vapi',
@@ -365,6 +379,9 @@ if have_local_backend
'-o', meson.current_build_dir() / 'frida-data-helper-backend',
'@INPUT1@',
'@INPUT2@',
'@INPUT3@',
'@INPUT4@',
'@INPUT5@',
],
)
helper_backend_sources += [helper_backend_data]
@@ -382,7 +399,7 @@ if have_local_backend
vala_args: [
helper_backend_vala_args,
'--pkg=linux',
'--pkg=linux-system',
'--pkg=frida-linux',
'--pkg=frida-gum-linux-1.0',
],
dependencies: [gio_dep, gio_unix_dep, gee_dep, gum_dep, base_dep] + helper_backend_extra_deps,
+2 -2
View File
@@ -950,8 +950,8 @@ namespace Frida {
construct {
var builder = new VariantBuilder (VariantType.VARDICT);
builder.add ("{sv}", "format", new Variant.string ("rgba"));
builder.add ("{sv}", "width", new Variant.int64 (16));
builder.add ("{sv}", "height", new Variant.int64 (16));
builder.add ("{sv}", "width", new Variant.uint16 (16));
builder.add ("{sv}", "height", new Variant.uint16 (16));
var image = new Bytes (Base64.decode ("AAAAAAAAAAAAAAAAOjo6Dzo6OhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6TZCHbvlycnL4Ojo6iTo6OhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6aa6fdv7878f/+/Te/93d3f9xcXH3Ojo6gTo6Og8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6F4KAfv//5Hn//fHK//r6+v/39/f/9/f3/9LS0v9kZGTzOjo6eDo6OgsAAAAAAAAAAAAAAAAAAAAAAAAAADo6Og6Tk5P/zc3N//z8/P/6+vr/8PDw/+7u7v/p6en/9PT0/8jIyP9XV1f2Ojo6SgAAAAAAAAAAAAAAAAAAAAA6OjoIb29v/8HBwf+5ubn/9/f3/+/v7//p6en/+Pj4/+np6f/o6Oj/4ODg/z09PcsAAAAAAAAAAAAAAAAAAAAAAAAAAjMzM1p8fHz/wsLC/7CwsP/x8fH/8/P0/9zc3f/09PT/+vr6/8vLy/9AQEDFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0tV2pqav7BwcH/rq6u/+bm5v/09PT/s7Oz/93d3f/R0dL/VVVVygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyNRWlpa+7+/v/+wsLD/oaGh/4iIiP9NTU7/VVVW/0BAQf89PT61Pj4/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbG09NTU32urq6/4yMjP9ycnL/Pj4//1BQUf9tbW7/XFxd/z4+P8M+Pj8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMTTD09PfBzc3P/LCwsvDAwMbVEREX/f3+A/6ioqf9tbW7zPj4/lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDQ0vGRkZggAAAAAAAAAAJycnh0NDRP2GhojujIyP4EtLS4k/Pz8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyRoRUVFq21tbp5TU1ZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkpK10AAAAWAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="));
builder.add ("{sv}", "image", Variant.new_from_data (new VariantType ("ay"), image.get_data (), true, image));
_icon = builder.end ();
+2 -2
View File
@@ -40,8 +40,8 @@ namespace Frida {
construct {
var builder = new VariantBuilder (VariantType.VARDICT);
builder.add ("{sv}", "format", new Variant.string ("rgba"));
builder.add ("{sv}", "width", new Variant.int64 (16));
builder.add ("{sv}", "height", new Variant.int64 (16));
builder.add ("{sv}", "width", new Variant.uint16 (16));
builder.add ("{sv}", "height", new Variant.uint16 (16));
var image = new Bytes (Base64.decode ("AAAAAAAAAAAAAAAAOjo6Dzo6OhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6TZCHbvlycnL4Ojo6iTo6OhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6aa6fdv7878f/+/Te/93d3f9xcXH3Ojo6gTo6Og8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6F4KAfv//5Hn//fHK//r6+v/39/f/9/f3/9LS0v9kZGTzOjo6eDo6OgsAAAAAAAAAAAAAAAAAAAAAAAAAADo6Og6Tk5P/zc3N//z8/P/6+vr/8PDw/+7u7v/p6en/9PT0/8jIyP9XV1f2Ojo6SgAAAAAAAAAAAAAAAAAAAAA6OjoIb29v/8HBwf+5ubn/9/f3/+/v7//p6en/+Pj4/+np6f/o6Oj/4ODg/z09PcsAAAAAAAAAAAAAAAAAAAAAAAAAAjMzM1p8fHz/wsLC/7CwsP/x8fH/8/P0/9zc3f/09PT/+vr6/8vLy/9AQEDFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0tV2pqav7BwcH/rq6u/+bm5v/09PT/s7Oz/93d3f/R0dL/VVVVygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyNRWlpa+7+/v/+wsLD/oaGh/4iIiP9NTU7/VVVW/0BAQf89PT61Pj4/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbG09NTU32urq6/4yMjP9ycnL/Pj4//1BQUf9tbW7/XFxd/z4+P8M+Pj8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMTTD09PfBzc3P/LCwsvDAwMbVEREX/f3+A/6ioqf9tbW7zPj4/lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDQ0vGRkZggAAAAAAAAAAJycnh0NDRP2GhojujIyP4EtLS4k/Pz8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyRoRUVFq21tbp5TU1ZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkpK10AAAAWAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="));
builder.add ("{sv}", "image", Variant.new_from_data (new VariantType ("ay"), image.get_data (), true, image));
_icon = builder.end ();
+2 -2
View File
@@ -234,8 +234,8 @@ _frida_icon_from_native_icon_handle (HICON icon, FridaIconSize size)
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "format", g_variant_new_string ("rgba"));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_int64 (width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_int64 (height));
g_variant_builder_add (&builder, "{sv}", "width", g_variant_new_uint16 (width));
g_variant_builder_add (&builder, "{sv}", "height", g_variant_new_uint16 (height));
g_variant_builder_add (&builder, "{sv}", "image",
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, data, rowstride * height, sizeof (guint8)));
result = g_variant_ref_sink (g_variant_builder_end (&builder));
+1 -1
View File
@@ -1,6 +1,6 @@
[wrap-git]
url = https://github.com/frida/frida-gum.git
revision = 17.6.2
revision = bda339b66655f29b5e82277b68235addfbd8fac7
depth = 1
[provide]
+8
View File
@@ -0,0 +1,8 @@
[wrap-git]
url = https://github.com/frida/libbpf.git
revision = 6c8d0d00a122fe126b7a3094f0785340128506f5
depth = 1
[provide]
dependency_names = libbpf
+225
View File
@@ -0,0 +1,225 @@
[CCode (cheader_filename = "bpf/libbpf.h", cprefix = "libbpf_", gir_namespace = "Libbpf", gir_version = "1.0")]
namespace Libbpf {
[Compact]
[CCode (cname = "struct bpf_object", cprefix = "bpf_object__", free_function = "bpf_object__close")]
public class Object {
public static Object open_mem (uint8[] buf, OpenOpts opts);
[Compact]
[CCode (cname = "struct bpf_object_open_opts")]
public struct OpenOpts {
public size_t sz;
public unowned string? object_name;
public bool relaxed_maps;
public unowned string? pin_root_path;
public unowned string? kconfig;
public unowned string? btf_custom_path;
[CCode (array_length_cname = "kernel_log_size")]
public unowned char[] kernel_log_buf;
public uint32 kernel_log_level;
public unowned string? bpf_token_path;
}
public int prepare ();
public int load ();
public unowned Program? find_program_by_name (string name);
public unowned Program? next_program (Program? prog = null);
public unowned Map? find_map_by_name (string name);
public int find_map_fd_by_name (string name);
public unowned Map? next_map (Map? map = null);
}
[Compact]
[CCode (cname = "struct bpf_program", cprefix = "bpf_program__", free_function = "")]
public class Program {
public string name {
[CCode (cname = "bpf_program__name")]
get;
}
public ProgramType ptype {
[CCode (cname = "bpf_program__type")]
get;
}
public string section_name {
[CCode (cname = "bpf_program__section_name")]
get;
}
public bool autoload {
[CCode (cname = "bpf_program__autoload")]
get;
set;
}
public bool autoattach {
[CCode (cname = "bpf_program__autoattach")]
get;
set;
}
public int fd {
[CCode (cname = "bpf_program__fd")]
get;
}
public Link? attach ();
public Link? attach_perf_event (int pfd);
}
[Compact]
[CCode (cname = "struct bpf_map", cprefix = "bpf_map__", free_function = "")]
public class Map {
public string name {
[CCode (cname = "bpf_map__name")]
get;
}
public MapType mtype {
[CCode (cname = "bpf_map__type")]
get;
}
public bool autocreate {
[CCode (cname = "bpf_map__autocreate")]
get;
set;
}
public bool autoattach {
[CCode (cname = "bpf_map__autoattach")]
get;
set;
}
public int fd {
[CCode (cname = "bpf_map__fd")]
get;
}
public uint32 max_entries {
[CCode (cname = "bpf_map__max_entries")]
get;
set;
}
public uint32 key_size {
[CCode (cname = "bpf_map__key_size")]
get;
set;
}
public uint32 value_size {
[CCode (cname = "bpf_map__value_size")]
get;
set;
}
public int reuse_fd (int fd);
public int lookup_elem (uint8[] key, uint8[] val, uint64 flags = 0);
public int update_elem (uint8[] key, uint8[] val, uint64 flags = 0);
public int delete_elem (uint8[] key, uint64 flags = 0);
}
[Compact]
[CCode (cname = "struct bpf_link", cprefix = "bpf_link__", free_function = "bpf_link__destroy")]
public class Link {
public string fd {
[CCode (cname = "bpf_link__fd")]
get;
}
public void disconnect ();
public int detach ();
}
[CCode (cname = "enum bpf_prog_type", cprefix = "BPF_PROG_TYPE_", has_type_id = false)]
public enum ProgramType {
UNSPEC,
SOCKET_FILTER,
KPROBE,
SCHED_CLS,
SCHED_ACT,
TRACEPOINT,
XDP,
PERF_EVENT,
CGROUP_SKB,
CGROUP_SOCK,
LWT_IN,
LWT_OUT,
LWT_XMIT,
SOCK_OPS,
SK_SKB,
CGROUP_DEVICE,
SK_MSG,
RAW_TRACEPOINT,
CGROUP_SOCK_ADDR,
LWT_SEG6LOCAL,
LIRC_MODE2,
SK_REUSEPORT,
FLOW_DISSECTOR,
CGROUP_SYSCTL,
RAW_TRACEPOINT_WRITABLE,
CGROUP_SOCKOPT,
TRACING,
STRUCT_OPS,
EXT,
LSM,
SK_LOOKUP,
SYSCALL,
NETFILTER;
[CCode (cname = "libbpf_bpf_prog_type_str")]
public unowned string? to_string ();
}
[CCode (cname = "enum bpf_map_type", cprefix = "BPF_MAP_TYPE_", has_type_id = false)]
public enum MapType {
UNSPEC,
HASH,
ARRAY,
PROG_ARRAY,
PERF_EVENT_ARRAY,
PERCPU_HASH,
PERCPU_ARRAY,
STACK_TRACE,
CGROUP_ARRAY,
LRU_HASH,
LRU_PERCPU_HASH,
LPM_TRIE,
ARRAY_OF_MAPS,
HASH_OF_MAPS,
DEVMAP,
SOCKMAP,
CPUMAP,
XSKMAP,
SOCKHASH,
CGROUP_STORAGE_DEPRECATED,
REUSEPORT_SOCKARRAY,
PERCPU_CGROUP_STORAGE_DEPRECATED,
QUEUE,
STACK,
SK_STORAGE,
DEVMAP_HASH,
STRUCT_OPS,
RINGBUF,
INODE_STORAGE,
TASK_STORAGE,
BLOOM_FILTER,
USER_RINGBUF,
CGRP_STORAGE,
ARENA,
INSN_ARRAY;
[CCode (cname = "libbpf_bpf_map_type_str")]
public unowned string? to_string ();
}
public int num_possible_cpus ();
public int strerror (int err, char[] buf);
}