Enable FreeBSD CI (#238)

Also fixes FreeBSD/OpenBSD build issues due to different pthread definitions, and an ordering issue where setgroups, setuid, and setgid were called in a different order from the macOS implementations (setgroups needs root so must be called first).

Author: jakepetroules

.github/workflows/pull_request.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   tests:
     name: Test
-    uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.6
+    uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.10
     with:
       linux_os_versions: '["amazonlinux2", "bookworm", "noble", "jammy", "rhel-ubi9"]'
       linux_swift_versions: '["6.2", "nightly-main"]'
@@ -36,6 +36,8 @@ jobs:
           yum install -y procps
         fi
       linux_build_command: 'swift test && swift test -c release && swift test --disable-default-traits'
+      enable_freebsd_checks: true
+      freebsd_build_command: 'swift test && swift test -c release && swift test --disable-default-traits'
       windows_swift_versions: '["6.2", "nightly-main"]'
       windows_build_command: |
         Invoke-Program swift test
@@ -57,7 +59,7 @@ jobs:
 
   soundness:
     name: Soundness
-    uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.6
+    uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.10
     with:
       license_header_check_project_name: "Swift.org"
       docs_check_enabled: false

Sources/Subprocess/Thread.swift

@@ -33,6 +33,12 @@ import Synchronization
 private typealias MutexType = CRITICAL_SECTION
 private typealias ConditionType = CONDITION_VARIABLE
 private typealias ThreadType = HANDLE
+#elseif os(FreeBSD) || os(OpenBSD)
+// On FreeBSD/OpenBSD, pthread types are pointer types (e.g. struct pthread_mutex *),
+// and pthread functions expect nullable pointers to them.
+private typealias MutexType = pthread_mutex_t?
+private typealias ConditionType = pthread_cond_t?
+private typealias ThreadType = pthread_t
 #else
 private typealias MutexType = pthread_mutex_t
 private typealias ConditionType = pthread_cond_t
@@ -320,7 +326,7 @@ internal func pthread_create(
         (Unmanaged<AnyObject>.fromOpaque(context!).takeRetainedValue() as! Context).body()
         return context
     }
-    #if canImport(Glibc) || canImport(Bionic)
+    #if (canImport(Glibc) || canImport(Bionic)) && !os(FreeBSD) && !os(OpenBSD)
     var thread = pthread_t()
     #else
     var thread: pthread_t?
@@ -334,7 +340,7 @@ internal func pthread_create(
     if rc != 0 {
         throw Errno(rawValue: rc)
     }
-    #if canImport(Glibc) || canImport(Bionic)
+    #if (canImport(Glibc) || canImport(Bionic)) && !os(FreeBSD) && !os(OpenBSD)
     return thread
     #else
     return thread!

Sources/_SubprocessCShims/include/process_shims.h

@@ -41,7 +41,7 @@ extern "C" {
 #endif
 
 int _subprocess_pthread_create(
-#if TARGET_OS_MAC
+#if TARGET_OS_MAC || defined(__FreeBSD__) || defined(__OpenBSD__)
     pthread_t _Nullable * _Nonnull ptr,
 #else
     pthread_t * _Nonnull ptr,

Sources/_SubprocessCShims/process_shims.c

@@ -615,23 +615,23 @@ int _subprocess_fork_exec(
             }
         }
 
-        if (uid != NULL) {
-            if (setuid(*uid) != 0) {
+        if (number_of_sgroups > 0 && sgroups != NULL) {
+            // POSIX doesn't define setgroups (only getgroups) and therefore makes no guarantee of async-signal-safety,
+            // but we'll assume in practice it should be async-signal-safe on any reasonable platform based on the fact
+            // that getgroups is async-signal-safe.
+            if (setgroups(number_of_sgroups, sgroups) != 0) {
                 write_error_and_exit;
             }
         }
 
-        if (gid != NULL) {
-            if (setgid(*gid) != 0) {
+        if (uid != NULL) {
+            if (setuid(*uid) != 0) {
                 write_error_and_exit;
             }
         }
 
-        if (number_of_sgroups > 0 && sgroups != NULL) {
-            // POSIX doesn't define setgroups (only getgroups) and therefore makes no guarantee of async-signal-safety,
-            // but we'll assume in practice it should be async-signal-safe on any reasonable platform based on the fact
-            // that getgroups is async-signal-safe.
-            if (setgroups(number_of_sgroups, sgroups) != 0) {
+        if (gid != NULL) {
+            if (setgid(*gid) != 0) {
                 write_error_and_exit;
             }
         }

Tests/SubprocessTests/AsyncIOTests.swift

@@ -35,7 +35,11 @@ import _SubprocessCShims
 @testable import Subprocess
 
 @Suite("Subprocess.AsyncIO Unit Tests", .serialized)
-struct SubprocessAsyncIOTests {}
+struct SubprocessAsyncIOTests {
+    init() {
+        _ = globallyIgnoredSIGPIPE
+    }
+}
 
 // MARK: - Basic Functionality Tests
 extension SubprocessAsyncIOTests {
@@ -228,7 +232,7 @@ extension SubprocessAsyncIOTests {
 
 // MARK: - Utils
 extension SubprocessAsyncIOTests {
-    final class TestBed {
+    final class TestBed: Sendable {
         let ioChannel: Subprocess.IOChannel
 
         init(ioChannel: consuming Subprocess.IOChannel) {
@@ -255,18 +259,23 @@ extension SubprocessAsyncIOTests {
             let readIO = AsyncIO.shared
             let writeIO = AsyncIO()
 
+            // Create TestBeds in outer scope so both pipe endpoints
+            // stay alive until both tasks complete
+            let readTestBed = try TestBed(ioChannel: _require(readBox.take()))
+            let writeTestBed = try TestBed(ioChannel: _require(writeBox.take()))
+
             group.addTask {
-                var readIOContainer: IOChannel? = readBox.take()
-                let readTestBed = try TestBed(ioChannel: _require(readIOContainer.take()))
                 try await reader(readIO, readTestBed)
             }
             group.addTask {
-                var writeIOContainer: IOChannel? = writeBox.take()
-                let writeTestBed = try TestBed(ioChannel: _require(writeIOContainer.take()))
                 try await writer(writeIO, writeTestBed)
             }
 
             try await group.waitForAll()
+            // Keep both pipe endpoints alive until both tasks complete,
+            // preventing the DispatchIO cleanup handler from closing
+            // a pipe fd while the other task is still using it.
+            withExtendedLifetime((readTestBed, writeTestBed)) {}
             // Teardown
             // readIO shutdown is done via `atexit`.
             writeIO.shutdown()

Tests/SubprocessTests/DarwinTests.swift

@@ -26,6 +26,10 @@ import SystemPackage
 // MARK: PlatformOptions Tests
 @Suite(.serialized)
 struct SubprocessDarwinTests {
+    init() {
+        _ = globallyIgnoredSIGPIPE
+    }
+
     @Test func testSubprocessPlatformOptionsProcessConfiguratorUpdateSpawnAttr() async throws {
         var platformOptions = PlatformOptions()
         platformOptions.preSpawnProcessConfigurator = { spawnAttr, _ in

Tests/SubprocessTests/IntegrationTests.swift

@@ -35,7 +35,11 @@ import _SubprocessCShims
 @testable import Subprocess
 
 @Suite("Subprocess Integration (End to End) Tests", .serialized)
-struct SubprocessIntegrationTests {}
+struct SubprocessIntegrationTests {
+    init() {
+        _ = globallyIgnoredSIGPIPE
+    }
+}
 
 // MARK: - Executable Tests
 extension SubprocessIntegrationTests {

Tests/SubprocessTests/LinuxTests.swift

@@ -35,6 +35,10 @@ import _SubprocessCShims
 // MARK: PlatformOption Tests
 @Suite(.serialized)
 struct SubprocessLinuxTests {
+    init() {
+        _ = globallyIgnoredSIGPIPE
+    }
+
     @Test func testSuspendResumeProcess() async throws {
         func blockAndWaitForStatus(
             pid: pid_t,

Tests/SubprocessTests/ProcessMonitoringTests.swift

@@ -38,6 +38,7 @@ import _SubprocessCShims
 struct SubprocessProcessMonitoringTests {
 
     init() {
+        _ = globallyIgnoredSIGPIPE
         #if os(Linux) || os(Android)
         _setupMonitorSignalHandler()
         #endif

Tests/SubprocessTests/TestSupport.swift

@@ -20,6 +20,29 @@ import FoundationEssentials
 import Testing
 import Subprocess
 
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Bionic)
+import Bionic
+#elseif canImport(Musl)
+import Musl
+#endif
+
+/// We receive a `SIGPIPE` if we write to a closed pipe, which crashes the process.
+///
+/// Some platforms have API that can be used to set state bits on a file descriptor
+/// that turn a `SIGPIPE` into an `EPIPE` instead, but this is not consistently available.
+///
+/// Instead, globally ignore `SIGPIPE` in tests to prevent us from crashing in this scenario.
+internal let globallyIgnoredSIGPIPE: Bool = {
+    #if canImport(Darwin) || canImport(Glibc) || canImport(Bionic) || canImport(Musl)
+    _ = signal(SIGPIPE, SIG_IGN)
+    #endif
+    return true
+}()
+
 #if canImport(System)
 import System
 #else