[msan] Intercept __getrlimit.

[eugenis]

Summary

This interceptor is useful on its own, but the main purpose of this
change is to intercept libpthread initialization on linux/glibc in
order to run __msan_init before any .preinit_array constructors.

We used to trigger on pthread_initialize_minimal -> getrlimit(), but
that call has changed to __getrlimit at some point.

[vitalybuka]

compiler-rt/lib/msan/msan_interceptors.cpp

770 ↗

(On Diff #222263)

why not sanitizer_common?
looks like races and use-after free are possible here

[vitalybuka]

Oh, because other are already there.
Consider to move them into common in a separate patch.

compiler-rt/trunk/lib/msan/msan_interceptors.cpp

if (res)
     __msan_unpoison(s, REAL(strlen)(s) + 1);
   return res;
 }
 #define MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED INTERCEPT_FUNCTION(fgets_unlocked)
 #else
 #define MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED
 #endif
 
+#define INTERCEPTOR_GETRLIMIT_BODY(func, resource, rlim)  \
+  if (msan_init_is_running)                               \
+    return REAL(getrlimit)(resource, rlim);               \
+  ENSURE_MSAN_INITED();                                   \
+  int res = REAL(func)(resource, rlim);                   \
+  if (!res)                                               \
+    __msan_unpoison(rlim, __sanitizer::struct_rlimit_sz); \
+  return res
+
 INTERCEPTOR(int, getrlimit, int resource, void *rlim) {
-  if (msan_init_is_running)
-    return REAL(getrlimit)(resource, rlim);
-  ENSURE_MSAN_INITED();
-  int res = REAL(getrlimit)(resource, rlim);
-  if (!res)
-    __msan_unpoison(rlim, __sanitizer::struct_rlimit_sz);
-  return res;
+  INTERCEPTOR_GETRLIMIT_BODY(getrlimit, resource, rlim);
 }
 
 #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
+INTERCEPTOR(int, __getrlimit, int resource, void *rlim) {
+  INTERCEPTOR_GETRLIMIT_BODY(__getrlimit, resource, rlim);
+}
+
 INTERCEPTOR(int, getrlimit64, int resource, void *rlim) {
   if (msan_init_is_running) return REAL(getrlimit64)(resource, rlim);
   ENSURE_MSAN_INITED();
   int res = REAL(getrlimit64)(resource, rlim);
   if (!res) __msan_unpoison(rlim, __sanitizer::struct_rlimit64_sz);
   return res;
 }
 
if (msan_init_is_running)
     return REAL(prlimit64)(pid, resource, new_rlimit, old_rlimit);
   ENSURE_MSAN_INITED();
   CHECK_UNPOISONED(new_rlimit, __sanitizer::struct_rlimit64_sz);
   int res = REAL(prlimit64)(pid, resource, new_rlimit, old_rlimit);
   if (!res) __msan_unpoison(old_rlimit, __sanitizer::struct_rlimit64_sz);
   return res;
 }
 
+#define MSAN_MAYBE_INTERCEPT___GETRLIMIT INTERCEPT_FUNCTION(__getrlimit)
 #define MSAN_MAYBE_INTERCEPT_GETRLIMIT64 INTERCEPT_FUNCTION(getrlimit64)
 #define MSAN_MAYBE_INTERCEPT_PRLIMIT INTERCEPT_FUNCTION(prlimit)
 #define MSAN_MAYBE_INTERCEPT_PRLIMIT64 INTERCEPT_FUNCTION(prlimit64)
 #else
+#define MSAN_MAYBE_INTERCEPT___GETRLIMIT
 #define MSAN_MAYBE_INTERCEPT_GETRLIMIT64
 #define MSAN_MAYBE_INTERCEPT_PRLIMIT
 #define MSAN_MAYBE_INTERCEPT_PRLIMIT64
 #endif
 
 #if SANITIZER_FREEBSD
 // FreeBSD's <sys/utsname.h> define uname() as
 // static __inline int uname(struct utsname *name) {
#endif
   MSAN_INTERCEPT_FSTATAT;
   MSAN_MAYBE_INTERCEPT___FXSTAT64;
   MSAN_MAYBE_INTERCEPT___FXSTATAT64;
   INTERCEPT_FUNCTION(pipe);
   INTERCEPT_FUNCTION(pipe2);
   INTERCEPT_FUNCTION(socketpair);
   MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED;
   INTERCEPT_FUNCTION(getrlimit);
+  MSAN_MAYBE_INTERCEPT___GETRLIMIT;
   MSAN_MAYBE_INTERCEPT_GETRLIMIT64;
   MSAN_MAYBE_INTERCEPT_PRLIMIT;
   MSAN_MAYBE_INTERCEPT_PRLIMIT64;
   MSAN_INTERCEPT_UNAME;
   INTERCEPT_FUNCTION(gethostname);
   MSAN_MAYBE_INTERCEPT_EPOLL_WAIT;
   MSAN_MAYBE_INTERCEPT_EPOLL_PWAIT;
   INTERCEPT_FUNCTION(dladdr);

compiler-rt/trunk/test/msan/preinit_array.cpp

+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <sanitizer/msan_interface.h>
+
+volatile int global;
+static void pre_ctor() {
+  volatile int local;
+  global = 42;
+  local = 42;
+}
+
+__attribute__((section(".preinit_array"), used)) void(*__local_pre_ctor)(void) = pre_ctor;
+
+int main(void) {
+  return 0;
+}