Compare commits

...
54 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
Ole André Vadla Ravnås 8c62357b94 subprojects: Prepare for release 2026-01-23 22:31:22 +01:00
Ole André Vadla Ravnås af43551888 subprojects: Bump outdated 2026-01-23 22:30:22 +01:00
Francesco Tamagni f332bddbfc fruity: Fix PortableCoreDevice flush infinite loop (#1207)
By reviving the call to `handle_events_completed` during FLUSHING state,
so that `pending_usb_ops` can get emptied eventually.
2026-01-23 22:29:05 +01:00
NSEcho e1bb883ba0 compiler: Rename conflictful Go symbols (#1205) 2026-01-23 12:40:11 +01:00
Ole André Vadla Ravnås a341cd1292 compiler: Load backend through memfd with fallback
So we retain the benefits of avoiding temporary files when possible.
2026-01-22 15:18:48 +01:00
Ole André Vadla Ravnås 70881a4e40 linux: Fix system session when memfd is restricted
Observed to happen in the Termux environment on Android.
2026-01-22 14:31:19 +01:00
Ole André Vadla Ravnås e0cae3fded subprojects: Prepare for release 2026-01-20 23:12:46 +01:00
Ole André Vadla Ravnås ff28ff33d9 subprojects: Bump outdated 2026-01-20 23:09:17 +01:00
Ole André Vadla Ravnås d072d48dfa subprojects: Bump outdated 2026-01-20 20:26:34 +01:00
Ole André Vadla Ravnås d8557b2c86 submodules: Bump releng 2026-01-20 20:26:34 +01:00
Ole André Vadla Ravnås de8a63b1f3 subprojects: Bump outdated 2026-01-20 18:54:21 +01:00
Ole André Vadla Ravnås 0f53d1b2ee submodules: Bump releng 2026-01-20 18:54:20 +01:00
Ole André Vadla Ravnås a638218794 compiler: Fix loading of backend on Android
The memfd path would typically fail because we were trying to open the
same underlying file with more restrictive permissions.

Avoid this and simplify things by using a temporary file even on systems
where memfd is supported.
2026-01-20 18:48:41 +01:00
Ole André Vadla Ravnås 5ea6e8507a file-descriptor: Add pwrite_all() 2026-01-20 18:45:16 +01:00
Ole André Vadla Ravnås 0ef2a0859b file-descriptor: Fix a stylistic inconsistency 2026-01-20 18:45:06 +01:00
Ole André Vadla Ravnås 01af5b3041 android: Place zymbiote payload on a better range
Picking a range not used by Zygote. The forked app/service might use it,
but by then we will have reverted it.
2026-01-20 13:02:54 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 3df3834f17 android: Fix zymbiote payload on BTI systems
The zymbiote payload must be built with BTI enabled on arm64, otherwise
indirect branches into it will fault.

Co-authored-by: Håvard Sørbø <[email protected]>
2026-01-20 01:12:56 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 31d11965e0 linux: Fix alignment in the helper linker script
Ensure .payload is 4 KiB–aligned to match ADRP page semantics on arm64.

Co-authored-by: Håvard Sørbø <[email protected]>
2026-01-20 01:10:06 +01:00
107 changed files with 14947 additions and 414 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
+21 -1
View File
@@ -71,7 +71,7 @@ namespace Frida {
public void pread_all (uint8[] buf, uint64 offset) throws Error {
size_t total = 0;
while (total < buf.length) {
while (total != buf.length) {
void * dst = (uint8 *) buf + total;
size_t remaining = buf.length - total;
@@ -104,6 +104,26 @@ namespace Frida {
return res;
}
}
public void pwrite_all (uint8[] buf, uint64 offset) throws Error {
size_t total = 0;
while (total != buf.length) {
uint8[] chunk = buf[total : buf.length];
while (true) {
ssize_t res = Posix.pwrite (handle, chunk, chunk.length, (Posix.off_t) (offset + total));
if (res == -1) {
if (errno == Posix.EINTR)
continue;
throw new Error.TRANSPORT ("%s", strerror (errno));
}
total += (size_t) res;
break;
}
}
}
}
public StdioPipes? make_stdio_pipes (Stdio stdio, bool in_supported, out FileDescriptor? in_fd, out string? in_name,
+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: 71f828f7c8...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)]
+25 -45
View File
@@ -85,8 +85,31 @@ def build_backend(
)
if mode == "c-archive":
symbols_to_scramble = detect_conflictful_symbols_in_archive(backend_a, config["nm"])
scramble_symbols_in_archive(backend_a, symbols_to_scramble, config["ranlib"])
symbol_dest = priv_dir / "symbol-replacer"
symbol_dest.mkdir(parents=True, exist_ok=True)
src_dir = base_dir / "symbol-replacer"
for name in ("main.go", "trie.go", "go.mod"):
shutil.copy(src_dir / name, symbol_dest)
env_copy = config["env"].copy()
env_copy.pop("GOOS", None)
env_copy.pop("GOARCH", None)
symbol_replacer_name = "frida-symbol-replacer"
subprocess.run(
[go, "build", "-buildvcs=false", "-o", symbol_replacer_name, "."],
cwd=symbol_dest,
env=env_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
encoding="utf-8",
check=True,
)
run(priv_dir / "symbol-replacer" / symbol_replacer_name,
backend_a.name, *config["nm"], *config["ranlib"], config["env"]["CC"])
if (mingw := config.get("mingw")) is not None and (abi := config["abi"]) in {
"x86",
@@ -133,49 +156,6 @@ def build_backend(
shutil.copy(priv_dir / backend_h.name, output_dir / backend_h.name)
def detect_conflictful_symbols_in_archive(
archive: Path, nm_cmd_array: List[str]
) -> List[str]:
result = []
for line in subprocess.run(
[*nm_cmd_array, str(archive)], capture_output=True, encoding="utf-8", check=True
).stdout.splitlines():
tokens = line.lstrip().split(" ")
if len(tokens) >= 3 and tokens[1] in {"S", "T"}:
symbol = tokens[2]
if all(sub not in symbol for sub in ("/", ".", ":", "frida")):
result.append(symbol)
return result
def scramble_symbols_in_archive(
archive: Path, symbols: List[str], ranlib_cmd_array: List[str]
):
data = archive.read_bytes()
for old_sym in symbols:
new_sym = roll_first_alpha(old_sym)
data = data.replace(old_sym.encode("ascii"), new_sym.encode("ascii"))
archive.write_bytes(data)
subprocess.run([*ranlib_cmd_array, str(archive)], check=True)
def roll_first_alpha(s: str) -> str:
chars = list(s)
for i, c in enumerate(chars):
if c.isalpha():
if c == "z":
chars[i] = "a"
elif c == "Z":
chars[i] = "A"
else:
chars[i] = chr(ord(c) + 1)
break
return "".join(chars)
# Work around the Go toolchain's almost-MSVC-compatible object files
# until our patch is merged upstream:
# https://go-review.googlesource.com/c/go/+/678795
+22 -16
View File
@@ -243,30 +243,36 @@ namespace Frida {
#else
unowned uint8[] backend_so = Frida.Data.Compiler.get_frida_compiler_backend_so_blob ().data;
FileDescriptor fd;
Module? backend = null;
if (MemoryFileDescriptor.is_supported ()) {
fd = MemoryFileDescriptor.from_bytes ("frida-compiler-backend.so", new Bytes.static (backend_so));
} else {
string name_used;
var fd = MemoryFileDescriptor.from_bytes ("frida-compiler-backend.so", new Bytes.static (backend_so));
try {
fd = new FileDescriptor (FileUtils.open_tmp ("frida-compiler-backend-XXXXXX.so", out name_used));
backend = new Module ("/proc/self/fd/%d".printf (fd.handle), LOCAL);
} catch (ModuleError e) {
}
}
if (backend == null) {
try {
string name_used;
{
var fd = new FileDescriptor (FileUtils.open_tmp ("frida-compiler-backend-XXXXXX.so", out name_used));
fd.pwrite_all (backend_so, 0);
}
try {
backend = new Module (name_used, LOCAL);
} catch (ModuleError e) {
assert_not_reached ();
}
FileUtils.unlink (name_used);
var output = new UnixOutputStream (fd.handle, false);
output.write_all (backend_so, null);
Posix.lseek (fd.handle, 0, Posix.SEEK_SET);
} catch (GLib.Error e) {
assert_not_reached ();
}
}
Module backend;
try {
backend = new Module ("/proc/self/fd/%d".printf (fd.handle), LOCAL);
} catch (ModuleError e) {
assert_not_reached ();
}
build = resolve_symbol (backend, "_frida_compiler_backend_build");
watch = resolve_symbol (backend, "_frida_compiler_backend_watch");
WatchSession.dispose = resolve_symbol (backend, "_frida_compiler_backend_watch_session_dispose");
+3
View File
@@ -0,0 +1,3 @@
module github.com/frida/frida-symbol-replacer
go 1.24.4
+135
View File
@@ -0,0 +1,135 @@
package main
import (
"bytes"
"io"
"os"
"os/exec"
"runtime"
"strings"
"unicode"
)
var (
excludeSymbols = [][]byte{
[]byte("fprintf"),
[]byte("pthread"),
[]byte("cas"),
}
)
func main() {
archive := os.Args[1]
nm := os.Args[2]
ranlib := os.Args[3]
cc := os.Args[4]
buf := new(bytes.Buffer)
c := exec.Command(nm, archive)
c.Stdout = buf
if err := c.Run(); err != nil {
panic(err)
}
t := newTrie()
t.insert([]byte("internal/"), flipAlpha([]byte("internal/")))
var content [][]byte
if runtime.GOOS == "windows" {
if strings.Contains(cc, "clangarm64") {
content = bytes.Split(buf.Bytes(), []byte{'\n'})
} else {
content = bytes.Split(buf.Bytes(), []byte("\r\n"))
}
} else {
content = bytes.Split(buf.Bytes(), []byte{'\n'})
}
for _, line := range content {
splitted := bytes.Split(line, []byte{' '})
if len(splitted) >= 3 {
symbolType := splitted[1]
symbol := splitted[2]
symbolLower := bytes.ToLower(symbol)
if bytes.ContainsAny(symbolType, "TSt") {
if symbolIsOkay(symbolLower) {
t.insert(symbol, flipAlpha(symbol))
}
} else if bytes.ContainsAny(symbolType, "Rrd") {
if bytes.HasPrefix(symbolLower, []byte("go:")) {
t.insert(symbol, flipAlpha(symbol))
}
}
}
}
f, err := os.OpenFile(archive, os.O_RDWR, 0755)
if err != nil {
panic(err)
}
data, _ := io.ReadAll(f)
modifiedData := make([]byte, len(data))
for i := 0; i < len(data); {
if l, replacement, ok := t.search(data, i); ok {
copy(modifiedData[i:], replacement)
i += l
} else {
modifiedData[i] = data[i]
i++
}
}
f.Truncate(0)
f.Seek(0, 0)
f.Write(modifiedData)
f.Close()
ranl := exec.Command(ranlib, archive)
if err := ranl.Run(); err != nil {
panic(err)
}
}
func flipAlpha(s []byte) []byte {
dt := make([]byte, len(s))
copy(dt, s)
for i, r := range s {
if unicode.IsLetter(rune(r)) || unicode.IsNumber(rune(r)) {
if r == 'z' {
dt[i] = 'a'
} else if r == 'Z' {
dt[i] = 'A'
} else {
dt[i] = r + 1
}
break
}
}
return dt
}
func symbolIsOkay(symbol []byte) bool {
switch {
case bytes.Contains(symbol, []byte("frida")):
return false
case bytes.Contains(symbol, []byte("rt0")):
return true
case bytes.Contains(symbol, []byte("cgo")):
return true
case bytes.ContainsAny(symbol, "./"):
return true
default:
for _, s := range excludeSymbols {
if bytes.Contains(symbol, s) {
return false
}
}
return true
}
}
+52
View File
@@ -0,0 +1,52 @@
package main
type trieNode struct {
children map[byte]*trieNode
isEnd bool
replacement []byte
}
type trie struct {
root *trieNode
}
func newTrie() *trie {
return &trie{
root: &trieNode{
children: make(map[byte]*trieNode),
},
}
}
func (t *trie) insert(pattern, value []byte) {
node := t.root
for _, b := range pattern {
if node.children[b] == nil {
node.children[b] = &trieNode{children: make(map[byte]*trieNode)}
}
node = node.children[b]
}
node.isEnd = true
node.replacement = value
}
func (t *trie) search(data []byte, start int) (int, []byte, bool) {
node := t.root
maxLen := 0
var match []byte
for i := start; i < len(data); i++ {
b := data[i]
node = node.children[b]
if node == nil {
break
}
if node.isEnd {
maxLen = i - start + 1
match = node.replacement
}
}
if maxLen > 0 {
return maxLen, match, true
}
return 0, nil, false
}
+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) {
+4 -4
View File
@@ -1149,17 +1149,17 @@ namespace Frida.Fruity {
}
lock (state) {
if (pending_usb_ops.is_empty)
if (pending_usb_ops.is_empty) {
state = STOPPING;
break;
}
}
continue;
}
int completed = 0;
usb_context.handle_events_completed (out completed);
if (AtomicUint.compare_and_exchange (ref polled_usb_outdated, 1, 0))
if (s != FLUSHING && AtomicUint.compare_and_exchange (ref polled_usb_outdated, 1, 0))
refresh_polled_usb_devices ();
}
+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";
+1 -1
View File
@@ -1,7 +1,7 @@
SECTIONS {
. = 0;
.payload : ALIGN(16)
.payload : ALIGN(4096)
{
KEEP(*(.text.entrypoint))
*(.text*)
+5 -1
View File
@@ -88,9 +88,13 @@ custom_target('loader-bin',
)
if host_machine.system() == 'android'
zymbiote_flags = []
if host_machine.cpu_family() == 'aarch64'
zymbiote_flags += '-mbranch-protection=bti'
endif
zymbiote = shared_module('zymbiote', ['zymbiote.c'],
name_prefix: '',
c_args: extra_flags,
c_args: zymbiote_flags + extra_flags,
link_args: extra_link_args,
link_depends: [helper_lds],
)
@@ -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
Binary file not shown.
+756 -2
View File
@@ -162,7 +162,20 @@ namespace Frida {
if (path == null)
path = tpl.expand (arch_name);
system_session_container = yield AgentContainer.create (path, cancellable);
#if HAVE_EMBEDDED_ASSETS
try {
#endif
system_session_container = yield AgentContainer.create (path, cancellable);
#if HAVE_EMBEDDED_ASSETS
} catch (Error e) {
if (MemoryFileDescriptor.is_supported ()) {
path = agent.get_path_template ().expand (arch_name);
system_session_container = yield AgentContainer.create (path, cancellable);
} else {
throw e;
}
}
#endif
connection = system_session_container.connection;
@@ -376,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) {
@@ -748,6 +783,7 @@ namespace Frida {
ZymbioteConnection? connection;
if (!zymbiote_connections.unset (pid, out connection))
return false;
connection.resume.begin (io_cancellable);
HostSpawnInfo? info;
@@ -929,7 +965,7 @@ namespace Frida {
while (iter.next ()) {
string path = iter.path;
string flags = iter.flags;
if (path.has_prefix ("/system/bin/app_process") && "x" in flags) {
if (path.has_suffix ("/libstagefright.so") && "x" in flags) {
if (payload_base == 0) {
payload_base = iter.end_address - Gum.query_page_size ();
payload_path = path;
@@ -1756,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,
Loaded 100 of 107 files, more files were not shown because too many files have changed in this diff. Show more