Allow specifying a callback. Don't write files.

Author: mitar

binding.gyp

@@ -6,10 +6,11 @@
         "src/segfault-handler.cpp"
       ],
       "defines": [ "DEBUG", "_DEBUG" ],
-      # DDOPSON-2013-04-16 - Some versions of node-gyp don't seem to respect "cflags" (eg, my v0.8.2)
-      # I hacked the module src to thart the over-optimization issue that previously required -O0, so we work even w/o the flag
-      # However, the -O0 flag is still preferable for this module where debuggability matters and code size / perf are non-issues
-      "cflags": [ "-O0" ],
+      "cflags": [ "-O0", "-g" ],
+      "xcode_settings": {
+        "OTHER_CFLAGS": [ "-O0", "-g"],
+        "OTHER_LFLAGS": [ "-O0", "-g"]
+      }
     }
   ]
 }

src/segfault-handler.cpp

@@ -18,35 +18,37 @@ using namespace node;
 
 #define STDERR_FD 2
 
+static Persistent<Function> callback;
+static bool handlersSet = false;
+
 static void segfault_handler(int sig, siginfo_t *si, void *unused) {
   void    *array[32]; // Array to store backtrace symbols
   size_t  size;       // To store the size of the stack backtrace
   char    sbuff[128];
   int     n;          // chars written to buffer
-  int     fd;
-  time_t  now;
   int     pid;
 
-  // Construct a filename
-  time(&now);
   pid = getpid();
-  snprintf(sbuff, sizeof(sbuff), "stacktrace-%d-%d.log", (int)now, pid );
 
-  // Open the File
-  fd = open(sbuff, O_CREAT | O_APPEND | O_WRONLY, S_IRUSR | S_IRGRP | S_IROTH);
-  // Write the header line
-  n = snprintf(sbuff, sizeof(sbuff), "PID %d received SIGSEGV for address: 0x%lx\n", pid, (long) si->si_addr);
-  if(fd > 0) write(fd, sbuff, n);
+  n = snprintf(sbuff, sizeof(sbuff), "PID %d received SIGSEGV/SIGBUS (%i) for address: 0x%lx\n", pid, si->si_signo, (long)si->si_addr);
   write(STDERR_FD, sbuff, n);
 
-  // Write the Backtrace
   size = backtrace(array, 32);
-  if(fd > 0) backtrace_symbols_fd(array, size, fd);
   backtrace_symbols_fd(array, size, STDERR_FD);
 
-  // Exit violently
-  close(fd);
-  exit(-1);
+  if (!callback.IsEmpty()) {
+    char **stack = backtrace_symbols(array, size);
+    Local<Array> argStack = Local<Array>::New(Array::New(size));
+    for (size_t i = 0; i < size; i++) {
+      argStack->Set(i, String::New(stack[i]));
+    }
+    Local<Value> argv[3] = {argStack, Local<Value>::New(Number::New(si->si_signo)), Local<Value>::New(Number::New((long)si->si_addr))};
+    callback->Call(Context::GetCurrent()->Global(), 3, argv);
+    free(stack);
+  }
+
+  // Re-send the signal, this time a default handler will be called
+  kill(pid, si->si_signo);
 }
 
 // create some stack frames to inspect from CauseSegfault
@@ -62,7 +64,6 @@ void segfault_stack_frame_1()
   int *foo = (int*)1;
   printf("NodeSegfaultHandlerNative: about to dereference NULL (will cause a SIGSEGV)\n");
   *foo = 78; // trigger a SIGSEGV
-
 }
 
 __attribute__ ((noinline)) 
@@ -80,13 +81,34 @@ Handle<Value> CauseSegfault(const Arguments& args) {
 }
 
 Handle<Value> RegisterHandler(const Arguments& args) {
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(struct sigaction));
-  sigemptyset(&sa.sa_mask);
-  sa.sa_sigaction = segfault_handler;
-  sa.sa_flags   = SA_SIGINFO;
-  sigaction(SIGSEGV, &sa, NULL);
-  return Undefined();
+  HandleScope scope;
+
+  if (args.Length() > 0) {
+    if (!args[0]->IsFunction()) {
+      ThrowException(Exception::TypeError(String::New("Invalid callback argument")));
+      return scope.Close(Undefined());
+    }
+
+    if (!callback.IsEmpty()) {
+      callback.Dispose();
+      callback.Clear();
+    }
+    callback = Persistent<Function>::New(Handle<Function>::Cast(args[0]));
+  }
+
+  // Set our handler only once
+  if (!handlersSet) {
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(struct sigaction));
+    sigemptyset(&sa.sa_mask);
+    sa.sa_sigaction = segfault_handler;
+    sa.sa_flags = SA_SIGINFO | SA_RESETHAND; // We set SA_RESETHAND so that our handler is called only once
+    sigaction(SIGSEGV, &sa, NULL);
+    sigaction(SIGBUS, &sa, NULL);
+    handlersSet = true;
+  }
+
+  return scope.Close(Undefined());
 }
 
 extern "C" {