lock_state.h

Go to the documentation of this file.

#pragma once

#include <queue>

#include "mongo/db/concurrency/fast_map_noalloc.h"
#include "mongo/db/concurrency/locker.h"
#include "mongo/db/operation_context.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/util/concurrency/spin_lock.h"

namespace mongo {

class CondVarLockGrantNotification : public LockGrantNotification {
    MONGO_DISALLOW_COPYING(CondVarLockGrantNotification);

public:
    CondVarLockGrantNotification();

    void clear();

    LockResult wait(Milliseconds timeout);

    LockResult wait(OperationContext* opCtx, Milliseconds timeout);

private:
    virtual void notify(ResourceId resId, LockResult result);

    // These two go together to implement the conditional variable pattern.
    stdx::mutex _mutex;
    stdx::condition_variable _cond;

    // Result from the last call to notify
    LockResult _result;
};


template <bool IsForMMAPV1>
class LockerImpl : public Locker {
public:
    LockerImpl();

    virtual ~LockerImpl();

    virtual ClientState getClientState() const;

    virtual LockerId getId() const {
        return _id;
    }

    stdx::thread::id getThreadId() const override;

    void updateThreadIdToCurrentThread() override;
    void unsetThreadId() override;

    void setSharedLocksShouldTwoPhaseLock(bool sharedLocksShouldTwoPhaseLock) override {
        _sharedLocksShouldTwoPhaseLock = sharedLocksShouldTwoPhaseLock;
    }

    void setMaxLockTimeout(Milliseconds maxTimeout) override {
        _maxLockTimeout = maxTimeout;
    }

    bool hasMaxLockTimeout() override {
        return static_cast<bool>(_maxLockTimeout);
    }

    void unsetMaxLockTimeout() override {
        _maxLockTimeout = boost::none;
    }

    virtual LockResult lockGlobal(OperationContext* opCtx, LockMode mode);
    virtual LockResult lockGlobal(LockMode mode) {
        return lockGlobal(nullptr, mode);
    }
    virtual LockResult lockGlobalBegin(OperationContext* opCtx, LockMode mode, Date_t deadline) {
        return _lockGlobalBegin(opCtx, mode, deadline);
    }
    virtual LockResult lockGlobalBegin(LockMode mode, Date_t deadline) {
        return _lockGlobalBegin(nullptr, mode, deadline);
    }
    virtual LockResult lockGlobalComplete(OperationContext* opCtx, Date_t deadline);
    virtual LockResult lockGlobalComplete(Date_t deadline) {
        return lockGlobalComplete(nullptr, deadline);
    }
    virtual void lockMMAPV1Flush();

    virtual void downgradeGlobalXtoSForMMAPV1();
    virtual bool unlockGlobal();

    virtual void beginWriteUnitOfWork();
    virtual void endWriteUnitOfWork();

    virtual bool inAWriteUnitOfWork() const {
        return _wuowNestingLevel > 0;
    }

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

    virtual LockResult lock(ResourceId resId,
                            LockMode mode,
                            Date_t deadline = Date_t::max(),
                            bool checkDeadlock = false) {
        return lock(nullptr, resId, mode, deadline, checkDeadlock);
    }

    virtual void downgrade(ResourceId resId, LockMode newMode);

    virtual bool unlock(ResourceId resId);

    virtual LockMode getLockMode(ResourceId resId) const;
    virtual bool isLockHeldForMode(ResourceId resId, LockMode mode) const;
    virtual bool isDbLockedForMode(StringData dbName, LockMode mode) const;
    virtual bool isCollectionLockedForMode(StringData ns, LockMode mode) const;

    virtual ResourceId getWaitingResource() const;

    virtual void getLockerInfo(LockerInfo* lockerInfo) const;
    virtual boost::optional<LockerInfo> getLockerInfo() const final;

    virtual bool saveLockStateAndUnlock(LockSnapshot* stateOut);

    virtual void restoreLockState(OperationContext* opCtx, const LockSnapshot& stateToRestore);
    virtual void restoreLockState(const LockSnapshot& stateToRestore) {
        restoreLockState(nullptr, stateToRestore);
    }

    virtual void releaseTicket();
    virtual void reacquireTicket(OperationContext* opCtx);

    LockResult lockBegin(OperationContext* opCtx, ResourceId resId, LockMode mode);

