Introduce process file descriptor (pidfd) based process monitoring for Linux

Sources/Subprocess/API.swift

@@ -753,7 +753,7 @@ public func runDetached(
             errorPipe: try processError.createPipe()
         ).execution
     }
-    execution.release()
+    execution.processIdentifier.close()
     return execution.processIdentifier
 }
 

Sources/Subprocess/Configuration.swift

@@ -101,7 +101,12 @@ public struct Configuration: Sendable {
         // even if `body` throws, and we are not leaving zombie processes in the
         // process table which will cause the process termination monitoring thread
         // to effectively hang due to the pid never being awaited
-        let terminationStatus = try await Subprocess.monitorProcessTermination(forExecution: _spawnResult.execution)
+        let terminationStatus = try await Subprocess.monitorProcessTermination(
+            for: execution.processIdentifier
+        )
+
+        // Close process file descriptor now we finished monitoring
+        execution.processIdentifier.close()
 
         return try ExecutionResult(terminationStatus: terminationStatus, value: result.get())
     }

Sources/Subprocess/Execution.swift

@@ -35,16 +35,13 @@ public struct Execution: Sendable {
     public let processIdentifier: ProcessIdentifier
 
     #if os(Windows)
-    internal nonisolated(unsafe) let processInformation: PROCESS_INFORMATION
     internal let consoleBehavior: PlatformOptions.ConsoleBehavior
 
     init(
         processIdentifier: ProcessIdentifier,
-        processInformation: PROCESS_INFORMATION,
         consoleBehavior: PlatformOptions.ConsoleBehavior
     ) {
         self.processIdentifier = processIdentifier
-        self.processInformation = processInformation
         self.consoleBehavior = consoleBehavior
     }
     #else
@@ -54,17 +51,6 @@ public struct Execution: Sendable {
         self.processIdentifier = processIdentifier
     }
     #endif  // os(Windows)
-
-    internal func release() {
-        #if os(Windows)
-        guard CloseHandle(processInformation.hThread) else {
-            fatalError("Failed to close thread HANDLE: \(SubprocessError.UnderlyingError(rawValue: GetLastError()))")
-        }
-        guard CloseHandle(processInformation.hProcess) else {
-            fatalError("Failed to close process HANDLE: \(SubprocessError.UnderlyingError(rawValue: GetLastError()))")
-        }
-        #endif
-    }
 }
 
 // MARK: - Output Capture

Sources/Subprocess/Platforms/Subprocess+Darwin.swift

@@ -477,26 +477,41 @@ extension Configuration {
     }
 }
 
-// Special keys used in Error's user dictionary
-extension String {
-    static let debugDescriptionErrorKey = "NSDebugDescription"
+// MARK: - ProcessIdentifier
+
+/// A platform independent identifier for a Subprocess.
+public struct ProcessIdentifier: Sendable, Hashable {
+    /// The platform specific process identifier value
+    public let value: pid_t
+
+    public init(value: pid_t) {
+        self.value = value
+    }
+
+    internal func close() { /* No-op on Darwin */ }
+}
+
+extension ProcessIdentifier: CustomStringConvertible, CustomDebugStringConvertible {
+    public var description: String { "\(self.value)" }
+
+    public var debugDescription: String { "\(self.value)" }
 }
 
 // MARK: - Process Monitoring
 @Sendable
 internal func monitorProcessTermination(
-    forExecution execution: Execution
+    for processIdentifier: ProcessIdentifier
 ) async throws -> TerminationStatus {
     return try await withCheckedThrowingContinuation { continuation in
         let source = DispatchSource.makeProcessSource(
-            identifier: execution.processIdentifier.value,
+            identifier: processIdentifier.value,
             eventMask: [.exit],
             queue: .global()
         )
         source.setEventHandler {
             source.cancel()
             var siginfo = siginfo_t()
-            let rc = waitid(P_PID, id_t(execution.processIdentifier.value), &siginfo, WEXITED)
+            let rc = waitid(P_PID, id_t(processIdentifier.value), &siginfo, WEXITED)
             guard rc == 0 else {
                 continuation.resume(
                     throwing: SubprocessError(