// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

//*****************************************************************************

// File: request.cpp

//

//

// CorDataAccess::Request implementation.

//

//*****************************************************************************

#include "stdafx.h"

#include <win32threadpool.h>

#include "typestring.h"

#include <gccover.h>

#include <virtualcallstub.h>

#ifdef FEATURE_COMINTEROP

#include <comcallablewrapper.h>

#endif // FEATURE_COMINTEROP

#ifndef FEATURE_PAL

// It is unfortunate having to include this header just to get the definition of GenericModeBlock

#include <msodw.h>

#endif // FEATURE_PAL

// To include definiton of IsThrowableThreadAbortException

#include <exstatecommon.h>

#include "rejit.h"

#include "request_common.h"

// GC headers define these to EE-specific stuff that we don't want.

#undef EnterCriticalSection

#undef LeaveCriticalSection

#define PTR_CDADDR(ptr) TO_CDADDR(PTR_TO_TADDR(ptr))

#define HOST_CDADDR(host) TO_CDADDR(PTR_HOST_TO_TADDR(host))

#define SOSDacEnter() \

DAC_ENTER(); \

HRESULT hr = S_OK; \

EX_TRY \

{

#define SOSDacLeave() \

} \

EX_CATCH \

{ \

if (!DacExceptionFilter(GET_EXCEPTION(), this, &hr)) \

{ \

EX_RETHROW; \

} \

} \

EX_END_CATCH(SwallowAllExceptions) \

DAC_LEAVE();

// Use this when you don't want to instantiate an Object * in the host.

TADDR DACGetMethodTableFromObjectPointer(TADDR objAddr, ICorDebugDataTarget * target)

{

ULONG32 returned = 0;

TADDR Value = NULL;

HRESULT hr = target->ReadVirtual(objAddr, (PBYTE)&Value, sizeof(TADDR), &returned);

if ((hr != S_OK) || (returned != sizeof(TADDR)))

{

return NULL;

}

Value = Value & ~3; // equivalent to Object::GetGCSafeMethodTable()

return Value;

}

// Use this when you don't want to instantiate an Object * in the host.

PTR_SyncBlock DACGetSyncBlockFromObjectPointer(TADDR objAddr, ICorDebugDataTarget * target)

{

ULONG32 returned = 0;

DWORD Value = NULL;

HRESULT hr = target->ReadVirtual(objAddr - sizeof(DWORD), (PBYTE)&Value, sizeof(DWORD), &returned);

if ((hr != S_OK) || (returned != sizeof(DWORD)))

{

return NULL;

}

if ((Value & (BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX | BIT_SBLK_IS_HASHCODE)) != BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX)

return NULL;

Value &= MASK_SYNCBLOCKINDEX;

PTR_SyncTableEntry ste = PTR_SyncTableEntry(dac_cast<TADDR>(g_pSyncTable) + (sizeof(SyncTableEntry) * Value));

return ste->m_SyncBlock;

}

BOOL DacValidateEEClass(EEClass *pEEClass)

{

// Verify things are right.

// The EEClass method table pointer should match the method table.

// TODO: Microsoft, need another test for validity, this one isn't always true anymore.

BOOL retval = TRUE;

EX_TRY

{

MethodTable *pMethodTable = pEEClass->GetMethodTable();

if (!pMethodTable)

{

// PREfix.

retval = FALSE;

}

else if (pEEClass != pMethodTable->GetClass())

{

retval = FALSE;

}

}

EX_CATCH

{

retval = FALSE; // Something is wrong

}

EX_END_CATCH(SwallowAllExceptions)

return retval;

}

BOOL DacValidateMethodTable(MethodTable *pMT, BOOL &bIsFree)

