1 files changed, 277 insertions, 189 deletions

diff --git a/src/sighook.c b/src/sighook.c
index ece8147..a87bed5 100644
--- a/src/sighook.c
+++ b/src/sighook.c
@@ -17,19 +17,33 @@
  * drop to zero.  Once it does, the old pointer can be safely freed.
  */
 
-#include "prelude.h"
 #include "sighook.h"
+
 #include "alloc.h"
 #include "atomic.h"
+#include "bfs.h"
 #include "bfstd.h"
 #include "diag.h"
 #include "thread.h"
+
 #include <errno.h>
+#include <pthread.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <unistd.h>
 
-#if _POSIX_SEMAPHORES > 0
+#if __linux__
+#  include <sys/syscall.h>
+#endif
+
+// NetBSD opens a file descriptor for each sem_init()
+#if defined(_POSIX_SEMAPHORES) && !__NetBSD__
+#  define BFS_POSIX_SEMAPHORES _POSIX_SEMAPHORES
+#else
+#  define BFS_POSIX_SEMAPHORES (-1)
+#endif
+
+#if BFS_POSIX_SEMAPHORES >= 0
 #  include <semaphore.h>
 #endif
 
@@ -42,8 +56,8 @@ struct arc {
 	/** The reference itself. */
 	void *ptr;
 
-#if _POSIX_SEMAPHORES > 0
-	/** A semaphore for arc_wake(). */
+#if BFS_POSIX_SEMAPHORES >= 0
+	/** A semaphore for arc_wait(). */
 	sem_t sem;
 	/** sem_init() result. */
 	int sem_status;
@@ -52,11 +66,17 @@ struct arc {
 
 /** Initialize an arc. */
 static void arc_init(struct arc *arc) {
+	bfs_verify(atomic_is_lock_free(&arc->refs));
+
 	atomic_init(&arc->refs, 0);
 	arc->ptr = NULL;
 
-#if _POSIX_SEMAPHORES > 0
-	arc->sem_status = sem_init(&arc->sem, false, 0);
+#if BFS_POSIX_SEMAPHORES >= 0
+	if (sysoption(SEMAPHORES) > 0) {
+		arc->sem_status = sem_init(&arc->sem, false, 0);
+	} else {
+		arc->sem_status = -1;
+	}
 #endif
 }
 
@@ -91,7 +111,7 @@ static void arc_put(struct arc *arc) {
 	size_t refs = fetch_sub(&arc->refs, 1, release);
 
 	if (refs == 1) {
-#if _POSIX_SEMAPHORES > 0
+#if BFS_POSIX_SEMAPHORES >= 0
 		if (arc->sem_status == 0 && sem_post(&arc->sem) != 0) {
 			abort();
 		}
@@ -101,7 +121,7 @@ static void arc_put(struct arc *arc) {
 
 /** Wait on the semaphore. */
 static int arc_sem_wait(struct arc *arc) {
-#if _POSIX_SEMAPHORES > 0
+#if BFS_POSIX_SEMAPHORES >= 0
 	if (arc->sem_status == 0) {
 		while (sem_wait(&arc->sem) != 0) {
 			bfs_everify(errno == EINTR, "sem_wait()");
@@ -142,9 +162,9 @@ done:;
 
 /** Destroy an arc. */
 static void arc_destroy(struct arc *arc) {
-	bfs_assert(arc_refs(arc) <= 1);
+	bfs_assert(arc_refs(arc) == 0);
 
-#if _POSIX_SEMAPHORES > 0
+#if BFS_POSIX_SEMAPHORES >= 0
 	if (arc->sem_status == 0) {
 		bfs_everify(sem_destroy(&arc->sem) == 0, "sem_destroy()");
 	}
@@ -164,12 +184,25 @@ struct rcu {
 /** Sentinel value for RCU, since arc uses NULL already. */
 static void *RCU_NULL = &RCU_NULL;
 
+/** Map NULL -> RCU_NULL. */
+static void *rcu_encode(void *ptr) {
+	return ptr ? ptr : RCU_NULL;
+}
+
+/** Map RCU_NULL -> NULL. */
+static void *rcu_decode(void *ptr) {
+	bfs_assert(ptr != NULL);
+	return ptr == RCU_NULL ? NULL : ptr;
+}
+
 /** Initialize an RCU block. */
-static void rcu_init(struct rcu *rcu) {
+static void rcu_init(struct rcu *rcu, void *ptr) {
+	bfs_verify(atomic_is_lock_free(&rcu->active));
+
 	atomic_init(&rcu->active, 0);
 	arc_init(&rcu->slots[0]);
 	arc_init(&rcu->slots[1]);
-	arc_set(&rcu->slots[0], RCU_NULL);
+	arc_set(&rcu->slots[0], rcu_encode(ptr));
 }
 
 /** Get the active slot. */
@@ -178,15 +211,20 @@ static struct arc *rcu_active(struct rcu *rcu) {
 	return &rcu->slots[i];
 }
 
+/** Destroy an RCU block. */
+static void rcu_destroy(struct rcu *rcu) {
+	arc_wait(rcu_active(rcu));
+	arc_destroy(&rcu->slots[1]);
+	arc_destroy(&rcu->slots[0]);
+}
+
 /** Read an RCU-protected pointer. */
 static void *rcu_read(struct rcu *rcu, struct arc **slot) {
 	while (true) {
 		*slot = rcu_active(rcu);
 		void *ptr = arc_get(*slot);
-		if (ptr == RCU_NULL) {
-			return NULL;
-		} else if (ptr) {
-			return ptr;
+		if (ptr) {
+			return rcu_decode(ptr);
 		}
 		// Otherwise, the other slot became active; retry
 	}
@@ -195,12 +233,7 @@ static void *rcu_read(struct rcu *rcu, struct arc **slot) {
 /** Get the RCU-protected pointer without acquiring a reference. */
 static void *rcu_peek(struct rcu *rcu) {
 	struct arc *arc = rcu_active(rcu);
-	void *ptr = arc->ptr;
-	if (ptr == RCU_NULL) {
-		return NULL;
-	} else {
-		return ptr;
-	}
+	return rcu_decode(arc->ptr);
 }
 
 /** Update an RCU-protected pointer, and return the old one. */
@@ -211,129 +244,104 @@ static void *rcu_update(struct rcu *rcu, void *ptr) {
 	size_t j = i ^ 1;
 	struct arc *next = &rcu->slots[j];
 
-	arc_set(next, ptr ? ptr : RCU_NULL);
+	arc_set(next, rcu_encode(ptr));
 	store(&rcu->active, j, relaxed);
-	return arc_wait(prev);
+	return rcu_decode(arc_wait(prev));
 }
 
-struct sighook {
-	int sig;
-	sighook_fn *fn;
-	void *arg;
-	enum sigflags flags;
+/**
+ * An RCU-protected linked list.
+ */
+struct rcu_list {
+	/** The first node in the list. */
+	struct rcu head;
+	/** &last->next */
+	struct rcu *tail;
 };
 
 /**
- * A table of signal hooks.
+ * An rcu_list node.
  */
-struct sigtable {
-	/** The number of filled slots. */
-	size_t filled;
-	/** The length of the array. */
-	size_t size;
-	/** An array of signal hooks. */
-	struct arc hooks[];
+struct rcu_node {
+	/** The RCU pointer to this node. */
+	struct rcu *self;
+	/** The next node in the list. */
+	struct rcu next;
 };
 
-/** Add a hook to a table. */
-static int sigtable_add(struct sigtable *table, struct sighook *hook) {
-	if (!table || table->filled == table->size) {
-		return -1;
-	}
-
-	for (size_t i = 0; i < table->size; ++i) {
-		struct arc *arc = &table->hooks[i];
-		if (arc_refs(arc) == 0) {
-			arc_set(arc, hook);
-			++table->filled;
-			return 0;
-		}
-	}
-
-	return -1;
+/** Initialize an rcu_list. */
+static void rcu_list_init(struct rcu_list *list) {
+	rcu_init(&list->head, NULL);
+	list->tail = &list->head;
 }
 
-/** Delete a hook from a table. */
-static int sigtable_del(struct sigtable *table, struct sighook *hook) {
-	for (size_t i = 0; i < table->size; ++i) {
-		struct arc *arc = &table->hooks[i];
-		if (arc->ptr == hook) {
-			arc_wait(arc);
-			--table->filled;
-			return 0;
-		}
-	}
-
-	return -1;
+/** Append to an rcu_list. */
+static void rcu_list_append(struct rcu_list *list, struct rcu_node *node) {
+	node->self = list->tail;
+	list->tail = &node->next;
+	rcu_init(&node->next, NULL);
+	rcu_update(node->self, node);
 }
 
-/** Create a bigger copy of a signal table. */
-static struct sigtable *sigtable_grow(struct sigtable *prev) {
-	size_t old_size = prev ? prev->size : 0;
-	size_t new_size = old_size ? 2 * old_size : 1;
-	struct sigtable *table = ALLOC_FLEX(struct sigtable, hooks, new_size);
-	if (!table) {
-		return NULL;
-	}
-
-	table->filled = 0;
-	table->size = new_size;
-	for (size_t i = 0; i < new_size; ++i) {
-		arc_init(&table->hooks[i]);
-	}
-
-	for (size_t i = 0; i < old_size; ++i) {
-		struct sighook *hook = prev->hooks[i].ptr;
-		if (hook) {
-			bfs_verify(sigtable_add(table, hook) == 0);
-		}
+/** Remove from an rcu_list. */
+static void rcu_list_remove(struct rcu_list *list, struct rcu_node *node) {
+	struct rcu_node *next = rcu_peek(&node->next);
+	rcu_update(node->self, next);
+	if (next) {
+		next->self = node->self;
+	} else {
+		list->tail = &list->head;
 	}
-
-	return table;
+	rcu_destroy(&node->next);
 }
 
-/** Free a signal table. */
-static void sigtable_free(struct sigtable *table) {
-	if (!table) {
-		return;
-	}
+/**
+ * Iterate over an rcu_list.
+ *
+ * It is save to `break` out of this loop, but `return` or `goto` will lead to
+ * a missed arc_put().
+ */
+#define for_rcu(type, node, list) \
+	for_rcu_(type, node, (list), node##_slot_, node##_prev_, node##_done_)
 
-	for (size_t i = 0; i < table->size; ++i) {
-		struct arc *arc = &table->hooks[i];
-		arc_destroy(arc);
-	}
-	free(table);
-}
+#define for_rcu_(type, node, list, slot, prev, done) \
+	for (struct arc *slot, *prev, **done = NULL; !done; arc_put(slot), done = &slot) \
+		for (type *node = rcu_read(&list->head, &slot); \
+		     node; \
+		     prev = slot, \
+		     node = rcu_read(&((struct rcu_node *)node)->next, &slot), \
+		     arc_put(prev))
 
-/** Add a hook to a signal table, growing it if necessary. */
-static int rcu_sigtable_add(struct rcu *rcu, struct sighook *hook) {
-	struct sigtable *prev = rcu_peek(rcu);
-	if (sigtable_add(prev, hook) == 0) {
-		return 0;
-	}
+struct sighook {
+	/** The RCU list node (must be the first field). */
+	struct rcu_node node;
 
-	struct sigtable *next = sigtable_grow(prev);
-	if (!next) {
-		return -1;
-	}
+	/** The signal being hooked, or 0 for atsigexit(). */
+	int sig;
+	/** Signal hook flags. */
+	enum sigflags flags;
+	/** The function to call. */
+	sighook_fn *fn;
+	/** An argument to pass to the function. */
+	void *arg;
+	/** Flag for SH_ONESHOT. */
+	atomic bool armed;
+};
 
-	bfs_verify(sigtable_add(next, hook) == 0);
-	rcu_update(rcu, next);
-	sigtable_free(prev);
-	return 0;
-}
+/** The lists of signal hooks. */
+static struct rcu_list sighooks[64];
 
-/** The global table of signal hooks. */
-static struct rcu rcu_sighooks;
-/** The global table of atsigexit() hooks. */
-static struct rcu rcu_exithooks;
+/** Get the hook list for a particular signal. */
+static struct rcu_list *siglist(int sig) {
+	return &sighooks[sig % countof(sighooks)];
+}
 
 /** Mutex for initialization and RCU writer exclusion. */
 static pthread_mutex_t sigmutex = PTHREAD_MUTEX_INITIALIZER;
 
 /** Check if a signal was generated by userspace. */
 static bool is_user_generated(const siginfo_t *info) {
-	// https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03
+	// https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html#tag_16_04_03_03
 	//
 	//     If si_code is SI_USER or SI_QUEUE, or any value less than or
 	//     equal to 0, then the signal was generated by a process ...
@@ -351,7 +359,7 @@ static bool is_fault(const siginfo_t *info) {
 	}
 }
 
-// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/signal.h.html
 static const int FATAL_SIGNALS[] = {
 	SIGABRT,
 	SIGALRM,
@@ -360,22 +368,31 @@ static const int FATAL_SIGNALS[] = {
 	SIGHUP,
 	SIGILL,
 	SIGINT,
+#ifdef SIGIO
+	SIGIO,
+#endif
 	SIGPIPE,
-	SIGQUIT,
-	SIGSEGV,
-	SIGTERM,
-	SIGUSR1,
-	SIGUSR2,
 #ifdef SIGPOLL
 	SIGPOLL,
 #endif
 #ifdef SIGPROF
 	SIGPROF,
 #endif
+#ifdef SIGPWR
+	SIGPWR,
+#endif
+	SIGQUIT,
+	SIGSEGV,
+#ifdef SIGSTKFLT
+	SIGSTKFLT,
+#endif
 #ifdef SIGSYS
 	SIGSYS,
 #endif
+	SIGTERM,
 	SIGTRAP,
+	SIGUSR1,
+	SIGUSR2,
 #ifdef SIGVTALRM
 	SIGVTALRM,
 #endif
@@ -392,7 +409,7 @@ static bool is_fatal(int sig) {
 	}
 
 #ifdef SIGRTMIN
-	// https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03
+	// https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html#tag_16_04_03_01
 	//
 	//     The default actions for the realtime signals in the range
 	//     SIGRTMIN to SIGRTMAX shall be to terminate the process
@@ -406,7 +423,10 @@ static bool is_fatal(int sig) {
 }
 
 /** Reraise a fatal signal. */
-static noreturn void reraise(int sig) {
+_noreturn
+static void reraise(siginfo_t *info) {
+	int sig = info->si_signo;
+
 	// Restore the default signal action
 	if (signal(sig, SIG_DFL) == SIG_ERR) {
 		goto fail;
@@ -420,52 +440,73 @@ static noreturn void reraise(int sig) {
 		goto fail;
 	}
 
+#if __linux__
+	// On Linux, try to re-raise the exact siginfo_t (since 3.9, a process can
+	// signal itself with any siginfo_t)
+	pid_t tid = syscall(SYS_gettid);
+	syscall(SYS_rt_tgsigqueueinfo, getpid(), tid, sig, info);
+#endif
+
 	raise(sig);
 fail:
 	abort();
 }
 
-/** Find any matching hooks and run them. */
-static enum sigflags run_hooks(struct rcu *rcu, int sig, siginfo_t *info) {
-	enum sigflags ret = 0;
-	struct arc *slot;
-	struct sigtable *table = rcu_read(rcu, &slot);
-	if (!table) {
-		goto done;
+/** Check whether we should run a hook. */
+static bool should_run(int sig, struct sighook *hook) {
+	if (hook->sig != sig && hook->sig != 0) {
+		return false;
 	}
 
-	for (size_t i = 0; i < table->size; ++i) {
-		struct arc *arc = &table->hooks[i];
-		struct sighook *hook = arc_get(arc);
-		if (!hook) {
-			continue;
+	if (hook->flags & SH_ONESHOT) {
+		if (!exchange(&hook->armed, false, relaxed)) {
+			return false;
 		}
+	}
+
+	return true;
+}
 
-		if (hook->sig == sig || hook->sig == 0) {
+/** Find any matching hooks and run them. */
+static enum sigflags run_hooks(struct rcu_list *list, int sig, siginfo_t *info) {
+	enum sigflags ret = 0;
+
+	for_rcu (struct sighook, hook, list) {
+		if (should_run(sig, hook)) {
 			hook->fn(sig, info, hook->arg);
 			ret |= hook->flags;
 		}
-		arc_put(arc);
 	}
 
-done:
-	arc_put(slot);
 	return ret;
 }
 
 /** Dispatches a signal to the registered handlers. */
 static void sigdispatch(int sig, siginfo_t *info, void *context) {
-	// https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03
+	// If we get a fault (e.g. a "real" SIGSEGV, not something like
+	// kill(..., SIGSEGV)), don't try to run signal hooks, since we could be
+	// in an arbitrarily corrupted state.
 	//
-	//     The behavior of a process is undefined after it returns normally
-	//     from a signal-catching function for a SIGBUS, SIGFPE, SIGILL, or
-	//     SIGSEGV signal that was not generated by kill(), sigqueue(), or
-	//     raise().
+	// POSIX says that returning normally from a signal handler for a fault
+	// is undefined.  But in practice, it's better to uninstall the handler
+	// and return, which will re-run the faulting instruction and cause us
+	// to die "correctly" (e.g. with a core dump pointing at the faulting
+	// instruction, not reraise()).
 	if (is_fault(info)) {
-		reraise(sig);
+		// On macOS, we cannot reliably distinguish between faults and
+		// asynchronous signals.  For example, pkill -SEGV bfs will
+		// result in si_code == SEGV_ACCERR.  So we always re-raise the
+		// signal, because just returning would cause us to ignore
+		// asynchronous SIG{BUS,ILL,SEGV}.
+#if !__APPLE__
+		if (signal(sig, SIG_DFL) != SIG_ERR) {
+			return;
+		}
+#endif
+		reraise(info);
 	}
 
-	// https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03
+	// https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html#tag_16_04_04
 	//
 	//     After returning from a signal-catching function, the value of
 	//     errno is unspecified if the signal-catching function or any
@@ -475,35 +516,58 @@ static void sigdispatch(int sig, siginfo_t *info, void *context) {
 	int error = errno;
 
 	// Run the normal hooks
-	enum sigflags flags = run_hooks(&rcu_sighooks, sig, info);
+	struct rcu_list *list = siglist(sig);
+	enum sigflags flags = run_hooks(list, sig, info);
 
 	// Run the atsigexit() hooks, if we're exiting
 	if (!(flags & SH_CONTINUE) && is_fatal(sig)) {
-		run_hooks(&rcu_exithooks, sig, info);
-		reraise(sig);
+		list = siglist(0);
+		run_hooks(list, sig, info);
+		reraise(info);
 	}
 
 	errno = error;
 }
 
+/** A saved signal handler, for sigreset() to restore. */
+struct sigsave {
+	struct rcu_node node;
+	int sig;
+	struct sigaction action;
+};
+
+/** The list of saved signal handlers. */
+static struct rcu_list saved;
+/** `saved` initialization status (since rcu_list_init() isn't atomic). */
+static atomic bool initialized = false;
+
 /** Make sure our signal handler is installed for a given signal. */
 static int siginit(int sig) {
+#ifdef SA_RESTART
+#  define BFS_SA_RESTART SA_RESTART
+#else
+#  define BFS_SA_RESTART 0
+#endif
+
 	static struct sigaction action = {
 		.sa_sigaction = sigdispatch,
-		.sa_flags = SA_RESTART | SA_SIGINFO,
+		.sa_flags = BFS_SA_RESTART | SA_SIGINFO,
 	};
 
 	static sigset_t signals;
-	static bool initialized = false;
 
-	if (!initialized) {
+	if (!load(&initialized, relaxed)) {
 		if (sigemptyset(&signals) != 0
 		    || sigemptyset(&action.sa_mask) != 0) {
 			return -1;
 		}
-		rcu_init(&rcu_sighooks);
-		rcu_init(&rcu_exithooks);
-		initialized = true;
+
+		for (size_t i = 0; i < countof(sighooks); ++i) {
+			rcu_list_init(&sighooks[i]);
+		}
+
+		rcu_list_init(&saved);
+		store(&initialized, true, release);
 	}
 
 	int installed = sigismember(&signals, sig);
@@ -513,47 +577,63 @@ static int siginit(int sig) {
 		return 0;
 	}
 
-	if (sigaction(sig, &action, NULL) != 0) {
+	sigset_t updated = signals;
+	if (sigaddset(&updated, sig) != 0) {
 		return -1;
 	}
 
-	if (sigaddset(&signals, sig) != 0) {
+	struct sigaction original;
+	if (sigaction(sig, NULL, &original) != 0) {
+		return -1;
+	}
+
+	struct sigsave *save = ALLOC(struct sigsave);
+	if (!save) {
+		return -1;
+	}
+
+	save->sig = sig;
+	save->action = original;
+	rcu_list_append(&saved, &save->node);
+
+	if (sigaction(sig, &action, NULL) != 0) {
+		rcu_list_remove(&saved, &save->node);
+		free(save);
 		return -1;
 	}
 
+	signals = updated;
 	return 0;
 }
 
 /** Shared sighook()/atsigexit() implementation. */
-static struct sighook *sighook_impl(struct rcu *rcu, int sig, sighook_fn *fn, void *arg, enum sigflags flags) {
+static struct sighook *sighook_impl(int sig, sighook_fn *fn, void *arg, enum sigflags flags) {
 	struct sighook *hook = ALLOC(struct sighook);
 	if (!hook) {
 		return NULL;
 	}
 
 	hook->sig = sig;
+	hook->flags = flags;
 	hook->fn = fn;
 	hook->arg = arg;
-	hook->flags = flags;
-
-	if (rcu_sigtable_add(rcu, hook) != 0) {
-		free(hook);
-		return NULL;
-	}
+	atomic_init(&hook->armed, true);
 
+	struct rcu_list *list = siglist(sig);
+	rcu_list_append(list, &hook->node);
 	return hook;
 }
 
 struct sighook *sighook(int sig, sighook_fn *fn, void *arg, enum sigflags flags) {
+	bfs_assert(sig > 0);
+
 	mutex_lock(&sigmutex);
 
 	struct sighook *ret = NULL;
-	if (siginit(sig) != 0) {
-		goto done;
+	if (siginit(sig) == 0) {
+		ret = sighook_impl(sig, fn, arg, flags);
 	}
 
-	ret = sighook_impl(&rcu_sighooks, sig, fn, arg, flags);
-done:
 	mutex_unlock(&sigmutex);
 	return ret;
 }
@@ -561,24 +641,20 @@ done:
 struct sighook *atsigexit(sighook_fn *fn, void *arg) {
 	mutex_lock(&sigmutex);
 
-	struct sighook *ret = NULL;
-
 	for (size_t i = 0; i < countof(FATAL_SIGNALS); ++i) {
-		if (siginit(FATAL_SIGNALS[i]) != 0) {
-			goto done;
-		}
+		// Ignore errors; atsigexit() is best-effort anyway and things
+		// like sanitizer runtimes or valgrind may reserve signals for
+		// their own use
+		siginit(FATAL_SIGNALS[i]);
 	}
 
 #ifdef SIGRTMIN
 	for (int i = SIGRTMIN; i <= SIGRTMAX; ++i) {
-		if (siginit(i) != 0) {
-			goto done;
-		}
+		siginit(i);
 	}
 #endif
 
-	ret = sighook_impl(&rcu_exithooks, 0, fn, arg, 0);
-done:
+	struct sighook *ret = sighook_impl(0, fn, arg, 0);
 	mutex_unlock(&sigmutex);
 	return ret;
 }
@@ -590,15 +666,27 @@ void sigunhook(struct sighook *hook) {
 
 	mutex_lock(&sigmutex);
 
-	struct rcu *rcu = hook->sig ? &rcu_sighooks : &rcu_exithooks;
-	struct sigtable *table = rcu_peek(rcu);
-	bfs_verify(sigtable_del(table, hook) == 0);
-
-	if (table->filled == 0) {
-		rcu_update(rcu, NULL);
-		sigtable_free(table);
-	}
+	struct rcu_list *list = siglist(hook->sig);
+	rcu_list_remove(list, &hook->node);
 
 	mutex_unlock(&sigmutex);
+
 	free(hook);
 }
+
+int sigreset(void) {
+	if (!load(&initialized, acquire)) {
+		return 0;
+	}
+
+	int ret = 0;
+
+	for_rcu (struct sigsave, save, &saved) {
+		if (sigaction(save->sig, &save->action, NULL) != 0) {
+			ret = -1;
+			break;
+		}
+	}
+
+	return ret;
+}