@arms/rum-reactnative 0.1.2 → 0.1.3-beta.1

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

@@ -0,0 +1,436 @@
+#include <unistd.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <stdint.h>
+#include <errno.h>
+#include <sys/ucontext.h>
+#include "rum_module_info.h"
+
+#define WRITE_BUF_SIZE 8192
+#define BUILD_ID_HEX_CAP 128  // GNU build-id hex（通常 40 字符）+ 余量
+#define MAX_REFERENCED_MODULES 32  // 按需过滤：栈帧引用的模块上限（去重后通常 3-10 个）
+#define TRUNCATION_THRESHOLD 512  // 双侧截断阈值，与 rum_crash_handler.c 的 MAX_FRAMES 对齐
+#define FRAMES_PER_SIDE 256       // 双侧截断时每侧保留的帧数
+
+// async-signal-safe: write all bytes (handle partial writes / EINTR only)
+static void safe_write(int fd, const char *buf, size_t len) {
+    size_t off = 0;
+    while (off < len) {
+        ssize_t n = write(fd, buf + off, len - off);
+        if (n > 0) {
+            off += (size_t)n;
+        } else if (n < 0) {
+            // 仅 EINTR 安全重试；其他错误（ENOSPC/EBADF/EIO）直接放弃，避免死循环
+            if (errno == EINTR) {
+                continue;
+            }
+            break;
+        } else {
+            break;
+        }
+    }
+}
+
+// Append literal string to buffer; flush to fd when nearly full
+static void buf_append(int fd, char *buf, size_t *pos, const char *s) {
+    while (*s) {
+        if (*pos >= WRITE_BUF_SIZE - 32) {
+            safe_write(fd, buf, *pos);
+            *pos = 0;
+        }
+        buf[(*pos)++] = *s++;
+    }
+}
+
+// async-signal-safe: append long long as decimal (handles LLONG_MIN safely)
+static void buf_append_ll(int fd, char *buf, size_t *pos, long long val) {
+    char tmp[32];
+    int n = 0;
+    int negative = 0;
+    // 使用 unsigned long long 避免 -LLONG_MIN 溢出（未定义行为）
+    unsigned long long uval;
+    if (val < 0) {
+        negative = 1;
+        // 安全取反：-(val+1) 不会溢出，再 +1 得到正确绝对值
+        uval = (unsigned long long)(-(val + 1)) + 1ULL;
+    } else {
+        uval = (unsigned long long)val;
+    }
+    if (uval == 0) {
+        tmp[n++] = '0';
+    } else {
+        while (uval > 0) {
+            tmp[n++] = (char)('0' + (uval % 10));
+            uval /= 10;
+        }
+    }
+    if (*pos >= WRITE_BUF_SIZE - (size_t)n - 4) {
+        safe_write(fd, buf, *pos);
+        *pos = 0;
+    }
+    if (negative) {
+        buf[(*pos)++] = '-';
+    }
+    for (int i = n - 1; i >= 0; i--) {
+        buf[(*pos)++] = tmp[i];
+    }
+}
+
+// async-signal-safe: append pointer as "0x..." hex (no padding)
+static void buf_append_hex(int fd, char *buf, size_t *pos, uintptr_t val) {
+    static const char hex[] = "0123456789abcdef";
+    char tmp[20];
+    int n = 0;
+    if (val == 0) {
+        tmp[n++] = '0';
+    } else {
+        while (val > 0) {
+            tmp[n++] = hex[val & 0xF];
+            val >>= 4;
+        }
+    }
+    if (*pos >= WRITE_BUF_SIZE - (size_t)n - 4) {
+        safe_write(fd, buf, *pos);
+        *pos = 0;
+    }
+    buf[(*pos)++] = '0';
+    buf[(*pos)++] = 'x';
+    for (int i = n - 1; i >= 0; i--) {
+        buf[(*pos)++] = tmp[i];
+    }
+}
+
+// Map signal number to name (static, no allocation)
+static const char *signal_name(int signum) {
+    switch (signum) {
+        case SIGSEGV: return "SIGSEGV";
+        case SIGABRT: return "SIGABRT";
+        case SIGBUS:  return "SIGBUS";
+        case SIGFPE:  return "SIGFPE";
+        case SIGILL:  return "SIGILL";
+        case SIGTRAP: return "SIGTRAP";
+        default:      return "UNKNOWN";
+    }
+}
+
+// Emit "key":"hex_value", or "key":"hex_value" depending on trailing flag
+static void emit_reg(int fd, char *buf, size_t *pos,
+                     const char *key, uintptr_t val, int trailing_comma) {
+    buf_append(fd, buf, pos, "\"");
+    buf_append(fd, buf, pos, key);
+    buf_append(fd, buf, pos, "\":\"");
+    buf_append_hex(fd, buf, pos, val);
+    buf_append(fd, buf, pos, "\"");
+    if (trailing_comma) {
+        buf_append(fd, buf, pos, ",");
+    }
+}
+
+// Escape and copy raw bytes into a JSON string value.
+// Only escapes backslash, double-quote, and control chars.
+static void buf_append_escaped(int fd, char *buf, size_t *pos,
+                               const char *src, size_t len) {
+    for (size_t i = 0; i < len; i++) {
+        char c = src[i];
+        // ensure room for at most a 6-byte escape (\u00XX)
+        if (*pos >= WRITE_BUF_SIZE - 8) {
+            safe_write(fd, buf, *pos);
+            *pos = 0;
+        }
+        if (c == '\\' || c == '"') {
+            buf[(*pos)++] = '\\';
+            buf[(*pos)++] = c;
+        } else if (c == '\n') {
+            buf[(*pos)++] = '\\';
+            buf[(*pos)++] = 'n';
+        } else if (c == '\r') {
+            buf[(*pos)++] = '\\';
+            buf[(*pos)++] = 'r';
+        } else if (c == '\t') {
+            buf[(*pos)++] = '\\';
+            buf[(*pos)++] = 't';
+        } else if ((unsigned char)c < 0x20) {
+            // skip other control chars
+        } else {
+            buf[(*pos)++] = c;
+        }
+    }
+}
+
+// 取路径 basename（最后一个 '/' 之后的部分），写入 *out_bn / *out_len。
+static void basename_of(const char *path, int len,
+                        const char **out_bn, int *out_len) {
+    const char *bn = path;
+    int bnlen = len;
+    for (int k = 0; k < len; k++) {
+        if (path[k] == '/') {
+            bn = path + k + 1;
+            bnlen = len - k - 1;
+        }
+    }
+    *out_bn = bn;
+    *out_len = bnlen;
+}
+
+// async-signal-safe: 输出单个栈帧 JSON 对象，并收集被引用模块地址。
+// 仅使用栈上数组、整数运算、safe_write，符合信号处理器约束。
+static void emit_frame(int fd, char *buf, size_t *pos,
+                       uintptr_t addr,
+                       uintptr_t *referenced_addrs, int *referenced_count,
+                       int *is_first) {
+    if (!*is_first) {
+        buf_append(fd, buf, pos, ",");
+    }
+    *is_first = 0;
+
+    buf_append(fd, buf, pos, "{\"address\":\"");
+    buf_append_hex(fd, buf, pos, addr);
+    buf_append(fd, buf, pos, "\"");
+
+    int si = rum_module_index_for_addr(addr);
+    if (si >= 0) {
+        uintptr_t base = rum_module_base_for_seg(si);
+
+        // 记录被引用模块的 image_addr（去重），供 binary_images 过滤
+        if (base != 0 && *referenced_count < MAX_REFERENCED_MODULES) {
+            int found = 0;
+            for (int r = 0; r < *referenced_count; r++) {
+                if (referenced_addrs[r] == base) {
+                    found = 1;
+                    break;
+                }
+            }
+            if (!found) {
+                referenced_addrs[(*referenced_count)++] = base;
+            }
+        }
+
+        int plen = 0;
+        const char *path = rum_seg_path(si, &plen);
+        if (path != NULL && plen > 0) {
+            const char *bn;
+            int bnlen;
+            basename_of(path, plen, &bn, &bnlen);
+            buf_append(fd, buf, pos, ",\"library\":\"");
+            buf_append_escaped(fd, buf, pos, bn, (size_t)bnlen);
+            buf_append(fd, buf, pos, "\",\"image_addr\":\"");
+            buf_append_hex(fd, buf, pos, base);
+            buf_append(fd, buf, pos, "\",\"offset\":\"");
+            buf_append_hex(fd, buf, pos, addr - base);
+            buf_append(fd, buf, pos, "\"");
+        }
+    }
+    buf_append(fd, buf, pos, "}");
+}
+
+void rum_write_crash(int fd, int signum, siginfo_t *info, ucontext_t *uc,
+                      void **frames, int frame_count) {
+    static char g_write_buf[WRITE_BUF_SIZE];
+    size_t pos = 0;
+    char *buf = g_write_buf;
+
+    // 获取秒级与毫秒级时间戳（clock_gettime 是 POSIX.1-2008 async-signal-safe）
+    struct timespec ts;
+    long long timestamp_ms = 0;
+    long long timestamp_sec = 0;
+    if (clock_gettime(CLOCK_REALTIME, &ts) == 0) {
+        timestamp_ms = (long long)ts.tv_sec * 1000 + (long long)ts.tv_nsec / 1000000;
+        timestamp_sec = (long long)ts.tv_sec;
+    } else {
+        // 极端 fallback：clock_gettime 失败时退回 time()
+        timestamp_sec = (long long)time(NULL);
+        timestamp_ms = timestamp_sec * 1000;
+    }
+
+    // {"crash_id":"crash_native_{timestamp}_{pid}","timestamp":<ms>,
+    // crash_id 中保持秒级 timestamp 作为文件名标识，不影响时间显示
+    buf_append(fd, buf, &pos, "{\"crash_id\":\"crash_native_");
+    buf_append_ll(fd, buf, &pos, timestamp_sec);
+    buf_append(fd, buf, &pos, "_");
+    buf_append_ll(fd, buf, &pos, (long long)getpid());
+    buf_append(fd, buf, &pos, "\",\"timestamp\":");
+    buf_append_ll(fd, buf, &pos, timestamp_ms);
+
+    // "signal":{...},
+    buf_append(fd, buf, &pos, ",\"signal\":{\"number\":");
+    buf_append_ll(fd, buf, &pos, (long long)signum);
+    buf_append(fd, buf, &pos, ",\"name\":\"");
+    buf_append(fd, buf, &pos, signal_name(signum));
+    buf_append(fd, buf, &pos, "\"");
+    if (info != NULL) {
+        buf_append(fd, buf, &pos, ",\"code\":");
+        buf_append_ll(fd, buf, &pos, (long long)info->si_code);
+        buf_append(fd, buf, &pos, ",\"fault_address\":\"");
+        buf_append_hex(fd, buf, &pos, (uintptr_t)info->si_addr);
+        buf_append(fd, buf, &pos, "\"");
+    }
+    buf_append(fd, buf, &pos, "}");
+
+    // "pid","tid"
+    buf_append(fd, buf, &pos, ",\"pid\":");
+    buf_append_ll(fd, buf, &pos, (long long)getpid());
+    buf_append(fd, buf, &pos, ",\"tid\":");
+    buf_append_ll(fd, buf, &pos, (long long)gettid());
+
+    // "arch": per-build
+    buf_append(fd, buf, &pos, ",\"arch\":\"");
+#if defined(__aarch64__)
+    buf_append(fd, buf, &pos, "arm64");
+#elif defined(__arm__)
+    buf_append(fd, buf, &pos, "arm");
+#elif defined(__x86_64__)
+    buf_append(fd, buf, &pos, "x86_64");
+#elif defined(__i386__)
+    buf_append(fd, buf, &pos, "x86");
+#else
+    buf_append(fd, buf, &pos, "unknown");
+#endif
+    buf_append(fd, buf, &pos, "\"");
+
+    // "registers":{...}
+    buf_append(fd, buf, &pos, ",\"registers\":{");
+    if (uc != NULL) {
+#if defined(__aarch64__)
+        emit_reg(fd, buf, &pos, "pc", (uintptr_t)uc->uc_mcontext.pc, 1);
+        emit_reg(fd, buf, &pos, "lr", (uintptr_t)uc->uc_mcontext.regs[30], 1);
+        emit_reg(fd, buf, &pos, "sp", (uintptr_t)uc->uc_mcontext.sp, 1);
+        emit_reg(fd, buf, &pos, "fp", (uintptr_t)uc->uc_mcontext.regs[29], 0);
+#elif defined(__arm__)
+        emit_reg(fd, buf, &pos, "pc", (uintptr_t)uc->uc_mcontext.arm_pc, 1);
+        emit_reg(fd, buf, &pos, "lr", (uintptr_t)uc->uc_mcontext.arm_lr, 1);
+        emit_reg(fd, buf, &pos, "sp", (uintptr_t)uc->uc_mcontext.arm_sp, 1);
+        emit_reg(fd, buf, &pos, "fp", (uintptr_t)uc->uc_mcontext.arm_fp, 0);
+#elif defined(__x86_64__)
+        emit_reg(fd, buf, &pos, "pc", (uintptr_t)uc->uc_mcontext.gregs[REG_RIP], 1);
+        emit_reg(fd, buf, &pos, "sp", (uintptr_t)uc->uc_mcontext.gregs[REG_RSP], 1);
+        emit_reg(fd, buf, &pos, "fp", (uintptr_t)uc->uc_mcontext.gregs[REG_RBP], 0);
+#elif defined(__i386__)
+        emit_reg(fd, buf, &pos, "pc", (uintptr_t)uc->uc_mcontext.gregs[REG_EIP], 1);
+        emit_reg(fd, buf, &pos, "sp", (uintptr_t)uc->uc_mcontext.gregs[REG_ESP], 1);
+        emit_reg(fd, buf, &pos, "fp", (uintptr_t)uc->uc_mcontext.gregs[REG_EBP], 0);
+#endif
+    }
+    buf_append(fd, buf, &pos, "}");
+
+    // 解析 /proc/self/maps（async-signal-safe），为帧提供模块归属与相对偏移
+    rum_modules_parse();
+    // 构建去重模块列表，供 emit_frame 获取模块级基址和 binary_images 枚举使用。
+    // 必须在 frames 循环前调用，确保 rum_module_base_for_seg() 能查到模块。
+    int mod_count = rum_module_build_distinct();
+
+    // binary_images 按需过滤：仅保留被栈帧引用的模块。
+    // 参照 Sentry 实践，服务端符号化时忽略未被任何栈帧引用的模块，
+    // 客户端过滤可减少 70-90% 的 binary_images 数据量。
+    // 数组大小 32 足够：帧最多 256 个，去重后引用的模块通常 3-10 个。
+    // 所有操作仅为内存读写与整数比较，符合 async-signal-safe。
+    uintptr_t referenced_addrs[MAX_REFERENCED_MODULES];
+    int referenced_count = 0;
+
+    // "frames":[{"address","library","image_addr","offset"}, ...]
+    // library/offset 供后端结合 binary_images 的 build_id 精确符号化
+    //
+    // NDK 信号处理器最多采集 MAX_FRAMES(512) 帧。frame_count 达到
+    // TRUNCATION_THRESHOLD(512) 时说明实际栈可能更长（已达到采集上限），
+    // 此时全部输出 512 帧 + 尾部标记帧（omitted_count=-1 表示实际总帧数
+    // 未知），不做双侧截断——因为 NDK 只能获取前 512 帧，前 256 + 后 256
+    // 恰好覆盖全部 512 帧，中间无省略，插入中间标记帧会造成冗余。
+    // frame_count < TRUNCATION_THRESHOLD 时全部输出，不截断。
+    // 所有操作仅为栈上数组读写与整数比较，符合 async-signal-safe。
+    buf_append(fd, buf, &pos, ",\"frames\":[");
+    int needs_tail_marker = (frame_count >= TRUNCATION_THRESHOLD);
+    int first = 1;
+
+    for (int i = 0; i < frame_count; i++) {
+        emit_frame(fd, buf, &pos, (uintptr_t)frames[i],
+                   referenced_addrs, &referenced_count, &first);
+    }
+
+    if (needs_tail_marker) {
+        // 尾部标记帧（omitted_count=-1 表示实际总帧数未知）
+        if (!first) {
+            buf_append(fd, buf, &pos, ",");
+        }
+        buf_append(fd, buf, &pos, "{\"truncated\":true,\"omitted_count\":-1}");
+    }
+    buf_append(fd, buf, &pos, "]");
+
+    // 在进入 binary_images 循环前，先刷新核心崩溃数据到磁盘。
+    // binary_images 枚举需调用 rum_module_build_id_hex() 读取各模块 ELF 头，
+    // 若某模块地址未映射可能触发二次 SIGSEGV。提前刷新确保 crash_id、
+    // timestamp、signal、registers、frames 等核心数据已落盘，
+    // 即使后续崩溃也能被后端解析恢复。
+    if (pos > 0) {
+        safe_write(fd, buf, pos);
+        pos = 0;
+    }
+
+    // "binary_images":[{"name","build_id","image_addr","image_size"}, ...]
+    // 仅上报带 GNU build-id 的 file-backed 模块（build-id 等价于 iOS image uuid，
+    // 用于后端精确匹配符号文件）。
+    buf_append(fd, buf, &pos, ",\"binary_images\":[");
+    int emitted = 0;
+    char bid[BUILD_ID_HEX_CAP];
+    for (int m = 0; m < mod_count; m++) {
+        uintptr_t base = rum_module_image_addr(m);
+
+        // 按需过滤：若已收集到被引用的模块地址，则跳过未被引用的模块。
+        // referenced_count == 0（未收集到引用）或 == MAX_REFERENCED_MODULES
+        // （达到上限，可能有第 33+ 个被引用模块未被记录）时不过滤，
+        // 输出全部模块作为 fallback，确保不丢失符号化信息。
+        if (referenced_count > 0 && referenced_count < MAX_REFERENCED_MODULES) {
+            int is_referenced = 0;
+            for (int r = 0; r < referenced_count; r++) {
+                if (referenced_addrs[r] == base) {
+                    is_referenced = 1;
+                    break;
+                }
+            }
+            if (!is_referenced) {
+                continue;
+            }
+        }
+
+        int n = rum_module_build_id_hex(base, bid, BUILD_ID_HEX_CAP - 1);
+        if (n <= 0) {
+            continue;  // 无 build-id 的模块不上报
+        }
+        bid[n] = '\0';
+
+        if (emitted > 0) {
+            buf_append(fd, buf, &pos, ",");
+        }
+        emitted++;
+
+        int nlen = 0;
+        const char *name = rum_module_name(m, &nlen);
+        const char *bn = name;
+        int bnlen = nlen;
+        if (name != NULL && nlen > 0) {
+            basename_of(name, nlen, &bn, &bnlen);
+        }
+        // type 字段为 Sentry debug_meta 规范必填，ELF 平台固定 "elf"
+        buf_append(fd, buf, &pos, "{\"type\":\"elf\",\"name\":\"");
+        if (bn != NULL && bnlen > 0) {
+            buf_append_escaped(fd, buf, &pos, bn, (size_t)bnlen);
+        }
+        buf_append(fd, buf, &pos, "\",\"build_id\":\"");
+        buf_append(fd, buf, &pos, bid);
+        buf_append(fd, buf, &pos, "\",\"image_addr\":\"");
+        buf_append_hex(fd, buf, &pos, base);
+        // image_size 为数字类型（Sentry 规范要求），使用十进制写入
+        buf_append(fd, buf, &pos, "\",\"image_size\":");
+        buf_append_ll(fd, buf, &pos, (long long)rum_module_image_size(m));
+        buf_append(fd, buf, &pos, "}");
+    }
+    buf_append(fd, buf, &pos, "]");
+
+    // close JSON
+    buf_append(fd, buf, &pos, "}\n");
+
+    // flush remainder
+    if (pos > 0) {
+        safe_write(fd, buf, pos);
+    }
+}