Cleaner SIGINT handling

Use a Mutex to wait for the signal handler to fire instead of checking
an atomic boolean over and over again.

src/subcommand/server.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const AtomicValue = std.atomic.Value;
 const DebugAllocator = std.heap.DebugAllocator;
 const Sigaction = std.posix.Sigaction;
 
@@ -17,24 +16,15 @@ const Server = zits.Server;
 
 const safe_build = builtin.mode == .Debug or builtin.mode == .ReleaseSafe;
 
-var keep_running = AtomicValue(bool).init(true);
+var exit_lock: std.Io.Mutex = .init;
+var io: Io = undefined;
 
 fn handleSigInt(sig: std.os.linux.SIG) callconv(.c) void {
     _ = sig;
-    keep_running.store(false, .monotonic);
+    exit_lock.unlock(io);
 }
 
 pub fn main(outer_alloc: Allocator, server_config: ServerInfo) !void {
-    // Configure the signal action
-    const act = Sigaction{
-        .handler = .{ .handler = handleSigInt },
-        .mask = std.posix.sigemptyset(),
-        .flags = 0,
-    };
-
-    // Register the handler for SIGINT (Ctrl+C)
-    std.posix.sigaction(std.posix.SIG.INT, &act, null);
-
     {
         var dba: DebugAllocator(.{}) = .init;
         dba.backing_allocator = outer_alloc;
@@ -43,7 +33,19 @@ pub fn main(outer_alloc: Allocator, server_config: ServerInfo) !void {
 
         var threaded: Threaded = .init(alloc, .{});
         defer threaded.deinit();
-        const io = threaded.io();
+        io = threaded.io();
+
+        try exit_lock.lock(io);
+
+        // Configure the signal action
+        const act = Sigaction{
+            .handler = .{ .handler = handleSigInt },
+            .mask = std.posix.sigemptyset(),
+            .flags = 0,
+        };
+
+        // Register the handler for SIGINT (Ctrl+C)
+        std.posix.sigaction(std.posix.SIG.INT, &act, null);
 
         var server: Server = .{
             .info = server_config,
@@ -54,10 +56,7 @@ pub fn main(outer_alloc: Allocator, server_config: ServerInfo) !void {
         defer server_task.cancel(io) catch {};
 
         // Block until Ctrl+C
-        while (keep_running.load(.monotonic)) {
-            try io.sleep(.fromMilliseconds(1), .awake);
-        }
-
+        try exit_lock.lock(io);
         std.debug.print("\n", .{});
         std.log.info("Shutting down...", .{});
         server_task.cancel(io) catch {};