Add placeholder for getting thread data

dotnet · lambdageek · Jul 8, 2024 · May 16, 2024 · May 17, 2024 · May 23, 2024
commit 890f9c6a6c3a73886dfe6c3e283d969cec92d422
diff --git a/docs/design/datacontracts/Thread.md b/docs/design/datacontracts/Thread.md
@@ -159,7 +159,7 @@ ThreadData GetThreadData(TargetPointer threadPointer)
         AllocContextLimit : thread.m_alloc_context.alloc_limit,
         Frame : thread.m_pFrame,
         TEB : thread.Has_m_pTEB ? thread.m_pTEB : TargetPointer.Null,
-        LastThreadObjectHandle : new DacGCHandle(thread.m_LastThrownObjectHandle),
+        LastThrownObjectHandle : new DacGCHandle(thread.m_LastThrownObjectHandle),
         FirstNestedException : firstNestedException,
         NextThread : ThreadListReader.GetHead.GetNext(threadPointer)
     );

diff --git a/src/coreclr/debug/daccess/dacimpl.h b/src/coreclr/debug/daccess/dacimpl.h
@@ -1229,6 +1229,7 @@ class ClrDataAccess
 
     HRESULT Initialize(void);
 
+    HRESULT GetThreadDataImpl(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *threadData);
     HRESULT GetThreadStoreDataImpl(struct DacpThreadStoreData *data);
 
     BOOL IsExceptionFromManagedCode(EXCEPTION_RECORD * pExceptionRecord);

diff --git a/src/coreclr/debug/daccess/request.cpp b/src/coreclr/debug/daccess/request.cpp
@@ -761,11 +761,52 @@ ClrDataAccess::GetHeapAllocData(unsigned int count, struct DacpGenerationAllocDa
     return hr;
 }
 
-HRESULT
-ClrDataAccess::GetThreadData(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *threadData)
+HRESULT ClrDataAccess::GetThreadData(CLRDATA_ADDRESS threadAddr, struct DacpThreadData* threadData)
 {
     SOSDacEnter();
 
+    if (m_cdacSos != NULL)
+    {
+        hr = m_cdacSos->GetThreadData(threadAddr, threadData);
+        if (FAILED(hr))
+        {
+            hr = GetThreadDataImpl(threadAddr, threadData);
+        }
+#ifdef _DEBUG
+        else
+        {
+            DacpThreadData threadDataLocal;
+            HRESULT hrLocal = GetThreadDataImpl(threadAddr, &threadDataLocal);
+            _ASSERTE(hr == hrLocal);
+            _ASSERTE(threadData->corThreadId == threadDataLocal.corThreadId);
+            _ASSERTE(threadData->osThreadId == threadDataLocal.osThreadId);
+            _ASSERTE(threadData->state == threadDataLocal.state);
+            _ASSERTE(threadData->preemptiveGCDisabled == threadDataLocal.preemptiveGCDisabled);
+            _ASSERTE(threadData->allocContextPtr == threadDataLocal.allocContextPtr);
+            _ASSERTE(threadData->allocContextLimit == threadDataLocal.allocContextLimit);
+            _ASSERTE(threadData->context == threadDataLocal.context);
+            _ASSERTE(threadData->domain == threadDataLocal.domain);
+            _ASSERTE(threadData->pFrame == threadDataLocal.pFrame);
+            _ASSERTE(threadData->lockCount == threadDataLocal.lockCount);
+            _ASSERTE(threadData->firstNestedException == threadDataLocal.firstNestedException);
+            _ASSERTE(threadData->teb == threadDataLocal.teb);
+            _ASSERTE(threadData->fiberData == threadDataLocal.fiberData);
+            _ASSERTE(threadData->lastThrownObjectHandle == threadDataLocal.lastThrownObjectHandle);
+            _ASSERTE(threadData->nextThread == threadDataLocal.nextThread);;
+        }
+#endif
+    }
+    else
+    {
+        hr = GetThreadDataImpl(threadAddr, threadData);
+    }
+
+    SOSDacLeave();
+    return hr;
+}
+
+HRESULT ClrDataAccess::GetThreadDataImpl(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *threadData)
+{
     // marshal the Thread object from the target
     Thread* thread = PTR_Thread(TO_TADDR(threadAddr));
 
@@ -804,8 +845,7 @@ ClrDataAccess::GetThreadData(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *
         thread->m_ExceptionState.m_currentExInfo.m_pPrevNestedInfo);
 #endif // FEATURE_EH_FUNCLETS
 
-    SOSDacLeave();
-    return hr;
+    return S_OK;
 }
 
 #ifdef FEATURE_REJIT

diff --git a/src/coreclr/debug/runtimeinfo/datadescriptor.h b/src/coreclr/debug/runtimeinfo/datadescriptor.h
@@ -105,7 +105,10 @@ CDAC_TYPES_BEGIN()
 
 CDAC_TYPE_BEGIN(Thread)
 CDAC_TYPE_INDETERMINATE(Thread)
+CDAC_TYPE_FIELD(Thread, /*uint32*/, Id, cdac_offsets<Thread>::Id)
+CDAC_TYPE_FIELD(Thread, /*nuint*/, OSId, cdac_offsets<Thread>::OSId)
 CDAC_TYPE_FIELD(Thread, GCHandle, GCHandle, cdac_offsets<Thread>::ExposedObject)
+CDAC_TYPE_FIELD(Thread, GCHandle, LastThrownObject, cdac_offsets<Thread>::LastThrownObject)
 CDAC_TYPE_FIELD(Thread, pointer, LinkNext, cdac_offsets<Thread>::Link)
 CDAC_TYPE_END(Thread)
 

diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h
@@ -4044,7 +4044,10 @@ class Thread
 template<>
 struct cdac_offsets<Thread>
 {
+    static constexpr size_t Id = offsetof(Thread, m_ThreadId);
+    static constexpr size_t OSId = offsetof(Thread, m_OSThreadId);
     static constexpr size_t ExposedObject = offsetof(Thread, m_ExposedObject);
+    static constexpr size_t LastThrownObject = offsetof(Thread, m_LastThrownObjectHandle);
     static constexpr size_t Link = offsetof(Thread, m_Link);
 };
 

diff --git a/src/native/managed/cdacreader/src/Contracts/Thread.cs b/src/native/managed/cdacreader/src/Contracts/Thread.cs
@@ -17,6 +17,10 @@ internal record struct ThreadStoreCounts(
     int PendingThreadCount,
     int DeadThreadCount);
 
+internal record struct ThreadData(
+    uint Id,
+    TargetPointer NextThread);
+
 internal interface IThread : IContract
 {
     static string IContract.Name { get; } = nameof(Thread);
@@ -33,6 +37,7 @@ static IContract IContract.Create(Target target, int version)
 
     public virtual ThreadStoreData GetThreadStoreData() => throw new NotImplementedException();
     public virtual ThreadStoreCounts GetThreadCounts() => throw new NotImplementedException();
+    public virtual ThreadData GetThreadData(TargetPointer thread) => throw new NotImplementedException();
 }
 
 internal readonly struct Thread : IThread
@@ -51,8 +56,10 @@ internal Thread_1(Target target, TargetPointer threadStore)
         _target = target;
         _threadStoreAddr = threadStore;
 
+        // Get the offset into Thread of the SLink. We use this to find the actual
+        // first thread from the linked list node contained by the first thread.
         Target.TypeInfo type = _target.GetTypeInfo(DataType.Thread);
-        _threadLinkOffset = (ulong)type.Fields["LinkNext"].Offset;
+        _threadLinkOffset = (ulong)type.Fields[nameof(Data.Thread.LinkNext)].Offset;
     }
 
     ThreadStoreData IThread.GetThreadStoreData()
@@ -68,7 +75,7 @@ ThreadStoreData IThread.GetThreadStoreData()
 
         return new ThreadStoreData(
             threadStore.ThreadCount,
-            new TargetPointer(threadStore.FirstThreadLink - _threadLinkOffset),
+            GetThreadFromLink(threadStore.FirstThreadLink),
             _target.ReadGlobalPointer(Constants.Globals.FinalizerThread),
             _target.ReadGlobalPointer(Constants.Globals.GCThread));
     }
@@ -90,4 +97,29 @@ ThreadStoreCounts IThread.GetThreadCounts()
             threadStore.PendingCount,
             threadStore.DeadCount);
     }
+
+    ThreadData IThread.GetThreadData(TargetPointer threadPointer)
+    {
+        Data.Thread? thread;
+        if (!_target.ProcessedData.TryGet(threadPointer, out thread))
+        {
+            thread = new Data.Thread(_target, threadPointer);
+
+            // Still okay if processed data is already registered by someone else.
+            _ = _target.ProcessedData.TryRegister(threadPointer, thread);
+        }
+
+        return new ThreadData(
+            thread.Id,
+            GetThreadFromLink(thread.LinkNext));
+    }
+
+    private TargetPointer GetThreadFromLink(TargetPointer threadLink)
+    {
+        if (threadLink == TargetPointer.Null)
+            return TargetPointer.Null;
+
+        // Get the address of the thread containing the link
+        return new TargetPointer(threadLink - _threadLinkOffset);
+    }
 }
diff --git a/src/native/managed/cdacreader/src/Data/Thread.cs b/src/native/managed/cdacreader/src/Data/Thread.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+internal sealed class Thread
+{
+    public Thread(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.Thread);
+
+        Id = target.Read<uint>(address + (ulong)type.Fields[nameof(Id)].Offset);
+        LinkNext = target.ReadPointer(address + (ulong)type.Fields[nameof(LinkNext)].Offset);
+    }
+
+    public uint Id { get; init; }
+    internal TargetPointer LinkNext { get; init; }
+}
diff --git a/src/native/managed/cdacreader/src/Legacy/SOSDacImpl.cs b/src/native/managed/cdacreader/src/Legacy/SOSDacImpl.cs
@@ -107,7 +107,24 @@ public int GetBreakingChangeVersion()
     public unsafe int GetSyncBlockCleanupData(ulong addr, void* data) => HResults.E_NOTIMPL;
     public unsafe int GetSyncBlockData(uint number, void* data) => HResults.E_NOTIMPL;
     public unsafe int GetThreadAllocData(ulong thread, void* data) => HResults.E_NOTIMPL;
-    public unsafe int GetThreadData(ulong thread, DacpThreadData* data) => HResults.E_NOTIMPL;
+
+    public unsafe int GetThreadData(ulong thread, DacpThreadData* data)
+    {
+        try
+        {
+            Contracts.IThread contract = _target.Contracts.Thread;
+            Contracts.ThreadData threadData = contract.GetThreadData(thread);
+            data->corThreadId = (int)threadData.Id;
+            data->nextThread = threadData.NextThread;
+        }
+        catch (Exception ex)
+        {
+            return ex.HResult;
+        }
+
+        // TODO: [cdac] Implement/populate rest of thread data fields
+        return HResults.E_NOTIMPL;
+    }
     public unsafe int GetThreadFromThinlockID(uint thinLockId, ulong* pThread) => HResults.E_NOTIMPL;
     public unsafe int GetThreadLocalModuleData(ulong thread, uint index, void* data) => HResults.E_NOTIMPL;
     public unsafe int GetThreadpoolData(void* data) => HResults.E_NOTIMPL;