1//===--- CrashRecoveryContext.cpp - Crash Recovery ------------------------===//
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#include "llvm/Support/CrashRecoveryContext.h"
11#include "llvm/Config/config.h"
12#include "llvm/Support/ErrorHandling.h"
13#include "llvm/Support/ManagedStatic.h"
14#include "llvm/Support/Mutex.h"
15#include "llvm/Support/ThreadLocal.h"
16#include <setjmp.h>
17using namespace llvm;
18
19namespace {
20
21struct CrashRecoveryContextImpl;
22
23static ManagedStatic<
24    sys::ThreadLocal<const CrashRecoveryContextImpl> > CurrentContext;
25
26struct CrashRecoveryContextImpl {
27  // When threads are disabled, this links up all active
28  // CrashRecoveryContextImpls.  When threads are enabled there's one thread
29  // per CrashRecoveryContext and CurrentContext is a thread-local, so only one
30  // CrashRecoveryContextImpl is active per thread and this is always null.
31  const CrashRecoveryContextImpl *Next;
32
33  CrashRecoveryContext *CRC;
34  ::jmp_buf JumpBuffer;
35  volatile unsigned Failed : 1;
36  unsigned SwitchedThread : 1;
37
38public:
39  CrashRecoveryContextImpl(CrashRecoveryContext *CRC) : CRC(CRC),
40                                                        Failed(false),
41                                                        SwitchedThread(false) {
42    Next = CurrentContext->get();
43    CurrentContext->set(this);
44  }
45  ~CrashRecoveryContextImpl() {
46    if (!SwitchedThread)
47      CurrentContext->set(Next);
48  }
49
50  /// \brief Called when the separate crash-recovery thread was finished, to
51  /// indicate that we don't need to clear the thread-local CurrentContext.
52  void setSwitchedThread() {
53#if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
54    SwitchedThread = true;
55#endif
56  }
57
58  void HandleCrash() {
59    // Eliminate the current context entry, to avoid re-entering in case the
60    // cleanup code crashes.
61    CurrentContext->set(Next);
62
63    assert(!Failed && "Crash recovery context already failed!");
64    Failed = true;
65
66    // FIXME: Stash the backtrace.
67
68    // Jump back to the RunSafely we were called under.
69    longjmp(JumpBuffer, 1);
70  }
71};
72
73}
74
75static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
76static bool gCrashRecoveryEnabled = false;
77
78static ManagedStatic<sys::ThreadLocal<const CrashRecoveryContext>>
79       tlIsRecoveringFromCrash;
80
81CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
82
83CrashRecoveryContext::~CrashRecoveryContext() {
84  // Reclaim registered resources.
85  CrashRecoveryContextCleanup *i = head;
86  const CrashRecoveryContext *PC = tlIsRecoveringFromCrash->get();
87  tlIsRecoveringFromCrash->set(this);
88  while (i) {
89    CrashRecoveryContextCleanup *tmp = i;
90    i = tmp->next;
91    tmp->cleanupFired = true;
92    tmp->recoverResources();
93    delete tmp;
94  }
95  tlIsRecoveringFromCrash->set(PC);
96
97  CrashRecoveryContextImpl *CRCI = (CrashRecoveryContextImpl *) Impl;
98  delete CRCI;
99}
100
101bool CrashRecoveryContext::isRecoveringFromCrash() {
102  return tlIsRecoveringFromCrash->get() != nullptr;
103}
104
105CrashRecoveryContext *CrashRecoveryContext::GetCurrent() {
106  if (!gCrashRecoveryEnabled)
107    return nullptr;
108
109  const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
110  if (!CRCI)
111    return nullptr;
112
113  return CRCI->CRC;
114}
115
116void CrashRecoveryContext::registerCleanup(CrashRecoveryContextCleanup *cleanup)
117{
118  if (!cleanup)
119    return;
120  if (head)
121    head->prev = cleanup;
122  cleanup->next = head;
123  head = cleanup;
124}
125
126void
127CrashRecoveryContext::unregisterCleanup(CrashRecoveryContextCleanup *cleanup) {
128  if (!cleanup)
129    return;
130  if (cleanup == head) {
131    head = cleanup->next;
132    if (head)
133      head->prev = nullptr;
134  }
135  else {
136    cleanup->prev->next = cleanup->next;
137    if (cleanup->next)
138      cleanup->next->prev = cleanup->prev;
139  }
140  delete cleanup;
141}
142
143#ifdef LLVM_ON_WIN32
144
145#include "Windows/WindowsSupport.h"
146
147// On Windows, we can make use of vectored exception handling to
148// catch most crashing situations.  Note that this does mean
149// we will be alerted of exceptions *before* structured exception
150// handling has the opportunity to catch it.  But that isn't likely
151// to cause problems because nowhere in the project is SEH being
152// used.
153//
154// Vectored exception handling is built on top of SEH, and so it
155// works on a per-thread basis.
156//
157// The vectored exception handler functionality was added in Windows
158// XP, so if support for older versions of Windows is required,
159// it will have to be added.
160//
161// If we want to support as far back as Win2k, we could use the
162// SetUnhandledExceptionFilter API, but there's a risk of that
163// being entirely overwritten (it's not a chain).
164
165static LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
166{
167  // Lookup the current thread local recovery object.
168  const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
169
170  if (!CRCI) {
171    // Something has gone horribly wrong, so let's just tell everyone
172    // to keep searching
173    CrashRecoveryContext::Disable();
174    return EXCEPTION_CONTINUE_SEARCH;
175  }
176
177  // TODO: We can capture the stack backtrace here and store it on the
178  // implementation if we so choose.
179
180  // Handle the crash
181  const_cast<CrashRecoveryContextImpl*>(CRCI)->HandleCrash();
182
183  // Note that we don't actually get here because HandleCrash calls
184  // longjmp, which means the HandleCrash function never returns.
185  llvm_unreachable("Handled the crash, should have longjmp'ed out of here");
186}
187
188// Because the Enable and Disable calls are static, it means that
189// there may not actually be an Impl available, or even a current
190// CrashRecoveryContext at all.  So we make use of a thread-local
191// exception table.  The handles contained in here will either be
192// non-NULL, valid VEH handles, or NULL.
193static sys::ThreadLocal<const void> sCurrentExceptionHandle;
194
195void CrashRecoveryContext::Enable() {
196  sys::ScopedLock L(*gCrashRecoveryContextMutex);
197
198  if (gCrashRecoveryEnabled)
199    return;
200
201  gCrashRecoveryEnabled = true;
202
203  // We can set up vectored exception handling now.  We will install our
204  // handler as the front of the list, though there's no assurances that
205  // it will remain at the front (another call could install itself before
206  // our handler).  This 1) isn't likely, and 2) shouldn't cause problems.
207  PVOID handle = ::AddVectoredExceptionHandler(1, ExceptionHandler);
208  sCurrentExceptionHandle.set(handle);
209}
210
211void CrashRecoveryContext::Disable() {
212  sys::ScopedLock L(*gCrashRecoveryContextMutex);
213
214  if (!gCrashRecoveryEnabled)
215    return;
216
217  gCrashRecoveryEnabled = false;
218
219  PVOID currentHandle = const_cast<PVOID>(sCurrentExceptionHandle.get());
220  if (currentHandle) {
221    // Now we can remove the vectored exception handler from the chain
222    ::RemoveVectoredExceptionHandler(currentHandle);
223
224    // Reset the handle in our thread-local set.
225    sCurrentExceptionHandle.set(NULL);
226  }
227}
228
229#else
230
231// Generic POSIX implementation.
232//
233// This implementation relies on synchronous signals being delivered to the
234// current thread. We use a thread local object to keep track of the active
235// crash recovery context, and install signal handlers to invoke HandleCrash on
236// the active object.
237//
238// This implementation does not to attempt to chain signal handlers in any
239// reliable fashion -- if we get a signal outside of a crash recovery context we
240// simply disable crash recovery and raise the signal again.
241
242#include <signal.h>
243
244static const int Signals[] =
245    { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP };
246static const unsigned NumSignals = array_lengthof(Signals);
247static struct sigaction PrevActions[NumSignals];
248
249static void CrashRecoverySignalHandler(int Signal) {
250  // Lookup the current thread local recovery object.
251  const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
252
253  if (!CRCI) {
254    // We didn't find a crash recovery context -- this means either we got a
255    // signal on a thread we didn't expect it on, the application got a signal
256    // outside of a crash recovery context, or something else went horribly
257    // wrong.
258    //
259    // Disable crash recovery and raise the signal again. The assumption here is
260    // that the enclosing application will terminate soon, and we won't want to
261    // attempt crash recovery again.
262    //
263    // This call of Disable isn't thread safe, but it doesn't actually matter.
264    CrashRecoveryContext::Disable();
265    raise(Signal);
266
267    // The signal will be thrown once the signal mask is restored.
268    return;
269  }
270
271  // Unblock the signal we received.
272  sigset_t SigMask;
273  sigemptyset(&SigMask);
274  sigaddset(&SigMask, Signal);
275  sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
276
277  if (CRCI)
278    const_cast<CrashRecoveryContextImpl*>(CRCI)->HandleCrash();
279}
280
281void CrashRecoveryContext::Enable() {
282  sys::ScopedLock L(*gCrashRecoveryContextMutex);
283
284  if (gCrashRecoveryEnabled)
285    return;
286
287  gCrashRecoveryEnabled = true;
288
289  // Setup the signal handler.
290  struct sigaction Handler;
291  Handler.sa_handler = CrashRecoverySignalHandler;
292  Handler.sa_flags = 0;
293  sigemptyset(&Handler.sa_mask);
294
295  for (unsigned i = 0; i != NumSignals; ++i) {
296    sigaction(Signals[i], &Handler, &PrevActions[i]);
297  }
298}
299
300void CrashRecoveryContext::Disable() {
301  sys::ScopedLock L(*gCrashRecoveryContextMutex);
302
303  if (!gCrashRecoveryEnabled)
304    return;
305
306  gCrashRecoveryEnabled = false;
307
308  // Restore the previous signal handlers.
309  for (unsigned i = 0; i != NumSignals; ++i)
310    sigaction(Signals[i], &PrevActions[i], nullptr);
311}
312
313#endif
314
315bool CrashRecoveryContext::RunSafely(function_ref<void()> Fn) {
316  // If crash recovery is disabled, do nothing.
317  if (gCrashRecoveryEnabled) {
318    assert(!Impl && "Crash recovery context already initialized!");
319    CrashRecoveryContextImpl *CRCI = new CrashRecoveryContextImpl(this);
320    Impl = CRCI;
321
322    if (setjmp(CRCI->JumpBuffer) != 0) {
323      return false;
324    }
325  }
326
327  Fn();
328  return true;
329}
330
331void CrashRecoveryContext::HandleCrash() {
332  CrashRecoveryContextImpl *CRCI = (CrashRecoveryContextImpl *) Impl;
333  assert(CRCI && "Crash recovery context never initialized!");
334  CRCI->HandleCrash();
335}
336
337// FIXME: Portability.
338static void setThreadBackgroundPriority() {
339#ifdef __APPLE__
340  setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
341#endif
342}
343
344static bool hasThreadBackgroundPriority() {
345#ifdef __APPLE__
346  return getpriority(PRIO_DARWIN_THREAD, 0) == 1;
347#else
348  return false;
349#endif
350}
351
352namespace {
353struct RunSafelyOnThreadInfo {
354  function_ref<void()> Fn;
355  CrashRecoveryContext *CRC;
356  bool UseBackgroundPriority;
357  bool Result;
358};
359}
360
361static void RunSafelyOnThread_Dispatch(void *UserData) {
362  RunSafelyOnThreadInfo *Info =
363    reinterpret_cast<RunSafelyOnThreadInfo*>(UserData);
364
365  if (Info->UseBackgroundPriority)
366    setThreadBackgroundPriority();
367
368  Info->Result = Info->CRC->RunSafely(Info->Fn);
369}
370bool CrashRecoveryContext::RunSafelyOnThread(function_ref<void()> Fn,
371                                             unsigned RequestedStackSize) {
372  bool UseBackgroundPriority = hasThreadBackgroundPriority();
373  RunSafelyOnThreadInfo Info = { Fn, this, UseBackgroundPriority, false };
374  llvm_execute_on_thread(RunSafelyOnThread_Dispatch, &Info, RequestedStackSize);
375  if (CrashRecoveryContextImpl *CRC = (CrashRecoveryContextImpl *)Impl)
376    CRC->setSwitchedThread();
377  return Info.Result;
378}
379