1 //===-- tsan_debugging.cpp ------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of ThreadSanitizer (TSan), a race detector. 10 // 11 // TSan debugging API implementation. 12 //===----------------------------------------------------------------------===// 13 #include "tsan_interface.h" 14 #include "tsan_report.h" 15 #include "tsan_rtl.h" 16 17 #include "sanitizer_common/sanitizer_stackdepot.h" 18 19 using namespace __tsan; 20 21 static const char *ReportTypeDescription(ReportType typ) { 22 switch (typ) { 23 case ReportTypeRace: return "data-race"; 24 case ReportTypeVptrRace: return "data-race-vptr"; 25 case ReportTypeUseAfterFree: return "heap-use-after-free"; 26 case ReportTypeVptrUseAfterFree: return "heap-use-after-free-vptr"; 27 case ReportTypeExternalRace: return "external-race"; 28 case ReportTypeThreadLeak: return "thread-leak"; 29 case ReportTypeMutexDestroyLocked: return "locked-mutex-destroy"; 30 case ReportTypeMutexDoubleLock: return "mutex-double-lock"; 31 case ReportTypeMutexInvalidAccess: return "mutex-invalid-access"; 32 case ReportTypeMutexBadUnlock: return "mutex-bad-unlock"; 33 case ReportTypeMutexBadReadLock: return "mutex-bad-read-lock"; 34 case ReportTypeMutexBadReadUnlock: return "mutex-bad-read-unlock"; 35 case ReportTypeSignalUnsafe: return "signal-unsafe-call"; 36 case ReportTypeErrnoInSignal: return "errno-in-signal-handler"; 37 case ReportTypeDeadlock: return "lock-order-inversion"; 38 // No default case so compiler warns us if we miss one 39 } 40 UNREACHABLE("missing case"); 41 } 42 43 static const char *ReportLocationTypeDescription(ReportLocationType typ) { 44 switch (typ) { 45 case ReportLocationGlobal: return "global"; 46 case ReportLocationHeap: return "heap"; 47 case ReportLocationStack: return "stack"; 48 case ReportLocationTLS: return "tls"; 49 case ReportLocationFD: return "fd"; 50 // No default case so compiler warns us if we miss one 51 } 52 UNREACHABLE("missing case"); 53 } 54 55 static void CopyTrace(SymbolizedStack *first_frame, void **trace, 56 uptr trace_size) { 57 uptr i = 0; 58 for (SymbolizedStack *frame = first_frame; frame != nullptr; 59 frame = frame->next) { 60 trace[i++] = (void *)frame->info.address; 61 if (i >= trace_size) break; 62 } 63 } 64 65 // Meant to be called by the debugger. 66 SANITIZER_INTERFACE_ATTRIBUTE 67 void *__tsan_get_current_report() { 68 return const_cast<ReportDesc*>(cur_thread()->current_report); 69 } 70 71 SANITIZER_INTERFACE_ATTRIBUTE 72 int __tsan_get_report_data(void *report, const char **description, int *count, 73 int *stack_count, int *mop_count, int *loc_count, 74 int *mutex_count, int *thread_count, 75 int *unique_tid_count, void **sleep_trace, 76 uptr trace_size) { 77 const ReportDesc *rep = (ReportDesc *)report; 78 *description = ReportTypeDescription(rep->typ); 79 *count = rep->count; 80 *stack_count = rep->stacks.Size(); 81 *mop_count = rep->mops.Size(); 82 *loc_count = rep->locs.Size(); 83 *mutex_count = rep->mutexes.Size(); 84 *thread_count = rep->threads.Size(); 85 *unique_tid_count = rep->unique_tids.Size(); 86 if (rep->sleep) CopyTrace(rep->sleep->frames, sleep_trace, trace_size); 87 return 1; 88 } 89 90 SANITIZER_INTERFACE_ATTRIBUTE 91 int __tsan_get_report_tag(void *report, uptr *tag) { 92 const ReportDesc *rep = (ReportDesc *)report; 93 *tag = rep->tag; 94 return 1; 95 } 96 97 SANITIZER_INTERFACE_ATTRIBUTE 98 int __tsan_get_report_stack(void *report, uptr idx, void **trace, 99 uptr trace_size) { 100 const ReportDesc *rep = (ReportDesc *)report; 101 CHECK_LT(idx, rep->stacks.Size()); 102 ReportStack *stack = rep->stacks[idx]; 103 if (stack) CopyTrace(stack->frames, trace, trace_size); 104 return stack ? 1 : 0; 105 } 106 107 SANITIZER_INTERFACE_ATTRIBUTE 108 int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 109 int *size, int *write, int *atomic, void **trace, 110 uptr trace_size) { 111 const ReportDesc *rep = (ReportDesc *)report; 112 CHECK_LT(idx, rep->mops.Size()); 113 ReportMop *mop = rep->mops[idx]; 114 *tid = mop->tid; 115 *addr = (void *)mop->addr; 116 *size = mop->size; 117 *write = mop->write ? 1 : 0; 118 *atomic = mop->atomic ? 1 : 0; 119 if (mop->stack) CopyTrace(mop->stack->frames, trace, trace_size); 120 return 1; 121 } 122 123 SANITIZER_INTERFACE_ATTRIBUTE 124 int __tsan_get_report_loc(void *report, uptr idx, const char **type, 125 void **addr, uptr *start, uptr *size, int *tid, 126 int *fd, int *suppressable, void **trace, 127 uptr trace_size) { 128 const ReportDesc *rep = (ReportDesc *)report; 129 CHECK_LT(idx, rep->locs.Size()); 130 ReportLocation *loc = rep->locs[idx]; 131 *type = ReportLocationTypeDescription(loc->type); 132 *addr = (void *)loc->global.start; 133 *start = loc->heap_chunk_start; 134 *size = loc->heap_chunk_size; 135 *tid = loc->tid; 136 *fd = loc->fd; 137 *suppressable = loc->suppressable; 138 if (loc->stack) CopyTrace(loc->stack->frames, trace, trace_size); 139 return 1; 140 } 141 142 SANITIZER_INTERFACE_ATTRIBUTE 143 int __tsan_get_report_loc_object_type(void *report, uptr idx, 144 const char **object_type) { 145 const ReportDesc *rep = (ReportDesc *)report; 146 CHECK_LT(idx, rep->locs.Size()); 147 ReportLocation *loc = rep->locs[idx]; 148 *object_type = GetObjectTypeFromTag(loc->external_tag); 149 return 1; 150 } 151 152 SANITIZER_INTERFACE_ATTRIBUTE 153 int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 154 int *destroyed, void **trace, uptr trace_size) { 155 const ReportDesc *rep = (ReportDesc *)report; 156 CHECK_LT(idx, rep->mutexes.Size()); 157 ReportMutex *mutex = rep->mutexes[idx]; 158 *mutex_id = mutex->id; 159 *addr = (void *)mutex->addr; 160 *destroyed = false; 161 if (mutex->stack) CopyTrace(mutex->stack->frames, trace, trace_size); 162 return 1; 163 } 164 165 SANITIZER_INTERFACE_ATTRIBUTE 166 int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id, 167 int *running, const char **name, int *parent_tid, 168 void **trace, uptr trace_size) { 169 const ReportDesc *rep = (ReportDesc *)report; 170 CHECK_LT(idx, rep->threads.Size()); 171 ReportThread *thread = rep->threads[idx]; 172 *tid = thread->id; 173 *os_id = thread->os_id; 174 *running = thread->running; 175 *name = thread->name; 176 *parent_tid = thread->parent_tid; 177 if (thread->stack) CopyTrace(thread->stack->frames, trace, trace_size); 178 return 1; 179 } 180 181 SANITIZER_INTERFACE_ATTRIBUTE 182 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid) { 183 const ReportDesc *rep = (ReportDesc *)report; 184 CHECK_LT(idx, rep->unique_tids.Size()); 185 *tid = rep->unique_tids[idx]; 186 return 1; 187 } 188 189 SANITIZER_INTERFACE_ATTRIBUTE 190 const char *__tsan_locate_address(uptr addr, char *name, uptr name_size, 191 uptr *region_address_ptr, 192 uptr *region_size_ptr) { 193 uptr region_address = 0; 194 uptr region_size = 0; 195 const char *region_kind = nullptr; 196 if (name && name_size > 0) name[0] = 0; 197 198 if (IsMetaMem(reinterpret_cast<u32 *>(addr))) { 199 region_kind = "meta shadow"; 200 } else if (IsShadowMem(reinterpret_cast<RawShadow *>(addr))) { 201 region_kind = "shadow"; 202 } else { 203 bool is_stack = false; 204 MBlock *b = 0; 205 Allocator *a = allocator(); 206 if (a->PointerIsMine((void *)addr)) { 207 void *block_begin = a->GetBlockBegin((void *)addr); 208 if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin); 209 } 210 211 if (b != 0) { 212 region_address = (uptr)allocator()->GetBlockBegin((void *)addr); 213 region_size = b->siz; 214 region_kind = "heap"; 215 } else { 216 // TODO(kuba.brecka): We should not lock. This is supposed to be called 217 // from within the debugger when other threads are stopped. 218 ctx->thread_registry.Lock(); 219 ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack); 220 ctx->thread_registry.Unlock(); 221 if (tctx) { 222 region_kind = is_stack ? "stack" : "tls"; 223 } else { 224 region_kind = "global"; 225 DataInfo info; 226 if (Symbolizer::GetOrInit()->SymbolizeData(addr, &info)) { 227 internal_strncpy(name, info.name, name_size); 228 region_address = info.start; 229 region_size = info.size; 230 } 231 } 232 } 233 } 234 235 CHECK(region_kind); 236 if (region_address_ptr) *region_address_ptr = region_address; 237 if (region_size_ptr) *region_size_ptr = region_size; 238 return region_kind; 239 } 240 241 SANITIZER_INTERFACE_ATTRIBUTE 242 int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id, 243 tid_t *os_id) { 244 MBlock *b = 0; 245 Allocator *a = allocator(); 246 if (a->PointerIsMine((void *)addr)) { 247 void *block_begin = a->GetBlockBegin((void *)addr); 248 if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin); 249 } 250 if (b == 0) return 0; 251 252 *thread_id = b->tid; 253 // No locking. This is supposed to be called from within the debugger when 254 // other threads are stopped. 255 ThreadContextBase *tctx = ctx->thread_registry.GetThreadLocked(b->tid); 256 *os_id = tctx->os_id; 257 258 StackTrace stack = StackDepotGet(b->stk); 259 size = Min(size, (uptr)stack.size); 260 for (uptr i = 0; i < size; i++) trace[i] = stack.trace[stack.size - i - 1]; 261 return size; 262 } 263