• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
ExtractToken(const char * str,const char * delims,char ** result)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 
ExtractInt(const char * str,const char * delims,int * result)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 
ExtractUptr(const char * str,const char * delims,uptr * result)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 
ExtractTokenUpToDelimiter(const char * str,const char * delimiter,char ** result)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 
SymbolizePC(uptr addr)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 
SymbolizeData(uptr addr,DataInfo * info)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 
GetModuleNameAndOffsetForPC(uptr pc,const char ** module_name,uptr * module_address)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 
Flush()112 void Symbolizer::Flush() {
113   BlockingMutexLock l(&mu_);
114   for (auto &tool : tools_) {
115     SymbolizerScope sym_scope(this);
116     tool.Flush();
117   }
118 }
119 
Demangle(const char * name)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 
PrepareForSandboxing()130 void Symbolizer::PrepareForSandboxing() {
131   BlockingMutexLock l(&mu_);
132   PlatformPrepareForSandboxing();
133 }
134 
FindModuleNameAndOffsetForAddress(uptr address,const char ** module_name,uptr * module_offset)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 
FindModuleForAddress(uptr address)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 
GetOrInit()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:
LLVMSymbolizerProcess(const char * path)191   explicit LLVMSymbolizerProcess(const char *path) : SymbolizerProcess(path) {}
192 
193  private:
ReachedEndOfOutput(const char * buffer,uptr length) const194   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 
GetArgV(const char * path_to_binary,const char * (& argv)[kArgVMax]) const200   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 
LLVMSymbolizer(const char * path,LowLevelAllocator * allocator)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.
ParseFileLineInfo(AddressInfo * info,const char * str)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.
ParseSymbolizePCOutput(const char * str,SymbolizedStack * res)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.
ParseSymbolizeDataOutput(const char * str,DataInfo * info)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 
SymbolizePC(uptr addr,SymbolizedStack * stack)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 
SymbolizeData(uptr addr,DataInfo * info)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 
SendCommand(bool is_data,const char * module_name,uptr module_offset)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 
SymbolizerProcess(const char * path,bool use_forkpty)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 
SendCommand(const char * command)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 
SendCommandImpl(const char * command)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 
Restart()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 
ReadFromSymbolizer(char * buffer,uptr max_length)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 
WriteToSymbolizer(const char * buffer,uptr length)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
429