use signalfd to stop on SIGTERM

Is this an overkill? I don't know.

The thing is, correctly intercepting SIGTERM (also SIGINT, etc.) is
incredibly tricky. For example, before this commit, my I/O loops in
server.c and worker.c were inherently racy.

This was immediately obvious if you tried to run the tests. The tests
(especially the Valgrind flavour) would run a worker, wait until it
prints a "Waiting for a new command" line, and try to kill it using
SIGTERM. The problem is, the global_stop_flag check could have already
been executed by the worker, and it would hang forever in recv().

The solution seems to be to use signalfd and select()/poll(). I've never
used either before, but it seems to work well enough - at least the very
same tests pass and don't hang now.

1 files changed, 52 insertions, 5 deletions

diff --git a/src/signal.c b/src/signal.c
index 7d00bc9..9f788b2 100644
--- a/src/signal.c
+++ b/src/signal.c
@@ -7,14 +7,25 @@
 
 #include "signal.h"
 #include "compiler.h"
+#include "event_loop.h"
+#include "file.h"
 #include "log.h"
 
 #include <signal.h>
 #include <stddef.h>
 #include <string.h>
+#include <sys/signalfd.h>
+#include <unistd.h>
 
 static int stop_signals[] = {SIGINT, SIGTERM, SIGQUIT};
 
+static void stops_set(sigset_t *set)
+{
+	sigemptyset(set);
+	for (size_t i = 0; i < sizeof(stop_signals) / sizeof(stop_signals[0]); ++i)
+		sigaddset(set, stop_signals[i]);
+}
+
 volatile sig_atomic_t global_stop_flag = 0;
 
 static void set_global_stop_flag(UNUSED int signum)
@@ -78,11 +89,7 @@ int signal_block_all(sigset_t *old)
 int signal_block_stops(void)
 {
 	sigset_t set;
-	sigemptyset(&set);
-
-	for (size_t i = 0; i < sizeof(stop_signals) / sizeof(stop_signals[0]); ++i)
-		sigaddset(&set, stop_signals[i]);
-
+	stops_set(&set);
 	return signal_set(&set, NULL);
 }
 
@@ -90,3 +97,43 @@ int signal_restore(const sigset_t *new)
 {
 	return signal_set(new, NULL);
 }
+
+int signalfd_create(const sigset_t *set)
+{
+	sigset_t old;
+	int ret = 0;
+
+	ret = signal_set(set, &old);
+	if (ret < 0)
+		return ret;
+
+	ret = signalfd(-1, set, SFD_CLOEXEC);
+	if (ret < 0)
+		goto restore;
+
+	return ret;
+
+restore:
+	signal_set(&old, NULL);
+
+	return ret;
+}
+
+int signalfd_listen_for_stops(void)
+{
+	sigset_t set;
+	stops_set(&set);
+	return signalfd_create(&set);
+}
+
+void signalfd_destroy(int fd)
+{
+	file_close(fd);
+}
+
+int signalfd_add_to_event_loop(int fd, struct event_loop *loop, event_loop_handler handler,
+                               void *arg)
+{
+	struct event_fd entry = {.fd = fd, .events = POLLIN, .handler = handler, .arg = arg};
+	return event_loop_add(loop, &entry);
+}