Add a `Symbolizer::GetEnvP()` method that allows symbolizer implementations to customise the environment of the symbolizer binary.

[delcypher]

Summary

This change introduces the Symbolizer::GetEnvP() method that returns a
pointer to environment array used for spawning the symbolizer process.
The motivation is to allow implementations to customise the environment
if required. The default implementation just returns
__sanitizer::GetEnviron() which (provided it's implemented) should
preserve the existing behaviours of the various implementations.

This change has been plumbed through the internal_spawn(...) and
StartSubprocess(...) process spawning implementations.

For the StartSubprocess() implementation we need to call execve()
rather than execv() to pass the environment. However, it appears that
internal_execve(...) exists in sanitizer_common so this patch uses that
which seems like a nice clean up.

Support in the Windows implementation of
SymbolizerProcess:StartSymbolizerSubprocess() has not been added
because the Windows sanitizer runtime doesn't implement GetEnviron().

rdar://problem/58789439

[delcypher]

Make GetEnvP() protected rather private so sub-class implementation can call the parent function.

[delcypher]

@vitalybuka Thanks for the review. I just discovered that GetEnvP() needs to be protected rather than private so it can be called by subclass implementations so I've updated this patch to do that. If you're happy with this could you approve again?

compiler-rt/lib/sanitizer_common/sanitizer_file.h

 bool IsAbsolutePath(const char *path);
 // Starts a subprocess and returs its pid.
 // If *_fd parameters are not kInvalidFd their corresponding input/output
 // streams will be redirect to the file. The files will always be closed
 // in parent process even in case of an error.
 // The child process will close all fds after STDERR_FILENO
 // before passing control to a program.
 pid_t StartSubprocess(const char *filename, const char *const argv[],
-                      fd_t stdin_fd = kInvalidFd, fd_t stdout_fd = kInvalidFd,
-                      fd_t stderr_fd = kInvalidFd);
+                      const char *const envp[], fd_t stdin_fd = kInvalidFd,
+                      fd_t stdout_fd = kInvalidFd, fd_t stderr_fd = kInvalidFd);
 // Checks if specified process is still running
 bool IsProcessRunning(pid_t pid);
 // Waits for the process to finish and returns its exit code.
 // Returns -1 in case of an error.
 int WaitForProcess(pid_t pid);
 
 // Maps given file to virtual memory, and returns pointer to it
 // (or NULL if mapping fails). Stores the size of mmaped region
 // in '*buff_size'.
 void *MapFileToMemory(const char *file_name, uptr *buff_size);
 void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FILE_H

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

 }
 
 int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
                           const void *newp, uptr newlen) {
   return sysctlbyname(sname, oldp, (size_t *)oldlenp, const_cast<void *>(newp),
                       (size_t)newlen);
 }
 
