《memory leak： stackwalk》 /// // // StackWalk.cpp // // Author: Oleg Starodumov // // NOTE: THIS FILE IS "WORK IN PROGRESS", NOT YET READY // // /// // // Description: <OS-TODO> // /// // Include files // #include <windows.h> #include <tchar.h>#include <dbghelp.h>#include <stdio.h>#include <vector>/// // Directives // #pragma comment( lib, "dbghelp.lib" )/// // CStackWalk class declaration // class CStackWalk { public: // Helper types struct CStackFrame{DWORD64 Ip; // Instruction pointer (EIP on x86) DWORD64 RetAddr; // Return address DWORD64 Bp; // Stack base pointer (EBP on x86) CStackFrame( DWORD64 _Ip, DWORD64 _RetAddr, DWORD64 _Bp ) : Ip( _Ip ), RetAddr( _RetAddr ), Bp( _Bp ) {}};typedef std::vector<CStackFrame> FrameColl_t;public: // Constructors / destructor CStackWalk( HANDLE hProcess = GetCurrentProcess(), HANDLE hThread = GetCurrentThread() ); ~CStackWalk(); // Operations // Walk the stack bool Walk( CONTEXT* pContext = 0 ); // Accessors // Call stack FrameColl_t CallStack() const { return m_CallStack; }// Last error code DWORD LastError() const { return m_LastError; }// GetModuleBase function void SetModuleBaseFunc( PGET_MODULE_BASE_ROUTINE64 pFunc ) { m_pfnGetModBase = pFunc; }private: // Copy protection CStackWalk( const CStackWalk& );CStackWalk& operator=( const CStackWalk& );private: // Data members // Process handle HANDLE m_hProcess; // Thread handle HANDLE m_hThread; // Call stack FrameColl_t m_CallStack; // Last error code DWORD m_LastError; // User-supplied GetModuleBase function (optional) PGET_MODULE_BASE_ROUTINE64 m_pfnGetModBase; };/// // CStackWalk class implementation //// Bring in _ReturnAddress intrinsic #ifdef __cplusplus extern "C" #endif void* _ReturnAddress(void);#pragma intrinsic(_ReturnAddress)// GetCallerAddress() helper function static void* GetCallerAddress(); #pragma optimize ( "", off ) void* GetCallerAddress() {return _ReturnAddress(); } #pragma optimize ( "", on )// Constructor CStackWalk::CStackWalk( HANDLE hProcess, HANDLE hThread ) : m_hProcess( hProcess ), m_hThread( hThread ), m_LastError( 0 ), m_pfnGetModBase( 0 ) { }// Destructor CStackWalk::~CStackWalk() {// no actions }// Stack walker function // Turn off optimizations to make sure that frame pointer is present #pragma optimize ( "", off )bool CStackWalk::Walk( CONTEXT* pContext ) {// Obtain an address in the address range of this function // _after_ its stack frame has been constructed. // (We cannot just use the function's address, because it is before // the stack frame construction) DWORD64 MyAddress = (DWORD64)GetCallerAddress(); // Cleanup m_LastError = 0; m_CallStack.clear(); SetLastError( 0 ); // Collect the data needed by StackWalk64 // Machine type DWORD MachineType = 0; // Stack frame STACKFRAME64 StackFrame; memset( &StackFrame, 0, sizeof(StackFrame) );// Architecture-specific initialization #ifdef _M_IX86// Machine type MachineType = IMAGE_FILE_MACHINE_I386;// STACKFRAME64 structure if( pContext != 0 ) {StackFrame.AddrPC.Offset = pContext->Eip;StackFrame.AddrPC.Mode = AddrModeFlat;StackFrame.AddrStack.Offset = pContext->Esp;StackFrame.AddrStack.Mode = AddrModeFlat;StackFrame.AddrFrame.Offset = pContext->Ebp;StackFrame.AddrFrame.Mode = AddrModeFlat;}else {// Initialize the stack frame structure so that StackWalk64 // attempts to walk the stack above the current function only, // excluding this function (Walk) itself. // // This is to avoid modifying the stack frame of the current function // between subsequent calls to StackWalk64, which IMO can affect // the possibility to walk the stack successfully. // unsigned long StackPtr;unsigned long BasePtr; __asm mov [StackPtr], esp__asm mov [BasePtr], ebpStackFrame.AddrPC.Offset = MyAddress; StackFrame.AddrPC.Mode = AddrModeFlat;StackFrame.AddrStack.Offset = StackPtr; StackFrame.AddrStack.Mode = AddrModeFlat;StackFrame.AddrFrame.Offset = BasePtr; StackFrame.AddrFrame.Mode = AddrModeFlat;}#else#error This architecture is not supported.#endif //_M_IX86// GetModuleBase function PGET_MODULE_BASE_ROUTINE64 pfnGetModBase = m_pfnGetModBase; if( pfnGetModBase == 0 ) pfnGetModBase = SymGetModuleBase64; // If we obtained the context ourselves, we have to skip // the first frame (the current function - Walk) bool bSkipFirst = ( pContext == 0 ); // Walk the stack while( 1 ) {// Reset last error code SetLastError( 0 ); // Call StackWalk64 if( !StackWalk64( MachineType, // Machine architecture type m_hProcess, // Process handle m_hThread, // Thread handle &StackFrame, // Stack frame 0, // Thread context (not needed for x86)0, // Read memory function - not used SymFunctionTableAccess64, // Function table access function (FPO access on x86) pfnGetModBase, //SymGetModuleBase64, // Function that can determine module base for the given address 0 // Address translation function - not user ) ){// StackWalk64 failed m_LastError = GetLastError(); break; }// Check the stack frame if( StackFrame.AddrFrame.Offset == 0 ) {// Invalid frame break; }bool bSaveFrame = true; if( StackFrame.AddrPC.Offset == 0 ) {// Do not save it bSaveFrame = false; }if( StackFrame.AddrPC.Offset == StackFrame.AddrReturn.Offset ) {// Do not save it bSaveFrame = false; }if( bSkipFirst ) {// Do not save it bSaveFrame = false; bSkipFirst = false; }// Save the stack frame if( bSaveFrame ) {CStackFrame NewFrame( StackFrame.AddrPC.Offset, StackFrame.AddrReturn.Offset, StackFrame.AddrFrame.Offset ); m_CallStack.push_back( NewFrame );}// Proceed to the next frame }// Complete return ( m_CallStack.size() > 0 );}#pragma optimize ( "", on )/// // main // int _tmain( int argc, const TCHAR* argv[] ) {BOOL bRet = FALSE; // Set options DWORD Options = SymGetOptions(); // SYMOPT_DEBUG option asks DbgHelp to print additional troubleshooting // messages to debug output - use the debugger's Debug Output window // to view the messages Options |= SYMOPT_DEBUG; ::SymSetOptions( Options ); // Initialize DbgHelp and load symbols for all modules of the current process bRet = ::SymInitialize ( GetCurrentProcess(), // Process handle of the current process NULL, // No user-defined search path -> use default TRUE // Load symbols for all modules in the current process ); if( !bRet ) {_tprintf( _T("Error: SymInitialize() failed. Error code: %u \n"), ::GetLastError() );return 0; }// Obtain the call stack {CStackWalk StackWalk; if( StackWalk.Walk() ) {// Display the call stack CStackWalk::FrameColl_t Frames( StackWalk.CallStack() ); for( int i = 0; i < Frames.size(); i++ ) {_tprintf( _T("BP: %08I64x RetAddr: %08I64x IP: %08I64x \n"), Frames[i].Bp, Frames[i].RetAddr, Frames[i].Ip ); }}else {_tprintf( _T("Stack walk failed. Error: %u \n"), StackWalk.LastError() ); }}// Deinitialize DbgHelp bRet = ::SymCleanup( GetCurrentProcess() ); if( !bRet ) {_tprintf(_T("Error: SymCleanup() failed. Error code: %u \n"), ::GetLastError());return 0; }// Complete return 0; } View Code

