Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 1 | //===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame^] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file defines some helpful functions for dealing with the possibility of |
| 11 | // Unix signals occuring while your program is running. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "Unix.h" |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 16 | #include "llvm/ADT/STLExtras.h" |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 17 | #include <vector> |
| 18 | #include <algorithm> |
Reid Spencer | cdf54d0 | 2004-12-27 06:16:52 +0000 | [diff] [blame] | 19 | #if HAVE_EXECINFO_H |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 20 | # include <execinfo.h> // For backtrace(). |
| 21 | #endif |
Reid Spencer | cdf54d0 | 2004-12-27 06:16:52 +0000 | [diff] [blame] | 22 | #if HAVE_SIGNAL_H |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 23 | #include <signal.h> |
Reid Spencer | cdf54d0 | 2004-12-27 06:16:52 +0000 | [diff] [blame] | 24 | #endif |
Reid Spencer | 2ae9d11 | 2007-04-07 18:52:17 +0000 | [diff] [blame] | 25 | #if HAVE_SYS_STAT_H |
| 26 | #include <sys/stat.h> |
| 27 | #endif |
Chris Lattner | 8961501 | 2006-08-01 17:59:14 +0000 | [diff] [blame] | 28 | using namespace llvm; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 29 | |
| 30 | namespace { |
| 31 | |
Reid Spencer | dc6830f | 2006-06-16 00:00:57 +0000 | [diff] [blame] | 32 | bool StackTraceRequested = false; |
| 33 | |
Chris Lattner | fa8c292 | 2005-08-02 02:14:22 +0000 | [diff] [blame] | 34 | /// InterruptFunction - The function to call if ctrl-c is pressed. |
| 35 | void (*InterruptFunction)() = 0; |
| 36 | |
Reid Spencer | a8e80c5 | 2006-08-07 05:34:08 +0000 | [diff] [blame] | 37 | std::vector<sys::Path> *FilesToRemove = 0 ; |
Chris Lattner | 8961501 | 2006-08-01 17:59:14 +0000 | [diff] [blame] | 38 | std::vector<sys::Path> *DirectoriesToRemove = 0; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 39 | |
| 40 | // IntSigs - Signals that may interrupt the program at any time. |
| 41 | const int IntSigs[] = { |
| 42 | SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2 |
| 43 | }; |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 44 | const int *IntSigsEnd = array_endof(IntSigs); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 45 | |
| 46 | // KillSigs - Signals that are synchronous with the program that will cause it |
| 47 | // to die. |
| 48 | const int KillSigs[] = { |
| 49 | SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ |
| 50 | #ifdef SIGEMT |
| 51 | , SIGEMT |
| 52 | #endif |
| 53 | }; |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 54 | const int *KillSigsEnd = array_endof(KillSigs); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 55 | |
| 56 | #ifdef HAVE_BACKTRACE |
| 57 | void* StackTrace[256]; |
| 58 | #endif |
| 59 | |
| 60 | // PrintStackTrace - In the case of a program crash or fault, print out a stack |
| 61 | // trace so that the user has an indication of why and where we died. |
| 62 | // |
| 63 | // On glibc systems we have the 'backtrace' function, which works nicely, but |
| 64 | // doesn't demangle symbols. In order to backtrace symbols, we fork and exec a |
| 65 | // 'c++filt' process to do the demangling. This seems like the simplest and |
| 66 | // most robust solution when we can't allocate memory (such as in a signal |
| 67 | // handler). If we can't find 'c++filt', we fallback to printing mangled names. |
| 68 | // |
| 69 | void PrintStackTrace() { |
| 70 | #ifdef HAVE_BACKTRACE |
| 71 | // Use backtrace() to output a backtrace on Linux systems with glibc. |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 72 | int depth = backtrace(StackTrace, array_lengthof(StackTrace)); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 73 | |
| 74 | // Create a one-way unix pipe. The backtracing process writes to PipeFDs[1], |
| 75 | // the c++filt process reads from PipeFDs[0]. |
| 76 | int PipeFDs[2]; |
| 77 | if (pipe(PipeFDs)) { |
| 78 | backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO); |
| 79 | return; |
| 80 | } |
| 81 | |
| 82 | switch (pid_t ChildPID = fork()) { |
| 83 | case -1: // Error forking, print mangled stack trace |
| 84 | close(PipeFDs[0]); |
| 85 | close(PipeFDs[1]); |
| 86 | backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO); |
| 87 | return; |
| 88 | default: // backtracing process |
| 89 | close(PipeFDs[0]); // Close the reader side. |
| 90 | |
| 91 | // Print the mangled backtrace into the pipe. |
| 92 | backtrace_symbols_fd(StackTrace, depth, PipeFDs[1]); |
| 93 | close(PipeFDs[1]); // We are done writing. |
| 94 | while (waitpid(ChildPID, 0, 0) == -1) |
| 95 | if (errno != EINTR) break; |
| 96 | return; |
| 97 | |
| 98 | case 0: // c++filt process |
| 99 | close(PipeFDs[1]); // Close the writer side. |
| 100 | dup2(PipeFDs[0], 0); // Read from standard input |
| 101 | close(PipeFDs[0]); // Close the old descriptor |
| 102 | dup2(2, 1); // Revector stdout -> stderr |
| 103 | |
| 104 | // Try to run c++filt or gc++filt. If neither is found, call back on 'cat' |
| 105 | // to print the mangled stack trace. If we can't find cat, just exit. |
Alkis Evlogimenos | 38da41c | 2005-04-22 17:56:01 +0000 | [diff] [blame] | 106 | execlp("c++filt", "c++filt", (char*)NULL); |
| 107 | execlp("gc++filt", "gc++filt", (char*)NULL); |
| 108 | execlp("cat", "cat", (char*)NULL); |
| 109 | execlp("/bin/cat", "cat", (char*)NULL); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 110 | exit(0); |
| 111 | } |
| 112 | #endif |
| 113 | } |
| 114 | |
| 115 | // SignalHandler - The signal handler that runs... |
| 116 | RETSIGTYPE SignalHandler(int Sig) { |
| 117 | if (FilesToRemove != 0) |
| 118 | while (!FilesToRemove->empty()) { |
Reid Spencer | a8e80c5 | 2006-08-07 05:34:08 +0000 | [diff] [blame] | 119 | FilesToRemove->back().eraseFromDisk(true); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 120 | FilesToRemove->pop_back(); |
| 121 | } |
| 122 | |
| 123 | if (DirectoriesToRemove != 0) |
| 124 | while (!DirectoriesToRemove->empty()) { |
Reid Spencer | a229c5c | 2005-07-08 03:08:58 +0000 | [diff] [blame] | 125 | DirectoriesToRemove->back().eraseFromDisk(true); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 126 | DirectoriesToRemove->pop_back(); |
| 127 | } |
| 128 | |
Chris Lattner | fa8c292 | 2005-08-02 02:14:22 +0000 | [diff] [blame] | 129 | if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) { |
| 130 | if (InterruptFunction) { |
| 131 | void (*IF)() = InterruptFunction; |
| 132 | InterruptFunction = 0; |
| 133 | IF(); // run the interrupt function. |
| 134 | return; |
| 135 | } else { |
| 136 | exit(1); // If this is an interrupt signal, exit the program |
| 137 | } |
| 138 | } |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 139 | |
| 140 | // Otherwise if it is a fault (like SEGV) output the stacktrace to |
| 141 | // STDERR (if we can) and reissue the signal to die... |
Reid Spencer | dc6830f | 2006-06-16 00:00:57 +0000 | [diff] [blame] | 142 | if (StackTraceRequested) |
| 143 | PrintStackTrace(); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 144 | signal(Sig, SIG_DFL); |
| 145 | } |
| 146 | |
| 147 | // Just call signal |
| 148 | void RegisterHandler(int Signal) { |
| 149 | signal(Signal, SignalHandler); |
| 150 | } |
| 151 | |
| 152 | } |
| 153 | |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 154 | |
Chris Lattner | fa8c292 | 2005-08-02 02:14:22 +0000 | [diff] [blame] | 155 | void sys::SetInterruptFunction(void (*IF)()) { |
| 156 | InterruptFunction = IF; |
| 157 | RegisterHandler(SIGINT); |
| 158 | } |
| 159 | |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 160 | // RemoveFileOnSignal - The public API |
Reid Spencer | 0554575 | 2006-08-25 21:37:17 +0000 | [diff] [blame] | 161 | bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) { |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 162 | if (FilesToRemove == 0) |
Reid Spencer | a8e80c5 | 2006-08-07 05:34:08 +0000 | [diff] [blame] | 163 | FilesToRemove = new std::vector<sys::Path>; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 164 | |
Reid Spencer | a8e80c5 | 2006-08-07 05:34:08 +0000 | [diff] [blame] | 165 | FilesToRemove->push_back(Filename); |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 166 | |
| 167 | std::for_each(IntSigs, IntSigsEnd, RegisterHandler); |
| 168 | std::for_each(KillSigs, KillSigsEnd, RegisterHandler); |
Reid Spencer | 0554575 | 2006-08-25 21:37:17 +0000 | [diff] [blame] | 169 | return false; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | // RemoveDirectoryOnSignal - The public API |
Reid Spencer | 0554575 | 2006-08-25 21:37:17 +0000 | [diff] [blame] | 173 | bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) { |
Chris Lattner | 8961501 | 2006-08-01 17:59:14 +0000 | [diff] [blame] | 174 | // Not a directory? |
Reid Spencer | 2ae9d11 | 2007-04-07 18:52:17 +0000 | [diff] [blame] | 175 | struct stat buf; |
| 176 | if (0 != stat(path.c_str(), &buf)) { |
| 177 | MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file"); |
Reid Spencer | 8475ec0 | 2007-03-29 19:05:44 +0000 | [diff] [blame] | 178 | return true; |
Reid Spencer | 2ae9d11 | 2007-04-07 18:52:17 +0000 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | if (!S_ISDIR(buf.st_mode)) { |
Reid Spencer | 0554575 | 2006-08-25 21:37:17 +0000 | [diff] [blame] | 182 | if (ErrMsg) |
| 183 | *ErrMsg = path.toString() + " is not a directory"; |
| 184 | return true; |
| 185 | } |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 186 | |
| 187 | if (DirectoriesToRemove == 0) |
| 188 | DirectoriesToRemove = new std::vector<sys::Path>; |
| 189 | |
| 190 | DirectoriesToRemove->push_back(path); |
| 191 | |
| 192 | std::for_each(IntSigs, IntSigsEnd, RegisterHandler); |
| 193 | std::for_each(KillSigs, KillSigsEnd, RegisterHandler); |
Reid Spencer | 0554575 | 2006-08-25 21:37:17 +0000 | [diff] [blame] | 194 | return false; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or |
| 198 | /// SIGSEGV) is delivered to the process, print a stack trace and then exit. |
| 199 | void sys::PrintStackTraceOnErrorSignal() { |
Reid Spencer | dc6830f | 2006-06-16 00:00:57 +0000 | [diff] [blame] | 200 | StackTraceRequested = true; |
Reid Spencer | 496c277 | 2004-08-29 19:22:48 +0000 | [diff] [blame] | 201 | std::for_each(KillSigs, KillSigsEnd, RegisterHandler); |
| 202 | } |