@arms/rum-reactnative 0.1.1 → 0.1.3-beta.0

package/android/src/main/jni/rum_backtrace.c

@@ -0,0 +1,144 @@
+#include <unwind.h>
+#include <stdint.h>
+#include <sys/ucontext.h>
+
+typedef struct {
+    void **frames;
+    int max_frames;
+    int count;
+    int skip;  // skip top frames (e.g. signal handler itself)
+} backtrace_state_t;
+
+static _Unwind_Reason_Code unwind_callback(struct _Unwind_Context *context, void *arg) {
+    backtrace_state_t *state = (backtrace_state_t *)arg;
+
+    uintptr_t pc = _Unwind_GetIP(context);
+    if (pc == 0) {
+        return _URC_END_OF_STACK;
+    }
+
+    if (state->skip > 0) {
+        state->skip--;
+    } else if (state->count < state->max_frames) {
+        state->frames[state->count++] = (void *)pc;
+    }
+
+    if (state->count >= state->max_frames) {
+        return _URC_END_OF_STACK;
+    }
+    return _URC_NO_REASON;
+}
+
+#if defined(__arm__)
+/*
+ * ARM32 frame pointer 遍历（async-signal-safe fallback）。
+ * _Unwind_Backtrace 在 ARM32 + 旧版 Android 上可能死锁，
+ * 使用 frame pointer 遍历作为更安全的替代方案。
+ * 要求编译选项 -fno-omit-frame-pointer（已在 CMakeLists 中启用）。
+ */
+static int rum_fp_backtrace(void **buffer, int max_frames, ucontext_t *uc) {
+    if (buffer == NULL || max_frames <= 0 || uc == NULL) {
+        return 0;
+    }
+
+    int count = 0;
+    // 从崩溃 PC 开始
+    buffer[count++] = (void *)(uintptr_t)uc->uc_mcontext.arm_pc;
+
+    // 使用 fp (frame pointer) 遍历调用栈
+    void *fp = (void *)(uintptr_t)uc->uc_mcontext.arm_fp;
+    while (count < max_frames && fp != NULL) {
+        // ARM32 栈帧布局：[fp_prev, lr, ...]
+        void **frame = (void **)fp;
+        void *lr = frame[1];   // link register (return address)
+        void *next_fp = frame[0];  // previous frame pointer
+
+        if (lr == NULL) break;
+        buffer[count++] = lr;
+
+        // 防止循环（fp 未变化）
+        if (next_fp == fp || next_fp == NULL) break;
+        fp = next_fp;
+    }
+    return count;
+}
+#endif
+
+#if defined(__aarch64__)
+/*
+ * ARM64 frame pointer 遍历（async-signal-safe）。
+ * _Unwind_Backtrace 在信号上下文中可能持有加载器/解锁器锁，
+ * 存在死锁风险；arm64 有稳定的 x29 帧指针链，改用 fp 遍历更安全。
+ * 要求 -fno-omit-frame-pointer（已在 CMakeLists 中启用）。
+ *
+ * arm64 栈帧布局（AAPCS64）：fp -> [saved_fp(x29), saved_lr(x30)]
+ * 权衡：穿越未开启帧指针的系统库（libc/libart 等）时可能提前截断，
+ * 栈略短于 .eh_frame unwinding，但避免了信号上下文加锁风险。
+ */
+static int rum_fp_backtrace_arm64(void **buffer, int max_frames, ucontext_t *uc) {
+    if (buffer == NULL || max_frames <= 0 || uc == NULL) {
+        return 0;
+    }
+
+    int count = 0;
+    // frame[0] = 崩溃 PC
+    buffer[count++] = (void *)(uintptr_t)uc->uc_mcontext.pc;
+
+    void **fp = (void **)(uintptr_t)uc->uc_mcontext.regs[29];
+    while (count < max_frames && fp != NULL) {
+        void *next_fp = fp[0];  // 上一帧 fp
+        void *lr = fp[1];       // 返回地址
+
+        if (lr == NULL) break;
+        buffer[count++] = lr;
+
+        if (next_fp == NULL) break;
+        // fp 必须单调递增（栈向低地址增长，调用者 fp 更高），防止循环
+        if ((uintptr_t)next_fp <= (uintptr_t)fp) break;
+        // fp 必须 16 字节对齐（AAPCS64 栈对齐要求）
+        if ((uintptr_t)next_fp & 0xf) break;
+        fp = (void **)next_fp;
+    }
+    return count;
+}
+#endif
+
+/*
+ * Capture backtrace.
+ * - arm64/x86: 使用 _Unwind_Backtrace（通常安全）
+ * - arm32: 使用 frame pointer 遍历（避免 _Unwind_Backtrace 死锁风险）
+ * If uc is provided, the crash PC is inserted as frame[0].
+ */
+int rum_backtrace(void **buffer, int max_frames, ucontext_t *uc) {
+    if (buffer == NULL || max_frames <= 0) {
+        return 0;
+    }
+
+#if defined(__arm__)
+    // ARM32: 使用 frame pointer 遍历，避免 _Unwind_Backtrace 死锁
+    return rum_fp_backtrace(buffer, max_frames, uc);
+#elif defined(__aarch64__)
+    // ARM64: 使用 frame pointer 遍历，避免 _Unwind_Backtrace 信号内持锁死锁
+    return rum_fp_backtrace_arm64(buffer, max_frames, uc);
+#else
+    // x86 / x86_64（主要为模拟器）: 使用 _Unwind_Backtrace
+    backtrace_state_t state = { buffer, max_frames, 0, 0 };
+
+    // Insert crash PC first (per-architecture register extraction)
+    if (uc != NULL) {
+#if defined(__aarch64__)
+        buffer[0] = (void *)(uintptr_t)uc->uc_mcontext.pc;
+        state.count = 1;
+#elif defined(__x86_64__)
+        buffer[0] = (void *)(uintptr_t)uc->uc_mcontext.gregs[REG_RIP];
+        state.count = 1;
+#elif defined(__i386__)
+        buffer[0] = (void *)(uintptr_t)uc->uc_mcontext.gregs[REG_EIP];
+        state.count = 1;
+#endif
+    }
+
+    _Unwind_Backtrace(unwind_callback, &state);
+    return state.count;
+#endif
+}

