[libFuzzer] Diff 9 - 1 - Properly use unsigned for Process ID.

[mpividori]

Summary

According to amccarth's suggestions in: https://reviews.llvm.org/D27234#inline-234114

For process id, I use a long unsigned to be sure it can hold a 32 bit unsigned (DWORD).

[amccarth]

The Windows bits look good to me know. Thanks for those revisions.

[mpividori]

@kcc Do you agree with these changes?

[kcc]

what problem does this fix?
If it fixes some existing problem, is a test possible?

[kcc]

This patch contain two independent changes then, right?
Please either split the patch, or abandon the non-relevant parts (jobs, workers).

[mpividori]

@kcc Ok. I updated the diff and Revision title to include the changes related to the Process ID.

[kcc]

LGTM

lib/Fuzzer/FuzzerDriver.cpp

 static void PulseThread() {
   while (true) {
     SleepSeconds(600);
     std::lock_guard<std::mutex> Lock(Mu);
     Printf("pulse...\n");
   }
 }
 
-static void WorkerThread(const std::string &Cmd, std::atomic<int> *Counter,
-                        int NumJobs, std::atomic<bool> *HasErrors) {
+static void WorkerThread(const std::string &Cmd, std::atomic<unsigned> *Counter,
+                         unsigned NumJobs, std::atomic<bool> *HasErrors) {
   while (true) {
-    int C = (*Counter)++;
+    unsigned C = (*Counter)++;
     if (C >= NumJobs) break;
     std::string Log = "fuzz-" + std::to_string(C) + ".log";
     std::string ToRun = Cmd + " > " + Log + " 2>&1\n";
     if (Flags.verbosity)
       Printf("%s", ToRun.c_str());
     int ExitCode = ExecuteCommand(ToRun);
     if (ExitCode != 0)
       *HasErrors = true;
     std::lock_guard<std::mutex> Lock(Mu);
-    Printf("================== Job %d exited with exit code %d ============\n",
+    Printf("================== Job %u exited with exit code %d ============\n",
            C, ExitCode);
     fuzzer::CopyFileToErr(Log);
   }
 }
 
 static std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                                      const char *X1, const char *X2) {
   std::string Cmd;
   for (auto &S : Args) {
     if (FlagValue(S.c_str(), X1) || FlagValue(S.c_str(), X2))
       continue;
     Cmd += S + " ";
   }
   return Cmd;
 }
 
 static std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                                      const char *X) {
   return CloneArgsWithoutX(Args, X, X);
 }
 
 static int RunInMultipleProcesses(const std::vector<std::string> &Args,
-                                  int NumWorkers, int NumJobs) {
-  std::atomic<int> Counter(0);
+                                  unsigned NumWorkers, unsigned NumJobs) {
+  std::atomic<unsigned> Counter(0);
   std::atomic<bool> HasErrors(false);
   std::string Cmd = CloneArgsWithoutX(Args, "jobs", "workers");
   std::vector<std::thread> V;
   std::thread Pulse(PulseThread);
   Pulse.detach();
-  for (int i = 0; i < NumWorkers; i++)
+  for (unsigned i = 0; i < NumWorkers; i++)
     V.push_back(std::thread(WorkerThread, Cmd, &Counter, NumJobs, &HasErrors));
   for (auto &T : V)
     T.join();
   return HasErrors ? 1 : 0;
 }
 
 static void RssThread(Fuzzer *F, size_t RssLimitMb) {
   while (true) {
int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
   if (Flags.close_fd_mask & 2)
     DupAndCloseStderr();
   if (Flags.close_fd_mask & 1)
     CloseStdout();
 
   if (Flags.jobs > 0 && Flags.workers == 0) {
     Flags.workers = std::min(NumberOfCpuCores() / 2, Flags.jobs);
     if (Flags.workers > 1)
-      Printf("Running %d workers\n", Flags.workers);
+      Printf("Running %u workers\n", Flags.workers);
   }
 
   if (Flags.workers > 0 && Flags.jobs > 0)
     return RunInMultipleProcesses(Args, Flags.workers, Flags.jobs);
 
   const size_t kMaxSaneLen = 1 << 20;
   const size_t kMinDefaultLen = 64;
   FuzzingOptions Options;

lib/Fuzzer/FuzzerFlags.def

 FUZZER_FLAG_INT(use_memcmp, 1,
                 "Use hints from intercepting memcmp, strcmp, etc")
 FUZZER_FLAG_INT(use_memmem, 1,
                 "Use hints from intercepting memmem, strstr, etc")
 FUZZER_FLAG_INT(use_value_profile, 0,
                 "Experimental. Use value profile to guide fuzzing.")
 FUZZER_FLAG_INT(use_cmp, 1, "Use CMP traces to guide mutations")
 FUZZER_FLAG_INT(shrink, 0, "Experimental. Try to shrink corpus elements.")
-FUZZER_FLAG_INT(jobs, 0, "Number of jobs to run. If jobs >= 1 we spawn"
+FUZZER_FLAG_UNSIGNED(jobs, 0, "Number of jobs to run. If jobs >= 1 we spawn"
                           " this number of jobs in separate worker processes"
                           " with stdout/stderr redirected to fuzz-JOB.log.")
-FUZZER_FLAG_INT(workers, 0,
+FUZZER_FLAG_UNSIGNED(workers, 0,
             "Number of simultaneous worker processes to run the jobs."
             " If zero, \"min(jobs,NumberOfCpuCores()/2)\" is used.")
 FUZZER_FLAG_INT(reload, 1,
                 "Reload the main corpus every <N> seconds to get new units"
                 " discovered by other processes. If 0, disabled")
 FUZZER_FLAG_INT(report_slow_units, 10,
     "Report slowest units if they run for more than this number of seconds.")
 FUZZER_FLAG_INT(only_ascii, 0,

lib/Fuzzer/FuzzerLoop.cpp

 }
 
 void Fuzzer::StaticInterruptCallback() {
   assert(F);
   F->InterruptCallback();
 }
 
 void Fuzzer::CrashCallback() {
-  Printf("==%d== ERROR: libFuzzer: deadly signal\n", GetPid());
+  Printf("==%lu== ERROR: libFuzzer: deadly signal\n", GetPid());
   if (EF->__sanitizer_print_stack_trace)
     EF->__sanitizer_print_stack_trace();
   Printf("NOTE: libFuzzer has rudimentary signal handlers.\n"
          "      Combine libFuzzer with AddressSanitizer or similar for better "
          "crash reports.\n");
   Printf("SUMMARY: libFuzzer: deadly signal\n");
   if (RunningCB) { // The fuzzer is in a consistent state.
     DumpCurrentUnit("crash-");
     PrintFinalStats();
   }
   exit(Options.ErrorExitCode);
 }
 
 void Fuzzer::InterruptCallback() {
-  Printf("==%d== libFuzzer: run interrupted; exiting\n", GetPid());
+  Printf("==%lu== libFuzzer: run interrupted; exiting\n", GetPid());
   std::lock_guard<std::mutex> Lock(RunningCBMtx);
   if (RunningCB) // The fuzzer is in a consistent state.
     PrintFinalStats();
   _Exit(0);  // Stop right now, don't perform any at-exit actions.
 }
 
 NO_SANITIZE_MEMORY
 void Fuzzer::AlarmCallback() {
   assert(Options.UnitTimeoutSec > 0);
   std::lock_guard<std::mutex> Lock(RunningCBMtx);
   if (!RunningCB)
     return; // We have not started running units yet.
   size_t Seconds =
       duration_cast<seconds>(system_clock::now() - UnitStartTime).count();
   if (Seconds == 0)
     return;
   if (Options.Verbosity >= 2)
     Printf("AlarmCallback %zd\n", Seconds);
   if (Seconds >= (size_t)Options.UnitTimeoutSec) {
     Printf("ALARM: working on the last Unit for %zd seconds\n", Seconds);
     Printf("       and the timeout value is %d (use -timeout=N to change)\n",
            Options.UnitTimeoutSec);
     DumpCurrentUnit("timeout-");
-    Printf("==%d== ERROR: libFuzzer: timeout after %d seconds\n", GetPid(),
+    Printf("==%lu== ERROR: libFuzzer: timeout after %d seconds\n", GetPid(),
            Seconds);
     if (EF->__sanitizer_print_stack_trace)
       EF->__sanitizer_print_stack_trace();
     Printf("SUMMARY: libFuzzer: timeout\n");
     PrintFinalStats();
     _Exit(Options.TimeoutExitCode); // Stop right now.
   }
 }
 
 void Fuzzer::RssLimitCallback() {
   Printf(
-      "==%d== ERROR: libFuzzer: out-of-memory (used: %zdMb; limit: %zdMb)\n",
+      "==%lu== ERROR: libFuzzer: out-of-memory (used: %zdMb; limit: %zdMb)\n",
       GetPid(), GetPeakRSSMb(), Options.RssLimitMb);
   Printf("   To change the out-of-memory limit use -rss_limit_mb=<N>\n\n");
   if (EF->__sanitizer_print_memory_profile)
     EF->__sanitizer_print_memory_profile(95);
   Printf("SUMMARY: libFuzzer: out-of-memory\n");
   std::lock_guard<std::mutex> Lock(RunningCBMtx);
   if (RunningCB) { // The fuzzer is in a consistent state.
     DumpCurrentUnit("oom-");

lib/Fuzzer/FuzzerUtil.h

 bool IsASCII(const uint8_t *Data, size_t Size);
 
 std::string Base64(const Unit &U);
 
 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC);
 
 std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC);
 
-int NumberOfCpuCores();
+unsigned NumberOfCpuCores();
 
 // Platform specific functions.
 struct SignalHandlerOptions {
   typedef void (*HandlerT)();
   int timeout = 0;
   HandlerT sigalrm_cb = nullptr;
   HandlerT sigsegv_cb = nullptr;
   HandlerT sigbus_cb = nullptr;
   HandlerT sigabrt_cb = nullptr;
   HandlerT sigill_cb = nullptr;
   HandlerT sigfpe_cb = nullptr;
   HandlerT sigint_cb = nullptr;
   HandlerT sigterm_cb = nullptr;
 };
 
 void SetSignalHandler(const SignalHandlerOptions& Opt);
 
 void SleepSeconds(int Seconds);
 
-int GetPid();
+unsigned long GetPid();
 
 size_t GetPeakRSSMb();
 
 bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out);
 
 int ExecuteCommand(const std::string &Command);
 
 #if LIBFUZZER_WINDOWS
 const void *memmem(const void *haystack, size_t haystacklen,
                    const void *needle, size_t needlelen);
 #endif
 
 }  // namespace fuzzer
 #endif  // LLVM_FUZZER_UTIL_H

lib/Fuzzer/FuzzerUtil.cpp

 
 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) {
   if (EF->__sanitizer_symbolize_pc)
     Printf("%s", DescribePC(SymbolizedFMT, PC).c_str());
   else
     Printf(FallbackFMT, PC);
 }
 
-int NumberOfCpuCores() {
+unsigned NumberOfCpuCores() {
   unsigned N = std::thread::hardware_concurrency();
   if (!N) {
     Printf("WARNING: std::thread::hardware_concurrency not well defined for "
       "your platform. Assuming CPU count of 1.\n");
     N = 1;
   }
   return N;
 }
 
 }  // namespace fuzzer

lib/Fuzzer/FuzzerUtilPosix.cpp

void SetSignalHandler(const SignalHandlerOptions& Opt) {
   if (Opt.sigfpe_cb)
     SetSigaction(SIGFPE, [](int,siginfo_t*,void*) {HandlerOpt.sigfpe_cb();});
 }
 
 void SleepSeconds(int Seconds) {
   sleep(Seconds);  // Use C API to avoid coverage from instrumented libc++.
 }
 
-int GetPid() { return getpid(); }
+unsigned long GetPid() { return (unsigned long)getpid(); }
 
 size_t GetPeakRSSMb() {
   struct rusage usage;
   if (getrusage(RUSAGE_SELF, &usage))
     return 0;
   if (LIBFUZZER_LINUX) {
     // ru_maxrss is in KiB
     return usage.ru_maxrss >> 10;

lib/Fuzzer/FuzzerUtilWindows.cpp

if (SIG_ERR == signal(SIGABRT, [](int){HandlerOpt.sigabrt_cb();})) {
       exit(1);
     }
 }
 
 void SleepSeconds(int Seconds) {
   Sleep(Seconds * 1000);
 }
 
-int GetPid() { return GetCurrentProcessId(); }
+unsigned long GetPid() { return GetCurrentProcessId(); }
 
 size_t GetPeakRSSMb() {
   PROCESS_MEMORY_COUNTERS info;
   if (!GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)))
     return 0;
   return info.PeakWorkingSetSize >> 20;
 }