LockResult LockerImpl<IsForMMAPV1>::_lockGlobalBegin(LockMode mode, Milliseconds timeout) {
dassert(isLocked() == (_modeForTicket != MODE_NONE));
if (_modeForTicket == MODE_NONE) {
const bool reader = isSharedLockMode(mode);
auto holder = ticketHolders[mode];
if (holder) {
_clientState.store(reader ? kQueuedReader : kQueuedWriter);
if (timeout == Milliseconds::max()) {
holder->waitForTicket();
} else if (!holder->waitForTicketUntil(Date_t::now() + timeout)) {
_clientState.store(kInactive);
return LOCK_TIMEOUT;
}
}
_clientState.store(reader ? kActiveReader : kActiveWriter);
_modeForTicket = mode;
}
const LockResult result = lockBegin(resourceIdGlobal, mode);
if (result == LOCK_OK)
return LOCK_OK;
// Currently, deadlock detection does not happen inline with lock acquisition so the only
// unsuccessful result that the lock manager would return is LOCK_WAITING.
invariant(result == LOCK_WAITING);
return result;
}
LockResult LockerImpl::_lockGlobalBegin(OperationContext* opCtx, LockMode mode, Date_t deadline) {
dassert(isLocked() == (_modeForTicket != MODE_NONE));
if (_modeForTicket == MODE_NONE) {
auto acquireTicketResult = _acquireTicket(opCtx, mode, deadline);
if (acquireTicketResult != LOCK_OK) {
return acquireTicketResult;
}
_modeForTicket = mode;
}
LockMode actualLockMode = mode;
if (opCtx) {
auto storageEngine = opCtx->getServiceContext()->getStorageEngine();
if (storageEngine && !storageEngine->supportsDBLocking()) {
actualLockMode = isSharedLockMode(mode) ? MODE_S : MODE_X;
}
}
const LockResult result = lockBegin(opCtx, resourceIdGlobal, actualLockMode);
if (result == LOCK_OK)
return LOCK_OK;
invariant(result == LOCK_WAITING);
return result;
}
LockResult LockerImpl<IsForMMAPV1>::lock(
OperationContext* opCtx, ResourceId resId, LockMode mode, Date_t deadline, bool checkDeadlock) {
const LockResult result = lockBegin(opCtx, resId, mode);
// Fast, uncontended path
if (result == LOCK_OK)
return LOCK_OK;
// Currently, deadlock detection does not happen inline with lock acquisition so the only
// unsuccessful result that the lock manager would return is LOCK_WAITING.
invariant(result == LOCK_WAITING);
return lockComplete(opCtx, resId, mode, deadline, checkDeadlock);
}
LockResult LockerImpl::lock(OperationContext* opCtx,
ResourceId resId,
LockMode mode,
Date_t deadline) {
const LockResult result = lockBegin(opCtx, resId, mode);
// Fast, uncontended path
if (result == LOCK_OK)
return LOCK_OK;
invariant(result == LOCK_WAITING);
return lockComplete(opCtx, resId, mode, deadline);
}
LockResult LockerImpl<IsForMMAPV1>::_lockGlobalBegin(OperationContext* opCtx,
LockMode mode,
Date_t deadline) {
dassert(isLocked() == (_modeForTicket != MODE_NONE));
if (_modeForTicket == MODE_NONE) {
auto acquireTicketResult = _acquireTicket(opCtx, mode, deadline);
if (acquireTicketResult != LOCK_OK) {
return acquireTicketResult;
}
_modeForTicket = mode;
}
const LockResult result = lockBegin(opCtx, resourceIdGlobal, mode);
if (result == LOCK_OK)
return LOCK_OK;
// Currently, deadlock detection does not happen inline with lock acquisition so the only
// unsuccessful result that the lock manager would return is LOCK_WAITING.
invariant(result == LOCK_WAITING);
return result;
}
