locker.h

Go to the documentation of this file.

#pragma once

#include <climits>  // For UINT_MAX
#include <vector>

#include "mongo/db/concurrency/lock_manager.h"
#include "mongo/db/concurrency/lock_stats.h"
#include "mongo/db/operation_context.h"
#include "mongo/stdx/thread.h"

namespace mongo {

class Locker {
    MONGO_DISALLOW_COPYING(Locker);

    friend class UninterruptibleLockGuard;

public:
    virtual ~Locker() {}

    virtual bool isNoop() const {
        return false;
    }

    static void setGlobalThrottling(class TicketHolder* reading, class TicketHolder* writing);

    enum ClientState { kInactive, kActiveReader, kActiveWriter, kQueuedReader, kQueuedWriter };

    virtual ClientState getClientState() const = 0;

    virtual LockerId getId() const = 0;

    virtual stdx::thread::id getThreadId() const = 0;

    virtual void updateThreadIdToCurrentThread() = 0;

    virtual void unsetThreadId() = 0;

    virtual void setSharedLocksShouldTwoPhaseLock(bool sharedLocksShouldTwoPhaseLock) = 0;

    virtual void setMaxLockTimeout(Milliseconds maxTimeout) = 0;

    virtual bool hasMaxLockTimeout() = 0;

    virtual void unsetMaxLockTimeout() = 0;

    virtual LockResult lockGlobal(OperationContext* opCtx, LockMode mode) = 0;
    virtual LockResult lockGlobal(LockMode mode) = 0;

    virtual LockResult lockGlobalBegin(OperationContext* opCtx, LockMode mode, Date_t deadline) = 0;
    virtual LockResult lockGlobalBegin(LockMode mode, Date_t deadline) = 0;

    virtual LockResult lockGlobalComplete(OperationContext* opCtx, Date_t deadline) = 0;
    virtual LockResult lockGlobalComplete(Date_t deadline) = 0;

    virtual void lockMMAPV1Flush() = 0;

    virtual bool unlockGlobal() = 0;

    virtual void downgradeGlobalXtoSForMMAPV1() = 0;

    virtual void beginWriteUnitOfWork() = 0;
    virtual void endWriteUnitOfWork() = 0;

    virtual bool inAWriteUnitOfWork() const = 0;

    virtual LockResult lock(OperationContext* opCtx,
                            ResourceId resId,
                            LockMode mode,
                            Date_t deadline = Date_t::max(),
                            bool checkDeadlock = false) = 0;

    virtual LockResult lock(ResourceId resId,
                            LockMode mode,
                            Date_t deadline = Date_t::max(),
                            bool checkDeadlock = false) = 0;

    virtual void downgrade(ResourceId resId, LockMode newMode) = 0;

    virtual bool unlock(ResourceId resId) = 0;

    virtual LockMode getLockMode(ResourceId resId) const = 0;
    virtual bool isLockHeldForMode(ResourceId resId, LockMode mode) const = 0;

    // These are shortcut methods for the above calls. They however check that the entire
    // hierarchy is properly locked and because of this they are very expensive to call.
    // Do not use them in performance critical code paths.
    virtual bool isDbLockedForMode(StringData dbName, LockMode mode) const = 0;
    virtual bool isCollectionLockedForMode(StringData ns, LockMode mode) const = 0;

    virtual ResourceId getWaitingResource() const = 0;

    struct OneLock {
        // What lock resource is held?
        ResourceId resourceId;

        // In what mode is it held?
        LockMode mode;

        // Reporting/serialization order is by resourceId, which is the canonical locking order
        bool operator<(const OneLock& rhs) const {
            return resourceId < rhs.resourceId;
        }
    };

    struct LockerInfo {
        // List of high-level locks held by this locker, sorted by ResourceId
        std::vector<OneLock> locks;

        // If isValid(), then what lock this particular locker is sleeping on
        ResourceId waitingResource;

