1 //===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source 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 bool StackTraceRequested = false;
34 /// InterruptFunction - The function to call if ctrl-c is pressed.
35 void (*InterruptFunction)() = 0;
37 std::vector<sys::Path> *FilesToRemove = 0 ;
38 std::vector<sys::Path> *DirectoriesToRemove = 0;
40 // IntSigs - Signals that may interrupt the program at any time.
41 const int IntSigs[] = {
42 SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
44 const int *IntSigsEnd = array_endof(IntSigs);
46 // KillSigs - Signals that are synchronous with the program that will cause it
48 const int KillSigs[] = {
49 SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ
54 const int *KillSigsEnd = array_endof(KillSigs);
57 void* StackTrace[256];
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.
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.
69 void PrintStackTrace() {
71 // Use backtrace() to output a backtrace on Linux systems with glibc.
72 int depth = backtrace(StackTrace, array_lengthof(StackTrace));
74 // Create a one-way unix pipe. The backtracing process writes to PipeFDs[1],
75 // the c++filt process reads from PipeFDs[0].
78 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
82 switch (pid_t ChildPID = fork()) {
83 case -1: // Error forking, print mangled stack trace
86 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
88 default: // backtracing process
89 close(PipeFDs[0]); // Close the reader side.
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;
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
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.
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);
115 // SignalHandler - The signal handler that runs...
116 RETSIGTYPE SignalHandler(int Sig) {
117 if (FilesToRemove != 0)
118 while (!FilesToRemove->empty()) {
119 FilesToRemove->back().eraseFromDisk(true);
120 FilesToRemove->pop_back();
123 if (DirectoriesToRemove != 0)
124 while (!DirectoriesToRemove->empty()) {
125 DirectoriesToRemove->back().eraseFromDisk(true);
126 DirectoriesToRemove->pop_back();
129 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
130 if (InterruptFunction) {
131 void (*IF)() = InterruptFunction;
132 InterruptFunction = 0;
133 IF(); // run the interrupt function.
136 exit(1); // If this is an interrupt signal, exit the program
140 // Otherwise if it is a fault (like SEGV) output the stacktrace to
141 // STDERR (if we can) and reissue the signal to die...
142 if (StackTraceRequested)
144 signal(Sig, SIG_DFL);
148 void RegisterHandler(int Signal) {
149 signal(Signal, SignalHandler);
155 void sys::SetInterruptFunction(void (*IF)()) {
156 InterruptFunction = IF;
157 RegisterHandler(SIGINT);
160 // RemoveFileOnSignal - The public API
161 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
162 if (FilesToRemove == 0)
163 FilesToRemove = new std::vector<sys::Path>;
165 FilesToRemove->push_back(Filename);
167 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
168 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
172 // RemoveDirectoryOnSignal - The public API
173 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
176 if (0 != stat(path.c_str(), &buf)) {
177 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
181 if (!S_ISDIR(buf.st_mode)) {
183 *ErrMsg = path.toString() + " is not a directory";
187 if (DirectoriesToRemove == 0)
188 DirectoriesToRemove = new std::vector<sys::Path>;
190 DirectoriesToRemove->push_back(path);
192 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
193 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
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() {
200 StackTraceRequested = true;
201 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);