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