OLD | NEW |
1 // Copyright (c) 2009, Google Inc. | 1 // Copyright (c) 2009, Google Inc. |
2 // All rights reserved. | 2 // All rights reserved. |
3 // | 3 // |
4 // Redistribution and use in source and binary forms, with or without | 4 // Redistribution and use in source and binary forms, with or without |
5 // modification, are permitted provided that the following conditions are | 5 // modification, are permitted provided that the following conditions are |
6 // met: | 6 // met: |
7 // | 7 // |
8 // * Redistributions of source code must retain the above copyright | 8 // * Redistributions of source code must retain the above copyright |
9 // notice, this list of conditions and the following disclaimer. | 9 // notice, this list of conditions and the following disclaimer. |
10 // * Redistributions in binary form must reproduce the above | 10 // * Redistributions in binary form must reproduce the above |
(...skipping 30 matching lines...) Expand all Loading... |
41 #endif | 41 #endif |
42 #ifdef HAVE_SYS_SOCKET_H | 42 #ifdef HAVE_SYS_SOCKET_H |
43 #include <sys/socket.h> // for socketpair() -- needed by Symbolize | 43 #include <sys/socket.h> // for socketpair() -- needed by Symbolize |
44 #endif | 44 #endif |
45 #ifdef HAVE_SYS_WAIT_H | 45 #ifdef HAVE_SYS_WAIT_H |
46 #include <sys/wait.h> // for wait() -- needed by Symbolize | 46 #include <sys/wait.h> // for wait() -- needed by Symbolize |
47 #endif | 47 #endif |
48 #ifdef HAVE_POLL_H | 48 #ifdef HAVE_POLL_H |
49 #include <poll.h> | 49 #include <poll.h> |
50 #endif | 50 #endif |
| 51 #ifdef __MACH__ |
| 52 #include <mach-o/dyld.h> // for GetProgramInvocationName() |
| 53 #include <limits.h> // for PATH_MAX |
| 54 #endif |
| 55 #if defined(__CYGWIN__) || defined(__CYGWIN32__) |
| 56 #include <io.h> // for get_osfhandle() |
| 57 #endif |
51 #include <string> | 58 #include <string> |
52 #include "base/commandlineflags.h" | 59 #include "base/commandlineflags.h" |
| 60 #include "base/logging.h" |
53 #include "base/sysinfo.h" | 61 #include "base/sysinfo.h" |
54 | 62 |
55 using std::string; | 63 using std::string; |
56 using tcmalloc::DumpProcSelfMaps; // from sysinfo.h | 64 using tcmalloc::DumpProcSelfMaps; // from sysinfo.h |
57 | 65 |
58 | 66 |
59 DEFINE_string(symbolize_pprof, | 67 DEFINE_string(symbolize_pprof, |
60 EnvToString("PPROF_PATH", "pprof"), | 68 EnvToString("PPROF_PATH", "pprof"), |
61 "Path to pprof to call for reporting function names."); | 69 "Path to pprof to call for reporting function names."); |
62 | 70 |
63 // heap_profile_table_pprof may be referenced after destructors are | 71 // heap_profile_table_pprof may be referenced after destructors are |
64 // called (since that's when leak-checking is done), so we make | 72 // called (since that's when leak-checking is done), so we make |
65 // a more-permanent copy that won't ever get destroyed. | 73 // a more-permanent copy that won't ever get destroyed. |
66 static string* g_pprof_path = new string(FLAGS_symbolize_pprof); | 74 static string* g_pprof_path = new string(FLAGS_symbolize_pprof); |
67 | 75 |
| 76 // Returns NULL if we're on an OS where we can't get the invocation name. |
| 77 // Using a static var is ok because we're not called from a thread. |
| 78 static char* GetProgramInvocationName() { |
| 79 #if defined(HAVE_PROGRAM_INVOCATION_NAME) |
| 80 extern char* program_invocation_name; // gcc provides this |
| 81 return program_invocation_name; |
| 82 #elif defined(__MACH__) |
| 83 // We don't want to allocate memory for this since we may be |
| 84 // calculating it when memory is corrupted. |
| 85 static char program_invocation_name[PATH_MAX]; |
| 86 if (program_invocation_name[0] == '\0') { // first time calculating |
| 87 uint32_t length = sizeof(program_invocation_name); |
| 88 if (_NSGetExecutablePath(program_invocation_name, &length)) |
| 89 return NULL; |
| 90 } |
| 91 return program_invocation_name; |
| 92 #else |
| 93 return NULL; // figure out a way to get argv[0] |
| 94 #endif |
| 95 } |
| 96 |
| 97 // Prints an error message when you can't run Symbolize(). |
| 98 static void PrintError(const char* reason) { |
| 99 RAW_LOG(ERROR, |
| 100 "*** WARNING: Cannot convert addresses to symbols in output below.\n" |
| 101 "*** Reason: %s\n" |
| 102 "*** If you cannot fix this, try running pprof directly.\n", |
| 103 reason); |
| 104 } |
| 105 |
68 void SymbolTable::Add(const void* addr) { | 106 void SymbolTable::Add(const void* addr) { |
69 symbolization_table_[addr] = ""; | 107 symbolization_table_[addr] = ""; |
70 } | 108 } |
71 | 109 |
72 const char* SymbolTable::GetSymbol(const void* addr) { | 110 const char* SymbolTable::GetSymbol(const void* addr) { |
73 return symbolization_table_[addr]; | 111 return symbolization_table_[addr]; |
74 } | 112 } |
75 | 113 |
76 // Updates symbolization_table with the pointers to symbol names corresponding | 114 // Updates symbolization_table with the pointers to symbol names corresponding |
77 // to its keys. The symbol names are stored in out, which is allocated and | 115 // to its keys. The symbol names are stored in out, which is allocated and |
78 // freed by the caller of this routine. | 116 // freed by the caller of this routine. |
79 // Note that the forking/etc is not thread-safe or re-entrant. That's | 117 // Note that the forking/etc is not thread-safe or re-entrant. That's |
80 // ok for the purpose we need -- reporting leaks detected by heap-checker | 118 // ok for the purpose we need -- reporting leaks detected by heap-checker |
81 // -- but be careful if you decide to use this routine for other purposes. | 119 // -- but be careful if you decide to use this routine for other purposes. |
| 120 // Returns number of symbols read on error. If can't symbolize, returns 0 |
| 121 // and emits an error message about why. |
82 int SymbolTable::Symbolize() { | 122 int SymbolTable::Symbolize() { |
83 #if !defined(HAVE_UNISTD_H) || !defined(HAVE_SYS_SOCKET_H) || !defined(HAVE_SYS
_WAIT_H) | 123 #if !defined(HAVE_UNISTD_H) || !defined(HAVE_SYS_SOCKET_H) || !defined(HAVE_SYS
_WAIT_H) |
| 124 PrintError("Perftools does not know how to call a sub-process on this O/S"); |
84 return 0; | 125 return 0; |
85 #elif !defined(HAVE_PROGRAM_INVOCATION_NAME) | |
86 return 0; // TODO(csilvers): get argv[0] somehow | |
87 #else | 126 #else |
| 127 const char* argv0 = GetProgramInvocationName(); |
| 128 if (argv0 == NULL) { // can't call symbolize if we can't figure out our name |
| 129 PrintError("Cannot figure out the name of this executable (argv0)"); |
| 130 return 0; |
| 131 } |
| 132 if (access(g_pprof_path->c_str(), R_OK) != 0) { |
| 133 PrintError("Cannot find 'pprof' (is PPROF_PATH set correctly?)"); |
| 134 return 0; |
| 135 } |
| 136 |
88 // All this work is to do two-way communication. ugh. | 137 // All this work is to do two-way communication. ugh. |
89 extern char* program_invocation_name; // gcc provides this | |
90 int *child_in = NULL; // file descriptors | 138 int *child_in = NULL; // file descriptors |
91 int *child_out = NULL; // for now, we don't worry about child_err | 139 int *child_out = NULL; // for now, we don't worry about child_err |
92 int child_fds[5][2]; // socketpair may be called up to five times below | 140 int child_fds[5][2]; // socketpair may be called up to five times below |
93 | 141 |
94 // The client program may close its stdin and/or stdout and/or stderr | 142 // The client program may close its stdin and/or stdout and/or stderr |
95 // thus allowing socketpair to reuse file descriptors 0, 1 or 2. | 143 // thus allowing socketpair to reuse file descriptors 0, 1 or 2. |
96 // In this case the communication between the forked processes may be broken | 144 // In this case the communication between the forked processes may be broken |
97 // if either the parent or the child tries to close or duplicate these | 145 // if either the parent or the child tries to close or duplicate these |
98 // descriptors. The loop below produces two pairs of file descriptors, each | 146 // descriptors. The loop below produces two pairs of file descriptors, each |
99 // greater than 2 (stderr). | 147 // greater than 2 (stderr). |
100 for (int i = 0; i < 5; i++) { | 148 for (int i = 0; i < 5; i++) { |
101 if (socketpair(AF_UNIX, SOCK_STREAM, 0, child_fds[i]) == -1) { | 149 if (socketpair(AF_UNIX, SOCK_STREAM, 0, child_fds[i]) == -1) { |
102 for (int j = 0; j < i; j++) { | 150 for (int j = 0; j < i; j++) { |
103 close(child_fds[j][0]); | 151 close(child_fds[j][0]); |
104 close(child_fds[j][1]); | 152 close(child_fds[j][1]); |
| 153 PrintError("Cannot create a socket pair"); |
105 return 0; | 154 return 0; |
106 } | 155 } |
107 } else { | 156 } else { |
108 if ((child_fds[i][0] > 2) && (child_fds[i][1] > 2)) { | 157 if ((child_fds[i][0] > 2) && (child_fds[i][1] > 2)) { |
109 if (child_in == NULL) { | 158 if (child_in == NULL) { |
110 child_in = child_fds[i]; | 159 child_in = child_fds[i]; |
111 } else { | 160 } else { |
112 child_out = child_fds[i]; | 161 child_out = child_fds[i]; |
113 for (int j = 0; j < i; j++) { | 162 for (int j = 0; j < i; j++) { |
114 if (child_fds[j] == child_in) continue; | 163 if (child_fds[j] == child_in) continue; |
115 close(child_fds[j][0]); | 164 close(child_fds[j][0]); |
116 close(child_fds[j][1]); | 165 close(child_fds[j][1]); |
117 } | 166 } |
118 break; | 167 break; |
119 } | 168 } |
120 } | 169 } |
121 } | 170 } |
122 } | 171 } |
123 | 172 |
124 switch (fork()) { | 173 switch (fork()) { |
125 case -1: { // error | 174 case -1: { // error |
126 close(child_in[0]); | 175 close(child_in[0]); |
127 close(child_in[1]); | 176 close(child_in[1]); |
128 close(child_out[0]); | 177 close(child_out[0]); |
129 close(child_out[1]); | 178 close(child_out[1]); |
| 179 PrintError("Unknown error calling fork()"); |
130 return 0; | 180 return 0; |
131 } | 181 } |
132 case 0: { // child | 182 case 0: { // child |
133 close(child_in[1]); // child uses the 0's, parent uses the 1's | 183 close(child_in[1]); // child uses the 0's, parent uses the 1's |
134 close(child_out[1]); // child uses the 0's, parent uses the 1's | 184 close(child_out[1]); // child uses the 0's, parent uses the 1's |
135 close(0); | 185 close(0); |
136 close(1); | 186 close(1); |
137 if (dup2(child_in[0], 0) == -1) _exit(1); | 187 if (dup2(child_in[0], 0) == -1) _exit(1); |
138 if (dup2(child_out[0], 1) == -1) _exit(2); | 188 if (dup2(child_out[0], 1) == -1) _exit(2); |
139 // Unset vars that might cause trouble when we fork | 189 // Unset vars that might cause trouble when we fork |
140 unsetenv("CPUPROFILE"); | 190 unsetenv("CPUPROFILE"); |
141 unsetenv("HEAPPROFILE"); | 191 unsetenv("HEAPPROFILE"); |
142 unsetenv("HEAPCHECK"); | 192 unsetenv("HEAPCHECK"); |
143 unsetenv("PERFTOOLS_VERBOSE"); | 193 unsetenv("PERFTOOLS_VERBOSE"); |
144 execlp(g_pprof_path->c_str(), g_pprof_path->c_str(), | 194 execlp(g_pprof_path->c_str(), g_pprof_path->c_str(), |
145 "--symbols", program_invocation_name, NULL); | 195 "--symbols", argv0, NULL); |
146 _exit(3); // if execvp fails, it's bad news for us | 196 _exit(3); // if execvp fails, it's bad news for us |
147 } | 197 } |
148 default: { // parent | 198 default: { // parent |
149 close(child_in[0]); // child uses the 0's, parent uses the 1's | 199 close(child_in[0]); // child uses the 0's, parent uses the 1's |
150 close(child_out[0]); // child uses the 0's, parent uses the 1's | 200 close(child_out[0]); // child uses the 0's, parent uses the 1's |
151 #ifdef HAVE_POLL_H | 201 #ifdef HAVE_POLL_H |
| 202 // Waiting for 1ms seems to give the OS time to notice any errors. |
| 203 poll(0, 0, 1); |
152 // For maximum safety, we check to make sure the execlp | 204 // For maximum safety, we check to make sure the execlp |
153 // succeeded before trying to write. (Otherwise we'll get a | 205 // succeeded before trying to write. (Otherwise we'll get a |
154 // SIGPIPE.) For systems without poll.h, we'll just skip this | 206 // SIGPIPE.) For systems without poll.h, we'll just skip this |
155 // check, and trust that the user set PPROF_PATH correctly! | 207 // check, and trust that the user set PPROF_PATH correctly! |
156 struct pollfd pfd = { child_in[1], POLLOUT, 0 }; | 208 struct pollfd pfd = { child_in[1], POLLOUT, 0 }; |
157 if (!poll(&pfd, 1, 0) || !(pfd.revents & POLLOUT) || | 209 if (!poll(&pfd, 1, 0) || !(pfd.revents & POLLOUT) || |
158 (pfd.revents & (POLLHUP|POLLERR))) { | 210 (pfd.revents & (POLLHUP|POLLERR))) { |
| 211 PrintError("Cannot run 'pprof' (is PPROF_PATH set correctly?)"); |
159 return 0; | 212 return 0; |
160 } | 213 } |
161 #endif | 214 #endif |
| 215 #if defined(__CYGWIN__) || defined(__CYGWIN32__) |
| 216 // On cygwin, DumpProcSelfMaps() takes a HANDLE, not an fd. Convert. |
| 217 const HANDLE symbols_handle = (HANDLE) get_osfhandle(child_in[1]); |
| 218 DumpProcSelfMaps(symbols_handle); |
| 219 #else |
162 DumpProcSelfMaps(child_in[1]); // what pprof expects on stdin | 220 DumpProcSelfMaps(child_in[1]); // what pprof expects on stdin |
| 221 #endif |
163 | 222 |
164 // Allocate 24 bytes = ("0x" + 8 bytes + "\n" + overhead) for each | 223 // Allocate 24 bytes = ("0x" + 8 bytes + "\n" + overhead) for each |
165 // address to feed to pprof. | 224 // address to feed to pprof. |
166 const int kOutBufSize = 24 * symbolization_table_.size(); | 225 const int kOutBufSize = 24 * symbolization_table_.size(); |
167 char *pprof_buffer = new char[kOutBufSize]; | 226 char *pprof_buffer = new char[kOutBufSize]; |
168 int written = 0; | 227 int written = 0; |
169 for (SymbolMap::const_iterator iter = symbolization_table_.begin(); | 228 for (SymbolMap::const_iterator iter = symbolization_table_.begin(); |
170 iter != symbolization_table_.end(); ++iter) { | 229 iter != symbolization_table_.end(); ++iter) { |
171 written += snprintf(pprof_buffer + written, kOutBufSize - written, | 230 written += snprintf(pprof_buffer + written, kOutBufSize - written, |
172 // pprof expects format to be 0xXXXXXX | 231 // pprof expects format to be 0xXXXXXX |
173 "0x%"PRIxPTR"\n", reinterpret_cast<uintptr_t>(iter->first)); | 232 "0x%"PRIxPTR"\n", reinterpret_cast<uintptr_t>(iter->first)); |
174 } | 233 } |
175 write(child_in[1], pprof_buffer, strlen(pprof_buffer)); | 234 write(child_in[1], pprof_buffer, strlen(pprof_buffer)); |
176 close(child_in[1]); // that's all we need to write | 235 close(child_in[1]); // that's all we need to write |
177 | 236 |
178 const int kSymbolBufferSize = kSymbolSize * symbolization_table_.size(); | 237 const int kSymbolBufferSize = kSymbolSize * symbolization_table_.size(); |
179 int total_bytes_read = 0; | 238 int total_bytes_read = 0; |
180 delete[] symbol_buffer_; | 239 delete[] symbol_buffer_; |
181 symbol_buffer_ = new char[kSymbolBufferSize]; | 240 symbol_buffer_ = new char[kSymbolBufferSize]; |
182 memset(symbol_buffer_, '\0', kSymbolBufferSize); | 241 memset(symbol_buffer_, '\0', kSymbolBufferSize); |
183 while (1) { | 242 while (1) { |
184 int bytes_read = read(child_out[1], symbol_buffer_ + total_bytes_read, | 243 int bytes_read = read(child_out[1], symbol_buffer_ + total_bytes_read, |
185 kSymbolBufferSize - total_bytes_read); | 244 kSymbolBufferSize - total_bytes_read); |
186 if (bytes_read < 0) { | 245 if (bytes_read < 0) { |
187 close(child_out[1]); | 246 close(child_out[1]); |
| 247 PrintError("Cannot read data from pprof"); |
188 return 0; | 248 return 0; |
189 } else if (bytes_read == 0) { | 249 } else if (bytes_read == 0) { |
190 close(child_out[1]); | 250 close(child_out[1]); |
191 wait(NULL); | 251 wait(NULL); |
192 break; | 252 break; |
193 } else { | 253 } else { |
194 total_bytes_read += bytes_read; | 254 total_bytes_read += bytes_read; |
195 } | 255 } |
196 } | 256 } |
197 // We have successfully read the output of pprof into out. Make sure | 257 // We have successfully read the output of pprof into out. Make sure |
198 // the last symbol is full (we can tell because it ends with a \n). | 258 // the last symbol is full (we can tell because it ends with a \n). |
199 if (total_bytes_read == 0 || symbol_buffer_[total_bytes_read - 1] != '\n') | 259 if (total_bytes_read == 0 || symbol_buffer_[total_bytes_read - 1] != '\n') |
200 return 0; | 260 return 0; |
201 // make the symbolization_table_ values point to the output vector | 261 // make the symbolization_table_ values point to the output vector |
202 SymbolMap::iterator fill = symbolization_table_.begin(); | 262 SymbolMap::iterator fill = symbolization_table_.begin(); |
203 int num_symbols = 0; | 263 int num_symbols = 0; |
204 const char *current_name = symbol_buffer_; | 264 const char *current_name = symbol_buffer_; |
205 for (int i = 0; i < total_bytes_read; i++) { | 265 for (int i = 0; i < total_bytes_read; i++) { |
206 if (symbol_buffer_[i] == '\n') { | 266 if (symbol_buffer_[i] == '\n') { |
207 fill->second = current_name; | 267 fill->second = current_name; |
208 symbol_buffer_[i] = '\0'; | 268 symbol_buffer_[i] = '\0'; |
209 current_name = symbol_buffer_ + i + 1; | 269 current_name = symbol_buffer_ + i + 1; |
210 fill++; | 270 fill++; |
211 num_symbols++; | 271 num_symbols++; |
212 } | 272 } |
213 } | 273 } |
214 return num_symbols; | 274 return num_symbols; |
215 } | 275 } |
216 } | 276 } |
| 277 PrintError("Unkown error (should never occur!)"); |
217 return 0; // shouldn't be reachable | 278 return 0; // shouldn't be reachable |
218 #endif | 279 #endif |
219 } | 280 } |
OLD | NEW |