lib/System/Unix/Signals.inc

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