libsanitizer/asan/asan_descriptions.cc

   1 //===-- asan_descriptions.cc ------------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of AddressSanitizer, an address sanity checker.
   9 //
  10 // ASan functions for getting information about an address and/or printing it.
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "asan_descriptions.h"
  14 #include "asan_mapping.h"
  15 #include "asan_report.h"
  16 #include "asan_stack.h"
  17 #include "sanitizer_common/sanitizer_stackdepot.h"
  18
  19 namespace __asan {
  20
  21 // Return " (thread_name) " or an empty string if the name is empty.
  22 const char *ThreadNameWithParenthesis(AsanThreadContext *t, char buff[],
  23                                       uptr buff_len) {
  24   const char *name = t->name;
  25   if (name[0] == '\0') return "";
  26   buff[0] = 0;
  27   internal_strncat(buff, " (", 3);
  28   internal_strncat(buff, name, buff_len - 4);
  29   internal_strncat(buff, ")", 2);
  30   return buff;
  31 }
  32
  33 const char *ThreadNameWithParenthesis(u32 tid, char buff[], uptr buff_len) {
  34   if (tid == kInvalidTid) return "";
  35   asanThreadRegistry().CheckLocked();
  36   AsanThreadContext *t = GetThreadContextByTidLocked(tid);
  37   return ThreadNameWithParenthesis(t, buff, buff_len);
  38 }
  39
  40 void DescribeThread(AsanThreadContext *context) {
  41   CHECK(context);
  42   asanThreadRegistry().CheckLocked();
  43   // No need to announce the main thread.
  44   if (context->tid == 0 || context->announced) {
  45     return;
  46   }
  47   context->announced = true;
  48   char tname[128];
  49   InternalScopedString str(1024);
  50   str.append("Thread T%d%s", context->tid,
  51              ThreadNameWithParenthesis(context->tid, tname, sizeof(tname)));
  52   if (context->parent_tid == kInvalidTid) {
  53     str.append(" created by unknown thread\n");
  54     Printf("%s", str.data());
  55     return;
  56   }
  57   str.append(
  58       " created by T%d%s here:\n", context->parent_tid,
  59       ThreadNameWithParenthesis(context->parent_tid, tname, sizeof(tname)));
  60   Printf("%s", str.data());
  61   StackDepotGet(context->stack_id).Print();
  62   // Recursively described parent thread if needed.
  63   if (flags()->print_full_thread_history) {
  64     AsanThreadContext *parent_context =
  65         GetThreadContextByTidLocked(context->parent_tid);
  66     DescribeThread(parent_context);
  67   }
  68 }
  69
  70 // Shadow descriptions
  71 static bool GetShadowKind(uptr addr, ShadowKind *shadow_kind) {
  72   CHECK(!AddrIsInMem(addr));
  73   if (AddrIsInShadowGap(addr)) {
  74     *shadow_kind = kShadowKindGap;
  75   } else if (AddrIsInHighShadow(addr)) {
  76     *shadow_kind = kShadowKindHigh;
  77   } else if (AddrIsInLowShadow(addr)) {
  78     *shadow_kind = kShadowKindLow;
  79   } else {
  80     CHECK(0 && "Address is not in memory and not in shadow?");
  81     return false;
  82   }
  83   return true;
  84 }
  85
  86 bool DescribeAddressIfShadow(uptr addr) {
  87   ShadowAddressDescription descr;
  88   if (!GetShadowAddressInformation(addr, &descr)) return false;
  89   descr.Print();
  90   return true;
  91 }
  92
  93 bool GetShadowAddressInformation(uptr addr, ShadowAddressDescription *descr) {
  94   if (AddrIsInMem(addr)) return false;
  95   ShadowKind shadow_kind;
  96   if (!GetShadowKind(addr, &shadow_kind)) return false;
  97   if (shadow_kind != kShadowKindGap) descr->shadow_byte = *(u8 *)addr;
  98   descr->addr = addr;
  99   descr->kind = shadow_kind;
 100   return true;
 101 }
 102
 103 // Heap descriptions
 104 static void GetAccessToHeapChunkInformation(ChunkAccess *descr,
 105                                             AsanChunkView chunk, uptr addr,
 106                                             uptr access_size) {
 107   descr->bad_addr = addr;
 108   if (chunk.AddrIsAtLeft(addr, access_size, &descr->offset)) {
 109     descr->access_type = kAccessTypeLeft;
 110   } else if (chunk.AddrIsAtRight(addr, access_size, &descr->offset)) {
 111     descr->access_type = kAccessTypeRight;
 112     if (descr->offset < 0) {
 113       descr->bad_addr -= descr->offset;
 114       descr->offset = 0;
 115     }
 116   } else if (chunk.AddrIsInside(addr, access_size, &descr->offset)) {
 117     descr->access_type = kAccessTypeInside;
 118   } else {
 119     descr->access_type = kAccessTypeUnknown;
 120   }
 121   descr->chunk_begin = chunk.Beg();
 122   descr->chunk_size = chunk.UsedSize();
 123   descr->alloc_type = chunk.GetAllocType();
 124 }
 125
 126 static void PrintHeapChunkAccess(uptr addr, const ChunkAccess &descr) {
 127   Decorator d;
 128   InternalScopedString str(4096);
 129   str.append("%s", d.Location());
 130   switch (descr.access_type) {
 131     case kAccessTypeLeft:
 132       str.append("%p is located %zd bytes to the left of",
 133                  (void *)descr.bad_addr, descr.offset);
 134       break;
 135     case kAccessTypeRight:
 136       str.append("%p is located %zd bytes to the right of",
 137                  (void *)descr.bad_addr, descr.offset);
 138       break;
 139     case kAccessTypeInside:
 140       str.append("%p is located %zd bytes inside of", (void *)descr.bad_addr,
 141                  descr.offset);
 142       break;
 143     case kAccessTypeUnknown:
 144       str.append(
 145           "%p is located somewhere around (this is AddressSanitizer bug!)",
 146           (void *)descr.bad_addr);
 147   }
 148   str.append(" %zu-byte region [%p,%p)\n", descr.chunk_size,
 149              (void *)descr.chunk_begin,
 150              (void *)(descr.chunk_begin + descr.chunk_size));
 151   str.append("%s", d.Default());
 152   Printf("%s", str.data());
 153 }
 154
 155 bool GetHeapAddressInformation(uptr addr, uptr access_size,
 156                                HeapAddressDescription *descr) {
 157   AsanChunkView chunk = FindHeapChunkByAddress(addr);
 158   if (!chunk.IsValid()) {
 159     return false;
 160   }
 161   descr->addr = addr;
 162   GetAccessToHeapChunkInformation(&descr->chunk_access, chunk, addr,
 163                                   access_size);
 164   CHECK_NE(chunk.AllocTid(), kInvalidTid);
 165   descr->alloc_tid = chunk.AllocTid();
 166   descr->alloc_stack_id = chunk.GetAllocStackId();
 167   descr->free_tid = chunk.FreeTid();
 168   if (descr->free_tid != kInvalidTid)
 169     descr->free_stack_id = chunk.GetFreeStackId();
 170   return true;
 171 }
 172
 173 static StackTrace GetStackTraceFromId(u32 id) {
 174   CHECK(id);
 175   StackTrace res = StackDepotGet(id);
 176   CHECK(res.trace);
 177   return res;
 178 }
 179
 180 bool DescribeAddressIfHeap(uptr addr, uptr access_size) {
 181   HeapAddressDescription descr;
 182   if (!GetHeapAddressInformation(addr, access_size, &descr)) {
 183     Printf(
 184         "AddressSanitizer can not describe address in more detail "
 185         "(wild memory access suspected).\n");
 186     return false;
 187   }
 188   descr.Print();
 189   return true;
 190 }
 191
 192 // Stack descriptions
 193 bool GetStackAddressInformation(uptr addr, uptr access_size,
 194                                 StackAddressDescription *descr) {
 195   AsanThread *t = FindThreadByStackAddress(addr);
 196   if (!t) return false;
 197
 198   descr->addr = addr;
 199   descr->tid = t->tid();
 200   // Try to fetch precise stack frame for this access.
 201   AsanThread::StackFrameAccess access;
 202   if (!t->GetStackFrameAccessByAddr(addr, &access)) {
 203     descr->frame_descr = nullptr;
 204     return true;
 205   }
 206
 207   descr->offset = access.offset;
 208   descr->access_size = access_size;
 209   descr->frame_pc = access.frame_pc;
 210   descr->frame_descr = access.frame_descr;
 211
 212 #if SANITIZER_PPC64V1
 213   // On PowerPC64 ELFv1, the address of a function actually points to a
 214   // three-doubleword data structure with the first field containing
 215   // the address of the function's code.
 216   descr->frame_pc = *reinterpret_cast<uptr *>(descr->frame_pc);
 217 #endif
 218   descr->frame_pc += 16;
 219
 220   return true;
 221 }
 222
 223 static void PrintAccessAndVarIntersection(const StackVarDescr &var, uptr addr,
 224                                           uptr access_size, uptr prev_var_end,
 225                                           uptr next_var_beg) {
 226   uptr var_end = var.beg + var.size;
 227   uptr addr_end = addr + access_size;
 228   const char *pos_descr = nullptr;
 229   // If the variable [var.beg, var_end) is the nearest variable to the
 230   // current memory access, indicate it in the log.
 231   if (addr >= var.beg) {
 232     if (addr_end <= var_end)
 233       pos_descr = "is inside";  // May happen if this is a use-after-return.
 234     else if (addr < var_end)
 235       pos_descr = "partially overflows";
 236     else if (addr_end <= next_var_beg &&
 237              next_var_beg - addr_end >= addr - var_end)
 238       pos_descr = "overflows";
 239   } else {
 240     if (addr_end > var.beg)
 241       pos_descr = "partially underflows";
 242     else if (addr >= prev_var_end && addr - prev_var_end >= var.beg - addr_end)
 243       pos_descr = "underflows";
 244   }
 245   InternalScopedString str(1024);
 246   str.append("    [%zd, %zd)", var.beg, var_end);
 247   // Render variable name.
 248   str.append(" '");
 249   for (uptr i = 0; i < var.name_len; ++i) {
 250     str.append("%c", var.name_pos[i]);
 251   }
 252   str.append("'");
 253   if (var.line > 0) {
 254     str.append(" (line %d)", var.line);
 255   }
 256   if (pos_descr) {
 257     Decorator d;
 258     // FIXME: we may want to also print the size of the access here,
 259     // but in case of accesses generated by memset it may be confusing.
 260     str.append("%s <== Memory access at offset %zd %s this variable%s\n",
 261                d.Location(), addr, pos_descr, d.Default());
 262   } else {
 263     str.append("\n");
 264   }
 265   Printf("%s", str.data());
 266 }
 267
 268 bool DescribeAddressIfStack(uptr addr, uptr access_size) {
 269   StackAddressDescription descr;
 270   if (!GetStackAddressInformation(addr, access_size, &descr)) return false;
 271   descr.Print();
 272   return true;
 273 }
 274
 275 // Global descriptions
 276 static void DescribeAddressRelativeToGlobal(uptr addr, uptr access_size,
 277                                             const __asan_global &g) {
 278   InternalScopedString str(4096);
 279   Decorator d;
 280   str.append("%s", d.Location());
 281   if (addr < g.beg) {
 282     str.append("%p is located %zd bytes to the left", (void *)addr,
 283                g.beg - addr);
 284   } else if (addr + access_size > g.beg + g.size) {
 285     if (addr < g.beg + g.size) addr = g.beg + g.size;
 286     str.append("%p is located %zd bytes to the right", (void *)addr,
 287                addr - (g.beg + g.size));
 288   } else {
 289     // Can it happen?
 290     str.append("%p is located %zd bytes inside", (void *)addr, addr - g.beg);
 291   }
 292   str.append(" of global variable '%s' defined in '",
 293              MaybeDemangleGlobalName(g.name));
 294   PrintGlobalLocation(&str, g);
 295   str.append("' (0x%zx) of size %zu\n", g.beg, g.size);
 296   str.append("%s", d.Default());
 297   PrintGlobalNameIfASCII(&str, g);
 298   Printf("%s", str.data());
 299 }
 300
 301 bool GetGlobalAddressInformation(uptr addr, uptr access_size,
 302                                  GlobalAddressDescription *descr) {
 303   descr->addr = addr;
 304   int globals_num = GetGlobalsForAddress(addr, descr->globals, descr->reg_sites,
 305                                          ARRAY_SIZE(descr->globals));
 306   descr->size = globals_num;
 307   descr->access_size = access_size;
 308   return globals_num != 0;
 309 }
 310
 311 bool DescribeAddressIfGlobal(uptr addr, uptr access_size,
 312                              const char *bug_type) {
 313   GlobalAddressDescription descr;
 314   if (!GetGlobalAddressInformation(addr, access_size, &descr)) return false;
 315
 316   descr.Print(bug_type);
 317   return true;
 318 }
 319
 320 void ShadowAddressDescription::Print() const {
 321   Printf("Address %p is located in the %s area.\n", addr, ShadowNames[kind]);
 322 }
 323
 324 void GlobalAddressDescription::Print(const char *bug_type) const {
 325   for (int i = 0; i < size; i++) {
 326     DescribeAddressRelativeToGlobal(addr, access_size, globals[i]);
 327     if (bug_type &&
 328         0 == internal_strcmp(bug_type, "initialization-order-fiasco") &&
 329         reg_sites[i]) {
 330       Printf("  registered at:\n");
 331       StackDepotGet(reg_sites[i]).Print();
 332     }
 333   }
 334 }
 335
 336 void StackAddressDescription::Print() const {
 337   Decorator d;
 338   char tname[128];
 339   Printf("%s", d.Location());
 340   Printf("Address %p is located in stack of thread T%d%s", addr, tid,
 341          ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
 342
 343   if (!frame_descr) {
 344     Printf("%s\n", d.Default());
 345     return;
 346   }
 347   Printf(" at offset %zu in frame%s\n", offset, d.Default());
 348
 349   // Now we print the frame where the alloca has happened.
 350   // We print this frame as a stack trace with one element.
 351   // The symbolizer may print more than one frame if inlining was involved.
 352   // The frame numbers may be different than those in the stack trace printed
 353   // previously. That's unfortunate, but I have no better solution,
 354   // especially given that the alloca may be from entirely different place
 355   // (e.g. use-after-scope, or different thread's stack).
 356   Printf("%s", d.Default());
 357   StackTrace alloca_stack(&frame_pc, 1);
 358   alloca_stack.Print();
 359
 360   InternalMmapVector<StackVarDescr> vars(16);
 361   if (!ParseFrameDescription(frame_descr, &vars)) {
 362     Printf(
 363         "AddressSanitizer can't parse the stack frame "
 364         "descriptor: |%s|\n",
 365         frame_descr);
 366     // 'addr' is a stack address, so return true even if we can't parse frame
 367     return;
 368   }
 369   uptr n_objects = vars.size();
 370   // Report the number of stack objects.
 371   Printf("  This frame has %zu object(s):\n", n_objects);
 372
 373   // Report all objects in this frame.
 374   for (uptr i = 0; i < n_objects; i++) {
 375     uptr prev_var_end = i ? vars[i - 1].beg + vars[i - 1].size : 0;
 376     uptr next_var_beg = i + 1 < n_objects ? vars[i + 1].beg : ~(0UL);
 377     PrintAccessAndVarIntersection(vars[i], offset, access_size, prev_var_end,
 378                                   next_var_beg);
 379   }
 380   Printf(
 381       "HINT: this may be a false positive if your program uses "
 382       "some custom stack unwind mechanism or swapcontext\n");
 383   if (SANITIZER_WINDOWS)
 384     Printf("      (longjmp, SEH and C++ exceptions *are* supported)\n");
 385   else
 386     Printf("      (longjmp and C++ exceptions *are* supported)\n");
 387
 388   DescribeThread(GetThreadContextByTidLocked(tid));
 389 }
 390
 391 void HeapAddressDescription::Print() const {
 392   PrintHeapChunkAccess(addr, chunk_access);
 393
 394   asanThreadRegistry().CheckLocked();
 395   AsanThreadContext *alloc_thread = GetThreadContextByTidLocked(alloc_tid);
 396   StackTrace alloc_stack = GetStackTraceFromId(alloc_stack_id);
 397
 398   char tname[128];
 399   Decorator d;
 400   AsanThreadContext *free_thread = nullptr;
 401   if (free_tid != kInvalidTid) {
 402     free_thread = GetThreadContextByTidLocked(free_tid);
 403     Printf("%sfreed by thread T%d%s here:%s\n", d.Allocation(),
 404            free_thread->tid,
 405            ThreadNameWithParenthesis(free_thread, tname, sizeof(tname)),
 406            d.Default());
 407     StackTrace free_stack = GetStackTraceFromId(free_stack_id);
 408     free_stack.Print();
 409     Printf("%spreviously allocated by thread T%d%s here:%s\n", d.Allocation(),
 410            alloc_thread->tid,
 411            ThreadNameWithParenthesis(alloc_thread, tname, sizeof(tname)),
 412            d.Default());
 413   } else {
 414     Printf("%sallocated by thread T%d%s here:%s\n", d.Allocation(),
 415            alloc_thread->tid,
 416            ThreadNameWithParenthesis(alloc_thread, tname, sizeof(tname)),
 417            d.Default());
 418   }
 419   alloc_stack.Print();
 420   DescribeThread(GetCurrentThread());
 421   if (free_thread) DescribeThread(free_thread);
 422   DescribeThread(alloc_thread);
 423 }
 424
 425 AddressDescription::AddressDescription(uptr addr, uptr access_size,
 426                                        bool shouldLockThreadRegistry) {
 427   if (GetShadowAddressInformation(addr, &data.shadow)) {
 428     data.kind = kAddressKindShadow;
 429     return;
 430   }
 431   if (GetHeapAddressInformation(addr, access_size, &data.heap)) {
 432     data.kind = kAddressKindHeap;
 433     return;
 434   }
 435
 436   bool isStackMemory = false;
 437   if (shouldLockThreadRegistry) {
 438     ThreadRegistryLock l(&asanThreadRegistry());
 439     isStackMemory = GetStackAddressInformation(addr, access_size, &data.stack);
 440   } else {
 441     isStackMemory = GetStackAddressInformation(addr, access_size, &data.stack);
 442   }
 443   if (isStackMemory) {
 444     data.kind = kAddressKindStack;
 445     return;
 446   }
 447
 448   if (GetGlobalAddressInformation(addr, access_size, &data.global)) {
 449     data.kind = kAddressKindGlobal;
 450     return;
 451   }
 452   data.kind = kAddressKindWild;
 453   addr = 0;
 454 }
 455
 456 void PrintAddressDescription(uptr addr, uptr access_size,
 457                              const char *bug_type) {
 458   ShadowAddressDescription shadow_descr;
 459   if (GetShadowAddressInformation(addr, &shadow_descr)) {
 460     shadow_descr.Print();
 461     return;
 462   }
 463
 464   GlobalAddressDescription global_descr;
 465   if (GetGlobalAddressInformation(addr, access_size, &global_descr)) {
 466     global_descr.Print(bug_type);
 467     return;
 468   }
 469
 470   StackAddressDescription stack_descr;
 471   if (GetStackAddressInformation(addr, access_size, &stack_descr)) {
 472     stack_descr.Print();
 473     return;
 474   }
 475
 476   HeapAddressDescription heap_descr;
 477   if (GetHeapAddressInformation(addr, access_size, &heap_descr)) {
 478     heap_descr.Print();
 479     return;
 480   }
 481
 482   // We exhausted our possibilities. Bail out.
 483   Printf(
 484       "AddressSanitizer can not describe address in more detail "
 485       "(wild memory access suspected).\n");
 486 }
 487 }  // namespace __asan