List:Commits« Previous MessageNext Message »
From:Marc Alff Date:October 10 2008 8:39pm
Subject:bzr push into mysql-6.0-perf branch (marc.alff:2693 to 2694)
View as plain text  
 2694 Marc Alff	2008-10-10
      Basic PSI instrumentation
added:
  include/mysql/mysql_mutex.h
  include/mysql/psi.h
  include/mysql/psi_abi_v1.h
  include/mysql/psi_abi_v1.h.pp
  include/mysql/psi_abi_v2.h
  include/mysql/psi_abi_v2.h.pp
  storage/perfschema/
  storage/perfschema/Makefile.am
  storage/perfschema/ha_perfschema.cc
  storage/perfschema/ha_perfschema.h
  storage/perfschema/plug.in
  storage/perfschema/pse_metadata.cc
  storage/perfschema/pse_metadata.h
  storage/perfschema/psm.cc
  storage/perfschema/psm.h
  storage/perfschema/psm_server.cc
  storage/perfschema/psm_server.h
  storage/perfschema/unittest/
  storage/perfschema/unittest/Makefile.am
modified:
  Makefile.am
  configure.in
  include/heap.h
  include/keycache.h
  include/maria.h
  include/my_bitmap.h
  include/my_no_pthread.h
  include/my_pthread.h
  include/my_sys.h
  include/myisam.h
  include/myisammrg.h
  include/thr_lock.h
  include/wqueue.h
  mysys/charset.c
  mysys/mf_iocache.c
  mysys/mf_iocache2.c
  mysys/mf_keycache.c
  mysys/mf_tempdir.c
  mysys/my_bitmap.c
  mysys/my_fopen.c
  mysys/my_gethostbyname.c
  mysys/my_getsystime.c
  mysys/my_lib.c
  mysys/my_lockmem.c
  mysys/my_net.c
  mysys/my_open.c
  mysys/my_pread.c
  mysys/my_pthread.c
  mysys/my_safehash.c
  mysys/my_safehash.h
  mysys/my_seek.c
  mysys/my_static.c
  mysys/my_thr_init.c
  mysys/my_uuid.c
  mysys/my_wincond.c
  mysys/my_winthread.c
  mysys/mysys_priv.h
  mysys/safemalloc.c
  mysys/thr_alarm.c
  mysys/thr_lock.c
  mysys/thr_rwlock.c
  mysys/wqueue.c
  sql/backup/backup_kernel.h
  sql/backup/be_thread.cc
  sql/backup/be_thread.h
  sql/backup/kernel.cc
  sql/ddl_blocker.cc
  sql/ddl_blocker.h
  sql/debug_sync.cc
  sql/des_key_file.cc
  sql/event_queue.cc
  sql/event_queue.h
  sql/event_scheduler.cc
  sql/event_scheduler.h
  sql/events.cc
  sql/events.h
  sql/ha_ndbcluster.cc
  sql/ha_ndbcluster.h
  sql/ha_ndbcluster_binlog.cc
  sql/ha_ndbcluster_binlog.h
  sql/ha_ndbcluster_connection.cc
  sql/ha_partition.cc
  sql/ha_partition.h
  sql/handler.cc
  sql/hash_filo.h
  sql/hostname.cc
  sql/item_func.cc
  sql/item_strfunc.cc
  sql/lock.cc
  sql/log.cc
  sql/log.h
  sql/log_event.cc
  sql/log_event.h
  sql/mdl.cc
  sql/mdl.h
  sql/mysql_priv.h
  sql/mysqld.cc
  sql/net_serv.cc
  sql/repl_failsafe.cc
  sql/repl_failsafe.h
  sql/rpl_mi.cc
  sql/rpl_mi.h
  sql/rpl_rli.cc
  sql/rpl_rli.h
  sql/scheduler.cc
  sql/set_var.cc
  sql/set_var.h
  sql/si_objects.cc
  sql/slave.cc
  sql/slave.h
  sql/sp_cache.cc
  sql/sp_head.cc
  sql/sql_acl.cc
  sql/sql_audit.cc
  sql/sql_base.cc
  sql/sql_cache.cc
  sql/sql_cache.h
  sql/sql_class.cc
  sql/sql_class.h
  sql/sql_connect.cc
  sql/sql_db.cc
  sql/sql_delete.cc
  sql/sql_handler.cc
  sql/sql_insert.cc
  sql/sql_manager.cc
  sql/sql_map.cc
  sql/sql_parse.cc
  sql/sql_partition.cc
  sql/sql_plugin.cc
  sql/sql_rename.cc
  sql/sql_repl.cc
  sql/sql_servers.cc
  sql/sql_show.cc
  sql/sql_table.cc
  sql/sql_test.cc
  sql/sql_trigger.cc
  sql/sql_udf.cc
  sql/sql_view.cc
  sql/table.cc
  sql/table.h
  sql/tztime.cc
  sql/udf_example.c
  storage/federated/ha_federated.cc
  storage/federated/ha_federated.h
  storage/maria/ha_maria.cc
  storage/maria/lockman.c
  storage/maria/lockman.h
  storage/maria/ma_bitmap.c
  storage/maria/ma_blockrec.c
  storage/maria/ma_check.c
  storage/maria/ma_checkpoint.c
  storage/maria/ma_close.c
  storage/maria/ma_create.c
  storage/maria/ma_dynrec.c
  storage/maria/ma_extra.c
  storage/maria/ma_info.c
  storage/maria/ma_init.c
  storage/maria/ma_key_recover.c
  storage/maria/ma_keycache.c
  storage/maria/ma_locking.c
  storage/maria/ma_loghandler.c
  storage/maria/ma_open.c
  storage/maria/ma_page.c
  storage/maria/ma_pagecache.h
  storage/maria/ma_panic.c
  storage/maria/ma_range.c
  storage/maria/ma_recovery.c
  storage/maria/ma_rkey.c
  storage/maria/ma_rnext.c
  storage/maria/ma_rnext_same.c
  storage/maria/ma_rprev.c
  storage/maria/ma_rsame.c
  storage/maria/ma_sort.c
  storage/maria/ma_state.c
  storage/maria/ma_static.c
  storage/maria/ma_write.c
  storage/maria/maria_def.h
  storage/maria/tablockman.c
  storage/maria/tablockman.h
  storage/maria/trnman.c
  storage/maria/trnman_public.h
  storage/myisam/ha_myisam.cc
  storage/myisam/mi_check.c
  storage/myisam/mi_close.c
  storage/myisam/mi_create.c
  storage/myisam/mi_dbug.c
  storage/myisam/mi_dynrec.c
  storage/myisam/mi_extra.c
  storage/myisam/mi_info.c
  storage/myisam/mi_keycache.c
  storage/myisam/mi_locking.c
  storage/myisam/mi_log.c
  storage/myisam/mi_open.c
  storage/myisam/mi_panic.c
  storage/myisam/mi_range.c
  storage/myisam/mi_rkey.c
  storage/myisam/mi_rnext.c
  storage/myisam/mi_rnext_same.c
  storage/myisam/mi_rprev.c
  storage/myisam/mi_rsame.c
  storage/myisam/mi_write.c
  storage/myisam/myisam_backup_engine.cc
  storage/myisam/myisamdef.h
  storage/myisam/sort.c

 2693 Marc Alff	2008-09-29
      New tree
modified:
  .bzr-mysql/default.conf

=== modified file 'Makefile.am'
--- a/Makefile.am	2008-09-11 18:36:05 +0000
+++ b/Makefile.am	2008-10-10 20:34:55 +0000
@@ -253,11 +253,12 @@ test-full-qa:
 #
 
 API_PREPROCESSOR_HEADER = $(top_srcdir)/include/mysql/plugin.h \
-                           $(top_srcdir)/include/mysql.h
+                          $(top_srcdir)/include/mysql.h \
+                          $(top_srcdir)/include/mysql/psi_abi_v1.h \
+                          $(top_srcdir)/include/mysql/psi_abi_v2.h
 
-TEST_PREPROCESSOR_HEADER = $(top_srcdir)/include/mysql/plugin.h \
-                            $(top_srcdir)/sql/mysql_priv.h \
-                            $(top_srcdir)/include/mysql.h
+TEST_PREPROCESSOR_HEADER = $(API_PREPROCESSOR_HEADER) \
+                           $(top_srcdir)/sql/mysql_priv.h
 
 #
 # Rules for checking that the abi/api has not changed.

=== modified file 'configure.in'
--- a/configure.in	2008-09-23 10:37:16 +0000
+++ b/configure.in	2008-10-10 20:34:55 +0000
@@ -1766,6 +1766,17 @@ case "$with_atomic_ops" in
    *) AC_MSG_ERROR(["$with_atomic_ops" is not a valid value for --with-atomic-ops]) ;;
 esac
 
+AC_ARG_WITH([performance-schema-interface],
+    AC_HELP_STRING([--with-performance-schema-interface],
+    [Compile with the performance schema interface mysql/psi.h (default is enabled)]),
+    [with_psi=$withval], [with_psi=yes])
+
+if test "$with_psi" != "no"
+then
+  AC_DEFINE([HAVE_PSI_INTERFACE], [1],
+            [Define to 1 if you want to use mysql/psi.h])
+fi
+
 AC_CACHE_CHECK([whether the compiler provides atomic builtins],
                [mysql_cv_gcc_atomic_builtins], [AC_TRY_RUN([
   int main()

=== modified file 'include/heap.h'
--- a/include/heap.h	2007-07-24 22:58:12 +0000
+++ b/include/heap.h	2008-10-10 20:34:55 +0000
@@ -148,7 +148,7 @@ typedef struct st_heap_share
   char * name;			/* Name of "memory-file" */
 #ifdef THREAD
   THR_LOCK lock;
-  pthread_mutex_t intern_lock;		/* Locking for use with _locking */
+  mysql_mutex_t intern_lock;		/* Locking for use with _locking */
 #endif
   my_bool delete_on_close;
   LIST open_list;

=== modified file 'include/keycache.h'
--- a/include/keycache.h	2008-07-09 07:12:43 +0000
+++ b/include/keycache.h	2008-10-10 20:34:55 +0000
@@ -77,7 +77,7 @@ typedef struct st_key_cache
   uchar HUGE_PTR *block_mem;     /* memory for block buffers                 */
   BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
   BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
-  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
+  mysql_mutex_t cache_lock;    /* to lock access to the cache structure    */
   KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
   /*
     Waiting for a zero resize count. Using a queue for symmetry though

=== modified file 'include/maria.h'
--- a/include/maria.h	2008-06-26 05:18:28 +0000
+++ b/include/maria.h	2008-10-10 20:34:55 +0000
@@ -346,8 +346,8 @@ typedef struct st_maria_sort_info
 {
 #ifdef THREAD
   /* sync things */
-  pthread_mutex_t mutex;
-  pthread_cond_t cond;
+  mysql_mutex_t mutex;
+  mysql_cond_t cond;
 #endif
   MARIA_HA *info, *new_info;
   HA_CHECK *param;

=== modified file 'include/my_bitmap.h'
--- a/include/my_bitmap.h	2007-12-12 10:14:59 +0000
+++ b/include/my_bitmap.h	2008-10-10 20:34:55 +0000
@@ -34,7 +34,7 @@ typedef struct st_bitmap
      acquiring the mutex
    */
 #ifdef THREAD
-  pthread_mutex_t *mutex;
+  mysql_mutex_t *mutex;
 #endif
 } MY_BITMAP;
 

=== modified file 'include/my_no_pthread.h'
--- a/include/my_no_pthread.h	2006-12-23 19:20:40 +0000
+++ b/include/my_no_pthread.h	2008-10-10 20:34:55 +0000
@@ -47,4 +47,15 @@
 #define rw_unlock(A)
 #define rwlock_destroy(A)
 
+#define MYSQL_MUTEX_INIT(A,B,C)
+#define MYSQL_MUTEX_LOCK(A)
+#define MYSQL_MUTEX_UNLOCK(A)
+#define MYSQL_MUTEX_DESTROY(A)
+
+#define MYSQL_RWLOCK_INIT(A,B,C)
+#define MYSQL_RWLOCK_RDLOCK(A)
+#define MYSQL_RWLOCK_WRLOCK(A)
+#define MYSQL_RWLOCK_UNLOCK(A)
+#define MYSQL_RWLOCK_DESTROY(A)
+
 #endif

=== modified file 'include/my_pthread.h'
--- a/include/my_pthread.h	2008-09-03 06:07:52 +0000
+++ b/include/my_pthread.h	2008-10-10 20:34:55 +0000
@@ -677,13 +677,15 @@ extern int pthread_dummy(int);
 #define MY_PTHREAD_LOCK_READ 0
 #define MY_PTHREAD_LOCK_WRITE 1
 
+#include "mysql/mysql_mutex.h"
+
 struct st_my_thread_var
 {
   int thr_errno;
-  pthread_cond_t suspend;
-  pthread_mutex_t mutex;
-  pthread_mutex_t * volatile current_mutex;
-  pthread_cond_t * volatile current_cond;
+  mysql_cond_t suspend;
+  mysql_mutex_t mutex;
+  mysql_mutex_t * volatile current_mutex;
+  mysql_cond_t * volatile current_cond;
   pthread_t pthread_self;
   my_thread_id id;
   int cmp_length;
@@ -735,16 +737,16 @@ extern uint thd_lib_detected;
 #ifdef THREAD
 #ifndef thread_safe_increment
 #define thread_safe_increment(V,L) \
-        (pthread_mutex_lock((L)), (V)++, pthread_mutex_unlock((L)))
+        (MYSQL_MUTEX_LOCK((L)), (V)++, MYSQL_MUTEX_UNLOCK((L)))
 #define thread_safe_decrement(V,L) \
-        (pthread_mutex_lock((L)), (V)--, pthread_mutex_unlock((L)))
+        (MYSQL_MUTEX_LOCK((L)), (V)--, MYSQL_MUTEX_UNLOCK((L)))
 #endif
 
 #ifndef thread_safe_add
 #define thread_safe_add(V,C,L) \
-        (pthread_mutex_lock((L)), (V)+=(C), pthread_mutex_unlock((L)))
+        (MYSQL_MUTEX_LOCK((L)), (V)+=(C), MYSQL_MUTEX_UNLOCK((L)))
 #define thread_safe_sub(V,C,L) \
-        (pthread_mutex_lock((L)), (V)-=(C), pthread_mutex_unlock((L)))
+        (MYSQL_MUTEX_LOCK((L)), (V)-=(C), MYSQL_MUTEX_UNLOCK((L)))
 #endif
 #endif
 

=== modified file 'include/my_sys.h'
--- a/include/my_sys.h	2008-08-24 16:12:12 +0000
+++ b/include/my_sys.h	2008-10-10 20:34:55 +0000
@@ -332,7 +332,7 @@ struct st_my_file_info
   char *		name;
   enum file_type	type;
 #if defined(THREAD) && !defined(HAVE_PREAD) && !defined(__WIN__)
-  pthread_mutex_t	mutex;
+  mysql_mutex_t	mutex;
 #endif
 };
 
@@ -352,7 +352,7 @@ typedef struct st_my_tmpdir
   char **list;
   uint cur, max;
 #ifdef THREAD
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
 #endif
 } MY_TMPDIR;
 
@@ -371,9 +371,9 @@ typedef int (*IO_CACHE_CALLBACK)(struct 
 #ifdef THREAD
 typedef struct st_io_cache_share
 {
-  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
-  pthread_cond_t        cond;            /* To wait for signals. */
-  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
+  mysql_mutex_t       mutex;           /* To sync on reads into buffer. */
+  mysql_cond_t        cond;            /* To wait for signals. */
+  mysql_cond_t        cond_writer;     /* For a synchronized writer. */
   /* Offset in file corresponding to the first byte of buffer. */
   my_off_t              pos_in_file;
   /* If a synchronized write cache is the source of the data. */
@@ -434,7 +434,7 @@ typedef struct st_io_cache		/* Used when
     The lock is for append buffer used in SEQ_READ_APPEND cache
     need mutex copying from append buffer to read buffer.
   */
-  pthread_mutex_t append_buffer_lock;
+  mysql_mutex_t append_buffer_lock;
   /*
     The following is used when several threads are reading the
     same file in parallel. They are synchronized on disk
@@ -1032,5 +1032,11 @@ void netware_reg_user(const char *ip, co
 		      const char *application);
 #endif
 
+#ifdef HAVE_PSI_INTERFACE
+#include "mysql/psi.h"
+extern struct PSI_bootstrap *PSI_hook;
+extern PSI *PSI_server;
+#endif
+
 C_MODE_END
 #endif /* _my_sys_h */

=== modified file 'include/myisam.h'
--- a/include/myisam.h	2008-08-24 16:12:12 +0000
+++ b/include/myisam.h	2008-10-10 20:34:55 +0000
@@ -339,8 +339,8 @@ typedef struct st_sort_info
 {
 #ifdef THREAD
   /* sync things */
-  pthread_mutex_t mutex;
-  pthread_cond_t cond;
+  mysql_mutex_t mutex;
+  mysql_cond_t cond;
 #endif
   MI_INFO *info;
   HA_CHECK *param;

=== modified file 'include/myisammrg.h'
--- a/include/myisammrg.h	2008-04-25 21:45:58 +0000
+++ b/include/myisammrg.h	2008-10-10 20:34:55 +0000
@@ -74,7 +74,7 @@ typedef struct st_myrg_info
   LIST	 open_list;
   QUEUE  by_key;
   ulong *rec_per_key_part;			/* for sql optimizing */
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
 } MYRG_INFO;
 
 

=== added file 'include/mysql/mysql_mutex.h'
--- a/include/mysql/mysql_mutex.h	1970-01-01 00:00:00 +0000
+++ b/include/mysql/mysql_mutex.h	2008-10-10 20:34:55 +0000
@@ -0,0 +1,377 @@
+
+#ifndef MYSQL_MUTEX_H
+#define MYSQL_MUTEX_H
+
+#ifdef HAVE_PSI_INTERFACE
+#include "mysql/psi.h"
+extern PSI *PSI_server;
+#endif
+
+#define MYSQL_MUTEX_ASSERT_OWNER(M) safe_mutex_assert_owner(& (M)->m_mutex)
+#define MYSQL_MUTEX_ASSERT_NOT_OWNER(M) safe_mutex_assert_not_owner(& (M)->m_mutex)
+
+#ifdef SAFE_MUTEX
+  #define MYSQL_MUTEX_INIT(M,K,A) mysql_mutex_init(M,K,A,__FILE__,__LINE__)
+  #define MYSQL_MUTEX_DESTROY(M) mysql_mutex_destroy(M,__FILE__,__LINE__)
+  #define MYSQL_MUTEX_LOCK(M) mysql_mutex_lock(M,__FILE__,__LINE__)
+  #define MYSQL_MUTEX_UNLOCK(M) mysql_mutex_unlock(M,__FILE__,__LINE__)
+#else
+  #define MYSQL_MUTEX_INIT(M,K,A) mysql_mutex_init(M,K,A)
+  #define MYSQL_MUTEX_DESTROY(M) mysql_mutex_destroy(M)
+  #define MYSQL_MUTEX_LOCK(M) mysql_mutex_lock(M)
+  #define MYSQL_MUTEX_UNLOCK(M) mysql_mutex_unlock(M)
+#endif
+
+#define MYSQL_RWLOCK_INIT(M,K,A) mysql_rwlock_init(M,K,A)
+#define MYSQL_RWLOCK_DESTROY(M) mysql_rwlock_destroy(M)
+#define MYSQL_RWLOCK_RDLOCK(M) mysql_rwlock_rdlock(M)
+#define MYSQL_RWLOCK_WRLOCK(M) mysql_rwlock_wrlock(M)
+#define MYSQL_RWLOCK_TRYRDLOCK(M) mysql_rwlock_tryrdlock(M)
+#define MYSQL_RWLOCK_TRYWRLOCK(M) mysql_rwlock_trywrlock(M)
+#define MYSQL_RWLOCK_UNLOCK(M) mysql_rwlock_unlock(M)
+
+#define MYSQL_COND_INIT(C,K,A) mysql_cond_init(C,K,A)
+#define MYSQL_COND_DESTROY(C) mysql_cond_destroy(C)
+#define MYSQL_COND_WAIT(C,M) mysql_cond_wait(C,M)
+#define MYSQL_COND_TIMEDWAIT(C,M,W) mysql_cond_timedwait(C,M,W)
+#define MYSQL_COND_SIGNAL(C) mysql_cond_signal(C)
+#define MYSQL_COND_BROADCAST(C) mysql_cond_broadcast(C)
+
+/*
+  Note: there are several orthogonal dimensions here.
+  - HAVE_PSI_INTERFACE, flag controlling the performance schema
+  instrumentation,
+
+  - SAFE_MUTEX, flag controlling internal debugging tools
+*/
+
+struct s_mysql_mutex
+{
+  pthread_mutex_t m_mutex;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_mutex *m_psi;
+#endif
+};
+typedef struct s_mysql_mutex mysql_mutex_t;
+
+static inline int mysql_mutex_init(
+  mysql_mutex_t *that,
+#ifdef HAVE_PSI_INTERFACE
+  PSI_mutex_key key,
+#endif
+  const pthread_mutexattr_t *attr
+#ifdef SAFE_MUTEX
+  , const char* file, int line
+#endif
+  )
+{
+#ifdef HAVE_PSI_INTERFACE
+  that->m_psi= PSI_server ? PSI_server->init_mutex(key, & that->m_mutex) : NULL;
+#endif
+#ifdef SAFE_MUTEX
+  return safe_mutex_init(& that->m_mutex, attr, file, line, "FIXME");
+#else
+  return pthread_mutex_init(& that->m_mutex, attr);
+#endif
+}
+
+static inline int mysql_mutex_destroy(
+  mysql_mutex_t *that
+#ifdef SAFE_MUTEX
+  , const char* file, int line
+#endif
+  )
+{
+#ifdef HAVE_PSI_INTERFACE
+  if (PSI_server && that->m_psi)
+    PSI_server->destroy_mutex(that->m_psi, & that->m_mutex);
+#endif
+#ifdef SAFE_MUTEX
+  return safe_mutex_destroy(& that->m_mutex, file, line);
+#else
+  return pthread_mutex_destroy(& that->m_mutex);
+#endif
+}
+
+static inline int mysql_mutex_lock(
+  mysql_mutex_t *that
+#ifdef SAFE_MUTEX
+  , const char* file, int line
+#endif
+  )
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_wait(locker, that->m_psi, 1);
+#endif
+#ifdef SAFE_MUTEX
+  result= safe_mutex_lock(& that->m_mutex, FALSE, file, line);
+#else
+  result= pthread_mutex_lock(& that->m_mutex);
+#endif
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_wait(locker, that->m_psi, 1, result);
+#endif
+  return result;
+}
+
+static inline int mysql_mutex_unlock(
+  mysql_mutex_t *that
+#ifdef SAFE_MUTEX
+  , const char* file, int line
+#endif
+  )
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      PSI_server->unlock_mutex(thread, that->m_psi);
+#endif
+#ifdef SAFE_MUTEX
+  result= safe_mutex_unlock(& that->m_mutex, file, line);
+#else
+  result= pthread_mutex_unlock(& that->m_mutex);
+#endif
+  return result;
+}
+
+struct s_mysql_rwlock
+{
+  rw_lock_t m_rwlock;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_rwlock *m_psi;
+#endif
+};
+typedef struct s_mysql_rwlock mysql_rwlock_t;
+
+static inline int mysql_rwlock_init(
+  mysql_rwlock_t *that,
+#ifdef HAVE_PSI_INTERFACE
+  PSI_rwlock_key key,
+#endif
+  const pthread_rwlockattr_t *attr)
+{
+#ifdef HAVE_PSI_INTERFACE
+  that->m_psi= (PSI_server ? PSI_server->init_rwlock(key, & that->m_rwlock) : NULL);
+#endif
+  return my_rwlock_init(& that->m_rwlock, attr);
+}
+
+static inline int mysql_rwlock_destroy(
+  mysql_rwlock_t *that)
+{
+#ifdef HAVE_PSI_INTERFACE
+  if (PSI_server)
+    PSI_server->destroy_rwlock(that->m_psi, & that->m_rwlock);
+#endif
+  return rwlock_destroy(& that->m_rwlock);
+}
+
+static inline int mysql_rwlock_rdlock(
+  mysql_rwlock_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_rdwait(locker, that->m_psi, 1);
+#endif
+  result= rw_rdlock(& that->m_rwlock);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_rdwait(locker, that->m_psi, 1, result);
+#endif
+  return result;
+}
+
+static inline int mysql_rwlock_wrlock(
+  mysql_rwlock_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_wrwait(locker, that->m_psi, 1);
+#endif
+  result= rw_rdlock(& that->m_rwlock);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_wrwait(locker, that->m_psi, 1, result);
+#endif
+  return result;
+}
+
+static inline int mysql_rwlock_tryrdlock(
+  mysql_rwlock_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_rdwait(locker, that->m_psi, 0);
+#endif
+  result= rw_rdlock(& that->m_rwlock);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_rdwait(locker, that->m_psi, 0, result);
+#endif
+  return result;
+}
+
+static inline int mysql_rwlock_trywrlock(
+  mysql_rwlock_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_wrwait(locker, that->m_psi, 0);
+#endif
+  result= rw_rdlock(& that->m_rwlock);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_wrwait(locker, that->m_psi, 0, result);
+#endif
+  return result;
+}
+
+static inline int mysql_rwlock_unlock(
+  mysql_rwlock_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      PSI_server->unlock_rwlock(thread, that->m_psi);
+#endif
+  result= rw_unlock(& that->m_rwlock);
+  return result;
+}
+
+struct s_mysql_cond
+{
+  pthread_cond_t m_cond;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_cond *m_psi;
+#endif
+};
+typedef struct s_mysql_cond mysql_cond_t;
+
+static inline int mysql_cond_init(
+  mysql_cond_t *that,
+#ifdef HAVE_PSI_INTERFACE
+  PSI_cond_key key,
+#endif
+  const pthread_condattr_t *attr
+  )
+{
+#ifdef HAVE_PSI_INTERFACE
+  that->m_psi= (PSI_server ? PSI_server->init_cond(key, & that->m_cond) : NULL);
+#endif
+  return pthread_cond_init(& that->m_cond, attr);
+}
+
+static inline int mysql_cond_destroy(
+  mysql_cond_t *that)
+{
+#ifdef HAVE_PSI_INTERFACE
+  if (PSI_server)
+    PSI_server->destroy_cond(that->m_psi, & that->m_cond);
+#endif
+  return pthread_cond_destroy(& that->m_cond);
+}
+
+static inline int mysql_cond_wait(
+  mysql_cond_t *that,
+  mysql_mutex_t *mutex)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_condwait(locker, that->m_psi, 1);
+#endif
+  result= pthread_cond_wait(& that->m_cond, & mutex->m_mutex);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_condwait(locker, that->m_psi, 1, result);
+#endif
+  return result;
+}
+
+static inline int mysql_cond_timedwait(
+  mysql_cond_t *that,
+  mysql_mutex_t *mutex,
+  struct timespec *abstime)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_locker *locker= NULL;
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      if ((locker= PSI_server->get_locker(thread)))
+        PSI_server->start_condwait(locker, that->m_psi, 0);
+#endif
+  result= pthread_cond_timedwait(& that->m_cond, & mutex->m_mutex, abstime);
+#ifdef HAVE_PSI_INTERFACE
+  if (locker)
+    PSI_server->end_condwait(locker, that->m_psi, 0, result);
+#endif
+  return result;
+}
+
+static inline int mysql_cond_signal(
+  mysql_cond_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      PSI_server->signal_cond(thread, that->m_psi);
+#endif
+  result= pthread_cond_signal(& that->m_cond);
+  return result;
+}
+
+static inline int mysql_cond_broadcast(
+  mysql_cond_t *that)
+{
+  int result;
+#ifdef HAVE_PSI_INTERFACE
+  struct PSI_thread *thread;
+  if (PSI_server && that->m_psi)
+    if ((thread= PSI_server->get_thread()))
+      PSI_server->broadcast_cond(thread, that->m_psi);
+#endif
+  result= pthread_cond_broadcast(& that->m_cond);
+  return result;
+}
+
+#endif
+

=== added file 'include/mysql/psi.h'
--- a/include/mysql/psi.h	1970-01-01 00:00:00 +0000
+++ b/include/mysql/psi.h	2008-10-10 20:34:55 +0000
@@ -0,0 +1,100 @@
+
+#ifndef MYSQL_PERFORMANCE_SCHEMA_INTERFACE_H
+#define MYSQL_PERFORMANCE_SCHEMA_INTERFACE_H
+
+#define PSI_VERSION_1 1
+#define PSI_VERSION_2 2
+#define PSI_CURRENT_VERSION 1
+
+#ifndef USE_PSI_2
+#ifndef USE_PSI_1
+#define USE_PSI_1
+#endif
+#endif
+
+struct PSI_bootstrap
+{
+  void* (*get_PSI)(int version);
+};
+
+/* Opaque structure */
+struct PSI_mutex;
+struct PSI_rwlock;
+struct PSI_cond;
+struct PSI_thread;
+struct PSI_locker;
+
+/* Opaque key */
+typedef int PSI_mutex_key;
+typedef int PSI_rwlock_key;
+typedef int PSI_cond_key;
+
+#ifdef USE_PSI_1
+#define HAVE_PSI_1
+#endif
+
+#ifdef HAVE_PSI_1
+/**
+  Performance Schema Application Binary Interface, version 1.
+*/
+struct PSI_v1
+{
+  PSI_mutex_key (*register_mutex)(const char* name, int global);
+  PSI_rwlock_key (*register_rwlock)(const char* name, int global);
+  PSI_cond_key (*register_cond)(const char* name, int global);
+
+  struct PSI_mutex* (*init_mutex)(PSI_mutex_key key, void *identity);
+  void (*destroy_mutex)(struct PSI_mutex* mutex, void *identity);
+  struct PSI_rwlock* (*init_rwlock)(PSI_rwlock_key key, void *identity);
+  void (*destroy_rwlock)(struct PSI_rwlock* rwlock, void *identity);
+  struct PSI_cond* (*init_cond)(PSI_cond_key key, void *identity);
+  void (*destroy_cond)(struct PSI_cond* cond, void *identity);
+
+  struct PSI_thread* (*new_thread)();
+  struct PSI_thread* (*get_thread)();
+  void (*delete_thread)(struct PSI_thread *thread);
+
+  struct PSI_locker* (*get_locker)(struct PSI_thread *thread);
+
+  void (*unlock_mutex)(struct PSI_thread *thread, struct PSI_mutex* mutex);
+  void (*unlock_rwlock)(struct PSI_thread *thread, struct PSI_rwlock* rwlock);
+  void (*signal_cond)(struct PSI_thread *thread, struct PSI_cond* cond);
+  void (*broadcast_cond)(struct PSI_thread *thread, struct PSI_cond* cond);
+
+  void (*start_wait)(struct PSI_locker* locker, struct PSI_mutex* mutex, int must);
+  void (*end_wait)(struct PSI_locker* locker, struct PSI_mutex* mutex, int must, int rc);
+  void (*start_rdwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must);
+  void (*end_rdwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must, int rc);
+  void (*start_wrwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must);
+  void (*end_wrwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must, int rc);
+  void (*start_condwait)(struct PSI_locker* locker, struct PSI_cond* cond, int must);
+  void (*end_condwait)(struct PSI_locker* locker, struct PSI_cond* cond, int must, int rc);
+};
+#endif
+
+#ifdef USE_PSI_2
+#define HAVE_PSI_2
+#endif
+
+#ifdef HAVE_PSI_2
+/**
+  Performance Schema Application Binary Interface, version 2.
+*/
+struct PSI_v2
+{
+  int later;
+  /* ... extended interface ... */
+};
+#endif
+
+/* Export the required version */
+#ifdef USE_PSI_1
+typedef struct PSI_v1 PSI;
+#endif
+
+#ifdef USE_PSI_2
+typedef struct PSI_v2 PSI;
+#endif
+
+#endif
+

=== added file 'include/mysql/psi_abi_v1.h'
--- a/include/mysql/psi_abi_v1.h	1970-01-01 00:00:00 +0000
+++ b/include/mysql/psi_abi_v1.h	2008-10-10 20:34:55 +0000
@@ -0,0 +1,4 @@
+
+#define USE_PSI_1
+#include "mysql/psi.h"
+

=== added file 'include/mysql/psi_abi_v1.h.pp'
--- a/include/mysql/psi_abi_v1.h.pp	1970-01-01 00:00:00 +0000
+++ b/include/mysql/psi_abi_v1.h.pp	2008-10-10 20:34:55 +0000
@@ -0,0 +1,42 @@
+#include "mysql/psi.h"
+struct PSI_bootstrap
+{
+  void* (*get_PSI)(int version);
+};
+struct PSI_mutex;
+struct PSI_rwlock;
+struct PSI_cond;
+struct PSI_thread;
+struct PSI_locker;
+typedef int PSI_mutex_key;
+typedef int PSI_rwlock_key;
+typedef int PSI_cond_key;
+struct PSI_v1
+{
+  PSI_mutex_key (*register_mutex)(const char* name, int global);
+  PSI_rwlock_key (*register_rwlock)(const char* name, int global);
+  PSI_cond_key (*register_cond)(const char* name, int global);
+  struct PSI_mutex* (*init_mutex)(PSI_mutex_key key, void *identity);
+  void (*destroy_mutex)(struct PSI_mutex* mutex, void *identity);
+  struct PSI_rwlock* (*init_rwlock)(PSI_rwlock_key key, void *identity);
+  void (*destroy_rwlock)(struct PSI_rwlock* rwlock, void *identity);
+  struct PSI_cond* (*init_cond)(PSI_cond_key key, void *identity);
+  void (*destroy_cond)(struct PSI_cond* cond, void *identity);
+  struct PSI_thread* (*new_thread)();
+  struct PSI_thread* (*get_thread)();
+  void (*delete_thread)(struct PSI_thread *thread);
+  struct PSI_locker* (*get_locker)(struct PSI_thread *thread);
+  void (*unlock_mutex)(struct PSI_thread *thread, struct PSI_mutex* mutex);
+  void (*unlock_rwlock)(struct PSI_thread *thread, struct PSI_rwlock* rwlock);
+  void (*signal_cond)(struct PSI_thread *thread, struct PSI_cond* cond);
+  void (*broadcast_cond)(struct PSI_thread *thread, struct PSI_cond* cond);
+  void (*start_wait)(struct PSI_locker* locker, struct PSI_mutex* mutex, int must);
+  void (*end_wait)(struct PSI_locker* locker, struct PSI_mutex* mutex, int must, int rc);
+  void (*start_rdwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must);
+  void (*end_rdwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must, int rc);
+  void (*start_wrwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must);
+  void (*end_wrwait)(struct PSI_locker* locker, struct PSI_rwlock *rwlock, int must, int rc);
+  void (*start_condwait)(struct PSI_locker* locker, struct PSI_cond* cond, int must);
+  void (*end_condwait)(struct PSI_locker* locker, struct PSI_cond* cond, int must, int rc);
+};
+typedef struct PSI_v1 PSI;

=== added file 'include/mysql/psi_abi_v2.h'
--- a/include/mysql/psi_abi_v2.h	1970-01-01 00:00:00 +0000
+++ b/include/mysql/psi_abi_v2.h	2008-10-10 20:34:55 +0000
@@ -0,0 +1,4 @@
+
+#define USE_PSI_2
+#include "mysql/psi.h"
+

=== added file 'include/mysql/psi_abi_v2.h.pp'
--- a/include/mysql/psi_abi_v2.h.pp	1970-01-01 00:00:00 +0000
+++ b/include/mysql/psi_abi_v2.h.pp	2008-10-10 20:34:55 +0000
@@ -0,0 +1,18 @@
+#include "mysql/psi.h"
+struct PSI_bootstrap
+{
+  void* (*get_PSI)(int version);
+};
+struct PSI_mutex;
+struct PSI_rwlock;
+struct PSI_cond;
+struct PSI_thread;
+struct PSI_locker;
+typedef int PSI_mutex_key;
+typedef int PSI_rwlock_key;
+typedef int PSI_cond_key;
+struct PSI_v2
+{
+  int later;
+};
+typedef struct PSI_v2 PSI;

=== modified file 'include/thr_lock.h'
--- a/include/thr_lock.h	2008-06-28 11:00:59 +0000
+++ b/include/thr_lock.h	2008-10-10 20:34:55 +0000
@@ -115,7 +115,7 @@ struct st_lock_list {
 
 typedef struct st_thr_lock {
   LIST list;
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   struct st_lock_list read_wait;
   struct st_lock_list read;
   struct st_lock_list write_wait;
@@ -133,7 +133,7 @@ typedef struct st_thr_lock {
 
 
 extern LIST *thr_lock_thread_list;
-extern pthread_mutex_t THR_LOCK_lock;
+extern mysql_mutex_t THR_LOCK_lock;
 
 my_bool init_thr_lock(void);		/* Must be called once/thread */
 #define thr_lock_owner_init(owner, info_arg) (owner)->info= (info_arg)

=== modified file 'include/wqueue.h'
--- a/include/wqueue.h	2008-02-22 20:32:34 +0000
+++ b/include/wqueue.h	2008-10-10 20:34:55 +0000
@@ -18,7 +18,7 @@ void wqueue_unlink_from_queue(WQUEUE *wq
 void wqueue_add_to_queue(WQUEUE *wqueue, struct st_my_thread_var *thread);
 void wqueue_add_and_wait(WQUEUE *wqueue,
                          struct st_my_thread_var *thread,
-                         pthread_mutex_t *lock);
+                         mysql_mutex_t *lock);
 void wqueue_release_queue(WQUEUE *wqueue);
 void wqueue_release_one_locktype_from_queue(WQUEUE *wqueue);
 

=== modified file 'mysys/charset.c'
--- a/mysys/charset.c	2008-07-24 11:33:35 +0000
+++ b/mysys/charset.c	2008-10-10 20:34:55 +0000
@@ -444,7 +444,7 @@ static my_bool init_available_charsets(m
       To make things thread safe we are not allowing other threads to interfere
       while we may changing the cs_info_table
     */
-    pthread_mutex_lock(&THR_LOCK_charset);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_charset);
     if (!charset_initialized)
     {
       bzero(&all_charsets,sizeof(all_charsets));
@@ -467,7 +467,7 @@ static my_bool init_available_charsets(m
       error= my_read_charset_file(fname,myflags);
       charset_initialized=1;
     }
-    pthread_mutex_unlock(&THR_LOCK_charset);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_charset);
   }
   return error;
 }
@@ -524,7 +524,7 @@ static CHARSET_INFO *get_internal_charse
     To make things thread safe we are not allowing other threads to interfere
     while we may changing the cs_info_table
   */
-  pthread_mutex_lock(&THR_LOCK_charset);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_charset);
   if ((cs= all_charsets[cs_number]))
   {
     if (!(cs->state & MY_CS_COMPILED) && !(cs->state & MY_CS_LOADED))
@@ -542,7 +542,7 @@ static CHARSET_INFO *get_internal_charse
     else
       cs->state|= MY_CS_READY;
   }
-  pthread_mutex_unlock(&THR_LOCK_charset);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_charset);
   return cs;
 }
 

=== modified file 'mysys/mf_iocache.c'
--- a/mysys/mf_iocache.c	2008-07-09 07:12:43 +0000
+++ b/mysys/mf_iocache.c	2008-10-10 20:34:55 +0000
@@ -58,9 +58,9 @@ static void my_aiowait(my_aio_result *re
 
 #ifdef THREAD
 #define lock_append_buffer(info) \
- pthread_mutex_lock(&(info)->append_buffer_lock)
+ MYSQL_MUTEX_LOCK(&(info)->append_buffer_lock)
 #define unlock_append_buffer(info) \
- pthread_mutex_unlock(&(info)->append_buffer_lock)
+ MYSQL_MUTEX_UNLOCK(&(info)->append_buffer_lock)
 #else
 #define lock_append_buffer(info)
 #define unlock_append_buffer(info)
@@ -691,7 +691,7 @@ void remove_io_thread(IO_CACHE *cache)
   if (cache == cshare->source_cache)
     flush_io_cache(cache);
 
-  pthread_mutex_lock(&cshare->mutex);
+  MYSQL_MUTEX_LOCK(&cshare->mutex);
   DBUG_PRINT("io_cache_share", ("%s: %p",
                                 (cache == cshare->source_cache) ?
                                 "writer" : "reader", cache));
@@ -714,18 +714,18 @@ void remove_io_thread(IO_CACHE *cache)
   if (!--cshare->running_threads)
   {
     DBUG_PRINT("io_cache_share", ("the last running thread leaves, wake all"));
-    pthread_cond_signal(&cshare->cond_writer);
-    pthread_cond_broadcast(&cshare->cond);
+    MYSQL_COND_SIGNAL(&cshare->cond_writer);
+    MYSQL_COND_BROADCAST(&cshare->cond);
   }
 
-  pthread_mutex_unlock(&cshare->mutex);
+  MYSQL_MUTEX_UNLOCK(&cshare->mutex);
 
   if (!total)
   {
     DBUG_PRINT("io_cache_share", ("last thread removed, destroy share"));
-    pthread_cond_destroy (&cshare->cond_writer);
-    pthread_cond_destroy (&cshare->cond);
-    pthread_mutex_destroy(&cshare->mutex);
+    MYSQL_COND_DESTROY (&cshare->cond_writer);
+    MYSQL_COND_DESTROY (&cshare->cond);
+    MYSQL_MUTEX_DESTROY(&cshare->mutex);
   }
 
   DBUG_VOID_RETURN;
@@ -766,7 +766,7 @@ static int lock_io_cache(IO_CACHE *cache
   DBUG_ENTER("lock_io_cache");
 
   /* Enter the lock. */
-  pthread_mutex_lock(&cshare->mutex);
+  MYSQL_MUTEX_LOCK(&cshare->mutex);
   cshare->running_threads--;
   DBUG_PRINT("io_cache_share", ("%s: %p  pos: %lu  running: %u",
                                 (cache == cshare->source_cache) ?
@@ -783,7 +783,7 @@ static int lock_io_cache(IO_CACHE *cache
       while (cshare->running_threads)
       {
         DBUG_PRINT("io_cache_share", ("writer waits in lock"));
-        pthread_cond_wait(&cshare->cond_writer, &cshare->mutex);
+        MYSQL_COND_WAIT(&cshare->cond_writer, &cshare->mutex);
       }
       DBUG_PRINT("io_cache_share", ("writer awoke, going to copy"));
 
@@ -795,7 +795,7 @@ static int lock_io_cache(IO_CACHE *cache
     if (!cshare->running_threads)
     {
       DBUG_PRINT("io_cache_share", ("waking writer"));
-      pthread_cond_signal(&cshare->cond_writer);
+      MYSQL_COND_SIGNAL(&cshare->cond_writer);
     }
 
     /*
@@ -807,7 +807,7 @@ static int lock_io_cache(IO_CACHE *cache
            cshare->source_cache)
     {
       DBUG_PRINT("io_cache_share", ("reader waits in lock"));
-      pthread_cond_wait(&cshare->cond, &cshare->mutex);
+      MYSQL_COND_WAIT(&cshare->cond, &cshare->mutex);
     }
 
     /*
@@ -849,7 +849,7 @@ static int lock_io_cache(IO_CACHE *cache
            cshare->running_threads)
     {
       DBUG_PRINT("io_cache_share", ("reader waits in lock"));
-      pthread_cond_wait(&cshare->cond, &cshare->mutex);
+      MYSQL_COND_WAIT(&cshare->cond, &cshare->mutex);
     }
 
     /* If the block is not yet read, continue with a locked cache and read. */
@@ -871,7 +871,7 @@ static int lock_io_cache(IO_CACHE *cache
     Leave the lock. Do not call unlock_io_cache() later. The thread that
     filled the buffer did this and marked all threads as running.
   */
-  pthread_mutex_unlock(&cshare->mutex);
+  MYSQL_MUTEX_UNLOCK(&cshare->mutex);
   DBUG_RETURN(0);
 }
 
@@ -914,8 +914,8 @@ static void unlock_io_cache(IO_CACHE *ca
                                 cshare->total_threads));
 
   cshare->running_threads= cshare->total_threads;
-  pthread_cond_broadcast(&cshare->cond);
-  pthread_mutex_unlock(&cshare->mutex);
+  MYSQL_COND_BROADCAST(&cshare->cond);
+  MYSQL_MUTEX_UNLOCK(&cshare->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -1865,7 +1865,7 @@ int end_io_cache(IO_CACHE *info)
     /* Destroy allocated mutex */
     info->type= TYPE_NOT_SET;
 #ifdef THREAD
-    pthread_mutex_destroy(&info->append_buffer_lock);
+    MYSQL_MUTEX_DESTROY(&info->append_buffer_lock);
 #endif
   }
 #ifdef THREAD

=== modified file 'mysys/mf_iocache2.c'
--- a/mysys/mf_iocache2.c	2008-05-29 15:44:11 +0000
+++ b/mysys/mf_iocache2.c	2008-10-10 20:34:55 +0000
@@ -82,7 +82,7 @@ my_off_t my_b_append_tell(IO_CACHE* info
     answer to the question.
   */
 #ifdef THREAD
-  pthread_mutex_lock(&info->append_buffer_lock);
+  MYSQL_MUTEX_LOCK(&info->append_buffer_lock);
 #endif
 #ifndef DBUG_OFF
   /*
@@ -104,7 +104,7 @@ my_off_t my_b_append_tell(IO_CACHE* info
 #endif  
   res = info->end_of_file + (info->write_pos-info->append_read_pos);
 #ifdef THREAD
-  pthread_mutex_unlock(&info->append_buffer_lock);
+  MYSQL_MUTEX_UNLOCK(&info->append_buffer_lock);
 #endif
   return res;
 }

=== modified file 'mysys/mf_keycache.c'
--- a/mysys/mf_keycache.c	2008-08-20 10:29:58 +0000
+++ b/mysys/mf_keycache.c	2008-10-10 20:34:55 +0000
@@ -59,13 +59,13 @@
   time only.
 
   Before starting to wait on its condition variable with
-  pthread_cond_wait(), the thread enters itself to a specific wait queue
+  MYSQL_COND_WAIT(), the thread enters itself to a specific wait queue
   with link_into_queue() (double linked with '*next' + '**prev') or
   wait_on_queue() (single linked with '*next').
 
   Another thread, when releasing a resource, looks up the waiting thread
   in the related wait queue. It sends a signal with
-  pthread_cond_signal() to the waiting thread.
+  MYSQL_COND_SIGNAL() to the waiting thread.
 
   NOTE: Depending on the particular wait situation, either the sending
   thread removes the waiting thread from the wait queue with
@@ -127,8 +127,8 @@
     accessing it;
     to set this number equal to <N> add
       #define MAX_THREADS <N>
-  - to substitute calls of pthread_cond_wait for calls of
-    pthread_cond_timedwait (wait with timeout set up);
+  - to substitute calls of MYSQL_COND_WAIT for calls of
+    MYSQL_COND_TIMEDWAIT (wait with timeout set up);
     this setting should be used only when you want to trap a deadlock
     situation, which theoretically should not happen;
     to set timeout equal to <T> seconds add
@@ -159,7 +159,7 @@
 #define  COND_FOR_SAVED     1
 #define  COND_FOR_READERS   2
 
-typedef pthread_cond_t KEYCACHE_CONDVAR;
+typedef mysql_cond_t KEYCACHE_CONDVAR;
 
 /* descriptor of the page in the key cache block buffer */
 struct st_keycache_page
@@ -227,7 +227,7 @@ KEY_CACHE *dflt_key_cache= &dflt_key_cac
 static int flush_all_key_blocks(KEY_CACHE *keycache);
 #ifdef THREAD
 static void wait_on_queue(KEYCACHE_WQUEUE *wqueue,
-                          pthread_mutex_t *mutex);
+                          mysql_mutex_t *mutex);
 static void release_whole_queue(KEYCACHE_WQUEUE *wqueue);
 #else
 #define wait_on_queue(wqueue, mutex)    do {} while (0)
@@ -314,20 +314,20 @@ static long keycache_thread_id;
   ((uint) (((char*)(h)-(char *) keycache->hash_link_root)/sizeof(HASH_LINK)))
 
 #if (defined(KEYCACHE_TIMEOUT) && !defined(__WIN__)) || defined(KEYCACHE_DEBUG)
-static int keycache_pthread_cond_wait(pthread_cond_t *cond,
-                                      pthread_mutex_t *mutex);
+static int keycache_MYSQL_COND_WAIT(mysql_cond_t *cond,
+                                      mysql_mutex_t *mutex);
 #else
-#define  keycache_pthread_cond_wait pthread_cond_wait
+#define  keycache_MYSQL_COND_WAIT MYSQL_COND_WAIT
 #endif
 
 #if defined(KEYCACHE_DEBUG)
-static int keycache_pthread_mutex_lock(pthread_mutex_t *mutex);
-static void keycache_pthread_mutex_unlock(pthread_mutex_t *mutex);
-static int keycache_pthread_cond_signal(pthread_cond_t *cond);
+static int keycache_MYSQL_MUTEX_LOCK(mysql_mutex_t *mutex);
+static void keycache_MYSQL_MUTEX_UNLOCK(mysql_mutex_t *mutex);
+static int keycache_MYSQL_COND_SIGNAL(mysql_cond_t *cond);
 #else
-#define keycache_pthread_mutex_lock pthread_mutex_lock
-#define keycache_pthread_mutex_unlock pthread_mutex_unlock
-#define keycache_pthread_cond_signal pthread_cond_signal
+#define keycache_MYSQL_MUTEX_LOCK MYSQL_MUTEX_LOCK
+#define keycache_MYSQL_MUTEX_UNLOCK MYSQL_MUTEX_UNLOCK
+#define keycache_MYSQL_COND_SIGNAL MYSQL_COND_SIGNAL
 #endif /* defined(KEYCACHE_DEBUG) */
 
 #if !defined(DBUG_OFF)
@@ -581,7 +581,7 @@ int resize_key_cache(KEY_CACHE *keycache
     DBUG_RETURN(keycache->disk_blocks);
   }
 
-  keycache_pthread_mutex_lock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
 
 #ifdef THREAD
   /*
@@ -664,7 +664,7 @@ finish:
   /* Signal waiting threads. */
   release_whole_queue(&keycache->resize_queue);
 
-  keycache_pthread_mutex_unlock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   DBUG_RETURN(blocks);
 }
 
@@ -711,14 +711,14 @@ void change_key_cache_param(KEY_CACHE *k
 {
   DBUG_ENTER("change_key_cache_param");
 
-  keycache_pthread_mutex_lock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
   if (division_limit)
     keycache->min_warm_blocks= (keycache->disk_blocks *
 				division_limit / 100 + 1);
   if (age_threshold)
     keycache->age_threshold=   (keycache->disk_blocks *
 				age_threshold / 100);
-  keycache_pthread_mutex_unlock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -767,7 +767,7 @@ void end_key_cache(KEY_CACHE *keycache, 
 
   if (cleanup)
   {
-    pthread_mutex_destroy(&keycache->cache_lock);
+    MYSQL_MUTEX_DESTROY(&keycache->cache_lock);
     keycache->key_cache_inited= keycache->can_be_used= 0;
     keycache->post_write= NULL;
     KEYCACHE_DEBUG_CLOSE;
@@ -907,7 +907,7 @@ static void unlink_from_queue(KEYCACHE_W
 */
 
 static void wait_on_queue(KEYCACHE_WQUEUE *wqueue,
-                          pthread_mutex_t *mutex)
+                          mysql_mutex_t *mutex)
 {
   struct st_my_thread_var *last;
   struct st_my_thread_var *thread= my_thread_var;
@@ -931,7 +931,7 @@ static void wait_on_queue(KEYCACHE_WQUEU
   do
   {
     KEYCACHE_DBUG_PRINT("wait", ("suspend thread %ld", thread->id));
-    keycache_pthread_cond_wait(&thread->suspend, mutex);
+    keycache_MYSQL_COND_WAIT(&thread->suspend, mutex);
   }
   while (thread->next);
 }
@@ -970,7 +970,7 @@ static void release_whole_queue(KEYCACHE
     KEYCACHE_DBUG_PRINT("release_whole_queue: signal",
                         ("thread %ld", thread->id));
     /* Signal the thread. */
-    keycache_pthread_cond_signal(&thread->suspend);
+    keycache_MYSQL_COND_SIGNAL(&thread->suspend);
     /* Take thread from queue. */
     next=thread->next;
     thread->next= NULL;
@@ -1175,7 +1175,7 @@ static void link_block(KEY_CACHE *keycac
       if ((HASH_LINK *) thread->opt_info == hash_link)
       {
         KEYCACHE_DBUG_PRINT("link_block: signal", ("thread %ld", thread->id));
-        keycache_pthread_cond_signal(&thread->suspend);
+        keycache_MYSQL_COND_SIGNAL(&thread->suspend);
         unlink_from_queue(&keycache->waiting_for_block, thread);
         block->requests++;
       }
@@ -1437,7 +1437,7 @@ static void remove_reader(BLOCK_LINK *bl
   DBUG_ASSERT(block->hash_link->requests);
 #ifdef THREAD
   if (! --block->hash_link->requests && block->condvar)
-    keycache_pthread_cond_signal(block->condvar);
+    keycache_MYSQL_COND_SIGNAL(block->condvar);
 #else
   --block->hash_link->requests;
 #endif
@@ -1472,7 +1472,7 @@ static void wait_for_readers(KEY_CACHE *
     /* There must be no other waiter. We have no queue here. */
     DBUG_ASSERT(!block->condvar);
     block->condvar= &thread->suspend;
-    keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock);
+    keycache_MYSQL_COND_WAIT(&thread->suspend, &keycache->cache_lock);
     block->condvar= NULL;
   }
 #else
@@ -1533,7 +1533,7 @@ static void unlink_hash(KEY_CACHE *keyca
       if (page->file == hash_link->file && page->filepos == hash_link->diskpos)
       {
         KEYCACHE_DBUG_PRINT("unlink_hash: signal", ("thread %ld", thread->id));
-        keycache_pthread_cond_signal(&thread->suspend);
+        keycache_MYSQL_COND_SIGNAL(&thread->suspend);
         unlink_from_queue(&keycache->waiting_for_hash_link, thread);
       }
     }
@@ -1621,7 +1621,7 @@ restart:
       link_into_queue(&keycache->waiting_for_hash_link, thread);
       KEYCACHE_DBUG_PRINT("get_hash_link: wait",
                         ("suspend thread %ld", thread->id));
-      keycache_pthread_cond_wait(&thread->suspend,
+      keycache_MYSQL_COND_WAIT(&thread->suspend,
                                  &keycache->cache_lock);
       thread->opt_info= NULL;
 #else
@@ -1790,7 +1790,7 @@ restart:
       {
         KEYCACHE_DBUG_PRINT("find_key_block: wait",
                             ("suspend thread %ld", thread->id));
-        keycache_pthread_cond_wait(&thread->suspend,
+        keycache_MYSQL_COND_WAIT(&thread->suspend,
                                    &keycache->cache_lock);
       } while (thread->next);
       thread->opt_info= NULL;
@@ -2136,7 +2136,7 @@ restart:
           {
             KEYCACHE_DBUG_PRINT("find_key_block: wait",
                                 ("suspend thread %ld", thread->id));
-            keycache_pthread_cond_wait(&thread->suspend,
+            keycache_MYSQL_COND_WAIT(&thread->suspend,
                                        &keycache->cache_lock);
           }
           while (thread->next);
@@ -2232,7 +2232,7 @@ restart:
                            BLOCK_CHANGED | BLOCK_IN_USE));
               DBUG_ASSERT(block->hash_link);
 
-              keycache_pthread_mutex_unlock(&keycache->cache_lock);
+              keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
               /*
                 The call is thread safe because only the current
                 thread might change the block->hash_link value
@@ -2245,7 +2245,7 @@ restart:
                                       MYF(MY_NABP | MY_WAIT_IF_FULL),
                                       keycache->post_write,
                                       block->post_write_arg);
-              keycache_pthread_mutex_lock(&keycache->cache_lock);
+              keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
 
               /* Block status must not have changed. */
               DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) ==
@@ -2462,14 +2462,14 @@ static void read_block(KEY_CACHE *keycac
 
     keycache->global_cache_read++;
     /* Page is not in buffer yet, is to be read from disk */
-    keycache_pthread_mutex_unlock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
     /*
       Here other threads may step in and register as secondary readers.
       They will register in block->wqueue[COND_FOR_REQUESTED].
     */
     got_length= my_pread(block->hash_link->file, block->buffer,
                          read_length, block->hash_link->diskpos, MYF(0));
-    keycache_pthread_mutex_lock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
     /*
       The block can now have been marked for free (in case of
       FLUSH_RELEASE). Otherwise the state must be unchanged.
@@ -2576,7 +2576,7 @@ uchar *key_cache_read(KEY_CACHE *keycach
       disabled cache. We always increment and decrement
       'cnt_for_resize_op' so that a resizer can wait for pending I/O.
     */
-    keycache_pthread_mutex_lock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
     /*
       Cache resizing has two phases: Flushing and re-initializing. In
       the flush phase read requests are allowed to bypass the cache for
@@ -2628,10 +2628,10 @@ uchar *key_cache_read(KEY_CACHE *keycach
           Read directly from file.
         */
         keycache->global_cache_read++;
-        keycache_pthread_mutex_unlock(&keycache->cache_lock);
+        keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
         error= (my_pread(file, (uchar*) buff, read_length,
                          filepos + offset, MYF(MY_NABP)) != 0);
-        keycache_pthread_mutex_lock(&keycache->cache_lock);
+        keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
         goto next_block;
       }
       if (!(block->status & BLOCK_ERROR))
@@ -2673,7 +2673,7 @@ uchar *key_cache_read(KEY_CACHE *keycach
         {
           DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-          keycache_pthread_mutex_unlock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
 #endif
 
           /* Copy data from the cache buffer */
@@ -2683,7 +2683,7 @@ uchar *key_cache_read(KEY_CACHE *keycach
             memcpy(buff, block->buffer+offset, (size_t) read_length);
 
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-          keycache_pthread_mutex_lock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
           DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 #endif
         }
@@ -2724,17 +2724,17 @@ no_key_cache:
   keycache->global_cache_read++;
 
   if (locked_and_incremented)
-    keycache_pthread_mutex_unlock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
     error= 1;
   if (locked_and_incremented)
-    keycache_pthread_mutex_lock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
 
 end:
   if (locked_and_incremented)
   {
     dec_counter_for_resize_op(keycache);
-    keycache_pthread_mutex_unlock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   }
   DBUG_RETURN(error ? (uchar*) 0 : start);
 }
@@ -2784,7 +2784,7 @@ int key_cache_insert(KEY_CACHE *keycache
       disabled cache. We always increment and decrement
       'cnt_for_resize_op' so that a resizer can wait for pending I/O.
     */
-    keycache_pthread_mutex_lock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
     /*
       We do not load index data into a disabled cache nor into an
       ongoing resize.
@@ -2880,7 +2880,7 @@ int key_cache_insert(KEY_CACHE *keycache
                       (block->status & BLOCK_READ));
 
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-          keycache_pthread_mutex_unlock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
           /*
             Here other threads may step in and register as secondary readers.
             They will register in block->wqueue[COND_FOR_REQUESTED].
@@ -2894,7 +2894,7 @@ int key_cache_insert(KEY_CACHE *keycache
             memcpy(block->buffer+offset, buff, (size_t) read_length);
 
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-          keycache_pthread_mutex_lock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
           DBUG_ASSERT(block->status & BLOCK_IN_USE);
           DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
                       (block->status & BLOCK_READ));
@@ -2967,7 +2967,7 @@ int key_cache_insert(KEY_CACHE *keycache
   no_key_cache:
     if (locked_and_incremented)
       dec_counter_for_resize_op(keycache);
-    keycache_pthread_mutex_unlock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   }
   DBUG_RETURN(error);
 }
@@ -3053,7 +3053,7 @@ int key_cache_write(KEY_CACHE *keycache,
       disabled cache. We always increment and decrement
       'cnt_for_resize_op' so that a resizer can wait for pending I/O.
     */
-    keycache_pthread_mutex_lock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
     /*
       Cache resizing has two phases: Flushing and re-initializing. In
       the flush phase write requests can modify dirty blocks that are
@@ -3103,13 +3103,13 @@ int key_cache_write(KEY_CACHE *keycache,
         {
           /* Used in the server. */
           keycache->global_cache_write++;
-          keycache_pthread_mutex_unlock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
           if (key_cache_pwrite(file, (uchar*) buff, read_length,
                                filepos + offset,
                                MYF(MY_NABP | MY_WAIT_IF_FULL),
                                keycache->post_write, post_write_arg))
             error=1;
-          keycache_pthread_mutex_lock(&keycache->cache_lock);
+          keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
         }
         goto next_block;
       }
@@ -3201,7 +3201,7 @@ int key_cache_write(KEY_CACHE *keycache,
       {
         block->post_write_arg= post_write_arg;
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-        keycache_pthread_mutex_unlock(&keycache->cache_lock);
+        keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
 #endif
         if (!(read_length & 511))
 	  bmove512(block->buffer+offset, buff, read_length);
@@ -3209,7 +3209,7 @@ int key_cache_write(KEY_CACHE *keycache,
           memcpy(block->buffer+offset, buff, (size_t) read_length);
 
 #if !defined(SERIALIZED_READ_FROM_CACHE)
-        keycache_pthread_mutex_lock(&keycache->cache_lock);
+        keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
 #endif
       }
 
@@ -3274,20 +3274,20 @@ no_key_cache:
     keycache->global_cache_w_requests++;
     keycache->global_cache_write++;
     if (locked_and_incremented)
-      keycache_pthread_mutex_unlock(&keycache->cache_lock);
+      keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
     if (key_cache_pwrite(file, (uchar*) buff, length, filepos,
                          MYF(MY_NABP | MY_WAIT_IF_FULL),
                          keycache->post_write, post_write_arg))
       error=1;
     if (locked_and_incremented)
-      keycache_pthread_mutex_lock(&keycache->cache_lock);
+      keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
   }
 
 end:
   if (locked_and_incremented)
   {
     dec_counter_for_resize_op(keycache);
-    keycache_pthread_mutex_unlock(&keycache->cache_lock);
+    keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   }
 #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
   DBUG_EXECUTE("exec",
@@ -3469,14 +3469,14 @@ static int flush_cached_blocks(KEY_CACHE
   uint count= (uint) (end-cache);
 
   /* Don't lock the cache during the flush */
-  keycache_pthread_mutex_unlock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   /*
      As all blocks referred in 'cache' are marked by BLOCK_IN_FLUSH
      we are guarunteed no thread will change them
   */
   my_qsort((uchar*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link);
 
-  keycache_pthread_mutex_lock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
   /*
     Note: Do not break the loop. We have registered a request on every
     block in 'cache'. These must be unregistered by free_block() or
@@ -3502,14 +3502,14 @@ static int flush_cached_blocks(KEY_CACHE
       DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) ==
                   (BLOCK_READ | BLOCK_IN_FLUSH | BLOCK_CHANGED | BLOCK_IN_USE));
       block->status|= BLOCK_IN_FLUSHWRITE;
-      keycache_pthread_mutex_unlock(&keycache->cache_lock);
+      keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
       error= key_cache_pwrite(file,
                               block->buffer+block->offset,
                               block->length - block->offset,
                               block->hash_link->diskpos+ block->offset,
                               MYF(MY_NABP | MY_WAIT_IF_FULL),
                               keycache->post_write, block->post_write_arg);
-      keycache_pthread_mutex_lock(&keycache->cache_lock);
+      keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
       keycache->global_cache_write++;
       if (error)
       {
@@ -4051,7 +4051,7 @@ int flush_key_blocks(KEY_CACHE *keycache
   if (!keycache->key_cache_inited)
     DBUG_RETURN(0);
 
-  keycache_pthread_mutex_lock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_LOCK(&keycache->cache_lock);
   /* While waiting for lock, keycache could have been ended. */
   if (keycache->disk_blocks > 0)
   {
@@ -4059,7 +4059,7 @@ int flush_key_blocks(KEY_CACHE *keycache
     res= flush_key_blocks_int(keycache, file, type);
     dec_counter_for_resize_op(keycache);
   }
-  keycache_pthread_mutex_unlock(&keycache->cache_lock);
+  keycache_MYSQL_MUTEX_UNLOCK(&keycache->cache_lock);
   DBUG_RETURN(res);
 }
 
@@ -4106,7 +4106,7 @@ static int flush_all_key_blocks(KEY_CACH
 
   do
   {
-    safe_mutex_assert_owner(&keycache->cache_lock);
+    MYSQL_MUTEX_ASSERT_OWNER(&keycache->cache_lock);
     total_found= 0;
 
     /*
@@ -4347,8 +4347,8 @@ static void keycache_dump(KEY_CACHE *key
 #if defined(KEYCACHE_TIMEOUT) && !defined(__WIN__)
 
 
-static int keycache_pthread_cond_wait(pthread_cond_t *cond,
-                                      pthread_mutex_t *mutex)
+static int keycache_MYSQL_COND_WAIT(mysql_cond_t *cond,
+                                      mysql_mutex_t *mutex)
 {
   int rc;
   struct timeval  now;            /* time when we started waiting        */
@@ -4375,7 +4375,7 @@ static int keycache_pthread_cond_wait(pt
     fprintf(keycache_debug_log, "waiting...\n");
     fflush(keycache_debug_log);
 #endif
-  rc= pthread_cond_timedwait(cond, mutex, &timeout);
+  rc= MYSQL_COND_TIMEDWAIT(cond, mutex, &timeout);
   KEYCACHE_THREAD_TRACE_BEGIN("finished waiting");
   if (rc == ETIMEDOUT || rc == ETIME)
   {
@@ -4396,12 +4396,12 @@ static int keycache_pthread_cond_wait(pt
 }
 #else
 #if defined(KEYCACHE_DEBUG)
-static int keycache_pthread_cond_wait(pthread_cond_t *cond,
-                                      pthread_mutex_t *mutex)
+static int keycache_MYSQL_COND_WAIT(mysql_cond_t *cond,
+                                      mysql_mutex_t *mutex)
 {
   int rc;
   KEYCACHE_THREAD_TRACE_END("started waiting");
-  rc= pthread_cond_wait(cond, mutex);
+  rc= MYSQL_COND_WAIT(cond, mutex);
   KEYCACHE_THREAD_TRACE_BEGIN("finished waiting");
   return rc;
 }
@@ -4411,27 +4411,27 @@ static int keycache_pthread_cond_wait(pt
 #if defined(KEYCACHE_DEBUG)
 
 
-static int keycache_pthread_mutex_lock(pthread_mutex_t *mutex)
+static int keycache_MYSQL_MUTEX_LOCK(mysql_mutex_t *mutex)
 {
   int rc;
-  rc= pthread_mutex_lock(mutex);
+  rc= MYSQL_MUTEX_LOCK(mutex);
   KEYCACHE_THREAD_TRACE_BEGIN("");
   return rc;
 }
 
 
-static void keycache_pthread_mutex_unlock(pthread_mutex_t *mutex)
+static void keycache_MYSQL_MUTEX_UNLOCK(mysql_mutex_t *mutex)
 {
   KEYCACHE_THREAD_TRACE_END("");
-  pthread_mutex_unlock(mutex);
+  MYSQL_MUTEX_UNLOCK(mutex);
 }
 
 
-static int keycache_pthread_cond_signal(pthread_cond_t *cond)
+static int keycache_MYSQL_COND_SIGNAL(mysql_cond_t *cond)
 {
   int rc;
   KEYCACHE_THREAD_TRACE("signal");
-  rc= pthread_cond_signal(cond);
+  rc= MYSQL_COND_SIGNAL(cond);
   return rc;
 }
 

=== modified file 'mysys/mf_tempdir.c'
--- a/mysys/mf_tempdir.c	2007-05-10 09:59:39 +0000
+++ b/mysys/mf_tempdir.c	2008-10-10 20:34:55 +0000
@@ -65,7 +65,7 @@ my_bool init_tmpdir(MY_TMPDIR *tmpdir, c
 
 err:
   delete_dynamic(&tmpdir->full_list);           /* Safe to free */
-  pthread_mutex_destroy(&tmpdir->mutex);
+  MYSQL_MUTEX_DESTROY(&tmpdir->mutex);
   DBUG_RETURN(TRUE);
 }
 
@@ -75,10 +75,10 @@ char *my_tmpdir(MY_TMPDIR *tmpdir)
   char *dir;
   if (!tmpdir->max)
     return tmpdir->list[0];
-  pthread_mutex_lock(&tmpdir->mutex);
+  MYSQL_MUTEX_LOCK(&tmpdir->mutex);
   dir=tmpdir->list[tmpdir->cur];
   tmpdir->cur= (tmpdir->cur == tmpdir->max) ? 0 : tmpdir->cur+1;
-  pthread_mutex_unlock(&tmpdir->mutex);
+  MYSQL_MUTEX_UNLOCK(&tmpdir->mutex);
   return dir;
 }
 
@@ -88,6 +88,6 @@ void free_tmpdir(MY_TMPDIR *tmpdir)
   for (i=0; i<=tmpdir->max; i++)
     my_free(tmpdir->list[i], MYF(0));
   delete_dynamic(&tmpdir->full_list);
-  pthread_mutex_destroy(&tmpdir->mutex);
+  MYSQL_MUTEX_DESTROY(&tmpdir->mutex);
 }
 

=== modified file 'mysys/my_bitmap.c'
--- a/mysys/my_bitmap.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_bitmap.c	2008-10-10 20:34:55 +0000
@@ -87,7 +87,7 @@ static inline void bitmap_lock(MY_BITMAP
 {
 #ifdef THREAD
   if (map->mutex)
-    pthread_mutex_lock(map->mutex);
+    MYSQL_MUTEX_LOCK(map->mutex);
 #endif
 }
 
@@ -95,7 +95,7 @@ static inline void bitmap_unlock(MY_BITM
 {
 #ifdef THREAD
   if (map->mutex)
-    pthread_mutex_unlock(map->mutex);
+    MYSQL_MUTEX_UNLOCK(map->mutex);
 #endif
 }
 
@@ -112,7 +112,7 @@ my_bool bitmap_init(MY_BITMAP *map, my_b
     if (thread_safe)
     {
       size_in_bytes= ALIGN_SIZE(size_in_bytes);
-      extra= sizeof(pthread_mutex_t);
+      extra= sizeof(mysql_mutex_t);
     }
     map->mutex= 0;
 #endif
@@ -121,7 +121,7 @@ my_bool bitmap_init(MY_BITMAP *map, my_b
 #ifdef THREAD
     if (thread_safe)
     {
-      map->mutex= (pthread_mutex_t *) ((char*) buf + size_in_bytes);
+      map->mutex= (mysql_mutex_t *) ((char*) buf + size_in_bytes);
       pthread_mutex_init(map->mutex, MY_MUTEX_INIT_FAST);
     }
 #endif
@@ -148,7 +148,7 @@ void bitmap_free(MY_BITMAP *map)
   {
 #ifdef THREAD
     if (map->mutex)
-      pthread_mutex_destroy(map->mutex);
+      MYSQL_MUTEX_DESTROY(map->mutex);
 #endif
     my_free((char*) map->bitmap, MYF(0));
     map->bitmap=0;

=== modified file 'mysys/my_fopen.c'
--- a/mysys/my_fopen.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_fopen.c	2008-10-10 20:34:55 +0000
@@ -71,18 +71,18 @@ FILE *my_fopen(const char *filename, int
       thread_safe_increment(my_stream_opened,&THR_LOCK_open);
       DBUG_RETURN(fd);				/* safeguard */
     }
-    pthread_mutex_lock(&THR_LOCK_open);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_open);
     if ((my_file_info[fileno(fd)].name = (char*)
 	 my_strdup(filename,MyFlags)))
     {
       my_stream_opened++;
       my_file_total_opened++;
       my_file_info[fileno(fd)].type = STREAM_BY_FOPEN;
-      pthread_mutex_unlock(&THR_LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
       DBUG_PRINT("exit",("stream: %p", fd));
       DBUG_RETURN(fd);
     }
-    pthread_mutex_unlock(&THR_LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
     (void) my_fclose(fd,MyFlags);
     my_errno=ENOMEM;
   }
@@ -105,7 +105,7 @@ int my_fclose(FILE *fd, myf MyFlags)
   DBUG_ENTER("my_fclose");
   DBUG_PRINT("my",("stream: %p  MyFlags: %d", fd, MyFlags));
 
-  pthread_mutex_lock(&THR_LOCK_open);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_open);
   file=fileno(fd);
   if ((err = fclose(fd)) < 0)
   {
@@ -121,7 +121,7 @@ int my_fclose(FILE *fd, myf MyFlags)
     my_file_info[file].type = UNOPEN;
     my_free(my_file_info[file].name, MYF(MY_ALLOW_ZERO_PTR));
   }
-  pthread_mutex_unlock(&THR_LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
   DBUG_RETURN(err);
 } /* my_fclose */
 
@@ -146,7 +146,7 @@ FILE *my_fdopen(File Filedes, const char
   }
   else
   {
-    pthread_mutex_lock(&THR_LOCK_open);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_open);
     my_stream_opened++;
     if ((uint) Filedes < (uint) my_file_limit)
     {
@@ -160,7 +160,7 @@ FILE *my_fdopen(File Filedes, const char
       }
       my_file_info[Filedes].type = STREAM_BY_FDOPEN;
     }
-    pthread_mutex_unlock(&THR_LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
   }
 
   DBUG_PRINT("exit",("stream: %p", fd));

=== modified file 'mysys/my_gethostbyname.c'
--- a/mysys/my_gethostbyname.c	2006-12-31 00:32:21 +0000
+++ b/mysys/my_gethostbyname.c	2008-10-10 20:34:55 +0000
@@ -79,7 +79,7 @@ struct hostent *my_gethostbyname_r(const
 #else /* !HAVE_GETHOSTBYNAME_R */
 
 #ifdef THREAD
-extern pthread_mutex_t LOCK_gethostbyname_r;
+extern mysql_mutex_t LOCK_gethostbyname_r;
 #endif
 
 /*
@@ -96,7 +96,7 @@ struct hostent *my_gethostbyname_r(const
 				   int buflen, int *h_errnop)
 {
   struct hostent *hp;
-  pthread_mutex_lock(&LOCK_gethostbyname_r);
+  MYSQL_MUTEX_LOCK(&LOCK_gethostbyname_r);
   hp= gethostbyname(name);
   *h_errnop= h_errno;
   return hp;
@@ -104,7 +104,7 @@ struct hostent *my_gethostbyname_r(const
 
 void my_gethostbyname_r_free()
 {
-  pthread_mutex_unlock(&LOCK_gethostbyname_r);  
+  MYSQL_MUTEX_UNLOCK(&LOCK_gethostbyname_r);  
 }
 
 #endif /* !HAVE_GETHOSTBYNAME_R */

=== modified file 'mysys/my_getsystime.c'
--- a/mysys/my_getsystime.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_getsystime.c	2008-10-10 20:34:55 +0000
@@ -168,7 +168,7 @@ ulonglong my_micro_time_and_time(time_t 
   static time_t cur_time= 0;
   hrtime_t cur_gethrtime;
 
-  pthread_mutex_lock(&THR_LOCK_time);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_time);
   cur_gethrtime= gethrtime();
   if ((cur_gethrtime - prev_gethrtime) > DELTA_FOR_SECONDS)
   {
@@ -176,7 +176,7 @@ ulonglong my_micro_time_and_time(time_t 
     prev_gethrtime= cur_gethrtime;
   }
   *time_arg= cur_time;
-  pthread_mutex_unlock(&THR_LOCK_time);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_time);
   return cur_gethrtime/1000;
 #else
   ulonglong newtime;

=== modified file 'mysys/my_lib.c'
--- a/mysys/my_lib.c	2008-04-09 01:07:00 +0000
+++ b/mysys/my_lib.c	2008-10-10 20:34:55 +0000
@@ -111,7 +111,7 @@ MY_DIR	*my_dir(const char *path, myf MyF
   DBUG_PRINT("my",("path: '%s' MyFlags: %d",path,MyFlags));
 
 #if defined(THREAD) && !defined(HAVE_READDIR_R)
-  pthread_mutex_lock(&THR_LOCK_open);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_open);
 #endif
 
   dirp = opendir(directory_file_name(tmp_path,(char *) path));
@@ -174,7 +174,7 @@ MY_DIR	*my_dir(const char *path, myf MyF
 
   (void) closedir(dirp);
 #if defined(THREAD) && !defined(HAVE_READDIR_R)
-  pthread_mutex_unlock(&THR_LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
 #endif
   result->dir_entry= (FILEINFO *)dir_entries_storage->buffer;
   result->number_off_files= dir_entries_storage->elements;
@@ -186,7 +186,7 @@ MY_DIR	*my_dir(const char *path, myf MyF
 
  error:
 #if defined(THREAD) && !defined(HAVE_READDIR_R)
-  pthread_mutex_unlock(&THR_LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
 #endif
   my_errno=errno;
   if (dirp)

=== modified file 'mysys/my_lockmem.c'
--- a/mysys/my_lockmem.c	2008-04-09 00:56:49 +0000
+++ b/mysys/my_lockmem.c	2008-10-10 20:34:55 +0000
@@ -66,9 +66,9 @@ uchar *my_malloc_lock(uint size,myf MyFl
     element->list.data=(uchar*) element;
     element->page=ptr;
     element->size=size;
-    pthread_mutex_lock(&THR_LOCK_malloc);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
     mem_list=list_add(mem_list,&element->list);
-    pthread_mutex_unlock(&THR_LOCK_malloc);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
   }
   DBUG_RETURN(ptr);
 }
@@ -79,7 +79,7 @@ void my_free_lock(uchar *ptr,myf Myflags
   LIST *list;
   struct st_mem_list *element=0;
 
-  pthread_mutex_lock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
   for (list=mem_list ; list ; list=list->next)
   {
     element=(struct st_mem_list*) list->data;
@@ -90,7 +90,7 @@ void my_free_lock(uchar *ptr,myf Myflags
       break;
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
   if (element)
     my_free((uchar*) element,MYF(0));
   free(ptr);					/* Free even if not locked */

=== modified file 'mysys/my_net.c'
--- a/mysys/my_net.c	2006-12-23 19:20:40 +0000
+++ b/mysys/my_net.c	2008-10-10 20:34:55 +0000
@@ -35,8 +35,8 @@
 void my_inet_ntoa(struct in_addr in, char *buf)
 {
   char *ptr;
-  pthread_mutex_lock(&THR_LOCK_net);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_net);
   ptr=inet_ntoa(in);
   strmov(buf,ptr);
-  pthread_mutex_unlock(&THR_LOCK_net);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_net);
 }

=== modified file 'mysys/my_open.c'
--- a/mysys/my_open.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_open.c	2008-10-10 20:34:55 +0000
@@ -93,7 +93,7 @@ int my_close(File fd, myf MyFlags)
   DBUG_ENTER("my_close");
   DBUG_PRINT("my",("fd: %d  MyFlags: %d",fd, MyFlags));
 
-  pthread_mutex_lock(&THR_LOCK_open);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_open);
   do
   {
     err= close(fd);
@@ -110,12 +110,12 @@ int my_close(File fd, myf MyFlags)
   {
     my_free(my_file_info[fd].name, MYF(0));
 #if defined(THREAD) && !defined(HAVE_PREAD) && !defined (__WIN__)
-    pthread_mutex_destroy(&my_file_info[fd].mutex);
+    MYSQL_MUTEX_DESTROY(&my_file_info[fd].mutex);
 #endif
     my_file_info[fd].type = UNOPEN;
   }
   my_file_opened--;
-  pthread_mutex_unlock(&THR_LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
   DBUG_RETURN(err);
 } /* my_close */
 
@@ -154,7 +154,7 @@ File my_register_filename(File fd, const
     }
     else
     {
-      pthread_mutex_lock(&THR_LOCK_open);
+      MYSQL_MUTEX_LOCK(&THR_LOCK_open);
       if ((my_file_info[fd].name = (char*) my_strdup(FileName,MyFlags)))
       {
         my_file_opened++;
@@ -163,11 +163,11 @@ File my_register_filename(File fd, const
 #if defined(THREAD) && !defined(HAVE_PREAD) && !defined(__WIN__)
         pthread_mutex_init(&my_file_info[fd].mutex,MY_MUTEX_INIT_FAST);
 #endif
-        pthread_mutex_unlock(&THR_LOCK_open);
+        MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
         DBUG_PRINT("exit",("fd: %d",fd));
         DBUG_RETURN(fd);
       }
-      pthread_mutex_unlock(&THR_LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_open);
       my_errno= ENOMEM;
     }
     (void) my_close(fd, MyFlags);

=== modified file 'mysys/my_pread.c'
--- a/mysys/my_pread.c	2008-08-25 18:23:18 +0000
+++ b/mysys/my_pread.c	2008-10-10 20:34:55 +0000
@@ -134,12 +134,12 @@ size_t my_pread(File Filedes, uchar *Buf
   {
     errno= 0;    /* Linux, Windows don't reset this on EOF/success */
 #if !defined (HAVE_PREAD) && !defined (__WIN__)
-    pthread_mutex_lock(&my_file_info[Filedes].mutex);
+    MYSQL_MUTEX_LOCK(&my_file_info[Filedes].mutex);
     readbytes= (uint) -1;
     error= (lseek(Filedes, offset, MY_SEEK_SET) == (my_off_t) -1 ||
 	    (readbytes= read(Filedes, Buffer, Count)) != Count);
     save_errno= errno;
-    pthread_mutex_unlock(&my_file_info[Filedes].mutex);
+    MYSQL_MUTEX_UNLOCK(&my_file_info[Filedes].mutex);
     if (error)
     {
       errno= save_errno;
@@ -221,10 +221,10 @@ size_t my_pwrite(int Filedes, const ucha
 #if !defined (HAVE_PREAD) && !defined (__WIN__)
     int error;
     writenbytes= (size_t) -1;
-    pthread_mutex_lock(&my_file_info[Filedes].mutex);
+    MYSQL_MUTEX_LOCK(&my_file_info[Filedes].mutex);
     error= (lseek(Filedes, offset, MY_SEEK_SET) != (my_off_t) -1 &&
             (writenbytes = write(Filedes, Buffer, Count)) == Count);
-    pthread_mutex_unlock(&my_file_info[Filedes].mutex);
+    MYSQL_MUTEX_UNLOCK(&my_file_info[Filedes].mutex);
     if (error)
       break;
 #else

=== modified file 'mysys/my_pthread.c'
--- a/mysys/my_pthread.c	2008-04-09 00:56:49 +0000
+++ b/mysys/my_pthread.c	2008-10-10 20:34:55 +0000
@@ -136,7 +136,7 @@ int my_sigwait(const sigset_t *set,int *
 
 #if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
 
-extern pthread_mutex_t LOCK_localtime_r;
+extern mysql_mutex_t LOCK_localtime_r;
 
 #endif
 
@@ -144,10 +144,10 @@ extern pthread_mutex_t LOCK_localtime_r;
 struct tm *localtime_r(const time_t *clock, struct tm *res)
 {
   struct tm *tmp;
-  pthread_mutex_lock(&LOCK_localtime_r);
+  MYSQL_MUTEX_LOCK(&LOCK_localtime_r);
   tmp=localtime(clock);
   *res= *tmp;
-  pthread_mutex_unlock(&LOCK_localtime_r);
+  MYSQL_MUTEX_UNLOCK(&LOCK_localtime_r);
   return res;
 }
 #endif
@@ -161,10 +161,10 @@ struct tm *localtime_r(const time_t *clo
 struct tm *gmtime_r(const time_t *clock, struct tm *res)
 {
   struct tm *tmp;
-  pthread_mutex_lock(&LOCK_localtime_r);
+  MYSQL_MUTEX_LOCK(&LOCK_localtime_r);
   tmp= gmtime(clock);
   *res= *tmp;
-  pthread_mutex_unlock(&LOCK_localtime_r);
+  MYSQL_MUTEX_UNLOCK(&LOCK_localtime_r);
   return res;
 }
 #endif
@@ -300,16 +300,16 @@ int sigwait(sigset_t *setp, int *sigp)
 
 static sigset_t pending_set;
 static bool inited=0;
-static pthread_cond_t  COND_sigwait;
-static pthread_mutex_t LOCK_sigwait;
+static mysql_cond_t  COND_sigwait;
+static mysql_mutex_t LOCK_sigwait;
 
 
 void sigwait_handle_sig(int sig)
 {
-  pthread_mutex_lock(&LOCK_sigwait);
+  MYSQL_MUTEX_LOCK(&LOCK_sigwait);
   sigaddset(&pending_set, sig);
-  pthread_cond_signal(&COND_sigwait); /* inform sigwait() about signal */
-  pthread_mutex_unlock(&LOCK_sigwait);
+  MYSQL_COND_SIGNAL(&COND_sigwait); /* inform sigwait() about signal */
+  MYSQL_MUTEX_UNLOCK(&LOCK_sigwait);
 }
 
 void *sigwait_thread(void *set_arg)
@@ -369,7 +369,7 @@ int sigwait(sigset_t *setp, int *sigp)
     pthread_attr_destroy(&thr_attr);
   }
 
-  pthread_mutex_lock(&LOCK_sigwait);
+  MYSQL_MUTEX_LOCK(&LOCK_sigwait);
   for (;;)
   {
     ulong *ptr= (ulong*) &pending_set;
@@ -388,11 +388,11 @@ int sigwait(sigset_t *setp, int *sigp)
 	}
 	*sigp=found;
 	sigdelset(&pending_set,found);
-	pthread_mutex_unlock(&LOCK_sigwait);
+	MYSQL_MUTEX_UNLOCK(&LOCK_sigwait);
 	return 0;
       }
     }
-    pthread_cond_wait(&COND_sigwait,&LOCK_sigwait);
+    MYSQL_COND_WAIT(&COND_sigwait,&LOCK_sigwait);
   }
   return 0;
 }
@@ -408,17 +408,17 @@ int sigwait(sigset_t *setp, int *sigp)
 
 /* Undefined wrappers set my_pthread.h so that we call os functions */
 #undef pthread_mutex_init
-#undef pthread_mutex_lock
-#undef pthread_mutex_unlock
-#undef pthread_mutex_destroy
+#undef MYSQL_MUTEX_LOCK
+#undef MYSQL_MUTEX_UNLOCK
+#undef MYSQL_MUTEX_DESTROY
 #undef pthread_mutex_wait
-#undef pthread_mutex_timedwait
-#undef pthread_mutex_trylock
-#undef pthread_mutex_t
+#undef mysql_mutex_timedwait
+#undef mysql_mutex_trylock
+#undef mysql_mutex_t
 #undef pthread_cond_init
-#undef pthread_cond_wait
-#undef pthread_cond_timedwait
-#undef pthread_cond_t
+#undef MYSQL_COND_WAIT
+#undef MYSQL_COND_TIMEDWAIT
+#undef mysql_cond_t
 #undef pthread_attr_getstacksize
 
 /*****************************************************************************
@@ -429,7 +429,7 @@ int sigwait(sigset_t *setp, int *sigp)
 
 #include <netdb.h>
 
-int my_pthread_mutex_init(pthread_mutex_t *mp, const pthread_mutexattr_t *attr)
+int my_pthread_mutex_init(mysql_mutex_t *mp, const pthread_mutexattr_t *attr)
 {
   int error;
   if (!attr)
@@ -439,7 +439,7 @@ int my_pthread_mutex_init(pthread_mutex_
   return error;
 }
 
-int my_pthread_cond_init(pthread_cond_t *mp, const pthread_condattr_t *attr)
+int my_pthread_cond_init(mysql_cond_t *mp, const pthread_condattr_t *attr)
 {
   int error;
   if (!attr)
@@ -464,10 +464,10 @@ int my_pthread_cond_init(pthread_cond_t 
 
 #if defined(HPUX10) || defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT)
 
-int my_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
+int my_MYSQL_COND_TIMEDWAIT(mysql_cond_t *cond, mysql_mutex_t *mutex,
 			      struct timespec *abstime)
 {
-  int error=pthread_cond_timedwait(cond, mutex, abstime);
+  int error=MYSQL_COND_TIMEDWAIT(cond, mutex, abstime);
   if (error == -1)			/* Safety if the lib is fixed */
   {
     if (!(error=errno))
@@ -492,8 +492,8 @@ void my_pthread_attr_getstacksize(pthrea
 #ifdef HAVE_POSIX1003_4a_MUTEX
 /*
   In HP-UX-10.20 and other old Posix 1003.4a Draft 4 implementations
-  pthread_mutex_trylock returns 1 on success, not 0 like
-  pthread_mutex_lock
+  mysql_mutex_trylock returns 1 on success, not 0 like
+  MYSQL_MUTEX_LOCK
 
   From the HP-UX-10.20 man page:
   RETURN VALUES
@@ -509,18 +509,18 @@ void my_pthread_attr_getstacksize(pthrea
 */
 
 /*
-  Convert pthread_mutex_trylock to return values according to latest POSIX
+  Convert mysql_mutex_trylock to return values according to latest POSIX
 
   RETURN VALUES
   0		If we are able successfully lock the mutex.
   EBUSY		Mutex was locked by another thread
-  #		Other error number returned by pthread_mutex_trylock()
+  #		Other error number returned by mysql_mutex_trylock()
 		(Not likely)  
 */
 
-int my_pthread_mutex_trylock(pthread_mutex_t *mutex)
+int my_mysql_mutex_trylock(mysql_mutex_t *mutex)
 {
-  int error= pthread_mutex_trylock(mutex);
+  int error= mysql_mutex_trylock(mutex);
   if (error == 1)
     return 0;				/* Got lock on mutex */
   if (error == 0)			/* Someon else is locking mutex */

=== modified file 'mysys/my_safehash.c'
--- a/mysys/my_safehash.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_safehash.c	2008-10-10 20:34:55 +0000
@@ -134,7 +134,7 @@ void safe_hash_free(SAFE_HASH *hash)
   if (hash->default_value)
   {
     hash_free(&hash->hash);
-    rwlock_destroy(&hash->mutex);
+    MYSQL_RWLOCK_DESTROY(&hash->mutex);
     hash->default_value=0;
   }
 }
@@ -159,9 +159,9 @@ uchar *safe_hash_search(SAFE_HASH *hash,
 {
   uchar *result;
   DBUG_ENTER("safe_hash_search");
-  rw_rdlock(&hash->mutex);
+  MYSQL_RWLOCK_RDLOCK(&hash->mutex);
   result= hash_search(&hash->hash, key, length);
-  rw_unlock(&hash->mutex);
+  MYSQL_RWLOCK_UNLOCK(&hash->mutex);
   if (!result)
     result= def;
   else
@@ -199,7 +199,7 @@ my_bool safe_hash_set(SAFE_HASH *hash, c
   DBUG_ENTER("safe_hash_set");
   DBUG_PRINT("enter",("key: %.*s  data: 0x%lx", length, key, (long) data));
 
-  rw_wrlock(&hash->mutex);
+  MYSQL_RWLOCK_WRLOCK(&hash->mutex);
   entry= (SAFE_HASH_ENTRY*) hash_search(&hash->hash, key, length);
 
   if (data == hash->default_value)
@@ -249,7 +249,7 @@ my_bool safe_hash_set(SAFE_HASH *hash, c
   }
 
 end:
-  rw_unlock(&hash->mutex);
+  MYSQL_RWLOCK_UNLOCK(&hash->mutex);
   DBUG_RETURN(error);
 }
 
@@ -274,7 +274,7 @@ void safe_hash_change(SAFE_HASH *hash, u
   SAFE_HASH_ENTRY *entry, *next;
   DBUG_ENTER("safe_hash_change");
 
-  rw_wrlock(&hash->mutex);
+  MYSQL_RWLOCK_WRLOCK(&hash->mutex);
 
   for (entry= hash->root ; entry ; entry= next)
   {
@@ -292,6 +292,6 @@ void safe_hash_change(SAFE_HASH *hash, u
     }
   }
 
-  rw_unlock(&hash->mutex);
+  MYSQL_RWLOCK_UNLOCK(&hash->mutex);
   DBUG_VOID_RETURN;
 }

=== modified file 'mysys/my_safehash.h'
--- a/mysys/my_safehash.h	2007-07-02 17:45:15 +0000
+++ b/mysys/my_safehash.h	2008-10-10 20:34:55 +0000
@@ -40,7 +40,7 @@ typedef struct st_safe_hash_entry
 typedef struct st_safe_hash_with_default
 {
 #ifdef THREAD
-  rw_lock_t mutex;
+  mysql_rwlock_t mutex;
 #endif
   HASH hash;
   uchar *default_value;

=== modified file 'mysys/my_seek.c'
--- a/mysys/my_seek.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_seek.c	2008-10-10 20:34:55 +0000
@@ -59,9 +59,9 @@ my_off_t my_seek(File fd, my_off_t pos, 
 #if defined(THREAD) && !defined(HAVE_PREAD) && !defined(__WIN__)
   if (MyFlags & MY_THREADSAFE)
   {
-    pthread_mutex_lock(&my_file_info[fd].mutex);
+    MYSQL_MUTEX_LOCK(&my_file_info[fd].mutex);
     newpos= lseek(fd, pos, whence);
-    pthread_mutex_unlock(&my_file_info[fd].mutex);
+    MYSQL_MUTEX_UNLOCK(&my_file_info[fd].mutex);
   }
   else
 #endif

=== modified file 'mysys/my_static.c'
--- a/mysys/my_static.c	2008-08-19 14:10:19 +0000
+++ b/mysys/my_static.c	2008-10-10 20:34:55 +0000
@@ -103,3 +103,9 @@ my_bool NEAR my_disable_async_io=0;
 my_bool NEAR my_disable_flush_key_blocks=0;
 my_bool NEAR my_disable_symlinks=0;
 my_bool NEAR mysys_uses_curses=0;
+
+#ifdef HAVE_PSI_INTERFACE
+struct PSI_bootstrap *PSI_hook= NULL;
+PSI *PSI_server= NULL;
+#endif
+

=== modified file 'mysys/my_thr_init.c'
--- a/mysys/my_thr_init.c	2008-07-09 07:12:43 +0000
+++ b/mysys/my_thr_init.c	2008-10-10 20:34:55 +0000
@@ -29,21 +29,21 @@ pthread_key(struct st_my_thread_var*, TH
 #else
 pthread_key(struct st_my_thread_var, THR_KEY_mysys);
 #endif /* USE_TLS */
-pthread_mutex_t THR_LOCK_malloc,THR_LOCK_open,
+mysql_mutex_t THR_LOCK_malloc,THR_LOCK_open,
 	        THR_LOCK_lock,THR_LOCK_isam,THR_LOCK_heap, THR_LOCK_net,
                 THR_LOCK_charset, THR_LOCK_threads, THR_LOCK_time;
 /** For insert/delete in the list of MyISAM open tables */
-pthread_mutex_t THR_LOCK_myisam;
+mysql_mutex_t THR_LOCK_myisam;
 /** For writing to the MyISAM logs */
-pthread_mutex_t THR_LOCK_myisam_log;
-pthread_cond_t  THR_COND_threads;
+mysql_mutex_t THR_LOCK_myisam_log;
+mysql_cond_t  THR_COND_threads;
 uint            THR_thread_count= 0;
 uint 		my_thread_end_wait_time= 5;
 #if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
-pthread_mutex_t LOCK_localtime_r;
+mysql_mutex_t LOCK_localtime_r;
 #endif
 #ifndef HAVE_GETHOSTBYNAME_R
-pthread_mutex_t LOCK_gethostbyname_r;
+mysql_mutex_t LOCK_gethostbyname_r;
 #endif
 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 pthread_mutexattr_t my_fast_mutexattr;
@@ -179,10 +179,10 @@ void my_thread_global_end(void)
   my_bool all_threads_killed= 1;
 
   set_timespec(abstime, my_thread_end_wait_time);
-  pthread_mutex_lock(&THR_LOCK_threads);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_threads);
   while (THR_thread_count > 0)
   {
-    int error= pthread_cond_timedwait(&THR_COND_threads, &THR_LOCK_threads,
+    int error= MYSQL_COND_TIMEDWAIT(&THR_COND_threads, &THR_LOCK_threads,
                                       &abstime);
     if (error == ETIMEDOUT || error == ETIME)
     {
@@ -201,7 +201,7 @@ void my_thread_global_end(void)
       break;
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_threads);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_threads);
 
   pthread_key_delete(THR_KEY_mysys);
 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
@@ -210,26 +210,26 @@ void my_thread_global_end(void)
 #ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
   pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
 #endif
-  pthread_mutex_destroy(&THR_LOCK_malloc);
-  pthread_mutex_destroy(&THR_LOCK_open);
-  pthread_mutex_destroy(&THR_LOCK_lock);
-  pthread_mutex_destroy(&THR_LOCK_isam);
-  pthread_mutex_destroy(&THR_LOCK_myisam);
-  pthread_mutex_destroy(&THR_LOCK_myisam_log);
-  pthread_mutex_destroy(&THR_LOCK_heap);
-  pthread_mutex_destroy(&THR_LOCK_net);
-  pthread_mutex_destroy(&THR_LOCK_time);
-  pthread_mutex_destroy(&THR_LOCK_charset);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_malloc);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_open);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_lock);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_isam);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_myisam);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_heap);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_net);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_time);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_charset);
   if (all_threads_killed)
   {
-    pthread_mutex_destroy(&THR_LOCK_threads);
-    pthread_cond_destroy(&THR_COND_threads);
+    MYSQL_MUTEX_DESTROY(&THR_LOCK_threads);
+    MYSQL_COND_DESTROY(&THR_COND_threads);
   }
 #if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
-  pthread_mutex_destroy(&LOCK_localtime_r);
+  MYSQL_MUTEX_DESTROY(&LOCK_localtime_r);
 #endif
 #ifndef HAVE_GETHOSTBYNAME_R
-  pthread_mutex_destroy(&LOCK_gethostbyname_r);
+  MYSQL_MUTEX_DESTROY(&LOCK_gethostbyname_r);
 #endif
 }
 
@@ -297,10 +297,10 @@ my_bool my_thread_init(void)
   pthread_mutex_init(&tmp->mutex,MY_MUTEX_INIT_FAST);
   pthread_cond_init(&tmp->suspend, NULL);
 
-  pthread_mutex_lock(&THR_LOCK_threads);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_threads);
   tmp->id= ++thread_id;
   ++THR_thread_count;
-  pthread_mutex_unlock(&THR_LOCK_threads);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_threads);
   tmp->init= 1;
 #ifndef DBUG_OFF
   /* Generate unique name for thread */
@@ -350,9 +350,9 @@ void my_thread_end(void)
 #endif
 #if !defined(__bsdi__) && !defined(__OpenBSD__)
  /* bsdi and openbsd 3.5 dumps core here */
-    pthread_cond_destroy(&tmp->suspend);
+    MYSQL_COND_DESTROY(&tmp->suspend);
 #endif
-    pthread_mutex_destroy(&tmp->mutex);
+    MYSQL_MUTEX_DESTROY(&tmp->mutex);
 #if !defined(__WIN__) || defined(USE_TLS)
     free(tmp);
 #else
@@ -368,11 +368,11 @@ void my_thread_end(void)
       my_thread_end and thus freed all memory they have allocated in
       my_thread_init() and DBUG_xxxx
     */
-    pthread_mutex_lock(&THR_LOCK_threads);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_threads);
     DBUG_ASSERT(THR_thread_count != 0);
     if (--THR_thread_count == 0)
-      pthread_cond_signal(&THR_COND_threads);
-   pthread_mutex_unlock(&THR_LOCK_threads);
+      MYSQL_COND_SIGNAL(&THR_COND_threads);
+   MYSQL_MUTEX_UNLOCK(&THR_LOCK_threads);
   }
   else
   {

=== modified file 'mysys/my_uuid.c'
--- a/mysys/my_uuid.c	2008-07-23 11:28:20 +0000
+++ b/mysys/my_uuid.c	2008-10-10 20:34:55 +0000
@@ -50,7 +50,7 @@ static ulonglong uuid_time= 0;
 static uchar uuid_suffix[2+6]; /* clock_seq and node */
 
 #ifdef THREAD
-static pthread_mutex_t LOCK_uuid_generator;
+static mysql_mutex_t LOCK_uuid_generator;
 #endif
 
 /*
@@ -133,7 +133,7 @@ void my_uuid(uchar *to)
 
   DBUG_ASSERT(my_uuid_inited);
 
-  pthread_mutex_lock(&LOCK_uuid_generator);
+  MYSQL_MUTEX_LOCK(&LOCK_uuid_generator);
   tv= my_getsystime() + UUID_TIME_OFFSET + nanoseq;
 
   if (likely(tv > uuid_time))
@@ -194,7 +194,7 @@ void my_uuid(uchar *to)
   }
 
   uuid_time=tv;
-  pthread_mutex_unlock(&LOCK_uuid_generator);
+  MYSQL_MUTEX_UNLOCK(&LOCK_uuid_generator);
 
   time_low=            (uint32) (tv & 0xFFFFFFFF);
   time_mid=            (uint16) ((tv >> 32) & 0xFFFF);
@@ -238,6 +238,6 @@ void my_uuid_end()
   if (my_uuid_inited)
   {
     my_uuid_inited= 0;
-    pthread_mutex_destroy(&LOCK_uuid_generator);
+    MYSQL_MUTEX_DESTROY(&LOCK_uuid_generator);
   }
 }

=== modified file 'mysys/my_wincond.c'
--- a/mysys/my_wincond.c	2007-05-10 09:59:39 +0000
+++ b/mysys/my_wincond.c	2008-10-10 20:34:55 +0000
@@ -25,7 +25,7 @@
 #include <process.h>
 #include <sys/timeb.h>
 
-int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
+int pthread_cond_init(mysql_cond_t *cond, const pthread_condattr_t *attr)
 {
   cond->waiting= 0;
   InitializeCriticalSection(&cond->lock_waiting);
@@ -54,7 +54,7 @@ int pthread_cond_init(pthread_cond_t *co
   return 0;
 }
 
-int pthread_cond_destroy(pthread_cond_t *cond)
+int MYSQL_COND_DESTROY(mysql_cond_t *cond)
 {
   DeleteCriticalSection(&cond->lock_waiting);
 
@@ -66,13 +66,13 @@ int pthread_cond_destroy(pthread_cond_t 
 }
 
 
-int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+int MYSQL_COND_WAIT(mysql_cond_t *cond, mysql_mutex_t *mutex)
 {
-  return pthread_cond_timedwait(cond,mutex,NULL);
+  return MYSQL_COND_TIMEDWAIT(cond,mutex,NULL);
 }
 
 
-int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
+int MYSQL_COND_TIMEDWAIT(mysql_cond_t *cond, mysql_mutex_t *mutex,
                            struct timespec *abstime)
 {
   int result;
@@ -144,7 +144,7 @@ int pthread_cond_timedwait(pthread_cond_
   return result == WAIT_TIMEOUT ? ETIMEDOUT : 0;
 }
 
-int pthread_cond_signal(pthread_cond_t *cond)
+int MYSQL_COND_SIGNAL(mysql_cond_t *cond)
 {
   EnterCriticalSection(&cond->lock_waiting);
   
@@ -157,7 +157,7 @@ int pthread_cond_signal(pthread_cond_t *
 }
 
 
-int pthread_cond_broadcast(pthread_cond_t *cond)
+int MYSQL_COND_BROADCAST(mysql_cond_t *cond)
 {
   EnterCriticalSection(&cond->lock_waiting);
   /*

=== modified file 'mysys/my_winthread.c'
--- a/mysys/my_winthread.c	2008-05-29 15:44:11 +0000
+++ b/mysys/my_winthread.c	2008-10-10 20:34:55 +0000
@@ -26,7 +26,7 @@
 #undef getpid
 #include <process.h>
 
-static pthread_mutex_t THR_LOCK_thread;
+static mysql_mutex_t THR_LOCK_thread;
 
 struct pthread_map
 {
@@ -42,13 +42,13 @@ void win_pthread_init(void)
 
 
 /**
-   Adapter to @c pthread_mutex_trylock()
+   Adapter to @c mysql_mutex_trylock()
 
    @retval 0      Mutex was acquired
    @retval EBUSY  Mutex was already locked by a thread
  */
 int
-win_pthread_mutex_trylock(pthread_mutex_t *mutex)
+win_mysql_mutex_trylock(mysql_mutex_t *mutex)
 {
   if (TryEnterCriticalSection(mutex))
   {
@@ -79,9 +79,9 @@ pthread_handler_t pthread_start(void *pa
   void *func_param=((struct pthread_map *) param)->param;
   void *result;
   my_thread_init();			/* Will always succeed in windows */
-  pthread_mutex_lock(&THR_LOCK_thread);	  /* Wait for beginthread to return */
+  MYSQL_MUTEX_LOCK(&THR_LOCK_thread);	  /* Wait for beginthread to return */
   win_pthread_self=((struct pthread_map *) param)->pthreadself;
-  pthread_mutex_unlock(&THR_LOCK_thread);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_thread);
   free((char*) param);			  /* Free param from create */
   result= (void*) (*func)(func_param);
   my_thread_end();
@@ -110,7 +110,7 @@ int pthread_create(pthread_t *thread_id,
   }
   if (StackSize == 0)
     StackSize= PTHREAD_STACK_MIN;
-  pthread_mutex_lock(&THR_LOCK_thread);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_thread);
 #ifdef __BORLANDC__
   hThread=(HANDLE)_beginthread((void(_USERENTRY *)(void *)) pthread_start,
 			       StackSize, (void*) map);
@@ -120,7 +120,7 @@ int pthread_create(pthread_t *thread_id,
 #endif
   DBUG_PRINT("info", ("hThread=%lu",(long) hThread));
   *thread_id=map->pthreadself=hThread;
-  pthread_mutex_unlock(&THR_LOCK_thread);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_thread);
 
   if (hThread == (HANDLE) -1)
   {

=== modified file 'mysys/mysys_priv.h'
--- a/mysys/mysys_priv.h	2007-07-30 08:33:50 +0000
+++ b/mysys/mysys_priv.h	2008-10-10 20:34:55 +0000
@@ -26,9 +26,9 @@
 
 #ifdef THREAD
 #include <my_pthread.h>
-extern pthread_mutex_t THR_LOCK_malloc, THR_LOCK_open, THR_LOCK_keycache;
-extern pthread_mutex_t THR_LOCK_lock, THR_LOCK_isam, THR_LOCK_net;
-extern pthread_mutex_t THR_LOCK_charset, THR_LOCK_time;
+extern mysql_mutex_t THR_LOCK_malloc, THR_LOCK_open, THR_LOCK_keycache;
+extern mysql_mutex_t THR_LOCK_lock, THR_LOCK_isam, THR_LOCK_net;
+extern mysql_mutex_t THR_LOCK_charset, THR_LOCK_time;
 #else
 #include <my_no_pthread.h>
 #endif

=== modified file 'mysys/safemalloc.c'
--- a/mysys/safemalloc.c	2008-08-21 05:20:27 +0000
+++ b/mysys/safemalloc.c	2008-10-10 20:34:55 +0000
@@ -178,7 +178,7 @@ void *_mymalloc(size_t size, const char 
   irem->prev=	  NULL;
 
   /* Add this remember structure to the linked list */
-  pthread_mutex_lock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
   if ((irem->next= sf_malloc_root))
     sf_malloc_root->prev= irem;
   sf_malloc_root= irem;
@@ -188,7 +188,7 @@ void *_mymalloc(size_t size, const char 
   if (sf_malloc_cur_memory > sf_malloc_max_memory)
     sf_malloc_max_memory= sf_malloc_cur_memory;
   sf_malloc_count++;
-  pthread_mutex_unlock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
 
   /* Set the memory to the aribtrary wierd value */
   if ((MyFlags & MY_ZEROFILL) || !sf_malloc_quick)
@@ -291,7 +291,7 @@ void _myfree(void *ptr, const char *file
   }
 
   /* Remove this structure from the linked list */
-  pthread_mutex_lock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
   if (irem->prev)
     irem->prev->next= irem->next;
    else
@@ -302,7 +302,7 @@ void _myfree(void *ptr, const char *file
   /* Handle the statistics */
   sf_malloc_cur_memory-= irem->datasize;
   sf_malloc_count--;
-  pthread_mutex_unlock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
 
 #ifndef HAVE_purify
   /* Mark this data as free'ed */
@@ -365,7 +365,7 @@ void TERMINATE(FILE *file, uint flag)
 {
   struct st_irem *irem;
   DBUG_ENTER("TERMINATE");
-  pthread_mutex_lock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
 
   /*
     Report the difference between number of calls to
@@ -428,7 +428,7 @@ void TERMINATE(FILE *file, uint flag)
   DBUG_PRINT("safe",("Maximum memory usage: %lu bytes (%luk)",
 		     (ulong) sf_malloc_max_memory,
 		     (ulong) (sf_malloc_max_memory + 1023L) /1024L));
-  pthread_mutex_unlock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
   DBUG_VOID_RETURN;
 }
 
@@ -505,7 +505,7 @@ int _sanity(const char *filename, uint l
   reg2 int flag=0;
   uint count=0;
 
-  pthread_mutex_lock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_malloc);
 #ifndef PEDANTIC_SAFEMALLOC  
   if (sf_malloc_tampered && (int) sf_malloc_count < 0)
     sf_malloc_count=0;
@@ -513,7 +513,7 @@ int _sanity(const char *filename, uint l
   count=sf_malloc_count;
   for (irem= sf_malloc_root; irem != NULL && count-- ; irem= irem->next)
     flag+= _checkchunk (irem, filename, lineno);
-  pthread_mutex_unlock(&THR_LOCK_malloc);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_malloc);
   if (count || irem)
   {
     const char *format="Error: Safemalloc link list destroyed, discovered at '%s:%d'";

=== modified file 'mysys/thr_alarm.c'
--- a/mysys/thr_alarm.c	2008-05-29 15:44:11 +0000
+++ b/mysys/thr_alarm.c	2008-10-10 20:34:55 +0000
@@ -43,8 +43,8 @@ static sig_handler process_alarm_part2(i
 
 #if !defined(__WIN__)
 
-static pthread_mutex_t LOCK_alarm;
-static pthread_cond_t COND_alarm;
+static mysql_mutex_t LOCK_alarm;
+static mysql_cond_t COND_alarm;
 static sigset_t full_signal_set;
 static QUEUE alarm_queue;
 static uint max_used_alarms=0;
@@ -52,7 +52,7 @@ pthread_t alarm_thread;
 
 #ifdef USE_ALARM_THREAD
 static void *alarm_handler(void *arg);
-#define reschedule_alarms() pthread_cond_signal(&COND_alarm)
+#define reschedule_alarms() MYSQL_COND_SIGNAL(&COND_alarm)
 #else
 #define reschedule_alarms() pthread_kill(alarm_thread,THR_SERVER_ALARM)
 #endif
@@ -119,14 +119,14 @@ void init_thr_alarm(uint max_alarms)
 
 void resize_thr_alarm(uint max_alarms)
 {
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
   /*
     It's ok not to shrink the queue as there may be more pending alarms than
     than max_alarms
   */
   if (alarm_queue.elements < max_alarms)
     resize_queue(&alarm_queue,max_alarms+1);
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 }
 
 
@@ -164,12 +164,12 @@ my_bool thr_alarm(thr_alarm_t *alrm, uin
 #ifndef USE_ONE_SIGNAL_HAND
   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
 #endif
-  pthread_mutex_lock(&LOCK_alarm);        /* Lock from threads & alarms */
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);        /* Lock from threads & alarms */
   if (alarm_aborted > 0)
   {					/* No signal thread */
     DBUG_PRINT("info", ("alarm aborted"));
     *alrm= 0;					/* No alarm */
-    pthread_mutex_unlock(&LOCK_alarm);
+    MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 #ifndef USE_ONE_SIGNAL_HAND
     pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
@@ -185,7 +185,7 @@ my_bool thr_alarm(thr_alarm_t *alrm, uin
       DBUG_PRINT("info", ("alarm queue full"));
       fprintf(stderr,"Warning: thr_alarm queue is full\n");
       *alrm= 0;					/* No alarm */
-      pthread_mutex_unlock(&LOCK_alarm);
+      MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 #ifndef USE_ONE_SIGNAL_HAND
       pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
@@ -200,7 +200,7 @@ my_bool thr_alarm(thr_alarm_t *alrm, uin
     {
       DBUG_PRINT("info", ("failed my_malloc()"));
       *alrm= 0;					/* No alarm */
-      pthread_mutex_unlock(&LOCK_alarm);
+      MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 #ifndef USE_ONE_SIGNAL_HAND
       pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
@@ -228,7 +228,7 @@ my_bool thr_alarm(thr_alarm_t *alrm, uin
     else
       reschedule_alarms();			/* Reschedule alarms */
   }
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 #ifndef USE_ONE_SIGNAL_HAND
   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
@@ -253,7 +253,7 @@ void thr_end_alarm(thr_alarm_t *alarmed)
 #ifndef USE_ONE_SIGNAL_HAND
   pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
 #endif
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
 
   alarm_data= (ALARM*) ((uchar*) *alarmed - offsetof(ALARM,alarmed));
   for (i=0 ; i < alarm_queue.elements ; i++)
@@ -278,7 +278,7 @@ void thr_end_alarm(thr_alarm_t *alarmed)
     DBUG_PRINT("warning",("Didn't find alarm %p in queue\n",
 			  *alarmed));
   }
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 #ifndef USE_ONE_SIGNAL_HAND
   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
@@ -321,14 +321,14 @@ sig_handler process_alarm(int sig __attr
 
 #ifndef USE_ALARM_THREAD
   pthread_sigmask(SIG_SETMASK,&full_signal_set,&old_mask);
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
 #endif
   process_alarm_part2(sig);
 #ifndef USE_ALARM_THREAD
 #if defined(DONT_REMEMBER_SIGNAL) && !defined(USE_ONE_SIGNAL_HAND)
   my_sigset(THR_SERVER_ALARM,process_alarm);
 #endif
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
   pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
 #endif
   return;
@@ -436,7 +436,7 @@ void end_thr_alarm(my_bool free_structur
   DBUG_ENTER("end_thr_alarm");
   if (alarm_aborted != 1)			/* If memory not freed */
   {
-    pthread_mutex_lock(&LOCK_alarm);
+    MYSQL_MUTEX_LOCK(&LOCK_alarm);
     DBUG_PRINT("info",("Resheduling %d waiting alarms",alarm_queue.elements));
     alarm_aborted= -1;				/* mark aborted */
     if (alarm_queue.elements || (alarm_thread_running && free_structures))
@@ -456,21 +456,21 @@ void end_thr_alarm(my_bool free_structur
       set_timespec(abstime, 10);		/* Wait up to 10 seconds */
       while (alarm_thread_running)
       {
-	int error= pthread_cond_timedwait(&COND_alarm, &LOCK_alarm, &abstime);
+	int error= MYSQL_COND_TIMEDWAIT(&COND_alarm, &LOCK_alarm, &abstime);
 	if (error == ETIME || error == ETIMEDOUT)
 	  break;				/* Don't wait forever */
       }
       delete_queue(&alarm_queue);
       alarm_aborted= 1;
-      pthread_mutex_unlock(&LOCK_alarm);
+      MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
       if (!alarm_thread_running)              /* Safety */
       {
-        pthread_mutex_destroy(&LOCK_alarm);
-        pthread_cond_destroy(&COND_alarm);
+        MYSQL_MUTEX_DESTROY(&LOCK_alarm);
+        MYSQL_COND_DESTROY(&COND_alarm);
       }
     }
     else
-      pthread_mutex_unlock(&LOCK_alarm);
+      MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
   }
   DBUG_VOID_RETURN;
 }
@@ -485,7 +485,7 @@ void thr_alarm_kill(my_thread_id thread_
   uint i;
   if (alarm_aborted)
     return;
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
   for (i=0 ; i < alarm_queue.elements ; i++)
   {
     if (((ALARM*) queue_element(&alarm_queue,i))->thread_id == thread_id)
@@ -497,13 +497,13 @@ void thr_alarm_kill(my_thread_id thread_
       break;
     }
   }
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 }
 
 
 void thr_alarm_info(ALARM_INFO *info)
 {
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
   info->next_alarm_time= 0;
   info->max_used_alarms= max_used_alarms;
   if ((info->active_alarms=  alarm_queue.elements))
@@ -514,7 +514,7 @@ void thr_alarm_info(ALARM_INFO *info)
     time_diff= (long) (alarm_data->expire_time - now);
     info->next_alarm_time= (ulong) (time_diff < 0 ? 0 : time_diff);
   }
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
 }
 
 /*
@@ -551,7 +551,7 @@ static void *alarm_handler(void *arg __a
 #endif
   my_thread_init();
   alarm_thread_running= 1;
-  pthread_mutex_lock(&LOCK_alarm);
+  MYSQL_MUTEX_LOCK(&LOCK_alarm);
   for (;;)
   {
     if (alarm_queue.elements)
@@ -566,7 +566,7 @@ static void *alarm_handler(void *arg __a
 	abstime.tv_sec=sleep_time;
 	abstime.tv_nsec=0;
         next_alarm_expire_time= sleep_time;
-	if ((error=pthread_cond_timedwait(&COND_alarm,&LOCK_alarm,&abstime)) &&
+	if ((error=MYSQL_COND_TIMEDWAIT(&COND_alarm,&LOCK_alarm,&abstime)) &&
 	    error != ETIME && error != ETIMEDOUT)
 	{
 #ifdef MAIN
@@ -581,7 +581,7 @@ static void *alarm_handler(void *arg __a
     else
     {
       next_alarm_expire_time= ~ (time_t) 0;
-      if ((error=pthread_cond_wait(&COND_alarm,&LOCK_alarm)))
+      if ((error=MYSQL_COND_WAIT(&COND_alarm,&LOCK_alarm)))
       {
 #ifdef MAIN
         printf("Got error: %d from ptread_cond_wait (errno: %d)\n",
@@ -593,8 +593,8 @@ static void *alarm_handler(void *arg __a
   }
   bzero((char*) &alarm_thread,sizeof(alarm_thread)); /* For easy debugging */
   alarm_thread_running= 0;
-  pthread_cond_signal(&COND_alarm);
-  pthread_mutex_unlock(&LOCK_alarm);
+  MYSQL_COND_SIGNAL(&COND_alarm);
+  MYSQL_MUTEX_UNLOCK(&LOCK_alarm);
   pthread_exit(0);
   return 0;					/* Impossible */
 }
@@ -696,8 +696,8 @@ void resize_thr_alarm(uint max_alarms)
 #ifdef MAIN
 #if defined(THREAD) && !defined(DONT_USE_THR_ALARM)
 
-static pthread_cond_t COND_thread_count;
-static pthread_mutex_t LOCK_thread_count;
+static mysql_cond_t COND_thread_count;
+static mysql_mutex_t LOCK_thread_count;
 static uint thread_count;
 
 #ifdef HPUX10
@@ -784,10 +784,10 @@ static void *test_thread(void *arg)
     thr_end_alarm(&got_alarm);
     fflush(stdout);
   }
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
-  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_COND_SIGNAL(&COND_thread_count); /* Tell main we are ready */
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   free((uchar*) arg);
   return 0;
 }
@@ -814,9 +814,9 @@ static void *signal_hand(void *arg __att
   my_thread_init();
   pthread_detach_this_thread();
   init_thr_alarm(10);				/* Setup alarm handler */
-  pthread_mutex_lock(&LOCK_thread_count);	/* Required by bsdi */
-  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);	/* Required by bsdi */
+  MYSQL_COND_SIGNAL(&COND_thread_count); /* Tell main we are ready */
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   sigemptyset(&set);				/* Catch all signals */
   sigaddset(&set,SIGINT);
@@ -915,10 +915,10 @@ int main(int argc __attribute__((unused)
   pthread_attr_setstacksize(&thr_attr,65536L);
 
   /* Start signal thread and wait for it to start */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   pthread_create(&tid,&thr_attr,signal_hand,NULL);
-  pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_PRINT("info",("signal thread created"));
 
   thr_setconcurrency(3);
@@ -928,32 +928,32 @@ int main(int argc __attribute__((unused)
   {
     param=(int*) malloc(sizeof(int));
     *param= i;
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
     {
       printf("Can't create thread %d, error: %d\n",i,error);
       exit(1);
     }
     thread_count++;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
 
   pthread_attr_destroy(&thr_attr);
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thr_alarm_info(&alarm_info);
   printf("Main_thread:  Alarms: %u  max_alarms: %u  next_alarm_time: %lu\n",
 	 alarm_info.active_alarms, alarm_info.max_used_alarms,
 	 alarm_info.next_alarm_time);
   while (thread_count)
   {
-    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
+    MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
     if (thread_count == 1)
     {
       printf("Calling end_thr_alarm. This should cancel the last thread\n");
       end_thr_alarm(0);
     }
   }
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   thr_alarm_info(&alarm_info);
   end_thr_alarm(1);
   printf("Main_thread:  Alarms: %u  max_alarms: %u  next_alarm_time: %lu\n",

=== modified file 'mysys/thr_lock.c'
--- a/mysys/thr_lock.c	2008-08-26 12:00:01 +0000
+++ b/mysys/thr_lock.c	2008-10-10 20:34:55 +0000
@@ -100,7 +100,7 @@ enum thr_lock_type thr_upgraded_concurre
 LIST *thr_lock_thread_list;			/* List of threads in use */
 ulong max_write_lock_count= ~(ulong) 0L;
 
-static inline pthread_cond_t *get_cond(void)
+static inline mysql_cond_t *get_cond(void)
 {
   return &my_thread_var->suspend;
 }
@@ -344,10 +344,10 @@ void thr_lock_init(THR_LOCK *lock)
   lock->write_wait.last= &lock->write_wait.data;
   lock->write.last= &lock->write.data;
 
-  pthread_mutex_lock(&THR_LOCK_lock);		/* Add to locks in use */
+  MYSQL_MUTEX_LOCK(&THR_LOCK_lock);		/* Add to locks in use */
   lock->list.data=(void*) lock;
   thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
-  pthread_mutex_unlock(&THR_LOCK_lock);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -355,10 +355,10 @@ void thr_lock_init(THR_LOCK *lock)
 void thr_lock_delete(THR_LOCK *lock)
 {
   DBUG_ENTER("thr_lock_delete");
-  pthread_mutex_lock(&THR_LOCK_lock);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_lock);
   thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
-  pthread_mutex_unlock(&THR_LOCK_lock);
-  pthread_mutex_destroy(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_lock);
+  MYSQL_MUTEX_DESTROY(&lock->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -422,7 +422,7 @@ wait_for_lock(struct st_lock_list *wait,
               my_bool in_wait_list)
 {
   struct st_my_thread_var *thread_var= my_thread_var;
-  pthread_cond_t *cond= &thread_var->suspend;
+  mysql_cond_t *cond= &thread_var->suspend;
   struct timespec wait_timeout;
   enum enum_thr_lock_result result= THR_LOCK_ABORTED;
   my_bool can_deadlock= test(data->owner->info->n_cursors);
@@ -456,9 +456,9 @@ wait_for_lock(struct st_lock_list *wait,
   while (!thread_var->abort || in_wait_list)
   {
     int rc= (can_deadlock ?
-             pthread_cond_timedwait(cond, &data->lock->mutex,
+             MYSQL_COND_TIMEDWAIT(cond, &data->lock->mutex,
                                     &wait_timeout) :
-             pthread_cond_wait(cond, &data->lock->mutex));
+             MYSQL_COND_WAIT(cond, &data->lock->mutex));
     /*
       We must break the wait if one of the following occurs:
       - the connection has been aborted (!thread_var->abort), but
@@ -514,13 +514,13 @@ wait_for_lock(struct st_lock_list *wait,
       (*data->lock->get_status)(data->status_param, 0);
     check_locks(data->lock,"got wait_for_lock",0);
   }
-  pthread_mutex_unlock(&data->lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&data->lock->mutex);
 
   /* The following must be done after unlock of lock->mutex */
-  pthread_mutex_lock(&thread_var->mutex);
+  MYSQL_MUTEX_LOCK(&thread_var->mutex);
   thread_var->current_mutex= 0;
   thread_var->current_cond=  0;
-  pthread_mutex_unlock(&thread_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&thread_var->mutex);
   DBUG_RETURN(result);
 }
 
@@ -539,7 +539,7 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_O
   data->cond=0;					/* safety */
   data->type=lock_type;
   data->owner= owner;                           /* Must be reset ! */
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   DBUG_PRINT("lock",("data: %p  thread: 0x%lx  lock: %p  type: %d",
                      data, data->owner->info->thread_id,
                      lock, (int) lock_type));
@@ -748,7 +748,7 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_O
   /* Can't get lock yet;  Wait for it */
   DBUG_RETURN(wait_for_lock(wait_queue, data, 0));
 end:
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_RETURN(result);
 }
 
@@ -770,7 +770,7 @@ static inline void free_all_read_locks(T
 
   do
   {
-    pthread_cond_t *cond=data->cond;
+    mysql_cond_t *cond=data->cond;
     if ((int) data->type == (int) TL_READ_NO_INSERT)
     {
       if (using_concurrent_insert)
@@ -795,7 +795,7 @@ static inline void free_all_read_locks(T
 		       data->owner->info->thread_id));
     /* purecov: end */
     data->cond=0;				/* Mark thread free */
-    pthread_cond_signal(cond);
+    MYSQL_COND_SIGNAL(cond);
   } while ((data=data->next));
   *lock->read_wait.last=0;
   if (!lock->read_wait.data)
@@ -812,7 +812,7 @@ void thr_unlock(THR_LOCK_DATA *data)
   DBUG_ENTER("thr_unlock");
   DBUG_PRINT("lock",("data: %p  thread: 0x%lx  lock: %p",
                      data, data->owner->info->thread_id, lock));
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   check_locks(lock,"start of release lock",0);
 
   if (((*data->prev)=data->next))		/* remove from lock-list */
@@ -834,7 +834,7 @@ void thr_unlock(THR_LOCK_DATA *data)
   data->type=TL_UNLOCK;				/* Mark unlocked */
   check_locks(lock,"after releasing lock",1);
   wake_up_waiters(lock);
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -892,9 +892,9 @@ static void wake_up_waiters(THR_LOCK *lo
 			     data->type, data->owner->info->thread_id));
           /* purecov: end */
 	  {
-	    pthread_cond_t *cond=data->cond;
+	    mysql_cond_t *cond=data->cond;
 	    data->cond=0;				/* Mark thread free */
-	    pthread_cond_signal(cond);	/* Start waiting thread */
+	    MYSQL_COND_SIGNAL(cond);	/* Start waiting thread */
 	  }
 	  if (data->type != TL_WRITE_ALLOW_WRITE ||
 	      !lock->write_wait.data ||
@@ -935,7 +935,7 @@ static void wake_up_waiters(THR_LOCK *lo
 	goto end;
       }
       do {
-	pthread_cond_t *cond=data->cond;
+	mysql_cond_t *cond=data->cond;
 	if (((*data->prev)=data->next))		/* remove from wait-list */
 	  data->next->prev= data->prev;
 	else
@@ -945,7 +945,7 @@ static void wake_up_waiters(THR_LOCK *lo
 	lock->write.last= &data->next;
 	data->next=0;				/* Only one write lock */
 	data->cond=0;				/* Mark thread free */
-	pthread_cond_signal(cond);	/* Start waiting thread */
+	MYSQL_COND_SIGNAL(cond);	/* Start waiting thread */
       } while (lock_type == TL_WRITE_ALLOW_WRITE &&
 	       (data=lock->write_wait.data) &&
 	       data->type == TL_WRITE_ALLOW_WRITE);
@@ -1131,19 +1131,19 @@ void thr_abort_locks(THR_LOCK *lock, my_
 {
   THR_LOCK_DATA *data;
   DBUG_ENTER("thr_abort_locks");
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
 
   for (data=lock->read_wait.data; data ; data=data->next)
   {
     data->type=TL_UNLOCK;			/* Mark killed */
     /* It's safe to signal the cond first: we're still holding the mutex. */
-    pthread_cond_signal(data->cond);
+    MYSQL_COND_SIGNAL(data->cond);
     data->cond=0;				/* Removed from list */
   }
   for (data=lock->write_wait.data; data ; data=data->next)
   {
     data->type=TL_UNLOCK;
-    pthread_cond_signal(data->cond);
+    MYSQL_COND_SIGNAL(data->cond);
     data->cond=0;
   }
   lock->read_wait.last= &lock->read_wait.data;
@@ -1151,7 +1151,7 @@ void thr_abort_locks(THR_LOCK *lock, my_
   lock->read_wait.data=lock->write_wait.data=0;
   if (upgrade_lock && lock->write.data)
     lock->write.data->type=TL_WRITE_ONLY;
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -1168,7 +1168,7 @@ my_bool thr_abort_locks_for_thread(THR_L
   my_bool found= FALSE;
   DBUG_ENTER("thr_abort_locks_for_thread");
 
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   for (data= lock->read_wait.data; data ; data= data->next)
   {
     if (data->owner->info->thread_id == thread_id)    /* purecov: tested */
@@ -1177,7 +1177,7 @@ my_bool thr_abort_locks_for_thread(THR_L
       data->type= TL_UNLOCK;			/* Mark killed */
       /* It's safe to signal the cond first: we're still holding the mutex. */
       found= TRUE;
-      pthread_cond_signal(data->cond);
+      MYSQL_COND_SIGNAL(data->cond);
       data->cond= 0;				/* Removed from list */
 
       if (((*data->prev)= data->next))
@@ -1193,7 +1193,7 @@ my_bool thr_abort_locks_for_thread(THR_L
       DBUG_PRINT("info",("Aborting write-wait lock"));
       data->type= TL_UNLOCK;
       found= TRUE;
-      pthread_cond_signal(data->cond);
+      MYSQL_COND_SIGNAL(data->cond);
       data->cond= 0;
 
       if (((*data->prev)= data->next))
@@ -1203,7 +1203,7 @@ my_bool thr_abort_locks_for_thread(THR_L
     }
   }
   wake_up_waiters(lock);
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_RETURN(found);
 }
 
@@ -1252,7 +1252,7 @@ void thr_downgrade_write_lock(THR_LOCK_D
 #endif
   DBUG_ENTER("thr_downgrade_write_only_lock");
 
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   DBUG_ASSERT(old_lock_type == TL_WRITE_ONLY);
   DBUG_ASSERT(old_lock_type > new_lock_type);
   in_data->type= new_lock_type;
@@ -1344,7 +1344,7 @@ void thr_downgrade_write_lock(THR_LOCK_D
       next= data->next;
       if (start_writers && data->type == new_lock_type)
       {
-        pthread_cond_t *cond= data->cond;
+        mysql_cond_t *cond= data->cond;
         /*
           It is ok to start this waiter.
           Move from being first in wait queue to be last in write queue.
@@ -1358,7 +1358,7 @@ void thr_downgrade_write_lock(THR_LOCK_D
         data->next= 0;
         check_locks(lock, "Started write lock after downgrade",0);
         data->cond= 0;
-        pthread_cond_signal(cond);
+        MYSQL_COND_SIGNAL(cond);
       }
       else
       {
@@ -1398,7 +1398,7 @@ void thr_downgrade_write_lock(THR_LOCK_D
       if (new_lock_type != TL_WRITE_ALLOW_READ ||
           data->type != TL_READ_NO_INSERT)
       {
-        pthread_cond_t *cond= data->cond;
+        mysql_cond_t *cond= data->cond;
         if (((*data->prev)= data->next))
           data->next->prev= data->prev;
         else
@@ -1411,13 +1411,13 @@ void thr_downgrade_write_lock(THR_LOCK_D
           lock->read_no_write_count++;
         check_locks(lock, "Started read lock after downgrade",0);
         data->cond= 0;
-        pthread_cond_signal(cond);
+        MYSQL_COND_SIGNAL(cond);
       }
     }
   }
   check_locks(lock,"after starting waiters after downgrading lock",0);
 #endif
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -1428,10 +1428,10 @@ my_bool thr_upgrade_write_delay_lock(THR
   THR_LOCK *lock=data->lock;
   DBUG_ENTER("thr_upgrade_write_delay_lock");
 
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   if (data->type == TL_UNLOCK || data->type >= TL_WRITE_LOW_PRIORITY)
   {
-    pthread_mutex_unlock(&lock->mutex);
+    MYSQL_MUTEX_UNLOCK(&lock->mutex);
     DBUG_RETURN(data->type == TL_UNLOCK);	/* Test if Aborted */
   }
   check_locks(lock,"before upgrading lock",0);
@@ -1445,7 +1445,7 @@ my_bool thr_upgrade_write_delay_lock(THR
     {						/* We have the lock */
       if (lock->get_status)
 	(*lock->get_status)(data->status_param, 0);
-      pthread_mutex_unlock(&lock->mutex);
+      MYSQL_MUTEX_UNLOCK(&lock->mutex);
       DBUG_RETURN(0);
     }
 
@@ -1477,10 +1477,10 @@ my_bool thr_reschedule_write_lock(THR_LO
   THR_LOCK *lock=data->lock;
   DBUG_ENTER("thr_reschedule_write_lock");
 
-  pthread_mutex_lock(&lock->mutex);
+  MYSQL_MUTEX_LOCK(&lock->mutex);
   if (!lock->read_wait.data)			/* No waiting read locks */
   {
-    pthread_mutex_unlock(&lock->mutex);
+    MYSQL_MUTEX_UNLOCK(&lock->mutex);
     DBUG_RETURN(0);
   }
 
@@ -1501,7 +1501,7 @@ my_bool thr_reschedule_write_lock(THR_LO
   lock->write_wait.data=data;
   free_all_read_locks(lock,0);
 
-  pthread_mutex_unlock(&lock->mutex);
+  MYSQL_MUTEX_UNLOCK(&lock->mutex);
   DBUG_RETURN(thr_upgrade_write_delay_lock(data));
 }
 
@@ -1536,13 +1536,13 @@ void thr_print_locks(void)
   LIST *list;
   uint count=0;
 
-  pthread_mutex_lock(&THR_LOCK_lock);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_lock);
   puts("Current locks:");
   for (list= thr_lock_thread_list; list && count++ < MAX_THREADS;
        list= list_rest(list))
   {
     THR_LOCK *lock=(THR_LOCK*) list->data;
-    pthread_mutex_lock(&lock->mutex);
+    MYSQL_MUTEX_LOCK(&lock->mutex);
     printf("lock: 0x%lx:",(ulong) lock);
     if ((lock->write_wait.data || lock->read_wait.data) &&
 	(! lock->read.data && ! lock->write.data))
@@ -1560,11 +1560,11 @@ void thr_print_locks(void)
     thr_print_lock("write_wait",&lock->write_wait);
     thr_print_lock("read",&lock->read);
     thr_print_lock("read_wait",&lock->read_wait);
-    pthread_mutex_unlock(&lock->mutex);
+    MYSQL_MUTEX_UNLOCK(&lock->mutex);
     puts("");
   }
   fflush(stdout);
-  pthread_mutex_unlock(&THR_LOCK_lock);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_lock);
 }
 
 #endif /* THREAD */
@@ -1641,8 +1641,8 @@ int lock_counts[]= {sizeof(test_0)/sizeo
 };
 
 
-static pthread_cond_t COND_thread_count;
-static pthread_mutex_t LOCK_thread_count;
+static mysql_cond_t COND_thread_count;
+static mysql_mutex_t LOCK_thread_count;
 static uint thread_count;
 static ulong sum=0;
 
@@ -1693,7 +1693,7 @@ static void *test_thread(void *arg)
       data[i].type= tests[param][i].lock_type;
     }
     thr_multi_lock(multi_locks, lock_counts[param], &owner);
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     {
       int tmp=rand() & 7;			/* Do something from 0-2 sec */
       if (tmp == 0)
@@ -1707,16 +1707,16 @@ static void *test_thread(void *arg)
 	  sum+=k;
       }
     }
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     thr_multi_unlock(multi_locks,lock_counts[param]);
   }
 
   printf("Thread %s (%d) ended\n",my_thread_name(),param); fflush(stdout);
   thr_print_locks();
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
-  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_COND_SIGNAL(&COND_thread_count); /* Tell main we are ready */
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   free((uchar*) arg);
   return 0;
 }
@@ -1785,9 +1785,9 @@ int main(int argc __attribute__((unused)
     param=(int*) malloc(sizeof(int));
     *param=i;
 
-    if ((error=pthread_mutex_lock(&LOCK_thread_count)))
+    if ((error=MYSQL_MUTEX_LOCK(&LOCK_thread_count)))
     {
-      fprintf(stderr,"Got error: %d from pthread_mutex_lock (errno: %d)",
+      fprintf(stderr,"Got error: %d from MYSQL_MUTEX_LOCK (errno: %d)",
 	      error,errno);
       exit(1);
     }
@@ -1795,23 +1795,23 @@ int main(int argc __attribute__((unused)
     {
       fprintf(stderr,"Got error: %d from pthread_create (errno: %d)\n",
 	      error,errno);
-      pthread_mutex_unlock(&LOCK_thread_count);
+      MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       exit(1);
     }
     thread_count++;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
 
   pthread_attr_destroy(&thr_attr);
-  if ((error=pthread_mutex_lock(&LOCK_thread_count)))
-    fprintf(stderr,"Got error: %d from pthread_mutex_lock\n",error);
+  if ((error=MYSQL_MUTEX_LOCK(&LOCK_thread_count)))
+    fprintf(stderr,"Got error: %d from MYSQL_MUTEX_LOCK\n",error);
   while (thread_count)
   {
-    if ((error=pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
-      fprintf(stderr,"Got error: %d from pthread_cond_wait\n",error);
+    if ((error=MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count)))
+      fprintf(stderr,"Got error: %d from MYSQL_COND_WAIT\n",error);
   }
-  if ((error=pthread_mutex_unlock(&LOCK_thread_count)))
-    fprintf(stderr,"Got error: %d from pthread_mutex_unlock\n",error);
+  if ((error=MYSQL_MUTEX_UNLOCK(&LOCK_thread_count)))
+    fprintf(stderr,"Got error: %d from MYSQL_MUTEX_UNLOCK\n",error);
   for (i=0 ; i < array_elements(locks) ; i++)
     thr_lock_delete(locks+i);
 #ifdef EXTRA_DEBUG

=== modified file 'mysys/thr_rwlock.c'
--- a/mysys/thr_rwlock.c	2006-12-23 19:17:15 +0000
+++ b/mysys/thr_rwlock.c	2008-10-10 20:34:55 +0000
@@ -58,7 +58,7 @@
 *  Mountain View, California  94043
 */
 
-int my_rwlock_init(rw_lock_t *rwp, void *arg __attribute__((unused)))
+int my_rwlock_init(mysql_rwlock_t *rwp, void *arg __attribute__((unused)))
 {
   pthread_condattr_t	cond_attr;
 
@@ -75,32 +75,32 @@ int my_rwlock_init(rw_lock_t *rwp, void 
 }
 
 
-int my_rwlock_destroy(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_DESTROY(mysql_rwlock_t *rwp)
 {
-  pthread_mutex_destroy( &rwp->lock );
-  pthread_cond_destroy( &rwp->readers );
-  pthread_cond_destroy( &rwp->writers );
+  MYSQL_MUTEX_DESTROY( &rwp->lock );
+  MYSQL_COND_DESTROY( &rwp->readers );
+  MYSQL_COND_DESTROY( &rwp->writers );
   return(0);
 }
 
 
-int my_rw_rdlock(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_RDLOCK(mysql_rwlock_t *rwp)
 {
-  pthread_mutex_lock(&rwp->lock);
+  MYSQL_MUTEX_LOCK(&rwp->lock);
 
   /* active or queued writers */
   while (( rwp->state < 0 ) || rwp->waiters)
-    pthread_cond_wait( &rwp->readers, &rwp->lock);
+    MYSQL_COND_WAIT( &rwp->readers, &rwp->lock);
 
   rwp->state++;
-  pthread_mutex_unlock(&rwp->lock);
+  MYSQL_MUTEX_UNLOCK(&rwp->lock);
   return(0);
 }
 
-int my_rw_tryrdlock(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_TRYRDLOCK(mysql_rwlock_t *rwp)
 {
   int res;
-  pthread_mutex_lock(&rwp->lock);
+  MYSQL_MUTEX_LOCK(&rwp->lock);
   if ((rwp->state < 0 ) || rwp->waiters)
     res= EBUSY;					/* Can't get lock */
   else
@@ -108,29 +108,29 @@ int my_rw_tryrdlock(rw_lock_t *rwp)
     res=0;
     rwp->state++;
   }
-  pthread_mutex_unlock(&rwp->lock);
+  MYSQL_MUTEX_UNLOCK(&rwp->lock);
   return(res);
 }
 
 
-int my_rw_wrlock(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_WRLOCK(mysql_rwlock_t *rwp)
 {
-  pthread_mutex_lock(&rwp->lock);
+  MYSQL_MUTEX_LOCK(&rwp->lock);
   rwp->waiters++;				/* another writer queued */
 
   while (rwp->state)
-    pthread_cond_wait(&rwp->writers, &rwp->lock);
+    MYSQL_COND_WAIT(&rwp->writers, &rwp->lock);
   rwp->state	= -1;
   rwp->waiters--;
-  pthread_mutex_unlock(&rwp->lock);
+  MYSQL_MUTEX_UNLOCK(&rwp->lock);
   return(0);
 }
 
 
-int my_rw_trywrlock(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_TRYWRLOCK(mysql_rwlock_t *rwp)
 {
   int res;
-  pthread_mutex_lock(&rwp->lock);
+  MYSQL_MUTEX_LOCK(&rwp->lock);
   if (rwp->state)
     res= EBUSY;					/* Can't get lock */    
   else
@@ -138,33 +138,33 @@ int my_rw_trywrlock(rw_lock_t *rwp)
     res=0;
     rwp->state	= -1;
   }
-  pthread_mutex_unlock(&rwp->lock);
+  MYSQL_MUTEX_UNLOCK(&rwp->lock);
   return(res);
 }
 
 
-int my_rw_unlock(rw_lock_t *rwp)
+int my_MYSQL_RWLOCK_UNLOCK(mysql_rwlock_t *rwp)
 {
-  DBUG_PRINT("rw_unlock",
+  DBUG_PRINT("MYSQL_RWLOCK_UNLOCK",
 	     ("state: %d waiters: %d", rwp->state, rwp->waiters));
-  pthread_mutex_lock(&rwp->lock);
+  MYSQL_MUTEX_LOCK(&rwp->lock);
 
   if (rwp->state == -1)		/* writer releasing */
   {
     rwp->state= 0;		/* mark as available */
 
     if ( rwp->waiters )		/* writers queued */
-      pthread_cond_signal( &rwp->writers );
+      MYSQL_COND_SIGNAL( &rwp->writers );
     else
-      pthread_cond_broadcast( &rwp->readers );
+      MYSQL_COND_BROADCAST( &rwp->readers );
   }
   else
   {
     if ( --rwp->state == 0 )	/* no more readers */
-      pthread_cond_signal( &rwp->writers );
+      MYSQL_COND_SIGNAL( &rwp->writers );
   }
 
-  pthread_mutex_unlock( &rwp->lock );
+  MYSQL_MUTEX_UNLOCK( &rwp->lock );
   return(0);
 }
 

=== modified file 'mysys/wqueue.c'
--- a/mysys/wqueue.c	2008-04-21 14:43:38 +0000
+++ b/mysys/wqueue.c	2008-10-10 20:34:55 +0000
@@ -130,7 +130,7 @@ void wqueue_release_queue(WQUEUE *wqueue
   do
   {
     thread= next;
-    pthread_cond_signal(&thread->suspend);
+    MYSQL_COND_SIGNAL(&thread->suspend);
     next= thread->next;
     thread->next= NULL;
   }
@@ -158,7 +158,7 @@ void wqueue_release_one_locktype_from_qu
   if (first_type == MY_PTHREAD_LOCK_WRITE)
   {
     /* release first waiting for write lock */
-    pthread_cond_signal(&next->suspend);
+    MYSQL_COND_SIGNAL(&next->suspend);
     if (next == last)
       wqueue->last_thread= NULL;
     else
@@ -184,7 +184,7 @@ void wqueue_release_one_locktype_from_qu
     else
     {
       /* release waiting for read lock */
-      pthread_cond_signal(&thread->suspend);
+      MYSQL_COND_SIGNAL(&thread->suspend);
       thread->next= NULL;
     }
   } while (thread != last);
@@ -204,7 +204,7 @@ void wqueue_release_one_locktype_from_qu
 
 void wqueue_add_and_wait(WQUEUE *wqueue,
                          struct st_my_thread_var *thread,
-                         pthread_mutex_t *lock)
+                         mysql_mutex_t *lock)
 {
   DBUG_ENTER("wqueue_add_and_wait");
   DBUG_PRINT("enter",
@@ -215,7 +215,7 @@ void wqueue_add_and_wait(WQUEUE *wqueue,
   {
     DBUG_PRINT("info", ("wait... cond:  0x%lx  mutex:  0x%lx",
                         (ulong) &thread->suspend, (ulong) lock));
-    pthread_cond_wait(&thread->suspend, lock);
+    MYSQL_COND_WAIT(&thread->suspend, lock);
     DBUG_PRINT("info", ("wait done cond: 0x%lx  mutex: 0x%lx   next: 0x%lx",
                         (ulong) &thread->suspend, (ulong) lock,
                         (ulong) thread->next));

=== modified file 'sql/backup/backup_kernel.h'
--- a/sql/backup/backup_kernel.h	2008-09-02 09:04:39 +0000
+++ b/sql/backup/backup_kernel.h	2008-10-10 20:34:55 +0000
@@ -50,6 +50,10 @@ int restore_table_data(THD*, Restore_inf
 
 }
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_BRC_run_lock;
+#endif
+
 /**
   Instances of this class are used for creating required context and performing
   backup/restore operations.
@@ -87,7 +91,7 @@ class Backup_restore_ctx: public backup:
       ongoing backup/restore operation.  If pointer is null, no
       operation is currently running. */
   static Backup_restore_ctx *current_op;
-  static pthread_mutex_t  run_lock; ///< To guard @c current_op.
+  static mysql_mutex_t  run_lock; ///< To guard @c current_op.
 
   /** 
     @brief State of a context object. 

=== modified file 'sql/backup/be_thread.cc'
--- a/sql/backup/be_thread.cc	2008-07-09 07:12:43 +0000
+++ b/sql/backup/be_thread.cc	2008-10-10 20:34:55 +0000
@@ -52,9 +52,9 @@ THD *create_new_thd()
   THD_CHECK_SENTRY(thd);
 
   thd->thread_stack = (char*)&thd; // remember where our stack is  
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (unlikely(thd->store_globals())) // for a proper MEM_ROOT  
   {
     thd->cleanup();
@@ -81,11 +81,11 @@ THD *create_new_thd()
     Making this thread visible to SHOW PROCESSLIST is useful for
     troubleshooting a backup job (why does it stall etc).
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
   thread_count++;
   thread_running++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   DBUG_RETURN(thd);
 }
@@ -146,13 +146,13 @@ pthread_handler_t backup_thread_for_lock
     goto end2;
   }
 
-  pthread_mutex_lock(&locking_thd->THR_LOCK_caller);
+  MYSQL_MUTEX_LOCK(&locking_thd->THR_LOCK_caller);
 
   if (thd->killed)
   {
     THD_SET_PROC_INFO(thd, "lock error");
     locking_thd->lock_state= LOCK_ERROR;
-    pthread_mutex_unlock(&locking_thd->THR_LOCK_caller);
+    MYSQL_MUTEX_UNLOCK(&locking_thd->THR_LOCK_caller);
     goto end;
   }
 
@@ -166,7 +166,7 @@ pthread_handler_t backup_thread_for_lock
     DBUG_PRINT("info",("Online backup locking thread dying"));
     THD_SET_PROC_INFO(thd, "lock error");
     locking_thd->lock_state= LOCK_ERROR;
-    pthread_mutex_unlock(&locking_thd->THR_LOCK_caller);
+    MYSQL_MUTEX_UNLOCK(&locking_thd->THR_LOCK_caller);
     goto end;
   }
 
@@ -174,24 +174,24 @@ pthread_handler_t backup_thread_for_lock
   {
     THD_SET_PROC_INFO(thd, "lock error");
     locking_thd->lock_state= LOCK_ERROR;
-    pthread_mutex_unlock(&locking_thd->THR_LOCK_caller);
+    MYSQL_MUTEX_UNLOCK(&locking_thd->THR_LOCK_caller);
     goto end;
   }
 
-  pthread_mutex_unlock(&locking_thd->THR_LOCK_caller);
+  MYSQL_MUTEX_UNLOCK(&locking_thd->THR_LOCK_caller);
 
   /*
     Part of work is done. Rest until woken up.
     We wait if the thread is not killed and the driver has not signaled us.
   */
   THD_SET_PROC_INFO(thd, "waiting for signal");
-  pthread_mutex_lock(&locking_thd->THR_LOCK_thread);
+  MYSQL_MUTEX_LOCK(&locking_thd->THR_LOCK_thread);
   locking_thd->lock_state= LOCK_ACQUIRED;
   thd->enter_cond(&locking_thd->COND_thread_wait,
                   &locking_thd->THR_LOCK_thread,
                   "Locking thread: holding table locks");
   while (!thd->killed && (locking_thd->lock_state != LOCK_SIGNAL))
-    pthread_cond_wait(&locking_thd->COND_thread_wait,
+    MYSQL_COND_WAIT(&locking_thd->COND_thread_wait,
                       &locking_thd->THR_LOCK_thread);
   thd->exit_cond("Locking thread: terminating");
   THD_SET_PROC_INFO(thd, "terminating");
@@ -206,12 +206,12 @@ end:
 
 end2:
   THD_SET_PROC_INFO(thd, "lock done");
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
   thread_running--;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
-  pthread_mutex_lock(&locking_thd->THR_LOCK_caller);
+  MYSQL_MUTEX_LOCK(&locking_thd->THR_LOCK_caller);
   net_end(&thd->net);
   my_thread_end();
   delete thd;
@@ -222,8 +222,8 @@ end2:
   /*
     Signal the driver thread that it's ok to proceed with destructor.
   */
-  pthread_cond_signal(&locking_thd->COND_caller_wait);
-  pthread_mutex_unlock(&locking_thd->THR_LOCK_caller);
+  MYSQL_COND_SIGNAL(&locking_thd->COND_caller_wait);
+  MYSQL_MUTEX_UNLOCK(&locking_thd->THR_LOCK_caller);
   pthread_exit(0);
   return (0);
 }
@@ -236,10 +236,10 @@ Locking_thread_st::Locking_thread_st()
   /*
     Initialize the thread mutex and cond variable.
   */
-  pthread_mutex_init(&THR_LOCK_thread, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_thread_wait, NULL);
-  pthread_mutex_init(&THR_LOCK_caller, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_caller_wait, NULL);
+  MYSQL_MUTEX_INIT(&THR_LOCK_thread, key_THR_LOCK_thread, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_thread_wait, key_COND_thread_wait, NULL);
+  MYSQL_MUTEX_INIT(&THR_LOCK_caller, key_THR_LOCK_caller, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_caller_wait, key_COND_caller_wait, NULL);
   lock_state= LOCK_NOT_STARTED;
   lock_thd= NULL; // set to 0 as precaution for get_data being called too soon
   thd_name.length(0);
@@ -261,10 +261,10 @@ Locking_thread_st::~Locking_thread_st()
   /*
     Destroy the thread mutexes and cond variables.
   */
-  pthread_mutex_destroy(&THR_LOCK_thread);
-  pthread_cond_destroy(&COND_thread_wait);
-  pthread_mutex_destroy(&THR_LOCK_caller);
-  pthread_cond_destroy(&COND_caller_wait);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_thread);
+  MYSQL_COND_DESTROY(&COND_thread_wait);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_caller);
+  MYSQL_COND_DESTROY(&COND_caller_wait);
 }
 
 /**
@@ -297,19 +297,19 @@ result_t Locking_thread_st::start_lockin
 void Locking_thread_st::kill_locking_thread()
 {
   DBUG_ENTER("Locking_thread_st::kill_locking_thread");
-  pthread_mutex_lock(&THR_LOCK_caller);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_caller);
   if (lock_state == LOCK_ERROR)
     THD_SET_PROC_INFO(m_thd, "error in the locking thread");
 
   if (lock_thd && (lock_state != LOCK_DONE) && (lock_state != LOCK_SIGNAL))
   {
     lock_state= LOCK_SIGNAL;
-    pthread_mutex_lock(&lock_thd->LOCK_delete);
+    MYSQL_MUTEX_LOCK(&lock_thd->LOCK_delete);
     lock_thd->awake(THD::KILL_CONNECTION);
-    pthread_mutex_unlock(&lock_thd->LOCK_delete);
-    pthread_cond_signal(&COND_thread_wait);
+    MYSQL_MUTEX_UNLOCK(&lock_thd->LOCK_delete);
+    MYSQL_COND_SIGNAL(&COND_thread_wait);
   }
-  pthread_mutex_unlock(&THR_LOCK_caller);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_caller);
 
   /*
     This tells the CS driver that we're finished with the tables.
@@ -328,17 +328,17 @@ void Locking_thread_st::kill_locking_thr
 */
 void Locking_thread_st::wait_until_locking_thread_dies()
 {
-  pthread_mutex_lock(&THR_LOCK_caller);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_caller);
   if (lock_state != LOCK_DONE)
   {
     m_thd->enter_cond(&COND_caller_wait, &THR_LOCK_caller,
                     "Locking thread: waiting until locking thread is done");
     while (lock_state != LOCK_DONE)
-      pthread_cond_wait(&COND_caller_wait, &THR_LOCK_caller);
+      MYSQL_COND_WAIT(&COND_caller_wait, &THR_LOCK_caller);
     m_thd->exit_cond("Locking thread: terminating");
 
     DBUG_PRINT("info",("Locking thread's locking thread terminated"));
   }
   else
-    pthread_mutex_unlock(&THR_LOCK_caller);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_caller);
 }

=== modified file 'sql/backup/be_thread.h'
--- a/sql/backup/be_thread.h	2008-07-09 07:12:43 +0000
+++ b/sql/backup/be_thread.h	2008-10-10 20:34:55 +0000
@@ -33,6 +33,13 @@ using backup::Table_list;
 */
 pthread_handler_t backup_thread_for_locking(void *arg);
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_THR_LOCK_thread;
+extern PSI_cond_key key_COND_thread_wait;
+extern PSI_mutex_key key_THR_LOCK_caller;
+extern PSI_cond_key key_COND_caller_wait;
+#endif
+
 /**
  * @struct Locking_thread
  *
@@ -48,10 +55,10 @@ public:
   Locking_thread_st();
   ~Locking_thread_st();
 
-  pthread_mutex_t THR_LOCK_thread; ///< mutex for thread variables
-  pthread_cond_t COND_thread_wait; ///< condition variable for wait
-  pthread_mutex_t THR_LOCK_caller; ///< mutex for thread variables
-  pthread_cond_t COND_caller_wait; ///< condition variable for wait
+  mysql_mutex_t THR_LOCK_thread; ///< mutex for thread variables
+  mysql_cond_t COND_thread_wait; ///< condition variable for wait
+  mysql_mutex_t THR_LOCK_caller; ///< mutex for thread variables
+  mysql_cond_t COND_caller_wait; ///< condition variable for wait
 
   TABLE_LIST *tables_in_backup;    ///< List of tables used in backup
   THD *lock_thd;                   ///< Locking thread pointer

=== modified file 'sql/backup/kernel.cc'
--- a/sql/backup/kernel.cc	2008-09-19 09:55:21 +0000
+++ b/sql/backup/kernel.cc	2008-10-10 20:34:55 +0000
@@ -94,7 +94,7 @@
  */
 int backup_init()
 {
-  pthread_mutex_init(&Backup_restore_ctx::run_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&Backup_restore_ctx::run_lock, key_BRC_run_lock, MY_MUTEX_INIT_FAST);
   return 0;
 }
 
@@ -106,7 +106,7 @@ int backup_init()
  */
 void backup_shutdown()
 {
-  pthread_mutex_destroy(&Backup_restore_ctx::run_lock);
+  MYSQL_MUTEX_DESTROY(&Backup_restore_ctx::run_lock);
 }
 
 /*
@@ -362,7 +362,7 @@ class Mem_allocator
 // static members
 
 Backup_restore_ctx *Backup_restore_ctx::current_op= NULL;
-pthread_mutex_t Backup_restore_ctx::run_lock;
+mysql_mutex_t Backup_restore_ctx::run_lock;
 
 
 Backup_restore_ctx::Backup_restore_ctx(THD *thd)
@@ -428,14 +428,14 @@ int Backup_restore_ctx::prepare(LEX_STRI
     this operation.
    */
 
-  pthread_mutex_lock(&run_lock);
+  MYSQL_MUTEX_LOCK(&run_lock);
 
   if (!current_op)
     current_op= this;
   else
     fatal_error(ER_BACKUP_RUNNING);
 
-  pthread_mutex_unlock(&run_lock);
+  MYSQL_MUTEX_UNLOCK(&run_lock);
 
   if (m_error)
     return m_error;
@@ -833,11 +833,11 @@ int Backup_restore_ctx::close()
   mem_alloc= NULL;
   
   // deregister this operation if it was running
-  pthread_mutex_lock(&run_lock);
+  MYSQL_MUTEX_LOCK(&run_lock);
   if (current_op == this) {
     current_op= NULL;
   }
-  pthread_mutex_unlock(&run_lock);
+  MYSQL_MUTEX_UNLOCK(&run_lock);
 
   /* 
     Remove the location, if asked for.

=== modified file 'sql/ddl_blocker.cc'
--- a/sql/ddl_blocker.cc	2008-08-19 15:35:29 +0000
+++ b/sql/ddl_blocker.cc	2008-10-10 20:34:55 +0000
@@ -46,24 +46,24 @@ void DDL_blocker_class::destroy_DDL_bloc
 
 DDL_blocker_class::DDL_blocker_class()
 {
-  pthread_mutex_init(&THR_LOCK_DDL_blocker, MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&THR_LOCK_DDL_is_blocked, MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&THR_LOCK_DDL_blocker_blocked, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_DDL_blocker, NULL);
-  pthread_cond_init(&COND_process_blocked, NULL);
-  pthread_cond_init(&COND_DDL_blocker_blocked, NULL);
+  MYSQL_MUTEX_INIT(&THR_LOCK_DDL_blocker, key_THR_LOCK_DDL_blocker, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&THR_LOCK_DDL_is_blocked, key_THR_LOCK_DDL_is_blocked, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&THR_LOCK_DDL_blocker_blocked, key_THR_LOCK_DDL_blocker_blocked, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_DDL_blocker, key_COND_DDL_blocker, NULL);
+  MYSQL_COND_INIT(&COND_process_blocked, key_COND_process_blocked, NULL);
+  MYSQL_COND_INIT(&COND_DDL_blocker_blocked, key_COND_DDL_blocker_blocked, NULL);
   DDL_blocked= FALSE;
   DDL_blocks= 0;
 }
 
 DDL_blocker_class::~DDL_blocker_class()
 {
-  pthread_mutex_destroy(&THR_LOCK_DDL_blocker);
-  pthread_mutex_destroy(&THR_LOCK_DDL_is_blocked);
-  pthread_mutex_destroy(&THR_LOCK_DDL_blocker_blocked);
-  pthread_cond_destroy(&COND_DDL_blocker);
-  pthread_cond_destroy(&COND_process_blocked);
-  pthread_cond_destroy(&COND_DDL_blocker_blocked);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_DDL_is_blocked);
+  MYSQL_MUTEX_DESTROY(&THR_LOCK_DDL_blocker_blocked);
+  MYSQL_COND_DESTROY(&COND_DDL_blocker);
+  MYSQL_COND_DESTROY(&COND_process_blocked);
+  MYSQL_COND_DESTROY(&COND_DDL_blocker_blocked);
 }
 
 /**
@@ -74,9 +74,9 @@ DDL_blocker_class::~DDL_blocker_class()
 void DDL_blocker_class::start_DDL()
 {
   DBUG_ENTER("start_DDL()");
-  pthread_mutex_lock(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_blocker);
   DDL_blocks++;
-  pthread_mutex_unlock(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_DDL_blocker);
   DBUG_VOID_RETURN;
 }
 
@@ -89,12 +89,12 @@ void DDL_blocker_class::start_DDL()
 void DDL_blocker_class::end_DDL()
 {
   DBUG_ENTER("end_DDL()");
-  pthread_mutex_lock(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_blocker);
   if (DDL_blocks > 0)
     DDL_blocks--;
   if (DDL_blocks == 0)
-    pthread_cond_broadcast(&COND_process_blocked);
-  pthread_mutex_unlock(&THR_LOCK_DDL_blocker);
+    MYSQL_COND_BROADCAST(&COND_process_blocked);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_DDL_blocker);
   DBUG_VOID_RETURN;
 }
 
@@ -123,7 +123,7 @@ my_bool DDL_blocker_class::check_DDL_blo
   /*
     Check the ddl blocker condition. Rest until ddl blocker is released.
   */
-  pthread_mutex_lock(&THR_LOCK_DDL_is_blocked);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_is_blocked);
   thd->enter_cond(&COND_DDL_blocker, &THR_LOCK_DDL_is_blocked,
                   "DDL blocker: DDL is blocked");
   while (DDL_blocked && !thd->DDL_exception && (ret == 0))
@@ -131,7 +131,7 @@ my_bool DDL_blocker_class::check_DDL_blo
     if (thd->backup_wait_timeout == 0)
       ret = -1;
     else
-      ret= pthread_cond_timedwait(&COND_DDL_blocker, &THR_LOCK_DDL_is_blocked,
+      ret= MYSQL_COND_TIMEDWAIT(&COND_DDL_blocker, &THR_LOCK_DDL_is_blocked,
                                   &ddl_timeout);
   }
   thd->exit_cond("DDL blocker: DDL is not blocked");
@@ -170,11 +170,11 @@ my_bool DDL_blocker_class::block_DDL(THD
     Check the blocker blocked condition. 
     Rest until another blocker is done.
   */
-  pthread_mutex_lock(&THR_LOCK_DDL_blocker_blocked);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_blocker_blocked);
   thd->enter_cond(&COND_DDL_blocker_blocked, &THR_LOCK_DDL_blocker_blocked,
                   "DDL blocker: Checking block on blocker");
   while (DDL_blocked)
-    pthread_cond_wait(&COND_DDL_blocker_blocked,
+    MYSQL_COND_WAIT(&COND_DDL_blocker_blocked,
                       &THR_LOCK_DDL_blocker_blocked);
   DDL_blocked= TRUE;
   thd->exit_cond("DDL blocker: Ok to block DDL");
@@ -182,11 +182,11 @@ my_bool DDL_blocker_class::block_DDL(THD
   /*
     Check the ddl blocker condition. Rest until ddl blocker is released.
   */
-  pthread_mutex_lock(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_blocker);
   thd->enter_cond(&COND_process_blocked, &THR_LOCK_DDL_blocker,
                   "DDL blocker: Checking block on DDL");
   while (DDL_blocks != 0)
-    pthread_cond_wait(&COND_process_blocked, &THR_LOCK_DDL_blocker);
+    MYSQL_COND_WAIT(&COND_process_blocked, &THR_LOCK_DDL_blocker);
   thd->exit_cond("DDL blocker: DDL is now blocked");
 
   DEBUG_SYNC(thd, "after_block_ddl");
@@ -201,10 +201,10 @@ my_bool DDL_blocker_class::block_DDL(THD
   */
 void DDL_blocker_class::unblock_DDL()
 {
-  pthread_mutex_lock(&THR_LOCK_DDL_blocker);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_DDL_blocker);
   DDL_blocked= FALSE;
-  pthread_cond_broadcast(&COND_DDL_blocker);
-  pthread_cond_signal(&COND_DDL_blocker_blocked);
-  pthread_mutex_unlock(&THR_LOCK_DDL_blocker);
+  MYSQL_COND_BROADCAST(&COND_DDL_blocker);
+  MYSQL_COND_SIGNAL(&COND_DDL_blocker_blocked);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_DDL_blocker);
 }
 

=== modified file 'sql/ddl_blocker.h'
--- a/sql/ddl_blocker.h	2008-06-25 13:39:04 +0000
+++ b/sql/ddl_blocker.h	2008-10-10 20:34:55 +0000
@@ -110,13 +110,23 @@ class DDL_blocker_class
       These variables are used to implement the metadata freeze "DDL blocker"
       for online backup.
     */
-    pthread_mutex_t THR_LOCK_DDL_blocker;    ///< Mutex for blocking DDL   
-    pthread_mutex_t THR_LOCK_DDL_is_blocked; ///< Mutex for checking block DDL 
-    pthread_mutex_t THR_LOCK_DDL_blocker_blocked; ///< One blocker at a time 
-    pthread_cond_t COND_DDL_blocker;         ///< cond for blocking DDL
-    pthread_cond_t COND_process_blocked;     ///< cond for checking block DDL
-    pthread_cond_t COND_DDL_blocker_blocked; ///< cond for blocker blocked
+    mysql_mutex_t THR_LOCK_DDL_blocker;    ///< Mutex for blocking DDL   
+    mysql_mutex_t THR_LOCK_DDL_is_blocked; ///< Mutex for checking block DDL 
+    mysql_mutex_t THR_LOCK_DDL_blocker_blocked; ///< One blocker at a time 
+    mysql_cond_t COND_DDL_blocker;         ///< cond for blocking DDL
+    mysql_cond_t COND_process_blocked;     ///< cond for checking block DDL
+    mysql_cond_t COND_DDL_blocker_blocked; ///< cond for blocker blocked
     my_bool DDL_blocked;                     ///< Is blocking operation running
     int DDL_blocks;              ///< Number of DDL operations in progress.
     static DDL_blocker_class *m_instance;    ///< instance var for singleton 
 };
+
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_THR_LOCK_DDL_blocker;
+extern PSI_mutex_key key_THR_LOCK_DDL_is_blocked;
+extern PSI_mutex_key key_THR_LOCK_DDL_blocker_blocked;
+extern PSI_cond_key key_COND_DDL_blocker;
+extern PSI_cond_key key_COND_process_blocked;
+extern PSI_cond_key key_COND_DDL_blocker_blocked;
+#endif
+

=== modified file 'sql/debug_sync.cc'
--- a/sql/debug_sync.cc	2008-09-08 09:25:46 +0000
+++ b/sql/debug_sync.cc	2008-10-10 20:34:55 +0000
@@ -240,6 +240,10 @@ struct st_debug_sync_control
   ulonglong             dsp_max_active;         /* statistics */
 };
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_cond_key key_ds_cond;
+PSI_mutex_key key_ds_mutex;
+#endif
 
 /**
   Definitions for the debug sync facility.
@@ -250,8 +254,8 @@ struct st_debug_sync_control
 struct st_debug_sync_globals
 {
   String                ds_signal;              /* signal variable */
-  pthread_cond_t        ds_cond;                /* condition variable */
-  pthread_mutex_t       ds_mutex;               /* mutex variable */
+  mysql_cond_t        ds_cond;                /* condition variable */
+  mysql_mutex_t       ds_mutex;               /* mutex variable */
   ulonglong             dsp_hits;               /* statistics */
   ulonglong             dsp_executed;           /* statistics */
   ulonglong             dsp_max_active;         /* statistics */
@@ -336,9 +340,10 @@ int debug_sync_init(void)
 
     /* Initialize the global variables. */
     debug_sync_global.ds_signal.length(0);
-    if ((rc= pthread_cond_init(&debug_sync_global.ds_cond, NULL)) ||
-        (rc= pthread_mutex_init(&debug_sync_global.ds_mutex,
-                                MY_MUTEX_INIT_FAST)))
+    if ((rc= MYSQL_COND_INIT(&debug_sync_global.ds_cond, key_ds_cond, NULL)) ||
+        (rc= MYSQL_MUTEX_INIT(&debug_sync_global.ds_mutex,
+                              key_ds_mutex,
+                              MY_MUTEX_INIT_FAST)))
       DBUG_RETURN(rc);
 
     /* Set the call back pointer in thr_lock.c. */
@@ -369,8 +374,8 @@ void debug_sync_end(void)
 
     /* Destroy the global variables. */
     debug_sync_global.ds_signal.free();
-    (void) pthread_cond_destroy(&debug_sync_global.ds_cond);
-    (void) pthread_mutex_destroy(&debug_sync_global.ds_mutex);
+    (void) MYSQL_COND_DESTROY(&debug_sync_global.ds_cond);
+    (void) MYSQL_MUTEX_DESTROY(&debug_sync_global.ds_mutex);
 
     /* Print statistics. */
     {
@@ -472,12 +477,12 @@ void debug_sync_end_thread(THD *thd)
     }
 
     /* Statistics. */
-    pthread_mutex_lock(&debug_sync_global.ds_mutex);
+    MYSQL_MUTEX_LOCK(&debug_sync_global.ds_mutex);
     debug_sync_global.dsp_hits+=           ds_control->dsp_hits;
     debug_sync_global.dsp_executed+=       ds_control->dsp_executed;
     if (debug_sync_global.dsp_max_active < ds_control->dsp_max_active)
       debug_sync_global.dsp_max_active=    ds_control->dsp_max_active;
-    pthread_mutex_unlock(&debug_sync_global.ds_mutex);
+    MYSQL_MUTEX_UNLOCK(&debug_sync_global.ds_mutex);
 
     my_free(ds_control, MYF(0));
     thd->debug_sync_control= NULL;
@@ -711,9 +716,9 @@ static void debug_sync_reset(THD *thd)
   ds_control->ds_active= 0;
 
   /* Clear the global signal. */
-  pthread_mutex_lock(&debug_sync_global.ds_mutex);
+  MYSQL_MUTEX_LOCK(&debug_sync_global.ds_mutex);
   debug_sync_global.ds_signal.length(0);
-  pthread_mutex_unlock(&debug_sync_global.ds_mutex);
+  MYSQL_MUTEX_UNLOCK(&debug_sync_global.ds_mutex);
 
   DBUG_VOID_RETURN;
 }
@@ -1516,7 +1521,7 @@ uchar *sys_var_debug_sync::value_ptr(THD
     static char on[]= "ON - current signal: '"; 
 
     // Ensure exclusive access to debug_sync_global.ds_signal
-    pthread_mutex_lock(&debug_sync_global.ds_mutex);
+    MYSQL_MUTEX_LOCK(&debug_sync_global.ds_mutex);
 
     size_t lgt= (sizeof(on) /* includes '\0' */ +
                  debug_sync_global.ds_signal.length() + 1 /* for '\'' */);
@@ -1533,7 +1538,7 @@ uchar *sys_var_debug_sync::value_ptr(THD
         *(vptr++)= '\'';
       *vptr= '\0'; /* We have one byte reserved for the worst case. */
     }
-    pthread_mutex_unlock(&debug_sync_global.ds_mutex);
+    MYSQL_MUTEX_UNLOCK(&debug_sync_global.ds_mutex);
   }
   else
     value= strmake_root(thd->mem_root, STRING_WITH_LEN("OFF"));
@@ -1595,7 +1600,7 @@ static void debug_sync_execute(THD *thd,
       read access too, to create a memory barrier in order to avoid that
       threads just reads an old cached version of the signal.
     */
-    pthread_mutex_lock(&debug_sync_global.ds_mutex);
+    MYSQL_MUTEX_LOCK(&debug_sync_global.ds_mutex);
     if (action->signal.length())
     {
       /* Copy the signal to the global variable. */
@@ -1608,15 +1613,15 @@ static void debug_sync_execute(THD *thd,
         debug_sync_emergency_disable(); /* purecov: tested */
       }
       /* Wake threads waiting in a sync point. */
-      pthread_cond_broadcast(&debug_sync_global.ds_cond);
+      MYSQL_COND_BROADCAST(&debug_sync_global.ds_cond);
       DBUG_PRINT("debug_sync_exec", ("signal '%s'  at: '%s'",
                                      sig_emit, dsp_name));
     } /* end if (action->signal.length()) */
 
     if (action->wait_for.length())
     {
-      pthread_mutex_t *old_mutex;
-      pthread_cond_t  *old_cond;
+      mysql_mutex_t *old_mutex;
+      mysql_cond_t  *old_cond;
       int             error= 0;
       struct timespec abstime;
 
@@ -1647,7 +1652,7 @@ static void debug_sync_execute(THD *thd,
       while (stringcmp(&debug_sync_global.ds_signal, &action->wait_for) &&
              !thd->killed && opt_debug_sync_timeout)
       {
-        error= pthread_cond_timedwait(&debug_sync_global.ds_cond,
+        error= MYSQL_COND_TIMEDWAIT(&debug_sync_global.ds_cond,
                                       &debug_sync_global.ds_mutex,
                                       &abstime);
         DBUG_EXECUTE("debug_sync", {
@@ -1675,18 +1680,18 @@ static void debug_sync_execute(THD *thd,
         protected mutex must always unlocked _before_ mysys_var->mutex
         is locked. (See comment in THD::exit_cond().)
       */
-      pthread_mutex_unlock(&debug_sync_global.ds_mutex);
-      pthread_mutex_lock(&thd->mysys_var->mutex);
+      MYSQL_MUTEX_UNLOCK(&debug_sync_global.ds_mutex);
+      MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
       thd->mysys_var->current_mutex= old_mutex;
       thd->mysys_var->current_cond= old_cond;
       thd_proc_info(thd, old_proc_info);
-      pthread_mutex_unlock(&thd->mysys_var->mutex);
+      MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
 
     } /* end if (action->wait_for.length()) */
     else
     {
       // Make sure to realease mutex also when there is no WAIT_FOR
-      pthread_mutex_unlock(&debug_sync_global.ds_mutex);
+      MYSQL_MUTEX_UNLOCK(&debug_sync_global.ds_mutex);
     }
 
   } /* end if (action->execute) */

=== modified file 'sql/des_key_file.cc'
--- a/sql/des_key_file.cc	2008-04-09 00:56:49 +0000
+++ b/sql/des_key_file.cc	2008-10-10 20:34:55 +0000
@@ -43,7 +43,7 @@ load_des_key_file(const char *file_name)
   DBUG_ENTER("load_des_key_file");
   DBUG_PRINT("enter",("name: %s",file_name));
 
-  pthread_mutex_lock(&LOCK_des_key_file);
+  MYSQL_MUTEX_LOCK(&LOCK_des_key_file);
   if ((file=my_open(file_name,O_RDONLY | O_BINARY ,MYF(MY_WME))) < 0 ||
       init_io_cache(&io, file, IO_SIZE*2, READ_CACHE, 0, 0, MYF(MY_WME)))
     goto error;
@@ -96,7 +96,7 @@ error:
     my_close(file,MYF(0));
     end_io_cache(&io);
   }
-  pthread_mutex_unlock(&LOCK_des_key_file);
+  MYSQL_MUTEX_UNLOCK(&LOCK_des_key_file);
   DBUG_RETURN(result);
 }
 #endif /* HAVE_OPENSSL */

=== modified file 'sql/event_queue.cc'
--- a/sql/event_queue.cc	2008-05-14 13:49:41 +0000
+++ b/sql/event_queue.cc	2008-10-10 20:34:55 +0000
@@ -95,16 +95,16 @@ Event_queue::Event_queue()
    mutex_queue_data_attempting_lock(FALSE),
    waiting_on_cond(FALSE)
 {
-  pthread_mutex_init(&LOCK_event_queue, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_queue_state, NULL);
+  MYSQL_MUTEX_INIT(&LOCK_event_queue, key_LOCK_event_queue, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_queue_state, key_COND_queue_state, NULL);
 }
 
 
 Event_queue::~Event_queue()
 {
   deinit_queue();
-  pthread_mutex_destroy(&LOCK_event_queue);
-  pthread_cond_destroy(&COND_queue_state);
+  MYSQL_MUTEX_DESTROY(&LOCK_event_queue);
+  MYSQL_COND_DESTROY(&COND_queue_state);
 }
 
 
@@ -211,7 +211,7 @@ Event_queue::create_event(THD *thd, Even
   LOCK_QUEUE_DATA();
   *created= (queue_insert_safe(&queue, (uchar *) new_element) == FALSE);
   dbug_dump_queue(thd->query_start());
-  pthread_cond_broadcast(&COND_queue_state);
+  MYSQL_COND_BROADCAST(&COND_queue_state);
   UNLOCK_QUEUE_DATA();
 
   DBUG_RETURN(!*created);
@@ -259,7 +259,7 @@ Event_queue::update_event(THD *thd, LEX_
   {
     DBUG_PRINT("info", ("new event in the queue: %p", new_element));
     queue_insert_safe(&queue, (uchar *) new_element);
-    pthread_cond_broadcast(&COND_queue_state);
+    MYSQL_COND_BROADCAST(&COND_queue_state);
   }
 
   dbug_dump_queue(thd->query_start());
@@ -344,7 +344,7 @@ Event_queue::drop_matching_events(THD *t
       i++;
   }
   /*
-    We don't call pthread_cond_broadcast(&COND_queue_state);
+    We don't call MYSQL_COND_BROADCAST(&COND_queue_state);
     If we remove the top event:
     1. The queue is empty. The scheduler will wake up at some time and
        realize that the queue is empty. If create_event() comes inbetween
@@ -677,7 +677,7 @@ Event_queue::lock_data(const char *func,
   mutex_last_attempted_lock_in_func= func;
   mutex_last_attempted_lock_at_line= line;
   mutex_queue_data_attempting_lock= TRUE;
-  pthread_mutex_lock(&LOCK_event_queue);
+  MYSQL_MUTEX_LOCK(&LOCK_event_queue);
   mutex_last_attempted_lock_in_func= "";
   mutex_last_attempted_lock_at_line= 0;
   mutex_queue_data_attempting_lock= FALSE;
@@ -708,19 +708,19 @@ Event_queue::unlock_data(const char *fun
   mutex_last_unlocked_at_line= line;
   mutex_queue_data_locked= FALSE;
   mutex_last_unlocked_in_func= func;
-  pthread_mutex_unlock(&LOCK_event_queue);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_queue);
   DBUG_VOID_RETURN;
 }
 
 
 /*
-  Wrapper for pthread_cond_wait/timedwait
+  Wrapper for MYSQL_COND_WAIT/timedwait
 
   SYNOPSIS
     Event_queue::cond_wait()
       thd     Thread (Could be NULL during shutdown procedure)
       msg     Message for thd->proc_info
-      abstime If not null then call pthread_cond_timedwait()
+      abstime If not null then call MYSQL_COND_TIMEDWAIT()
       func    Which function is requesting cond_wait
       line    On which line cond_wait is requested
 */
@@ -739,9 +739,9 @@ Event_queue::cond_wait(THD *thd, struct 
 
   DBUG_PRINT("info", ("pthread_cond_%swait", abstime? "timed":""));
   if (!abstime)
-    pthread_cond_wait(&COND_queue_state, &LOCK_event_queue);
+    MYSQL_COND_WAIT(&COND_queue_state, &LOCK_event_queue);
   else
-    pthread_cond_timedwait(&COND_queue_state, &LOCK_event_queue, abstime);
+    MYSQL_COND_TIMEDWAIT(&COND_queue_state, &LOCK_event_queue, abstime);
 
   mutex_last_locked_in_func= func;
   mutex_last_locked_at_line= line;

=== modified file 'sql/event_queue.h'
--- a/sql/event_queue.h	2007-08-15 15:08:44 +0000
+++ b/sql/event_queue.h	2008-10-10 20:34:55 +0000
@@ -35,6 +35,11 @@ class THD;
   Queue of active events awaiting execution.
 */
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_event_queue;
+extern PSI_cond_key key_COND_queue_state;
+#endif
+
 class Event_queue
 {
 public:
@@ -101,8 +106,8 @@ private:
   dbug_dump_queue(time_t now);
 
   /* LOCK_event_queue is the mutex which protects the access to the queue. */
-  pthread_mutex_t LOCK_event_queue;
-  pthread_cond_t COND_queue_state;
+  mysql_mutex_t LOCK_event_queue;
+  mysql_cond_t COND_queue_state;
 
   /* The sorted queue with the Event_queue_element objects */
   QUEUE queue;

=== modified file 'sql/event_scheduler.cc'
--- a/sql/event_scheduler.cc	2008-05-08 16:01:15 +0000
+++ b/sql/event_scheduler.cc	2008-10-10 20:34:55 +0000
@@ -129,11 +129,11 @@ post_init_event_thread(THD *thd)
   }
   lex_start(thd);
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
   thread_count++;
   thread_running++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   return FALSE;
 }
@@ -154,11 +154,11 @@ deinit_event_thread(THD *thd)
   DBUG_ASSERT(thd->net.buff != 0);
   net_end(&thd->net);
   DBUG_PRINT("exit", ("Event thread finishing"));
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
   thread_running--;
   delete thd;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 }
 
 
@@ -190,9 +190,9 @@ pre_init_event_thread(THD* thd)
   thd->slave_thread= 0;
   thd->options|= OPTION_AUTO_IS_NULL;
   thd->client_capabilities|= CLIENT_MULTI_RESULTS;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   /*
     Guarantees that we will see the thread in SHOW PROCESSLIST though its
@@ -348,16 +348,16 @@ Event_scheduler::Event_scheduler(Event_q
   waiting_on_cond(FALSE),
   started_events(0)
 {
-  pthread_mutex_init(&LOCK_scheduler_state, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_state, NULL);
+  MYSQL_MUTEX_INIT(&LOCK_scheduler_state, key_LOCK_scheduler_state, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_state, key_Event_scheduler_COND_state, NULL);
 }
 
 
 Event_scheduler::~Event_scheduler()
 {
   stop();                                    /* does nothing if not running */
-  pthread_mutex_destroy(&LOCK_scheduler_state);
-  pthread_cond_destroy(&COND_state);
+  MYSQL_MUTEX_DESTROY(&LOCK_scheduler_state);
+  MYSQL_COND_DESTROY(&COND_state);
 }
 
 
@@ -427,11 +427,11 @@ Event_scheduler::start()
     THD_SET_PROC_INFO(new_thd, "Clearing");
     DBUG_ASSERT(new_thd->net.buff != 0);
     net_end(&new_thd->net);
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thread_count--;
     thread_running--;
     delete new_thd;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
 end:
   UNLOCK_DATA();
@@ -499,7 +499,7 @@ Event_scheduler::run(THD *thd)
   scheduler_thd= NULL;
   state= INITIALIZED;
   DBUG_PRINT("info", ("Signalling back to the stopper COND_state"));
-  pthread_cond_signal(&COND_state);
+  MYSQL_COND_SIGNAL(&COND_state);
   UNLOCK_DATA();
 
   DBUG_RETURN(res);
@@ -559,11 +559,11 @@ error:
     THD_SET_PROC_INFO(new_thd, "Clearing");
     DBUG_ASSERT(new_thd->net.buff != 0);
     net_end(&new_thd->net);
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thread_count--;
     thread_running--;
     delete new_thd;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
   delete event_name;
   DBUG_RETURN(TRUE);
@@ -643,13 +643,13 @@ Event_scheduler::stop()
     DBUG_PRINT("info", ("Scheduler thread has id %lu",
                         scheduler_thd->thread_id));
     /* Lock from delete */
-    pthread_mutex_lock(&scheduler_thd->LOCK_delete);
+    MYSQL_MUTEX_LOCK(&scheduler_thd->LOCK_delete);
     /* This will wake up the thread if it waits on Queue's conditional */
     sql_print_information("Event Scheduler: Killing the scheduler thread, "
                           "thread id %lu",
                           scheduler_thd->thread_id);
     scheduler_thd->awake(THD::KILL_CONNECTION);
-    pthread_mutex_unlock(&scheduler_thd->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&scheduler_thd->LOCK_delete);
 
     /* thd could be 0x0, when shutting down */
     sql_print_information("Event Scheduler: "
@@ -678,12 +678,12 @@ Event_scheduler::workers_count()
   uint count= 0;
 
   DBUG_ENTER("Event_scheduler::workers_count");
-  pthread_mutex_lock(&LOCK_thread_count);       // For unlink from list
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);       // For unlink from list
   I_List_iterator<THD> it(threads);
   while ((tmp=it++))
     if (tmp->system_thread == SYSTEM_THREAD_EVENT_WORKER)
       ++count;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_PRINT("exit", ("%d", count));
   DBUG_RETURN(count);
 }
@@ -704,7 +704,7 @@ Event_scheduler::lock_data(const char *f
 {
   DBUG_ENTER("Event_scheduler::lock_data");
   DBUG_PRINT("enter", ("func=%s line=%u", func, line));
-  pthread_mutex_lock(&LOCK_scheduler_state);
+  MYSQL_MUTEX_LOCK(&LOCK_scheduler_state);
   mutex_last_locked_in_func= func;
   mutex_last_locked_at_line= line;
   mutex_scheduler_data_locked= TRUE;
@@ -730,18 +730,18 @@ Event_scheduler::unlock_data(const char 
   mutex_last_unlocked_at_line= line;
   mutex_scheduler_data_locked= FALSE;
   mutex_last_unlocked_in_func= func;
-  pthread_mutex_unlock(&LOCK_scheduler_state);
+  MYSQL_MUTEX_UNLOCK(&LOCK_scheduler_state);
   DBUG_VOID_RETURN;
 }
 
 
 /*
-  Wrapper for pthread_cond_wait/timedwait
+  Wrapper for MYSQL_COND_WAIT/timedwait
 
   SYNOPSIS
     Event_scheduler::cond_wait()
       thd     Thread (Could be NULL during shutdown procedure)
-      abstime If not null then call pthread_cond_timedwait()
+      abstime If not null then call MYSQL_COND_TIMEDWAIT()
       msg     Message for thd->proc_info
       func    Which function is requesting cond_wait
       line    On which line cond_wait is requested
@@ -761,9 +761,9 @@ Event_scheduler::cond_wait(THD *thd, str
 
   DBUG_PRINT("info", ("pthread_cond_%swait", abstime? "timed":""));
   if (!abstime)
-    pthread_cond_wait(&COND_state, &LOCK_scheduler_state);
+    MYSQL_COND_WAIT(&COND_state, &LOCK_scheduler_state);
   else
-    pthread_cond_timedwait(&COND_state, &LOCK_scheduler_state, abstime);
+    MYSQL_COND_TIMEDWAIT(&COND_state, &LOCK_scheduler_state, abstime);
   if (thd)
   {
     /*

=== modified file 'sql/event_scheduler.h'
--- a/sql/event_scheduler.h	2007-08-15 15:08:44 +0000
+++ b/sql/event_scheduler.h	2008-10-10 20:34:55 +0000
@@ -65,6 +65,10 @@ private:
   static Event_db_repository *db_repository;
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_scheduler_state;
+extern PSI_cond_key key_Event_scheduler_COND_state;
+#endif
 
 class Event_scheduler
 {
@@ -115,7 +119,7 @@ private:
   cond_wait(THD *thd, struct timespec *abstime, const char* msg,
             const char *func, uint line);
 
-  pthread_mutex_t LOCK_scheduler_state;
+  mysql_mutex_t LOCK_scheduler_state;
 
   enum enum_state
   {
@@ -129,7 +133,7 @@ private:
 
   THD *scheduler_thd;
 
-  pthread_cond_t COND_state;
+  mysql_cond_t COND_state;
 
   Event_queue *queue;
 

=== modified file 'sql/events.cc'
--- a/sql/events.cc	2008-08-07 17:52:43 +0000
+++ b/sql/events.cc	2008-10-10 20:34:55 +0000
@@ -100,7 +100,7 @@ Event_scheduler *Events::scheduler;
 Event_db_repository *Events::db_repository;
 enum Events::enum_opt_event_scheduler
 Events::opt_event_scheduler= Events::EVENTS_OFF;
-pthread_mutex_t Events::LOCK_event_metadata;
+mysql_mutex_t Events::LOCK_event_metadata;
 bool Events::check_system_tables_error= FALSE;
 
 
@@ -181,9 +181,9 @@ Events::get_opt_event_scheduler_str()
 {
   const char *str;
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
   str= opt_typelib.type_names[(int) opt_event_scheduler];
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
 
   return str;
 }
@@ -396,7 +396,7 @@ Events::create_event(THD *thd, Event_par
   if (thd->current_stmt_binlog_row_based)
     thd->clear_current_stmt_binlog_row_based();
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
 
   /* On error conditions my_error() is called so no need to handle here */
   if (!(ret= db_repository->create_event(thd, parse_data, if_not_exists)))
@@ -424,7 +424,7 @@ Events::create_event(THD *thd, Event_par
       write_bin_log(thd, TRUE, thd->query, thd->query_length);
     }
   }
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
 
   DBUG_RETURN(ret);
 }
@@ -505,7 +505,7 @@ Events::update_event(THD *thd, Event_par
   if (thd->current_stmt_binlog_row_based)
     thd->clear_current_stmt_binlog_row_based();
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
 
   /* On error conditions my_error() is called so no need to handle here */
   if (!(ret= db_repository->update_event(thd, parse_data,
@@ -538,7 +538,7 @@ Events::update_event(THD *thd, Event_par
       write_bin_log(thd, TRUE, thd->query, thd->query_length);
     }
   }
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
 
   DBUG_RETURN(ret);
 }
@@ -588,7 +588,7 @@ Events::drop_event(THD *thd, LEX_STRING 
   if (thd->current_stmt_binlog_row_based)
     thd->clear_current_stmt_binlog_row_based();
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
   /* On error conditions my_error() is called so no need to handle here */
   if (!(ret= db_repository->drop_event(thd, dbname, name, if_exists)))
   {
@@ -598,7 +598,7 @@ Events::drop_event(THD *thd, LEX_STRING 
     DBUG_ASSERT(thd->query && thd->query_length);
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   }
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
   DBUG_RETURN(ret);
 }
 
@@ -627,11 +627,11 @@ Events::drop_schema_events(THD *thd, cha
     are damaged, as intended.
   */
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
   if (event_queue)
     event_queue->drop_schema_events(thd, db_lex);
   db_repository->drop_schema_events(thd, db_lex);
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
 
   DBUG_VOID_RETURN;
 }
@@ -965,7 +965,7 @@ Events::deinit()
 void
 Events::init_mutexes()
 {
-  pthread_mutex_init(&LOCK_event_metadata, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_event_metadata, key_LOCK_event_metadata, MY_MUTEX_INIT_FAST);
 }
 
 
@@ -979,7 +979,7 @@ Events::init_mutexes()
 void
 Events::destroy_mutexes()
 {
-  pthread_mutex_destroy(&LOCK_event_metadata);
+  MYSQL_MUTEX_DESTROY(&LOCK_event_metadata);
 }
 
 
@@ -1001,7 +1001,7 @@ Events::dump_internal_status()
   puts("LLA = Last Locked At  LUA = Last Unlocked At");
   puts("WOC = Waiting On Condition  DL = Data Locked");
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
   if (opt_event_scheduler == EVENTS_DISABLED)
     puts("The Event Scheduler is disabled");
   else
@@ -1010,7 +1010,7 @@ Events::dump_internal_status()
     event_queue->dump_internal_status();
   }
 
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
   DBUG_VOID_RETURN;
 }
 
@@ -1040,7 +1040,7 @@ Events::switch_event_scheduler_state(enu
   if (check_if_system_tables_error())
     DBUG_RETURN(TRUE);
 
-  pthread_mutex_lock(&LOCK_event_metadata);
+  MYSQL_MUTEX_LOCK(&LOCK_event_metadata);
 
   if (opt_event_scheduler == EVENTS_DISABLED)
   {
@@ -1064,7 +1064,7 @@ Events::switch_event_scheduler_state(enu
   opt_event_scheduler= new_state;
 
 end:
-  pthread_mutex_unlock(&LOCK_event_metadata);
+  MYSQL_MUTEX_UNLOCK(&LOCK_event_metadata);
   DBUG_RETURN(ret);
 }
 

=== modified file 'sql/events.h'
--- a/sql/events.h	2007-08-15 15:08:44 +0000
+++ b/sql/events.h	2008-10-10 20:34:55 +0000
@@ -67,6 +67,10 @@ sortcmp_lex_string(LEX_STRING s, LEX_STR
   subsystems (ACL, time zone tables, etc).
 */
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_event_metadata;
+#endif
+
 class Events
 {
 public:
@@ -142,7 +146,7 @@ private:
 private:
   /* Command line option names */
   static const TYPELIB opt_typelib;
-  static pthread_mutex_t LOCK_event_metadata;
+  static mysql_mutex_t LOCK_event_metadata;
   static Event_queue         *event_queue;
   static Event_scheduler     *scheduler;
   static Event_db_repository *db_repository;

=== modified file 'sql/ha_ndbcluster.cc'
--- a/sql/ha_ndbcluster.cc	2008-07-31 18:41:00 +0000
+++ b/sql/ha_ndbcluster.cc	2008-10-10 20:34:55 +0000
@@ -141,8 +141,12 @@ extern Ndb* g_ndb;
 
 uchar g_node_id_map[max_ndb_nodes];
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_ndbcluster_mutex;
+#endif
+
 /// Handler synchronization
-pthread_mutex_t ndbcluster_mutex;
+mysql_mutex_t ndbcluster_mutex;
 
 /// Table lock handling
 HASH ndbcluster_open_tables;
@@ -161,9 +165,16 @@ static int ndb_get_table_statistics(ha_n
 // Util thread variables
 pthread_t ndb_util_thread;
 int ndb_util_thread_running= 0;
-pthread_mutex_t LOCK_ndb_util_thread;
-pthread_cond_t COND_ndb_util_thread;
-pthread_cond_t COND_ndb_util_ready;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_ndb_util_thread;
+PSI_cond_key key_COND_ndb_util_thread;
+PSI_cond_key key_COND_ndb_util_ready;
+#endif
+
+mysql_mutex_t LOCK_ndb_util_thread;
+mysql_cond_t COND_ndb_util_thread;
+mysql_cond_t COND_ndb_util_ready;
 pthread_handler_t ndb_util_thread_func(void *arg);
 ulong ndb_cache_check_time;
 
@@ -5027,11 +5038,11 @@ int ha_ndbcluster::external_lock(THD *th
         thd_ndb->changed_tables.push_back(m_share, &thd->transaction.mem_root);
       }
 
-      pthread_mutex_lock(&m_share->mutex);
+      MYSQL_MUTEX_LOCK(&m_share->mutex);
       DBUG_PRINT("info", ("Invalidating commit_count"));
       m_share->commit_count= 0;
       m_share->commit_count_lock++;
-      pthread_mutex_unlock(&m_share->mutex);
+      MYSQL_MUTEX_UNLOCK(&m_share->mutex);
     }
 
     if (!--thd_ndb->lock_count)
@@ -5209,12 +5220,12 @@ static int ndbcluster_commit(handlerton 
   List_iterator_fast<NDB_SHARE> it(thd_ndb->changed_tables);
   while ((share= it++))
   {
-    pthread_mutex_lock(&share->mutex);
+    MYSQL_MUTEX_LOCK(&share->mutex);
     DBUG_PRINT("info", ("Invalidate commit_count for %s, share->commit_count: %lu",
                         share->table_name, (ulong) share->commit_count));
     share->commit_count= 0;
     share->commit_count_lock++;
-    pthread_mutex_unlock(&share->mutex);
+    MYSQL_MUTEX_UNLOCK(&share->mutex);
   }
   thd_ndb->changed_tables.empty();
 
@@ -6025,7 +6036,7 @@ int ha_ndbcluster::create(const char *na
   if (!my_errno)
   {
     NDB_SHARE *share= 0;
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
     /*
       First make sure we get a "fresh" share here, not an old trailing one...
     */
@@ -6050,7 +6061,7 @@ int ha_ndbcluster::create(const char *na
       DBUG_PRINT("NDB_SHARE", ("%s binlog create  use_count: %u",
                                share->key, share->use_count));
     }
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
     while (!IS_TMP_PREFIX(m_tabname))
     {
@@ -6651,7 +6662,7 @@ retry_temporary_error1:
     /* the drop table failed for some reason, drop the share anyways */
     if (share)
     {
-      pthread_mutex_lock(&ndbcluster_mutex);
+      MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
       if (share->state != NSS_DROPPED)
       {
         /*
@@ -6667,7 +6678,7 @@ retry_temporary_error1:
       DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
                                share->key, share->use_count));
       free_share(&share, TRUE);
-      pthread_mutex_unlock(&ndbcluster_mutex);
+      MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
     }
 #endif
     DBUG_RETURN(res);
@@ -6702,7 +6713,7 @@ retry_temporary_error1:
 
   if (share)
   {
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
     if (share->state != NSS_DROPPED)
     {
       /*
@@ -6718,7 +6729,7 @@ retry_temporary_error1:
     DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
                              share->key, share->use_count));
     free_share(&share, TRUE);
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   }
 #endif
   DBUG_RETURN(0);
@@ -7417,7 +7428,7 @@ int ndbcluster_drop_database_impl(THD *t
   while ((tabname=it++))
   {
     tablename_to_filename(tabname, tmp, FN_REFLEN - (tmp - full_path)-1);
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     if (ha_ndbcluster::delete_table(thd, 0, ndb, full_path, dbname, tabname))
     {
       const NdbError err= dict->getNdbError();
@@ -7427,7 +7438,7 @@ int ndbcluster_drop_database_impl(THD *t
         ret= ndb_to_mysql_error(&err);
       }
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
   }
   DBUG_RETURN(ret);      
 }
@@ -7580,7 +7591,7 @@ int ndbcluster_find_all_files(THD *thd)
       my_free((char*) data, MYF(MY_ALLOW_ZERO_PTR));
       my_free((char*) pack_data, MYF(MY_ALLOW_ZERO_PTR));
 
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       if (discover)
       {
         /* ToDo 4.1 database needs to be created if missing */
@@ -7598,7 +7609,7 @@ int ndbcluster_find_all_files(THD *thd)
                                        TRUE);
       }
 #endif
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
     }
   }
   while (unhandled && retries);
@@ -7689,19 +7700,19 @@ int ndbcluster_find_files(handlerton *ht
       build_table_filename(name, sizeof(name), db, file_name->str, reg_ext, 0);
       if (my_access(name, F_OK))
       {
-        pthread_mutex_lock(&LOCK_open);
+        MYSQL_MUTEX_LOCK(&LOCK_open);
         DBUG_PRINT("info", ("Table %s listed and need discovery",
                             file_name->str));
         if (ndb_create_table_from_engine(thd, db, file_name->str))
         {
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
           push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                               ER_TABLE_EXISTS_ERROR,
                               "Discover of table %s.%s failed",
                               db, file_name->str);
           continue;
         }
-        pthread_mutex_unlock(&LOCK_open);
+        MYSQL_MUTEX_UNLOCK(&LOCK_open);
       }
       DBUG_PRINT("info", ("%s existed in NDB _and_ on disk ", file_name->str));
       file_on_disk= TRUE;
@@ -7757,10 +7768,10 @@ int ndbcluster_find_files(handlerton *ht
       file_name_str= (char*)hash_element(&ok_tables, i);
       end= end1 +
         tablename_to_filename(file_name_str, end1, sizeof(name) - (end1 - name));
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       ndbcluster_create_binlog_setup(thd, ndb, name, end-name,
                                      db, file_name_str, TRUE);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
     }
   }
 #endif
@@ -7824,7 +7835,7 @@ int ndbcluster_find_files(handlerton *ht
   thd->restore_backup_open_tables_state(&open_tables_state_backup);
 
   /* Lock mutex before creating .FRM files. */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   /* Create new files. */
   List_iterator_fast<char> it2(create_list);
   while ((file_name_str=it2++))
@@ -7839,7 +7850,7 @@ int ndbcluster_find_files(handlerton *ht
     }
   }
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   hash_free(&ok_tables);
   hash_free(&ndb_tables);
@@ -7873,7 +7884,7 @@ int ndbcluster_find_files(handlerton *ht
 /* Call back after cluster connect */
 static int connect_callback()
 {
-  pthread_mutex_lock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
   update_status_variables(&g_ndb_status,
                           g_ndb_cluster_connection);
 
@@ -7883,13 +7894,13 @@ static int connect_callback()
   while ((node_id= g_ndb_cluster_connection->get_next_node(node_iter)))
     g_node_id_map[node_id]= i++;
 
-  pthread_cond_signal(&COND_ndb_util_thread);
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+  MYSQL_COND_SIGNAL(&COND_ndb_util_thread);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
   return 0;
 }
 
 extern int ndb_dictionary_is_mysqld;
-extern pthread_mutex_t LOCK_plugin;
+extern mysql_mutex_t LOCK_plugin;
 
 static int ndbcluster_init(void *p)
 {
@@ -7903,12 +7914,12 @@ static int ndbcluster_init(void *p)
     plugin initialization code. Release it to avoid deadlocks.  It's safe, as
     there're no threads that may concurrently access plugin control structures.
   */
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
-  pthread_mutex_init(&ndbcluster_mutex,MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&LOCK_ndb_util_thread, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_ndb_util_thread, NULL);
-  pthread_cond_init(&COND_ndb_util_ready, NULL);
+  MYSQL_MUTEX_INIT(&ndbcluster_mutex, key_ndbcluster_mutex, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_ndb_util_thread, key_LOCK_ndb_util_thread, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_ndb_util_thread, key_COND_ndb_util_thread, NULL);
+  MYSQL_COND_INIT(&COND_ndb_util_ready, key_COND_ndb_util_ready, NULL);
   ndb_util_thread_running= -1;
   ndbcluster_terminating= 0;
   ndb_dictionary_is_mysqld= 1;
@@ -7961,31 +7972,31 @@ static int ndbcluster_init(void *p)
   {
     DBUG_PRINT("error", ("Could not create ndb utility thread"));
     hash_free(&ndbcluster_open_tables);
-    pthread_mutex_destroy(&ndbcluster_mutex);
-    pthread_mutex_destroy(&LOCK_ndb_util_thread);
-    pthread_cond_destroy(&COND_ndb_util_thread);
-    pthread_cond_destroy(&COND_ndb_util_ready);
+    MYSQL_MUTEX_DESTROY(&ndbcluster_mutex);
+    MYSQL_MUTEX_DESTROY(&LOCK_ndb_util_thread);
+    MYSQL_COND_DESTROY(&COND_ndb_util_thread);
+    MYSQL_COND_DESTROY(&COND_ndb_util_ready);
     goto ndbcluster_init_error;
   }
 
   /* Wait for the util thread to start */
-  pthread_mutex_lock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
   while (ndb_util_thread_running < 0)
-    pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+    MYSQL_COND_WAIT(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
   
   if (!ndb_util_thread_running)
   {
     DBUG_PRINT("error", ("ndb utility thread exited prematurely"));
     hash_free(&ndbcluster_open_tables);
-    pthread_mutex_destroy(&ndbcluster_mutex);
-    pthread_mutex_destroy(&LOCK_ndb_util_thread);
-    pthread_cond_destroy(&COND_ndb_util_thread);
-    pthread_cond_destroy(&COND_ndb_util_ready);
+    MYSQL_MUTEX_DESTROY(&ndbcluster_mutex);
+    MYSQL_MUTEX_DESTROY(&LOCK_ndb_util_thread);
+    MYSQL_COND_DESTROY(&COND_ndb_util_thread);
+    MYSQL_COND_DESTROY(&COND_ndb_util_ready);
     goto ndbcluster_init_error;
   }
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
   ndbcluster_inited= 1;
   DBUG_RETURN(FALSE);
@@ -7995,7 +8006,7 @@ ndbcluster_init_error:
   ndbcluster_disconnect();
   ndbcluster_hton->state= SHOW_OPTION_DISABLED;               // If we couldn't use handler
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
   DBUG_RETURN(TRUE);
 }
@@ -8010,17 +8021,17 @@ static int ndbcluster_end(handlerton *ht
 
   /* wait for util thread to finish */
   sql_print_information("Stopping Cluster Utility thread");
-  pthread_mutex_lock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
   ndbcluster_terminating= 1;
-  pthread_cond_signal(&COND_ndb_util_thread);
+  MYSQL_COND_SIGNAL(&COND_ndb_util_thread);
   while (ndb_util_thread_running > 0)
-    pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+    MYSQL_COND_WAIT(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
 
 
 #ifdef HAVE_NDB_BINLOG
   {
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
     while (ndbcluster_open_tables.records)
     {
       NDB_SHARE *share=
@@ -8031,7 +8042,7 @@ static int ndbcluster_end(handlerton *ht
 #endif
       ndbcluster_real_free_share(&share);
     }
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   }
 #endif
   hash_free(&ndbcluster_open_tables);
@@ -8057,10 +8068,10 @@ static int ndbcluster_end(handlerton *ht
   // cleanup ndb interface
   ndb_end_internal();
 
-  pthread_mutex_destroy(&ndbcluster_mutex);
-  pthread_mutex_destroy(&LOCK_ndb_util_thread);
-  pthread_cond_destroy(&COND_ndb_util_thread);
-  pthread_cond_destroy(&COND_ndb_util_ready);
+  MYSQL_MUTEX_DESTROY(&ndbcluster_mutex);
+  MYSQL_MUTEX_DESTROY(&LOCK_ndb_util_thread);
+  MYSQL_COND_DESTROY(&COND_ndb_util_thread);
+  MYSQL_COND_DESTROY(&COND_ndb_util_ready);
   DBUG_RETURN(0);
 }
 
@@ -8361,12 +8372,12 @@ uint ndb_get_commitcount(THD *thd, char 
 
   build_table_filename(name, sizeof(name), dbname, tabname, "", 0);
   DBUG_PRINT("enter", ("name: %s", name));
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   if (!(share=(NDB_SHARE*) hash_search(&ndbcluster_open_tables,
                                        (uchar*) name,
                                        strlen(name))))
   {
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
     DBUG_PRINT("info", ("Table %s not found in ndbcluster_open_tables", name));
     DBUG_RETURN(1);
   }
@@ -8374,9 +8385,9 @@ uint ndb_get_commitcount(THD *thd, char 
   share->use_count++;
   DBUG_PRINT("NDB_SHARE", ("%s temporary  use_count: %u",
                            share->key, share->use_count));
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
-  pthread_mutex_lock(&share->mutex);
+  MYSQL_MUTEX_LOCK(&share->mutex);
   if (ndb_cache_check_time > 0)
   {
     if (share->commit_count != 0)
@@ -8387,7 +8398,7 @@ uint ndb_get_commitcount(THD *thd, char 
 #endif
       DBUG_PRINT("info", ("Getting commit_count: %s from share",
                           llstr(share->commit_count, buff)));
-      pthread_mutex_unlock(&share->mutex);
+      MYSQL_MUTEX_UNLOCK(&share->mutex);
       /* ndb_share reference temporary free */
       DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
                                share->key, share->use_count));
@@ -8404,7 +8415,7 @@ uint ndb_get_commitcount(THD *thd, char 
     ERR_RETURN(ndb->getNdbError());
   }
   uint lock= share->commit_count_lock;
-  pthread_mutex_unlock(&share->mutex);
+  MYSQL_MUTEX_UNLOCK(&share->mutex);
 
   struct Ndb_statistics stat;
   {
@@ -8420,7 +8431,7 @@ uint ndb_get_commitcount(THD *thd, char 
     }
   }
 
-  pthread_mutex_lock(&share->mutex);
+  MYSQL_MUTEX_LOCK(&share->mutex);
   if (share->commit_count_lock == lock)
   {
 #ifndef DBUG_OFF
@@ -8436,7 +8447,7 @@ uint ndb_get_commitcount(THD *thd, char 
     DBUG_PRINT("info", ("Discarding commit_count, comit_count_lock changed"));
     *commit_count= 0;
   }
-  pthread_mutex_unlock(&share->mutex);
+  MYSQL_MUTEX_UNLOCK(&share->mutex);
   /* ndb_share reference temporary free */
   DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
                            share->key, share->use_count));
@@ -8659,7 +8670,7 @@ static void print_ndbcluster_open_tables
   to avoid segmentation faults.  There is a risk that the memory for
   this trailing share leaks.
   
-  Must be called with previous pthread_mutex_lock(&ndbcluster_mutex)
+  Must be called with previous MYSQL_MUTEX_LOCK(&ndbcluster_mutex)
 */
 int handle_trailing_share(THD *thd, NDB_SHARE *share, int have_lock_open)
 {
@@ -8672,21 +8683,21 @@ int handle_trailing_share(THD *thd, NDB_
     sql_print_information ("handle_trailing_share: %s use_count: %u", share->key, share->use_count);
   DBUG_PRINT("NDB_SHARE", ("%s temporary  use_count: %u",
                            share->key, share->use_count));
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
   TABLE_LIST table_list;
   bzero((char*) &table_list,sizeof(table_list));
   table_list.db= share->db;
   table_list.alias= table_list.table_name= share->table_name;
   if (have_lock_open)
-    safe_mutex_assert_owner(&LOCK_open);
+    MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
   else
-    pthread_mutex_lock(&LOCK_open);    
+    MYSQL_MUTEX_LOCK(&LOCK_open);    
   close_cached_tables(thd, &table_list, TRUE, FALSE);
   if (!have_lock_open)
-    pthread_mutex_unlock(&LOCK_open);    
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);    
 
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   /* ndb_share reference temporary free */
   DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
                            share->key, share->use_count));
@@ -8802,7 +8813,7 @@ int ndbcluster_undo_rename_share(THD *th
 int ndbcluster_rename_share(THD *thd, NDB_SHARE *share, int have_lock_open)
 {
   NDB_SHARE *tmp;
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   uint new_length= (uint) strlen(share->new_key);
   DBUG_PRINT("ndbcluster_rename_share", ("old_key: %s  old__length: %d",
                               share->key, share->key_length));
@@ -8835,7 +8846,7 @@ int ndbcluster_rename_share(THD *thd, ND
                            share->key));
     }
     dbug_print_open_tables();
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
     return -1;
   }
   dbug_print_open_tables();
@@ -8865,7 +8876,7 @@ int ndbcluster_rename_share(THD *thd, ND
   if (ndb_extra_logging > 9)
     sql_print_information ("ndbcluster_rename_share: %s-%s use_count: %u", old_key, share->key, share->use_count);
 
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   return 0;
 }
 #endif
@@ -8876,14 +8887,14 @@ int ndbcluster_rename_share(THD *thd, ND
 */
 NDB_SHARE *ndbcluster_get_share(NDB_SHARE *share)
 {
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   share->use_count++;
 
   dbug_print_open_tables();
   dbug_print_share("ndbcluster_get_share:", share);
   if (ndb_extra_logging > 9)
     sql_print_information ("ndbcluster_get_share: %s use_count: %u", share->key, share->use_count);
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   return share;
 }
 
@@ -8900,7 +8911,7 @@ NDB_SHARE *ndbcluster_get_share(NDB_SHAR
   create_if_not_exists == FALSE:
     returns 0 if share does not exist
 
-  have_lock == TRUE, pthread_mutex_lock(&ndbcluster_mutex) already taken
+  have_lock == TRUE, MYSQL_MUTEX_LOCK(&ndbcluster_mutex) already taken
 */
 
 NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
@@ -8913,7 +8924,7 @@ NDB_SHARE *ndbcluster_get_share(const ch
   DBUG_PRINT("enter", ("key: '%s'", key));
 
   if (!have_lock)
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   if (!(share= (NDB_SHARE*) hash_search(&ndbcluster_open_tables,
                                         (uchar*) key,
                                         length)))
@@ -8922,7 +8933,7 @@ NDB_SHARE *ndbcluster_get_share(const ch
     {
       DBUG_PRINT("error", ("get_share: %s does not exist", key));
       if (!have_lock)
-        pthread_mutex_unlock(&ndbcluster_mutex);
+        MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
       DBUG_RETURN(0);
     }
     if ((share= (NDB_SHARE*) my_malloc(sizeof(*share),
@@ -8944,11 +8955,11 @@ NDB_SHARE *ndbcluster_get_share(const ch
         my_free((uchar*) share, 0);
         *root_ptr= old_root;
         if (!have_lock)
-          pthread_mutex_unlock(&ndbcluster_mutex);
+          MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
         DBUG_RETURN(0);
       }
       thr_lock_init(&share->lock);
-      pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
+      MYSQL_MUTEX_INIT(&share->mutex, key_NDB_SHARE_mutex, MY_MUTEX_INIT_FAST);
       share->commit_count= 0;
       share->commit_count_lock= 0;
       share->db= share->key + length + 1;
@@ -8962,7 +8973,7 @@ NDB_SHARE *ndbcluster_get_share(const ch
         ndbcluster_real_free_share(&share);
         *root_ptr= old_root;
         if (!have_lock)
-          pthread_mutex_unlock(&ndbcluster_mutex);
+          MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
         DBUG_RETURN(0);
       }
 #endif
@@ -8972,7 +8983,7 @@ NDB_SHARE *ndbcluster_get_share(const ch
     {
       DBUG_PRINT("error", ("get_share: failed to alloc share"));
       if (!have_lock)
-        pthread_mutex_unlock(&ndbcluster_mutex);
+        MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
       my_error(ER_OUTOFMEMORY, MYF(0), sizeof(*share));
       DBUG_RETURN(0);
     }
@@ -8984,7 +8995,7 @@ NDB_SHARE *ndbcluster_get_share(const ch
   dbug_print_open_tables();
   dbug_print_share("ndbcluster_get_share:", share);
   if (!have_lock)
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   DBUG_RETURN(share);
 }
 
@@ -8999,7 +9010,7 @@ void ndbcluster_real_free_share(NDB_SHAR
 
   hash_delete(&ndbcluster_open_tables, (uchar*) *share);
   thr_lock_delete(&(*share)->lock);
-  pthread_mutex_destroy(&(*share)->mutex);
+  MYSQL_MUTEX_DESTROY(&(*share)->mutex);
 
 #ifdef HAVE_NDB_BINLOG
   (*share)->new_op= 0;
@@ -9021,7 +9032,7 @@ void ndbcluster_real_free_share(NDB_SHAR
 void ndbcluster_free_share(NDB_SHARE **share, bool have_lock)
 {
   if (!have_lock)
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   if (!--(*share)->use_count)
   {
     if (ndb_extra_logging > 9)
@@ -9036,7 +9047,7 @@ void ndbcluster_free_share(NDB_SHARE **s
     dbug_print_share("ndbcluster_free_share:", *share);
   }
   if (!have_lock)
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 }
 
 
@@ -9067,16 +9078,16 @@ int ha_ndbcluster::update_stats(THD *thd
     }
     if (m_share)
     {
-      pthread_mutex_lock(&m_share->mutex);
+      MYSQL_MUTEX_LOCK(&m_share->mutex);
       m_share->stat= stat;
-      pthread_mutex_unlock(&m_share->mutex);
+      MYSQL_MUTEX_UNLOCK(&m_share->mutex);
     }
   }
   else
   {
-    pthread_mutex_lock(&m_share->mutex);
+    MYSQL_MUTEX_LOCK(&m_share->mutex);
     stat= m_share->stat;
-    pthread_mutex_unlock(&m_share->mutex);
+    MYSQL_MUTEX_UNLOCK(&m_share->mutex);
   }
   struct Ndb_local_table_statistics *local_info= m_table_info;
   int no_uncommitted_rows_count;
@@ -9993,7 +10004,7 @@ pthread_handler_t ndb_util_thread_func(v
   DBUG_ENTER("ndb_util_thread");
   DBUG_PRINT("enter", ("ndb_cache_check_time: %lu", ndb_cache_check_time));
  
-   pthread_mutex_lock(&LOCK_ndb_util_thread);
+   MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
 
   thd= new THD; /* note that contructor of THD uses DBUG_ */
   if (thd == NULL)
@@ -10027,45 +10038,45 @@ pthread_handler_t ndb_util_thread_func(v
 
   /* Signal successful initialization */
   ndb_util_thread_running= 1;
-  pthread_cond_signal(&COND_ndb_util_ready);
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+  MYSQL_COND_SIGNAL(&COND_ndb_util_ready);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
 
   /*
     wait for mysql server to start
   */
-  pthread_mutex_lock(&LOCK_server_started);
+  MYSQL_MUTEX_LOCK(&LOCK_server_started);
   while (!mysqld_server_started)
   {
     set_timespec(abstime, 1);
-    pthread_cond_timedwait(&COND_server_started, &LOCK_server_started,
+    MYSQL_COND_TIMEDWAIT(&COND_server_started, &LOCK_server_started,
 	                       &abstime);
     if (ndbcluster_terminating)
     {
-      pthread_mutex_unlock(&LOCK_server_started);
-      pthread_mutex_lock(&LOCK_ndb_util_thread);
+      MYSQL_MUTEX_UNLOCK(&LOCK_server_started);
+      MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
       goto ndb_util_thread_end;
     }
   }
-  pthread_mutex_unlock(&LOCK_server_started);
+  MYSQL_MUTEX_UNLOCK(&LOCK_server_started);
 
   /*
     Wait for cluster to start
   */
-  pthread_mutex_lock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
   while (!g_ndb_status.cluster_node_id && (ndbcluster_hton->slot != ~(uint)0))
   {
     /* ndb not connected yet */
-    pthread_cond_wait(&COND_ndb_util_thread, &LOCK_ndb_util_thread);
+    MYSQL_COND_WAIT(&COND_ndb_util_thread, &LOCK_ndb_util_thread);
     if (ndbcluster_terminating)
       goto ndb_util_thread_end;
   }
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
 
   /* Get thd_ndb for this thread */
   if (!(thd_ndb= ha_ndbcluster::seize_thd_ndb()))
   {
     sql_print_error("Could not allocate Thd_ndb object");
-    pthread_mutex_lock(&LOCK_ndb_util_thread);
+    MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
     goto ndb_util_thread_end;
   }
   set_thd_ndb(thd, thd_ndb);
@@ -10086,14 +10097,14 @@ pthread_handler_t ndb_util_thread_func(v
   set_timespec(abstime, 0);
   for (;;)
   {
-    pthread_mutex_lock(&LOCK_ndb_util_thread);
+    MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
     if (!ndbcluster_terminating)
-      pthread_cond_timedwait(&COND_ndb_util_thread,
+      MYSQL_COND_TIMEDWAIT(&COND_ndb_util_thread,
                              &LOCK_ndb_util_thread,
                              &abstime);
     if (ndbcluster_terminating) /* Shutting down server */
       goto ndb_util_thread_end;
-    pthread_mutex_unlock(&LOCK_ndb_util_thread);
+    MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
 #ifdef NDB_EXTRA_DEBUG_UTIL_THREAD
     DBUG_PRINT("ndb_util_thread", ("Started, ndb_cache_check_time: %lu",
                                    ndb_cache_check_time));
@@ -10118,7 +10129,7 @@ pthread_handler_t ndb_util_thread_func(v
 
     /* Lock mutex and fill list with pointers to all open tables */
     NDB_SHARE *share;
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
     uint i, open_count, record_count= ndbcluster_open_tables.records;
     if (share_list_size < record_count)
     {
@@ -10127,7 +10138,7 @@ pthread_handler_t ndb_util_thread_func(v
       {
         sql_print_warning("ndb util thread: malloc failure, "
                           "query cache not maintained properly");
-        pthread_mutex_unlock(&ndbcluster_mutex);
+        MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
         goto next;                               // At least do not crash
       }
       delete [] share_list;
@@ -10153,7 +10164,7 @@ pthread_handler_t ndb_util_thread_func(v
       /* Store pointer to table */
       share_list[open_count++]= share;
     }
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
     /* Iterate through the open files list */
     for (i= 0; i < open_count; i++)
@@ -10178,9 +10189,9 @@ pthread_handler_t ndb_util_thread_func(v
 
       struct Ndb_statistics stat;
       uint lock;
-      pthread_mutex_lock(&share->mutex);
+      MYSQL_MUTEX_LOCK(&share->mutex);
       lock= share->commit_count_lock;
-      pthread_mutex_unlock(&share->mutex);
+      MYSQL_MUTEX_UNLOCK(&share->mutex);
       {
         /* Contact NDB to get commit count for table */
         Ndb* ndb= thd_ndb->ndb;
@@ -10211,10 +10222,10 @@ pthread_handler_t ndb_util_thread_func(v
         }
       }
   loop_next:
-      pthread_mutex_lock(&share->mutex);
+      MYSQL_MUTEX_LOCK(&share->mutex);
       if (share->commit_count_lock == lock)
         share->commit_count= stat.commit_count;
-      pthread_mutex_unlock(&share->mutex);
+      MYSQL_MUTEX_UNLOCK(&share->mutex);
 
       /* ndb_share reference temporary free */
       DBUG_PRINT("NDB_SHARE", ("%s temporary free  use_count: %u",
@@ -10244,7 +10255,7 @@ next:
     }
   }
 
-  pthread_mutex_lock(&LOCK_ndb_util_thread);
+  MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
 
 ndb_util_thread_end:
   net_end(&thd->net);
@@ -10256,8 +10267,8 @@ ndb_util_thread_fail:
   
   /* signal termination */
   ndb_util_thread_running= 0;
-  pthread_cond_signal(&COND_ndb_util_ready);
-  pthread_mutex_unlock(&LOCK_ndb_util_thread);
+  MYSQL_COND_SIGNAL(&COND_ndb_util_ready);
+  MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
   DBUG_PRINT("exit", ("ndb_util_thread"));
   my_thread_end();
   pthread_exit(0);

=== modified file 'sql/ha_ndbcluster.h'
--- a/sql/ha_ndbcluster.h	2008-06-05 16:11:22 +0000
+++ b/sql/ha_ndbcluster.h	2008-10-10 20:34:55 +0000
@@ -138,11 +138,15 @@ struct Ndb_statistics {
   Uint64 fragment_memory;
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_NDB_SHARE_mutex;
+#endif
+
 typedef struct st_ndbcluster_share {
   NDB_SHARE_STATE state;
   MEM_ROOT mem_root;
   THR_LOCK lock;
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   char *key;
   uint key_length;
   char *new_key;
@@ -169,9 +173,9 @@ NDB_SHARE_STATE
 get_ndb_share_state(NDB_SHARE *share)
 {
   NDB_SHARE_STATE state;
-  pthread_mutex_lock(&share->mutex);
+  MYSQL_MUTEX_LOCK(&share->mutex);
   state= share->state;
-  pthread_mutex_unlock(&share->mutex);
+  MYSQL_MUTEX_UNLOCK(&share->mutex);
   return state;
 }
 
@@ -179,19 +183,19 @@ inline
 void
 set_ndb_share_state(NDB_SHARE *share, NDB_SHARE_STATE state)
 {
-  pthread_mutex_lock(&share->mutex);
+  MYSQL_MUTEX_LOCK(&share->mutex);
   share->state= state;
-  pthread_mutex_unlock(&share->mutex);
+  MYSQL_MUTEX_UNLOCK(&share->mutex);
 }
 
 struct Ndb_tuple_id_range_guard {
   Ndb_tuple_id_range_guard(NDB_SHARE* _share) :
     share(_share),
     range(share->tuple_id_range) {
-    pthread_mutex_lock(&share->mutex);
+    MYSQL_MUTEX_LOCK(&share->mutex);
   }
   ~Ndb_tuple_id_range_guard() {
-    pthread_mutex_unlock(&share->mutex);
+    MYSQL_MUTEX_UNLOCK(&share->mutex);
   }
   NDB_SHARE* share;
   Ndb::TupleIdRange& range;
@@ -762,4 +766,4 @@ static const char ndbcluster_hton_name[]
 static const int ndbcluster_hton_name_length=sizeof(ndbcluster_hton_name)-1;
 extern int ndbcluster_terminating;
 extern int ndb_util_thread_running;
-extern pthread_cond_t COND_ndb_util_ready;
+extern mysql_cond_t COND_ndb_util_ready;

=== modified file 'sql/ha_ndbcluster_binlog.cc'
--- a/sql/ha_ndbcluster_binlog.cc	2008-07-14 12:49:19 +0000
+++ b/sql/ha_ndbcluster_binlog.cc	2008-10-10 20:34:55 +0000
@@ -82,7 +82,7 @@ THD *injector_thd= 0;
   to enable ndb injector thread receiving events.
 
   Must therefore always be used with a surrounding
-  pthread_mutex_lock(&injector_mutex), when doing create/dropEventOperation
+  MYSQL_MUTEX_LOCK(&injector_mutex), when doing create/dropEventOperation
 */
 static Ndb *injector_ndb= 0;
 static Ndb *schema_ndb= 0;
@@ -109,8 +109,14 @@ static int ndbcluster_binlog_terminating
   and injector thread
 */
 pthread_t ndb_binlog_thread;
-pthread_mutex_t injector_mutex;
-pthread_cond_t  injector_cond;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_injector_mutex;
+PSI_cond_key key_injector_cond;
+#endif
+
+mysql_mutex_t injector_mutex;
+mysql_cond_t  injector_cond;
 
 /* NDB Injector thread (used for binlog creation) */
 static ulonglong ndb_latest_applied_binlog_epoch= 0;
@@ -119,15 +125,24 @@ static ulonglong ndb_latest_received_bin
 
 NDB_SHARE *ndb_apply_status_share= 0;
 NDB_SHARE *ndb_schema_share= 0;
-pthread_mutex_t ndb_schema_share_mutex;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_ndb_schema_share_mutex;
+#endif
+mysql_mutex_t ndb_schema_share_mutex;
 
 extern my_bool opt_log_slave_updates;
 static my_bool g_ndb_log_slave_updates;
 
 /* Schema object distribution handling */
 HASH ndb_schema_objects;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_NSO_mutex;
+#endif
+
 typedef struct st_ndb_schema_object {
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   char *key;
   uint key_length;
   uint use_count;
@@ -368,7 +383,7 @@ ndbcluster_binlog_open_table(THD *thd, N
   TABLE *table= event_data->table= 
     (TABLE*)alloc_root(&event_data->mem_root, sizeof(TABLE));
 
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
   init_tmp_table_share(thd, table_share, share->db, 0, share->table_name, 
                        share->key);
   if ((error= open_table_def(thd, table_share, 0)) ||
@@ -493,7 +508,7 @@ static void ndbcluster_binlog_wait(THD *
     if (thd)
       THD_SET_PROC_INFO(thd,
         "Waiting for ndbcluster binlog update to reach current position");
-    pthread_mutex_lock(&injector_mutex);
+    MYSQL_MUTEX_LOCK(&injector_mutex);
     while (!thd->killed && count && ndb_binlog_running &&
            (ndb_latest_handled_binlog_epoch == 0 ||
             ndb_latest_handled_binlog_epoch < wait_epoch))
@@ -501,9 +516,9 @@ static void ndbcluster_binlog_wait(THD *
       count--;
       struct timespec abstime;
       set_timespec(abstime, 1);
-      pthread_cond_timedwait(&injector_cond, &injector_mutex, &abstime);
+      MYSQL_COND_TIMEDWAIT(&injector_cond, &injector_mutex, &abstime);
     }
-    pthread_mutex_unlock(&injector_mutex);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
     if (thd)
       THD_SET_PROC_INFO(thd, save_info);
     DBUG_VOID_RETURN;
@@ -633,28 +648,28 @@ static int ndbcluster_binlog_end(THD *th
       however be a likely case as the ndbcluster_binlog_end is supposed to
       be called before ndb_cluster_end().
     */
-    pthread_mutex_lock(&LOCK_ndb_util_thread);
+    MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
     /* Ensure mutex are not freed if ndb_cluster_end is running at same time */
     ndb_util_thread_running++;
     ndbcluster_terminating= 1;
-    pthread_cond_signal(&COND_ndb_util_thread);
+    MYSQL_COND_SIGNAL(&COND_ndb_util_thread);
     while (ndb_util_thread_running > 1)
-      pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
+      MYSQL_COND_WAIT(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
     ndb_util_thread_running--;
-    pthread_mutex_unlock(&LOCK_ndb_util_thread);
+    MYSQL_MUTEX_UNLOCK(&LOCK_ndb_util_thread);
   }
 
   /* wait for injector thread to finish */
   ndbcluster_binlog_terminating= 1;
-  pthread_mutex_lock(&injector_mutex);
-  pthread_cond_signal(&injector_cond);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
+  MYSQL_COND_SIGNAL(&injector_cond);
   while (ndb_binlog_thread_running > 0)
-    pthread_cond_wait(&injector_cond, &injector_mutex);
-  pthread_mutex_unlock(&injector_mutex);
+    MYSQL_COND_WAIT(&injector_cond, &injector_mutex);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
 
-  pthread_mutex_destroy(&injector_mutex);
-  pthread_cond_destroy(&injector_cond);
-  pthread_mutex_destroy(&ndb_schema_share_mutex);
+  MYSQL_MUTEX_DESTROY(&injector_mutex);
+  MYSQL_COND_DESTROY(&injector_cond);
+  MYSQL_MUTEX_DESTROY(&ndb_schema_share_mutex);
 #endif
 
   DBUG_RETURN(0);
@@ -734,14 +749,14 @@ void ndbcluster_binlog_init_handlerton()
 */
 static NDB_SHARE *ndbcluster_check_ndb_apply_status_share()
 {
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
 
   void *share= hash_search(&ndbcluster_open_tables, 
                            (uchar*) NDB_APPLY_TABLE_FILE,
                            sizeof(NDB_APPLY_TABLE_FILE) - 1);
   DBUG_PRINT("info",("ndbcluster_check_ndb_apply_status_share %s %p",
                      NDB_APPLY_TABLE_FILE, share));
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   return (NDB_SHARE*) share;
 }
 
@@ -752,14 +767,14 @@ static NDB_SHARE *ndbcluster_check_ndb_a
 */
 static NDB_SHARE *ndbcluster_check_ndb_schema_share()
 {
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
 
   void *share= hash_search(&ndbcluster_open_tables, 
                            (uchar*) NDB_SCHEMA_TABLE_FILE,
                            sizeof(NDB_SCHEMA_TABLE_FILE) - 1);
   DBUG_PRINT("info",("ndbcluster_check_ndb_schema_share %s %p",
                      NDB_SCHEMA_TABLE_FILE, share));
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   return (NDB_SHARE*) share;
 }
 
@@ -885,9 +900,9 @@ int ndbcluster_setup_binlog_table_shares
   if (!ndb_schema_share &&
       ndbcluster_check_ndb_schema_share() == 0)
   {
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     ndb_create_table_from_engine(thd, NDB_REP_DB, NDB_SCHEMA_TABLE);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     if (!ndb_schema_share)
     {
       ndbcluster_create_schema_table(thd);
@@ -899,9 +914,9 @@ int ndbcluster_setup_binlog_table_shares
   if (!ndb_apply_status_share &&
       ndbcluster_check_ndb_apply_status_share() == 0)
   {
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     ndb_create_table_from_engine(thd, NDB_REP_DB, NDB_APPLY_TABLE);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     if (!ndb_apply_status_share)
     {
       ndbcluster_create_ndb_apply_status_table(thd);
@@ -912,7 +927,7 @@ int ndbcluster_setup_binlog_table_shares
 
   if (!ndbcluster_find_all_files(thd))
   {
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     ndb_binlog_tables_inited= TRUE;
     if (ndb_binlog_tables_inited &&
         ndb_binlog_running && ndb_binlog_is_ready)
@@ -921,9 +936,9 @@ int ndbcluster_setup_binlog_table_shares
         sql_print_information("NDB Binlog: ndb tables writable");
       close_cached_tables(NULL, NULL, TRUE, FALSE);
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     /* Signal injector thread that all is setup */
-    pthread_cond_signal(&injector_cond);
+    MYSQL_COND_SIGNAL(&injector_cond);
   }
   return 0;
 }
@@ -1219,12 +1234,12 @@ static void ndb_report_waiting(const cha
 {
   ulonglong ndb_latest_epoch= 0;
   const char *proc_info= "<no info>";
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   if (injector_ndb)
     ndb_latest_epoch= injector_ndb->getLatestGCI();
   if (injector_thd)
     proc_info= injector_thd->proc_info;
-  pthread_mutex_unlock(&injector_mutex);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
   sql_print_information("NDB %s:"
                         " waiting max %u sec for %s %s."
                         "  epochs: (%u/%u,%u/%u,%u/%u)"
@@ -1354,15 +1369,15 @@ int ndbcluster_log_schema_op(THD *thd,
     bitmap_set_all(&schema_subscribers);
 
     /* begin protect ndb_schema_share */
-    pthread_mutex_lock(&ndb_schema_share_mutex);
+    MYSQL_MUTEX_LOCK(&ndb_schema_share_mutex);
     if (ndb_schema_share == 0)
     {
-      pthread_mutex_unlock(&ndb_schema_share_mutex);
+      MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
       if (ndb_schema_object)
         ndb_free_schema_object(&ndb_schema_object, FALSE);
       DBUG_RETURN(0);    
     }
-    (void) pthread_mutex_lock(&ndb_schema_share->mutex);
+    (void) MYSQL_MUTEX_LOCK(&ndb_schema_share->mutex);
     for (i= 0; i < no_storage_nodes; i++)
     {
       MY_BITMAP *table_subscribers= &ndb_schema_share->subscriber_bitmap[i];
@@ -1373,8 +1388,8 @@ int ndbcluster_log_schema_op(THD *thd,
         updated= 1;
       }
     }
-    (void) pthread_mutex_unlock(&ndb_schema_share->mutex);
-    pthread_mutex_unlock(&ndb_schema_share_mutex);
+    (void) MYSQL_MUTEX_UNLOCK(&ndb_schema_share->mutex);
+    MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
     /* end protect ndb_schema_share */
 
     if (updated)
@@ -1397,10 +1412,10 @@ int ndbcluster_log_schema_op(THD *thd,
 
     if (ndb_schema_object)
     {
-      (void) pthread_mutex_lock(&ndb_schema_object->mutex);
+      (void) MYSQL_MUTEX_LOCK(&ndb_schema_object->mutex);
       memcpy(ndb_schema_object->slock, schema_subscribers.bitmap,
              sizeof(ndb_schema_object->slock));
-      (void) pthread_mutex_unlock(&ndb_schema_object->mutex);
+      (void) MYSQL_MUTEX_UNLOCK(&ndb_schema_object->mutex);
     }
 
     DBUG_DUMP("schema_subscribers", (uchar*)schema_subscribers.bitmap,
@@ -1568,11 +1583,11 @@ end:
         ndbcluster_update_slock(thd, db, table_name);
     }
     int max_timeout= opt_ndb_sync_timeout;
-    (void) pthread_mutex_lock(&ndb_schema_object->mutex);
+    (void) MYSQL_MUTEX_LOCK(&ndb_schema_object->mutex);
     if (have_lock_open)
     {
-      safe_mutex_assert_owner(&LOCK_open);
-      (void) pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
+      (void) MYSQL_MUTEX_UNLOCK(&LOCK_open);
     }
     while (1)
     {
@@ -1580,20 +1595,20 @@ end:
       int i;
       int no_storage_nodes= g_ndb_cluster_connection->no_db_nodes();
       set_timespec(abstime, 1);
-      int ret= pthread_cond_timedwait(&injector_cond,
+      int ret= MYSQL_COND_TIMEDWAIT(&injector_cond,
                                       &ndb_schema_object->mutex,
                                       &abstime);
       if (thd->killed)
         break;
 
       /* begin protect ndb_schema_share */
-      pthread_mutex_lock(&ndb_schema_share_mutex);
+      MYSQL_MUTEX_LOCK(&ndb_schema_share_mutex);
       if (ndb_schema_share == 0)
       {
-        pthread_mutex_unlock(&ndb_schema_share_mutex);
+        MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
         break;
       }
-      (void) pthread_mutex_lock(&ndb_schema_share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&ndb_schema_share->mutex);
       for (i= 0; i < no_storage_nodes; i++)
       {
         /* remove any unsubscribed from schema_subscribers */
@@ -1601,8 +1616,8 @@ end:
         if (!bitmap_is_clear_all(tmp))
           bitmap_intersect(&schema_subscribers, tmp);
       }
-      (void) pthread_mutex_unlock(&ndb_schema_share->mutex);
-      pthread_mutex_unlock(&ndb_schema_share_mutex);
+      (void) MYSQL_MUTEX_UNLOCK(&ndb_schema_share->mutex);
+      MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
       /* end protect ndb_schema_share */
 
       /* remove any unsubscribed from ndb_schema_object->slock */
@@ -1631,9 +1646,9 @@ end:
     }
     if (have_lock_open)
     {
-      (void) pthread_mutex_lock(&LOCK_open);
+      (void) MYSQL_MUTEX_LOCK(&LOCK_open);
     }
-    (void) pthread_mutex_unlock(&ndb_schema_object->mutex);
+    (void) MYSQL_MUTEX_UNLOCK(&ndb_schema_object->mutex);
   }
 
   if (ndb_schema_object)
@@ -1675,7 +1690,7 @@ ndb_handle_schema_change(THD *thd, Ndb *
       ndbtab_g.invalidate();
   }
 
-  (void) pthread_mutex_lock(&share->mutex);
+  (void) MYSQL_MUTEX_LOCK(&share->mutex);
   DBUG_ASSERT(share->state == NSS_DROPPED || 
               share->op == pOp || share->new_op == pOp);
   if (share->new_op)
@@ -1689,10 +1704,10 @@ ndb_handle_schema_change(THD *thd, Ndb *
   // either just us or drop table handling as well
       
   /* Signal ha_ndbcluster::delete/rename_table that drop is done */
-  (void) pthread_mutex_unlock(&share->mutex);
-  (void) pthread_cond_signal(&injector_cond);
+  (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
+  (void) MYSQL_COND_SIGNAL(&injector_cond);
 
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   /* ndb_share reference binlog free */
   DBUG_PRINT("NDB_SHARE", ("%s binlog free  use_count: %u",
                            share->key, share->use_count));
@@ -1718,7 +1733,7 @@ ndb_handle_schema_change(THD *thd, Ndb *
   }
   else
     share= 0;
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
   if (event_data)
   {
@@ -1726,10 +1741,10 @@ ndb_handle_schema_change(THD *thd, Ndb *
     pOp->setCustomData(NULL);
   }
 
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   ndb->dropEventOperation(pOp);
   pOp= 0;
-  pthread_mutex_unlock(&injector_mutex);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
 
   if (do_close_cached_tables)
   {
@@ -1882,7 +1897,7 @@ ndb_binlog_thread_handle_schema_event(TH
         }
         // fall through
         case SOT_CREATE_TABLE:
-          pthread_mutex_lock(&LOCK_open);
+          MYSQL_MUTEX_LOCK(&LOCK_open);
           if (ndbcluster_check_if_local_table(schema->db, schema->name))
           {
             DBUG_PRINT("info", ("NDB Binlog: Skipping locally defined table '%s.%s'",
@@ -1904,7 +1919,7 @@ ndb_binlog_thread_handle_schema_event(TH
             while ((err= it++))
               sql_print_warning("NDB Binlog: (%d)%s", err->code, err->msg);
           }
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
           log_query= 1;
           break;
         case SOT_DROP_DB:
@@ -1993,7 +2008,7 @@ ndb_binlog_thread_handle_schema_event(TH
                               "read only on reconnect.");
 
       /* begin protect ndb_schema_share */
-      pthread_mutex_lock(&ndb_schema_share_mutex);
+      MYSQL_MUTEX_LOCK(&ndb_schema_share_mutex);
       /* ndb_share reference binlog extra free */
       DBUG_PRINT("NDB_SHARE", ("%s binlog extra free  use_count: %u",
                                ndb_schema_share->key,
@@ -2002,7 +2017,7 @@ ndb_binlog_thread_handle_schema_event(TH
       ndb_schema_share= 0;
       ndb_binlog_tables_inited= FALSE;
       ndb_binlog_is_ready= FALSE;
-      pthread_mutex_unlock(&ndb_schema_share_mutex);
+      MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
       /* end protect ndb_schema_share */
 
       close_cached_tables(NULL, NULL, FALSE, FALSE);
@@ -2014,7 +2029,7 @@ ndb_binlog_thread_handle_schema_event(TH
     {
       uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
       DBUG_ASSERT(node_id != 0xFF);
-      (void) pthread_mutex_lock(&tmp_share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&tmp_share->mutex);
       bitmap_clear_all(&tmp_share->subscriber_bitmap[node_id]);
       DBUG_PRINT("info",("NODE_FAILURE UNSUBSCRIBE[%d]", node_id));
       if (ndb_extra_logging)
@@ -2025,8 +2040,8 @@ ndb_binlog_thread_handle_schema_event(TH
                               tmp_share->subscriber_bitmap[node_id].bitmap[1],
                               tmp_share->subscriber_bitmap[node_id].bitmap[0]);
       }
-      (void) pthread_mutex_unlock(&tmp_share->mutex);
-      (void) pthread_cond_signal(&injector_cond);
+      (void) MYSQL_MUTEX_UNLOCK(&tmp_share->mutex);
+      (void) MYSQL_COND_SIGNAL(&injector_cond);
       break;
     }
     case NDBEVENT::TE_SUBSCRIBE:
@@ -2034,7 +2049,7 @@ ndb_binlog_thread_handle_schema_event(TH
       uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
       uint8 req_id= pOp->getReqNodeId();
       DBUG_ASSERT(req_id != 0 && node_id != 0xFF);
-      (void) pthread_mutex_lock(&tmp_share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&tmp_share->mutex);
       bitmap_set_bit(&tmp_share->subscriber_bitmap[node_id], req_id);
       DBUG_PRINT("info",("SUBSCRIBE[%d] %d", node_id, req_id));
       if (ndb_extra_logging)
@@ -2046,8 +2061,8 @@ ndb_binlog_thread_handle_schema_event(TH
                               tmp_share->subscriber_bitmap[node_id].bitmap[1],
                               tmp_share->subscriber_bitmap[node_id].bitmap[0]);
       }
-      (void) pthread_mutex_unlock(&tmp_share->mutex);
-      (void) pthread_cond_signal(&injector_cond);
+      (void) MYSQL_MUTEX_UNLOCK(&tmp_share->mutex);
+      (void) MYSQL_COND_SIGNAL(&injector_cond);
       break;
     }
     case NDBEVENT::TE_UNSUBSCRIBE:
@@ -2055,7 +2070,7 @@ ndb_binlog_thread_handle_schema_event(TH
       uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
       uint8 req_id= pOp->getReqNodeId();
       DBUG_ASSERT(req_id != 0 && node_id != 0xFF);
-      (void) pthread_mutex_lock(&tmp_share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&tmp_share->mutex);
       bitmap_clear_bit(&tmp_share->subscriber_bitmap[node_id], req_id);
       DBUG_PRINT("info",("UNSUBSCRIBE[%d] %d", node_id, req_id));
       if (ndb_extra_logging)
@@ -2067,8 +2082,8 @@ ndb_binlog_thread_handle_schema_event(TH
                               tmp_share->subscriber_bitmap[node_id].bitmap[1],
                               tmp_share->subscriber_bitmap[node_id].bitmap[0]);
       }
-      (void) pthread_mutex_unlock(&tmp_share->mutex);
-      (void) pthread_cond_signal(&injector_cond);
+      (void) MYSQL_MUTEX_UNLOCK(&tmp_share->mutex);
+      (void) MYSQL_COND_SIGNAL(&injector_cond);
       break;
     }
     default:
@@ -2108,22 +2123,22 @@ ndb_binlog_thread_handle_schema_event_po
       build_table_filename(key, sizeof(key), schema->db, schema->name, "", 0);
       if (schema_type == SOT_CLEAR_SLOCK)
       {
-        pthread_mutex_lock(&ndbcluster_mutex);
+        MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
         NDB_SCHEMA_OBJECT *ndb_schema_object=
           (NDB_SCHEMA_OBJECT*) hash_search(&ndb_schema_objects,
                                            (uchar*) key, strlen(key));
         if (ndb_schema_object)
         {
-          pthread_mutex_lock(&ndb_schema_object->mutex);
+          MYSQL_MUTEX_LOCK(&ndb_schema_object->mutex);
           memcpy(ndb_schema_object->slock, schema->slock,
                  sizeof(ndb_schema_object->slock));
           DBUG_DUMP("ndb_schema_object->slock_bitmap.bitmap",
                     (uchar*)ndb_schema_object->slock_bitmap.bitmap,
                     no_bytes_in_map(&ndb_schema_object->slock_bitmap));
-          pthread_mutex_unlock(&ndb_schema_object->mutex);
-          pthread_cond_signal(&injector_cond);
+          MYSQL_MUTEX_UNLOCK(&ndb_schema_object->mutex);
+          MYSQL_COND_SIGNAL(&injector_cond);
         }
-        pthread_mutex_unlock(&ndbcluster_mutex);
+        MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
         continue;
       }
       /* ndb_share reference temporary, free below */
@@ -2176,7 +2191,7 @@ ndb_binlog_thread_handle_schema_event_po
         {
           if (ndb_extra_logging > 9)
             sql_print_information("NDB Binlog: renaming files start");
-          pthread_mutex_lock(&LOCK_open);
+          MYSQL_MUTEX_LOCK(&LOCK_open);
           char from[FN_REFLEN];
           char to[FN_REFLEN];
           strxnmov(from, FN_REFLEN-1, share->key, NullS);
@@ -2184,7 +2199,7 @@ ndb_binlog_thread_handle_schema_event_po
           strxnmov(to, FN_REFLEN-1, share->key, NullS);
           rename_file_ext(from, to, ".ndb");
           rename_file_ext(from, to, ".frm");
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
           if (ndb_extra_logging > 9)
             sql_print_information("NDB Binlog: renaming files done");
         }
@@ -2243,7 +2258,7 @@ ndb_binlog_thread_handle_schema_event_po
             free_share(&share);
             share= 0;
           }
-          pthread_mutex_lock(&LOCK_open);
+          MYSQL_MUTEX_LOCK(&LOCK_open);
           if (ndbcluster_check_if_local_table(schema->db, schema->name))
           {
             DBUG_PRINT("info", ("NDB Binlog: Skipping locally defined table '%s.%s'",
@@ -2264,7 +2279,7 @@ ndb_binlog_thread_handle_schema_event_po
             while ((err= it++))
               sql_print_warning("NDB Binlog: (%d)%s", err->code, err->msg);
           }
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
         }
         break;
       case SOT_ONLINE_ALTER_TABLE_PREPARE:
@@ -2285,7 +2300,7 @@ ndb_binlog_thread_handle_schema_event_po
           Refresh local frm file and dictionary cache if
           remote on-line alter table
         */
-        pthread_mutex_lock(&LOCK_open);
+        MYSQL_MUTEX_LOCK(&LOCK_open);
         TABLE_LIST table_list;
         bzero((char*) &table_list,sizeof(table_list));
         table_list.db= (char *)schema->db;
@@ -2328,21 +2343,21 @@ ndb_binlog_thread_handle_schema_event_po
           my_free((char*)pack_data, MYF(MY_ALLOW_ZERO_PTR));
         }
         if (!share)
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
         else
         {
           if (ndb_extra_logging > 9)
             sql_print_information("NDB Binlog: handeling online alter/rename");
 
-          (void) pthread_mutex_lock(&share->mutex);
+          (void) MYSQL_MUTEX_LOCK(&share->mutex);
           ndbcluster_binlog_close_table(thd, share);
 
           if ((error= ndbcluster_binlog_open_table(thd, share)))
             sql_print_error("NDB Binlog: Failed to re-open table %s.%s",
                             schema->db, schema->name);
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
           if (error)
-            (void) pthread_mutex_unlock(&share->mutex);
+            (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
         }
         if (!error && share)
         {
@@ -2375,7 +2390,7 @@ ndb_binlog_thread_handle_schema_event_po
             share->new_op= share->op;
           }
           share->op= tmp_op;
-          (void) pthread_mutex_unlock(&share->mutex);
+          (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
 
           if (ndb_extra_logging > 9)
             sql_print_information("NDB Binlog: handeling online alter/rename done");
@@ -2388,7 +2403,7 @@ ndb_binlog_thread_handle_schema_event_po
           sql_print_information("SOT_ONLINE_ALTER_TABLE_COMMIT %s.%s", schema->db, schema->name);
         if (share)
         {
-          (void) pthread_mutex_lock(&share->mutex);
+          (void) MYSQL_MUTEX_LOCK(&share->mutex);
           if (share->op && share->new_op)
           {
             Ndb_event_data *event_data= (Ndb_event_data *) share->op->getCustomData();
@@ -2400,7 +2415,7 @@ ndb_binlog_thread_handle_schema_event_po
             share->new_op= 0;
             free_share(&share);
           }
-          (void) pthread_mutex_unlock(&share->mutex);
+          (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
         }
         break;
       }
@@ -2422,7 +2437,7 @@ ndb_binlog_thread_handle_schema_event_po
             free_share(&share);
             share= 0;
           }
-          pthread_mutex_lock(&LOCK_open);
+          MYSQL_MUTEX_LOCK(&LOCK_open);
           if (ndbcluster_check_if_local_table(schema->db, schema->name))
           {
             DBUG_PRINT("info", ("NDB Binlog: Skipping locally defined table '%s.%s'",
@@ -2443,7 +2458,7 @@ ndb_binlog_thread_handle_schema_event_po
             while ((err= it++))
               sql_print_warning("NDB Binlog: (%d)%s", err->code, err->msg);
           }
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
         }
         break;
       default:
@@ -2669,27 +2684,27 @@ int ndbcluster_binlog_start()
     DBUG_RETURN(-1);
   }
 
-  pthread_mutex_init(&injector_mutex, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&injector_cond, NULL);
-  pthread_mutex_init(&ndb_schema_share_mutex, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&injector_mutex, key_injector_mutex, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&injector_cond, key_injector_cond, NULL);
+  MYSQL_MUTEX_INIT(&ndb_schema_share_mutex, key_ndb_schema_share_mutex, MY_MUTEX_INIT_FAST);
 
   /* Create injector thread */
   if (pthread_create(&ndb_binlog_thread, &connection_attrib,
                      ndb_binlog_thread_func, 0))
   {
     DBUG_PRINT("error", ("Could not create ndb injector thread"));
-    pthread_cond_destroy(&injector_cond);
-    pthread_mutex_destroy(&injector_mutex);
+    MYSQL_COND_DESTROY(&injector_cond);
+    MYSQL_MUTEX_DESTROY(&injector_mutex);
     DBUG_RETURN(-1);
   }
 
   ndbcluster_binlog_inited= 1;
 
   /* Wait for the injector thread to start */
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   while (!ndb_binlog_thread_running)
-    pthread_cond_wait(&injector_cond, &injector_mutex);
-  pthread_mutex_unlock(&injector_mutex);
+    MYSQL_COND_WAIT(&injector_cond, &injector_mutex);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
 
   if (ndb_binlog_thread_running < 0)
     DBUG_RETURN(-1);
@@ -2792,7 +2807,7 @@ int ndbcluster_create_binlog_setup(THD *
   DBUG_ASSERT(! IS_NDB_BLOB_PREFIX(table_name));
   DBUG_ASSERT(strlen(key) == key_len);
 
-  pthread_mutex_lock(&ndbcluster_mutex);
+  MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
 
   /* Handle any trailing share */
   NDB_SHARE *share= (NDB_SHARE*) hash_search(&ndbcluster_open_tables,
@@ -2804,7 +2819,7 @@ int ndbcluster_create_binlog_setup(THD *
         share->op != 0 ||
         share->new_op != 0)
     {
-      pthread_mutex_unlock(&ndbcluster_mutex);
+      MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
       DBUG_RETURN(0); // replication already setup, or should not
     }
   }
@@ -2814,7 +2829,7 @@ int ndbcluster_create_binlog_setup(THD *
     if (share->op || share->new_op)
     {
       my_errno= HA_ERR_TABLE_EXIST;
-      pthread_mutex_unlock(&ndbcluster_mutex);
+      MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
       DBUG_RETURN(1);
     }
     if (!share_may_exist || share->connect_count != 
@@ -2857,10 +2872,10 @@ int ndbcluster_create_binlog_setup(THD *
   if (!do_event_op)
   {
     set_binlog_nologging(share);
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
     DBUG_RETURN(0);
   }
-  pthread_mutex_unlock(&ndbcluster_mutex);
+  MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
 
   while (share && !IS_TMP_PREFIX(table_name))
   {
@@ -3169,14 +3184,14 @@ ndbcluster_create_event_ops(THD *thd, ND
   int retry_sleep= 100;
   while (1)
   {
-    pthread_mutex_lock(&injector_mutex);
+    MYSQL_MUTEX_LOCK(&injector_mutex);
     Ndb *ndb= injector_ndb;
     if (do_ndb_schema_share)
       ndb= schema_ndb;
 
     if (ndb == 0)
     {
-      pthread_mutex_unlock(&injector_mutex);
+      MYSQL_MUTEX_UNLOCK(&injector_mutex);
       DBUG_RETURN(-1);
     }
 
@@ -3201,7 +3216,7 @@ ndbcluster_create_event_ops(THD *thd, ND
                           ndb->getNdbError().code,
                           ndb->getNdbError().message,
                           "NDB");
-      pthread_mutex_unlock(&injector_mutex);
+      MYSQL_MUTEX_UNLOCK(&injector_mutex);
       DBUG_RETURN(-1);
     }
 
@@ -3264,7 +3279,7 @@ ndbcluster_create_event_ops(THD *thd, ND
                                 op->getNdbError().message,
                                 "NDB");
             ndb->dropEventOperation(op);
-            pthread_mutex_unlock(&injector_mutex);
+            MYSQL_MUTEX_UNLOCK(&injector_mutex);
             DBUG_RETURN(-1);
           }
         }
@@ -3310,7 +3325,7 @@ ndbcluster_create_event_ops(THD *thd, ND
       share->event_data= event_data;
       op->setCustomData(NULL);
       ndb->dropEventOperation(op);
-      pthread_mutex_unlock(&injector_mutex);
+      MYSQL_MUTEX_UNLOCK(&injector_mutex);
       if (retries)
       {
         my_sleep(retry_sleep);
@@ -3318,7 +3333,7 @@ ndbcluster_create_event_ops(THD *thd, ND
       }
       DBUG_RETURN(-1);
     }
-    pthread_mutex_unlock(&injector_mutex);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
     break;
   }
 
@@ -3332,7 +3347,7 @@ ndbcluster_create_event_ops(THD *thd, ND
     ndb_apply_status_share= get_share(share);
     DBUG_PRINT("NDB_SHARE", ("%s binlog extra  use_count: %u",
                              share->key, share->use_count));
-    (void) pthread_cond_signal(&injector_cond);
+    (void) MYSQL_COND_SIGNAL(&injector_cond);
   }
   else if (do_ndb_schema_share)
   {
@@ -3340,7 +3355,7 @@ ndbcluster_create_event_ops(THD *thd, ND
     ndb_schema_share= get_share(share);
     DBUG_PRINT("NDB_SHARE", ("%s binlog extra  use_count: %u",
                              share->key, share->use_count));
-    (void) pthread_cond_signal(&injector_cond);
+    (void) MYSQL_COND_SIGNAL(&injector_cond);
   }
 
   DBUG_PRINT("info",("%s share->op: %p  share->use_count: %u",
@@ -3405,13 +3420,13 @@ ndbcluster_handle_alter_table(THD *thd, 
   DBUG_ENTER("ndbcluster_handle_alter_table");
   const char *save_proc_info= thd->proc_info;
   thd->proc_info= "Syncing ndb table schema operation and binlog";
-  (void) pthread_mutex_lock(&share->mutex);
+  (void) MYSQL_MUTEX_LOCK(&share->mutex);
   int max_timeout= opt_ndb_sync_timeout;
   while (share->state == NSS_ALTERED)
   {
     struct timespec abstime;
     set_timespec(abstime, 1);
-    int ret= pthread_cond_timedwait(&injector_cond,
+    int ret= MYSQL_COND_TIMEDWAIT(&injector_cond,
                                     &share->mutex,
                                     &abstime);
     if (thd->killed ||
@@ -3431,7 +3446,7 @@ ndbcluster_handle_alter_table(THD *thd, 
                            type_str, share->key);
     }
   }
-  (void) pthread_mutex_unlock(&share->mutex);
+  (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
   thd->proc_info= save_proc_info;
   DBUG_RETURN(0);
 }
@@ -3473,15 +3488,15 @@ ndbcluster_handle_drop_table(THD *thd, N
 #define SYNC_DROP_
 #ifdef SYNC_DROP_
   THD_SET_PROC_INFO(thd, "Syncing ndb table schema operation and binlog");
-  (void) pthread_mutex_lock(&share->mutex);
-  safe_mutex_assert_owner(&LOCK_open);
-  (void) pthread_mutex_unlock(&LOCK_open);
+  (void) MYSQL_MUTEX_LOCK(&share->mutex);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_open);
   int max_timeout= opt_ndb_sync_timeout;
   while (share->op)
   {
     struct timespec abstime;
     set_timespec(abstime, 1);
-    int ret= pthread_cond_timedwait(&injector_cond,
+    int ret= MYSQL_COND_TIMEDWAIT(&injector_cond,
                                     &share->mutex,
                                     &abstime);
     if (thd->killed ||
@@ -3501,12 +3516,12 @@ ndbcluster_handle_drop_table(THD *thd, N
                            type_str, share->key);
     }
   }
-  (void) pthread_mutex_lock(&LOCK_open);
-  (void) pthread_mutex_unlock(&share->mutex);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_open);
+  (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
 #else
-  (void) pthread_mutex_lock(&share->mutex);
+  (void) MYSQL_MUTEX_LOCK(&share->mutex);
   share->op= 0;
-  (void) pthread_mutex_unlock(&share->mutex);
+  (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
 #endif
   THD_SET_PROC_INFO(thd, save_proc_info);
 
@@ -4114,7 +4129,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema
   DBUG_PRINT("enter", ("key: '%s'", key));
 
   if (!have_lock)
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   while (!(ndb_schema_object=
            (NDB_SCHEMA_OBJECT*) hash_search(&ndb_schema_objects,
                                             (uchar*) key,
@@ -4140,7 +4155,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema
       my_free((uchar*) ndb_schema_object, 0);
       break;
     }
-    pthread_mutex_init(&ndb_schema_object->mutex, MY_MUTEX_INIT_FAST);
+    MYSQL_MUTEX_INIT(&ndb_schema_object->mutex, key_NSO_mutex, MY_MUTEX_INIT_FAST);
     bitmap_init(&ndb_schema_object->slock_bitmap, ndb_schema_object->slock,
                 sizeof(ndb_schema_object->slock)*8, FALSE);
     bitmap_clear_all(&ndb_schema_object->slock_bitmap);
@@ -4152,7 +4167,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema
     DBUG_PRINT("info", ("use_count: %d", ndb_schema_object->use_count));
   }
   if (!have_lock)
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   DBUG_RETURN(ndb_schema_object);
 }
 
@@ -4163,12 +4178,12 @@ static void ndb_free_schema_object(NDB_S
   DBUG_ENTER("ndb_free_schema_object");
   DBUG_PRINT("enter", ("key: '%s'", (*ndb_schema_object)->key));
   if (!have_lock)
-    pthread_mutex_lock(&ndbcluster_mutex);
+    MYSQL_MUTEX_LOCK(&ndbcluster_mutex);
   if (!--(*ndb_schema_object)->use_count)
   {
     DBUG_PRINT("info", ("use_count: %d", (*ndb_schema_object)->use_count));
     hash_delete(&ndb_schema_objects, (uchar*) *ndb_schema_object);
-    pthread_mutex_destroy(&(*ndb_schema_object)->mutex);
+    MYSQL_MUTEX_DESTROY(&(*ndb_schema_object)->mutex);
     my_free((uchar*) *ndb_schema_object, MYF(0));
     *ndb_schema_object= 0;
   }
@@ -4177,7 +4192,7 @@ static void ndb_free_schema_object(NDB_S
     DBUG_PRINT("info", ("use_count: %d", (*ndb_schema_object)->use_count));
   }
   if (!have_lock)
-    pthread_mutex_unlock(&ndbcluster_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndbcluster_mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -4196,7 +4211,7 @@ pthread_handler_t ndb_binlog_thread_func
   Timer main_timer;
 #endif
 
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   /*
     Set up the Thread
   */
@@ -4209,9 +4224,9 @@ pthread_handler_t ndb_binlog_thread_func
   /* We need to set thd->thread_id before thd->store_globals, or it will
      set an invalid value for thd->variables.pseudo_thread_id.
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   thd->thread_stack= (char*) &thd; /* remember where our stack is */
   if (thd->store_globals())
@@ -4219,8 +4234,8 @@ pthread_handler_t ndb_binlog_thread_func
     thd->cleanup();
     delete thd;
     ndb_binlog_thread_running= -1;
-    pthread_mutex_unlock(&injector_mutex);
-    pthread_cond_signal(&injector_cond);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
+    MYSQL_COND_SIGNAL(&injector_cond);
     my_thread_end();
     pthread_exit(0);
     DBUG_RETURN(NULL);
@@ -4244,9 +4259,9 @@ pthread_handler_t ndb_binlog_thread_func
 
   pthread_detach_this_thread();
   thd->real_id= pthread_self();
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   thd->lex->start_transaction_opt= 0;
 
   if (!(s_ndb= new Ndb(g_ndb_cluster_connection, "")) ||
@@ -4254,8 +4269,8 @@ pthread_handler_t ndb_binlog_thread_func
   {
     sql_print_error("NDB Binlog: Getting Schema Ndb object failed");
     ndb_binlog_thread_running= -1;
-    pthread_mutex_unlock(&injector_mutex);
-    pthread_cond_signal(&injector_cond);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
+    MYSQL_COND_SIGNAL(&injector_cond);
     goto err;
   }
 
@@ -4265,8 +4280,8 @@ pthread_handler_t ndb_binlog_thread_func
   {
     sql_print_error("NDB Binlog: Getting Ndb object failed");
     ndb_binlog_thread_running= -1;
-    pthread_mutex_unlock(&injector_mutex);
-    pthread_cond_signal(&injector_cond);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
+    MYSQL_COND_SIGNAL(&injector_cond);
     goto err;
   }
 
@@ -4279,7 +4294,7 @@ pthread_handler_t ndb_binlog_thread_func
 
     Used by both sql client thread and binlog thread to interact
     with the storage
-    pthread_mutex_lock(&injector_mutex);
+    MYSQL_MUTEX_LOCK(&injector_mutex);
   */
   injector_thd= thd;
   injector_ndb= i_ndb;
@@ -4292,28 +4307,28 @@ pthread_handler_t ndb_binlog_thread_func
 
   /* Thread start up completed  */
   ndb_binlog_thread_running= 1;
-  pthread_mutex_unlock(&injector_mutex);
-  pthread_cond_signal(&injector_cond);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
+  MYSQL_COND_SIGNAL(&injector_cond);
 
   /*
     wait for mysql server to start (so that the binlog is started
     and thus can receive the first GAP event)
   */
-  pthread_mutex_lock(&LOCK_server_started);
+  MYSQL_MUTEX_LOCK(&LOCK_server_started);
   while (!mysqld_server_started)
   {
     struct timespec abstime;
     set_timespec(abstime, 1);
-    pthread_cond_timedwait(&COND_server_started, &LOCK_server_started,
+    MYSQL_COND_TIMEDWAIT(&COND_server_started, &LOCK_server_started,
                            &abstime);
     if (ndbcluster_terminating)
     {
-      pthread_mutex_unlock(&LOCK_server_started);
-      pthread_mutex_lock(&LOCK_ndb_util_thread);
+      MYSQL_MUTEX_UNLOCK(&LOCK_server_started);
+      MYSQL_MUTEX_LOCK(&LOCK_ndb_util_thread);
       goto err;
     }
   }
-  pthread_mutex_unlock(&LOCK_server_started);
+  MYSQL_MUTEX_UNLOCK(&LOCK_server_started);
 restart:
   /*
     Main NDB Injector loop
@@ -4356,7 +4371,7 @@ restart:
   {
     THD_SET_PROC_INFO(thd, "Waiting for ndbcluster to start");
 
-    pthread_mutex_lock(&injector_mutex);
+    MYSQL_MUTEX_LOCK(&injector_mutex);
     while (!ndb_schema_share ||
            (ndb_binlog_running && !ndb_apply_status_share) ||
            !ndb_binlog_tables_inited)
@@ -4364,14 +4379,14 @@ restart:
       /* ndb not connected yet */
       struct timespec abstime;
       set_timespec(abstime, 1);
-      pthread_cond_timedwait(&injector_cond, &injector_mutex, &abstime);
+      MYSQL_COND_TIMEDWAIT(&injector_cond, &injector_mutex, &abstime);
       if (ndbcluster_binlog_terminating)
       {
-        pthread_mutex_unlock(&injector_mutex);
+        MYSQL_MUTEX_UNLOCK(&injector_mutex);
         goto err;
       }
     }
-    pthread_mutex_unlock(&injector_mutex);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
 
     if (thd_ndb == NULL)
     {
@@ -4888,12 +4903,12 @@ err:
   DBUG_PRINT("info",("Shutting down cluster binlog thread"));
   THD_SET_PROC_INFO(thd, "Shutting down");
   close_thread_tables(thd);
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   /* don't mess with the injector_ndb anymore from other threads */
   injector_thd= 0;
   injector_ndb= 0;
   schema_ndb= 0;
-  pthread_mutex_unlock(&injector_mutex);
+  MYSQL_MUTEX_UNLOCK(&injector_mutex);
   thd->db= 0; // as not to try to free memory
 
   if (ndb_apply_status_share)
@@ -4909,7 +4924,7 @@ err:
   if (ndb_schema_share)
   {
     /* begin protect ndb_schema_share */
-    pthread_mutex_lock(&ndb_schema_share_mutex);
+    MYSQL_MUTEX_LOCK(&ndb_schema_share_mutex);
     /* ndb_share reference binlog extra free */
     DBUG_PRINT("NDB_SHARE", ("%s binlog extra free  use_count: %u",
                              ndb_schema_share->key,
@@ -4917,7 +4932,7 @@ err:
     free_share(&ndb_schema_share);
     ndb_schema_share= 0;
     ndb_binlog_tables_inited= FALSE;
-    pthread_mutex_unlock(&ndb_schema_share_mutex);
+    MYSQL_MUTEX_UNLOCK(&ndb_schema_share_mutex);
     /* end protect ndb_schema_share */
   }
 
@@ -4940,10 +4955,10 @@ err:
         delete event_data;
         op->setCustomData(NULL);
       }
-      (void) pthread_mutex_lock(&share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&share->mutex);
       share->op= 0;
       share->new_op= 0;
-      (void) pthread_mutex_unlock(&share->mutex);
+      (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
       /* ndb_share reference binlog free */
       DBUG_PRINT("NDB_SHARE", ("%s binlog free  use_count: %u",
                                share->key, share->use_count));
@@ -4970,11 +4985,11 @@ err:
         op->setCustomData(NULL);
       }
       DBUG_ASSERT(share != 0);
-      (void) pthread_mutex_lock(&share->mutex);
+      (void) MYSQL_MUTEX_LOCK(&share->mutex);
       DBUG_ASSERT(share->op == op || share->new_op == op);
       share->op= 0;
       share->new_op= 0;
-      (void) pthread_mutex_unlock(&share->mutex);
+      (void) MYSQL_MUTEX_UNLOCK(&share->mutex);
       /* ndb_share reference binlog free */
       DBUG_PRINT("NDB_SHARE", ("%s binlog free  use_count: %u",
                                share->key, share->use_count));
@@ -4993,7 +5008,7 @@ err:
 
   ndb_binlog_thread_running= -1;
   ndb_binlog_running= FALSE;
-  (void) pthread_cond_signal(&injector_cond);
+  (void) MYSQL_COND_SIGNAL(&injector_cond);
 
   DBUG_PRINT("exit", ("ndb_binlog_thread"));
   my_thread_end();
@@ -5011,12 +5026,12 @@ ndbcluster_show_status_binlog(THD* thd, 
   ulonglong ndb_latest_epoch= 0;
   DBUG_ENTER("ndbcluster_show_status_binlog");
   
-  pthread_mutex_lock(&injector_mutex);
+  MYSQL_MUTEX_LOCK(&injector_mutex);
   if (injector_ndb)
   {
     char buff1[22],buff2[22],buff3[22],buff4[22],buff5[22];
     ndb_latest_epoch= injector_ndb->getLatestGCI();
-    pthread_mutex_unlock(&injector_mutex);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
 
     buflen=
       snprintf(buf, sizeof(buf),
@@ -5036,7 +5051,7 @@ ndbcluster_show_status_binlog(THD* thd, 
       DBUG_RETURN(TRUE);
   }
   else
-    pthread_mutex_unlock(&injector_mutex);
+    MYSQL_MUTEX_UNLOCK(&injector_mutex);
   DBUG_RETURN(FALSE);
 }
 

=== modified file 'sql/ha_ndbcluster_binlog.h'
--- a/sql/ha_ndbcluster_binlog.h	2008-02-05 15:34:12 +0000
+++ b/sql/ha_ndbcluster_binlog.h	2008-10-10 20:34:55 +0000
@@ -139,15 +139,15 @@ extern Ndb_cluster_connection* g_ndb_clu
 
 #ifdef HAVE_NDB_BINLOG
 extern pthread_t ndb_binlog_thread;
-extern pthread_mutex_t injector_mutex;
-extern pthread_cond_t  injector_cond;
+extern mysql_mutex_t injector_mutex;
+extern mysql_cond_t  injector_cond;
 
 extern unsigned char g_node_id_map[max_ndb_nodes];
 extern pthread_t ndb_util_thread;
-extern pthread_mutex_t LOCK_ndb_util_thread;
-extern pthread_cond_t COND_ndb_util_thread;
+extern mysql_mutex_t LOCK_ndb_util_thread;
+extern mysql_cond_t COND_ndb_util_thread;
 extern int ndbcluster_util_inited;
-extern pthread_mutex_t ndbcluster_mutex;
+extern mysql_mutex_t ndbcluster_mutex;
 extern HASH ndbcluster_open_tables;
 extern long ndb_number_of_storage_nodes;
 

=== modified file 'sql/ha_ndbcluster_connection.cc'
--- a/sql/ha_ndbcluster_connection.cc	2007-11-20 14:22:05 +0000
+++ b/sql/ha_ndbcluster_connection.cc	2008-10-10 20:34:55 +0000
@@ -35,7 +35,12 @@ Ndb_cluster_connection* g_ndb_cluster_co
 static Ndb_cluster_connection **g_ndb_cluster_connection_pool= NULL;
 static ulong g_ndb_cluster_connection_pool_alloc= 0;
 static ulong g_ndb_cluster_connection_pool_pos= 0;
-static pthread_mutex_t g_ndb_cluster_connection_pool_mutex;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_ndb_cluster_connection_pool_mutex;
+#endif
+
+static mysql_mutex_t g_ndb_cluster_connection_pool_mutex;
 
 int ndbcluster_connect(int (*connect_callback)(void))
 {
@@ -101,8 +106,9 @@ int ndbcluster_connect(int (*connect_cal
       my_malloc(g_ndb_cluster_connection_pool_alloc *
                 sizeof(Ndb_cluster_connection*),
                 MYF(MY_WME | MY_ZEROFILL));
-    pthread_mutex_init(&g_ndb_cluster_connection_pool_mutex,
-                       MY_MUTEX_INIT_FAST);
+    MYSQL_MUTEX_INIT(&g_ndb_cluster_connection_pool_mutex,
+                     key_ndb_cluster_connection_pool_mutex,
+                     MY_MUTEX_INIT_FAST);
     g_ndb_cluster_connection_pool[0]= g_ndb_cluster_connection;
     for (unsigned i= 1; i < g_ndb_cluster_connection_pool_alloc; i++)
     {
@@ -218,7 +224,7 @@ int ndbcluster_disconnect()
           delete g_ndb_cluster_connection_pool[i];
       }
       my_free((uchar*) g_ndb_cluster_connection_pool, MYF(MY_ALLOW_ZERO_PTR));
-      pthread_mutex_destroy(&g_ndb_cluster_connection_pool_mutex);
+      MYSQL_MUTEX_DESTROY(&g_ndb_cluster_connection_pool_mutex);
       g_ndb_cluster_connection_pool= 0;
     }
     g_ndb_cluster_connection_pool_alloc= 0;
@@ -232,14 +238,14 @@ int ndbcluster_disconnect()
 
 Ndb_cluster_connection *ndb_get_cluster_connection()
 {
-  pthread_mutex_lock(&g_ndb_cluster_connection_pool_mutex);
+  MYSQL_MUTEX_LOCK(&g_ndb_cluster_connection_pool_mutex);
   Ndb_cluster_connection *connection=
     g_ndb_cluster_connection_pool[g_ndb_cluster_connection_pool_pos];
   g_ndb_cluster_connection_pool_pos++;
   if (g_ndb_cluster_connection_pool_pos ==
       g_ndb_cluster_connection_pool_alloc)
     g_ndb_cluster_connection_pool_pos= 0;
-  pthread_mutex_unlock(&g_ndb_cluster_connection_pool_mutex);
+  MYSQL_MUTEX_UNLOCK(&g_ndb_cluster_connection_pool_mutex);
   return connection;
 }
 

=== modified file 'sql/ha_partition.cc'
--- a/sql/ha_partition.cc	2008-08-20 18:05:57 +0000
+++ b/sql/ha_partition.cc	2008-10-10 20:34:55 +0000
@@ -2506,7 +2506,7 @@ int ha_partition::open(const char *name,
     for the same table.
   */
   if (is_not_tmp_table)
-    pthread_mutex_lock(&table_share->LOCK_ha_data);
+    MYSQL_MUTEX_LOCK(&table_share->LOCK_ha_data);
   if (!table_share->ha_data)
   {
     HA_DATA_PARTITION *ha_data;
@@ -2520,7 +2520,7 @@ int ha_partition::open(const char *name,
     bzero(ha_data, sizeof(HA_DATA_PARTITION));
   }
   if (is_not_tmp_table)
-    pthread_mutex_unlock(&table_share->LOCK_ha_data);
+    MYSQL_MUTEX_UNLOCK(&table_share->LOCK_ha_data);
   /*
     Some handlers update statistics as part of the open call. This will in
     some cases corrupt the statistics of the partition handler and thus
@@ -6179,7 +6179,7 @@ int ha_partition::indexes_are_disabled(v
 
 #ifdef NOT_USED
 static HASH partition_open_tables;
-static pthread_mutex_t partition_mutex;
+static mysql_mutex_t partition_mutex;
 static int partition_init= 0;
 
 
@@ -6217,7 +6217,7 @@ static PARTITION_SHARE *get_share(const 
   if (!partition_init)
   {
     /* Hijack a mutex for init'ing the storage engine */
-    pthread_mutex_lock(&LOCK_mysql_create_db);
+    MYSQL_MUTEX_LOCK(&LOCK_mysql_create_db);
     if (!partition_init)
     {
       partition_init++;
@@ -6225,9 +6225,9 @@ static PARTITION_SHARE *get_share(const 
       (void) hash_init(&partition_open_tables, system_charset_info, 32, 0, 0,
 		       (hash_get_key) partition_get_key, 0, 0);
     }
-    pthread_mutex_unlock(&LOCK_mysql_create_db);
+    MYSQL_MUTEX_UNLOCK(&LOCK_mysql_create_db);
   }
-  pthread_mutex_lock(&partition_mutex);
+  MYSQL_MUTEX_LOCK(&partition_mutex);
   length= (uint) strlen(table_name);
 
   if (!(share= (PARTITION_SHARE *) hash_search(&partition_open_tables,
@@ -6238,7 +6238,7 @@ static PARTITION_SHARE *get_share(const 
 			  &share, (uint) sizeof(*share),
 			  &tmp_name, (uint) length + 1, NullS)))
     {
-      pthread_mutex_unlock(&partition_mutex);
+      MYSQL_MUTEX_UNLOCK(&partition_mutex);
       return NULL;
     }
 
@@ -6252,12 +6252,12 @@ static PARTITION_SHARE *get_share(const 
     pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
   }
   share->use_count++;
-  pthread_mutex_unlock(&partition_mutex);
+  MYSQL_MUTEX_UNLOCK(&partition_mutex);
 
   return share;
 
 error:
-  pthread_mutex_unlock(&partition_mutex);
+  MYSQL_MUTEX_UNLOCK(&partition_mutex);
   my_free((uchar*) share, MYF(0));
 
   return NULL;
@@ -6272,15 +6272,15 @@ error:
 
 static int free_share(PARTITION_SHARE *share)
 {
-  pthread_mutex_lock(&partition_mutex);
+  MYSQL_MUTEX_LOCK(&partition_mutex);
   if (!--share->use_count)
   {
     hash_delete(&partition_open_tables, (uchar *) share);
     thr_lock_delete(&share->lock);
-    pthread_mutex_destroy(&share->mutex);
+    MYSQL_MUTEX_DESTROY(&share->mutex);
     my_free((uchar*) share, MYF(0));
   }
-  pthread_mutex_unlock(&partition_mutex);
+  MYSQL_MUTEX_UNLOCK(&partition_mutex);
 
   return 0;
 }

=== modified file 'sql/ha_partition.h'
--- a/sql/ha_partition.h	2008-08-12 08:20:26 +0000
+++ b/sql/ha_partition.h	2008-10-10 20:34:55 +0000
@@ -32,7 +32,7 @@ typedef struct st_partition_share
 {
   char *table_name;
   uint table_name_length, use_count;
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   THR_LOCK lock;
 } PARTITION_SHARE;
 #endif
@@ -864,7 +864,7 @@ private:
     if(table_share->tmp_table == NO_TMP_TABLE)
     {
       auto_increment_lock= TRUE;
-      pthread_mutex_lock(&table_share->LOCK_ha_data);
+      MYSQL_MUTEX_LOCK(&table_share->LOCK_ha_data);
     }
   }
   virtual void unlock_auto_increment()
@@ -877,7 +877,7 @@ private:
     */
     if(auto_increment_lock && !auto_increment_safe_stmt_log_lock)
     {
-      pthread_mutex_unlock(&table_share->LOCK_ha_data);
+      MYSQL_MUTEX_UNLOCK(&table_share->LOCK_ha_data);
       auto_increment_lock= FALSE;
     }
   }

=== modified file 'sql/handler.cc'
--- a/sql/handler.cc	2008-09-04 18:30:34 +0000
+++ b/sql/handler.cc	2008-10-10 20:34:55 +0000
@@ -1553,7 +1553,7 @@ bool mysql_xa_recover(THD *thd)
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_RETURN(1);
 
-  pthread_mutex_lock(&LOCK_xid_cache);
+  MYSQL_MUTEX_LOCK(&LOCK_xid_cache);
   while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
   {
     if (xs->xa_state==XA_PREPARED)
@@ -1566,13 +1566,13 @@ bool mysql_xa_recover(THD *thd)
                       &my_charset_bin);
       if (protocol->write())
       {
-        pthread_mutex_unlock(&LOCK_xid_cache);
+        MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
         DBUG_RETURN(1);
       }
     }
   }
 
-  pthread_mutex_unlock(&LOCK_xid_cache);
+  MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
   my_eof(thd);
   DBUG_RETURN(0);
 }
@@ -3508,12 +3508,12 @@ int ha_init_key_cache(const char *name, 
 
   if (!key_cache->key_cache_inited)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     ulong tmp_buff_size= (ulong) key_cache->param_buff_size;
     uint tmp_block_size= (uint) key_cache->param_block_size;
     uint division_limit= key_cache->param_division_limit;
     uint age_threshold=  key_cache->param_age_threshold;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     DBUG_RETURN(!init_key_cache(key_cache,
 				tmp_block_size,
 				tmp_buff_size,
@@ -3532,12 +3532,12 @@ int ha_resize_key_cache(KEY_CACHE *key_c
 
   if (key_cache->key_cache_inited)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     long tmp_buff_size= (long) key_cache->param_buff_size;
     long tmp_block_size= (long) key_cache->param_block_size;
     uint division_limit= key_cache->param_division_limit;
     uint age_threshold=  key_cache->param_age_threshold;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
 				  tmp_buff_size,
 				  division_limit, age_threshold));
@@ -3553,10 +3553,10 @@ int ha_change_key_cache_param(KEY_CACHE 
 {
   if (key_cache->key_cache_inited)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     uint division_limit= key_cache->param_division_limit;
     uint age_threshold=  key_cache->param_age_threshold;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     change_key_cache_param(key_cache, division_limit, age_threshold);
   }
   return 0;

=== modified file 'sql/hash_filo.h'
--- a/sql/hash_filo.h	2007-05-10 09:59:39 +0000
+++ b/sql/hash_filo.h	2008-10-10 20:34:55 +0000
@@ -34,6 +34,9 @@ class hash_filo_element
   friend class hash_filo;
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_hash_filo_lock;
+#endif
 
 class hash_filo
 {
@@ -45,7 +48,7 @@ class hash_filo
 
   hash_filo_element *first_link,*last_link;
 public:
-  pthread_mutex_t lock;
+  mysql_mutex_t lock;
   HASH cache;
 
   hash_filo(uint size_arg, uint key_offset_arg , uint key_length_arg,
@@ -64,7 +67,7 @@ public:
     {
       if (cache.array.buffer)	/* Avoid problems with thread library */
 	(void) hash_free(&cache);
-      pthread_mutex_destroy(&lock);
+      MYSQL_MUTEX_DESTROY(&lock);
     }
   }
   void clear(bool locked=0)
@@ -72,15 +75,15 @@ public:
     if (!init)
     {
       init=1;
-      (void) pthread_mutex_init(&lock,MY_MUTEX_INIT_FAST);
+      (void) MYSQL_MUTEX_INIT(&lock, key_hash_filo_lock, MY_MUTEX_INIT_FAST);
     }
     if (!locked)
-      (void) pthread_mutex_lock(&lock);
+      (void) MYSQL_MUTEX_LOCK(&lock);
     (void) hash_free(&cache);
     (void) hash_init(&cache,hash_charset,size,key_offset, 
     		     key_length, get_key, free_element,0);
     if (!locked)
-      (void) pthread_mutex_unlock(&lock);
+      (void) MYSQL_MUTEX_UNLOCK(&lock);
     first_link=last_link=0;
   }
 

=== modified file 'sql/hostname.cc'
--- a/sql/hostname.cc	2008-07-08 16:01:41 +0000
+++ b/sql/hostname.cc	2008-10-10 20:34:55 +0000
@@ -49,7 +49,12 @@ public:
 };
 
 static hash_filo *hostname_cache;
-static pthread_mutex_t LOCK_hostname;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_hostname;
+#endif
+
+static mysql_mutex_t LOCK_hostname;
 
 void hostname_cache_refresh()
 {
@@ -66,7 +71,7 @@ bool hostname_cache_init()
 				     &my_charset_bin)))
     return 1;
   hostname_cache->clear();
-  (void) pthread_mutex_init(&LOCK_hostname,MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_hostname, key_LOCK_hostname, MY_MUTEX_INIT_SLOW);
 
   return 0;
 }
@@ -75,7 +80,7 @@ void hostname_cache_free()
 {
   if (hostname_cache)
   {
-    (void) pthread_mutex_destroy(&LOCK_hostname);
+    (void) MYSQL_MUTEX_DESTROY(&LOCK_hostname);
     delete hostname_cache;
     hostname_cache= 0;
   }
@@ -85,7 +90,7 @@ static void add_hostname(struct sockaddr
 {
   if (!(specialflag & SPECIAL_NO_HOST_CACHE))
   {
-    pthread_mutex_lock(&hostname_cache->lock);
+    MYSQL_MUTEX_LOCK(&hostname_cache->lock);
     host_entry *entry;
     if (!(entry=(host_entry*) hostname_cache->search((uchar*) in, 0)))
     {
@@ -104,7 +109,7 @@ static void add_hostname(struct sockaddr
 	(void) hostname_cache->add(entry);
       }
     }
-    pthread_mutex_unlock(&hostname_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&hostname_cache->lock);
   }
 }
 
@@ -115,25 +120,25 @@ inline void add_wrong_ip(struct sockaddr
 
 void inc_host_errors(struct sockaddr_storage *in)
 {
-  pthread_mutex_lock(&hostname_cache->lock);
+  MYSQL_MUTEX_LOCK(&hostname_cache->lock);
   host_entry *entry;
 
   if ((entry=(host_entry*) hostname_cache->search((uchar*)in, 0)))
     entry->errors++;
 
-  pthread_mutex_unlock(&hostname_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&hostname_cache->lock);
 }
 
 
 void reset_host_errors(struct sockaddr_storage *in)
 {
-  pthread_mutex_lock(&hostname_cache->lock);
+  MYSQL_MUTEX_LOCK(&hostname_cache->lock);
   host_entry *entry;
 
   if ((entry=(host_entry*) hostname_cache->search((uchar*)in, 0)))
     entry->errors=0;
 
-  pthread_mutex_unlock(&hostname_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&hostname_cache->lock);
 }
 
 
@@ -177,7 +182,7 @@ char *ip_to_hostname(struct sockaddr_sto
   /* Check first if we have name in cache */
   if (!(specialflag & SPECIAL_NO_HOST_CACHE))
   {
-    pthread_mutex_lock(&hostname_cache->lock);
+    MYSQL_MUTEX_LOCK(&hostname_cache->lock);
     if ((entry= (host_entry*)hostname_cache->search((uchar *)&in, 0)))
     {
       if (entry->hostname)
@@ -187,10 +192,10 @@ char *ip_to_hostname(struct sockaddr_sto
 
       DBUG_PRINT("info",("cached data %s", name ? name : "null" ));
       *errors= entry->errors;
-      pthread_mutex_unlock(&hostname_cache->lock);
+      MYSQL_MUTEX_UNLOCK(&hostname_cache->lock);
       DBUG_RETURN(name);
     }
-    pthread_mutex_unlock(&hostname_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&hostname_cache->lock);
   }
 
   if (!(name= my_strdup(hostname_buff, MYF(0))))

=== modified file 'sql/item_func.cc'
--- a/sql/item_func.cc	2008-08-07 03:05:33 +0000
+++ b/sql/item_func.cc	2008-10-10 20:34:55 +0000
@@ -3261,7 +3261,12 @@ bool udf_handler::get_arguments() { retu
 ** User level locks
 */
 
-pthread_mutex_t LOCK_user_locks;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_user_locks;
+PSI_cond_key key_ULL_cond;
+#endif
+
+mysql_mutex_t LOCK_user_locks;
 static HASH hash_user_locks;
 
 class User_level_lock
@@ -3272,7 +3277,7 @@ class User_level_lock
 public:
   int count;
   bool locked;
-  pthread_cond_t cond;
+  mysql_cond_t cond;
   my_thread_id thread_id;
   void set_thread(THD *thd) { thread_id= thd->thread_id; }
 
@@ -3280,7 +3285,7 @@ public:
     :key_length(length),count(1),locked(1), thread_id(id)
   {
     key= (uchar*) my_memdup(key_arg,length,MYF(0));
-    pthread_cond_init(&cond,NULL);
+    MYSQL_COND_INIT(&cond, key_ULL_cond, NULL);
     if (key)
     {
       if (my_hash_insert(&hash_user_locks,(uchar*) this))
@@ -3297,7 +3302,7 @@ public:
       hash_delete(&hash_user_locks,(uchar*) this);
       my_free(key, MYF(0));
     }
-    pthread_cond_destroy(&cond);
+    MYSQL_COND_DESTROY(&cond);
   }
   inline bool initialized() { return key != 0; }
   friend void item_user_lock_release(User_level_lock *ull);
@@ -3317,7 +3322,7 @@ static bool item_user_lock_inited= 0;
 
 void item_user_lock_init(void)
 {
-  pthread_mutex_init(&LOCK_user_locks,MY_MUTEX_INIT_SLOW);
+  MYSQL_MUTEX_INIT(&LOCK_user_locks, key_LOCK_user_locks, MY_MUTEX_INIT_SLOW);
   hash_init(&hash_user_locks,system_charset_info,
 	    16,0,0,(hash_get_key) ull_get_key,NULL,0);
   item_user_lock_inited= 1;
@@ -3329,7 +3334,7 @@ void item_user_lock_free(void)
   {
     item_user_lock_inited= 0;
     hash_free(&hash_user_locks);
-    pthread_mutex_destroy(&LOCK_user_locks);
+    MYSQL_MUTEX_DESTROY(&LOCK_user_locks);
   }
 }
 
@@ -3338,7 +3343,7 @@ void item_user_lock_release(User_level_l
   ull->locked=0;
   ull->thread_id= 0;
   if (--ull->count)
-    pthread_cond_signal(&ull->cond);
+    MYSQL_COND_SIGNAL(&ull->cond);
   else
     delete ull;
 }
@@ -3402,7 +3407,7 @@ void debug_sync_point(const char* lock_n
   */
   DBUG_ASSERT(thd->ull == NULL);
 
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
   /*
     If the lock has not been aquired by some client, we do not want to
     create an entry for it, since we immediately release the lock. In
@@ -3413,7 +3418,7 @@ void debug_sync_point(const char* lock_n
                                              (uchar*) lock_name,
                                              lock_name_len))))
   {
-    pthread_mutex_unlock(&LOCK_user_locks);
+    MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
     DBUG_VOID_RETURN;
   }
   ull->count++;
@@ -3437,7 +3442,7 @@ void debug_sync_point(const char* lock_n
   set_timespec(abstime,lock_timeout);
   while (ull->locked && !thd->killed)
   {
-    int error= pthread_cond_timedwait(&ull->cond, &LOCK_user_locks, &abstime);
+    int error= MYSQL_COND_TIMEDWAIT(&ull->cond, &LOCK_user_locks, &abstime);
     if (error == ETIMEDOUT || error == ETIME)
       break;
   }
@@ -3453,19 +3458,19 @@ void debug_sync_point(const char* lock_n
     ull->set_thread(thd);
     thd->ull=ull;
   }
-  pthread_mutex_unlock(&LOCK_user_locks);
-  pthread_mutex_lock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
   thd_proc_info(thd, 0);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
   if (thd->ull)
   {
     item_user_lock_release(thd->ull);
     thd->ull=0;
   }
-  pthread_mutex_unlock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
   DBUG_VOID_RETURN;
 }
 
@@ -3479,13 +3484,13 @@ void debug_sync_point(const char* lock_n
   @param lock the associated mutex
   @param abstime the amount of time in seconds to wait
 
-  @retval return value from pthread_cond_timedwait
+  @retval return value from MYSQL_COND_TIMEDWAIT
 */
 
 #define INTERRUPT_INTERVAL (5 * ULL(1000000000))
 
-static int interruptible_wait(THD *thd, pthread_cond_t *cond,
-                              pthread_mutex_t *lock, double time)
+static int interruptible_wait(THD *thd, mysql_cond_t *cond,
+                              mysql_mutex_t *lock, double time)
 {
   int error;
   struct timespec abstime;
@@ -3501,7 +3506,7 @@ static int interruptible_wait(THD *thd, 
 
     timeout-= slice;
     set_timespec_nsec(abstime, slice);
-    error= pthread_cond_timedwait(cond, lock, &abstime);
+    error= MYSQL_COND_TIMEDWAIT(cond, lock, &abstime);
     if (error == ETIMEDOUT || error == ETIME)
     {
       /* Return error if timed out or connection is broken. */
@@ -3544,11 +3549,11 @@ longlong Item_func_get_lock::val_int()
   if (thd->slave_thread)
     DBUG_RETURN(1);
 
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
 
   if (!res || !res->length())
   {
-    pthread_mutex_unlock(&LOCK_user_locks);
+    MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
     null_value=1;
     DBUG_RETURN(0);
   }
@@ -3571,13 +3576,13 @@ longlong Item_func_get_lock::val_int()
     if (!ull || !ull->initialized())
     {
       delete ull;
-      pthread_mutex_unlock(&LOCK_user_locks);
+      MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
       null_value=1;				// Probably out of memory
       DBUG_RETURN(0);
     }
     ull->set_thread(thd);
     thd->ull=ull;
-    pthread_mutex_unlock(&LOCK_user_locks);
+    MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
     DBUG_PRINT("info", ("made new lock"));
     DBUG_RETURN(1);				// Got new lock
   }
@@ -3627,13 +3632,13 @@ longlong Item_func_get_lock::val_int()
     error=0;
     DBUG_PRINT("info", ("got the lock"));
   }
-  pthread_mutex_unlock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
 
-  pthread_mutex_lock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
   thd_proc_info(thd, 0);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
 
   DBUG_RETURN(!error ? 1 : 0);
 }
@@ -3664,7 +3669,7 @@ longlong Item_func_release_lock::val_int
   null_value=0;
 
   result=0;
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
   if (!(ull= ((User_level_lock*) hash_search(&hash_user_locks,
                                              (const uchar*) res->ptr(),
                                              (size_t) res->length()))))
@@ -3685,7 +3690,7 @@ longlong Item_func_release_lock::val_int
       thd->ull=0;
     }
   }
-  pthread_mutex_unlock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
   DBUG_RETURN(result);
 }
 
@@ -3785,13 +3790,16 @@ void Item_func_benchmark::print(String *
   str->append(')');
 }
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_cond_key key_Item_func_sleep_cond;
+#endif
 
 /** This function is just used to create tests with time gaps. */
 
 longlong Item_func_sleep::val_int()
 {
   THD *thd= current_thd;
-  pthread_cond_t cond;
+  mysql_cond_t cond;
   double timeout;
   int error;
 
@@ -3799,19 +3807,19 @@ longlong Item_func_sleep::val_int()
 
   timeout= args[0]->val_real();
   /*
-    On 64-bit OSX pthread_cond_timedwait() waits forever
+    On 64-bit OSX MYSQL_COND_TIMEDWAIT() waits forever
     if passed abstime time has already been exceeded by 
     the system time.
     When given a very short timeout (< 10 mcs) just return 
     immediately.
     We assume that the lines between this test and the call 
-    to pthread_cond_timedwait() will be executed in less than 0.00001 sec.
+    to MYSQL_COND_TIMEDWAIT() will be executed in less than 0.00001 sec.
   */
   if (timeout < 0.00001)
     return 0;
 
-  pthread_cond_init(&cond, NULL);
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_COND_INIT(&cond, key_Item_func_sleep_cond, NULL);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
 
   thd_proc_info(thd, "User sleep");
   thd->mysys_var->current_mutex= &LOCK_user_locks;
@@ -3826,13 +3834,13 @@ longlong Item_func_sleep::val_int()
     error= 0;
   }
   thd_proc_info(thd, 0);
-  pthread_mutex_unlock(&LOCK_user_locks);
-  pthread_mutex_lock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
 
-  pthread_cond_destroy(&cond);
+  MYSQL_COND_DESTROY(&cond);
 
   return test(!error); 		// Return 1 killed
 }
@@ -5306,10 +5314,10 @@ longlong Item_func_is_free_lock::val_int
     return 0;
   }
   
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
   ull= (User_level_lock *) hash_search(&hash_user_locks, (uchar*) res->ptr(),
                                        (size_t) res->length());
-  pthread_mutex_unlock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
   if (!ull || !ull->locked)
     return 1;
   return 0;
@@ -5325,10 +5333,10 @@ longlong Item_func_is_used_lock::val_int
   if (!res || !res->length())
     return 0;
   
-  pthread_mutex_lock(&LOCK_user_locks);
+  MYSQL_MUTEX_LOCK(&LOCK_user_locks);
   ull= (User_level_lock *) hash_search(&hash_user_locks, (uchar*) res->ptr(),
                                        (size_t) res->length());
-  pthread_mutex_unlock(&LOCK_user_locks);
+  MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
   if (!ull || !ull->locked)
     return 0;
 
@@ -5765,13 +5773,13 @@ void uuid_short_init()
                (((ulonglong) server_start_time) << 24));
 }
 
-pthread_mutex_t LOCK_uuid_short;
+mysql_mutex_t LOCK_uuid_short;
 
 longlong Item_func_uuid_short::val_int()
 {
   ulonglong val;
-  pthread_mutex_lock(&LOCK_uuid_short);
+  MYSQL_MUTEX_LOCK(&LOCK_uuid_short);
   val= uuid_value++;
-  pthread_mutex_unlock(&LOCK_uuid_short);
+  MYSQL_MUTEX_UNLOCK(&LOCK_uuid_short);
   return (longlong) val;
 }

=== modified file 'sql/item_strfunc.cc'
--- a/sql/item_strfunc.cc	2008-07-25 17:21:55 +0000
+++ b/sql/item_strfunc.cc	2008-10-10 20:34:55 +0000
@@ -612,18 +612,18 @@ String *Item_func_des_encrypt::val_str(S
   if (arg_count == 1)
   {
     /* Protect against someone doing FLUSH DES_KEY_FILE */
-    pthread_mutex_lock(&LOCK_des_key_file);
+    MYSQL_MUTEX_LOCK(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number=des_default_key];
-    pthread_mutex_unlock(&LOCK_des_key_file);
+    MYSQL_MUTEX_UNLOCK(&LOCK_des_key_file);
   }
   else if (args[1]->result_type() == INT_RESULT)
   {
     key_number= (uint) args[1]->val_int();
     if (key_number > 9)
       goto error;
-    pthread_mutex_lock(&LOCK_des_key_file);
+    MYSQL_MUTEX_LOCK(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number];
-    pthread_mutex_unlock(&LOCK_des_key_file);
+    MYSQL_MUTEX_UNLOCK(&LOCK_des_key_file);
   }
   else
   {
@@ -709,9 +709,9 @@ String *Item_func_des_decrypt::val_str(S
         key_number > 9)
       goto error;
 
-    pthread_mutex_lock(&LOCK_des_key_file);
+    MYSQL_MUTEX_LOCK(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number];
-    pthread_mutex_unlock(&LOCK_des_key_file);
+    MYSQL_MUTEX_UNLOCK(&LOCK_des_key_file);
   }
   else
   {
@@ -1838,17 +1838,17 @@ String *Item_func_encrypt::val_str(Strin
       return 0;
     salt_ptr= salt_str->c_ptr();
   }
-  pthread_mutex_lock(&LOCK_crypt);
+  MYSQL_MUTEX_LOCK(&LOCK_crypt);
   char *tmp= crypt(res->c_ptr(),salt_ptr);
   if (!tmp)
   {
-    pthread_mutex_unlock(&LOCK_crypt);
+    MYSQL_MUTEX_UNLOCK(&LOCK_crypt);
     null_value= 1;
     return 0;
   }
   str->set(tmp, (uint) strlen(tmp), &my_charset_bin);
   str->copy();
-  pthread_mutex_unlock(&LOCK_crypt);
+  MYSQL_MUTEX_UNLOCK(&LOCK_crypt);
   return str;
 #else
   null_value=1;

=== modified file 'sql/lock.cc'
--- a/sql/lock.cc	2008-08-08 01:33:43 +0000
+++ b/sql/lock.cc	2008-10-10 20:34:55 +0000
@@ -1104,7 +1104,7 @@ bool lock_global_read_lock(THD *thd)
   {
     const char *old_message;
     const char *new_message= "Waiting to get readlock";
-    (void) pthread_mutex_lock(&LOCK_global_read_lock);
+    (void) MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
 
 #if defined(ENABLED_DEBUG_SYNC)
     /*
@@ -1136,7 +1136,7 @@ bool lock_global_read_lock(THD *thd)
 
     waiting_for_read_lock++;
     while (protect_against_global_read_lock && !thd->killed)
-      pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
+      MYSQL_COND_WAIT(&COND_global_read_lock, &LOCK_global_read_lock);
     waiting_for_read_lock--;
     if (thd->killed)
     {
@@ -1163,13 +1163,13 @@ bool lock_global_read_lock(THD *thd)
     if (mdl_acquire_global_shared_lock(&thd->mdl_context))
     {
       /* Our thread was killed -- return back to initial state. */
-      pthread_mutex_lock(&LOCK_global_read_lock);
+      MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
       if (!(--global_read_lock))
       {
         DBUG_PRINT("signal", ("Broadcasting COND_global_read_lock"));
-        pthread_cond_broadcast(&COND_global_read_lock);
+        MYSQL_COND_BROADCAST(&COND_global_read_lock);
       }
-      pthread_mutex_unlock(&LOCK_global_read_lock);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_read_lock);
       thd->global_read_lock= 0;
       DBUG_RETURN(1);
     }
@@ -1196,16 +1196,16 @@ void unlock_global_read_lock(THD *thd)
 
   mdl_release_global_shared_lock(&thd->mdl_context);
 
-  pthread_mutex_lock(&LOCK_global_read_lock);
+  MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
   tmp= --global_read_lock;
   if (thd->global_read_lock == MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT)
     --global_read_lock_blocks_commit;
-  pthread_mutex_unlock(&LOCK_global_read_lock);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_read_lock);
   /* Send the signal outside the mutex to avoid a context switch */
   if (!tmp)
   {
     DBUG_PRINT("signal", ("Broadcasting COND_global_read_lock"));
-    pthread_cond_broadcast(&COND_global_read_lock);
+    MYSQL_COND_BROADCAST(&COND_global_read_lock);
   }
   thd->global_read_lock= 0;
 
@@ -1229,9 +1229,9 @@ bool wait_if_global_read_lock(THD *thd, 
     threads could not close their tables. This would make a pretty
     deadlock.
   */
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
-  (void) pthread_mutex_lock(&LOCK_global_read_lock);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
   if ((need_exit_cond= must_wait))
   {
     const char *new_message= "Waiting for release of readlock";
@@ -1241,7 +1241,7 @@ bool wait_if_global_read_lock(THD *thd, 
       if (is_not_commit)
         my_message(ER_CANT_UPDATE_WITH_READLOCK,
                    ER(ER_CANT_UPDATE_WITH_READLOCK), MYF(0));
-      (void) pthread_mutex_unlock(&LOCK_global_read_lock);
+      (void) MYSQL_MUTEX_UNLOCK(&LOCK_global_read_lock);
       /*
         We allow FLUSHer to COMMIT; we assume FLUSHer knows what it does.
         This allowance is needed to not break existing versions of innobackup
@@ -1278,7 +1278,7 @@ bool wait_if_global_read_lock(THD *thd, 
 	   (!abort_on_refresh || thd->version == refresh_version))
     {
       DBUG_PRINT("signal", ("Waiting for COND_global_read_lock"));
-      (void) pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
+      (void) MYSQL_COND_WAIT(&COND_global_read_lock, &LOCK_global_read_lock);
       DBUG_PRINT("signal", ("Got COND_global_read_lock"));
     }
     if (thd->killed)
@@ -1297,7 +1297,7 @@ bool wait_if_global_read_lock(THD *thd, 
   if (unlikely(need_exit_cond))
     thd->exit_cond(old_message); // this unlocks LOCK_global_read_lock
   else
-    pthread_mutex_unlock(&LOCK_global_read_lock);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_read_lock);
   DBUG_RETURN(result);
 }
 
@@ -1308,15 +1308,15 @@ void start_waiting_global_read_lock(THD 
   DBUG_ENTER("start_waiting_global_read_lock");
   if (unlikely(thd->global_read_lock))
     DBUG_VOID_RETURN;
-  (void) pthread_mutex_lock(&LOCK_global_read_lock);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
   DBUG_ASSERT(protect_against_global_read_lock);
   tmp= (!--protect_against_global_read_lock &&
         (waiting_for_read_lock || global_read_lock_blocks_commit));
   DBUG_PRINT("sql_lock", ("protect_against_global_read_lock decr: %u",
                           protect_against_global_read_lock));
-  (void) pthread_mutex_unlock(&LOCK_global_read_lock);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_global_read_lock);
   if (tmp)
-    pthread_cond_broadcast(&COND_global_read_lock);
+    MYSQL_COND_BROADCAST(&COND_global_read_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -1332,7 +1332,7 @@ bool make_global_read_lock_block_commit(
   */
   if (thd->global_read_lock != GOT_GLOBAL_READ_LOCK)
     DBUG_RETURN(0);
-  pthread_mutex_lock(&LOCK_global_read_lock);
+  MYSQL_MUTEX_LOCK(&LOCK_global_read_lock);
   /* increment this BEFORE waiting on cond (otherwise race cond) */
   global_read_lock_blocks_commit++;
   /* For testing we set up some blocking, to see if we can be killed */
@@ -1341,7 +1341,7 @@ bool make_global_read_lock_block_commit(
   old_message= thd->enter_cond(&COND_global_read_lock, &LOCK_global_read_lock,
                                "Waiting for all running commits to finish");
   while (protect_against_global_read_lock && !thd->killed)
-    pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
+    MYSQL_COND_WAIT(&COND_global_read_lock, &LOCK_global_read_lock);
   DBUG_EXECUTE_IF("make_global_read_lock_block_commit_loop",
                   protect_against_global_read_lock--;);
   if ((error= test(thd->killed)))
@@ -1359,7 +1359,7 @@ bool make_global_read_lock_block_commit(
     Due to a bug in a threading library it could happen that a signal
     did not reach its target. A condition for this was that the same
     condition variable was used with different mutexes in
-    pthread_cond_wait(). Some time ago we changed LOCK_open to
+    MYSQL_COND_WAIT(). Some time ago we changed LOCK_open to
     LOCK_global_read_lock in global read lock handling. So COND_refresh
     was used with LOCK_open and LOCK_global_read_lock.
 
@@ -1374,8 +1374,8 @@ bool make_global_read_lock_block_commit(
 
 void broadcast_refresh(void)
 {
-  pthread_cond_broadcast(&COND_refresh);
-  pthread_cond_broadcast(&COND_global_read_lock);
+  MYSQL_COND_BROADCAST(&COND_refresh);
+  MYSQL_COND_BROADCAST(&COND_global_read_lock);
 }
 
 

=== modified file 'sql/log.cc'
--- a/sql/log.cc	2008-09-11 18:21:54 +0000
+++ b/sql/log.cc	2008-10-10 20:34:55 +0000
@@ -144,24 +144,24 @@ char *make_backup_log_name(char *buff, c
 class Mutex_sentry
 {
 public:
-  Mutex_sentry(pthread_mutex_t *mutex)
+  Mutex_sentry(mysql_mutex_t *mutex)
     : m_mutex(mutex)
   {
     if (m_mutex)
-      pthread_mutex_lock(mutex);
+      MYSQL_MUTEX_LOCK(mutex);
   }
 
   ~Mutex_sentry()
   {
     if (m_mutex)
-      pthread_mutex_unlock(m_mutex);
+      MYSQL_MUTEX_UNLOCK(m_mutex);
 #ifndef DBUG_OFF
     m_mutex= 0;
 #endif
   }
 
 private:
-  pthread_mutex_t *m_mutex;
+  mysql_mutex_t *m_mutex;
 
   // It's not allowed to copy this object in any way
   Mutex_sentry(Mutex_sentry const&);
@@ -1302,7 +1302,7 @@ bool LOGGER::error_log_print(enum loglev
 void LOGGER::cleanup_base()
 {
   DBUG_ASSERT(inited == 1);
-  rwlock_destroy(&LOCK_logger);
+  MYSQL_RWLOCK_DESTROY(&LOCK_logger);
   if (table_log_handler)
   {
     table_log_handler->cleanup();
@@ -1342,7 +1342,7 @@ void LOGGER::init_base()
   init_error_log(LOG_FILE);
 
   file_log_handler->init_pthread_objects();
-  my_rwlock_init(&LOCK_logger, NULL);
+  MYSQL_RWLOCK_INIT(&LOCK_logger, key_LOCK_logger, NULL);
 }
 
 
@@ -2703,7 +2703,7 @@ void MYSQL_LOG::init_pthread_objects()
 {
   DBUG_ASSERT(inited == 0);
   inited= 1;
-  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_log, key_LOG_LOCK_log, MY_MUTEX_INIT_SLOW);
 }
 
 /*
@@ -2754,7 +2754,7 @@ void MYSQL_LOG::cleanup()
   if (inited)
   {
     inited= 0;
-    (void) pthread_mutex_destroy(&LOCK_log);
+    (void) MYSQL_MUTEX_DESTROY(&LOCK_log);
     close(0);
   }
   DBUG_VOID_RETURN;
@@ -2802,7 +2802,7 @@ void MYSQL_QUERY_LOG::reopen_file()
     DBUG_VOID_RETURN;
   }
 
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
 
   save_name= name;
   name= 0;				// Don't free name
@@ -2815,7 +2815,7 @@ void MYSQL_QUERY_LOG::reopen_file()
   open(save_name, log_type, 0, io_cache_type);
   my_free(save_name, MYF(0));
 
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
 
   DBUG_VOID_RETURN;
 }
@@ -2857,7 +2857,7 @@ bool MYSQL_QUERY_LOG::write(time_t event
   struct tm start;
   uint time_buff_len= 0;
 
-  (void) pthread_mutex_lock(&LOCK_log);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_log);
 
   /* Test if someone closed between the is_open test and lock */
   if (is_open())
@@ -2903,7 +2903,7 @@ bool MYSQL_QUERY_LOG::write(time_t event
       goto err;
   }
 
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   return FALSE;
 err:
 
@@ -2912,7 +2912,7 @@ err:
     write_error= 1;
     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
   }
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   return TRUE;
 }
 
@@ -2955,11 +2955,11 @@ bool MYSQL_QUERY_LOG::write(THD *thd, ti
   bool error= 0;
   DBUG_ENTER("MYSQL_QUERY_LOG::write");
 
-  (void) pthread_mutex_lock(&LOCK_log);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_log);
 
   if (!is_open())
   {
-    (void) pthread_mutex_unlock(&LOCK_log);
+    (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
     DBUG_RETURN(0);
   }
 
@@ -3068,7 +3068,7 @@ bool MYSQL_QUERY_LOG::write(THD *thd, ti
       }
     }
   }
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   DBUG_RETURN(error);
 }
 
@@ -3300,7 +3300,7 @@ bool MYSQL_BACKUP_LOG::write(THD *thd, s
 
   save_time_zone_used= thd->time_zone_used;
 
-  (void) pthread_mutex_lock(&LOCK_log);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_log);
 
   /* 
     Test if someone closed between the is_open test and lock 
@@ -3350,7 +3350,7 @@ bool MYSQL_BACKUP_LOG::write(THD *thd, s
       goto err;
   }
 
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   thd->time_zone_used= save_time_zone_used;
   return FALSE;
 err:
@@ -3360,7 +3360,7 @@ err:
     write_error= 1;
     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
   }
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   thd->time_zone_used= save_time_zone_used;
   return TRUE;
 }
@@ -3392,7 +3392,7 @@ bool MYSQL_BACKUP_LOG::write(THD *thd, u
 
   save_time_zone_used= thd->time_zone_used;
 
-  (void) pthread_mutex_lock(&LOCK_log);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_log);
 
   /* 
     Test if someone closed between the is_open test and lock 
@@ -3424,7 +3424,7 @@ bool MYSQL_BACKUP_LOG::write(THD *thd, u
       goto err;
   }
 
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   thd->time_zone_used= save_time_zone_used;
   return FALSE;
 err:
@@ -3434,7 +3434,7 @@ err:
     write_error= 1;
     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
   }
-  (void) pthread_mutex_unlock(&LOCK_log);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_log);
   thd->time_zone_used= save_time_zone_used;
   return TRUE;
 }
@@ -3531,7 +3531,7 @@ ulonglong MYSQL_BACKUP_LOG::get_next_bac
     m_next_id == 0 means we need to read the next id from the file (on startup).
     m_next_id > 0 means use this value
   */
-  pthread_mutex_lock(&LOCK_backupid);
+  MYSQL_MUTEX_LOCK(&LOCK_backupid);
   if (!m_next_id)
   {
     file_path= make_backup_log_name(buff, BACKUP_SETTINGS_NAME.str, ".obx");
@@ -3598,7 +3598,7 @@ err:
   
 err_end:
   m_next_id= id;
-  pthread_mutex_unlock(&LOCK_backupid);
+  MYSQL_MUTEX_UNLOCK(&LOCK_backupid);
   DBUG_PRINT("backup_log",("The next id is %lu.\n", (ulong)id));
   if(read_id)
     my_free(read_id, MYF(0));
@@ -3626,7 +3626,7 @@ void MYSQL_BACKUP_LOG::reopen_file(bool 
     DBUG_VOID_RETURN;
   }
 
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
 
   save_name= name;
   name= 0;            // Don't free name
@@ -3639,7 +3639,7 @@ void MYSQL_BACKUP_LOG::reopen_file(bool 
   open(save_name, log_type, 0, io_cache_type, history);
   my_free(save_name, MYF(0));
 
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
 
   DBUG_VOID_RETURN;
 }
@@ -3699,9 +3699,9 @@ void MYSQL_BIN_LOG::cleanup()
     close(LOG_CLOSE_INDEX|LOG_CLOSE_STOP_EVENT);
     delete description_event_for_queue;
     delete description_event_for_exec;
-    (void) pthread_mutex_destroy(&LOCK_log);
-    (void) pthread_mutex_destroy(&LOCK_index);
-    (void) pthread_cond_destroy(&update_cond);
+    (void) MYSQL_MUTEX_DESTROY(&LOCK_log);
+    (void) MYSQL_MUTEX_DESTROY(&LOCK_index);
+    (void) MYSQL_COND_DESTROY(&update_cond);
   }
   DBUG_VOID_RETURN;
 }
@@ -3722,9 +3722,9 @@ void MYSQL_BIN_LOG::init_pthread_objects
 {
   DBUG_ASSERT(inited == 0);
   inited= 1;
-  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);
-  (void) pthread_cond_init(&update_cond, 0);
+  (void) MYSQL_MUTEX_INIT(&LOCK_log, key_LOG_LOCK_log, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_index, key_BINLOG_LOCK_index, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_COND_INIT(&update_cond, key_BINLOG_update_cond, 0);
 }
 
 
@@ -3918,9 +3918,9 @@ shutdown the MySQL server and restart it
 
 int MYSQL_BIN_LOG::get_current_log(LOG_INFO* linfo)
 {
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
   int ret = raw_get_current_log(linfo);
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   return ret;
 }
 
@@ -4021,8 +4021,8 @@ int MYSQL_BIN_LOG::find_log_pos(LOG_INFO
     move from under our feet
   */
   if (need_lock)
-    pthread_mutex_lock(&LOCK_index);
-  safe_mutex_assert_owner(&LOCK_index);
+    MYSQL_MUTEX_LOCK(&LOCK_index);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_index);
 
   /* As the file is flushed, we can't get an error here */
   (void) reinit_io_cache(&index_file, READ_CACHE, (my_off_t) 0, 0, 0);
@@ -4054,7 +4054,7 @@ int MYSQL_BIN_LOG::find_log_pos(LOG_INFO
   }
 
   if (need_lock)
-    pthread_mutex_unlock(&LOCK_index);
+    MYSQL_MUTEX_UNLOCK(&LOCK_index);
   DBUG_RETURN(error);
 }
 
@@ -4090,8 +4090,8 @@ int MYSQL_BIN_LOG::find_next_log(LOG_INF
   char *fname= linfo->log_file_name;
 
   if (need_lock)
-    pthread_mutex_lock(&LOCK_index);
-  safe_mutex_assert_owner(&LOCK_index);
+    MYSQL_MUTEX_LOCK(&LOCK_index);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_index);
 
   /* As the file is flushed, we can't get an error here */
   (void) reinit_io_cache(&index_file, READ_CACHE, linfo->index_file_offset, 0,
@@ -4108,7 +4108,7 @@ int MYSQL_BIN_LOG::find_next_log(LOG_INF
 
 err:
   if (need_lock)
-    pthread_mutex_unlock(&LOCK_index);
+    MYSQL_MUTEX_UNLOCK(&LOCK_index);
   return error;
 }
 
@@ -4142,8 +4142,8 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
     We need to get both locks to be sure that no one is trying to
     write to the index log file.
   */
-  pthread_mutex_lock(&LOCK_log);
-  pthread_mutex_lock(&LOCK_index);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_index);
 
   /*
     The following mutex is needed to ensure that no threads call
@@ -4151,7 +4151,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
     thread. If the transaction involved MyISAM tables, it should go
     into binlog even on rollback.
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   /* Save variables so that we can reopen the log */
   save_name=name;
@@ -4231,9 +4231,9 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
   my_free((uchar*) save_name, MYF(0));
 
 err:
-  pthread_mutex_unlock(&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_index);
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_index);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   DBUG_RETURN(error);
 }
 
@@ -4286,20 +4286,20 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
   DBUG_ASSERT(rli->slave_running == 1);
   DBUG_ASSERT(!strcmp(rli->linfo.log_file_name,rli->event_relay_log_name));
 
-  pthread_mutex_lock(&LOCK_index);
-  pthread_mutex_lock(&rli->log_space_lock);
+  MYSQL_MUTEX_LOCK(&LOCK_index);
+  MYSQL_MUTEX_LOCK(&rli->log_space_lock);
   rli->relay_log.purge_logs(rli->group_relay_log_name, included,
                             0, 0, &rli->log_space_total);
   // Tell the I/O thread to take the relay_log_space_limit into account
   rli->ignore_log_space_limit= 0;
-  pthread_mutex_unlock(&rli->log_space_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->log_space_lock);
 
   /*
     Ok to broadcast after the critical region as there is no risk of
     the mutex being destroyed by this thread later - this helps save
     context switches
   */
-  pthread_cond_broadcast(&rli->log_space_cond);
+  MYSQL_COND_BROADCAST(&rli->log_space_cond);
   
   /*
     Read the next log file name from the index file and pass it back to
@@ -4345,7 +4345,7 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
   flush_relay_log_info(rli);
 
 err:
-  pthread_mutex_unlock(&LOCK_index);
+  MYSQL_MUTEX_UNLOCK(&LOCK_index);
   DBUG_RETURN(error);
 }
 
@@ -4403,7 +4403,7 @@ int MYSQL_BIN_LOG::purge_logs(const char
   DBUG_PRINT("info",("to_log= %s",to_log));
 
   if (need_mutex)
-    pthread_mutex_lock(&LOCK_index);
+    MYSQL_MUTEX_LOCK(&LOCK_index);
   if ((error=find_log_pos(&log_info, to_log, 0 /*no mutex*/)))
     goto err;
 
@@ -4534,7 +4534,7 @@ int MYSQL_BIN_LOG::purge_logs(const char
 
 err:
   if (need_mutex)
-    pthread_mutex_unlock(&LOCK_index);
+    MYSQL_MUTEX_UNLOCK(&LOCK_index);
   DBUG_RETURN(error);
 }
 
@@ -4566,7 +4566,7 @@ int MYSQL_BIN_LOG::purge_logs_before_dat
   
   DBUG_ENTER("purge_logs_before_date");
 
-  pthread_mutex_lock(&LOCK_index);
+  MYSQL_MUTEX_LOCK(&LOCK_index);
 
   /*
     Delete until we find curren file
@@ -4673,7 +4673,7 @@ int MYSQL_BIN_LOG::purge_logs_before_dat
   error= update_log_index(&log_info, 1);
 
 err:
-  pthread_mutex_unlock(&LOCK_index);
+  MYSQL_MUTEX_UNLOCK(&LOCK_index);
   DBUG_RETURN(error);
 }
 #endif /* HAVE_REPLICATION */
@@ -4749,11 +4749,11 @@ void MYSQL_BIN_LOG::new_file_impl(bool n
   }
 
   if (need_lock)
-    pthread_mutex_lock(&LOCK_log);
-  pthread_mutex_lock(&LOCK_index);
+    MYSQL_MUTEX_LOCK(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_index);
 
-  safe_mutex_assert_owner(&LOCK_log);
-  safe_mutex_assert_owner(&LOCK_index);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_log);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_index);
 
   /*
     if binlog is used as tc log, be sure all xids are "unlogged",
@@ -4767,12 +4767,12 @@ void MYSQL_BIN_LOG::new_file_impl(bool n
   if (prepared_xids)
   {
     tc_log_page_waits++;
-    pthread_mutex_lock(&LOCK_prep_xids);
+    MYSQL_MUTEX_LOCK(&LOCK_prep_xids);
     while (prepared_xids) {
       DBUG_PRINT("info", ("prepared_xids=%lu", prepared_xids));
-      pthread_cond_wait(&COND_prep_xids, &LOCK_prep_xids);
+      MYSQL_COND_WAIT(&COND_prep_xids, &LOCK_prep_xids);
     }
-    pthread_mutex_unlock(&LOCK_prep_xids);
+    MYSQL_MUTEX_UNLOCK(&LOCK_prep_xids);
   }
 
   /* Reuse old name if not binlog and not update log */
@@ -4830,8 +4830,8 @@ void MYSQL_BIN_LOG::new_file_impl(bool n
 
 end:
   if (need_lock)
-    pthread_mutex_unlock(&LOCK_log);
-  pthread_mutex_unlock(&LOCK_index);
+    MYSQL_MUTEX_UNLOCK(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_index);
 
   DBUG_VOID_RETURN;
 }
@@ -4840,7 +4840,7 @@ end:
 bool MYSQL_BIN_LOG::append(Log_event* ev)
 {
   bool error = 0;
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
   DBUG_ENTER("MYSQL_BIN_LOG::append");
 
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
@@ -4859,7 +4859,7 @@ bool MYSQL_BIN_LOG::append(Log_event* ev
     new_file_without_locking();
 
 err:
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   signal_update();				// Safe as we don't call close
   DBUG_RETURN(error);
 }
@@ -4874,7 +4874,7 @@ bool MYSQL_BIN_LOG::appendv(const char* 
 
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
 
-  safe_mutex_assert_owner(&LOCK_log);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_log);
   do
   {
     if (my_b_append(&log_file,(uchar*) buf,len))
@@ -4898,7 +4898,7 @@ err:
 bool MYSQL_BIN_LOG::flush_and_sync()
 {
   int err=0, fd=log_file.file;
-  safe_mutex_assert_owner(&LOCK_log);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_log);
   if (flush_io_cache(&log_file))
     return 1;
   if (++sync_binlog_counter >= sync_binlog_period && sync_binlog_period)
@@ -5136,14 +5136,14 @@ MYSQL_BIN_LOG::flush_and_set_pending_row
       m_table_map_version below, and that change has to be protected
       by the LOCK_log mutex.
     */
-    pthread_mutex_lock(&LOCK_log);
+    MYSQL_MUTEX_LOCK(&LOCK_log);
 
     /*
       Write pending event to log file or transaction cache
     */
     if (pending->write(file))
     {
-      pthread_mutex_unlock(&LOCK_log);
+      MYSQL_MUTEX_UNLOCK(&LOCK_log);
       DBUG_RETURN(1);
     }
 
@@ -5177,7 +5177,7 @@ MYSQL_BIN_LOG::flush_and_set_pending_row
       }
     }
 
-    pthread_mutex_unlock(&LOCK_log);
+    MYSQL_MUTEX_UNLOCK(&LOCK_log);
   }
 
   thd->binlog_set_pending_rows_event(event);
@@ -5220,7 +5220,7 @@ bool MYSQL_BIN_LOG::write(Log_event *eve
     thd->locked_tables_mode && thd->lex->requires_prelocking();
   thd->binlog_flush_pending_rows_event(end_stmt);
 
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
 
   /*
      In most cases this is only called if 'is_open()' is true; in fact this is
@@ -5240,7 +5240,7 @@ bool MYSQL_BIN_LOG::write(Log_event *eve
     if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
 	(!binlog_filter->db_ok(local_db)))
     {
-      pthread_mutex_unlock(&LOCK_log);
+      MYSQL_MUTEX_UNLOCK(&LOCK_log);
       DBUG_RETURN(0);
     }
 #endif /* HAVE_REPLICATION */
@@ -5378,7 +5378,7 @@ err:
   if (event_info->flags & LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F)
     ++m_table_map_version;
 
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   DBUG_RETURN(error);
 }
 
@@ -5455,7 +5455,7 @@ bool general_log_write(THD *thd, enum en
 void MYSQL_BIN_LOG::rotate_and_purge(uint flags)
 {
   if (!(flags & RP_LOCK_LOG_IS_ALREADY_LOCKED))
-    pthread_mutex_lock(&LOCK_log);
+    MYSQL_MUTEX_LOCK(&LOCK_log);
   if ((flags & RP_FORCE_ROTATE) ||
       (my_b_tell(&log_file) >= (my_off_t) max_size))
   {
@@ -5470,15 +5470,15 @@ void MYSQL_BIN_LOG::rotate_and_purge(uin
 #endif
   }
   if (!(flags & RP_LOCK_LOG_IS_ALREADY_LOCKED))
-    pthread_mutex_unlock(&LOCK_log);
+    MYSQL_MUTEX_UNLOCK(&LOCK_log);
 }
 
 uint MYSQL_BIN_LOG::next_file_id()
 {
   uint res;
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
   res = file_id++;
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   return res;
 }
 
@@ -5648,7 +5648,7 @@ int MYSQL_BIN_LOG::write_cache(IO_CACHE 
 bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)
 {
   DBUG_ENTER("MYSQL_BIN_LOG::write(THD *, IO_CACHE *, Log_event *)");
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
 
   /* NULL would represent nothing to replicate after ROLLBACK */
   DBUG_ASSERT(commit_event != NULL);
@@ -5727,14 +5727,14 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_C
     */
     if (commit_event && commit_event->get_type_code() == XID_EVENT)
     {
-      pthread_mutex_lock(&LOCK_prep_xids);
+      MYSQL_MUTEX_LOCK(&LOCK_prep_xids);
       prepared_xids++;
-      pthread_mutex_unlock(&LOCK_prep_xids);
+      MYSQL_MUTEX_UNLOCK(&LOCK_prep_xids);
     }
     else
       rotate_and_purge(RP_LOCK_LOG_IS_ALREADY_LOCKED);
   }
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
 
   DBUG_RETURN(0);
 
@@ -5744,7 +5744,7 @@ err:
     write_error= 1;
     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
   }
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   DBUG_RETURN(1);
 }
 
@@ -5766,7 +5766,7 @@ void MYSQL_BIN_LOG::wait_for_update_rela
                            "Slave has read all relay log; " 
                            "waiting for the slave I/O "
                            "thread to update it" );
-  pthread_cond_wait(&update_cond, &LOCK_log);
+  MYSQL_COND_WAIT(&update_cond, &LOCK_log);
   thd->exit_cond(old_msg);
   DBUG_VOID_RETURN;
 }
@@ -5798,9 +5798,9 @@ int MYSQL_BIN_LOG::wait_for_update_bin_l
                            "Master has sent all binlog to slave; "
                            "waiting for binlog to be updated");
   if (!timeout)
-    pthread_cond_wait(&update_cond, &LOCK_log);
+    MYSQL_COND_WAIT(&update_cond, &LOCK_log);
   else
-    ret= pthread_cond_timedwait(&update_cond, &LOCK_log,
+    ret= MYSQL_COND_TIMEDWAIT(&update_cond, &LOCK_log,
                                 const_cast<struct timespec *>(timeout));
   DBUG_RETURN(ret);
 }
@@ -5887,10 +5887,10 @@ void MYSQL_BIN_LOG::set_max_size(ulong m
     it's like if the SET command was never run.
   */
   DBUG_ENTER("MYSQL_BIN_LOG::set_max_size");
-  pthread_mutex_lock(&LOCK_log);
+  MYSQL_MUTEX_LOCK(&LOCK_log);
   if (is_open())
     max_size= max_size_arg;
-  pthread_mutex_unlock(&LOCK_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_log);
   DBUG_VOID_RETURN;
 }
 
@@ -5962,7 +5962,7 @@ bool flush_error_log()
     char err_renamed[FN_REFLEN], *end;
     end= strmake(err_renamed,log_error_file,FN_REFLEN-4);
     strmov(end, "-old");
-    pthread_mutex_lock(&LOCK_error_log);
+    MYSQL_MUTEX_LOCK(&LOCK_error_log);
 #ifdef __WIN__
     char err_temp[FN_REFLEN+4];
     /*
@@ -6001,7 +6001,7 @@ bool flush_error_log()
    else
      result= 1;
 #endif
-    pthread_mutex_unlock(&LOCK_error_log);
+    MYSQL_MUTEX_UNLOCK(&LOCK_error_log);
   }
    return result;
 }
@@ -6009,7 +6009,7 @@ bool flush_error_log()
 void MYSQL_BIN_LOG::signal_update()
 {
   DBUG_ENTER("MYSQL_BIN_LOG::signal_update");
-  pthread_cond_broadcast(&update_cond);
+  MYSQL_COND_BROADCAST(&update_cond);
   DBUG_VOID_RETURN;
 }
 
@@ -6075,7 +6075,7 @@ static void print_buffer_to_file(enum lo
   DBUG_ENTER("print_buffer_to_file");
   DBUG_PRINT("enter",("buffer: %s", buffer));
 
-  pthread_mutex_lock(&LOCK_error_log);
+  MYSQL_MUTEX_LOCK(&LOCK_error_log);
 
   skr= my_time(0);
   localtime_r(&skr, &tm_tmp);
@@ -6094,7 +6094,7 @@ static void print_buffer_to_file(enum lo
 
   fflush(stderr);
 
-  pthread_mutex_unlock(&LOCK_error_log);
+  MYSQL_MUTEX_UNLOCK(&LOCK_error_log);
   DBUG_VOID_RETURN;
 }
 
@@ -6268,8 +6268,8 @@ int TC_LOG_MMAP::open(const char *opt_na
     pg->next=pg+1;
     pg->waiters=0;
     pg->state=POOL;
-    pthread_mutex_init(&pg->lock, MY_MUTEX_INIT_FAST);
-    pthread_cond_init (&pg->cond, 0);
+    MYSQL_MUTEX_INIT(&pg->lock, key_PAGE_lock, MY_MUTEX_INIT_FAST);
+    MYSQL_COND_INIT (&pg->cond, key_PAGE_cond, 0);
     pg->start=(my_xid *)(data + i*tc_log_page_size);
     pg->ptr=pg->start;
     pg->end=(my_xid *)(pg->start + tc_log_page_size);
@@ -6289,11 +6289,11 @@ int TC_LOG_MMAP::open(const char *opt_na
   my_msync(fd, data, tc_log_page_size, MS_SYNC);
   inited=5;
 
-  pthread_mutex_init(&LOCK_sync,    MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&LOCK_active,  MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&LOCK_pool,    MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_active, 0);
-  pthread_cond_init(&COND_pool, 0);
+  MYSQL_MUTEX_INIT(&LOCK_sync, key_LOCK_sync, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_active, key_LOCK_active, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_pool, key_LOCK_pool, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_active, key_COND_active, 0);
+  MYSQL_COND_INIT(&COND_pool, key_COND_pool, 0);
 
   inited=6;
 
@@ -6327,7 +6327,7 @@ void TC_LOG_MMAP::get_active_from_pool()
   int best_free;
 
   if (syncing)
-    pthread_mutex_lock(&LOCK_pool);
+    MYSQL_MUTEX_LOCK(&LOCK_pool);
 
   do
   {
@@ -6360,7 +6360,7 @@ void TC_LOG_MMAP::get_active_from_pool()
     pool_last=*best_p;
 
   if (syncing)
-    pthread_mutex_unlock(&LOCK_pool);
+    MYSQL_MUTEX_UNLOCK(&LOCK_pool);
 }
 
 /**
@@ -6375,7 +6375,7 @@ int TC_LOG_MMAP::overflow()
     let's check the behaviour of tc_log_page_waits first
   */
   tc_log_page_waits++;
-  pthread_cond_wait(&COND_pool, &LOCK_pool);
+  MYSQL_COND_WAIT(&COND_pool, &LOCK_pool);
   return 1; // always return 1
 }
 
@@ -6412,7 +6412,7 @@ int TC_LOG_MMAP::log_xid(THD *thd, my_xi
   PAGE *p;
   ulong cookie;
 
-  pthread_mutex_lock(&LOCK_active);
+  MYSQL_MUTEX_LOCK(&LOCK_active);
 
   /*
     if active page is full - just wait...
@@ -6422,14 +6422,14 @@ int TC_LOG_MMAP::log_xid(THD *thd, my_xi
     unlog() does not signal COND_active.
   */
   while (unlikely(active && active->free == 0))
-    pthread_cond_wait(&COND_active, &LOCK_active);
+    MYSQL_COND_WAIT(&COND_active, &LOCK_active);
 
   /* no active page ? take one from the pool */
   if (active == 0)
     get_active_from_pool();
 
   p=active;
-  pthread_mutex_lock(&p->lock);
+  MYSQL_MUTEX_LOCK(&p->lock);
 
   /* searching for an empty slot */
   while (*p->ptr)
@@ -6445,9 +6445,9 @@ int TC_LOG_MMAP::log_xid(THD *thd, my_xi
   p->state= DIRTY;
 
   /* to sync or not to sync - this is the question */
-  pthread_mutex_unlock(&LOCK_active);
-  pthread_mutex_lock(&LOCK_sync);
-  pthread_mutex_unlock(&p->lock);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active);
+  MYSQL_MUTEX_LOCK(&LOCK_sync);
+  MYSQL_MUTEX_UNLOCK(&p->lock);
 
   if (syncing)
   {                                          // somebody's syncing. let's wait
@@ -6457,24 +6457,24 @@ int TC_LOG_MMAP::log_xid(THD *thd, my_xi
       as p->state may be not DIRTY when we come here
     */
     while (p->state == DIRTY && syncing)
-      pthread_cond_wait(&p->cond, &LOCK_sync);
+      MYSQL_COND_WAIT(&p->cond, &LOCK_sync);
     p->waiters--;
     err= p->state == ERROR;
     if (p->state != DIRTY)                   // page was synced
     {
       if (p->waiters == 0)
-        pthread_cond_signal(&COND_pool);     // in case somebody's waiting
-      pthread_mutex_unlock(&LOCK_sync);
+        MYSQL_COND_SIGNAL(&COND_pool);     // in case somebody's waiting
+      MYSQL_MUTEX_UNLOCK(&LOCK_sync);
       goto done;                             // we're done
     }
   }                                          // page was not synced! do it now
   DBUG_ASSERT(active == p && syncing == 0);
-  pthread_mutex_lock(&LOCK_active);
+  MYSQL_MUTEX_LOCK(&LOCK_active);
   syncing=p;                                 // place is vacant - take it
   active=0;                                  // page is not active anymore
-  pthread_cond_broadcast(&COND_active);      // in case somebody's waiting
-  pthread_mutex_unlock(&LOCK_active);
-  pthread_mutex_unlock(&LOCK_sync);
+  MYSQL_COND_BROADCAST(&COND_active);      // in case somebody's waiting
+  MYSQL_MUTEX_UNLOCK(&LOCK_active);
+  MYSQL_MUTEX_UNLOCK(&LOCK_sync);
   err= sync();
 
 done:
@@ -6494,20 +6494,20 @@ int TC_LOG_MMAP::sync()
   err= my_msync(fd, syncing->start, 1, MS_SYNC);
 
   /* page is synced. let's move it to the pool */
-  pthread_mutex_lock(&LOCK_pool);
+  MYSQL_MUTEX_LOCK(&LOCK_pool);
   pool_last->next=syncing;
   pool_last=syncing;
   syncing->next=0;
   syncing->state= err ? ERROR : POOL;
-  pthread_cond_broadcast(&syncing->cond);    // signal "sync done"
-  pthread_cond_signal(&COND_pool);           // in case somebody's waiting
-  pthread_mutex_unlock(&LOCK_pool);
+  MYSQL_COND_BROADCAST(&syncing->cond);    // signal "sync done"
+  MYSQL_COND_SIGNAL(&COND_pool);           // in case somebody's waiting
+  MYSQL_MUTEX_UNLOCK(&LOCK_pool);
 
   /* marking 'syncing' slot free */
-  pthread_mutex_lock(&LOCK_sync);
+  MYSQL_MUTEX_LOCK(&LOCK_sync);
   syncing=0;
-  pthread_cond_signal(&active->cond);        // wake up a new syncer
-  pthread_mutex_unlock(&LOCK_sync);
+  MYSQL_COND_SIGNAL(&active->cond);        // wake up a new syncer
+  MYSQL_MUTEX_UNLOCK(&LOCK_sync);
   return err;
 }
 
@@ -6525,15 +6525,15 @@ void TC_LOG_MMAP::unlog(ulong cookie, my
   DBUG_ASSERT(x >= p->start && x < p->end);
   *x=0;
 
-  pthread_mutex_lock(&p->lock);
+  MYSQL_MUTEX_LOCK(&p->lock);
   p->free++;
   DBUG_ASSERT(p->free <= p->size);
   set_if_smaller(p->ptr, x);
   if (p->free == p->size)               // the page is completely empty
     statistic_decrement(tc_log_cur_pages_used, &LOCK_status);
   if (p->waiters == 0)                 // the page is in pool and ready to rock
-    pthread_cond_signal(&COND_pool);   // ping ... for overflow()
-  pthread_mutex_unlock(&p->lock);
+    MYSQL_COND_SIGNAL(&COND_pool);   // ping ... for overflow()
+  MYSQL_MUTEX_UNLOCK(&p->lock);
 }
 
 void TC_LOG_MMAP::close()
@@ -6541,10 +6541,10 @@ void TC_LOG_MMAP::close()
   uint i;
   switch (inited) {
   case 6:
-    pthread_mutex_destroy(&LOCK_sync);
-    pthread_mutex_destroy(&LOCK_active);
-    pthread_mutex_destroy(&LOCK_pool);
-    pthread_cond_destroy(&COND_pool);
+    MYSQL_MUTEX_DESTROY(&LOCK_sync);
+    MYSQL_MUTEX_DESTROY(&LOCK_active);
+    MYSQL_MUTEX_DESTROY(&LOCK_pool);
+    MYSQL_COND_DESTROY(&COND_pool);
   case 5:
     data[0]='A'; // garble the first (signature) byte, in case my_delete fails
   case 4:
@@ -6552,8 +6552,8 @@ void TC_LOG_MMAP::close()
     {
       if (pages[i].ptr == 0)
         break;
-      pthread_mutex_destroy(&pages[i].lock);
-      pthread_cond_destroy(&pages[i].cond);
+      MYSQL_MUTEX_DESTROY(&pages[i].lock);
+      MYSQL_COND_DESTROY(&pages[i].cond);
     }
   case 3:
     my_free((uchar*)pages, MYF(0));
@@ -6668,8 +6668,8 @@ int TC_LOG_BINLOG::open(const char *opt_
   DBUG_ASSERT(total_ha_2pc > 1);
   DBUG_ASSERT(opt_name && opt_name[0]);
 
-  pthread_mutex_init(&LOCK_prep_xids, MY_MUTEX_INIT_FAST);
-  pthread_cond_init (&COND_prep_xids, 0);
+  MYSQL_MUTEX_INIT(&LOCK_prep_xids, key_BINLOG_LOCK_prep_xids, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_prep_xids, key_BINLOG_COND_prep_xids, 0);
 
   if (!my_b_inited(&index_file))
   {
@@ -6749,8 +6749,8 @@ err:
 void TC_LOG_BINLOG::close()
 {
   DBUG_ASSERT(prepared_xids==0);
-  pthread_mutex_destroy(&LOCK_prep_xids);
-  pthread_cond_destroy (&COND_prep_xids);
+  MYSQL_MUTEX_DESTROY(&LOCK_prep_xids);
+  MYSQL_COND_DESTROY (&COND_prep_xids);
 }
 
 /**
@@ -6777,13 +6777,13 @@ int TC_LOG_BINLOG::log_xid(THD *thd, my_
 
 void TC_LOG_BINLOG::unlog(ulong cookie, my_xid xid)
 {
-  pthread_mutex_lock(&LOCK_prep_xids);
+  MYSQL_MUTEX_LOCK(&LOCK_prep_xids);
   DBUG_ASSERT(prepared_xids > 0);
   if (--prepared_xids == 0) {
     DBUG_PRINT("info", ("prepared_xids=%lu", prepared_xids));
-    pthread_cond_signal(&COND_prep_xids);
+    MYSQL_COND_SIGNAL(&COND_prep_xids);
   }
-  pthread_mutex_unlock(&LOCK_prep_xids);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prep_xids);
   rotate_and_purge(0);     // as ::write() did not rotate
 }
 

=== modified file 'sql/log.h'
--- a/sql/log.h	2008-08-27 17:30:49 +0000
+++ b/sql/log.h	2008-10-10 20:34:55 +0000
@@ -92,6 +92,17 @@ public:
 };
 
 #ifdef HAVE_MMAP
+
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_PAGE_lock;
+extern PSI_cond_key key_PAGE_cond;
+extern PSI_mutex_key key_LOCK_sync;
+extern PSI_mutex_key key_LOCK_active;
+extern PSI_mutex_key key_LOCK_pool;
+extern PSI_cond_key key_COND_active;
+extern PSI_cond_key key_COND_pool;
+#endif
+
 class TC_LOG_MMAP: public TC_LOG
 {
   public:                // only to keep Sun Forte on sol9x86 happy
@@ -109,8 +120,8 @@ class TC_LOG_MMAP: public TC_LOG
     int size, free;       // max and current number of free xid slots on the page
     int waiters;          // number of waiters on condition
     PAGE_STATE state;     // see above
-    pthread_mutex_t lock; // to access page data or control structure
-    pthread_cond_t  cond; // to wait for a sync
+    mysql_mutex_t lock; // to access page data or control structure
+    mysql_cond_t  cond; // to wait for a sync
   } PAGE;
 
   char logname[FN_REFLEN];
@@ -125,8 +136,8 @@ class TC_LOG_MMAP: public TC_LOG
     one has to use active->lock.
     Same for LOCK_pool and LOCK_sync
   */
-  pthread_mutex_t LOCK_active, LOCK_pool, LOCK_sync;
-  pthread_cond_t COND_pool, COND_active;
+  mysql_mutex_t LOCK_active, LOCK_pool, LOCK_sync;
+  mysql_cond_t COND_pool, COND_active;
 
   public:
   TC_LOG_MMAP(): inited(0) {}
@@ -165,6 +176,10 @@ extern TC_LOG_DUMMY tc_log_dummy;
 #define LOG_CLOSE_TO_BE_OPENED	2
 #define LOG_CLOSE_STOP_EVENT	4
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOG_INFO_lock;
+#endif
+
 class Relay_log_info;
 
 typedef struct st_log_info
@@ -173,15 +188,15 @@ typedef struct st_log_info
   my_off_t index_file_offset, index_file_start_offset;
   my_off_t pos;
   bool fatal; // if the purge happens to give us a negative offset
-  pthread_mutex_t lock;
+  mysql_mutex_t lock;
   st_log_info()
     : index_file_offset(0), index_file_start_offset(0),
       pos(0), fatal(0)
     {
       log_file_name[0] = '\0';
-      pthread_mutex_init(&lock, MY_MUTEX_INIT_FAST);
+      MYSQL_MUTEX_INIT(&lock, key_LOG_INFO_lock, MY_MUTEX_INIT_FAST);
     }
-  ~st_log_info() { pthread_mutex_destroy(&lock);}
+  ~st_log_info() { MYSQL_MUTEX_DESTROY(&lock);}
 } LOG_INFO;
 
 /*
@@ -206,6 +221,10 @@ enum enum_log_state { LOG_OPENED, LOG_CL
   (mmap+fsync is two times faster than write+fsync)
 */
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOG_LOCK_log;
+#endif
+
 class MYSQL_LOG
 {
 public:
@@ -225,7 +244,7 @@ public:
   int generate_new_name(char *new_name, const char *log_name);
  protected:
   /* LOCK_log is inited by init_pthread_objects() */
-  pthread_mutex_t LOCK_log;
+  mysql_mutex_t LOCK_log;
   char *name;
   char log_file_name[FN_REFLEN];
   char time_buff[20], db[NAME_LEN + 1];
@@ -267,18 +286,22 @@ private:
   time_t last_time;
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_backupid;
+#endif
+
 class MYSQL_BACKUP_LOG: public MYSQL_LOG
 {
 public:
   MYSQL_BACKUP_LOG () 
   { 
     headers_written= FALSE; 
-    pthread_mutex_init(&LOCK_backupid, MY_MUTEX_INIT_FAST);
+    MYSQL_MUTEX_INIT(&LOCK_backupid, key_LOCK_backupid, MY_MUTEX_INIT_FAST);
     m_next_id= 0;
   }
   ~MYSQL_BACKUP_LOG()
   {
-    pthread_mutex_destroy(&LOCK_backupid);
+    MYSQL_MUTEX_DESTROY(&LOCK_backupid);
   }
   void reopen_file(bool history);
   bool write(THD *thd, st_backup_history *history_data);
@@ -314,17 +337,24 @@ private:
   bool write_str(const char *str);
   bool headers_written;
   ulonglong m_next_id;       ///< the next available backup_id
-  pthread_mutex_t LOCK_backupid; ///< mutex for backupid generation
+  mysql_mutex_t LOCK_backupid; ///< mutex for backupid generation
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_BINLOG_LOCK_index;
+extern PSI_mutex_key key_BINLOG_LOCK_prep_xids;
+extern PSI_cond_key key_BINLOG_COND_prep_xids;
+extern PSI_cond_key key_BINLOG_update_cond;
+#endif
+
 class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG
 {
  private:
   /* LOCK_log and LOCK_index are inited by init_pthread_objects() */
-  pthread_mutex_t LOCK_index;
-  pthread_mutex_t LOCK_prep_xids;
-  pthread_cond_t  COND_prep_xids;
-  pthread_cond_t update_cond;
+  mysql_mutex_t LOCK_index;
+  mysql_mutex_t LOCK_prep_xids;
+  mysql_cond_t  COND_prep_xids;
+  mysql_cond_t update_cond;
   ulonglong bytes_written;
   IO_CACHE index_file;
   char index_file_name[FN_REFLEN];
@@ -477,11 +507,11 @@ public:
   inline char* get_index_fname() { return index_file_name;}
   inline char* get_log_fname() { return log_file_name; }
   inline char* get_name() { return name; }
-  inline pthread_mutex_t* get_log_lock() { return &LOCK_log; }
+  inline mysql_mutex_t* get_log_lock() { return &LOCK_log; }
   inline IO_CACHE* get_log_file() { return &log_file; }
 
-  inline void lock_index() { pthread_mutex_lock(&LOCK_index);}
-  inline void unlock_index() { pthread_mutex_unlock(&LOCK_index);}
+  inline void lock_index() { MYSQL_MUTEX_LOCK(&LOCK_index);}
+  inline void unlock_index() { MYSQL_MUTEX_UNLOCK(&LOCK_index);}
   inline IO_CACHE *get_index_file() { return &index_file;}
   inline uint32 get_open_count() { return open_count; }
 };
@@ -623,6 +653,9 @@ public:
   { return &mysql_backup_progress_log; }
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_logger;
+#endif
 
 /*
    Class which manages slow, general, error log, backup history, and
@@ -630,7 +663,7 @@ public:
 */
 class LOGGER
 {
-  rw_lock_t LOCK_logger;
+  mysql_rwlock_t LOCK_logger;
   /* flag to check whether logger mutex is initialized */
   uint inited;
 
@@ -652,9 +685,9 @@ public:
   LOGGER() : inited(0), table_log_handler(NULL),
              file_log_handler(NULL), is_log_tables_initialized(FALSE)
   {}
-  void lock_shared() { rw_rdlock(&LOCK_logger); }
-  void lock_exclusive() { rw_wrlock(&LOCK_logger); }
-  void unlock() { rw_unlock(&LOCK_logger); }
+  void lock_shared() { MYSQL_RWLOCK_RDLOCK(&LOCK_logger); }
+  void lock_exclusive() { MYSQL_RWLOCK_WRLOCK(&LOCK_logger); }
+  void unlock() { MYSQL_RWLOCK_UNLOCK(&LOCK_logger); }
   bool is_log_table_enabled(uint log_table_type);
   bool log_command(THD *thd, enum enum_server_command command);
 

=== modified file 'sql/log_event.cc'
--- a/sql/log_event.cc	2008-09-04 18:30:34 +0000
+++ b/sql/log_event.cc	2008-10-10 20:34:55 +0000
@@ -874,7 +874,7 @@ bool Log_event::write_header(IO_CACHE* f
 */
 
 int Log_event::read_log_event(IO_CACHE* file, String* packet,
-			      pthread_mutex_t* log_lock)
+			      mysql_mutex_t* log_lock)
 {
   ulong data_len;
   int result=0;
@@ -882,7 +882,7 @@ int Log_event::read_log_event(IO_CACHE* 
   DBUG_ENTER("Log_event::read_log_event");
 
   if (log_lock)
-    pthread_mutex_lock(log_lock);
+    MYSQL_MUTEX_LOCK(log_lock);
   if (my_b_read(file, (uchar*) buf, sizeof(buf)))
   {
     /*
@@ -940,14 +940,14 @@ int Log_event::read_log_event(IO_CACHE* 
 
 end:
   if (log_lock)
-    pthread_mutex_unlock(log_lock);
+    MYSQL_MUTEX_UNLOCK(log_lock);
   DBUG_RETURN(result);
 }
 #endif /* !MYSQL_CLIENT */
 
 #ifndef MYSQL_CLIENT
-#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
-#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
+#define UNLOCK_MUTEX if (log_lock) MYSQL_MUTEX_UNLOCK(log_lock);
+#define LOCK_MUTEX if (log_lock) MYSQL_MUTEX_LOCK(log_lock);
 #else
 #define UNLOCK_MUTEX
 #define LOCK_MUTEX
@@ -959,7 +959,7 @@ end:
     Allocates memory;  The caller is responsible for clean-up.
 */
 Log_event* Log_event::read_log_event(IO_CACHE* file,
-				     pthread_mutex_t* log_lock,
+				     mysql_mutex_t* log_lock,
                                      const Format_description_log_event
                                      *description_event)
 #else
@@ -2914,9 +2914,9 @@ int Query_log_event::do_apply_event(Rela
     thd->set_time((time_t)when);
     thd->query_length= q_len_arg;
     thd->query= (char*)query_arg;
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thd->query_id = next_query_id();
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     thd->variables.pseudo_thread_id= thread_id;		// for temp tables
     DBUG_PRINT("query",("%s",thd->query));
 
@@ -3117,7 +3117,7 @@ Default database: '%s'. Query: '%s'",
   } /* End of if (db_ok(... */
 
 end:
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   /*
     Probably we have set thd->query, thd->db, thd->catalog to point to places
     in the data_buf of this event. Now the event is going to be deleted
@@ -3133,7 +3133,7 @@ end:
   DBUG_PRINT("info", ("end: query= 0"));
   thd->query= 0;			// just to be sure
   thd->query_length= 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   close_thread_tables(thd);      
   /*
     As a disk space optimization, future masters will not log an event for
@@ -4355,9 +4355,9 @@ int Load_log_event::do_apply_event(NET* 
   if (rpl_filter->db_ok(thd->db))
   {
     thd->set_time((time_t)when);
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thd->query_id = next_query_id();
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     /*
       Initing thd->row_count is not necessary in theory as this variable has no
       influence in the case of the slave SQL thread (it is used to generate a
@@ -4511,12 +4511,12 @@ int Load_log_event::do_apply_event(NET* 
 error:
   thd->net.vio = 0; 
   const char *remember_db= thd->db;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->catalog= 0;
   thd->set_db(NULL, 0);                   /* will free the current database */
   thd->query= 0;
   thd->query_length= 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   close_thread_tables(thd);
 
   DBUG_EXECUTE_IF("LOAD_DATA_INFILE_has_fatal_error",
@@ -4701,7 +4701,7 @@ int Rotate_log_event::do_update_pos(Rela
   DBUG_PRINT("info", ("new_log_ident: %s", this->new_log_ident));
   DBUG_PRINT("info", ("pos: %s", llstr(this->pos, buf)));
 
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
   rli->event_relay_log_pos= my_b_tell(rli->cur_log);
   /*
     If we are in a transaction or in a group: the only normal case is
@@ -4750,8 +4750,8 @@ int Rotate_log_event::do_update_pos(Rela
     thd->variables.auto_increment_increment=
       thd->variables.auto_increment_offset= 1;
   }
-  pthread_mutex_unlock(&rli->data_lock);
-  pthread_cond_broadcast(&rli->data_cond);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
+  MYSQL_COND_BROADCAST(&rli->data_cond);
   flush_relay_log_info(rli);
 
   DBUG_RETURN(0);
@@ -5550,8 +5550,8 @@ Slave_log_event::Slave_log_event(THD* th
 
   Master_info* mi = rli->mi;
   // TODO: re-write this better without holding both locks at the same time
-  pthread_mutex_lock(&mi->data_lock);
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&mi->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
   master_host_len = strlen(mi->host);
   master_log_len = strlen(rli->group_master_log_name);
   // on OOM, just do not initialize the structure and print the error
@@ -5569,8 +5569,8 @@ Slave_log_event::Slave_log_event(THD* th
   }
   else
     sql_print_error("Out of memory while recording slave event");
-  pthread_mutex_unlock(&rli->data_lock);
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_VOID_RETURN;
 }
 #endif /* !MYSQL_CLIENT */
@@ -6335,7 +6335,7 @@ int Execute_load_log_event::do_apply_eve
     goto err;
   }
   if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
-                                                         (pthread_mutex_t*)0,
+                                                         (mysql_mutex_t*)0,
                                                          rli->relay_log.description_event_for_exec)) ||
       lev->get_type_code() != NEW_LOAD_EVENT)
   {
@@ -7858,9 +7858,9 @@ int Table_map_log_event::do_apply_event(
   DBUG_ASSERT(rli->sql_thd == thd);
 
   /* Step the query id to mark what columns that are actually used. */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query_id= next_query_id();
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if (!(memory= my_multi_malloc(MYF(MY_WME),
                                 &table_list, (uint) sizeof(RPL_TABLE_LIST),

=== modified file 'sql/log_event.h'
--- a/sql/log_event.h	2008-09-09 08:19:21 +0000
+++ b/sql/log_event.h	2008-10-10 20:34:55 +0000
@@ -920,11 +920,11 @@ public:
     constructor and pass description_event as an argument.
   */
   static Log_event* read_log_event(IO_CACHE* file,
-				   pthread_mutex_t* log_lock,
+				   mysql_mutex_t* log_lock,
                                    const Format_description_log_event
                                    *description_event);
   static int read_log_event(IO_CACHE* file, String* packet,
-			    pthread_mutex_t* log_lock);
+			    mysql_mutex_t* log_lock);
   /*
     init_show_field_list() prepares the column names and types for the
     output of SHOW BINLOG EVENTS; it is used only by SHOW BINLOG

=== modified file 'sql/mdl.cc'
--- a/sql/mdl.cc	2008-08-13 10:36:29 +0000
+++ b/sql/mdl.cc	2008-10-10 20:34:55 +0000
@@ -66,9 +66,13 @@ struct MDL_LOCK
   }
 };
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_mdl;
+PSI_cond_key key_COND_mdl;
+#endif
 
-pthread_mutex_t LOCK_mdl;
-pthread_cond_t  COND_mdl;
+mysql_mutex_t LOCK_mdl;
+mysql_cond_t  COND_mdl;
 HASH mdl_locks;
 
 /**
@@ -117,8 +121,8 @@ extern "C" uchar *mdl_locks_key(const uc
 void mdl_init()
 {
   mdl_initialized= 1;
-  pthread_mutex_init(&LOCK_mdl, NULL);
-  pthread_cond_init(&COND_mdl, NULL);
+  MYSQL_MUTEX_INIT(&LOCK_mdl, key_LOCK_mdl, NULL);
+  MYSQL_COND_INIT(&COND_mdl, key_COND_mdl, NULL);
   hash_init(&mdl_locks, &my_charset_bin, 16 /* FIXME */, 0, 0,
             mdl_locks_key, 0, 0);
   global_lock.waiting_shared= global_lock.active_shared= 0;
@@ -139,8 +143,8 @@ void mdl_destroy()
   {
     mdl_initialized= 0;
     DBUG_ASSERT(!mdl_locks.records);
-    pthread_mutex_destroy(&LOCK_mdl);
-    pthread_cond_destroy(&COND_mdl);
+    MYSQL_MUTEX_DESTROY(&LOCK_mdl);
+    MYSQL_COND_DESTROY(&COND_mdl);
     hash_free(&mdl_locks);
   }
 }
@@ -465,7 +469,7 @@ static inline const char* mdl_enter_cond
                                          const char *calling_file,
                                          const unsigned int calling_line)
 {
-  safe_mutex_assert_owner(&LOCK_mdl);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_mdl);
 
   mysys_var->current_mutex= &LOCK_mdl;
   mysys_var->current_cond= &COND_mdl;
@@ -485,11 +489,11 @@ static inline void mdl_exit_cond(MDL_CON
 {
   DBUG_ASSERT(&LOCK_mdl == mysys_var->current_mutex);
 
-  pthread_mutex_unlock(&LOCK_mdl);
-  pthread_mutex_lock(&mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&mysys_var->mutex);
   mysys_var->current_mutex= 0;
   mysys_var->current_cond= 0;
-  pthread_mutex_unlock(&mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&mysys_var->mutex);
 
   (void) set_thd_proc_info(context->thd, old_msg, calling_func,
                            calling_file, calling_line);
@@ -718,7 +722,7 @@ bool mdl_acquire_shared_lock(MDL_CONTEXT
 
   DBUG_ASSERT(lock_data->ctx == context);
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   if (context->has_global_shared_lock &&
       lock_data->type == MDL_SHARED_UPGRADABLE)
@@ -727,11 +731,11 @@ bool mdl_acquire_shared_lock(MDL_CONTEXT
     return TRUE;
   }
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
 
   if (!can_grant_global_lock(lock_data))
   {
-    pthread_mutex_unlock(&LOCK_mdl);
+    MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
     *retry= TRUE;
     return TRUE;
   }
@@ -741,7 +745,7 @@ bool mdl_acquire_shared_lock(MDL_CONTEXT
   {
     if (!(lock= get_lock_object()))
     {
-      pthread_mutex_unlock(&LOCK_mdl);
+      MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
       return TRUE;
     }
     /*
@@ -754,7 +758,7 @@ bool mdl_acquire_shared_lock(MDL_CONTEXT
     if (my_hash_insert(&mdl_locks, (uchar*)lock))
     {
       release_lock_object(lock);
-      pthread_mutex_unlock(&LOCK_mdl);
+      MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
       return TRUE;
     }
     lock_data->state= MDL_ACQUIRED;
@@ -776,7 +780,7 @@ bool mdl_acquire_shared_lock(MDL_CONTEXT
     else
       *retry= TRUE;
   }
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
 
   return *retry;
 }
@@ -809,7 +813,7 @@ bool mdl_acquire_exclusive_locks(MDL_CON
   I_P_List_iterator<MDL_LOCK_DATA, MDL_LOCK_DATA_context> it(context->locks);
   st_my_thread_var *mysys_var= my_thread_var;
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   if (context->has_global_shared_lock)
   {
@@ -817,7 +821,7 @@ bool mdl_acquire_exclusive_locks(MDL_CON
     return TRUE;
   }
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
 
   old_msg= MDL_ENTER_COND(context, mysys_var);
 
@@ -891,7 +895,7 @@ bool mdl_acquire_exclusive_locks(MDL_CON
     if (!lock_data)
       break;
     if (signalled)
-      pthread_cond_wait(&COND_mdl, &LOCK_mdl);
+      MYSQL_COND_WAIT(&COND_mdl, &LOCK_mdl);
     else
     {
       /*
@@ -902,7 +906,7 @@ bool mdl_acquire_exclusive_locks(MDL_CON
       */
       struct timespec abstime;
       set_timespec(abstime, 10);
-      pthread_cond_timedwait(&COND_mdl, &LOCK_mdl, &abstime);
+      MYSQL_COND_TIMEDWAIT(&COND_mdl, &LOCK_mdl, &abstime);
     }
     if (mysys_var->abort)
       goto err;
@@ -935,7 +939,7 @@ err:
     lock_data->state= MDL_INITIALIZED;
   }
   /* May be some pending requests for shared locks can be satisfied now. */
-  pthread_cond_broadcast(&COND_mdl);
+  MYSQL_COND_BROADCAST(&COND_mdl);
   MDL_EXIT_COND(context, mysys_var, old_msg);
   return TRUE;
 }
@@ -967,7 +971,7 @@ bool mdl_upgrade_shared_lock_to_exclusiv
 
   DBUG_ENTER("mdl_upgrade_shared_lock_to_exclusive");
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   DBUG_ASSERT(lock_data->state == MDL_ACQUIRED);
 
@@ -979,7 +983,7 @@ bool mdl_upgrade_shared_lock_to_exclusiv
 
   lock= lock_data->lock;
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
 
   old_msg= MDL_ENTER_COND(context, mysys_var);
 
@@ -1022,7 +1026,7 @@ bool mdl_upgrade_shared_lock_to_exclusiv
     }
 
     if (signalled)
-      pthread_cond_wait(&COND_mdl, &LOCK_mdl);
+      MYSQL_COND_WAIT(&COND_mdl, &LOCK_mdl);
     else
     {
       /*
@@ -1034,7 +1038,7 @@ bool mdl_upgrade_shared_lock_to_exclusiv
       struct timespec abstime;
       set_timespec(abstime, 10);
       DBUG_PRINT("info", ("Failed to wake-up from table-level lock ... sleeping"));
-      pthread_cond_timedwait(&COND_mdl, &LOCK_mdl, &abstime);
+      MYSQL_COND_TIMEDWAIT(&COND_mdl, &LOCK_mdl, &abstime);
     }
     if (mysys_var->abort)
     {
@@ -1043,7 +1047,7 @@ bool mdl_upgrade_shared_lock_to_exclusiv
       lock->active_shared_waiting_upgrade.remove(lock_data);
       lock->active_shared.push_front(lock_data);
       /* Pending requests for shared locks can be satisfied now. */
-      pthread_cond_broadcast(&COND_mdl);
+      MYSQL_COND_BROADCAST(&COND_mdl);
       MDL_EXIT_COND(context, mysys_var, old_msg);
       DBUG_RETURN(TRUE);
     }
@@ -1095,11 +1099,11 @@ bool mdl_try_acquire_exclusive_lock(MDL_
   DBUG_ASSERT(lock_data->type == MDL_EXCLUSIVE &&
               lock_data->state == MDL_INITIALIZED);
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   *conflict= FALSE;
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
 
   if (!(lock= (MDL_LOCK *)hash_search(&mdl_locks, (uchar*)lock_data->key,
                                       lock_data->key_length)))
@@ -1116,7 +1120,7 @@ bool mdl_try_acquire_exclusive_lock(MDL_
     lock_data->state= MDL_ACQUIRED;
     lock_data->lock= lock;
     global_lock.active_intention_exclusive++;
-    pthread_mutex_unlock(&LOCK_mdl);
+    MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
     return FALSE;
   }
 
@@ -1124,7 +1128,7 @@ bool mdl_try_acquire_exclusive_lock(MDL_
   *conflict= TRUE;
 
 err:
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
   return TRUE;
 }
 
@@ -1146,16 +1150,16 @@ bool mdl_acquire_global_shared_lock(MDL_
   st_my_thread_var *mysys_var= my_thread_var;
   const char *old_msg;
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
   DBUG_ASSERT(!context->has_global_shared_lock);
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
 
   global_lock.waiting_shared++;
   old_msg= MDL_ENTER_COND(context, mysys_var);
 
   while (!mysys_var->abort && global_lock.active_intention_exclusive)
-    pthread_cond_wait(&COND_mdl, &LOCK_mdl);
+    MYSQL_COND_WAIT(&COND_mdl, &LOCK_mdl);
 
   global_lock.waiting_shared--;
   if (mysys_var->abort)
@@ -1195,7 +1199,7 @@ bool mdl_wait_for_locks(MDL_CONTEXT *con
   const char *old_msg;
   st_my_thread_var *mysys_var= my_thread_var;
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   while (!mysys_var->abort)
   {
@@ -1210,7 +1214,7 @@ bool mdl_wait_for_locks(MDL_CONTEXT *con
             COND_mdl because of above scenario.
     */
     mysql_ha_flush(context->thd);
-    pthread_mutex_lock(&LOCK_mdl);
+    MYSQL_MUTEX_LOCK(&LOCK_mdl);
     old_msg= MDL_ENTER_COND(context, mysys_var);
     it.rewind();
     while ((lock_data= it++))
@@ -1230,10 +1234,10 @@ bool mdl_wait_for_locks(MDL_CONTEXT *con
     }
     if (!lock_data)
     {
-      pthread_mutex_unlock(&LOCK_mdl);
+      MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
       break;
     }
-    pthread_cond_wait(&COND_mdl, &LOCK_mdl);
+    MYSQL_COND_WAIT(&COND_mdl, &LOCK_mdl);
     /* As a side-effect MDL_EXIT_COND() unlocks LOCK_mdl. */
     MDL_EXIT_COND(context, mysys_var, old_msg);
   }
@@ -1319,9 +1323,9 @@ void mdl_release_locks(MDL_CONTEXT *cont
   I_P_List_iterator<MDL_LOCK_DATA, MDL_LOCK_DATA_context> it(context->locks);
   DBUG_ENTER("mdl_release_locks");
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
   while ((lock_data= it++))
   {
     DBUG_PRINT("info", ("found lock to release lock_data=%p", lock_data));
@@ -1346,8 +1350,8 @@ void mdl_release_locks(MDL_CONTEXT *cont
     */
   }
   /* Inefficient but will do for a while */
-  pthread_cond_broadcast(&COND_mdl);
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_COND_BROADCAST(&COND_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
   DBUG_VOID_RETURN;
 }
 
@@ -1362,16 +1366,16 @@ void mdl_release_locks(MDL_CONTEXT *cont
 
 void mdl_release_lock(MDL_CONTEXT *context, MDL_LOCK_DATA *lock_data)
 {
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
   release_lock(lock_data);
 #ifndef DBUG_OFF
   lock_data->lock= 0;
 #endif
   lock_data->state= MDL_INITIALIZED;
-  pthread_cond_broadcast(&COND_mdl);
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_COND_BROADCAST(&COND_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
 }
 
 
@@ -1424,7 +1428,7 @@ void mdl_downgrade_exclusive_lock(MDL_CO
 {
   MDL_LOCK *lock;
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   DBUG_ASSERT(lock_data->state == MDL_ACQUIRED);
 
@@ -1433,12 +1437,12 @@ void mdl_downgrade_exclusive_lock(MDL_CO
 
   lock= lock_data->lock;
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
   lock->active_exclusive.remove(lock_data);
   lock_data->type= MDL_SHARED_UPGRADABLE;
   lock->active_shared.push_front(lock_data);
-  pthread_cond_broadcast(&COND_mdl);
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_COND_BROADCAST(&COND_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
 }
 
 
@@ -1450,14 +1454,14 @@ void mdl_downgrade_exclusive_lock(MDL_CO
 
 void mdl_release_global_shared_lock(MDL_CONTEXT *context)
 {
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
   DBUG_ASSERT(context->has_global_shared_lock);
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
   global_lock.active_shared--;
   context->has_global_shared_lock= FALSE;
-  pthread_cond_broadcast(&COND_mdl);
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_COND_BROADCAST(&COND_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
 }
 
 
@@ -1543,12 +1547,12 @@ bool mdl_has_pending_conflicting_lock(MD
   bool result;
 
   DBUG_ASSERT(is_shared(lock_data) && lock_data->state == MDL_ACQUIRED);
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
-  pthread_mutex_lock(&LOCK_mdl);
+  MYSQL_MUTEX_LOCK(&LOCK_mdl);
   result= !(lock_data->lock->waiting_exclusive.is_empty() &&
             lock_data->lock->active_shared_waiting_upgrade.is_empty());
-  pthread_mutex_unlock(&LOCK_mdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mdl);
   return result;
 }
 

=== modified file 'sql/mdl.h'
--- a/sql/mdl.h	2008-06-20 13:11:20 +0000
+++ b/sql/mdl.h	2008-10-10 20:34:55 +0000
@@ -253,7 +253,7 @@ extern "C" const char *set_thd_proc_info
                                          const char *calling_file,
                                          const unsigned int calling_line);
 #ifndef DBUG_OFF
-extern pthread_mutex_t LOCK_open;
+extern mysql_mutex_t LOCK_open;
 #endif
 
 #endif

=== modified file 'sql/mysql_priv.h'
--- a/sql/mysql_priv.h	2008-09-19 09:55:21 +0000
+++ b/sql/mysql_priv.h	2008-10-10 20:34:55 +0000
@@ -1344,7 +1344,7 @@ bool open_new_frm(THD *thd, TABLE_SHARE 
                   uint ha_open_flags, TABLE *outparam,
                   TABLE_LIST *table_desc, MEM_ROOT *mem_root);
 void execute_init_command(THD *thd, sys_var_str *init_command_var,
-			  rw_lock_t *var_mutex);
+			  mysql_rwlock_t *var_mutex);
 extern Field *not_found_field;
 extern Field *view_ref_found;
 
@@ -1385,7 +1385,7 @@ struct st_des_keyschedule
 extern char *des_key_file;
 extern struct st_des_keyschedule des_keyschedule[10];
 extern uint des_default_key;
-extern pthread_mutex_t LOCK_des_key_file;
+extern mysql_mutex_t LOCK_des_key_file;
 bool load_des_key_file(const char *file_name);
 #endif /* HAVE_OPENSSL */
 
@@ -1593,8 +1593,8 @@ int setup_conds(THD *thd, TABLE_LIST *ta
 		COND **conds);
 int setup_ftfuncs(SELECT_LEX* select);
 int init_ftfuncs(THD *thd, SELECT_LEX* select, bool no_order);
-void wait_for_condition(THD *thd, pthread_mutex_t *mutex,
-                        pthread_cond_t *cond);
+void wait_for_condition(THD *thd, mysql_mutex_t *mutex,
+                        mysql_cond_t *cond);
 int open_tables(THD *thd, TABLE_LIST **tables, uint *counter, uint flags);
 /* open_and_lock_tables with optional derived handling */
 int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived,
@@ -1773,7 +1773,7 @@ void release_ddl_log();
 void execute_ddl_log_recovery();
 bool execute_ddl_log_entry(THD *thd, uint first_entry);
 
-extern pthread_mutex_t LOCK_gdl;
+extern mysql_mutex_t LOCK_gdl;
 
 #define WFRM_WRITE_SHADOW 1
 #define WFRM_INSTALL_SHADOW 2
@@ -2072,7 +2072,53 @@ extern FILE *bootstrap_file;
 extern int bootstrap_error;
 extern FILE *stderror_file;
 extern pthread_key(MEM_ROOT**,THR_MALLOC);
-extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open, LOCK_lock_db,
+
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_mysql_create_db;
+extern PSI_mutex_key key_LOCK_Acl;
+extern PSI_mutex_key key_LOCK_open;
+extern PSI_mutex_key key_LOCK_lock_db;
+extern PSI_mutex_key key_LOCK_thread_count;
+extern PSI_mutex_key key_LOCK_mapped_file;
+extern PSI_mutex_key key_LOCK_user_locks;
+extern PSI_mutex_key key_LOCK_status;
+extern PSI_mutex_key key_LOCK_error_log;
+extern PSI_mutex_key key_LOCK_delayed_insert;
+extern PSI_mutex_key key_LOCK_uuid_short;
+extern PSI_mutex_key key_LOCK_delayed_status;
+extern PSI_mutex_key key_LOCK_delayed_create;
+extern PSI_mutex_key key_LOCK_crypt;
+extern PSI_mutex_key key_LOCK_timezone;
+extern PSI_mutex_key key_LOCK_slave_list;
+extern PSI_mutex_key key_LOCK_active_mi;
+extern PSI_mutex_key key_LOCK_manager;
+extern PSI_mutex_key key_LOCK_global_read_lock;
+extern PSI_mutex_key key_LOCK_global_system_variables;
+extern PSI_mutex_key key_LOCK_user_conn;
+extern PSI_mutex_key key_LOCK_prepared_stmt_count;
+extern PSI_mutex_key key_LOCK_bytes_sent;
+extern PSI_mutex_key key_LOCK_bytes_received;
+extern PSI_mutex_key key_LOCK_connection_count;
+#ifdef HAVE_OPENSSL
+extern PSI_mutex_key key_LOCK_des_key_file;
+#endif
+extern PSI_mutex_key key_LOCK_server_started;
+extern PSI_cond_key key_COND_server_started;
+extern PSI_rwlock_key key_LOCK_grant;
+extern PSI_rwlock_key key_LOCK_sys_init_connect;
+extern PSI_rwlock_key key_LOCK_sys_init_slave;
+extern PSI_rwlock_key key_LOCK_system_variables_hash;
+extern PSI_cond_key key_COND_refresh;
+extern PSI_cond_key key_COND_thread_count;
+extern PSI_cond_key key_COND_manager;
+extern PSI_cond_key key_COND_global_read_lock;
+extern PSI_cond_key key_COND_thread_cache;
+extern PSI_cond_key key_COND_flush_thread_cache;
+extern PSI_mutex_key key_LOCK_rpl_status;
+extern PSI_cond_key key_COND_rpl_status;
+#endif
+
+extern mysql_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open, LOCK_lock_db,
        LOCK_thread_count,LOCK_mapped_file,LOCK_user_locks, LOCK_status,
        LOCK_error_log, LOCK_delayed_insert, LOCK_uuid_short,
        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
@@ -2081,15 +2127,15 @@ extern pthread_mutex_t LOCK_mysql_create
        LOCK_prepared_stmt_count,
        LOCK_bytes_sent, LOCK_bytes_received, LOCK_connection_count;
 #ifdef HAVE_OPENSSL
-extern pthread_mutex_t LOCK_des_key_file;
+extern mysql_mutex_t LOCK_des_key_file;
 #endif
-extern pthread_mutex_t LOCK_server_started;
-extern pthread_cond_t COND_server_started;
+extern mysql_mutex_t LOCK_server_started;
+extern mysql_cond_t COND_server_started;
 extern int mysqld_server_started;
-extern rw_lock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
-extern rw_lock_t LOCK_system_variables_hash;
-extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;
-extern pthread_cond_t COND_global_read_lock;
+extern mysql_rwlock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
+extern mysql_rwlock_t LOCK_system_variables_hash;
+extern mysql_cond_t COND_refresh, COND_thread_count, COND_manager;
+extern mysql_cond_t COND_global_read_lock;
 extern pthread_attr_t connection_attrib;
 extern I_List<THD> threads;
 extern I_List<NAMED_LIST> key_caches;
@@ -2428,9 +2474,9 @@ inline const char *table_case_name(HA_CR
 
 inline ulong sql_rnd_with_mutex()
 {
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   ulong tmp=(ulong) (my_rnd(&sql_rand) * 0xffffffff); /* make all bits random */
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   return tmp;
 }
 

=== modified file 'sql/mysqld.cc'
--- a/sql/mysqld.cc	2008-09-08 11:05:26 +0000
+++ b/sql/mysqld.cc	2008-10-10 20:34:55 +0000
@@ -423,7 +423,7 @@ static I_List<THD> thread_cache;
 static double long_query_time;
 static ulong opt_my_crc_dbug_check;
 
-static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;
+static mysql_cond_t COND_thread_cache, COND_flush_thread_cache;
 
 /* Global variables */
 
@@ -682,7 +682,7 @@ SHOW_COMP_OPTION have_community_features
 
 pthread_key(MEM_ROOT**,THR_MALLOC);
 pthread_key(THD*, THR_THD);
-pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
+mysql_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
 		LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,
 		LOCK_error_log,
 		LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
@@ -698,17 +698,17 @@ pthread_mutex_t LOCK_mysql_create_db, LO
   in the server, respectively. As PREPARE/DEALLOCATE rate in a loaded
   server may be fairly high, we need a dedicated lock.
 */
-pthread_mutex_t LOCK_prepared_stmt_count;
+mysql_mutex_t LOCK_prepared_stmt_count;
 #ifdef HAVE_OPENSSL
-pthread_mutex_t LOCK_des_key_file;
+mysql_mutex_t LOCK_des_key_file;
 #endif
-rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
-rw_lock_t	LOCK_system_variables_hash;
-pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
+mysql_rwlock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
+mysql_rwlock_t	LOCK_system_variables_hash;
+mysql_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
 pthread_t signal_thread;
 pthread_attr_t connection_attrib;
-pthread_mutex_t  LOCK_server_started;
-pthread_cond_t  COND_server_started;
+mysql_mutex_t  LOCK_server_started;
+mysql_cond_t  COND_server_started;
 
 int mysqld_server_started= 0;
 
@@ -755,7 +755,7 @@ static uint thr_kill_signal;
 #undef	 getpid
 #include <process.h>
 
-static pthread_cond_t COND_handler_count;
+static mysql_cond_t COND_handler_count;
 static uint handler_count;
 static bool start_mode=0, use_opt_args;
 static int opt_argc;
@@ -810,7 +810,7 @@ scheduler_functions thread_scheduler;
 #ifndef HAVE_YASSL
 typedef struct CRYPTO_dynlock_value
 {
-  rw_lock_t lock;
+  mysql_rwlock_t lock;
 } openssl_lock_t;
 
 static openssl_lock_t *openssl_stdlocks;
@@ -888,20 +888,20 @@ static void close_connections(void)
   flush_thread_cache();
 
   /* kill flush thread */
-  (void) pthread_mutex_lock(&LOCK_manager);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_manager);
   if (manager_thread_in_use)
   {
     DBUG_PRINT("quit", ("killing manager thread: 0x%llx",
                         (ulonglong)manager_thread));
-   (void) pthread_cond_signal(&COND_manager);
+   (void) MYSQL_COND_SIGNAL(&COND_manager);
   }
-  (void) pthread_mutex_unlock(&LOCK_manager);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_manager);
 
   /* kill connection thread */
 #if !defined(__WIN__) && !defined(__NETWARE__)
   DBUG_PRINT("quit", ("waiting for select thread: 0x%llx",
                       (ulonglong)select_thread));
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   while (select_thread_in_use)
   {
@@ -917,18 +917,18 @@ static void close_connections(void)
     set_timespec(abstime, 2);
     for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
     {
-      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,
+      error=MYSQL_COND_TIMEDWAIT(&COND_thread_count,&LOCK_thread_count,
 				   &abstime);
       if (error != EINTR)
 	break;
     }
 #ifdef EXTRA_DEBUG
     if (error != 0 && error != ETIMEDOUT && !count++)
-      sql_print_error("Got error %d from pthread_cond_timedwait",error);
+      sql_print_error("Got error %d from MYSQL_COND_TIMEDWAIT",error);
 #endif
     close_server_sock();
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 #endif /* __WIN__ */
 
 
@@ -985,7 +985,7 @@ static void close_connections(void)
   */
 
   THD *tmp;
-  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For unlink from list
 
   I_List_iterator<THD> it(threads);
   while ((tmp=it++))
@@ -1001,17 +1001,17 @@ static void close_connections(void)
     if (tmp->mysys_var)
     {
       tmp->mysys_var->abort=1;
-      pthread_mutex_lock(&tmp->mysys_var->mutex);
+      MYSQL_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);
+	MYSQL_MUTEX_LOCK(tmp->mysys_var->current_mutex);
+	MYSQL_COND_BROADCAST(tmp->mysys_var->current_cond);
+	MYSQL_MUTEX_UNLOCK(tmp->mysys_var->current_mutex);
       }
-      pthread_mutex_unlock(&tmp->mysys_var->mutex);
+      MYSQL_MUTEX_UNLOCK(&tmp->mysys_var->mutex);
     }
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count); // For unlink from list
 
   Events::deinit();
   end_slave();
@@ -1028,11 +1028,11 @@ static void close_connections(void)
   for (;;)
   {
     DBUG_PRINT("quit",("Locking LOCK_thread_count"));
-    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
+    (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For unlink from list
     if (!(tmp=threads.get()))
     {
       DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
-      (void) pthread_mutex_unlock(&LOCK_thread_count);
+      (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       break;
     }
 #ifndef __bsdi__				// Bug in BSDI kernel
@@ -1047,17 +1047,17 @@ static void close_connections(void)
     }
 #endif
     DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
-    (void) pthread_mutex_unlock(&LOCK_thread_count);
+    (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
   /* All threads has now been aborted */
   DBUG_PRINT("quit",("Waiting for threads to die (count=%u)",thread_count));
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   while (thread_count)
   {
-    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
+    (void) MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
     DBUG_PRINT("quit",("One thread died (count=%u)",thread_count));
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   DBUG_PRINT("quit",("close_connections thread"));
   DBUG_VOID_RETURN;
@@ -1412,12 +1412,12 @@ void clean_up(bool print_message)
   DBUG_PRINT("quit", ("Error messages freed"));
   /* Tell main we are ready */
   logger.cleanup_end();
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   DBUG_PRINT("quit", ("got thread count lock"));
   ready_to_exit=1;
   /* do the broadcast inside the lock to ensure that my_end() is not called */
-  (void) pthread_cond_broadcast(&COND_thread_count);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_COND_BROADCAST(&COND_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   my_uuid_end();
 
   /*
@@ -1454,51 +1454,51 @@ static void wait_for_signal_thread_to_en
 
 static void clean_up_mutexes()
 {
-  (void) pthread_mutex_destroy(&LOCK_mysql_create_db);
-  (void) pthread_mutex_destroy(&LOCK_lock_db);
-  (void) pthread_mutex_destroy(&LOCK_Acl);
-  (void) rwlock_destroy(&LOCK_grant);
-  (void) pthread_mutex_destroy(&LOCK_open);
-  (void) pthread_mutex_destroy(&LOCK_thread_count);
-  (void) pthread_mutex_destroy(&LOCK_mapped_file);
-  (void) pthread_mutex_destroy(&LOCK_status);
-  (void) pthread_mutex_destroy(&LOCK_error_log);
-  (void) pthread_mutex_destroy(&LOCK_delayed_insert);
-  (void) pthread_mutex_destroy(&LOCK_delayed_status);
-  (void) pthread_mutex_destroy(&LOCK_delayed_create);
-  (void) pthread_mutex_destroy(&LOCK_manager);
-  (void) pthread_mutex_destroy(&LOCK_crypt);
-  (void) pthread_mutex_destroy(&LOCK_bytes_sent);
-  (void) pthread_mutex_destroy(&LOCK_bytes_received);
-  (void) pthread_mutex_destroy(&LOCK_user_conn);
-  (void) pthread_mutex_destroy(&LOCK_connection_count);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_mysql_create_db);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_lock_db);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_Acl);
+  (void) MYSQL_RWLOCK_DESTROY(&LOCK_grant);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_open);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_mapped_file);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_status);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_error_log);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_delayed_insert);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_delayed_status);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_delayed_create);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_manager);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_crypt);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_bytes_sent);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_bytes_received);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_connection_count);
   Events::destroy_mutexes();
 #ifdef HAVE_OPENSSL
-  (void) pthread_mutex_destroy(&LOCK_des_key_file);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_des_key_file);
 #ifndef HAVE_YASSL
   for (int i= 0; i < CRYPTO_num_locks(); ++i)
-    (void) rwlock_destroy(&openssl_stdlocks[i].lock);
+    (void) MYSQL_RWLOCK_DESTROY(&openssl_stdlocks[i].lock);
   OPENSSL_free(openssl_stdlocks);
 #endif
 #endif
 #ifdef HAVE_REPLICATION
-  (void) pthread_mutex_destroy(&LOCK_rpl_status);
-  (void) pthread_cond_destroy(&COND_rpl_status);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_rpl_status);
+  (void) MYSQL_COND_DESTROY(&COND_rpl_status);
 #endif
-  (void) pthread_mutex_destroy(&LOCK_active_mi);
-  (void) rwlock_destroy(&LOCK_sys_init_connect);
-  (void) rwlock_destroy(&LOCK_sys_init_slave);
-  (void) pthread_mutex_destroy(&LOCK_global_system_variables);
-  (void) pthread_mutex_destroy(&LOCK_uuid_short);
-  (void) rwlock_destroy(&LOCK_system_variables_hash);
-  (void) pthread_mutex_destroy(&LOCK_global_read_lock);
-  (void) pthread_mutex_destroy(&LOCK_prepared_stmt_count);
-  (void) pthread_cond_destroy(&COND_thread_count);
-  (void) pthread_cond_destroy(&COND_refresh);
-  (void) pthread_cond_destroy(&COND_global_read_lock);
-  (void) pthread_cond_destroy(&COND_thread_cache);
-  (void) pthread_cond_destroy(&COND_flush_thread_cache);
-  (void) pthread_cond_destroy(&COND_manager);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_active_mi);
+  (void) MYSQL_RWLOCK_DESTROY(&LOCK_sys_init_connect);
+  (void) MYSQL_RWLOCK_DESTROY(&LOCK_sys_init_slave);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_global_system_variables);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_uuid_short);
+  (void) MYSQL_RWLOCK_DESTROY(&LOCK_system_variables_hash);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_global_read_lock);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_prepared_stmt_count);
+  (void) MYSQL_COND_DESTROY(&COND_thread_count);
+  (void) MYSQL_COND_DESTROY(&COND_refresh);
+  (void) MYSQL_COND_DESTROY(&COND_global_read_lock);
+  (void) MYSQL_COND_DESTROY(&COND_thread_cache);
+  (void) MYSQL_COND_DESTROY(&COND_flush_thread_cache);
+  (void) MYSQL_COND_DESTROY(&COND_manager);
   DDL_blocker_class::destroy_DDL_blocker_class_instance();
 }
 
@@ -1906,7 +1906,7 @@ void close_connection(THD *thd, uint err
 		      "(not connected)",
 		      errcode ? ER(errcode) : ""));
   if (lock)
-    (void) pthread_mutex_lock(&LOCK_thread_count);
+    (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->killed= THD::KILL_CONNECTION;
   if ((vio= thd->net.vio) != 0)
   {
@@ -1915,7 +1915,7 @@ void close_connection(THD *thd, uint err
     vio_close(vio);			/* vio is freed in delete thd */
   }
   if (lock)
-    (void) pthread_mutex_unlock(&LOCK_thread_count);
+    (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 }
 #endif /* EMBEDDED_LIBRARY */
@@ -1953,11 +1953,11 @@ void unlink_thd(THD *thd)
   DBUG_PRINT("enter", ("thd: %p", thd));
   thd->cleanup();
 
-  pthread_mutex_lock(&LOCK_connection_count);
+  MYSQL_MUTEX_LOCK(&LOCK_connection_count);
   --connection_count;
-  pthread_mutex_unlock(&LOCK_connection_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_connection_count);
 
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
   delete thd;
   DBUG_VOID_RETURN;
@@ -1982,7 +1982,7 @@ void unlink_thd(THD *thd)
 
 static bool cache_thread()
 {
-  safe_mutex_assert_owner(&LOCK_thread_count);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_thread_count);
   if (cached_thread_count < thread_cache_size &&
       ! abort_loop && !kill_cached_threads)
   {
@@ -1990,10 +1990,10 @@ static bool cache_thread()
     DBUG_PRINT("info", ("Adding thread to cache"));
     cached_thread_count++;
     while (!abort_loop && ! wake_thread && ! kill_cached_threads)
-      (void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);
+      (void) MYSQL_COND_WAIT(&COND_thread_cache, &LOCK_thread_count);
     cached_thread_count--;
     if (kill_cached_threads)
-      pthread_cond_signal(&COND_flush_thread_cache);
+      MYSQL_COND_SIGNAL(&COND_flush_thread_cache);
     if (wake_thread)
     {
       THD *thd;
@@ -2041,14 +2041,14 @@ bool one_thread_per_connection_end(THD *
   unlink_thd(thd);
   if (put_in_cache)
     put_in_cache= cache_thread();
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (put_in_cache)
     DBUG_RETURN(0);                             // Thread is reused
 
   /* It's safe to broadcast outside a lock (COND... is not deleted here) */
   DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
   my_thread_end();
-  (void) pthread_cond_broadcast(&COND_thread_count);
+  (void) MYSQL_COND_BROADCAST(&COND_thread_count);
 
   pthread_exit(0);
   DBUG_RETURN(0);                               // Impossible
@@ -2057,15 +2057,15 @@ bool one_thread_per_connection_end(THD *
 
 void flush_thread_cache()
 {
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   kill_cached_threads++;
   while (cached_thread_count)
   {
-    pthread_cond_broadcast(&COND_thread_cache);
-    pthread_cond_wait(&COND_flush_thread_cache,&LOCK_thread_count);
+    MYSQL_COND_BROADCAST(&COND_thread_cache);
+    MYSQL_COND_WAIT(&COND_flush_thread_cache,&LOCK_thread_count);
   }
   kill_cached_threads--;
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 }
 
 
@@ -2788,15 +2788,15 @@ static void start_signal_handler(void)
 #endif
 #endif
 
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
   {
     sql_print_error("Can't create interrupt-thread (error %d, errno: %d)",
 		    error,errno);
     exit(1);
   }
-  (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   (void) pthread_attr_destroy(&thr_attr);
   DBUG_VOID_RETURN;
@@ -2854,11 +2854,11 @@ pthread_handler_t signal_hand(void *arg 
     This works by waiting for start_signal_handler to free mutex,
     after which we signal it that we are ready.
     At this pointer there is no other threads running, so there
-    should not be any other pthread_cond_signal() calls.
+    should not be any other MYSQL_COND_SIGNAL() calls.
   */
-  (void) pthread_mutex_lock(&LOCK_thread_count);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
-  (void) pthread_cond_broadcast(&COND_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
+  (void) MYSQL_COND_BROADCAST(&COND_thread_count);
 
   (void) pthread_sigmask(SIG_BLOCK,&set,NULL);
   for (;;)
@@ -3696,36 +3696,36 @@ You should consider changing lower_case_
 
 static int init_thread_environment()
 {
-  (void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_Acl,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_open, NULL);
-  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_delayed_insert,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_delayed_status,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_delayed_create,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_bytes_sent,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_bytes_received,MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
-  (void) my_rwlock_init(&LOCK_system_variables_hash, NULL);
-  (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_uuid_short, MY_MUTEX_INIT_FAST);
-  (void) pthread_mutex_init(&LOCK_connection_count, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_mysql_create_db, key_LOCK_mysql_create_db, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_lock_db, key_LOCK_lock_db, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_Acl, key_LOCK_Acl, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_open, key_LOCK_open, NULL);
+  (void) MYSQL_MUTEX_INIT(&LOCK_thread_count,key_LOCK_thread_count, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_mapped_file, key_LOCK_mapped_file, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_status, key_LOCK_status, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_error_log, key_LOCK_error_log, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_delayed_insert, key_LOCK_delayed_insert, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_delayed_status, key_LOCK_delayed_status, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_delayed_create, key_LOCK_delayed_create, MY_MUTEX_INIT_SLOW);
+  (void) MYSQL_MUTEX_INIT(&LOCK_manager, key_LOCK_manager, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_crypt, key_LOCK_crypt, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_bytes_sent, key_LOCK_bytes_sent, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_bytes_received, key_LOCK_bytes_received, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_user_conn, key_LOCK_user_conn, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_active_mi, key_LOCK_active_mi, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_global_system_variables, key_LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_RWLOCK_INIT(&LOCK_system_variables_hash, key_LOCK_system_variables_hash, NULL);
+  (void) MYSQL_MUTEX_INIT(&LOCK_global_read_lock, key_LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_prepared_stmt_count, key_LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_uuid_short, key_LOCK_uuid_short, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_connection_count, key_LOCK_connection_count, MY_MUTEX_INIT_FAST);
 #ifdef HAVE_OPENSSL
-  (void) pthread_mutex_init(&LOCK_des_key_file,MY_MUTEX_INIT_FAST);
+  (void) MYSQL_MUTEX_INIT(&LOCK_des_key_file, key_LOCK_des_key_file, MY_MUTEX_INIT_FAST);
 #ifndef HAVE_YASSL
   openssl_stdlocks= (openssl_lock_t*) OPENSSL_malloc(CRYPTO_num_locks() *
                                                      sizeof(openssl_lock_t));
   for (int i= 0; i < CRYPTO_num_locks(); ++i)
-    (void) my_rwlock_init(&openssl_stdlocks[i].lock, NULL);
+    (void) MYSQL_RWLOCK_INIT(&openssl_stdlocks[i].lock, key_openssl_lock, NULL);
   CRYPTO_set_dynlock_create_callback(openssl_dynlock_create);
   CRYPTO_set_dynlock_destroy_callback(openssl_dynlock_destroy);
   CRYPTO_set_dynlock_lock_callback(openssl_lock);
@@ -3733,21 +3733,21 @@ static int init_thread_environment()
   CRYPTO_set_id_callback(openssl_id_function);
 #endif
 #endif
-  (void) my_rwlock_init(&LOCK_sys_init_connect, NULL);
-  (void) my_rwlock_init(&LOCK_sys_init_slave, NULL);
-  (void) my_rwlock_init(&LOCK_grant, NULL);
-  (void) pthread_cond_init(&COND_thread_count,NULL);
-  (void) pthread_cond_init(&COND_refresh,NULL);
-  (void) pthread_cond_init(&COND_global_read_lock,NULL);
-  (void) pthread_cond_init(&COND_thread_cache,NULL);
-  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
-  (void) pthread_cond_init(&COND_manager,NULL);
+  (void) MYSQL_RWLOCK_INIT(&LOCK_sys_init_connect, key_LOCK_sys_init_connect, NULL);
+  (void) MYSQL_RWLOCK_INIT(&LOCK_sys_init_slave, key_LOCK_sys_init_slave, NULL);
+  (void) MYSQL_RWLOCK_INIT(&LOCK_grant, key_LOCK_grant, NULL);
+  (void) MYSQL_COND_INIT(&COND_thread_count, key_COND_thread_count, NULL);
+  (void) MYSQL_COND_INIT(&COND_refresh, key_COND_refresh, NULL);
+  (void) MYSQL_COND_INIT(&COND_global_read_lock, key_COND_global_read_lock, NULL);
+  (void) MYSQL_COND_INIT(&COND_thread_cache, key_COND_thread_cache, NULL);
+  (void) MYSQL_COND_INIT(&COND_flush_thread_cache, key_COND_flush_thread_cache, NULL);
+  (void) MYSQL_COND_INIT(&COND_manager, key_COND_manager, NULL);
 #ifdef HAVE_REPLICATION
-  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
-  (void) pthread_cond_init(&COND_rpl_status, NULL);
+  (void) MYSQL_MUTEX_INIT(&LOCK_rpl_status, key_LOCK_rpl_status, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_COND_INIT(&COND_rpl_status, key_COND_rpl_status, NULL);
 #endif
-  (void) pthread_mutex_init(&LOCK_server_started, MY_MUTEX_INIT_FAST);
-  (void) pthread_cond_init(&COND_server_started,NULL);
+  (void) MYSQL_MUTEX_INIT(&LOCK_server_started, key_LOCK_server_started, MY_MUTEX_INIT_FAST);
+  (void) MYSQL_COND_INIT(&COND_server_started, key_COND_server_started, NULL);
 
   /*
     Initialize the DDL blocker
@@ -3786,7 +3786,7 @@ static unsigned long openssl_id_function
 static openssl_lock_t *openssl_dynlock_create(const char *file, int line)
 {
   openssl_lock_t *lock= new openssl_lock_t;
-  my_rwlock_init(&lock->lock, NULL);
+  MYSQL_RWLOCK_INIT(&lock->lock, key_openssl_lock, NULL);
   return lock;
 }
 
@@ -3794,7 +3794,7 @@ static openssl_lock_t *openssl_dynlock_c
 static void openssl_dynlock_destroy(openssl_lock_t *lock, const char *file,
 				    int line)
 {
-  rwlock_destroy(&lock->lock);
+  MYSQL_RWLOCK_DESTROY(&lock->lock);
   delete lock;
 }
 
@@ -3820,16 +3820,16 @@ static void openssl_lock(int mode, opens
   switch (mode) {
   case CRYPTO_LOCK|CRYPTO_READ:
     what = "read lock";
-    err = rw_rdlock(&lock->lock);
+    err = MYSQL_RWLOCK_RDLOCK(&lock->lock);
     break;
   case CRYPTO_LOCK|CRYPTO_WRITE:
     what = "write lock";
-    err = rw_wrlock(&lock->lock);
+    err = MYSQL_RWLOCK_WRLOCK(&lock->lock);
     break;
   case CRYPTO_UNLOCK|CRYPTO_READ:
   case CRYPTO_UNLOCK|CRYPTO_WRITE:
     what = "unlock";
-    err = rw_unlock(&lock->lock);
+    err = MYSQL_RWLOCK_UNLOCK(&lock->lock);
     break;
   default:
     /* Unknown locking mode. */
@@ -4374,8 +4374,8 @@ static void handle_connections_methods()
   }
 #endif
 
-  pthread_mutex_lock(&LOCK_thread_count);
-  (void) pthread_cond_init(&COND_handler_count,NULL);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
+  (void) MYSQL_COND_INIT(&COND_handler_count, key_COND_handler_count, NULL);
   handler_count=0;
 #ifdef __NT__
   if (hPipe != INVALID_HANDLE_VALUE)
@@ -4413,17 +4413,17 @@ static void handle_connections_methods()
 #endif
 
   while (handler_count > 0)
-    pthread_cond_wait(&COND_handler_count,&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_COND_WAIT(&COND_handler_count,&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 }
 
 void decrement_handler_count()
 {
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   handler_count--;
-  pthread_cond_signal(&COND_handler_count);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_COND_SIGNAL(&COND_handler_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   my_thread_end();
 }
 #else
@@ -4663,10 +4663,10 @@ int main(int argc, char **argv)
 
 
   /* Signal threads waiting for server to be started */
-  pthread_mutex_lock(&LOCK_server_started);
+  MYSQL_MUTEX_LOCK(&LOCK_server_started);
   mysqld_server_started= 1;
-  pthread_cond_signal(&COND_server_started);
-  pthread_mutex_unlock(&LOCK_server_started);
+  MYSQL_COND_SIGNAL(&COND_server_started);
+  MYSQL_MUTEX_UNLOCK(&LOCK_server_started);
 
 #if defined(__NT__) || defined(HAVE_SMEM)
   handle_connections_methods();
@@ -4689,21 +4689,21 @@ int main(int argc, char **argv)
 #ifdef EXTRA_DEBUG2
   sql_print_error("Before Lock_thread_count");
 #endif
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   DBUG_PRINT("quit", ("Got thread_count mutex"));
   select_thread_in_use=0;			// For close_connections
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
-  (void) pthread_cond_broadcast(&COND_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
+  (void) MYSQL_COND_BROADCAST(&COND_thread_count);
 #ifdef EXTRA_DEBUG2
   sql_print_error("After lock_thread_count");
 #endif
 #endif /* __WIN__ */
 
   /* Wait until cleanup is done */
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   while (!ready_to_exit)
-    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
 #if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
   if (Service.IsNT() && start_mode)
@@ -4939,13 +4939,13 @@ static void bootstrap(FILE *file)
     DBUG_VOID_RETURN;
   }
   /* Wait for thread to die */
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   while (thread_count)
   {
-    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
+    (void) MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
     DBUG_PRINT("quit",("One thread died (count=%u)",thread_count));
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 #else
   thd->mysql= 0;
   handle_bootstrap((void *)thd);
@@ -4982,10 +4982,10 @@ static bool read_init_file(char *file_na
 
 void handle_connection_in_main_thread(THD *thd)
 {
-  safe_mutex_assert_owner(&LOCK_thread_count);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_thread_count);
   thread_cache_size=0;			// Safety
   threads.append(thd);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   handle_one_connection((void*) thd);
 }
 
@@ -5001,7 +5001,7 @@ void create_thread_to_handle_connection(
     /* Get thread from cache */
     thread_cache.append(thd);
     wake_thread++;
-    pthread_cond_signal(&COND_thread_cache);
+    MYSQL_COND_SIGNAL(&COND_thread_cache);
   }
   else
   {
@@ -5022,26 +5022,26 @@ void create_thread_to_handle_connection(
                   error));
       thread_count--;
       thd->killed= THD::KILL_CONNECTION;			// Safety
-      (void) pthread_mutex_unlock(&LOCK_thread_count);
+      (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
-      pthread_mutex_lock(&LOCK_connection_count);
+      MYSQL_MUTEX_LOCK(&LOCK_connection_count);
       --connection_count;
-      pthread_mutex_unlock(&LOCK_connection_count);
+      MYSQL_MUTEX_UNLOCK(&LOCK_connection_count);
 
       statistic_increment(aborted_connects,&LOCK_status);
       /* Can't use my_error() since store_globals has not been called. */
       my_snprintf(error_message_buff, sizeof(error_message_buff),
                   ER(ER_CANT_CREATE_THREAD), error);
       net_send_error(thd, ER_CANT_CREATE_THREAD, error_message_buff);
-      (void) pthread_mutex_lock(&LOCK_thread_count);
+      (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
       close_connection(thd,0,0);
       delete thd;
-      (void) pthread_mutex_unlock(&LOCK_thread_count);
+      (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       return;
       /* purecov: end */
     }
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_PRINT("info",("Thread created"));
 }
 
@@ -5068,11 +5068,11 @@ static void create_new_thread(THD *thd)
     only (max_connections + 1) connections.
   */
 
-  pthread_mutex_lock(&LOCK_connection_count);
+  MYSQL_MUTEX_LOCK(&LOCK_connection_count);
 
   if (connection_count >= max_connections + 1 || abort_loop)
   {
-    pthread_mutex_unlock(&LOCK_connection_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_connection_count);
 
     DBUG_PRINT("error",("Too many connections"));
     close_connection(thd, ER_CON_COUNT_ERROR, 1);
@@ -5085,11 +5085,11 @@ static void create_new_thread(THD *thd)
   if (connection_count > max_used_connections)
     max_used_connections= connection_count;
 
-  pthread_mutex_unlock(&LOCK_connection_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_connection_count);
 
   /* Start a new thread to handle connection. */
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   /*
     The initialization of thread_id is done in create_embedded_thd() for
@@ -7197,11 +7197,11 @@ static int show_rpl_status(THD *thd, SHO
 static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)
 {
   var->type= SHOW_MY_BOOL;
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   var->value= buff;
   *((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&
                                  active_mi->rli.slave_running);
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   return 0;
 }
 
@@ -7211,41 +7211,41 @@ static int show_slave_retried_trans(THD 
     TODO: with multimaster, have one such counter per line in
     SHOW SLAVE STATUS, and have the sum over all lines here.
   */
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   if (active_mi)
   {
     var->type= SHOW_LONG;
     var->value= buff;
-    pthread_mutex_lock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_LOCK(&active_mi->rli.data_lock);
     *((long *)buff)= (long)active_mi->rli.retried_trans;
-    pthread_mutex_unlock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_UNLOCK(&active_mi->rli.data_lock);
   }
   else
     var->type= SHOW_UNDEF;
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   return 0;
 }
 
 static int show_slave_received_heartbeats(THD *thd, SHOW_VAR *var, char *buff)
 {
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   if (active_mi)
   {
     var->type= SHOW_LONGLONG;
     var->value= buff;
-    pthread_mutex_lock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_LOCK(&active_mi->rli.data_lock);
     *((longlong *)buff)= active_mi->received_heartbeats;
-    pthread_mutex_unlock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_UNLOCK(&active_mi->rli.data_lock);
   }
   else
     var->type= SHOW_UNDEF;
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   return 0;
 }
 
 static int show_heartbeat_period(THD *thd, SHOW_VAR *var, char *buff)
 {
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   if (active_mi)
   {
     var->type= SHOW_CHAR;
@@ -7254,7 +7254,7 @@ static int show_heartbeat_period(THD *th
   }
   else
     var->type= SHOW_UNDEF;
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   return 0;
 }
 
@@ -7273,9 +7273,9 @@ static int show_prepared_stmt_count(THD 
 {
   var->type= SHOW_LONG;
   var->value= buff;
-  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_LOCK(&LOCK_prepared_stmt_count);
   *((long *)buff)= (long)prepared_stmt_count;
-  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
   return 0;
 }
 
@@ -8973,7 +8973,7 @@ static void create_pid_file()
 /** Clear most status variables. */
 void refresh_status(THD *thd)
 {
-  pthread_mutex_lock(&LOCK_status);
+  MYSQL_MUTEX_LOCK(&LOCK_status);
 
   /* Add thread's status variabes to global status */
   add_to_status(&global_status_var, &thd->status_var);
@@ -8987,7 +8987,7 @@ void refresh_status(THD *thd)
   /* Reset the counters of all key caches (default and named). */
   process_key_caches(reset_key_cache_counters);
   flush_status_time= time((time_t*) 0);
-  pthread_mutex_unlock(&LOCK_status);
+  MYSQL_MUTEX_UNLOCK(&LOCK_status);
 
   /*
     Set max_used_connections to the number of currently open
@@ -8995,9 +8995,9 @@ void refresh_status(THD *thd)
     deadlocks.  Status reset becomes not atomic, but status data is
     not exact anyway.
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   max_used_connections= thread_count-delayed_insert_threads;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 }
 
 
@@ -9025,3 +9025,118 @@ template class I_List<NAMED_LIST>;
 template class I_List<Statement>;
 template class I_List_iterator<Statement>;
 #endif
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_mysql_create_db;
+PSI_mutex_key key_LOCK_Acl;
+PSI_mutex_key key_LOCK_open;
+PSI_mutex_key key_LOCK_lock_db;
+PSI_mutex_key key_LOCK_thread_count;
+PSI_mutex_key key_LOCK_mapped_file;
+PSI_mutex_key key_LOCK_status;
+PSI_mutex_key key_LOCK_error_log;
+PSI_mutex_key key_LOCK_delayed_insert;
+PSI_mutex_key key_LOCK_uuid_short;
+PSI_mutex_key key_LOCK_delayed_status;
+PSI_mutex_key key_LOCK_delayed_create;
+PSI_mutex_key key_LOCK_crypt;
+PSI_mutex_key key_LOCK_timezone;
+PSI_mutex_key key_LOCK_slave_list;
+PSI_mutex_key key_LOCK_active_mi;
+PSI_mutex_key key_LOCK_manager;
+PSI_mutex_key key_LOCK_global_read_lock;
+PSI_mutex_key key_LOCK_global_system_variables;
+PSI_mutex_key key_LOCK_user_conn;
+PSI_mutex_key key_LOCK_prepared_stmt_count;
+PSI_mutex_key key_LOCK_bytes_sent;
+PSI_mutex_key key_LOCK_bytes_received;
+PSI_mutex_key key_LOCK_connection_count;
+PSI_mutex_key key_LOCK_server_started;
+PSI_cond_key key_COND_server_started;
+PSI_rwlock_key key_LOCK_grant;
+PSI_rwlock_key key_LOCK_sys_init_connect;
+PSI_rwlock_key key_LOCK_sys_init_slave;
+PSI_rwlock_key key_LOCK_system_variables_hash;
+PSI_cond_key key_COND_refresh;
+PSI_cond_key key_COND_thread_count;
+PSI_cond_key key_COND_manager;
+PSI_cond_key key_COND_global_read_lock;
+PSI_cond_key key_COND_thread_cache;
+PSI_cond_key key_COND_flush_thread_cache;
+PSI_mutex_key key_LOCK_rpl_status;
+PSI_cond_key key_COND_rpl_status;
+
+PSI_mutex_key key_LOCK_delete;
+PSI_mutex_key key_hash_filo_lock;
+PSI_mutex_key key_LOCK_ha_data;
+
+PSI_mutex_key key_LOG_LOCK_log;
+
+PSI_mutex_key key_BINLOG_LOCK_index;
+PSI_mutex_key key_BINLOG_LOCK_prep_xids;
+PSI_cond_key key_BINLOG_COND_prep_xids;
+PSI_cond_key key_BINLOG_update_cond;
+
+PSI_mutex_key key_LOCK_logger;
+PSI_mutex_key key_LOG_INFO_lock;
+PSI_mutex_key key_LOCK_backupid;
+PSI_rwlock_key key_QCQ_lock;
+PSI_mutex_key key_structure_guard_mutex;
+PSI_cond_key key_COND_cache_status_changed;
+PSI_mutex_key key_RLI_run_lock;
+PSI_mutex_key key_RLI_data_lock;
+PSI_mutex_key key_RLI_log_space_lock;
+PSI_cond_key key_RLI_data_cond;
+PSI_cond_key key_RLI_start_cond;
+PSI_cond_key key_RLI_stop_cond;
+PSI_cond_key key_RLI_log_space_cond;
+PSI_mutex_key key_MI_run_lock;
+PSI_mutex_key key_MI_data_lock;
+PSI_cond_key key_MI_data_cond;
+PSI_cond_key key_MI_start_cond;
+PSI_cond_key key_MI_stop_cond;
+PSI_mutex_key key_LOCK_scheduler_state;
+PSI_cond_key key_Event_scheduler_COND_state;
+PSI_mutex_key key_LOCK_event_metadata;
+PSI_mutex_key key_LOCK_event_queue;
+PSI_cond_key key_COND_queue_state;
+PSI_mutex_key key_THR_LOCK_DDL_blocker;
+PSI_mutex_key key_THR_LOCK_DDL_is_blocked;
+PSI_mutex_key key_THR_LOCK_DDL_blocker_blocked;
+PSI_cond_key key_COND_DDL_blocker;
+PSI_cond_key key_COND_process_blocked;
+PSI_cond_key key_COND_DDL_blocker_blocked;
+PSI_mutex_key key_THR_LOCK_thread;
+PSI_cond_key key_COND_thread_wait;
+PSI_mutex_key key_THR_LOCK_caller;
+PSI_cond_key key_COND_caller_wait;
+PSI_mutex_key key_BRC_run_lock;
+PSI_mutex_key key_NDB_SHARE_mutex;
+
+
+
+#ifdef HAVE_OPENSSL
+PSI_mutex_key key_LOCK_des_key_file;
+#endif
+
+#ifdef HAVE_MMAP
+PSI_mutex_key key_PAGE_lock;
+PSI_cond_key key_PAGE_cond;
+PSI_mutex_key key_LOCK_sync;
+PSI_mutex_key key_LOCK_active;
+PSI_mutex_key key_LOCK_pool;
+PSI_cond_key key_COND_active;
+PSI_cond_key key_COND_pool;
+#endif
+
+void init_psi_server_keys()
+{
+}
+
+#endif
+
+
+
+
+
+

=== modified file 'sql/net_serv.cc'
--- a/sql/net_serv.cc	2008-05-29 15:44:11 +0000
+++ b/sql/net_serv.cc	2008-10-10 20:34:55 +0000
@@ -90,7 +90,7 @@ void sql_print_error(const char *format,
 */
 extern uint test_flags;
 extern ulong bytes_sent, bytes_received, net_big_packet_count;
-extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
+extern mysql_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
 #ifndef MYSQL_INSTANCE_MANAGER
 #ifdef HAVE_QUERY_CACHE
 #define USE_QUERY_CACHE

=== modified file 'sql/repl_failsafe.cc'
--- a/sql/repl_failsafe.cc	2008-08-07 17:52:43 +0000
+++ b/sql/repl_failsafe.cc	2008-10-10 20:34:55 +0000
@@ -39,8 +39,8 @@
 
 
 RPL_STATUS rpl_status=RPL_NULL;
-pthread_mutex_t LOCK_rpl_status;
-pthread_cond_t COND_rpl_status;
+mysql_mutex_t LOCK_rpl_status;
+mysql_cond_t COND_rpl_status;
 HASH slave_list;
 
 const char *rpl_role_type[] = {"MASTER","SLAVE",NullS};
@@ -83,9 +83,9 @@ static int init_failsafe_rpl_thread(THD*
   my_net_init(&thd->net, 0);
   thd->net.read_timeout = slave_net_timeout;
   thd->max_client_packet_length=thd->net.max_packet;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if (init_thr_lock() || thd->store_globals())
   {
@@ -110,11 +110,11 @@ static int init_failsafe_rpl_thread(THD*
 
 void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status)
 {
-  pthread_mutex_lock(&LOCK_rpl_status);
+  MYSQL_MUTEX_LOCK(&LOCK_rpl_status);
   if (rpl_status == from_status || rpl_status == RPL_ANY)
     rpl_status = to_status;
-  pthread_cond_signal(&COND_rpl_status);
-  pthread_mutex_unlock(&LOCK_rpl_status);
+  MYSQL_COND_SIGNAL(&COND_rpl_status);
+  MYSQL_MUTEX_UNLOCK(&LOCK_rpl_status);
 }
 
 
@@ -143,7 +143,7 @@ void unregister_slave(THD* thd, bool onl
   if (thd->server_id)
   {
     if (need_mutex)
-      pthread_mutex_lock(&LOCK_slave_list);
+      MYSQL_MUTEX_LOCK(&LOCK_slave_list);
 
     SLAVE_INFO* old_si;
     if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
@@ -152,7 +152,7 @@ void unregister_slave(THD* thd, bool onl
     hash_delete(&slave_list, (uchar*)old_si);
 
     if (need_mutex)
-      pthread_mutex_unlock(&LOCK_slave_list);
+      MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
   }
 }
 
@@ -193,10 +193,10 @@ int register_slave(THD* thd, uchar* pack
     si->master_id= server_id;
   si->thd= thd;
 
-  pthread_mutex_lock(&LOCK_slave_list);
+  MYSQL_MUTEX_LOCK(&LOCK_slave_list);
   unregister_slave(thd,0,0);
   res= my_hash_insert(&slave_list, (uchar*) si);
-  pthread_mutex_unlock(&LOCK_slave_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
   return res;
 
 err:
@@ -223,7 +223,7 @@ void init_slave_list()
 {
   hash_init(&slave_list, system_charset_info, SLAVE_LIST_CHUNK, 0, 0,
 	    (hash_get_key) slave_list_key, (hash_free_key) slave_info_free, 0);
-  pthread_mutex_init(&LOCK_slave_list, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_slave_list, key_LOCK_slave_list, MY_MUTEX_INIT_FAST);
 }
 
 void end_slave_list()
@@ -232,7 +232,7 @@ void end_slave_list()
   if (hash_inited(&slave_list))
   {
     hash_free(&slave_list);
-    pthread_mutex_destroy(&LOCK_slave_list);
+    MYSQL_MUTEX_DESTROY(&LOCK_slave_list);
   }
 }
 
@@ -244,7 +244,7 @@ static int find_target_pos(LEX_MASTER_IN
   for (;;)
   {
     Log_event* ev;
-    if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*) 0, 0)))
+    if (!(ev = Log_event::read_log_event(log, (mysql_mutex_t*) 0, 0)))
     {
       if (log->error > 0)
 	strmov(errmsg, "Binary log truncated in the middle of event");
@@ -286,7 +286,7 @@ int translate_master(THD* thd, LEX_MASTE
   char last_log_name[FN_REFLEN];
   IO_CACHE log;
   File file = -1, last_file = -1;
-  pthread_mutex_t *log_lock;
+  mysql_mutex_t *log_lock;
   const char* errmsg_p;
   Slave_log_event* sev = 0;
   my_off_t last_pos = 0;
@@ -316,7 +316,7 @@ int translate_master(THD* thd, LEX_MASTE
 
   bzero((char*) &log,sizeof(log));
   log_lock = mysql_bin_log.get_log_lock();
-  pthread_mutex_lock(log_lock);
+  MYSQL_MUTEX_LOCK(log_lock);
 
   for (;;)
   {
@@ -389,11 +389,11 @@ found_log:
 mi_inited:
   error = 0;
 err:
-  pthread_mutex_unlock(log_lock);
+  MYSQL_MUTEX_UNLOCK(log_lock);
   end_io_cache(&log);
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->current_linfo = 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (file >= 0)
     (void) my_close(file, MYF(MY_WME));
   if (last_file >= 0 && last_file != file)
@@ -418,7 +418,7 @@ static Slave_log_event* find_slave_event
 
   for (i = 0; i < 2; i++)
   {
-    if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*)0, 0)))
+    if (!(ev = Log_event::read_log_event(log, (mysql_mutex_t*)0, 0)))
     {
       my_snprintf(errmsg, SLAVE_ERRMSG_SIZE,
 		  "Error reading event in log '%s'",
@@ -540,7 +540,7 @@ HOSTS";
     goto err;
   }
 
-  pthread_mutex_lock(&LOCK_slave_list);
+  MYSQL_MUTEX_LOCK(&LOCK_slave_list);
 
   while ((row= mysql_fetch_row(res)))
   {
@@ -555,7 +555,7 @@ HOSTS";
       if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
       {
 	error= "the slave is out of memory";
-	pthread_mutex_unlock(&LOCK_slave_list);
+	MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
 	goto err;
       }
       si->server_id = log_server_id;
@@ -571,7 +571,7 @@ HOSTS";
       strmake(si->password, row[3], sizeof(si->password)-1);
     }
   }
-  pthread_mutex_unlock(&LOCK_slave_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
 
 err:
   if (res)
@@ -609,13 +609,13 @@ pthread_handler_t handle_failsafe_rpl(vo
     sql_print_error("Could not initialize failsafe replication thread");
     goto err;
   }
-  pthread_mutex_lock(&LOCK_rpl_status);
+  MYSQL_MUTEX_LOCK(&LOCK_rpl_status);
   msg= thd->enter_cond(&COND_rpl_status,
                        &LOCK_rpl_status, "Waiting for request");
   while (!thd->killed && !abort_loop)
   {
     bool break_req_chain = 0;
-    pthread_cond_wait(&COND_rpl_status, &LOCK_rpl_status);
+    MYSQL_COND_WAIT(&COND_rpl_status, &LOCK_rpl_status);
     thd_proc_info(thd, "Processing request");
     while (!break_req_chain)
     {
@@ -668,7 +668,7 @@ bool show_slave_hosts(THD* thd)
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_RETURN(TRUE);
 
-  pthread_mutex_lock(&LOCK_slave_list);
+  MYSQL_MUTEX_LOCK(&LOCK_slave_list);
 
   for (uint i = 0; i < slave_list.records; ++i)
   {
@@ -686,11 +686,11 @@ bool show_slave_hosts(THD* thd)
     protocol->store((uint32) si->master_id);
     if (protocol->write())
     {
-      pthread_mutex_unlock(&LOCK_slave_list);
+      MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
       DBUG_RETURN(TRUE);
     }
   }
-  pthread_mutex_unlock(&LOCK_slave_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_slave_list);
   my_eof(thd);
   DBUG_RETURN(FALSE);
 }

=== modified file 'sql/repl_failsafe.h'
--- a/sql/repl_failsafe.h	2007-08-16 06:52:50 +0000
+++ b/sql/repl_failsafe.h	2008-10-10 20:34:55 +0000
@@ -25,8 +25,8 @@ typedef enum {RPL_AUTH_MASTER=0,RPL_ACTI
 	      RPL_ANY /* wild card used by change_rpl_status */ } RPL_STATUS;
 extern RPL_STATUS rpl_status;
 
-extern pthread_mutex_t LOCK_rpl_status;
-extern pthread_cond_t COND_rpl_status;
+extern mysql_mutex_t LOCK_rpl_status;
+extern mysql_cond_t COND_rpl_status;
 extern TYPELIB rpl_role_typelib, rpl_status_typelib;
 extern const char* rpl_role_type[], *rpl_status_type[];
 

=== modified file 'sql/rpl_mi.cc'
--- a/sql/rpl_mi.cc	2008-03-14 22:21:29 +0000
+++ b/sql/rpl_mi.cc	2008-10-10 20:34:55 +0000
@@ -41,20 +41,20 @@ Master_info::Master_info()
   ssl_cipher[0]= 0; ssl_key[0]= 0;
 
   bzero((char*) &file, sizeof(file));
-  pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&data_cond, NULL);
-  pthread_cond_init(&start_cond, NULL);
-  pthread_cond_init(&stop_cond, NULL);
+  MYSQL_MUTEX_INIT(&run_lock, key_MI_run_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&data_lock, key_MI_data_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&data_cond, key_MI_data_cond, NULL);
+  MYSQL_COND_INIT(&start_cond, key_MI_start_cond, NULL);
+  MYSQL_COND_INIT(&stop_cond, key_MI_stop_cond, NULL);
 }
 
 Master_info::~Master_info()
 {
-  pthread_mutex_destroy(&run_lock);
-  pthread_mutex_destroy(&data_lock);
-  pthread_cond_destroy(&data_cond);
-  pthread_cond_destroy(&start_cond);
-  pthread_cond_destroy(&stop_cond);
+  MYSQL_MUTEX_DESTROY(&run_lock);
+  MYSQL_MUTEX_DESTROY(&data_lock);
+  MYSQL_COND_DESTROY(&data_cond);
+  MYSQL_COND_DESTROY(&start_cond);
+  MYSQL_COND_DESTROY(&stop_cond);
 }
 
 
@@ -131,7 +131,7 @@ int init_master_info(Master_info* mi, co
     keep other threads from reading bogus info
   */
 
-  pthread_mutex_lock(&mi->data_lock);
+  MYSQL_MUTEX_LOCK(&mi->data_lock);
   fd = mi->fd;
 
   /* does master.info exist ? */
@@ -140,7 +140,7 @@ int init_master_info(Master_info* mi, co
   {
     if (abort_if_no_master_info_file)
     {
-      pthread_mutex_unlock(&mi->data_lock);
+      MYSQL_MUTEX_UNLOCK(&mi->data_lock);
       DBUG_RETURN(0);
     }
     /*
@@ -313,7 +313,7 @@ file '%s')", fname);
   reinit_io_cache(&mi->file, WRITE_CACHE, 0L, 0, 1);
   if ((error=test(flush_master_info(mi, 1))))
     sql_print_error("Failed to flush master info file");
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_RETURN(error);
 
 errwithmsg:
@@ -326,7 +326,7 @@ err:
     end_io_cache(&mi->file);
   }
   mi->fd= -1;
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_RETURN(1);
 }
 

=== modified file 'sql/rpl_mi.h'
--- a/sql/rpl_mi.h	2008-02-03 09:00:49 +0000
+++ b/sql/rpl_mi.h	2008-10-10 20:34:55 +0000
@@ -55,6 +55,14 @@
 
 *****************************************************************************/
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_MI_run_lock;
+extern PSI_mutex_key key_MI_data_lock;
+extern PSI_cond_key key_MI_data_cond;
+extern PSI_cond_key key_MI_start_cond;
+extern PSI_cond_key key_MI_stop_cond;
+#endif
+
 class Master_info : public Slave_reporting_capability
 {
  public:
@@ -75,8 +83,8 @@ class Master_info : public Slave_reporti
   File fd; // we keep the file open, so we need to remember the file pointer
   IO_CACHE file;
 
-  pthread_mutex_t data_lock,run_lock;
-  pthread_cond_t data_cond,start_cond,stop_cond;
+  mysql_mutex_t data_lock,run_lock;
+  mysql_cond_t data_cond,start_cond,stop_cond;
   THD *io_thd;
   MYSQL* mysql;
   uint32 file_id;				/* for 3.23 load data infile */

=== modified file 'sql/rpl_rli.cc'
--- a/sql/rpl_rli.cc	2008-08-08 01:33:43 +0000
+++ b/sql/rpl_rli.cc	2008-10-10 20:34:55 +0000
@@ -54,13 +54,13 @@ Relay_log_info::Relay_log_info()
   bzero((char*) &info_file, sizeof(info_file));
   bzero((char*) &cache_buf, sizeof(cache_buf));
   cached_charset_invalidate();
-  pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
-  pthread_mutex_init(&log_space_lock, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&data_cond, NULL);
-  pthread_cond_init(&start_cond, NULL);
-  pthread_cond_init(&stop_cond, NULL);
-  pthread_cond_init(&log_space_cond, NULL);
+  MYSQL_MUTEX_INIT(&run_lock, key_RLI_run_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&data_lock, key_RLI_data_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&log_space_lock, key_RLI_log_space_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&data_cond, key_RLI_data_cond, NULL);
+  MYSQL_COND_INIT(&start_cond, key_RLI_start_cond, NULL);
+  MYSQL_COND_INIT(&stop_cond, key_RLI_stop_cond, NULL);
+  MYSQL_COND_INIT(&log_space_cond, key_RLI_log_space_cond, NULL);
   relay_log.init_pthread_objects();
   DBUG_VOID_RETURN;
 }
@@ -70,13 +70,13 @@ Relay_log_info::~Relay_log_info()
 {
   DBUG_ENTER("Relay_log_info::~Relay_log_info");
 
-  pthread_mutex_destroy(&run_lock);
-  pthread_mutex_destroy(&data_lock);
-  pthread_mutex_destroy(&log_space_lock);
-  pthread_cond_destroy(&data_cond);
-  pthread_cond_destroy(&start_cond);
-  pthread_cond_destroy(&stop_cond);
-  pthread_cond_destroy(&log_space_cond);
+  MYSQL_MUTEX_DESTROY(&run_lock);
+  MYSQL_MUTEX_DESTROY(&data_lock);
+  MYSQL_MUTEX_DESTROY(&log_space_lock);
+  MYSQL_COND_DESTROY(&data_cond);
+  MYSQL_COND_DESTROY(&start_cond);
+  MYSQL_COND_DESTROY(&stop_cond);
+  MYSQL_COND_DESTROY(&log_space_cond);
   relay_log.cleanup();
   DBUG_VOID_RETURN;
 }
@@ -95,7 +95,7 @@ int init_relay_log_info(Relay_log_info* 
   if (rli->inited)                       // Set if this function called
     DBUG_RETURN(0);
   fn_format(fname, info_fname, mysql_data_home, "", 4+32);
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
   info_fd = rli->info_fd;
   rli->cur_log_fd = -1;
   rli->slave_skip_counter=0;
@@ -152,7 +152,7 @@ int init_relay_log_info(Relay_log_info* 
                             (max_relay_log_size ? max_relay_log_size :
                             max_binlog_size), 1))
     {
-      pthread_mutex_unlock(&rli->data_lock);
+      MYSQL_MUTEX_UNLOCK(&rli->data_lock);
       sql_print_error("Failed in open_log() called from init_relay_log_info()");
       DBUG_RETURN(1);
     }
@@ -221,7 +221,7 @@ Failed to open the existing relay log in
           my_close(info_fd, MYF(0));
         rli->info_fd= -1;
         rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
-        pthread_mutex_unlock(&rli->data_lock);
+        MYSQL_MUTEX_UNLOCK(&rli->data_lock);
         DBUG_RETURN(1);
       }
     }
@@ -284,7 +284,7 @@ Failed to open the existing relay log in
     goto err;
   }
   rli->inited= 1;
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   DBUG_RETURN(error);
 
 err:
@@ -294,7 +294,7 @@ err:
     my_close(info_fd, MYF(0));
   rli->info_fd= -1;
   rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   DBUG_RETURN(1);
 }
 
@@ -403,10 +403,10 @@ int init_relay_log_pos(Relay_log_info* r
   DBUG_PRINT("info", ("pos: %lu", (ulong) pos));
 
   *errmsg=0;
-  pthread_mutex_t *log_lock=rli->relay_log.get_log_lock();
+  mysql_mutex_t *log_lock=rli->relay_log.get_log_lock();
 
   if (need_data_lock)
-    pthread_mutex_lock(&rli->data_lock);
+    MYSQL_MUTEX_LOCK(&rli->data_lock);
 
   /*
     Slave threads are not the only users of init_relay_log_pos(). CHANGE MASTER
@@ -426,7 +426,7 @@ int init_relay_log_pos(Relay_log_info* r
   rli->relay_log.description_event_for_exec= new
     Format_description_log_event(3);
 
-  pthread_mutex_lock(log_lock);
+  MYSQL_MUTEX_LOCK(log_lock);
 
   /* Close log file and free buffers if it's already open */
   if (rli->cur_log_fd >= 0)
@@ -566,12 +566,12 @@ err:
   */
   if (!relay_log_purge)
     rli->log_space_limit= 0;
-  pthread_cond_broadcast(&rli->data_cond);
+  MYSQL_COND_BROADCAST(&rli->data_cond);
 
-  pthread_mutex_unlock(log_lock);
+  MYSQL_MUTEX_UNLOCK(log_lock);
 
   if (need_data_lock)
-    pthread_mutex_unlock(&rli->data_lock);
+    MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   if (!rli->relay_log.description_event_for_exec->is_valid() && !*errmsg)
     *errmsg= "Invalid Format_description log event; could be out of memory";
 
@@ -622,7 +622,7 @@ int Relay_log_info::wait_for_pos(THD* th
                       log_name->c_ptr(), (ulong) log_pos, (ulong) timeout));
 
   set_timespec(abstime,timeout);
-  pthread_mutex_lock(&data_lock);
+  MYSQL_MUTEX_LOCK(&data_lock);
   msg= thd->enter_cond(&data_cond, &data_lock,
                        "Waiting for the slave SQL thread to "
                        "advance position");
@@ -741,20 +741,20 @@ int Relay_log_info::wait_for_pos(THD* th
     if (timeout > 0)
     {
       /*
-        Note that pthread_cond_timedwait checks for the timeout
+        Note that MYSQL_COND_TIMEDWAIT checks for the timeout
         before for the condition ; i.e. it returns ETIMEDOUT
         if the system time equals or exceeds the time specified by abstime
         before the condition variable is signaled or broadcast, _or_ if
         the absolute time specified by abstime has already passed at the time
         of the call.
-        For that reason, pthread_cond_timedwait will do the "timeoutting" job
+        For that reason, MYSQL_COND_TIMEDWAIT will do the "timeoutting" job
         even if its condition is always immediately signaled (case of a loaded
         master).
       */
-      error=pthread_cond_timedwait(&data_cond, &data_lock, &abstime);
+      error=MYSQL_COND_TIMEDWAIT(&data_cond, &data_lock, &abstime);
     }
     else
-      pthread_cond_wait(&data_cond, &data_lock);
+      MYSQL_COND_WAIT(&data_cond, &data_lock);
     DBUG_PRINT("info",("Got signal of master update or timed out"));
     if (error == ETIMEDOUT || error == ETIME)
     {
@@ -790,7 +790,7 @@ void Relay_log_info::inc_group_relay_log
   DBUG_ENTER("Relay_log_info::inc_group_relay_log_pos");
 
   if (!skip_lock)
-    pthread_mutex_lock(&data_lock);
+    MYSQL_MUTEX_LOCK(&data_lock);
   inc_event_relay_log_pos();
   group_relay_log_pos= event_relay_log_pos;
   strmake(group_relay_log_name,event_relay_log_name,
@@ -834,9 +834,9 @@ void Relay_log_info::inc_group_relay_log
   {
     group_master_log_pos= log_pos;
   }
-  pthread_cond_broadcast(&data_cond);
+  MYSQL_COND_BROADCAST(&data_cond);
   if (!skip_lock)
-    pthread_mutex_unlock(&data_lock);
+    MYSQL_MUTEX_UNLOCK(&data_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -905,7 +905,7 @@ int purge_relay_logs(Relay_log_info* rli
   DBUG_ASSERT(rli->mi->slave_running == 0);
 
   rli->slave_skip_counter=0;
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
 
   /*
     we close the relay log fd possibly left open by the slave SQL thread,
@@ -947,7 +947,7 @@ err:
   char buf[22];
 #endif
   DBUG_PRINT("info",("log_space_total: %s",llstr(rli->log_space_total,buf)));
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   DBUG_RETURN(error);
 }
 

=== modified file 'sql/rpl_rli.h'
--- a/sql/rpl_rli.h	2008-05-23 13:54:03 +0000
+++ b/sql/rpl_rli.h	2008-10-10 20:34:55 +0000
@@ -49,6 +49,16 @@ class Master_info;
 
 *****************************************************************************/
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_RLI_run_lock;
+extern PSI_mutex_key key_RLI_data_lock;
+extern PSI_mutex_key key_RLI_log_space_lock;
+extern PSI_cond_key key_RLI_data_cond;
+extern PSI_cond_key key_RLI_start_cond;
+extern PSI_cond_key key_RLI_stop_cond;
+extern PSI_cond_key key_RLI_log_space_cond;
+#endif
+
 class Relay_log_info : public Slave_reporting_capability
 {
 public:
@@ -112,14 +122,14 @@ public:
     standard lock acquistion order to avoid deadlocks:
     run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
   */
-  pthread_mutex_t data_lock,run_lock;
+  mysql_mutex_t data_lock,run_lock;
 
   /*
     start_cond is broadcast when SQL thread is started
     stop_cond - when stopped
     data_cond - when data protected by data_lock changes
   */
-  pthread_cond_t start_cond, stop_cond, data_cond;
+  mysql_cond_t start_cond, stop_cond, data_cond;
 
   /* parent Master_info structure */
   Master_info *mi;
@@ -201,8 +211,8 @@ public:
   volatile uint32 slave_skip_counter;
   volatile ulong abort_pos_wait;	/* Incremented on change master */
   volatile ulong slave_run_id;		/* Incremented on slave start */
-  pthread_mutex_t log_space_lock;
-  pthread_cond_t log_space_cond;
+  mysql_mutex_t log_space_lock;
+  mysql_cond_t log_space_cond;
   THD * sql_thd;
 #ifndef DBUG_OFF
   int events_till_abort;

=== modified file 'sql/scheduler.cc'
--- a/sql/scheduler.cc	2008-06-27 19:07:13 +0000
+++ b/sql/scheduler.cc	2008-10-10 20:34:55 +0000
@@ -56,7 +56,7 @@ scheduler_functions::scheduler_functions
 static bool no_threads_end(THD *thd, bool put_in_cache)
 {
   unlink_thd(thd);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   return 1;                                     // Abort handle_one_connection
 }
 
@@ -102,7 +102,11 @@ static bool kill_pool_threads;
 static struct event thd_add_event;
 static struct event thd_kill_event;
 
-static pthread_mutex_t LOCK_thd_add;    /* protects thds_need_adding */
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_thd_add;
+#endif
+
+static mysql_mutex_t LOCK_thd_add;    /* protects thds_need_adding */
 static LIST *thds_need_adding;    /* list of thds to add to libevent queue */
 
 static int thd_add_pipe[2]; /* pipe to signal add a connection to libevent*/
@@ -112,7 +116,10 @@ static int thd_kill_pipe[2]; /* pipe to 
   LOCK_event_loop protects the non-thread safe libevent calls (event_add and 
   event_del) and thds_need_processing and thds_waiting_for_io.
 */
-static pthread_mutex_t LOCK_event_loop;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_event_loop;
+#endif
+static mysql_mutex_t LOCK_event_loop;
 static LIST *thds_need_processing; /* list of thds that needs some processing */
 static LIST *thds_waiting_for_io; /* list of thds with added events */
 
@@ -222,9 +229,9 @@ void thd_scheduler::thread_detach()
   if (thread_attached)
   {
     THD* thd = (THD*)list.data;
-    pthread_mutex_lock(&thd->LOCK_delete);
+    MYSQL_MUTEX_LOCK(&thd->LOCK_delete);
     thd->mysys_var= NULL;
-    pthread_mutex_unlock(&thd->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&thd->LOCK_delete);
     thread_attached= FALSE;
 #ifndef DBUG_OFF
     /*
@@ -269,8 +276,8 @@ static bool libevent_init(void)
   killed_threads= 0;
   kill_pool_threads= FALSE;
 
-  pthread_mutex_init(&LOCK_event_loop, NULL);
-  pthread_mutex_init(&LOCK_thd_add, NULL);
+  MYSQL_MUTEX_INIT(&LOCK_event_loop, key_LOCK_event_loop, NULL);
+  MYSQL_MUTEX_INIT(&LOCK_thd_add, key_LOCK_thd_add, NULL);
 
   /* set up the pipe used to add new thds to the event pool */
   if (init_pipe(thd_add_pipe))
@@ -299,7 +306,7 @@ static bool libevent_init(void)
   }
   /* Set up the thread pool */
   created_threads= killed_threads= 0;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   for (i= 0; i < thread_pool_size; i++)
   {
@@ -310,7 +317,7 @@ static bool libevent_init(void)
     {
       sql_print_error("Can't create completion port thread (error %d)",
                       error);
-      pthread_mutex_unlock(&LOCK_thread_count);
+      MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       libevent_end();                      // Cleanup
       DBUG_RETURN(TRUE);
     }
@@ -318,8 +325,8 @@ static bool libevent_init(void)
 
   /* Wait until all threads are created */
   while (created_threads != thread_pool_size)
-    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_COND_WAIT(&COND_thread_count,&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   DBUG_PRINT("info", ("%u threads created", (uint) thread_pool_size));
   DBUG_RETURN(FALSE);
@@ -339,7 +346,7 @@ static bool libevent_init(void)
 
 void libevent_io_callback(int, short, void *ctx)
 {
-  safe_mutex_assert_owner(&LOCK_event_loop);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_event_loop);
   THD *thd= (THD*)ctx;
   thds_waiting_for_io= list_delete(thds_waiting_for_io, &thd->scheduler.list);
   thds_need_processing= list_add(thds_need_processing, &thd->scheduler.list);
@@ -354,7 +361,7 @@ void libevent_io_callback(int, short, vo
 
 void libevent_kill_thd_callback(int Fd, short, void*)
 {
-  safe_mutex_assert_owner(&LOCK_event_loop);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_event_loop);
 
   /* clear the pending events */
   char c;
@@ -392,21 +399,21 @@ void libevent_kill_thd_callback(int Fd, 
 
 void libevent_add_thd_callback(int Fd, short, void *)
 {
-  safe_mutex_assert_owner(&LOCK_event_loop);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_event_loop);
 
   /* clear the pending events */
   char c;
   while (read(Fd, &c, sizeof(c)) == sizeof(c))
   {}
 
-  pthread_mutex_lock(&LOCK_thd_add);
+  MYSQL_MUTEX_LOCK(&LOCK_thd_add);
   while (thds_need_adding)
   {
     /* pop the first thd off the list */
     THD* thd= (THD*)thds_need_adding->data;
     thds_need_adding= list_delete(thds_need_adding, thds_need_adding);
 
-    pthread_mutex_unlock(&LOCK_thd_add);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thd_add);
 
     if (!thd->scheduler.logged_in || libevent_should_close_connection(thd))
     {
@@ -431,9 +438,9 @@ void libevent_add_thd_callback(int Fd, s
                                       &thd->scheduler.list);
       }
     }
-    pthread_mutex_lock(&LOCK_thd_add);
+    MYSQL_MUTEX_LOCK(&LOCK_thd_add);
   }
-  pthread_mutex_unlock(&LOCK_thd_add);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thd_add);
 }
 
 
@@ -453,14 +460,14 @@ static void libevent_add_connection(THD 
   if (thd->scheduler.init(thd))
   {
     sql_print_error("Scheduler init error in libevent_add_new_connection\n");
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     libevent_connection_close(thd);
     DBUG_VOID_RETURN;
   }
   threads.append(thd);
   libevent_thd_add(thd);
 
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 }
 
@@ -509,7 +516,7 @@ static void libevent_connection_close(TH
   }
   thd->scheduler.thread_detach();
   unlink_thd(thd);   /* locks LOCK_thread_count and deletes thd */
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   DBUG_VOID_RETURN;
 }
@@ -546,16 +553,16 @@ pthread_handler_t libevent_thread_proc(v
     Signal libevent_init() when all threads has been created and are ready to
     receive events.
   */
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   created_threads++;
   if (created_threads == thread_pool_size)
-    (void) pthread_cond_signal(&COND_thread_count);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+    (void) MYSQL_COND_SIGNAL(&COND_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   for (;;)
   {
     THD *thd= NULL;
-    (void) pthread_mutex_lock(&LOCK_event_loop);
+    (void) MYSQL_MUTEX_LOCK(&LOCK_event_loop);
 
     /* get thd(s) to process */
     while (!thds_need_processing)
@@ -563,7 +570,7 @@ pthread_handler_t libevent_thread_proc(v
       if (kill_pool_threads)
       {
         /* the flag that we should die has been set */
-        (void) pthread_mutex_unlock(&LOCK_event_loop);
+        (void) MYSQL_MUTEX_UNLOCK(&LOCK_event_loop);
         goto thread_exit;
       }
       event_loop(EVLOOP_ONCE);
@@ -574,7 +581,7 @@ pthread_handler_t libevent_thread_proc(v
     thds_need_processing= list_delete(thds_need_processing,
                                       thds_need_processing);
 
-    (void) pthread_mutex_unlock(&LOCK_event_loop);
+    (void) MYSQL_MUTEX_UNLOCK(&LOCK_event_loop);
 
     /* now we process the connection (thd) */
 
@@ -621,10 +628,10 @@ pthread_handler_t libevent_thread_proc(v
 
 thread_exit:
   DBUG_PRINT("exit", ("ending thread"));
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   killed_threads++;
-  pthread_cond_broadcast(&COND_thread_count);
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_COND_BROADCAST(&COND_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   my_thread_end();
   pthread_exit(0);
   DBUG_RETURN(0);                               /* purify: deadcode */
@@ -672,12 +679,12 @@ static void libevent_thd_add(THD* thd)
   char c=0;
   /* release any audit resources, this thd is going to sleep */
   mysql_audit_release(thd);
-  pthread_mutex_lock(&LOCK_thd_add);
+  MYSQL_MUTEX_LOCK(&LOCK_thd_add);
   /* queue for libevent */
   thds_need_adding= list_add(thds_need_adding, &thd->scheduler.list);
   /* notify libevent */
   write(thd_add_pipe[1], &c, sizeof(c));
-  pthread_mutex_unlock(&LOCK_thd_add);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thd_add);
 }
 
 
@@ -691,7 +698,7 @@ static void libevent_end()
   DBUG_PRINT("enter", ("created_threads: %d  killed_threads: %u",
                        created_threads, killed_threads));
 
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   kill_pool_threads= TRUE;
   while (killed_threads != created_threads)
@@ -700,9 +707,9 @@ static void libevent_end()
     char c= 0;
     write(thd_add_pipe[1], &c, sizeof(c));
 
-    pthread_cond_wait(&COND_thread_count, &LOCK_thread_count);
+    MYSQL_COND_WAIT(&COND_thread_count, &LOCK_thread_count);
   }
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   event_del(&thd_add_event);
   close(thd_add_pipe[0]);
@@ -712,8 +719,8 @@ static void libevent_end()
   close(thd_kill_pipe[1]);
   event_base_free(base);
 
-  (void) pthread_mutex_destroy(&LOCK_event_loop);
-  (void) pthread_mutex_destroy(&LOCK_thd_add);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_event_loop);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_thd_add);
   DBUG_VOID_RETURN;
 }
 

=== modified file 'sql/set_var.cc'
--- a/sql/set_var.cc	2008-09-16 08:34:30 +0000
+++ b/sql/set_var.cc	2008-10-10 20:34:55 +0000
@@ -909,7 +909,7 @@ bool sys_var_str::check(THD *thd, set_va
   'var' parameter is NULL pointer.
 */
 
-bool update_sys_var_str(sys_var_str *var_str, rw_lock_t *var_mutex,
+bool update_sys_var_str(sys_var_str *var_str, mysql_rwlock_t *var_mutex,
 			set_var *var)
 {
   char *res= 0, *old_value=(char *)(var ? var->value->str_value.ptr() : 0);
@@ -922,11 +922,11 @@ bool update_sys_var_str(sys_var_str *var
     Replace the old value in such a way that the any thread using
     the value will work.
   */
-  rw_wrlock(var_mutex);
+  MYSQL_RWLOCK_WRLOCK(var_mutex);
   old_value= var_str->value;
   var_str->value= res;
   var_str->value_length= new_length;
-  rw_unlock(var_mutex);
+  MYSQL_RWLOCK_UNLOCK(var_mutex);
   my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));
   return 0;
 }
@@ -1201,9 +1201,9 @@ bool sys_var_set_slave_mode::check(THD *
 bool sys_var_set_slave_mode::update(THD *thd, set_var *var)
 {
   bool rc;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   rc= sys_var_set::update(thd, var);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return rc;
 }
 
@@ -1402,7 +1402,7 @@ bool sys_var_long_ptr_global::check(THD 
 bool sys_var_long_ptr_global::update(THD *thd, set_var *var)
 {
   ulonglong tmp= var->save_result.ulonglong_value;
-  pthread_mutex_lock(guard);
+  MYSQL_MUTEX_LOCK(guard);
   if (option_limits)
     *value= (ulong) fix_unsigned(thd, tmp, option_limits);
   else
@@ -1419,7 +1419,7 @@ bool sys_var_long_ptr_global::update(THD
     *value= (ulong) tmp;
   }
 
-  pthread_mutex_unlock(guard);
+  MYSQL_MUTEX_UNLOCK(guard);
   return 0;
 }
 
@@ -1427,22 +1427,22 @@ bool sys_var_long_ptr_global::update(THD
 void sys_var_long_ptr_global::set_default(THD *thd, enum_var_type type)
 {
   my_bool not_used;
-  pthread_mutex_lock(guard);
+  MYSQL_MUTEX_LOCK(guard);
   *value= (ulong) getopt_ull_limit_value((ulong) option_limits->def_value,
                                          option_limits, &not_used);
-  pthread_mutex_unlock(guard);
+  MYSQL_MUTEX_UNLOCK(guard);
 }
 
 
 bool sys_var_ulonglong_ptr::update(THD *thd, set_var *var)
 {
   ulonglong tmp= var->save_result.ulonglong_value;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   if (option_limits)
     *value= (ulonglong) fix_unsigned(thd, tmp, option_limits);
   else
     *value= (ulonglong) tmp;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return 0;
 }
 
@@ -1450,10 +1450,10 @@ bool sys_var_ulonglong_ptr::update(THD *
 void sys_var_ulonglong_ptr::set_default(THD *thd, enum_var_type type)
 {
   my_bool not_used;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   *value= getopt_ull_limit_value((ulonglong) option_limits->def_value,
                                  option_limits, &not_used);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 
@@ -1561,9 +1561,9 @@ bool sys_var_thd_ha_rows::update(THD *th
   if (var->type == OPT_GLOBAL)
   {
     /* Lock is needed to make things safe on 32 bit systems */
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.*offset= (ha_rows) tmp;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= (ha_rows) tmp;
@@ -1577,11 +1577,11 @@ void sys_var_thd_ha_rows::set_default(TH
   {
     my_bool not_used;
     /* We will not come here if option_limits is not set */
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.*offset=
       (ha_rows) getopt_ull_limit_value((ha_rows) option_limits->def_value,
                                        option_limits, &not_used);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= global_system_variables.*offset;
@@ -1613,9 +1613,9 @@ bool sys_var_thd_ulonglong::update(THD *
   if (var->type == OPT_GLOBAL)
   {
     /* Lock is needed to make things safe on 32 bit systems */
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.*offset= (ulonglong) tmp;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= (ulonglong) tmp;
@@ -1628,11 +1628,11 @@ void sys_var_thd_ulonglong::set_default(
   if (type == OPT_GLOBAL)
   {
     my_bool not_used;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.*offset=
       getopt_ull_limit_value((ulonglong) option_limits->def_value,
                              option_limits, &not_used);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= global_system_variables.*offset;
@@ -1803,56 +1803,56 @@ Item *sys_var::item(THD *thd, enum_var_t
   case SHOW_INT:
   {
     uint value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(uint*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return new Item_uint((ulonglong) value);
   }
   case SHOW_LONG:
   {
     ulong value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(ulong*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return new Item_uint((ulonglong) value);
   }
   case SHOW_LONGLONG:
   {
     longlong value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(longlong*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return new Item_int(value);
   }
   case SHOW_DOUBLE:
   {
     double value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(double*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     /* 6, as this is for now only used with microseconds */
     return new Item_float(value, 6);
   }
   case SHOW_HA_ROWS:
   {
     ha_rows value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(ha_rows*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return new Item_int((ulonglong) value);
   }
   case SHOW_MY_BOOL:
   {
     int32 value;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     value= *(my_bool*) value_ptr(thd, var_type, base);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return new Item_int(value,1);
   }
   case SHOW_CHAR_PTR:
   {
     Item *tmp;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     char *str= *(char**) value_ptr(thd, var_type, base);
     if (str)
     {
@@ -1865,13 +1865,13 @@ Item *sys_var::item(THD *thd, enum_var_t
       tmp= new Item_null();
       tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
     }
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return tmp;
   }
   case SHOW_CHAR:
   {
     Item *tmp;
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     char *str= (char*) value_ptr(thd, var_type, base);
     if (str)
       tmp= new Item_string(str, strlen(str),
@@ -1881,7 +1881,7 @@ Item *sys_var::item(THD *thd, enum_var_t
       tmp= new Item_null();
       tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
     }
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     return tmp;
   }
   default:
@@ -1957,10 +1957,10 @@ void sys_var_thd_date_time_format::updat
 
   if (type == OPT_GLOBAL)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     old= (global_system_variables.*offset);
     (global_system_variables.*offset)= new_value;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
   {
@@ -2272,7 +2272,7 @@ static KEY_CACHE zero_key_cache;
 
 KEY_CACHE *get_key_cache(LEX_STRING *cache_name)
 {
-  safe_mutex_assert_owner(&LOCK_global_system_variables);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_global_system_variables);
   if (!cache_name || ! cache_name->length)
     cache_name= &default_key_cache_base;
   return ((KEY_CACHE*) find_named(&key_caches,
@@ -2300,7 +2300,7 @@ bool sys_var_key_buffer_size::update(THD
   if (!base_name->length)
     base_name= &default_key_cache_base;
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   key_cache= get_key_cache(base_name);
                             
   if (!key_cache)
@@ -2343,9 +2343,9 @@ bool sys_var_key_buffer_size::update(THD
       key_cache= (KEY_CACHE *) find_named(&key_caches, base_name->str,
 					      base_name->length, &list);
       key_cache->in_init= 1;
-      pthread_mutex_unlock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
       error= reassign_keycache_tables(thd, key_cache, dflt_key_cache);
-      pthread_mutex_lock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
       key_cache->in_init= 0;
     }
     /*
@@ -2360,18 +2360,18 @@ bool sys_var_key_buffer_size::update(THD
 
   /* If key cache didn't existed initialize it, else resize it */
   key_cache->in_init= 1;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
   if (!key_cache->key_cache_inited)
     error= (bool) (ha_init_key_cache("", key_cache));
   else
     error= (bool)(ha_resize_key_cache(key_cache));
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   key_cache->in_init= 0;  
 
 end:
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return error;
 }
 
@@ -2391,7 +2391,7 @@ bool sys_var_key_cache_long::update(THD 
   if (!base_name->length)
     base_name= &default_key_cache_base;
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   KEY_CACHE *key_cache= get_key_cache(base_name);
 
   if (!key_cache && !(key_cache= create_key_cache(base_name->str,
@@ -2418,15 +2418,15 @@ bool sys_var_key_cache_long::update(THD 
   */
   key_cache->in_init= 1;
 
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
   error= (bool) (ha_resize_key_cache(key_cache));
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   key_cache->in_init= 0;  
 
 end:
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return error;
 }
 
@@ -2434,7 +2434,7 @@ end:
 bool sys_var_log_state::update(THD *thd, set_var *var)
 {
   bool res;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   if (!var->save_result.ulong_value)
   {
     logger.deactivate_log_handler(thd, log_type);
@@ -2442,15 +2442,15 @@ bool sys_var_log_state::update(THD *thd,
   }
   else
     res= logger.activate_log_handler(thd, log_type);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return res;
 }
 
 void sys_var_log_state::set_default(THD *thd, enum_var_type type)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.deactivate_log_handler(thd, log_type);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 
@@ -2585,7 +2585,7 @@ bool update_sys_var_str_path(THD *thd, s
     goto err;
   }
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
 
   /*
@@ -2639,7 +2639,7 @@ bool update_sys_var_str_path(THD *thd, s
   }
 
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
 err:
   return result;
@@ -2735,26 +2735,26 @@ static void sys_default_slow_log_path(TH
 
 bool sys_var_log_output::update(THD *thd, set_var *var)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
   logger.init_slow_log(var->save_result.ulong_value);
   logger.init_general_log(var->save_result.ulong_value);
   *value= var->save_result.ulong_value;
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return 0;
 }
 
 
 void sys_var_log_output::set_default(THD *thd, enum_var_type type)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
   logger.init_slow_log(LOG_FILE);
   logger.init_general_log(LOG_FILE);
   *value= LOG_FILE;
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 
@@ -2787,13 +2787,13 @@ uchar *sys_var_log_output::value_ptr(THD
 */
 bool sys_var_log_backup_output::update(THD *thd, set_var *var)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
   logger.init_backup_history_log(var->save_result.ulong_value);
   logger.init_backup_progress_log(var->save_result.ulong_value);
   *value= var->save_result.ulong_value;
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return 0;
 }
 
@@ -2802,13 +2802,13 @@ bool sys_var_log_backup_output::update(T
 */
 void sys_var_log_backup_output::set_default(THD *thd, enum_var_type type)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
   logger.init_backup_history_log(LOG_TABLE);
   logger.init_backup_progress_log(LOG_TABLE);
   *value= LOG_TABLE;
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 /*
@@ -2935,13 +2935,13 @@ static bool sys_update_backupdir(THD *th
     goto err;
   }
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   logger.lock_exclusive();
   old_value= sys_var_backupdir.value;
   sys_var_backupdir.value= res;
   sys_var_backupdir.value_length= str_length;
   logger.unlock();
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
   if (my_access(sys_var_backupdir.value, (F_OK|W_OK)))
     goto err;
@@ -3148,9 +3148,9 @@ bool sys_var_thd_time_zone::update(THD *
   /* We are using Time_zone object found during check() phase. */
   if (var->type == OPT_GLOBAL)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.time_zone= var->save_result.time_zone;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.time_zone= var->save_result.time_zone;
@@ -3185,7 +3185,7 @@ uchar *sys_var_thd_time_zone::value_ptr(
 
 void sys_var_thd_time_zone::set_default(THD *thd, enum_var_type type)
 {
- pthread_mutex_lock(&LOCK_global_system_variables);
+ MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
  if (type == OPT_GLOBAL)
  {
    if (default_tz_name)
@@ -3202,7 +3202,7 @@ void sys_var_thd_time_zone::set_default(
  }
  else
    thd->variables.time_zone= global_system_variables.time_zone;
- pthread_mutex_unlock(&LOCK_global_system_variables);
+ MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 
@@ -3224,9 +3224,9 @@ bool sys_var_max_user_conn::check(THD *t
 bool sys_var_max_user_conn::update(THD *thd, set_var *var)
 {
   DBUG_ASSERT(var->type == OPT_GLOBAL);
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   max_user_connections= (uint)var->save_result.ulonglong_value;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return 0;
 }
 
@@ -3234,9 +3234,9 @@ bool sys_var_max_user_conn::update(THD *
 void sys_var_max_user_conn::set_default(THD *thd, enum_var_type type)
 {
   DBUG_ASSERT(type == OPT_GLOBAL);
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   max_user_connections= (ulong) option_limits->def_value;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 }
 
 
@@ -3334,9 +3334,9 @@ bool sys_var_microseconds::update(THD *t
   microseconds= (longlong) (num * 1000000.0 + 0.5);
   if (var->type == OPT_GLOBAL)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     (global_system_variables.*offset)= microseconds;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= microseconds;
@@ -3349,9 +3349,9 @@ void sys_var_microseconds::set_default(T
   longlong microseconds= (longlong) (option_limits->def_value * 1000000.0);
   if (type == OPT_GLOBAL)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.*offset= microseconds;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.*offset= microseconds;
@@ -4395,10 +4395,10 @@ KEY_CACHE *get_or_create_key_cache(const
 
   key_cache_name.str= (char *) name;
   key_cache_name.length= length;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   if (!(key_cache= get_key_cache(&key_cache_name)))
     key_cache= create_key_cache(name, length);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   return key_cache;
 }
 

=== modified file 'sql/set_var.h'
--- a/sql/set_var.h	2008-08-27 17:30:49 +0000
+++ b/sql/set_var.h	2008-10-10 20:34:55 +0000
@@ -131,10 +131,10 @@ private:
 class sys_var_global: public sys_var
 {
 protected:
-  pthread_mutex_t *guard;
+  mysql_mutex_t *guard;
 public:
   sys_var_global(const char *name_arg, sys_after_update_func after_update_arg,
-                 pthread_mutex_t *guard_arg)
+                 mysql_mutex_t *guard_arg)
     :sys_var(name_arg, after_update_arg), guard(guard_arg) {}
 };
 
@@ -150,7 +150,7 @@ public:
   ulong *value;
   sys_var_long_ptr_global(sys_var_chain *chain, const char *name_arg,
                           ulong *value_ptr_arg,
-                          pthread_mutex_t *guard_arg,
+                          mysql_mutex_t *guard_arg,
                           sys_after_update_func after_update_arg= NULL)
     :sys_var_global(name_arg, after_update_arg, guard_arg),
     value(value_ptr_arg)

=== modified file 'sql/si_objects.cc'
--- a/sql/si_objects.cc	2008-09-11 16:28:29 +0000
+++ b/sql/si_objects.cc	2008-10-10 20:34:55 +0000
@@ -57,9 +57,9 @@ int silent_exec(THD *thd, String *query)
   thd->query_length=  query->length();
 
   thd->set_time();
-  pthread_mutex_lock(&::LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&::LOCK_thread_count);
   thd->query_id= ::next_query_id();
-  pthread_mutex_unlock(&::LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&::LOCK_thread_count);
 
   /*
     @todo The following is a work around for online backup and the DDL blocker.
@@ -91,13 +91,13 @@ int silent_exec(THD *thd, String *query)
       next_packet++;
       length--;
     }
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thd->query_length= length;
     thd->query= next_packet;
     thd->query_id= next_query_id();
     thd->set_time(); /* Reset the query start time. */
     /* TODO: set thd->lex->sql_command to SQLCOM_END here */
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     mysql_parse(thd, next_packet, length, & found_semicolon);
   }
 
@@ -3852,7 +3852,7 @@ int Name_locker::get_name_locks(List<Obj
   {
     if (lock_table_names(m_thd, m_table_list))
       ret= 1;
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     for (ltable= m_table_list; ltable; ltable= ltable->next_local)
       tdc_remove_table(m_thd, TDC_RT_REMOVE_ALL, ltable->db,
                        ltable->table_name);
@@ -3873,7 +3873,7 @@ int Name_locker::release_name_locks()
   DBUG_ENTER("Name_locker::release_name_locks()");
   if (m_table_list)
   {
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     unlock_table_names(m_thd);
   }
   DBUG_RETURN(0);

=== modified file 'sql/slave.cc'
--- a/sql/slave.cc	2008-08-08 01:39:23 +0000
+++ b/sql/slave.cc	2008-10-10 20:34:55 +0000
@@ -139,8 +139,8 @@ static int get_master_version_and_clock(
 static Log_event* next_event(Relay_log_info* rli);
 static int queue_event(Master_info* mi,const char* buf,ulong event_len);
 static int terminate_slave_thread(THD *thd,
-                                  pthread_mutex_t* term_lock,
-                                  pthread_cond_t* term_cond,
+                                  mysql_mutex_t* term_lock,
+                                  mysql_cond_t* term_cond,
                                   volatile uint *slave_running,
                                   bool skip_lock);
 static bool check_io_slave_killed(THD *thd, Master_info *mi, const char *info);
@@ -189,8 +189,8 @@ void lock_slave_threads(Master_info* mi)
   DBUG_ENTER("lock_slave_threads");
 
   //TODO: see if we can do this without dual mutex
-  pthread_mutex_lock(&mi->run_lock);
-  pthread_mutex_lock(&mi->rli.run_lock);
+  MYSQL_MUTEX_LOCK(&mi->run_lock);
+  MYSQL_MUTEX_LOCK(&mi->rli.run_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -204,8 +204,8 @@ void unlock_slave_threads(Master_info* m
   DBUG_ENTER("unlock_slave_threads");
 
   //TODO: see if we can do this without dual mutex
-  pthread_mutex_unlock(&mi->rli.run_lock);
-  pthread_mutex_unlock(&mi->run_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->rli.run_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->run_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -221,7 +221,7 @@ int init_slave()
     accepted. However bootstrap may conflict with us if it does START SLAVE.
     So it's safer to take the lock.
   */
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   /*
     TODO: re-write this to interate through the list of files
     for multi-master
@@ -261,11 +261,11 @@ int init_slave()
       goto err;
     }
   }
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   DBUG_RETURN(0);
 
 err:
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   DBUG_RETURN(1);
 }
 
@@ -320,7 +320,7 @@ int terminate_slave_threads(Master_info*
   if (!mi->inited)
     DBUG_RETURN(0); /* successfully do nothing */
   int error,force_all = (thread_mask & SLAVE_FORCE_ALL);
-  pthread_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
+  mysql_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
 
   if ((thread_mask & (SLAVE_IO|SLAVE_FORCE_ALL)))
   {
@@ -379,8 +379,8 @@ int terminate_slave_threads(Master_info*
  */
 static int
 terminate_slave_thread(THD *thd,
-                       pthread_mutex_t* term_lock,
-                       pthread_cond_t* term_cond,
+                       mysql_mutex_t* term_lock,
+                       mysql_cond_t* term_cond,
                        volatile uint *slave_running,
                        bool skip_lock)
 {
@@ -389,14 +389,14 @@ terminate_slave_thread(THD *thd,
   DBUG_ENTER("terminate_slave_thread");
 
   if (!skip_lock)
-    pthread_mutex_lock(term_lock);
+    MYSQL_MUTEX_LOCK(term_lock);
 
-  safe_mutex_assert_owner(term_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(term_lock);
 
   if (!*slave_running)
   {
     if (!skip_lock)
-      pthread_mutex_unlock(term_lock);
+      MYSQL_MUTEX_UNLOCK(term_lock);
     DBUG_RETURN(ER_SLAVE_NOT_RUNNING);
   }
   DBUG_ASSERT(thd != 0);
@@ -411,7 +411,7 @@ terminate_slave_thread(THD *thd,
   {
     DBUG_PRINT("loop", ("killing slave thread"));
 
-    pthread_mutex_lock(&thd->LOCK_delete);
+    MYSQL_MUTEX_LOCK(&thd->LOCK_delete);
 #ifndef DONT_USE_THR_ALARM
     /*
       Error codes from pthread_kill are:
@@ -422,7 +422,7 @@ terminate_slave_thread(THD *thd,
     DBUG_ASSERT(err != EINVAL);
 #endif
     thd->awake(THD::NOT_KILLED);
-    pthread_mutex_unlock(&thd->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&thd->LOCK_delete);
 
     /*
       There is a small chance that slave thread might miss the first
@@ -430,21 +430,21 @@ terminate_slave_thread(THD *thd,
     */
     struct timespec abstime;
     set_timespec(abstime,2);
-    error= pthread_cond_timedwait(term_cond, term_lock, &abstime);
+    error= MYSQL_COND_TIMEDWAIT(term_cond, term_lock, &abstime);
     DBUG_ASSERT(error == ETIMEDOUT || error == 0);
   }
 
   DBUG_ASSERT(*slave_running == 0);
 
   if (!skip_lock)
-    pthread_mutex_unlock(term_lock);
+    MYSQL_MUTEX_UNLOCK(term_lock);
   DBUG_RETURN(0);
 }
 
 
-int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
-                       pthread_mutex_t *cond_lock,
-                       pthread_cond_t *start_cond,
+int start_slave_thread(pthread_handler h_func, mysql_mutex_t *start_lock,
+                       mysql_mutex_t *cond_lock,
+                       mysql_cond_t *start_cond,
                        volatile uint *slave_running,
                        volatile ulong *slave_run_id,
                        Master_info* mi,
@@ -457,13 +457,13 @@ int start_slave_thread(pthread_handler h
   DBUG_ASSERT(mi->inited);
 
   if (start_lock)
-    pthread_mutex_lock(start_lock);
+    MYSQL_MUTEX_LOCK(start_lock);
   if (!server_id)
   {
     if (start_cond)
-      pthread_cond_broadcast(start_cond);
+      MYSQL_COND_BROADCAST(start_cond);
     if (start_lock)
-      pthread_mutex_unlock(start_lock);
+      MYSQL_MUTEX_UNLOCK(start_lock);
     sql_print_error("Server id not set, will not start slave");
     DBUG_RETURN(ER_BAD_SLAVE);
   }
@@ -471,9 +471,9 @@ int start_slave_thread(pthread_handler h
   if (*slave_running)
   {
     if (start_cond)
-      pthread_cond_broadcast(start_cond);
+      MYSQL_COND_BROADCAST(start_cond);
     if (start_lock)
-      pthread_mutex_unlock(start_lock);
+      MYSQL_MUTEX_UNLOCK(start_lock);
     DBUG_RETURN(ER_SLAVE_MUST_STOP);
   }
   start_id= *slave_run_id;
@@ -483,7 +483,7 @@ int start_slave_thread(pthread_handler h
   if (pthread_create(&th, &connection_attrib, h_func, (void*)mi))
   {
     if (start_lock)
-      pthread_mutex_unlock(start_lock);
+      MYSQL_MUTEX_UNLOCK(start_lock);
     DBUG_RETURN(ER_SLAVE_THREAD);
   }
   if (start_cond && cond_lock) // caller has cond_lock
@@ -494,15 +494,15 @@ int start_slave_thread(pthread_handler h
       DBUG_PRINT("sleep",("Waiting for slave thread to start"));
       const char* old_msg = thd->enter_cond(start_cond,cond_lock,
                                             "Waiting for slave thread to start");
-      pthread_cond_wait(start_cond,cond_lock);
+      MYSQL_COND_WAIT(start_cond,cond_lock);
       thd->exit_cond(old_msg);
-      pthread_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
+      MYSQL_MUTEX_LOCK(cond_lock); // re-acquire it as exit_cond() released
       if (thd->killed)
         DBUG_RETURN(thd->killed_errno());
     }
   }
   if (start_lock)
-    pthread_mutex_unlock(start_lock);
+    MYSQL_MUTEX_UNLOCK(start_lock);
   DBUG_RETURN(0);
 }
 
@@ -520,8 +520,8 @@ int start_slave_threads(bool need_slave_
                         Master_info* mi, const char* master_info_fname,
                         const char* slave_info_fname, int thread_mask)
 {
-  pthread_mutex_t *lock_io=0,*lock_sql=0,*lock_cond_io=0,*lock_cond_sql=0;
-  pthread_cond_t* cond_io=0,*cond_sql=0;
+  mysql_mutex_t *lock_io=0,*lock_sql=0,*lock_cond_io=0,*lock_cond_sql=0;
+  mysql_cond_t* cond_io=0,*cond_sql=0;
   int error=0;
   DBUG_ENTER("start_slave_threads");
 
@@ -585,7 +585,7 @@ void end_slave()
     will make us wait until slave threads have started, and START SLAVE
     returns, then we terminate them here.
   */
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   if (active_mi)
   {
     /*
@@ -598,7 +598,7 @@ void end_slave()
     delete active_mi;
     active_mi= 0;
   }
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   DBUG_VOID_RETURN;
 }
 
@@ -1054,7 +1054,7 @@ static bool wait_for_relay_log_space(Rel
   THD* thd = mi->io_thd;
   DBUG_ENTER("wait_for_relay_log_space");
 
-  pthread_mutex_lock(&rli->log_space_lock);
+  MYSQL_MUTEX_LOCK(&rli->log_space_lock);
   save_proc_info= thd->enter_cond(&rli->log_space_cond,
                                   &rli->log_space_lock,
                                   "\
@@ -1062,7 +1062,7 @@ Waiting for the slave SQL thread to free
   while (rli->log_space_limit < rli->log_space_total &&
          !(slave_killed=io_slave_killed(thd,mi)) &&
          !rli->ignore_log_space_limit)
-    pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
+    MYSQL_COND_WAIT(&rli->log_space_cond, &rli->log_space_lock);
   thd->exit_cond(save_proc_info);
   DBUG_RETURN(slave_killed);
 }
@@ -1084,11 +1084,11 @@ Waiting for the slave SQL thread to free
 static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
 {
   Relay_log_info *rli= &mi->rli;
-  pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
+  mysql_mutex_t *log_lock= rli->relay_log.get_log_lock();
   DBUG_ENTER("write_ignored_events_info_to_relay_log");
 
   DBUG_ASSERT(thd == mi->io_thd);
-  pthread_mutex_lock(log_lock);
+  MYSQL_MUTEX_LOCK(log_lock);
   if (rli->ign_master_log_name_end[0])
   {
     DBUG_PRINT("info",("writing a Rotate event to track down ignored events"));
@@ -1097,7 +1097,7 @@ static void write_ignored_events_info_to
                                                Rotate_log_event::DUP_NAME);
     rli->ign_master_log_name_end[0]= 0;
     /* can unlock before writing as slave SQL thd will soon see our Rotate */
-    pthread_mutex_unlock(log_lock);
+    MYSQL_MUTEX_UNLOCK(log_lock);
     if (likely((bool)ev))
     {
       ev->server_id= 0; // don't be ignored by slave SQL thread
@@ -1119,7 +1119,7 @@ static void write_ignored_events_info_to
                  " SHOW SLAVE STATUS may be inaccurate");
   }
   else
-    pthread_mutex_unlock(log_lock);
+    MYSQL_MUTEX_UNLOCK(log_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -1255,12 +1255,12 @@ bool show_master_info(THD* thd, Master_i
       slave_running can be accessed without run_lock but not other
       non-volotile members like mi->io_thd, which is guarded by the mutex.
     */
-    pthread_mutex_lock(&mi->run_lock);
+    MYSQL_MUTEX_LOCK(&mi->run_lock);
     protocol->store(mi->io_thd ? mi->io_thd->proc_info : "", &my_charset_bin);
-    pthread_mutex_unlock(&mi->run_lock);
+    MYSQL_MUTEX_UNLOCK(&mi->run_lock);
 
-    pthread_mutex_lock(&mi->data_lock);
-    pthread_mutex_lock(&mi->rli.data_lock);
+    MYSQL_MUTEX_LOCK(&mi->data_lock);
+    MYSQL_MUTEX_LOCK(&mi->rli.data_lock);
     protocol->store(mi->host, &my_charset_bin);
     protocol->store(mi->user, &my_charset_bin);
     protocol->store((uint32) mi->port);
@@ -1360,8 +1360,8 @@ bool show_master_info(THD* thd, Master_i
     // Last_SQL_Error
     protocol->store(mi->rli.last_error().message, &my_charset_bin);
 
-    pthread_mutex_unlock(&mi->rli.data_lock);
-    pthread_mutex_unlock(&mi->data_lock);
+    MYSQL_MUTEX_UNLOCK(&mi->rli.data_lock);
+    MYSQL_MUTEX_UNLOCK(&mi->data_lock);
 
     if (my_net_write(&thd->net, (uchar*) thd->packet.ptr(), packet->length()))
       DBUG_RETURN(TRUE);
@@ -1440,9 +1440,9 @@ static int init_slave_thread(THD* thd, S
   thd->enable_slow_log= opt_log_slow_slave_statements;
   set_slave_thread_options(thd);
   thd->client_capabilities = CLIENT_LOCAL_FILES;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   DBUG_EXECUTE_IF("simulate_io_slave_error_on_init",
                   simulate_error|= (1 << SLAVE_THD_IO););
@@ -1756,7 +1756,7 @@ int apply_event_and_update_pos(Log_event
     int reason= ev->shall_skip(rli);
     if (reason == Log_event::EVENT_SKIP_COUNT)
       --rli->slave_skip_counter;
-    pthread_mutex_unlock(&rli->data_lock);
+    MYSQL_MUTEX_UNLOCK(&rli->data_lock);
     if (reason == Log_event::EVENT_SKIP_NOT)
       exec_res= ev->apply_event(rli);
 #ifndef DBUG_OFF
@@ -1864,7 +1864,7 @@ static int exec_relay_log_event(THD* thd
      event execution. But we will release it in places where we will
      wait for something for example inside of next_event().
    */
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
 
   Log_event * ev = next_event(rli);
 
@@ -1872,7 +1872,7 @@ static int exec_relay_log_event(THD* thd
 
   if (sql_slave_killed(thd,rli))
   {
-    pthread_mutex_unlock(&rli->data_lock);
+    MYSQL_MUTEX_UNLOCK(&rli->data_lock);
     delete ev;
     DBUG_RETURN(1);
   }
@@ -1897,7 +1897,7 @@ static int exec_relay_log_event(THD* thd
         error in query execution to be printed.
       */
       rli->abort_slave= 1;
-      pthread_mutex_unlock(&rli->data_lock);
+      MYSQL_MUTEX_UNLOCK(&rli->data_lock);
       delete ev;
       DBUG_RETURN(1);
     }
@@ -1958,10 +1958,10 @@ static int exec_relay_log_event(THD* thd
             /* chance for concurrent connection to get more locks */
             safe_sleep(thd, min(rli->trans_retries, MAX_SLAVE_RETRY_PAUSE),
                        (CHECK_KILLED_FUNC)sql_slave_killed, (void*)rli);
-            pthread_mutex_lock(&rli->data_lock); // because of SHOW STATUS
+            MYSQL_MUTEX_LOCK(&rli->data_lock); // because of SHOW STATUS
             rli->trans_retries++;
             rli->retried_trans++;
-            pthread_mutex_unlock(&rli->data_lock);
+            MYSQL_MUTEX_UNLOCK(&rli->data_lock);
             DBUG_PRINT("info", ("Slave retries transaction "
                                 "rli->trans_retries: %lu", rli->trans_retries));
           }
@@ -1989,7 +1989,7 @@ static int exec_relay_log_event(THD* thd
     }
     DBUG_RETURN(exec_res);
   }
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   rli->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_READ_FAILURE,
               ER(ER_SLAVE_RELAY_LOG_READ_FAILURE), "\
 Could not parse relay log event entry. The possible reasons are: the master's \
@@ -2102,7 +2102,7 @@ pthread_handler_t handle_slave_io(void *
   mysql= NULL ;
   retry_count= 0;
 
-  pthread_mutex_lock(&mi->run_lock);
+  MYSQL_MUTEX_LOCK(&mi->run_lock);
   /* Inform waiting threads that slave has started */
   mi->slave_run_id++;
 
@@ -2118,18 +2118,18 @@ pthread_handler_t handle_slave_io(void *
   thd->thread_stack= (char*) &thd; // remember where our stack is
   if (init_slave_thread(thd, SLAVE_THD_IO))
   {
-    pthread_cond_broadcast(&mi->start_cond);
-    pthread_mutex_unlock(&mi->run_lock);
+    MYSQL_COND_BROADCAST(&mi->start_cond);
+    MYSQL_MUTEX_UNLOCK(&mi->run_lock);
     sql_print_error("Failed during slave I/O thread initialization");
     goto err;
   }
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   mi->slave_running = 1;
   mi->abort_slave = 0;
-  pthread_mutex_unlock(&mi->run_lock);
-  pthread_cond_broadcast(&mi->start_cond);
+  MYSQL_MUTEX_UNLOCK(&mi->run_lock);
+  MYSQL_COND_BROADCAST(&mi->start_cond);
 
   DBUG_PRINT("master_info",("log_file_name: '%s'  position: %s",
                             mi->master_log_name,
@@ -2333,10 +2333,10 @@ err:
   // print the current replication position
   sql_print_information("Slave I/O thread exiting, read up to log '%s', position %s",
                   IO_RPL_LOG_NAME, llstr(mi->master_log_pos,llbuff));
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query = thd->db = 0; // extra safety
   thd->query_length= thd->db_length= 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (mysql)
   {
     /*
@@ -2355,7 +2355,7 @@ err:
   }
   write_ignored_events_info_to_relay_log(thd, mi);
   thd_proc_info(thd, "Waiting for slave mutex on exit");
-  pthread_mutex_lock(&mi->run_lock);
+  MYSQL_MUTEX_LOCK(&mi->run_lock);
 
   /* Forget the relay log's format */
   delete mi->rli.relay_log.description_event_for_queue;
@@ -2365,10 +2365,10 @@ err:
   DBUG_ASSERT(thd->net.buff != 0);
   net_end(&thd->net); // destructor will not free it, because net.vio is 0
   close_thread_tables(thd);
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   THD_CHECK_SENTRY(thd);
   delete thd;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   mi->abort_slave= 0;
   mi->slave_running= 0;
   mi->io_thd= 0;
@@ -2377,8 +2377,8 @@ err:
     is important. Otherwise a killer_thread can execute between the calls and
     delete the mi structure leading to a crash! (see BUG#25306 for details)
    */ 
-  pthread_cond_broadcast(&mi->stop_cond);       // tell the world we are done
-  pthread_mutex_unlock(&mi->run_lock);
+  MYSQL_COND_BROADCAST(&mi->stop_cond);       // tell the world we are done
+  MYSQL_MUTEX_UNLOCK(&mi->run_lock);
   my_thread_end();
   pthread_exit(0);
   DBUG_RETURN(0);                               // Can't return anything here
@@ -2400,7 +2400,7 @@ pthread_handler_t handle_slave_sql(void 
   DBUG_ENTER("handle_slave_sql");
 
   DBUG_ASSERT(rli->inited);
-  pthread_mutex_lock(&rli->run_lock);
+  MYSQL_MUTEX_LOCK(&rli->run_lock);
   DBUG_ASSERT(!rli->slave_running);
   errmsg= 0;
 #ifndef DBUG_OFF
@@ -2422,16 +2422,16 @@ pthread_handler_t handle_slave_sql(void 
       TODO: this is currently broken - slave start and change master
       will be stuck if we fail here
     */
-    pthread_cond_broadcast(&rli->start_cond);
-    pthread_mutex_unlock(&rli->run_lock);
+    MYSQL_COND_BROADCAST(&rli->start_cond);
+    MYSQL_MUTEX_UNLOCK(&rli->run_lock);
     sql_print_error("Failed during slave thread initialization");
     goto err;
   }
   thd->init_for_queries();
   thd->temporary_tables = rli->save_temporary_tables; // restore temp tables
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   /*
     We are going to set slave_running to 1. Assuming slave I/O thread is
     alive and connected, this is going to make Seconds_Behind_Master be 0
@@ -2441,8 +2441,8 @@ pthread_handler_t handle_slave_sql(void 
     Seconds_Behind_Master grows. No big deal.
   */
   rli->abort_slave = 0;
-  pthread_mutex_unlock(&rli->run_lock);
-  pthread_cond_broadcast(&rli->start_cond);
+  MYSQL_MUTEX_UNLOCK(&rli->run_lock);
+  MYSQL_COND_BROADCAST(&rli->start_cond);
 
   /*
     Reset errors for a clean start (otherwise, if the master is idle, the SQL
@@ -2457,9 +2457,9 @@ pthread_handler_t handle_slave_sql(void 
   rli->clear_error();
 
   //tell the I/O thread to take relay_log_space_limit into account from now on
-  pthread_mutex_lock(&rli->log_space_lock);
+  MYSQL_MUTEX_LOCK(&rli->log_space_lock);
   rli->ignore_log_space_limit= 0;
-  pthread_mutex_unlock(&rli->log_space_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->log_space_lock);
   rli->trans_retries= 0; // start from "no error"
   DBUG_PRINT("info", ("rli->trans_retries: %lu", rli->trans_retries));
 
@@ -2525,17 +2525,17 @@ Slave SQL thread aborted. Can't execute 
     First check until condition - probably there is nothing to execute. We
     do not want to wait for next event in this case.
   */
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
   if (rli->until_condition != Relay_log_info::UNTIL_NONE &&
       rli->is_until_satisfied(rli->group_master_log_pos))
   {
     char buf[22];
     sql_print_information("Slave SQL thread stopped because it reached its"
                           " UNTIL position %s", llstr(rli->until_pos(), buf));
-    pthread_mutex_unlock(&rli->data_lock);
+    MYSQL_MUTEX_UNLOCK(&rli->data_lock);
     goto err;
   }
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
 
   /* Read queries from the IO/THREAD until this thread is killed */
 
@@ -2619,7 +2619,7 @@ the slave SQL thread with \"SLAVE START\
     must "proactively" clear playgrounds:
   */
   rli->cleanup_context(thd, 1);
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   /*
     Some extra safety, which should not been needed (normally, event deletion
     should already have done these assignments (each event which sets these
@@ -2627,11 +2627,11 @@ the slave SQL thread with \"SLAVE START\
   */
   thd->query= thd->db= thd->catalog= 0;
   thd->query_length= thd->db_length= 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   thd_proc_info(thd, "Waiting for slave mutex on exit");
-  pthread_mutex_lock(&rli->run_lock);
+  MYSQL_MUTEX_LOCK(&rli->run_lock);
   /* We need data_lock, at least to wake up any waiting master_pos_wait() */
-  pthread_mutex_lock(&rli->data_lock);
+  MYSQL_MUTEX_LOCK(&rli->data_lock);
   DBUG_ASSERT(rli->slave_running == 1); // tracking buffer overrun
   /* When master_pos_wait() wakes up it will check this and terminate */
   rli->slave_running= 0;
@@ -2639,9 +2639,9 @@ the slave SQL thread with \"SLAVE START\
   delete rli->relay_log.description_event_for_exec;
   rli->relay_log.description_event_for_exec= 0;
   /* Wake up master_pos_wait() */
-  pthread_mutex_unlock(&rli->data_lock);
+  MYSQL_MUTEX_UNLOCK(&rli->data_lock);
   DBUG_PRINT("info",("Signaling possibly waiting master_pos_wait() functions"));
-  pthread_cond_broadcast(&rli->data_cond);
+  MYSQL_COND_BROADCAST(&rli->data_cond);
   rli->ignore_log_space_limit= 0; /* don't need any lock */
   /* we die so won't remember charset - re-update them on next thread start */
   rli->cached_charset_invalidate();
@@ -2657,17 +2657,17 @@ the slave SQL thread with \"SLAVE START\
   DBUG_ASSERT(rli->sql_thd == thd);
   THD_CHECK_SENTRY(thd);
   rli->sql_thd= 0;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   THD_CHECK_SENTRY(thd);
   delete thd;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
  /*
   Note: the order of the broadcast and unlock calls below (first broadcast, then unlock)
   is important. Otherwise a killer_thread can execute between the calls and
   delete the mi structure leading to a crash! (see BUG#25306 for details)
  */ 
-  pthread_cond_broadcast(&rli->stop_cond);
-  pthread_mutex_unlock(&rli->run_lock);  // tell the world we are done
+  MYSQL_COND_BROADCAST(&rli->stop_cond);
+  MYSQL_MUTEX_UNLOCK(&rli->run_lock);  // tell the world we are done
   
   my_thread_end();
   pthread_exit(0);
@@ -2809,7 +2809,7 @@ err:
 static int process_io_rotate(Master_info *mi, Rotate_log_event *rev)
 {
   DBUG_ENTER("process_io_rotate");
-  safe_mutex_assert_owner(&mi->data_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&mi->data_lock);
 
   if (unlikely(!rev->is_valid()))
     DBUG_RETURN(1);
@@ -2905,7 +2905,7 @@ static int queue_binlog_ver_1_event(Mast
     DBUG_RETURN(1);
   }
 
-  pthread_mutex_lock(&mi->data_lock);
+  MYSQL_MUTEX_LOCK(&mi->data_lock);
   ev->log_pos= mi->master_log_pos; /* 3.23 events don't contain log_pos */
   switch (ev->get_type_code()) {
   case STOP_EVENT:
@@ -2916,7 +2916,7 @@ static int queue_binlog_ver_1_event(Mast
     if (unlikely(process_io_rotate(mi,(Rotate_log_event*)ev)))
     {
       delete ev;
-      pthread_mutex_unlock(&mi->data_lock);
+      MYSQL_MUTEX_UNLOCK(&mi->data_lock);
       DBUG_RETURN(1);
     }
     inc_pos= 0;
@@ -2937,7 +2937,7 @@ static int queue_binlog_ver_1_event(Mast
     delete ev;
     mi->master_log_pos += inc_pos;
     DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
-    pthread_mutex_unlock(&mi->data_lock);
+    MYSQL_MUTEX_UNLOCK(&mi->data_lock);
     my_free((char*)tmp_buf, MYF(0));
     DBUG_RETURN(error);
   }
@@ -2956,7 +2956,7 @@ static int queue_binlog_ver_1_event(Mast
     if (unlikely(rli->relay_log.append(ev)))
     {
       delete ev;
-      pthread_mutex_unlock(&mi->data_lock);
+      MYSQL_MUTEX_UNLOCK(&mi->data_lock);
       DBUG_RETURN(1);
     }
     rli->relay_log.harvest_bytes_written(&rli->log_space_total);
@@ -2964,7 +2964,7 @@ static int queue_binlog_ver_1_event(Mast
   delete ev;
   mi->master_log_pos+= inc_pos;
   DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_RETURN(0);
 }
 
@@ -2992,7 +2992,7 @@ static int queue_binlog_ver_3_event(Mast
     my_free((char*) tmp_buf, MYF(MY_ALLOW_ZERO_PTR));
     DBUG_RETURN(1);
   }
-  pthread_mutex_lock(&mi->data_lock);
+  MYSQL_MUTEX_LOCK(&mi->data_lock);
   switch (ev->get_type_code()) {
   case STOP_EVENT:
     goto err;
@@ -3000,7 +3000,7 @@ static int queue_binlog_ver_3_event(Mast
     if (unlikely(process_io_rotate(mi,(Rotate_log_event*)ev)))
     {
       delete ev;
-      pthread_mutex_unlock(&mi->data_lock);
+      MYSQL_MUTEX_UNLOCK(&mi->data_lock);
       DBUG_RETURN(1);
     }
     inc_pos= 0;
@@ -3012,7 +3012,7 @@ static int queue_binlog_ver_3_event(Mast
   if (unlikely(rli->relay_log.append(ev)))
   {
     delete ev;
-    pthread_mutex_unlock(&mi->data_lock);
+    MYSQL_MUTEX_UNLOCK(&mi->data_lock);
     DBUG_RETURN(1);
   }
   rli->relay_log.harvest_bytes_written(&rli->log_space_total);
@@ -3020,7 +3020,7 @@ static int queue_binlog_ver_3_event(Mast
   mi->master_log_pos+= inc_pos;
 err:
   DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_RETURN(0);
 }
 
@@ -3070,7 +3070,7 @@ static int queue_event(Master_info* mi,c
   String error_msg;
   ulong inc_pos;
   Relay_log_info *rli= &mi->rli;
-  pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
+  mysql_mutex_t *log_lock= rli->relay_log.get_log_lock();
   DBUG_ENTER("queue_event");
 
   LINT_INIT(inc_pos);
@@ -3080,7 +3080,7 @@ static int queue_event(Master_info* mi,c
     DBUG_RETURN(queue_old_event(mi,buf,event_len));
 
   LINT_INIT(inc_pos);
-  pthread_mutex_lock(&mi->data_lock);
+  MYSQL_MUTEX_LOCK(&mi->data_lock);
 
   switch (buf[EVENT_TYPE_OFFSET]) {
   case STOP_EVENT:
@@ -3216,7 +3216,7 @@ static int queue_event(Master_info* mi,c
      direct master (an unsupported, useless setup!).
   */
 
-  pthread_mutex_lock(log_lock);
+  MYSQL_MUTEX_LOCK(log_lock);
 
   if ((uint4korr(buf + SERVER_ID_OFFSET) == ::server_id) &&
       !mi->rli.replicate_same_server_id)
@@ -3263,12 +3263,12 @@ static int queue_event(Master_info* mi,c
     }
     rli->ign_master_log_name_end[0]= 0; // last event is not ignored
   }
-  pthread_mutex_unlock(log_lock);
+  MYSQL_MUTEX_UNLOCK(log_lock);
 
 skip_relay_logging:
   
 err:
-  pthread_mutex_unlock(&mi->data_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->data_lock);
   DBUG_PRINT("info", ("error: %d", error));
   if (error)
     mi->report(ERROR_LEVEL, error, ER(error), 
@@ -3542,7 +3542,7 @@ static Log_event* next_event(Relay_log_i
 {
   Log_event* ev;
   IO_CACHE* cur_log = rli->cur_log;
-  pthread_mutex_t *log_lock = rli->relay_log.get_log_lock();
+  mysql_mutex_t *log_lock = rli->relay_log.get_log_lock();
   const char* errmsg=0;
   THD* thd = rli->sql_thd;
   DBUG_ENTER("next_event");
@@ -3559,9 +3559,9 @@ static Log_event* next_event(Relay_log_i
     so we assume calling function acquired this mutex for us and we will
     hold it for the most of the loop below However, we will release it
     whenever it is worth the hassle,  and in the cases when we go into a
-    pthread_cond_wait() with the non-data_lock mutex
+    MYSQL_COND_WAIT() with the non-data_lock mutex
   */
-  safe_mutex_assert_owner(&rli->data_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&rli->data_lock);
 
   while (!sql_slave_killed(thd,rli))
   {
@@ -3580,7 +3580,7 @@ static Log_event* next_event(Relay_log_i
     if ((hot_log = (cur_log != &rli->cache_buf)))
     {
       DBUG_ASSERT(rli->cur_log_fd == -1); // foreign descriptor
-      pthread_mutex_lock(log_lock);
+      MYSQL_MUTEX_LOCK(log_lock);
 
       /*
         Reading xxx_file_id is safe because the log will only
@@ -3590,7 +3590,7 @@ static Log_event* next_event(Relay_log_i
       {
         // The master has switched to a new log file; Reopen the old log file
         cur_log=reopen_relay_log(rli, &errmsg);
-        pthread_mutex_unlock(log_lock);
+        MYSQL_MUTEX_UNLOCK(log_lock);
         if (!cur_log)                           // No more log files
           goto err;
         hot_log=0;                              // Using old binary log
@@ -3637,7 +3637,7 @@ static Log_event* next_event(Relay_log_i
       */
       rli->future_event_relay_log_pos= my_b_tell(cur_log);
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+        MYSQL_MUTEX_UNLOCK(log_lock);
       DBUG_RETURN(ev);
     }
     DBUG_ASSERT(thd==rli->sql_thd);
@@ -3647,7 +3647,7 @@ static Log_event* next_event(Relay_log_i
     {
       errmsg = "slave SQL thread aborted because of I/O error";
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+        MYSQL_MUTEX_UNLOCK(log_lock);
       goto err;
     }
     if (!cur_log->error) /* EOF */
@@ -3694,7 +3694,7 @@ static Log_event* next_event(Relay_log_i
                                    0, rli->ign_master_log_pos_end,
                                    Rotate_log_event::DUP_NAME);
           rli->ign_master_log_name_end[0]= 0;
-          pthread_mutex_unlock(log_lock);
+          MYSQL_MUTEX_UNLOCK(log_lock);
           if (unlikely(!ev))
           {
             errmsg= "Slave SQL thread failed to create a Rotate event "
@@ -3709,7 +3709,7 @@ static Log_event* next_event(Relay_log_i
           We can, and should release data_lock while we are waiting for
           update. If we do not, show slave status will block
         */
-        pthread_mutex_unlock(&rli->data_lock);
+        MYSQL_MUTEX_UNLOCK(&rli->data_lock);
 
         /*
           Possible deadlock :
@@ -3735,7 +3735,7 @@ static Log_event* next_event(Relay_log_i
           be stopped, and the SQL thread sets ignore_log_space_limit to 0 when
           it stops.
         */
-        pthread_mutex_lock(&rli->log_space_lock);
+        MYSQL_MUTEX_LOCK(&rli->log_space_lock);
         // prevent the I/O thread from blocking next times
         rli->ignore_log_space_limit= 1;
         /*
@@ -3744,12 +3744,12 @@ static Log_event* next_event(Relay_log_i
           ~Relay_log_info(), i.e. when rli is destroyed, and rli will
           not be destroyed before we exit the present function.
         */
-        pthread_mutex_unlock(&rli->log_space_lock);
-        pthread_cond_broadcast(&rli->log_space_cond);
+        MYSQL_MUTEX_UNLOCK(&rli->log_space_lock);
+        MYSQL_COND_BROADCAST(&rli->log_space_cond);
         // Note that wait_for_update_relay_log unlocks lock_log !
         rli->relay_log.wait_for_update_relay_log(rli->sql_thd);
         // re-acquire data lock since we released it earlier
-        pthread_mutex_lock(&rli->data_lock);
+        MYSQL_MUTEX_LOCK(&rli->data_lock);
         rli->last_master_timestamp= save_timestamp;
         continue;
       }
@@ -3817,7 +3817,7 @@ static Log_event* next_event(Relay_log_i
 
       DBUG_PRINT("info",("hot_log: %d",hot_log));
       if (!hot_log) /* if hot_log, we already have this mutex */
-        pthread_mutex_lock(log_lock);
+        MYSQL_MUTEX_LOCK(log_lock);
       if (rli->relay_log.is_active(rli->linfo.log_file_name))
       {
 #ifdef EXTRA_DEBUG
@@ -3838,13 +3838,13 @@ static Log_event* next_event(Relay_log_i
         */
         if (check_binlog_magic(cur_log,&errmsg))
         {
-          if (!hot_log) pthread_mutex_unlock(log_lock);
+          if (!hot_log) MYSQL_MUTEX_UNLOCK(log_lock);
           goto err;
         }
-        if (!hot_log) pthread_mutex_unlock(log_lock);
+        if (!hot_log) MYSQL_MUTEX_UNLOCK(log_lock);
         continue;
       }
-      if (!hot_log) pthread_mutex_unlock(log_lock);
+      if (!hot_log) MYSQL_MUTEX_UNLOCK(log_lock);
       /*
         if we get here, the log was not hot, so we will have to open it
         ourselves. We are sure that the log is still not hot now (a log can get
@@ -3867,7 +3867,7 @@ static Log_event* next_event(Relay_log_i
         TODO: come up with something better to handle this error
       */
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+        MYSQL_MUTEX_UNLOCK(log_lock);
       sql_print_error("Slave SQL thread: I/O error reading \
 event(errno: %d  cur_log->error: %d)",
                       my_errno,cur_log->error);
@@ -3905,7 +3905,7 @@ void rotate_relay_log(Master_info* mi)
   Relay_log_info* rli= &mi->rli;
 
   /* We don't lock rli->run_lock. This would lead to deadlocks. */
-  pthread_mutex_lock(&mi->run_lock);
+  MYSQL_MUTEX_LOCK(&mi->run_lock);
 
   /*
      We need to test inited because otherwise, new_file() will attempt to lock
@@ -3935,7 +3935,7 @@ void rotate_relay_log(Master_info* mi)
   */
   rli->relay_log.harvest_bytes_written(&rli->log_space_total);
 end:
-  pthread_mutex_unlock(&mi->run_lock);
+  MYSQL_MUTEX_UNLOCK(&mi->run_lock);
   DBUG_VOID_RETURN;
 }
 

=== modified file 'sql/slave.h'
--- a/sql/slave.h	2008-07-21 03:55:09 +0000
+++ b/sql/slave.h	2008-10-10 20:34:55 +0000
@@ -155,11 +155,11 @@ int start_slave_threads(bool need_slave_
   cond_lock is usually same as start_lock. It is needed for the case when
   start_lock is 0 which happens if start_slave_thread() is called already
   inside the start_lock section, but at the same time we want a
-  pthread_cond_wait() on start_cond,start_lock
+  MYSQL_COND_WAIT() on start_cond,start_lock
 */
-int start_slave_thread(pthread_handler h_func, pthread_mutex_t* start_lock,
-		       pthread_mutex_t *cond_lock,
-		       pthread_cond_t* start_cond,
+int start_slave_thread(pthread_handler h_func, mysql_mutex_t* start_lock,
+		       mysql_mutex_t *cond_lock,
+		       mysql_cond_t* start_cond,
 		       volatile uint *slave_running,
 		       volatile ulong *slave_run_id,
 		       Master_info* mi,

=== modified file 'sql/sp_cache.cc'
--- a/sql/sp_cache.cc	2008-07-03 19:41:22 +0000
+++ b/sql/sp_cache.cc	2008-10-10 20:34:55 +0000
@@ -20,7 +20,10 @@
 #include "sp_cache.h"
 #include "sp_head.h"
 
-static pthread_mutex_t Cversion_lock;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_Cversion_lock;
+#endif
+static mysql_mutex_t Cversion_lock;
 static ulong volatile Cversion= 0;
 
 
@@ -79,7 +82,7 @@ private:
 
 void sp_cache_init()
 {
-  pthread_mutex_init(&Cversion_lock, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&Cversion_lock, key_Cversion_lock, MY_MUTEX_INIT_FAST);
 }
 
 

=== modified file 'sql/sp_head.cc'
--- a/sql/sp_head.cc	2008-09-04 18:30:34 +0000
+++ b/sql/sp_head.cc	2008-10-10 20:34:55 +0000
@@ -1734,9 +1734,9 @@ sp_head::execute_function(THD *thd, Item
       as one select and not resetting THD::user_var_events before
       each invocation.
     */
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     q= global_query_id;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
     mysql_bin_log.start_union_events(thd, q + 1);
     binlog_save_options= thd->options;
     thd->options&= ~OPTION_BIN_LOG;
@@ -2698,9 +2698,9 @@ sp_lex_keeper::reset_lex_and_exec_core(T
   */
   thd->lex= m_lex;
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query_id= next_query_id();
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if (thd->locked_tables_mode <= LTM_LOCK_TABLES)
   {

=== modified file 'sql/sql_acl.cc'
--- a/sql/sql_acl.cc	2008-08-12 16:46:23 +0000
+++ b/sql/sql_acl.cc	2008-10-10 20:34:55 +0000
@@ -227,9 +227,9 @@ static void restrict_update_of_old_passw
 {
   if (var_type == OPT_GLOBAL)
   {
-    pthread_mutex_lock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
     global_system_variables.old_passwords= 1;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
     thd->variables.old_passwords= 1;
@@ -389,23 +389,23 @@ static my_bool acl_load(THD *thd, TABLE_
   DBUG_PRINT("info",("user table fields: %d, password length: %d",
 		     table->s->fields, password_length));
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   if (password_length < SCRAMBLED_PASSWORD_CHAR_LENGTH)
   {
     if (opt_secure_auth)
     {
-      pthread_mutex_unlock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
       sql_print_error("Fatal error: mysql.user table is in old format, "
                       "but server started with --secure-auth option.");
       goto end;
     }
     sys_old_passwords.after_update= restrict_update_of_old_passwords_var;
     if (global_system_variables.old_passwords)
-      pthread_mutex_unlock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     else
     {
       global_system_variables.old_passwords= 1;
-      pthread_mutex_unlock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
       sql_print_warning("mysql.user table is not updated to new password format; "
                         "Disabling new password usage until "
                         "mysql_fix_privilege_tables is run");
@@ -415,7 +415,7 @@ static my_bool acl_load(THD *thd, TABLE_
   else
   {
     sys_old_passwords.after_update= 0;
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
 
   allow_all_hosts=0;
@@ -704,7 +704,7 @@ my_bool acl_reload(THD *thd)
   }
 
   if ((old_initialized=initialized))
-    pthread_mutex_lock(&acl_cache->lock);
+    MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   old_acl_hosts=acl_hosts;
   old_acl_users=acl_users;
@@ -731,7 +731,7 @@ my_bool acl_reload(THD *thd)
     delete_dynamic(&old_acl_dbs);
   }
   if (old_initialized)
-    pthread_mutex_unlock(&acl_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 end:
   close_thread_tables(thd);
   DBUG_RETURN(return_val);
@@ -883,7 +883,7 @@ int acl_getroot(THD *thd, USER_RESOURCES
     DBUG_RETURN(0);
   }
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   /*
     Find acl entry in user database. Note, that find_acl_user is not the same,
@@ -1055,7 +1055,7 @@ int acl_getroot(THD *thd, USER_RESOURCES
     else
       *sctx->priv_host= 0;
   }
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   DBUG_RETURN(res);
 }
 
@@ -1102,7 +1102,7 @@ bool acl_getroot_no_password(Security_co
     DBUG_RETURN(FALSE);
   }
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   sctx->master_access= 0;
   sctx->db_access= 0;
@@ -1156,7 +1156,7 @@ bool acl_getroot_no_password(Security_co
     else
       *sctx->priv_host= 0;
   }
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   DBUG_RETURN(res);
 }
 
@@ -1177,7 +1177,7 @@ static void acl_update_user(const char *
 			    USER_RESOURCES  *mqh,
 			    ulong privileges)
 {
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   for (uint i=0 ; i < acl_users.elements ; i++)
   {
@@ -1229,7 +1229,7 @@ static void acl_insert_user(const char *
 {
   ACL_USER acl_user;
 
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   acl_user.user=*user ? strdup_root(&mem,user) : 0;
   update_hostname(&acl_user.host, *host ? strdup_root(&mem, host): 0);
@@ -1260,7 +1260,7 @@ static void acl_insert_user(const char *
 static void acl_update_db(const char *user, const char *host, const char *db,
 			  ulong privileges)
 {
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   for (uint i=0 ; i < acl_dbs.elements ; i++)
   {
@@ -1305,7 +1305,7 @@ static void acl_insert_db(const char *us
 			  ulong privileges)
 {
   ACL_DB acl_db;
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
   acl_db.user=strdup_root(&mem,user);
   update_hostname(&acl_db.host, *host ? strdup_root(&mem,host) : 0);
   acl_db.db=strdup_root(&mem,db);
@@ -1335,7 +1335,7 @@ ulong acl_get(const char *host, const ch
   acl_entry *entry;
   DBUG_ENTER("acl_get");
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   end=strmov((tmp_db=strmov(strmov(key, ip ? ip : "")+1,user)+1),db);
   if (lower_case_table_names)
   {
@@ -1347,7 +1347,7 @@ ulong acl_get(const char *host, const ch
                                                               key_length)))
   {
     db_access=entry->access;
-    pthread_mutex_unlock(&acl_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
     DBUG_PRINT("exit", ("access: 0x%lx", db_access));
     DBUG_RETURN(db_access);
   }
@@ -1401,7 +1401,7 @@ exit:
     memcpy((uchar*) entry->key,key,key_length);
     acl_cache->add(entry);
   }
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   DBUG_PRINT("exit", ("access: 0x%lx", db_access & host_access));
   DBUG_RETURN(db_access & host_access);
 }
@@ -1481,12 +1481,12 @@ bool acl_check_host(const char *host, co
 {
   if (allow_all_hosts)
     return 0;
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   if (host && hash_search(&acl_check_hosts,(uchar*) host,strlen(host)) ||
       ip && hash_search(&acl_check_hosts,(uchar*) ip, strlen(ip)))
   {
-    pthread_mutex_unlock(&acl_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
     return 0;					// Found host
   }
   for (uint i=0 ; i < acl_wild_hosts.elements ; i++)
@@ -1494,11 +1494,11 @@ bool acl_check_host(const char *host, co
     acl_host_and_ip *acl=dynamic_element(&acl_wild_hosts,i,acl_host_and_ip*);
     if (compare_hostname(acl, host, ip))
     {
-      pthread_mutex_unlock(&acl_cache->lock);
+      MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
       return 0;					// Host ok
     }
   }
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   return 1;					// Host is not allowed
 }
 
@@ -1613,11 +1613,11 @@ bool change_password(THD *thd, const cha
   if (!(table= open_ltable(thd, &tables, TL_WRITE, 0)))
     DBUG_RETURN(1);
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   ACL_USER *acl_user;
   if (!(acl_user= find_acl_user(host, user, TRUE)))
   {
-    pthread_mutex_unlock(&acl_cache->lock);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
     my_message(ER_PASSWORD_NO_MATCH, ER(ER_PASSWORD_NO_MATCH), MYF(0));
     goto end;
   }
@@ -1629,12 +1629,12 @@ bool change_password(THD *thd, const cha
 			acl_user->user ? acl_user->user : "",
 			new_password, new_password_len))
   {
-    pthread_mutex_unlock(&acl_cache->lock); /* purecov: deadcode */
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock); /* purecov: deadcode */
     goto end;
   }
 
   acl_cache->clear(1);				// Clear locked hostname cache
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   result= 0;
   if (mysql_bin_log.is_open())
   {
@@ -1674,9 +1674,9 @@ bool is_acl_user(const char *host, const
   if (!initialized)
     return TRUE;
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   res= find_acl_user(host, user, TRUE) != NULL;
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   return res;
 }
 
@@ -1691,7 +1691,7 @@ find_acl_user(const char *host, const ch
   DBUG_ENTER("find_acl_user");
   DBUG_PRINT("enter",("host: '%s'  user: '%s'",host,user));
 
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   for (uint i=0 ; i < acl_users.elements ; i++)
   {
@@ -1894,7 +1894,7 @@ static int replace_user_table(THD *thd, 
   LEX *lex= thd->lex;
   DBUG_ENTER("replace_user_table");
 
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   if (combo.password.str && combo.password.str[0])
   {
@@ -3065,8 +3065,8 @@ int mysql_table_grant(THD *thd, TABLE_LI
   if (!revoke_grant)
     create_new_users= test_if_create_new_users(thd);
   bool result= FALSE;
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   MEM_ROOT *old_root= thd->mem_root;
   thd->mem_root= &memex;
   grant_version++;
@@ -3175,14 +3175,14 @@ int mysql_table_grant(THD *thd, TABLE_LI
     }
   }
   thd->mem_root= old_root;
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   if (!result) /* success */
   {
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   }
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   if (!result) /* success */
     my_ok(thd);
@@ -3284,8 +3284,8 @@ bool mysql_routine_grant(THD *thd, TABLE
 
   if (!revoke_grant)
     create_new_users= test_if_create_new_users(thd);
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   MEM_ROOT *old_root= thd->mem_root;
   thd->mem_root= &memex;
 
@@ -3346,13 +3346,13 @@ bool mysql_routine_grant(THD *thd, TABLE
     }
   }
   thd->mem_root= old_root;
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   if (!result && !no_error)
   {
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   }
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   if (!result && !no_error)
     my_ok(thd);
@@ -3428,8 +3428,8 @@ bool mysql_grant(THD *thd, const char *d
     create_new_users= test_if_create_new_users(thd);
 
   /* go through users in user_list */
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
   grant_version++;
 
   int result=0;
@@ -3461,14 +3461,14 @@ bool mysql_grant(THD *thd, const char *d
       }
     }
   }
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   if (!result)
   {
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   }
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
 
   if (!result)
@@ -3738,7 +3738,7 @@ static my_bool grant_reload_procs_priv(T
   old_proc_priv_hash= proc_priv_hash;
   old_func_priv_hash= func_priv_hash;
 
-  rw_wrlock(&LOCK_grant);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
   if ((return_val= grant_load_procs_priv(table.table)))
   {
     /* Error; Reverting to old hash */
@@ -3752,7 +3752,7 @@ static my_bool grant_reload_procs_priv(T
     hash_free(&old_proc_priv_hash);
     hash_free(&old_func_priv_hash);
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   close_thread_tables(thd);
   DBUG_RETURN(return_val);
@@ -3802,7 +3802,7 @@ my_bool grant_reload(THD *thd)
   if (simple_open_n_lock_tables(thd, tables))
     goto end;
 
-  rw_wrlock(&LOCK_grant);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
   old_column_priv_hash= column_priv_hash;
 
   /*
@@ -3824,7 +3824,7 @@ my_bool grant_reload(THD *thd)
     hash_free(&old_column_priv_hash);
     free_root(&old_mem,MYF(0));
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
 
   /*
@@ -3834,9 +3834,9 @@ my_bool grant_reload(THD *thd)
   if (grant_reload_procs_priv(thd))
     return_val= 1;
 
-  rw_wrlock(&LOCK_grant);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
   grant_version++;
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
 end:
   DBUG_RETURN(return_val);
@@ -3911,7 +3911,7 @@ bool check_grant(THD *thd, ulong want_ac
     table->grant.orig_want_privilege= (want_access & ~SHOW_VIEW_ACL);
   }
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
   for (table= tables;
        table && number-- && table != first_not_own_table;
        table= table->next_global)
@@ -3972,11 +3972,11 @@ bool check_grant(THD *thd, ulong want_ac
       goto err;					// impossible
     }
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   DBUG_RETURN(FALSE);
 
 err:
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   if (!no_errors)				// Not a silent skip of table
   {
     char command[128];
@@ -4030,11 +4030,11 @@ bool has_any_table_level_privileges(THD 
         Get privileges from table_priv and column_priv tables by searching
         the cache.
       */
-      rw_rdlock(&LOCK_grant);
+      MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
       grant_table= table_hash_search(sctx->host, sctx->ip,
                                     table->db, sctx->priv_user,
                                     table->table_name,0);
-      rw_unlock(&LOCK_grant);
+      MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
       /* Stop if there are no grants for the current user */
       if (!grant_table)
@@ -4111,7 +4111,7 @@ bool check_grant_column(THD *thd, GRANT_
   if (!want_access)
     DBUG_RETURN(0);				// Already checked
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 
   /* reload table if someone has modified any grants */
 
@@ -4129,12 +4129,12 @@ bool check_grant_column(THD *thd, GRANT_
   grant_column=column_hash_search(grant_table, name, length);
   if (grant_column && !(~grant_column->rights & want_access))
   {
-    rw_unlock(&LOCK_grant);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
     DBUG_RETURN(0);
   }
 
 err:
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   char command[128];
   get_privilege_desc(command, sizeof(command), want_access);
   my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0),
@@ -4245,7 +4245,7 @@ bool check_grant_all_columns(THD *thd, u
   /* Initialized only to make gcc happy */
   GRANT_TABLE *grant_table= NULL;
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 
   for (; !fields->end_of_fields(); fields->next())
   {
@@ -4284,11 +4284,11 @@ bool check_grant_all_columns(THD *thd, u
         goto err;
     }
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   return 0;
 
 err:
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   char command[128];
   get_privilege_desc(command, sizeof(command), want_access);
@@ -4337,7 +4337,7 @@ bool check_grant_db(THD *thd,const char 
 
   len= (uint) (strmov(strmov(helping, sctx->priv_user) + 1, db) - helping) + 1;
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 
   for (uint idx=0 ; idx < column_priv_hash.records ; idx++)
   {
@@ -4356,7 +4356,7 @@ bool check_grant_db(THD *thd,const char 
     error= check_grant_db_routine(thd, db, &proc_priv_hash) &&
            check_grant_db_routine(thd, db, &func_priv_hash);
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   return error;
 }
@@ -4392,7 +4392,7 @@ bool check_grant_routine(THD *thd, ulong
   if (!want_access)
     DBUG_RETURN(0);                             // ok
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
   for (table= procs; table; table= table->next_global)
   {
     GRANT_NAME *grant_proc;
@@ -4406,10 +4406,10 @@ bool check_grant_routine(THD *thd, ulong
       goto err;
     }
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   DBUG_RETURN(0);
 err:
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   if (!no_errors)
   {
     char buff[1024];
@@ -4450,13 +4450,13 @@ bool check_routine_level_acl(THD *thd, c
   bool no_routine_acl= 1;
   GRANT_NAME *grant_proc;
   Security_context *sctx= thd->security_ctx;
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
   if ((grant_proc= routine_hash_search(sctx->priv_host,
                                        sctx->ip, db,
                                        sctx->priv_user,
                                        name, is_proc, 0)))
     no_routine_acl= !(grant_proc->privs & SHOW_PROC_ACLS);
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   return no_routine_acl;
 }
 
@@ -4472,7 +4472,7 @@ ulong get_table_grant(THD *thd, TABLE_LI
   const char *db = table->db ? table->db : thd->db;
   GRANT_TABLE *grant_table;
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 #ifdef EMBEDDED_LIBRARY
   grant_table= NULL;
 #else
@@ -4484,7 +4484,7 @@ ulong get_table_grant(THD *thd, TABLE_LI
   if (grant_table)
     table->grant.privilege|= grant_table->privs;
   privilege= table->grant.privilege;
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   return privilege;
 }
 
@@ -4515,7 +4515,7 @@ ulong get_column_grant(THD *thd, GRANT_I
   GRANT_COLUMN *grant_column;
   ulong priv;
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
   /* reload table if someone has modified any grants */
   if (grant->version != grant_version)
   {
@@ -4538,7 +4538,7 @@ ulong get_column_grant(THD *thd, GRANT_I
     else
       priv= (grant->privilege | grant_table->privs | grant_column->rights);
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   return priv;
 }
 
@@ -4605,14 +4605,14 @@ bool mysql_show_grants(THD *thd,LEX_USER
     DBUG_RETURN(TRUE);
   }
 
-  rw_rdlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   acl_user= find_acl_user(lex_user->host.str, lex_user->user.str, TRUE);
   if (!acl_user)
   {
-    pthread_mutex_unlock(&acl_cache->lock);
-    rw_unlock(&LOCK_grant);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
     my_error(ER_NONEXISTING_GRANT, MYF(0),
              lex_user->user.str, lex_user->host.str);
@@ -4629,8 +4629,8 @@ bool mysql_show_grants(THD *thd,LEX_USER
   if (protocol->send_result_set_metadata(&field_list,
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
   {
-    pthread_mutex_unlock(&acl_cache->lock);
-    rw_unlock(&LOCK_grant);
+    MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
     DBUG_RETURN(TRUE);
   }
@@ -4940,8 +4940,8 @@ bool mysql_show_grants(THD *thd,LEX_USER
   }
 
 end:
-  pthread_mutex_unlock(&acl_cache->lock);
-  rw_unlock(&LOCK_grant);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   my_eof(thd);
   DBUG_RETURN(error);
@@ -5065,14 +5065,14 @@ void get_mqh(const char *user, const cha
 {
   ACL_USER *acl_user;
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   if (initialized && (acl_user= find_acl_user(host,user, FALSE)))
     uc->user_resources= acl_user->user_resource;
   else
     bzero((char*) &uc->user_resources, sizeof(uc->user_resources));
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 }
 
 /*
@@ -5159,7 +5159,7 @@ ACL_USER *check_acl_user(LEX_USER *user_
   ACL_USER *acl_user= 0;
   uint counter;
 
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   for (counter= 0 ; counter < acl_users.elements ; counter++)
   {
@@ -5431,7 +5431,7 @@ static int handle_grant_struct(uint stru
   LINT_INIT(user);
   LINT_INIT(host);
 
-  safe_mutex_assert_owner(&acl_cache->lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&acl_cache->lock);
 
   /* Get the number of elements in the in-memory structure. */
   switch (struct_no) {
@@ -5728,8 +5728,8 @@ bool mysql_create_user(THD *thd, List <L
   if ((result= open_grant_tables(thd, tables)))
     DBUG_RETURN(result != 1);
 
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   while ((tmp_user_name= user_list++))
   {
@@ -5758,7 +5758,7 @@ bool mysql_create_user(THD *thd, List <L
     }
   }
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "CREATE USER", wrong_users.c_ptr_safe());
@@ -5766,7 +5766,7 @@ bool mysql_create_user(THD *thd, List <L
   if (some_users_created)
     write_bin_log(thd, FALSE, thd->query, thd->query_length);
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
   DBUG_RETURN(result);
 }
@@ -5806,8 +5806,8 @@ bool mysql_drop_user(THD *thd, List <LEX
   if ((result= open_grant_tables(thd, tables)))
     DBUG_RETURN(result != 1);
 
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   while ((tmp_user_name= user_list++))
   {
@@ -5828,7 +5828,7 @@ bool mysql_drop_user(THD *thd, List <LEX
   /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
   rebuild_check_host();
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "DROP USER", wrong_users.c_ptr_safe());
@@ -5836,7 +5836,7 @@ bool mysql_drop_user(THD *thd, List <LEX
   if (some_users_deleted)
     write_bin_log(thd, FALSE, thd->query, thd->query_length);
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
   DBUG_RETURN(result);
 }
@@ -5877,8 +5877,8 @@ bool mysql_rename_user(THD *thd, List <L
   if ((result= open_grant_tables(thd, tables)))
     DBUG_RETURN(result != 1);
 
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   while ((tmp_user_from= user_list++))
   {
@@ -5912,7 +5912,7 @@ bool mysql_rename_user(THD *thd, List <L
   /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
   rebuild_check_host();
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "RENAME USER", wrong_users.c_ptr_safe());
@@ -5920,7 +5920,7 @@ bool mysql_rename_user(THD *thd, List <L
   if (some_users_renamed && mysql_bin_log.is_open())
     write_bin_log(thd, FALSE, thd->query, thd->query_length);
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
   DBUG_RETURN(result);
 }
@@ -5958,8 +5958,8 @@ bool mysql_revoke_all(THD *thd,  List <L
   if ((result= open_grant_tables(thd, tables)))
     DBUG_RETURN(result != 1);
 
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   LEX_USER *lex_user, *tmp_lex_user;
   List_iterator <LEX_USER> user_list(list);
@@ -6098,11 +6098,11 @@ bool mysql_revoke_all(THD *thd,  List <L
     } while (revoked);
   }
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   write_bin_log(thd, FALSE, thd->query, thd->query_length);
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
 
   if (result)
@@ -6198,8 +6198,8 @@ bool sp_revoke_privileges(THD *thd, cons
   /* Be sure to pop this before exiting this scope! */
   thd->push_internal_handler(&error_handler);
 
-  rw_wrlock(&LOCK_grant);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_grant);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   /*
     This statement will be replicated as a statement, even when using
@@ -6237,8 +6237,8 @@ bool sp_revoke_privileges(THD *thd, cons
     }
   } while (revoked);
 
-  pthread_mutex_unlock(&acl_cache->lock);
-  rw_unlock(&LOCK_grant);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
   close_thread_tables(thd);
 
   thd->pop_internal_handler();
@@ -6278,7 +6278,7 @@ int sp_grant_privileges(THD *thd, const 
 
   combo->user.str= sctx->user;
 
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   if ((au= find_acl_user(combo->host.str=(char*)sctx->host_or_ip,combo->user.str,FALSE)))
     goto found_acl;
@@ -6289,11 +6289,11 @@ int sp_grant_privileges(THD *thd, const 
   if((au= find_acl_user(combo->host.str=(char*)"%", combo->user.str, FALSE)))
     goto found_acl;
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
   DBUG_RETURN(TRUE);
 
  found_acl:
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   bzero((char*)tables, sizeof(TABLE_LIST));
   user_list.empty();
@@ -6437,7 +6437,7 @@ int fill_schema_user_privileges(THD *thd
 
   if (!initialized)
     DBUG_RETURN(0);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   for (counter=0 ; counter < acl_users.elements ; counter++)
   {
@@ -6475,7 +6475,7 @@ int fill_schema_user_privileges(THD *thd
     }
   }
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   DBUG_RETURN(0);
 #else
@@ -6498,7 +6498,7 @@ int fill_schema_schema_privileges(THD *t
 
   if (!initialized)
     DBUG_RETURN(0);
-  pthread_mutex_lock(&acl_cache->lock);
+  MYSQL_MUTEX_LOCK(&acl_cache->lock);
 
   for (counter=0 ; counter < acl_dbs.elements ; counter++)
   {
@@ -6539,7 +6539,7 @@ int fill_schema_schema_privileges(THD *t
     }
   }
 
-  pthread_mutex_unlock(&acl_cache->lock);
+  MYSQL_MUTEX_UNLOCK(&acl_cache->lock);
 
   DBUG_RETURN(0);
 #else
@@ -6558,7 +6558,7 @@ int fill_schema_table_privileges(THD *th
   char *curr_host= thd->security_ctx->priv_host_name();
   DBUG_ENTER("fill_schema_table_privileges");
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 
   for (index=0 ; index < column_priv_hash.records ; index++)
   {
@@ -6607,7 +6607,7 @@ int fill_schema_table_privileges(THD *th
     }
   }
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   DBUG_RETURN(0);
 #else
@@ -6626,7 +6626,7 @@ int fill_schema_column_privileges(THD *t
   char *curr_host= thd->security_ctx->priv_host_name();
   DBUG_ENTER("fill_schema_table_privileges");
 
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
 
   for (index=0 ; index < column_priv_hash.records ; index++)
   {
@@ -6681,7 +6681,7 @@ int fill_schema_column_privileges(THD *t
     }
   }
 
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   DBUG_RETURN(0);
 #else
@@ -6733,7 +6733,7 @@ void fill_effective_table_privileges(THD
   grant->privilege|= acl_get(sctx->host, sctx->ip, sctx->priv_user, db, 0);
 
   /* table privileges */
-  rw_rdlock(&LOCK_grant);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_grant);
   if (grant->version != grant_version)
   {
     grant->grant_table=
@@ -6746,7 +6746,7 @@ void fill_effective_table_privileges(THD
   {
     grant->privilege|= grant->grant_table->privs;
   }
-  rw_unlock(&LOCK_grant);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_grant);
 
   DBUG_PRINT("info", ("privilege 0x%lx", grant->privilege));
   DBUG_VOID_RETURN;

=== modified file 'sql/sql_audit.cc'
--- a/sql/sql_audit.cc	2008-03-26 14:30:28 +0000
+++ b/sql/sql_audit.cc	2008-10-10 20:34:55 +0000
@@ -23,7 +23,10 @@ extern int finalize_audit_plugin(st_plug
 
 unsigned long mysql_global_audit_mask[MYSQL_AUDIT_CLASS_MASK_SIZE];
 
-static pthread_mutex_t LOCK_audit_mask;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_audit_mask;
+#endif
+static mysql_mutex_t LOCK_audit_mask;
 
 static void event_class_dispatch(THD *thd, const struct mysql_event *event);
 
@@ -247,7 +250,7 @@ void mysql_audit_free_thd(THD *thd)
 
 void mysql_audit_initialize()
 {
-  pthread_mutex_init(&LOCK_audit_mask, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_audit_mask, key_LOCK_audit_mask, MY_MUTEX_INIT_FAST);
   bzero(mysql_global_audit_mask, sizeof(mysql_global_audit_mask));
 }
 
@@ -258,7 +261,7 @@ void mysql_audit_initialize()
 
 void mysql_audit_finalize()
 {
-  pthread_mutex_destroy(&LOCK_audit_mask);
+  MYSQL_MUTEX_DESTROY(&LOCK_audit_mask);
 }
 
 
@@ -294,9 +297,9 @@ int initialize_audit_plugin(st_plugin_in
   plugin->data= plugin->plugin->info;
   
   /* Add the bits the plugin is interested in to the global mask */
-  pthread_mutex_lock(&LOCK_audit_mask);
+  MYSQL_MUTEX_LOCK(&LOCK_audit_mask);
   add_audit_mask(mysql_global_audit_mask, data->class_mask);
-  pthread_mutex_unlock(&LOCK_audit_mask);
+  MYSQL_MUTEX_UNLOCK(&LOCK_audit_mask);
 
   return 0;
 }
@@ -343,13 +346,13 @@ int finalize_audit_plugin(st_plugin_int 
   bzero(&event_class_mask, sizeof(event_class_mask));
 
   /* Iterate through all the installed plugins to create new mask */
-  pthread_mutex_lock(&LOCK_audit_mask);
+  MYSQL_MUTEX_LOCK(&LOCK_audit_mask);
   plugin_foreach(current_thd, calc_class_mask, MYSQL_AUDIT_PLUGIN,
                  &event_class_mask);
 
   /* Set the global audit mask */
   bmove(mysql_global_audit_mask, event_class_mask, sizeof(event_class_mask));
-  pthread_mutex_unlock(&LOCK_audit_mask);
+  MYSQL_MUTEX_UNLOCK(&LOCK_audit_mask);
 
   return 0;
 }

=== modified file 'sql/sql_base.cc'
--- a/sql/sql_base.cc	2008-09-04 18:30:34 +0000
+++ b/sql/sql_base.cc	2008-10-10 20:34:55 +0000
@@ -242,7 +242,7 @@ extern "C" uchar *table_def_key(const uc
 static void table_def_free_entry(TABLE_SHARE *share)
 {
   DBUG_ENTER("table_def_free_entry");
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
   if (share->prev)
   {
     /* remove from old_unused_share list */
@@ -619,7 +619,7 @@ void release_table_share(TABLE_SHARE *sh
               share, share->db.str, share->table_name.str,
               share->ref_count, share->version));
 
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   if (!--share->ref_count)
   {
@@ -667,7 +667,7 @@ TABLE_SHARE *get_cached_table_share(cons
   char key[NAME_LEN*2+2];
   TABLE_LIST table_list;
   uint key_length;
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   table_list.db= (char*) db;
   table_list.table_name= (char*) table_name;
@@ -687,7 +687,7 @@ static void reference_table_share(TABLE_
 {
   DBUG_ENTER("reference_table_share");
   DBUG_ASSERT(share->ref_count);
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
   share->ref_count++;
   DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                      (ulong) share, share->ref_count));
@@ -720,7 +720,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *t
   TABLE_LIST table_list;
   DBUG_ENTER("list_open_tables");
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   bzero((char*) &table_list,sizeof(table_list));
   start_list= &open_list;
   open_list=0;
@@ -760,7 +760,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *t
     start_list= &(*start_list)->next;
     *start_list=0;
   }
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   DBUG_RETURN(open_list);
 }
 
@@ -837,7 +837,7 @@ static void kill_delayed_threads_for_tab
   I_P_List_iterator<TABLE, TABLE_share> it(share->used_tables);
   TABLE *tab;
 
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   while ((tab= it++))
   {
@@ -847,14 +847,14 @@ static void kill_delayed_threads_for_tab
         ! in_use->killed)
     {
       in_use->killed= THD::KILL_CONNECTION;
-      pthread_mutex_lock(&in_use->mysys_var->mutex);
+      MYSQL_MUTEX_LOCK(&in_use->mysys_var->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);
-        pthread_mutex_unlock(in_use->mysys_var->current_mutex);
+        MYSQL_MUTEX_LOCK(in_use->mysys_var->current_mutex);
+        MYSQL_COND_BROADCAST(in_use->mysys_var->current_cond);
+        MYSQL_MUTEX_UNLOCK(in_use->mysys_var->current_mutex);
       }
-      pthread_mutex_unlock(&in_use->mysys_var->mutex);
+      MYSQL_MUTEX_UNLOCK(&in_use->mysys_var->mutex);
     }
   }
 }
@@ -888,7 +888,7 @@ bool close_cached_tables(THD *thd, TABLE
   DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
 
   if (!have_lock)
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
   if (!tables)
   {
     refresh_version++;				// Force close of open tables
@@ -926,7 +926,7 @@ bool close_cached_tables(THD *thd, TABLE
   }
 
   if (!have_lock)
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (!wait_for_refresh)
     DBUG_RETURN(result);
@@ -977,7 +977,7 @@ bool close_cached_tables(THD *thd, TABLE
     mysql_ha_flush(thd);
     DEBUG_SYNC(thd, "after_flush_unlock");
 
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
 
     thd->enter_cond(&COND_refresh, &LOCK_open, "Flushing tables");
 
@@ -1009,7 +1009,7 @@ bool close_cached_tables(THD *thd, TABLE
     if (found)
     {
       DBUG_PRINT("signal", ("Waiting for COND_refresh"));
-      pthread_cond_wait(&COND_refresh,&LOCK_open);
+      MYSQL_COND_WAIT(&COND_refresh,&LOCK_open);
     }
 
     thd->exit_cond(NULL);
@@ -1053,7 +1053,7 @@ bool close_cached_connection_tables(THD 
   bzero(&tmp, sizeof(TABLE_LIST));
 
   if (!have_lock)
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
 
   for (idx= 0; idx < table_def_cache.records; idx++)
   {
@@ -1086,15 +1086,15 @@ bool close_cached_connection_tables(THD 
     result= close_cached_tables(thd, tables, TRUE, FALSE);
 
   if (!have_lock)
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (if_wait_for_refresh)
   {
-    pthread_mutex_lock(&thd->mysys_var->mutex);
+    MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
     thd->mysys_var->current_mutex= 0;
     thd->mysys_var->current_cond= 0;
     thd->proc_info=0;
-    pthread_mutex_unlock(&thd->mysys_var->mutex);
+    MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
   }
 
   DBUG_RETURN(result);
@@ -1178,9 +1178,9 @@ static void close_open_tables(THD *thd)
 {
   bool found_old_table= 0;
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   DBUG_PRINT("info", ("thd->open_tables: %p", thd->open_tables));
 
@@ -1197,7 +1197,7 @@ static void close_open_tables(THD *thd)
     broadcast_refresh();
   }
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 }
 
 
@@ -1228,13 +1228,13 @@ close_all_tables_for_name(THD *thd, TABL
 
   memcpy(key, share->table_cache_key.str, key_length);
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
   /*
     We need to hold LOCK_open while changing the open_tables
     list, since another thread may work on it.
     @sa mysql_notify_thread_having_shared_lock()
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   for (TABLE **prev= &thd->open_tables; *prev; )
   {
@@ -1270,7 +1270,7 @@ close_all_tables_for_name(THD *thd, TABL
   }
   /* We have been removing tables from the table cache. */
   broadcast_refresh();
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 }
 
 
@@ -1453,7 +1453,7 @@ bool close_thread_table(THD *thd, TABLE 
   DBUG_ENTER("close_thread_table");
   DBUG_ASSERT(table->key_read == 0);
   DBUG_ASSERT(!table->file || table->file->inited == handler::NONE);
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   *table_ptr=table->next;
 
@@ -2047,10 +2047,10 @@ bool wait_while_table_is_used(THD *thd, 
     DBUG_RETURN(TRUE);
   }
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   tdc_remove_table(thd, TDC_RT_REMOVE_NOT_OWN,
                    table->s->db.str, table->s->table_name.str);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   /* extra() call must come only after all instances above are closed */
   (void) table->file->extra(function);
   DBUG_RETURN(FALSE);
@@ -2090,11 +2090,11 @@ void drop_open_table(THD *thd, TABLE *ta
     /* Ensure the table is removed from the cache. */
     table->s->version= 0;
 
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     table->file->extra(HA_EXTRA_PREPARE_FOR_DROP);
     close_thread_table(thd, &thd->open_tables);
     quick_rm_table(table_type, db_name, table_name, 0);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
   }
   DBUG_VOID_RETURN;
 }
@@ -2111,7 +2111,7 @@ void drop_open_table(THD *thd, TABLE *ta
      cond	Condition to wait for
 */
 
-void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
+void wait_for_condition(THD *thd, mysql_mutex_t *mutex, mysql_cond_t *cond)
 {
   /* Wait until the current table is up to date */
   const char *proc_info;
@@ -2121,7 +2121,7 @@ void wait_for_condition(THD *thd, pthrea
   thd_proc_info(thd, "Waiting for table");
   DBUG_ENTER("wait_for_condition");
   if (!thd->killed)
-    (void) pthread_cond_wait(cond, mutex);
+    (void) MYSQL_COND_WAIT(cond, mutex);
 
   /*
     We must unlock mutex first to avoid deadlock becasue conditions are
@@ -2134,12 +2134,12 @@ void wait_for_condition(THD *thd, pthrea
     mutex is unlocked
   */
     
-  pthread_mutex_unlock(mutex);
-  pthread_mutex_lock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(mutex);
+  MYSQL_MUTEX_LOCK(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond= 0;
   thd_proc_info(thd, proc_info);
-  pthread_mutex_unlock(&thd->mysys_var->mutex);
+  MYSQL_MUTEX_UNLOCK(&thd->mysys_var->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -2171,7 +2171,7 @@ bool check_if_table_exists(THD *thd, TAB
   int rc;
   DBUG_ENTER("check_if_table_exists");
 
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   *exists= TRUE;
 
@@ -2215,10 +2215,10 @@ bool check_if_table_exists(THD *thd, TAB
 
 void table_share_release_hook(void *share)
 {
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   release_table_share((TABLE_SHARE*) share);
   broadcast_refresh();
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 }
 
 
@@ -2536,7 +2536,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
     }
   }
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   /*
     If it's the first table from a list of tables used in a query,
@@ -2553,7 +2553,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
   {
     /* Someone did a refresh while thread was opening tables */
     *action= OT_BACK_OFF_AND_RETRY;
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     DBUG_RETURN(TRUE);
   }
 
@@ -2566,14 +2566,14 @@ bool open_table(THD *thd, TABLE_LIST *ta
 
     if (!exists)
     {
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       DBUG_RETURN(FALSE);
     }
     /* Table exists. Let us try to open it. */
   }
   else if (table_list->open_type == TABLE_LIST::TAKE_EXCLUSIVE_MDL)
   {
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     DBUG_RETURN(FALSE);
   }
 
@@ -2620,7 +2620,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
         DBUG_ASSERT(table_list->view);
       }
 
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       DBUG_RETURN(FALSE);
     }
     /*
@@ -2677,7 +2677,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
        */
       *action= OT_BACK_OFF_AND_RETRY;
       release_table_share(share);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       DBUG_RETURN(TRUE);
     }
     /* Force close at once after usage */
@@ -2739,7 +2739,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
     table_def_add_used_table(thd, table);
   }
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   /*
     In CREATE TABLE .. If NOT EXISTS .. SELECT we have found that
@@ -2796,7 +2796,7 @@ bool open_table(THD *thd, TABLE_LIST *ta
 err_unlock:
   release_table_share(share);
 err_unlock2:
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   if (! (flags & MYSQL_OPEN_HAS_MDL_LOCK))
   {
     mdl_release_lock(&thd->mdl_context, mdl_lock_data);
@@ -3114,9 +3114,9 @@ Locked_tables_list::reopen_tables(THD *t
         No one's seen this branch work. Recover and report an
         error just in case.
       */
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       close_thread_table(thd, &thd->open_tables);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       table_list->table= 0;
       unlink_all_closed_tables();
       my_error(ER_LOCK_DEADLOCK, MYF(0));
@@ -3166,7 +3166,7 @@ void assign_new_table_id(TABLE_SHARE *sh
 
   /* Preconditions */
   DBUG_ASSERT(share != NULL);
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   ulong tid= ++last_table_id;                   /* get next id */
   /*
@@ -3276,7 +3276,7 @@ bool tdc_open_view(THD *thd, TABLE_LIST 
   int error;
   TABLE_SHARE *share;
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                            cache_key_length, 
@@ -3292,14 +3292,14 @@ bool tdc_open_view(THD *thd, TABLE_LIST 
                     mem_root))
   {
     release_table_share(share);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     return FALSE;
   }
 
   my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str, "VIEW");
   release_table_share(share);
 err:
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   return TRUE;
 }
 
@@ -3372,13 +3372,13 @@ static bool auto_repair_table(THD *thd, 
 
   thd->clear_error();
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   if (!(share= get_table_share_with_create(thd, table_list, cache_key,
                                            cache_key_length,
                                            OPEN_VIEW, &not_used)))
   {
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     return TRUE;
   }
 
@@ -3391,7 +3391,7 @@ static bool auto_repair_table(THD *thd, 
     goto end_with_lock_open;
   }
   share->version= 0;
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (open_table_from_share(thd, share, table_list->alias,
                             (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
@@ -3418,11 +3418,11 @@ static bool auto_repair_table(THD *thd, 
   }
   my_free(entry, MYF(0));
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
 end_with_lock_open:
   release_table_share(share);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   return result;
 }
 
@@ -3461,10 +3461,10 @@ recover_from_failed_open_table_attempt(T
         mdl_remove_lock(&thd->mdl_context, table->mdl_lock_data);
         return TRUE;
       }
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name);
       ha_create_table_from_engine(thd, table->db, table->table_name);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
       mysql_reset_errors(thd, 1);         // Clear warnings
       thd->clear_error();                 // Clear error message
@@ -3479,9 +3479,9 @@ recover_from_failed_open_table_attempt(T
         mdl_remove_lock(&thd->mdl_context, table->mdl_lock_data);
         return TRUE;
       }
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
       result= auto_repair_table(thd, table);
       mdl_release_lock(&thd->mdl_context, table->mdl_lock_data);
@@ -7376,10 +7376,10 @@ my_bool mysql_rm_tmp_tables(void)
 
 void flush_tables()
 {
-  (void) pthread_mutex_lock(&LOCK_open);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_open);
   while (unused_tables)
     free_cache_entry(unused_tables);
-  (void) pthread_mutex_unlock(&LOCK_open);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_open);
 }
 
 
@@ -7415,13 +7415,13 @@ bool mysql_notify_thread_having_shared_l
       !in_use->killed)
   {
     in_use->killed= THD::KILL_CONNECTION;
-    pthread_mutex_lock(&in_use->mysys_var->mutex);
+    MYSQL_MUTEX_LOCK(&in_use->mysys_var->mutex);
     if (in_use->mysys_var->current_cond)
-      pthread_cond_broadcast(in_use->mysys_var->current_cond);
-    pthread_mutex_unlock(&in_use->mysys_var->mutex);
+      MYSQL_COND_BROADCAST(in_use->mysys_var->current_cond);
+    MYSQL_MUTEX_UNLOCK(&in_use->mysys_var->mutex);
     signalled= TRUE;
   }
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   for (TABLE *thd_table= in_use->open_tables;
        thd_table ;
        thd_table= thd_table->next)
@@ -7436,7 +7436,7 @@ bool mysql_notify_thread_having_shared_l
     if (thd_table->db_stat)
       signalled|= mysql_lock_abort_for_thread(thd, thd_table);
   }
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   return signalled;
 }
 
@@ -7479,7 +7479,7 @@ void tdc_remove_table(THD *thd, enum_tdc
   TABLE *table;
   TABLE_SHARE *share;
 
-  safe_mutex_assert_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 
   DBUG_ASSERT(remove_type == TDC_RT_REMOVE_UNUSED ||
               mdl_is_exclusive_lock_owner(&thd->mdl_context, 0,
@@ -7546,7 +7546,7 @@ static bool tdc_wait_for_old_versions(TH
             to broadcast on COND_refresh because of this.
     */
     mysql_ha_flush(thd);
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
 
     I_P_List_iterator<MDL_LOCK_DATA,
                       MDL_LOCK_DATA_context> it= mdl_get_locks(context);
@@ -7561,11 +7561,11 @@ static bool tdc_wait_for_old_versions(TH
     }
     if (!lock_data)
     {
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       break;
     }
     old_msg= thd->enter_cond(&COND_refresh, &LOCK_open, "Waiting for table");
-    pthread_cond_wait(&COND_refresh, &LOCK_open);
+    MYSQL_COND_WAIT(&COND_refresh, &LOCK_open);
     /* LOCK_open mutex is unlocked by THD::exit_cond() as side-effect. */
     thd->exit_cond(old_msg);
   }
@@ -7963,7 +7963,7 @@ void close_performance_schema_table(THD 
   mysql_unlock_tables(thd, thd->lock);
   thd->lock= 0;
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   found_old_table= false;
   /*
@@ -7977,7 +7977,7 @@ void close_performance_schema_table(THD 
   if (found_old_table)
     broadcast_refresh();
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   mdl_release_locks(&thd->mdl_context);
   mdl_remove_all_locks(&thd->mdl_context);

=== modified file 'sql/sql_cache.cc'
--- a/sql/sql_cache.cc	2008-08-07 03:05:33 +0000
+++ b/sql/sql_cache.cc	2008-10-10 20:34:55 +0000
@@ -340,23 +340,23 @@ TODO list:
 
 #if !defined(EXTRA_DBUG) && !defined(DBUG_OFF)
 #define MUTEX_LOCK(M) { DBUG_PRINT("lock", ("mutex lock %p", (M))); \
-  pthread_mutex_lock(M);}
+  MYSQL_MUTEX_LOCK(M);}
 #define MUTEX_UNLOCK(M) {DBUG_PRINT("lock", ("mutex unlock %p",\
-  (M))); pthread_mutex_unlock(M);}
+  (M))); MYSQL_MUTEX_UNLOCK(M);}
 #define RW_WLOCK(M) {DBUG_PRINT("lock", ("rwlock wlock %p",(M))); \
-  if (!rw_wrlock(M)) DBUG_PRINT("lock", ("rwlock wlock ok")); \
+  if (!MYSQL_RWLOCK_WRLOCK(M)) DBUG_PRINT("lock", ("rwlock wlock ok")); \
   else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); }
 #define RW_RLOCK(M) {DBUG_PRINT("lock", ("rwlock rlock %p", (M))); \
-  if (!rw_rdlock(M)) DBUG_PRINT("lock", ("rwlock rlock ok")); \
+  if (!MYSQL_RWLOCK_RDLOCK(M)) DBUG_PRINT("lock", ("rwlock rlock ok")); \
   else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); }
 #define RW_UNLOCK(M) {DBUG_PRINT("lock", ("rwlock unlock %p",(M))); \
-  if (!rw_unlock(M)) DBUG_PRINT("lock", ("rwlock unlock ok")); \
+  if (!MYSQL_RWLOCK_UNLOCK(M)) DBUG_PRINT("lock", ("rwlock unlock ok")); \
   else DBUG_PRINT("lock", ("rwlock unlock FAILED %d", errno)); }
 #define STRUCT_LOCK(M) {DBUG_PRINT("lock", ("%d struct lock...",__LINE__)); \
-  pthread_mutex_lock(M);DBUG_PRINT("lock", ("struct lock OK"));}
+  MYSQL_MUTEX_LOCK(M);DBUG_PRINT("lock", ("struct lock OK"));}
 #define STRUCT_UNLOCK(M) { \
   DBUG_PRINT("lock", ("%d struct unlock...",__LINE__)); \
-  pthread_mutex_unlock(M);DBUG_PRINT("lock", ("struct unlock OK"));}
+  MYSQL_MUTEX_UNLOCK(M);DBUG_PRINT("lock", ("struct unlock OK"));}
 #define BLOCK_LOCK_WR(B) {DBUG_PRINT("lock", ("%d LOCK_WR %p",\
   __LINE__,(B))); \
   B->query()->lock_writing();}
@@ -398,13 +398,13 @@ static void debug_wait_for_kill(const ch
 }
 
 #else
-#define MUTEX_LOCK(M) pthread_mutex_lock(M)
-#define MUTEX_UNLOCK(M) pthread_mutex_unlock(M)
-#define RW_WLOCK(M) rw_wrlock(M)
-#define RW_RLOCK(M) rw_rdlock(M)
-#define RW_UNLOCK(M) rw_unlock(M)
-#define STRUCT_LOCK(M) pthread_mutex_lock(M)
-#define STRUCT_UNLOCK(M) pthread_mutex_unlock(M)
+#define MUTEX_LOCK(M) MYSQL_MUTEX_LOCK(M)
+#define MUTEX_UNLOCK(M) MYSQL_MUTEX_UNLOCK(M)
+#define RW_WLOCK(M) MYSQL_RWLOCK_WRLOCK(M)
+#define RW_RLOCK(M) MYSQL_RWLOCK_RDLOCK(M)
+#define RW_UNLOCK(M) MYSQL_RWLOCK_UNLOCK(M)
+#define STRUCT_LOCK(M) MYSQL_MUTEX_LOCK(M)
+#define STRUCT_UNLOCK(M) MYSQL_MUTEX_UNLOCK(M)
 #define BLOCK_LOCK_WR(B) B->query()->lock_writing()
 #define BLOCK_LOCK_RD(B) B->query()->lock_reading()
 #define BLOCK_UNLOCK_WR(B) B->query()->unlock_writing()
@@ -546,7 +546,7 @@ inline void Query_cache_query::lock_writ
 my_bool Query_cache_query::try_lock_writing()
 {
   DBUG_ENTER("Query_cache_block::try_lock_writing");
-  if (rw_trywrlock(&lock)!=0)
+  if (MYSQL_RWLOCK_TRYWRLOCK(&lock)!=0)
   {
     DBUG_PRINT("info", ("can't lock rwlock"));
     DBUG_RETURN(0);
@@ -578,7 +578,7 @@ void Query_cache_query::init_n_lock()
 {
   DBUG_ENTER("Query_cache_query::init_n_lock");
   res=0; wri = 0; len = 0;
-  my_rwlock_init(&lock, NULL);
+  MYSQL_RWLOCK_INIT(&lock, key_QCQ_lock, NULL);
   lock_writing();
   DBUG_PRINT("qcache", ("inited & locked query for block %p",
 			(((uchar*) this) -
@@ -598,7 +598,7 @@ void Query_cache_query::unlock_n_destroy
     active semaphore
   */
   this->unlock_writing();
-  rwlock_destroy(&lock);
+  MYSQL_RWLOCK_DESTROY(&lock);
   DBUG_VOID_RETURN;
 }
 
@@ -927,7 +927,7 @@ ulong Query_cache::resize(ulong query_ca
 
   STRUCT_LOCK(&structure_guard_mutex);
   while (is_flushing())
-    pthread_cond_wait(&COND_cache_status_changed, &structure_guard_mutex);
+    MYSQL_COND_WAIT(&COND_cache_status_changed, &structure_guard_mutex);
   m_cache_status= Query_cache::FLUSH_IN_PROGRESS;
   STRUCT_UNLOCK(&structure_guard_mutex);
 
@@ -963,7 +963,7 @@ ulong Query_cache::resize(ulong query_ca
 
   STRUCT_LOCK(&structure_guard_mutex);
   m_cache_status= Query_cache::NO_FLUSH_IN_PROGRESS;
-  pthread_cond_signal(&COND_cache_status_changed);
+  MYSQL_COND_SIGNAL(&COND_cache_status_changed);
   if (new_query_cache_size)
     DBUG_EXECUTE("check_querycache",check_integrity(1););
   STRUCT_UNLOCK(&structure_guard_mutex);
@@ -1639,7 +1639,7 @@ void Query_cache::wait_while_table_flush
       If a table flush is in progress; wait on cache status to change.
     */
     if (m_cache_status == Query_cache::TABLE_FLUSH_IN_PROGRESS)
-      pthread_cond_wait(&COND_cache_status_changed, &structure_guard_mutex);
+      MYSQL_COND_WAIT(&COND_cache_status_changed, &structure_guard_mutex);
   }
   *interrupt= FALSE;
 }
@@ -1809,8 +1809,8 @@ void Query_cache::destroy()
     free_cache();
     STRUCT_UNLOCK(&structure_guard_mutex);
 
-    pthread_cond_destroy(&COND_cache_status_changed);
-    pthread_mutex_destroy(&structure_guard_mutex);
+    MYSQL_COND_DESTROY(&COND_cache_status_changed);
+    MYSQL_MUTEX_DESTROY(&structure_guard_mutex);
     initialized = 0;
   }
   DBUG_VOID_RETURN;
@@ -1824,8 +1824,8 @@ void Query_cache::destroy()
 void Query_cache::init()
 {
   DBUG_ENTER("Query_cache::init");
-  pthread_mutex_init(&structure_guard_mutex,MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&COND_cache_status_changed, NULL);
+  MYSQL_MUTEX_INIT(&structure_guard_mutex, key_structure_guard_mutex, MY_MUTEX_INIT_FAST);
+  MYSQL_COND_INIT(&COND_cache_status_changed, key_COND_cache_status_changed, NULL);
   m_cache_status= Query_cache::NO_FLUSH_IN_PROGRESS;
   initialized = 1;
   DBUG_VOID_RETURN;
@@ -2074,7 +2074,7 @@ void Query_cache::flush_cache()
     flush the cache is empty.
   */
   while (is_flushing())
-    pthread_cond_wait(&COND_cache_status_changed, &structure_guard_mutex);
+    MYSQL_COND_WAIT(&COND_cache_status_changed, &structure_guard_mutex);
 
   /*
     Setting 'FLUSH_IN_PROGRESS' will prevent other threads from using
@@ -2093,7 +2093,7 @@ void Query_cache::flush_cache()
 
   STRUCT_LOCK(&structure_guard_mutex);
   m_cache_status= Query_cache::NO_FLUSH_IN_PROGRESS;
-  pthread_cond_signal(&COND_cache_status_changed);
+  MYSQL_COND_SIGNAL(&COND_cache_status_changed);
 }
 
 /*
@@ -2572,7 +2572,7 @@ void Query_cache::invalidate_table(THD *
     net_real_write might be waiting on a change on the m_cache_status
     variable.
   */
-  pthread_cond_signal(&COND_cache_status_changed);
+  MYSQL_COND_SIGNAL(&COND_cache_status_changed);
   STRUCT_UNLOCK(&structure_guard_mutex);
 }
 
@@ -3705,7 +3705,7 @@ my_bool Query_cache::move_by_type(uchar 
       } while ( result_block != first_result_block );
     }
     Query_cache_query *new_query= ((Query_cache_query *) new_block->data());
-    my_rwlock_init(&new_query->lock, NULL);
+    MYSQL_RWLOCK_INIT(&new_query->lock, key_QCQ_lock, NULL);
 
     /* 
       If someone is writing to this block, inform the writer that the block
@@ -4129,7 +4129,7 @@ my_bool Query_cache::check_integrity(boo
     STRUCT_LOCK(&structure_guard_mutex);
 
   while (is_flushing())
-    pthread_cond_wait(&COND_cache_status_changed,&structure_guard_mutex);
+    MYSQL_COND_WAIT(&COND_cache_status_changed,&structure_guard_mutex);
 
   if (hash_check(&queries))
   {

=== modified file 'sql/sql_cache.h'
--- a/sql/sql_cache.h	2008-08-10 14:49:52 +0000
+++ b/sql/sql_cache.h	2008-10-10 20:34:55 +0000
@@ -134,10 +134,14 @@ struct Query_cache_block
   inline Query_cache_block_table *table(TABLE_COUNTER_TYPE n);
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_rwlock_key key_QCQ_lock;
+#endif
+
 struct Query_cache_query
 {
   ulonglong limit_found_rows;
-  rw_lock_t lock;
+  mysql_rwlock_t lock;
   Query_cache_block *res;
   Query_cache_tls *wri;
   ulong len;
@@ -263,6 +267,11 @@ struct Query_cache_memory_bin_step
   }
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_structure_guard_mutex;
+extern PSI_cond_key key_COND_cache_status_changed;
+#endif
+
 class Query_cache
 {
 public:
@@ -274,7 +283,7 @@ public:
 
 
 private:
-  pthread_cond_t COND_cache_status_changed;
+  mysql_cond_t COND_cache_status_changed;
 
   enum Cache_status { NO_FLUSH_IN_PROGRESS, FLUSH_IN_PROGRESS,
                       TABLE_FLUSH_IN_PROGRESS };
@@ -299,7 +308,7 @@ protected:
     is other threads that were going to do cache flush---they'll wait
     till the end of a flush operation.
   */
-  pthread_mutex_t structure_guard_mutex;
+  mysql_mutex_t structure_guard_mutex;
   uchar *cache;					// cache memory
   Query_cache_block *first_block;		// physical location block list
   Query_cache_block *queries_blocks;		// query list (LIFO)

=== modified file 'sql/sql_class.cc'
--- a/sql/sql_class.cc	2008-09-16 08:34:30 +0000
+++ b/sql/sql_class.cc	2008-10-10 20:34:55 +0000
@@ -608,7 +608,7 @@ THD::THD()
 #ifdef SIGNAL_WITH_VIO_CLOSE
   active_vio = 0;
 #endif
-  pthread_mutex_init(&LOCK_delete, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_delete, key_LOCK_delete, MY_MUTEX_INIT_FAST);
 
   /* Variables with default values */
   proc_info="login";
@@ -738,7 +738,7 @@ void thd_get_xid(const MYSQL_THD thd, MY
 
 void THD::init(void)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   plugin_thdvar_init(this);
   variables.time_format= date_time_format_copy((THD*) 0,
 					       variables.time_format);
@@ -752,7 +752,7 @@ void THD::init(void)
     avoid temporary tables replication failure.
   */
   variables.pseudo_thread_id= thread_id;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   server_status= SERVER_STATUS_AUTOCOMMIT;
   if (variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES)
     server_status|= SERVER_STATUS_NO_BACKSLASH_ESCAPES;
@@ -817,9 +817,9 @@ void THD::init_for_queries()
 
 void THD::change_user(void)
 {
-  pthread_mutex_lock(&LOCK_status);
+  MYSQL_MUTEX_LOCK(&LOCK_status);
   add_to_status(&global_status_var, &status_var);
-  pthread_mutex_unlock(&LOCK_status);
+  MYSQL_MUTEX_UNLOCK(&LOCK_status);
 
   cleanup();
   killed= NOT_KILLED;
@@ -875,9 +875,9 @@ void THD::cleanup(void)
     unlock_global_read_lock(this);
   if (ull)
   {
-    pthread_mutex_lock(&LOCK_user_locks);
+    MYSQL_MUTEX_LOCK(&LOCK_user_locks);
     item_user_lock_release(ull);
-    pthread_mutex_unlock(&LOCK_user_locks);
+    MYSQL_MUTEX_UNLOCK(&LOCK_user_locks);
     ull= NULL;
   }
 
@@ -913,8 +913,8 @@ THD::~THD()
   THD_CHECK_SENTRY(this);
   DBUG_ENTER("~THD()");
   /* Ensure that no one is using THD */
-  pthread_mutex_lock(&LOCK_delete);
-  pthread_mutex_unlock(&LOCK_delete);
+  MYSQL_MUTEX_LOCK(&LOCK_delete);
+  MYSQL_MUTEX_UNLOCK(&LOCK_delete);
   add_to_status(&global_status_var, &status_var);
 
   /* Close connection */
@@ -943,7 +943,7 @@ THD::~THD()
   free_root(&warn_root,MYF(0));
   free_root(&transaction.mem_root,MYF(0));
   mysys_var=0;					// Safety (shouldn't be needed)
-  pthread_mutex_destroy(&LOCK_delete);
+  MYSQL_MUTEX_DESTROY(&LOCK_delete);
 #ifndef DBUG_OFF
   dbug_sentry= THD_SENTRY_GONE;
 #endif  
@@ -1018,7 +1018,7 @@ void THD::awake(THD::killed_state state_
   DBUG_ENTER("THD::awake");
   DBUG_PRINT("enter", ("this: %p", this));
   THD_CHECK_SENTRY(this);
-  safe_mutex_assert_owner(&LOCK_delete); 
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_delete); 
 
   killed= state_to_set;
   if (state_to_set != THD::KILL_QUERY)
@@ -1045,7 +1045,7 @@ void THD::awake(THD::killed_state state_
   }
   if (mysys_var)
   {
-    pthread_mutex_lock(&mysys_var->mutex);
+    MYSQL_MUTEX_LOCK(&mysys_var->mutex);
     if (system_thread == NON_SYSTEM_THREAD ||
         system_thread == SYSTEM_THREAD_BACKUP)
       mysys_var->abort= 1; // abort locks
@@ -1070,11 +1070,11 @@ void THD::awake(THD::killed_state state_
     */
     if (mysys_var->current_cond && 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);
+      MYSQL_MUTEX_LOCK(mysys_var->current_mutex);
+      MYSQL_COND_BROADCAST(mysys_var->current_cond);
+      MYSQL_MUTEX_UNLOCK(mysys_var->current_mutex);
     }
-    pthread_mutex_unlock(&mysys_var->mutex);
+    MYSQL_MUTEX_UNLOCK(&mysys_var->mutex);
   }
   DBUG_VOID_RETURN;
 }
@@ -1419,7 +1419,7 @@ int THD::send_explain_fields(select_resu
 void THD::close_active_vio()
 {
   DBUG_ENTER("close_active_vio");
-  safe_mutex_assert_owner(&LOCK_delete); 
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_delete); 
 #ifndef EMBEDDED_LIBRARY
   if (active_vio)
   {
@@ -2512,7 +2512,7 @@ int Statement_map::insert(THD *thd, Stat
     my_error(ER_OUT_OF_RESOURCES, MYF(0));
     goto err_names_hash;
   }
-  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_LOCK(&LOCK_prepared_stmt_count);
   /*
     We don't check that prepared_stmt_count is <= max_prepared_stmt_count
     because we would like to allow to lower the total limit
@@ -2522,13 +2522,13 @@ int Statement_map::insert(THD *thd, Stat
   */
   if (prepared_stmt_count >= max_prepared_stmt_count)
   {
-    pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
     my_error(ER_MAX_PREPARED_STMT_COUNT_REACHED, MYF(0),
              max_prepared_stmt_count);
     goto err_max;
   }
   prepared_stmt_count++;
-  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
 
   last_found_statement= statement;
   return 0;
@@ -2561,20 +2561,20 @@ void Statement_map::erase(Statement *sta
     hash_delete(&names_hash, (uchar *) statement);
 
   hash_delete(&st_hash, (uchar *) statement);
-  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_LOCK(&LOCK_prepared_stmt_count);
   DBUG_ASSERT(prepared_stmt_count > 0);
   prepared_stmt_count--;
-  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
 }
 
 
 void Statement_map::reset()
 {
   /* Must be first, hash_free will reset st_hash.records */
-  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_LOCK(&LOCK_prepared_stmt_count);
   DBUG_ASSERT(prepared_stmt_count >= st_hash.records);
   prepared_stmt_count-= st_hash.records;
-  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
 
   my_hash_reset(&names_hash);
   my_hash_reset(&st_hash);
@@ -2585,10 +2585,10 @@ void Statement_map::reset()
 Statement_map::~Statement_map()
 {
   /* Must go first, hash_free will reset st_hash.records */
-  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_LOCK(&LOCK_prepared_stmt_count);
   DBUG_ASSERT(prepared_stmt_count >= st_hash.records);
   prepared_stmt_count-= st_hash.records;
-  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_prepared_stmt_count);
 
   hash_free(&names_hash);
   hash_free(&st_hash);
@@ -3080,7 +3080,10 @@ void mark_transaction_to_rollback(THD *t
   Handling of XA id cacheing
 ***************************************************************************/
 
-pthread_mutex_t LOCK_xid_cache;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_xid_cache;
+#endif
+mysql_mutex_t LOCK_xid_cache;
 HASH xid_cache;
 
 extern "C" uchar *xid_get_hash_key(const uchar *, size_t *, my_bool);
@@ -3101,7 +3104,7 @@ void xid_free_hash(void *ptr)
 
 bool xid_cache_init()
 {
-  pthread_mutex_init(&LOCK_xid_cache, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_xid_cache, key_LOCK_xid_cache, MY_MUTEX_INIT_FAST);
   return hash_init(&xid_cache, &my_charset_bin, 100, 0, 0,
                    xid_get_hash_key, xid_free_hash, 0) != 0;
 }
@@ -3111,15 +3114,15 @@ void xid_cache_free()
   if (hash_inited(&xid_cache))
   {
     hash_free(&xid_cache);
-    pthread_mutex_destroy(&LOCK_xid_cache);
+    MYSQL_MUTEX_DESTROY(&LOCK_xid_cache);
   }
 }
 
 XID_STATE *xid_cache_search(XID *xid)
 {
-  pthread_mutex_lock(&LOCK_xid_cache);
+  MYSQL_MUTEX_LOCK(&LOCK_xid_cache);
   XID_STATE *res=(XID_STATE *)hash_search(&xid_cache, xid->key(), xid->key_length());
-  pthread_mutex_unlock(&LOCK_xid_cache);
+  MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
   return res;
 }
 
@@ -3128,7 +3131,7 @@ bool xid_cache_insert(XID *xid, enum xa_
 {
   XID_STATE *xs;
   my_bool res;
-  pthread_mutex_lock(&LOCK_xid_cache);
+  MYSQL_MUTEX_LOCK(&LOCK_xid_cache);
   if (hash_search(&xid_cache, xid->key(), xid->key_length()))
     res=0;
   else if (!(xs=(XID_STATE *)my_malloc(sizeof(*xs), MYF(MY_WME))))
@@ -3140,27 +3143,27 @@ bool xid_cache_insert(XID *xid, enum xa_
     xs->in_thd=0;
     res=my_hash_insert(&xid_cache, (uchar*)xs);
   }
-  pthread_mutex_unlock(&LOCK_xid_cache);
+  MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
   return res;
 }
 
 
 bool xid_cache_insert(XID_STATE *xid_state)
 {
-  pthread_mutex_lock(&LOCK_xid_cache);
+  MYSQL_MUTEX_LOCK(&LOCK_xid_cache);
   DBUG_ASSERT(hash_search(&xid_cache, xid_state->xid.key(),
                           xid_state->xid.key_length())==0);
   my_bool res=my_hash_insert(&xid_cache, (uchar*)xid_state);
-  pthread_mutex_unlock(&LOCK_xid_cache);
+  MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
   return res;
 }
 
 
 void xid_cache_delete(XID_STATE *xid_state)
 {
-  pthread_mutex_lock(&LOCK_xid_cache);
+  MYSQL_MUTEX_LOCK(&LOCK_xid_cache);
   hash_delete(&xid_cache, (uchar *)xid_state);
-  pthread_mutex_unlock(&LOCK_xid_cache);
+  MYSQL_MUTEX_UNLOCK(&LOCK_xid_cache);
 }
 
 /*

=== modified file 'sql/sql_class.h'
--- a/sql/sql_class.h	2008-09-05 14:16:07 +0000
+++ b/sql/sql_class.h	2008-10-10 20:34:55 +0000
@@ -804,7 +804,7 @@ typedef struct st_xid_state {
   bool in_thd;
 } XID_STATE;
 
-extern pthread_mutex_t LOCK_xid_cache;
+extern mysql_mutex_t LOCK_xid_cache;
 extern HASH xid_cache;
 bool xid_cache_init(void);
 void xid_cache_free(void);
@@ -1310,6 +1310,9 @@ struct Ha_data
   Ha_data() :ha_ptr(NULL) {}
 };
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_delete;
+#endif
 
 /**
   @class THD
@@ -1370,7 +1373,7 @@ public:
   THR_LOCK_OWNER main_lock_id;          // To use for conventional queries
   THR_LOCK_OWNER *lock_id;              // If not main_lock_id, points to
                                         // the lock_id of a cursor.
-  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
+  mysql_mutex_t LOCK_delete;		// Locked before thd is deleted
   /* all prepared statements and cursors of this connection */
   Statement_map stmt_map;
   /*
@@ -1986,15 +1989,15 @@ public:
 #ifdef SIGNAL_WITH_VIO_CLOSE
   inline void set_active_vio(Vio* vio)
   {
-    pthread_mutex_lock(&LOCK_delete);
+    MYSQL_MUTEX_LOCK(&LOCK_delete);
     active_vio = vio;
-    pthread_mutex_unlock(&LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&LOCK_delete);
   }
   inline void clear_active_vio()
   {
-    pthread_mutex_lock(&LOCK_delete);
+    MYSQL_MUTEX_LOCK(&LOCK_delete);
     active_vio = 0;
-    pthread_mutex_unlock(&LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&LOCK_delete);
   }
   void close_active_vio();
 #endif
@@ -2031,11 +2034,11 @@ public:
     enter_cond(); this mutex is then released by exit_cond().
     Usage must be: lock mutex; enter_cond(); your code; exit_cond().
   */
-  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
+  inline const char* enter_cond(mysql_cond_t *cond, mysql_mutex_t* mutex,
 			  const char* msg)
   {
     const char* old_msg = get_proc_info();
-    safe_mutex_assert_owner(mutex);
+    MYSQL_MUTEX_ASSERT_OWNER(mutex);
     mysys_var->current_mutex = mutex;
     mysys_var->current_cond = cond;
     thd_proc_info(this, msg);
@@ -2049,12 +2052,12 @@ public:
       locked (if that would not be the case, you'll get a deadlock if someone
       does a THD::awake() on you).
     */
-    pthread_mutex_unlock(mysys_var->current_mutex);
-    pthread_mutex_lock(&mysys_var->mutex);
+    MYSQL_MUTEX_UNLOCK(mysys_var->current_mutex);
+    MYSQL_MUTEX_LOCK(&mysys_var->mutex);
     mysys_var->current_mutex = 0;
     mysys_var->current_cond = 0;
     thd_proc_info(this, old_msg);
-    pthread_mutex_unlock(&mysys_var->mutex);
+    MYSQL_MUTEX_UNLOCK(&mysys_var->mutex);
   }
   inline time_t query_start() { query_start_used=1; return start_time; }
   inline void set_time()

=== modified file 'sql/sql_connect.cc'
--- a/sql/sql_connect.cc	2008-06-27 09:26:03 +0000
+++ b/sql/sql_connect.cc	2008-10-10 20:34:55 +0000
@@ -64,7 +64,7 @@ static int get_or_create_user_conn(THD *
 
   user_len= strlen(user);
   temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
-  (void) pthread_mutex_lock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_user_conn);
   if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
 					       (uchar*) temp_user, temp_len)))
   {
@@ -95,7 +95,7 @@ static int get_or_create_user_conn(THD *
   thd->user_connect=uc;
   uc->connections++;
 end:
-  (void) pthread_mutex_unlock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_user_conn);
   return return_val;
 
 }
@@ -124,7 +124,7 @@ int check_for_max_user_connections(THD *
   int error=0;
   DBUG_ENTER("check_for_max_user_connections");
 
-  (void) pthread_mutex_lock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_user_conn);
   if (max_user_connections && !uc->user_resources.user_conn &&
       max_user_connections < (uint) uc->connections)
   {
@@ -164,7 +164,7 @@ end:
     */
     thd->user_connect= NULL;
   }
-  (void) pthread_mutex_unlock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_user_conn);
   DBUG_RETURN(error);
 }
 
@@ -190,14 +190,14 @@ end:
 void decrease_user_connections(USER_CONN *uc)
 {
   DBUG_ENTER("decrease_user_connections");
-  (void) pthread_mutex_lock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_user_conn);
   DBUG_ASSERT(uc->connections);
   if (!--uc->connections && !mqh_used)
   {
     /* Last connection for user; Delete it */
     (void) hash_delete(&hash_user_connections,(uchar*) uc);
   }
-  (void) pthread_mutex_unlock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_user_conn);
   DBUG_VOID_RETURN;
 }
 
@@ -245,7 +245,7 @@ bool check_mqh(THD *thd, uint check_comm
   DBUG_ENTER("check_mqh");
   DBUG_ASSERT(uc != 0);
 
-  (void) pthread_mutex_lock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_user_conn);
 
   time_out_user_resource_limits(thd, uc);
 
@@ -272,7 +272,7 @@ bool check_mqh(THD *thd, uint check_comm
     }
   }
 end:
-  (void) pthread_mutex_unlock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_user_conn);
   DBUG_RETURN(error);
 }
 
@@ -333,9 +333,9 @@ check_user(THD *thd, enum enum_server_co
 #else
 
   my_bool opt_secure_auth_local;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   opt_secure_auth_local= opt_secure_auth;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   
   /*
     If the server is running in secure auth mode, short scrambles are 
@@ -412,10 +412,10 @@ check_user(THD *thd, enum enum_server_co
 
       if (check_count)
       {
-        pthread_mutex_lock(&LOCK_connection_count);
+        MYSQL_MUTEX_LOCK(&LOCK_connection_count);
         bool count_ok= connection_count <= max_connections ||
                        (thd->main_security_ctx.master_access & SUPER_ACL);
-        pthread_mutex_unlock(&LOCK_connection_count);
+        MYSQL_MUTEX_UNLOCK(&LOCK_connection_count);
 
         if (!count_ok)
         {                                         // too many connections
@@ -560,7 +560,7 @@ void free_max_user_conn(void)
 void reset_mqh(LEX_USER *lu, bool get_them= 0)
 {
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
-  (void) pthread_mutex_lock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_user_conn);
   if (lu)  // for GRANT
   {
     USER_CONN *uc;
@@ -593,7 +593,7 @@ void reset_mqh(LEX_USER *lu, bool get_th
       uc->conn_per_hour=0;
     }
   }
-  (void) pthread_mutex_unlock(&LOCK_user_conn);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_user_conn);
 #endif /* NO_EMBEDDED_ACCESS_CHECKS */
 }
 

=== modified file 'sql/sql_db.cc'
--- a/sql/sql_db.cc	2008-08-27 08:47:03 +0000
+++ b/sql/sql_db.cc	2008-10-10 20:34:55 +0000
@@ -47,7 +47,7 @@ static void mysql_change_db_impl(THD *th
 
 /* Database lock hash */
 HASH lock_db_cache;
-pthread_mutex_t LOCK_lock_db;
+mysql_mutex_t LOCK_lock_db;
 int creating_database= 0;  // how many database locks are made
 
 
@@ -103,7 +103,7 @@ static my_bool lock_db_insert(const char
   my_bool error= 0;
   DBUG_ENTER("lock_db_insert");
   
-  safe_mutex_assert_owner(&LOCK_lock_db);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_lock_db);
 
   if (!(opt= (my_dblock_t*) hash_search(&lock_db_cache,
                                         (uchar*) dbname, length)))
@@ -138,7 +138,7 @@ end:
 void lock_db_delete(const char *name, uint length)
 {
   my_dblock_t *opt;
-  safe_mutex_assert_owner(&LOCK_lock_db);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_lock_db);
   if ((opt= (my_dblock_t *)hash_search(&lock_db_cache,
                                        (const uchar*) name, length)))
     hash_delete(&lock_db_cache, (uchar*) opt);
@@ -148,7 +148,12 @@ void lock_db_delete(const char *name, ui
 /* Database options hash */
 static HASH dboptions;
 static my_bool dboptions_init= 0;
-static rw_lock_t LOCK_dboptions;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_rwlock_key key_LOCK_dboptions;
+#endif
+
+static mysql_rwlock_t LOCK_dboptions;
 
 /* Structure for database options */
 typedef struct my_dbopt_st
@@ -218,7 +223,7 @@ void free_dbopt(void *dbopt)
 bool my_database_names_init(void)
 {
   bool error= 0;
-  (void) my_rwlock_init(&LOCK_dboptions, NULL);
+  (void) MYSQL_RWLOCK_INIT(&LOCK_dboptions, key_LOCK_dboptions, NULL);
   if (!dboptions_init)
   {
     dboptions_init= 1;
@@ -247,7 +252,7 @@ void my_database_names_free(void)
   {
     dboptions_init= 0;
     hash_free(&dboptions);
-    (void) rwlock_destroy(&LOCK_dboptions);
+    (void) MYSQL_RWLOCK_DESTROY(&LOCK_dboptions);
     hash_free(&lock_db_cache);
   }
 }
@@ -259,13 +264,13 @@ void my_database_names_free(void)
 
 void my_dbopt_cleanup(void)
 {
-  rw_wrlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_dboptions);
   hash_free(&dboptions);
   hash_init(&dboptions, lower_case_table_names ? 
             &my_charset_bin : system_charset_info,
             32, 0, 0, (hash_get_key) dboptions_get_key,
             free_dbopt,0);
-  rw_unlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_dboptions);
 }
 
 
@@ -289,13 +294,13 @@ static my_bool get_dbopt(const char *dbn
   
   length= (uint) strlen(dbname);
   
-  rw_rdlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_dboptions);
   if ((opt= (my_dbopt_t*) hash_search(&dboptions, (uchar*) dbname, length)))
   {
     create->default_table_charset= opt->charset;
     error= 0;
   }
-  rw_unlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_dboptions);
   return error;
 }
 
@@ -321,7 +326,7 @@ static my_bool put_dbopt(const char *dbn
 
   length= (uint) strlen(dbname);
   
-  rw_wrlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_dboptions);
   if (!(opt= (my_dbopt_t*) hash_search(&dboptions, (uchar*) dbname, length)))
   { 
     /* Options are not in the hash, insert them */
@@ -349,7 +354,7 @@ static my_bool put_dbopt(const char *dbn
   opt->charset= create->default_table_charset;
 
 end:
-  rw_unlock(&LOCK_dboptions);  
+  MYSQL_RWLOCK_UNLOCK(&LOCK_dboptions);  
   DBUG_RETURN(error);
 }
 
@@ -361,11 +366,11 @@ end:
 void del_dbopt(const char *path)
 {
   my_dbopt_t *opt;
-  rw_wrlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_dboptions);
   if ((opt= (my_dbopt_t *)hash_search(&dboptions, (const uchar*) path,
                                       strlen(path))))
     hash_delete(&dboptions, (uchar*) opt);
-  rw_unlock(&LOCK_dboptions);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_dboptions);
 }
 
 
@@ -643,7 +648,7 @@ int mysql_create_db(THD *thd, char *db, 
     goto exit2;
   }
 
-  pthread_mutex_lock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_LOCK(&LOCK_mysql_create_db);
 
   /* Check directory */
   path_len= build_table_filename(path, sizeof(path), db, "", "", 0);
@@ -753,7 +758,7 @@ int mysql_create_db(THD *thd, char *db, 
   }
 
 exit:
-  pthread_mutex_unlock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -784,7 +789,7 @@ bool mysql_alter_db(THD *thd, const char
   if ((error=wait_if_global_read_lock(thd,0,1)))
     goto exit2;
 
-  pthread_mutex_lock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_LOCK(&LOCK_mysql_create_db);
 
   /* 
      Recreate db options file: /dbpath/.db.opt
@@ -829,7 +834,7 @@ bool mysql_alter_db(THD *thd, const char
   my_ok(thd, result);
 
 exit:
-  pthread_mutex_unlock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -881,7 +886,7 @@ bool mysql_rm_db(THD *thd,char *db,bool 
     goto exit2;
   }
 
-  pthread_mutex_lock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_LOCK(&LOCK_mysql_create_db);
 
   length= build_table_filename(path, sizeof(path), db, "", "", 0);
   strmov(path+length, MY_DB_OPT_FILE);		// Append db option file name
@@ -1020,7 +1025,7 @@ exit:
   */
   if (thd->db && !strcmp(thd->db, db) && error == 0)
     mysql_change_db_impl(thd, NULL, 0, thd->variables.collation_server);
-  pthread_mutex_unlock(&LOCK_mysql_create_db);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -1706,18 +1711,18 @@ static int
 lock_databases(THD *thd, const char *db1, uint length1,
                          const char *db2, uint length2)
 {
-  pthread_mutex_lock(&LOCK_lock_db);
+  MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   while (!thd->killed &&
          (hash_search(&lock_db_cache,(uchar*) db1, length1) ||
           hash_search(&lock_db_cache,(uchar*) db2, length2)))
   {
     wait_for_condition(thd, &LOCK_lock_db, &COND_refresh);
-    pthread_mutex_lock(&LOCK_lock_db);
+    MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   }
 
   if (thd->killed)
   {
-    pthread_mutex_unlock(&LOCK_lock_db);
+    MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
     return 1;
   }
 
@@ -1734,7 +1739,7 @@ lock_databases(THD *thd, const char *db1
   while (!thd->killed && creating_table)
   {
     wait_for_condition(thd, &LOCK_lock_db, &COND_refresh);
-    pthread_mutex_lock(&LOCK_lock_db);
+    MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   }
 
   if (thd->killed)
@@ -1742,8 +1747,8 @@ lock_databases(THD *thd, const char *db1
     lock_db_delete(db1, length1);
     lock_db_delete(db2, length2);
     creating_database--;
-    pthread_mutex_unlock(&LOCK_lock_db);
-    pthread_cond_signal(&COND_refresh);
+    MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
+    MYSQL_COND_SIGNAL(&COND_refresh);
     return(1);
   }
 
@@ -1751,7 +1756,7 @@ lock_databases(THD *thd, const char *db1
     We can unlock now as the hash will protect against anyone creating a table
     in the databases we are using
   */
-  pthread_mutex_unlock(&LOCK_lock_db);
+  MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
   return 0;
 }
 
@@ -1962,14 +1967,14 @@ bool mysql_upgrade_db(THD *thd, LEX_STRI
     error|= mysql_change_db(thd, & new_db, FALSE);
 
 exit:
-  pthread_mutex_lock(&LOCK_lock_db);
+  MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   /* Remove the databases from db lock cache */
   lock_db_delete(old_db->str, old_db->length);
   lock_db_delete(new_db.str, new_db.length);
   creating_database--;
   /* Signal waiting CREATE TABLE's to continue */
-  pthread_cond_signal(&COND_refresh);
-  pthread_mutex_unlock(&LOCK_lock_db);
+  MYSQL_COND_SIGNAL(&COND_refresh);
+  MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
 
   DBUG_RETURN(error);
 }

=== modified file 'sql/sql_delete.cc'
--- a/sql/sql_delete.cc	2008-07-26 16:38:20 +0000
+++ b/sql/sql_delete.cc	2008-10-10 20:34:55 +0000
@@ -1044,10 +1044,10 @@ bool mysql_truncate(THD *thd, TABLE_LIST
       mdl_remove_lock(&thd->mdl_context, mdl_lock_data);
       DBUG_RETURN(TRUE);
     }
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table_list->db,
                      table_list->table_name);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
   }
 
   /*
@@ -1056,10 +1056,10 @@ bool mysql_truncate(THD *thd, TABLE_LIST
      '\0';
   */
   path[path_length - reg_ext_length] = 0;
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   error= ha_create_table(thd, path, table_list->db, table_list->table_name,
                          &create_info, 1);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   query_cache_invalidate3(thd, table_list, 0);
 
 end:

=== modified file 'sql/sql_handler.cc'
--- a/sql/sql_handler.cc	2008-08-07 17:52:43 +0000
+++ b/sql/sql_handler.cc	2008-10-10 20:34:55 +0000
@@ -142,13 +142,13 @@ static void mysql_ha_close_table(THD *th
   {
     (*table_ptr)->file->ha_index_or_rnd_end();
     mdl_lock_data= (*table_ptr)->mdl_lock_data;
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     if (close_thread_table(thd, table_ptr))
     {
       /* Tell threads waiting for refresh that something has happened */
       broadcast_refresh();
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     mdl_release_lock(&thd->handler_mdl_context, mdl_lock_data);
     mdl_remove_lock(&thd->handler_mdl_context, mdl_lock_data);
   }
@@ -768,7 +768,7 @@ void mysql_ha_flush(THD *thd)
   TABLE_LIST *hash_tables;
   DBUG_ENTER("mysql_ha_flush");
 
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   for (uint i= 0; i < thd->handler_tables_hash.records; i++)
   {

=== modified file 'sql/sql_insert.cc'
--- a/sql/sql_insert.cc	2008-09-16 17:58:49 +0000
+++ b/sql/sql_insert.cc	2008-10-10 20:34:55 +0000
@@ -1707,6 +1707,12 @@ public:
   }
 };
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_Delayed_insert_mutex;
+PSI_cond_key key_Delayed_insert_cond;
+PSI_cond_key key_Delayed_insert_cond_client;
+#endif
+
 /**
   Delayed_insert - context of a thread responsible for delayed insert
   into one table. When processing delayed inserts, we create an own
@@ -1719,8 +1725,8 @@ class Delayed_insert :public ilink {
 public:
   THD thd;
   TABLE *table;
-  pthread_mutex_t mutex;
-  pthread_cond_t cond,cond_client;
+  mysql_mutex_t mutex;
+  mysql_cond_t cond,cond_client;
   volatile uint tables_in_use,stacked_inserts;
   volatile bool status,dead;
   COPY_INFO info;
@@ -1752,12 +1758,12 @@ public:
     thd.system_thread= SYSTEM_THREAD_DELAYED_INSERT;
     thd.security_ctx->host_or_ip= "";
     bzero((char*) &info,sizeof(info));
-    pthread_mutex_init(&mutex,MY_MUTEX_INIT_FAST);
-    pthread_cond_init(&cond,NULL);
-    pthread_cond_init(&cond_client,NULL);
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_INIT(&mutex, key_Delayed_insert_mutex, MY_MUTEX_INIT_FAST);
+    MYSQL_COND_INIT(&cond, key_Delayed_insert_cond, NULL);
+    MYSQL_COND_INIT(&cond_client, key_Delayed_insert_cond_client, NULL);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     delayed_insert_threads++;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   }
   ~Delayed_insert()
   {
@@ -1767,17 +1773,17 @@ public:
       delete row;
     if (table)
       close_thread_tables(&thd);
-    pthread_mutex_lock(&LOCK_thread_count);
-    pthread_mutex_destroy(&mutex);
-    pthread_cond_destroy(&cond);
-    pthread_cond_destroy(&cond_client);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
+    MYSQL_MUTEX_DESTROY(&mutex);
+    MYSQL_COND_DESTROY(&cond);
+    MYSQL_COND_DESTROY(&cond_client);
     thd.unlink();				// Must be unlinked under lock
     x_free(thd.query);
     thd.security_ctx->user= thd.security_ctx->host=0;
     thread_count--;
     delayed_insert_threads--;
-    pthread_mutex_unlock(&LOCK_thread_count);
-    pthread_cond_broadcast(&COND_thread_count); /* Tell main we are ready */
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
+    MYSQL_COND_BROADCAST(&COND_thread_count); /* Tell main we are ready */
   }
 
   /* The following is for checking when we can delete ourselves */
@@ -1787,18 +1793,18 @@ public:
   }
   void unlock()
   {
-    pthread_mutex_lock(&LOCK_delayed_insert);
+    MYSQL_MUTEX_LOCK(&LOCK_delayed_insert);
     if (!--locks_in_memory)
     {
-      pthread_mutex_lock(&mutex);
+      MYSQL_MUTEX_LOCK(&mutex);
       if (thd.killed && ! stacked_inserts && ! tables_in_use)
       {
-	pthread_cond_signal(&cond);
+	MYSQL_COND_SIGNAL(&cond);
 	status=1;
       }
-      pthread_mutex_unlock(&mutex);
+      MYSQL_MUTEX_UNLOCK(&mutex);
     }
-    pthread_mutex_unlock(&LOCK_delayed_insert);
+    MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert);
   }
   inline uint lock_count() { return locks_in_memory; }
 
@@ -1820,7 +1826,7 @@ static
 Delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list)
 {
   thd_proc_info(thd, "waiting for delay_list");
-  pthread_mutex_lock(&LOCK_delayed_insert);	// Protect master list
+  MYSQL_MUTEX_LOCK(&LOCK_delayed_insert);	// Protect master list
   I_List_iterator<Delayed_insert> it(delayed_threads);
   Delayed_insert *di;
   while ((di= it++))
@@ -1832,7 +1838,7 @@ Delayed_insert *find_handler(THD *thd, T
       break;
     }
   }
-  pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
+  MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert); // For unlink from list
   return di;
 }
 
@@ -1902,7 +1908,7 @@ bool delayed_get_table(THD *thd, TABLE_L
     if (delayed_insert_threads >= thd->variables.max_insert_delayed_threads)
       DBUG_RETURN(0);
     thd_proc_info(thd, "Creating delayed handler");
-    pthread_mutex_lock(&LOCK_delayed_create);
+    MYSQL_MUTEX_LOCK(&LOCK_delayed_create);
     /*
       The first search above was done without LOCK_delayed_create.
       Another thread might have created the handler in between. Search again.
@@ -1911,9 +1917,9 @@ bool delayed_get_table(THD *thd, TABLE_L
     {
       if (!(di= new Delayed_insert()))
         goto end_create;
-      pthread_mutex_lock(&LOCK_thread_count);
+      MYSQL_MUTEX_LOCK(&LOCK_thread_count);
       thread_count++;
-      pthread_mutex_unlock(&LOCK_thread_count);
+      MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       di->thd.set_db(table_list->db, strlen(table_list->db));
       di->thd.query= my_strdup(table_list->table_name, MYF(MY_WME | ME_FATALERROR));
       if (di->thd.db == NULL || di->thd.query == NULL)
@@ -1927,14 +1933,14 @@ bool delayed_get_table(THD *thd, TABLE_L
       di->table_list.alias= di->table_list.table_name= di->thd.query;
       di->table_list.db= di->thd.db;
       di->lock();
-      pthread_mutex_lock(&di->mutex);
+      MYSQL_MUTEX_LOCK(&di->mutex);
       if ((error= pthread_create(&di->thd.real_id, &connection_attrib,
                                  handle_delayed_insert, (void*) di)))
       {
 	DBUG_PRINT("error",
 		   ("Can't create thread to handle delayed insert (error %d)",
 		    error));
-	pthread_mutex_unlock(&di->mutex);
+	MYSQL_MUTEX_UNLOCK(&di->mutex);
 	di->unlock();
 	delete di;
 	my_error(ER_CANT_CREATE_THREAD, MYF(ME_FATALERROR), error);
@@ -1945,9 +1951,9 @@ bool delayed_get_table(THD *thd, TABLE_L
       thd_proc_info(thd, "waiting for handler open");
       while (!di->thd.killed && !di->table && !thd->killed)
       {
-	pthread_cond_wait(&di->cond_client, &di->mutex);
+	MYSQL_COND_WAIT(&di->cond_client, &di->mutex);
       }
-      pthread_mutex_unlock(&di->mutex);
+      MYSQL_MUTEX_UNLOCK(&di->mutex);
       thd_proc_info(thd, "got old table");
       if (di->thd.killed)
       {
@@ -1970,16 +1976,16 @@ bool delayed_get_table(THD *thd, TABLE_L
 	di->unlock();
 	goto end_create;
       }
-      pthread_mutex_lock(&LOCK_delayed_insert);
+      MYSQL_MUTEX_LOCK(&LOCK_delayed_insert);
       delayed_threads.append(di);
-      pthread_mutex_unlock(&LOCK_delayed_insert);
+      MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert);
     }
-    pthread_mutex_unlock(&LOCK_delayed_create);
+    MYSQL_MUTEX_UNLOCK(&LOCK_delayed_create);
   }
 
-  pthread_mutex_lock(&di->mutex);
+  MYSQL_MUTEX_LOCK(&di->mutex);
   table_list->table= di->get_local_table(thd);
-  pthread_mutex_unlock(&di->mutex);
+  MYSQL_MUTEX_UNLOCK(&di->mutex);
   if (table_list->table)
   {
     DBUG_ASSERT(! thd->is_error());
@@ -1990,7 +1996,7 @@ bool delayed_get_table(THD *thd, TABLE_L
   DBUG_RETURN((table_list->table == NULL));
 
 end_create:
-  pthread_mutex_unlock(&LOCK_delayed_create);
+  MYSQL_MUTEX_UNLOCK(&LOCK_delayed_create);
   DBUG_RETURN(thd->is_error());
 }
 
@@ -2026,10 +2032,10 @@ TABLE *Delayed_insert::get_local_table(T
   if (!thd.lock)				// Table is not locked
   {
     thd_proc_info(client_thd, "waiting for handler lock");
-    pthread_cond_signal(&cond);			// Tell handler to lock table
+    MYSQL_COND_SIGNAL(&cond);			// Tell handler to lock table
     while (!dead && !thd.lock && ! client_thd->killed)
     {
-      pthread_cond_wait(&cond_client,&mutex);
+      MYSQL_COND_WAIT(&cond_client,&mutex);
     }
     thd_proc_info(client_thd, "got handler lock");
     if (client_thd->killed)
@@ -2116,7 +2122,7 @@ TABLE *Delayed_insert::get_local_table(T
  error:
   tables_in_use--;
   status=1;
-  pthread_cond_signal(&cond);			// Inform thread about abort
+  MYSQL_COND_SIGNAL(&cond);			// Inform thread about abort
   DBUG_RETURN(0);
 }
 
@@ -2135,9 +2141,9 @@ int write_delayed(THD *thd, TABLE *table
                        (ulong) query.length));
 
   thd_proc_info(thd, "waiting for handler insert");
-  pthread_mutex_lock(&di->mutex);
+  MYSQL_MUTEX_LOCK(&di->mutex);
   while (di->stacked_inserts >= delayed_queue_size && !thd->killed)
-    pthread_cond_wait(&di->cond_client,&di->mutex);
+    MYSQL_COND_WAIT(&di->cond_client,&di->mutex);
   thd_proc_info(thd, "storing row into queue");
 
   if (thd->killed)
@@ -2199,15 +2205,15 @@ int write_delayed(THD *thd, TABLE *table
   di->status=1;
   if (table->s->blob_fields)
     unlink_blobs(table);
-  pthread_cond_signal(&di->cond);
+  MYSQL_COND_SIGNAL(&di->cond);
 
   thread_safe_increment(delayed_rows_in_use,&LOCK_delayed_status);
-  pthread_mutex_unlock(&di->mutex);
+  MYSQL_MUTEX_UNLOCK(&di->mutex);
   DBUG_RETURN(0);
 
  err:
   delete row;
-  pthread_mutex_unlock(&di->mutex);
+  MYSQL_MUTEX_UNLOCK(&di->mutex);
   DBUG_RETURN(1);
 }
 
@@ -2220,14 +2226,14 @@ static void end_delayed_insert(THD *thd)
 {
   DBUG_ENTER("end_delayed_insert");
   Delayed_insert *di=thd->di;
-  pthread_mutex_lock(&di->mutex);
+  MYSQL_MUTEX_LOCK(&di->mutex);
   DBUG_PRINT("info",("tables in use: %d",di->tables_in_use));
   if (!--di->tables_in_use || di->thd.killed)
   {						// Unlock table
     di->status=1;
-    pthread_cond_signal(&di->cond);
+    MYSQL_COND_SIGNAL(&di->cond);
   }
-  pthread_mutex_unlock(&di->mutex);
+  MYSQL_MUTEX_UNLOCK(&di->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -2236,7 +2242,7 @@ static void end_delayed_insert(THD *thd)
 
 void kill_delayed_threads(void)
 {
-  pthread_mutex_lock(&LOCK_delayed_insert); // For unlink from list
+  MYSQL_MUTEX_LOCK(&LOCK_delayed_insert); // For unlink from list
 
   I_List_iterator<Delayed_insert> it(delayed_threads);
   Delayed_insert *di;
@@ -2245,7 +2251,7 @@ void kill_delayed_threads(void)
     di->thd.killed= THD::KILL_CONNECTION;
     if (di->thd.mysys_var)
     {
-      pthread_mutex_lock(&di->thd.mysys_var->mutex);
+      MYSQL_MUTEX_LOCK(&di->thd.mysys_var->mutex);
       if (di->thd.mysys_var->current_cond)
       {
 	/*
@@ -2253,15 +2259,15 @@ void kill_delayed_threads(void)
 	  in handle_delayed_insert()
 	*/
 	if (&di->mutex != di->thd.mysys_var->current_mutex)
-	  pthread_mutex_lock(di->thd.mysys_var->current_mutex);
-	pthread_cond_broadcast(di->thd.mysys_var->current_cond);
+	  MYSQL_MUTEX_LOCK(di->thd.mysys_var->current_mutex);
+	MYSQL_COND_BROADCAST(di->thd.mysys_var->current_cond);
 	if (&di->mutex != di->thd.mysys_var->current_mutex)
-	  pthread_mutex_unlock(di->thd.mysys_var->current_mutex);
+	  MYSQL_MUTEX_UNLOCK(di->thd.mysys_var->current_mutex);
       }
-      pthread_mutex_unlock(&di->thd.mysys_var->mutex);
+      MYSQL_MUTEX_UNLOCK(&di->thd.mysys_var->mutex);
     }
   }
-  pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
+  MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert); // For unlink from list
 }
 
 
@@ -2312,22 +2318,22 @@ pthread_handler_t handle_delayed_insert(
 
   pthread_detach_this_thread();
   /* Add thread to THD list so that's it's visible in 'show processlist' */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
   thd->set_current_time();
   threads.append(thd);
   thd->killed=abort_loop ? THD::KILL_CONNECTION : THD::NOT_KILLED;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   /*
-    Wait until the client runs into pthread_cond_wait(),
+    Wait until the client runs into MYSQL_COND_WAIT(),
     where we free it after the table is opened and di linked in the list.
     If we did not wait here, the client might detect the opened table
     before it is linked to the list. It would release LOCK_delayed_create
     and allow another thread to create another handler for the same table,
     since it does not find one in the list.
   */
-  pthread_mutex_lock(&di->mutex);
+  MYSQL_MUTEX_LOCK(&di->mutex);
 #if !defined( __WIN__) /* Win32 calls this in pthread_create */
   if (my_thread_init())
   {
@@ -2369,7 +2375,7 @@ pthread_handler_t handle_delayed_insert(
     goto err;
 
   /* Tell client that the thread is initialized */
-  pthread_cond_signal(&di->cond_client);
+  MYSQL_COND_SIGNAL(&di->cond_client);
 
   /* Now wait until we get an insert or lock to handle */
   /* We will not abort as long as a client thread uses this thread */
@@ -2383,12 +2389,12 @@ pthread_handler_t handle_delayed_insert(
 	Remove this from delay insert list so that no one can request a
 	table from this
       */
-      pthread_mutex_unlock(&di->mutex);
-      pthread_mutex_lock(&LOCK_delayed_insert);
+      MYSQL_MUTEX_UNLOCK(&di->mutex);
+      MYSQL_MUTEX_LOCK(&LOCK_delayed_insert);
       di->unlink();
       lock_count=di->lock_count();
-      pthread_mutex_unlock(&LOCK_delayed_insert);
-      pthread_mutex_lock(&di->mutex);
+      MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert);
+      MYSQL_MUTEX_LOCK(&di->mutex);
       if (!lock_count && !di->tables_in_use && !di->stacked_inserts)
 	break;					// Time to die
     }
@@ -2409,14 +2415,14 @@ pthread_handler_t handle_delayed_insert(
 	int error;
         mysql_audit_release(thd);
 #if defined(HAVE_BROKEN_COND_TIMEDWAIT)
-	error=pthread_cond_wait(&di->cond,&di->mutex);
+	error=MYSQL_COND_WAIT(&di->cond,&di->mutex);
 #else
-	error=pthread_cond_timedwait(&di->cond,&di->mutex,&abstime);
+	error=MYSQL_COND_TIMEDWAIT(&di->cond,&di->mutex,&abstime);
 #ifdef EXTRA_DEBUG
 	if (error && error != EINTR && error != ETIMEDOUT)
 	{
-	  fprintf(stderr, "Got error %d from pthread_cond_timedwait\n",error);
-	  DBUG_PRINT("error",("Got error %d from pthread_cond_timedwait",
+	  fprintf(stderr, "Got error %d from MYSQL_COND_TIMEDWAIT\n",error);
+	  DBUG_PRINT("error",("Got error %d from MYSQL_COND_TIMEDWAIT",
 			      error));
 	}
 #endif
@@ -2430,12 +2436,12 @@ pthread_handler_t handle_delayed_insert(
 	}
       }
       /* 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);
+      MYSQL_MUTEX_UNLOCK(&di->mutex);
+      MYSQL_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);
+      MYSQL_MUTEX_UNLOCK(&di->thd.mysys_var->mutex);
+      MYSQL_MUTEX_LOCK(&di->mutex);
     }
     thd_proc_info(&(di->thd), 0);
 
@@ -2478,7 +2484,7 @@ pthread_handler_t handle_delayed_insert(
           thd->killed= THD::KILL_CONNECTION;
         }
       }
-      pthread_cond_broadcast(&di->cond_client);
+      MYSQL_COND_BROADCAST(&di->cond_client);
     }
     if (di->stacked_inserts)
     {
@@ -2498,7 +2504,7 @@ pthread_handler_t handle_delayed_insert(
       */
       MYSQL_LOCK *lock=thd->lock;
       thd->lock=0;
-      pthread_mutex_unlock(&di->mutex);
+      MYSQL_MUTEX_UNLOCK(&di->mutex);
       /*
         We need to release next_insert_id before unlocking. This is
         enforced by handler::ha_external_lock().
@@ -2508,10 +2514,10 @@ pthread_handler_t handle_delayed_insert(
       trans_commit_stmt(thd);
       di->group_count=0;
       mysql_audit_release(thd);
-      pthread_mutex_lock(&di->mutex);
+      MYSQL_MUTEX_LOCK(&di->mutex);
     }
     if (di->tables_in_use)
-      pthread_cond_broadcast(&di->cond_client); // If waiting clients
+      MYSQL_COND_BROADCAST(&di->cond_client); // If waiting clients
   }
 
 err:
@@ -2540,14 +2546,14 @@ end:
   di->table=0;
   di->dead= 1;                                  // If error
   thd->killed= THD::KILL_CONNECTION;	        // If error
-  pthread_cond_broadcast(&di->cond_client);	// Safety
-  pthread_mutex_unlock(&di->mutex);
+  MYSQL_COND_BROADCAST(&di->cond_client);	// Safety
+  MYSQL_MUTEX_UNLOCK(&di->mutex);
 
-  pthread_mutex_lock(&LOCK_delayed_create);	// Because of delayed_get_table
-  pthread_mutex_lock(&LOCK_delayed_insert);	
+  MYSQL_MUTEX_LOCK(&LOCK_delayed_create);	// Because of delayed_get_table
+  MYSQL_MUTEX_LOCK(&LOCK_delayed_insert);	
   delete di;
-  pthread_mutex_unlock(&LOCK_delayed_insert);
-  pthread_mutex_unlock(&LOCK_delayed_create);  
+  MYSQL_MUTEX_UNLOCK(&LOCK_delayed_insert);
+  MYSQL_MUTEX_UNLOCK(&LOCK_delayed_create);  
 
   my_thread_end();
   pthread_exit(0);
@@ -2593,7 +2599,7 @@ bool Delayed_insert::handle_inserts(void
   DBUG_ENTER("handle_inserts");
 
   /* Allow client to insert new rows */
-  pthread_mutex_unlock(&mutex);
+  MYSQL_MUTEX_UNLOCK(&mutex);
 
   table->next_number_field=table->found_next_number_field;
   table->use_all_columns();
@@ -2621,12 +2627,12 @@ bool Delayed_insert::handle_inserts(void
   */
   if (!using_bin_log)
     table->file->extra(HA_EXTRA_WRITE_CACHE);
-  pthread_mutex_lock(&mutex);
+  MYSQL_MUTEX_LOCK(&mutex);
 
   while ((row=rows.get()))
   {
     stacked_inserts--;
-    pthread_mutex_unlock(&mutex);
+    MYSQL_MUTEX_UNLOCK(&mutex);
     memcpy(table->record[0],row->record,table->s->reclength);
 
     thd.start_time=row->start_time;
@@ -2727,7 +2733,7 @@ bool Delayed_insert::handle_inserts(void
       free_delayed_insert_blobs(table);
     thread_safe_decrement(delayed_rows_in_use,&LOCK_delayed_status);
     thread_safe_increment(delayed_insert_writes,&LOCK_delayed_status);
-    pthread_mutex_lock(&mutex);
+    MYSQL_MUTEX_LOCK(&mutex);
 
     delete row;
     /*
@@ -2743,9 +2749,9 @@ bool Delayed_insert::handle_inserts(void
       if (stacked_inserts || tables_in_use)	// Let these wait a while
       {
 	if (tables_in_use)
-	  pthread_cond_broadcast(&cond_client); // If waiting clients
+	  MYSQL_COND_BROADCAST(&cond_client); // If waiting clients
 	thd_proc_info(&thd, "reschedule");
-	pthread_mutex_unlock(&mutex);
+	MYSQL_MUTEX_UNLOCK(&mutex);
 	if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
 	{
 	  /* This should never happen */
@@ -2763,15 +2769,15 @@ bool Delayed_insert::handle_inserts(void
 	}
 	if (!using_bin_log)
 	  table->file->extra(HA_EXTRA_WRITE_CACHE);
-	pthread_mutex_lock(&mutex);
+	MYSQL_MUTEX_LOCK(&mutex);
 	thd_proc_info(&thd, "insert");
       }
       if (tables_in_use)
-	pthread_cond_broadcast(&cond_client);	// If waiting clients
+	MYSQL_COND_BROADCAST(&cond_client);	// If waiting clients
     }
   }
   thd_proc_info(&thd, 0);
-  pthread_mutex_unlock(&mutex);
+  MYSQL_MUTEX_UNLOCK(&mutex);
 
   /*
     We need to flush the pending event when using row-based
@@ -2796,7 +2802,7 @@ bool Delayed_insert::handle_inserts(void
     goto err;
   }
   query_cache_invalidate3(&thd, table, 1);
-  pthread_mutex_lock(&mutex);
+  MYSQL_MUTEX_LOCK(&mutex);
   DBUG_RETURN(0);
 
  err:
@@ -2815,7 +2821,7 @@ bool Delayed_insert::handle_inserts(void
   }
   DBUG_PRINT("error", ("dropped %lu rows after an error", max_rows));
   thread_safe_increment(delayed_insert_errors, &LOCK_delayed_status);
-  pthread_mutex_lock(&mutex);
+  MYSQL_MUTEX_LOCK(&mutex);
   DBUG_RETURN(1);
 }
 #endif /* EMBEDDED_LIBRARY */
@@ -3482,11 +3488,11 @@ static TABLE *create_table_from_items(TH
         if (open_table(thd, create_table, thd->mem_root, &ot_action_unused,
                        MYSQL_OPEN_REOPEN))
         {
-          pthread_mutex_lock(&LOCK_open);
+          MYSQL_MUTEX_LOCK(&LOCK_open);
           quick_rm_table(create_info->db_type, create_table->db,
                          table_case_name(create_info, create_table->table_name),
                          0);
-          pthread_mutex_unlock(&LOCK_open);
+          MYSQL_MUTEX_UNLOCK(&LOCK_open);
         }
         else
           table= create_table->table;

=== modified file 'sql/sql_manager.cc'
--- a/sql/sql_manager.cc	2007-05-10 09:59:39 +0000
+++ b/sql/sql_manager.cc	2008-10-10 20:34:55 +0000
@@ -27,8 +27,8 @@ ulong volatile manager_status;
 bool volatile manager_thread_in_use;
 
 pthread_t manager_thread;
-pthread_mutex_t LOCK_manager;
-pthread_cond_t COND_manager;
+mysql_mutex_t LOCK_manager;
+mysql_cond_t COND_manager;
 
 struct handler_cb {
    struct handler_cb *next;
@@ -41,7 +41,7 @@ bool mysql_manager_submit(void (*action)
 {
   bool result= FALSE;
   struct handler_cb * volatile *cb;
-  pthread_mutex_lock(&LOCK_manager);
+  MYSQL_MUTEX_LOCK(&LOCK_manager);
   cb= &cb_list;
   while (*cb && (*cb)->action != action)
     cb= &(*cb)->next;
@@ -56,7 +56,7 @@ bool mysql_manager_submit(void (*action)
       (*cb)->action= action;
     }
   }
-  pthread_mutex_unlock(&LOCK_manager);
+  MYSQL_MUTEX_UNLOCK(&LOCK_manager);
   return result;
 }
 
@@ -77,7 +77,7 @@ pthread_handler_t handle_manager(void *a
 
   for (;;)
   {
-    pthread_mutex_lock(&LOCK_manager);
+    MYSQL_MUTEX_LOCK(&LOCK_manager);
     /* XXX: This will need to be made more general to handle different
      * polling needs. */
     if (flush_time)
@@ -88,12 +88,12 @@ pthread_handler_t handle_manager(void *a
         reset_flush_time = FALSE;
       }
       while (!manager_status && (!error || error == EINTR) && !abort_loop)
-        error= pthread_cond_timedwait(&COND_manager, &LOCK_manager, &abstime);
+        error= MYSQL_COND_TIMEDWAIT(&COND_manager, &LOCK_manager, &abstime);
     }
     else
     {
       while (!manager_status && (!error || error == EINTR) && !abort_loop)
-        error= pthread_cond_wait(&COND_manager, &LOCK_manager);
+        error= MYSQL_COND_WAIT(&COND_manager, &LOCK_manager);
     }
     status = manager_status;
     manager_status = 0;
@@ -102,7 +102,7 @@ pthread_handler_t handle_manager(void *a
       cb= cb_list;
       cb_list= NULL;
     }
-    pthread_mutex_unlock(&LOCK_manager);
+    MYSQL_MUTEX_UNLOCK(&LOCK_manager);
 
     if (abort_loop)
       break;

=== modified file 'sql/sql_map.cc'
--- a/sql/sql_map.cc	2008-04-09 00:56:49 +0000
+++ b/sql/sql_map.cc	2008-10-10 20:34:55 +0000
@@ -85,7 +85,7 @@ static I_List<mapped_files> maps_in_use;
 mapped_files *map_file(const char * name,uchar *magic,uint magic_length)
 {
 #ifdef HAVE_MMAP
-  pthread_mutex_lock(&LOCK_mapped_file);
+  MYSQL_MUTEX_LOCK(&LOCK_mapped_file);
   I_List_iterator<mapped_files> list(maps_in_use);
   mapped_files *map;
   char path[FN_REFLEN];
@@ -108,7 +108,7 @@ mapped_files *map_file(const char * name
     if (!map->map)
       my_error(ER_NO_FILE_MAPPING, MYF(0), path, map->error);
   }
-  pthread_mutex_unlock(&LOCK_mapped_file);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mapped_file);
   return map;
 #else
   return NULL;
@@ -122,10 +122,10 @@ mapped_files *map_file(const char * name
 void unmap_file(mapped_files *map)
 {
 #ifdef HAVE_MMAP
-  pthread_mutex_lock(&LOCK_mapped_file);
+  MYSQL_MUTEX_LOCK(&LOCK_mapped_file);
   if (!map->use_count--)
     delete map;
-  pthread_mutex_unlock(&LOCK_mapped_file);
+  MYSQL_MUTEX_UNLOCK(&LOCK_mapped_file);
 #endif
 }
 

=== modified file 'sql/sql_parse.cc'
--- a/sql/sql_parse.cc	2008-09-16 08:34:30 +0000
+++ b/sql/sql_parse.cc	2008-10-10 20:34:55 +0000
@@ -350,7 +350,7 @@ bool is_log_table_write_query(enum enum_
 }
 
 void execute_init_command(THD *thd, sys_var_str *init_command_var,
-			  rw_lock_t *var_mutex)
+			  mysql_rwlock_t *var_mutex)
 {
   Vio* save_vio;
   ulong save_client_capabilities;
@@ -367,7 +367,7 @@ void execute_init_command(THD *thd, sys_
     during execution of init_command_var query
     values of init_command_var can't be changed
   */
-  rw_rdlock(var_mutex);
+  MYSQL_RWLOCK_RDLOCK(var_mutex);
   save_client_capabilities= thd->client_capabilities;
   thd->client_capabilities|= CLIENT_MULTI_QUERIES;
   /*
@@ -379,7 +379,7 @@ void execute_init_command(THD *thd, sys_
   dispatch_command(COM_QUERY, thd,
                    init_command_var->value,
                    init_command_var->value_length);
-  rw_unlock(var_mutex);
+  MYSQL_RWLOCK_UNLOCK(var_mutex);
   thd->client_capabilities= save_client_capabilities;
   thd->net.vio= save_vio;
 
@@ -510,10 +510,10 @@ end:
   delete thd;
 
 #ifndef EMBEDDED_LIBRARY
-  (void) pthread_mutex_lock(&LOCK_thread_count);
+  (void) MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thread_count--;
-  (void) pthread_mutex_unlock(&LOCK_thread_count);
-  (void) pthread_cond_broadcast(&COND_thread_count);
+  (void) MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
+  (void) MYSQL_COND_BROADCAST(&COND_thread_count);
   my_thread_end();
   pthread_exit(0);
 #endif
@@ -802,12 +802,12 @@ bool dispatch_command(enum enum_server_c
   thd->enable_slow_log= TRUE;
   thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
   thd->set_time();
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query_id= global_query_id;
   if (!(server_command_flags[command] & CF_SKIP_QUERY_ID))
     next_query_id();
   thread_running++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if (!(server_command_flags[command] & CF_SKIP_QUESTIONS))
     statistic_increment(thd->status_var.questions, &LOCK_status);
@@ -1031,7 +1031,7 @@ bool dispatch_command(enum enum_server_c
       thd->profiling.set_query_source(beginning_of_next_stmt, length);
 #endif
 
-      pthread_mutex_lock(&LOCK_thread_count);
+      MYSQL_MUTEX_LOCK(&LOCK_thread_count);
       thd->query_length= length;
       thd->query= beginning_of_next_stmt;
       /*
@@ -1041,7 +1041,7 @@ bool dispatch_command(enum enum_server_c
       thd->query_id= next_query_id();
       thd->set_time(); /* Reset the query start time. */
       /* TODO: set thd->lex->sql_command to SQLCOM_END here */
-      pthread_mutex_unlock(&LOCK_thread_count);
+      MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
       mysql_parse(thd, beginning_of_next_stmt, length, &end_of_stmt);
     }
 
@@ -1405,13 +1405,13 @@ bool dispatch_command(enum enum_server_c
   log_slow_statement(thd);
 
   thd_proc_info(thd, "cleaning up");
-  pthread_mutex_lock(&LOCK_thread_count); // For process list
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For process list
   thd_proc_info(thd, 0);
   thd->command=COM_SLEEP;
   thd->query=0;
   thd->query_length=0;
   thread_running--;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
   free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
 
@@ -1992,11 +1992,11 @@ mysql_execute_command(THD *thd)
       restore status variables, as we don't want 'show status' to cause
       changes
     */
-    pthread_mutex_lock(&LOCK_status);
+    MYSQL_MUTEX_LOCK(&LOCK_status);
     add_diff_to_status(&global_status_var, &thd->status_var,
                        &old_status_var);
     thd->status_var= old_status_var;
-    pthread_mutex_unlock(&LOCK_status);
+    MYSQL_MUTEX_UNLOCK(&LOCK_status);
     break;
   }
   case SQLCOM_SHOW_DATABASES:
@@ -2232,9 +2232,9 @@ mysql_execute_command(THD *thd)
   {
     if (check_global_access(thd, SUPER_ACL))
       goto error;
-    pthread_mutex_lock(&LOCK_active_mi);
+    MYSQL_MUTEX_LOCK(&LOCK_active_mi);
     res = change_master(thd,active_mi);
-    pthread_mutex_unlock(&LOCK_active_mi);
+    MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
     break;
   }
   case SQLCOM_SHOW_SLAVE_STAT:
@@ -2242,7 +2242,7 @@ mysql_execute_command(THD *thd)
     /* Accept one of two privileges */
     if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
       goto error;
-    pthread_mutex_lock(&LOCK_active_mi);
+    MYSQL_MUTEX_LOCK(&LOCK_active_mi);
     if (active_mi != NULL)
     {
       res = show_master_info(thd, active_mi);
@@ -2253,7 +2253,7 @@ mysql_execute_command(THD *thd)
                    "the master info structure does not exist");
       my_ok(thd);
     }
-    pthread_mutex_unlock(&LOCK_active_mi);
+    MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
     break;
   }
   case SQLCOM_SHOW_MASTER_STAT:
@@ -2528,9 +2528,9 @@ ddl_blocker_err:
 #ifdef HAVE_REPLICATION
   case SQLCOM_SLAVE_START:
   {
-    pthread_mutex_lock(&LOCK_active_mi);
+    MYSQL_MUTEX_LOCK(&LOCK_active_mi);
     start_slave(thd,active_mi,1 /* net report*/);
-    pthread_mutex_unlock(&LOCK_active_mi);
+    MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
     break;
   }
   case SQLCOM_SLAVE_STOP:
@@ -2555,9 +2555,9 @@ ddl_blocker_err:
     goto error;
   }
   {
-    pthread_mutex_lock(&LOCK_active_mi);
+    MYSQL_MUTEX_LOCK(&LOCK_active_mi);
     stop_slave(thd,active_mi,1/* net report*/);
-    pthread_mutex_unlock(&LOCK_active_mi);
+    MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
     break;
   }
 #endif /* HAVE_REPLICATION */
@@ -6452,9 +6452,9 @@ bool reload_acl_and_cache(THD *thd, ulon
       mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
     }
 #ifdef HAVE_REPLICATION
-    pthread_mutex_lock(&LOCK_active_mi);
+    MYSQL_MUTEX_LOCK(&LOCK_active_mi);
     rotate_relay_log(active_mi);
-    pthread_mutex_unlock(&LOCK_active_mi);
+    MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
 #endif
 
     /* flush slow and general logs */
@@ -6582,10 +6582,10 @@ bool reload_acl_and_cache(THD *thd, ulon
  if (options & REFRESH_SLAVE)
  {
    tmp_write_to_binlog= 0;
-   pthread_mutex_lock(&LOCK_active_mi);
+   MYSQL_MUTEX_LOCK(&LOCK_active_mi);
    if (reset_slave(thd, active_mi))
      result=1;
-   pthread_mutex_unlock(&LOCK_active_mi);
+   MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
  }
 #endif
  if (options & REFRESH_USER_RESOURCES)
@@ -6612,7 +6612,7 @@ uint kill_one_thread(THD *thd, ulong id,
   uint error=ER_NO_SUCH_THREAD;
   DBUG_ENTER("kill_one_thread");
   DBUG_PRINT("enter", ("id=%lu only_kill=%d", id, only_kill_query));
-  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For unlink from list
   I_List_iterator<THD> it(threads);
   while ((tmp=it++))
   {
@@ -6620,11 +6620,11 @@ uint kill_one_thread(THD *thd, ulong id,
       continue;
     if (tmp->thread_id == id)
     {
-      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
+      MYSQL_MUTEX_LOCK(&tmp->LOCK_delete);	// Lock from delete
       break;
     }
   }
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (tmp)
   {
     if ((thd->security_ctx->master_access & SUPER_ACL) ||
@@ -6635,7 +6635,7 @@ uint kill_one_thread(THD *thd, ulong id,
     }
     else
       error=ER_KILL_DENIED_ERROR;
-    pthread_mutex_unlock(&tmp->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&tmp->LOCK_delete);
   }
   DBUG_PRINT("exit", ("%d", error));
   DBUG_RETURN(error);

=== modified file 'sql/sql_partition.cc'
--- a/sql/sql_partition.cc	2008-09-04 18:30:34 +0000
+++ b/sql/sql_partition.cc	2008-10-10 20:34:55 +0000
@@ -5481,7 +5481,7 @@ static bool write_log_drop_shadow_frm(AL
   DBUG_ENTER("write_log_drop_shadow_frm");
 
   build_table_shadow_filename(shadow_path, sizeof(shadow_path), lpt);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_log_replace_delete_frm(lpt, 0UL, NULL,
                                   (const char*)shadow_path, FALSE))
     goto error;
@@ -5489,13 +5489,13 @@ static bool write_log_drop_shadow_frm(AL
   if (write_execute_ddl_log_entry(log_entry->entry_pos,
                                     FALSE, &exec_log_entry))
     goto error;
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   set_part_info_exec_log_entry(part_info, exec_log_entry);
   DBUG_RETURN(FALSE);
 
 error:
   release_part_info_log_entries(part_info->first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
@@ -5529,7 +5529,7 @@ static bool write_log_rename_frm(ALTER_P
   build_table_filename(path, sizeof(path), lpt->db,
                        lpt->table_name, "", 0);
   build_table_shadow_filename(shadow_path, sizeof(shadow_path), lpt);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_log_replace_delete_frm(lpt, 0UL, shadow_path, path, TRUE))
     goto error;
   log_entry= part_info->first_log_entry;
@@ -5538,12 +5538,12 @@ static bool write_log_rename_frm(ALTER_P
                                     FALSE, &exec_log_entry))
     goto error;
   release_part_info_log_entries(old_first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   DBUG_RETURN(FALSE);
 
 error:
   release_part_info_log_entries(part_info->first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= old_first_log_entry;
   part_info->frm_log_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
@@ -5582,7 +5582,7 @@ static bool write_log_drop_partition(ALT
                        lpt->table_name, "", 0);
   build_table_filename(tmp_path, sizeof(tmp_path), lpt->db,
                        lpt->table_name, "#", 0);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_log_dropped_partitions(lpt, &next_entry, (const char*)path,
                                    FALSE))
     goto error;
@@ -5595,12 +5595,12 @@ static bool write_log_drop_partition(ALT
                                     FALSE, &exec_log_entry))
     goto error;
   release_part_info_log_entries(old_first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   DBUG_RETURN(FALSE);
 
 error:
   release_part_info_log_entries(part_info->first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= old_first_log_entry;
   part_info->frm_log_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
@@ -5639,7 +5639,7 @@ static bool write_log_add_change_partiti
                        lpt->table_name, "", 0);
   build_table_filename(tmp_path, sizeof(tmp_path), lpt->db,
                        lpt->table_name, "#", 0);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_log_dropped_partitions(lpt, &next_entry, (const char*)path,
                                    FALSE))
     goto error;
@@ -5650,13 +5650,13 @@ static bool write_log_add_change_partiti
   if (write_execute_ddl_log_entry(log_entry->entry_pos,
                                     FALSE, &exec_log_entry))
     goto error;
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   set_part_info_exec_log_entry(part_info, exec_log_entry);
   DBUG_RETURN(FALSE);
 
 error:
   release_part_info_log_entries(part_info->first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
@@ -5694,7 +5694,7 @@ static bool write_log_final_change_parti
   build_table_filename(path, sizeof(path), lpt->db,
                        lpt->table_name, "", 0);
   build_table_shadow_filename(shadow_path, sizeof(shadow_path), lpt);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_log_dropped_partitions(lpt, &next_entry, (const char*)path,
                       lpt->alter_info->flags & ALTER_REORGANIZE_PARTITION))
     goto error;
@@ -5708,12 +5708,12 @@ static bool write_log_final_change_parti
                                     FALSE, &exec_log_entry))
     goto error;
   release_part_info_log_entries(old_first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   DBUG_RETURN(FALSE);
 
 error:
   release_part_info_log_entries(part_info->first_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= old_first_log_entry;
   part_info->frm_log_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
@@ -5740,7 +5740,7 @@ static void write_log_completed(ALTER_PA
   DBUG_ENTER("write_log_completed");
 
   DBUG_ASSERT(log_entry);
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   if (write_execute_ddl_log_entry(0UL, TRUE, &log_entry))
   {
     /*
@@ -5754,7 +5754,7 @@ static void write_log_completed(ALTER_PA
   }
   release_part_info_log_entries(part_info->first_log_entry);
   release_part_info_log_entries(part_info->exec_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->exec_log_entry= NULL;
   part_info->first_log_entry= NULL;
   DBUG_VOID_RETURN;
@@ -5772,10 +5772,10 @@ static void write_log_completed(ALTER_PA
 
 static void release_log_entries(partition_info *part_info)
 {
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   release_part_info_log_entries(part_info->first_log_entry);
   release_part_info_log_entries(part_info->exec_log_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   part_info->first_log_entry= NULL;
   part_info->exec_log_entry= NULL;
 }
@@ -5820,7 +5820,7 @@ static int alter_close_tables(ALTER_PART
     We must keep LOCK_open while manipulating with thd->open_tables.
     Another thread may be working on it.
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   /*
     We can safely remove locks for all tables with the same name:
     later they will all be closed anyway in
@@ -5843,7 +5843,7 @@ static int alter_close_tables(ALTER_PART
       table->s->version= 0;
     }
   }
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   DBUG_RETURN(0);
 }
 

=== modified file 'sql/sql_plugin.cc'
--- a/sql/sql_plugin.cc	2008-08-19 15:58:48 +0000
+++ b/sql/sql_plugin.cc	2008-10-10 20:34:55 +0000
@@ -108,7 +108,11 @@ static bool initialized= 0;
   following variables/structures.
   We are always manipulating ref count, so a rwlock here is unneccessary.
 */
-pthread_mutex_t LOCK_plugin;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_plugin;
+#endif
+
+mysql_mutex_t LOCK_plugin;
 static DYNAMIC_ARRAY plugin_dl_array;
 static DYNAMIC_ARRAY plugin_array;
 static HASH plugin_hash[MYSQL_MAX_PLUGIN_TYPE_NUM];
@@ -532,7 +536,7 @@ static void plugin_dl_del(const LEX_STRI
   uint i;
   DBUG_ENTER("plugin_dl_del");
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   for (i= 0; i < plugin_dl_array.elements; i++)
   {
@@ -564,7 +568,7 @@ static struct st_plugin_int *plugin_find
   if (! initialized)
     DBUG_RETURN(0);
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   if (type == MYSQL_ANY_PLUGIN)
   {
@@ -588,14 +592,14 @@ static SHOW_COMP_OPTION plugin_status(co
   SHOW_COMP_OPTION rc= SHOW_OPTION_NO;
   struct st_plugin_int *plugin;
   DBUG_ENTER("plugin_is_ready");
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   if ((plugin= plugin_find_internal(name, type)))
   {
     rc= SHOW_OPTION_DISABLED;
     if (plugin->state == PLUGIN_IS_READY)
       rc= SHOW_OPTION_YES;
   }
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(rc);
 }
 
@@ -621,7 +625,7 @@ static plugin_ref intern_plugin_lock(LEX
   st_plugin_int *pi= plugin_ref_to_int(rc);
   DBUG_ENTER("intern_plugin_lock");
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   if (pi->state & (PLUGIN_IS_READY | PLUGIN_IS_UNINITIALIZED))
   {
@@ -660,9 +664,9 @@ plugin_ref plugin_lock(THD *thd, plugin_
   LEX *lex= thd ? thd->lex : 0;
   plugin_ref rc;
   DBUG_ENTER("plugin_lock");
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   rc= my_intern_plugin_lock_ci(lex, *ptr);
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(rc);
 }
 
@@ -674,10 +678,10 @@ plugin_ref plugin_lock_by_name(THD *thd,
   plugin_ref rc= NULL;
   st_plugin_int *plugin;
   DBUG_ENTER("plugin_lock_by_name");
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   if ((plugin= plugin_find_internal(name, type)))
     rc= my_intern_plugin_lock_ci(lex, plugin_int_to_ref(plugin));
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(rc);
 }
 
@@ -797,7 +801,7 @@ static void plugin_deinitialize(struct s
     deinitialization to deadlock if plugins have worker threads
     with plugin locks
   */
-  safe_mutex_assert_not_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_plugin);
 
   if (plugin->plugin->status_vars)
   {
@@ -851,7 +855,7 @@ static void plugin_deinitialize(struct s
 static void plugin_del(struct st_plugin_int *plugin)
 {
   DBUG_ENTER("plugin_del(plugin)");
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
   /* Free allocated strings before deleting the plugin. */
   plugin_vars_free_values(plugin->system_vars);
   hash_delete(&plugin_hash[plugin->plugin->type], (uchar*)plugin);
@@ -859,9 +863,9 @@ static void plugin_del(struct st_plugin_
     plugin_dl_del(&plugin->plugin_dl->dl);
   plugin->state= PLUGIN_IS_FREED;
   plugin_array_version++;
-  rw_wrlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_system_variables_hash);
   mysql_del_sys_var_chain(plugin->system_vars);
-  rw_unlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
   free_root(&plugin->mem_root, MYF(0));
   DBUG_VOID_RETURN;
 }
@@ -884,7 +888,7 @@ static void reap_plugins(void)
   uint count, idx;
   struct st_plugin_int *plugin, **reap, **list;
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   if (!reap_needed)
     return;
@@ -905,13 +909,13 @@ static void reap_plugins(void)
     }
   }
 
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   list= reap;
   while ((plugin= *(--list)))
     plugin_deinitialize(plugin, true);
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
   while ((plugin= *(--reap)))
     plugin_del(plugin);
@@ -925,7 +929,7 @@ static void intern_plugin_unlock(LEX *le
   st_plugin_int *pi;
   DBUG_ENTER("intern_plugin_unlock");
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   if (!plugin)
     DBUG_VOID_RETURN;
@@ -978,10 +982,10 @@ void plugin_unlock(THD *thd, plugin_ref 
   if (!plugin_dlib(plugin))
     DBUG_VOID_RETURN;
 #endif
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   intern_plugin_unlock(lex, plugin);
   reap_plugins();
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_VOID_RETURN;
 }
 
@@ -991,11 +995,11 @@ void plugin_unlock_list(THD *thd, plugin
   LEX *lex= thd ? thd->lex : 0;
   DBUG_ENTER("plugin_unlock_list");
   DBUG_ASSERT(list);
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   while (count--)
     intern_plugin_unlock(lex, *list++);
   reap_plugins();
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_VOID_RETURN;
 }
 
@@ -1004,7 +1008,7 @@ static int plugin_initialize(struct st_p
 {
   DBUG_ENTER("plugin_initialize");
 
-  safe_mutex_assert_owner(&LOCK_plugin);
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_plugin);
 
   if (plugin_type_initialize[plugin->plugin->type])
   {
@@ -1120,7 +1124,7 @@ int plugin_init(int *argc, char **argv, 
       goto err;
 
 
-  pthread_mutex_init(&LOCK_plugin, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_plugin, key_LOCK_plugin, MY_MUTEX_INIT_FAST);
 
   if (my_init_dynamic_array(&plugin_dl_array,
                             sizeof(struct st_plugin_dl *),16,16) ||
@@ -1135,7 +1139,7 @@ int plugin_init(int *argc, char **argv, 
       goto err;
   }
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
   initialized= 1;
 
@@ -1188,7 +1192,7 @@ int plugin_init(int *argc, char **argv, 
   /* should now be set to MyISAM storage engine */
   DBUG_ASSERT(global_system_variables.table_plugin);
 
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   /* Register all dynamic plugins */
   if (!(flags & PLUGIN_INIT_SKIP_DYNAMIC_LOADING))
@@ -1206,7 +1210,7 @@ int plugin_init(int *argc, char **argv, 
     Now we initialize all remaining plugins
   */
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   reap= (st_plugin_int **) my_alloca((plugin_array.elements+1) * sizeof(void*));
   *(reap++)= NULL;
 
@@ -1228,13 +1232,13 @@ int plugin_init(int *argc, char **argv, 
   */
   while ((plugin_ptr= *(--reap)))
   {
-    pthread_mutex_unlock(&LOCK_plugin);
+    MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
     plugin_deinitialize(plugin_ptr, true);
-    pthread_mutex_lock(&LOCK_plugin);
+    MYSQL_MUTEX_LOCK(&LOCK_plugin);
     plugin_del(plugin_ptr);
   }
 
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   my_afree(reap);
 
 end:
@@ -1243,7 +1247,7 @@ end:
   DBUG_RETURN(0);
 
 err_unlock:
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 err:
   free_root(&tmp_root, MYF(0));
   DBUG_RETURN(1);
@@ -1300,8 +1304,8 @@ bool plugin_register_builtin(THD *thd, s
   tmp.name.str= (char *)plugin->name;
   tmp.name.length= strlen(plugin->name);
 
-  pthread_mutex_lock(&LOCK_plugin);
-  rw_wrlock(&LOCK_system_variables_hash);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_system_variables_hash);
 
   if (test_plugin_options(thd->mem_root, &tmp, &dummy_argc, NULL, true))
     goto end;
@@ -1310,8 +1314,8 @@ bool plugin_register_builtin(THD *thd, s
     mysql_del_sys_var_chain(tmp.system_vars);
 
 end:
-  rw_unlock(&LOCK_system_variables_hash);
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   DBUG_RETURN(result);;
 }
@@ -1351,10 +1355,10 @@ static void plugin_load(MEM_ROOT *tmp_ro
     When building an embedded library, if the mysql.plugin table
     does not exist, we silently ignore the missing table
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   if (check_if_table_exists(new_thd, &tables, &table_exists))
     table_exists= FALSE;
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   if (!table_exists)
     goto end;
 #endif /* EMBEDDED_LIBRARY */
@@ -1372,10 +1376,10 @@ static void plugin_load(MEM_ROOT *tmp_ro
   /*
     there're no other threads running yet, so we don't need a mutex.
     but plugin_add() before is designed to work in multi-threaded
-    environment, and it uses safe_mutex_assert_owner(), so we lock
+    environment, and it uses MYSQL_MUTEX_ASSERT_OWNER(), so we lock
     the mutex here to satisfy the assert
   */
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   while (!(error= read_record_info.read_record(&read_record_info)))
   {
     DBUG_PRINT("info", ("init plugin record"));
@@ -1391,7 +1395,7 @@ static void plugin_load(MEM_ROOT *tmp_ro
                         str_name.c_ptr(), str_dl.c_ptr());
     free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
   }
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   if (error > 0)
     sql_print_error(ER(ER_GET_ERRNO), my_errno);
   end_read_record(&read_record_info);
@@ -1442,7 +1446,7 @@ static bool plugin_load_list(MEM_ROOT *t
         }
 
         dl= name;
-        pthread_mutex_lock(&LOCK_plugin);
+        MYSQL_MUTEX_LOCK(&LOCK_plugin);
         if ((plugin_dl= plugin_dl_add(&dl, REPORT_TO_LOG)))
         {
           for (plugin= plugin_dl->plugins; plugin->info; plugin++)
@@ -1460,11 +1464,11 @@ static bool plugin_load_list(MEM_ROOT *t
       else
       {
         free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
-        pthread_mutex_lock(&LOCK_plugin);
+        MYSQL_MUTEX_LOCK(&LOCK_plugin);
         if (plugin_add(tmp_root, &name, &dl, argc, argv, REPORT_TO_LOG))
           goto error;
       }
-      pthread_mutex_unlock(&LOCK_plugin);
+      MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
       name.length= dl.length= 0;
       dl.str= NULL; name.str= p= buffer;
       str= &name;
@@ -1485,7 +1489,7 @@ static bool plugin_load_list(MEM_ROOT *t
   }
   DBUG_RETURN(FALSE);
 error:
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   sql_print_error("Couldn't load plugin named '%s' with soname '%s'.",
                   name.str, dl.str);
   DBUG_RETURN(TRUE);
@@ -1501,7 +1505,7 @@ void plugin_shutdown(void)
 
   if (initialized)
   {
-    pthread_mutex_lock(&LOCK_plugin);
+    MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
     reap_needed= true;
 
@@ -1554,7 +1558,7 @@ void plugin_shutdown(void)
       if (plugins[i]->state == PLUGIN_IS_DELETED)
         plugins[i]->state= PLUGIN_IS_DYING;
     }
-    pthread_mutex_unlock(&LOCK_plugin);
+    MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
     /*
       We loop through all plugins and call deinit() if they have one.
@@ -1574,9 +1578,9 @@ void plugin_shutdown(void)
     /*
       It's perfectly safe not to lock LOCK_plugin, as there're no
       concurrent threads anymore. But some functions called from here
-      use safe_mutex_assert_owner(), so we lock the mutex to satisfy it
+      use MYSQL_MUTEX_ASSERT_OWNER(), so we lock the mutex to satisfy it
     */
-    pthread_mutex_lock(&LOCK_plugin);
+    MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
     /*
       We defer checking ref_counts until after all plugins are deinitialized
@@ -1597,10 +1601,10 @@ void plugin_shutdown(void)
 
     cleanup_variables(NULL, &global_system_variables);
     cleanup_variables(NULL, &max_system_variables);
-    pthread_mutex_unlock(&LOCK_plugin);
+    MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
     initialized= 0;
-    pthread_mutex_destroy(&LOCK_plugin);
+    MYSQL_MUTEX_DESTROY(&LOCK_plugin);
 
     my_afree(plugins);
   }
@@ -1650,14 +1654,14 @@ bool mysql_install_plugin(THD *thd, cons
   if (! (table = open_ltable(thd, &tables, TL_WRITE, 0)))
     DBUG_RETURN(TRUE);
 
-  pthread_mutex_lock(&LOCK_plugin);
-  rw_wrlock(&LOCK_system_variables_hash);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
+  MYSQL_RWLOCK_WRLOCK(&LOCK_system_variables_hash);
   /* handle_options() assumes arg0 (program name) always exists */
   argv[0]= const_cast<char*>(""); // without a cast gcc emits a warning
   argv[1]= 0;
   argc= 1;
   error= plugin_add(thd->mem_root, name, dl, &argc, argv, REPORT_TO_USER);
-  rw_unlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
 
   if (error || !(tmp= plugin_find_internal(name, MYSQL_ANY_PLUGIN)))
     goto err;
@@ -1687,14 +1691,14 @@ bool mysql_install_plugin(THD *thd, cons
     goto deinit;
   }
 
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(FALSE);
 deinit:
   tmp->state= PLUGIN_IS_DELETED;
   reap_needed= true;
   reap_plugins();
 err:
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(TRUE);
 }
 
@@ -1715,7 +1719,7 @@ bool mysql_uninstall_plugin(THD *thd, co
   if (! (table= open_ltable(thd, &tables, TL_WRITE, 0)))
     DBUG_RETURN(TRUE);
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   if (!(plugin= plugin_find_internal(name, MYSQL_ANY_PLUGIN)))
   {
     my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PLUGIN", name->str);
@@ -1736,7 +1740,7 @@ bool mysql_uninstall_plugin(THD *thd, co
   else
     reap_needed= true;
   reap_plugins();
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   table->use_all_columns();
   table->field[0]->store(name->str, name->length, system_charset_info);
@@ -1762,7 +1766,7 @@ bool mysql_uninstall_plugin(THD *thd, co
   }
   DBUG_RETURN(FALSE);
 err:
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_RETURN(TRUE);
 }
 
@@ -1780,7 +1784,7 @@ bool plugin_foreach_with_mask(THD *thd, 
 
   state_mask= ~state_mask; // do it only once
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
   total= type == MYSQL_ANY_PLUGIN ? plugin_array.elements
                                   : plugin_hash[type].records;
   /*
@@ -1805,17 +1809,17 @@ bool plugin_foreach_with_mask(THD *thd, 
       plugins[idx]= !(plugin->state & state_mask) ? plugin : NULL;
     }
   }
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   for (idx= 0; idx < total; idx++)
   {
     if (unlikely(version != plugin_array_version))
     {
-      pthread_mutex_lock(&LOCK_plugin);
+      MYSQL_MUTEX_LOCK(&LOCK_plugin);
       for (uint i=idx; i < total; i++)
         if (plugins[i] && plugins[i]->state & state_mask)
           plugins[i]=0;
-      pthread_mutex_unlock(&LOCK_plugin);
+      MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
     }
     plugin= plugins[idx];
     /* It will stop iterating on first engine error when "func" returns TRUE */
@@ -2136,12 +2140,12 @@ sys_var *find_sys_var(THD *thd, const ch
   plugin_ref plugin;
   DBUG_ENTER("find_sys_var");
 
-  pthread_mutex_lock(&LOCK_plugin);
-  rw_rdlock(&LOCK_system_variables_hash);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_system_variables_hash);
   if ((var= intern_find_sys_var(str, length, false)) &&
       (pi= var->cast_pluginvar()))
   {
-    rw_unlock(&LOCK_system_variables_hash);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
     LEX *lex= thd ? thd->lex : 0;
     if (!(plugin= my_intern_plugin_lock(lex, plugin_int_to_ref(pi->plugin))))
       var= NULL; /* failed to lock it, it must be uninstalling */
@@ -2154,8 +2158,8 @@ sys_var *find_sys_var(THD *thd, const ch
     }
   }
   else
-    rw_unlock(&LOCK_system_variables_hash);
-  pthread_mutex_unlock(&LOCK_plugin);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   /*
     If the variable exists but the plugin it is associated with is not ready
@@ -2334,7 +2338,7 @@ static uchar *intern_sys_var_ptr(THD* th
   {
     uint idx;
 
-    rw_rdlock(&LOCK_system_variables_hash);
+    MYSQL_RWLOCK_RDLOCK(&LOCK_system_variables_hash);
 
     thd->variables.dynamic_variables_ptr= (char*)
       my_realloc(thd->variables.dynamic_variables_ptr,
@@ -2342,9 +2346,9 @@ static uchar *intern_sys_var_ptr(THD* th
                  MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR));
 
     if (global_lock)
-      pthread_mutex_lock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
 
-    safe_mutex_assert_owner(&LOCK_global_system_variables);
+    MYSQL_MUTEX_ASSERT_OWNER(&LOCK_global_system_variables);
 
     memcpy(thd->variables.dynamic_variables_ptr +
              thd->variables.dynamic_variables_size,
@@ -2383,7 +2387,7 @@ static uchar *intern_sys_var_ptr(THD* th
     }
 
     if (global_lock)
-      pthread_mutex_unlock(&LOCK_global_system_variables);
+      MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
     thd->variables.dynamic_variables_version=
            global_system_variables.dynamic_variables_version;
@@ -2392,7 +2396,7 @@ static uchar *intern_sys_var_ptr(THD* th
     thd->variables.dynamic_variables_size=
            global_system_variables.dynamic_variables_size;
 
-    rw_unlock(&LOCK_system_variables_hash);
+    MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
   }
   return (uchar*)thd->variables.dynamic_variables_ptr + offset;
 }
@@ -2419,11 +2423,11 @@ void plugin_thdvar_init(THD *thd)
   thd->variables.dynamic_variables_size= 0;
   thd->variables.dynamic_variables_ptr= 0;
 
-  pthread_mutex_lock(&LOCK_plugin);  
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);  
   thd->variables.table_plugin=
         my_intern_plugin_lock(NULL, global_system_variables.table_plugin);
   intern_plugin_unlock(NULL, old_table_plugin);
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
   DBUG_VOID_RETURN;
 }
 
@@ -2452,7 +2456,7 @@ static void cleanup_variables(THD *thd, 
   int flags;
   uint idx;
 
-  rw_rdlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_system_variables_hash);
   for (idx= 0; idx < bookmark_hash.records; idx++)
   {
     v= (st_bookmark*) hash_element(&bookmark_hash, idx);
@@ -2472,7 +2476,7 @@ static void cleanup_variables(THD *thd, 
       *ptr= NULL;
     }
   }
-  rw_unlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
 
   DBUG_ASSERT(vars->table_plugin == NULL);
 
@@ -2489,7 +2493,7 @@ void plugin_thdvar_cleanup(THD *thd)
   plugin_ref *list;
   DBUG_ENTER("plugin_thdvar_cleanup");
 
-  pthread_mutex_lock(&LOCK_plugin);
+  MYSQL_MUTEX_LOCK(&LOCK_plugin);
 
   unlock_variables(thd, &thd->variables);
   cleanup_variables(thd, &thd->variables);
@@ -2503,7 +2507,7 @@ void plugin_thdvar_cleanup(THD *thd)
   }
 
   reap_plugins();
-  pthread_mutex_unlock(&LOCK_plugin);
+  MYSQL_MUTEX_UNLOCK(&LOCK_plugin);
 
   reset_dynamic(&thd->lex->plugins);
 
@@ -2677,7 +2681,7 @@ void sys_var_pluginvar::set_default(THD 
   if (is_readonly())
     return;
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   tgt= real_value_ptr(thd, type);
   src= ((void **) (plugin_var + 1) + 1);
 
@@ -2720,11 +2724,11 @@ void sys_var_pluginvar::set_default(THD 
   if (!(plugin_var->flags & PLUGIN_VAR_THDLOCAL) || type == OPT_GLOBAL)
   {
     plugin_var->update(thd, plugin_var, tgt, src);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
   {
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     plugin_var->update(thd, plugin_var, tgt, src);
   }
 }
@@ -2743,18 +2747,18 @@ bool sys_var_pluginvar::update(THD *thd,
   if (is_readonly())
     return 1;
 
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   tgt= real_value_ptr(thd, var->type);
 
   if (!(plugin_var->flags & PLUGIN_VAR_THDLOCAL) || var->type == OPT_GLOBAL)
   {
     /* variable we are updating has global scope, so we unlock after updating */
     plugin_var->update(thd, plugin_var, tgt, &var->save_result);
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   }
   else
   {
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     plugin_var->update(thd, plugin_var, tgt, &var->save_result);
   }
  return 0;

=== modified file 'sql/sql_rename.cc'
--- a/sql/sql_rename.cc	2008-06-11 04:33:36 +0000
+++ b/sql/sql_rename.cc	2008-10-10 20:34:55 +0000
@@ -136,7 +136,7 @@ bool mysql_rename_tables(THD *thd, TABLE
   if (lock_table_names(thd, table_list))
     goto err;
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   for (ren_table= table_list; ren_table; ren_table= ren_table->next_local)
     tdc_remove_table(thd, TDC_RT_REMOVE_ALL, ren_table->db,
@@ -174,7 +174,7 @@ bool mysql_rename_tables(THD *thd, TABLE
     higher concurrency - query_cache_invalidate can take minutes to
     complete.
   */
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   /* Lets hope this doesn't fail as the result will be messy */ 
   if (!silent && !error)

=== modified file 'sql/sql_repl.cc'
--- a/sql/sql_repl.cc	2008-09-04 18:30:34 +0000
+++ b/sql/sql_repl.cc	2008-10-10 20:34:55 +0000
@@ -178,7 +178,7 @@ void adjust_linfo_offsets(my_off_t purge
 {
   THD *tmp;
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   I_List_iterator<THD> it(threads);
 
   while ((tmp=it++))
@@ -186,7 +186,7 @@ void adjust_linfo_offsets(my_off_t purge
     LOG_INFO* linfo;
     if ((linfo = tmp->current_linfo))
     {
-      pthread_mutex_lock(&linfo->lock);
+      MYSQL_MUTEX_LOCK(&linfo->lock);
       /*
 	Index file offset can be less that purge offset only if
 	we just started reading the index file. In that case
@@ -196,10 +196,10 @@ void adjust_linfo_offsets(my_off_t purge
 	linfo->fatal = (linfo->index_file_offset != 0);
       else
 	linfo->index_file_offset -= purge_offset;
-      pthread_mutex_unlock(&linfo->lock);
+      MYSQL_MUTEX_UNLOCK(&linfo->lock);
     }
   }
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 }
 
 
@@ -209,7 +209,7 @@ bool log_in_use(const char* log_name)
   THD *tmp;
   bool result = 0;
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   I_List_iterator<THD> it(threads);
 
   while ((tmp=it++))
@@ -217,16 +217,16 @@ bool log_in_use(const char* log_name)
     LOG_INFO* linfo;
     if ((linfo = tmp->current_linfo))
     {
-      pthread_mutex_lock(&linfo->lock);
+      MYSQL_MUTEX_LOCK(&linfo->lock);
       result = !bcmp((uchar*) log_name, (uchar*) linfo->log_file_name,
                      log_name_len);
-      pthread_mutex_unlock(&linfo->lock);
+      MYSQL_MUTEX_UNLOCK(&linfo->lock);
       if (result)
 	break;
     }
   }
 
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   return result;
 }
 
@@ -398,7 +398,7 @@ void mysql_binlog_send(THD* thd, char* l
   int error;
   const char *errmsg = "Unknown error";
   NET* net = &thd->net;
-  pthread_mutex_t *log_lock;
+  mysql_mutex_t *log_lock;
   bool binlog_can_be_corrupted= FALSE;
 #ifndef DBUG_OFF
   int left_events = max_binlog_dump_events;
@@ -460,9 +460,9 @@ void mysql_binlog_send(THD* thd, char* l
     goto err;
   }
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->current_linfo = &linfo;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if ((file=open_binlog(&log, log_file_name, &errmsg)) < 0)
   {
@@ -710,11 +710,11 @@ impossible position";
           has not been updated since last read.
 	*/
 
-	pthread_mutex_lock(log_lock);
-	switch (Log_event::read_log_event(&log, packet, (pthread_mutex_t*)0)) {
+	MYSQL_MUTEX_LOCK(log_lock);
+	switch (Log_event::read_log_event(&log, packet, (mysql_mutex_t*)0)) {
 	case 0:
 	  /* we read successfully, so we'll need to send it to the slave */
-	  pthread_mutex_unlock(log_lock);
+	  MYSQL_MUTEX_UNLOCK(log_lock);
 	  read_packet = 1;
           if (coord)
             coord->pos= uint4korr(packet->ptr() + 1 + LOG_POS_OFFSET);
@@ -726,7 +726,7 @@ impossible position";
 	  DBUG_PRINT("wait",("waiting for data in binary log"));
 	  if (thd->server_id==0) // for mysqlbinlog (mysqlbinlog.server_id==0)
 	  {
-	    pthread_mutex_unlock(log_lock);
+	    MYSQL_MUTEX_UNLOCK(log_lock);
 	    goto end;
 	  }
 
@@ -757,7 +757,7 @@ impossible position";
               {
                 errmsg = "Failed on my_net_write()";
                 my_errno= ER_UNKNOWN_ERROR;
-                pthread_mutex_unlock(log_lock);
+                MYSQL_MUTEX_UNLOCK(log_lock);
                 goto err;
               }
             }
@@ -767,12 +767,12 @@ impossible position";
               DBUG_PRINT("wait",("binary log received update"));
             }
           } while (ret != 0 && coord != NULL && !thd->killed);
-          pthread_mutex_unlock(log_lock);
+          MYSQL_MUTEX_UNLOCK(log_lock);
         }    
         break;
             
         default:
-	  pthread_mutex_unlock(log_lock);
+	  MYSQL_MUTEX_UNLOCK(log_lock);
 	  fatal_error = 1;
 	  break;
 	}
@@ -866,9 +866,9 @@ end:
 
   my_eof(thd);
   thd_proc_info(thd, "Waiting to finalize termination");
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->current_linfo = 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 
 err:
@@ -881,9 +881,9 @@ err:
     this mutex will make sure that it never tried to update our linfo
     after we return from this stack frame
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->current_linfo = 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (file >= 0)
     (void) my_close(file, MYF(MY_WME));
 
@@ -924,7 +924,7 @@ int start_slave(THD* thd , Master_info* 
       */
       if (thread_mask & SLAVE_SQL)
       {
-        pthread_mutex_lock(&mi->rli.data_lock);
+        MYSQL_MUTEX_LOCK(&mi->rli.data_lock);
 
         if (thd->lex->mi.pos)
         {
@@ -978,7 +978,7 @@ int start_slave(THD* thd , Master_info* 
                          ER(ER_MISSING_SKIP_SLAVE));
         }
 
-        pthread_mutex_unlock(&mi->rli.data_lock);
+        MYSQL_MUTEX_UNLOCK(&mi->rli.data_lock);
       }
       else if (thd->lex->mi.pos || thd->lex->mi.relay_log_pos)
         push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_UNTIL_COND_IGNORED,
@@ -1145,7 +1145,7 @@ err:
 
   Kill all Binlog_dump threads which previously talked to the same slave
   ("same" means with the same server id). Indeed, if the slave stops, if the
-  Binlog_dump thread is waiting (pthread_cond_wait) for binlog update, then it
+  Binlog_dump thread is waiting (MYSQL_COND_WAIT) for binlog update, then it
   will keep existing until a query is written to the binlog. If the master is
   idle, then this could last long, and if the slave reconnects, we could have 2
   Binlog_dump threads in SHOW PROCESSLIST, until a query is written to the
@@ -1163,7 +1163,7 @@ err:
 
 void kill_zombie_dump_threads(uint32 slave_server_id)
 {
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   I_List_iterator<THD> it(threads);
   THD *tmp;
 
@@ -1172,11 +1172,11 @@ void kill_zombie_dump_threads(uint32 sla
     if (tmp->command == COM_BINLOG_DUMP &&
        tmp->server_id == slave_server_id)
     {
-      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
+      MYSQL_MUTEX_LOCK(&tmp->LOCK_delete);	// Lock from delete
       break;
     }
   }
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (tmp)
   {
     /*
@@ -1185,7 +1185,7 @@ void kill_zombie_dump_threads(uint32 sla
       again. We just to do kill the thread ourselves.
     */
     tmp->awake(THD::KILL_QUERY);
-    pthread_mutex_unlock(&tmp->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&tmp->LOCK_delete);
   }
 }
 
@@ -1386,7 +1386,7 @@ bool change_master(THD* thd, Master_info
   if (!mi->rli.group_master_log_name[0]) // uninitialized case
     mi->rli.group_master_log_pos=0;
 
-  pthread_mutex_lock(&mi->rli.data_lock);
+  MYSQL_MUTEX_LOCK(&mi->rli.data_lock);
   mi->rli.abort_pos_wait++; /* for MASTER_POS_WAIT() to abort */
   /* Clear the errors, for a clean start */
   mi->rli.clear_error();
@@ -1399,8 +1399,8 @@ bool change_master(THD* thd, Master_info
     not exist anymore).
   */
   flush_relay_log_info(&mi->rli);
-  pthread_cond_broadcast(&mi->data_cond);
-  pthread_mutex_unlock(&mi->rli.data_lock);
+  MYSQL_COND_BROADCAST(&mi->data_cond);
+  MYSQL_MUTEX_UNLOCK(&mi->rli.data_lock);
 
   unlock_slave_threads(mi);
   thd_proc_info(thd, 0);
@@ -1470,7 +1470,7 @@ bool mysql_show_binlog_events(THD* thd)
     my_off_t pos = max(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly
     char search_file_name[FN_REFLEN], *name;
     const char *log_file_name = lex_mi->log_file_name;
-    pthread_mutex_t *log_lock = mysql_bin_log.get_log_lock();
+    mysql_mutex_t *log_lock = mysql_bin_log.get_log_lock();
     LOG_INFO linfo;
     Log_event* ev;
 
@@ -1492,9 +1492,9 @@ bool mysql_show_binlog_events(THD* thd)
       goto err;
     }
 
-    pthread_mutex_lock(&LOCK_thread_count);
+    MYSQL_MUTEX_LOCK(&LOCK_thread_count);
     thd->current_linfo = &linfo;
-    pthread_mutex_unlock(&LOCK_thread_count);
+    MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
     if ((file=open_binlog(&log, linfo.log_file_name, &errmsg)) < 0)
       goto err;
@@ -1504,7 +1504,7 @@ bool mysql_show_binlog_events(THD* thd)
     */
     thd->variables.max_allowed_packet += MAX_LOG_EVENT_HEADER;
 
-    pthread_mutex_lock(log_lock);
+    MYSQL_MUTEX_LOCK(log_lock);
 
     /*
       open_binlog() sought to position 4.
@@ -1514,7 +1514,7 @@ bool mysql_show_binlog_events(THD* thd)
       This code will fail on a mixed relay log (one which has Format_desc then
       Rotate then Format_desc).
     */
-    ev = Log_event::read_log_event(&log,(pthread_mutex_t*)0,description_event);
+    ev = Log_event::read_log_event(&log,(mysql_mutex_t*)0,description_event);
     if (ev)
     {
       if (ev->get_type_code() == FORMAT_DESCRIPTION_EVENT)
@@ -1535,7 +1535,7 @@ bool mysql_show_binlog_events(THD* thd)
     }
 
     for (event_count = 0;
-	 (ev = Log_event::read_log_event(&log,(pthread_mutex_t*) 0,
+	 (ev = Log_event::read_log_event(&log,(mysql_mutex_t*) 0,
                                          description_event)); )
     {
       if (event_count >= limit_start &&
@@ -1543,7 +1543,7 @@ bool mysql_show_binlog_events(THD* thd)
       {
 	errmsg = "Net error";
 	delete ev;
-	pthread_mutex_unlock(log_lock);
+	MYSQL_MUTEX_UNLOCK(log_lock);
 	goto err;
       }
 
@@ -1557,11 +1557,11 @@ bool mysql_show_binlog_events(THD* thd)
     if (event_count < limit_end && log.error)
     {
       errmsg = "Wrong offset or I/O error";
-      pthread_mutex_unlock(log_lock);
+      MYSQL_MUTEX_UNLOCK(log_lock);
       goto err;
     }
 
-    pthread_mutex_unlock(log_lock);
+    MYSQL_MUTEX_UNLOCK(log_lock);
   }
 
   ret= FALSE;
@@ -1580,9 +1580,9 @@ err:
   else
     my_eof(thd);
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->current_linfo = 0;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_RETURN(ret);
 }
 
@@ -1657,12 +1657,12 @@ bool show_binlogs(THD* thd)
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_RETURN(TRUE);
   
-  pthread_mutex_lock(mysql_bin_log.get_log_lock());
+  MYSQL_MUTEX_LOCK(mysql_bin_log.get_log_lock());
   mysql_bin_log.lock_index();
   index_file=mysql_bin_log.get_index_file();
   
   mysql_bin_log.raw_get_current_log(&cur); // dont take mutex
-  pthread_mutex_unlock(mysql_bin_log.get_log_lock()); // lockdep, OK
+  MYSQL_MUTEX_UNLOCK(mysql_bin_log.get_log_lock()); // lockdep, OK
   
   cur_dir_len= dirname_length(cur.log_file_name);
 
@@ -1790,7 +1790,7 @@ static void fix_slave_net_timeout(THD *t
 {
   DBUG_ENTER("fix_slave_net_timeout");
 #ifdef HAVE_REPLICATION
-  pthread_mutex_lock(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
   DBUG_PRINT("info",("slave_net_timeout=%lu mi->heartbeat_period=%.3f",
                      slave_net_timeout,
                      (active_mi? active_mi->heartbeat_period : 0.0)));
@@ -1801,7 +1801,7 @@ static void fix_slave_net_timeout(THD *t
                         " exceeds the new value of `slave_net_timeout' sec."
                         " A sensible value for the period should be"
                         " less than the timeout.");
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
 #endif
   DBUG_VOID_RETURN;
 }
@@ -1871,15 +1871,15 @@ static int show_slave_skip_errors(THD *t
 bool sys_var_slave_skip_counter::check(THD *thd, set_var *var)
 {
   int result= 0;
-  pthread_mutex_lock(&LOCK_active_mi);
-  pthread_mutex_lock(&active_mi->rli.run_lock);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&active_mi->rli.run_lock);
   if (active_mi->rli.slave_running)
   {
     my_message(ER_SLAVE_MUST_STOP, ER(ER_SLAVE_MUST_STOP), MYF(0));
     result=1;
   }
-  pthread_mutex_unlock(&active_mi->rli.run_lock);
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&active_mi->rli.run_lock);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   var->save_result.ulong_value= (ulong) var->value->val_int();
   return result;
 }
@@ -1887,8 +1887,8 @@ bool sys_var_slave_skip_counter::check(T
 
 bool sys_var_slave_skip_counter::update(THD *thd, set_var *var)
 {
-  pthread_mutex_lock(&LOCK_active_mi);
-  pthread_mutex_lock(&active_mi->rli.run_lock);
+  MYSQL_MUTEX_LOCK(&LOCK_active_mi);
+  MYSQL_MUTEX_LOCK(&active_mi->rli.run_lock);
   /*
     The following test should normally never be true as we test this
     in the check function;  To be safe against multiple
@@ -1896,12 +1896,12 @@ bool sys_var_slave_skip_counter::update(
   */
   if (!active_mi->rli.slave_running)
   {
-    pthread_mutex_lock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_LOCK(&active_mi->rli.data_lock);
     active_mi->rli.slave_skip_counter= var->save_result.ulong_value;
-    pthread_mutex_unlock(&active_mi->rli.data_lock);
+    MYSQL_MUTEX_UNLOCK(&active_mi->rli.data_lock);
   }
-  pthread_mutex_unlock(&active_mi->rli.run_lock);
-  pthread_mutex_unlock(&LOCK_active_mi);
+  MYSQL_MUTEX_UNLOCK(&active_mi->rli.run_lock);
+  MYSQL_MUTEX_UNLOCK(&LOCK_active_mi);
   return 0;
 }
 

=== modified file 'sql/sql_servers.cc'
--- a/sql/sql_servers.cc	2008-07-17 19:55:18 +0000
+++ b/sql/sql_servers.cc	2008-10-10 20:34:55 +0000
@@ -47,7 +47,10 @@
 
 static HASH servers_cache;
 static MEM_ROOT mem;
-static rw_lock_t THR_LOCK_servers;
+#ifdef HAVE_PSI_INTERFACE
+PSI_rwlock_key key_THR_LOCK_servers;
+#endif
+static mysql_rwlock_t THR_LOCK_servers;
 
 static bool get_server_from_table_to_cache(TABLE *table);
 
@@ -116,7 +119,7 @@ bool servers_init(bool dont_read_servers
   DBUG_ENTER("servers_init");
 
   /* init the mutex */
-  if (my_rwlock_init(&THR_LOCK_servers, NULL))
+  if (MYSQL_RWLOCK_INIT(&THR_LOCK_servers, key_THR_LOCK_servers, NULL))
     DBUG_RETURN(TRUE);
 
   /* initialise our servers cache */
@@ -228,7 +231,7 @@ bool servers_reload(THD *thd)
   thd->locked_tables_list.unlock_locked_tables(thd);
 
   DBUG_PRINT("info", ("locking servers_cache"));
-  rw_wrlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_servers);
 
   bzero((char*) tables, sizeof(tables));
   tables[0].alias= tables[0].table_name= (char*) "servers";
@@ -254,7 +257,7 @@ bool servers_reload(THD *thd)
 end:
   close_thread_tables(thd);
   DBUG_PRINT("info", ("unlocking servers_cache"));
-  rw_unlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_servers);
   DBUG_RETURN(return_val);
 }
 
@@ -586,7 +589,7 @@ int drop_server(THD *thd, LEX_SERVER_OPT
   tables.alias= tables.table_name= (char*) "servers";
   alloc_mdl_locks(&tables, thd->mem_root);
 
-  rw_wrlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_servers);
 
   /* hit the memory hit first */
   if ((error= delete_server_record_in_cache(server_options)))
@@ -610,7 +613,7 @@ int drop_server(THD *thd, LEX_SERVER_OPT
   }
 
 end:
-  rw_unlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_servers);
   DBUG_RETURN(error);
 }
 
@@ -962,7 +965,7 @@ int create_server(THD *thd, LEX_SERVER_O
   DBUG_PRINT("info", ("server_options->server_name %s",
                       server_options->server_name));
 
-  rw_wrlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_servers);
 
   /* hit the memory first */
   if (hash_search(&servers_cache, (uchar*) server_options->server_name,
@@ -983,7 +986,7 @@ int create_server(THD *thd, LEX_SERVER_O
   DBUG_PRINT("info", ("error returned %d", error));
 
 end:
-  rw_unlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_servers);
   DBUG_RETURN(error);
 }
 
@@ -1012,7 +1015,7 @@ int alter_server(THD *thd, LEX_SERVER_OP
   DBUG_PRINT("info", ("server_options->server_name %s",
                       server_options->server_name));
 
-  rw_wrlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_servers);
 
   if (!(existing= (FOREIGN_SERVER *) hash_search(&servers_cache,
                                                  (uchar*) name.str,
@@ -1037,7 +1040,7 @@ int alter_server(THD *thd, LEX_SERVER_OP
 
 end:
   DBUG_PRINT("info", ("error returned %d", error));
-  rw_unlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_servers);
   DBUG_RETURN(error);
 }
 
@@ -1203,7 +1206,7 @@ void servers_free(bool end)
 	my_hash_reset(&servers_cache);
     DBUG_VOID_RETURN;
   }
-  rwlock_destroy(&THR_LOCK_servers);
+  MYSQL_RWLOCK_DESTROY(&THR_LOCK_servers);
   free_root(&mem,MYF(0));
   hash_free(&servers_cache);
   DBUG_VOID_RETURN;
@@ -1285,7 +1288,7 @@ FOREIGN_SERVER *get_server_by_name(MEM_R
   }
 
   DBUG_PRINT("info", ("locking servers_cache"));
-  rw_rdlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_RDLOCK(&THR_LOCK_servers);
   if (!(server= (FOREIGN_SERVER *) hash_search(&servers_cache,
                                                (uchar*) server_name,
                                                server_name_length)))
@@ -1299,7 +1302,7 @@ FOREIGN_SERVER *get_server_by_name(MEM_R
     server= clone_server(mem, server, buff);
 
   DBUG_PRINT("info", ("unlocking servers_cache"));
-  rw_unlock(&THR_LOCK_servers);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_servers);
   DBUG_RETURN(server);
 
 }

=== modified file 'sql/sql_show.cc'
--- a/sql/sql_show.cc	2008-09-16 17:58:49 +0000
+++ b/sql/sql_show.cc	2008-10-10 20:34:55 +0000
@@ -1661,7 +1661,7 @@ void mysqld_list_processes(THD *thd,cons
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_VOID_RETURN;
 
-  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For unlink from list
   if (!thd->killed)
   {
     I_List_iterator<THD> it(threads);
@@ -1694,7 +1694,7 @@ void mysqld_list_processes(THD *thd,cons
           thd_info->db=thd->strdup(thd_info->db);
         thd_info->command=(int) tmp->command;
         if ((mysys_var= tmp->mysys_var))
-          pthread_mutex_lock(&mysys_var->mutex);
+          MYSQL_MUTEX_LOCK(&mysys_var->mutex);
         thd_info->proc_info= (char*) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0);
 #ifndef EMBEDDED_LIBRARY
         thd_info->state_info= (char*) (tmp->net.reading_or_writing ?
@@ -1710,7 +1710,7 @@ void mysqld_list_processes(THD *thd,cons
         thd_info->state_info= (char*)"Writing to net";
 #endif
         if (mysys_var)
-          pthread_mutex_unlock(&mysys_var->mutex);
+          MYSQL_MUTEX_UNLOCK(&mysys_var->mutex);
 
         thd_info->start_time= tmp->start_time;
         thd_info->query=0;
@@ -1728,7 +1728,7 @@ void mysqld_list_processes(THD *thd,cons
       }
     }
   }
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   thread_info *thd_info;
   time_t now= my_time(0);
@@ -1767,7 +1767,7 @@ int fill_schema_processlist(THD* thd, TA
   user= thd->security_ctx->master_access & PROCESS_ACL ?
         NullS : thd->security_ctx->priv_user;
 
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
 
   if (!thd->killed)
   {
@@ -1811,7 +1811,7 @@ int fill_schema_processlist(THD* thd, TA
       }
 
       if ((mysys_var= tmp->mysys_var))
-        pthread_mutex_lock(&mysys_var->mutex);
+        MYSQL_MUTEX_LOCK(&mysys_var->mutex);
       /* COMMAND */
       if ((val= (char *) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0)))
         table->field[4]->store(val, strlen(val), cs);
@@ -1842,7 +1842,7 @@ int fill_schema_processlist(THD* thd, TA
       }
 
       if (mysys_var)
-        pthread_mutex_unlock(&mysys_var->mutex);
+        MYSQL_MUTEX_UNLOCK(&mysys_var->mutex);
 
       /* INFO */
       if (tmp->query)
@@ -1855,13 +1855,13 @@ int fill_schema_processlist(THD* thd, TA
 
       if (schema_table_store_record(thd, table))
       {
-        pthread_mutex_unlock(&LOCK_thread_count);
+        MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
         DBUG_RETURN(1);
       }
     }
   }
 
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_RETURN(0);
 }
 
@@ -1920,7 +1920,7 @@ int add_status_vars(SHOW_VAR *list)
 {
   int res= 0;
   if (status_vars_inited)
-    pthread_mutex_lock(&LOCK_status);
+    MYSQL_MUTEX_LOCK(&LOCK_status);
   if (!all_status_vars.buffer && // array is not allocated yet - do it now
       my_init_dynamic_array(&all_status_vars, sizeof(SHOW_VAR), 200, 20))
   {
@@ -1935,7 +1935,7 @@ int add_status_vars(SHOW_VAR *list)
     sort_dynamic(&all_status_vars, show_var_cmp);
 err:
   if (status_vars_inited)
-    pthread_mutex_unlock(&LOCK_status);
+    MYSQL_MUTEX_UNLOCK(&LOCK_status);
   return res;
 }
 
@@ -1997,7 +1997,7 @@ void remove_status_vars(SHOW_VAR *list)
 {
   if (status_vars_inited)
   {
-    pthread_mutex_lock(&LOCK_status);
+    MYSQL_MUTEX_LOCK(&LOCK_status);
     SHOW_VAR *all= dynamic_element(&all_status_vars, 0, SHOW_VAR *);
     int a= 0, b= all_status_vars.elements, c= (a+b)/2;
 
@@ -2018,7 +2018,7 @@ void remove_status_vars(SHOW_VAR *list)
         all[c].type= SHOW_UNDEF;
     }
     shrink_var_array(&all_status_vars);
-    pthread_mutex_unlock(&LOCK_status);
+    MYSQL_MUTEX_UNLOCK(&LOCK_status);
   }
   else
   {
@@ -2097,7 +2097,7 @@ static bool show_status_array(THD *thd, 
         char *value=var->value;
         const char *pos, *end;                  // We assign a lot of const's
 
-        pthread_mutex_lock(&LOCK_global_system_variables);
+        MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
 
         if (show_type == SHOW_SYS)
         {
@@ -2186,7 +2186,7 @@ static bool show_status_array(THD *thd, 
         table->field[1]->store(pos, (uint32) (end - pos), system_charset_info);
         table->field[1]->set_notnull();
 
-        pthread_mutex_unlock(&LOCK_global_system_variables);
+        MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
 
         if (schema_table_store_record(thd, table))
           DBUG_RETURN(TRUE);
@@ -2205,7 +2205,7 @@ void calc_sum_of_all_status(STATUS_VAR *
   DBUG_ENTER("calc_sum_of_all_status");
 
   /* Ensure that thread id not killed during loop */
-  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count); // For unlink from list
 
   I_List_iterator<THD> it(threads);
   THD *tmp;
@@ -2217,7 +2217,7 @@ void calc_sum_of_all_status(STATUS_VAR *
   while ((tmp= it++))
     add_to_status(to, &tmp->status_var);
   
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 }
 
@@ -3108,7 +3108,7 @@ static int fill_schema_table_from_frm(TH
   }
 
   key_length= create_table_def_key(thd, key, &table_list, 0);
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   share= get_table_share(thd, &table_list, key,
                          key_length, OPEN_VIEW, &error);
   if (!share)
@@ -3163,7 +3163,7 @@ err_share:
   release_table_share(share);
 
 err_unlock:
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
 err:
   mdl_release_lock(&thd->mdl_context, &mdl_lock_data);
@@ -5583,10 +5583,10 @@ int fill_variables(THD *thd, TABLE_LIST 
       schema_table_idx == SCH_GLOBAL_VARIABLES)
     option_type= OPT_GLOBAL;
 
-  rw_rdlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_RDLOCK(&LOCK_system_variables_hash);
   res= show_status_array(thd, wild, enumerate_sys_vars(thd, sorted_vars),
                          option_type, NULL, "", tables->table, upper_case_names);
-  rw_unlock(&LOCK_system_variables_hash);
+  MYSQL_RWLOCK_UNLOCK(&LOCK_system_variables_hash);
   DBUG_RETURN(res);
 }
 
@@ -5622,14 +5622,14 @@ int fill_status(THD *thd, TABLE_LIST *ta
     tmp1= &thd->status_var;
   }
 
-  pthread_mutex_lock(&LOCK_status);
+  MYSQL_MUTEX_LOCK(&LOCK_status);
   if (option_type == OPT_GLOBAL)
     calc_sum_of_all_status(&tmp);
   res= show_status_array(thd, wild,
                          (SHOW_VAR *)all_status_vars.buffer,
                          option_type, tmp1, "", tables->table,
                          upper_case_names);
-  pthread_mutex_unlock(&LOCK_status);
+  MYSQL_MUTEX_UNLOCK(&LOCK_status);
   DBUG_RETURN(res);
 }
 
@@ -7338,7 +7338,7 @@ TABLE_LIST *get_trigger_table(THD *thd, 
 {
   /* Acquire LOCK_open (stop the server). */
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
 
   /*
     Load base table name from the TRN-file and create TABLE_LIST object.
@@ -7348,7 +7348,7 @@ TABLE_LIST *get_trigger_table(THD *thd, 
 
   /* Release LOCK_open (continue the server). */
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   /* That's it. */
 

=== modified file 'sql/sql_table.cc'
--- a/sql/sql_table.cc	2008-09-04 20:00:04 +0000
+++ b/sql/sql_table.cc	2008-10-10 20:34:55 +0000
@@ -310,7 +310,11 @@ struct st_global_ddl_log
 
 st_global_ddl_log global_ddl_log;
 
-pthread_mutex_t LOCK_gdl;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_LOCK_gdl;
+#endif
+
+mysql_mutex_t LOCK_gdl;
 
 #define DDL_LOG_ENTRY_TYPE_POS 0
 #define DDL_LOG_ACTION_TYPE_POS 1
@@ -467,7 +471,7 @@ static uint read_ddl_log_header()
   global_ddl_log.first_free= NULL;
   global_ddl_log.first_used= NULL;
   global_ddl_log.num_entries= 0;
-  pthread_mutex_init(&LOCK_gdl, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&LOCK_gdl, key_LOCK_gdl, MY_MUTEX_INIT_FAST);
   global_ddl_log.do_release= true;
   DBUG_RETURN(entry_no);
 }
@@ -1036,7 +1040,7 @@ bool execute_ddl_log_entry(THD *thd, uin
   uint read_entry= first_entry;
   DBUG_ENTER("execute_ddl_log_entry");
 
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   do
   {
     if (read_ddl_log_entry(read_entry, &ddl_log_entry))
@@ -1058,7 +1062,7 @@ bool execute_ddl_log_entry(THD *thd, uin
     }
     read_entry= ddl_log_entry.next_entry;
   } while (read_entry);
-  pthread_mutex_unlock(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
   DBUG_RETURN(FALSE);
 }
 
@@ -1162,7 +1166,7 @@ void release_ddl_log()
   if (!global_ddl_log.do_release)
     DBUG_VOID_RETURN;
 
-  pthread_mutex_lock(&LOCK_gdl);
+  MYSQL_MUTEX_LOCK(&LOCK_gdl);
   while (used_list)
   {
     DDL_LOG_MEMORY_ENTRY *tmp= used_list->next_log_entry;
@@ -1177,8 +1181,8 @@ void release_ddl_log()
   }
   close_ddl_log();
   global_ddl_log.inited= 0;
-  pthread_mutex_unlock(&LOCK_gdl);
-  pthread_mutex_destroy(&LOCK_gdl);
+  MYSQL_MUTEX_UNLOCK(&LOCK_gdl);
+  MYSQL_MUTEX_DESTROY(&LOCK_gdl);
   global_ddl_log.do_release= false;
   DBUG_VOID_RETURN;
 }
@@ -1355,7 +1359,7 @@ bool mysql_write_frm(ALTER_PARTITION_PAR
       completing this we write a new phase to the log entry that will
       deactivate it.
     */
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     if (my_delete(frm_name, MYF(MY_WME)) ||
 #ifdef WITH_PARTITION_STORAGE_ENGINE
         lpt->table->file->ha_create_handler_files(path, shadow_path,
@@ -1406,7 +1410,7 @@ bool mysql_write_frm(ALTER_PARTITION_PAR
 #endif
 
 err:
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
     deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos);
     part_info->frm_log_entry= NULL;
@@ -1561,7 +1565,7 @@ int mysql_rm_table_part2(THD *thd, TABLE
     .frm file to find if the table is a normal table (not view) and what
     engine to use.
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   for (table= tables; table; table= table->next_local)
   {
     TABLE_SHARE *share;
@@ -1574,12 +1578,12 @@ int mysql_rm_table_part2(THD *thd, TABLE
         check_if_log_table(table->db_length, table->db,
                            table->table_name_length, table->table_name, 1))
     {
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       my_error(ER_BAD_LOG_STATEMENT, MYF(0), "DROP");
       DBUG_RETURN(1);
     }
   }
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (!drop_temporary)
   {
@@ -1587,10 +1591,10 @@ int mysql_rm_table_part2(THD *thd, TABLE
     {
       if (lock_table_names(thd, tables))
         DBUG_RETURN(1);
-      pthread_mutex_lock(&LOCK_open);
+      MYSQL_MUTEX_LOCK(&LOCK_open);
       for (table= tables; table; table= table->next_local)
         tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
     }
     else
     {
@@ -1703,7 +1707,7 @@ int mysql_rm_table_part2(THD *thd, TABLE
       TODO: Investigate what should be done to remove this lock completely.
             Is exclusive meta-data lock enough ?
     */
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     if (drop_temporary ||
         (table_type == NULL &&        
          (access(path, F_OK) &&
@@ -1756,7 +1760,7 @@ int mysql_rm_table_part2(THD *thd, TABLE
         error|= new_error;
       }
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     if (error)
     {
       if (wrong_tables.length())
@@ -3544,7 +3548,7 @@ bool mysql_create_table_no_lock(THD *thd
                         file->engine_name()->str,
                         "TRANSACTIONAL=1");
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
   {
     if (!access(path,F_OK))
@@ -3669,7 +3673,7 @@ bool mysql_create_table_no_lock(THD *thd
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   error= FALSE;
 unlock_and_end:
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
 err:
   thd_proc_info(thd, "After create");
@@ -3743,21 +3747,21 @@ bool mysql_create_table(THD *thd, const 
   DBUG_ENTER("mysql_create_table");
 
   /* Wait for any database locks */
-  pthread_mutex_lock(&LOCK_lock_db);
+  MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   while (!thd->killed &&
          hash_search(&lock_db_cache,(uchar*) db, strlen(db)))
   {
     wait_for_condition(thd, &LOCK_lock_db, &COND_refresh);
-    pthread_mutex_lock(&LOCK_lock_db);
+    MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   }
 
   if (thd->killed)
   {
-    pthread_mutex_unlock(&LOCK_lock_db);
+    MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
     DBUG_RETURN(TRUE);
   }
   creating_table++;
-  pthread_mutex_unlock(&LOCK_lock_db);
+  MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
 
   if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
   {
@@ -3796,10 +3800,10 @@ unlock:
     mdl_release_lock(&thd->mdl_context, target_lock_data);
     mdl_remove_lock(&thd->mdl_context, target_lock_data);
   }
-  pthread_mutex_lock(&LOCK_lock_db);
+  MYSQL_MUTEX_LOCK(&LOCK_lock_db);
   if (!--creating_table && creating_database)
-    pthread_cond_signal(&COND_refresh);
-  pthread_mutex_unlock(&LOCK_lock_db);
+    MYSQL_COND_SIGNAL(&COND_refresh);
+  MYSQL_MUTEX_UNLOCK(&LOCK_lock_db);
   DBUG_RETURN(result);
 }
 
@@ -3986,21 +3990,21 @@ static int prepare_for_repair(THD *thd, 
       DBUG_RETURN(0);
     }
 
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     if (!(share= (get_table_share(thd, table_list, key, key_length, 0,
                                   &error))))
     {
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       DBUG_RETURN(0);				// Can't open frm file
     }
 
     if (open_table_from_share(thd, share, "", 0, 0, 0, &tmp_table, OTM_OPEN))
     {
       release_table_share(share);
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       DBUG_RETURN(0);                           // Out of memory
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     table= &tmp_table;
     table_list->mdl_lock_data= mdl_lock_data;
   }
@@ -4112,9 +4116,9 @@ end:
   thd->locked_tables_list.unlink_all_closed_tables();
   if (table == &tmp_table)
   {
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     closefrm(table, 1);				// Free allocated memory
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
   }
   /* In case of a temporary table there will be no metadata lock. */
   if (error && mdl_lock_data)
@@ -4661,14 +4665,14 @@ bool mysql_assign_to_keycache(THD* thd, 
   DBUG_ENTER("mysql_assign_to_keycache");
 
   check_opt.init();
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_LOCK(&LOCK_global_system_variables);
   if (!(key_cache= get_key_cache(key_cache_name)))
   {
-    pthread_mutex_unlock(&LOCK_global_system_variables);
+    MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
     my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
     DBUG_RETURN(TRUE);
   }
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  MYSQL_MUTEX_UNLOCK(&LOCK_global_system_variables);
   check_opt.key_cache= key_cache;
   DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
 				"assign_to_keycache", TL_READ_NO_INSERT, 0, 0,
@@ -4880,12 +4884,12 @@ bool mysql_create_like_table(THD* thd, T
           info). So we should double check and probably fix this code
           to not acquire this mutex.
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   if (src_table->schema_table)
   {
     if (mysql_create_like_schema_frm(thd, src_table, dst_path, create_info))
     {
-      pthread_mutex_unlock(&LOCK_open);
+      MYSQL_MUTEX_UNLOCK(&LOCK_open);
       goto err;
     }
   }
@@ -4895,7 +4899,7 @@ bool mysql_create_like_table(THD* thd, T
       my_error(ER_BAD_DB_ERROR,MYF(0),db);
     else
       my_error(ER_CANT_CREATE_FILE,MYF(0),dst_path,my_errno);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     goto err;
   }
 
@@ -4924,7 +4928,7 @@ bool mysql_create_like_table(THD* thd, T
   if (thd->variables.keep_files_on_create)
     create_info->options|= HA_CREATE_KEEP_FILES;
   err= ha_create_table(thd, dst_path, db, table_name, create_info, 1);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
   {
@@ -4990,14 +4994,14 @@ bool mysql_create_like_table(THD* thd, T
         write_bin_log(thd, TRUE, query.ptr(), query.length());
 
         DBUG_ASSERT(thd->open_tables == table->table);
-        pthread_mutex_lock(&LOCK_open);
+        MYSQL_MUTEX_LOCK(&LOCK_open);
         /*
           When opening the table, we ignored the locked tables
           (MYSQL_OPEN_GET_NEW_TABLE). Now we can close the table without
           risking to close some locked table.
         */
         close_thread_table(thd, &thd->open_tables);
-        pthread_mutex_unlock(&LOCK_open);
+        MYSQL_MUTEX_UNLOCK(&LOCK_open);
       }
       else                                      // Case 1
         write_bin_log(thd, TRUE, thd->query, thd->query_length);
@@ -5854,13 +5858,13 @@ mysql_fast_or_online_alter_table(THD *th
     The final .frm file is already created as a temporary file.
     Let's rename it to the original table name.
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   error= mysql_rename_table(NULL,
                             altered_table->s->db.str,
                             altered_table->s->table_name.str,
                             table_list->db, table_list->table_name,
                             FN_FROM_IS_TMP);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   /*
     The ALTER TABLE is always in its own transaction.
@@ -5895,9 +5899,9 @@ mysql_fast_or_online_alter_table(THD *th
       error= 2;
 
     DBUG_ASSERT(thd->open_tables == table);
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
     close_thread_table(thd, &thd->open_tables);
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
     table_list->table= 0;
   }
   DBUG_ASSERT(table_list->table == 0);
@@ -6488,7 +6492,7 @@ bool mysql_alter_table(THD *thd,char *ne
       goto view_err;
     }
 
-    pthread_mutex_lock(&LOCK_open);
+    MYSQL_MUTEX_LOCK(&LOCK_open);
 
     if (!do_rename(thd, table_list, new_db, new_name, new_name, 1))
     {
@@ -6500,7 +6504,7 @@ bool mysql_alter_table(THD *thd,char *ne
       }
       my_ok(thd);
     }
-    pthread_mutex_unlock(&LOCK_open);
+    MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
     unlock_table_names(thd);
 
@@ -6701,7 +6705,7 @@ view_err:
       else
       {
         *fn_ext(new_name)=0;
-        pthread_mutex_lock(&LOCK_open);
+        MYSQL_MUTEX_LOCK(&LOCK_open);
         if (mysql_rename_table(old_db_type,db,table_name,new_db,new_alias, 0))
           error= -1;
         else if (Table_triggers_list::change_table_name(thd, db, table_name,
@@ -6711,7 +6715,7 @@ view_err:
                                     table_name, 0);
           error= -1;
         }
-        pthread_mutex_unlock(&LOCK_open);
+        MYSQL_MUTEX_UNLOCK(&LOCK_open);
       }
     }
 
@@ -7084,7 +7088,7 @@ view_err:
     table is renamed and the SE is also changed, then an intermediate table
     is created and the additional call will not take place.
   */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   if (mysql_rename_table(old_db_type, db, table_name, db, old_name,
                          FN_TO_IS_TMP))
   {
@@ -7108,7 +7112,7 @@ view_err:
   if (! error)
   (void) quick_rm_table(old_db_type, db, old_name, FN_IS_TMP);
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (error)
     goto err_with_mdl;

=== modified file 'sql/sql_test.cc'
--- a/sql/sql_test.cc	2008-06-28 11:00:59 +0000
+++ b/sql/sql_test.cc	2008-10-10 20:34:55 +0000
@@ -77,7 +77,7 @@ void print_cached_tables(void)
   TABLE *start_link, *lnk, *entry;
 
   /* purecov: begin tested */
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   puts("DB             Table                            Version  Thread  Open  Lock");
 
   for (idx=unused=0 ; idx < table_def_cache.records ; idx++)
@@ -124,7 +124,7 @@ void print_cached_tables(void)
   if (hash_check(&table_def_cache))
     printf("Error: Table definition hash table is corrupted\n");
   fflush(stdout);
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   /* purecov: end */
   return;
 }
@@ -425,12 +425,12 @@ static void display_table_locks(void) 
   DYNAMIC_ARRAY saved_table_locks;
 
   (void) my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO), table_cache_count + 20,50);
-  pthread_mutex_lock(&THR_LOCK_lock);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_lock);
   for (list= thr_lock_thread_list; list; list= list_rest(list))
   {
     THR_LOCK *lock=(THR_LOCK*) list->data;
 
-    pthread_mutex_lock(&lock->mutex);
+    MYSQL_MUTEX_LOCK(&lock->mutex);
     push_locks_into_array(&saved_table_locks, lock->write.data, FALSE,
 			  "Locked - write");
     push_locks_into_array(&saved_table_locks, lock->write_wait.data, TRUE,
@@ -439,9 +439,9 @@ static void display_table_locks(void) 
 			  "Locked - read");
     push_locks_into_array(&saved_table_locks, lock->read_wait.data, TRUE,
 			  "Waiting - read");
-    pthread_mutex_unlock(&lock->mutex);
+    MYSQL_MUTEX_UNLOCK(&lock->mutex);
   }
-  pthread_mutex_unlock(&THR_LOCK_lock);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_lock);
   if (!saved_table_locks.elements) goto end;
   
   qsort((uchar*) dynamic_element(&saved_table_locks,0,TABLE_LOCK_INFO *),saved_table_locks.elements,sizeof(TABLE_LOCK_INFO),(qsort_cmp) dl_compare);
@@ -517,7 +517,7 @@ void mysql_print_status()
   /* Print key cache status */
   puts("\nKey caches:");
   process_key_caches(print_key_cache_status);
-  pthread_mutex_lock(&LOCK_status);
+  MYSQL_MUTEX_LOCK(&LOCK_status);
   printf("\nhandler status:\n\
 read_key:   %10lu\n\
 read_next:  %10lu\n\
@@ -533,7 +533,7 @@ update:     %10lu\n",
 	 tmp.ha_write_count,
 	 tmp.ha_delete_count,
 	 tmp.ha_update_count);
-  pthread_mutex_unlock(&LOCK_status);
+  MYSQL_MUTEX_UNLOCK(&LOCK_status);
   printf("\nTable status:\n\
 Opened tables: %10lu\n\
 Open tables:   %10lu\n\

=== modified file 'sql/sql_trigger.cc'
--- a/sql/sql_trigger.cc	2008-07-15 16:29:51 +0000
+++ b/sql/sql_trigger.cc	2008-10-10 20:34:55 +0000
@@ -482,11 +482,11 @@ bool mysql_create_or_drop_trigger(THD *t
       goto end;
   }
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   result= (create ?
            table->triggers->create_trigger(thd, tables, &stmt_query):
            table->triggers->drop_trigger(thd, tables, &stmt_query));
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
 
   if (result)
     goto end;
@@ -1857,7 +1857,7 @@ bool Table_triggers_list::change_table_n
   */
 #ifndef DBUG_OFF
   if (mdl_is_exclusive_lock_owner(&thd->mdl_context, 0, db, old_table))
-    safe_mutex_assert_owner(&LOCK_open);
+    MYSQL_MUTEX_ASSERT_OWNER(&LOCK_open);
 #endif
 
   DBUG_ASSERT(my_strcasecmp(table_alias_charset, db, new_db) ||

=== modified file 'sql/sql_udf.cc'
--- a/sql/sql_udf.cc	2008-08-26 12:00:01 +0000
+++ b/sql/sql_udf.cc	2008-10-10 20:34:55 +0000
@@ -44,7 +44,11 @@ extern "C"
 static bool initialized = 0;
 static MEM_ROOT mem;
 static HASH udf_hash;
-static rw_lock_t THR_LOCK_udf;
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_rwlock_key key_THR_LOCK_udf;
+#endif
+static mysql_rwlock_t THR_LOCK_udf;
 
 
 static udf_func *add_udf(LEX_STRING *name, Item_result ret,
@@ -119,7 +123,7 @@ void udf_init()
   if (initialized)
     DBUG_VOID_RETURN;
 
-  my_rwlock_init(&THR_LOCK_udf,NULL);
+  MYSQL_RWLOCK_INIT(&THR_LOCK_udf, key_THR_LOCK_udf, NULL);
   
   init_sql_alloc(&mem, UDF_ALLOC_BLOCK_SIZE, 0);
   THD *new_thd = new THD;
@@ -257,7 +261,7 @@ void udf_free()
   if (initialized)
   {
     initialized= 0;
-    rwlock_destroy(&THR_LOCK_udf);
+    MYSQL_RWLOCK_DESTROY(&THR_LOCK_udf);
   }
   DBUG_VOID_RETURN;
 }
@@ -295,7 +299,7 @@ void free_udf(udf_func *udf)
   if (!initialized)
     DBUG_VOID_RETURN;
 
-  rw_wrlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_udf);
   if (!--udf->usage_count)
   {
     /*
@@ -307,7 +311,7 @@ void free_udf(udf_func *udf)
     if (!find_udf_dl(udf->dl))
       dlclose(udf->dlhandle);
   }
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
   DBUG_VOID_RETURN;
 }
 
@@ -324,9 +328,9 @@ udf_func *find_udf(const char *name,uint
 
   /* TODO: This should be changed to reader locks someday! */
   if (mark_used)
-    rw_wrlock(&THR_LOCK_udf);  /* Called during fix_fields */
+    MYSQL_RWLOCK_WRLOCK(&THR_LOCK_udf);  /* Called during fix_fields */
   else
-    rw_rdlock(&THR_LOCK_udf);  /* Called during parsing */
+    MYSQL_RWLOCK_RDLOCK(&THR_LOCK_udf);  /* Called during parsing */
 
   if ((udf=(udf_func*) hash_search(&udf_hash,(uchar*) name,
 				   length ? length : (uint) strlen(name))))
@@ -336,7 +340,7 @@ udf_func *find_udf(const char *name,uint
     else if (mark_used)
       udf->usage_count++;
   }
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
   DBUG_RETURN(udf);
 }
 
@@ -436,7 +440,7 @@ int mysql_create_function(THD *thd,udf_f
   if (thd->current_stmt_binlog_row_based)
     thd->clear_current_stmt_binlog_row_based();
 
-  rw_wrlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_udf);
   if ((hash_search(&udf_hash,(uchar*) udf->name.str, udf->name.length)))
   {
     my_error(ER_UDF_EXISTS, MYF(0), udf->name.str);
@@ -500,7 +504,7 @@ int mysql_create_function(THD *thd,udf_f
     del_udf(u_d);
     goto err;
   }
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
 
   /* Binlog the create function. */
   write_bin_log(thd, TRUE, thd->query, thd->query_length);
@@ -510,7 +514,7 @@ int mysql_create_function(THD *thd,udf_f
  err:
   if (new_dl)
     dlclose(dl);
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
   DBUG_RETURN(1);
 }
 
@@ -540,7 +544,7 @@ int mysql_drop_function(THD *thd,const L
   if (thd->current_stmt_binlog_row_based)
     thd->clear_current_stmt_binlog_row_based();
 
-  rw_wrlock(&THR_LOCK_udf);  
+  MYSQL_RWLOCK_WRLOCK(&THR_LOCK_udf);  
   if (!(udf=(udf_func*) hash_search(&udf_hash,(uchar*) udf_name->str,
 				    (uint) udf_name->length)))
   {
@@ -576,14 +580,14 @@ int mysql_drop_function(THD *thd,const L
   }
   close_thread_tables(thd);
 
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
 
   /* Binlog the drop function. */
   write_bin_log(thd, TRUE, thd->query, thd->query_length);
 
   DBUG_RETURN(0);
  err:
-  rw_unlock(&THR_LOCK_udf);
+  MYSQL_RWLOCK_UNLOCK(&THR_LOCK_udf);
   DBUG_RETURN(1);
 }
 

=== modified file 'sql/sql_view.cc'
--- a/sql/sql_view.cc	2008-07-15 16:29:51 +0000
+++ b/sql/sql_view.cc	2008-10-10 20:34:55 +0000
@@ -617,7 +617,7 @@ bool mysql_create_view(THD *thd, TABLE_L
     goto err;
   }
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   res= mysql_register_view(thd, view, mode);
 
   if (mysql_bin_log.is_open())
@@ -662,7 +662,7 @@ bool mysql_create_view(THD *thd, TABLE_L
                       buff.ptr(), buff.length(), FALSE, FALSE);
   }
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   if (view->revision != 1)
     query_cache_invalidate3(thd, view, 0);
   start_waiting_global_read_lock(thd);
@@ -1592,7 +1592,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIS
   if (lock_table_names(thd, views))
     DBUG_RETURN(TRUE);
 
-  pthread_mutex_lock(&LOCK_open);
+  MYSQL_MUTEX_LOCK(&LOCK_open);
   for (view= views; view; view= view->next_local)
   {
     TABLE_SHARE *share;
@@ -1667,7 +1667,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIS
     write_bin_log(thd, !something_wrong, thd->query, thd->query_length);
   }
 
-  pthread_mutex_unlock(&LOCK_open);
+  MYSQL_MUTEX_UNLOCK(&LOCK_open);
   
   if (something_wrong)
   {

=== modified file 'sql/table.cc'
--- a/sql/table.cc	2008-09-16 08:34:30 +0000
+++ b/sql/table.cc	2008-10-10 20:34:55 +0000
@@ -380,7 +380,7 @@ TABLE_SHARE *alloc_table_share(TABLE_LIS
     share->free_tables.empty();
 
     memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
-    pthread_mutex_init(&share->LOCK_ha_data, MY_MUTEX_INIT_FAST);
+    MYSQL_MUTEX_INIT(&share->LOCK_ha_data, key_LOCK_ha_data, MY_MUTEX_INIT_FAST);
   }
   DBUG_RETURN(share);
 }
@@ -471,7 +471,7 @@ void free_table_share(TABLE_SHARE *share
 
   /* The mutex is initialized only for shares that are part of the TDC */
   if (share->tmp_table == NO_TMP_TABLE)
-    pthread_mutex_destroy(&share->LOCK_ha_data);
+    MYSQL_MUTEX_DESTROY(&share->LOCK_ha_data);
   hash_free(&share->name_hash);
 
   plugin_unlock(NULL, share->db_plugin);

=== modified file 'sql/table.h'
--- a/sql/table.h	2008-09-16 17:58:49 +0000
+++ b/sql/table.h	2008-10-10 20:34:55 +0000
@@ -240,6 +240,10 @@ TABLE_CATEGORY get_table_category(const 
 
 struct TABLE_share;
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_ha_data;
+#endif
+
 /*
   This structure is shared between different table objects. There is one
   instance of table share per one table in the database.
@@ -258,7 +262,7 @@ struct TABLE_SHARE
   TYPELIB keynames;			/* Pointers to keynames */
   TYPELIB fieldnames;			/* Pointer to fieldnames */
   TYPELIB *intervals;			/* pointer to interval info */
-  pthread_mutex_t LOCK_ha_data;         /* To protect access to ha_data */
+  mysql_mutex_t LOCK_ha_data;         /* To protect access to ha_data */
   TABLE_SHARE *next, **prev;            /* Link to unused shares */
 
   /*

=== modified file 'sql/tztime.cc'
--- a/sql/tztime.cc	2008-05-08 20:43:28 +0000
+++ b/sql/tztime.cc	2008-10-10 20:34:55 +0000
@@ -1429,7 +1429,10 @@ static MEM_ROOT tz_storage;
   time zone in offset_tzs or creating if it didn't existed before in
   tz_storage. So contention is low.
 */
-static pthread_mutex_t tz_LOCK;
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_tz_LOCK;
+#endif
+static mysql_mutex_t tz_LOCK;
 static bool tz_inited= 0;
 
 /*
@@ -1592,7 +1595,7 @@ my_tz_init(THD *org_thd, const char *def
     goto end;
   }
   init_sql_alloc(&tz_storage, 32 * 1024, 0);
-  pthread_mutex_init(&tz_LOCK, MY_MUTEX_INIT_FAST);
+  MYSQL_MUTEX_INIT(&tz_LOCK, key_tz_LOCK, MY_MUTEX_INIT_FAST);
   tz_inited= 1;
 
   /* Add 'SYSTEM' time zone to tz_names hash */
@@ -1770,7 +1773,7 @@ void my_tz_free()
   if (tz_inited)
   {
     tz_inited= 0;
-    pthread_mutex_destroy(&tz_LOCK);
+    MYSQL_MUTEX_DESTROY(&tz_LOCK);
     hash_free(&offset_tzs);
     hash_free(&tz_names);
     free_root(&tz_storage, MYF(0));
@@ -2231,7 +2234,7 @@ my_tz_find(THD *thd, const String *name)
   if (!name)
     DBUG_RETURN(0);
 
-  pthread_mutex_lock(&tz_LOCK);
+  MYSQL_MUTEX_LOCK(&tz_LOCK);
 
   if (!str_to_offset(name->ptr(), name->length(), &offset))
   {
@@ -2273,7 +2276,7 @@ my_tz_find(THD *thd, const String *name)
     }
   }
 
-  pthread_mutex_unlock(&tz_LOCK);
+  MYSQL_MUTEX_UNLOCK(&tz_LOCK);
 
   DBUG_RETURN(result_tz);
 }

=== modified file 'sql/udf_example.c'
--- a/sql/udf_example.c	2008-05-29 15:44:11 +0000
+++ b/sql/udf_example.c	2008-10-10 20:34:55 +0000
@@ -139,7 +139,7 @@ typedef long long longlong;
 #include <mysql.h>
 #include <ctype.h>
 
-static pthread_mutex_t LOCK_hostname;
+static mysql_mutex_t LOCK_hostname;
 
 #ifdef HAVE_DLOPEN
 
@@ -727,7 +727,7 @@ my_bool lookup_init(UDF_INIT *initid, UD
 void lookup_deinit(UDF_INIT *initid __attribute__((unused)))
 {
 #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_SOLARIS_STYLE_GETHOST)
-  (void) pthread_mutex_destroy(&LOCK_hostname);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_hostname);
 #endif
 }
 
@@ -762,14 +762,14 @@ char *lookup(UDF_INIT *initid __attribut
     return 0;
   }
 #else
-  pthread_mutex_lock(&LOCK_hostname);
+  MYSQL_MUTEX_LOCK(&LOCK_hostname);
   if (!(hostent= gethostbyname((char*) name_buff)))
   {
-    pthread_mutex_unlock(&LOCK_hostname);
+    MYSQL_MUTEX_UNLOCK(&LOCK_hostname);
     *null_value= 1;
     return 0;
   }
-  pthread_mutex_unlock(&LOCK_hostname);
+  MYSQL_MUTEX_UNLOCK(&LOCK_hostname);
 #endif
   memcpy_fixed((char*) &in,(char*) *hostent->h_addr_list, sizeof(in.s_addr));
   *res_length= (ulong) (strmov(result, inet_ntoa(in)) - result);
@@ -807,7 +807,7 @@ my_bool reverse_lookup_init(UDF_INIT *in
 void reverse_lookup_deinit(UDF_INIT *initid __attribute__((unused)))
 {
 #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_SOLARIS_STYLE_GETHOST)
-  (void) pthread_mutex_destroy(&LOCK_hostname);
+  (void) MYSQL_MUTEX_DESTROY(&LOCK_hostname);
 #endif
 }
 
@@ -866,14 +866,14 @@ char *reverse_lookup(UDF_INIT *initid __
     return 0;
   }
 #else
-  pthread_mutex_lock(&LOCK_hostname);
+  MYSQL_MUTEX_LOCK(&LOCK_hostname);
   if (!(hp= gethostbyaddr((char*) &taddr, sizeof(taddr), AF_INET)))
   {
-    pthread_mutex_unlock(&LOCK_hostname);
+    MYSQL_MUTEX_UNLOCK(&LOCK_hostname);
     *null_value= 1;
     return 0;
   }
-  pthread_mutex_unlock(&LOCK_hostname);
+  MYSQL_MUTEX_UNLOCK(&LOCK_hostname);
 #endif
   *res_length=(ulong) (strmov(result,hp->h_name) - result);
   return result;

=== modified file 'storage/federated/ha_federated.cc'
--- a/storage/federated/ha_federated.cc	2008-08-15 19:58:03 +0000
+++ b/storage/federated/ha_federated.cc	2008-10-10 20:34:55 +0000
@@ -387,7 +387,13 @@
 
 /* Variables for federated share methods */
 static HASH federated_open_tables;              // To track open tables
-pthread_mutex_t federated_mutex;                // To init the hash
+
+#ifdef HAVE_PSI_INTERFACE
+PSI_mutex_key key_FEDERATED_SHARE_mutex;
+PSI_mutex_key key_federated_mutex;
+#endif
+
+mysql_mutex_t federated_mutex;                // To init the hash
 static char ident_quote_char= '`';              // Character for quoting
                                                 // identifiers
 static char value_quote_char= '\'';             // Character for quoting
@@ -456,7 +462,7 @@ int federated_db_init(void *p)
   federated_hton->commit= 0;
   federated_hton->rollback= 0;
 
-  if (pthread_mutex_init(&federated_mutex, MY_MUTEX_INIT_FAST))
+  if (MYSQL_MUTEX_INIT(&federated_mutex, key_federated_mutex, MY_MUTEX_INIT_FAST))
     goto error;
   if (!hash_init(&federated_open_tables, &my_charset_bin, 32, 0, 0,
                     (hash_get_key) federated_get_key, 0, 0))
@@ -464,7 +470,7 @@ int federated_db_init(void *p)
     DBUG_RETURN(FALSE);
   }
 
-  pthread_mutex_destroy(&federated_mutex);
+  MYSQL_MUTEX_DESTROY(&federated_mutex);
 error:
   DBUG_RETURN(TRUE);
 }
@@ -483,7 +489,7 @@ error:
 int federated_done(void *p)
 {
   hash_free(&federated_open_tables);
-  pthread_mutex_destroy(&federated_mutex);
+  MYSQL_MUTEX_DESTROY(&federated_mutex);
 
   return 0;
 }
@@ -1484,7 +1490,7 @@ static FEDERATED_SHARE *get_share(const 
 
   init_alloc_root(&mem_root, 256, 0);
 
-  pthread_mutex_lock(&federated_mutex);
+  MYSQL_MUTEX_LOCK(&federated_mutex);
 
   tmp_share.share_key= table_name;
   tmp_share.share_key_length= strlen(table_name);
@@ -1526,18 +1532,18 @@ static FEDERATED_SHARE *get_share(const 
     if (my_hash_insert(&federated_open_tables, (uchar*) share))
       goto error;
     thr_lock_init(&share->lock);
-    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
+    MYSQL_MUTEX_INIT(&share->mutex, key_FEDERATED_SHARE_mutex, MY_MUTEX_INIT_FAST);
   }
   else
     free_root(&mem_root, MYF(0)); /* prevents memory leak */
 
   share->use_count++;
-  pthread_mutex_unlock(&federated_mutex);
+  MYSQL_MUTEX_UNLOCK(&federated_mutex);
 
   DBUG_RETURN(share);
 
 error:
-  pthread_mutex_unlock(&federated_mutex);
+  MYSQL_MUTEX_UNLOCK(&federated_mutex);
   free_root(&mem_root, MYF(0));
   DBUG_RETURN(NULL);
 }
@@ -1554,15 +1560,15 @@ static int free_share(FEDERATED_SHARE *s
   MEM_ROOT mem_root= share->mem_root;
   DBUG_ENTER("free_share");
 
-  pthread_mutex_lock(&federated_mutex);
+  MYSQL_MUTEX_LOCK(&federated_mutex);
   if (!--share->use_count)
   {
     hash_delete(&federated_open_tables, (uchar*) share);
     thr_lock_delete(&share->lock);
-    pthread_mutex_destroy(&share->mutex);
+    MYSQL_MUTEX_DESTROY(&share->mutex);
     free_root(&mem_root, MYF(0));
   }
-  pthread_mutex_unlock(&federated_mutex);
+  MYSQL_MUTEX_UNLOCK(&federated_mutex);
 
   DBUG_RETURN(0);
 }
@@ -3079,7 +3085,7 @@ int ha_federated::real_connect()
     to establish Federated connection to guard against a trivial
     Denial of Service scenerio.
   */
-  safe_mutex_assert_not_owner(&LOCK_open);
+  MYSQL_MUTEX_ASSERT_NOT_OWNER(&LOCK_open);
 
   DBUG_ASSERT(mysql == NULL);
 

=== modified file 'storage/federated/ha_federated.h'
--- a/storage/federated/ha_federated.h	2008-08-15 12:18:06 +0000
+++ b/storage/federated/ha_federated.h	2008-10-10 20:34:55 +0000
@@ -38,6 +38,10 @@
 #define FEDERATED_RECORDS_IN_RANGE 2
 #define FEDERATED_MAX_KEY_LENGTH 3500 // Same as innodb
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_FEDERATED_SHARE_mutex;
+#endif
+
 /*
   FEDERATED_SHARE is a structure that will be shared amoung all open handlers
   The example implements the minimum of what you will probably need.
@@ -71,7 +75,7 @@ typedef struct st_federated_share {
   ushort port;
 
   uint table_name_length, server_name_length, connect_string_length, use_count;
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   THR_LOCK lock;
 } FEDERATED_SHARE;
 

=== modified file 'storage/maria/ha_maria.cc'
--- a/storage/maria/ha_maria.cc	2008-09-04 18:30:34 +0000
+++ b/storage/maria/ha_maria.cc	2008-10-10 20:34:55 +0000
@@ -1035,14 +1035,14 @@ int ha_maria::check(THD * thd, HA_CHECK_
         (param.testflag & T_STATISTICS) || maria_is_crashed(file))
     {
       file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       share->state.changed &= ~(STATE_CHANGED | STATE_CRASHED |
                                 STATE_CRASHED_ON_REPAIR);
       if (!(table->db_stat & HA_READ_ONLY))
         error= maria_update_state_info(&param, file,
                                        UPDATE_TIME | UPDATE_OPEN_COUNT |
                                        UPDATE_STAT);
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |
            HA_STATUS_CONST);
     }
@@ -1086,9 +1086,9 @@ int ha_maria::analyze(THD *thd, HA_CHECK
   error= maria_chk_key(&param, file);
   if (!error)
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     error= maria_update_state_info(&param, file, UPDATE_STAT);
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   else if (!maria_is_crashed(file) && !thd->killed)
     maria_mark_crashed(file);
@@ -1169,9 +1169,9 @@ int ha_maria::zerofill(THD * thd, HA_CHE
 
   if (!error)
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     maria_update_state_info(&param, file, UPDATE_TIME | UPDATE_OPEN_COUNT);
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   return error;
 }
@@ -1324,7 +1324,7 @@ int ha_maria::repair(THD *thd, HA_CHECK 
     }
   }
   thd_proc_info(thd, "Saving state");
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   if (!error)
   {
     if ((share->state.changed & STATE_CHANGED) || maria_is_crashed(file))
@@ -1364,7 +1364,7 @@ int ha_maria::repair(THD *thd, HA_CHECK 
     file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
     maria_update_state_info(param, file, 0);
   }
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   thd_proc_info(thd, old_proc_info);
   if (!thd->locked_tables_mode)
     maria_lock_database(file, F_UNLCK);
@@ -1810,10 +1810,10 @@ bool ha_maria::check_and_repair(THD *thd
 
   old_query= thd->query;
   old_query_length= thd->query_length;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query= table->s->table_name.str;
   thd->query_length= table->s->table_name.length;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if (!(crashed= maria_is_crashed(file)))
   {
@@ -1831,10 +1831,10 @@ bool ha_maria::check_and_repair(THD *thd
     if (repair(thd, &check_opt))
       error= 1;
   }
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query= old_query;
   thd->query_length= old_query_length;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_RETURN(error);
 }
 
@@ -2050,7 +2050,7 @@ int ha_maria::info(uint flag)
 
     /* Update share */
     if (share->tmp_table == NO_TMP_TABLE)
-      pthread_mutex_lock(&share->LOCK_ha_data);
+      MYSQL_MUTEX_LOCK(&share->LOCK_ha_data);
     share->keys_in_use.set_prefix(share->keys);
     share->keys_in_use.intersect_extended(maria_info.key_map);
     share->keys_for_keyread.intersect(share->keys_in_use);
@@ -2063,7 +2063,7 @@ int ha_maria::info(uint flag)
         *to= (ulong) (*from + 0.5);
     }
     if (share->tmp_table == NO_TMP_TABLE)
-      pthread_mutex_unlock(&share->LOCK_ha_data);
+      MYSQL_MUTEX_UNLOCK(&share->LOCK_ha_data);
 
     /*
        Set data_file_name and index_file_name to point at the symlink value

=== modified file 'storage/maria/lockman.c'
--- a/storage/maria/lockman.c	2008-02-21 00:51:51 +0000
+++ b/storage/maria/lockman.c	2008-10-10 20:34:55 +0000
@@ -676,14 +676,14 @@ enum lockman_getlock_result lockman_getl
       if there're other active LOCK_OWNERs.
     */
     /* QQ: race condition here */
-    pthread_mutex_lock(wait_for_lo->mutex);
+    MYSQL_MUTEX_LOCK(wait_for_lo->mutex);
     if (DELETED(blocker->link))
     {
       /*
         blocker transaction was ended, or a savepoint that owned
         the lock was rolled back. Either way - the lock was removed
       */
-      pthread_mutex_unlock(wait_for_lo->mutex);
+      MYSQL_MUTEX_UNLOCK(wait_for_lo->mutex);
       lf_rwlock_by_pins(pins);
       continue;
     }
@@ -693,9 +693,9 @@ enum lockman_getlock_result lockman_getl
     set_timespec_nsec(timeout,lm->lock_timeout * 1000000);
     do
     {
-      pthread_cond_timedwait(wait_for_lo->cond, wait_for_lo->mutex, &timeout);
+      MYSQL_COND_TIMEDWAIT(wait_for_lo->cond, wait_for_lo->mutex, &timeout);
     } while (!DELETED(blocker->link) && my_getsystime() < deadline);
-    pthread_mutex_unlock(wait_for_lo->mutex);
+    MYSQL_MUTEX_UNLOCK(wait_for_lo->mutex);
     lf_rwlock_by_pins(pins);
     if (!DELETED(blocker->link))
     {
@@ -729,7 +729,7 @@ int lockman_release_locks(LOCKMAN *lm, L
   uint bucket;
   LF_PINS *pins= lo->pins;
 
-  pthread_mutex_lock(lo->mutex);
+  MYSQL_MUTEX_LOCK(lo->mutex);
   lf_rwlock_by_pins(pins);
   for (node= lo->all_locks; node; node= next)
   {
@@ -744,8 +744,8 @@ int lockman_release_locks(LOCKMAN *lm, L
   lf_rwunlock_by_pins(pins);
   lo->all_locks= 0;
   /* now signal all waiters */
-  pthread_cond_broadcast(lo->cond);
-  pthread_mutex_unlock(lo->mutex);
+  MYSQL_COND_BROADCAST(lo->cond);
+  MYSQL_MUTEX_UNLOCK(lo->mutex);
   return 0;
 }
 

=== modified file 'storage/maria/lockman.h'
--- a/storage/maria/lockman.h	2007-12-18 22:22:55 +0000
+++ b/storage/maria/lockman.h	2008-10-10 20:34:55 +0000
@@ -40,8 +40,8 @@ struct st_lock_owner {
   LF_PINS  *pins;           /* must be allocated from lockman's pinbox       */
   struct lockman_lock *all_locks; /* a LIFO                                  */
   LOCK_OWNER  *waiting_for;
-  pthread_cond_t  *cond;    /* transactions waiting for this, wait on 'cond' */
-  pthread_mutex_t *mutex;   /* mutex is required to use 'cond'               */
+  mysql_cond_t  *cond;    /* transactions waiting for this, wait on 'cond' */
+  mysql_mutex_t *mutex;   /* mutex is required to use 'cond'               */
   uint16    loid;
 };
 

=== modified file 'storage/maria/ma_bitmap.c'
--- a/storage/maria/ma_bitmap.c	2008-04-03 13:40:25 +0000
+++ b/storage/maria/ma_bitmap.c	2008-10-10 20:34:55 +0000
@@ -260,8 +260,8 @@ my_bool _ma_bitmap_init(MARIA_SHARE *sha
 my_bool _ma_bitmap_end(MARIA_SHARE *share)
 {
   my_bool res= _ma_bitmap_flush(share);
-  pthread_mutex_destroy(&share->bitmap.bitmap_lock);
-  pthread_cond_destroy(&share->bitmap.bitmap_cond);
+  MYSQL_MUTEX_DESTROY(&share->bitmap.bitmap_lock);
+  MYSQL_COND_DESTROY(&share->bitmap.bitmap_cond);
   delete_dynamic(&share->bitmap.pinned_pages);
   my_free((uchar*) share->bitmap.map, MYF(MY_ALLOW_ZERO_PTR));
   share->bitmap.map= 0;
@@ -293,13 +293,13 @@ my_bool _ma_bitmap_flush(MARIA_SHARE *sh
   DBUG_ENTER("_ma_bitmap_flush");
   if (share->bitmap.changed)
   {
-    pthread_mutex_lock(&share->bitmap.bitmap_lock);
+    MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
     if (share->bitmap.changed)
     {
       share->bitmap.changed= 0;
       res= write_changed_bitmap(share, &share->bitmap);
     }
-    pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+    MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
   }
   DBUG_RETURN(res);
 }
@@ -319,18 +319,18 @@ my_bool _ma_bitmap_wait_or_flush(MARIA_S
   DBUG_ENTER("_ma_bitmap_flush");
   if (bitmap->changed)
   {
-    pthread_mutex_lock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
     while (bitmap->non_flushable && bitmap->changed)
     {
       DBUG_PRINT("info", ("waiting for bitmap to be flushable"));
-      pthread_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
+      MYSQL_COND_WAIT(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
     }
     if (bitmap->changed)
     {
       bitmap->changed= 0;
       res= write_changed_bitmap(share, bitmap);
     }
-    pthread_mutex_unlock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   }
   DBUG_RETURN(res);
 }
@@ -369,7 +369,7 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE
   my_bool res= 0;
   MARIA_FILE_BITMAP *bitmap= &share->bitmap;
   DBUG_ENTER("_ma_bitmap_flush_all");
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
   if (bitmap->changed)
   {
     bitmap->flush_all_requested= TRUE;
@@ -377,7 +377,7 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE
     while (bitmap->non_flushable > 0)
     {
       DBUG_PRINT("info", ("waiting for bitmap to be flushable"));
-      pthread_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
+      MYSQL_COND_WAIT(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
     }
 #endif
     /*
@@ -410,9 +410,9 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE
       become false, wake them up.
     */
     DBUG_PRINT("info", ("bitmap flusher waking up others"));
-    pthread_cond_broadcast(&bitmap->bitmap_cond);
+    MYSQL_COND_BROADCAST(&bitmap->bitmap_cond);
   }
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -1703,7 +1703,7 @@ my_bool _ma_bitmap_find_place(MARIA_HA *
   info->bitmap_blocks.elements= ELEMENTS_RESERVED_FOR_MAIN_PART;
   max_page_size= (share->block_size - PAGE_OVERHEAD_SIZE);
 
-  pthread_mutex_lock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
 
   if (row->total_length <= max_page_size)
   {
@@ -1765,7 +1765,7 @@ end:
   res= 0;
 
 abort:
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -1809,7 +1809,7 @@ my_bool _ma_bitmap_find_new_place(MARIA_
   row->extents_count= 0;
   info->bitmap_blocks.elements= ELEMENTS_RESERVED_FOR_MAIN_PART;
 
-  pthread_mutex_lock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
 
   /*
     First allocate all blobs (so that we can find out the needed size for
@@ -1861,7 +1861,7 @@ end:
   res= 0;
 
 abort:
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -2001,7 +2001,7 @@ my_bool _ma_bitmap_reset_full_page_bits(
   uchar *data;
   DBUG_ENTER("_ma_bitmap_reset_full_page_bits");
   DBUG_PRINT("enter", ("page: %lu  page_count: %u", (ulong) page, page_count));
-  safe_mutex_assert_owner(&info->s->bitmap.bitmap_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&info->s->bitmap.bitmap_lock);
 
   bitmap_page= page - page % bitmap->pages_covered;
   DBUG_ASSERT(page != bitmap_page);
@@ -2079,7 +2079,7 @@ my_bool _ma_bitmap_set_full_page_bits(MA
   uchar *data;
   DBUG_ENTER("_ma_bitmap_set_full_page_bits");
   DBUG_PRINT("enter", ("page: %lu  page_count: %u", (ulong) page, page_count));
-  safe_mutex_assert_owner(&info->s->bitmap.bitmap_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&info->s->bitmap.bitmap_lock);
 
   bitmap_page= page - page % bitmap->pages_covered;
   if (bitmap_page != bitmap->page &&
@@ -2162,7 +2162,7 @@ void _ma_bitmap_flushable(MARIA_HA *info
   bitmap= &share->bitmap;
   if (non_flushable_inc == -1)
   {
-    pthread_mutex_lock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
     DBUG_ASSERT((int) bitmap->non_flushable > 0 &&
                 info->non_flushable_state == 1);
     info->non_flushable_state= 0;
@@ -2177,11 +2177,11 @@ void _ma_bitmap_flushable(MARIA_HA *info
       if (unlikely(bitmap->flush_all_requested))
       {
         DBUG_PRINT("info", ("bitmap flushable waking up flusher"));
-        pthread_cond_broadcast(&bitmap->bitmap_cond);
+        MYSQL_COND_BROADCAST(&bitmap->bitmap_cond);
       }
     }
     DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
-    pthread_mutex_unlock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
     return;
   }
   DBUG_ASSERT(non_flushable_inc == 1 && info->non_flushable_state == 0);
@@ -2199,13 +2199,13 @@ void _ma_bitmap_flushable(MARIA_HA *info
       our thread), it is not going to increase it more so is not going to come
       here.
     */
-    pthread_mutex_lock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
     while (bitmap->flush_all_requested)
     {
       DBUG_PRINT("info", ("waiting for bitmap flusher"));
-      pthread_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
+      MYSQL_COND_WAIT(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
     }
-    pthread_mutex_unlock(&bitmap->bitmap_lock);
+    MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   }
   /*
     Ok to set without mutex: we didn't touch the bitmap's content yet; when we
@@ -2259,7 +2259,7 @@ my_bool _ma_bitmap_release_unused(MARIA_
   */
   current_bitmap_value= FULL_HEAD_PAGE;
 
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
 
   /* First handle head block */
   if (block->used & BLOCKUSED_USED)
@@ -2332,17 +2332,17 @@ my_bool _ma_bitmap_release_unused(MARIA_
       if (unlikely(bitmap->flush_all_requested))
       {
         DBUG_PRINT("info", ("bitmap flushable waking up flusher"));
-        pthread_cond_broadcast(&bitmap->bitmap_cond);
+        MYSQL_COND_BROADCAST(&bitmap->bitmap_cond);
       }
     }
   }
   DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
 
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   DBUG_RETURN(0);
 
 err:
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   DBUG_RETURN(1);
 }
 
@@ -2371,7 +2371,7 @@ my_bool _ma_bitmap_free_full_pages(MARIA
   MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
   DBUG_ENTER("_ma_bitmap_free_full_pages");
 
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_LOCK(&bitmap->bitmap_lock);
   for (; count--; extents+= ROW_EXTENT_SIZE)
   {
     pgcache_page_no_t page=  uint5korr(extents);
@@ -2385,12 +2385,12 @@ my_bool _ma_bitmap_free_full_pages(MARIA
                                  page_count, PAGECACHE_LOCK_WRITE, 1) ||
           _ma_bitmap_reset_full_page_bits(info, bitmap, page, page_count))
       {
-        pthread_mutex_unlock(&bitmap->bitmap_lock);
+        MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
         DBUG_RETURN(1);
       }
     }
   }
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&bitmap->bitmap_lock);
   DBUG_RETURN(0);
 }
 
@@ -2418,12 +2418,12 @@ my_bool _ma_bitmap_set(MARIA_HA *info, p
   my_bool res;
   DBUG_ENTER("_ma_bitmap_set");
 
-  pthread_mutex_lock(&info->s->bitmap.bitmap_lock);
+  MYSQL_MUTEX_LOCK(&info->s->bitmap.bitmap_lock);
   bits= (head ?
          _ma_free_size_to_head_pattern(bitmap, empty_space) :
          free_size_to_tail_pattern(bitmap, empty_space));
   res= set_page_bits(info, bitmap, page, bits);
-  pthread_mutex_unlock(&info->s->bitmap.bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&info->s->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 

=== modified file 'storage/maria/ma_blockrec.c'
--- a/storage/maria/ma_blockrec.c	2008-08-11 14:40:32 +0000
+++ b/storage/maria/ma_blockrec.c	2008-10-10 20:34:55 +0000
@@ -2285,10 +2285,10 @@ static my_bool extent_to_bitmap_blocks(M
     else
     {
       my_bool res;
-      pthread_mutex_lock(&share->bitmap.bitmap_lock);
+      MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
       res= _ma_bitmap_set_full_page_bits(info, &share->bitmap,
                                          block->page, block->page_count);
-      pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+      MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
       if (res)
         DBUG_RETURN(1);
       block->used= BLOCKUSED_USED;
@@ -2438,10 +2438,10 @@ static my_bool free_full_page_range(MARI
                               log_data, NULL))
       res= 1;
   }
-  pthread_mutex_lock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
   if (_ma_bitmap_reset_full_page_bits(info, &share->bitmap, page, count))
     res= 1;
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -6274,10 +6274,10 @@ uint _ma_apply_redo_free_blocks(MARIA_HA
     DBUG_PRINT("info", ("page: %lu  pages: %u", (long) page, page_range));
 
     /** @todo leave bitmap lock to the bitmap code... */
-    pthread_mutex_lock(&share->bitmap.bitmap_lock);
+    MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
     res= _ma_bitmap_reset_full_page_bits(info, &share->bitmap, start_page,
                                          page_range);
-    pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+    MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
     if (res)
     {
       _ma_mark_file_crashed(share);
@@ -6355,9 +6355,9 @@ uint _ma_apply_redo_free_head_or_tail(MA
     push_dynamic(&info->pinned_pages, (void*) &page_link);
   }
   /** @todo leave bitmap lock to the bitmap code... */
-  pthread_mutex_lock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
   res= _ma_bitmap_reset_full_page_bits(info, &share->bitmap, page, 1);
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
   if (res)
     goto err;
   DBUG_RETURN(0);
@@ -6531,10 +6531,10 @@ uint _ma_apply_redo_insert_row_blobs(MAR
           goto err;
       }
       /** @todo leave bitmap lock to the bitmap code... */
-      pthread_mutex_lock(&share->bitmap.bitmap_lock);
+      MYSQL_MUTEX_LOCK(&share->bitmap.bitmap_lock);
       res= _ma_bitmap_set_full_page_bits(info, &share->bitmap, start_page,
                                          page_range);
-      pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+      MYSQL_MUTEX_UNLOCK(&share->bitmap.bitmap_lock);
       if (res)
         goto err;
     }

=== modified file 'storage/maria/ma_check.c'
--- a/storage/maria/ma_check.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_check.c	2008-10-10 20:34:55 +0000
@@ -2988,10 +2988,10 @@ int maria_sort_index(HA_CHECK *param, re
 	/* Put same locks as old file */
   share->r_locks= share->w_locks= share->tot_locks= 0;
   (void) _ma_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   (void)(my_close(share->kfile.file, MYF(MY_WME)));
   share->kfile.file = -1;
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   (void) my_close(new_file,MYF(MY_WME));
   if (maria_change_to_newfile(share->index_file_name.str, MARIA_NAME_IEXT,
                               INDEX_TMP_EXT, sync_dir) ||
@@ -4210,7 +4210,7 @@ int maria_repair_parallel(HA_CHECK *para
   sort_param[0].calc_checksum= test(param->testflag & T_CALC_CHECKSUM);
 
   sort_info.got_error=0;
-  pthread_mutex_lock(&sort_info.mutex);
+  MYSQL_MUTEX_LOCK(&sort_info.mutex);
 
   /*
     Initialize the I/O cache share for use with the read caches and, in
@@ -4276,8 +4276,8 @@ int maria_repair_parallel(HA_CHECK *para
 
   /* waiting for all threads to finish */
   while (sort_info.threads_running)
-    pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
-  pthread_mutex_unlock(&sort_info.mutex);
+    MYSQL_COND_WAIT(&sort_info.cond, &sort_info.mutex);
+  MYSQL_MUTEX_UNLOCK(&sort_info.mutex);
 
   if ((got_error= _ma_thr_write_keys(sort_param)))
   {
@@ -4427,8 +4427,8 @@ err:
     share->state.changed&= ~(STATE_NOT_OPTIMIZED_ROWS | STATE_NOT_ZEROFILLED |
                              STATE_NOT_MOVABLE);
 
-  pthread_cond_destroy (&sort_info.cond);
-  pthread_mutex_destroy(&sort_info.mutex);
+  MYSQL_COND_DESTROY (&sort_info.cond);
+  MYSQL_MUTEX_DESTROY(&sort_info.mutex);
 
   my_free((uchar*) sort_info.ft_buf, MYF(MY_ALLOW_ZERO_PTR));
   my_free((uchar*) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));

=== modified file 'storage/maria/ma_checkpoint.c'
--- a/storage/maria/ma_checkpoint.c	2008-08-25 11:49:47 +0000
+++ b/storage/maria/ma_checkpoint.c	2008-10-10 20:34:55 +0000
@@ -40,9 +40,9 @@
 /** @brief type of checkpoint currently running */
 static CHECKPOINT_LEVEL checkpoint_in_progress= CHECKPOINT_NONE;
 /** @brief protects checkpoint_in_progress */
-static pthread_mutex_t LOCK_checkpoint;
+static mysql_mutex_t LOCK_checkpoint;
 /** @brief for killing the background checkpoint thread */
-static pthread_cond_t  COND_checkpoint;
+static mysql_cond_t  COND_checkpoint;
 /** @brief if checkpoint module was inited or not */
 static my_bool checkpoint_inited= FALSE;
 /** @brief 'kill' flag for the background checkpoint thread */
@@ -109,7 +109,7 @@ int ma_checkpoint_execute(CHECKPOINT_LEV
   DBUG_ASSERT(level > CHECKPOINT_NONE);
 
   /* look for already running checkpoints */
-  pthread_mutex_lock(&LOCK_checkpoint);
+  MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
   while (checkpoint_in_progress != CHECKPOINT_NONE)
   {
     if (no_wait && (checkpoint_in_progress >= level))
@@ -119,18 +119,18 @@ int ma_checkpoint_execute(CHECKPOINT_LEV
         smarter to flush pages instead of waiting here while the other thread
         finishes its checkpoint).
       */
-      pthread_mutex_unlock(&LOCK_checkpoint);
+      MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
       goto end;
     }
-    pthread_cond_wait(&COND_checkpoint, &LOCK_checkpoint);
+    MYSQL_COND_WAIT(&COND_checkpoint, &LOCK_checkpoint);
   }
 
   checkpoint_in_progress= level;
-  pthread_mutex_unlock(&LOCK_checkpoint);
+  MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
   /* from then on, we are sure to be and stay the only checkpointer */
 
   result= really_execute_checkpoint();
-  pthread_cond_broadcast(&COND_checkpoint);
+  MYSQL_COND_BROADCAST(&COND_checkpoint);
 end:
   DBUG_RETURN(result);
 }
@@ -291,11 +291,11 @@ err:
 end:
   for (i= 0; i < (sizeof(record_pieces)/sizeof(record_pieces[0])); i++)
     my_free(record_pieces[i].str, MYF(MY_ALLOW_ZERO_PTR));
-  pthread_mutex_lock(&LOCK_checkpoint);
+  MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
   checkpoint_in_progress= CHECKPOINT_NONE;
   checkpoints_total++;
   checkpoints_ok_total+= !error;
-  pthread_mutex_unlock(&LOCK_checkpoint);
+  MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
   DBUG_RETURN(error);
 }
 
@@ -355,7 +355,7 @@ static void flush_all_tables(int what_to
 {
   int res= 0;
   LIST *pos; /**< to iterate over open tables */
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   for (pos= maria_open_list; pos; pos= pos->next)
   {
     MARIA_HA *info= (MARIA_HA*)pos->data;
@@ -380,7 +380,7 @@ static void flush_all_tables(int what_to
     }
     DBUG_ASSERT(res == 0);
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
 }
 #endif
 
@@ -425,7 +425,7 @@ void ma_checkpoint_end(void)
 
   if (checkpoint_inited)
   {
-    pthread_mutex_lock(&LOCK_checkpoint);
+    MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
     if (checkpoint_thread_die != 2) /* thread was started ok */
     {
       DBUG_PRINT("info",("killing Maria background checkpoint thread"));
@@ -433,19 +433,19 @@ void ma_checkpoint_end(void)
       do /* and wait for it to be dead */
       {
         /* wake it up if it was in a sleep */
-        pthread_cond_broadcast(&COND_checkpoint);
+        MYSQL_COND_BROADCAST(&COND_checkpoint);
         DBUG_PRINT("info",("waiting for Maria background checkpoint thread"
                            " to die"));
-        pthread_cond_wait(&COND_checkpoint, &LOCK_checkpoint);
+        MYSQL_COND_WAIT(&COND_checkpoint, &LOCK_checkpoint);
       }
       while (checkpoint_thread_die != 2);
     }
-    pthread_mutex_unlock(&LOCK_checkpoint);
+    MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
     my_free((uchar *)dfiles, MYF(MY_ALLOW_ZERO_PTR));
     my_free((uchar *)kfiles, MYF(MY_ALLOW_ZERO_PTR));
     dfiles= kfiles= NULL;
-    pthread_mutex_destroy(&LOCK_checkpoint);
-    pthread_cond_destroy(&COND_checkpoint);
+    MYSQL_MUTEX_DESTROY(&LOCK_checkpoint);
+    MYSQL_COND_DESTROY(&COND_checkpoint);
     checkpoint_inited= FALSE;
   }
   DBUG_VOID_RETURN;
@@ -691,25 +691,25 @@ pthread_handler_t ma_checkpoint_backgrou
         sleep_time= interval - (sleeps % interval);
       }
     }
-    pthread_mutex_lock(&LOCK_checkpoint);
+    MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
     if (checkpoint_thread_die == 1)
       break;
 #if 0 /* good for testing, to do a lot of checkpoints, finds a lot of bugs */
-    pthread_mutex_unlock(&LOCK_checkpoint);
+    MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
     my_sleep(100000); /* a tenth of a second */
-    pthread_mutex_lock(&LOCK_checkpoint);
+    MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
 #else
     /* To have a killable sleep, we use timedwait like our SQL GET_LOCK() */
     DBUG_PRINT("info", ("sleeping %u seconds", sleep_time));
     set_timespec(abstime, sleep_time);
-    pthread_cond_timedwait(&COND_checkpoint, &LOCK_checkpoint, &abstime);
+    MYSQL_COND_TIMEDWAIT(&COND_checkpoint, &LOCK_checkpoint, &abstime);
 #endif
     if (checkpoint_thread_die == 1)
       break;
-    pthread_mutex_unlock(&LOCK_checkpoint);
+    MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
     sleeps+= sleep_time;
   }
-  pthread_mutex_unlock(&LOCK_checkpoint);
+  MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
   DBUG_PRINT("info",("Maria background checkpoint thread ends"));
   {
     CHECKPOINT_LEVEL level= CHECKPOINT_FULL;
@@ -720,12 +720,12 @@ pthread_handler_t ma_checkpoint_backgrou
     DBUG_EXECUTE_IF("maria_checkpoint_indirect", level= CHECKPOINT_INDIRECT;);
     ma_checkpoint_execute(level, FALSE);
   }
-  pthread_mutex_lock(&LOCK_checkpoint);
+  MYSQL_MUTEX_LOCK(&LOCK_checkpoint);
   checkpoint_thread_die= 2; /* indicate that we are dead */
   /* wake up ma_checkpoint_end() which may be waiting for our death */
-  pthread_cond_broadcast(&COND_checkpoint);
+  MYSQL_COND_BROADCAST(&COND_checkpoint);
   /* broadcast was inside unlock because ma_checkpoint_end() destroys mutex */
-  pthread_mutex_unlock(&LOCK_checkpoint);
+  MYSQL_MUTEX_UNLOCK(&LOCK_checkpoint);
   my_thread_end();
   return 0;
 }
@@ -773,7 +773,7 @@ static int collect_tables(LEX_STRING *st
 
   LINT_INIT(state_copies_horizon);
   /* let's make a list of distinct shares */
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   for (nb= 0, pos= maria_open_list; pos; pos= pos->next)
   {
     MARIA_HA *info= (MARIA_HA*)pos->data;
@@ -825,7 +825,7 @@ static int collect_tables(LEX_STRING *st
   }
 
   DBUG_ASSERT(i == nb);
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   DBUG_PRINT("info",("found %u table shares", nb));
 
   str->length=
@@ -956,7 +956,7 @@ static int collect_tables(LEX_STRING *st
 
     /* OS file descriptors are ints which we stored in 4 bytes */
     compile_time_assert(sizeof(int) <= 4);
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     /*
       Tables in a normal state have their two file descriptors open.
       In some rare cases like REPAIR, some descriptor may be closed or even
@@ -1058,22 +1058,22 @@ static int collect_tables(LEX_STRING *st
       TODO: Only do this call if there has been # (10?) ended transactions
       since last call.
     */
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     _ma_remove_not_visible_states_with_lock(share);
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
 
     if (share->in_checkpoint & MARIA_CHECKPOINT_SHOULD_FREE_ME)
     {
       /* maria_close() left us to free the share */
-      pthread_mutex_unlock(&share->intern_lock);
-      pthread_mutex_destroy(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
+      MYSQL_MUTEX_DESTROY(&share->intern_lock);
       my_free((uchar *)share, MYF(0));
     }
     else
     {
       /* share goes back to normal state */
       share->in_checkpoint= 0;
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     }
 
     /*
@@ -1172,14 +1172,14 @@ err:
   if (unlikely(unmark_tables))
   {
     /* maria_close() uses THR_LOCK_maria from start to end */
-    pthread_mutex_lock(&THR_LOCK_maria);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
     for (i= 0; i < nb; i++)
     {
       MARIA_SHARE *share= distinct_shares[i];
       if (share->in_checkpoint & MARIA_CHECKPOINT_SHOULD_FREE_ME)
       {
         /* maria_close() left us to free the share */
-        pthread_mutex_destroy(&share->intern_lock);
+        MYSQL_MUTEX_DESTROY(&share->intern_lock);
         my_free((uchar *)share, MYF(0));
       }
       else
@@ -1188,7 +1188,7 @@ err:
         share->in_checkpoint= 0;
       }
     }
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   }
   my_free((uchar *)distinct_shares, MYF(MY_ALLOW_ZERO_PTR));
   my_free((uchar *)state_copies, MYF(MY_ALLOW_ZERO_PTR));

=== modified file 'storage/maria/ma_close.c'
--- a/storage/maria/ma_close.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_close.c	2008-10-10 20:34:55 +0000
@@ -35,7 +35,7 @@ int maria_close(register MARIA_HA *info)
   /* Check that we have unlocked key delete-links properly */
   DBUG_ASSERT(info->used_key_del == 0);
 
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   if (info->lock_type == F_EXTRA_LCK)
     info->lock_type=F_UNLCK;			/* HA_EXTRA_NO_USER_CHANGE */
 
@@ -47,7 +47,7 @@ int maria_close(register MARIA_HA *info)
     if (maria_lock_database(info,F_UNLCK))
       error=my_errno;
   }
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
 
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
@@ -117,9 +117,9 @@ int maria_close(register MARIA_HA *info)
     {
       int i,keys;
       keys = share->state.header.keys;
-      (void)(rwlock_destroy(&share->mmap_lock));
+      (void)(MYSQL_RWLOCK_DESTROY(&share->mmap_lock));
       for(i=0; i<keys; i++) {
-        (void)(rwlock_destroy(&share->keyinfo[i].root_lock));
+        (void)(MYSQL_RWLOCK_DESTROY(&share->keyinfo[i].root_lock));
       }
     }
 #endif
@@ -158,11 +158,11 @@ int maria_close(register MARIA_HA *info)
       }
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   if (share_can_be_freed)
   {
-    (void)(pthread_mutex_destroy(&share->intern_lock));
+    (void)(MYSQL_MUTEX_DESTROY(&share->intern_lock));
     my_free((uchar *)share, MYF(0));
   }
   if (info->ftparser_param)

=== modified file 'storage/maria/ma_create.c'
--- a/storage/maria/ma_create.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_create.c	2008-10-10 20:34:55 +0000
@@ -766,7 +766,7 @@ int maria_create(const char *name, enum 
   if (! (flags & HA_DONT_TOUCH_DATA))
     share.state.create_time= (long) time((time_t*) 0);
 
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
 
   /*
     NOTE: For test_if_reopen() we need a real path name. Hence we need
@@ -1134,7 +1134,7 @@ int maria_create(const char *name, enum 
     if (my_close(dfile,MYF(0)))
       goto err;
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   res= 0;
   my_free((char*) rec_per_key_part,MYF(0));
   errpos=0;
@@ -1143,7 +1143,7 @@ int maria_create(const char *name, enum 
   DBUG_RETURN(res);
 
 err:
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
 
 err_no_lock:
   save_errno=my_errno;
@@ -1301,10 +1301,10 @@ int _ma_update_state_lsns(MARIA_SHARE *s
                           my_bool do_sync, my_bool update_create_rename_lsn)
 {
   int res;
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   res= _ma_update_state_lsns_sub(share, lsn, create_trid, do_sync,
                                  update_create_rename_lsn);
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   return res;
 }
 

=== modified file 'storage/maria/ma_dynrec.c'
--- a/storage/maria/ma_dynrec.c	2008-06-05 16:11:22 +0000
+++ b/storage/maria/ma_dynrec.c	2008-10-10 20:34:55 +0000
@@ -137,7 +137,7 @@ size_t _ma_mmap_pread(MARIA_HA *info, uc
 {
   DBUG_PRINT("info", ("maria_read with mmap %d\n", info->dfile.file));
   if (info->s->lock_key_trees)
-    rw_rdlock(&info->s->mmap_lock);
+    MYSQL_RWLOCK_RDLOCK(&info->s->mmap_lock);
 
   /*
     The following test may fail in the following cases:
@@ -150,13 +150,13 @@ size_t _ma_mmap_pread(MARIA_HA *info, uc
   {
     memcpy(Buffer, info->s->file_map + offset, Count);
     if (info->s->lock_key_trees)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return 0;
   }
   else
   {
     if (info->s->lock_key_trees)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return my_pread(info->dfile.file, Buffer, Count, offset, MyFlags);
   }
 }
@@ -192,7 +192,7 @@ size_t _ma_mmap_pwrite(MARIA_HA *info, c
 {
   DBUG_PRINT("info", ("maria_write with mmap %d\n", info->dfile.file));
   if (info->s->lock_key_trees)
-    rw_rdlock(&info->s->mmap_lock);
+    MYSQL_RWLOCK_RDLOCK(&info->s->mmap_lock);
 
   /*
     The following test may fail in the following cases:
@@ -205,14 +205,14 @@ size_t _ma_mmap_pwrite(MARIA_HA *info, c
   {
     memcpy(info->s->file_map + offset, Buffer, Count);
     if (info->s->lock_key_trees)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return 0;
   }
   else
   {
     info->s->nonmmaped_inserts++;
     if (info->s->lock_key_trees)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return my_pwrite(info->dfile.file, Buffer, Count, offset, MyFlags);
   }
 

=== modified file 'storage/maria/ma_extra.c'
--- a/storage/maria/ma_extra.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_extra.c	2008-10-10 20:34:55 +0000
@@ -80,17 +80,17 @@ int maria_extra(MARIA_HA *info, enum ha_
 #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
     if ((share->options & HA_OPTION_COMPRESS_RECORD))
     {
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       if (_ma_memmap_file(info))
       {
 	/* We don't nead MADV_SEQUENTIAL if small file */
 	madvise((char*) share->file_map, share->state.state.data_file_length,
 		share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
 		MADV_RANDOM : MADV_SEQUENTIAL);
-	pthread_mutex_unlock(&share->intern_lock);
+	MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 	break;
       }
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     }
 #endif
     if (info->opt_flag & WRITE_CACHE_USED)
@@ -232,10 +232,10 @@ int maria_extra(MARIA_HA *info, enum ha_
     break;
   case HA_EXTRA_NO_KEYS:
     /* we're going to modify pieces of the state, stall Checkpoint */
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     if (info->lock_type == F_UNLCK)
     {
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       error= 1;					/* Not possibly if not lock */
       break;
     }
@@ -274,7 +274,7 @@ int maria_extra(MARIA_HA *info, enum ha_
       DBUG_ASSERT(!maria_in_recovery);
       error= _ma_state_info_write(share, 1|2);
     }
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     break;
   case HA_EXTRA_FORCE_REOPEN:
     /*
@@ -288,24 +288,24 @@ int maria_extra(MARIA_HA *info, enum ha_
                                  FLUSH_FORCE_WRITE, FLUSH_FORCE_WRITE);
     if (!error && share->changed)
     {
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       if (!(error= _ma_state_info_write(share, 1|2)))
         share->changed= 0;
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     }
-    pthread_mutex_lock(&THR_LOCK_maria);
-    pthread_mutex_lock(&share->intern_lock); /* protect against Checkpoint */
+    MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
+    MYSQL_MUTEX_LOCK(&share->intern_lock); /* protect against Checkpoint */
     /* this makes the share not be re-used next time the table is opened */
     share->last_version= 0L;			/* Impossible version */
-    pthread_mutex_unlock(&share->intern_lock);
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
     break;
   case HA_EXTRA_PREPARE_FOR_DROP:
   case HA_EXTRA_PREPARE_FOR_RENAME:
   {
     my_bool do_flush= test(function != HA_EXTRA_PREPARE_FOR_DROP);
     enum flush_type type;
-    pthread_mutex_lock(&THR_LOCK_maria);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
     /*
       This share, to have last_version=0, needs to save all its data/index
       blocks to disk if this is not for a DROP TABLE. Otherwise they would be
@@ -321,7 +321,7 @@ int maria_extra(MARIA_HA *info, enum ha_
     }
     if (share->kfile.file >= 0)
       _ma_decrement_open_count(info);
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     if (info->trn)
     {
       _ma_remove_table_from_trnman(share, info->trn);
@@ -367,8 +367,8 @@ int maria_extra(MARIA_HA *info, enum ha_
     }
     /* For protection against Checkpoint, we set under intern_lock: */
     share->last_version= 0L;			/* Impossible version */
-    pthread_mutex_unlock(&share->intern_lock);
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
     break;
   }
   case HA_EXTRA_FLUSH:
@@ -412,7 +412,7 @@ int maria_extra(MARIA_HA *info, enum ha_
 #ifdef HAVE_MMAP
     if (block_records)
       break;                                    /* Not supported */
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     /*
       Memory map the data file if it is not already mapped. It is safe
       to memory map a file while other threads are using file I/O on it.
@@ -433,13 +433,13 @@ int maria_extra(MARIA_HA *info, enum ha_
         share->file_write= _ma_mmap_pwrite;
       }
     }
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 #endif
     break;
   case HA_EXTRA_MARK_AS_LOG_TABLE:
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     share->is_log_table= TRUE;
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     break;
   case HA_EXTRA_KEY_CACHE:
   case HA_EXTRA_NO_KEY_CACHE:

=== modified file 'storage/maria/ma_info.c'
--- a/storage/maria/ma_info.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_info.c	2008-10-10 20:34:55 +0000
@@ -42,10 +42,10 @@ int maria_status(MARIA_HA *info, registe
     DBUG_RETURN(0);				/* Compatible with ISAM */
   if (!(flag & HA_STATUS_NO_LOCK))
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     (void)(_ma_readinfo(info,F_RDLCK,0));
     fast_ma_writeinfo(info);
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   if (flag & HA_STATUS_VARIABLE)
   {

=== modified file 'storage/maria/ma_init.c'
--- a/storage/maria/ma_init.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_init.c	2008-10-10 20:34:55 +0000
@@ -96,7 +96,7 @@ void maria_end(void)
     end_pagecache(maria_log_pagecache, TRUE);
     end_pagecache(maria_pagecache, TRUE);
     ma_control_file_end();
-    pthread_mutex_destroy(&THR_LOCK_maria);
+    MYSQL_MUTEX_DESTROY(&THR_LOCK_maria);
     hash_free(&maria_stored_state);
   }
 }

=== modified file 'storage/maria/ma_key_recover.c'
--- a/storage/maria/ma_key_recover.c	2008-07-09 09:02:27 +0000
+++ b/storage/maria/ma_key_recover.c	2008-10-10 20:34:55 +0000
@@ -1251,21 +1251,21 @@ my_bool _ma_lock_key_del(MARIA_HA *info,
   */
   if (info->used_key_del != 1)
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     if (share->state.key_del == HA_OFFSET_ERROR && insert_at_end)
     {
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       info->used_key_del= 2;                  /* insert-with-append */
       return 1;
     }
 #ifdef THREAD
     while (share->used_key_del)
-      pthread_cond_wait(&share->intern_cond, &share->intern_lock);
+      MYSQL_COND_WAIT(&share->intern_cond, &share->intern_lock);
 #endif
     info->used_key_del= 1;
     share->used_key_del= 1;
     share->current_key_del= share->state.key_del;
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   return share->current_key_del == HA_OFFSET_ERROR;
 }
@@ -1281,11 +1281,11 @@ void _ma_unlock_key_del(MARIA_HA *info)
   if (info->used_key_del == 1)                  /* Ignore insert-with-append */
   {
     MARIA_SHARE *share= info->s;
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     share->used_key_del= 0;
     share->state.key_del= share->current_key_del;
-    pthread_mutex_unlock(&share->intern_lock);
-    pthread_cond_signal(&share->intern_cond);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
+    MYSQL_COND_SIGNAL(&share->intern_cond);
   }
   info->used_key_del= 0;
 }

=== modified file 'storage/maria/ma_keycache.c'
--- a/storage/maria/ma_keycache.c	2008-08-25 11:49:47 +0000
+++ b/storage/maria/ma_keycache.c	2008-10-10 20:34:55 +0000
@@ -97,7 +97,7 @@ int maria_assign_to_pagecache(MARIA_HA *
     ensure that setting the key cache and changing the multi_pagecache
     is done atomicly
   */
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   /*
     Tell all threads to use the new key cache
     This should be seen at the lastes for the next call to an maria function.
@@ -109,7 +109,7 @@ int maria_assign_to_pagecache(MARIA_HA *
                           share->unique_file_name.length,
 			  share->pagecache))
     error= my_errno;
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   DBUG_RETURN(error);
 }
 
@@ -144,7 +144,7 @@ void maria_change_pagecache(PAGECACHE *o
   /*
     Lock list to ensure that no one can close the table while we manipulate it
   */
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   for (pos=maria_open_list ; pos ; pos=pos->next)
   {
     MARIA_HA *info= (MARIA_HA*) pos->data;
@@ -159,6 +159,6 @@ void maria_change_pagecache(PAGECACHE *o
     open a new table that will be associted with the old key cache
   */
   multi_pagecache_change(old_pagecache, new_pagecache);
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   DBUG_VOID_RETURN;
 }

=== modified file 'storage/maria/ma_locking.c'
--- a/storage/maria/ma_locking.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_locking.c	2008-10-10 20:34:55 +0000
@@ -47,7 +47,7 @@ int maria_lock_database(MARIA_HA *info, 
   }
 
   error=0;
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   if (share->kfile.file >= 0)		/* May only be false on windows */
   {
     switch (lock_type) {
@@ -97,11 +97,11 @@ int maria_lock_database(MARIA_HA *info, 
               (share->nonmmaped_inserts > MAX_NONMAPPED_INSERTS))
           {
             if (share->lock_key_trees)
-              rw_wrlock(&share->mmap_lock);
+              MYSQL_RWLOCK_WRLOCK(&share->mmap_lock);
             _ma_remap_file(info, share->state.state.data_file_length);
             share->nonmmaped_inserts= 0;
             if (share->lock_key_trees)
-              rw_unlock(&share->mmap_lock);
+              MYSQL_RWLOCK_UNLOCK(&share->mmap_lock);
           }
 #endif
 #ifdef EXTERNAL_LOCKING
@@ -237,7 +237,7 @@ int maria_lock_database(MARIA_HA *info, 
     }
   }
 #endif
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   DBUG_RETURN(error);
 } /* maria_lock_database */
 

=== modified file 'storage/maria/ma_loghandler.c'
--- a/storage/maria/ma_loghandler.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_loghandler.c	2008-10-10 20:34:55 +0000
@@ -129,7 +129,7 @@ struct st_translog_buffer
   /* File handler for this buffer */
   TRANSLOG_FILE *file;
   /* Threads which are waiting for buffer filling/freeing */
-  pthread_cond_t waiting_filling_buffer;
+  mysql_cond_t waiting_filling_buffer;
   /* Number of records which are in copy progress */
   uint copy_to_buffer_in_progress;
   /* list of waiting buffer ready threads */
@@ -164,7 +164,7 @@ struct st_translog_buffer
    Because of above and number of buffers equal 5 we can't get dead lock (it is
    impossible to get all 5 buffers locked simultaneously).
   */
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   /*
     Some thread is going to close the buffer and it should be
     done only by that thread
@@ -249,7 +249,7 @@ struct st_translog_descriptor
   /* min/max number of file in the array */
   uint32 max_file, min_file;
   /* the opened files list guard */
-  rw_lock_t open_files_lock;
+  mysql_rwlock_t open_files_lock;
 
   /*
     File descriptor of the directory where we store log files for syncing
@@ -261,7 +261,7 @@ struct st_translog_descriptor
   /* Mask where 1 in position N mean that buffer N is not flushed */
   dirty_buffer_mask_t dirty_buffer_mask;
   /* The above variable protection */
-  pthread_mutex_t dirty_buffer_mask_lock;
+  mysql_mutex_t dirty_buffer_mask_lock;
   /*
      horizon - visible end of the log (here is absolute end of the log:
      position where next chunk can start
@@ -287,22 +287,22 @@ struct st_translog_descriptor
   /* All what is after this address is not sent to disk yet */
   TRANSLOG_ADDRESS in_buffers_only;
   /* protection of sent_to_disk and in_buffers_only */
-  pthread_mutex_t sent_to_disk_lock;
+  mysql_mutex_t sent_to_disk_lock;
   /*
     Protect flushed (see above) and for flush serialization (will
     be removed in v1.5
   */
-  pthread_mutex_t log_flush_lock;
-  pthread_cond_t log_flush_cond;
+  mysql_mutex_t log_flush_lock;
+  mysql_cond_t log_flush_cond;
 
   /* Protects changing of headers of finished files (max_lsn) */
-  pthread_mutex_t file_header_lock;
+  mysql_mutex_t file_header_lock;
 
   /*
     Sorted array (with protection) of files where we started writing process
     and so we can't give last LSN yet
   */
-  pthread_mutex_t unfinished_files_lock;
+  mysql_mutex_t unfinished_files_lock;
   DYNAMIC_ARRAY unfinished_files;
 
   /*
@@ -313,7 +313,7 @@ struct st_translog_descriptor
   /* Purger data: minimum file in the log (or 0 if unknown) */
   uint32 min_file_number;
   /* Protect purger from many calls and it's data */
-  pthread_mutex_t purger_lock;
+  mysql_mutex_t purger_lock;
   /* last low water mark checked */
   LSN last_lsn_checked;
   /**
@@ -381,9 +381,9 @@ LOG_DESC log_record_type_descriptor[LOGR
 #ifndef DBUG_OFF
 
 #define translog_buffer_lock_assert_owner(B) \
-  safe_mutex_assert_owner(&(B)->mutex)
+  MYSQL_MUTEX_ASSERT_OWNER(&(B)->mutex)
 #define translog_lock_assert_owner() \
-  safe_mutex_assert_owner(&log_descriptor.bc.buffer->mutex)
+  MYSQL_MUTEX_ASSERT_OWNER(&log_descriptor.bc.buffer->mutex)
 void translog_lock_handler_assert_owner()
 {
   translog_lock_assert_owner();
@@ -928,12 +928,12 @@ static TRANSLOG_FILE *get_logfile_by_num
 {
   TRANSLOG_FILE *file;
   DBUG_ENTER("get_logfile_by_number");
-  rw_rdlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_RDLOCK(&log_descriptor.open_files_lock);
   if (log_descriptor.max_file - file_no >=
       log_descriptor.open_files.elements)
   {
     DBUG_PRINT("info", ("File #%u is not opened", file_no));
-    rw_unlock(&log_descriptor.open_files_lock);
+    MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
     DBUG_RETURN(NULL);
   }
   DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
@@ -943,7 +943,7 @@ static TRANSLOG_FILE *get_logfile_by_num
 
   file= *dynamic_element(&log_descriptor.open_files,
                          log_descriptor.max_file - file_no, TRANSLOG_FILE **);
-  rw_unlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
   DBUG_PRINT("info", ("File 0x%lx File no: %lu, File handler: %d",
                       (ulong)file, (ulong)file_no,
                       (file ? file->handler.file : -1)));
@@ -961,11 +961,11 @@ static TRANSLOG_FILE *get_logfile_by_num
 static TRANSLOG_FILE *get_current_logfile()
 {
   TRANSLOG_FILE *file;
-  rw_rdlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_RDLOCK(&log_descriptor.open_files_lock);
   DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
               log_descriptor.open_files.elements);
   file= *dynamic_element(&log_descriptor.open_files, 0, TRANSLOG_FILE **);
-  rw_unlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
   return (file);
 }
 
@@ -1188,7 +1188,7 @@ static my_bool translog_set_lsn_for_file
     translog_unlock();
 
   /* Checks finished files if they are */
-  pthread_mutex_lock(&log_descriptor.file_header_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.file_header_lock);
   for (file= from_file; file <= to_file; file++)
   {
     LOGHANDLER_FILE_INFO info;
@@ -1203,7 +1203,7 @@ static my_bool translog_set_lsn_for_file
       DBUG_RETURN(1);
     }
   }
-  pthread_mutex_unlock(&log_descriptor.file_header_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.file_header_lock);
 
   DBUG_RETURN(0);
 }
@@ -1232,7 +1232,7 @@ static void translog_mark_file_unfinishe
   DBUG_PRINT("enter", ("file: %lu", (ulong) file));
 
   fc.file= file; fc.counter= 1;
-  pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.unfinished_files_lock);
 
   if (log_descriptor.unfinished_files.elements == 0)
   {
@@ -1283,7 +1283,7 @@ static void translog_mark_file_unfinishe
                          place + 1, struct st_file_counter *),
          &fc, sizeof(struct st_file_counter));
 end:
-  pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.unfinished_files_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -1303,7 +1303,7 @@ static void translog_mark_file_finished(
 
   LINT_INIT(fc_ptr);
 
-  pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.unfinished_files_lock);
 
   DBUG_ASSERT(log_descriptor.unfinished_files.elements > 0);
   for (i= 0;
@@ -1321,7 +1321,7 @@ static void translog_mark_file_finished(
 
   if (! --fc_ptr->counter)
     delete_dynamic_element(&log_descriptor.unfinished_files, i);
-  pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.unfinished_files_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -1345,7 +1345,7 @@ LSN translog_get_file_max_lsn_stored(uin
   DBUG_ASSERT(translog_status == TRANSLOG_OK ||
               translog_status == TRANSLOG_READONLY);
 
-  pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.unfinished_files_lock);
 
   /* find file with minimum file number "in progress" */
   if (log_descriptor.unfinished_files.elements > 0)
@@ -1355,7 +1355,7 @@ LSN translog_get_file_max_lsn_stored(uin
                             0, struct st_file_counter *);
     limit= fc_ptr->file; /* minimal file number "in progress" */
   }
-  pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.unfinished_files_lock);
 
   /*
     if there is no "in progress file" then unfinished file is in progress
@@ -1521,7 +1521,7 @@ static my_bool translog_create_new_file(
   if (translog_max_lsn_to_header(old->handler.file, log_descriptor.max_lsn))
     goto error;
 
-  rw_wrlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_WRLOCK(&log_descriptor.open_files_lock);
   DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
               log_descriptor.open_files.elements);
   DBUG_ASSERT(file_no == log_descriptor.max_file + 1);
@@ -1547,7 +1547,7 @@ static my_bool translog_create_new_file(
   set_dynamic(&log_descriptor.open_files, (uchar*)&file, 0);
   DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
               log_descriptor.open_files.elements);
-  rw_unlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
 
   DBUG_PRINT("info", ("file_no: %lu", (ulong)file_no));
 
@@ -1565,7 +1565,7 @@ static my_bool translog_create_new_file(
   DBUG_RETURN(0);
 
 error_lock:
-  rw_unlock(&log_descriptor.open_files_lock);
+  MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
 error:
   translog_stop_writing();
   DBUG_RETURN(1);
@@ -1589,7 +1589,7 @@ static void translog_buffer_lock(struct 
   DBUG_PRINT("enter",
              ("Lock buffer #%u: (0x%lx)", (uint) buffer->buffer_no,
               (ulong) buffer));
-  pthread_mutex_lock(&buffer->mutex);
+  MYSQL_MUTEX_LOCK(&buffer->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -1612,7 +1612,7 @@ static void translog_buffer_unlock(struc
   DBUG_PRINT("enter", ("Unlock buffer... #%u (0x%lx)",
                        (uint) buffer->buffer_no, (ulong) buffer));
 
-  pthread_mutex_unlock(&buffer->mutex);
+  MYSQL_MUTEX_UNLOCK(&buffer->mutex);
   DBUG_VOID_RETURN;
 }
 
@@ -1873,7 +1873,7 @@ static void translog_wait_for_closing(st
     DBUG_PRINT("info", ("wait for writers... buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
     DBUG_ASSERT(buffer->file != NULL);
-    pthread_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
+    MYSQL_COND_WAIT(&buffer->waiting_filling_buffer, &buffer->mutex);
     DBUG_PRINT("info", ("wait for writers done buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
   }
@@ -1905,7 +1905,7 @@ static void translog_wait_for_writers(st
     DBUG_PRINT("info", ("wait for writers... buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
     DBUG_ASSERT(buffer->file != NULL);
-    pthread_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
+    MYSQL_COND_WAIT(&buffer->waiting_filling_buffer, &buffer->mutex);
     DBUG_PRINT("info", ("wait for writers done buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
   }
@@ -1949,7 +1949,7 @@ static void translog_wait_for_buffer_fre
   {
     DBUG_PRINT("info", ("wait for writers... buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
-    pthread_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
+    MYSQL_COND_WAIT(&buffer->waiting_filling_buffer, &buffer->mutex);
     DBUG_PRINT("info", ("wait for writers done. buffer: #%u  0x%lx",
                         (uint) buffer->buffer_no, (ulong) buffer));
   }
@@ -2021,9 +2021,9 @@ static void translog_start_buffer(struct
                       cursor->chaser, (ulong) cursor->buffer->size,
                       (ulong) (cursor->ptr - cursor->buffer->buffer)));
   translog_check_cursor(cursor);
-  pthread_mutex_lock(&log_descriptor.dirty_buffer_mask_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.dirty_buffer_mask_lock);
   log_descriptor.dirty_buffer_mask|= (1 << buffer->buffer_no);
-  pthread_mutex_unlock(&log_descriptor.dirty_buffer_mask_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.dirty_buffer_mask_lock);
 
   DBUG_VOID_RETURN;
 }
@@ -2126,7 +2126,7 @@ static my_bool translog_buffer_next(TRAN
 static void translog_set_sent_to_disk(LSN lsn, TRANSLOG_ADDRESS in_buffers)
 {
   DBUG_ENTER("translog_set_sent_to_disk");
-  pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_PRINT("enter", ("lsn: (%lu,0x%lx) in_buffers: (%lu,0x%lx)  "
                        "in_buffers_only: (%lu,0x%lx)  start: (%lu,0x%lx)  "
                        "sent_to_disk: (%lu,0x%lx)",
@@ -2149,7 +2149,7 @@ static void translog_set_sent_to_disk(LS
     log_descriptor.in_buffers_only= in_buffers;
     DBUG_PRINT("info", ("set new in_buffers_only"));
   }
-  pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -2166,7 +2166,7 @@ static void translog_set_sent_to_disk(LS
 static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
 {
   DBUG_ENTER("translog_set_only_in_buffers");
-  pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_PRINT("enter", ("in_buffers: (%lu,0x%lx)  "
                        "in_buffers_only: (%lu,0x%lx)",
                        LSN_IN_PARTS(in_buffers),
@@ -2179,7 +2179,7 @@ static void translog_set_only_in_buffers
     log_descriptor.in_buffers_only= in_buffers;
     DBUG_PRINT("info", ("set new in_buffers_only"));
   }
-  pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_VOID_RETURN;
 }
 
@@ -2198,9 +2198,9 @@ static TRANSLOG_ADDRESS translog_only_in
 {
   register TRANSLOG_ADDRESS addr;
   DBUG_ENTER("translog_only_in_buffers");
-  pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.sent_to_disk_lock);
   addr= log_descriptor.in_buffers_only;
-  pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_RETURN(addr);
 }
 
@@ -2219,10 +2219,10 @@ static LSN translog_get_sent_to_disk()
 {
   register LSN lsn;
   DBUG_ENTER("translog_get_sent_to_disk");
-  pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.sent_to_disk_lock);
   lsn= log_descriptor.sent_to_disk;
   DBUG_PRINT("info", ("sent to disk up to (%lu,0x%lx)", LSN_IN_PARTS(lsn)));
-  pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.sent_to_disk_lock);
   DBUG_RETURN(lsn);
 }
 
@@ -2561,10 +2561,10 @@ static my_bool translog_buffer_flush(str
   buffer->file= NULL;
   buffer->overlay= 0;
   buffer->ver++;
-  pthread_mutex_lock(&log_descriptor.dirty_buffer_mask_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.dirty_buffer_mask_lock);
   log_descriptor.dirty_buffer_mask&= ~(1 << buffer->buffer_no);
-  pthread_mutex_unlock(&log_descriptor.dirty_buffer_mask_lock);
-  pthread_cond_broadcast(&buffer->waiting_filling_buffer);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.dirty_buffer_mask_lock);
+  MYSQL_COND_BROADCAST(&buffer->waiting_filling_buffer);
   DBUG_RETURN(0);
 }
 
@@ -4025,8 +4025,8 @@ static void translog_buffer_destroy(stru
     translog_buffer_unlock(buffer);
   }
   DBUG_PRINT("info", ("Destroy mutex: 0x%lx", (ulong) &buffer->mutex));
-  pthread_mutex_destroy(&buffer->mutex);
-  pthread_cond_destroy(&buffer->waiting_filling_buffer);
+  MYSQL_MUTEX_DESTROY(&buffer->mutex);
+  MYSQL_COND_DESTROY(&buffer->waiting_filling_buffer);
   DBUG_VOID_RETURN;
 }
 
@@ -4068,14 +4068,14 @@ void translog_destroy()
   /* close files */
   while ((file= (TRANSLOG_FILE **)pop_dynamic(&log_descriptor.open_files)))
     translog_close_log_file(*file);
-  pthread_mutex_destroy(&log_descriptor.sent_to_disk_lock);
-  pthread_mutex_destroy(&log_descriptor.file_header_lock);
-  pthread_mutex_destroy(&log_descriptor.unfinished_files_lock);
-  pthread_mutex_destroy(&log_descriptor.purger_lock);
-  pthread_mutex_destroy(&log_descriptor.log_flush_lock);
-  pthread_mutex_destroy(&log_descriptor.dirty_buffer_mask_lock);
-  pthread_cond_destroy(&log_descriptor.log_flush_cond);
-  rwlock_destroy(&log_descriptor.open_files_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.sent_to_disk_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.file_header_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.unfinished_files_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_DESTROY(&log_descriptor.dirty_buffer_mask_lock);
+  MYSQL_COND_DESTROY(&log_descriptor.log_flush_cond);
+  MYSQL_RWLOCK_DESTROY(&log_descriptor.open_files_lock);
   delete_dynamic(&log_descriptor.open_files);
   delete_dynamic(&log_descriptor.unfinished_files);
 
@@ -4372,7 +4372,7 @@ static void translog_buffer_decrease_wri
               (uint) buffer->buffer_no, (ulong) buffer,
               buffer->copy_to_buffer_in_progress));
   if (buffer->copy_to_buffer_in_progress == 0)
-    pthread_cond_broadcast(&buffer->waiting_filling_buffer);
+    MYSQL_COND_BROADCAST(&buffer->waiting_filling_buffer);
   DBUG_VOID_RETURN;
 }
 
@@ -7417,7 +7417,7 @@ static void translog_force_current_buffe
   old_buffer->is_closing_buffer= 0;
   DBUG_PRINT("enter", ("Buffer #%u 0x%lx  is_closing_buffer cleared",
                        (uint) old_buffer->buffer_no, (ulong) old_buffer));
-  pthread_cond_broadcast(&old_buffer->waiting_filling_buffer);
+  MYSQL_COND_BROADCAST(&old_buffer->waiting_filling_buffer);
 
   if (left)
   {
@@ -7448,9 +7448,9 @@ void  translog_flush_wait_for_end(LSN ls
 {
   DBUG_ENTER("translog_flush_wait_for_end");
   DBUG_PRINT("enter", ("LSN: (%lu,0x%lx)", LSN_IN_PARTS(lsn)));
-  safe_mutex_assert_owner(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&log_descriptor.log_flush_lock);
   while (cmp_translog_addr(log_descriptor.flushed, lsn) < 0)
-    pthread_cond_wait(&log_descriptor.log_flush_cond,
+    MYSQL_COND_WAIT(&log_descriptor.log_flush_cond,
                       &log_descriptor.log_flush_lock);
   DBUG_VOID_RETURN;
 }
@@ -7467,7 +7467,7 @@ void translog_flush_set_new_goal_and_wai
 {
   DBUG_ENTER("translog_flush_set_new_goal_and_wait");
   DBUG_PRINT("enter", ("LSN: (%lu,0x%lx)", LSN_IN_PARTS(lsn)));
-  safe_mutex_assert_owner(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&log_descriptor.log_flush_lock);
   if (cmp_translog_addr(lsn, log_descriptor.next_pass_max_lsn) > 0)
   {
     log_descriptor.next_pass_max_lsn= lsn;
@@ -7475,7 +7475,7 @@ void translog_flush_set_new_goal_and_wai
   }
   while (log_descriptor.flush_in_progress)
   {
-    pthread_cond_wait(&log_descriptor.log_flush_cond,
+    MYSQL_COND_WAIT(&log_descriptor.log_flush_cond,
                       &log_descriptor.log_flush_lock);
   }
   DBUG_VOID_RETURN;
@@ -7508,12 +7508,12 @@ my_bool translog_flush(TRANSLOG_ADDRESS 
               translog_status == TRANSLOG_READONLY);
   LINT_INIT(sent_to_disk);
 
-  pthread_mutex_lock(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.log_flush_lock);
   DBUG_PRINT("info", ("Everything is flushed up to (%lu,0x%lx)",
                       LSN_IN_PARTS(log_descriptor.flushed)));
   if (cmp_translog_addr(log_descriptor.flushed, lsn) >= 0)
   {
-    pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+    MYSQL_MUTEX_UNLOCK(&log_descriptor.log_flush_lock);
     DBUG_RETURN(0);
   }
   if (log_descriptor.flush_in_progress)
@@ -7525,7 +7525,7 @@ my_bool translog_flush(TRANSLOG_ADDRESS 
       if (cmp_translog_addr(lsn, log_descriptor.bc.buffer->last_lsn) > 0)
           lsn= BUFFER_MAX_LSN(log_descriptor.bc.buffer);
       translog_flush_wait_for_end(lsn);
-      pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+      MYSQL_MUTEX_UNLOCK(&log_descriptor.log_flush_lock);
       DBUG_RETURN(0);
     }
     log_descriptor.next_pass_max_lsn= LSN_IMPOSSIBLE;
@@ -7533,7 +7533,7 @@ my_bool translog_flush(TRANSLOG_ADDRESS 
   log_descriptor.flush_in_progress= 1;
   flush_horizon= log_descriptor.previous_flush_horizon;
   DBUG_PRINT("info", ("flush_in_progress is set"));
-  pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.log_flush_lock);
 
   translog_lock();
   if (log_descriptor.is_everything_flushed)
@@ -7648,13 +7648,13 @@ my_bool translog_flush(TRANSLOG_ADDRESS 
     rc|= sync_dir(log_descriptor.directory_fd, MYF(MY_WME | MY_IGNORE_BADFD));
   log_descriptor.previous_flush_horizon= flush_horizon;
 out:
-  pthread_mutex_lock(&log_descriptor.log_flush_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.log_flush_lock);
   if (sent_to_disk != LSN_IMPOSSIBLE)
     log_descriptor.flushed= sent_to_disk;
   log_descriptor.flush_in_progress= 0;
   DBUG_PRINT("info", ("flush_in_progress is dropped"));
-  pthread_mutex_unlock(&log_descriptor.log_flush_lock);\
-  pthread_cond_broadcast(&log_descriptor.log_flush_cond);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.log_flush_lock);\
+  MYSQL_COND_BROADCAST(&log_descriptor.log_flush_cond);
   DBUG_RETURN(rc);
 }
 
@@ -7685,7 +7685,7 @@ int translog_assign_id_to_share(MARIA_HA
   */
   DBUG_ASSERT(share->data_file_type == BLOCK_RECORD);
   /* re-check under mutex to avoid having 2 ids for the same share */
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   if (unlikely(share->id == 0))
   {
     LSN lsn;
@@ -7732,11 +7732,11 @@ int translog_assign_id_to_share(MARIA_HA
                                        sizeof(log_array)/sizeof(log_array[0]),
                                        log_array, log_data, NULL)))
     {
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       return 1;
     }
   }
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   return 0;
 }
 
@@ -7759,7 +7759,7 @@ void translog_deassign_id_from_share(MAR
     happening. But a Checkpoint may be reading share->id, so we require this
     mutex:
   */
-  safe_mutex_assert_owner(&share->intern_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&share->intern_lock);
   my_atomic_rwlock_rdlock(&LOCK_id_to_share);
   my_atomic_storeptr((void **)&id_to_share[share->id], 0);
   my_atomic_rwlock_rdunlock(&LOCK_id_to_share);
@@ -7813,14 +7813,14 @@ static uint32 translog_first_file(TRANSL
   uint min_file= 0, max_file;
   DBUG_ENTER("translog_first_file");
   if (!is_protected)
-    pthread_mutex_lock(&log_descriptor.purger_lock);
+    MYSQL_MUTEX_LOCK(&log_descriptor.purger_lock);
   if (log_descriptor.min_file_number &&
       translog_is_file(log_descriptor.min_file_number))
   {
     DBUG_PRINT("info", ("cached %lu",
                         (ulong) log_descriptor.min_file_number));
     if (!is_protected)
-      pthread_mutex_unlock(&log_descriptor.purger_lock);
+      MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
     DBUG_RETURN(log_descriptor.min_file_number);
   }
 
@@ -7841,7 +7841,7 @@ static uint32 translog_first_file(TRANSL
   }
   log_descriptor.min_file_number= max_file;
   if (!is_protected)
-    pthread_mutex_unlock(&log_descriptor.purger_lock);
+    MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
   DBUG_PRINT("info", ("first file :%lu", (ulong) max_file));
   DBUG_ASSERT(max_file >= 1);
   DBUG_RETURN(max_file);
@@ -8029,7 +8029,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS 
   DBUG_ASSERT(translog_status == TRANSLOG_OK ||
               translog_status == TRANSLOG_READONLY);
 
-  pthread_mutex_lock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.purger_lock);
   if (LSN_FILE_NO(log_descriptor.last_lsn_checked) < last_need_file)
   {
     uint32 i;
@@ -8058,7 +8058,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS 
       if (i >= log_descriptor.min_file)
       {
         TRANSLOG_FILE *file;
-        rw_wrlock(&log_descriptor.open_files_lock);
+        MYSQL_RWLOCK_WRLOCK(&log_descriptor.open_files_lock);
         DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
                     log_descriptor.open_files.elements);
         DBUG_ASSERT(log_descriptor.min_file == i);
@@ -8068,7 +8068,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS 
         log_descriptor.min_file++;
         DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
                     log_descriptor.open_files.elements);
-        rw_unlock(&log_descriptor.open_files_lock);
+        MYSQL_RWLOCK_UNLOCK(&log_descriptor.open_files_lock);
         translog_close_log_file(file);
       }
       if (log_purge_type == TRANSLOG_PURGE_IMMIDIATE)
@@ -8084,7 +8084,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS 
       log_descriptor.min_need_file= i;
   }
 
-  pthread_mutex_unlock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
   DBUG_RETURN(rc);
 }
 
@@ -8121,12 +8121,12 @@ my_bool translog_purge_at_flush()
     DBUG_RETURN(0);
   }
 
-  pthread_mutex_lock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.purger_lock);
 
   if (unlikely(log_descriptor.min_need_file == 0))
   {
     DBUG_PRINT("info", ("No info about min need file => exit"));
-    pthread_mutex_unlock(&log_descriptor.purger_lock);
+    MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
     DBUG_RETURN(0);
   }
 
@@ -8140,7 +8140,7 @@ my_bool translog_purge_at_flush()
     rc= test(my_delete(file_name, MYF(MY_WME)));
   }
 
-  pthread_mutex_unlock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
   DBUG_RETURN(rc);
 }
 
@@ -8170,9 +8170,9 @@ uint32 translog_get_first_file(TRANSLOG_
 uint32 translog_get_first_needed_file()
 {
   uint32 file_no;
-  pthread_mutex_lock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_LOCK(&log_descriptor.purger_lock);
   file_no= log_descriptor.min_need_file;
-  pthread_mutex_unlock(&log_descriptor.purger_lock);
+  MYSQL_MUTEX_UNLOCK(&log_descriptor.purger_lock);
   return file_no;
 }
 

=== modified file 'storage/maria/ma_open.c'
--- a/storage/maria/ma_open.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_open.c	2008-10-10 20:34:55 +0000
@@ -162,7 +162,7 @@ static MARIA_HA *maria_clone_internal(MA
     goto err;
 
 
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   info.read_record= share->read_record;
   share->reopen++;
   share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
@@ -188,7 +188,7 @@ static MARIA_HA *maria_clone_internal(MA
   }
   info.state_start= info.state;                 /* Initial values */
 
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 
   /* Allocate buffer for one record */
   /* prerequisites: info->rec_buffer == 0 && info->rec_buff_size == 0 */
@@ -234,11 +234,11 @@ err:
 MARIA_HA *maria_clone(MARIA_SHARE *share, int mode)
 {
   MARIA_HA *new_info;
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   new_info= maria_clone_internal(share, mode,
                                  share->data_file_type == BLOCK_RECORD ?
                                  share->bitmap.file.file : -1);
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   return new_info;
 }
 
@@ -278,7 +278,7 @@ MARIA_HA *maria_open(const char *name, i
 
   my_realpath(name_buff, fn_format(org_name,name,"",MARIA_NAME_IEXT,
                                    MY_UNPACK_FILENAME),MYF(0));
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   old_info= 0;
   if ((open_flags & HA_OPEN_COPY) ||
       !(old_info=_ma_test_if_reopen(name_buff)))
@@ -508,7 +508,7 @@ MARIA_HA *maria_open(const char *name, i
                          &share->open_file_name.str,
                          share->open_file_name.length+1,
 			 &share->state.key_root,keys*sizeof(my_off_t),
-			 &share->mmap_lock,sizeof(rw_lock_t),
+			 &share->mmap_lock,sizeof(mysql_rwlock_t),
 			 NullS))
       goto err;
     errpos= 4;
@@ -885,7 +885,7 @@ MARIA_HA *maria_open(const char *name, i
   if (!(m_info= maria_clone_internal(share, mode, data_file)))
     goto err;
 
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   DBUG_RETURN(m_info);
 
 err:
@@ -924,7 +924,7 @@ err:
   default:
     break;
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   my_errno= save_errno;
   DBUG_RETURN (NULL);
 } /* maria_open */
@@ -1178,10 +1178,10 @@ uint _ma_state_info_write(MARIA_SHARE *s
     return 0;
 
   if (pWrite & 4)
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
   else if (maria_multi_threaded)
   {
-    safe_mutex_assert_owner(&share->intern_lock);
+    MYSQL_MUTEX_ASSERT_OWNER(&share->intern_lock);
   }
   if (share->base.born_transactional && translog_status == TRANSLOG_OK &&
       !maria_in_recovery)
@@ -1197,7 +1197,7 @@ uint _ma_state_info_write(MARIA_SHARE *s
   }
   res= _ma_state_info_write_sub(share->kfile.file, &share->state, pWrite);
   if (pWrite & 4)
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   share->changed= 0;
   return res;
 }
@@ -1737,11 +1737,11 @@ int _ma_open_keyfile(MARIA_SHARE *share)
     Modifications to share->kfile should be under intern_lock to protect
     against a concurrent checkpoint.
   */
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   share->kfile.file= my_open(share->unique_file_name.str,
                              share->mode | O_SHARE,
                              MYF(MY_WME));
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   return (share->kfile.file < 0);
 }
 

=== modified file 'storage/maria/ma_page.c'
--- a/storage/maria/ma_page.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_page.c	2008-10-10 20:34:55 +0000
@@ -329,18 +329,18 @@ my_off_t _ma_new(register MARIA_HA *info
 
   if (_ma_lock_key_del(info, 1))
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     pos= share->state.state.key_file_length;
     if (pos >= share->base.max_key_file_length - block_size)
     {
       my_errno=HA_ERR_INDEX_FILE_FULL;
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       DBUG_RETURN(HA_OFFSET_ERROR);
     }
     share->state.state.key_file_length+= block_size;
     /* Following is for not transactional tables */
     info->state->key_file_length= share->state.state.key_file_length;
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     (*page_link)->changed= 0;
     (*page_link)->write_lock= PAGECACHE_LOCK_WRITE;
   }

=== modified file 'storage/maria/ma_pagecache.h'
--- a/storage/maria/ma_pagecache.h	2008-03-04 11:58:21 +0000
+++ b/storage/maria/ma_pagecache.h	2008-10-10 20:34:55 +0000
@@ -140,7 +140,7 @@ typedef struct st_pagecache
   uchar HUGE_PTR *block_mem;     /* memory for block buffers                 */
   PAGECACHE_BLOCK_LINK *used_last;/* ptr to the last block of the LRU chain  */
   PAGECACHE_BLOCK_LINK *used_ins;/* ptr to the insertion block in LRU chain  */
-  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
+  mysql_mutex_t cache_lock;    /* to lock access to the cache structure    */
   WQUEUE resize_queue; /* threads waiting during resize operation  */
   WQUEUE waiting_for_hash_link;/* waiting for a free hash link     */
   WQUEUE waiting_for_block;   /* requests waiting for a free block */

=== modified file 'storage/maria/ma_panic.c'
--- a/storage/maria/ma_panic.c	2007-12-31 11:52:45 +0000
+++ b/storage/maria/ma_panic.c	2008-10-10 20:34:55 +0000
@@ -45,7 +45,7 @@ int maria_panic(enum ha_panic_function f
 
   if (!maria_inited)
     DBUG_RETURN(0);
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   for (list_element=maria_open_list ; list_element ; list_element=next_open)
   {
     next_open=list_element->next;		/* Save if close */
@@ -57,10 +57,10 @@ int maria_panic(enum ha_panic_function f
         happen in MySQL), as we release the mutex, the list may change and so
         we may crash.
       */
-      pthread_mutex_unlock(&THR_LOCK_maria);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
       if (maria_close(info))
 	error=my_errno;
-      pthread_mutex_lock(&THR_LOCK_maria);
+      MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
       break;
     case HA_PANIC_WRITE:		/* Do this to free databases */
 #ifdef CANT_OPEN_FILES_TWICE
@@ -131,7 +131,7 @@ int maria_panic(enum ha_panic_function f
       break;
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   if (flag == HA_PANIC_CLOSE)
     maria_end();
   if (!error)

=== modified file 'storage/maria/ma_range.c'
--- a/storage/maria/ma_range.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_range.c	2008-10-10 20:34:55 +0000
@@ -60,7 +60,7 @@ ha_rows maria_records_in_range(MARIA_HA 
   info->update&= (HA_STATE_CHANGED+HA_STATE_ROW_CHANGED);
   keyinfo= share->keyinfo + inx;
   if (share->lock_key_trees)
-    rw_rdlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
 
   switch (keyinfo->key_alg) {
 #ifdef HAVE_RTREE_KEYS
@@ -109,7 +109,7 @@ ha_rows maria_records_in_range(MARIA_HA 
   }
 
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
   fast_ma_writeinfo(info);
 
   /**

=== modified file 'storage/maria/ma_recovery.c'
--- a/storage/maria/ma_recovery.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_recovery.c	2008-10-10 20:34:55 +0000
@@ -3121,7 +3121,7 @@ static int close_all_tables(void)
   TRANSLOG_ADDRESS addr;
   DBUG_ENTER("close_all_tables");
 
-  pthread_mutex_lock(&THR_LOCK_maria);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   if (maria_open_list == NULL)
     goto end;
   tprint(tracef, "Closing all tables\n");
@@ -3152,7 +3152,7 @@ static int close_all_tables(void)
       break;
     next_open= list_element->next;
     info= (MARIA_HA*)list_element->data;
-    pthread_mutex_unlock(&THR_LOCK_maria); /* ok, UNDO phase not online yet */
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria); /* ok, UNDO phase not online yet */
     /*
       Tables which we see here are exactly those which were open at time of
       crash. They might have open_count>0 as Checkpoint maybe flushed their
@@ -3162,10 +3162,10 @@ static int close_all_tables(void)
     info->s->state.open_count= 0;
     prepare_table_for_close(info, addr);
     error|= maria_close(info);
-    pthread_mutex_lock(&THR_LOCK_maria);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_maria);
   }
 end:
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_maria);
   DBUG_RETURN(error);
 }
 

=== modified file 'storage/maria/ma_rkey.c'
--- a/storage/maria/ma_rkey.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_rkey.c	2008-10-10 20:34:55 +0000
@@ -79,7 +79,7 @@ int maria_rkey(MARIA_HA *info, uchar *bu
   if (fast_ma_readinfo(info))
     goto err;
   if (share->lock_key_trees)
-    rw_rdlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
 
   nextflag= maria_read_vec[search_flag] | key.flag;
 
@@ -155,7 +155,7 @@ int maria_rkey(MARIA_HA *info, uchar *bu
     }
   }
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
 
   if (info->cur_row.lastpos == HA_OFFSET_ERROR)
   {

=== modified file 'storage/maria/ma_rnext.c'
--- a/storage/maria/ma_rnext.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_rnext.c	2008-10-10 20:34:55 +0000
@@ -43,7 +43,7 @@ int maria_rnext(MARIA_HA *info, uchar *b
     DBUG_RETURN(my_errno);
   keyinfo= share->keyinfo + inx;
   if (share->lock_key_trees)
-    rw_rdlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
   changed= _ma_test_if_changed(info);
   if (!flag)
   {
@@ -100,7 +100,7 @@ int maria_rnext(MARIA_HA *info, uchar *b
     }
   }
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
 
 	/* Don't clear if database-changed */
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);

=== modified file 'storage/maria/ma_rnext_same.c'
--- a/storage/maria/ma_rnext_same.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_rnext_same.c	2008-10-10 20:34:55 +0000
@@ -40,7 +40,7 @@ int maria_rnext_same(MARIA_HA *info, uch
 
   keyinfo= info->s->keyinfo+inx;
   if (info->s->lock_key_trees)
-    rw_rdlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
 
   switch (keyinfo->key_alg) {
 #ifdef HAVE_RTREE_KEYS
@@ -85,7 +85,7 @@ int maria_rnext_same(MARIA_HA *info, uch
       }
   }
   if (info->s->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
 	/* Don't clear if database-changed */
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
   info->update|= HA_STATE_NEXT_FOUND | HA_STATE_RNEXT_SAME;

=== modified file 'storage/maria/ma_rprev.c'
--- a/storage/maria/ma_rprev.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_rprev.c	2008-10-10 20:34:55 +0000
@@ -42,7 +42,7 @@ int maria_rprev(MARIA_HA *info, uchar *b
   keyinfo= share->keyinfo + inx;
   changed= _ma_test_if_changed(info);
   if (share->lock_key_trees)
-    rw_rdlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
   if (!flag)
     error= _ma_search_last(info, keyinfo, share->state.key_root[inx]);
   else if (!changed)
@@ -65,7 +65,7 @@ int maria_rprev(MARIA_HA *info, uchar *b
     }
   }
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
   info->update|= HA_STATE_PREV_FOUND;
   if (error)

=== modified file 'storage/maria/ma_rsame.c'
--- a/storage/maria/ma_rsame.c	2008-06-26 17:48:42 +0000
+++ b/storage/maria/ma_rsame.c	2008-10-10 20:34:55 +0000
@@ -62,11 +62,11 @@ int maria_rsame(MARIA_HA *info, uchar *r
                          info->cur_row.lastpos,
                          info->cur_row.trid);
     if (info->s->lock_key_trees)
-      rw_rdlock(&keyinfo->root_lock);
+      MYSQL_RWLOCK_RDLOCK(&keyinfo->root_lock);
     (void)(_ma_search(info, &info->last_key, SEARCH_SAME,
                       info->s->state.key_root[inx]));
     if (info->s->lock_key_trees)
-      rw_unlock(&keyinfo->root_lock);
+      MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
   }
 
   if (!(*info->read_record)(info, record, info->cur_row.lastpos))

=== modified file 'storage/maria/ma_sort.c'
--- a/storage/maria/ma_sort.c	2008-06-26 17:48:42 +0000
+++ b/storage/maria/ma_sort.c	2008-10-10 20:34:55 +0000
@@ -484,10 +484,10 @@ ok:
     if (sort_param->read_cache.share)
       remove_io_thread(&sort_param->read_cache);
 
-    pthread_mutex_lock(&sort_param->sort_info->mutex);
+    MYSQL_MUTEX_LOCK(&sort_param->sort_info->mutex);
     if (!--sort_param->sort_info->threads_running)
-      pthread_cond_signal(&sort_param->sort_info->cond);
-    pthread_mutex_unlock(&sort_param->sort_info->mutex);
+      MYSQL_COND_SIGNAL(&sort_param->sort_info->cond);
+    MYSQL_MUTEX_UNLOCK(&sort_param->sort_info->mutex);
     DBUG_PRINT("exit", ("======== ending thread ========"));
   }
   my_thread_end();

=== modified file 'storage/maria/ma_state.c'
--- a/storage/maria/ma_state.c	2008-08-18 22:21:22 +0000
+++ b/storage/maria/ma_state.c	2008-10-10 20:34:55 +0000
@@ -77,7 +77,7 @@ my_bool _ma_setup_live_state(MARIA_HA *i
   trn->used_tables= tables;
   tables->share= share;
 
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   share->in_trans++;
   DBUG_PRINT("info", ("share: 0x%lx  in_trans: %d",
                       (ulong) share, share->in_trans));
@@ -93,7 +93,7 @@ my_bool _ma_setup_live_state(MARIA_HA *i
   */
   while (trn->trid < history->trid)
     history= history->next;
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   /* The current item can't be deleted as it's the first one visible for us */
   tables->state_start=  tables->state_current= history->state;
   DBUG_PRINT("info", ("records: %ld", (ulong) tables->state_start.records));
@@ -190,10 +190,10 @@ MARIA_STATE_HISTORY
 void _ma_remove_not_visible_states_with_lock(MARIA_SHARE *share)
 {
   trnman_lock();
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   share->state_history=  _ma_remove_not_visible_states(share->state_history, 0,
                                                        1);
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   trnman_unlock();
 }
 
@@ -374,7 +374,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *t
     {
       MARIA_STATE_HISTORY *history;
 
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       if (active_transactions && share->now_transactional &&
           trnman_exists_active_transactions(share->state_history->trid,
                                             trn->commit_trid, 1))
@@ -383,7 +383,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *t
         {
           /* purecov: begin inspected */
           error= 1;
-          pthread_mutex_unlock(&share->intern_lock);
+          MYSQL_MUTEX_UNLOCK(&share->intern_lock);
           my_free(tables, MYF(0));
           continue;
           /* purecov: end */
@@ -412,7 +412,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *t
       DBUG_PRINT("info", ("share: 0x%lx  in_trans: %d",
                           (ulong) share, share->in_trans));
       share->in_trans--;
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     }
     else
     {
@@ -421,9 +421,9 @@ my_bool _ma_trnman_end_trans_hook(TRN *t
         We need to keep share->in_trans correct in the debug library
         because of the assert in maria_close()
       */
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       share->in_trans--;
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 #endif
     }
     my_free(tables, MYF(0));
@@ -450,7 +450,7 @@ void _ma_remove_table_from_trnman(MARIA_
   DBUG_PRINT("enter", ("share: 0x%lx  in_trans: %d",
                        (ulong) share, share->in_trans));
 
-  safe_mutex_assert_owner(&share->intern_lock);
+  MYSQL_MUTEX_ASSERT_OWNER(&share->intern_lock);
   
   for (prev= (MARIA_USED_TABLES**) &trn->used_tables, tables= *prev;
        tables;
@@ -547,10 +547,10 @@ void maria_versioning(MARIA_HA *info, my
 
 void _ma_set_share_data_file_length(MARIA_SHARE *share, ulonglong new_length)
 {
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   if (share->state.state.data_file_length < new_length)
     share->state.state.data_file_length= new_length;
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 }
 
 

=== modified file 'storage/maria/ma_static.c'
--- a/storage/maria/ma_static.c	2008-06-26 05:18:28 +0000
+++ b/storage/maria/ma_static.c	2008-10-10 20:34:55 +0000
@@ -36,7 +36,7 @@ my_bool maria_flush= 0, maria_single_use
 my_bool maria_delay_key_write= 0, maria_page_checksums= 1;
 my_bool maria_inited= FALSE;
 my_bool maria_in_ha_maria= FALSE; /* If used from ha_maria or not */
-pthread_mutex_t THR_LOCK_maria;
+mysql_mutex_t THR_LOCK_maria;
 #if defined(THREAD) && !defined(DONT_USE_RW_LOCKS)
 ulong maria_concurrent_insert= 2;
 #else

=== modified file 'storage/maria/ma_write.c'
--- a/storage/maria/ma_write.c	2008-08-25 18:23:18 +0000
+++ b/storage/maria/ma_write.c	2008-10-10 20:34:55 +0000
@@ -165,7 +165,7 @@ int maria_write(MARIA_HA *info, uchar *r
                                   is_tree_inited(&info->bulk_insert[i])));
       if (local_lock_tree)
       {
-	rw_wrlock(&keyinfo->root_lock);
+	MYSQL_RWLOCK_WRLOCK(&keyinfo->root_lock);
 	keyinfo->version++;
       }
       if (keyinfo->flag & HA_FULLTEXT )
@@ -173,7 +173,7 @@ int maria_write(MARIA_HA *info, uchar *r
         if (_ma_ft_add(info,i, buff,record,filepos))
         {
 	  if (local_lock_tree)
-	    rw_unlock(&keyinfo->root_lock);
+	    MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
           DBUG_PRINT("error",("Got error: %d on write",my_errno));
           goto err;
         }
@@ -186,7 +186,7 @@ int maria_write(MARIA_HA *info, uchar *r
                                                     info->trn->trid)))
         {
           if (local_lock_tree)
-            rw_unlock(&keyinfo->root_lock);
+            MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
           DBUG_PRINT("error",("Got error: %d on write",my_errno));
           goto err;
         }
@@ -196,7 +196,7 @@ int maria_write(MARIA_HA *info, uchar *r
       info->update&= ~HA_STATE_RNEXT_SAME;
 
       if (local_lock_tree)
-        rw_unlock(&keyinfo->root_lock);
+        MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
     }
   }
   if (share->calc_write_checksum)
@@ -276,7 +276,7 @@ err:
                                     is_tree_inited(&info->bulk_insert[i])));
         keyinfo= share->keyinfo + i;
 	if (local_lock_tree)
-	  rw_wrlock(&keyinfo->root_lock);
+	  MYSQL_RWLOCK_WRLOCK(&keyinfo->root_lock);
         /**
            @todo RECOVERY BUG
            The key deletes below should generate CLR_ENDs
@@ -286,7 +286,7 @@ err:
           if (_ma_ft_del(info,i,buff,record,filepos))
 	  {
 	    if (local_lock_tree)
-	      rw_unlock(&keyinfo->root_lock);
+	      MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
             break;
 	  }
         }
@@ -298,12 +298,12 @@ err:
                                                  filepos, info->trn->trid)))
 	  {
 	    if (local_lock_tree)
-	      rw_unlock(&keyinfo->root_lock);
+	      MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
 	    break;
 	  }
 	}
 	if (local_lock_tree)
-	  rw_unlock(&keyinfo->root_lock);
+	  MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
       }
     }
   }
@@ -1545,7 +1545,7 @@ static int keys_free(uchar *key, TREE_FR
   case free_init:
     if (share->lock_key_trees)
     {
-      rw_wrlock(&keyinfo->root_lock);
+      MYSQL_RWLOCK_WRLOCK(&keyinfo->root_lock);
       keyinfo->version++;
     }
     return 0;
@@ -1566,7 +1566,7 @@ static int keys_free(uchar *key, TREE_FR
     return _ma_ck_write_btree(param->info, &tmp_key);
   case free_end:
     if (share->lock_key_trees)
-      rw_unlock(&keyinfo->root_lock);
+      MYSQL_RWLOCK_UNLOCK(&keyinfo->root_lock);
     return 0;
   }
   return 1;

=== modified file 'storage/maria/maria_def.h'
--- a/storage/maria/maria_def.h	2008-08-25 11:49:47 +0000
+++ b/storage/maria/maria_def.h	2008-10-10 20:34:55 +0000
@@ -246,8 +246,8 @@ typedef struct st_maria_file_bitmap
   PAGECACHE_FILE file;		       /* datafile where bitmap is stored */
 
 #ifdef THREAD
-  pthread_mutex_t bitmap_lock;
-  pthread_cond_t bitmap_cond;          /**< When bitmap becomes flushable */
+  mysql_mutex_t bitmap_lock;
+  mysql_cond_t bitmap_cond;          /**< When bitmap becomes flushable */
 #endif
   /* Constants, allocated when initiating bitmaps */
   uint sizes[8];                      /* Size per bit combination */
@@ -384,14 +384,14 @@ typedef struct st_maria_share
 #ifdef THREAD
   THR_LOCK lock;
   void (*lock_restore_status)(void *);
-  pthread_mutex_t intern_lock;		/* Locking for use with _locking */
-  pthread_cond_t intern_cond;
+  mysql_mutex_t intern_lock;		/* Locking for use with _locking */
+  mysql_cond_t intern_cond;
 #endif
   my_off_t mmaped_length;
   uint nonmmaped_inserts;		/* counter of writing in
 						   non-mmaped area */
   MARIA_FILE_BITMAP bitmap;
-  rw_lock_t mmap_lock;
+  mysql_rwlock_t mmap_lock;
   LSN lsn_of_file_id; /**< LSN of its last LOGREC_FILE_ID */
 } MARIA_SHARE;
 
@@ -729,12 +729,12 @@ struct st_maria_handler
 #define maria_unique_store(A,B)    mi_int4store((A),(B))
 
 #ifdef THREAD
-extern pthread_mutex_t THR_LOCK_maria;
+extern mysql_mutex_t THR_LOCK_maria;
 #endif
 #if !defined(THREAD) || defined(DONT_USE_RW_LOCKS)
-#define rw_wrlock(A) {}
-#define rw_rdlock(A) {}
-#define rw_unlock(A) {}
+#define MYSQL_RWLOCK_WRLOCK(A) {}
+#define MYSQL_RWLOCK_RDLOCK(A) {}
+#define MYSQL_RWLOCK_UNLOCK(A) {}
 #endif
 
 /* Some tuning parameters */

=== modified file 'storage/maria/tablockman.c'
--- a/storage/maria/tablockman.c	2008-01-10 12:21:53 +0000
+++ b/storage/maria/tablockman.c	2008-10-10 20:34:55 +0000
@@ -282,7 +282,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE
   DBUG_ASSERT(lo->waiting_for == 0);
   DBUG_ASSERT(lo->waiting_for_loid == 0);
 
-  pthread_mutex_lock(& table->mutex);
+  MYSQL_MUTEX_LOCK(& table->mutex);
   /* do we already have a lock on this resource ? */
   old= find_by_loid(table, lo->loid);
 
@@ -298,16 +298,16 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE
   }
 
   /* no, placing a new lock. first - take a free lock structure from the pool */
-  pthread_mutex_lock(& lm->pool_mutex);
+  MYSQL_MUTEX_LOCK(& lm->pool_mutex);
   new= lm->pool;
   if (new)
   {
     lm->pool= new->next;
-    pthread_mutex_unlock(& lm->pool_mutex);
+    MYSQL_MUTEX_UNLOCK(& lm->pool_mutex);
   }
   else
   {
-    pthread_mutex_unlock(& lm->pool_mutex);
+    MYSQL_MUTEX_UNLOCK(& lm->pool_mutex);
     new= (TABLE_LOCK *)my_malloc(sizeof(*new), MYF(MY_WME));
     if (unlikely(!new))
     {
@@ -443,13 +443,13 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE
       and we must release table's mutex.
       note that blocker's mutex is locked _before_ table's mutex is released
     */
-    pthread_mutex_lock(wait_for->mutex);
-    pthread_mutex_unlock(& table->mutex);
+    MYSQL_MUTEX_LOCK(wait_for->mutex);
+    MYSQL_MUTEX_UNLOCK(& table->mutex);
 
     /* now really wait */
-    i= pthread_cond_timedwait(wait_for->cond, wait_for->mutex, & timeout);
+    i= MYSQL_COND_TIMEDWAIT(wait_for->cond, wait_for->mutex, & timeout);
 
-    pthread_mutex_unlock(wait_for->mutex);
+    MYSQL_MUTEX_UNLOCK(wait_for->mutex);
 
     if (i == ETIMEDOUT || i == ETIME)
     {
@@ -458,7 +458,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE
       goto ret2;
     }
 
-    pthread_mutex_lock(& table->mutex);
+    MYSQL_MUTEX_LOCK(& table->mutex);
 
     /* ... and repeat from the beginning */
   }
@@ -493,7 +493,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE
   res= getlock_result[lock][lock];
 
 ret:
-  pthread_mutex_unlock(& table->mutex);
+  MYSQL_MUTEX_UNLOCK(& table->mutex);
 ret2:
   DBUG_ASSERT(res);
   return res;
@@ -520,7 +520,7 @@ void tablockman_release_locks(TABLOCKMAN
   if ((lock= lo->waiting_lock))
   {
     DBUG_ASSERT(lock->loid == lo->loid);
-    pthread_mutex_lock(& lock->table->mutex);
+    MYSQL_MUTEX_LOCK(& lock->table->mutex);
     remove_from_wait_queue(lock, lock->table);
 
     /*
@@ -544,13 +544,13 @@ void tablockman_release_locks(TABLOCKMAN
     if (lock->next &&
         lock_compatibility_matrix[lock->next->lock_type][lock->lock_type])
     {
-      pthread_mutex_lock(lo->waiting_for->mutex);
-      pthread_cond_broadcast(lo->waiting_for->cond);
-      pthread_mutex_unlock(lo->waiting_for->mutex);
+      MYSQL_MUTEX_LOCK(lo->waiting_for->mutex);
+      MYSQL_COND_BROADCAST(lo->waiting_for->cond);
+      MYSQL_MUTEX_UNLOCK(lo->waiting_for->mutex);
     }
     lo->waiting_for= 0;
     lo->waiting_for_loid= 0;
-    pthread_mutex_unlock(& lock->table->mutex);
+    MYSQL_MUTEX_UNLOCK(& lock->table->mutex);
 
     lock->next= local_pool;
     local_pool= lock;
@@ -561,14 +561,14 @@ void tablockman_release_locks(TABLOCKMAN
   while (lock)
   {
     TABLE_LOCK *cur= lock;
-    pthread_mutex_t *mutex= & lock->table->mutex;
+    mysql_mutex_t *mutex= & lock->table->mutex;
     DBUG_ASSERT(cur->loid == lo->loid);
 
     DBUG_ASSERT(lock != lock->next_in_lo);
     lock= lock->next_in_lo;
 
     /* TODO ? group locks by table to reduce the number of mutex locks */
-    pthread_mutex_lock(mutex);
+    MYSQL_MUTEX_LOCK(mutex);
     hash_delete(& cur->table->latest_locks, (uchar *)cur);
 
     if (cur->prev)
@@ -581,7 +581,7 @@ void tablockman_release_locks(TABLOCKMAN
     cur->next= local_pool;
     local_pool= cur;
 
-    pthread_mutex_unlock(mutex);
+    MYSQL_MUTEX_UNLOCK(mutex);
   }
 
   lo->waiting_lock= lo->active_locks= 0;
@@ -590,15 +590,15 @@ void tablockman_release_locks(TABLOCKMAN
     okay, all locks released. now signal that we're leaving,
     in case somebody's waiting for it
   */
-  pthread_mutex_lock(lo->mutex);
-  pthread_cond_broadcast(lo->cond);
-  pthread_mutex_unlock(lo->mutex);
+  MYSQL_MUTEX_LOCK(lo->mutex);
+  MYSQL_COND_BROADCAST(lo->cond);
+  MYSQL_MUTEX_UNLOCK(lo->mutex);
 
   /* and push all freed locks to the lockman's pool */
-  pthread_mutex_lock(& lm->pool_mutex);
+  MYSQL_MUTEX_LOCK(& lm->pool_mutex);
   local_pool_end->next= lm->pool;
   lm->pool= local_pool;
-  pthread_mutex_unlock(& lm->pool_mutex);
+  MYSQL_MUTEX_UNLOCK(& lm->pool_mutex);
 }
 
 void tablockman_init(TABLOCKMAN *lm, loid_to_tlo_func *func, uint timeout)
@@ -618,7 +618,7 @@ void tablockman_destroy(TABLOCKMAN *lm)
     lm->pool= tmp->next;
     my_free((void *)tmp, MYF(0));
   }
-  pthread_mutex_destroy(& lm->pool_mutex);
+  MYSQL_MUTEX_DESTROY(& lm->pool_mutex);
 }
 
 /*
@@ -648,7 +648,7 @@ void tablockman_destroy_locked_table(LOC
      DBUG_ASSERT(lt->active_locks[i] == 0);
 
   hash_free(& lt->latest_locks);
-  pthread_mutex_destroy(& lt->mutex);
+  MYSQL_MUTEX_DESTROY(& lt->mutex);
 }
 
 #ifdef EXTRA_DEBUG

=== modified file 'storage/maria/tablockman.h'
--- a/storage/maria/tablockman.h	2007-12-18 22:22:55 +0000
+++ b/storage/maria/tablockman.h	2008-10-10 20:34:55 +0000
@@ -50,13 +50,13 @@ typedef struct st_table_lock_owner {
   TABLE_LOCK *active_locks;                          /* list of active locks */
   TABLE_LOCK *waiting_lock;                  /* waiting lock (one lock only) */
   struct st_table_lock_owner *waiting_for; /* transaction we're waiting for  */
-  pthread_cond_t  *cond;      /* transactions waiting for us, wait on 'cond' */
-  pthread_mutex_t *mutex;                 /* mutex is required to use 'cond' */
+  mysql_cond_t  *cond;      /* transactions waiting for us, wait on 'cond' */
+  mysql_mutex_t *mutex;                 /* mutex is required to use 'cond' */
   uint16    loid, waiting_for_loid;                 /* Lock Owner IDentifier */
 } TABLE_LOCK_OWNER;
 
 typedef struct st_locked_table {
-  pthread_mutex_t mutex;                        /* mutex for everything below */
+  mysql_mutex_t mutex;                        /* mutex for everything below */
   HASH latest_locks;                                /* latest locks in a hash */
   TABLE_LOCK *active_locks[LOCK_TYPES];          /* dl-list of locks per type */
   TABLE_LOCK *wait_queue_in, *wait_queue_out; /* wait deque (double-end queue)*/
@@ -65,7 +65,7 @@ typedef struct st_locked_table {
 typedef TABLE_LOCK_OWNER *loid_to_tlo_func(uint16);
 
 typedef struct {
-  pthread_mutex_t pool_mutex;
+  mysql_mutex_t pool_mutex;
   TABLE_LOCK *pool;                                /* lifo pool of free locks */
   uint lock_timeout;                          /* lock timeout in milliseconds */
   loid_to_tlo_func *loid_to_tlo;      /* for mapping loid to TABLE_LOCK_OWNER */

=== modified file 'storage/maria/trnman.c'
--- a/storage/maria/trnman.c	2008-07-05 11:03:21 +0000
+++ b/storage/maria/trnman.c	2008-10-10 20:34:55 +0000
@@ -38,7 +38,7 @@ static TRN committed_list_min, committed
 static TrID global_trid_generator;
 
 /* the mutex for everything above */
-static pthread_mutex_t LOCK_trn_list;
+static mysql_mutex_t LOCK_trn_list;
 
 /* LIFO pool of unused TRN structured for reuse */
 static TRN *pool;
@@ -206,8 +206,8 @@ void trnman_destroy()
     my_free((void *)trn, MYF(0));
   }
   lf_hash_destroy(&trid_to_committed_trn);
-  DBUG_PRINT("info", ("pthread_mutex_destroy LOCK_trn_list"));
-  pthread_mutex_destroy(&LOCK_trn_list);
+  DBUG_PRINT("info", ("MYSQL_MUTEX_DESTROY LOCK_trn_list"));
+  MYSQL_MUTEX_DESTROY(&LOCK_trn_list);
   my_atomic_rwlock_destroy(&LOCK_short_trid_to_trn);
   my_atomic_rwlock_destroy(&LOCK_pool);
   my_free((void *)(short_trid_to_active_trn+1), MYF(0));
@@ -228,8 +228,8 @@ static TrID new_trid()
 {
   DBUG_ENTER("new_trid");
   DBUG_ASSERT(global_trid_generator < 0xffffffffffffLL);
-  DBUG_PRINT("info", ("safe_mutex_assert_owner LOCK_trn_list"));
-  safe_mutex_assert_owner(&LOCK_trn_list);
+  DBUG_PRINT("info", ("MYSQL_MUTEX_ASSERT_OWNER LOCK_trn_list"));
+  MYSQL_MUTEX_ASSERT_OWNER(&LOCK_trn_list);
   DBUG_RETURN(++global_trid_generator);
 }
 
@@ -260,7 +260,7 @@ static void set_short_trid(TRN *trn)
     mutex and cond will be used for lock waits
 */
 
-TRN *trnman_new_trn(pthread_mutex_t *mutex, pthread_cond_t *cond,
+TRN *trnman_new_trn(mysql_mutex_t *mutex, mysql_cond_t *cond,
                     void *stack_end)
 {
   TRN *trn;
@@ -275,8 +275,8 @@ TRN *trnman_new_trn(pthread_mutex_t *mut
     mutex.
   */
 
-  DBUG_PRINT("info", ("pthread_mutex_lock LOCK_trn_list"));
-  pthread_mutex_lock(&LOCK_trn_list);
+  DBUG_PRINT("info", ("MYSQL_MUTEX_LOCK LOCK_trn_list"));
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
 
   /* Allocating a new TRN structure */
   trn= pool;
@@ -302,8 +302,8 @@ TRN *trnman_new_trn(pthread_mutex_t *mut
     trn= (TRN *)my_malloc(sizeof(TRN), MYF(MY_WME | MY_ZEROFILL));
     if (unlikely(!trn))
     {
-      DBUG_PRINT("info", ("pthread_mutex_unlock LOCK_trn_list"));
-      pthread_mutex_unlock(&LOCK_trn_list);
+      DBUG_PRINT("info", ("MYSQL_MUTEX_UNLOCK LOCK_trn_list"));
+      MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
       return 0;
     }
     trnman_allocated_transactions++;
@@ -325,8 +325,8 @@ TRN *trnman_new_trn(pthread_mutex_t *mut
   trn->next= &active_list_max;
   trn->prev= active_list_max.prev;
   active_list_max.prev= trn->prev->next= trn;
-  DBUG_PRINT("info", ("pthread_mutex_unlock LOCK_trn_list"));
-  pthread_mutex_unlock(&LOCK_trn_list);
+  DBUG_PRINT("info", ("MYSQL_MUTEX_UNLOCK LOCK_trn_list"));
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
 
   if (unlikely(!trn->min_read_from))
   {
@@ -390,8 +390,8 @@ my_bool trnman_end_trn(TRN *trn, my_bool
   DBUG_ASSERT(trn->rec_lsn == 0);
   /* if a rollback, all UNDO records should have been executed */
   DBUG_ASSERT(commit || trn->undo_lsn == 0);
-  DBUG_PRINT("info", ("pthread_mutex_lock LOCK_trn_list"));
-  pthread_mutex_lock(&LOCK_trn_list);
+  DBUG_PRINT("info", ("MYSQL_MUTEX_LOCK LOCK_trn_list"));
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
 
   /* remove from active list */
   trn->next->prev= trn->prev;
@@ -467,7 +467,7 @@ my_bool trnman_end_trn(TRN *trn, my_bool
                                active_list_min.next != &active_list_max))
     res= -1;
   trnman_active_transactions--;
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
 
   /* the rest is done outside of a critical section */
 #ifdef NOT_USED
@@ -638,7 +638,7 @@ my_bool trnman_collect_transactions(LEX_
 
   /* validate the use of read_non_atomic() in general: */
   compile_time_assert((sizeof(LSN) == 8) && (sizeof(LSN_WITH_FLAGS) == 8));
-  pthread_mutex_lock(&LOCK_trn_list);
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
   str_act->length= 2 + /* number of active transactions */
     LSN_STORE_SIZE + /* minimum of their rec_lsn */
     TRANSID_SIZE + /* current TrID generator value */
@@ -758,7 +758,7 @@ my_bool trnman_collect_transactions(LEX_
 err:
   error= 1;
 end:
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
   DBUG_RETURN(error);
 }
 
@@ -805,9 +805,9 @@ TrID trnman_get_min_trid()
     return ~(TrID) 0;
   }
 
-  pthread_mutex_lock(&LOCK_trn_list);
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
   min_read_from= active_list_min.next->min_read_from;
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
   return min_read_from;
 }
 
@@ -827,10 +827,10 @@ TrID trnman_get_min_trid()
 TrID trnman_get_min_safe_trid()
 {
   TrID trid;
-  pthread_mutex_lock(&LOCK_trn_list);
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
   trid= min(active_list_min.next->min_read_from,
             global_trid_generator);
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
   return trid;
 }
 
@@ -844,9 +844,9 @@ TrID trnman_get_max_trid()
   TrID id;
   if (short_trid_to_active_trn == NULL)
     return 0;
-  pthread_mutex_lock(&LOCK_trn_list);
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
   id= global_trid_generator;
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
   return id;
 }
 
@@ -872,7 +872,7 @@ my_bool trnman_exists_active_transaction
   my_bool ret= 0;
 
   if (!trnman_is_locked)
-    pthread_mutex_lock(&LOCK_trn_list);
+    MYSQL_MUTEX_LOCK(&LOCK_trn_list);
   for (trn= active_list_min.next; trn != &active_list_max; trn= trn->next)
   {
     if (trn->trid > min_id && trn->trid < max_id)
@@ -882,7 +882,7 @@ my_bool trnman_exists_active_transaction
     }
   }
   if (!trnman_is_locked)
-    pthread_mutex_unlock(&LOCK_trn_list);
+    MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
   return ret;
 }
 
@@ -893,7 +893,7 @@ my_bool trnman_exists_active_transaction
 
 void trnman_lock()
 {
-  pthread_mutex_lock(&LOCK_trn_list);
+  MYSQL_MUTEX_LOCK(&LOCK_trn_list);
 }
 
 /**
@@ -902,5 +902,5 @@ void trnman_lock()
 
 void trnman_unlock()
 {
-  pthread_mutex_unlock(&LOCK_trn_list);
+  MYSQL_MUTEX_UNLOCK(&LOCK_trn_list);
 }

=== modified file 'storage/maria/trnman_public.h'
--- a/storage/maria/trnman_public.h	2008-07-05 11:03:21 +0000
+++ b/storage/maria/trnman_public.h	2008-10-10 20:34:55 +0000
@@ -38,7 +38,7 @@ extern my_bool (*trnman_end_trans_hook)(
 
 int trnman_init(TrID);
 void trnman_destroy(void);
-TRN *trnman_new_trn(pthread_mutex_t *, pthread_cond_t *, void *);
+TRN *trnman_new_trn(mysql_mutex_t *, mysql_cond_t *, void *);
 my_bool trnman_end_trn(TRN *trn, my_bool commit);
 #define trnman_commit_trn(T) trnman_end_trn(T, TRUE)
 #define trnman_abort_trn(T)  trnman_end_trn(T, FALSE)

=== modified file 'storage/myisam/ha_myisam.cc'
--- a/storage/myisam/ha_myisam.cc	2008-07-09 07:12:43 +0000
+++ b/storage/myisam/ha_myisam.cc	2008-10-10 20:34:55 +0000
@@ -523,7 +523,7 @@ void _mi_report_crashed(MI_INFO *file, c
   THD *cur_thd;
   LIST *element;
   char buf[1024];
-  pthread_mutex_lock(&file->s->intern_lock);
+  MYSQL_MUTEX_LOCK(&file->s->intern_lock);
   if ((cur_thd= (THD*) file->in_use.data))
     sql_print_error("Got an error from thread_id=%lu, %s:%d", cur_thd->thread_id,
                     sfile, sline);
@@ -537,7 +537,7 @@ void _mi_report_crashed(MI_INFO *file, c
     sql_print_error("%s", thd ? thd_security_context(thd, buf, sizeof(buf), 0)
                               : "Unknown thread accessing table");
   }
-  pthread_mutex_unlock(&file->s->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&file->s->intern_lock);
 }
 
 }
@@ -787,14 +787,14 @@ int ha_myisam::check(THD* thd, HA_CHECK_
 	mi_is_crashed(file))
     {
       file->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       share->state.changed&= ~(STATE_CHANGED | STATE_CRASHED |
 			       STATE_CRASHED_ON_REPAIR |
                                STATE_BAD_OPEN_COUNT);
       if (!(table->db_stat & HA_READ_ONLY))
 	error=update_state_info(&param,file,UPDATE_TIME | UPDATE_OPEN_COUNT |
 				UPDATE_STAT);
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
       info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |
 	   HA_STATUS_CONST);
     }
@@ -838,9 +838,9 @@ int ha_myisam::analyze(THD *thd, HA_CHEC
   error = chk_key(&param, file);
   if (!error)
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     error=update_state_info(&param,file,UPDATE_STAT);
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   else if (!mi_is_crashed(file) && !thd->killed)
     mi_mark_crashed(file);
@@ -1434,10 +1434,10 @@ bool ha_myisam::check_and_repair(THD *th
 
   old_query= thd->query;
   old_query_length= thd->query_length;
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query=        table->s->table_name.str;
   thd->query_length= table->s->table_name.length;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
 
   if ((marked_crashed= mi_is_crashed(file)) || check(thd, &check_opt))
   {
@@ -1450,10 +1450,10 @@ bool ha_myisam::check_and_repair(THD *th
     if (repair(thd, &check_opt))
       error=1;
   }
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->query= old_query;
   thd->query_length= old_query_length;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   DBUG_RETURN(error);
 }
 
@@ -1694,7 +1694,7 @@ int ha_myisam::info(uint flag)
 
     /* Update share */
     if (share->tmp_table == NO_TMP_TABLE)
-      pthread_mutex_lock(&share->LOCK_ha_data);
+      MYSQL_MUTEX_LOCK(&share->LOCK_ha_data);
     share->keys_in_use.set_prefix(share->keys);
     share->keys_in_use.intersect_extended(misam_info.key_map);
     share->keys_for_keyread.intersect(share->keys_in_use);
@@ -1704,7 +1704,7 @@ int ha_myisam::info(uint flag)
 	     (char*) misam_info.rec_per_key,
 	     sizeof(table->key_info[0].rec_per_key)*share->key_parts);
     if (share->tmp_table == NO_TMP_TABLE)
-      pthread_mutex_unlock(&share->LOCK_ha_data);
+      MYSQL_MUTEX_UNLOCK(&share->LOCK_ha_data);
 
    /*
      Set data_file_name and index_file_name to point at the symlink value

=== modified file 'storage/myisam/mi_check.c'
--- a/storage/myisam/mi_check.c	2008-08-24 16:12:12 +0000
+++ b/storage/myisam/mi_check.c	2008-10-10 20:34:55 +0000
@@ -2909,7 +2909,7 @@ int mi_repair_parallel(HA_CHECK *param, 
   sort_param[0].calc_checksum= test(param->testflag & T_CALC_CHECKSUM);
 
   sort_info.got_error=0;
-  pthread_mutex_lock(&sort_info.mutex);
+  MYSQL_MUTEX_LOCK(&sort_info.mutex);
 
   /*
     Initialize the I/O cache share for use with the read caches and, in
@@ -2975,8 +2975,8 @@ int mi_repair_parallel(HA_CHECK *param, 
 
   /* waiting for all threads to finish */
   while (sort_info.threads_running)
-    pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
-  pthread_mutex_unlock(&sort_info.mutex);
+    MYSQL_COND_WAIT(&sort_info.cond, &sort_info.mutex);
+  MYSQL_MUTEX_UNLOCK(&sort_info.mutex);
 
   if ((got_error= thr_write_keys(sort_param)))
   {
@@ -3120,8 +3120,8 @@ err:
     share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS;
   share->state.changed|=STATE_NOT_SORTED_PAGES;
 
-  pthread_cond_destroy (&sort_info.cond);
-  pthread_mutex_destroy(&sort_info.mutex);
+  MYSQL_COND_DESTROY (&sort_info.cond);
+  MYSQL_MUTEX_DESTROY(&sort_info.mutex);
 
   my_free((uchar*) sort_info.ft_buf, MYF(MY_ALLOW_ZERO_PTR));
   my_free((uchar*) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));

=== modified file 'storage/myisam/mi_close.c'
--- a/storage/myisam/mi_close.c	2008-07-09 07:12:43 +0000
+++ b/storage/myisam/mi_close.c	2008-10-10 20:34:55 +0000
@@ -31,7 +31,7 @@ int mi_close(register MI_INFO *info)
 		      info, (uint) share->reopen,
                       (uint) share->tot_locks));
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   if (info->lock_type == F_EXTRA_LCK)
     info->lock_type=F_UNLCK;			/* HA_EXTRA_NO_USER_CHANGE */
 
@@ -43,7 +43,7 @@ int mi_close(register MI_INFO *info)
     if (mi_lock_database(info,F_UNLCK))
       error=my_errno;
   }
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
 
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
@@ -60,7 +60,7 @@ int mi_close(register MI_INFO *info)
   }
   flag= !--share->reopen;
   myisam_open_list=list_delete(myisam_open_list,&info->open_list);
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 
   my_free(mi_get_rec_buff_ptr(info, info->rec_buff), MYF(MY_ALLOW_ZERO_PTR));
   if (flag)
@@ -102,20 +102,20 @@ int mi_close(register MI_INFO *info)
     }
 #ifdef THREAD
     thr_lock_delete(&share->lock);
-    pthread_mutex_destroy(&share->intern_lock);
+    MYSQL_MUTEX_DESTROY(&share->intern_lock);
     my_atomic_rwlock_destroy(&share->physical_logging_rwlock);
     {
       int i,keys;
       keys = share->state.header.keys;
-      (void) rwlock_destroy(&share->mmap_lock);
+      (void) MYSQL_RWLOCK_DESTROY(&share->mmap_lock);
       for(i=0; i<keys; i++) {
-	(void) rwlock_destroy(&share->key_root_lock[i]);
+	(void) MYSQL_RWLOCK_DESTROY(&share->key_root_lock[i]);
       }
     }
 #endif
     my_free((uchar*) info->s,MYF(0));
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   if (info->ftparser_param)
   {
     my_free((uchar*)info->ftparser_param, MYF(0));

=== modified file 'storage/myisam/mi_create.c'
--- a/storage/myisam/mi_create.c	2008-08-25 18:23:27 +0000
+++ b/storage/myisam/mi_create.c	2008-10-10 20:34:55 +0000
@@ -580,7 +580,7 @@ int mi_create(const char *name,uint keys
   my_atomic_rwlock_init(&share.physical_logging_rwlock);
 #endif
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
 
   /*
     NOTE: For test_if_reopen() we need a real path name. Hence we need
@@ -843,7 +843,7 @@ int mi_create(const char *name,uint keys
       goto err;
   }
   errpos=0;
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   res= 0;
   if (my_close(file,MYF(0)))
     res= my_errno;
@@ -854,7 +854,7 @@ int mi_create(const char *name,uint keys
   DBUG_RETURN(res);
 
 err:
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
 err_no_lock:
 
   save_errno=my_errno;

=== modified file 'storage/myisam/mi_dbug.c'
--- a/storage/myisam/mi_dbug.c	2008-05-29 15:44:11 +0000
+++ b/storage/myisam/mi_dbug.c	2008-10-10 20:34:55 +0000
@@ -173,7 +173,7 @@ my_bool check_table_is_closed(const char
   LIST *pos;
   DBUG_ENTER("check_table_is_closed");
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
 
   (void) fn_format(filename,name,"",MI_NAME_IEXT,4+16+32);
   for (pos=myisam_open_list ; pos ; pos=pos->next)
@@ -186,12 +186,12 @@ my_bool check_table_is_closed(const char
       {
 	fprintf(stderr,"Warning:  Table: %s is open on %s\n", name,where);
 	DBUG_PRINT("warning",("Table: %s is open on %s", name,where));
-        pthread_mutex_unlock(&THR_LOCK_myisam);
+        MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
 	DBUG_RETURN(1);
       }
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   DBUG_RETURN(0);
 }
 #endif /* EXTRA_DEBUG */

=== modified file 'storage/myisam/mi_dynrec.c'
--- a/storage/myisam/mi_dynrec.c	2008-07-23 12:46:33 +0000
+++ b/storage/myisam/mi_dynrec.c	2008-10-10 20:34:55 +0000
@@ -140,7 +140,7 @@ size_t mi_mmap_pread(MI_INFO *info, ucha
 {
   DBUG_PRINT("info", ("mi_read with mmap %d\n", info->dfile));
   if (info->s->concurrent_insert)
-    rw_rdlock(&info->s->mmap_lock);
+    MYSQL_RWLOCK_RDLOCK(&info->s->mmap_lock);
 
   /*
     The following test may fail in the following cases:
@@ -153,13 +153,13 @@ size_t mi_mmap_pread(MI_INFO *info, ucha
   {
     memcpy(Buffer, info->s->file_map + offset, Count);
     if (info->s->concurrent_insert)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return 0;
   }
   else
   {
     if (info->s->concurrent_insert)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
     return my_pread(info->dfile, Buffer, Count, offset, MyFlags);
   }
 }
@@ -197,7 +197,7 @@ size_t mi_mmap_pwrite(MI_INFO *info, con
   uint ret;
   DBUG_PRINT("info", ("mi_write with mmap %d\n", info->dfile));
   if (share->concurrent_insert)
-    rw_rdlock(&share->mmap_lock);
+    MYSQL_RWLOCK_RDLOCK(&share->mmap_lock);
 
   /*
     The following test may fail in the following cases:
@@ -210,14 +210,14 @@ size_t mi_mmap_pwrite(MI_INFO *info, con
   {
     memcpy(share->file_map + offset, Buffer, Count);
     if (share->concurrent_insert)
-      rw_unlock(&share->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&share->mmap_lock);
     ret= 0;
   }
   else
   {
     share->nonmmaped_inserts++;
     if (share->concurrent_insert)
-      rw_unlock(&share->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&share->mmap_lock);
     ret= my_pwrite(info->dfile, Buffer, Count, offset, MyFlags);
   }
   if (unlikely(mi_get_physical_logging_state(share)))

=== modified file 'storage/myisam/mi_extra.c'
--- a/storage/myisam/mi_extra.c	2008-07-09 07:12:43 +0000
+++ b/storage/myisam/mi_extra.c	2008-10-10 20:34:55 +0000
@@ -76,17 +76,17 @@ int mi_extra(MI_INFO *info, enum ha_extr
 #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
     if ((share->options & HA_OPTION_COMPRESS_RECORD))
     {
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       if (_mi_memmap_file(info))
       {
 	/* We don't nead MADV_SEQUENTIAL if small file */
 	madvise((char*) share->file_map, share->state.state.data_file_length,
 		share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
 		MADV_RANDOM : MADV_SEQUENTIAL);
-	pthread_mutex_unlock(&share->intern_lock);
+	MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 	break;
       }
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     }
 #endif
     if (info->opt_flag & WRITE_CACHE_USED)
@@ -267,17 +267,17 @@ int mi_extra(MI_INFO *info, enum ha_extr
     }
     break;
   case HA_EXTRA_FORCE_REOPEN:
-    pthread_mutex_lock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
     share->last_version= 0L;			/* Impossible version */
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     break;
   case HA_EXTRA_PREPARE_FOR_RENAME:
   case HA_EXTRA_PREPARE_FOR_DROP:
-    pthread_mutex_lock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
     share->last_version= 0L;			/* Impossible version */
 #ifdef __WIN__REMOVE_OBSOLETE_WORKAROUND
     /* Close the isam and data files as Win32 can't drop an open table */
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     if (flush_key_blocks(share->key_cache, share->kfile,
 			 (function == HA_EXTRA_PREPARE_FOR_DROP ?
                           FLUSH_IGNORE_CHANGED : FLUSH_RELEASE)))
@@ -319,9 +319,9 @@ int mi_extra(MI_INFO *info, enum ha_extr
       }
     }
     share->kfile= -1;				/* Files aren't open anymore */
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 #endif
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     break;
   case HA_EXTRA_FLUSH:
     if (!share->temporary)
@@ -365,7 +365,7 @@ int mi_extra(MI_INFO *info, enum ha_extr
     break;
   case HA_EXTRA_MMAP:
 #ifdef HAVE_MMAP
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     /*
       Memory map the data file if it is not already mapped. It is safe
       to memory map a file while other threads are using file I/O on it.
@@ -386,13 +386,13 @@ int mi_extra(MI_INFO *info, enum ha_extr
         share->file_write= mi_mmap_pwrite;
       }
     }
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 #endif
     break;
   case HA_EXTRA_MARK_AS_LOG_TABLE:
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     share->is_log_table= TRUE;
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     break;
   case HA_EXTRA_KEY_CACHE:
   case HA_EXTRA_NO_KEY_CACHE:
@@ -463,7 +463,7 @@ int mi_reset(MI_INFO *info)
     if (!share->temporary && (info->opt_flag & WRITE_CACHE_USED) &&
         (info->lock.type <= TL_READ_NO_INSERT))
     {
-      safe_mutex_assert_owner(&share->intern_lock);
+      MYSQL_MUTEX_ASSERT_OWNER(&share->intern_lock);
     }
     info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
     error= end_io_cache(&info->rec_cache);

=== modified file 'storage/myisam/mi_info.c'
--- a/storage/myisam/mi_info.c	2008-04-09 00:56:49 +0000
+++ b/storage/myisam/mi_info.c	2008-10-10 20:34:55 +0000
@@ -42,10 +42,10 @@ int mi_status(MI_INFO *info, register MI
     DBUG_RETURN(0);				/* Compatible with ISAM */
   if (!(flag & HA_STATUS_NO_LOCK))
   {
-    pthread_mutex_lock(&share->intern_lock);
+    MYSQL_MUTEX_LOCK(&share->intern_lock);
     (void) _mi_readinfo(info,F_RDLCK,0);
     fast_mi_writeinfo(info);
-    pthread_mutex_unlock(&share->intern_lock);
+    MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   }
   if (flag & HA_STATUS_VARIABLE)
   {

=== modified file 'storage/myisam/mi_keycache.c'
--- a/storage/myisam/mi_keycache.c	2008-04-08 01:47:13 +0000
+++ b/storage/myisam/mi_keycache.c	2008-10-10 20:34:55 +0000
@@ -96,7 +96,7 @@ int mi_assign_to_key_cache(MI_INFO *info
     ensure that setting the key cache and changing the multi_key_cache
     is done atomicly
   */
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   /*
     Tell all threads to use the new key cache
     This should be seen at the lastes for the next call to an myisam function.
@@ -108,7 +108,7 @@ int mi_assign_to_key_cache(MI_INFO *info
                           share->unique_name_length,
 			  share->key_cache))
     error= my_errno;
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   DBUG_RETURN(error);
 }
 
@@ -143,7 +143,7 @@ void mi_change_key_cache(KEY_CACHE *old_
   /*
     Lock list to ensure that no one can close the table while we manipulate it
   */
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   for (pos=myisam_open_list ; pos ; pos=pos->next)
   {
     MI_INFO *info= (MI_INFO*) pos->data;
@@ -158,6 +158,6 @@ void mi_change_key_cache(KEY_CACHE *old_
     open a new table that will be associted with the old key cache
   */
   multi_key_cache_change(old_key_cache, new_key_cache);
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   DBUG_VOID_RETURN;
 }

=== modified file 'storage/myisam/mi_locking.c'
--- a/storage/myisam/mi_locking.c	2008-07-23 12:46:33 +0000
+++ b/storage/myisam/mi_locking.c	2008-10-10 20:34:55 +0000
@@ -52,7 +52,7 @@ int mi_lock_database(MI_INFO *info, int 
   }
 
   flag=error=0;
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   if (share->kfile >= 0)		/* May only be false on windows */
   {
     switch (lock_type) {
@@ -242,7 +242,7 @@ int mi_lock_database(MI_INFO *info, int 
     }
   }
 #endif
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
   if (my_b_inited(&myisam_logical_log))
   {
     uchar lock_type_buff[4];
@@ -618,11 +618,11 @@ int mi_remap_file_and_write_state_for_un
       (info->s->nonmmaped_inserts > MAX_NONMAPPED_INSERTS))
   {
     if (info->s->concurrent_insert)
-      rw_wrlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_WRLOCK(&info->s->mmap_lock);
     mi_remap_file(info, info->s->state.state.data_file_length);
     info->s->nonmmaped_inserts= 0;
     if (info->s->concurrent_insert)
-      rw_unlock(&info->s->mmap_lock);
+      MYSQL_RWLOCK_UNLOCK(&info->s->mmap_lock);
   }
 #endif
   share->state.process= share->last_process=share->this_process;

=== modified file 'storage/myisam/mi_log.c'
--- a/storage/myisam/mi_log.c	2008-07-09 07:12:43 +0000
+++ b/storage/myisam/mi_log.c	2008-10-10 20:34:55 +0000
@@ -194,7 +194,7 @@ static int mi_log_open_cache(enum enum_m
   DBUG_ENTER("mi_log_open_cache");
 
   DBUG_ASSERT(log_filename != NULL);
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   if (type == MI_LOG_LOGICAL)
   {
     log= &myisam_logical_log;
@@ -235,7 +235,7 @@ static int mi_log_open_cache(enum enum_m
       my_close(file, MYF(MY_WME));
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   DBUG_RETURN(error);
 }
 
@@ -255,7 +255,7 @@ static int mi_log_close_cache(enum enum_
   int error= 0;
   IO_CACHE *log;
   DBUG_ENTER("mi_log_close_cache");
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   if (type == MI_LOG_LOGICAL)
     log         = &myisam_logical_log;
   else
@@ -270,7 +270,7 @@ static int mi_log_close_cache(enum enum_
       error= my_errno;
     log->file= -1;
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   DBUG_RETURN(error);
 }
 
@@ -349,7 +349,7 @@ retry:
     - mi_close() flushes indexes while holding THR_LOCK_myisam, and that flush
     can cause log writes, so we would lock the mutex twice.
   */
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   /*
     We need to check that 'log' is not closed, this can happen for a physical
     log. Indeed we do not have full control on the table from the thread doing
@@ -386,7 +386,7 @@ retry:
       else if (unlikely(!share->MI_LOG_OPEN_stored_in_physical_log))
       {
         DBUG_ASSERT(command != MI_LOG_CLOSE);
-        pthread_mutex_unlock(&THR_LOCK_myisam_log);
+        MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
         _myisam_log_command(&myisam_physical_log, MI_LOG_OPEN, share,
                             (uchar *)share->unresolv_file_name,
                             strlen(share->unresolv_file_name), 0);
@@ -420,7 +420,7 @@ retry:
         error=my_lock(log->file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   my_errno=old_errno;
 }
 
@@ -475,7 +475,7 @@ void _myisam_log_record_logical(enum myi
     headerlen= 15;
   }
 
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   error= my_lock(myisam_logical_log.file, F_WRLCK, 0L, F_TO_EOF,
                  MYF(MY_SEEK_NOT_DONE));
   (void) my_b_write(&myisam_logical_log, header, headerlen);
@@ -497,7 +497,7 @@ void _myisam_log_record_logical(enum myi
   if (!error)
     error= my_lock(myisam_logical_log.file, F_UNLCK, 0L, F_TO_EOF,
                    MYF(MY_SEEK_NOT_DONE));
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   my_errno=old_errno;
 }
 
@@ -553,12 +553,12 @@ void myisam_log_pwrite_physical(enum myi
   }
   /* pid and result are not needed */
 retry:
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   if (likely(my_b_inited(&myisam_physical_log) != NULL))
   {
     if (unlikely(!share->MI_LOG_OPEN_stored_in_physical_log))
     {
-      pthread_mutex_unlock(&THR_LOCK_myisam_log);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
       _myisam_log_command(&myisam_physical_log, MI_LOG_OPEN, share,
                           (uchar *)share->unresolv_file_name,
                           strlen(share->unresolv_file_name), 0);
@@ -567,7 +567,7 @@ retry:
     (void) my_b_write(&myisam_physical_log, header, headerlen);
     (void) my_b_write(&myisam_physical_log, buffert, length);
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   my_errno= old_errno;
   DBUG_VOID_RETURN;
 }
@@ -606,12 +606,12 @@ void myisam_log_chsize_kfile_physical(MY
   }
   /* pid and result are not needed */
 retry:
-  pthread_mutex_lock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam_log);
   if (likely(my_b_inited(&myisam_physical_log) != NULL))
   {
     if (unlikely(!share->MI_LOG_OPEN_stored_in_physical_log))
     {
-      pthread_mutex_unlock(&THR_LOCK_myisam_log);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
       _myisam_log_command(&myisam_physical_log, MI_LOG_OPEN, share,
                           (uchar *)share->unresolv_file_name,
                           strlen(share->unresolv_file_name), 0);
@@ -619,7 +619,7 @@ retry:
     }
     (void) my_b_write(&myisam_physical_log, header, headerlen);
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam_log);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam_log);
   my_errno= old_errno;
   DBUG_VOID_RETURN;
 }
@@ -669,10 +669,10 @@ static int mi_log_start_physical(const c
   DBUG_ASSERT(log_filename != NULL);
   DBUG_ASSERT(hash_inited(tables));
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   if (mi_log_tables_physical) /* physical logging already running */
   {
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     DBUG_ASSERT(0); /* because it should not happen */
     DBUG_RETURN(1);
   }
@@ -712,7 +712,7 @@ static int mi_log_start_physical(const c
   }
   error= 0;
 end:
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   if (unlikely(error))
     mi_log_stop_physical(MI_LOG_ACTION_CLOSE_INCONSISTENT, MI_LOG_PHYSICAL,
                          NULL, NULL);
@@ -754,10 +754,10 @@ static int mi_log_stop_physical(enum enu
   DBUG_ASSERT(action == MI_LOG_ACTION_CLOSE_CONSISTENT ||
               action == MI_LOG_ACTION_CLOSE_INCONSISTENT);
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   if (mi_log_tables_physical == NULL) /* no physical logging running */
   {
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     DBUG_RETURN(0); /* it's ok if it happens */
   }
   /*
@@ -788,7 +788,7 @@ static int mi_log_stop_physical(enum enu
         Must take intern_lock, at least because key cache isn't safe if two
         calls to flush_key_blocks_int() run concurrently on the same file.
       */
-      pthread_mutex_lock(&share->intern_lock);
+      MYSQL_MUTEX_LOCK(&share->intern_lock);
       /*
         It is possible that some statement just finished, has not called
         mi_lock_database(F_UNLCK) yet, and so some key blocks would still be
@@ -830,7 +830,7 @@ static int mi_log_stop_physical(enum enu
         mi_print_error(share, HA_ERR_CRASHED);
         mi_mark_crashed(info);		/* Mark that table must be checked */
       }
-      pthread_mutex_unlock(&share->intern_lock);
+      MYSQL_MUTEX_UNLOCK(&share->intern_lock);
     } /* ... for (list_item=...) */
   } /* ... if (action == MI_LOG_ACTION_CLOSE_CONSISTENT) */
 
@@ -868,7 +868,7 @@ static int mi_log_stop_physical(enum enu
     share->MI_LOG_OPEN_stored_in_physical_log= FALSE;
   }
 
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   /*
     From this moment on, from the point of view of MyISAM, a new physical log
     (a new backup) can start (new log will use a different tmp name).

=== modified file 'storage/myisam/mi_open.c'
--- a/storage/myisam/mi_open.c	2008-08-25 14:26:49 +0000
+++ b/storage/myisam/mi_open.c	2008-10-10 20:34:55 +0000
@@ -112,7 +112,7 @@ MI_INFO *mi_open(const char *name, int m
     DBUG_RETURN (NULL);
   }
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   if (!(old_info=test_if_reopen(name_buff)))
   {
     share= &share_buff;
@@ -345,9 +345,9 @@ MI_INFO *mi_open(const char *name, int m
 			 &share->state.key_del,
 			 (share->state.header.max_block_size_index*sizeof(my_off_t)),
 #ifdef THREAD
-			 &share->key_root_lock,sizeof(rw_lock_t)*keys,
+			 &share->key_root_lock,sizeof(mysql_rwlock_t)*keys,
 #endif
-			 &share->mmap_lock,sizeof(rw_lock_t),
+			 &share->mmap_lock,sizeof(mysql_rwlock_t),
 			 NullS))
       goto err;
     errpos=4;
@@ -651,7 +651,7 @@ MI_INFO *mi_open(const char *name, int m
   info.ft1_to_ft2=0;
   info.errkey= -1;
   info.page_changed=1;
-  pthread_mutex_lock(&share->intern_lock);
+  MYSQL_MUTEX_LOCK(&share->intern_lock);
   info.read_record=share->read_record;
   share->reopen++;
   share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
@@ -682,7 +682,7 @@ MI_INFO *mi_open(const char *name, int m
     mi_state_info_write(share, share->kfile, &share->state, 1);
   }
 
-  pthread_mutex_unlock(&share->intern_lock);
+  MYSQL_MUTEX_UNLOCK(&share->intern_lock);
 
   /* Allocate buffer for one record */
 
@@ -702,7 +702,7 @@ MI_INFO *mi_open(const char *name, int m
   m_info->open_list.data=(void*) m_info;
   myisam_open_list=list_add(myisam_open_list,&m_info->open_list);
 
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   if (my_b_inited(&myisam_logical_log))
   {
     intern_filename(name_buff,share->index_file_name);
@@ -743,7 +743,7 @@ err:
   default:
     break;
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   my_errno=save_errno;
   DBUG_RETURN (NULL);
 } /* mi_open */

=== modified file 'storage/myisam/mi_panic.c'
--- a/storage/myisam/mi_panic.c	2008-07-01 20:32:27 +0000
+++ b/storage/myisam/mi_panic.c	2008-10-10 20:34:55 +0000
@@ -30,17 +30,17 @@ int mi_panic(enum ha_panic_function flag
   MI_INFO *info;
   DBUG_ENTER("mi_panic");
 
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   for (list_element=myisam_open_list ; list_element ; list_element=next_open)
   {
     next_open=list_element->next;		/* Save if close */
     info=(MI_INFO*) list_element->data;
     switch (flag) {
     case HA_PANIC_CLOSE:
-      pthread_mutex_unlock(&THR_LOCK_myisam);	/* Not exactly right... */
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);	/* Not exactly right... */
       if (mi_close(info))
 	error=my_errno;
-      pthread_mutex_lock(&THR_LOCK_myisam);
+      MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
       break;
     case HA_PANIC_WRITE:		/* Do this to free databases */
 #ifdef CANT_OPEN_FILES_TWICE
@@ -110,7 +110,7 @@ int mi_panic(enum ha_panic_function flag
     mi_log(MI_LOG_ACTION_CLOSE_INCONSISTENT, MI_LOG_LOGICAL, NULL, NULL);
     ft_free_stopwords();
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   if (!error)
     DBUG_RETURN(0);
   DBUG_RETURN(my_errno=error);

=== modified file 'storage/myisam/mi_range.c'
--- a/storage/myisam/mi_range.c	2008-06-26 05:18:28 +0000
+++ b/storage/myisam/mi_range.c	2008-10-10 20:34:55 +0000
@@ -57,7 +57,7 @@ ha_rows mi_records_in_range(MI_INFO *inf
     DBUG_RETURN(HA_POS_ERROR);
   info->update&= (HA_STATE_CHANGED+HA_STATE_ROW_CHANGED);
   if (info->s->concurrent_insert)
-    rw_rdlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_RDLOCK(&info->s->key_root_lock[inx]);
 
   switch(info->s->keyinfo[inx].key_alg){
 #ifdef HAVE_RTREE_KEYS
@@ -106,7 +106,7 @@ ha_rows mi_records_in_range(MI_INFO *inf
   }
 
   if (info->s->concurrent_insert)
-    rw_unlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_UNLOCK(&info->s->key_root_lock[inx]);
   fast_mi_writeinfo(info);
 
   DBUG_PRINT("info",("records: %ld",(ulong) (res)));

=== modified file 'storage/myisam/mi_rkey.c'
--- a/storage/myisam/mi_rkey.c	2008-05-29 15:44:11 +0000
+++ b/storage/myisam/mi_rkey.c	2008-10-10 20:34:55 +0000
@@ -73,7 +73,7 @@ int mi_rkey(MI_INFO *info, uchar *buf, i
     goto err;
 
   if (share->concurrent_insert)
-    rw_rdlock(&share->key_root_lock[inx]);
+    MYSQL_RWLOCK_RDLOCK(&share->key_root_lock[inx]);
 
   nextflag=myisam_read_vec[search_flag];
   use_key_length=pack_key_length;
@@ -88,7 +88,7 @@ int mi_rkey(MI_INFO *info, uchar *buf, i
       mi_print_error(info->s, HA_ERR_CRASHED);
       my_errno=HA_ERR_CRASHED;
       if (share->concurrent_insert)
-        rw_unlock(&share->key_root_lock[inx]);
+        MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[inx]);
       goto err;
     }
     break;
@@ -152,7 +152,7 @@ int mi_rkey(MI_INFO *info, uchar *buf, i
       {
         info->lastpos= HA_OFFSET_ERROR;
         if (share->concurrent_insert)
-          rw_unlock(&share->key_root_lock[inx]);
+          MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[inx]);
         DBUG_RETURN((my_errno= HA_ERR_KEY_NOT_FOUND));
       }
       /*
@@ -168,7 +168,7 @@ int mi_rkey(MI_INFO *info, uchar *buf, i
     }
   }
   if (share->concurrent_insert)
-    rw_unlock(&share->key_root_lock[inx]);
+    MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[inx]);
 
   /* Calculate length of the found key;  Used by mi_rnext_same */
   if ((keyinfo->flag & HA_VAR_LENGTH_KEY) && last_used_keyseg &&

=== modified file 'storage/myisam/mi_rnext.c'
--- a/storage/myisam/mi_rnext.c	2007-06-27 17:48:00 +0000
+++ b/storage/myisam/mi_rnext.c	2008-10-10 20:34:55 +0000
@@ -40,7 +40,7 @@ int mi_rnext(MI_INFO *info, uchar *buf, 
   if (fast_mi_readinfo(info))
     DBUG_RETURN(my_errno);
   if (info->s->concurrent_insert)
-    rw_rdlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_RDLOCK(&info->s->key_root_lock[inx]);
   changed=_mi_test_if_changed(info);
   if (!flag)
   {
@@ -100,14 +100,14 @@ int mi_rnext(MI_INFO *info, uchar *buf, 
     if (!error && res == 2)
     {
       if (info->s->concurrent_insert)
-        rw_unlock(&info->s->key_root_lock[inx]);
+        MYSQL_RWLOCK_UNLOCK(&info->s->key_root_lock[inx]);
       info->lastpos= HA_OFFSET_ERROR;
       DBUG_RETURN(my_errno= HA_ERR_END_OF_FILE);
     }
   }
   
   if (info->s->concurrent_insert)
-    rw_unlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_UNLOCK(&info->s->key_root_lock[inx]);
 
 	/* Don't clear if database-changed */
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);

=== modified file 'storage/myisam/mi_rnext_same.c'
--- a/storage/myisam/mi_rnext_same.c	2007-06-27 17:48:00 +0000
+++ b/storage/myisam/mi_rnext_same.c	2008-10-10 20:34:55 +0000
@@ -38,7 +38,7 @@ int mi_rnext_same(MI_INFO *info, uchar *
     DBUG_RETURN(my_errno);
 
   if (info->s->concurrent_insert)
-    rw_rdlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_RDLOCK(&info->s->key_root_lock[inx]);
 
   switch (keyinfo->key_alg)
   {
@@ -82,7 +82,7 @@ int mi_rnext_same(MI_INFO *info, uchar *
       }
   }
   if (info->s->concurrent_insert)
-    rw_unlock(&info->s->key_root_lock[inx]);
+    MYSQL_RWLOCK_UNLOCK(&info->s->key_root_lock[inx]);
 	/* Don't clear if database-changed */
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
   info->update|= HA_STATE_NEXT_FOUND | HA_STATE_RNEXT_SAME;

=== modified file 'storage/myisam/mi_rprev.c'
--- a/storage/myisam/mi_rprev.c	2007-05-10 09:59:39 +0000
+++ b/storage/myisam/mi_rprev.c	2008-10-10 20:34:55 +0000
@@ -39,7 +39,7 @@ int mi_rprev(MI_INFO *info, uchar *buf, 
     DBUG_RETURN(my_errno);
   changed=_mi_test_if_changed(info);
   if (share->concurrent_insert)
-    rw_rdlock(&share->key_root_lock[inx]);
+    MYSQL_RWLOCK_RDLOCK(&share->key_root_lock[inx]);
   if (!flag)
     error=_mi_search_last(info, share->keyinfo+inx,
 			  share->state.key_root[inx]);
@@ -65,7 +65,7 @@ int mi_rprev(MI_INFO *info, uchar *buf, 
 	  break;
       }
     }
-    rw_unlock(&share->key_root_lock[inx]);
+    MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[inx]);
   }
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
   info->update|= HA_STATE_PREV_FOUND;

=== modified file 'storage/myisam/mi_rsame.c'
--- a/storage/myisam/mi_rsame.c	2008-04-09 00:56:49 +0000
+++ b/storage/myisam/mi_rsame.c	2008-10-10 20:34:55 +0000
@@ -49,12 +49,12 @@ int mi_rsame(MI_INFO *info, uchar *recor
     info->lastkey_length=_mi_make_key(info,(uint) inx,info->lastkey,record,
 				      info->lastpos);
     if (info->s->concurrent_insert)
-      rw_rdlock(&info->s->key_root_lock[inx]);
+      MYSQL_RWLOCK_RDLOCK(&info->s->key_root_lock[inx]);
     (void) _mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,
 		    SEARCH_SAME,
 		    info->s->state.key_root[inx]);
     if (info->s->concurrent_insert)
-      rw_unlock(&info->s->key_root_lock[inx]);
+      MYSQL_RWLOCK_UNLOCK(&info->s->key_root_lock[inx]);
   }
 
   if (!(*info->read_record)(info,info->lastpos,record))

=== modified file 'storage/myisam/mi_write.c'
--- a/storage/myisam/mi_write.c	2008-07-09 07:12:43 +0000
+++ b/storage/myisam/mi_write.c	2008-10-10 20:34:55 +0000
@@ -107,7 +107,7 @@ int mi_write(MI_INFO *info, uchar *recor
                                   is_tree_inited(&info->bulk_insert[i])));
       if (local_lock_tree)
       {
-	rw_wrlock(&share->key_root_lock[i]);
+	MYSQL_RWLOCK_WRLOCK(&share->key_root_lock[i]);
 	share->keyinfo[i].version++;
       }
       if (share->keyinfo[i].flag & HA_FULLTEXT )
@@ -115,7 +115,7 @@ int mi_write(MI_INFO *info, uchar *recor
         if (_mi_ft_add(info,i, buff, record, filepos))
         {
 	  if (local_lock_tree)
-	    rw_unlock(&share->key_root_lock[i]);
+	    MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
           DBUG_PRINT("error",("Got error: %d on write",my_errno));
           goto err;
         }
@@ -126,7 +126,7 @@ int mi_write(MI_INFO *info, uchar *recor
 			_mi_make_key(info,i,buff,record,filepos)))
         {
           if (local_lock_tree)
-            rw_unlock(&share->key_root_lock[i]);
+            MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
           DBUG_PRINT("error",("Got error: %d on write",my_errno));
           goto err;
         }
@@ -136,7 +136,7 @@ int mi_write(MI_INFO *info, uchar *recor
       info->update&= ~HA_STATE_RNEXT_SAME;
 
       if (local_lock_tree)
-        rw_unlock(&share->key_root_lock[i]);
+        MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
     }
   }
   if (share->calc_checksum)
@@ -198,13 +198,13 @@ err:
                                   !(info->bulk_insert &&
                                     is_tree_inited(&info->bulk_insert[i])));
 	if (local_lock_tree)
-	  rw_wrlock(&share->key_root_lock[i]);
+	  MYSQL_RWLOCK_WRLOCK(&share->key_root_lock[i]);
 	if (share->keyinfo[i].flag & HA_FULLTEXT)
         {
           if (_mi_ft_del(info,i, buff,record,filepos))
 	  {
 	    if (local_lock_tree)
-	      rw_unlock(&share->key_root_lock[i]);
+	      MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
             break;
 	  }
         }
@@ -214,12 +214,12 @@ err:
 	  if (_mi_ck_delete(info,i,buff,key_length))
 	  {
 	    if (local_lock_tree)
-	      rw_unlock(&share->key_root_lock[i]);
+	      MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
 	    break;
 	  }
 	}
 	if (local_lock_tree)
-	  rw_unlock(&share->key_root_lock[i]);
+	  MYSQL_RWLOCK_UNLOCK(&share->key_root_lock[i]);
       }
     }
   }
@@ -935,7 +935,7 @@ static int keys_free(uchar *key, TREE_FR
   case free_init:
     if (param->info->s->concurrent_insert)
     {
-      rw_wrlock(&param->info->s->key_root_lock[param->keynr]);
+      MYSQL_RWLOCK_WRLOCK(&param->info->s->key_root_lock[param->keynr]);
       param->info->s->keyinfo[param->keynr].version++;
     }
     return 0;
@@ -947,7 +947,7 @@ static int keys_free(uchar *key, TREE_FR
 			      keylen - param->info->s->rec_reflength);
   case free_end:
     if (param->info->s->concurrent_insert)
-      rw_unlock(&param->info->s->key_root_lock[param->keynr]);
+      MYSQL_RWLOCK_UNLOCK(&param->info->s->key_root_lock[param->keynr]);
     return 0;
   }
   return -1;

=== modified file 'storage/myisam/myisam_backup_engine.cc'
--- a/storage/myisam/myisam_backup_engine.cc	2008-08-11 16:06:30 +0000
+++ b/storage/myisam/myisam_backup_engine.cc	2008-10-10 20:34:55 +0000
@@ -193,6 +193,9 @@ class Engine: public Backup_engine
 
 class Object_backup;
 
+#ifdef HAVE_PSI_INTERFACE
+PSI_cond_key key_COND_lock_state;
+#endif
 
 /**
   Handles backup orders received from the backup kernel (implements the API).
@@ -249,7 +252,7 @@ private:
   */
   THD *lock_thd;
   bool cannot_delete_lock_thd;
-  pthread_cond_t COND_lock_state; ///< for communication with locking thread
+  mysql_cond_t COND_lock_state; ///< for communication with locking thread
   void kill_locking_thread();
   static const size_t bytes_between_sleeps= 10*1024*1024;
   /** After copying bytes_between_sleeps we sleep sleep_time */
@@ -377,7 +380,7 @@ Backup::Backup(const Table_list &tables)
     Driver is not ready at this point, so state is ERROR.
     This constructor cannot fail, otherwise begin() would have to detect it.
   */
-  pthread_cond_init(&COND_lock_state, NULL);
+  MYSQL_COND_INIT(&COND_lock_state, key_COND_lock_state, NULL);
 }
 
 
@@ -392,7 +395,7 @@ void Backup::kill_locking_thread()
     (LOCK_ERROR).
   */
 retry:
-  pthread_mutex_lock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
   /* If thread started and not already dead, kill it */
   if ((lock_state != LOCK_NOT_STARTED) & (lock_state != LOCK_ERROR))
   {
@@ -402,7 +405,7 @@ retry:
     */
     if (unlikely(lock_thd == NULL))
     {
-      pthread_mutex_unlock(&THR_LOCK_myisam);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
       DBUG_PRINT("info",("lock_thd not yet set"));
       sleep(1);
       goto retry;
@@ -423,25 +426,25 @@ retry:
       So So we set a flag:
     */
     cannot_delete_lock_thd= TRUE;
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     /*
       So now lock_thd cannot be destroyed.
       We kill the thread (which will in particular work if it is waiting for
       some table locks).
     */
-    pthread_mutex_lock(&lock_thd->LOCK_delete);
+    MYSQL_MUTEX_LOCK(&lock_thd->LOCK_delete);
     lock_thd->awake(THD::KILL_CONNECTION);
-    pthread_mutex_unlock(&lock_thd->LOCK_delete);
+    MYSQL_MUTEX_UNLOCK(&lock_thd->LOCK_delete);
     /* won't look at lock_thd anymore, allow its deletion */
-    pthread_mutex_lock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
     cannot_delete_lock_thd= FALSE;
     /* we wake up thread if it was blocked on the bool above */
-    pthread_cond_broadcast(&COND_lock_state);
+    MYSQL_COND_BROADCAST(&COND_lock_state);
     /* And we wait for the thread to inform of its death */
     while (lock_state != LOCK_ERROR)
-      pthread_cond_wait(&COND_lock_state, &THR_LOCK_myisam);
+      MYSQL_COND_WAIT(&COND_lock_state, &THR_LOCK_myisam);
   }
-  pthread_mutex_unlock(&THR_LOCK_myisam);
+  MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
   DBUG_VOID_RETURN;
 }
 
@@ -467,7 +470,7 @@ Backup::~Backup()
     hash_of_tables= NULL;
   }
   kill_locking_thread();
-  pthread_cond_destroy(&COND_lock_state);
+  MYSQL_COND_DESTROY(&COND_lock_state);
   DBUG_VOID_RETURN;
 }
 
@@ -718,20 +721,20 @@ result_t Backup::get_data(Buffer &buf)
     if (lock_state == LOCK_NOT_STARTED)
       DBUG_RETURN(backup::OK);
     /* Let's see if the locking thread has finished locking all tables */
-    pthread_mutex_lock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_LOCK(&THR_LOCK_myisam);
     if (lock_state == LOCK_STARTED) // not yet
     {
-      pthread_mutex_unlock(&THR_LOCK_myisam);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
       DBUG_RETURN(backup::OK);
     }
     if (lock_state !=  LOCK_ACQUIRED) // it failed, so do we
     {
-      pthread_mutex_unlock(&THR_LOCK_myisam);
+      MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
       SET_STATE_TO_ERROR_AND_DBUG_RETURN;
     }
     DBUG_PRINT("info",("locking thread acquired locks on tables"));
 
-    pthread_mutex_unlock(&THR_LOCK_myisam);
+    MYSQL_MUTEX_UNLOCK(&THR_LOCK_myisam);
     if (mi_log(MI_LOG_ACTION_CLOSE_CONSISTENT, MI_LOG_PHYSICAL, NULL, NULL))
       SET_STATE_TO_ERROR_AND_DBUG_RETURN;
     state= DUMPING_LOG_FILE_AFTER_TABLES_ARE_LOCKED;
@@ -788,9 +791,9 @@ void Backup::lock_tables_TL_READ_NO_INSE
   if (unlikely(!thd))
     goto end2;
   thd->thread_stack = reinterpret_cast< char *>(&thd);
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   thd->thread_id= thread_id++;
-  pthread_mutex_unlock(&LOCK_thread_count);
+  MYSQL_MUTEX_UNLOCK(&LOCK_thread_count);
   if (unlikely(thd->store_globals())) // for a proper MEM_ROOT
     goto end2;
   thd->init_for_queries(); // opening tables needs a proper LEX
@@ -808,9 +811,9 @@ void Backup::lock_tables_TL_READ_NO_INSE
     Making this thread visible to SHOW PROCESSLIST is useful for
     troubleshooting a backup job (why does it stall etc).
   */
-  pthread_mutex_lock(&LOCK_thread_count);
+  MYSQL_MUTEX_LOCK(&LOCK_thread_count);
   threads.append(thd);
-  pthread_mutex_unlock(&LOCK_t