Add internal_sysctl() used by FreeBSD, NetBSD, OpenBSD and MacOSX

[krytarowski]

Summary

Switch local sysctl(2) calls to internal_sysctl().

This is a preparation for introduction of interceptors for
the sysctl*() family of functions and switching internal_sysctl*()
to libc calls bypassing interceptors.

No functional change intended with this revision.

lib/sanitizer_common/sanitizer_linux.cc

void ReExec() {
   char **argv, **envp;
   const char *pathname = "/proc/self/exe";
 
 #if SANITIZER_NETBSD
   static const int name[] = {
     CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME,
   };
   char path[400];
-  size_t len;
+  uptr len;
 
   len = sizeof(path);
-  if (sysctl(name, ARRAY_SIZE(name), path, &len, NULL, 0) != -1)
+  if (internal_sysctl(name, ARRAY_SIZE(name), path, &len, NULL, 0) != -1)
     pathname = path;
 #elif SANITIZER_SOLARIS
   pathname = getexecname();
   CHECK_NE(pathname, NULL);
 #endif
 
   GetArgsAndEnv(&argv, &envp);
   uptr rv = internal_execve(pathname, argv, envp);

 int internal_fork() {
 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
 #else
   return internal_syscall(SYSCALL(fork));
 #endif
 }
 
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD
+int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
+                    uptr *oldlenp, const void *newp, uptr newlen) {
+  return sysctl(name, namelen, oldp, oldlenp, newp, newlen);
+}
+#endif
+
 #if SANITIZER_LINUX
 #define SA_RESTORER 0x04000000
 // Doesn't set sa_restorer if the caller did not set it, so use with caution
 //(see below).
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
   __sanitizer_kernel_sigaction_t k_act, k_oldact;
   internal_memset(&k_act, 0, sizeof(__sanitizer_kernel_sigaction_t));
   internal_memset(&k_oldact, 0, sizeof(__sanitizer_kernel_sigaction_t));

 #else
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
 #if SANITIZER_FREEBSD
   const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
 #else
   const int Mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
 #endif
   const char *default_module_name = "kern.proc.pathname";
