use PSI wrappers in aria and other non-MySQL code

include/maria.h

@@ -174,7 +174,7 @@ typedef struct st_maria_key                 /* Internal info about a key */
 typedef struct st_maria_keydef          /* Key definition with open & info */
 {
   struct st_maria_share *share;         /* Pointer to base (set in open) */
-  rw_lock_t root_lock;                  /* locking of tree */
+  mysql_rwlock_t root_lock;                  /* locking of tree */
   uint16 keysegs;                       /* Number of key-segment */
   uint16 flag;                          /* NOSAME, PACK_USED */
 
@@ -355,8 +355,8 @@ typedef struct st_maria_bit_buff
 typedef struct st_maria_sort_info
 {
   /* sync things */
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
-  pthread_cond_t cond;
+  mysql_cond_t cond;
   MARIA_HA *info, *new_info;
   HA_CHECK *param;
   char *buff;

include/waiting_threads.h

@@ -120,7 +120,7 @@ void wt_end(void);
 void wt_thd_lazy_init(WT_THD *, const ulong *, const ulong *, const ulong *, const ulong *);
 void wt_thd_destroy(WT_THD *);
 int wt_thd_will_wait_for(WT_THD *, WT_THD *, const WT_RESOURCE_ID *);
-int wt_thd_cond_timedwait(WT_THD *, pthread_mutex_t *);
+int wt_thd_cond_timedwait(WT_THD *, mysql_mutex_t *);
 void wt_thd_release(WT_THD *, const WT_RESOURCE_ID *);
 #define wt_thd_release_all(THD) wt_thd_release((THD), 0)
 my_bool wt_resource_id_memcmp(const void *, const void *);

mysql-test/include/default_mysqld.cnf

@@ -32,6 +32,7 @@ max_heap_table_size=        1M
 
 loose-skip-innodb
 loose-skip-pbxt
+loose-skip-federated
 
 loose-innodb_data_file_path=      ibdata1:10M:autoextend
 loose-innodb_buffer_pool_size=    8M

mysql-test/suite/perfschema/r/all_instances.result

@@ -0,0 +1,149 @@
+use performance_schema;
+select name from mutex_instances group by name;
+name
+wait/synch/mutex/archive/archive_mutex
+wait/synch/mutex/aria/LOCK_trn_list
+wait/synch/mutex/aria/PAGECACHE::cache_lock
+wait/synch/mutex/aria/SERVICE_THREAD_CONTROL::LOCK_control
+wait/synch/mutex/aria/THR_LOCK_maria
+wait/synch/mutex/aria/TRANSLOG_BUFFER::mutex
+wait/synch/mutex/aria/TRANSLOG_DESCRIPTOR::dirty_buffer_mask_lock
+wait/synch/mutex/aria/TRANSLOG_DESCRIPTOR::file_header_lock
+wait/synch/mutex/aria/TRANSLOG_DESCRIPTOR::log_flush_lock
+wait/synch/mutex/aria/TRANSLOG_DESCRIPTOR::purger_lock
+wait/synch/mutex/aria/TRANSLOG_DESCRIPTOR::unfinished_files_lock
+wait/synch/mutex/blackhole/blackhole
+wait/synch/mutex/csv/tina
+wait/synch/mutex/memory/HP_SHARE::intern_lock
+wait/synch/mutex/myisam/MYISAM_SHARE::intern_lock
+wait/synch/mutex/mysys/BITMAP::mutex
+wait/synch/mutex/mysys/KEY_CACHE::cache_lock
+wait/synch/mutex/mysys/LOCK_alarm
+wait/synch/mutex/mysys/LOCK_uuid_generator
+wait/synch/mutex/mysys/my_thread_var::mutex
+wait/synch/mutex/mysys/THR_LOCK::mutex
+wait/synch/mutex/mysys/THR_LOCK_charset
+wait/synch/mutex/mysys/THR_LOCK_heap
+wait/synch/mutex/mysys/THR_LOCK_isam
+wait/synch/mutex/mysys/THR_LOCK_malloc
+wait/synch/mutex/mysys/THR_LOCK_myisam
+wait/synch/mutex/mysys/THR_LOCK_net
+wait/synch/mutex/mysys/THR_LOCK_open
+wait/synch/mutex/mysys/THR_LOCK_threads
+wait/synch/mutex/mysys/TMPDIR_mutex
+wait/synch/mutex/sql/Cversion_lock
+wait/synch/mutex/sql/DEBUG_SYNC::mutex
+wait/synch/mutex/sql/Event_scheduler::LOCK_scheduler_state
+wait/synch/mutex/sql/hash_filo::lock
+wait/synch/mutex/sql/LOCK_active_mi
+wait/synch/mutex/sql/LOCK_audit_mask
+wait/synch/mutex/sql/LOCK_connection_count
+wait/synch/mutex/sql/LOCK_crypt
+wait/synch/mutex/sql/LOCK_delayed_create
+wait/synch/mutex/sql/LOCK_delayed_insert
+wait/synch/mutex/sql/LOCK_delayed_status
+wait/synch/mutex/sql/LOCK_des_key_file
+wait/synch/mutex/sql/LOCK_error_log
+wait/synch/mutex/sql/LOCK_error_messages
+wait/synch/mutex/sql/LOCK_event_queue
+wait/synch/mutex/sql/LOCK_gdl
+wait/synch/mutex/sql/LOCK_global_index_stats
+wait/synch/mutex/sql/LOCK_global_system_variables
+wait/synch/mutex/sql/LOCK_global_table_stats
+wait/synch/mutex/sql/LOCK_global_user_client_stats
+wait/synch/mutex/sql/LOCK_manager
+wait/synch/mutex/sql/LOCK_open
+wait/synch/mutex/sql/LOCK_plugin
+wait/synch/mutex/sql/LOCK_prepared_stmt_count
+wait/synch/mutex/sql/LOCK_rpl_status
+wait/synch/mutex/sql/LOCK_server_started
+wait/synch/mutex/sql/LOCK_slave_list
+wait/synch/mutex/sql/LOCK_stats
+wait/synch/mutex/sql/LOCK_status
+wait/synch/mutex/sql/LOCK_thread_count
+wait/synch/mutex/sql/LOCK_user_conn
+wait/synch/mutex/sql/LOCK_user_locks
+wait/synch/mutex/sql/LOCK_uuid_generator
+wait/synch/mutex/sql/LOCK_xid_cache
+wait/synch/mutex/sql/LOG::LOCK_log
+wait/synch/mutex/sql/LOG_INFO::lock
+wait/synch/mutex/sql/Master_info::data_lock
+wait/synch/mutex/sql/Master_info::run_lock
+wait/synch/mutex/sql/MDL_map::mutex
+wait/synch/mutex/sql/MDL_wait::LOCK_wait_status
+wait/synch/mutex/sql/MYSQL_BIN_LOG::LOCK_index
+wait/synch/mutex/sql/MYSQL_RELAY_LOG::LOCK_index
+wait/synch/mutex/sql/Query_cache::structure_guard_mutex
+wait/synch/mutex/sql/Relay_log_info::data_lock
+wait/synch/mutex/sql/Relay_log_info::log_space_lock
+wait/synch/mutex/sql/Relay_log_info::run_lock
+wait/synch/mutex/sql/Slave_reporting_capability::err_lock
+wait/synch/mutex/sql/TABLE_SHARE::LOCK_ha_data
+wait/synch/mutex/sql/THD::LOCK_thd_data
+wait/synch/mutex/sql/tz_LOCK
+select name from rwlock_instances group by name;
+name
+wait/synch/rwlock/aria/TRANSLOG_DESCRIPTOR::open_files_lock
+wait/synch/rwlock/myisam/MYISAM_SHARE::key_root_lock
+wait/synch/rwlock/myisam/MYISAM_SHARE::mmap_lock
+wait/synch/rwlock/mysys/SAFE_HASH::mutex
+wait/synch/rwlock/sql/LOCK_dboptions
+wait/synch/rwlock/sql/LOCK_grant
+wait/synch/rwlock/sql/LOCK_system_variables_hash
+wait/synch/rwlock/sql/LOCK_sys_init_connect
+wait/synch/rwlock/sql/LOCK_sys_init_slave
+wait/synch/rwlock/sql/LOGGER::LOCK_logger
+wait/synch/rwlock/sql/MDL_context::LOCK_waiting_for
+wait/synch/rwlock/sql/MDL_lock::rwlock
+wait/synch/rwlock/sql/THR_LOCK_servers
+wait/synch/rwlock/sql/THR_LOCK_udf
+select name from cond_instances group by name;
+name
+wait/synch/cond/aria/SERVICE_THREAD_CONTROL::COND_control
+wait/synch/cond/aria/TRANSLOG_BUFFER::prev_sent_to_disk_cond
+wait/synch/cond/aria/TRANSLOG_BUFFER::waiting_filling_buffer
+wait/synch/cond/aria/TRANSLOG_DESCRIPTOR::log_flush_cond
+wait/synch/cond/aria/TRANSLOG_DESCRIPTOR::new_goal_cond
+wait/synch/cond/mysys/COND_alarm
+wait/synch/cond/mysys/my_thread_var::suspend
+wait/synch/cond/mysys/THR_COND_threads
+wait/synch/cond/sql/COND_flush_thread_cache
+wait/synch/cond/sql/COND_manager
+wait/synch/cond/sql/COND_queue_state
+wait/synch/cond/sql/COND_rpl_status
+wait/synch/cond/sql/COND_server_started
+wait/synch/cond/sql/COND_thread_cache
+wait/synch/cond/sql/COND_thread_count
+wait/synch/cond/sql/DEBUG_SYNC::cond
+wait/synch/cond/sql/Event_scheduler::COND_state
+wait/synch/cond/sql/Master_info::data_cond
+wait/synch/cond/sql/Master_info::start_cond
+wait/synch/cond/sql/Master_info::stop_cond
+wait/synch/cond/sql/MDL_context::COND_wait_status
+wait/synch/cond/sql/MYSQL_BIN_LOG::update_cond
+wait/synch/cond/sql/MYSQL_RELAY_LOG::update_cond
+wait/synch/cond/sql/Query_cache::COND_cache_status_changed
+wait/synch/cond/sql/Relay_log_info::data_cond
+wait/synch/cond/sql/Relay_log_info::log_space_cond
+wait/synch/cond/sql/Relay_log_info::start_cond
+wait/synch/cond/sql/Relay_log_info::stop_cond
+select event_name from file_instances group by event_name;
+event_name
+wait/io/file/aria/control
+wait/io/file/aria/translog
+wait/io/file/myisam/dfile
+wait/io/file/myisam/kfile
+wait/io/file/mysys/charset
+wait/io/file/sql/casetest
+wait/io/file/sql/dbopt
+wait/io/file/sql/ERRMSG
+wait/io/file/sql/FRM
+wait/io/file/sql/pid
+wait/io/file/sql/query_log
+wait/io/file/sql/slow_log
+select name from threads group by name;
+name
+thread/aria/checkpoint_background
+thread/sql/main
+thread/sql/one_connection
+thread/sql/signal_handler

mysql-test/suite/perfschema/r/query_cache.result

@@ -38,7 +38,7 @@ spins
 NULL
 select name from performance_schema.setup_instruments order by name limit 1;
 name
-wait/io/file/csv/data
+wait/io/file/aria/control
 show status like "Qcache_queries_in_cache";
 Variable_name	Value
 Qcache_queries_in_cache	1
@@ -53,7 +53,7 @@ spins
 NULL
 select name from performance_schema.setup_instruments order by name limit 1;
 name
-wait/io/file/csv/data
+wait/io/file/aria/control
 show status like "Qcache_queries_in_cache";
 Variable_name	Value
 Qcache_queries_in_cache	1

mysql-test/suite/perfschema/t/all_instances-master.opt

@@ -0,0 +1 @@
+--force-restart

mysql-test/suite/perfschema/t/all_instances.test

@@ -0,0 +1,20 @@
+--source include/not_embedded.inc
+--source include/have_perfschema.inc
+--source include/have_maria.inc
+
+use performance_schema;
+
+#
+# list all instances of everything.
+#
+
+#
+# "group by" sorts and removes duplicates.
+# "where" filters out instances that can be conditionally compiled out
+#
+
+select name from mutex_instances group by name;
+select name from rwlock_instances group by name;
+select name from cond_instances group by name;
+select event_name from file_instances group by event_name;
+select name from threads group by name;

mysys/my_init.c

@@ -479,7 +479,7 @@ PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
   key_THR_LOCK_isam, key_THR_LOCK_lock, key_THR_LOCK_malloc,
   key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
   key_THR_LOCK_open, key_THR_LOCK_threads,
-  key_TMPDIR_mutex, key_THR_LOCK_myisam_mmap;
+  key_TMPDIR_mutex, key_THR_LOCK_myisam_mmap, key_LOCK_uuid_generator;
 
 static PSI_mutex_info all_mysys_mutexes[]=
 {
@@ -506,12 +506,13 @@ static PSI_mutex_info all_mysys_mutexes[]=
   { &key_THR_LOCK_open, "THR_LOCK_open", PSI_FLAG_GLOBAL},
   { &key_THR_LOCK_threads, "THR_LOCK_threads", PSI_FLAG_GLOBAL},
   { &key_TMPDIR_mutex, "TMPDIR_mutex", PSI_FLAG_GLOBAL},
-  { &key_THR_LOCK_myisam_mmap, "THR_LOCK_myisam_mmap", PSI_FLAG_GLOBAL}
+  { &key_THR_LOCK_myisam_mmap, "THR_LOCK_myisam_mmap", PSI_FLAG_GLOBAL},
+  { &key_LOCK_uuid_generator, "LOCK_uuid_generator", PSI_FLAG_GLOBAL }
 };
 
 PSI_cond_key key_COND_alarm, key_IO_CACHE_SHARE_cond,
   key_IO_CACHE_SHARE_cond_writer, key_my_thread_var_suspend,
-  key_THR_COND_threads;
+  key_THR_COND_threads, key_WT_RESOURCE_cond;
 
 static PSI_cond_info all_mysys_conds[]=
 {
@@ -519,7 +520,15 @@ static PSI_cond_info all_mysys_conds[]=
   { &key_IO_CACHE_SHARE_cond, "IO_CACHE_SHARE::cond", 0},
   { &key_IO_CACHE_SHARE_cond_writer, "IO_CACHE_SHARE::cond_writer", 0},
   { &key_my_thread_var_suspend, "my_thread_var::suspend", 0},
-  { &key_THR_COND_threads, "THR_COND_threads", 0}
+  { &key_THR_COND_threads, "THR_COND_threads", PSI_FLAG_GLOBAL},
+  { &key_WT_RESOURCE_cond, "WT_RESOURCE::cond", 0}
+};
+
+PSI_rwlock_key key_SAFEHASH_mutex;
+
+static PSI_rwlock_info all_mysys_rwlocks[]=
+{
+  { &key_SAFEHASH_mutex, "SAFE_HASH::mutex", 0}
 };
 
 #ifdef USE_ALARM_THREAD
@@ -559,6 +568,9 @@ void my_init_mysys_psi_keys()
   count= sizeof(all_mysys_conds)/sizeof(all_mysys_conds[0]);
   PSI_server->register_cond(category, all_mysys_conds, count);
 
+  count= sizeof(all_mysys_rwlocks)/sizeof(all_mysys_rwlocks[0]);
+  PSI_server->register_rwlock(category, all_mysys_rwlocks, count);
+
 #ifdef USE_ALARM_THREAD
   count= sizeof(all_mysys_threads)/sizeof(all_mysys_threads[0]);
   PSI_server->register_thread(category, all_mysys_threads, count);

mysys/my_safehash.c

@@ -107,7 +107,7 @@ my_bool safe_hash_init(SAFE_HASH *hash, uint elements,
     hash->default_value= 0;
     DBUG_RETURN(1);
   }
-  my_rwlock_init(&hash->mutex, 0);
+  mysql_rwlock_init(key_SAFEHASH_mutex, &hash->mutex);
   hash->default_value= default_value;
   hash->root= 0;
   DBUG_RETURN(0);
@@ -134,7 +134,7 @@ void safe_hash_free(SAFE_HASH *hash)
   if (hash->default_value)
   {
     my_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, const uchar *key, uint length,
 {
   uchar *result;
   DBUG_ENTER("safe_hash_search");
-  rw_rdlock(&hash->mutex);
+  mysql_rwlock_rdlock(&hash->mutex);
   result= my_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, const uchar *key, uint length,
   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*) my_hash_search(&hash->hash, key, length);
 
   if (data == hash->default_value)
@@ -249,7 +249,7 @@ my_bool safe_hash_set(SAFE_HASH *hash, const uchar *key, uint length,
   }
 
 end:
-  rw_unlock(&hash->mutex);
+  mysql_rwlock_unlock(&hash->mutex);
   DBUG_RETURN(error);
 }
 
@@ -274,7 +274,7 @@ void safe_hash_change(SAFE_HASH *hash, uchar *old_data, uchar *new_data)
   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, uchar *old_data, uchar *new_data)
     }
   }
 
-  rw_unlock(&hash->mutex);
+  mysql_rwlock_unlock(&hash->mutex);
   DBUG_VOID_RETURN;
 }

mysys/my_safehash.h

@@ -39,7 +39,7 @@ typedef struct st_safe_hash_entry
 
 typedef struct st_safe_hash_with_default
 {
-  rw_lock_t mutex;
+  mysql_rwlock_t mutex;
   HASH hash;
   uchar *default_value;
   SAFE_HASH_ENTRY *root;

mysys/my_uuid.c

@@ -49,7 +49,7 @@ static uint nanoseq;
 static ulonglong uuid_time= 0;
 static uchar uuid_suffix[2+6]; /* clock_seq and node */
 
-pthread_mutex_t LOCK_uuid_generator;
+mysql_mutex_t LOCK_uuid_generator;
 
 /*
   Number of 100-nanosecond intervals between
@@ -112,7 +112,7 @@ void my_uuid_init(ulong seed1, ulong seed2)
   }
   my_rnd_init(&uuid_rand, (ulong) (seed1 + now), (ulong) (now/2+ getpid()));
   set_clock_seq();
-  pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_uuid_generator, &LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
 }
 
 
@@ -131,7 +131,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))
@@ -192,7 +192,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);
@@ -236,6 +236,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);
   }
 }

mysys/mysys_priv.h

@@ -41,7 +41,7 @@ extern PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
   key_my_thread_var_mutex, key_THR_LOCK_charset, key_THR_LOCK_heap,
   key_THR_LOCK_isam, key_THR_LOCK_lock, key_THR_LOCK_malloc,
   key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
-  key_THR_LOCK_open, key_THR_LOCK_threads,
+  key_THR_LOCK_open, key_THR_LOCK_threads, key_LOCK_uuid_generator,
   key_TMPDIR_mutex, key_THR_LOCK_myisam_mmap;
 
 extern PSI_cond_key key_COND_alarm, key_IO_CACHE_SHARE_cond,
@@ -52,6 +52,8 @@ extern PSI_cond_key key_COND_alarm, key_IO_CACHE_SHARE_cond,
 extern PSI_thread_key key_thread_alarm;
 #endif /* USE_ALARM_THREAD */
 
+extern PSI_rwlock_key key_SAFEHASH_mutex;
+
 #endif /* HAVE_PSI_INTERFACE */
 
 extern mysql_mutex_t THR_LOCK_malloc, THR_LOCK_open, THR_LOCK_keycache;

mysys/waiting_threads.c

@@ -193,6 +193,8 @@ uint32 wt_success_stats;
 
 static my_atomic_rwlock_t cycle_stats_lock, wait_stats_lock, success_stats_lock;
 
+extern PSI_cond_key key_WT_RESOURCE_cond;
+
 #ifdef SAFE_STATISTICS
 #define incr(VAR, LOCK)                           \
   do {                                            \
@@ -253,7 +255,7 @@ struct st_wt_resource {
   uint            waiter_count;
   enum { ACTIVE, FREE } state;
 #ifndef DBUG_OFF
-  pthread_mutex_t  *cond_mutex; /* a mutex for the 'cond' below */
+  mysql_mutex_t  *cond_mutex; /* a mutex for the 'cond' below */
 #endif
   /*
     before the 'lock' all elements are mutable, after (and including) -
@@ -301,7 +303,7 @@ struct st_wt_resource {
 #else
   rw_lock_t lock;
 #endif
-  pthread_cond_t   cond; /* the corresponding mutex is provided by the caller */
+  mysql_cond_t   cond; /* the corresponding mutex is provided by the caller */
   DYNAMIC_ARRAY    owners;
 };
 
@@ -398,7 +400,7 @@ static void wt_resource_init(uchar *arg)
 
   bzero(rc, sizeof(*rc));
   rc_rwlock_init(rc);
-  pthread_cond_init(&rc->cond, 0);
+  mysql_cond_init(key_WT_RESOURCE_cond, &rc->cond, 0);
   my_init_dynamic_array(&rc->owners, sizeof(WT_THD *), 0, 5);
   DBUG_VOID_RETURN;
 }
@@ -416,7 +418,7 @@ static void wt_resource_destroy(uchar *arg)
 
   DBUG_ASSERT(rc->owners.elements == 0);
   rc_rwlock_destroy(rc);
-  pthread_cond_destroy(&rc->cond);
+  mysql_cond_destroy(&rc->cond);
   delete_dynamic(&rc->owners);
   DBUG_VOID_RETURN;
 }
