[RemoteMirror][swift-inspect] Decode locks in priority-escalation concurrency runtime.

When possible, decode the DrainLock/ExecutionLock fields of tasks and actors in concurrency runtimes built with priority escalation, and show the corresponding thread info in swift-inspect output.

We weren't properly decoding actor flags previously, so fix that up as well and have Remote Mirror split them out into separate fields so clients don't have to. We were missing the Job Storage field from the definition of DefaultActorImpl in RuntimeInternals.h, fix that so we actually read the right data.

rdar://88598003

Author: mikeash

include/swift/Concurrency/Actor.h

@@ -0,0 +1,71 @@
+//===--- Actor.h - Swift concurrency actor declarations ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Actor-related declarations that are also used by Remote Mirror.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_CONCURRENCY_ACTOR_H
+#define SWIFT_CONCURRENCY_ACTOR_H
+
+#include <stdint.h>
+
+namespace swift {
+namespace concurrency {
+namespace ActorFlagConstants {
+
+enum : uint32_t {
+  // Bits 0-2: Actor state
+  //
+  // Possible state transitions for an actor:
+  //
+  // Idle -> Running
+  // Running -> Idle
+  // Running -> Scheduled
+  // Scheduled -> Running
+  // Idle -> Deallocated
+  // Running -> Zombie_ReadyForDeallocation
+  // Zombie_ReadyForDeallocation -> Deallocated
+  //
+  // It is possible for an actor to be in Running and yet completely released
+  // by clients. However, the actor needs to be kept alive until it is done
+  // executing the task that is running on it and gives it up. It is only
+  // after that that we can safely deallocate it.
+  ActorStateMask = 0x7,
+
+  /// The actor is not currently scheduled.  Completely redundant
+  /// with the job list being empty.
+  Idle = 0x0,
+  /// There actor is scheduled
+  Scheduled = 0x1,
+  /// There is currently a thread running the actor.
+  Running = 0x2,
+  /// The actor is ready for deallocation once it stops running
+  Zombie_ReadyForDeallocation = 0x3,
+
+  // Bit 3
+  DistributedRemote = 0x8,
+  // Bit 4
+  IsPriorityEscalated = 0x10,
+
+  // Bits 8 - 15. We only need 8 bits of the whole size_t to represent Job
+  // Priority
+  PriorityMask = 0xFF00,
+  PriorityAndOverrideMask = PriorityMask | IsPriorityEscalated,
+  PriorityShift = 0x8,
+};
+
+} // namespace ActorFlagConstants
+} // namespace concurrency
+} // namespace swift
+
+#endif // SWIFT_CONCURRENCY_ACTOR_H

include/swift/Reflection/ReflectionContext.h

@@ -27,6 +27,7 @@
 
 #include "swift/ABI/Enum.h"
 #include "swift/ABI/ObjectFile.h"
+#include "swift/Concurrency/Actor.h"
 #include "swift/Remote/MemoryReader.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Reflection/Records.h"
@@ -58,8 +59,11 @@
 //   with escalation   |         present             |       full
 //   with escalation   |       not present           |     DEGRADED
 //
-// Currently, degraded info means that IsRunning is not available (indicated
-// with `HasIsRunning = false`) and async backtraces are not provided.
+// Currently, degraded info has these effects:
+// 1. Task.IsRunning is not available, indicated with Task.HasIsRunning = false.
+// 2. Task async backtraces are not provided.
+// 3. Task and actor thread ports are not available, indicated with
+//    HasThreadPort = false.
 
 #if __has_include(<dispatch/swift_concurrency_private.h>)
 #include <dispatch/swift_concurrency_private.h>
@@ -185,6 +189,9 @@ class ReflectionContext
     bool IsRunning;
     bool IsEnqueued;
 
+    bool HasThreadPort;
+    uint32_t ThreadPort;
+
     uint64_t Id;
     StoredPointer RunJob;
     StoredPointer AllocatorSlabPtr;
@@ -193,8 +200,15 @@ class ReflectionContext
   };
 
   struct ActorInfo {
-    StoredSize Flags;
     StoredPointer FirstJob;
+
+    uint8_t State;
+    bool IsDistributedRemote;
+    bool IsPriorityEscalated;
+    uint8_t MaxPriority;
+
+    bool HasThreadPort;
+    uint32_t ThreadPort;
   };
 
   explicit ReflectionContext(std::shared_ptr<MemoryReader> reader)
@@ -1532,6 +1546,44 @@ class ReflectionContext
         Task->PrivateStorage.Status.Flags[0] & ActiveTaskStatusFlags::IsRunning;
   }
 
