Merge work:/home/bk/mysql into hundin.mysql.fi:/my/bk/mysql

9 files changed, 38 insertions, 48 deletions

diff --git a/sql/item_func.cc b/sql/item_func.cc
index 47adb902107..ac12adb50e0 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -1500,11 +1500,9 @@ longlong Item_func_get_lock::val_int()
 
   /* structure is now initialized.  Try to get the lock */
   /* Set up control struct to allow others to abort locks */
-  pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->proc_info="User lock";
   thd->mysys_var->current_mutex= &LOCK_user_locks;
   thd->mysys_var->current_cond=  &ull->cond;
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
 
 #ifdef HAVE_TIMESPEC_TS_SEC
   abstime.ts_sec=time((time_t*) 0)+(time_t) timeout;
@@ -1514,15 +1512,11 @@ longlong Item_func_get_lock::val_int()
   abstime.tv_nsec=0;
 #endif
 
-  while ((error=pthread_cond_timedwait(&ull->cond,&LOCK_user_locks,&abstime))
-	 != ETIME && error != ETIMEDOUT && ull->locked)
-  {
-    if (thd->killed || abort_loop)
-    {
-      error=EINTR;				// Return NULL
-      break;
-    }
-  }
+  while (!thd->killed &&
+	 (error=pthread_cond_timedwait(&ull->cond,&LOCK_user_locks,&abstime))
+	 != ETIME && error != ETIMEDOUT && ull->locked) ;
+  if (thd->killed)
+    error=EINTR;				// Return NULL
   if (ull->locked)
   {
     if (!--ull->count)
diff --git a/sql/lock.cc b/sql/lock.cc
index 1d9aca66e74..a8b26c3b17d 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -65,11 +65,9 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd,TABLE **tables,uint count)
       }	
 
       pthread_mutex_lock(&LOCK_open);
-      pthread_mutex_lock(&thd->mysys_var->mutex);
       thd->mysys_var->current_mutex= &LOCK_open;
       thd->mysys_var->current_cond= &COND_refresh;
       thd->proc_info="Waiting for table";
