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