Lines Matching defs:thr
25 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r);
26 void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,
30 ThreadState *thr;
33 Callback(ThreadState *thr, uptr pc)
34 : thr(thr)
36 DDCallback::pt = thr->proc()->dd_pt;
37 DDCallback::lt = thr->dd_lt;
40 StackID Unwind() override { return CurrentStackId(thr, pc); }
41 int UniqueTid() override { return thr->tid; }
44 void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s) {
45 Callback cb(thr, pc);
50 static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,
56 if (!ShouldReport(thr, typ))
62 ObtainCurrentStack(thr, pc, &trace);
65 OutputReport(thr, rep);
68 static void RecordMutexLock(ThreadState *thr, uptr pc, uptr addr,
76 TraceMutexLock(thr, typ, pc, addr, stack_id);
77 thr->mset.AddAddr(addr, stack_id, write);
80 static void RecordMutexUnlock(ThreadState *thr, uptr addr) {
82 TraceMutexUnlock(thr, addr);
83 thr->mset.DelAddr(addr);
86 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
87 DPrintf("#%d: MutexCreate %zx flagz=0x%x\n", thr->tid, addr, flagz);
89 MemoryAccess(thr, pc, addr, 1, kAccessWrite);
90 SlotLocker locker(thr);
91 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
95 s->creation_stack_id = CurrentStackId(thr, pc);
98 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
99 DPrintf("#%d: MutexDestroy %zx\n", thr->tid, addr);
107 SlotLocker locker(thr);
118 Callback cb(thr, pc);
131 MemoryAccess(thr, pc, addr, 1,
134 if (unlock_locked && ShouldReport(thr, ReportTypeMutexDestroyLocked))
135 ReportDestroyLocked(thr, pc, addr, last_lock, creation_stack_id);
136 thr->mset.DelAddr(addr, true);
140 void MutexPreLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
141 DPrintf("#%d: MutexPreLock %zx flagz=0x%x\n", thr->tid, addr, flagz);
146 Callback cb(thr, pc);
148 SlotLocker locker(thr);
149 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
152 if (s->owner_tid != thr->tid)
155 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
158 void MutexPostLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz, int rec) {
160 thr->tid, addr, flagz, rec);
166 MemoryAccess(thr, pc, addr, 1, kAccessRead | kAccessAtomic);
172 SlotLocker locker(thr);
173 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
175 RecordMutexLock(thr, pc, addr, creation_stack_id, true);
182 s->owner_tid = thr->tid;
183 s->last_lock = thr->fast_state;
184 } else if (s->owner_tid == thr->tid) {
192 if (!thr->ignore_sync) {
193 thr->clock.Acquire(s->clock);
194 thr->clock.Acquire(s->read_clock);
200 Callback cb(thr, pc);
208 ReportMutexMisuse(thr, pc, ReportTypeMutexDoubleLock, addr,
211 Callback cb(thr, pc);
212 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
216 int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
217 DPrintf("#%d: MutexUnlock %zx flagz=0x%x\n", thr->tid, addr, flagz);
219 MemoryAccess(thr, pc, addr, 1, kAccessRead | kAccessAtomic);
221 RecordMutexUnlock(thr, addr);
225 SlotLocker locker(thr);
226 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
231 if (!SANITIZER_GO && (s->recursion == 0 || s->owner_tid != thr->tid)) {
241 if (!thr->ignore_sync) {
242 thr->clock.ReleaseStore(&s->clock);
249 Callback cb(thr, pc);
254 IncrementEpoch(thr);
257 ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr,
260 Callback cb(thr, pc);
261 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
266 void MutexPreReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
267 DPrintf("#%d: MutexPreReadLock %zx flagz=0x%x\n", thr->tid, addr, flagz);
270 Callback cb(thr, pc);
272 SlotLocker locker(thr);
273 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
278 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
281 void MutexPostReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
282 DPrintf("#%d: MutexPostReadLock %zx flagz=0x%x\n", thr->tid, addr, flagz);
284 MemoryAccess(thr, pc, addr, 1, kAccessRead | kAccessAtomic);
289 SlotLocker locker(thr);
290 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
292 RecordMutexLock(thr, pc, addr, creation_stack_id, false);
302 if (!thr->ignore_sync)
303 thr->clock.Acquire(s->clock);
304 s->last_lock = thr->fast_state;
308 Callback cb(thr, pc);
316 ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadLock, addr,
319 Callback cb(thr, pc);
320 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
324 void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr) {
325 DPrintf("#%d: MutexReadUnlock %zx\n", thr->tid, addr);
327 MemoryAccess(thr, pc, addr, 1, kAccessRead | kAccessAtomic);
328 RecordMutexUnlock(thr, addr);
332 SlotLocker locker(thr);
333 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
344 if (!thr->ignore_sync) {
345 thr->clock.Release(&s->read_clock);
349 Callback cb(thr, pc);
354 IncrementEpoch(thr);
357 ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadUnlock, addr,
360 Callback cb(thr, pc);
361 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
365 void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr) {
366 DPrintf("#%d: MutexReadOrWriteUnlock %zx\n", thr->tid, addr);
368 MemoryAccess(thr, pc, addr, 1, kAccessRead | kAccessAtomic);
369 RecordMutexUnlock(thr, addr);
374 SlotLocker locker(thr);
375 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
383 if (!thr->ignore_sync) {
384 thr->clock.Release(&s->read_clock);
387 } else if (s->owner_tid == thr->tid) {
393 if (!thr->ignore_sync) {
394 thr->clock.ReleaseStore(&s->clock);
403 Callback cb(thr, pc);
408 IncrementEpoch(thr);
411 ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr,
414 Callback cb(thr, pc);
415 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
419 void MutexRepair(ThreadState *thr, uptr pc, uptr addr) {
420 DPrintf("#%d: MutexRepair %zx\n", thr->tid, addr);
421 SlotLocker locker(thr);
422 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
428 void MutexInvalidAccess(ThreadState *thr, uptr pc, uptr addr) {
429 DPrintf("#%d: MutexInvalidAccess %zx\n", thr->tid, addr);
432 SlotLocker locker(thr);
433 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, true);
437 ReportMutexMisuse(thr, pc, ReportTypeMutexInvalidAccess, addr,
441 void Acquire(ThreadState *thr, uptr pc, uptr addr) {
442 DPrintf("#%d: Acquire %zx\n", thr->tid, addr);
443 if (thr->ignore_sync)
448 SlotLocker locker(thr);
452 thr->clock.Acquire(s->clock);
455 void AcquireGlobal(ThreadState *thr) {
456 DPrintf("#%d: AcquireGlobal\n", thr->tid);
457 if (thr->ignore_sync)
459 SlotLocker locker(thr);
460 for (auto &slot : ctx->slots) thr->clock.Set(slot.sid, slot.epoch());
463 void Release(ThreadState *thr, uptr pc, uptr addr) {
464 DPrintf("#%d: Release %zx\n", thr->tid, addr);
465 if (thr->ignore_sync)
467 SlotLocker locker(thr);
469 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, false);
471 thr->clock.Release(&s->clock);
473 IncrementEpoch(thr);
476 void ReleaseStore(ThreadState *thr, uptr pc, uptr addr) {
477 DPrintf("#%d: ReleaseStore %zx\n", thr->tid, addr);
478 if (thr->ignore_sync)
480 SlotLocker locker(thr);
482 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, false);
484 thr->clock.ReleaseStore(&s->clock);
486 IncrementEpoch(thr);
489 void ReleaseStoreAcquire(ThreadState *thr, uptr pc, uptr addr) {
490 DPrintf("#%d: ReleaseStoreAcquire %zx\n", thr->tid, addr);
491 if (thr->ignore_sync)
493 SlotLocker locker(thr);
495 auto s = ctx->metamap.GetSyncOrCreate(thr, pc, addr, false);
497 thr->clock.ReleaseStoreAcquire(&s->clock);
499 IncrementEpoch(thr);
502 void IncrementEpoch(ThreadState *thr) {
503 DCHECK(!thr->ignore_sync);
504 DCHECK(thr->slot_locked);
505 Epoch epoch = EpochInc(thr->fast_state.epoch());
507 Sid sid = thr->fast_state.sid();
508 thr->clock.Set(sid, epoch);
509 thr->fast_state.SetEpoch(epoch);
510 thr->slot->SetEpoch(epoch);
511 TraceTime(thr);
516 void AfterSleep(ThreadState *thr, uptr pc) {
517 DPrintf("#%d: AfterSleep\n", thr->tid);
518 if (thr->ignore_sync)
520 thr->last_sleep_stack_id = CurrentStackId(thr, pc);
521 thr->last_sleep_clock.Reset();
522 SlotLocker locker(thr);
524 thr->last_sleep_clock.Set(slot.sid, slot.epoch());
528 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) {
529 if (r == 0 || !ShouldReport(thr, ReportTypeDeadlock))
551 OutputReport(thr, rep);
554 void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,
564 ObtainCurrentStack(thr, pc, &trace);
575 OutputReport(thr, rep);