// 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: enummem.cpp

//

//

// ICLRDataEnumMemoryRegions implementation.

//

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

#include "stdafx.h"

#include <eeconfig.h>

#include <ecall.h>

#include <gcinfodecoder.h>

#include "typestring.h"

#include "daccess.h"

#include "binder.h"

#include "win32threadpool.h"

#ifdef FEATURE_PAL

#include <dactablerva.h>

#endif

#ifdef FEATURE_APPX

#include "appxutil.h"

#endif // FEATURE_APPX

#if defined(DAC_MEASURE_PERF)

unsigned __int64 g_nTotalTime;

unsigned __int64 g_nStackTotalTime;

unsigned __int64 g_nReadVirtualTotalTime;

unsigned __int64 g_nFindTotalTime;

unsigned __int64 g_nFindHashTotalTime;

unsigned __int64 g_nFindHits;

unsigned __int64 g_nFindCalls;

unsigned __int64 g_nFindFails;

unsigned __int64 g_nStackWalk;

unsigned __int64 g_nFindStackTotalTime;

#endif // #if defined(DAC_MEASURE_PERF)

//

// EnumMemCollectImages - collect all images of interest for heap dumps

//

// This is used primarily to save ngen images.

// This is necessary so that heap dumps contain the full native code for the

// process. Normally mini/heap dump debugging requires that the images be

// available at debug-time, (in fact, watson explicitly does not want to

// be downloading 3rd party images). Not including images is the main size

// advantage of heap dumps over full dumps. However, since ngen images are

// produced on the client, we can't always ensure that the debugger will

// have access to the exact ngen image used in the dump. Therefore, managed

// heap dumps also include full copies of all NGen images in the process.

//

// We also currently include in-memory modules (provided by a host, or loaded

// from a Byte[]).

//

HRESULT ClrDataAccess::EnumMemCollectImages()

