SERVER-14995 Move operation id, lockState and client fields to OperationContext.

They have been moved from OperationContextImpl.  Furthermore, the CurOp stack is
now attached to OperationContext, instead of Client.

With this change, an operation's lifetime is governed by the lifetime of an
OperationContext object.  The "_active" field of CurOp is therefore no longer
meaingful.  This required fixing the lifetime of OperationContext in a few
places.

A future change will adjust operation lifetime timing to time the lifetime of
the OperationContext object, as well.

1 files changed, 24 insertions, 53 deletions

diff --git a/src/mongo/db/curop.cpp b/src/mongo/db/curop.cpp
index 640c82063e0..4c41b5bd365 100644
--- a/src/mongo/db/curop.cpp
+++ b/src/mongo/db/curop.cpp
@@ -56,10 +56,10 @@ namespace mongo {
      *
      * The stack itself is represented in the _parent pointers of the CurOp class.
      */
-    class CurOp::ClientCuropStack {
-        MONGO_DISALLOW_COPYING(ClientCuropStack);
+    class CurOp::CurOpStack {
+        MONGO_DISALLOW_COPYING(CurOpStack);
     public:
-        ClientCuropStack() : _base(nullptr, this) {}
+        CurOpStack() : _base(nullptr, this) {}
 
         /**
          * Returns the top of the CurOp stack.
@@ -69,15 +69,15 @@ namespace mongo {
         /**
          * Adds "curOp" to the top of the CurOp stack for a client. Called by CurOp's constructor.
          */
-        void push(Client* client, CurOp* curOp) {
-            invariant(client);
-            if (_client) {
-                invariant(_client == client);
+        void push(OperationContext* opCtx, CurOp* curOp) {
+            invariant(opCtx);
+            if (_opCtx) {
+                invariant(_opCtx == opCtx);
             }
             else {
-                _client = client;
+                _opCtx = opCtx;
             }
-            boost::lock_guard<Client> lk(*_client);
+            boost::lock_guard<Client> lk(*_opCtx->getClient());
             push_nolock(curOp);
         }
 
@@ -101,20 +101,20 @@ namespace mongo {
             // the client during the final pop.
             const bool shouldLock = _top->_parent;
             if (shouldLock) {
-                invariant(_client);
-                _client->lock();
+                invariant(_opCtx);
+                _opCtx->getClient()->lock();
             }
             invariant(_top);
             CurOp* retval = _top;
             _top = _top->_parent;
             if (shouldLock) {
-                _client->unlock();
+                _opCtx->getClient()->unlock();
             }
             return retval;
         }
 
     private:
-        Client* _client = nullptr;
+        OperationContext* _opCtx = nullptr;
 
         // Top of the stack of CurOps for a Client.
         CurOp* _top = nullptr;
@@ -123,8 +123,8 @@ namespace mongo {
         const CurOp _base;
     };
 
-    const Client::Decoration<CurOp::ClientCuropStack> CurOp::_curopStack =
-        Client::declareDecoration<CurOp::ClientCuropStack>();
+    const OperationContext::Decoration<CurOp::CurOpStack> CurOp::_curopStack =
+        OperationContext::declareDecoration<CurOp::CurOpStack>();
 
     // Enabling the maxTimeAlwaysTimeOut fail point will cause any query or command run with a
     // valid non-zero max time to fail immediately.  Any getmore operation on a cursor already
@@ -146,33 +146,18 @@ namespace mongo {
 
     CurOp* CurOp::get(const OperationContext* opCtx) { return get(*opCtx); }
 
-    CurOp* CurOp::get(const OperationContext& opCtx) {
-        return _curopStack(opCtx.getClient()).top();
-    }
+    CurOp* CurOp::get(const OperationContext& opCtx) { return _curopStack(opCtx).top(); }
 
-    CurOp::CurOp(Client* client) : CurOp(client, &_curopStack(client)) {}
+    CurOp::CurOp(OperationContext* opCtx) : CurOp(opCtx, &_curopStack(opCtx)) {}
 
-    CurOp::CurOp(Client* client, ClientCuropStack* stack) : _stack(stack) {
-        if (client) {
-            _stack->push(client, this);
+    CurOp::CurOp(OperationContext* opCtx, CurOpStack* stack) : _stack(stack) {
+        if (opCtx) {
+            _stack->push(opCtx, this);
         }
         else {
             _stack->push_nolock(this);
         }
         _start = 0;
-        _active = false;
-        _reset();
-        _op = 0;
-        _opNum = _nextOpNum.fetchAndAdd(1);
-        _command = NULL;
-    }
-
-    CurOp::CurOp(Client* client, int op) : CurOp(client, &_curopStack(client)) {
-        _op = op;
-        _active = true;
-    }
-
-    void CurOp::_reset() {
         _isCommand = false;
         _dbprofile = 0;
         _end = 0;
@@ -183,20 +168,11 @@ namespace mongo {
         _killPending.store(0);
         _numYields = 0;
         _expectedLatencyMs = 0;
+        _op = 0;
+        _command = NULL;
     }
 
-    void CurOp::reset() {
-        _reset();
-        _start = 0;
-        _opNum = _nextOpNum.fetchAndAdd(1);
-        _ns = "";
-        _debug.reset();
-        _query.reset();
-        _active = true; // this should be last for ui clarity
-    }
-
-    void CurOp::reset(int op) {
-        reset();
+    void CurOp::setOp(int op) {
         _op = op;
     }
 
@@ -254,11 +230,8 @@ namespace mongo {
     }
 
     void CurOp::reportState(BSONObjBuilder* builder) {
-        builder->append("opid", _opNum);
-        bool a = _active && _start;
-        builder->append("active", a);
 
-        if( a ) {
+        if (_start) {
             builder->append("secs_running", elapsedSeconds() );
             builder->append("microsecs_running", static_cast<long long int>(elapsedMicros()) );
         }
@@ -412,8 +385,6 @@ namespace mongo {
     }
 
 
-    AtomicUInt32 CurOp::_nextOpNum;
-
     static Counter64 returnedCounter;
     static Counter64 insertedCounter;
     static Counter64 updatedCounter;