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::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;
}
bool LockerImpl<IsForMMAPV1>::unlock(ResourceId resId) {
LockRequestsMap::Iterator it = _requests.find(resId);
if (inAWriteUnitOfWork() && shouldDelayUnlock(it.key(), (it->mode))) {
_resourcesToUnlockAtEndOfUnitOfWork.push(it.key());
return false;
}
return _unlockImpl(&it);
}
LockResult LockerImpl<IsForMMAPV1>::lockBegin(OperationContext* opCtx,
ResourceId resId,
LockMode mode) {
dassert(!getWaitingResource().isValid());
LockRequest* request;
bool isNew = true;
LockRequestsMap::Iterator it = _requests.find(resId);
if (!it) {
scoped_spinlock scopedLock(_lock);
LockRequestsMap::Iterator itNew = _requests.insert(resId);
itNew->initNew(this, &_notify);
request = itNew.objAddr();
} else {
request = it.objAddr();
isNew = false;
}
// If unlockPending is nonzero, that means a LockRequest already exists for this resource but
// is planned to be released at the end of this WUOW due to two-phase locking. Rather than
// unlocking the existing request, we can reuse it if the existing mode matches the new mode.
if (request->unlockPending && isModeCovered(mode, request->mode)) {
request->unlockPending--;
if (!request->unlockPending) {
_numResourcesToUnlockAtEndUnitOfWork--;
}
return LOCK_OK;
}
// Making this call here will record lock re-acquisitions and conversions as well.
globalStats.recordAcquisition(_id, resId, mode);
_stats.recordAcquisition(resId, mode);
// Give priority to the full modes for global, parallel batch writer mode,
// and flush lock so we don't stall global operations such as shutdown or flush.
const ResourceType resType = resId.getType();
if (resType == RESOURCE_GLOBAL || (IsForMMAPV1 && resId == resourceIdMMAPV1Flush)) {
if (mode == MODE_S || mode == MODE_X) {
request->enqueueAtFront = true;
request->compatibleFirst = true;
}
} else if (resType != RESOURCE_MUTEX) {
// This is all sanity checks that the global and flush locks are always be acquired
// before any other lock has been acquired and they must be in sync with the nesting.
DEV {
const LockRequestsMap::Iterator itGlobal = _requests.find(resourceIdGlobal);
invariant(itGlobal->recursiveCount > 0);
invariant(itGlobal->mode != MODE_NONE);
// Check the MMAP V1 flush lock is held in the appropriate mode
invariant(!IsForMMAPV1 ||
isLockHeldForMode(resourceIdMMAPV1Flush, _getModeForMMAPV1FlushLock()));
};
}
LockResult LockerImpl<IsForMMAPV1>::lockBegin(ResourceId resId, LockMode mode) {
dassert(!getWaitingResource().isValid());
LockRequest* request;
bool isNew = true;
LockRequestsMap::Iterator it = _requests.find(resId);
if (!it) {
scoped_spinlock scopedLock(_lock);
LockRequestsMap::Iterator itNew = _requests.insert(resId);
itNew->initNew(this, &_notify);
request = itNew.objAddr();
} else {
request = it.objAddr();
isNew = false;
}
// Making this call here will record lock re-acquisitions and conversions as well.
globalStats.recordAcquisition(_id, resId, mode);
_stats.recordAcquisition(resId, mode);
// Give priority to the full modes for global, parallel batch writer mode,
// and flush lock so we don't stall global operations such as shutdown or flush.
const ResourceType resType = resId.getType();
if (resType == RESOURCE_GLOBAL || (IsForMMAPV1 && resId == resourceIdMMAPV1Flush)) {
if (mode == MODE_S || mode == MODE_X) {
request->enqueueAtFront = true;
request->compatibleFirst = true;
}
} else if (resType != RESOURCE_MUTEX) {
// This is all sanity checks that the global and flush locks are always be acquired
// before any other lock has been acquired and they must be in sync with the nesting.
DEV {
const LockRequestsMap::Iterator itGlobal = _requests.find(resourceIdGlobal);
invariant(itGlobal->recursiveCount > 0);
invariant(itGlobal->mode != MODE_NONE);
// Check the MMAP V1 flush lock is held in the appropriate mode
invariant(!IsForMMAPV1 ||
isLockHeldForMode(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();
}
}
void LockerImpl<IsForMMAPV1>::downgrade(ResourceId resId, LockMode newMode) {
LockRequestsMap::Iterator it = _requests.find(resId);
globalLockManager.downgrade(it.objAddr(), newMode);
}