1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
//===-- sanitizer_symbolizer_mac.cc ---------------------------------------===//
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is shared between various sanitizers' runtime libraries.
//
// Implementation of Mac-specific "atos" symbolizer.
//===----------------------------------------------------------------------===//
#include "sanitizer_platform.h"
#if SANITIZER_MAC
#include "sanitizer_allocator_internal.h"
#include "sanitizer_mac.h"
#include "sanitizer_symbolizer_mac.h"
namespace __sanitizer {
#include <dlfcn.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <util.h>
bool DlAddrSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
Dl_info info;
int result = dladdr((const void *)addr, &info);
if (!result) return false;
const char *demangled = DemangleCXXABI(info.dli_sname);
stack->info.function = internal_strdup(demangled);
return true;
}
bool DlAddrSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
return false;
}
class AtosSymbolizerProcess : public SymbolizerProcess {
public:
explicit AtosSymbolizerProcess(const char *path, pid_t parent_pid)
: SymbolizerProcess(path, /*use_forkpty*/ true) {
// Put the string command line argument in the object so that it outlives
// the call to GetArgV.
internal_snprintf(pid_str_, sizeof(pid_str_), "%d", parent_pid);
}
private:
bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
return (length >= 1 && buffer[length - 1] == '\n');
}
void GetArgV(const char *path_to_binary,
const char *(&argv)[kArgVMax]) const override {
int i = 0;
argv[i++] = path_to_binary;
argv[i++] = "-p";
argv[i++] = &pid_str_[0];
if (GetMacosVersion() == MACOS_VERSION_MAVERICKS) {
// On Mavericks atos prints a deprecation warning which we suppress by
// passing -d. The warning isn't present on other OSX versions, even the
// newer ones.
argv[i++] = "-d";
}
argv[i++] = nullptr;
}
char pid_str_[16];
};
static const char *kAtosErrorMessages[] = {
"atos cannot examine process",
"unable to get permission to examine process",
"An admin user name and password is required",
"could not load inserted library",
"architecture mismatch between analysis process",
};
static bool IsAtosErrorMessage(const char *str) {
for (uptr i = 0; i < ARRAY_SIZE(kAtosErrorMessages); i++) {
if (internal_strstr(str, kAtosErrorMessages[i])) {
return true;
}
}
return false;
}
static bool ParseCommandOutput(const char *str, SymbolizedStack *res) {
// Trim ending newlines.
char *trim;
ExtractTokenUpToDelimiter(str, "\n", &trim);
// The line from `atos` is in one of these formats:
// myfunction (in library.dylib) (sourcefile.c:17)
// myfunction (in library.dylib) + 0x1fe
// 0xdeadbeef (in library.dylib) + 0x1fe
// 0xdeadbeef (in library.dylib)
// 0xdeadbeef
if (IsAtosErrorMessage(trim)) {
Report("atos returned an error: %s\n", trim);
InternalFree(trim);
return false;
}
const char *rest = trim;
char *function_name;
rest = ExtractTokenUpToDelimiter(rest, " (in ", &function_name);
if (internal_strncmp(function_name, "0x", 2) != 0)
res->info.function = function_name;
else
InternalFree(function_name);
rest = ExtractTokenUpToDelimiter(rest, ") ", &res->info.module);
if (rest[0] == '(') {
rest++;
rest = ExtractTokenUpToDelimiter(rest, ":", &res->info.file);
char *extracted_line_number;
rest = ExtractTokenUpToDelimiter(rest, ")", &extracted_line_number);
res->info.line = internal_atoll(extracted_line_number);
InternalFree(extracted_line_number);
}
InternalFree(trim);
return true;
}
AtosSymbolizer::AtosSymbolizer(const char *path, LowLevelAllocator *allocator)
: process_(new(*allocator) AtosSymbolizerProcess(path, getpid())) {}
bool AtosSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
if (!process_) return false;
char command[32];
internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
const char *buf = process_->SendCommand(command);
if (!buf) return false;
if (!ParseCommandOutput(buf, stack)) {
process_ = nullptr;
return false;
}
return true;
}
bool AtosSymbolizer::SymbolizeData(uptr addr, DataInfo *info) { return false; }
} // namespace __sanitizer
#endif // SANITIZER_MAC
|
