Temporary commit of merge of MariaDB 10.0-base and MySQL 5.6

client/mysql_upgrade.c

@@ -800,14 +800,32 @@ static void print_line(char* line)
 static int run_sql_fix_privilege_tables(void)
 {
   int found_real_errors= 0;
+  const char **query_ptr;
+  DYNAMIC_STRING ds_script;
   DYNAMIC_STRING ds_result;
   DBUG_ENTER("run_sql_fix_privilege_tables");
 
+  if (init_dynamic_string(&ds_script, "", 65536, 1024))
+    die("Out of memory");
+
   if (init_dynamic_string(&ds_result, "", 512, 512))
     die("Out of memory");
 
   verbose("Phase 3/3: Running 'mysql_fix_privilege_tables'...");
-  run_query(mysql_fix_privilege_tables,
+  /*
+    Individual queries can not be executed independently by invoking
+    a forked mysql client, because the script uses session variables
+    and prepared statements.
+  */
+  for ( query_ptr= &mysql_fix_privilege_tables[0];
+        *query_ptr != NULL;
+        query_ptr++
+      )
+  {
+    dynstr_append(&ds_script, *query_ptr);
+  }
+
+  run_query(ds_script.str,
             &ds_result, /* Collect result */
             TRUE);
 
@@ -835,6 +853,7 @@ static int run_sql_fix_privilege_tables(void)
   }
 
   dynstr_free(&ds_result);
+  dynstr_free(&ds_script);
   DBUG_RETURN(found_real_errors);
 }
 

configure.cmake

@@ -67,14 +67,7 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
   # MySQL "canonical" GCC flags. At least -fno-rtti flag affects
   # ABI and cannot be simply removed. 
   SET(CMAKE_CXX_FLAGS 
-    "${CMAKE_CXX_FLAGS} -fno-implicit-templates -fno-exceptions -fno-rtti")
-  IF(CMAKE_CXX_FLAGS)
-    STRING(REGEX MATCH "fno-implicit-templates" NO_IMPLICIT_TEMPLATES
-      ${CMAKE_CXX_FLAGS})
-    IF (NO_IMPLICIT_TEMPLATES)
-      SET(HAVE_EXPLICIT_TEMPLATE_INSTANTIATION TRUE)
-    ENDIF()
-  ENDIF()
+    "${CMAKE_CXX_FLAGS} -fno-exceptions -fno-rtti")
 
   IF (CMAKE_EXE_LINKER_FLAGS MATCHES " -static " 
      OR CMAKE_EXE_LINKER_FLAGS MATCHES " -static$")

include/my_global.h

@@ -18,6 +18,7 @@
 
 #ifndef _global_h
 #define _global_h
+#define MY_GLOBAL_INCLUDED
 
 /* Client library users on Windows need this macro defined here. */
 #if !defined(__WIN__) && defined(_WIN32)
@@ -1438,6 +1439,8 @@ static inline char *dlerror(void)
 #define max(a, b)	((a) > (b) ? (a) : (b))
 #define min(a, b)	((a) < (b) ? (a) : (b))
 #endif  
+#define MY_MAX(a, b)	((a) > (b) ? (a) : (b))
+#define MY_MIN(a, b)	((a) < (b) ? (a) : (b))
 
 #define CMP_NUM(a,b)    (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
 

include/my_md5.h

@@ -22,6 +22,36 @@
  * $FreeBSD: src/contrib/cvs/lib/md5.h,v 1.2 1999/12/11 15:10:02 peter Exp $
  */
 
+#if defined(HAVE_YASSL) || defined(HAVE_OPENSSL)
+/*
+  Use MD5 implementation provided by the SSL libraries.
+*/
+
+#if defined(HAVE_YASSL)
+
+C_MODE_START
+
+void my_md5_hash(char *digest, const char *buf, int len);
+
+C_MODE_END
+
+#else /* HAVE_YASSL */
+
+#include <openssl/md5.h>
+
+#define MY_MD5_HASH(digest, buf, len) \
+do { \
+  MD5_CTX ctx; \
+  MD5_Init (&ctx); \
+  MD5_Update (&ctx, buf, len); \
+  MD5_Final (digest, &ctx); \
+} while (0)
+
+#endif /* HAVE_YASSL */
+
+#else /* HAVE_YASSL || HAVE_OPENSSL */
+/* Fallback to the MySQL's implementation. */
+
 /* Unlike previous versions of this code, uint32 need not be exactly
    32 bits, merely 32 bits or more.  Choosing a data type which is 32
    bits instead of 64 is not important; speed is considerably more
@@ -35,18 +65,15 @@ typedef struct {
   unsigned char in[64];
 } my_MD5Context;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+C_MODE_START
+
 void my_MD5Init (my_MD5Context *context);
 void my_MD5Update (my_MD5Context *context,
                    unsigned char const *buf, unsigned len);
 void my_MD5Final (unsigned char digest[16],
                   my_MD5Context *context);
 
-#ifdef __cplusplus
-}
-#endif
+C_MODE_END
 
 #define MY_MD5_HASH(digest,buf,len) \
 do { \
@@ -56,4 +83,12 @@ do { \
   my_MD5Final (digest, &ctx); \
 } while (0)
 
-#endif /* MY_MD__INCLUDED */
+#endif /* defined(HAVE_YASSL) || defined(HAVE_OPENSSL) */
+
+C_MODE_START
+
+void compute_md5_hash(char *digest, const char *buf, int len);
+
+C_MODE_END
+
+#endif /* MY_MD5_INCLUDED */

include/my_pthread.h

@@ -498,13 +498,22 @@ void safe_mutex_free_deadlock_data(safe_mutex_t *mp);
           DBUG_ASSERT(! (mp)->count || \
                       ! pthread_equal(pthread_self(), (mp)->thread))
 #define safe_mutex_setflags(mp, F)      do { (mp)->create_flags|= (F); } while (0)
