Respect personality in kernel area detector

[ygribov]

Checked x64 (check-all), i386 (only kernel-area) and schroot on x64 with i386 personality (only kernel-area). Looks like currently kernel-area.cc test won't work under schroots because we can't reliably determine asan-32-bits there.

[ygribov]

This is a draft so let me know if you'd prefer mmaps or /proc/pid/maps approach.

[kcc]

Looks reasonable. But maybe also add the check for the value of current stack pointer?

[samsonov]

lib/sanitizer_common/sanitizer_flags.cc

125

Please provide default value for this flag in SetCommonFlagsDefaults().

[ygribov]

Updated based on review. Also relaxed personality check to allow innocent modifications which don't harm uname.

[kcc]

LGTM

[kcc]

r208760.

lib/asan/asan_rtl.cc

CHECK(kMidShadowBeg > kLowShadowEnd &&
           kHighShadowBeg > kMidMemEnd);
 }
 
 static void AsanInitInternal() {
   if (asan_inited) return;
   SanitizerToolName = "AddressSanitizer";
   CHECK(!asan_init_is_running && "ASan init calls itself!");
   asan_init_is_running = true;
+
+  // Initialize flags. This must be done early, because most of the
+  // initialization steps look at flags().
+  const char *options = GetEnv("ASAN_OPTIONS");
+  InitializeFlags(flags(), options);
+
   InitializeHighMemEnd();
 
   // Make sure we are not statically linked.
   AsanDoesNotSupportStaticLinkage();
 
   // Install tool-specific callbacks in sanitizer_common.
   SetDieCallback(AsanDie);
   SetCheckFailedCallback(AsanCheckFailed);
   SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
 
-  // Initialize flags. This must be done early, because most of the
-  // initialization steps look at flags().
-  const char *options = GetEnv("ASAN_OPTIONS");
-  InitializeFlags(flags(), options);
-
   if (!flags()->start_deactivated)
     ParseExtraActivationFlags();
 
   __sanitizer_set_report_path(common_flags()->log_path);
   __asan_option_detect_stack_use_after_return =
       flags()->detect_stack_use_after_return;
   CHECK_LE(flags()->min_uar_stack_size_log, flags()->max_uar_stack_size_log);
 

lib/sanitizer_common/sanitizer_flags.h

struct CommonFlags {
   bool use_sigaltstack;
   bool detect_deadlocks;
   uptr clear_shadow_mmap_threshold;
   const char *color;
   bool legacy_pthread_cond;
   bool intercept_tls_get_addr;
   bool help;
   uptr mmap_limit_mb;
+  bool full_address_space;
 };
 
 inline CommonFlags *common_flags() {
   extern CommonFlags common_flags_dont_use;
   return &common_flags_dont_use;
 }
 
 void SetCommonFlagsDefaults(CommonFlags *f);
 void ParseCommonFlagsFromString(CommonFlags *f, const char *str);
 void PrintFlagDescriptions();
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/sanitizer_common/sanitizer_flags.cc

void ParseCommonFlagsFromString(CommonFlags *f, const char *str) {
   ParseFlag(str, &f->legacy_pthread_cond, "legacy_pthread_cond",
       "Enables support for dynamic libraries linked with libpthread 2.2.5.");
   ParseFlag(str, &f->intercept_tls_get_addr, "intercept_tls_get_addr",
             "Intercept __tls_get_addr.");
   ParseFlag(str, &f->help, "help", "Print the flag descriptions.");
   ParseFlag(str, &f->mmap_limit_mb, "mmap_limit_mb",
             "Limit the amount of mmap-ed memory (excluding shadow) in Mb; "
             "not a user-facing flag, used mosly for testing the tools");
+  ParseFlag(str, &f->full_address_space, "full_address_space",
+            "Sanitize complete address space; "
+            "by default kernel area on 32-bit platforms will not be sanitized");
 
   // Do a sanity check for certain flags.
   if (f->malloc_context_size < 1)
     f->malloc_context_size = 1;
 }
 
 static bool GetFlagValue(const char *env, const char *name,
                          const char **value, int *value_length) {

lib/sanitizer_common/sanitizer_posix.cc

 #include "sanitizer_libc.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_stacktrace.h"
 
 #include <sys/mman.h>
 
 #if SANITIZER_LINUX
 #include <sys/utsname.h>
+#include <sys/personality.h>
 #endif
 
 namespace __sanitizer {
 
 // ------------- sanitizer_common.h
 uptr GetMmapGranularity() {
   return GetPageSize();
 }
 
 #if SANITIZER_WORDSIZE == 32
 // Take care of unusable kernel area in top gigabyte
 static uptr GetKernelStartAddress() {
-#if 0  // SANITIZER_LINUX
-  // FIXME: this code is too naive. We have a situation where the machine is a
-  // true x8_64, but under schroot uname returns i686.
+#if SANITIZER_LINUX
+  // Uname may return misleading results if personality is set
+  // (e.g. under schroot). Abort early if that's the case.
+  if (0 != personality(0xffffffffUL))
+    return 0;
+
   // 64-bit Linux provides 32-bit apps with full address space
   struct utsname uname_info;
   return 0 == uname(&uname_info) && !internal_strstr(uname_info.machine, "64")
     ? 1ULL << 30
     : 0;
 #else
   return 0;
 #endif  // SANITIZER_LINUX
# if defined(__powerpc64__)
   return (1ULL << 44) - 1;  // 0x00000fffffffffffUL
 # elif defined(__aarch64__)
   return (1ULL << 39) - 1;
 # else
   return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
 # endif
 #else  // SANITIZER_WORDSIZE == 32
   uptr res = (1ULL << 32) - 1;  // 0xffffffff;
+  if (!common_flags()->full_address_space)
     res -= GetKernelStartAddress();
   CHECK_LT(reinterpret_cast<uptr>(&res), res);
   return res;
 #endif  // SANITIZER_WORDSIZE
 }
 
 void *MmapOrDie(uptr size, const char *mem_type) {
   size = RoundUpTo(size, GetPageSizeCached());
   uptr res = internal_mmap(0, size,

test/asan/TestCases/Linux/kernel-area.cc

 // Test that kernel area is not sanitized on 32-bit machines.
 //
 // RUN: %clangxx_asan %s -o %t
 // RUN: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-kernel-64-bits
 //
 // CHECK-kernel-32-bits: || `[0x38000000, 0xbfffffff]` || HighMem    ||
 // CHECK-kernel-32-bits: || `[0x27000000, 0x37ffffff]` || HighShadow ||
 // CHECK-kernel-32-bits: || `[0x24000000, 0x26ffffff]` || ShadowGap  ||
 //
 // CHECK-kernel-64-bits: || `[0x40000000, 0xffffffff]` || HighMem    ||
 // CHECK-kernel-64-bits: || `[0x28000000, 0x3fffffff]` || HighShadow ||
 // CHECK-kernel-64-bits: || `[0x24000000, 0x27ffffff]` || ShadowGap  ||
 //
 // REQUIRES: asan-32-bits
 
 int main() {
   return 0;
 }