Add improved support for signals (raise, kill, sigaction, etc)

Although we don't have any support for external or async signal a lot of
this functionality works fine within a single process (e.g. using raise
the syncronously run signal handlers in your own process).

I'm adding this so that as a followup we can implement `pthread_kill`
to send signal between threads.  See: #14872

Author: sbc100

ChangeLog.md

@@ -20,6 +20,10 @@ See docs/process.md for more on how version tagging works.
 
 2.0.27
 ------
+- Added some support for signal handling libc functions (raise, kill,
+  sigaction, sigpending, etc).  We still don't have a way to deliver signals from
+  the outside but these at least now work for sending signals to the current
+  thread (JS context) (#14883).
 - Added `EM_ASYNC_JS` macro - similar to `EM_JS`, but allows using `await`
   inside the JS block and automatically integrates with Asyncify without
   the need for listing the declared function in `ASYNCIFY_IMPORTS` (#9709).

src/library.js

@@ -2619,6 +2619,20 @@ LibraryManager.library = {
     return 0;
   },
 
+  // http://pubs.opengroup.org/onlinepubs/000095399/functions/alarm.html
+  alarm__deps: ['raise'],
+  alarm: function(seconds) {
+    setTimeout(function() {
+      _raise({{{ cDefine('SIGALRM') }}});
+    }, seconds*1000);
+  },
+
+  // Helper for raise() to avoid signature mismatch failures:
+  // https://github.com/emscripten-core/posixtestsuite/issues/6
+  __call_sighandler: function(fp, sig) {
+    {{{ makeDynCall('vi', 'fp') }}}(sig);
+  },
+
   // ==========================================================================
   // emscripten.h
   // ==========================================================================
@@ -3681,6 +3695,12 @@ LibraryManager.library = {
   },
 #endif
 
+  $safeSetTimeout__deps: ['$callUserCallback',
+#if !MINIMAL_RUNTIME
+   '$runtimeKeepalivePush',
+   '$runtimeKeepalivePop',
+#endif
+  ],
   $safeSetTimeout: function(func, timeout) {
     {{{ runtimeKeepalivePush() }}}
     return setTimeout(function() {

src/library_signals.js

@@ -61,7 +61,6 @@ var LibraryManager = {
       'library_formatString.js',
       'library_math.js',
       'library_path.js',
-      'library_signals.js',
       'library_syscall.js',
       'library_html5.js',
       'library_stack_trace.js',

src/modules.js

@@ -0,0 +1,12 @@
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+
+int kill(pid_t pid, int sig) {
+  if (pid == getpid()) {
+    return raise(sig);
+  }
+  errno = EPERM;
+  return -1;
+}

system/lib/libc/kill.c

@@ -259,7 +259,7 @@ int sigandset(sigset_t *, const sigset_t *, const sigset_t *);
 
 #define SIG_ERR  ((void (*)(int))-1)
 #define SIG_DFL  ((void (*)(int)) 0)
-#define SIG_IGN  ((void (*)(int)) 1)
+#define SIG_IGN  ((void (*)(int))-2) /* XXX EMSCRIPTEN: use -2 since 1 is a valid function address */
 
 typedef int sig_atomic_t;
 

system/lib/libc/musl/include/signal.h

@@ -0,0 +1,63 @@
+#define _GNU_SOURCE // for sigorset/sigandset
+#include <stdbool.h>
+#include <threads.h>
+#include <signal.h>
+#include <errno.h>
+#include "libc.h"
+
+#define SST_SIZE (_NSIG/8/sizeof(long))
+
+static thread_local sigset_t __sig_mask;
+sigset_t __sig_pending;
+
+static int siginvertset(sigset_t *dest, const sigset_t *src) {
+  unsigned long i = 0, *d = (void*) dest, *s = (void*) src;
+  for(; i < SST_SIZE; i++) d[i] = ~s[i];
+  return 0;
+}
+
+bool __sig_is_blocked(int sig) {
+  return sigismember(&__sig_mask, sig);
+}
+
+int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict old) {
+  if (old) {
+    *old = __sig_mask;
+  }
+
+  switch (how) {
+    case SIG_SETMASK:
+      __sig_mask = *set;
+      break;
+    case SIG_BLOCK:
+      sigorset(&__sig_mask, &__sig_mask, set);
+      break;
+    case SIG_UNBLOCK: {
+      sigset_t tmp;
+      siginvertset(&tmp, set);
+      sigandset(&__sig_mask, &__sig_mask, &tmp);
+      break;
+    }
+    default:
+      return EINVAL;
+  }
+
+  // These two signals can never be blocked.
+  sigdelset(&__sig_mask, SIGKILL);
+  sigdelset(&__sig_mask, SIGSTOP);
+
+  // Raise any pending signals that are now unblocked.
+  for (int sig = 0; sig < _NSIG; sig++) {
+    if (sigismember(&__sig_pending, sig) && !sigismember(&__sig_mask, sig)) {
+      sigdelset(&__sig_pending, sig);
+      raise(sig);
+    }
+  }
+
+  return 0;
+}
+
+int sigpending(sigset_t *set) {
+  *set = __sig_pending;
+  return 0;
+}

system/lib/libc/pthread_sigmask.c

@@ -0,0 +1,32 @@
+#define _GNU_SOURCE // for sighandler_t
+#include <stdbool.h>
+#include <stddef.h>
+#include <signal.h>
+
+extern struct sigaction __sig_actions[_NSIG];
+extern sigset_t __sig_pending;
+
+bool __sig_is_blocked(int sig);
+
+extern void __call_sighandler(sighandler_t handler, int sig);
+
+int raise(int sig) {
+  if (__sig_is_blocked(sig)) {
+    sigaddset(&__sig_pending, sig);
+    return 0;
+  }
+  if (__sig_actions[sig].sa_flags & SA_SIGINFO) {
+    siginfo_t t = {0};
+    __sig_actions[sig].sa_sigaction(sig, &t, NULL);
+  } else {
+    if (__sig_actions[sig].sa_handler == SIG_DFL || __sig_actions[sig].sa_handler == SIG_IGN) {
+
+      return 0;
+    }
+    // Avoid a direct call to the handler, and instead call via JS so we can
+    // avoid strict signature checking.
+    // https://github.com/emscripten-core/posixtestsuite/issues/6
+    __call_sighandler(__sig_actions[sig].sa_handler, sig);
+  }
+  return 0;
+}

system/lib/libc/raise.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <signal.h>
+#include <errno.h>
+#include "libc.h"
+
+struct sigaction __sig_actions[_NSIG];
+
+int __sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old) {
+  if (sig < 0 || sig >= _NSIG) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (old) {
+    *old = __sig_actions[sig];
+  }
+
+  __sig_actions[sig] = *sa;
+  return 0;
+}
+
+weak_alias(__sigaction, sigaction);

system/lib/libc/sigaction.c

@@ -0,0 +1,22 @@
+#include <signal.h>
+#include <errno.h>
+#include "syscall.h"
+#include "libc.h"
+
+extern sigset_t __sig_pending;
+
+int sigtimedwait(const sigset_t *restrict mask, siginfo_t *restrict si, const struct timespec *restrict timeout) {
+  for (int sig = 0; sig < _NSIG; sig++) {
+    if (sigismember(mask, sig) && sigismember(&__sig_pending, sig)) {
+      if (si) {
+        siginfo_t t = {0};
+        *si = t;
+      }
+      sigdelset(&__sig_pending, sig);
+      return sig;
+    }
+  }
+
+  errno = EINVAL;
+  return -1;
+}

system/lib/libc/sigtimedwait.c

@@ -5319,6 +5319,9 @@ def test_fs_64bit(self):
   def test_sigalrm(self):
     self.do_runf(test_file('test_sigalrm.c'), 'Received alarm!')
 
+  def test_signals(self):
+    self.do_core_test(test_file('test_signals.c'))
+
   @no_windows('https://github.com/emscripten-core/emscripten/issues/8882')
   def test_unistd_access(self):
     self.uses_es6 = True

tests/test_core.py

@@ -29,8 +29,6 @@ class posixtest(RunnerCore):
 
 def filter_tests(all_tests):
   pthread_tests = [t for t in all_tests if t.startswith('pthread_')]
-  # filter out some tests we don't support
-  pthread_tests = [t for t in pthread_tests if not t.startswith('pthread_sigmask')]
   return pthread_tests
 
 
@@ -56,15 +54,15 @@ def get_pthread_tests():
   'test_pthread_atfork_3_2': 'fork() and multiple processes are not supported',
   'test_pthread_atfork_4_1': 'fork() and multiple processes are not supported',
   'test_pthread_kill_1_1': 'signals are not supported',
-  'test_pthread_create_1_5': 'semaphores are not supported',
+  'test_pthread_create_1_5': 'fork() and multiple processes are not supported',
   'test_pthread_exit_6_1': 'lacking necessary mmap() support',
   'test_pthread_spin_lock_1_1': 'signals are not supported',
   'test_pthread_mutex_lock_5_1': 'signals are not supported',
   'test_pthread_mutexattr_settype_2_1': 'interrupting pthread_mutex_lock wait via SIGALRM is not supported',
   'test_pthread_spin_lock_3_1': 'signals are not supported',
-  'test_pthread_create_14_1': 'signals are not supported',
-  'test_pthread_detach_4_3': 'signals are not supported',
-  'test_pthread_join_6_3': 'signals are not supported',
+  'test_pthread_create_14_1': 'creates too many threads',
+  'test_pthread_detach_4_3': 'creates too many threads',
+  'test_pthread_join_6_3': 'creates too many threads',
   'test_pthread_barrier_wait_3_2': 'signals are not supported',
   'test_pthread_cond_broadcast_1_2': 'tries to create 10,0000 threads, then depends on fork()',
 }