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 const 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 std::string *ProgName;
  60
  61 static void PrintHelp() {
  62   Printf("Usage: %s [-flag1=val1 [-flag2=val2 ...] ] [dir1 [dir2 ...] ]\n",
  63          ProgName->c_str());
  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(const std::vector<std::string> &Args) {
 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   Inputs = new std::vector<std::string>;
 130   for (size_t A = 1; A < Args.size(); A++) {
 131     if (ParseOneFlag(Args[A].c_str())) continue;
 132     Inputs->push_back(Args[A]);
 133   }
 134 }
 135
 136 static std::mutex Mu;
 137
 138 static void PulseThread() {
 139   while (true) {
 140     std::this_thread::sleep_for(std::chrono::seconds(600));
 141     std::lock_guard<std::mutex> Lock(Mu);
 142     Printf("pulse...\n");
 143   }
 144 }
 145
 146 static void WorkerThread(const std::string &Cmd, std::atomic<int> *Counter,
 147                         int NumJobs, std::atomic<bool> *HasErrors) {
 148   while (true) {
 149     int C = (*Counter)++;
 150     if (C >= NumJobs) break;
 151     std::string Log = "fuzz-" + std::to_string(C) + ".log";
 152     std::string ToRun = Cmd + " > " + Log + " 2>&1\n";
 153     if (Flags.verbosity)
 154       Printf("%s", ToRun.c_str());
 155     int ExitCode = system(ToRun.c_str());
 156     if (ExitCode != 0)
 157       *HasErrors = true;
 158     std::lock_guard<std::mutex> Lock(Mu);
 159     Printf("================== Job %d exited with exit code %d ============\n",
 160            C, ExitCode);
 161     fuzzer::CopyFileToErr(Log);
 162   }
 163 }
 164
 165 static int RunInMultipleProcesses(const std::vector<std::string> &Args,
 166                                   int NumWorkers, int NumJobs) {
 167   std::atomic<int> Counter(0);
 168   std::atomic<bool> HasErrors(false);
 169   std::string Cmd;
 170   for (auto &S : Args) {
 171     if (FlagValue(S.c_str(), "jobs") || FlagValue(S.c_str(), "workers"))
 172       continue;
 173     Cmd += S + " ";
 174   }
 175   std::vector<std::thread> V;
 176   std::thread Pulse(PulseThread);
 177   Pulse.detach();
 178   for (int i = 0; i < NumWorkers; i++)
 179     V.push_back(std::thread(WorkerThread, Cmd, &Counter, NumJobs, &HasErrors));
 180   for (auto &T : V)
 181     T.join();
 182   return HasErrors ? 1 : 0;
 183 }
 184
 185 int RunOneTest(Fuzzer *F, const char *InputFilePath) {
 186   Unit U = FileToVector(InputFilePath);
 187   Unit PreciseSizedU(U);
 188   assert(PreciseSizedU.size() == PreciseSizedU.capacity());
 189   F->ExecuteCallback(PreciseSizedU);
 190   return 0;
 191 }
 192
 193 int FuzzerDriver(int argc, char **argv, UserCallback Callback) {
 194   FuzzerRandomLibc Rand(0);
 195   SimpleUserSuppliedFuzzer SUSF(&Rand, Callback);
 196   return FuzzerDriver(argc, argv, SUSF);
 197 }
 198
 199 int FuzzerDriver(int argc, char **argv, UserSuppliedFuzzer &USF) {
 200   std::vector<std::string> Args(argv, argv + argc);
 201   return FuzzerDriver(Args, USF);
 202 }
 203
 204 int FuzzerDriver(const std::vector<std::string> &Args, UserCallback Callback) {
 205   FuzzerRandomLibc Rand(0);
 206   SimpleUserSuppliedFuzzer SUSF(&Rand, Callback);
 207   return FuzzerDriver(Args, SUSF);
 208 }
 209
 210 int FuzzerDriver(const std::vector<std::string> &Args,
 211                  UserSuppliedFuzzer &USF) {
 212   using namespace fuzzer;
 213   assert(!Args.empty());
 214   ProgName = new std::string(Args[0]);
 215   ParseFlags(Args);
 216   if (Flags.help) {
 217     PrintHelp();
 218     return 0;
 219   }
 220
 221   if (Flags.jobs > 0 && Flags.workers == 0) {
 222     Flags.workers = std::min(NumberOfCpuCores() / 2, Flags.jobs);
 223     if (Flags.workers > 1)
 224       Printf("Running %d workers\n", Flags.workers);
 225   }
 226
 227   if (Flags.workers > 0 && Flags.jobs > 0)
 228     return RunInMultipleProcesses(Args, Flags.workers, Flags.jobs);
 229
 230   Fuzzer::FuzzingOptions Options;
 231   Options.Verbosity = Flags.verbosity;
 232   Options.MaxLen = Flags.max_len;
 233   Options.UnitTimeoutSec = Flags.timeout;
 234   Options.MaxTotalTimeSec = Flags.max_total_time;
 235   Options.DoCrossOver = Flags.cross_over;
 236   Options.MutateDepth = Flags.mutate_depth;
 237   Options.ExitOnFirst = Flags.exit_on_first;
 238   Options.UseCounters = Flags.use_counters;
 239   Options.UseIndirCalls = Flags.use_indir_calls;
 240   Options.UseTraces = Flags.use_traces;
 241   Options.ShuffleAtStartUp = Flags.shuffle;
 242   Options.PreferSmallDuringInitialShuffle =
 243       Flags.prefer_small_during_initial_shuffle;
 244   Options.Reload = Flags.reload;
 245   Options.OnlyASCII = Flags.only_ascii;
 246   Options.TBMDepth = Flags.tbm_depth;
 247   Options.TBMWidth = Flags.tbm_width;
 248   if (Flags.runs >= 0)
 249     Options.MaxNumberOfRuns = Flags.runs;
 250   if (!Inputs->empty())
 251     Options.OutputCorpus = (*Inputs)[0];
 252   if (Flags.sync_command)
 253     Options.SyncCommand = Flags.sync_command;
 254   Options.SyncTimeout = Flags.sync_timeout;
 255   Options.ReportSlowUnits = Flags.report_slow_units;
 256   if (Flags.artifact_prefix)
 257     Options.ArtifactPrefix = Flags.artifact_prefix;
 258   if (Flags.dict)
 259     if (!ParseDictionaryFile(FileToString(Flags.dict), &Options.Dictionary))
 260       return 1;
 261   if (Flags.verbosity > 0 && !Options.Dictionary.empty())
 262     Printf("Dictionary: %zd entries\n", Options.Dictionary.size());
 263   Options.SaveArtifacts = !Flags.test_single_input;
 264
 265   Fuzzer F(USF, Options);
 266
 267   // Timer
 268   if (Flags.timeout > 0)
 269     SetTimer(Flags.timeout / 2 + 1);
 270
 271   if (Flags.test_single_input)
 272     return RunOneTest(&F, Flags.test_single_input);
 273
 274   if (Flags.merge) {
 275     F.Merge(*Inputs);
 276     exit(0);
 277   }
 278
 279   unsigned Seed = Flags.seed;
 280   // Initialize Seed.
 281   if (Seed == 0)
 282     Seed = time(0) * 10000 + getpid();
 283   if (Flags.verbosity)
 284     Printf("Seed: %u\n", Seed);
 285   USF.GetRand().ResetSeed(Seed);
 286
 287   F.RereadOutputCorpus();
 288   for (auto &inp : *Inputs)
 289     if (inp != Options.OutputCorpus)
 290       F.ReadDir(inp, nullptr);
 291
 292   if (F.CorpusSize() == 0)
 293     F.AddToCorpus(Unit());  // Can't fuzz empty corpus, so add an empty input.
 294   F.ShuffleAndMinimize();
 295   if (Flags.save_minimized_corpus)
 296     F.SaveCorpus();
 297   F.Loop();
 298   if (Flags.verbosity)
 299     Printf("Done %d runs in %zd second(s)\n", F.getTotalNumberOfRuns(),
 300            F.secondsSinceProcessStartUp());
 301
 302   exit(0);  // Don't let F destroy itself.
 303 }
 304
 305 }  // namespace fuzzer