mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 04:22:27 +01:00
32f81bab7d
This writes a warning on stderr if one uses mutex in different order, like if one in one case would lock mutex in the order A,B and in another case would lock mutex in the order B,A This is inspired by and loosely based on the LOCKDEP patch by Jonas Wrong mutex order is either fixed or mutex are marked with MYF_NO_DEADLOCK_DETECTION if used inconsistently (need to be fixed by server team) KNOWN_BUGS.txt: Added information that one need to dump and restore Maria tables include/hash.h: Added prototype function for walking over all elements in a hash include/my_pthread.h: Added my_pthread_mutex_init() and my_pthread_mutex_lock(); These should be used if one wants to disable mutex order checking. Changed names of the nonposix mutex_init functions to not conflict with my_phread_mutex_init() Added and extended structures for mutex deadlock detection. New arguments to sage_mutex_init() and safe_mutex_lock() to allow one to disable mutex order checking. Added variable 'safe_mutex_deadlock_detector' to enable/disable deadlock detection for all pthread_mutex_init() mysys/Makefile.am: Added cleaning of test files Added test_thr_mutex mysys/hash.c: Added hash_iterate() to iterate over all elements in a hash More comments mysys/my_init.c: Added calls to destory all mutex uses by mysys() Added waiting for threads to end before calling TERMINATE() to list not freed memory mysys/my_pthread.c: Changed names to free my_pthread_mutex_init() for mutex-lock-order-checking mysys/my_sleep.c: Fixed too long wait if using 1000000L as argument mysys/my_thr_init.c: Mark THR_LOCK_threads and THR_LOCK_malloc to not have mutex deadlock detection. (We can't have it enabled for this as these are internal mutex used by the detector Call my_thread_init() early as we need thread specific variables enabled for the following pthread_mutex_init() Move code to wait for threads to end to my_wait_for_other_threads_to_die() Don't destroy mutex and conditions unless all threads have died Added my_thread_destroy_mutex() to destroy all mutex used by the mysys thread system Name the thread specific mutex as "mysys_var->mutex" Added my_thread_var_mutex_in_use() to return pointer to mutex in use or 0 if thread variables are not initialized mysys/mysys_priv.h: Added prototypes for functions used internally with mutex-wrong-usage detection mysys/thr_mutex.c: Added runtime detection of mutex used in conflicting order See WL#3262 or test_thr_mutex.c for examples The base idea is for each mutex have two hashes: - mutex->locked_mutex points to all mutex used after this one - mutex->used_mutex points to all mutex which has this mutex in it's mutex->locked_mutex There is a wrong mutex order if any mutex currently locked before this mutex is in the mutex->locked_mutex hash sql/event_queue.cc: Mark mutex used inconsistently (need to be fixed by server team) sql/event_scheduler.cc: Declare the right order to take the mutex sql/events.cc: Mark mutex used inconsistently (need to be fixed by server team) sql/ha_ndbcluster_binlog.cc: Mark mutex used inconsistently (need to be fixed by server team) sql/log.cc: Mark mutex used inconsistently (need to be fixed by server team) sql/mysqld.cc: Use pthread_mutex_trylock instead of pthread_mutex_unlock() when sending kill signal to thread This is needed to avoid wrong mutex order as normally one takes 'current_mutex' before mysys_var->mutex. Added call to free sp cache. Add destruction of LOCK_server_started and COND_server_started. Added register_mutex_order() function to register in which order mutex should be taken (to initiailize mutex_deadlock_detector). Added option to turn off safe_mutex_deadlock_detector sql/protocol.cc: Fixed wrong argument to DBUG_PRINT (found by valgrind) sql/rpl_mi.cc: Mark mutex used inconsistently (need to be fixed by server team) sql/set_var.cc: Remove wrong locking of LOCK_global_system_variables when reading and setting log variables (would cause inconsistent mutex order). Update global variables outside of logger.unlock() as LOCK_global_system_variables has to be taken before logger locks Reviewed by gluh sql/sp_cache.cc: Added function to destroy mutex used by sp cache sql/sp_cache.h: Added function to destroy mutex used by sp cache sql/sql_class.cc: Use pthread_mutex_trylock instead of pthread_mutex_unlock() when sending kill signal to thread This is needed to avoid wrong mutex order as normally one takes 'current_mutex' before mysys_var->mutex. Register order in which LOCK_delete and mysys_var->mutex is taken sql/sql_insert.cc: Give a name for Delayed_insert::mutex Mark mutex used inconsistently (need to be fixed by server team) Move closing of tables outside of di->mutex (to avoid wrong mutex order) sql/sql_show.cc: Don't keep LOCK_global_system_variables locked over value->show_type() as this leads to wrong mutex order storage/innobase/handler/ha_innodb.cc: Disable safe_muted_deadlock_detector for innobase intern mutex (to speed up page cache initialization) storage/maria/ha_maria.cc: Added flag to ha_maria::info() to signal if we need to lock table share or not. This is needed to avoid locking mutex in wrong order storage/maria/ha_maria.h: Added flag to ha_maria::info() to signal if we need to lock table share or not. storage/maria/ma_close.c: Destroy key_del_lock Simplify freeing ftparser_param storage/maria/ma_key.c: Better comment storage/maria/ma_loghandler.c: Mark mutex used inconsistently (need to be fixed by sanja) storage/maria/ma_state.c: More comments storage/maria/ma_test1.c: Ensure that safe_mutex_deadlock_detector is always on (should be, this is just for safety) storage/maria/ma_test2.c: Ensure that safe_mutex_deadlock_detector is always on (should be, this is just for safety)
167 lines
6.3 KiB
C++
167 lines
6.3 KiB
C++
/* Copyright (C) 2006,2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
|
|
#ifdef USE_PRAGMA_INTERFACE
|
|
#pragma interface /* gcc class implementation */
|
|
#endif
|
|
|
|
/* class for the maria handler */
|
|
|
|
#include <maria.h>
|
|
|
|
#define HA_RECOVER_NONE 0 /* No automatic recover */
|
|
#define HA_RECOVER_DEFAULT 1 /* Automatic recover active */
|
|
#define HA_RECOVER_BACKUP 2 /* Make a backupfile on recover */
|
|
#define HA_RECOVER_FORCE 4 /* Recover even if we loose rows */
|
|
#define HA_RECOVER_QUICK 8 /* Don't check rows in data file */
|
|
|
|
extern ulong maria_sort_buffer_size;
|
|
extern TYPELIB maria_recover_typelib;
|
|
extern ulong maria_recover_options;
|
|
|
|
class ha_maria :public handler
|
|
{
|
|
MARIA_HA *file;
|
|
ulonglong int_table_flags;
|
|
MARIA_RECORD_POS remember_pos;
|
|
char *data_file_name, *index_file_name;
|
|
enum data_file_type data_file_type;
|
|
bool can_enable_indexes;
|
|
/**
|
|
If a transactional table is doing bulk insert with a single
|
|
UNDO_BULK_INSERT with/without repair.
|
|
*/
|
|
uint8 bulk_insert_single_undo;
|
|
int repair(THD * thd, HA_CHECK *param, bool optimize);
|
|
int zerofill(THD * thd, HA_CHECK_OPT *check_opt);
|
|
|
|
public:
|
|
ha_maria(handlerton *hton, TABLE_SHARE * table_arg);
|
|
~ha_maria() {}
|
|
handler *clone(MEM_ROOT *mem_root);
|
|
const char *table_type() const
|
|
{ return "MARIA"; }
|
|
const char *index_type(uint key_number);
|
|
const char **bas_ext() const;
|
|
ulonglong table_flags() const
|
|
{ return int_table_flags; }
|
|
ulong index_flags(uint inx, uint part, bool all_parts) const
|
|
{
|
|
return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
|
|
0 : HA_READ_NEXT | HA_READ_PREV | HA_READ_RANGE |
|
|
HA_READ_ORDER | HA_KEYREAD_ONLY);
|
|
}
|
|
uint max_supported_keys() const
|
|
{ return MARIA_MAX_KEY; }
|
|
uint max_supported_key_length() const;
|
|
uint max_supported_key_part_length() const
|
|
{ return max_supported_key_length(); }
|
|
enum row_type get_row_type() const;
|
|
uint checksum() const;
|
|
virtual double scan_time();
|
|
|
|
int open(const char *name, int mode, uint test_if_locked);
|
|
int close(void);
|
|
int write_row(uchar * buf);
|
|
int update_row(const uchar * old_data, uchar * new_data);
|
|
int delete_row(const uchar * buf);
|
|
int index_read_map(uchar * buf, const uchar * key, key_part_map keypart_map,
|
|
enum ha_rkey_function find_flag);
|
|
int index_read_idx_map(uchar * buf, uint idx, const uchar * key,
|
|
key_part_map keypart_map,
|
|
enum ha_rkey_function find_flag);
|
|
int index_read_last_map(uchar * buf, const uchar * key,
|
|
key_part_map keypart_map);
|
|
int index_next(uchar * buf);
|
|
int index_prev(uchar * buf);
|
|
int index_first(uchar * buf);
|
|
int index_last(uchar * buf);
|
|
int index_next_same(uchar * buf, const uchar * key, uint keylen);
|
|
int ft_init()
|
|
{
|
|
if (!ft_handler)
|
|
return 1;
|
|
ft_handler->please->reinit_search(ft_handler);
|
|
return 0;
|
|
}
|
|
FT_INFO *ft_init_ext(uint flags, uint inx, String * key)
|
|
{
|
|
return maria_ft_init_search(flags, file, inx,
|
|
(uchar *) key->ptr(), key->length(),
|
|
key->charset(), table->record[0]);
|
|
}
|
|
int ft_read(uchar * buf);
|
|
int rnd_init(bool scan);
|
|
int rnd_end(void);
|
|
int rnd_next(uchar * buf);
|
|
int rnd_pos(uchar * buf, uchar * pos);
|
|
int remember_rnd_pos();
|
|
int restart_rnd_next(uchar * buf);
|
|
void position(const uchar * record);
|
|
int info(uint);
|
|
int info(uint, my_bool);
|
|
int extra(enum ha_extra_function operation);
|
|
int extra_opt(enum ha_extra_function operation, ulong cache_size);
|
|
int reset(void);
|
|
int external_lock(THD * thd, int lock_type);
|
|
int start_stmt(THD *thd, thr_lock_type lock_type);
|
|
int delete_all_rows(void);
|
|
int disable_indexes(uint mode);
|
|
int enable_indexes(uint mode);
|
|
int indexes_are_disabled(void);
|
|
void start_bulk_insert(ha_rows rows);
|
|
int end_bulk_insert(bool abort);
|
|
ha_rows records_in_range(uint inx, key_range * min_key, key_range * max_key);
|
|
void update_create_info(HA_CREATE_INFO * create_info);
|
|
int create(const char *name, TABLE * form, HA_CREATE_INFO * create_info);
|
|
THR_LOCK_DATA **store_lock(THD * thd, THR_LOCK_DATA ** to,
|
|
enum thr_lock_type lock_type);
|
|
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
|
|
ulonglong nb_desired_values,
|
|
ulonglong *first_value,
|
|
ulonglong *nb_reserved_values);
|
|
int rename_table(const char *from, const char *to);
|
|
int delete_table(const char *name);
|
|
int check(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int analyze(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int repair(THD * thd, HA_CHECK_OPT * check_opt);
|
|
bool check_and_repair(THD * thd);
|
|
bool is_crashed() const;
|
|
bool is_changed() const;
|
|
bool auto_repair() const { return 1; }
|
|
int optimize(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int restore(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int backup(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int assign_to_keycache(THD * thd, HA_CHECK_OPT * check_opt);
|
|
int preload_keys(THD * thd, HA_CHECK_OPT * check_opt);
|
|
bool check_if_incompatible_data(HA_CREATE_INFO * info, uint table_changes);
|
|
#ifdef HAVE_REPLICATION
|
|
int dump(THD * thd, int fd);
|
|
int net_read_dump(NET * net);
|
|
#endif
|
|
#ifdef HAVE_QUERY_CACHE
|
|
my_bool register_query_cache_table(THD *thd, char *table_key,
|
|
uint key_length,
|
|
qc_engine_callback
|
|
*engine_callback,
|
|
ulonglong *engine_data);
|
|
#endif
|
|
MARIA_HA *file_ptr(void)
|
|
{
|
|
return file;
|
|
}
|
|
static int implicit_commit(THD *thd, bool new_trn);
|
|
};
|