305 lines
11 KiB
C++
305 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code 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 General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
#include "precompiled.hpp"
|
|
#include "utilities/ostream.hpp"
|
|
#include "windbghelp.hpp"
|
|
|
|
#include <windows.h>
|
|
|
|
typedef DWORD (WINAPI *pfn_SymSetOptions)(DWORD);
|
|
typedef DWORD (WINAPI *pfn_SymGetOptions)(void);
|
|
typedef BOOL (WINAPI *pfn_SymInitialize)(HANDLE, PCTSTR, BOOL);
|
|
typedef BOOL (WINAPI *pfn_SymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
|
|
typedef DWORD (WINAPI *pfn_UnDecorateSymbolName)(const char*, char*, DWORD, DWORD);
|
|
typedef BOOL (WINAPI *pfn_SymSetSearchPath)(HANDLE, PCTSTR);
|
|
typedef BOOL (WINAPI *pfn_SymGetSearchPath)(HANDLE, PTSTR, int);
|
|
typedef BOOL (WINAPI *pfn_StackWalk64)(DWORD MachineType,
|
|
HANDLE hProcess,
|
|
HANDLE hThread,
|
|
LPSTACKFRAME64 StackFrame,
|
|
PVOID ContextRecord,
|
|
PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
|
|
PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
|
|
PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
|
|
PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
|
|
typedef PVOID (WINAPI *pfn_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
|
|
typedef DWORD64 (WINAPI *pfn_SymGetModuleBase64)(HANDLE hProcess, DWORD64 dwAddr);
|
|
typedef BOOL (WINAPI *pfn_MiniDumpWriteDump) (HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
|
|
MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
|
|
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
|
|
PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
|
|
typedef BOOL (WINAPI *pfn_SymGetLineFromAddr64) (HANDLE hProcess, DWORD64 dwAddr,
|
|
PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line);
|
|
typedef LPAPI_VERSION (WINAPI *pfn_ImagehlpApiVersion)(void);
|
|
|
|
// Add functions as needed.
|
|
#define FOR_ALL_FUNCTIONS(DO) \
|
|
DO(ImagehlpApiVersion) \
|
|
DO(SymGetOptions) \
|
|
DO(SymSetOptions) \
|
|
DO(SymInitialize) \
|
|
DO(SymGetSymFromAddr64) \
|
|
DO(UnDecorateSymbolName) \
|
|
DO(SymSetSearchPath) \
|
|
DO(SymGetSearchPath) \
|
|
DO(StackWalk64) \
|
|
DO(SymFunctionTableAccess64) \
|
|
DO(SymGetModuleBase64) \
|
|
DO(MiniDumpWriteDump) \
|
|
DO(SymGetLineFromAddr64)
|
|
|
|
|
|
#define DECLARE_FUNCTION_POINTER(functionname) \
|
|
static pfn_##functionname g_pfn_##functionname;
|
|
|
|
FOR_ALL_FUNCTIONS(DECLARE_FUNCTION_POINTER)
|
|
|
|
|
|
static HMODULE g_dll_handle = NULL;
|
|
static DWORD g_dll_load_error = 0;
|
|
static API_VERSION g_version = { 0, 0, 0, 0 };
|
|
|
|
static enum {
|
|
state_uninitialized = 0,
|
|
state_ready = 1,
|
|
state_error = 2
|
|
} g_state = state_uninitialized;
|
|
|
|
static void initialize() {
|
|
|
|
assert(g_state == state_uninitialized, "wrong sequence");
|
|
g_state = state_error;
|
|
|
|
g_dll_handle = ::LoadLibrary("DBGHELP.DLL");
|
|
if (g_dll_handle == NULL) {
|
|
g_dll_load_error = ::GetLastError();
|
|
} else {
|
|
// Note: We loaded the DLL successfully. From here on we count
|
|
// initialization as success. We still may fail to load all of the
|
|
// desired function pointers successfully, but DLL may still be usable
|
|
// enough for our purposes.
|
|
g_state = state_ready;
|
|
|
|
#define DO_RESOLVE(functionname) \
|
|
g_pfn_##functionname = (pfn_##functionname) ::GetProcAddress(g_dll_handle, #functionname);
|
|
|
|
FOR_ALL_FUNCTIONS(DO_RESOLVE)
|
|
|
|
// Retrieve version information.
|
|
if (g_pfn_ImagehlpApiVersion) {
|
|
const API_VERSION* p = g_pfn_ImagehlpApiVersion();
|
|
memcpy(&g_version, p, sizeof(API_VERSION));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////// External functions //////////////////////////
|
|
|
|
// All outside facing functions are synchronized. Also, we run
|
|
// initialization on first touch.
|
|
|
|
static CRITICAL_SECTION g_cs;
|
|
|
|
namespace { // Do not export.
|
|
class WindowsDbgHelpEntry {
|
|
public:
|
|
WindowsDbgHelpEntry() {
|
|
::EnterCriticalSection(&g_cs);
|
|
if (g_state == state_uninitialized) {
|
|
initialize();
|
|
}
|
|
}
|
|
~WindowsDbgHelpEntry() {
|
|
::LeaveCriticalSection(&g_cs);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Called at DLL_PROCESS_ATTACH.
|
|
void WindowsDbgHelp::pre_initialize() {
|
|
::InitializeCriticalSection(&g_cs);
|
|
}
|
|
|
|
DWORD WindowsDbgHelp::symSetOptions(DWORD arg) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymSetOptions != NULL) {
|
|
return g_pfn_SymSetOptions(arg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
DWORD WindowsDbgHelp::symGetOptions(void) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymGetOptions != NULL) {
|
|
return g_pfn_SymGetOptions();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::symInitialize(HANDLE hProcess, PCTSTR UserSearchPath, BOOL fInvadeProcess) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymInitialize != NULL) {
|
|
return g_pfn_SymInitialize(hProcess, UserSearchPath, fInvadeProcess);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::symGetSymFromAddr64(HANDLE hProcess, DWORD64 the_address,
|
|
PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymGetSymFromAddr64 != NULL) {
|
|
return g_pfn_SymGetSymFromAddr64(hProcess, the_address, Displacement, Symbol);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD WindowsDbgHelp::unDecorateSymbolName(const char* DecoratedName, char* UnDecoratedName,
|
|
DWORD UndecoratedLength, DWORD Flags) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_UnDecorateSymbolName != NULL) {
|
|
return g_pfn_UnDecorateSymbolName(DecoratedName, UnDecoratedName, UndecoratedLength, Flags);
|
|
}
|
|
if (UnDecoratedName != NULL && UndecoratedLength > 0) {
|
|
UnDecoratedName[0] = '\0';
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::symSetSearchPath(HANDLE hProcess, PCTSTR SearchPath) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymSetSearchPath != NULL) {
|
|
return g_pfn_SymSetSearchPath(hProcess, SearchPath);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::symGetSearchPath(HANDLE hProcess, PTSTR SearchPath, int SearchPathLength) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymGetSearchPath != NULL) {
|
|
return g_pfn_SymGetSearchPath(hProcess, SearchPath, SearchPathLength);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::stackWalk64(DWORD MachineType,
|
|
HANDLE hProcess,
|
|
HANDLE hThread,
|
|
LPSTACKFRAME64 StackFrame,
|
|
PVOID ContextRecord) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_StackWalk64 != NULL) {
|
|
return g_pfn_StackWalk64(MachineType, hProcess, hThread, StackFrame,
|
|
ContextRecord,
|
|
NULL, // ReadMemoryRoutine
|
|
g_pfn_SymFunctionTableAccess64, // FunctionTableAccessRoutine,
|
|
g_pfn_SymGetModuleBase64, // GetModuleBaseRoutine
|
|
NULL // TranslateAddressRoutine
|
|
);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
PVOID WindowsDbgHelp::symFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymFunctionTableAccess64 != NULL) {
|
|
return g_pfn_SymFunctionTableAccess64(hProcess, AddrBase);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
DWORD64 WindowsDbgHelp::symGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymGetModuleBase64 != NULL) {
|
|
return g_pfn_SymGetModuleBase64(hProcess, dwAddr);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::miniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
|
|
MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
|
|
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
|
|
PMINIDUMP_CALLBACK_INFORMATION CallbackParam) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_MiniDumpWriteDump != NULL) {
|
|
return g_pfn_MiniDumpWriteDump(hProcess, ProcessId, hFile, DumpType,
|
|
ExceptionParam, UserStreamParam, CallbackParam);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL WindowsDbgHelp::symGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
|
|
PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line) {
|
|
WindowsDbgHelpEntry entry_guard;
|
|
if (g_pfn_SymGetLineFromAddr64 != NULL) {
|
|
return g_pfn_SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, Line);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// Print one liner describing state (if library loaded, which functions are
|
|
// missing - if any, and the dbhelp API version)
|
|
void WindowsDbgHelp::print_state_on(outputStream* st) {
|
|
// Note: We should not lock while printing, but this should be
|
|
// safe to do without lock anyway.
|
|
st->print("dbghelp: ");
|
|
|
|
if (g_state == state_uninitialized) {
|
|
st->print("uninitialized.");
|
|
} else if (g_state == state_error) {
|
|
st->print("loading error: %u", g_dll_load_error);
|
|
} else {
|
|
st->print("loaded successfully ");
|
|
|
|
// We may want to print dll file name here - which may be interesting for
|
|
// cases where more than one version exists on the system, e.g. with a
|
|
// debugging sdk separately installed. But we get the file name in the DLL
|
|
// section of the hs-err file too, so this may be redundant.
|
|
|
|
// Print version.
|
|
st->print("- version: %u.%u.%u",
|
|
g_version.MajorVersion, g_version.MinorVersion, g_version.Revision);
|
|
|
|
// Print any functions which failed to load.
|
|
int num_missing = 0;
|
|
st->print(" - missing functions: ");
|
|
|
|
#define CHECK_AND_PRINT_IF_NULL(functionname) \
|
|
if (g_pfn_##functionname == NULL) { \
|
|
st->print("%s" #functionname, ((num_missing > 0) ? ", " : "")); \
|
|
num_missing ++; \
|
|
}
|
|
|
|
FOR_ALL_FUNCTIONS(CHECK_AND_PRINT_IF_NULL)
|
|
|
|
if (num_missing == 0) {
|
|
st->print("none");
|
|
}
|
|
}
|
|
st->cr();
|
|
}
|
|
|