[sanitizer] Support running without fd 0,1,2.

[eugenis]

Summary

Support running with no open file descriptors (as may happen to
"init" process on linux).

• Remove a check that writing to stderr succeeds.
• When opening a file (ex. for log_path option), dup the new fd out of

[0, 2] range to avoid confusing the program.

[eugenis]

Gave AdjustFd a more descriptive name.

[pcc]

LGTM

lib/sanitizer_common/sanitizer_linux.cc

 
 uptr internal_filesize(fd_t fd) {
   struct stat st;
   if (internal_fstat(fd, &st))
     return -1;
   return (uptr)st.st_size;
 }
 
+uptr internal_dup(int oldfd) {
+  return internal_syscall(SYSCALL(dup), oldfd);
+}
+
 uptr internal_dup2(int oldfd, int newfd) {
 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
 #else
   return internal_syscall(SYSCALL(dup2), oldfd, newfd);
 #endif
 }
 

lib/sanitizer_common/sanitizer_mac.cc

 
 uptr internal_filesize(fd_t fd) {
   struct stat st;
   if (internal_fstat(fd, &st))
     return -1;
   return (uptr)st.st_size;
 }
 
+uptr internal_dup(int oldfd) {
+  return dup(oldfd);
+}
+
 uptr internal_dup2(int oldfd, int newfd) {
   return dup2(oldfd, newfd);
 }
 
 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
   return readlink(path, buf, bufsize);
 }
 

lib/sanitizer_common/sanitizer_netbsd.cc

 
 uptr internal_filesize(fd_t fd) {
   struct stat st;
   if (internal_fstat(fd, &st))
     return -1;
   return (uptr)st.st_size;
 }
 
+uptr internal_dup(int oldfd) {
+  DEFINE__REAL(int, dup, int a);
+  return _REAL(dup, oldfd);
+}
+
 uptr internal_dup2(int oldfd, int newfd) {
   DEFINE__REAL(int, dup2, int a, int b);
   return _REAL(dup2, oldfd, newfd);
 }
 
 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
   CHECK(&_sys_readlink);
   return (uptr)_sys_readlink(path, buf, bufsize);

lib/sanitizer_common/sanitizer_posix.h

 uptr internal_munmap(void *addr, uptr length);
 int internal_mprotect(void *addr, uptr length, int prot);
 
 // OS
 uptr internal_filesize(fd_t fd);  // -1 on error.
 uptr internal_stat(const char *path, void *buf);
 uptr internal_lstat(const char *path, void *buf);
 uptr internal_fstat(fd_t fd, void *buf);
+uptr internal_dup(int oldfd);
 uptr internal_dup2(int oldfd, int newfd);
 uptr internal_readlink(const char *path, char *buf, uptr bufsize);
 uptr internal_unlink(const char *path);
 uptr internal_rename(const char *oldpath, const char *newpath);
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence);
 
 uptr internal_ptrace(int request, int pid, void *addr, void *data);
 uptr internal_waitpid(int pid, int *status, int options);

 void internal_sigemptyset(__sanitizer_sigset_t *set);
 bool internal_sigismember(__sanitizer_sigset_t *set, int signum);
 
 uptr internal_execve(const char *filename, char *const argv[],
                      char *const envp[]);
 
 bool IsStateDetached(int state);
 
+// Move the fd out of {0, 1, 2} range.
+fd_t ReserveStandardFds(fd_t fd);
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_POSIX_H

lib/sanitizer_common/sanitizer_posix.cc

fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {
   switch (mode) {
     case RdOnly: flags = O_RDONLY; break;
     case WrOnly: flags = O_WRONLY | O_CREAT | O_TRUNC; break;
     case RdWr: flags = O_RDWR | O_CREAT; break;
   }
   fd_t res = internal_open(filename, flags, 0660);
   if (internal_iserror(res, errno_p))
     return kInvalidFd;
-  return res;
+  return ReserveStandardFds(res);
 }
 
 void CloseFile(fd_t fd) {
   internal_close(fd);
 }
 
 bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
                   error_t *error_p) {

 }
 
 bool IsAbsolutePath(const char *path) {
   return path != nullptr && IsPathSeparator(path[0]);
 }
 
 void ReportFile::Write(const char *buffer, uptr length) {
   SpinMutexLock l(mu);
-  static const char *kWriteError =
-      "ReportFile::Write() can't output requested buffer!\n";
   ReopenIfNecessary();
-  if (length != internal_write(fd, buffer, length)) {
-    internal_write(fd, kWriteError, internal_strlen(kWriteError));
-    Die();
-  }
+  internal_write(fd, buffer, length);
 }
 
 bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end) {
   MemoryMappingLayout proc_maps(/*cache_enabled*/false);
   InternalScopedString buff(kMaxPathLength);
   MemoryMappedSegment segment(buff.data(), kMaxPathLength);
   while (proc_maps.Next(&segment)) {
     if (segment.IsExecutable() &&
switch (GetType()) {
     case SIGSEGV:
       return "SEGV";
     case SIGBUS:
       return "BUS";
   }
   return "UNKNOWN SIGNAL";
 }
 
+fd_t ReserveStandardFds(fd_t fd) {
+  CHECK_GE(fd, 0);
+  if (fd > 2)
+    return fd;
+  bool used[3] = {false, false, false};
+  while (fd <= 2) {
+    used[fd] = true;
+    fd = internal_dup(fd);
+  }
+  for (int i = 0; i <= 2; ++i)
+    if (used[i])
+      internal_close(i);
+  return fd;
+}
+
 } // namespace __sanitizer
 
 #endif // SANITIZER_POSIX

lib/sanitizer_common/sanitizer_rtems.cc

fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {
   switch (mode) {
     case RdOnly: flags = O_RDONLY; break;
     case WrOnly: flags = O_WRONLY | O_CREAT | O_TRUNC; break;
     case RdWr: flags = O_RDWR | O_CREAT; break;
   }
   fd_t res = open(filename, flags, 0660);
   if (internal_iserror(res, errno_p))
     return kInvalidFd;
-  return res;
+  return ReserveStandardFds(res);
 }
 
 void CloseFile(fd_t fd) {
   close(fd);
 }
 
 bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
                   error_t *error_p) {

lib/sanitizer_common/sanitizer_solaris.cc

uptr internal_open(const char *filename, int flags) {
   return _REAL64(open)(filename, flags);
 }
 
 uptr internal_open(const char *filename, int flags, u32 mode) {
   return _REAL64(open)(filename, flags, mode);
 }
 
 uptr OpenFile(const char *filename, bool write) {
-  return internal_open(filename,
-      write ? O_WRONLY | O_CREAT : O_RDONLY, 0660);
+  return ReserveStandardFds(
+      internal_open(filename, write ? O_WRONLY | O_CREAT : O_RDONLY, 0660));
 }
 
 DECLARE__REAL_AND_INTERNAL(uptr, read, fd_t fd, void *buf, uptr count) {
   return _REAL(read)(fd, buf, count);
 }
 
 DECLARE__REAL_AND_INTERNAL(uptr, write, fd_t fd, const void *buf, uptr count) {
   return _REAL(write)(fd, buf, count);

test/asan/TestCases/Posix/no-fd.cc

+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=debug=1,verbosity=2 %run %t 2>&1 | FileCheck %s
+
+// Test ASan initialization
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void parent(int argc, char **argv) {
+  fprintf(stderr, "hello\n");
+  // CHECK: hello
+  close(0);
+  close(1);
+  dup2(2, 3);
+  close(2);
+  char *const newargv[] = {argv[0], (char *)"x", nullptr};
+  execv(argv[0], newargv);
+  perror("execve");
+  exit(1);
+}
+
+void child() {
+  assert(dup(3) == 0);
+  assert(dup(3) == 1);
+  assert(dup(3) == 2);
+  fprintf(stderr, "world\n");
+  // CHECK: world
+}
+
+int main(int argc, char **argv) {
+  if (argc == 1) {
+    parent(argc, argv);
+  } else {
+    child();
+  }
+}