{

SUPPORTS_DAC;

ProcessModIter modIter;

Module* modDef = NULL;

HRESULT status = S_OK;

PEFile *file;

TADDR pStartAddr = 0;

ULONG32 ulSize = 0;

ULONG32 ulSizeBlock;

TSIZE_T cbMemoryReported = m_cbMemoryReported;

//

// Collect the ngen images - Iterating through module list

//

EX_TRY

{

while ((modDef = modIter.NextModule()))

{

EX_TRY

{

ulSize = 0;

file = modDef->GetFile();

// We want to save all native images

if (file->HasNativeImage())

{

// We should only skip if signed by Microsoft!

pStartAddr = PTR_TO_TADDR(file->GetLoadedNative()->GetBase());

ulSize = file->GetLoadedNative()->GetSize();

}

// We also want to save any in-memory images. These show up like mapped files

// and so would not be in a heap dump by default. Technically it's not clear we

// should include them in the dump - you can often have the files available

// after-the-fact. But in-memory modules may be harder to track down at debug time

// and people may have come to rely on this - so we'll include them for now.

else

if (

file->GetPath().IsEmpty() && // is in-memory

file->HasMetadata() && // skip resource assemblies

file->IsLoaded(FALSE) && // skip files not yet loaded

!file->IsDynamic()) // skip dynamic (GetLoadedIL asserts anyway)

{

pStartAddr = PTR_TO_TADDR(file->GetLoadedIL()->GetBase());

ulSize = file->GetLoadedIL()->GetSize();

}

// memory are mapped in in GetOsPageSize() size.

// Some memory are mapped in but some are not. You cannot

// write all in one block. So iterating through page size

//

while (ulSize > 0)

{

//

// Note that we have talked about not writing IL and Metadata to save size.

// It turns out IL was rarely mapped in.

// Metadata is needed. The RVA field is needed for it is pointed to a

// MethodHeader MethodDesc::GetILHeader. Without this RVA,

// all locals are broken. In case, you are asked about this question again.

//

ulSizeBlock = ulSize > GetOsPageSize() ? GetOsPageSize() : ulSize;

ReportMem(pStartAddr, ulSizeBlock, false);

pStartAddr += ulSizeBlock;

ulSize -= ulSizeBlock;

}

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

}

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

m_dumpStats.m_cbNgen = m_cbMemoryReported - cbMemoryReported;

return status;

}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// collecting memory for mscorwks's heap dump critical statics

// This include the stress log, config structure, and IPC block

//

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemCLRHeapCrticalStatic(IN CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

TSIZE_T cbMemoryReported = m_cbMemoryReported;

// Write out the stress log structure itself

DacEnumHostDPtrMem(g_pStressLog);

// This is pointing to a static buffer

DacEnumHostDPtrMem(g_pConfig);

// dump GC heap structures. Note that the managed heap is not dumped out.

// We are just dump the GC heap structures.

//

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( EnumWksGlobalMemoryRegions(flags); );

#ifdef FEATURE_SVR_GC

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( EnumSvrGlobalMemoryRegions(flags); );

#endif

m_dumpStats.m_cbClrHeapStatics = m_cbMemoryReported - cbMemoryReported;

return S_OK;

}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// collecting memory for mscorwks's statics. This is the minimal

// set of global and statics that we need to have !threads, !pe, !ClrStack

// to work.

//

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemCLRStatic(IN CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

TSIZE_T cbMemoryReported = m_cbMemoryReported;

//

// write out the static and global content that we care.

//

// The followig macro will report memory all of the dac related mscorwks static and

// global variables. But it won't report the structures that are pointed by

// global pointers.

//

#define DEFINE_DACVAR(id_type, size_type, id, var) \

ReportMem(m_globalBase + g_dacGlobals.id, sizeof(size_type));

#ifdef FEATURE_PAL

// Add the dac table memory in coreclr

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED ( ReportMem(m_globalBase + DAC_TABLE_RVA, sizeof(g_dacGlobals)); )

#endif

// Cannot use CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED

// around conditional preprocessor directives in a sane fashion.

EX_TRY

{

#include "dacvars.h"

}

EX_CATCH

{

// Catch the exception and keep going unless COR_E_OPERATIONCANCELED

// was thrown. Used generating dumps, where rethrow will cancel dump.

}

EX_END_CATCH(RethrowCancelExceptions)

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED ( ReportMem(m_globalBase + g_dacGlobals.dac__g_pStressLog, sizeof(StressLog *)); )

EX_TRY

{

// These two static pointers are pointed to static data of byte[]

// then run constructor in place

//

ReportMem(m_globalBase + g_dacGlobals.SystemDomain__m_pSystemDomain, sizeof(SystemDomain));

// We need IGCHeap pointer to make EEVersion work

ReportMem(m_globalBase + g_dacGlobals.dac__g_pGCHeap, sizeof(IGCHeap *));

// see synblk.cpp, the pointer is pointed to a static byte[]

SyncBlockCache::s_pSyncBlockCache.EnumMem();

ReportMem(m_globalBase + g_dacGlobals.dac__g_FCDynamicallyAssignedImplementations,

sizeof(TADDR)*ECall::NUM_DYNAMICALLY_ASSIGNED_FCALL_IMPLEMENTATIONS);

ReportMem(g_gcDacGlobals.GetAddr(), sizeof(GcDacVars));

// We need all of the dac variables referenced by the GC DAC global struct.

// This struct contains pointers to pointers, so we first dereference the pointers

// to obtain the location of the variable that's reported.

#define GC_DAC_VAR(type, name) ReportMem(g_gcDacGlobals->name.GetAddr(), sizeof(type));

#include "../../gc/gcinterface.dacvars.def"

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

#ifndef FEATURE_PAL

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_runtimeLoadedBaseAddress.EnumMem(); )

#endif // !FEATURE_PAL

// These are the structures that are pointed by global pointers and we care.

// Some may reside in heap and some may reside as a static byte array in mscorwks.dll

// That is ok. We will report them explicitly.

//

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pConfig.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pPredefinedArrayTypes.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pObjectClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pStringClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pArrayClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pExceptionClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pThreadAbortExceptionClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pOutOfMemoryExceptionClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pStackOverflowExceptionClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pExecutionEngineExceptionClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pDelegateClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pMulticastDelegateClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pValueTypeClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pEnumClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pThreadClass.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pFreeObjectMethodTable.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_fHostConfig.EnumMem(); )

// These two static pointers are pointed to static data of byte[]

// then run constructor in place

//

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( SystemDomain::m_pSystemDomain.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pDebugger.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pEEInterface.EnumMem(); )

if (g_pDebugInterface != nullptr)

{

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED(g_pDebugInterface.EnumMem(); )

}

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pEEDbgInterfaceImpl.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_CORDebuggerControlFlags.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_Mscorlib.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pPredefinedArrayTypes[ELEMENT_TYPE_OBJECT]->EnumMemoryRegions(flags); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( StubManager::EnumMemoryRegions(flags); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pFinalizerThread.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pSuspensionThread.EnumMem(); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_heap_type.EnumMem(); )

m_dumpStats.m_cbClrStatics = m_cbMemoryReported - cbMemoryReported;

return S_OK;

}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// This function reports memory that a heap dump need to debug CLR

// and managed code efficiently.

//

// We will write out -

// 1. mscorwks.dll's image read/write pages

// 2. IPC blocks - shared memory (needed for debugging service and perf counter)

// 3. ngen images excluding Metadata and IL for size perf

// 4. We may want to touch the code pages on the stack - to be safe....

//

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemoryRegionsWorkerHeap(IN CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

HRESULT status = S_OK;

// clear all of the previous cached memory

Flush();

// collect ngen image

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCollectImages(); );

// collect CLR static

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRStatic(flags); );

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRHeapCrticalStatic(flags); );

