WL#6769 - Resync with mysql-trunk

Author: Sunny Bains

storage/innobase/CMakeLists.txt

@@ -41,7 +41,6 @@ SET(INNOBASE_SOURCES
 	dict/dict0mem.cc
 	dict/dict0stats.cc
 	dict/dict0stats_bg.cc
-	dyn/dyn0dyn.cc
 	eval/eval0eval.cc
 	eval/eval0proc.cc
 	fil/fil0fil.cc

storage/innobase/btr/btr0btr.cc

@@ -789,7 +789,7 @@ btr_height_get(
         height = btr_page_get_level(buf_block_get_frame(root_block), mtr);
 
         /* Release the S latch on the root page. */
-        mtr_memo_release(mtr, root_block, MTR_MEMO_PAGE_S_FIX);
+        mtr->memo_release(root_block, MTR_MEMO_PAGE_S_FIX);
 #ifdef UNIV_SYNC_DEBUG
         sync_thread_reset_level(&root_block->lock);
 #endif /* UNIV_SYNC_DEBUG */
@@ -849,13 +849,13 @@ btr_root_adjust_on_import(
 	ulint		zip_size	= dict_table_zip_size(table);
 	ulint		root_page_no	= dict_index_get_page(index);
 
+	DBUG_EXECUTE_IF("ib_import_trigger_corruption_3",
+			return(DB_CORRUPTION););
+
 	mtr_start(&mtr);
 
 	mtr_set_log_mode(&mtr, MTR_LOG_NO_REDO);
 
-	DBUG_EXECUTE_IF("ib_import_trigger_corruption_3",
-			return(DB_CORRUPTION););
-
 	block = btr_block_get(
 		space_id, zip_size, root_page_no, RW_X_LATCH, index, &mtr);
 
@@ -1714,7 +1714,7 @@ btr_free_but_not_root(
 						in bytes or 0 for uncompressed
 						pages */
 	ulint			root_page_no,	/*!< in: root page number */
-	ulint			logging_mode)	/*!< in: mtr logging mode */
+	mtr_log_t		logging_mode)	/*!< in: mtr logging mode */
 {
 	ibool	finished;
 	page_t*	root;
@@ -1831,7 +1831,6 @@ btr_page_reorganize_low(
 	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
 	buf_block_t*	temp_block;
 	page_t*		temp_page;
-	ulint		log_mode;
 	ulint		data_size1;
 	ulint		data_size2;
 	ulint		max_ins_size1;
@@ -1849,7 +1848,7 @@ btr_page_reorganize_low(
 	max_ins_size1 = page_get_max_insert_size_after_reorganize(page, 1);
 
 	/* Turn logging off */
-	log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
+	mtr_log_t	log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
 #ifndef UNIV_HOTBACKUP
 	temp_block = buf_block_alloc(buf_pool);
@@ -1989,8 +1988,8 @@ btr_page_reorganize_low(
 
 #ifndef UNIV_HOTBACKUP
 	if (success) {
-		byte	type;
-		byte*	log_ptr;
+		mlog_id_t	type;
+		byte*		log_ptr;
 
 		/* Write the log record */
 		if (page_zip) {
@@ -3048,8 +3047,8 @@ btr_page_split_and_insert(
 	    && page_is_leaf(page)
 	    && !dict_index_is_online_ddl(cursor->index)) {
 
-		mtr_memo_release(mtr, dict_index_get_lock(cursor->index),
-				 MTR_MEMO_X_LOCK);
+		mtr->memo_release(dict_index_get_lock(cursor->index),
+				  MTR_MEMO_X_LOCK);
 	}
 
 	/* 5. Move then the records to the new page */
@@ -3336,9 +3335,10 @@ UNIV_INLINE
 void
 btr_set_min_rec_mark_log(
 /*=====================*/
-	rec_t*	rec,	/*!< in: record */
-	byte	type,	/*!< in: MLOG_COMP_REC_MIN_MARK or MLOG_REC_MIN_MARK */
-	mtr_t*	mtr)	/*!< in: mtr */
+	rec_t*		rec,	/*!< in: record */
+	mlog_id_t	type,	/*!< in: MLOG_COMP_REC_MIN_MARK or
+				MLOG_REC_MIN_MARK */
+	mtr_t*		mtr)	/*!< in: mtr */
 {
 	mlog_write_initial_log_record(rec, type, mtr);
 

storage/innobase/btr/btr0cur.cc

@@ -4420,17 +4420,17 @@ btr_store_big_rec_extern_fields(
 	if (btr_blob_op_is_update(op)) {
 		/* Avoid reusing pages that have been previously freed
 		in btr_mtr. */
-		if (btr_mtr->n_freed_pages) {
+		if (btr_mtr->has_freed_pages()) {
 			if (heap == NULL) {
 				heap = mem_heap_create(
-					btr_mtr->n_freed_pages
+					btr_mtr->get_freed_pages()
 					* sizeof *freed_pages);
 			}
 
 			freed_pages = static_cast<buf_block_t**>(
 				mem_heap_alloc(
 					heap,
-					btr_mtr->n_freed_pages
+					btr_mtr->get_freed_pages()
 					* sizeof *freed_pages));
 			n_freed_pages = 0;
 		}
@@ -4530,7 +4530,8 @@ btr_store_big_rec_extern_fields(
 				allocate another page for the BLOB data. */
 				ut_ad(alloc_mtr == btr_mtr);
 				ut_ad(btr_blob_op_is_update(op));
-				ut_ad(n_freed_pages < btr_mtr->n_freed_pages);
+				ut_ad(n_freed_pages
+				      < btr_mtr->get_freed_pages());
 				freed_pages[n_freed_pages++] = block;
 				goto alloc_another;
 			}

storage/innobase/btr/btr0pcur.cc

@@ -241,7 +241,7 @@ btr_pcur_restore_position_func(
 	mem_heap_t*	heap;
 
 	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 
 	index = btr_cur_get_index(btr_pcur_get_btr_cur(cursor));
 

storage/innobase/btr/btr0sea.cc

@@ -42,6 +42,7 @@ Created 2/17/1996 Heikki Tuuri
 #include "btr0pcur.h"
 #include "btr0btr.h"
 #include "ha0ha.h"
+#include "srv0mon.h"
 
 /** Flag: has the search system been enabled?
 Protected by btr_search_latch. */

storage/innobase/buf/buf0buddy.cc

@@ -69,7 +69,7 @@ are written.*/
 
 /** Value that we stamp on all buffers that are currently on the zip_free
 list. This value is stamped at BUF_BUDDY_STAMP_OFFSET offset */
-#define BUF_BUDDY_STAMP_FREE	(SRV_LOG_SPACE_FIRST_ID)
+#define BUF_BUDDY_STAMP_FREE	(0xFFFFFFE0UL)
 
 /** Stamp value for non-free buffers. Will be overwritten by a non-zero
 value by the consumer of the block */

storage/innobase/buf/buf0buf.cc

@@ -510,13 +510,13 @@ buf_page_is_corrupted(
 	}
 
 #if !defined(UNIV_HOTBACKUP) && !defined(UNIV_INNOCHECKSUM)
-	if (check_lsn && recv_lsn_checks_on) {
+	if (check_lsn && recover_ptr->is_lsn_check_on()) {
 		lsn_t	current_lsn;
 
 		/* Since we are going to reset the page LSN during the import
 		phase it makes no sense to spam the log with error messages. */
 
-		if (log_peek_lsn(&current_lsn)
+		if (redo_log->peek_lsn(&current_lsn)
 		    && current_lsn
 		    < mach_read_from_8(read_buf + FIL_PAGE_LSN)) {
 			ut_print_timestamp(stderr);
@@ -2576,16 +2576,14 @@ buf_page_get_gen(
 	buf_block_t*	block;
 	ulint		fold;
 	unsigned	access_time;
-	ulint		fix_type;
 	ibool		must_read;
 	rw_lock_t*	hash_lock;
 	ib_mutex_t*	block_mutex;
 	buf_page_t*	hash_bpage;
 	ulint		retries = 0;
 	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 	ut_ad((rw_latch == RW_S_LATCH)
 	      || (rw_latch == RW_X_LATCH)
 	      || (rw_latch == RW_NO_LATCH));
@@ -2865,7 +2863,7 @@ buf_page_get_gen(
 		verification is not necessary when decompressing the page. */
 		ut_a(buf_zip_decompress(block, FALSE));
 
-		if (UNIV_LIKELY(!recv_no_ibuf_operations)) {
+		if (redo_log->is_ibuf_allowed()) {
 			if (access_time) {
 #ifdef UNIV_IBUF_COUNT_DEBUG
 				ut_a(ibuf_count_get(space, offset) == 0);
@@ -3003,6 +3001,8 @@ buf_page_get_gen(
 	ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
+	mtr_memo_type_t	fix_type;
+
 	switch (rw_latch) {
 	case RW_NO_LATCH:
 		if (must_read) {
@@ -3082,11 +3082,10 @@ buf_page_optimistic_get(
 	buf_pool_t*	buf_pool;
 	unsigned	access_time;
 	ibool		success;
-	ulint		fix_type;
 
 	ut_ad(block);
 	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 	ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));
 
 	mutex_enter(&block->mutex);
@@ -3113,6 +3112,8 @@ buf_page_optimistic_get(
 			   buf_block_get_zip_size(block),
 			   buf_block_get_page_no(block), NULL));
 
+	mtr_memo_type_t	fix_type;
+
 	if (rw_latch == RW_S_LATCH) {
 		success = rw_lock_s_lock_nowait(&(block->lock),
 						file, line);
@@ -3199,10 +3200,8 @@ buf_page_get_known_nowait(
 {
 	buf_pool_t*	buf_pool;
 	ibool		success;
-	ulint		fix_type;
 
-	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 	ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));
 
 	mutex_enter(&block->mutex);
@@ -3236,6 +3235,8 @@ buf_page_get_known_nowait(
 
 	ut_ad(!ibuf_inside(mtr) || mode == BUF_KEEP_OLD);
 
+	mtr_memo_type_t	fix_type;
+
 	if (rw_latch == RW_S_LATCH) {
 		success = rw_lock_s_lock_nowait(&(block->lock),
 						file, line);
@@ -3303,12 +3304,11 @@ buf_page_try_get_func(
 {
 	buf_block_t*	block;
 	ibool		success;
-	ulint		fix_type;
 	buf_pool_t*	buf_pool = buf_pool_get(space_id, page_no);
 	rw_lock_t*	hash_lock;
 
 	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 
 	block = buf_block_hash_get_s_locked(buf_pool, space_id,
 					    page_no, &hash_lock);
@@ -3334,7 +3334,7 @@ buf_page_try_get_func(
 	buf_block_buf_fix_inc(block, file, line);
 	mutex_exit(&block->mutex);
 
-	fix_type = MTR_MEMO_PAGE_S_FIX;
+	mtr_memo_type_t	fix_type = MTR_MEMO_PAGE_S_FIX;
 	success = rw_lock_s_lock_nowait(&block->lock, file, line);
 
 	if (!success) {
@@ -3530,7 +3530,7 @@ buf_page_init_for_read(
 
 		ibuf_mtr_start(&mtr);
 
-		if (!recv_no_ibuf_operations
+		if (redo_log->is_ibuf_allowed()
 		    && !ibuf_page(space, zip_size, offset, &mtr)) {
 
 			ibuf_mtr_commit(&mtr);
@@ -3541,7 +3541,7 @@ buf_page_init_for_read(
 		ut_ad(mode == BUF_READ_ANY_PAGE);
 	}
 
-	if (zip_size && !unzip && !recv_recovery_is_on()) {
+	if (zip_size && !unzip && !redo_log->is_recovery_on()) {
 		block = NULL;
 	} else {
 		block = buf_LRU_get_free_block(buf_pool);
@@ -3760,8 +3760,7 @@ buf_page_create(
 	buf_pool_t*	buf_pool	= buf_pool_get(space, offset);
 	rw_lock_t*	hash_lock;
 
-	ut_ad(mtr);
-	ut_ad(mtr->state == MTR_ACTIVE);
+	ut_ad(mtr->is_active());
 	ut_ad(space || !zip_size);
 
 	free_block = buf_LRU_get_free_block(buf_pool);
@@ -4194,17 +4193,18 @@ buf_page_io_complete(
 		DBUG_EXECUTE_IF("buf_page_is_corrupt_failure",
 				page_not_corrupt:  bpage = bpage; );
 
-		if (recv_recovery_is_on()) {
+		if (redo_log->is_recovery_on()) {
 			/* Pages must be uncompressed for crash recovery. */
 			ut_a(uncompressed);
-			recv_recover_page(TRUE, (buf_block_t*) bpage);
+			recover_ptr->recover_page(TRUE, (buf_block_t*) bpage);
 		}
 
 		/* If space is being truncated then avoid ibuf operation.
 		During re-init we have already freed ibuf entries. */
 		if (uncompressed
-		    && !recv_no_ibuf_operations
+		    && redo_log->is_ibuf_allowed()
 		    && !srv_is_tablespace_truncated(bpage->space)) {
+
 			ibuf_merge_or_delete_for_page(
 				(buf_block_t*) bpage, bpage->space,
 				bpage->offset, buf_page_get_zip_size(bpage),

storage/innobase/buf/buf0dblwr.cc

@@ -24,7 +24,6 @@ Created 2011/12/19
 *******************************************************/
 
 #include "ha_prototypes.h"
-
 #include "buf0dblwr.h"
 
 #ifdef UNIV_NONINL
@@ -38,6 +37,8 @@ Created 2011/12/19
 #include "page0zip.h"
 #include "trx0sys.h"
 
+#include "buf0dblwr.h"
+
 #ifndef UNIV_HOTBACKUP
 
 #ifdef UNIV_PFS_MUTEX
@@ -339,7 +340,7 @@ buf_dblwr_create(void)
 	mtr_commit(&mtr);
 
 	/* Flush the modified pages to disk and make a checkpoint */
-	log_make_checkpoint_at(LSN_MAX, TRUE);
+	redo_log->checkpoint_at(LSN_MAX, true);
 
 	/* Remove doublewrite pages from LRU */
 	buf_pool_invalidate();

storage/innobase/buf/buf0flu.cc

@@ -917,7 +917,9 @@ buf_flush_write_block_low(
 	}
 #else
 	/* Force the log to the disk before writing the modified block */
-	log_write_up_to(bpage->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
+	redo_log->write_up_to(
+		bpage->newest_modification,
+		redo_log_t::WAIT_MODE_ALL_GROUPS, true);
 #endif
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_POOL_WATCH:
@@ -2195,14 +2197,14 @@ af_get_pct_for_lsn(
 	lsn_t	max_async_age;
 	lsn_t	lsn_age_factor;
 	lsn_t	af_lwm = (srv_adaptive_flushing_lwm
-			  * log_get_capacity()) / 100;
+			  * redo_log->get_capacity()) / 100;
 
 	if (age < af_lwm) {
 		/* No adaptive flushing. */
 		return(0);
 	}
 
-	max_async_age = log_get_max_modified_age_async();
+	max_async_age = redo_log->get_max_modified_age_async();
 
 	if (age < max_async_age && !srv_adaptive_flushing) {
 		/* We have still not reached the max_async point and
@@ -2252,7 +2254,7 @@ page_cleaner_flush_pages_if_needed(void)
 	ulint			pct_total = 0;
 	int			age_factor = 0;
 
-	cur_lsn = log_get_lsn();
+	cur_lsn = redo_log->get_lsn();
 
 	if (prev_lsn == 0) {
 		/* First time around. */