Compare commits

..
145 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
Ole André Vadla Ravnås 2e705e3f44 subprojects: Prepare for release 2026-01-17 08:43:29 +01:00
Ole André Vadla Ravnås 13c3e00be3 subprojects: Bump outdated 2026-01-17 00:24:19 +01:00
Ole André Vadla Ravnås 90164ccf7a subprojects: Bump outdated 2026-01-16 15:31:46 +01:00
Ole André Vadla Ravnås 3f9159e80a libc-shim: Revive FreeBSD support 2026-01-16 12:58:13 +00:00
Ole André Vadla Ravnås d4ca46a213 subprojects: Bump outdated 2026-01-16 13:44:36 +01:00
Ole André Vadla Ravnås 126ab29dce submodules: Bump releng 2026-01-16 13:44:36 +01:00
Ole André Vadla Ravnås 5104b0d08e libc-shim: Fix portability regressions
- Make stdio handling compatible with musl by treating FILE as
  opaque and fixing stdin/stdout/stderr definitions.
- Improve Linux compatibility.
- Add Darwin dirent shim.
- Fix MSVC support.
2026-01-16 13:34:11 +01:00
Ole André Vadla Ravnås 55c8bcb8ec fruity: Fix USB startup/shutdown race
Fix a race where stopping shortly after startup could leave the USB
worker blocked inside libusb_handle_events_completed().

Restructure the USB event loop to observe state transitions before
entering blocking libusb calls, ensuring FLUSHING and STOPPING are
handled deterministically.

Make initial USB enumeration during startup robust by gating completion
on a startup barrier and tracking in-flight arrivals, deduplicated by
device ID. This accounts for libusb HOTPLUG_ENUMERATE semantics where
arrival callbacks may be duplicated or delayed.

Together these changes ensure startup only completes once all initially
present devices are known, and shutdown cannot deadlock the USB thread.
2026-01-16 10:47:21 +01:00
Ole André Vadla Ravnås 4fbfae9b92 subprojects: Bump outdated 2026-01-15 18:07:56 +01:00
Ole André Vadla Ravnås 4d1e9f1113 submodules: Bump releng 2026-01-15 18:07:56 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 3e778a99c0 android: Move to light-weight Zygote hooking
Instead of injecting an internal agent into the Zygote/USAP processes
and using child gating, rethink this completely:

1. Write a tiny payload into a code region through /proc/$pid/mem.
2. Patch the ArtMethod of android.os.Process.setArgV0Native() so it
   jumps to the payload.
3. The payload acts as a proxy, chaining to the original setArgV0Native.
4. It also makes a UNIX socket connection back to frida-core, giving it
   a chance to instrument it.

Co-authored-by: Håvard Sørbø <[email protected]>
2026-01-15 18:06:05 +01:00
Ole André Vadla Ravnås 2d2a944d8e file-descriptor: Add pread{,_all}() and pwrite() 2026-01-15 18:06:00 +01:00
Ole André Vadla Ravnås 0ba8b05fef linux: Fix the WaitResult constructor
Early returns from a struct constructor results in the Vala compiler
generating invalid C code. We'll just avoid this pattern for now.
2026-01-15 18:05:56 +01:00
Ole André Vadla Ravnås 783626e8fb android: Ignore noisy frida-helper.dex warnings
Coming from the dynamic linker on older Android OSes.
2026-01-15 12:53:39 +01:00
Ole André Vadla Ravnås 7399cc1092 android: Improve frida-helper.dex Android compat
- Support Android OS versions as far back as 4.4.
- Improve get_frontmost_application() to support a wider range of
  versions, not just Android >= 10.
2026-01-15 12:53:34 +01:00
Ole André Vadla Ravnås cefa0d0567 libc-shim: Improve stylistic consistency 2026-01-15 12:02:13 +01:00
Ole André Vadla Ravnås 0824ee85d9 libc-shim: Fix Android SELinux getline() UB
Fix a long-standing heap corruption/UB on Android caused by the SELinux
userspace library running a constructor that calls getline() and then
free().

Only free() went through our libc shim, while getline() allocated using
libc's heap, so the pointer was freed by the wrong allocator.

Add a minimal stdio shim (including getline()/getdelim()) and related
FILE*/__sF handling so allocations stay on the shim heap and are cleaned
up correctly.
2026-01-15 01:24:32 +01:00
Ole André Vadla Ravnås bea37618d1 android: Fix app spawn() on older Android versions 2026-01-13 22:45:36 +01:00
Ole André Vadla Ravnås cae7be99f8 meson: Fix Android dirty build from backend output 2026-01-11 14:21:56 +01:00
Ole André Vadla Ravnås 4406c8d146 android: Unlink frida-helper.dex on early error 2026-01-11 14:21:56 +01:00
Ole André Vadla Ravnås c89190e4f6 android: Explicitly set frida-helper.dex file mode 2026-01-11 14:21:56 +01:00
Ole André Vadla Ravnås dd68e84217 android: Improve frida-helper.dex spawn logic
- Include stderr and logcat output when unable to spawn.
- Process stdout and stderr. There shouldn't be any output on either,
  so if there is we definitely want to see it. This also makes it easier
  to add temporary logging to the helper.
2026-01-11 14:21:56 +01:00
Ole André Vadla Ravnås dc56b2eb16 subprojects: Bump outdated 2026-01-11 00:48:04 +01:00
Ole André Vadla Ravnås 1b908e69f3 android: Migrate to frida-helper.dex
Previously this helper was only used on non-rooted systems.
We now use it universally, which lets us stop injecting code
into system_server and drop the dependency on frida-java-bridge.

The only functionality lost is launch-timeout suppression.
2026-01-11 00:14:55 +01:00
Ole André Vadla Ravnås fae32353e1 linux: Fix ptrace signal waiter forwarding
Signal wait helpers could incorrectly forward ptrace-internal stops
(e.g. event SIGTRAPs) or syscall-stops back into the tracee while
waiting for a specific signal. This can perturb execution and break
spawn/attach flows.

Use WaitResult.should_deliver_to_tracee to gate signal reinjection.
Waiters now always satisfy the requested stop first, and only pass
through unmatched stops when they represent a real deliverable
signal.
2026-01-08 14:08:01 +01:00
Ole André Vadla Ravnås babe40274f linux: Fix ptrace syscall tracing desync
Syscall tracing could become desynchronized when the tracee stopped for
non-syscall reasons (e.g. PTRACE_EVENT_EXEC or real signals). These
SIGTRAP stops were incorrectly treated as syscall entry/exit points,
leading to bogus syscall IDs and eventual timeouts.

