[libFuzzer] Diff 39 - [FuzzerSupport] Decouple Signal Handler interface from libFuzzer.

lib/Fuzzer/FuzzerDriver.cpp

int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
   auto *F = new Fuzzer(Callback, *Corpus, *MD, Options);
 
   for (auto &U: Dictionary)
     if (U.size() <= Word::GetMaxSize())
       MD->AddWordToManualDictionary(Word(U.data(), U.size()));
 
   StartRssThread(F, Flags.rss_limit_mb);
 
-  Options.HandleAbrt = Flags.handle_abrt;
-  Options.HandleBus = Flags.handle_bus;
-  Options.HandleFpe = Flags.handle_fpe;
-  Options.HandleIll = Flags.handle_ill;
-  Options.HandleInt = Flags.handle_int;
-  Options.HandleSegv = Flags.handle_segv;
-  Options.HandleTerm = Flags.handle_term;
-  SetSignalHandler(Options);
+  HandlerOptions HandlerOpt;
+  if (Flags.handle_abrt)
+    HandlerOpt.HandlerAbrt = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_bus)
+    HandlerOpt.HandlerBus = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_fpe)
+    HandlerOpt.HandlerFpe = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_ill)
+    HandlerOpt.HandlerIll = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_int)
+    HandlerOpt.HandlerInt = Fuzzer::StaticInterruptCallback;
+  if (Flags.handle_segv)
+    HandlerOpt.HandlerSegv = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_term)
+    HandlerOpt.HandlerTerm = Fuzzer::StaticInterruptCallback;
+  SetSignalHandler(HandlerOpt);
+
+  SetTimer(Options.UnitTimeoutSec / 2 + 1, Fuzzer::StaticAlarmCallback);
 
   if (Flags.minimize_crash_internal_step)
     return MinimizeCrashInputInternalStep(F, Corpus);
 
   if (DoPlainRun) {
     Options.SaveArtifacts = false;
     int Runs = std::max(1, Flags.runs);
     Printf("%s: Running %zd inputs %d time(s) each.\n", ProgName->c_str(),

lib/Fuzzer/FuzzerOptions.h

struct FuzzingOptions {
   bool PrintNEW = true; // Print a status line when new units are found;
   bool OutputCSV = false;
   bool PrintNewCovPcs = false;
   bool PrintFinalStats = false;
   bool PrintCorpusStats = false;
   bool PrintCoverage = false;
   bool DetectLeaks = true;
   int  TraceMalloc = 0;
-  bool HandleAbrt = false;
-  bool HandleBus = false;
-  bool HandleFpe = false;
-  bool HandleIll = false;
-  bool HandleInt = false;
-  bool HandleSegv = false;
-  bool HandleTerm = false;
 };
 
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_OPTIONS_H

lib/Fuzzer/Support/Util.h

 std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                               const char *X1, const char *X2);
 
 inline std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                                      const char *X) {
   return CloneArgsWithoutX(Args, X, X);
 }
 
-void SetSignalHandler(const FuzzingOptions& Options);
+struct HandlerOptions {
+  typedef void (*CB)(void);
+  CB HandlerAbrt = nullptr;
+  CB HandlerBus = nullptr;
+  CB HandlerFpe = nullptr;
+  CB HandlerIll = nullptr;
+  CB HandlerInt = nullptr;
+  CB HandlerSegv = nullptr;
+  CB HandlerTerm = nullptr;
+};
+
+void SetSignalHandler(const HandlerOptions& Options);
+
+void SetTimer(int Seconds, void (*Cb)(void));
 
 void SleepSeconds(int Seconds);
 
 unsigned long GetPid();
 
 size_t GetPeakRSSMb();
 
 const void *SearchMemory(const void *haystack, size_t haystacklen,

lib/Fuzzer/Support/UtilPosix.cpp

 //===- UtilPosix.cpp - Misc utils for Posix. ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils implementation using Posix API.
 //===----------------------------------------------------------------------===//
 #include "Platform.h"
 #if LIBFUZZER_POSIX
+#include "Util.h"
 #include "UtilIO.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <thread>
 #include <unistd.h>
 
 namespace fuzzer {
 
-static void AlarmHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticAlarmCallback();
-}
-
-static void CrashHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticCrashSignalCallback();
-}
-
-static void InterruptHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticInterruptCallback();
-}
+static HandlerOptions HandlerOpt;
 
 static void SetSigaction(int signum,
                          void (*callback)(int, siginfo_t *, void *)) {
   struct sigaction sigact;
   memset(&sigact, 0, sizeof(sigact));
   sigact.sa_sigaction = callback;
   if (sigaction(signum, &sigact, 0)) {
     Printf("libFuzzer: sigaction failed with %d\n", errno);
     exit(1);
   }
 }
 
