47086
|
1 |
/*
|
|
2 |
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
|
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 |
*
|
|
5 |
* This code is free software; you can redistribute it and/or modify it
|
|
6 |
* under the terms of the GNU General Public License version 2 only, as
|
|
7 |
* published by the Free Software Foundation.
|
|
8 |
*
|
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that
|
|
13 |
* accompanied this code).
|
|
14 |
*
|
|
15 |
* You should have received a copy of the GNU General Public License version
|
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 |
*
|
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
20 |
* or visit www.oracle.com if you need additional information or have any
|
|
21 |
* questions.
|
|
22 |
*
|
|
23 |
*/
|
|
24 |
|
|
25 |
#include "precompiled.hpp"
|
|
26 |
#include "utilities/ostream.hpp"
|
|
27 |
#include "windbghelp.hpp"
|
|
28 |
|
|
29 |
#include <windows.h>
|
|
30 |
|
|
31 |
typedef DWORD (WINAPI *pfn_SymSetOptions)(DWORD);
|
|
32 |
typedef DWORD (WINAPI *pfn_SymGetOptions)(void);
|
|
33 |
typedef BOOL (WINAPI *pfn_SymInitialize)(HANDLE, PCTSTR, BOOL);
|
|
34 |
typedef BOOL (WINAPI *pfn_SymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
|
|
35 |
typedef DWORD (WINAPI *pfn_UnDecorateSymbolName)(const char*, char*, DWORD, DWORD);
|
|
36 |
typedef BOOL (WINAPI *pfn_SymSetSearchPath)(HANDLE, PCTSTR);
|
|
37 |
typedef BOOL (WINAPI *pfn_SymGetSearchPath)(HANDLE, PTSTR, int);
|
|
38 |
typedef BOOL (WINAPI *pfn_StackWalk64)(DWORD MachineType,
|
|
39 |
HANDLE hProcess,
|
|
40 |
HANDLE hThread,
|
|
41 |
LPSTACKFRAME64 StackFrame,
|
|
42 |
PVOID ContextRecord,
|
|
43 |
PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
|
|
44 |
PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
|
|
45 |
PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
|
|
46 |
PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
|
|
47 |
typedef PVOID (WINAPI *pfn_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
|
|
48 |
typedef DWORD64 (WINAPI *pfn_SymGetModuleBase64)(HANDLE hProcess, DWORD64 dwAddr);
|
|
49 |
typedef BOOL (WINAPI *pfn_MiniDumpWriteDump) (HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
|
|
50 |
MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
|
|
51 |
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
|
|
52 |
PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
|
|
53 |
typedef BOOL (WINAPI *pfn_SymGetLineFromAddr64) (HANDLE hProcess, DWORD64 dwAddr,
|
|
54 |
PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line);
|
|
55 |
typedef LPAPI_VERSION (WINAPI *pfn_ImagehlpApiVersion)(void);
|
|
56 |
|
|
57 |
// Add functions as needed.
|
|
58 |
#define FOR_ALL_FUNCTIONS(DO) \
|
|
59 |
DO(ImagehlpApiVersion) \
|
|
60 |
DO(SymGetOptions) \
|
|
61 |
DO(SymSetOptions) \
|
|
62 |
DO(SymInitialize) \
|
|
63 |
DO(SymGetSymFromAddr64) \
|
|
64 |
DO(UnDecorateSymbolName) \
|
|
65 |
DO(SymSetSearchPath) \
|
|
66 |
DO(SymGetSearchPath) \
|
|
67 |
DO(StackWalk64) \
|
|
68 |
DO(SymFunctionTableAccess64) \
|
|
69 |
DO(SymGetModuleBase64) \
|
|
70 |
DO(MiniDumpWriteDump) \
|
|
71 |
DO(SymGetLineFromAddr64)
|
|
72 |
|
|
73 |
|
|
74 |
#define DECLARE_FUNCTION_POINTER(functionname) \
|
|
75 |
static pfn_##functionname g_pfn_##functionname;
|
|
76 |
|
|
77 |
FOR_ALL_FUNCTIONS(DECLARE_FUNCTION_POINTER)
|
|
78 |
|
|
79 |
|
|
80 |
static HMODULE g_dll_handle = NULL;
|
|
81 |
static DWORD g_dll_load_error = 0;
|
|
82 |
static API_VERSION g_version = { 0, 0, 0, 0 };
|
|
83 |
|
|
84 |
static enum {
|
|
85 |
state_uninitialized = 0,
|
|
86 |
state_ready = 1,
|
|
87 |
state_error = 2
|
|
88 |
} g_state = state_uninitialized;
|
|
89 |
|
|
90 |
static void initialize() {
|
|
91 |
|
|
92 |
assert(g_state == state_uninitialized, "wrong sequence");
|
|
93 |
g_state = state_error;
|
|
94 |
|
|
95 |
g_dll_handle = ::LoadLibrary("DBGHELP.DLL");
|
|
96 |
if (g_dll_handle == NULL) {
|
|
97 |
g_dll_load_error = ::GetLastError();
|
|
98 |
} else {
|
|
99 |
// Note: We loaded the DLL successfully. From here on we count
|
|
100 |
// initialization as success. We still may fail to load all of the
|
|
101 |
// desired function pointers successfully, but DLL may still be usable
|
|
102 |
// enough for our purposes.
|
|
103 |
g_state = state_ready;
|
|
104 |
|
|
105 |
#define DO_RESOLVE(functionname) \
|
|
106 |
g_pfn_##functionname = (pfn_##functionname) ::GetProcAddress(g_dll_handle, #functionname);
|
|
107 |
|
|
108 |
FOR_ALL_FUNCTIONS(DO_RESOLVE)
|
|
109 |
|
|
110 |
// Retrieve version information.
|
|
111 |
if (g_pfn_ImagehlpApiVersion) {
|
|
112 |
const API_VERSION* p = g_pfn_ImagehlpApiVersion();
|
|
113 |
memcpy(&g_version, p, sizeof(API_VERSION));
|
|
114 |
}
|
|
115 |
}
|
|
116 |
|
|
117 |
}
|
|
118 |
|
|
119 |
///////////////////// External functions //////////////////////////
|
|
120 |
|
|
121 |
// All outside facing functions are synchronized. Also, we run
|
|
122 |
// initialization on first touch.
|
|
123 |
|
|
124 |
|
|
125 |
// Call InitializeCriticalSection as early as possible.
|
|
126 |
class CritSect {
|
|
127 |
CRITICAL_SECTION cs;
|
|
128 |
public:
|
|
129 |
CritSect() { ::InitializeCriticalSection(&cs); }
|
|
130 |
void enter() { ::EnterCriticalSection(&cs); }
|
|
131 |
void leave() { ::LeaveCriticalSection(&cs); }
|
|
132 |
};
|
|
133 |
|
|
134 |
static CritSect g_cs;
|
|
135 |
|
|
136 |
class EntryGuard {
|
|
137 |
public:
|
|
138 |
EntryGuard() {
|
|
139 |
g_cs.enter();
|
|
140 |
if (g_state == state_uninitialized) {
|
|
141 |
initialize();
|
|
142 |
}
|
|
143 |
}
|
|
144 |
~EntryGuard() {
|
|
145 |
g_cs.leave();
|
|
146 |
}
|
|
147 |
};
|
|
148 |
|
|
149 |
DWORD WindowsDbgHelp::symSetOptions(DWORD arg) {
|
|
150 |
EntryGuard entry_guard;
|
|
151 |
if (g_pfn_SymSetOptions != NULL) {
|
|
152 |
return g_pfn_SymSetOptions(arg);
|
|
153 |
}
|
|
154 |
return 0;
|
|
155 |
}
|
|
156 |
|
|
157 |
DWORD WindowsDbgHelp::symGetOptions(void) {
|
|
158 |
EntryGuard entry_guard;
|
|
159 |
if (g_pfn_SymGetOptions != NULL) {
|
|
160 |
return g_pfn_SymGetOptions();
|
|
161 |
}
|
|
162 |
return 0;
|
|
163 |
}
|
|
164 |
|
|
165 |
BOOL WindowsDbgHelp::symInitialize(HANDLE hProcess, PCTSTR UserSearchPath, BOOL fInvadeProcess) {
|
|
166 |
EntryGuard entry_guard;
|
|
167 |
if (g_pfn_SymInitialize != NULL) {
|
|
168 |
return g_pfn_SymInitialize(hProcess, UserSearchPath, fInvadeProcess);
|
|
169 |
}
|
|
170 |
return FALSE;
|
|
171 |
}
|
|
172 |
|
|
173 |
BOOL WindowsDbgHelp::symGetSymFromAddr64(HANDLE hProcess, DWORD64 the_address,
|
|
174 |
PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol) {
|
|
175 |
EntryGuard entry_guard;
|
|
176 |
if (g_pfn_SymGetSymFromAddr64 != NULL) {
|
|
177 |
return g_pfn_SymGetSymFromAddr64(hProcess, the_address, Displacement, Symbol);
|
|
178 |
}
|
|
179 |
return FALSE;
|
|
180 |
}
|
|
181 |
|
|
182 |
DWORD WindowsDbgHelp::unDecorateSymbolName(const char* DecoratedName, char* UnDecoratedName,
|
|
183 |
DWORD UndecoratedLength, DWORD Flags) {
|
|
184 |
EntryGuard entry_guard;
|
|
185 |
if (g_pfn_UnDecorateSymbolName != NULL) {
|
|
186 |
return g_pfn_UnDecorateSymbolName(DecoratedName, UnDecoratedName, UndecoratedLength, Flags);
|
|
187 |
}
|
|
188 |
if (UnDecoratedName != NULL && UndecoratedLength > 0) {
|
|
189 |
UnDecoratedName[0] = '\0';
|
|
190 |
}
|
|
191 |
return 0;
|
|
192 |
}
|
|
193 |
|
|
194 |
BOOL WindowsDbgHelp::symSetSearchPath(HANDLE hProcess, PCTSTR SearchPath) {
|
|
195 |
EntryGuard entry_guard;
|
|
196 |
if (g_pfn_SymSetSearchPath != NULL) {
|
|
197 |
return g_pfn_SymSetSearchPath(hProcess, SearchPath);
|
|
198 |
}
|
|
199 |
return FALSE;
|
|
200 |
}
|
|
201 |
|
|
202 |
BOOL WindowsDbgHelp::symGetSearchPath(HANDLE hProcess, PTSTR SearchPath, int SearchPathLength) {
|
|
203 |
EntryGuard entry_guard;
|
|
204 |
if (g_pfn_SymGetSearchPath != NULL) {
|
|
205 |
return g_pfn_SymGetSearchPath(hProcess, SearchPath, SearchPathLength);
|
|
206 |
}
|
|
207 |
return FALSE;
|
|
208 |
}
|
|
209 |
|
|
210 |
BOOL WindowsDbgHelp::stackWalk64(DWORD MachineType,
|
|
211 |
HANDLE hProcess,
|
|
212 |
HANDLE hThread,
|
|
213 |
LPSTACKFRAME64 StackFrame,
|
|
214 |
PVOID ContextRecord) {
|
|
215 |
EntryGuard entry_guard;
|
|
216 |
if (g_pfn_StackWalk64 != NULL) {
|
|
217 |
return g_pfn_StackWalk64(MachineType, hProcess, hThread, StackFrame,
|
|
218 |
ContextRecord,
|
|
219 |
NULL, // ReadMemoryRoutine
|
|
220 |
g_pfn_SymFunctionTableAccess64, // FunctionTableAccessRoutine,
|
|
221 |
g_pfn_SymGetModuleBase64, // GetModuleBaseRoutine
|
|
222 |
NULL // TranslateAddressRoutine
|
|
223 |
);
|
|
224 |
}
|
|
225 |
return FALSE;
|
|
226 |
}
|
|
227 |
|
|
228 |
PVOID WindowsDbgHelp::symFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) {
|
|
229 |
EntryGuard entry_guard;
|
|
230 |
if (g_pfn_SymFunctionTableAccess64 != NULL) {
|
|
231 |
return g_pfn_SymFunctionTableAccess64(hProcess, AddrBase);
|
|
232 |
}
|
|
233 |
return NULL;
|
|
234 |
}
|
|
235 |
|
|
236 |
DWORD64 WindowsDbgHelp::symGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr) {
|
|
237 |
EntryGuard entry_guard;
|
|
238 |
if (g_pfn_SymGetModuleBase64 != NULL) {
|
|
239 |
return g_pfn_SymGetModuleBase64(hProcess, dwAddr);
|
|
240 |
}
|
|
241 |
return 0;
|
|
242 |
}
|
|
243 |
|
|
244 |
BOOL WindowsDbgHelp::miniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
|
|
245 |
MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
|
|
246 |
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
|
|
247 |
PMINIDUMP_CALLBACK_INFORMATION CallbackParam) {
|
|
248 |
EntryGuard entry_guard;
|
|
249 |
if (g_pfn_MiniDumpWriteDump != NULL) {
|
|
250 |
return g_pfn_MiniDumpWriteDump(hProcess, ProcessId, hFile, DumpType,
|
|
251 |
ExceptionParam, UserStreamParam, CallbackParam);
|
|
252 |
}
|
|
253 |
return FALSE;
|
|
254 |
}
|
|
255 |
|
|
256 |
BOOL WindowsDbgHelp::symGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
|
|
257 |
PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line) {
|
|
258 |
EntryGuard entry_guard;
|
|
259 |
if (g_pfn_SymGetLineFromAddr64 != NULL) {
|
|
260 |
return g_pfn_SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, Line);
|
|
261 |
}
|
|
262 |
return FALSE;
|
|
263 |
}
|
|
264 |
|
|
265 |
// Print one liner describing state (if library loaded, which functions are
|
|
266 |
// missing - if any, and the dbhelp API version)
|
|
267 |
void WindowsDbgHelp::print_state_on(outputStream* st) {
|
|
268 |
// Note: We should not lock while printing, but this should be
|
|
269 |
// safe to do without lock anyway.
|
|
270 |
st->print("dbghelp: ");
|
|
271 |
|
|
272 |
if (g_state == state_uninitialized) {
|
|
273 |
st->print("uninitialized.");
|
|
274 |
} else if (g_state == state_error) {
|
|
275 |
st->print("loading error: %u", g_dll_load_error);
|
|
276 |
} else {
|
|
277 |
st->print("loaded successfully ");
|
|
278 |
|
|
279 |
// We may want to print dll file name here - which may be interesting for
|
|
280 |
// cases where more than one version exists on the system, e.g. with a
|
|
281 |
// debugging sdk separately installed. But we get the file name in the DLL
|
|
282 |
// section of the hs-err file too, so this may be redundant.
|
|
283 |
|
|
284 |
// Print version.
|
|
285 |
st->print("- version: %u.%u.%u",
|
|
286 |
g_version.MajorVersion, g_version.MinorVersion, g_version.Revision);
|
|
287 |
|
|
288 |
// Print any functions which failed to load.
|
|
289 |
int num_missing = 0;
|
|
290 |
st->print(" - missing functions: ");
|
|
291 |
|
|
292 |
#define CHECK_AND_PRINT_IF_NULL(functionname) \
|
|
293 |
if (g_pfn_##functionname == NULL) { \
|
|
294 |
st->print("%s" #functionname, ((num_missing > 0) ? ", " : "")); \
|
|
295 |
num_missing ++; \
|
|
296 |
}
|
|
297 |
|
|
298 |
FOR_ALL_FUNCTIONS(CHECK_AND_PRINT_IF_NULL)
|
|
299 |
|
|
300 |
if (num_missing == 0) {
|
|
301 |
st->print("none");
|
|
302 |
}
|
|
303 |
}
|
|
304 |
st->cr();
|
|
305 |
}
|
|
306 |
|