1 //===-- sanitizer_symbolizer_posix_libcdep.cc -----------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // POSIX-specific implementation of symbolizer parts.
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_platform.h"
15 #include "sanitizer_allocator_internal.h"
16 #include "sanitizer_common.h"
17 #include "sanitizer_flags.h"
18 #include "sanitizer_internal_defs.h"
19 #include "sanitizer_linux.h"
20 #include "sanitizer_placement_new.h"
21 #include "sanitizer_posix.h"
22 #include "sanitizer_procmaps.h"
23 #include "sanitizer_symbolizer_internal.h"
24 #include "sanitizer_symbolizer_libbacktrace.h"
25 #include "sanitizer_symbolizer_mac.h"
33 #include <util.h> // for forkpty()
34 #endif // SANITIZER_MAC
36 // C++ demangling function, as required by Itanium C++ ABI. This is weak,
37 // because we do not require a C++ ABI library to be linked to a program
38 // using sanitizers; if it's not present, we'll just use the mangled name.
39 namespace __cxxabiv1
{
40 extern "C" SANITIZER_WEAK_ATTRIBUTE
41 char *__cxa_demangle(const char *mangled
, char *buffer
,
42 size_t *length
, int *status
);
45 namespace __sanitizer
{
47 // Attempts to demangle the name via __cxa_demangle from __cxxabiv1.
48 const char *DemangleCXXABI(const char *name
) {
49 // FIXME: __cxa_demangle aggressively insists on allocating memory.
50 // There's not much we can do about that, short of providing our
51 // own demangler (libc++abi's implementation could be adapted so that
52 // it does not allocate). For now, we just call it anyway, and we leak
53 // the returned value.
54 if (__cxxabiv1::__cxa_demangle
)
55 if (const char *demangled_name
=
56 __cxxabiv1::__cxa_demangle(name
, 0, 0, 0))
57 return demangled_name
;
62 bool SymbolizerProcess::StartSymbolizerSubprocess() {
63 if (!FileExists(path_
)) {
64 if (!reported_invalid_path_
) {
65 Report("WARNING: invalid path to external symbolizer!\n");
66 reported_invalid_path_
= true;
75 // Use forkpty to disable buffering in the new terminal.
76 pid
= forkpty(&fd
, 0, 0, 0);
79 Report("WARNING: failed to fork external symbolizer (errno: %d)\n",
82 } else if (pid
== 0) {
84 const char *argv
[kArgVMax
];
86 execv(path_
, const_cast<char **>(&argv
[0]));
90 // Continue execution in parent process.
91 input_fd_
= output_fd_
= fd
;
93 // Disable echo in the new terminal, disable CR.
94 struct termios termflags
;
95 tcgetattr(fd
, &termflags
);
96 termflags
.c_oflag
&= ~ONLCR
;
97 termflags
.c_lflag
&= ~ECHO
;
98 tcsetattr(fd
, TCSANOW
, &termflags
);
99 #else // SANITIZER_MAC
101 #endif // SANITIZER_MAC
105 // The client program may close its stdin and/or stdout and/or stderr
106 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
107 // In this case the communication between the forked processes may be
108 // broken if either the parent or the child tries to close or duplicate
109 // these descriptors. The loop below produces two pairs of file
110 // descriptors, each greater than 2 (stderr).
112 for (int i
= 0; i
< 5; i
++) {
113 if (pipe(sock_pair
[i
]) == -1) {
114 for (int j
= 0; j
< i
; j
++) {
115 internal_close(sock_pair
[j
][0]);
116 internal_close(sock_pair
[j
][1]);
118 Report("WARNING: Can't create a socket pair to start "
119 "external symbolizer (errno: %d)\n", errno
);
121 } else if (sock_pair
[i
][0] > 2 && sock_pair
[i
][1] > 2) {
125 outfd
= sock_pair
[i
];
126 for (int j
= 0; j
< i
; j
++) {
127 if (sock_pair
[j
] == infd
) continue;
128 internal_close(sock_pair
[j
][0]);
129 internal_close(sock_pair
[j
][1]);
138 // Real fork() may call user callbacks registered with pthread_atfork().
139 pid
= internal_fork();
142 internal_close(infd
[0]);
143 internal_close(infd
[1]);
144 internal_close(outfd
[0]);
145 internal_close(outfd
[1]);
146 Report("WARNING: failed to fork external symbolizer "
147 " (errno: %d)\n", errno
);
149 } else if (pid
== 0) {
151 internal_close(STDOUT_FILENO
);
152 internal_close(STDIN_FILENO
);
153 internal_dup2(outfd
[0], STDIN_FILENO
);
154 internal_dup2(infd
[1], STDOUT_FILENO
);
155 internal_close(outfd
[0]);
156 internal_close(outfd
[1]);
157 internal_close(infd
[0]);
158 internal_close(infd
[1]);
159 for (int fd
= sysconf(_SC_OPEN_MAX
); fd
> 2; fd
--)
161 const char *argv
[kArgVMax
];
162 GetArgV(path_
, argv
);
163 execv(path_
, const_cast<char **>(&argv
[0]));
167 // Continue execution in parent process.
168 internal_close(outfd
[0]);
169 internal_close(infd
[1]);
171 output_fd_
= outfd
[1];
174 // Check that symbolizer subprocess started successfully.
176 SleepForMillis(kSymbolizerStartupTimeMillis
);
177 int exited_pid
= waitpid(pid
, &pid_status
, WNOHANG
);
178 if (exited_pid
!= 0) {
179 // Either waitpid failed, or child has already exited.
180 Report("WARNING: external symbolizer didn't start up correctly!\n");
187 class Addr2LineProcess
: public SymbolizerProcess
{
189 Addr2LineProcess(const char *path
, const char *module_name
)
190 : SymbolizerProcess(path
), module_name_(internal_strdup(module_name
)) {}
192 const char *module_name() const { return module_name_
; }
195 void GetArgV(const char *path_to_binary
,
196 const char *(&argv
)[kArgVMax
]) const override
{
198 argv
[i
++] = path_to_binary
;
200 argv
[i
++] = module_name_
;
204 bool ReachedEndOfOutput(const char *buffer
, uptr length
) const override
;
206 bool ReadFromSymbolizer(char *buffer
, uptr max_length
) override
{
207 if (!SymbolizerProcess::ReadFromSymbolizer(buffer
, max_length
))
209 // We should cut out output_terminator_ at the end of given buffer,
210 // appended by addr2line to mark the end of its meaningful output.
211 // We cannot scan buffer from it's beginning, because it is legal for it
212 // to start with output_terminator_ in case given offset is invalid. So,
213 // scanning from second character.
214 char *garbage
= internal_strstr(buffer
+ 1, output_terminator_
);
215 // This should never be NULL since buffer must end up with
216 // output_terminator_.
223 const char *module_name_
; // Owned, leaked.
224 static const char output_terminator_
[];
227 const char Addr2LineProcess::output_terminator_
[] = "??\n??:0\n";
229 bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer
,
231 const size_t kTerminatorLen
= sizeof(output_terminator_
) - 1;
232 // Skip, if we read just kTerminatorLen bytes, because Addr2Line output
233 // should consist at least of two pairs of lines:
234 // 1. First one, corresponding to given offset to be symbolized
235 // (may be equal to output_terminator_, if offset is not valid).
236 // 2. Second one for output_terminator_, itself to mark the end of output.
237 if (length
<= kTerminatorLen
) return false;
238 // Addr2Line output should end up with output_terminator_.
239 return !internal_memcmp(buffer
+ length
- kTerminatorLen
,
240 output_terminator_
, kTerminatorLen
);
243 class Addr2LinePool
: public SymbolizerTool
{
245 explicit Addr2LinePool(const char *addr2line_path
,
246 LowLevelAllocator
*allocator
)
247 : addr2line_path_(addr2line_path
), allocator_(allocator
),
248 addr2line_pool_(16) {}
250 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
251 if (const char *buf
=
252 SendCommand(stack
->info
.module
, stack
->info
.module_offset
)) {
253 ParseSymbolizePCOutput(buf
, stack
);
259 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
264 const char *SendCommand(const char *module_name
, uptr module_offset
) {
265 Addr2LineProcess
*addr2line
= 0;
266 for (uptr i
= 0; i
< addr2line_pool_
.size(); ++i
) {
268 internal_strcmp(module_name
, addr2line_pool_
[i
]->module_name())) {
269 addr2line
= addr2line_pool_
[i
];
275 new(*allocator_
) Addr2LineProcess(addr2line_path_
, module_name
);
276 addr2line_pool_
.push_back(addr2line
);
278 CHECK_EQ(0, internal_strcmp(module_name
, addr2line
->module_name()));
279 char buffer
[kBufferSize
];
280 internal_snprintf(buffer
, kBufferSize
, "0x%zx\n0x%zx\n",
281 module_offset
, dummy_address_
);
282 return addr2line
->SendCommand(buffer
);
285 static const uptr kBufferSize
= 64;
286 const char *addr2line_path_
;
287 LowLevelAllocator
*allocator_
;
288 InternalMmapVector
<Addr2LineProcess
*> addr2line_pool_
;
289 static const uptr dummy_address_
=
290 FIRST_32_SECOND_64(UINT32_MAX
, UINT64_MAX
);
293 #if SANITIZER_SUPPORTS_WEAK_HOOKS
295 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
296 bool __sanitizer_symbolize_code(const char *ModuleName
, u64 ModuleOffset
,
297 char *Buffer
, int MaxLength
);
298 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
299 bool __sanitizer_symbolize_data(const char *ModuleName
, u64 ModuleOffset
,
300 char *Buffer
, int MaxLength
);
301 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
302 void __sanitizer_symbolize_flush();
303 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
304 int __sanitizer_symbolize_demangle(const char *Name
, char *Buffer
,
308 class InternalSymbolizer
: public SymbolizerTool
{
310 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) {
311 if (__sanitizer_symbolize_code
!= 0 &&
312 __sanitizer_symbolize_data
!= 0) {
313 return new(*alloc
) InternalSymbolizer();
318 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
319 bool result
= __sanitizer_symbolize_code(
320 stack
->info
.module
, stack
->info
.module_offset
, buffer_
, kBufferSize
);
321 if (result
) ParseSymbolizePCOutput(buffer_
, stack
);
325 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
326 bool result
= __sanitizer_symbolize_data(info
->module
, info
->module_offset
,
327 buffer_
, kBufferSize
);
329 ParseSymbolizeDataOutput(buffer_
, info
);
330 info
->start
+= (addr
- info
->module_offset
); // Add the base address.
335 void Flush() override
{
336 if (__sanitizer_symbolize_flush
)
337 __sanitizer_symbolize_flush();
340 const char *Demangle(const char *name
) override
{
341 if (__sanitizer_symbolize_demangle
) {
342 for (uptr res_length
= 1024;
343 res_length
<= InternalSizeClassMap::kMaxSize
;) {
344 char *res_buff
= static_cast<char*>(InternalAlloc(res_length
));
346 __sanitizer_symbolize_demangle(name
, res_buff
, res_length
);
347 if (req_length
> res_length
) {
348 res_length
= req_length
+ 1;
349 InternalFree(res_buff
);
359 InternalSymbolizer() { }
361 static const int kBufferSize
= 16 * 1024;
362 static const int kMaxDemangledNameSize
= 1024;
363 char buffer_
[kBufferSize
];
365 #else // SANITIZER_SUPPORTS_WEAK_HOOKS
367 class InternalSymbolizer
: public SymbolizerTool
{
369 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) { return 0; }
372 #endif // SANITIZER_SUPPORTS_WEAK_HOOKS
374 const char *Symbolizer::PlatformDemangle(const char *name
) {
375 return DemangleCXXABI(name
);
378 void Symbolizer::PlatformPrepareForSandboxing() {}
380 static SymbolizerTool
*ChooseExternalSymbolizer(LowLevelAllocator
*allocator
) {
381 const char *path
= common_flags()->external_symbolizer_path
;
382 const char *binary_name
= path
? StripModuleName(path
) : "";
383 if (path
&& path
[0] == '\0') {
384 VReport(2, "External symbolizer is explicitly disabled.\n");
386 } else if (!internal_strcmp(binary_name
, "llvm-symbolizer")) {
387 VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path
);
388 return new(*allocator
) LLVMSymbolizer(path
, allocator
);
389 } else if (!internal_strcmp(binary_name
, "atos")) {
391 VReport(2, "Using atos at user-specified path: %s\n", path
);
392 return new(*allocator
) AtosSymbolizer(path
, allocator
);
393 #else // SANITIZER_MAC
394 Report("ERROR: Using `atos` is only supported on Darwin.\n");
396 #endif // SANITIZER_MAC
397 } else if (!internal_strcmp(binary_name
, "addr2line")) {
398 VReport(2, "Using addr2line at user-specified path: %s\n", path
);
399 return new(*allocator
) Addr2LinePool(path
, allocator
);
401 Report("ERROR: External symbolizer path is set to '%s' which isn't "
402 "a known symbolizer. Please set the path to the llvm-symbolizer "
403 "binary or other known tool.\n", path
);
407 // Otherwise symbolizer program is unknown, let's search $PATH
408 CHECK(path
== nullptr);
409 if (const char *found_path
= FindPathToBinary("llvm-symbolizer")) {
410 VReport(2, "Using llvm-symbolizer found at: %s\n", found_path
);
411 return new(*allocator
) LLVMSymbolizer(found_path
, allocator
);
414 if (const char *found_path
= FindPathToBinary("atos")) {
415 VReport(2, "Using atos found at: %s\n", found_path
);
416 return new(*allocator
) AtosSymbolizer(found_path
, allocator
);
418 #endif // SANITIZER_MAC
419 if (common_flags()->allow_addr2line
) {
420 if (const char *found_path
= FindPathToBinary("addr2line")) {
421 VReport(2, "Using addr2line found at: %s\n", found_path
);
422 return new(*allocator
) Addr2LinePool(found_path
, allocator
);
428 static void ChooseSymbolizerTools(IntrusiveList
<SymbolizerTool
> *list
,
429 LowLevelAllocator
*allocator
) {
430 if (!common_flags()->symbolize
) {
431 VReport(2, "Symbolizer is disabled.\n");
434 if (SymbolizerTool
*tool
= InternalSymbolizer::get(allocator
)) {
435 VReport(2, "Using internal symbolizer.\n");
436 list
->push_back(tool
);
439 if (SymbolizerTool
*tool
= LibbacktraceSymbolizer::get(allocator
)) {
440 VReport(2, "Using libbacktrace symbolizer.\n");
441 list
->push_back(tool
);
445 if (SymbolizerTool
*tool
= ChooseExternalSymbolizer(allocator
)) {
446 list
->push_back(tool
);
450 VReport(2, "Using dladdr symbolizer.\n");
451 list
->push_back(new(*allocator
) DlAddrSymbolizer());
452 #endif // SANITIZER_MAC
454 if (list
->size() == 0) {
455 Report("WARNING: no internal or external symbolizer found.\n");
459 Symbolizer
*Symbolizer::PlatformInit() {
460 IntrusiveList
<SymbolizerTool
> list
;
462 ChooseSymbolizerTools(&list
, &symbolizer_allocator_
);
463 return new(symbolizer_allocator_
) Symbolizer(list
);
466 } // namespace __sanitizer
468 #endif // SANITIZER_POSIX