-void SetTimer(int Seconds) {
+static void (*AlarmCB)(void) = nullptr;
+
+void SetTimer(int Seconds, void (*Cb)(void)) {
+  AlarmCB = Cb;
   struct itimerval T {
     {Seconds, 0}, { Seconds, 0 }
   };
   if (setitimer(ITIMER_REAL, &T, nullptr)) {
     Printf("libFuzzer: setitimer failed with %d\n", errno);
     exit(1);
   }
-  SetSigaction(SIGALRM, AlarmHandler);
+  SetSigaction(SIGALRM, [](int, siginfo_t *, void *) {AlarmCB();});
 }
 
-void SetSignalHandler(const FuzzingOptions& Options) {
-  if (Options.UnitTimeoutSec > 0)
-    SetTimer(Options.UnitTimeoutSec / 2 + 1);
-  if (Options.HandleInt)
-    SetSigaction(SIGINT, InterruptHandler);
-  if (Options.HandleTerm)
-    SetSigaction(SIGTERM, InterruptHandler);
-  if (Options.HandleSegv)
-    SetSigaction(SIGSEGV, CrashHandler);
-  if (Options.HandleBus)
-    SetSigaction(SIGBUS, CrashHandler);
-  if (Options.HandleAbrt)
-    SetSigaction(SIGABRT, CrashHandler);
-  if (Options.HandleIll)
-    SetSigaction(SIGILL, CrashHandler);
-  if (Options.HandleFpe)
-    SetSigaction(SIGFPE, CrashHandler);
+void SetSignalHandler(const HandlerOptions& Options) {
+  HandlerOpt = Options;
+  if (Options.HandlerInt)
+    SetSigaction(SIGINT, [](int,siginfo_t*,void*){HandlerOpt.HandlerInt();});
+  if (Options.HandlerTerm)
+    SetSigaction(SIGTERM, [](int,siginfo_t*,void*){HandlerOpt.HandlerTerm();});
+  if (Options.HandlerSegv)
+    SetSigaction(SIGSEGV, [](int,siginfo_t*,void*){HandlerOpt.HandlerSegv();});
+  if (Options.HandlerBus)
+    SetSigaction(SIGBUS, [](int,siginfo_t*,void*){HandlerOpt.HandlerBus();});
+  if (Options.HandlerAbrt)
+    SetSigaction(SIGABRT, [](int,siginfo_t*,void*){HandlerOpt.HandlerAbrt();});
+  if (Options.HandlerIll)
+    SetSigaction(SIGILL, [](int,siginfo_t*,void*){HandlerOpt.HandlerIll();});
+  if (Options.HandlerFpe)
+    SetSigaction(SIGFPE, [](int,siginfo_t*,void*){HandlerOpt.HandlerFpe();});
 }
 
 void SleepSeconds(int Seconds) {
   sleep(Seconds); // Use C API to avoid coverage from instrumented libc++.
 }
 
 unsigned long GetPid() { return (unsigned long)getpid(); }
 

lib/Fuzzer/Support/UtilWindows.cpp

 //===- UtilWindows.cpp - Misc utils for Windows. --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils implementation for Windows.
 //===----------------------------------------------------------------------===//
 #include "Platform.h"
 #if LIBFUZZER_WINDOWS
+#include "Util.h"
 #include "UtilIO.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>
 #include <sys/types.h>
 #include <windows.h>
 #include <Psapi.h>
 
 namespace fuzzer {
 
-static const FuzzingOptions* HandlerOpt = nullptr;
+static HandlerOptions HandlerOpt;
 
 LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo) {
   switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
     case EXCEPTION_ACCESS_VIOLATION:
     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
     case EXCEPTION_STACK_OVERFLOW:
-      if (HandlerOpt->HandleSegv)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerSegv)
+        HandlerOpt.HandlerSegv();
       break;
     case EXCEPTION_DATATYPE_MISALIGNMENT:
     case EXCEPTION_IN_PAGE_ERROR:
-      if (HandlerOpt->HandleBus)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerBus)
+        HandlerOpt.HandlerBus();
       break;
     case EXCEPTION_ILLEGAL_INSTRUCTION:
     case EXCEPTION_PRIV_INSTRUCTION:
-      if (HandlerOpt->HandleIll)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerIll)
+        HandlerOpt.HandlerIll();
       break;
     case EXCEPTION_FLT_DENORMAL_OPERAND:
     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
     case EXCEPTION_FLT_INEXACT_RESULT:
     case EXCEPTION_FLT_INVALID_OPERATION:
     case EXCEPTION_FLT_OVERFLOW:
     case EXCEPTION_FLT_STACK_CHECK:
     case EXCEPTION_FLT_UNDERFLOW:
     case EXCEPTION_INT_DIVIDE_BY_ZERO:
     case EXCEPTION_INT_OVERFLOW:
-      if (HandlerOpt->HandleFpe)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerFpe)
+        HandlerOpt.HandlerFpe();
       break;
   }
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
 BOOL WINAPI CtrlHandler(DWORD dwCtrlType) {
   switch (dwCtrlType) {
     case CTRL_C_EVENT:
-      if (HandlerOpt->HandleInt)
-        Fuzzer::StaticInterruptCallback();
+      if (HandlerOpt.HandlerInt)
+        HandlerOpt.HandlerInt();
       return TRUE;
     case CTRL_BREAK_EVENT:
-      if (HandlerOpt->HandleTerm)
-        Fuzzer::StaticInterruptCallback();
+      if (HandlerOpt.HandlerTerm)
+        HandlerOpt.HandlerTerm();
       return TRUE;
   }
   return FALSE;
 }
 
+static void (*AlarmCB)(void) = nullptr;
 void CALLBACK AlarmHandler(PVOID, BOOLEAN) {
-  Fuzzer::StaticAlarmCallback();
+  if (AlarmCB)
+    AlarmCB();
 }
 
 class TimerQ {
   HANDLE TimerQueue;
  public:
   TimerQ() : TimerQueue(NULL) {};
   ~TimerQ() {
     if (TimerQueue)
if (!CreateTimerQueueTimer(&Timer, TimerQueue, AlarmHandler, NULL,
       Printf("libFuzzer: CreateTimerQueueTimer failed.\n");
       exit(1);
     }
   };
 };
 
 static TimerQ Timer;
 
-static void CrashHandler(int) { Fuzzer::StaticCrashSignalCallback(); }
+static void AbrtHandler(int) {
+  if (HandlerOpt.HandlerAbrt)
+    HandlerOpt.HandlerAbrt();
+}
 
-void SetSignalHandler(const FuzzingOptions& Options) {
-  HandlerOpt = &Options;
+void SetTimer(int Seconds, void (*Cb)(void)) {
+  AlarmCB = Cb;
+  Timer.SetTimer(Seconds);
+}
 
-  if (Options.UnitTimeoutSec > 0)
-    Timer.SetTimer(Options.UnitTimeoutSec / 2 + 1);
+void SetSignalHandler(const HandlerOptions& Options) {
+  HandlerOpt = Options;
 
-  if (Options.HandleInt || Options.HandleTerm)
+  if (Options.HandlerInt || Options.HandlerTerm)
     if (!SetConsoleCtrlHandler(CtrlHandler, TRUE)) {
       DWORD LastError = GetLastError();
       Printf("libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu).\n",
         LastError);
       exit(1);
     }
 
-  if (Options.HandleSegv || Options.HandleBus || Options.HandleIll ||
-      Options.HandleFpe)
+  if (Options.HandlerSegv || Options.HandlerBus || Options.HandlerIll ||
+      Options.HandlerFpe)
     if (!AddVectoredExceptionHandler(1, ExceptionHandler)) {
       Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
       exit(1);
     }
 
-  if (Options.HandleAbrt)
-    if (SIG_ERR == signal(SIGABRT, CrashHandler)) {
+  if (Options.HandlerAbrt)
+    if (SIG_ERR == signal(SIGABRT, AbrtHandler)) {
       Printf("libFuzzer: signal failed with %d\n", errno);
       exit(1);
     }
 }
 
 void SleepSeconds(int Seconds) { Sleep(Seconds * 1000); }
 
 unsigned long GetPid() { return GetCurrentProcessId(); }