http://www.debuginfo.com/examples/src/StackWalk.cpp?

?

https://dxr.mozilla.org/mozilla-beta/source/mozglue/misc/StackWalk.cpp

https://dxr.mozilla.org/mozilla-central/source/mozglue/misc/StackWalk.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public* License, v. 2.0. If a copy of the MPL was not distributed with this* file, You can obtain one at http://mozilla.org/MPL/2.0/. *//* API for getting a stack trace of the C/C++ stack on the current thread */#include "mozilla/ArrayUtils.h" #include "mozilla/Assertions.h" #include "mozilla/IntegerPrintfMacros.h" #include "mozilla/StackWalk.h"#include <string.h>using namespace mozilla;// The presence of this address is the stack must stop the stack walk. If // there is no such address, the structure will be {nullptr, true}. struct CriticalAddress {void* mAddr;bool mInit; }; static CriticalAddress gCriticalAddress;// for _Unwind_Backtrace from libcxxrt or libunwind // cxxabi.h from libcxxrt implicitly includes unwind.h first #if defined(HAVE__UNWIND_BACKTRACE) && !defined(_GNU_SOURCE) #define _GNU_SOURCE #endif#if defined(HAVE_DLOPEN) || defined(XP_DARWIN) #include <dlfcn.h> #endif#if (defined(XP_DARWIN) && \(defined(__i386) || defined(__ppc__) || defined(HAVE__UNWIND_BACKTRACE))) #define MOZ_STACKWALK_SUPPORTS_MACOSX 1 #else #define MOZ_STACKWALK_SUPPORTS_MACOSX 0 #endif#if (defined(linux) && \((defined(__GNUC__) && (defined(__i386) || defined(PPC))) || \defined(HAVE__UNWIND_BACKTRACE))) #define MOZ_STACKWALK_SUPPORTS_LINUX 1 #else #define MOZ_STACKWALK_SUPPORTS_LINUX 0 #endif#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) #define HAVE___LIBC_STACK_END 1 #else #define HAVE___LIBC_STACK_END 0 #endif#if HAVE___LIBC_STACK_END extern MOZ_EXPORT void* __libc_stack_end; // from ld-linux.so #endif#ifdef ANDROID #include <algorithm> #include <unistd.h> #include <pthread.h> #endif#if MOZ_STACKWALK_SUPPORTS_MACOSX #include <pthread.h> #include <sys/errno.h> #ifdef MOZ_WIDGET_COCOA #include <CoreServices/CoreServices.h> #endiftypedef void malloc_logger_t(uint32_t aType,uintptr_t aArg1, uintptr_t aArg2, uintptr_t aArg3,uintptr_t aResult, uint32_t aNumHotFramesToSkip); extern malloc_logger_t* malloc_logger;static void stack_callback(uint32_t aFrameNumber, void* aPc, void* aSp, void* aClosure) {const char* name = static_cast<char*>(aClosure);Dl_info info;// On Leopard dladdr returns the wrong value for "new_sem_from_pool". The// stack shows up as having two pthread_cond_wait$UNIX2003 frames. The// correct one is the first that we find on our way up, so the// following check for gCriticalAddress.mAddr is critical.if (gCriticalAddress.mAddr || dladdr(aPc, &info) == 0 ||!info.dli_sname || strcmp(info.dli_sname, name) != 0) {return;}gCriticalAddress.mAddr = aPc; }static void my_malloc_logger(uint32_t aType,uintptr_t aArg1, uintptr_t aArg2, uintptr_t aArg3,uintptr_t aResult, uint32_t aNumHotFramesToSkip) {static bool once = false;if (once) {return;}once = true;// On Leopard dladdr returns the wrong value for "new_sem_from_pool". The// stack shows up as having two pthread_cond_wait$UNIX2003 frames.const char* name = "new_sem_from_pool";MozStackWalk(stack_callback, /* skipFrames */ 0, /* maxFrames */ 0,const_cast<char*>(name), 0, nullptr); }// This is called from NS_LogInit() and from the stack walking functions, but // only the first call has any effect. We need to call this function from both // places because it must run before any mutexes are created, and also before // any objects whose refcounts we're logging are created. Running this // function during NS_LogInit() ensures that we meet the first criterion, and // running this function during the stack walking functions ensures we meet the // second criterion. MFBT_API void StackWalkInitCriticalAddress() {if (gCriticalAddress.mInit) {return;}gCriticalAddress.mInit = true;// We must not do work when 'new_sem_from_pool' calls realloc, since// it holds a non-reentrant spin-lock and we will quickly deadlock.// new_sem_from_pool is not directly accessible using dlsym, so// we force a situation where new_sem_from_pool is on the stack and// use dladdr to check the addresses.// malloc_logger can be set by external tools like 'Instruments' or 'leaks'malloc_logger_t* old_malloc_logger = malloc_logger;malloc_logger = my_malloc_logger;pthread_cond_t cond;int r = pthread_cond_init(&cond, 0);MOZ_ASSERT(r == 0);pthread_mutex_t mutex;r = pthread_mutex_init(&mutex, 0);MOZ_ASSERT(r == 0);r = pthread_mutex_lock(&mutex);MOZ_ASSERT(r == 0);struct timespec abstime = { 0, 1 };r = pthread_cond_timedwait_relative_np(&cond, &mutex, &abstime);// restore the previous malloc loggermalloc_logger = old_malloc_logger;MOZ_ASSERT(r == ETIMEDOUT);r = pthread_mutex_unlock(&mutex);MOZ_ASSERT(r == 0);r = pthread_mutex_destroy(&mutex);MOZ_ASSERT(r == 0);r = pthread_cond_destroy(&cond);MOZ_ASSERT(r == 0); }static bool IsCriticalAddress(void* aPC) {return gCriticalAddress.mAddr == aPC; } #else static bool IsCriticalAddress(void* aPC) {return false; } // We still initialize gCriticalAddress.mInit so that this code behaves // the same on all platforms. Otherwise a failure to init would be visible // only on OS X. MFBT_API void StackWalkInitCriticalAddress() {gCriticalAddress.mInit = true; } #endif#if defined(_WIN32) && (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64)) // WIN32 x86 stack walking code#include <windows.h> #include <process.h> #include <stdio.h> #include <malloc.h> #include "mozilla/ArrayUtils.h"#include <imagehlp.h> // We need a way to know if we are building for WXP (or later), as if we are, we // need to use the newer 64-bit APIs. API_VERSION_NUMBER seems to fit the bill. // A value of 9 indicates we want to use the new APIs. #if API_VERSION_NUMBER < 9 #error Too old imagehlp.h #endifstruct WalkStackData {// Are we walking the stack of the calling thread? Note that we need to avoid// calling fprintf and friends if this is false, in order to avoid deadlocks.bool walkCallingThread;uint32_t skipFrames;HANDLE thread;HANDLE process;HANDLE eventStart;HANDLE eventEnd;void** pcs;uint32_t pc_size;uint32_t pc_count;uint32_t pc_max;void** sps;uint32_t sp_size;uint32_t sp_count;void* platformData; };DWORD gStackWalkThread; CRITICAL_SECTION gDbgHelpCS;// Routine to print an error message to standard error. static void PrintError(const char* aPrefix) {LPSTR lpMsgBuf;DWORD lastErr = GetLastError();FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,nullptr,lastErr,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language(LPSTR)&lpMsgBuf,0,nullptr);fprintf(stderr, "### ERROR: %s: %s",aPrefix, lpMsgBuf ? lpMsgBuf : "(null)\n");fflush(stderr);LocalFree(lpMsgBuf); }static unsigned int WINAPI WalkStackThread(void* aData);static bool EnsureWalkThreadReady() {static bool walkThreadReady = false;static HANDLE stackWalkThread = nullptr;static HANDLE readyEvent = nullptr;if (walkThreadReady) {return walkThreadReady;}if (!stackWalkThread) {readyEvent = ::CreateEvent(nullptr, FALSE /* auto-reset*/,FALSE /* initially non-signaled */,nullptr);if (!readyEvent) {PrintError("CreateEvent");return false;}unsigned int threadID;stackWalkThread = (HANDLE)_beginthreadex(nullptr, 0, WalkStackThread,(void*)readyEvent, 0, &threadID);if (!stackWalkThread) {PrintError("CreateThread");::CloseHandle(readyEvent);readyEvent = nullptr;return false;}gStackWalkThread = threadID;::CloseHandle(stackWalkThread);}MOZ_ASSERT((stackWalkThread && readyEvent) ||(!stackWalkThread && !readyEvent));// The thread was created. Try to wait an arbitrary amount of time (1 second// should be enough) for its event loop to start before posting events to it.DWORD waitRet = ::WaitForSingleObject(readyEvent, 1000);if (waitRet == WAIT_TIMEOUT) {// We get a timeout if we're called during static initialization because// the thread will only start executing after we return so it couldn't// have signalled the event. If that is the case, give up for now and// try again next time we're called.return false;}::CloseHandle(readyEvent);stackWalkThread = nullptr;readyEvent = nullptr;::InitializeCriticalSection(&gDbgHelpCS);return walkThreadReady = true; }static void WalkStackMain64(struct WalkStackData* aData) {// Get a context for the specified thread. CONTEXT context;if (!aData->platformData) {memset(&context, 0, sizeof(CONTEXT));context.ContextFlags = CONTEXT_FULL;if (!GetThreadContext(aData->thread, &context)) {if (aData->walkCallingThread) {PrintError("GetThreadContext");}return;}} else {context = *static_cast<CONTEXT*>(aData->platformData);}#if defined(_M_IX86) || defined(_M_IA64)// Setup initial stack frame to walk from. STACKFRAME64 frame64;memset(&frame64, 0, sizeof(frame64)); #ifdef _M_IX86frame64.AddrPC.Offset = context.Eip;frame64.AddrStack.Offset = context.Esp;frame64.AddrFrame.Offset = context.Ebp; #elif defined _M_IA64frame64.AddrPC.Offset = context.StIIP;frame64.AddrStack.Offset = context.SP;frame64.AddrFrame.Offset = context.RsBSP; #endifframe64.AddrPC.Mode = AddrModeFlat;frame64.AddrStack.Mode = AddrModeFlat;frame64.AddrFrame.Mode = AddrModeFlat;frame64.AddrReturn.Mode = AddrModeFlat; #endif// Skip our own stack walking frames.int skip = (aData->walkCallingThread ? 3 : 0) + aData->skipFrames;// Now walk the stack.while (true) {DWORD64 addr;DWORD64 spaddr;#if defined(_M_IX86) || defined(_M_IA64)// 32-bit frame unwinding.// Debug routines are not threadsafe, so grab the lock.EnterCriticalSection(&gDbgHelpCS);BOOL ok = StackWalk64( #if defined _M_IA64IMAGE_FILE_MACHINE_IA64, #elif defined _M_IX86IMAGE_FILE_MACHINE_I386, #endifaData->process,aData->thread,&frame64,&context,nullptr,SymFunctionTableAccess64, // function table access routineSymGetModuleBase64, // module base routine0);LeaveCriticalSection(&gDbgHelpCS);if (ok) {addr = frame64.AddrPC.Offset;spaddr = frame64.AddrStack.Offset;} else {addr = 0;spaddr = 0;if (aData->walkCallingThread) {PrintError("WalkStack64");}}if (!ok) {break;}#elif defined(_M_AMD64)// 64-bit frame unwinding.// Try to look up unwind metadata for the current function. ULONG64 imageBase;PRUNTIME_FUNCTION runtimeFunction =RtlLookupFunctionEntry(context.Rip, &imageBase, NULL);if (!runtimeFunction) {// Alas, this is probably a JIT frame, for which we don't generate unwind// info and so we have to give up.break;}PVOID dummyHandlerData;ULONG64 dummyEstablisherFrame;RtlVirtualUnwind(UNW_FLAG_NHANDLER,imageBase,context.Rip,runtimeFunction,&context,&dummyHandlerData,&dummyEstablisherFrame,nullptr);addr = context.Rip;spaddr = context.Rsp;#else #error "unknown platform" #endifif (addr == 0) {break;}if (skip-- > 0) {continue;}if (aData->pc_count < aData->pc_size) {aData->pcs[aData->pc_count] = (void*)addr;}++aData->pc_count;if (aData->sp_count < aData->sp_size) {aData->sps[aData->sp_count] = (void*)spaddr;}++aData->sp_count;if (aData->pc_max != 0 && aData->pc_count == aData->pc_max) {break;}#if defined(_M_IX86) || defined(_M_IA64)if (frame64.AddrReturn.Offset == 0) {break;} #endif} }static unsigned int WINAPI WalkStackThread(void* aData) {BOOL msgRet;MSG msg;// Call PeekMessage to force creation of a message queue so that// other threads can safely post events to us.::PeekMessage(&msg, nullptr, WM_USER, WM_USER, PM_NOREMOVE);// and tell the thread that created us that we're ready.HANDLE readyEvent = (HANDLE)aData;::SetEvent(readyEvent);while ((msgRet = ::GetMessage(&msg, (HWND)-1, 0, 0)) != 0) {if (msgRet == -1) {PrintError("GetMessage");} else {DWORD ret;struct WalkStackData* data = (WalkStackData*)msg.lParam;if (!data) {continue;}// Don't suspend the calling thread until it's waiting for// us; otherwise the number of frames on the stack could vary.ret = ::WaitForSingleObject(data->eventStart, INFINITE);if (ret != WAIT_OBJECT_0) {PrintError("WaitForSingleObject");}// Suspend the calling thread, dump his stack, and then resume him.// He's currently waiting for us to finish so now should be a good time.ret = ::SuspendThread(data->thread);if (ret == -1) {PrintError("ThreadSuspend");} else {WalkStackMain64(data);ret = ::ResumeThread(data->thread);if (ret == -1) {PrintError("ThreadResume");}}::SetEvent(data->eventEnd);}}return 0; }/*** Walk the stack, translating PC's found into strings and recording the* chain in aBuffer. For this to work properly, the DLLs must be rebased* so that the address in the file agrees with the address in memory.* Otherwise StackWalk will return FALSE when it hits a frame in a DLL* whose in memory address doesn't match its in-file address.*/MFBT_API bool MozStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, uintptr_t aThread,void* aPlatformData) {StackWalkInitCriticalAddress();static HANDLE myProcess = nullptr;HANDLE myThread;DWORD walkerReturn;struct WalkStackData data;if (!EnsureWalkThreadReady()) {return false;}HANDLE currentThread = ::GetCurrentThread();HANDLE targetThread =aThread ? reinterpret_cast<HANDLE>(aThread) : currentThread;data.walkCallingThread = (targetThread == currentThread);// Have to duplicate handle to get a real handle.if (!myProcess) {if (!::DuplicateHandle(::GetCurrentProcess(),::GetCurrentProcess(),::GetCurrentProcess(),&myProcess,PROCESS_ALL_ACCESS, FALSE, 0)) {if (data.walkCallingThread) {PrintError("DuplicateHandle (process)");}return false;}}if (!::DuplicateHandle(::GetCurrentProcess(),targetThread,::GetCurrentProcess(),&myThread,THREAD_ALL_ACCESS, FALSE, 0)) {if (data.walkCallingThread) {PrintError("DuplicateHandle (thread)");}return false;}data.skipFrames = aSkipFrames;data.thread = myThread;data.process = myProcess;void* local_pcs[1024];data.pcs = local_pcs;data.pc_count = 0;data.pc_size = ArrayLength(local_pcs);data.pc_max = aMaxFrames;void* local_sps[1024];data.sps = local_sps;data.sp_count = 0;data.sp_size = ArrayLength(local_sps);data.platformData = aPlatformData;if (aThread) {// If we're walking the stack of another thread, we don't need to// use a separate walker thread.WalkStackMain64(&data);if (data.pc_count > data.pc_size) {data.pcs = (void**)_alloca(data.pc_count * sizeof(void*));data.pc_size = data.pc_count;data.pc_count = 0;data.sps = (void**)_alloca(data.sp_count * sizeof(void*));data.sp_size = data.sp_count;data.sp_count = 0;WalkStackMain64(&data);}} else {data.eventStart = ::CreateEvent(nullptr, FALSE /* auto-reset*/,FALSE /* initially non-signaled */, nullptr);data.eventEnd = ::CreateEvent(nullptr, FALSE /* auto-reset*/,FALSE /* initially non-signaled */, nullptr);::PostThreadMessage(gStackWalkThread, WM_USER, 0, (LPARAM)&data);walkerReturn = ::SignalObjectAndWait(data.eventStart,data.eventEnd, INFINITE, FALSE);if (walkerReturn != WAIT_OBJECT_0 && data.walkCallingThread) {PrintError("SignalObjectAndWait (1)");}if (data.pc_count > data.pc_size) {data.pcs = (void**)_alloca(data.pc_count * sizeof(void*));data.pc_size = data.pc_count;data.pc_count = 0;data.sps = (void**)_alloca(data.sp_count * sizeof(void*));data.sp_size = data.sp_count;data.sp_count = 0;::PostThreadMessage(gStackWalkThread, WM_USER, 0, (LPARAM)&data);walkerReturn = ::SignalObjectAndWait(data.eventStart,data.eventEnd, INFINITE, FALSE);if (walkerReturn != WAIT_OBJECT_0 && data.walkCallingThread) {PrintError("SignalObjectAndWait (2)");}}::CloseHandle(data.eventStart);::CloseHandle(data.eventEnd);}::CloseHandle(myThread);for (uint32_t i = 0; i < data.pc_count; ++i) {(*aCallback)(i + 1, data.pcs[i], data.sps[i], aClosure);}return data.pc_count != 0; }static BOOL CALLBACK callbackEspecial64(PCSTR aModuleName,DWORD64 aModuleBase,ULONG aModuleSize,PVOID aUserContext) {BOOL retval = TRUE;DWORD64 addr = *(DWORD64*)aUserContext;/** You'll want to control this if we are running on an* architecture where the addresses go the other direction.* Not sure this is even a realistic consideration.*/const BOOL addressIncreases = TRUE;/** If it falls in side the known range, load the symbols.*/if (addressIncreases? (addr >= aModuleBase && addr <= (aModuleBase + aModuleSize)): (addr <= aModuleBase && addr >= (aModuleBase - aModuleSize))) {retval = !!SymLoadModule64(GetCurrentProcess(), nullptr,(PSTR)aModuleName, nullptr,aModuleBase, aModuleSize);if (!retval) {PrintError("SymLoadModule64");}}return retval; }/** SymGetModuleInfoEspecial** Attempt to determine the module information.* Bug 112196 says this DLL may not have been loaded at the time* SymInitialize was called, and thus the module information* and symbol information is not available.* This code rectifies that problem.*/// New members were added to IMAGEHLP_MODULE64 (that show up in the // Platform SDK that ships with VC8, but not the Platform SDK that ships // with VC7.1, i.e., between DbgHelp 6.0 and 6.1), but we don't need to // use them, and it's useful to be able to function correctly with the // older library. (Stock Windows XP SP2 seems to ship with dbghelp.dll // version 5.1.) Since Platform SDK version need not correspond to // compiler version, and the version number in debughlp.h was NOT bumped // when these changes were made, ifdef based on a constant that was // added between these versions. #ifdef SSRVOPT_SETCONTEXT #define NS_IMAGEHLP_MODULE64_SIZE (((offsetof(IMAGEHLP_MODULE64, LoadedPdbName) + sizeof(DWORD64) - 1) / sizeof(DWORD64)) * sizeof(DWORD64)) #else #define NS_IMAGEHLP_MODULE64_SIZE sizeof(IMAGEHLP_MODULE64) #endifBOOL SymGetModuleInfoEspecial64(HANDLE aProcess, DWORD64 aAddr,PIMAGEHLP_MODULE64 aModuleInfo,PIMAGEHLP_LINE64 aLineInfo) {BOOL retval = FALSE;/** Init the vars if we have em.*/aModuleInfo->SizeOfStruct = NS_IMAGEHLP_MODULE64_SIZE;if (aLineInfo) {aLineInfo->SizeOfStruct = sizeof(IMAGEHLP_LINE64);}/** Give it a go.* It may already be loaded.*/retval = SymGetModuleInfo64(aProcess, aAddr, aModuleInfo);if (retval == FALSE) {/** Not loaded, here's the magic.* Go through all the modules.*/// Need to cast to PENUMLOADED_MODULES_CALLBACK64 because the// constness of the first parameter of// PENUMLOADED_MODULES_CALLBACK64 varies over SDK versions (from// non-const to const over time). See bug 391848 and bug// 415426.BOOL enumRes = EnumerateLoadedModules64(aProcess,(PENUMLOADED_MODULES_CALLBACK64)callbackEspecial64,(PVOID)&aAddr);if (enumRes != FALSE) {/** One final go.* If it fails, then well, we have other problems.*/retval = SymGetModuleInfo64(aProcess, aAddr, aModuleInfo);}}/** If we got module info, we may attempt line info as well.* We will not report failure if this does not work.*/if (retval != FALSE && aLineInfo) {DWORD displacement = 0;BOOL lineRes = FALSE;lineRes = SymGetLineFromAddr64(aProcess, aAddr, &displacement, aLineInfo);if (!lineRes) {// Clear out aLineInfo to indicate that it's not validmemset(aLineInfo, 0, sizeof(*aLineInfo));}}return retval; }static bool EnsureSymInitialized() {static bool gInitialized = false;bool retStat;if (gInitialized) {return gInitialized;}if (!EnsureWalkThreadReady()) {return false;}SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME);retStat = SymInitialize(GetCurrentProcess(), nullptr, TRUE);if (!retStat) {PrintError("SymInitialize");}gInitialized = retStat;/* XXX At some point we need to arrange to call SymCleanup */return retStat; }MFBT_API bool MozDescribeCodeAddress(void* aPC, MozCodeAddressDetails* aDetails) {aDetails->library[0] = '\0';aDetails->loffset = 0;aDetails->filename[0] = '\0';aDetails->lineno = 0;aDetails->function[0] = '\0';aDetails->foffset = 0;if (!EnsureSymInitialized()) {return false;}HANDLE myProcess = ::GetCurrentProcess();BOOL ok;// debug routines are not threadsafe, so grab the lock.EnterCriticalSection(&gDbgHelpCS);//// Attempt to load module info before we attempt to resolve the symbol.// This just makes sure we get good info if available.// DWORD64 addr = (DWORD64)aPC;IMAGEHLP_MODULE64 modInfo;IMAGEHLP_LINE64 lineInfo;BOOL modInfoRes;modInfoRes = SymGetModuleInfoEspecial64(myProcess, addr, &modInfo, &lineInfo);if (modInfoRes) {strncpy(aDetails->library, modInfo.LoadedImageName,sizeof(aDetails->library));aDetails->library[mozilla::ArrayLength(aDetails->library) - 1] = '\0';aDetails->loffset = (char*)aPC - (char*)modInfo.BaseOfImage;if (lineInfo.FileName) {strncpy(aDetails->filename, lineInfo.FileName,sizeof(aDetails->filename));aDetails->filename[mozilla::ArrayLength(aDetails->filename) - 1] = '\0';aDetails->lineno = lineInfo.LineNumber;}}ULONG64 buffer[(sizeof(SYMBOL_INFO) +MAX_SYM_NAME * sizeof(TCHAR) + sizeof(ULONG64) - 1) / sizeof(ULONG64)];PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);pSymbol->MaxNameLen = MAX_SYM_NAME;DWORD64 displacement;ok = SymFromAddr(myProcess, addr, &displacement, pSymbol);if (ok) {strncpy(aDetails->function, pSymbol->Name,sizeof(aDetails->function));aDetails->function[mozilla::ArrayLength(aDetails->function) - 1] = '\0';aDetails->foffset = static_cast<ptrdiff_t>(displacement);}LeaveCriticalSection(&gDbgHelpCS); // release our lockreturn true; }// i386 or PPC Linux stackwalking code #elif HAVE_DLADDR && (HAVE__UNWIND_BACKTRACE || MOZ_STACKWALK_SUPPORTS_LINUX || MOZ_STACKWALK_SUPPORTS_MACOSX)#include <stdlib.h> #include <string.h> #include <stdio.h>// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed // if __USE_GNU is defined. I suppose its some kind of standards // adherence thing. // #if (__GLIBC_MINOR__ >= 1) && !defined(__USE_GNU) #define __USE_GNU #endif// This thing is exported by libstdc++ // Yes, this is a gcc only hack #if defined(MOZ_DEMANGLE_SYMBOLS) #include <cxxabi.h> #endif // MOZ_DEMANGLE_SYMBOLSvoid DemangleSymbol(const char* aSymbol,char* aBuffer,int aBufLen) {aBuffer[0] = '\0';#if defined(MOZ_DEMANGLE_SYMBOLS)/* See demangle.h in the gcc source for the voodoo */char* demangled = abi::__cxa_demangle(aSymbol, 0, 0, 0);if (demangled) {strncpy(aBuffer, demangled, aBufLen);aBuffer[aBufLen - 1] = '\0';free(demangled);} #endif // MOZ_DEMANGLE_SYMBOLS }// {x86, ppc} x {Linux, Mac} stackwalking code. #if ((defined(__i386) || defined(PPC) || defined(__ppc__)) && \(MOZ_STACKWALK_SUPPORTS_MACOSX || MOZ_STACKWALK_SUPPORTS_LINUX))MFBT_API bool MozStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, uintptr_t aThread,void* aPlatformData) {MOZ_ASSERT(!aThread);MOZ_ASSERT(!aPlatformData);StackWalkInitCriticalAddress();// Get the frame pointervoid** bp = (void**)__builtin_frame_address(0);void* stackEnd; #if HAVE___LIBC_STACK_ENDstackEnd = __libc_stack_end; #elif defined(XP_DARWIN)stackEnd = pthread_get_stackaddr_np(pthread_self()); #elif defined(ANDROID)pthread_attr_t sattr;pthread_attr_init(&sattr);pthread_getattr_np(pthread_self(), &sattr);void* stackBase = stackEnd = nullptr;size_t stackSize = 0;if (gettid() != getpid()) {// bionic's pthread_attr_getstack doesn't tell the truth for the main// thread (see bug 846670). So don't use it for the main thread.if (!pthread_attr_getstack(&sattr, &stackBase, &stackSize)) {stackEnd = static_cast<char*>(stackBase) + stackSize;} else {stackEnd = nullptr;}}if (!stackEnd) {// So consider the current frame pointer + an arbitrary size of 8MB// (modulo overflow ; not really arbitrary as it's the default stack// size for the main thread) if pthread_attr_getstack failed for// some reason (or was skipped).static const uintptr_t kMaxStackSize = 8 * 1024 * 1024;uintptr_t maxStackStart = uintptr_t(-1) - kMaxStackSize;uintptr_t stackStart = std::max(maxStackStart, uintptr_t(bp));stackEnd = reinterpret_cast<void*>(stackStart + kMaxStackSize);} #else # error Unsupported configuration #endifreturn FramePointerStackWalk(aCallback, aSkipFrames, aMaxFrames,aClosure, bp, stackEnd); }#elif defined(HAVE__UNWIND_BACKTRACE)// libgcc_s.so symbols _Unwind_Backtrace@@GCC_3.3 and _Unwind_GetIP@@GCC_3.0 #include <unwind.h>struct unwind_info {MozWalkStackCallback callback;int skip;int maxFrames;int numFrames;bool isCriticalAbort;void* closure; };static _Unwind_Reason_Code unwind_callback(struct _Unwind_Context* context, void* closure) {unwind_info* info = static_cast<unwind_info*>(closure);void* pc = reinterpret_cast<void*>(_Unwind_GetIP(context));// TODO Use something like '_Unwind_GetGR()' to get the stack pointer.if (IsCriticalAddress(pc)) {info->isCriticalAbort = true;// We just want to stop the walk, so any error code will do. Using// _URC_NORMAL_STOP would probably be the most accurate, but it is not// defined on Android for ARM.return _URC_FOREIGN_EXCEPTION_CAUGHT;}if (--info->skip < 0) {info->numFrames++;(*info->callback)(info->numFrames, pc, nullptr, info->closure);if (info->maxFrames != 0 && info->numFrames == info->maxFrames) {// Again, any error code that stops the walk will do.return _URC_FOREIGN_EXCEPTION_CAUGHT;}}return _URC_NO_REASON; }MFBT_API bool MozStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, uintptr_t aThread,void* aPlatformData) {MOZ_ASSERT(!aThread);MOZ_ASSERT(!aPlatformData);StackWalkInitCriticalAddress();unwind_info info;info.callback = aCallback;info.skip = aSkipFrames + 1;info.maxFrames = aMaxFrames;info.numFrames = 0;info.isCriticalAbort = false;info.closure = aClosure;(void)_Unwind_Backtrace(unwind_callback, &info);// We ignore the return value from _Unwind_Backtrace and instead determine// the outcome from |info|. There are two main reasons for this:// - On ARM/Android bionic's _Unwind_Backtrace usually (always?) returns// _URC_FAILURE. See// https://bugzilla.mozilla.org/show_bug.cgi?id=717853#c110.// - If aMaxFrames != 0, we want to stop early, and the only way to do that// is to make unwind_callback return something other than _URC_NO_REASON,// which causes _Unwind_Backtrace to return a non-success code.if (info.isCriticalAbort) {return false;}return info.numFrames != 0; }#endifbool MFBT_API MozDescribeCodeAddress(void* aPC, MozCodeAddressDetails* aDetails) {aDetails->library[0] = '\0';aDetails->loffset = 0;aDetails->filename[0] = '\0';aDetails->lineno = 0;aDetails->function[0] = '\0';aDetails->foffset = 0;Dl_info info;int ok = dladdr(aPC, &info);if (!ok) {return true;}strncpy(aDetails->library, info.dli_fname, sizeof(aDetails->library));aDetails->library[mozilla::ArrayLength(aDetails->library) - 1] = '\0';aDetails->loffset = (char*)aPC - (char*)info.dli_fbase;const char* symbol = info.dli_sname;if (!symbol || symbol[0] == '\0') {return true;}DemangleSymbol(symbol, aDetails->function, sizeof(aDetails->function));if (aDetails->function[0] == '\0') {// Just use the mangled symbol if demangling failed.strncpy(aDetails->function, symbol, sizeof(aDetails->function));aDetails->function[mozilla::ArrayLength(aDetails->function) - 1] = '\0';}aDetails->foffset = (char*)aPC - (char*)info.dli_saddr;return true; }#else // unsupported platform.MFBT_API bool MozStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, uintptr_t aThread,void* aPlatformData) {MOZ_ASSERT(!aThread);MOZ_ASSERT(!aPlatformData);return false; }MFBT_API bool MozDescribeCodeAddress(void* aPC, MozCodeAddressDetails* aDetails) {aDetails->library[0] = '\0';aDetails->loffset = 0;aDetails->filename[0] = '\0';aDetails->lineno = 0;aDetails->function[0] = '\0';aDetails->foffset = 0;return false; }#endif#if defined(XP_WIN) || defined (XP_MACOSX) || defined (XP_LINUX) namespace mozilla { bool FramePointerStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, void** bp,void* aStackEnd) {// Stack walking code courtesy Kipp's "leaky". int32_t skip = aSkipFrames;uint32_t numFrames = 0;while (bp) {void** next = (void**)*bp;// bp may not be a frame pointer on i386 if code was compiled with// -fomit-frame-pointer, so do some sanity checks.// (bp should be a frame pointer on ppc(64) but checking anyway may help// a little if the stack has been corrupted.)// We don't need to check against the begining of the stack because// we can assume that bp > spif (next <= bp ||next > aStackEnd ||(uintptr_t(next) & 3)) {break;} #if (defined(__ppc__) && defined(XP_MACOSX)) || defined(__powerpc64__)// ppc mac or powerpc64 linuxvoid* pc = *(bp + 2);bp += 3; #else // i386 or powerpc32 linuxvoid* pc = *(bp + 1);bp += 2; #endifif (IsCriticalAddress(pc)) {return false;}if (--skip < 0) {// Assume that the SP points to the BP of the function// it called. We can't know the exact location of the SP// but this should be sufficient for our use the SP// to order elements on the stack.numFrames++;(*aCallback)(numFrames, pc, bp, aClosure);if (aMaxFrames != 0 && numFrames == aMaxFrames) {break;}}bp = next;}return numFrames != 0; } } // namespace mozilla#elsenamespace mozilla { MFBT_API bool FramePointerStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,void* aClosure, void** aBp) {return false; } }#endifMFBT_API void MozFormatCodeAddressDetails(char* aBuffer, uint32_t aBufferSize,uint32_t aFrameNumber, void* aPC,const MozCodeAddressDetails* aDetails) {MozFormatCodeAddress(aBuffer, aBufferSize,aFrameNumber, aPC, aDetails->function,aDetails->library, aDetails->loffset,aDetails->filename, aDetails->lineno); }MFBT_API void MozFormatCodeAddress(char* aBuffer, uint32_t aBufferSize, uint32_t aFrameNumber,const void* aPC, const char* aFunction,const char* aLibrary, ptrdiff_t aLOffset,const char* aFileName, uint32_t aLineNo) {const char* function = aFunction && aFunction[0] ? aFunction : "???";if (aFileName && aFileName[0]) {// We have a filename and (presumably) a line number. Use them. snprintf(aBuffer, aBufferSize,"#%02u: %s (%s:%u)",aFrameNumber, function, aFileName, aLineNo);} else if (aLibrary && aLibrary[0]) {// We have no filename, but we do have a library name. Use it and the// library offset, and print them in a way that scripts like// fix_{linux,macosx}_stacks.py can easily post-process. snprintf(aBuffer, aBufferSize,"#%02u: %s[%s +0x%" PRIxPTR "]",aFrameNumber, function, aLibrary, static_cast<uintptr_t>(aLOffset));} else {// We have nothing useful to go on. (The format string is split because// '??)' is a trigraph and causes a warning, sigh.) snprintf(aBuffer, aBufferSize,"#%02u: ??? (???:???" ")",aFrameNumber);} } StackWalk.cpp /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public* License, v. 2.0. If a copy of the MPL was not distributed with this* file, You can obtain one at http://mozilla.org/MPL/2.0/. *//* API for getting a stack trace of the C/C++ stack on the current thread */#ifndef mozilla_StackWalk_h #define mozilla_StackWalk_h/* WARNING: This file is intended to be included from C or C++ files. */#include "mozilla/Types.h" #include <stdint.h>/*** The callback for MozStackWalk.** @param aFrameNumber The frame number (starts at 1, not 0).* @param aPC The program counter value.* @param aSP The best approximation possible of what the stack* pointer will be pointing to when the execution returns* to executing that at aPC. If no approximation can* be made it will be nullptr.* @param aClosure Extra data passed in via MozStackWalk().*/ typedef void (*MozWalkStackCallback)(uint32_t aFrameNumber, void* aPC, void* aSP,void* aClosure);/*** Call aCallback for the C/C++ stack frames on the current thread, from* the caller of MozStackWalk to main (or above).** @param aCallback Callback function, called once per frame.* @param aSkipFrames Number of initial frames to skip. 0 means that* the first callback will be for the caller of* MozStackWalk.* @param aMaxFrames Maximum number of frames to trace. 0 means no limit.* @param aClosure Caller-supplied data passed through to aCallback.* @param aThread The thread for which the stack is to be retrieved.* Passing null causes us to walk the stack of the* current thread. On Windows, this is a thread HANDLE.* It is currently not supported on any other platform.* @param aPlatformData Platform specific data that can help in walking the* stack, this should be nullptr unless you really know* what you're doing! This needs to be a pointer to a* CONTEXT on Windows and should not be passed on other* platforms.** May skip some stack frames due to compiler optimizations or code* generation.** Note: this (and other helper methods) will only be available when* MOZ_STACKWALKING is defined, so any new consumers must #if based on that.*/ MFBT_API bool MozStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, uintptr_t aThread,void* aPlatformData);typedef struct {/** The name of the shared library or executable containing an* address and the address's offset within that library, or empty* string and zero if unknown.*/char library[256];ptrdiff_t loffset;/** The name of the file name and line number of the code* corresponding to the address, or empty string and zero if* unknown.*/char filename[256];unsigned long lineno;/** The name of the function containing an address and the address's* offset within that function, or empty string and zero if unknown.*/char function[256];ptrdiff_t foffset; } MozCodeAddressDetails;/*** For a given pointer to code, fill in the pieces of information used* when printing a stack trace.** @param aPC The code address.* @param aDetails A structure to be filled in with the result.*/ MFBT_API bool MozDescribeCodeAddress(void* aPC, MozCodeAddressDetails* aDetails);/*** Format the information about a code address in a format suitable for* stack traces on the current platform. When available, this string* should contain the function name, source file, and line number. When* these are not available, library and offset should be reported, if* possible.** Note that this output is parsed by several scripts including the fix*.py and* make-tree.pl scripts in tools/rb/. It should only be change with care, and* in conjunction with those scripts.** @param aBuffer A string to be filled in with the description.* The string will always be null-terminated.* @param aBufferSize The size, in bytes, of aBuffer, including* room for the terminating null. If the information* to be printed would be larger than aBuffer, it* will be truncated so that aBuffer[aBufferSize-1]* is the terminating null.* @param aFrameNumber The frame number.* @param aPC The code address.* @param aFunction The function name. Possibly null or the empty string.* @param aLibrary The library name. Possibly null or the empty string.* @param aLOffset The library offset.* @param aFileName The filename. Possibly null or the empty string.* @param aLineNo The line number. Possibly zero.*/ MFBT_API void MozFormatCodeAddress(char* aBuffer, uint32_t aBufferSize, uint32_t aFrameNumber,const void* aPC, const char* aFunction,const char* aLibrary, ptrdiff_t aLOffset,const char* aFileName, uint32_t aLineNo);/*** Format the information about a code address in the same fashion as* MozFormatCodeAddress.** @param aBuffer A string to be filled in with the description.* The string will always be null-terminated.* @param aBufferSize The size, in bytes, of aBuffer, including* room for the terminating null. If the information* to be printed would be larger than aBuffer, it* will be truncated so that aBuffer[aBufferSize-1]* is the terminating null.* @param aFrameNumber The frame number.* @param aPC The code address.* @param aDetails The value filled in by MozDescribeCodeAddress(aPC).*/ MFBT_API void MozFormatCodeAddressDetails(char* aBuffer, uint32_t aBufferSize,uint32_t aFrameNumber, void* aPC,const MozCodeAddressDetails* aDetails);namespace mozilla {MFBT_API bool FramePointerStackWalk(MozWalkStackCallback aCallback, uint32_t aSkipFrames,uint32_t aMaxFrames, void* aClosure, void** aBp,void* aStackEnd);} // namespace mozilla/*** Initialize the critical sections for this platform so that we can* abort stack walks when needed.*/ MFBT_API void StackWalkInitCriticalAddress(void);#endif StackWalk.h

?

posted on 2017-06-23 15:36?DeanWang 閱讀(...) 評論(...) 編輯 收藏

轉載于:https://www.cnblogs.com/DeanWang/p/6280106.html

總結

以上是生活随笔為你收集整理的《memory leak： stackwalk》的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。