diff --git a/etc/evergreen.yml b/etc/evergreen.yml
index 3e229a1..c28dd6e 100644
--- a/etc/evergreen.yml
+++ b/etc/evergreen.yml
@@ -245,9 +245,12 @@ functions:
 
         . ./${set_tools_gopath|set_gopath.sh}
 
+        sed -i.bak "s/built-without-version-string/$(git describe)/" common/options/options.go
+        sed -i.bak "s/built-without-git-spec/$(git rev-parse HEAD)/" common/options/options.go
+
         for i in bsondump mongostat mongofiles mongoexport mongoimport mongorestore mongodump mongotop mongooplog; do
-             ${gorootvars} go build -ldflags "-X github.com/mongodb/mongo-tools/common/options.Gitspec $(git rev-parse HEAD) -X github.com/mongodb/mongo-tools/common/options.VersionStr $(git --git-dir ../.git describe)" ${tooltags|} -o "../src/mongo-tools/$i${exe|}" $i/main/$i.go
-             echo $i;
+             ${gorootvars} go build ${tooltags|} -o "../src/mongo-tools/$i${exe|}" $i/main/$i.go
+             "../src/mongo-tools/$i${exe|}" --version
         done
 
   "do setup" :
@@ -3862,7 +3865,7 @@ buildvariants:
   - name: tool_WT
   - name: unittests
   - name: ssl
-  - name: sslspecial
+  - name: sslSpecial
   - name: push
     distros:
     - rhel70
diff --git a/src/mongo/db/concurrency/SConscript b/src/mongo/db/concurrency/SConscript
index ebe267a..dd3679a 100644
--- a/src/mongo/db/concurrency/SConscript
+++ b/src/mongo/db/concurrency/SConscript
@@ -43,6 +43,7 @@ env.CppUnitTest(
             'lock_stats_test.cpp',
     ],
     LIBDEPS=[
-        'lock_manager'
+        '$BUILD_DIR/mongo/util/progress_meter',
+        'lock_manager',
     ]
 )
