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_checks.h"
  17 #include "hwasan_poisoning.h"
  18 #include "hwasan_report.h"
  19 #include "hwasan_thread.h"
  20 #include "hwasan_thread_list.h"
  21 #include "sanitizer_common/sanitizer_atomic.h"
  22 #include "sanitizer_common/sanitizer_common.h"
  23 #include "sanitizer_common/sanitizer_flag_parser.h"
  24 #include "sanitizer_common/sanitizer_flags.h"
  25 #include "sanitizer_common/sanitizer_libc.h"
  26 #include "sanitizer_common/sanitizer_procmaps.h"
  27 #include "sanitizer_common/sanitizer_stackdepot.h"
  28 #include "sanitizer_common/sanitizer_stacktrace.h"
  29 #include "sanitizer_common/sanitizer_symbolizer.h"
  30 #include "ubsan/ubsan_flags.h"
  31 #include "ubsan/ubsan_init.h"
  32
  33 // ACHTUNG! No system header includes in this file.
  34
  35 using namespace __sanitizer;
  36
  37 namespace __hwasan {
  38
  39 void EnterSymbolizer() {
  40   Thread *t = GetCurrentThread();
  41   CHECK(t);
  42   t->EnterSymbolizer();
  43 }
  44 void ExitSymbolizer() {
  45   Thread *t = GetCurrentThread();
  46   CHECK(t);
  47   t->LeaveSymbolizer();
  48 }
  49 bool IsInSymbolizer() {
  50   Thread *t = GetCurrentThread();
  51   return t && t->InSymbolizer();
  52 }
  53
  54 static Flags hwasan_flags;
  55
  56 Flags *flags() {
  57   return &hwasan_flags;
  58 }
  59
  60 int hwasan_inited = 0;
  61 int hwasan_shadow_inited = 0;
  62 bool hwasan_init_is_running;
  63
  64 int hwasan_report_count = 0;
  65
  66 void Flags::SetDefaults() {
  67 #define HWASAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
  68 #include "hwasan_flags.inc"
  69 #undef HWASAN_FLAG
  70 }
  71
  72 static void RegisterHwasanFlags(FlagParser *parser, Flags *f) {
  73 #define HWASAN_FLAG(Type, Name, DefaultValue, Description) \
  74   RegisterFlag(parser, #Name, Description, &f->Name);
  75 #include "hwasan_flags.inc"
  76 #undef HWASAN_FLAG
  77 }
  78
  79 static void InitializeFlags() {
  80   SetCommonFlagsDefaults();
  81   {
  82     CommonFlags cf;
  83     cf.CopyFrom(*common_flags());
  84     cf.external_symbolizer_path = GetEnv("HWASAN_SYMBOLIZER_PATH");
  85     cf.malloc_context_size = 20;
  86     cf.handle_ioctl = true;
  87     // FIXME: test and enable.
  88     cf.check_printf = false;
  89     cf.intercept_tls_get_addr = true;
  90     cf.exitcode = 99;
  91     // Sigtrap is used in error reporting.
  92     cf.handle_sigtrap = kHandleSignalExclusive;
  93
  94 #if SANITIZER_ANDROID
  95     // Let platform handle other signals. It is better at reporting them then we
  96     // are.
  97     cf.handle_segv = kHandleSignalNo;
  98     cf.handle_sigbus = kHandleSignalNo;
  99     cf.handle_abort = kHandleSignalNo;
 100     cf.handle_sigill = kHandleSignalNo;
 101     cf.handle_sigfpe = kHandleSignalNo;
 102 #endif
 103     OverrideCommonFlags(cf);
 104   }
 105
 106   Flags *f = flags();
 107   f->SetDefaults();
 108
 109   FlagParser parser;
 110   RegisterHwasanFlags(&parser, f);
 111   RegisterCommonFlags(&parser);
 112
 113 #if HWASAN_CONTAINS_UBSAN
 114   __ubsan::Flags *uf = __ubsan::flags();
 115   uf->SetDefaults();
 116
 117   FlagParser ubsan_parser;
 118   __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
 119   RegisterCommonFlags(&ubsan_parser);
 120 #endif
 121
 122   // Override from user-specified string.
 123   if (__hwasan_default_options)
 124     parser.ParseString(__hwasan_default_options());
 125 #if HWASAN_CONTAINS_UBSAN
 126   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
 127   ubsan_parser.ParseString(ubsan_default_options);
 128 #endif
 129
 130   const char *hwasan_options = GetEnv("HWASAN_OPTIONS");
 131   parser.ParseString(hwasan_options);
 132 #if HWASAN_CONTAINS_UBSAN
 133   ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
 134 #endif
 135   VPrintf(1, "HWASAN_OPTIONS: %s\n",
 136           hwasan_options ? hwasan_options : "<empty>");
 137
 138   InitializeCommonFlags();
 139
 140   if (Verbosity()) ReportUnrecognizedFlags();
 141
 142   if (common_flags()->help) parser.PrintFlagDescriptions();
 143 }
 144
 145 void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
 146                    void *context, bool request_fast_unwind) {
 147   Thread *t = GetCurrentThread();
 148   if (!t) {
 149     // the thread is still being created.
 150     stack->size = 0;
 151     return;
 152   }
 153   if (!StackTrace::WillUseFastUnwind(request_fast_unwind)) {
 154     // Block reports from our interceptors during _Unwind_Backtrace.
 155     SymbolizerScope sym_scope;
 156     return stack->Unwind(max_s, pc, bp, context, 0, 0, request_fast_unwind);
 157   }
 158   stack->Unwind(max_s, pc, bp, context, t->stack_top(), t->stack_bottom(),
 159                 request_fast_unwind);
 160 }
 161
 162 static void HWAsanCheckFailed(const char *file, int line, const char *cond,
 163                               u64 v1, u64 v2) {
 164   Report("HWAddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
 165          line, cond, (uptr)v1, (uptr)v2);
 166   PRINT_CURRENT_STACK_CHECK();
 167   Die();
 168 }
 169
 170 static constexpr uptr kMemoryUsageBufferSize = 4096;
 171
 172 static void HwasanFormatMemoryUsage(InternalScopedString &s) {
 173   HwasanThreadList &thread_list = hwasanThreadList();
 174   auto thread_stats = thread_list.GetThreadStats();
 175   auto *sds = StackDepotGetStats();
 176   AllocatorStatCounters asc;
 177   GetAllocatorStats(asc);
 178   s.append(
 179       "HWASAN pid: %d rss: %zd threads: %zd stacks: %zd"
 180       " thr_aux: %zd stack_depot: %zd uniq_stacks: %zd"
 181       " heap: %zd",
 182       internal_getpid(), GetRSS(), thread_stats.n_live_threads,
 183       thread_stats.total_stack_size,
 184       thread_stats.n_live_threads * thread_list.MemoryUsedPerThread(),
 185       sds->allocated, sds->n_uniq_ids, asc[AllocatorStatMapped]);
 186 }
 187
 188 #if SANITIZER_ANDROID
 189 static char *memory_usage_buffer = nullptr;
 190
 191 #define PR_SET_VMA 0x53564d41
 192 #define PR_SET_VMA_ANON_NAME 0
 193
 194 static void InitMemoryUsage() {
 195   memory_usage_buffer =
 196       (char *)MmapOrDie(kMemoryUsageBufferSize, "memory usage string");
 197   CHECK(memory_usage_buffer);
 198   memory_usage_buffer[0] = '\0';
 199   CHECK(internal_prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME,
 200                        (uptr)memory_usage_buffer, kMemoryUsageBufferSize,
 201                        (uptr)memory_usage_buffer) == 0);
 202 }
 203
 204 void UpdateMemoryUsage() {
 205   if (!flags()->export_memory_stats)
 206     return;
 207   if (!memory_usage_buffer)
 208     InitMemoryUsage();
 209   InternalScopedString s(kMemoryUsageBufferSize);
 210   HwasanFormatMemoryUsage(s);
 211   internal_strncpy(memory_usage_buffer, s.data(), kMemoryUsageBufferSize - 1);
 212   memory_usage_buffer[kMemoryUsageBufferSize - 1] = '\0';
 213 }
 214 #else
 215 void UpdateMemoryUsage() {}
 216 #endif
 217
 218 struct FrameDescription {
 219   uptr PC;
 220   const char *Descr;
 221 };
 222
 223 struct FrameDescriptionArray {
 224   FrameDescription *beg, *end;
 225 };
 226
 227 static InternalMmapVectorNoCtor<FrameDescriptionArray> AllFrames;
 228
 229 void InitFrameDescriptors(uptr b, uptr e) {
 230   FrameDescription *beg = reinterpret_cast<FrameDescription *>(b);
 231   FrameDescription *end = reinterpret_cast<FrameDescription *>(e);
 232   if (beg == end)
 233     return;
 234   AllFrames.push_back({beg, end});
 235   if (Verbosity())
 236     for (FrameDescription *frame_descr = beg; frame_descr < end; frame_descr++)
 237       Printf("Frame: %p %s\n", frame_descr->PC, frame_descr->Descr);
 238 }
 239
 240 const char *GetStackFrameDescr(uptr pc) {
 241   for (uptr i = 0, n = AllFrames.size(); i < n; i++)
 242     for (auto p = AllFrames[i].beg; p < AllFrames[i].end; p++)
 243       if (p->PC == pc)
 244         return p->Descr;
 245   return nullptr;
 246 }
 247
 248 } // namespace __hwasan
 249
 250 // Interface.
 251
 252 using namespace __hwasan;
 253
 254 uptr __hwasan_shadow_memory_dynamic_address;  // Global interface symbol.
 255
 256 void __hwasan_shadow_init() {
 257   if (hwasan_shadow_inited) return;
 258   if (!InitShadow()) {
 259     Printf("FATAL: HWAddressSanitizer cannot mmap the shadow memory.\n");
 260     DumpProcessMap();
 261     Die();
 262   }
 263   hwasan_shadow_inited = 1;
 264 }
 265
 266 void __hwasan_init_frames(uptr beg, uptr end) {
 267   InitFrameDescriptors(beg, end);
 268 }
 269
 270 void __hwasan_init() {
 271   CHECK(!hwasan_init_is_running);
 272   if (hwasan_inited) return;
 273   hwasan_init_is_running = 1;
 274   SanitizerToolName = "HWAddressSanitizer";
 275
 276   InitTlsSize();
 277
 278   CacheBinaryName();
 279   InitializeFlags();
 280
 281   // Install tool-specific callbacks in sanitizer_common.
 282   SetCheckFailedCallback(HWAsanCheckFailed);
 283
 284   __sanitizer_set_report_path(common_flags()->log_path);
 285
 286   AndroidTestTlsSlot();
 287
 288   DisableCoreDumperIfNecessary();
 289
 290   __hwasan_shadow_init();
 291
 292   InitThreads();
 293   hwasanThreadList().CreateCurrentThread();
 294
 295   MadviseShadow();
 296
 297   SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
 298   // This may call libc -> needs initialized shadow.
 299   AndroidLogInit();
 300
 301   InitializeInterceptors();
 302   InstallDeadlySignalHandlers(HwasanOnDeadlySignal);
 303   InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
 304
 305   Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
 306
 307   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 308
 309   HwasanTSDInit();
 310   HwasanTSDThreadInit();
 311
 312   HwasanAllocatorInit();
 313
 314 #if HWASAN_CONTAINS_UBSAN
 315   __ubsan::InitAsPlugin();
 316 #endif
 317
 318   VPrintf(1, "HWAddressSanitizer init done\n");
 319
 320   hwasan_init_is_running = 0;
 321   hwasan_inited = 1;
 322 }
 323
 324 void __hwasan_print_shadow(const void *p, uptr sz) {
 325   uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
 326   uptr shadow_first = MemToShadow(ptr_raw);
 327   uptr shadow_last = MemToShadow(ptr_raw + sz - 1);
 328   Printf("HWASan shadow map for %zx .. %zx (pointer tag %x)\n", ptr_raw,
 329          ptr_raw + sz, GetTagFromPointer((uptr)p));
 330   for (uptr s = shadow_first; s <= shadow_last; ++s)
 331     Printf("  %zx: %x\n", ShadowToMem(s), *(tag_t *)s);
 332 }
 333
 334 sptr __hwasan_test_shadow(const void *p, uptr sz) {
 335   if (sz == 0)
 336     return -1;
 337   tag_t ptr_tag = GetTagFromPointer((uptr)p);
 338   if (ptr_tag == 0)
 339     return -1;
 340   uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
 341   uptr shadow_first = MemToShadow(ptr_raw);
 342   uptr shadow_last = MemToShadow(ptr_raw + sz - 1);
 343   for (uptr s = shadow_first; s <= shadow_last; ++s)
 344     if (*(tag_t*)s != ptr_tag)
 345       return ShadowToMem(s) - ptr_raw;
 346   return -1;
 347 }
 348
 349 u16 __sanitizer_unaligned_load16(const uu16 *p) {
 350   return *p;
 351 }
 352 u32 __sanitizer_unaligned_load32(const uu32 *p) {
 353   return *p;
 354 }
 355 u64 __sanitizer_unaligned_load64(const uu64 *p) {
 356   return *p;
 357 }
 358 void __sanitizer_unaligned_store16(uu16 *p, u16 x) {
 359   *p = x;
 360 }
 361 void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
 362   *p = x;
 363 }
 364 void __sanitizer_unaligned_store64(uu64 *p, u64 x) {
 365   *p = x;
 366 }
 367
 368 void __hwasan_loadN(uptr p, uptr sz) {
 369   CheckAddressSized<ErrorAction::Abort, AccessType::Load>(p, sz);
 370 }
 371 void __hwasan_load1(uptr p) {
 372   CheckAddress<ErrorAction::Abort, AccessType::Load, 0>(p);
 373 }
 374 void __hwasan_load2(uptr p) {
 375   CheckAddress<ErrorAction::Abort, AccessType::Load, 1>(p);
 376 }
 377 void __hwasan_load4(uptr p) {
 378   CheckAddress<ErrorAction::Abort, AccessType::Load, 2>(p);
 379 }
 380 void __hwasan_load8(uptr p) {
 381   CheckAddress<ErrorAction::Abort, AccessType::Load, 3>(p);
 382 }
 383 void __hwasan_load16(uptr p) {
 384   CheckAddress<ErrorAction::Abort, AccessType::Load, 4>(p);
 385 }
 386
 387 void __hwasan_loadN_noabort(uptr p, uptr sz) {
 388   CheckAddressSized<ErrorAction::Recover, AccessType::Load>(p, sz);
 389 }
 390 void __hwasan_load1_noabort(uptr p) {
 391   CheckAddress<ErrorAction::Recover, AccessType::Load, 0>(p);
 392 }
 393 void __hwasan_load2_noabort(uptr p) {
 394   CheckAddress<ErrorAction::Recover, AccessType::Load, 1>(p);
 395 }
 396 void __hwasan_load4_noabort(uptr p) {
 397   CheckAddress<ErrorAction::Recover, AccessType::Load, 2>(p);
 398 }
 399 void __hwasan_load8_noabort(uptr p) {
 400   CheckAddress<ErrorAction::Recover, AccessType::Load, 3>(p);
 401 }
 402 void __hwasan_load16_noabort(uptr p) {
 403   CheckAddress<ErrorAction::Recover, AccessType::Load, 4>(p);
 404 }
 405
 406 void __hwasan_storeN(uptr p, uptr sz) {
 407   CheckAddressSized<ErrorAction::Abort, AccessType::Store>(p, sz);
 408 }
 409 void __hwasan_store1(uptr p) {
 410   CheckAddress<ErrorAction::Abort, AccessType::Store, 0>(p);
 411 }
 412 void __hwasan_store2(uptr p) {
 413   CheckAddress<ErrorAction::Abort, AccessType::Store, 1>(p);
 414 }
 415 void __hwasan_store4(uptr p) {
 416   CheckAddress<ErrorAction::Abort, AccessType::Store, 2>(p);
 417 }
 418 void __hwasan_store8(uptr p) {
 419   CheckAddress<ErrorAction::Abort, AccessType::Store, 3>(p);
 420 }
 421 void __hwasan_store16(uptr p) {
 422   CheckAddress<ErrorAction::Abort, AccessType::Store, 4>(p);
 423 }
 424
 425 void __hwasan_storeN_noabort(uptr p, uptr sz) {
 426   CheckAddressSized<ErrorAction::Recover, AccessType::Store>(p, sz);
 427 }
 428 void __hwasan_store1_noabort(uptr p) {
 429   CheckAddress<ErrorAction::Recover, AccessType::Store, 0>(p);
 430 }
 431 void __hwasan_store2_noabort(uptr p) {
 432   CheckAddress<ErrorAction::Recover, AccessType::Store, 1>(p);
 433 }
 434 void __hwasan_store4_noabort(uptr p) {
 435   CheckAddress<ErrorAction::Recover, AccessType::Store, 2>(p);
 436 }
 437 void __hwasan_store8_noabort(uptr p) {
 438   CheckAddress<ErrorAction::Recover, AccessType::Store, 3>(p);
 439 }
 440 void __hwasan_store16_noabort(uptr p) {
 441   CheckAddress<ErrorAction::Recover, AccessType::Store, 4>(p);
 442 }
 443
 444 void __hwasan_tag_memory(uptr p, u8 tag, uptr sz) {
 445   TagMemoryAligned(p, sz, tag);
 446 }
 447
 448 uptr __hwasan_tag_pointer(uptr p, u8 tag) {
 449   return AddTagToPointer(p, tag);
 450 }
 451
 452 void __hwasan_handle_longjmp(const void *sp_dst) {
 453   uptr dst = (uptr)sp_dst;
 454   // HWASan does not support tagged SP.
 455   CHECK(GetTagFromPointer(dst) == 0);
 456
 457   uptr sp = (uptr)__builtin_frame_address(0);
 458   static const uptr kMaxExpectedCleanupSize = 64 << 20;  // 64M
 459   if (dst < sp || dst - sp > kMaxExpectedCleanupSize) {
 460     Report(
 461         "WARNING: HWASan is ignoring requested __hwasan_handle_longjmp: "
 462         "stack top: %p; target %p; distance: %p (%zd)\n"
 463         "False positive error reports may follow\n",
 464         (void *)sp, (void *)dst, dst - sp);
 465     return;
 466   }
 467   TagMemory(sp, dst - sp, 0);
 468 }
 469
 470 void __hwasan_print_memory_usage() {
 471   InternalScopedString s(kMemoryUsageBufferSize);
 472   HwasanFormatMemoryUsage(s);
 473   Printf("%s\n", s.data());
 474 }
 475
 476 static const u8 kFallbackTag = 0xBB;
 477
 478 u8 __hwasan_generate_tag() {
 479   Thread *t = GetCurrentThread();
 480   if (!t) return kFallbackTag;
 481   return t->GenerateRandomTag();
 482 }
 483
 484 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 485 extern "C" {
 486 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 487 const char* __hwasan_default_options() { return ""; }
 488 }  // extern "C"
 489 #endif
 490
 491 extern "C" {
 492 SANITIZER_INTERFACE_ATTRIBUTE
 493 void __sanitizer_print_stack_trace() {
 494   GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME());
 495   stack.Print();
 496 }
 497 } // extern "C"