contrib/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

   1 //===-- sanitizer_symbolizer_libcdep.cc -----------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between AddressSanitizer and ThreadSanitizer
  11 // run-time libraries.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_allocator_internal.h"
  15 #include "sanitizer_internal_defs.h"
  16 #include "sanitizer_symbolizer_internal.h"
  17
  18 namespace __sanitizer {
  19
  20 const char *ExtractToken(const char *str, const char *delims, char **result) {
  21   uptr prefix_len = internal_strcspn(str, delims);
  22   *result = (char*)InternalAlloc(prefix_len + 1);
  23   internal_memcpy(*result, str, prefix_len);
  24   (*result)[prefix_len] = '\0';
  25   const char *prefix_end = str + prefix_len;
  26   if (*prefix_end != '\0') prefix_end++;
  27   return prefix_end;
  28 }
  29
  30 const char *ExtractInt(const char *str, const char *delims, int *result) {
  31   char *buff;
  32   const char *ret = ExtractToken(str, delims, &buff);
  33   if (buff != 0) {
  34     *result = (int)internal_atoll(buff);
  35   }
  36   InternalFree(buff);
  37   return ret;
  38 }
  39
  40 const char *ExtractUptr(const char *str, const char *delims, uptr *result) {
  41   char *buff;
  42   const char *ret = ExtractToken(str, delims, &buff);
  43   if (buff != 0) {
  44     *result = (uptr)internal_atoll(buff);
  45   }
  46   InternalFree(buff);
  47   return ret;
  48 }
  49
  50 const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
  51                                       char **result) {
  52   const char *found_delimiter = internal_strstr(str, delimiter);
  53   uptr prefix_len =
  54       found_delimiter ? found_delimiter - str : internal_strlen(str);
  55   *result = (char *)InternalAlloc(prefix_len + 1);
  56   internal_memcpy(*result, str, prefix_len);
  57   (*result)[prefix_len] = '\0';
  58   const char *prefix_end = str + prefix_len;
  59   if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter);
  60   return prefix_end;
  61 }
  62
  63 SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
  64   BlockingMutexLock l(&mu_);
  65   const char *module_name;
  66   uptr module_offset;
  67   SymbolizedStack *res = SymbolizedStack::New(addr);
  68   if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
  69     return res;
  70   // Always fill data about module name and offset.
  71   res->info.FillModuleInfo(module_name, module_offset);
  72   for (auto &tool : tools_) {
  73     SymbolizerScope sym_scope(this);
  74     if (tool.SymbolizePC(addr, res)) {
  75       return res;
  76     }
  77   }
  78   return res;
  79 }
  80
  81 bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
  82   BlockingMutexLock l(&mu_);
  83   const char *module_name;
  84   uptr module_offset;
  85   if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
  86     return false;
  87   info->Clear();
  88   info->module = internal_strdup(module_name);
  89   info->module_offset = module_offset;
  90   for (auto &tool : tools_) {
  91     SymbolizerScope sym_scope(this);
  92     if (tool.SymbolizeData(addr, info)) {
  93       return true;
  94     }
  95   }
  96   return true;
  97 }
  98
  99 bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
 100                                              uptr *module_address) {
 101   BlockingMutexLock l(&mu_);
 102   const char *internal_module_name = nullptr;
 103   if (!FindModuleNameAndOffsetForAddress(pc, &internal_module_name,
 104                                          module_address))
 105     return false;
 106
 107   if (module_name)
 108     *module_name = module_names_.GetOwnedCopy(internal_module_name);
 109   return true;
 110 }
 111
 112 void Symbolizer::Flush() {
 113   BlockingMutexLock l(&mu_);
 114   for (auto &tool : tools_) {
 115     SymbolizerScope sym_scope(this);
 116     tool.Flush();
 117   }
 118 }
 119
 120 const char *Symbolizer::Demangle(const char *name) {
 121   BlockingMutexLock l(&mu_);
 122   for (auto &tool : tools_) {
 123     SymbolizerScope sym_scope(this);
 124     if (const char *demangled = tool.Demangle(name))
 125       return demangled;
 126   }
 127   return PlatformDemangle(name);
 128 }
 129
 130 void Symbolizer::PrepareForSandboxing() {
 131   BlockingMutexLock l(&mu_);
 132   PlatformPrepareForSandboxing();
 133 }
 134
 135 bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
 136                                                    const char **module_name,
 137                                                    uptr *module_offset) {
 138   const LoadedModule *module = FindModuleForAddress(address);
 139   if (module == nullptr)
 140     return false;
 141   *module_name = module->full_name();
 142   *module_offset = address - module->base_address();
 143   return true;
 144 }
 145
 146 const LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
 147   bool modules_were_reloaded = false;
 148   if (!modules_fresh_) {
 149     modules_.init();
 150     RAW_CHECK(modules_.size() > 0);
 151     modules_fresh_ = true;
 152     modules_were_reloaded = true;
 153   }
 154   for (uptr i = 0; i < modules_.size(); i++) {
 155     if (modules_[i].containsAddress(address)) {
 156       return &modules_[i];
 157     }
 158   }
 159   // Reload the modules and look up again, if we haven't tried it yet.
 160   if (!modules_were_reloaded) {
 161     // FIXME: set modules_fresh_ from dlopen()/dlclose() interceptors.
 162     // It's too aggressive to reload the list of modules each time we fail
 163     // to find a module for a given address.
 164     modules_fresh_ = false;
 165     return FindModuleForAddress(address);
 166   }
 167   return 0;
 168 }
 169
 170 Symbolizer *Symbolizer::GetOrInit() {
 171   SpinMutexLock l(&init_mu_);
 172   if (symbolizer_)
 173     return symbolizer_;
 174   symbolizer_ = PlatformInit();
 175   CHECK(symbolizer_);
 176   return symbolizer_;
 177 }
 178
 179 // For now we assume the following protocol:
 180 // For each request of the form
 181 //   <module_name> <module_offset>
 182 // passed to STDIN, external symbolizer prints to STDOUT response:
 183 //   <function_name>
 184 //   <file_name>:<line_number>:<column_number>
 185 //   <function_name>
 186 //   <file_name>:<line_number>:<column_number>
 187 //   ...
 188 //   <empty line>
 189 class LLVMSymbolizerProcess : public SymbolizerProcess {
 190  public:
 191   explicit LLVMSymbolizerProcess(const char *path) : SymbolizerProcess(path) {}
 192
 193  private:
 194   bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
 195     // Empty line marks the end of llvm-symbolizer output.
 196     return length >= 2 && buffer[length - 1] == '\n' &&
 197            buffer[length - 2] == '\n';
 198   }
 199
 200   void GetArgV(const char *path_to_binary,
 201                const char *(&argv)[kArgVMax]) const override {
 202 #if defined(__x86_64h__)
 203     const char* const kSymbolizerArch = "--default-arch=x86_64h";
 204 #elif defined(__x86_64__)
 205     const char* const kSymbolizerArch = "--default-arch=x86_64";
 206 #elif defined(__i386__)
 207     const char* const kSymbolizerArch = "--default-arch=i386";
 208 #elif defined(__aarch64__)
 209     const char* const kSymbolizerArch = "--default-arch=arm64";
 210 #elif defined(__arm__)
 211     const char* const kSymbolizerArch = "--default-arch=arm";
 212 #elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 213     const char* const kSymbolizerArch = "--default-arch=powerpc64";
 214 #elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 215     const char* const kSymbolizerArch = "--default-arch=powerpc64le";
 216 #elif defined(__s390x__)
 217     const char* const kSymbolizerArch = "--default-arch=s390x";
 218 #elif defined(__s390__)
 219     const char* const kSymbolizerArch = "--default-arch=s390";
 220 #else
 221     const char* const kSymbolizerArch = "--default-arch=unknown";
 222 #endif
 223
 224     const char *const inline_flag = common_flags()->symbolize_inline_frames
 225                                         ? "--inlining=true"
 226                                         : "--inlining=false";
 227     int i = 0;
 228     argv[i++] = path_to_binary;
 229     argv[i++] = inline_flag;
 230     argv[i++] = kSymbolizerArch;
 231     argv[i++] = nullptr;
 232   }
 233 };
 234
 235 LLVMSymbolizer::LLVMSymbolizer(const char *path, LowLevelAllocator *allocator)
 236     : symbolizer_process_(new(*allocator) LLVMSymbolizerProcess(path)) {}
 237
 238 // Parse a <file>:<line>[:<column>] buffer. The file path may contain colons on
 239 // Windows, so extract tokens from the right hand side first. The column info is
 240 // also optional.
 241 static const char *ParseFileLineInfo(AddressInfo *info, const char *str) {
 242   char *file_line_info = 0;
 243   str = ExtractToken(str, "\n", &file_line_info);
 244   CHECK(file_line_info);
 245   // Parse the last :<int>, which must be there.
 246   char *last_colon = internal_strrchr(file_line_info, ':');
 247   CHECK(last_colon);
 248   int line_or_column = internal_atoll(last_colon + 1);
 249   // Truncate the string at the last colon and find the next-to-last colon.
 250   *last_colon = '\0';
 251   last_colon = internal_strrchr(file_line_info, ':');
 252   if (last_colon && IsDigit(last_colon[1])) {
 253     // If the second-to-last colon is followed by a digit, it must be the line
 254     // number, and the previous parsed number was a column.
 255     info->line = internal_atoll(last_colon + 1);
 256     info->column = line_or_column;
 257     *last_colon = '\0';
 258   } else {
 259     // Otherwise, we have line info but no column info.
 260     info->line = line_or_column;
 261     info->column = 0;
 262   }
 263   ExtractToken(file_line_info, "", &info->file);
 264   InternalFree(file_line_info);
 265   return str;
 266 }
 267
 268 // Parses one or more two-line strings in the following format:
 269 //   <function_name>
 270 //   <file_name>:<line_number>[:<column_number>]
 271 // Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of
 272 // them use the same output format.
 273 void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res) {
 274   bool top_frame = true;
 275   SymbolizedStack *last = res;
 276   while (true) {
 277     char *function_name = 0;
 278     str = ExtractToken(str, "\n", &function_name);
 279     CHECK(function_name);
 280     if (function_name[0] == '\0') {
 281       // There are no more frames.
 282       InternalFree(function_name);
 283       break;
 284     }
 285     SymbolizedStack *cur;
 286     if (top_frame) {
 287       cur = res;
 288       top_frame = false;
 289     } else {
 290       cur = SymbolizedStack::New(res->info.address);
 291       cur->info.FillModuleInfo(res->info.module, res->info.module_offset);
 292       last->next = cur;
 293       last = cur;
 294     }
 295
 296     AddressInfo *info = &cur->info;
 297     info->function = function_name;
 298     str = ParseFileLineInfo(info, str);
 299
 300     // Functions and filenames can be "??", in which case we write 0
 301     // to address info to mark that names are unknown.
 302     if (0 == internal_strcmp(info->function, "??")) {
 303       InternalFree(info->function);
 304       info->function = 0;
 305     }
 306     if (0 == internal_strcmp(info->file, "??")) {
 307       InternalFree(info->file);
 308       info->file = 0;
 309     }
 310   }
 311 }
 312
 313 // Parses a two-line string in the following format:
 314 //   <symbol_name>
 315 //   <start_address> <size>
 316 // Used by LLVMSymbolizer and InternalSymbolizer.
 317 void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
 318   str = ExtractToken(str, "\n", &info->name);
 319   str = ExtractUptr(str, " ", &info->start);
 320   str = ExtractUptr(str, "\n", &info->size);
 321 }
 322
 323 bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
 324   if (const char *buf = SendCommand(/*is_data*/ false, stack->info.module,
 325                                     stack->info.module_offset)) {
 326     ParseSymbolizePCOutput(buf, stack);
 327     return true;
 328   }
 329   return false;
 330 }
 331
 332 bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
 333   if (const char *buf =
 334           SendCommand(/*is_data*/ true, info->module, info->module_offset)) {
 335     ParseSymbolizeDataOutput(buf, info);
 336     info->start += (addr - info->module_offset); // Add the base address.
 337     return true;
 338   }
 339   return false;
 340 }
 341
 342 const char *LLVMSymbolizer::SendCommand(bool is_data, const char *module_name,
 343                                         uptr module_offset) {
 344   CHECK(module_name);
 345   internal_snprintf(buffer_, kBufferSize, "%s\"%s\" 0x%zx\n",
 346                     is_data ? "DATA " : "", module_name, module_offset);
 347   return symbolizer_process_->SendCommand(buffer_);
 348 }
 349
 350 SymbolizerProcess::SymbolizerProcess(const char *path, bool use_forkpty)
 351     : path_(path),
 352       input_fd_(kInvalidFd),
 353       output_fd_(kInvalidFd),
 354       times_restarted_(0),
 355       failed_to_start_(false),
 356       reported_invalid_path_(false),
 357       use_forkpty_(use_forkpty) {
 358   CHECK(path_);
 359   CHECK_NE(path_[0], '\0');
 360 }
 361
 362 const char *SymbolizerProcess::SendCommand(const char *command) {
 363   for (; times_restarted_ < kMaxTimesRestarted; times_restarted_++) {
 364     // Start or restart symbolizer if we failed to send command to it.
 365     if (const char *res = SendCommandImpl(command))
 366       return res;
 367     Restart();
 368   }
 369   if (!failed_to_start_) {
 370     Report("WARNING: Failed to use and restart external symbolizer!\n");
 371     failed_to_start_ = true;
 372   }
 373   return 0;
 374 }
 375
 376 const char *SymbolizerProcess::SendCommandImpl(const char *command) {
 377   if (input_fd_ == kInvalidFd || output_fd_ == kInvalidFd)
 378       return 0;
 379   if (!WriteToSymbolizer(command, internal_strlen(command)))
 380       return 0;
 381   if (!ReadFromSymbolizer(buffer_, kBufferSize))
 382       return 0;
 383   return buffer_;
 384 }
 385
 386 bool SymbolizerProcess::Restart() {
 387   if (input_fd_ != kInvalidFd)
 388     CloseFile(input_fd_);
 389   if (output_fd_ != kInvalidFd)
 390     CloseFile(output_fd_);
 391   return StartSymbolizerSubprocess();
 392 }
 393
 394 bool SymbolizerProcess::ReadFromSymbolizer(char *buffer, uptr max_length) {
 395   if (max_length == 0)
 396     return true;
 397   uptr read_len = 0;
 398   while (true) {
 399     uptr just_read = 0;
 400     bool success = ReadFromFile(input_fd_, buffer + read_len,
 401                                 max_length - read_len - 1, &just_read);
 402     // We can't read 0 bytes, as we don't expect external symbolizer to close
 403     // its stdout.
 404     if (!success || just_read == 0) {
 405       Report("WARNING: Can't read from symbolizer at fd %d\n", input_fd_);
 406       return false;
 407     }
 408     read_len += just_read;
 409     if (ReachedEndOfOutput(buffer, read_len))
 410       break;
 411   }
 412   buffer[read_len] = '\0';
 413   return true;
 414 }
 415
 416 bool SymbolizerProcess::WriteToSymbolizer(const char *buffer, uptr length) {
 417   if (length == 0)
 418     return true;
 419   uptr write_len = 0;
 420   bool success = WriteToFile(output_fd_, buffer, length, &write_len);
 421   if (!success || write_len != length) {
 422     Report("WARNING: Can't write to symbolizer at fd %d\n", output_fd_);
 423     return false;
 424   }
 425   return true;
 426 }
 427
 428 }  // namespace __sanitizer