    LockResult lockComplete(OperationContext* opCtx,
                            ResourceId resId,
                            LockMode mode,
                            Date_t deadline,
                            bool checkDeadlock);

    LockResult lockComplete(ResourceId resId, LockMode mode, Date_t deadline, bool checkDeadlock) {
        return lockComplete(nullptr, resId, mode, deadline, checkDeadlock);
    }

    FastMapNoAlloc<ResourceId, LockRequest> getRequestsForTest() const {
        scoped_spinlock scopedLock(_lock);
        return _requests;
    }

private:
    friend class AutoYieldFlushLockForMMAPV1Commit;

    typedef FastMapNoAlloc<ResourceId, LockRequest> LockRequestsMap;

    LockResult _lockGlobalBegin(OperationContext* opCtx, LockMode, Date_t deadline);

    bool _unlockImpl(LockRequestsMap::Iterator* it);

    LockMode _getModeForMMAPV1FlushLock() const;

    bool _shouldDelayUnlock(ResourceId resId, LockMode mode) const;

    void _releaseTicket();

    LockResult _acquireTicket(OperationContext* opCtx, LockMode mode, Date_t deadline);

    // Used to disambiguate different lockers
    const LockerId _id;

    // The only reason we have this spin lock here is for the diagnostic tools, which could
    // iterate through the LockRequestsMap on a separate thread and need it to be stable.
    // Apart from that, all accesses to the LockerImpl are always from a single thread.
    //
    // This has to be locked inside const methods, hence the mutable.
    mutable SpinLock _lock;
    // Note: this data structure must always guarantee the continued validity of pointers/references
    // to its contents (LockRequests). The LockManager maintains a LockRequestList of pointers to
    // the LockRequests managed by this data structure.
    LockRequestsMap _requests;

    // Reuse the notification object across requests so we don't have to create a new mutex
    // and condition variable every time.
    CondVarLockGrantNotification _notify;

    // Per-locker locking statistics. Reported in the slow-query log message and through
    // db.currentOp. Complementary to the per-instance locking statistics.
    SingleThreadedLockStats _stats;

    // Delays release of exclusive/intent-exclusive locked resources until the write unit of
    // work completes. Value of 0 means we are not inside a write unit of work.
    int _wuowNestingLevel;

    // Mode for which the Locker acquired a ticket, or MODE_NONE if no ticket was acquired.
    LockMode _modeForTicket = MODE_NONE;

    // Indicates whether the client is active reader/writer or is queued.
    AtomicWord<ClientState> _clientState{kInactive};

    // Track the thread who owns the lock for debugging purposes
    stdx::thread::id _threadId;

    // If true, shared locks will participate in two-phase locking.
    bool _sharedLocksShouldTwoPhaseLock = false;

    // If this is set, dictates the max number of milliseconds that we will wait for lock
    // acquisition. Effectively resets lock acquisition deadlines to time out sooner. If set to 0,
    // for example, lock attempts will time out immediately if the lock is not immediately
    // available.
    boost::optional<Milliseconds> _maxLockTimeout;

    //
    // Methods merged from LockState, which should eventually be removed or changed to methods
    // on the LockerImpl interface.
    //

public:
    virtual void dump() const;

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

    virtual bool isLocked() const;
    virtual bool isWriteLocked() const;
    virtual bool isReadLocked() const;
    bool isGlobalLockedRecursively() override;

    virtual bool hasLockPending() const {
        return getWaitingResource().isValid();
    }
};

typedef LockerImpl<false> DefaultLockerImpl;
typedef LockerImpl<true> MMAPV1LockerImpl;


class AutoYieldFlushLockForMMAPV1Commit {
public:
    AutoYieldFlushLockForMMAPV1Commit(Locker* locker);
    ~AutoYieldFlushLockForMMAPV1Commit();

private:
    MMAPV1LockerImpl* const _locker;
};


class AutoAcquireFlushLockForMMAPV1Commit {
public:
    AutoAcquireFlushLockForMMAPV1Commit(Locker* locker);
    ~AutoAcquireFlushLockForMMAPV1Commit();

    void upgradeFlushLockToExclusive();

    void release();

private:
    Locker* const _locker;
    bool _released;
};


LockManager* getGlobalLockManager();

}  // namespace mongo