The Tor Browser: ipc/chromium/src/base/debug_util

ipc/chromium/src/base/debug_util_win.cc@8bccb770b82d (annotated)

ipc/chromium/src/base/debug_util_win.cc

Wed, 31 Dec 2014 13:27:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 13:27:57 +0100
branch: TOR_BUG_3246
changeset 6: 8bccb770b82d
permissions: -rw-r--r--

Ignore runtime configuration files generated during quality assurance.

 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "base/debug_util.h"
 #include <windows.h>
 #include <dbghelp.h>
 #include <iostream>
 #include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 namespace {
 // Minimalist key reader.
 // Note: Does not use the CRT.
 bool RegReadString(HKEY root, const wchar_t* subkey,
                    const wchar_t* value_name, wchar_t* buffer, int* len) {
   HKEY key = NULL;
   DWORD res = RegOpenKeyEx(root, subkey, 0, KEY_READ, &key);
   if (ERROR_SUCCESS != res || key == NULL)
     return false;
   DWORD type = 0;
   DWORD buffer_size = *len * sizeof(wchar_t);
   // We don't support REG_EXPAND_SZ.
   res = RegQueryValueEx(key, value_name, NULL, &type,
                         reinterpret_cast<BYTE*>(buffer), &buffer_size);
   if (ERROR_SUCCESS == res && buffer_size != 0 && type == REG_SZ) {
     // Make sure the buffer is NULL terminated.
     buffer[*len - 1] = 0;
     *len = lstrlen(buffer);
     RegCloseKey(key);
     return true;
   }
   RegCloseKey(key);
   return false;
 }
 // Replaces each "%ld" in input per a value. Not efficient but it works.
 // Note: Does not use the CRT.
 bool StringReplace(const wchar_t* input, int value, wchar_t* output,
                    int output_len) {
   memset(output, 0, output_len*sizeof(wchar_t));
   int input_len = lstrlen(input);
   for (int i = 0; i < input_len; ++i) {
     int current_output_len = lstrlen(output);
     if (input[i] == L'%' && input[i + 1] == L'l' && input[i + 2] == L'd') {
       // Make sure we have enough place left.
       if ((current_output_len + 12) >= output_len)
         return false;
       // Cheap _itow().
       wsprintf(output+current_output_len, L"%d", value);
       i += 2;
     } else {
       if (current_output_len >= output_len)
         return false;
       output[current_output_len] = input[i];
     }
   }
   return true;
 }
 // SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family
 // of functions.  The Sym* family of functions may only be invoked by one
 // thread at a time.  SymbolContext code may access a symbol server over the
 // network while holding the lock for this singleton.  In the case of high
 // latency, this code will adversly affect performance.
 //
 // There is also a known issue where this backtrace code can interact
 // badly with breakpad if breakpad is invoked in a separate thread while
 // we are using the Sym* functions.  This is because breakpad does now
 // share a lock with this function.  See this related bug:
 //
 //   http://code.google.com/p/google-breakpad/issues/detail?id=311
 //
 // This is a very unlikely edge case, and the current solution is to
 // just ignore it.
 class SymbolContext {
  public:
   static SymbolContext* Get() {
     // We use a leaky singleton because code may call this during process
     // termination.
     return
       Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get();
   }
   // Initializes the symbols for the process if it hasn't been done yet.
   // Subsequent calls will not reinitialize the symbol, but instead return
   // the error code from the first call.
   bool Init() {
     AutoLock lock(lock_);
     if (!initialized_) {
       process_ = GetCurrentProcess();
       // Defer symbol load until they're needed, use undecorated names, and
       // get line numbers.
       SymSetOptions(SYMOPT_DEFERRED_LOADS |
                     SYMOPT_UNDNAME |
                     SYMOPT_LOAD_LINES);
       if (SymInitialize(process_, NULL, TRUE)) {
         init_error_ = ERROR_SUCCESS;
       } else {
         init_error_ = GetLastError();
       }
     }
     initialized_ = true;
     return init_error_ == ERROR_SUCCESS;
   }
   // Returns the error code of a failed initialization.  This should only be
   // called if Init() has been called.  We do not CHROMIUM_LOG(FATAL) here because
   // this code is called might be triggered by a CHROMIUM_LOG(FATAL) itself.  Instead,
   // we log an ERROR, and return ERROR_INVALID_DATA.
   DWORD init_error() {
     if (!initialized_) {
       CHROMIUM_LOG(ERROR) << "Calling GetInitError() before Init() was called.  "
                           << "Returning ERROR_INVALID_DATA.";
       return ERROR_INVALID_DATA;
     }
     return init_error_;
   }
   // Returns the process this was initialized for.  This should only be
   // called if Init() has been called.  We CHROMIUM_LOG(ERROR) in this situation.
   // CHROMIUM_LOG(FATAL) is not used because this code is might be triggered
   // by a CHROMIUM_LOG(FATAL) itself.
   HANDLE process() {
     if (!initialized_) {
       CHROMIUM_LOG(ERROR) << "Calling process() before Init() was called. "
                           << "Returning NULL.";
       return NULL;
     }
     return process_;
   }
   // For the given trace, attempts to resolve the symbols, and output a trace
   // to the ostream os.  The format for each line of the backtrace is:
   //
   //    <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
   //
   // This function should only be called if Init() has been called.  We do not
   // CHROMIUM_LOG(FATAL) here because this code is called might be triggered by a
   // CHROMIUM_LOG(FATAL) itself.
   void OutputTraceToStream(const std::vector<void*>& trace, std::ostream* os) {
     AutoLock lock(lock_);
     for (size_t i = 0; (i < trace.size()) && os->good(); ++i) {
       const int kMaxNameLength = 256;
       DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
       // Code adapted from MSDN example:
       // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
       ULONG64 buffer[
         (sizeof(SYMBOL_INFO) +
           kMaxNameLength * sizeof(wchar_t) +
           sizeof(ULONG64) - 1) /
         sizeof(ULONG64)];
       // Initialize symbol information retrieval structures.
       DWORD64 sym_displacement = 0;
       PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
       symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
       symbol->MaxNameLen = kMaxNameLength;
       BOOL has_symbol = SymFromAddr(process(), frame,
                                     &sym_displacement, symbol);
       // Attempt to retrieve line number information.
       DWORD line_displacement = 0;
       IMAGEHLP_LINE64 line = {};
       line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
       BOOL has_line = SymGetLineFromAddr64(process(), frame,
                                            &line_displacement, &line);
       // Output the backtrace line.
       (*os) << "\t";
       if (has_symbol) {
         (*os) << symbol->Name << " [0x" << trace[i] << "+"
               << sym_displacement << "]";
       } else {
         // If there is no symbol informtion, add a spacer.
         (*os) << "(No symbol) [0x" << trace[i] << "]";
       }
       if (has_line) {
         (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
       }
       (*os) << "\n";
     }
   }
   SymbolContext()
     : initialized_(false),
       process_(NULL),
       init_error_(ERROR_SUCCESS) {
   }
  private:
   Lock lock_;
   bool initialized_;
   HANDLE process_;
   DWORD init_error_;
   DISALLOW_COPY_AND_ASSIGN(SymbolContext);
 };
 }  // namespace
 // Note: Does not use the CRT.
 bool DebugUtil::SpawnDebuggerOnProcess(unsigned process_id) {
   wchar_t reg_value[1026];
   int len = arraysize(reg_value);
   if (RegReadString(HKEY_LOCAL_MACHINE,
       L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug",
       L"Debugger", reg_value, &len)) {
     wchar_t command_line[1026];
     if (StringReplace(reg_value, process_id, command_line,
                       arraysize(command_line))) {
       // We don't mind if the debugger is present because it will simply fail
       // to attach to this process.
       STARTUPINFO startup_info = {0};
       startup_info.cb = sizeof(startup_info);
       PROCESS_INFORMATION process_info = {0};
       if (CreateProcess(NULL, command_line, NULL, NULL, FALSE, 0, NULL, NULL,
                         &startup_info, &process_info)) {
         CloseHandle(process_info.hThread);
         WaitForInputIdle(process_info.hProcess, 10000);
         CloseHandle(process_info.hProcess);
         return true;
       }
     }
   }
   return false;
 }
 // static
 bool DebugUtil::BeingDebugged() {
   return ::IsDebuggerPresent() != 0;
 }
 // static
 void DebugUtil::BreakDebugger() {
   __debugbreak();
 }
 StackTrace::StackTrace() {
   // From http://msdn.microsoft.com/en-us/library/bb204633(VS.85).aspx,
   // the sum of FramesToSkip and FramesToCapture must be less than 63,
   // so set it to 62.
   const int kMaxCallers = 62;
   void* callers[kMaxCallers];
   // TODO(ajwong): Migrate this to StackWalk64.
   int count = CaptureStackBackTrace(0, kMaxCallers, callers, NULL);
   if (count > 0) {
     trace_.resize(count);
     memcpy(&trace_[0], callers, sizeof(callers[0]) * count);
   } else {
     trace_.resize(0);
   }
 }
 void StackTrace::PrintBacktrace() {
   OutputToStream(&std::cerr);
 }
 void StackTrace::OutputToStream(std::ostream* os) {
   SymbolContext* context = SymbolContext::Get();
   if (context->Init() != ERROR_SUCCESS) {
     DWORD error = context->init_error();
     (*os) << "Error initializing symbols (" << error
           << ").  Dumping unresolved backtrace:\n";
     for (size_t i = 0; (i < trace_.size()) && os->good(); ++i) {
       (*os) << "\t" << trace_[i] << "\n";
     }
   } else {
     (*os) << "Backtrace:\n";
     context->OutputTraceToStream(trace_, os);
   }
 }

The Tor Browser / annotate

ipc/chromium/src/base/debug_util_win.cc@8bccb770b82d (annotated)

ipc/chromium/src/base/debug_util_win.cc