+#define my_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
+#define my_cond_wait(A,B) safe_cond_wait((A), (B), __FILE__, __LINE__)
 #else
-#define my_pthread_mutex_init(A,B,C,D) pthread_mutex_init((A),(B))
-#define safe_mutex_assert_owner(mp)    do {} while(0)
-#define safe_mutex_assert_not_owner(mp) do {} while(0)
-#define safe_mutex_free_deadlock_data(mp) do {} while(0)
+
+#define safe_mutex_assert_owner(mp) do {} while (0)
+#define safe_mutex_assert_not_owner(mp) do {} while (0)
 #define safe_mutex_setflags(mp, F) do {} while (0)
-#endif /* SAFE_MUTEX */
+
+#if defined(MY_PTHREAD_FASTMUTEX)
+#define my_cond_timedwait(A,B,C) pthread_cond_timedwait((A), &(B)->mutex, (C))
+#define my_cond_wait(A,B) pthread_cond_wait((A), &(B)->mutex)
+#else
+#define my_cond_timedwait(A,B,C) pthread_cond_timedwait((A),(B),(C))
+#define my_cond_wait(A,B) pthread_cond_wait((A), (B))
+#endif /* MY_PTHREAD_FASTMUTEX */
+#endif /* !SAFE_MUTEX */
 
 #if defined(MY_PTHREAD_FASTMUTEX) && !defined(SAFE_MUTEX)
 typedef struct st_my_pthread_fastmutex_t

include/my_sys.h

@@ -252,7 +252,9 @@ extern const char *my_defaults_extra_file;
 extern const char *my_defaults_group_suffix;
 extern const char *my_defaults_file;
 
+#ifndef timed_mutexes
 extern my_bool timed_mutexes;
+#endif
 
 enum loglevel {
    ERROR_LEVEL,
@@ -772,16 +774,17 @@ extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint element_size,
 /* init_dynamic_array() function is deprecated */
 extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
                                   uint init_alloc, uint alloc_increment);
-extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const uchar * element);
-extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
-extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
-extern my_bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
+extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void* element);
+extern void *alloc_dynamic(DYNAMIC_ARRAY *array);
+extern void *pop_dynamic(DYNAMIC_ARRAY*);
+extern my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element,
+                           uint array_index);
 extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
-extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
+extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint array_index);
 extern void delete_dynamic(DYNAMIC_ARRAY *array);
 extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
 extern void freeze_size(DYNAMIC_ARRAY *array);
-extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
+extern int  get_index_dynamic(DYNAMIC_ARRAY *array, void *element);
 #define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
 #define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
 #define push_dynamic(A,B) insert_dynamic((A),(B))

include/my_valgrind.h

@@ -37,9 +37,9 @@
 #endif /* HAVE_VALGRIND */
 
 #ifndef DBUG_OFF
-#define TRASH_FILL(A,B,C) do { bfill(A, B, C); MEM_UNDEFINED(A, B); } while (0)
+#define TRASH_FILL(A,B,C) do { const size_t trash_tmp= (B) ; bfill(A, trash_tmp, C); MEM_UNDEFINED(A, trash_tmp); } while (0)
 #else
-#define TRASH_FILL(A,B,C) do{ MEM_CHECK_ADDRESSABLE(A,B);MEM_UNDEFINED(A,B);} while (0)
+#define TRASH_FILL(A,B,C) do{ const size_t trash_tmp= (B) ; MEM_CHECK_ADDRESSABLE(A,trash_tmp);MEM_UNDEFINED(A,trash_tmp);} while (0)
 #endif
 #define TRASH_ALLOC(A,B) TRASH_FILL(A,B,0xA5)
 #define TRASH_FREE(A,B) TRASH_FILL(A,B,0x8F)

include/mysql/psi/mysql_idle.h

+/* Copyright (c) 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
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef MYSQL_IDLE_H
+#define MYSQL_IDLE_H
+
+/**
+  @file mysql/psi/mysql_idle.h
+  Instrumentation helpers for idle waits.
+*/
+
+#include "mysql/psi/psi.h"
+
+/**
+  @defgroup Idle_instrumentation Idle Instrumentation
+  @ingroup Instrumentation_interface
+  @{
+*/
+
+/**
+  @def MYSQL_START_IDLE_WAIT
+  Instrumentation helper for table io_waits.
+  This instrumentation marks the start of a wait event.
+  @param LOCKER the locker
+  @param STATE the locker state
+  @sa MYSQL_END_IDLE_WAIT.
+*/
+#ifdef HAVE_PSI_IDLE_INTERFACE
+  #define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
+    LOCKER= inline_mysql_start_idle_wait(STATE, __FILE__, __LINE__)
+#else
+  #define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
+    do {} while (0)
+#endif
+
+/**
+  @def MYSQL_END_IDLE_WAIT
+  Instrumentation helper for idle waits.
+  This instrumentation marks the end of a wait event.
+  @param LOCKER the locker
+  @sa MYSQL_START_IDLE_WAIT.
+*/
+#ifdef HAVE_PSI_IDLE_INTERFACE
+  #define MYSQL_END_IDLE_WAIT(LOCKER) \
+    inline_mysql_end_idle_wait(LOCKER)
+#else
+  #define MYSQL_END_IDLE_WAIT(LOCKER) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_IDLE_INTERFACE
+/**
+  Instrumentation calls for MYSQL_START_IDLE_WAIT.
+  @sa MYSQL_END_IDLE_WAIT.
+*/
+static inline struct PSI_idle_locker *
+inline_mysql_start_idle_wait(PSI_idle_locker_state *state,
+                             const char *src_file, int src_line)
+{
+  struct PSI_idle_locker *locker;
+  locker= PSI_CALL(start_idle_wait)(state, src_file, src_line);
+  return locker;
+}
+
+/**
+  Instrumentation calls for MYSQL_END_IDLE_WAIT.
+  @sa MYSQL_START_IDLE_WAIT.
+*/
+static inline void
+inline_mysql_end_idle_wait(struct PSI_idle_locker *locker)
+{
+  if (likely(locker != NULL))
+    PSI_CALL(end_idle_wait)(locker);
+}
+#endif
+
+/** @} (end of group Idle_instrumentation) */
+
+#endif
+

