From ae51d02dd05fae25eadf3abae98284ad02f75458 Mon Sep 17 00:00:00 2001 From: wuzx Date: Wed, 20 Aug 2025 17:10:34 +0800 Subject: [PATCH] add sw64 arch --- systemtap-add-sw.patch | 2158 ++++++++++++++++++++++++++++++++++++++++ systemtap.spec | 6 +- 2 files changed, 2163 insertions(+), 1 deletion(-) create mode 100644 systemtap-add-sw.patch diff --git a/systemtap-add-sw.patch b/systemtap-add-sw.patch new file mode 100644 index 0000000..b430bbe --- /dev/null +++ b/systemtap-add-sw.patch @@ -0,0 +1,2158 @@ +From cc4166b2e20047e53bf2bf5e6d659ce160d0791b Mon Sep 17 00:00:00 2001 +From: wuzx +Date: Wed, 20 Aug 2025 17:00:32 +0800 +Subject: [PATCH] add sw + +--- + build.sh | 106 +++ + config.guess | 4 + + config.sub | 2 + + dwflpp.cxx | 20 +- + runtime/linux/regs.c | 6 + + runtime/linux/runtime.h | 2 +- + runtime/loc2c-runtime.h | 37 + + runtime/regs.h | 11 + + runtime/syscall.h | 56 ++ + runtime/transport/transport.c | 2 +- + runtime/unwind.c | 3 +- + runtime/unwind/sw_64.h | 171 ++++ + runtime/unwind/unwind.h | 2 +- + stap-env | 1 + + tapset/bpf/aux_syscalls.stp | 1 + + tapset/errno.stp | 2 + + tapset/linux/aux_syscalls.stp | 3 +- + tapset/linux/sw_64/aux_syscalls.stp | 37 + + tapset/linux/sw_64/syscall_num.stp | 963 +++++++++++++++++++++++ + tapset/linux/syscalls.stpm | 9 + + tapset/sw_64 | 336 ++++++++ + tapsets.cxx | 38 +- + testsuite/systemtap.base/at_register.stp | 2 +- + testsuite/systemtap.context/num_args.stp | 1 + + 24 files changed, 1800 insertions(+), 15 deletions(-) + create mode 100755 build.sh + create mode 100644 runtime/unwind/sw_64.h + create mode 100644 tapset/linux/sw_64/aux_syscalls.stp + create mode 100644 tapset/linux/sw_64/syscall_num.stp + create mode 100644 tapset/sw_64 + +diff --git a/build.sh b/build.sh +new file mode 100755 +index 0000000..67231b2 +--- /dev/null ++++ b/build.sh +@@ -0,0 +1,106 @@ ++#!/bin/bash ++ ++# echo message with color ++echo_red() { echo -e "\033[31;1m$1\033[0m"; } ++echo_green() { echo -e "\033[32;1m$1\033[0m"; } ++echo_yellow() { echo -e "\033[33;1m$1\033[0m"; } ++ ++# install dependency packages ++install_package_apt() { ++ for i in "$@" ++ do ++ if [ `dpkg -l | grep $i | wc -l` -ne 0 ]; then ++ echo_green "package $i already exists." ++ else ++ sudo apt-get install $i -y ++ if [ $? -eq 0 ]; then ++ echo_green "package $i installed successfully." ++ else ++ echo_yellow "package $i installed FAIL!" ++ fi ++ fi ++ done ++} ++ ++install_package_yum() { ++ for i in "$@" ++ do ++ if [ `rpm -qa | grep $i | wc -l` -ne 0 ]; then ++ echo_green "package $i already exists." ++ else ++ sudo yum -y install $i ++ if [ $? -eq 0 ]; then ++ echo_green "package $i installed successfully." ++ else ++ echo_yellow "package $i installed FAIL!" ++ fi ++ fi ++ done ++} ++ ++install_pkgs() { ++ if type apt >/dev/null 2>&1; then ++ install_package_apt libdw-dev elfutils g++ tcl ++ elif type yum >/dev/null 2>&1; then ++ install_package_yum elfutils-devel ++ else ++ echo_red "no yum or apt!" ++ fi ++} ++ ++# install systemtap ++build_systemtap() ++{ ++ install_pkgs ++ cd ../ && rm -rf build-systemtap && mkdir build-systemtap ++ version=$1; build_type=$2; current_dir=$(pwd) ++ cd build-systemtap ++ case $build_type in ++ "release") ++ CFLAGS="" CXXFLAGS="" ++ ;; ++ "debug") ++ CFLAGS="-g -O0" CXXFLAGS="-g -O0" ++ ;; ++ "static") ++ CFLAGS="-static" CXXFLAGS="-static" ++ ;; ++ *) ++ echo_red "===== Error! =====" ++ ;; ++ esac ++ # If `--prefix` is not specified, the default installation is `/usr/local` ++ ../systemtap-5.3/configure --prefix=$current_dir/install-systemtap ++ make -j$(nproc) && make install ++ if [ $? -eq 0 ]; then ++ echo_green "===== systemtap installed successfully. =====" ++ else ++ echo_red "===== systemtap installed FAIL! =====" ++ fi ++ cd ../ ++} ++ ++function main() ++{ ++ systemtap_version="5.3" ++ case $1 in ++ release | r) ++ build_systemtap $systemtap_version release ++ ;; ++ debug | d) ++ build_systemtap $systemtap_version debug ++ ;; ++ static | s) ++ build_systemtap $systemtap_version static ++ ;; ++ *) ++ echo_green "=============== help message ===============" ++ echo_green " ./build.sh [arg]" ++ echo " release : Release version of systemtap." ++ echo " debug : Debug version of systemtap." ++ echo " static : Static version of systemtap." ++ echo_green "============================================" ++ ;; ++ esac ++} ++main $@ +diff --git a/config.guess b/config.guess +index dc0a6b2..3fa0f38 100755 +--- a/config.guess ++++ b/config.guess +@@ -938,6 +938,10 @@ EOF + UNAME_MACHINE=aarch64_be + echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" + exit ;; ++ sw_64:Linux:*:*) ++ UNAME_MACHINE=sw_64_be ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; + alpha:Linux:*:*) + case $(sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null) in + EV5) UNAME_MACHINE=alphaev5 ;; +diff --git a/config.sub b/config.sub +index 6467c95..5900a3a 100755 +--- a/config.sub ++++ b/config.sub +@@ -251,6 +251,7 @@ case $basic_machine in + | aarch64 | aarch64_be \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ ++ | sw_64 \ + | am33_2.0 \ + | arc | arceb \ + | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ +@@ -374,6 +375,7 @@ case $basic_machine in + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ ++ | sw_64 \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* | avr32-* \ + | be32-* | be64-* \ +diff --git a/dwflpp.cxx b/dwflpp.cxx +index bd92357..7e86fae 100644 +--- a/dwflpp.cxx ++++ b/dwflpp.cxx +@@ -1375,6 +1375,7 @@ dwflpp::iterate_over_libraries(void (*callback)(void*, const char*), + && interpreter != "/lib/ld-linux.so.3" // arm + && interpreter != "/lib/ld-linux-armhf.so.3" // arm + && interpreter != "/lib/ld-linux-aarch64.so.1" // arm64 ++ && interpreter != "/lib/ld-linux.so.2" // sw_64 + && interpreter != "/lib64/ld64.so.2" // ppc64le + ) + { +@@ -2182,7 +2183,7 @@ dwflpp::iterate_over_callees(Dwarf_Die *begin_die, + Dwarf_Addr func_addr; + + // caller's unwind pc during call (to match against bt for filtering) +- Dwarf_Addr caller_uw_addr; ++ Dwarf_Addr caller_uw_addr,caller_uw_addr2; + + Dwarf_Attribute attr; + +@@ -2242,14 +2243,19 @@ dwflpp::iterate_over_callees(Dwarf_Die *begin_die, + // show up in a backtrace (inlines are a special case in which + // the die's low_pc is also the abstract_origin's low_pc = the + // 'start' of the inline instance) +- if (dwarf_lowpc(&die, &caller_uw_addr) != 0 +- && dwarf_lowpc(&origin, &caller_uw_addr) != 0) ++ if (dwarf_lowpc(&die, &caller_uw_addr) != 0 && dwarf_entrypc(&die, &caller_uw_addr2) != 0) + continue; + +- if (inlined) +- func_addr = caller_uw_addr; +- else if (dwarf_lowpc(&origin, &func_addr) != 0) +- { ++ if (!inlined) ++ caller_uw_addr -= 8; ++ if (inlined){ ++ if (dwarf_lowpc(&die, &caller_uw_addr) != 0) ++ func_addr = caller_uw_addr2; ++ else ++ func_addr = caller_uw_addr; ++ } ++ else if (dwarf_lowpc(&origin, &func_addr) != 0) ++ { + // function doesn't have a low_pc, is it external? + if (dwarf_attr_integrate(&origin, DW_AT_external, + &attr) != NULL) +diff --git a/runtime/linux/regs.c b/runtime/linux/regs.c +index f2aaa74..f994215 100644 +--- a/runtime/linux/regs.c ++++ b/runtime/linux/regs.c +@@ -133,6 +133,12 @@ static void _stp_print_regs(struct pt_regs * regs) + _stp_printf ("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4); + } + ++#elif defined (__sw_64__) ++static void _stp_print_regs(struct pt_regs * regs) ++{ ++ _stp_printf("\n"); ++} ++ + #elif defined (__ia64__) + static void _stp_print_regs(struct pt_regs * regs) + { +diff --git a/runtime/linux/runtime.h b/runtime/linux/runtime.h +index bd93073..6d14cf0 100644 +--- a/runtime/linux/runtime.h ++++ b/runtime/linux/runtime.h +@@ -220,7 +220,7 @@ static struct + Only define STP_USE_DWARF_UNWINDER when STP_NEED_UNWIND_DATA, + as set through a pragma:unwind in one of the [u]context-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(sw_64) + #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..6e98660 100644 +--- a/runtime/loc2c-runtime.h ++++ b/runtime/loc2c-runtime.h +@@ -238,6 +238,43 @@ + #define pt_dwarf_register_31(regs) regs->t6 + #define pt_regs_maxno 31 + ++#elif defined (__sw_64__) ++ ++#define pt_dwarf_register_0(pt_regs) pt_regs->regs[0] ++#define pt_dwarf_register_1(pt_regs) pt_regs->regs[1] ++#define pt_dwarf_register_2(pt_regs) pt_regs->regs[2] ++#define pt_dwarf_register_3(pt_regs) pt_regs->regs[3] ++#define pt_dwarf_register_4(pt_regs) pt_regs->regs[4] ++#define pt_dwarf_register_5(pt_regs) pt_regs->regs[5] ++#define pt_dwarf_register_6(pt_regs) pt_regs->regs[6] ++#define pt_dwarf_register_7(pt_regs) pt_regs->regs[7] ++#define pt_dwarf_register_8(pt_regs) pt_regs->regs[8] ++#define pt_dwarf_register_9(pt_regs) pt_regs->regs[9] ++ ++#define pt_dwarf_register_10(pt_regs) pt_regs->regs[10] ++#define pt_dwarf_register_11(pt_regs) pt_regs->regs[11] ++#define pt_dwarf_register_12(pt_regs) pt_regs->regs[12] ++#define pt_dwarf_register_13(pt_regs) pt_regs->regs[13] ++#define pt_dwarf_register_14(pt_regs) pt_regs->regs[14] ++#define pt_dwarf_register_15(pt_regs) pt_regs->regs[15] ++#define pt_dwarf_register_16(pt_regs) pt_regs->regs[16] ++#define pt_dwarf_register_17(pt_regs) pt_regs->regs[17] ++#define pt_dwarf_register_18(pt_regs) pt_regs->regs[18] ++#define pt_dwarf_register_19(pt_regs) pt_regs->regs[19] ++ ++#define pt_dwarf_register_20(pt_regs) pt_regs->regs[20] ++#define pt_dwarf_register_21(pt_regs) pt_regs->regs[21] ++#define pt_dwarf_register_22(pt_regs) pt_regs->regs[22] ++#define pt_dwarf_register_23(pt_regs) pt_regs->regs[23] ++#define pt_dwarf_register_24(pt_regs) pt_regs->regs[24] ++#define pt_dwarf_register_25(pt_regs) pt_regs->regs[25] ++#define pt_dwarf_register_26(pt_regs) pt_regs->regs[26] ++#define pt_dwarf_register_27(pt_regs) pt_regs->regs[27] ++#define pt_dwarf_register_28(pt_regs) pt_regs->regs[28] ++#define pt_dwarf_register_29(pt_regs) pt_regs->regs[29] ++#define pt_dwarf_register_30(pt_regs) pt_regs->regs[30] ++#define pt_regs_maxno 31 ++ + #elif defined (__aarch64__) + + #define pt_dwarf_register_0(pt_regs) pt_regs->regs[0] +diff --git a/runtime/regs.h b/runtime/regs.h +index 5d6b4c6..525b52b 100644 +--- a/runtime/regs.h ++++ b/runtime/regs.h +@@ -28,6 +28,17 @@ + #define REG_SP(regs) regs->esp + #define REG_FP(regs) regs->ebp + ++#elif defined (__sw_64__) ++ ++#define REG_IP(regs) regs->pc ++#define REG_SP(regs) regs->sp ++ ++#ifndef OS510 ++#define REG_SP(regs) regs->sp ++#else ++#define REG_SP(regs_arg) ((regs_arg)->regs[30]) ++#endif ++ + #elif defined (__ia64__) + + #define REG_IP(regs) ((regs)->cr_iip +ia64_psr(regs)->ri) +diff --git a/runtime/syscall.h b/runtime/syscall.h +index 44d8a28..c35eeee 100644 +--- a/runtime/syscall.h ++++ b/runtime/syscall.h +@@ -158,6 +158,14 @@ + #define MREMAP_SYSCALL_NO(tsk) 216 + #endif + ++#if defined(__sw_64__) ++#define MMAP_SYSCALL_NO(tsk) 71 ++#define MMAP2_SYSCALL_NO(tsk) 999999999 //not implemented ++#define MPROTECT_SYSCALL_NO(tsk) 74 ++#define MUNMAP_SYSCALL_NO(tsk) 73 ++#define MREMAP_SYSCALL_NO(tsk) 341 ++#endif ++ // + #if !defined(MMAP_SYSCALL_NO) || !defined(MMAP2_SYSCALL_NO) \ + || !defined(MPROTECT_SYSCALL_NO) || !defined(MUNMAP_SYSCALL_NO) \ + || !defined(MREMAP_SYSCALL_NO) +@@ -180,6 +188,14 @@ _stp_syscall_get_nr(struct task_struct *task, struct pt_regs *regs) + return regs->ARM_r7; + } + ++#elif defined(__sw_64__) ++ ++static inline long ++_stp_syscall_get_nr(struct task_struct *task, struct pt_regs *regs) ++{ ++ return regs->regs[0]; ++} ++ + #elif defined(__mips__) + /* Define our own function as syscall_get_nr always returns 0 unless + * ftrace syscall tracing has been enabled */ +@@ -464,6 +480,46 @@ _stp_syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, + } + #endif + ++#if defined(__sw_64__) ++static inline void _stp_syscall_get_arguments(struct task_struct *task, ++ struct pt_regs *regs, unsigned int i, ++ unsigned int n, unsigned long *args) ++{ ++ switch (i) { ++ case 0: ++ if (!n--) ++ break; ++ *args++ = regs->r16; ++ case 1: ++ if (!n--) ++ break; ++ *args++ = regs->r17; ++ case 2: ++ if (!n--) ++ break; ++ *args++ = regs->r18; ++ case 3: ++ if (!n--) ++ break; ++ *args++ = regs->r19; ++ case 4: ++ if (!n--) ++ break; ++ *args++ = regs->r20; ++ case 5: ++ if (!n--) ++ break; ++ *args++ = regs->r21; ++ case 6: ++ if (!n--) ++ break; ++ default: ++ BUG(); ++ break; ++ } ++} ++ ++#endif + #if defined(__powerpc__) + static inline void + _stp_syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, +diff --git a/runtime/transport/transport.c b/runtime/transport/transport.c +index 2fb6dfa..167adc3 100644 +--- a/runtime/transport/transport.c ++++ b/runtime/transport/transport.c +@@ -24,7 +24,7 @@ + #ifdef STAPCONF_LOCKDOWN_DEBUGFS + #include + #endif +-#ifdef STAPCONF_514_PANIC ++#ifndef STAPCONF_514_PANIC + #include + #endif + #include "../uidgid_compatibility.h" +diff --git a/runtime/unwind.c b/runtime/unwind.c +index 6916d2e..9531bc7 100644 +--- a/runtime/unwind.c ++++ b/runtime/unwind.c +@@ -1534,7 +1534,8 @@ static int unwind(struct unwind_context *context, int user) + dbug_unwind(1, "trying debug_frame\n"); + res = unwind_frame (context, m, s, m->debug_frame, + m->debug_frame_len, 0, user, compat_task); +- if (res != 0) { ++ if ( (res != 0) && (user > 0) ) { ++// if (res != 0) { + dbug_unwind(1, "debug_frame failed: %d, trying eh_frame\n", res); + res = unwind_frame (context, m, s, m->eh_frame, + m->eh_frame_len, 1, user, compat_task); +diff --git a/runtime/unwind/sw_64.h b/runtime/unwind/sw_64.h +new file mode 100644 +index 0000000..e1fd69e +--- /dev/null ++++ b/runtime/unwind/sw_64.h +@@ -0,0 +1,171 @@ ++/* -*- linux-c -*- ++ * ++ * SW_64 dwarf unwinder header file ++ * Copyright (C) 2011 Red Hat, Inc. ++ * ++ * 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_SW_64_UNWIND_H ++#define _STP_SW_64_UNWIND_H ++ ++#include ++#include ++ ++#define _stp_get_unaligned(ptr) (*(ptr)) ++#ifdef OS510 ++ ++#define UNW_PC(frame) (frame)->regs.pc ++#define UNW_SP(frame) (frame)->regs.regs[30] ++#define UNW_GP(frame) (frame)->regs.gp ++#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) ++ ++#define UNW_REGISTER_INFO \ ++ PTREGS_INFO(regs[0]), \ ++ PTREGS_INFO(regs[1]), \ ++ PTREGS_INFO(regs[2]), \ ++ PTREGS_INFO(regs[3]), \ ++ PTREGS_INFO(regs[4]), \ ++ PTREGS_INFO(regs[5]), \ ++ PTREGS_INFO(regs[6]), \ ++ PTREGS_INFO(regs[7]), \ ++ PTREGS_INFO(regs[8]), \ ++ PTREGS_INFO(regs[9]), \ ++ PTREGS_INFO(regs[10]), \ ++ PTREGS_INFO(regs[11]), \ ++ PTREGS_INFO(regs[12]), \ ++ PTREGS_INFO(regs[13]), \ ++ PTREGS_INFO(regs[14]), \ ++ PTREGS_INFO(regs[15]), \ ++ PTREGS_INFO(regs[16]), \ ++ PTREGS_INFO(regs[17]), \ ++ PTREGS_INFO(regs[18]), \ ++ PTREGS_INFO(regs[19]), \ ++ PTREGS_INFO(regs[20]), \ ++ PTREGS_INFO(regs[21]), \ ++ PTREGS_INFO(regs[22]), \ ++ PTREGS_INFO(regs[23]), \ ++ PTREGS_INFO(regs[24]), \ ++ PTREGS_INFO(regs[25]), \ ++ PTREGS_INFO(regs[26]), \ ++ PTREGS_INFO(regs[27]), \ ++ PTREGS_INFO(regs[28]), \ ++ PTREGS_INFO(regs[29]), \ ++ PTREGS_INFO(regs[30]), \ ++ PTREGS_INFO(regs[31]), \ ++ PTREGS_INFO(pc) ++ ++#define DWARF_REG_MAP(r) \ ++ ((r >= 0 && r <= 32) ? r /* regs[0-30] + sp */ \ ++ : 9999) ++ ++#define UNW_PC_IDX 32 ++#define UNW_SP_IDX 30 ++#define UNW_GP_IDX 29 ++ ++#else ++ ++#define UNW_PC(frame) (frame)->regs.pc ++#define UNW_SP(frame) (frame)->regs.sp ++#define UNW_GP(frame) (frame)->regs.gp ++#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) ++ ++#define UNW_REGISTER_INFO \ ++ PTREGS_INFO(r0), \ ++ PTREGS_INFO(r1), \ ++ PTREGS_INFO(r2), \ ++ PTREGS_INFO(r3), \ ++ PTREGS_INFO(r4), \ ++ PTREGS_INFO(r5), \ ++ PTREGS_INFO(r6), \ ++ PTREGS_INFO(r7), \ ++ PTREGS_INFO(r8), \ ++ PTREGS_INFO(r9), \ ++ PTREGS_INFO(r10), \ ++ PTREGS_INFO(r11), \ ++ PTREGS_INFO(r12), \ ++ PTREGS_INFO(r13), \ ++ PTREGS_INFO(r14), \ ++ PTREGS_INFO(r15), \ ++ PTREGS_INFO(r16), \ ++ PTREGS_INFO(r17), \ ++ PTREGS_INFO(r18), \ ++ PTREGS_INFO(r19), \ ++ PTREGS_INFO(r20), \ ++ PTREGS_INFO(r21), \ ++ PTREGS_INFO(r22), \ ++ PTREGS_INFO(r23), \ ++ PTREGS_INFO(r24), \ ++ PTREGS_INFO(r25), \ ++ PTREGS_INFO(r26), \ ++ PTREGS_INFO(r27), \ ++ PTREGS_INFO(r28), \ ++ PTREGS_INFO(gp), \ ++ PTREGS_INFO(sp), \ ++ PTREGS_INFO(pc), \ ++ ++#define DWARF_REG_MAP(r) \ ++ ((r >= 0 && r <= 31) ? r \ ++ : 9999) ++ ++#define UNW_PC_IDX 31 ++#define UNW_SP_IDX 30 ++#define UNW_GP_IDX 29 ++#endif ++ ++static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, ++ /*const*/ struct pt_regs *regs, ++ int sanitize) ++{ ++ ++ /* if(regs == NULL){ ++ asm("stl $r0, 0(%2) \n\t" ++ "stl $r1, 8(%2) \n\t" ++ "stl $r2, 16(%2) \n\t" ++ "stl $r3, 24(%2) \n\t" ++ "stl $r4, 32(%2) \n\t" ++ "stl $r5, 40(%2) \n\t" ++ "stl $r6, 48(%2) \n\t" ++ "stl $r7, 56(%2) \n\t" ++ "stl $r8, 64(%2) \n\t" ++ "stl $r9, 72(%2) \n\t" ++ "stl $r10, 80(%2) \n\t" ++ "stl $r11, 88(%2) \n\t" ++ "stl $r12, 96(%2) \n\t" ++ "stl $r13, 104(%2) \n\t" ++ "stl $r14, 112(%2) \n\t" ++ "stl $r15, 120(%2) \n\t" ++ "stl $r16, 128(%2) \n\t" ++ "stl $r17, 136(%2) \n\t" ++ "stl $r18, 144(%2) \n\t" ++ "stl $r19, 152(%2) \n\t" ++ "stl $r20, 160(%2) \n\t" ++ "stl $r21, 168(%2) \n\t" ++ "stl $r22, 176(%2) \n\t" ++ "stl $r23, 184(%2) \n\t" ++ "stl $r24, 192(%2) \n\t" ++ "stl $r25, 200(%2) \n\t" ++ "stl $r26, 208(%2) \n\t" ++ "stl $r27, 216(%2) \n\t" ++ "stl $r28, 224(%2) \n\t" ++ "stl gp, 232(%2) \n\t" ++ "stl sp, 240(%2) \n\t" ++ "stl pc, 248(%2) \n\t" ++ : "=m" (info->regs), ++ "=r" (info->regs.pc) ++ : "r" (&info->regs) ++ ); ++ return; ++ }*/ ++ if (&info->regs == regs) { /* happens when unwinding kernel->user */ ++ info->call_frame = 1; ++ return; ++ } ++ ++ memset(info, 0, sizeof(*info)); ++ info->regs = *regs; ++} ++ ++#endif /* _STP_SW_64_UNWIND_H */ +diff --git a/runtime/unwind/unwind.h b/runtime/unwind/unwind.h +index 1c77b50..6be1f95 100644 +--- a/runtime/unwind/unwind.h ++++ b/runtime/unwind/unwind.h +@@ -516,7 +516,7 @@ struct unwind_context { + struct uw_state state; + }; + +-static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 }; ++static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 0 }; + #else /* !STP_USE_DWARF_UNWINDER */ + struct unwind_context { }; + #endif /* !STP_USE_DWARF_UNWINDER */ +diff --git a/stap-env b/stap-env +index c65c3f6..b383dfa 100755 +--- a/stap-env ++++ b/stap-env +@@ -48,6 +48,7 @@ function stap_get_arch { + s390*) machine="s390" ;; + aarch64) machine="arm64" ;; + ppc*) machine="powerpc" ;; ++ sw_64*) machine="sw_64" ;; + mips*) machine="mips" ;; + sh?) machine="sh" ;; + # the default is to just use the output of 'uname -m' +diff --git a/tapset/bpf/aux_syscalls.stp b/tapset/bpf/aux_syscalls.stp +index bc0922c..62cd4ca 100644 +--- a/tapset/bpf/aux_syscalls.stp ++++ b/tapset/bpf/aux_syscalls.stp +@@ -8,5 +8,6 @@ function _stp_bpf_syscall_get_nr:long(regs:long) + @choose_defined(@cast(regs, "struct pt_regs", "kernel")->gpr[0], //__powerpc__ + @choose_defined(@cast(regs, "struct pt_regs", "kernel")->gprs[2], // __s390__ || __s390x__ + @choose_defined(@cast(regs, "struct pt_regs", "kernel")->syscallno, // __aarch64__ ++ @choose_defined(@cast(regs, "struct pt_regs", "kernel")->r0, + @cast(regs, "struct pt_regs", "kernel")->a7)))))))); // __riscv__ + } +diff --git a/tapset/errno.stp b/tapset/errno.stp +index a75e3ba..03bf1cb 100644 +--- a/tapset/errno.stp ++++ b/tapset/errno.stp +@@ -390,6 +390,8 @@ static long _stp_returnval(struct pt_regs *regs) { + return regs->regs[0]; + #elif defined (__arm__) + return regs->ARM_r0; ++#elif defined (__sw_64__) ++ return regs->regs[0]; + #elif defined (__mips__) + return regs->regs[2]; + #else +diff --git a/tapset/linux/aux_syscalls.stp b/tapset/linux/aux_syscalls.stp +index fa915af..fb1d034 100644 +--- a/tapset/linux/aux_syscalls.stp ++++ b/tapset/linux/aux_syscalls.stp +@@ -3584,7 +3584,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(__SW_64__) + slen = strlen(ptr); + _stp_snprintf(ptr + slen, len - slen, + "0x%lx, ", (long)act->sa_restorer); +@@ -5872,6 +5872,7 @@ static const _stp_val_array _stp_kexec_flags_list[] = { + V(KEXEC_ARCH_386), + V(KEXEC_ARCH_X86_64), + V(KEXEC_ARCH_PPC), ++ V(KEXEC_ARCH_SW64), + V(KEXEC_ARCH_PPC64), + V(KEXEC_ARCH_IA_64), + #ifdef KEXEC_ARCH_ARM +diff --git a/tapset/linux/sw_64/aux_syscalls.stp b/tapset/linux/sw_64/aux_syscalls.stp +new file mode 100644 +index 0000000..74734fa +--- /dev/null ++++ b/tapset/linux/sw_64/aux_syscalls.stp +@@ -0,0 +1,37 @@ ++# arch-specific requests of ptrace ___________________________ ++# ++%{ ++// Get _stp_val_array and _stp_lookup_* definitions. ++#include "linux/syscalls-common.h" ++ ++static const _stp_val_array _stp_arch_ptrace_request_list[] = { ++ V(PTRACE_PEEKUSR), ++ V(PTRACE_POKEUSR), ++ {0, NULL} ++}; ++%} ++ ++function __arch_ptrace_request_str:string(request:long) ++%{ /* pure */ ++ _stp_lookup_str(_stp_arch_ptrace_request_list, ++ (unsigned long)STAP_ARG_request, STAP_RETVALUE, ++ MAXSTRINGLEN); ++%} ++ ++function _arch_ptrace_argstr(request, pid, addr, data) ++{ ++ if (request == @const("PTRACE_PEEKUSR") ++ || request == @const("PTRACE_POKEUSR")) ++ return sprintf("%s, %d, %#x, %p", ++ __arch_ptrace_request_str(request), pid, ++ addr, data) ++/* if (request == @const("PTRACE_SET_DEBUGREG")) ++ return sprintf("PTRACE_SET_DEBUGREG, %d, %#x, %#x", pid, ++ addr, data) ++*/ ++} ++ ++function _ptrace_return_arch_prctl_addr:long(request:long, addr:long, data:long) ++{ ++ return 0 ++} +diff --git a/tapset/linux/sw_64/syscall_num.stp b/tapset/linux/sw_64/syscall_num.stp +new file mode 100644 +index 0000000..310c99f +--- /dev/null ++++ b/tapset/linux/sw_64/syscall_num.stp +@@ -0,0 +1,963 @@ ++# This is arch specific syscall table generated by scripts/dump-syscalls.sh ++ ++%( arch =="sw_64" %? ++global __syscall_64_num2name[476] ++global __syscall_64_name2num[476] ++%) ++ ++probe init { ++%( arch =="sw_64" %? ++__syscall_64_num2name[319]="_sysctl" ++__syscall_64_name2num["_sysctl"]=319 ++__syscall_64_num2name[99]="accept" ++__syscall_64_name2num["accept"]=99 ++__syscall_64_num2name[502]="accept4" ++__syscall_64_name2num["accept4"]=502 ++__syscall_64_num2name[33]="access" ++__syscall_64_name2num["access"]=33 ++__syscall_64_num2name[51]="acct" ++__syscall_64_name2num["acct"]=51 ++__syscall_64_num2name[439]="add_key" ++__syscall_64_name2num["add_key"]=439 ++__syscall_64_num2name[366]="adjtimex" ++__syscall_64_name2num["adjtimex"]=366 ++__syscall_64_num2name[338]="afs_syscall" ++__syscall_64_name2num["afs_syscall"]=338 ++__syscall_64_num2name[300]="bdflush" ++__syscall_64_name2num["bdflush"]=300 ++__syscall_64_num2name[104]="bind" ++__syscall_64_name2num["bind"]=104 ++__syscall_64_num2name[515]="bpf" ++__syscall_64_name2num["bpf"]=515 ++__syscall_64_num2name[17]="brk" ++__syscall_64_name2num["brk"]=17 ++__syscall_64_num2name[368]="capget" ++__syscall_64_name2num["capget"]=368 ++__syscall_64_num2name[369]="capset" ++__syscall_64_name2num["capset"]=369 ++__syscall_64_num2name[12]="chdir" ++__syscall_64_name2num["chdir"]=12 ++__syscall_64_num2name[15]="chmod" ++__syscall_64_name2num["chmod"]=15 ++__syscall_64_num2name[16]="chown" ++__syscall_64_name2num["chown"]=16 ++__syscall_64_num2name[61]="chroot" ++__syscall_64_name2num["chroot"]=61 ++__syscall_64_num2name[499]="clock_adjtime" ++__syscall_64_name2num["clock_adjtime"]=499 ++__syscall_64_num2name[421]="clock_getres" ++__syscall_64_name2num["clock_getres"]=421 ++__syscall_64_num2name[420]="clock_gettime" ++__syscall_64_name2num["clock_gettime"]=420 ++__syscall_64_num2name[422]="clock_nanosleep" ++__syscall_64_name2num["clock_nanosleep"]=422 ++__syscall_64_num2name[419]="clock_settime" ++__syscall_64_name2num["clock_settime"]=419 ++__syscall_64_num2name[312]="clone" ++__syscall_64_name2num["clone"]=312 ++__syscall_64_num2name[110+435]="clone3" ++__syscall_64_name2num["clone3"]=110+435 ++__syscall_64_num2name[6]="close" ++__syscall_64_name2num["close"]=6 ++__syscall_64_num2name[110+436]="close_range" ++__syscall_64_name2num["close_range"]=110+436 ++__syscall_64_num2name[98]="connect" ++__syscall_64_name2num["connect"]=98 ++__syscall_64_num2name[519]="copy_file_range" ++__syscall_64_name2num["copy_file_range"]=519 ++__syscall_64_num2name[306]="create_module" ++__syscall_64_name2num["create_module"]=306 ++__syscall_64_num2name[308]="delete_module" ++__syscall_64_name2num["delete_module"]=308 ++__syscall_64_num2name[373]="dipc" ++__syscall_64_name2num["dipc"]=373 ++__syscall_64_num2name[41]="dup" ++__syscall_64_name2num["dup"]=41 ++__syscall_64_num2name[90]="dup2" ++__syscall_64_name2num["dup2"]=90 ++__syscall_64_num2name[487]="dup3" ++__syscall_64_name2num["dup3"]=487 ++__syscall_64_num2name[407]="epoll_create" ++__syscall_64_name2num["epoll_create"]=407 ++__syscall_64_num2name[486]="epoll_create1" ++__syscall_64_name2num["epoll_create1"]=486 ++__syscall_64_num2name[408]="epoll_ctl" ++__syscall_64_name2num["epoll_ctl"]=408 ++__syscall_64_num2name[474]="epoll_pwait" ++__syscall_64_name2num["epoll_pwait"]=474 ++__syscall_64_num2name[110+441]="epoll_pwait2" ++__syscall_64_name2num["epoll_pwait2"]=110+441 ++__syscall_64_num2name[409]="epoll_wait" ++__syscall_64_name2num["epoll_wait"]=409 ++__syscall_64_num2name[478]="eventfd" ++__syscall_64_name2num["eventfd"]=478 ++__syscall_64_num2name[485]="eventfd2" ++__syscall_64_name2num["eventfd2"]=485 ++__syscall_64_num2name[25]="exec_with_loader" ++__syscall_64_name2num["exec_with_loader"]=25 ++__syscall_64_num2name[59]="execve" ++__syscall_64_name2num["execve"]=59 ++__syscall_64_num2name[513]="execveat" ++__syscall_64_name2num["execveat"]=513 ++__syscall_64_num2name[1]="exit" ++__syscall_64_name2num["exit"]=1 ++__syscall_64_num2name[405]="exit_group" ++__syscall_64_name2num["exit_group"]=405 ++__syscall_64_num2name[462]="faccessat" ++__syscall_64_name2num["faccessat"]=462 ++__syscall_64_num2name[110+439]="faccessat2" ++__syscall_64_name2num["faccessat2"]=110+439 ++__syscall_64_num2name[413]="fadvise64" ++__syscall_64_name2num["fadvise64"]=413 ++__syscall_64_num2name[480]="fallocate" ++__syscall_64_name2num["fallocate"]=480 ++__syscall_64_num2name[494]="fanotify_init" ++__syscall_64_name2num["fanotify_init"]=494 ++__syscall_64_num2name[495]="fanotify_mark" ++__syscall_64_name2num["fanotify_mark"]=495 ++__syscall_64_num2name[13]="fchdir" ++__syscall_64_name2num["fchdir"]=13 ++__syscall_64_num2name[124]="fchmod" ++__syscall_64_name2num["fchmod"]=124 ++__syscall_64_num2name[461]="fchmodat" ++__syscall_64_name2num["fchmodat"]=461 ++__syscall_64_num2name[123]="fchown" ++__syscall_64_name2num["fchown"]=123 ++__syscall_64_num2name[453]="fchownat" ++__syscall_64_name2num["fchownat"]=453 ++__syscall_64_num2name[92]="fcntl" ++__syscall_64_name2num["fcntl"]=92 ++__syscall_64_num2name[447]="fdatasync" ++__syscall_64_name2num["fdatasync"]=447 ++__syscall_64_num2name[387]="fgetxattr" ++__syscall_64_name2num["fgetxattr"]=387 ++__syscall_64_num2name[507]="finit_module" ++__syscall_64_name2num["finit_module"]=507 ++__syscall_64_num2name[390]="flistxattr" ++__syscall_64_name2num["flistxattr"]=390 ++__syscall_64_num2name[131]="flock" ++__syscall_64_name2num["flock"]=131 ++__syscall_64_num2name[2]="fork" ++__syscall_64_name2num["fork"]=2 ++__syscall_64_num2name[393]="fremovexattr" ++__syscall_64_name2num["fremovexattr"]=393 ++__syscall_64_num2name[110+431]="fsconfig" ++__syscall_64_name2num["fsconfig"]=110+431 ++__syscall_64_num2name[384]="fsetxattr" ++__syscall_64_name2num["fsetxattr"]=384 ++__syscall_64_num2name[110+432]="fsmount" ++__syscall_64_name2num["fsmount"]=110+432 ++__syscall_64_num2name[110+430]="fsopen" ++__syscall_64_name2num["fsopen"]=110+430 ++__syscall_64_num2name[110+433]="fspick" ++__syscall_64_name2num["fspick"]=110+433 ++__syscall_64_num2name[91]="fstat" ++__syscall_64_name2num["fstat"]=91 ++__syscall_64_num2name[427]="fstat64" ++__syscall_64_name2num["fstat64"]=427 ++__syscall_64_num2name[455]="fstatat64" ++__syscall_64_name2num["fstatat64"]=455 ++__syscall_64_num2name[329]="fstatfs" ++__syscall_64_name2num["fstatfs"]=329 ++__syscall_64_num2name[529]="fstatfs64" ++__syscall_64_name2num["fstatfs64"]=529 ++__syscall_64_num2name[95]="fsync" ++__syscall_64_name2num["fsync"]=95 ++__syscall_64_num2name[130]="ftruncate" ++__syscall_64_name2num["ftruncate"]=130 ++__syscall_64_num2name[394]="futex" ++__syscall_64_name2num["futex"]=394 ++__syscall_64_num2name[454]="futimesat" ++__syscall_64_name2num["futimesat"]=454 ++__syscall_64_num2name[309]="get_kernel_syms" ++__syscall_64_name2num["get_kernel_syms"]=309 ++__syscall_64_num2name[430]="get_mempolicy" ++__syscall_64_name2num["get_mempolicy"]=430 ++__syscall_64_num2name[467]="get_robust_list" ++__syscall_64_name2num["get_robust_list"]=467 ++__syscall_64_num2name[473]="getcpu" ++__syscall_64_name2num["getcpu"]=473 ++__syscall_64_num2name[367]="getcwd" ++__syscall_64_name2num["getcwd"]=367 ++__syscall_64_num2name[305]="getdents" ++__syscall_64_name2num["getdents"]=305 ++__syscall_64_num2name[377]="getdents64" ++__syscall_64_name2num["getdents64"]=377 ++__syscall_64_num2name[89]="getdtablesize" ++__syscall_64_name2num["getdtablesize"]=89 ++__syscall_64_num2name[530]="getegid" ++__syscall_64_name2num["getegid"]=530 ++__syscall_64_num2name[531]="geteuid" ++__syscall_64_name2num["geteuid"]=531 ++__syscall_64_num2name[79]="getgroups" ++__syscall_64_name2num["getgroups"]=79 ++__syscall_64_num2name[87]="gethostname" ++__syscall_64_name2num["gethostname"]=87 ++__syscall_64_num2name[361]="getitimer" ++__syscall_64_name2num["getitimer"]=361 ++__syscall_64_num2name[64]="getpagesize" ++__syscall_64_name2num["getpagesize"]=64 ++__syscall_64_num2name[141]="getpeername" ++__syscall_64_name2num["getpeername"]=141 ++__syscall_64_num2name[233]="getpgid" ++__syscall_64_name2num["getpgid"]=233 ++__syscall_64_num2name[63]="getpgrp" ++__syscall_64_name2num["getpgrp"]=63 ++__syscall_64_num2name[532]="getppid" ++__syscall_64_name2num["getppid"]=532 ++__syscall_64_num2name[100]="getpriority" ++__syscall_64_name2num["getpriority"]=100 ++__syscall_64_num2name[511]="getrandom" ++__syscall_64_name2num["getrandom"]=511 ++__syscall_64_num2name[372]="getresgid" ++__syscall_64_name2num["getresgid"]=372 ++__syscall_64_num2name[344]="getresuid" ++__syscall_64_name2num["getresuid"]=344 ++__syscall_64_num2name[144]="getrlimit" ++__syscall_64_name2num["getrlimit"]=144 ++__syscall_64_num2name[364]="getrusage" ++__syscall_64_name2num["getrusage"]=364 ++__syscall_64_num2name[234]="getsid" ++__syscall_64_name2num["getsid"]=234 ++__syscall_64_num2name[150]="getsockname" ++__syscall_64_name2num["getsockname"]=150 ++__syscall_64_num2name[118]="getsockopt" ++__syscall_64_name2num["getsockopt"]=118 ++__syscall_64_num2name[378]="gettid" ++__syscall_64_name2num["gettid"]=378 ++__syscall_64_num2name[359]="gettimeofday" ++__syscall_64_name2num["gettimeofday"]=359 ++__syscall_64_num2name[385]="getxattr" ++__syscall_64_name2num["getxattr"]=385 ++__syscall_64_num2name[47]="getxgid" ++__syscall_64_name2num["getxgid"]=47 ++__syscall_64_num2name[20]="getxpid" ++__syscall_64_name2num["getxpid"]=20 ++__syscall_64_num2name[24]="getxuid" ++__syscall_64_name2num["getxuid"]=24 ++__syscall_64_num2name[307]="init_module" ++__syscall_64_name2num["init_module"]=307 ++__syscall_64_num2name[445]="inotify_add_watch" ++__syscall_64_name2num["inotify_add_watch"]=445 ++__syscall_64_num2name[444]="inotify_init" ++__syscall_64_name2num["inotify_init"]=444 ++__syscall_64_num2name[489]="inotify_init1" ++__syscall_64_name2num["inotify_init1"]=489 ++__syscall_64_num2name[446]="inotify_rm_watch" ++__syscall_64_name2num["inotify_rm_watch"]=446 ++__syscall_64_num2name[402]="io_cancel" ++__syscall_64_name2num["io_cancel"]=402 ++__syscall_64_num2name[399]="io_destroy" ++__syscall_64_name2num["io_destroy"]=399 ++__syscall_64_num2name[400]="io_getevents" ++__syscall_64_name2num["io_getevents"]=400 ++__syscall_64_num2name[523]="io_pgetevents" ++__syscall_64_name2num["io_pgetevents"]=523 ++__syscall_64_num2name[398]="io_setup" ++__syscall_64_name2num["io_setup"]=398 ++__syscall_64_num2name[401]="io_submit" ++__syscall_64_name2num["io_submit"]=401 ++__syscall_64_num2name[110+426]="io_uring_enter" ++__syscall_64_name2num["io_uring_enter"]=110+426 ++__syscall_64_num2name[110+427]="io_uring_register" ++__syscall_64_name2num["io_uring_register"]=110+427 ++__syscall_64_num2name[110+425]="io_uring_setup" ++__syscall_64_name2num["io_uring_setup"]=110+425 ++__syscall_64_num2name[54]="ioctl" ++__syscall_64_name2num["ioctl"]=54 ++__syscall_64_num2name[443]="ioprio_get" ++__syscall_64_name2num["ioprio_get"]=443 ++__syscall_64_num2name[442]="ioprio_set" ++__syscall_64_name2num["ioprio_set"]=442 ++__syscall_64_num2name[506]="kcmp" ++__syscall_64_name2num["kcmp"]=506 ++__syscall_64_num2name[448]="kexec_load" ++__syscall_64_name2num["kexec_load"]=448 ++__syscall_64_num2name[441]="keyctl" ++__syscall_64_name2num["keyctl"]=441 ++__syscall_64_num2name[37]="kill" ++__syscall_64_name2num["kill"]=37 ++__syscall_64_num2name[110+445]="landlock_add_rule" ++__syscall_64_name2num["landlock_add_rule"]=110+445 ++__syscall_64_num2name[110+444]="landlock_create_ruleset" ++__syscall_64_name2num["landlock_create_ruleset"]=110+444 ++__syscall_64_num2name[110+446]="landlock_restrict_self" ++__syscall_64_name2num["landlock_restrict_self"]=110+446 ++__syscall_64_num2name[208]="lchown" ++__syscall_64_name2num["lchown"]=208 ++__syscall_64_num2name[386]="lgetxattr" ++__syscall_64_name2num["lgetxattr"]=386 ++__syscall_64_num2name[9]="link" ++__syscall_64_name2num["link"]=9 ++__syscall_64_num2name[458]="linkat" ++__syscall_64_name2num["linkat"]=458 ++__syscall_64_num2name[106]="listen" ++__syscall_64_name2num["listen"]=106 ++__syscall_64_num2name[388]="listxattr" ++__syscall_64_name2num["listxattr"]=388 ++__syscall_64_num2name[389]="llistxattr" ++__syscall_64_name2num["llistxattr"]=389 ++__syscall_64_num2name[406]="lookup_dcookie" ++__syscall_64_name2num["lookup_dcookie"]=406 ++__syscall_64_num2name[392]="lremovexattr" ++__syscall_64_name2num["lremovexattr"]=392 ++__syscall_64_num2name[19]="lseek" ++__syscall_64_name2num["lseek"]=19 ++__syscall_64_num2name[383]="lsetxattr" ++__syscall_64_name2num["lsetxattr"]=383 ++__syscall_64_num2name[68]="lstat" ++__syscall_64_name2num["lstat"]=68 ++__syscall_64_num2name[426]="lstat64" ++__syscall_64_name2num["lstat64"]=426 ++__syscall_64_num2name[75]="madvise" ++__syscall_64_name2num["madvise"]=75 ++__syscall_64_num2name[429]="mbind" ++__syscall_64_name2num["mbind"]=429 ++__syscall_64_num2name[517]="membarrier" ++__syscall_64_name2num["membarrier"]=517 ++__syscall_64_num2name[512]="memfd_create" ++__syscall_64_name2num["memfd_create"]=512 ++__syscall_64_num2name[110+447]="memfd_secret" ++__syscall_64_name2num["memfd_secret"]=110+447 ++__syscall_64_num2name[449]="migrate_pages" ++__syscall_64_name2num["migrate_pages"]=449 ++__syscall_64_num2name[375]="mincore" ++__syscall_64_name2num["mincore"]=375 ++__syscall_64_num2name[136]="mkdir" ++__syscall_64_name2num["mkdir"]=136 ++__syscall_64_num2name[451]="mkdirat" ++__syscall_64_name2num["mkdirat"]=451 ++__syscall_64_num2name[14]="mknod" ++__syscall_64_name2num["mknod"]=14 ++__syscall_64_num2name[452]="mknodat" ++__syscall_64_name2num["mknodat"]=452 ++__syscall_64_num2name[314]="mlock" ++__syscall_64_name2num["mlock"]=314 ++__syscall_64_num2name[518]="mlock2" ++__syscall_64_name2num["mlock2"]=518 ++__syscall_64_num2name[316]="mlockall" ++__syscall_64_name2num["mlockall"]=316 ++__syscall_64_num2name[71]="mmap" ++__syscall_64_name2num["mmap"]=71 ++__syscall_64_num2name[302]="mount" ++__syscall_64_name2num["mount"]=302 ++__syscall_64_num2name[110+442]="mount_setattr" ++__syscall_64_name2num["mount_setattr"]=110+442 ++__syscall_64_num2name[110+429]="move_mount" ++__syscall_64_name2num["move_mount"]=110+429 ++__syscall_64_num2name[472]="move_pages" ++__syscall_64_name2num["move_pages"]=472 ++__syscall_64_num2name[74]="mprotect" ++__syscall_64_name2num["mprotect"]=74 ++__syscall_64_num2name[437]="mq_getsetattr" ++__syscall_64_name2num["mq_getsetattr"]=437 ++__syscall_64_num2name[436]="mq_notify" ++__syscall_64_name2num["mq_notify"]=436 ++__syscall_64_num2name[432]="mq_open" ++__syscall_64_name2num["mq_open"]=432 ++__syscall_64_num2name[435]="mq_timedreceive" ++__syscall_64_name2num["mq_timedreceive"]=435 ++__syscall_64_num2name[434]="mq_timedsend" ++__syscall_64_name2num["mq_timedsend"]=434 ++__syscall_64_num2name[433]="mq_unlink" ++__syscall_64_name2num["mq_unlink"]=433 ++__syscall_64_num2name[341]="mremap" ++__syscall_64_name2num["mremap"]=341 ++__syscall_64_num2name[200]="msgctl" ++__syscall_64_name2num["msgctl"]=200 ++__syscall_64_num2name[201]="msgget" ++__syscall_64_name2num["msgget"]=201 ++__syscall_64_num2name[202]="msgrcv" ++__syscall_64_name2num["msgrcv"]=202 ++__syscall_64_num2name[203]="msgsnd" ++__syscall_64_name2num["msgsnd"]=203 ++__syscall_64_num2name[217]="msync" ++__syscall_64_name2num["msync"]=217 ++__syscall_64_num2name[315]="munlock" ++__syscall_64_name2num["munlock"]=315 ++__syscall_64_num2name[317]="munlockall" ++__syscall_64_name2num["munlockall"]=317 ++__syscall_64_num2name[73]="munmap" ++__syscall_64_name2num["munmap"]=73 ++__syscall_64_num2name[497]="name_to_handle_at" ++__syscall_64_name2num["name_to_handle_at"]=497 ++__syscall_64_num2name[340]="nanosleep" ++__syscall_64_name2num["nanosleep"]=340 ++__syscall_64_num2name[342]="nfsservctl" ++__syscall_64_name2num["nfsservctl"]=342 ++__syscall_64_num2name[303]="old_adjtimex" ++__syscall_64_name2num["old_adjtimex"]=303 ++__syscall_64_num2name[321]="oldumount" ++__syscall_64_name2num["oldumount"]=321 ++__syscall_64_num2name[45]="open" ++__syscall_64_name2num["open"]=45 ++__syscall_64_num2name[498]="open_by_handle_at" ++__syscall_64_name2num["open_by_handle_at"]=498 ++__syscall_64_num2name[110+428]="open_tree" ++__syscall_64_name2num["open_tree"]=110+428 ++__syscall_64_num2name[450]="openat" ++__syscall_64_name2num["openat"]=450 ++__syscall_64_num2name[110+437]="openat2" ++__syscall_64_name2num["openat2"]=110+437 ++__syscall_64_num2name[140]="osf_adjtime" ++__syscall_64_name2num["osf_adjtime"]=140 ++__syscall_64_num2name[258]="osf_afs_syscall" ++__syscall_64_name2num["osf_afs_syscall"]=258 ++__syscall_64_num2name[181]="osf_alt_plock" ++__syscall_64_name2num["osf_alt_plock"]=181 ++__syscall_64_num2name[188]="osf_alt_setsid" ++__syscall_64_name2num["osf_alt_setsid"]=188 ++__syscall_64_num2name[187]="osf_alt_sigpending" ++__syscall_64_name2num["osf_alt_sigpending"]=187 ++__syscall_64_num2name[163]="osf_asynch_daemon" ++__syscall_64_name2num["osf_asynch_daemon"]=163 ++__syscall_64_num2name[252]="osf_audcntl" ++__syscall_64_name2num["osf_audcntl"]=252 ++__syscall_64_num2name[253]="osf_audgen" ++__syscall_64_name2num["osf_audgen"]=253 ++__syscall_64_num2name[34]="osf_chflags" ++__syscall_64_name2num["osf_chflags"]=34 ++__syscall_64_num2name[11]="osf_execve" ++__syscall_64_name2num["osf_execve"]=11 ++__syscall_64_num2name[169]="osf_exportfs" ++__syscall_64_name2num["osf_exportfs"]=169 ++__syscall_64_num2name[35]="osf_fchflags" ++__syscall_64_name2num["osf_fchflags"]=35 ++__syscall_64_num2name[261]="osf_fdatasync" ++__syscall_64_name2num["osf_fdatasync"]=261 ++__syscall_64_num2name[248]="osf_fpathconf" ++__syscall_64_name2num["osf_fpathconf"]=248 ++__syscall_64_num2name[226]="osf_fstat" ++__syscall_64_name2num["osf_fstat"]=226 ++__syscall_64_num2name[161]="osf_fstatfs" ++__syscall_64_name2num["osf_fstatfs"]=161 ++__syscall_64_num2name[228]="osf_fstatfs64" ++__syscall_64_name2num["osf_fstatfs64"]=228 ++__syscall_64_num2name[243]="osf_fuser" ++__syscall_64_name2num["osf_fuser"]=243 ++__syscall_64_num2name[214]="osf_getaddressconf" ++__syscall_64_name2num["osf_getaddressconf"]=214 ++__syscall_64_num2name[159]="osf_getdirentries" ++__syscall_64_name2num["osf_getdirentries"]=159 ++__syscall_64_num2name[165]="osf_getdomainname" ++__syscall_64_name2num["osf_getdomainname"]=165 ++__syscall_64_num2name[164]="osf_getfh" ++__syscall_64_name2num["osf_getfh"]=164 ++__syscall_64_num2name[18]="osf_getfsstat" ++__syscall_64_name2num["osf_getfsstat"]=18 ++__syscall_64_num2name[142]="osf_gethostid" ++__syscall_64_name2num["osf_gethostid"]=142 ++__syscall_64_num2name[86]="osf_getitimer" ++__syscall_64_name2num["osf_getitimer"]=86 ++__syscall_64_num2name[49]="osf_getlogin" ++__syscall_64_name2num["osf_getlogin"]=49 ++__syscall_64_num2name[184]="osf_getmnt" ++__syscall_64_name2num["osf_getmnt"]=184 ++__syscall_64_num2name[117]="osf_getrusage" ++__syscall_64_name2num["osf_getrusage"]=117 ++__syscall_64_num2name[256]="osf_getsysinfo" ++__syscall_64_name2num["osf_getsysinfo"]=256 ++__syscall_64_num2name[116]="osf_gettimeofday" ++__syscall_64_name2num["osf_gettimeofday"]=116 ++__syscall_64_num2name[223]="osf_kloadcall" ++__syscall_64_name2num["osf_kloadcall"]=223 ++__syscall_64_num2name[77]="osf_kmodcall" ++__syscall_64_name2num["osf_kmodcall"]=77 ++__syscall_64_num2name[225]="osf_lstat" ++__syscall_64_name2num["osf_lstat"]=225 ++__syscall_64_num2name[260]="osf_memcntl" ++__syscall_64_name2num["osf_memcntl"]=260 ++__syscall_64_num2name[78]="osf_mincore" ++__syscall_64_name2num["osf_mincore"]=78 ++__syscall_64_num2name[21]="osf_mount" ++__syscall_64_name2num["osf_mount"]=21 ++__syscall_64_num2name[65]="osf_mremap" ++__syscall_64_name2num["osf_mremap"]=65 ++__syscall_64_num2name[240]="osf_msfs_syscall" ++__syscall_64_name2num["osf_msfs_syscall"]=240 ++__syscall_64_num2name[215]="osf_msleep" ++__syscall_64_name2num["osf_msleep"]=215 ++__syscall_64_num2name[213]="osf_mvalid" ++__syscall_64_name2num["osf_mvalid"]=213 ++__syscall_64_num2name[216]="osf_mwakeup" ++__syscall_64_name2num["osf_mwakeup"]=216 ++__syscall_64_num2name[30]="osf_naccept" ++__syscall_64_name2num["osf_naccept"]=30 ++__syscall_64_num2name[158]="osf_nfssvc" ++__syscall_64_name2num["osf_nfssvc"]=158 ++__syscall_64_num2name[31]="osf_ngetpeername" ++__syscall_64_name2num["osf_ngetpeername"]=31 ++__syscall_64_num2name[32]="osf_ngetsockname" ++__syscall_64_name2num["osf_ngetsockname"]=32 ++__syscall_64_num2name[29]="osf_nrecvfrom" ++__syscall_64_name2num["osf_nrecvfrom"]=29 ++__syscall_64_num2name[27]="osf_nrecvmsg" ++__syscall_64_name2num["osf_nrecvmsg"]=27 ++__syscall_64_num2name[28]="osf_nsendmsg" ++__syscall_64_name2num["osf_nsendmsg"]=28 ++__syscall_64_num2name[245]="osf_ntp_adjtime" ++__syscall_64_name2num["osf_ntp_adjtime"]=245 ++__syscall_64_num2name[246]="osf_ntp_gettime" ++__syscall_64_name2num["osf_ntp_gettime"]=246 ++__syscall_64_num2name[8]="osf_old_creat" ++__syscall_64_name2num["osf_old_creat"]=8 ++__syscall_64_num2name[62]="osf_old_fstat" ++__syscall_64_name2num["osf_old_fstat"]=62 ++__syscall_64_num2name[81]="osf_old_getpgrp" ++__syscall_64_name2num["osf_old_getpgrp"]=81 ++__syscall_64_num2name[146]="osf_old_killpg" ++__syscall_64_name2num["osf_old_killpg"]=146 ++__syscall_64_num2name[40]="osf_old_lstat" ++__syscall_64_name2num["osf_old_lstat"]=40 ++__syscall_64_num2name[5]="osf_old_open" ++__syscall_64_name2num["osf_old_open"]=5 ++__syscall_64_num2name[46]="osf_old_sigaction" ++__syscall_64_name2num["osf_old_sigaction"]=46 ++__syscall_64_num2name[109]="osf_old_sigblock" ++__syscall_64_name2num["osf_old_sigblock"]=109 ++__syscall_64_num2name[139]="osf_old_sigreturn" ++__syscall_64_name2num["osf_old_sigreturn"]=139 ++__syscall_64_num2name[110]="osf_old_sigsetmask" ++__syscall_64_name2num["osf_old_sigsetmask"]=110 ++__syscall_64_num2name[108]="osf_old_sigvec" ++__syscall_64_name2num["osf_old_sigvec"]=108 ++__syscall_64_num2name[38]="osf_old_stat" ++__syscall_64_name2num["osf_old_stat"]=38 ++__syscall_64_num2name[72]="osf_old_vadvise" ++__syscall_64_name2num["osf_old_vadvise"]=72 ++__syscall_64_num2name[115]="osf_old_vtrace" ++__syscall_64_name2num["osf_old_vtrace"]=115 ++__syscall_64_num2name[84]="osf_old_wait" ++__syscall_64_name2num["osf_old_wait"]=84 ++__syscall_64_num2name[149]="osf_oldquota" ++__syscall_64_name2num["osf_oldquota"]=149 ++__syscall_64_num2name[247]="osf_pathconf" ++__syscall_64_name2num["osf_pathconf"]=247 ++__syscall_64_num2name[153]="osf_pid_block" ++__syscall_64_name2num["osf_pid_block"]=153 ++__syscall_64_num2name[154]="osf_pid_unblock" ++__syscall_64_name2num["osf_pid_unblock"]=154 ++__syscall_64_num2name[107]="osf_plock" ++__syscall_64_name2num["osf_plock"]=107 ++__syscall_64_num2name[237]="osf_priocntlset" ++__syscall_64_name2num["osf_priocntlset"]=237 ++__syscall_64_num2name[44]="osf_profil" ++__syscall_64_name2num["osf_profil"]=44 ++__syscall_64_num2name[244]="osf_proplist_syscall" ++__syscall_64_name2num["osf_proplist_syscall"]=244 ++__syscall_64_num2name[55]="osf_reboot" ++__syscall_64_name2num["osf_reboot"]=55 ++__syscall_64_num2name[56]="osf_revoke" ++__syscall_64_name2num["osf_revoke"]=56 ++__syscall_64_num2name[69]="osf_sbrk" ++__syscall_64_name2num["osf_sbrk"]=69 ++__syscall_64_num2name[222]="osf_security" ++__syscall_64_name2num["osf_security"]=222 ++__syscall_64_num2name[93]="osf_select" ++__syscall_64_name2num["osf_select"]=93 ++__syscall_64_num2name[43]="osf_set_program_attributes" ++__syscall_64_name2num["osf_set_program_attributes"]=43 ++__syscall_64_num2name[239]="osf_set_speculative" ++__syscall_64_name2num["osf_set_speculative"]=239 ++__syscall_64_num2name[143]="osf_sethostid" ++__syscall_64_name2num["osf_sethostid"]=143 ++__syscall_64_num2name[83]="osf_setitimer" ++__syscall_64_name2num["osf_setitimer"]=83 ++__syscall_64_num2name[50]="osf_setlogin" ++__syscall_64_name2num["osf_setlogin"]=50 ++__syscall_64_num2name[257]="osf_setsysinfo" ++__syscall_64_name2num["osf_setsysinfo"]=257 ++__syscall_64_num2name[122]="osf_settimeofday" ++__syscall_64_name2num["osf_settimeofday"]=122 ++__syscall_64_num2name[209]="osf_shmat" ++__syscall_64_name2num["osf_shmat"]=209 ++__syscall_64_num2name[218]="osf_signal" ++__syscall_64_name2num["osf_signal"]=218 ++__syscall_64_num2name[48]="osf_sigprocmask" ++__syscall_64_name2num["osf_sigprocmask"]=48 ++__syscall_64_num2name[238]="osf_sigsendset" ++__syscall_64_name2num["osf_sigsendset"]=238 ++__syscall_64_num2name[112]="osf_sigstack" ++__syscall_64_name2num["osf_sigstack"]=112 ++__syscall_64_num2name[157]="osf_sigwaitprim" ++__syscall_64_name2num["osf_sigwaitprim"]=157 ++__syscall_64_num2name[70]="osf_sstk" ++__syscall_64_name2num["osf_sstk"]=70 ++__syscall_64_num2name[224]="osf_stat" ++__syscall_64_name2num["osf_stat"]=224 ++__syscall_64_num2name[160]="osf_statfs" ++__syscall_64_name2num["osf_statfs"]=160 ++__syscall_64_num2name[227]="osf_statfs64" ++__syscall_64_name2num["osf_statfs64"]=227 ++__syscall_64_num2name[255]="osf_subsys_info" ++__syscall_64_name2num["osf_subsys_info"]=255 ++__syscall_64_num2name[259]="osf_swapctl" ++__syscall_64_name2num["osf_swapctl"]=259 ++__syscall_64_num2name[199]="osf_swapon" ++__syscall_64_name2num["osf_swapon"]=199 ++__syscall_64_num2name[0]="osf_syscall" ++__syscall_64_name2num["osf_syscall"]=0 ++__syscall_64_num2name[241]="osf_sysinfo" ++__syscall_64_name2num["osf_sysinfo"]=241 ++__syscall_64_num2name[85]="osf_table" ++__syscall_64_name2num["osf_table"]=85 ++__syscall_64_num2name[242]="osf_uadmin" ++__syscall_64_name2num["osf_uadmin"]=242 ++__syscall_64_num2name[251]="osf_usleep_thread" ++__syscall_64_name2num["osf_usleep_thread"]=251 ++__syscall_64_num2name[250]="osf_uswitch" ++__syscall_64_name2num["osf_uswitch"]=250 ++__syscall_64_num2name[220]="osf_utc_adjtime" ++__syscall_64_name2num["osf_utc_adjtime"]=220 ++__syscall_64_num2name[219]="osf_utc_gettime" ++__syscall_64_name2num["osf_utc_gettime"]=219 ++__syscall_64_num2name[138]="osf_utimes" ++__syscall_64_name2num["osf_utimes"]=138 ++__syscall_64_num2name[207]="osf_utsname" ++__syscall_64_name2num["osf_utsname"]=207 ++__syscall_64_num2name[7]="osf_wait4" ++__syscall_64_name2num["osf_wait4"]=7 ++__syscall_64_num2name[236]="osf_waitid" ++__syscall_64_name2num["osf_waitid"]=236 ++__syscall_64_num2name[376]="pciconfig_iobase" ++__syscall_64_name2num["pciconfig_iobase"]=376 ++__syscall_64_num2name[345]="pciconfig_read" ++__syscall_64_name2num["pciconfig_read"]=345 ++__syscall_64_num2name[346]="pciconfig_write" ++__syscall_64_name2num["pciconfig_write"]=346 ++__syscall_64_num2name[493]="perf_event_open" ++__syscall_64_name2num["perf_event_open"]=493 ++__syscall_64_num2name[324]="personality" ++__syscall_64_name2num["personality"]=324 ++__syscall_64_num2name[110+438]="pidfd_getfd" ++__syscall_64_name2num["pidfd_getfd"]=110+438 ++__syscall_64_num2name[110+434]="pidfd_open" ++__syscall_64_name2num["pidfd_open"]=110+434 ++__syscall_64_num2name[110+424]="pidfd_send_signal" ++__syscall_64_name2num["pidfd_send_signal"]=110+424 ++__syscall_64_num2name[42]="pipe" ++__syscall_64_name2num["pipe"]=42 ++__syscall_64_num2name[488]="pipe2" ++__syscall_64_name2num["pipe2"]=488 ++__syscall_64_num2name[374]="pivot_root" ++__syscall_64_name2num["pivot_root"]=374 ++__syscall_64_num2name[525]="pkey_alloc" ++__syscall_64_name2num["pkey_alloc"]=525 ++__syscall_64_num2name[526]="pkey_free" ++__syscall_64_name2num["pkey_free"]=526 ++__syscall_64_num2name[524]="pkey_mprotect" ++__syscall_64_name2num["pkey_mprotect"]=524 ++__syscall_64_num2name[94]="poll" ++__syscall_64_name2num["poll"]=94 ++__syscall_64_num2name[464]="ppoll" ++__syscall_64_name2num["ppoll"]=464 ++__syscall_64_num2name[348]="prctl" ++__syscall_64_name2num["prctl"]=348 ++__syscall_64_num2name[349]="pread64" ++__syscall_64_name2num["pread64"]=349 ++__syscall_64_num2name[490]="preadv" ++__syscall_64_name2num["preadv"]=490 ++__syscall_64_num2name[520]="preadv2" ++__syscall_64_name2num["preadv2"]=520 ++__syscall_64_num2name[496]="prlimit64" ++__syscall_64_name2num["prlimit64"]=496 ++__syscall_64_num2name[110+440]="process_madvise" ++__syscall_64_name2num["process_madvise"]=110+440 ++__syscall_64_num2name[504]="process_vm_readv" ++__syscall_64_name2num["process_vm_readv"]=504 ++__syscall_64_num2name[505]="process_vm_writev" ++__syscall_64_name2num["process_vm_writev"]=505 ++__syscall_64_num2name[463]="pselect6" ++__syscall_64_name2num["pselect6"]=463 ++__syscall_64_num2name[26]="ptrace" ++__syscall_64_name2num["ptrace"]=26 ++__syscall_64_num2name[350]="pwrite64" ++__syscall_64_name2num["pwrite64"]=350 ++__syscall_64_num2name[491]="pwritev" ++__syscall_64_name2num["pwritev"]=491 ++__syscall_64_num2name[521]="pwritev2" ++__syscall_64_name2num["pwritev2"]=521 ++__syscall_64_num2name[347]="query_module" ++__syscall_64_name2num["query_module"]=347 ++__syscall_64_num2name[148]="quotactl" ++__syscall_64_name2num["quotactl"]=148 ++__syscall_64_num2name[110+443]="quotactl_fd" ++__syscall_64_name2num["quotactl_fd"]=110+443 ++__syscall_64_num2name[3]="read" ++__syscall_64_name2num["read"]=3 ++__syscall_64_num2name[379]="readahead" ++__syscall_64_name2num["readahead"]=379 ++__syscall_64_num2name[58]="readlink" ++__syscall_64_name2num["readlink"]=58 ++__syscall_64_num2name[460]="readlinkat" ++__syscall_64_name2num["readlinkat"]=460 ++__syscall_64_num2name[120]="readv" ++__syscall_64_name2num["readv"]=120 ++__syscall_64_num2name[311]="reboot" ++__syscall_64_name2num["reboot"]=311 ++__syscall_64_num2name[102]="recv" ++__syscall_64_name2num["recv"]=102 ++__syscall_64_num2name[125]="recvfrom" ++__syscall_64_name2num["recvfrom"]=125 ++__syscall_64_num2name[479]="recvmmsg" ++__syscall_64_name2num["recvmmsg"]=479 ++__syscall_64_num2name[113]="recvmsg" ++__syscall_64_name2num["recvmsg"]=113 ++__syscall_64_num2name[410]="remap_file_pages" ++__syscall_64_name2num["remap_file_pages"]=410 ++__syscall_64_num2name[391]="removexattr" ++__syscall_64_name2num["removexattr"]=391 ++__syscall_64_num2name[128]="rename" ++__syscall_64_name2num["rename"]=128 ++__syscall_64_num2name[457]="renameat" ++__syscall_64_name2num["renameat"]=457 ++__syscall_64_num2name[510]="renameat2" ++__syscall_64_name2num["renameat2"]=510 ++__syscall_64_num2name[440]="request_key" ++__syscall_64_name2num["request_key"]=440 ++__syscall_64_num2name[412]="restart_syscall" ++__syscall_64_name2num["restart_syscall"]=412 ++__syscall_64_num2name[137]="rmdir" ++__syscall_64_name2num["rmdir"]=137 ++__syscall_64_num2name[527]="rseq" ++__syscall_64_name2num["rseq"]=527 ++__syscall_64_num2name[352]="rt_sigaction" ++__syscall_64_name2num["rt_sigaction"]=352 ++__syscall_64_num2name[354]="rt_sigpending" ++__syscall_64_name2num["rt_sigpending"]=354 ++__syscall_64_num2name[353]="rt_sigprocmask" ++__syscall_64_name2num["rt_sigprocmask"]=353 ++__syscall_64_num2name[356]="rt_sigqueueinfo" ++__syscall_64_name2num["rt_sigqueueinfo"]=356 ++__syscall_64_num2name[351]="rt_sigreturn" ++__syscall_64_name2num["rt_sigreturn"]=351 ++__syscall_64_num2name[357]="rt_sigsuspend" ++__syscall_64_name2num["rt_sigsuspend"]=357 ++__syscall_64_num2name[355]="rt_sigtimedwait" ++__syscall_64_name2num["rt_sigtimedwait"]=355 ++__syscall_64_num2name[492]="rt_tgsigqueueinfo" ++__syscall_64_name2num["rt_tgsigqueueinfo"]=492 ++__syscall_64_num2name[335]="sched_get_priority_max" ++__syscall_64_name2num["sched_get_priority_max"]=335 ++__syscall_64_num2name[336]="sched_get_priority_min" ++__syscall_64_name2num["sched_get_priority_min"]=336 ++__syscall_64_num2name[396]="sched_getaffinity" ++__syscall_64_name2num["sched_getaffinity"]=396 ++__syscall_64_num2name[509]="sched_getattr" ++__syscall_64_name2num["sched_getattr"]=509 ++__syscall_64_num2name[331]="sched_getparam" ++__syscall_64_name2num["sched_getparam"]=331 ++__syscall_64_num2name[333]="sched_getscheduler" ++__syscall_64_name2num["sched_getscheduler"]=333 ++__syscall_64_num2name[337]="sched_rr_get_interval" ++__syscall_64_name2num["sched_rr_get_interval"]=337 ++__syscall_64_num2name[395]="sched_setaffinity" ++__syscall_64_name2num["sched_setaffinity"]=395 ++__syscall_64_num2name[508]="sched_setattr" ++__syscall_64_name2num["sched_setattr"]=508 ++__syscall_64_num2name[330]="sched_setparam" ++__syscall_64_name2num["sched_setparam"]=330 ++__syscall_64_num2name[332]="sched_setscheduler" ++__syscall_64_name2num["sched_setscheduler"]=332 ++__syscall_64_num2name[334]="sched_yield" ++__syscall_64_name2num["sched_yield"]=334 ++__syscall_64_num2name[514]="seccomp" ++__syscall_64_name2num["seccomp"]=514 ++__syscall_64_num2name[358]="select" ++__syscall_64_name2num["select"]=358 ++__syscall_64_num2name[204]="semctl" ++__syscall_64_name2num["semctl"]=204 ++__syscall_64_num2name[205]="semget" ++__syscall_64_name2num["semget"]=205 ++__syscall_64_num2name[206]="semop" ++__syscall_64_name2num["semop"]=206 ++__syscall_64_num2name[423]="semtimedop" ++__syscall_64_name2num["semtimedop"]=423 ++__syscall_64_num2name[101]="send" ++__syscall_64_name2num["send"]=101 ++__syscall_64_num2name[370]="sendfile" ++__syscall_64_name2num["sendfile"]=370 ++__syscall_64_num2name[503]="sendmmsg" ++__syscall_64_name2num["sendmmsg"]=503 ++__syscall_64_num2name[114]="sendmsg" ++__syscall_64_name2num["sendmsg"]=114 ++__syscall_64_num2name[133]="sendto" ++__syscall_64_name2num["sendto"]=133 ++__syscall_64_num2name[431]="set_mempolicy" ++__syscall_64_name2num["set_mempolicy"]=431 ++__syscall_64_num2name[466]="set_robust_list" ++__syscall_64_name2num["set_robust_list"]=466 ++__syscall_64_num2name[411]="set_tid_address" ++__syscall_64_name2num["set_tid_address"]=411 ++__syscall_64_num2name[166]="setdomainname" ++__syscall_64_name2num["setdomainname"]=166 ++__syscall_64_num2name[326]="setfsgid" ++__syscall_64_name2num["setfsgid"]=326 ++__syscall_64_num2name[325]="setfsuid" ++__syscall_64_name2num["setfsuid"]=325 ++__syscall_64_num2name[132]="setgid" ++__syscall_64_name2num["setgid"]=132 ++__syscall_64_num2name[80]="setgroups" ++__syscall_64_name2num["setgroups"]=80 ++__syscall_64_num2name[301]="sethae" ++__syscall_64_name2num["sethae"]=301 ++__syscall_64_num2name[88]="sethostname" ++__syscall_64_name2num["sethostname"]=88 ++__syscall_64_num2name[362]="setitimer" ++__syscall_64_name2num["setitimer"]=362 ++__syscall_64_num2name[501]="setns" ++__syscall_64_name2num["setns"]=501 ++__syscall_64_num2name[39]="setpgid" ++__syscall_64_name2num["setpgid"]=39 ++__syscall_64_num2name[82]="setpgrp" ++__syscall_64_name2num["setpgrp"]=82 ++__syscall_64_num2name[96]="setpriority" ++__syscall_64_name2num["setpriority"]=96 ++__syscall_64_num2name[127]="setregid" ++__syscall_64_name2num["setregid"]=127 ++__syscall_64_num2name[371]="setresgid" ++__syscall_64_name2num["setresgid"]=371 ++__syscall_64_num2name[343]="setresuid" ++__syscall_64_name2num["setresuid"]=343 ++__syscall_64_num2name[126]="setreuid" ++__syscall_64_name2num["setreuid"]=126 ++__syscall_64_num2name[145]="setrlimit" ++__syscall_64_name2num["setrlimit"]=145 ++__syscall_64_num2name[147]="setsid" ++__syscall_64_name2num["setsid"]=147 ++__syscall_64_num2name[105]="setsockopt" ++__syscall_64_name2num["setsockopt"]=105 ++__syscall_64_num2name[360]="settimeofday" ++__syscall_64_name2num["settimeofday"]=360 ++__syscall_64_num2name[23]="setuid" ++__syscall_64_name2num["setuid"]=23 ++__syscall_64_num2name[382]="setxattr" ++__syscall_64_name2num["setxattr"]=382 ++__syscall_64_num2name[210]="shmctl" ++__syscall_64_name2num["shmctl"]=210 ++__syscall_64_num2name[211]="shmdt" ++__syscall_64_name2num["shmdt"]=211 ++__syscall_64_num2name[212]="shmget" ++__syscall_64_name2num["shmget"]=212 ++__syscall_64_num2name[134]="shutdown" ++__syscall_64_name2num["shutdown"]=134 ++__syscall_64_num2name[156]="sigaction" ++__syscall_64_name2num["sigaction"]=156 ++__syscall_64_num2name[235]="sigaltstack" ++__syscall_64_name2num["sigaltstack"]=235 ++__syscall_64_num2name[476]="signalfd" ++__syscall_64_name2num["signalfd"]=476 ++__syscall_64_num2name[484]="signalfd4" ++__syscall_64_name2num["signalfd4"]=484 ++__syscall_64_num2name[52]="sigpending" ++__syscall_64_name2num["sigpending"]=52 ++__syscall_64_num2name[103]="sigreturn" ++__syscall_64_name2num["sigreturn"]=103 ++__syscall_64_num2name[111]="sigsuspend" ++__syscall_64_name2num["sigsuspend"]=111 ++__syscall_64_num2name[97]="socket" ++__syscall_64_name2num["socket"]=97 ++__syscall_64_num2name[135]="socketpair" ++__syscall_64_name2num["socketpair"]=135 ++__syscall_64_num2name[468]="splice" ++__syscall_64_name2num["splice"]=468 ++__syscall_64_num2name[67]="stat" ++__syscall_64_name2num["stat"]=67 ++__syscall_64_num2name[425]="stat64" ++__syscall_64_name2num["stat64"]=425 ++__syscall_64_num2name[328]="statfs" ++__syscall_64_name2num["statfs"]=328 ++__syscall_64_num2name[528]="statfs64" ++__syscall_64_name2num["statfs64"]=528 ++__syscall_64_num2name[522]="statx" ++__syscall_64_name2num["statx"]=522 ++__syscall_64_num2name[304]="swapoff" ++__syscall_64_name2num["swapoff"]=304 ++__syscall_64_num2name[322]="swapon" ++__syscall_64_name2num["swapon"]=322 ++__syscall_64_num2name[57]="symlink" ++__syscall_64_name2num["symlink"]=57 ++__syscall_64_num2name[459]="symlinkat" ++__syscall_64_name2num["symlinkat"]=459 ++__syscall_64_num2name[36]="sync" ++__syscall_64_name2num["sync"]=36 ++__syscall_64_num2name[469]="sync_file_range" ++__syscall_64_name2num["sync_file_range"]=469 ++__syscall_64_num2name[500]="syncfs" ++__syscall_64_name2num["syncfs"]=500 ++__syscall_64_num2name[254]="sysfs" ++__syscall_64_name2num["sysfs"]=254 ++__syscall_64_num2name[318]="sysinfo" ++__syscall_64_name2num["sysinfo"]=318 ++__syscall_64_num2name[310]="syslog" ++__syscall_64_name2num["syslog"]=310 ++__syscall_64_num2name[470]="tee" ++__syscall_64_name2num["tee"]=470 ++__syscall_64_num2name[424]="tgkill" ++__syscall_64_name2num["tgkill"]=424 ++__syscall_64_num2name[414]="timer_create" ++__syscall_64_name2num["timer_create"]=414 ++__syscall_64_num2name[418]="timer_delete" ++__syscall_64_name2num["timer_delete"]=418 ++__syscall_64_num2name[417]="timer_getoverrun" ++__syscall_64_name2num["timer_getoverrun"]=417 ++__syscall_64_num2name[416]="timer_gettime" ++__syscall_64_name2num["timer_gettime"]=416 ++__syscall_64_num2name[415]="timer_settime" ++__syscall_64_name2num["timer_settime"]=415 ++__syscall_64_num2name[477]="timerfd" ++__syscall_64_name2num["timerfd"]=477 ++__syscall_64_num2name[481]="timerfd_create" ++__syscall_64_name2num["timerfd_create"]=481 ++__syscall_64_num2name[483]="timerfd_gettime" ++__syscall_64_name2num["timerfd_gettime"]=483 ++__syscall_64_num2name[482]="timerfd_settime" ++__syscall_64_name2num["timerfd_settime"]=482 ++__syscall_64_num2name[323]="times" ++__syscall_64_name2num["times"]=323 ++__syscall_64_num2name[381]="tkill" ++__syscall_64_name2num["tkill"]=381 ++__syscall_64_num2name[129]="truncate" ++__syscall_64_name2num["truncate"]=129 ++__syscall_64_num2name[397]="tuxcall" ++__syscall_64_name2num["tuxcall"]=397 ++__syscall_64_num2name[60]="umask" ++__syscall_64_name2num["umask"]=60 ++__syscall_64_num2name[22]="umount" ++__syscall_64_name2num["umount"]=22 ++__syscall_64_num2name[339]="uname" ++__syscall_64_name2num["uname"]=339 ++__syscall_64_num2name[10]="unlink" ++__syscall_64_name2num["unlink"]=10 ++__syscall_64_num2name[456]="unlinkat" ++__syscall_64_name2num["unlinkat"]=456 ++__syscall_64_num2name[465]="unshare" ++__syscall_64_name2num["unshare"]=465 ++__syscall_64_num2name[313]="uselib" ++__syscall_64_name2num["uselib"]=313 ++__syscall_64_num2name[516]="userfaultfd" ++__syscall_64_name2num["userfaultfd"]=516 ++__syscall_64_num2name[327]="ustat" ++__syscall_64_name2num["ustat"]=327 ++__syscall_64_num2name[475]="utimensat" ++__syscall_64_name2num["utimensat"]=475 ++__syscall_64_num2name[363]="utimes" ++__syscall_64_name2num["utimes"]=363 ++__syscall_64_num2name[66]="vfork" ++__syscall_64_name2num["vfork"]=66 ++__syscall_64_num2name[76]="vhangup" ++__syscall_64_name2num["vhangup"]=76 ++__syscall_64_num2name[471]="vmsplice" ++__syscall_64_name2num["vmsplice"]=471 ++__syscall_64_num2name[428]="vserver" ++__syscall_64_name2num["vserver"]=428 ++__syscall_64_num2name[365]="wait4" ++__syscall_64_name2num["wait4"]=365 ++__syscall_64_num2name[438]="waitid" ++__syscall_64_name2num["waitid"]=438 ++__syscall_64_num2name[4]="write" ++__syscall_64_name2num["write"]=4 ++__syscall_64_num2name[121]="writev" ++__syscall_64_name2num["writev"]=121 ++%) ++} /* probe init */ +diff --git a/tapset/linux/syscalls.stpm b/tapset/linux/syscalls.stpm +index 9f14a99..d7dc1d5 100644 +--- a/tapset/linux/syscalls.stpm ++++ b/tapset/linux/syscalls.stpm +@@ -384,6 +384,15 @@ + @define SYSC_CLONE_CHILD_TID_UADDR_ARGNO %( 4 %) + %) + ++%( arch == "sw_64" %? ++@define arch_syscall_prefix %( "__sw_64_" %) ++@define arch_syscall0_prefix %( "__sw_64_" %) ++@define SYSC_CLONE_CLONE_FLAGS_ARGNO %( 1 %) ++@define SYSC_CLONE_STACK_START_ARGNO %( 2 %) ++@define SYSC_CLONE_PARENT_TID_UADDR_ARGNO %( 3 %) ++@define SYSC_CLONE_CHILD_TID_UADDR_ARGNO %( 5 %) ++%) ++ + %( arch == "x86_64" %? + @define arch_syscall_prefix %( "__{ia32,x64}_" %) + @define arch_syscall0_prefix %( "__x64_" %) +diff --git a/tapset/sw_64 b/tapset/sw_64 +new file mode 100644 +index 0000000..d8d4f74 +--- /dev/null ++++ b/tapset/sw_64 +@@ -0,0 +1,336 @@ ++@__private30 global _reg_offsets[33] ++ ++probe init { ++ /* Same order as pt_regs */ ++ _reg_offsets["r0"] = 0 ++ _reg_offsets["r1"] = 8 ++ _reg_offsets["r2"] = 16 ++ _reg_offsets["r3"] = 24 ++ _reg_offsets["r4"] = 32 ++ _reg_offsets["r5"] = 40 ++ _reg_offsets["r6"] = 48 ++ _reg_offsets["r7"] = 56 ++ _reg_offsets["r8"] = 64 ++ _reg_offsets["r9"] = 72 ++ _reg_offsets["r10"] = 80 ++ _reg_offsets["r11"] = 88 ++ _reg_offsets["r12"] = 96 ++ _reg_offsets["r13"] = 104 ++ _reg_offsets["r14"] = 112 ++ _reg_offsets["r15"] = 120 ++ _reg_offsets["r16"] = 128 ++ _reg_offsets["r17"] = 136 ++ _reg_offsets["r18"] = 144 ++ _reg_offsets["r19"] = 152 ++ _reg_offsets["r20"] = 160 ++ _reg_offsets["r21"] = 168 ++ _reg_offsets["r22"] = 176 ++ _reg_offsets["r23"] = 184 ++ _reg_offsets["r24"] = 192 ++ _reg_offsets["r25"] = 200 ++ _reg_offsets["r26"] = 208 ++ _reg_offsets["r27"] = 216 ++ _reg_offsets["r28"] = 224 ++ _reg_offsets["gp"] = 232 ++ _reg_offsets["sp"] = 240 ++ _reg_offsets["pc"] = 248 ++ _reg_offsets["ps"] = 256 ++} ++ ++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", (long long) STAP_ARG_offset); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ memcpy(&value, ((char *)regs) + STAP_ARG_offset, sizeof(value)); ++ STAP_RETVALUE = value; ++%} ++ ++/* ++ * _stp_sign_extend32() is callable from a script function. ++ * __stp_sign_extend32() (in regs.c) is callable from a C function. ++ */ ++ ++function _stp_sign_extend32:long (value:long) { ++ if (value & 0x80000000) ++ value |= (0xffffffff << 32) ++ return value ++} ++ ++/* ++ * _stp_sign_extend16() is callable from a script function. ++ * __stp_sign_extend16() (in regs.c) is callable from a C function. ++ */ ++function _stp_sign_extend16:long (value:long) %{ /* pure */ ++ STAP_RETVALUE = __stp_sign_extend16(STAP_ARG_value); ++%} ++ ++/* ++ * _stp_sign_extend8() is callable from a script function. ++ * __stp_sign_extend8() (in regs.c) is callable from a C function. ++ */ ++function _stp_sign_extend8:long (value:long) %{ /* pure */ ++ STAP_RETVALUE = __stp_sign_extend8(STAP_ARG_value); ++%} ++ ++function _stp_register:long (name:string, sign_extend:long) { ++ /*reg32 = 0 ++ reg16 = 0 ++ reg8 = 0*/ ++ assert(registers_valid(), "cannot access CPU registers in this context") ++ offset = _reg_offsets[name] ++/* if (offset == 0 && !(name in _reg_offsets)) { ++ offset = _r32_offsets[name] ++ if (offset == 0 && !(name in _r32_offsets)) { ++ offset = _r16_offsets[name] ++ if (offset == 0 && !(name in _r16_offsets)) { ++ offset = _r8_offsets[name] ++ if (offset == 0 && !(name in _r8_offsets)) { ++ assert(0, "Unknown register: " . name) ++ } else { ++ reg8 = 1; ++ } ++ } else { ++ reg16 = 1; ++ } ++ ++ } else { ++ reg32 = 1 ++ } ++ } ++*/ value = _stp_get_register_by_offset(offset) ++/* if (reg32) { ++ if (sign_extend) ++ value = _stp_sign_extend32(value) ++ else ++ value &= 0xffffffff ++ } else if (reg16) { ++ if (sign_extend) ++ value = _stp_sign_extend16(value) ++ else ++ value &= 0xffff ++ } else if (reg8) { ++ if (sign_extend) ++ value = _stp_sign_extend8(value) ++ else ++ value &= 0xff ++ } ++*/ 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) ++} ++ ++/* ++ * 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. ++ * If force64=1, return a 64-bit value even if we're in a 32-bit app. ++ */ ++/* ++function _stp_arg:long (argnum:long, sign_extend:long, truncate:long) ++{ ++ return _stp_arg2(argnum, sign_extend, truncate, 0) ++}*/ ++ ++function _stp_arg:long (argnum:long, sign_extend:long, truncate:long) { ++ val = 0 ++ assert(!(argnum < 1 || argnum > 6), sprintf("Cannot access arg(%d)", argnum)) ++ ++ if (argnum == 1) ++ val = u_register("r16") ++ else if (argnum == 2) ++ val = u_register("r17") ++ else if (argnum == 3) ++ val = u_register("r18") ++ else if (argnum == 4) ++ val = u_register("r19") ++ else if (argnum == 5) ++ val = u_register("r20") ++ else if (argnum == 6) ++ val = u_register("r21") ++ ++ if (truncate) { ++ if (sign_extend) ++ val = _stp_sign_extend32(val) ++ else ++ /* High bits may be garbage. */ ++ val = (val & 0xffffffff); ++ } ++ return val; ++} ++/* For use with syscall-in-pt_regs mode: kernel 4.17+ or similar */ ++function _stp_offset_to_argptr:long (offset:long) %{ ++ struct pt_regs *regs = CONTEXT->sregs; ++ ++ if (!regs) { ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "cannot access function args in this context"); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ 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", ++ (long long)STAP_ARG_offset); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++ return; ++ } ++ STAP_RETVALUE = (unsigned long)(((char *)regs) + STAP_ARG_offset); ++%} ++/* ++ * Return a pointer to function argument #argnum (1=first arg). ++ */ ++function _stp_get_argptr:long (argnum:long) { ++ off = 0 ++ assert(!(argnum < 1 || argnum > 6), sprintf("Cannot access arg(%d)", argnum)) ++ ++ if (argnum == 1) ++ off = _reg_offsets["r16"] ++ else if (argnum == 2) ++ off = _reg_offsets["r17"] ++ else if (argnum == 3) ++ off = _reg_offsets["r18"] ++ else if (argnum == 4) ++ off = _reg_offsets["r19"] ++ else if (argnum == 5) ++ off = _reg_offsets["r20"] ++ else if (argnum == 6) ++ off = _reg_offsets["r21"] ++ ++ return _stp_offset_to_argptr(off) ++} ++ ++/* 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 probing_32bit_app:long() %{ /* pure */ ++ STAP_RETVALUE = (CONTEXT->user_mode_p && _stp_is_compat_task()); ++%} ++ ++function arch_bytes:long() %{ /* pure */ ++ STAP_RETVALUE = sizeof(long); ++%} ++ ++function uarch_bytes:long() { ++ assert(user_mode(), "requires user mode") ++ return 8 ++} ++ ++/* Set the value of function arg #argnum (1=first arg) as a signed int. */ ++function set_int_arg:long (argnum:long, value:long) { ++ return set_kernel_int(_stp_get_argptr(argnum), value) ++} ++ ++/* Return the value of function arg #argnum (1=first arg) as an unsigned int. */ ++function set_uint_arg:long (argnum:long, value:long) { ++ return set_int_arg(argnum, value) ++} ++ ++function set_long_arg:long (argnum:long, value:long) { ++ return set_kernel_long(_stp_get_argptr(argnum), value) ++} ++ ++function set_ulong_arg:long (argnum:long, value:long) { ++ return set_long_arg(argnum, value) ++} ++ ++function set_longlong_arg:long (argnum:long, value:long) { ++ set_long_arg(argnum, value) ++} ++ ++function set_ulonglong_arg:long (argnum:long, value:long) { ++ return set_longlong_arg(argnum, value) ++} ++ ++function set_pointer_arg:long (argnum:long, value:long) { ++ return set_kernel_pointer(_stp_get_argptr(argnum), value) ++} ++ ++function set_s32_arg:long (argnum:long, value:long) { ++ return set_int_arg(argnum, value) ++} ++ ++function set_u32_arg:long (argnum:long, value:long) { ++ return set_uint_arg(argnum, value) ++} ++ ++function set_s64_arg:long (argnum:long, value:long) { ++ return set_longlong_arg(argnum, value) ++} ++ ++function set_u64_arg:long (argnum:long, value:long) { ++ return set_ulonglong_arg(argnum, value) ++} ++function asmlinkage() %{ /* pure */ %} ++ ++function fastcall() %{ /* pure */ %} ++ ++function regparm(n:long) %{ ++ snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer), ++ "regparm is invalid on sw_64."); ++ CONTEXT->last_error = CONTEXT->error_buffer; ++%} +diff --git a/tapsets.cxx b/tapsets.cxx +index 06540ca..9adf7a5 100644 +--- a/tapsets.cxx ++++ b/tapsets.cxx +@@ -2584,6 +2584,7 @@ validate_module_elf (systemtap_session& sess, + case EM_IA_64: expect_machine = "ia64"; break; + case EM_ARM: expect_machine = "arm*"; break; + case EM_AARCH64: expect_machine = "arm64"; break; ++ case EM_SW_64: expect_machine = "sw_64"; break; + case EM_MIPS: expect_machine = "mips"; break; + case EM_RISCV: expect_machine = "riscv"; break; + // XXX: fill in some more of these +@@ -6701,6 +6702,39 @@ sdt_uprobe_var_expanding_visitor::build_dwarf_registers () + DRI ("%ebp", 5, SI); DRI ("%bp", 5, HI); + DRI ("%esi", 6, SI); DRI ("%si", 6, HI); DRI ("%sil", 6, QI); + DRI ("%edi", 7, SI); DRI ("%di", 7, HI); DRI ("%dil", 7, QI); ++ } else if (elf_machine == EM_SW_64) { ++ DRI ("$0", 0, DI); ++ DRI ("$1", 1, DI); ++ DRI ("$2", 2, DI); ++ DRI ("$3", 3, DI); ++ DRI ("$4", 4, DI); ++ DRI ("$5", 5, DI); ++ DRI ("$6", 6, DI); ++ DRI ("$7", 7, DI); ++ DRI ("$8", 8, DI); ++ DRI ("$9", 9, DI); ++ DRI ("$10", 10, DI); ++ DRI ("$11", 11, DI); ++ DRI ("$12", 12, DI); ++ DRI ("$13", 13, DI); ++ DRI ("$14", 14, DI); ++ DRI ("$15", 15, DI); ++ DRI ("$16", 16, DI); ++ DRI ("$17", 17, DI); ++ DRI ("$18", 18, DI); ++ DRI ("$19", 19, DI); ++ DRI ("$20", 20, DI); ++ DRI ("$21", 21, DI); ++ DRI ("$22", 22, DI); ++ DRI ("$23", 23, DI); ++ DRI ("$24", 24, DI); ++ DRI ("$25", 25, DI); ++ DRI ("$26", 26, DI); ++ DRI ("$27", 27, DI); ++ DRI ("$28", 28, DI); ++ DRI ("$29", 29, DI); ++ DRI ("$30", 30, DI); ++ DRI ("$31", 31, DI); + } else if (elf_machine == EM_PPC || elf_machine == EM_PPC64) { + DRI ("%r0", 0, DI); + DRI ("%r1", 1, DI); +@@ -7139,7 +7173,7 @@ sdt_uprobe_var_expanding_visitor::try_parse_arg_literal (target_symbol *e, + vector matches; + string regexp; + +- if (elf_machine == EM_AARCH64 || elf_machine == EM_MIPS) { ++ if (elf_machine == EM_AARCH64 || elf_machine == EM_SW_64 || elf_machine == EM_MIPS) { + regexp = "^([-]?[0-9][0-9]*)$"; + } else { + regexp = "^[i\\$#]([-]?[0-9][0-9]*)$"; +@@ -7186,7 +7220,7 @@ sdt_uprobe_var_expanding_visitor::try_parse_arg_register (target_symbol *e, + string regexp; + if (elf_machine == EM_PPC || elf_machine == EM_PPC64 + || elf_machine == EM_ARM || elf_machine == EM_AARCH64 +- || elf_machine == EM_RISCV) ++ || elf_machine == EM_RISCV || elf_machine == EM_SW_64) + regexp = "^(" + regnames + ")$"; + else + regexp = "^(" + percent_regnames + ")$"; +diff --git a/testsuite/systemtap.base/at_register.stp b/testsuite/systemtap.base/at_register.stp +index f904624..da8e219 100644 +--- a/testsuite/systemtap.base/at_register.stp ++++ b/testsuite/systemtap.base/at_register.stp +@@ -6,7 +6,7 @@ global regname = "eax" + %( arch == "x86_64" %? + global regname = "rax" + %) +-%( arch == "powerpc" || arch == "s390x" %? ++%( arch == "powerpc" || arch == "sw_64" || arch == "s390x" %? + global regname = "r0" + %) + %( arch == "arm64" %? +diff --git a/testsuite/systemtap.context/num_args.stp b/testsuite/systemtap.context/num_args.stp +index bc6eca2..96a1486 100644 +--- a/testsuite/systemtap.context/num_args.stp ++++ b/testsuite/systemtap.context/num_args.stp +@@ -5,6 +5,7 @@ + %( arch == "arm" %? global ir = "r0", lr = "r0" %) + %( arch == "arm64" %? global ir = "x0", lr = "x0" %) + %( arch == "mips" %? global ir = "v0", lr = "v0" %) ++%( arch == "sw_64" %? global ir = "r0", lr = "r0" %) + + # On s390/s390x, when in a syscall, the 1st argument is in the + # orig_gpr2 register. If you aren't in a syscall, the 1st argument is +-- +2.33.0 + diff --git a/systemtap.spec b/systemtap.spec index 3f68773..389224b 100644 --- a/systemtap.spec +++ b/systemtap.spec @@ -1,4 +1,4 @@ -%define anolis_release 4 +%define anolis_release 5 %bcond_without rpm %bcond_without bpf %ifarch %{riscv} @@ -121,6 +121,7 @@ URL: http://sourceware.org/systemtap/ Source: https://sourceware.org/ftp/systemtap/releases/%{name}-%{version}.tar.gz Patch001: 0001-add-loongarch64-support-for-systemtap.patch Patch002: 0002-PR32302-Emit-forward-decls-within-tracepoint_derived.patch +Patch003: systemtap-add-sw.patch # Build* BuildRequires: make gcc-c++ @@ -1279,6 +1280,9 @@ exit 0 # ------------------------------------------------------------------------ %changelog +* Wed Aug 20 2025 wxiat - 5.2-5 +- add sw arch + * Sun Apr 27 2025 Shangtong Guo - 5.2-4 - add support for riscv64 build -- Gitee