// Note that we do not need to flush out all of the dac instance manager's instance.

// This is because it is a heap dump here. Assembly and AppDomain objects will be reported

// by the default heap collection mechanism by dbghelp.lib

//

// Microsoft: I suspect if we have all private read-write pages the preceding statement

// would be true, but I don't think we have that guarantee here.

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpModuleList(flags); );

// Iterating to all threads' stacks, as we have to collect data stored inside (core)clr.dll

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpAllThreadsStack(flags); )

// Dump AppDomain-specific info

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpAppDomainInfo(flags); )

// Dump the Debugger object data needed

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pDebugger->EnumMemoryRegions(flags); )

// now dump the memory get dragged in by using DAC API implicitly.

m_dumpStats.m_cbImplicity = m_instances.DumpAllInstances(m_enumMemCb);

// Do not let any remaining implicitly enumerated memory leak out.

Flush();

return S_OK;

} // EnumMemoryRegionsWorkerHeap

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Helper function for skinny mini-dump

// Pass in an managed object, this function will dump the EEClass hierachy

// and field desc of object so SOS's !DumpObj will work

//

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::DumpManagedObject(CLRDataEnumMemoryFlags flags, OBJECTREF objRef)

{

SUPPORTS_DAC;

HRESULT status = S_OK;

if (objRef == NULL)

{

return status;

}

if (*g_gcDacGlobals->gc_structures_invalid_cnt != 0)

{

// GC is in progress, don't dump this object

return S_OK;

}

EX_TRY

{

// write out the current EE class and the direct/indirect inherited EE Classes

MethodTable *pMethodTable = objRef->GetGCSafeMethodTable();

while (pMethodTable)

{

EX_TRY

{

pMethodTable->EnumMemoryRegions(flags);

StackSString s;

// This might look odd. We are not using variable s after forming it.

// That is because our DAC inspecting API is using TypeString to form

// full type name. Form the full name here is a implicit reference to needed

// memory.

//

TypeString::AppendType(s, TypeHandle(pMethodTable), TypeString::FormatNamespace|TypeString::FormatFullInst);

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

// Walk up to parent MethodTable

pMethodTable = pMethodTable->GetParentMethodTable();

}

// now dump the content for the managed object

objRef->EnumMemoryRegions();

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

return status;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Helper function for skinny mini-dump

// Pass in an managed excption object, this function will dump

// the managed exception object and some of its fields, such as message, stack trace string,

// inner exception.

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::DumpManagedExcepObject(CLRDataEnumMemoryFlags flags, OBJECTREF objRef)

{

SUPPORTS_DAC;

if (objRef == NULL)

{

return S_OK;

}

if (*g_gcDacGlobals->gc_structures_invalid_cnt != 0)

{

// GC is in progress, don't dump this object

return S_OK;

}

// write out the managed object for exception. This will only write out the

// direct field value. After this, we need to visit some selected fields, such as

// exception message and stack trace field, and dump out the object referenced via

// the fields.

//

DumpManagedObject(flags, objRef);

// If this is not a pre-allocated exception type, then we'll need to dump out enough memory to ensure

// that the lookup codepath from the Module to information for the type of this Exception will

// be present. Simply dumping the managed object itself isn't enough. Sos doesn't need this.

EX_TRY

{

MethodTable * pMethodTable = objRef->GetGCSafeMethodTable();

PTR_Module pModule = pMethodTable->GetModule();

mdTypeDef exceptionTypeDef = pMethodTable->GetCl();

if (TypeFromToken(exceptionTypeDef) != mdtTypeDef)

{

_ASSERTE(!"Module should have contained a TypeDef, dump will likely be missing exception type lookup!");

}

// The lookup from the Module that contains this TypeDef:

pModule->LookupTypeDef(RidFromToken(exceptionTypeDef));

// If it's a generic class, we need to implicitly enumerate the memory needed to look it up

// and enable the calls that ICD will want to make against the TypeHandle when retrieving the

// Exception info.

TypeHandle th;

th = ClassLoader::LookupTypeDefOrRefInModule(pModule, exceptionTypeDef);

th.EnumMemoryRegions(flags);

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

#ifdef FEATURE_MINIMETADATA_IN_TRIAGEDUMPS

// store the exception type name

EX_TRY

{

MethodTable * pMethodTable = objRef->GetGCSafeMethodTable();

StackSString s;

TypeString::AppendType(s, TypeHandle(pMethodTable), TypeString::FormatNamespace|TypeString::FormatFullInst);

DacMdCacheAddEEName(dac_cast<TADDR>(pMethodTable), s);

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

#endif // FEATURE_MINIMETADATA_IN_TRIAGEDUMPS

EXCEPTIONREF exceptRef = (EXCEPTIONREF)objRef;

if (flags != CLRDATA_ENUM_MEM_TRIAGE)

{

// dump the exception message field

DumpManagedObject(flags, (OBJECTREF)exceptRef->GetMessage());

}

// dump the exception's stack trace field

DumpManagedStackTraceStringObject(flags, exceptRef->GetStackTraceString());

// dump the exception's remote stack trace field only if we are not generating a triage dump, or

// if we are generating a triage dump of an AppX process, or the exception type does not override

// the StackTrace getter (see Exception.InternalPreserveStackTrace to understand why)

if (flags != CLRDATA_ENUM_MEM_TRIAGE ||

#ifdef FEATURE_APPX

AppX::DacIsAppXProcess() ||

#endif // FEATURE_APPX

!ExceptionTypeOverridesStackTraceGetter(exceptRef->GetGCSafeMethodTable()))

{

DumpManagedStackTraceStringObject(flags, exceptRef->GetRemoteStackTraceString());

}

// Dump inner exception

DumpManagedExcepObject(flags, exceptRef->GetInnerException());

// Dump the stack trace array object and its underlying type

I1ARRAYREF stackTraceArrayObj = exceptRef->GetStackTraceArrayObject();

// There are cases where a managed exception does not have a stack trace.

// These cases are:

// * exception was thrown by VM and no managed frames are on the thread.

// * exception thrown is a preallocated exception.

if (stackTraceArrayObj != NULL)

{

// first dump the array's element type

TypeHandle arrayTypeHandle = stackTraceArrayObj->GetTypeHandle();

ArrayTypeDesc* pArrayTypeDesc = arrayTypeHandle.AsArray();

TypeHandle elementTypeHandle = pArrayTypeDesc->GetArrayElementTypeHandle();

elementTypeHandle.AsMethodTable()->EnumMemoryRegions(flags);

elementTypeHandle.AsMethodTable()->GetClass()->EnumMemoryRegions(flags, elementTypeHandle.AsMethodTable());

// now dump the actual stack trace array object

DumpManagedObject(flags, (OBJECTREF)stackTraceArrayObj);

}

// Dump the stack trace native structure. Unfortunately, we need to write out the

// native structure and also dump the MethodDesc that we care about!

// We need to ensure the entire _stackTrace from the Exception is enumerated and

// included in the dump. When we touch the header and each element looking for the

// MD this happens.

StackTraceArray stackTrace;

exceptRef->GetStackTrace(stackTrace);

for(size_t i = 0; i < stackTrace.Size(); i++)

{

MethodDesc* pMD = stackTrace[i].pFunc;

if (!DacHasMethodDescBeenEnumerated(pMD) && DacValidateMD(pMD))

{

pMD->EnumMemoryRegions(flags);

// The following calls are to ensure that mscordacwks!DacDbiInterfaceImpl::GetNativeCodeInfo

// will succeed for all dumps.

// Pulls in data to translate from token to MethodDesc

FindLoadedMethodRefOrDef(pMD->GetMethodTable()->GetModule(), pMD->GetMemberDef());

// Pulls in sequence points.

DebugInfoManager::EnumMemoryRegionsForMethodDebugInfo(flags, pMD);

PCODE addr = pMD->GetNativeCode();

if (addr != NULL)

{

IJitManager::MethodRegionInfo methodRegionInfo = { NULL, 0, NULL, 0 };

EECodeInfo codeInfo(addr);

codeInfo.GetMethodRegionInfo(&methodRegionInfo);

}

}

// Enumerate the code around call site to help SOS resolve the source lines

TADDR callEnd = PCODEToPINSTR(stackTrace[i].ip);

DacEnumCodeForStackwalk(callEnd);

}

return S_OK;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Helper function for skinny mini-dump

// Pass in a string object representing a managed stack trace, this function will

// dump it and "poison" the contents with a PII-free version of the stack trace.

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::DumpManagedStackTraceStringObject(CLRDataEnumMemoryFlags flags, STRINGREF orefStackTrace)

{

SUPPORTS_DAC;

if (orefStackTrace == NULL)

{

return S_OK;

}

// dump the stack trace string object

DumpManagedObject(flags, (OBJECTREF)orefStackTrace);

if (flags == CLRDATA_ENUM_MEM_TRIAGE)

{

// StringObject::GetSString does not support DAC, use GetBuffer/GetStringLength

SString stackTrace(dac_cast<PTR_WSTR>((TADDR)orefStackTrace->GetBuffer()), orefStackTrace->GetStringLength());

StripFileInfoFromStackTrace(stackTrace);

COUNT_T traceCharCount = stackTrace.GetCount();

_ASSERTE(traceCharCount <= orefStackTrace->GetStringLength());

// fill the rest of the string with \0

WCHAR *buffer = stackTrace.OpenUnicodeBuffer(orefStackTrace->GetStringLength());

memset(buffer + traceCharCount, 0, sizeof(WCHAR) * (orefStackTrace->GetStringLength() - traceCharCount));

// replace the string

DacUpdateMemoryRegion(dac_cast<TADDR>(orefStackTrace) + StringObject::GetBufferOffset(), sizeof(WCHAR) * orefStackTrace->GetStringLength(), (BYTE *)buffer);

}

return S_OK;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Iterating through module list and report the memory.

// Remember to call

// m_instances.DumpAllInstances(m_enumMemCb);

// when all memory enumeration are done if you call this function!

// This is because using ProcessModIter will drag in some memory implicitly.

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemDumpModuleList(CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

ProcessModIter modIter;

Module* modDef;

TADDR base;

ULONG32 length;

PEFile *file;

TSIZE_T cbMemoryReported = m_cbMemoryReported;

#ifdef FEATURE_PREJIT

COUNT_T count;

#endif // FEATURE_PREJIT

//

// Iterating through module list

//

// Cannot use CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED around

// conditional pre-processor directives in a sane fashion

EX_TRY

{

while ((modDef = modIter.NextModule()))

{

// We also want to dump the link from the Module back to the AppDomain,

// since the stackwalker uses it to find the AD.

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED

(

// Pass false to ensure we force enumeration of this module's references.

modDef->EnumMemoryRegions(flags, false);

);

EX_TRY

{

// To enable a debugger to check on whether a module is an NI or IL image, they need

// the DOS header, PE headers, and IMAGE_COR20_HEADER for the Flags member.

// We expose no API today to find this out.

PTR_PEFile pPEFile = modDef->GetFile();

PEImage * pILImage = pPEFile->GetILimage();

PEImage * pNIImage = pPEFile->GetNativeImage();

// Implicitly gets the COR header.

if ((pILImage) && (pILImage->HasLoadedLayout()))

{

pILImage->GetCorHeaderFlags();

}

if ((pNIImage) && (pNIImage->HasLoadedLayout()))

{

pNIImage->GetCorHeaderFlags();

}

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

EX_TRY

{

file = modDef->GetFile();

base = PTR_TO_TADDR(file->GetLoadedImageContents(&length));

file->EnumMemoryRegions(flags);

#ifdef FEATURE_PREJIT

// If module has native image and it has debug map, we need to get the debug map.

//

if (modDef->HasNativeImage() && modDef->GetNativeImage()->HasNativeDebugMap())

{

modDef->GetNativeImage()->GetNativeDebugMap(&count);

}

#endif // FEATURE_PREJIT

}

EX_CATCH

{

// Catch the exception and keep going unless COR_E_OPERATIONCANCELED

// was thrown. Used generating dumps, where rethrow will cancel dump.

}

EX_END_CATCH(RethrowCancelExceptions)

}

}

EX_CATCH

{

// Catch the exception and keep going unless COR_E_OPERATIONCANCELED

// was thrown. Used generating dumps, where rethrow will cancel dump.

}

EX_END_CATCH(RethrowCancelExceptions)

m_dumpStats.m_cbModuleList = m_cbMemoryReported - cbMemoryReported;

return S_OK;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Iterate through AppDomains and report specific memory needed

// for all dumps, such as the Module lookup path.

// This is intended for MiniDumpNormal and should be kept small.

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemDumpAppDomainInfo(CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

AppDomainIterator adIter(FALSE);

EX_TRY

{

while (adIter.Next())

{

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED

(

// Note that the flags being CLRDATA_ENUM_MEM_MINI prevents

// you from pulling entire files loaded into memory into the dump.

adIter.GetDomain()->EnumMemoryRegions(flags, true);

);

}

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

return S_OK;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//

// Iterating through each frame to make sure

// we dump out MethodDesc, DJI etc related info

// This is a generic helper for walking stack. However, if you call

// this function, make sure to flush instance in the DAC Instance manager.

//

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

HRESULT ClrDataAccess::EnumMemWalkStackHelper(CLRDataEnumMemoryFlags flags,

IXCLRDataStackWalk *pStackWalk,

Thread * pThread)

{

SUPPORTS_DAC;

#if defined(DAC_MEASURE_PERF)

g_nStackWalk = 1;

unsigned __int64 nStart= GetCycleCount();

#endif

HRESULT status = S_OK;

ReleaseHolder<IXCLRDataFrame> pFrame(NULL);

ReleaseHolder<IXCLRDataMethodInstance> pMethod(NULL);

ReleaseHolder<IXCLRDataMethodDefinition> pMethodDefinition(NULL);

ReleaseHolder<IXCLRDataTypeInstance> pTypeInstance(NULL);

MethodDesc * pMethodDesc = NULL;

EX_TRY

{

TADDR previousSP = 0; //start at zero; this allows first check to always succeed.

TADDR currentSP;

currentSP = dac_cast<TADDR>(pThread->GetCachedStackLimit()) + sizeof(TADDR);

// exhaust the frames using DAC api

for (; status == S_OK; )

{

bool frameHadContext = false;

status = pStackWalk->GetFrame(&pFrame);

PCODE addr = NULL;

if (status == S_OK && pFrame != NULL)

{

// write out the code that ip pointed to

T_CONTEXT context;

REGDISPLAY regDisp;

if ((status=pFrame->GetContext(CONTEXT_ALL, sizeof(T_CONTEXT),

NULL, (BYTE *)&context))==S_OK)

{

// Enumerate the code around the call site to help debugger stack walking heuristics

::FillRegDisplay(&regDisp, &context);

addr = GetControlPC(&regDisp);

TADDR callEnd = PCODEToPINSTR(addr);

DacEnumCodeForStackwalk(callEnd);

frameHadContext = true;

}

//

// There are identical stack pointer checking semantics in code:Thread::EnumMemoryRegionsWorker

// See that code for comments.

// You ***MUST*** maintain identical semantics for both checks!

//

CLRDataSimpleFrameType simpleFrameType;

CLRDataDetailedFrameType detailedFrameType;

if (SUCCEEDED(pFrame->GetFrameType(&simpleFrameType, &detailedFrameType)))

{

if (!frameHadContext)

{

_ASSERTE(!"Stack frame should always have an associated context!");

break;

}

// This is StackFrameIterator::SFITER_FRAMELESS_METHOD, initialized by Code:ClrDataStackWalk::GetFrame

// from code:ClrDataStackWalk::RawGetFrameType

if (simpleFrameType == CLRDATA_SIMPFRAME_MANAGED_METHOD)

{

currentSP = (TADDR)GetRegdisplaySP(&regDisp);

if (currentSP <= previousSP)

{

_ASSERTE(!"Target stack has been corrupted, SP for current frame must be larger than previous frame.");

break;

}

if (currentSP % sizeof(TADDR) != 0)

{

_ASSERTE(!"Target stack has been corrupted, SP must be aligned.");

break;

}

if (!pThread->IsAddressInStack(currentSP))

{

_ASSERTE(!"Target stack has been corrupted, SP must in in the stack range.");

break;

}

}

}

else

{

_ASSERTE(!"The stack frame should always know what type it is!");

break;

}

status = pFrame->GetMethodInstance(&pMethod);

if (status == S_OK && pMethod != NULL)

{

// managed frame

if (SUCCEEDED(pMethod->GetTypeInstance(&pTypeInstance)) &&

(pTypeInstance != NULL))

{

pTypeInstance.Clear();

}

if(SUCCEEDED(pMethod->GetDefinition(&pMethodDefinition)) &&

(pMethodDefinition != NULL))

{

pMethodDesc = ((ClrDataMethodDefinition *)pMethodDefinition.GetValue())->GetMethodDesc();

if (pMethodDesc)

{

// If this is a generic, we'll need to pull in enough extra info that

// we get decent results later when stackwalking. Note that we do not guarantee

// we'll always get an exact type for any reference type; most of the time the

// stack walk will just show System.__Canon, which is the level of support we

// guarantee for minidumps without full memory.

EX_TRY

{

if ((pMethodDesc->AcquiresInstMethodTableFromThis()) ||

(pMethodDesc->RequiresInstMethodTableArg()))

{

// MethodTable

ReleaseHolder<IXCLRDataValue> pDV(NULL);

ReleaseHolder<IXCLRDataValue> pAssociatedValue(NULL);

CLRDATA_ADDRESS address;

PTR_Object pObjThis = NULL;

if (SUCCEEDED(pFrame->GetArgumentByIndex(0, &pDV, 0, NULL, NULL)) &&

SUCCEEDED(pDV->GetAssociatedValue(&pAssociatedValue)) &&

SUCCEEDED(pAssociatedValue->GetAddress(&address)))

{

// Implicitly enumerate the object itself.

TADDR addrObjThis = CLRDATA_ADDRESS_TO_TADDR(address);

pObjThis = dac_cast<PTR_Object>(addrObjThis);

}

// And now get the extra info we need for the AcquiresInstMethodTableFromThis case.

if (pMethodDesc->AcquiresInstMethodTableFromThis())

{

// When working with the 'this' case, we need to pick up the MethodTable from

// object lookup.

PTR_MethodTable pMT = NULL;

if (pObjThis != NULL)

{

pMT = pObjThis->GetMethodTable();

}

TypeHandle th;

if (pMT != NULL)

{

th = TypeHandle(pMT);

}

Instantiation classInst = pMethodDesc->GetExactClassInstantiation(th);

Instantiation methodInst = pMethodDesc->GetMethodInstantiation();

}

}

else if (pMethodDesc->RequiresInstMethodDescArg())

{

// This method has a generic type token which is required to figure out the exact instantiation

// of the method.

// We need to to use the variable index of the generic type token in order to do the look up.

CLRDATA_ADDRESS address = NULL;

DWORD dwExactGenericArgsTokenIndex = 0;

ReleaseHolder<IXCLRDataValue> pDV(NULL);

ReleaseHolder<IXCLRDataValue> pAssociatedValue(NULL);

ReleaseHolder<IXCLRDataFrame2> pFrame2(NULL);

if (SUCCEEDED(pFrame->QueryInterface(__uuidof(IXCLRDataFrame2), (void**)&pFrame2)) &&

SUCCEEDED(pFrame2->GetExactGenericArgsToken(&pDV)) &&

SUCCEEDED(pDV->GetAssociatedValue(&pAssociatedValue)) &&

SUCCEEDED(pAssociatedValue->GetAddress(&address)))

{

TADDR addrMD = CLRDATA_ADDRESS_TO_TADDR(address);

PTR_MethodDesc pMD = dac_cast<PTR_MethodDesc>(addrMD);

pMD->EnumMemoryRegions(flags);

}

pMethodDesc->EnumMemoryRegions(flags);

MethodTable * pCanonicalMT = pMethodDesc->GetCanonicalMethodTable();

MethodTable * pNormalMT = pMethodDesc->GetMethodTable();

pCanonicalMT->EnumMemoryRegions(flags);

pNormalMT->EnumMemoryRegions(flags);

}

}

EX_CATCH_RETHROW_ONLY_COR_E_OPERATIONCANCELLED

pMethodDesc->EnumMemoryRegions(flags);

// The following calls are to ensure that mscordacwks!DacDbiInterfaceImpl::GetNativeCodeSequencePointsAndVarInfo

// will succeed for all dumps. Local variable info usefulness is somewhat questionable

// since most dumps will be for optimized targets. However, being able to map

// back to source lines for functions on stacks is very useful and we don't

// want to allow the function to fail for all targets.

// Pulls in sequence points and local variable info

DebugInfoManager::EnumMemoryRegionsForMethodDebugInfo(flags, pMethodDesc);

#if defined(FEATURE_EH_FUNCLETS) && defined(USE_GC_INFO_DECODER)

if (addr != NULL)

{

EECodeInfo codeInfo(addr);

if (codeInfo.IsValid())

{

// We want IsFilterFunclet to work for anything on the stack

codeInfo.GetJitManager()->IsFilterFunclet(&codeInfo);

// The stackwalker needs GC info to find the parent 'stack pointer' or PSP

GCInfoToken gcInfoToken = codeInfo.GetGCInfoToken();

PTR_BYTE pGCInfo = dac_cast<PTR_BYTE>(gcInfoToken.Info);

if (pGCInfo != NULL)

{

GcInfoDecoder gcDecoder(gcInfoToken, DECODE_PSP_SYM, 0);

DacEnumMemoryRegion(dac_cast<TADDR>(pGCInfo), gcDecoder.GetNumBytesRead(), true);

}

}

}

#endif // FEATURE_EH_FUNCLETS && USE_GC_INFO_DECODER

}

pMethodDefinition.Clear();

}

pMethod.Clear();

}

pFrame.Clear();

}

previousSP = currentSP;

status = pStackWalk->Next();

}

}

EX_CATCH

{

status = E_FAIL;

// Catch the exception and keep going unless a COR_E_OPERATIONCANCELED

// was thrown. In which case, rethrow to cancel the dump gathering

}

EX_END_CATCH(RethrowCancelExceptions)

#if defined(DAC_MEASURE_PERF)

unsigned __int64 nEnd = GetCycleCount();

g_nStackTotalTime += nEnd - nStart;

g_nStackWalk = 0;

#endif // #if defined(DAC_MEASURE_PERF)

return status;

}

// code: ClrDataAccess::EnumMemDumpAllThreadsStack needs a trivial implementation of

// an un-DACized container class to track what exceptions have happened so far.

// It shouldn't get used anywhere else.

class DebuggingExceptionTrackerList

{

private:

struct TrivialTADDRNode

{

TADDR m_exceptionAddress;

TrivialTADDRNode * m_pNext;

TrivialTADDRNode(TrivialTADDRNode *pNext, TADDR address)

: m_exceptionAddress(address), m_pNext(pNext)

{