@@ -795,7 +797,7 @@ static int deadlock(WT_THD *thd, WT_THD *blocker, uint depth,
   {
     DBUG_PRINT("wt", ("killing %s", arg.victim->name));
     arg.victim->killed= 1;
-    pthread_cond_broadcast(&arg.victim->waiting_for->cond);
+    mysql_cond_broadcast(&arg.victim->waiting_for->cond);
     rc_unlock(arg.victim->waiting_for);
     ret= WT_OK;
   }
@@ -1029,11 +1031,11 @@ retry:
   called by a *waiter* (thd) to start waiting
 
   It's supposed to be a drop-in replacement for
-  pthread_cond_timedwait(), and it takes mutex as an argument.
+  mysql_cond_timedwait(), and it takes mutex as an argument.
 
   @return one of WT_TIMEOUT, WT_DEADLOCK, WT_OK
 */
-int wt_thd_cond_timedwait(WT_THD *thd, pthread_mutex_t *mutex)
+int wt_thd_cond_timedwait(WT_THD *thd, mysql_mutex_t *mutex)
 {
   int ret= WT_TIMEOUT;
   struct timespec timeout;
@@ -1047,7 +1049,7 @@ int wt_thd_cond_timedwait(WT_THD *thd, pthread_mutex_t *mutex)
     DBUG_ASSERT(rc->cond_mutex == mutex);
   else
     rc->cond_mutex= mutex;
-  safe_mutex_assert_owner(mutex);
+  mysql_mutex_assert_owner(mutex);
 #endif
 
   before= starttime= my_getsystime();
@@ -1074,7 +1076,7 @@ int wt_thd_cond_timedwait(WT_THD *thd, pthread_mutex_t *mutex)
 
   set_timespec_time_nsec(timeout, starttime, (*thd->timeout_short)*ULL(1000));
   if (ret == WT_TIMEOUT && !thd->killed)
-    ret= pthread_cond_timedwait(&rc->cond, mutex, &timeout);
+    ret= mysql_cond_timedwait(&rc->cond, mutex, &timeout);
   if (ret == WT_TIMEOUT && !thd->killed)
   {
     int r= deadlock(thd, thd, 0, *thd->deadlock_search_depth_long);
@@ -1086,7 +1088,7 @@ int wt_thd_cond_timedwait(WT_THD *thd, pthread_mutex_t *mutex)
     {
       set_timespec_time_nsec(timeout, starttime, (*thd->timeout_long)*ULL(1000));
       if (!thd->killed)
-        ret= pthread_cond_timedwait(&rc->cond, mutex, &timeout);
+        ret= mysql_cond_timedwait(&rc->cond, mutex, &timeout);
     }
   }
   after= my_getsystime();
@@ -1132,10 +1134,10 @@ void wt_thd_release(WT_THD *thd, const WT_RESOURCE_ID *resid)
       delete_dynamic_element(&rc->owners, j);
       if (rc->owners.elements == 0)
       {
-        pthread_cond_broadcast(&rc->cond);
+        mysql_cond_broadcast(&rc->cond);
 #ifndef DBUG_OFF
         if (rc->cond_mutex)
-          safe_mutex_assert_owner(rc->cond_mutex);
+          mysql_mutex_assert_owner(rc->cond_mutex);
 #endif
       }
       unlock_lock_and_free_resource(thd, rc);

sql/item_strfunc.cc

@@ -41,7 +41,6 @@
 */
 #include "sql_class.h"                          // set_var.h: THD
 #include "set_var.h"
-#include "mysqld.h"                             // LOCK_uuid_generator
 #include "sql_acl.h"                            // SUPER_ACL
 #include "des_key_file.h"       // st_des_keyschedule, st_des_keyblock
 #include "password.h"           // my_make_scrambled_password,

sql/mysqld.cc

@@ -698,6 +698,262 @@ static char *opt_bin_logname;
 int orig_argc;
 char **orig_argv;
 
+#ifdef HAVE_PSI_INTERFACE
+#ifdef HAVE_MMAP
+PSI_mutex_key key_PAGE_lock, key_LOCK_sync, key_LOCK_active, key_LOCK_pool;
+#endif /* HAVE_MMAP */
+
+#ifdef HAVE_OPENSSL
+PSI_mutex_key key_LOCK_des_key_file;
+#endif /* HAVE_OPENSSL */
+
+PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids,
+  key_delayed_insert_mutex, key_hash_filo_lock, key_LOCK_active_mi,
+  key_LOCK_connection_count, key_LOCK_crypt, key_LOCK_delayed_create,
+  key_LOCK_delayed_insert, key_LOCK_delayed_status, key_LOCK_error_log,
+  key_LOCK_gdl, key_LOCK_global_system_variables,
+  key_LOCK_manager,
+  key_LOCK_prepared_stmt_count,
+  key_LOCK_rpl_status, key_LOCK_server_started, key_LOCK_status,
+  key_LOCK_system_variables_hash, key_LOCK_table_share, key_LOCK_thd_data,
+  key_LOCK_user_conn, key_LOCK_uuid_short_generator, key_LOG_LOCK_log,
+  key_master_info_data_lock, key_master_info_run_lock,
+  key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock,
+  key_relay_log_info_log_space_lock, key_relay_log_info_run_lock,
+  key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data,
+  key_LOCK_error_messages, key_LOG_INFO_lock, key_LOCK_thread_count,
+  key_PARTITION_LOCK_auto_inc;
+PSI_mutex_key key_RELAYLOG_LOCK_index;
+
+PSI_mutex_key key_LOCK_stats,
+  key_LOCK_global_user_client_stats, key_LOCK_global_table_stats,
+  key_LOCK_global_index_stats;
+
+static PSI_mutex_info all_server_mutexes[]=
+{
+#ifdef HAVE_MMAP
+  { &key_PAGE_lock, "PAGE::lock", 0},
+  { &key_LOCK_sync, "TC_LOG_MMAP::LOCK_sync", 0},
+  { &key_LOCK_active, "TC_LOG_MMAP::LOCK_active", 0},
+  { &key_LOCK_pool, "TC_LOG_MMAP::LOCK_pool", 0},
+#endif /* HAVE_MMAP */
+
+#ifdef HAVE_OPENSSL
+  { &key_LOCK_des_key_file, "LOCK_des_key_file", PSI_FLAG_GLOBAL},
+#endif /* HAVE_OPENSSL */
+
+  { &key_BINLOG_LOCK_index, "MYSQL_BIN_LOG::LOCK_index", 0},
+  { &key_BINLOG_LOCK_prep_xids, "MYSQL_BIN_LOG::LOCK_prep_xids", 0},
+  { &key_RELAYLOG_LOCK_index, "MYSQL_RELAY_LOG::LOCK_index", 0},
+  { &key_delayed_insert_mutex, "Delayed_insert::mutex", 0},
+  { &key_hash_filo_lock, "hash_filo::lock", 0},
+  { &key_LOCK_active_mi, "LOCK_active_mi", PSI_FLAG_GLOBAL},
+  { &key_LOCK_connection_count, "LOCK_connection_count", PSI_FLAG_GLOBAL},
+  { &key_LOCK_crypt, "LOCK_crypt", PSI_FLAG_GLOBAL},
+  { &key_LOCK_delayed_create, "LOCK_delayed_create", PSI_FLAG_GLOBAL},
+  { &key_LOCK_delayed_insert, "LOCK_delayed_insert", PSI_FLAG_GLOBAL},
+  { &key_LOCK_delayed_status, "LOCK_delayed_status", PSI_FLAG_GLOBAL},
+  { &key_LOCK_error_log, "LOCK_error_log", PSI_FLAG_GLOBAL},
+  { &key_LOCK_gdl, "LOCK_gdl", PSI_FLAG_GLOBAL},
+  { &key_LOCK_global_system_variables, "LOCK_global_system_variables", PSI_FLAG_GLOBAL},
+  { &key_LOCK_manager, "LOCK_manager", PSI_FLAG_GLOBAL},
+  { &key_LOCK_prepared_stmt_count, "LOCK_prepared_stmt_count", PSI_FLAG_GLOBAL},
+  { &key_LOCK_rpl_status, "LOCK_rpl_status", PSI_FLAG_GLOBAL},
+  { &key_LOCK_server_started, "LOCK_server_started", PSI_FLAG_GLOBAL},
+  { &key_LOCK_status, "LOCK_status", PSI_FLAG_GLOBAL},
+  { &key_LOCK_system_variables_hash, "LOCK_system_variables_hash", PSI_FLAG_GLOBAL},
+  { &key_LOCK_table_share, "LOCK_table_share", PSI_FLAG_GLOBAL},
+  { &key_LOCK_stats, "LOCK_stats", PSI_FLAG_GLOBAL},
+  { &key_LOCK_global_user_client_stats, "LOCK_global_user_client_stats", PSI_FLAG_GLOBAL},
+  { &key_LOCK_global_table_stats, "LOCK_global_table_stats", PSI_FLAG_GLOBAL},
+  { &key_LOCK_global_index_stats, "LOCK_global_index_stats", PSI_FLAG_GLOBAL},
+  { &key_LOCK_thd_data, "THD::LOCK_thd_data", 0},
+  { &key_LOCK_user_conn, "LOCK_user_conn", PSI_FLAG_GLOBAL},
+  { &key_LOCK_uuid_short_generator, "LOCK_uuid_generator", PSI_FLAG_GLOBAL},
+  { &key_LOG_LOCK_log, "LOG::LOCK_log", 0},
+  { &key_master_info_data_lock, "Master_info::data_lock", 0},
+  { &key_master_info_run_lock, "Master_info::run_lock", 0},
+  { &key_mutex_slave_reporting_capability_err_lock, "Slave_reporting_capability::err_lock", 0},
+  { &key_relay_log_info_data_lock, "Relay_log_info::data_lock", 0},
+  { &key_relay_log_info_log_space_lock, "Relay_log_info::log_space_lock", 0},
+  { &key_relay_log_info_run_lock, "Relay_log_info::run_lock", 0},
+  { &key_structure_guard_mutex, "Query_cache::structure_guard_mutex", 0},
+  { &key_TABLE_SHARE_LOCK_ha_data, "TABLE_SHARE::LOCK_ha_data", 0},
+  { &key_LOCK_error_messages, "LOCK_error_messages", PSI_FLAG_GLOBAL},
+  { &key_LOG_INFO_lock, "LOG_INFO::lock", 0},
+  { &key_LOCK_thread_count, "LOCK_thread_count", PSI_FLAG_GLOBAL},
+  { &key_PARTITION_LOCK_auto_inc, "HA_DATA_PARTITION::LOCK_auto_inc", 0}
+};
+
+PSI_rwlock_key key_rwlock_LOCK_grant, key_rwlock_LOCK_logger,
+  key_rwlock_LOCK_sys_init_connect, key_rwlock_LOCK_sys_init_slave,
+  key_rwlock_LOCK_system_variables_hash, key_rwlock_query_cache_query_lock;
+
+static PSI_rwlock_info all_server_rwlocks[]=
+{
+#if defined (HAVE_OPENSSL) && !defined(HAVE_YASSL)
+  { &key_rwlock_openssl, "CRYPTO_dynlock_value::lock", 0},
+#endif
+  { &key_rwlock_LOCK_grant, "LOCK_grant", PSI_FLAG_GLOBAL},
+  { &key_rwlock_LOCK_logger, "LOGGER::LOCK_logger", 0},
+  { &key_rwlock_LOCK_sys_init_connect, "LOCK_sys_init_connect", PSI_FLAG_GLOBAL},
+  { &key_rwlock_LOCK_sys_init_slave, "LOCK_sys_init_slave", PSI_FLAG_GLOBAL},
+  { &key_rwlock_LOCK_system_variables_hash, "LOCK_system_variables_hash", PSI_FLAG_GLOBAL},
+  { &key_rwlock_query_cache_query_lock, "Query_cache_query::lock", 0}
+};
+
+#ifdef HAVE_MMAP
+PSI_cond_key key_PAGE_cond, key_COND_active, key_COND_pool;
+#endif /* HAVE_MMAP */
+
+PSI_cond_key key_BINLOG_COND_prep_xids, key_BINLOG_update_cond,
+  key_COND_cache_status_changed, key_COND_manager,
+  key_COND_rpl_status, key_COND_server_started,
+  key_delayed_insert_cond, key_delayed_insert_cond_client,
+  key_item_func_sleep_cond, key_master_info_data_cond,
+  key_master_info_start_cond, key_master_info_stop_cond,
+  key_relay_log_info_data_cond, key_relay_log_info_log_space_cond,
+  key_relay_log_info_start_cond, key_relay_log_info_stop_cond,
+  key_TABLE_SHARE_cond, key_user_level_lock_cond,
+  key_COND_thread_count, key_COND_thread_cache, key_COND_flush_thread_cache;
+PSI_cond_key key_RELAYLOG_update_cond;
+
+static PSI_cond_info all_server_conds[]=
+{
+#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
+  { &key_COND_handler_count, "COND_handler_count", PSI_FLAG_GLOBAL},
+#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
+#ifdef HAVE_MMAP
+  { &key_PAGE_cond, "PAGE::cond", 0},
+  { &key_COND_active, "TC_LOG_MMAP::COND_active", 0},
+  { &key_COND_pool, "TC_LOG_MMAP::COND_pool", 0},
+#endif /* HAVE_MMAP */
+  { &key_BINLOG_COND_prep_xids, "MYSQL_BIN_LOG::COND_prep_xids", 0},
+  { &key_BINLOG_update_cond, "MYSQL_BIN_LOG::update_cond", 0},
+  { &key_RELAYLOG_update_cond, "MYSQL_RELAY_LOG::update_cond", 0},
+  { &key_COND_cache_status_changed, "Query_cache::COND_cache_status_changed", 0},
+  { &key_COND_manager, "COND_manager", PSI_FLAG_GLOBAL},
+  { &key_COND_rpl_status, "COND_rpl_status", PSI_FLAG_GLOBAL},
+  { &key_COND_server_started, "COND_server_started", PSI_FLAG_GLOBAL},
+  { &key_delayed_insert_cond, "Delayed_insert::cond", 0},
+  { &key_delayed_insert_cond_client, "Delayed_insert::cond_client", 0},
+  { &key_item_func_sleep_cond, "Item_func_sleep::cond", 0},
+  { &key_master_info_data_cond, "Master_info::data_cond", 0},
+  { &key_master_info_start_cond, "Master_info::start_cond", 0},
+  { &key_master_info_stop_cond, "Master_info::stop_cond", 0},
+  { &key_relay_log_info_data_cond, "Relay_log_info::data_cond", 0},
+  { &key_relay_log_info_log_space_cond, "Relay_log_info::log_space_cond", 0},
+  { &key_relay_log_info_start_cond, "Relay_log_info::start_cond", 0},
+  { &key_relay_log_info_stop_cond, "Relay_log_info::stop_cond", 0},
+  { &key_TABLE_SHARE_cond, "TABLE_SHARE::cond", 0},
+  { &key_user_level_lock_cond, "User_level_lock::cond", 0},
+  { &key_COND_thread_count, "COND_thread_count", PSI_FLAG_GLOBAL},
+  { &key_COND_thread_cache, "COND_thread_cache", PSI_FLAG_GLOBAL},
+  { &key_COND_flush_thread_cache, "COND_flush_thread_cache", PSI_FLAG_GLOBAL}
+};
+
+PSI_thread_key key_thread_bootstrap, key_thread_delayed_insert,
+  key_thread_handle_manager, key_thread_main,
+  key_thread_one_connection, key_thread_signal_hand;
+
+static PSI_thread_info all_server_threads[]=
+{
+#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
+  { &key_thread_handle_con_namedpipes, "con_named_pipes", PSI_FLAG_GLOBAL},
+#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
+
+#if defined(HAVE_SMEM) && !defined(EMBEDDED_LIBRARY)
+  { &key_thread_handle_con_sharedmem, "con_shared_mem", PSI_FLAG_GLOBAL},
+#endif /* HAVE_SMEM && !EMBEDDED_LIBRARY */
+
+#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
+  { &key_thread_handle_con_sockets, "con_sockets", PSI_FLAG_GLOBAL},
+#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
+
+#ifdef __WIN__
+  { &key_thread_handle_shutdown, "shutdown", PSI_FLAG_GLOBAL},
+#endif /* __WIN__ */
+
+  { &key_thread_bootstrap, "bootstrap", PSI_FLAG_GLOBAL},
+  { &key_thread_delayed_insert, "delayed_insert", 0},
+  { &key_thread_handle_manager, "manager", PSI_FLAG_GLOBAL},
+  { &key_thread_main, "main", PSI_FLAG_GLOBAL},
+  { &key_thread_one_connection, "one_connection", 0},
+  { &key_thread_signal_hand, "signal_handler", PSI_FLAG_GLOBAL}
+};
+
+PSI_file_key key_file_binlog, key_file_binlog_index, key_file_casetest,
+  key_file_dbopt, key_file_des_key_file, key_file_ERRMSG, key_select_to_file,
+  key_file_fileparser, key_file_frm, key_file_global_ddl_log, key_file_load,
+  key_file_loadfile, key_file_log_event_data, key_file_log_event_info,
+  key_file_master_info, key_file_misc, key_file_partition,
+  key_file_pid, key_file_relay_log_info, key_file_send_file, key_file_tclog,
+  key_file_trg, key_file_trn, key_file_init;
+PSI_file_key key_file_query_log, key_file_slow_log;
+PSI_file_key key_file_relaylog, key_file_relaylog_index;
+
+static PSI_file_info all_server_files[]=
+{
+  { &key_file_binlog, "binlog", 0},
+  { &key_file_binlog_index, "binlog_index", 0},
+  { &key_file_relaylog, "relaylog", 0},
+  { &key_file_relaylog_index, "relaylog_index", 0},
+  { &key_file_casetest, "casetest", 0},
+  { &key_file_dbopt, "dbopt", 0},
+  { &key_file_des_key_file, "des_key_file", 0},
+  { &key_file_ERRMSG, "ERRMSG", 0},
+  { &key_select_to_file, "select_to_file", 0},
+  { &key_file_fileparser, "file_parser", 0},
+  { &key_file_frm, "FRM", 0},
+  { &key_file_global_ddl_log, "global_ddl_log", 0},
+  { &key_file_load, "load", 0},
+  { &key_file_loadfile, "LOAD_FILE", 0},
+  { &key_file_log_event_data, "log_event_data", 0},
+  { &key_file_log_event_info, "log_event_info", 0},
+  { &key_file_master_info, "master_info", 0},
+  { &key_file_misc, "misc", 0},
+  { &key_file_partition, "partition", 0},
+  { &key_file_pid, "pid", 0},
+  { &key_file_query_log, "query_log", 0},
+  { &key_file_relay_log_info, "relay_log_info", 0},
+  { &key_file_send_file, "send_file", 0},
+  { &key_file_slow_log, "slow_log", 0},
+  { &key_file_tclog, "tclog", 0},
+  { &key_file_trg, "trigger_name", 0},
+  { &key_file_trn, "trigger", 0},
+  { &key_file_init, "init", 0}
+};
+
+/**
+  Initialise all the performance schema instrumentation points
+  used by the server.
+*/
+void init_server_psi_keys(void)
+{
+  const char* category= "sql";
+  int count;
+
+  if (PSI_server == NULL)
+    return;
+
+  count= array_elements(all_server_mutexes);
+  PSI_server->register_mutex(category, all_server_mutexes, count);
+
+  count= array_elements(all_server_rwlocks);
+  PSI_server->register_rwlock(category, all_server_rwlocks, count);
+
+  count= array_elements(all_server_conds);
+  PSI_server->register_cond(category, all_server_conds, count);
+
+  count= array_elements(all_server_threads);
+  PSI_server->register_thread(category, all_server_threads, count);
+
+  count= array_elements(all_server_files);
+  PSI_server->register_file(category, all_server_files, count);
+}
+
+#endif /* HAVE_PSI_INTERFACE */
+
 /*
   Since buffered_option_error_reporter is only used currently
   for parsing performance schema options, this code is not needed
@@ -3710,7 +3966,7 @@ static int init_thread_environment()
                    &LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
   mysql_mutex_init(key_LOCK_error_messages,
                    &LOCK_error_messages, MY_MUTEX_INIT_FAST);
-  mysql_mutex_init(key_LOCK_uuid_generator,
+  mysql_mutex_init(key_LOCK_uuid_short_generator,
                    &LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
   mysql_mutex_init(key_LOCK_connection_count,
                    &LOCK_connection_count, MY_MUTEX_INIT_FAST);
@@ -7969,266 +8225,3 @@ template class I_List<Statement>;
 template class I_List_iterator<Statement>;
 #endif
 
-#ifdef HAVE_PSI_INTERFACE
-#ifdef HAVE_MMAP
-PSI_mutex_key key_PAGE_lock, key_LOCK_sync, key_LOCK_active, key_LOCK_pool;
-#endif /* HAVE_MMAP */
-
-#ifdef HAVE_OPENSSL
-PSI_mutex_key key_LOCK_des_key_file;
-#endif /* HAVE_OPENSSL */
-
-PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids,
-  key_delayed_insert_mutex, key_hash_filo_lock, key_LOCK_active_mi,
-  key_LOCK_connection_count, key_LOCK_crypt, key_LOCK_delayed_create,
-  key_LOCK_delayed_insert, key_LOCK_delayed_status, key_LOCK_error_log,
-  key_LOCK_gdl, key_LOCK_global_system_variables,
-  key_LOCK_manager,
-  key_LOCK_prepared_stmt_count,
-  key_LOCK_rpl_status, key_LOCK_server_started, key_LOCK_status,
-  key_LOCK_system_variables_hash, key_LOCK_table_share, key_LOCK_thd_data,
-  key_LOCK_user_conn, key_LOCK_uuid_generator, key_LOG_LOCK_log,
-  key_master_info_data_lock, key_master_info_run_lock,
-  key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock,
-  key_relay_log_info_log_space_lock, key_relay_log_info_run_lock,
-  key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data,
-  key_LOCK_error_messages, key_LOG_INFO_lock, key_LOCK_thread_count,
-  key_PARTITION_LOCK_auto_inc;
-PSI_mutex_key key_RELAYLOG_LOCK_index;
-
-PSI_mutex_key key_LOCK_stats,
-  key_LOCK_global_user_client_stats, key_LOCK_global_table_stats,
-  key_LOCK_global_index_stats;
-
-static PSI_mutex_info all_server_mutexes[]=
-{
-#ifdef HAVE_MMAP
-  { &key_PAGE_lock, "PAGE::lock", 0},
-  { &key_LOCK_sync, "TC_LOG_MMAP::LOCK_sync", 0},
-  { &key_LOCK_active, "TC_LOG_MMAP::LOCK_active", 0},
-  { &key_LOCK_pool, "TC_LOG_MMAP::LOCK_pool", 0},
-#endif /* HAVE_MMAP */
-
-#ifdef HAVE_OPENSSL
-  { &key_LOCK_des_key_file, "LOCK_des_key_file", PSI_FLAG_GLOBAL},
-#endif /* HAVE_OPENSSL */
-
-  { &key_BINLOG_LOCK_index, "MYSQL_BIN_LOG::LOCK_index", 0},
-  { &key_BINLOG_LOCK_prep_xids, "MYSQL_BIN_LOG::LOCK_prep_xids", 0},
-  { &key_RELAYLOG_LOCK_index, "MYSQL_RELAY_LOG::LOCK_index", 0},
-  { &key_delayed_insert_mutex, "Delayed_insert::mutex", 0},
-  { &key_hash_filo_lock, "hash_filo::lock", 0},
-  { &key_LOCK_active_mi, "LOCK_active_mi", PSI_FLAG_GLOBAL},
-  { &key_LOCK_connection_count, "LOCK_connection_count", PSI_FLAG_GLOBAL},
-  { &key_LOCK_crypt, "LOCK_crypt", PSI_FLAG_GLOBAL},
-  { &key_LOCK_delayed_create, "LOCK_delayed_create", PSI_FLAG_GLOBAL},
-  { &key_LOCK_delayed_insert, "LOCK_delayed_insert", PSI_FLAG_GLOBAL},
-  { &key_LOCK_delayed_status, "LOCK_delayed_status", PSI_FLAG_GLOBAL},
-  { &key_LOCK_error_log, "LOCK_error_log", PSI_FLAG_GLOBAL},
-  { &key_LOCK_gdl, "LOCK_gdl", PSI_FLAG_GLOBAL},
-  { &key_LOCK_global_system_variables, "LOCK_global_system_variables", PSI_FLAG_GLOBAL},
-  { &key_LOCK_manager, "LOCK_manager", PSI_FLAG_GLOBAL},
-  { &key_LOCK_prepared_stmt_count, "LOCK_prepared_stmt_count", PSI_FLAG_GLOBAL},
-  { &key_LOCK_rpl_status, "LOCK_rpl_status", PSI_FLAG_GLOBAL},
-  { &key_LOCK_server_started, "LOCK_server_started", PSI_FLAG_GLOBAL},
-  { &key_LOCK_status, "LOCK_status", PSI_FLAG_GLOBAL},
-  { &key_LOCK_system_variables_hash, "LOCK_system_variables_hash", PSI_FLAG_GLOBAL},
-  { &key_LOCK_table_share, "LOCK_table_share", PSI_FLAG_GLOBAL},
-  { &key_LOCK_stats, "LOCK_stats", PSI_FLAG_GLOBAL},
-  { &key_LOCK_global_user_client_stats, "LOCK_global_user_client_stats", PSI_FLAG_GLOBAL},
-  { &key_LOCK_global_table_stats, "LOCK_global_table_stats", PSI_FLAG_GLOBAL},
-  { &key_LOCK_global_index_stats, "LOCK_global_index_stats", PSI_FLAG_GLOBAL},
-  { &key_LOCK_thd_data, "THD::LOCK_thd_data", 0},
-  { &key_LOCK_user_conn, "LOCK_user_conn", PSI_FLAG_GLOBAL},
-  { &key_LOCK_uuid_generator, "LOCK_uuid_generator", PSI_FLAG_GLOBAL},
-  { &key_LOG_LOCK_log, "LOG::LOCK_log", 0},
-  { &key_master_info_data_lock, "Master_info::data_lock", 0},
-  { &key_master_info_run_lock, "Master_info::run_lock", 0},
-  { &key_mutex_slave_reporting_capability_err_lock, "Slave_reporting_capability::err_lock", 0},
-  { &key_relay_log_info_data_lock, "Relay_log_info::data_lock", 0},
-  { &key_relay_log_info_log_space_lock, "Relay_log_info::log_space_lock", 0},
-  { &key_relay_log_info_run_lock, "Relay_log_info::run_lock", 0},
-  { &key_structure_guard_mutex, "Query_cache::structure_guard_mutex", 0},
-  { &key_TABLE_SHARE_LOCK_ha_data, "TABLE_SHARE::LOCK_ha_data", 0},
-  { &key_LOCK_error_messages, "LOCK_error_messages", PSI_FLAG_GLOBAL},
-  { &key_LOG_INFO_lock, "LOG_INFO::lock", 0},
-  { &key_LOCK_thread_count, "LOCK_thread_count", PSI_FLAG_GLOBAL},
-  { &key_PARTITION_LOCK_auto_inc, "HA_DATA_PARTITION::LOCK_auto_inc", 0}
-};
-
-PSI_rwlock_key key_rwlock_LOCK_grant, key_rwlock_LOCK_logger,
-  key_rwlock_LOCK_sys_init_connect, key_rwlock_LOCK_sys_init_slave,
-  key_rwlock_LOCK_system_variables_hash, key_rwlock_query_cache_query_lock;
-
-static PSI_rwlock_info all_server_rwlocks[]=
-{
-#if defined (HAVE_OPENSSL) && !defined(HAVE_YASSL)
-  { &key_rwlock_openssl, "CRYPTO_dynlock_value::lock", 0},
-#endif
-  { &key_rwlock_LOCK_grant, "LOCK_grant", PSI_FLAG_GLOBAL},
-  { &key_rwlock_LOCK_logger, "LOGGER::LOCK_logger", 0},
-  { &key_rwlock_LOCK_sys_init_connect, "LOCK_sys_init_connect", PSI_FLAG_GLOBAL},
-  { &key_rwlock_LOCK_sys_init_slave, "LOCK_sys_init_slave", PSI_FLAG_GLOBAL},
-  { &key_rwlock_LOCK_system_variables_hash, "LOCK_system_variables_hash", PSI_FLAG_GLOBAL},
-  { &key_rwlock_query_cache_query_lock, "Query_cache_query::lock", 0}
-};
-
-#ifdef HAVE_MMAP
-PSI_cond_key key_PAGE_cond, key_COND_active, key_COND_pool;
-#endif /* HAVE_MMAP */
-
-PSI_cond_key key_BINLOG_COND_prep_xids, key_BINLOG_update_cond,
-  key_COND_cache_status_changed, key_COND_manager,
-  key_COND_rpl_status, key_COND_server_started,
-  key_delayed_insert_cond, key_delayed_insert_cond_client,
-  key_item_func_sleep_cond, key_master_info_data_cond,
-  key_master_info_start_cond, key_master_info_stop_cond,
-  key_relay_log_info_data_cond, key_relay_log_info_log_space_cond,
-  key_relay_log_info_start_cond, key_relay_log_info_stop_cond,
-  key_TABLE_SHARE_cond, key_user_level_lock_cond,
-  key_COND_thread_count, key_COND_thread_cache, key_COND_flush_thread_cache;
-PSI_cond_key key_RELAYLOG_update_cond;
-
-static PSI_cond_info all_server_conds[]=
-{
-#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
-  { &key_COND_handler_count, "COND_handler_count", PSI_FLAG_GLOBAL},
-#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
-#ifdef HAVE_MMAP
-  { &key_PAGE_cond, "PAGE::cond", 0},
-  { &key_COND_active, "TC_LOG_MMAP::COND_active", 0},
-  { &key_COND_pool, "TC_LOG_MMAP::COND_pool", 0},
-#endif /* HAVE_MMAP */
-  { &key_BINLOG_COND_prep_xids, "MYSQL_BIN_LOG::COND_prep_xids", 0},
-  { &key_BINLOG_update_cond, "MYSQL_BIN_LOG::update_cond", 0},
-  { &key_RELAYLOG_update_cond, "MYSQL_RELAY_LOG::update_cond", 0},
-  { &key_COND_cache_status_changed, "Query_cache::COND_cache_status_changed", 0},
-  { &key_COND_manager, "COND_manager", PSI_FLAG_GLOBAL},
-  { &key_COND_rpl_status, "COND_rpl_status", PSI_FLAG_GLOBAL},
-  { &key_COND_server_started, "COND_server_started", PSI_FLAG_GLOBAL},
-  { &key_delayed_insert_cond, "Delayed_insert::cond", 0},
-  { &key_delayed_insert_cond_client, "Delayed_insert::cond_client", 0},
-  { &key_item_func_sleep_cond, "Item_func_sleep::cond", 0},
-  { &key_master_info_data_cond, "Master_info::data_cond", 0},
-  { &key_master_info_start_cond, "Master_info::start_cond", 0},
-  { &key_master_info_stop_cond, "Master_info::stop_cond", 0},
-  { &key_relay_log_info_data_cond, "Relay_log_info::data_cond", 0},
-  { &key_relay_log_info_log_space_cond, "Relay_log_info::log_space_cond", 0},
-  { &key_relay_log_info_start_cond, "Relay_log_info::start_cond", 0},
-  { &key_relay_log_info_stop_cond, "Relay_log_info::stop_cond", 0},
-  { &key_TABLE_SHARE_cond, "TABLE_SHARE::cond", 0},
-  { &key_user_level_lock_cond, "User_level_lock::cond", 0},
-  { &key_COND_thread_count, "COND_thread_count", PSI_FLAG_GLOBAL},
-  { &key_COND_thread_cache, "COND_thread_cache", PSI_FLAG_GLOBAL},
-  { &key_COND_flush_thread_cache, "COND_flush_thread_cache", PSI_FLAG_GLOBAL}
-};
-
-PSI_thread_key key_thread_bootstrap, key_thread_delayed_insert,
-  key_thread_handle_manager, key_thread_main,
-  key_thread_one_connection, key_thread_signal_hand;
-
-static PSI_thread_info all_server_threads[]=
-{
-#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
-  { &key_thread_handle_con_namedpipes, "con_named_pipes", PSI_FLAG_GLOBAL},
-#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
-
-#if defined(HAVE_SMEM) && !defined(EMBEDDED_LIBRARY)
-  { &key_thread_handle_con_sharedmem, "con_shared_mem", PSI_FLAG_GLOBAL},
-#endif /* HAVE_SMEM && !EMBEDDED_LIBRARY */
-
-#if (defined(_WIN32) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
-  { &key_thread_handle_con_sockets, "con_sockets", PSI_FLAG_GLOBAL},
-#endif /* _WIN32 || HAVE_SMEM && !EMBEDDED_LIBRARY */
-
-#ifdef __WIN__
-  { &key_thread_handle_shutdown, "shutdown", PSI_FLAG_GLOBAL},
-#endif /* __WIN__ */
-
-  { &key_thread_bootstrap, "bootstrap", PSI_FLAG_GLOBAL},
-  { &key_thread_delayed_insert, "delayed_insert", 0},
-  { &key_thread_handle_manager, "manager", PSI_FLAG_GLOBAL},
-  { &key_thread_main, "main", PSI_FLAG_GLOBAL},
-  { &key_thread_one_connection, "one_connection", 0},
-  { &key_thread_signal_hand, "signal_handler", PSI_FLAG_GLOBAL}
-};
-
-#ifdef HAVE_MMAP
-PSI_file_key key_file_map;
-#endif /* HAVE_MMAP */
-
-PSI_file_key key_file_binlog, key_file_binlog_index, key_file_casetest,
-  key_file_dbopt, key_file_des_key_file, key_file_ERRMSG, key_select_to_file,
-  key_file_fileparser, key_file_frm, key_file_global_ddl_log, key_file_load,
-  key_file_loadfile, key_file_log_event_data, key_file_log_event_info,
-  key_file_master_info, key_file_misc, key_file_partition,
-  key_file_pid, key_file_relay_log_info, key_file_send_file, key_file_tclog,
-  key_file_trg, key_file_trn, key_file_init;
-PSI_file_key key_file_query_log, key_file_slow_log;
-PSI_file_key key_file_relaylog, key_file_relaylog_index;
-
-static PSI_file_info all_server_files[]=
-{
-#ifdef HAVE_MMAP
-  { &key_file_map, "map", 0},
-#endif /* HAVE_MMAP */
-  { &key_file_binlog, "binlog", 0},
-  { &key_file_binlog_index, "binlog_index", 0},
-  { &key_file_relaylog, "relaylog", 0},
-  { &key_file_relaylog_index, "relaylog_index", 0},
-  { &key_file_casetest, "casetest", 0},
-  { &key_file_dbopt, "dbopt", 0},
-  { &key_file_des_key_file, "des_key_file", 0},
-  { &key_file_ERRMSG, "ERRMSG", 0},
-  { &key_select_to_file, "select_to_file", 0},
-  { &key_file_fileparser, "file_parser", 0},
-  { &key_file_frm, "FRM", 0},
-  { &key_file_global_ddl_log, "global_ddl_log", 0},
-  { &key_file_load, "load", 0},
-  { &key_file_loadfile, "LOAD_FILE", 0},
-  { &key_file_log_event_data, "log_event_data", 0},
-  { &key_file_log_event_info, "log_event_info", 0},
-  { &key_file_master_info, "master_info", 0},
-  { &key_file_misc, "misc", 0},
-  { &key_file_partition, "partition", 0},
-  { &key_file_pid, "pid", 0},
-  { &key_file_query_log, "query_log", 0},
-  { &key_file_relay_log_info, "relay_log_info", 0},
-  { &key_file_send_file, "send_file", 0},
-  { &key_file_slow_log, "slow_log", 0},
-  { &key_file_tclog, "tclog", 0},
-  { &key_file_trg, "trigger_name", 0},
-  { &key_file_trn, "trigger", 0},
-  { &key_file_init, "init", 0}
-};
-
-/**
-  Initialise all the performance schema instrumentation points
-  used by the server.
-*/
-void init_server_psi_keys(void)
-{
-  const char* category= "sql";
-  int count;
-
-  if (PSI_server == NULL)
-    return;
-
-  count= array_elements(all_server_mutexes);
-  PSI_server->register_mutex(category, all_server_mutexes, count);
-
-  count= array_elements(all_server_rwlocks);
-  PSI_server->register_rwlock(category, all_server_rwlocks, count);
-
-  count= array_elements(all_server_conds);
-  PSI_server->register_cond(category, all_server_conds, count);
-
-  count= array_elements(all_server_threads);
-  PSI_server->register_thread(category, all_server_threads, count);
-
-  count= array_elements(all_server_files);
-  PSI_server->register_file(category, all_server_files, count);
-}
-
-#endif /* HAVE_PSI_INTERFACE */
-

sql/mysqld.h

@@ -231,7 +231,7 @@ extern PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids,
   key_LOCK_prepared_stmt_count,
   key_LOCK_rpl_status, key_LOCK_server_started, key_LOCK_status,
   key_LOCK_table_share, key_LOCK_thd_data,
-  key_LOCK_user_conn, key_LOCK_uuid_generator, key_LOG_LOCK_log,
+  key_LOCK_user_conn, key_LOG_LOCK_log,
   key_master_info_data_lock, key_master_info_run_lock,
   key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock,
   key_relay_log_info_log_space_lock, key_relay_log_info_run_lock,
@@ -267,10 +267,6 @@ extern PSI_thread_key key_thread_bootstrap, key_thread_delayed_insert,
   key_thread_handle_manager, key_thread_kill_server, key_thread_main,
   key_thread_one_connection, key_thread_signal_hand;
 
-#ifdef HAVE_MMAP
-extern PSI_file_key key_file_map;
-#endif /* HAVE_MMAP */
-
 extern PSI_file_key key_file_binlog, key_file_binlog_index, key_file_casetest,
   key_file_dbopt, key_file_des_key_file, key_file_ERRMSG, key_select_to_file,
   key_file_fileparser, key_file_frm, key_file_global_ddl_log, key_file_load,

storage/federatedx/federatedx_io.cc

@@ -63,7 +63,7 @@ federatedx_io::federatedx_io(FEDERATEDX_SERVER *aserver)
   DBUG_ENTER("federatedx_io::federatedx_io");
   DBUG_ASSERT(server);
 
-  safe_mutex_assert_owner(&server->mutex);
+  mysql_mutex_assert_owner(&server->mutex);
   server->io_count++;
 
   DBUG_VOID_RETURN;

storage/federatedx/federatedx_txn.cc

@@ -111,7 +111,7 @@ int federatedx_txn::acquire(FEDERATEDX_SHARE *share, bool readonly,
     if (!io)
     {
       /* check to see if there are any unowned IO connections */
-      pthread_mutex_lock(&server->mutex);
+      mysql_mutex_lock(&server->mutex);
       if ((io= server->idle_list))
       {
 	server->idle_list= io->idle_next;
@@ -123,7 +123,7 @@ int federatedx_txn::acquire(FEDERATEDX_SHARE *share, bool readonly,
       io->txn_next= txn_list;
       txn_list= io;
 
-      pthread_mutex_unlock(&server->mutex);
+      mysql_mutex_unlock(&server->mutex);
     }
 
     if (io->busy)
@@ -188,10 +188,10 @@ void federatedx_txn::release_scan()
       /* reset some values */
       io->readonly= TRUE;
 
-      pthread_mutex_lock(&server->mutex);
+      mysql_mutex_lock(&server->mutex);
       io->idle_next= server->idle_list;
       server->idle_list= io;
-      pthread_mutex_unlock(&server->mutex);
+      mysql_mutex_unlock(&server->mutex);
       returned++;
     }
   }

storage/federatedx/ha_federatedx.cc

@@ -327,7 +327,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* Variables for federatedx share methods */
 static HASH federatedx_open_tables;             // To track open tables
 static HASH federatedx_open_servers;            // To track open servers
-pthread_mutex_t federatedx_mutex;               // To init the hash
+mysql_mutex_t federatedx_mutex;                 // To init the hash
 const char ident_quote_char= '`';               // Character for quoting
                                                 // identifiers
 const char value_quote_char= '\'';              // Character for quoting
@@ -374,6 +374,30 @@ federatedx_server_get_key(FEDERATEDX_SERVER *server, size_t *length,
   return server->key;
 }
 
+#ifdef HAVE_PSI_INTERFACE
+static PSI_mutex_key fe_key_mutex_federatedx, fe_key_mutex_FEDERATEDX_SERVER_mutex;
+
+static PSI_mutex_info all_federated_mutexes[]=
+{
+  { &fe_key_mutex_federatedx, "federatedx", PSI_FLAG_GLOBAL},
+  { &fe_key_mutex_FEDERATEDX_SERVER_mutex, "FEDERATED_SERVER::mutex", 0}
+};
+
+static void init_federated_psi_keys(void)
+{
+  const char* category= "federated";
+  int count;
+
+  if (PSI_server == NULL)
+    return;
+
+  count= array_elements(all_federated_mutexes);
+  PSI_server->register_mutex(category, all_federated_mutexes, count);
+}
+#else
+#define init_federated_psi_keys() /* no-op */
+#endif /* HAVE_PSI_INTERFACE */
+
 
 /*
   Initialize the federatedx handler.
@@ -390,6 +414,7 @@ federatedx_server_get_key(FEDERATEDX_SERVER *server, size_t *length,
 int federatedx_db_init(void *p)
 {
   DBUG_ENTER("federatedx_db_init");
+  init_federated_psi_keys();
   handlerton *federatedx_hton= (handlerton *)p;
   federatedx_hton->state= SHOW_OPTION_YES;
   /* Needed to work with old .frm files */
@@ -404,7 +429,8 @@ int federatedx_db_init(void *p)
   federatedx_hton->create= federatedx_create_handler;
   federatedx_hton->flags= HTON_ALTER_NOT_SUPPORTED | HTON_NO_PARTITION;
 
-  if (pthread_mutex_init(&federatedx_mutex, MY_MUTEX_INIT_FAST))
+  if (mysql_mutex_init(fe_key_mutex_federatedx,
+                       &federatedx_mutex, MY_MUTEX_INIT_FAST))
     goto error;
   if (!my_hash_init(&federatedx_open_tables, &my_charset_bin, 32, 0, 0,
                  (my_hash_get_key) federatedx_share_get_key, 0, 0) &&
@@ -414,7 +440,7 @@ int federatedx_db_init(void *p)
     DBUG_RETURN(FALSE);
   }
 
-  pthread_mutex_destroy(&federatedx_mutex);
+  mysql_mutex_destroy(&federatedx_mutex);
 error:
   DBUG_RETURN(TRUE);
 }
@@ -434,7 +460,7 @@ int federatedx_done(void *p)
 {
   my_hash_free(&federatedx_open_tables);
   my_hash_free(&federatedx_open_servers);
-  pthread_mutex_destroy(&federatedx_mutex);
+  mysql_mutex_destroy(&federatedx_mutex);
 
   return 0;
 }
@@ -1489,7 +1515,7 @@ static FEDERATEDX_SERVER *get_server(FEDERATEDX_SHARE *share, TABLE *table)
   String password(share->password ? share->password : "", &my_charset_bin);
   DBUG_ENTER("ha_federated.cc::get_server");
 
-  safe_mutex_assert_owner(&federatedx_mutex);
+  mysql_mutex_assert_owner(&federatedx_mutex);
 
   init_alloc_root(&mem_root, 4096, 4096);
 
@@ -1512,7 +1538,8 @@ static FEDERATEDX_SERVER *get_server(FEDERATEDX_SHARE *share, TABLE *table)
     if (my_hash_insert(&federatedx_open_servers, (uchar*) server))
       goto error;
 
-    pthread_mutex_init(&server->mutex, MY_MUTEX_INIT_FAST);
+    mysql_mutex_init(fe_key_mutex_FEDERATEDX_SERVER_mutex,
+                     &server->mutex, MY_MUTEX_INIT_FAST);
   }
   else
     free_root(&mem_root, MYF(0)); /* prevents memory leak */
@@ -1550,7 +1577,7 @@ static FEDERATEDX_SHARE *get_share(const char *table_name, TABLE *table)
   bzero(&tmp_share, sizeof(tmp_share));
   init_alloc_root(&mem_root, 256, 0);
 
-  pthread_mutex_lock(&federatedx_mutex);
+  mysql_mutex_lock(&federatedx_mutex);
 
   tmp_share.share_key= table_name;
   tmp_share.share_key_length= strlen(table_name);
@@ -1599,12 +1626,12 @@ static FEDERATEDX_SHARE *get_share(const char *table_name, TABLE *table)
     free_root(&mem_root, MYF(0)); /* prevents memory leak */
 
   share->use_count++;
-  pthread_mutex_unlock(&federatedx_mutex);
+  mysql_mutex_unlock(&federatedx_mutex);
 
   DBUG_RETURN(share);
 
 error:
-  pthread_mutex_unlock(&federatedx_mutex);
+  mysql_mutex_unlock(&federatedx_mutex);
   free_root(&mem_root, MYF(0));
   DBUG_RETURN(NULL);
 }
