[Fuzzer] Assign names to workers

[devnexen]

Summary

Allow to have a name for workers in case the fuzzed code is itself using threads.

[vitalybuka]

it could be nice to have a test

compiler-rt/lib/fuzzer/FuzzerCommand.h

 
 #include "FuzzerDefs.h"
 #include "FuzzerIO.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
+#include <thread>
 
 namespace fuzzer {
 
 class Command final {
 public:
   // This command line flag is used to indicate that the remaining command line
   // is immutable, meaning this flag effectively marks the end of the mutable
   // argument list.

compiler-rt/lib/fuzzer/FuzzerDriver.cpp

static int RunInMultipleProcesses(const std::vector<std::string> &Args,
   std::atomic<unsigned> Counter(0);
   std::atomic<bool> HasErrors(false);
   Command Cmd(Args);
   Cmd.removeFlag("jobs");
   Cmd.removeFlag("workers");
   std::vector<std::thread> V;
   std::thread Pulse(PulseThread);
   Pulse.detach();
-  for (unsigned i = 0; i < NumWorkers; i++)
-    V.push_back(std::thread(WorkerThread, std::ref(Cmd), &Counter, NumJobs,
-                            &HasErrors));
+  V.resize(NumWorkers);
+  for (unsigned i = 0; i < NumWorkers; i++) {
+    V[i] = std::thread(WorkerThread, std::ref(Cmd), &Counter, NumJobs,
+                            &HasErrors);
+    SetThreadName(V[i], "FuzzerWorker");
+  }
   for (auto &T : V)
     T.join();
   return HasErrors ? 1 : 0;
 }
 
 static void RssThread(Fuzzer *F, size_t RssLimitMb) {
   while (true) {
     SleepSeconds(1);

compiler-rt/lib/fuzzer/FuzzerUtil.h

 
 unsigned long GetPid();
 
 size_t GetPeakRSSMb();
 
 int ExecuteCommand(const Command &Cmd);
 bool ExecuteCommand(const Command &Cmd, std::string *CmdOutput);
 
+void SetThreadName(std::thread &thread, const std::string &name);
+
 // Fuchsia does not have popen/pclose.
 FILE *OpenProcessPipe(const char *Command, const char *Mode);
 int CloseProcessPipe(FILE *F);
 
 const void *SearchMemory(const void *haystack, size_t haystacklen,
                          const void *needle, size_t needlelen);
 
 std::string CloneArgsWithoutX(const std::vector<std::string> &Args,

compiler-rt/lib/fuzzer/FuzzerUtilDarwin.cpp

 void DiscardOutput(int Fd) {
   FILE* Temp = fopen("/dev/null", "w");
   if (!Temp)
     return;
   dup2(fileno(Temp), Fd);
   fclose(Temp);
 }
 
+void SetThreadName(std::thread &thread, const std::string &name) {
+  // TODO ?
+  // Darwin allows to set the name only on the current thread it seems
+}
+
 } // namespace fuzzer
 
 #endif // LIBFUZZER_APPLE

compiler-rt/lib/fuzzer/FuzzerUtilFuchsia.cpp

void DiscardOutput(int Fd) {
   dup2(nullfd, Fd);
 }
 
 size_t PageSize() {
   static size_t PageSizeCached = _zx_system_get_page_size();
   return PageSizeCached;
 }
 
+void SetThreadName(std::thread &thread, const std::string &name) {
+  // TODO ?
+}
+
 } // namespace fuzzer
 
 #endif // LIBFUZZER_FUCHSIA

compiler-rt/lib/fuzzer/FuzzerUtilLinux.cpp

 void DiscardOutput(int Fd) {
   FILE* Temp = fopen("/dev/null", "w");
   if (!Temp)
     return;
   dup2(fileno(Temp), Fd);
   fclose(Temp);
 }
 
+void SetThreadName(std::thread &thread, const std::string &name) {
+#if LIBFUZZER_LINUX || LIBFUZZER_FREEBSD
+  (void)pthread_setname_np(thread.native_handle(), name.c_str());
+#elif LIBFUZZER_NETBSD
+  (void)pthread_set_name_np(thread.native_handle(), "%s", name.c_str());
+#endif
+}
+
 } // namespace fuzzer
 
 #endif

compiler-rt/lib/fuzzer/FuzzerUtilWindows.cpp

size_t PageSize() {
   static size_t PageSizeCached = []() -> size_t {
     SYSTEM_INFO si;
     GetSystemInfo(&si);
     return si.dwPageSize;
   }();
   return PageSizeCached;
 }
 
+void SetThreadName(std::thread &thread, const std::string &name) {
+  // TODO ?
+  // to UTF-8 then SetThreadDescription ?
+}
+
 } // namespace fuzzer
 
 #endif // LIBFUZZER_WINDOWS