Introduce internal_sysctlbyname in place of sysctlbyname

[krytarowski]

Summary

This change will allow to install sysctlbyname() interceptors
more easily in sanitizers.

[vitalybuka]

lib/sanitizer_common/sanitizer_netbsd.cc

96

I don't see how DEFINE_INTERNAL is helpful

the following looks better:
uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd, OFF_T offset) {
}

[krytarowski]

lib/sanitizer_common/sanitizer_netbsd.cc

96

I will unroll it in a new revision.

lib/sanitizer_common/sanitizer_linux.cc

 #if !SANITIZER_OPENBSD
 static void GetArgsAndEnv(char ***argv, char ***envp) {
 #if SANITIZER_FREEBSD
   // On FreeBSD, retrieving the argument and environment arrays is done via the
   // kern.ps_strings sysctl, which returns a pointer to a structure containing
   // this information. See also <sys/exec.h>.
   ps_strings *pss;
   size_t sz = sizeof(pss);
-  if (sysctlbyname("kern.ps_strings", &pss, &sz, NULL, 0) == -1) {
+  if (internal_sysctlbyname("kern.ps_strings", &pss, &sz, NULL, 0) == -1) {
     Printf("sysctl kern.ps_strings failed\n");
     Die();
   }
   *argv = pss->ps_argvstr;
   *envp = pss->ps_envstr;
 #elif SANITIZER_NETBSD
   *argv = __ps_strings->ps_argvstr;
   *envp = __ps_strings->ps_envstr;
int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                     uptr *oldlenp, const void *newp, uptr newlen) {
 #if SANITIZER_OPENBSD
   return sysctl(name, namelen, oldp, (size_t *)oldlenp, (void *)newp,
                 (size_t)newlen);
 #else
   return sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
 #endif
 }
+
+int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
+                          const void *newp, uptr newlen) {
+#if SANITIZER_OPENBSD
+  return sysctlbyname(sname, oldp, (size_t *)oldlenp, (void *)newp,
+                      (size_t)newlen);
+#else
+  return sysctlbyname(sname, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
+#endif
+}
 #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;

lib/sanitizer_common/sanitizer_mac.cc

 }
 
 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                     uptr *oldlenp, const void *newp, uptr newlen) {
   return sysctl(const_cast<int *>(name), namelen, oldp, (size_t *)oldlenp,
                 const_cast<void *>(newp), (size_t)newlen);
 }
 
+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);
+}
+
 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;

lib/sanitizer_common/sanitizer_netbsd.cc

 
 #define _REAL(func, ...) real##_##func(__VA_ARGS__)
 #define DEFINE__REAL(ret_type, func, ...)                              \
   static ret_type (*real_##func)(__VA_ARGS__) = NULL;                  \
   if (!real_##func) {                                                  \
     real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
   }                                                                    \
   CHECK(real_##func);
 #define DEFINE_INTERNAL(ret_type, func, ...) \
   ret_type internal_##func(__VA_ARGS__)
 
 // --------------- sanitizer_libc.h
 DEFINE_INTERNAL(uptr, mmap, void *addr, uptr length, int prot, int flags,
                 int fd, OFF_T offset) {
   CHECK(&__mmap);
   return (uptr)__mmap(addr, length, prot, flags, fd, 0, offset);
 }

 }
 
 DEFINE_INTERNAL(int, sysctl, const int *name, unsigned int namelen, void *oldp,
                 uptr *oldlenp, const void *newp, uptr newlen) {
   CHECK(&__sysctl);
   return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
 }
 
+DEFINE_INTERNAL(int, sysctlbyname, const char *sname, void *oldp, uptr *oldlenp,
+                const void *newp, uptr newlen) {
+  DEFINE__REAL(int, sysctlbyname, const char *a, void *b, size_t *c,
+               const void *d, size_t e);
+  return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
+               (size_t)newlen);
+}
+
 DEFINE_INTERNAL(uptr, sigprocmask, int how, __sanitizer_sigset_t *set,
                 __sanitizer_sigset_t *oldset) {
   CHECK(&_sys___sigprocmask14);
   return _sys___sigprocmask14(how, set, oldset);
 }
 
 DEFINE_INTERNAL(void, sigfillset, __sanitizer_sigset_t *set) {
   DEFINE__REAL(int, __sigfillset14, const void *a);

lib/sanitizer_common/sanitizer_posix.h

 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);
+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.
 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);

lib/xray/xray_x86_64.cc

 #include "cpuid.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_posix.h"
 #include "xray_defs.h"
 #include "xray_interface_internal.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_MAC
 #include <sys/types.h>
 #if SANITIZER_OPENBSD
 #include <sys/time.h>
 #include <machine/cpu.h>
uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
   return TSCFrequency == -1 ? 0 : static_cast<uint64_t>(TSCFrequency);
 }
 #elif SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_MAC
 uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
     long long TSCFrequency = -1;
     size_t tscfreqsz = sizeof(TSCFrequency);
 #if SANITIZER_OPENBSD
     int Mib[2] = { CTL_MACHDEP, CPU_TSCFREQ };
-    if (sysctl(Mib, 2, &TSCFrequency, &tscfreqsz, NULL, 0) != -1) {
+    if (internal_sysctl(Mib, 2, &TSCFrequency, &tscfreqsz, NULL, 0) != -1) {
 #elif SANITIZER_MAC
-    if (sysctlbyname("machdep.tsc.frequency", &TSCFrequency, &tscfreqsz,
-        NULL, 0) != -1 ) {
+    if (internal_sysctlbyname("machdep.tsc.frequency", &TSCFrequency,
+                              &tscfreqsz, NULL, 0) != -1) {
 
 #else
-    if (sysctlbyname("machdep.tsc_freq", &TSCFrequency, &tscfreqsz,
+    if (internal_sysctlbyname("machdep.tsc_freq", &TSCFrequency, &tscfreqsz,
                               NULL, 0) != -1) {
 #endif
         return static_cast<uint64_t>(TSCFrequency);
     } else {
       Report("Unable to determine CPU frequency for TSC accounting.\n");
     }
 
     return 0;
 }