[compiler-rt] [TSan] Enable TSan for AArch64/42-bit VMA

[zatrazz]

Summary

This patch adds support for tsan on aarch64-linux with 42-bit VMA
(current default config for 64K pagesize kernels). The support is
enabled by defining the SANITIZER_AARCH64_VMA to 42 at build time
for both clang/llvm and compiler-rt. The default VMA is 39 bits.

The ignore_lib{0,1,3}.cc is now disable for aarch64 (although for newer
kernels they do pass) until the all the buildbots have the fix.

[dvyukov]

LGTM when you fix nits in the test

test/tsan/test.h

46

s/require/requires/

48

s/NULL/0/ for consistency with the rest of tsan code

53

in the comment you say 39, 42 and 48, but here you handle only 39 and 42
do

else {
  fprintf(stderr, "unsupported vma: %ul\n", vma);
  exit(1);
}

better than crash with format==0

[zatrazz]

test/tsan/test.h

46

I will fix it.

48

I will change it.

53

I only handle 39 and 42 because 48 I not really yet supported. I will add this crash check. Thanks for the review.

cmake/config-ix.cmake

set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86_64} i386 i686 powerpc64
   powerpc64le ${ARM32} ${ARM64} mips mips64 mipsel mips64el)
 set(ALL_ASAN_SUPPORTED_ARCH ${X86_64} i386 i686 powerpc64 powerpc64le ${ARM32}
   ${ARM64} mips mipsel mips64 mips64el)
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} mips64 mips64el ${ARM64})
 set(ALL_LSAN_SUPPORTED_ARCH ${X86_64} mips64 mips64el)
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} mips64 mips64el)
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86_64} i386 i686 ${ARM32} mips mips64
     mipsel mips64el ${ARM64} powerpc64 powerpc64le)
-set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} mips64 mips64el)
+set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} mips64 mips64el ${ARM64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86_64} i386 i686 ${ARM32} ${ARM64} mips
     mipsel mips64 mips64el powerpc64 powerpc64le)
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86_64} i386 i686)
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" Off)

lib/sanitizer_common/sanitizer_allocator.h

for (uptr region = 0; region < kNumPossibleRegions; region++)
           callback(chunk, arg);
         }
       }
   }
 
   void PrintStats() {
   }
 
+  static uptr AdditionalSize() {
+    return 0;
+  }
+
   typedef SizeClassMap SizeClassMapT;
   static const uptr kNumClasses = SizeClassMap::kNumClasses;
 
  private:
   static const uptr kRegionSize = 1 << kRegionSizeLog;
   static const uptr kNumPossibleRegions = kSpaceSize / kRegionSize;
 
   struct SizeClassInfo {

lib/sanitizer_common/sanitizer_platform.h

 #if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
 #define SANITIZER_USES_UID16_SYSCALLS 1
 #else
 #define SANITIZER_USES_UID16_SYSCALLS 0
 #endif
 
 #if defined(__mips__) || (defined(__aarch64__) && SANITIZER_AARCH64_VMA == 39)
 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
+#elif defined(__aarch64__) && SANITIZER_AARCH64_VMA == 42
+# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 11)
 #else
 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
 #endif
 
 // Assume obsolete RPC headers are available by default
 #if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H)
 # define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID)
 # define HAVE_TIRPC_RPC_XDR_H 0

lib/tsan/rtl/tsan_platform.h

 const uptr kLoAppMemBeg   = 0x0100000000ull;
 const uptr kLoAppMemEnd   = 0x0200000000ull;
 const uptr kHiAppMemBeg   = 0xff80000000ull;
 const uptr kHiAppMemEnd   = 0xffffffffffull;
 const uptr kAppMemMsk     = 0xfc00000000ull;
 const uptr kAppMemXor     = 0x0400000000ull;
 const uptr kVdsoBeg       = 0xfffff00000ull;
 #elif defined(__aarch64__)
+# if SANITIZER_AARCH64_VMA == 39
 /*
 C/C++ on linux/aarch64 (39-bit VMA)
 0000 4000 00 - 0200 0000 00: main binary
 2000 0000 00 - 4000 0000 00: shadow memory
 4000 0000 00 - 5000 0000 00: metainfo
 5000 0000 00 - 6000 0000 00: -
 6000 0000 00 - 6200 0000 00: traces
 6200 0000 00 - 7d00 0000 00: -

 const uptr kTraceMemEnd   = 0x6200000000ull;
 const uptr kHeapMemBeg    = 0x7d00000000ull;
 const uptr kHeapMemEnd    = 0x7e00000000ull;
 const uptr kHiAppMemBeg   = 0x7e00000000ull;
 const uptr kHiAppMemEnd   = 0x7fffffffffull;
 const uptr kAppMemMsk     = 0x7800000000ull;
 const uptr kAppMemXor     = 0x0800000000ull;
 const uptr kVdsoBeg       = 0x7f00000000ull;
+# elif SANITIZER_AARCH64_VMA == 42
+/*
+C/C++ on linux/aarch64 (42-bit VMA)
+00000 4000 00 - 01000 0000 00: main binary
+01000 0000 00 - 10000 0000 00: -
[phone] - 20000 0000 00: shadow memory
[phone] - 26000 0000 00: -
[phone] - 28000 0000 00: metainfo
[phone] - 36200 0000 00: -
[phone] - 36240 0000 00: traces
[phone] - 3e000 0000 00: -
+3e000 0000 00 - 3f000 0000 00: heap
+3c000 0000 00 - 3ff00 0000 00: -
+3ff00 0000 00 - 3ffff f000 00: modules and main thread stack
+*/
+const uptr kLoAppMemBeg   = 0x00000400000ull;
+const uptr kLoAppMemEnd   = 0x01000000000ull;
+const uptr kShadowBeg     = 0x10000000000ull;
+const uptr kShadowEnd     = 0x20000000000ull;
+const uptr kMetaShadowBeg = 0x26000000000ull;
+const uptr kMetaShadowEnd = 0x28000000000ull;
+const uptr kTraceMemBeg   = 0x36200000000ull;
+const uptr kTraceMemEnd   = 0x36400000000ull;
+const uptr kHeapMemBeg    = 0x3e000000000ull;
+const uptr kHeapMemEnd    = 0x3f000000000ull;
+const uptr kHiAppMemBeg   = 0x3ff00000000ull;
+const uptr kHiAppMemEnd   = 0x3fffff00000ull;
+const uptr kAppMemMsk     = 0x3c000000000ull;
+const uptr kAppMemXor     = 0x04000000000ull;
+const uptr kVdsoBeg       = 0x37f00000000ull;
+# endif
 #endif
 
 ALWAYS_INLINE
 bool IsAppMem(uptr mem) {
   return (mem >= kHeapMemBeg && mem < kHeapMemEnd) ||
          (mem >= kLoAppMemBeg && mem < kLoAppMemEnd) ||
          (mem >= kHiAppMemBeg && mem < kHiAppMemEnd);
 }

lib/tsan/rtl/tsan_rtl.h

#endif
   Event *trace = (Event*)GetThreadTrace(fs.tid());
   Event *evp = &trace[pos];
   Event ev = (u64)addr | ((u64)typ << 61);
   *evp = ev;
 }
 
 #ifndef SANITIZER_GO
 uptr ALWAYS_INLINE HeapEnd() {
-#if SANITIZER_CAN_USE_ALLOCATOR64
   return kHeapMemEnd + PrimaryAllocator::AdditionalSize();
-#else
-  return kHeapMemEnd;
-#endif
 }
 #endif
 
 }  // namespace __tsan
 
 #endif  // TSAN_RTL_H

