[compiler-rt][ASAN] Allow mlock, munlock

[jump_ripatel]

Summary

Removes interceptors for mlock(), munlock().

On recent Linux kernels, calling mlock(2) while ASan is active does not pose any problem. mlockall(2) remains problematic.

The sanitizers currently also don't block mlock2(2).

[jump_ripatel]

Fixed weird clang-format output

compiler-rt/lib/asan/tests/asan_test.cpp

TEST(AddressSanitizer, DISABLED_StressStackReuseAndExceptionsTest) {
   }
 }
 #endif
 
 #if !defined(_WIN32)
 TEST(AddressSanitizer, MlockTest) {
 #if !defined(__ANDROID__) || __ANDROID_API__ >= 17
   EXPECT_EQ(0, mlockall(MCL_CURRENT));
-#endif
-  EXPECT_EQ(0, mlock((void*)0x12345, 0x5678));
-#if !defined(__ANDROID__) || __ANDROID_API__ >= 17
+#  endif
+#  if !defined(__ANDROID__) || __ANDROID_API__ >= 17
   EXPECT_EQ(0, munlockall());
-#endif
-  EXPECT_EQ(0, munlock((void*)0x987, 0x654));
+#  endif
 }
 #endif
 
 struct LargeStruct {
   int foo[100];
 };
 
 // Test for bug http://llvm.org/bugs/show_bug.cgi?id=11763.

compiler-rt/lib/msan/tests/msan_test.cpp

TEST(MemorySanitizerAllocator, get_allocated_size_and_ownership) {
   EXPECT_FALSE(__sanitizer_get_ownership(array));
   EXPECT_EQ(0U, __sanitizer_get_allocated_size(array));
 
   delete int_ptr;
 }
 
 TEST(MemorySanitizer, MlockTest) {
   EXPECT_EQ(0, mlockall(MCL_CURRENT));
-  EXPECT_EQ(0, mlock((void*)0x12345, 0x5678));
   EXPECT_EQ(0, munlockall());
-  EXPECT_EQ(0, munlock((void*)0x987, 0x654));
 }
 
 // Test that LargeAllocator unpoisons memory before releasing it to the OS.
 TEST(MemorySanitizer, LargeAllocatorUnpoisonsOnFree) {
   void *p = malloc(1024 * 1024);
   free(p);
 
   typedef void *(*mmap_fn)(void *, size_t, int, int, int, off_t);

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 #define INIT_TIMERFD                          \
   COMMON_INTERCEPT_FUNCTION(timerfd_settime); \
   COMMON_INTERCEPT_FUNCTION(timerfd_gettime);
 #else
 #define INIT_TIMERFD
 #endif
 
 #if SANITIZER_INTERCEPT_MLOCKX
-// Linux kernel has a bug that leads to kernel deadlock if a process
-// maps TBs of memory and then calls mlock().
+// Sanitizers might map a large amount of unbacked memory.
+// mlockall would exhaust all available system resources.
 static void MlockIsUnsupported() {
   static atomic_uint8_t printed;
   if (atomic_exchange(&printed, 1, memory_order_relaxed))
     return;
-  VPrintf(1, "%s ignores mlock/mlockall/munlock/munlockall\n",
+  VPrintf(1, "%s ignores mlockall/munlockall\n",
           SanitizerToolName);
 }
 
-INTERCEPTOR(int, mlock, const void *addr, uptr len) {
-  MlockIsUnsupported();
-  return 0;
-}
-
-INTERCEPTOR(int, munlock, const void *addr, uptr len) {
-  MlockIsUnsupported();
-  return 0;
-}
-
 INTERCEPTOR(int, mlockall, int flags) {
   MlockIsUnsupported();
   return 0;
 }
 
 INTERCEPTOR(int, munlockall, void) {
   MlockIsUnsupported();
   return 0;
 }
 
 #define INIT_MLOCKX                                                            \
-  COMMON_INTERCEPT_FUNCTION(mlock);                                            \
-  COMMON_INTERCEPT_FUNCTION(munlock);                                          \
   COMMON_INTERCEPT_FUNCTION(mlockall);                                         \
   COMMON_INTERCEPT_FUNCTION(munlockall);
 
 #else
 #define INIT_MLOCKX
 #endif  // SANITIZER_INTERCEPT_MLOCKX
 
 #if SANITIZER_INTERCEPT_FOPENCOOKIE

compiler-rt/test/sanitizer_common/TestCases/Linux/mlock_test.cpp

 // RUN: %clang  %s -o %t && %run %t
 // XFAIL: ubsan,lsan
 
 #include <assert.h>
 #include <sys/mman.h>
 
 int main() {
   assert(0 == mlockall(MCL_CURRENT));
-  assert(0 == mlock((void *)0x12345, 0x5678));
   assert(0 == munlockall());
-  assert(0 == munlock((void *)0x987, 0x654));
 }