@@ -1615,10 +1642,10 @@ static int free_server(federatedx_txn *txn, FEDERATEDX_SERVER *server)
   bool destroy;
   DBUG_ENTER("free_server");
 
-  pthread_mutex_lock(&federatedx_mutex);
+  mysql_mutex_lock(&federatedx_mutex);
   if ((destroy= !--server->use_count))
     my_hash_delete(&federatedx_open_servers, (uchar*) server);
-  pthread_mutex_unlock(&federatedx_mutex);
+  mysql_mutex_unlock(&federatedx_mutex);
 
   if (destroy)
   {
@@ -1634,7 +1661,7 @@ static int free_server(federatedx_txn *txn, FEDERATEDX_SERVER *server)
 
     DBUG_ASSERT(server->io_count == 0);
 
-    pthread_mutex_destroy(&server->mutex);
+    mysql_mutex_destroy(&server->mutex);
     mem_root= server->mem_root;
     free_root(&mem_root, MYF(0));
   }
@@ -1654,10 +1681,10 @@ static int free_share(federatedx_txn *txn, FEDERATEDX_SHARE *share)
   bool destroy;
   DBUG_ENTER("free_share");
 
-  pthread_mutex_lock(&federatedx_mutex);
+  mysql_mutex_lock(&federatedx_mutex);
   if ((destroy= !--share->use_count))
     my_hash_delete(&federatedx_open_tables, (uchar*) share);
-  pthread_mutex_unlock(&federatedx_mutex);
+  mysql_mutex_unlock(&federatedx_mutex);
 
   if (destroy)
   {
@@ -3350,9 +3377,9 @@ int ha_federatedx::create(const char *name, TABLE *table_arg,
     the remote server. To ensure that no new FEDERATEDX_SERVER
     instance is created, we pass NULL in get_server() TABLE arg.
   */
-  pthread_mutex_lock(&federatedx_mutex);
+  mysql_mutex_lock(&federatedx_mutex);
   tmp_share.s= get_server(&tmp_share, NULL);
-  pthread_mutex_unlock(&federatedx_mutex);
+  mysql_mutex_unlock(&federatedx_mutex);
 
   if (tmp_share.s)
   {
@@ -3379,8 +3406,9 @@ int ha_federatedx::create(const char *name, TABLE *table_arg,
     fill_server(thd->mem_root, &server, &tmp_share, create_info->table_charset);
 
 #ifndef DBUG_OFF
-    pthread_mutex_init(&server.mutex, MY_MUTEX_INIT_FAST);
+    mysql_mutex_init(fe_key_mutex_FEDERATEDX_SERVER_mutex,
-    pthread_mutex_lock(&server.mutex);
+                     &server.mutex, MY_MUTEX_INIT_FAST);
+    mysql_mutex_lock(&server.mutex);
 #endif
 
     tmp_io= federatedx_io::construct(thd->mem_root, &server);
@@ -3388,8 +3416,8 @@ int ha_federatedx::create(const char *name, TABLE *table_arg,
     retval= test_connection(thd, tmp_io, &tmp_share);
 
 #ifndef DBUG_OFF
-    pthread_mutex_unlock(&server.mutex);
+    mysql_mutex_unlock(&server.mutex);
-    pthread_mutex_destroy(&server.mutex);
+    mysql_mutex_destroy(&server.mutex);
 #endif
 
     delete tmp_io;

storage/federatedx/ha_federatedx.h

@@ -66,7 +66,7 @@ typedef struct st_fedrated_server {
 
   const char *csname;
 
-  pthread_mutex_t mutex;
+  mysql_mutex_t mutex;
   federatedx_io *idle_list;
 } FEDERATEDX_SERVER;
 

storage/maria/CMakeLists.txt

@@ -32,7 +32,7 @@ SET(ARIA_SOURCES ma_init.c ma_open.c ma_extra.c ma_info.c ma_rkey.c
             ma_keycache.c ma_preload.c ma_ft_parser.c 
             ma_ft_update.c ma_ft_boolean_search.c 
             ma_ft_nlq_search.c ft_maria.c ma_sort.c 
-            ha_maria.cc trnman.c lockman.c tablockman.c 
+            ha_maria.cc trnman.c lockman.c
             ma_rt_index.c ma_rt_key.c ma_rt_mbr.c ma_rt_split.c 
             ma_sp_key.c ma_control_file.c ma_loghandler.c 
             ma_pagecache.c ma_pagecaches.c compat_aliases.cc compat_aliases.h

storage/maria/ha_maria.cc

@@ -280,6 +280,93 @@ static MYSQL_SYSVAR_BOOL(used_for_temp_tables,
        "Whether temporary tables should be MyISAM or Aria", 0, 0,
        1);
 
+#ifdef HAVE_PSI_INTERFACE
+
+static PSI_mutex_info all_aria_mutexes[]=
+{
+  { &key_THR_LOCK_maria, "THR_LOCK_maria", PSI_FLAG_GLOBAL},
+  { &key_LOCK_soft_sync, "LOCK_soft_sync", PSI_FLAG_GLOBAL},
+  { &key_LOCK_trn_list, "LOCK_trn_list", PSI_FLAG_GLOBAL},
+  { &key_SHARE_BITMAP_lock, "SHARE::bitmap::bitmap_lock", 0},
+  { &key_SORT_INFO_mutex, "SORT_INFO::mutex", 0},
+  { &key_TRANSLOG_BUFFER_mutex, "TRANSLOG_BUFFER::mutex", 0},
+  { &key_TRANSLOG_DESCRIPTOR_dirty_buffer_mask_lock, "TRANSLOG_DESCRIPTOR::dirty_buffer_mask_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_sent_to_disk_lock, "TRANSLOG_DESCRIPTOR::sent_to_disk_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_log_flush_lock, "TRANSLOG_DESCRIPTOR::log_flush_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_file_header_lock, "TRANSLOG_DESCRIPTOR::file_header_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_unfinished_files_lock, "TRANSLOG_DESCRIPTOR::unfinished_files_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_purger_lock, "TRANSLOG_DESCRIPTOR::purger_lock", 0},
+  { &key_SHARE_intern_lock, "SHARE::intern_lock", 0},
+  { &key_SHARE_key_del_lock, "SHARE::key_del_lock", 0},
+  { &key_SHARE_close_lock, "SHARE::close_lock", 0},
+  { &key_SERVICE_THREAD_CONTROL_lock, "SERVICE_THREAD_CONTROL::LOCK_control", 0},
+  { &key_TRN_state_lock, "TRN::state_lock", 0},
+  { &key_PAGECACHE_cache_lock, "PAGECACHE::cache_lock", 0}
+};
+
+static PSI_cond_info all_aria_conds[]=
+{
+  { &key_COND_soft_sync, "COND_soft_sync", PSI_FLAG_GLOBAL},
+  { &key_SHARE_key_del_cond, "SHARE::key_del_cond", 0},
+  { &key_SERVICE_THREAD_CONTROL_cond, "SERVICE_THREAD_CONTROL::COND_control", 0},
+  { &key_SORT_INFO_cond, "SORT_INFO::cond", 0},
+  { &key_SHARE_BITMAP_cond, "BITMAP::bitmap_cond", 0},
+  { &key_TRANSLOG_BUFFER_waiting_filling_buffer, "TRANSLOG_BUFFER::waiting_filling_buffer", 0},
+  { &key_TRANSLOG_BUFFER_prev_sent_to_disk_cond, "TRANSLOG_BUFFER::prev_sent_to_disk_cond", 0},
+  { &key_TRANSLOG_DESCRIPTOR_log_flush_cond, "TRANSLOG_DESCRIPTOR::log_flush_cond", 0},
+  { &key_TRANSLOG_DESCRIPTOR_new_goal_cond, "TRANSLOG_DESCRIPTOR::new_goal_cond", 0}
+};
+
+static PSI_rwlock_info all_aria_rwlocks[]=
+{
+  { &key_KEYINFO_root_lock, "KEYINFO::root_lock", 0},
+  { &key_SHARE_mmap_lock, "SHARE::mmap_lock", 0},
+  { &key_TRANSLOG_DESCRIPTOR_open_files_lock, "TRANSLOG_DESCRIPTOR::open_files_lock", 0}
+};
+
+static PSI_thread_info all_aria_threads[]=
+{
+  { &key_thread_checkpoint, "checkpoint_background", PSI_FLAG_GLOBAL},
+  { &key_thread_soft_sync, "soft_sync_background", PSI_FLAG_GLOBAL},
+  { &key_thread_find_all_keys, "thr_find_all_keys", 0}
+};
+
+static PSI_file_info all_aria_files[]=
+{
+  { &key_file_translog, "translog", 0},
+  { &key_file_kfile, "MAI", 0},
+  { &key_file_dfile, "MAD", 0},
+  { &key_file_control, "control", PSI_FLAG_GLOBAL}
+};
+
+
+static void init_aria_psi_keys(void)
+{
+  const char* category= "aria";
+  int count;
+
+  if (PSI_server == NULL)
+    return;
+
+  count= array_elements(all_aria_mutexes);
+  PSI_server->register_mutex(category, all_aria_mutexes, count);
+
+  count= array_elements(all_aria_rwlocks);
+  PSI_server->register_rwlock(category, all_aria_rwlocks, count);
+
+  count= array_elements(all_aria_conds);
+  PSI_server->register_cond(category, all_aria_conds, count);
+
+  count= array_elements(all_aria_threads);
+  PSI_server->register_thread(category, all_aria_threads, count);
+
+  count= array_elements(all_aria_files);
+  PSI_server->register_file(category, all_aria_files, count);
+}
+#else
+#define init_aria_psi_keys() /* no-op */
+#endif /* HAVE_PSI_INTERFACE */
+
 /*****************************************************************************
 ** MARIA tables
 *****************************************************************************/
@@ -906,7 +993,7 @@ int ha_maria::net_read_dump(NET * net)
   int data_fd= file->dfile.file;
   int error= 0;
 
-  my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
+  mysql_file_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
   for (;;)
   {
     ulong packet_len= my_net_read(net);
@@ -918,7 +1005,7 @@ int ha_maria::net_read_dump(NET * net)
       error= -1;
       goto err;
     }
-    if (my_write(data_fd, (uchar *) net->read_pos, (uint) packet_len,
+    if (mysql_file_write(data_fd, (uchar *) net->read_pos, (uint) packet_len,
                  MYF(MY_WME | MY_FNABP)))
     {
       error= errno;
@@ -942,10 +1029,10 @@ int ha_maria::dump(THD * thd, int fd)
     return ENOMEM;
 
   int error= 0;
-  my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
+  mysql_file_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
   for (; bytes_to_read > 0;)
   {
-    size_t bytes= my_read(data_fd, buf, block_size, MYF(MY_WME));
+    size_t bytes= mysql_file_read(data_fd, buf, block_size, MYF(MY_WME));
     if (bytes == MY_FILE_ERROR)
     {
       error= errno;
@@ -954,7 +1041,7 @@ int ha_maria::dump(THD * thd, int fd)
 
     if (fd >= 0)
     {
-      if (my_write(fd, buf, bytes, MYF(MY_WME | MY_FNABP)))
+      if (mysql_file_write(fd, buf, bytes, MYF(MY_WME | MY_FNABP)))
       {
         error= errno ? errno : EPIPE;
         goto err;
@@ -1156,7 +1243,7 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt)
         (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);
       DBUG_PRINT("info", ("Reseting crashed state"));
       share->state.changed&= ~(STATE_CHANGED | STATE_CRASHED |
                                STATE_CRASHED_ON_REPAIR | STATE_IN_REPAIR);
@@ -1164,7 +1251,7 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt)
         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);
     }
@@ -1213,9 +1300,9 @@ int ha_maria::analyze(THD *thd, HA_CHECK_OPT * check_opt)
   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);
@@ -1300,9 +1387,9 @@ int ha_maria::zerofill(THD * thd, HA_CHECK_OPT *check_opt)
 
   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;
 }
@@ -1459,7 +1546,7 @@ int ha_maria::repair(THD *thd, HA_CHECK *param, bool do_optimize)
     }
   }
   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))
@@ -1500,7 +1587,7 @@ int ha_maria::repair(THD *thd, HA_CHECK *param, bool do_optimize)
     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);
@@ -3064,7 +3151,7 @@ bool maria_show_status(handlerton *hton,
       const char error[]= "can't stat";
       char object[SHOW_MSG_LEN];
       file= translog_filename_by_fileno(i, path);
-      if (!(stat= my_stat(file, &stat_buff, MYF(0))))
+      if (!(stat= mysql_file_stat(key_file_translog, file, &stat_buff, MYF(0))))
       {
         status= error;
         status_len= sizeof(error) - 1;
@@ -3119,7 +3206,7 @@ static my_bool translog_callback_delete_all(const char *directory,
 {
   char complete_name[FN_REFLEN];
   fn_format(complete_name, filename, directory, "", MYF(MY_UNPACK_FILENAME));
-  return my_delete(complete_name, MYF(MY_WME));
+  return mysql_file_delete(key_file_translog, complete_name, MYF(MY_WME));
 }
 
 

storage/maria/ma_bitmap.c

@@ -242,8 +242,10 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file)
   bitmap->sizes[6]= max_page_size - max_page_size * 80 / 100;
   bitmap->sizes[7]= 0;
 
-  pthread_mutex_init(&share->bitmap.bitmap_lock, MY_MUTEX_INIT_SLOW);
+  mysql_mutex_init(key_SHARE_BITMAP_lock,
-  pthread_cond_init(&share->bitmap.bitmap_cond, 0);
+                   &share->bitmap.bitmap_lock, MY_MUTEX_INIT_SLOW);
+  mysql_cond_init(key_SHARE_BITMAP_cond,
+                  &share->bitmap.bitmap_cond, 0);
 
   _ma_bitmap_reset_cache(share);
 
@@ -267,9 +269,9 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file)
 my_bool _ma_bitmap_end(MARIA_SHARE *share)
 {
   my_bool res= _ma_bitmap_flush(share);
-  safe_mutex_assert_owner(&share->close_lock);
+  mysql_mutex_assert_owner(&share->close_lock);
-  pthread_mutex_destroy(&share->bitmap.bitmap_lock);
+  mysql_mutex_destroy(&share->bitmap.bitmap_lock);
-  pthread_cond_destroy(&share->bitmap.bitmap_cond);
+  mysql_cond_destroy(&share->bitmap.bitmap_cond);
   delete_dynamic(&share->bitmap.pinned_pages);
   my_free(share->bitmap.map);
   share->bitmap.map= 0;
@@ -309,13 +311,13 @@ my_bool _ma_bitmap_flush(MARIA_SHARE *share)
   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)
     {
       res= write_changed_bitmap(share, &share->bitmap);
       share->bitmap.changed= 0;
     }
-    pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+    mysql_mutex_unlock(&share->bitmap.bitmap_lock);
   }
   DBUG_RETURN(res);
 }
@@ -353,7 +355,7 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE *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->changed_not_flushed)
   {
     bitmap->flush_all_requested++;
@@ -361,7 +363,7 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE *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
     DBUG_ASSERT(bitmap->flush_all_requested == 1);
@@ -399,9 +401,9 @@ my_bool _ma_bitmap_flush_all(MARIA_SHARE *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);
 }
 
@@ -429,19 +431,19 @@ void _ma_bitmap_lock(MARIA_SHARE *share)
   if (!share->now_transactional)
     DBUG_VOID_RETURN;
 
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  mysql_mutex_lock(&bitmap->bitmap_lock);
   bitmap->flush_all_requested++;
   while (bitmap->non_flushable)
   {
     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);
   }
   /*
     Ensure that _ma_bitmap_flush_all() and _ma_bitmap_lock() are blocked.
     ma_bitmap_flushable() is blocked thanks to 'flush_all_requested'.
   */
   bitmap->non_flushable= 1;
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  mysql_mutex_unlock(&bitmap->bitmap_lock);
   DBUG_VOID_RETURN;
 }
   
@@ -461,11 +463,11 @@ void _ma_bitmap_unlock(MARIA_SHARE *share)
     DBUG_VOID_RETURN;
   DBUG_ASSERT(bitmap->flush_all_requested > 0 && bitmap->non_flushable == 1);
 
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  mysql_mutex_lock(&bitmap->bitmap_lock);
   bitmap->flush_all_requested--;
   bitmap->non_flushable= 0;
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  mysql_mutex_unlock(&bitmap->bitmap_lock);
-  pthread_cond_broadcast(&bitmap->bitmap_cond);
+  mysql_cond_broadcast(&bitmap->bitmap_cond);
   DBUG_VOID_RETURN;
 }
 
@@ -1768,7 +1770,7 @@ my_bool _ma_bitmap_find_place(MARIA_HA *info, MARIA_ROW *row,
   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)
   {
@@ -1830,7 +1832,7 @@ end:
   res= 0;
 
 abort:
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  mysql_mutex_unlock(&share->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -1874,7 +1876,7 @@ my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *row,
   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
@@ -1926,7 +1928,7 @@ end:
   res= 0;
 
 abort:
-  pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+  mysql_mutex_unlock(&share->bitmap.bitmap_lock);
   DBUG_RETURN(res);
 }
 
@@ -2067,7 +2069,7 @@ my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info,
   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);
@@ -2145,7 +2147,7 @@ my_bool _ma_bitmap_set_full_page_bits(MARIA_HA *info,
   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 (page == bitmap_page ||
@@ -2234,7 +2236,7 @@ void _ma_bitmap_flushable(MARIA_HA *info, int non_flushable_inc)
     DBUG_VOID_RETURN;
 
   bitmap= &share->bitmap;
-  pthread_mutex_lock(&bitmap->bitmap_lock);
+  mysql_mutex_lock(&bitmap->bitmap_lock);
 
   if (non_flushable_inc == -1)
   {
@@ -2251,11 +2253,11 @@ void _ma_bitmap_flushable(MARIA_HA *info, int non_flushable_inc)
       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);
     info->non_flushable_state= 0;
     DBUG_VOID_RETURN;
   }
@@ -2275,11 +2277,11 @@ void _ma_bitmap_flushable(MARIA_HA *info, int non_flushable_inc)
       here.
     */
     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);
   }
   bitmap->non_flushable++;
   DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
