Applied InnoDB 5.1 snapshot ss787.

Bugs fixed:
- Bug #20791    valgrind errors in InnoDB
  Remove Valgrind warning of Bug #20791 : in new database
  creation, we read the doublewrite buffer magic number from
  uninitialized memory; the code worked because it was extremely
  unlikely that the memory would contain the magic number
- Bug #21784    DROP TABLE crashes 5.1.12-pre if concurrent
  queries on the table
  remove update_thd() in ::store_lock()


Also includes numerous coding style fixes, etc.  See file-level
comments for details.

sql/ha_innodb.cc

@@ -6787,19 +6787,17 @@ ha_innobase::store_lock(
 	row_prebuilt_t* prebuilt	= (row_prebuilt_t*) innobase_prebuilt;
 	trx_t*		trx;
 
-	/* Call update_thd() to update prebuilt->trx to point to the trx
-	object of thd! Failure to do this caused a serious memory
-	corruption bug in 5.1.11. */
+	/* Note that trx in this function is NOT necessarily prebuilt->trx
+	because we call update_thd() later, in ::external_lock()! Failure to
+	understand this caused a serious memory corruption bug in 5.1.11. */
 
-	update_thd(thd);
-
-	trx = prebuilt->trx;
+	trx = check_trx_exists(thd);
 
-	/* NOTE: MySQL	can call this function with lock 'type' TL_IGNORE!
+	/* NOTE: MySQL can call this function with lock 'type' TL_IGNORE!
 	Be careful to ignore TL_IGNORE if we are going to do something with
 	only 'real' locks! */
 
-	/* If no MySQL tables is use we need to set isolation level
+	/* If no MySQL table is in use, we need to set the isolation level
 	of the transaction. */
 
 	if (lock_type != TL_IGNORE
@@ -6809,7 +6807,13 @@ ha_innobase::store_lock(
 						thd->variables.tx_isolation);
 	}
 
-	if ((lock_type == TL_READ && thd->in_lock_tables) ||
+	if (thd->lex->sql_command == SQLCOM_DROP_TABLE) {
+
+		/* MySQL calls this function in DROP TABLE though this table
+		handle may belong to another thd that is running a query. Let
+		us in that case skip any changes to the prebuilt struct. */ 
+
+	} else if ((lock_type == TL_READ && thd->in_lock_tables) ||
 		(lock_type == TL_READ_HIGH_PRIORITY && thd->in_lock_tables) ||
 		lock_type == TL_READ_WITH_SHARED_LOCKS ||
 		lock_type == TL_READ_NO_INSERT ||
@@ -7400,7 +7404,9 @@ innobase_xa_prepare(
 	int error = 0;
 	trx_t* trx = check_trx_exists(thd);
 
-	if (thd->lex->sql_command != SQLCOM_XA_PREPARE) {
+	if (thd->lex->sql_command != SQLCOM_XA_PREPARE &&
+	    (all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))))
+	{
 
 		/* For ibbackup to work the order of transactions in binlog
 		and InnoDB must be the same. Consider the situation
@@ -7625,6 +7631,19 @@ SHOW_VAR innodb_status_variables_export[]= {
   {NullS, NullS, SHOW_LONG}
 };
 
+static int show_innodb_vars(THD *thd, SHOW_VAR *var, char *buff)
+{
+  innodb_export_status();
+  var->type= SHOW_ARRAY;
+  var->value= (char *) &innodb_status_variables;
+  return 0;
+}
+
+SHOW_VAR innodb_status_variables_export[]= {
+  {"Innodb",                   (char*) &show_innodb_vars, SHOW_FUNC},
+  {NullS, NullS, SHOW_LONG}
+};
+
 struct st_mysql_storage_engine innobase_storage_engine=
 { MYSQL_HANDLERTON_INTERFACE_VERSION, &innobase_hton};
 

storage/innobase/Makefile.am

@@ -87,7 +87,8 @@ EXTRA_DIST = 	include/btr0btr.h include/btr0btr.ic include/btr0cur.h include/btr
 		include/ut0byte.h include/ut0byte.ic include/ut0dbg.h include/ut0lst.h \
 		include/ut0mem.h include/ut0mem.ic include/ut0rnd.h include/ut0rnd.ic \
 		include/ut0sort.h include/ut0ut.h include/ut0ut.ic include/ut0vec.h include/ut0vec.ic include/ha_prototypes.h \
-		include/ut0list.h include/ut0list.ic include/ut0wqueue.h \
+		include/ut0list.h include/ut0list.ic \
+		include/ut0wqueue.h \
 		CMakeLists.txt
 
 noinst_LIBRARIES =	libinnobase.a

storage/innobase/btr/btr0pcur.c

@@ -92,9 +92,9 @@ btr_pcur_store_position(
 	offs = ut_align_offset(rec, UNIV_PAGE_SIZE);
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-			MTR_MEMO_PAGE_S_FIX)
-		|| mtr_memo_contains(mtr, buf_block_align(page),
-			MTR_MEMO_PAGE_X_FIX));
+				MTR_MEMO_PAGE_S_FIX)
+	      || mtr_memo_contains(mtr, buf_block_align(page),
+				   MTR_MEMO_PAGE_X_FIX));
 	ut_a(cursor->latch_mode != BTR_NO_LATCHES);
 
 	if (UNIV_UNLIKELY(page_get_n_recs(page) == 0)) {
@@ -133,14 +133,13 @@ btr_pcur_store_position(
 	}
 
 	cursor->old_stored = BTR_PCUR_OLD_STORED;
-	cursor->old_rec = dict_tree_copy_rec_order_prefix(tree, rec,
-						&cursor->old_n_fields,
-						&cursor->old_rec_buf,
-						&cursor->buf_size);
+	cursor->old_rec = dict_tree_copy_rec_order_prefix
+		(tree, rec, &cursor->old_n_fields,
+		 &cursor->old_rec_buf, &cursor->buf_size);
 
 	cursor->block_when_stored = buf_block_align(page);
-	cursor->modify_clock = buf_block_get_modify_clock(
-				cursor->block_when_stored);
+	cursor->modify_clock = buf_block_get_modify_clock
+		(cursor->block_when_stored);
 }
 
 /******************************************************************
@@ -165,7 +164,7 @@ btr_pcur_copy_stored_position(
 		pcur_receive->old_rec_buf = mem_alloc(pcur_donate->buf_size);
 
 		ut_memcpy(pcur_receive->old_rec_buf, pcur_donate->old_rec_buf,
-						pcur_donate->buf_size);
+			  pcur_donate->buf_size);
 		pcur_receive->old_rec = pcur_receive->old_rec_buf
 			+ (pcur_donate->old_rec - pcur_donate->old_rec_buf);
 	}
@@ -206,8 +205,8 @@ btr_pcur_restore_position(
 	mem_heap_t*	heap;
 
 	if (UNIV_UNLIKELY(cursor->old_stored != BTR_PCUR_OLD_STORED)
-		|| UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
-			&& cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
+	    || UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
+			     && cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
 		ut_print_buf(stderr, cursor, sizeof(btr_pcur_t));
 		if (cursor->trx_if_known) {
 			trx_print(stderr, cursor->trx_if_known, 0);
@@ -216,19 +215,20 @@ btr_pcur_restore_position(
 		ut_error;
 	}
 
-	if (UNIV_UNLIKELY(cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
-			|| cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
+	if (UNIV_UNLIKELY
+	    (cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
+	     || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
 
 		/* In these cases we do not try an optimistic restoration,
 		but always do a search */
 
-		btr_cur_open_at_index_side(
-			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
-			btr_pcur_get_btr_cur(cursor)->index, latch_mode,
-					btr_pcur_get_btr_cur(cursor), mtr);
+		btr_cur_open_at_index_side
+			(cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
+			 btr_pcur_get_btr_cur(cursor)->index, latch_mode,
+			 btr_pcur_get_btr_cur(cursor), mtr);
 
-		cursor->block_when_stored =
-				buf_block_align(btr_pcur_get_page(cursor));
+		cursor->block_when_stored
+			= buf_block_align(btr_pcur_get_page(cursor));
 
 		return(FALSE);
 	}
@@ -239,12 +239,13 @@ btr_pcur_restore_position(
 	page = btr_cur_get_page(btr_pcur_get_btr_cur(cursor));
 
 	if (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
-			|| UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
+	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
 		/* Try optimistic restoration */
 
-		if (UNIV_LIKELY(buf_page_optimistic_get(latch_mode,
-					cursor->block_when_stored, page,
-					cursor->modify_clock, mtr))) {
+		if (UNIV_LIKELY
+		    (buf_page_optimistic_get(latch_mode,
+					     cursor->block_when_stored, 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);
@@ -262,14 +263,16 @@ btr_pcur_restore_position(
 				index = btr_pcur_get_btr_cur(cursor)->index;
 
 				heap = mem_heap_create(256);
-				offsets1 = rec_get_offsets(cursor->old_rec,
-						index, NULL,
-						cursor->old_n_fields, &heap);
-				offsets2 = rec_get_offsets(rec, index, NULL,
-						cursor->old_n_fields, &heap);
-
-				ut_ad(cmp_rec_rec(cursor->old_rec,
-					rec, offsets1, offsets2, index) == 0);
+				offsets1 = rec_get_offsets
+					(cursor->old_rec, index, NULL,
+					 cursor->old_n_fields, &heap);
+				offsets2 = rec_get_offsets
+					(rec, index, NULL,
+					 cursor->old_n_fields, &heap);
+
+				ut_ad(!cmp_rec_rec(cursor->old_rec,
+						   rec, offsets1, offsets2,
+						   index));
 				mem_heap_free(heap);
 #endif /* UNIV_DEBUG */
 				return(TRUE);
@@ -285,7 +288,7 @@ btr_pcur_restore_position(
 
 	tree = btr_cur_get_tree(btr_pcur_get_btr_cur(cursor));
 	tuple = dict_tree_build_data_tuple(tree, cursor->old_rec,
-					cursor->old_n_fields, heap);
+					   cursor->old_n_fields, heap);
 
 	/* Save the old search mode of the cursor */
 	old_mode = cursor->search_mode;
@@ -300,26 +303,27 @@ btr_pcur_restore_position(
 	}
 
 	btr_pcur_open_with_no_init(btr_pcur_get_btr_cur(cursor)->index, tuple,
-					mode, latch_mode, cursor, 0, mtr);
+				   mode, latch_mode, cursor, 0, mtr);
 
 	/* Restore the old search mode */
 	cursor->search_mode = old_mode;
 
 	if (cursor->rel_pos == BTR_PCUR_ON
-		&& btr_pcur_is_on_user_rec(cursor, mtr)
-		&& 0 == cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
-			rec_get_offsets(btr_pcur_get_rec(cursor),
-				btr_pcur_get_btr_cur(cursor)->index,
-				NULL, ULINT_UNDEFINED, &heap))) {
+	    && btr_pcur_is_on_user_rec(cursor, mtr)
+	    && 0 == cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
+				   rec_get_offsets
+				   (btr_pcur_get_rec(cursor),
+				    btr_pcur_get_btr_cur(cursor)->index,
+				    NULL, ULINT_UNDEFINED, &heap))) {
 
 		/* We have to store the NEW value for the modify clock, since
 		the cursor can now be on a different page! But we can retain
 		the value of old_rec */
 
-		cursor->block_when_stored =
-			buf_block_align(btr_pcur_get_page(cursor));
-		cursor->modify_clock =
-			buf_block_get_modify_clock(cursor->block_when_stored);
+		cursor->block_when_stored = buf_block_align
+			(btr_pcur_get_page(cursor));
+		cursor->modify_clock = buf_block_get_modify_clock
+			(cursor->block_when_stored);
 		cursor->old_stored = BTR_PCUR_OLD_STORED;
 
 		mem_heap_free(heap);
@@ -467,14 +471,14 @@ btr_pcur_move_backward_from_page(
 	space = buf_frame_get_space_id(page);
 
 	if (btr_pcur_is_before_first_on_page(cursor, mtr)
-					&& (prev_page_no != FIL_NULL)) {
+	    && (prev_page_no != FIL_NULL)) {
 
 		prev_page = btr_pcur_get_btr_cur(cursor)->left_page;
 
 		btr_leaf_page_release(page, latch_mode, mtr);
 
 		page_cur_set_after_last(prev_page,
-						btr_pcur_get_page_cur(cursor));
+					btr_pcur_get_page_cur(cursor));
 	} else if (prev_page_no != FIL_NULL) {
 
 		/* The repositioned cursor did not end on an infimum record on

storage/innobase/data/data0type.c

@@ -67,9 +67,9 @@ dtype_get_at_most_n_mbchars(
 
 	if (dtype->mbminlen != dtype->mbmaxlen) {
 		ut_a(!(prefix_len % dtype->mbmaxlen));
-		return(innobase_get_at_most_n_mbchars(
-				dtype_get_charset_coll(dtype->prtype),
-				prefix_len, data_len, str));
+		return(innobase_get_at_most_n_mbchars
+		       (dtype_get_charset_coll(dtype->prtype),
+			prefix_len, data_len, str));
 	}
 
 	if (prefix_len < data_len) {
@@ -98,8 +98,8 @@ dtype_is_string_type(
 	ulint	mtype)	/* in: InnoDB main data type code: DATA_CHAR, ... */
 {
 	if (mtype <= DATA_BLOB
-		|| mtype == DATA_MYSQL
-		|| mtype == DATA_VARMYSQL) {
+	    || mtype == DATA_MYSQL
+	    || mtype == DATA_VARMYSQL) {
 
 		return(TRUE);
 	}
@@ -120,8 +120,8 @@ dtype_is_binary_string_type(
 	ulint	prtype)	/* in: precise type */
 {
 	if ((mtype == DATA_FIXBINARY)
-		|| (mtype == DATA_BINARY)
-		|| (mtype == DATA_BLOB && (prtype & DATA_BINARY_TYPE))) {
+	    || (mtype == DATA_BINARY)
+	    || (mtype == DATA_BLOB && (prtype & DATA_BINARY_TYPE))) {
 
 		return(TRUE);
 	}
@@ -143,7 +143,7 @@ dtype_is_non_binary_string_type(
 	ulint	prtype)	/* in: precise type */
 {
 	if (dtype_is_string_type(mtype) == TRUE
-		&& dtype_is_binary_string_type(mtype, prtype) == FALSE) {
+	    && dtype_is_binary_string_type(mtype, prtype) == FALSE) {
 
 		return(TRUE);
 	}
@@ -258,9 +258,9 @@ dtype_print(
 	len = type->len;
 
 	if ((type->mtype == DATA_SYS)
-	   || (type->mtype == DATA_VARCHAR)
-	   || (type->mtype == DATA_CHAR)) {
-	  putc(' ', stderr);
+	    || (type->mtype == DATA_VARCHAR)
+	    || (type->mtype == DATA_CHAR)) {
+		putc(' ', stderr);
 		if (prtype == DATA_ROW_ID) {
 			fputs("DATA_ROW_ID", stderr);
 			len = DATA_ROW_ID_LEN;
@@ -317,9 +317,9 @@ dtype_get_max_size(
 	case DATA_BINARY:
 	case DATA_DECIMAL:
 	case DATA_VARMYSQL:
-			return(type->len);
+		return(type->len);
 	case DATA_BLOB:
-			return(ULINT_MAX);
+		return(ULINT_MAX);
 	default:
 		ut_error;
 	}

storage/innobase/dict/dict0mem.c

@@ -65,7 +65,7 @@ dict_mem_table_create(
 	table->cached = FALSE;
 
 	table->cols = mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
-							* sizeof(dict_col_t));
+				     * sizeof(dict_col_t));
 	UT_LIST_INIT(table->indexes);
 
 	table->auto_inc_lock = mem_heap_alloc(heap, lock_get_size());
@@ -177,9 +177,9 @@ dict_mem_index_create(
 	index->n_def = index->n_nullable = 0;
 	index->n_fields = n_fields;
 	index->fields = mem_heap_alloc(heap, 1 + n_fields
-						* sizeof(dict_field_t));
-					/* The '1 +' above prevents allocation
-					of an empty mem block */
+				       * sizeof(dict_field_t));
+	/* The '1 +' above prevents allocation
+	of an empty mem block */
 	index->stat_n_diff_key_vals = NULL;
 
 	index->cached = FALSE;

storage/innobase/eval/eval0proc.c

@@ -51,7 +51,8 @@ if_step(
 			for (;;) {
 				eval_exp(elsif_node->cond);
 
-				if (eval_node_get_ibool_val(elsif_node->cond)) {
+				if (eval_node_get_ibool_val
+				    (elsif_node->cond)) {
 
 					/* The condition evaluated to TRUE:
 					start execution from the first
@@ -104,7 +105,7 @@ while_step(
 	ut_ad(que_node_get_type(node) == QUE_NODE_WHILE);
 
 	ut_ad((thr->prev_node == que_node_get_parent(node))
-			|| (que_node_get_next(thr->prev_node) == NULL));
+	      || (que_node_get_next(thr->prev_node) == NULL));
 
 	/* Evaluate the condition */
 
@@ -192,8 +193,8 @@ for_step(
 
 		loop_var_value = eval_node_get_int_val(node->loop_start_limit);
 
-		node->loop_end_value = eval_node_get_int_val(
-							node->loop_end_limit);
+		node->loop_end_value
+			= eval_node_get_int_val(node->loop_end_limit);
 	}
 
 	/* Check if we should do another loop */

storage/innobase/include/btr0cur.h

@@ -583,9 +583,11 @@ to know struct size! */
 struct btr_cur_struct {
 	dict_index_t*	index;		/* index where positioned */
 	page_cur_t	page_cur;	/* page cursor */
-	page_t*		left_page;	/* this field is used to store a pointer
-					to the left neighbor page, in the cases
-					BTR_SEARCH_PREV and BTR_MODIFY_PREV */
+	page_t*		left_page;	/* this field is used to store
+					a pointer to the left neighbor
+					page, in the cases
+					BTR_SEARCH_PREV and
+					BTR_MODIFY_PREV */
 	/*------------------------------*/
 	que_thr_t*	thr;		/* this field is only used when
 					btr_cur_search_... is called for an