base/debug/crash_logging.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/debug/crash_logging.h"
   6
   7 #include <cmath>
   8 #include <map>
   9
  10 #include "base/debug/stack_trace.h"
  11 #include "base/format_macros.h"
  12 #include "base/logging.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15
  16 namespace base {
  17 namespace debug {
  18
  19 namespace {
  20
  21 // Global map of crash key names to registration entries.
  22 typedef std::map<base::StringPiece, CrashKey> CrashKeyMap;
  23 CrashKeyMap* g_crash_keys_ = NULL;
  24
  25 // The maximum length of a single chunk.
  26 size_t g_chunk_max_length_ = 0;
  27
  28 // String used to format chunked key names.
  29 const char kChunkFormatString[] = "%s-%" PRIuS;
  30
  31 // The functions that are called to actually set the key-value pairs in the
  32 // crash reportng system.
  33 SetCrashKeyValueFuncT g_set_key_func_ = NULL;
  34 ClearCrashKeyValueFuncT g_clear_key_func_ = NULL;
  35
  36 // For a given |length|, computes the number of chunks a value of that size
  37 // will occupy.
  38 size_t NumChunksForLength(size_t length) {
  39   return std::ceil(length / static_cast<float>(g_chunk_max_length_));
  40 }
  41
  42 // The longest max_length allowed by the system.
  43 const size_t kLargestValueAllowed = 1024;
  44
  45 }  // namespace
  46
  47 void SetCrashKeyValue(const base::StringPiece& key,
  48                       const base::StringPiece& value) {
  49   if (!g_set_key_func_ || !g_crash_keys_)
  50     return;
  51
  52   const CrashKey* crash_key = LookupCrashKey(key);
  53
  54   DCHECK(crash_key) << "All crash keys must be registered before use "
  55                     << "(key = " << key << ")";
  56
  57   // Handle the un-chunked case.
  58   if (!crash_key || crash_key->max_length <= g_chunk_max_length_) {
  59     g_set_key_func_(key, value);
  60     return;
  61   }
  62
  63   // Unset the unused chunks.
  64   std::vector<std::string> chunks =
  65       ChunkCrashKeyValue(*crash_key, value, g_chunk_max_length_);
  66   for (size_t i = chunks.size();
  67        i < NumChunksForLength(crash_key->max_length);
  68        ++i) {
  69     g_clear_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1));
  70   }
  71
  72   // Set the chunked keys.
  73   for (size_t i = 0; i < chunks.size(); ++i) {
  74     g_set_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1),
  75                     chunks[i]);
  76   }
  77 }
  78
  79 void ClearCrashKey(const base::StringPiece& key) {
  80   if (!g_clear_key_func_ || !g_crash_keys_)
  81     return;
  82
  83   const CrashKey* crash_key = LookupCrashKey(key);
  84
  85   // Handle the un-chunked case.
  86   if (!crash_key || crash_key->max_length <= g_chunk_max_length_) {
  87     g_clear_key_func_(key);
  88     return;
  89   }
  90
  91   for (size_t i = 0; i < NumChunksForLength(crash_key->max_length); ++i) {
  92     g_clear_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1));
  93   }
  94 }
  95
  96 void SetCrashKeyToStackTrace(const base::StringPiece& key,
  97                              const StackTrace& trace) {
  98   size_t count = 0;
  99   const void* const* addresses = trace.Addresses(&count);
 100   SetCrashKeyFromAddresses(key, addresses, count);
 101 }
 102
 103 void SetCrashKeyFromAddresses(const base::StringPiece& key,
 104                               const void* const* addresses,
 105                               size_t count) {
 106   std::string value = "<null>";
 107   if (addresses && count) {
 108     const size_t kBreakpadValueMax = 255;
 109
 110     std::vector<std::string> hex_backtrace;
 111     size_t length = 0;
 112
 113     for (size_t i = 0; i < count; ++i) {
 114       std::string s = base::StringPrintf("%p", addresses[i]);
 115       length += s.length() + 1;
 116       if (length > kBreakpadValueMax)
 117         break;
 118       hex_backtrace.push_back(s);
 119     }
 120
 121     value = JoinString(hex_backtrace, ' ');
 122
 123     // Warn if this exceeds the breakpad limits.
 124     DCHECK_LE(value.length(), kBreakpadValueMax);
 125   }
 126
 127   SetCrashKeyValue(key, value);
 128 }
 129
 130 ScopedCrashKey::ScopedCrashKey(const base::StringPiece& key,
 131                                const base::StringPiece& value)
 132     : key_(key.as_string()) {
 133   SetCrashKeyValue(key, value);
 134 }
 135
 136 ScopedCrashKey::~ScopedCrashKey() {
 137   ClearCrashKey(key_);
 138 }
 139
 140 size_t InitCrashKeys(const CrashKey* const keys, size_t count,
 141                      size_t chunk_max_length) {
 142   DCHECK(!g_crash_keys_) << "Crash logging may only be initialized once";
 143   if (!keys) {
 144     delete g_crash_keys_;
 145     g_crash_keys_ = NULL;
 146     return 0;
 147   }
 148
 149   g_crash_keys_ = new CrashKeyMap;
 150   g_chunk_max_length_ = chunk_max_length;
 151
 152   size_t total_keys = 0;
 153   for (size_t i = 0; i < count; ++i) {
 154     g_crash_keys_->insert(std::make_pair(keys[i].key_name, keys[i]));
 155     total_keys += NumChunksForLength(keys[i].max_length);
 156     DCHECK_LT(keys[i].max_length, kLargestValueAllowed);
 157   }
 158   DCHECK_EQ(count, g_crash_keys_->size())
 159       << "Duplicate crash keys were registered";
 160
 161   return total_keys;
 162 }
 163
 164 const CrashKey* LookupCrashKey(const base::StringPiece& key) {
 165   if (!g_crash_keys_)
 166     return NULL;
 167   CrashKeyMap::const_iterator it = g_crash_keys_->find(key.as_string());
 168   if (it == g_crash_keys_->end())
 169     return NULL;
 170   return &(it->second);
 171 }
 172
 173 void SetCrashKeyReportingFunctions(
 174     SetCrashKeyValueFuncT set_key_func,
 175     ClearCrashKeyValueFuncT clear_key_func) {
 176   g_set_key_func_ = set_key_func;
 177   g_clear_key_func_ = clear_key_func;
 178 }
 179
 180 std::vector<std::string> ChunkCrashKeyValue(const CrashKey& crash_key,
 181                                             const base::StringPiece& value,
 182                                             size_t chunk_max_length) {
 183   std::string value_string = value.substr(0, crash_key.max_length).as_string();
 184   std::vector<std::string> chunks;
 185   for (size_t offset = 0; offset < value_string.length(); ) {
 186     std::string chunk = value_string.substr(offset, chunk_max_length);
 187     chunks.push_back(chunk);
 188     offset += chunk.length();
 189   }
 190   return chunks;
 191 }
 192
 193 void ResetCrashLoggingForTesting() {
 194   delete g_crash_keys_;
 195   g_crash_keys_ = NULL;
 196   g_chunk_max_length_ = 0;
 197   g_set_key_func_ = NULL;
 198   g_clear_key_func_ = NULL;
 199 }
 200
 201 }  // namespace debug
 202 }  // namespace base