Merge pull request #41676 from mikeash/swift-inspect-concurrency-flags

[swift-inspect][RemoteMirror] Decode job/task/actor flags.

Author: mikeash

include/swift/Reflection/ReflectionContext.h

@@ -43,6 +43,29 @@
 
 #include <inttypes.h>
 
+// The Swift runtime can be built in two ways: with or without
+// SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION enabled. In order to decode the
+// lock used in a runtime with priority escalation enabled, we need inline
+// functions from dispatch/swift_concurrency_private.h. If we don't have that
+// header at build time, we can still build but we'll be unable to decode the
+// lock and thus information about a running task is degraded. There are four
+// combinations:
+//
+//      Runtime        | swift_concurrency_private.h | task running info
+// --------------------+-----------------------------+------------------
+// without escalation  |         present             |       full
+// without escalation  |       not present           |       full
+//   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.
+
+#if __has_include(<dispatch/swift_concurrency_private.h>)
+#include <dispatch/swift_concurrency_private.h>
+#define HAS_DISPATCH_LOCK_IS_LOCKED 1
+#endif
+
 namespace {
 
 template <unsigned PointerSize> struct MachOTraits;
@@ -145,8 +168,23 @@ class ReflectionContext
   };
 
   struct AsyncTaskInfo {
-    uint32_t JobFlags;
-    uint64_t TaskStatusFlags;
+    // Job flags.
+    unsigned Kind;
+    unsigned EnqueuePriority;
+    bool IsChildTask;
+    bool IsFuture;
+    bool IsGroupChildTask;
+    bool IsAsyncLetTask;
+
+    // Task flags.
+    unsigned MaxPriority;
+    bool IsCancelled;
+    bool IsStatusRecordLocked;
+    bool IsEscalated;
+    bool HasIsRunning; // If false, the IsRunning flag is not valid.
+    bool IsRunning;
+    bool IsEnqueued;
+
     uint64_t Id;
     StoredPointer RunJob;
     StoredPointer AllocatorSlabPtr;
@@ -1435,18 +1473,91 @@ class ReflectionContext
   asyncTaskInfo(StoredPointer AsyncTaskPtr) {
     loadTargetPointers();
 
-    if (supportsPriorityEscalation) {
-      return {std::string("Failure reading async task with escalation support"), {}};
-    }
+    if (supportsPriorityEscalation)
+      return asyncTaskInfo<
+          AsyncTask<Runtime, ActiveTaskStatusWithEscalation<Runtime>>>(
+          AsyncTaskPtr);
+    else
+      return asyncTaskInfo<
+          AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>>(
+          AsyncTaskPtr);
+  }
+
+  std::pair<llvm::Optional<std::string>, ActorInfo>
+  actorInfo(StoredPointer ActorPtr) {
+    if (supportsPriorityEscalation)
+      return actorInfo<
+          DefaultActorImpl<Runtime, ActiveActorStatusWithEscalation<Runtime>>>(
+          ActorPtr);
+    else
+      return actorInfo<DefaultActorImpl<
+          Runtime, ActiveActorStatusWithoutEscalation<Runtime>>>(ActorPtr);
+  }
+
+  StoredPointer nextJob(StoredPointer JobPtr) {
+    using Job = Job<Runtime>;
+
+    auto JobBytes = getReader().readBytes(RemoteAddress(JobPtr), sizeof(Job));
+    auto *JobObj = reinterpret_cast<const Job *>(JobBytes.get());
+    if (!JobObj)
+      return 0;
+
+    // This is a JobRef which stores flags in the low bits.
+    return JobObj->SchedulerPrivate[0] & ~StoredPointer(0x3);
+  }
+
+private:
+  void setIsRunning(
+      AsyncTaskInfo &Info,
+      const AsyncTask<Runtime, ActiveTaskStatusWithEscalation<Runtime>> *Task) {
+#if HAS_DISPATCH_LOCK_IS_LOCKED
+    Info.HasIsRunning = true;
+    Info.IsRunning =
+        dispatch_lock_is_locked(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 running
+    // status in the task. Set HasIsRunning to false to indicate that we can't
+    // tell whether or not the task is running.
+    Info.HasIsRunning = false;
+#endif
+  }
+
+  void setIsRunning(
+      AsyncTaskInfo &Info,
+      const AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>
+          *Task) {
+    Info.HasIsRunning = true;
+    Info.IsRunning =
+        Task->PrivateStorage.Status.Flags[0] & ActiveTaskStatusFlags::IsRunning;
+  }
 
-    using AsyncTask = AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>;
-    auto AsyncTaskObj = readObj<AsyncTask>(AsyncTaskPtr);
+  template <typename AsyncTaskType>
+  std::pair<llvm::Optional<std::string>, AsyncTaskInfo>
+  asyncTaskInfo(StoredPointer AsyncTaskPtr) {
+    auto AsyncTaskObj = readObj<AsyncTaskType>(AsyncTaskPtr);
     if (!AsyncTaskObj)
       return {std::string("failure reading async task"), {}};
 
     AsyncTaskInfo Info{};
-    Info.JobFlags = AsyncTaskObj->Flags;
-    Info.TaskStatusFlags = AsyncTaskObj->PrivateStorage.Status.Flags[0];
+
+    swift::JobFlags JobFlags(AsyncTaskObj->Flags);
+    Info.Kind = static_cast<unsigned>(JobFlags.getKind());
+    Info.EnqueuePriority = static_cast<unsigned>(JobFlags.getPriority());
+    Info.IsChildTask = JobFlags.task_isChildTask();
+    Info.IsFuture = JobFlags.task_isFuture();
+    Info.IsGroupChildTask = JobFlags.task_isGroupChildTask();
+    Info.IsAsyncLetTask = JobFlags.task_isAsyncLetTask();
+
+    uint32_t TaskStatusFlags = AsyncTaskObj->PrivateStorage.Status.Flags[0];
+    Info.IsCancelled = TaskStatusFlags & ActiveTaskStatusFlags::IsCancelled;
+    Info.IsStatusRecordLocked =
+        TaskStatusFlags & ActiveTaskStatusFlags::IsStatusRecordLocked;
+    Info.IsEscalated = TaskStatusFlags & ActiveTaskStatusFlags::IsEscalated;
+    Info.IsEnqueued = TaskStatusFlags & ActiveTaskStatusFlags::IsEnqueued;
+
+    setIsRunning(Info, AsyncTaskObj.get());
+
     Info.Id =
         AsyncTaskObj->Id | ((uint64_t)AsyncTaskObj->PrivateStorage.Id << 32);
     Info.AllocatorSlabPtr = AsyncTaskObj->PrivateStorage.Allocator.FirstSlab;
@@ -1479,8 +1590,7 @@ class ReflectionContext
       while (ChildTask) {
         Info.ChildTasks.push_back(ChildTask);
 
-        StoredPointer ChildFragmentAddr =
-            ChildTask + sizeof(AsyncTask);
+        StoredPointer ChildFragmentAddr = ChildTask + sizeof(*AsyncTaskObj);
         auto ChildFragmentObj =
             readObj<ChildFragment<Runtime>>(ChildFragmentAddr);
         if (ChildFragmentObj)
@@ -1492,13 +1602,8 @@ class ReflectionContext
       RecordPtr = RecordObj->Parent;
     }
 
-    // Walk the async backtrace if the task isn't running or cancelled.
-    // TODO: Use isEnqueued from https://github.com/apple/swift/pull/41088/ once
-    // that's available.
-    int IsCancelledFlag = 0x100;
-    int IsRunningFlag = 0x800;
-    if (!(AsyncTaskObj->PrivateStorage.Status.Flags[0] & IsCancelledFlag) &&
-        !(AsyncTaskObj->PrivateStorage.Status.Flags[0] & IsRunningFlag)) {
+    // Walk the async backtrace.
+    if (Info.HasIsRunning && !Info.IsRunning) {
       auto ResumeContext = AsyncTaskObj->ResumeContextAndReserved[0];
       while (ResumeContext) {
         auto ResumeContextObj = readObj<AsyncContext<Runtime>>(ResumeContext);
@@ -1513,15 +1618,10 @@ class ReflectionContext
     return {llvm::None, Info};
   }
 
+  template <typename ActorType>
   std::pair<llvm::Optional<std::string>, ActorInfo>
   actorInfo(StoredPointer ActorPtr) {
-    if (supportsPriorityEscalation) {
-      return {std::string("Failure reading actor with escalation support"), {}};
-    }
-
-    using DefaultActorImpl = DefaultActorImpl<Runtime, ActiveActorStatusWithoutEscalation<Runtime>>;
-
-    auto ActorObj = readObj<DefaultActorImpl>(ActorPtr);
+    auto ActorObj = readObj<ActorType>(ActorPtr);
     if (!ActorObj)
       return {std::string("failure reading actor"), {}};
 
@@ -1538,22 +1638,10 @@ class ReflectionContext
     return {llvm::None, Info};
   }
 
-  StoredPointer nextJob(StoredPointer JobPtr) {
-    using Job = Job<Runtime>;
-
-    auto JobBytes = getReader().readBytes(RemoteAddress(JobPtr), sizeof(Job));
-    auto *JobObj = reinterpret_cast<const Job *>(JobBytes.get());
-    if (!JobObj)
-      return 0;
-
-    // This is a JobRef which stores flags in the low bits.
-    return JobObj->SchedulerPrivate[0] & ~StoredPointer(0x3);
-  }
-
-private:
   // Get the most human meaningful "run job" function pointer from the task,
   // like AsyncTask::getResumeFunctionForLogging does.
-  StoredPointer getRunJob(const AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>> *AsyncTaskObj) {
+  template <typename AsyncTaskType>
+  StoredPointer getRunJob(const AsyncTaskType *AsyncTaskObj) {
     auto Fptr = stripSignedPointer(AsyncTaskObj->RunJob);
 
     loadTargetPointers();
@@ -1612,9 +1700,11 @@ class ReflectionContext
         getFunc("_swift_concurrency_debug_task_wait_throwing_resume_adapter");
     target_task_future_wait_resume_adapter =
         getFunc("_swift_concurrency_debug_task_future_wait_resume_adapter");
-    auto supportsPriorityEscalationAddr = getReader().getSymbolAddress("_swift_concurrency_debug_supportsPriorityEscalation");
+    auto supportsPriorityEscalationAddr = getReader().getSymbolAddress(
+        "_swift_concurrency_debug_supportsPriorityEscalation");
     if (supportsPriorityEscalationAddr) {
-      getReader().readInteger(supportsPriorityEscalationAddr, &supportsPriorityEscalation);
+      getReader().readInteger(supportsPriorityEscalationAddr,
+                              &supportsPriorityEscalation);
     }
 
     setupTargetPointers = true;

include/swift/Reflection/RuntimeInternals.h

@@ -95,7 +95,7 @@ struct StackAllocator {
 
 template <typename Runtime>
 struct ActiveTaskStatusWithEscalation {
-  uint32_t Flags;
+  uint32_t Flags[1];
   uint32_t ExecutionLock[(sizeof(typename Runtime::StoredPointer) == 8) ? 1 : 2];
   typename Runtime::StoredPointer Record;
 };
@@ -106,6 +106,16 @@ struct ActiveTaskStatusWithoutEscalation {
   typename Runtime::StoredPointer Record;
 };
 
+struct ActiveTaskStatusFlags {
+  static const uint32_t PriorityMask = 0xFF;
+  static const uint32_t IsCancelled = 0x100;
+  static const uint32_t IsStatusRecordLocked = 0x200;
+  static const uint32_t IsEscalated = 0x400;
+  static const uint32_t IsRunning = 0x800;
+  static const uint32_t IsEnqueued = 0x1000;
+  static const uint32_t IsComplete = 0x2000;
+};
+
 template <typename Runtime, typename ActiveTaskStatus>
 struct AsyncTaskPrivateStorage {
   typename Runtime::StoredPointer ExclusivityAccessSet[2];
@@ -150,7 +160,7 @@ struct FutureAsyncContextPrefix {
 
 template <typename Runtime>
 struct ActiveActorStatusWithEscalation {
-  uint32_t Flags;
+  uint32_t Flags[1];
   uint32_t DrainLock[(sizeof(typename Runtime::StoredPointer) == 8) ? 1 : 2];
   typename Runtime::StoredPointer FirstJob;
 };

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -233,8 +233,21 @@ typedef struct swift_async_task_info {
   /// swift_reflection call on the given context.
   const char *Error;
 
-  uint32_t JobFlags;
-  uint64_t TaskStatusFlags;
+  unsigned Kind;
+  unsigned EnqueuePriority;
+  uint8_t IsChildTask;
+  uint8_t IsFuture;
+  uint8_t IsGroupChildTask;
+  uint8_t 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;
+
   uint64_t Id;
   swift_reflection_ptr_t RunJob;
   swift_reflection_ptr_t AllocatorSlabPtr;

stdlib/public/Concurrency/TaskPrivate.h

@@ -295,6 +295,10 @@ class alignas(2 * sizeof(void*)) ActiveTaskStatus {
 #endif
   };
 
+  // Note: this structure is mirrored by ActiveTaskStatusWithEscalation and
+  // ActiveTaskStatusWithoutEscalation in
+  // include/swift/Reflection/RuntimeInternals.h. Any changes to the layout here
+  // must also be made there.
 #if SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION && SWIFT_POINTER_IS_4_BYTES
   uint32_t Flags;
   dispatch_lock_t ExecutionLock;

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -875,9 +875,23 @@ swift_reflection_asyncTaskInfo(SwiftReflectionContextRef ContextRef,
     Result.Error = returnableCString(ContextRef, Error);
     return Result;
   }
-  Result.JobFlags = TaskInfo.JobFlags;
-  Result.TaskStatusFlags = TaskInfo.TaskStatusFlags;
+
+  Result.Kind = TaskInfo.Kind;
+  Result.EnqueuePriority = TaskInfo.EnqueuePriority;
+  Result.IsChildTask = TaskInfo.IsChildTask;
+  Result.IsFuture = TaskInfo.IsFuture;
+  Result.IsGroupChildTask = TaskInfo.IsGroupChildTask;
+  Result.IsAsyncLetTask = TaskInfo.IsAsyncLetTask;
+
+  Result.MaxPriority = TaskInfo.MaxPriority;
+  Result.IsCancelled = TaskInfo.IsCancelled;
+  Result.IsStatusRecordLocked = TaskInfo.IsStatusRecordLocked;
+  Result.IsEscalated = TaskInfo.IsEscalated;
+  Result.HasIsRunning = TaskInfo.HasIsRunning;
+  Result.IsRunning = TaskInfo.IsRunning;
+  Result.IsEnqueued = TaskInfo.IsEnqueued;
   Result.Id = TaskInfo.Id;
+
   Result.RunJob = TaskInfo.RunJob;
   Result.AllocatorSlabPtr = TaskInfo.AllocatorSlabPtr;