Fixed lp:933719, "Assertion open_tables == 0 ... " in THD::restore_backup_open_tables_state.

This also fixes a (not likely) crashing bug when forcing a thread that was doing a table lock to re-open it's files, for example by creating a trigger.


mysys/thr_lock.c:
  Added more checking to find wrong locks.
  Removed one, not needed, parameter to thr_lock
sql/lock.cc:
  Fixed mysql_lock_tables() to retry with new sql_lock if lock fails. This was needed as table may be closed and reopened between retry's and then the old sql_lock will point to stale data.
sql/mysql_priv.h:
  Updated prototype
sql/sql_base.cc:
  Ensure that all tables are closed if opening of system table failes; This fixes the assert in THD::restore_backup_open_tables_state
sql/sql_handler.cc:
  Updated variable type

1 files changed, 30 insertions, 11 deletions

diff --git a/mysys/thr_lock.c b/mysys/thr_lock.c
index 99a498cfdd5..32b38105d1f 100644
--- a/mysys/thr_lock.c
+++ b/mysys/thr_lock.c
@@ -168,7 +168,8 @@ thr_lock_owner_equal(THR_LOCK_OWNER *rhs, THR_LOCK_OWNER *lhs)
 static uint found_errors=0;
 
 static int check_lock(struct st_lock_list *list, const char* lock_type,
-		      const char *where, my_bool same_owner, my_bool no_cond)
+		      const char *where, my_bool same_owner, my_bool no_cond,
+                      my_bool read_lock)
 {
   THR_LOCK_DATA *data,**prev;
   uint count=0;
@@ -181,6 +182,23 @@ static int check_lock(struct st_lock_list *list, const char* lock_type,
 
     for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
     {
+      if (data->type == TL_UNLOCK)
+      {
+	fprintf(stderr,
+		"Warning: Found unlocked lock at %s: %s\n",
+                lock_type, where);
+        return 1;
+      }
+      if ((read_lock && data->type > TL_READ_NO_INSERT) ||
+          (!read_lock && data->type <= TL_READ_NO_INSERT))
+      {
+	fprintf(stderr,
+		"Warning: Found %s lock in %s queue at %s: %s\n",
+                read_lock ? "write" : "read",
+                read_lock ? "read" : "write",
+                lock_type, where);
+        return 1;
+      }
       if (data->type != last_lock_type)
 	last_lock_type=TL_IGNORE;
       if (data->prev != prev)
@@ -237,11 +255,14 @@ static void check_locks(THR_LOCK *lock, const char *where,
 
   if (found_errors < MAX_FOUND_ERRORS)
   {
-    if (check_lock(&lock->write,"write",where,1,1) |
-	check_lock(&lock->write_wait,"write_wait",where,0,0) |
-	check_lock(&lock->read,"read",where,0,1) |
-	check_lock(&lock->read_wait,"read_wait",where,0,0))
+    if (check_lock(&lock->write,"write",where,1,1,0) |
+	check_lock(&lock->write_wait,"write_wait",where,0,0,0) |
+	check_lock(&lock->read,"read",where,0,1,1) |
+	check_lock(&lock->read_wait,"read_wait",where,0,0,1))
+    {
+      DBUG_ASSERT(my_assert_on_error == 0);
       found_errors++;
+    }
 
     if (found_errors < MAX_FOUND_ERRORS)
     {
@@ -592,18 +613,17 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
 
 
 static enum enum_thr_lock_result
-thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner,
-         enum thr_lock_type lock_type)
+thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner)
 {
   THR_LOCK *lock=data->lock;
   enum enum_thr_lock_result result= THR_LOCK_SUCCESS;
   struct st_lock_list *wait_queue;
   THR_LOCK_DATA *lock_owner;
+  enum thr_lock_type lock_type= data->type;
   DBUG_ENTER("thr_lock");
 
   data->next=0;
   data->cond=0;					/* safety */
-  data->type=lock_type;
   data->owner= owner;                           /* Must be reset ! */
   data->priority&= ~THR_LOCK_LATE_PRIV;
   VOID(pthread_mutex_lock(&lock->mutex));
@@ -912,9 +932,7 @@ void thr_unlock(THR_LOCK_DATA *data, uint unlock_flags)
   if (lock_type == TL_READ_NO_INSERT)
     lock->read_no_write_count--;
   data->type=TL_UNLOCK;				/* Mark unlocked */
-  check_locks(lock,"after releasing lock", lock_type, 1);
   wake_up_waiters(lock);
-  check_locks(lock,"end of thr_unlock", lock_type, 1);
   pthread_mutex_unlock(&lock->mutex);
   DBUG_VOID_RETURN;
 }
@@ -934,6 +952,7 @@ static void wake_up_waiters(THR_LOCK *lock)
   enum thr_lock_type lock_type;
   DBUG_ENTER("wake_up_waiters");
 
+  check_locks(lock, "before waking up waiters", TL_UNLOCK, 1);
   if (!lock->write.data)			/* If no active write locks */
   {
     data=lock->write_wait.data;
@@ -1087,7 +1106,7 @@ thr_multi_lock(THR_LOCK_DATA **data, uint count, THR_LOCK_OWNER *owner)
   /* lock everything */
   for (pos=data,end=data+count; pos < end ; pos++)
   {
-    enum enum_thr_lock_result result= thr_lock(*pos, owner, (*pos)->type);
+    enum enum_thr_lock_result result= thr_lock(*pos, owner);
     if (result != THR_LOCK_SUCCESS)
     {						/* Aborted */
       thr_multi_unlock(data,(uint) (pos-data), 0);