+  std::pair<bool, uint32_t> getThreadPort(
+      const AsyncTask<Runtime, ActiveTaskStatusWithEscalation<Runtime>> *Task) {
+#if HAS_DISPATCH_LOCK_IS_LOCKED
+    return {true,
+            dispatch_lock_owner(Task->PrivateStorage.Status.ExecutionLock[0])};
+#else
+    // The target runtime was built with priority escalation but we don't have
+    // the swift_concurrency_private.h header needed to decode the lock.
+    return {false, 0};
+#endif
+  }
+
+  std::pair<bool, uint32_t> getThreadPort(
+      const AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>
+          *Task) {
+    // Tasks without escalation have no thread port to query.
+    return {false, 0};
+  }
+
+  std::pair<bool, uint32_t> getThreadPort(
+      const DefaultActorImpl<Runtime, ActiveActorStatusWithEscalation<Runtime>>
+          *Actor) {
+#if HAS_DISPATCH_LOCK_IS_LOCKED
+    return {true, dispatch_lock_owner(Actor->Status.DrainLock[0])};
+#else
+    // The target runtime was built with priority escalation but we don't have
+    // the swift_concurrency_private.h header needed to decode the lock.
+    return {false, 0};
+#endif
+  }
+
+  std::pair<bool, uint32_t>
+  getThreadPort(const DefaultActorImpl<
+                Runtime, ActiveActorStatusWithoutEscalation<Runtime>> *Actor) {
+    // Actors without escalation have no thread port to query.
+    return {false, 0};
+  }
+
   template <typename AsyncTaskType>
   std::pair<llvm::Optional<std::string>, AsyncTaskInfo>
   asyncTaskInfo(StoredPointer AsyncTaskPtr) {
@@ -1557,6 +1609,8 @@ class ReflectionContext
     Info.IsEnqueued = TaskStatusFlags & ActiveTaskStatusFlags::IsEnqueued;
 
     setIsRunning(Info, AsyncTaskObj.get());
+    std::tie(Info.HasThreadPort, Info.ThreadPort) =
+        getThreadPort(AsyncTaskObj.get());
 
     Info.Id =
         AsyncTaskObj->Id | ((uint64_t)AsyncTaskObj->PrivateStorage.Id << 32);
@@ -1626,15 +1680,26 @@ class ReflectionContext
       return {std::string("failure reading actor"), {}};
 
     ActorInfo Info{};
-    Info.Flags = ActorObj->Status.Flags[0];
 
-    // Status is the low 3 bits of Flags. Status of 0 is Idle. Don't read
-    // FirstJob when idle.
-    auto Status = Info.Flags & 0x7;
-    if (Status != 0) {
+    uint32_t Flags = ActorObj->Status.Flags[0];
+    Info.State = Flags & concurrency::ActorFlagConstants::ActorStateMask;
+    Info.IsDistributedRemote =
+        Flags & concurrency::ActorFlagConstants::DistributedRemote;
+    Info.IsPriorityEscalated =
+        Flags & concurrency::ActorFlagConstants::IsPriorityEscalated;
+    Info.MaxPriority =
+        (Flags & concurrency::ActorFlagConstants::PriorityMask) >>
+        concurrency::ActorFlagConstants::PriorityShift;
+
+    // Don't read FirstJob when idle.
+    if (Info.State != concurrency::ActorFlagConstants::Idle) {
       // This is a JobRef which stores flags in the low bits.
       Info.FirstJob = ActorObj->Status.FirstJob & ~StoredPointer(0x3);
     }
+
+    std::tie(Info.HasThreadPort, Info.ThreadPort) =
+        getThreadPort(ActorObj.get());
+
     return {llvm::None, Info};
   }
 

include/swift/Reflection/RuntimeInternals.h

@@ -174,6 +174,7 @@ struct ActiveActorStatusWithoutEscalation {
 template <typename Runtime, typename ActiveActorStatus>
 struct DefaultActorImpl {
   HeapObject<Runtime> HeapObject;
+  Job<Runtime> JobStorage;
   ActiveActorStatus Status;
 };
 

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -18,6 +18,7 @@
 #ifndef SWIFT_REMOTE_MIRROR_TYPES_H
 #define SWIFT_REMOTE_MIRROR_TYPES_H
 
+#include <stdbool.h>
 #include <stdint.h>
 
 #ifdef __cplusplus
@@ -235,18 +236,21 @@ typedef struct swift_async_task_info {
 
   unsigned Kind;
   unsigned EnqueuePriority;
-  uint8_t IsChildTask;
-  uint8_t IsFuture;
-  uint8_t IsGroupChildTask;
-  uint8_t IsAsyncLetTask;
+  bool IsChildTask;
+  bool IsFuture;
+  bool IsGroupChildTask;
+  bool IsAsyncLetTask;
 
   unsigned MaxPriority;
-  uint8_t IsCancelled;
-  uint8_t IsStatusRecordLocked;
-  uint8_t IsEscalated;
-  uint8_t HasIsRunning; // If false, the IsRunning flag is not valid.
-  uint8_t IsRunning;
-  uint8_t IsEnqueued;
+  bool IsCancelled;
+  bool IsStatusRecordLocked;
+  bool IsEscalated;
+  bool HasIsRunning; // If false, the IsRunning flag is not valid.
+  bool IsRunning;
+  bool IsEnqueued;
+
+  bool HasThreadPort;
+  uint32_t ThreadPort;
 
   uint64_t Id;
   swift_reflection_ptr_t RunJob;
@@ -265,8 +269,15 @@ typedef struct swift_actor_info {
   /// swift_reflection call on the given context.
   const char *Error;
 
-  uint64_t Flags;
+  uint8_t State;
+  bool IsDistributedRemote;
+  bool IsPriorityEscalated;
+  uint8_t MaxPriority;
+
   swift_reflection_ptr_t FirstJob;
+
+  bool HasThreadPort;
+  uint32_t ThreadPort;
 } swift_actor_info_t;
 
 /// An opaque pointer to a context which maintains state and