first commit

Author: cppcoffee

.gitignore

@@ -0,0 +1,54 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+example
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+

Makefile

@@ -0,0 +1,43 @@
+# tool macros
+CC := cc
+CCFLAGS := -g -Wall
+LIBS := -lbfd
+CCOBJFLAGS := $(CCFLAGS) -c
+
+
+# compile macros
+TARGET := example
+SRC_PATH := .
+OBJ_PATH := .
+
+
+# src files & obj files
+SRC := $(foreach x, $(SRC_PATH), $(wildcard $(addprefix $(x)/*,.c*)))
+OBJ := $(addprefix $(OBJ_PATH)/, $(addsuffix .o, $(notdir $(basename $(SRC)))))
+
+
+# clean files list
+CLEAN_LIST := $(TARGET) $(OBJ)
+
+
+# default rule
+default: all
+
+
+# non-phony targets
+$(TARGET): $(OBJ)
+	$(CC) $(CCFLAGS) -o $@ $(OBJ) $(LIBS)
+
+$(OBJ_PATH)/%.o: $(SRC_PATH)/%.c*
+	$(CC) $(CCOBJFLAGS) -o $@ $<
+
+
+# phony rules
+.PHONY: all
+all: $(TARGET)
+
+.PHONY: clean
+clean:
+	@echo CLEAN $(CLEAN_LIST)
+	@rm -f $(CLEAN_LIST)
+

example.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include "stacktrace.h"
+
+
+static void bar()
+{
+    char *p = 0;
+    *p = 'a';
+}
+
+
+static void foo()
+{
+    bar();
+}
+
+
+int main()
+{
+    init_stacktrace();
+
+    foo();
+
+    return 0;
+}
+

stacktrace.c

@@ -0,0 +1,211 @@
+#define _GNU_SOURCE
+#include <execinfo.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include "symbol_table.h"
+
+
+// The max number of levels in the stack trace
+#define STACK_TRACE_MAX_LEVELS  100
+#define BUFFER_LENGTH           4096
+
+
+typedef void (*signal_handler_t)(int signo, siginfo_t *info, void *ctx);
+
+static void register_crash_handlers();
+static int backtrace_symbol_write(int fd, const char *text, void *addr);
+
+
+// store process full path.
+static char program_path[PATH_MAX];
+// the current program binary symbol table.
+static symbol_table_t symtab;
+
+
+// initialize stacktrace library.
+int init_stacktrace()
+{
+    int n;
+
+    n = readlink("/proc/self/exe", program_path, PATH_MAX);
+    if (n < 0 || n >= PATH_MAX) {
+        return -1;
+    }
+
+    program_path[n] = '\0';
+
+    if (symbol_table_build(program_path, &symtab) != 0) {
+        return -2;
+    }
+
+    register_crash_handlers();
+
+    return 0;
+}
+
+
+static void
+stack_trace_dump()
+{
+    int             i, btl;
+    char          **strings;
+    void           *stack[STACK_TRACE_MAX_LEVELS + 1];
+    const char     *msg = " - STACK TRACE: \n";
+
+    if (write(STDERR_FILENO, program_path, strlen(program_path)) == -1) {
+        return;
+    }
+
+    if (write(STDERR_FILENO, msg, strlen(msg)) == -1) {
+        return;
+    }
+
+    memset(stack, 0, sizeof(stack));
+
+    if ((btl = backtrace(stack, STACK_TRACE_MAX_LEVELS)) > 2) {
+        strings = backtrace_symbols(stack, btl);
+        if (strings != NULL) {
+            for (i = 2; i < btl; i++) {
+                backtrace_symbol_write(STDERR_FILENO, strings[i], stack[i]);
+            }
+
+            free(strings);
+
+        } else {
+            backtrace_symbols_fd(stack + 2, btl - 2, STDERR_FILENO);
+        }
+    }
+}
+
+
+// Reset a signal handler to the default handler.
+static void
+signal_reset_default(int signo)
+{
+    struct sigaction act;
+
+    act.sa_handler = SIG_DFL;
+    act.sa_flags   = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
+    sigemptyset(&(act.sa_mask));
+
+    assert(sigaction(signo, &act, NULL) == 0);
+}
+
+
+static void
+signal_crash_handler(int signo, siginfo_t *siginfo, void *data)
+{
+    stack_trace_dump();
+
+    signal_reset_default(signo);
+    // throw signal to default handler.
+    raise(signo);
+}
+
+
+static void
+set_signal(int signo, signal_handler_t handler)
+{
+    struct sigaction act;
+
+    act.sa_handler   = NULL;
+    act.sa_sigaction = handler;
+    act.sa_flags     = SA_SIGINFO;
+    sigemptyset(&(act.sa_mask));
+
+    assert(sigaction(signo, &act, NULL) == 0);
+}
+
+
+static void
+register_crash_handlers()
+{
+    set_signal(SIGBUS,  signal_crash_handler);
+    set_signal(SIGSEGV, signal_crash_handler);
+    set_signal(SIGILL,  signal_crash_handler);
+    set_signal(SIGTRAP, signal_crash_handler);
+    set_signal(SIGFPE,  signal_crash_handler);
+    set_signal(SIGABRT, signal_crash_handler);
+}
+
+
+static int
+backtrace_symbol_format(char *buf, size_t len, const char *prefix, frame_record_t fr)
+{
+    int     n;
+    char   *p = buf;
+
+    // file name
+    if (fr.filename != NULL) {
+        n = snprintf(p, len, "%s %s", prefix, fr.filename);
+
+    } else {
+        n = snprintf(p, len, "%s ??", prefix);
+    }
+
+    p += n;
+    len -= n;
+
+    // function name
+    if (fr.functionname != NULL && *fr.functionname != '\0') {
+        n = snprintf(p, len, " %s()", fr.functionname);
+
+    } else {
+        n = snprintf(p, len, " ??");
+    }
+
+    p += n;
+    len -= n;
+
+    // line
+    if (fr.line != 0) {
+        n = snprintf(p, len, ":%u", fr.line);
+
+        p += n;
+        len -= n;
+    }
+
+    // discriminator
+    if (fr.discriminator != 0) {
+        n = snprintf(p, len, " (discriminator %u)\n", fr.discriminator);
+
+    } else {
+        n = snprintf(p, len, "\n");
+    }
+
+    p += n;
+    len -= n;
+
+    return p - buf;
+}
+
+
+static int
+backtrace_symbol_write(int fd, const char *text, void *addr)
+{
+    frame_record_t  fr;
+    int             n;
+    char            buf[BUFFER_LENGTH + 1];
+
+    if (symbol_table_find(&symtab, addr, &fr)) {
+        n = backtrace_symbol_format(buf, BUFFER_LENGTH, text, fr);
+
+    } else {
+        n = snprintf(buf, BUFFER_LENGTH, "%s\n", text);
+    }
+
+    buf[n] = '\0';
+
+    if (write(fd, buf, strlen(buf)) == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+

stacktrace.h

@@ -0,0 +1,18 @@
+#ifndef __STACKTRACE_H__
+#define __STACKTRACE_H__
+
+
+/*
+ * Initialize stack trace library.
+ * DESCRIPTION
+ *  call init_stacktrace register crash signal handler.
+ *  if process crash, this library outputs the stack calls to stderr.
+ *
+ * RETURN VALUE
+ * - On success, init_stacktrace return 0.
+ * - On error, -1 is returned.
+ */
+int init_stacktrace();
+
+
+#endif /* __STACKTRACE_H__ */