include/mysql/psi/mysql_stage.h

+/* Copyright (c) 2010, 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
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#ifndef MYSQL_STAGE_H
+#define MYSQL_STAGE_H
+
+/**
+  @file mysql/psi/mysql_stage.h
+  Instrumentation helpers for stages.
+*/
+
+#include "mysql/psi/psi.h"
+
+/**
+  @defgroup Stage_instrumentation Stage Instrumentation
+  @ingroup Instrumentation_interface
+  @{
+*/
+
+/**
+  @def mysql_stage_register(P1, P2, P3)
+  Stage registration.
+*/
+#ifdef HAVE_PSI_STAGE_INTERFACE
+#define mysql_stage_register(P1, P2, P3) \
+  inline_mysql_stage_register(P1, P2, P3)
+#else
+#define mysql_stage_register(P1, P2, P3) \
+  do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STAGE_INTERFACE
+  #define MYSQL_SET_STAGE(K, F, L) \
+    inline_mysql_set_stage(K, F, L)
+#else
+  #define MYSQL_SET_STAGE(K, F, L) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STAGE_INTERFACE
+static inline void inline_mysql_stage_register(
+  const char *category, PSI_stage_info **info, int count)
+{
+  PSI_CALL(register_stage)(category, info, count);
+}
+#endif
+
+#ifdef HAVE_PSI_STAGE_INTERFACE
+static inline void
+inline_mysql_set_stage(PSI_stage_key key,
+                       const char *src_file, int src_line)
+{
+  PSI_CALL(start_stage)(key, src_file, src_line);
+}
+#endif
+
+/** @} (end of group Stage_instrumentation) */
+
+#endif
+

include/mysql/psi/mysql_statement.h

+/* Copyright (c) 2010, 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
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#ifndef MYSQL_STATEMENT_H
+#define MYSQL_STATEMENT_H
+
+/**
+  @file mysql/psi/mysql_statement.h
+  Instrumentation helpers for statements.
+*/
+
+#include "mysql/psi/psi.h"
+
+/**
+  @defgroup Statement_instrumentation Statement Instrumentation
+  @ingroup Instrumentation_interface
+  @{
+*/
+
+/**
+  @def mysql_statement_register(P1, P2, P3)
+  Statement registration.
+*/
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+#define mysql_statement_register(P1, P2, P3) \
+  inline_mysql_statement_register(P1, P2, P3)
+#else
+#define mysql_statement_register(P1, P2, P3) \
+  do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
+  #define MYSQL_DIGEST_START(LOCKER) \
+    inline_mysql_digest_start(LOCKER)
+#else
+  #define MYSQL_DIGEST_START(LOCKER) \
+    NULL
+#endif
+#else
+  #define MYSQL_DIGEST_START(LOCKER) \
+    NULL
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
+  #define MYSQL_ADD_TOKEN(LOCKER, T, Y) \
+    inline_mysql_add_token(LOCKER, T, Y)
+#else
+  #define MYSQL_ADD_TOKEN(LOCKER, T, Y) \
+    NULL
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN) \
+    inline_mysql_start_statement(STATE, K, DB, DB_LEN, __FILE__, __LINE__)
+#else
+  #define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN) \
+    NULL
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_REFINE_STATEMENT(LOCKER, K) \
+    inline_mysql_refine_statement(LOCKER, K)
+#else
+  #define MYSQL_REFINE_STATEMENT(LOCKER, K) \
+    NULL
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
+    inline_mysql_set_statement_text(LOCKER, P1, P2)
+#else
+  #define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
+    inline_mysql_set_statement_lock_time(LOCKER, P1)
+#else
+  #define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
+    inline_mysql_set_statement_rows_sent(LOCKER, P1)
+#else
+  #define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
+    inline_mysql_set_statement_rows_examined(LOCKER, P1)
+#else
+  #define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+  #define MYSQL_END_STATEMENT(LOCKER, DA) \
+    inline_mysql_end_statement(LOCKER, DA)
+#else
+  #define MYSQL_END_STATEMENT(LOCKER, DA) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+static inline void inline_mysql_statement_register(
+  const char *category, PSI_statement_info *info, int count)
+{
+  PSI_CALL(register_statement)(category, info, count);
+}
+
+#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
+static inline struct PSI_digest_locker *
+inline_mysql_digest_start(PSI_statement_locker *locker)
+{
+  PSI_digest_locker* digest_locker= NULL;
+
+  if (likely(locker != NULL))
+    digest_locker= PSI_CALL(digest_start)(locker);
+  return digest_locker;
+}
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
+static inline struct PSI_digest_locker *
+inline_mysql_add_token(PSI_digest_locker *locker, uint token,
+                       void *yylval)
+{
+  if (likely(locker != NULL))
+    locker= PSI_CALL(digest_add_token)(locker, token,
+                                      (OPAQUE_LEX_YYSTYPE*)yylval);
+  return locker;
+}
+#endif
+
+static inline struct PSI_statement_locker *
+inline_mysql_start_statement(PSI_statement_locker_state *state,
+                             PSI_statement_key key,
+                             const char *db, uint db_len,
+                             const char *src_file, int src_line)
+{
+  PSI_statement_locker *locker;
+  locker= PSI_CALL(get_thread_statement_locker)(state, key);
+  if (likely(locker != NULL))
+    PSI_CALL(start_statement)(locker, db, db_len, src_file, src_line);
+  return locker;
+}
+
+static inline struct PSI_statement_locker *
+inline_mysql_refine_statement(PSI_statement_locker *locker,
+                              PSI_statement_key key)
+{
+  if (likely(locker != NULL))
+  {
+    locker= PSI_CALL(refine_statement)(locker, key);
+  }
+  return locker;
+}
+
+static inline void
+inline_mysql_set_statement_text(PSI_statement_locker *locker,
+                                const char *text, uint text_len)
+{
+  if (likely(locker != NULL))
+  {
+    PSI_CALL(set_statement_text)(locker, text, text_len);
+  }
+}
+
+static inline void
+inline_mysql_set_statement_lock_time(PSI_statement_locker *locker,
+                                     ulonglong count)
+{
+  if (likely(locker != NULL))
+  {
+    PSI_CALL(set_statement_lock_time)(locker, count);
+  }
+}
+
+static inline void
+inline_mysql_set_statement_rows_sent(PSI_statement_locker *locker,
+                                     ulonglong count)
+{
+  if (likely(locker != NULL))
+  {
+    PSI_CALL(set_statement_rows_sent)(locker, count);
+  }
+}
+
+static inline void
+inline_mysql_set_statement_rows_examined(PSI_statement_locker *locker,
+                                         ulonglong count)
+{
+  if (likely(locker != NULL))
+  {
+    PSI_CALL(set_statement_rows_examined)(locker, count);
+  }
+}
+
+static inline void
+inline_mysql_end_statement(struct PSI_statement_locker *locker,
+                           Diagnostics_area *stmt_da)
+{
+  PSI_CALL(end_stage)();
+  if (likely(locker != NULL))
+    PSI_CALL(end_statement)(locker, stmt_da);
+}
+#endif
+
+/** @} (end of group Statement_instrumentation) */
+
+#endif
+