-static fd_t internal_spawn_impl(const char *argv[], pid_t *pid) {
+static fd_t internal_spawn_impl(const char *argv[], const char *envp[],
+                                pid_t *pid) {
   fd_t master_fd = kInvalidFd;
   fd_t slave_fd = kInvalidFd;
 
   auto fd_closer = at_scope_exit([&] {
     internal_close(master_fd);
     internal_close(slave_fd);
   });
 
static fd_t internal_spawn_impl(const char *argv[], const char *envp[],
 
   // In the spawned process, close all file descriptors that are not explicitly
   // described by the file actions object. This is Darwin-specific extension.
   res = posix_spawnattr_setflags(&attrs, POSIX_SPAWN_CLOEXEC_DEFAULT);
   if (res != 0) return kInvalidFd;
 
   // posix_spawn
   char **argv_casted = const_cast<char **>(argv);
-  char **env = GetEnviron();
-  res = posix_spawn(pid, argv[0], &acts, &attrs, argv_casted, env);
+  char **envp_casted = const_cast<char **>(envp);
+  res = posix_spawn(pid, argv[0], &acts, &attrs, argv_casted, envp_casted);
   if (res != 0) return kInvalidFd;
 
   // Disable echo in the new terminal, disable CR.
   struct termios termflags;
   tcgetattr(master_fd, &termflags);
   termflags.c_oflag &= ~ONLCR;
   termflags.c_lflag &= ~ECHO;
   tcsetattr(master_fd, TCSANOW, &termflags);
 
   // On success, do not close master_fd on scope exit.
   fd_t fd = master_fd;
   master_fd = kInvalidFd;
 
   return fd;
 }
 
-fd_t internal_spawn(const char *argv[], pid_t *pid) {
+fd_t internal_spawn(const char *argv[], const char *envp[], pid_t *pid) {
   // The client program may close its stdin and/or stdout and/or stderr thus
   // allowing open/posix_openpt to reuse file descriptors 0, 1 or 2. In this
   // case the communication is broken if either the parent or the child tries to
   // close or duplicate these descriptors. We temporarily reserve these
   // descriptors here to prevent this.
   fd_t low_fds[3];
   size_t count = 0;
 
   for (; count < 3; count++) {
     low_fds[count] = posix_openpt(O_RDWR);
     if (low_fds[count] >= STDERR_FILENO)
       break;
   }
 
-  fd_t fd = internal_spawn_impl(argv, pid);
+  fd_t fd = internal_spawn_impl(argv, envp, pid);
 
   for (; count > 0; count--) {
     internal_close(low_fds[count]);
   }
 
   return fd;
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_posix.h

 #if SANITIZER_NETBSD
 uptr internal_ptrace(int request, int pid, void *addr, int data);
 #else
 uptr internal_ptrace(int request, int pid, void *addr, void *data);
 #endif
 uptr internal_waitpid(int pid, int *status, int options);
 
 int internal_fork();
-fd_t internal_spawn(const char *argv[], pid_t *pid);
+fd_t internal_spawn(const char *argv[], const char *envp[], pid_t *pid);
 
 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                     uptr *oldlenp, const void *newp, uptr newlen);
 int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
                           const void *newp, uptr newlen);
 
 // These functions call appropriate pthread_ functions directly, bypassing
 // the interceptor. They are weak and may not be present in some tools.

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

if (!stack_set) {
              "%zu < %zu\n", stacksize, minstacksize);
       Printf("Sanitizer: pthread_create is likely to fail.\n");
     }
   }
 }
 #endif // !SANITIZER_GO
 
 pid_t StartSubprocess(const char *program, const char *const argv[],
-                      fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) {
+                      const char *const envp[], fd_t stdin_fd, fd_t stdout_fd,
+                      fd_t stderr_fd) {
   auto file_closer = at_scope_exit([&] {
     if (stdin_fd != kInvalidFd) {
       internal_close(stdin_fd);
     }
     if (stdout_fd != kInvalidFd) {
       internal_close(stdout_fd);
     }
     if (stderr_fd != kInvalidFd) {
if (pid == 0) {
     if (stderr_fd != kInvalidFd) {
       internal_close(STDERR_FILENO);
       internal_dup2(stderr_fd, STDERR_FILENO);
       internal_close(stderr_fd);
     }
 
     for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) internal_close(fd);
 
-    execv(program, const_cast<char **>(&argv[0]));
+    internal_execve(program, const_cast<char **>(&argv[0]),
+                    const_cast<char *const *>(envp));
     internal__exit(1);
   }
 
   return pid;
 }
 
 bool IsProcessRunning(pid_t pid) {
   int process_status;

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h

 
  protected:
   /// The maximum number of arguments required to invoke a tool process.
   static const unsigned kArgVMax = 6;
 
   // Customizable by subclasses.
   virtual bool StartSymbolizerSubprocess();
   virtual bool ReadFromSymbolizer(char *buffer, uptr max_length);
+  // Return the environment to run the symbolizer in.
+  virtual char **GetEnvP() { return GetEnviron(); }
 
  private:
   virtual bool ReachedEndOfOutput(const char *buffer, uptr length) const {
     UNIMPLEMENTED();
   }
 
   /// Fill in an argv array to invoke the child process.
   virtual void GetArgV(const char *path_to_binary,

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

bool SymbolizerProcess::StartSymbolizerSubprocess() {
   }
 
   const char *argv[kArgVMax];
   GetArgV(path_, argv);
   pid_t pid;
 
   if (use_posix_spawn_) {
 #if SANITIZER_MAC
-    fd_t fd = internal_spawn(argv, &pid);
+    fd_t fd = internal_spawn(argv, const_cast<const char **>(GetEnvP()), &pid);
     if (fd == kInvalidFd) {
       Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
              errno);
       return false;
     }
 
     input_fd_ = fd;
     output_fd_ = fd;
 #else  // SANITIZER_MAC
     UNIMPLEMENTED();
 #endif  // SANITIZER_MAC
   } else {
     fd_t infd[2] = {}, outfd[2] = {};
     if (!CreateTwoHighNumberedPipes(infd, outfd)) {
       Report("WARNING: Can't create a socket pair to start "
              "external symbolizer (errno: %d)\n", errno);
       return false;
     }
 
-    pid = StartSubprocess(path_, argv, /* stdin */ outfd[0],
+    pid = StartSubprocess(path_, argv, GetEnvP(), /* stdin */ outfd[0],
                           /* stdout */ infd[1]);
     if (pid < 0) {
       internal_close(infd[0]);
       internal_close(outfd[1]);
       return false;
     }
 
     input_fd_ = infd[0];

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

 }
 
 char **GetEnviron() {
   // FIXME: Actually implement this function.
   return 0;
 }
 
 pid_t StartSubprocess(const char *program, const char *const argv[],
-                      fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) {
+                      const char *const envp[], fd_t stdin_fd, fd_t stdout_fd,
+                      fd_t stderr_fd) {
   // FIXME: implement on this platform
   // Should be implemented based on
   // SymbolizerProcess::StarAtSymbolizerSubprocess
   // from lib/sanitizer_common/sanitizer_symbolizer_win.cpp.
   return -1;
 }
 
 bool IsProcessRunning(pid_t pid) {

compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp

TEST(SanitizerCommon, StartSubprocessTest) {
   int pipe_fds[2];
   ASSERT_EQ(0, pipe(pipe_fds));
 #if SANITIZER_ANDROID
   const char *shell = "/system/bin/sh";
 #else
   const char *shell = "/bin/sh";
 #endif
   const char *argv[] = {shell, "-c", "echo -n 'hello'", (char *)NULL};
-  int pid = StartSubprocess(shell, argv,
+  int pid = StartSubprocess(shell, argv, GetEnviron(),
                             /* stdin */ kInvalidFd, /* stdout */ pipe_fds[1]);
   ASSERT_GT(pid, 0);
 
   // wait for process to finish.
   while (IsProcessRunning(pid)) {
   }
   ASSERT_FALSE(IsProcessRunning(pid));