{

// Verify things are right.

BOOL retval = FALSE;

EX_TRY

{

bIsFree = FALSE;

EEClass *pEEClass = pMT->GetClass();

if (pEEClass==NULL)

{

// Okay to have a NULL EEClass if this is a free methodtable

CLRDATA_ADDRESS MethTableAddr = HOST_CDADDR(pMT);

CLRDATA_ADDRESS FreeObjMethTableAddr = HOST_CDADDR(g_pFreeObjectMethodTable);

if (MethTableAddr != FreeObjMethTableAddr)

goto BadMethodTable;

bIsFree = TRUE;

}

else

{

// Standard fast check

if (!pMT->ValidateWithPossibleAV())

goto BadMethodTable;

// In rare cases, we've seen the standard check above pass when it shouldn't.

// Insert additional/ad-hoc tests below.

// Metadata token should look valid for a class

mdTypeDef td = pMT->GetCl();

if (td != mdTokenNil && TypeFromToken(td) != mdtTypeDef)

goto BadMethodTable;

// BaseSize should always be greater than 0 for valid objects (unless it's an interface)

// For strings, baseSize is not ptr-aligned

if (!pMT->IsInterface() && !pMT->IsString())

{

if (pMT->GetBaseSize() == 0 || !IS_ALIGNED(pMT->GetBaseSize(), sizeof(void *)))

goto BadMethodTable;

}

}

retval = TRUE;

BadMethodTable: ;

}

EX_CATCH

{

retval = FALSE; // Something is wrong

}

EX_END_CATCH(SwallowAllExceptions)

return retval;

}

BOOL DacValidateMD(MethodDesc * pMD)

{

if (pMD == NULL)

{

return FALSE;

}

// Verify things are right.

BOOL retval = TRUE;

EX_TRY

{

MethodTable *pMethodTable = pMD->GetMethodTable();

// Standard fast check

if (!pMethodTable->ValidateWithPossibleAV())

{

retval = FALSE;

}

if (retval && (pMD->GetSlot() >= pMethodTable->GetNumVtableSlots() && !pMD->HasNonVtableSlot()))

{

retval = FALSE;

}

if (retval && pMD->HasTemporaryEntryPoint())

{

MethodDesc *pMDCheck = MethodDesc::GetMethodDescFromStubAddr(pMD->GetTemporaryEntryPoint(), TRUE);

if (PTR_HOST_TO_TADDR(pMD) != PTR_HOST_TO_TADDR(pMDCheck))

{

retval = FALSE;

}

}

if (retval && pMD->HasNativeCode())

{

PCODE jitCodeAddr = pMD->GetNativeCode();

MethodDesc *pMDCheck = ExecutionManager::GetCodeMethodDesc(jitCodeAddr);

if (pMDCheck)

{

// Check that the given MethodDesc matches the MethodDesc from

// the CodeHeader

if (PTR_HOST_TO_TADDR(pMD) != PTR_HOST_TO_TADDR(pMDCheck))

{

retval = FALSE;

}

}

else

{

retval = FALSE;

}

}

}

EX_CATCH

{

retval = FALSE; // Something is wrong

}

EX_END_CATCH(SwallowAllExceptions)

return retval;

}

BOOL DacValidateMD(LPCVOID pMD)

{

return DacValidateMD((MethodDesc *)pMD);

}

VOID GetJITMethodInfo (EECodeInfo * pCodeInfo, JITTypes *pJITType, CLRDATA_ADDRESS *pGCInfo)

{

DWORD dwType = pCodeInfo->GetJitManager()->GetCodeType();

if (IsMiIL(dwType))

{

*pJITType = TYPE_JIT;

}

else if (IsMiNative(dwType))

{

*pJITType = TYPE_PJIT;

}

else

{

*pJITType = TYPE_UNKNOWN;

}

*pGCInfo = (CLRDATA_ADDRESS)PTR_TO_TADDR(pCodeInfo->GetGCInfo());

}

HRESULT

ClrDataAccess::GetWorkRequestData(CLRDATA_ADDRESS addr, struct DacpWorkRequestData *workRequestData)