include/mysql/psi/mysql_table.h

+/* Copyright (c) 2010, 2012, 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
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef MYSQL_TABLE_H
+#define MYSQL_TABLE_H
+
+/**
+  @file mysql/psi/mysql_table.h
+  Instrumentation helpers for table io.
+*/
+
+#include "mysql/psi/psi.h"
+
+/**
+  @defgroup Table_instrumentation Table Instrumentation
+  @ingroup Instrumentation_interface
+  @{
+*/
+
+/**
+  @def MYSQL_TABLE_WAIT_VARIABLES
+  Instrumentation helper for table waits.
+  This instrumentation declares local variables.
+  Do not use a ';' after this macro
+  @param LOCKER the locker
+  @param STATE the locker state
+  @sa MYSQL_START_TABLE_IO_WAIT.
+  @sa MYSQL_END_TABLE_IO_WAIT.
+  @sa MYSQL_START_TABLE_LOCK_WAIT.
+  @sa MYSQL_END_TABLE_LOCK_WAIT.
+*/
+#ifdef HAVE_PSI_TABLE_INTERFACE
+  #define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE) \
+    struct PSI_table_locker* LOCKER; \
+    PSI_table_locker_state STATE;
+#else
+  #define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE)
+#endif
+
+/**
+  @def MYSQL_TABLE_IO_WAIT
+  Instrumentation helper for table io_waits.
+  This instrumentation marks the start of a wait event.
+  @param PSI the instrumented table
+  @param OP the table operation to be performed
+  @param INDEX the table index used if any, or MAY_KEY.
+  @param FLAGS per table operation flags.
+  @sa MYSQL_END_TABLE_WAIT.
+*/
+#ifdef HAVE_PSI_TABLE_INTERFACE
+  #define MYSQL_TABLE_IO_WAIT(PSI, OP, INDEX, FLAGS, PAYLOAD)          \
+    {                                                                  \
+      if (PSI != NULL)                                                 \
+      {                                                                \
+        PSI_table_locker *locker;                                      \
+        PSI_table_locker_state state;                                  \
+        locker= PSI_CALL(start_table_io_wait)(& state, PSI, OP, INDEX, \
+                                              __FILE__, __LINE__);     \
+        PAYLOAD                                                        \
+        if (locker != NULL)                                            \
+          PSI_CALL(end_table_io_wait)(locker);                         \
+      }                                                                \
+      else                                                             \
+      {                                                                \
+        PAYLOAD                                                        \
+      }                                                                \
+    }
+#else
+  #define MYSQL_TABLE_IO_WAIT(PSI, OP, INDEX, FLAGS, PAYLOAD) \
+    PAYLOAD
+#endif
+
+/**
+  @def MYSQL_TABLE_LOCK_WAIT
+  Instrumentation helper for table io_waits.
+  This instrumentation marks the start of a wait event.
+  @param PSI the instrumented table
+  @param OP the table operation to be performed
+  @param INDEX the table index used if any, or MAY_KEY.
+  @param FLAGS per table operation flags.
+  @sa MYSQL_END_TABLE_WAIT.
+*/
+#ifdef HAVE_PSI_TABLE_INTERFACE
+  #define MYSQL_TABLE_LOCK_WAIT(PSI, OP, FLAGS, PAYLOAD)                 \
+    {                                                                    \
+      if (PSI != NULL)                                                   \
+      {                                                                  \
+        PSI_table_locker *locker;                                        \
+        PSI_table_locker_state state;                                    \
+        locker= PSI_CALL(start_table_lock_wait)(& state, PSI, OP, FLAGS, \
+                                                __FILE__, __LINE__);     \
+        PAYLOAD                                                          \
+        if (locker != NULL)                                              \
+          PSI_CALL(end_table_lock_wait)(locker);                         \
+      }                                                                  \
+      else                                                               \
+      {                                                                  \
+        PAYLOAD                                                          \
+      }                                                                  \
+    }
+#else
+  #define MYSQL_TABLE_LOCK_WAIT(PSI, OP, FLAGS, PAYLOAD) \
+    PAYLOAD
+#endif
+
+/**
+  @def MYSQL_START_TABLE_LOCK_WAIT
+  Instrumentation helper for table lock waits.
+  This instrumentation marks the start of a wait event.
+  @param LOCKER the locker
+  @param STATE the locker state
+  @param PSI the instrumented table
+  @param OP the table operation to be performed
+  @param FLAGS per table operation flags.
+  @sa MYSQL_END_TABLE_LOCK_WAIT.
+*/
+#ifdef HAVE_PSI_TABLE_INTERFACE
+  #define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
+    LOCKER= inline_mysql_start_table_lock_wait(STATE, PSI, \
+                                               OP, FLAGS, __FILE__, __LINE__)
+#else
+  #define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
+    do {} while (0)
+#endif
+
+/**
+  @def MYSQL_END_TABLE_LOCK_WAIT
+  Instrumentation helper for table lock waits.
+  This instrumentation marks the end of a wait event.
+  @param LOCKER the locker
+  @sa MYSQL_START_TABLE_LOCK_WAIT.
+*/
+#ifdef HAVE_PSI_TABLE_INTERFACE
+  #define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
+    inline_mysql_end_table_lock_wait(LOCKER)
+#else
+  #define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
+    do {} while (0)
+#endif
+
+#ifdef HAVE_PSI_TABLE_INTERFACE
+/**
+  Instrumentation calls for MYSQL_START_TABLE_LOCK_WAIT.
+  @sa MYSQL_END_TABLE_LOCK_WAIT.
+*/
+static inline struct PSI_table_locker *
+inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
+                                   struct PSI_table *psi,
+                                   enum PSI_table_lock_operation op,
+                                   ulong flags, const char *src_file, int src_line)
+{
+  if (psi != NULL)
+  {
+    struct PSI_table_locker *locker;
+    locker= PSI_CALL(start_table_lock_wait)(state, psi, op, flags, src_file, src_line);
+    return locker;
+  }
+  return NULL;
+}
+
+/**
+  Instrumentation calls for MYSQL_END_TABLE_LOCK_WAIT.
+  @sa MYSQL_START_TABLE_LOCK_WAIT.
+*/
+static inline void
+inline_mysql_end_table_lock_wait(struct PSI_table_locker *locker)
+{
+  if (locker != NULL)
+    PSI_CALL(end_table_lock_wait)(locker);
+}
+#endif
+
+/** @} (end of group Table_instrumentation) */
+
+#endif
+

