register exception handlers

Signed-off-by: Luca Mondada <luca@mondada.net>

Author: lmondada

runtime/cudaq/cudaq.cpp

@@ -16,11 +16,16 @@
 #endif
 #include "cudaq/platform.h"
 #include "distributed/mpi_plugin.h"
+#include <cstring>
 #include <dlfcn.h>
+#include <execinfo.h>
+#include <fcntl.h>
 #include <filesystem>
 #include <map>
 #include <signal.h>
 #include <string>
+#include <sys/ucontext.h>
+#include <unistd.h>
 #include <vector>
 namespace nvqir {
 void tearDownBeforeMPIFinalize();
@@ -253,12 +258,264 @@ void cudaqCtrlCHandler(int signal) {
   std::exit(1);
 }
 
+// #region agent log - SIGSEGV handler for debugging
+void cudaqSegfaultHandler(int sig, siginfo_t *info, void *context) {
+  char buf[512];
+  int len;
+
+  // Header with signal type
+  const char *sig_name = "UNKNOWN";
+  if (sig == SIGSEGV)
+    sig_name = "SIGSEGV (Segmentation Fault)";
+  else if (sig == SIGBUS)
+    sig_name = "SIGBUS (Bus Error)";
+  else if (sig == SIGABRT)
+    sig_name = "SIGABRT (Abort)";
+  else if (sig == SIGFPE)
+    sig_name = "SIGFPE (Floating Point Exception)";
+  else if (sig == SIGILL)
+    sig_name = "SIGILL (Illegal Instruction)";
+
+  len = snprintf(
+      buf, sizeof(buf),
+      "\n╔══════════════════════════════════════════════════════════════╗\n"
+      "║ FATAL SIGNAL: %s (%d)                                      \n"
+      "╚══════════════════════════════════════════════════════════════╝\n",
+      sig_name, sig);
+  write(STDERR_FILENO, buf, len);
+
+  // Fault address and signal code
+  len = snprintf(buf, sizeof(buf), "\n[FAULT INFO]\n");
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf), "  Fault address: %p\n", info->si_addr);
+  write(STDERR_FILENO, buf, len);
+
+  const char *code_str = "unknown";
+  if (sig == SIGSEGV) {
+    switch (info->si_code) {
+    case SEGV_MAPERR:
+      code_str = "SEGV_MAPERR (address not mapped to object)";
+      break;
+    case SEGV_ACCERR:
+      code_str = "SEGV_ACCERR (invalid permissions for mapped object)";
+      break;
+    }
+  } else if (sig == SIGBUS) {
+    switch (info->si_code) {
+    case BUS_ADRALN:
+      code_str = "BUS_ADRALN (invalid address alignment)";
+      break;
+    case BUS_ADRERR:
+      code_str = "BUS_ADRERR (nonexistent physical address)";
+      break;
+    case BUS_OBJERR:
+      code_str = "BUS_OBJERR (object-specific hardware error)";
+      break;
+    }
+  }
+  len = snprintf(buf, sizeof(buf), "  Signal code: %d (%s)\n", info->si_code,
+                 code_str);
+  write(STDERR_FILENO, buf, len);
+
+  // Register dump from ucontext (x86_64 Linux)
+#if defined(__x86_64__) && defined(__linux__)
+  ucontext_t *uc = (ucontext_t *)context;
+  mcontext_t *mc = &uc->uc_mcontext;
+
+  len = snprintf(buf, sizeof(buf), "\n[REGISTERS (x86_64)]\n");
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  RIP: %016llx   RSP: %016llx   RBP: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_RIP],
+                 (unsigned long long)mc->gregs[REG_RSP],
+                 (unsigned long long)mc->gregs[REG_RBP]);
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  RAX: %016llx   RBX: %016llx   RCX: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_RAX],
+                 (unsigned long long)mc->gregs[REG_RBX],
+                 (unsigned long long)mc->gregs[REG_RCX]);
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  RDX: %016llx   RSI: %016llx   RDI: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_RDX],
+                 (unsigned long long)mc->gregs[REG_RSI],
+                 (unsigned long long)mc->gregs[REG_RDI]);
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  R8:  %016llx   R9:  %016llx   R10: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_R8],
+                 (unsigned long long)mc->gregs[REG_R9],
+                 (unsigned long long)mc->gregs[REG_R10]);
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  R11: %016llx   R12: %016llx   R13: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_R11],
+                 (unsigned long long)mc->gregs[REG_R12],
+                 (unsigned long long)mc->gregs[REG_R13]);
+  write(STDERR_FILENO, buf, len);
+
+  len = snprintf(buf, sizeof(buf),
+                 "  R14: %016llx   R15: %016llx   EFLAGS: %016llx\n",
+                 (unsigned long long)mc->gregs[REG_R14],
+                 (unsigned long long)mc->gregs[REG_R15],
+                 (unsigned long long)mc->gregs[REG_EFL]);
+  write(STDERR_FILENO, buf, len);
+
+  // Check if we're running on alternate stack (important for stack corruption)
+  stack_t current_stack;
+  if (sigaltstack(NULL, &current_stack) == 0) {
+    const char *stack_status =
+        (current_stack.ss_flags & SS_ONSTACK)
+            ? "YES (good - handler is protected from stack corruption)"
+            : "NO (handler using main stack - may be unreliable if stack is "
+              "corrupted)";
+    len =
+        snprintf(buf, sizeof(buf),
+                 "\n[SIGNAL HANDLER STACK]\n  Running on alternate stack: %s\n",
+                 stack_status);
+    write(STDERR_FILENO, buf, len);
+  }
+
+  // Stack dump around RSP - be very careful here since stack may be corrupted
+  len =
+      snprintf(buf, sizeof(buf),
+               "\n[STACK DUMP around RSP (best effort - may be corrupted)]\n");
+  write(STDERR_FILENO, buf, len);
+
+  unsigned long long *sp = (unsigned long long *)mc->gregs[REG_RSP];
+
+  // Validate RSP looks reasonable before trying to read from it
+  // Check if it's in a plausible stack range (not null, not tiny, not huge)
+  if ((unsigned long long)sp < 0x10000 ||
+      (unsigned long long)sp > 0x7fffffffffff) {
+    len = snprintf(buf, sizeof(buf),
+                   "  RSP (%p) looks invalid - skipping stack dump\n",
+                   (void *)sp);
+    write(STDERR_FILENO, buf, len);
+  } else {
+    // Try to dump 8 words before and 32 words after RSP
+    // We use mincore() to check if pages are readable before accessing
+    for (int i = -8; i < 32; i++) {
+      unsigned long long *addr = sp + i;
+
+      // Skip obviously bad addresses
+      if ((unsigned long long)addr < 0x10000)
+        continue;
+      if ((unsigned long long)addr > 0x7fffffffffff)
+        continue;
+
+      // Try to read - if this crashes, SA_RESETHAND will let us die cleanly
+      unsigned long long val = 0;
+      volatile unsigned long long *vaddr = (volatile unsigned long long *)addr;
+      val = *vaddr;
+
+      const char *marker = (i == 0) ? " <-- RSP" : "";
+      len = snprintf(buf, sizeof(buf), "  [RSP%+3d] %p: %016llx%s\n", i * 8,
+                     (void *)addr, val, marker);
+      write(STDERR_FILENO, buf, len);
+    }
+  }
+#endif
+
+  // Backtrace with symbols
+  len = snprintf(buf, sizeof(buf), "\n[BACKTRACE]\n");
+  write(STDERR_FILENO, buf, len);
+
+  void *bt[128];
+  int bt_size = backtrace(bt, 128);
+  backtrace_symbols_fd(bt, bt_size, STDERR_FILENO);
+
+  // Try to read /proc/self/maps for memory layout
+  len = snprintf(buf, sizeof(buf), "\n[MEMORY MAP (from /proc/self/maps)]\n");
+  write(STDERR_FILENO, buf, len);
+
+  int maps_fd = open("/proc/self/maps", O_RDONLY);
+  if (maps_fd >= 0) {
+    char maps_buf[4096];
+    ssize_t bytes_read;
+    while ((bytes_read = read(maps_fd, maps_buf, sizeof(maps_buf))) > 0) {
+      write(STDERR_FILENO, maps_buf, bytes_read);
+    }
+    close(maps_fd);
+  } else {
+    const char *err = "  (could not read /proc/self/maps)\n";
+    write(STDERR_FILENO, err, strlen(err));
+  }
+
+  // Try to identify if fault address is near any known region
+  len = snprintf(
+      buf, sizeof(buf),
+      "\n[ANALYSIS HINTS]\n"
+      "  - If fault addr is 0x0-0xfff: NULL pointer dereference\n"
+      "  - If fault addr is near RSP: Stack overflow/corruption\n"
+      "  - If RIP is in unmapped region: Return address corruption\n"
+      "  - If during exception unwind: Check exception handling tables\n");
+  write(STDERR_FILENO, buf, len);
+
+  // Flush and exit
+  len = snprintf(
+      buf, sizeof(buf),
+      "\n╔══════════════════════════════════════════════════════════════╗\n"
+      "║ END OF CRASH DUMP - Re-raising signal for core dump          ║\n"
+      "╚══════════════════════════════════════════════════════════════╝\n\n");
+  write(STDERR_FILENO, buf, len);
+
+  // Re-raise to get core dump
+  signal(sig, SIG_DFL);
+  raise(sig);
+}
+// #endregion
+
+// #region agent log - Alternate signal stack for crash handler
+// This is critical: if the main stack is corrupted, the signal handler
+// needs its own stack to run on, otherwise it will crash too.
+// Use 64KB which is larger than typical SIGSTKSZ (8KB-32KB)
+static char altStackMem[65536];
+// #endregion
+
 __attribute__((constructor)) void startSigIntHandler() {
   struct sigaction sigIntHandler;
   sigIntHandler.sa_handler = cudaqCtrlCHandler;
   sigemptyset(&sigIntHandler.sa_mask);
   sigIntHandler.sa_flags = 0;
   sigaction(SIGINT, &sigIntHandler, NULL);
+
+  // #region agent log - Install alternate signal stack and SIGSEGV handler
+  // Set up alternate stack FIRST - this is crucial for handling stack
+  // corruption
+  stack_t altStack;
+  altStack.ss_sp = altStackMem;
+  altStack.ss_size = sizeof(altStackMem);
+  altStack.ss_flags = 0;
+  if (sigaltstack(&altStack, NULL) == 0) {
+    // Alternate stack set up successfully
+  } else {
+    // Failed to set up alt stack - handler will use main stack (risky if
+    // corrupted)
+    perror("Warning: sigaltstack failed, crash handler may not work with stack "
+           "corruption");
+  }
+
+  struct sigaction segvHandler;
+  segvHandler.sa_sigaction = cudaqSegfaultHandler;
+  sigemptyset(&segvHandler.sa_mask);
+  // SA_ONSTACK: Use alternate stack (critical for stack corruption)
+  // SA_SIGINFO: Get detailed info via siginfo_t
+  // SA_RESETHAND: Reset to default after first signal (prevent infinite loops)
+  segvHandler.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESETHAND;
+  sigaction(SIGSEGV, &segvHandler, NULL);
+  sigaction(SIGBUS, &segvHandler, NULL);  // Also catch bus errors
+  sigaction(SIGABRT, &segvHandler, NULL); // And aborts
+  sigaction(SIGFPE, &segvHandler, NULL);  // Floating point exceptions
+  sigaction(SIGILL, &segvHandler, NULL);  // Illegal instruction
+  // #endregion
 }
 } // namespace __internal__