169 lines
4.9 KiB
C++
169 lines
4.9 KiB
C++
/**
|
|
* @file llstacktrace.cpp
|
|
* @brief stack tracing functionality
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "linden_common.h"
|
|
#include "llstacktrace.h"
|
|
|
|
#ifdef LL_WINDOWS
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
#include "llwin32headerslean.h"
|
|
#pragma warning (push)
|
|
#pragma warning (disable:4091) // a microsoft header has warnings. Very nice.
|
|
#include <dbghelp.h>
|
|
#pragma warning (pop)
|
|
|
|
typedef USHORT NTAPI RtlCaptureStackBackTrace_Function(
|
|
IN ULONG frames_to_skip,
|
|
IN ULONG frames_to_capture,
|
|
OUT PVOID *backtrace,
|
|
OUT PULONG backtrace_hash);
|
|
|
|
static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
|
|
(RtlCaptureStackBackTrace_Function*)
|
|
GetProcAddress(GetModuleHandleA("ntdll.dll"), "RtlCaptureStackBackTrace");
|
|
|
|
bool ll_get_stack_trace(std::vector<std::string>& lines)
|
|
{
|
|
const S32 MAX_STACK_DEPTH = 32;
|
|
const S32 STRING_NAME_LENGTH = 200;
|
|
const S32 FRAME_SKIP = 2;
|
|
static BOOL symbolsLoaded = false;
|
|
static BOOL firstCall = true;
|
|
|
|
HANDLE hProc = GetCurrentProcess();
|
|
|
|
// load the symbols if they're not loaded
|
|
if(!symbolsLoaded && firstCall)
|
|
{
|
|
symbolsLoaded = SymInitialize(hProc, NULL, true);
|
|
firstCall = false;
|
|
}
|
|
|
|
// if loaded, get the call stack
|
|
if(symbolsLoaded)
|
|
{
|
|
// create the frames to hold the addresses
|
|
void* frames[MAX_STACK_DEPTH];
|
|
memset(frames, 0, sizeof(void*)*MAX_STACK_DEPTH);
|
|
S32 depth = 0;
|
|
|
|
// get the addresses
|
|
depth = RtlCaptureStackBackTrace_fn(FRAME_SKIP, MAX_STACK_DEPTH, frames, NULL);
|
|
|
|
IMAGEHLP_LINE64 line;
|
|
memset(&line, 0, sizeof(IMAGEHLP_LINE64));
|
|
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
|
|
|
// create something to hold address info
|
|
PIMAGEHLP_SYMBOL64 pSym;
|
|
pSym = (PIMAGEHLP_SYMBOL64)malloc(sizeof(IMAGEHLP_SYMBOL64) + STRING_NAME_LENGTH);
|
|
memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + STRING_NAME_LENGTH);
|
|
pSym->MaxNameLength = STRING_NAME_LENGTH;
|
|
pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
|
|
|
|
// get address info for each address frame
|
|
// and store
|
|
for(S32 i=0; i < depth; i++)
|
|
{
|
|
std::stringstream stack_line;
|
|
BOOL ret;
|
|
|
|
DWORD64 addr = (DWORD64)frames[i];
|
|
ret = SymGetSymFromAddr64(hProc, addr, 0, pSym);
|
|
if(ret)
|
|
{
|
|
stack_line << pSym->Name << " ";
|
|
}
|
|
|
|
DWORD dummy;
|
|
ret = SymGetLineFromAddr64(hProc, addr, &dummy, &line);
|
|
if(ret)
|
|
{
|
|
std::string file_name = line.FileName;
|
|
std::string::size_type index = file_name.rfind("\\");
|
|
stack_line << file_name.substr(index + 1, file_name.size()) << ":" << line.LineNumber;
|
|
}
|
|
|
|
lines.push_back(stack_line.str());
|
|
}
|
|
|
|
free(pSym);
|
|
|
|
// TODO: figure out a way to cleanup symbol loading
|
|
// Not hugely necessary, however.
|
|
//SymCleanup(hProc);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
lines.push_back("Stack Trace Failed. PDB symbol info not loaded");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ll_get_stack_trace_internal(std::vector<std::string>& lines)
|
|
{
|
|
const S32 MAX_STACK_DEPTH = 100;
|
|
const S32 STRING_NAME_LENGTH = 256;
|
|
|
|
HANDLE process = GetCurrentProcess();
|
|
SymInitialize( process, NULL, TRUE );
|
|
|
|
void *stack[MAX_STACK_DEPTH];
|
|
|
|
unsigned short frames = RtlCaptureStackBackTrace_fn( 0, MAX_STACK_DEPTH, stack, NULL );
|
|
SYMBOL_INFO *symbol = (SYMBOL_INFO*)calloc(sizeof(SYMBOL_INFO) + STRING_NAME_LENGTH * sizeof(char), 1);
|
|
symbol->MaxNameLen = STRING_NAME_LENGTH-1;
|
|
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
|
|
|
|
for(unsigned int i = 0; i < frames; i++)
|
|
{
|
|
SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);
|
|
lines.push_back(symbol->Name);
|
|
}
|
|
|
|
free( symbol );
|
|
}
|
|
|
|
#else
|
|
|
|
bool ll_get_stack_trace(std::vector<std::string>& lines)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void ll_get_stack_trace_internal(std::vector<std::string>& lines)
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|