bool LockerImpl::saveLockStateAndUnlock(Locker::LockSnapshot* stateOut) {
// We shouldn't be saving and restoring lock state from inside a WriteUnitOfWork.
invariant(!inAWriteUnitOfWork());
// Clear out whatever is in stateOut.
stateOut->locks.clear();
stateOut->globalMode = MODE_NONE;
// First, we look at the global lock. There is special handling for this (as the flush
// lock goes along with it) so we store it separately from the more pedestrian locks.
LockRequestsMap::Iterator globalRequest = _requests.find(resourceIdGlobal);
if (!globalRequest) {
// If there's no global lock there isn't really anything to do. Check that.
for (auto it = _requests.begin(); !it.finished(); it.next()) {
invariant(it.key().getType() == RESOURCE_MUTEX);
}
return false;
}
// If the global lock or RSTL has been acquired more than once, we're probably somewhere in a
// DBDirectClient call. It's not safe to release and reacquire locks -- the context using
// the DBDirectClient is probably not prepared for lock release.
LockRequestsMap::Iterator rstlRequest =
_requests.find(resourceIdReplicationStateTransitionLock);
if (globalRequest->recursiveCount > 1 || (rstlRequest && rstlRequest->recursiveCount > 1)) {
return false;
}
// The global lock must have been acquired just once
stateOut->globalMode = globalRequest->mode;
invariant(unlock(resourceIdGlobal));
// Next, the non-global locks.
for (LockRequestsMap::Iterator it = _requests.begin(); !it.finished(); it.next()) {
const ResourceId resId = it.key();
const ResourceType resType = resId.getType();
if (resType == RESOURCE_MUTEX)
continue;
// We should never have to save and restore metadata locks.
invariant(RESOURCE_DATABASE == resId.getType() || RESOURCE_COLLECTION == resId.getType() ||
(RESOURCE_GLOBAL == resId.getType() && isSharedLockMode(it->mode)) ||
(resourceIdReplicationStateTransitionLock == resId && it->mode == MODE_IX));
// And, stuff the info into the out parameter.
OneLock info;
info.resourceId = resId;
info.mode = it->mode;
stateOut->locks.push_back(info);
invariant(unlock(resId));
}
invariant(!isLocked());
// Sort locks by ResourceId. They'll later be acquired in this canonical locking order.
std::sort(stateOut->locks.begin(), stateOut->locks.end());
return true;
}
void LockerImpl<IsForMMAPV1>::endWriteUnitOfWork() {
invariant(_wuowNestingLevel > 0);
if (--_wuowNestingLevel > 0) {
// Don't do anything unless leaving outermost WUOW.
return;
}
LockRequestsMap::Iterator it = _requests.begin();
while (_numResourcesToUnlockAtEndUnitOfWork > 0) {
if (it->unlockPending) {
invariant(!it.finished());
_numResourcesToUnlockAtEndUnitOfWork--;
}
while (it->unlockPending > 0) {
// If a lock is converted, unlock() may be called multiple times on a resource within
// the same WriteUnitOfWork. All such unlock() requests must thus be fulfilled here.
it->unlockPending--;
unlock(it.key());
}
it.next();
}
// For MMAP V1, we need to yield the flush lock so that the flush thread can run
if (IsForMMAPV1) {
invariant(unlock(resourceIdMMAPV1Flush));
invariant(LOCK_OK == lock(resourceIdMMAPV1Flush, _getModeForMMAPV1FlushLock()));
}
}
bool LockerImpl<IsForMMAPV1>::unlock(ResourceId resId) {
LockRequestsMap::Iterator it = _requests.find(resId);
if (inAWriteUnitOfWork() && _shouldDelayUnlock(it.key(), (it->mode))) {
if (!it->unlockPending) {
_numResourcesToUnlockAtEndUnitOfWork++;
}
it->unlockPending++;
// unlockPending will only be incremented if a lock is converted and unlock() is called
// multiple times on one ResourceId.
invariant(it->unlockPending < LockModesCount);
return false;
}
// Don't attempt to unlock twice. This can happen when an interrupted global lock is destructed.
if (it.finished())
return false;
return _unlockImpl(&it);
}
bool LockerImpl<IsForMMAPV1>::unlockGlobal() {
if (!unlock(resourceIdGlobal)) {
return false;
}
invariant(!inAWriteUnitOfWork());
LockRequestsMap::Iterator it = _requests.begin();
while (!it.finished()) {
// If we're here we should only have one reference to any lock. It is a programming
// error for any lock used with multi-granularity locking to have more references than
// the global lock, because every scope starts by calling lockGlobal.
if (it.key().getType() == RESOURCE_GLOBAL || it.key().getType() == RESOURCE_MUTEX) {
it.next();
} else {
invariant(_unlockImpl(&it));
}
}
return true;
}
void LockerImpl::endWriteUnitOfWork() {
invariant(_wuowNestingLevel > 0);
if (--_wuowNestingLevel > 0) {
// Don't do anything unless leaving outermost WUOW.
return;
}
LockRequestsMap::Iterator it = _requests.begin();
while (_numResourcesToUnlockAtEndUnitOfWork > 0) {
if (it->unlockPending) {
invariant(!it.finished());
_numResourcesToUnlockAtEndUnitOfWork--;
}
while (it->unlockPending > 0) {
// If a lock is converted, unlock() may be called multiple times on a resource within
// the same WriteUnitOfWork. All such unlock() requests must thus be fulfilled here.
it->unlockPending--;
unlock(it.key());
}
it.next();
}
}