-  pthread_mutex_unlock(&bitmap->bitmap_lock);
+  mysql_mutex_unlock(&bitmap->bitmap_lock);
   info->non_flushable_state= 1;
   DBUG_VOID_RETURN;
 }
@@ -2329,7 +2331,7 @@ my_bool _ma_bitmap_release_unused(MARIA_HA *info, MARIA_BITMAP_BLOCKS *blocks)
   */
   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)
@@ -2409,17 +2411,17 @@ my_bool _ma_bitmap_release_unused(MARIA_HA *info, MARIA_BITMAP_BLOCKS *blocks)
       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);
 }
 
@@ -2448,7 +2450,7 @@ my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents,
   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);
@@ -2462,12 +2464,12 @@ my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents,
                                  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);
 }
 
@@ -2497,12 +2499,12 @@ my_bool _ma_bitmap_set(MARIA_HA *info, pgcache_page_no_t page, my_bool head,
   DBUG_PRINT("enter", ("page: %lu  head: %d  empty_space: %u",
                        (ulong) page, head, empty_space));
 
-  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);
 }
 
@@ -2619,8 +2621,8 @@ int _ma_bitmap_create_first(MARIA_SHARE *share)
   */
   int4store(marker, MARIA_NO_CRC_BITMAP_PAGE);
 
-  if (my_chsize(file, block_size - sizeof(marker),
+  if (mysql_file_chsize(file, block_size - sizeof(marker),
-                0, MYF(MY_WME)) ||
+                        0, MYF(MY_WME)) ||
       my_pwrite(file, marker, sizeof(marker),
                 block_size - sizeof(marker),
                 MYF(MY_NABP | MY_WME)))

storage/maria/ma_blockrec.c

@@ -440,9 +440,9 @@ my_bool _ma_once_end_block_record(MARIA_SHARE *share)
       becoming unknown to Checkpoint.
     */
     if (share->now_transactional &&
-        my_sync(share->bitmap.file.file, MYF(MY_WME)))
+        mysql_file_sync(share->bitmap.file.file, MYF(MY_WME)))
       res= 1;
-    if (my_close(share->bitmap.file.file, MYF(MY_WME)))
+    if (mysql_file_close(share->bitmap.file.file, MYF(MY_WME)))
       res= 1;
     /*
       Trivial assignment to guard against multiple invocations
@@ -2367,10 +2367,10 @@ static my_bool extent_to_bitmap_blocks(MARIA_HA *info,
     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, 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;
@@ -2532,10 +2532,10 @@ static my_bool free_full_page_range(MARIA_HA *info, pgcache_page_no_t page,
                               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);
 }
 
@@ -6518,10 +6518,10 @@ uint _ma_apply_redo_free_blocks(MARIA_HA *info,
     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);
@@ -6600,9 +6600,9 @@ uint _ma_apply_redo_free_head_or_tail(MARIA_HA *info, LSN lsn,
     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);
@@ -6795,10 +6795,10 @@ uint _ma_apply_redo_insert_row_blobs(MARIA_HA *info,
           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;
     }

storage/maria/ma_cache.c

@@ -49,7 +49,7 @@ my_bool _ma_read_cache(IO_CACHE *info, uchar *buff, my_off_t pos,
     if ((my_off_t) read_length > (my_off_t) (info->pos_in_file-pos))
       read_length=(uint) (info->pos_in_file-pos);
     info->seek_not_done=1;
-    if (my_pread(info->file,buff,read_length,pos,MYF(MY_NABP)))
+    if (mysql_file_pread(info->file,buff,read_length,pos,MYF(MY_NABP)))
       DBUG_RETURN(1);
     if (!(length-=read_length))
       DBUG_RETURN(0);
@@ -88,7 +88,7 @@ my_bool _ma_read_cache(IO_CACHE *info, uchar *buff, my_off_t pos,
   else
   {
     info->seek_not_done=1;
-    if ((read_length=my_pread(info->file,buff,length,pos,MYF(0))) == length)
+    if ((read_length=mysql_file_pread(info->file,buff,length,pos,MYF(0))) == length)
       DBUG_RETURN(0);
   }
   if (!(flag & READING_HEADER) || (int) read_length == -1 ||

storage/maria/ma_check.c

@@ -226,7 +226,7 @@ int maria_chk_del(HA_CHECK *param, register MARIA_HA *info,
 	printf(" %9s",llstr(next_link,buff));
       if (next_link >= share->state.state.data_file_length)
 	goto wrong;
-      if (my_pread(info->dfile.file, (uchar*) buff, delete_link_length,
+      if (mysql_file_pread(info->dfile.file, (uchar*) buff, delete_link_length,
 		   next_link,MYF(MY_NABP)))
       {
 	if (test_flag & T_VERBOSE) puts("");
@@ -399,7 +399,7 @@ int maria_chk_size(HA_CHECK *param, register MARIA_HA *info)
                                     FLUSH_FORCE_WRITE, FLUSH_FORCE_WRITE)))
     _ma_check_print_error(param, "Failed to flush data or index file");
 
-  size= my_seek(share->kfile.file, 0L, MY_SEEK_END, MYF(MY_THREADSAFE));
+  size= mysql_file_seek(share->kfile.file, 0L, MY_SEEK_END, MYF(MY_THREADSAFE));
   if ((skr=(my_off_t) share->state.state.key_file_length) != size)
   {
     /* Don't give error if file generated by mariapack */
@@ -423,7 +423,7 @@ int maria_chk_size(HA_CHECK *param, register MARIA_HA *info)
 			   llstr(share->state.state.key_file_length,buff),
 			   llstr(share->base.max_key_file_length-1,buff));
 
-  size= my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
+  size= mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
   skr=(my_off_t) share->state.state.data_file_length;
   if (share->options & HA_OPTION_COMPRESS_RECORD)
     skr+= MEMMAP_EXTRA_MARGIN;