        // Lock timing statistics
        SingleThreadedLockStats stats;
    };

    virtual void getLockerInfo(LockerInfo* lockerInfo) const = 0;

    virtual boost::optional<LockerInfo> getLockerInfo() const = 0;

    struct LockSnapshot {
        // The global lock is handled differently from all other locks.
        LockMode globalMode;

        // The non-global non-flush locks held, sorted by granularity.  That is, locks[i] is
        // coarser or as coarse as locks[i + 1].
        std::vector<OneLock> locks;
    };

    virtual bool saveLockStateAndUnlock(LockSnapshot* stateOut) = 0;

    virtual void restoreLockState(OperationContext* opCtx, const LockSnapshot& stateToRestore) = 0;
    virtual void restoreLockState(const LockSnapshot& stateToRestore) = 0;

    virtual void releaseTicket() = 0;

    virtual void reacquireTicket(OperationContext* opCtx) = 0;

    //
    // These methods are legacy from LockerImpl and will eventually go away or be converted to
    // calls into the Locker methods
    //

    virtual void dump() const = 0;

    virtual bool isW() const = 0;
    virtual bool isR() const = 0;

    virtual bool isLocked() const = 0;
    virtual bool isWriteLocked() const = 0;
    virtual bool isReadLocked() const = 0;
    virtual bool isGlobalLockedRecursively() = 0;

    virtual bool hasLockPending() const = 0;

    void setShouldConflictWithSecondaryBatchApplication(bool newValue) {
        _shouldConflictWithSecondaryBatchApplication = newValue;
    }
    bool shouldConflictWithSecondaryBatchApplication() const {
        return _shouldConflictWithSecondaryBatchApplication;
    }

    void setShouldAcquireTicket(bool newValue) {
        invariant(!isLocked() || isNoop());
        _shouldAcquireTicket = newValue;
    }
    bool shouldAcquireTicket() const {
        return _shouldAcquireTicket;
    }
    unsigned numResourcesToUnlockAtEndUnitOfWorkForTest() const {
        return _numResourcesToUnlockAtEndUnitOfWork;
    }

protected:
    Locker() {}

    int _uninterruptibleLocksRequested = 0;

    unsigned _numResourcesToUnlockAtEndUnitOfWork = 0;

private:
    bool _shouldConflictWithSecondaryBatchApplication = true;
    bool _shouldAcquireTicket = true;
};

class UninterruptibleLockGuard {
public:
    /*
     * Accepts a Locker, and increments the _uninterruptibleLocksRequested. Decrements the
     * counter when destoyed.
     */
    explicit UninterruptibleLockGuard(Locker* locker) : _locker(locker) {
        invariant(_locker);
        invariant(_locker->_uninterruptibleLocksRequested >= 0);
        invariant(_locker->_uninterruptibleLocksRequested < std::numeric_limits<int>::max());
        _locker->_uninterruptibleLocksRequested += 1;
    }

    ~UninterruptibleLockGuard() {
        invariant(_locker->_uninterruptibleLocksRequested > 0);
        _locker->_uninterruptibleLocksRequested -= 1;
    }

private:
    Locker* const _locker;
};

class ShouldNotConflictWithSecondaryBatchApplicationBlock {
    MONGO_DISALLOW_COPYING(ShouldNotConflictWithSecondaryBatchApplicationBlock);

public:
    explicit ShouldNotConflictWithSecondaryBatchApplicationBlock(Locker* lockState)
        : _lockState(lockState),
          _originalShouldConflict(_lockState->shouldConflictWithSecondaryBatchApplication()) {
        _lockState->setShouldConflictWithSecondaryBatchApplication(false);
    }

    ~ShouldNotConflictWithSecondaryBatchApplicationBlock() {
        _lockState->setShouldConflictWithSecondaryBatchApplication(_originalShouldConflict);
    }

private:
    Locker* const _lockState;
    const bool _originalShouldConflict;
};

}  // namespace mongo