Fix the build on FreeBSD (and OpenBSD?)

Package.swift

@@ -27,6 +27,10 @@ var defaultTraits: Set<String> = ["SubprocessFoundation"]
 defaultTraits.insert("SubprocessSpan")
 #endif
 
+let packageSwiftSettings: [SwiftSetting] = [
+    .define("SUBPROCESS_ASYNCIO_DISPATCH", .when(platforms: [.macOS, .custom("freebsd"), .openbsd]))
+]
+
 let package = Package(
     name: "Subprocess",
     platforms: [.macOS(.v13), .iOS("99.0")],
@@ -58,7 +62,7 @@ let package = Package(
                 .enableExperimentalFeature("NonescapableTypes"),
                 .enableExperimentalFeature("LifetimeDependence"),
                 .enableExperimentalFeature("Span"),
-            ]
+            ] + packageSwiftSettings
         ),
         .testTarget(
             name: "SubprocessTests",
@@ -70,7 +74,7 @@ let package = Package(
             ],
             swiftSettings: [
                 .enableExperimentalFeature("Span"),
-            ]
+            ] + packageSwiftSettings
         ),
 
         .target(

Sources/Subprocess/AsyncBufferSequence.swift

@@ -23,7 +23,7 @@ public struct AsyncBufferSequence: AsyncSequence, @unchecked Sendable {
     public typealias Failure = any Swift.Error
     public typealias Element = Buffer
 
-    #if canImport(Darwin)
+    #if SUBPROCESS_ASYNCIO_DISPATCH
     internal typealias DiskIO = DispatchIO
     #elseif canImport(WinSDK)
     internal typealias DiskIO = HANDLE
@@ -55,7 +55,7 @@ public struct AsyncBufferSequence: AsyncSequence, @unchecked Sendable {
             )
             guard let data else {
                 // We finished reading. Close the file descriptor now
-                #if canImport(Darwin)
+                #if SUBPROCESS_ASYNCIO_DISPATCH
                 try _safelyClose(.dispatchIO(self.diskIO))
                 #elseif canImport(WinSDK)
                 try _safelyClose(.handle(self.diskIO))
@@ -137,7 +137,7 @@ extension AsyncBufferSequence {
                         self.eofReached = true
                         return nil
                     }
-                    #if canImport(Darwin)
+                    #if SUBPROCESS_ASYNCIO_DISPATCH
                     // Unfortunately here we _have to_ copy the bytes out because
                     // DispatchIO (rightfully) reuses buffer, which means `buffer.data`
                     // has the same address on all iterations, therefore we can't directly

Sources/Subprocess/Buffer.swift

@@ -17,7 +17,7 @@
 extension AsyncBufferSequence {
     /// A immutable collection of bytes
     public struct Buffer: Sendable {
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         // We need to keep the backingData alive while Slice is alive
         internal let backingData: DispatchData
         internal let data: DispatchData.Region
@@ -45,7 +45,7 @@ extension AsyncBufferSequence {
         internal static func createFrom(_ data: [UInt8]) -> [Buffer] {
             return [.init(data: data)]
         }
-        #endif // canImport(Darwin)
+        #endif // SUBPROCESS_ASYNCIO_DISPATCH
     }
 }
 
@@ -92,7 +92,7 @@ extension AsyncBufferSequence.Buffer {
 
 // MARK: - Hashable, Equatable
 extension AsyncBufferSequence.Buffer: Equatable, Hashable {
-    #if canImport(Darwin)
+    #if SUBPROCESS_ASYNCIO_DISPATCH
     public static func == (lhs: AsyncBufferSequence.Buffer, rhs: AsyncBufferSequence.Buffer) -> Bool {
         return lhs.data == rhs.data
     }
@@ -104,7 +104,7 @@ extension AsyncBufferSequence.Buffer: Equatable, Hashable {
     // else Compiler generated conformances
 }
 
-#if canImport(Darwin)
+#if SUBPROCESS_ASYNCIO_DISPATCH
 extension DispatchData.Region {
     static func == (lhs: DispatchData.Region, rhs: DispatchData.Region) -> Bool {
         return lhs.withUnsafeBytes { lhsBytes in
@@ -120,7 +120,7 @@ extension DispatchData.Region {
         }
     }
 }
-#if !SubprocessFoundation
+#if !canImport(Darwin) || !SubprocessFoundation
 /// `DispatchData.Region` is defined in Foundation, but we can't depend on Foundation when the SubprocessFoundation trait is disabled.
 extension DispatchData {
     typealias Region = _ContiguousBufferView

Sources/Subprocess/CMakeLists.txt

@@ -17,7 +17,7 @@ add_library(Subprocess
   Result.swift
   IO/Output.swift
   IO/Input.swift
-  IO/AsyncIO+Darwin.swift
+  IO/AsyncIO+Dispatch.swift
   IO/AsyncIO+Linux.swift
   IO/AsyncIO+Windows.swift
   Span+Subprocess.swift
@@ -36,8 +36,13 @@ elseif(LINUX OR ANDROID)
     Platforms/Subprocess+Unix.swift)
 elseif(APPLE)
   target_sources(Subprocess PRIVATE
+    Platforms/Subprocess+BSD.swift
     Platforms/Subprocess+Darwin.swift
     Platforms/Subprocess+Unix.swift)
+elseif(FREEBSD OR OPENBSD)
+  target_sources(Subprocess PRIVATE
+    Platforms/Subprocess+BSD.swift
+    Platforms/Subprocess+Unix.swift)
 endif()
 
 target_compile_options(Subprocess PRIVATE

Sources/Subprocess/Configuration.swift

@@ -657,7 +657,7 @@ internal struct IODescriptor: ~Copyable {
     consuming func createIOChannel() -> IOChannel {
         let shouldClose = self.closeWhenDone
         self.closeWhenDone = false
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         // Transferring out the ownership of fileDescriptor means we don't have go close here
         let closeFd = self.descriptor
         let dispatchIO: DispatchIO = DispatchIO(
@@ -708,10 +708,10 @@ internal struct IODescriptor: ~Copyable {
 }
 
 internal struct IOChannel: ~Copyable, @unchecked Sendable {
-    #if canImport(WinSDK)
-    typealias Channel = HANDLE
-    #elseif canImport(Darwin)
+    #if SUBPROCESS_ASYNCIO_DISPATCH
     typealias Channel = DispatchIO
+    #elseif canImport(WinSDK)
+    typealias Channel = HANDLE
     #else
     typealias Channel = FileDescriptor
     #endif
@@ -733,10 +733,10 @@ internal struct IOChannel: ~Copyable, @unchecked Sendable {
         }
         closeWhenDone = false
 
-        #if canImport(WinSDK)
-        try _safelyClose(.handle(self.channel))
-        #elseif canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         try _safelyClose(.dispatchIO(self.channel))
+        #elseif canImport(WinSDK)
+        try _safelyClose(.handle(self.channel))
         #else
         try _safelyClose(.fileDescriptor(self.channel))
         #endif

Sources/Subprocess/IO/AsyncIO+Darwin.swift → Sources/Subprocess/IO/AsyncIO+Dispatch.swift

@@ -12,7 +12,7 @@
 /// Darwin AsyncIO implementation based on DispatchIO
 
 // MARK: - macOS (DispatchIO)
-#if canImport(Darwin)
+#if SUBPROCESS_ASYNCIO_DISPATCH
 
 #if canImport(System)
 @preconcurrency import System
@@ -166,4 +166,8 @@ final class AsyncIO: Sendable {
     }
 }
 
+#if !canImport(Darwin)
+extension DispatchData: @retroactive @unchecked Sendable { }
+#endif
+
 #endif

Sources/Subprocess/IO/AsyncIO+Linux.swift

@@ -11,7 +11,7 @@
 
 /// Linux AsyncIO implementation based on epoll
 
-#if canImport(Glibc) || canImport(Android) || canImport(Musl)
+#if os(Linux) || os(Android)
 
 #if canImport(System)
 @preconcurrency import System
@@ -266,6 +266,11 @@ final class AsyncIO: Sendable {
                     targetEvent = EPOLL_EVENTS(EPOLLOUT)
                 }
 
+                // Save the continuation (before calling epoll_ctl, so we don't miss any data)
+                _registration.withLock { storage in
+                    storage[fileDescriptor.rawValue] = continuation
+                }
+
                 var event = epoll_event(
                     events: targetEvent.rawValue,
                     data: epoll_data(fd: fileDescriptor.rawValue)
@@ -277,6 +282,10 @@ final class AsyncIO: Sendable {
                     &event
                 )
                 if rc != 0 {
+                    _registration.withLock { storage in
+                        storage.removeValue(forKey: fileDescriptor.rawValue)
+                    }
+
                     let capturedError = errno
                     let error = SubprocessError(
                         code: .init(.asyncIOFailed(
@@ -287,10 +296,6 @@ final class AsyncIO: Sendable {
                     continuation.finish(throwing: error)
                     return
                 }
-                // Now save the continuation
-                _registration.withLock { storage in
-                    storage[fileDescriptor.rawValue] = continuation
-                }
             case .failure(let setupError):
                 continuation.finish(throwing: setupError)
                 return

Sources/Subprocess/IO/Output.swift

@@ -148,7 +148,7 @@ public struct BytesOutput: OutputProtocol {
     internal func captureOutput(
         from diskIO: consuming IOChannel
     ) async throws -> [UInt8] {
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         var result: DispatchData? = nil
         #else
         var result: [UInt8]? = nil
@@ -173,7 +173,7 @@ public struct BytesOutput: OutputProtocol {
                 underlyingError: nil
             )
         }
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         return result?.array() ?? []
         #else
         return result ?? []
@@ -302,7 +302,7 @@ extension OutputProtocol {
             return try await bytesOutput.captureOutput(from: diskIO) as! Self.OutputType
         }
 
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         var result: DispatchData? = nil
         #else
         var result: [UInt8]? = nil
@@ -328,7 +328,7 @@ extension OutputProtocol {
             )
         }
 
-        #if canImport(Darwin)
+        #if SUBPROCESS_ASYNCIO_DISPATCH
         return try self.output(from: result ?? .empty)
         #else
         return try self.output(from: result ?? [])
@@ -353,7 +353,7 @@ extension OutputProtocol where OutputType == Void {
 
 #if SubprocessSpan
 extension OutputProtocol {
-    #if canImport(Darwin)
+    #if SUBPROCESS_ASYNCIO_DISPATCH
     internal func output(from data: DispatchData) throws -> OutputType {
         guard !data.isEmpty else {
             let empty = UnsafeRawBufferPointer(start: nil, count: 0)
@@ -380,7 +380,7 @@ extension OutputProtocol {
             return try self.output(from: span)
         }
     }
-    #endif // canImport(Darwin)
+    #endif // SUBPROCESS_ASYNCIO_DISPATCH
 }
 #endif
 

Sources/Subprocess/Platforms/Subprocess+BSD.swift

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+#if os(macOS) || os(FreeBSD) || os(OpenBSD)
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+internal import Dispatch
+
+// MARK: - Process Monitoring
+@Sendable
+internal func monitorProcessTermination(
+    for processIdentifier: ProcessIdentifier
+) async throws -> TerminationStatus {
+    switch Result(catching: { () throws(SubprocessError.UnderlyingError) -> TerminationStatus? in try processIdentifier.reap() }) {
+    case let .success(status?):
+        return status
+    case .success(nil):
+        break
+    case let .failure(error):
+        throw SubprocessError(
+            code: .init(.failedToMonitorProcess),
+            underlyingError: error
+        )
+    }
+    return try await withCheckedThrowingContinuation { continuation in
+        let source = DispatchSource.makeProcessSource(
+            identifier: processIdentifier.value,
+            eventMask: [.exit],
+            queue: .global()
+        )
+        source.setEventHandler {
+            source.cancel()
+            continuation.resume(with: Result(catching: { () throws(SubprocessError.UnderlyingError) -> TerminationStatus in
+                // NOTE_EXIT may be delivered slightly before the process becomes reapable,
+                // so we must call waitid without WNOHANG to avoid a narrow possibility of a race condition.
+                // If waitid does block, it won't do so for very long at all.
+                try processIdentifier.blockingReap()
+            }).mapError { underlyingError in
+                SubprocessError(    
+                    code: .init(.failedToMonitorProcess),
+                    underlyingError: underlyingError
+                )
+            })
+        }
+        source.resume()
+    }
+}
+
+#endif

Sources/Subprocess/Platforms/Subprocess+Darwin.swift

@@ -497,46 +497,4 @@ extension ProcessIdentifier: CustomStringConvertible, CustomDebugStringConvertib
     public var debugDescription: String { "\(self.value)" }
 }
 
-// MARK: - Process Monitoring
-@Sendable
-internal func monitorProcessTermination(
-    for processIdentifier: ProcessIdentifier
-) async throws -> TerminationStatus {
-    return try await withCheckedThrowingContinuation { continuation in
-        let source = DispatchSource.makeProcessSource(
-            identifier: processIdentifier.value,
-            eventMask: [.exit],
-            queue: .global()
-        )
-        source.setEventHandler {
-            source.cancel()
-            var siginfo = siginfo_t()
-            let rc = waitid(P_PID, id_t(processIdentifier.value), &siginfo, WEXITED)
-            guard rc == 0 else {
-                continuation.resume(
-                    throwing: SubprocessError(
-                        code: .init(.failedToMonitorProcess),
-                        underlyingError: .init(rawValue: errno)
-                    )
-                )
-                return
-            }
-            switch siginfo.si_code {
-            case .init(CLD_EXITED):
-                continuation.resume(returning: .exited(siginfo.si_status))
-                return
-            case .init(CLD_KILLED), .init(CLD_DUMPED):
-                continuation.resume(returning: .unhandledException(siginfo.si_status))
-            case .init(CLD_TRAPPED), .init(CLD_STOPPED), .init(CLD_CONTINUED), .init(CLD_NOOP):
-                // Ignore these signals because they are not related to
-                // process exiting
-                break
-            default:
-                fatalError("Unexpected exit status: \(siginfo.si_code)")
-            }
-        }
-        source.resume()
-    }
-}
-
 #endif  // canImport(Darwin)