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#include <inttypes.h>
23
24#include <sstream>
25
26#include "base/dumpable.h"
27#include "base/logging.h"
28#include "base/macros.h"
29#include "base/mutex.h"
30#include "base/stringprintf.h"
31#include "thread-inl.h"
32#include "thread_list.h"
33#include "utils.h"
34
35namespace art {
36
37static constexpr bool kDumpHeapObjectOnSigsevg = false;
38static constexpr bool kUseSigRTTimeout = true;
39static constexpr bool kDumpNativeStackOnTimeout = true;
40
41struct Backtrace {
42 public:
43  explicit Backtrace(void* raw_context) : raw_context_(raw_context) {}
44  void Dump(std::ostream& os) const {
45    DumpNativeStack(os, GetTid(), nullptr, "\t", nullptr, raw_context_);
46  }
47 private:
48  // Stores the context of the signal that was unexpected and will terminate the runtime. The
49  // DumpNativeStack code will take care of casting it to the expected type. This is required
50  // as our signal handler runs on an alternate stack.
51  void* raw_context_;
52};
53
54struct OsInfo {
55  void Dump(std::ostream& os) const {
56    utsname info;
57    uname(&info);
58    // Linux 2.6.38.8-gg784 (x86_64)
59    // Darwin 11.4.0 (x86_64)
60    os << info.sysname << " " << info.release << " (" << info.machine << ")";
61  }
62};
63
64static const char* GetSignalName(int signal_number) {
65  switch (signal_number) {
66    case SIGABRT: return "SIGABRT";
67    case SIGBUS: return "SIGBUS";
68    case SIGFPE: return "SIGFPE";
69    case SIGILL: return "SIGILL";
70    case SIGPIPE: return "SIGPIPE";
71    case SIGSEGV: return "SIGSEGV";
72#if defined(SIGSTKFLT)
73    case SIGSTKFLT: return "SIGSTKFLT";
74#endif
75    case SIGTRAP: return "SIGTRAP";
76  }
77  return "??";
78}
79
80static const char* GetSignalCodeName(int signal_number, int signal_code) {
81  // Try the signal-specific codes...
82  switch (signal_number) {
83    case SIGILL:
84      switch (signal_code) {
85        case ILL_ILLOPC: return "ILL_ILLOPC";
86        case ILL_ILLOPN: return "ILL_ILLOPN";
87        case ILL_ILLADR: return "ILL_ILLADR";
88        case ILL_ILLTRP: return "ILL_ILLTRP";
89        case ILL_PRVOPC: return "ILL_PRVOPC";
90        case ILL_PRVREG: return "ILL_PRVREG";
91        case ILL_COPROC: return "ILL_COPROC";
92        case ILL_BADSTK: return "ILL_BADSTK";
93      }
94      break;
95    case SIGBUS:
96      switch (signal_code) {
97        case BUS_ADRALN: return "BUS_ADRALN";
98        case BUS_ADRERR: return "BUS_ADRERR";
99        case BUS_OBJERR: return "BUS_OBJERR";
100      }
101      break;
102    case SIGFPE:
103      switch (signal_code) {
104        case FPE_INTDIV: return "FPE_INTDIV";
105        case FPE_INTOVF: return "FPE_INTOVF";
106        case FPE_FLTDIV: return "FPE_FLTDIV";
107        case FPE_FLTOVF: return "FPE_FLTOVF";
108        case FPE_FLTUND: return "FPE_FLTUND";
109        case FPE_FLTRES: return "FPE_FLTRES";
110        case FPE_FLTINV: return "FPE_FLTINV";
111        case FPE_FLTSUB: return "FPE_FLTSUB";
112      }
113      break;
114    case SIGSEGV:
115      switch (signal_code) {
116        case SEGV_MAPERR: return "SEGV_MAPERR";
117        case SEGV_ACCERR: return "SEGV_ACCERR";
118#if defined(SEGV_BNDERR)
119        case SEGV_BNDERR: return "SEGV_BNDERR";
120#endif
121      }
122      break;
123    case SIGTRAP:
124      switch (signal_code) {
125        case TRAP_BRKPT: return "TRAP_BRKPT";
126        case TRAP_TRACE: return "TRAP_TRACE";
127      }
128      break;
129  }
130  // Then the other codes...
131  switch (signal_code) {
132    case SI_USER:     return "SI_USER";
133#if defined(SI_KERNEL)
134    case SI_KERNEL:   return "SI_KERNEL";
135#endif
136    case SI_QUEUE:    return "SI_QUEUE";
137    case SI_TIMER:    return "SI_TIMER";
138    case SI_MESGQ:    return "SI_MESGQ";
139    case SI_ASYNCIO:  return "SI_ASYNCIO";
140#if defined(SI_SIGIO)
141    case SI_SIGIO:    return "SI_SIGIO";
142#endif
143#if defined(SI_TKILL)
144    case SI_TKILL:    return "SI_TKILL";
145#endif
146  }
147  // Then give up...
148  return "?";
149}
150
151struct UContext {
152  explicit UContext(void* raw_context) :
153      context(reinterpret_cast<ucontext_t*>(raw_context)->uc_mcontext) {
154  }
155
156  void Dump(std::ostream& os) const {
157    // TODO: support non-x86 hosts (not urgent because this code doesn't run on targets).
158#if defined(__APPLE__) && defined(__i386__)
159    DumpRegister32(os, "eax", context->__ss.__eax);
160    DumpRegister32(os, "ebx", context->__ss.__ebx);
161    DumpRegister32(os, "ecx", context->__ss.__ecx);
162    DumpRegister32(os, "edx", context->__ss.__edx);
163    os << '\n';
164
165    DumpRegister32(os, "edi", context->__ss.__edi);
166    DumpRegister32(os, "esi", context->__ss.__esi);
167    DumpRegister32(os, "ebp", context->__ss.__ebp);
168    DumpRegister32(os, "esp", context->__ss.__esp);
169    os << '\n';
170
171    DumpRegister32(os, "eip", context->__ss.__eip);
172    os << "                   ";
173    DumpRegister32(os, "eflags", context->__ss.__eflags);
174    DumpX86Flags(os, context->__ss.__eflags);
175    os << '\n';
176
177    DumpRegister32(os, "cs",  context->__ss.__cs);
178    DumpRegister32(os, "ds",  context->__ss.__ds);
179    DumpRegister32(os, "es",  context->__ss.__es);
180    DumpRegister32(os, "fs",  context->__ss.__fs);
181    os << '\n';
182    DumpRegister32(os, "gs",  context->__ss.__gs);
183    DumpRegister32(os, "ss",  context->__ss.__ss);
184#elif defined(__linux__) && defined(__i386__)
185    DumpRegister32(os, "eax", context.gregs[REG_EAX]);
186    DumpRegister32(os, "ebx", context.gregs[REG_EBX]);
187    DumpRegister32(os, "ecx", context.gregs[REG_ECX]);
188    DumpRegister32(os, "edx", context.gregs[REG_EDX]);
189    os << '\n';
190
191    DumpRegister32(os, "edi", context.gregs[REG_EDI]);
192    DumpRegister32(os, "esi", context.gregs[REG_ESI]);
193    DumpRegister32(os, "ebp", context.gregs[REG_EBP]);
194    DumpRegister32(os, "esp", context.gregs[REG_ESP]);
195    os << '\n';
196
197    DumpRegister32(os, "eip", context.gregs[REG_EIP]);
198    os << "                   ";
199    DumpRegister32(os, "eflags", context.gregs[REG_EFL]);
200    DumpX86Flags(os, context.gregs[REG_EFL]);
201    os << '\n';
202
203    DumpRegister32(os, "cs",  context.gregs[REG_CS]);
204    DumpRegister32(os, "ds",  context.gregs[REG_DS]);
205    DumpRegister32(os, "es",  context.gregs[REG_ES]);
206    DumpRegister32(os, "fs",  context.gregs[REG_FS]);
207    os << '\n';
208    DumpRegister32(os, "gs",  context.gregs[REG_GS]);
209    DumpRegister32(os, "ss",  context.gregs[REG_SS]);
210#elif defined(__linux__) && defined(__x86_64__)
211    DumpRegister64(os, "rax", context.gregs[REG_RAX]);
212    DumpRegister64(os, "rbx", context.gregs[REG_RBX]);
213    DumpRegister64(os, "rcx", context.gregs[REG_RCX]);
214    DumpRegister64(os, "rdx", context.gregs[REG_RDX]);
215    os << '\n';
216
217    DumpRegister64(os, "rdi", context.gregs[REG_RDI]);
218    DumpRegister64(os, "rsi", context.gregs[REG_RSI]);
219    DumpRegister64(os, "rbp", context.gregs[REG_RBP]);
220    DumpRegister64(os, "rsp", context.gregs[REG_RSP]);
221    os << '\n';
222
223    DumpRegister64(os, "r8 ", context.gregs[REG_R8]);
224    DumpRegister64(os, "r9 ", context.gregs[REG_R9]);
225    DumpRegister64(os, "r10", context.gregs[REG_R10]);
226    DumpRegister64(os, "r11", context.gregs[REG_R11]);
227    os << '\n';
228
229    DumpRegister64(os, "r12", context.gregs[REG_R12]);
230    DumpRegister64(os, "r13", context.gregs[REG_R13]);
231    DumpRegister64(os, "r14", context.gregs[REG_R14]);
232    DumpRegister64(os, "r15", context.gregs[REG_R15]);
233    os << '\n';
234
235    DumpRegister64(os, "rip", context.gregs[REG_RIP]);
236    os << "   ";
237    DumpRegister32(os, "eflags", context.gregs[REG_EFL]);
238    DumpX86Flags(os, context.gregs[REG_EFL]);
239    os << '\n';
240
241    DumpRegister32(os, "cs",  (context.gregs[REG_CSGSFS]) & 0x0FFFF);
242    DumpRegister32(os, "gs",  (context.gregs[REG_CSGSFS] >> 16) & 0x0FFFF);
243    DumpRegister32(os, "fs",  (context.gregs[REG_CSGSFS] >> 32) & 0x0FFFF);
244    os << '\n';
245#else
246    os << "Unknown architecture/word size/OS in ucontext dump";
247#endif
248  }
249
250  void DumpRegister32(std::ostream& os, const char* name, uint32_t value) const {
251    os << StringPrintf(" %6s: 0x%08x", name, value);
252  }
253
254  void DumpRegister64(std::ostream& os, const char* name, uint64_t value) const {
255    os << StringPrintf(" %6s: 0x%016" PRIx64, name, value);
256  }
257
258  void DumpX86Flags(std::ostream& os, uint32_t flags) const {
259    os << " [";
260    if ((flags & (1 << 0)) != 0) {
261      os << " CF";
262    }
263    if ((flags & (1 << 2)) != 0) {
264      os << " PF";
265    }
266    if ((flags & (1 << 4)) != 0) {
267      os << " AF";
268    }
269    if ((flags & (1 << 6)) != 0) {
270      os << " ZF";
271    }
272    if ((flags & (1 << 7)) != 0) {
273      os << " SF";
274    }
275    if ((flags & (1 << 8)) != 0) {
276      os << " TF";
277    }
278    if ((flags & (1 << 9)) != 0) {
279      os << " IF";
280    }
281    if ((flags & (1 << 10)) != 0) {
282      os << " DF";
283    }
284    if ((flags & (1 << 11)) != 0) {
285      os << " OF";
286    }
287    os << " ]";
288  }
289
290  mcontext_t& context;
291};
292
293// Return the signal number we recognize as timeout. -1 means not active/supported.
294static int GetTimeoutSignal() {
295#if defined(__APPLE__)
296  // Mac does not support realtime signals.
297  UNUSED(kUseSigRTTimeout);
298  return -1;
299#else
300  return kUseSigRTTimeout ? (SIGRTMIN + 2) : -1;
301#endif
302}
303
304static bool IsTimeoutSignal(int signal_number) {
305  return signal_number == GetTimeoutSignal();
306}
307
308void HandleUnexpectedSignal(int signal_number, siginfo_t* info, void* raw_context) {
309  static bool handlingUnexpectedSignal = false;
310  if (handlingUnexpectedSignal) {
311    LogMessage::LogLine(__FILE__, __LINE__, INTERNAL_FATAL, "HandleUnexpectedSignal reentered\n");
312    if (IsTimeoutSignal(signal_number)) {
313      // Ignore a recursive timeout.
314      return;
315    }
316    _exit(1);
317  }
318  handlingUnexpectedSignal = true;
319
320  gAborting++;  // set before taking any locks
321  MutexLock mu(Thread::Current(), *Locks::unexpected_signal_lock_);
322
323  bool has_address = (signal_number == SIGILL || signal_number == SIGBUS ||
324                      signal_number == SIGFPE || signal_number == SIGSEGV);
325
326  OsInfo os_info;
327  const char* cmd_line = GetCmdLine();
328  if (cmd_line == nullptr) {
329    cmd_line = "<unset>";  // Because no-one called InitLogging.
330  }
331  pid_t tid = GetTid();
332  std::string thread_name(GetThreadName(tid));
333  UContext thread_context(raw_context);
334  Backtrace thread_backtrace(raw_context);
335
336  LOG(INTERNAL_FATAL) << "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n"
337                      << StringPrintf("Fatal signal %d (%s), code %d (%s)",
338                                      signal_number, GetSignalName(signal_number),
339                                      info->si_code,
340                                      GetSignalCodeName(signal_number, info->si_code))
341                      << (has_address ? StringPrintf(" fault addr %p", info->si_addr) : "") << "\n"
342                      << "OS: " << Dumpable<OsInfo>(os_info) << "\n"
343                      << "Cmdline: " << cmd_line << "\n"
344                      << "Thread: " << tid << " \"" << thread_name << "\"\n"
345                      << "Registers:\n" << Dumpable<UContext>(thread_context) << "\n"
346                      << "Backtrace:\n" << Dumpable<Backtrace>(thread_backtrace);
347  if (kIsDebugBuild && signal_number == SIGSEGV) {
348    PrintFileToLog("/proc/self/maps", LogSeverity::INTERNAL_FATAL);
349  }
350  Runtime* runtime = Runtime::Current();
351  if (runtime != nullptr) {
352    if (IsTimeoutSignal(signal_number)) {
353      // Special timeout signal. Try to dump all threads.
354      // Note: Do not use DumpForSigQuit, as that might disable native unwind, but the native parts
355      //       are of value here.
356      runtime->GetThreadList()->Dump(LOG(INTERNAL_FATAL), kDumpNativeStackOnTimeout);
357    }
358    gc::Heap* heap = runtime->GetHeap();
359    LOG(INTERNAL_FATAL) << "Fault message: " << runtime->GetFaultMessage();
360    if (kDumpHeapObjectOnSigsevg && heap != nullptr && info != nullptr) {
361      LOG(INTERNAL_FATAL) << "Dump heap object at fault address: ";
362      heap->DumpObject(LOG(INTERNAL_FATAL), reinterpret_cast<mirror::Object*>(info->si_addr));
363    }
364  }
365  if (getenv("debug_db_uid") != nullptr || getenv("art_wait_for_gdb_on_crash") != nullptr) {
366    LOG(INTERNAL_FATAL) << "********************************************************\n"
367                        << "* Process " << getpid() << " thread " << tid << " \"" << thread_name
368                        << "\""
369                        << " has been suspended while crashing.\n"
370                        << "* Attach gdb:\n"
371                        << "*     gdb -p " << tid << "\n"
372                        << "********************************************************\n";
373    // Wait for debugger to attach.
374    while (true) {
375    }
376  }
377#ifdef __linux__
378  // Remove our signal handler for this signal...
379  struct sigaction action;
380  memset(&action, 0, sizeof(action));
381  sigemptyset(&action.sa_mask);
382  action.sa_handler = SIG_DFL;
383  sigaction(signal_number, &action, nullptr);
384  // ...and re-raise so we die with the appropriate status.
385  kill(getpid(), signal_number);
386#else
387  exit(EXIT_FAILURE);
388#endif
389}
390
391void Runtime::InitPlatformSignalHandlers() {
392  // On the host, we don't have debuggerd to dump a stack for us when something unexpected happens.
393  struct sigaction action;
394  memset(&action, 0, sizeof(action));
395  sigemptyset(&action.sa_mask);
396  action.sa_sigaction = HandleUnexpectedSignal;
397  // Use the three-argument sa_sigaction handler.
398  action.sa_flags |= SA_SIGINFO;
399  // Use the alternate signal stack so we can catch stack overflows.
400  action.sa_flags |= SA_ONSTACK;
401
402  int rc = 0;
403  rc += sigaction(SIGABRT, &action, nullptr);
404  rc += sigaction(SIGBUS, &action, nullptr);
405  rc += sigaction(SIGFPE, &action, nullptr);
406  rc += sigaction(SIGILL, &action, nullptr);
407  rc += sigaction(SIGPIPE, &action, nullptr);
408  rc += sigaction(SIGSEGV, &action, nullptr);
409#if defined(SIGSTKFLT)
410  rc += sigaction(SIGSTKFLT, &action, nullptr);
411#endif
412  rc += sigaction(SIGTRAP, &action, nullptr);
413  // Special dump-all timeout.
414  if (GetTimeoutSignal() != -1) {
415    rc += sigaction(GetTimeoutSignal(), &action, nullptr);
416  }
417  CHECK_EQ(rc, 0);
418}
419
420}  // namespace art
421