include/mysql/psi/psi_abi_v0.h

+/* Copyright (c) 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
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+  @file mysql/psi/psi_abi_v0.h
+  ABI check for mysql/psi/psi.h, when compiling without instrumentation.
+  This file is only used to automate detection of changes between versions.
+  Do not include this file, include mysql/psi/psi.h instead.
+*/
+#define _global_h
+#include "mysql/psi/psi.h"
+

include/mysql/psi/psi_abi_v0.h.pp

+#include "mysql/psi/psi.h"
+C_MODE_START
+struct TABLE_SHARE;
+struct OPAQUE_LEX_YYSTYPE;
+struct PSI_mutex;
+typedef struct PSI_mutex PSI_mutex;
+struct PSI_rwlock;
+typedef struct PSI_rwlock PSI_rwlock;
+struct PSI_cond;
+typedef struct PSI_cond PSI_cond;
+struct PSI_table_share;
+typedef struct PSI_table_share PSI_table_share;
+struct PSI_table;
+typedef struct PSI_table PSI_table;
+struct PSI_thread;
+typedef struct PSI_thread PSI_thread;
+struct PSI_file;
+typedef struct PSI_file PSI_file;
+struct PSI_socket;
+typedef struct PSI_socket PSI_socket;
+struct PSI_table_locker;
+typedef struct PSI_table_locker PSI_table_locker;
+struct PSI_statement_locker;
+typedef struct PSI_statement_locker PSI_statement_locker;
+struct PSI_idle_locker;
+typedef struct PSI_idle_locker PSI_idle_locker;
+struct PSI_digest_locker;
+typedef struct PSI_digest_locker PSI_digest_locker;
+struct PSI_bootstrap
+{
+  void* (*get_interface)(int version);
+};
+typedef struct PSI_bootstrap PSI_bootstrap;
+struct PSI_none
+{
+  int opaque;
+};
+typedef struct PSI_none PSI;
+struct PSI_stage_info_none
+{
+  unsigned int m_key;
+  const char *m_name;
+  int m_flags;
+};
+typedef struct PSI_stage_info_none PSI_stage_info;
+extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
+C_MODE_END

include/mysql/psi/psi_abi_v1.h

-/* 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
@@ -21,6 +21,6 @@
 */
 #define USE_PSI_1
 #define HAVE_PSI_INTERFACE
-#define _global_h
+#define MY_GLOBAL_INCLUDED
 #include "mysql/psi/psi.h"
 

include/mysql/psi/psi_abi_v2.h.pp

 #include "mysql/psi/psi.h"
 C_MODE_START
+struct TABLE_SHARE;
+struct OPAQUE_LEX_YYSTYPE;
 struct PSI_mutex;
+typedef struct PSI_mutex PSI_mutex;
 struct PSI_rwlock;
+typedef struct PSI_rwlock PSI_rwlock;
 struct PSI_cond;
+typedef struct PSI_cond PSI_cond;
 struct PSI_table_share;
