1 /* 2 * Copyright (C) 2011 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 #include "runtime.h" 18 19 #include <signal.h> 20 #include <string.h> 21 #include <sys/utsname.h> 22 23 #include "base/logging.h" 24 #include "base/mutex.h" 25 #include "base/stringprintf.h" 26 #include "thread.h" 27 #include "utils.h" 28 29 namespace art { 30 31 struct Backtrace { 32 void Dump(std::ostream& os) { 33 DumpNativeStack(os, GetTid(), "\t", true); 34 } 35 }; 36 37 struct OsInfo { 38 void Dump(std::ostream& os) { 39 utsname info; 40 uname(&info); 41 // Linux 2.6.38.8-gg784 (x86_64) 42 // Darwin 11.4.0 (x86_64) 43 os << info.sysname << " " << info.release << " (" << info.machine << ")"; 44 } 45 }; 46 47 static const char* GetSignalName(int signal_number) { 48 switch (signal_number) { 49 case SIGABRT: return "SIGABRT"; 50 case SIGBUS: return "SIGBUS"; 51 case SIGFPE: return "SIGFPE"; 52 case SIGILL: return "SIGILL"; 53 case SIGPIPE: return "SIGPIPE"; 54 case SIGSEGV: return "SIGSEGV"; 55 #if defined(SIGSTKFLT) 56 case SIGSTKFLT: return "SIGSTKFLT"; 57 #endif 58 case SIGTRAP: return "SIGTRAP"; 59 } 60 return "??"; 61 } 62 63 static const char* GetSignalCodeName(int signal_number, int signal_code) { 64 // Try the signal-specific codes... 65 switch (signal_number) { 66 case SIGILL: 67 switch (signal_code) { 68 case ILL_ILLOPC: return "ILL_ILLOPC"; 69 case ILL_ILLOPN: return "ILL_ILLOPN"; 70 case ILL_ILLADR: return "ILL_ILLADR"; 71 case ILL_ILLTRP: return "ILL_ILLTRP"; 72 case ILL_PRVOPC: return "ILL_PRVOPC"; 73 case ILL_PRVREG: return "ILL_PRVREG"; 74 case ILL_COPROC: return "ILL_COPROC"; 75 case ILL_BADSTK: return "ILL_BADSTK"; 76 } 77 break; 78 case SIGBUS: 79 switch (signal_code) { 80 case BUS_ADRALN: return "BUS_ADRALN"; 81 case BUS_ADRERR: return "BUS_ADRERR"; 82 case BUS_OBJERR: return "BUS_OBJERR"; 83 } 84 break; 85 case SIGFPE: 86 switch (signal_code) { 87 case FPE_INTDIV: return "FPE_INTDIV"; 88 case FPE_INTOVF: return "FPE_INTOVF"; 89 case FPE_FLTDIV: return "FPE_FLTDIV"; 90 case FPE_FLTOVF: return "FPE_FLTOVF"; 91 case FPE_FLTUND: return "FPE_FLTUND"; 92 case FPE_FLTRES: return "FPE_FLTRES"; 93 case FPE_FLTINV: return "FPE_FLTINV"; 94 case FPE_FLTSUB: return "FPE_FLTSUB"; 95 } 96 break; 97 case SIGSEGV: 98 switch (signal_code) { 99 case SEGV_MAPERR: return "SEGV_MAPERR"; 100 case SEGV_ACCERR: return "SEGV_ACCERR"; 101 } 102 break; 103 case SIGTRAP: 104 switch (signal_code) { 105 case TRAP_BRKPT: return "TRAP_BRKPT"; 106 case TRAP_TRACE: return "TRAP_TRACE"; 107 } 108 break; 109 } 110 // Then the other codes... 111 switch (signal_code) { 112 case SI_USER: return "SI_USER"; 113 #if defined(SI_KERNEL) 114 case SI_KERNEL: return "SI_KERNEL"; 115 #endif 116 case SI_QUEUE: return "SI_QUEUE"; 117 case SI_TIMER: return "SI_TIMER"; 118 case SI_MESGQ: return "SI_MESGQ"; 119 case SI_ASYNCIO: return "SI_ASYNCIO"; 120 #if defined(SI_SIGIO) 121 case SI_SIGIO: return "SI_SIGIO"; 122 #endif 123 #if defined(SI_TKILL) 124 case SI_TKILL: return "SI_TKILL"; 125 #endif 126 } 127 // Then give up... 128 return "?"; 129 } 130 131 struct UContext { 132 explicit UContext(void* raw_context) : context(reinterpret_cast<ucontext_t*>(raw_context)->uc_mcontext) {} 133 134 void Dump(std::ostream& os) { 135 // TODO: support non-x86 hosts (not urgent because this code doesn't run on targets). 136 #if defined(__APPLE__) 137 DumpRegister32(os, "eax", context->__ss.__eax); 138 DumpRegister32(os, "ebx", context->__ss.__ebx); 139 DumpRegister32(os, "ecx", context->__ss.__ecx); 140 DumpRegister32(os, "edx", context->__ss.__edx); 141 os << '\n'; 142 143 DumpRegister32(os, "edi", context->__ss.__edi); 144 DumpRegister32(os, "esi", context->__ss.__esi); 145 DumpRegister32(os, "ebp", context->__ss.__ebp); 146 DumpRegister32(os, "esp", context->__ss.__esp); 147 os << '\n'; 148 149 DumpRegister32(os, "eip", context->__ss.__eip); 150 os << " "; 151 DumpRegister32(os, "eflags", context->__ss.__eflags); 152 DumpX86Flags(os, context->__ss.__eflags); 153 os << '\n'; 154 155 DumpRegister32(os, "cs", context->__ss.__cs); 156 DumpRegister32(os, "ds", context->__ss.__ds); 157 DumpRegister32(os, "es", context->__ss.__es); 158 DumpRegister32(os, "fs", context->__ss.__fs); 159 os << '\n'; 160 DumpRegister32(os, "gs", context->__ss.__gs); 161 DumpRegister32(os, "ss", context->__ss.__ss); 162 #else 163 DumpRegister32(os, "eax", context.gregs[REG_EAX]); 164 DumpRegister32(os, "ebx", context.gregs[REG_EBX]); 165 DumpRegister32(os, "ecx", context.gregs[REG_ECX]); 166 DumpRegister32(os, "edx", context.gregs[REG_EDX]); 167 os << '\n'; 168 169 DumpRegister32(os, "edi", context.gregs[REG_EDI]); 170 DumpRegister32(os, "esi", context.gregs[REG_ESI]); 171 DumpRegister32(os, "ebp", context.gregs[REG_EBP]); 172 DumpRegister32(os, "esp", context.gregs[REG_ESP]); 173 os << '\n'; 174 175 DumpRegister32(os, "eip", context.gregs[REG_EIP]); 176 os << " "; 177 DumpRegister32(os, "eflags", context.gregs[REG_EFL]); 178 DumpX86Flags(os, context.gregs[REG_EFL]); 179 os << '\n'; 180 181 DumpRegister32(os, "cs", context.gregs[REG_CS]); 182 DumpRegister32(os, "ds", context.gregs[REG_DS]); 183 DumpRegister32(os, "es", context.gregs[REG_ES]); 184 DumpRegister32(os, "fs", context.gregs[REG_FS]); 185 os << '\n'; 186 DumpRegister32(os, "gs", context.gregs[REG_GS]); 187 DumpRegister32(os, "ss", context.gregs[REG_SS]); 188 #endif 189 } 190 191 void DumpRegister32(std::ostream& os, const char* name, uint32_t value) { 192 os << StringPrintf(" %6s: 0x%08x", name, value); 193 } 194 195 void DumpX86Flags(std::ostream& os, uint32_t flags) { 196 os << " ["; 197 if ((flags & (1 << 0)) != 0) { 198 os << " CF"; 199 } 200 if ((flags & (1 << 2)) != 0) { 201 os << " PF"; 202 } 203 if ((flags & (1 << 4)) != 0) { 204 os << " AF"; 205 } 206 if ((flags & (1 << 6)) != 0) { 207 os << " ZF"; 208 } 209 if ((flags & (1 << 7)) != 0) { 210 os << " SF"; 211 } 212 if ((flags & (1 << 8)) != 0) { 213 os << " TF"; 214 } 215 if ((flags & (1 << 9)) != 0) { 216 os << " IF"; 217 } 218 if ((flags & (1 << 10)) != 0) { 219 os << " DF"; 220 } 221 if ((flags & (1 << 11)) != 0) { 222 os << " OF"; 223 } 224 os << " ]"; 225 } 226 227 mcontext_t& context; 228 }; 229 230 void HandleUnexpectedSignal(int signal_number, siginfo_t* info, void* raw_context) { 231 static bool handlingUnexpectedSignal = false; 232 if (handlingUnexpectedSignal) { 233 LogMessageData data(__FILE__, __LINE__, INTERNAL_FATAL, -1); 234 LogMessage::LogLine(data, "HandleUnexpectedSignal reentered\n"); 235 _exit(1); 236 } 237 handlingUnexpectedSignal = true; 238 239 gAborting++; // set before taking any locks 240 MutexLock mu(Thread::Current(), *Locks::unexpected_signal_lock_); 241 242 bool has_address = (signal_number == SIGILL || signal_number == SIGBUS || 243 signal_number == SIGFPE || signal_number == SIGSEGV); 244 245 OsInfo os_info; 246 const char* cmd_line = GetCmdLine(); 247 if (cmd_line == NULL) { 248 cmd_line = "<unset>"; // Because no-one called InitLogging. 249 } 250 pid_t tid = GetTid(); 251 std::string thread_name(GetThreadName(tid)); 252 UContext thread_context(raw_context); 253 Backtrace thread_backtrace; 254 255 LOG(INTERNAL_FATAL) << "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n" 256 << StringPrintf("Fatal signal %d (%s), code %d (%s)", 257 signal_number, GetSignalName(signal_number), 258 info->si_code, 259 GetSignalCodeName(signal_number, info->si_code)) 260 << (has_address ? StringPrintf(" fault addr %p", info->si_addr) : "") << "\n" 261 << "OS: " << Dumpable<OsInfo>(os_info) << "\n" 262 << "Cmdline: " << cmd_line << "\n" 263 << "Thread: " << tid << " \"" << thread_name << "\"\n" 264 << "Registers:\n" << Dumpable<UContext>(thread_context) << "\n" 265 << "Backtrace:\n" << Dumpable<Backtrace>(thread_backtrace); 266 267 if (getenv("debug_db_uid") != NULL || getenv("art_wait_for_gdb_on_crash") != NULL) { 268 LOG(INTERNAL_FATAL) << "********************************************************\n" 269 << "* Process " << getpid() << " thread " << tid << " \"" << thread_name << "\"" 270 << " has been suspended while crashing.\n" 271 << "* Attach gdb:\n" 272 << "* gdb -p " << tid << "\n" 273 << "********************************************************\n"; 274 // Wait for debugger to attach. 275 while (true) { 276 } 277 } 278 279 // Remove our signal handler for this signal... 280 struct sigaction action; 281 memset(&action, 0, sizeof(action)); 282 sigemptyset(&action.sa_mask); 283 action.sa_handler = SIG_DFL; 284 sigaction(signal_number, &action, NULL); 285 // ...and re-raise so we die with the appropriate status. 286 kill(getpid(), signal_number); 287 } 288 289 void Runtime::InitPlatformSignalHandlers() { 290 // On the host, we don't have debuggerd to dump a stack for us when something unexpected happens. 291 struct sigaction action; 292 memset(&action, 0, sizeof(action)); 293 sigemptyset(&action.sa_mask); 294 action.sa_sigaction = HandleUnexpectedSignal; 295 // Use the three-argument sa_sigaction handler. 296 action.sa_flags |= SA_SIGINFO; 297 // Use the alternate signal stack so we can catch stack overflows. 298 action.sa_flags |= SA_ONSTACK; 299 300 int rc = 0; 301 rc += sigaction(SIGABRT, &action, NULL); 302 rc += sigaction(SIGBUS, &action, NULL); 303 rc += sigaction(SIGFPE, &action, NULL); 304 rc += sigaction(SIGILL, &action, NULL); 305 rc += sigaction(SIGPIPE, &action, NULL); 306 rc += sigaction(SIGSEGV, &action, NULL); 307 #if defined(SIGSTKFLT) 308 rc += sigaction(SIGSTKFLT, &action, NULL); 309 #endif 310 rc += sigaction(SIGTRAP, &action, NULL); 311 CHECK_EQ(rc, 0); 312 } 313 314 } // namespace art 315
