libsanitizer/sanitizer_common/sanitizer_symbolizer_win.cpp

   1 //===-- sanitizer_symbolizer_win.cpp --------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is shared between AddressSanitizer and ThreadSanitizer
  10 // run-time libraries.
  11 // Windows-specific implementation of symbolizer parts.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_platform.h"
  15 #if SANITIZER_WINDOWS
  16
  17 #  include "sanitizer_dbghelp.h"
  18 #  include "sanitizer_symbolizer_internal.h"
  19
  20 namespace __sanitizer {
  21
  22 decltype(::StackWalk64) *StackWalk64;
  23 decltype(::SymCleanup) *SymCleanup;
  24 decltype(::SymFromAddr) *SymFromAddr;
  25 decltype(::SymFunctionTableAccess64) *SymFunctionTableAccess64;
  26 decltype(::SymGetLineFromAddr64) *SymGetLineFromAddr64;
  27 decltype(::SymGetModuleBase64) *SymGetModuleBase64;
  28 decltype(::SymGetSearchPathW) *SymGetSearchPathW;
  29 decltype(::SymInitialize) *SymInitialize;
  30 decltype(::SymSetOptions) *SymSetOptions;
  31 decltype(::SymSetSearchPathW) *SymSetSearchPathW;
  32 decltype(::UnDecorateSymbolName) *UnDecorateSymbolName;
  33
  34 namespace {
  35
  36 class WinSymbolizerTool final : public SymbolizerTool {
  37  public:
  38   // The constructor is provided to avoid synthesized memsets.
  39   WinSymbolizerTool() {}
  40
  41   bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
  42   bool SymbolizeData(uptr addr, DataInfo *info) override {
  43     return false;
  44   }
  45   const char *Demangle(const char *name) override;
  46 };
  47
  48 bool is_dbghelp_initialized = false;
  49
  50 bool TrySymInitialize() {
  51   SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
  52   return SymInitialize(GetCurrentProcess(), 0, TRUE);
  53   // FIXME: We don't call SymCleanup() on exit yet - should we?
  54 }
  55
  56 }  // namespace
  57
  58 // Initializes DbgHelp library, if it's not yet initialized. Calls to this
  59 // function should be synchronized with respect to other calls to DbgHelp API
  60 // (e.g. from WinSymbolizerTool).
  61 void InitializeDbgHelpIfNeeded() {
  62   if (is_dbghelp_initialized)
  63     return;
  64
  65   HMODULE dbghelp = LoadLibraryA("dbghelp.dll");
  66   CHECK(dbghelp && "failed to load dbghelp.dll");
  67
  68 #define DBGHELP_IMPORT(name)                                                  \
  69   do {                                                                        \
  70     name =                                                                    \
  71         reinterpret_cast<decltype(::name) *>(GetProcAddress(dbghelp, #name)); \
  72     CHECK(name != nullptr);                                                   \
  73   } while (0)
  74   DBGHELP_IMPORT(StackWalk64);
  75   DBGHELP_IMPORT(SymCleanup);
  76   DBGHELP_IMPORT(SymFromAddr);
  77   DBGHELP_IMPORT(SymFunctionTableAccess64);
  78   DBGHELP_IMPORT(SymGetLineFromAddr64);
  79   DBGHELP_IMPORT(SymGetModuleBase64);
  80   DBGHELP_IMPORT(SymGetSearchPathW);
  81   DBGHELP_IMPORT(SymInitialize);
  82   DBGHELP_IMPORT(SymSetOptions);
  83   DBGHELP_IMPORT(SymSetSearchPathW);
  84   DBGHELP_IMPORT(UnDecorateSymbolName);
  85 #undef DBGHELP_IMPORT
  86
  87   if (!TrySymInitialize()) {
  88     // OK, maybe the client app has called SymInitialize already.
  89     // That's a bit unfortunate for us as all the DbgHelp functions are
  90     // single-threaded and we can't coordinate with the app.
  91     // FIXME: Can we stop the other threads at this point?
  92     // Anyways, we have to reconfigure stuff to make sure that SymInitialize
  93     // has all the appropriate options set.
  94     // Cross our fingers and reinitialize DbgHelp.
  95     Report("*** WARNING: Failed to initialize DbgHelp!              ***\n");
  96     Report("*** Most likely this means that the app is already      ***\n");
  97     Report("*** using DbgHelp, possibly with incompatible flags.    ***\n");
  98     Report("*** Due to technical reasons, symbolization might crash ***\n");
  99     Report("*** or produce wrong results.                           ***\n");
 100     SymCleanup(GetCurrentProcess());
 101     TrySymInitialize();
 102   }
 103   is_dbghelp_initialized = true;
 104
 105   // When an executable is run from a location different from the one where it
 106   // was originally built, we may not see the nearby PDB files.
 107   // To work around this, let's append the directory of the main module
 108   // to the symbol search path.  All the failures below are not fatal.
 109   const size_t kSymPathSize = 2048;
 110   static wchar_t path_buffer[kSymPathSize + 1 + MAX_PATH];
 111   if (!SymGetSearchPathW(GetCurrentProcess(), path_buffer, kSymPathSize)) {
 112     Report("*** WARNING: Failed to SymGetSearchPathW ***\n");
 113     return;
 114   }
 115   size_t sz = wcslen(path_buffer);
 116   if (sz) {
 117     CHECK_EQ(0, wcscat_s(path_buffer, L";"));
 118     sz++;
 119   }
 120   DWORD res = GetModuleFileNameW(NULL, path_buffer + sz, MAX_PATH);
 121   if (res == 0 || res == MAX_PATH) {
 122     Report("*** WARNING: Failed to getting the EXE directory ***\n");
 123     return;
 124   }
 125   // Write the zero character in place of the last backslash to get the
 126   // directory of the main module at the end of path_buffer.
 127   wchar_t *last_bslash = wcsrchr(path_buffer + sz, L'\\');
 128   CHECK_NE(last_bslash, 0);
 129   *last_bslash = L'\0';
 130   if (!SymSetSearchPathW(GetCurrentProcess(), path_buffer)) {
 131     Report("*** WARNING: Failed to SymSetSearchPathW\n");
 132     return;
 133   }
 134 }
 135
 136 bool WinSymbolizerTool::SymbolizePC(uptr addr, SymbolizedStack *frame) {
 137   InitializeDbgHelpIfNeeded();
 138
 139   // See https://docs.microsoft.com/en-us/windows/win32/debug/retrieving-symbol-information-by-address
 140   InternalMmapVector<char> buffer(sizeof(SYMBOL_INFO) +
 141                                   MAX_SYM_NAME * sizeof(CHAR));
 142   PSYMBOL_INFO symbol = (PSYMBOL_INFO)&buffer[0];
 143   symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
 144   symbol->MaxNameLen = MAX_SYM_NAME;
 145   DWORD64 offset = 0;
 146   BOOL got_objname = SymFromAddr(GetCurrentProcess(),
 147                                  (DWORD64)addr, &offset, symbol);
 148   if (!got_objname)
 149     return false;
 150
 151   DWORD unused;
 152   IMAGEHLP_LINE64 line_info;
 153   line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
 154   BOOL got_fileline = SymGetLineFromAddr64(GetCurrentProcess(), (DWORD64)addr,
 155                                            &unused, &line_info);
 156   frame->info.function = internal_strdup(symbol->Name);
 157   frame->info.function_offset = (uptr)offset;
 158   if (got_fileline) {
 159     frame->info.file = internal_strdup(line_info.FileName);
 160     frame->info.line = line_info.LineNumber;
 161   }
 162   // Only consider this a successful symbolization attempt if we got file info.
 163   // Otherwise, try llvm-symbolizer.
 164   return got_fileline;
 165 }
 166
 167 const char *WinSymbolizerTool::Demangle(const char *name) {
 168   CHECK(is_dbghelp_initialized);
 169   static char demangle_buffer[1000];
 170   if (name[0] == '\01' &&
 171       UnDecorateSymbolName(name + 1, demangle_buffer, sizeof(demangle_buffer),
 172                            UNDNAME_NAME_ONLY))
 173     return demangle_buffer;
 174   else
 175     return name;
 176 }
 177
 178 const char *Symbolizer::PlatformDemangle(const char *name) {
 179   return name;
 180 }
 181
 182 namespace {
 183 struct ScopedHandle {
 184   ScopedHandle() : h_(nullptr) {}
 185   explicit ScopedHandle(HANDLE h) : h_(h) {}
 186   ~ScopedHandle() {
 187     if (h_)
 188       ::CloseHandle(h_);
 189   }
 190   HANDLE get() { return h_; }
 191   HANDLE *receive() { return &h_; }
 192   HANDLE release() {
 193     HANDLE h = h_;
 194     h_ = nullptr;
 195     return h;
 196   }
 197   HANDLE h_;
 198 };
 199 } // namespace
 200
 201 bool SymbolizerProcess::StartSymbolizerSubprocess() {
 202   // Create inherited pipes for stdin and stdout.
 203   ScopedHandle stdin_read, stdin_write;
 204   ScopedHandle stdout_read, stdout_write;
 205   SECURITY_ATTRIBUTES attrs;
 206   attrs.nLength = sizeof(SECURITY_ATTRIBUTES);
 207   attrs.bInheritHandle = TRUE;
 208   attrs.lpSecurityDescriptor = nullptr;
 209   if (!::CreatePipe(stdin_read.receive(), stdin_write.receive(), &attrs, 0) ||
 210       !::CreatePipe(stdout_read.receive(), stdout_write.receive(), &attrs, 0)) {
 211     VReport(2, "WARNING: %s CreatePipe failed (error code: %d)\n",
 212             SanitizerToolName, path_, GetLastError());
 213     return false;
 214   }
 215
 216   // Don't inherit the writing end of stdin or the reading end of stdout.
 217   if (!SetHandleInformation(stdin_write.get(), HANDLE_FLAG_INHERIT, 0) ||
 218       !SetHandleInformation(stdout_read.get(), HANDLE_FLAG_INHERIT, 0)) {
 219     VReport(2, "WARNING: %s SetHandleInformation failed (error code: %d)\n",
 220             SanitizerToolName, path_, GetLastError());
 221     return false;
 222   }
 223
 224   // Compute the command line. Wrap double quotes around everything.
 225   const char *argv[kArgVMax];
 226   GetArgV(path_, argv);
 227   InternalScopedString command_line;
 228   for (int i = 0; argv[i]; i++) {
 229     const char *arg = argv[i];
 230     int arglen = internal_strlen(arg);
 231     // Check that tool command lines are simple and that complete escaping is
 232     // unnecessary.
 233     CHECK(!internal_strchr(arg, '"') && "quotes in args unsupported");
 234     CHECK(arglen > 0 && arg[arglen - 1] != '\\' &&
 235           "args ending in backslash and empty args unsupported");
 236     command_line.append("\"%s\" ", arg);
 237   }
 238   VReport(3, "Launching symbolizer command: %s\n", command_line.data());
 239
 240   // Launch llvm-symbolizer with stdin and stdout redirected.
 241   STARTUPINFOA si;
 242   memset(&si, 0, sizeof(si));
 243   si.cb = sizeof(si);
 244   si.dwFlags |= STARTF_USESTDHANDLES;
 245   si.hStdInput = stdin_read.get();
 246   si.hStdOutput = stdout_write.get();
 247   PROCESS_INFORMATION pi;
 248   memset(&pi, 0, sizeof(pi));
 249   if (!CreateProcessA(path_,               // Executable
 250                       command_line.data(), // Command line
 251                       nullptr,             // Process handle not inheritable
 252                       nullptr,             // Thread handle not inheritable
 253                       TRUE,                // Set handle inheritance to TRUE
 254                       0,                   // Creation flags
 255                       nullptr,             // Use parent's environment block
 256                       nullptr,             // Use parent's starting directory
 257                       &si, &pi)) {
 258     VReport(2, "WARNING: %s failed to create process for %s (error code: %d)\n",
 259             SanitizerToolName, path_, GetLastError());
 260     return false;
 261   }
 262
 263   // Process creation succeeded, so transfer handle ownership into the fields.
 264   input_fd_ = stdout_read.release();
 265   output_fd_ = stdin_write.release();
 266
 267   // The llvm-symbolizer process is responsible for quitting itself when the
 268   // stdin pipe is closed, so we don't need these handles. Close them to prevent
 269   // leaks. If we ever want to try to kill the symbolizer process from the
 270   // parent, we'll want to hang on to these handles.
 271   CloseHandle(pi.hProcess);
 272   CloseHandle(pi.hThread);
 273   return true;
 274 }
 275
 276 static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
 277                                   LowLevelAllocator *allocator) {
 278   if (!common_flags()->symbolize) {
 279     VReport(2, "Symbolizer is disabled.\n");
 280     return;
 281   }
 282
 283   // Add llvm-symbolizer.
 284   const char *user_path = common_flags()->external_symbolizer_path;
 285
 286   if (user_path && internal_strchr(user_path, '%')) {
 287     char *new_path = (char *)InternalAlloc(kMaxPathLength);
 288     SubstituteForFlagValue(user_path, new_path, kMaxPathLength);
 289     user_path = new_path;
 290   }
 291
 292   const char *path =
 293       user_path ? user_path : FindPathToBinary("llvm-symbolizer.exe");
 294   if (path) {
 295     VReport(2, "Using llvm-symbolizer at %spath: %s\n",
 296             user_path ? "user-specified " : "", path);
 297     list->push_back(new(*allocator) LLVMSymbolizer(path, allocator));
 298   } else {
 299     if (user_path && user_path[0] == '\0') {
 300       VReport(2, "External symbolizer is explicitly disabled.\n");
 301     } else {
 302       VReport(2, "External symbolizer is not present.\n");
 303     }
 304   }
 305
 306   // Add the dbghelp based symbolizer.
 307   list->push_back(new(*allocator) WinSymbolizerTool());
 308 }
 309
 310 Symbolizer *Symbolizer::PlatformInit() {
 311   IntrusiveList<SymbolizerTool> list;
 312   list.clear();
 313   ChooseSymbolizerTools(&list, &symbolizer_allocator_);
 314
 315   return new(symbolizer_allocator_) Symbolizer(list);
 316 }
 317
 318 void Symbolizer::LateInitialize() {
 319   Symbolizer::GetOrInit();
 320 }
 321
 322 }  // namespace __sanitizer
 323
 324 #endif  // _WIN32