diff --git a/db/db_impl.cc b/db/db_impl.cc
index d1003bfdc9..9cc957f857 100644
--- a/db/db_impl.cc
+++ b/db/db_impl.cc
@@ -3331,10 +3331,10 @@ void DBImpl::InstallSuperVersion(DeletionState& deletion_state) {
 DBImpl::SuperVersion* DBImpl::InstallSuperVersion(
     SuperVersion* new_superversion) {
   mutex_.AssertHeld();
+  new_superversion->db = this;
   new_superversion->Init(mem_, imm_.current(), versions_->current());
   SuperVersion* old_superversion = super_version_;
   super_version_ = new_superversion;
-  super_version_->db = this;
   ++super_version_number_;
   super_version_->version_number = super_version_number_;
 
diff --git a/port/port_posix.cc b/port/port_posix.cc
index f7025f4614..911cebdf2d 100644
--- a/port/port_posix.cc
+++ b/port/port_posix.cc
@@ -11,6 +11,7 @@
 
 #include <cstdlib>
 #include <stdio.h>
+#include <assert.h>
 #include <string.h>
 #include "util/logging.h"
 
@@ -45,9 +46,25 @@ Mutex::Mutex(bool adaptive) {
 
 Mutex::~Mutex() { PthreadCall("destroy mutex", pthread_mutex_destroy(&mu_)); }
 
-void Mutex::Lock() { PthreadCall("lock", pthread_mutex_lock(&mu_)); }
+void Mutex::Lock() {
+  PthreadCall("lock", pthread_mutex_lock(&mu_));
+#ifndef NDEBUG
+  locked_ = true;
+#endif
+}
 
-void Mutex::Unlock() { PthreadCall("unlock", pthread_mutex_unlock(&mu_)); }
+void Mutex::Unlock() {
+#ifndef NDEBUG
+  locked_ = false;
+#endif
+  PthreadCall("unlock", pthread_mutex_unlock(&mu_));
+}
+
+void Mutex::AssertHeld() {
+#ifndef NDEBUG
+  assert(locked_);
+#endif
+}
 
 CondVar::CondVar(Mutex* mu)
     : mu_(mu) {
@@ -57,7 +74,13 @@ CondVar::CondVar(Mutex* mu)
 CondVar::~CondVar() { PthreadCall("destroy cv", pthread_cond_destroy(&cv_)); }
 
 void CondVar::Wait() {
+#ifndef NDEBUG
+  mu_->locked_ = false;
+#endif
   PthreadCall("wait", pthread_cond_wait(&cv_, &mu_->mu_));
+#ifndef NDEBUG
+  mu_->locked_ = true;
+#endif
 }
 
 void CondVar::Signal() {
diff --git a/port/port_posix.h b/port/port_posix.h
index aaea0b5744..d393af6dad 100644
--- a/port/port_posix.h
+++ b/port/port_posix.h
@@ -97,11 +97,16 @@ class Mutex {
 
   void Lock();
   void Unlock();
-  void AssertHeld() { }
+  // this will assert if the mutex is not locked
+  // it does NOT verify that mutex is held by a calling thread
+  void AssertHeld();
 
  private:
   friend class CondVar;
   pthread_mutex_t mu_;
+#ifndef NDEBUG
+  bool locked_;
+#endif
 
   // No copying
   Mutex(const Mutex&);