Lines Matching full:lock
49 // Lock ID (LID) is in range [1, kMaxLID-1]
50 // Lock Set ID (LSID) is in range [-kMaxLID+1, -1]
72 // Incremented on each Lock and Unlock. Used by LockHistory.
96 // ThreadSanitizer Internal lock (scoped).
99 TIL(TSLock *lock, int lock_site, bool need_locking = true) :
100 lock_(lock),
104 lock_->Lock();
122 ts_lock->Lock();
230 // Lock ID.
241 // Singleton: id > 0 (id == Lock's id)
631 // -------- Lock -------------------- {{{1
633 class Lock {
636 static Lock *Create(uintptr_t lock_addr) {
638 // Printf("Lock::Create: %p\n", lock_addr);
642 Lock *res = LookupOrCreate(lock_addr);
651 // Printf("Lock::Destroy: %p\n", lock_addr);
655 static NOINLINE Lock *LookupOrCreate(uintptr_t lock_addr) {
657 Lock **lock = &(*map_)[lock_addr];
658 if (*lock == NULL) {
659 // Printf("Lock::LookupOrCreate: %p\n", lock_addr);
660 ScopedMallocCostCenter cc_lock("new Lock");
661 *lock = new Lock(lock_addr, map_->size());
663 return *lock;
666 static NOINLINE Lock *Lookup(uintptr_t lock_addr) {
679 // When a lock is pure happens-before, we need to create hb arcs
680 // between all Unlock/Lock pairs except RdUnlock/RdLock.
737 static Lock *LIDtoLock(LID lid) {
740 Lock *l = it->second;
749 Lock *lock = LIDtoLock(lid);
750 CHECK(lock);
751 return lock->ToString();
759 Lock *lock = LIDtoLock(lid);
760 CHECK(lock);
761 if (lock->last_lock_site_) {
763 lock->ToString().c_str(),
764 lock->lock_addr_,
765 lock->last_lock_site_->ToString().c_str());
767 Report(" %s. This lock was probably destroyed"
768 " w/o calling Unlock()\n", lock->ToString().c_str());
773 map_ = new Lock::Map;
777 Lock(uintptr_t lock_addr, int32_t lid)
798 typedef map<uintptr_t, Lock*> Map;
803 Lock::Map *Lock::map_;
848 NOINLINE static LSID Add(LSID lsid, Lock *lock) {
850 LID lid = lock->lid();
852 // adding to an empty lock set
875 // If lock is present in lsid, set new_lsid to (lsid \ lock) and return true.
877 NOINLINE static bool Remove(LSID lsid, Lock *lock, LSID *new_lsid) {
880 LID lid = lock->lid();
883 // removing the only lock -> LSID(0)
960 return !Lock::LIDtoLock(LID(lsid.raw()))->is_pure_happens_before();
964 if (!Lock::LIDtoLock(*it)->is_pure_happens_before())
973 return "{" + Lock::ToString(lsid.GetSingleton()) + "}";
979 res += Lock::ToString(*it);
992 Lock::ReportLockWithOrWithoutContext(lid,
999 Lock::ReportLockWithOrWithoutContext(lid,
1045 // signleton lock set has lsid == lid.
3271 "Cache::lines_ accessed without a lock");
3370 // Get a CacheLine. This operation should be performed under a lock
3372 // concurrently w/o a lock.
3894 // Report for invalid lock addresses (INVALID_LOCK).
3908 // If there is a race report (in hybrid mode) we try to guess a lock
3914 // mu.Lock();
3917 // mu.Lock(); // (**)
3924 // LockHistory will find the lock mu and report it.
3932 // Record a Lock event.
3945 // - A Lock happend in `l`.
3947 // - Lock's era is greater than Unlock's era.
3959 if (Lock::LIDtoLock(lid)->is_pure_happens_before()) continue;
4000 Lock::ReportLockWithOrWithoutContext(e.lid, true);
4163 // mu.Lock();
4168 // mu.Lock();
4173 // mu.Lock();
4536 Lock *lock = Lock::LookupOrCreate(lock_addr);
4540 tid_.raw(), lock->lid().raw(),
4553 wr_lockset_ = LockSet::Add(wr_lockset_, lock);
4554 rd_lockset_ = LockSet::Add(rd_lockset_, lock);
4555 lock->WrLock(tid_, CreateStackTrace());
4557 if (lock->wr_held()) {
4560 rd_lockset_ = LockSet::Add(rd_lockset_, lock);
4561 lock->RdLock(CreateStackTrace());
4564 if (lock->is_pure_happens_before()) {
4566 HandleWait(lock->wr_signal_addr());
4568 HandleWait(lock->rd_signal_addr());
4573 lock_history_.OnLock(lock->lid());
4583 Lock *lock = Lock::Lookup(lock_addr);
4584 // If the lock is not found, report an error.
4585 if (lock == NULL) {
4595 bool is_w_lock = lock->wr_held();
4599 tid_.raw(), lock->lid().raw(),
4606 if (lock->is_pure_happens_before()) {
4607 // reader unlock signals only to writer lock,
4610 HandleSignal(lock->rd_signal_addr());
4612 HandleSignal(lock->wr_signal_addr());
4615 if (!lock->wr_held() && !lock->rd_held()) {
4620 report->lid = lock->lid();
4628 lock->WrUnlock();
4629 removed = LockSet::Remove(wr_lockset_, lock, &wr_lockset_)
4630 && LockSet::Remove(rd_lockset_, lock, &rd_lockset_);
4632 lock->RdUnlock();
4633 removed = LockSet::Remove(rd_lockset_, lock, &rd_lockset_);
4641 report->lid = lock->lid();
4647 lock_history_.OnUnlock(lock->lid());
4816 // No fresh SIDs available, have to grab a lock and get few.
5169 // When running fast path w/o a lock we need to recycle SIDs to a thread-local
5170 // pool. HasRoomForDeadSids and AddDeadSid may be called w/o a lock.
5171 // FlushDeadSids should be called under a lock.
5340 // This is done under the main lock.
5346 // We own the lock, but we also must acquire all cache lines
5466 " False lock report inside ntdll.dll \n"
5801 "(reporting last lock sites):%s {%s}\n",
5808 Lock::ReportLockWithOrWithoutContext(lid, true);
5858 Report("WARNING: Lock %s was released by thread T%d"
5859 " which did not acquire this lock: {{{\n%s}}}\n",
5860 Lock::ToString(bad_unlock->lid).c_str(),
5866 Report("WARNING: Unlocking a non-locked lock %s in thread T%d: "
5868 Lock::ToString(bad_unlock->lid).c_str(),
5874 Report("WARNING: accessing an invalid lock %p in thread T%d: "
6352 // Everything else is under a lock.
6365 // Since we have the lock, get some fresh SIDs.
6461 Lock *lock = Lock::LookupOrCreate(lock_addr);
6462 lock->set_name(name);
6637 Lock *lock = Lock::LookupOrCreate(e->a());
6638 CHECK(lock);
6639 lock->set_is_pure_happens_before(true);
6647 Lock *lock = Lock::LookupOrCreate(e->a());
6648 CHECK(lock);
6649 lock->set_is_pure_happens_before(false);
6655 // if the lock was not seen before or if it is currently unlocked.
6665 Lock *lock = Lock::Lookup(lock_addr);
6666 if (lock && lock->wr_held()) {
6667 // We know this lock and it is locked. Just unlock it.
6670 // Never seen this lock or it is currently unlocked. Init it.
6671 Lock::Create(lock_addr);
6682 Lock::Create(lock_addr);
6685 // A locked pthread_mutex_t can not be destroyed but other lock types can.
6686 // When destroying a lock, we must unlock it.
6688 // a destoyed lock, we are likely to fail in an assert.
6693 Lock *lock = Lock::Lookup(lock_addr);
6694 // If the lock is not found, report an error.
6695 if (lock == NULL) {
6705 if (lock->wr_held() || lock->rd_held()) {
6711 Lock::Destroy(lock_addr);
7370 // Everything below goes under a lock.
7404 // Printf("era %d T%d access under lock pc=%p addr=%p size=%p w=%d\n",
8085 debug_lock = PhaseDebugIsOn("lock");
8315 // Grab the lock again
8378 Lock::InitClassMembers();
8444 // Lock is inside on some paths.
8459 // The lock is taken inside on the slow path.
