contrib/compiler-rt/lib/hwasan/hwasan.cc

   1 //===-- hwasan.cc -----------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of HWAddressSanitizer.
  11 //
  12 // HWAddressSanitizer runtime.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "hwasan.h"
  16 #include "hwasan_thread.h"
  17 #include "hwasan_poisoning.h"
  18 #include "sanitizer_common/sanitizer_atomic.h"
  19 #include "sanitizer_common/sanitizer_common.h"
  20 #include "sanitizer_common/sanitizer_flags.h"
  21 #include "sanitizer_common/sanitizer_flag_parser.h"
  22 #include "sanitizer_common/sanitizer_libc.h"
  23 #include "sanitizer_common/sanitizer_procmaps.h"
  24 #include "sanitizer_common/sanitizer_stacktrace.h"
  25 #include "sanitizer_common/sanitizer_symbolizer.h"
  26 #include "sanitizer_common/sanitizer_stackdepot.h"
  27 #include "ubsan/ubsan_flags.h"
  28 #include "ubsan/ubsan_init.h"
  29
  30 // ACHTUNG! No system header includes in this file.
  31
  32 using namespace __sanitizer;
  33
  34 namespace __hwasan {
  35
  36 void EnterSymbolizer() {
  37   HwasanThread *t = GetCurrentThread();
  38   CHECK(t);
  39   t->EnterSymbolizer();
  40 }
  41 void ExitSymbolizer() {
  42   HwasanThread *t = GetCurrentThread();
  43   CHECK(t);
  44   t->LeaveSymbolizer();
  45 }
  46 bool IsInSymbolizer() {
  47   HwasanThread *t = GetCurrentThread();
  48   return t && t->InSymbolizer();
  49 }
  50
  51 static Flags hwasan_flags;
  52
  53 Flags *flags() {
  54   return &hwasan_flags;
  55 }
  56
  57 int hwasan_inited = 0;
  58 bool hwasan_init_is_running;
  59
  60 int hwasan_report_count = 0;
  61
  62 void Flags::SetDefaults() {
  63 #define HWASAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
  64 #include "hwasan_flags.inc"
  65 #undef HWASAN_FLAG
  66 }
  67
  68 static void RegisterHwasanFlags(FlagParser *parser, Flags *f) {
  69 #define HWASAN_FLAG(Type, Name, DefaultValue, Description) \
  70   RegisterFlag(parser, #Name, Description, &f->Name);
  71 #include "hwasan_flags.inc"
  72 #undef HWASAN_FLAG
  73 }
  74
  75 static void InitializeFlags() {
  76   SetCommonFlagsDefaults();
  77   {
  78     CommonFlags cf;
  79     cf.CopyFrom(*common_flags());
  80     cf.external_symbolizer_path = GetEnv("HWASAN_SYMBOLIZER_PATH");
  81     cf.malloc_context_size = 20;
  82     cf.handle_ioctl = true;
  83     // FIXME: test and enable.
  84     cf.check_printf = false;
  85     cf.intercept_tls_get_addr = true;
  86     cf.exitcode = 99;
  87     cf.handle_sigill = kHandleSignalExclusive;
  88     OverrideCommonFlags(cf);
  89   }
  90
  91   Flags *f = flags();
  92   f->SetDefaults();
  93
  94   FlagParser parser;
  95   RegisterHwasanFlags(&parser, f);
  96   RegisterCommonFlags(&parser);
  97
  98 #if HWASAN_CONTAINS_UBSAN
  99   __ubsan::Flags *uf = __ubsan::flags();
 100   uf->SetDefaults();
 101
 102   FlagParser ubsan_parser;
 103   __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
 104   RegisterCommonFlags(&ubsan_parser);
 105 #endif
 106
 107   // Override from user-specified string.
 108   if (__hwasan_default_options)
 109     parser.ParseString(__hwasan_default_options());
 110 #if HWASAN_CONTAINS_UBSAN
 111   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
 112   ubsan_parser.ParseString(ubsan_default_options);
 113 #endif
 114
 115   const char *hwasan_options = GetEnv("HWASAN_OPTIONS");
 116   parser.ParseString(hwasan_options);
 117 #if HWASAN_CONTAINS_UBSAN
 118   ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
 119 #endif
 120   VPrintf(1, "HWASAN_OPTIONS: %s\n", hwasan_options ? hwasan_options : "<empty>");
 121
 122   InitializeCommonFlags();
 123
 124   if (Verbosity()) ReportUnrecognizedFlags();
 125
 126   if (common_flags()->help) parser.PrintFlagDescriptions();
 127 }
 128
 129 void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
 130                    void *context, bool request_fast_unwind) {
 131   HwasanThread *t = GetCurrentThread();
 132   if (!t || !StackTrace::WillUseFastUnwind(request_fast_unwind)) {
 133     // Block reports from our interceptors during _Unwind_Backtrace.
 134     SymbolizerScope sym_scope;
 135     return stack->Unwind(max_s, pc, bp, context, 0, 0, request_fast_unwind);
 136   }
 137   stack->Unwind(max_s, pc, bp, context, t->stack_top(), t->stack_bottom(),
 138                 request_fast_unwind);
 139 }
 140
 141 void PrintWarning(uptr pc, uptr bp) {
 142   GET_FATAL_STACK_TRACE_PC_BP(pc, bp);
 143   ReportInvalidAccess(&stack, 0);
 144 }
 145
 146 } // namespace __hwasan
 147
 148 // Interface.
 149
 150 using namespace __hwasan;
 151
 152 void __hwasan_init() {
 153   CHECK(!hwasan_init_is_running);
 154   if (hwasan_inited) return;
 155   hwasan_init_is_running = 1;
 156   SanitizerToolName = "HWAddressSanitizer";
 157
 158   InitTlsSize();
 159
 160   CacheBinaryName();
 161   InitializeFlags();
 162
 163   __sanitizer_set_report_path(common_flags()->log_path);
 164
 165   InitializeInterceptors();
 166   InstallDeadlySignalHandlers(HwasanOnDeadlySignal);
 167   InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
 168
 169   DisableCoreDumperIfNecessary();
 170   if (!InitShadow()) {
 171     Printf("FATAL: HWAddressSanitizer can not mmap the shadow memory.\n");
 172     Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
 173     Printf("FATAL: Disabling ASLR is known to cause this error.\n");
 174     Printf("FATAL: If running under GDB, try "
 175            "'set disable-randomization off'.\n");
 176     DumpProcessMap();
 177     Die();
 178   }
 179
 180   Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
 181
 182   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 183
 184   HwasanTSDInit(HwasanTSDDtor);
 185
 186   HwasanAllocatorInit();
 187
 188   HwasanThread *main_thread = HwasanThread::Create(nullptr, nullptr);
 189   SetCurrentThread(main_thread);
 190   main_thread->ThreadStart();
 191
 192 #if HWASAN_CONTAINS_UBSAN
 193   __ubsan::InitAsPlugin();
 194 #endif
 195
 196   VPrintf(1, "HWAddressSanitizer init done\n");
 197
 198   hwasan_init_is_running = 0;
 199   hwasan_inited = 1;
 200 }
 201
 202 void __hwasan_print_shadow(const void *x, uptr size) {
 203   // FIXME:
 204   Printf("FIXME: __hwasan_print_shadow unimplemented\n");
 205 }
 206
 207 sptr __hwasan_test_shadow(const void *p, uptr sz) {
 208   if (sz == 0)
 209     return -1;
 210   tag_t ptr_tag = GetTagFromPointer((uptr)p);
 211   if (ptr_tag == 0)
 212     return -1;
 213   uptr ptr_raw = GetAddressFromPointer((uptr)p);
 214   uptr shadow_first = MEM_TO_SHADOW(ptr_raw);
 215   uptr shadow_last = MEM_TO_SHADOW(ptr_raw + sz - 1);
 216   for (uptr s = shadow_first; s <= shadow_last; ++s)
 217     if (*(tag_t*)s != ptr_tag)
 218       return SHADOW_TO_MEM(s) - ptr_raw;
 219   return -1;
 220 }
 221
 222 u16 __sanitizer_unaligned_load16(const uu16 *p) {
 223   return *p;
 224 }
 225 u32 __sanitizer_unaligned_load32(const uu32 *p) {
 226   return *p;
 227 }
 228 u64 __sanitizer_unaligned_load64(const uu64 *p) {
 229   return *p;
 230 }
 231 void __sanitizer_unaligned_store16(uu16 *p, u16 x) {
 232   *p = x;
 233 }
 234 void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
 235   *p = x;
 236 }
 237 void __sanitizer_unaligned_store64(uu64 *p, u64 x) {
 238   *p = x;
 239 }
 240
 241 template<unsigned X>
 242 __attribute__((always_inline))
 243 static void SigIll() {
 244 #if defined(__aarch64__)
 245   asm("hlt %0\n\t" ::"n"(X));
 246 #elif defined(__x86_64__) || defined(__i386__)
 247   asm("ud2\n\t");
 248 #else
 249   // FIXME: not always sigill.
 250   __builtin_trap();
 251 #endif
 252   // __builtin_unreachable();
 253 }
 254
 255 enum class ErrorAction { Abort, Recover };
 256 enum class AccessType { Load, Store };
 257
 258 template <ErrorAction EA, AccessType AT, unsigned LogSize>
 259 __attribute__((always_inline, nodebug)) static void CheckAddress(uptr p) {
 260   tag_t ptr_tag = GetTagFromPointer(p);
 261   uptr ptr_raw = p & ~kAddressTagMask;
 262   tag_t mem_tag = *(tag_t *)MEM_TO_SHADOW(ptr_raw);
 263   if (UNLIKELY(ptr_tag != mem_tag)) {
 264     SigIll<0x100 + 0x20 * (EA == ErrorAction::Recover) +
 265            0x10 * (AT == AccessType::Store) + LogSize>();
 266     if (EA == ErrorAction::Abort) __builtin_unreachable();
 267   }
 268 }
 269
 270 template <ErrorAction EA, AccessType AT>
 271 __attribute__((always_inline, nodebug)) static void CheckAddressSized(uptr p,
 272                                                                       uptr sz) {
 273   CHECK_NE(0, sz);
 274   tag_t ptr_tag = GetTagFromPointer(p);
 275   uptr ptr_raw = p & ~kAddressTagMask;
 276   tag_t *shadow_first = (tag_t *)MEM_TO_SHADOW(ptr_raw);
 277   tag_t *shadow_last = (tag_t *)MEM_TO_SHADOW(ptr_raw + sz - 1);
 278   for (tag_t *t = shadow_first; t <= shadow_last; ++t)
 279     if (UNLIKELY(ptr_tag != *t)) {
 280       SigIll<0x100 + 0x20 * (EA == ErrorAction::Recover) +
 281              0x10 * (AT == AccessType::Store) + 0xf>();
 282       if (EA == ErrorAction::Abort) __builtin_unreachable();
 283     }
 284 }
 285
 286 void __hwasan_load(uptr p, uptr sz) {
 287   CheckAddressSized<ErrorAction::Abort, AccessType::Load>(p, sz);
 288 }
 289 void __hwasan_load1(uptr p) {
 290   CheckAddress<ErrorAction::Abort, AccessType::Load, 0>(p);
 291 }
 292 void __hwasan_load2(uptr p) {
 293   CheckAddress<ErrorAction::Abort, AccessType::Load, 1>(p);
 294 }
 295 void __hwasan_load4(uptr p) {
 296   CheckAddress<ErrorAction::Abort, AccessType::Load, 2>(p);
 297 }
 298 void __hwasan_load8(uptr p) {
 299   CheckAddress<ErrorAction::Abort, AccessType::Load, 3>(p);
 300 }
 301 void __hwasan_load16(uptr p) {
 302   CheckAddress<ErrorAction::Abort, AccessType::Load, 4>(p);
 303 }
 304
 305 void __hwasan_load_noabort(uptr p, uptr sz) {
 306   CheckAddressSized<ErrorAction::Recover, AccessType::Load>(p, sz);
 307 }
 308 void __hwasan_load1_noabort(uptr p) {
 309   CheckAddress<ErrorAction::Recover, AccessType::Load, 0>(p);
 310 }
 311 void __hwasan_load2_noabort(uptr p) {
 312   CheckAddress<ErrorAction::Recover, AccessType::Load, 1>(p);
 313 }
 314 void __hwasan_load4_noabort(uptr p) {
 315   CheckAddress<ErrorAction::Recover, AccessType::Load, 2>(p);
 316 }
 317 void __hwasan_load8_noabort(uptr p) {
 318   CheckAddress<ErrorAction::Recover, AccessType::Load, 3>(p);
 319 }
 320 void __hwasan_load16_noabort(uptr p) {
 321   CheckAddress<ErrorAction::Recover, AccessType::Load, 4>(p);
 322 }
 323
 324 void __hwasan_store(uptr p, uptr sz) {
 325   CheckAddressSized<ErrorAction::Abort, AccessType::Store>(p, sz);
 326 }
 327 void __hwasan_store1(uptr p) {
 328   CheckAddress<ErrorAction::Abort, AccessType::Store, 0>(p);
 329 }
 330 void __hwasan_store2(uptr p) {
 331   CheckAddress<ErrorAction::Abort, AccessType::Store, 1>(p);
 332 }
 333 void __hwasan_store4(uptr p) {
 334   CheckAddress<ErrorAction::Abort, AccessType::Store, 2>(p);
 335 }
 336 void __hwasan_store8(uptr p) {
 337   CheckAddress<ErrorAction::Abort, AccessType::Store, 3>(p);
 338 }
 339 void __hwasan_store16(uptr p) {
 340   CheckAddress<ErrorAction::Abort, AccessType::Store, 4>(p);
 341 }
 342
 343 void __hwasan_store_noabort(uptr p, uptr sz) {
 344   CheckAddressSized<ErrorAction::Recover, AccessType::Store>(p, sz);
 345 }
 346 void __hwasan_store1_noabort(uptr p) {
 347   CheckAddress<ErrorAction::Recover, AccessType::Store, 0>(p);
 348 }
 349 void __hwasan_store2_noabort(uptr p) {
 350   CheckAddress<ErrorAction::Recover, AccessType::Store, 1>(p);
 351 }
 352 void __hwasan_store4_noabort(uptr p) {
 353   CheckAddress<ErrorAction::Recover, AccessType::Store, 2>(p);
 354 }
 355 void __hwasan_store8_noabort(uptr p) {
 356   CheckAddress<ErrorAction::Recover, AccessType::Store, 3>(p);
 357 }
 358 void __hwasan_store16_noabort(uptr p) {
 359   CheckAddress<ErrorAction::Recover, AccessType::Store, 4>(p);
 360 }
 361
 362 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 363 extern "C" {
 364 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 365 const char* __hwasan_default_options() { return ""; }
 366 }  // extern "C"
 367 #endif
 368
 369 extern "C" {
 370 SANITIZER_INTERFACE_ATTRIBUTE
 371 void __sanitizer_print_stack_trace() {
 372   GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME());
 373   stack.Print();
 374 }
 375 } // extern "C"