1 //===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines some helpful functions for dealing with the possibility of
11 // Unix signals occuring while your program is running.
13 //===----------------------------------------------------------------------===//
16 #include "llvm/ADT/STLExtras.h"
20 # include <execinfo.h> // For backtrace().
32 static bool StackTraceRequested = false;
34 /// InterruptFunction - The function to call if ctrl-c is pressed.
35 static void (*InterruptFunction)() = 0;
37 static std::vector<sys::Path> *FilesToRemove = 0 ;
38 static std::vector<sys::Path> *DirectoriesToRemove = 0;
40 // IntSigs - Signals that may interrupt the program at any time.
41 static const int IntSigs[] = {
42 SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
44 static const int *const IntSigsEnd =
45 IntSigs + sizeof(IntSigs) / sizeof(IntSigs[0]);
47 // KillSigs - Signals that are synchronous with the program that will cause it
49 static const int KillSigs[] = {
50 SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ
55 static const int *const KillSigsEnd =
56 KillSigs + sizeof(KillSigs) / sizeof(KillSigs[0]);
59 static void* StackTrace[256];
62 // PrintStackTrace - In the case of a program crash or fault, print out a stack
63 // trace so that the user has an indication of why and where we died.
65 // On glibc systems we have the 'backtrace' function, which works nicely, but
66 // doesn't demangle symbols.
67 static void PrintStackTrace() {
69 // Use backtrace() to output a backtrace on Linux systems with glibc.
70 int depth = backtrace(StackTrace,
71 static_cast<int>(array_lengthof(StackTrace)));
72 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
76 // SignalHandler - The signal handler that runs...
77 static RETSIGTYPE SignalHandler(int Sig) {
78 if (FilesToRemove != 0)
79 while (!FilesToRemove->empty()) {
80 FilesToRemove->back().eraseFromDisk(true);
81 FilesToRemove->pop_back();
84 if (DirectoriesToRemove != 0)
85 while (!DirectoriesToRemove->empty()) {
86 DirectoriesToRemove->back().eraseFromDisk(true);
87 DirectoriesToRemove->pop_back();
90 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
91 if (InterruptFunction) {
92 void (*IF)() = InterruptFunction;
93 InterruptFunction = 0;
94 IF(); // run the interrupt function.
97 exit(1); // If this is an interrupt signal, exit the program
101 // Otherwise if it is a fault (like SEGV) output the stacktrace to
102 // STDERR (if we can) and reissue the signal to die...
103 if (StackTraceRequested)
105 signal(Sig, SIG_DFL);
109 static void RegisterHandler(int Signal) {
110 signal(Signal, SignalHandler);
116 void sys::SetInterruptFunction(void (*IF)()) {
117 InterruptFunction = IF;
118 RegisterHandler(SIGINT);
121 // RemoveFileOnSignal - The public API
122 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
123 if (FilesToRemove == 0)
124 FilesToRemove = new std::vector<sys::Path>;
126 FilesToRemove->push_back(Filename);
128 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
129 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
133 // RemoveDirectoryOnSignal - The public API
134 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
137 if (0 != stat(path.c_str(), &buf)) {
138 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
142 if (!S_ISDIR(buf.st_mode)) {
144 *ErrMsg = path.toString() + " is not a directory";
148 if (DirectoriesToRemove == 0)
149 DirectoriesToRemove = new std::vector<sys::Path>;
151 DirectoriesToRemove->push_back(path);
153 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
154 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
158 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
159 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
160 void sys::PrintStackTraceOnErrorSignal() {
161 StackTraceRequested = true;
162 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);