[swift-inspect] Force forkCorpse if VMUProcInfo advises it.

Various processes, such as launchd, are unsafe to inspect directly. Inspecting them pauses them and the system does not like it when they're paused. Forking a corpse avoids this, as the original process continues running while we inspect the forked corpse.

VMUProcInfo provides a shouldAnalyzeWithCorpse call which tells us whether we're inspecting one of those processes. When we are, then we force the forkCorpse option even when it's not specified.

Add shims to Symbolication+Extensions.swift to allow calls to VMUProcInfo and use it to force forkCorpse when appropriate.

rdar://124720793

Author: mikeash

tools/swift-inspect/Sources/swift-inspect/DarwinRemoteProcess.swift

@@ -125,7 +125,17 @@ internal final class DarwinRemoteProcess: RemoteProcess {
       return nil
     }
 
-    if forkCorpse {
+    // Consult with VMUProcInfo to determine if we should force forkCorpse.
+    let forceForkCorpse: Bool
+    if let procInfoClass = getVMUProcInfoClass() {
+      let procInfo = procInfoClass.init(task: task)
+      forceForkCorpse = procInfo.shouldAnalyzeWithCorpse
+    } else {
+      // Default to not forcing forkCorpse.
+      forceForkCorpse = false
+    }
+
+    if forkCorpse || forceForkCorpse {
       var corpse = task_t()
       let maxRetry = 6
       for retry in 0..<maxRetry {

tools/swift-inspect/Sources/swift-inspect/Symbolication+Extensions.swift

@@ -30,6 +30,13 @@ private func symbol<T>(_ handle: UnsafeMutableRawPointer, _ name: String) -> T {
   return unsafeBitCast(result, to: T.self)
 }
 
+private func objcClass<T>(_ name: String) -> T? {
+  guard let result = objc_getClass(name) as? AnyClass else {
+    return nil
+  }
+  return unsafeBitCast(result, to: T.self)
+}
+
 enum Sym {
   static let pidFromHint: @convention(c) (AnyObject) -> pid_t =
     symbol(symbolicationHandle, "pidFromHint")
@@ -97,6 +104,16 @@ typealias CSSymbolicatorRef = CSTypeRef
 typealias CSSymbolRef = CSTypeRef
 typealias CSSymbolOwnerRef = CSTypeRef
 
+// Declare just enough of VMUProcInfo for our purposes. It does not actually
+// conform to this protocol, but ObjC protocol method dispatch is based entirely
+// around msgSend and the presence of the method on the class, not conformance.
+@objc protocol VMUProcInfo {
+  @objc(initWithTask:)
+  init(task: task_read_t)
+
+  var shouldAnalyzeWithCorpse: Bool { get }
+}
+
 func pidFromHint(_ hint: String) -> pid_t? {
   let result = Sym.pidFromHint(hint as NSString)
   return result == 0 ? nil : result
@@ -231,4 +248,8 @@ func machErrStr(_ kr: kern_return_t) -> String {
   return "\(errStr) (0x\(errHex))"
 }
 
+func getVMUProcInfoClass() -> VMUProcInfo.Type? {
+  return objcClass("VMUProcInfo")
+}
+
 #endif