Fix FreeBSD runtime issues found by running the test suite

packages/bun-usockets/src/loop.c

@@ -23,7 +23,9 @@
 #include <string.h>
 #include <time.h>
 #ifndef WIN32
+#include <fcntl.h>
 #include <sys/ioctl.h>
+#include <unistd.h>
 #endif
 #ifdef __linux__
 #include <netinet/in.h>
@@ -693,16 +695,41 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, in
                         msg.msg_iovlen = 1;
                         msg.msg_name = NULL;
                         msg.msg_namelen = 0;
-                        msg.msg_controllen = CMSG_LEN(sizeof(int));
+                        /* CMSG_SPACE (the full aligned buffer), or FreeBSD truncates and drops the fd. */
+                        msg.msg_controllen = sizeof(cmsg_buf);
                         msg.msg_control = cmsg_buf;
 
+                        // Received descriptors must not leak into children we spawn.
+                        #ifdef MSG_CMSG_CLOEXEC
+                        length = bsd_recvmsg(us_poll_fd(&s->p), &msg, recv_flags | MSG_CMSG_CLOEXEC);
+                        #else
                         length = bsd_recvmsg(us_poll_fd(&s->p), &msg, recv_flags);
+                        #endif
 
-                        // Extract file descriptor if present
+                        // Extract the file descriptor if present. One per message is the
+                        // protocol; close anything else a peer packed into the buffer.
                         if (length > 0 && msg.msg_controllen > 0) {
-                            struct cmsghdr *cmsg_ptr = CMSG_FIRSTHDR(&msg);
-                            if (cmsg_ptr && cmsg_ptr->cmsg_level == SOL_SOCKET && cmsg_ptr->cmsg_type == SCM_RIGHTS) {
-                                int fd = *(int *)CMSG_DATA(cmsg_ptr);
+                            int fd = -1;
+                            for (struct cmsghdr *cmsg_ptr = CMSG_FIRSTHDR(&msg); cmsg_ptr; cmsg_ptr = CMSG_NXTHDR(&msg, cmsg_ptr)) {
+                                if (cmsg_ptr->cmsg_level != SOL_SOCKET || cmsg_ptr->cmsg_type != SCM_RIGHTS || cmsg_ptr->cmsg_len < CMSG_LEN(0)) {
+                                    continue;
+                                }
+                                unsigned char *fds = CMSG_DATA(cmsg_ptr);
+                                size_t nfds = (cmsg_ptr->cmsg_len - CMSG_LEN(0)) / sizeof(int);
+                                for (size_t i = 0; i < nfds; i++) {
+                                    int received;
+                                    memcpy(&received, fds + i * sizeof(int), sizeof(int));
+                                    #ifndef MSG_CMSG_CLOEXEC
+                                    fcntl(received, F_SETFD, FD_CLOEXEC);
+                                    #endif
+                                    if (fd == -1) {
+                                        fd = received;
+                                    } else {
+                                        close(received);
+                                    }
+                                }
+                            }
+                            if (fd != -1) {
                                 s = us_dispatch_fd(s, fd);
                                 if (!s || us_socket_is_closed(s)) {
                                     break;

scripts/build/deps/webkit.ts

@@ -3,7 +3,7 @@
  * for local mode. Override via `--webkit-version=<hash>` to test a branch.
  * From https://github.com/oven-sh/WebKit releases.
  */
-export const WEBKIT_VERSION = "caad865eb1a6e5ca4427f5ea1f066140b11953e7";
+export const WEBKIT_VERSION = "687eb8e1b73cb2d45ea9e689a97ea8cb867ab754";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

scripts/build/flags.ts

@@ -1386,7 +1386,7 @@ export const linkerFlags: Flag[] = [
       "-Wl,--build-id=sha1",
     ],
     when: c => c.freebsd,
-    desc: "FreeBSD linker tuning (same as Linux ELF)",
+    desc: "FreeBSD linker tuning (same as Linux ELF; here -z stack-size also sizes the main thread's stack)",
   },
   {
     // rust-lang/llvm-project doesn't enable `LLVM_ENABLE_ZLIB` (or `_ZSTD`) for

scripts/runner.node.mjs

@@ -54,6 +54,7 @@ import {
   getSecret,
   getShell,
   getWindowsExitReason,
+  isAndroid,
   isBuildkite,
   isCI,
   isGithubAction,
@@ -184,7 +185,7 @@ const { values: options, positionals: filters } = parseArgs({
     },
     ["coredump-upload"]: {
       type: "boolean",
-      default: isBuildkite && isLinux,
+      default: isBuildkite && isLinux && !isAndroid,
     },
     ["parallel"]: {
       type: "boolean",

scripts/utils.mjs

@@ -21,8 +21,11 @@ import { normalize as normalizeWindows } from "node:path/win32";
 
 export const isWindows = process.platform === "win32";
 export const isMacOS = process.platform === "darwin";
-export const isLinux = process.platform === "linux";
-export const isPosix = isMacOS || isLinux;
+// Node built for Termux/bionic reports "android"; CI models that as linux + abi=android.
+export const isAndroid = process.platform === "android";
+export const isLinux = process.platform === "linux" || isAndroid;
+export const isFreeBSD = process.platform === "freebsd";
+export const isPosix = isMacOS || isLinux || isFreeBSD;
 
 export const isArm64 = process.arch === "arm64";
 export const isX64 = process.arch === "x64";
@@ -1538,23 +1541,26 @@ export function parseNumber(value) {
 
 /**
  * @param {string} string
- * @returns {"darwin" | "linux" | "windows"}
+ * @returns {"darwin" | "linux" | "windows" | "freebsd"}
  */
 export function parseOs(string) {
   if (/darwin|apple|mac/i.test(string)) {
     return "darwin";
   }
-  if (/linux/i.test(string)) {
+  if (/linux|android/i.test(string)) {
     return "linux";
   }
+  if (/freebsd/i.test(string)) {
+    return "freebsd";
+  }
   if (/win/i.test(string)) {
     return "windows";
   }
   throw new Error(`Unsupported operating system: ${string}`);
 }
 
 /**
- * @returns {"darwin" | "linux" | "windows"}
+ * @returns {"darwin" | "linux" | "windows" | "freebsd"}
  */
 export function getOs() {
   return parseOs(process.platform);
@@ -1604,13 +1610,17 @@ export function getKernel() {
 }
 
 /**
- * @returns {"musl" | "gnu" | undefined}
+ * @returns {"musl" | "gnu" | "android" | undefined}
  */
 export function getAbi() {
   if (!isLinux) {
     return;
   }
 
+  if (isAndroid || existsSync("/system/bin/linker64")) {
+    return "android";
+  }
+
   if (existsSync("/etc/alpine-release")) {
     return "musl";
   }

src/bun_core/lib.rs

@@ -2406,19 +2406,15 @@ pub mod ffi {
     /// Safe `uname(2)` wrapper: zero-init a `utsname`, call `libc::uname`, return
     /// it by value. On the (theoretical) error path the struct stays all-zero,
     /// so every `c_char[]` field reads as an empty NUL-terminated string.
+    /// Goes through the `libc` crate rather than binding the symbol by name:
+    /// on FreeBSD the exported `uname` is a compat entry with 32-byte fields and
+    /// the real call is `__xuname(256, buf)`, which the crate already handles.
     #[cfg(unix)]
     #[inline]
     pub fn uname() -> libc::utsname {
-        // `&mut libc::utsname` is ABI-identical to libc's `struct utsname *`
-        // (thin non-null pointer to a `#[repr(C)]` struct); the type encodes
-        // the only pointer-validity precondition, so `safe fn` discharges the
-        // link-time proof and the call needs no `unsafe` block.
-        unsafe extern "C" {
-            #[link_name = "uname"]
-            safe fn libc_uname(buf: &mut libc::utsname) -> core::ffi::c_int;
-        }
         let mut u: libc::utsname = zeroed();
-        let _ = libc_uname(&mut u);
+        // SAFETY: `u` is a valid, writable utsname for the duration of the call.
+        let _ = unsafe { libc::uname(&raw mut u) };
         u
     }
 

src/io/lib.rs

@@ -1542,15 +1542,19 @@ impl Poll {
         );
 
         let one_shot_flag = libc::EV_ONESHOT;
-        let udata: usize = Pollable::init(tag, std::ptr::from_mut::<Poll>(poll)).ptr() as usize;
-        let (filter, flags_): (i16, u16) = match action {
-            ApplyAction::Readable => (libc::EVFILT_READ, libc::EV_ADD | one_shot_flag),
-            ApplyAction::Writable => (libc::EVFILT_WRITE, libc::EV_ADD | one_shot_flag),
+        let owner = Pollable::init(tag, std::ptr::from_mut::<Poll>(poll)).ptr() as usize;
+        // A cancel carries no udata: its owner is finished (`on_done` runs right
+        // after), EV_DELETE matches by (ident, filter) alone, and any receipt for it
+        // (knote already fired → ENOENT, fd closed → EBADF) must land on the
+        // `PollableTag::Empty` early return, not on the stale owner.
+        let (filter, flags_, udata): (i16, u16, usize) = match action {
+            ApplyAction::Readable => (libc::EVFILT_READ, libc::EV_ADD | one_shot_flag, owner),
+            ApplyAction::Writable => (libc::EVFILT_WRITE, libc::EV_ADD | one_shot_flag, owner),
             ApplyAction::Cancel => {
                 if poll.flags.contains(Flags::PollReadable) {
-                    (libc::EVFILT_READ, libc::EV_DELETE)
+                    (libc::EVFILT_READ, libc::EV_DELETE, 0)
                 } else if poll.flags.contains(Flags::PollWritable) {
-                    (libc::EVFILT_WRITE, libc::EV_DELETE)
+                    (libc::EVFILT_WRITE, libc::EV_DELETE, 0)
                 } else {
                     unreachable!()
                 }
@@ -1631,16 +1635,19 @@ impl Poll {
 
         let pollable = Pollable::from(event.udata as u64);
         let tag = pollable.tag();
-        // The waker is registered with udata=0 → tag=.empty. The wakeup exists
-        // only to unblock kevent() so the pending queue drains.
+        // The waker (whose event only exists to unblock kevent() so the pending
+        // queue drains) and cancels are submitted with udata=0 → tag=.empty.
         if tag == PollableTag::Empty {
             return;
         }
         let poll = pollable.poll();
         // CYCLEBREAK: owner (ReadFile/WriteFile) is T6; dispatch via link-time
         // `extern "Rust"` defined in `bun_runtime::dispatch`. The
         // container_of(io_poll) recovery happens there.
-        if event.flags == libc::EV_ERROR {
+        // A changelist entry the kernel could not apply comes back with EV_ERROR
+        // set (xnu ORs it into the action bits, FreeBSD replaces them) and the
+        // errno in `data`.
+        if (event.flags & libc::EV_ERROR) != 0 {
             log!("error({}) = {}", event.ident, event.data);
             // SAFETY: poll is the `io_poll` field of a live owner; link-time
             // extern body matches on `tag`.

src/runtime/api/bun/Terminal.rs

@@ -10,8 +10,6 @@
 //! - Callbacks are stored via `values` in classes.ts, accessed via js.gc
 
 use core::cell::Cell;
-#[cfg(unix)]
-use core::ffi::c_ulong;
 use core::ffi::{c_int, c_void};
 #[cfg(windows)]
 use core::sync::atomic::{AtomicU32, Ordering};
@@ -920,8 +918,9 @@ mod lib_util {
 
 #[cfg(unix)]
 fn get_open_pty_fn() -> Option<OpenPtyFn> {
-    // On macOS, openpty is in libc, so we can use it directly
-    #[cfg(target_os = "macos")]
+    // openpty is linked directly on macOS (libc) and FreeBSD (libutil, see
+    // scripts/build/bun.ts).
+    #[cfg(any(target_os = "macos", target_os = "freebsd"))]
     {
         // Declared locally (not via the `libc` crate) so the `OpenPtyFn`
         // type unifies with the Linux dlsym path.
@@ -947,7 +946,12 @@ fn get_open_pty_fn() -> Option<OpenPtyFn> {
         return lib_util::get_open_pty();
     }
 
-    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "android")))]
+    #[cfg(not(any(
+        target_os = "macos",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd"
+    )))]
     None
 }
 
@@ -1565,11 +1569,6 @@ impl Terminal {
 
         #[cfg(unix)]
         {
-            #[cfg(target_os = "macos")]
-            const TIOCSWINSZ: c_ulong = 0x80087467;
-            #[cfg(not(target_os = "macos"))]
-            const TIOCSWINSZ: c_ulong = 0x5414;
-
             let winsize = bun_core::Winsize {
                 row: new_rows,
                 col: new_cols,
@@ -1582,7 +1581,7 @@ impl Terminal {
             let ioctl_result = unsafe {
                 libc::ioctl(
                     self.master_fd.get().native(),
-                    TIOCSWINSZ as _,
+                    libc::TIOCSWINSZ as _,
                     &raw const winsize,
                 )
             };

src/runtime/cli/install_completions_command.rs

@@ -553,10 +553,11 @@ impl InstallCompletionsCommand {
 
             // Check if they need to load the zsh completions file into their .zshrc
             if shell == Shell::Zsh {
-                let mut completions_absolute_path_buf = PathBuffer::uninit();
-                let completions_path =
-                    bun_sys::get_fd_path(output_file.handle, &mut completions_absolute_path_buf)
-                        .expect("unreachable");
+                let mut completions_path_buf = PathBuffer::uninit();
+                let completions_path: &[u8] = resolve_path::join_string_buf::<platform::Auto>(
+                    &mut completions_path_buf,
+                    &[completions_dir, filename],
+                );
                 let mut zshrc_filepath = PathBuffer::uninit();
                 let needs_to_tell_them_to_add_completions_file: bool = 'brk: {
                     let dot_zshrc: File = 'zshrc: {
@@ -693,8 +694,8 @@ impl InstallCompletionsCommand {
                 if needs_to_tell_them_to_add_completions_file {
                     pretty_errorln!(
                         "<r>To enable completions, add this to your .zshrc:\n      <b>[ -s \"{}\" ] && source \"{}\"",
-                        bstr::BStr::new(&*completions_path),
-                        bstr::BStr::new(&*completions_path),
+                        bstr::BStr::new(completions_path),
+                        bstr::BStr::new(completions_path),
                     );
                 }
             }

src/runtime/webcore/blob/read_file.rs

@@ -396,11 +396,10 @@ impl ReadFile {
             node: Default::default(),
             callback: Self::do_read_loop_task,
         };
-        // On macOS, we use one-shot mode, so:
+        // On kqueue platforms we use one-shot mode, so:
         // - we don't need to unregister
         // - we don't need to delete from kqueue
-        #[cfg(target_os = "macos")]
-        {
+        if bun_core::Environment::IS_KQUEUE {
             // unless pending IO has been scheduled in-between.
             self.close_after_io = self.io_request.scheduled;
         }
@@ -416,11 +415,10 @@ impl ReadFile {
             node: Default::default(),
             callback: Self::do_read_loop_task,
         };
-        // On macOS, we use one-shot mode, so:
+        // On kqueue platforms we use one-shot mode, so:
         // - we don't need to unregister
         // - we don't need to delete from kqueue
-        #[cfg(target_os = "macos")]
-        {
+        if bun_core::Environment::IS_KQUEUE {
             // unless pending IO has been scheduled in-between.
             self.close_after_io = self.io_request.scheduled;
         }

src/runtime/webcore/blob/write_file.rs

@@ -476,9 +476,8 @@ impl WriteFile {
         // SAFETY: only reached via `WorkPoolTask::callback` with `task` = `&mut self.task`
         // (intrusive) registered in `on_writable`/`init`; recover parent.
         let this = unsafe { WriteFile::from_task_ptr(task) };
-        // On macOS, we use one-shot mode, so we don't need to unregister.
-        #[cfg(target_os = "macos")]
-        {
+        // On kqueue platforms we use one-shot mode, so we don't need to unregister.
+        if bun_core::Environment::IS_KQUEUE {
             // SAFETY: `this` is the live parent (see above); scoped access.
             unsafe { (*this).close_after_io = false };
         }

src/spawn_sys/lib.rs

@@ -121,8 +121,12 @@ pub mod waiter_thread_flag {
 
     static SHOULD_USE_WAITER_THREAD: AtomicBool = AtomicBool::new(false);
 
+    /// The waiter thread is the fallback for Linux without pidfd. kqueue
+    /// platforms always have EVFILT_PROC, and the thread's loop has no wakeup
+    /// for newly appended processes there, so the flag is not honoured on them.
     #[inline]
     pub fn set() {
+        #[cfg(any(target_os = "linux", target_os = "android"))]
         SHOULD_USE_WAITER_THREAD.store(true, Ordering::Relaxed);
     }