Merge branch 'dev.linux'

Author: Frizlab

Doc/signal-tests/signal-test-blocked.c

@@ -45,7 +45,7 @@ static void *threadMain(void *info) {
 
 		sigset_t set;
 		sigpending(&set);
-		fprintf(stderr, "✊ Other thread pending: %d\n", sigismember(&set, s));
+		fprintf(stderr, "🧵 Other thread pending: %d\n", sigismember(&set, s));
 
 		sigemptyset(&set);
 		sigaddset(&set, s);

Package.resolved

@@ -14,6 +14,7 @@ let package = Package(
 		.package(url: "https://github.com/apple/swift-argument-parser.git", from: "0.4.0"),
 		.package(url: "https://github.com/apple/swift-log.git", from: "1.4.2"),
 		.package(url: "https://github.com/apple/swift-system.git", from: "0.0.1"),
+		.package(url: "https://github.com/swift-server/swift-backtrace.git", from: "1.2.3"),
 		.package(url: "https://github.com/xcode-actions/clt-logger.git", from: "0.3.0")
 	],
 	targets: [
@@ -24,8 +25,9 @@ let package = Package(
 
 		.target(name: "signal-handling-tests-helper", dependencies: [
 			.product(name: "ArgumentParser", package: "swift-argument-parser"),
+			.product(name: "Backtrace",      package: "swift-backtrace"),
 			.product(name: "CLTLogger",      package: "clt-logger"),
-			.product(name: "Logging",       package: "swift-log"),
+			.product(name: "Logging",        package: "swift-log"),
 			.target(name: "SignalHandling")
 		]),
 		.testTarget(name: "SignalHandlingTests", dependencies: [

Package.swift

@@ -4,6 +4,9 @@ François Lamboley <[email protected]>
 This package provides a Swift syntax for the low-level C `sigaction` function
 and a way to delay or cancel sigaction handlers.
 
+It is compatible with macOS and Linux. Read the documentation carefully before
+using the sigaction handler delaying capabilities.
+
 == Example of Use
 
 I believe good examples are worth thousands of words.
@@ -95,7 +98,9 @@ not notify `libdispatch`.
 
 * There is a non-avoidable race-condition (AFAICT) between the time the signal
 is sent and set back to ignored;
-* The signal that is sent back has lost the siginfo of the original signal.
+* The signal that is sent back has lost the siginfo of the original signal;
+* On Linux signal delaying is fragile. See Linux caveat of the blocking strategy
+for more information.
 
 === Details of the Blocking Strategy (`SigactionDelayer_Block`)
 
@@ -113,10 +118,22 @@ dedicated thread too!
 When the signal is received, `libdispatch` will notify the delayer, which will
 unblock the signal, thus allowing it to be delivered.
 
-**Caveat of this method**: On macOS, when a signal blocked on all threads is
-received, it seems to be affected to an arbitrary thread. Unblocking the signal
-on another thread will not unblock it at all. To workaround this problem we
-check if the signal is pending on the dedicated thread before unblocking it. If
-it is not, we send the signal to our thread, thus losing the sigaction again,
-exactly like when using the unsigaction strategy. Plus the original signal will
-stay pending on the affected thread forever.
+**Caveats of this method**:
+
+* On macOS, when a signal blocked on all threads is received, it seems to be
+assigned to an arbitrary thread. Unblocking the signal on another thread will
+not unblock it at all. To workaround this problem we check if the signal is
+pending on the dedicated thread before unblocking it. If it is not, we send the
+signal to our thread, thus losing the sigaction again, exactly like when using
+the unsigaction strategy. Plus the original signal will stay pending on the
+affected thread forever.
+* On Linux, there is an issue where contrary to what the man page says,
+`libdispatch` https://github.com/apple/swift-corelibs-libdispatch/pull/560[does
+modify the sigaction of a signal when a dispatch source for this signal is first
+installed].
+So in theory this strategy should not work (and to be honest, the other one
+should not either). However, it has been noticed that changing the sigaction
+_after_ the signal source has been installed is enough to avoid this problem. So
+we save the sigaction before installing the signal source, then restore it after
+the source is installed, and we’re good. This solution seems fragile though, and
+might break in the future, or not even work reliably right now.

Readme.adoc

@@ -45,13 +45,23 @@ public struct Sigaction : Equatable, RawRepresentable {
 		self.mask = Signal.set(from: rawValue.sa_mask)
 		self.flags = SigactionFlags(rawValue: rawValue.sa_flags)
 
+		#if !os(Linux)
 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 			default:
 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
 		}
+		#else
+		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_handler.sa_handler, to: Int.self)) {
+			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
+			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
+			default:
+				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_handler.sa_sigaction)}
+				else                        {self.handler = .ansiC(rawValue.__sigaction_handler.sa_handler)}
+		}
+		#endif
 
 		if !isValid {
 			SignalHandlingConfig.logger?.warning("Initialized an invalid Sigaction.")
@@ -75,12 +85,21 @@ public struct Sigaction : Equatable, RawRepresentable {
 		ret.sa_mask = Signal.sigset(from: mask)
 		ret.sa_flags = flags.rawValue
 
+		#if !os(Linux)
 		switch handler {
 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
 		}
+		#else
+		switch handler {
+			case .ignoreHandler:  ret.__sigaction_handler.sa_handler = SIG_IGN
+			case .defaultHandler: ret.__sigaction_handler.sa_handler = SIG_DFL
+			case .ansiC(let h):   ret.__sigaction_handler.sa_handler = h
+			case .posix(let h):   ret.__sigaction_handler.sa_sigaction = h
+		}
+		#endif
 
 		return ret
 	}

Sources/SignalHandling/CStructsInSwift/Sigaction.swift

@@ -32,7 +32,7 @@ public struct SigactionFlags : OptionSet {
 	/**
 	If this bit is set, the handler is reset back to `SIG_DFL` at the moment the
 	signal is delivered. */
-	public static let resetHandler = SigactionFlags(rawValue: SA_RESETHAND)
+	public static let resetHandler = SigactionFlags(rawValue: CInt(SA_RESETHAND) /* On Linux, an UInt32 instead of Int32, so we cast… */)
 
 	/** See `sigaction(2)`. */
 	public static let restart = SigactionFlags(rawValue: SA_RESTART)

Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift

@@ -19,7 +19,7 @@ public enum SigactionHandler : Equatable {
 	case defaultHandler
 
 	case ansiC(@convention(c) (_ signalID: Int32) -> Void)
-	case posix(@convention(c) (_ signalID: Int32, _ siginfo: UnsafeMutablePointer<__siginfo>?, _ userThreadContext: UnsafeMutableRawPointer?) -> Void)
+	case posix(@convention(c) (_ signalID: Int32, _ siginfo: UnsafeMutablePointer<siginfo_t>?, _ userThreadContext: UnsafeMutableRawPointer?) -> Void)
 
 	public static func ==(lhs: SigactionHandler, rhs: SigactionHandler) -> Bool {
 		switch (lhs, rhs) {

Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift

@@ -48,6 +48,12 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 	/* https://www.gnu.org/software/libc/manual/html_node/Program-Error-Signals.html */
 
 	public static var programErrorSignals: Set<Signal> {
+		let platformDependant: Set<Signal>
+		#if !os(Linux)
+		platformDependant = Set(arrayLiteral: .emulatorTrap)
+		#else
+		platformDependant = Set()
+		#endif
 		return Set(arrayLiteral:
 			.arithmeticError,
 			.illegalInstruction,
@@ -56,9 +62,8 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 			.abortTrap,
 			.iot,
 			.traceBreakpointTrap,
-			.emulatorTrap,
 			.badSystemCall
-		)
+		).union(platformDependant)
 	}
 
 	/**
@@ -74,7 +79,9 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 	/** Usually the same as `abortTrap`. */
 	public static let iot                    = Signal(rawValue: SIGIOT)
 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
+	#if !os(Linux)
 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
+	#endif
 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
 
 	/* *** Termination Signals *** */
@@ -128,8 +135,10 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 
 	public static let ioPossible        = Signal(rawValue: SIGIO)
 	public static let urgentIOCondition = Signal(rawValue: SIGURG)
+	#if os(Linux)
 	/* System V signal name similar to SIGIO */
-	//	public static let poll              = Signal(rawValue: SIGPOLL)
+	public static let poll              = Signal(rawValue: SIGPOLL)
+	#endif
 
 	/* *** Job Control Signals *** */
 	/* https://www.gnu.org/software/libc/manual/html_node/Job-Control-Signals.html */
@@ -147,7 +156,7 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 
 	public static let childExited       = Signal(rawValue: SIGCHLD)
 	/* Obsolete name for SIGCHLD */
-	//	public static let cildExited        = Signal(rawValue: SIGCLD)
+//	public static let cildExited        = Signal(rawValue: SIGCLD)
 	public static let continued         = Signal(rawValue: SIGCONT)
 	/** Suspends the program. Cannot be handled, ignored or blocked. */
 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
@@ -168,26 +177,48 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 	}
 
 	public static let brokenPipe            = Signal(rawValue: SIGPIPE)
-	//	public static let resourceLost          = Signal(rawValue: SIGLOST)
+//	public static let resourceLost          = Signal(rawValue: SIGLOST)
 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
 	public static let filesizeLimitExceeded = Signal(rawValue: SIGXFSZ)
 
 	/* *** Miscellaneous Signals *** */
 	/* https://www.gnu.org/software/libc/manual/html_node/Miscellaneous-Signals.html */
 
 	public static var miscellaneousSignals: Set<Signal> {
+		let platformDependant: Set<Signal>
+		#if !os(Linux)
+		platformDependant = Set(arrayLiteral: .informationRequest)
+		#else
+		platformDependant = Set()
+		#endif
 		return Set(arrayLiteral:
 			.userDefinedSignal1,
 			.userDefinedSignal2,
-			.windowSizeChanges,
-			.informationRequest
-		)
+			.windowSizeChanges
+		).union(platformDependant)
 	}
 
 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
+	#if !os(Linux)
 	public static let informationRequest = Signal(rawValue: SIGINFO)
+	#endif
+	
+	#if os(Linux)
+	/* *** Other Signals *** */
+	/* Not in GNU doc */
+	
+	public static var otherSignals: Set<Signal> {
+		return Set(arrayLiteral:
+			.stackFault,
+			.powerFailure
+		)
+	}
+	
+	public static let stackFault   = Signal(rawValue: SIGSTKFLT)
+	public static let powerFailure = Signal(rawValue: SIGPWR)
+	#endif
 
 	public static func set(from sigset: sigset_t) -> Set<Signal> {
 		var sigset = sigset
@@ -231,6 +262,7 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 	}
 
 	/** Will return `usr1` or similar for `.userDefinedSignal1` for instance. */
+	#if !os(Linux)
 	public var signalName: String? {
 		guard rawValue >= 0 && rawValue < NSIG else {
 			return nil
@@ -242,6 +274,7 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 			})
 		})
 	}
+	#endif
 
 	/**
 	Return a user readable description of the signal (always in English I think). */
@@ -258,7 +291,11 @@ public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, Custom
 	}
 
 	public var description: String {
+		#if !os(Linux)
 		return "SIG\((signalName ?? "\(rawValue)").uppercased())"
+		#else
+		return "\(signalDescription ?? "\(rawValue)")"
+		#endif
 	}
 
 }