Fix this by decoding the raw waitpid() status into a structured
WaitResult, distinguishing syscall-stops, ptrace event stops, and real
signal stops. The syscall entry/exit phase is now advanced only on true
syscall-stops, and ptrace-internal traps are no longer reinjected into
the tracee.
2026-01-08 13:42:14 +01:00
Ole André Vadla Ravnås d19036305d subprojects: Bump outdated 2026-01-06 22:40:20 +01:00
Ole André Vadla Ravnås 1572fb6594 submodules: Bump releng 2026-01-06 22:40:19 +01:00
wyxhjr 747a9cd172 Add preliminary support for RISC-V (#1201) 2026-01-06 20:06:58 +01:00
Francesco Tamagni 8ff3a58612 fruity: Throw CLOSED on tcp write in closed state
In this way the stream stops being polled and an infinite loop is
avoided.
2026-01-06 20:03:50 +01:00
Ole André Vadla Ravnås bcd4a3d586 subprojects: Prepare for release 2025-12-15 21:28:35 +01:00
Ole André Vadla Ravnås 9937b40032 subprojects: Bump outdated 2025-12-15 21:16:49 +01:00
Ole André Vadla Ravnås 81299af1ef darwin: Use DO_NOT_REAP_CHILD when spawning helper
When the system is booted without -arm64e_preview_abi, the helper
binary is killed very early during startup. Enabling
DO_NOT_REAP_CHILD allows GLib to use posix_spawn(), insulating the
host process from signal-related side effects during helper launch.

This means the child process is no longer reaped automatically.
Since this code may run inside a host process that installs its own
signal handlers, GLib's child-watch support cannot be used. Instead,
the helper is reaped explicitly using non-blocking polling.
2025-12-15 17:54:19 +01:00
Ole André Vadla Ravnås f76a3315e7 submodules: Bump releng 2025-12-15 15:06:33 +01:00
Ole André Vadla Ravnås f5c01842c9 meson: Avoid repeating the GLib requirement 2025-12-15 15:05:40 +01:00
Ole André Vadla Ravnås 40879413c0 meson: Remove the unused frida_profile variable 2025-12-15 12:43:25 +01:00
Ole André Vadla Ravnås ab4a7f43f6 meson: Update version logic to support snapshot tags 2025-12-15 12:31:16 +01:00
Ole André Vadla Ravnås 8ed4a69e03 meson: Restore support for GLib being a subproject
Which was broken when gio-unix-2.0 became part of the public API on
non-Windows systems.
2025-12-15 12:09:12 +01:00
Ole André Vadla Ravnås d93557625d ci: Move xcframework .modulemap inside a subdir
To avoid clashes when an app links with multiple static frameworks, each
with their own modulemap.
2025-12-11 15:12:50 +01:00
Ole André Vadla Ravnås 7ecebf23b1 ci: Remove snapshot-tag.yml
Actually triggering ci.yml seems like a rabbit-hole. Leaving for later.
2025-12-08 23:48:06 +01:00
Ole André Vadla Ravnås e2b4b120d7 ci: Add modulemap to xcframework for FridaCore
Add a Clang module.modulemap to each header slice in the generated
FridaCore.xcframework so SwiftPM can load the FridaCore C module.
2025-12-08 23:44:34 +01:00
Ole André Vadla Ravnås e1cb645805 ci: Fix some stylistic inconsistencies 2025-12-08 23:43:35 +01:00
Ole André Vadla Ravnås a0ea09d4d6 ci: Improve snapshot-tag.yml so it triggers ci.yml 2025-12-08 22:46:53 +01:00
Ole André Vadla Ravnås 0f32cc8f4e darwin: Emit 128px app icons on macOS
Instead of two small sizes, we'll emit just one larger one.
2025-12-08 22:29:15 +01:00
Ole André Vadla Ravnås 46a566655f submodules: Bump releng 2025-12-08 22:21:08 +01:00
Ole André Vadla Ravnås 690597f908 ci: Add workflow for automated snapshot tagging 2025-12-08 22:21:08 +01:00
Ole André Vadla Ravnås 0c49c7ee62 ci: Publish releases with .xcframework 2025-12-08 22:21:08 +01:00
Ole André Vadla Ravnås ce40c30a20 ci: Build and upload .xcframework artifact 2025-12-08 22:21:08 +01:00
Ole André Vadla Ravnås 3bb44c222a ci: Add ios-arm64-simulator to the mobile matrix 2025-12-08 22:21:07 +01:00
Ole André Vadla Ravnås 5ec73cab32 ci: Temporarily disable mobile tests
As the backend infrastructure needs some love.
2025-12-08 18:05:39 +01:00
Ole André Vadla Ravnås 257f198659 ci: Fix the emulator job 2025-12-08 18:05:39 +01:00
Ole André Vadla Ravnås 5fca68ebe0 ci: Fix the macOS/x86_64 job
As --host was omitted, we ended up building for macOS/arm64.
2025-12-08 18:05:39 +01:00
Ole André Vadla Ravnås 9eab4f8975 linux: Add missing Gum #include
Which only worked in the past due to luck, i.e. some unrelated code
including it.
2025-11-12 13:18:00 +00:00
Ole André Vadla Ravnås afd8c8789f subprojects: Prepare for release 2025-11-05 18:59:04 +01:00
Ole André Vadla Ravnås cfd5a730e4 subprojects: Bump outdated 2025-11-05 18:57:16 +01:00
Ole André Vadla Ravnås 3f411908e7 subprojects: Prepare for release 2025-11-04 10:30:52 +01:00
Ole André Vadla Ravnås 4e44f4d243 subprojects: Bump outdated 2025-11-04 10:29:26 +01:00
Leo Conforti 9573f1aa22 compiler: Add platform and externals options
Introduce a platform property and externals API to CompilerOptions, and
plumb them through to the Go backend. The backend maps the platform to an
esbuild platform and passes externals to esbuild for exclusion from the
bundle.
2025-11-04 09:52:09 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 79a08e4767 simmy: Wire up spawn() argv and env options
Though `argv` was already wired up for the program case, we didn't wire
it up for the app case.

Co-authored-by: Håvard Sørbø <[email protected]>
2025-11-03 19:30:56 +01:00
Ole André Vadla Ravnås 57dfe9d5ad subprojects: Prepare for release 2025-11-01 00:38:11 +01:00
Ole André Vadla Ravnås 347662b45b subprojects: Bump outdated 2025-11-01 00:36:24 +01:00
Ole André Vadla Ravnås cc95375136 darwin: Revive app listing/launching on iOS >= 16
When running on rootful systems. This brings dccb612 back to life.
It was broken in 8108d4d, which fixed two Interceptor singleton leaks.
Turns out the one in springboard.m was intentional, as it was done as
part of init-once logic, with no teardown intended. And since nothing
else uses Interceptor in this case, the instrumentation we just
applied gets reverted right away.

Kudo to @alexhude for reporting.
2025-11-01 00:23:17 +01:00
Ole André Vadla Ravnås 329c4075d0 subprojects: Prepare for release 2025-10-31 20:24:06 +01:00
Ole André Vadla Ravnås c4198498d5 subprojects: Bump outdated 2025-10-31 20:21:36 +01:00
Ole André Vadla Ravnås 20ef7bb318 simmy: Degrade functionality when SIP is enabled
As get_frontmost_application() and icons rely on being able to inject
our internal agent into SpringBoard.

Down the road we might be able to reimplement this functionality as a
helper program that we spawn inside the Simulator runtime. The uncertain
part is whether we'll be able to give that program the appropriate
entitlements.
2025-10-31 20:09:20 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 367f8cf22b simmy: Handle app enumeration with selected IDs
Co-authored-by: Håvard Sørbø <[email protected]>
2025-10-30 14:58:35 +01:00
Ole André Vadla Ravnås 9f04675b87 subprojects: Prepare for release 2025-10-29 16:47:53 +01:00
Ole André Vadla Ravnås cd8bda0513 subprojects: Bump outdated 2025-10-29 16:45:40 +01:00
Ole André Vadla RavnåsandHåvard Sørbø e09e09fb85 simmy: Wire up application icons
Co-authored-by: Håvard Sørbø <[email protected]>
2025-10-29 15:08:50 +01:00
Ole André Vadla RavnåsandHåvard Sørbø c24a5da82c simmy: Implement get_frontmost_application()
Co-authored-by: Håvard Sørbø <[email protected]>
2025-10-29 15:01:15 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 05ec6563d1 internal-agent: Support non-local HostSession
So we can use it in the Simmy backend, too.

Co-authored-by: Håvard Sørbø <[email protected]>
2025-10-28 14:12:01 +01:00
Ole André Vadla RavnåsandHåvard Sørbø 9dc9d30fa4 simmy: Fix the reported hardware.product
In query_system_parameters().

So it's e.g. `iPhone18,2` instead of `iPhone 17 Pro Max`.

Co-authored-by: Håvard Sørbø <[email protected]>
2025-10-28 13:15:38 +01:00
Ole André Vadla Ravnås 0b57936285 subprojects: Prepare for release 2025-10-24 15:25:15 +02:00
Ole André Vadla Ravnås 41be857a91 subprojects: Bump outdated 2025-10-24 15:23:37 +02:00
Ole André Vadla Ravnås afa847b898 submodules: Bump releng 2025-10-24 15:23:37 +02:00
Ole André Vadla Ravnås 3e43478de0 android: Bump frida-java-bridge in system-server 2025-10-24 15:22:18 +02:00
Ole André Vadla Ravnås a847a012c9 freebsd: Wire up PTY support 2025-10-12 08:11:13 +02:00
Ole André Vadla Ravnås c34fad1ff0 freebsd: Port remaining bits to the new stdio API 2025-10-12 07:50:00 +02:00
Ole André Vadla Ravnås ceef1d696b darwin: Fix a stylistic inconsistency 2025-10-12 07:47:09 +02:00
Ole André Vadla Ravnås d0cfe69dba subprojects: Prepare for release 2025-10-11 19:22:49 +02:00
Ole André Vadla Ravnås a35aff1865 api: Exclude HostSessionHub from .gir
As it's an internal interface.
2025-10-11 11:46:28 +02:00
Ole André Vadla Ravnås be8a59607a android: Bump frida-java-bridge in system-server 2025-10-11 11:07:51 +02:00
Ole André Vadla Ravnås 726740f96a simmy: Move to CoreSimulator.framework 2025-10-10 12:34:41 +02:00
Ole André Vadla Ravnås 9e11d57a76 Add new Simmy backend
For interacting with Apple's simulators on macOS.
2025-10-10 12:34:41 +02:00
Ole André Vadla Ravnås d8c3c9bfb5 darwin: Support early instrumentation of dyld_sim 2025-10-10 12:34:41 +02:00
Ole André Vadla Ravnås 2720968791 base: Add StdioPipes and FileDescriptor helpers
Factored out of the Darwin and Linux backends.
2025-10-10 12:34:41 +02:00
Ole André Vadla Ravnås b8998e52cd host-session: Support cross-backend communication 2025-10-10 12:34:41 +02:00
Ole André Vadla Ravnås c23f046968 value: Add VariantReader.list_members() 2025-10-10 12:34:41 +02:00
Francesco Tamagni 2d521bbeb7 fruity: Unpair on InvalidHostID
So the error doesn't become persistent, and the
device can be paired again.
2025-10-07 11:37:57 +02:00
Ole André Vadla Ravnås cdae790ba9 darwin: Port to the latest Gum.Darwin API 2025-10-01 10:52:33 +02:00
Ole André Vadla Ravnås 90d2d93799 subprojects: Bump outdated 2025-10-01 10:49:57 +02:00
163 changed files with 22808 additions and 4884 deletions

No files matched your search

+145 -6
View File
@@ -2,11 +2,15 @@ name: CI
on:
push:
branches:
- main
pull_request:
branches:
- main
workflow_dispatch:
inputs:
tag:
description: "Tag to build/test"
required: false
type: string
env:
FRIDA_CORE_OPTIONS: '--with-devkits=core --enable-tests'
@@ -71,6 +75,7 @@ jobs:
if: ${{ !startsWith(matrix.id, 'windows-') && matrix.id != 'linux-x86' }}
run: |
./configure \
--host=${{ matrix.id }} \
--enable-compiler-backend \
${{ env.FRIDA_CORE_OPTIONS }}
make
@@ -205,7 +210,7 @@ jobs:
/sbin/entropy
cat /etc/motd
export PS1='\u@frida:\w\$ '
/root/frida-tests
/root/tests/frida-tests
status=\$?
echo "exit status: \$status"
if [ \$status -eq 0 ]; then
@@ -281,7 +286,8 @@ jobs:
COPY initscript /tmp/initramfs/init
RUN chmod +x /tmp/initramfs/init
COPY build/tests /tmp/initramfs/root/
COPY build/tests /tmp/initramfs/root/tests/
COPY build/lib/agent/frida-agent.so /tmp/initramfs/root/lib/agent/
RUN find . | cpio -o --format=newc -R root:root > /root/initramfs.img
COPY launch.sh /root/launch.sh
@@ -297,6 +303,7 @@ jobs:
matrix:
id:
- ios-arm64
- ios-arm64-simulator
- android-x86
- android-x86_64
- android-arm
@@ -341,6 +348,7 @@ jobs:
name: core-devkit-${{ matrix.id }}
path: build/src/devkit/
- name: Package tests
if: false
run: |
mkdir -p /tmp/pkg
cd build
@@ -360,7 +368,7 @@ jobs:
esac
tar -C /tmp/pkg -czf /tmp/runner.tar.gz .
- name: Test on Corellium iOS device
if: matrix.id == 'ios-arm64'
if: false
continue-on-error: true
uses: frida/corellium-action@v4
with:
@@ -376,7 +384,7 @@ jobs:
tar xf $ASSET_PATH
./frida-tests
- name: Test on Corellium Android device
if: matrix.id == 'android-arm64'
if: false
continue-on-error: true
uses: frida/corellium-action@v4
with:
@@ -480,3 +488,134 @@ jobs:
else
echo "No unexpected changes detected."
fi
xcframework:
name: Build FridaCore.xcframework
runs-on: macos-latest
needs:
- native
- mobile
steps:
- name: Check out repo
uses: actions/checkout@v4
- name: Download macOS/x86_64 devkit
uses: actions/download-artifact@v4
with:
name: core-devkit-macos-x86_64
path: devkits/macos-x86_64
- name: Download macOS/arm64 devkit
uses: actions/download-artifact@v4
with:
name: core-devkit-macos-arm64
path: devkits/macos-arm64
- name: Download iOS/arm64 devkit
uses: actions/download-artifact@v4
with:
name: core-devkit-ios-arm64
path: devkits/ios-arm64
- name: Download iOS/arm64-simulator devkit
uses: actions/download-artifact@v4
with:
name: core-devkit-ios-arm64-simulator
path: devkits/ios-arm64-simulator
- name: Create FridaCore.xcframework
shell: bash
run: |
set -euo pipefail
mkdir -p devkits/macos-universal
lipo -create \
devkits/macos-x86_64/libfrida-core.a \
devkits/macos-arm64/libfrida-core.a \
-output devkits/macos-universal/libfrida-core.a
platforms=(
"macos-universal"
"ios-arm64"
"ios-arm64-simulator"
)
for platform in "${platforms[@]}"; do
mkdir -p "xcframework_headers/${platform}/FridaCore"
done
cp devkits/macos-x86_64/frida-core.h \
xcframework_headers/macos-universal/frida-core-x86_64.h
cp devkits/macos-arm64/frida-core.h \
xcframework_headers/macos-universal/frida-core-arm64.h
cat > xcframework_headers/macos-universal/frida-core.h <<'EOF'
#if defined (__x86_64__)
# include "frida-core-x86_64.h"
#elif defined (__arm64__)
# include "frida-core-arm64.h"
#else
# error "Unsupported macOS architecture for FridaCore"
#endif
EOF
cp devkits/ios-arm64/frida-core.h \
xcframework_headers/ios-arm64/frida-core.h
cp devkits/ios-arm64-simulator/frida-core.h \
xcframework_headers/ios-arm64-simulator/frida-core.h
for platform in "${platforms[@]}"; do
cat > "xcframework_headers/${platform}/FridaCore/module.modulemap" <<'EOF'
module FridaCore [extern_c] {
header "../frida-core.h"
export *
}
EOF
done
xcodebuild -create-xcframework \
-library devkits/macos-universal/libfrida-core.a \
-headers xcframework_headers/macos-universal \
-library devkits/ios-arm64/libfrida-core.a \
-headers xcframework_headers/ios-arm64 \
-library devkits/ios-arm64-simulator/libfrida-core.a \
-headers xcframework_headers/ios-arm64-simulator \
-output FridaCore.xcframework
- name: Upload FridaCore.xcframework
uses: actions/upload-artifact@v4
with:
name: FridaCore.xcframework
path: FridaCore.xcframework
publish-xcframework:
if: github.ref_type == 'tag'
runs-on: macos-latest
needs:
- xcframework
steps:
- name: Download FridaCore.xcframework artifact
uses: actions/download-artifact@v4
with:
name: FridaCore.xcframework
path: dist
- name: Rewrap into FridaCore.xcframework directory
shell: bash
run: |
set -euo pipefail
cd dist
mkdir -p FridaCore.xcframework
shopt -s dotglob
for f in *; do
if [[ "$f" != "FridaCore.xcframework" ]]; then
mv "$f" FridaCore.xcframework/
fi
done
- name: Zip FridaCore.xcframework
run: |
cd dist
zip -r FridaCore.xcframework.zip FridaCore.xcframework
- name: Create GitHub release
uses: softprops/action-gh-release@v2
with:
files: |
dist/FridaCore.xcframework.zip
prerelease: ${{ contains(github.ref_name, 'snapshot') }}
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+1 -1
View File
@@ -1,5 +1,6 @@
/build/
/deps/
/src/android-helper/build/
/src/barebone/agent/target/
/src/barebone/agent/xpacks/
/src/barebone/helpers/memory-scanner/target/
@@ -11,7 +12,6 @@
/src/darwin/agent/osanalytics/osanalytics.js
/src/darwin/agent/reportcrash/node_modules/
/src/darwin/agent/reportcrash/reportcrash.js
/src/droidy/helper/build/
/src/fruity/helpers/build/
/src/linux/agent/system-server/node_modules/
/src/linux/agent/system-server/system-server.js
+5 -5
View File
@@ -24,7 +24,9 @@ _frida_agent_environment_init (void)
been_here = TRUE;
#endif
gum_init_embedded ();
#ifdef _MSC_VER
frida_libc_shim_init ();
#endif
gio_init ();
g_thread_set_garbage_handler (_frida_agent_on_pending_thread_garbage, NULL);
@@ -54,13 +56,11 @@ _frida_agent_environment_deinit (void)
glib_shutdown ();
gio_deinit ();
gum_deinit_embedded ();
frida_run_atexit_handlers ();
# ifdef HAVE_DARWIN
/* Do what frida_deinit_memory() does on the other platforms. */
gum_internal_heap_unref ();
# if defined (_MSC_VER) || defined (HAVE_DARWIN)
frida_libc_shim_deinit ();
# endif
#endif
}
+2 -2
View File
@@ -50,9 +50,9 @@ raw_agent = shared_library('frida-agent-raw', agent_sources,
dependencies: [gio_dep, gee_dep, gum_dep, gumjs_dep, base_dep, pipe_dep, tls_provider_dep, payload_dep],
)
operations = ['--move', 'constructor', 'frida_init_memory', 'first']
operations = ['--move', 'constructor', 'frida_libc_shim_init', 'first']
if host_os_family != 'darwin'
operations += ['--move', 'destructor', 'frida_deinit_memory', 'first']
operations += ['--move', 'destructor', 'frida_libc_shim_deinit', 'first']
endif
modulated_agent = custom_target('frida-agent-modulated',
input: raw_agent,
+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,
}
}
-63
View File
@@ -1,63 +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
#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,
}
}
+439 -16
View File
@@ -11,27 +11,50 @@ namespace Frida {
return (linux_major == major && linux_minor >= minor) || linux_major > major;
}
public class FileDescriptor : Object, FileDescriptorBased {
public int handle;
public struct DevId {
public uint32 major;
public uint32 minor;
public FileDescriptor (int handle) {
this.handle = handle;
public DevId (uint32 major, uint32 minor) {
this.major = major;
this.minor = minor;
}
~FileDescriptor () {
if (handle != -1)
Posix.close (handle);
public uint64 pack () {
return ((uint64) major << 32) | minor;
}
public int steal () {
int result = handle;
handle = -1;
return result;
public static DevId unpack (uint64 dev) {
return DevId ((uint32) (dev >> 32), (uint32) dev);
}
public int get_fd () {
return handle;
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 {
@@ -65,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]
@@ -101,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);
}
}
+42 -4
View File
@@ -19,6 +19,13 @@ base_sources = [
extra_vala_args = []
if host_os == 'windows'
base_sources += 'windows.vala'
else
base_sources += 'posix.vala'
extra_vala_args += '--pkg=posix'
endif
if host_os == 'macos'
base_sources += [
'xpc.vala',
@@ -28,27 +35,57 @@ endif
if host_os_family == 'darwin'
base_sources += 'corefoundation.vala'
extra_vala_args += '--pkg=darwin-xnu'
endif
if host_os_family == 'linux'
base_sources += 'linux.vala'
base_sources += [
'linux.vala',
]
extra_vala_args += [
'--pkg=linux',
'--pkg=linux-system',
'--pkg=posix',
'--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
if host_os_family == 'freebsd'
extra_vala_args += '--pkg=freebsd'
endif
extra_deps = []
if host_os_family != 'windows'
extra_vala_args += '--pkg=gio-unix-2.0'
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()
base_vala_args += '--pkg=nice'
endif
if host_os_family != 'windows'
base_vala_args += [
'--pkg=gio-unix-2.0',
]
endif
if host_os_family == 'darwin'
base_vala_args += [
'--pkg=corefoundation',
@@ -59,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
+223
View File
@@ -0,0 +1,223 @@
namespace Frida {
public sealed class StdioPipes : Object {
public OutputStream? input {
get;
construct;
}
public InputStream output {
get;
construct;
}
public InputStream error {
get;
construct;
}
public StdioPipes (FileDescriptor? input, FileDescriptor output, FileDescriptor error) {
Object (
input: (input != null) ? new UnixOutputStream (ensure_nonblocking (input.steal ()), true) : null,
output: new UnixInputStream (ensure_nonblocking (output.steal ()), true),
error: new UnixInputStream (ensure_nonblocking (error.steal ()), true)
);
}
private static int ensure_nonblocking (int fd) {
try {
Unix.set_fd_nonblocking (fd, true);
return fd;
} catch (GLib.Error e) {
assert_not_reached ();
}
}
}
public class FileDescriptor : Object, FileDescriptorBased {
public int handle;
public FileDescriptor (int handle) {
this.handle = handle;
}
~FileDescriptor () {
if (handle != -1)
Posix.close (handle);
}
public int steal () {
int result = handle;
handle = -1;
return result;
}
public int get_fd () {
return handle;
}
public size_t pread (uint8[] buf, uint64 offset) throws Error {
while (true) {
ssize_t res = Posix.pread (handle, buf, buf.length, (Posix.off_t) offset);
if (res == -1) {
if (errno == Posix.EINTR)
continue;
throw new Error.TRANSPORT ("%s", strerror (errno));
}
return res;
}
}
public void pread_all (uint8[] buf, uint64 offset) throws Error {
size_t total = 0;
while (total != buf.length) {
void * dst = (uint8 *) buf + total;
size_t remaining = buf.length - total;
while (true) {
ssize_t res = Posix.pread (handle, dst, remaining, (Posix.off_t) (offset + total));
if (res == -1) {
if (errno == Posix.EINTR)
continue;
throw new Error.TRANSPORT ("%s", strerror (errno));
}
if (res == 0)
throw new Error.TRANSPORT ("Unexpected EOF: read %zu of %zu bytes", total, buf.length);
total += (size_t) res;
break;
}
}
}
public size_t pwrite (uint8[] buf, uint64 offset) throws Error {
while (true) {
ssize_t res = Posix.pwrite (handle, buf, buf.length, (Posix.off_t) offset);
if (res == -1) {
if (errno == Posix.EINTR)
continue;
throw new Error.TRANSPORT ("%s", strerror (errno));
}
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,
out FileDescriptor? out_fd, out string? out_name, out FileDescriptor? err_fd, out string? err_name) throws Error {
if (stdio == PIPE) {
FileDescriptor? in_write = null;
FileDescriptor? out_read, err_read;
if (in_supported) {
make_stdio_pipe (out in_fd, out in_write, out in_name);
} else {
in_fd = null;
in_name = null;
}
make_stdio_pipe (out out_read, out out_fd, out out_name);
make_stdio_pipe (out err_read, out err_fd, out err_name);
return new StdioPipes (in_write, out_read, err_read);
} else {
in_fd = null;
in_name = null;
out_fd = null;
out_name = null;
err_fd = null;
err_name = null;
return null;
}
}
public void make_stdio_pipe (out FileDescriptor read, out FileDescriptor write, out string? name = null) throws Error {
#if HAVE_OPENPTY
int rfd = -1, wfd = -1;
char buf[Posix.Limits.PATH_MAX];
var res =
#if DARWIN
Darwin.XNU.openpty (out rfd, out wfd, buf, null, null)
#elif LINUX
Linux.openpty (out rfd, out wfd, buf, null, null)
#elif FREEBSD
FreeBSD.openpty (out rfd, out wfd, buf, null, null)
#endif
;
if (res == -1)
throw new Error.NOT_SUPPORTED ("Unable to open PTY: %s", strerror (errno));
name = (string) buf;
enable_close_on_exec (rfd);
enable_close_on_exec (wfd);
disable_sigpipe (rfd);
disable_sigpipe (wfd);
configure_terminal_attributes (rfd);
read = new FileDescriptor (rfd);
write = new FileDescriptor (wfd);
#else
name = null;
try {
int fds[2];
Unix.open_pipe (fds, Posix.FD_CLOEXEC);
read = new FileDescriptor (fds[0]);
write = new FileDescriptor (fds[1]);
} catch (GLib.Error e) {
throw new Error.NOT_SUPPORTED ("Unable to open pipe: %s", e.message);
}
#endif
}
#if HAVE_OPENPTY
private void enable_close_on_exec (int fd) {
Posix.fcntl (fd, Posix.F_SETFD, Posix.fcntl (fd, Posix.F_GETFD) | Posix.FD_CLOEXEC);
}
private void disable_sigpipe (int fd) {
#if DARWIN
Posix.fcntl (fd, Darwin.XNU.F_SETNOSIGPIPE, true);
#endif
}
private void configure_terminal_attributes (int fd) {
var tios = Posix.termios ();
Posix.tcgetattr (fd, out tios);
tios.c_oflag &= ~Posix.ONLCR;
tios.c_cflag = (tios.c_cflag & Posix.CLOCAL) | Posix.CS8 | Posix.CREAD | Posix.HUPCL;
tios.c_lflag &= ~Posix.ECHO;
Posix.tcsetattr (fd, 0, tios);
}
#endif
}
+16
View File
@@ -57,6 +57,22 @@ namespace Frida {
push_scope (v);
}
public string[] list_members () throws Error {
var scope = peek_scope ();
if (scope.dict == null)
throw new Error.PROTOCOL ("Dictionary expected, but at %s", scope.val.print (true));
var members = new Gee.ArrayList<string> ();
foreach (var item in scope.val) {
string k;
Variant v;
item.get ("{sv}", out k, out v);
members.add (k);
}
return members.to_array ();
}
public bool has_member (string name) throws Error {
var scope = peek_scope ();
if (scope.dict == null)
+22
View File
@@ -0,0 +1,22 @@
namespace Frida {
public sealed class StdioPipes : Object {
public OutputStream input {
get;
construct;
}
public InputStream output {
get;
construct;
}
public InputStream error {
get;
construct;
}
public StdioPipes (OutputStream input, InputStream output, InputStream error) {
Object (input: input, output: output, error: error);
}
}
}
+5 -5
View File
@@ -84,7 +84,9 @@ frida_on_unload (void)
void
frida_gadget_environment_init (void)
{
gum_init_embedded ();
#ifdef _MSC_VER
frida_libc_shim_init ();
#endif
gio_init ();
g_thread_set_garbage_handler (_frida_gadget_on_pending_thread_garbage, NULL);
@@ -136,13 +138,11 @@ frida_gadget_environment_deinit (void)
glib_shutdown ();
gio_deinit ();
gum_deinit_embedded ();
frida_run_atexit_handlers ();
#ifdef HAVE_DARWIN
/* Do what frida_deinit_memory() does on the other platforms. */
gum_internal_heap_unref ();
#if defined (_MSC_VER) || defined (HAVE_DARWIN)
frida_libc_shim_deinit ();
#endif
}
+2 -2
View File
@@ -69,12 +69,12 @@ raw_gadget = shared_library('frida-gadget-raw', gadget_sources,
)
operations = [
'--move', 'constructor', 'frida_init_memory', 'first',
'--move', 'constructor', 'frida_libc_shim_init', 'first',
'--move', 'constructor', 'frida_on_load', 'last',
]
if host_os_family != 'darwin'
operations += [
'--move', 'destructor', 'frida_deinit_memory', 'first',
'--move', 'destructor', 'frida_libc_shim_deinit', 'first',
'--move', 'destructor', 'frida_on_unload', 'last',
]
endif
+1692 -68
View File
File diff suppressed because it is too large. Load diff
+3
View File
@@ -1,4 +1,7 @@
namespace Frida {
#if DARWIN
public extern void libc_shim_deinit ();
#endif
public extern void run_atexit_handlers ();
public extern uint get_process_id ();
+54 -12
View File
@@ -32,18 +32,34 @@ frida_version = get_option('frida_version')
if frida_version == ''
frida_version = run_command(releng / 'frida_version.py', meson.project_source_root(), check: true).stdout().strip()
endif
tokens = frida_version.split('.')
frida_major_version = tokens[0].to_int()
frida_minor_version = tokens[1].to_int()
if tokens.length() == 4
frida_micro_version = tokens[2].split('-')[0].to_int() - 1
frida_nano_version = tokens[3].to_int() + 1
is_dev = frida_version.contains('-dev.')
if is_dev
dev_parts = frida_version.split('-dev.')
assert(dev_parts.length() == 2)
prefix = dev_parts[0]
frida_nano_version = dev_parts[1].to_int() + 1
else
assert(tokens.length() == 3)
frida_micro_version = tokens[2].to_int()
prefix = frida_version
frida_nano_version = 0
endif
frida_profile = (frida_version != '0.0.0' and frida_nano_version == 0) ? 'prod' : 'dev'
parts = prefix.split('-')
core = parts[0]
has_suffix = parts.length() > 1
core_tokens = core.split('.')
assert(core_tokens.length() == 3)
frida_major_version = core_tokens[0].to_int()
frida_minor_version = core_tokens[1].to_int()
micro_encoded = core_tokens[2].to_int()
if is_dev and not has_suffix
frida_micro_version = micro_encoded - 1
else
frida_micro_version = micro_encoded
endif
api_version = '1.0'
@@ -92,6 +108,12 @@ elif host_machine.cpu_family() == 'mips64'
else
host_abi = 'mips64'
endif
elif host_machine.cpu_family() == 'riscv32'
host_arch = 'riscv'
host_abi = 'riscv32'
elif host_machine.cpu_family() == 'riscv64'
host_arch = 'riscv'
host_abi = 'riscv64'
else
host_arch = host_machine.cpu_family()
host_abi = host_arch
@@ -236,6 +258,7 @@ cpu_defines = [
['arm', 'HAVE_ARM'],
['arm64', 'HAVE_ARM64'],
['mips', 'HAVE_MIPS'],
['riscv', 'HAVE_RISCV'],
]
foreach d : cpu_defines
if d.get(0) == host_arch
@@ -292,6 +315,7 @@ gum_dep = dependency('frida-gum-1.0', default_options: [
gumjs_dep = dependency('frida-gumjs-1.0')
gumjs_inspector_dep = dependency('frida-gumjs-inspector-1.0')
glib_version_req = '>=2.74'
glib_options = [
'cocoa=disabled',
'selinux=disabled',
@@ -315,7 +339,7 @@ if optimize_for_prod
gee_options += 'disable-internal-asserts=true'
endif
glib_dep = dependency('glib-2.0', version: '>=2.72', default_options: glib_options)
glib_dep = dependency('glib-2.0', version: glib_version_req, default_options: glib_options)
gobject_dep = dependency('gobject-2.0')
gmodule_dep = dependency('gmodule-2.0')
gio_dep = dependency('gio-2.0')
@@ -346,7 +370,7 @@ quickjs_dep = dependency('quickjs', required: get_option('barebone_backend'), de
])
lzfse_dep = dependency('lzfse', required: get_option('barebone_backend'))
native_glib_dep = dependency('glib-2.0', version: '>=2.74', native: true, default_options: glib_options)
native_glib_dep = dependency('glib-2.0', version: glib_version_req, native: true, default_options: glib_options)
native_gio_dep = dependency('gio-2.0', native: true)
native_gee_dep = dependency('gee-0.8', native: true, default_options: gee_options)
native_brotlienc_dep = dependency('libbrotlienc', native: true)
@@ -357,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',
@@ -403,6 +431,10 @@ else
endif
have_local_backend = get_option('local_backend').allowed()
have_simmy_backend = get_option('simmy_backend') \
.disable_auto_if(host_os != 'macos') \
.require(host_os == 'macos', error_message: 'Simmy backend is only available on macOS') \
.allowed()
have_fruity_backend = get_option('fruity_backend') \
.disable_auto_if(not host_docks_mobile_devices) \
.allowed()
@@ -491,6 +523,7 @@ build_tests = get_option('tests') \
.allowed()
foreach b : [['local', have_local_backend],
['simmy', have_simmy_backend],
['fruity', have_fruity_backend],
['droidy', have_droidy_backend],
['socket', have_socket_backend],
@@ -581,7 +614,12 @@ if lzfse_dep.found()
backend_reqs_private += 'lzfse'
endif
if host_os_family == 'linux' and cc.has_function('openpty', prefix: '#include <pty.h>')
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
@@ -653,6 +691,9 @@ endif
if host_os in ['ios', 'tvos']
backend_libs_private += ['-Wl,-framework,CoreGraphics', '-Wl,-framework,UIKit']
endif
if host_os_family == 'freebsd'
backend_libs_private += ['-lutil']
endif
if get_option('devkits').length() != 0
if get_option('default_library') != 'static'
@@ -786,6 +827,7 @@ endif
summary(
{
'local': have_local_backend,
'simmy': have_simmy_backend,
'fruity': have_fruity_backend,
'droidy': have_droidy_backend,
'socket': have_socket_backend,
+6
View File
@@ -10,6 +10,12 @@ option('local_backend',
description: 'Include backend for the local system',
)
option('simmy_backend',
type: 'feature',
value: 'auto',
description: 'Include the iDevice Simulator backend',
)
option('fruity_backend',
type: 'feature',
value: 'auto',
+1 -1
Submodule releng updated: c24becede0...7ed66fe687.
@@ -1,11 +1,15 @@
ANDROID_API_LEVEL ?= 21
ANDROID_SDK_ROOT ?= $(shell echo ~/Library/Android/sdk)
ANDROID_API_LEVEL ?= 19
ANDROID_SDK_ROOT ?= $(shell echo ~/Android/Sdk)
android_platform := android-$(ANDROID_API_LEVEL)
android_jar := $(ANDROID_SDK_ROOT)/platforms/$(android_platform)/android.jar
build/frida-helper.dex: build/frida-helper.jar
dx --dex --output=$@ $<
helper.dex: build/frida-helper.jar
d8 \
--classpath $(android_jar) \
--output build/ \
$<
mv build/classes.dex $@
build/frida-helper.jar: re/frida/Helper.java
javac \
+738
View File
@@ -0,0 +1,738 @@
namespace Frida {
public sealed class AndroidHelperClient : Object, AsyncInitable {
public signal void closed ();
public IOStream stream {
get;
construct;
}
private BufferedInputStream input;
private OutputStream output;
private Cancellable io_cancellable = new Cancellable ();
private State state = CLOSED;
private Gee.Queue<Request> pending_requests = new Gee.ArrayQueue<Request> ();
private ByteArray pending_output = new ByteArray ();
private bool writing = false;
private enum State {
CLOSED,
OPEN
}
private const uint32 MAX_RESPONSE_SIZE = 100 * 1024 * 1024;
public AndroidHelperClient (IOStream stream) {
Object (stream: stream);
}
construct {
input = (BufferedInputStream) Object.new (typeof (BufferedInputStream),
"base-stream", stream.get_input_stream (),
"close-base-stream", false,
"buffer-size", 128 * 1024);
output = stream.get_output_stream ();
state = OPEN;
process_incoming_responses.begin ();
}
public async void close (Cancellable? cancellable) throws IOError {
io_cancellable.cancel ();
var source = new IdleSource ();
source.set_callback (close.callback);
source.attach (MainContext.get_thread_default ());
yield;
try {
yield stream.close_async (Priority.DEFAULT, cancellable);
} catch (IOError e) {
}
ensure_closed ();
}
private void ensure_closed () {
if (state == CLOSED)
return;
state = CLOSED;
closed ();
}
public async HostApplicationInfo get_frontmost_application (FrontmostQueryOptions options,
Cancellable? cancellable) throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("get-frontmost-application")
.add_string_value (options.scope.to_nick ())
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
if (response.is_null ())
return HostApplicationInfo.empty ();
Json.Reader reader = new Json.Reader (response);
string? identifier = null;
string? name = null;
uint pid = 0;
HashTable<string, Variant> parameters = make_parameters_dict ();
if (reader.read_element (0)) {
identifier = reader.get_string_value ();
reader.end_element ();
}
if (reader.read_element (1)) {
name = reader.get_string_value ();
reader.end_element ();
}
if (reader.read_element (2)) {
pid = (uint) reader.get_int_value ();
reader.end_element ();
}
if (reader.read_element (3)) {
if (reader.is_object ())
add_parameters_from_json (parameters, reader);
reader.end_element ();
}
GLib.Error? error = reader.get_error ();
if (error != null)
throw new Error.PROTOCOL ("%s", error.message);
return HostApplicationInfo (identifier, name, pid, (owned) parameters);
}
public async HostApplicationInfo[] enumerate_applications (ApplicationQueryOptions options, Cancellable? cancellable)
throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("enumerate-applications");
stanza.begin_array ();
options.enumerate_selected_identifiers (identifier => stanza.add_string_value (identifier));
stanza.end_array ();
stanza
.add_string_value (options.scope.to_nick ())
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
Json.Reader reader = new Json.Reader (response);
int num_apps = reader.count_elements ();
if (num_apps == -1)
throw new Error.PROTOCOL ("Invalid response from helper service");
var result = new HostApplicationInfo[0];
for (int i = 0; i != num_apps; i++) {
reader.read_element (i);
string? identifier = null;
string? name = null;
uint pid = 0;
HashTable<string, Variant> parameters = make_parameters_dict ();
if (reader.read_element (0)) {
identifier = reader.get_string_value ();
reader.end_element ();
}
if (reader.read_element (1)) {
name = reader.get_string_value ();
reader.end_element ();
}
if (reader.read_element (2)) {
pid = (uint) reader.get_int_value ();
reader.end_element ();
}
if (reader.read_element (3)) {
if (reader.is_object ())
add_parameters_from_json (parameters, reader);
reader.end_element ();
}
GLib.Error? error = reader.get_error ();
if (error != null)
throw new Error.PROTOCOL ("%s", error.message);
result += HostApplicationInfo (identifier, name, pid, (owned) parameters);
reader.end_element ();
}
return result;
}
public async HostProcessInfo[] enumerate_processes (ProcessQueryOptions options, Cancellable? cancellable)
throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("enumerate-processes");
stanza.begin_array ();
options.enumerate_selected_pids (pid => stanza.add_int_value (pid));
stanza.end_array ();
stanza
.add_string_value (options.scope.to_nick ())
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
Json.Reader reader = new Json.Reader (response);
int num_processes = reader.count_elements ();
if (num_processes == -1)
throw new Error.PROTOCOL ("Invalid response from helper service");
var result = new HostProcessInfo[0];
for (int i = 0; i != num_processes; i++) {
reader.read_element (i);
uint pid = 0;
string? name = null;
HashTable<string, Variant> parameters = make_parameters_dict ();
if (reader.read_element (0)) {
pid = (uint) reader.get_int_value ();
reader.end_element ();
}
if (reader.read_element (1)) {
name = reader.get_string_value ();
reader.end_element ();
}
if (reader.read_element (2)) {
if (reader.is_object ())
add_parameters_from_json (parameters, reader);
reader.end_element ();
}
GLib.Error? error = reader.get_error ();
if (error != null)
throw new Error.PROTOCOL ("%s", error.message);
result += HostProcessInfo (pid, name, (owned) parameters);
reader.end_element ();
}
return result;
}
public async string get_process_name (string package, int uid, Cancellable? cancellable) throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("get-process-name")
.add_string_value (package)
.add_int_value (uid)
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
var r = new Json.Reader (response);
parse_envelope_or_throw (r);
r.read_element (1);
string? process_name = r.get_string_value ();
if (process_name == null)
throw new Error.PROTOCOL ("Malformed response");
return process_name;
}
public async void start_package (string package, PackageEntrypoint entrypoint, Cancellable? cancellable)
throws Error, IOError {
if (entrypoint is DefaultActivityEntrypoint) {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("start-activity")
.add_string_value (package)
.add_null_value ()
.add_int_value (entrypoint.uid)
.end_array ();
yield request_ok (stanza, cancellable);
return;
}
if (entrypoint is ActivityEntrypoint) {
var e = (ActivityEntrypoint) entrypoint;
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("start-activity")
.add_string_value (package)
.add_string_value (e.activity)
.add_int_value (entrypoint.uid)
.end_array ();
yield request_ok (stanza, cancellable);
return;
}
if (entrypoint is BroadcastReceiverEntrypoint) {
var e = (BroadcastReceiverEntrypoint) entrypoint;
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("send-broadcast")
.add_string_value (package)
.add_string_value (e.receiver)
.add_string_value (e.action)
.add_int_value (entrypoint.uid)
.end_array ();
yield request_ok (stanza, cancellable);
return;
}
assert_not_reached ();
}
public async void stop_package (string package, int uid, Cancellable? cancellable) throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("stop-package")
.add_string_value (package)
.add_int_value (uid)
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
var r = new Json.Reader (response);
parse_envelope_or_throw (r);
}
public async bool try_stop_package_by_pid (uint pid, Cancellable? cancellable) throws Error, IOError {
var stanza = new Json.Builder ();
stanza
.begin_array ()
.add_string_value ("try-stop-package-by-pid")
.add_int_value ((int) pid)
.end_array ();
Json.Node response = yield request (stanza.get_root (), cancellable);
var r = new Json.Reader (response);
parse_envelope_or_throw (r);
r.read_element (1);
var val = r.get_value ();
if (val == null || val.get_value_type () != typeof (bool))
throw new Error.PROTOCOL ("Malformed response");
return r.get_boolean_value ();
}
private void parse_envelope_or_throw (Json.Reader r) throws Error {
r.read_element (0);
string? kind = r.get_string_value ();
if (kind == null)
throw new Error.PROTOCOL ("Malformed response");
r.end_element ();
if (kind == "ok")
return;
if (kind == "error") {
r.read_element (1);
string? code = r.get_string_value ();
if (code == null)
throw new Error.PROTOCOL ("Malformed response");
r.end_element ();
r.read_element (2);
string? message = r.get_string_value ();
if (message == null)
throw new Error.PROTOCOL ("Malformed response");
r.end_element ();
if (code == "INVALID_ARGUMENT")
throw new Error.INVALID_ARGUMENT ("%s", message);
throw new Error.NOT_SUPPORTED ("%s", message);
}
throw new Error.PROTOCOL ("Malformed response");
}
private static void add_parameters_from_json (HashTable<string, Variant> parameters, Json.Reader reader) throws Error {
foreach (string name in reader.list_members ()) {
reader.read_member (name);
if (reader.is_value ()) {
Json.Node val = reader.get_value ();
parameters[name] = variant_from_json_value (val);
} else if (reader.is_array ()) {
int length = reader.count_elements ();
if (length == 0)
throw new Error.PROTOCOL ("Unexpected JSON array element shape");
if (name == "$icons") {
var icons = new VariantBuilder (new VariantType.array (VariantType.VARDICT));
for (int i = 0; i != length; i++) {
reader.read_element (i);
string? png_str = reader.get_string_value ();
if (png_str == null)
throw new Error.PROTOCOL ("Unexpected JSON icon type");
var png = new Bytes.take (Base64.decode (png_str));
icons.open (VariantType.VARDICT);
icons.add ("{sv}", "format", new Variant.string ("png"));
icons.add ("{sv}", "image", Variant.new_from_data (new VariantType ("ay"),
png.get_data (), true, png));
icons.close ();
reader.end_element ();
}
parameters["icons"] = icons.end ();
} else {
reader.read_element (0);
if (!reader.is_value ())
throw new Error.PROTOCOL ("Unexpected JSON array element type");
Variant first_element = variant_from_json_value (reader.get_value ());
reader.end_element ();
var builder = new VariantBuilder (new VariantType.array (first_element.get_type ()));
builder.add_value (first_element);
for (int i = 1; i != length; i++) {
reader.read_element (i);
if (!reader.is_value ())
throw new Error.PROTOCOL ("Unexpected JSON array element type");
builder.add_value (variant_from_json_value (reader.get_value ()));
reader.end_element ();
}
parameters[name] = builder.end ();
}
} else {
throw new Error.PROTOCOL ("Unexpected JSON type");
}
reader.end_member ();
}
}
private static Variant variant_from_json_value (Json.Node node) throws Error {
Type type = node.get_value_type ();
if (type == typeof (string))
return new Variant.string (node.get_string ());
if (type == typeof (int64))
return new Variant.int64 (node.get_int ());
if (type == typeof (bool))
return new Variant.boolean (node.get_boolean ());
throw new Error.PROTOCOL ("Unexpected JSON type: %s", type.name ());
}
public async Json.Node request (Json.Node stanza, Cancellable? cancellable) throws Error, IOError {
if (state == CLOSED)
throw new Error.INVALID_OPERATION ("Helper client is closed");
var r = new Request (request.callback);
pending_requests.offer (r);
var cancel_source = new CancellableSource (cancellable);
cancel_source.set_callback (() => {
r.complete_with_error (new IOError.CANCELLED ("Operation was cancelled"));
return false;
});
cancel_source.attach (MainContext.get_thread_default ());
write_request (stanza);
yield;
cancel_source.destroy ();
cancellable.set_error_if_cancelled ();
GLib.Error? e = r.error;
if (e != null) {
if (e is Error)
throw (Error) e;
if (e is IOError.CANCELLED)
throw (IOError) e;
throw new Error.TRANSPORT ("%s", e.message);
}
return r.response;
}
private async void request_ok (Json.Builder stanza, Cancellable? cancellable) throws Error, IOError {
Json.Node response = yield request (stanza.get_root (), cancellable);
var r = new Json.Reader (response);
parse_envelope_or_throw (r);
}
private void write_request (Json.Node request) {
string request_str = Json.to_string (request, false);
uint8[] request_data = request_str.data;
uint offset = pending_output.len;
pending_output.set_size ((uint) (offset + sizeof (uint32) + request_data.length));
uint8 * blob = (uint8 *) pending_output.data + offset;
uint32 * size = blob;
*size = request_data.length.to_big_endian ();
Memory.copy (blob + 4, request_data, request_data.length);
if (!writing) {
writing = true;
var source = new IdleSource ();
source.set_callback (() => {
process_pending_output.begin ();
return false;
});
source.attach (MainContext.get_thread_default ());
}
}
private async void process_pending_output () {
while (pending_output.len > 0) {
uint8[] batch = pending_output.steal ();
size_t bytes_written;
try {
yield output.write_all_async (batch, Priority.DEFAULT, io_cancellable, out bytes_written);
} catch (GLib.Error e) {
break;
}
}
writing = false;
}
private async void process_incoming_responses () {
while (true) {
try {
Json.Node response = yield read_response ();
Request? request = pending_requests.poll ();
if (request == null)
throw new Error.PROTOCOL ("Unexpected response");
request.complete_with_response (response);
} catch (GLib.Error e) {
foreach (Request r in pending_requests)
r.complete_with_error (e);
pending_requests.clear ();
ensure_closed ();
return;
}
}
}
private async Json.Node read_response () throws GLib.Error {
size_t header_size = sizeof (uint32);
if (input.get_available () < header_size)
yield fill_until_n_bytes_available (header_size, io_cancellable);
uint32 response_size = 0;
unowned uint8[] response_size_buf = ((uint8[]) &response_size)[0:4];
input.peek (response_size_buf);
response_size = uint32.from_big_endian (response_size);
if (response_size < 1 || response_size > MAX_RESPONSE_SIZE)
throw new Error.PROTOCOL ("Invalid response size");
size_t frame_size = header_size + response_size;
if (input.get_available () < frame_size)
yield fill_until_n_bytes_available (frame_size, io_cancellable);
var response_data = new uint8[response_size + 1];
response_data.length = (int) response_size;
input.peek (response_data, header_size);
input.skip (frame_size, io_cancellable);
return Json.from_string ((string) response_data);
}
private async void fill_until_n_bytes_available (size_t minimum, Cancellable? cancellable) throws GLib.Error {
size_t available = input.get_available ();
while (available < minimum) {
if (input.get_buffer_size () < minimum)
input.set_buffer_size (minimum);
ssize_t n = yield input.fill_async ((ssize_t) (input.get_buffer_size () - available),
Priority.DEFAULT, cancellable);
if (n == 0)
throw new IOError.CONNECTION_CLOSED ("Connection closed");
available += n;
}
}
private class Request {
private SourceFunc? handler;
public Json.Node? response;
public GLib.Error? error;
public Request (owned SourceFunc handler) {
this.handler = (owned) handler;
}
public void complete_with_response (Json.Node r) {
if (handler == null)
return;
response = r;
handler ();
handler = null;
}
public void complete_with_error (GLib.Error e) {
if (handler == null)
return;
error = e;
handler ();
handler = null;
}
}
}
public abstract class PackageEntrypoint : Object {
public int uid {
get;
set;
}
public static PackageEntrypoint parse (string package, HostSpawnOptions options) throws Error {
PackageEntrypoint? entrypoint = null;
HashTable<string, Variant> aux = options.aux;
Variant? activity_value = aux["activity"];
if (activity_value != null) {
if (!activity_value.is_of_type (VariantType.STRING))
throw new Error.INVALID_ARGUMENT ("The 'activity' option must be a string");
string activity = canonicalize_class_name (activity_value.get_string (), package);
if (aux.contains ("action")) {
throw new Error.INVALID_ARGUMENT (
"The 'action' option should only be specified when a 'receiver' is specified");
}
entrypoint = new ActivityEntrypoint (activity);
}
Variant? receiver_value = aux["receiver"];
if (receiver_value != null) {
if (!receiver_value.is_of_type (VariantType.STRING))
throw new Error.INVALID_ARGUMENT ("The 'receiver' option must be a string");
string receiver = canonicalize_class_name (receiver_value.get_string (), package);
if (entrypoint != null) {
throw new Error.INVALID_ARGUMENT (
"Only one of 'activity' or 'receiver' (with 'action') may be specified");
}
Variant? action_value = aux["action"];
if (action_value == null)
throw new Error.INVALID_ARGUMENT ("The 'action' option is required when 'receiver' is specified");
if (!action_value.is_of_type (VariantType.STRING))
throw new Error.INVALID_ARGUMENT ("The 'action' option must be a string");
string action = action_value.get_string ();
entrypoint = new BroadcastReceiverEntrypoint (receiver, action);
}
if (entrypoint == null)
entrypoint = new DefaultActivityEntrypoint ();
Variant? uid_value = aux["uid"];
if (uid_value != null) {
if (!uid_value.is_of_type (VariantType.INT64))
throw new Error.INVALID_ARGUMENT ("The 'uid' option must be an integer");
entrypoint.uid = (int) uid_value.get_int64 ();
}
return entrypoint;
}
}
public sealed class DefaultActivityEntrypoint : PackageEntrypoint {
public DefaultActivityEntrypoint () {
Object ();
}
}
public sealed class ActivityEntrypoint : PackageEntrypoint {
public string activity {
get;
construct;
}
public ActivityEntrypoint (string activity) {
Object (activity: activity);
}
}
public sealed class BroadcastReceiverEntrypoint : PackageEntrypoint {
public string receiver {
get;
construct;
}
public string action {
get;
construct;
}
public BroadcastReceiverEntrypoint (string receiver, string action) {
Object (receiver: receiver, action: action);
}
}
private static string canonicalize_class_name (string klass, string package) {
var result = new StringBuilder (klass);
if (klass.has_prefix (".")) {
result.prepend (package);
} else if (klass.index_of (".") == -1) {
result.prepend_c ('.');
result.prepend (package);
}
return result.str;
}
}
Binary file not shown.
+2
View File
@@ -0,0 +1,2 @@
backend_sources += files('client.vala')
android_helper_dex = files('helper.dex')
File diff suppressed because it is too large. Load diff
File renamed without changes.
+12 -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") == "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,7 +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)]
+2 -1
View File
@@ -40,7 +40,8 @@ namespace Frida {
}
}
public async HostSession create (HostSessionOptions? options, Cancellable? cancellable) throws Error, IOError {
public async HostSession create (HostSessionHub hub, HostSessionOptions? options, Cancellable? cancellable)
throws Error, IOError {
if (host_session != null)
throw new Error.INVALID_OPERATION ("Already created");
+39 -3
View File
@@ -106,6 +106,8 @@ type BuildOptions struct {
DisableTypeCheck bool
SourceMap bool
Compress bool
Platform esbuild.Platform
Externals []string
}
type OutputFormat C.FridaOutputFormat
@@ -146,7 +148,7 @@ type BuildDiagnosticCallback func(d Diagnostic)
//export _frida_compiler_backend_build
func _frida_compiler_backend_build(cProjectRoot, cEntrypoint *C.char, outputFormat C.FridaOutputFormat, bundleFormat C.FridaBundleFormat,
disableTypeCheck, sourceMap, compress uintptr,
disableTypeCheck, sourceMap, compress uintptr, cPlatform *C.char, cExternals **C.char, numExternals C.int,
onCompleteFn C.FridaBuildCompleteFunc, onCompleteData unsafe.Pointer, onCompleteDataDestroy C.FridaDestroyFunc,
onDiagnosticFn C.FridaDiagnosticFunc, onDiagnosticData unsafe.Pointer) {
options := BuildOptions{
@@ -157,6 +159,8 @@ func _frida_compiler_backend_build(cProjectRoot, cEntrypoint *C.char, outputForm
DisableTypeCheck: disableTypeCheck != 0,
SourceMap: sourceMap != 0,
Compress: compress != 0,
Platform: platformFromFrida(C.GoString(cPlatform)),
Externals: parseCExternals(cExternals, numExternals),
}
onComplete := NewCDelegate(onCompleteFn, onCompleteData, onCompleteDataDestroy)
onDiagnostic := NewCDelegate(onDiagnosticFn, onDiagnosticData, nil)
@@ -181,7 +185,7 @@ func _frida_compiler_backend_build(cProjectRoot, cEntrypoint *C.char, outputForm
//export _frida_compiler_backend_watch
func _frida_compiler_backend_watch(cProjectRoot, cEntrypoint *C.char, outputFormat C.FridaOutputFormat, bundleFormat C.FridaBundleFormat,
disableTypeCheck, sourceMap, compress uintptr,
disableTypeCheck, sourceMap, compress uintptr, cPlatform *C.char, cExternals **C.char, numExternals C.int,
onReadyFn C.FridaWatchReadyFunc, onReadyData unsafe.Pointer, onReadyDataDestroy C.FridaDestroyFunc,
onStartingFn C.FridaStartingFunc, onStartingData unsafe.Pointer,
onFinishedFn C.FridaFinishedFunc, onFinishedData unsafe.Pointer,
@@ -195,6 +199,8 @@ func _frida_compiler_backend_watch(cProjectRoot, cEntrypoint *C.char, outputForm
DisableTypeCheck: disableTypeCheck != 0,
SourceMap: sourceMap != 0,
Compress: compress != 0,
Platform: platformFromFrida(C.GoString(cPlatform)),
Externals: parseCExternals(cExternals, numExternals),
}
onReady := NewCDelegate(onReadyFn, onReadyData, onReadyDataDestroy)
onStarting := NewCDelegate(onStartingFn, onStartingData, nil)
@@ -246,6 +252,35 @@ func _frida_compiler_backend_watch_session_dispose(h uintptr) {
handle.Delete()
}
func platformFromFrida(s string) esbuild.Platform {
switch s {
case "gum":
return esbuild.PlatformNode
case "browser":
return esbuild.PlatformBrowser
case "neutral":
return esbuild.PlatformNeutral
default:
panic(fmt.Sprintf("Unknown platform: %q", s))
}
}
func parseCExternals(cExternals **C.char, numExternals C.int) []string {
if numExternals == 0 {
return nil
}
n := int(numExternals)
cArray := (*[1 << 20]*C.char)(unsafe.Pointer(cExternals))[:n:n]
externals := make([]string, n)
for i := 0; i < n; i++ {
externals[i] = C.GoString(cArray[i])
}
return externals
}
func makeCBuildDiagnosticCallback(onDiagnostic *CDelegate[C.FridaDiagnosticFunc]) BuildDiagnosticCallback {
return func(d Diagnostic) {
var cPath *C.char
@@ -445,9 +480,10 @@ func makeContext(options BuildOptions, callbacks BuildEventCallbacks) (ctx esbui
Bundle: true,
Outdir: projectRoot,
AbsWorkingDir: projectRoot,
Platform: esbuild.PlatformNode,
Platform: options.Platform,
Format: format,
Inject: []string{"frida-builtins:///node-globals.js"},
External: options.Externals,
EntryPoints: []string{entrypoint},
Write: false,
Plugins: plugins,
+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
+65 -21
View File
@@ -46,7 +46,8 @@ namespace Frida {
CompilerBackend.build (project_root, entrypoint, opts.output_format, opts.bundle_format,
(size_t) (opts.type_check == NONE), (size_t) (opts.source_maps == INCLUDED),
(size_t) (opts.compression == TERSER), (owned) on_complete, on_diagnostic);
(size_t) (opts.compression == TERSER), opts.platform.to_nick (),
opts.externals.to_array (), (owned) on_complete, on_diagnostic);
yield;
if (error_message != null)
@@ -96,7 +97,8 @@ namespace Frida {
CompilerBackend.watch (project_root, entrypoint, opts.output_format, opts.bundle_format,
(size_t) (opts.type_check == NONE), (size_t) (opts.source_maps == INCLUDED),
(size_t) (opts.compression == TERSER), (owned) on_ready, on_starting, on_finished,
(size_t) (opts.compression == TERSER), opts.platform.to_nick (),
opts.externals.to_array (), (owned) on_ready, on_starting, on_finished,
on_output, on_diagnostic);
yield;
@@ -241,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");
@@ -283,13 +291,14 @@ namespace Frida {
[CCode (has_target = false)]
private delegate void BuildFunc (string project_root, string entrypoint, OutputFormat output_format,
BundleFormat bundle_format, size_t disable_type_check, size_t source_map, size_t compress,
owned BuildCompleteFunc on_complete, DiagnosticFunc on_diagnostic);
string platform, string[] externals, owned BuildCompleteFunc on_complete,
DiagnosticFunc on_diagnostic);
[CCode (has_target = false)]
private delegate void WatchFunc (string project_root, string entrypoint, OutputFormat output_format,
BundleFormat bundle_format, size_t disable_type_check, size_t source_map, size_t compress,
owned WatchReadyFunc on_ready, StartingFunc on_starting, FinishedFunc on_finished, OutputFunc on_output,
DiagnosticFunc on_diagnostic);
string platform, string[] externals, owned WatchReadyFunc on_ready, StartingFunc on_starting,
FinishedFunc on_finished, OutputFunc on_output, DiagnosticFunc on_diagnostic);
#if COMPILER_BACKEND_STATIC_COMPILATION
private extern void _init_go_runtime ();
@@ -373,6 +382,27 @@ namespace Frida {
set;
default = NONE;
}
public JsPlatform platform {
get;
set;
default = GUM;
}
internal Gee.List<string> externals = new Gee.ArrayList<string> ();
public void clear_externals () {
externals.clear ();
}
public void add_external (string external) {
externals.add (external);
}
public void enumerate_externals (Func<string> func) {
foreach (var external in externals)
func (external);
}
}
public sealed class BuildOptions : CompilerOptions {
@@ -446,4 +476,18 @@ namespace Frida {
return Marshal.enum_to_nick<JsCompression> (this);
}
}
public enum JsPlatform {
GUM,
BROWSER,
NEUTRAL;
public static JsPlatform from_nick (string nick) throws Error {
return Marshal.enum_from_nick<JsPlatform> (nick);
}
public string to_nick () {
return Marshal.enum_to_nick<JsPlatform> (this);
}
}
}
+3 -2
View File
@@ -4,6 +4,7 @@ compiler_sources = files(
)
if have_compiler_backend
output_suffix = compiler_backend_static_compilation ? '' : '-raw'
compiler_backend = custom_target('frida-compiler-backend',
input: [
'go.mod',
@@ -17,8 +18,8 @@ if have_compiler_backend
'package-lock.json',
],
output: [
'frida-compiler-backend' + (compiler_backend_static_compilation ? '.a' : ('-raw' + shlib_suffix)),
'frida-compiler-backend.h',
'frida-compiler-backend' + output_suffix + (compiler_backend_static_compilation ? '.a' : shlib_suffix),
'frida-compiler-backend' + output_suffix + '.h',
],
command: [
python,
+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
}
+13 -12
View File
@@ -845,8 +845,8 @@ namespace Frida {
construct;
}
public LaunchdAgent (DarwinHostSession host_session, Cancellable io_cancellable) {
Object (host_session: host_session, io_cancellable: io_cancellable);
public LaunchdAgent (HostSessionConnection connection, Cancellable io_cancellable) {
Object (connection: connection, io_cancellable: io_cancellable);
}
construct {
@@ -905,7 +905,7 @@ namespace Frida {
try {
if (path == XPC_PROXY_PATH) {
var agent = new XpcProxyAgent ((DarwinHostSession) host_session, identifier, pid);
var agent = new XpcProxyAgent (connection, identifier, pid);
yield agent.run_until_exec (io_cancellable);
}
@@ -921,7 +921,7 @@ namespace Frida {
try {
if (path == XPC_PROXY_PATH) {
var agent = new XpcProxyAgent ((DarwinHostSession) host_session, identifier, pid);
var agent = new XpcProxyAgent (connection, identifier, pid);
yield agent.run_until_exec (io_cancellable);
}
@@ -937,7 +937,8 @@ namespace Frida {
protected override async string? load_source (Cancellable? cancellable) throws Error, IOError {
string * raw_source = Frida.Data.Darwin.get_launchd_js_blob ().data;
return raw_source->replace ("@REPORT_CRASHES@", ((DarwinHostSession) host_session).report_crashes.to_string ());
return raw_source->replace ("@REPORT_CRASHES@",
((DarwinHostSession) connection.host_session).report_crashes.to_string ());
}
}
@@ -952,8 +953,8 @@ namespace Frida {
construct;
}
public XpcProxyAgent (DarwinHostSession host_session, string identifier, uint pid) {
Object (host_session: host_session, identifier: identifier, pid: pid);
public XpcProxyAgent (HostSessionConnection connection, string identifier, uint pid) {
Object (connection: connection, identifier: identifier, pid: pid);
}
construct {
@@ -965,7 +966,7 @@ namespace Frida {
public async void run_until_exec (Cancellable? cancellable) throws Error, IOError {
yield ensure_loaded (cancellable);
var helper = ((DarwinHostSession) host_session).helper;
var helper = ((DarwinHostSession) connection.host_session).helper;
yield helper.resume (pid, cancellable);
yield wait_for_unload (cancellable);
@@ -1002,10 +1003,10 @@ namespace Frida {
construct;
}
public ReportCrashAgent (DarwinHostSession host_session, uint pid, MappedAgentContainer mapped_agent_container,
public ReportCrashAgent (HostSessionConnection connection, uint pid, MappedAgentContainer mapped_agent_container,
Cancellable io_cancellable) {
Object (
host_session: host_session,
connection: connection,
pid: pid,
mapped_agent_container: mapped_agent_container,
io_cancellable: io_cancellable
@@ -1226,9 +1227,9 @@ namespace Frida {
construct;
}
public OSAnalyticsAgent (DarwinHostSession host_session, uint pid, Cancellable io_cancellable) {
public OSAnalyticsAgent (HostSessionConnection connection, uint pid, Cancellable io_cancellable) {
Object (
host_session: host_session,
connection: connection,
pid: pid,
io_cancellable: io_cancellable
);
+52 -93
View File
@@ -30,7 +30,6 @@
#include <sys/mman.h>
#include <sys/sysctl.h>
#include <unistd.h>
#include <util.h>
#ifndef _POSIX_SPAWN_DISABLE_ASLR
# define _POSIX_SPAWN_DISABLE_ASLR 0x0100
@@ -181,6 +180,7 @@ struct _FridaSpawnInstance
mach_vm_address_t dyld_data;
GumAddress modern_entry_address;
GumAddress sim_notify_address;
/* V4+ */
GumAddress notify_objc_init;
@@ -405,9 +405,6 @@ static void frida_spawn_instance_disable_nth_breakpoint (FridaSpawnInstance * se
static guint32 frida_spawn_instance_put_software_breakpoint (FridaSpawnInstance * self, GumAddress where, guint index);
static guint32 frida_spawn_instance_overwrite_arm64_instruction (FridaSpawnInstance * self, GumAddress address, guint32 new_instruction);
static void frida_make_pty (int fds[2]);
static void frida_configure_terminal_attributes (gint fd);
static FridaInjectInstance * frida_inject_instance_new (FridaDarwinHelperBackend * backend, guint id, guint pid);
static FridaInjectInstance * frida_inject_instance_clone (const FridaInjectInstance * instance, guint id);
static void frida_inject_instance_close (FridaInjectInstance * instance);
@@ -804,12 +801,17 @@ _frida_darwin_helper_backend_spawn (FridaDarwinHelperBackend * self, const gchar
posix_spawnattr_t attributes;
sigset_t signal_mask_set;
short flags;
int stdin_pipe[2], stdout_pipe[2], stderr_pipe[2];
FridaFileDescriptor * in_fd = NULL;
FridaFileDescriptor * out_fd = NULL;
FridaFileDescriptor * err_fd = NULL;
GError * stdio_error = NULL;
FridaAslr aslr = FRIDA_ASLR_AUTO;
GVariant * aslr_value;
gchar * old_cwd = NULL;
int result, spawn_errno;
*pipes = NULL;
instance = frida_spawn_instance_new (self);
argv = frida_host_spawn_options_compute_argv (options, path, NULL);
@@ -823,33 +825,13 @@ _frida_darwin_helper_backend_spawn (FridaDarwinHelperBackend * self, const gchar
flags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_START_SUSPENDED;
switch (options->stdio)
{
case FRIDA_STDIO_INHERIT:
*pipes = NULL;
*pipes = frida_make_stdio_pipes (options->stdio, TRUE, &in_fd, NULL, &out_fd, NULL, &err_fd, NULL, &stdio_error);
if (stdio_error != NULL)
goto propagate_stdio_error;
posix_spawn_file_actions_adddup2 (&file_actions, 0, 0);
posix_spawn_file_actions_adddup2 (&file_actions, 1, 1);
posix_spawn_file_actions_adddup2 (&file_actions, 2, 2);
break;
case FRIDA_STDIO_PIPE:
frida_make_pty (stdin_pipe);
frida_make_pty (stdout_pipe);
frida_make_pty (stderr_pipe);
*pipes = frida_stdio_pipes_new (stdin_pipe[1], stdout_pipe[0], stderr_pipe[0]);
posix_spawn_file_actions_adddup2 (&file_actions, stdin_pipe[0], 0);
posix_spawn_file_actions_adddup2 (&file_actions, stdout_pipe[1], 1);
posix_spawn_file_actions_adddup2 (&file_actions, stderr_pipe[1], 2);
break;
default:
g_assert_not_reached ();
}
posix_spawn_file_actions_adddup2 (&file_actions, (in_fd != NULL) ? in_fd->handle : 0, 0);
posix_spawn_file_actions_adddup2 (&file_actions, (out_fd != NULL) ? out_fd->handle : 1, 1);
posix_spawn_file_actions_adddup2 (&file_actions, (err_fd != NULL) ? err_fd->handle : 2, 2);
aslr_value = g_hash_table_lookup (options->aux, "aslr");
if (aslr_value != NULL && !frida_parse_aslr_option (aslr_value, &aslr, error))
@@ -872,13 +854,6 @@ _frida_darwin_helper_backend_spawn (FridaDarwinHelperBackend * self, const gchar
if (old_cwd != NULL)
chdir (old_cwd);
if (options->stdio == FRIDA_STDIO_PIPE)
{
close (stdin_pipe[0]);
close (stdout_pipe[1]);
close (stderr_pipe[1]);
}
posix_spawnattr_destroy (&attributes);
posix_spawn_file_actions_destroy (&file_actions);
@@ -892,6 +867,11 @@ _frida_darwin_helper_backend_spawn (FridaDarwinHelperBackend * self, const gchar
goto beach;
propagate_stdio_error:
{
g_propagate_error (error, stdio_error);
goto early_failure;
}
chdir_failed:
{
g_set_error (error,
@@ -936,12 +916,18 @@ any_failure:
kill (instance->pid, SIGKILL);
frida_spawn_instance_close (instance);
g_clear_object (pipes);
pid = 0;
goto beach;
}
beach:
{
g_clear_object (&in_fd);
g_clear_object (&out_fd);
g_clear_object (&err_fd);
g_free (old_cwd);
g_strfreev (envp);
g_strfreev (argv);
@@ -1057,6 +1043,8 @@ frida_darwin_helper_backend_launch_using_fbs (NSString * identifier, NSURL * url
FridaSpringboardApi * api;
NSMutableDictionary * debug_options, * open_options;
FridaStdioPipes * pipes = NULL;
gchar * stdout_name = NULL;
gchar * stderr_name = NULL;
GError * error = NULL;
FridaAslr aslr = FRIDA_ASLR_AUTO;
GVariant * aslr_value;
@@ -1092,22 +1080,12 @@ frida_darwin_helper_backend_launch_using_fbs (NSString * identifier, NSURL * url
if (strlen (spawn_options->cwd) > 0)
goto cwd_not_supported;
pipes = frida_make_stdio_pipes (spawn_options->stdio, FALSE, NULL, NULL, NULL, &stdout_name, NULL, &stderr_name, &error);
if (error != NULL)
goto failure;
if (spawn_options->stdio == FRIDA_STDIO_PIPE)
{
gint stdout_master, stdout_slave, stderr_master, stderr_slave;
gchar stdout_name[PATH_MAX], stderr_name[PATH_MAX];
openpty (&stdout_master, &stdout_slave, stdout_name, NULL, NULL);
openpty (&stderr_master, &stderr_slave, stderr_name, NULL, NULL);
pipes = frida_stdio_pipes_new (-1, stdout_master, stderr_master);
frida_configure_terminal_attributes (stdout_master);
frida_configure_terminal_attributes (stderr_master);
frida_stdio_pipes_retain (pipes, stdout_slave);
frida_stdio_pipes_retain (pipes, stderr_slave);
chmod (stdout_name, 0666);
chmod (stderr_name, 0666);
@@ -1174,7 +1152,7 @@ frida_darwin_helper_backend_launch_using_fbs (NSString * identifier, NSURL * url
}
});
return;
goto beach;
envp_not_supported:
{
@@ -1195,6 +1173,16 @@ cwd_not_supported:
failure:
{
on_complete (NULL, error, on_complete_target);
g_clear_object (&pipes);
goto beach;
}
beach:
{
g_free (stdout_name);
g_free (stderr_name);
return;
}
}
@@ -1881,7 +1869,7 @@ _frida_darwin_helper_backend_prepare_spawn_instance_for_injection (FridaDarwinHe
mach_msg_type_number_t state_count = GUM_DARWIN_THREAD_STATE_COUNT;
thread_state_flavor_t state_flavor = GUM_DARWIN_THREAD_STATE_FLAVOR;
GumAddress dyld_start, dyld_granularity, dyld_chunk, dyld_header;
GumAddress modern_entry_address, legacy_entry_address;
GumAddress modern_entry_address, legacy_entry_address, sim_notify_address;
const gchar * launch_with_closure_names[] = {
"__ZN4dyldL17launchWithClosureEPKN5dyld37closure13LaunchClosureEPK15DyldSharedCachePKNS0_11MachOLoadedEmiPPKcSD_SD_R11DiagnosticsPmSG_PbSH_",
"__ZN4dyldL17launchWithClosureEPKN5dyld312launch_cache13binary_format7ClosureEPK15DyldSharedCachePK11mach_headermiPPKcSE_SE_PmSF_",
@@ -2101,6 +2089,9 @@ _frida_darwin_helper_backend_prepare_spawn_instance_for_injection (FridaDarwinHe
instance->ret_gadget |= 1;
}
sim_notify_address = gum_darwin_module_resolve_symbol_address (dyld, "__ZN5dyld4L29sim_notifyMonitorOfMainCalledEv");
instance->sim_notify_address = sim_notify_address;
instance->ret_state = FRIDA_RET_FROM_HELPER;
kr = frida_get_debug_state (child_thread, &instance->previous_debug_state, instance->cpu_type);
@@ -2112,6 +2103,8 @@ _frida_darwin_helper_backend_prepare_spawn_instance_for_injection (FridaDarwinHe
frida_spawn_instance_set_nth_breakpoint (instance, i++, legacy_entry_address, FRIDA_BREAKPOINT_REPEAT_ALWAYS);
if (modern_entry_address != 0)
frida_spawn_instance_set_nth_breakpoint (instance, i++, modern_entry_address, FRIDA_BREAKPOINT_REPEAT_ALWAYS);
if (sim_notify_address != 0)
frida_spawn_instance_set_nth_breakpoint (instance, i++, sim_notify_address, FRIDA_BREAKPOINT_REPEAT_ALWAYS);
if (instance->dyld_flavor == FRIDA_DYLD_V4_PLUS)
{
GumAddress restart_with_dyld_in_cache = gum_darwin_module_resolve_symbol_address (dyld,
@@ -3104,7 +3097,11 @@ frida_spawn_instance_handle_breakpoint (FridaSpawnInstance * self, FridaBreakpoi
if (self->breakpoint_phase == FRIDA_BREAKPOINT_DETECT_FLAVOR)
{
if (self->dyld_flavor == FRIDA_DYLD_V4_PLUS)
if (pc == self->sim_notify_address)
{
self->breakpoint_phase = FRIDA_BREAKPOINT_LIBSYSTEM_INITIALIZED;
}
else if (self->dyld_flavor == FRIDA_DYLD_V4_PLUS)
{
if (pc == self->modern_entry_address)
{
@@ -4065,44 +4062,6 @@ frida_spawn_instance_overwrite_arm64_instruction (FridaSpawnInstance * self, Gum
return original_instruction;
}
static void
frida_make_pty (int fds[2])
{
gboolean pipe_opened;
int i;
pipe_opened = openpty (&fds[0], &fds[1], NULL, NULL, NULL) != -1;
g_assert (pipe_opened);
for (i = 0; i != 2; i++)
{
const int fd = fds[i];
int res;
res = fcntl (fd, F_SETFD, fcntl (fd, F_GETFD) | FD_CLOEXEC);
g_assert (res == 0);
res = fcntl (fd, F_SETNOSIGPIPE, TRUE);
g_assert (res == 0);
}
frida_configure_terminal_attributes (fds[0]);
}
static void
frida_configure_terminal_attributes (gint fd)
{
struct termios tios;
tcgetattr (fd, &tios);
tios.c_oflag &= ~ONLCR;
tios.c_cflag = (tios.c_cflag & CLOCAL) | CS8 | CREAD | HUPCL;
tios.c_lflag &= ~ECHO;
tcsetattr (fd, 0, &tios);
}
static FridaInjectInstance *
frida_inject_instance_new (FridaDarwinHelperBackend * backend, guint id, guint pid)
{
+10 -62
View File
@@ -136,9 +136,9 @@ namespace Frida {
ChildWatch.add ((Pid) child_pid, on_child_dead);
if (pipes != null) {
stdin_streams[child_pid] = new UnixOutputStream (pipes.input, false);
process_next_output_from.begin (new UnixInputStream (pipes.output, false), child_pid, 1, pipes);
process_next_output_from.begin (new UnixInputStream (pipes.error, false), child_pid, 2, pipes);
stdin_streams[child_pid] = pipes.input;
process_next_output_from.begin (pipes.output, child_pid, 1, pipes);
process_next_output_from.begin (pipes.error, child_pid, 2, pipes);
}
return child_pid;
@@ -180,10 +180,8 @@ namespace Frida {
var pipes = pending.pipes;
if (pipes != null) {
pipes.clear_retained ();
process_next_output_from.begin (new UnixInputStream (pipes.output, false), pid, 1, pipes);
process_next_output_from.begin (new UnixInputStream (pipes.error, false), pid, 2, pipes);
process_next_output_from.begin (pipes.output, pid, 1, pipes);
process_next_output_from.begin (pipes.error, pid, 2, pipes);
}
}
@@ -439,8 +437,11 @@ namespace Frida {
private bool is_booting (uint task) throws Error {
Gum.Darwin.AllImageInfos infos;
if (!Gum.Darwin.query_all_image_infos (task, out infos))
throw new Error.PROCESS_NOT_FOUND ("Target process died unexpectedly");
try {
Gum.Darwin.query_all_image_infos (task, out infos);
} catch (Gum.Error e) {
throw new Error.PROCESS_NOT_FOUND ("%s", e.message);
}
return !infos.libsystem_initialized;
}
@@ -888,57 +889,4 @@ namespace Frida {
return false;
}
}
public sealed class StdioPipes : Object {
public int input {
get;
construct;
}
public int output {
get;
construct;
}
public int error {
get;
construct;
}
private int[] retained = {};
public StdioPipes (int input, int output, int error) {
Object (input: input, output: output, error: error);
}
construct {
try {
if (input != -1)
Unix.set_fd_nonblocking (input, true);
Unix.set_fd_nonblocking (output, true);
Unix.set_fd_nonblocking (error, true);
} catch (GLib.Error e) {
assert_not_reached ();
}
}
~StdioPipes () {
clear_retained ();
if (input != -1)
Posix.close (input);
Posix.close (output);
Posix.close (error);
}
public void clear_retained () {
foreach (var fd in retained)
Posix.close (fd);
retained = {};
}
public void retain (int fd) {
retained += fd;
}
}
}
+123 -21
View File
@@ -314,6 +314,9 @@ namespace Frida {
SocketService? service = null;
TimeoutSource? timeout_source = null;
bool timed_out = false;
bool child_exited = false;
int child_status = 0;
try {
string tempdir;
@@ -341,7 +344,6 @@ namespace Frida {
return false;
});
idle_source.attach (main_context);
yield;
var incoming_handler = service.incoming.connect ((c) => {
@@ -350,42 +352,63 @@ namespace Frida {
return true;
});
var timer = new Timer ();
timeout_source = new TimeoutSource (10);
timeout_source = new TimeoutSource.seconds (10);
timeout_source.set_callback (() => {
timed_out = true;
launch_helper.callback ();
return Source.CONTINUE;
return Source.REMOVE;
});
timeout_source.attach (main_context);
string[] argv = { helper_path, socket_address };
GLib.SpawnFlags flags = GLib.SpawnFlags.LEAVE_DESCRIPTORS_OPEN | /* GLib.SpawnFlags.CLOEXEC_PIPES */ 256;
GLib.SpawnFlags flags =
GLib.SpawnFlags.LEAVE_DESCRIPTORS_OPEN |
GLib.SpawnFlags.DO_NOT_REAP_CHILD |
/* GLib.SpawnFlags.CLOEXEC_PIPES */ 256;
GLib.Process.spawn_async (null, argv, null, flags, null, out pending_pid);
while (pending_stream == null && timer.elapsed () < 10.0 && !process_is_dead (pending_pid))
var exit_monitor = new ChildExitMonitor (pending_pid, main_context);
var exit_handler = exit_monitor.exited.connect ((status) => {
child_exited = true;
child_status = status;
launch_helper.callback ();
});
while (pending_stream == null && !timed_out && !child_exited)
yield;
exit_monitor.disconnect (exit_handler);
exit_monitor.stop ();
timeout_source.destroy ();
timeout_source = null;
service.disconnect (incoming_handler);
service.stop ();
service = null;
timeout_source.destroy ();
timeout_source = null;
if (pending_stream == null)
throw new Error.TIMED_OUT ("Unexpectedly timed out while spawning helper process");
if (pending_stream == null) {
if (child_exited)
throw new Error.PROCESS_NOT_FOUND ("Helper exited during launch (status=%d)", child_status);
if (timed_out)
throw new Error.TIMED_OUT ("Unexpectedly timed out while spawning helper");
}
pending_connection = yield new DBusConnection (pending_stream, ServerGuid.HOST_SESSION_SERVICE,
AUTHENTICATION_SERVER | AUTHENTICATION_ALLOW_ANONYMOUS, null, cancellable);
pending_proxy = yield pending_connection.get_proxy (null, ObjectPath.HELPER, DO_NOT_LOAD_PROPERTIES,
cancellable);
if (pending_connection.is_closed ())
throw new Error.NOT_SUPPORTED ("Helper terminated prematurely");
} catch (GLib.Error e) {
bool died_unexpectedly = pending_pid != 0 && process_is_dead (pending_pid);
if (pending_pid != 0 && !died_unexpectedly)
if (pending_pid != 0 && !child_exited) {
Posix.kill ((Posix.pid_t) pending_pid, Posix.Signal.KILL);
reap_later.begin (pending_pid);
}
if (timeout_source != null)
timeout_source.destroy ();
@@ -393,10 +416,6 @@ namespace Frida {
if (service != null)
service.stop ();
if (died_unexpectedly) {
throw new Error.PROCESS_NOT_FOUND ("Peer process (%d) died unexpectedly: %s",
pending_pid, e.message);
}
if (e is Error)
throw (Error) e;
throw new Error.PERMISSION_DENIED ("%s", e.message);
@@ -422,10 +441,6 @@ namespace Frida {
return proxy;
}
private static bool process_is_dead (uint pid) {
return Posix.kill ((Posix.pid_t) pid, 0) == -1 && Posix.errno == Posix.ESRCH;
}
private void on_connection_closed (bool remote_peer_vanished, GLib.Error? error) {
obtain_request = null;
@@ -441,7 +456,10 @@ namespace Frida {
connection.on_closed.disconnect (on_connection_closed);
connection = null;
Pid pid = process_pid;
process_pid = 0;
if (pid != 0)
reap_later.begin (pid);
}
private void on_output (uint pid, int fd, uint8[] data) {
@@ -559,4 +577,88 @@ namespace Frida {
return false;
}
}
private class ChildExitMonitor : Object {
public signal void exited (int status);
private Pid pid;
private MainContext? context;
private TimeoutSource? source;
private uint interval_ms = 10;
private const uint MAX_INTERVAL_MS = 1000;
public ChildExitMonitor (Pid pid, MainContext? ctx = null) {
this.pid = pid;
context = ctx ?? MainContext.get_thread_default ();
arm ();
}
public void stop () {
if (source != null) {
source.destroy ();
source = null;
}
}
private void arm () {
source = new TimeoutSource (interval_ms);
source.set_callback (() => {
int status;
if (try_reap (pid, out status)) {
stop ();
exited (status);
return Source.REMOVE;
}
if (interval_ms < MAX_INTERVAL_MS) {
interval_ms = uint.min (MAX_INTERVAL_MS, 2 * interval_ms);
stop ();
arm ();
return Source.REMOVE;
}
return Source.CONTINUE;
});
source.attach (context);
}
private static bool try_reap (Pid pid, out int status) {
status = 0;
var r = Posix.waitpid ((Posix.pid_t) pid, out status, Posix.WNOHANG);
if (r > 0)
return true;
if (r == 0)
return false;
if (Posix.errno == Posix.EINTR)
return false;
if (Posix.errno == Posix.ECHILD)
return true;
return true;
}
}
private async void reap_later (Pid pid) {
var monitor = new ChildExitMonitor (pid);
bool done = false;
ulong h = monitor.exited.connect ((status) => {
done = true;
reap_later.callback ();
});
try {
while (!done)
yield;
} finally {
monitor.disconnect (h);
monitor.stop ();
}
}
}
+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
@@ -109,8 +109,6 @@ _frida_get_springboard_api (void)
gum_interceptor_replace (interceptor, frida_xpc_look_up_endpoint, frida_replacement_xpc_look_up_endpoint, NULL, NULL);
else
g_error ("Unable to locate _xpc_look_up_endpoint(); please file a bug");
g_object_unref (interceptor);
}
#endif
+1 -3
View File
@@ -489,7 +489,7 @@ static void
frida_add_app_icons (GHashTable * parameters, NSImage * image)
{
GVariantBuilder builder;
const guint sizes[] = { 16, 32 };
const guint sizes[] = { 128 };
guint i;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}"));
@@ -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);
File diff suppressed because it is too large. Load diff
-703
View File
@@ -1,703 +0,0 @@
package re.frida;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.ActivityManager.RunningTaskInfo;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.net.LocalServerSocket;
import android.net.LocalSocket;
import android.os.Looper;
import android.os.Process;
import android.system.ErrnoException;
import android.system.Os;
import android.system.OsConstants;
import android.util.Base64;
import android.util.Base64OutputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.Class;
import java.lang.Exception;
import java.lang.Object;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class Helper {
public static void main(String[] args) {
if (args.length != 1) {
System.err.println("Usage: frida-helper <instance-id>");
System.exit(1);
return;
}
String instanceId = args[0];
new File("/data/local/tmp/frida-helper-" + instanceId + ".dex").delete();
LocalServerSocket socket;
try {
socket = new LocalServerSocket("/frida-helper-" + instanceId);
} catch (IOException e) {
System.err.println(e);
System.exit(2);
return;
}
Looper.prepare();
Context context;
try {
Class<?> ActivityThread = Class.forName("android.app.ActivityThread");
Object activityThread = ActivityThread.getDeclaredMethod("systemMain").invoke(null);
context = (Context) ActivityThread.getDeclaredMethod("getSystemContext").invoke(activityThread);
} catch (InvocationTargetException e) {
System.err.println(e.getCause());
System.exit(1);
return;
} catch (Exception e) {
System.err.println(e);
System.exit(1);
return;
}
new Helper(socket, context).run();
}
private PackageManager mPackageManager;
private ActivityManager mActivityManager;
private Field mTopActivityField;
private String mLauncherPkgName;
private static Pattern sStatusUidPattern = Pattern.compile("^Uid:\\s+\\d+\\s+(\\d+)\\s+\\d+\\s+\\d+$", Pattern.MULTILINE);
private long mSystemBootTime;
private long mMillisecondsPerJiffy;
private SimpleDateFormat mIso8601;
private Method mGetpwuid;
private Field mPwnameField;
private LocalServerSocket mSocket;
private Thread mWorker;
private final int MAX_REQUEST_SIZE = 128 * 1024;
public Helper(LocalServerSocket socket, Context ctx) {
mPackageManager = ctx.getPackageManager();
mActivityManager = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
try {
mTopActivityField = Class.forName("android.app.TaskInfo").getDeclaredField("topActivity");
} catch (Exception e) {
}
mLauncherPkgName = detectLauncherPackageName();
mSystemBootTime = querySystemBootTime();
mMillisecondsPerJiffy = 1000 / Os.sysconf(OsConstants._SC_CLK_TCK);
mIso8601 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
mIso8601.setTimeZone(TimeZone.getTimeZone("UTC"));
try {
mGetpwuid = Class.forName("android.system.Os").getDeclaredMethod("getpwuid", int.class);
mPwnameField = Class.forName("android.system.StructPasswd").getDeclaredField("pw_name");
} catch (Exception e) {
throw new RuntimeException(e);
}
mSocket = socket;
mWorker = new Thread("Connection Listener") {
public void run() {
handleIncomingConnections();
}
};
}
private void run() {
mWorker.start();
Looper.loop();
}
private void handleIncomingConnections() {
System.out.println("READY.");
while (true) {
try {
LocalSocket client = mSocket.accept();
Thread handler = new Thread("Connection Handler") {
public void run() {
handleConnection(client);
}
};
handler.start();
} catch (IOException e) {
break;
}
}
}
protected void handleConnection(LocalSocket client) {
DataInputStream input;
DataOutputStream output;
try {
input = new DataInputStream(new BufferedInputStream(client.getInputStream()));
output = new DataOutputStream(new BufferedOutputStream(client.getOutputStream()));
} catch (IOException e) {
return;
}
while (true) {
try {
int requestSize = input.readInt();
if (requestSize < 1 || requestSize > MAX_REQUEST_SIZE) {
break;
}
byte[] rawRequest = new byte[requestSize];
input.readFully(rawRequest);
JSONArray request = new JSONArray(new String(rawRequest));
JSONArray response;
String type = request.getString(0);
if (type.equals("get-frontmost-application")) {
response = getFrontmostApplication(request);
} else if (type.equals("enumerate-applications")) {
response = enumerateApplications(request);
} else if (type.equals("enumerate-processes")) {
response = enumerateProcesses(request);
} else {
break;
}
byte[] rawResponse = (response != null)
? response.toString().getBytes()
: JSONObject.NULL.toString().getBytes();
output.writeInt(rawResponse.length);
output.write(rawResponse);
output.flush();
} catch (JSONException e) {
break;
} catch (EOFException e) {
break;
} catch (IOException e) {
break;
}
}
try {
client.close();
} catch (IOException e) {
}
}
private JSONArray getFrontmostApplication(JSONArray request) throws JSONException {
Scope scope = Scope.valueOf(request.getString(1).toUpperCase());
String pkgName = getFrontmostPackageName();
if (pkgName == null) {
return null;
}
ApplicationInfo appInfo;
try {
appInfo = mPackageManager.getApplicationInfo(pkgName, 0);
} catch (NameNotFoundException e) {
return null;
}
CharSequence appLabel = appInfo.loadLabel(mPackageManager);
int pid = 0;
List<RunningAppProcessInfo> pkgProcesses = getAppProcesses().get(pkgName);
if (pkgProcesses != null) {
pid = pkgProcesses.get(0).pid;
}
JSONObject parameters = null;
if (scope != Scope.MINIMAL) {
try {
parameters = fetchAppParameters(appInfo, scope);
} catch (NameNotFoundException e) {
return null;
}
if (pid != 0) {
try {
addProcessMetadata(parameters, pid);
} catch (IOException e) {
return null;
}
}
}
JSONArray app = new JSONArray();
app.put(pkgName);
app.put(appLabel);
app.put(pid);
app.put(parameters);
return app;
}
private JSONArray enumerateApplications(JSONArray request) throws JSONException {
JSONArray identifiersValue = request.getJSONArray(1);
Scope scope = Scope.valueOf(request.getString(2).toUpperCase());
List<ApplicationInfo> apps;
int numIdentifiers = identifiersValue.length();
if (numIdentifiers > 0) {
apps = new ArrayList<ApplicationInfo>();
for (int i = 0; i != numIdentifiers; i++) {
String pkgName = identifiersValue.getString(i);
try {
apps.add(mPackageManager.getApplicationInfo(pkgName, 0));
} catch (NameNotFoundException e) {
}
}
} else {
apps = getLauncherApplications();
}
JSONArray result = new JSONArray();
Map<String, List<RunningAppProcessInfo>> processes = getAppProcesses();
String frontmostPkgName = (scope != Scope.MINIMAL) ? getFrontmostPackageName() : null;
for (ApplicationInfo appInfo : apps) {
String pkgName = appInfo.packageName;
CharSequence appLabel = appInfo.loadLabel(mPackageManager);
int pid = 0;
List<RunningAppProcessInfo> pkgProcesses = processes.get(pkgName);
if (pkgProcesses != null) {
pid = pkgProcesses.get(0).pid;
}
JSONObject parameters = null;
if (scope != Scope.MINIMAL) {
try {
parameters = fetchAppParameters(appInfo, scope);
} catch (NameNotFoundException e) {
continue;
}
if (pid != 0) {
try {
addProcessMetadata(parameters, pid);
} catch (IOException e) {
pid = 0;
}
}
if (pid != 0 && pkgName.equals(frontmostPkgName)) {
parameters.put("frontmost", true);
}
}
JSONArray app = new JSONArray();
app.put(pkgName);
app.put(appLabel);
app.put(pid);
app.put(parameters);
result.put(app);
}
return result;
}
private JSONArray enumerateProcesses(JSONArray request) throws JSONException {
JSONArray pidsValue = request.getJSONArray(1);
Scope scope = Scope.valueOf(request.getString(2).toUpperCase());
int numPids = pidsValue.length();
List<Integer> pids = new ArrayList<Integer>(numPids);
if (numPids > 0) {
for (int i = 0; i != numPids; i++) {
pids.add(pidsValue.getInt(i));
}
} else {
int myPid = Process.myPid();
for (File candidate : new File("/proc").listFiles()) {
if (!candidate.isDirectory()) {
continue;
}
int pid;
try {
pid = Integer.parseInt(candidate.getName());
} catch (NumberFormatException e) {
continue;
}
if (pid == myPid) {
continue;
}
pids.add(pid);
}
}
JSONArray result = new JSONArray();
Map<String, List<RunningAppProcessInfo>> appProcessByPkgName = getAppProcesses();
Map<Integer, RunningAppProcessInfo> appProcessByPid = new HashMap<Integer, RunningAppProcessInfo>();
for (List<RunningAppProcessInfo> processes : appProcessByPkgName.values()) {
for (RunningAppProcessInfo process : processes) {
appProcessByPid.put(process.pid, process);
}
}
Map<String, ApplicationInfo> appInfoByPkgName = new HashMap<String, ApplicationInfo>();
for (ApplicationInfo appInfo : getLauncherApplications()) {
appInfoByPkgName.put(appInfo.packageName, appInfo);
}
Map<Integer, ApplicationInfo> appInfoByPid = new HashMap<Integer, ApplicationInfo>();
for (List<RunningAppProcessInfo> processes : appProcessByPkgName.values()) {
RunningAppProcessInfo mostImportantProcess = processes.get(0);
for (String pkgName : mostImportantProcess.pkgList) {
ApplicationInfo appInfo = appInfoByPkgName.get(pkgName);
if (appInfo != null) {
appInfoByPid.put(mostImportantProcess.pid, appInfo);
break;
}
}
}
int frontmostPid = -1;
if (scope != Scope.MINIMAL) {
String frontmostPkgName = getFrontmostPackageName();
if (frontmostPkgName != null) {
List<RunningAppProcessInfo> frontmostProcesses = appProcessByPkgName.get(frontmostPkgName);
if (frontmostProcesses != null) {
frontmostPid = frontmostProcesses.get(0).pid;
}
}
}
for (Integer pid : pids) {
File procDir = new File("/proc", pid.toString());
ApplicationInfo appInfo = appInfoByPid.get(pid);
CharSequence name;
if (appInfo != null) {
name = appInfo.loadLabel(mPackageManager);
} else {
String cmdline;
try {
cmdline = getFileContentsAsString(new File(procDir, "cmdline"));
} catch (IOException e) {
continue;
}
boolean isKernelProcess = cmdline.isEmpty();
if (isKernelProcess) {
continue;
}
name = deriveProcessNameFromCmdline(cmdline);
}
JSONObject parameters = null;
if (scope != Scope.MINIMAL) {
parameters = new JSONObject();
try {
File program = new File(Os.readlink(new File(procDir, "exe").getAbsolutePath()));
parameters.put("path", program.getAbsolutePath());
} catch (ErrnoException e) {
}
try {
addProcessMetadata(parameters, pid);
} catch (IOException e) {
continue;
}
RunningAppProcessInfo appProcess = appProcessByPid.get(pid);
if (appProcess != null) {
JSONArray ids = new JSONArray();
for (String pkgName : appProcess.pkgList) {
ids.put(pkgName);
}
parameters.put("applications", ids);
}
if (scope == Scope.FULL && appInfo != null) {
JSONArray icons = new JSONArray();
icons.put(fetchAppIcon(appInfo));
parameters.put("$icons", icons);
}
if (pid == frontmostPid) {
parameters.put("frontmost", true);
}
}
JSONArray process = new JSONArray();
process.put(pid);
process.put(name);
process.put(parameters);
result.put(process);
}
return result;
}
@SuppressWarnings("deprecation")
private String getFrontmostPackageName() {
if (mTopActivityField == null) {
return null;
}
List<RunningTaskInfo> tasks = mActivityManager.getRunningTasks(1);
if (tasks.isEmpty()) {
return null;
}
RunningTaskInfo task = tasks.get(0);
ComponentName name;
try {
name = (ComponentName) mTopActivityField.get(task);
} catch (Exception e) {
throw new RuntimeException(e);
}
String pkgName = name.getPackageName();
if (pkgName.equals(mLauncherPkgName)) {
return null;
}
return pkgName;
}
private List<ApplicationInfo> getLauncherApplications() {
List<ApplicationInfo> apps = new ArrayList<ApplicationInfo>();
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
for (ResolveInfo resolveInfo : mPackageManager.queryIntentActivities(intent, 0)) {
apps.add(resolveInfo.activityInfo.applicationInfo);
}
return apps;
}
private JSONObject fetchAppParameters(ApplicationInfo appInfo, Scope scope) throws NameNotFoundException {
JSONObject parameters = new JSONObject();
PackageInfo packageInfo = mPackageManager.getPackageInfo(appInfo.packageName, 0);
try {
parameters.put("version", packageInfo.versionName);
parameters.put("build", Integer.toString(packageInfo.versionCode));
parameters.put("sources", fetchAppSources(appInfo));
parameters.put("data-dir", appInfo.dataDir);
parameters.put("target-sdk", appInfo.targetSdkVersion);
if ((appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
parameters.put("debuggable", true);
}
if (scope == Scope.FULL) {
JSONArray icons = new JSONArray();
icons.put(fetchAppIcon(appInfo));
parameters.put("$icons", icons);
}
} catch (JSONException e) {
throw new RuntimeException(e);
}
return parameters;
}
private static JSONArray fetchAppSources(ApplicationInfo appInfo) {
JSONArray sources = new JSONArray();
sources.put(appInfo.publicSourceDir);
String[] splitDirs = appInfo.splitPublicSourceDirs;
if (splitDirs != null) {
for (String splitDir : splitDirs) {
sources.put(splitDir);
}
}
return sources;
}
private String fetchAppIcon(ApplicationInfo appInfo) {
Drawable icon = mPackageManager.getApplicationIcon(appInfo);
int width = icon.getIntrinsicWidth();
int height = icon.getIntrinsicHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
icon.setBounds(0, 0, width, height);
icon.draw(canvas);
ByteArrayOutputStream output = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.PNG, 100, new Base64OutputStream(output, Base64.NO_WRAP));
return output.toString();
}
private Map<String, List<RunningAppProcessInfo>> getAppProcesses() {
Map<String, List<RunningAppProcessInfo>> processes = new HashMap<String, List<RunningAppProcessInfo>>();
for (RunningAppProcessInfo processInfo : mActivityManager.getRunningAppProcesses()) {
for (String pkgName : processInfo.pkgList) {
List<RunningAppProcessInfo> entries = processes.get(pkgName);
if (entries == null) {
entries = new ArrayList<RunningAppProcessInfo>();
processes.put(pkgName, entries);
}
entries.add(processInfo);
if (entries.size() > 1) {
Collections.sort(entries, new Comparator<RunningAppProcessInfo>() {
@Override
public int compare(RunningAppProcessInfo a, RunningAppProcessInfo b) {
return a.importance - b.importance;
}
});
}
}
}
return processes;
}
private static String deriveProcessNameFromCmdline(String cmdline) {
String str = cmdline;
int spaceDashOffset = str.indexOf(" -");
if (spaceDashOffset != -1) {
str = str.substring(0, spaceDashOffset);
}
return new File(str).getName();
}
private void addProcessMetadata(JSONObject parameters, int pid) throws IOException {
File procNode = new File("/proc/" + Integer.toString(pid));
String status = getFileContentsAsString(new File(procNode, "status"));
Matcher m = sStatusUidPattern.matcher(status);
m.find();
int uid = Integer.parseInt(m.group(1));
String stat = getFileContentsAsString(new File(procNode, "stat"));
int commFieldEndOffset = stat.indexOf(')');
int stateFieldStartOffset = commFieldEndOffset + 2;
String[] statFields = stat.substring(stateFieldStartOffset).split(" ");
int manPageFieldIdOffset = 3;
int ppid = Integer.parseInt(statFields[4 - manPageFieldIdOffset]);
long startTimeDeltaInJiffies = Long.parseLong(statFields[22 - manPageFieldIdOffset]);
long startTimeDeltaInMilliseconds = startTimeDeltaInJiffies * mMillisecondsPerJiffy;
Date started = new Date(mSystemBootTime + startTimeDeltaInMilliseconds);
try {
parameters.put("user", resolveUserIdToName(uid));
parameters.put("ppid", ppid);
parameters.put("started", mIso8601.format(started));
} catch (JSONException e) {
throw new RuntimeException(e);
}
}
private static long querySystemBootTime() {
String stat;
try {
stat = getFileContentsAsString(new File("/proc/stat"));
} catch (IOException e) {
throw new RuntimeException(e);
}
Matcher m = Pattern.compile("^btime (\\d+)$", Pattern.MULTILINE).matcher(stat);
m.find();
return Long.parseLong(m.group(1)) * 1000;
}
private String resolveUserIdToName(int uid) {
try {
return (String) mPwnameField.get(mGetpwuid.invoke(null, uid));
} catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
}
private String detectLauncherPackageName() {
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
List<ResolveInfo> launchers = mPackageManager.queryIntentActivities(intent, 0);
if (launchers.isEmpty()) {
return null;
}
return launchers.get(0).activityInfo.packageName;
}
private static String getFileContentsAsString(File file) throws IOException {
ByteArrayOutputStream result = new ByteArrayOutputStream();
FileInputStream input = new FileInputStream(file);
try {
byte[] buffer = new byte[64 * 1024];
while (true) {
int n = input.read(buffer);
if (n == -1) {
break;
}
result.write(buffer, 0, n);
}
} finally {
input.close();
}
return result.toString();
}
}
enum Scope {
MINIMAL,
METADATA,
FULL;
}
+19 -37
View File
@@ -172,8 +172,6 @@ static gboolean frida_exec_instance_try_perform_transition (FridaExecInstance *
static void frida_exec_instance_suspend (FridaExecInstance * self);
static void frida_exec_instance_resume (FridaExecInstance * self);
static void frida_make_pipe (int fds[2]);
static FridaInjectInstance * frida_inject_instance_new (FridaBinjector * binjector, guint id, guint pid, const FridaRemoteApi * api,
const gchar * temp_path);
static void frida_inject_instance_recreate_fifo (FridaInjectInstance * self);
@@ -211,7 +209,10 @@ _frida_binjector_do_spawn (FridaBinjector * self, const gchar * path, FridaHostS
{
FridaSpawnInstance * instance;
gchar ** argv, ** envp;
int stdin_pipe[2], stdout_pipe[2], stderr_pipe[2];
FridaFileDescriptor * in_fd = NULL;
FridaFileDescriptor * out_fd = NULL;
FridaFileDescriptor * err_fd = NULL;
GError * stdio_error = NULL;
gchar * old_cwd = NULL;
gboolean success;
const gchar * failed_operation;
@@ -221,24 +222,9 @@ _frida_binjector_do_spawn (FridaBinjector * self, const gchar * path, FridaHostS
argv = frida_host_spawn_options_compute_argv (options, path, NULL);
envp = frida_host_spawn_options_compute_envp (options, NULL);
switch (options->stdio)
{
case FRIDA_STDIO_INHERIT:
*pipes = NULL;
break;
case FRIDA_STDIO_PIPE:
frida_make_pipe (stdin_pipe);
frida_make_pipe (stdout_pipe);
frida_make_pipe (stderr_pipe);
*pipes = frida_stdio_pipes_new (stdin_pipe[1], stdout_pipe[0], stderr_pipe[0]);
break;
default:
g_assert_not_reached ();
}
*pipes = frida_make_stdio_pipes (options->stdio, TRUE, &in_fd, NULL, &out_fd, NULL, &err_fd, NULL, &stdio_error);
if (stdio_error != NULL)
goto propagate_stdio_error;
if (strlen (options->cwd) > 0)
{
@@ -254,9 +240,9 @@ _frida_binjector_do_spawn (FridaBinjector * self, const gchar * path, FridaHostS
if (options->stdio == FRIDA_STDIO_PIPE)
{
dup2 (stdin_pipe[0], 0);
dup2 (stdout_pipe[1], 1);
dup2 (stderr_pipe[1], 2);
dup2 (in_fd->handle, 0);
dup2 (out_fd->handle, 1);
dup2 (err_fd->handle, 2);
}
ptrace (PT_TRACE_ME, 0, NULL, 0);
@@ -273,13 +259,6 @@ _frida_binjector_do_spawn (FridaBinjector * self, const gchar * path, FridaHostS
g_warning ("Failed to restore working directory");
}
if (options->stdio == FRIDA_STDIO_PIPE)
{
close (stdin_pipe[0]);
close (stdout_pipe[1]);
close (stderr_pipe[1]);
}
success = frida_wait_for_child_signal (instance->pid, SIGTRAP, NULL);
CHECK_OS_RESULT (success, !=, FALSE, "wait(SIGTRAP)");
@@ -290,6 +269,11 @@ _frida_binjector_do_spawn (FridaBinjector * self, const gchar * path, FridaHostS
goto beach;
propagate_stdio_error:
{
g_propagate_error (error, stdio_error);
goto failure;
}
chdir_failed:
{
g_set_error (error,
@@ -316,6 +300,10 @@ failure:
}
beach:
{
g_clear_object (&in_fd);
g_clear_object (&out_fd);
g_clear_object (&err_fd);
g_free (old_cwd);
g_strfreev (envp);
g_strfreev (argv);
@@ -736,12 +724,6 @@ frida_exec_instance_resume (FridaExecInstance * self)
ptrace (PT_DETACH, self->pid, NULL, 0);
}
static void
frida_make_pipe (int fds[2])
{
g_unix_open_pipe (fds, FD_CLOEXEC, NULL);
}
static FridaInjectInstance *
frida_inject_instance_new (FridaBinjector * binjector, guint id, guint pid, const FridaRemoteApi * api, const gchar * temp_path)
{
+3 -40
View File
@@ -68,9 +68,9 @@ namespace Frida {
monitor_child (child_pid);
if (pipes != null) {
stdin_streams[child_pid] = new UnixOutputStream (pipes.input, false);
process_next_output_from.begin (new UnixInputStream (pipes.output, false), child_pid, 1, pipes);
process_next_output_from.begin (new UnixInputStream (pipes.error, false), child_pid, 2, pipes);
stdin_streams[child_pid] = pipes.input;
process_next_output_from.begin (pipes.output, child_pid, 1, pipes);
process_next_output_from.begin (pipes.error, child_pid, 2, pipes);
}
return child_pid;
@@ -696,41 +696,4 @@ namespace Frida {
protected enum ProgressMessageType {
HELLO = 0xff
}
protected class StdioPipes : Object {
public int input {
get;
construct;
}
public int output {
get;
construct;
}
public int error {
get;
construct;
}
public StdioPipes (int input, int output, int error) {
Object (input: input, output: output, error: error);
}
construct {
try {
Unix.set_fd_nonblocking (input, true);
Unix.set_fd_nonblocking (output, true);
Unix.set_fd_nonblocking (error, true);
} catch (GLib.Error e) {
assert_not_reached ();
}
}
~StdioPipes () {
Posix.close (input);
Posix.close (output);
Posix.close (error);
}
}
}
+8 -2
View File
@@ -24,7 +24,7 @@ namespace Frida {
}
}
public sealed class DeviceManager : Object {
public sealed class DeviceManager : Object, HostSessionHub {
public signal void added (Device device);
public signal void removed (Device device);
public signal void changed ();
@@ -394,6 +394,12 @@ namespace Frida {
changed ();
}
private async HostSessionEntry resolve_host_session (string id, Cancellable? cancellable) throws Error, IOError {
var device = yield get_device_by_id (id, 0, cancellable);
var session = yield device.get_host_session (cancellable);
return new HostSessionEntry (device.provider, session);
}
private void check_open () throws Error {
if (stop_request != null)
throw new Error.INVALID_OPERATION ("Device manager is closed");
@@ -1326,7 +1332,7 @@ namespace Frida {
host_session_request = new Promise<HostSession> ();
try {
var session = yield provider.create (host_session_options, cancellable);
var session = yield provider.create (manager, host_session_options, cancellable);
attach_host_session (session);
current_host_session = session;
+89 -24
View File
@@ -961,7 +961,10 @@ namespace Frida.Fruity {
private LibUSB.Context? usb_context;
private LibUSB.HotCallbackHandle iphone_callback;
private LibUSB.HotCallbackHandle ipad_callback;
private uint pending_usb_device_arrivals = 0;
private Gee.Set<uint32> startup_counted = new Gee.HashSet<uint32> ();
private uint startup_inflight = 0;
private uint startup_barrier_reached = 0;
private uint usb_started_resolved = 0;
private Gee.Map<uint32, LibUSB.Device> polled_usb_devices = new Gee.HashMap<uint32, LibUSB.Device> ();
private Source? polled_usb_timer;
private uint polled_usb_outdated = 0;
@@ -1099,14 +1102,17 @@ namespace Frida.Fruity {
return;
}
AtomicUint.inc (ref pending_usb_device_arrivals);
bool callbacks_registered = true;
bool callbacks_registered = false;
if (LibUSB.has_capability (HAS_HOTPLUG) != 0) {
usb_context.hotplug_register_callback (DEVICE_ARRIVED | DEVICE_LEFT, ENUMERATE, VENDOR_ID_APPLE,
PRODUCT_ID_IPHONE, LibUSB.HotPlugEvent.MATCH_ANY, on_usb_hotplug_event, out iphone_callback);
usb_context.hotplug_register_callback (DEVICE_ARRIVED | DEVICE_LEFT, ENUMERATE, VENDOR_ID_APPLE,
PRODUCT_ID_IPAD, LibUSB.HotPlugEvent.MATCH_ANY, on_usb_hotplug_event, out ipad_callback);
callbacks_registered = true;
usb_context.interrupt_event_handler ();
int completed = 0;
usb_context.handle_events_completed (out completed);
} else {
refresh_polled_usb_devices ();
@@ -1120,21 +1126,17 @@ namespace Frida.Fruity {
polled_usb_timer = source;
}
if (AtomicUint.dec_and_test (ref pending_usb_device_arrivals)) {
schedule_on_frida_thread (() => {
usb_started.resolve (true);
return Source.REMOVE;
});
}
schedule_startup_barrier_close ();
while (state != STOPPING) {
int completed = 0;
usb_context.handle_events_completed (out completed);
while (true) {
State s;
lock (state)
s = state;
if (AtomicUint.compare_and_exchange (ref polled_usb_outdated, 1, 0))
refresh_polled_usb_devices ();
if (s == STOPPING)
break;
if (state == FLUSHING) {
if (s == FLUSHING) {
if (callbacks_registered) {
usb_context.hotplug_deregister_callback (iphone_callback);
usb_context.hotplug_deregister_callback (ipad_callback);
@@ -1147,10 +1149,18 @@ namespace Frida.Fruity {
}
lock (state) {
if (pending_usb_ops.is_empty)
if (pending_usb_ops.is_empty) {
state = STOPPING;
break;
}
}
}
int completed = 0;
usb_context.handle_events_completed (out completed);
if (s != FLUSHING && AtomicUint.compare_and_exchange (ref polled_usb_outdated, 1, 0))
refresh_polled_usb_devices ();
}
schedule_on_frida_thread (() => {
@@ -1168,9 +1178,22 @@ namespace Frida.Fruity {
}
private void on_usb_device_arrived (LibUSB.Device device) {
AtomicUint.inc (ref pending_usb_device_arrivals);
var desc = LibUSB.DeviceDescriptor (device);
uint32 id = make_usb_device_id (device, desc);
bool counted_for_startup = false;
lock (state) {
if (state == STARTING && AtomicUint.get (ref startup_barrier_reached) == 0) {
if (!startup_counted.contains (id)) {
startup_counted.add (id);
AtomicUint.inc (ref startup_inflight);
counted_for_startup = true;
}
}
}
schedule_on_frida_thread (() => {
handle_usb_device_arrival.begin (device);
handle_usb_device_arrival.begin (device, counted_for_startup, id);
return Source.REMOVE;
});
}
@@ -1182,7 +1205,7 @@ namespace Frida.Fruity {
});
}
private async void handle_usb_device_arrival (LibUSB.Device raw_device) {
private async void handle_usb_device_arrival (LibUSB.Device raw_device, bool counted_for_startup, uint32 counted_id) {
try {
UsbDevice usb_device;
try {
@@ -1199,7 +1222,11 @@ namespace Frida.Fruity {
var transport = usb_transports.first_match (t => t.udid == udid);
bool may_need_time_to_settle = state != STARTING && (transport == null || transport.modeswitch_in_progress);
bool starting;
lock (state)
starting = state == STARTING;
bool may_need_time_to_settle = !starting && (transport == null || transport.modeswitch_in_progress);
if (may_need_time_to_settle) {
try {
yield sleep (250, io_cancellable);
@@ -1219,7 +1246,11 @@ namespace Frida.Fruity {
transport = new PortableCoreDeviceUsbTransport (this, usb_device, pairing_store);
usb_transports.add (transport);
if (state != STARTING) {
bool open_now;
lock (state)
open_now = state != STARTING;
if (open_now) {
try {
yield transport.open (io_cancellable);
} catch (GLib.Error e) {
@@ -1229,11 +1260,19 @@ namespace Frida.Fruity {
transport_attached (transport);
}
} finally {
if (AtomicUint.dec_and_test (ref pending_usb_device_arrivals) && state == STARTING)
usb_started.resolve (true);
if (counted_for_startup)
resolve_startup_device (counted_id);
}
}
private void resolve_startup_device (uint32 id) {
lock (state)
startup_counted.remove (id);
if (AtomicUint.dec_and_test (ref startup_inflight))
maybe_resolve_usb_started ();
}
private async void handle_usb_device_departure (LibUSB.Device raw_device) {
var transport = usb_transports.first_match (t => t.usb_device.raw_device == raw_device && !t.modeswitch_in_progress);
if (transport == null)
@@ -1274,6 +1313,32 @@ namespace Frida.Fruity {
polled_usb_devices = current_devices;
}
private void maybe_resolve_usb_started () {
if (AtomicUint.get (ref startup_barrier_reached) == 0)
return;
if (AtomicUint.get (ref startup_inflight) != 0)
return;
if (!AtomicUint.compare_and_exchange (ref usb_started_resolved, 0, 1))
return;
schedule_on_frida_thread (() => {
usb_started.resolve (true);
return Source.REMOVE;
});
}
private void schedule_startup_barrier_close () {
var source = new IdleSource ();
source.set_priority (Priority.LOW);
source.set_callback (() => {
AtomicUint.set (ref startup_barrier_reached, 1);
maybe_resolve_usb_started ();
return Source.REMOVE;
});
source.attach (main_context);
}
private UsbOperation allocate_usb_operation () throws Error {
var op = new PendingUsbOperation (this);
+2 -1
View File
@@ -80,7 +80,8 @@ namespace Frida {
yield Fruity.DTXConnection.close_all (device, cancellable);
}
public async HostSession create (HostSessionOptions? options, Cancellable? cancellable) throws Error, IOError {
public async HostSession create (HostSessionHub hub, HostSessionOptions? options, Cancellable? cancellable)
throws Error, IOError {
if (host_session != null)
throw new Error.INVALID_OPERATION ("Already created");
+6 -2
View File
@@ -88,8 +88,12 @@ namespace Frida.Fruity {
request.set_string ("SystemBUID", system_buid);
var response = yield service.query (request, cancellable);
if (response.has ("Error"))
throw new LockdownError.PROTOCOL ("Unexpected response: %s", response.get_string ("Error"));
if (response.has ("Error")) {
var error = response.get_string ("Error");
if (error == "InvalidHostID")
yield unpair (cancellable);
throw new LockdownError.PROTOCOL ("Unexpected response: %s", error);
}
if (response.get_boolean ("EnableSessionSSL"))
service.stream = yield start_tls (service.stream, cancellable);
+4 -1
View File
@@ -760,8 +760,11 @@ namespace Frida.Fruity {
return OK;
}));
if (n == 0)
if (n == 0) {
if (state == CLOSED)
throw new IOError.CLOSED ("Connection is closed");
throw new IOError.WOULD_BLOCK ("Resource temporarily unavailable");
}
return n;
}
+74 -13
View File
@@ -47,6 +47,9 @@ namespace Frida {
}
private void add_nonlocal_backends () {
#if HAVE_SIMMY_BACKEND
add_backend (new SimmyHostSessionBackend ());
#endif
#if !IOS && !ANDROID && !TVOS
#if HAVE_FRUITY_BACKEND
add_backend (new FruityHostSessionBackend ());
@@ -161,7 +164,7 @@ namespace Frida {
get;
}
public abstract async HostSession create (HostSessionOptions? options = null,
public abstract async HostSession create (HostSessionHub hub, HostSessionOptions? options = null,
Cancellable? cancellable = null) throws Error, IOError;
public abstract async void destroy (HostSession session, Cancellable? cancellable = null) throws Error, IOError;
public signal void host_session_detached (HostSession session);
@@ -180,6 +183,42 @@ namespace Frida {
public abstract void unlink_service_session (HostSession host_session, ServiceSessionId id);
}
public interface HostSessionConnection : Object {
public abstract HostSession host_session {
get;
}
public abstract async AgentSession link_agent_session (AgentSessionId id, AgentMessageSink sink,
Cancellable? cancellable = null) throws Error, IOError;
public abstract void unlink_agent_session (AgentSessionId id);
}
public interface HostSessionHub : Object {
public abstract async HostSessionEntry resolve_host_session (string id, Cancellable? cancellable) throws Error, IOError;
}
public class NullHostSessionHub : Object, HostSessionHub {
public async HostSessionEntry resolve_host_session (string id, Cancellable? cancellable) throws Error, IOError {
throw new Error.NOT_SUPPORTED ("Host session lookup not supported");
}
}
public class HostSessionEntry : Object {
public HostSessionProvider provider {
get;
construct;
}
public HostSession session {
get;
construct;
}
public HostSessionEntry (HostSessionProvider provider, HostSession session) {
Object (provider: provider, session: session);
}
}
public enum HostSessionProviderKind {
LOCAL,
REMOTE,
@@ -277,7 +316,8 @@ namespace Frida {
host_session = null;
}
public async HostSession create (HostSessionOptions? options, Cancellable? cancellable) throws Error, IOError {
public async HostSession create (HostSessionHub hub, HostSessionOptions? options, Cancellable? cancellable)
throws Error, IOError {
if (host_session != null)
throw new Error.INVALID_OPERATION ("Already created");
@@ -321,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) {
@@ -332,7 +379,13 @@ namespace Frida {
}
}
public abstract class LocalHostSession : Object, HostSession, AgentController {
public abstract class LocalHostSession : Object, HostSession, HostSessionConnection, AgentController {
public HostSession host_session {
get {
return this;
}
}
private Gee.HashMap<uint, Cancellable> pending_establish_ops = new Gee.HashMap<uint, Cancellable> ();
private Gee.HashMap<uint, Future<AgentEntry>> agent_entries = new Gee.HashMap<uint, Future<AgentEntry>> ();
@@ -351,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 {
@@ -901,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 {
@@ -1423,7 +1486,7 @@ namespace Frida {
public abstract class InternalAgent : Object, AgentMessageSink, RpcPeer {
public signal void unloaded ();
public weak LocalHostSession host_session {
public weak HostSessionConnection connection {
get;
construct;
}
@@ -1447,11 +1510,7 @@ namespace Frida {
construct {
rpc_client = new RpcClient (this);
host_session.agent_session_detached.connect (on_agent_session_detached);
}
~InternalAgent () {
host_session.agent_session_detached.disconnect (on_agent_session_detached);
connection.host_session.agent_session_detached.connect (on_agent_session_detached);
}
public async void close (Cancellable? cancellable) throws IOError {
@@ -1463,6 +1522,8 @@ namespace Frida {
}
yield ensure_unloaded (cancellable);
connection.host_session.agent_session_detached.disconnect (on_agent_session_detached);
}
protected abstract async uint get_target_pid (Cancellable? cancellable) throws Error, IOError;
@@ -1516,9 +1577,9 @@ namespace Frida {
target_pid = yield get_target_pid (cancellable);
try {
session_id = yield host_session.attach (target_pid, attach_options, cancellable);
session_id = yield connection.host_session.attach (target_pid, attach_options, cancellable);
session = yield host_session.link_agent_session (session_id, (AgentMessageSink) this, cancellable);
session = yield connection.link_agent_session (session_id, (AgentMessageSink) this, cancellable);
string? source = yield load_source (cancellable);
if (source != null) {
+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;
}
}
}
-22
View File
@@ -1,22 +0,0 @@
import esbuild from 'esbuild';
import alias from 'esbuild-plugin-alias';
import { createRequire } from 'module';
const require = createRequire(import.meta.url);
const BUFFER_SHIM = require.resolve('@frida/buffer');
esbuild.build({
entryPoints: ['index.js'],
outfile: 'system-server.js',
bundle: true,
platform: 'node',
target: ['es2022'],
legalComments: 'none',
minify: true,
plugins: [
alias({
'buffer': BUFFER_SHIM,
'node:buffer': BUFFER_SHIM,
}),
],
}).catch(() => process.exit(1));
-492
View File
@@ -1,492 +0,0 @@
import Java from 'frida-java-bridge';
let ApplicationInfo, Base64OutputStream, Bitmap, ByteArrayOutputStream, Canvas, ComponentName, ContextWrapper, Intent, ResolveInfo,
RunningAppProcessInfo, RunningTaskInfo, UserHandle;
let ACTION_MAIN, ARGB_8888, CATEGORY_HOME, CATEGORY_LAUNCHER, GET_ACTIVITIES, FLAG_ACTIVITY_NEW_TASK, FLAG_DEBUGGABLE, NO_WRAP, PNG;
let context, packageManager, activityManager, loadAppLabel, loadResolveInfoLabel;
let multiUserSupported;
let launcherPkgName;
const pendingLaunches = new Map();
function init() {
const ActivityManager = Java.use('android.app.ActivityManager');
const ActivityThread = Java.use('android.app.ActivityThread');
ApplicationInfo = Java.use('android.content.pm.ApplicationInfo');
const Base64 = Java.use('android.util.Base64');
Base64OutputStream = Java.use('android.util.Base64OutputStream');
Bitmap = Java.use('android.graphics.Bitmap');
const BitmapCompressFormat = Java.use('android.graphics.Bitmap$CompressFormat');
const BitmapConfig = Java.use('android.graphics.Bitmap$Config');
ByteArrayOutputStream = Java.use('java.io.ByteArrayOutputStream');
Canvas = Java.use('android.graphics.Canvas');
ComponentName = Java.use('android.content.ComponentName');
ContextWrapper = Java.use('android.content.ContextWrapper');
Intent = Java.use('android.content.Intent');
const Context = Java.use('android.content.Context');
const PackageManager = Java.use('android.content.pm.PackageManager');
ResolveInfo = Java.use('android.content.pm.ResolveInfo');
RunningAppProcessInfo = Java.use('android.app.ActivityManager$RunningAppProcessInfo');
RunningTaskInfo = Java.use('android.app.ActivityManager$RunningTaskInfo');
UserHandle = Java.use('android.os.UserHandle');
const ACTIVITY_SERVICE = Context.ACTIVITY_SERVICE.value;
ACTION_MAIN = Intent.ACTION_MAIN.value;
ARGB_8888 = BitmapConfig.ARGB_8888.value;
CATEGORY_HOME = Intent.CATEGORY_HOME.value;
CATEGORY_LAUNCHER = Intent.CATEGORY_LAUNCHER.value;
GET_ACTIVITIES = PackageManager.GET_ACTIVITIES.value;
FLAG_ACTIVITY_NEW_TASK = Intent.FLAG_ACTIVITY_NEW_TASK.value;
FLAG_DEBUGGABLE = ApplicationInfo.FLAG_DEBUGGABLE.value;
NO_WRAP = Base64.NO_WRAP.value;
PNG = BitmapCompressFormat.PNG.value;
context = ActivityThread.currentApplication();
packageManager = context.getPackageManager();
activityManager = Java.cast(context.getSystemService(ACTIVITY_SERVICE), ActivityManager);
loadAppLabel = ApplicationInfo.loadUnsafeLabel ?? ApplicationInfo.loadLabel;
multiUserSupported = 'getApplicationInfoAsUser' in PackageManager;
launcherPkgName = detectLauncherPackageName();
installLaunchTimeoutRemovalInstrumentation();
}
rpc.exports = {
getFrontmostApplication(scope) {
return performOnJavaVM(() => {
const pkgName = getFrontmostPackageName();
if (pkgName === null)
return null;
const appInfo = packageManager.getApplicationInfo(pkgName, 0);
const appLabel = loadAppLabel.call(appInfo, packageManager).toString();
const pid = computeAppPids(getAppProcesses()).get(pkgName) ?? 0;
const parameters = (scope !== 'minimal') ? fetchAppParameters(pkgName, appInfo, scope) : null;
return [pkgName, appLabel, pid, parameters];
});
},
enumerateApplications(identifiers, scope) {
return performOnJavaVM(() => {
const apps = [];
if (identifiers.length > 0) {
for (const pkgName of identifiers) {
try {
apps.push([pkgName, packageManager.getApplicationInfo(pkgName, 0)]);
} catch (e) {
}
}
} else {
for (const appInfo of getLauncherApplications()) {
apps.push([appInfo.packageName.value, appInfo]);
}
}
const result = [];
const pids = computeAppPids(getAppProcesses());
const includeParameters = scope !== 'minimal';
const frontmostPkgName = includeParameters ? getFrontmostPackageName() : null;
for (const [pkgName, appInfo] of apps) {
const appLabel = loadAppLabel.call(appInfo, packageManager).toString();
const pid = pids.get(pkgName) ?? 0;
let parameters = null;
if (includeParameters) {
parameters = fetchAppParameters(pkgName, appInfo, scope);
if (pkgName === frontmostPkgName)
parameters.frontmost = true;
}
result.push([pkgName, appLabel, pid, parameters]);
}
return result;
});
},
getProcessName(pkgName, uid) {
checkUidOptionSupported(uid);
return performOnJavaVM(() => {
try {
return getAppInfo(pkgName, uid).processName.value;
} catch (e) {
throw new Error(`Unable to find application with identifier '${pkgName}'${(uid !== 0) ? ' belonging to uid ' + uid : ''}`);
}
});
},
getProcessParameters(pids, scope) {
const result = {};
const appProcesses = getAppProcesses();
const appPidByPkgName = computeAppPids(appProcesses);
const appProcessByPid = new Map();
for (const process of appProcesses)
appProcessByPid.set(process.pid, process);
const appInfoByPkgName = new Map();
for (const appInfo of getLauncherApplications())
appInfoByPkgName.set(appInfo.packageName.value, appInfo);
const appInfoByPid = new Map();
for (const [pkgName, appPid] of appPidByPkgName.entries()) {
const appInfo = appInfoByPkgName.get(pkgName);
if (appInfo !== undefined)
appInfoByPid.set(appPid, appInfo);
}
let frontmostPid = -1;
const frontmostPkgName = getFrontmostPackageName();
if (frontmostPkgName !== null) {
frontmostPid = appPidByPkgName.get(frontmostPkgName) ?? -1;
}
const includeParameters = scope !== 'minimal';
const includeIcons = scope === 'full';
for (const pid of pids) {
const parameters = {};
const appInfo = appInfoByPid.get(pid);
if (appInfo !== undefined) {
parameters.$name = loadAppLabel.call(appInfo, packageManager).toString()
if (includeIcons)
parameters.$icon = fetchAppIcon(appInfo);
}
if (includeParameters) {
const appProcess = appProcessByPid.get(pid);
if (appProcess !== undefined) {
parameters.applications = appProcess.pkgList;
}
if (pid === frontmostPid) {
parameters.frontmost = true;
}
}
if (Object.keys(parameters).length !== 0) {
result[pid] = parameters;
}
}
return result;
},
startActivity(pkgName, activity, uid) {
checkUidOptionSupported(uid);
return performOnJavaVM(() => {
let user, ctx, pm;
if (uid !== 0) {
user = UserHandle.of(uid);
ctx = context.createPackageContextAsUser(pkgName, 0, user);
pm = ctx.getPackageManager();
} else {
user = null;
ctx = context;
pm = packageManager;
}
let appInstalled = false;
const apps = (uid !== 0)
? pm.getInstalledApplicationsAsUser(0, uid)
: pm.getInstalledApplications(0);
const numApps = apps.size();
for (let i = 0; i !== numApps; i++) {
const appInfo = Java.cast(apps.get(i), ApplicationInfo);
if (appInfo.packageName.value === pkgName) {
appInstalled = true;
break;
}
}
if (!appInstalled)
throw new Error("Unable to find application with identifier '" + pkgName + "'");
let intent = pm.getLaunchIntentForPackage(pkgName);
if (intent === null && 'getLeanbackLaunchIntentForPackage' in pm)
intent = pm.getLeanbackLaunchIntentForPackage(pkgName);
if (intent === null && activity === null)
throw new Error('Unable to find a front-door activity');
if (intent === null) {
intent = Intent.$new();
intent.setFlags(FLAG_ACTIVITY_NEW_TASK);
}
if (activity !== null) {
const pkgInfo = (uid !== 0)
? pm.getPackageInfoAsUser(pkgName, GET_ACTIVITIES, uid)
: pm.getPackageInfo(pkgName, GET_ACTIVITIES);
const activities = pkgInfo.activities.value.map(activityInfo => activityInfo.name.value);
if (!activities.includes(activity))
throw new Error("Unable to find activity with identifier '" + activity + "'");
intent.setClassName(pkgName, activity);
}
performLaunchOperation(pkgName, uid, () => {
if (user !== null)
ContextWrapper.$new(ctx).startActivityAsUser(intent, user);
else
ctx.startActivity(intent);
});
});
},
sendBroadcast(pkgName, receiver, action, uid) {
checkUidOptionSupported(uid);
return performOnJavaVM(() => {
const intent = Intent.$new();
intent.setComponent(ComponentName.$new(pkgName, receiver));
intent.setAction(action);
performLaunchOperation(pkgName, uid, () => {
if (uid !== 0)
ContextWrapper.$new(context).sendBroadcastAsUser(intent, UserHandle.of(uid));
else
context.sendBroadcast(intent);
});
});
},
stopPackage(pkgName, uid) {
checkUidOptionSupported(uid);
return performOnJavaVM(() => {
if (uid !== 0)
activityManager.forceStopPackageAsUser(pkgName, uid);
else
activityManager.forceStopPackage(pkgName);
});
},
tryStopPackageByPid(pid) {
return performOnJavaVM(() => {
const processes = activityManager.getRunningAppProcesses();
const numProcesses = processes.size();
for (let i = 0; i !== numProcesses; i++) {
const process = Java.cast(processes.get(i), RunningAppProcessInfo);
if (process.pid.value === pid) {
for (const pkgName of process.pkgList.value) {
activityManager.forceStopPackage(pkgName);
}
return true;
}
}
return false;
});
},
};
function getFrontmostPackageName() {
const tasks = activityManager.getRunningTasks(1);
if (tasks.isEmpty())
return null;
const task = Java.cast(tasks.get(0), RunningTaskInfo);
if (task.topActivity === undefined)
return null;
const name = task.topActivity.value.getPackageName();
if (name === launcherPkgName)
return null;
return name;
}
function getLauncherApplications() {
const intent = Intent.$new(ACTION_MAIN);
intent.addCategory(CATEGORY_LAUNCHER);
const activities = packageManager.queryIntentActivities(intent, 0);
const result = [];
const n = activities.size();
for (let i = 0; i !== n; i++) {
const resolveInfo = Java.cast(activities.get(i), ResolveInfo);
result.push(resolveInfo.activityInfo.value.applicationInfo.value);
}
return result;
}
function getAppInfo(pkgName, uid) {
return (uid !== 0)
? packageManager.getApplicationInfoAsUser(pkgName, 0, uid)
: packageManager.getApplicationInfo(pkgName, 0);
}
function fetchAppParameters(pkgName, appInfo, scope) {
const pkgInfo = packageManager.getPackageInfo(pkgName, 0);
const parameters = {
'version': pkgInfo.versionName.value,
'build': pkgInfo.versionCode.value.toString(),
'sources': [appInfo.publicSourceDir.value].concat(appInfo.splitPublicSourceDirs?.value ?? []),
'data-dir': appInfo.dataDir.value,
'target-sdk': appInfo.targetSdkVersion.value,
};
if ((appInfo.flags.value & FLAG_DEBUGGABLE) !== 0)
parameters.debuggable = true;
if (scope === 'full')
parameters.$icon = fetchAppIcon(appInfo);
return parameters;
}
function fetchAppIcon(appInfo) {
const icon = packageManager.getApplicationIcon(appInfo);
const width = icon.getIntrinsicWidth();
const height = icon.getIntrinsicHeight();
const bitmap = Bitmap.createBitmap(width, height, ARGB_8888);
const canvas = Canvas.$new(bitmap);
icon.setBounds(0, 0, width, height);
icon.draw(canvas);
const output = ByteArrayOutputStream.$new();
bitmap.compress(PNG, 100, Base64OutputStream.$new(output, NO_WRAP));
return output.toString('US-ASCII');
}
function getAppProcesses() {
const result = [];
const processes = activityManager.getRunningAppProcesses();
const n = processes.size();
for (let i = 0; i !== n; i++) {
const process = Java.cast(processes.get(i), RunningAppProcessInfo);
result.push({
pid: process.pid.value,
importance: process.importance.value,
pkgList: process.pkgList.value
});
}
return result;
}
function computeAppPids(processes) {
const pids = new Map();
for (const { pid, importance, pkgList } of processes) {
for (const pkgName of pkgList) {
let entries = pids.get(pkgName);
if (entries === undefined) {
entries = [];
pids.set(pkgName, entries);
}
entries.push([ pid, importance ]);
if (entries.length > 1) {
entries.sort((a, b) => a[1] - b[1]);
}
}
}
return new Map(Array.from(pids.entries()).map(([k, v]) => [k, v[0][0]]));
}
function detectLauncherPackageName() {
const intent = Intent.$new(ACTION_MAIN);
intent.addCategory(CATEGORY_HOME);
const launchers = packageManager.queryIntentActivities(intent, 0);
if (launchers.isEmpty())
return null;
const launcher = Java.cast(launchers.get(0), ResolveInfo);
return launcher.activityInfo.value.packageName.value;
}
function checkUidOptionSupported(uid) {
if (uid !== 0 && !multiUserSupported)
throw new Error('The “uid” option is not supported on the current Android OS version');
}
function installLaunchTimeoutRemovalInstrumentation() {
const Handler = Java.use('android.os.Handler');
const OSProcess = Java.use('android.os.Process');
const pendingStartRequests = new Set();
const start = OSProcess.start;
start.implementation = function (processClass, niceName) {
const result = start.apply(this, arguments);
if (tryFinishLaunch(niceName)) {
pendingStartRequests.add(Process.getCurrentThreadId());
}
return result;
};
const sendMessageDelayed = Handler.sendMessageDelayed;
sendMessageDelayed.implementation = function (msg, delayMillis) {
const tid = Process.getCurrentThreadId();
if (pendingStartRequests.has(tid)) {
pendingStartRequests.delete(tid);
msg.recycle();
return true;
}
return sendMessageDelayed.call(this, msg, delayMillis);
};
}
function performLaunchOperation(pkgName, uid, operation) {
const processName = getAppInfo(pkgName, uid).processName.value;
tryFinishLaunch(processName);
const timer = setTimeout(() => {
if (pendingLaunches.get(processName) === timer)
tryFinishLaunch(processName);
}, 10000);
pendingLaunches.set(processName, timer);
try {
return operation();
} catch (e) {
tryFinishLaunch(processName);
throw e;
}
}
function tryFinishLaunch(processName) {
const timer = pendingLaunches.get(processName);
if (timer === undefined)
return false;
pendingLaunches.delete(processName);
clearTimeout(timer);
return true;
}
function performOnJavaVM(task) {
return new Promise((resolve, reject) => {
Java.perform(() => {
try {
const result = task();
resolve(result);
} catch (e) {
reject(e);
}
});
});
}
Java.perform(init);
-19
View File
@@ -1,19 +0,0 @@
system_server_js = custom_target('system-server.js',
input: [
'package.json',
'package-lock.json',
'build.js',
'index.js',
],
output: [
'system-server.js',
],
command: [
python,
compile_js_agent,
'@OUTPUT@',
'@PRIVATE_DIR@',
npm,
'@INPUT@',
],
)
-563
View File
@@ -1,563 +0,0 @@
{
"name": "frida-system-server-agent",
"version": "1.0.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "frida-system-server-agent",
"version": "1.0.0",
"dependencies": {
"@frida/buffer": "^7.0.4",
"frida-java-bridge": "^7.0.8"
},
"devDependencies": {
"esbuild": "^0.25.5",
"esbuild-plugin-alias": "^0.2.1"
}
},
"node_modules/@esbuild/aix-ppc64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz",
"integrity": "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==",
"cpu": [
"ppc64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"aix"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-arm": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.5.tgz",
"integrity": "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==",
"cpu": [
"arm"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz",
"integrity": "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.5.tgz",
"integrity": "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/darwin-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz",
"integrity": "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/darwin-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz",
"integrity": "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/freebsd-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz",
"integrity": "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/freebsd-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz",
"integrity": "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-arm": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz",
"integrity": "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==",
"cpu": [
"arm"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz",
"integrity": "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-ia32": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz",
"integrity": "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==",
"cpu": [
"ia32"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-loong64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz",
"integrity": "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==",
"cpu": [
"loong64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-mips64el": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz",
"integrity": "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==",
"cpu": [
"mips64el"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-ppc64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz",
"integrity": "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==",
"cpu": [
"ppc64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-riscv64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz",
"integrity": "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==",
"cpu": [
"riscv64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-s390x": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz",
"integrity": "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==",
"cpu": [
"s390x"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz",
"integrity": "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/netbsd-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz",
"integrity": "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"netbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/netbsd-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz",
"integrity": "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"netbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/openbsd-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz",
"integrity": "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/openbsd-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz",
"integrity": "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/sunos-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz",
"integrity": "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"sunos"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-arm64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz",
"integrity": "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-ia32": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz",
"integrity": "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==",
"cpu": [
"ia32"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-x64": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz",
"integrity": "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@frida/buffer": {
"version": "7.0.4",
"resolved": "https://registry.npmjs.org/@frida/buffer/-/buffer-7.0.4.tgz",
"integrity": "sha512-RxQ1lZRRiCJj7nhcCiD8xeJx0NsLpGGnjqsmTg7jShGmbnVFMN5W7+J+3gqdPSQhc/IxNBIWc6zRXVp4+qnYHg==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"license": "MIT",
"dependencies": {
"base64-js": "^1.5.1",
"ieee754": "^1.2.1"
}
},
"node_modules/base64-js": {
"version": "1.5.1",
"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"license": "MIT"
},
"node_modules/esbuild": {
"version": "0.25.5",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz",
"integrity": "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==",
"dev": true,
"hasInstallScript": true,
"license": "MIT",
"bin": {
"esbuild": "bin/esbuild"
},
"engines": {
"node": ">=18"
},
"optionalDependencies": {
"@esbuild/aix-ppc64": "0.25.5",
"@esbuild/android-arm": "0.25.5",
"@esbuild/android-arm64": "0.25.5",
"@esbuild/android-x64": "0.25.5",
"@esbuild/darwin-arm64": "0.25.5",
"@esbuild/darwin-x64": "0.25.5",
"@esbuild/freebsd-arm64": "0.25.5",
"@esbuild/freebsd-x64": "0.25.5",
"@esbuild/linux-arm": "0.25.5",
"@esbuild/linux-arm64": "0.25.5",
"@esbuild/linux-ia32": "0.25.5",
"@esbuild/linux-loong64": "0.25.5",
"@esbuild/linux-mips64el": "0.25.5",
"@esbuild/linux-ppc64": "0.25.5",
"@esbuild/linux-riscv64": "0.25.5",
"@esbuild/linux-s390x": "0.25.5",
"@esbuild/linux-x64": "0.25.5",
"@esbuild/netbsd-arm64": "0.25.5",
"@esbuild/netbsd-x64": "0.25.5",
"@esbuild/openbsd-arm64": "0.25.5",
"@esbuild/openbsd-x64": "0.25.5",
"@esbuild/sunos-x64": "0.25.5",
"@esbuild/win32-arm64": "0.25.5",
"@esbuild/win32-ia32": "0.25.5",
"@esbuild/win32-x64": "0.25.5"
}
},
"node_modules/esbuild-plugin-alias": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/esbuild-plugin-alias/-/esbuild-plugin-alias-0.2.1.tgz",
"integrity": "sha512-jyfL/pwPqaFXyKnj8lP8iLk6Z0m099uXR45aSN8Av1XD4vhvQutxxPzgA2bTcAwQpa1zCXDcWOlhFgyP3GKqhQ==",
"dev": true,
"license": "MIT"
},
"node_modules/frida-java-bridge": {
"version": "7.0.8",
"resolved": "https://registry.npmjs.org/frida-java-bridge/-/frida-java-bridge-7.0.8.tgz",
"integrity": "sha512-EmqoTGzcDuCd+YFcjBJJPf7iVQCSbbj9fD0/TN8YYYwl5ZJtTqaCLTTsaC07o3bJaDVs/f3ks+Vu1bOw0S1PnQ==",
"license": "LGPL-2.0 WITH WxWindows-exception-3.1"
},
"node_modules/ieee754": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"license": "BSD-3-Clause"
}
}
}
@@ -1,17 +0,0 @@
{
"name": "frida-system-server-agent",
"version": "1.0.0",
"description": "Agent used by Frida's Linux backend on Android",
"type": "module",
"scripts": {
"build": "node build.js"
},
"devDependencies": {
"esbuild": "^0.25.5",
"esbuild-plugin-alias": "^0.2.1"
},
"dependencies": {
"@frida/buffer": "^7.0.4",
"frida-java-bridge": "^7.0.8"
}
}
+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;
}
+183 -314
View File
@@ -36,21 +36,8 @@ namespace Frida {
string[] argv = options.compute_argv (path);
string[] envp = options.compute_envp ();
StdioPipes? pipes = null;
FileDescriptor? stdin_read = null, stdin_write = null;
FileDescriptor? stdout_read = null, stdout_write = null;
FileDescriptor? stderr_read = null, stderr_write = null;
switch (options.stdio) {
case INHERIT:
break;
case PIPE: {
make_pty (out stdin_read, out stdin_write);
make_pty (out stdout_read, out stdout_write);
make_pty (out stderr_read, out stderr_write);
pipes = new StdioPipes (stdin_write, stdout_read, stderr_read);
break;
}
}
FileDescriptor? in_fd, out_fd, err_fd;
StdioPipes? pipes = make_stdio_pipes (options.stdio, true, out in_fd, null, out out_fd, null, out err_fd, null);
string? old_cwd = null;
if (options.cwd.length > 0) {
@@ -68,10 +55,10 @@ namespace Frida {
if (pid == 0) {
Posix.setsid ();
if (options.stdio == PIPE) {
Posix.dup2 (stdin_read.handle, 0);
Posix.dup2 (stdout_write.handle, 1);
Posix.dup2 (stderr_write.handle, 2);
if (pipes != null) {
Posix.dup2 (in_fd.handle, 0);
Posix.dup2 (out_fd.handle, 1);
Posix.dup2 (err_fd.handle, 2);
}
if (_ptrace (TRACEME) == -1) {
@@ -232,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;
}
@@ -637,9 +624,9 @@ namespace Frida {
monitor ();
if (pipes != null) {
stdin_stream = new UnixOutputStream (pipes.input.handle, false);
process_next_output_from.begin (new UnixInputStream (pipes.output.handle, false), 1);
process_next_output_from.begin (new UnixInputStream (pipes.error.handle, false), 2);
stdin_stream = pipes.input;
process_next_output_from.begin (pipes.output, 1);
process_next_output_from.begin (pipes.error, 2);
}
}
@@ -703,37 +690,6 @@ namespace Frida {
}
}
private sealed class StdioPipes : Object {
public FileDescriptor input {
get;
construct;
}
public FileDescriptor output {
get;
construct;
}
public FileDescriptor error {
get;
construct;
}
public StdioPipes (FileDescriptor input, FileDescriptor output, FileDescriptor error) {
Object (input: input, output: output, error: error);
}
construct {
try {
Unix.set_fd_nonblocking (input.handle, true);
Unix.set_fd_nonblocking (output.handle, true);
Unix.set_fd_nonblocking (error.handle, true);
} catch (GLib.Error e) {
assert_not_reached ();
}
}
}
private sealed class ExecTransitionSession : SeizeSession {
private ExecTransitionSession (uint pid) {
Object (pid: pid, on_init: SeizeSession.InitBehavior.CONTINUE);
@@ -782,28 +738,41 @@ 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;
do {
while (state != SATISFIED) {
ptrace (SYSCALL, tid, null, (void *) pending_signal);
pending_signal = 0;
Posix.Signal sig = yield wait_for_next_signal (cancellable);
if (sig != (TRAP | 0x80)) {
on_syscall_entry = !on_syscall_entry;
pending_signal = sig;
var wr = yield ChildProcess.wait_for_next_stop (tid, cancellable);
wr.check_stopped ();
if (wr.is_ptrace_event_stop) {
if (wr.ptrace_event == PtraceEvent.EXEC)
on_syscall_entry = true;
continue;
}
if (on_syscall_entry) {
get_regs (&saved_regs);
if (_syscall_satisfies (get_syscall_id (saved_regs), mask))
state = SATISFIED;
if (wr.is_syscall_stop) {
if (on_syscall_entry) {
get_regs (&saved_regs);
var id = get_syscall_id (saved_regs);
if (_syscall_satisfies (id, mask))
state = SATISFIED;
}
on_syscall_entry = !on_syscall_entry;
continue;
}
on_syscall_entry = !on_syscall_entry;
} while (state != SATISFIED);
if (wr.should_deliver_to_tracee)
pending_signal = wr.stop_signal;
else
pending_signal = 0;
}
}
public async void interrupt (Cancellable? cancellable) throws Error, IOError {
@@ -1086,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;
@@ -1197,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);
@@ -2061,6 +2032,10 @@ namespace Frida {
return yield ChildProcess.wait_for_next_signal (tid, cancellable);
}
public async WaitResult wait_for_next_stop (Cancellable? cancellable) throws Error, IOError {
return yield ChildProcess.wait_for_next_stop (tid, cancellable);
}
public void get_regs (GPRegs * regs) throws Error {
#if !MIPS
if (regset_supported) {
@@ -2252,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,
@@ -2262,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);
}
}
@@ -3062,30 +3037,53 @@ namespace Frida {
namespace ChildProcess {
private async void wait_for_early_signal (uint pid, Posix.Signal sig, Cancellable? cancellable) throws Error, IOError {
while (true) {
Posix.Signal next_signal = yield wait_for_next_signal (pid, cancellable);
if (next_signal == sig)
return;
ptrace (CONT, pid);
}
yield wait_for_signals_common (pid, { sig }, suppress_unmatched, cancellable);
}
private async void wait_for_signal (uint pid, Posix.Signal sig, Cancellable? cancellable) throws Error, IOError {
yield wait_for_signals (pid, { sig }, cancellable);
}
private async Posix.Signal wait_for_signals (uint pid, Posix.Signal[] sigs, Cancellable? cancellable) throws Error, IOError {
while (true) {
Posix.Signal next_signal = yield wait_for_next_signal (pid, cancellable);
if (next_signal in sigs)
return next_signal;
private async Posix.Signal wait_for_signals (uint pid, Posix.Signal[] sigs, Cancellable? cancellable)
throws Error, IOError {
return yield wait_for_signals_common (pid, sigs, pass_through_unmatched, cancellable);
}
ptrace (CONT, pid, null, (void *) next_signal);
private async Posix.Signal wait_for_signals_common (uint pid, Posix.Signal[] sigs, UnmatchedStopHandler on_unmatched,
Cancellable? cancellable) throws Error, IOError {
while (true) {
var wr = yield wait_for_next_stop (pid, cancellable);
wr.check_stopped ();
if (wr.stop_signal in sigs)
return wr.stop_signal;
if (!wr.should_deliver_to_tracee) {
ptrace (CONT, pid);
continue;
}
on_unmatched (pid, wr);
}
}
private delegate void UnmatchedStopHandler (uint pid, WaitResult wr) throws Error;
private static void pass_through_unmatched (uint pid, WaitResult wr) throws Error {
ptrace (CONT, pid, null, (void *) wr.stop_signal);
}
private static void suppress_unmatched (uint pid, WaitResult wr) throws Error {
ptrace (CONT, pid);
}
private async Posix.Signal wait_for_next_signal (uint pid, Cancellable? cancellable) throws Error, IOError {
var wr = yield wait_for_next_stop (pid, cancellable);
wr.check_stopped ();
return wr.stop_signal;
}
private async WaitResult wait_for_next_stop (uint pid, Cancellable? cancellable) throws Error, IOError {
var main_context = MainContext.get_thread_default ();
bool timed_out = false;
@@ -3098,21 +3096,23 @@ namespace Frida {
int status = 0;
uint[] delays = { 0, 1, 2, 5, 10, 20, 50, 250 };
try {
for (uint i = 0; !timed_out && !cancellable.set_error_if_cancelled (); i++) {
int res = Posix.waitpid ((Posix.pid_t) pid, out status, Posix.WNOHANG);
if (res == -1)
throw new Error.NOT_SUPPORTED ("Unable to wait for next signal: %s", strerror (errno));
throw new Error.NOT_SUPPORTED ("Unable to wait for next stop: %s", strerror (errno));
if (res != 0)
break;
uint delay_ms = (i < delays.length) ? delays[i] : delays[delays.length - 1];
var delay_source = new TimeoutSource (delay_ms);
delay_source.set_callback (wait_for_next_signal.callback);
delay_source.set_callback (wait_for_next_stop.callback);
delay_source.attach (main_context);
var cancel_source = new CancellableSource (cancellable);
cancel_source.set_callback (wait_for_next_signal.callback);
cancel_source.set_callback (wait_for_next_stop.callback);
cancel_source.attach (main_context);
yield;
@@ -3125,21 +3125,79 @@ namespace Frida {
}
if (timed_out)
throw new Error.TIMED_OUT ("Unexpectedly timed out while waiting for signal from process with PID %u", pid);
throw new Error.TIMED_OUT ("Unexpectedly timed out while waiting for stop from process with PID %u", pid);
return WaitResult (pid, status);
}
}
public enum WaitKind {
EXITED,
SIGNALED,
STOPPED,
OTHER
}
public struct WaitResult {
public uint pid;
public int status;
public WaitKind kind;
public uint exit_status;
public Posix.Signal term_signal;
public Posix.Signal stop_signal;
public PtraceEvent ptrace_event;
public bool is_ptrace_event_stop;
public bool is_syscall_stop;
public bool should_deliver_to_tracee;
public WaitResult (uint pid, int status) {
this.pid = pid;
this.status = status;
kind = WaitKind.OTHER;
exit_status = 0;
term_signal = 0;
stop_signal = 0;
ptrace_event = PtraceEvent.NONE;
is_ptrace_event_stop = false;
is_syscall_stop = false;
should_deliver_to_tracee = false;
if (PosixStatus.is_exit (status)) {
throw new Error.NOT_SUPPORTED ("Target exited with status %u",
PosixStatus.parse_exit_status (status));
}
kind = WaitKind.EXITED;
exit_status = PosixStatus.parse_exit_status (status);
} else if (PosixStatus.is_signaled (status)) {
kind = WaitKind.SIGNALED;
term_signal = PosixStatus.parse_termination_signal (status);
} else if (PosixStatus.is_stopped (status)) {
kind = WaitKind.STOPPED;
if (PosixStatus.is_signaled (status)) {
throw new Error.NOT_SUPPORTED ("Target terminated with signal %u",
PosixStatus.parse_termination_signal (status));
}
stop_signal = PosixStatus.parse_stop_signal (status);
ptrace_event = PosixStatus.ptrace_event (status);
if (!PosixStatus.is_stopped (status))
throw new Error.NOT_SUPPORTED ("Unexpected status: 0x%08x", status);
return PosixStatus.parse_stop_signal (status);
is_ptrace_event_stop = (stop_signal == Posix.Signal.TRAP) && (ptrace_event != NONE);
is_syscall_stop = (stop_signal == (Posix.Signal.TRAP | 0x80)) && (ptrace_event == NONE);
should_deliver_to_tracee = !is_syscall_stop && !is_ptrace_event_stop && stop_signal != Posix.Signal.TRAP;
}
}
public void check_stopped () throws Error {
switch (kind) {
case WaitKind.EXITED:
throw new Error.NOT_SUPPORTED ("Target exited with status %u", exit_status);
case WaitKind.SIGNALED:
throw new Error.NOT_SUPPORTED ("Target terminated with signal %u", term_signal);
case WaitKind.STOPPED:
return;
default:
throw new Error.NOT_SUPPORTED ("Unexpected status: 0x%08x", status);
}
}
}
@@ -3161,217 +3219,28 @@ namespace Frida {
[CCode (cname = "WSTOPSIG", cheader_filename = "sys/wait.h")]
private extern Posix.Signal parse_stop_signal (int status);
private PtraceEvent ptrace_event (int status) {
return ((uint) status) >> 16;
}
}
public enum PtraceEvent {
NONE,
FORK,
VFORK,
CLONE,
EXEC,
VFORK_DONE,
EXIT,
SECCOMP,
}
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);
private void make_pty (out FileDescriptor read, out FileDescriptor write) throws Error {
#if HAVE_OPENPTY
int rfd = -1, wfd = -1;
char name[Posix.Limits.PATH_MAX];
if (Linux.openpty (out rfd, out wfd, name, null, null) == -1)
throw new Error.NOT_SUPPORTED ("Unable to open PTY: %s", strerror (errno));
enable_close_on_exec (rfd);
enable_close_on_exec (wfd);
configure_terminal_attributes (rfd);
read = new FileDescriptor (rfd);
write = new FileDescriptor (wfd);
#else
try {
int fds[2];
Unix.open_pipe (fds, Posix.FD_CLOEXEC);
read = new FileDescriptor (fds[0]);
write = new FileDescriptor (fds[1]);
} catch (GLib.Error e) {
throw new Error.NOT_SUPPORTED ("Unable to open pipe: %s", e.message);
}
#endif
}
#if HAVE_OPENPTY
private void enable_close_on_exec (int fd) {
Posix.fcntl (fd, Posix.F_SETFD, Posix.fcntl (fd, Posix.F_GETFD) | Posix.FD_CLOEXEC);
}
private void configure_terminal_attributes (int fd) {
var tios = Posix.termios ();
Posix.tcgetattr (fd, out tios);
tios.c_oflag &= ~Posix.ONLCR;
tios.c_cflag = (tios.c_cflag & Posix.CLOCAL) | Posix.CS8 | Posix.CREAD | Posix.HUPCL;
tios.c_lflag &= ~Posix.ECHO;
Posix.tcsetattr (fd, 0, tios);
}
#endif
private sealed 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 = MapsIter.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 = MapsIter.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;
}
}
private class MapsIter {
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 MapsIter for_pid (uint pid) {
return new MapsIter (pid);
}
private MapsIter (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 -7
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,16 +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
cp build/bootstrapper.bin bootstrapper-$(host_arch).bin
cp build/loader.bin loader-$(host_arch).bin
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; \
@@ -28,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";
Loaded 100 of 163 files, more files were not shown because too many files have changed in this diff. Show more