reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

  562 extern Context *ctx;  // The one and the only global runtime context.

References

 4825   COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name);

   91   ClockBlock *cb = ctx->clock_alloc.Map(idx);
  103     ctx->clock_alloc.Free(c, cb->table[ClockBlock::kBlockIdx - i]);
  104   ctx->clock_alloc.Free(c, idx);
  248     dst->tab_ = ctx->clock_alloc.Map(cached_idx_);
  416     tab_idx_ = ctx->clock_alloc.Alloc(c);
  417     tab_ = ctx->clock_alloc.Map(tab_idx_);
  422     u32 idx = ctx->clock_alloc.Alloc(c);
  423     ClockBlock *new_cb = ctx->clock_alloc.Map(idx);
  436     u32 idx = ctx->clock_alloc.Alloc(c);
  437     ClockBlock *cb = ctx->clock_alloc.Map(idx);
  521   ClockBlock *cb = ctx->clock_alloc.Map(idx);
  581     ClockBlock *cb = ctx->clock_alloc.Map(idx);

  208       if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);
  218       ctx->thread_registry->Lock();
  220       ctx->thread_registry->Unlock();
  248     if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);
  255   ThreadContextBase *tctx = ctx->thread_registry->GetThreadLocked(b->tid);

  104     if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);

  966   if (ctx->after_multithreaded_fork) {
 1891   if (!ctx->after_multithreaded_fork) {
 1911   if (!ctx->after_multithreaded_fork) {
 1930     ThreadRegistryLock l(ctx->thread_registry);
 1932     if (!IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack)) {

  309       ctx->nmissed_expected++;

  233   SyncVar *s = ctx->metamap.GetIfExistsAndLock((uptr)a, false);
  271   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, true);
  285     s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, true);
  410     s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, write_lock);

  113   ctx->metamap.FreeRange(thr->proc(), ptr, size);
  133   ctx->metamap.MoveMemory(src, dst, size);
  160     MBlock *b = ctx->metamap.GetBlock(from);

  145   if (IsFiredSuppression(ctx, ReportTypeSignalUnsafe, stack))
  147   ThreadRegistryLock l(ctx->thread_registry);
  171   if (ctx && ctx->initialized)
  171   if (ctx && ctx->initialized)
  180   if (ctx && ctx->initialized)
  180   if (ctx && ctx->initialized)
  216   ctx->metamap.AllocBlock(thr, pc, p, sz);
  225   uptr sz = ctx->metamap.FreeBlock(thr->proc(), p);
  309   MBlock *b = ctx->metamap.GetBlock((uptr)p);
  319   if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
  319   if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
  327   if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
  327   if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
  394   ctx->metamap.OnProcIdle(thr->proc());

  178       atomic_load(&ctx->stop_background_thread, memory_order_relaxed) == 0;
  209       MemoryProfiler(ctx, mprof_fd, i);
  213       u64 last = atomic_load(&ctx->last_symbolize_time_ns,
  216         Lock l(&ctx->report_mtx);
  219         atomic_store(&ctx->last_symbolize_time_ns, 0, memory_order_relaxed);
  226   ctx->background_thread = internal_start_thread(&BackgroundThread, 0);
  231   atomic_store(&ctx->stop_background_thread, 1, memory_order_relaxed);
  232   internal_join_thread(ctx->background_thread);
  233   ctx->background_thread = 0;
  247   ctx->metamap.ResetRange(thr->proc(), addr, size);
  362   ctx = new(ctx_placeholder) Context;
  367   InitializeFlags(&ctx->flags, options, env_name);
  380     ctx->dd = DDetector::Create(flags());
  411   ctx->initialized = true;
  451   ctx->report_mtx.Lock();
  453   ctx->report_mtx.Unlock();
  461   if (ctx->nreported) {
  464     Printf("ThreadSanitizer: reported %d warnings\n", ctx->nreported);
  470   if (ctx->nmissed_expected) {
  473         ctx->nmissed_expected);
  495   ctx->thread_registry->Lock();
  496   ctx->report_mtx.Lock();
  500   ctx->report_mtx.Unlock();
  501   ctx->thread_registry->Unlock();
  505   ctx->report_mtx.Unlock();
  506   ctx->thread_registry->Unlock();
  509   ctx->thread_registry->GetNumberOfThreads(0, 0, &nthread /* alive threads */);
  518     ctx->after_multithreaded_fork = true;
  563   if (ctx->after_multithreaded_fork)
 1051   if (save_stack && !ctx->after_multithreaded_fork)
 1081   if (save_stack && !ctx->after_multithreaded_fork)

  565   return &ctx->flags;

   44   ctx->dd->MutexInit(&cb, &s->dd);
   54   ThreadRegistryLock l(ctx->thread_registry);
   73   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
   83   SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr, true);
   95     ctx->dd->MutexDestroy(&cb, &s->dd);
   96     ctx->dd->MutexInit(&cb, &s->dd);
  111     ThreadRegistryLock l(ctx->thread_registry);
  123     SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr, true);
  145     SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false);
  149       ctx->dd->MutexBeforeLock(&cb, &s->dd, true);
  151       ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  167   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  198       ctx->dd->MutexBeforeLock(&cb, &s->dd, true);
  199     ctx->dd->MutexAfterLock(&cb, &s->dd, true, flagz & MutexFlagTryLock);
  209     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  217   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  242     ctx->dd->MutexBeforeUnlock(&cb, &s->dd, true);
  251     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  259     SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false);
  262     ctx->dd->MutexBeforeLock(&cb, &s->dd, false);
  264     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  273   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false);
  293       ctx->dd->MutexBeforeLock(&cb, &s->dd, false);
  294     ctx->dd->MutexAfterLock(&cb, &s->dd, false, flagz & MutexFlagTryLock);
  304     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  313   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  326     ctx->dd->MutexBeforeUnlock(&cb, &s->dd, false);
  336     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  344   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  374     ctx->dd->MutexBeforeUnlock(&cb, &s->dd, write);
  383     ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
  389   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  397   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  407   SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr, false);
  427   ThreadRegistryLock l(ctx->thread_registry);
  428   ctx->thread_registry->RunCallbackForEachThreadLocked(
  436   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  448   SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
  471   ThreadRegistryLock l(ctx->thread_registry);
  472   ctx->thread_registry->RunCallbackForEachThreadLocked(
  516   ThreadRegistryLock l(ctx->thread_registry);

   29     proc->dd_pt = ctx->dd->CreatePhysicalThread();
   38   ctx->clock_alloc.FlushCache(&proc->clock_cache);
   39   ctx->metamap.OnProcIdle(proc);
   41      ctx->dd->DestroyPhysicalThread(proc->dd_pt);

  146   ctx->thread_registry->CheckLocked();
  151   ctx->report_mtx.Lock();
  155   ctx->report_mtx.Unlock();
  219   ctx->thread_registry->CheckLocked();
  221       ctx->thread_registry->FindThreadContextLocked(
  226   ctx->thread_registry->CheckLocked();
  228       ctx->thread_registry->GetThreadLocked(tid));
  243   ctx->thread_registry->CheckLocked();
  245       ctx->thread_registry->FindThreadContextLocked(IsInStackOrTls,
  281   SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr, true);
  333       b = ctx->metamap.GetBlock((uptr)block_begin);
  449     ReadLock lock(&ctx->racy_mtx);
  453       for (uptr i = 0; i < ctx->racy_stacks.Size(); i++) {
  454         if (hash == ctx->racy_stacks[i]) {
  463       for (uptr i = 0; i < ctx->racy_addresses.Size(); i++) {
  464         RacyAddress ra2 = ctx->racy_addresses[i];
  478     Lock lock(&ctx->racy_mtx);
  479     ctx->racy_stacks.PushBack(hash);
  482     Lock lock(&ctx->racy_mtx);
  483     ctx->racy_addresses.PushBack(ra0);
  490   Lock lock(&ctx->racy_mtx);
  495     ctx->racy_stacks.PushBack(hash);
  499     ctx->racy_addresses.PushBack(ra0);
  506   atomic_store_relaxed(&ctx->last_symbolize_time_ns, NanoTime());
  521     Lock lock(&ctx->fired_suppressions_mtx);
  523     ctx->fired_suppressions.push_back(s);
  537   ctx->nreported++;
  630   if (IsFiredSuppression(ctx, typ, addr))
  658   if (IsFiredSuppression(ctx, typ, traces[0]))
  668   if (IsFiredSuppression(ctx, typ, traces[1]))
  684   ThreadRegistryLock l0(ctx->thread_registry);
  695         ctx->thread_registry->GetThreadLocked(s.tid()));

   95   new(thr) ThreadState(ctx, tid, unique_id, epoch0, reuse_count,
  110     thr->dd_lt = ctx->dd->CreateLogicalThread(unique_id);
  143     ctx->dd->DestroyLogicalThread(thr->dd_lt);
  196   if (ctx->after_multithreaded_fork)
  212   ThreadRegistryLock l(ctx->thread_registry);
  214   ctx->thread_registry->RunCallbackForEachThreadLocked(
  227   ctx->thread_registry->GetNumberOfThreads(0, 0, &result);
  236       ctx->thread_registry->CreateThread(uid, detached, parent_tid, &args);
  238   StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads());
  260   ThreadRegistry *tr = ctx->thread_registry;
  269   if (ctx->after_multithreaded_fork) {
  285   ctx->thread_registry->FinishThread(thr->tid);
  298   int res = ctx->thread_registry->FindThread(FindThreadByUid, (void*)uid);
  307   ctx->thread_registry->JoinThread(tid, thr);
  313   ctx->thread_registry->DetachThread(tid, thr);
  319   ctx->thread_registry->SetThreadUserId(tid, uid);
  323   ctx->thread_registry->SetThreadName(thr->tid, name);