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

127

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 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 coverage;
+  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 SetCommonFlagsDefaults(CommonFlags *f) {
   f->allow_user_segv_handler = false;
   f->use_sigaltstack = true;
   f->detect_deadlocks = false;
   f->clear_shadow_mmap_threshold = 64 * 1024;
   f->color = "auto";
   f->legacy_pthread_cond = false;
   f->intercept_tls_get_addr = false;
   f->coverage = false;
+  f->full_address_space = false;
 }
 
 void ParseCommonFlagsFromString(CommonFlags *f, const char *str) {
   ParseFlag(str, &f->symbolize, "symbolize",
       "If set, use the online symbolizer from common sanitizer runtime to turn "
       "virtual addresses to file/line locations.");
   ParseFlag(str, &f->external_symbolizer_path, "external_symbolizer_path",
       "Path to external symbolizer. If empty, the tool will search $PATH for "
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->coverage, "coverage",
       "If set, coverage information will be dumped at program shutdown (if the "
       "coverage instrumentation was enabled at compile time).");
+  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.
-  // 64-bit Linux provides 32-bit apps with full address space
+// Take care of unusable kernel area in top gigabyte.
+static uptr GetKernelAreaSize() {
+#if SANITIZER_LINUX
+  const uptr gbyte = 1UL << 30;
+
+  // Firstly check if there are writable segments
+  // mapped to top gigabyte (e.g. stack).
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr end, prot;
+  while (proc_maps.Next(/*start*/0, &end,
+                        /*offset*/0, /*filename*/0,
+                        /*filename_size*/0, &prot)) {
+    if ((end >= 3 * gbyte)
+        && (prot & MemoryMappingLayout::kProtectionWrite) != 0)
+      return 0;
+  }
+
+  // Even if nothing is mapped, top Gb may still be accessible
+  // if we are running on 64-bit kernel.
+  // Uname may report misleading results if personality type
+  // is modified (e.g. under schroot) so check this as well.
   struct utsname uname_info;
-  return 0 == uname(&uname_info) && !internal_strstr(uname_info.machine, "64")
-    ? 1ULL << 30
-    : 0;
+  int pers = personality(0xffffffffUL);
+  if (!(pers & PER_MASK)
+      && uname(&uname_info) == 0
+      && internal_strstr(uname_info.machine, "64"))
+    return 0;
+
+  // Top gigabyte is reserved for kernel.
+  return gbyte;
 #else
   return 0;
 #endif  // SANITIZER_LINUX
 }
 #endif  // SANITIZER_WORDSIZE == 32
 
 uptr GetMaxVirtualAddress() {
 #if SANITIZER_WORDSIZE == 64
 # if defined(__powerpc64__)
   // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
   // Note that with 'ulimit -s unlimited' the stack is moved away from the top
   // of the address space, so simply checking the stack address is not enough.
   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;
-  res -= GetKernelStartAddress();
+  if (!common_flags()->full_address_space)
+    res -= GetKernelAreaSize();
   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;
 }