+typedef struct PSI_table_share PSI_table_share;
 struct PSI_table;
+typedef struct PSI_table PSI_table;
 struct PSI_thread;
+typedef struct PSI_thread PSI_thread;
 struct PSI_file;
+typedef struct PSI_file PSI_file;
+struct PSI_socket;
+typedef struct PSI_socket PSI_socket;
+struct PSI_table_locker;
+typedef struct PSI_table_locker PSI_table_locker;
+struct PSI_statement_locker;
+typedef struct PSI_statement_locker PSI_statement_locker;
+struct PSI_idle_locker;
+typedef struct PSI_idle_locker PSI_idle_locker;
+struct PSI_digest_locker;
+typedef struct PSI_digest_locker PSI_digest_locker;
 struct PSI_bootstrap
 {
   void* (*get_interface)(int version);
 };
+typedef struct PSI_bootstrap PSI_bootstrap;
 struct PSI_mutex_locker;
+typedef struct PSI_mutex_locker PSI_mutex_locker;
 struct PSI_rwlock_locker;
+typedef struct PSI_rwlock_locker PSI_rwlock_locker;
 struct PSI_cond_locker;
+typedef struct PSI_cond_locker PSI_cond_locker;
 struct PSI_file_locker;
+typedef struct PSI_file_locker PSI_file_locker;
+struct PSI_socket_locker;
+typedef struct PSI_socket_locker PSI_socket_locker;
 enum PSI_mutex_operation
 {
   PSI_MUTEX_LOCK= 0,
   PSI_MUTEX_TRYLOCK= 1
 };
+typedef enum PSI_mutex_operation PSI_mutex_operation;
 enum PSI_rwlock_operation
 {
   PSI_RWLOCK_READLOCK= 0,
@@ -27,11 +54,13 @@ enum PSI_rwlock_operation
   PSI_RWLOCK_TRYREADLOCK= 2,
   PSI_RWLOCK_TRYWRITELOCK= 3
 };
+typedef enum PSI_rwlock_operation PSI_rwlock_operation;
 enum PSI_cond_operation
 {
   PSI_COND_WAIT= 0,
   PSI_COND_TIMEDWAIT= 1
 };
+typedef enum PSI_cond_operation PSI_cond_operation;
 enum PSI_file_operation
 {
   PSI_FILE_CREATE= 0,
@@ -52,12 +81,54 @@ enum PSI_file_operation
   PSI_FILE_RENAME= 15,
   PSI_FILE_SYNC= 16
 };
-struct PSI_table_locker;
+typedef enum PSI_file_operation PSI_file_operation;
+enum PSI_table_io_operation
+{
+  PSI_TABLE_FETCH_ROW= 0,
+  PSI_TABLE_WRITE_ROW= 1,
+  PSI_TABLE_UPDATE_ROW= 2,
+  PSI_TABLE_DELETE_ROW= 3
+};
+typedef enum PSI_table_io_operation PSI_table_io_operation;
+enum PSI_table_lock_operation
+{
+  PSI_TABLE_LOCK= 0,
+  PSI_TABLE_EXTERNAL_LOCK= 1
+};
+typedef enum PSI_table_lock_operation PSI_table_lock_operation;
+enum PSI_socket_state
+{
+  PSI_SOCKET_STATE_IDLE= 1,
+  PSI_SOCKET_STATE_ACTIVE= 2
+};
+typedef enum PSI_socket_state PSI_socket_state;
+enum PSI_socket_operation
+{
+  PSI_SOCKET_CREATE= 0,
+  PSI_SOCKET_CONNECT= 1,
+  PSI_SOCKET_BIND= 2,
+  PSI_SOCKET_CLOSE= 3,
+  PSI_SOCKET_SEND= 4,
+  PSI_SOCKET_RECV= 5,
+  PSI_SOCKET_SENDTO= 6,
+  PSI_SOCKET_RECVFROM= 7,
+  PSI_SOCKET_SENDMSG= 8,
+  PSI_SOCKET_RECVMSG= 9,
+  PSI_SOCKET_SEEK= 10,
+  PSI_SOCKET_OPT= 11,
+  PSI_SOCKET_STAT= 12,
+  PSI_SOCKET_SHUTDOWN= 13,
+  PSI_SOCKET_SELECT= 14
+};
+typedef enum PSI_socket_operation PSI_socket_operation;
 typedef unsigned int PSI_mutex_key;
 typedef unsigned int PSI_rwlock_key;
 typedef unsigned int PSI_cond_key;
 typedef unsigned int PSI_thread_key;
 typedef unsigned int PSI_file_key;
