[sanitizer] Intercept mcheck and mprobe on Linux

[m.ostapenko]

Summary

This patch addresses https://github.com/google/sanitizers/issues/804. Users can use mcheck and mprobe functions to verify heap state so we should intercept them to avoid breakage of valid code.

[ygribov]

lib/lsan/lsan_interceptors.cc

197 ↗

(On Diff #96900)

We don't seem to use enum at all (except for "return MCHECK_OK" which can be replaced with "return 0").

[m.ostapenko]

lib/lsan/lsan_interceptors.cc

197 ↗

(On Diff #96900)

Ok, if you think that it would be cleaner to just use 0 here I don't mind.

[m.ostapenko]

Remove enum.

[alekseyshl]

What about mcheck_pedantic and mcheck_check_all?

[m.ostapenko]

In D32589#739737, @alekseyshl wrote:

What about mcheck_pedantic and mcheck_check_all?

Right, we need mcheck_pedantic as well. I'm not sure about mcheck_check_all since it checks all chunks allocated by Glibc and this is probably fine. Should we add it for consistency?

[m.ostapenko]

Add mcheck_pedantic.

[alekseyshl]

From man, "The mcheck_pedantic() and mcheck_check_all() functions are available since glibc 2.2. The mcheck() and mprobe() functions are present since at least glibc 2.0". What about systems < 2.0? I guess, __GLIBC_PREREQ is required here.

[eugenis]

lib/sanitizer_common/sanitizer_common_interceptors.inc

6157 ↗

(On Diff #96958)

I think INIT_MCHECK_MPROBE is simply unnecessary if we don't use REAL(mcheck). Compare with asan_malloc_linux.cc.

And we don't need to care about glibc version then.

[m.ostapenko]

Remove INIT_MCHECK_MPROBE.

[alekseyshl]

lib/sanitizer_common/sanitizer_common_interceptors.inc

6157 ↗

(On Diff #96958)

Here, yes, but the test still need the version check for check_pedantic, right? We had this problem with getauxval, there're bots running on glibc 2.13.

[eugenis]

lib/sanitizer_common/sanitizer_common_interceptors.inc

6157 ↗

(On Diff #96958)

Yes.

[m.ostapenko]

Add guards against old Glibc versions to testcase.

[eugenis]

LGTM

compiler-rt/trunk/lib/lsan/lsan_interceptors.cc

 
 #if SANITIZER_INTERCEPT_CFREE
 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
 #define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
 #else
 #define LSAN_MAYBE_INTERCEPT_CFREE
 #endif // SANITIZER_INTERCEPT_CFREE
 
+#if SANITIZER_INTERCEPT_MCHECK_MPROBE
+INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
+  return 0;
+}
+
+INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
+  return 0;
+}
+
+INTERCEPTOR(int, mprobe, void *ptr) {
+  return 0;
+}
+#endif // SANITIZER_INTERCEPT_MCHECK_MPROBE
+
 #define OPERATOR_NEW_BODY                              \
   ENSURE_LSAN_INITED;                                  \
   GET_STACK_TRACE_MALLOC;                              \
   return Allocate(stack, size, 1, kAlwaysClearMemory);
 
 INTERCEPTOR_ATTRIBUTE
 void *operator new(size_t size) { OPERATOR_NEW_BODY; }
 INTERCEPTOR_ATTRIBUTE

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common_interceptors.inc

INTERCEPTOR(int, getloadavg, double *loadavg, int nelem) {
   return res;
 }
 #define INIT_GETLOADAVG                      \
   COMMON_INTERCEPT_FUNCTION(getloadavg);
 #else
 #define INIT_GETLOADAVG
 #endif
 
+#if SANITIZER_INTERCEPT_MCHECK_MPROBE
+INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
+  return 0;
+}
+
+INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
+  return 0;
+}
+
+INTERCEPTOR(int, mprobe, void *ptr) {
+  return 0;
+}
+#endif
+
 static void InitializeCommonInterceptors() {
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new((void *)&metadata_mem) MetadataHashMap();
 
   INIT_TEXTDOMAIN;
   INIT_STRLEN;
   INIT_STRNLEN;
   INIT_STRCMP;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_interceptors.h

#define SANITIZER_INTERCEPT_GETLOADAVG \
   SI_LINUX_NOT_ANDROID || SI_MAC || SI_FREEBSD
 
 #define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO (!SI_FREEBSD && !SI_MAC)
 #define SANITIZER_INTERCEPT_MEMALIGN (!SI_FREEBSD && !SI_MAC)
 #define SANITIZER_INTERCEPT_PVALLOC (!SI_FREEBSD && !SI_MAC)
 #define SANITIZER_INTERCEPT_CFREE (!SI_FREEBSD && !SI_MAC)
 #define SANITIZER_INTERCEPT_ALIGNED_ALLOC (!SI_MAC)
 #define SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE (!SI_MAC)
+#define SANITIZER_INTERCEPT_MCHECK_MPROBE SI_LINUX_NOT_ANDROID
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

compiler-rt/trunk/test/sanitizer_common/TestCases/Linux/mprobe.cc

+// RUN: %clangxx %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: android
+
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 2)
+#include <mcheck.h>
+#else
+#define MCHECK_OK 0
+extern "C" int mcheck(void (*abortfunc)(int mstatus));
+extern "C" int mcheck_pedantic(void (*abortfunc)(int mstatus));
+extern "C" int mprobe(void *ptr);
+#endif
+
+void check_heap() {
+  void *p = malloc(1000);
+  int res = mprobe(p);
+  if (res == MCHECK_OK)
+    printf("Success!\n");
+  free(p);
+}
+
+int main(int argc, char *argv[]) {
+  void *p;
+  if (mcheck(NULL) != 0) {
+    fprintf(stderr, "mcheck() failed\n");
+    exit(EXIT_FAILURE);
+  }
+
+  check_heap();
+  // CHECK: Success!
+
+  if (mcheck_pedantic(NULL) != 0) {
+    fprintf(stderr, "mcheck_pedantic() failed\n");
+    exit(EXIT_FAILURE);
+  }
+
+  check_heap();
+  // CHECK: Success!
+
+  return 0;
+}