[sanitizer_common] Use posix_spawn when starting a subprocess

[nspark]

Summary

When available, enables use of posix_spawn when starting a subprocess

Passes local testing (test/check-llvm-instrumentation) on Ubuntu 20.04

Fixes: https://github.com/google/sanitizers/issues/979

See also: https://reviews.llvm.org/D48451

[nspark]

Fix lint errors with clang-format on sanitizer_posix_libcdep.cpp

[nspark]

Squashed last two commits, since the earlier patch (pre clang-format) was not appearing in Phabricator.

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

 //===-- sanitizer_posix_libcdep.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries and implements libc-dependent POSIX-specific functions
 // from sanitizer_libc.h.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_POSIX
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_platform_limits_solaris.h"
 #include "sanitizer_posix.h"
 #include "sanitizer_procmaps.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
+#include <spawn.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #if SANITIZER_FREEBSD
 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
 // that, it was never implemented.  So just define it to zero.
 #undef MAP_NORESERVE
 #define MAP_NORESERVE 0
 #endif
 
 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
if (!stack_set) {
       Printf("Sanitizer: pre-allocated stack size is insufficient: "
              "%zu < %zu\n", stacksize, minstacksize);
       Printf("Sanitizer: pthread_create is likely to fail.\n");
     }
   }
 }
 #endif // !SANITIZER_GO
 
+// Android < P (r28) does not have posix_spawn
+#if !SANITIZER_ANDROID || __ANDROID_API__ >= 28
+pid_t StartSubprocess(const char *program, const char *const argv[],
+                      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) {
+      internal_close(stderr_fd);
+    }
+  });
+
+  int rc;
+  posix_spawn_file_actions_t file_actions;
+  if (0 != (rc = posix_spawn_file_actions_init(&file_actions))) {
+    Report("WARNING: posix_spawn_file_actions_init failed (rc %d)\n", rc);
+    return -1;
+  }
+
+  auto file_actions_destroyer =
+      at_scope_exit([&] { posix_spawn_file_actions_destroy(&file_actions); });
+
+  if (stdin_fd != kInvalidFd) {
+    rc =
+        posix_spawn_file_actions_adddup2(&file_actions, stdin_fd, STDIN_FILENO);
+    if (rc != 0) {
+      Report("WARNING: posix_spawn_file_actions_adddup2 failed (rc %d)\n", rc);
+      return -1;
+    }
+  }
+  if (stdout_fd != kInvalidFd) {
+    rc = posix_spawn_file_actions_adddup2(&file_actions, stdout_fd,
+                                          STDOUT_FILENO);
+    if (rc != 0) {
+      Report("WARNING: posix_spawn_file_actions_adddup2 failed (rc %d)\n", rc);
+      return -1;
+    }
+  }
+  if (stderr_fd != kInvalidFd) {
+    rc = posix_spawn_file_actions_adddup2(&file_actions, stderr_fd,
+                                          STDERR_FILENO);
+    if (rc != 0) {
+      Report("WARNING: posix_spawn_file_actions_adddup2 failed (rc %d)\n", rc);
+      return -1;
+    }
+  }
+
+  for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) {
+    errno = 0;
+    if ((fcntl(fd, F_GETFL) != -1) || (errno != EBADF)) {
+      rc = posix_spawn_file_actions_addclose(&file_actions, fd);
+      if (rc != 0) {
+        Report("WARNING: posix_spawn_file_actions_addclose failed (rc %d)\n",
+               rc);
+        return -1;
+      }
+    }
+  }
+
+  int pid = -1;
+  rc = posix_spawn(&pid, program, &file_actions, nullptr,
+                   const_cast<char *const *>(argv),
+                   const_cast<char *const *>(envp));
+  if (rc != 0) {
+    Report("WARNING: posix_spawn failed (rc %d)\n", rc);
+    return -1;
+  }
+
+  return pid;
+}
+#else
 pid_t StartSubprocess(const char *program, const char *const argv[],
                       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) {
if (pid == 0) {
 
     internal_execve(program, const_cast<char **>(&argv[0]),
                     const_cast<char *const *>(envp));
     internal__exit(1);
   }
 
   return pid;
 }
+#endif
 
 bool IsProcessRunning(pid_t pid) {
   int process_status;
   uptr waitpid_status = internal_waitpid(pid, &process_status, WNOHANG);
   int local_errno;
   if (internal_iserror(waitpid_status, &local_errno)) {
     VReport(1, "Waiting on the process failed (errno %d).\n", local_errno);
     return false;