SERVER-16415: Use new OplogIntentWriteLock

Author: GeertBosch

src/mongo/db/concurrency/d_concurrency.cpp

@@ -30,6 +30,8 @@
 
 #include "mongo/db/concurrency/d_concurrency.h"
 
+#include <string>
+
 #include "mongo/db/concurrency/locker.h"
 #include "mongo/db/global_environment_experiment.h"
 #include "mongo/db/namespace_string.h"
@@ -49,6 +51,10 @@ namespace mongo {
     //  SERVER-14668: Remove or invert sense once MMAPv1 CLL can be default
     MONGO_EXPORT_STARTUP_SERVER_PARAMETER(enableCollectionLocking, bool, true);
 
+    // Local Oplog. Used by OplogLock.
+    static const ResourceId resourceIdOplog =
+                    ResourceId(RESOURCE_COLLECTION, StringData("local.oplog.rs"));
+
     DBTryLockTimeoutException::DBTryLockTimeoutException() {}
     DBTryLockTimeoutException::~DBTryLockTimeoutException() throw() { }
 
@@ -213,6 +219,29 @@ namespace mongo {
         }
     }
 
+namespace {
+    boost::mutex oplogSerialization; // for OplogIntentWriteLock
+} // namespace
+
+    Lock::OplogIntentWriteLock::OplogIntentWriteLock(Locker* lockState)
+          : _lockState(lockState),
+            _serialized(false) {
+        _lockState->lock(resourceIdOplog, MODE_IX);
+    }
+
+    Lock::OplogIntentWriteLock::~OplogIntentWriteLock() {
+        if (_serialized) {
+            oplogSerialization.unlock();
+        }
+        _lockState->unlock(resourceIdOplog);
+    }
+
+    void Lock::OplogIntentWriteLock::serializeIfNeeded() {
+        if (!supportsDocLocking() && !_serialized) {
+            oplogSerialization.lock();
+            _serialized = true;
+        }
+    }
 
     Lock::ResourceLock::ResourceLock(Locker* lockState, ResourceId rid, LockMode mode)
             : _rid(rid),

src/mongo/db/concurrency/d_concurrency.h

@@ -191,6 +191,22 @@ namespace mongo {
             Locker* const _lockState;
         };
 
+        /**
+         * Like the CollectionLock, but optimized for the local oplog. Always locks in MODE_IX,
+         * must call serializeIfNeeded() before doing any concurrent operations in order to
+         * support storage engines without document level locking. It is an error, checked with a
+         * dassert(), to not have a suitable database lock when taking this lock.
+         */
+        class OplogIntentWriteLock {
+            MONGO_DISALLOW_COPYING(OplogIntentWriteLock);
+        public:
+            explicit OplogIntentWriteLock(Locker* lockState);
+            ~OplogIntentWriteLock();
+            void serializeIfNeeded();
+        private:
+            Locker* const _lockState;
+            bool _serialized;
+        };
 
         /**
          * General purpose RAII wrapper for a resource managed by the lock manager

src/mongo/db/repl/oplog.cpp

@@ -220,7 +220,7 @@ namespace {
 
         ScopedTransaction transaction(txn, MODE_IX);
         Lock::DBLock lk(txn->lockState(), "local", MODE_IX);
-        Lock::CollectionLock lk2(txn->lockState(), rsoplog, MODE_IX);
+        Lock::OplogIntentWriteLock oplogLk(txn->lockState());
 
         DEV verify( logNS == 0 ); // check this was never a master/slave master
 
@@ -241,11 +241,12 @@ namespace {
         Client::Context ctx(txn, rsoplog, localDB);
         WriteUnitOfWork wunit(txn);
 
-        std::pair<OpTime,long long> slot = getNextOpTime(txn,
-                                                         localOplogRSCollection,
-                                                         ns,
-                                                         replCoord,
-                                                         opstr);
+        oplogLk.serializeIfNeeded();
+        std::pair<OpTime, long long> slot = getNextOpTime(txn,
+                                                          localOplogRSCollection,
+                                                          ns,
+                                                          replCoord,
+                                                          opstr);
 
         /* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
            instead we do a single copy to the destination position in the memory mapped file.