tweaks, up to Zig 0.14.1

Author: mitchellh

flake.lock

@@ -24,7 +24,7 @@
       # Other overlays
       (final: prev: rec {
         zigpkgs = inputs.zig.packages.${prev.system};
-        zig = inputs.zig.packages.${prev.system}."master";
+        zig = inputs.zig.packages.${prev.system}."0.14.1";
 
         # Latest versions
         wasmtime = inputs.nixpkgs-unstable.legacyPackages.${prev.system}.wasmtime;

flake.nix

@@ -17,7 +17,12 @@ const log = std.log.scoped(.libxev_kqueue);
 /// True if this backend is available on this platform.
 pub fn available() bool {
     return switch (builtin.os.tag) {
-        .freebsd, .ios, .macos => true,
+        // macOS uses kqueue
+        .ios, .macos => true,
+
+        // BSDs use kqueue, but we only test on FreeBSD for now.
+        // kqueue isn't exactly the same here as it is on Apple platforms.
+        .freebsd => true,
 
         // Technically other BSDs support kqueue but our implementation
         // below hard requires mach ports currently. That's not a fundamental
@@ -28,9 +33,7 @@ pub fn available() bool {
 }
 
 pub const NOTE_EXIT_FLAGS = switch (builtin.os.tag) {
-    .ios,
-    .macos,
-    => std.c.NOTE.EXIT | std.c.NOTE.EXITSTATUS,
+    .ios, .macos => std.c.NOTE.EXIT | std.c.NOTE.EXITSTATUS,
     .freebsd => std.c.NOTE.EXIT,
     else => @compileError("kqueue not supported yet for target OS"),
 };

src/backend/kqueue.zig

@@ -49,7 +49,8 @@ pub const Backend = enum {
     pub fn default() Backend {
         return switch (builtin.os.tag) {
             .linux => .io_uring,
-            .ios, .macos, .freebsd => .kqueue,
+            .ios, .macos => .kqueue,
+            .freebsd => .kqueue,
             .wasi => .wasi_poll,
             .windows => .iocp,
             else => {
@@ -63,7 +64,8 @@ pub const Backend = enum {
     pub fn candidates() []const Backend {
         return switch (builtin.os.tag) {
             .linux => &.{ .io_uring, .epoll },
-            .freebsd, .ios, .macos => &.{.kqueue},
+            .ios, .macos => &.{.kqueue},
+            .freebsd => &.{.kqueue},
             .wasi => &.{.wasi_poll},
             .windows => &.{.iocp},
             else => {

src/main.zig

@@ -5,8 +5,6 @@ const assert = std.debug.assert;
 const posix = std.posix;
 const common = @import("common.zig");
 
-pub extern "c" fn eventfd(initval: c_uint, flags: c_uint) c_int;
-
 pub fn Async(comptime xev: type) type {
     if (xev.dynamic) return AsyncDynamic(xev);
 
@@ -19,7 +17,7 @@ pub fn Async(comptime xev: type) type {
         // Supported, uses the backend API
         .wasi_poll => AsyncLoopState(xev, xev.Loop.threaded),
 
-        // Supported, uses mach port on Mac and eventfd on BSD
+        // Supported, uses mach port on Darwin and eventfd on BSD.
         .kqueue => if (comptime builtin.target.os.tag.isDarwin())
             AsyncMachPort(xev)
         else
@@ -40,12 +38,29 @@ fn AsyncEventFd(comptime xev: type) type {
         /// eventfd file descriptor
         fd: posix.fd_t,
 
+        /// This is only used for FreeBSD currently.
+        extern "c" fn eventfd(initval: c_uint, flags: c_uint) c_int;
+
         /// Create a new async. An async can be assigned to exactly one loop
         /// to be woken up. The completion must be allocated in advance.
         pub fn init() !Self {
             return .{
-                //.fd = try std.posix.eventfd(0, std.os.linux.EFD.CLOEXEC),
-                .fd = eventfd(0, 0),
+                .fd = switch (builtin.os.tag) {
+                    // std.posix is unavailable on FreeBSD. We call the
+                    // syscall directly.
+                    //
+                    // TODO: error handling
+                    .freebsd => eventfd(
+                        0,
+                        0x100000, // EFD_CLOEXEC
+                    ),
+
+                    // Use std.posix if we can.
+                    else => try std.posix.eventfd(
+                        0,
+                        std.os.linux.EFD.CLOEXEC,
+                    ),
+                },
             };
         }