-  size_t Size = buf_len;
-  bool IsErr = (sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0);
+  uptr Size = buf_len;
+  bool IsErr =
+      (internal_sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0);
   int readlink_error = IsErr ? errno : 0;
   uptr module_name_len = Size;
 #else
   const char *default_module_name = "/proc/self/exe";
   uptr module_name_len = internal_readlink(
       default_module_name, buf, buf_len);
   int readlink_error;
   bool IsErr = internal_iserror(module_name_len, &readlink_error);

 void MaybeReexec() {
   // No need to re-exec on Linux.
 }
 
 void CheckASLR() {
 #if SANITIZER_NETBSD
   int mib[3];
   int paxflags;
-  size_t len = sizeof(paxflags);
+  uptr len = sizeof(paxflags);
 
   mib[0] = CTL_PROC;
   mib[1] = internal_getpid();
   mib[2] = PROC_PID_PAXFLAGS;
 
-  if (UNLIKELY(sysctl(mib, 3, &paxflags, &len, NULL, 0) == -1)) {
+  if (UNLIKELY(internal_sysctl(mib, 3, &paxflags, &len, NULL, 0) == -1)) {
     Printf("sysctl failed\n");
     Die();
   }
 
   if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_ASLR)) {
     Printf("This sanitizer is not compatible with enabled ASLR\n");
     Die();
   }

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 }
 
 // sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used on most platforms as
 // they allocate memory.
 u32 GetNumberOfCPUs() {
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD
   u32 ncpu;
   int req[2];
-  size_t len = sizeof(ncpu);
+  uptr len = sizeof(ncpu);
   req[0] = CTL_HW;
   req[1] = HW_NCPU;
-  CHECK_EQ(sysctl(req, 2, &ncpu, &len, NULL, 0), 0);
+  CHECK_EQ(internal_sysctl(req, 2, &ncpu, &len, NULL, 0), 0);
   return ncpu;
 #elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
   // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't
   // exist in sched.h. That is the case for toolchains generated with older
   // NDKs.
   // This code doesn't work on AArch64 because internal_getdents makes use of
   // the 64bit getdents syscall, but cpu_set_t seems to always exist on AArch64.
   uptr fd = internal_open("/sys/devices/system/cpu", O_RDONLY | O_DIRECTORY);

lib/sanitizer_common/sanitizer_mac.cc

 extern "C" pid_t __fork(void) SANITIZER_WEAK_ATTRIBUTE;
 
 int internal_fork() {
   if (&__fork)
     return __fork();
   return fork();
 }
 
+int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
+                    uptr *oldlenp, const void *newp, uptr newlen) {
+  return sysctl(name, namelen, oldp, oldlenp, newp, newlen);
+}
+
 int internal_forkpty(int *amaster) {
   int master, slave;
   if (openpty(&master, &slave, nullptr, nullptr, nullptr) == -1) return -1;
   int pid = internal_fork();
   if (pid == -1) {
     close(master);
     close(slave);
     return -1;

 MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
 
 MacosVersion GetMacosVersionInternal() {
   int mib[2] = { CTL_KERN, KERN_OSRELEASE };
   char version[100];
   uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
   for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
   // Get the version length.
-  CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);
+  CHECK_NE(internal_sysctl(mib, 2, 0, &len, 0, 0), -1);
   CHECK_LT(len, maxlen);
-  CHECK_NE(sysctl(mib, 2, version, &len, 0, 0), -1);
+  CHECK_NE(internal_sysctl(mib, 2, version, &len, 0, 0), -1);
   switch (version[0]) {
     case '9': return MACOS_VERSION_LEOPARD;
     case '1': {
       switch (version[1]) {
         case '0': return MACOS_VERSION_SNOW_LEOPARD;
         case '1': return MACOS_VERSION_LION;
         case '2': return MACOS_VERSION_MOUNTAIN_LION;
         case '3': return MACOS_VERSION_MAVERICKS;

lib/sanitizer_common/sanitizer_openbsd.cc

 
 int internal_mprotect(void *addr, uptr length, int prot) {
   return mprotect(addr, length, prot);
 }
 
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
   // On OpenBSD we cannot get the full path
   struct kinfo_proc kp;
-  size_t kl;
+  uptr kl;
   const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
-  if (sysctl(Mib, ARRAY_SIZE(Mib), &kp, &kl, NULL, 0) != -1)
+  if (internal_sysctl(Mib, ARRAY_SIZE(Mib), &kp, &kl, NULL, 0) != -1)
     return internal_snprintf(buf,
                              (KI_MAXCOMLEN < buf_len ? KI_MAXCOMLEN : buf_len),
                              "%s", kp.p_comm);
   return (uptr)0;
 }
 
 static void GetArgsAndEnv(char ***argv, char ***envp) {
-  size_t nargv;
-  size_t nenv;
+  uptr nargv;
+  uptr nenv;
   int argvmib[4] = {CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV};
   int envmib[4] = {CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ENV};
-  if (sysctl(argvmib, 4, NULL, &nargv, NULL, 0) == -1) {
+  if (internal_sysctl(argvmib, 4, NULL, &nargv, NULL, 0) == -1) {
     Printf("sysctl KERN_PROC_NARGV failed\n");
     Die();
   }
-  if (sysctl(envmib, 4, NULL, &nenv, NULL, 0) == -1) {
+  if (internal_sysctl(envmib, 4, NULL, &nenv, NULL, 0) == -1) {
     Printf("sysctl KERN_PROC_NENV failed\n");
     Die();
   }
-  if (sysctl(argvmib, 4, &argv, &nargv, NULL, 0) == -1) {
+  if (internal_sysctl(argvmib, 4, &argv, &nargv, NULL, 0) == -1) {
     Printf("sysctl KERN_PROC_ARGV failed\n");
     Die();
   }
-  if (sysctl(envmib, 4, &envp, &nenv, NULL, 0) == -1) {
+  if (internal_sysctl(envmib, 4, &envp, &nenv, NULL, 0) == -1) {
     Printf("sysctl KERN_PROC_ENV failed\n");
     Die();
   }
 }
 
 char **GetArgv() {
   char **argv, **envp;
   GetArgsAndEnv(&argv, &envp);

lib/sanitizer_common/sanitizer_posix.h

 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);
 
 int internal_fork();
 int internal_forkpty(int *amaster);
 
+int internal_sysctl(const int *name, unsigned int namelen, 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.
 SANITIZER_WEAK_ATTRIBUTE
 int real_pthread_create(void *th, void *attr, void *(*callback)(void *),
                         void *param);
 SANITIZER_WEAK_ATTRIBUTE
 int real_pthread_join(void *th, void **ret);