@@ -671,7 +671,7 @@ static int chk_index_down(HA_CHECK *param, MARIA_HA *info,
   {
     /* purecov: begin tested */
     /* Give it a chance to fit in the real file size. */
-    my_off_t max_length= my_seek(info->s->kfile.file, 0L, MY_SEEK_END,
+    my_off_t max_length= mysql_file_seek(info->s->kfile.file, 0L, MY_SEEK_END,
                                  MYF(MY_THREADSAFE));
     _ma_check_print_error(param, "Invalid key block position: %s  "
                           "key block size: %u  file_length: %s",
@@ -2315,7 +2315,7 @@ static int initialize_variables_for_repair(HA_CHECK *param,
     return 1;
 
   /* calculate max_records */
-  sort_info->filelength= my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
+  sort_info->filelength= mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
   if ((param->testflag & T_CREATE_MISSING_KEYS) ||
       sort_info->org_data_file_type == COMPRESSED_RECORD)
     sort_info->max_records= share->state.state.records;
@@ -2536,7 +2536,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
   if (!rep_quick)
   {
     /* Get real path for data file */
-    if ((new_file= my_create(fn_format(param->temp_filename,
+    if ((new_file= mysql_file_create(key_file_dfile, fn_format(param->temp_filename,
                                        share->data_file_name.str, "",
                                        DATA_TMP_EXT, 2+4),
                              0,param->tmpfile_createflag,
@@ -2681,7 +2681,8 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
   {
     fputs("          \r",stdout); fflush(stdout);
   }
-  if (my_chsize(share->kfile.file, share->state.state.key_file_length, 0, MYF(0)))
+  if (mysql_file_chsize(share->kfile.file,
+                        share->state.state.key_file_length, 0, MYF(0)))
   {
     _ma_check_print_warning(param,
 			   "Can't change size of indexfile, error: %d",
@@ -2740,7 +2741,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
 
     /* Replace the actual file with the temporary file */
     if (new_file >= 0)
-      my_close(new_file, MYF(MY_WME));
+      mysql_file_close(new_file, MYF(MY_WME));
     new_file= -1;
     change_data_file_descriptor(info, -1);
     if (maria_change_to_newfile(share->data_file_name.str, MARIA_NAME_DEXT,
@@ -2798,8 +2799,8 @@ err:
     }
     if (new_file >= 0)
     {
-      my_close(new_file,MYF(0));
+      mysql_file_close(new_file,MYF(0));
-      my_delete(param->temp_filename, MYF(MY_WME));
+      mysql_file_delete(key_file_dfile, param->temp_filename, MYF(MY_WME));
     }
     maria_mark_crashed_on_repair(info);
   }
@@ -3011,7 +3012,7 @@ int maria_sort_index(HA_CHECK *param, register MARIA_HA *info, char *name)
 
   /* Get real path for index file */
   fn_format(param->temp_filename,name,"", MARIA_NAME_IEXT,2+4+32);
-  if ((new_file=my_create(fn_format(param->temp_filename,param->temp_filename,
+  if ((new_file=mysql_file_create(key_file_kfile, fn_format(param->temp_filename,param->temp_filename,
 				    "", INDEX_TMP_EXT,2+4),
 			  0,param->tmpfile_createflag,MYF(0))) <= 0)
   {
@@ -3054,11 +3055,11 @@ int maria_sort_index(HA_CHECK *param, register MARIA_HA *info, char *name)
 	/* 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);
-  my_close(share->kfile.file, MYF(MY_WME));
+  mysql_file_close(share->kfile.file, MYF(MY_WME));
   share->kfile.file = -1;
-  pthread_mutex_unlock(&share->intern_lock);
+  mysql_mutex_unlock(&share->intern_lock);
-  my_close(new_file, MYF(MY_WME));
+  mysql_file_close(new_file, MYF(MY_WME));
   if (maria_change_to_newfile(share->index_file_name.str, MARIA_NAME_IEXT,
                               INDEX_TMP_EXT, sync_dir) ||
       _ma_open_keyfile(share))
@@ -3091,9 +3092,9 @@ int maria_sort_index(HA_CHECK *param, register MARIA_HA *info, char *name)
   DBUG_RETURN(0);
 
 err:
-  my_close(new_file, MYF(MY_WME));
+  mysql_file_close(new_file, MYF(MY_WME));
 err2:
-  my_delete(param->temp_filename,MYF(MY_WME));
+  mysql_file_delete(key_file_dfile, param->temp_filename,MYF(MY_WME));
   DBUG_RETURN(-1);
 } /* maria_sort_index */
 
@@ -3526,16 +3527,16 @@ int maria_filecopy(HA_CHECK *param, File to,File from,my_off_t start,
     buff=tmp_buff; buff_length=IO_SIZE;
   }
 
-  my_seek(from, start, MY_SEEK_SET,MYF(0));
+  mysql_file_seek(from, start, MY_SEEK_SET,MYF(0));
   while (length > buff_length)
   {
-    if (my_read(from, buff, buff_length, MYF(MY_NABP)) ||
+    if (mysql_file_read(from, buff, buff_length, MYF(MY_NABP)) ||
-	my_write(to,  buff, buff_length, param->myf_rw))
+	mysql_file_write(to,  buff, buff_length, param->myf_rw))
       goto err;
     length-= buff_length;
   }
-  if (my_read(from, buff, (size_t) length,MYF(MY_NABP)) ||
+  if (mysql_file_read(from, buff, (size_t) length,MYF(MY_NABP)) ||
-      my_write(to,  buff, (size_t) length,param->myf_rw))
+      mysql_file_write(to,  buff, (size_t) length,param->myf_rw))
     goto err;
   if (buff != tmp_buff)
     my_free(buff);
@@ -3609,7 +3610,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
   if (!rep_quick)
   {
     /* Get real path for data file */
-    if ((new_file=my_create(fn_format(param->temp_filename,
+    if ((new_file=mysql_file_create(key_file_dfile, fn_format(param->temp_filename,
                                       share->data_file_name.str, "",
                                       DATA_TMP_EXT, 2+4),
                             0,param->tmpfile_createflag,
@@ -3871,7 +3872,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
       /* Replace the actual file with the temporary file */
       if (new_file >= 0)
       {
-        my_close(new_file, MYF(MY_WME));
+        mysql_file_close(new_file, MYF(MY_WME));
         new_file= -1;
       }
       change_data_file_descriptor(info, -1);
@@ -3929,7 +3930,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
       skr=share->base.reloc*share->base.min_pack_length;
 #endif
     if (skr != sort_info.filelength)
-      if (my_chsize(info->dfile.file, skr, 0, MYF(0)))
+      if (mysql_file_chsize(info->dfile.file, skr, 0, MYF(0)))
 	_ma_check_print_warning(param,
 			       "Can't change size of datafile,  error: %d",
 			       my_errno);
@@ -3938,8 +3939,8 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
   if (param->testflag & T_CALC_CHECKSUM)
     share->state.state.checksum=param->glob_crc;
 
-  if (my_chsize(share->kfile.file, share->state.state.key_file_length, 0,
+  if (mysql_file_chsize(share->kfile.file,
-                MYF(0)))
+                        share->state.state.key_file_length, 0, MYF(0)))
     _ma_check_print_warning(param,
 			   "Can't change size of indexfile, error: %d",
 			   my_errno);
@@ -3979,8 +3980,8 @@ err:
     }
     if (new_file >= 0)
     {
-      my_close(new_file, MYF(0));
+      mysql_file_close(new_file, MYF(0));
-      my_delete(param->temp_filename, MYF(MY_WME));
+      mysql_file_delete(key_file_dfile, param->temp_filename, MYF(MY_WME));
     }
     maria_mark_crashed_on_repair(info);
   }
@@ -4139,8 +4140,8 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
   DBUG_PRINT("info", ("is quick repair: %d", (int) rep_quick));
 
   /* Initialize pthread structures before goto err. */
-  pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_SORT_INFO_mutex, &sort_info.mutex, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(&sort_info.cond, 0);
+  mysql_cond_init(key_SORT_INFO_cond, &sort_info.cond, 0);
 
   if (!(sort_info.key_block=
 	alloc_key_blocks(param, (uint) param->sort_key_blocks,
@@ -4165,7 +4166,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
   if (!rep_quick)
   {
     /* Get real path for data file */
-    if ((new_file= my_create(fn_format(param->temp_filename,
+    if ((new_file= mysql_file_create(key_file_dfile, fn_format(param->temp_filename,
                                        share->data_file_name.str, "",
                                        DATA_TMP_EXT,
                                        2+4),
@@ -4310,7 +4311,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
     goto err;
 
   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
@@ -4358,9 +4359,9 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
 #else
       param->sort_buffer_length*sort_param[i].key_length/total_key_length;
 #endif
-    if (pthread_create(&sort_param[i].thr, &thr_attr,
+    if (mysql_thread_create(key_thread_find_all_keys,
-		       _ma_thr_find_all_keys,
+                            &sort_param[i].thr, &thr_attr,
-		       (void *) (sort_param+i)))
+	                    _ma_thr_find_all_keys, (void *) (sort_param+i)))
     {
       _ma_check_print_error(param,"Cannot start a repair thread");
       /* Cleanup: Detach from the share. Avoid others to be blocked. */
@@ -4376,8 +4377,8 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
 
   /* waiting for all threads to finish */
   while (sort_info.threads_running)
-    pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
+    mysql_cond_wait(&sort_info.cond, &sort_info.mutex);
-  pthread_mutex_unlock(&sort_info.mutex);
+  mysql_mutex_unlock(&sort_info.mutex);
 
   if ((got_error= _ma_thr_write_keys(sort_param)))
   {
@@ -4415,7 +4416,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
       Exchange the data file descriptor of the table, so that we use the
       new file from now on.
      */
-    my_close(info->dfile.file, MYF(0));
+    mysql_file_close(info->dfile.file, MYF(0));
     info->dfile.file= new_file;
     share->pack.header_length=(ulong) new_header_length;
   }
@@ -4443,7 +4444,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
       skr=share->base.reloc*share->base.min_pack_length;
 #endif
     if (skr != sort_info.filelength)
-      if (my_chsize(info->dfile.file, skr, 0, MYF(0)))
+      if (mysql_file_chsize(info->dfile.file, skr, 0, MYF(0)))
 	_ma_check_print_warning(param,
 			       "Can't change size of datafile,  error: %d",
 			       my_errno);
@@ -4451,8 +4452,8 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
   if (param->testflag & T_CALC_CHECKSUM)
     share->state.state.checksum=param->glob_crc;
 
-  if (my_chsize(share->kfile.file, share->state.state.key_file_length, 0,
+  if (mysql_file_chsize(share->kfile.file,
-                MYF(0)))
+                        share->state.state.key_file_length, 0, MYF(0)))
     _ma_check_print_warning(param,
 			   "Can't change size of indexfile, error: %d",
                             my_errno);
@@ -4496,7 +4497,7 @@ err:
     /* Replace the actual file with the temporary file */
     if (new_file >= 0)
     {
-      my_close(new_file,MYF(0));
+      mysql_file_close(new_file,MYF(0));
       info->dfile.file= new_file= -1;
       if (maria_change_to_newfile(share->data_file_name.str, MARIA_NAME_DEXT,
                                   DATA_TMP_EXT,
@@ -4514,8 +4515,8 @@ err:
     (void)_ma_flush_table_files_before_swap(param, info);
     if (new_file >= 0)
     {
-      my_close(new_file,MYF(0));
+      mysql_file_close(new_file,MYF(0));
-      my_delete(param->temp_filename, MYF(MY_WME));
+      mysql_file_delete(key_file_dfile, param->temp_filename, MYF(MY_WME));
       if (info->dfile.file == new_file)
 	info->dfile.file= -1;
     }
@@ -4528,8 +4529,8 @@ err:
     share->state.changed&= ~(STATE_NOT_OPTIMIZED_ROWS | STATE_NOT_ZEROFILLED |
                              STATE_NOT_MOVABLE);
 
-  pthread_cond_destroy (&sort_info.cond);
+  mysql_cond_destroy (&sort_info.cond);
-  pthread_mutex_destroy(&sort_info.mutex);
+  mysql_mutex_destroy(&sort_info.mutex);
 
   /* If caller had disabled logging it's not up to us to re-enable it */
   if (reenable_logging)
@@ -5824,10 +5825,10 @@ int maria_test_if_almost_full(MARIA_HA *info)
 
   if (share->options & HA_OPTION_COMPRESS_RECORD)
     return 0;
-  return my_seek(share->kfile.file, 0L, MY_SEEK_END,
+  return mysql_file_seek(share->kfile.file, 0L, MY_SEEK_END,
                  MYF(MY_THREADSAFE))/10*9 >
     (my_off_t) share->base.max_key_file_length ||
-    my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) / 10 * 9 >
+    mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) / 10 * 9 >
     (my_off_t) share->base.max_data_file_length;
 }
 
@@ -5921,7 +5922,7 @@ int maria_recreate_table(HA_CHECK *param, MARIA_HA **org_info, char *filename)
     keyseg+=u_ptr->keysegs+1;
   }
 
-  file_length=(ulonglong) my_seek(info.dfile.file, 0L, MY_SEEK_END, MYF(0));
+  file_length=(ulonglong) mysql_file_seek(info.dfile.file, 0L, MY_SEEK_END, MYF(0));
   if (share.options & HA_OPTION_COMPRESS_RECORD)
     share.base.records=max_records=info.state->records;
   else if (share.base.min_pack_length)
@@ -6430,7 +6431,7 @@ static void restore_data_file_type(MARIA_SHARE *share)
 
 static void change_data_file_descriptor(MARIA_HA *info, File new_file)
 {
-  my_close(info->dfile.file, MYF(MY_WME));
+  mysql_file_close(info->dfile.file, MYF(MY_WME));
   info->dfile.file= info->s->bitmap.file.file= new_file;
   _ma_bitmap_reset_cache(info->s);
 }

storage/maria/ma_checkpoint.c

@@ -41,9 +41,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 control structure for checkpoint background thread */
 static MA_SERVICE_THREAD_CONTROL checkpoint_control=
   {THREAD_DEAD, FALSE, &LOCK_checkpoint, &COND_checkpoint};
@@ -109,7 +109,7 @@ int ma_checkpoint_execute(CHECKPOINT_LEVEL level, my_bool no_wait)
   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_LEVEL level, my_bool no_wait)
         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);
-  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);
 }
 
@@ -331,8 +331,9 @@ int ma_checkpoint_init(ulong interval)
   else if (interval > 0)
   {
     compile_time_assert(sizeof(void *) >= sizeof(ulong));
-    if (!(res= pthread_create(&th, NULL, ma_checkpoint_background,
+    if (!(res= mysql_thread_create(key_thread_checkpoint,
-                              (void *)interval)))
+                                   &th, NULL, ma_checkpoint_background,
+                                   (void *)interval)))
     {
       /* thread lives, will have to be killed */
       checkpoint_control.status= THREAD_RUNNING;
@@ -355,7 +356,7 @@ static void flush_all_tables(int what_to_flush)
 {
   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;
@@ -382,7 +383,7 @@ static void flush_all_tables(int what_to_flush)
     }
     DBUG_ASSERT(res == 0);
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
 }
 #endif
 
@@ -745,7 +746,7 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
 
   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;
@@ -794,7 +795,7 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
   }
 
   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=
@@ -935,8 +936,8 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
       intern_lock in the middle of manipulating the table. Serializing us and
       maria_close() should help avoid problems.
     */
-    pthread_mutex_lock(&share->close_lock);
+    mysql_mutex_lock(&share->close_lock);
-    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
@@ -1032,7 +1033,7 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
       otherwise this would deadlock with allocate_and_write_block_record()
       calling _ma_set_share_data_file_length()
     */
-    pthread_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->intern_lock);
     
     if (!ignore_share)
     {
@@ -1064,16 +1065,16 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
         and so this assertion should be true:
       */
       DBUG_ASSERT(ignore_share);
-      pthread_mutex_destroy(&share->intern_lock);
+      mysql_mutex_destroy(&share->intern_lock);
-      pthread_mutex_unlock(&share->close_lock);
+      mysql_mutex_unlock(&share->close_lock);
-      pthread_mutex_destroy(&share->close_lock);
+      mysql_mutex_destroy(&share->close_lock);
       my_free(share);
     }
     else
     {
       /* share goes back to normal state */
       share->in_checkpoint= 0;
-      pthread_mutex_unlock(&share->close_lock);
+      mysql_mutex_unlock(&share->close_lock);
     }
 
     /*
@@ -1146,8 +1147,8 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
         per second, so if you have touched 1000 files it's 7 seconds).
       */
       sync_error|=
-        my_sync(dfile.file, MYF(MY_WME | MY_IGNORE_BADFD)) |
+        mysql_file_sync(dfile.file, MYF(MY_WME | MY_IGNORE_BADFD)) |
-        my_sync(kfile.file, MYF(MY_WME | MY_IGNORE_BADFD));
+        mysql_file_sync(kfile.file, MYF(MY_WME | MY_IGNORE_BADFD));
       /*
         in case of error, we continue because writing other tables to disk is
         still useful.
@@ -1172,14 +1173,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(share);
       }
       else
@@ -1188,7 +1189,7 @@ err:
         share->in_checkpoint= 0;
       }
     }
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    mysql_mutex_unlock(&THR_LOCK_maria);
   }
   my_free(distinct_shares);
   my_free(state_copies);

storage/maria/ma_close.c

@@ -35,7 +35,7 @@ int maria_close(register MARIA_HA *info)
   /* Check that we have unlocked key delete-links properly */
   DBUG_ASSERT(info->key_del_used == 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,8 +47,8 @@ int maria_close(register MARIA_HA *info)
     if (maria_lock_database(info,F_UNLCK))
       error=my_errno;
   }
-  pthread_mutex_lock(&share->close_lock);
+  mysql_mutex_lock(&share->close_lock);
-  pthread_mutex_lock(&share->intern_lock);
+  mysql_mutex_lock(&share->intern_lock);
 
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
@@ -108,19 +108,19 @@ int maria_close(register MARIA_HA *info)
         File must be synced as it is going out of the maria_open_list and so
         becoming unknown to future Checkpoints.
       */
-      if (share->now_transactional && my_sync(share->kfile.file, MYF(MY_WME)))
+      if (share->now_transactional && mysql_file_sync(share->kfile.file, MYF(MY_WME)))
         error= my_errno;
-      if (my_close(share->kfile.file, MYF(0)))
+      if (mysql_file_close(share->kfile.file, MYF(0)))
         error= my_errno;
     }
     thr_lock_delete(&share->lock);
-    (void) pthread_mutex_destroy(&share->key_del_lock);
+    (void) mysql_mutex_destroy(&share->key_del_lock);
     {
       int i,keys;
       keys = share->state.header.keys;
-      rwlock_destroy(&share->mmap_lock);
+      mysql_rwlock_destroy(&share->mmap_lock);
       for(i=0; i<keys; i++) {
-	rwlock_destroy(&share->keyinfo[i].root_lock);
+	mysql_rwlock_destroy(&share->keyinfo[i].root_lock);
       }
     }
     DBUG_ASSERT(share->now_transactional == share->base.born_transactional);
@@ -136,9 +136,9 @@ int maria_close(register MARIA_HA *info)
       We have to unlock share->intern_lock then lock it after
       LOCK_trn_list (trnman_lock()) to avoid dead locks.
     */
-    pthread_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->intern_lock);
     _ma_remove_not_visible_states_with_lock(share, TRUE);
-    pthread_mutex_lock(&share->intern_lock);
+    mysql_mutex_lock(&share->intern_lock);
 
     if (share->in_checkpoint & MARIA_CHECKPOINT_LOOKS_AT_ME)
     {
@@ -168,14 +168,14 @@ int maria_close(register MARIA_HA *info)
       share->state_history= 0;
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
-  pthread_mutex_unlock(&share->intern_lock);
+  mysql_mutex_unlock(&share->intern_lock);
-  pthread_mutex_unlock(&share->close_lock);
+  mysql_mutex_unlock(&share->close_lock);
   if (share_can_be_freed)
   {
-    (void) pthread_mutex_destroy(&share->intern_lock);
+    (void) mysql_mutex_destroy(&share->intern_lock);
-    (void) pthread_mutex_destroy(&share->close_lock);
+    (void) mysql_mutex_destroy(&share->close_lock);
-    (void) pthread_cond_destroy(&share->key_del_cond);
+    (void) mysql_cond_destroy(&share->key_del_cond);
     my_free(share);
     /*
       If share cannot be freed, it's because checkpoint has previously
@@ -190,7 +190,7 @@ int maria_close(register MARIA_HA *info)
       This is outside of mutex so would confuse a concurrent
       Checkpoint. Fortunately in BLOCK_RECORD we close earlier under mutex.
     */
-    if (my_close(info->dfile.file, MYF(0)))
+    if (mysql_file_close(info->dfile.file, MYF(0)))
       error= my_errno;
   }
 

storage/maria/ma_control_file.c

@@ -148,9 +148,8 @@ static CONTROL_FILE_ERROR create_control_file(const char *name,
   uchar buffer[CF_CREATE_TIME_TOTAL_SIZE];
   DBUG_ENTER("maria_create_control_file");
 
-  if ((control_file_fd= my_create(name, 0,
+  if ((control_file_fd= mysql_file_create(key_file_control, name, 0,
-                                  open_flags,
+                                  open_flags, MYF(MY_SYNC_DIR | MY_WME))) < 0)
-                                  MYF(MY_SYNC_DIR | MY_WME))) < 0)
     DBUG_RETURN(CONTROL_FILE_UNKNOWN_ERROR);
 
   /* Reset variables, as we are creating the file */
@@ -318,7 +317,8 @@ CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
 
   /* Otherwise, file exists */
 
-  if ((control_file_fd= my_open(name, open_flags, MYF(MY_WME))) < 0)
+  if ((control_file_fd= mysql_file_open(key_file_control, name,
+                                        open_flags, MYF(MY_WME))) < 0)
   {
     errmsg= "Can't open file";
     goto err;
@@ -330,7 +330,7 @@ CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
     goto err;
   }
 
-  file_size= my_seek(control_file_fd, 0, SEEK_END, MYF(MY_WME));
+  file_size= mysql_file_seek(control_file_fd, 0, SEEK_END, MYF(MY_WME));
   if (file_size == MY_FILEPOS_ERROR)
   {
     errmsg= "Can't read size";
@@ -362,7 +362,7 @@ CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
     goto err;
   }
 
-  if (my_pread(control_file_fd, buffer, (size_t)file_size, 0, MYF(MY_FNABP)))
+  if (mysql_file_pread(control_file_fd, buffer, (size_t)file_size, 0, MYF(MY_FNABP)))
   {
     errmsg= "Can't read file";
     goto err;
@@ -544,7 +544,7 @@ int ma_control_file_write_and_force(LSN last_checkpoint_lsn_arg,
 
   if (my_pwrite(control_file_fd, buffer, cf_changeable_size,
                 cf_create_time_size, MYF(MY_FNABP |  MY_WME)) ||
-      (!no_need_sync && my_sync(control_file_fd, MYF(MY_WME))))
+      (!no_need_sync && mysql_file_sync(control_file_fd, MYF(MY_WME))))
     DBUG_RETURN(1);
 
   last_checkpoint_lsn= last_checkpoint_lsn_arg;
@@ -577,9 +577,9 @@ int ma_control_file_end(void)
                  MYF(MY_SEEK_NOT_DONE | MY_FORCE_LOCK));
 #endif
 
-  close_error= my_close(control_file_fd, MYF(MY_WME));
+  close_error= mysql_file_close(control_file_fd, MYF(MY_WME));
   /*
-    As my_close() frees structures even if close() fails, we do the same,
+    As mysql_file_close() frees structures even if close() fails, we do the same,
     i.e. we mark the file as closed in all cases.
   */
   control_file_fd= -1;

storage/maria/ma_create.c

@@ -774,7 +774,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
   if (! (flags & HA_DONT_TOUCH_DATA))
     share.state.create_time= 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
@@ -848,8 +848,9 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     goto err;
   }
 
-  if ((file= my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
+  if ((file= mysql_file_create_with_symlink(key_file_kfile, linkname_ptr,
-				    MYF(MY_WME|create_flag))) < 0)
+                                            filename, 0, create_mode,
+                                            MYF(MY_WME|create_flag))) < 0)
     goto err;
   errpos=1;
 
@@ -860,7 +861,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     goto err;
   DBUG_PRINT("info", ("base_pos: %d  base_info_size: %d",
                       base_pos, MARIA_BASE_INFO_SIZE));
-  DBUG_ASSERT(my_tell(file,MYF(0)) == base_pos+ MARIA_BASE_INFO_SIZE);
+  DBUG_ASSERT(mysql_file_tell(file,MYF(0)) == base_pos+ MARIA_BASE_INFO_SIZE);
 
   /* Write key and keyseg definitions */
   DBUG_PRINT("info", ("write key and keyseg definitions"));
@@ -984,7 +985,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
   if (_ma_column_nr_write(file, column_array, columns))
     goto err;
 
-  if ((kfile_size_before_extension= my_tell(file,MYF(0))) == MY_FILEPOS_ERROR)
+  if ((kfile_size_before_extension= mysql_file_tell(file,MYF(0))) == MY_FILEPOS_ERROR)
     goto err;
 #ifndef DBUG_OFF
   if (kfile_size_before_extension != info_length)
@@ -1008,7 +1009,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     /* we are needing maybe 64 kB, so don't use the stack */
     log_data= my_malloc(log_array[TRANSLOG_INTERNAL_PARTS + 1].length, MYF(0));
     if ((log_data == NULL) ||
-        my_pread(file, 1 + 2 + 2 + log_data,
+        mysql_file_pread(file, 1 + 2 + 2 + log_data,
                  (size_t) kfile_size_before_extension, 0, MYF(MY_NABP)))
       goto err;
     /*
@@ -1124,8 +1125,9 @@ int maria_create(const char *name, enum data_file_type datafile_type,
       create_flag= (flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
     }
     if ((dfile=
-         my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
+         mysql_file_create_with_symlink(key_file_dfile, linkname_ptr,
-                                MYF(MY_WME | create_flag | sync_dir))) < 0)
+                                        filename, 0, create_mode,
+                                        MYF(MY_WME | create_flag | sync_dir))) < 0)
       goto err;
     errpos=3;
 
@@ -1136,50 +1138,53 @@ int maria_create(const char *name, enum data_file_type datafile_type,
 	/* Enlarge files */
   DBUG_PRINT("info", ("enlarge to keystart: %lu",
                       (ulong) share.base.keystart));
-  if (my_chsize(file,(ulong) share.base.keystart,0,MYF(0)))
+  if (mysql_file_chsize(file,(ulong) share.base.keystart,0,MYF(0)))
     goto err;
 
-  if (sync_dir && my_sync(file, MYF(0)))
+  if (sync_dir && mysql_file_sync(file, MYF(0)))
     goto err;
 
   if (! (flags & HA_DONT_TOUCH_DATA))
   {
 #ifdef USE_RELOC
-    if (my_chsize(dfile,share.base.min_pack_length*ci->reloc_rows,0,MYF(0)))
+    if (mysql_file_chsize(key_file_dfile, dfile,
+                          share.base.min_pack_length*ci->reloc_rows,0,MYF(0)))
       goto err;
 #endif
-    if (sync_dir && my_sync(dfile, MYF(0)))
+    if (sync_dir && mysql_file_sync(dfile, MYF(0)))
       goto err;
-    if (my_close(dfile,MYF(0)))
+    if (mysql_file_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);
   errpos=0;
-  if (my_close(file,MYF(0)))
+  if (mysql_file_close(file,MYF(0)))
     res= my_errno;
   DBUG_RETURN(res);
 
 err:
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
 
 err_no_lock:
   save_errno=my_errno;
   switch (errpos) {
   case 3:
-    my_close(dfile, MYF(0));
+    mysql_file_close(dfile, MYF(0));
     /* fall through */
   case 2:
   if (! (flags & HA_DONT_TOUCH_DATA))
-    my_delete_with_symlink(fn_format(filename,name,"",MARIA_NAME_DEXT,
+    mysql_file_delete_with_symlink(key_file_dfile,
+                                   fn_format(filename,name,"",MARIA_NAME_DEXT,
                                      MY_UNPACK_FILENAME | MY_APPEND_EXT),
 			   sync_dir);
     /* fall through */
   case 1:
-    my_close(file, MYF(0));
+    mysql_file_close(file, MYF(0));
     if (! (flags & HA_DONT_TOUCH_DATA))
-      my_delete_with_symlink(fn_format(filename,name,"",MARIA_NAME_IEXT,
+      mysql_file_delete_with_symlink(key_file_kfile,
+                                     fn_format(filename,name,"",MARIA_NAME_IEXT,
                                        MY_UNPACK_FILENAME | MY_APPEND_EXT),
 			     sync_dir);
   }
@@ -1320,10 +1325,10 @@ int _ma_update_state_lsns(MARIA_SHARE *share, LSN lsn, TrID create_trid,
                           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;
 }
 
@@ -1412,7 +1417,7 @@ int _ma_update_state_lsns_sub(MARIA_SHARE *share, LSN lsn, TrID create_trid,
           my_pwrite(file, trid_buff, sizeof(trid_buff),
                     sizeof(share->state.header) +
                     MARIA_FILE_CREATE_TRID_OFFSET, MYF(MY_NABP)) ||
-          (do_sync && my_sync(file, MYF(0))));
+          (do_sync && mysql_file_sync(file, MYF(0))));
 }
 #if (_MSC_VER == 1310)
 #pragma optimize("",on)

storage/maria/ma_dbug.c

@@ -179,7 +179,7 @@ my_bool _ma_check_table_is_closed(const char *name, const char *where)
   DBUG_ENTER("_ma_check_table_is_closed");
 
   (void) fn_format(filename,name,"",MARIA_NAME_IEXT,4+16+32);
-  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;
@@ -190,12 +190,12 @@ my_bool _ma_check_table_is_closed(const char *name, const char *where)
       {
 	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_maria);
+        mysql_mutex_unlock(&THR_LOCK_maria);
 	DBUG_RETURN(1);
       }
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
   DBUG_RETURN(0);
 }
 #endif /* EXTRA_DEBUG */

storage/maria/ma_delete_all.c

@@ -98,8 +98,8 @@ int maria_delete_all_rows(MARIA_HA *info)
 
   if (_ma_flush_table_files(info, MARIA_FLUSH_DATA|MARIA_FLUSH_INDEX,
                             FLUSH_IGNORE_CHANGED, FLUSH_IGNORE_CHANGED) ||
-      my_chsize(info->dfile.file, 0, 0, MYF(MY_WME)) ||
+      mysql_file_chsize(info->dfile.file, 0, 0, MYF(MY_WME)) ||
-      my_chsize(share->kfile.file, share->base.keystart, 0, MYF(MY_WME)))
+      mysql_file_chsize(share->kfile.file, share->base.keystart, 0, MYF(MY_WME)))
     goto err;
 
   if (_ma_initialize_data_file(share, info->dfile.file))

storage/maria/ma_delete_table.c

@@ -94,14 +94,11 @@ int maria_delete_table(const char *name)
   }
 
   fn_format(from,name,"",MARIA_NAME_IEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
-  if (my_delete_with_symlink(from, MYF(MY_WME | sync_dir)))
+  if (mysql_file_delete_with_symlink(key_file_kfile, from,
+                                     MYF(MY_WME | sync_dir)))
     DBUG_RETURN(my_errno);
   fn_format(from,name,"",MARIA_NAME_DEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
-#ifdef USE_RAID
+  DBUG_RETURN(mysql_file_delete_with_symlink(key_file_dfile,
-  if (raid_type)
+                                             from, MYF(MY_WME | sync_dir)) ?
-    DBUG_RETURN(my_raid_delete(from, raid_chunks, MYF(MY_WME | sync_dir)) ?
-                my_errno : 0);
-#endif
-  DBUG_RETURN(my_delete_with_symlink(from, MYF(MY_WME | sync_dir)) ?
               my_errno : 0);
 }

storage/maria/ma_dynrec.c

@@ -135,7 +135,7 @@ size_t _ma_mmap_pread(MARIA_HA *info, uchar *Buffer,
 {
   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:
@@ -148,14 +148,14 @@ size_t _ma_mmap_pread(MARIA_HA *info, uchar *Buffer,
   {
     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);
+    return mysql_file_pread(info->dfile.file, Buffer, Count, offset, MyFlags);
   }
 }
 
@@ -165,7 +165,7 @@ size_t _ma_mmap_pread(MARIA_HA *info, uchar *Buffer,
 size_t _ma_nommap_pread(MARIA_HA *info, uchar *Buffer,
 			size_t Count, my_off_t offset, myf MyFlags)
 {
-  return my_pread(info->dfile.file, Buffer, Count, offset, MyFlags);
+  return mysql_file_pread(info->dfile.file, Buffer, Count, offset, MyFlags);
 }
 
 
@@ -190,7 +190,7 @@ size_t _ma_mmap_pwrite(MARIA_HA *info, const uchar *Buffer,
 {
   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:
@@ -203,14 +203,14 @@ size_t _ma_mmap_pwrite(MARIA_HA *info, const uchar *Buffer,
   {
     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);
   }
 
@@ -1682,7 +1682,7 @@ static my_bool _ma_cmp_buffer(File file, const uchar *buff, my_off_t filepos,
 
   while (length > IO_SIZE*2)
   {
-    if (my_pread(file,temp_buff,next_length,filepos, MYF(MY_NABP)) ||
+    if (mysql_file_pread(file,temp_buff,next_length,filepos, MYF(MY_NABP)) ||
 	memcmp(buff, temp_buff, next_length))
       goto err;
     filepos+=next_length;
@@ -1690,7 +1690,7 @@ static my_bool _ma_cmp_buffer(File file, const uchar *buff, my_off_t filepos,
     length-= next_length;
     next_length=IO_SIZE*2;
   }
-  if (my_pread(file,temp_buff,length,filepos,MYF(MY_NABP)))
+  if (mysql_file_pread(file,temp_buff,length,filepos,MYF(MY_NABP)))
     goto err;
   DBUG_RETURN(memcmp(buff, temp_buff, length) != 0);
 err:
@@ -1864,7 +1864,7 @@ int _ma_read_rnd_dynamic_record(MARIA_HA *info,
             flush_io_cache(&info->rec_cache))
           goto err;
 	/* VOID(my_seek(info->dfile.file, filepos, MY_SEEK_SET, MYF(0))); */
-	if (my_read(info->dfile.file, to, block_info.data_len, MYF(MY_NABP)))
+	if (mysql_file_read(info->dfile.file, to, block_info.data_len, MYF(MY_NABP)))
 	{
 	  if (my_errno == HA_ERR_FILE_TOO_SHORT)
 	    my_errno= HA_ERR_WRONG_IN_RECORD;	/* Unexpected end of file */
@@ -1915,8 +1915,8 @@ uint _ma_get_block_info(MARIA_BLOCK_INFO *info, File file, my_off_t filepos)
       pointer set to the end of the header after this function.
       my_pread() may leave the file pointer untouched.
     */
-    my_seek(file,filepos,MY_SEEK_SET,MYF(0));
+    mysql_file_seek(file,filepos,MY_SEEK_SET,MYF(0));
-    if (my_read(file, header, sizeof(info->header),MYF(0)) !=
+    if (mysql_file_read(file, header, sizeof(info->header),MYF(0)) !=
 	sizeof(info->header))
       goto err;
   }

storage/maria/ma_extra.c

@@ -80,17 +80,17 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
 #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_extra_function function,
     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;
     }
@@ -276,7 +276,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
                                   MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
                                   MA_STATE_INFO_WRITE_FULL_INFO);
     }
-    pthread_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->intern_lock);
     break;
   case HA_EXTRA_FORCE_REOPEN:
     /*
@@ -290,19 +290,19 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
                                  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,
                                         MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET|
                                         MA_STATE_INFO_WRITE_FULL_INFO)))
         share->changed= 0;
-      pthread_mutex_unlock(&share->intern_lock);
+      mysql_mutex_unlock(&share->intern_lock);
     }
-    pthread_mutex_lock(&THR_LOCK_maria);
+    mysql_mutex_lock(&THR_LOCK_maria);
-    pthread_mutex_lock(&share->intern_lock); /* protect against Checkpoint */
+    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);
+    mysql_mutex_unlock(&share->intern_lock);
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    mysql_mutex_unlock(&THR_LOCK_maria);
     break;
   case HA_EXTRA_PREPARE_FOR_DROP:
     /* Signals about intent to delete this table */
@@ -315,7 +315,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
   {
     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
@@ -336,7 +336,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
       call it as in that case the automatic repair on open will add
       the missing index entries
     */
-    pthread_mutex_lock(&share->intern_lock);
+    mysql_mutex_lock(&share->intern_lock);
     if (share->kfile.file >= 0 && function != HA_EXTRA_PREPARE_FOR_DROP)
       _ma_decrement_open_count(info);
     if (info->trn)
@@ -368,7 +368,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
              _ma_state_info_write(share,
                                   MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
                                   MA_STATE_INFO_WRITE_FULL_INFO)) ||
-            my_sync(share->kfile.file, MYF(0)))
+            mysql_file_sync(share->kfile.file, MYF(0)))
           error= my_errno;
         else
           share->changed= 0;
@@ -382,23 +382,23 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
     if (share->data_file_type == BLOCK_RECORD &&
         share->bitmap.file.file >= 0)
     {
-      if (do_flush && my_sync(share->bitmap.file.file, MYF(0)))
+      if (do_flush && mysql_file_sync(share->bitmap.file.file, MYF(0)))
         error= my_errno;
     }
     /* For protection against Checkpoint, we set under intern_lock: */
     share->last_version= 0L;			/* Impossible version */
-    pthread_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->intern_lock);
-    pthread_mutex_unlock(&THR_LOCK_maria);
+    mysql_mutex_unlock(&THR_LOCK_maria);
     break;
   }
   case HA_EXTRA_PREPARE_FOR_FORCED_CLOSE:
     if (info->trn)
     {
-      pthread_mutex_lock(&share->intern_lock);
+      mysql_mutex_lock(&share->intern_lock);
       _ma_remove_table_from_trnman(share, info->trn);
       /* Ensure we don't point to the deleted data in trn */
       info->state= info->state_start= &share->state.state;
-      pthread_mutex_unlock(&share->intern_lock);    
+      mysql_mutex_unlock(&share->intern_lock);    
     }
     break;
   case HA_EXTRA_FLUSH:
@@ -442,7 +442,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
 #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.
@@ -463,13 +463,13 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
         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:
@@ -564,8 +564,8 @@ int maria_reset(MARIA_HA *info)
 
 int _ma_sync_table_files(const MARIA_HA *info)
 {
-  return (my_sync(info->dfile.file, MYF(MY_WME)) ||
+  return (mysql_file_sync(info->dfile.file, MYF(MY_WME)) ||
-          my_sync(info->s->kfile.file, MYF(MY_WME)));
+          mysql_file_sync(info->s->kfile.file, MYF(MY_WME)));
 }
 
 
@@ -614,9 +614,9 @@ int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
       }
       else
       {
-        pthread_mutex_lock(&share->bitmap.bitmap_lock);
+        mysql_mutex_lock(&share->bitmap.bitmap_lock);
         share->bitmap.changed= 0;
-        pthread_mutex_unlock(&share->bitmap.bitmap_lock);
+        mysql_mutex_unlock(&share->bitmap.bitmap_lock);
       }
       if (flush_pagecache_blocks(share->pagecache, &info->dfile,
                                  flush_type_for_data))

storage/maria/ma_info.c

@@ -42,10 +42,10 @@ int maria_status(MARIA_HA *info, register MARIA_INFO *x, uint flag)
     DBUG_RETURN(0);				/* Compatible with ISAM */
   if (!(flag & HA_STATUS_NO_LOCK))
   {
-    pthread_mutex_lock(&share->intern_lock);
+    mysql_mutex_lock(&share->intern_lock);
     _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)
   {

storage/maria/ma_init.c

@@ -66,7 +66,7 @@ int maria_init(void)
   if (!maria_inited)
   {
     maria_inited= TRUE;
-    pthread_mutex_init(&THR_LOCK_maria,MY_MUTEX_INIT_SLOW);
+    mysql_mutex_init(key_THR_LOCK_maria, &THR_LOCK_maria, MY_MUTEX_INIT_SLOW);
     _ma_init_block_record_data();
     trnman_end_trans_hook= _ma_trnman_end_trans_hook;
     maria_create_trn_hook= dummy_maria_create_trn_hook;
@@ -108,7 +108,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);
     my_hash_free(&maria_stored_state);
   }
 }
@@ -166,7 +166,8 @@ my_bool maria_upgrade()
         char old_logname[FN_REFLEN], new_logname[FN_REFLEN];
         fn_format(old_logname, file, maria_data_root, "", MYF(0));
         fn_format(new_logname, file+1, maria_data_root, "", MYF(0));
-        if (my_rename(old_logname, new_logname, MYF(MY_WME)))
+        if (mysql_file_rename(key_file_translog, old_logname,
+                              new_logname, MYF(MY_WME)))
         {
           my_dirend(dir);
           DBUG_RETURN(1);
@@ -176,7 +177,7 @@ my_bool maria_upgrade()
     my_dirend(dir);
     
     fn_format(new_name, CONTROL_FILE_BASE_NAME, maria_data_root, "", MYF(0));
-    if (my_rename(name, new_name, MYF(MY_WME)))
+    if (mysql_file_rename(key_file_control, name, new_name, MYF(MY_WME)))
       DBUG_RETURN(1);
   }
   DBUG_RETURN(0);

storage/maria/ma_key_recover.c

@@ -131,7 +131,7 @@ my_bool _ma_write_clr(MARIA_HA *info, LSN undo_lsn,
     (first intern_lock then transactional log  buffer lock)
   */
   if (undo_type == LOGREC_UNDO_BULK_INSERT)
-    pthread_mutex_lock(&info->s->intern_lock);
+    mysql_mutex_lock(&info->s->intern_lock);
 
   res= translog_write_record(res_lsn, LOGREC_CLR_END,
                              info->trn, info,
@@ -140,7 +140,7 @@ my_bool _ma_write_clr(MARIA_HA *info, LSN undo_lsn,
                              TRANSLOG_INTERNAL_PARTS + 1, log_array,
                              log_data + LSN_STORE_SIZE, &msg);
   if (undo_type == LOGREC_UNDO_BULK_INSERT)
-    pthread_mutex_unlock(&info->s->intern_lock);
+    mysql_mutex_unlock(&info->s->intern_lock);
   DBUG_RETURN(res);
 }
 
@@ -190,7 +190,7 @@ my_bool write_hook_for_clr_end(enum translog_record_type type
   case LOGREC_UNDO_KEY_DELETE:
     break;
   case LOGREC_UNDO_BULK_INSERT:
-    safe_mutex_assert_owner(&share->intern_lock);
+    mysql_mutex_assert_owner(&share->intern_lock);
     error= (maria_enable_indexes(tbl_info) ||
             /* we enabled indices, need '2' below */
             _ma_state_info_write(share,
@@ -1388,19 +1388,19 @@ my_bool _ma_lock_key_del(MARIA_HA *info, my_bool insert_at_end)
   */
   if (info->key_del_used != 1)
   {
-    pthread_mutex_lock(&share->key_del_lock);
+    mysql_mutex_lock(&share->key_del_lock);
     if (share->state.key_del == HA_OFFSET_ERROR && insert_at_end)
     {
-      pthread_mutex_unlock(&share->key_del_lock);
+      mysql_mutex_unlock(&share->key_del_lock);
       info->key_del_used= 2;                  /* insert-with-append */
       return 1;
     }
     while (share->key_del_used)
-      pthread_cond_wait(&share->key_del_cond, &share->key_del_lock);
+      mysql_cond_wait(&share->key_del_cond, &share->key_del_lock);
     info->key_del_used= 1;
     share->key_del_used= 1;
     share->key_del_current= share->state.key_del;
-    pthread_mutex_unlock(&share->key_del_lock);
+    mysql_mutex_unlock(&share->key_del_lock);
   }
   return share->key_del_current == HA_OFFSET_ERROR;
 }
@@ -1420,11 +1420,11 @@ void _ma_unlock_key_del(MARIA_HA *info)
   if (info->key_del_used == 1)                  /* Ignore insert-with-append */
   {
     MARIA_SHARE *share= info->s;
-    pthread_mutex_lock(&share->key_del_lock);
+    mysql_mutex_lock(&share->key_del_lock);
     share->key_del_used= 0;
     share->state.key_del= share->key_del_current;
-    pthread_mutex_unlock(&share->key_del_lock);
+    mysql_mutex_unlock(&share->key_del_lock);
-    pthread_cond_signal(&share->key_del_cond);
+    mysql_cond_signal(&share->key_del_cond);
   }
   info->key_del_used= 0;
 }

storage/maria/ma_keycache.c

@@ -97,7 +97,7 @@ int maria_assign_to_pagecache(MARIA_HA *info,
     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 *info,
                           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 *old_pagecache,
   /*
     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 *old_pagecache,
     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;
 }

storage/maria/ma_locking.c

@@ -47,7 +47,7 @@ int maria_lock_database(MARIA_HA *info, int lock_type)
   }
 
   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, int lock_type)
               (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
@@ -238,7 +238,7 @@ int maria_lock_database(MARIA_HA *info, int lock_type)
     }
   }
 #endif
-  pthread_mutex_unlock(&share->intern_lock);
+  mysql_mutex_unlock(&share->intern_lock);
   DBUG_RETURN(error);
 } /* maria_lock_database */
 
@@ -399,7 +399,7 @@ int _ma_mark_file_changed(MARIA_HA *info)
 
   if (_MA_ALREADY_MARKED_FILE_CHANGED)
     DBUG_RETURN(0);
-  pthread_mutex_lock(&share->intern_lock); /* recheck under mutex */
+  mysql_mutex_lock(&share->intern_lock); /* recheck under mutex */
   if (! _MA_ALREADY_MARKED_FILE_CHANGED)
   {
     share->state.changed|=(STATE_CHANGED | STATE_NOT_ANALYZED |
@@ -445,7 +445,7 @@ int _ma_mark_file_changed(MARIA_HA *info)
   }
   error= 0;
 err:
-  pthread_mutex_unlock(&share->intern_lock);
+  mysql_mutex_unlock(&share->intern_lock);
   DBUG_RETURN(error);
 #undef _MA_ALREADY_MARKED_FILE_CHANGED
 }

storage/maria/ma_loghandler.c

@@ -21,14 +21,14 @@
 #include "ma_servicethread.h"
 
 /*
-  On Windows, neither my_open() nor my_sync() work for directories.
+  On Windows, neither my_open() nor mysql_file_sync() work for directories.
   Also there is no need to flush filesystem changes ,i.e to sync()
   directories.
 */
 #ifdef __WIN__
 #define sync_dir(A,B) 0
 #else
-#define sync_dir(A,B) my_sync(A,B)
+#define sync_dir(A,B) mysql_file_sync(A,B)
 #endif
 
 /**
@@ -49,9 +49,9 @@
 #endif
 
 /** @brief protects checkpoint_in_progress */
-static pthread_mutex_t LOCK_soft_sync;
+static mysql_mutex_t LOCK_soft_sync;
 /** @brief for killing the background checkpoint thread */
-static pthread_cond_t  COND_soft_sync;
+static mysql_cond_t  COND_soft_sync;
 /** @brief control structure for checkpoint background thread */
 static MA_SERVICE_THREAD_CONTROL soft_sync_control=
   {THREAD_DEAD, FALSE, &LOCK_soft_sync, &COND_soft_sync};
@@ -155,7 +155,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 */
@@ -190,7 +190,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
@@ -208,7 +208,7 @@ struct st_translog_buffer
     (we have to keep it in this buffer to lock buffers only in one direction).
   */
   TRANSLOG_ADDRESS prev_sent_to_disk;
-  pthread_cond_t prev_sent_to_disk_cond;
+  mysql_cond_t prev_sent_to_disk_cond;
 };
 
 
@@ -283,7 +283,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
@@ -295,7 +295,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
@@ -321,23 +321,23 @@ 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;
+  mysql_mutex_t log_flush_lock;
-  pthread_cond_t log_flush_cond;
+  mysql_cond_t log_flush_cond;
-  pthread_cond_t new_goal_cond;
+  mysql_cond_t new_goal_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;
 
   /*
@@ -348,7 +348,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;
   /**
@@ -444,9 +444,9 @@ LOG_DESC log_record_type_descriptor[LOGREC_NUMBER_OF_TYPES];
 #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();
@@ -937,8 +937,9 @@ static File create_logfile_by_number_no_cache(uint32 file_no)
      DBUG_RETURN(-1);
 
   /* TODO: add O_DIRECT to open flags (when buffer is aligned) */
-  if ((file= my_create(translog_filename_by_fileno(file_no, path),
+  if ((file= mysql_file_create(key_file_translog,
-                       0, O_BINARY | O_RDWR, MYF(MY_WME))) < 0)
+                               translog_filename_by_fileno(file_no, path),
+                               0, O_BINARY | O_RDWR, MYF(MY_WME))) < 0)
   {
     DBUG_PRINT("error", ("Error %d during creating file '%s'", errno, path));
     translog_stop_writing();
@@ -973,9 +974,10 @@ static File open_logfile_by_number_no_cache(uint32 file_no)
 
   /* TODO: add O_DIRECT to open flags (when buffer is aligned) */
   /* TODO: use my_create() */
-  if ((file= my_open(translog_filename_by_fileno(file_no, path),
+  if ((file= mysql_file_open(key_file_translog,
-                     log_descriptor.open_flags,
+                             translog_filename_by_fileno(file_no, path),
-                     MYF(MY_WME))) < 0)
+                             log_descriptor.open_flags,
+                             MYF(MY_WME))) < 0)
   {
     DBUG_PRINT("error", ("Error %d during opening file '%s'", errno, path));
     DBUG_RETURN(-1);
@@ -998,12 +1000,12 @@ static TRANSLOG_FILE *get_logfile_by_number(uint32 file_no)
 {
   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 ==
@@ -1013,7 +1015,7 @@ static TRANSLOG_FILE *get_logfile_by_number(uint32 file_no)
 
   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)));
@@ -1032,7 +1034,7 @@ static TRANSLOG_FILE *get_current_logfile()
 {
   TRANSLOG_FILE *file;
   DBUG_ENTER("get_current_logfile");
-  rw_rdlock(&log_descriptor.open_files_lock);
+  mysql_rwlock_rdlock(&log_descriptor.open_files_lock);
   DBUG_PRINT("info", ("max_file: %lu  min_file: %lu  open_files: %lu",
                       (ulong) log_descriptor.max_file,
                       (ulong) log_descriptor.min_file,
@@ -1040,7 +1042,7 @@ static TRANSLOG_FILE *get_current_logfile()
   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);
   DBUG_RETURN(file);
 }
 
@@ -1138,7 +1140,7 @@ static my_bool translog_max_lsn_to_header(File file, LSN lsn)
                  LSN_STORE_SIZE,
                  (LOG_HEADER_DATA_SIZE - LSN_STORE_SIZE),
                  log_write_flags) != 0 ||
-       my_sync(file, MYF(MY_WME)) != 0);
+       mysql_file_sync(file, MYF(MY_WME)) != 0);
   /*
     We should not increase counter in case of error above, but it is so
     unlikely that we can ignore this case
@@ -1212,7 +1214,7 @@ my_bool translog_read_file_header(LOGHANDLER_FILE_INFO *desc, File file)
   uchar page_buff[LOG_HEADER_DATA_SIZE];
   DBUG_ENTER("translog_read_file_header");
 
-  if (my_pread(file, page_buff,
+  if (mysql_file_pread(file, page_buff,
                sizeof(page_buff), 0, MYF(MY_FNABP | MY_WME)))
   {
     DBUG_PRINT("info", ("log read fail error: %d", my_errno));
@@ -1270,7 +1272,7 @@ static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_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;
@@ -1282,13 +1284,13 @@ static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,
         ((translog_read_file_header(&info, fd) ||
           (cmp_translog_addr(lsn, info.max_lsn) > 0 &&
            translog_max_lsn_to_header(fd, lsn))) |
-          my_close(fd, MYF(MY_WME))))
+          mysql_file_close(fd, MYF(MY_WME))))
     {
       translog_stop_writing();
       DBUG_RETURN(1);
     }
   }
-  pthread_mutex_unlock(&log_descriptor.file_header_lock);
+  mysql_mutex_unlock(&log_descriptor.file_header_lock);
 
   DBUG_RETURN(0);
 }
@@ -1317,7 +1319,7 @@ static void translog_mark_file_unfinished(uint32 file)
   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)
   {
@@ -1368,7 +1370,7 @@ static void translog_mark_file_unfinished(uint32 file)
                          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;
 }
 
@@ -1388,7 +1390,7 @@ static void translog_mark_file_finished(uint32 file)
 
   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;
@@ -1406,7 +1408,7 @@ static void translog_mark_file_finished(uint32 file)
 
   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;
 }
 
@@ -1430,7 +1432,7 @@ LSN translog_get_file_max_lsn_stored(uint32 file)
   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)
@@ -1440,7 +1442,7 @@ LSN translog_get_file_max_lsn_stored(uint32 file)
                             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
@@ -1464,7 +1466,7 @@ LSN translog_get_file_max_lsn_stored(uint32 file)
 
     fd= open_logfile_by_number_no_cache(file);
     if ((fd < 0) ||
-        (translog_read_file_header(&info, fd) | my_close(fd, MYF(MY_WME))))
+        (translog_read_file_header(&info, fd) | mysql_file_close(fd, MYF(MY_WME))))
     {
       DBUG_PRINT("error", ("Can't read file header"));
       DBUG_RETURN(LSN_ERROR);
@@ -1507,7 +1509,8 @@ static my_bool translog_buffer_init(struct st_translog_buffer *buffer, int num)
   buffer->size= 0;
   buffer->skipped_data= 0;
   /* cond of thread which is waiting for buffer filling */
-  if (pthread_cond_init(&buffer->waiting_filling_buffer, 0))
+  if (mysql_cond_init(key_TRANSLOG_BUFFER_waiting_filling_buffer,
+                      &buffer->waiting_filling_buffer, 0))
     DBUG_RETURN(1);
   /* Number of records which are in copy progress */
   buffer->copy_to_buffer_in_progress= 0;
@@ -1527,8 +1530,10 @@ static my_bool translog_buffer_init(struct st_translog_buffer *buffer, int num)
     possible problems which include this mutexes.
   */
 
-  if (pthread_mutex_init(&buffer->mutex, MY_MUTEX_INIT_FAST) ||
+  if (mysql_mutex_init(key_TRANSLOG_BUFFER_mutex,
-      pthread_cond_init(&buffer->prev_sent_to_disk_cond, 0))
+                       &buffer->mutex, MY_MUTEX_INIT_FAST) ||
+      mysql_cond_init(key_TRANSLOG_BUFFER_prev_sent_to_disk_cond,
+                      &buffer->prev_sent_to_disk_cond, 0))
     DBUG_RETURN(1);
   buffer->is_closing_buffer= 0;
   buffer->prev_sent_to_disk= LSN_IMPOSSIBLE;
@@ -1559,10 +1564,10 @@ static my_bool translog_close_log_file(TRANSLOG_FILE *file)
   */
   if (!file->is_sync)
   {
-    rc= my_sync(file->handler.file, MYF(MY_WME));
+    rc= mysql_file_sync(file->handler.file, MYF(MY_WME));
     translog_syncs++;
   }
-  rc|= my_close(file->handler.file, MYF(MY_WME));
+  rc|= mysql_file_close(file->handler.file, MYF(MY_WME));
   my_free(file);
   return test(rc);
 }
@@ -1633,7 +1638,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);
@@ -1659,7 +1664,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));
 
@@ -1677,7 +1682,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);
@@ -1701,7 +1706,7 @@ static void translog_buffer_lock(struct st_translog_buffer *buffer)
   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;
 }
 
@@ -1724,7 +1729,7 @@ static void translog_buffer_unlock(struct st_translog_buffer *buffer)
   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;
 }
 
@@ -1985,7 +1990,7 @@ static void translog_wait_for_closing(struct st_translog_buffer *buffer)
     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));
   }
@@ -2017,7 +2022,7 @@ static void translog_wait_for_writers(struct st_translog_buffer *buffer)
     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));
   }
@@ -2061,7 +2066,7 @@ static void translog_wait_for_buffer_free(struct st_translog_buffer *buffer)
   {
     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));
   }
@@ -2135,9 +2140,9 @@ static void translog_start_buffer(struct st_translog_buffer *buffer,
                       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;
 }
@@ -2244,7 +2249,7 @@ static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)
   TRANSLOG_ADDRESS in_buffers= buffer->next_buffer_offset;
 
   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)",
@@ -2267,7 +2272,7 @@ static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)
     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;
 }
 
@@ -2284,7 +2289,7 @@ static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)
 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),
@@ -2297,7 +2302,7 @@ static void translog_set_only_in_buffers(TRANSLOG_ADDRESS 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;
 }
 
@@ -2316,9 +2321,9 @@ static TRANSLOG_ADDRESS translog_only_in_buffers()
 {
   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);
 }
 
@@ -2337,10 +2342,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);
 }
 
@@ -2566,7 +2571,7 @@ my_bool translog_prev_buffer_flush_wait(struct st_translog_buffer *buffer)
   if (buffer->prev_buffer_offset != buffer->prev_sent_to_disk)
   {
     do {
-      pthread_cond_wait(&buffer->prev_sent_to_disk_cond, &buffer->mutex);
+      mysql_cond_wait(&buffer->prev_sent_to_disk_cond, &buffer->mutex);
       if (buffer->file != file || buffer->offset != offset ||
           buffer->ver != ver)
       {
@@ -2709,7 +2714,7 @@ static my_bool translog_buffer_flush(struct st_translog_buffer *buffer)
       translog_buffer_lock(next_buffer);
       next_buffer->prev_sent_to_disk= buffer->offset;
       translog_buffer_unlock(next_buffer);
-      pthread_cond_broadcast(&next_buffer->prev_sent_to_disk_cond);
+      mysql_cond_broadcast(&next_buffer->prev_sent_to_disk_cond);
     }
     else
     {
@@ -2725,10 +2730,10 @@ static my_bool translog_buffer_flush(struct st_translog_buffer *buffer)
   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);
+  mysql_mutex_unlock(&log_descriptor.dirty_buffer_mask_lock);
-  pthread_cond_broadcast(&buffer->waiting_filling_buffer);
+  mysql_cond_broadcast(&buffer->waiting_filling_buffer);
   DBUG_RETURN(0);
 }
 
@@ -3264,7 +3269,7 @@ static my_bool translog_get_last_page_addr(TRANSLOG_ADDRESS *addr,
       requested log file have to be opened and can't be freed after
       returning pointer on it (file_size).
     */
-    file_size= my_seek(file->handler.file, 0, SEEK_END, MYF(0));
+    file_size= mysql_file_seek(file->handler.file, 0, SEEK_END, MYF(0));
   }
   else
   {
@@ -3273,16 +3278,17 @@ static my_bool translog_get_last_page_addr(TRANSLOG_ADDRESS *addr,
       when files are not opened.
     */
     File fd;
-    if ((fd= my_open(translog_filename_by_fileno(file_no, path),
+    if ((fd= mysql_file_open(key_file_translog,
-                     O_RDONLY, (no_errors ? MYF(0) : MYF(MY_WME)))) < 0)
+                             translog_filename_by_fileno(file_no, path),
+                             O_RDONLY, (no_errors ? MYF(0) : MYF(MY_WME)))) < 0)
     {
       my_errno= errno;
       DBUG_PRINT("error", ("Error %d during opening file #%d",
                            errno, file_no));
       DBUG_RETURN(1);
     }
-    file_size= my_seek(fd, 0, SEEK_END, MYF(0));
+    file_size= mysql_file_seek(fd, 0, SEEK_END, MYF(0));
-    my_close(fd, MYF(0));
+    mysql_file_close(fd, MYF(0));
   }
   DBUG_PRINT("info", ("File size: %s", llstr(file_size, buff)));
   if (file_size == MY_FILEPOS_ERROR)
@@ -3418,7 +3424,8 @@ static my_bool translog_truncate_log(TRANSLOG_ADDRESS addr)
   DBUG_ASSERT(cmp_translog_addr(addr, log_descriptor.horizon) < 0);
   /* remove files between the address and horizon */
   for (i= LSN_FILE_NO(addr) + 1; i <= LSN_FILE_NO(log_descriptor.horizon); i++)
-    if (my_delete(translog_filename_by_fileno(i, path),  MYF(MY_WME)))
+    if (mysql_file_delete(key_file_translog,
+                          translog_filename_by_fileno(i, path),  MYF(MY_WME)))
     {
       translog_unlock();
       DBUG_RETURN(1);
@@ -3432,12 +3439,12 @@ static my_bool translog_truncate_log(TRANSLOG_ADDRESS addr)
   page_rest= next_page_offset - LSN_OFFSET(addr);
   memset(page_buff, TRANSLOG_FILLER, page_rest);
   rc= ((fd= open_logfile_by_number_no_cache(LSN_FILE_NO(addr))) < 0 ||
-       ((my_chsize(fd, next_page_offset, TRANSLOG_FILLER, MYF(MY_WME)) ||
+       ((mysql_file_chsize(fd, next_page_offset, TRANSLOG_FILLER, MYF(MY_WME)) ||
          (page_rest && my_pwrite(fd, page_buff, page_rest, LSN_OFFSET(addr),
                                  log_write_flags)) ||
-         my_sync(fd, MYF(MY_WME)))));
+         mysql_file_sync(fd, MYF(MY_WME)))));
   translog_syncs++;
-  rc|= (fd > 0 && my_close(fd, MYF(MY_WME)));
+  rc|= (fd > 0 && mysql_file_close(fd, MYF(MY_WME)));
   if (sync_log_dir >= TRANSLOG_SYNC_DIR_ALWAYS)
   {
     rc|= sync_dir(log_descriptor.directory_fd, MYF(MY_WME | MY_IGNORE_BADFD));
@@ -3621,22 +3628,24 @@ my_bool translog_init_with_table(const char *directory,
     log_descriptor.open_flags= O_BINARY | O_RDONLY;
   else
     log_descriptor.open_flags= O_BINARY | O_RDWR;
-  if (pthread_mutex_init(&log_descriptor.sent_to_disk_lock,
+  if (mysql_mutex_init(key_TRANSLOG_BUFFER_mutex,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.sent_to_disk_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_mutex_init(&log_descriptor.file_header_lock,
+      mysql_mutex_init(key_TRANSLOG_DESCRIPTOR_file_header_lock,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.file_header_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_mutex_init(&log_descriptor.unfinished_files_lock,
+      mysql_mutex_init(key_TRANSLOG_DESCRIPTOR_unfinished_files_lock,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.unfinished_files_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_mutex_init(&log_descriptor.purger_lock,
+      mysql_mutex_init(key_TRANSLOG_DESCRIPTOR_purger_lock,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.purger_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_mutex_init(&log_descriptor.log_flush_lock,
+      mysql_mutex_init(key_TRANSLOG_DESCRIPTOR_log_flush_lock,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.log_flush_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_mutex_init(&log_descriptor.dirty_buffer_mask_lock,
+      mysql_mutex_init(key_TRANSLOG_DESCRIPTOR_dirty_buffer_mask_lock,
-                         MY_MUTEX_INIT_FAST) ||
+                       &log_descriptor.dirty_buffer_mask_lock, MY_MUTEX_INIT_FAST) ||
-      pthread_cond_init(&log_descriptor.log_flush_cond, 0) ||
+      mysql_cond_init(key_TRANSLOG_DESCRIPTOR_log_flush_cond,
-      pthread_cond_init(&log_descriptor.new_goal_cond, 0) ||
+                      &log_descriptor.log_flush_cond, 0) ||
-      my_rwlock_init(&log_descriptor.open_files_lock,
+      mysql_cond_init(key_TRANSLOG_DESCRIPTOR_new_goal_cond,
-                     NULL) ||
+                      &log_descriptor.new_goal_cond, 0) ||
+      mysql_rwlock_init(key_TRANSLOG_DESCRIPTOR_open_files_lock,
+                        &log_descriptor.open_files_lock) ||
       my_init_dynamic_array(&log_descriptor.open_files,
                             sizeof(TRANSLOG_FILE*), 10, 10) ||
       my_init_dynamic_array(&log_descriptor.unfinished_files,
@@ -3798,7 +3807,7 @@ my_bool translog_init_with_table(const char *directory,
         if (file == NULL ||
             (file->handler.file=
              open_logfile_by_number_no_cache(i)) < 0 ||
-            my_seek(file->handler.file, 0, SEEK_END, MYF(0)) >=
+            mysql_file_seek(file->handler.file, 0, SEEK_END, MYF(0)) >=
             ULL(0xffffffff))
         {
           int j;
@@ -3807,7 +3816,7 @@ my_bool translog_init_with_table(const char *directory,
             TRANSLOG_FILE *el=
               *dynamic_element(&log_descriptor.open_files, j,
                                TRANSLOG_FILE **);
-            my_close(el->handler.file, MYF(MY_WME));
+            mysql_file_close(el->handler.file, MYF(MY_WME));
             my_free(el);
           }
           if (file)
@@ -4238,8 +4247,8 @@ static void translog_buffer_destroy(struct st_translog_buffer *buffer)
     translog_buffer_unlock(buffer);
   }
   DBUG_PRINT("info", ("Destroy mutex: 0x%lx", (ulong) &buffer->mutex));
-  pthread_mutex_destroy(&buffer->mutex);
+  mysql_mutex_destroy(&buffer->mutex);
-  pthread_cond_destroy(&buffer->waiting_filling_buffer);
+  mysql_cond_destroy(&buffer->waiting_filling_buffer);
   DBUG_VOID_RETURN;
 }
 
@@ -4281,20 +4290,20 @@ 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);
+  mysql_mutex_destroy(&log_descriptor.sent_to_disk_lock);
-  pthread_mutex_destroy(&log_descriptor.file_header_lock);
+  mysql_mutex_destroy(&log_descriptor.file_header_lock);
-  pthread_mutex_destroy(&log_descriptor.unfinished_files_lock);
+  mysql_mutex_destroy(&log_descriptor.unfinished_files_lock);
-  pthread_mutex_destroy(&log_descriptor.purger_lock);
+  mysql_mutex_destroy(&log_descriptor.purger_lock);
-  pthread_mutex_destroy(&log_descriptor.log_flush_lock);
+  mysql_mutex_destroy(&log_descriptor.log_flush_lock);
-  pthread_mutex_destroy(&log_descriptor.dirty_buffer_mask_lock);
+  mysql_mutex_destroy(&log_descriptor.dirty_buffer_mask_lock);
-  pthread_cond_destroy(&log_descriptor.log_flush_cond);
+  mysql_cond_destroy(&log_descriptor.log_flush_cond);
-  pthread_cond_destroy(&log_descriptor.new_goal_cond);
+  mysql_cond_destroy(&log_descriptor.new_goal_cond);
-  rwlock_destroy(&log_descriptor.open_files_lock);
+  mysql_rwlock_destroy(&log_descriptor.open_files_lock);
   delete_dynamic(&log_descriptor.open_files);
   delete_dynamic(&log_descriptor.unfinished_files);
 
   if (log_descriptor.directory_fd >= 0)
-    my_close(log_descriptor.directory_fd, MYF(MY_WME));
+    mysql_file_close(log_descriptor.directory_fd, MYF(MY_WME));
   my_atomic_rwlock_destroy(&LOCK_id_to_share);
   if (id_to_share != NULL)
     my_free(id_to_share + 1);
@@ -4586,7 +4595,7 @@ static void translog_buffer_decrease_writers(struct st_translog_buffer *buffer)
               (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;
 }
 
@@ -7639,7 +7648,7 @@ static void translog_force_current_buffer_to_finish()
   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)
   {
@@ -7678,9 +7687,9 @@ void  translog_flush_wait_for_end(LSN lsn)
 {
   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;
 }
@@ -7698,16 +7707,16 @@ void translog_flush_set_new_goal_and_wait(TRANSLOG_ADDRESS lsn)
   int flush_no= log_descriptor.flush_no;
   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;
     log_descriptor.max_lsn_requester= pthread_self();
-    pthread_cond_broadcast(&log_descriptor.new_goal_cond);
+    mysql_cond_broadcast(&log_descriptor.new_goal_cond);
   }
   while (flush_no == log_descriptor.flush_no)
   {
-    pthread_cond_wait(&log_descriptor.log_flush_cond,
+    mysql_cond_wait(&log_descriptor.log_flush_cond,
                       &log_descriptor.log_flush_lock);
   }
   DBUG_VOID_RETURN;
@@ -7746,7 +7755,7 @@ static my_bool translog_sync_files(uint32 min, uint32 max,
     DBUG_ASSERT(file != NULL);
     if (!file->is_sync)
     {
-      if (my_sync(file->handler.file, MYF(MY_WME)))
+      if (mysql_file_sync(file->handler.file, MYF(MY_WME)))
       {
         rc= 1;
         translog_stop_writing();
@@ -7937,12 +7946,12 @@ my_bool translog_flush(TRANSLOG_ADDRESS lsn)
   LINT_INIT(sent_to_disk);
   LINT_INIT(flush_interval);
 
-  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)
@@ -7960,7 +7969,7 @@ my_bool translog_flush(TRANSLOG_ADDRESS lsn)
         waiting then acquire it again
       */
       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;
@@ -7969,7 +7978,7 @@ my_bool translog_flush(TRANSLOG_ADDRESS lsn)
   flush_horizon= log_descriptor.previous_flush_horizon;
   DBUG_PRINT("info", ("flush_in_progress is set, flush_horizon: (%lu,0x%lx)",
                       LSN_IN_PARTS(flush_horizon)));
-  pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+  mysql_mutex_unlock(&log_descriptor.log_flush_lock);
 
   hgroup_commit_at_start= hard_group_commit;
   if (hgroup_commit_at_start)
@@ -7980,7 +7989,7 @@ my_bool translog_flush(TRANSLOG_ADDRESS lsn)
   {
     DBUG_PRINT("info", ("everything is flushed"));
     translog_unlock();
-    pthread_mutex_lock(&log_descriptor.log_flush_lock);
+    mysql_mutex_lock(&log_descriptor.log_flush_lock);
     goto out;
   }
 
@@ -7994,20 +8003,20 @@ my_bool translog_flush(TRANSLOG_ADDRESS lsn)
 
 retest:
     /*
-      We do not check time here because pthread_mutex_lock rarely takes
+      We do not check time here because mysql_mutex_lock rarely takes
       a lot of time so we can sacrifice a bit precision to performance
       (taking into account that my_micro_time() might be expensive call).
     */
     if (flush_interval == 0)
       break;  /* flush pass is ended */
 
-    pthread_mutex_lock(&log_descriptor.log_flush_lock);
+    mysql_mutex_lock(&log_descriptor.log_flush_lock);
     if (log_descriptor.next_pass_max_lsn == LSN_IMPOSSIBLE)
     {
       if (flush_interval == 0 ||
           (time_spent= (my_micro_time() - flush_start)) >= flush_interval)
       {
-        pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+        mysql_mutex_unlock(&log_descriptor.log_flush_lock);
         break;
       }
       DBUG_PRINT("info", ("flush waits: %llu  interval: %llu  spent: %llu",
@@ -8015,10 +8024,10 @@ retest:
                           flush_interval, time_spent));
       /* wait time or next goal */
       set_timespec_nsec(abstime, flush_interval - time_spent);
-      pthread_cond_timedwait(&log_descriptor.new_goal_cond,
+      mysql_cond_timedwait(&log_descriptor.new_goal_cond,
                              &log_descriptor.log_flush_lock,
                              &abstime);
-      pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+      mysql_mutex_unlock(&log_descriptor.log_flush_lock);
       DBUG_PRINT("info", ("retest conditions"));
       goto retest;
     }
@@ -8030,7 +8039,7 @@ retest:
     log_descriptor.max_lsn_requester= pthread_self();
     DBUG_PRINT("info", ("flush took next goal: (%lu,0x%lx)",
                         LSN_IN_PARTS(lsn)));
-    pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+    mysql_mutex_unlock(&log_descriptor.log_flush_lock);
 
     /* next flush pass */
     DBUG_PRINT("info", ("next flush pass"));
@@ -8056,7 +8065,7 @@ retest:
                                TRANSLOG_PAGE_SIZE)))))
     {
       sent_to_disk= LSN_IMPOSSIBLE;
-      pthread_mutex_lock(&log_descriptor.log_flush_lock);
+      mysql_mutex_lock(&log_descriptor.log_flush_lock);
       goto out;
     }
     /* keep values for soft sync() and forced sync() actual */
@@ -8074,7 +8083,7 @@ retest:
 
   DBUG_ASSERT(flush_horizon <= log_descriptor.horizon);
 
-  pthread_mutex_lock(&log_descriptor.log_flush_lock);
+  mysql_mutex_lock(&log_descriptor.log_flush_lock);
   log_descriptor.previous_flush_horizon= flush_horizon;
 out:
   if (sent_to_disk != LSN_IMPOSSIBLE)
@@ -8082,8 +8091,8 @@ out:
   log_descriptor.flush_in_progress= 0;
   log_descriptor.flush_no++;
   DBUG_PRINT("info", ("flush_in_progress is dropped"));
-  pthread_mutex_unlock(&log_descriptor.log_flush_lock);
+  mysql_mutex_unlock(&log_descriptor.log_flush_lock);
-  pthread_cond_broadcast(&log_descriptor.log_flush_cond);
+  mysql_cond_broadcast(&log_descriptor.log_flush_cond);
   DBUG_RETURN(rc);
 }
 
@@ -8114,7 +8123,7 @@ int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)
   */
   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;
@@ -8162,11 +8171,11 @@ int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)
                                        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;
 }
 
@@ -8189,7 +8198,7 @@ void translog_deassign_id_from_share(MARIA_SHARE *share)
     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);
@@ -8223,8 +8232,9 @@ my_bool translog_is_file(uint file_no)
 {
   MY_STAT stat_buff;
   char path[FN_REFLEN];
-  return (test(my_stat(translog_filename_by_fileno(file_no, path),
+  return (test(mysql_file_stat(key_file_translog,
-                       &stat_buff, MYF(0))));
+                               translog_filename_by_fileno(file_no, path),
+                               &stat_buff, MYF(0))));
 }
 
 
@@ -8243,14 +8253,14 @@ static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected)
   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);
   }
 
@@ -8271,7 +8281,7 @@ static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected)
   }
   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);
@@ -8470,7 +8480,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
     DBUG_PRINT("info", ("last_need_file set to %lu", (ulong)last_need_file));
   }
 
-  pthread_mutex_lock(&log_descriptor.purger_lock);
+  mysql_mutex_lock(&log_descriptor.purger_lock);
   DBUG_PRINT("info", ("last_lsn_checked file: %lu:",
                       (ulong) log_descriptor.last_lsn_checked));
   if (LSN_FILE_NO(log_descriptor.last_lsn_checked) < last_need_file)
@@ -8502,7 +8512,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
       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);
@@ -8512,14 +8522,15 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
         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)
       {
         char path[FN_REFLEN], *file_name;
         file_name= translog_filename_by_fileno(i, path);
-        rc= test(my_delete(file_name, MYF(MY_WME)));
+        rc= test(mysql_file_delete(key_file_translog,
+                                   file_name, MYF(MY_WME)));
       }
     }
     if (unlikely(rc == 1))
@@ -8528,7 +8539,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
       log_descriptor.min_need_file= i;
   }
 
-  pthread_mutex_unlock(&log_descriptor.purger_lock);
+  mysql_mutex_unlock(&log_descriptor.purger_lock);
   DBUG_RETURN(rc);
 }
 
@@ -8565,12 +8576,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);
   }
 
@@ -8581,10 +8592,11 @@ my_bool translog_purge_at_flush()
     char path[FN_REFLEN], *file_name;
     DBUG_PRINT("info", ("purge file %lu\n", (ulong) i));
     file_name= translog_filename_by_fileno(i, path);
-    rc= test(my_delete(file_name, MYF(MY_WME)));
+    rc= test(mysql_file_delete(key_file_translog,
+                               file_name, MYF(MY_WME)));
   }
 