-      pthread_mutex_unlock(&thd->mysys_var->mutex);
 
       while (global_read_lock && ! thd->killed &&
 	     thd->version == refresh_version)
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index b484eee3480..1255b55a81c 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -509,12 +509,14 @@ static void close_connections(void)
     if (tmp->mysys_var)
     {
       tmp->mysys_var->abort=1;
-      if (tmp->mysys_var->current_mutex)
+      pthread_mutex_lock(&tmp->mysys_var->mutex);
+      if (tmp->mysys_var->current_cond)
       {
 	pthread_mutex_lock(tmp->mysys_var->current_mutex);
 	pthread_cond_broadcast(tmp->mysys_var->current_cond);
 	pthread_mutex_unlock(tmp->mysys_var->current_mutex);
       }
+      pthread_mutex_unlock(&tmp->mysys_var->mutex);
     }
   }
   (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index d885d308770..16495ab03b0 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -358,11 +358,9 @@ bool close_cached_tables(THD *thd, bool if_wait_for_refresh,
     */
     if (!tables)
       kill_delayed_threads();
-    pthread_mutex_lock(&thd->mysys_var->mutex);
     thd->mysys_var->current_mutex= &LOCK_open;
     thd->mysys_var->current_cond= &COND_refresh;
     thd->proc_info="Flushing tables";
-    pthread_mutex_unlock(&thd->mysys_var->mutex);
 
     close_old_data_files(thd,thd->open_tables,1,1);
     bool found=1;
@@ -667,13 +665,12 @@ void wait_for_refresh(THD *thd)
 {
   /* Wait until the current table is up to date */
   const char *proc_info;
-  pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= &LOCK_open;
   thd->mysys_var->current_cond= &COND_refresh;
   proc_info=thd->proc_info;
   thd->proc_info="Waiting for table";
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
-  (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
+  if (!thd->killed)
+    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
 
   pthread_mutex_unlock(&LOCK_open);	// Must be unlocked first
   pthread_mutex_lock(&thd->mysys_var->mutex);
@@ -2182,7 +2179,7 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
       {
 	in_use->killed=1;
 	pthread_mutex_lock(&in_use->mysys_var->mutex);
-	if (in_use->mysys_var->current_mutex)
+	if (in_use->mysys_var->current_cond)
 	{
 	  pthread_mutex_lock(in_use->mysys_var->current_mutex);
 	  pthread_cond_broadcast(in_use->mysys_var->current_cond);
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index c57b59f55a6..ace7c291ed3 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -226,12 +226,12 @@ void THD::prepare_to_die()
       pthread_mutex_lock(&mysys_var->mutex);
       if (!system_thread)		// Don't abort locks
 	mysys_var->abort=1;
-      if (mysys_var->current_mutex)
-	{
-	  pthread_mutex_lock(mysys_var->current_mutex);
-	  pthread_cond_broadcast(mysys_var->current_cond);
-	  pthread_mutex_unlock(mysys_var->current_mutex);
-	}
+      if (mysys_var->current_cond)
+      {
+	pthread_mutex_lock(mysys_var->current_mutex);
+	pthread_cond_broadcast(mysys_var->current_cond);
+	pthread_mutex_unlock(mysys_var->current_mutex);
+      }
       pthread_mutex_unlock(&mysys_var->mutex);
     }
 }
diff --git a/sql/sql_class.h b/sql/sql_class.h
index bbf6fe08d88..3d218a06d0c 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -326,11 +326,9 @@ public:
 			  const char* msg)
   {
     const char* old_msg = proc_info;
-    pthread_mutex_lock(&mysys_var->mutex);
     mysys_var->current_mutex = mutex;
     mysys_var->current_cond = cond;
     proc_info = msg;
-    pthread_mutex_unlock(&mysys_var->mutex);
     return old_msg;
   }
   inline void exit_cond(const char* old_msg)
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index c14fbda3bc5..cd738999383 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -482,7 +482,7 @@ public:
   COPY_INFO info;
   I_List<delayed_row> rows;
   uint group_count;
-  TABLE_LIST *table_list;			// Argument
+  TABLE_LIST table_list;			// Argument
 
   delayed_insert()
     :locks_in_memory(0),
@@ -511,10 +511,12 @@ public:
     delayed_row *row;
     while ((row=rows.get()))
       delete row;
-    pthread_mutex_destroy(&mutex);
     if (table)
       close_thread_tables(&thd);
     VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_destroy(&mutex);
+    pthread_cond_destroy(&cond);
+    pthread_cond_destroy(&cond_client);
     thd.unlink();				// Must be unlinked under lock
     x_free(thd.query);
     thd.user=thd.host=0;
@@ -609,7 +611,9 @@ static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list)
 	pthread_mutex_unlock(&LOCK_delayed_create);
 	DBUG_RETURN(0);
       }
-      tmp->table_list=table_list;			// Needed to open table
+      tmp->table_list= *table_list;			// Needed to open table
+      tmp->table_list.db= tmp->thd.db;
+      tmp->table_list.name= tmp->table_list.real_name=tmp->thd.query;
       tmp->lock();
       pthread_mutex_lock(&tmp->mutex);
       if ((error=pthread_create(&tmp->thd.real_id,&connection_attrib,
@@ -842,13 +846,11 @@ void kill_delayed_threads(void)
     if (tmp->thd.mysys_var)
     {
       pthread_mutex_lock(&tmp->thd.mysys_var->mutex);
-      if (tmp->thd.mysys_var->current_mutex)
+      if (tmp->thd.mysys_var->current_cond)
       {
-	if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
-	  pthread_mutex_lock(tmp->thd.mysys_var->current_mutex);
+	pthread_mutex_lock(tmp->thd.mysys_var->current_mutex);
 	pthread_cond_broadcast(tmp->thd.mysys_var->current_cond);
-	if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
-	  pthread_mutex_unlock(tmp->thd.mysys_var->current_mutex);
+	pthread_mutex_unlock(tmp->thd.mysys_var->current_mutex);
       }
       pthread_mutex_unlock(&tmp->thd.mysys_var->mutex);
     }
@@ -873,6 +875,7 @@ static pthread_handler_decl(handle_delayed_insert,arg)
   thd->thread_id=thread_id++;
   thd->end_time();
   threads.append(thd);
+  thd->killed=abort_loop;
   pthread_mutex_unlock(&LOCK_thread_count);
 
   pthread_mutex_lock(&di->mutex);
@@ -903,7 +906,7 @@ static pthread_handler_decl(handle_delayed_insert,arg)
 
   /* open table */
 
-  if (!(di->table=open_ltable(thd,di->table_list,TL_WRITE_DELAYED)))
+  if (!(di->table=open_ltable(thd,&di->table_list,TL_WRITE_DELAYED)))
   {
     thd->fatal_error=1;				// Abort waiting inserts
     goto end;
@@ -911,7 +914,7 @@ static pthread_handler_decl(handle_delayed_insert,arg)
   if (di->table->file->has_transactions())
   {
     thd->fatal_error=1;
-    my_error(ER_ILLEGAL_HA, MYF(0), di->table_list->real_name);
+    my_error(ER_ILLEGAL_HA, MYF(0), di->table_list.real_name);
     goto end;
   }
   di->table->copy_blobs=1;
@@ -963,14 +966,12 @@ static pthread_handler_decl(handle_delayed_insert,arg)
 #endif
 
       /* Information for pthread_kill */
-      pthread_mutex_lock(&di->thd.mysys_var->mutex);
       di->thd.mysys_var->current_mutex= &di->mutex;
       di->thd.mysys_var->current_cond= &di->cond;
-      pthread_mutex_unlock(&di->thd.mysys_var->mutex);
       di->thd.proc_info=0;
 
       DBUG_PRINT("info",("Waiting for someone to insert rows"));
-      for ( ; ;)
+      while (!thd->killed)
       {
 	int error;
 #if (defined(HAVE_BROKEN_COND_TIMEDWAIT) || defined(HAVE_LINUXTHREADS))
@@ -994,10 +995,13 @@ static pthread_handler_decl(handle_delayed_insert,arg)
 	  break;
 	}
       }
+      /* We can't lock di->mutex and mysys_var->mutex at the same time */
+      pthread_mutex_unlock(&di->mutex);
       pthread_mutex_lock(&di->thd.mysys_var->mutex);
       di->thd.mysys_var->current_mutex= 0;
       di->thd.mysys_var->current_cond= 0;
       pthread_mutex_unlock(&di->thd.mysys_var->mutex);
+      pthread_mutex_lock(&di->mutex);
     }
 
     if (di->tables_in_use && ! thd->lock)
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index b9ba284ab27..7d4a7847eb1 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -414,12 +414,10 @@ void mysql_binlog_send(THD* thd, char* log_ident, ulong pos, ushort flags)
 	log.error=0;
 
 	// tell the kill thread how to wake us up
-	pthread_mutex_lock(&thd->mysys_var->mutex);
 	thd->mysys_var->current_mutex = log_lock;
 	thd->mysys_var->current_cond = &COND_binlog_update;
 	const char* proc_info = thd->proc_info;
 	thd->proc_info = "Slave connection: waiting for binlog update";
-	pthread_mutex_unlock(&thd->mysys_var->mutex);
 
 	bool read_packet = 0, fatal_error = 0;
 
@@ -444,7 +442,8 @@ void mysql_binlog_send(THD* thd, char* log_ident, ulong pos, ushort flags)
 	  break;
 	case LOG_READ_EOF:
 	  DBUG_PRINT("wait",("waiting for data on binary log"));
-	  pthread_cond_wait(&COND_binlog_update, log_lock);
+	  if (!thd->killed)
+	    pthread_cond_wait(&COND_binlog_update, log_lock);
 	  break;
 
 	default:
@@ -694,9 +693,9 @@ void kill_zombie_dump_threads(uint32 slave_server_id)
 	  
 	  thr_alarm_kill(tmp->real_id);
 	  tmp->killed = 1;
-	  pthread_mutex_lock(&tmp->mysys_var->mutex);
           tmp->mysys_var->abort = 1;
-	  if(tmp->mysys_var->current_mutex)
+	  pthread_mutex_lock(&tmp->mysys_var->mutex);
+	  if(tmp->mysys_var->current_cond)
 	    {
 	      pthread_mutex_lock(tmp->mysys_var->current_mutex);
 	      pthread_cond_broadcast(tmp->mysys_var->current_cond);
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 5c3d8def542..8f4082c6688 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -53,11 +53,9 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists)
 
   /* mark for close and remove all cached entries */
 
-  pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= &LOCK_open;
   thd->mysys_var->current_cond= &COND_refresh;
   VOID(pthread_mutex_lock(&LOCK_open));
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
 
   if (global_read_lock)
   {