lib/Fuzzer/FuzzerDriver.cpp

   1 //===- FuzzerDriver.cpp - FuzzerDriver function and flags -----------------===//
   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 // FuzzerDriver and flag parsing.
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "FuzzerInterface.h"
  13 #include "FuzzerInternal.h"
  14
  15 #include <cstring>
  16 #include <chrono>
  17 #include <unistd.h>
  18 #include <iostream>
  19 #include <thread>
  20 #include <atomic>
  21 #include <mutex>
  22 #include <string>
  23 #include <sstream>
  24 #include <algorithm>
  25 #include <iterator>
  26
  27 namespace fuzzer {
  28
  29 // Program arguments.
  30 struct FlagDescription {
  31   const char *Name;
  32   const char *Description;
  33   int   Default;
  34   int   *IntFlag;
  35   const char **StrFlag;
  36 };
  37
  38 struct {
  39 #define FUZZER_FLAG_INT(Name, Default, Description) int Name;
  40 #define FUZZER_FLAG_STRING(Name, Description) const char *Name;
  41 #include "FuzzerFlags.def"
  42 #undef FUZZER_FLAG_INT
  43 #undef FUZZER_FLAG_STRING
  44 } Flags;
  45
  46 static FlagDescription FlagDescriptions [] {
  47 #define FUZZER_FLAG_INT(Name, Default, Description)                            \
  48   { #Name, Description, Default, &Flags.Name, nullptr},
  49 #define FUZZER_FLAG_STRING(Name, Description)                                  \
  50   { #Name, Description, 0, nullptr, &Flags.Name },
  51 #include "FuzzerFlags.def"
  52 #undef FUZZER_FLAG_INT
  53 #undef FUZZER_FLAG_STRING
  54 };
  55
  56 static const size_t kNumFlags =
  57     sizeof(FlagDescriptions) / sizeof(FlagDescriptions[0]);
  58
  59 static std::vector<std::string> inputs;
  60 static const char *ProgName;
  61
  62 static void PrintHelp() {
  63   std::cerr << "Usage: " << ProgName
  64             << " [-flag1=val1 [-flag2=val2 ...] ] [dir1 [dir2 ...] ]\n";
  65   std::cerr << "\nFlags: (strictly in form -flag=value)\n";
  66   size_t MaxFlagLen = 0;
  67   for (size_t F = 0; F < kNumFlags; F++)
  68     MaxFlagLen = std::max(strlen(FlagDescriptions[F].Name), MaxFlagLen);
  69
  70   for (size_t F = 0; F < kNumFlags; F++) {
  71     const auto &D = FlagDescriptions[F];
  72     std::cerr << "  " << D.Name;
  73     for (size_t i = 0, n = MaxFlagLen - strlen(D.Name); i < n; i++)
  74       std::cerr << " ";
  75     std::cerr << "\t";
  76     std::cerr << D.Default << "\t" << D.Description << "\n";
  77   }
  78 }
  79
  80 static const char *FlagValue(const char *Param, const char *Name) {
  81   size_t Len = strlen(Name);
  82   if (Param[0] == '-' && strstr(Param + 1, Name) == Param + 1 &&
  83       Param[Len + 1] == '=')
  84       return &Param[Len + 2];
  85   return nullptr;
  86 }
  87
  88 static bool ParseOneFlag(const char *Param) {
  89   if (Param[0] != '-') return false;
  90   for (size_t F = 0; F < kNumFlags; F++) {
  91     const char *Name = FlagDescriptions[F].Name;
  92     const char *Str = FlagValue(Param, Name);
  93     if (Str)  {
  94       if (FlagDescriptions[F].IntFlag) {
  95         int Val = std::stol(Str);
  96         *FlagDescriptions[F].IntFlag = Val;
  97         if (Flags.verbosity >= 2)
  98           std::cerr << "Flag: " << Name << " " << Val << "\n";
  99         return true;
 100       } else if (FlagDescriptions[F].StrFlag) {
 101         *FlagDescriptions[F].StrFlag = Str;
 102         if (Flags.verbosity >= 2)
 103           std::cerr << "Flag: " << Name << " " << Str << "\n";
 104         return true;
 105       }
 106     }
 107   }
 108   PrintHelp();
 109   exit(1);
 110 }
 111
 112 // We don't use any library to minimize dependencies.
 113 static void ParseFlags(int argc, char **argv) {
 114   for (size_t F = 0; F < kNumFlags; F++) {
 115     if (FlagDescriptions[F].IntFlag)
 116       *FlagDescriptions[F].IntFlag = FlagDescriptions[F].Default;
 117     if (FlagDescriptions[F].StrFlag)
 118       *FlagDescriptions[F].StrFlag = nullptr;
 119   }
 120   for (int A = 1; A < argc; A++) {
 121     if (ParseOneFlag(argv[A])) continue;
 122     inputs.push_back(argv[A]);
 123   }
 124 }
 125
 126 static std::mutex Mu;
 127
 128 static void PulseThread() {
 129   while (true) {
 130     std::this_thread::sleep_for(std::chrono::seconds(600));
 131     std::lock_guard<std::mutex> Lock(Mu);
 132     std::cerr << "pulse...\n";
 133   }
 134 }
 135
 136 static void WorkerThread(const std::string &Cmd, std::atomic<int> *Counter,
 137                         int NumJobs, std::atomic<bool> *HasErrors) {
 138   while (true) {
 139     int C = (*Counter)++;
 140     if (C >= NumJobs) break;
 141     std::string Log = "fuzz-" + std::to_string(C) + ".log";
 142     std::string ToRun = Cmd + " > " + Log + " 2>&1\n";
 143     if (Flags.verbosity)
 144       std::cerr << ToRun;
 145     int ExitCode = system(ToRun.c_str());
 146     if (ExitCode != 0)
 147       *HasErrors = true;
 148     std::lock_guard<std::mutex> Lock(Mu);
 149     std::cerr << "================== Job " << C
 150               << " exited with exit code " << ExitCode
 151               << " =================\n";
 152     fuzzer::CopyFileToErr(Log);
 153   }
 154 }
 155
 156 static int RunInMultipleProcesses(int argc, char **argv, int NumWorkers,
 157                                   int NumJobs) {
 158   std::atomic<int> Counter(0);
 159   std::atomic<bool> HasErrors(false);
 160   std::string Cmd;
 161   for (int i = 0; i < argc; i++) {
 162     if (FlagValue(argv[i], "jobs") || FlagValue(argv[i], "workers")) continue;
 163     Cmd += argv[i];
 164     Cmd += " ";
 165   }
 166   std::vector<std::thread> V;
 167   std::thread Pulse(PulseThread);
 168   for (int i = 0; i < NumWorkers; i++)
 169     V.push_back(std::thread(WorkerThread, Cmd, &Counter, NumJobs, &HasErrors));
 170   for (auto &T : V)
 171     T.join();
 172   Pulse.join();
 173   return HasErrors ? 1 : 0;
 174 }
 175
 176 std::vector<std::string> ReadTokensFile(const char *TokensFilePath) {
 177   if (!TokensFilePath) return {};
 178   std::string TokensFileContents = FileToString(TokensFilePath);
 179   std::istringstream ISS(TokensFileContents);
 180   std::vector<std::string> Res = {std::istream_iterator<std::string>{ISS},
 181                                   std::istream_iterator<std::string>{}};
 182   Res.push_back(" ");
 183   Res.push_back("\t");
 184   Res.push_back("\n");
 185   return Res;
 186 }
 187
 188 int ApplyTokens(const Fuzzer &F, const char *InputFilePath) {
 189   Unit U = FileToVector(InputFilePath);
 190   auto T = F.SubstituteTokens(U);
 191   T.push_back(0);
 192   std::cout << T.data();
 193   return 0;
 194 }
 195
 196 int FuzzerDriver(int argc, char **argv, UserCallback Callback) {
 197   using namespace fuzzer;
 198
 199   ProgName = argv[0];
 200   ParseFlags(argc, argv);
 201   if (Flags.help) {
 202     PrintHelp();
 203     return 0;
 204   }
 205
 206   if (Flags.workers > 0 && Flags.jobs > 0)
 207     return RunInMultipleProcesses(argc, argv, Flags.workers, Flags.jobs);
 208
 209   Fuzzer::FuzzingOptions Options;
 210   Options.Verbosity = Flags.verbosity;
 211   Options.MaxLen = Flags.max_len;
 212   Options.DoCrossOver = Flags.cross_over;
 213   Options.MutateDepth = Flags.mutate_depth;
 214   Options.ExitOnFirst = Flags.exit_on_first;
 215   Options.UseCounters = Flags.use_counters;
 216   Options.UseTraces = Flags.use_traces;
 217   Options.UseFullCoverageSet = Flags.use_full_coverage_set;
 218   Options.UseCoveragePairs = Flags.use_coverage_pairs;
 219   Options.UseDFSan = Flags.dfsan;
 220   Options.PreferSmallDuringInitialShuffle =
 221       Flags.prefer_small_during_initial_shuffle;
 222   Options.Tokens = ReadTokensFile(Flags.tokens);
 223   Options.Reload = Flags.reload;
 224   if (Flags.runs >= 0)
 225     Options.MaxNumberOfRuns = Flags.runs;
 226   if (!inputs.empty())
 227     Options.OutputCorpus = inputs[0];
 228   Fuzzer F(Callback, Options);
 229
 230   unsigned seed = Flags.seed;
 231   // Initialize seed.
 232   if (seed == 0)
 233     seed = time(0) * 10000 + getpid();
 234   if (Flags.verbosity)
 235     std::cerr << "Seed: " << seed << "\n";
 236   srand(seed);
 237
 238   // Timer
 239   if (Flags.timeout > 0)
 240     SetTimer(Flags.timeout);
 241
 242   if (Flags.verbosity >= 2) {
 243     std::cerr << "Tokens: {";
 244     for (auto &T : Options.Tokens)
 245       std::cerr << T << ",";
 246     std::cerr << "}\n";
 247   }
 248
 249   if (Flags.apply_tokens)
 250     return ApplyTokens(F, Flags.apply_tokens);
 251
 252   F.RereadOutputCorpus();
 253   for (auto &inp : inputs)
 254     if (inp != Options.OutputCorpus)
 255       F.ReadDir(inp, nullptr);
 256
 257   if (F.CorpusSize() == 0)
 258     F.AddToCorpus(Unit());  // Can't fuzz empty corpus, so add an empty input.
 259   F.ShuffleAndMinimize();
 260   if (Flags.save_minimized_corpus)
 261     F.SaveCorpus();
 262   F.Loop(Flags.iterations < 0 ? INT_MAX : Flags.iterations);
 263   if (Flags.verbosity)
 264     std::cerr << "Done " << F.getTotalNumberOfRuns()
 265               << " runs in " << F.secondsSinceProcessStartUp()
 266               << " seconds\n";
 267   return 0;
 268 }
 269
 270 }  // namespace fuzzer