-  pthread_mutex_unlock(&log_descriptor.purger_lock);
+  mysql_mutex_unlock(&log_descriptor.purger_lock);
   DBUG_RETURN(rc);
 }
 
@@ -8614,9 +8626,9 @@ uint32 translog_get_first_file(TRANSLOG_ADDRESS horizon)
 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;
 }
 
@@ -8835,7 +8847,8 @@ int translog_soft_sync_start(void)
   soft_need_sync= 1;
 
   if (!(res= ma_service_thread_control_init(&soft_sync_control)))
-    if (!(res= pthread_create(&th, NULL, ma_soft_sync_background, NULL)))
+    if (!(res= mysql_thread_create(key_thread_soft_sync,
+                                   &th, NULL, ma_soft_sync_background, NULL)))
       soft_sync_control.status= THREAD_RUNNING;
   DBUG_RETURN(res);
 }
@@ -9272,7 +9285,7 @@ int main(int argc, char **argv)
             opt_file, my_errno);
     goto err;
   }
-  if (my_seek(handler, opt_offset, SEEK_SET, MYF(MY_WME)) !=
+  if (mysql_file_seek(handler, opt_offset, SEEK_SET, MYF(MY_WME)) !=
       opt_offset)
   {
      fprintf(stderr, "Can't set position %lld  file: '%s'  errno: %d\n",
@@ -9283,7 +9296,7 @@ int main(int argc, char **argv)
        opt_pages;
        opt_offset+= TRANSLOG_PAGE_SIZE, opt_pages--)
   {
-    if (my_pread(handler, buffer, TRANSLOG_PAGE_SIZE, opt_offset,
+    if (mysql_file_pread(handler, buffer, TRANSLOG_PAGE_SIZE, opt_offset,
                  MYF(MY_NABP)))
     {
       if (my_errno == HA_ERR_FILE_TOO_SHORT)

storage/maria/ma_open.c

@@ -162,7 +162,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, const char *name,
     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);
@@ -189,7 +189,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, const char *name,
   }
   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 */
@@ -221,7 +221,7 @@ err:
     /* fall through */
   case 5:
     if (data_file < 0)
-      my_close(info.dfile.file, MYF(0));
+      mysql_file_close(info.dfile.file, MYF(0));
     break;
   }
   my_errno=save_errno;
@@ -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, NullS, 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;
 }
 
@@ -287,7 +287,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
     DBUG_RETURN(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)))
@@ -305,16 +305,18 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
                       my_errno= HA_ERR_CRASHED;
                       goto err;
                     });
