Final patch for BUG#4285.

This patch collects all previous patches into one.

The main problem was due to that there is are two variables -
dflt_key_cache and sql_key_cache with have more or less duplicate
function. The reson for the bug was that the default value in the key
cache hash was set to dflt_key_cache, then sql_key_cache was set to a
new key cache object, and then dflt_key_cache was set to sql_key_cache
which was different from the dflt_key_cache_var. After sending SIGHUP,
the server was using the original default value for the key cache hash,
which was different from the actual key cache object used for the
default key cache.


include/keycache.h:
  Import patch 4285.diff
mysys/mf_keycache.c:
  Import patch 4285.diff
sql/mysql_priv.h:
  Import patch 4285.diff
sql/mysqld.cc:
  Import patch 4285.diff
sql/set_var.cc:
  Import patch 4285.diff
sql/sql_parse.cc:
  Import patch 4285.diff
sql/sql_show.cc:
  Import patch 4285.diff

7 files changed, 50 insertions, 24 deletions

diff --git a/include/keycache.h b/include/keycache.h
index 26ee0ccadb1..a292a69b0a3 100644
--- a/include/keycache.h
+++ b/include/keycache.h
@@ -88,12 +88,13 @@ typedef struct st_key_cache
   ulong param_division_limit;   /* min. percentage of warm blocks           */
   ulong param_age_threshold;    /* determines when hot block is downgraded  */
 
-  /* Statistics variables */
+  /* Statistics variables. These are reset in reset_key_cache_counters(). */
   ulong global_blocks_changed;	/* number of currently dirty blocks         */
   ulong global_cache_w_requests;/* number of write requests (write hits)    */
   ulong global_cache_write;     /* number of writes from the cache to files */
   ulong global_cache_r_requests;/* number of read requests (read hits)      */
   ulong global_cache_read;      /* number of reads from files to the cache  */
+
   int blocks;                   /* max number of blocks in the cache        */
   my_bool in_init;		/* Set to 1 in MySQL during init/resize     */
 } KEY_CACHE;
@@ -132,5 +133,7 @@ extern my_bool multi_key_cache_set(const byte *key, uint length,
 				   KEY_CACHE *key_cache);
 extern void multi_key_cache_change(KEY_CACHE *old_data,
 				   KEY_CACHE *new_data);
+extern int reset_key_cache_counters(const char *name,
+                                    KEY_CACHE *key_cache);
 C_MODE_END
 #endif /* _keycache_h */
diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c
index 052d6c79ab9..a1227989a4b 100644
--- a/mysys/mf_keycache.c
+++ b/mysys/mf_keycache.c
@@ -2444,6 +2444,41 @@ static int flush_all_key_blocks(KEY_CACHE *keycache)
 }
 
 
+/*
+  Reset the counters of a key cache.
+
+  SYNOPSIS
+    reset_key_cache_counters()
+    name       the name of a key cache
+    key_cache  pointer to the key kache to be reset
+
+  DESCRIPTION
+   This procedure is used by process_key_caches() to reset the counters of all
+   currently used key caches, both the default one and the named ones.
+
+  RETURN
+    0 on success (always because it can't fail)
+*/
+
+int reset_key_cache_counters(const char *name, KEY_CACHE *key_cache)
+{
+  DBUG_ENTER("reset_key_cache_counters");
+  if (!key_cache->key_cache_inited)
+  {
+    DBUG_PRINT("info", ("Key cache %s not initialized.", name));
+    DBUG_RETURN(0);
+  }
+  DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
+
+  key_cache->global_blocks_changed= 0;   /* Key_blocks_not_flushed */
+  key_cache->global_cache_r_requests= 0; /* Key_read_requests */
+  key_cache->global_cache_read= 0;       /* Key_reads */
+  key_cache->global_cache_w_requests= 0; /* Key_write_requests */
+  key_cache->global_cache_write= 0;      /* Key_writes */
+  DBUG_RETURN(0);
+}
+
+
 #ifndef DBUG_OFF
 /*
   Test if disk-cache is ok
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 4b785aafc5f..4f4aea66dd7 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -938,7 +938,6 @@ extern SHOW_COMP_OPTION have_ndbcluster;
 extern struct system_variables global_system_variables;
 extern struct system_variables max_system_variables;
 extern struct rand_struct sql_rand;
-extern KEY_CACHE *sql_key_cache;
 
 extern const char *opt_date_time_formats[];
 extern KNOWN_DATE_TIME_FORMAT known_date_time_formats[];
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index d1fef3519bf..21b1cb7ffd0 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -383,7 +383,6 @@ struct system_variables max_system_variables;
 
 MY_TMPDIR mysql_tmpdir_list;
 MY_BITMAP temp_pool;
-KEY_CACHE *sql_key_cache;
 
 CHARSET_INFO *system_charset_info, *files_charset_info ;
 CHARSET_INFO *national_charset_info, *table_alias_charset;
@@ -1846,14 +1845,14 @@ We will try our best to scrape up some info that will hopefully help diagnose\n\
 the problem, but since we have already crashed, something is definitely wrong\n\
 and this may fail.\n\n");
   fprintf(stderr, "key_buffer_size=%lu\n", 
-          (ulong) sql_key_cache->key_cache_mem_size);
+          (ulong) dflt_key_cache->key_cache_mem_size);
   fprintf(stderr, "read_buffer_size=%ld\n", global_system_variables.read_buff_size);
   fprintf(stderr, "max_used_connections=%ld\n", max_used_connections);
   fprintf(stderr, "max_connections=%ld\n", max_connections);
   fprintf(stderr, "threads_connected=%d\n", thread_count);
   fprintf(stderr, "It is possible that mysqld could use up to \n\
 key_buffer_size + (read_buffer_size + sort_buffer_size)*max_connections = %ld K\n\
-bytes of memory\n", ((ulong) sql_key_cache->key_cache_mem_size +
+bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
 		     (global_system_variables.read_buff_size +
 		      global_system_variables.sortbuff_size) *
 		     max_connections)/ 1024);
@@ -2120,12 +2119,12 @@ extern "C" void *signal_hand(void *arg __attribute__((unused)))
     case SIGHUP:
       if (!abort_loop)
       {
+	mysql_print_status((THD*) 0);		// Print some debug info
 	reload_acl_and_cache((THD*) 0,
 			     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
 			      REFRESH_STATUS | REFRESH_GRANT |
 			      REFRESH_THREADS | REFRESH_HOSTS),
 			     (TABLE_LIST*) 0, NULL); // Flush logs
-	mysql_print_status((THD*) 0);		// Send debug some info
       }
       break;
 #ifdef USE_ONE_SIGNAL_HAND
@@ -2699,8 +2698,6 @@ server.");
 
   /* call ha_init_key_cache() on all key caches to init them */
   process_key_caches(&ha_init_key_cache);