test/tsan/ignore_lib0.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib0.so
 // RUN: %clangxx_tsan -O1 %s -L%T -lignore_lib0 -o %t
 // RUN: echo running w/o suppressions:
 // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
 // RUN: echo running with suppressions:
 // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
 
 // Tests that interceptors coming from a library specified in called_from_lib
 // suppression are ignored.
 
 // Some aarch64 kernels do not support non executable write pages
-// XFAIL: aarch64
+// REQUIRES: stable-runtime
 
 #ifndef LIB
 
 extern "C" void libfunc();
 
 int main() {
   libfunc();
 }

test/tsan/ignore_lib1.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib1.so
 // RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: echo running w/o suppressions:
 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
 // RUN: echo running with suppressions:
 // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
 
 // Tests that interceptors coming from a dynamically loaded library specified
 // in called_from_lib suppression are ignored.
 
-// XFAIL: aarch64
+// REQUIRES: stable-runtime
 
 #ifndef LIB
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <libgen.h>

test/tsan/ignore_lib3.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib3.so
 // RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %deflake %run %t | FileCheck %s
 
 // Tests that unloading of a library matched against called_from_lib suppression
 // causes program crash (this is not supported).
 
 // Some aarch64 kernels do not support non executable write pages
-// XFAIL: aarch64
+// REQUIRES: stable-runtime
 
 #ifndef LIB
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <libgen.h>

test/tsan/lit.cfg

 config.substitutions.append( ("%deflake ", os.path.join(os.path.dirname(__file__), "deflake.bash")) )
 
 # Default test suffixes.
 config.suffixes = ['.c', '.cc', '.cpp']
 
 # ThreadSanitizer tests are currently supported on FreeBSD and Linux only.
 if config.host_os not in ['FreeBSD', 'Linux']:
   config.unsupported = True
+
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test hangs.
+if config.target_arch != 'aarch64':
+  config.available_features.add('stable-runtime')

test/tsan/test.h

 // Default instance of the barrier, but a test can declare more manually.
 pthread_barrier_t barrier;
 
 void print_address(void *address) {
 // On FreeBSD, the %p conversion specifier works as 0x%x and thus does not match
 // to the format used in the diagnotic message.
 #ifdef __x86_64__
   fprintf(stderr, "0x%012lx", (unsigned long) address);
-#elif defined(__mips64) || defined(__aarch64__)
+#elif defined(__mips64)
   fprintf(stderr, "0x%010lx", (unsigned long) address);
+#elif defined(__aarch64__)
+  // AArch64 currently has 3 different VMA (39, 42, and 48 bits) and it require
+  // different pointer size to match the diagnostic message.
+  const char *format = NULL;
+  unsigned long vma = (unsigned long)__builtin_frame_address(0);
+  vma = 64 - __builtin_clzll(vma);
+  if (vma == 39)
+    format = "0x%010lx";
+  else if (vma == 42)
+    format = "0x%011lx";
+
+  fprintf(stderr, format, (unsigned long) address);
 #endif
 }