Enhance support for NetBSD in SafeStack

[krytarowski]

Summary

Always try to detect and call internal or real libc symbols instead of
locally installed interceptors.

This covers:

• GetTid()
• TgKill()
• Mmap()
• Munmap()
• Mprotect()

This cherry-picks code from sanitizer_common/sanitizer_netbsd.cc.

[vitalybuka]

lib/safestack/safestack_platform.h

35

Why do we need weak here?

45

maybe merge this and "#if SANITIZER_NETBSD" above?

83

Why do you rely need DEFINE__REAL? I just copied TgKill for other platforms. Not sure that syscalls are necessary.
mmap/protect is a different story, see below

114

We don't want to hit interpector here, because it can be called called from preinit_array.
DEFINE__REAL will avoid interceptors, however dlsym from preinit_array may crash as it can to try to allocate memory.
So we use syscall on linux.
sanitizer_common/sanitizer_netbsd still had such problem, so I didn't bother to copy DEFINE_REAL.

[krytarowski]

lib/safestack/safestack_platform.h

35

It was needed for sanitizer common but it seems to work fine for safestack without the weak attribute.

83

For LWP functions this is optional, for consistence I prefer to keep it.

114

NetBSD does not use/support preinit_array, except on archs that demand it (amd64/i386 aren't in the set).

How does it crash with allocating the memory? By calling real malloc? Dynamic loader on NetBSD uses its internal copy of xmalloc() for allocations.

According to my quick testing with gdb(1) and an example program, dlsym(3) does not allocate anything through xmalloc() (at least for RTLD_SELF).

[vitalybuka]

lib/safestack/safestack_platform.h

96

This SFS_CHECK (like the on in sanitizer_common) is not useful with or without weak
It will crash anyway with obvious stack on null pointer.

114

Yes, on linux it crashes with malloc which can be not initialized (if its non standard allocator)

[krytarowski]

lib/safestack/safestack_platform.h

45

I prefer to keep this function namespaced.

114

So there is no problem on NetBSD, at least in the current circumstances nothing is known to be faulty.

lib/safestack/safestack_platform.h

 //===-- safestack_platform.h ----------------------------------------------===//
 //
 // 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 implements platform specific parts of SafeStack runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SAFESTACK_PLATFORM_H
 #define SAFESTACK_PLATFORM_H
 
+#include "safestack_util.h"
 #include "sanitizer_common/sanitizer_platform.h"
 
+#include <dlfcn.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #if !(SANITIZER_NETBSD || SANITIZER_FREEBSD || SANITIZER_LINUX)
 #error "Support for your platform has not been implemented"
 #endif
 
 #if SANITIZER_NETBSD
 #include <lwp.h>
+
+extern "C" void *__mmap(void *, size_t, int, int, int, int, off_t);
 #endif
 
 #if SANITIZER_FREEBSD
 #include <sys/thr.h>
 #endif
 
 namespace safestack {
 
+#if SANITIZER_NETBSD
+static void *GetRealLibcAddress(const char *symbol) {
+  void *real = dlsym(RTLD_NEXT, symbol);
+  if (!real)
+    real = dlsym(RTLD_DEFAULT, symbol);
+  if (!real) {
+    fprintf(stderr, "safestack GetRealLibcAddress failed for symbol=%s",
+            symbol);
+    abort();
+  }
+  return real;
+}
+
+#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); \
+  }                                                                    \
+  SFS_CHECK(real_##func);
+#endif
+
 using ThreadId = uint64_t;
 
 inline ThreadId GetTid() {
 #if SANITIZER_NETBSD
-  return _lwp_self();
+  DEFINE__REAL(int, _lwp_self);
+  return _REAL(_lwp_self);
 #elif SANITIZER_FREEBSD
   long Tid;
   thr_self(&Tid);
   return Tid;
 #else
   return syscall(SYS_gettid);
 #endif
 }
 
 inline int TgKill(pid_t pid, ThreadId tid, int sig) {
 #if SANITIZER_NETBSD
+  DEFINE__REAL(int, _lwp_kill, int a, int b);
   (void)pid;
-  return _lwp_kill(tid, sig);
+  return _REAL(_lwp_kill, tid, sig);
 #elif SANITIZER_FREEBSD
   return syscall(SYS_thr_kill2, pid, tid, sig);
 #else
   return syscall(SYS_tgkill, pid, tid, sig);
 #endif
 }
 
 inline void *Mmap(void *addr, size_t length, int prot, int flags, int fd,
                   off_t offset) {
 #if SANITIZER_NETBSD
-  return mmap(addr, length, prot, flags, fd, offset);
+  return __mmap(addr, length, prot, flags, fd, 0, offset);
 #elif defined(__x86_64__) && (SANITIZER_FREEBSD)
   return (void *)__syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
 #else
   return (void *)syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
 #endif
 }
 
 inline int Munmap(void *addr, size_t length) {
 #if SANITIZER_NETBSD
-  return munmap(addr, length);
+  DEFINE__REAL(int, munmap, void *a, size_t b);
+  return _REAL(munmap, addr, length);
 #else
   return syscall(SYS_munmap, addr, length);
 #endif
 }
 
 inline int Mprotect(void *addr, size_t length, int prot) {
 #if SANITIZER_NETBSD
-  return mprotect(addr, length, prot);
+  DEFINE__REAL(int, mprotect, void *a, size_t b, int c);
+  return _REAL(mprotect, addr, length, prot);
 #else
   return syscall(SYS_mprotect, addr, length, prot);
 #endif
 }
 
 }  // namespace safestack
 
 #endif  // SAFESTACK_PLATFORM_H