Projects
Mega:24.09
systemtap
Sign Up
Log In
Username
Password
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
Expand all
Collapse all
Changes of Revision 3
View file
_service:tar_scm:systemtap.spec
Changed
@@ -22,7 +22,7 @@ Name: systemtap Version: 5.0 -Release: 1 +Release: 3 Summary: Linux trace and probe tool License: GPLv2+ and Public Domain URL: http://sourceware.org/systemtap @@ -30,6 +30,8 @@ Patch9000: huawei-fix-network-tcp-test-error.patch Patch9001: huawei-local-is-only-valid-in-functions-for-shellche-sc2168.patch +Patch9002: Add-basic-LoongArch64-support.patch +Patch9003: Make-stp_task_work-compatible-with-6.11-kernels.patch BuildRequires: gcc-c++ emacs systemd python3-setuptools BuildRequires: gettext-devel rpm-devel readline-devel @@ -477,6 +479,18 @@ %{_mandir}/man1378/* %changelog +* Wed Sep 04 2024 wangxiao <wangxiao184@h-partners.com> - 5.0-3 +- Type:bugfix +- CVE:NA +- SUG:NA +- DESC:Make stp_task_work compatible with 6.11 kernels + +* Fri Jul 05 2024 wangqiang <wangqiang1@kylinos.cn> - 5.0-2 +- Type:update +- CVE:NA +- SUG:NA +- DESC:Add basic loongarch64 support + * Wed Jan 24 2024 liuchao <liuchao173@huawei.com> - 5.0-1 - Upgrade to 5.0: - Performance improvements in uprobe registration and module startup.
View file
_service:tar_scm:Add-basic-LoongArch64-support.patch
Added
@@ -0,0 +1,2442 @@ +From 3c7f981349c02da5baee0d1f721571078aa6bbc6 Mon Sep 17 00:00:00 2001 +From: wangqiang <wangqiang1@kylinos.cn> +Date: Fri, 5 Jul 2024 15:51:29 +0800 +Subject: PATCH Add basic LoongArch64 support + +LoongArch is a new RISC ISA, which is a bit like MIPS or RISC-V. +LoongArch includes a reduced 32-bit version (LA32R), a standard 32-bit +version (LA32S) and a 64-bit version (LA64). LoongArch use ACPI as its +boot protocol LoongArch-specific interrupt controllers (similar to APIC) +are already added in the next revision of ACPI Specification (current +revision is 6.4). + +This patchset is adding basic LoongArch support in mainline systemtap. +--- + bpf-translate.cxx | 33 + + buildrun.cxx | 9 +- + dwflpp.cxx | 1 + + dwflpp.h | 4 + + runtime/dyninst/regs.c | 20 + + runtime/dyninst/stapdyn.h | 26 + + runtime/linux/compat_structs.h | 4 +- + runtime/linux/compat_unistd.h | 4 +- + runtime/linux/regs.c | 20 + + runtime/linux/runtime.h | 2 +- + runtime/loc2c-runtime.h | 49 + + runtime/regs.h | 8 + + runtime/syscall.h | 42 + + runtime/unwind/loongarch.h | 83 + + runtime/unwind/unwind.h | 2 + + scripts/dump-syscalls.sh | 6 + + stapbpf/libbpf.c | 2 +- + stapdyn/mutatee.cxx | 9 + + tapset/errno.stp | 2 + + tapset/linux/aux_syscalls.stp | 5 +- + tapset/linux/loongarch64/aux_syscalls.stp | 12 + + tapset/linux/loongarch64/registers.stp | 293 +++++ + tapset/linux/loongarch64/syscall_num.stp | 1283 +++++++++++++++++++++ + tapset/linux/syscalls.stpm | 2 +- + tapsets.cxx | 40 +- + testsuite/lib/compile_flags.exp | 9 +- + testsuite/lib/systemtap.exp | 3 +- + testsuite/systemtap.syscall/clone.c | 2 +- + translate.cxx | 3 +- + util.cxx | 2 + + 30 files changed, 1964 insertions(+), 16 deletions(-) + create mode 100644 runtime/unwind/loongarch.h + create mode 100644 tapset/linux/loongarch64/aux_syscalls.stp + create mode 100644 tapset/linux/loongarch64/registers.stp + create mode 100644 tapset/linux/loongarch64/syscall_num.stp + +diff --git a/bpf-translate.cxx b/bpf-translate.cxx +index 1a93024..8867d8e 100644 +--- a/bpf-translate.cxx ++++ b/bpf-translate.cxx +@@ -3328,6 +3328,39 @@ bpf_unparser::visit_target_register (target_register* e) + case 29: ofs = offsetof(user_pt_regs, regs29); break; + case 30: ofs = offsetof(user_pt_regs, regs30); break; + case 31: ofs = offsetof(user_pt_regs, sp); break; ++#elif defined(__loongarch64) ++ case 0: ofs = offsetof(user_pt_regs, regs0); break; ++ case 1: ofs = offsetof(user_pt_regs, regs1); break; ++ case 2: ofs = offsetof(user_pt_regs, regs2); break; ++ case 3: ofs = offsetof(user_pt_regs, regs3); break; ++ case 4: ofs = offsetof(user_pt_regs, regs4); break; ++ case 5: ofs = offsetof(user_pt_regs, regs5); break; ++ case 6: ofs = offsetof(user_pt_regs, regs6); break; ++ case 7: ofs = offsetof(user_pt_regs, regs7); break; ++ case 8: ofs = offsetof(user_pt_regs, regs8); break; ++ case 9: ofs = offsetof(user_pt_regs, regs9); break; ++ case 10: ofs = offsetof(user_pt_regs, regs10); break; ++ case 11: ofs = offsetof(user_pt_regs, regs11); break; ++ case 12: ofs = offsetof(user_pt_regs, regs12); break; ++ case 13: ofs = offsetof(user_pt_regs, regs13); break; ++ case 14: ofs = offsetof(user_pt_regs, regs14); break; ++ case 15: ofs = offsetof(user_pt_regs, regs15); break; ++ case 16: ofs = offsetof(user_pt_regs, regs16); break; ++ case 17: ofs = offsetof(user_pt_regs, regs17); break; ++ case 18: ofs = offsetof(user_pt_regs, regs18); break; ++ case 19: ofs = offsetof(user_pt_regs, regs19); break; ++ case 20: ofs = offsetof(user_pt_regs, regs20); break; ++ case 21: ofs = offsetof(user_pt_regs, regs21); break; ++ case 22: ofs = offsetof(user_pt_regs, regs22); break; ++ case 23: ofs = offsetof(user_pt_regs, regs23); break; ++ case 24: ofs = offsetof(user_pt_regs, regs24); break; ++ case 25: ofs = offsetof(user_pt_regs, regs25); break; ++ case 26: ofs = offsetof(user_pt_regs, regs26); break; ++ case 27: ofs = offsetof(user_pt_regs, regs27); break; ++ case 28: ofs = offsetof(user_pt_regs, regs28); break; ++ case 29: ofs = offsetof(user_pt_regs, regs29); break; ++ case 30: ofs = offsetof(user_pt_regs, regs30); break; ++ case 31: ofs = offsetof(user_pt_regs, regs31); break; + #elif defined(__powerpc__) + case 0: ofs = offsetof(pt_regs, gpr0); break; + case 1: ofs = offsetof(pt_regs, gpr1); break; +diff --git a/buildrun.cxx b/buildrun.cxx +index 8168420..3eaf7a6 100644 +--- a/buildrun.cxx ++++ b/buildrun.cxx +@@ -144,8 +144,13 @@ make_any_make_cmd(systemtap_session& s, const string& dir, const string& target) + + // Add architecture, except for old powerpc (RHBZ669082) + if (s.architecture != "powerpc" || +- (strverscmp (s.kernel_base_release.c_str(), "2.6.15") >= 0)) +- make_cmd.push_back("ARCH=" + s.architecture); // need make-quoting? ++ (strverscmp (s.kernel_base_release.c_str(), "2.6.15") >= 0)) { ++ if (s.architecture == "loongarch64") { ++ make_cmd.push_back("ARCH=loongarch"); ++ } else { ++ make_cmd.push_back("ARCH=" + s.architecture); // need make-quoting? ++ } ++ } + + // PR29837: Suppress the kernel version warning + make_cmd.push_back("CC_VERSION_TEXT=foo"); +diff --git a/dwflpp.cxx b/dwflpp.cxx +index 9fccca0..d1b2b70 100644 +--- a/dwflpp.cxx ++++ b/dwflpp.cxx +@@ -1355,6 +1355,7 @@ dwflpp::iterate_over_libraries<void>(void (*callback)(void*, const char*), + && interpreter != "/lib/ld-linux-armhf.so.3" // arm + && interpreter != "/lib/ld-linux-aarch64.so.1" // arm64 + && interpreter != "/lib64/ld64.so.2" // ppc64le ++ && interpreter != "/lib64/ld-linux-loongarch-lp64d.so.1" // loongarch64 + ) + { + sess.print_warning (_F("module %s --ldd skipped: unsupported interpreter: %s", +diff --git a/dwflpp.h b/dwflpp.h +index d90ce94..a604992 100644 +--- a/dwflpp.h ++++ b/dwflpp.h +@@ -36,6 +36,10 @@ + #define EM_RISCV 243 + #endif + ++// Old elf.h doesn't know about this machine type. ++#ifndef EM_LOONGARCH ++#define EM_LOONGARCH 258 ++#endif + + #define write_uleb128(ptr,val) ({ \ + uint32_t valv = (val); \ +diff --git a/runtime/dyninst/regs.c b/runtime/dyninst/regs.c +index 8389ebd..664e45d 100644 +--- a/runtime/dyninst/regs.c ++++ b/runtime/dyninst/regs.c +@@ -87,6 +87,26 @@ static void _stp_print_regs(struct pt_regs * regs) + _stp_printf("\n"); + } + ++#elif defined (__loongarch64) ++static void _stp_print_regs(struct pt_regs * regs) ++{ ++ int i, top_reg; ++ u64 lr, sp; ++ ++ lr = regs->regs1; ++ sp = regs->regs3; ++ top_reg = 31; ++ ++ _stp_printf("pc : <%016llx> lr : <%016llx> estat: %08llx\n", ++ regs->csr_era, lr, regs->csr_estat); ++ for (i = top_reg; i >= 0; i--) { ++ _stp_printf("x%-2d: %016llx ", i, regs->regsi); ++ if (i % 2 == 0) ++ _stp_printf("\n"); ++ } ++ _stp_printf("\n"); ++} ++ + #endif + + #endif /* _DYNINST_REGS_C_ */ +diff --git a/runtime/dyninst/stapdyn.h b/runtime/dyninst/stapdyn.h +index 4045dfc..2467f9a 100644 +--- a/runtime/dyninst/stapdyn.h ++++ b/runtime/dyninst/stapdyn.h +@@ -52,6 +52,32 @@ struct pt_regs { + }; + #endif + ++#if defined(__loongarch64) ++ ++/* ++ * This struct defines the way the registers are stored on the stack during a ++ * system call/exception. ++ * ++ * If you add a register here, also add it to regoffset_table in ++ * arch/loongarch/kernel/ptrace.c. ++ */ ++struct pt_regs { ++ /* Saved main processor registers. */ ++ unsigned long regs32; ++ ++ /* Saved special registers. */ ++ unsigned long csr_era; ++ unsigned long csr_badv; ++ unsigned long csr_crmd; ++ unsigned long csr_prmd; ++ unsigned long csr_euen; ++ unsigned long csr_ecfg; ++ unsigned long csr_estat; ++ unsigned long orig_a0; ++ unsigned long __last; ++} __attribute__ ((aligned (8))); ++#endif ++ + /* These are declarations of all interfaces that stapdyn may call in the + * module, either directly or via dyninst in the mutatee. To maintain + * compatibility as much as possible, function signatures should not be +diff --git a/runtime/linux/compat_structs.h b/runtime/linux/compat_structs.h +index fa9b855..1ca6de7 100644 +--- a/runtime/linux/compat_structs.h ++++ b/runtime/linux/compat_structs.h +@@ -133,7 +133,7 @@ typedef struct compat_siginfo { + #include <asm/ia32.h> + #endif /* __x86_64__ */ + +-#if defined(__aarch64__) ++#if defined(__aarch64__) || defined(__loongarch64) + typedef struct compat_siginfo { + int si_signo; + int si_errno; +@@ -193,6 +193,6 @@ typedef struct compat_siginfo { + } _sigsys; + } _sifields; + } compat_siginfo_t; +-#endif /* __aarch64__ */ ++#endif /* __aarch64__, __loongarch64 */ + + #endif /* _COMPAT_STRUCTS_H_ */ +diff --git a/runtime/linux/compat_unistd.h b/runtime/linux/compat_unistd.h +index a66be04..84052e0 100644 +--- a/runtime/linux/compat_unistd.h ++++ b/runtime/linux/compat_unistd.h +@@ -1860,7 +1860,7 @@ + + #endif /* __x86_64__ */ + +-#if defined(__powerpc64__) || defined (__s390x__) || defined(__aarch64__) ++#if defined(__powerpc64__) || defined (__s390x__) || defined(__aarch64__) || defined(__loongarch64) + + // On the ppc64 and s390x, the 32-bit syscalls use the same number + // as the 64-bit syscalls. +@@ -2217,7 +2217,7 @@ + #endif + #define __NR_compat_writev __NR_writev + +-#endif /* __powerpc64__ || __s390x__ || __aarch64__ */ ++#endif /* __powerpc64__ || __s390x__ || __aarch64__ || __loongarch64 */ + + #if defined(__ia64__) + +diff --git a/runtime/linux/regs.c b/runtime/linux/regs.c +index f2aaa74..dc0edef 100644 +--- a/runtime/linux/regs.c ++++ b/runtime/linux/regs.c +@@ -225,6 +225,26 @@ static void _stp_print_regs(struct pt_regs * regs) + _stp_printf("\n"); + } + ++#elif defined (__loongarch64) ++static void _stp_print_regs(struct pt_regs * regs) ++{ ++ int i, top_reg; ++ u64 lr, sp; ++ ++ lr = regs->regs1; ++ sp = regs->regs3; ++ top_reg = 31; ++ ++ _stp_printf("pc : <%016llx> lr : <%016llx> estat: %08llx\n", ++ regs->csr_era, lr, regs->csr_estat); ++ for (i = top_reg; i >= 0; i--) { ++ _stp_printf("x%-2d: %016llx ", i, regs->regsi); ++ if (i % 2 == 0) ++ _stp_printf("\n"); ++ } ++ _stp_printf("\n"); ++} ++ + #elif defined (__arm__) + + static const char *processor_modes= +diff --git a/runtime/linux/runtime.h b/runtime/linux/runtime.h +index a584079..c931e5e 100644 +--- a/runtime/linux/runtime.h ++++ b/runtime/linux/runtime.h +@@ -201,7 +201,7 @@ static struct + Only define STP_USE_DWARF_UNWINDER when STP_NEED_UNWIND_DATA, + as set through a pragma:unwind in one of the ucontext-unwind.stp + functions. */ +-#if (defined(__arm__) || defined(__i386__) || defined(__x86_64__) || defined(__powerpc64__)) || defined (__s390x__) || defined(__aarch64__) || defined(__mips__) || defined(__riscv) ++#if (defined(__arm__) || defined(__i386__) || defined(__x86_64__) || defined(__powerpc64__)) || defined (__s390x__) || defined(__aarch64__) || defined(__mips__) || defined(__riscv) || defined(__loongarch64) + #ifdef STP_NEED_UNWIND_DATA + #ifndef STP_USE_DWARF_UNWINDER + #define STP_USE_DWARF_UNWINDER +diff --git a/runtime/loc2c-runtime.h b/runtime/loc2c-runtime.h +index 073ba04..d2732af 100644 +--- a/runtime/loc2c-runtime.h ++++ b/runtime/loc2c-runtime.h +@@ -202,6 +202,16 @@ + (pt_regs->regsregno = (value)) + #define pt_regs_maxno 31 /* ignore special registers */ + ++#elif defined __loongarch64 ++ ++#undef pt_regs_fetch_register ++#undef pt_regs_store_register ++#define pt_regs_fetch_register(pt_regs,regno) \ ++ ((intptr_t) pt_regs->regsregno) ++#define pt_regs_store_register(pt_regs,regno,value) \ ++ (pt_regs->regsregno = (value)) ++#define pt_regs_maxno 31 /* register max number,ignore special registers */ ++ + #elif defined __riscv + + #define pt_dwarf_register_0(regs) regs->epc +@@ -310,6 +320,45 @@ + #define pt_dwarf_register_95(regs) ({uint64_t v; __asm__ __volatile__("mov %0, v31.d0" : "=r"(v)); v;}) + #define pt_regs_maxno 95 + ++#elif defined (__loongarch64) ++ ++#define pt_dwarf_register_0(pt_regs) pt_regs->regs0 ++#define pt_dwarf_register_1(pt_regs) pt_regs->regs1 ++#define pt_dwarf_register_2(pt_regs) pt_regs->regs2 ++#define pt_dwarf_register_3(pt_regs) pt_regs->regs3 ++#define pt_dwarf_register_4(pt_regs) pt_regs->regs4 ++#define pt_dwarf_register_5(pt_regs) pt_regs->regs5 ++#define pt_dwarf_register_6(pt_regs) pt_regs->regs6 ++#define pt_dwarf_register_7(pt_regs) pt_regs->regs7 ++#define pt_dwarf_register_8(pt_regs) pt_regs->regs8 ++#define pt_dwarf_register_9(pt_regs) pt_regs->regs9 ++ ++#define pt_dwarf_register_10(pt_regs) pt_regs->regs10 ++#define pt_dwarf_register_11(pt_regs) pt_regs->regs11 ++#define pt_dwarf_register_12(pt_regs) pt_regs->regs12 ++#define pt_dwarf_register_13(pt_regs) pt_regs->regs13 ++#define pt_dwarf_register_14(pt_regs) pt_regs->regs14 ++#define pt_dwarf_register_15(pt_regs) pt_regs->regs15 ++#define pt_dwarf_register_16(pt_regs) pt_regs->regs16 ++#define pt_dwarf_register_17(pt_regs) pt_regs->regs17 ++#define pt_dwarf_register_18(pt_regs) pt_regs->regs18 ++#define pt_dwarf_register_19(pt_regs) pt_regs->regs19 ++ ++#define pt_dwarf_register_20(pt_regs) pt_regs->regs20 ++#define pt_dwarf_register_21(pt_regs) pt_regs->regs21 ++#define pt_dwarf_register_22(pt_regs) pt_regs->regs22 ++#define pt_dwarf_register_23(pt_regs) pt_regs->regs23 ++#define pt_dwarf_register_24(pt_regs) pt_regs->regs24 ++#define pt_dwarf_register_25(pt_regs) pt_regs->regs25 ++#define pt_dwarf_register_26(pt_regs) pt_regs->regs26 ++#define pt_dwarf_register_27(pt_regs) pt_regs->regs27 ++#define pt_dwarf_register_28(pt_regs) pt_regs->regs28 ++#define pt_dwarf_register_29(pt_regs) pt_regs->regs29 ++ ++#define pt_dwarf_register_30(pt_regs) pt_regs->regs30 ++#define pt_dwarf_register_31(pt_regs) pt_regs->regs31 ++#define pt_regs_maxno 31 ++ + #elif defined (__arm__) + + #undef pt_regs_fetch_register +diff --git a/runtime/regs.h b/runtime/regs.h +index b0237fc..05c9dce 100644 +--- a/runtime/regs.h ++++ b/runtime/regs.h +@@ -64,6 +64,14 @@ + #define REG_SP(regs_arg) (regs_arg)->sp + #define REG_LINK(regs_arg) (regs_arg)->ra + ++#elif defined (__loongarch64) ++#define REG_IP(regs_arg) ((regs_arg)->csr_era) ++#ifdef REG_SP ++#undef REG_SP ++#define REG_SP(regs_arg) ((regs_arg)->regs3) ++#endif ++#define REG_LINK(regs_arg) ((regs_arg)->regs1) ++ + #elif defined (__s390__) || defined (__s390x__) + + #ifndef __s390x__ +diff --git a/runtime/syscall.h b/runtime/syscall.h +index 44d8a28..92a10e4 100644 +--- a/runtime/syscall.h ++++ b/runtime/syscall.h +@@ -158,6 +158,14 @@ + #define MREMAP_SYSCALL_NO(tsk) 216 + #endif + ++#if defined(__loongarch64) ++#define MMAP_SYSCALL_NO(tsk) 222 ++#define MMAP2_SYSCALL_NO(tsk) 222 ++#define MPROTECT_SYSCALL_NO(tsk) 226 ++#define MUNMAP_SYSCALL_NO(tsk) 215 ++#define MREMAP_SYSCALL_NO(tsk) 216 ++#endif ++ + #if !defined(MMAP_SYSCALL_NO) || !defined(MMAP2_SYSCALL_NO) \ + || !defined(MPROTECT_SYSCALL_NO) || !defined(MUNMAP_SYSCALL_NO) \ + || !defined(MREMAP_SYSCALL_NO) +@@ -261,6 +269,14 @@ _stp_syscall_get_nr(struct task_struct *task, struct pt_regs *regs) + } + #endif + ++#if defined(__loongarch64) ++static inline long ++_stp_syscall_get_nr(struct task_struct *task, struct pt_regs *regs) ++{ ++ return regs->regs11; ++} ++#endif ++ + #if defined(__aarch64__) + static inline long + _stp_syscall_get_nr(struct task_struct *task, struct pt_regs *regs) +@@ -327,6 +343,14 @@ syscall_get_return_value(struct task_struct *task, struct pt_regs *regs) + } + #endif + ++#if defined(__loongarch64) ++static inline long ++syscall_get_return_value(struct task_struct *task, struct pt_regs *regs) ++{ ++ return regs->regs4; ++} ++#endif ++ + #if defined(__arm__) + static inline long + syscall_get_return_value(struct task_struct *task, struct pt_regs *regs) +@@ -676,5 +700,23 @@ _stp_syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, + } + #endif + ++#if defined(__loongarch64) ++static inline void ++_stp_syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, ++ unsigned int i, unsigned int n, unsigned long *args) ++{ ++ if (!n) ++ return; ++ if (i == 0) { ++ args0 = regs->orig_a0; ++ args++; ++ n--; ++ } else { ++ i--; ++ } ++ memcpy(args, ®s->regs5 + i, n * sizeof(args0)); ++} ++#endif ++ + #endif /* !STAPCONF_ASM_SYSCALL_H */ + #endif /* _SYSCALL_H_ */ +diff --git a/runtime/unwind/loongarch.h b/runtime/unwind/loongarch.h +new file mode 100644 +index 0000000..a5e5390 +--- /dev/null ++++ b/runtime/unwind/loongarch.h +@@ -0,0 +1,83 @@ ++/* -*- linux-c -*- ++ * ++ * LOONGARCH dwarf unwinder header file ++ * ++ * This file is part of systemtap, and is free software. You can ++ * redistribute it and/or modify it under the terms of the GNU General ++ * Public License (GPL); either version 2, or (at your option) any ++ * later version. ++ */ ++#ifndef _STP_LOONGARCH_UNWIND_H ++#define _STP_LOONGARCH_UNWIND_H ++ ++#include <linux/sched.h> ++#include <asm/ptrace.h> ++ ++#define _stp_get_unaligned(ptr) (*(ptr)) ++ ++#define UNW_PC(frame) (frame)->regs.csr_era ++#define UNW_SP(frame) (frame)->regs.regs3 ++ ++#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) ++ ++// runtime/unwind/unwind.h: ++// struct pt_regs regs; ++// #define PTREGS_INFO(f) EXTRA_INFO(regs.f) ++// ++#define UNW_REGISTER_INFO \ ++ PTREGS_INFO(regs0), \ ++ PTREGS_INFO(regs1), \ ++ PTREGS_INFO(regs2), \ ++ PTREGS_INFO(regs3), \ ++ PTREGS_INFO(regs4), \ ++ PTREGS_INFO(regs5), \ ++ PTREGS_INFO(regs6), \ ++ PTREGS_INFO(regs7), \ ++ PTREGS_INFO(regs8), \ ++ PTREGS_INFO(regs9), \ ++ PTREGS_INFO(regs10), \ ++ PTREGS_INFO(regs11), \ ++ PTREGS_INFO(regs12), \ ++ PTREGS_INFO(regs13), \ ++ PTREGS_INFO(regs14), \ ++ PTREGS_INFO(regs16), \ ++ PTREGS_INFO(regs17), \ ++ PTREGS_INFO(regs18), \ ++ PTREGS_INFO(regs19), \ ++ PTREGS_INFO(regs20), \ ++ PTREGS_INFO(regs21), \ ++ PTREGS_INFO(regs22), \ ++ PTREGS_INFO(regs23), \ ++ PTREGS_INFO(regs24), \ ++ PTREGS_INFO(regs26), \ ++ PTREGS_INFO(regs27), \ ++ PTREGS_INFO(regs28), \ ++ PTREGS_INFO(regs29), \ ++ PTREGS_INFO(regs30), \ ++ PTREGS_INFO(regs31), \ ++ PTREGS_INFO(csr_era) ++ ++//libunwind: include/libunwind-loongarch64.h UNW_LOONGARCH64_PC = 33 ++#define UNW_PC_IDX 33 ++// sp(r3) register ++#define UNW_SP_IDX 3 ++ ++/* Use default rules. The stack pointer should be set from the CFA. ++ And the instruction pointer should be set from the return address ++ column (which normally is the return register (regs31). */ ++ ++static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, ++ /*const*/ struct pt_regs *regs, ++ int sanitize) ++{ ++ if (&info->regs == regs) { /* happens when unwinding kernel->user */ ++ info->call_frame = 1; ++ return; ++ } ++ ++ memset(info, 0, sizeof(*info)); ++ /* XXX handle sanitize??? */ ++ info->regs = *regs; ++} ++ ++#endif /* _STP_LOONGARCH_UNWIND_H */ +\ No newline at end of file +diff --git a/runtime/unwind/unwind.h b/runtime/unwind/unwind.h +index 1c77b50..cebae34 100644 +--- a/runtime/unwind/unwind.h ++++ b/runtime/unwind/unwind.h +@@ -38,6 +38,8 @@ struct unwind_frame_info + #include "mips.h" + #elif defined (__riscv) + #include "riscv.h" ++#elif defined (__loongarch64) ++#include "loongarch64.h" + #else + #error "Unsupported dwarf unwind architecture" + #endif +diff --git a/scripts/dump-syscalls.sh b/scripts/dump-syscalls.sh +index 57e5e42..420f620 100755 +--- a/scripts/dump-syscalls.sh ++++ b/scripts/dump-syscalls.sh +@@ -24,6 +24,7 @@ TAPSET_ARM=$TAPSET_SRC/linux/arm/syscall_num.stp + TAPSET_AARCH64=$TAPSET_SRC/linux/arm64/syscall_num.stp + TAPSET_MIPS=$TAPSET_SRC/linux/mips/syscall_num.stp + TAPSET_RISCV=$TAPSET_SRC/linux/riscv/syscall_num.stp ++TAPSET_LOONGARCH=$TAPSET_SRC/linux/loongarch64/syscall_num.stp + + SYSCALLS_32=$(mktemp) + SYSCALLS_64=$(mktemp) +@@ -132,5 +133,10 @@ __dump_syscalls $STRACE_SRC/linux/riscv64/syscallent.h 64 + # than nothing. + __dump_syscalls $STRACE_SRC/linux/riscv64/syscallent.h 32 + __generate_tapset $TAPSET_RISCV riscv ++# ======= loongarch64 ======= ++__init ++__dump_syscalls $STRACE_SRC/linux/64/syscallent.h 64 ++__dump_syscalls $STRACE_SRC/linux/loongarch64/syscallent.h 64 ++__generate_tapset $TAPSET_LOONGARCH loongarch64 + + rm -f $SYSCALLS_32 $SYSCALLS_64 +diff --git a/stapbpf/libbpf.c b/stapbpf/libbpf.c +index 09f20eb..95505c5 100644 +--- a/stapbpf/libbpf.c ++++ b/stapbpf/libbpf.c +@@ -20,7 +20,7 @@ + # define __NR_bpf 357 + # elif defined(__x86_64__) + # define __NR_bpf 321 +-# elif defined(__aarch64__) ++# elif defined(__aarch64__) || defined(__loongarch64) + # define __NR_bpf 280 + # else + # error __NR_bpf not defined. +diff --git a/stapdyn/mutatee.cxx b/stapdyn/mutatee.cxx +index c357b17..5438ee4 100644 +--- a/stapdyn/mutatee.cxx ++++ b/stapdyn/mutatee.cxx +@@ -62,6 +62,15 @@ get_dwarf_registers(BPatch_process *app, + "r20", "r21", "r22", "r23", + "r24", "r25", "r26", "r27", + "r28", "r29", "r30", "r31", ++#elif defined(__loongarch64) ++ "r0", "r1", "r2", "r3", ++ "r4", "r5", "r6", "r7", ++ "r8", "r9", "r10", "r11", ++ "r12", "r13", "r14", "r15", ++ "r16", "r17", "r18", "r19", ++ "r20", "r21", "r22", "r23", ++ "r24", "r25", "r26", "r27", ++ "r28", "r29", "r30", "r31", + #endif + NULL }; + +diff --git a/tapset/errno.stp b/tapset/errno.stp +index a75e3ba..d7c93f5 100644 +--- a/tapset/errno.stp ++++ b/tapset/errno.stp +@@ -392,6 +392,8 @@ static long _stp_returnval(struct pt_regs *regs) { + return regs->ARM_r0; + #elif defined (__mips__) + return regs->regs2; ++#elif defined (__loongarch64) ++ return regs->regs4; + #else + _stp_error("returnval() not defined for this architecture"); + return 0; +diff --git a/tapset/linux/aux_syscalls.stp b/tapset/linux/aux_syscalls.stp +index af6b0ae..6193f76 100644 +--- a/tapset/linux/aux_syscalls.stp ++++ b/tapset/linux/aux_syscalls.stp +@@ -3568,7 +3568,7 @@ static void _stp_sigaction_str(struct sigaction *act, char *ptr, int len) + strlcat (ptr, ", ", len); + _stp_lookup_or_str(_stp_sa_flags_list, act->sa_flags, ptr, len); + strlcat (ptr, ", ", len); +-#if !defined (__ia64__) && !defined (__mips__) && !defined(__riscv) ++#if !defined (__ia64__) && !defined (__mips__) && !defined(__riscv) && !defined (__loongarch64) + slen = strlen(ptr); + _stp_snprintf(ptr + slen, len - slen, + "0x%lx, ", (long)act->sa_restorer); +@@ -4129,6 +4129,9 @@ function _swapon_flags_str:string(flags:long) + #elif defined(__aarch64__) + long pstate = kread(®s->pstate); + STAP_RETVALUE = ((pstate & PSR_MODE_MASK) == PSR_MODE_EL0t); ++#elif defined(__loongarch64) ++ long csr_prmd = kread(®s->csr_prmd); ++ STAP_RETVALUE = ((csr_prmd & PLV_MASK) == PLV_USER); + #else + #error "Unimplemented architecture" + #endif +diff --git a/tapset/linux/loongarch64/aux_syscalls.stp b/tapset/linux/loongarch64/aux_syscalls.stp +new file mode 100644 +index 0000000..d7f2edd +--- /dev/null ++++ b/tapset/linux/loongarch64/aux_syscalls.stp +@@ -0,0 +1,12 @@ ++# arch-specific requests of ptrace ___________________________ ++# ++ ++function _arch_ptrace_argstr(request, pid, addr, data) ++{ ++ return("") ++} ++ ++function _ptrace_return_arch_prctl_addr:long(request:long, addr:long, data:long) ++{ ++ return 0 ++} +\ No newline at end of file +diff --git a/tapset/linux/loongarch64/registers.stp b/tapset/linux/loongarch64/registers.stp +new file mode 100644 +index 0000000..b2523f4 +--- /dev/null ++++ b/tapset/linux/loongarch64/registers.stp +@@ -0,0 +1,293 @@ ++/* Dwarfless register access for LOONGARCH */ ++ ++global _reg_offsets, _stp_regs_registered ++ ++function _stp_register_regs() { ++ offset_acx = 0 ++ /* Same order as struct pt_regs */ ++ _reg_offsets"$zero" = 0 ++ _reg_offsets"$ra" = 8 ++ _reg_offsets"$tp" = 16 ++ _reg_offsets"$sp" = 24 ++ _reg_offsets"$a0" = 32 ++ _reg_offsets"$a1" = 40 ++ _reg_offsets"$a2" = 48 ++ _reg_offsets"$a3" = 56 ++ _reg_offsets"$a4" = 64 ++ _reg_offsets"$a5" = 72 ++ _reg_offsets"$a6" = 80 ++ _reg_offsets"$a7" = 88 ++ _reg_offsets"$t0" = 96 ++ _reg_offsets"$t1" = 104 ++ _reg_offsets"$t2" = 112 ++ _reg_offsets"$t3" = 120 ++ _reg_offsets"$t4" = 128 ++ _reg_offsets"$t5" = 136 ++ _reg_offsets"$t6" = 144 ++ _reg_offsets"$t7" = 152 ++ _reg_offsets"$t8" = 160 ++ _reg_offsets"$x" = 168 ++ _reg_offsets"$fp" = 176 ++ _reg_offsets"$s0" = 184 ++ _reg_offsets"$s1" = 192 ++ _reg_offsets"$s2" = 200 ++ _reg_offsets"$s3" = 208 ++ _reg_offsets"$s4" = 216 ++ _reg_offsets"$s5" = 224 ++ _reg_offsets"$s6" = 232 ++ _reg_offsets"$s7" = 240 ++ _reg_offsets"$s8" = 248 ++ ++/* ignore special registers */ ++ ++ _stp_regs_registered = 1 ++} ++ ++function _stp_get_register_by_offset:long (offset:long) %{ /* pure */ ++ long value; ++ struct pt_regs *regs; ++ regs = (CONTEXT->user_mode_p ? CONTEXT->uregs : CONTEXT->kregs); ++ ++ if (!regs) { ++ CONTEXT->last_error = "No registers available in this context"; ++ return; ++ } ++ if (STAP_ARG_offset < 0 || STAP_ARG_offset > sizeof(struct pt_regs) - sizeof(long)) { ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "Bad register offset: %lld", STAP_ARG_offset); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ memcpy(&value, ((char *)regs) + STAP_ARG_offset, sizeof(value)); ++ STAP_RETVALUE = value; ++%} ++ ++function _stp_sign_extend32:long (value:long) { ++ if (value & 0x80000000) ++ value |= (0xffffffff << 32) ++ return value ++} ++ ++function _stp_register:long (name:string, sign_extend:long) { ++ if (!registers_valid()) { ++ error("cannot access CPU registers in this context") ++ return 0 ++ } ++ if (!_stp_regs_registered) ++ _stp_register_regs() ++ offset = _reg_offsetsname ++ if (offset == 0 && !(name in _reg_offsets)) { ++ error("Unknown register: " . name) ++ return 0 ++ } ++ value = _stp_get_register_by_offset(offset) ++ return value ++} ++ ++/* Return the named register value as a signed value. */ ++function register:long (name:string) { ++ return _stp_register(name, 1) ++} ++ ++/* ++ * Return the named register value as an unsigned value. Specifically, ++ * don't sign-extend the register value when promoting it to 64 bits. ++ */ ++function u_register:long (name:string) { ++ return _stp_register(name, 0) ++} ++ ++ ++/* Dwarfless register access for loongarch */ ++ ++%{ ++// These functions are largely lifted from arch/loongarch/include/asm/ptrace.h. ++ ++static inline unsigned long _stp_kernel_stack_pointer(struct pt_regs *regs) ++{ ++ return regs->regs3; ++} ++ ++/** ++ * _stp_regs_within_kernel_stack() - check the address in the stack ++ * @regs: pt_regs which contains kernel stack pointer. ++ * @addr: address which is checked. ++ * ++ * _stp_regs_within_kernel_stack() checks @addr is within the kernel stack page(s). ++ * If @addr is within the kernel stack, it returns true. If not, returns false. ++ */ ++static inline int _stp_regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr) ++{ ++ return ((addr & ~(THREAD_SIZE - 1)) == ++ (_stp_kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1))); ++} ++ ++/* ++ * _stp_regs_get_kernel_stack_nth_addr() - get address of the Nth entry of the stack ++ * @regs: pt_regs which contains kernel stack pointer. ++ * @n: stack entry number. ++ * ++ * _stp_regs_get_kernel_stack_nth_addr() returns the address of the @n ++ * th entry of the kernel stack which is specified by @regs. If the @n ++ * th entry is NOT in the kernel stack, this returns 0. ++ */ ++long * ++_stp_regs_get_kernel_stack_nth_addr(struct pt_regs *regs, unsigned int n) ++{ ++ long *addr = (unsigned long *)_stp_kernel_stack_pointer(regs); ++ addr += n; ++ if (_stp_regs_within_kernel_stack(regs, (unsigned long)addr)) ++ return addr; ++ else ++ return 0; ++} ++ ++%} ++ ++function _stp_get_stack_nth:long (n:long) ++%{ /* pure */ ++ __label__ deref_fault; ++ unsigned int n = (unsigned int)STAP_ARG_n; ++ struct pt_regs *regs; ++ long *addr; ++ ++ STAP_RETVALUE = 0; ++ if (CONTEXT->user_mode_p) { ++ // This function only handles kernel arguments off the stack. ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "cannot access function args in this context"); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ regs = CONTEXT->kregs; ++ if (!regs) { ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "cannot access function args in this context"); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ ++ /* Get the address of the nth item on the stack. */ ++ addr = _stp_regs_get_kernel_stack_nth_addr(regs, n); ++ if (addr == NULL) { ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "cannot access stack arg(%d)", n); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ STAP_RETVALUE = kread(addr); ++ return; ++ ++deref_fault: /* branched to from kread() */ ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "kernel fault at %#lx accessing stack arg(%d)", ++ (unsigned long)addr, n); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++%} ++ ++/* ++ * Return the value of function arg #argnum (1=first arg). ++ * If truncate=1, mask off the top 32 bits. ++ * If sign_extend=1 and (truncate=1 or the probepoint we've hit is in a ++ * 32-bit app), sign-extend the 32-bit value. ++ */ ++function _stp_arg:long (argnum:long, sign_extend:long, truncate:long) { ++ val = 0 ++ if (argnum < 1 || argnum > 8) { ++ error(sprintf("Cannot access arg(%d)", argnum)) ++ return 0 ++ } ++ ++ if (argnum == 1) ++ val = u_register("$a0") ++ else if (argnum == 2) ++ val = u_register("$a1") ++ else if (argnum == 3) ++ val = u_register("$a2") ++ else if (argnum == 4) ++ val = u_register("$a3") ++ else if (argnum == 5) ++ val = u_register("$a4") ++ else if (argnum == 6) ++ val = u_register("$a5") ++ else if (argnum == 7) ++ val = u_register("$a6") ++ else if (argnum == 8) ++ val = u_register("$a7") ++ else ++ val = _stp_get_stack_nth(argnum - 5) ++ ++ if (truncate) { ++ if (sign_extend) ++ val = _stp_sign_extend32(val) ++ else ++ /* High bits may be garbage. */ ++ val = (val & 0xffffffff); ++ } ++ return val; ++} ++ ++function arch_bytes:long() %{ /* pure */ ++ STAP_RETVALUE = sizeof(long); ++%} ++ ++function uarch_bytes:long() { ++ assert(user_mode(), "requires user mode") ++ return probing_32bit_app() ? 4 : 8 ++} ++ ++/* Return the value of function arg #argnum (1=first arg) as a signed int. */ ++function int_arg:long (argnum:long) { ++ return _stp_arg(argnum, 1, 1) ++} ++ ++/* Return the value of function arg #argnum (1=first arg) as an unsigned int. */ ++function uint_arg:long (argnum:long) { ++ return _stp_arg(argnum, 0, 1) ++} ++ ++function long_arg:long (argnum:long) { ++ return _stp_arg(argnum, 1, 0) ++} ++ ++function ulong_arg:long (argnum:long) { ++ return _stp_arg(argnum, 0, 0) ++} ++ ++function longlong_arg:long (argnum:long) { ++ return _stp_arg(argnum, 0, 0) ++} ++ ++function ulonglong_arg:long (argnum:long) { ++ return longlong_arg(argnum) ++} ++ ++function pointer_arg:long (argnum:long) { ++ return _stp_arg(argnum, 0, 0) ++} ++ ++function s32_arg:long (argnum:long) { ++ return int_arg(argnum) ++} ++ ++function u32_arg:long (argnum:long) { ++ return uint_arg(argnum) ++} ++ ++function s64_arg:long (argnum:long) { ++ return longlong_arg(argnum) ++} ++ ++function u64_arg:long (argnum:long) { ++ return ulonglong_arg(argnum) ++} ++ ++function asmlinkage() %{ /* pure */ %} ++ ++function fastcall() %{ /* pure */ %} ++ ++function regparm() %{ ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "regparm is invalid on mips."); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++%} +\ No newline at end of file +diff --git a/tapset/linux/loongarch64/syscall_num.stp b/tapset/linux/loongarch64/syscall_num.stp +new file mode 100644 +index 0000000..284f6ba +--- /dev/null ++++ b/tapset/linux/loongarch64/syscall_num.stp +@@ -0,0 +1,1283 @@ ++# This is arch specific syscall table generated by scripts/dump-syscalls.sh ++ ++%( arch =="loongarch64" %? ++global __syscall_64_num2name636 ++global __syscall_64_name2num636 ++%) ++ ++probe init { ++%( arch =="loongarch64" %? ++__syscall_64_num2name202="accept" ++__syscall_64_num2name202="accept" ++__syscall_64_name2num"accept"=202 ++__syscall_64_name2num"accept"=202 ++__syscall_64_num2name242="accept4" ++__syscall_64_num2name242="accept4" ++__syscall_64_name2num"accept4"=242 ++__syscall_64_name2num"accept4"=242 ++__syscall_64_num2name89="acct" ++__syscall_64_num2name89="acct" ++__syscall_64_name2num"acct"=89 ++__syscall_64_name2num"acct"=89 ++__syscall_64_num2name217="add_key" ++__syscall_64_num2name217="add_key" ++__syscall_64_name2num"add_key"=217 ++__syscall_64_name2num"add_key"=217 ++__syscall_64_num2name171="adjtimex" ++__syscall_64_num2name171="adjtimex" ++__syscall_64_name2num"adjtimex"=171 ++__syscall_64_name2num"adjtimex"=171 ++__syscall_64_num2name200="bind" ++__syscall_64_num2name200="bind" ++__syscall_64_name2num"bind"=200 ++__syscall_64_name2num"bind"=200 ++__syscall_64_num2name280="bpf" ++__syscall_64_num2name280="bpf" ++__syscall_64_name2num"bpf"=280 ++__syscall_64_name2num"bpf"=280 ++__syscall_64_num2name214="brk" ++__syscall_64_num2name214="brk" ++__syscall_64_name2num"brk"=214 ++__syscall_64_name2num"brk"=214 ++__syscall_64_num2name0+451="cachestat" ++__syscall_64_num2name0+451="cachestat" ++__syscall_64_name2num"cachestat"=0+451 ++__syscall_64_name2num"cachestat"=0+451 ++__syscall_64_num2name90="capget" ++__syscall_64_num2name90="capget" ++__syscall_64_name2num"capget"=90 ++__syscall_64_name2num"capget"=90 ++__syscall_64_num2name91="capset" ++__syscall_64_num2name91="capset" ++__syscall_64_name2num"capset"=91 ++__syscall_64_name2num"capset"=91 ++__syscall_64_num2name49="chdir" ++__syscall_64_num2name49="chdir" ++__syscall_64_name2num"chdir"=49 ++__syscall_64_name2num"chdir"=49 ++__syscall_64_num2name51="chroot" ++__syscall_64_num2name51="chroot" ++__syscall_64_name2num"chroot"=51 ++__syscall_64_name2num"chroot"=51 ++__syscall_64_num2name266="clock_adjtime" ++__syscall_64_num2name266="clock_adjtime" ++__syscall_64_name2num"clock_adjtime"=266 ++__syscall_64_name2num"clock_adjtime"=266 ++__syscall_64_num2name114="clock_getres" ++__syscall_64_num2name114="clock_getres" ++__syscall_64_name2num"clock_getres"=114 ++__syscall_64_name2num"clock_getres"=114 ++__syscall_64_num2name113="clock_gettime" ++__syscall_64_num2name113="clock_gettime" ++__syscall_64_name2num"clock_gettime"=113 ++__syscall_64_name2num"clock_gettime"=113 ++__syscall_64_num2name115="clock_nanosleep" ++__syscall_64_num2name115="clock_nanosleep" ++__syscall_64_name2num"clock_nanosleep"=115 ++__syscall_64_name2num"clock_nanosleep"=115 ++__syscall_64_num2name112="clock_settime" ++__syscall_64_num2name112="clock_settime" ++__syscall_64_name2num"clock_settime"=112 ++__syscall_64_name2num"clock_settime"=112 ++__syscall_64_num2name220="clone" ++__syscall_64_num2name220="clone" ++__syscall_64_name2num"clone"=220 ++__syscall_64_name2num"clone"=220 ++__syscall_64_num2name0+435="clone3" ++__syscall_64_num2name0+435="clone3" ++__syscall_64_name2num"clone3"=0+435 ++__syscall_64_name2num"clone3"=0+435 ++__syscall_64_num2name57="close" ++__syscall_64_num2name57="close" ++__syscall_64_name2num"close"=57 ++__syscall_64_name2num"close"=57 ++__syscall_64_num2name0+436="close_range" ++__syscall_64_num2name0+436="close_range" ++__syscall_64_name2num"close_range"=0+436 ++__syscall_64_name2num"close_range"=0+436 ++__syscall_64_num2name203="connect" ++__syscall_64_num2name203="connect" ++__syscall_64_name2num"connect"=203 ++__syscall_64_name2num"connect"=203 ++__syscall_64_num2name285="copy_file_range" ++__syscall_64_num2name285="copy_file_range" ++__syscall_64_name2num"copy_file_range"=285 ++__syscall_64_name2num"copy_file_range"=285 ++__syscall_64_num2name106="delete_module" ++__syscall_64_num2name106="delete_module" ++__syscall_64_name2num"delete_module"=106 ++__syscall_64_name2num"delete_module"=106 ++__syscall_64_num2name23="dup" ++__syscall_64_num2name23="dup" ++__syscall_64_name2num"dup"=23 ++__syscall_64_name2num"dup"=23 ++__syscall_64_num2name24="dup3" ++__syscall_64_num2name24="dup3" ++__syscall_64_name2num"dup3"=24 ++__syscall_64_name2num"dup3"=24 ++__syscall_64_num2name20="epoll_create1" ++__syscall_64_num2name20="epoll_create1" ++__syscall_64_name2num"epoll_create1"=20 ++__syscall_64_name2num"epoll_create1"=20 ++__syscall_64_num2name21="epoll_ctl" ++__syscall_64_num2name21="epoll_ctl" ++__syscall_64_name2num"epoll_ctl"=21 ++__syscall_64_name2num"epoll_ctl"=21 ++__syscall_64_num2name22="epoll_pwait" ++__syscall_64_num2name22="epoll_pwait" ++__syscall_64_num2name0+441="epoll_pwait2" ++__syscall_64_num2name0+441="epoll_pwait2" ++__syscall_64_name2num"epoll_pwait2"=0+441 ++__syscall_64_name2num"epoll_pwait2"=0+441 ++__syscall_64_name2num"epoll_pwait"=22 ++__syscall_64_name2num"epoll_pwait"=22 ++__syscall_64_num2name19="eventfd2" ++__syscall_64_num2name19="eventfd2" ++__syscall_64_name2num"eventfd2"=19 ++__syscall_64_name2num"eventfd2"=19 ++__syscall_64_num2name221="execve" ++__syscall_64_num2name221="execve" ++__syscall_64_name2num"execve"=221 ++__syscall_64_name2num"execve"=221 ++__syscall_64_num2name281="execveat" ++__syscall_64_num2name281="execveat" ++__syscall_64_name2num"execveat"=281 ++__syscall_64_name2num"execveat"=281 ++__syscall_64_num2name93="exit" ++__syscall_64_num2name93="exit" ++__syscall_64_name2num"exit"=93 ++__syscall_64_name2num"exit"=93 ++__syscall_64_num2name94="exit_group" ++__syscall_64_num2name94="exit_group" ++__syscall_64_name2num"exit_group"=94 ++__syscall_64_name2num"exit_group"=94 ++__syscall_64_num2name48="faccessat" ++__syscall_64_num2name48="faccessat" ++__syscall_64_num2name0+439="faccessat2" ++__syscall_64_num2name0+439="faccessat2" ++__syscall_64_name2num"faccessat2"=0+439 ++__syscall_64_name2num"faccessat2"=0+439 ++__syscall_64_name2num"faccessat"=48 ++__syscall_64_name2num"faccessat"=48 ++__syscall_64_num2name223="fadvise64" ++__syscall_64_num2name223="fadvise64" ++__syscall_64_name2num"fadvise64"=223 ++__syscall_64_name2num"fadvise64"=223 ++__syscall_64_num2name47="fallocate" ++__syscall_64_num2name47="fallocate" ++__syscall_64_name2num"fallocate"=47 ++__syscall_64_name2num"fallocate"=47 ++__syscall_64_num2name262="fanotify_init" ++__syscall_64_num2name262="fanotify_init" ++__syscall_64_name2num"fanotify_init"=262 ++__syscall_64_name2num"fanotify_init"=262 ++__syscall_64_num2name263="fanotify_mark" ++__syscall_64_num2name263="fanotify_mark" ++__syscall_64_name2num"fanotify_mark"=263 ++__syscall_64_name2num"fanotify_mark"=263 ++__syscall_64_num2name50="fchdir" ++__syscall_64_num2name50="fchdir" ++__syscall_64_name2num"fchdir"=50 ++__syscall_64_name2num"fchdir"=50 ++__syscall_64_num2name52="fchmod" ++__syscall_64_num2name52="fchmod" ++__syscall_64_name2num"fchmod"=52 ++__syscall_64_name2num"fchmod"=52 ++__syscall_64_num2name53="fchmodat" ++__syscall_64_num2name53="fchmodat" ++__syscall_64_num2name0+452="fchmodat2" ++__syscall_64_num2name0+452="fchmodat2" ++__syscall_64_name2num"fchmodat2"=0+452 ++__syscall_64_name2num"fchmodat2"=0+452 ++__syscall_64_name2num"fchmodat"=53 ++__syscall_64_name2num"fchmodat"=53 ++__syscall_64_num2name55="fchown" ++__syscall_64_num2name55="fchown" ++__syscall_64_name2num"fchown"=55 ++__syscall_64_name2num"fchown"=55 ++__syscall_64_num2name54="fchownat" ++__syscall_64_num2name54="fchownat" ++__syscall_64_name2num"fchownat"=54 ++__syscall_64_name2num"fchownat"=54 ++__syscall_64_num2name25="fcntl" ++__syscall_64_num2name25="fcntl" ++__syscall_64_name2num"fcntl"=25 ++__syscall_64_name2num"fcntl"=25 ++__syscall_64_num2name83="fdatasync" ++__syscall_64_num2name83="fdatasync" ++__syscall_64_name2num"fdatasync"=83 ++__syscall_64_name2num"fdatasync"=83 ++__syscall_64_num2name10="fgetxattr" ++__syscall_64_num2name10="fgetxattr" ++__syscall_64_name2num"fgetxattr"=10 ++__syscall_64_name2num"fgetxattr"=10 ++__syscall_64_num2name273="finit_module" ++__syscall_64_num2name273="finit_module" ++__syscall_64_name2num"finit_module"=273 ++__syscall_64_name2num"finit_module"=273 ++__syscall_64_num2name13="flistxattr" ++__syscall_64_num2name13="flistxattr" ++__syscall_64_name2num"flistxattr"=13 ++__syscall_64_name2num"flistxattr"=13 ++__syscall_64_num2name32="flock" ++__syscall_64_num2name32="flock" ++__syscall_64_name2num"flock"=32 ++__syscall_64_name2num"flock"=32 ++__syscall_64_num2name16="fremovexattr" ++__syscall_64_num2name16="fremovexattr" ++__syscall_64_name2num"fremovexattr"=16 ++__syscall_64_name2num"fremovexattr"=16 ++__syscall_64_num2name0+431="fsconfig" ++__syscall_64_num2name0+431="fsconfig" ++__syscall_64_name2num"fsconfig"=0+431 ++__syscall_64_name2num"fsconfig"=0+431 ++__syscall_64_num2name7="fsetxattr" ++__syscall_64_num2name7="fsetxattr" ++__syscall_64_name2num"fsetxattr"=7 ++__syscall_64_name2num"fsetxattr"=7 ++__syscall_64_num2name0+432="fsmount" ++__syscall_64_num2name0+432="fsmount" ++__syscall_64_name2num"fsmount"=0+432 ++__syscall_64_name2num"fsmount"=0+432 ++__syscall_64_num2name0+430="fsopen" ++__syscall_64_num2name0+430="fsopen" ++__syscall_64_name2num"fsopen"=0+430 ++__syscall_64_name2num"fsopen"=0+430 ++__syscall_64_num2name0+433="fspick" ++__syscall_64_num2name0+433="fspick" ++__syscall_64_name2num"fspick"=0+433 ++__syscall_64_name2num"fspick"=0+433 ++__syscall_64_num2name80="fstat" ++__syscall_64_num2name80="fstat" ++__syscall_64_name2num"fstat"=80 ++__syscall_64_name2num"fstat"=80 ++__syscall_64_num2name44="fstatfs" ++__syscall_64_num2name44="fstatfs" ++__syscall_64_name2num"fstatfs"=44 ++__syscall_64_name2num"fstatfs"=44 ++__syscall_64_num2name82="fsync" ++__syscall_64_num2name82="fsync" ++__syscall_64_name2num"fsync"=82 ++__syscall_64_name2num"fsync"=82 ++__syscall_64_num2name46="ftruncate" ++__syscall_64_num2name46="ftruncate" ++__syscall_64_name2num"ftruncate"=46 ++__syscall_64_name2num"ftruncate"=46 ++__syscall_64_num2name98="futex" ++__syscall_64_num2name98="futex" ++__syscall_64_name2num"futex"=98 ++__syscall_64_name2num"futex"=98 ++__syscall_64_num2name0+456="futex_requeue" ++__syscall_64_num2name0+456="futex_requeue" ++__syscall_64_name2num"futex_requeue"=0+456 ++__syscall_64_name2num"futex_requeue"=0+456 ++__syscall_64_num2name0+455="futex_wait" ++__syscall_64_num2name0+455="futex_wait" ++__syscall_64_name2num"futex_wait"=0+455 ++__syscall_64_name2num"futex_wait"=0+455 ++__syscall_64_num2name0+449="futex_waitv" ++__syscall_64_num2name0+449="futex_waitv" ++__syscall_64_name2num"futex_waitv"=0+449 ++__syscall_64_name2num"futex_waitv"=0+449 ++__syscall_64_num2name0+454="futex_wake" ++__syscall_64_num2name0+454="futex_wake" ++__syscall_64_name2num"futex_wake"=0+454 ++__syscall_64_name2num"futex_wake"=0+454 ++__syscall_64_num2name168="getcpu" ++__syscall_64_num2name168="getcpu" ++__syscall_64_name2num"getcpu"=168 ++__syscall_64_name2num"getcpu"=168 ++__syscall_64_num2name17="getcwd" ++__syscall_64_num2name17="getcwd" ++__syscall_64_name2num"getcwd"=17 ++__syscall_64_name2num"getcwd"=17 ++__syscall_64_num2name61="getdents64" ++__syscall_64_num2name61="getdents64" ++__syscall_64_name2num"getdents64"=61 ++__syscall_64_name2num"getdents64"=61 ++__syscall_64_num2name177="getegid" ++__syscall_64_num2name177="getegid" ++__syscall_64_name2num"getegid"=177 ++__syscall_64_name2num"getegid"=177 ++__syscall_64_num2name175="geteuid" ++__syscall_64_num2name175="geteuid" ++__syscall_64_name2num"geteuid"=175 ++__syscall_64_name2num"geteuid"=175 ++__syscall_64_num2name176="getgid" ++__syscall_64_num2name176="getgid" ++__syscall_64_name2num"getgid"=176 ++__syscall_64_name2num"getgid"=176 ++__syscall_64_num2name158="getgroups" ++__syscall_64_num2name158="getgroups" ++__syscall_64_name2num"getgroups"=158 ++__syscall_64_name2num"getgroups"=158 ++__syscall_64_num2name102="getitimer" ++__syscall_64_num2name102="getitimer" ++__syscall_64_name2num"getitimer"=102 ++__syscall_64_name2num"getitimer"=102 ++__syscall_64_num2name236="get_mempolicy" ++__syscall_64_num2name236="get_mempolicy" ++__syscall_64_name2num"get_mempolicy"=236 ++__syscall_64_name2num"get_mempolicy"=236 ++__syscall_64_num2name205="getpeername" ++__syscall_64_num2name205="getpeername" ++__syscall_64_name2num"getpeername"=205 ++__syscall_64_name2num"getpeername"=205 ++__syscall_64_num2name155="getpgid" ++__syscall_64_num2name155="getpgid" ++__syscall_64_name2num"getpgid"=155 ++__syscall_64_name2num"getpgid"=155 ++__syscall_64_num2name172="getpid" ++__syscall_64_num2name172="getpid" ++__syscall_64_name2num"getpid"=172 ++__syscall_64_name2num"getpid"=172 ++__syscall_64_num2name173="getppid" ++__syscall_64_num2name173="getppid" ++__syscall_64_name2num"getppid"=173 ++__syscall_64_name2num"getppid"=173 ++__syscall_64_num2name141="getpriority" ++__syscall_64_num2name141="getpriority" ++__syscall_64_name2num"getpriority"=141 ++__syscall_64_name2num"getpriority"=141 ++__syscall_64_num2name278="getrandom" ++__syscall_64_num2name278="getrandom" ++__syscall_64_name2num"getrandom"=278 ++__syscall_64_name2num"getrandom"=278 ++__syscall_64_num2name150="getresgid" ++__syscall_64_num2name150="getresgid" ++__syscall_64_name2num"getresgid"=150 ++__syscall_64_name2num"getresgid"=150 ++__syscall_64_num2name148="getresuid" ++__syscall_64_num2name148="getresuid" ++__syscall_64_name2num"getresuid"=148 ++__syscall_64_name2num"getresuid"=148 ++__syscall_64_num2name163="getrlimit" ++__syscall_64_num2name163="getrlimit" ++__syscall_64_name2num"getrlimit"=163 ++__syscall_64_name2num"getrlimit"=163 ++__syscall_64_num2name100="get_robust_list" ++__syscall_64_num2name100="get_robust_list" ++__syscall_64_name2num"get_robust_list"=100 ++__syscall_64_name2num"get_robust_list"=100 ++__syscall_64_num2name165="getrusage" ++__syscall_64_num2name165="getrusage" ++__syscall_64_name2num"getrusage"=165 ++__syscall_64_name2num"getrusage"=165 ++__syscall_64_num2name156="getsid" ++__syscall_64_num2name156="getsid" ++__syscall_64_name2num"getsid"=156 ++__syscall_64_name2num"getsid"=156 ++__syscall_64_num2name204="getsockname" ++__syscall_64_num2name204="getsockname" ++__syscall_64_name2num"getsockname"=204 ++__syscall_64_name2num"getsockname"=204 ++__syscall_64_num2name209="getsockopt" ++__syscall_64_num2name209="getsockopt" ++__syscall_64_name2num"getsockopt"=209 ++__syscall_64_name2num"getsockopt"=209 ++__syscall_64_num2name178="gettid" ++__syscall_64_num2name178="gettid" ++__syscall_64_name2num"gettid"=178 ++__syscall_64_name2num"gettid"=178 ++__syscall_64_num2name169="gettimeofday" ++__syscall_64_num2name169="gettimeofday" ++__syscall_64_name2num"gettimeofday"=169 ++__syscall_64_name2num"gettimeofday"=169 ++__syscall_64_num2name174="getuid" ++__syscall_64_num2name174="getuid" ++__syscall_64_name2num"getuid"=174 ++__syscall_64_name2num"getuid"=174 ++__syscall_64_num2name8="getxattr" ++__syscall_64_num2name8="getxattr" ++__syscall_64_name2num"getxattr"=8 ++__syscall_64_name2num"getxattr"=8 ++__syscall_64_num2name105="init_module" ++__syscall_64_num2name105="init_module" ++__syscall_64_name2num"init_module"=105 ++__syscall_64_name2num"init_module"=105 ++__syscall_64_num2name27="inotify_add_watch" ++__syscall_64_num2name27="inotify_add_watch" ++__syscall_64_name2num"inotify_add_watch"=27 ++__syscall_64_name2num"inotify_add_watch"=27 ++__syscall_64_num2name26="inotify_init1" ++__syscall_64_num2name26="inotify_init1" ++__syscall_64_name2num"inotify_init1"=26 ++__syscall_64_name2num"inotify_init1"=26 ++__syscall_64_num2name28="inotify_rm_watch" ++__syscall_64_num2name28="inotify_rm_watch" ++__syscall_64_name2num"inotify_rm_watch"=28 ++__syscall_64_name2num"inotify_rm_watch"=28 ++__syscall_64_num2name3="io_cancel" ++__syscall_64_num2name3="io_cancel" ++__syscall_64_name2num"io_cancel"=3 ++__syscall_64_name2num"io_cancel"=3 ++__syscall_64_num2name29="ioctl" ++__syscall_64_num2name29="ioctl" ++__syscall_64_name2num"ioctl"=29 ++__syscall_64_name2num"ioctl"=29 ++__syscall_64_num2name1="io_destroy" ++__syscall_64_num2name1="io_destroy" ++__syscall_64_name2num"io_destroy"=1 ++__syscall_64_name2num"io_destroy"=1 ++__syscall_64_num2name4="io_getevents" ++__syscall_64_num2name4="io_getevents" ++__syscall_64_name2num"io_getevents"=4 ++__syscall_64_name2num"io_getevents"=4 ++__syscall_64_num2name292="io_pgetevents" ++__syscall_64_num2name292="io_pgetevents" ++__syscall_64_name2num"io_pgetevents"=292 ++__syscall_64_name2num"io_pgetevents"=292 ++__syscall_64_num2name31="ioprio_get" ++__syscall_64_num2name31="ioprio_get" ++__syscall_64_name2num"ioprio_get"=31 ++__syscall_64_name2num"ioprio_get"=31 ++__syscall_64_num2name30="ioprio_set" ++__syscall_64_num2name30="ioprio_set" ++__syscall_64_name2num"ioprio_set"=30 ++__syscall_64_name2num"ioprio_set"=30 ++__syscall_64_num2name0="io_setup" ++__syscall_64_num2name0="io_setup" ++__syscall_64_name2num"io_setup"=0 ++__syscall_64_name2num"io_setup"=0 ++__syscall_64_num2name2="io_submit" ++__syscall_64_num2name2="io_submit" ++__syscall_64_name2num"io_submit"=2 ++__syscall_64_name2num"io_submit"=2 ++__syscall_64_num2name0+426="io_uring_enter" ++__syscall_64_num2name0+426="io_uring_enter" ++__syscall_64_name2num"io_uring_enter"=0+426 ++__syscall_64_name2num"io_uring_enter"=0+426 ++__syscall_64_num2name0+427="io_uring_register" ++__syscall_64_num2name0+427="io_uring_register" ++__syscall_64_name2num"io_uring_register"=0+427 ++__syscall_64_name2num"io_uring_register"=0+427 ++__syscall_64_num2name0+425="io_uring_setup" ++__syscall_64_num2name0+425="io_uring_setup" ++__syscall_64_name2num"io_uring_setup"=0+425 ++__syscall_64_name2num"io_uring_setup"=0+425 ++__syscall_64_num2name272="kcmp" ++__syscall_64_num2name272="kcmp" ++__syscall_64_name2num"kcmp"=272 ++__syscall_64_name2num"kcmp"=272 ++__syscall_64_num2name294="kexec_file_load" ++__syscall_64_num2name294="kexec_file_load" ++__syscall_64_name2num"kexec_file_load"=294 ++__syscall_64_name2num"kexec_file_load"=294 ++__syscall_64_num2name104="kexec_load" ++__syscall_64_num2name104="kexec_load" ++__syscall_64_name2num"kexec_load"=104 ++__syscall_64_name2num"kexec_load"=104 ++__syscall_64_num2name219="keyctl" ++__syscall_64_num2name219="keyctl" ++__syscall_64_name2num"keyctl"=219 ++__syscall_64_name2num"keyctl"=219 ++__syscall_64_num2name129="kill" ++__syscall_64_num2name129="kill" ++__syscall_64_name2num"kill"=129 ++__syscall_64_name2num"kill"=129 ++__syscall_64_num2name0+445="landlock_add_rule" ++__syscall_64_num2name0+445="landlock_add_rule" ++__syscall_64_name2num"landlock_add_rule"=0+445 ++__syscall_64_name2num"landlock_add_rule"=0+445 ++__syscall_64_num2name0+444="landlock_create_ruleset" ++__syscall_64_num2name0+444="landlock_create_ruleset" ++__syscall_64_name2num"landlock_create_ruleset"=0+444 ++__syscall_64_name2num"landlock_create_ruleset"=0+444 ++__syscall_64_num2name0+446="landlock_restrict_self" ++__syscall_64_num2name0+446="landlock_restrict_self" ++__syscall_64_name2num"landlock_restrict_self"=0+446 ++__syscall_64_name2num"landlock_restrict_self"=0+446 ++__syscall_64_num2name9="lgetxattr" ++__syscall_64_num2name9="lgetxattr" ++__syscall_64_name2num"lgetxattr"=9 ++__syscall_64_name2num"lgetxattr"=9 ++__syscall_64_num2name37="linkat" ++__syscall_64_num2name37="linkat" ++__syscall_64_name2num"linkat"=37 ++__syscall_64_name2num"linkat"=37 ++__syscall_64_num2name201="listen" ++__syscall_64_num2name201="listen" ++__syscall_64_name2num"listen"=201 ++__syscall_64_name2num"listen"=201 ++__syscall_64_num2name0+458="listmount" ++__syscall_64_num2name0+458="listmount" ++__syscall_64_name2num"listmount"=0+458 ++__syscall_64_name2num"listmount"=0+458 ++__syscall_64_num2name11="listxattr" ++__syscall_64_num2name11="listxattr" ++__syscall_64_name2num"listxattr"=11 ++__syscall_64_name2num"listxattr"=11 ++__syscall_64_num2name12="llistxattr" ++__syscall_64_num2name12="llistxattr" ++__syscall_64_name2num"llistxattr"=12 ++__syscall_64_name2num"llistxattr"=12 ++__syscall_64_num2name18="lookup_dcookie" ++__syscall_64_num2name18="lookup_dcookie" ++__syscall_64_name2num"lookup_dcookie"=18 ++__syscall_64_name2num"lookup_dcookie"=18 ++__syscall_64_num2name15="lremovexattr" ++__syscall_64_num2name15="lremovexattr" ++__syscall_64_name2num"lremovexattr"=15 ++__syscall_64_name2num"lremovexattr"=15 ++__syscall_64_num2name62="lseek" ++__syscall_64_num2name62="lseek" ++__syscall_64_name2num"lseek"=62 ++__syscall_64_name2num"lseek"=62 ++__syscall_64_num2name6="lsetxattr" ++__syscall_64_num2name6="lsetxattr" ++__syscall_64_name2num"lsetxattr"=6 ++__syscall_64_name2num"lsetxattr"=6 ++__syscall_64_num2name0+459="lsm_get_self_attr" ++__syscall_64_num2name0+459="lsm_get_self_attr" ++__syscall_64_name2num"lsm_get_self_attr"=0+459 ++__syscall_64_name2num"lsm_get_self_attr"=0+459 ++__syscall_64_num2name0+461="lsm_list_modules" ++__syscall_64_num2name0+461="lsm_list_modules" ++__syscall_64_name2num"lsm_list_modules"=0+461 ++__syscall_64_name2num"lsm_list_modules"=0+461 ++__syscall_64_num2name0+460="lsm_set_self_attr" ++__syscall_64_num2name0+460="lsm_set_self_attr" ++__syscall_64_name2num"lsm_set_self_attr"=0+460 ++__syscall_64_name2num"lsm_set_self_attr"=0+460 ++__syscall_64_num2name233="madvise" ++__syscall_64_num2name233="madvise" ++__syscall_64_name2num"madvise"=233 ++__syscall_64_name2num"madvise"=233 ++__syscall_64_num2name0+453="map_shadow_stack" ++__syscall_64_num2name0+453="map_shadow_stack" ++__syscall_64_name2num"map_shadow_stack"=0+453 ++__syscall_64_name2num"map_shadow_stack"=0+453 ++__syscall_64_num2name235="mbind" ++__syscall_64_num2name235="mbind" ++__syscall_64_name2num"mbind"=235 ++__syscall_64_name2num"mbind"=235 ++__syscall_64_num2name283="membarrier" ++__syscall_64_num2name283="membarrier" ++__syscall_64_name2num"membarrier"=283 ++__syscall_64_name2num"membarrier"=283 ++__syscall_64_num2name279="memfd_create" ++__syscall_64_num2name279="memfd_create" ++__syscall_64_name2num"memfd_create"=279 ++__syscall_64_name2num"memfd_create"=279 ++__syscall_64_num2name0+447="memfd_secret" ++__syscall_64_num2name0+447="memfd_secret" ++__syscall_64_name2num"memfd_secret"=0+447 ++__syscall_64_name2num"memfd_secret"=0+447 ++__syscall_64_num2name238="migrate_pages" ++__syscall_64_num2name238="migrate_pages" ++__syscall_64_name2num"migrate_pages"=238 ++__syscall_64_name2num"migrate_pages"=238 ++__syscall_64_num2name232="mincore" ++__syscall_64_num2name232="mincore" ++__syscall_64_name2num"mincore"=232 ++__syscall_64_name2num"mincore"=232 ++__syscall_64_num2name34="mkdirat" ++__syscall_64_num2name34="mkdirat" ++__syscall_64_name2num"mkdirat"=34 ++__syscall_64_name2num"mkdirat"=34 ++__syscall_64_num2name33="mknodat" ++__syscall_64_num2name33="mknodat" ++__syscall_64_name2num"mknodat"=33 ++__syscall_64_name2num"mknodat"=33 ++__syscall_64_num2name228="mlock" ++__syscall_64_num2name228="mlock" ++__syscall_64_num2name284="mlock2" ++__syscall_64_num2name284="mlock2" ++__syscall_64_name2num"mlock"=228 ++__syscall_64_name2num"mlock"=228 ++__syscall_64_name2num"mlock2"=284 ++__syscall_64_name2num"mlock2"=284 ++__syscall_64_num2name230="mlockall" ++__syscall_64_num2name230="mlockall" ++__syscall_64_name2num"mlockall"=230 ++__syscall_64_name2num"mlockall"=230 ++__syscall_64_num2name222="mmap" ++__syscall_64_num2name222="mmap" ++__syscall_64_name2num"mmap"=222 ++__syscall_64_name2num"mmap"=222 ++__syscall_64_num2name40="mount" ++__syscall_64_num2name40="mount" ++__syscall_64_name2num"mount"=40 ++__syscall_64_name2num"mount"=40 ++__syscall_64_num2name0+442="mount_setattr" ++__syscall_64_num2name0+442="mount_setattr" ++__syscall_64_name2num"mount_setattr"=0+442 ++__syscall_64_name2num"mount_setattr"=0+442 ++__syscall_64_num2name0+429="move_mount" ++__syscall_64_num2name0+429="move_mount" ++__syscall_64_name2num"move_mount"=0+429 ++__syscall_64_name2num"move_mount"=0+429 ++__syscall_64_num2name239="move_pages" ++__syscall_64_num2name239="move_pages" ++__syscall_64_name2num"move_pages"=239 ++__syscall_64_name2num"move_pages"=239 ++__syscall_64_num2name226="mprotect" ++__syscall_64_num2name226="mprotect" ++__syscall_64_name2num"mprotect"=226 ++__syscall_64_name2num"mprotect"=226 ++__syscall_64_num2name185="mq_getsetattr" ++__syscall_64_num2name185="mq_getsetattr" ++__syscall_64_name2num"mq_getsetattr"=185 ++__syscall_64_name2num"mq_getsetattr"=185 ++__syscall_64_num2name184="mq_notify" ++__syscall_64_num2name184="mq_notify" ++__syscall_64_name2num"mq_notify"=184 ++__syscall_64_name2num"mq_notify"=184 ++__syscall_64_num2name180="mq_open" ++__syscall_64_num2name180="mq_open" ++__syscall_64_name2num"mq_open"=180 ++__syscall_64_name2num"mq_open"=180 ++__syscall_64_num2name183="mq_timedreceive" ++__syscall_64_num2name183="mq_timedreceive" ++__syscall_64_name2num"mq_timedreceive"=183 ++__syscall_64_name2num"mq_timedreceive"=183 ++__syscall_64_num2name182="mq_timedsend" ++__syscall_64_num2name182="mq_timedsend" ++__syscall_64_name2num"mq_timedsend"=182 ++__syscall_64_name2num"mq_timedsend"=182 ++__syscall_64_num2name181="mq_unlink" ++__syscall_64_num2name181="mq_unlink" ++__syscall_64_name2num"mq_unlink"=181 ++__syscall_64_name2num"mq_unlink"=181 ++__syscall_64_num2name216="mremap" ++__syscall_64_num2name216="mremap" ++__syscall_64_name2num"mremap"=216 ++__syscall_64_name2num"mremap"=216 ++__syscall_64_num2name0+462="mseal" ++__syscall_64_num2name0+462="mseal" ++__syscall_64_name2num"mseal"=0+462 ++__syscall_64_name2num"mseal"=0+462 ++__syscall_64_num2name187="msgctl" ++__syscall_64_num2name187="msgctl" ++__syscall_64_name2num"msgctl"=187 ++__syscall_64_name2num"msgctl"=187 ++__syscall_64_num2name186="msgget" ++__syscall_64_num2name186="msgget" ++__syscall_64_name2num"msgget"=186 ++__syscall_64_name2num"msgget"=186 ++__syscall_64_num2name188="msgrcv" ++__syscall_64_num2name188="msgrcv" ++__syscall_64_name2num"msgrcv"=188 ++__syscall_64_name2num"msgrcv"=188 ++__syscall_64_num2name189="msgsnd" ++__syscall_64_num2name189="msgsnd" ++__syscall_64_name2num"msgsnd"=189 ++__syscall_64_name2num"msgsnd"=189 ++__syscall_64_num2name227="msync" ++__syscall_64_num2name227="msync" ++__syscall_64_name2num"msync"=227 ++__syscall_64_name2num"msync"=227 ++__syscall_64_num2name229="munlock" ++__syscall_64_num2name229="munlock" ++__syscall_64_name2num"munlock"=229 ++__syscall_64_name2num"munlock"=229 ++__syscall_64_num2name231="munlockall" ++__syscall_64_num2name231="munlockall" ++__syscall_64_name2num"munlockall"=231 ++__syscall_64_name2num"munlockall"=231 ++__syscall_64_num2name215="munmap" ++__syscall_64_num2name215="munmap" ++__syscall_64_name2num"munmap"=215 ++__syscall_64_name2num"munmap"=215 ++__syscall_64_num2name264="name_to_handle_at" ++__syscall_64_num2name264="name_to_handle_at" ++__syscall_64_name2num"name_to_handle_at"=264 ++__syscall_64_name2num"name_to_handle_at"=264 ++__syscall_64_num2name101="nanosleep" ++__syscall_64_num2name101="nanosleep" ++__syscall_64_name2num"nanosleep"=101 ++__syscall_64_name2num"nanosleep"=101 ++__syscall_64_num2name79="newfstatat" ++__syscall_64_num2name79="newfstatat" ++__syscall_64_name2num"newfstatat"=79 ++__syscall_64_name2num"newfstatat"=79 ++__syscall_64_num2name42="nfsservctl" ++__syscall_64_num2name42="nfsservctl" ++__syscall_64_name2num"nfsservctl"=42 ++__syscall_64_name2num"nfsservctl"=42 ++__syscall_64_num2name56="openat" ++__syscall_64_num2name56="openat" ++__syscall_64_num2name0+437="openat2" ++__syscall_64_num2name0+437="openat2" ++__syscall_64_name2num"openat2"=0+437 ++__syscall_64_name2num"openat2"=0+437 ++__syscall_64_name2num"openat"=56 ++__syscall_64_name2num"openat"=56 ++__syscall_64_num2name265="open_by_handle_at" ++__syscall_64_num2name265="open_by_handle_at" ++__syscall_64_name2num"open_by_handle_at"=265 ++__syscall_64_name2num"open_by_handle_at"=265 ++__syscall_64_num2name0+428="open_tree" ++__syscall_64_num2name0+428="open_tree" ++__syscall_64_name2num"open_tree"=0+428 ++__syscall_64_name2num"open_tree"=0+428 ++__syscall_64_num2name241="perf_event_open" ++__syscall_64_num2name241="perf_event_open" ++__syscall_64_name2num"perf_event_open"=241 ++__syscall_64_name2num"perf_event_open"=241 ++__syscall_64_num2name92="personality" ++__syscall_64_num2name92="personality" ++__syscall_64_name2num"personality"=92 ++__syscall_64_name2num"personality"=92 ++__syscall_64_num2name0+438="pidfd_getfd" ++__syscall_64_num2name0+438="pidfd_getfd" ++__syscall_64_name2num"pidfd_getfd"=0+438 ++__syscall_64_name2num"pidfd_getfd"=0+438 ++__syscall_64_num2name0+434="pidfd_open" ++__syscall_64_num2name0+434="pidfd_open" ++__syscall_64_name2num"pidfd_open"=0+434 ++__syscall_64_name2num"pidfd_open"=0+434 ++__syscall_64_num2name0+424="pidfd_send_signal" ++__syscall_64_num2name0+424="pidfd_send_signal" ++__syscall_64_name2num"pidfd_send_signal"=0+424 ++__syscall_64_name2num"pidfd_send_signal"=0+424 ++__syscall_64_num2name59="pipe2" ++__syscall_64_num2name59="pipe2" ++__syscall_64_name2num"pipe2"=59 ++__syscall_64_name2num"pipe2"=59 ++__syscall_64_num2name41="pivot_root" ++__syscall_64_num2name41="pivot_root" ++__syscall_64_name2num"pivot_root"=41 ++__syscall_64_name2num"pivot_root"=41 ++__syscall_64_num2name289="pkey_alloc" ++__syscall_64_num2name289="pkey_alloc" ++__syscall_64_name2num"pkey_alloc"=289 ++__syscall_64_name2num"pkey_alloc"=289 ++__syscall_64_num2name290="pkey_free" ++__syscall_64_num2name290="pkey_free" ++__syscall_64_name2num"pkey_free"=290 ++__syscall_64_name2num"pkey_free"=290 ++__syscall_64_num2name288="pkey_mprotect" ++__syscall_64_num2name288="pkey_mprotect" ++__syscall_64_name2num"pkey_mprotect"=288 ++__syscall_64_name2num"pkey_mprotect"=288 ++__syscall_64_num2name73="ppoll" ++__syscall_64_num2name73="ppoll" ++__syscall_64_name2num"ppoll"=73 ++__syscall_64_name2num"ppoll"=73 ++__syscall_64_num2name167="prctl" ++__syscall_64_num2name167="prctl" ++__syscall_64_name2num"prctl"=167 ++__syscall_64_name2num"prctl"=167 ++__syscall_64_num2name67="pread64" ++__syscall_64_num2name67="pread64" ++__syscall_64_name2num"pread64"=67 ++__syscall_64_name2num"pread64"=67 ++__syscall_64_num2name69="preadv" ++__syscall_64_num2name69="preadv" ++__syscall_64_num2name286="preadv2" ++__syscall_64_num2name286="preadv2" ++__syscall_64_name2num"preadv2"=286 ++__syscall_64_name2num"preadv2"=286 ++__syscall_64_name2num"preadv"=69 ++__syscall_64_name2num"preadv"=69 ++__syscall_64_num2name261="prlimit64" ++__syscall_64_num2name261="prlimit64" ++__syscall_64_name2num"prlimit64"=261 ++__syscall_64_name2num"prlimit64"=261 ++__syscall_64_num2name0+440="process_madvise" ++__syscall_64_num2name0+440="process_madvise" ++__syscall_64_name2num"process_madvise"=0+440 ++__syscall_64_name2num"process_madvise"=0+440 ++__syscall_64_num2name0+448="process_mrelease" ++__syscall_64_num2name0+448="process_mrelease" ++__syscall_64_name2num"process_mrelease"=0+448 ++__syscall_64_name2num"process_mrelease"=0+448 ++__syscall_64_num2name270="process_vm_readv" ++__syscall_64_num2name270="process_vm_readv" ++__syscall_64_name2num"process_vm_readv"=270 ++__syscall_64_name2num"process_vm_readv"=270 ++__syscall_64_num2name271="process_vm_writev" ++__syscall_64_num2name271="process_vm_writev" ++__syscall_64_name2num"process_vm_writev"=271 ++__syscall_64_name2num"process_vm_writev"=271 ++__syscall_64_num2name72="pselect6" ++__syscall_64_num2name72="pselect6" ++__syscall_64_name2num"pselect6"=72 ++__syscall_64_name2num"pselect6"=72 ++__syscall_64_num2name117="ptrace" ++__syscall_64_num2name117="ptrace" ++__syscall_64_name2num"ptrace"=117 ++__syscall_64_name2num"ptrace"=117 ++__syscall_64_num2name68="pwrite64" ++__syscall_64_num2name68="pwrite64" ++__syscall_64_name2num"pwrite64"=68 ++__syscall_64_name2num"pwrite64"=68 ++__syscall_64_num2name70="pwritev" ++__syscall_64_num2name70="pwritev" ++__syscall_64_num2name287="pwritev2" ++__syscall_64_num2name287="pwritev2" ++__syscall_64_name2num"pwritev2"=287 ++__syscall_64_name2num"pwritev2"=287 ++__syscall_64_name2num"pwritev"=70 ++__syscall_64_name2num"pwritev"=70 ++__syscall_64_num2name60="quotactl" ++__syscall_64_num2name60="quotactl" ++__syscall_64_name2num"quotactl"=60 ++__syscall_64_name2num"quotactl"=60 ++__syscall_64_num2name0+443="quotactl_fd" ++__syscall_64_num2name0+443="quotactl_fd" ++__syscall_64_name2num"quotactl_fd"=0+443 ++__syscall_64_name2num"quotactl_fd"=0+443 ++__syscall_64_num2name63="read" ++__syscall_64_num2name63="read" ++__syscall_64_name2num"read"=63 ++__syscall_64_name2num"read"=63 ++__syscall_64_num2name213="readahead" ++__syscall_64_num2name213="readahead" ++__syscall_64_name2num"readahead"=213 ++__syscall_64_name2num"readahead"=213 ++__syscall_64_num2name78="readlinkat" ++__syscall_64_num2name78="readlinkat" ++__syscall_64_name2num"readlinkat"=78 ++__syscall_64_name2num"readlinkat"=78 ++__syscall_64_num2name65="readv" ++__syscall_64_num2name65="readv" ++__syscall_64_name2num"readv"=65 ++__syscall_64_name2num"readv"=65 ++__syscall_64_num2name142="reboot" ++__syscall_64_num2name142="reboot" ++__syscall_64_name2num"reboot"=142 ++__syscall_64_name2num"reboot"=142 ++__syscall_64_num2name207="recvfrom" ++__syscall_64_num2name207="recvfrom" ++__syscall_64_name2num"recvfrom"=207 ++__syscall_64_name2num"recvfrom"=207 ++__syscall_64_num2name243="recvmmsg" ++__syscall_64_num2name243="recvmmsg" ++__syscall_64_name2num"recvmmsg"=243 ++__syscall_64_name2num"recvmmsg"=243 ++__syscall_64_num2name212="recvmsg" ++__syscall_64_num2name212="recvmsg" ++__syscall_64_name2num"recvmsg"=212 ++__syscall_64_name2num"recvmsg"=212 ++__syscall_64_num2name234="remap_file_pages" ++__syscall_64_num2name234="remap_file_pages" ++__syscall_64_name2num"remap_file_pages"=234 ++__syscall_64_name2num"remap_file_pages"=234 ++__syscall_64_num2name14="removexattr" ++__syscall_64_num2name14="removexattr" ++__syscall_64_name2num"removexattr"=14 ++__syscall_64_name2num"removexattr"=14 ++__syscall_64_num2name38="renameat" ++__syscall_64_num2name38="renameat" ++__syscall_64_num2name276="renameat2" ++__syscall_64_num2name276="renameat2" ++__syscall_64_name2num"renameat2"=276 ++__syscall_64_name2num"renameat2"=276 ++__syscall_64_name2num"renameat"=38 ++__syscall_64_name2num"renameat"=38 ++__syscall_64_num2name218="request_key" ++__syscall_64_num2name218="request_key" ++__syscall_64_name2num"request_key"=218 ++__syscall_64_name2num"request_key"=218 ++__syscall_64_num2name128="restart_syscall" ++__syscall_64_num2name128="restart_syscall" ++__syscall_64_name2num"restart_syscall"=128 ++__syscall_64_name2num"restart_syscall"=128 ++__syscall_64_num2name293="rseq" ++__syscall_64_num2name293="rseq" ++__syscall_64_name2num"rseq"=293 ++__syscall_64_name2num"rseq"=293 ++__syscall_64_num2name134="rt_sigaction" ++__syscall_64_num2name134="rt_sigaction" ++__syscall_64_name2num"rt_sigaction"=134 ++__syscall_64_name2num"rt_sigaction"=134 ++__syscall_64_num2name136="rt_sigpending" ++__syscall_64_num2name136="rt_sigpending" ++__syscall_64_name2num"rt_sigpending"=136 ++__syscall_64_name2num"rt_sigpending"=136 ++__syscall_64_num2name135="rt_sigprocmask" ++__syscall_64_num2name135="rt_sigprocmask" ++__syscall_64_name2num"rt_sigprocmask"=135 ++__syscall_64_name2num"rt_sigprocmask"=135 ++__syscall_64_num2name138="rt_sigqueueinfo" ++__syscall_64_num2name138="rt_sigqueueinfo" ++__syscall_64_name2num"rt_sigqueueinfo"=138 ++__syscall_64_name2num"rt_sigqueueinfo"=138 ++__syscall_64_num2name139="rt_sigreturn" ++__syscall_64_num2name139="rt_sigreturn" ++__syscall_64_name2num"rt_sigreturn"=139 ++__syscall_64_name2num"rt_sigreturn"=139 ++__syscall_64_num2name133="rt_sigsuspend" ++__syscall_64_num2name133="rt_sigsuspend" ++__syscall_64_name2num"rt_sigsuspend"=133 ++__syscall_64_name2num"rt_sigsuspend"=133 ++__syscall_64_num2name137="rt_sigtimedwait" ++__syscall_64_num2name137="rt_sigtimedwait" ++__syscall_64_name2num"rt_sigtimedwait"=137 ++__syscall_64_name2num"rt_sigtimedwait"=137 ++__syscall_64_num2name240="rt_tgsigqueueinfo" ++__syscall_64_num2name240="rt_tgsigqueueinfo" ++__syscall_64_name2num"rt_tgsigqueueinfo"=240 ++__syscall_64_name2num"rt_tgsigqueueinfo"=240 ++__syscall_64_num2name123="sched_getaffinity" ++__syscall_64_num2name123="sched_getaffinity" ++__syscall_64_name2num"sched_getaffinity"=123 ++__syscall_64_name2num"sched_getaffinity"=123 ++__syscall_64_num2name275="sched_getattr" ++__syscall_64_num2name275="sched_getattr" ++__syscall_64_name2num"sched_getattr"=275 ++__syscall_64_name2num"sched_getattr"=275 ++__syscall_64_num2name121="sched_getparam" ++__syscall_64_num2name121="sched_getparam" ++__syscall_64_name2num"sched_getparam"=121 ++__syscall_64_name2num"sched_getparam"=121 ++__syscall_64_num2name125="sched_get_priority_max" ++__syscall_64_num2name125="sched_get_priority_max" ++__syscall_64_name2num"sched_get_priority_max"=125 ++__syscall_64_name2num"sched_get_priority_max"=125 ++__syscall_64_num2name126="sched_get_priority_min" ++__syscall_64_num2name126="sched_get_priority_min" ++__syscall_64_name2num"sched_get_priority_min"=126 ++__syscall_64_name2num"sched_get_priority_min"=126 ++__syscall_64_num2name120="sched_getscheduler" ++__syscall_64_num2name120="sched_getscheduler" ++__syscall_64_name2num"sched_getscheduler"=120 ++__syscall_64_name2num"sched_getscheduler"=120 ++__syscall_64_num2name127="sched_rr_get_interval" ++__syscall_64_num2name127="sched_rr_get_interval" ++__syscall_64_name2num"sched_rr_get_interval"=127 ++__syscall_64_name2num"sched_rr_get_interval"=127 ++__syscall_64_num2name122="sched_setaffinity" ++__syscall_64_num2name122="sched_setaffinity" ++__syscall_64_name2num"sched_setaffinity"=122 ++__syscall_64_name2num"sched_setaffinity"=122 ++__syscall_64_num2name274="sched_setattr" ++__syscall_64_num2name274="sched_setattr" ++__syscall_64_name2num"sched_setattr"=274 ++__syscall_64_name2num"sched_setattr"=274 ++__syscall_64_num2name118="sched_setparam" ++__syscall_64_num2name118="sched_setparam" ++__syscall_64_name2num"sched_setparam"=118 ++__syscall_64_name2num"sched_setparam"=118 ++__syscall_64_num2name119="sched_setscheduler" ++__syscall_64_num2name119="sched_setscheduler" ++__syscall_64_name2num"sched_setscheduler"=119 ++__syscall_64_name2num"sched_setscheduler"=119 ++__syscall_64_num2name124="sched_yield" ++__syscall_64_num2name124="sched_yield" ++__syscall_64_name2num"sched_yield"=124 ++__syscall_64_name2num"sched_yield"=124 ++__syscall_64_num2name277="seccomp" ++__syscall_64_num2name277="seccomp" ++__syscall_64_name2num"seccomp"=277 ++__syscall_64_name2num"seccomp"=277 ++__syscall_64_num2name191="semctl" ++__syscall_64_num2name191="semctl" ++__syscall_64_name2num"semctl"=191 ++__syscall_64_name2num"semctl"=191 ++__syscall_64_num2name190="semget" ++__syscall_64_num2name190="semget" ++__syscall_64_name2num"semget"=190 ++__syscall_64_name2num"semget"=190 ++__syscall_64_num2name193="semop" ++__syscall_64_num2name193="semop" ++__syscall_64_name2num"semop"=193 ++__syscall_64_name2num"semop"=193 ++__syscall_64_num2name192="semtimedop" ++__syscall_64_num2name192="semtimedop" ++__syscall_64_name2num"semtimedop"=192 ++__syscall_64_name2num"semtimedop"=192 ++__syscall_64_num2name71="sendfile" ++__syscall_64_num2name71="sendfile" ++__syscall_64_name2num"sendfile"=71 ++__syscall_64_name2num"sendfile"=71 ++__syscall_64_num2name269="sendmmsg" ++__syscall_64_num2name269="sendmmsg" ++__syscall_64_name2num"sendmmsg"=269 ++__syscall_64_name2num"sendmmsg"=269 ++__syscall_64_num2name211="sendmsg" ++__syscall_64_num2name211="sendmsg" ++__syscall_64_name2num"sendmsg"=211 ++__syscall_64_name2num"sendmsg"=211 ++__syscall_64_num2name206="sendto" ++__syscall_64_num2name206="sendto" ++__syscall_64_name2num"sendto"=206 ++__syscall_64_name2num"sendto"=206 ++__syscall_64_num2name162="setdomainname" ++__syscall_64_num2name162="setdomainname" ++__syscall_64_name2num"setdomainname"=162 ++__syscall_64_name2num"setdomainname"=162 ++__syscall_64_num2name152="setfsgid" ++__syscall_64_num2name152="setfsgid" ++__syscall_64_name2num"setfsgid"=152 ++__syscall_64_name2num"setfsgid"=152 ++__syscall_64_num2name151="setfsuid" ++__syscall_64_num2name151="setfsuid" ++__syscall_64_name2num"setfsuid"=151 ++__syscall_64_name2num"setfsuid"=151 ++__syscall_64_num2name144="setgid" ++__syscall_64_num2name144="setgid" ++__syscall_64_name2num"setgid"=144 ++__syscall_64_name2num"setgid"=144 ++__syscall_64_num2name159="setgroups" ++__syscall_64_num2name159="setgroups" ++__syscall_64_name2num"setgroups"=159 ++__syscall_64_name2num"setgroups"=159 ++__syscall_64_num2name161="sethostname" ++__syscall_64_num2name161="sethostname" ++__syscall_64_name2num"sethostname"=161 ++__syscall_64_name2num"sethostname"=161 ++__syscall_64_num2name103="setitimer" ++__syscall_64_num2name103="setitimer" ++__syscall_64_name2num"setitimer"=103 ++__syscall_64_name2num"setitimer"=103 ++__syscall_64_num2name237="set_mempolicy" ++__syscall_64_num2name237="set_mempolicy" ++__syscall_64_name2num"set_mempolicy"=237 ++__syscall_64_name2num"set_mempolicy"=237 ++__syscall_64_num2name0+450="set_mempolicy_home_node" ++__syscall_64_num2name0+450="set_mempolicy_home_node" ++__syscall_64_name2num"set_mempolicy_home_node"=0+450 ++__syscall_64_name2num"set_mempolicy_home_node"=0+450 ++__syscall_64_num2name268="setns" ++__syscall_64_num2name268="setns" ++__syscall_64_name2num"setns"=268 ++__syscall_64_name2num"setns"=268 ++__syscall_64_num2name154="setpgid" ++__syscall_64_num2name154="setpgid" ++__syscall_64_name2num"setpgid"=154 ++__syscall_64_name2num"setpgid"=154 ++__syscall_64_num2name140="setpriority" ++__syscall_64_num2name140="setpriority" ++__syscall_64_name2num"setpriority"=140 ++__syscall_64_name2num"setpriority"=140 ++__syscall_64_num2name143="setregid" ++__syscall_64_num2name143="setregid" ++__syscall_64_name2num"setregid"=143 ++__syscall_64_name2num"setregid"=143 ++__syscall_64_num2name149="setresgid" ++__syscall_64_num2name149="setresgid" ++__syscall_64_name2num"setresgid"=149 ++__syscall_64_name2num"setresgid"=149 ++__syscall_64_num2name147="setresuid" ++__syscall_64_num2name147="setresuid" ++__syscall_64_name2num"setresuid"=147 ++__syscall_64_name2num"setresuid"=147 ++__syscall_64_num2name145="setreuid" ++__syscall_64_num2name145="setreuid" ++__syscall_64_name2num"setreuid"=145 ++__syscall_64_name2num"setreuid"=145 ++__syscall_64_num2name164="setrlimit" ++__syscall_64_num2name164="setrlimit" ++__syscall_64_name2num"setrlimit"=164 ++__syscall_64_name2num"setrlimit"=164 ++__syscall_64_num2name99="set_robust_list" ++__syscall_64_num2name99="set_robust_list" ++__syscall_64_name2num"set_robust_list"=99 ++__syscall_64_name2num"set_robust_list"=99 ++__syscall_64_num2name157="setsid" ++__syscall_64_num2name157="setsid" ++__syscall_64_name2num"setsid"=157 ++__syscall_64_name2num"setsid"=157 ++__syscall_64_num2name208="setsockopt" ++__syscall_64_num2name208="setsockopt" ++__syscall_64_name2num"setsockopt"=208 ++__syscall_64_name2num"setsockopt"=208 ++__syscall_64_num2name96="set_tid_address" ++__syscall_64_num2name96="set_tid_address" ++__syscall_64_name2num"set_tid_address"=96 ++__syscall_64_name2num"set_tid_address"=96 ++__syscall_64_num2name170="settimeofday" ++__syscall_64_num2name170="settimeofday" ++__syscall_64_name2num"settimeofday"=170 ++__syscall_64_name2num"settimeofday"=170 ++__syscall_64_num2name146="setuid" ++__syscall_64_num2name146="setuid" ++__syscall_64_name2num"setuid"=146 ++__syscall_64_name2num"setuid"=146 ++__syscall_64_num2name5="setxattr" ++__syscall_64_num2name5="setxattr" ++__syscall_64_name2num"setxattr"=5 ++__syscall_64_name2num"setxattr"=5 ++__syscall_64_num2name196="shmat" ++__syscall_64_num2name196="shmat" ++__syscall_64_name2num"shmat"=196 ++__syscall_64_name2num"shmat"=196 ++__syscall_64_num2name195="shmctl" ++__syscall_64_num2name195="shmctl" ++__syscall_64_name2num"shmctl"=195 ++__syscall_64_name2num"shmctl"=195 ++__syscall_64_num2name197="shmdt" ++__syscall_64_num2name197="shmdt" ++__syscall_64_name2num"shmdt"=197 ++__syscall_64_name2num"shmdt"=197 ++__syscall_64_num2name194="shmget" ++__syscall_64_num2name194="shmget" ++__syscall_64_name2num"shmget"=194 ++__syscall_64_name2num"shmget"=194 ++__syscall_64_num2name210="shutdown" ++__syscall_64_num2name210="shutdown" ++__syscall_64_name2num"shutdown"=210 ++__syscall_64_name2num"shutdown"=210 ++__syscall_64_num2name132="sigaltstack" ++__syscall_64_num2name132="sigaltstack" ++__syscall_64_name2num"sigaltstack"=132 ++__syscall_64_name2num"sigaltstack"=132 ++__syscall_64_num2name74="signalfd4" ++__syscall_64_num2name74="signalfd4" ++__syscall_64_name2num"signalfd4"=74 ++__syscall_64_name2num"signalfd4"=74 ++__syscall_64_num2name198="socket" ++__syscall_64_num2name198="socket" ++__syscall_64_name2num"socket"=198 ++__syscall_64_name2num"socket"=198 ++__syscall_64_num2name199="socketpair" ++__syscall_64_num2name199="socketpair" ++__syscall_64_name2num"socketpair"=199 ++__syscall_64_name2num"socketpair"=199 ++__syscall_64_num2name76="splice" ++__syscall_64_num2name76="splice" ++__syscall_64_name2num"splice"=76 ++__syscall_64_name2num"splice"=76 ++__syscall_64_num2name43="statfs" ++__syscall_64_num2name43="statfs" ++__syscall_64_name2num"statfs"=43 ++__syscall_64_name2num"statfs"=43 ++__syscall_64_num2name0+457="statmount" ++__syscall_64_num2name0+457="statmount" ++__syscall_64_name2num"statmount"=0+457 ++__syscall_64_name2num"statmount"=0+457 ++__syscall_64_num2name291="statx" ++__syscall_64_num2name291="statx" ++__syscall_64_name2num"statx"=291 ++__syscall_64_name2num"statx"=291 ++__syscall_64_num2name225="swapoff" ++__syscall_64_num2name225="swapoff" ++__syscall_64_name2num"swapoff"=225 ++__syscall_64_name2num"swapoff"=225 ++__syscall_64_num2name224="swapon" ++__syscall_64_num2name224="swapon" ++__syscall_64_name2num"swapon"=224 ++__syscall_64_name2num"swapon"=224 ++__syscall_64_num2name36="symlinkat" ++__syscall_64_num2name36="symlinkat" ++__syscall_64_name2num"symlinkat"=36 ++__syscall_64_name2num"symlinkat"=36 ++__syscall_64_num2name81="sync" ++__syscall_64_num2name81="sync" ++__syscall_64_name2num"sync"=81 ++__syscall_64_name2num"sync"=81 ++__syscall_64_num2name84="sync_file_range" ++__syscall_64_num2name84="sync_file_range" ++__syscall_64_name2num"sync_file_range"=84 ++__syscall_64_name2num"sync_file_range"=84 ++__syscall_64_num2name267="syncfs" ++__syscall_64_num2name267="syncfs" ++__syscall_64_name2num"syncfs"=267 ++__syscall_64_name2num"syncfs"=267 ++__syscall_64_num2name179="sysinfo" ++__syscall_64_num2name179="sysinfo" ++__syscall_64_name2num"sysinfo"=179 ++__syscall_64_name2num"sysinfo"=179 ++__syscall_64_num2name116="syslog" ++__syscall_64_num2name116="syslog" ++__syscall_64_name2num"syslog"=116 ++__syscall_64_name2num"syslog"=116 ++__syscall_64_num2name77="tee" ++__syscall_64_num2name77="tee" ++__syscall_64_name2num"tee"=77 ++__syscall_64_name2num"tee"=77 ++__syscall_64_num2name131="tgkill" ++__syscall_64_num2name131="tgkill" ++__syscall_64_name2num"tgkill"=131 ++__syscall_64_name2num"tgkill"=131 ++__syscall_64_num2name107="timer_create" ++__syscall_64_num2name107="timer_create" ++__syscall_64_name2num"timer_create"=107 ++__syscall_64_name2num"timer_create"=107 ++__syscall_64_num2name111="timer_delete" ++__syscall_64_num2name111="timer_delete" ++__syscall_64_name2num"timer_delete"=111 ++__syscall_64_name2num"timer_delete"=111 ++__syscall_64_num2name85="timerfd_create" ++__syscall_64_num2name85="timerfd_create" ++__syscall_64_name2num"timerfd_create"=85 ++__syscall_64_name2num"timerfd_create"=85 ++__syscall_64_num2name87="timerfd_gettime" ++__syscall_64_num2name87="timerfd_gettime" ++__syscall_64_name2num"timerfd_gettime"=87 ++__syscall_64_name2num"timerfd_gettime"=87 ++__syscall_64_num2name86="timerfd_settime" ++__syscall_64_num2name86="timerfd_settime" ++__syscall_64_name2num"timerfd_settime"=86 ++__syscall_64_name2num"timerfd_settime"=86 ++__syscall_64_num2name109="timer_getoverrun" ++__syscall_64_num2name109="timer_getoverrun" ++__syscall_64_name2num"timer_getoverrun"=109 ++__syscall_64_name2num"timer_getoverrun"=109 ++__syscall_64_num2name108="timer_gettime" ++__syscall_64_num2name108="timer_gettime" ++__syscall_64_name2num"timer_gettime"=108 ++__syscall_64_name2num"timer_gettime"=108 ++__syscall_64_num2name110="timer_settime" ++__syscall_64_num2name110="timer_settime" ++__syscall_64_name2num"timer_settime"=110 ++__syscall_64_name2num"timer_settime"=110 ++__syscall_64_num2name153="times" ++__syscall_64_num2name153="times" ++__syscall_64_name2num"times"=153 ++__syscall_64_name2num"times"=153 ++__syscall_64_num2name130="tkill" ++__syscall_64_num2name130="tkill" ++__syscall_64_name2num"tkill"=130 ++__syscall_64_name2num"tkill"=130 ++__syscall_64_num2name45="truncate" ++__syscall_64_num2name45="truncate" ++__syscall_64_name2num"truncate"=45 ++__syscall_64_name2num"truncate"=45 ++__syscall_64_num2name166="umask" ++__syscall_64_num2name166="umask" ++__syscall_64_name2num"umask"=166 ++__syscall_64_name2num"umask"=166 ++__syscall_64_num2name39="umount2" ++__syscall_64_num2name39="umount2" ++__syscall_64_name2num"umount2"=39 ++__syscall_64_name2num"umount2"=39 ++__syscall_64_num2name160="uname" ++__syscall_64_num2name160="uname" ++__syscall_64_name2num"uname"=160 ++__syscall_64_name2num"uname"=160 ++__syscall_64_num2name35="unlinkat" ++__syscall_64_num2name35="unlinkat" ++__syscall_64_name2num"unlinkat"=35 ++__syscall_64_name2num"unlinkat"=35 ++__syscall_64_num2name97="unshare" ++__syscall_64_num2name97="unshare" ++__syscall_64_name2num"unshare"=97 ++__syscall_64_name2num"unshare"=97 ++__syscall_64_num2name282="userfaultfd" ++__syscall_64_num2name282="userfaultfd" ++__syscall_64_name2num"userfaultfd"=282 ++__syscall_64_name2num"userfaultfd"=282 ++__syscall_64_num2name88="utimensat" ++__syscall_64_num2name88="utimensat" ++__syscall_64_name2num"utimensat"=88 ++__syscall_64_name2num"utimensat"=88 ++__syscall_64_num2name58="vhangup" ++__syscall_64_num2name58="vhangup" ++__syscall_64_name2num"vhangup"=58 ++__syscall_64_name2num"vhangup"=58 ++__syscall_64_num2name75="vmsplice" ++__syscall_64_num2name75="vmsplice" ++__syscall_64_name2num"vmsplice"=75 ++__syscall_64_name2num"vmsplice"=75 ++__syscall_64_num2name260="wait4" ++__syscall_64_num2name260="wait4" ++__syscall_64_name2num"wait4"=260 ++__syscall_64_name2num"wait4"=260 ++__syscall_64_num2name95="waitid" ++__syscall_64_num2name95="waitid" ++__syscall_64_name2num"waitid"=95 ++__syscall_64_name2num"waitid"=95 ++__syscall_64_num2name64="write" ++__syscall_64_num2name64="write" ++__syscall_64_name2num"write"=64 ++__syscall_64_name2num"write"=64 ++__syscall_64_num2name66="writev" ++__syscall_64_num2name66="writev" ++__syscall_64_name2num"writev"=66 ++__syscall_64_name2num"writev"=66 ++%) ++} /* probe init */ +\ No newline at end of file +diff --git a/tapset/linux/syscalls.stpm b/tapset/linux/syscalls.stpm +index 9f14a99..3c79bc8 100644 +--- a/tapset/linux/syscalls.stpm ++++ b/tapset/linux/syscalls.stpm +@@ -402,7 +402,7 @@ + @define SYSC_CLONE_CHILD_TID_UADDR_ARGNO %( 5 %) + %) + +-%( arch == "i386" || arch == "arm" || arch == "powerpc" || arch == "mips" || arch == "riscv" %? ++%( arch == "i386" || arch == "arm" || arch == "powerpc" || arch == "mips" || arch == "riscv" || arch == "loongarch64" %? + @define arch_syscall_prefix %( "" %) + @define arch_syscall0_prefix %( "" %) + @define SYSC_CLONE_CLONE_FLAGS_ARGNO %( 1 %) +diff --git a/tapsets.cxx b/tapsets.cxx +index 49a0d1d..404a64c 100644 +--- a/tapsets.cxx ++++ b/tapsets.cxx +@@ -2582,6 +2582,7 @@ validate_module_elf (systemtap_session& sess, + case EM_AARCH64: expect_machine = "arm64"; break; + case EM_MIPS: expect_machine = "mips"; break; + case EM_RISCV: expect_machine = "riscv"; break; ++ case EM_LOONGARCH: expect_machine = "loongarch64"; break; + // XXX: fill in some more of these + default: expect_machine = "?"; break; + } +@@ -6961,6 +6962,43 @@ sdt_uprobe_var_expanding_visitor::build_dwarf_registers () + DRI ("$29", 29, mips_reg_width); + DRI ("$30", 30, mips_reg_width); + DRI ("$31", 31, mips_reg_width); ++ } else if (elf_machine == EM_LOONGARCH) { ++ Dwarf_Addr bias; ++ Elf* elf = (dwfl_module_getelf (dw.mod_info->mod, &bias)); ++ enum regwidths loongarch_reg_width = ++ (gelf_getclass (elf) == ELFCLASS32) ? SI : DI; // 32-bit: SI 64-bit: DI ++ DRI ("$r0", 0, loongarch_reg_width); DRI ("$zero", 0, loongarch_reg_width); ++ DRI ("$r1", 1, loongarch_reg_width); DRI ("$ra", 1, loongarch_reg_width); ++ DRI ("$r2", 2, loongarch_reg_width); DRI ("$tp", 2, loongarch_reg_width); ++ DRI ("$r3", 3, loongarch_reg_width); DRI ("$sp", 3, loongarch_reg_width); ++ DRI ("$r4", 4, loongarch_reg_width); DRI ("$a0", 4, loongarch_reg_width); DRI ("$v0", 4, loongarch_reg_width); ++ DRI ("$r5", 5, loongarch_reg_width); DRI ("$a1", 5, loongarch_reg_width); DRI ("$v1", 5, loongarch_reg_width); ++ DRI ("$r6", 6, loongarch_reg_width); DRI ("$a2", 6, loongarch_reg_width); ++ DRI ("$r7", 7, loongarch_reg_width); DRI ("$a3", 7, loongarch_reg_width); ++ DRI ("$r8", 8, loongarch_reg_width); DRI ("$a4", 8, loongarch_reg_width); ++ DRI ("$r9", 9, loongarch_reg_width); DRI ("$a5", 9, loongarch_reg_width); ++ DRI ("$r10", 10, loongarch_reg_width); DRI ("$a6", 10, loongarch_reg_width); ++ DRI ("$r11", 11, loongarch_reg_width); DRI ("$a7", 11, loongarch_reg_width); ++ DRI ("$r12", 12, loongarch_reg_width); DRI ("$t0", 12, loongarch_reg_width); ++ DRI ("$r13", 13, loongarch_reg_width); DRI ("$t1", 13, loongarch_reg_width); ++ DRI ("$r14", 14, loongarch_reg_width); DRI ("$t2", 14, loongarch_reg_width); ++ DRI ("$r15", 15, loongarch_reg_width); DRI ("$t3", 15, loongarch_reg_width); ++ DRI ("$r16", 16, loongarch_reg_width); DRI ("$t4", 16, loongarch_reg_width); ++ DRI ("$r17", 17, loongarch_reg_width); DRI ("$t5", 17, loongarch_reg_width); ++ DRI ("$r18", 18, loongarch_reg_width); DRI ("$t6", 18, loongarch_reg_width); ++ DRI ("$r19", 19, loongarch_reg_width); DRI ("$t7", 19, loongarch_reg_width); ++ DRI ("$r20", 20, loongarch_reg_width); DRI ("$t8", 20, loongarch_reg_width); ++ DRI ("$r21", 21, loongarch_reg_width); DRI ("$x", 21, loongarch_reg_width); ++ DRI ("$r22", 22, loongarch_reg_width); DRI ("$fp", 22, loongarch_reg_width); ++ DRI ("$r23", 23, loongarch_reg_width); DRI ("$s0", 23, loongarch_reg_width); ++ DRI ("$r24", 24, loongarch_reg_width); DRI ("$s1", 24, loongarch_reg_width); ++ DRI ("$r25", 25, loongarch_reg_width); DRI ("$s2", 25, loongarch_reg_width); ++ DRI ("$r26", 26, loongarch_reg_width); DRI ("$s3", 26, loongarch_reg_width); ++ DRI ("$r27", 27, loongarch_reg_width); DRI ("$s4", 27, loongarch_reg_width); ++ DRI ("$r28", 28, loongarch_reg_width); DRI ("$s5", 28, loongarch_reg_width); ++ DRI ("$r29", 29, loongarch_reg_width); DRI ("$s6", 29, loongarch_reg_width); ++ DRI ("$r30", 30, loongarch_reg_width); DRI ("$s7", 30, loongarch_reg_width); ++ DRI ("$r31", 31, loongarch_reg_width); DRI ("$s8", 31, loongarch_reg_width); + } else if (arg_count) { + /* permit this case; just fall back to dwarf */ + } +@@ -7134,7 +7172,7 @@ sdt_uprobe_var_expanding_visitor::try_parse_arg_literal (target_symbol *e, + vector<string> matches; + string regexp; + +- if (elf_machine == EM_AARCH64 || elf_machine == EM_MIPS) { ++ if (elf_machine == EM_AARCH64 || elf_machine == EM_MIPS || elf_machine == EM_LOONGARCH) { + regexp = "^(-?0-90-9*)$"; + } else { + regexp = "^i\\$#(-?0-90-9*)$"; +diff --git a/testsuite/lib/compile_flags.exp b/testsuite/lib/compile_flags.exp +index a84e7ca..06864df 100644 +--- a/testsuite/lib/compile_flags.exp ++++ b/testsuite/lib/compile_flags.exp +@@ -59,7 +59,11 @@ proc arch_compile_init {} { + } + + puts "Checking for $compat_arch_bits-bit support..." +- set flags "additional_flags=-g compiler=gcc additional_flags=-m$compat_arch_bits" ++ set flags "additional_flags=-g compiler=gcc " ++# GCC on loongarch64 doesn't recognize -m64 ++ if { !regexp "^(loongarch64)$" $::tcl_platform(machine) } { ++ set flags "$flags additional_flags=-m$compat_arch_bits" ++ } + set exe "hello-m$compat_arch_bits" + set result target_compile $source $exe executable $flags + if { $result != "" } { +@@ -109,6 +113,7 @@ proc arch_compile_flag_name { INDEX } { + {^(ia64|aarch64|ppc64le|ppc64)$} { return "m64" } + {^s390$} { return "m31" } + {^mips64$} { return "64" } ++ {^loongarch64$} { return "lp64d" } + default { return "m32" } + } + } +@@ -135,7 +140,7 @@ proc arch_compile_flag_bits { INDEX } { + # Notice that even though s390/s390x is 31 bits, we'll call it 32. + if { arch_compile_flags == 1 } { + switch -regexp $::tcl_platform(machine) { +- {^(ia64|aarch64|ppc64le|ppc64|mips64|s390x)$} { return 64 } ++ {^(ia64|aarch64|ppc64le|ppc64|mips64|s390x|loongarch64)$} { return 64 } + default { return 32 } + } + } +diff --git a/testsuite/lib/systemtap.exp b/testsuite/lib/systemtap.exp +index dcf5ee7..5463d5a 100644 +--- a/testsuite/lib/systemtap.exp ++++ b/testsuite/lib/systemtap.exp +@@ -85,7 +85,7 @@ proc uretprobes_p {} { + proc plt_probes_p {} { + # .plt probes need uprobes and a supported arch (x86 and arm) + return expr uprobes_p \ +- && regexp "^(x86_64|i.86|arm.*|aarch64)$" $::tcl_platform(machine) ++ && regexp "^(x86_64|i.86|arm.*|aarch64|loongarch64)$" $::tcl_platform(machine) + } + + proc perf_probes_p {} { +@@ -570,6 +570,7 @@ proc normalize_arch { arch } { + if {$arch == "armv7l"} then {return "arm"} + if {$arch == "armv7lh"} then {return "arm"} + if {$arch == "aarch64"} then {return "arm64"} ++ if {$arch == "loongarch64"} then {return "loongarch64"} + if {$arch == "ppc64le"} then {return "powerpc"} + if {$arch == "mips64"} then {return "mips"} + return $arch +diff --git a/testsuite/systemtap.syscall/clone.c b/testsuite/systemtap.syscall/clone.c +index f1335ce..942d104 100644 +--- a/testsuite/systemtap.syscall/clone.c ++++ b/testsuite/systemtap.syscall/clone.c +@@ -61,7 +61,7 @@ __sys_clone2(int flags, void *ustack_base, size_t ustack_size, + #endif + #if defined(__powerpc__) || defined(__powerpc64__) \ + || defined(__arm__) || defined(__aarch64__) \ +- || defined(__i386__) ++ || defined(__i386__) || defined(__loongarch64) + #define CLONE_BACKWARDS + #endif + +diff --git a/translate.cxx b/translate.cxx +index 0a3b58a..90c3f1f 100644 +--- a/translate.cxx ++++ b/translate.cxx +@@ -8482,7 +8482,8 @@ translate_pass (systemtap_session& s) + + s.op->hdr->newline() << "#if (defined(__arm__) || defined(__i386__) " + "|| defined(__x86_64__) || defined(__powerpc64__)) " +- "|| defined (__s390x__) || defined(__aarch64__) || defined(__mips__)\n" ++ "|| defined (__s390x__) || defined(__aarch64__) || defined(__mips__) " ++ "|| defined(__loongarch64)\n" + "#ifdef STP_NEED_UNWIND_DATA\n" + "#ifndef STP_USE_DWARF_UNWINDER\n" + "#define STP_USE_DWARF_UNWINDER\n" +diff --git a/util.cxx b/util.cxx +index f2eaf54..24d3215 100644 +--- a/util.cxx ++++ b/util.cxx +@@ -1400,6 +1400,7 @@ normalize_machine(const string& machine) + else if (machine == "s390x") return "s390"; + else if (machine == "aarch64") return "arm64"; + else if (machine == "riscv64") return "riscv"; ++ else if (machine == "loongarch64") return "loongarch64"; + else if (machine.substr(0,3) == "ppc") return "powerpc"; + else if (machine.substr(0,4) == "mips") return "mips"; + else if (machine.substr(0,3) == "sh2") return "sh"; +@@ -1421,6 +1422,7 @@ elf_class_from_normalized_machine (const string &machine) + || machine == "powerpc" // see normalize_machine (). + || machine == "x86_64" + || machine == "ia64" ++ || machine == "loongarch64" + || machine == "arm64") + return ELFCLASS64; + +-- +2.33.0 +
View file
_service:tar_scm:Make-stp_task_work-compatible-with-6.11-kernels.patch
Added
@@ -0,0 +1,99 @@ +From a64dc4e2e0195ca80c6509df511a42459b40e9af Mon Sep 17 00:00:00 2001 +From: Martin Cermak <mcermak@redhat.com> +Date: Wed, 24 Jul 2024 16:47:42 +0200 +Subject: PATCH Make stp_task_work compatible with 6.11 kernels + +Update systemtap runtime so that it works with kernel commit +68cbd415dd4b task_work: + +s/task_work_cancel()/task_work_cancel_func()/ +--- + buildrun.cxx | 1 + + .../linux/autoconf-task_work_cancel_func.c | 3 +++ + runtime/linux/runtime.h | 2 +- + runtime/stp_task_work.c | 21 ++++++++++++++----- + 4 files changed, 21 insertions(+), 6 deletions(-) + create mode 100644 runtime/linux/autoconf-task_work_cancel_func.c + +diff --git a/buildrun.cxx b/buildrun.cxx +index a7fcd6297..e3f2f83d1 100644 +--- a/buildrun.cxx ++++ b/buildrun.cxx +@@ -400,6 +400,7 @@ compile_pass (systemtap_session& s) + output_exportconf(s, o2, "__module_text_address", "STAPCONF_MODULE_TEXT_ADDRESS"); + output_exportconf(s, o2, "add_timer_on", "STAPCONF_ADD_TIMER_ON"); + output_autoconf(s, o, cs, "autoconf-514-panic.c", "STAPCONF_514_PANIC", NULL); ++ output_autoconf(s, o, cs, "autoconf-task_work_cancel_func.c", "STAPCONF_TASK_WORK_CANCEL_FUNC", NULL); + + output_dual_exportconf(s, o2, "probe_kernel_read", "probe_kernel_write", "STAPCONF_PROBE_KERNEL"); + output_autoconf(s, o, cs, "autoconf-hw_breakpoint_context.c", +diff --git a/runtime/linux/autoconf-task_work_cancel_func.c b/runtime/linux/autoconf-task_work_cancel_func.c +new file mode 100644 +index 000000000..0d460de6c +--- /dev/null ++++ b/runtime/linux/autoconf-task_work_cancel_func.c +@@ -0,0 +1,3 @@ ++#include <linux/task_work.h> ++ ++void* c = & task_work_cancel_func; +diff --git a/runtime/linux/runtime.h b/runtime/linux/runtime.h +index 0e9fe3fea..bd9307385 100644 +--- a/runtime/linux/runtime.h ++++ b/runtime/linux/runtime.h +@@ -265,7 +265,7 @@ static void *kallsyms_uprobe_get_swbp_addr; + static void *kallsyms_task_work_add; + #endif + #if !defined(STAPCONF_TASK_WORK_CANCEL_EXPORTED) +-static void *kallsyms_task_work_cancel; ++static void *kallsyms_task_work_cancel_fn; + #endif + + #if !defined(STAPCONF_TRY_TO_WAKE_UP_EXPORTED) && !defined(STAPCONF_WAKE_UP_STATE_EXPORTED) +diff --git a/runtime/stp_task_work.c b/runtime/stp_task_work.c +index 0dd3095b6..4818fecbf 100644 +--- a/runtime/stp_task_work.c ++++ b/runtime/stp_task_work.c +@@ -3,14 +3,25 @@ + + #include "linux/task_work_compatibility.h" + ++// Handle kernel commit 68cbd415dd4b9c5b9df69f0f091879e56bf5907a ++// task_work: s/task_work_cancel()/task_work_cancel_func()/ ++#if defined(STAPCONF_TASK_WORK_CANCEL_FUNC) ++#define TASK_WORK_CANCEL_FN task_work_cancel_func ++#else ++#define TASK_WORK_CANCEL_FN task_work_cancel ++#endif ++ ++#define STRINGIFY(x) #x ++#define TOSTRING(x) STRINGIFY(x) ++ + #if !defined(STAPCONF_TASK_WORK_ADD_EXPORTED) + // First typedef from the original decls, then #define as typecasted calls. + typedef typeof(&task_work_add) task_work_add_fn; + #define task_work_add(a,b,c) ibt_wrapper(int, (* (task_work_add_fn)kallsyms_task_work_add)((a), (b), (c))) + #endif + #if !defined(STAPCONF_TASK_WORK_CANCEL_EXPORTED) +-typedef typeof(&task_work_cancel) task_work_cancel_fn; +-#define task_work_cancel(a,b) ibt_wrapper(struct callback_head *, (* (task_work_cancel_fn)kallsyms_task_work_cancel)((a), (b))) ++typedef typeof(&TASK_WORK_CANCEL_FN) task_work_cancel_fn; ++#define task_work_cancel(a,b) ibt_wrapper(struct callback_head *, (* (task_work_cancel_fn)kallsyms_task_work_cancel_fn)((a), (b))) + #endif + + /* To avoid a crash when a task_work callback gets called after the +@@ -35,9 +46,9 @@ stp_task_work_init(void) + } + #endif + #if !defined(STAPCONF_TASK_WORK_CANCEL_EXPORTED) +- kallsyms_task_work_cancel = (void *)kallsyms_lookup_name("task_work_cancel"); +- if (kallsyms_task_work_cancel == NULL) { +- _stp_error("Can't resolve task_work_cancel!"); ++ kallsyms_task_work_cancel_fn = (void *)kallsyms_lookup_name(TOSTRING(TASK_WORK_CANCEL_FN)); ++ if (kallsyms_task_work_cancel_fn == NULL) { ++ _stp_error("Can't resolve %s!", TOSTRING(TASK_WORK_CANCEL_FN)); + return -ENOENT; + } + #endif +-- +2.33.0 +
Locations
Projects
Search
Status Monitor
Help
Open Build Service
OBS Manuals
API Documentation
OBS Portal
Reporting a Bug
Contact
Mailing List
Forums
Chat (IRC)
Twitter
Open Build Service (OBS)
is an
openSUSE project
.
浙ICP备2022010568号-2