diff options
111 files changed, 1286 insertions, 696 deletions
diff --git a/client/mysqlbinlog.cc b/client/mysqlbinlog.cc index 29ee6efbfb0..6c6acb750d3 100644 --- a/client/mysqlbinlog.cc +++ b/client/mysqlbinlog.cc @@ -438,9 +438,9 @@ static struct my_option my_long_options[] = {"user", 'u', "Connect to the remote server as username.", (gptr*) &user, (gptr*) &user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, - {"local-load", 'l', "Prepare files for local load in directory.", + {"local-load", 'l', "Prepare local temporary files for LOAD DATA INFILE in the specified directory.", (gptr*) &dirname_for_local_load, (gptr*) &dirname_for_local_load, 0, - GET_STR_ALLOC, OPT_ARG, 0, 0, 0, 0, 0, 0}, + GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, {"version", 'V', "Print version and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0} @@ -947,7 +947,7 @@ int main(int argc, char** argv) exit(1); if (dirname_for_local_load) load_processor.init_by_dir_name(dirname_for_local_load); - else + else /* my_malloc() failed in my_strdup() */ load_processor.init_by_cur_dir(); exit_value= 0; diff --git a/client/mysqldump.c b/client/mysqldump.c index 34f9b7998d7..f93c791564e 100644 --- a/client/mysqldump.c +++ b/client/mysqldump.c @@ -72,13 +72,13 @@ static char *add_load_option(char *ptr, const char *object, static char *field_escape(char *to,const char *from,uint length); static my_bool verbose=0,tFlag=0,cFlag=0,dFlag=0,quick=0, extended_insert = 0, - lock_tables=0,ignore_errors=0,flush_logs=0,replace=0, - ignore=0,opt_drop=0,opt_keywords=0,opt_lock=0,opt_compress=0, - opt_delayed=0,create_options=0,opt_quoted=0,opt_databases=0, - opt_alldbs=0,opt_create_db=0,opt_first_slave=0, - opt_autocommit=0,opt_master_data,opt_disable_keys=0,opt_xml=0, - opt_delete_master_logs=0, tty_password=0, - opt_single_transaction=0, opt_comments= 0; + lock_tables=0,ignore_errors=0,flush_logs=0,replace=0, + ignore=0,opt_drop=0,opt_keywords=0,opt_lock=0,opt_compress=0, + opt_delayed=0,create_options=0,opt_quoted=0,opt_databases=0, + opt_alldbs=0,opt_create_db=0,opt_first_slave=0, + opt_autocommit=0,opt_master_data,opt_disable_keys=0,opt_xml=0, + opt_delete_master_logs=0, tty_password=0, + opt_single_transaction=0, opt_comments= 0; static MYSQL mysql_connection,*sock=0; static char insert_pat[12 * 1024],*opt_password=0,*current_user=0, *current_host=0,*path=0,*fields_terminated=0, diff --git a/extra/replace.c b/extra/replace.c index 792684918ea..422cfdbac36 100644 --- a/extra/replace.c +++ b/extra/replace.c @@ -14,18 +14,16 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* Replace strings in textfile +/* + Replace strings in textfile + This program replaces strings in files or from stdin to stdout. It accepts a list of from-string/to-string pairs and replaces each occurrence of a from-string with the corresponding to-string. The first occurrence of a found string is matched. If there is more than one possibility for the string to replace, longer matches are preferred before shorter matches. - This program replace strings in a file or on stdin/stdout. - It accepts a list of from-strings and to-strings and replaces all - occurents of from-strings to to-strings. - The first occurents of a found string is matched. If there are more than - one possibly replace the longer from-string is replaced. + Special characters in from string: \^ Match start of line. \$ Match end of line. @@ -956,9 +954,11 @@ static void free_buffer() } -/* Fill the buffer retaining the last n bytes at the beginning of the - newly filled buffer (for backward context). Returns the number of new - bytes read from disk. */ +/* + Fill the buffer retaining the last n bytes at the beginning of the + newly filled buffer (for backward context). Returns the number of new + bytes read from disk. +*/ static int fill_buffer_retaining(fd,n) File fd; diff --git a/innobase/btr/btr0btr.c b/innobase/btr/btr0btr.c index 1af9336ce72..71be6d81d7c 100644 --- a/innobase/btr/btr0btr.c +++ b/innobase/btr/btr0btr.c @@ -299,7 +299,9 @@ btr_page_alloc_for_ibuf( new_page = buf_page_get(dict_tree_get_space(tree), node_addr.page, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW); +#endif /* UNIV_SYNC_DEBUG */ flst_remove(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST, new_page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, @@ -357,7 +359,9 @@ btr_page_alloc( new_page = buf_page_get(dict_tree_get_space(tree), new_page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW); +#endif /* UNIV_SYNC_DEBUG */ return(new_page); } @@ -398,7 +402,7 @@ btr_get_size( n += fseg_n_reserved_pages(seg_header, &dummy, &mtr); } else { - ut_a(0); + ut_error; } mtr_commit(&mtr); @@ -663,8 +667,9 @@ btr_create( ibuf_hdr_frame = fseg_create(space, 0, IBUF_HEADER + IBUF_TREE_SEG_HEADER, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(ibuf_hdr_frame, SYNC_TREE_NODE_NEW); - +#endif /* UNIV_SYNC_DEBUG */ ut_ad(buf_frame_get_page_no(ibuf_hdr_frame) == IBUF_HEADER_PAGE_NO); /* Allocate then the next page to the segment: it will be the @@ -689,7 +694,9 @@ btr_create( page_no = buf_frame_get_page_no(frame); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW); +#endif /* UNIV_SYNC_DEBUG */ if (type & DICT_IBUF) { /* It is an insert buffer tree: initialize the free list */ @@ -704,7 +711,9 @@ btr_create( mtr); /* The fseg create acquires a second latch on the page, therefore we must declare it: */ +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW); +#endif /* UNIV_SYNC_DEBUG */ } /* Create a new index page on the the allocated segment page */ @@ -1517,7 +1526,9 @@ func_start: ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree), MTR_MEMO_X_LOCK)); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(dict_tree_get_lock(tree), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ page = btr_cur_get_page(cursor); diff --git a/innobase/btr/btr0cur.c b/innobase/btr/btr0cur.c index d506c5a91a7..6e1794c2ff7 100644 --- a/innobase/btr/btr0cur.c +++ b/innobase/btr/btr0cur.c @@ -3146,8 +3146,10 @@ btr_store_big_rec_extern_fields( prev_page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(prev_page, SYNC_EXTERN_STORAGE); +#endif /* UNIV_SYNC_DEBUG */ mlog_write_ulint(prev_page + FIL_PAGE_DATA + BTR_BLOB_HDR_NEXT_PAGE_NO, @@ -3182,9 +3184,9 @@ btr_store_big_rec_extern_fields( rec_page = buf_page_get(space_id, buf_frame_get_page_no(data), RW_X_LATCH, &mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK); - +#endif /* UNIV_SYNC_DEBUG */ mlog_write_ulint(data + local_len + BTR_EXTERN_LEN, 0, MLOG_4BYTES, &mtr); mlog_write_ulint(data + local_len + BTR_EXTERN_LEN + 4, @@ -3276,9 +3278,9 @@ btr_free_externally_stored_field( rec_page = buf_page_get(buf_frame_get_space_id(data), buf_frame_get_page_no(data), RW_X_LATCH, &mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK); - +#endif /* UNIV_SYNC_DEBUG */ space_id = mach_read_from_4(data + local_len + BTR_EXTERN_SPACE_ID); @@ -3321,9 +3323,9 @@ btr_free_externally_stored_field( } page = buf_page_get(space_id, page_no, RW_X_LATCH, &mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE); - +#endif /* UNIV_SYNC_DEBUG */ next_page_no = mach_read_from_4(page + FIL_PAGE_DATA + BTR_BLOB_HDR_NEXT_PAGE_NO); @@ -3501,9 +3503,9 @@ btr_copy_externally_stored_field( mtr_start(&mtr); page = buf_page_get(space_id, page_no, RW_S_LATCH, &mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE); - +#endif /* UNIV_SYNC_DEBUG */ blob_header = page + offset; part_len = btr_blob_get_part_len(blob_header); diff --git a/innobase/btr/btr0pcur.c b/innobase/btr/btr0pcur.c index 63e7763ef87..4725551d4d7 100644 --- a/innobase/btr/btr0pcur.c +++ b/innobase/btr/btr0pcur.c @@ -227,9 +227,9 @@ btr_pcur_restore_position( if (buf_page_optimistic_get(latch_mode, page, cursor->modify_clock, mtr)) { cursor->pos_state = BTR_PCUR_IS_POSITIONED; - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE); - +#endif /* UNIV_SYNC_DEBUG */ if (cursor->rel_pos == BTR_PCUR_ON) { cursor->latch_mode = latch_mode; diff --git a/innobase/btr/btr0sea.c b/innobase/btr/btr0sea.c index 68f631dcba5..9421ca48718 100644 --- a/innobase/btr/btr0sea.c +++ b/innobase/btr/btr0sea.c @@ -93,8 +93,10 @@ btr_search_check_free_space_in_heap(void) hash_table_t* table; mem_heap_t* heap; - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ table = btr_search_sys->hash_index; @@ -194,8 +196,10 @@ btr_search_info_update_hash( ulint n_unique; int cmp; - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ index = cursor->index; @@ -317,10 +321,12 @@ btr_search_update_block_hash_info( buf_block_t* block, /* in: buffer block */ btr_cur_t* cursor) /* in: cursor */ { - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); - ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED) - || rw_lock_own(&(block->lock), RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); + ut_ad(rw_lock_own(&((buf_block_t*) block)->lock, RW_LOCK_SHARED) + || rw_lock_own(&((buf_block_t*) block)->lock, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(cursor); info->last_hash_succ = FALSE; @@ -398,9 +404,11 @@ btr_search_update_hash_ref( dulint tree_id; ut_ad(cursor->flag == BTR_CUR_HASH_FAIL); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX)); ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED) || rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ if (block->is_hashed && (info->n_hash_potential > 0) && (block->curr_n_fields == info->n_fields) @@ -419,7 +427,9 @@ btr_search_update_hash_ref( fold = rec_fold(rec, block->curr_n_fields, block->curr_n_bytes, tree_id); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ ha_insert_for_fold(btr_search_sys->hash_index, fold, rec); } @@ -439,8 +449,10 @@ btr_search_info_update_slow( ulint* params; ulint* params2; - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ block = buf_block_align(btr_cur_get_rec(cursor)); @@ -762,7 +774,9 @@ btr_search_guess_on_hash( can_only_compare_to_cursor_rec = FALSE; +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE_FROM_HASH); +#endif /* UNIV_SYNC_DEBUG */ } block = buf_block_align(page); @@ -910,10 +924,12 @@ btr_search_drop_page_hash_index( ulint n_recs; ulint* folds; ulint i; - - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); - + +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ + rw_lock_s_lock(&btr_search_latch); block = buf_block_align(page); @@ -927,9 +943,11 @@ btr_search_drop_page_hash_index( table = btr_search_sys->hash_index; +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED) || rw_lock_own(&(block->lock), RW_LOCK_EX) || (block->buf_fix_count == 0)); +#endif /* UNIV_SYNC_DEBUG */ n_fields = block->curr_n_fields; n_bytes = block->curr_n_bytes; @@ -1029,8 +1047,10 @@ btr_search_drop_page_hash_when_freed( page = buf_page_get(space, page_no, RW_S_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE_FROM_HASH); - +#endif /* UNIV_SYNC_DEBUG */ + btr_search_drop_page_hash_index(page); mtr_commit(&mtr); @@ -1070,9 +1090,11 @@ btr_search_build_page_hash_index( block = buf_block_align(page); table = btr_search_sys->hash_index; +#ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED) || rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ rw_lock_s_lock(&btr_search_latch); @@ -1235,8 +1257,10 @@ btr_search_move_or_delete_hash_entries( block = buf_block_align(page); new_block = buf_block_align(new_page); - ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX) - && rw_lock_own(&(new_block->lock), RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); + ut_ad(rw_lock_own(&(new_block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ rw_lock_s_lock(&btr_search_latch); @@ -1296,7 +1320,9 @@ btr_search_update_hash_on_delete( block = buf_block_align(rec); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ if (!block->is_hashed) { @@ -1337,7 +1363,9 @@ btr_search_update_hash_node_on_insert( block = buf_block_align(rec); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ if (!block->is_hashed) { @@ -1398,7 +1426,9 @@ btr_search_update_hash_on_insert( block = buf_block_align(rec); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ if (!block->is_hashed) { diff --git a/innobase/buf/buf0buf.c b/innobase/buf/buf0buf.c index 1c0315131b2..e2661725912 100644 --- a/innobase/buf/buf0buf.c +++ b/innobase/buf/buf0buf.c @@ -446,9 +446,10 @@ buf_block_init( rw_lock_create(&(block->read_lock)); rw_lock_set_level(&(block->read_lock), SYNC_NO_ORDER_CHECK); - +#ifdef UNIV_SYNC_DEBUG rw_lock_create(&(block->debug_latch)); rw_lock_set_level(&(block->debug_latch), SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ } /************************************************************************ @@ -1088,9 +1089,9 @@ buf_page_optimistic_get_func( } if (!UT_DULINT_EQ(modify_clock, block->modify_clock)) { - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(block->frame, SYNC_NO_ORDER_CHECK); - +#endif /* UNIV_SYNC_DEBUG */ if (rw_latch == RW_S_LATCH) { rw_lock_s_unlock(&(block->lock)); } else { @@ -1285,7 +1286,9 @@ buf_page_init( in units of a page */ buf_block_t* block) /* in: block to init */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(block->state == BUF_BLOCK_READY_FOR_USE); /* Set the state of the block */ diff --git a/innobase/buf/buf0flu.c b/innobase/buf/buf0flu.c index c0999ee4841..66c9bb605dc 100644 --- a/innobase/buf/buf0flu.c +++ b/innobase/buf/buf0flu.c @@ -47,7 +47,9 @@ buf_flush_insert_into_flush_list( /*=============================*/ buf_block_t* block) /* in: block which is modified */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL) || (ut_dulint_cmp( @@ -73,7 +75,9 @@ buf_flush_insert_sorted_into_flush_list( buf_block_t* prev_b; buf_block_t* b; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ prev_b = NULL; b = UT_LIST_GET_FIRST(buf_pool->flush_list); @@ -105,7 +109,9 @@ buf_flush_ready_for_replace( buf_block_t* block) /* in: buffer control block, must be in state BUF_BLOCK_FILE_PAGE and in the LRU list*/ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(block->state == BUF_BLOCK_FILE_PAGE); if ((ut_dulint_cmp(block->oldest_modification, ut_dulint_zero) > 0) @@ -129,7 +135,9 @@ buf_flush_ready_for_flush( BUF_BLOCK_FILE_PAGE */ ulint flush_type)/* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(block->state == BUF_BLOCK_FILE_PAGE); if ((ut_dulint_cmp(block->oldest_modification, ut_dulint_zero) > 0) @@ -161,8 +169,9 @@ buf_flush_write_complete( buf_block_t* block) /* in: pointer to the block in question */ { ut_ad(block); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ block->oldest_modification = ut_dulint_zero; UT_LIST_REMOVE(flush_list, buf_pool->flush_list, block); @@ -244,7 +253,7 @@ buf_flush_buffered_writes(void) "InnoDB: files.\n", block->offset, block->space); - ut_a(0); + ut_error; } } diff --git a/innobase/buf/buf0lru.c b/innobase/buf/buf0lru.c index 1d49833969f..0128ee87871 100644 --- a/innobase/buf/buf0lru.c +++ b/innobase/buf/buf0lru.c @@ -235,7 +235,7 @@ loop: "InnoDB: on Linux!\n", (ulong)(buf_pool->curr_size / (1024 * 1024 / UNIV_PAGE_SIZE))); - ut_a(0); + ut_error; } else if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free) + UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->max_size / 5) { @@ -370,7 +370,9 @@ buf_LRU_old_adjust_len(void) ulint new_len; ut_ad(buf_pool->LRU_old); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(3 * (BUF_LRU_OLD_MIN_LEN / 8) > BUF_LRU_OLD_TOLERANCE + 5); for (;;) { @@ -440,7 +442,9 @@ buf_LRU_remove_block( { ut_ad(buf_pool); ut_ad(block); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* If the LRU_old pointer is defined and points to just this block, move it backward one step */ @@ -493,7 +497,9 @@ buf_LRU_add_block_to_end_low( ut_ad(buf_pool); ut_ad(block); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ block->old = TRUE; @@ -545,7 +551,9 @@ buf_LRU_add_block_low( ut_ad(buf_pool); ut_ad(block); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ block->old = old; cl = buf_pool_clock_tic(); @@ -632,7 +640,9 @@ buf_LRU_block_free_non_file_page( /*=============================*/ buf_block_t* block) /* in: block, must not contain a file page */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(block); ut_ad((block->state == BUF_BLOCK_MEMORY) @@ -658,7 +668,9 @@ buf_LRU_block_remove_hashed_page( be in a state where it can be freed; there may or may not be a hash index to the page */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(block); ut_ad(block->state == BUF_BLOCK_FILE_PAGE); @@ -672,7 +684,7 @@ buf_LRU_block_remove_hashed_page( buf_pool->freed_page_clock += 1; buf_frame_modify_clock_inc(block->frame); - + HASH_DELETE(buf_block_t, hash, buf_pool->page_hash, buf_page_address_fold(block->space, block->offset), block); @@ -689,7 +701,9 @@ buf_LRU_block_free_hashed_page( buf_block_t* block) /* in: block, must contain a file page and be in a state where it can be freed */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(block->state == BUF_BLOCK_REMOVE_HASH); block->state = BUF_BLOCK_MEMORY; diff --git a/innobase/data/data0data.c b/innobase/data/data0data.c index 629570ce751..c3c2b135717 100644 --- a/innobase/data/data0data.c +++ b/innobase/data/data0data.c @@ -261,7 +261,7 @@ dfield_check_typed( "InnoDB: Error: data field type %lu, len %lu\n", dfield_get_type(field)->mtype, dfield_get_len(field)); - ut_a(0); + ut_error; } return(TRUE); diff --git a/innobase/dict/dict0boot.c b/innobase/dict/dict0boot.c index 0bf2ace3324..3abb71a842d 100644 --- a/innobase/dict/dict0boot.c +++ b/innobase/dict/dict0boot.c @@ -39,8 +39,9 @@ dict_hdr_get( header = DICT_HDR + buf_page_get(DICT_HDR_SPACE, DICT_HDR_PAGE_NO, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(header, SYNC_DICT_HEADER); - +#endif /* UNIV_SYNC_DEBUG */ return(header); } @@ -64,7 +65,7 @@ dict_hdr_get_new_id( dict_hdr = dict_hdr_get(&mtr); - id = mtr_read_dulint(dict_hdr + type, MLOG_8BYTES, &mtr); + id = mtr_read_dulint(dict_hdr + type, &mtr); /* Add some dummy code here because otherwise pgcc seems to compile wrong */ @@ -75,7 +76,7 @@ dict_hdr_get_new_id( id = ut_dulint_add(id, 1); - mlog_write_dulint(dict_hdr + type, id, MLOG_8BYTES, &mtr); + mlog_write_dulint(dict_hdr + type, id, &mtr); mtr_commit(&mtr); @@ -94,7 +95,9 @@ dict_hdr_flush_row_id(void) dulint id; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ id = dict_sys->row_id; @@ -102,7 +105,7 @@ dict_hdr_flush_row_id(void) dict_hdr = dict_hdr_get(&mtr); - mlog_write_dulint(dict_hdr + DICT_HDR_ROW_ID, id, MLOG_8BYTES, &mtr); + mlog_write_dulint(dict_hdr + DICT_HDR_ROW_ID, id, &mtr); mtr_commit(&mtr); } @@ -138,20 +141,16 @@ dict_hdr_create( /* Start counting row, table, index, and tree ids from DICT_HDR_FIRST_ID */ mlog_write_dulint(dict_header + DICT_HDR_ROW_ID, - ut_dulint_create(0, DICT_HDR_FIRST_ID), - MLOG_8BYTES, mtr); + ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr); mlog_write_dulint(dict_header + DICT_HDR_TABLE_ID, - ut_dulint_create(0, DICT_HDR_FIRST_ID), - MLOG_8BYTES, mtr); + ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr); mlog_write_dulint(dict_header + DICT_HDR_INDEX_ID, - ut_dulint_create(0, DICT_HDR_FIRST_ID), - MLOG_8BYTES, mtr); + ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr); mlog_write_dulint(dict_header + DICT_HDR_MIX_ID, - ut_dulint_create(0, DICT_HDR_FIRST_ID), - MLOG_8BYTES, mtr); + ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr); /* Create the B-tree roots for the clustered indexes of the basic system tables */ @@ -247,7 +246,7 @@ dict_boot(void) dict_sys->row_id = ut_dulint_add( ut_dulint_align_up( mtr_read_dulint(dict_hdr + DICT_HDR_ROW_ID, - MLOG_8BYTES, &mtr), + &mtr), DICT_HDR_ROW_ID_WRITE_MARGIN), DICT_HDR_ROW_ID_WRITE_MARGIN); diff --git a/innobase/dict/dict0crea.c b/innobase/dict/dict0crea.c index d6e817d465e..48fcb9c1e79 100644 --- a/innobase/dict/dict0crea.c +++ b/innobase/dict/dict0crea.c @@ -158,7 +158,7 @@ dict_create_sys_tables_tuple( if (table->type == DICT_TABLE_CLUSTER_MEMBER) { dfield_set_data(dfield, table->cluster_name, ut_strlen(table->cluster_name)); - ut_a(0); /* Oracle-style clusters are not supported yet */ + ut_error; /* Oracle-style clusters are not supported yet */ } else { dfield_set_data(dfield, NULL, UNIV_SQL_NULL); } @@ -270,9 +270,10 @@ dict_build_table_def_step( dict_table_t* cluster_table; dtuple_t* row; - UT_NOT_USED(thr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ + table = node->table; table->id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID); @@ -341,7 +342,9 @@ dict_create_sys_indexes_tuple( byte* ptr; UT_NOT_USED(trx); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(index && heap); sys_indexes = dict_sys->sys_indexes; @@ -534,8 +537,9 @@ dict_build_index_def_step( dict_index_t* index; dtuple_t* row; - UT_NOT_USED(thr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ index = node->index; @@ -607,8 +611,10 @@ dict_create_index_tree_step( dtuple_t* search_tuple; btr_pcur_t pcur; mtr_t mtr; - + +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ UT_NOT_USED(thr); index = node->index; @@ -670,7 +676,9 @@ dict_drop_index_tree( byte* ptr; ulint len; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ptr = rec_get_nth_field(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD, &len); @@ -791,8 +799,10 @@ dict_create_table_step( trx_t* trx; ut_ad(thr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ + trx = thr_get_trx(thr); node = thr->run_node; @@ -899,7 +909,9 @@ dict_create_index_step( trx_t* trx; ut_ad(thr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx = thr_get_trx(thr); @@ -1160,7 +1172,9 @@ dict_create_add_foreigns_to_dictionary( ulint i; char buf[10000]; - ut_ad(mutex_own(&(dict_sys->mutex))); +#ifdef UNIV_SYNC_DEBUG + ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (NULL == dict_table_get_low((char *) "SYS_FOREIGN")) { fprintf(stderr, @@ -1221,7 +1235,7 @@ loop: foreign->referenced_col_names[i]); } - ut_a(len < (sizeof buf) - 19) + ut_a(len < (sizeof buf) - 19); len += sprintf(buf + len,"COMMIT WORK;\nEND;\n"); graph = pars_sql(buf); diff --git a/innobase/dict/dict0dict.c b/innobase/dict/dict0dict.c index 5b2a16ce9f3..dc19997de72 100644 --- a/innobase/dict/dict0dict.c +++ b/innobase/dict/dict0dict.c @@ -208,7 +208,7 @@ dict_tables_have_same_db( } } - ut_a(0); + ut_error; return(FALSE); } @@ -231,7 +231,7 @@ dict_remove_db_name( } } - ut_a(0); + ut_error; return(NULL); } @@ -254,7 +254,7 @@ dict_get_db_name_len( } } - ut_a(0); + ut_error; return(0); } @@ -615,7 +615,9 @@ dict_table_get_on_id( if we are doing a rollback to handle an error in TABLE CREATE, for example, we already have the mutex! */ +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ return(dict_table_get_on_id_low(table_id, trx)); } @@ -761,7 +763,9 @@ dict_table_add_to_cache( ulint i; ut_ad(table); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->n_def == table->n_cols - DATA_N_SYS_COLS); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); ut_ad(table->cached == FALSE); @@ -896,8 +900,10 @@ dict_table_rename_in_cache( ulint i; ut_ad(table); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ + old_size = mem_heap_get_size(table->heap); fold = ut_fold_string(new_name); @@ -1095,7 +1101,9 @@ dict_table_remove_from_cache( ulint i; ut_ad(table); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); /* printf("Removing table %s from dictionary cache\n", table->name); */ @@ -1164,9 +1172,11 @@ dict_table_LRU_trim(void) dict_table_t* table; dict_table_t* prev_table; - ut_a(0); + ut_error; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ table = UT_LIST_GET_LAST(dict_sys->table_LRU); @@ -1195,7 +1205,9 @@ dict_col_add_to_cache( ulint fold; ut_ad(table && col); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); fold = ut_fold_ulint_pair(ut_fold_string(table->name), @@ -1226,7 +1238,9 @@ dict_col_remove_from_cache( ulint fold; ut_ad(table && col); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); fold = ut_fold_ulint_pair(ut_fold_string(table->name), @@ -1249,7 +1263,9 @@ dict_col_reposition_in_cache( ulint fold; ut_ad(table && col); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); fold = ut_fold_ulint_pair(ut_fold_string(table->name), @@ -1283,7 +1299,9 @@ dict_index_add_to_cache( ulint i; ut_ad(index); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(index->n_def == index->n_fields); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); @@ -1409,7 +1427,9 @@ dict_index_remove_from_cache( ut_ad(table && index); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); ut_ad(index->magic_n == DICT_INDEX_MAGIC_N); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(UT_LIST_GET_LEN((index->tree)->tree_indexes) == 1); dict_tree_free(index->tree); @@ -1453,7 +1473,9 @@ dict_index_find_cols( ut_ad(table && index); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ for (i = 0; i < index->n_fields; i++) { field = dict_index_get_nth_field(index, i); @@ -1594,7 +1616,9 @@ dict_index_build_internal_clust( ut_ad(table && index); ut_ad(index->type & DICT_CLUSTERED); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); /* Create a new index object with certainly enough fields */ @@ -1763,7 +1787,9 @@ dict_index_build_internal_non_clust( ut_ad(table && index); ut_ad(0 == (index->type & DICT_CLUSTERED)); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); /* The clustered index should be the first in the list of indexes */ @@ -1882,7 +1908,9 @@ dict_foreign_remove_from_cache( /*===========================*/ dict_foreign_t* foreign) /* in, own: foreign constraint */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(foreign); if (foreign->referenced_table) { @@ -1911,7 +1939,9 @@ dict_foreign_find( { dict_foreign_t* foreign; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ foreign = UT_LIST_GET_FIRST(table->foreign_list); @@ -2020,7 +2050,9 @@ dict_foreign_add_to_cache( ibool added_to_referenced_list = FALSE; char* buf = dict_foreign_err_buf; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ for_table = dict_table_check_if_in_cache_low( foreign->foreign_table_name); @@ -2691,7 +2723,9 @@ dict_create_foreign_constraints_low( ulint column_name_lens[500]; char referenced_table_name[2500]; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ table = dict_table_get_low(name); @@ -3271,7 +3305,9 @@ dict_foreign_parse_drop_constraints( str = dict_strip_comments(*(trx->mysql_query_str)); ptr = str; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ loop: ptr = dict_scan_to(ptr, (char *) "DROP"); @@ -3411,7 +3447,9 @@ dict_procedure_reserve_parsed_copy( que_t* graph; proc_node_t* proc_node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(dict_sys->mutex)); @@ -3459,7 +3497,9 @@ dict_procedure_release_parsed_copy( { proc_node_t* proc_node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(dict_sys->mutex)); @@ -3536,9 +3576,9 @@ dict_tree_create( tree->id = index->id; UT_LIST_INIT(tree->tree_indexes); - +#ifdef UNIV_DEBUG tree->magic_n = DICT_TREE_MAGIC_N; - +#endif /* UNIV_DEBUG */ rw_lock_create(&(tree->lock)); rw_lock_set_level(&(tree->lock), SYNC_INDEX_TREE); @@ -3936,7 +3976,9 @@ dict_foreign_print_low( { ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ printf(" FOREIGN KEY CONSTRAINT %s: %s (", foreign->id, foreign->foreign_table_name); @@ -4001,7 +4043,9 @@ dict_table_print_low( dict_foreign_t* foreign; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ dict_update_statistics_low(table, TRUE); @@ -4054,7 +4098,9 @@ dict_col_print_low( { dtype_t* type; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ type = dict_col_get_type(col); printf("%s: ", col->name); @@ -4074,7 +4120,9 @@ dict_index_print_low( ib_longlong n_vals; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ tree = index->tree; @@ -4120,7 +4168,9 @@ dict_field_print_low( /*=================*/ dict_field_t* field) /* in: field */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ printf(" %s", field->name); diff --git a/innobase/dict/dict0load.c b/innobase/dict/dict0load.c index 48c445fa0c9..5a5830a2517 100644 --- a/innobase/dict/dict0load.c +++ b/innobase/dict/dict0load.c @@ -42,7 +42,9 @@ dict_get_first_table_name_in_db( char* table_name; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ heap = mem_heap_create(1000); @@ -212,7 +214,9 @@ dict_load_columns( ulint i; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); @@ -310,7 +314,9 @@ dict_load_fields( ulint i; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ UT_NOT_USED(table); @@ -422,7 +428,9 @@ dict_load_indexes( dulint id; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if ((ut_dulint_get_high(table->id) == 0) && (ut_dulint_get_low(table->id) < DICT_HDR_FIRST_ID)) { @@ -591,7 +599,9 @@ dict_load_table( ulint err; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ heap = mem_heap_create(1000); @@ -663,7 +673,7 @@ dict_load_table( table->type = mach_read_from_4(field); if (table->type == DICT_TABLE_CLUSTER_MEMBER) { - ut_a(0); + ut_error; field = rec_get_nth_field(rec, 6, &len); table->mix_id = mach_read_from_8(field); @@ -744,7 +754,9 @@ dict_load_table_on_id( char* name; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* NOTE that the operation of this function is protected by the dictionary mutex, and therefore no deadlocks can occur @@ -829,7 +841,9 @@ dict_load_sys_table( { mem_heap_t* heap; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ heap = mem_heap_create(1000); @@ -860,7 +874,9 @@ dict_load_foreign_cols( ulint i; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ foreign->foreign_col_names = mem_heap_alloc(foreign->heap, foreign->n_fields * sizeof(void*)); @@ -941,7 +957,9 @@ dict_load_foreign( ulint err; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ heap2 = mem_heap_create(1000); @@ -1073,7 +1091,9 @@ dict_load_foreigns( ulint err; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ sys_foreign = dict_table_get_low((char *) "SYS_FOREIGN"); diff --git a/innobase/dict/dict0mem.c b/innobase/dict/dict0mem.c index 56efc0a0117..c9eb7a9d8bd 100644 --- a/innobase/dict/dict0mem.c +++ b/innobase/dict/dict0mem.c @@ -90,9 +90,9 @@ dict_mem_table_create( mutex_set_level(&(table->autoinc_mutex), SYNC_DICT_AUTOINC_MUTEX); table->autoinc_inited = FALSE; - +#ifdef UNIV_DEBUG table->magic_n = DICT_TABLE_MAGIC_N; - +#endif /* UNIV_DEBUG */ return(table); } @@ -217,7 +217,9 @@ dict_mem_index_create( index->stat_n_diff_key_vals = NULL; index->cached = FALSE; +#ifdef UNIV_DEBUG index->magic_n = DICT_INDEX_MAGIC_N; +#endif /* UNIV_DEBUG */ return(index); } diff --git a/innobase/fil/fil0fil.c b/innobase/fil/fil0fil.c index f55df90846c..9f33013d2f9 100644 --- a/innobase/fil/fil0fil.c +++ b/innobase/fil/fil0fil.c @@ -332,7 +332,9 @@ fil_node_close( ibool ret; ut_ad(node && system); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(system->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(node->open); ut_a(node->n_pending == 0); @@ -356,7 +358,9 @@ fil_node_free( fil_space_t* space) /* in: space where the file node is chained */ { ut_ad(node && system && space); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(system->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(node->magic_n == FIL_NODE_MAGIC_N); if (node->open) { @@ -632,7 +636,7 @@ fil_space_create( /* Spaces with an odd id number are reserved to replicate spaces used in log debugging */ - ut_anp((purpose == FIL_LOG) || (id % 2 == 0)); + ut_a((purpose == FIL_LOG) || (id % 2 == 0)); #endif mutex_enter(&(system->mutex)); @@ -875,7 +879,9 @@ fil_node_prepare_for_io( fil_node_t* last_node; ut_ad(node && system && space); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(system->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (node->open == FALSE) { /* File is closed */ @@ -896,7 +902,7 @@ fil_node_prepare_for_io( "InnoDB: Pending i/o's on %lu files exist\n", system->n_open_pending); - ut_a(0); + ut_error; } fil_node_close(last_node, system); @@ -952,7 +958,9 @@ fil_node_complete_io( { ut_ad(node); ut_ad(system); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(system->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(node->n_pending > 0); node->n_pending--; @@ -1201,7 +1209,7 @@ loop: "InnoDB: Byte offset %lu, len %lu, i/o type %lu\n", block_offset, space_id, byte_offset, len, type); - ut_a(0); + ut_error; } if (node->size > block_offset) { @@ -1230,8 +1238,8 @@ loop: /* Do aio */ - ut_anp(byte_offset % OS_FILE_LOG_BLOCK_SIZE == 0); - ut_anp((len % OS_FILE_LOG_BLOCK_SIZE) == 0); + ut_a(byte_offset % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a((len % OS_FILE_LOG_BLOCK_SIZE) == 0); /* Queue the aio request */ ret = os_aio(type, mode | wake_later, node->name, node->handle, buf, @@ -1331,7 +1339,7 @@ fil_aio_wait( ret = os_aio_posix_handle(segment, &fil_node, &message); #else ret = 0; /* Eliminate compiler warning */ - ut_a(0); + ut_error; #endif } else { srv_io_thread_op_info[segment] =(char *)"simulated aio handle"; diff --git a/innobase/fsp/fsp0fsp.c b/innobase/fsp/fsp0fsp.c index 2cb3ad43e7f..49885df07d7 100644 --- a/innobase/fsp/fsp0fsp.c +++ b/innobase/fsp/fsp0fsp.c @@ -301,9 +301,9 @@ fsp_get_space_header( ut_ad(mtr); header = FSP_HEADER_OFFSET + buf_page_get(id, 0, RW_X_LATCH, mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(header, SYNC_FSP_PAGE); - +#endif /* UNIV_SYNC_DEBUG */ return(header); } @@ -658,7 +658,9 @@ xdes_get_descriptor_with_space_hdr( } else { descr_page = buf_page_get(space, descr_page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(descr_page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ } return(descr_page + XDES_ARR_OFFSET @@ -688,8 +690,9 @@ xdes_get_descriptor( sp_header = FSP_HEADER_OFFSET + buf_page_get(space, 0, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(sp_header, SYNC_FSP_PAGE); - +#endif /* UNIV_SYNC_DEBUG */ return(xdes_get_descriptor_with_space_hdr(sp_header, space, offset, mtr)); } @@ -840,10 +843,13 @@ fsp_header_init( mtr_x_lock(fil_space_get_latch(space), mtr); page = buf_page_create(space, 0, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); - +#endif /* UNIV_SYNC_DEBUG */ buf_page_get(space, 0, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ /* The prior contents of the file page should be ignored */ @@ -862,8 +868,7 @@ fsp_header_init( flst_init(header + FSP_SEG_INODES_FULL, mtr); flst_init(header + FSP_SEG_INODES_FREE, mtr); - mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), - MLOG_8BYTES, mtr); + mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), mtr); fsp_fill_free_list(space, header, mtr); btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF, space, @@ -1083,11 +1088,15 @@ fsp_fill_free_list( if (i > 0) { descr_page = buf_page_create(space, i, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(descr_page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ buf_page_get(space, i, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(descr_page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ fsp_init_file_page(descr_page, mtr); } @@ -1100,12 +1109,14 @@ fsp_fill_free_list( ibuf_page = buf_page_create(space, i + FSP_IBUF_BITMAP_OFFSET, &ibuf_mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(ibuf_page, SYNC_IBUF_BITMAP); - +#endif /* UNIV_SYNC_DEBUG */ buf_page_get(space, i + FSP_IBUF_BITMAP_OFFSET, RW_X_LATCH, &ibuf_mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(ibuf_page, SYNC_FSP_PAGE); - +#endif /* UNIV_SYNC_DEBUG */ fsp_init_file_page(ibuf_page, &ibuf_mtr); ibuf_bitmap_page_init(ibuf_page, &ibuf_mtr); @@ -1264,7 +1275,7 @@ fsp_alloc_free_page( ut_print_buf(((byte*)descr) - 500, 1000); - ut_a(0); + ut_error; } xdes_set_bit(descr, XDES_FREE_BIT, free, FALSE, mtr); @@ -1297,8 +1308,9 @@ fsp_alloc_free_page( buf_page_create(space, page_no, mtr); page = buf_page_get(space, page_no, RW_X_LATCH, mtr); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ /* Prior contents of the page should be ignored */ fsp_init_file_page(page, mtr); @@ -1347,7 +1359,7 @@ fsp_free_page( return; } - ut_a(0); + ut_error; } if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr) @@ -1417,7 +1429,7 @@ fsp_free_extent( ut_print_buf(((byte*)descr) - 500, 1000); - ut_a(0); + ut_error; } xdes_init(descr, mtr); @@ -1532,15 +1544,15 @@ fsp_alloc_seg_inode_page( buf_block_align(page)->check_index_page_at_flush = FALSE; fil_page_set_type(page, FIL_PAGE_INODE); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ for (i = 0; i < FSP_SEG_INODES_PER_PAGE; i++) { inode = fsp_seg_inode_page_get_nth_inode(page, i, mtr); - mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, - MLOG_8BYTES, mtr); + mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr); } flst_add_last(space_header + FSP_SEG_INODES_FREE, @@ -1580,7 +1592,9 @@ fsp_alloc_seg_inode( page = buf_page_get(buf_frame_get_space_id(space_header), page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ n = fsp_seg_inode_page_find_free(page, 0, mtr); @@ -1633,7 +1647,7 @@ fsp_free_seg_inode( page + FSEG_INODE_PAGE_NODE, mtr); } - mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, MLOG_8BYTES, mtr); + mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr); mlog_write_ulint(inode + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr); if (ULINT_UNDEFINED == fsp_seg_inode_page_find_used(page, mtr)) { @@ -1831,9 +1845,11 @@ fseg_create_general( mtr); } +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ latch = fil_space_get_latch(space); mtr_x_lock(latch, mtr); @@ -1865,12 +1881,12 @@ fseg_create_general( /* Read the next segment id from space header and increment the value in space header */ - seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, MLOG_8BYTES, mtr); + seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, mtr); mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1), - MLOG_8BYTES, mtr); + mtr); - mlog_write_dulint(inode + FSEG_ID, seg_id, MLOG_8BYTES, mtr); + mlog_write_dulint(inode + FSEG_ID, seg_id, mtr); mlog_write_ulint(inode + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr); flst_init(inode + FSEG_FREE, mtr); @@ -1985,9 +2001,11 @@ fseg_n_reserved_pages( space = buf_frame_get_space_id(header); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ mtr_x_lock(fil_space_get_latch(space), mtr); inode = fseg_inode_get(header, mtr); @@ -2050,8 +2068,8 @@ fseg_fill_free_list( xdes_set_state(descr, XDES_FSEG, mtr); - seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr); - mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr); + seg_id = mtr_read_dulint(inode + FSEG_ID, mtr); + mlog_write_dulint(descr + XDES_ID, seg_id, mtr); flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr); hint += FSP_EXTENT_SIZE; @@ -2092,10 +2110,10 @@ fseg_alloc_free_extent( return(NULL); } - seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr); + seg_id = mtr_read_dulint(inode + FSEG_ID, mtr); xdes_set_state(descr, XDES_FSEG, mtr); - mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr); + mlog_write_dulint(descr + XDES_ID, seg_id, mtr); flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr); /* Try to fill the segment free list */ @@ -2142,7 +2160,7 @@ fseg_alloc_free_page_low( ut_ad((direction >= FSP_UP) && (direction <= FSP_NO_DIR)); ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE); - seg_id = mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr); + seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr); ut_ad(ut_dulint_cmp(seg_id, ut_dulint_zero) > 0); @@ -2161,8 +2179,7 @@ fseg_alloc_free_page_low( /*-------------------------------------------------------------*/ if ((xdes_get_state(descr, mtr) == XDES_FSEG) && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, - MLOG_8BYTES, mtr), - seg_id)) + mtr), seg_id)) && (xdes_get_bit(descr, XDES_FREE_BIT, hint % FSP_EXTENT_SIZE, mtr) == TRUE)) { @@ -2184,8 +2201,7 @@ fseg_alloc_free_page_low( ut_a(ret_descr == descr); xdes_set_state(ret_descr, XDES_FSEG, mtr); - mlog_write_dulint(ret_descr + XDES_ID, seg_id, MLOG_8BYTES, - mtr); + mlog_write_dulint(ret_descr + XDES_ID, seg_id, mtr); flst_add_last(seg_inode + FSEG_FREE, ret_descr + XDES_FLST_NODE, mtr); @@ -2214,8 +2230,7 @@ fseg_alloc_free_page_low( /*-------------------------------------------------------------*/ } else if ((xdes_get_state(descr, mtr) == XDES_FSEG) && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, - MLOG_8BYTES, mtr), - seg_id)) + mtr), seg_id)) && (!xdes_is_full(descr, mtr))) { /* 4. We can take the page from the same extent as the @@ -2292,7 +2307,9 @@ fseg_alloc_free_page_low( ut_a(page == buf_page_get(space, ret_page, RW_X_LATCH, mtr)); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_FSP_PAGE); +#endif /* UNIV_SYNC_DEBUG */ /* The prior contents of the page should be ignored */ fsp_init_file_page(page, mtr); @@ -2345,9 +2362,11 @@ fseg_alloc_free_page_general( space = buf_frame_get_space_id(seg_header); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ latch = fil_space_get_latch(space); mtr_x_lock(latch, mtr); @@ -2442,9 +2461,11 @@ fsp_reserve_free_extents( ulint n_pages_added; ut_ad(mtr); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ latch = fil_space_get_latch(space); mtr_x_lock(latch, mtr); @@ -2534,8 +2555,9 @@ fsp_get_available_space_in_free_extents( rw_lock_t* latch; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); - +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); latch = fil_space_get_latch(space); @@ -2686,7 +2708,7 @@ fseg_free_page_low( fprintf(stderr, "InnoDB: If the InnoDB recovery crashes here, see section 6.1\n" "InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n"); - ut_a(0); + ut_error; } state = xdes_get_state(descr, mtr); @@ -2716,18 +2738,18 @@ fseg_free_page_low( "InnoDB: segment %lu %lu.\n", space, page, ut_dulint_get_high( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(descr + XDES_ID, mtr)), ut_dulint_get_low( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(descr + XDES_ID, mtr)), ut_dulint_get_high( - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(seg_inode + FSEG_ID, mtr)), ut_dulint_get_low( - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr))); + mtr_read_dulint(seg_inode + FSEG_ID, mtr))); */ /* If we get here, the page is in some extent of the segment */ if (0 != ut_dulint_cmp( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr), - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr))) { + mtr_read_dulint(descr + XDES_ID, mtr), + mtr_read_dulint(seg_inode + FSEG_ID, mtr))) { ut_sprintf_buf(errbuf, descr, 40); fprintf(stderr, @@ -2745,21 +2767,21 @@ fseg_free_page_low( "InnoDB: to segment %lu %lu.\n", space, page, ut_dulint_get_high( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(descr + XDES_ID, mtr)), ut_dulint_get_low( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(descr + XDES_ID, mtr)), ut_dulint_get_high( - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr)), + mtr_read_dulint(seg_inode + FSEG_ID, mtr)), ut_dulint_get_low( - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr))); + mtr_read_dulint(seg_inode + FSEG_ID, mtr))); #else /* More pedantic usage to avoid VC++ 6.0 compiler errors due to inline function expansion issues */ - desm = mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr); - segm = mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr); + desm = mtr_read_dulint(descr + XDES_ID, mtr); + segm = mtr_read_dulint(seg_inode + FSEG_ID, mtr); fprintf(stderr, "InnoDB: Serious error: InnoDB is trying to free space %lu page %lu,\n" @@ -2776,7 +2798,7 @@ fseg_free_page_low( fprintf(stderr, "InnoDB: If the InnoDB recovery crashes here, see section 6.1\n" "InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n"); - ut_a(0); + ut_error; } not_full_n_used = mtr_read_ulint(seg_inode + FSEG_NOT_FULL_N_USED, @@ -2820,9 +2842,11 @@ fseg_free_page( { fseg_inode_t* seg_inode; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ mtr_x_lock(fil_space_get_latch(space), mtr); seg_inode = fseg_inode_get(seg_header, mtr); @@ -2857,8 +2881,8 @@ fseg_free_extent( ut_a(xdes_get_state(descr, mtr) == XDES_FSEG); ut_a(0 == ut_dulint_cmp( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr), - mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr))); + mtr_read_dulint(descr + XDES_ID, mtr), + mtr_read_dulint(seg_inode + FSEG_ID, mtr))); first_page_in_extent = page - (page % FSP_EXTENT_SIZE); @@ -2929,9 +2953,11 @@ fseg_free_step( space = buf_frame_get_space_id(header); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ mtr_x_lock(fil_space_get_latch(space), mtr); descr = xdes_get_descriptor(space, buf_frame_get_page_no(header), mtr); @@ -2940,7 +2966,7 @@ fseg_free_step( freed yet */ ut_a(descr); - ut_anp(xdes_get_bit(descr, XDES_FREE_BIT, buf_frame_get_page_no(header) + ut_a(xdes_get_bit(descr, XDES_FREE_BIT, buf_frame_get_page_no(header) % FSP_EXTENT_SIZE, mtr) == FALSE); inode = fseg_inode_get(header, mtr); @@ -3002,9 +3028,11 @@ fseg_free_step_not_header( space = buf_frame_get_space_id(header); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex) || mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); +#endif /* UNIV_SYNC_DEBUG */ mtr_x_lock(fil_space_get_latch(space), mtr); inode = fseg_inode_get(header, mtr); @@ -3146,7 +3174,7 @@ fseg_validate_low( space = buf_frame_get_space_id(inode); - seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr2); + seg_id = mtr_read_dulint(inode + FSEG_ID, mtr2); n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED, MLOG_4BYTES, mtr2); flst_validate(inode + FSEG_FREE, mtr2); @@ -3165,8 +3193,7 @@ fseg_validate_low( ut_a(xdes_get_n_used(descr, &mtr) == 0); ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG); ut_a(0 == ut_dulint_cmp( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, - &mtr), seg_id)); + mtr_read_dulint(descr + XDES_ID, &mtr), seg_id)); node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr); mtr_commit(&mtr); @@ -3186,8 +3213,7 @@ fseg_validate_low( ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE); ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG); ut_a(0 == ut_dulint_cmp( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, - &mtr), seg_id)); + mtr_read_dulint(descr + XDES_ID, &mtr), seg_id)); n_used2 += xdes_get_n_used(descr, &mtr); @@ -3208,8 +3234,7 @@ fseg_validate_low( ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE); ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG); ut_a(0 == ut_dulint_cmp( - mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, - &mtr), seg_id)); + mtr_read_dulint(descr + XDES_ID, &mtr), seg_id)); node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr); mtr_commit(&mtr); @@ -3274,7 +3299,7 @@ fseg_print_low( reserved = fseg_n_reserved_pages_low(inode, &used, mtr); - d_var = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr); + d_var = mtr_read_dulint(inode + FSEG_ID, mtr); seg_id_low = ut_dulint_get_low(d_var); seg_id_high = ut_dulint_get_high(d_var); @@ -3590,7 +3615,7 @@ fsp_print( n_free_frag = flst_get_len(header + FSP_FREE_FRAG, &mtr); n_full_frag = flst_get_len(header + FSP_FULL_FRAG, &mtr); - d_var = mtr_read_dulint(header + FSP_SEG_ID, MLOG_8BYTES, &mtr); + d_var = mtr_read_dulint(header + FSP_SEG_ID, &mtr); seg_id_low = ut_dulint_get_low(d_var); seg_id_high = ut_dulint_get_high(d_var); diff --git a/innobase/ha/ha0ha.c b/innobase/ha/ha0ha.c index 6021a0846a2..ad833312963 100644 --- a/innobase/ha/ha0ha.c +++ b/innobase/ha/ha0ha.c @@ -82,8 +82,9 @@ ha_insert_for_fold( ulint hash; ut_ad(table && data); +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); - +#endif /* UNIV_SYNC_DEBUG */ hash = hash_calc_hash(fold, table); cell = hash_get_nth_cell(table, hash); @@ -163,8 +164,9 @@ ha_delete( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); - +#endif /* UNIV_SYNC_DEBUG */ node = ha_search_with_data(table, fold, data); ut_a(node); @@ -185,8 +187,9 @@ ha_remove_all_nodes_to_page( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); - +#endif /* UNIV_SYNC_DEBUG */ node = ha_chain_get_first(table, fold); while (node) { diff --git a/innobase/ha/hash0hash.c b/innobase/ha/hash0hash.c index 1f7edf9d7d2..808aa88da3d 100644 --- a/innobase/ha/hash0hash.c +++ b/innobase/ha/hash0hash.c @@ -22,6 +22,7 @@ hash_mutex_enter( hash_table_t* table, /* in: hash table */ ulint fold) /* in: fold */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); mutex_enter(hash_get_mutex(table, fold)); } @@ -34,41 +35,10 @@ hash_mutex_exit( hash_table_t* table, /* in: hash table */ ulint fold) /* in: fold */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); mutex_exit(hash_get_mutex(table, fold)); } -/**************************************************************** -Reserves all the mutexes of a hash table, in an ascending order. */ - -void -hash_mutex_enter_all( -/*=================*/ - hash_table_t* table) /* in: hash table */ -{ - ulint i; - - for (i = 0; i < table->n_mutexes; i++) { - - mutex_enter(table->mutexes + i); - } -} - -/**************************************************************** -Releases all the mutexes of a hash table. */ - -void -hash_mutex_exit_all( -/*================*/ - hash_table_t* table) /* in: hash table */ -{ - ulint i; - - for (i = 0; i < table->n_mutexes; i++) { - - mutex_exit(table->mutexes + i); - } -} - /***************************************************************** Creates a hash table with >= n array cells. The actual number of cells is chosen to be a prime number slightly bigger than n. */ @@ -97,7 +67,9 @@ hash_create( table->mutexes = NULL; table->heaps = NULL; table->heap = NULL; +#ifdef UNIV_DEBUG table->magic_n = HASH_TABLE_MAGIC_N; +#endif /* UNIV_DEBUG */ /* Initialize the cell array */ @@ -118,6 +90,7 @@ hash_table_free( /*============*/ hash_table_t* table) /* in, own: hash table */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); ut_a(table->mutexes == NULL); ut_free(table->array); @@ -139,6 +112,7 @@ hash_create_mutexes( ulint i; ut_a(n_mutexes == ut_2_power_up(n_mutexes)); + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t)); diff --git a/innobase/ibuf/ibuf0ibuf.c b/innobase/ibuf/ibuf0ibuf.c index 7c31ca7c320..f2c631d88cd 100644 --- a/innobase/ibuf/ibuf0ibuf.c +++ b/innobase/ibuf/ibuf0ibuf.c @@ -49,7 +49,7 @@ The solution is the following: We put into each tablespace an insert buffer of its own. Let all the tree and page latches connected with the insert buffer be later in the latching order than the fsp latch and fsp page latches. Insert buffer pages must be such that the insert buffer is never invoked -when these pages area accessed as this would result in a recursion violating +when these pages are accessed as this would result in a recursion violating the latching order. We let a special i/o-handler thread take care of i/o to the insert buffer pages and the ibuf bitmap pages, as well as the fsp bitmap pages and the first inode page, which contains the inode of the ibuf tree: let @@ -239,7 +239,9 @@ ibuf_header_page_get( page = buf_page_get(space, FSP_IBUF_HEADER_PAGE_NO, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_IBUF_HEADER); +#endif /* UNIV_SYNC_DEBUG */ return(page); } @@ -263,7 +265,9 @@ ibuf_tree_root_get( page = buf_page_get(space, FSP_IBUF_TREE_ROOT_PAGE_NO, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ return(page); } @@ -375,7 +379,9 @@ ibuf_data_sizes_update( { ulint old_size; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&ibuf_mutex)); +#endif /* UNIV_SYNC_DEBUG */ old_size = data->size; @@ -455,7 +461,9 @@ ibuf_data_init_for_space( root = buf_page_get(space, FSP_IBUF_TREE_ROOT_PAGE_NO, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(root, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ data->size = 0; data->n_inserts = 0; @@ -679,7 +687,9 @@ ibuf_bitmap_get_map_page( page = buf_page_get(space, ibuf_bitmap_page_no_calc(page_no), RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_IBUF_BITMAP); +#endif /* UNIV_SYNC_DEBUG */ return(page); } @@ -1198,7 +1208,9 @@ ibuf_data_enough_free_for_insert( /* out: TRUE if enough free pages in list */ ibuf_data_t* data) /* in: ibuf data for the space */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&ibuf_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* We want a big margin of free pages, because a B-tree can sometimes grow in size also if records are deleted from it, as the node pointers @@ -1224,7 +1236,9 @@ ibuf_data_too_much_free( /* out: TRUE if enough free pages in list */ ibuf_data_t* data) /* in: ibuf data for the space */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&ibuf_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (data->free_list_len >= 3 + data->size / 2 + 3 * data->height) { @@ -1282,7 +1296,9 @@ ibuf_add_free_page( page = buf_page_get(space, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE_NEW); +#endif /* UNIV_SYNC_DEBUG */ ibuf_enter(); @@ -1402,7 +1418,9 @@ ibuf_remove_free_page( page = buf_page_get(space, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ /* Remove the page from the free list and update the ibuf size data */ @@ -1443,8 +1461,9 @@ ibuf_free_excess_pages( { ibuf_data_t* ibuf_data; ulint i; - +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(fil_space_get_latch(space), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(rw_lock_get_x_lock_count(fil_space_get_latch(space)) == 1); ut_ad(!ibuf_inside()); @@ -1909,7 +1928,9 @@ ibuf_get_volume_buffered( prev_page = buf_page_get(space, prev_page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(prev_page, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ rec = page_get_supremum_rec(prev_page); rec = page_rec_get_prev(rec); @@ -1968,7 +1989,9 @@ count_later: next_page = buf_page_get(space, next_page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(next_page, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ rec = page_get_infimum_rec(next_page); rec = page_rec_get_next(rec); @@ -2592,8 +2615,9 @@ loop: IB__FILE__, __LINE__, &mtr); ut_a(success); - +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TREE_NODE); +#endif /* UNIV_SYNC_DEBUG */ } /* Position pcur in the insert buffer at the first entry for this @@ -2627,7 +2651,7 @@ loop: fprintf(stderr, "InnoDB: Fatal error: you are downgrading from >= 4.1.1 to 4.0, but\n" "InnoDB: the insert buffer was not empty.\n"); - ut_a(0); + ut_error; } if (corruption_noticed) { @@ -2744,7 +2768,9 @@ ibuf_validate_low(void) ibuf_data_t* data; ulint sum_sizes; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&ibuf_mutex)); +#endif /* UNIV_SYNC_DEBUG */ sum_sizes = 0; diff --git a/innobase/include/btr0btr.ic b/innobase/include/btr0btr.ic index 09006828cc9..fd66c7bf2a3 100644 --- a/innobase/include/btr0btr.ic +++ b/innobase/include/btr0btr.ic @@ -45,8 +45,7 @@ btr_page_set_index_id( dulint id, /* in: index id */ mtr_t* mtr) /* in: mtr */ { - mlog_write_dulint(page + PAGE_HEADER + PAGE_INDEX_ID, id, - MLOG_8BYTES, mtr); + mlog_write_dulint(page + PAGE_HEADER + PAGE_INDEX_ID, id, mtr); } /****************************************************************** diff --git a/innobase/include/btr0sea.ic b/innobase/include/btr0sea.ic index 63a3a658cf4..8a41042f713 100644 --- a/innobase/include/btr0sea.ic +++ b/innobase/include/btr0sea.ic @@ -44,8 +44,10 @@ btr_search_info_update( { btr_search_t* info; - ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED) - && !rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); + ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ info = btr_search_get_info(index); diff --git a/innobase/include/buf0buf.h b/innobase/include/buf0buf.h index 2963efd6396..72cedafa7e1 100644 --- a/innobase/include/buf0buf.h +++ b/innobase/include/buf0buf.h @@ -525,11 +525,11 @@ buf_pool_invalidate(void); --------------------------- LOWER LEVEL ROUTINES ------------------------- =========================================================================*/ +#ifdef UNIV_SYNC_DEBUG /************************************************************************* Adds latch level info for the rw-lock protecting the buffer frame. This should be called in the debug version after a successful latching of a -page if we know the latching order level of the acquired latch. If -UNIV_SYNC_DEBUG is not defined, compiles to an empty function. */ +page if we know the latching order level of the acquired latch. */ UNIV_INLINE void buf_page_dbg_add_level( @@ -537,6 +537,7 @@ buf_page_dbg_add_level( buf_frame_t* frame, /* in: buffer page where we have acquired a latch */ ulint level); /* in: latching order level */ +#endif /* UNIV_SYNC_DEBUG */ /************************************************************************* Gets a pointer to the memory frame of a block. */ UNIV_INLINE @@ -778,11 +779,12 @@ struct buf_block_struct{ BTR_SEARCH_RIGHT_SIDE in hash indexing */ /* 6. Debug fields */ - +#ifdef UNIV_SYNC_DEBUG rw_lock_t debug_latch; /* in the debug version, each thread which bufferfixes the block acquires an s-latch here; so we can use the debug utilities in sync0rw */ +#endif ibool file_page_was_freed; /* this is set to TRUE when fsp frees a page in buffer pool */ @@ -822,7 +824,7 @@ struct buf_pool_struct{ ulint n_pages_created;/* number of pages created in the pool with no read */ ulint n_page_gets; /* number of page gets performed; - also successful seraches through + also successful searches through the adaptive hash index are counted as page gets; this field is NOT protected by the buffer diff --git a/innobase/include/buf0buf.ic b/innobase/include/buf0buf.ic index d8e5857a570..5a4c56b0c30 100644 --- a/innobase/include/buf0buf.ic +++ b/innobase/include/buf0buf.ic @@ -129,7 +129,9 @@ buf_pool_clock_tic(void) /*====================*/ /* out: new clock value */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ buf_pool->ulint_clock++; @@ -218,7 +220,7 @@ buf_block_align( "InnoDB: Error: trying to access a stray pointer %lx\n" "InnoDB: buf pool start is at %lx, number of pages %lu\n", (ulint)ptr, (ulint)frame_zero, buf_pool->max_size); - ut_a(0); + ut_error; } return(block); @@ -252,7 +254,7 @@ buf_block_align_low( "InnoDB: Error: trying to access a stray pointer %lx\n" "InnoDB: buf pool start is at %lx, number of pages %lu\n", (ulint)ptr, (ulint)frame_zero, buf_pool->max_size); - ut_a(0); + ut_error; } return(block); @@ -281,7 +283,7 @@ buf_frame_align( "InnoDB: Error: trying to access a stray pointer %lx\n" "InnoDB: buf pool start is at %lx, number of pages %lu\n", (ulint)ptr, (ulint)(buf_pool->frame_zero), buf_pool->max_size); - ut_a(0); + ut_error; } return(frame); @@ -471,8 +473,10 @@ buf_frame_modify_clock_inc( block = buf_block_align_low(frame); +#ifdef UNIV_SYNC_DEBUG ut_ad((mutex_own(&(buf_pool->mutex)) && (block->buf_fix_count == 0)) || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE)); +#endif /* UNIV_SYNC_DEBUG */ UT_DULINT_INC(block->modify_clock); @@ -495,8 +499,10 @@ buf_frame_get_modify_clock( block = buf_block_align(frame); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED) || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE)); +#endif /* UNIV_SYNC_DEBUG */ return(block->modify_clock); } @@ -546,7 +552,9 @@ buf_page_hash_get( ulint fold; ut_ad(buf_pool); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* Look for the page in the hash table */ @@ -644,6 +652,7 @@ buf_page_release( } } +#ifdef UNIV_SYNC_DEBUG /************************************************************************* Adds latch level info for the rw-lock protecting the buffer frame. This should be called in the debug version after a successful latching of a @@ -658,7 +667,6 @@ buf_page_dbg_add_level( ulint level __attribute__((unused))) /* in: latching order level */ { -#ifdef UNIV_SYNC_DEBUG sync_thread_add_level(&(buf_block_align(frame)->lock), level); -#endif } +#endif /* UNIV_SYNC_DEBUG */ diff --git a/innobase/include/buf0flu.ic b/innobase/include/buf0flu.ic index e2faf773cab..d6dbdcc0865 100644 --- a/innobase/include/buf0flu.ic +++ b/innobase/include/buf0flu.ic @@ -40,8 +40,10 @@ buf_flush_note_modification( ut_ad(block); ut_ad(block->state == BUF_BLOCK_FILE_PAGE); ut_ad(block->buf_fix_count > 0); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); ut_ad(mutex_own(&(buf_pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(ut_dulint_cmp(mtr->start_lsn, ut_dulint_zero) != 0); ut_ad(mtr->modifications); @@ -76,7 +78,9 @@ buf_flush_recv_note_modification( ut_ad(block); ut_ad(block->state == BUF_BLOCK_FILE_PAGE); ut_ad(block->buf_fix_count > 0); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(buf_pool->mutex)); diff --git a/innobase/include/data0data.h b/innobase/include/data0data.h index 2501d2b809f..c4e93bec738 100644 --- a/innobase/include/data0data.h +++ b/innobase/include/data0data.h @@ -402,9 +402,11 @@ struct dtuple_struct { UT_LIST_NODE_T(dtuple_t) tuple_list; /* data tuples can be linked into a list using this field */ - ulint magic_n; -}; +#ifdef UNIV_DEBUG + ulint magic_n; #define DATA_TUPLE_MAGIC_N 65478679 +#endif /* UNIV_DEBUG */ +}; /* A slot for a field in a big rec vector */ diff --git a/innobase/include/data0type.ic b/innobase/include/data0type.ic index ddd0b0ae8cc..dbc5b6615f6 100644 --- a/innobase/include/data0type.ic +++ b/innobase/include/data0type.ic @@ -216,7 +216,7 @@ dtype_get_fixed_size( case DATA_VARMYSQL: case DATA_BLOB: return(0); - default: ut_a(0); + default: ut_error; } return(0); diff --git a/innobase/include/dict0dict.ic b/innobase/include/dict0dict.ic index c5982c162a7..b70822e331f 100644 --- a/innobase/include/dict0dict.ic +++ b/innobase/include/dict0dict.ic @@ -543,8 +543,10 @@ dict_table_check_if_in_cache_low( ulint table_fold; ut_ad(table_name); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ + /* Look for the table name in the hash table */ table_fold = ut_fold_string(table_name); @@ -566,8 +568,10 @@ dict_table_get_low( dict_table_t* table; ut_ad(table_name); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ + table = dict_table_check_if_in_cache_low(table_name); if (table == NULL) { @@ -621,7 +625,9 @@ dict_table_get_on_id_low( dict_table_t* table; ulint fold; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ UT_NOT_USED(trx); /* Look for the table name in the hash table */ diff --git a/innobase/include/dict0mem.h b/innobase/include/dict0mem.h index 03dc913a7c9..1930825f601 100644 --- a/innobase/include/dict0mem.h +++ b/innobase/include/dict0mem.h @@ -198,10 +198,11 @@ struct dict_tree_struct{ the list; if the tree is of the mixed type, the first index in the list is the index of the cluster which owns the tree */ +#ifdef UNIV_DEBUG ulint magic_n;/* magic number */ -}; - #define DICT_TREE_MAGIC_N 7545676 +#endif /* UNIV_DEBUG */ +}; /* Data structure for an index */ struct dict_index_struct{ @@ -247,7 +248,10 @@ struct dict_index_struct{ ulint stat_n_leaf_pages; /* approximate number of leaf pages in the index tree */ +#ifdef UNIV_DEBUG ulint magic_n;/* magic number */ +#define DICT_INDEX_MAGIC_N 76789786 +#endif /* UNIV_DEBUG */ }; /* Data structure for a foreign key constraint; an example: @@ -298,9 +302,6 @@ a foreign key constraint is enforced, therefore RESTRICT just means no flag */ #define DICT_FOREIGN_ON_DELETE_NO_ACTION 16 #define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32 - -#define DICT_INDEX_MAGIC_N 76789786 - /* Data structure for a database table */ struct dict_table_struct{ dulint id; /* id of the table or cluster */ @@ -412,10 +413,12 @@ struct dict_table_struct{ inited; MySQL gets the init value by executing SELECT MAX(auto inc column) */ ib_longlong autoinc;/* autoinc counter value to give to the - next inserted row */ + next inserted row */ +#ifdef UNIV_DEBUG ulint magic_n;/* magic number */ -}; #define DICT_TABLE_MAGIC_N 76333786 +#endif /* UNIV_DEBUG */ +}; /* Data structure for a stored procedure */ struct dict_proc_struct{ diff --git a/innobase/include/fut0fut.ic b/innobase/include/fut0fut.ic index 0f1aa9dd9ae..6a107786376 100644 --- a/innobase/include/fut0fut.ic +++ b/innobase/include/fut0fut.ic @@ -30,7 +30,9 @@ fut_get_ptr( ptr = buf_page_get(space, addr.page, rw_latch, mtr) + addr.boffset; +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(ptr, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ return(ptr); } diff --git a/innobase/include/ha0ha.ic b/innobase/include/ha0ha.ic index 761bc3b20de..f6faf84b9f5 100644 --- a/innobase/include/ha0ha.ic +++ b/innobase/include/ha0ha.ic @@ -84,7 +84,9 @@ ha_search( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_chain_get_first(table, fold); @@ -114,7 +116,9 @@ ha_search_and_get_data( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_chain_get_first(table, fold); @@ -146,7 +150,9 @@ ha_next( fold = node->fold; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_chain_get_next(table, node); @@ -176,7 +182,9 @@ ha_search_with_data( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_chain_get_first(table, fold); @@ -206,7 +214,9 @@ ha_search_and_update_if_found( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_search_with_data(table, fold, data); @@ -229,7 +239,9 @@ ha_search_and_delete_if_found( { ha_node_t* node; +#ifdef UNIV_SYNC_DEBUG ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold))); +#endif /* UNIV_SYNC_DEBUG */ node = ha_search_with_data(table, fold, data); diff --git a/innobase/include/hash0hash.h b/innobase/include/hash0hash.h index 378925a5bea..d325636f511 100644 --- a/innobase/include/hash0hash.h +++ b/innobase/include/hash0hash.h @@ -53,15 +53,24 @@ hash_calc_hash( /* out: hashed value */ ulint fold, /* in: folded value */ hash_table_t* table); /* in: hash table */ +/************************************************************************ +Assert that the mutex for the table in a hash operation is owned. */ +#ifdef UNIV_SYNC_DEBUG +# define HASH_ASSERT_OWNED(TABLE, FOLD) \ +ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD))); +#else +# define HASH_ASSERT_OWNED(TABLE, FOLD) +#endif + /*********************************************************************** Inserts a struct to a hash table. */ #define HASH_INSERT(TYPE, NAME, TABLE, FOLD, DATA)\ -{\ +do {\ hash_cell_t* cell3333;\ TYPE* struct3333;\ \ - ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\ + HASH_ASSERT_OWNED(TABLE, FOLD)\ \ (DATA)->NAME = NULL;\ \ @@ -79,17 +88,17 @@ Inserts a struct to a hash table. */ \ struct3333->NAME = DATA;\ }\ -} +} while (0) /*********************************************************************** Deletes a struct from a hash table. */ #define HASH_DELETE(TYPE, NAME, TABLE, FOLD, DATA)\ -{\ +do {\ hash_cell_t* cell3333;\ TYPE* struct3333;\ \ - ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\ + HASH_ASSERT_OWNED(TABLE, FOLD)\ \ cell3333 = hash_get_nth_cell(TABLE, hash_calc_hash(FOLD, TABLE));\ \ @@ -100,13 +109,13 @@ Deletes a struct from a hash table. */ \ while (struct3333->NAME != DATA) {\ \ - ut_ad(struct3333)\ + ut_ad(struct3333);\ struct3333 = struct3333->NAME;\ }\ \ struct3333->NAME = DATA->NAME;\ }\ -} +} while (0) /*********************************************************************** Gets the first struct in a hash chain, NULL if none. */ @@ -124,7 +133,7 @@ Looks for a struct in a hash table. */ #define HASH_SEARCH(NAME, TABLE, FOLD, DATA, TEST)\ {\ \ - ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\ + HASH_ASSERT_OWNED(TABLE, FOLD)\ \ (DATA) = HASH_GET_FIRST(TABLE, hash_calc_hash(FOLD, TABLE));\ \ @@ -160,7 +169,7 @@ the heap. The fold value must be stored in the struct NODE in a field named 'fold'. */ #define HASH_DELETE_AND_COMPACT(TYPE, NAME, TABLE, NODE)\ -{\ +do {\ TYPE* node111;\ TYPE* top_node111;\ hash_cell_t* cell111;\ @@ -211,33 +220,7 @@ the heap. The fold value must be stored in the struct NODE in a field named /* Free the space occupied by the top node */\ \ mem_heap_free_top(hash_get_heap(TABLE, fold111), sizeof(TYPE));\ -} - -/*********************************************************************** -Calculates the number of stored structs in a hash table. */ - -#define HASH_GET_N_NODES(TYPE, NAME, TABLE, N)\ -{\ - hash_cell_t* cell3333;\ - TYPE* struct3333;\ - ulint i3333;\ -\ - (N) = 0;\ -\ - for (i3333 = 0; i3333 < hash_get_n_cells(TABLE); i3333++) {\ -\ - cell3333 = hash_get_nth_cell(TABLE, i3333);\ -\ - struct3333 = cell3333->node;\ -\ - while (struct3333) {\ -\ - (N) = (N) + 1;\ -\ - struct = HASH_GET_NEXT(NAME, struct3333);\ - }\ - }\ -} +} while (0) /**************************************************************** Gets the mutex index for a fold value in a hash table. */ @@ -300,21 +283,6 @@ hash_mutex_exit( /*============*/ hash_table_t* table, /* in: hash table */ ulint fold); /* in: fold */ -/**************************************************************** -Reserves all the mutexes of a hash table, in an ascending order. */ - -void -hash_mutex_enter_all( -/*=================*/ - hash_table_t* table); /* in: hash table */ -/**************************************************************** -Releases all the mutexes of a hash table. */ - -void -hash_mutex_exit_all( -/*================*/ - hash_table_t* table); /* in: hash table */ - struct hash_cell_struct{ void* node; /* hash chain node, NULL if none */ @@ -333,10 +301,11 @@ struct hash_table_struct { memory heaps; there are then n_mutexes many of these heaps */ mem_heap_t* heap; +#ifdef UNIV_DEBUG ulint magic_n; -}; - #define HASH_TABLE_MAGIC_N 76561114 +#endif /* UNIV_DEBUG */ +}; #ifndef UNIV_NONINL #include "hash0hash.ic" diff --git a/innobase/include/hash0hash.ic b/innobase/include/hash0hash.ic index 0d713140c13..1b9acfa2f34 100644 --- a/innobase/include/hash0hash.ic +++ b/innobase/include/hash0hash.ic @@ -18,6 +18,7 @@ hash_get_nth_cell( hash_table_t* table, /* in: hash table */ ulint n) /* in: cell index */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); ut_ad(n < table->n_cells); return(table->array + n); @@ -32,6 +33,7 @@ hash_get_n_cells( /* out: number of cells */ hash_table_t* table) /* in: table */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); return(table->n_cells); } @@ -45,6 +47,7 @@ hash_calc_hash( ulint fold, /* in: folded value */ hash_table_t* table) /* in: hash table */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); return(ut_hash_ulint(fold, table->n_cells)); } @@ -58,6 +61,7 @@ hash_get_mutex_no( hash_table_t* table, /* in: hash table */ ulint fold) /* in: fold */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); return(ut_2pow_remainder(fold, table->n_mutexes)); } @@ -71,6 +75,7 @@ hash_get_nth_heap( hash_table_t* table, /* in: hash table */ ulint i) /* in: index of the heap */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); ut_ad(i < table->n_mutexes); return(table->heaps[i]); @@ -88,6 +93,8 @@ hash_get_heap( { ulint i; + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); + if (table->heap) { return(table->heap); } @@ -107,6 +114,7 @@ hash_get_nth_mutex( hash_table_t* table, /* in: hash table */ ulint i) /* in: index of the mutex */ { + ut_ad(table->magic_n == HASH_TABLE_MAGIC_N); ut_ad(i < table->n_mutexes); return(table->mutexes + i); diff --git a/innobase/include/lock0lock.ic b/innobase/include/lock0lock.ic index 64c43c88d2e..fabc9256401 100644 --- a/innobase/include/lock0lock.ic +++ b/innobase/include/lock0lock.ic @@ -64,7 +64,9 @@ lock_clust_rec_some_has_impl( { dulint trx_id; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(index->type & DICT_CLUSTERED); ut_ad(page_rec_is_user_rec(rec)); diff --git a/innobase/include/log0log.ic b/innobase/include/log0log.ic index 8de239df0bd..587291883f7 100644 --- a/innobase/include/log0log.ic +++ b/innobase/include/log0log.ic @@ -255,7 +255,9 @@ log_block_init( { ulint no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ no = log_block_convert_lsn_to_no(lsn); @@ -277,7 +279,9 @@ log_block_init_in_old_format( { ulint no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ no = log_block_convert_lsn_to_no(lsn); @@ -407,7 +411,9 @@ log_get_online_backup_lsn_low(void) /* out: online_backup_lsn, the caller must own the log_sys mutex */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(log_sys->online_backup_state); return(log_sys->online_backup_lsn); @@ -422,7 +428,9 @@ log_get_online_backup_state_low(void) /* out: online backup state, the caller must own the log_sys mutex */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ return(log_sys->online_backup_state); } diff --git a/innobase/include/mach0data.h b/innobase/include/mach0data.h index 006f55d5f1f..f28c9422670 100644 --- a/innobase/include/mach0data.h +++ b/innobase/include/mach0data.h @@ -88,25 +88,6 @@ mach_read_from_4( /*=============*/ /* out: ulint integer */ byte* b); /* in: pointer to four bytes */ -/*********************************************************** -The following function is used to store data from a ulint to memory -in standard order: -we store the most significant byte to the lowest address. */ -UNIV_INLINE -void -mach_write( -/*=======*/ - byte* b, /* in: pointer to sizeof(ulint) bytes where to store */ - ulint n); /* in: ulint integer to be stored */ -/************************************************************ -The following function is used to fetch data from memory to a ulint. -The most significant byte is at the lowest address. */ -UNIV_INLINE -ulint -mach_read( -/*======*/ - /* out: ulint integer */ - byte* b); /* in: pointer to sizeof(ulint) bytes */ /************************************************************* Writes a ulint in a compressed form. */ UNIV_INLINE diff --git a/innobase/include/mach0data.ic b/innobase/include/mach0data.ic index 1d6badd035b..65e5df2178e 100644 --- a/innobase/include/mach0data.ic +++ b/innobase/include/mach0data.ic @@ -167,44 +167,6 @@ mach_read_from_4( #endif } -/*********************************************************** -The following function is used to store data from a ulint to memory -in standard order: we store the most significant byte to the lowest -address. */ -UNIV_INLINE -void -mach_write( -/*=======*/ - byte* b, /* in: pointer to 4 bytes where to store */ - ulint n) /* in: ulint integer to be stored */ -{ - ut_ad(b); - - b[0] = (byte)(n >> 24); - b[1] = (byte)(n >> 16); - b[2] = (byte)(n >> 8); - b[3] = (byte)n; -} - -/************************************************************ -The following function is used to fetch data from memory to a ulint. -The most significant byte is at the lowest address. */ -UNIV_INLINE -ulint -mach_read( -/*======*/ - /* out: ulint integer */ - byte* b) /* in: pointer to 4 bytes */ -{ - ut_ad(b); - - return( ((ulint)(b[0]) << 24) - + ((ulint)(b[1]) << 16) - + ((ulint)(b[2]) << 8) - + (ulint)(b[3]) - ); -} - /************************************************************* Writes a ulint in a compressed form where the first byte codes the length of the stored ulint. We look at the most significant bits of diff --git a/innobase/include/mem0dbg.ic b/innobase/include/mem0dbg.ic index 765e23e747e..6efac719760 100644 --- a/innobase/include/mem0dbg.ic +++ b/innobase/include/mem0dbg.ic @@ -7,6 +7,7 @@ compilation module but is included in mem0mem.*. Created 6/8/1994 Heikki Tuuri *************************************************************************/ +#ifdef UNIV_MEM_DEBUG extern mutex_t mem_hash_mutex; extern ulint mem_current_allocated_memory; @@ -89,3 +90,4 @@ mem_field_trailer_set_check(byte* field, ulint check); ulint mem_field_trailer_get_check(byte* field); +#endif /* UNIV_MEM_DEBUG */ diff --git a/innobase/include/mtr0log.h b/innobase/include/mtr0log.h index d7de6feb94d..367c9a00651 100644 --- a/innobase/include/mtr0log.h +++ b/innobase/include/mtr0log.h @@ -32,7 +32,6 @@ mlog_write_dulint( /*==============*/ byte* ptr, /* in: pointer where to write */ dulint val, /* in: value to write */ - byte type, /* in: MLOG_8BYTES */ mtr_t* mtr); /* in: mini-transaction handle */ /************************************************************ Writes a string to a file page buffered in the buffer pool. Writes the diff --git a/innobase/include/mtr0log.ic b/innobase/include/mtr0log.ic index 0598f1a9536..54f15779078 100644 --- a/innobase/include/mtr0log.ic +++ b/innobase/include/mtr0log.ic @@ -167,7 +167,7 @@ mlog_write_initial_log_record_fast( fprintf(stderr, "InnoDB: error: buffer page pointer %lx has nonsensical space id %lu\n" "InnoDB: or page no %lu\n", (ulint)ptr, space, offset); - ut_a(0); + ut_error; } mach_write_to_1(log_ptr, type); diff --git a/innobase/include/mtr0mtr.h b/innobase/include/mtr0mtr.h index 86b7c3345ff..d999b7cc5b7 100644 --- a/innobase/include/mtr0mtr.h +++ b/innobase/include/mtr0mtr.h @@ -189,7 +189,6 @@ mtr_read_dulint( /*===========*/ /* out: value read */ byte* ptr, /* in: pointer from where to read */ - ulint type, /* in: MLOG_8BYTES */ mtr_t* mtr); /* in: mini-transaction handle */ /************************************************************************* This macro locks an rw-lock in s-mode. */ @@ -290,7 +289,12 @@ struct mtr_memo_slot_struct{ /* Mini-transaction handle and buffer */ struct mtr_struct{ +#ifdef UNIV_DEBUG ulint state; /* MTR_ACTIVE, MTR_COMMITTING, MTR_COMMITTED */ +#define MTR_ACTIVE 12231 +#define MTR_COMMITTING 56456 +#define MTR_COMMITTED 34676 +#endif /* UNIV_DEBUG */ dyn_array_t memo; /* memo stack for locks etc. */ dyn_array_t log; /* mini-transaction log */ ibool modifications; @@ -305,15 +309,12 @@ struct mtr_struct{ this mtr */ dulint end_lsn;/* end lsn of the possible log entry for this mtr */ +#ifdef UNIV_DEBUG ulint magic_n; -}; - #define MTR_MAGIC_N 54551 +#endif /* UNIV_DEBUG */ +}; -#define MTR_ACTIVE 12231 -#define MTR_COMMITTING 56456 -#define MTR_COMMITTED 34676 - #ifndef UNIV_NONINL #include "mtr0mtr.ic" #endif diff --git a/innobase/include/row0ins.h b/innobase/include/row0ins.h index a5b4b74e7fc..f3f0b7e8eca 100644 --- a/innobase/include/row0ins.h +++ b/innobase/include/row0ins.h @@ -145,10 +145,11 @@ struct ins_node_struct{ entry_list and sys fields are stored here; if this is NULL, entry list should be created and buffers for sys fields in row allocated */ +#ifdef UNIV_DEBUG ulint magic_n; -}; - #define INS_NODE_MAGIC_N 15849075 +#endif /* UNIV_DEBUG */ +}; /* Insert node types */ #define INS_SEARCHED 0 /* INSERT INTO ... SELECT ... */ diff --git a/innobase/include/row0upd.h b/innobase/include/row0upd.h index f5e0a88231f..687e90deee5 100644 --- a/innobase/include/row0upd.h +++ b/innobase/include/row0upd.h @@ -384,10 +384,11 @@ struct upd_node_struct{ sym_node_t* table_sym;/* table node in symbol table */ que_node_t* col_assign_list; /* column assignment list */ +#ifdef UNIV_DEBUG ulint magic_n; -}; - #define UPD_NODE_MAGIC_N 1579975 +#endif /* UNIV_DEBUG */ +}; /* Node execution states */ #define UPD_NODE_SET_IX_LOCK 1 /* execution came to the node from diff --git a/innobase/include/row0upd.ic b/innobase/include/row0upd.ic index 7015b2eda13..3e00978be2f 100644 --- a/innobase/include/row0upd.ic +++ b/innobase/include/row0upd.ic @@ -107,8 +107,10 @@ row_upd_rec_sys_fields( dulint roll_ptr)/* in: roll ptr of the undo log record */ { ut_ad(index->type & DICT_CLUSTERED); +#ifdef UNIV_SYNC_DEBUG ut_ad(!buf_block_align(rec)->is_hashed || rw_lock_own(&btr_search_latch, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ row_set_rec_trx_id(rec, index, trx->id); row_set_rec_roll_ptr(rec, index, roll_ptr); diff --git a/innobase/include/sync0rw.h b/innobase/include/sync0rw.h index 5aa3dcdffc3..d71691b4353 100644 --- a/innobase/include/sync0rw.h +++ b/innobase/include/sync0rw.h @@ -25,13 +25,16 @@ smaller than 30 and the order of the numerical values like below! */ #define RW_NO_LATCH 3 typedef struct rw_lock_struct rw_lock_t; +#ifdef UNIV_SYNC_DEBUG typedef struct rw_lock_debug_struct rw_lock_debug_t; +#endif /* UNIV_SYNC_DEBUG */ typedef UT_LIST_BASE_NODE_T(rw_lock_t) rw_lock_list_t; extern rw_lock_list_t rw_lock_list; extern mutex_t rw_lock_list_mutex; +#ifdef UNIV_SYNC_DEBUG /* The global mutex which protects debug info lists of all rw-locks. To modify the debug info list of an rw-lock, this mutex has to be @@ -42,6 +45,7 @@ extern os_event_t rw_lock_debug_event; /* If deadlock detection does may wait for this event */ extern ibool rw_lock_debug_waiters; /* This is set to TRUE, if there may be waiters for the event */ +#endif /* UNIV_SYNC_DEBUG */ extern ulint rw_s_system_call_count; extern ulint rw_s_spin_wait_count; @@ -327,6 +331,7 @@ ulint rw_lock_get_reader_count( /*=====================*/ rw_lock_t* lock); +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Checks if the thread has locked the rw-lock in the specified mode, with the pass value == 0. */ @@ -337,6 +342,7 @@ rw_lock_own( rw_lock_t* lock, /* in: rw-lock */ ulint lock_type); /* in: lock type: RW_LOCK_SHARED, RW_LOCK_EX */ +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Checks if somebody has locked the rw-lock in the specified mode. */ @@ -346,6 +352,7 @@ rw_lock_is_locked( rw_lock_t* lock, /* in: rw-lock */ ulint lock_type); /* in: lock type: RW_LOCK_SHARED, RW_LOCK_EX */ +#ifdef UNIV_SYNC_DEBUG /******************************************************************* Prints debug info of an rw-lock. */ @@ -392,6 +399,7 @@ void rw_lock_debug_print( /*================*/ rw_lock_debug_t* info); /* in: debug struct */ +#endif /* UNIV_SYNC_DEBUG */ /* NOTE! The structure appears here only for the compiler to know its size. Do not use its fields directly! The structure used in the spin lock @@ -434,10 +442,12 @@ struct rw_lock_struct { UT_LIST_NODE_T(rw_lock_t) list; /* All allocated rw locks are put into a list */ +#ifdef UNIV_SYNC_DEBUG UT_LIST_BASE_NODE_T(rw_lock_debug_t) debug_list; /* In the debug version: pointer to the debug info list of the lock */ - ulint level; /* Debug version: level in the global latching +#endif /* UNIV_SYNC_DEBUG */ + ulint level; /* Level in the global latching order; default SYNC_LEVEL_NONE */ char* cfile_name; /* File name where lock created */ ulint cline; /* Line where created */ @@ -450,6 +460,7 @@ struct rw_lock_struct { #define RW_LOCK_MAGIC_N 22643 +#ifdef UNIV_SYNC_DEBUG /* The structure for storing debug info of an rw-lock */ struct rw_lock_debug_struct { @@ -464,6 +475,7 @@ struct rw_lock_debug_struct { /* Debug structs are linked in a two-way list */ }; +#endif /* UNIV_SYNC_DEBUG */ #ifndef UNIV_NONINL #include "sync0rw.ic" diff --git a/innobase/include/sync0rw.ic b/innobase/include/sync0rw.ic index caf6f5f1de4..8fc93f4a9da 100644 --- a/innobase/include/sync0rw.ic +++ b/innobase/include/sync0rw.ic @@ -20,6 +20,7 @@ rw_lock_s_lock_spin( be passed to another thread to unlock */ char* file_name,/* in: file name where lock requested */ ulint line); /* in: line where requested */ +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Inserts the debug information for an rw-lock. */ @@ -40,7 +41,7 @@ rw_lock_remove_debug_info( rw_lock_t* lock, /* in: rw-lock */ ulint pass, /* in: pass value */ ulint lock_type); /* in: lock type */ - +#endif /* UNIV_SYNC_DEBUG */ /************************************************************************ Accessor functions for rw lock. */ @@ -132,8 +133,9 @@ rw_lock_s_lock_low( char* file_name, /* in: file name where lock requested */ ulint line) /* in: line where requested */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(rw_lock_get_mutex(lock))); - +#endif /* UNIV_SYNC_DEBUG */ /* Check if the writer field is free */ if (lock->writer == RW_LOCK_NOT_LOCKED) { @@ -144,7 +146,6 @@ rw_lock_s_lock_low( rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name, line); #endif - lock->last_s_file_name = file_name; lock->last_s_line = line; @@ -236,7 +237,9 @@ rw_lock_s_lock_func( the threads which have s-locked a latch. This would use some CPU time. */ +#ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(lock, RW_LOCK_SHARED)); /* see NOTE above */ +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(rw_lock_get_mutex(lock)); diff --git a/innobase/include/sync0sync.h b/innobase/include/sync0sync.h index 71263f5d136..3acf3415889 100644 --- a/innobase/include/sync0sync.h +++ b/innobase/include/sync0sync.h @@ -185,6 +185,7 @@ sync_thread_levels_empty_gen( allowed to be owned by the thread, also purge_is_running mutex is allowed */ +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Checks that the current thread owns the mutex. Works only in the debug version. */ @@ -217,6 +218,7 @@ Prints debug info of currently reserved mutexes. */ void mutex_list_print_info(void); /*========================*/ +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** NOT to be used outside this module except in debugging! Gets the value of the lock word. */ @@ -225,6 +227,7 @@ ulint mutex_get_lock_word( /*================*/ mutex_t* mutex); /* in: mutex */ +#ifdef UNIV_SYNC_DEBUG /********************************************************************** NOT to be used outside this module except in debugging! Gets the waiters field in a mutex. */ @@ -234,6 +237,7 @@ mutex_get_waiters( /*==============*/ /* out: value to set */ mutex_t* mutex); /* in: mutex */ +#endif /* UNIV_SYNC_DEBUG */ /* LATCHING ORDER WITHIN THE DATABASE @@ -442,13 +446,13 @@ struct mutex_struct { Otherwise, this is 0. */ UT_LIST_NODE_T(mutex_t) list; /* All allocated mutexes are put into a list. Pointers to the next and prev. */ +#ifdef UNIV_SYNC_DEBUG + const char* file_name; /* File where the mutex was locked */ + ulint line; /* Line where the mutex was locked */ os_thread_id_t thread_id; /* Debug version: The thread id of the thread which locked the mutex. */ - char* file_name; /* Debug version: File name where the mutex - was locked */ - ulint line; /* Debug version: Line where the mutex was - locked */ - ulint level; /* Debug version: level in the global latching +#endif /* UNIV_SYNC_DEBUG */ + ulint level; /* Level in the global latching order; default SYNC_LEVEL_NONE */ char* cfile_name; /* File name where mutex created */ ulint cline; /* Line where created */ diff --git a/innobase/include/sync0sync.ic b/innobase/include/sync0sync.ic index 816b44a5bd3..758c8524f66 100644 --- a/innobase/include/sync0sync.ic +++ b/innobase/include/sync0sync.ic @@ -25,6 +25,7 @@ mutex_spin_wait( mutex_t* mutex, /* in: pointer to mutex */ char* file_name,/* in: file name where mutex requested */ ulint line); /* in: line where requested */ +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Sets the debug information for a reserved mutex. */ @@ -34,6 +35,7 @@ mutex_set_debug_info( mutex_t* mutex, /* in: mutex */ char* file_name, /* in: file where requested */ ulint line); /* in: line where requested */ +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Releases the threads waiting in the primary wait array for this mutex. */ @@ -200,9 +202,9 @@ mutex_exit( /*=======*/ mutex_t* mutex) /* in: pointer to mutex */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(mutex)); -#ifdef UNIV_SYNC_DEBUG mutex->thread_id = ULINT_UNDEFINED; sync_thread_reset_level(mutex); @@ -249,14 +251,9 @@ mutex_enter_func( the atomic test_and_set; we could peek, and possibly save time. */ if (!mutex_test_and_set(mutex)) { - #ifdef UNIV_SYNC_DEBUG mutex_set_debug_info(mutex, file_name, line); #endif - - mutex->file_name = file_name; - mutex->line = line; - return; /* Succeeded! */ } diff --git a/innobase/include/trx0rseg.ic b/innobase/include/trx0rseg.ic index 423447d5566..9a6137eb2e5 100644 --- a/innobase/include/trx0rseg.ic +++ b/innobase/include/trx0rseg.ic @@ -24,7 +24,9 @@ trx_rsegf_get( header = TRX_RSEG + buf_page_get(space, page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(header, SYNC_RSEG_HEADER); +#endif /* UNIV_SYNC_DEBUG */ return(header); } @@ -45,7 +47,9 @@ trx_rsegf_get_new( header = TRX_RSEG + buf_page_get(space, page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(header, SYNC_RSEG_HEADER_NEW); +#endif /* UNIV_SYNC_DEBUG */ return(header); } @@ -64,7 +68,7 @@ trx_rsegf_get_nth_undo( if (n >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: trying to get slot %lu of rseg\n", n); - ut_a(0); + ut_error; } return(mtr_read_ulint(rsegf + TRX_RSEG_UNDO_SLOTS + @@ -85,7 +89,7 @@ trx_rsegf_set_nth_undo( if (n >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: trying to set slot %lu of rseg\n", n); - ut_a(0); + ut_error; } mlog_write_ulint(rsegf + TRX_RSEG_UNDO_SLOTS + n * TRX_RSEG_SLOT_SIZE, diff --git a/innobase/include/trx0sys.ic b/innobase/include/trx0sys.ic index 343e6d7c2fa..8f455e554ea 100644 --- a/innobase/include/trx0sys.ic +++ b/innobase/include/trx0sys.ic @@ -60,7 +60,9 @@ trx_sys_get_nth_rseg( trx_sys_t* sys, /* in: trx system */ ulint n) /* in: index of slot */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(n < TRX_SYS_N_RSEGS); return(sys->rseg_array[n]); @@ -98,7 +100,9 @@ trx_sysf_get( header = TRX_SYS + buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(header, SYNC_TRX_SYS_HEADER); +#endif /* UNIV_SYNC_DEBUG */ return(header); } @@ -115,7 +119,9 @@ trx_sysf_rseg_get_space( ulint i, /* in: slot index == rseg id */ mtr_t* mtr) /* in: mtr */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(sys_header); ut_ad(i < TRX_SYS_N_RSEGS); @@ -138,7 +144,9 @@ trx_sysf_rseg_get_page_no( mtr_t* mtr) /* in: mtr */ { ut_ad(sys_header); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(i < TRX_SYS_N_RSEGS); return(mtr_read_ulint(sys_header + TRX_SYS_RSEGS @@ -158,7 +166,9 @@ trx_sysf_rseg_set_space( ulint space, /* in: space id */ mtr_t* mtr) /* in: mtr */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(sys_header); ut_ad(i < TRX_SYS_N_RSEGS); @@ -182,7 +192,9 @@ trx_sysf_rseg_set_page_no( slot is reset to unused */ mtr_t* mtr) /* in: mtr */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(sys_header); ut_ad(i < TRX_SYS_N_RSEGS); @@ -236,7 +248,9 @@ trx_get_on_id( { trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx = UT_LIST_GET_FIRST(trx_sys->trx_list); @@ -266,7 +280,9 @@ trx_list_get_min_trx_id(void) { trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx = UT_LIST_GET_LAST(trx_sys->trx_list); @@ -289,7 +305,9 @@ trx_is_active( { trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (ut_dulint_cmp(trx_id, trx_list_get_min_trx_id()) < 0) { @@ -325,7 +343,9 @@ trx_sys_get_new_trx_id(void) { dulint id; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* VERY important: after the database is started, max_trx_id value is divisible by TRX_SYS_TRX_ID_WRITE_MARGIN, and the following if @@ -355,7 +375,9 @@ trx_sys_get_new_trx_no(void) /*========================*/ /* out: new, allocated trx number */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ return(trx_sys_get_new_trx_id()); } diff --git a/innobase/include/trx0undo.ic b/innobase/include/trx0undo.ic index bedbc02b00b..a04b234b495 100644 --- a/innobase/include/trx0undo.ic +++ b/innobase/include/trx0undo.ic @@ -126,7 +126,9 @@ trx_undo_page_get( page = buf_page_get(space, page_no, RW_X_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TRX_UNDO_PAGE); +#endif /* UNIV_SYNC_DEBUG */ return(page); } @@ -146,7 +148,9 @@ trx_undo_page_get_s_latched( page = buf_page_get(space, page_no, RW_S_LATCH, mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TRX_UNDO_PAGE); +#endif /* UNIV_SYNC_DEBUG */ return(page); } diff --git a/innobase/include/ut0dbg.h b/innobase/include/ut0dbg.h index 54df031067f..bec9cdd42b5 100644 --- a/innobase/include/ut0dbg.h +++ b/innobase/include/ut0dbg.h @@ -10,7 +10,6 @@ Created 1/30/1994 Heikki Tuuri #define ut0dbg_h #include "univ.i" -#include <assert.h> #include <stdlib.h> #include "os0thread.h" @@ -20,110 +19,46 @@ extern ibool ut_dbg_stop_threads; extern ulint* ut_dbg_null_ptr; -#define ut_a(EXPR)\ -{\ - ulint dbg_i;\ -\ - if (!((ulint)(EXPR) + ut_dbg_zero)) {\ - ut_print_timestamp(stderr);\ - fprintf(stderr,\ - " InnoDB: Assertion failure in thread %lu in file %s line %lu\n",\ - os_thread_pf(os_thread_get_curr_id()), IB__FILE__,\ - (ulint)__LINE__);\ - fprintf(stderr,\ - "InnoDB: Failing assertion: " #EXPR);\ - fprintf(stderr,\ - "\nInnoDB: We intentionally generate a memory trap.\n");\ - fprintf(stderr,\ - "InnoDB: Send a detailed bug report to mysql@lists.mysql.com\n"\ - "InnoDB: If you get repeated assertion failures or crashes, even\n"\ - "InnoDB: immediately after the mysqld startup, there may be\n"\ - "InnoDB: corruption in the InnoDB tablespace. See section 6.1 of\n"\ - "InnoDB: http://www.innodb.com/ibman.php about forcing recovery.\n");\ - ut_dbg_stop_threads = TRUE;\ - dbg_i = *(ut_dbg_null_ptr);\ - if (dbg_i) {\ - ut_dbg_null_ptr = NULL;\ - }\ - }\ - if (ut_dbg_stop_threads) {\ - fprintf(stderr,\ - "InnoDB: Thread %lu stopped in file %s line %lu\n",\ - os_thread_pf(os_thread_get_curr_id()), IB__FILE__, (ulint)__LINE__);\ - os_thread_sleep(1000000000);\ - }\ -} +extern const char* ut_dbg_msg_assert_fail; +extern const char* ut_dbg_msg_trap; +extern const char* ut_dbg_msg_stop; -/* This can be used if there are % characters in the assertion formula: -if we try to printf the formula gcc would complain of illegal print -format characters */ -#define ut_anp(EXPR)\ -{\ - ulint dbg_i;\ -\ +#define ut_a(EXPR) do {\ if (!((ulint)(EXPR) + ut_dbg_zero)) {\ ut_print_timestamp(stderr);\ - fprintf(stderr,\ - " InnoDB: Assertion failure in thread %lu in file %s line %lu\n",\ - os_thread_pf(os_thread_get_curr_id()), IB__FILE__,\ + fprintf(stderr, ut_dbg_msg_assert_fail,\ + os_thread_pf(os_thread_get_curr_id()), __FILE__,\ (ulint)__LINE__);\ - fprintf(stderr,\ - "\nInnoDB: We intentionally generate a memory trap.\n");\ - fprintf(stderr,\ - "InnoDB: Send a detailed bug report to mysql@lists.mysql.com\n"\ - "InnoDB: If you get repeated assertion failures or crashes, even\n"\ - "InnoDB: immediately after the mysqld startup, there may be\n"\ - "InnoDB: corruption in the InnoDB tablespace. See section 6.1 of\n"\ - "InnoDB: http://www.innodb.com/ibman.php about forcing recovery.\n");\ + fputs("InnoDB: Failing assertion: " #EXPR "\n", stderr);\ + fputs(ut_dbg_msg_trap, stderr);\ ut_dbg_stop_threads = TRUE;\ - dbg_i = *(ut_dbg_null_ptr);\ - if (dbg_i) {\ - ut_dbg_null_ptr = NULL;\ - }\ + if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\ }\ if (ut_dbg_stop_threads) {\ - fprintf(stderr,\ - "InnoDB: Thread %lu stopped in file %s line %lu\n",\ - os_thread_pf(os_thread_get_curr_id()), IB__FILE__, (ulint)__LINE__);\ + fprintf(stderr, ut_dbg_msg_stop,\ + os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\ os_thread_sleep(1000000000);\ }\ -} +} while (0) -#define ut_error {\ - ulint dbg_i;\ - ut_print_timestamp(stderr);\ - fprintf(stderr,\ - " InnoDB: Assertion failure in thread %lu in file %s line %lu\n",\ - os_thread_pf(os_thread_get_curr_id()), IB__FILE__, (ulint)__LINE__);\ - fprintf(stderr,\ - "InnoDB: We intentionally generate a memory trap.\n");\ - fprintf(stderr,\ - "InnoDB: Send a detailed bug report to mysql@lists.mysql.com\n"\ - "InnoDB: If you get repeated assertion failures or crashes, even\n"\ - "InnoDB: immediately after the mysqld startup, there may be\n"\ - "InnoDB: corruption in the InnoDB tablespace. See section 6.1 of\n"\ - "InnoDB: http://www.innodb.com/ibman.php about forcing recovery.\n");\ - ut_dbg_stop_threads = TRUE;\ - dbg_i = *(ut_dbg_null_ptr);\ - printf("%lu", dbg_i);\ -} +#define ut_error do {\ + ut_print_timestamp(stderr);\ + fprintf(stderr, ut_dbg_msg_assert_fail,\ + os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\ + fprintf(stderr, ut_dbg_msg_trap);\ + ut_dbg_stop_threads = TRUE;\ + if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\ +} while (0) #ifdef UNIV_DEBUG -#define ut_ad(EXPR) ut_a(EXPR) -#define ut_d(EXPR) {EXPR;} +# define ut_ad(EXPR) ut_a(EXPR) +# define ut_d(EXPR) do {EXPR;} while (0) #else -#define ut_ad(EXPR) -#define ut_d(EXPR) +# define ut_ad(EXPR) +# define ut_d(EXPR) #endif - #define UT_NOT_USED(A) A = A - - - - - - #endif diff --git a/innobase/lock/lock0lock.c b/innobase/lock/lock0lock.c index dd033b037ad..c706ebceaec 100644 --- a/innobase/lock/lock0lock.c +++ b/innobase/lock/lock0lock.c @@ -953,7 +953,9 @@ lock_rec_get_next_on_page( ulint space; ulint page_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(lock) == LOCK_REC); space = lock->un_member.rec_lock.space; @@ -990,7 +992,9 @@ lock_rec_get_first_on_page_addr( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = HASH_GET_FIRST(lock_sys->rec_hash, lock_rec_hash(space, page_no)); @@ -1048,7 +1052,9 @@ lock_rec_get_first_on_page( ulint space; ulint page_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ hash = buf_frame_get_lock_hash_val(ptr); @@ -1080,7 +1086,9 @@ lock_rec_get_next( rec_t* rec, /* in: record on a page */ lock_t* lock) /* in: lock */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(lock) == LOCK_REC); for (;;) { @@ -1109,7 +1117,9 @@ lock_rec_get_first( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = lock_rec_get_first_on_page(rec); @@ -1197,7 +1207,9 @@ lock_rec_get_prev( ulint page_no; lock_t* found_lock = NULL; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(in_lock) == LOCK_REC); space = in_lock->un_member.rec_lock.space; @@ -1237,7 +1249,9 @@ lock_table_has( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* Look for stronger locks the same trx already has on the table */ @@ -1281,7 +1295,9 @@ lock_rec_has_expl( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S || (precise_mode & LOCK_MODE_MASK) == LOCK_X); ut_ad(!(precise_mode & LOCK_INSERT_INTENTION)); @@ -1328,7 +1344,9 @@ lock_rec_other_has_expl_req( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(mode == LOCK_X || mode == LOCK_S); ut_ad(gap == 0 || gap == LOCK_GAP); ut_ad(wait == 0 || wait == LOCK_WAIT); @@ -1367,7 +1385,9 @@ lock_rec_other_has_conflicting( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = lock_rec_get_first(rec); @@ -1399,7 +1419,9 @@ lock_rec_find_similar_on_page( lock_t* lock; ulint heap_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ heap_no = rec_get_heap_no(rec); @@ -1433,7 +1455,9 @@ lock_sec_rec_some_has_impl_off_kernel( { page_t* page; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(!(index->type & DICT_CLUSTERED)); ut_ad(page_rec_is_user_rec(rec)); @@ -1491,7 +1515,9 @@ lock_rec_create( ulint n_bits; ulint n_bytes; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ page = buf_frame_align(rec); space = buf_frame_get_space_id(page); @@ -1575,7 +1601,9 @@ lock_rec_enqueue_waiting( lock_t* lock; trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* Test if there already is some other reason to suspend thread: we do not enqueue a lock request if the query thread should be @@ -1583,7 +1611,7 @@ lock_rec_enqueue_waiting( if (que_thr_stop(thr)) { - ut_a(0); + ut_error; return(DB_QUE_THR_SUSPENDED); } @@ -1660,7 +1688,9 @@ lock_rec_add_to_queue( page_t* page; ibool somebody_waits = FALSE; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((type_mode & (LOCK_WAIT | LOCK_GAP)) || ((type_mode & LOCK_MODE_MASK) != LOCK_S) || !lock_rec_other_has_expl_req(LOCK_X, 0, LOCK_WAIT, rec, trx)); @@ -1740,7 +1770,9 @@ lock_rec_lock_fast( lock_t* lock; ulint heap_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((LOCK_MODE_MASK & mode) != LOCK_S || lock_table_has(thr_get_trx(thr), index->table, LOCK_IS)); ut_ad((LOCK_MODE_MASK & mode) != LOCK_X @@ -1804,7 +1836,9 @@ lock_rec_lock_slow( trx_t* trx; ulint err; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((LOCK_MODE_MASK & mode) != LOCK_S || lock_table_has(thr_get_trx(thr), index->table, LOCK_IS)); ut_ad((LOCK_MODE_MASK & mode) != LOCK_X @@ -1866,7 +1900,9 @@ lock_rec_lock( { ulint err; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((LOCK_MODE_MASK & mode) != LOCK_S || lock_table_has(thr_get_trx(thr), index->table, LOCK_IS)); ut_ad((LOCK_MODE_MASK & mode) != LOCK_X @@ -1904,7 +1940,9 @@ lock_rec_has_to_wait_in_queue( ulint page_no; ulint heap_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_wait(wait_lock)); ut_ad(lock_get_type(wait_lock) == LOCK_REC); @@ -1937,7 +1975,9 @@ lock_grant( /*=======*/ lock_t* lock) /* in: waiting lock request */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock_reset_lock_and_trx_wait(lock); @@ -1979,7 +2019,9 @@ lock_rec_cancel( /*============*/ lock_t* lock) /* in: waiting record lock request */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(lock) == LOCK_REC); /* Reset the bit (there can be only one set bit) in the lock bitmap */ @@ -2012,7 +2054,9 @@ lock_rec_dequeue_from_page( lock_t* lock; trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(in_lock) == LOCK_REC); trx = in_lock->trx; @@ -2055,7 +2099,9 @@ lock_rec_discard( ulint page_no; trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(in_lock) == LOCK_REC); trx = in_lock->trx; @@ -2084,7 +2130,9 @@ lock_rec_free_all_from_discard_page( lock_t* lock; lock_t* next_lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ space = buf_frame_get_space_id(page); page_no = buf_frame_get_page_no(page); @@ -2117,7 +2165,9 @@ lock_rec_reset_and_release_wait( lock_t* lock; ulint heap_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ heap_no = rec_get_heap_no(rec); @@ -2149,7 +2199,9 @@ lock_rec_inherit_to_gap( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = lock_rec_get_first(rec); @@ -2179,7 +2231,9 @@ lock_rec_inherit_to_gap_if_gap_lock( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = lock_rec_get_first(rec); @@ -2212,7 +2266,9 @@ lock_rec_move( ulint heap_no; ulint type_mode; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ heap_no = rec_get_heap_no(donator); @@ -2848,7 +2904,9 @@ lock_deadlock_occurs( char* err_buf; ut_ad(trx && lock); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ retry: /* We check that adding this trx to the waits-for graph does not produce a cycle. First mark all active transactions @@ -2924,7 +2982,9 @@ lock_deadlock_recursive( ulint ret; ut_a(trx && start && wait_lock); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (trx->deadlock_mark == 1) { /* We have already exhaustively searched the subtree starting @@ -3115,7 +3175,9 @@ lock_table_create( lock_t* lock; ut_ad(table && trx); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (type_mode == LOCK_AUTO_INC) { /* Only one trx can have the lock on the table @@ -3165,7 +3227,9 @@ lock_table_remove_low( dict_table_t* table; trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ table = lock->un_member.tab_lock.table; trx = lock->trx; @@ -3199,14 +3263,16 @@ lock_table_enqueue_waiting( lock_t* lock; trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* Test if there already is some other reason to suspend thread: we do not enqueue a lock request if the query thread should be stopped anyway */ if (que_thr_stop(thr)) { - ut_a(0); + ut_error; return(DB_QUE_THR_SUSPENDED); } @@ -3269,7 +3335,9 @@ lock_table_other_has_incompatible( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = UT_LIST_GET_LAST(table->locks); @@ -3419,7 +3487,9 @@ lock_table_dequeue( { lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(lock_get_type(in_lock) == LOCK_TABLE); lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock); @@ -3475,7 +3545,9 @@ lock_release_off_kernel( ulint count; lock_t* lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = UT_LIST_GET_LAST(trx->trx_locks); @@ -3535,7 +3607,9 @@ lock_cancel_waiting_and_release( /*============================*/ lock_t* lock) /* in: waiting lock request */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (lock_get_type(lock) == LOCK_REC) { @@ -3568,7 +3642,9 @@ lock_reset_all_on_table_for_trx( lock_t* lock; lock_t* prev_lock; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ lock = UT_LIST_GET_LAST(trx->trx_locks); @@ -3630,7 +3706,9 @@ lock_table_print( 500 bytes */ lock_t* lock) /* in: table type lock */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_a(lock_get_type(lock) == LOCK_TABLE); buf += sprintf(buf, "TABLE LOCK table %s trx id %lu %lu", @@ -3677,7 +3755,9 @@ lock_rec_print( char* buf_start = buf; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_a(lock_get_type(lock) == LOCK_REC); space = lock->un_member.rec_lock.space; @@ -3739,7 +3819,9 @@ lock_rec_print( } if (page) { +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ } for (i = 0; i < lock_rec_get_n_bits(lock); i++) { @@ -3783,7 +3865,9 @@ lock_get_n_rec_locks(void) ulint n_locks = 0; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) { @@ -4055,7 +4139,9 @@ lock_table_queue_validate( lock_t* lock; ibool is_waiting; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ is_waiting = FALSE; @@ -4208,12 +4294,16 @@ lock_rec_validate_page( ulint i; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); page = buf_page_get(space, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ lock_mutex_enter_kernel(); loop: @@ -4458,7 +4548,9 @@ lock_rec_convert_impl_to_expl( { trx_t* impl_trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(page_rec_is_user_rec(rec)); if (index->type & DICT_CLUSTERED) { diff --git a/innobase/log/log0log.c b/innobase/log/log0log.c index 5df63e39296..ec0db57564a 100644 --- a/innobase/log/log0log.c +++ b/innobase/log/log0log.c @@ -140,7 +140,9 @@ log_buf_pool_get_oldest_modification(void) { dulint lsn; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ lsn = buf_pool_get_oldest_modification(); @@ -239,7 +241,9 @@ log_write_low( ulint data_len; byte* log_block; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log->mutex))); +#endif /* UNIV_SYNC_DEBUG */ part_loop: /* Calculate a part length */ @@ -306,7 +310,9 @@ log_close(void) log_t* log = log_sys; ulint checkpoint_age; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log->mutex))); +#endif /* UNIV_SYNC_DEBUG */ lsn = log->lsn; @@ -407,7 +413,7 @@ log_pad_current_log_block(void) log_close(); log_release(); - ut_anp((ut_dulint_get_low(lsn) % OS_FILE_LOG_BLOCK_SIZE) + ut_a((ut_dulint_get_low(lsn) % OS_FILE_LOG_BLOCK_SIZE) == LOG_BLOCK_HDR_SIZE); } @@ -421,7 +427,9 @@ log_group_get_capacity( /* out: capacity in bytes */ log_group_t* group) /* in: log group */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ return((group->file_size - LOG_FILE_HDR_SIZE) * group->n_files); } @@ -437,7 +445,9 @@ log_group_calc_size_offset( ulint offset, /* in: real offset within the log group */ log_group_t* group) /* in: log group */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ return(offset - LOG_FILE_HDR_SIZE * (1 + offset / group->file_size)); } @@ -453,7 +463,9 @@ log_group_calc_real_offset( ulint offset, /* in: size offset within the log group */ log_group_t* group) /* in: log group */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ return(offset + LOG_FILE_HDR_SIZE * (1 + offset / (group->file_size - LOG_FILE_HDR_SIZE))); @@ -475,7 +487,9 @@ log_group_calc_lsn_offset( ib_longlong group_size; ib_longlong offset; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* If total log file size is > 2 GB we can easily get overflows with 32-bit integers. Use 64-bit integers instead. */ @@ -589,7 +603,9 @@ log_calc_max_ages(void) ulint archive_margin; ulint smallest_archive_margin; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(log_sys->mutex)); @@ -876,7 +892,9 @@ log_flush_do_unlocks( ulint code) /* in: any ORed combination of LOG_UNLOCK_FLUSH_LOCK and LOG_UNLOCK_NONE_FLUSHED_LOCK */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* NOTE that we must own the log mutex when doing the setting of the events: this is because transactions will wait for these events to @@ -908,7 +926,9 @@ log_group_check_flush_completion( /* out: LOG_UNLOCK_NONE_FLUSHED_LOCK or 0 */ log_group_t* group) /* in: log group */ { - ut_ad(mutex_own(&(log_sys->mutex))); +#ifdef UNIV_SYNC_DEBUG + ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (!log_sys->one_flushed && group->n_pending_writes == 0) { @@ -941,7 +961,9 @@ log_sys_check_flush_completion(void) ulint move_start; ulint move_end; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (log_sys->n_pending_writes == 0) { @@ -1004,7 +1026,7 @@ log_io_complete( return; } - ut_a(0); /* We currently use synchronous writing of the + ut_error; /* We currently use synchronous writing of the logs and cannot end up here! */ if (srv_unix_file_flush_method != SRV_UNIX_O_DSYNC @@ -1048,7 +1070,9 @@ log_group_file_header_flush( UT_NOT_USED(type); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(nth_file < group->n_files); @@ -1116,9 +1140,11 @@ log_group_write_buf( ulint next_offset; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); - ut_anp(len % OS_FILE_LOG_BLOCK_SIZE == 0); - ut_anp(ut_dulint_get_low(start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); +#endif /* UNIV_SYNC_DEBUG */ + ut_a(len % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a(ut_dulint_get_low(start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); if (new_data_offset == 0) { write_header = TRUE; @@ -1513,7 +1539,9 @@ void log_complete_checkpoint(void) /*=========================*/ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(log_sys->n_pending_checkpoint_writes == 0); log_sys->next_checkpoint_no @@ -1603,7 +1631,9 @@ log_group_checkpoint( byte* buf; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(LOG_CHECKPOINT_SIZE <= OS_FILE_LOG_BLOCK_SIZE); buf = group->checkpoint_buf; @@ -1757,7 +1787,9 @@ log_group_read_checkpoint_info( log_group_t* group, /* in: log group */ ulint field) /* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ log_sys->n_log_ios++; @@ -1775,7 +1807,9 @@ log_groups_write_checkpoint_info(void) { log_group_t* group; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ group = UT_LIST_GET_FIRST(log_sys->log_groups); @@ -2040,7 +2074,9 @@ log_group_read_log_seg( ulint source_offset; ibool sync; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ sync = FALSE; @@ -2110,7 +2146,9 @@ log_group_archive_file_header_write( byte* buf; ulint dest_offset; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(nth_file < group->n_files); @@ -2147,7 +2185,9 @@ log_group_archive_completed_header_write( byte* buf; ulint dest_offset; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_a(nth_file < group->n_files); buf = *(group->archive_file_header_bufs + nth_file); @@ -2186,15 +2226,17 @@ log_group_archive( ulint n_files; ulint open_mode; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ start_lsn = log_sys->archived_lsn; - ut_anp(ut_dulint_get_low(start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a(ut_dulint_get_low(start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); end_lsn = log_sys->next_archived_lsn; - ut_anp(ut_dulint_get_low(end_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a(ut_dulint_get_low(end_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0); buf = log_sys->archive_buf; @@ -2301,7 +2343,7 @@ loop: group->next_archived_file_no = group->archived_file_no + n_files; group->next_archived_offset = next_offset % group->file_size; - ut_anp(group->next_archived_offset % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a(group->next_archived_offset % OS_FILE_LOG_BLOCK_SIZE == 0); } /********************************************************* @@ -2314,7 +2356,9 @@ log_archive_groups(void) { log_group_t* group; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ group = UT_LIST_GET_FIRST(log_sys->log_groups); @@ -2337,7 +2381,9 @@ log_archive_write_complete_groups(void) dulint end_lsn; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ group = UT_LIST_GET_FIRST(log_sys->log_groups); @@ -2399,7 +2445,9 @@ void log_archive_check_completion_low(void) /*==================================*/ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (log_sys->n_pending_archive_ios == 0 && log_sys->archiving_phase == LOG_ARCHIVE_READ) { @@ -2496,8 +2544,7 @@ loop: start_lsn = log_sys->archived_lsn; if (calc_new_limit) { - ut_anp(log_sys->archive_buf_size % OS_FILE_LOG_BLOCK_SIZE - == 0); + ut_a(log_sys->archive_buf_size % OS_FILE_LOG_BLOCK_SIZE == 0); limit_lsn = ut_dulint_add(start_lsn, log_sys->archive_buf_size); @@ -2631,7 +2678,9 @@ log_archive_close_groups( log_group_t* group; ulint trunc_len; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ group = UT_LIST_GET_FIRST(log_sys->log_groups); @@ -3125,7 +3174,9 @@ log_check_log_recs( byte* buf1; byte* scan_buf; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (len == 0) { diff --git a/innobase/log/log0recv.c b/innobase/log/log0recv.c index a4ca1b4327c..323d6c63f71 100644 --- a/innobase/log/log0recv.c +++ b/innobase/log/log0recv.c @@ -152,13 +152,15 @@ void recv_sys_empty_hash(void) /*=====================*/ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(recv_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (recv_sys->n_addrs != 0) { fprintf(stderr, "InnoDB: Error: %lu pages with log records were left unprocessed!\n" "InnoDB: Maximum page number with log records on it %lu\n", recv_sys->n_addrs, recv_max_parsed_page_no); - ut_a(0); + ut_error; } hash_table_free(recv_sys->addr_hash); @@ -1044,7 +1046,9 @@ recv_recover_page( &mtr); ut_a(success); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ } /* Read the newest modification lsn from the page */ @@ -1245,14 +1249,13 @@ loop: goto loop; } +#ifdef UNIV_SYNC_DEBUG + ut_ad(!allow_ibuf == mutex_own(&log_sys->mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (!allow_ibuf) { - ut_ad(mutex_own(&(log_sys->mutex))); - recv_no_ibuf_operations = TRUE; - } else { - ut_ad(!mutex_own(&(log_sys->mutex))); } - + recv_sys->apply_log_recs = TRUE; recv_sys->apply_batch_on = TRUE; @@ -1282,8 +1285,10 @@ loop: page = buf_page_get(space, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ recv_recover_page(FALSE, FALSE, page, space, page_no); mtr_commit(&mtr); @@ -1505,7 +1510,9 @@ recv_update_replicate( replica = buf_page_get(space + RECV_REPLICA_SPACE_ADD, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(replica, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ ptr = recv_parse_or_apply_log_rec_body(type, body, end_ptr, replica, &mtr); @@ -1574,7 +1581,9 @@ recv_compare_replicate( replica = buf_page_get(space + RECV_REPLICA_SPACE_ADD, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(replica, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ recv_check_identical(page + FIL_PAGE_DATA, replica + FIL_PAGE_DATA, @@ -1615,7 +1624,9 @@ recv_compare_spaces( IB__FILE__, __LINE__, &mtr); if (frame) { +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(frame, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ ut_memcpy(page, frame, UNIV_PAGE_SIZE); } else { /* Read it from file */ @@ -1628,7 +1639,9 @@ recv_compare_spaces( IB__FILE__, __LINE__, &mtr); if (frame) { +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(frame, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ ut_memcpy(replica, frame, UNIV_PAGE_SIZE); } else { /* Read it from file */ @@ -1880,7 +1893,9 @@ recv_parse_log_recs( byte* body; ulint n_recs; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(!ut_dulint_is_zero(recv_sys->parse_start_lsn)); loop: ptr = recv_sys->buf + recv_sys->recovered_offset; @@ -2775,8 +2790,9 @@ recv_reset_logs( { log_group_t* group; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(log_sys->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ log_sys->lsn = ut_dulint_align_up(lsn, OS_FILE_LOG_BLOCK_SIZE); group = UT_LIST_GET_FIRST(log_sys->log_groups); diff --git a/innobase/mem/mem0dbg.c b/innobase/mem/mem0dbg.c index f66f7890fe2..07f348ab82f 100644 --- a/innobase/mem/mem0dbg.c +++ b/innobase/mem/mem0dbg.c @@ -7,6 +7,7 @@ but is included in mem0mem.* ! Created 6/9/1994 Heikki Tuuri *************************************************************************/ +#ifdef UNIV_MEM_DEBUG mutex_t mem_hash_mutex; /* The mutex which protects in the debug version the hash table containing the list of live memory heaps, and @@ -16,12 +17,11 @@ mutex_t mem_hash_mutex; /* The mutex which protects in the extent of memory allocations. Only used in the debug version. Protected by mem_hash_mutex above. */ -ulint mem_n_created_heaps = 0; -ulint mem_n_allocations = 0; -ulint mem_total_allocated_memory = 0; -ulint mem_current_allocated_memory = 0; -ulint mem_max_allocated_memory = 0; -ulint mem_last_print_info = 0; +static ulint mem_n_created_heaps = 0; +static ulint mem_n_allocations = 0; +static ulint mem_total_allocated_memory = 0; +static ulint mem_current_allocated_memory = 0; +static ulint mem_max_allocated_memory = 0; /* Size of the hash table for memory management tracking */ #define MEM_HASH_SIZE 997 @@ -43,12 +43,12 @@ struct mem_hash_node_struct { typedef UT_LIST_BASE_NODE_T(mem_hash_node_t) mem_hash_cell_t; /* The hash table of allocated heaps */ -mem_hash_cell_t mem_hash_table[MEM_HASH_SIZE]; +static mem_hash_cell_t mem_hash_table[MEM_HASH_SIZE]; /* The base node of the list of all allocated heaps */ -mem_hash_cell_t mem_all_list_base; +static mem_hash_cell_t mem_all_list_base; -ibool mem_hash_initialized = FALSE; +static ibool mem_hash_initialized = FALSE; UNIV_INLINE @@ -65,45 +65,44 @@ mem_hash_get_nth_cell(ulint i) return(&(mem_hash_table[i])); } +#endif /* UNIV_MEM_DEBUG */ /* Accessor functions for a memory field in the debug version */ void mem_field_header_set_len(byte* field, ulint len) { - ut_ad(len >= 0); - - mach_write(field - 2 * sizeof(ulint), len); + mach_write_to_4(field - 2 * sizeof(ulint), len); } ulint mem_field_header_get_len(byte* field) { - return(mach_read(field - 2 * sizeof(ulint))); + return(mach_read_from_4(field - 2 * sizeof(ulint))); } void mem_field_header_set_check(byte* field, ulint check) { - mach_write(field - sizeof(ulint), check); + mach_write_to_4(field - sizeof(ulint), check); } ulint mem_field_header_get_check(byte* field) { - return(mach_read(field - sizeof(ulint))); + return(mach_read_from_4(field - sizeof(ulint))); } void mem_field_trailer_set_check(byte* field, ulint check) { - mach_write(field + mem_field_header_get_len(field), check); + mach_write_to_4(field + mem_field_header_get_len(field), check); } ulint mem_field_trailer_get_check(byte* field) { - return(mach_read(field + + return(mach_read_from_4(field + mem_field_header_get_len(field))); } @@ -164,6 +163,7 @@ mem_field_init( mem_field_header_set_check(usr_buf, rnd); mem_field_trailer_set_check(usr_buf, rnd); +#ifdef UNIV_MEM_DEBUG /* Update the memory allocation information */ mutex_enter(&mem_hash_mutex); @@ -182,6 +182,7 @@ mem_field_init( combination of 0xBA and 0xBE */ mem_init_buf(usr_buf, n); +#endif /* UNIV_MEM_DEBUG */ } /********************************************************************** @@ -191,12 +192,14 @@ void mem_field_erase( /*============*/ byte* buf, /* in: memory field */ - ulint n) /* in: how many bytes the user requested */ + ulint n __attribute__((unused))) + /* in: how many bytes the user requested */ { byte* usr_buf; usr_buf = buf + MEM_FIELD_HEADER_SIZE; - + +#ifdef UNIV_MEM_DEBUG mutex_enter(&mem_hash_mutex); mem_current_allocated_memory -= n; mutex_exit(&mem_hash_mutex); @@ -208,8 +211,10 @@ mem_field_erase( combination of 0xDE and 0xAD */ mem_erase_buf(buf, MEM_SPACE_NEEDED(n)); +#endif /* UNIV_MEM_DEBUG */ } +#ifdef UNIV_MEM_DEBUG /******************************************************************* Initializes a buffer to a random combination of hex BA and BE. Used to initialize allocated memory. */ @@ -370,6 +375,7 @@ mem_hash_remove( mutex_exit(&mem_hash_mutex); } +#endif /* UNIV_MEM_DEBUG */ /******************************************************************* Checks a memory heap for consistency and prints the contents if requested. diff --git a/innobase/mem/mem0pool.c b/innobase/mem/mem0pool.c index b004a8c4df7..9a5d16cd4a2 100644 --- a/innobase/mem/mem0pool.c +++ b/innobase/mem/mem0pool.c @@ -259,7 +259,9 @@ mem_pool_fill_free_list( mem_area_t* area2; ibool ret; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(pool->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (i >= 63) { /* We come here when we have run out of space in the @@ -295,7 +297,7 @@ mem_pool_fill_free_list( if (UT_LIST_GET_LEN(pool->free_list[i + 1]) == 0) { mem_analyze_corruption((byte*)area); - ut_a(0); + ut_error; } UT_LIST_REMOVE(free_list, pool->free_list[i + 1], area); @@ -373,7 +375,7 @@ mem_area_alloc( "InnoDB: Probably a race condition because now the area is marked free!\n"); } - ut_a(0); + ut_error; } if (UT_LIST_GET_LEN(pool->free_list[n]) == 0) { @@ -383,7 +385,7 @@ mem_area_alloc( n); mem_analyze_corruption((byte*)area); - ut_a(0); + ut_error; } ut_ad(mem_area_get_size(area) == ut_2_exp(n)); @@ -479,7 +481,7 @@ mem_area_free( "InnoDB: element is marked free!\n"); mem_analyze_corruption((byte*)area); - ut_a(0); + ut_error; } size = mem_area_get_size(area); @@ -490,7 +492,7 @@ mem_area_free( "InnoDB: previous allocated area!\n"); mem_analyze_corruption((byte*)area); - ut_a(0); + ut_error; } #ifdef UNIV_LIGHT_MEM_DEBUG @@ -507,7 +509,7 @@ mem_area_free( size, next_size); mem_analyze_corruption((byte*)area); - ut_a(0); + ut_error; } } #endif @@ -603,7 +605,7 @@ mem_pool_validate( } } - ut_anp(free + pool->reserved == pool->size + ut_a(free + pool->reserved == pool->size - (pool->size % MEM_AREA_MIN_SIZE)); mutex_exit(&(pool->mutex)); diff --git a/innobase/mtr/mtr0log.c b/innobase/mtr/mtr0log.c index 2cfe81d3261..91ff588713d 100644 --- a/innobase/mtr/mtr0log.c +++ b/innobase/mtr/mtr0log.c @@ -59,7 +59,7 @@ mlog_write_initial_log_record( fprintf(stderr, "InnoDB: Error: trying to write to a stray memory location %lx\n", (ulint)ptr); - ut_a(0); + ut_error; } log_ptr = mlog_open(mtr, 20); @@ -222,7 +222,7 @@ mlog_write_ulint( fprintf(stderr, "InnoDB: Error: trying to write to a stray memory location %lx\n", (ulint)ptr); - ut_a(0); + ut_error; } if (type == MLOG_1BYTE) { @@ -261,7 +261,6 @@ mlog_write_dulint( /*==============*/ byte* ptr, /* in: pointer where to write */ dulint val, /* in: value to write */ - byte type, /* in: MLOG_8BYTES */ mtr_t* mtr) /* in: mini-transaction handle */ { byte* log_ptr; @@ -270,11 +269,10 @@ mlog_write_dulint( fprintf(stderr, "InnoDB: Error: trying to write to a stray memory location %lx\n", (ulint)ptr); - ut_a(0); + ut_error; } ut_ad(ptr && mtr); - ut_ad(type == MLOG_8BYTES); mach_write_to_8(ptr, val); @@ -286,7 +284,8 @@ mlog_write_dulint( return; } - log_ptr = mlog_write_initial_log_record_fast(ptr, type, log_ptr, mtr); + log_ptr = mlog_write_initial_log_record_fast(ptr, MLOG_8BYTES, + log_ptr, mtr); mach_write_to_2(log_ptr, ptr - buf_frame_align(ptr)); log_ptr += 2; @@ -314,7 +313,7 @@ mlog_write_string( fprintf(stderr, "InnoDB: Error: trying to write to a stray memory location %lx\n", (ulint)ptr); - ut_a(0); + ut_error; } ut_ad(ptr && mtr); ut_a(len < UNIV_PAGE_SIZE); diff --git a/innobase/mtr/mtr0mtr.c b/innobase/mtr/mtr0mtr.c index aa0acf73d2c..b2d8d022f8c 100644 --- a/innobase/mtr/mtr0mtr.c +++ b/innobase/mtr/mtr0mtr.c @@ -495,13 +495,11 @@ mtr_read_dulint( /*===========*/ /* out: value read */ byte* ptr, /* in: pointer from where to read */ - ulint type __attribute__((unused)), /* in: MLOG_8BYTES */ mtr_t* mtr __attribute__((unused))) /* in: mini-transaction handle */ { ut_ad(mtr->state == MTR_ACTIVE); ut_ad(ptr && mtr); - ut_ad(type == MLOG_8BYTES); ut_ad(mtr_memo_contains(mtr, buf_block_align(ptr), MTR_MEMO_PAGE_S_FIX) || mtr_memo_contains(mtr, buf_block_align(ptr), diff --git a/innobase/os/os0file.c b/innobase/os/os0file.c index 55d0ade1bf7..abcb2259e84 100644 --- a/innobase/os/os0file.c +++ b/innobase/os/os0file.c @@ -722,7 +722,7 @@ try_again: } else if (type == OS_DATA_FILE) { type_str = "DATA"; } else { - ut_a(0); + ut_error; } if (purpose == OS_FILE_AIO) { @@ -730,7 +730,7 @@ try_again: } else if (purpose == OS_FILE_NORMAL) { purpose_str = "NORMAL"; } else { - ut_a(0); + ut_error; } /* printf("Opening file %s, mode %s, type %s, purpose %s\n", @@ -1016,7 +1016,7 @@ os_file_flush( /* It is a fatal error if a file flush does not succeed, because then the database can get corrupt on disk */ - ut_a(0); + ut_error; return(FALSE); #else @@ -1050,7 +1050,7 @@ os_file_flush( /* It is a fatal error if a file flush does not succeed, because then the database can get corrupt on disk */ - ut_a(0); + ut_error; return(FALSE); #endif @@ -1801,7 +1801,7 @@ os_aio_get_array_no( return(3); } else { - ut_a(0); + ut_error; return(0); } @@ -1828,7 +1828,7 @@ os_aio_get_array_from_no( return(os_aio_write_array); } else { - ut_a(0); + ut_error; return(NULL); } @@ -2418,7 +2418,7 @@ os_aio_posix_handle( if (sig != SIGRTMIN + 1 + array_no) { - ut_a(0); + ut_error; return(FALSE); } @@ -2682,7 +2682,7 @@ consecutive_loop: "InnoDB: Error: trying a displaced write to %s %lu %lu, len %lu\n", slot->name, slot->offset_high, slot->offset, total_len); - ut_a(0); + ut_error; } /* Do a 'last millisecond' check that the page end diff --git a/innobase/page/page0cur.c b/innobase/page/page0cur.c index 7e2fc19c00f..b08efacf43a 100644 --- a/innobase/page/page0cur.c +++ b/innobase/page/page0cur.c @@ -713,7 +713,7 @@ page_cur_parse_insert_rec( buf_page_print(page); - ut_a(0); + ut_error; } ut_memcpy(buf, rec_get_start(cursor_rec), mismatch_index); diff --git a/innobase/page/page0page.c b/innobase/page/page0page.c index 71031263fbf..21adcdea635 100644 --- a/innobase/page/page0page.c +++ b/innobase/page/page0page.c @@ -110,7 +110,7 @@ page_dir_find_owner_slot( buf_page_print(page); - ut_a(0); + ut_error; } i--; @@ -441,7 +441,7 @@ page_copy_rec_list_end_no_locks( (ulint)(rec - page), (ulint)(page_cur_get_rec(&cur1) - page), (ulint)(page_cur_get_rec(&cur2) - new_page)); - ut_a(0); + ut_error; } page_cur_move_to_next(&cur1); diff --git a/innobase/pars/lexyy.c b/innobase/pars/lexyy.c index 71507ccd868..ab723cb635c 100644 --- a/innobase/pars/lexyy.c +++ b/innobase/pars/lexyy.c @@ -627,7 +627,7 @@ Linux. #define malloc(A) mem_alloc(A) #define free(A) mem_free(A) #define realloc(P, A) mem_realloc(P, A, __FILE__, __LINE__) -#define exit(A) ut_a(0) +#define exit(A) ut_error #define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size) #define comment 1 diff --git a/innobase/que/que0que.c b/innobase/que/que0que.c index 73af1dc70e2..279f9fc21aa 100644 --- a/innobase/que/que0que.c +++ b/innobase/que/que0que.c @@ -485,7 +485,7 @@ que_graph_free_recursive( "que_thr struct appears corrupt; magic n %lu\n", thr->magic_n); mem_analyze_corruption((byte*)thr); - ut_a(0); + ut_error; } thr->magic_n = QUE_THR_MAGIC_FREED; @@ -597,7 +597,7 @@ que_graph_free_recursive( "que_node struct appears corrupt; type %lu\n", que_node_get_type(node)); mem_analyze_corruption((byte*)node); - ut_a(0); + ut_error; } } @@ -987,7 +987,7 @@ que_thr_move_to_run_state_for_mysql( mem_analyze_corruption((byte*)thr); - ut_a(0); + ut_error; } if (!thr->is_active) { @@ -1023,7 +1023,7 @@ que_thr_stop_for_mysql_no_error( mem_analyze_corruption((byte*)thr); - ut_a(0); + ut_error; } thr->state = QUE_THR_COMPLETED; diff --git a/innobase/read/read0read.c b/innobase/read/read0read.c index 5c1d2d5418e..64b6d87283d 100644 --- a/innobase/read/read0read.c +++ b/innobase/read/read0read.c @@ -54,9 +54,10 @@ read_view_oldest_copy_or_open_new( ulint insert_done = 0; ulint n; ulint i; - - ut_ad(mutex_own(&kernel_mutex)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ old_view = UT_LIST_GET_LAST(trx_sys->view_list); if (old_view == NULL) { @@ -132,9 +133,9 @@ read_view_open_now( read_view_t* view; trx_t* trx; ulint n; - +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); - +#endif /* UNIV_SYNC_DEBUG */ view = read_view_create_low(UT_LIST_GET_LEN(trx_sys->trx_list), heap); view->creator = cr_trx; @@ -195,8 +196,9 @@ read_view_close( /*============*/ read_view_t* view) /* in: read view */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); - +#endif /* UNIV_SYNC_DEBUG */ UT_LIST_REMOVE(view_list, trx_sys->view_list, view); } diff --git a/innobase/rem/rem0cmp.c b/innobase/rem/rem0cmp.c index 71a7b1368cb..dea2621faf3 100644 --- a/innobase/rem/rem0cmp.c +++ b/innobase/rem/rem0cmp.c @@ -273,7 +273,7 @@ cmp_whole_field( default: fprintf(stderr, "InnoDB: unknown type number %lu\n", data_type); - ut_a(0); + ut_error; } return(0); diff --git a/innobase/rem/rem0rec.c b/innobase/rem/rem0rec.c index a151389798d..fddc8eab761 100644 --- a/innobase/rem/rem0rec.c +++ b/innobase/rem/rem0rec.c @@ -108,12 +108,12 @@ rec_get_nth_field( if (n > 1024) { fprintf(stderr, "Error: trying to access field %lu in rec\n", n); - ut_a(0); + ut_error; } if (rec == NULL) { fprintf(stderr, "Error: rec is NULL pointer\n"); - ut_a(0); + ut_error; } if (rec_get_1byte_offs_flag(rec)) { diff --git a/innobase/row/row0ins.c b/innobase/row/row0ins.c index f455eabd2e0..84968ea4e20 100644 --- a/innobase/row/row0ins.c +++ b/innobase/row/row0ins.c @@ -80,9 +80,9 @@ ins_node_create( node->trx_id = ut_dulint_zero; node->entry_sys_heap = mem_heap_create(128); - - node->magic_n = INS_NODE_MAGIC_N; - +#ifdef UNIV_DEBUG + node->magic_n = INS_NODE_MAGIC_N; +#endif /* UNIV_DEBUG */ return(node); } @@ -194,6 +194,7 @@ ins_node_set_new_row( ins_node_t* node, /* in: insert node */ dtuple_t* row) /* in: new row (or first row) for the node */ { + ut_ad(node->magic_n == INS_NODE_MAGIC_N); node->state = INS_NODE_SET_IX_LOCK; node->index = NULL; node->entry = NULL; @@ -855,7 +856,7 @@ row_ins_foreign_check_on_constraint( "InnoDB: Make a detailed bug report and send it\n"); fprintf(stderr, "InnoDB: to mysql@lists.mysql.com\n"); - ut_a(0); + ut_error; */ err = DB_SUCCESS; @@ -1031,8 +1032,10 @@ row_ins_check_foreign_constraint( mtr_t mtr; run_again: +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_SHARED)); - +#endif /* UNIV_SYNC_DEBUG */ + err = DB_SUCCESS; if (thr_get_trx(thr)->check_foreigns == FALSE) { @@ -2031,6 +2034,7 @@ row_ins( ulint err; ut_ad(node && thr); + ut_ad(node->magic_n == INS_NODE_MAGIC_N); if (node->state == INS_NODE_ALLOC_ROW_ID) { @@ -2095,7 +2099,7 @@ row_ins_step( trx_start_if_not_started(trx); node = thr->run_node; - + ut_ad(node->magic_n == INS_NODE_MAGIC_N); ut_ad(que_node_get_type(node) == QUE_NODE_INSERT); parent = que_node_get_parent(node); diff --git a/innobase/row/row0mysql.c b/innobase/row/row0mysql.c index 576c2bc1597..ab73dc2ad6d 100644 --- a/innobase/row/row0mysql.c +++ b/innobase/row/row0mysql.c @@ -270,7 +270,7 @@ handle_new_error: } else { fprintf(stderr, "InnoDB: unknown error code %lu\n", err); - ut_a(0); + ut_error; } if (trx->error_state != DB_SUCCESS) { @@ -383,7 +383,7 @@ row_prebuilt_free( mem_analyze_corruption((byte*)prebuilt); - ut_a(0); + ut_error; } prebuilt->magic_n = ROW_PREBUILT_FREED; @@ -431,7 +431,7 @@ row_prebuilt_free( mem_analyze_corruption( prebuilt->fetch_cache[i]); - ut_a(0); + ut_error; } mem_free((prebuilt->fetch_cache[i]) - 4); @@ -463,7 +463,7 @@ row_update_prebuilt_trx( mem_analyze_corruption((byte*)trx); - ut_a(0); + ut_error; } if (prebuilt->magic_n != ROW_PREBUILT_ALLOCATED) { @@ -474,7 +474,7 @@ row_update_prebuilt_trx( mem_analyze_corruption((byte*)prebuilt); - ut_a(0); + ut_error; } prebuilt->trx = trx; @@ -701,7 +701,7 @@ row_insert_for_mysql( mem_analyze_corruption((byte*)prebuilt); - ut_a(0); + ut_error; } if (srv_created_new_raw || srv_force_recovery) { @@ -917,7 +917,7 @@ row_update_for_mysql( mem_analyze_corruption((byte*)prebuilt); - ut_a(0); + ut_error; } if (srv_created_new_raw || srv_force_recovery) { @@ -1267,9 +1267,11 @@ row_create_table_for_mysql( ulint err; ut_ad(trx->mysql_thread_id == os_thread_get_curr_id()); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX)); - ut_ad(trx->dict_operation_lock_mode == RW_X_LATCH); ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ + ut_ad(trx->dict_operation_lock_mode == RW_X_LATCH); if (srv_created_new_raw) { fprintf(stderr, @@ -1471,8 +1473,10 @@ row_create_index_for_mysql( ulint err; ulint i, j; +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX)); ut_ad(mutex_own(&(dict_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(trx->mysql_thread_id == os_thread_get_curr_id()); trx->op_info = (char *) "creating index"; @@ -1576,8 +1580,10 @@ row_table_add_foreign_constraints( ulint keywordlen; ulint err; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ ut_a(sql_string); trx->op_info = (char *) "adding foreign keys"; @@ -1748,7 +1754,9 @@ row_get_background_drop_list_len_low(void) /*======================================*/ /* out: how many tables in list */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (!row_mysql_drop_list_inited) { @@ -1968,8 +1976,10 @@ row_drop_table_for_mysql( locked_dictionary = TRUE; } +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(dict_sys->mutex))); ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX)); +#endif /* UNIV_SYNC_DEBUG */ graph = pars_sql(buf); @@ -2081,7 +2091,7 @@ row_drop_table_for_mysql( row_mysql_handle_errors(&err, trx, thr, NULL); - ut_a(0); + ut_error; } else { dict_table_remove_from_cache(table); diff --git a/innobase/row/row0purge.c b/innobase/row/row0purge.c index 104d71eda2d..bd3742ad589 100644 --- a/innobase/row/row0purge.c +++ b/innobase/row/row0purge.c @@ -140,7 +140,7 @@ row_purge_remove_clust_if_poss_low( } else if (err == DB_OUT_OF_FILE_SPACE) { success = FALSE; } else { - ut_a(0); + ut_error; } } @@ -266,7 +266,7 @@ row_purge_remove_sec_if_poss_low( } else if (err == DB_OUT_OF_FILE_SPACE) { success = FALSE; } else { - ut_a(0); + ut_error; } } } @@ -447,8 +447,10 @@ skip_secondaries: data_field = buf_page_get(0, page_no, RW_X_LATCH, &mtr) + offset + internal_offset; +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(buf_frame_align(data_field), SYNC_TRX_UNDO_PAGE); +#endif /* UNIV_SYNC_DEBUG */ data_field_len = ufield->new_val.len; diff --git a/innobase/row/row0row.c b/innobase/row/row0row.c index b5d676a936a..6820cb5bccd 100644 --- a/innobase/row/row0row.c +++ b/innobase/row/row0row.c @@ -406,7 +406,7 @@ row_build_row_ref_in_tuple( if (!table) { fprintf(stderr, "InnoDB: table %s for index %s not found\n", index->table_name, index->name); - ut_a(0); + ut_error; } clust_index = dict_table_get_first_index(table); @@ -415,7 +415,7 @@ row_build_row_ref_in_tuple( fprintf(stderr, "InnoDB: clust index for table %s for index %s not found\n", index->table_name, index->name); - ut_a(0); + ut_error; } ref_len = dict_index_get_n_unique(clust_index); diff --git a/innobase/row/row0sel.c b/innobase/row/row0sel.c index fce47a8f9af..6ae4f791205 100644 --- a/innobase/row/row0sel.c +++ b/innobase/row/row0sel.c @@ -930,7 +930,9 @@ row_sel_try_search_shortcut( ut_ad(node->read_view); ut_ad(plan->unique_search); ut_ad(!plan->must_get_clust); +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ row_sel_open_pcur(node, plan, TRUE, mtr); @@ -2070,7 +2072,7 @@ row_sel_store_row_id_to_prebuilt( len, index->table_name, index->name, dict_index_get_sys_col_pos(index, DATA_ROW_ID), err_buf); - ut_a(0); + ut_error; } ut_memcpy(prebuilt->row_id, data, len); @@ -2714,7 +2716,7 @@ row_search_for_mysql( mem_analyze_corruption((byte*)prebuilt); - ut_a(0); + ut_error; } /* printf("Match mode %lu\n search tuple ", match_mode); @@ -2763,7 +2765,7 @@ row_search_for_mysql( if (direction != prebuilt->fetch_direction) { if (prebuilt->n_fetch_cached > 0) { - ut_a(0); + ut_error; /* TODO: scrollable cursor: restore cursor to the place of the latest returned row, or better: prevent caching for a scroll diff --git a/innobase/row/row0undo.c b/innobase/row/row0undo.c index 01b0b1ab41e..78cfe70c260 100644 --- a/innobase/row/row0undo.c +++ b/innobase/row/row0undo.c @@ -333,7 +333,7 @@ row_undo_step( exit(1); } - ut_a(0); + ut_error; return(NULL); } diff --git a/innobase/row/row0upd.c b/innobase/row/row0upd.c index ae373dfc621..ad6542845cb 100644 --- a/innobase/row/row0upd.c +++ b/innobase/row/row0upd.c @@ -287,7 +287,9 @@ upd_node_create( node->select = NULL; node->heap = mem_heap_create(128); - node->magic_n = UPD_NODE_MAGIC_N; +#ifdef UNIV_DEBUG + node->magic_n = UPD_NODE_MAGIC_N; +#endif /* UNIV_DEBUG */ node->cmpl_info = 0; @@ -1804,6 +1806,7 @@ row_upd_step( trx_start_if_not_started(trx); node = thr->run_node; + ut_ad(node->magic_n == UPD_NODE_MAGIC_N); sel_node = node->select; @@ -1923,6 +1926,7 @@ row_upd_in_place_in_select( node = que_node_get_parent(sel_node); + ut_ad(node->magic_n == UPD_NODE_MAGIC_N); ut_ad(que_node_get_type(node) == QUE_NODE_UPDATE); pcur = node->pcur; diff --git a/innobase/row/row0vers.c b/innobase/row/row0vers.c index fca56389e45..bc17ede89e3 100644 --- a/innobase/row/row0vers.c +++ b/innobase/row/row0vers.c @@ -60,8 +60,10 @@ row_vers_impl_x_locked_off_kernel( ulint err; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ mutex_exit(&kernel_mutex); @@ -254,7 +256,9 @@ row_vers_must_preserve_del_marked( mtr_t* mtr) /* in: mtr holding the latch on the clustered index record; it will also hold the latch on purge_view */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ mtr_s_lock(&(purge_sys->latch), mtr); @@ -302,7 +306,9 @@ row_vers_old_has_index_entry( ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX) || mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_S_FIX)); +#ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ mtr_s_lock(&(purge_sys->latch), mtr); clust_index = dict_table_get_first_index(index->table); @@ -411,7 +417,9 @@ row_vers_build_for_consistent_read( ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX) || mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_S_FIX)); +#ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(!read_view_sees_trx_id(view, row_get_rec_trx_id(rec, index))); rw_lock_s_lock(&(purge_sys->latch)); diff --git a/innobase/srv/srv0que.c b/innobase/srv/srv0que.c index 4d36adfefa4..ac8bd7d0e65 100644 --- a/innobase/srv/srv0que.c +++ b/innobase/srv/srv0que.c @@ -83,7 +83,9 @@ srv_que_task_enqueue_low( { ut_ad(thr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr); diff --git a/innobase/srv/srv0srv.c b/innobase/srv/srv0srv.c index 3daf0fe9767..0be0ab957af 100644 --- a/innobase/srv/srv0srv.c +++ b/innobase/srv/srv0srv.c @@ -606,7 +606,9 @@ srv_suspend_thread(void) ulint slot_no; ulint type; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ slot_no = thr_local_get_slot_no(os_thread_get_curr_id()); @@ -656,7 +658,9 @@ srv_release_threads( ut_ad(type >= SRV_WORKER); ut_ad(type <= SRV_MASTER); ut_ad(n > 0); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ for (i = 0; i < OS_THREAD_MAX_N; i++) { @@ -1148,7 +1152,9 @@ srv_table_reserve_slot_for_mysql(void) srv_slot_t* slot; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ i = 0; slot = srv_mysql_table + i; @@ -1178,7 +1184,7 @@ srv_table_reserve_slot_for_mysql(void) (ulint)difftime(ut_time(), slot->suspend_time)); } - ut_a(0); + ut_error; } slot = srv_mysql_table + i; @@ -1213,7 +1219,9 @@ srv_suspend_mysql_thread( ibool had_dict_lock = FALSE; ibool was_declared_inside_innodb = FALSE; +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ trx = thr_get_trx(thr); @@ -1332,7 +1340,9 @@ srv_release_mysql_thread_if_suspended( srv_slot_t* slot; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ for (i = 0; i < OS_THREAD_MAX_N; i++) { diff --git a/innobase/sync/sync0arr.c b/innobase/sync/sync0arr.c index 06e9fdcd63d..67671299e3d 100644 --- a/innobase/sync/sync0arr.c +++ b/innobase/sync/sync0arr.c @@ -100,6 +100,7 @@ struct sync_array_struct { since creation of the array */ }; +#ifdef UNIV_SYNC_DEBUG /********************************************************************** This function is called only in the debug version. Detects a deadlock of one or more threads because of waits of semaphores. */ @@ -113,6 +114,7 @@ sync_array_detect_deadlock( sync_cell_t* start, /* in: cell where recursive search started */ sync_cell_t* cell, /* in: cell to search */ ulint depth); /* in: recursion depth */ +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************* Gets the nth cell in array. */ @@ -464,12 +466,17 @@ sync_array_cell_print( mutex = cell->old_wait_mutex; buf += sprintf(buf, - "Mutex at %lx created file %s line %lu, lock var %lu\n", - (ulint)mutex, mutex->cfile_name, mutex->cline, - mutex->lock_word); - buf += sprintf(buf, - "Last time reserved in file %s line %lu, waiters flag %lu\n", - mutex->file_name, mutex->line, mutex->waiters); + "Mutex at %p created file %s line %lu, lock var %lu\n" +#ifdef UNIV_SYNC_DEBUG + "Last time reserved in file %s line %lu, " +#endif /* UNIV_SYNC_DEBUG */ + "waiters flag %lu\n", + mutex, mutex->cfile_name, mutex->cline, + mutex->lock_word, +#ifdef UNIV_SYNC_DEBUG + mutex->file_name, mutex->line, +#endif /* UNIV_SYNC_DEBUG */ + mutex->waiters); } else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) { @@ -518,6 +525,7 @@ sync_array_cell_print( } } +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Looks for a cell with the given thread id. */ static @@ -689,7 +697,6 @@ sync_array_detect_deadlock( sync_array_cell_print(buf, cell); printf("rw-lock %lx %s ", (ulint) lock, buf); rw_lock_debug_print(debug); - return(TRUE); } } @@ -739,6 +746,7 @@ sync_array_detect_deadlock( return(TRUE); /* Execution never reaches this line: for compiler fooling only */ } +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Determines if we can wake up the thread waiting for a sempahore. */ @@ -932,7 +940,7 @@ sync_array_print_long_waits(void) "InnoDB: We intentionally crash the server, because it appears to be hung.\n" ); - ut_a(0); + ut_error; } } diff --git a/innobase/sync/sync0rw.c b/innobase/sync/sync0rw.c index fd52d5aac2e..86924c437c7 100644 --- a/innobase/sync/sync0rw.c +++ b/innobase/sync/sync0rw.c @@ -31,6 +31,7 @@ ulint rw_x_exit_count = 0; rw_lock_list_t rw_lock_list; mutex_t rw_lock_list_mutex; +#ifdef UNIV_SYNC_DEBUG /* The global mutex which protects debug info lists of all rw-locks. To modify the debug info list of an rw-lock, this mutex has to be acquired in addition to the mutex protecting the lock. */ @@ -76,6 +77,7 @@ rw_lock_debug_free( { mem_free(info); } +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Creates, or rather, initializes an rw-lock object in a specified memory @@ -107,10 +109,12 @@ rw_lock_create_func( lock->writer_is_wait_ex = FALSE; +#ifdef UNIV_SYNC_DEBUG UT_LIST_INIT(lock->debug_list); - lock->magic_n = RW_LOCK_MAGIC_N; lock->level = SYNC_LEVEL_NONE; +#endif /* UNIV_SYNC_DEBUG */ + lock->magic_n = RW_LOCK_MAGIC_N; lock->cfile_name = cfile_name; lock->cline = cline; @@ -307,8 +311,9 @@ rw_lock_x_lock_low( char* file_name,/* in: file name where lock requested */ ulint line) /* in: line where requested */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(rw_lock_get_mutex(lock))); - +#endif /* UNIV_SYNC_DEBUG */ if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) { if (rw_lock_get_reader_count(lock) == 0) { @@ -516,6 +521,7 @@ lock_loop: goto lock_loop; } +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Acquires the debug mutex. We cannot use the mutex defined in sync0sync, because the debug mutex is also acquired in sync0arr while holding the OS @@ -641,6 +647,7 @@ rw_lock_remove_debug_info( ut_error; } +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Sets the rw-lock latching level field. */ @@ -654,6 +661,7 @@ rw_lock_set_level( lock->level = level; } +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Checks if the thread has locked the rw-lock in the specified mode, with the pass value == 0. */ @@ -671,9 +679,6 @@ rw_lock_own( ut_ad(lock); ut_ad(rw_lock_validate(lock)); -#ifndef UNIV_SYNC_DEBUG - ut_error; -#endif mutex_enter(&(lock->mutex)); info = UT_LIST_GET_FIRST(lock->debug_list); @@ -696,6 +701,7 @@ rw_lock_own( return(FALSE); } +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Checks if somebody has locked the rw-lock in the specified mode. */ @@ -732,6 +738,7 @@ rw_lock_is_locked( return(ret); } +#ifdef UNIV_SYNC_DEBUG /******************************************************************* Prints debug info of currently locked rw-locks. */ @@ -739,8 +746,6 @@ void rw_lock_list_print_info(void) /*=========================*/ { -#ifndef UNIV_SYNC_DEBUG -#else rw_lock_t* lock; ulint count = 0; rw_lock_debug_t* info; @@ -784,7 +789,6 @@ rw_lock_list_print_info(void) printf("Total number of rw-locks %ld\n", count); mutex_exit(&rw_lock_list_mutex); -#endif } /******************************************************************* @@ -795,11 +799,6 @@ rw_lock_print( /*==========*/ rw_lock_t* lock __attribute__((unused))) /* in: rw-lock */ { -#ifndef UNIV_SYNC_DEBUG - printf( - "Sorry, cannot give rw-lock info in non-debug version!\n"); -#else - ulint count = 0; rw_lock_debug_t* info; printf("-------------\n"); @@ -822,7 +821,6 @@ rw_lock_print( info = UT_LIST_GET_NEXT(list, info); } } -#endif } /************************************************************************* @@ -862,12 +860,6 @@ ulint rw_lock_n_locked(void) /*==================*/ { -#ifndef UNIV_SYNC_DEBUG - printf( - "Sorry, cannot give rw-lock info in non-debug version!\n"); - ut_error; - return(0); -#else rw_lock_t* lock; ulint count = 0; @@ -890,5 +882,5 @@ rw_lock_n_locked(void) mutex_exit(&rw_lock_list_mutex); return(count); -#endif } +#endif /* UNIV_SYNC_DEBUG */ diff --git a/innobase/sync/sync0sync.c b/innobase/sync/sync0sync.c index 178511b8996..4f5d27bcc7c 100644 --- a/innobase/sync/sync0sync.c +++ b/innobase/sync/sync0sync.c @@ -188,8 +188,10 @@ mutex_create_func( #endif mutex_set_waiters(mutex, 0); mutex->magic_n = MUTEX_MAGIC_N; +#ifdef UNIV_SYNC_DEBUG mutex->line = 0; mutex->file_name = (char *) "not yet reserved"; +#endif /* UNIV_SYNC_DEBUG */ mutex->level = SYNC_LEVEL_NONE; mutex->cfile_name = cfile_name; mutex->cline = cline; @@ -253,9 +255,11 @@ mutex_enter_nowait( /*===============*/ /* out: 0 if succeed, 1 if not */ mutex_t* mutex, /* in: pointer to mutex */ - char* file_name, /* in: file name where mutex + char* file_name __attribute__((unused)), + /* in: file name where mutex requested */ - ulint line) /* in: line where requested */ + ulint line __attribute__((unused))) + /* in: line where requested */ { ut_ad(mutex_validate(mutex)); @@ -264,9 +268,6 @@ mutex_enter_nowait( #ifdef UNIV_SYNC_DEBUG mutex_set_debug_info(mutex, file_name, line); #endif - - mutex->file_name = file_name; - mutex->line = line; return(0); /* Succeeded! */ } @@ -366,9 +367,6 @@ spin_loop: mutex_set_debug_info(mutex, file_name, line); #endif - mutex->file_name = file_name; - mutex->line = line; - return; } @@ -413,9 +411,6 @@ spin_loop: mutex_set_debug_info(mutex, file_name, line); #endif - mutex->file_name = file_name; - mutex->line = line; - if (srv_print_latch_waits) { printf( "Thread %lu spin wait succeeds at 2: mutex at %lx\n", @@ -465,6 +460,7 @@ mutex_signal_object( sync_array_signal_object(sync_primary_wait_array, mutex); } +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Sets the debug information for a reserved mutex. */ @@ -502,7 +498,8 @@ mutex_get_debug_info( *file_name = mutex->file_name; *line = mutex->line; *thread_id = mutex->thread_id; -} +} +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Sets the mutex latching level field. */ @@ -516,6 +513,7 @@ mutex_set_level( mutex->level = level; } +#ifdef UNIV_SYNC_DEBUG /********************************************************************** Checks that the current thread owns the mutex. Works only in the debug version. */ @@ -548,8 +546,6 @@ void mutex_list_print_info(void) /*=======================*/ { -#ifndef UNIV_SYNC_DEBUG -#else mutex_t* mutex; char* file_name; ulint line; @@ -582,7 +578,6 @@ mutex_list_print_info(void) printf("Total number of mutexes %ld\n", count); mutex_exit(&mutex_list_mutex); -#endif } /********************************************************************** @@ -592,12 +587,6 @@ ulint mutex_n_reserved(void) /*==================*/ { -#ifndef UNIV_SYNC_DEBUG - printf("Sorry, cannot give mutex info in non-debug version!\n"); - ut_error; - - return(0); -#else mutex_t* mutex; ulint count = 0; @@ -620,7 +609,6 @@ mutex_n_reserved(void) return(count - 1); /* Subtract one, because this function itself was holding one mutex (mutex_list_mutex) */ -#endif } /********************************************************************** @@ -631,19 +619,9 @@ ibool sync_all_freed(void) /*================*/ { -#ifdef UNIV_SYNC_DEBUG - if (mutex_n_reserved() + rw_lock_n_locked() == 0) { - - return(TRUE); - } else { - return(FALSE); - } -#else - ut_error; - - return(FALSE); -#endif + return(mutex_n_reserved() + rw_lock_n_locked() == 0); } +#endif /* UNIV_SYNC_DEBUG */ /********************************************************************** Gets the value in the nth slot in the thread level arrays. */ @@ -740,9 +718,6 @@ sync_thread_levels_g( thread */ ulint limit) /* in: level limit */ { - char* file_name; - ulint line; - os_thread_id_t thread_id; sync_level_t* slot; rw_lock_t* lock; mutex_t* mutex; @@ -767,18 +742,28 @@ sync_thread_levels_g( mutex->cline); if (mutex_get_lock_word(mutex) != 0) { +#ifdef UNIV_SYNC_DEBUG + char* file_name; + ulint line; + os_thread_id_t thread_id; mutex_get_debug_info(mutex, &file_name, &line, &thread_id); - printf("InnoDB: Locked mutex: addr %lx thread %ld file %s line %ld\n", - (ulint)mutex, os_thread_pf(thread_id), - file_name, line); + fprintf(stderr, + "InnoDB: Locked mutex: addr %p thread %ld file %s line %ld\n", + mutex, os_thread_pf(thread_id), file_name, line); +#else /* UNIV_SYNC_DEBUG */ + fprintf(stderr, + "InnoDB: Locked mutex: addr %p\n", mutex); +#endif /* UNIV_SYNC_DEBUG */ } else { - printf("Not locked\n"); + fputs("Not locked\n", stderr); } } else { +#ifdef UNIV_SYNC_DEBUG rw_lock_print(lock); +#endif /* UNIV_SYNC_DEBUG */ } return(FALSE); @@ -918,7 +903,9 @@ sync_thread_add_level( if ((latch == (void*)&sync_thread_mutex) || (latch == (void*)&mutex_list_mutex) +#ifdef UNIV_SYNC_DEBUG || (latch == (void*)&rw_lock_debug_mutex) +#endif /* UNIV_SYNC_DEBUG */ || (latch == (void*)&rw_lock_list_mutex)) { return; @@ -1098,7 +1085,9 @@ sync_thread_reset_level( if ((latch == (void*)&sync_thread_mutex) || (latch == (void*)&mutex_list_mutex) +#ifdef UNIV_SYNC_DEBUG || (latch == (void*)&rw_lock_debug_mutex) +#endif /* UNIV_SYNC_DEBUG */ || (latch == (void*)&rw_lock_list_mutex)) { return(FALSE); @@ -1184,11 +1173,13 @@ sync_init(void) mutex_create(&rw_lock_list_mutex); mutex_set_level(&rw_lock_list_mutex, SYNC_NO_ORDER_CHECK); +#ifdef UNIV_SYNC_DEBUG mutex_create(&rw_lock_debug_mutex); mutex_set_level(&rw_lock_debug_mutex, SYNC_NO_ORDER_CHECK); rw_lock_debug_event = os_event_create(NULL); rw_lock_debug_waiters = FALSE; +#endif /* UNIV_SYNC_DEBUG */ } /********************************************************************** @@ -1250,9 +1241,11 @@ sync_print( char* buf, /* in/out: buffer where to print */ char* buf_end) /* in: buffer end */ { +#ifdef UNIV_SYNC_DEBUG mutex_list_print_info(); rw_lock_list_print_info(); +#endif /* UNIV_SYNC_DEBUG */ sync_array_print_info(buf, buf_end, sync_primary_wait_array); diff --git a/innobase/thr/thr0loc.c b/innobase/thr/thr0loc.c index 839cb024f25..a17d09fcca6 100644 --- a/innobase/thr/thr0loc.c +++ b/innobase/thr/thr0loc.c @@ -46,10 +46,11 @@ struct thr_local_struct{ ibool in_ibuf;/* TRUE if the the thread is doing an ibuf operation */ hash_node_t hash; /* hash chain node */ +#ifdef UNIV_DEBUG ulint magic_n; -}; - #define THR_LOCAL_MAGIC_N 1231234 +#endif /* UNIV_DEBUG */ +}; /*********************************************************************** Returns the local storage struct for a thread. */ @@ -64,7 +65,9 @@ thr_local_get( try_again: ut_ad(thr_local_hash); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&thr_local_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* Look for the local struct in the hash table */ @@ -167,8 +170,9 @@ thr_local_create(void) local->id = os_thread_get_curr_id(); local->handle = os_thread_get_curr(); +#ifdef UNIV_DEBUG local->magic_n = THR_LOCAL_MAGIC_N; - +#endif /* UNIV_DEBUG */ local->in_ibuf = FALSE; mutex_enter(&thr_local_mutex); @@ -207,7 +211,7 @@ thr_local_free( mutex_exit(&thr_local_mutex); - ut_a(local->magic_n == THR_LOCAL_MAGIC_N); + ut_ad(local->magic_n == THR_LOCAL_MAGIC_N); mem_free(local); } diff --git a/innobase/trx/trx0purge.c b/innobase/trx/trx0purge.c index 222ca6debbd..6a509b163b3 100644 --- a/innobase/trx/trx0purge.c +++ b/innobase/trx/trx0purge.c @@ -45,7 +45,9 @@ trx_purge_update_undo_must_exist( the undo log still exists in the system */ dulint trx_id) /* in: transaction id */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ if (!read_view_sees_trx_id(purge_sys->view, trx_id)) { @@ -195,7 +197,9 @@ void trx_purge_sys_create(void) /*======================*/ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ purge_sys = mem_alloc(sizeof(trx_purge_t)); @@ -258,7 +262,9 @@ trx_purge_add_update_undo_to_history( ut_ad(undo); rseg = undo->rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr); @@ -272,7 +278,7 @@ trx_purge_add_update_undo_to_history( if (undo->id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id); - ut_a(0); + ut_error; } trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL, mtr); @@ -291,8 +297,7 @@ trx_purge_add_update_undo_to_history( undo_header + TRX_UNDO_HISTORY_NODE, mtr); /* Write the trx number to the undo log header */ - mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, MLOG_8BYTES, - mtr); + mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr); /* Write information about delete markings to the undo log header */ if (!undo->del_marks) { @@ -334,7 +339,9 @@ trx_purge_free_segment( /* printf("Freeing an update undo log segment\n"); */ +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ loop: mtr_start(&mtr); mutex_enter(&(rseg->mutex)); @@ -430,7 +437,9 @@ trx_purge_truncate_rseg_history( ulint n_removed_logs = 0; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); mutex_enter(&(rseg->mutex)); @@ -516,7 +525,9 @@ trx_purge_truncate_history(void) dulint limit_trx_no; dulint limit_undo_no; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no, &limit_undo_no); @@ -556,7 +567,9 @@ trx_purge_truncate_if_arr_empty(void) /*=================================*/ /* out: TRUE if array empty */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (purge_sys->arr->n_used == 0) { @@ -585,7 +598,9 @@ trx_purge_rseg_get_next_history_log( ibool del_marks; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(rseg->mutex)); @@ -665,7 +680,9 @@ trx_purge_choose_next_log(void) ulint offset = 0; /* remove warning (??? bug ???) */ mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(purge_sys->next_stored == FALSE); rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list); @@ -766,7 +783,9 @@ trx_purge_get_next_rec( ulint cmpl_info; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(purge_sys->mutex))); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(purge_sys->next_stored); space = purge_sys->rseg->space; @@ -997,7 +1016,7 @@ trx_purge(void) /* Should not happen */ - ut_a(0); + ut_error; return(0); } diff --git a/innobase/trx/trx0rec.c b/innobase/trx/trx0rec.c index c62f311d6a4..9d944e16a1e 100644 --- a/innobase/trx/trx0rec.c +++ b/innobase/trx/trx0rec.c @@ -1069,7 +1069,9 @@ trx_undo_report_row_operation( IB__FILE__, __LINE__, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(undo_page, SYNC_TRX_UNDO_PAGE); +#endif /* UNIV_SYNC_DEBUG */ if (op_type == TRX_UNDO_INSERT_OP) { offset = trx_undo_page_report_insert(undo_page, trx, @@ -1196,7 +1198,9 @@ trx_undo_get_undo_rec( trx_undo_rec_t** undo_rec, /* out, own: copy of the record */ mem_heap_t* heap) /* in: memory heap where copied */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ if (!trx_purge_update_undo_must_exist(trx_id)) { @@ -1256,7 +1260,9 @@ trx_undo_prev_version_build( ulint i; char err_buf[1000]; +#ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(mtr_memo_contains(index_mtr, buf_block_align(index_rec), MTR_MEMO_PAGE_S_FIX) || mtr_memo_contains(index_mtr, buf_block_align(index_rec), diff --git a/innobase/trx/trx0roll.c b/innobase/trx/trx0roll.c index 206aeb1d2ce..c00c6f0c862 100644 --- a/innobase/trx/trx0roll.c +++ b/innobase/trx/trx0roll.c @@ -676,8 +676,10 @@ trx_roll_try_truncate( dulint limit; dulint biggest; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); ut_ad(mutex_own(&((trx->rseg)->mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx->pages_undone = 0; @@ -720,7 +722,9 @@ trx_roll_pop_top_rec( trx_undo_rec_t* prev_rec; page_t* prev_rec_page; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); +#endif /* UNIV_SYNC_DEBUG */ undo_page = trx_undo_page_get_s_latched(undo->space, undo->top_page_no, mtr); @@ -944,7 +948,9 @@ trx_rollback( que_thr_t* thr; /* que_thr_t* thr2; */ +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad((trx->undo_no_arr == NULL) || ((trx->undo_no_arr)->n_used == 0)); /* Initialize the rollback field in the transaction */ @@ -1013,7 +1019,9 @@ trx_roll_graph_build( que_thr_t* thr; /* que_thr_t* thr2; */ +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ heap = mem_heap_create(512); fork = que_fork_create(NULL, NULL, QUE_FORK_ROLLBACK, heap); @@ -1040,7 +1048,9 @@ trx_finish_error_processing( trx_sig_t* sig; trx_sig_t* next_sig; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ sig = UT_LIST_GET_FIRST(trx->signals); @@ -1073,7 +1083,9 @@ trx_finish_partial_rollback_off_kernel( { trx_sig_t* sig; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ sig = UT_LIST_GET_FIRST(trx->signals); @@ -1104,7 +1116,9 @@ trx_finish_rollback_off_kernel( trx_sig_t* sig; trx_sig_t* next_sig; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_a(trx->undo_no_arr == NULL || trx->undo_no_arr->n_used == 0); diff --git a/innobase/trx/trx0rseg.c b/innobase/trx/trx0rseg.c index b1fb8a9539c..e3885c86def 100644 --- a/innobase/trx/trx0rseg.c +++ b/innobase/trx/trx0rseg.c @@ -60,7 +60,9 @@ trx_rseg_header_create( page_t* page; ut_ad(mtr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space), MTR_MEMO_X_LOCK)); sys_header = trx_sysf_get(mtr); @@ -81,7 +83,9 @@ trx_rseg_header_create( return(FIL_NULL); } +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_RSEG_HEADER_NEW); +#endif /* UNIV_SYNC_DEBUG */ page_no = buf_frame_get_page_no(page); @@ -132,7 +136,9 @@ trx_rseg_mem_create( fil_addr_t node_addr; ulint sum_of_undo_sizes; - ut_ad(mutex_own(&kernel_mutex)); +#ifdef UNIV_SYNC_DEBUG + ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ rseg = mem_alloc(sizeof(trx_rseg_t)); @@ -173,8 +179,7 @@ trx_rseg_mem_create( + node_addr.boffset; rseg->last_trx_no = mtr_read_dulint( - undo_log_hdr + TRX_UNDO_TRX_NO, - MLOG_8BYTES, mtr); + undo_log_hdr + TRX_UNDO_TRX_NO, mtr); rseg->last_del_marks = mtr_read_ulint( undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr); diff --git a/innobase/trx/trx0sys.c b/innobase/trx/trx0sys.c index 3b5f024d39e..d4c14a5509c 100644 --- a/innobase/trx/trx0sys.c +++ b/innobase/trx/trx0sys.c @@ -56,7 +56,9 @@ trx_sys_mark_downgraded_from_4_1_1(void) mtr_start(&mtr); page = buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ doublewrite = page + TRX_SYS_DOUBLEWRITE; @@ -169,7 +171,9 @@ start_again: mtr_start(&mtr); page = buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ doublewrite = page + TRX_SYS_DOUBLEWRITE; @@ -228,7 +232,9 @@ start_again: /* fseg_create acquires a second latch on the page, therefore we must declare it: */ +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page2, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ if (page2 == NULL) { fprintf(stderr, @@ -271,7 +277,9 @@ start_again: new_page = buf_page_get(TRX_SYS_SPACE, page_no, RW_X_LATCH, &mtr); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(new_page, SYNC_NO_ORDER_CHECK); +#endif /* UNIV_SYNC_DEBUG */ /* Make a dummy change to the page to ensure it will be written to disk in a flush */ @@ -490,7 +498,9 @@ trx_in_trx_list( { trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ trx = UT_LIST_GET_FIRST(trx_sys->trx_list); @@ -517,14 +527,16 @@ trx_sys_flush_max_trx_id(void) trx_sysf_t* sys_header; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); sys_header = trx_sysf_get(&mtr); mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE, - trx_sys->max_trx_id, MLOG_8BYTES, &mtr); + trx_sys->max_trx_id, &mtr); mtr_commit(&mtr); } @@ -716,7 +728,9 @@ trx_sysf_rseg_find_free( ulint page_no; ulint i; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(kernel_mutex))); +#endif /* UNIV_SYNC_DEBUG */ sys_header = trx_sysf_get(mtr); @@ -762,13 +776,15 @@ trx_sysf_create( mtr); ut_a(buf_frame_get_page_no(page) == TRX_SYS_PAGE_NO); +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(page, SYNC_TRX_SYS_HEADER); +#endif /* UNIV_SYNC_DEBUG */ sys_header = trx_sysf_get(mtr); /* Start counting transaction ids from number 1 up */ mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE, - ut_dulint_create(0, 1), MLOG_8BYTES, mtr); + ut_dulint_create(0, 1), mtr); /* Reset the rollback segment slots */ for (i = 0; i < TRX_SYS_N_RSEGS; i++) { @@ -823,8 +839,7 @@ trx_sys_init_at_db_start(void) trx_sys->max_trx_id = ut_dulint_add( ut_dulint_align_up( mtr_read_dulint(sys_header - + TRX_SYS_TRX_ID_STORE, - MLOG_8BYTES, &mtr), + + TRX_SYS_TRX_ID_STORE, &mtr), TRX_SYS_TRX_ID_WRITE_MARGIN), 2 * TRX_SYS_TRX_ID_WRITE_MARGIN); diff --git a/innobase/trx/trx0trx.c b/innobase/trx/trx0trx.c index 78a7e277657..9b6e6904537 100644 --- a/innobase/trx/trx0trx.c +++ b/innobase/trx/trx0trx.c @@ -73,7 +73,9 @@ trx_create( { trx_t* trx; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ trx = mem_alloc(sizeof(trx_t)); @@ -239,7 +241,9 @@ trx_free( { char err_buf[1000]; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (trx->declared_to_be_inside_innodb) { ut_print_timestamp(stderr); @@ -345,7 +349,9 @@ trx_list_insert_ordered( { trx_t* trx2; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ trx2 = UT_LIST_GET_FIRST(trx_sys->trx_list); @@ -507,7 +513,9 @@ trx_assign_rseg(void) { trx_rseg_t* rseg = trx_sys->latest_rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ loop: /* Get next rseg in a round-robin fashion */ @@ -544,7 +552,9 @@ trx_start_low( { trx_rseg_t* rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(trx->rseg == NULL); if (trx->type == TRX_PURGE) { @@ -619,7 +629,9 @@ trx_commit_off_kernel( ibool must_flush_log = FALSE; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ rseg = trx->rseg; @@ -713,7 +725,9 @@ trx_commit_off_kernel( } ut_ad(trx->conc_state == TRX_ACTIVE); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ /* The following assignment makes the transaction committed in memory and makes its changes to data visible to other transactions. @@ -802,7 +816,7 @@ trx_commit_off_kernel( log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE); } else { - ut_a(0); + ut_error; } trx->commit_lsn = lsn; @@ -893,7 +907,9 @@ trx_handle_commit_sig_off_kernel( trx_sig_t* sig; trx_sig_t* next_sig; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ trx->que_state = TRX_QUE_COMMITTING; @@ -933,7 +949,9 @@ trx_end_lock_wait( { que_thr_t* thr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT); thr = UT_LIST_GET_FIRST(trx->wait_thrs); @@ -960,7 +978,9 @@ trx_lock_wait_to_suspended( { que_thr_t* thr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT); thr = UT_LIST_GET_FIRST(trx->wait_thrs); @@ -988,7 +1008,9 @@ trx_sig_reply_wait_to_suspended( trx_sig_t* sig; que_thr_t* thr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ sig = UT_LIST_GET_FIRST(trx->reply_signals); @@ -1021,7 +1043,9 @@ trx_sig_is_compatible( { trx_sig_t* sig; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (UT_LIST_GET_LEN(trx->signals) == 0) { @@ -1109,13 +1133,15 @@ trx_sig_send( trx_t* receiver_trx; ut_ad(trx); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (!trx_sig_is_compatible(trx, type, sender)) { /* The signal is not compatible with the other signals in the queue: do nothing */ - ut_a(0); + ut_error; return(FALSE); } @@ -1163,7 +1189,7 @@ trx_sig_send( signal to the end of the queue, if the session is not yet in the error state: */ - ut_a(0); + ut_error; } /* If there were no other signals ahead in the queue, try to start @@ -1188,7 +1214,9 @@ trx_end_signal_handling( /*====================*/ trx_t* trx) /* in: trx */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(trx->handling_signals == TRUE); trx->handling_signals = FALSE; @@ -1222,7 +1250,9 @@ loop: we can process immediately */ ut_ad(trx); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (trx->handling_signals && (UT_LIST_GET_LEN(trx->signals) == 0)) { @@ -1323,7 +1353,9 @@ trx_sig_reply( trx_t* receiver_trx; ut_ad(sig); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ if (sig->receiver != NULL) { ut_ad((sig->receiver)->state == QUE_THR_SIG_REPLY_WAIT); @@ -1351,7 +1383,9 @@ trx_sig_remove( trx_sig_t* sig) /* in, own: signal */ { ut_ad(trx && sig); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(sig->receiver == NULL); @@ -1500,7 +1534,7 @@ trx_commit_complete_for_mysql( log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE); } else { - ut_a(0); + ut_error; } trx->op_info = (char*)""; diff --git a/innobase/trx/trx0undo.c b/innobase/trx/trx0undo.c index 0b82a929878..de3da382e83 100644 --- a/innobase/trx/trx0undo.c +++ b/innobase/trx/trx0undo.c @@ -390,7 +390,9 @@ trx_undo_seg_create( ibool success; ut_ad(mtr && id && rseg_hdr); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ /* if (type == TRX_UNDO_INSERT) { printf("Creating insert undo log segment\n"); @@ -430,7 +432,9 @@ trx_undo_seg_create( return(NULL); } +#ifdef UNIV_SYNC_DEBUG buf_page_dbg_add_level(undo_page, SYNC_TRX_UNDO_PAGE); +#endif /* UNIV_SYNC_DEBUG */ page_hdr = undo_page + TRX_UNDO_PAGE_HDR; seg_hdr = undo_page + TRX_UNDO_SEG_HDR; @@ -735,13 +739,14 @@ trx_undo_add_page( ulint page_no; ibool success; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); ut_ad(!mutex_own(&kernel_mutex)); + ut_ad(mutex_own(&(trx->rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ rseg = trx->rseg; - ut_ad(mutex_own(&(rseg->mutex))); - if (rseg->curr_size == rseg->max_size) { return(FIL_NULL); @@ -811,8 +816,10 @@ trx_undo_free_page( UT_NOT_USED(hdr_offset); ut_a(hdr_page_no != page_no); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ undo_page = trx_undo_page_get(space, page_no, mtr); @@ -859,7 +866,9 @@ trx_undo_free_page_in_rollback( ulint last_page_no; ut_ad(undo->hdr_page_no != page_no); +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); +#endif /* UNIV_SYNC_DEBUG */ last_page_no = trx_undo_free_page(undo->rseg, FALSE, undo->space, undo->hdr_page_no, undo->hdr_offset, @@ -913,12 +922,13 @@ trx_undo_truncate_end( trx_rseg_t* rseg; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); + ut_ad(mutex_own(&(trx->rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ rseg = trx->rseg; - ut_ad(mutex_own(&(rseg->mutex))); - for (;;) { mtr_start(&mtr); @@ -992,7 +1002,9 @@ trx_undo_truncate_start( ulint page_no; mtr_t mtr; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (0 == ut_dulint_cmp(limit, ut_dulint_zero)) { @@ -1058,8 +1070,9 @@ trx_undo_seg_free( while (!finished) { mtr_start(&mtr); - +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(rseg->mutex)); seg_header = trx_undo_page_get(undo->space, undo->hdr_page_no, @@ -1115,7 +1128,7 @@ trx_undo_mem_create_at_db_start( if (id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", id); - ut_a(0); + ut_error; } undo_page = trx_undo_page_get(rseg->space, page_no, mtr); @@ -1132,8 +1145,7 @@ trx_undo_mem_create_at_db_start( undo_header = undo_page + offset; - trx_id = mtr_read_dulint(undo_header + TRX_UNDO_TRX_ID, MLOG_8BYTES, - mtr); + trx_id = mtr_read_dulint(undo_header + TRX_UNDO_TRX_ID, mtr); mutex_enter(&(rseg->mutex)); undo = trx_undo_mem_create(rseg, id, type, trx_id, page_no, offset); @@ -1143,8 +1155,7 @@ trx_undo_mem_create_at_db_start( undo->dict_operation = mtr_read_ulint( undo_header + TRX_UNDO_DICT_OPERATION, MLOG_2BYTES, mtr); - undo->table_id = mtr_read_dulint(undo_header + TRX_UNDO_TABLE_ID, - MLOG_8BYTES, mtr); + undo->table_id = mtr_read_dulint(undo_header + TRX_UNDO_TABLE_ID, mtr); undo->state = state; undo->size = flst_get_len(seg_header + TRX_UNDO_PAGE_LIST, mtr); @@ -1268,12 +1279,14 @@ trx_undo_mem_create( { trx_undo_t* undo; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", id); - ut_a(0); + ut_error; } undo = mem_alloc(sizeof(trx_undo_t)); @@ -1312,13 +1325,15 @@ trx_undo_mem_init_for_reuse( is created */ ulint offset) /* in: undo log header byte offset on page */ { +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&((undo->rseg)->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (undo->id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id); mem_analyze_corruption((byte*)undo); - ut_a(0); + ut_error; } undo->state = TRX_UNDO_ACTIVE; @@ -1342,7 +1357,7 @@ trx_undo_mem_free( if (undo->id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id); - ut_a(0); + ut_error; } mem_free(undo); @@ -1370,7 +1385,9 @@ trx_undo_create( trx_undo_t* undo; page_t* undo_page; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (rseg->curr_size == rseg->max_size) { @@ -1421,7 +1438,9 @@ trx_undo_reuse_cached( page_t* undo_page; ulint offset; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); +#endif /* UNIV_SYNC_DEBUG */ if (type == TRX_UNDO_INSERT) { @@ -1449,7 +1468,7 @@ trx_undo_reuse_cached( if (undo->id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id); mem_analyze_corruption((byte*)undo); - ut_a(0); + ut_error; } undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr); @@ -1490,7 +1509,7 @@ trx_undo_mark_as_dict_operation( trx->dict_operation, MLOG_2BYTES, mtr); mlog_write_dulint(hdr_page + undo->hdr_offset + TRX_UNDO_TABLE_ID, - trx->table_id, MLOG_8BYTES, mtr); + trx->table_id, mtr); undo->dict_operation = trx->dict_operation; undo->table_id = trx->table_id; @@ -1517,11 +1536,15 @@ trx_undo_assign_undo( rseg = trx->rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(trx->undo_mutex))); +#endif /* UNIV_SYNC_DEBUG */ mtr_start(&mtr); +#ifdef UNIV_SYNC_DEBUG ut_ad(!mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ mutex_enter(&(rseg->mutex)); undo = trx_undo_reuse_cached(rseg, type, trx->id, &mtr); @@ -1581,7 +1604,7 @@ trx_undo_set_state_at_finish( if (undo->id >= TRX_RSEG_N_SLOTS) { fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id); mem_analyze_corruption((byte*)undo); - ut_a(0); + ut_error; } undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr); @@ -1626,8 +1649,9 @@ trx_undo_update_cleanup( undo = trx->update_undo; rseg = trx->rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); - +#endif /* UNIV_SYNC_DEBUG */ trx_purge_add_update_undo_to_history(trx, undo_page, mtr); UT_LIST_REMOVE(undo_list, rseg->update_undo_list, undo); @@ -1666,8 +1690,10 @@ trx_undo_update_cleanup_by_discard( undo = trx->update_undo; rseg = trx->rseg; +#ifdef UNIV_SYNC_DEBUG ut_ad(mutex_own(&(rseg->mutex))); ut_ad(mutex_own(&kernel_mutex)); +#endif /* UNIV_SYNC_DEBUG */ ut_ad(undo->size == 1); ut_ad(undo->del_marks == FALSE); ut_ad(UT_LIST_GET_LEN(trx_sys->view_list) == 1); diff --git a/innobase/ut/ut0dbg.c b/innobase/ut/ut0dbg.c index d6593b70217..3697e31050f 100644 --- a/innobase/ut/ut0dbg.c +++ b/innobase/ut/ut0dbg.c @@ -18,3 +18,16 @@ ibool ut_dbg_stop_threads = FALSE; /* Null pointer used to generate memory trap */ ulint* ut_dbg_null_ptr = NULL; + +const char* ut_dbg_msg_assert_fail = +"InnoDB: Assertion failure in thread %lu in file %s line %lu\n"; +const char* ut_dbg_msg_trap = +"InnoDB: We intentionally generate a memory trap.\n" +"InnoDB: Send a detailed bug report to mysql@lists.mysql.com.\n" +"InnoDB: If you get repeated assertion failures or crashes, even\n" +"InnoDB: immediately after the mysqld startup, there may be\n" +"InnoDB: corruption in the InnoDB tablespace. See section 6.1 of\n" +"InnoDB: http://www.innodb.com/ibman.php about forcing recovery.\n"; + +const char* ut_dbg_msg_stop = +"InnoDB: Thread %lu stopped in file %s line %lu\n"; diff --git a/libmysql/libmysql.c b/libmysql/libmysql.c index f86435712dc..f2d77d495c9 100644 --- a/libmysql/libmysql.c +++ b/libmysql/libmysql.c @@ -2112,8 +2112,8 @@ static my_bool mysql_reconnect(MYSQL *mysql) { /* Allow reconnect next time */ mysql->server_status&= ~SERVER_STATUS_IN_TRANS; - mysql->net.last_errno=CR_SERVER_GONE_ERROR; - strmov(mysql->net.last_error,ER(mysql->net.last_errno)); + mysql->net.last_errno= CR_SERVER_GONE_ERROR; + strmov(mysql->net.last_error, ER(mysql->net.last_errno)); DBUG_RETURN(1); } mysql_init(&tmp_mysql); diff --git a/myisam/mi_check.c b/myisam/mi_check.c index 8581f79c99d..61c98eb526f 100644 --- a/myisam/mi_check.c +++ b/myisam/mi_check.c @@ -112,7 +112,9 @@ int chk_status(MI_CHECK *param, register MI_INFO *info) /* Don't count this as a real warning, as check can correct this ! */ uint save=param->warning_printed; mi_check_print_warning(param, - "%d clients is using or hasn't closed the table properly", + share->state.open_count==1 ? + "%d client is using or hasn't closed the table properly" : + "%d clients are using or haven't closed the table properly", share->state.open_count); /* If this will be fixed by the check, forget the warning */ if (param->testflag & T_UPDATE_STATE) diff --git a/mysql-test/install_test_db.sh b/mysql-test/install_test_db.sh index c87cf82088f..3b361b8afec 100644 --- a/mysql-test/install_test_db.sh +++ b/mysql-test/install_test_db.sh @@ -5,9 +5,16 @@ # This scripts creates the privilege tables db, host, user, tables_priv, # columns_priv in the mysql database, as well as the func table. -if [ x$1 = x"-bin" ]; then +if [ x$1 = x"--bin" ]; then shift 1 - execdir=../bin + +# Check if it's a binary distribution or a 'make install' +if test -x ../libexec/mysqld + then + execdir=../libexec + else + execdir=../bin +fi bindir=../bin BINARY_DIST=1 fix_bin=mysql-test diff --git a/mysql-test/mysql-test-run.sh b/mysql-test/mysql-test-run.sh index cbacedfedb4..a606a492058 100644 --- a/mysql-test/mysql-test-run.sh +++ b/mysql-test/mysql-test-run.sh @@ -487,7 +487,7 @@ else MYSQL_MANAGER_CLIENT="$BASEDIR/bin/mysqlmanagerc" MYSQL_MANAGER_PWGEN="$BASEDIR/bin/mysqlmanager-pwgen" MYSQL="$BASEDIR/bin/mysql" - INSTALL_DB="./install_test_db -bin" + INSTALL_DB="./install_test_db --bin" MYSQL_FIX_SYSTEM_TABLES="$BASEDIR/bin/mysql_fix_privilege_tables" if test -d "$BASEDIR/share/mysql/english" then diff --git a/mysql-test/r/create.result b/mysql-test/r/create.result index 627913939fb..22743782484 100644 --- a/mysql-test/r/create.result +++ b/mysql-test/r/create.result @@ -216,3 +216,9 @@ a b 0 2 3 4 drop table t1; +create table `t1 `(a int); +Incorrect table name 't1 ' +create database `db1 `; +Incorrect database name 'db1 ' +create table t1(`a ` int); +Incorrect column name 'a ' diff --git a/mysql-test/r/func_math.result b/mysql-test/r/func_math.result index 46ad7a14e25..04dabcb5481 100644 --- a/mysql-test/r/func_math.result +++ b/mysql-test/r/func_math.result @@ -59,3 +59,12 @@ ASIN(0.8+0.2) SELECT ASIN(1.2-0.2); ASIN(1.2-0.2) 1.570796 +select floor(log(4)/log(2)); +floor(log(4)/log(2)) +2 +select floor(log(8)/log(2)); +floor(log(8)/log(2)) +3 +select floor(log(16)/log(2)); +floor(log(16)/log(2)) +4 diff --git a/mysql-test/r/multi_update.result b/mysql-test/r/multi_update.result index 21035c8bc60..12cb965f045 100644 --- a/mysql-test/r/multi_update.result +++ b/mysql-test/r/multi_update.result @@ -386,3 +386,17 @@ SELECT * from t2; a 1 DROP TABLE t1,t2; +create table `t1` (`p_id` int(10) unsigned NOT NULL auto_increment, `p_code` varchar(20) NOT NULL default '', `p_active` tinyint(1) unsigned NOT NULL default '1', PRIMARY KEY (`p_id`) ); +create table `t2` (`c2_id` int(10) unsigned NULL auto_increment, `c2_p_id` int(10) unsigned NOT NULL default '0', `c2_note` text NOT NULL, `c2_active` tinyint(1) unsigned NOT NULL default '1', PRIMARY KEY (`c2_id`), KEY `c2_p_id` (`c2_p_id`) ); +insert into t1 values (0,'A01-Comp',1); +insert into t1 values (0,'B01-Comp',1); +insert into t2 values (0,1,'A Note',1); +update t1 left join t2 on p_id = c2_p_id set c2_note = 'asdf-1' where p_id = 2; +select * from t1; +p_id p_code p_active +1 A01-Comp 1 +2 B01-Comp 1 +select * from t2; +c2_id c2_p_id c2_note c2_active +1 1 A Note 1 +drop table t1, t2; diff --git a/mysql-test/r/mysqlbinlog.result b/mysql-test/r/mysqlbinlog.result index df472eb9c80..79bf46280dd 100644 --- a/mysql-test/r/mysqlbinlog.result +++ b/mysql-test/r/mysqlbinlog.result @@ -14,6 +14,7 @@ insert into t1 values ("Alas"); flush logs; --- Local -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; create table t1 (word varchar(20)); @@ -31,19 +32,23 @@ LOAD DATA LOCAL INFILE 'MYSQL_TEST_DIR/var/tmp/words.dat-4-0' INTO TABLE `t1` FI LOAD DATA LOCAL INFILE 'MYSQL_TEST_DIR/var/tmp/words.dat-5-0' INTO TABLE `t1` FIELDS TERMINATED BY '\t' ENCLOSED BY '' ESCAPED BY '\\' LINES TERMINATED BY '\n' STARTING BY '' (word); --- Broken LOAD DATA -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; insert into t1 values ("Alas"); --- --database -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; SET INSERT_ID=1; --- --position -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; insert into t1 values ("Alas"); --- Remote -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; create table t1 (word varchar(20)); @@ -64,14 +69,17 @@ SET TIMESTAMP=1000000000; insert into t1 values ("Alas"); --- Broken LOAD DATA -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; insert into t1 values ("Alas"); --- --database -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; SET INSERT_ID=1; --- --position -- +/*!40019 SET @@session.max_insert_delayed_threads=0*/; use test; SET TIMESTAMP=1000000000; insert into t1 values ("Alas"); diff --git a/mysql-test/t/create.test b/mysql-test/t/create.test index 8aee586268f..94c2f24dffc 100644 --- a/mysql-test/t/create.test +++ b/mysql-test/t/create.test @@ -179,3 +179,15 @@ create table if not exists t1 select 3 as 'a',4 as 'b'; create table if not exists t1 select 3 as 'a',3 as 'b'; select * from t1; drop table t1; + +# +# Test for Bug #2985 +# "Table truncated when creating another table name with Spaces" +# + +--error 1103 +create table `t1 `(a int); +--error 1102 +create database `db1 `; +--error 1166; +create table t1(`a ` int); diff --git a/mysql-test/t/func_math.test b/mysql-test/t/func_math.test index 2de692d4389..7057b0ca412 100644 --- a/mysql-test/t/func_math.test +++ b/mysql-test/t/func_math.test @@ -28,3 +28,11 @@ SELECT ACOS(0.2*5.0); SELECT ACOS(0.5*2.0); SELECT ASIN(0.8+0.2); SELECT ASIN(1.2-0.2); + +# +# Bug #3051 FLOOR returns invalid +# + +select floor(log(4)/log(2)); +select floor(log(8)/log(2)); +select floor(log(16)/log(2)); diff --git a/mysql-test/t/multi_update.test b/mysql-test/t/multi_update.test index 283637912a1..39ea136bde1 100644 --- a/mysql-test/t/multi_update.test +++ b/mysql-test/t/multi_update.test @@ -325,3 +325,17 @@ DELETE t2 FROM t1 AS t2, t2 AS t1 where t1.a=t2.a and t1.a=2; SELECT * from t1; SELECT * from t2; DROP TABLE t1,t2; + +# +# Test update with const tables +# + +create table `t1` (`p_id` int(10) unsigned NOT NULL auto_increment, `p_code` varchar(20) NOT NULL default '', `p_active` tinyint(1) unsigned NOT NULL default '1', PRIMARY KEY (`p_id`) ); +create table `t2` (`c2_id` int(10) unsigned NULL auto_increment, `c2_p_id` int(10) unsigned NOT NULL default '0', `c2_note` text NOT NULL, `c2_active` tinyint(1) unsigned NOT NULL default '1', PRIMARY KEY (`c2_id`), KEY `c2_p_id` (`c2_p_id`) ); +insert into t1 values (0,'A01-Comp',1); +insert into t1 values (0,'B01-Comp',1); +insert into t2 values (0,1,'A Note',1); +update t1 left join t2 on p_id = c2_p_id set c2_note = 'asdf-1' where p_id = 2; +select * from t1; +select * from t2; +drop table t1, t2; diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc index 15eb7fc72c6..35e731f20da 100644 --- a/sql/ha_berkeley.cc +++ b/sql/ha_berkeley.cc @@ -1334,7 +1334,7 @@ int ha_berkeley::index_init(uint keynr) int ha_berkeley::index_end() { int error=0; - DBUG_ENTER("index_end"); + DBUG_ENTER("ha_berkely::index_end"); if (cursor) { DBUG_PRINT("enter",("table: '%s'", table->real_name)); diff --git a/sql/item_func.cc b/sql/item_func.cc index ab96915e746..9d1f784fc25 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -667,7 +667,8 @@ longlong Item_func_ceiling::val_int() longlong Item_func_floor::val_int() { - double value=args[0]->val(); + // the volatile's for BUG #3051 to calm optimizer down (because of gcc's bug) + volatile double value=args[0]->val(); null_value=args[0]->null_value; return (longlong) floor(value); } diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 3267b42effc..c21a2f6f31d 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -376,7 +376,7 @@ bool check_stack_overrun(THD *thd,char *dummy); #endif bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables); -void table_cache_init(void); +bool table_cache_init(void); void table_cache_free(void); uint cached_tables(void); void kill_mysql(void); diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 38faf95fd0e..671a78f6bfd 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -2225,8 +2225,10 @@ You should consider changing lower_case_table_names to 1 or 2", mysql_data_home[0]=FN_CURLIB; // all paths are relative from here mysql_data_home[1]=0; server_init(); - table_cache_init(); - hostname_cache_init(); + if (table_cache_init() || hostname_cache_init()) + { + unireg_abort(1); + } query_cache_result_size_limit(query_cache_limit); query_cache_resize(query_cache_size); randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2); @@ -3749,11 +3751,11 @@ replicating a LOAD DATA INFILE command", 0, 0, 0, 0}, {"log-warnings", 'W', "Log some not critical warnings to the log file", (gptr*) &global_system_variables.log_warnings, - (gptr*) &max_system_variables.log_warnings, 0, GET_BOOL, NO_ARG, 0, 0, 0, + (gptr*) &max_system_variables.log_warnings, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0}, {"warnings", 'W', "Deprecated ; Use --log-warnings instead", (gptr*) &global_system_variables.log_warnings, - (gptr*) &max_system_variables.log_warnings, 0, GET_BOOL, NO_ARG, 0, 0, 0, + (gptr*) &max_system_variables.log_warnings, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0}, { "back_log", OPT_BACK_LOG, "The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.", @@ -4100,8 +4102,8 @@ this value; if zero (the default): when the size exceeds max_binlog_size. \ 1, 0}, {"table_cache", OPT_TABLE_CACHE, "The number of open tables for all threads.", (gptr*) &table_cache_size, - (gptr*) &table_cache_size, 0, GET_ULONG, REQUIRED_ARG, 64, 1, ~0L, 0, 1, - 0}, + (gptr*) &table_cache_size, 0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L, + 0, 1, 0}, {"thread_concurrency", OPT_THREAD_CONCURRENCY, "Permits the application to give the threads system a hint for the desired number of threads that should be run at the same time.", (gptr*) &concurrency, (gptr*) &concurrency, 0, GET_ULONG, REQUIRED_ARG, diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 9da1f4e2231..dac8da12065 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -47,11 +47,11 @@ extern "C" byte *table_cache_key(const byte *record,uint *length, return (byte*) entry->table_cache_key; } -void table_cache_init(void) +bool table_cache_init(void) { - VOID(hash_init(&open_cache,table_cache_size+16,0,0,table_cache_key, - (hash_free_key) free_cache_entry,0)); mysql_rm_tmp_tables(); + return hash_init(&open_cache,table_cache_size+16,0,0,table_cache_key, + (hash_free_key) free_cache_entry,0) != 0; } diff --git a/sql/sql_db.cc b/sql/sql_db.cc index a88cff0cd9b..1217a909071 100644 --- a/sql/sql_db.cc +++ b/sql/sql_db.cc @@ -381,13 +381,13 @@ bool mysql_change_db(THD *thd,const char *name) ulong db_access; DBUG_ENTER("mysql_change_db"); - if (!dbname || !(db_length=strip_sp(dbname))) + if (!dbname || !(db_length= strlen(dbname))) { x_free(dbname); /* purecov: inspected */ send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: inspected */ DBUG_RETURN(1); /* purecov: inspected */ } - if ((db_length > NAME_LEN) || check_db_name(dbname)) + if (check_db_name(dbname)) { net_printf(&thd->net,ER_WRONG_DB_NAME, dbname); x_free(dbname); diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 5b1487aa313..aeec3808591 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -65,7 +65,7 @@ static bool create_total_list(THD *thd, LEX *lex, TABLE_LIST **result, bool skip_first); static bool check_one_table_access(THD *thd, ulong want_access, TABLE_LIST *table, bool no_errors); -static inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables); + const char *any_db="*any*"; // Special symbol for check_access @@ -108,6 +108,7 @@ static void unlock_locked_tables(THD *thd) } } + static bool end_active_trans(THD *thd) { int error=0; @@ -123,6 +124,14 @@ static bool end_active_trans(THD *thd) } +inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables) +{ + return (table_rules_on && tables && !tables_ok(thd,tables) && + ((thd->lex.sql_command != SQLCOM_DELETE_MULTI) || + !tables_ok(thd,(TABLE_LIST *)thd->lex.auxilliary_table_list.first))); +} + + static HASH hash_user_connections; extern pthread_mutex_t LOCK_user_conn; @@ -1124,8 +1133,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd, statistic_increment(com_stat[SQLCOM_CREATE_DB],&LOCK_status); // null test to handle EOM - if (!db || !strip_sp(db) || !(alias= thd->strdup(db)) || - check_db_name(db)) + if (!db || !(alias= thd->strdup(db)) || check_db_name(db)) { net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL"); break; @@ -1141,8 +1149,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd, statistic_increment(com_stat[SQLCOM_DROP_DB],&LOCK_status); char *db=thd->strdup(packet), *alias; // null test to handle EOM - if (!db || !strip_sp(db) || !(alias= thd->strdup(db)) || - check_db_name(db)) + if (!db || !(alias= thd->strdup(db)) || check_db_name(db)) { net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL"); break; @@ -2323,8 +2330,7 @@ mysql_execute_command(void) case SQLCOM_CREATE_DB: { char *alias; - if (!strip_sp(lex->name) || !(alias=thd->strdup(lex->name)) || - check_db_name(lex->name)) + if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name)) { net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name); break; @@ -2353,8 +2359,7 @@ mysql_execute_command(void) case SQLCOM_DROP_DB: { char *alias; - if (!strip_sp(lex->name) || !(alias=thd->strdup(lex->name)) || - check_db_name(lex->name)) + if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name)) { net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name); break; @@ -2967,12 +2972,6 @@ void mysql_init_multi_delete(LEX *lex) lex->select->table_list.save_and_clear(&lex->auxilliary_table_list); } -static inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables) -{ - return (table_rules_on && tables && !tables_ok(thd,tables) && - ((thd->lex.sql_command != SQLCOM_DELETE_MULTI) || - !tables_ok(thd,(TABLE_LIST *)thd->lex.auxilliary_table_list.first))); -} /* When you modify mysql_parse(), you may need to mofify diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 3ffa4e6a92c..87812414881 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -4897,8 +4897,8 @@ join_read_const_table(JOIN_TAB *tab, POSITION *pos) if (tab->on_expr && !table->null_row) { if ((table->null_row= test(tab->on_expr->val_int() == 0))) - empty_record(table); - } + mark_as_null_row(table); + } if (!table->null_row) table->maybe_null=0; DBUG_RETURN(0); diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 0a8530aa141..02d2fe2c442 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -866,14 +866,16 @@ int multi_update::do_updates(bool from_send_error) DBUG_RETURN(0); for (cur_table= update_tables; cur_table ; cur_table= cur_table->next) { + byte *ref_pos; + TABLE *tmp_table; + table = cur_table->table; if (table == table_to_update) continue; // Already updated - org_updated= updated; - byte *ref_pos; - TABLE *tmp_table= tmp_tables[cur_table->shared]; + tmp_table= tmp_tables[cur_table->shared]; tmp_table->file->extra(HA_EXTRA_CACHE); // Change to read cache + (void) table->file->rnd_init(0); table->file->extra(HA_EXTRA_NO_CACHE); /* @@ -940,6 +942,7 @@ int multi_update::do_updates(bool from_send_error) else trans_safe= 0; // Can't do safe rollback } + (void) table->file->rnd_end(); } DBUG_RETURN(0); diff --git a/sql/table.cc b/sql/table.cc index bc9d046f617..01a09426634 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -1140,7 +1140,8 @@ char *get_field(MEM_ROOT *mem, TABLE *table, uint fieldnr) bool check_db_name(char *name) { - char *start=name; + char *start=name; + bool last_char_is_space= FALSE; if (lower_case_table_names) casedn_str(name); @@ -1148,6 +1149,7 @@ bool check_db_name(char *name) while (*name) { #if defined(USE_MB) && defined(USE_MB_IDENT) + last_char_is_space= my_isspace(default_charset_info, *name); if (use_mb(default_charset_info)) { int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN); @@ -1157,19 +1159,22 @@ bool check_db_name(char *name) continue; } } +#else + last_char_is_space= *name==' '; #endif if (*name == '/' || *name == '\\' || *name == FN_LIBCHAR || *name == FN_EXTCHAR) return 1; name++; } - return (uint) (name - start) > NAME_LEN; + return last_char_is_space || (uint) (name - start) > NAME_LEN; } /* Allow anything as a table name, as long as it doesn't contain an a '/', or a '.' character + or ' ' at the end returns 1 on error */ @@ -1179,10 +1184,17 @@ bool check_table_name(const char *name, uint length) const char *end= name+length; if (!length || length > NAME_LEN) return 1; +#if defined(USE_MB) && defined(USE_MB_IDENT) + bool last_char_is_space= FALSE; +#else + if (name[length-1]==' ') + return 1; +#endif while (name != end) { #if defined(USE_MB) && defined(USE_MB_IDENT) + last_char_is_space= my_isspace(default_charset_info, *name); if (use_mb(default_charset_info)) { int len=my_ismbchar(default_charset_info, name, end); @@ -1197,16 +1209,23 @@ bool check_table_name(const char *name, uint length) return 1; name++; } +#if defined(USE_MB) && defined(USE_MB_IDENT) + return last_char_is_space; +#else return 0; +#endif } + bool check_column_name(const char *name) { const char *start= name; - + bool last_char_is_space= FALSE; + while (*name) { #if defined(USE_MB) && defined(USE_MB_IDENT) + last_char_is_space= my_isspace(default_charset_info, *name); if (use_mb(default_charset_info)) { int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN); @@ -1216,13 +1235,15 @@ bool check_column_name(const char *name) continue; } } +#else + last_char_is_space= *name==' '; #endif if (*name == NAMES_SEP_CHAR) return 1; name++; } /* Error if empty or too long column name */ - return (name == start || (uint) (name - start) > NAME_LEN); + return last_char_is_space || (name == start || (uint) (name - start) > NAME_LEN); } /* |