+typedef unsigned int PSI_stage_key;
+typedef unsigned int PSI_statement_key;
+typedef unsigned int PSI_socket_key;
 struct PSI_v2
 {
   int placeholder;
@@ -82,6 +153,18 @@ struct PSI_file_info_v2
 {
   int placeholder;
 };
+struct PSI_stage_info_v2
+{
+  int placeholder;
+};
+struct PSI_statement_info_v2
+{
+  int placeholder;
+};
+struct PSI_idle_locker_state_v2
+{
+  int placeholder;
+};
 struct PSI_mutex_locker_state_v2
 {
   int placeholder;
@@ -102,16 +185,30 @@ struct PSI_table_locker_state_v2
 {
   int placeholder;
 };
+struct PSI_statement_locker_state_v2
+{
+  int placeholder;
+};
+struct PSI_socket_locker_state_v2
+{
+  int placeholder;
+};
 typedef struct PSI_v2 PSI;
 typedef struct PSI_mutex_info_v2 PSI_mutex_info;
 typedef struct PSI_rwlock_info_v2 PSI_rwlock_info;
 typedef struct PSI_cond_info_v2 PSI_cond_info;
 typedef struct PSI_thread_info_v2 PSI_thread_info;
 typedef struct PSI_file_info_v2 PSI_file_info;
+typedef struct PSI_stage_info_v2 PSI_stage_info;
+typedef struct PSI_statement_info_v2 PSI_statement_info;
+typedef struct PSI_socket_info_v2 PSI_socket_info;
+typedef struct PSI_idle_locker_state_v2 PSI_idle_locker_state;
 typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state;
 typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state;
 typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state;
 typedef struct PSI_file_locker_state_v2 PSI_file_locker_state;
 typedef struct PSI_table_locker_state_v2 PSI_table_locker_state;
+typedef struct PSI_statement_locker_state_v2 PSI_statement_locker_state;
+typedef struct PSI_socket_locker_state_v2 PSI_socket_locker_state;
 extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
 C_MODE_END

include/mysql/service_debug_sync.h

@@ -337,10 +337,16 @@ extern void (*debug_sync_C_callback_ptr)(MYSQL_THD, const char *, size_t);
 #define DEBUG_SYNC(thd, name)                           \
   do {                                                  \
     if (debug_sync_service)                             \
-      debug_sync_service(thd, name, sizeof(name)-1);    \
+      debug_sync_service(thd, STRING_WITH_LEN(name));   \
   } while(0)
+#define DEBUG_SYNC_C_IF_THD(thd, name)                  \
+  do {                                                  \
+    if (debug_sync_service && thd)                      \
+      (*debug_sync_service)(thd, STRING_WITH_LEN(name)); } \
+  while(0)
 #else
-#define DEBUG_SYNC(thd,name)            do { } while(0)
+#define DEBUG_SYNC(thd,name)           do { } while(0)
+#define DEBUG_SYNC_C_IF_THD(thd, name) do { } while(0)
 #endif
 
 /* compatibility macro */

libmysqld/CMakeLists.txt

@@ -69,7 +69,8 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc libmysqld.c lib_sql.cc
            ../sql/sql_lex.cc ../sql/keycaches.cc
            ../sql/sql_list.cc ../sql/sql_load.cc ../sql/sql_locale.cc 
            ../sql/sql_binlog.cc ../sql/sql_manager.cc
-           ../sql/sql_parse.cc ../sql/sql_partition.cc ../sql/sql_plugin.cc 
+           ../sql/sql_parse.cc ../sql/sql_bootstrap.cc
+           ../sql/sql_partition.cc ../sql/sql_plugin.cc 
            ../sql/debug_sync.cc ../sql/opt_table_elimination.cc
            ../sql/sql_prepare.cc ../sql/sql_rename.cc ../sql/sql_repl.cc 
            ../sql/sql_select.cc ../sql/sql_servers.cc

mysql-test/mysql-test-run.pl

@@ -3516,7 +3516,7 @@ sub mysql_install_db {
   {
     my $sql_dir= dirname($path_sql);
     # Use the mysql database for system tables
-    mtr_tofile($bootstrap_sql_file, "use mysql\n");
+    mtr_tofile($bootstrap_sql_file, "use mysql;\n");
 
     # Add the offical mysql system tables
     # for a production system

mysys/CMakeLists.txt

@@ -16,7 +16,9 @@
 INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR} ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/mysys)
 
 SET(MYSYS_SOURCES  array.c charset-def.c charset.c checksum.c default.c
-				errors.c hash.c list.c md5.c mf_cache.c mf_dirname.c mf_fn_ext.c
+				errors.c hash.c list.c
+                                md5.c md5_compute.cc
+                                mf_cache.c mf_dirname.c mf_fn_ext.c
 				mf_format.c mf_getdate.c mf_iocache.c mf_iocache2.c mf_keycache.c 
 				mf_keycaches.c mf_loadpath.c mf_pack.c mf_path.c mf_qsort.c mf_qsort2.c
 				mf_radix.c mf_same.c mf_sort.c mf_soundex.c mf_arr_appstr.c mf_tempdir.c
@@ -37,7 +39,7 @@ SET(MYSYS_SOURCES  array.c charset-def.c charset.c checksum.c default.c
                 safemalloc.c my_new.cc
 				my_atomic.c my_getncpus.c my_safehash.c my_chmod.c my_rnd.c
                                 my_uuid.c wqueue.c waiting_threads.c ma_dyncol.c
-				my_rdtsc.c my_context.c)
+				my_rdtsc.c my_context.c psi_noop.c)
 
 IF (WIN32)
  SET (MYSYS_SOURCES ${MYSYS_SOURCES} my_winthread.c my_wincond.c my_winerr.c my_winfile.c my_windac.c my_conio.c)

mysys/array.c

@@ -87,9 +87,9 @@ my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
     FALSE	Ok
 */
 
-my_bool insert_dynamic(DYNAMIC_ARRAY *array, const uchar* element)
+my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
 {
-  uchar* buffer;
+  void *buffer;
   if (array->elements == array->max_element)
   {						/* Call only when nessesary */
     if (!(buffer=alloc_dynamic(array)))
@@ -122,7 +122,7 @@ my_bool insert_dynamic(DYNAMIC_ARRAY *array, const uchar* element)
     0		Error
 */
 
-uchar *alloc_dynamic(DYNAMIC_ARRAY *array)
+void *alloc_dynamic(DYNAMIC_ARRAY *array)
 {
   DBUG_ENTER("alloc_dynamic");
   if (array->elements == array->max_element)
@@ -167,7 +167,7 @@ uchar *alloc_dynamic(DYNAMIC_ARRAY *array)
     0		Array is empty
 */
 
-uchar *pop_dynamic(DYNAMIC_ARRAY *array)
+void *pop_dynamic(DYNAMIC_ARRAY *array)
 {
   if (array->elements)
     return array->buffer+(--array->elements * array->size_of_element);
@@ -192,7 +192,7 @@ uchar *pop_dynamic(DYNAMIC_ARRAY *array)
     FALSE	Ok
 */
 
-my_bool set_dynamic(DYNAMIC_ARRAY *array, uchar* element, uint idx)
+my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
 {
   if (idx >= array->elements)
   {
@@ -268,7 +268,7 @@ my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
       idx	Index of element wanted.
 */
 
-void get_dynamic(DYNAMIC_ARRAY *array, uchar* element, uint idx)
+void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint idx)
 {
   if (idx >= array->elements)
   {
@@ -363,13 +363,13 @@ void freeze_size(DYNAMIC_ARRAY *array)
 
 */
 
-int get_index_dynamic(DYNAMIC_ARRAY *array, uchar* element)
+int get_index_dynamic(DYNAMIC_ARRAY *array, void* element)
 {
   size_t ret;
-  if (array->buffer > element)
+  if (array->buffer > (uchar*) element)
     return -1;
 
-  ret= (element - array->buffer) /  array->size_of_element;
+  ret= ((uchar*) element - array->buffer) /  array->size_of_element;
   if (ret > array->elements)
     return -1;
 

mysys/md5.c

@@ -38,13 +38,15 @@
    copyright in any changes I have made; this code remains in the
    public domain.  */
 
+/*
+  Skip entirely if built with OpenSSL/YaSSL support.
+*/
+#if !defined(HAVE_OPENSSL) && !defined(HAVE_YASSL)
+
 #include <my_global.h>
 #include <m_string.h>
 #include "my_md5.h"
 
-#include <string.h>	/* for memcpy() and memset() */
-
-
 static void 
 my_MD5Transform (cvs_uint32 buf[4], const unsigned char in[64]);
 
@@ -323,3 +325,5 @@ main (int argc, char **argv)
   return 0;
 }
 #endif /* TEST */
+
+#endif /* !defined(HAVE_OPENSSL) && !defined(HAVE_YASSL) */

mysys/md5_compute.cc

+/* Copyright (c) 2012, 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
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+
+/**
+  @file
+
+  @brief
+  Wrapper functions for OpenSSL, YaSSL and MySQL's MD5
+  implementations. Also provides a Compatibility layer
+  to make available YaSSL's MD5 implementation.
+*/
+
+#include <my_global.h>
+#include <my_md5.h>
+
+#ifdef HAVE_YASSL
+
+#include "md5.hpp"
+
+/**
+  Compute MD5 message digest.
+
+  @param digest [out]  Computed MD5 digest
+  @param buf    [in]   Message to be computed
+  @param len    [in]   Length of the message
+
+  @return              void
+*/
+void my_md5_hash(char *digest, const char *buf, int len)
+{
+  TaoCrypt::MD5 hasher;
+  hasher.Update((TaoCrypt::byte *) buf, len);
+  hasher.Final((TaoCrypt::byte *) digest);
+}
+#endif /* HAVE_YASSL */
+
+
+/**
+    Wrapper function to compute MD5 message digest.
+
+    @param digest [out]  Computed MD5 digest
+    @param buf    [in]   Message to be computed
+    @param len    [in]   Length of the message
+
+    @return              void
+*/
+void compute_md5_hash(char *digest, const char *buf, int len)
+{
+#ifdef HAVE_YASSL
+  my_md5_hash(digest, buf, len);
+#else
+  MY_MD5_HASH((unsigned char *) digest, (unsigned char const *) buf, len);
+#endif /* HAVE_YASSL */
+}
+

mysys/my_static.c

@@ -98,31 +98,3 @@ my_bool my_disable_sync=0;
 my_bool my_disable_async_io=0;
 my_bool my_disable_flush_key_blocks=0;
 my_bool my_disable_symlinks=0;
-
-/*
-  Note that PSI_hook and PSI_server are unconditionally
-  (no ifdef HAVE_PSI_INTERFACE) defined.
-  This is to ensure binary compatibility between the server and plugins,
-  in the case when:
-  - the server is not compiled with HAVE_PSI_INTERFACE
-  - a plugin is compiled with HAVE_PSI_INTERFACE
-  See the doxygen documentation for the performance schema.
-*/
-
-/**
-  Hook for the instrumentation interface.
-  Code implementing the instrumentation interface should register here.
-*/
-struct PSI_bootstrap *PSI_hook= NULL;
-
-/**
-  Instance of the instrumentation interface for the MySQL server.
-  @todo This is currently a global variable, which is handy when
-  compiling instrumented code that is bundled with the server.
-  When dynamic plugin are truly supported, this variable will need
-  to be replaced by a macro, so that each XYZ plugin can have it's own
-  xyz_psi_server variable, obtained from PSI_bootstrap::get_interface()
-  with the version used at compile time for plugin XYZ.
-*/
-PSI *PSI_server= NULL;
-

sql/CMakeLists.txt

@@ -59,7 +59,8 @@ SET (SQL_SOURCE
                sql_cache.cc sql_class.cc sql_client.cc sql_crypt.cc sql_crypt.h 
                sql_cursor.cc sql_db.cc sql_delete.cc sql_derived.cc sql_do.cc 
                sql_error.cc sql_handler.cc sql_help.cc sql_insert.cc sql_lex.cc 
-               sql_list.cc sql_load.cc sql_manager.cc sql_parse.cc
+               sql_list.cc sql_load.cc sql_manager.cc
+               sql_parse.cc sql_bootstrap.cc sql_bootstrap.h
                sql_partition.cc sql_plugin.cc sql_prepare.cc sql_rename.cc 
                debug_sync.cc debug_sync.h
                sql_repl.cc sql_select.cc sql_show.cc sql_state.c sql_string.cc