diff --git a/src/mongo/db/concurrency/lock_manager.cpp b/src/mongo/db/concurrency/lock_manager.cpp
index 6d24500..07d235d 100644
--- a/src/mongo/db/concurrency/lock_manager.cpp
+++ b/src/mongo/db/concurrency/lock_manager.cpp
@@ -191,12 +191,9 @@ struct LockHead {
      * Returns LOCK_WAITING for conflict case and LOCK_OK otherwise.
      */
     LockResult newRequest(LockRequest* request, LockMode mode) {
-        request->mode = mode;
+        invariant(!request->partitionedLock);
         request->lock = this;
-        request->partitionedLock = NULL;
-        if (!partitioned()) {
-            request->recursiveCount = 1;
-        }
+
         // request->partitioned cannot be set to false, as this might be a migration, in
         // which case access to that field is not protected. The 'partitioned' member instead
         // indicates if a request was initially partitioned.
@@ -353,25 +350,20 @@ struct LockHead {
  * May not lock a LockManager bucket while holding a partition lock.
  */
 struct PartitionedLockHead {
+
     void initNew(ResourceId resId) {
         grantedList.reset();
     }
 
     void newRequest(LockRequest* request, LockMode mode) {
-        request->lock = NULL;
+        invariant(request->partitioned);
+        invariant(!request->lock);
         request->partitionedLock = this;
-        request->recursiveCount = 1;
         request->status = LockRequest::STATUS_GRANTED;
-        request->partitioned = true;
-        request->mode = mode;
 
         grantedList.push_back(request);
     }
 
-    //
-    // Granted queue
-    //
-
     // Doubly-linked list of requests, which have been granted. Newly granted requests go to
     // the end of the queue. The PartitionedLockHead never contains anything but granted
     // requests with intent modes.
@@ -395,6 +387,7 @@ void LockHead::migratePartitionedLockHeads() {
             while (!partitionedLock->grantedList.empty()) {
                 LockRequest* request = partitionedLock->grantedList._front;
                 partitionedLock->grantedList.remove(request);
+                request->partitionedLock = NULL;
                 // Ordering is important here, as the next/prev fields are shared.
                 // Note that newRequest() will preserve the recursiveCount in this case
                 LockResult res = newRequest(request, request->mode);
@@ -440,8 +433,10 @@ LockManager::~LockManager() {
 LockResult LockManager::lock(ResourceId resId, LockRequest* request, LockMode mode) {
     // Sanity check that requests are not being reused without proper cleanup
     invariant(request->status == LockRequest::STATUS_NEW);
+    invariant(request->recursiveCount == 1);
 
     request->partitioned = (mode == MODE_IX || mode == MODE_IS);
+    request->mode = mode;
 
     // For intent modes, try the PartitionedLockHead
     if (request->partitioned) {
@@ -545,7 +540,6 @@ LockResult LockManager::convert(ResourceId resId, LockRequest* request, LockMode
     // T1 in S mode, instead of block, which would otherwise cause deadlock.
     if (conflicts(newMode, grantedModesWithoutCurrentRequest)) {
         request->status = LockRequest::STATUS_CONVERTING;
-        invariant(request->recursiveCount > 1);
         request->convertMode = newMode;
 
         lock->conversionsCount++;
@@ -775,11 +769,13 @@ void LockManager::_onLockModeChanged(LockHead* lock, bool checkConflictQueue) {
 
         iter->status = LockRequest::STATUS_GRANTED;
 
+        // Remove from the conflicts list
         lock->conflictList.remove(iter);
-        lock->grantedList.push_back(iter);
+        lock->decConflictModeCount(iter->mode);
 
+        // Add to the granted list
+        lock->grantedList.push_back(iter);
         lock->incGrantedModeCount(iter->mode);
-        lock->decConflictModeCount(iter->mode);
 
         if (iter->compatibleFirst) {
             lock->compatibleFirstCount++;
@@ -796,8 +792,8 @@ void LockManager::_onLockModeChanged(LockHead* lock, bool checkConflictQueue) {
 
     // This is a convenient place to check that the state of the two request queues is in sync
     // with the bitmask on the modes.
-    dassert((lock->grantedModes == 0) ^ (lock->grantedList._front != NULL));
-    dassert((lock->conflictModes == 0) ^ (lock->conflictList._front != NULL));
+    invariant((lock->grantedModes == 0) ^ (lock->grantedList._front != NULL));
+    invariant((lock->conflictModes == 0) ^ (lock->conflictList._front != NULL));
 }
 
 LockManager::LockBucket* LockManager::_getBucket(ResourceId resId) const {
@@ -1087,9 +1083,10 @@ void LockRequest::initNew(Locker* locker, LockGrantNotification* notify) {
 
     enqueueAtFront = false;
     compatibleFirst = false;
-    recursiveCount = 0;
+    recursiveCount = 1;
 
     lock = NULL;
+    partitionedLock = NULL;
     prev = NULL;
     next = NULL;
     status = STATUS_NEW;
diff --git a/src/mongo/db/concurrency/lock_manager_defs.h b/src/mongo/db/concurrency/lock_manager_defs.h
index 48fcb07..0ef12c6 100644
--- a/src/mongo/db/concurrency/lock_manager_defs.h
+++ b/src/mongo/db/concurrency/lock_manager_defs.h
@@ -331,77 +331,112 @@ struct LockRequest {
      */
     void initNew(Locker* locker, LockGrantNotification* notify);
 
-
-    //
-    // These fields are maintained by the Locker class
+    // This is the Locker, which created this LockRequest. Pointer is not owned, just referenced.
+    // Must outlive the LockRequest.
     //
-
-    // This is the Locker, which created this LockRequest. Pointer is not owned, just
-    // referenced. Must outlive the LockRequest.
+    // Written at construction time by Locker
+    // Read by LockManager on any thread
+    // No synchronization
     Locker* locker;
 
-    // Not owned, just referenced. If a request is in the WAITING or CONVERTING state, must
-    // live at least until LockManager::unlock is cancelled or the notification has been
-    // invoked.
+    // Notification to be invoked when the lock is granted. Pointer is not owned, just referenced.
+    // If a request is in the WAITING or CONVERTING state, must live at least until
+    // LockManager::unlock is cancelled or the notification has been invoked.
+    //
+    // Written at construction time by Locker
+    // Read by LockManager
+    // No synchronization
     LockGrantNotification* notify;
 
-
+    // If the request cannot be granted right away, whether to put it at the front or at the end of
+    // the queue. By default, requests are put at the back. If a request is requested to be put at
+    // the front, this effectively bypasses fairness. Default is FALSE.
     //
-    // These fields are maintained by both the LockManager and Locker class
-    //
-
-    // If the request cannot be granted right away, whether to put it at the front or at the
-    // end of the queue. By default, requests are put at the back. If a request is requested
-    // to be put at the front, this effectively bypasses fairness. Default is FALSE.
+    // Written at construction time by Locker
+    // Read by LockManager on any thread
+    // No synchronization
     bool enqueueAtFront;
 
     // When this request is granted and as long as it is on the granted queue, the particular
-    // resource's policy will be changed to "compatibleFirst". This means that even if there
-    // are pending requests on the conflict queue, if a compatible request comes in it will be
-    // granted immediately. This effectively turns off fairness.
+    // resource's policy will be changed to "compatibleFirst". This means that even if there are
+    // pending requests on the conflict queue, if a compatible request comes in it will be granted
+    // immediately. This effectively turns off fairness.
+    //
+    // Written at construction time by Locker
+    // Read by LockManager on any thread
+    // No synchronization
     bool compatibleFirst;
 
-    // When set, an attempt is made to execute this request using partitioned lockheads.
-    // This speeds up the common case where all requested locking modes are compatible with
-    // each other, at the cost of extra overhead for conflicting modes.
+    // When set, an attempt is made to execute this request using partitioned lockheads. This speeds
+    // up the common case where all requested locking modes are compatible with each other, at the
+    // cost of extra overhead for conflicting modes.
+    //
+    // Written by LockManager on Locker thread
+    // Read by LockManager on any thread
+    // No synchronization
     bool partitioned;
 
-    // How many times has LockManager::lock been called for this request. Locks are released
-    // when their recursive count drops to zero.
+    // How many times has LockManager::lock been called for this request. Locks are released when
+    // their recursive count drops to zero.
+    //
+    // Written by LockManager on Locker thread
+    // Read by LockManager on Locker thread
+    // Read by Locker on any thread
+    // No synchronization
     unsigned recursiveCount;
 
+    // Pointer to the lock to which this request belongs, or null if this request has not yet been
+    // assigned to a lock or if it belongs to the PartitionedLockHead for locker (in which case
+    // partitionedLock must be set). The LockHead should be alive as long as there are LockRequests
+    // on it, so it is safe to have this pointer hanging around.
     //
-    // These fields are owned and maintained by the LockManager class exclusively
-    //
-
-
-    // Pointer to the lock to which this request belongs, or null if this request has not yet
-    // been assigned to a lock or if it belongs to the PartitionedLockHead for locker. The
-    // LockHead should be alive as long as there are LockRequests on it, so it is safe to have
-    // this pointer hanging around.
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     LockHead* lock;
 
     // Pointer to the partitioned lock to which this request belongs, or null if it is not
-    // partitioned. Only one of 'lock' and 'partitionedLock' is non-NULL, and a request can
-    // only transition from 'partitionedLock' to 'lock', never the other way around.
+    // partitioned. Only one of 'lock' and 'partitionedLock' is non-NULL, and a request can only
+    // transition from 'partitionedLock' to 'lock', never the other way around.
+    //
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     PartitionedLockHead* partitionedLock;
 
-    // The reason intrusive linked list is used instead of the std::list class is to allow
-    // for entries to be removed from the middle of the list in O(1) time, if they are known
-    // instead of having to search for them and we cannot persist iterators, because the list
-    // can be modified while an iterator is held.
+    // The linked list chain on which this request hangs off the owning lock head. The reason
+    // intrusive linked list is used instead of the std::list class is to allow for entries to be
+    // removed from the middle of the list in O(1) time, if they are known instead of having to
+    // search for them and we cannot persist iterators, because the list can be modified while an
+    // iterator is held.
+    //
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     LockRequest* prev;
     LockRequest* next;
 
-    // Current status of this request.
+    // The current status of this request. Always starts at STATUS_NEW.
+    //
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     Status status;
 
-    // If not granted, the mode which has been requested for this lock. If granted, the mode
-    // in which it is currently granted.
+    // If this request is not granted, the mode which has been requested for this lock. If granted,
+    // the mode in which it is currently granted.
+    //
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     LockMode mode;
 
-    // This value is different from MODE_NONE only if a conversion is requested for a lock and
-    // that conversion cannot be immediately granted.
+    // This value is different from MODE_NONE only if a conversion is requested for a lock and that
+    // conversion cannot be immediately granted.
+    //
+    // Written by LockManager on any thread
+    // Read by LockManager on any thread
+    // Protected by LockHead bucket's mutex
     LockMode convertMode;
 };
 