-  /* We must set dflt_key_cache in case we are using ISAM tables */
-  dflt_key_cache= sql_key_cache;
 
 #if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT) && !defined(EMBEDDED_LIBRARY)
   if (locked_in_memory && !getuid())
@@ -5598,10 +5595,10 @@ static void mysql_init_variables(void)
   threads.empty();
   thread_cache.empty();
   key_caches.empty();
-  multi_keycache_init();
-  if (!(sql_key_cache= get_or_create_key_cache(default_key_cache_base.str,
+  if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
 					       default_key_cache_base.length)))
     exit(1);
+  multi_keycache_init(); /* set key_cache_hash.default_value = dflt_key_cache */
 
   /* Initialize structures that is used when processing options */
   replicate_rewrite_db.empty();
diff --git a/sql/set_var.cc b/sql/set_var.cc
index e44ac742abe..1237c31075c 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -2174,7 +2174,7 @@ bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
 
   if (!tmp)					// Zero size means delete
   {
-    if (key_cache == sql_key_cache)
+    if (key_cache == dflt_key_cache)
       goto end;					// Ignore default key cache
 
     if (key_cache->key_cache_inited)		// If initied
@@ -2188,7 +2188,7 @@ bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
 					      base_name->length, &list);
       key_cache->in_init= 1;
       pthread_mutex_unlock(&LOCK_global_system_variables);
-      error= reassign_keycache_tables(thd, key_cache, sql_key_cache);
+      error= reassign_keycache_tables(thd, key_cache, dflt_key_cache);
       pthread_mutex_lock(&LOCK_global_system_variables);
       key_cache->in_init= 0;
     }
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index c81aefc9cea..9eb4019b5d7 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -4946,6 +4946,7 @@ void kill_one_thread(THD *thd, ulong id)
     net_printf(thd,error,id);
 }
 
+
 /* Clear most status variables */
 
 static void refresh_status(void)
@@ -4955,18 +4956,9 @@ static void refresh_status(void)
   {
     if (ptr->type == SHOW_LONG)
       *(ulong*) ptr->value= 0;
-    else if (ptr->type == SHOW_KEY_CACHE_LONG)
-    {
-      /*
-	Reset value in 'default' key cache.
-	This needs to be recoded when we have thread specific key values
-      */
-      char *value= (((char*) sql_key_cache) +
-		    (uint) ((char*) (ptr->value) -
-			    (char*) &dflt_key_cache_var));
-      *(ulong*) value= 0;
-    }
   }
+  /* Reset the counters of all key caches (default and named). */
+  process_key_caches(reset_key_cache_counters);
   pthread_mutex_unlock(&LOCK_status);
 }
 
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 8929872c466..d9acd47c5a6 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -2066,7 +2066,7 @@ int mysqld_show(THD *thd, const char *wild, show_var_st *variables,
 #endif /* HAVE_OPENSSL */
       case SHOW_KEY_CACHE_LONG:
       case SHOW_KEY_CACHE_CONST_LONG:
-	value= (value-(char*) &dflt_key_cache_var)+ (char*) sql_key_cache;
+	value= (value-(char*) &dflt_key_cache_var)+ (char*) dflt_key_cache;
 	end= int10_to_str(*(long*) value, buff, 10);
         break;
       case SHOW_UNDEF:				// Show never happen