Changes in / [d933c3ca:f661cee]

Files:

• owl.c (modified) (2 diffs)
• signal.c (modified) (3 diffs)

owl.c

@@ -389 +389 @@
 }
 
-#define OR_DIE(s, syscall)       \
+#define CHECK_RESULT(s, syscall) \
   G_STMT_START {                 \
-    if ((syscall) == -1) {       \
+    if ((syscall) != 0) {        \
       perror((s));               \
       exit(1);                   \
@@ -402 +402 @@
   sigset_t sigset;
   int ret, i;
-  const int reset_signals[] = { SIGABRT, SIGBUS, SIGCHLD, SIGFPE, SIGILL,
-                                SIGQUIT, SIGSEGV, };
-  /* Don't bother resetting watched ones because owl_signal_init will. */
-  const int watch_signals[] = { SIGWINCH, SIGTERM, SIGHUP, SIGINT, };
+  const int signals[] = { SIGABRT, SIGBUS, SIGCHLD, SIGFPE, SIGHUP, SIGILL,
+                          SIGINT, SIGQUIT, SIGSEGV, SIGTERM, SIGWINCH };
 
   /* Sanitize our signals; the mask and dispositions from our parent
    * aren't really useful. Signal list taken from equivalent code in
    * Chromium. */
-  OR_DIE("sigemptyset", sigemptyset(&sigset));
+  CHECK_RESULT("sigemptyset", sigemptyset(&sigset));
   if ((ret = pthread_sigmask(SIG_SETMASK, &sigset, NULL)) != 0) {
     errno = ret;
     perror("pthread_sigmask");
-    exit(1);
-  }
-  for (i = 0; i < G_N_ELEMENTS(reset_signals); i++) {
-    OR_DIE("sigaction", sigaction(reset_signals[i], &sig_default, NULL));
+  }
+  for (i = 0; i < G_N_ELEMENTS(signals); i++) {
+    CHECK_RESULT("sigaction", sigaction(signals[i], &sig_default, NULL));
   }
 
   /* Turn off SIGPIPE; we check the return value of write. */
-  OR_DIE("sigaction", sigaction(SIGPIPE, &sig_ignore, NULL));
+  CHECK_RESULT("sigaction", sigaction(SIGPIPE, &sig_ignore, NULL));
 
   /* Register some signals with the signal thread. */
-  owl_signal_init(watch_signals, G_N_ELEMENTS(watch_signals),
-                  sig_handler, NULL);
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGWINCH));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGTERM));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGHUP));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGINT));
+  owl_signal_init(&sigset, sig_handler, NULL);
 }
 

signal.c

@@ -1 +1 @@
 #include <errno.h>
-#include <glib.h>
 #include <pthread.h>
 #include <signal.h>
@@ -14 +13 @@
 static void *signal_thread_func(void *data);
 
-static void dummy_handler(int signum)
-{
-  /* Do nothing. This should never get called. It'd be nice to report the error
-   * or something, but you can't have nice things in a signal handler. */
-}
-
-#define OR_DIE(s, syscall)       \
-  G_STMT_START {                 \
-    if ((syscall) == -1) {       \
-      perror((s));               \
-      exit(1);                   \
-    }                            \
-  } G_STMT_END
-
-/* Initializes the signal thread to listen for 'signals' on a dedicated
+/* Initializes the signal thread to listen for 'set' on a dedicated
  * thread. 'callback' is called *on the signal thread* when a signal
  * is received.
@@ -34 +19 @@
  * This function /must/ be called before any other threads are
  * created. (Otherwise the signals will not get blocked correctly.) */
-void owl_signal_init(const int *signals, int num_signals, void (*callback)(const siginfo_t*, void*), void *data) {
-  struct sigaction sig_dummy = { .sa_handler = dummy_handler };
+void owl_signal_init(const sigset_t *set, void (*callback)(const siginfo_t*, void*), void *data) {
   int ret;
-  int i;
 
+  signal_set = *set;
   signal_cb = callback;
   signal_cbdata = data;
-
-  /* Stuff the signals into our sigset_t. Also assign all of them to a dummy
-   * handler. Otherwise, if their default is SIG_IGN, they will get dropped if
-   * delivered while processing. On Solaris, they will not get delivered at
-   * all. */
-  OR_DIE("sigemptyset", sigemptyset(&signal_set));
-  for (i = 0; i < num_signals; i++) {
-    OR_DIE("sigaddset", sigaddset(&signal_set, signals[i]));
-    OR_DIE("sigaction", sigaction(signals[i], &sig_dummy, NULL));
-  }
-
   /* Block these signals in all threads, so we can get them. */
-  if ((ret = pthread_sigmask(SIG_BLOCK, &signal_set, NULL)) != 0) {
+  if ((ret = pthread_sigmask(SIG_BLOCK, set, NULL)) != 0) {
     errno = ret;
     perror("pthread_sigmask");
-    exit(1);
   }
   /* Spawn a dedicated thread to sigwait. */