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

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

* Use signal handler for process state monitoring on Linux kernel lower than 5.4

* Disable testPlatformOptionsRunAsUser on CI if we don't have privilege to create a temporary user

* Remove unused consoleBehavior from Execution

* Add PlatformConformance in tests to ensure platform specifc types follow a uniform shape

* Disable testPlatformOptionsRunAsUser until we can resolve CI filure issue

* Prob whether waitid supports P_PIDFD instead of checking for Linux kernel version

* Use  as a platform-independent term to describe pidfd(Linux)/process handle (Windows)

Author: iCharlesHu

Sources/Subprocess/Configuration.swift

@@ -103,7 +103,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

@@ -34,37 +34,11 @@ public struct Execution: Sendable {
     /// The process identifier of the current execution
     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
     init(
         processIdentifier: ProcessIdentifier
     ) {
         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(