diff options
Diffstat (limited to 'src/mongo')
59 files changed, 203 insertions, 220 deletions
diff --git a/src/mongo/db/auth/auth_index_d.cpp b/src/mongo/db/auth/auth_index_d.cpp index 20f2bd2eb5d..7c223c5ce0a 100644 --- a/src/mongo/db/auth/auth_index_d.cpp +++ b/src/mongo/db/auth/auth_index_d.cpp @@ -84,7 +84,7 @@ namespace { const NamespaceString systemUsers("admin", "system.users"); // Make sure the old unique index from v2.4 on system.users doesn't exist. - AutoGetDb autoDb(txn, systemUsers.db(), newlm::MODE_X); + AutoGetDb autoDb(txn, systemUsers.db(), MODE_X); if (!autoDb.getDb()) { return; } diff --git a/src/mongo/db/client.cpp b/src/mongo/db/client.cpp index 917003e4916..49b951e87c1 100644 --- a/src/mongo/db/client.cpp +++ b/src/mongo/db/client.cpp @@ -188,7 +188,7 @@ namespace mongo { } - AutoGetDb::AutoGetDb(OperationContext* txn, const StringData& ns, newlm::LockMode mode) + AutoGetDb::AutoGetDb(OperationContext* txn, const StringData& ns, LockMode mode) : _dbLock(txn->lockState(), ns, mode), _db(dbHolder().get(txn, ns)) { @@ -199,7 +199,7 @@ namespace mongo { const std::string& ns) : _txn(txn), _nss(ns), - _dbLock(_txn->lockState(), _nss.db(), newlm::MODE_IS), + _dbLock(_txn->lockState(), _nss.db(), MODE_IS), _db(NULL), _coll(NULL) { @@ -210,7 +210,7 @@ namespace mongo { const NamespaceString& nss) : _txn(txn), _nss(nss), - _dbLock(_txn->lockState(), _nss.db(), newlm::MODE_IS), + _dbLock(_txn->lockState(), _nss.db(), MODE_IS), _db(NULL), _coll(NULL) { @@ -226,10 +226,10 @@ namespace mongo { // Lock both the DB and the collection (DB is locked in the constructor), because this is // necessary in order to to shard version checking. - const newlm::ResourceId resId(newlm::RESOURCE_COLLECTION, _nss); - const newlm::LockMode collLockMode = supportsDocLocking() ? newlm::MODE_IS : newlm::MODE_S; + const ResourceId resId(RESOURCE_COLLECTION, _nss); + const LockMode collLockMode = supportsDocLocking() ? MODE_IS : MODE_S; - invariant(newlm::LOCK_OK == _txn->lockState()->lock(resId, collLockMode)); + invariant(LOCK_OK == _txn->lockState()->lock(resId, collLockMode)); // Shard version check needs to be performed under the collection lock ensureShardVersionOKOrThrow(_nss); @@ -248,7 +248,7 @@ namespace mongo { AutoGetCollectionForRead::~AutoGetCollectionForRead() { // If the database is NULL, we would never have tried to lock the collection resource if (_db) { - const newlm::ResourceId resId(newlm::RESOURCE_COLLECTION, _nss); + const ResourceId resId(RESOURCE_COLLECTION, _nss); _txn->lockState()->unlock(resId); } @@ -260,8 +260,8 @@ namespace mongo { Client::WriteContext::WriteContext(OperationContext* opCtx, const std::string& ns) : _txn(opCtx), _nss(ns), - _dblk(opCtx->lockState(), _nss.db(), newlm::MODE_IX), - _collk(opCtx->lockState(), ns, newlm::MODE_IX), + _dblk(opCtx->lockState(), _nss.db(), MODE_IX), + _collk(opCtx->lockState(), ns, MODE_IX), _wunit(opCtx), _c(opCtx, ns) { } diff --git a/src/mongo/db/client.h b/src/mongo/db/client.h index 99957f6359e..8f82c5d67d3 100644 --- a/src/mongo/db/client.h +++ b/src/mongo/db/client.h @@ -218,7 +218,7 @@ namespace mongo { class AutoGetDb { MONGO_DISALLOW_COPYING(AutoGetDb); public: - AutoGetDb(OperationContext* txn, const StringData& ns, newlm::LockMode mode); + AutoGetDb(OperationContext* txn, const StringData& ns, LockMode mode); Database* getDb() const { return _db; diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp index 109c0598711..985ce76e473 100644 --- a/src/mongo/db/cloner.cpp +++ b/src/mongo/db/cloner.cpp @@ -308,7 +308,7 @@ namespace mongo { const NamespaceString nss(ns); const string dbname = nss.db().toString(); - Lock::DBLock dbWrite(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbWrite(txn->lockState(), dbname, MODE_X); Database* db = dbHolder().openDb(txn, dbname); diff --git a/src/mongo/db/commands/apply_ops.cpp b/src/mongo/db/commands/apply_ops.cpp index cc760412120..4b2858d9505 100644 --- a/src/mongo/db/commands/apply_ops.cpp +++ b/src/mongo/db/commands/apply_ops.cpp @@ -137,7 +137,7 @@ namespace mongo { // We do not have a wrapping WriteUnitOfWork so it is possible for a journal // commit to happen with a subset of ops applied. // TODO figure out what to do about this. - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); invariant(txn->lockState()->isRecursive()); Client::Context ctx(txn, ns); diff --git a/src/mongo/db/commands/clone.cpp b/src/mongo/db/commands/clone.cpp index 0b73001e559..44270a6596d 100644 --- a/src/mongo/db/commands/clone.cpp +++ b/src/mongo/db/commands/clone.cpp @@ -115,7 +115,7 @@ namespace mongo { set<string> clonedColls; - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Cloner cloner; bool rval = cloner.go(txn, dbname, from, opts, &clonedColls, errmsg); diff --git a/src/mongo/db/commands/collection_to_capped.cpp b/src/mongo/db/commands/collection_to_capped.cpp index 24439e82b9b..6be8e0d7cd5 100644 --- a/src/mongo/db/commands/collection_to_capped.cpp +++ b/src/mongo/db/commands/collection_to_capped.cpp @@ -161,7 +161,7 @@ namespace mongo { return false; } - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, dbname); Status status = cloneCollectionAsCapped( txn, ctx.db(), from, to, size, temp, true ); diff --git a/src/mongo/db/commands/compact.cpp b/src/mongo/db/commands/compact.cpp index 8ffac0bff38..d2703c560f4 100644 --- a/src/mongo/db/commands/compact.cpp +++ b/src/mongo/db/commands/compact.cpp @@ -144,7 +144,7 @@ namespace mongo { compactOptions.validateDocuments = cmdObj["validate"].trueValue(); - Lock::DBLock lk(txn->lockState(), db, newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), db, MODE_X); BackgroundOperation::assertNoBgOpInProgForNs(ns.ns()); Client::Context ctx(txn, ns); diff --git a/src/mongo/db/commands/copydb.cpp b/src/mongo/db/commands/copydb.cpp index 58f733e02b0..469e0cd0a59 100644 --- a/src/mongo/db/commands/copydb.cpp +++ b/src/mongo/db/commands/copydb.cpp @@ -188,7 +188,7 @@ namespace mongo { return cloner.go(txn, todb, fromhost, cloneOptions, NULL, errmsg); } - Lock::DBLock lk (txn->lockState(), todb, newlm::MODE_X); + Lock::DBLock lk (txn->lockState(), todb, MODE_X); return cloner.go(txn, todb, fromhost, cloneOptions, NULL, errmsg); } diff --git a/src/mongo/db/commands/cpuprofile.cpp b/src/mongo/db/commands/cpuprofile.cpp index b1c81ca3584..d25b7c034cb 100644 --- a/src/mongo/db/commands/cpuprofile.cpp +++ b/src/mongo/db/commands/cpuprofile.cpp @@ -133,7 +133,7 @@ namespace mongo { std::string &errmsg, BSONObjBuilder &result, bool fromRepl ) { - Lock::DBLock dbXLock(txn->lockState(), db, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), db, MODE_X); // The lock here is just to prevent concurrency, nothing will write. Client::Context ctx(txn, db); @@ -152,7 +152,7 @@ namespace mongo { std::string &errmsg, BSONObjBuilder &result, bool fromRepl ) { - Lock::DBLock dbXLock(txn->lockState(), db, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), db, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, db); diff --git a/src/mongo/db/commands/create_indexes.cpp b/src/mongo/db/commands/create_indexes.cpp index 43ff03f26e4..c978b5ec046 100644 --- a/src/mongo/db/commands/create_indexes.cpp +++ b/src/mongo/db/commands/create_indexes.cpp @@ -134,7 +134,7 @@ namespace mongo { // now we know we have to create index(es) // Note: createIndexes command does not currently respect shard versioning. - Lock::DBLock lk(txn->lockState(), ns.db(), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), ns.db(), MODE_X); Client::Context ctx(txn, ns.ns(), false /* doVersion */ ); Database* db = ctx.db(); diff --git a/src/mongo/db/commands/dbhash.cpp b/src/mongo/db/commands/dbhash.cpp index 596675d1ef6..2eabb57610e 100644 --- a/src/mongo/db/commands/dbhash.cpp +++ b/src/mongo/db/commands/dbhash.cpp @@ -149,7 +149,7 @@ namespace mongo { // We lock the entire database in S-mode in order to ensure that the contents will not // change for the snapshot. - AutoGetDb autoDb(txn, ns, newlm::MODE_S); + AutoGetDb autoDb(txn, ns, MODE_S); Database* db = autoDb.getDb(); if (db) { db->getDatabaseCatalogEntry()->getCollectionNamespaces(&colls); diff --git a/src/mongo/db/commands/drop_indexes.cpp b/src/mongo/db/commands/drop_indexes.cpp index 937039070a4..ff2f975b5ef 100644 --- a/src/mongo/db/commands/drop_indexes.cpp +++ b/src/mongo/db/commands/drop_indexes.cpp @@ -104,7 +104,7 @@ namespace mongo { CmdDropIndexes() : Command("dropIndexes", false, "deleteIndexes") { } bool run(OperationContext* txn, const string& dbname, BSONObj& jsobj, int, string& errmsg, BSONObjBuilder& anObjBuilder, bool fromRepl) { - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); bool ok = wrappedRun(txn, dbname, jsobj, errmsg, anObjBuilder); if (!ok) { @@ -240,7 +240,7 @@ namespace mongo { LOG(0) << "CMD: reIndex " << toDeleteNs << endl; - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, toDeleteNs); Collection* collection = ctx.db()->getCollection( txn, toDeleteNs ); diff --git a/src/mongo/db/commands/find_and_modify.cpp b/src/mongo/db/commands/find_and_modify.cpp index e8b308bbfdd..1298767fd9f 100644 --- a/src/mongo/db/commands/find_and_modify.cpp +++ b/src/mongo/db/commands/find_and_modify.cpp @@ -329,7 +329,7 @@ namespace mongo { } } - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, ns); diff --git a/src/mongo/db/commands/list_collections.cpp b/src/mongo/db/commands/list_collections.cpp index e00872f983e..87f58770fc8 100644 --- a/src/mongo/db/commands/list_collections.cpp +++ b/src/mongo/db/commands/list_collections.cpp @@ -67,7 +67,7 @@ namespace mongo { BSONObjBuilder& result, bool /*fromRepl*/) { - AutoGetDb autoDb(txn, dbname, newlm::MODE_S); + AutoGetDb autoDb(txn, dbname, MODE_S); const Database* d = autoDb.getDb(); const DatabaseCatalogEntry* dbEntry = NULL; diff --git a/src/mongo/db/commands/mr.cpp b/src/mongo/db/commands/mr.cpp index 0e88bc4e2a4..fe76552c8e4 100644 --- a/src/mongo/db/commands/mr.cpp +++ b/src/mongo/db/commands/mr.cpp @@ -334,7 +334,7 @@ namespace mongo { // harmless, this would lead to a scary looking warning on the secondaries. Lock::DBLock lk(_txn->lockState(), nsToDatabaseSubstring(_config.incLong), - newlm::MODE_X); + MODE_X); if (Database* db = dbHolder().get(_txn, _config.incLong)) { WriteUnitOfWork wunit(_txn); db->dropCollection(_txn, _config.incLong); @@ -594,7 +594,7 @@ namespace mongo { while (cursor->more()) { Lock::DBLock lock(_txn->lockState(), nsToDatabaseSubstring(_config.outputOptions.finalNamespace), - newlm::MODE_X); + MODE_X); WriteUnitOfWork wunit(_txn); BSONObj o = cursor->nextSafe(); Helpers::upsert( _txn, _config.outputOptions.finalNamespace , o ); @@ -1113,7 +1113,7 @@ namespace mongo { Lock::DBLock kl(_txn->lockState(), nsToDatabaseSubstring(_config.incLong), - newlm::MODE_X); + MODE_X); WriteUnitOfWork wunit(_txn); for ( InMemory::iterator i=_temp->begin(); i!=_temp->end(); i++ ) { diff --git a/src/mongo/db/commands/test_commands.cpp b/src/mongo/db/commands/test_commands.cpp index 9121971efb1..16f8fae04f0 100644 --- a/src/mongo/db/commands/test_commands.cpp +++ b/src/mongo/db/commands/test_commands.cpp @@ -64,7 +64,7 @@ namespace mongo { string ns = dbname + "." + coll; BSONObj obj = cmdObj[ "obj" ].embeddedObjectUserCheck(); - Lock::DBLock lk(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, ns ); Database* db = ctx.db(); diff --git a/src/mongo/db/commands/write_commands/batch_executor.cpp b/src/mongo/db/commands/write_commands/batch_executor.cpp index e59c6fbca69..b71978dc5a6 100644 --- a/src/mongo/db/commands/write_commands/batch_executor.cpp +++ b/src/mongo/db/commands/write_commands/batch_executor.cpp @@ -928,10 +928,10 @@ namespace mongo { invariant(!_context.get()); _writeLock.reset(new Lock::DBLock(txn->lockState(), nsToDatabase(request->getNS()), - intentLock ? newlm::MODE_IX : newlm::MODE_X)); + intentLock ? MODE_IX : MODE_X)); _collLock.reset(new Lock::CollectionLock(txn->lockState(), request->getNS(), - intentLock ? newlm::MODE_IX : newlm::MODE_X)); + intentLock ? MODE_IX : MODE_X)); if (!checkIsMasterForDatabase(request->getNS(), result)) { return false; } @@ -1144,10 +1144,10 @@ namespace mongo { } /////////////////////////////////////////// - Lock::DBLock dbLock(txn->lockState(), nsString.db(), newlm::MODE_IX); + Lock::DBLock dbLock(txn->lockState(), nsString.db(), MODE_IX); Lock::CollectionLock colLock(txn->lockState(), nsString.ns(), - isMulti ? newlm::MODE_X : newlm::MODE_IX); + isMulti ? MODE_X : MODE_IX); /////////////////////////////////////////// if (!checkShardVersion(txn, &shardingState, *updateItem.getRequest(), result)) @@ -1202,7 +1202,7 @@ namespace mongo { } /////////////////////////////////////////// - Lock::DBLock writeLock(txn->lockState(), nss.db(), newlm::MODE_X); + Lock::DBLock writeLock(txn->lockState(), nss.db(), MODE_X); /////////////////////////////////////////// // Check version once we're locked diff --git a/src/mongo/db/commands/write_commands/write_commands.cpp b/src/mongo/db/commands/write_commands/write_commands.cpp index 5ec2bd98aa9..6adf097dba2 100644 --- a/src/mongo/db/commands/write_commands/write_commands.cpp +++ b/src/mongo/db/commands/write_commands/write_commands.cpp @@ -211,7 +211,7 @@ namespace mongo { // Explains of write commands are read-only, but we take an exclusive lock so // that timing info is more accurate. - Lock::DBLock dlk(txn->lockState(), nsString.db(), newlm::MODE_X); + Lock::DBLock dlk(txn->lockState(), nsString.db(), MODE_X); Client::Context ctx(txn, nsString); Status prepInLockStatus = updateExecutor.prepareInLock(ctx.db()); @@ -246,7 +246,7 @@ namespace mongo { // Explains of write commands are read-only, but we take a write lock so that timing // info is more accurate. - Lock::DBLock dlk(txn->lockState(), nsString.db(), newlm::MODE_X); + Lock::DBLock dlk(txn->lockState(), nsString.db(), MODE_X); Client::Context ctx(txn, nsString); Status prepInLockStatus = deleteExecutor.prepareInLock(ctx.db()); diff --git a/src/mongo/db/concurrency/d_concurrency.cpp b/src/mongo/db/concurrency/d_concurrency.cpp index f510513fe5f..a93a28b33d1 100644 --- a/src/mongo/db/concurrency/d_concurrency.cpp +++ b/src/mongo/db/concurrency/d_concurrency.cpp @@ -197,7 +197,7 @@ namespace mongo { invariant(!_lockState->isLocked()); TrackLockAcquireTime a('W'); - _lockState->lockGlobal(newlm::MODE_X); + _lockState->lockGlobal(MODE_X); resetTime(); } @@ -206,8 +206,8 @@ namespace mongo { TrackLockAcquireTime a('W'); - newlm::LockResult result = _lockState->lockGlobal(newlm::MODE_X, timeoutms); - if (result == newlm::LOCK_TIMEOUT) { + LockResult result = _lockState->lockGlobal(MODE_X, timeoutms); + if (result == LOCK_TIMEOUT) { throw DBTryLockTimeoutException(); } @@ -227,8 +227,8 @@ namespace mongo { TrackLockAcquireTime a('R'); - newlm::LockResult result = _lockState->lockGlobal(newlm::MODE_S, timeoutms); - if (result == newlm::LOCK_TIMEOUT) { + LockResult result = _lockState->lockGlobal(MODE_S, timeoutms); + if (result == LOCK_TIMEOUT) { throw DBTryLockTimeoutException(); } @@ -240,9 +240,9 @@ namespace mongo { recordTime(); } - Lock::DBLock::DBLock(Locker* lockState, const StringData& db, const newlm::LockMode mode) - : ScopedLock(lockState, mode == newlm::MODE_S || mode == newlm::MODE_IS ? 'r' : 'w'), - _id(newlm::RESOURCE_DATABASE, db), + Lock::DBLock::DBLock(Locker* lockState, const StringData& db, const LockMode mode) + : ScopedLock(lockState, mode == MODE_S || mode == MODE_IS ? 'r' : 'w'), + _id(RESOURCE_DATABASE, db), _mode(mode) { dassert(!db.empty()); dassert(!nsIsFull(db)); @@ -254,16 +254,16 @@ namespace mongo { } void Lock::DBLock::lockDB() { - const bool isRead = (_mode == newlm::MODE_S || _mode == newlm::MODE_IS); + const bool isRead = (_mode == MODE_S || _mode == MODE_IS); TrackLockAcquireTime a(isRead ? 'r' : 'w'); - _lockState->lockGlobal(isRead ? newlm::MODE_IS : newlm::MODE_IX); + _lockState->lockGlobal(isRead ? MODE_IS : MODE_IX); if (supportsDocLocking()) { // SERVER-14668: Make this branch unconditional when MMAPv1 has coll. locking _lockState->lock(_id, _mode); } else { - _lockState->lock(_id, isRead ? newlm::MODE_S : newlm::MODE_X); + _lockState->lock(_id, isRead ? MODE_S : MODE_X); } resetTime(); @@ -280,19 +280,19 @@ namespace mongo { Lock::CollectionLock::CollectionLock(Locker* lockState, const StringData& ns, - newlm::LockMode mode) - : _id(newlm::RESOURCE_COLLECTION, ns), + LockMode mode) + : _id(RESOURCE_COLLECTION, ns), _lockState(lockState) { - const bool isRead = (mode == newlm::MODE_S || mode == newlm::MODE_IS); + const bool isRead = (mode == MODE_S || mode == MODE_IS); dassert(!ns.empty()); dassert(nsIsFull(ns)); - dassert(_lockState->isLockHeldForMode(newlm::ResourceId(newlm::RESOURCE_DATABASE, + dassert(_lockState->isLockHeldForMode(ResourceId(RESOURCE_DATABASE, nsToDatabaseSubstring(ns)), - isRead ? newlm::MODE_IS : newlm::MODE_IX)); + isRead ? MODE_IS : MODE_IX)); if (supportsDocLocking()) { _lockState->lock(_id, mode); // SERVER-14668: add when MMAPv1 ready for collection-level locking - // else { _lockState->lock(_id, isRead ? newlm::MODE_S : newlm::MODE_X); } + // else { _lockState->lock(_id, isRead ? MODE_S : MODE_X); } invariant(isRead || !isRead); // artificial use to silence warning. } } @@ -305,7 +305,7 @@ namespace mongo { } Lock::DBRead::DBRead(Locker* lockState, const StringData& dbOrNs) : - DBLock(lockState, nsToDatabaseSubstring(dbOrNs), newlm::MODE_S) { } + DBLock(lockState, nsToDatabaseSubstring(dbOrNs), MODE_S) { } writelocktry::writelocktry(Locker* lockState, int tryms) : _got( false ), diff --git a/src/mongo/db/concurrency/d_concurrency.h b/src/mongo/db/concurrency/d_concurrency.h index a55eaa077f3..185662cb6da 100644 --- a/src/mongo/db/concurrency/d_concurrency.h +++ b/src/mongo/db/concurrency/d_concurrency.h @@ -128,7 +128,7 @@ namespace mongo { * * Allows exclusive write access to all databases and collections, blocking all other * access. Allows further (recursive) acquisition of the global lock in any mode, - * see newlm::LockMode. + * see LockMode. */ class GlobalWrite : public ScopedLock { protected: @@ -145,7 +145,7 @@ namespace mongo { * * Allows concurrent read access to all databases and collections, blocking any writers. * Allows further (recursive) acquisition of the global lock in shared (S) or intent-shared - * (IS) mode, see newlm::LockMode. + * (IS) mode, see LockMode. */ class GlobalRead : public ScopedLock { public: @@ -157,7 +157,7 @@ namespace mongo { /** * Database lock with support for collection- and document-level locking * - * This lock supports four modes (see newlm::Lock_Mode): + * This lock supports four modes (see Lock_Mode): * MODE_IS: concurrent database access, requiring further collection read locks * MODE_IX: concurrent database access, requiring further collection read or write locks * MODE_S: shared read access to the database, blocking any writers @@ -170,15 +170,15 @@ namespace mongo { */ class DBLock : public ScopedLock { public: - DBLock(Locker* lockState, const StringData& db, const newlm::LockMode mode); + DBLock(Locker* lockState, const StringData& db, const LockMode mode); virtual ~DBLock(); private: void lockDB(); void unlockDB(); - const newlm::ResourceId _id; - const newlm::LockMode _mode; + const ResourceId _id; + const LockMode _mode; protected: // Still need to override these for ScopedLock::tempRelease() and relock(). @@ -190,7 +190,7 @@ namespace mongo { /** * Collection lock with support for document-level locking * - * This lock supports four modes (see newlm::Lock_Mode): + * This lock supports four modes (see Lock_Mode): * MODE_IS: concurrent collection access, requiring document level locking read locks * MODE_IX: concurrent collection access, requiring document level read or write locks * MODE_S: shared read access to the collection, blocking any writers @@ -203,10 +203,10 @@ namespace mongo { */ class CollectionLock : boost::noncopyable { public: - CollectionLock (Locker* lockState, const StringData& ns, const newlm::LockMode); + CollectionLock (Locker* lockState, const StringData& ns, const LockMode); virtual ~CollectionLock(); private: - const newlm::ResourceId _id; + const ResourceId _id; Locker* _lockState; }; diff --git a/src/mongo/db/concurrency/d_concurrency_test.cpp b/src/mongo/db/concurrency/d_concurrency_test.cpp index ddc59b17bd7..f930529fcbe 100644 --- a/src/mongo/db/concurrency/d_concurrency_test.cpp +++ b/src/mongo/db/concurrency/d_concurrency_test.cpp @@ -92,18 +92,19 @@ namespace mongo { TEST(DConcurrency, readlocktryTimeoutDueToFlushLock) { LockState ls; - newlm::AutoAcquireFlushLockForMMAPV1Commit autoFlushLock(&ls); + AutoAcquireFlushLockForMMAPV1Commit autoFlushLock(&ls); { LockState lsTry; readlocktry lockTry(&lsTry, 1); + ASSERT(!lockTry.got()); } } TEST(DConcurrency, writelocktryTimeoutDueToFlushLock) { LockState ls; - newlm::AutoAcquireFlushLockForMMAPV1Commit autoFlushLock(&ls); + AutoAcquireFlushLockForMMAPV1Commit autoFlushLock(&ls); { LockState lsTry; @@ -129,24 +130,24 @@ namespace mongo { Lock::DBRead dbRead(&ls, "db"); - const newlm::ResourceId resIdDb(newlm::RESOURCE_DATABASE, string("db")); - ASSERT(ls.getLockMode(resIdDb) == newlm::MODE_S); + const ResourceId resIdDb(RESOURCE_DATABASE, string("db")); + ASSERT(ls.getLockMode(resIdDb) == MODE_S); } TEST(DConcurrency, DBLockTakesX) { LockState ls; - Lock::DBLock dbWrite(&ls, "db", newlm::MODE_X); + Lock::DBLock dbWrite(&ls, "db", MODE_X); - const newlm::ResourceId resIdDb(newlm::RESOURCE_DATABASE, string("db")); - ASSERT(ls.getLockMode(resIdDb) == newlm::MODE_X); + const ResourceId resIdDb(RESOURCE_DATABASE, string("db")); + ASSERT(ls.getLockMode(resIdDb) == MODE_X); } TEST(DConcurrency, MultipleWriteDBLocksOnSameThread) { LockState ls; - Lock::DBLock r1(&ls, "db1", newlm::MODE_X); - Lock::DBLock r2(&ls, "db1", newlm::MODE_X); + Lock::DBLock r1(&ls, "db1", MODE_X); + Lock::DBLock r2(&ls, "db1", MODE_X); ASSERT(ls.isWriteLocked("db1")); } @@ -154,7 +155,7 @@ namespace mongo { TEST(DConcurrency, MultipleConflictingDBLocksOnSameThread) { LockState ls; - Lock::DBLock r1(&ls, "db1", newlm::MODE_X); + Lock::DBLock r1(&ls, "db1", MODE_X); Lock::DBRead r2(&ls, "db1"); ASSERT(ls.isWriteLocked("db1")); @@ -163,12 +164,12 @@ namespace mongo { TEST(DConcurrenty, IntentCollectionLock) { LockState ls; const std::string ns("db1.coll"); - const newlm::ResourceId id(newlm::RESOURCE_COLLECTION, ns); - Lock::DBLock r1(&ls, "db1", newlm::MODE_X); + const ResourceId id(RESOURCE_COLLECTION, ns); + Lock::DBLock r1(&ls, "db1", MODE_X); { - Lock::CollectionLock r2(&ls, ns, newlm::MODE_S); + Lock::CollectionLock r2(&ls, ns, MODE_S); ASSERT(ls.isAtLeastReadLocked(ns)); } - ASSERT(ls.getLockMode(id) == newlm::MODE_NONE); + ASSERT(ls.getLockMode(id) == MODE_NONE); } } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_mgr_new.cpp b/src/mongo/db/concurrency/lock_mgr_new.cpp index f94837d1a89..685c541a9da 100644 --- a/src/mongo/db/concurrency/lock_mgr_new.cpp +++ b/src/mongo/db/concurrency/lock_mgr_new.cpp @@ -38,7 +38,6 @@ namespace mongo { -namespace newlm { namespace { @@ -733,5 +732,4 @@ namespace newlm { recursiveCount = 0; } -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_mgr_new.h b/src/mongo/db/concurrency/lock_mgr_new.h index 991c4d69304..21bee164bed 100644 --- a/src/mongo/db/concurrency/lock_mgr_new.h +++ b/src/mongo/db/concurrency/lock_mgr_new.h @@ -47,9 +47,6 @@ namespace mongo { class Locker; - -namespace newlm { - struct LockHead; /** @@ -77,9 +74,6 @@ namespace newlm { LockModesCount = 5, }; - // To ensure lock modes are not added without updating the counts - BOOST_STATIC_ASSERT(LockModesCount == MODE_X + 1); - /** * Return values for the locking functions of the lock manager. @@ -343,5 +337,4 @@ namespace newlm { bool _noCheckForLeakedLocksTestOnly; }; -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_mgr_new_test.cpp b/src/mongo/db/concurrency/lock_mgr_new_test.cpp index 11d77656aee..a5cb80611ff 100644 --- a/src/mongo/db/concurrency/lock_mgr_new_test.cpp +++ b/src/mongo/db/concurrency/lock_mgr_new_test.cpp @@ -31,7 +31,6 @@ namespace mongo { -namespace newlm { TEST(ResourceId, Semantics) { ResourceId resIdDb(RESOURCE_DATABASE, 324334234); @@ -635,5 +634,4 @@ namespace newlm { checkConflict(MODE_X, MODE_X, true); } -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_mgr_test_help.h b/src/mongo/db/concurrency/lock_mgr_test_help.h index a711002284f..f9bf57cfd99 100644 --- a/src/mongo/db/concurrency/lock_mgr_test_help.h +++ b/src/mongo/db/concurrency/lock_mgr_test_help.h @@ -32,7 +32,6 @@ #include "mongo/db/concurrency/lock_state.h" namespace mongo { -namespace newlm { class TrackingLockGrantNotification : public LockGrantNotification { public: @@ -53,5 +52,4 @@ namespace newlm { LockResult lastResult; }; -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_state.cpp b/src/mongo/db/concurrency/lock_state.cpp index 0729efce3f4..e69e149d40e 100644 --- a/src/mongo/db/concurrency/lock_state.cpp +++ b/src/mongo/db/concurrency/lock_state.cpp @@ -37,7 +37,6 @@ namespace mongo { -namespace newlm { namespace { @@ -64,8 +63,44 @@ namespace newlm { const ResourceId resourceIdLocalDB = ResourceId(RESOURCE_DATABASE, string("local")); - bool isSharedMode(newlm::LockMode mode) { - return (mode == newlm::MODE_IS || mode == newlm::MODE_S); + /** + * Returns whether the passed in mode is S or IS. Used for validation checks. + */ + bool isSharedMode(LockMode mode) { + return (mode == MODE_IS || mode == MODE_S); + } + + /** + * Whether the particular lock's release should be held until the end of the operation. + */ + bool shouldDelayUnlock(const ResourceId& resId, LockMode mode) { + // Global and flush lock are not used to protect transactional resources and as such, they + // need to be acquired and released when requested. + if (resId == resourceIdGlobal) { + return false; + } + + if (resId == resourceIdMMAPV1Flush) { + return false; + } + + switch (mode) { + // unlocks of exclusive locks are delayed to the end of the WUOW + case MODE_X: + case MODE_IX: + return true; + + // nothing else should be + case MODE_IS: + case MODE_S: + return false; + + // these should never be passed in + case MODE_NONE: + invariant(false); + } + + invariant(false); } } @@ -97,12 +132,12 @@ namespace newlm { } const StringData db = nsToDatabaseSubstring(ns); - const newlm::ResourceId resIdNs(newlm::RESOURCE_DATABASE, db); + const ResourceId resIdNs(RESOURCE_DATABASE, db); - return isLockHeldForMode(resIdNs, newlm::MODE_X); + return isLockHeldForMode(resIdNs, MODE_X); } - bool LockerImpl::isDbLockedForMode(const StringData& dbName, newlm::LockMode mode) const { + bool LockerImpl::isDbLockedForMode(const StringData& dbName, LockMode mode) const { DEV { const NamespaceString nss(dbName); dassert(nss.coll().empty()); @@ -111,7 +146,7 @@ namespace newlm { if (isW()) return true; if (isR() && isSharedMode(mode)) return true; - const newlm::ResourceId resIdDb(newlm::RESOURCE_DATABASE, dbName); + const ResourceId resIdDb(RESOURCE_DATABASE, dbName); return isLockHeldForMode(resIdDb, mode); } @@ -124,20 +159,20 @@ namespace newlm { } const StringData db = nsToDatabaseSubstring(ns); - const newlm::ResourceId resIdDb(newlm::RESOURCE_DATABASE, db); + const ResourceId resIdDb(RESOURCE_DATABASE, db); // S on the database means we don't need to check further down the hierarchy - if (isLockHeldForMode(resIdDb, newlm::MODE_S)) { + if (isLockHeldForMode(resIdDb, MODE_S)) { return true; } - if (!isLockHeldForMode(resIdDb, newlm::MODE_IS)) { + if (!isLockHeldForMode(resIdDb, MODE_IS)) { return false; } if (nsIsFull(ns)) { - const newlm::ResourceId resIdColl(newlm::RESOURCE_DATABASE, ns); - return isLockHeldForMode(resIdColl, newlm::MODE_IS); + const ResourceId resIdColl(RESOURCE_DATABASE, ns); + return isLockHeldForMode(resIdColl, MODE_IS); } // We're just asking about a database, so IS on the db is enough. @@ -489,38 +524,6 @@ namespace newlm { return result; } -namespace { - bool shouldDelayUnlock(const ResourceId& resId, LockMode mode) { - // Global and flush lock are not used to protect transactional resources and as such, they - // need to be acquired and released when requested. - if (resId == resourceIdGlobal) { - return false; - } - - if (resId == resourceIdMMAPV1Flush) { - return false; - } - - switch (mode) { - // unlocks of exclusive locks are delayed to the end of the WUOW - case MODE_X: - case MODE_IX: - return true; - - // nothing else should be - case MODE_IS: - case MODE_S: - return false; - - // these should never be passed in - case MODE_NONE: - invariant(false); - } - - invariant(false); - } -} // namespace - bool LockerImpl::unlock(const ResourceId& resId) { LockRequest* request = _find(resId); @@ -743,5 +746,4 @@ namespace { invariant(_locker->unlock(resourceIdMMAPV1Flush)); } -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/lock_state.h b/src/mongo/db/concurrency/lock_state.h index 2201a4fc9e0..c321b6415c7 100644 --- a/src/mongo/db/concurrency/lock_state.h +++ b/src/mongo/db/concurrency/lock_state.h @@ -35,8 +35,7 @@ namespace mongo { -namespace newlm { - + /** * Notfication callback, which stores the last notification result and signals a condition * variable, which can be waited on. @@ -217,7 +216,7 @@ namespace newlm { virtual bool isLocked() const; virtual bool isWriteLocked() const; virtual bool isWriteLocked(const StringData& ns) const; - virtual bool isDbLockedForMode(const StringData& dbName, newlm::LockMode mode) const; + virtual bool isDbLockedForMode(const StringData& dbName, LockMode mode) const; virtual bool isAtLeastReadLocked(const StringData& ns) const; virtual bool isRecursive() const; @@ -296,14 +295,12 @@ namespace newlm { private: Locker* _locker; }; - -} // namespace newlm /** * This will go away as a separate step. */ - class LockState : public newlm::LockerImpl { + class LockState : public LockerImpl { public: LockState() { } diff --git a/src/mongo/db/concurrency/lock_state_test.cpp b/src/mongo/db/concurrency/lock_state_test.cpp index ee1fd2682d3..80e1e98de3b 100644 --- a/src/mongo/db/concurrency/lock_state_test.cpp +++ b/src/mongo/db/concurrency/lock_state_test.cpp @@ -35,7 +35,6 @@ namespace mongo { -namespace newlm { TEST(LockerImpl, LockNoConflict) { const ResourceId resId(RESOURCE_COLLECTION, std::string("TestDB.collection")); @@ -153,12 +152,12 @@ namespace newlm { locker.endWriteUnitOfWork(); { - newlm::AutoYieldFlushLockForMMAPV1Commit flushLockYield(&locker); + AutoYieldFlushLockForMMAPV1Commit flushLockYield(&locker); // This block simulates the flush/remap thread { LockerImpl flushLocker(2); - newlm::AutoAcquireFlushLockForMMAPV1Commit flushLockAcquire(&flushLocker); + AutoAcquireFlushLockForMMAPV1Commit flushLockAcquire(&flushLocker); } } @@ -254,5 +253,4 @@ namespace newlm { locker.unlockAll(); } -} // namespace newlm } // namespace mongo diff --git a/src/mongo/db/concurrency/locker.h b/src/mongo/db/concurrency/locker.h index e8d68eafdd3..02974ddce21 100644 --- a/src/mongo/db/concurrency/locker.h +++ b/src/mongo/db/concurrency/locker.h @@ -75,7 +75,7 @@ namespace mongo { * acquired within the specified time bound. Otherwise, the respective failure * code and neither lock will be acquired. */ - virtual newlm::LockResult lockGlobal(newlm::LockMode mode, + virtual LockResult lockGlobal(LockMode mode, unsigned timeoutMs = UINT_MAX) = 0; /** @@ -127,8 +127,8 @@ namespace mongo { * * @return All LockResults except for LOCK_WAITING, because it blocks. */ - virtual newlm::LockResult lock(const newlm::ResourceId& resId, - newlm::LockMode mode, + virtual LockResult lock(const ResourceId& resId, + LockMode mode, unsigned timeoutMs = UINT_MAX) = 0; /** @@ -138,7 +138,7 @@ namespace mongo { * @return true if the lock was actually released; false if only the reference count was * decremented, but the lock is still held. */ - virtual bool unlock(const newlm::ResourceId& resId) = 0; + virtual bool unlock(const ResourceId& resId) = 0; /** * Retrieves the mode in which a lock is held or checks whether the lock held for a @@ -147,9 +147,9 @@ namespace mongo { * For example isLockHeldForMode will return true for MODE_S, if MODE_X is already held, * because MODE_X covers MODE_S. */ - virtual newlm::LockMode getLockMode(const newlm::ResourceId& resId) const = 0; - virtual bool isLockHeldForMode(const newlm::ResourceId& resId, - newlm::LockMode mode) const = 0; + virtual LockMode getLockMode(const ResourceId& resId) const = 0; + virtual bool isLockHeldForMode(const ResourceId& resId, + LockMode mode) const = 0; /** * LockSnapshot captures the state of all resources that are locked, what modes they're @@ -157,17 +157,17 @@ namespace mongo { */ struct LockSnapshot { // The global lock is handled differently from all other locks. - newlm::LockMode globalMode; + LockMode globalMode; // One can acquire the global lock repeatedly. unsigned globalRecursiveCount; struct OneLock { // What lock resource is held? - newlm::ResourceId resourceId; + ResourceId resourceId; // In what mode is it held? - newlm::LockMode mode; + LockMode mode; // What's the recursive count of this lock? Note that we don't store any state // about how we got this lock (eg upgrade), just how many times we've locked it @@ -222,7 +222,7 @@ namespace mongo { virtual bool isLocked() const = 0; virtual bool isWriteLocked() const = 0; virtual bool isWriteLocked(const StringData& ns) const = 0; - virtual bool isDbLockedForMode(const StringData& dbName, newlm::LockMode mode) const = 0; + virtual bool isDbLockedForMode(const StringData& dbName, LockMode mode) const = 0; virtual bool isAtLeastReadLocked(const StringData& ns) const = 0; virtual bool isRecursive() const = 0; diff --git a/src/mongo/db/concurrency/resource_id.h b/src/mongo/db/concurrency/resource_id.h index b5503fba9d5..8631619d37b 100644 --- a/src/mongo/db/concurrency/resource_id.h +++ b/src/mongo/db/concurrency/resource_id.h @@ -37,7 +37,6 @@ namespace mongo { -namespace newlm { /** * Hierarchy of resource types. The lock manager knows nothing about this hierarchy, it is @@ -115,13 +114,12 @@ namespace newlm { // // BOOST_STATIC_ASSERT(sizeof(ResourceId) == sizeof(uint64_t)); -} // namespace newlm } // namespace mongo MONGO_HASH_NAMESPACE_START - template <> struct hash<mongo::newlm::ResourceId> { - size_t operator()(const mongo::newlm::ResourceId& resource) const { + template <> struct hash<mongo::ResourceId> { + size_t operator()(const mongo::ResourceId& resource) const { return resource; } }; diff --git a/src/mongo/db/dbcommands.cpp b/src/mongo/db/dbcommands.cpp index 4b010e4ce9b..992eb942ca2 100644 --- a/src/mongo/db/dbcommands.cpp +++ b/src/mongo/db/dbcommands.cpp @@ -349,7 +349,7 @@ namespace mongo { // Needs to be locked exclusively, because creates the system.profile collection // in the local database. // - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, dbname); BSONElement e = cmdObj.firstElement(); @@ -404,7 +404,7 @@ namespace mongo { // This doesn't look like it requires exclusive DB lock, because it uses its own diag // locking, but originally the lock was set to be WRITE, so preserving the behaviour. // - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, dbname); int was = _diaglog.setLevel( cmdObj.firstElement().numberInt() ); @@ -460,7 +460,7 @@ namespace mongo { return false; } - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, nsToDrop); Database* db = ctx.db(); @@ -560,7 +560,7 @@ namespace mongo { !options["capped"].trueValue() || options["size"].isNumber() || options.hasField("$nExtents")); - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, ns); @@ -951,7 +951,7 @@ namespace mongo { bool run(OperationContext* txn, const string& dbname, BSONObj& jsobj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl ) { const string ns = dbname + "." + jsobj.firstElement().valuestr(); - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, ns ); @@ -1095,7 +1095,7 @@ namespace mongo { // We lock the entire database in S-mode in order to ensure that the contents will not // change for the stats snapshot. This might be unnecessary and if it becomes a // performance issue, we can take IS lock and then lock collection-by-collection. - AutoGetDb autoDb(txn, ns, newlm::MODE_S); + AutoGetDb autoDb(txn, ns, MODE_S); result.append("db", ns); diff --git a/src/mongo/db/exec/stagedebug_cmd.cpp b/src/mongo/db/exec/stagedebug_cmd.cpp index e2db4f3a120..75bcfb3dce9 100644 --- a/src/mongo/db/exec/stagedebug_cmd.cpp +++ b/src/mongo/db/exec/stagedebug_cmd.cpp @@ -121,7 +121,7 @@ namespace mongo { // TODO A write lock is currently taken here to accommodate stages that perform writes // (e.g. DeleteStage). This should be changed to use a read lock for read-only // execution trees. - Lock::DBLock lk(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, dbname); // Make sure the collection is valid. diff --git a/src/mongo/db/index_builder.cpp b/src/mongo/db/index_builder.cpp index 737cb4d1196..915b468891b 100644 --- a/src/mongo/db/index_builder.cpp +++ b/src/mongo/db/index_builder.cpp @@ -71,7 +71,7 @@ namespace mongo { txn.getCurOp()->reset(HostAndPort(), dbInsert); NamespaceString ns(_index["ns"].String()); - Lock::DBLock dlk(txn.lockState(), ns.db(), newlm::MODE_X); + Lock::DBLock dlk(txn.lockState(), ns.db(), MODE_X); Client::Context ctx(&txn, ns.getSystemIndexesCollection()); Database* db = dbHolder().get(&txn, ns.db().toString()); diff --git a/src/mongo/db/index_rebuilder.cpp b/src/mongo/db/index_rebuilder.cpp index fa494c5f220..58bb3b98501 100644 --- a/src/mongo/db/index_rebuilder.cpp +++ b/src/mongo/db/index_rebuilder.cpp @@ -64,7 +64,7 @@ namespace { // This write lock is held throughout the index building process // for this namespace. - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); Client::Context ctx(txn, ns); Collection* collection = ctx.db()->getCollection(txn, ns); @@ -147,7 +147,7 @@ namespace { for (std::vector<std::string>::const_iterator dbName = dbNames.begin(); dbName < dbNames.end(); ++dbName) { - AutoGetDb autoDb(txn, *dbName, newlm::MODE_S); + AutoGetDb autoDb(txn, *dbName, MODE_S); Database* db = autoDb.getDb(); db->getDatabaseCatalogEntry()->getCollectionNamespaces(&collNames); diff --git a/src/mongo/db/instance.cpp b/src/mongo/db/instance.cpp index e2f53df9ef3..67fa4f2c00c 100644 --- a/src/mongo/db/instance.cpp +++ b/src/mongo/db/instance.cpp @@ -623,8 +623,8 @@ namespace mongo { { // Tentatively take an intent lock, fix up if we need to create the collection - Lock::DBLock dbLock(txn->lockState(), ns.db(), newlm::MODE_IX); - Lock::CollectionLock colLock(txn->lockState(), ns.ns(), newlm::MODE_IX); + Lock::DBLock dbLock(txn->lockState(), ns.db(), MODE_IX); + Lock::CollectionLock colLock(txn->lockState(), ns.ns(), MODE_IX); Client::Context ctx(txn, ns); // The common case: no implicit collection creation @@ -640,7 +640,7 @@ namespace mongo { // This is an upsert into a non-existing database, so need an exclusive lock // to avoid deadlock { - Lock::DBLock dbLock(txn->lockState(), ns.db(), newlm::MODE_X); + Lock::DBLock dbLock(txn->lockState(), ns.db(), MODE_X); Client::Context ctx(txn, ns); UpdateResult res = executor.execute(ctx.db()); lastError.getSafe()->recordUpdate( res.existing , res.numMatched , res.upserted ); @@ -672,8 +672,8 @@ namespace mongo { DeleteExecutor executor(&request); uassertStatusOK(executor.prepare()); - Lock::DBLock dbLocklk(txn->lockState(), ns.db(), newlm::MODE_IX); - Lock::CollectionLock colLock(txn->lockState(), ns.ns(), newlm::MODE_IX); + Lock::DBLock dbLocklk(txn->lockState(), ns.db(), MODE_IX); + Lock::CollectionLock colLock(txn->lockState(), ns.ns(), MODE_IX); Client::Context ctx(txn, ns); long long n = executor.execute(ctx.db()); @@ -935,7 +935,7 @@ namespace mongo { const int notMasterCodeForInsert = 10058; // This is different from ErrorCodes::NotMaster { const bool isIndexBuild = (nsToCollectionSubstring(ns) == "system.indexes"); - const newlm::LockMode mode = isIndexBuild ? newlm::MODE_X : newlm::MODE_IX; + const LockMode mode = isIndexBuild ? MODE_X : MODE_IX; Lock::DBLock dbLock(txn->lockState(), nsString.db(), mode); Lock::CollectionLock collLock(txn->lockState(), nsString.ns(), mode); @@ -945,7 +945,7 @@ namespace mongo { repl::getGlobalReplicationCoordinator()->canAcceptWritesForDatabase(nsString.db())); Client::Context ctx(txn, ns); - if (mode == newlm::MODE_X || ctx.db()->getCollection(txn, nsString)) { + if (mode == MODE_X || ctx.db()->getCollection(txn, nsString)) { if (multi.size() > 1) { const bool keepGoing = d.reservedField() & InsertOption_ContinueOnError; insertMulti(txn, ctx, keepGoing, ns, multi, op); @@ -959,7 +959,7 @@ namespace mongo { } // Collection didn't exist so try again with MODE_X - Lock::DBLock dbLock(txn->lockState(), nsString.db(), newlm::MODE_X); + Lock::DBLock dbLock(txn->lockState(), nsString.db(), MODE_X); // CONCURRENCY TODO: is being read locked in big log sufficient here? // writelock is used to synchronize stepdowns w/ writes diff --git a/src/mongo/db/introspect.cpp b/src/mongo/db/introspect.cpp index aa6cf2eda1f..1aac02076d6 100644 --- a/src/mongo/db/introspect.cpp +++ b/src/mongo/db/introspect.cpp @@ -138,7 +138,7 @@ namespace { // NOTE: It's kind of weird that we lock the op's namespace, but have to for now // since we're sometimes inside the lock already const string dbname(nsToDatabase(currentOp.getNS())); - Lock::DBLock lk(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), dbname, MODE_X); if (dbHolder().get(txn, dbname) != NULL) { // We are ok with the profiling happening in a different WUOW from the actual op. WriteUnitOfWork wunit(txn); diff --git a/src/mongo/db/operation_context_impl.cpp b/src/mongo/db/operation_context_impl.cpp index a7f66d5452a..31bac237f05 100644 --- a/src/mongo/db/operation_context_impl.cpp +++ b/src/mongo/db/operation_context_impl.cpp @@ -48,7 +48,7 @@ namespace mongo { invariant(storageEngine); _recovery.reset(storageEngine->newRecoveryUnit(this)); - _locker.reset(new newlm::LockerImpl()); + _locker.reset(new LockerImpl()); getGlobalEnvironment()->registerOperationContext(this); } diff --git a/src/mongo/db/ops/update_executor.cpp b/src/mongo/db/ops/update_executor.cpp index 12bb3e89a73..efa88679628 100644 --- a/src/mongo/db/ops/update_executor.cpp +++ b/src/mongo/db/ops/update_executor.cpp @@ -124,7 +124,7 @@ namespace mongo { LOG(0) << "About to upgrade to exclusive lock on " + nsString.ns(); } - Lock::DBLock lk(txn->lockState(), nsString.db(), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsString.db(), MODE_X); WriteUnitOfWork wuow(txn); invariant(db->createCollection(txn, nsString.ns())); diff --git a/src/mongo/db/prefetch.cpp b/src/mongo/db/prefetch.cpp index 958f6039046..7638320722f 100644 --- a/src/mongo/db/prefetch.cpp +++ b/src/mongo/db/prefetch.cpp @@ -175,7 +175,7 @@ namespace { // This will have to change for engines other than MMAP V1, because they might not have // means for directly prefetching pages from the collection. For this purpose, acquire S // lock on the database, instead of optimizing with IS. - Lock::CollectionLock collLock(txn->lockState(), ns, newlm::MODE_S); + Lock::CollectionLock collLock(txn->lockState(), ns, MODE_S); Collection* collection = db->getCollection( txn, ns ); if (!collection) { diff --git a/src/mongo/db/repl/master_slave.cpp b/src/mongo/db/repl/master_slave.cpp index 123d52bf344..ff66e43cdbc 100644 --- a/src/mongo/db/repl/master_slave.cpp +++ b/src/mongo/db/repl/master_slave.cpp @@ -168,7 +168,7 @@ namespace repl { bool exists = Helpers::getSingleton(txn, "local.me", _me); if (!exists || !_me.hasField("host") || _me["host"].String() != myname) { - Lock::DBLock dblk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock dblk(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); // clean out local.me Helpers::emptyCollection(txn, "local.me"); diff --git a/src/mongo/db/repl/minvalid.cpp b/src/mongo/db/repl/minvalid.cpp index 47620adbb06..db4afb3e345 100644 --- a/src/mongo/db/repl/minvalid.cpp +++ b/src/mongo/db/repl/minvalid.cpp @@ -49,14 +49,14 @@ namespace { } // namespace void clearInitialSyncFlag(OperationContext* txn) { - Lock::DBLock lk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); Helpers::putSingleton(txn, minvalidNS, BSON("$unset" << initialSyncFlag)); wunit.commit(); } void setInitialSyncFlag(OperationContext* txn) { - Lock::DBLock lk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); Helpers::putSingleton(txn, minvalidNS, BSON("$set" << initialSyncFlag)); wunit.commit(); @@ -72,7 +72,7 @@ namespace { } void setMinValid(OperationContext* ctx, OpTime ts) { - Lock::DBLock lk(ctx->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(ctx->lockState(), "local", MODE_X); WriteUnitOfWork wunit(ctx); Helpers::putSingleton(ctx, minvalidNS, BSON("$set" << BSON("ts" << ts))); wunit.commit(); diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp index 12596e0ce63..8f22452d69f 100644 --- a/src/mongo/db/repl/oplog.cpp +++ b/src/mongo/db/repl/oplog.cpp @@ -120,7 +120,7 @@ namespace repl { todo : make _logOpRS() call this so we don't repeat ourself? */ OpTime _logOpObjRS(OperationContext* txn, const BSONObj& op) { - Lock::DBLock lk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), "local", MODE_X); // XXX soon this needs to be part of an outer WUOW not its own. // We can't do this yet due to locking limitations. WriteUnitOfWork wunit(txn); @@ -237,7 +237,7 @@ namespace repl { BSONObj *o2, bool *bb, bool fromMigrate ) { - Lock::DBLock lk1(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk1(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); if ( strncmp(ns, "local.", 6) == 0 ) { @@ -321,7 +321,7 @@ namespace repl { BSONObj *o2, bool *bb, bool fromMigrate ) { - Lock::DBLock lk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); static BufBuilder bufbuilder(8*1024); // todo there is likely a mutex on this constructor diff --git a/src/mongo/db/repl/repl_coordinator_external_state_impl.cpp b/src/mongo/db/repl/repl_coordinator_external_state_impl.cpp index 4d359bd023e..ae4509f027a 100644 --- a/src/mongo/db/repl/repl_coordinator_external_state_impl.cpp +++ b/src/mongo/db/repl/repl_coordinator_external_state_impl.cpp @@ -102,7 +102,7 @@ namespace { std::string myname = getHostName(); OID myRID; { - Lock::DBLock lock(txn->lockState(), meDatabaseName, newlm::MODE_X); + Lock::DBLock lock(txn->lockState(), meDatabaseName, MODE_X); BSONObj me; // local.me is an identifier for a server for getLastError w:2+ @@ -148,7 +148,7 @@ namespace { OperationContext* txn, const BSONObj& config) { try { - Lock::DBLock dbWriteLock(txn->lockState(), configDatabaseName, newlm::MODE_X); + Lock::DBLock dbWriteLock(txn->lockState(), configDatabaseName, MODE_X); Helpers::putSingleton(txn, configCollectionName, config); return Status::OK(); } diff --git a/src/mongo/db/repl/rs_initialsync.cpp b/src/mongo/db/repl/rs_initialsync.cpp index 0226547127d..6799d5df3c3 100644 --- a/src/mongo/db/repl/rs_initialsync.cpp +++ b/src/mongo/db/repl/rs_initialsync.cpp @@ -84,7 +84,7 @@ namespace { options.syncIndexes = ! dataPass; // Make database stable - Lock::DBLock dbWrite(txn->lockState(), db, newlm::MODE_X); + Lock::DBLock dbWrite(txn->lockState(), db, MODE_X); if (!cloner.go(txn, db, host, options, NULL, err, &errCode)) { log() << "initial sync: error while " @@ -280,7 +280,7 @@ namespace { log() << "initial sync finishing up"; { - AutoGetDb autodb(&txn, "local", newlm::MODE_X); + AutoGetDb autodb(&txn, "local", MODE_X); WriteUnitOfWork wunit(&txn); OpTime lastOpTimeWritten(getGlobalReplicationCoordinator()->getMyLastOptime()); log() << "replSet set minValid=" << lastOpTimeWritten << rsLog; diff --git a/src/mongo/db/repl/sync_source_feedback.cpp b/src/mongo/db/repl/sync_source_feedback.cpp index 28cb8c12384..ab285fedb72 100644 --- a/src/mongo/db/repl/sync_source_feedback.cpp +++ b/src/mongo/db/repl/sync_source_feedback.cpp @@ -78,7 +78,7 @@ namespace repl { void SyncSourceFeedback::ensureMe(OperationContext* txn) { string myname = getHostName(); { - Lock::DBLock dlk(txn->lockState(), "local", newlm::MODE_X); + Lock::DBLock dlk(txn->lockState(), "local", MODE_X); WriteUnitOfWork wunit(txn); Client::Context ctx(txn, "local"); diff --git a/src/mongo/db/repl/sync_tail.cpp b/src/mongo/db/repl/sync_tail.cpp index 683990a5dab..dd341ee4ea1 100644 --- a/src/mongo/db/repl/sync_tail.cpp +++ b/src/mongo/db/repl/sync_tail.cpp @@ -124,7 +124,7 @@ namespace repl { lk.reset(new Lock::GlobalWrite(txn->lockState())); } else { // DB level lock for this operation - lk.reset(new Lock::DBLock(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X)); + lk.reset(new Lock::DBLock(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X)); } Client::Context ctx(txn, ns); @@ -332,7 +332,7 @@ namespace { BackgroundSync* bgsync = BackgroundSync::get(); if (bgsync->getInitialSyncRequestedFlag()) { // got a resync command - Lock::DBLock lk(txn.lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn.lockState(), "local", MODE_X); WriteUnitOfWork wunit(&txn); Client::Context ctx(&txn, "local"); @@ -500,7 +500,7 @@ namespace { OpTime lastOpTime; { OperationContextImpl txn; // XXX? - Lock::DBLock lk(txn.lockState(), "local", newlm::MODE_X); + Lock::DBLock lk(txn.lockState(), "local", MODE_X); WriteUnitOfWork wunit(&txn); while (!ops->empty()) { diff --git a/src/mongo/db/storage/mmap_v1/dur.cpp b/src/mongo/db/storage/mmap_v1/dur.cpp index 71bb5c4f2c8..47357b21141 100644 --- a/src/mongo/db/storage/mmap_v1/dur.cpp +++ b/src/mongo/db/storage/mmap_v1/dur.cpp @@ -231,7 +231,7 @@ namespace mongo { NotifyAll::When when = commitJob._notify.now(); - newlm::AutoYieldFlushLockForMMAPV1Commit flushLockYield(txn->lockState()); + AutoYieldFlushLockForMMAPV1Commit flushLockYield(txn->lockState()); // There is always just one waiting anyways flushRequested.notify_one(); @@ -653,7 +653,7 @@ namespace mongo { // Waits for all active operations to drain and won't let new ones start. This // should be optimized to allow readers in (see SERVER-15262). - newlm::AutoAcquireFlushLockForMMAPV1Commit flushLock(txn.lockState()); + AutoAcquireFlushLockForMMAPV1Commit flushLock(txn.lockState()); groupCommit(); remapPrivateView(); diff --git a/src/mongo/dbtests/counttests.cpp b/src/mongo/dbtests/counttests.cpp index 4d0f87bb811..10f823a6c39 100644 --- a/src/mongo/dbtests/counttests.cpp +++ b/src/mongo/dbtests/counttests.cpp @@ -43,7 +43,7 @@ namespace CountTests { class Base { public: - Base() : _lk(_txn.lockState(), nsToDatabaseSubstring(ns()), newlm::MODE_X), + Base() : _lk(_txn.lockState(), nsToDatabaseSubstring(ns()), MODE_X), _context(&_txn, ns()), _client(&_txn) { _database = _context.db(); diff --git a/src/mongo/dbtests/dbhelper_tests.cpp b/src/mongo/dbtests/dbhelper_tests.cpp index a49fb91bd9f..987874ff3b3 100644 --- a/src/mongo/dbtests/dbhelper_tests.cpp +++ b/src/mongo/dbtests/dbhelper_tests.cpp @@ -62,7 +62,7 @@ namespace mongo { { // Remove _id range [_min, _max). - Lock::DBLock lk(txn.lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn.lockState(), nsToDatabaseSubstring(ns), MODE_X); WriteUnitOfWork wunit(&txn); Client::Context ctx(&txn, ns ); diff --git a/src/mongo/dbtests/framework.cpp b/src/mongo/dbtests/framework.cpp index bff325eaa4a..5c3f37421e8 100644 --- a/src/mongo/dbtests/framework.cpp +++ b/src/mongo/dbtests/framework.cpp @@ -96,7 +96,7 @@ namespace mongo { warning() << currentTestName << " has been running for more than " << minutesRunning-1 << " minutes." << endl; // See what is stuck - newlm::LockerImpl::dumpGlobalLockManager(); + LockerImpl::dumpGlobalLockManager(); } } } diff --git a/src/mongo/dbtests/namespacetests.cpp b/src/mongo/dbtests/namespacetests.cpp index d755d355a82..d4dbca8fe92 100644 --- a/src/mongo/dbtests/namespacetests.cpp +++ b/src/mongo/dbtests/namespacetests.cpp @@ -524,7 +524,7 @@ namespace NamespaceTests { OperationContextImpl txn; - Lock::DBLock lk(txn.lockState(), dbName, newlm::MODE_X); + Lock::DBLock lk(txn.lockState(), dbName, MODE_X); bool justCreated; Database* db = dbHolder().openDb(&txn, dbName, &justCreated); @@ -567,7 +567,7 @@ namespace NamespaceTests { OperationContextImpl txn; - Lock::DBLock lk(txn.lockState(), dbName, newlm::MODE_X); + Lock::DBLock lk(txn.lockState(), dbName, MODE_X); bool justCreated; Database* db = dbHolder().openDb(&txn, dbName, &justCreated); diff --git a/src/mongo/dbtests/querytests.cpp b/src/mongo/dbtests/querytests.cpp index 02e3bcaebd0..cd1c5171fbc 100644 --- a/src/mongo/dbtests/querytests.cpp +++ b/src/mongo/dbtests/querytests.cpp @@ -594,7 +594,7 @@ namespace QueryTests { } void run() { const char *ns = "unittests.querytests.OplogReplaySlaveReadTill"; - Lock::DBLock lk(_txn.lockState(), "unittests", newlm::MODE_X); + Lock::DBLock lk(_txn.lockState(), "unittests", MODE_X); WriteUnitOfWork wunit(&_txn); Client::Context ctx(&_txn, ns ); @@ -1405,7 +1405,7 @@ namespace QueryTests { public: CollectionInternalBase( const char *nsLeaf ) : CollectionBase( nsLeaf ), - _lk(_txn.lockState(), "unittests", newlm::MODE_X), + _lk(_txn.lockState(), "unittests", MODE_X), _ctx(&_txn, ns()) { } diff --git a/src/mongo/dbtests/threadedtests.cpp b/src/mongo/dbtests/threadedtests.cpp index 62ab464fc98..4cd61f73f04 100644 --- a/src/mongo/dbtests/threadedtests.cpp +++ b/src/mongo/dbtests/threadedtests.cpp @@ -187,7 +187,7 @@ namespace ThreadedTests { Lock::DBRead x(&lockState, "local"); } { - Lock::DBLock x(&lockState, "local", newlm::MODE_X); + Lock::DBLock x(&lockState, "local", MODE_X); // No actual writing here, so no WriteUnitOfWork if( sometimes ) { Lock::TempRelease t(&lockState); @@ -199,11 +199,11 @@ namespace ThreadedTests { } { - Lock::DBLock x(&lockState, "admin", newlm::MODE_X); + Lock::DBLock x(&lockState, "admin", MODE_X); } } else if( q == 3 ) { - Lock::DBLock x(&lockState, "foo", newlm::MODE_X); + Lock::DBLock x(&lockState, "foo", MODE_X); Lock::DBRead y(&lockState, "admin"); } else if( q == 4 ) { @@ -211,7 +211,7 @@ namespace ThreadedTests { Lock::DBRead y(&lockState, "admin"); } else { - Lock::DBLock w(&lockState, "foo", newlm::MODE_X); + Lock::DBLock w(&lockState, "foo", MODE_X); { Lock::TempRelease t(&lockState); diff --git a/src/mongo/s/d_merge.cpp b/src/mongo/s/d_merge.cpp index bdfcda69b6b..e934ed97213 100644 --- a/src/mongo/s/d_merge.cpp +++ b/src/mongo/s/d_merge.cpp @@ -293,7 +293,7 @@ namespace mongo { // { - Lock::DBLock writeLk(txn->lockState(), nss.db(), newlm::MODE_X); + Lock::DBLock writeLk(txn->lockState(), nss.db(), MODE_X); shardingState.mergeChunks(txn, nss.ns(), minKey, maxKey, mergeVersion); } diff --git a/src/mongo/s/d_migrate.cpp b/src/mongo/s/d_migrate.cpp index d20b8cd2a61..be56417492f 100644 --- a/src/mongo/s/d_migrate.cpp +++ b/src/mongo/s/d_migrate.cpp @@ -1242,7 +1242,7 @@ namespace mongo { myVersion.incMajor(); { - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); verify( myVersion > shardingState.getVersion( ns ) ); // bump the metadata's version up and "forget" about the chunk being moved @@ -1656,7 +1656,7 @@ namespace mongo { if ( getState() != DONE ) { // Unprotect the range if needed/possible on unsuccessful TO migration - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); string errMsg; if (!shardingState.forgetPending(txn, ns, min, max, epoch, &errMsg)) { warning() << errMsg << endl; @@ -1714,7 +1714,7 @@ namespace mongo { indexSpecs.insert(indexSpecs.begin(), indexes.begin(), indexes.end()); } - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); Client::Context ctx(txn, ns); Database* db = ctx.db(); Collection* collection = db->getCollection( txn, ns ); @@ -1799,7 +1799,7 @@ namespace mongo { { // Protect the range by noting that we're now starting a migration to it - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); if (!shardingState.notePending(txn, ns, min, max, epoch, &errmsg)) { warning() << errmsg << endl; setState(FAIL); @@ -2099,7 +2099,7 @@ namespace mongo { } } - Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock lk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); Client::Context ctx(txn, ns); if (serverGlobalParams.moveParanoia) { diff --git a/src/mongo/s/d_split.cpp b/src/mongo/s/d_split.cpp index 37c535e4eb9..e157e1226b0 100644 --- a/src/mongo/s/d_split.cpp +++ b/src/mongo/s/d_split.cpp @@ -787,7 +787,7 @@ namespace mongo { // { - Lock::DBLock writeLk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock writeLk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); // NOTE: The newShardVersion resulting from this split is higher than any // other chunk version, so it's also implicitly the newCollVersion diff --git a/src/mongo/s/d_state.cpp b/src/mongo/s/d_state.cpp index dcaa8c6a074..332843ff98d 100644 --- a/src/mongo/s/d_state.cpp +++ b/src/mongo/s/d_state.cpp @@ -595,7 +595,7 @@ namespace mongo { { // DBLock needed since we're now potentially changing the metadata, and don't want // reads/writes to be ongoing. - Lock::DBLock writeLk(txn->lockState(), nsToDatabaseSubstring(ns), newlm::MODE_X); + Lock::DBLock writeLk(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X); // // Get the metadata now that the load has completed @@ -1298,7 +1298,7 @@ namespace mongo { } bool run(OperationContext* txn, const string& dbname, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool) { - Lock::DBLock dbXLock(txn->lockState(), dbname, newlm::MODE_X); + Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X); Client::Context ctx(txn, dbname); shardingState.appendInfo( result ); diff --git a/src/mongo/s/metadata_loader.h b/src/mongo/s/metadata_loader.h index a058a1e5cfa..7cf97f4c73e 100644 --- a/src/mongo/s/metadata_loader.h +++ b/src/mongo/s/metadata_loader.h @@ -53,7 +53,7 @@ namespace mongo { * Example usage: * beforeMetadata = <get latest local metadata>; * remoteMetadata = makeCollectionMetadata( beforeMetadata, remoteMetadata ); - * DBLock lock(txn, dbname, newlm::MODE_X); + * DBLock lock(txn, dbname, MODE_X); * afterMetadata = <get latest local metadata>; * promotePendingChunks( afterMetadata, remoteMetadata ); * |