1//===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines some helpful functions for dealing with the possibility of 11// Unix signals occurring while your program is running. 12// 13//===----------------------------------------------------------------------===// 14 15#include "Unix.h" 16#include "llvm/ADT/STLExtras.h" 17#include "llvm/Support/FileSystem.h" 18#include "llvm/Support/FileUtilities.h" 19#include "llvm/Support/ManagedStatic.h" 20#include "llvm/Support/MemoryBuffer.h" 21#include "llvm/Support/Mutex.h" 22#include "llvm/Support/Program.h" 23#include "llvm/Support/UniqueLock.h" 24#include "llvm/Support/raw_ostream.h" 25#include <algorithm> 26#include <string> 27#include <vector> 28#if HAVE_EXECINFO_H 29# include <execinfo.h> // For backtrace(). 30#endif 31#if HAVE_SIGNAL_H 32#include <signal.h> 33#endif 34#if HAVE_SYS_STAT_H 35#include <sys/stat.h> 36#endif 37#if HAVE_CXXABI_H 38#include <cxxabi.h> 39#endif 40#if HAVE_DLFCN_H 41#include <dlfcn.h> 42#endif 43#if HAVE_MACH_MACH_H 44#include <mach/mach.h> 45#endif 46#if HAVE_LINK_H 47#include <link.h> 48#endif 49 50using namespace llvm; 51 52static RETSIGTYPE SignalHandler(int Sig); // defined below. 53 54static ManagedStatic<SmartMutex<true> > SignalsMutex; 55 56/// InterruptFunction - The function to call if ctrl-c is pressed. 57static void (*InterruptFunction)() = nullptr; 58 59static ManagedStatic<std::vector<std::string>> FilesToRemove; 60static ManagedStatic<std::vector<std::pair<void (*)(void *), void *>>> 61 CallBacksToRun; 62 63// IntSigs - Signals that represent requested termination. There's no bug 64// or failure, or if there is, it's not our direct responsibility. For whatever 65// reason, our continued execution is no longer desirable. 66static const int IntSigs[] = { 67 SIGHUP, SIGINT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2 68}; 69 70// KillSigs - Signals that represent that we have a bug, and our prompt 71// termination has been ordered. 72static const int KillSigs[] = { 73 SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGQUIT 74#ifdef SIGSYS 75 , SIGSYS 76#endif 77#ifdef SIGXCPU 78 , SIGXCPU 79#endif 80#ifdef SIGXFSZ 81 , SIGXFSZ 82#endif 83#ifdef SIGEMT 84 , SIGEMT 85#endif 86}; 87 88static unsigned NumRegisteredSignals = 0; 89static struct { 90 struct sigaction SA; 91 int SigNo; 92} RegisteredSignalInfo[(sizeof(IntSigs)+sizeof(KillSigs))/sizeof(KillSigs[0])]; 93 94 95static void RegisterHandler(int Signal) { 96 assert(NumRegisteredSignals < 97 sizeof(RegisteredSignalInfo)/sizeof(RegisteredSignalInfo[0]) && 98 "Out of space for signal handlers!"); 99 100 struct sigaction NewHandler; 101 102 NewHandler.sa_handler = SignalHandler; 103 NewHandler.sa_flags = SA_NODEFER|SA_RESETHAND; 104 sigemptyset(&NewHandler.sa_mask); 105 106 // Install the new handler, save the old one in RegisteredSignalInfo. 107 sigaction(Signal, &NewHandler, 108 &RegisteredSignalInfo[NumRegisteredSignals].SA); 109 RegisteredSignalInfo[NumRegisteredSignals].SigNo = Signal; 110 ++NumRegisteredSignals; 111} 112 113static void RegisterHandlers() { 114 // If the handlers are already registered, we're done. 115 if (NumRegisteredSignals != 0) return; 116 117 for (auto S : IntSigs) RegisterHandler(S); 118 for (auto S : KillSigs) RegisterHandler(S); 119} 120 121static void UnregisterHandlers() { 122 // Restore all of the signal handlers to how they were before we showed up. 123 for (unsigned i = 0, e = NumRegisteredSignals; i != e; ++i) 124 sigaction(RegisteredSignalInfo[i].SigNo, 125 &RegisteredSignalInfo[i].SA, nullptr); 126 NumRegisteredSignals = 0; 127} 128 129 130/// RemoveFilesToRemove - Process the FilesToRemove list. This function 131/// should be called with the SignalsMutex lock held. 132/// NB: This must be an async signal safe function. It cannot allocate or free 133/// memory, even in debug builds. 134static void RemoveFilesToRemove() { 135 // We avoid iterators in case of debug iterators that allocate or release 136 // memory. 137 std::vector<std::string>& FilesToRemoveRef = *FilesToRemove; 138 for (unsigned i = 0, e = FilesToRemoveRef.size(); i != e; ++i) { 139 // We rely on a std::string implementation for which repeated calls to 140 // 'c_str()' don't allocate memory. We pre-call 'c_str()' on all of these 141 // strings to try to ensure this is safe. 142 const char *path = FilesToRemoveRef[i].c_str(); 143 144 // Get the status so we can determine if it's a file or directory. If we 145 // can't stat the file, ignore it. 146 struct stat buf; 147 if (stat(path, &buf) != 0) 148 continue; 149 150 // If this is not a regular file, ignore it. We want to prevent removal of 151 // special files like /dev/null, even if the compiler is being run with the 152 // super-user permissions. 153 if (!S_ISREG(buf.st_mode)) 154 continue; 155 156 // Otherwise, remove the file. We ignore any errors here as there is nothing 157 // else we can do. 158 unlink(path); 159 } 160} 161 162// SignalHandler - The signal handler that runs. 163static RETSIGTYPE SignalHandler(int Sig) { 164 // Restore the signal behavior to default, so that the program actually 165 // crashes when we return and the signal reissues. This also ensures that if 166 // we crash in our signal handler that the program will terminate immediately 167 // instead of recursing in the signal handler. 168 UnregisterHandlers(); 169 170 // Unmask all potentially blocked kill signals. 171 sigset_t SigMask; 172 sigfillset(&SigMask); 173 sigprocmask(SIG_UNBLOCK, &SigMask, nullptr); 174 175 { 176 unique_lock<SmartMutex<true>> Guard(*SignalsMutex); 177 RemoveFilesToRemove(); 178 179 if (std::find(std::begin(IntSigs), std::end(IntSigs), Sig) 180 != std::end(IntSigs)) { 181 if (InterruptFunction) { 182 void (*IF)() = InterruptFunction; 183 Guard.unlock(); 184 InterruptFunction = nullptr; 185 IF(); // run the interrupt function. 186 return; 187 } 188 189 Guard.unlock(); 190 raise(Sig); // Execute the default handler. 191 return; 192 } 193 } 194 195 // Otherwise if it is a fault (like SEGV) run any handler. 196 std::vector<std::pair<void (*)(void *), void *>>& CallBacksToRunRef = 197 *CallBacksToRun; 198 for (unsigned i = 0, e = CallBacksToRun->size(); i != e; ++i) 199 CallBacksToRunRef[i].first(CallBacksToRunRef[i].second); 200 201#ifdef __s390__ 202 // On S/390, certain signals are delivered with PSW Address pointing to 203 // *after* the faulting instruction. Simply returning from the signal 204 // handler would continue execution after that point, instead of 205 // re-raising the signal. Raise the signal manually in those cases. 206 if (Sig == SIGILL || Sig == SIGFPE || Sig == SIGTRAP) 207 raise(Sig); 208#endif 209} 210 211void llvm::sys::RunInterruptHandlers() { 212 sys::SmartScopedLock<true> Guard(*SignalsMutex); 213 RemoveFilesToRemove(); 214} 215 216void llvm::sys::SetInterruptFunction(void (*IF)()) { 217 { 218 sys::SmartScopedLock<true> Guard(*SignalsMutex); 219 InterruptFunction = IF; 220 } 221 RegisterHandlers(); 222} 223 224// RemoveFileOnSignal - The public API 225bool llvm::sys::RemoveFileOnSignal(StringRef Filename, 226 std::string* ErrMsg) { 227 { 228 sys::SmartScopedLock<true> Guard(*SignalsMutex); 229 std::vector<std::string>& FilesToRemoveRef = *FilesToRemove; 230 std::string *OldPtr = 231 FilesToRemoveRef.empty() ? nullptr : &FilesToRemoveRef[0]; 232 FilesToRemoveRef.push_back(Filename); 233 234 // We want to call 'c_str()' on every std::string in this vector so that if 235 // the underlying implementation requires a re-allocation, it happens here 236 // rather than inside of the signal handler. If we see the vector grow, we 237 // have to call it on every entry. If it remains in place, we only need to 238 // call it on the latest one. 239 if (OldPtr == &FilesToRemoveRef[0]) 240 FilesToRemoveRef.back().c_str(); 241 else 242 for (unsigned i = 0, e = FilesToRemoveRef.size(); i != e; ++i) 243 FilesToRemoveRef[i].c_str(); 244 } 245 246 RegisterHandlers(); 247 return false; 248} 249 250// DontRemoveFileOnSignal - The public API 251void llvm::sys::DontRemoveFileOnSignal(StringRef Filename) { 252 sys::SmartScopedLock<true> Guard(*SignalsMutex); 253 std::vector<std::string>::reverse_iterator RI = 254 std::find(FilesToRemove->rbegin(), FilesToRemove->rend(), Filename); 255 std::vector<std::string>::iterator I = FilesToRemove->end(); 256 if (RI != FilesToRemove->rend()) 257 I = FilesToRemove->erase(RI.base()-1); 258 259 // We need to call c_str() on every element which would have been moved by 260 // the erase. These elements, in a C++98 implementation where c_str() 261 // requires a reallocation on the first call may have had the call to c_str() 262 // made on insertion become invalid by being copied down an element. 263 for (std::vector<std::string>::iterator E = FilesToRemove->end(); I != E; ++I) 264 I->c_str(); 265} 266 267/// AddSignalHandler - Add a function to be called when a signal is delivered 268/// to the process. The handler can have a cookie passed to it to identify 269/// what instance of the handler it is. 270void llvm::sys::AddSignalHandler(void (*FnPtr)(void *), void *Cookie) { 271 CallBacksToRun->push_back(std::make_pair(FnPtr, Cookie)); 272 RegisterHandlers(); 273} 274 275#if defined(HAVE_BACKTRACE) && defined(ENABLE_BACKTRACES) 276 277#if HAVE_LINK_H && (defined(__linux__) || defined(__FreeBSD__) || \ 278 defined(__FreeBSD_kernel__) || defined(__NetBSD__)) 279struct DlIteratePhdrData { 280 void **StackTrace; 281 int depth; 282 bool first; 283 const char **modules; 284 intptr_t *offsets; 285 const char *main_exec_name; 286}; 287 288static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) { 289 DlIteratePhdrData *data = (DlIteratePhdrData*)arg; 290 const char *name = data->first ? data->main_exec_name : info->dlpi_name; 291 data->first = false; 292 for (int i = 0; i < info->dlpi_phnum; i++) { 293 const auto *phdr = &info->dlpi_phdr[i]; 294 if (phdr->p_type != PT_LOAD) 295 continue; 296 intptr_t beg = info->dlpi_addr + phdr->p_vaddr; 297 intptr_t end = beg + phdr->p_memsz; 298 for (int j = 0; j < data->depth; j++) { 299 if (data->modules[j]) 300 continue; 301 intptr_t addr = (intptr_t)data->StackTrace[j]; 302 if (beg <= addr && addr < end) { 303 data->modules[j] = name; 304 data->offsets[j] = addr - info->dlpi_addr; 305 } 306 } 307 } 308 return 0; 309} 310 311static bool findModulesAndOffsets(void **StackTrace, int Depth, 312 const char **Modules, intptr_t *Offsets, 313 const char *MainExecutableName) { 314 DlIteratePhdrData data = {StackTrace, Depth, true, 315 Modules, Offsets, MainExecutableName}; 316 dl_iterate_phdr(dl_iterate_phdr_cb, &data); 317 return true; 318} 319#else 320static bool findModulesAndOffsets(void **StackTrace, int Depth, 321 const char **Modules, intptr_t *Offsets, 322 const char *MainExecutableName) { 323 return false; 324} 325#endif 326 327static bool printSymbolizedStackTrace(void **StackTrace, int Depth, FILE *FD) { 328 // FIXME: Subtract necessary number from StackTrace entries to turn return addresses 329 // into actual instruction addresses. 330 // Use llvm-symbolizer tool to symbolize the stack traces. 331 ErrorOr<std::string> LLVMSymbolizerPathOrErr = 332 sys::findProgramByName("llvm-symbolizer"); 333 if (!LLVMSymbolizerPathOrErr) 334 return false; 335 const std::string &LLVMSymbolizerPath = *LLVMSymbolizerPathOrErr; 336 // We don't know argv0 or the address of main() at this point, but try 337 // to guess it anyway (it's possible on some platforms). 338 std::string MainExecutableName = sys::fs::getMainExecutable(nullptr, nullptr); 339 if (MainExecutableName.empty() || 340 MainExecutableName.find("llvm-symbolizer") != std::string::npos) 341 return false; 342 343 std::vector<const char *> Modules(Depth, nullptr); 344 std::vector<intptr_t> Offsets(Depth, 0); 345 if (!findModulesAndOffsets(StackTrace, Depth, Modules.data(), Offsets.data(), 346 MainExecutableName.c_str())) 347 return false; 348 int InputFD; 349 SmallString<32> InputFile, OutputFile; 350 sys::fs::createTemporaryFile("symbolizer-input", "", InputFD, InputFile); 351 sys::fs::createTemporaryFile("symbolizer-output", "", OutputFile); 352 FileRemover InputRemover(InputFile.c_str()); 353 FileRemover OutputRemover(OutputFile.c_str()); 354 355 { 356 raw_fd_ostream Input(InputFD, true); 357 for (int i = 0; i < Depth; i++) { 358 if (Modules[i]) 359 Input << Modules[i] << " " << (void*)Offsets[i] << "\n"; 360 } 361 } 362 363 StringRef InputFileStr(InputFile); 364 StringRef OutputFileStr(OutputFile); 365 StringRef StderrFileStr; 366 const StringRef *Redirects[] = {&InputFileStr, &OutputFileStr, 367 &StderrFileStr}; 368 const char *Args[] = {"llvm-symbolizer", "--functions=linkage", "--inlining", 369 "--demangle", nullptr}; 370 int RunResult = 371 sys::ExecuteAndWait(LLVMSymbolizerPath, Args, nullptr, Redirects); 372 if (RunResult != 0) 373 return false; 374 375 auto OutputBuf = MemoryBuffer::getFile(OutputFile.c_str()); 376 if (!OutputBuf) 377 return false; 378 StringRef Output = OutputBuf.get()->getBuffer(); 379 SmallVector<StringRef, 32> Lines; 380 Output.split(Lines, "\n"); 381 auto CurLine = Lines.begin(); 382 int frame_no = 0; 383 for (int i = 0; i < Depth; i++) { 384 if (!Modules[i]) { 385 fprintf(FD, "#%d %p\n", frame_no++, StackTrace[i]); 386 continue; 387 } 388 // Read pairs of lines (function name and file/line info) until we 389 // encounter empty line. 390 for (;;) { 391 if (CurLine == Lines.end()) 392 return false; 393 StringRef FunctionName = *CurLine++; 394 if (FunctionName.empty()) 395 break; 396 fprintf(FD, "#%d %p ", frame_no++, StackTrace[i]); 397 if (!FunctionName.startswith("??")) 398 fprintf(FD, "%s ", FunctionName.str().c_str()); 399 if (CurLine == Lines.end()) 400 return false; 401 StringRef FileLineInfo = *CurLine++; 402 if (!FileLineInfo.startswith("??")) 403 fprintf(FD, "%s", FileLineInfo.str().c_str()); 404 else 405 fprintf(FD, "(%s+%p)", Modules[i], (void *)Offsets[i]); 406 fprintf(FD, "\n"); 407 } 408 } 409 return true; 410} 411#endif // defined(HAVE_BACKTRACE) && defined(ENABLE_BACKTRACES) 412 413// PrintStackTrace - In the case of a program crash or fault, print out a stack 414// trace so that the user has an indication of why and where we died. 415// 416// On glibc systems we have the 'backtrace' function, which works nicely, but 417// doesn't demangle symbols. 418void llvm::sys::PrintStackTrace(FILE *FD) { 419#if defined(HAVE_BACKTRACE) && defined(ENABLE_BACKTRACES) 420 static void* StackTrace[256]; 421 // Use backtrace() to output a backtrace on Linux systems with glibc. 422 int depth = backtrace(StackTrace, 423 static_cast<int>(array_lengthof(StackTrace))); 424 if (printSymbolizedStackTrace(StackTrace, depth, FD)) 425 return; 426#if HAVE_DLFCN_H && __GNUG__ 427 int width = 0; 428 for (int i = 0; i < depth; ++i) { 429 Dl_info dlinfo; 430 dladdr(StackTrace[i], &dlinfo); 431 const char* name = strrchr(dlinfo.dli_fname, '/'); 432 433 int nwidth; 434 if (!name) nwidth = strlen(dlinfo.dli_fname); 435 else nwidth = strlen(name) - 1; 436 437 if (nwidth > width) width = nwidth; 438 } 439 440 for (int i = 0; i < depth; ++i) { 441 Dl_info dlinfo; 442 dladdr(StackTrace[i], &dlinfo); 443 444 fprintf(FD, "%-2d", i); 445 446 const char* name = strrchr(dlinfo.dli_fname, '/'); 447 if (!name) fprintf(FD, " %-*s", width, dlinfo.dli_fname); 448 else fprintf(FD, " %-*s", width, name+1); 449 450 fprintf(FD, " %#0*lx", 451 (int)(sizeof(void*) * 2) + 2, (unsigned long)StackTrace[i]); 452 453 if (dlinfo.dli_sname != nullptr) { 454 fputc(' ', FD); 455# if HAVE_CXXABI_H 456 int res; 457 char* d = abi::__cxa_demangle(dlinfo.dli_sname, nullptr, nullptr, &res); 458# else 459 char* d = NULL; 460# endif 461 if (!d) fputs(dlinfo.dli_sname, FD); 462 else fputs(d, FD); 463 free(d); 464 465 // FIXME: When we move to C++11, use %t length modifier. It's not in 466 // C++03 and causes gcc to issue warnings. Losing the upper 32 bits of 467 // the stack offset for a stack dump isn't likely to cause any problems. 468 fprintf(FD, " + %u",(unsigned)((char*)StackTrace[i]- 469 (char*)dlinfo.dli_saddr)); 470 } 471 fputc('\n', FD); 472 } 473#else 474 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO); 475#endif 476#endif 477} 478 479static void PrintStackTraceSignalHandler(void *) { 480 PrintStackTrace(stderr); 481} 482 483/// PrintStackTraceOnErrorSignal - When an error signal (such as SIGABRT or 484/// SIGSEGV) is delivered to the process, print a stack trace and then exit. 485void llvm::sys::PrintStackTraceOnErrorSignal() { 486 AddSignalHandler(PrintStackTraceSignalHandler, nullptr); 487 488#if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES) 489 // Environment variable to disable any kind of crash dialog. 490 if (getenv("LLVM_DISABLE_CRASH_REPORT")) { 491 mach_port_t self = mach_task_self(); 492 493 exception_mask_t mask = EXC_MASK_CRASH; 494 495 kern_return_t ret = task_set_exception_ports(self, 496 mask, 497 MACH_PORT_NULL, 498 EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES, 499 THREAD_STATE_NONE); 500 (void)ret; 501 } 502#endif 503} 504 505 506/***/ 507 508// On Darwin, raise sends a signal to the main thread instead of the current 509// thread. This has the unfortunate effect that assert() and abort() will end up 510// bypassing our crash recovery attempts. We work around this for anything in 511// the same linkage unit by just defining our own versions of the assert handler 512// and abort. 513 514#if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES) 515 516#include <signal.h> 517#include <pthread.h> 518 519int raise(int sig) { 520 return pthread_kill(pthread_self(), sig); 521} 522 523void __assert_rtn(const char *func, 524 const char *file, 525 int line, 526 const char *expr) { 527 if (func) 528 fprintf(stderr, "Assertion failed: (%s), function %s, file %s, line %d.\n", 529 expr, func, file, line); 530 else 531 fprintf(stderr, "Assertion failed: (%s), file %s, line %d.\n", 532 expr, file, line); 533 abort(); 534} 535 536void abort() { 537 raise(SIGABRT); 538 usleep(1000); 539 __builtin_trap(); 540} 541 542#endif 543