package/android/src/main/jni/rum_crash_handler.c

@@ -0,0 +1,200 @@
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <sys/ucontext.h>
+#include <android/log.h>
+#include <jni.h>
+
+#define TAG "RumCrash"
+// 帧采集上限：与 rum_crash_writer.c 的 TRUNCATION_THRESHOLD 对齐。
+// 递归崩溃（如 StackOverflow）可能产生数千帧，512 帧足以覆盖
+// 大多数崩溃场景，同时在信号处理器栈上占用可控（512 * sizeof(void*) = 4KB）。
+#define MAX_FRAMES 512
+
+// Signals to capture
+static const int HANDLED_SIGNALS[] = { SIGSEGV, SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGTRAP };
+#define NUM_SIGNALS 6
+
+// Previous signal handlers (for chain calling)
+static struct sigaction g_old_actions[NUM_SIGNALS];
+
+// Crash output directory
+static char g_crash_dir[512] = {0};
+static size_t g_crash_dir_len = 0;
+
+// Alternate signal stack (32KB+)
+static char g_alt_stack[SIGSTKSZ * 4];
+
+// Reentrancy guard
+static volatile sig_atomic_t g_handling_crash = 0;
+
+// Forward declarations (implemented in companion files)
+extern int rum_backtrace(void **buffer, int max_frames, ucontext_t *uc);
+extern void rum_write_crash(int fd, int signum, siginfo_t *info, ucontext_t *uc,
+                             void **frames, int frame_count);
+
+// async-signal-safe: convert non-negative long long to decimal string
+// returns length written (no null terminator)
+static int safe_ltoa(char *buf, long long val) {
+    if (val < 0) {
+        buf[0] = '-';
+        // 使用 unsigned long long 避免 LLONG_MIN 取反溢出
+        unsigned long long uval = (unsigned long long)(-(val + 1)) + 1ULL;
+        char tmp[32];
+        int n = 0;
+        while (uval > 0) {
+            tmp[n++] = (char)('0' + (uval % 10));
+            uval /= 10;
+        }
+        if (n == 0) tmp[n++] = '0';
+        for (int i = 0; i < n; i++) {
+            buf[1 + i] = tmp[n - 1 - i];
+        }
+        return 1 + n;
+    }
+    char tmp[32];
+    int n = 0;
+    if (val == 0) {
+        tmp[n++] = '0';
+    } else {
+        while (val > 0) {
+            tmp[n++] = (char)('0' + (val % 10));
+            val /= 10;
+        }
+    }
+    for (int i = 0; i < n; i++) {
+        buf[i] = tmp[n - 1 - i];
+    }
+    return n;
+}
+
+// async-signal-safe: append source string to buf at *pos, capped by cap
+static void safe_append(char *buf, size_t *pos, size_t cap, const char *src) {
+    while (*src && *pos < cap - 1) {
+        buf[(*pos)++] = *src++;
+    }
+}
+
+static void crash_signal_handler(int signum, siginfo_t *info, void *context) {
+    // 1. Reentrancy guard
+    if (g_handling_crash) {
+        // Restore default and re-raise to allow process termination
+        signal(signum, SIG_DFL);
+        return;
+    }
+    g_handling_crash = 1;
+
+    ucontext_t *uc = (ucontext_t *)context;
+
+    // 2. Capture backtrace
+    void *frames[MAX_FRAMES];
+    int frame_count = rum_backtrace(frames, MAX_FRAMES, uc);
+
+    // 3. Build file path: {dir}/crash_native_{timestamp}_{pid}.json
+    //    Manual concatenation (no sprintf, async-signal-safe).
+    char filepath[768];
+    size_t fp_pos = 0;
+    if (g_crash_dir_len > 0 && g_crash_dir_len < sizeof(filepath) - 100) {
+        memcpy(filepath, g_crash_dir, g_crash_dir_len);
+        fp_pos = g_crash_dir_len;
+        // ensure trailing slash
+        if (filepath[fp_pos - 1] != '/') {
+            filepath[fp_pos++] = '/';
+        }
+    }
+    safe_append(filepath, &fp_pos, sizeof(filepath), "crash_native_");
+
+    // timestamp via time(NULL) — async-signal-safe per POSIX
+    time_t now = time(NULL);
+    fp_pos += safe_ltoa(filepath + fp_pos, (long long)now);
+
+    // 追加 pid 防止同秒崩溃文件名冲突，同时作为 crash_id 的一部分
+    safe_append(filepath, &fp_pos, sizeof(filepath), "_");
+    fp_pos += safe_ltoa(filepath + fp_pos, (long long)getpid());
+
+    safe_append(filepath, &fp_pos, sizeof(filepath), ".json");
+    filepath[fp_pos] = '\0';
+
+    // 4. Open and write
+    int fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if (fd >= 0) {
+        rum_write_crash(fd, signum, info, uc, frames, frame_count);
+        fsync(fd);
+        close(fd);
+    }
+
+    // 5. Chain to previous handler
+    for (int i = 0; i < NUM_SIGNALS; i++) {
+        if (HANDLED_SIGNALS[i] == signum) {
+            sigaction(signum, &g_old_actions[i], NULL);
+            if (g_old_actions[i].sa_flags & SA_SIGINFO) {
+                if (g_old_actions[i].sa_sigaction != NULL) {
+                    g_old_actions[i].sa_sigaction(signum, info, context);
+                }
+            } else if (g_old_actions[i].sa_handler != SIG_DFL &&
+                       g_old_actions[i].sa_handler != SIG_IGN &&
+                       g_old_actions[i].sa_handler != NULL) {
+                g_old_actions[i].sa_handler(signum);
+            }
+            break;
+        }
+    }
+
+    // 6. Terminate process
+    _exit(128 + signum);
+}
+
+JNIEXPORT void JNICALL
+Java_com_rumsdkreactnative_crash_NdkCrashHandler_nativeInstall(JNIEnv *env, jclass clazz, jstring crash_dir_path) {
+    (void)clazz;
+
+    if (crash_dir_path == NULL) {
+        __android_log_print(ANDROID_LOG_WARN, TAG, "nativeInstall: null crash_dir_path");
+        return;
+    }
+
+    const char *dir = (*env)->GetStringUTFChars(env, crash_dir_path, NULL);
+    if (dir != NULL) {
+        size_t len = strlen(dir);
+        if (len >= sizeof(g_crash_dir)) {
+            len = sizeof(g_crash_dir) - 1;
+        }
+        memcpy(g_crash_dir, dir, len);
+        g_crash_dir[len] = '\0';
+        g_crash_dir_len = len;
+        (*env)->ReleaseStringUTFChars(env, crash_dir_path, dir);
+    }
+
+    // Setup alternate signal stack (avoid stack overflow during crash)
+    stack_t ss;
+    memset(&ss, 0, sizeof(ss));
+    ss.ss_sp = g_alt_stack;
+    ss.ss_size = sizeof(g_alt_stack);
+    ss.ss_flags = 0;
+    sigaltstack(&ss, NULL);
+
+    // Setup sigaction template
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_sigaction = crash_signal_handler;
+    sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
+    sigemptyset(&sa.sa_mask);
+    for (int i = 0; i < NUM_SIGNALS; i++) {
+        sigaddset(&sa.sa_mask, HANDLED_SIGNALS[i]);
+    }
+
+    // Register for each signal, preserving previous handler for chain calling
+    for (int i = 0; i < NUM_SIGNALS; i++) {
+        if (sigaction(HANDLED_SIGNALS[i], &sa, &g_old_actions[i]) != 0) {
+            __android_log_print(ANDROID_LOG_WARN, TAG,
+                "Failed to install handler for signal %d", HANDLED_SIGNALS[i]);
+        }
+    }
+
+    __android_log_print(ANDROID_LOG_INFO, TAG,
+        "NDK crash handler installed at: %s", g_crash_dir);
+}