-    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
+    if ((kfile=mysql_file_open(key_file_kfile, name_buff,
+                               (open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
     {
       if ((errno != EROFS && errno != EACCES) ||
 	  mode != O_RDONLY ||
-	  (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
+	  (kfile=mysql_file_open(key_file_kfile, name_buff,
+                                 (open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
 	goto err;
     }
     share->mode=open_mode;
     errpos= 1;
-    if (my_pread(kfile,share->state.header.file_version, head_length, 0,
+    if (mysql_file_pread(kfile,share->state.header.file_version, head_length, 0,
                  MYF(MY_NABP)))
     {
       my_errno= HA_ERR_NOT_A_TABLE;
@@ -381,7 +383,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
 
     end_pos=disk_cache+info_length;
     errpos= 3;
-    if (my_pread(kfile, disk_cache, info_length, 0L, MYF(MY_NABP)))
+    if (mysql_file_pread(kfile, disk_cache, info_length, 0L, MYF(MY_NABP)))
     {
       my_errno=HA_ERR_CRASHED;
       goto err;
@@ -536,7 +538,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
                          &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;
@@ -837,13 +839,17 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
       }
     }
     thr_lock_init(&share->lock);
-    pthread_mutex_init(&share->intern_lock, MY_MUTEX_INIT_FAST);
+    mysql_mutex_init(key_SHARE_intern_lock,
-    pthread_mutex_init(&share->key_del_lock, MY_MUTEX_INIT_FAST);
+                     &share->intern_lock, MY_MUTEX_INIT_FAST);
-    pthread_cond_init(&share->key_del_cond, 0);
+    mysql_mutex_init(key_SHARE_key_del_lock,
-    pthread_mutex_init(&share->close_lock, MY_MUTEX_INIT_FAST);
+                     &share->key_del_lock, MY_MUTEX_INIT_FAST);
+    mysql_cond_init(key_SHARE_key_del_cond, &share->key_del_cond, 0);
+    mysql_mutex_init(key_SHARE_close_lock,
+                     &share->close_lock, MY_MUTEX_INIT_FAST);
     for (i=0; i<keys; i++)
-      my_rwlock_init(&share->keyinfo[i].root_lock, NULL);
+      mysql_rwlock_init(key_KEYINFO_root_lock,
-    my_rwlock_init(&share->mmap_lock, NULL);
+                        &share->keyinfo[i].root_lock);
+    mysql_rwlock_init(key_SHARE_mmap_lock, &share->mmap_lock);
 
     share->row_is_visible= _ma_row_visible_always;
     share->lock.get_status= _ma_reset_update_flag;
@@ -926,7 +932,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
     DBUG_PRINT("warning", ("table is crashed: changed: %u",
                            share->state.changed));
 
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
   DBUG_RETURN(m_info);
 
 err:
@@ -946,7 +952,7 @@ err:
   switch (errpos) {
   case 5:
     if (data_file >= 0)
-      my_close(data_file, MYF(0));
+      mysql_file_close(data_file, MYF(0));
     if (old_info)
       break;					/* Don't remove open table */
     (*share->once_end)(share);
@@ -958,13 +964,13 @@ err:
     my_free(disk_cache);
     /* fall through */
   case 1:
-    my_close(kfile,MYF(0));
+    mysql_file_close(kfile,MYF(0));
     /* fall through */
   case 0:
   default:
     break;
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
   my_errno= save_errno;
   DBUG_RETURN (NULL);
 } /* maria_open */
@@ -1220,11 +1226,9 @@ uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite)
     return 0;
 
   if (pWrite & MA_STATE_INFO_WRITE_LOCK)
-    pthread_mutex_lock(&share->intern_lock);
+    mysql_mutex_lock(&share->intern_lock);
   else if (maria_multi_threaded)
-  {
+    mysql_mutex_assert_owner(&share->intern_lock);
-    safe_mutex_assert_owner(&share->intern_lock);
-  }
   if (share->base.born_transactional && translog_status == TRANSLOG_OK &&
       !maria_in_recovery)
   {
@@ -1239,7 +1243,7 @@ uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite)
   }
   res= _ma_state_info_write_sub(share->kfile.file, &share->state, pWrite);
   if (pWrite & MA_STATE_INFO_WRITE_LOCK)
-    pthread_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->intern_lock);
   share->changed= 0;
   return res;
 }
@@ -1338,9 +1342,9 @@ uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite)
   }
 
   res= (pWrite & MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET) ?
-    my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
+    mysql_file_pwrite(file, buff, (size_t) (ptr-buff), 0L,
               MYF(MY_NABP | MY_THREADSAFE)) :
-    my_write(file,  buff, (size_t) (ptr-buff),
+    mysql_file_write(file,  buff, (size_t) (ptr-buff),
              MYF(MY_NABP));
   DBUG_RETURN(res != 0);
 }
@@ -1422,7 +1426,7 @@ uint _ma_state_info_read_dsk(File file __attribute__((unused)),
   DBUG_ASSERT(state->create_rename_lsn == LSN_IMPOSSIBLE);
   if (!maria_single_user)
   {
-    if (my_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
+    if (mysql_file_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
       return 1;
     _ma_state_info_read(buff, state);
   }
@@ -1477,7 +1481,7 @@ uint _ma_base_info_write(File file, MARIA_BASE_INFO *base)
   *ptr++= base->extra_alloc_procent;
   bzero(ptr,16);					ptr+= 16; /* extra */
   DBUG_ASSERT((ptr - buff) == MARIA_BASE_INFO_SIZE);
-  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
+  return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 }
 
 
@@ -1539,7 +1543,7 @@ my_bool _ma_keydef_write(File file, MARIA_KEYDEF *keydef)
   mi_int2store(ptr,keydef->keylength);		ptr+= 2;
   mi_int2store(ptr,keydef->minlength);		ptr+= 2;
   mi_int2store(ptr,keydef->maxlength);		ptr+= 2;
-  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
+  return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 }
 
 uchar *_ma_keydef_read(uchar *ptr, MARIA_KEYDEF *keydef)
@@ -1582,7 +1586,7 @@ my_bool _ma_keyseg_write(File file, const HA_KEYSEG *keyseg)
   mi_int4store(ptr, pos);
   ptr+=4;
 
-  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
+  return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 }
 
 
@@ -1622,7 +1626,7 @@ my_bool _ma_uniquedef_write(File file, MARIA_UNIQUEDEF *def)
   *ptr++=  (uchar) def->key;
   *ptr++ = (uchar) def->null_are_equal;
 
-  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
+  return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 }
 
 uchar *_ma_uniquedef_read(uchar *ptr, MARIA_UNIQUEDEF *def)
@@ -1653,7 +1657,7 @@ my_bool _ma_columndef_write(File file, MARIA_COLUMNDEF *columndef)
   (*ptr++)= columndef->null_bit;
   (*ptr++)= columndef->empty_bit;
   ptr[0]= ptr[1]= ptr[2]= ptr[3]= 0;            ptr+= 4;  /* For future */
-  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
+  return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 }
 
 uchar *_ma_columndef_read(uchar *ptr, MARIA_COLUMNDEF *columndef)
@@ -1681,7 +1685,7 @@ my_bool _ma_column_nr_write(File file, uint16 *offsets, uint columns)
     return 1;
   for (ptr= buff, end= ptr + size; ptr < end ; ptr+= 2, offsets++)
     int2store(ptr, *offsets);
-  res= my_write(file, buff, size, MYF(MY_NABP)) != 0;
+  res= mysql_file_write(file, buff, size, MYF(MY_NABP)) != 0;
   my_afree(buff);
   return res;
 }
@@ -1793,8 +1797,8 @@ int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share, const char *org_name,
   }
 
   info->dfile.file= share->bitmap.file.file=
-    my_open(share->data_file_name.str, share->mode | O_SHARE,
+    mysql_file_open(key_file_dfile, share->data_file_name.str,
-            MYF(MY_WME));
+                    share->mode | O_SHARE, MYF(MY_WME));
   return info->dfile.file >= 0 ? 0 : 1;
 }
 
@@ -1805,11 +1809,12 @@ 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->kfile.file= mysql_file_open(key_file_kfile,
-                             share->mode | O_SHARE,
+                                     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);
 }
 

storage/maria/ma_packrec.c

@@ -184,7 +184,7 @@ static my_bool _ma_read_pack_info(MARIA_SHARE *share, File file,
     maria_quick_table_bits=MAX_QUICK_TABLE_BITS;
 
   my_errno=0;
-  if (my_read(file, header, sizeof(header), MYF(MY_NABP)))
+  if (mysql_file_read(file, header, sizeof(header), MYF(MY_NABP)))
   {
     if (!my_errno)
       my_errno=HA_ERR_END_OF_FILE;
@@ -252,7 +252,7 @@ static my_bool _ma_read_pack_info(MARIA_SHARE *share, File file,
   tmp_buff=share->decode_tables+length;
   disk_cache=(uchar*) (tmp_buff+OFFSET_TABLE_SIZE);
 
-  if (my_read(file,disk_cache,
+  if (mysql_file_read(file,disk_cache,
 	      (uint) (share->pack.header_length-sizeof(header)),
 	      MYF(MY_NABP)))
     goto err2;
@@ -752,7 +752,7 @@ int _ma_read_pack_record(MARIA_HA *info, uchar *buf, MARIA_RECORD_POS filepos)
                               &info->rec_buff, &info->rec_buff_size, file,
                               filepos))
     goto err;
-  if (my_read(file, info->rec_buff + block_info.offset ,
+  if (mysql_file_read(file, info->rec_buff + block_info.offset ,
 	      block_info.rec_len - block_info.offset, MYF(MY_NABP)))
     goto panic;
   info->update|= HA_STATE_AKTIV;
@@ -1385,7 +1385,7 @@ int _ma_read_rnd_pack_record(MARIA_HA *info,
   }
   else
   {
-    if (my_read(info->dfile.file, info->rec_buff + block_info.offset,
+    if (mysql_file_read(info->dfile.file, info->rec_buff + block_info.offset,
 		block_info.rec_len-block_info.offset,
 		MYF(MY_NABP)))
       goto err;
@@ -1420,8 +1420,8 @@ uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
       We can't use my_pread() here because _ma_read_rnd_pack_record assumes
       position is ok
     */
-    my_seek(file,filepos,MY_SEEK_SET,MYF(0));
+    mysql_file_seek(file,filepos,MY_SEEK_SET,MYF(0));
-    if (my_read(file, header,ref_length,MYF(MY_NABP)))
+    if (mysql_file_read(file, header,ref_length,MYF(MY_NABP)))
       return BLOCK_FATAL_ERROR;
     DBUG_DUMP("header", header, ref_length);
   }
@@ -1546,7 +1546,7 @@ my_bool _ma_memmap_file(MARIA_HA *info)
 
   if (!info->s->file_map)
   {
-    if (my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) <
+    if (mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) <
         share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
     {
       DBUG_PRINT("warning",("File isn't extended for memmap"));

storage/maria/ma_page.c

@@ -394,18 +394,18 @@ my_off_t _ma_new(register MARIA_HA *info, int level,
 
   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;
   }

storage/maria/ma_pagecache.c

@@ -639,7 +639,7 @@ static my_bool pagecache_fwrite(PAGECACHE *pagecache,
     flags     - MYF() flags
 */
 #define pagecache_fread(pagecache, filedesc, buffer, pageno, flags) \
-  my_pread((filedesc)->file, buffer, pagecache->block_size,         \
+  mysql_file_pread((filedesc)->file, buffer, pagecache->block_size,         \
            ((my_off_t) pageno << pagecache->shift), flags)
 
 
@@ -720,7 +720,7 @@ ulong init_pagecache(PAGECACHE *pagecache, size_t use_mem,
   pagecache->disk_blocks= -1;
   if (! pagecache->inited)
   {
-    if (mysql_mutex_init(ma_key_mutex_PAGECACHE_cache_lock,
+    if (mysql_mutex_init(key_PAGECACHE_cache_lock,
                          &pagecache->cache_lock, MY_MUTEX_INIT_FAST) ||
         my_hash_init(&pagecache->files_in_flush, &my_charset_bin, 32,
                   offsetof(struct st_file_in_flush, file),

storage/maria/ma_panic.c

@@ -45,7 +45,7 @@ int maria_panic(enum ha_panic_function flag)
 
   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 flag)
         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
@@ -87,9 +87,9 @@ int maria_panic(enum ha_panic_function flag)
 	  error=my_errno;
       }
 #ifdef CANT_OPEN_FILES_TWICE
-      if (info->s->kfile.file >= 0 && my_close(info->s->kfile.file, MYF(0)))
+      if (info->s->kfile.file >= 0 && mysql_file_close(info->s->kfile.file, MYF(0)))
 	error = my_errno;
-      if (info->dfile.file >= 0 && my_close(info->dfile.file, MYF(0)))
+      if (info->dfile.file >= 0 && mysql_file_close(info->dfile.file, MYF(0)))
 	error = my_errno;
       info->s->kfile.file= info->dfile.file= -1;/* Files aren't open anymore */
       break;
@@ -102,19 +102,18 @@ int maria_panic(enum ha_panic_function flag)
 	if (share->kfile.file < 0)
         {
 
-	  if ((share->kfile.file= my_open(fn_format(name_buff,
+	  if ((share->kfile.file= mysql_file_open(key_file_kfile,
-                                                    info->filename, "",
+                                       fn_format(name_buff, info->filename, "",
-                                                    N_NAME_IEXT,4),
+                                                 N_NAME_IEXT,4),
-                                          info->mode,
+                                       info->mode, MYF(MY_WME))) < 0)
-                                          MYF(MY_WME))) < 0)
 	    error = my_errno;  
         }
 	if (info->dfile.file < 0)
 	{
-	  if ((info->dfile.file= my_open(fn_format(name_buff, info->filename,
+	  if ((info->dfile.file= mysql_file_open(key_file_dfile,
-                                                   "", N_NAME_DEXT, 4),
+                                     fn_format(name_buff, info->filename,
-                                         info->mode,
+                                               "", N_NAME_DEXT, 4),
-                                         MYF(MY_WME))) < 0)
+                                      info->mode, MYF(MY_WME))) < 0)
 	    error = my_errno;
 	  info->rec_cache.file= info->dfile.file;
 	}
@@ -131,7 +130,7 @@ int maria_panic(enum ha_panic_function flag)
       break;
     }
   }
-  pthread_mutex_unlock(&THR_LOCK_maria);
+  mysql_mutex_unlock(&THR_LOCK_maria);
   if (flag == HA_PANIC_CLOSE)
     maria_end();
   if (!error)

storage/maria/ma_range.c

@@ -60,7 +60,7 @@ ha_rows maria_records_in_range(MARIA_HA *info, int inx, key_range *min_key,
   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 *info, int inx, key_range *min_key,
   }
 
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    mysql_rwlock_unlock(&keyinfo->root_lock);
   fast_ma_writeinfo(info);
 
   /**

storage/maria/ma_recovery.c

@@ -864,15 +864,16 @@ prototype_redo_exec_hook(REDO_CREATE_TABLE)
   linkname_ptr= NULL;
   create_flag= MY_DELETE_OLD;
   tprint(tracef, "Table '%s' creating as '%s'\n", name, filename);
-  if ((kfile= my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
+  if ((kfile= mysql_file_create_with_symlink(key_file_kfile, linkname_ptr,
-                                     MYF(MY_WME|create_flag))) < 0)
+                                             filename, 0, create_mode,
+                                             MYF(MY_WME|create_flag))) < 0)
   {
     eprint(tracef, "Failed to create index file");
     goto end;
   }
   if (my_pwrite(kfile, kfile_header,
                 kfile_size_before_extension, 0, MYF(MY_NABP|MY_WME)) ||
-      my_chsize(kfile, keystart, 0, MYF(MY_WME)))
+      mysql_file_chsize(kfile, keystart, 0, MYF(MY_WME)))
   {
     eprint(tracef, "Failed to write to index file");
     goto end;
@@ -884,9 +885,10 @@ prototype_redo_exec_hook(REDO_CREATE_TABLE)
     linkname_ptr= NULL;
     create_flag=MY_DELETE_OLD;
     if (((dfile=
-          my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
+          mysql_file_create_with_symlink(key_file_dfile, linkname_ptr,
-                                 MYF(MY_WME | create_flag))) < 0) ||
+                                         filename, 0, create_mode,
-        my_close(dfile, MYF(MY_WME)))
+                                         MYF(MY_WME | create_flag))) < 0) ||
+        mysql_file_close(dfile, MYF(MY_WME)))
     {
       eprint(tracef, "Failed to create data file");
       goto end;
@@ -907,7 +909,7 @@ prototype_redo_exec_hook(REDO_CREATE_TABLE)
   error= 0;
 end:
   if (kfile >= 0)
-    error|= my_close(kfile, MYF(MY_WME));
+    error|= mysql_file_close(kfile, MYF(MY_WME));
   if (info != NULL)
     error|= maria_close(info);
   DBUG_RETURN(error);
@@ -1387,8 +1389,8 @@ static int new_table(uint16 sid, const char *name, LSN lsn_of_file_id)
   /* don't log any records for this work */
   _ma_tmp_disable_logging_for_table(info, FALSE);
   /* execution of some REDO records relies on data_file_length */
-  dfile_len= my_seek(info->dfile.file, 0, SEEK_END, MYF(MY_WME));
+  dfile_len= mysql_file_seek(info->dfile.file, 0, SEEK_END, MYF(MY_WME));
-  kfile_len= my_seek(info->s->kfile.file, 0, SEEK_END, MYF(MY_WME));
+  kfile_len= mysql_file_seek(info->s->kfile.file, 0, SEEK_END, MYF(MY_WME));
   if ((dfile_len == MY_FILEPOS_ERROR) ||
       (kfile_len == MY_FILEPOS_ERROR))
   {
@@ -3341,7 +3343,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");
@@ -3372,7 +3374,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
@@ -3387,10 +3389,10 @@ static int close_all_tables(void)
     }
     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);
 }
 

storage/maria/ma_rename.c

@@ -107,18 +107,14 @@ int maria_rename(const char *old_name, const char *new_name)
 
   fn_format(from,old_name,"",MARIA_NAME_IEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
   fn_format(to,new_name,"",MARIA_NAME_IEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
-  if (my_rename_with_symlink(from, to, MYF(MY_WME | sync_dir)))
+  if (mysql_file_rename_with_symlink(key_file_kfile, from, to,
+                                     MYF(MY_WME | sync_dir)))
     DBUG_RETURN(my_errno);
   fn_format(from,old_name,"",MARIA_NAME_DEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
   fn_format(to,new_name,"",MARIA_NAME_DEXT,MY_UNPACK_FILENAME|MY_APPEND_EXT);
-#ifdef USE_RAID
+  data_file_rename_error=
-  if (raid_type)
+      mysql_file_rename_with_symlink(key_file_dfile, from, to,
-    data_file_rename_error= my_raid_rename(from, to, raid_chunks,
+                                     MYF(MY_WME | sync_dir));
-                                           MYF(MY_WME | sync_dir));
-  else
-#endif
-    data_file_rename_error=
-      my_rename_with_symlink(from, to, MYF(MY_WME | sync_dir));
   if (data_file_rename_error)
   {
     /*
@@ -128,7 +124,8 @@ int maria_rename(const char *old_name, const char *new_name)
     data_file_rename_error= my_errno;
     fn_format(from, old_name, "", MARIA_NAME_IEXT, MYF(MY_UNPACK_FILENAME|MY_APPEND_EXT));
     fn_format(to, new_name, "", MARIA_NAME_IEXT, MYF(MY_UNPACK_FILENAME|MY_APPEND_EXT));
-    my_rename_with_symlink(to, from, MYF(MY_WME | sync_dir));
+    mysql_file_rename_with_symlink(key_file_kfile, to, from,
+                                   MYF(MY_WME | sync_dir));
   }
   DBUG_RETURN(data_file_rename_error);
 

storage/maria/ma_rkey.c

@@ -80,7 +80,7 @@ int maria_rkey(MARIA_HA *info, uchar *buf, int inx, const uchar *key_data,
   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;
   if (search_flag != HA_READ_KEY_EXACT ||
@@ -165,7 +165,7 @@ int maria_rkey(MARIA_HA *info, uchar *buf, int inx, const uchar *key_data,
     }
   }
   if (share->lock_key_trees)
-    rw_unlock(&keyinfo->root_lock);
+    mysql_rwlock_unlock(&keyinfo->root_lock);
 
   if (info->cur_row.lastpos == HA_OFFSET_ERROR || (icp_res != 1))
   {

storage/maria/ma_rnext.c

@@ -44,7 +44,7 @@ int maria_rnext(MARIA_HA *info, uchar *buf, int inx)
     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)
   {
@@ -102,7 +102,7 @@ int maria_rnext(MARIA_HA *info, uchar *buf, int inx)
     }
   }
   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);

storage/maria/ma_rnext_same.c

@@ -41,7 +41,7 @@ int maria_rnext_same(MARIA_HA *info, uchar *buf)
 
   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
@@ -87,7 +87,7 @@ int maria_rnext_same(MARIA_HA *info, uchar *buf)
       }
   }
   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;

storage/maria/ma_rprev.c

@@ -42,7 +42,7 @@ int maria_rprev(MARIA_HA *info, uchar *buf, int inx)
   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 *buf, int inx)
     }
   }
   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)

storage/maria/ma_rsame.c

@@ -62,11 +62,11 @@ int maria_rsame(MARIA_HA *info, uchar *record, int inx)
                          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);
     _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))

storage/maria/ma_servicethread.c

@@ -18,8 +18,10 @@ int ma_service_thread_control_init(MA_SERVICE_THREAD_CONTROL *control)
   DBUG_PRINT("init", ("control 0x%lx", (ulong) control));
   control->inited= TRUE;
   control->status= THREAD_DEAD; /* not yet born == dead */
-  res= (pthread_mutex_init(control->LOCK_control, MY_MUTEX_INIT_SLOW) ||
+  res= (mysql_mutex_init(key_SERVICE_THREAD_CONTROL_lock,
-        pthread_cond_init(control->COND_control, 0));
+                         control->LOCK_control, MY_MUTEX_INIT_SLOW) ||
+        mysql_cond_init(key_SERVICE_THREAD_CONTROL_cond,
+                        control->COND_control, 0));
   DBUG_PRINT("info", ("init: %s", (res ? "Error" : "OK")));
   DBUG_RETURN(res);
 }
@@ -41,7 +43,7 @@ void ma_service_thread_control_end(MA_SERVICE_THREAD_CONTROL *control)
   DBUG_ENTER("ma_service_thread_control_end");
   DBUG_PRINT("init", ("control 0x%lx", (ulong) control));
   DBUG_ASSERT(control->inited);
-  pthread_mutex_lock(control->LOCK_control);
+  mysql_mutex_lock(control->LOCK_control);
   if (control->status != THREAD_DEAD) /* thread was started OK */
   {
     DBUG_PRINT("info",("killing Maria background thread"));
@@ -49,15 +51,15 @@ void ma_service_thread_control_end(MA_SERVICE_THREAD_CONTROL *control)
     do /* and wait for it to be dead */
     {
       /* wake it up if it was in a sleep */
-      pthread_cond_broadcast(control->COND_control);
+      mysql_cond_broadcast(control->COND_control);
       DBUG_PRINT("info",("waiting for Maria background thread to die"));
-      pthread_cond_wait(control->COND_control, control->LOCK_control);
+      mysql_cond_wait(control->COND_control, control->LOCK_control);
     }
     while (control->status != THREAD_DEAD);
   }
-  pthread_mutex_unlock(control->LOCK_control);
+  mysql_mutex_unlock(control->LOCK_control);
-  pthread_mutex_destroy(control->LOCK_control);
+  mysql_mutex_destroy(control->LOCK_control);
-  pthread_cond_destroy(control->COND_control);
+  mysql_cond_destroy(control->COND_control);
   control->inited= FALSE;
   DBUG_VOID_RETURN;
 }
@@ -81,29 +83,29 @@ my_bool my_service_thread_sleep(MA_SERVICE_THREAD_CONTROL *control,
   my_bool res= FALSE;
   DBUG_ENTER("my_service_thread_sleep");
   DBUG_PRINT("init", ("control 0x%lx", (ulong) control));
-  pthread_mutex_lock(control->LOCK_control);
+  mysql_mutex_lock(control->LOCK_control);
   if (control->status == THREAD_DYING)
   {
-    pthread_mutex_unlock(control->LOCK_control);
+    mysql_mutex_unlock(control->LOCK_control);
     DBUG_RETURN(TRUE);
   }
 #if 0 /* good for testing, to do a lot of checkpoints, finds a lot of bugs */
-  pthread_mutex_unlock(&control->LOCK_control);
+  mysql_mutex_unlock(&control->LOCK_control);
   my_sleep(100000); /* a tenth of a second */
-  pthread_mutex_lock(&control->LOCK_control);
+  mysql_mutex_lock(&control->LOCK_control);
 #else
     /* To have a killable sleep, we use timedwait like our SQL GET_LOCK() */
   DBUG_PRINT("info", ("sleeping %llu nano seconds", sleep_time));
   if (sleep_time)
   {
     set_timespec_nsec(abstime, sleep_time);
-    pthread_cond_timedwait(control->COND_control,
+    mysql_cond_timedwait(control->COND_control,
                            control->LOCK_control, &abstime);
   }
 #endif
   if (control->status == THREAD_DYING)
     res= TRUE;
-  pthread_mutex_unlock(control->LOCK_control);
+  mysql_mutex_unlock(control->LOCK_control);
   DBUG_RETURN(res);
 }
 
@@ -118,17 +120,17 @@ void my_service_thread_signal_end(MA_SERVICE_THREAD_CONTROL *control)
 {
   DBUG_ENTER("my_service_thread_signal_end");
   DBUG_PRINT("init", ("control 0x%lx", (ulong) control));
-  pthread_mutex_lock(control->LOCK_control);
+  mysql_mutex_lock(control->LOCK_control);
   control->status = THREAD_DEAD; /* indicate that we are dead */
   /*
     wake up ma_service_thread_control_end which may be waiting for
     our death
   */
-  pthread_cond_broadcast(control->COND_control);
+  mysql_cond_broadcast(control->COND_control);
   /*
     broadcast was inside unlock because ma_service_thread_control_end
     destroys mutex
   */
-  pthread_mutex_unlock(control->LOCK_control);
+  mysql_mutex_unlock(control->LOCK_control);
   DBUG_VOID_RETURN;
 }

storage/maria/ma_servicethread.h

@@ -9,9 +9,9 @@ typedef struct st_ma_service_thread_control
   /** if thread module was inited or not */
   my_bool inited;
   /** for killing the background thread */
-  pthread_mutex_t *LOCK_control;
+  mysql_mutex_t *LOCK_control;
   /** for killing the background thread */
-  pthread_cond_t *COND_control;
+  mysql_cond_t *COND_control;
 } MA_SERVICE_THREAD_CONTROL;
 
 

storage/maria/ma_sort.c

@@ -482,10 +482,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);
+      mysql_cond_signal(&sort_param->sort_info->cond);
-    pthread_mutex_unlock(&sort_param->sort_info->mutex);
+    mysql_mutex_unlock(&sort_param->sort_info->mutex);
     DBUG_PRINT("exit", ("======== ending thread ========"));
   }
   my_thread_end();
@@ -833,7 +833,7 @@ static uint read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
 
   if ((count=(uint) min((ha_rows) buffpek->max_keys,buffpek->count)))
   {
-    if (my_pread(fromfile->file, buffpek->base,
+    if (mysql_file_pread(fromfile->file, buffpek->base,
                  (length= sort_length*count),buffpek->file_pos,MYF_RW))
       return((uint) -1);                        /* purecov: inspected */
     buffpek->key=buffpek->base;
@@ -858,11 +858,11 @@ static uint read_to_buffer_varlen(IO_CACHE *fromfile, BUFFPEK *buffpek,
     for (idx=1;idx<=count;idx++)
     {
       uint16 length_of_key;
-      if (my_pread(fromfile->file,(uchar*)&length_of_key,sizeof(length_of_key),
+      if (mysql_file_pread(fromfile->file,(uchar*)&length_of_key,sizeof(length_of_key),
                    buffpek->file_pos,MYF_RW))
         return((uint) -1);
       buffpek->file_pos+=sizeof(length_of_key);
-      if (my_pread(fromfile->file, buffp, length_of_key,
+      if (mysql_file_pread(fromfile->file, buffp, length_of_key,
                    buffpek->file_pos,MYF_RW))
         return((uint) -1);
       buffpek->file_pos+=length_of_key;

storage/maria/ma_state.c

@@ -82,7 +82,7 @@ my_bool _ma_setup_live_state(MARIA_HA *info)
   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));
@@ -98,7 +98,7 @@ my_bool _ma_setup_live_state(MARIA_HA *info)
   */
   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;
   tables->state_current.changed= tables->state_current.no_transid= 0;
@@ -215,10 +215,10 @@ void _ma_remove_not_visible_states_with_lock(MARIA_SHARE *share,
   if ((is_lock_trman= trman_is_inited()))
     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,
                                                        all, 1);
-  pthread_mutex_unlock(&share->intern_lock);
+  mysql_mutex_unlock(&share->intern_lock);
   if (is_lock_trman)
     trnman_unlock();
 }
@@ -444,7 +444,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *trn, my_bool commit,
     {
       MARIA_STATE_HISTORY *history;
 
-      pthread_mutex_lock(&share->intern_lock);
+      mysql_mutex_lock(&share->intern_lock);
 
       /* We only have to update history state if something changed */
       if (tables->state_current.changed)
@@ -476,7 +476,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *trn, my_bool commit,
             {
               /* purecov: begin inspected */
               error= 1;
-              pthread_mutex_unlock(&share->intern_lock);
+              mysql_mutex_unlock(&share->intern_lock);
               my_free(tables);
               continue;
               /* purecov: end */
@@ -512,7 +512,7 @@ my_bool _ma_trnman_end_trans_hook(TRN *trn, my_bool commit,
         }
       }
       share->in_trans--;
-      pthread_mutex_unlock(&share->intern_lock);
+      mysql_mutex_unlock(&share->intern_lock);
     }
     else
     {
@@ -521,9 +521,9 @@ my_bool _ma_trnman_end_trans_hook(TRN *trn, my_bool commit,
         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);
@@ -550,7 +550,7 @@ void _ma_remove_table_from_trnman(MARIA_SHARE *share, TRN *trn)
   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**) (char*) &trn->used_tables, tables= *prev;
        tables;
@@ -712,10 +712,10 @@ void maria_versioning(MARIA_HA *info, my_bool versioning)
 
 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);
 }
 
 

storage/maria/ma_static.c

@@ -38,7 +38,7 @@ 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 */
 my_bool maria_recovery_changed_data= 0, maria_recovery_verbose= 0;
-pthread_mutex_t THR_LOCK_maria;
+mysql_mutex_t THR_LOCK_maria;
 #ifdef DONT_USE_RW_LOCKS
 ulong maria_concurrent_insert= 0;
 #else
@@ -109,23 +109,36 @@ static int always_valid(const char *filename __attribute__((unused)))
 int (*maria_test_invalid_symlink)(const char *filename)= always_valid;
 
 #ifdef HAVE_PSI_INTERFACE
-PSI_mutex_key ma_key_mutex_PAGECACHE_cache_lock;
 
-static PSI_mutex_info all_mutexes[]=
+PSI_mutex_key key_SHARE_BITMAP_lock, key_SORT_INFO_mutex,
-{
+              key_THR_LOCK_maria, key_TRANSLOG_BUFFER_mutex,
-  { &ma_key_mutex_PAGECACHE_cache_lock, "PAGECACHE::cache_lock", 0}
+              key_LOCK_soft_sync,
-};
+              key_TRANSLOG_DESCRIPTOR_dirty_buffer_mask_lock,
+              key_TRANSLOG_DESCRIPTOR_sent_to_disk_lock,
+              key_TRANSLOG_DESCRIPTOR_log_flush_lock,
+              key_TRANSLOG_DESCRIPTOR_file_header_lock,
+              key_TRANSLOG_DESCRIPTOR_unfinished_files_lock,
+              key_TRANSLOG_DESCRIPTOR_purger_lock,
+              key_SHARE_intern_lock, key_SHARE_key_del_lock,
+              key_SHARE_close_lock, key_PAGECACHE_cache_lock,
+              key_SERVICE_THREAD_CONTROL_lock,
+              key_LOCK_trn_list, key_TRN_state_lock;
 
-void init_aria_psi_keys()
+PSI_cond_key key_SHARE_key_del_cond, key_SERVICE_THREAD_CONTROL_cond,
-{
+             key_SORT_INFO_cond, key_SHARE_BITMAP_cond,
-  const char* category= "aria";
+             key_COND_soft_sync, key_TRANSLOG_BUFFER_waiting_filling_buffer,
-  int count;
+             key_TRANSLOG_BUFFER_prev_sent_to_disk_cond,
+             key_TRANSLOG_DESCRIPTOR_log_flush_cond,
+             key_TRANSLOG_DESCRIPTOR_new_goal_cond;
 
-  if (PSI_server == NULL)
+PSI_rwlock_key key_KEYINFO_root_lock, key_SHARE_mmap_lock,
-    return;
+               key_TRANSLOG_DESCRIPTOR_open_files_lock;
+
+PSI_thread_key key_thread_checkpoint, key_thread_find_all_keys,
+               key_thread_soft_sync;
+
+PSI_file_key key_file_translog, key_file_kfile, key_file_dfile,
+             key_file_control;
 
-  count= array_elements(all_mutexes);
-  PSI_server->register_mutex(category, all_mutexes, count);
-}
 #endif /* HAVE_PSI_INTERFACE */
 

storage/maria/ma_write.c

@@ -161,7 +161,7 @@ int maria_write(MARIA_HA *info, uchar *record)
                                   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 )
@@ -169,7 +169,7 @@ int maria_write(MARIA_HA *info, uchar *record)
         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;
         }
@@ -196,7 +196,7 @@ int maria_write(MARIA_HA *info, uchar *record)
           if (info->dup_key_trid == info->trn->trid ||
               my_errno != HA_ERR_FOUND_DUPP_KEY)
           {
-	    rw_unlock(&keyinfo->root_lock);
+	    mysql_rwlock_unlock(&keyinfo->root_lock);
             goto err;
           }
           /* Different TrIDs: table must be transactional */
@@ -219,11 +219,11 @@ int maria_write(MARIA_HA *info, uchar *record)
           if (!blocker || blocker->commit_trid != ~(TrID)0)
           { /* committed */
             if (blocker)
-              pthread_mutex_unlock(& blocker->state_lock);
+              mysql_mutex_unlock(& blocker->state_lock);
-            rw_unlock(&keyinfo->root_lock);
+            mysql_rwlock_unlock(&keyinfo->root_lock);
             goto err;
           }
-          rw_unlock(&keyinfo->root_lock);
+          mysql_rwlock_unlock(&keyinfo->root_lock);
           {
             /* running. now we wait */
             WT_RESOURCE_ID rc;
@@ -236,7 +236,7 @@ int maria_write(MARIA_HA *info, uchar *record)
             res= wt_thd_will_wait_for(info->trn->wt, blocker->wt, & rc);
             if (res != WT_OK)
             {
-              pthread_mutex_unlock(& blocker->state_lock);
+              mysql_mutex_unlock(& blocker->state_lock);
               my_errno= HA_ERR_LOCK_DEADLOCK;
               goto err;
             }
@@ -246,7 +246,7 @@ int maria_write(MARIA_HA *info, uchar *record)
             res= wt_thd_cond_timedwait(info->trn->wt, & blocker->state_lock);
             proc_info_hook(0, old_proc_info, __func__, __FILE__, __LINE__);
 
-            pthread_mutex_unlock(& blocker->state_lock);
+            mysql_mutex_unlock(& blocker->state_lock);
             if (res != WT_OK)
             {
               my_errno= res == WT_TIMEOUT ? HA_ERR_LOCK_WAIT_TIMEOUT
@@ -254,7 +254,7 @@ int maria_write(MARIA_HA *info, uchar *record)
               goto err;
             }
           }
-          rw_wrlock(&keyinfo->root_lock);
+          mysql_rwlock_wrlock(&keyinfo->root_lock);
 #ifndef MARIA_CANNOT_ROLLBACK
           keyinfo->version++;
 #endif
@@ -265,7 +265,7 @@ int maria_write(MARIA_HA *info, uchar *record)
       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)
@@ -347,7 +347,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
@@ -357,7 +357,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;
 	  }
         }
@@ -369,12 +369,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);
       }
     }
   }
@@ -1671,7 +1671,7 @@ static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
   case free_init:
     if (share->lock_key_trees)
     {
-      rw_wrlock(&keyinfo->root_lock);
+      mysql_rwlock_wrlock(&keyinfo->root_lock);
       keyinfo->version++;
     }
     return 0;
@@ -1692,7 +1692,7 @@ static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
     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;

storage/maria/maria_def.h

@@ -26,6 +26,7 @@
 #include "ma_control_file.h"
 #include "ma_state.h"
 #include <waiting_threads.h>
+#include <mysql/psi/mysql_file.h>
 
 /* For testing recovery */
 #ifdef TO_BE_REMOVED
@@ -246,8 +247,8 @@ typedef struct st_maria_file_bitmap
   uint non_flushable;                  /**< 0 if bitmap and log are in sync */
   PAGECACHE_FILE file;		       /* datafile where bitmap is stored */
 
-  pthread_mutex_t bitmap_lock;
+  mysql_mutex_t bitmap_lock;
-  pthread_cond_t bitmap_cond;          /**< When bitmap becomes flushable */
+  mysql_cond_t bitmap_cond;          /**< When bitmap becomes flushable */
   /* Constants, allocated when initiating bitmaps */
   uint sizes[8];                      /* Size per bit combination */
   uint total_size;		      /* Total usable size of bitmap page */
@@ -395,20 +396,20 @@ typedef struct st_maria_share
     versioning information (like in_trans, state_history).
     @todo find the exhaustive list.
   */
-  pthread_mutex_t intern_lock;	
+  mysql_mutex_t intern_lock;	
-  pthread_mutex_t key_del_lock;
+  mysql_mutex_t key_del_lock;
-  pthread_cond_t  key_del_cond;
+  mysql_cond_t  key_del_cond;
   /**
     _Always_ held while closing table; prevents checkpoint from looking at
     structures freed during closure (like bitmap). If you need close_lock and
     intern_lock, lock them in this order.
   */
-  pthread_mutex_t close_lock;
+  mysql_mutex_t close_lock;
   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;
 
@@ -764,7 +765,7 @@ struct st_maria_handler
 #define MARIA_UNIQUE_HASH_TYPE	HA_KEYTYPE_ULONG_INT
 #define maria_unique_store(A,B)    mi_int4store((A),(B))
 
-extern pthread_mutex_t THR_LOCK_maria;
+extern mysql_mutex_t THR_LOCK_maria;
 #ifdef DONT_USE_RW_LOCKS
 #define rw_wrlock(A) {}
 #define rw_rdlock(A) {}
@@ -795,6 +796,39 @@ extern my_bool maria_recovery_verbose;
 extern HASH maria_stored_state;
 extern int (*maria_create_trn_hook)(MARIA_HA *);
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_SHARE_BITMAP_lock, key_SORT_INFO_mutex,
+                     key_THR_LOCK_maria, key_TRANSLOG_BUFFER_mutex,
+                     key_LOCK_soft_sync,
+                     key_TRANSLOG_DESCRIPTOR_dirty_buffer_mask_lock,
+                     key_TRANSLOG_DESCRIPTOR_sent_to_disk_lock,
+                     key_TRANSLOG_DESCRIPTOR_log_flush_lock,
+                     key_TRANSLOG_DESCRIPTOR_file_header_lock,
+                     key_TRANSLOG_DESCRIPTOR_unfinished_files_lock,
+                     key_TRANSLOG_DESCRIPTOR_purger_lock,
+                     key_SHARE_intern_lock, key_SHARE_key_del_lock,
+                     key_SHARE_close_lock,
+                     key_SERVICE_THREAD_CONTROL_lock,
+                     key_PAGECACHE_cache_lock;
+
+extern PSI_cond_key key_SHARE_key_del_cond, key_SERVICE_THREAD_CONTROL_cond,
+                    key_SORT_INFO_cond, key_SHARE_BITMAP_cond,
+                    key_COND_soft_sync, key_TRANSLOG_BUFFER_waiting_filling_buffer,
+                    key_TRANSLOG_BUFFER_prev_sent_to_disk_cond,
+                    key_TRANSLOG_DESCRIPTOR_log_flush_cond,
+                    key_TRANSLOG_DESCRIPTOR_new_goal_cond;
+
+extern PSI_rwlock_key key_KEYINFO_root_lock, key_SHARE_mmap_lock,
+                      key_TRANSLOG_DESCRIPTOR_open_files_lock;
+
+extern PSI_thread_key key_thread_checkpoint, key_thread_find_all_keys,
+                      key_thread_soft_sync;
+
+extern PSI_file_key key_file_translog, key_file_kfile, key_file_dfile,
+                    key_file_control;
+
+#endif
+
 /* This is used by _ma_calc_xxx_key_length och _ma_store_key */
 typedef struct st_maria_s_param
 {
@@ -1250,17 +1284,3 @@ extern void ma_set_index_cond_func(MARIA_HA *info, index_cond_func_t func,
                                    void *func_arg);
 int ma_check_index_cond(register MARIA_HA *info, uint keynr, uchar *record);
 
-#ifdef HAVE_PSI_INTERFACE
-extern PSI_mutex_key ma_key_mutex_PAGECACHE_cache_lock;
-
-//extern PSI_rwlock_key mi_key_rwlock_MYISAM_SHARE_key_root_lock;
-
-//extern PSI_cond_key mi_key_cond_MI_SORT_INFO_cond;
-
-//extern PSI_file_key mi_key_file_datatmp;
-
-//extern PSI_thread_key mi_key_thread_find_all_keys;
-
-void init_aria_psi_keys();
-#endif /* HAVE_PSI_INTERFACE */
-

storage/maria/tablockman.c

@@ -280,7 +280,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo,
   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);
 
@@ -296,16 +296,16 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo,
   }
 
   /* 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))
     {
@@ -441,13 +441,13 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo,
       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);
+    mysql_mutex_lock(wait_for->mutex);
-    pthread_mutex_unlock(& table->mutex);
+    mysql_mutex_unlock(& table->mutex);
 
     /* now really wait */
     i= pthread_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)
     {
@@ -456,7 +456,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo,
       goto ret2;
     }
 
-    pthread_mutex_lock(& table->mutex);
+    mysql_mutex_lock(& table->mutex);
 
     /* ... and repeat from the beginning */
   }
@@ -491,7 +491,7 @@ tablockman_getlock(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo,
   res= getlock_result[lock][lock];
 
 ret:
-  pthread_mutex_unlock(& table->mutex);
+  mysql_mutex_unlock(& table->mutex);
 ret2:
   DBUG_ASSERT(res);
   return res;
@@ -518,7 +518,7 @@ void tablockman_release_locks(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo)
   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);
 
     /*
@@ -542,13 +542,13 @@ void tablockman_release_locks(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo)
     if (lock->next &&
         lock_compatibility_matrix[lock->next->lock_type][lock->lock_type])
     {
-      pthread_mutex_lock(lo->waiting_for->mutex);
+      mysql_mutex_lock(lo->waiting_for->mutex);
       pthread_cond_broadcast(lo->waiting_for->cond);
-      pthread_mutex_unlock(lo->waiting_for->mutex);
+      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;
@@ -559,14 +559,14 @@ void tablockman_release_locks(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo)
   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);
     my_hash_delete(& cur->table->latest_locks, (uchar *)cur);
 
     if (cur->prev)
@@ -579,7 +579,7 @@ void tablockman_release_locks(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo)
     cur->next= local_pool;
     local_pool= cur;
 
-    pthread_mutex_unlock(mutex);
+    mysql_mutex_unlock(mutex);
   }
 
   lo->waiting_lock= lo->active_locks= 0;
@@ -588,15 +588,15 @@ void tablockman_release_locks(TABLOCKMAN *lm, TABLE_LOCK_OWNER *lo)
     okay, all locks released. now signal that we're leaving,
     in case somebody's waiting for it
   */
-  pthread_mutex_lock(lo->mutex);
+  mysql_mutex_lock(lo->mutex);
   pthread_cond_broadcast(lo->cond);
-  pthread_mutex_unlock(lo->mutex);
+  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)
@@ -604,7 +604,7 @@ void tablockman_init(TABLOCKMAN *lm, loid_to_tlo_func *func, uint timeout)
   lm->pool= 0;
   lm->loid_to_tlo= func;
   lm->lock_timeout= timeout;
-  pthread_mutex_init(& lm->pool_mutex, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(& lm->pool_mutex, MY_MUTEX_INIT_FAST);
   my_getsystime(); /* ensure that my_getsystime() is initialized */
 }
 
@@ -616,7 +616,7 @@ void tablockman_destroy(TABLOCKMAN *lm)
     lm->pool= tmp->next;
     my_free(tmp);
   }
-  pthread_mutex_destroy(& lm->pool_mutex);
+  mysql_mutex_destroy(& lm->pool_mutex);
 }
 
 /*
@@ -629,7 +629,7 @@ void tablockman_destroy(TABLOCKMAN *lm)
 void tablockman_init_locked_table(LOCKED_TABLE *lt, int initial_hash_size)
 {
   bzero(lt, sizeof(*lt));
-  pthread_mutex_init(& lt->mutex, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(& lt->mutex, MY_MUTEX_INIT_FAST);
   my_hash_init(& lt->latest_locks, & my_charset_bin, initial_hash_size,
             offsetof(TABLE_LOCK, loid),
             sizeof(((TABLE_LOCK*)0)->loid), 0, 0, 0);
@@ -646,7 +646,7 @@ void tablockman_destroy_locked_table(LOCKED_TABLE *lt)
      DBUG_ASSERT(lt->active_locks[i] == 0);
 
   my_hash_free(& lt->latest_locks);
-  pthread_mutex_destroy(& lt->mutex);
+  mysql_mutex_destroy(& lt->mutex);
 }
 
 #ifdef EXTRA_DEBUG

storage/maria/tablockman.h

@@ -51,12 +51,12 @@ typedef struct st_table_lock_owner {
   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_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 */

