kit

posix_dbg.c (12817B)

---

 /* POSIX dbg_os scaffolding shared across mac/linux/freebsd: pthreads for
  * worker thread and event objects, sigaction-based signal handling that
  * delegates per-(arch,OS) ucontext marshalling to dbg_ucontext_to_frame /
  * dbg_frame_to_ucontext, and a sigsetjmp-guarded memory copy.
  *
  * The W^X transitions (code_write_begin/end) and icache flush are wired
  * directly from the per-OS file, since they're the genuine divergence
  * point between Apple's alias-only model and the Linux/FreeBSD memfd
  * model.
  */
 
 #include <pthread.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "backtrace.h"
 #include "env_posix.h"
 
 /* Single-session process model (one debug target at a time). The signal
  * handler reads these from async-signal context; both writes happen in
  * signals_install before any signal can arrive, both clears happen in
  * signals_uninstall after restoring SIG_DFL. */
 static KitDbgSignalOps g_dbg_ops;
 static int g_dbg_ops_set;
 static void* g_dbg_session;
 static pthread_t g_dbg_worker_tid;
 static int g_dbg_worker_tid_valid;
 
 static const int g_dbg_signos[6] = {SIGTRAP, SIGSEGV, SIGBUS,
                                     SIGILL,  SIGFPE,  DBG_INTERRUPT_SIGNO};
 #define DBG_NSIGS ((int)(sizeof(g_dbg_signos) / sizeof(g_dbg_signos[0])))
 static struct sigaction g_dbg_prev_sa[DBG_NSIGS];
 static int g_dbg_installed;
 
 /* TLS landing slot for guarded_copy. The SEGV/BUS handler checks
  * g_guard_armed first; if set it siglongjmps back into guarded_copy
  * without touching on_fault. */
 static __thread sigjmp_buf g_guard_buf;
 static __thread int g_guard_armed;
 
 /* --- thread shim --- */
 
 typedef struct DbgThread {
   pthread_t tid;
   void (*fn)(void*);
   void* arg;
 } DbgThread;
 
 static void* dbg_thread_trampoline(void* p) {
   DbgThread* t = (DbgThread*)p;
   t->fn(t->arg);
   return NULL;
 }
 
 static KitStatus dbg_thread_start(void* user, void (*fn)(void*), void* arg,
                                   void** thread_out) {
   DbgThread* t;
   (void)user;
   t = (DbgThread*)malloc(sizeof(*t));
   if (!t) return KIT_NOMEM;
   t->fn = fn;
   t->arg = arg;
   if (pthread_create(&t->tid, NULL, dbg_thread_trampoline, t) != 0) {
     free(t);
     return KIT_ERR;
   }
   g_dbg_worker_tid = t->tid;
   g_dbg_worker_tid_valid = 1;
   *thread_out = t;
   return KIT_OK;
 }
 
 static void dbg_thread_join(void* user, void* thread) {
   DbgThread* t = (DbgThread*)thread;
   (void)user;
   if (!t) return;
   pthread_join(t->tid, NULL);
   g_dbg_worker_tid_valid = 0;
   free(t);
 }
 
 static KitStatus dbg_thread_interrupt(void* user, void* thread) {
   DbgThread* t = (DbgThread*)thread;
   (void)user;
   if (!t) return KIT_INVALID;
   return pthread_kill(t->tid, DBG_INTERRUPT_SIGNO) == 0 ? KIT_OK : KIT_ERR;
 }
 
 int posix_dbg_caller_is_worker(void) {
   return g_dbg_worker_tid_valid &&
          pthread_equal(pthread_self(), g_dbg_worker_tid);
 }
 
 /* --- event shim --- */
 
 typedef struct DbgEvent {
   pthread_mutex_t mu;
   pthread_cond_t cv;
   int signaled;
 } DbgEvent;
 
 static KitStatus dbg_event_new(void* user, void** event_out) {
   DbgEvent* e;
   (void)user;
   e = (DbgEvent*)malloc(sizeof(*e));
   if (!e) return KIT_NOMEM;
   if (pthread_mutex_init(&e->mu, NULL) != 0) {
     free(e);
     return KIT_ERR;
   }
   if (pthread_cond_init(&e->cv, NULL) != 0) {
     pthread_mutex_destroy(&e->mu);
     free(e);
     return KIT_ERR;
   }
   e->signaled = 0;
   *event_out = e;
   return KIT_OK;
 }
 
 static void dbg_event_free(void* user, void* ev) {
   DbgEvent* e = (DbgEvent*)ev;
   (void)user;
   if (!e) return;
   pthread_cond_destroy(&e->cv);
   pthread_mutex_destroy(&e->mu);
   free(e);
 }
 
 static KitStatus dbg_event_wait(void* user, void* ev) {
   DbgEvent* e = (DbgEvent*)ev;
   (void)user;
   pthread_mutex_lock(&e->mu);
   while (!e->signaled) pthread_cond_wait(&e->cv, &e->mu);
   e->signaled = 0;
   pthread_mutex_unlock(&e->mu);
   return KIT_OK;
 }
 
 /* pthread_cond_signal is not formally async-signal-safe per POSIX, but
  * it is in practice on glibc and Apple libc when callers manage the
  * signal mask carefully. LLDB and rr rely on the same pattern. */
 static KitStatus dbg_event_signal(void* user, void* ev) {
   DbgEvent* e = (DbgEvent*)ev;
   (void)user;
   pthread_mutex_lock(&e->mu);
   e->signaled = 1;
   pthread_cond_broadcast(&e->cv);
   pthread_mutex_unlock(&e->mu);
   return KIT_OK;
 }
 
 static KitStatus dbg_event_reset(void* user, void* ev) {
   DbgEvent* e = (DbgEvent*)ev;
   (void)user;
   pthread_mutex_lock(&e->mu);
   e->signaled = 0;
   pthread_mutex_unlock(&e->mu);
   return KIT_OK;
 }
 
 /* --- signal install + ucontext dispatch --- */
 
 static void dbg_signal_handler(int signo, siginfo_t* si, void* ucv) {
   ucontext_t* uc = (ucontext_t*)ucv;
   KitUnwindFrame frame;
   KitStatus rc;
   (void)si;
 
   /* SIGSEGV/SIGBUS during an armed guarded_copy: bail out to the
    * sigsetjmp landing slot before the session ever sees the fault. */
   if ((signo == SIGSEGV || signo == SIGBUS) && g_guard_armed) {
     g_guard_armed = 0;
     siglongjmp(g_guard_buf, 1);
   }
 
   /* Only the registered worker thread participates in stop-the-world.
    * Faults on other threads (e.g. the REPL) fall through to the default. */
   if (!posix_dbg_caller_is_worker() || !g_dbg_ops_set || !g_dbg_ops.on_fault) {
     int i;
     for (i = 0; i < DBG_NSIGS; ++i) {
       if (g_dbg_signos[i] == signo) {
         sigaction(signo, &g_dbg_prev_sa[i], NULL);
         break;
       }
     }
     raise(signo);
     return;
   }
 
   dbg_ucontext_to_frame(uc, &frame);
   rc = g_dbg_ops.on_fault(g_dbg_session, signo, &frame);
   if (rc != KIT_OK) {
     int i;
     for (i = 0; i < DBG_NSIGS; ++i) {
       if (g_dbg_signos[i] == signo) {
         sigaction(signo, &g_dbg_prev_sa[i], NULL);
         break;
       }
     }
     raise(signo);
     return;
   }
   dbg_frame_to_ucontext(&frame, uc);
 }
 
 static KitStatus dbg_signals_install(void* user, const KitDbgSignalOps* ops,
                                      void* session) {
   struct sigaction sa;
   int i;
   (void)user;
   if (g_dbg_installed) return KIT_ERR;
   g_dbg_ops = *ops;
   g_dbg_ops_set = 1;
   g_dbg_session = session;
 
   memset(&sa, 0, sizeof(sa));
   sa.sa_sigaction = dbg_signal_handler;
   sa.sa_flags = SA_SIGINFO | SA_RESTART;
   sigemptyset(&sa.sa_mask);
   for (i = 0; i < DBG_NSIGS; ++i) sigaddset(&sa.sa_mask, g_dbg_signos[i]);
 
   for (i = 0; i < DBG_NSIGS; ++i) {
     if (sigaction(g_dbg_signos[i], &sa, &g_dbg_prev_sa[i]) != 0) {
       int j;
       for (j = 0; j < i; ++j)
         sigaction(g_dbg_signos[j], &g_dbg_prev_sa[j], NULL);
       memset(&g_dbg_ops, 0, sizeof(g_dbg_ops));
       g_dbg_ops_set = 0;
       g_dbg_session = NULL;
       return KIT_ERR;
     }
   }
   g_dbg_installed = 1;
   return KIT_OK;
 }
 
 static void dbg_signals_uninstall(void* user) {
   int i;
   (void)user;
   if (!g_dbg_installed) return;
   for (i = 0; i < DBG_NSIGS; ++i)
     sigaction(g_dbg_signos[i], &g_dbg_prev_sa[i], NULL);
   g_dbg_installed = 0;
   memset(&g_dbg_ops, 0, sizeof(g_dbg_ops));
   g_dbg_ops_set = 0;
   g_dbg_session = NULL;
 }
 
 /* --- guarded copy --- */
 
 static KitStatus dbg_guarded_copy(void* user, void* dst, const void* src,
                                   size_t n) {
   (void)user;
   if (sigsetjmp(g_guard_buf, 1) != 0) {
     g_guard_armed = 0;
     return KIT_ERR; /* SIGSEGV/SIGBUS during the copy */
   }
   g_guard_armed = 1;
   memcpy(dst, src, n);
   g_guard_armed = 0;
   return KIT_OK;
 }
 
 static __thread sigjmp_buf g_dbg_abort_buf;
 
 static int dbg_call_with_catch(void* user, void (*fn)(void*), void* arg) {
   (void)user;
   if (sigsetjmp(g_dbg_abort_buf, 1) == 0) {
     fn(arg);
     return 0;
   }
   return 1;
 }
 
 static void dbg_thread_abort(void* user) {
   (void)user;
   siglongjmp(g_dbg_abort_buf, 1);
 }
 
 /* --- kit run crash guard --------------------------------------------------
  * Independent of the session machinery above (no worker thread, no KitDbgOs):
  * `kit run` calls the JITed entry directly in-process, sharing its stack with
  * the program. So we catch a fatal fault, marshal the faulting frame via the
  * same per-(arch,OS) ucontext path the session uses, and walk the frame-pointer
  * chain *here in the handler* — where those frames are still intact. After the
  * siglongjmp the guard's own call frames reuse that stack, so the walk must
  * finish first; only the captured return-address list survives, to be
  * symbolized later in normal context (DWARF/malloc/printf never run async). */
 
 #define RUN_BT_MAX 256
 static const int g_run_signos[6] = {SIGSEGV, SIGBUS,  SIGILL,
                                     SIGFPE,  SIGABRT, SIGTRAP};
 #define RUN_NSIGS ((int)(sizeof(g_run_signos) / sizeof(g_run_signos[0])))
 static struct sigaction g_run_prev_sa[RUN_NSIGS];
 static int g_run_installed;
 
 static sigjmp_buf g_run_crash_buf; /* fault -> back into the guard */
 static volatile sig_atomic_t g_run_crash_armed;
 static KitArchKind g_run_crash_arch;
 static int g_run_crash_signo;
 static uint64_t g_run_crash_pcs[RUN_BT_MAX];
 static int g_run_crash_npcs;
 
 static void run_crash_restore(void) {
   int i;
   if (!g_run_installed) return;
   for (i = 0; i < RUN_NSIGS; ++i)
     sigaction(g_run_signos[i], &g_run_prev_sa[i], NULL);
   g_run_installed = 0;
 }
 
 /* Raw in-handler memory read. The FP-walk guards (alignment, strictly
  * increasing fp, bounded depth) keep this from running away on a corrupt
  * chain, mirroring rt's __kit_backtrace. */
 static KitStatus run_raw_read(void* user, uint64_t addr, void* dst, size_t n) {
   (void)user;
   memcpy(dst, (const void*)(uintptr_t)addr, n);
   return KIT_OK;
 }
 
 static void run_crash_handler(int signo, siginfo_t* si, void* ucv) {
   ucontext_t* uc = (ucontext_t*)ucv;
   (void)si;
   if (g_run_crash_armed) {
     KitUnwindFrame fr;
     int fpreg, n = 0;
     g_run_crash_armed = 0;
     g_run_crash_signo = signo;
     dbg_ucontext_to_frame(uc, &fr);
     g_run_crash_pcs[n++] = fr.pc; /* frame #0 = the faulting PC */
     fpreg = driver_bt_fp_dwarf_reg(g_run_crash_arch);
     if (fpreg >= 0) {
       uint64_t fp = fr.regs[fpreg], ra = 0, next_fp = 0;
       while (n < RUN_BT_MAX && driver_bt_fp_step(g_run_crash_arch, run_raw_read,
                                                  NULL, fp, &ra, &next_fp)) {
         g_run_crash_pcs[n++] = ra;
         fp = next_fp;
       }
     }
     g_run_crash_npcs = n;
     siglongjmp(g_run_crash_buf, 1);
   }
   /* Not ours (or a fault after disarm): restore the default disposition for
    * this signal and re-raise so the process dies as it would have. */
   {
     int i;
     for (i = 0; i < RUN_NSIGS; ++i)
       if (g_run_signos[i] == signo) {
         sigaction(signo, &g_run_prev_sa[i], NULL);
         break;
       }
   }
   raise(signo);
 }
 
 int driver_run_with_crash_guard(DriverEnv* env, KitArchKind arch,
                                 DriverRunEntryFn entry, int argc, char** argv,
                                 int* ret_out, DriverRunCrashFn on_crash,
                                 void* user) {
   struct sigaction sa;
   int i;
   (void)env;
 
   g_run_crash_arch = arch;
 
   memset(&sa, 0, sizeof sa);
   sa.sa_sigaction = run_crash_handler;
   sa.sa_flags = SA_SIGINFO;
   sigemptyset(&sa.sa_mask);
   for (i = 0; i < RUN_NSIGS; ++i) sigaddset(&sa.sa_mask, g_run_signos[i]);
 
   g_run_installed = 1;
   for (i = 0; i < RUN_NSIGS; ++i) {
     if (sigaction(g_run_signos[i], &sa, &g_run_prev_sa[i]) != 0) {
       int j;
       for (j = 0; j < i; ++j)
         sigaction(g_run_signos[j], &g_run_prev_sa[j], NULL);
       g_run_installed = 0;
       *ret_out = entry(argc, argv); /* could not guard — run unguarded */
       return 0;
     }
   }
 
   if (sigsetjmp(g_run_crash_buf, 1) != 0) {
     /* Reached via a fault. Restore default dispositions first so symbolization
      * (which touches libkit, not the corrupt stack) faults cleanly if it ever
      * goes wrong, then hand the captured chain to the caller. */
     run_crash_restore();
     if (on_crash)
       on_crash(user, g_run_crash_signo, g_run_crash_pcs, g_run_crash_npcs);
     return 1;
   }
 
   g_run_crash_armed = 1;
   *ret_out = entry(argc, argv);
   g_run_crash_armed = 0;
   run_crash_restore();
   return 0;
 }
 
 /* --- vtable --- */
 
 KitDbgOs g_dbg_os_posix = {
     .thread_start = dbg_thread_start,
     .thread_join = dbg_thread_join,
     .thread_interrupt = dbg_thread_interrupt,
     .event_new = dbg_event_new,
     .event_free = dbg_event_free,
     .event_wait = dbg_event_wait,
     .event_signal = dbg_event_signal,
     .event_reset = dbg_event_reset,
     .signals_install = dbg_signals_install,
     .signals_uninstall = dbg_signals_uninstall,
     .interrupt_signo = DBG_INTERRUPT_SIGNO,
     .trap_signo = SIGTRAP,
     .code_write_begin = os_dbg_code_write_begin,
     .code_write_end = os_dbg_code_write_end,
     .flush_icache = os_dbg_flush_icache,
     .guarded_copy = dbg_guarded_copy,
     .call_with_catch = dbg_call_with_catch,
     .thread_abort = dbg_thread_abort,
     .user = NULL,
 };