1 files changed, 163 insertions, 2 deletions

diff --git a/storage/perfschema/pfs_server.cc b/storage/perfschema/pfs_server.cc
index 0f322a9cb76..1f7010e5b5f 100644
--- a/storage/perfschema/pfs_server.cc
+++ b/storage/perfschema/pfs_server.cc
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,21 +27,35 @@
 #include "pfs_instr_class.h"
 #include "pfs_instr.h"
 #include "pfs_events_waits.h"
+#include "pfs_events_stages.h"
+#include "pfs_events_statements.h"
 #include "pfs_timer.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_defaults.h"
+#include "pfs_digest.h"
 
 PFS_global_param pfs_param;
 
+PFS_table_stat PFS_table_stat::g_reset_template;
+
 C_MODE_START
 static void destroy_pfs_thread(void *key);
 C_MODE_END
 
 static void cleanup_performance_schema(void);
+void cleanup_instrument_config(void);
 
 struct PSI_bootstrap*
 initialize_performance_schema(const PFS_global_param *param)
 {
   pfs_initialized= false;
 
+  PFS_table_stat::g_reset_template.reset();
+
   if (! param->m_enabled)
   {
     /*
@@ -54,6 +68,9 @@ initialize_performance_schema(const PFS_global_param *param)
   init_timers();
   PFS_atomic::init();
 
+  init_event_name_sizing(param);
+  register_global_classes();
+
   if (pthread_key_create(&THR_PFS, destroy_pfs_thread))
     return NULL;
 
@@ -65,11 +82,30 @@ initialize_performance_schema(const PFS_global_param *param)
       init_thread_class(param->m_thread_class_sizing) ||
       init_table_share(param->m_table_share_sizing) ||
       init_file_class(param->m_file_class_sizing) ||
+      init_stage_class(param->m_stage_class_sizing) ||
+      init_statement_class(param->m_statement_class_sizing) ||
+      init_socket_class(param->m_socket_class_sizing) ||
       init_instruments(param) ||
       init_events_waits_history_long(
         param->m_events_waits_history_long_sizing) ||
+      init_events_stages_history_long(
+        param->m_events_stages_history_long_sizing) ||
+      init_events_statements_history_long(
+        param->m_events_statements_history_long_sizing) ||
       init_file_hash() ||
-      init_table_share_hash())
+      init_table_share_hash() ||
+      init_setup_actor(param) ||
+      init_setup_actor_hash() ||
+      init_setup_object(param) ||
+      init_setup_object_hash() ||
+      init_host(param) ||
+      init_host_hash() ||
+      init_user(param) ||
+      init_user_hash() ||
+      init_account(param) ||
+      init_account_hash() ||
+      init_digest(param) ||
+      init_digest_hash())
   {
     /*
       The performance schema initialization failed.
@@ -80,6 +116,22 @@ initialize_performance_schema(const PFS_global_param *param)
   }
 
   pfs_initialized= true;
+
+  /** Default values for SETUP_CONSUMERS */
+  flag_events_stages_current=          param->m_consumer_events_stages_current_enabled;
+  flag_events_stages_history=          param->m_consumer_events_stages_history_enabled;
+  flag_events_stages_history_long=     param->m_consumer_events_stages_history_long_enabled;
+  flag_events_statements_current=      param->m_consumer_events_statements_current_enabled;
+  flag_events_statements_history=      param->m_consumer_events_statements_history_enabled;
+  flag_events_statements_history_long= param->m_consumer_events_statements_history_long_enabled;
+  flag_events_waits_current=           param->m_consumer_events_waits_current_enabled;
+  flag_events_waits_history=           param->m_consumer_events_waits_history_enabled;
+  flag_events_waits_history_long=      param->m_consumer_events_waits_history_long_enabled;
+  flag_global_instrumentation=         param->m_consumer_global_instrumentation_enabled;
+  flag_thread_instrumentation=         param->m_consumer_thread_instrumentation_enabled;
+  flag_statements_digest=              param->m_consumer_statement_digest_enabled;
+
+  install_default_setup(&PFS_bootstrap);
   return &PFS_bootstrap;
 }
 
@@ -104,21 +156,41 @@ static void destroy_pfs_thread(void *key)
 
 static void cleanup_performance_schema(void)
 {
+  cleanup_instrument_config();
+/*  Disabled: Bug#5666
   cleanup_instruments();
   cleanup_sync_class();
   cleanup_thread_class();
   cleanup_table_share();
   cleanup_file_class();
+  cleanup_stage_class();
+  cleanup_statement_class();
+  cleanup_socket_class();
   cleanup_events_waits_history_long();
+  cleanup_events_stages_history_long();
+  cleanup_events_statements_history_long();
   cleanup_table_share_hash();
   cleanup_file_hash();
+  cleanup_setup_actor();
+  cleanup_setup_actor_hash();
+  cleanup_setup_object();
+  cleanup_setup_object_hash();
+  cleanup_host();
+  cleanup_host_hash();
+  cleanup_user();
+  cleanup_user_hash();
+  cleanup_account();
+  cleanup_account_hash();
+  cleanup_digest();
   PFS_atomic::cleanup();
+*/
 }
 
 void shutdown_performance_schema(void)
 {
   pfs_initialized= false;
   cleanup_performance_schema();
+#if 0
   /*
     Be careful to not delete un-initialized keys,
     this would affect key 0, which is THR_KEY_mysys,
@@ -129,5 +201,94 @@ void shutdown_performance_schema(void)
     pthread_key_delete(THR_PFS);
     THR_PFS_initialized= false;
   }
+#endif
+}
+
+/**
+  Initialize the dynamic array used to hold PFS_INSTRUMENT configuration
+  options.
+*/
+void init_pfs_instrument_array()
+{
+  my_init_dynamic_array(&pfs_instr_config_array, sizeof(PFS_instr_config*), 10, 10);
+  pfs_instr_config_state=  PFS_INSTR_CONFIG_ALLOCATED;
 }
 
+/**
+  Deallocate the PFS_INSTRUMENT array. Use an atomic compare-and-swap to ensure
+  that it is deallocated only once in the chaotic environment of server shutdown.
+*/
+void cleanup_instrument_config()
+{
+  int desired_state= PFS_INSTR_CONFIG_ALLOCATED;
+  
+  /* Ignore if another thread has already deallocated the array */
+  if (my_atomic_cas32(&pfs_instr_config_state, &desired_state, PFS_INSTR_CONFIG_DEALLOCATED))
+    delete_dynamic(&pfs_instr_config_array);
+}
+
+/**
+  Process one performance_schema_instrument configuration string. Isolate the
+  instrument name, evaluate the option value, and store them in a dynamic array.
+  Return 'false' for success, 'true' for error.
+
+  @param name    Instrument name
+  @param value   Configuration option: 'on', 'off', etc.
+  @return 0 for success, non zero for errors
+*/
+
+int add_pfs_instr_to_array(const char* name, const char* value)
+{
+  int name_length= strlen(name);
+  int value_length= strlen(value);
+
+  /* Allocate structure plus string buffers plus null terminators */
+  PFS_instr_config* e = (PFS_instr_config*)my_malloc(sizeof(PFS_instr_config)
+                       + name_length + 1 + value_length + 1, MYF(MY_WME));
+  if (!e) return 1;
+  
+  /* Copy the instrument name */
+  e->m_name= (char*)e + sizeof(PFS_instr_config);
+  memcpy(e->m_name, name, name_length);
+  e->m_name_length= name_length;
+  e->m_name[name_length]= '\0';
+  
+  /* Set flags accordingly */
+  if (!my_strcasecmp(&my_charset_latin1, value, "counted"))
+  {
+    e->m_enabled= true;
+    e->m_timed= false;
+  }
+  else
+  if (!my_strcasecmp(&my_charset_latin1, value, "true") ||
+      !my_strcasecmp(&my_charset_latin1, value, "on") ||
+      !my_strcasecmp(&my_charset_latin1, value, "1") ||
+      !my_strcasecmp(&my_charset_latin1, value, "yes"))
+  {
+    e->m_enabled= true;
+    e->m_timed= true;
+  }
+  else
+  if (!my_strcasecmp(&my_charset_latin1, value, "false") ||
+      !my_strcasecmp(&my_charset_latin1, value, "off") ||
+      !my_strcasecmp(&my_charset_latin1, value, "0") ||
+      !my_strcasecmp(&my_charset_latin1, value, "no"))
+  {
+    e->m_enabled= false;
+    e->m_timed= false;
+  }
+  else
+  {
+    my_free(e);
+    return 1;
+  }
+
+  /* Add to the array of default startup options */
+  if (insert_dynamic(&pfs_instr_config_array, &e))
+  {
+    my_free(e);
+    return 1;
+  }
+
+  return 0;
+}