storage/maria/trnman.c

@@ -45,7 +45,7 @@ static TrID global_trid_generator;
 static TrID trid_min_read_from= MAX_TRID;
 
 /* 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;
@@ -185,8 +185,8 @@ int trnman_init(TrID initial_trid)
   trid_min_read_from= initial_trid;
   lf_hash_init(&trid_to_trn, sizeof(TRN*), LF_HASH_UNIQUE,
                0, 0, trn_get_hash_key, 0);
-  DBUG_PRINT("info", ("pthread_mutex_init LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_init LOCK_trn_list"));
-  pthread_mutex_init(&LOCK_trn_list, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_trn_list, &LOCK_trn_list, MY_MUTEX_INIT_FAST);
   my_atomic_rwlock_init(&LOCK_short_trid_to_trn);
   my_atomic_rwlock_init(&LOCK_pool);
 
@@ -216,12 +216,12 @@ void trnman_destroy()
     TRN *trn= pool;
     pool= pool->next;
     DBUG_ASSERT(trn->wt == NULL);
-    pthread_mutex_destroy(&trn->state_lock);
+    mysql_mutex_destroy(&trn->state_lock);
     my_free(trn);
   }
   lf_hash_destroy(&trid_to_trn);
-  DBUG_PRINT("info", ("pthread_mutex_destroy LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_destroy LOCK_trn_list"));
-  pthread_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(short_trid_to_active_trn+1);
@@ -240,8 +240,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"));
+  DBUG_PRINT("info", ("mysql_mutex_assert_owner LOCK_trn_list"));
-  safe_mutex_assert_owner(&LOCK_trn_list);
+  mysql_mutex_assert_owner(&LOCK_trn_list);
   DBUG_RETURN(++global_trid_generator);
 }
 
@@ -293,8 +293,8 @@ TRN *trnman_new_trn(WT_THD *wt)
     mutex.
   */
 
-  DBUG_PRINT("info", ("pthread_mutex_lock LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
-  pthread_mutex_lock(&LOCK_trn_list);
+  mysql_mutex_lock(&LOCK_trn_list);
 
   /* Allocating a new TRN structure */
   tmp.trn= pool;
@@ -320,19 +320,19 @@ TRN *trnman_new_trn(WT_THD *wt)
     trn= (TRN *)my_malloc(sizeof(TRN), MYF(MY_WME | MY_ZEROFILL));
     if (unlikely(!trn))
     {
-      DBUG_PRINT("info", ("pthread_mutex_unlock LOCK_trn_list"));
+      DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
-      pthread_mutex_unlock(&LOCK_trn_list);
+      mysql_mutex_unlock(&LOCK_trn_list);
       return 0;
     }
     trnman_allocated_transactions++;
-    pthread_mutex_init(&trn->state_lock, MY_MUTEX_INIT_FAST);
+    mysql_mutex_init(key_TRN_state_lock, &trn->state_lock, MY_MUTEX_INIT_FAST);
   }
   trn->wt= wt;
   trn->pins= lf_hash_get_pins(&trid_to_trn);
   if (!trn->pins)
   {
     trnman_free_trn(trn);
-    pthread_mutex_unlock(&LOCK_trn_list);
+    mysql_mutex_unlock(&LOCK_trn_list);
     return 0;
   }
 
@@ -346,8 +346,8 @@ TRN *trnman_new_trn(WT_THD *wt)
   trn->prev= active_list_max.prev;
   active_list_max.prev= trn->prev->next= trn;
   trid_min_read_from= active_list_min.next->min_read_from;
-  DBUG_PRINT("info", ("pthread_mutex_unlock LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
-  pthread_mutex_unlock(&LOCK_trn_list);
+  mysql_mutex_unlock(&LOCK_trn_list);
 
   if (unlikely(!trn->min_read_from))
   {
@@ -370,9 +370,9 @@ TRN *trnman_new_trn(WT_THD *wt)
     only after the following function TRN is considered initialized,
     so it must be done the last
   */
-  pthread_mutex_lock(&trn->state_lock);
+  mysql_mutex_lock(&trn->state_lock);
   trn->short_id= get_short_trid(trn);
-  pthread_mutex_unlock(&trn->state_lock);
+  mysql_mutex_unlock(&trn->state_lock);
 
   res= lf_hash_insert(&trid_to_trn, trn->pins, &trn);
   DBUG_ASSERT(res <= 0);
@@ -417,9 +417,9 @@ my_bool trnman_end_trn(TRN *trn, my_bool commit)
   /* if a rollback, all UNDO records should have been executed */
   DBUG_ASSERT(commit || trn->undo_lsn == 0);
   DBUG_ASSERT(trn != &dummy_transaction_object);
-  DBUG_PRINT("info", ("pthread_mutex_lock LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
 
-  pthread_mutex_lock(&LOCK_trn_list);
+  mysql_mutex_lock(&LOCK_trn_list);
 
   /* remove from active list */
   trn->next->prev= trn->prev;
@@ -451,11 +451,11 @@ my_bool trnman_end_trn(TRN *trn, my_bool commit)
     }
   }
 
-  pthread_mutex_lock(&trn->state_lock);
+  mysql_mutex_lock(&trn->state_lock);
   if (commit)
     trn->commit_trid= global_trid_generator;
   wt_thd_release_self(trn);
-  pthread_mutex_unlock(&trn->state_lock);
+  mysql_mutex_unlock(&trn->state_lock);
 
   /*
     if transaction is committed and it was not the only active transaction -
@@ -480,8 +480,8 @@ my_bool trnman_end_trn(TRN *trn, my_bool commit)
     res= -1;
   trnman_active_transactions--;
 
-  DBUG_PRINT("info", ("pthread_mutex_unlock LOCK_trn_list"));
+  DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
-  pthread_mutex_unlock(&LOCK_trn_list);
+  mysql_mutex_unlock(&LOCK_trn_list);
 
   /*
     the rest is done outside of a critical section
@@ -535,9 +535,9 @@ static void trnman_free_trn(TRN *trn)
   */
   union { TRN *trn; void *v; } tmp;
 
-  pthread_mutex_lock(&trn->state_lock);
+  mysql_mutex_lock(&trn->state_lock);
   trn->short_id= 0;
-  pthread_mutex_unlock(&trn->state_lock);
+  mysql_mutex_unlock(&trn->state_lock);
 
   tmp.trn= pool;
 
@@ -627,11 +627,11 @@ TRN *trnman_trid_to_trn(TRN *trn, TrID trid)
     return 0; /* no luck */
 
   /* we've found something */
-  pthread_mutex_lock(&(*found)->state_lock);
+  mysql_mutex_lock(&(*found)->state_lock);
 
   if ((*found)->short_id == 0)
   {
-    pthread_mutex_unlock(&(*found)->state_lock);
+    mysql_mutex_unlock(&(*found)->state_lock);
     lf_hash_search_unpin(trn->pins);
     return 0; /* but it was a ghost */
   }
@@ -688,7 +688,7 @@ my_bool trnman_collect_transactions(LEX_STRING *str_act, LEX_STRING *str_com,
 
   /* 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 */
@@ -718,9 +718,9 @@ my_bool trnman_collect_transactions(LEX_STRING *str_act, LEX_STRING *str_com,
   {
     uint sid;
     LSN rec_lsn, undo_lsn, first_undo_lsn;
-    pthread_mutex_lock(&trn->state_lock);
+    mysql_mutex_lock(&trn->state_lock);
     sid= trn->short_id;
-    pthread_mutex_unlock(&trn->state_lock);
+    mysql_mutex_unlock(&trn->state_lock);
     if (sid == 0)
     {
       /*
@@ -814,7 +814,7 @@ my_bool trnman_collect_transactions(LEX_STRING *str_act, LEX_STRING *str_com,
 err:
   error= 1;
 end:
-  pthread_mutex_unlock(&LOCK_trn_list);
+  mysql_mutex_unlock(&LOCK_trn_list);
   DBUG_RETURN(error);
 }
 
@@ -872,10 +872,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;
 }
 
@@ -889,9 +889,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;
 }
 
@@ -917,8 +917,8 @@ my_bool trnman_exists_active_transactions(TrID min_id, TrID max_id,
   my_bool ret= 0;
 
   if (!trnman_is_locked)
-    pthread_mutex_lock(&LOCK_trn_list);
+    mysql_mutex_lock(&LOCK_trn_list);
-  safe_mutex_assert_owner(&LOCK_trn_list);
+  mysql_mutex_assert_owner(&LOCK_trn_list);
   for (trn= active_list_min.next; trn != &active_list_max; trn= trn->next)
   {
     /*
@@ -944,7 +944,7 @@ my_bool trnman_exists_active_transactions(TrID min_id, TrID max_id,
     }
   }
   if (!trnman_is_locked)
-    pthread_mutex_unlock(&LOCK_trn_list);
+    mysql_mutex_unlock(&LOCK_trn_list);
   return ret;
 }
 
@@ -955,7 +955,7 @@ my_bool trnman_exists_active_transactions(TrID min_id, TrID max_id,
 
 void trnman_lock()
 {
-  pthread_mutex_lock(&LOCK_trn_list);
+  mysql_mutex_lock(&LOCK_trn_list);
 }
 
 
@@ -965,7 +965,7 @@ void trnman_lock()
 
 void trnman_unlock()
 {
-  pthread_mutex_unlock(&LOCK_trn_list);
+  mysql_mutex_unlock(&LOCK_trn_list);
 }
 
 

storage/maria/trnman.h

@@ -45,7 +45,7 @@ struct st_ma_transaction
 {
   LF_PINS              *pins;
   WT_THD               *wt;
-  pthread_mutex_t      state_lock;
+  mysql_mutex_t         state_lock;
   void                 *used_tables;  /**< Tables used by transaction */
   TRN                  *next, *prev;
   TrID                 trid, min_read_from, commit_trid;
@@ -61,6 +61,10 @@ struct st_ma_transaction
 
 extern WT_RESOURCE_TYPE ma_rc_dup_unique;
 
+#ifdef HAVE_PSI_INTERFACE
+extern PSI_mutex_key key_LOCK_trn_list, key_TRN_state_lock;
+#endif
+
 C_MODE_END
 
 #endif