{

if (addr == 0 || workRequestData == NULL)

return E_INVALIDARG;

SOSDacEnter();

WorkRequest *pRequest = PTR_WorkRequest(TO_TADDR(addr));

workRequestData->Function = (TADDR)(pRequest->Function);

workRequestData->Context = (TADDR)(pRequest->Context);

workRequestData->NextWorkRequest = (TADDR)(pRequest->next);

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetHillClimbingLogEntry(CLRDATA_ADDRESS addr, struct DacpHillClimbingLogEntry *entry)

{

if (addr == 0 || entry == NULL)

return E_INVALIDARG;

SOSDacEnter();

HillClimbingLogEntry *pLogEntry = PTR_HillClimbingLogEntry(TO_TADDR(addr));

entry->TickCount = pLogEntry->TickCount;

entry->NewControlSetting = pLogEntry->NewControlSetting;

entry->LastHistoryCount = pLogEntry->LastHistoryCount;

entry->LastHistoryMean = pLogEntry->LastHistoryMean;

entry->Transition = pLogEntry->Transition;

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetThreadpoolData(struct DacpThreadpoolData *threadpoolData)

{

if (threadpoolData == NULL)

return E_INVALIDARG;

SOSDacEnter();

threadpoolData->cpuUtilization = ThreadpoolMgr::cpuUtilization;

threadpoolData->MinLimitTotalWorkerThreads = ThreadpoolMgr::MinLimitTotalWorkerThreads;

threadpoolData->MaxLimitTotalWorkerThreads = ThreadpoolMgr::MaxLimitTotalWorkerThreads;

//

// Read ThreadpoolMgr::WorkerCounter

//

TADDR pCounter = DacGetTargetAddrForHostAddr(&ThreadpoolMgr::WorkerCounter,true);

ThreadpoolMgr::ThreadCounter counter;

DacReadAll(pCounter,&counter,sizeof(ThreadpoolMgr::ThreadCounter),true);

ThreadpoolMgr::ThreadCounter::Counts counts = counter.counts;

threadpoolData->NumWorkingWorkerThreads = counts.NumWorking;

threadpoolData->NumIdleWorkerThreads = counts.NumActive - counts.NumWorking;

threadpoolData->NumRetiredWorkerThreads = counts.NumRetired;

threadpoolData->FirstUnmanagedWorkRequest = HOST_CDADDR(ThreadpoolMgr::WorkRequestHead);

threadpoolData->HillClimbingLog = dac_cast<TADDR>(&HillClimbingLog);

threadpoolData->HillClimbingLogFirstIndex = HillClimbingLogFirstIndex;

threadpoolData->HillClimbingLogSize = HillClimbingLogSize;

//

// Read ThreadpoolMgr::CPThreadCounter

//

pCounter = DacGetTargetAddrForHostAddr(&ThreadpoolMgr::CPThreadCounter,true);

DacReadAll(pCounter,&counter,sizeof(ThreadpoolMgr::ThreadCounter),true);

counts = counter.counts;

threadpoolData->NumCPThreads = (LONG)(counts.NumActive + counts.NumRetired);

threadpoolData->NumFreeCPThreads = (LONG)(counts.NumActive - counts.NumWorking);

threadpoolData->MaxFreeCPThreads = ThreadpoolMgr::MaxFreeCPThreads;

threadpoolData->NumRetiredCPThreads = (LONG)(counts.NumRetired);

threadpoolData->MaxLimitTotalCPThreads = ThreadpoolMgr::MaxLimitTotalCPThreads;

threadpoolData->CurrentLimitTotalCPThreads = (LONG)(counts.NumActive); //legacy: currently has no meaning

threadpoolData->MinLimitTotalCPThreads = ThreadpoolMgr::MinLimitTotalCPThreads;

TADDR pEntry = DacGetTargetAddrForHostAddr(&ThreadpoolMgr::TimerQueue,true);

ThreadpoolMgr::LIST_ENTRY entry;

DacReadAll(pEntry,&entry,sizeof(ThreadpoolMgr::LIST_ENTRY),true);

TADDR node = (TADDR) entry.Flink;

threadpoolData->NumTimers = 0;

while (node && node != pEntry)

{

threadpoolData->NumTimers++;

DacReadAll(node,&entry,sizeof(ThreadpoolMgr::LIST_ENTRY),true);

node = (TADDR) entry.Flink;

}

threadpoolData->AsyncTimerCallbackCompletionFPtr = (CLRDATA_ADDRESS) GFN_TADDR(ThreadpoolMgr__AsyncTimerCallbackCompletion);

SOSDacLeave();

return hr;

}

HRESULT ClrDataAccess::GetThreadStoreData(struct DacpThreadStoreData *threadStoreData)

{

SOSDacEnter();

ThreadStore* threadStore = ThreadStore::s_pThreadStore;

if (!threadStore)

{

hr = E_UNEXPECTED;

}

else

{

// initialize the fields of our local structure

threadStoreData->threadCount = threadStore->m_ThreadCount;

threadStoreData->unstartedThreadCount = threadStore->m_UnstartedThreadCount;

threadStoreData->backgroundThreadCount = threadStore->m_BackgroundThreadCount;

threadStoreData->pendingThreadCount = threadStore->m_PendingThreadCount;

threadStoreData->deadThreadCount = threadStore->m_DeadThreadCount;

threadStoreData->fHostConfig = g_fHostConfig;

// identify the "important" threads

threadStoreData->firstThread = HOST_CDADDR(threadStore->m_ThreadList.GetHead());

threadStoreData->finalizerThread = HOST_CDADDR(g_pFinalizerThread);

threadStoreData->gcThread = HOST_CDADDR(g_pSuspensionThread);

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetStressLogAddress(CLRDATA_ADDRESS *stressLog)

{

if (stressLog == NULL)

return E_INVALIDARG;

#ifdef STRESS_LOG

SOSDacEnter();

if (g_pStressLog.IsValid())

*stressLog = HOST_CDADDR(g_pStressLog);

else

hr = E_FAIL;

SOSDacLeave();

return hr;

#else

return E_NOTIMPL;

#endif // STRESS_LOG

}

HRESULT

ClrDataAccess::GetJitManagerList(unsigned int count, struct DacpJitManagerInfo managers[], unsigned int *pNeeded)

{

SOSDacEnter();

if (managers)

{

if (count >= 1)

{

EEJitManager * managerPtr = ExecutionManager::GetEEJitManager();

DacpJitManagerInfo *currentPtr = &managers[0];

currentPtr->managerAddr = HOST_CDADDR(managerPtr);

currentPtr->codeType = managerPtr->GetCodeType();

EEJitManager *eeJitManager = PTR_EEJitManager(PTR_HOST_TO_TADDR(managerPtr));

currentPtr->ptrHeapList = HOST_CDADDR(eeJitManager->m_pCodeHeap);

}

#ifdef FEATURE_PREJIT

if (count >= 2)

{

NativeImageJitManager * managerPtr = ExecutionManager::GetNativeImageJitManager();

DacpJitManagerInfo *currentPtr = &managers[1];

currentPtr->managerAddr = HOST_CDADDR(managerPtr);

currentPtr->codeType = managerPtr->GetCodeType();

}

#endif

}

else if (pNeeded)

{

*pNeeded = 1;

#ifdef FEATURE_PREJIT

(*pNeeded)++;

#endif

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetMethodTableSlot(CLRDATA_ADDRESS mt, unsigned int slot, CLRDATA_ADDRESS *value)

{

if (mt == 0 || value == NULL)

return E_INVALIDARG;

SOSDacEnter();

MethodTable* mTable = PTR_MethodTable(TO_TADDR(mt));

BOOL bIsFree = FALSE;

if (!DacValidateMethodTable(mTable, bIsFree))

{

hr = E_INVALIDARG;

}

else if (slot < mTable->GetNumVtableSlots())

{

// Now get the slot:

*value = mTable->GetRestoredSlot(slot);

}

else

{

hr = E_INVALIDARG;

MethodTable::IntroducedMethodIterator it(mTable);

for (; it.IsValid() && FAILED(hr); it.Next())

{

MethodDesc * pMD = it.GetMethodDesc();

if (pMD->GetSlot() == slot)

{

*value = pMD->GetMethodEntryPoint();

hr = S_OK;

}

}

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetCodeHeapList(CLRDATA_ADDRESS jitManager, unsigned int count, struct DacpJitCodeHeapInfo codeHeaps[], unsigned int *pNeeded)

{

if (jitManager == NULL)

return E_INVALIDARG;

SOSDacEnter();

EEJitManager *pJitManager = PTR_EEJitManager(TO_TADDR(jitManager));

HeapList *heapList = pJitManager->m_pCodeHeap;

if (codeHeaps)

{

unsigned int i = 0;

while ((heapList != NULL) && (i < count))

{

// What type of CodeHeap pointer do we have?

CodeHeap *codeHeap = heapList->pHeap;

TADDR ourVTablePtr = VPTR_HOST_VTABLE_TO_TADDR(*(LPVOID*)codeHeap);

if (ourVTablePtr == LoaderCodeHeap::VPtrTargetVTable())

{

LoaderCodeHeap *loaderCodeHeap = PTR_LoaderCodeHeap(PTR_HOST_TO_TADDR(codeHeap));

codeHeaps[i].codeHeapType = CODEHEAP_LOADER;

codeHeaps[i].LoaderHeap =

TO_CDADDR(PTR_HOST_MEMBER_TADDR(LoaderCodeHeap, loaderCodeHeap, m_LoaderHeap));

}

else if (ourVTablePtr == HostCodeHeap::VPtrTargetVTable())

{

HostCodeHeap *hostCodeHeap = PTR_HostCodeHeap(PTR_HOST_TO_TADDR(codeHeap));

codeHeaps[i].codeHeapType = CODEHEAP_HOST;

codeHeaps[i].HostData.baseAddr = PTR_CDADDR(hostCodeHeap->m_pBaseAddr);

codeHeaps[i].HostData.currentAddr = PTR_CDADDR(hostCodeHeap->m_pLastAvailableCommittedAddr);

}

else

{

codeHeaps[i].codeHeapType = CODEHEAP_UNKNOWN;

}

heapList = heapList->hpNext;

i++;

}

if (pNeeded)

*pNeeded = i;

}

else if (pNeeded)

{

int i = 0;

while (heapList != NULL)

{

heapList = heapList->hpNext;

i++;

}

*pNeeded = i;

}

else

{

hr = E_INVALIDARG;

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetStackLimits(CLRDATA_ADDRESS threadPtr, CLRDATA_ADDRESS *lower,

CLRDATA_ADDRESS *upper, CLRDATA_ADDRESS *fp)

{

if (threadPtr == 0 || (lower == NULL && upper == NULL && fp == NULL))

return E_INVALIDARG;

SOSDacEnter();

Thread * thread = PTR_Thread(TO_TADDR(threadPtr));

if (lower)

*lower = TO_CDADDR(thread->GetCachedStackBase().GetAddr());

if (upper)

*upper = TO_CDADDR(thread->GetCachedStackLimit().GetAddr());

if (fp)

*fp = PTR_HOST_MEMBER_TADDR(Thread, thread, m_pFrame);

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetRegisterName(int regNum, unsigned int count, __out_z __inout_ecount(count) WCHAR *buffer, unsigned int *pNeeded)

{

if (!buffer && !pNeeded)

return E_POINTER;

#ifdef _TARGET_AMD64_

static const WCHAR *regs[] =

{

W("rax"), W("rcx"), W("rdx"), W("rbx"), W("rsp"), W("rbp"), W("rsi"), W("rdi"),

W("r8"), W("r9"), W("r10"), W("r11"), W("r12"), W("r13"), W("r14"), W("r15"),

};

#elif defined(_TARGET_ARM_)

static const WCHAR *regs[] =

{

W("r0"),

W("r1"),

W("r2"),

W("r3"),

W("r4"),

W("r5"),

W("r6"),

W("r7"),

W("r8"), W("r9"), W("r10"), W("r11"), W("r12"), W("sp"), W("lr")

};

#elif defined(_TARGET_ARM64_)

static const WCHAR *regs[] =

{

W("X0"),

W("X1"),

W("X2"),

W("X3"),

W("X4"),

W("X5"),

W("X6"),

W("X7"),

W("X8"), W("X9"), W("X10"), W("X11"), W("X12"), W("X13"), W("X14"), W("X15"), W("X16"), W("X17"),

W("X18"), W("X19"), W("X20"), W("X21"), W("X22"), W("X23"), W("X24"), W("X25"), W("X26"), W("X27"),

W("X28"), W("Fp"), W("Lr"), W("Sp")

};

#elif defined(_TARGET_X86_)

static const WCHAR *regs[] =

{

W("eax"), W("ecx"), W("edx"), W("ebx"), W("esp"), W("ebp"), W("esi"), W("edi"),

};

#endif

// Caller frame registers are encoded as "-(reg+1)".

bool callerFrame = regNum < 0;

if (callerFrame)

regNum = -regNum-1;

if ((unsigned int)regNum >= _countof(regs))

return E_UNEXPECTED;

const WCHAR caller[] = W("caller.");

unsigned int needed = (callerFrame?(unsigned int)wcslen(caller):0) + (unsigned int)wcslen(regs[regNum]) + 1;

if (pNeeded)

*pNeeded = needed;

if (buffer)

{

_snwprintf_s(buffer, count, _TRUNCATE, W("%s%s"), callerFrame ? caller : W(""), regs[regNum]);

if (count < needed)

return S_FALSE;

}

return S_OK;

}

HRESULT

ClrDataAccess::GetStackReferences(DWORD osThreadID, ISOSStackRefEnum **ppEnum)

{

if (ppEnum == NULL)

return E_POINTER;

SOSDacEnter();

DacStackReferenceWalker *walker = new (nothrow) DacStackReferenceWalker(this, osThreadID);

if (walker == NULL)

{

hr = E_OUTOFMEMORY;

}

else

{

hr = walker->Init();

if (SUCCEEDED(hr))

hr = walker->QueryInterface(__uuidof(ISOSStackRefEnum), (void**)ppEnum);

if (FAILED(hr))

{

delete walker;

*ppEnum = NULL;

}

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetThreadFromThinlockID(UINT thinLockId, CLRDATA_ADDRESS *pThread)

{

if (pThread == NULL)

return E_INVALIDARG;

SOSDacEnter();

Thread *thread = g_pThinLockThreadIdDispenser->IdToThread(thinLockId);

*pThread = PTR_HOST_TO_TADDR(thread);

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetThreadAllocData(CLRDATA_ADDRESS addr, struct DacpAllocData *data)

{

if (data == NULL)

return E_POINTER;

SOSDacEnter();

Thread* thread = PTR_Thread(TO_TADDR(addr));

data->allocBytes = TO_CDADDR(thread->m_alloc_context.alloc_bytes);

data->allocBytesLoh = TO_CDADDR(thread->m_alloc_context.alloc_bytes_loh);

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetHeapAllocData(unsigned int count, struct DacpGenerationAllocData *data, unsigned int *pNeeded)

{

if (data == 0 && pNeeded == NULL)

return E_INVALIDARG;

SOSDacEnter();

#if defined(FEATURE_SVR_GC)

if (GCHeapUtilities::IsServerHeap())

{

hr = GetServerAllocData(count, data, pNeeded);

}

else

#endif //FEATURE_SVR_GC

{

if (pNeeded)

*pNeeded = 1;

if (data && count >= 1)

{

DPTR(dac_generation) table = g_gcDacGlobals->generation_table;

for (unsigned int i=0; i < *g_gcDacGlobals->max_gen + 2; i++)

{

dac_generation entry = *GenerationTableIndex(table, i);

data[0].allocData[i].allocBytes = (CLRDATA_ADDRESS)(ULONG_PTR) entry.allocation_context.alloc_bytes;

data[0].allocData[i].allocBytesLoh = (CLRDATA_ADDRESS)(ULONG_PTR) entry.allocation_context.alloc_bytes_loh;

}

}

}

SOSDacLeave();

return hr;

}

HRESULT

ClrDataAccess::GetThreadData(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *threadData)

{

SOSDacEnter();

// marshal the Thread object from the target

Thread* thread = PTR_Thread(TO_TADDR(threadAddr));

// initialize our local copy from the marshaled target Thread instance

ZeroMemory (threadData, sizeof(DacpThreadData));

threadData->corThreadId = thread->m_ThreadId;

threadData->osThreadId = (DWORD)thread->m_OSThreadId;

threadData->state = thread->m_State;

threadData->preemptiveGCDisabled = thread->m_fPreemptiveGCDisabled;

threadData->allocContextPtr = TO_CDADDR(thread->m_alloc_context.alloc_ptr);

threadData->allocContextLimit = TO_CDADDR(thread->m_alloc_context.alloc_limit);

threadData->fiberData = NULL;

threadData->pFrame = PTR_CDADDR(thread->m_pFrame);

threadData->context = PTR_CDADDR(thread->m_pDomain);

threadData->domain = PTR_CDADDR(thread->m_pDomain);

threadData->lockCount = thread->m_dwLockCount;

#ifndef FEATURE_PAL

threadData->teb = TO_CDADDR(thread->m_pTEB);

#else

threadData->teb = NULL;

#endif

threadData->lastThrownObjectHandle =

TO_CDADDR(thread->m_LastThrownObjectHandle);

threadData->nextThread =

HOST_CDADDR(ThreadStore::s_pThreadStore->m_ThreadList.GetNext(thread));

#ifdef FEATURE_EH_FUNCLETS

if (thread->m_ExceptionState.m_pCurrentTracker)

{

threadData->firstNestedException = PTR_HOST_TO_TADDR(

thread->m_ExceptionState.m_pCurrentTracker->m_pPrevNestedInfo);

}

#else

threadData->firstNestedException = PTR_HOST_TO_TADDR(

thread->m_ExceptionState.m_currentExInfo.m_pPrevNestedInfo);

#endif // FEATURE_EH_FUNCLETS

SOSDacLeave();

return hr;

}

#ifdef FEATURE_REJIT

void CopyNativeCodeVersionToReJitData(NativeCodeVersion nativeCodeVersion, NativeCodeVersion activeCodeVersion, DacpReJitData * pReJitData)

{

pReJitData->rejitID = nativeCodeVersion.GetILCodeVersion().GetVersionId();

pReJitData->NativeCodeAddr = nativeCodeVersion.GetNativeCode();

if (nativeCodeVersion != activeCodeVersion)

{

pReJitData->flags = DacpReJitData::kReverted;

}

else

{

switch (nativeCodeVersion.GetILCodeVersion().GetRejitState())

{

default:

_ASSERTE(!"Unknown SharedRejitInfo state. DAC should be updated to understand this new state.");

pReJitData->flags = DacpReJitData::kUnknown;

break;

case ILCodeVersion::kStateRequested:

pReJitData->flags = DacpReJitData::kRequested;

break;

case ILCodeVersion::kStateActive:

pReJitData->flags = DacpReJitData::kActive;

break;

}

}

}

#endif // FEATURE_REJIT

//---------------------------------------------------------------------------------------

//

// Given a method desc addr, this loads up DacpMethodDescData and multiple DacpReJitDatas

// with data on that method

//

// Arguments:

// * methodDesc - MD to look up

// * ip - IP address of interest (e.g., from an !ip2md call). This is used to ensure

// the rejitted version corresponding to this IP is returned. May be NULL if you

// don't care.

// * methodDescData - [out] DacpMethodDescData to populate

// * cRevertedRejitVersions - Number of entries allocated in rgRevertedRejitData

// array

// * rgRevertedRejitData - [out] Array of DacpReJitDatas to populate with rejitted

// rejit version data

// * pcNeededRevertedRejitData - [out] If cRevertedRejitVersions==0, the total

// number of available rejit versions (including the current version) is

// returned here. Else, the number of reverted rejit data actually fetched is

// returned here.

//

// Return Value:

// HRESULT indicating success or failure.

//

HRESULT ClrDataAccess::GetMethodDescData(

CLRDATA_ADDRESS methodDesc,

CLRDATA_ADDRESS ip,

struct DacpMethodDescData *methodDescData,

ULONG cRevertedRejitVersions,

DacpReJitData * rgRevertedRejitData,

ULONG * pcNeededRevertedRejitData)

{

if (methodDesc == 0)

return E_INVALIDARG;

if ((cRevertedRejitVersions != 0) && (rgRevertedRejitData == NULL))

{

return E_INVALIDARG;

}

if ((rgRevertedRejitData != NULL) && (pcNeededRevertedRejitData == NULL))

{

// If you're asking for reverted rejit data, you'd better ask for the number of

// elements we return

return E_INVALIDARG;

}

SOSDacEnter();

PTR_MethodDesc pMD = PTR_MethodDesc(TO_TADDR(methodDesc));

if (!DacValidateMD(pMD))

{

hr = E_INVALIDARG;

}

else

{

ZeroMemory(methodDescData, sizeof(DacpMethodDescData));

if (rgRevertedRejitData != NULL)

ZeroMemory(rgRevertedRejitData, sizeof(*rgRevertedRejitData) * cRevertedRejitVersions);

if (pcNeededRevertedRejitData != NULL)

*pcNeededRevertedRejitData = 0;

NativeCodeVersion requestedNativeCodeVersion, activeNativeCodeVersion;

if (ip != NULL)

{

requestedNativeCodeVersion = ExecutionManager::GetNativeCodeVersion(CLRDATA_ADDRESS_TO_TADDR(ip));

}

else

{

#ifdef FEATURE_CODE_VERSIONING

activeNativeCodeVersion = pMD->GetCodeVersionManager()->GetActiveILCodeVersion(pMD).GetActiveNativeCodeVersion(pMD);

#else

activeNativeCodeVersion = NativeCodeVersion(pMD);

#endif

requestedNativeCodeVersion = activeNativeCodeVersion;

}

methodDescData->requestedIP = ip;

methodDescData->bIsDynamic = (pMD->IsLCGMethod()) ? TRUE : FALSE;

methodDescData->wSlotNumber = pMD->GetSlot();

if (!requestedNativeCodeVersion.IsNull() && requestedNativeCodeVersion.GetNativeCode() != NULL)

{

methodDescData->bHasNativeCode = TRUE;

methodDescData->NativeCodeAddr = TO_CDADDR(PCODEToPINSTR(requestedNativeCodeVersion.GetNativeCode()));

}

else

{

methodDescData->bHasNativeCode = FALSE;

methodDescData->NativeCodeAddr = (CLRDATA_ADDRESS)-1;

}

methodDescData->AddressOfNativeCodeSlot = pMD->HasNativeCodeSlot() ? TO_CDADDR(pMD->GetAddrOfNativeCodeSlot()) : NULL;

methodDescData->MDToken = pMD->GetMemberDef();

methodDescData->MethodDescPtr = methodDesc;

methodDescData->MethodTablePtr = HOST_CDADDR(pMD->GetMethodTable());

methodDescData->ModulePtr = HOST_CDADDR(pMD->GetModule());

#ifdef FEATURE_REJIT

// If rejit info is appropriate, get the following:

// * ReJitInfo for the current, active version of the method

// * ReJitInfo for the requested IP (for !ip2md and !u)

// * ReJitInfos for all reverted versions of the method (up to

// cRevertedRejitVersions)

//

// Minidumps will not have all this rejit info, and failure to get rejit info

// should not be fatal. So enclose all rejit stuff in a try.

EX_TRY

{

CodeVersionManager *pCodeVersionManager = pMD->GetCodeVersionManager();

// Current ReJitInfo

if (activeNativeCodeVersion.IsNull())

{

ILCodeVersion activeILCodeVersion = pCodeVersionManager->GetActiveILCodeVersion(pMD);

activeNativeCodeVersion = activeILCodeVersion.GetActiveNativeCodeVersion(pMD);

}

CopyNativeCodeVersionToReJitData(

activeNativeCodeVersion,

activeNativeCodeVersion,

&methodDescData->rejitDataCurrent);

// Requested ReJitInfo

_ASSERTE(methodDescData->rejitDataRequested.rejitID == 0);

if (ip != NULL && !requestedNativeCodeVersion.IsNull())

{

CopyNativeCodeVersionToReJitData(

requestedNativeCodeVersion,

activeNativeCodeVersion,

&methodDescData->rejitDataRequested);

}

// Total number of jitted rejit versions

ULONG cJittedRejitVersions;

if (SUCCEEDED(ReJitManager::GetReJITIDs(pMD, 0 /* cReJitIds */, &cJittedRejitVersions, NULL /* reJitIds */)))

{

methodDescData->cJittedRejitVersions = cJittedRejitVersions;

}

// Reverted ReJitInfos

if (rgRevertedRejitData == NULL)

{

// No reverted rejit versions will be returned, but maybe caller wants a

// count of all versions

if (pcNeededRevertedRejitData != NULL)

{

*pcNeededRevertedRejitData = methodDescData->cJittedRejitVersions;

}

}

else

{

// Caller wants some reverted rejit versions. Gather reverted rejit version data to return

ULONG cReJitIds;

StackSArray<ReJITID> reJitIds;

// Prepare array to populate with rejitids. "+ 1" because GetReJITIDs

// returns all available rejitids, including the rejitid for the one non-reverted

// current version.

ReJITID *rgReJitIds = reJitIds.OpenRawBuffer(cRevertedRejitVersions + 1);

if (rgReJitIds != NULL)

{

hr = ReJitManager::GetReJITIDs(pMD, cRevertedRejitVersions + 1, &cReJitIds, rgReJitIds);

if (SUCCEEDED(hr))

{

// Go through rejitids. For each reverted one, populate a entry in rgRevertedRejitData

reJitIds.CloseRawBuffer(cReJitIds);

ULONG iRejitDataReverted = 0;

ILCodeVersion activeVersion = pCodeVersionManager->GetActiveILCodeVersion(pMD);

for (COUNT_T i = 0;

(i < cReJitIds) && (iRejitDataReverted < cRevertedRejitVersions);

i++)