Revert "[swift-inspect] Fix corpse leaks when target doesn't have libswiftCore loaded."

This reverts commit 9671d6b.

Author: hamishknight

tools/swift-inspect/Sources/swift-inspect/Cleanup.swift

@@ -19,25 +19,13 @@ internal final class DarwinRemoteProcess: RemoteProcess {
   public typealias ProcessIdentifier = pid_t
   public typealias ProcessHandle = task_t
 
-  private var task = Cleanup<task_t> {
-    // task_stop_peeking does nothing if we didn't task_start_peeking first, so
-    // we can call it unconditionally.
-    task_stop_peeking($0)
-    mach_port_deallocate(mach_task_self_, $0)
-  }
-
+  private var task: task_t
   internal var processIdentifier: ProcessIdentifier
   internal lazy var processName = getProcessName(processId: processIdentifier) ?? "<unknown process>"
 
-  public var process: ProcessHandle { task.value }
-  private var _context = Cleanup<SwiftReflectionContextRef> {
-    swift_reflection_destroyReflectionContext($0)
-  }
-  public var context: SwiftReflectionContextRef! { _context.value }
-
-  private var symbolicator = Cleanup<CSSymbolicatorRef> {
-    CSRelease($0)
-  }
+  public var process: ProcessHandle { task }
+  public private(set) var context: SwiftReflectionContextRef!
+  private var symbolicator: CSSymbolicatorRef
 
   private var swiftCore: CSTypeRef
   private let swiftConcurrency: CSTypeRef
@@ -84,7 +72,7 @@ internal final class DarwinRemoteProcess: RemoteProcess {
   }
 
   func read(address: swift_addr_t, size: Int) -> UnsafeRawPointer? {
-    return task_peek(task.value, address, mach_vm_size_t(size))
+    return task_peek(task, address, mach_vm_size_t(size))
   }
 
   func getAddr(symbolName: String) -> swift_addr_t {
@@ -110,7 +98,7 @@ internal final class DarwinRemoteProcess: RemoteProcess {
   static var GetStringLength: GetStringLengthFunction {
     return { (context, address) in
       let process: DarwinRemoteProcess = DarwinRemoteProcess.fromOpaque(context!)
-      if let str = task_peek_string(process.task.value, address) {
+      if let str = task_peek_string(process.task, address) {
         return UInt64(strlen(str))
       }
       return 0
@@ -131,19 +119,18 @@ internal final class DarwinRemoteProcess: RemoteProcess {
 
   init?(processId: ProcessIdentifier, forkCorpse: Bool) {
     processIdentifier = processId
-    var processTask: task_t = task_t()
-    let taskResult = task_for_pid(mach_task_self_, processId, &processTask)
+    var task: task_t = task_t()
+    let taskResult = task_for_pid(mach_task_self_, processId, &task)
     guard taskResult == KERN_SUCCESS else {
       print("unable to get task for pid \(processId): \(String(cString: mach_error_string(taskResult))) \(hex: taskResult)",
         to: &Std.err)
       return nil
     }
-    self.task.value = processTask
 
     // Consult with VMUProcInfo to determine if we should force forkCorpse.
     let forceForkCorpse: Bool
     if let procInfoClass = getVMUProcInfoClass() {
-      let procInfo = procInfoClass.init(task: self.task.value)
+      let procInfo = procInfoClass.init(task: task)
       forceForkCorpse = procInfo.shouldAnalyzeWithCorpse
     } else {
       // Default to not forcing forkCorpse.
@@ -154,9 +141,11 @@ internal final class DarwinRemoteProcess: RemoteProcess {
       var corpse = task_t()
       let maxRetry = 6
       for retry in 0..<maxRetry {
-        let corpseResult = task_generate_corpse(task.value, &corpse)
+        let corpseResult = task_generate_corpse(task, &corpse)
         if corpseResult == KERN_SUCCESS {
-          task.value = corpse
+          task_stop_peeking(task)
+          mach_port_deallocate(mach_task_self_, task)
+          task = corpse
           break
         }
         if corpseResult != KERN_RESOURCE_SHORTAGE || retry == maxRetry {
@@ -168,19 +157,20 @@ internal final class DarwinRemoteProcess: RemoteProcess {
       }
     }
 
-    self.symbolicator.value = CSSymbolicatorCreateWithTask(self.task.value)
-
-    self.swiftCore = CSSymbolicatorGetSymbolOwnerWithNameAtTime(
-        self.symbolicator.value, "libswiftCore.dylib", kCSNow)
-    self.swiftConcurrency = CSSymbolicatorGetSymbolOwnerWithNameAtTime(
-        self.symbolicator.value, "libswift_Concurrency.dylib", kCSNow)
+    self.task = task
 
+    self.symbolicator = CSSymbolicatorCreateWithTask(self.task)
+    self.swiftCore =
+        CSSymbolicatorGetSymbolOwnerWithNameAtTime(self.symbolicator,
+                                                   "libswiftCore.dylib", kCSNow)
     if CSIsNull(self.swiftCore) {
       print("pid \(processId) does not have libswiftCore.dylib loaded")
       return nil
     }
 
-    _ = task_start_peeking(self.task.value)
+    self.swiftConcurrency = CSSymbolicatorGetSymbolOwnerWithNameAtTime(
+      symbolicator, "libswift_Concurrency.dylib", kCSNow)
+    _ = task_start_peeking(self.task)
 
     guard let context =
         swift_reflection_createReflectionContextWithDataLayout(self.toOpaqueRef(),
@@ -191,17 +181,23 @@ internal final class DarwinRemoteProcess: RemoteProcess {
                                                                Self.GetSymbolAddress) else {
       return nil
     }
-    self._context.value = context
+    self.context = context
 
-    _ = CSSymbolicatorForeachSymbolOwnerAtTime(self.symbolicator.value, kCSNow, { owner in
+    _ = CSSymbolicatorForeachSymbolOwnerAtTime(self.symbolicator, kCSNow, { owner in
       let address = CSSymbolOwnerGetBaseAddress(owner)
       _ = swift_reflection_addImage(self.context, address)
     })
   }
 
+  deinit {
+    task_stop_peeking(self.task)
+    CSRelease(self.symbolicator)
+    mach_port_deallocate(mach_task_self_, self.task)
+  }
+
   func symbolicate(_ address: swift_addr_t) -> (module: String?, symbol: String?) {
     let symbol =
-        CSSymbolicatorGetSymbolWithAddressAtTime(self.symbolicator.value, address, kCSNow)
+        CSSymbolicatorGetSymbolWithAddressAtTime(self.symbolicator, address, kCSNow)
 
     let module = CSSymbolGetSymbolOwner(symbol)
     return (CSSymbolOwnerGetName(module), CSSymbolGetName(symbol))
@@ -210,7 +206,7 @@ internal final class DarwinRemoteProcess: RemoteProcess {
   internal func iterateHeap(_ body: (swift_addr_t, UInt64) -> Void) {
     withoutActuallyEscaping(body) {
       withUnsafePointer(to: $0) {
-        task_enumerate_malloc_blocks(self.task.value,
+        task_enumerate_malloc_blocks(self.task,
                                      UnsafeMutableRawPointer(mutating: $0),
                                      CUnsignedInt(MALLOC_PTR_IN_USE_RANGE_TYPE),
                                      { (task, context, type, ranges, count) in
@@ -268,14 +264,14 @@ extension DarwinRemoteProcess {
   }
 
   private func getThreadInfos() -> [ThreadInfo] {
-    guard let threads = PortList(task: self.task.value) else {
+    guard let threads = PortList(task: self.task) else {
       return []
     }
-    return threads.compactMap { t -> ThreadInfo? in
-      guard let info = getThreadInfo(thread: t) else {
+    return threads.compactMap {
+      guard let info = getThreadInfo(thread: $0) else {
         return nil
       }
-      guard let kernelObj = getKernelObject(task: mach_task_self_, port: t) else {
+      guard let kernelObj = getKernelObject(task: mach_task_self_, port: $0) else {
         return nil
       }
       return ThreadInfo(threadID: info.thread_id,
@@ -332,7 +328,7 @@ extension DarwinRemoteProcess {
   }
 
   internal func getThreadID(remotePort: thread_t) -> UInt64? {
-    guard let remoteThreadObj = getKernelObject(task: self.task.value, port: remotePort) else {
+    guard let remoteThreadObj = getKernelObject(task: self.task, port: remotePort) else {
       return nil
     }
     return threadInfos.first{ $0.kernelObject == remoteThreadObj }?.threadID

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

@@ -80,7 +80,7 @@ internal func getAllProcesses(options: UniversalOptions) -> [ProcessIdentifier]?
   }
   let newCount = bufferSize / kinfo_stride
   if count > newCount {
-    buffer.removeLast(count - newCount)
+    buffer.dropLast(count - newCount)
   }
   let sorted = buffer.sorted { first, second in
     first.kp_proc.p_pid > second.kp_proc.p_pid