1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "CallStack" 18 19 #include <string.h> 20 #include <stdlib.h> 21 #include <stdio.h> 22 23 #if HAVE_DLADDR 24 #include <dlfcn.h> 25 #endif 26 27 #if HAVE_CXXABI 28 #include <cxxabi.h> 29 #endif 30 31 #include <unwind.h> 32 33 #include <utils/Log.h> 34 #include <utils/Errors.h> 35 #include <utils/CallStack.h> 36 #include <utils/threads.h> 37 38 39 /*****************************************************************************/ 40 namespace android { 41 42 43 typedef struct { 44 size_t count; 45 size_t ignore; 46 const void** addrs; 47 } stack_crawl_state_t; 48 49 static 50 _Unwind_Reason_Code trace_function(_Unwind_Context *context, void *arg) 51 { 52 stack_crawl_state_t* state = (stack_crawl_state_t*)arg; 53 if (state->count) { 54 void* ip = (void*)_Unwind_GetIP(context); 55 if (ip) { 56 if (state->ignore) { 57 state->ignore--; 58 } else { 59 state->addrs[0] = ip; 60 state->addrs++; 61 state->count--; 62 } 63 } 64 } 65 return _URC_NO_REASON; 66 } 67 68 static 69 int backtrace(const void** addrs, size_t ignore, size_t size) 70 { 71 stack_crawl_state_t state; 72 state.count = size; 73 state.ignore = ignore; 74 state.addrs = addrs; 75 _Unwind_Backtrace(trace_function, (void*)&state); 76 return size - state.count; 77 } 78 79 /*****************************************************************************/ 80 81 static 82 const char *lookup_symbol(const void* addr, void **offset, char* name, size_t bufSize) 83 { 84 #if HAVE_DLADDR 85 Dl_info info; 86 if (dladdr(addr, &info)) { 87 *offset = info.dli_saddr; 88 return info.dli_sname; 89 } 90 #endif 91 return NULL; 92 } 93 94 static 95 int32_t linux_gcc_demangler(const char *mangled_name, char *unmangled_name, size_t buffersize) 96 { 97 size_t out_len = 0; 98 #if HAVE_CXXABI 99 int status = 0; 100 char *demangled = abi::__cxa_demangle(mangled_name, 0, &out_len, &status); 101 if (status == 0) { 102 // OK 103 if (out_len < buffersize) memcpy(unmangled_name, demangled, out_len); 104 else out_len = 0; 105 free(demangled); 106 } else { 107 out_len = 0; 108 } 109 #endif 110 return out_len; 111 } 112 113 /*****************************************************************************/ 114 115 class MapInfo { 116 struct mapinfo { 117 struct mapinfo *next; 118 uint64_t start; 119 uint64_t end; 120 char name[]; 121 }; 122 123 const char *map_to_name(uint64_t pc, const char* def, uint64_t* start) { 124 mapinfo* mi = getMapInfoList(); 125 while(mi) { 126 if ((pc >= mi->start) && (pc < mi->end)) { 127 if (start) 128 *start = mi->start; 129 return mi->name; 130 } 131 mi = mi->next; 132 } 133 if (start) 134 *start = 0; 135 return def; 136 } 137 138 mapinfo *parse_maps_line(char *line) { 139 mapinfo *mi; 140 int len = strlen(line); 141 if (len < 1) return 0; 142 line[--len] = 0; 143 if (len < 50) return 0; 144 if (line[20] != 'x') return 0; 145 mi = (mapinfo*)malloc(sizeof(mapinfo) + (len - 47)); 146 if (mi == 0) return 0; 147 mi->start = strtoull(line, 0, 16); 148 mi->end = strtoull(line + 9, 0, 16); 149 mi->next = 0; 150 strcpy(mi->name, line + 49); 151 return mi; 152 } 153 154 mapinfo* getMapInfoList() { 155 Mutex::Autolock _l(mLock); 156 if (milist == 0) { 157 char data[1024]; 158 FILE *fp; 159 sprintf(data, "/proc/%d/maps", getpid()); 160 fp = fopen(data, "r"); 161 if (fp) { 162 while(fgets(data, 1024, fp)) { 163 mapinfo *mi = parse_maps_line(data); 164 if(mi) { 165 mi->next = milist; 166 milist = mi; 167 } 168 } 169 fclose(fp); 170 } 171 } 172 return milist; 173 } 174 mapinfo* milist; 175 Mutex mLock; 176 static MapInfo sMapInfo; 177 178 public: 179 MapInfo() 180 : milist(0) { 181 } 182 183 ~MapInfo() { 184 while (milist) { 185 mapinfo *next = milist->next; 186 free(milist); 187 milist = next; 188 } 189 } 190 191 static const char *mapAddressToName(const void* pc, const char* def, 192 void const** start) 193 { 194 uint64_t s; 195 char const* name = sMapInfo.map_to_name(uint64_t(uintptr_t(pc)), def, &s); 196 if (start) { 197 *start = (void*)s; 198 } 199 return name; 200 } 201 202 }; 203 204 /*****************************************************************************/ 205 206 MapInfo MapInfo::sMapInfo; 207 208 /*****************************************************************************/ 209 210 CallStack::CallStack() 211 : mCount(0) 212 { 213 } 214 215 CallStack::CallStack(const CallStack& rhs) 216 : mCount(rhs.mCount) 217 { 218 if (mCount) { 219 memcpy(mStack, rhs.mStack, mCount*sizeof(void*)); 220 } 221 } 222 223 CallStack::~CallStack() 224 { 225 } 226 227 CallStack& CallStack::operator = (const CallStack& rhs) 228 { 229 mCount = rhs.mCount; 230 if (mCount) { 231 memcpy(mStack, rhs.mStack, mCount*sizeof(void*)); 232 } 233 return *this; 234 } 235 236 bool CallStack::operator == (const CallStack& rhs) const { 237 if (mCount != rhs.mCount) 238 return false; 239 return !mCount || (memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) == 0); 240 } 241 242 bool CallStack::operator != (const CallStack& rhs) const { 243 return !operator == (rhs); 244 } 245 246 bool CallStack::operator < (const CallStack& rhs) const { 247 if (mCount != rhs.mCount) 248 return mCount < rhs.mCount; 249 return memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) < 0; 250 } 251 252 bool CallStack::operator >= (const CallStack& rhs) const { 253 return !operator < (rhs); 254 } 255 256 bool CallStack::operator > (const CallStack& rhs) const { 257 if (mCount != rhs.mCount) 258 return mCount > rhs.mCount; 259 return memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) > 0; 260 } 261 262 bool CallStack::operator <= (const CallStack& rhs) const { 263 return !operator > (rhs); 264 } 265 266 const void* CallStack::operator [] (int index) const { 267 if (index >= int(mCount)) 268 return 0; 269 return mStack[index]; 270 } 271 272 273 void CallStack::clear() 274 { 275 mCount = 0; 276 } 277 278 void CallStack::update(int32_t ignoreDepth, int32_t maxDepth) 279 { 280 if (maxDepth > MAX_DEPTH) 281 maxDepth = MAX_DEPTH; 282 mCount = backtrace(mStack, ignoreDepth, maxDepth); 283 } 284 285 // Return the stack frame name on the designated level 286 String8 CallStack::toStringSingleLevel(const char* prefix, int32_t level) const 287 { 288 String8 res; 289 char namebuf[1024]; 290 char tmp[256]; 291 char tmp1[32]; 292 char tmp2[32]; 293 void *offs; 294 295 const void* ip = mStack[level]; 296 if (!ip) return res; 297 298 if (prefix) res.append(prefix); 299 snprintf(tmp1, 32, "#%02d ", level); 300 res.append(tmp1); 301 302 const char* name = lookup_symbol(ip, &offs, namebuf, sizeof(namebuf)); 303 if (name) { 304 if (linux_gcc_demangler(name, tmp, 256) != 0) 305 name = tmp; 306 snprintf(tmp1, 32, "0x%p: <", ip); 307 snprintf(tmp2, 32, ">+0x%p", offs); 308 res.append(tmp1); 309 res.append(name); 310 res.append(tmp2); 311 } else { 312 void const* start = 0; 313 name = MapInfo::mapAddressToName(ip, "<unknown>", &start); 314 snprintf(tmp, 256, "pc %08lx %s", 315 long(uintptr_t(ip)-uintptr_t(start)), name); 316 res.append(tmp); 317 } 318 res.append("\n"); 319 320 return res; 321 } 322 323 // Dump a stack trace to the log 324 void CallStack::dump(const char* prefix) const 325 { 326 /* 327 * Sending a single long log may be truncated since the stack levels can 328 * get very deep. So we request function names of each frame individually. 329 */ 330 for (int i=0; i<int(mCount); i++) { 331 LOGD("%s", toStringSingleLevel(prefix, i).string()); 332 } 333 } 334 335 // Return a string (possibly very long) containing the complete stack trace 336 String8 CallStack::toString(const char* prefix) const 337 { 338 String8 res; 339 340 for (int i=0; i<int(mCount); i++) { 341 res.append(toStringSingleLevel(prefix, i).string()); 342 } 343 344 return res; 345 } 346 347 /*****************************************************************************/ 348 349 }; // namespace android 350
