lib+driver+common: Tidy up signal handling & move it to driver

Another old remnant of when c-ray was a standalone program, the renderer
was hooking SIGINT internally. Now we do that in the driver, and use the
public API to tell the renderer to stop when ^C is invoked. Also removed
the useless wrapper around signal(3).

Author: vkoskiv

include/c-ray/c-ray.h

@@ -93,7 +93,6 @@ struct cr_renderer_cb_info {
 	size_t finished_passes;
 	double completion;
 	bool paused;
-	bool aborted;
 };
 
 enum cr_renderer_callback {

src/common/platform/signal.c

@@ -8,14 +8,17 @@
 
 #pragma once
 
-enum sigtype {
-	sigint,
-	sigabrt,
-};
-
-int registerHandler(enum sigtype, void (*handler)(int));
+#if !defined(WINDOWS) && !defined(__APPLE__)
+	#include <signal.h>
+#endif
 
 // By default, signals may be delivered to any running thread
 // so block them in background threads.
 // Thanks to jart for this TIL, I saw it in cosmo turfwar.c
-void block_signals(void);
+static inline void block_signals(void) {
+#if !defined(WINDOWS) && !defined(__APPLE__)
+	sigset_t mask;
+	sigfillset(&mask);
+	sigprocmask(SIG_SETMASK, &mask, 0);
+#endif
+}

src/common/platform/signal.h

@@ -18,9 +18,6 @@
 #include <unistd.h>
 #endif
 
-#include "signal.h"
-#include "../logging.h"
-
 bool isTeleType(void) {
 #ifdef WINDOWS
 	return _isatty(_fileno(stdout));
@@ -36,20 +33,7 @@ static void show_cursor(bool show) {
 #endif
 }
 
-//FIXME: This doesn't perform cleanup
-static void handler(int sig) {
-	if (sig == 2) { //SIGINT
-		printf("\n");
-		logr(info, "Aborting initialization.\n");
-		term_restore();
-		exit(0);
-	}
-}
-
 void term_init(void) {
-	if (registerHandler(sigint, handler)) {
-		logr(warning, "Unable to catch SIGINT\n");
-	}
 	//If we're on a reasonable (non-windows) terminal, hide the cursor.
 #ifndef WINDOWS
 	//Disable output buffering

src/common/platform/terminal.c

@@ -7,6 +7,8 @@
 //
 
 #include <c-ray/c-ray.h>
+#include <errno.h>
+#include <signal.h>
 #include <v.h>
 
 #include <imagefile.h>
@@ -21,8 +23,30 @@
 #include <args.h>
 #include <sdl.h>
 
+// Before render, just exit without cleaning up
+// FIXME: Consider performing cleanup here too
+static void s_sigint_init(int sig) {
+	if (sig != SIGINT)
+		return;
+	logr(plain, "\n");
+	logr(info, "Aborting initialization.\n");
+	term_restore();
+	exit(0);
+}
+
+static int g_sigint_flag = 0;
+
+// Set flag to allow renderer to exit gracefully
+static void s_sigint_flag(int sig) {
+	if (sig == SIGINT && !g_sigint_flag) {
+		logr(plain, "\n");
+		logr(info, "Received ^C, aborting render without saving\n");
+		g_sigint_flag = 1;
+	}
+}
+
 struct cb_context {
-	struct cr_renderer *r;
+	struct cr_renderer *r; // TODO: Pass in cr_renderer_cb_info directly
 	struct sdl_window *w;
 	bool skip_save;
 
@@ -69,15 +93,18 @@ static void on_stop(struct cr_renderer_cb_info *info, void *user_data) {
 	struct cb_context *d = user_data;
 	if (d->w)
 		win_destroy(d->w);
-	if (info->aborted)
-		d->skip_save = true;
 }
 
 static void status(struct cr_renderer_cb_info *state, void *user_data) {
 	static int pauser = 0;
 	struct cb_context *d = user_data;
 	if (!d)
 		return;
+	if (g_sigint_flag) {
+		d->skip_save = true;
+		cr_renderer_stop(d->r);
+		g_sigint_flag = 0;
+	}
 	if (d->w) {
 		enum input_event e = win_update(d->w, state->tiles, state->tiles_count);
 		switch (e) {
@@ -114,6 +141,8 @@ static void status(struct cr_renderer_cb_info *state, void *user_data) {
 int main(int argc, char *argv[]) {
 	term_init();
 	atexit(term_restore);
+	if (signal(SIGINT, s_sigint_init) == SIG_ERR)
+		logr(error, "signal(SIGINT, s_sigint_init) == SIG_ERR: %s", strerror(errno));
 	logr(info, "c-ray v%s [%.8s], © 2015-2025 Valtteri Koskivuori\n", cr_get_version(), cr_get_git_hash());
 
 	struct driver_args *opts = args_parse(argc, argv);
@@ -285,6 +314,10 @@ int main(int argc, char *argv[]) {
 		KNRM,
 		PLURAL(threads));
 
+	// FIXME: There is a gap between this call and when the renderer will
+	// actually respond to a renderer_stop() call, maybe do something about that.
+	if (signal(SIGINT, s_sigint_flag) == SIG_ERR)
+		logr(error, "signal(SIGINT, s_sigint_flag) == SIG_ERR: %s", strerror(errno));
 	v_timer timer = v_timer_start();
 	cr_renderer_render(renderer);
 	long ms = v_timer_get_ms(timer);

src/driver/main.c

@@ -375,7 +375,7 @@ void exitHandler(int sig) {
 
 int worker_start(int port, size_t thread_limit) {
 	signal(SIGPIPE, SIG_IGN);
-	if (registerHandler(sigint, exitHandler) < 0) {
+	if (signal(SIGINT, exitHandler) == SIG_ERR) {
 		logr(error, "registerHandler failed\n");
 	}
 	int receivingSocket, connectionSocket;

src/lib/protocol/worker.c

@@ -30,18 +30,6 @@
 #define paused_msec 100
 #define active_msec  16
 
-static bool g_aborted = false;
-
-// FIXME: c-ray is a library now, so just setting upa global handler like this
-//        is a bit ugly.
-void sigHandler(int sig) {
-	if (sig == 2) { //SIGINT
-		logr(plain, "\n");
-		logr(info, "Received ^C, aborting render without saving\n");
-		g_aborted = true;
-	}
-}
-
 static void print_stats(const struct world *scene) {
 	uint64_t polys = 0;
 	uint64_t vertices = 0;
@@ -145,12 +133,6 @@ void update_toplevel_bvh(struct world *s) {
 
 // TODO: Clean this up, it's ugly.
 void renderer_render(struct renderer *r) {
-	//Check for CTRL-C
-	// TODO: Move signal to driver
-	if (registerHandler(sigint, sigHandler)) {
-		logr(warning, "Unable to catch SIGINT\n");
-	}
-
 	struct camera *camera = &r->scene->cameras[r->prefs.selected_camera];
 	if (r->prefs.override_width && r->prefs.override_height) {
 		camera->width = r->prefs.override_width ? (int)r->prefs.override_width : camera->width;
@@ -292,7 +274,7 @@ void renderer_render(struct renderer *r) {
 		w->thread_ctx.thread_fn = render_single_iteration;
 		while (r->state.s == r_rendering) {
 			w->thread_ctx.thread_fn(w->thread_ctx.ctx);
-			if (g_aborted || w->thread_complete)
+			if (w->thread_complete)
 				break;
 			struct callback status = r->state.callbacks[cr_cb_status_update];
 			if (status.fn) {
@@ -306,9 +288,10 @@ void renderer_render(struct renderer *r) {
 		while (r->state.s == r_rendering) {
 			size_t inactive = 0;
 			for (size_t w = 0; w < v_arr_len(r->state.workers); ++w) {
-				if (r->state.workers[w].thread_complete) inactive++;
+				if (r->state.workers[w].thread_complete)
+					inactive++;
 			}
-			if (g_aborted || inactive == v_arr_len(r->state.workers))
+			if (inactive == v_arr_len(r->state.workers))
 				break;
 
 			struct callback status = r->state.callbacks[cr_cb_status_update];
@@ -332,11 +315,10 @@ void renderer_render(struct renderer *r) {
 	struct callback stop = r->state.callbacks[cr_cb_on_stop];
 	if (stop.fn) {
 		update_cb_info(r, &set, &cb_info);
-		if (g_aborted)
-			cb_info.aborted = true;
 		stop.fn(&cb_info, stop.user_data);
 	}
-	if (info_tiles) free(info_tiles);
+	if (info_tiles)
+		free(info_tiles);
 	tile_set_free(&set);
 	logr(info, "Renderer exiting\n");
 	r->state.s = r_idle;