compiler-rt/lib/tsan/go/tsan_go.cpp

   1 //===-- tsan_go.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 // ThreadSanitizer runtime for Go language.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "tsan_rtl.h"
  14 #include "tsan_symbolize.h"
  15 #include "sanitizer_common/sanitizer_common.h"
  16 #include <stdlib.h>
  17
  18 namespace __tsan {
  19
  20 void InitializeInterceptors() {
  21 }
  22
  23 void InitializeDynamicAnnotations() {
  24 }
  25
  26 bool IsExpectedReport(uptr addr, uptr size) {
  27   return false;
  28 }
  29
  30 void *Alloc(uptr sz) { return InternalAlloc(sz); }
  31
  32 void FreeImpl(void *p) { InternalFree(p); }
  33
  34 // Callback into Go.
  35 static void (*go_runtime_cb)(uptr cmd, void *ctx);
  36
  37 enum {
  38   CallbackGetProc = 0,
  39   CallbackSymbolizeCode = 1,
  40   CallbackSymbolizeData = 2,
  41 };
  42
  43 struct SymbolizeCodeContext {
  44   uptr pc;
  45   char *func;
  46   char *file;
  47   uptr line;
  48   uptr off;
  49   uptr res;
  50 };
  51
  52 SymbolizedStack *SymbolizeCode(uptr addr) {
  53   SymbolizedStack *first = SymbolizedStack::New(addr);
  54   SymbolizedStack *s = first;
  55   for (;;) {
  56     SymbolizeCodeContext cbctx;
  57     internal_memset(&cbctx, 0, sizeof(cbctx));
  58     cbctx.pc = addr;
  59     go_runtime_cb(CallbackSymbolizeCode, &cbctx);
  60     if (cbctx.res == 0)
  61       break;
  62     AddressInfo &info = s->info;
  63     info.module_offset = cbctx.off;
  64     info.function = internal_strdup(cbctx.func ? cbctx.func : "??");
  65     info.file = internal_strdup(cbctx.file ? cbctx.file : "-");
  66     info.line = cbctx.line;
  67     info.column = 0;
  68
  69     if (cbctx.pc == addr) // outermost (non-inlined) function
  70       break;
  71     addr = cbctx.pc;
  72     // Allocate a stack entry for the parent of the inlined function.
  73     SymbolizedStack *s2 = SymbolizedStack::New(addr);
  74     s->next = s2;
  75     s = s2;
  76   }
  77   return first;
  78 }
  79
  80 struct SymbolizeDataContext {
  81   uptr addr;
  82   uptr heap;
  83   uptr start;
  84   uptr size;
  85   char *name;
  86   char *file;
  87   uptr line;
  88   uptr res;
  89 };
  90
  91 ReportLocation *SymbolizeData(uptr addr) {
  92   SymbolizeDataContext cbctx;
  93   internal_memset(&cbctx, 0, sizeof(cbctx));
  94   cbctx.addr = addr;
  95   go_runtime_cb(CallbackSymbolizeData, &cbctx);
  96   if (!cbctx.res)
  97     return 0;
  98   if (cbctx.heap) {
  99     MBlock *b = ctx->metamap.GetBlock(cbctx.start);
 100     if (!b)
 101       return 0;
 102     auto *loc = New<ReportLocation>();
 103     loc->type = ReportLocationHeap;
 104     loc->heap_chunk_start = cbctx.start;
 105     loc->heap_chunk_size = b->siz;
 106     loc->tid = b->tid;
 107     loc->stack = SymbolizeStackId(b->stk);
 108     return loc;
 109   } else {
 110     auto *loc = New<ReportLocation>();
 111     loc->type = ReportLocationGlobal;
 112     loc->global.name = internal_strdup(cbctx.name ? cbctx.name : "??");
 113     loc->global.file = internal_strdup(cbctx.file ? cbctx.file : "??");
 114     loc->global.line = cbctx.line;
 115     loc->global.start = cbctx.start;
 116     loc->global.size = cbctx.size;
 117     return loc;
 118   }
 119 }
 120
 121 static ThreadState *main_thr;
 122 static bool inited;
 123
 124 static Processor* get_cur_proc() {
 125   if (UNLIKELY(!inited)) {
 126     // Running Initialize().
 127     // We have not yet returned the Processor to Go, so we cannot ask it back.
 128     // Currently, Initialize() does not use the Processor, so return nullptr.
 129     return nullptr;
 130   }
 131   Processor *proc;
 132   go_runtime_cb(CallbackGetProc, &proc);
 133   return proc;
 134 }
 135
 136 Processor *ThreadState::proc() {
 137   return get_cur_proc();
 138 }
 139
 140 extern "C" {
 141
 142 static ThreadState *AllocGoroutine() {
 143   auto *thr = (ThreadState *)Alloc(sizeof(ThreadState));
 144   internal_memset(thr, 0, sizeof(*thr));
 145   return thr;
 146 }
 147
 148 void __tsan_init(ThreadState **thrp, Processor **procp,
 149                  void (*cb)(uptr cmd, void *cb)) {
 150   go_runtime_cb = cb;
 151   ThreadState *thr = AllocGoroutine();
 152   main_thr = *thrp = thr;
 153   Initialize(thr);
 154   *procp = thr->proc1;
 155   inited = true;
 156 }
 157
 158 void __tsan_fini() {
 159   // FIXME: Not necessary thread 0.
 160   ThreadState *thr = main_thr;
 161   int res = Finalize(thr);
 162   exit(res);
 163 }
 164
 165 void __tsan_map_shadow(uptr addr, uptr size) {
 166   MapShadow(addr, size);
 167 }
 168
 169 void __tsan_read(ThreadState *thr, void *addr, void *pc) {
 170   MemoryAccess(thr, (uptr)pc, (uptr)addr, 1, kAccessRead);
 171 }
 172
 173 void __tsan_read_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
 174   if (callpc != 0)
 175     FuncEntry(thr, callpc);
 176   MemoryAccess(thr, (uptr)pc, (uptr)addr, 1, kAccessRead);
 177   if (callpc != 0)
 178     FuncExit(thr);
 179 }
 180
 181 void __tsan_write(ThreadState *thr, void *addr, void *pc) {
 182   MemoryAccess(thr, (uptr)pc, (uptr)addr, 1, kAccessWrite);
 183 }
 184
 185 void __tsan_write_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
 186   if (callpc != 0)
 187     FuncEntry(thr, callpc);
 188   MemoryAccess(thr, (uptr)pc, (uptr)addr, 1, kAccessWrite);
 189   if (callpc != 0)
 190     FuncExit(thr);
 191 }
 192
 193 void __tsan_read_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
 194   MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, false);
 195 }
 196
 197 void __tsan_write_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
 198   MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, true);
 199 }
 200
 201 void __tsan_func_enter(ThreadState *thr, void *pc) {
 202   FuncEntry(thr, (uptr)pc);
 203 }
 204
 205 void __tsan_func_exit(ThreadState *thr) {
 206   FuncExit(thr);
 207 }
 208
 209 void __tsan_malloc(ThreadState *thr, uptr pc, uptr p, uptr sz) {
 210   CHECK(inited);
 211   if (thr && pc)
 212     ctx->metamap.AllocBlock(thr, pc, p, sz);
 213   MemoryResetRange(thr, pc, (uptr)p, sz);
 214 }
 215
 216 void __tsan_free(uptr p, uptr sz) {
 217   ctx->metamap.FreeRange(get_cur_proc(), p, sz, false);
 218 }
 219
 220 void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
 221   ThreadState *thr = AllocGoroutine();
 222   *pthr = thr;
 223   Tid goid = ThreadCreate(parent, (uptr)pc, 0, true);
 224   ThreadStart(thr, goid, 0, ThreadType::Regular);
 225 }
 226
 227 void __tsan_go_end(ThreadState *thr) {
 228   ThreadFinish(thr);
 229   Free(thr);
 230 }
 231
 232 void __tsan_proc_create(Processor **pproc) {
 233   *pproc = ProcCreate();
 234 }
 235
 236 void __tsan_proc_destroy(Processor *proc) {
 237   ProcDestroy(proc);
 238 }
 239
 240 void __tsan_acquire(ThreadState *thr, void *addr) {
 241   Acquire(thr, 0, (uptr)addr);
 242 }
 243
 244 void __tsan_release_acquire(ThreadState *thr, void *addr) {
 245   ReleaseStoreAcquire(thr, 0, (uptr)addr);
 246 }
 247
 248 void __tsan_release(ThreadState *thr, void *addr) {
 249   ReleaseStore(thr, 0, (uptr)addr);
 250 }
 251
 252 void __tsan_release_merge(ThreadState *thr, void *addr) {
 253   Release(thr, 0, (uptr)addr);
 254 }
 255
 256 void __tsan_finalizer_goroutine(ThreadState *thr) { AcquireGlobal(thr); }
 257
 258 void __tsan_mutex_before_lock(ThreadState *thr, uptr addr, uptr write) {
 259   if (write)
 260     MutexPreLock(thr, 0, addr);
 261   else
 262     MutexPreReadLock(thr, 0, addr);
 263 }
 264
 265 void __tsan_mutex_after_lock(ThreadState *thr, uptr addr, uptr write) {
 266   if (write)
 267     MutexPostLock(thr, 0, addr);
 268   else
 269     MutexPostReadLock(thr, 0, addr);
 270 }
 271
 272 void __tsan_mutex_before_unlock(ThreadState *thr, uptr addr, uptr write) {
 273   if (write)
 274     MutexUnlock(thr, 0, addr);
 275   else
 276     MutexReadUnlock(thr, 0, addr);
 277 }
 278
 279 void __tsan_go_ignore_sync_begin(ThreadState *thr) {
 280   ThreadIgnoreSyncBegin(thr, 0);
 281 }
 282
 283 void __tsan_go_ignore_sync_end(ThreadState *thr) { ThreadIgnoreSyncEnd(thr); }
 284
 285 void __tsan_report_count(u64 *pn) {
 286   Lock lock(&ctx->report_mtx);
 287   *pn = ctx->nreported;
 288 }
 289
 290 }  // extern "C"
 291 }  // namespace __tsan