1 files changed, 116 insertions, 160 deletions

diff --git a/storage/innobase/trx/trx0rseg.cc b/storage/innobase/trx/trx0rseg.cc
index 29e6acc773c..546a4c51e03 100644
--- a/storage/innobase/trx/trx0rseg.cc
+++ b/storage/innobase/trx/trx0rseg.cc
@@ -31,8 +31,6 @@ Created 3/26/1996 Heikki Tuuri
 #include "trx0purge.h"
 #include "srv0mon.h"
 
-#include <algorithm>
-
 #ifdef WITH_WSREP
 #include <mysql/service_wsrep.h>
 
@@ -49,7 +47,7 @@ static unsigned char wsrep_uuid[16];
 @param[in,out]	mtr		mini transaction */
 static void
 trx_rseg_write_wsrep_checkpoint(
-	trx_rsegf_t*	rseg_header,
+	buf_block_t*	rseg_header,
 	const XID*	xid,
 	mtr_t*		mtr)
 {
@@ -57,26 +55,29 @@ trx_rseg_write_wsrep_checkpoint(
 	DBUG_ASSERT(xid->bqual_length >= 0);
 	DBUG_ASSERT(xid->gtrid_length + xid->bqual_length < XIDDATASIZE);
 
-	mlog_write_ulint(TRX_RSEG_WSREP_XID_FORMAT + rseg_header,
-			 uint32_t(xid->formatID),
-			 MLOG_4BYTES, mtr);
+	mtr->write<4,mtr_t::OPT>(*rseg_header,
+				 TRX_RSEG + TRX_RSEG_WSREP_XID_FORMAT
+				 + rseg_header->frame,
+				 uint32_t(xid->formatID));
 
-	mlog_write_ulint(TRX_RSEG_WSREP_XID_GTRID_LEN + rseg_header,
-			 uint32_t(xid->gtrid_length),
-			 MLOG_4BYTES, mtr);
+	mtr->write<4,mtr_t::OPT>(*rseg_header,
+				 TRX_RSEG + TRX_RSEG_WSREP_XID_GTRID_LEN
+				 + rseg_header->frame,
+				 uint32_t(xid->gtrid_length));
 
-	mlog_write_ulint(TRX_RSEG_WSREP_XID_BQUAL_LEN + rseg_header,
-			 uint32_t(xid->bqual_length),
-			 MLOG_4BYTES, mtr);
+	mtr->write<4,mtr_t::OPT>(*rseg_header,
+				 TRX_RSEG + TRX_RSEG_WSREP_XID_BQUAL_LEN
+				 + rseg_header->frame,
+				 uint32_t(xid->bqual_length));
 
 	const ulint xid_length = static_cast<ulint>(xid->gtrid_length
 						    + xid->bqual_length);
-	mlog_write_string(TRX_RSEG_WSREP_XID_DATA + rseg_header,
-			  reinterpret_cast<const byte*>(xid->data),
-			  xid_length, mtr);
+	mtr->memcpy(rseg_header, TRX_RSEG + TRX_RSEG_WSREP_XID_DATA,
+		    xid->data, xid_length);
 	if (UNIV_LIKELY(xid_length < XIDDATASIZE)) {
-		mlog_memset(TRX_RSEG_WSREP_XID_DATA + rseg_header + xid_length,
-			    XIDDATASIZE - xid_length, 0, mtr);
+		mtr->memset(rseg_header,
+			    TRX_RSEG + TRX_RSEG_WSREP_XID_DATA + xid_length,
+			    XIDDATASIZE - xid_length, 0);
 	}
 }
 
@@ -86,7 +87,7 @@ trx_rseg_write_wsrep_checkpoint(
 @param[in,out]	mtr		mini-transaction */
 void
 trx_rseg_update_wsrep_checkpoint(
-	trx_rsegf_t*	rseg_header,
+	buf_block_t*	rseg_header,
 	const XID*	xid,
 	mtr_t*		mtr)
 {
@@ -109,16 +110,13 @@ trx_rseg_update_wsrep_checkpoint(
 }
 
 /** Clear the WSREP XID information from rollback segment header.
-@param[in,out]	rseg_header	Rollback segment header
-@param[in,out]	mtr 		mini-transaction */
-static void
-trx_rseg_clear_wsrep_checkpoint(
-	trx_rsegf_t*	rseg_header,
-	mtr_t*		mtr)
+@param[in,out]	block	rollback segment header
+@param[in,out]	mtr 	mini-transaction */
+static void trx_rseg_clear_wsrep_checkpoint(buf_block_t *block, mtr_t *mtr)
 {
-	mlog_memset(rseg_header + TRX_RSEG_WSREP_XID_INFO,
-		    TRX_RSEG_WSREP_XID_DATA + XIDDATASIZE
-		    - TRX_RSEG_WSREP_XID_INFO, 0, mtr);
+  mtr->memset(block, TRX_RSEG + TRX_RSEG_WSREP_XID_INFO,
+              TRX_RSEG_WSREP_XID_DATA + XIDDATASIZE - TRX_RSEG_WSREP_XID_INFO,
+              0);
 }
 
 static void
@@ -133,9 +131,10 @@ trx_rseg_update_wsrep_checkpoint(const XID* xid, mtr_t* mtr)
 					     sizeof wsrep_uuid);
 	const trx_rseg_t* rseg = trx_sys.rseg_array[0];
 
-	trx_rsegf_t* rseg_header = trx_rsegf_get(rseg->space, rseg->page_no,
+	buf_block_t* rseg_header = trx_rsegf_get(rseg->space, rseg->page_no,
 						 mtr);
-	if (UNIV_UNLIKELY(mach_read_from_4(rseg_header + TRX_RSEG_FORMAT))) {
+	if (UNIV_UNLIKELY(mach_read_from_4(TRX_RSEG + TRX_RSEG_FORMAT
+					   + rseg_header->frame))) {
 		trx_rseg_format_upgrade(rseg_header, mtr);
 	}
 
@@ -178,25 +177,26 @@ void trx_rseg_update_wsrep_checkpoint(const XID* xid)
 @param[out]	xid		Transaction XID
 @return	whether the WSREP XID was present */
 static
-bool trx_rseg_read_wsrep_checkpoint(const trx_rsegf_t* rseg_header, XID& xid)
+bool trx_rseg_read_wsrep_checkpoint(const buf_block_t *rseg_header, XID &xid)
 {
 	int formatID = static_cast<int>(
-		mach_read_from_4(
-			TRX_RSEG_WSREP_XID_FORMAT + rseg_header));
+		mach_read_from_4(TRX_RSEG + TRX_RSEG_WSREP_XID_FORMAT
+				 + rseg_header->frame));
 	if (formatID == 0) {
 		return false;
 	}
 
 	xid.formatID = formatID;
 	xid.gtrid_length = static_cast<int>(
-		mach_read_from_4(
-			TRX_RSEG_WSREP_XID_GTRID_LEN + rseg_header));
+		mach_read_from_4(TRX_RSEG + TRX_RSEG_WSREP_XID_GTRID_LEN
+				 + rseg_header->frame));
 
 	xid.bqual_length = static_cast<int>(
-		mach_read_from_4(
-			TRX_RSEG_WSREP_XID_BQUAL_LEN + rseg_header));
+		mach_read_from_4(TRX_RSEG + TRX_RSEG_WSREP_XID_BQUAL_LEN
+				 + rseg_header->frame));
 
-	memcpy(xid.data, TRX_RSEG_WSREP_XID_DATA + rseg_header, XIDDATASIZE);
+	memcpy(xid.data, TRX_RSEG + TRX_RSEG_WSREP_XID_DATA
+	       + rseg_header->frame, XIDDATASIZE);
 
 	return true;
 }
@@ -252,10 +252,11 @@ bool trx_rseg_read_wsrep_checkpoint(XID& xid)
 			continue;
 		}
 
-		const trx_rsegf_t* rseg_header = trx_rsegf_get_new(
+		const buf_block_t* rseg_header = trx_rsegf_get_new(
 			trx_sysf_rseg_get_space(sys, rseg_id), page_no, &mtr);
 
-		if (mach_read_from_4(rseg_header + TRX_RSEG_FORMAT)) {
+		if (mach_read_from_4(TRX_RSEG + TRX_RSEG_FORMAT
+				     + rseg_header->frame)) {
 			continue;
 		}
 
@@ -279,17 +280,15 @@ bool trx_rseg_read_wsrep_checkpoint(XID& xid)
 /** Upgrade a rollback segment header page to MariaDB 10.3 format.
 @param[in,out]	rseg_header	rollback segment header page
 @param[in,out]	mtr		mini-transaction */
-void trx_rseg_format_upgrade(trx_rsegf_t* rseg_header, mtr_t* mtr)
+void trx_rseg_format_upgrade(buf_block_t *rseg_header, mtr_t *mtr)
 {
-	ut_ad(page_offset(rseg_header) == TRX_RSEG);
-	byte* rseg_format = TRX_RSEG_FORMAT + rseg_header;
-	mlog_write_ulint(rseg_format, 0, MLOG_4BYTES, mtr);
-	/* Clear also possible garbage at the end of the page. Old
-	InnoDB versions did not initialize unused parts of pages. */
-	mlog_memset(TRX_RSEG_MAX_TRX_ID + 8 + rseg_header,
-		    srv_page_size
-		    - (FIL_PAGE_DATA_END
-		       + TRX_RSEG + TRX_RSEG_MAX_TRX_ID + 8), 0, mtr);
+  mtr->memset(rseg_header, TRX_RSEG + TRX_RSEG_FORMAT, 4, 0);
+  /* Clear also possible garbage at the end of the page. Old
+  InnoDB versions did not initialize unused parts of pages. */
+  mtr->memset(rseg_header, TRX_RSEG + TRX_RSEG_MAX_TRX_ID + 8,
+              srv_page_size
+              - (FIL_PAGE_DATA_END + TRX_RSEG + TRX_RSEG_MAX_TRX_ID + 8),
+              0);
 }
 
 /** Create a rollback segment header.
@@ -330,23 +329,23 @@ trx_rseg_header_create(
 	flst_init(block, TRX_RSEG_HISTORY + TRX_RSEG, mtr);
 
 	/* Reset the undo log slots */
-	mlog_memset(block, TRX_RSEG_UNDO_SLOTS + TRX_RSEG,
-		    TRX_RSEG_N_SLOTS * 4, 0xff, mtr);
+	mtr->memset(block, TRX_RSEG_UNDO_SLOTS + TRX_RSEG,
+		    TRX_RSEG_N_SLOTS * 4, 0xff);
 
 	if (sys_header) {
 		/* Add the rollback segment info to the free slot in
 		the trx system header */
 
-		mlog_write_ulint(TRX_SYS + TRX_SYS_RSEGS
-				 + TRX_SYS_RSEG_SPACE
-				 + rseg_id * TRX_SYS_RSEG_SLOT_SIZE
-				 + sys_header->frame,
-				 space->id, MLOG_4BYTES, mtr);
-		mlog_write_ulint(TRX_SYS + TRX_SYS_RSEGS
-				 + TRX_SYS_RSEG_PAGE_NO
-				 + rseg_id * TRX_SYS_RSEG_SLOT_SIZE
-				 + sys_header->frame,
-				 block->page.id.page_no(), MLOG_4BYTES, mtr);
+		mtr->write<4,mtr_t::OPT>(
+			*sys_header,
+			TRX_SYS + TRX_SYS_RSEGS + TRX_SYS_RSEG_SPACE
+			+ rseg_id * TRX_SYS_RSEG_SLOT_SIZE
+			+ sys_header->frame, space->id);
+		mtr->write<4,mtr_t::OPT>(
+			*sys_header,
+			TRX_SYS + TRX_SYS_RSEGS + TRX_SYS_RSEG_PAGE_NO
+			+ rseg_id * TRX_SYS_RSEG_SLOT_SIZE
+			+ sys_header->frame, block->page.id.page_no());
 	}
 
 	return block;
@@ -410,29 +409,28 @@ trx_rseg_mem_create(ulint id, fil_space_t* space, ulint page_no)
 }
 
 /** Read the undo log lists.
-@param[in,out]	rseg		rollback segment
-@param[in,out]	max_trx_id	maximum observed transaction identifier
-@param[in]	rseg_header	rollback segment header
+@param[in,out]  rseg            rollback segment
+@param[in,out]  max_trx_id      maximum observed transaction identifier
+@param[in]      rseg_header     rollback segment header
 @return the combined size of undo log segments in pages */
-static
-ulint
-trx_undo_lists_init(trx_rseg_t* rseg, trx_id_t& max_trx_id,
-		    const trx_rsegf_t* rseg_header)
+static ulint trx_undo_lists_init(trx_rseg_t *rseg, trx_id_t &max_trx_id,
+                                 const buf_block_t *rseg_header)
 {
-	ut_ad(srv_force_recovery < SRV_FORCE_NO_UNDO_LOG_SCAN);
+  ut_ad(srv_force_recovery < SRV_FORCE_NO_UNDO_LOG_SCAN);
 
-	ulint size = 0;
+  ulint size= 0;
 
-	for (ulint i = 0; i < TRX_RSEG_N_SLOTS; i++) {
-		ulint	page_no = trx_rsegf_get_nth_undo(rseg_header, i);
-		if (page_no != FIL_NULL) {
-			size += trx_undo_mem_create_at_db_start(
-				rseg, i, page_no, max_trx_id);
-			MONITOR_INC(MONITOR_NUM_UNDO_SLOT_USED);
-		}
-	}
+  for (ulint i= 0; i < TRX_RSEG_N_SLOTS; i++)
+  {
+    uint32_t page_no= trx_rsegf_get_nth_undo(rseg_header, i);
+    if (page_no != FIL_NULL)
+    {
+      size+= trx_undo_mem_create_at_db_start(rseg, i, page_no, max_trx_id);
+      MONITOR_INC(MONITOR_NUM_UNDO_SLOT_USED);
+    }
+  }
 
-	return(size);
+  return size;
 }
 
 /** Restore the state of a persistent rollback segment.
@@ -443,20 +441,20 @@ static
 void
 trx_rseg_mem_restore(trx_rseg_t* rseg, trx_id_t& max_trx_id, mtr_t* mtr)
 {
-	trx_rsegf_t*	rseg_header = trx_rsegf_get_new(
+	buf_block_t* rseg_hdr = trx_rsegf_get_new(
 		rseg->space->id, rseg->page_no, mtr);
 
-	if (mach_read_from_4(rseg_header + TRX_RSEG_FORMAT) == 0) {
-		trx_id_t id = mach_read_from_8(rseg_header
-					       + TRX_RSEG_MAX_TRX_ID);
+	if (!mach_read_from_4(TRX_RSEG + TRX_RSEG_FORMAT + rseg_hdr->frame)) {
+		trx_id_t id = mach_read_from_8(TRX_RSEG + TRX_RSEG_MAX_TRX_ID
+					       + rseg_hdr->frame);
 
 		if (id > max_trx_id) {
 			max_trx_id = id;
 		}
 
-		if (rseg_header[TRX_RSEG_BINLOG_NAME]) {
-			const char* binlog_name = reinterpret_cast<const char*>
-				(rseg_header) + TRX_RSEG_BINLOG_NAME;
+		const char* binlog_name = TRX_RSEG + TRX_RSEG_BINLOG_NAME
+			+ reinterpret_cast<const char*>(rseg_hdr->frame);
+		if (*binlog_name) {
 			compile_time_assert(TRX_RSEG_BINLOG_NAME_LEN == sizeof
 					    trx_sys.recovered_binlog_filename);
 
@@ -468,7 +466,8 @@ trx_rseg_mem_restore(trx_rseg_t* rseg, trx_id_t& max_trx_id, mtr_t* mtr)
 
 			if (cmp >= 0) {
 				uint64_t binlog_offset = mach_read_from_8(
-					rseg_header + TRX_RSEG_BINLOG_OFFSET);
+					TRX_RSEG + TRX_RSEG_BINLOG_OFFSET
+					+ rseg_hdr->frame);
 				if (cmp) {
 					memcpy(trx_sys.
 					       recovered_binlog_filename,
@@ -485,7 +484,7 @@ trx_rseg_mem_restore(trx_rseg_t* rseg, trx_id_t& max_trx_id, mtr_t* mtr)
 
 #ifdef WITH_WSREP
 			trx_rseg_read_wsrep_checkpoint(
-				rseg_header, trx_sys.recovered_wsrep_xid);
+				rseg_hdr, trx_sys.recovered_wsrep_xid);
 #endif
 		}
 	}
@@ -499,32 +498,37 @@ trx_rseg_mem_restore(trx_rseg_t* rseg, trx_id_t& max_trx_id, mtr_t* mtr)
 
 	/* Initialize the undo log lists according to the rseg header */
 
-	rseg->curr_size = mach_read_from_4(rseg_header + TRX_RSEG_HISTORY_SIZE)
-		+ 1 + trx_undo_lists_init(rseg, max_trx_id, rseg_header);
+	rseg->curr_size = mach_read_from_4(TRX_RSEG + TRX_RSEG_HISTORY_SIZE
+					   + rseg_hdr->frame)
+		+ 1 + trx_undo_lists_init(rseg, max_trx_id, rseg_hdr);
 
-	if (auto len = flst_get_len(rseg_header + TRX_RSEG_HISTORY)) {
+	if (auto len = flst_get_len(TRX_RSEG + TRX_RSEG_HISTORY
+				    + rseg_hdr->frame)) {
 		trx_sys.rseg_history_len += len;
 
 		fil_addr_t	node_addr = trx_purge_get_log_from_hist(
-			flst_get_last(rseg_header + TRX_RSEG_HISTORY, mtr));
+			flst_get_last(TRX_RSEG + TRX_RSEG_HISTORY
+				      + rseg_hdr->frame));
 
 		rseg->last_page_no = node_addr.page;
 		rseg->last_offset = node_addr.boffset;
 
-		const trx_ulogf_t*	undo_log_hdr = trx_undo_page_get(
-			page_id_t(rseg->space->id, node_addr.page), mtr)
-			+ node_addr.boffset;
+		const buf_block_t* block = trx_undo_page_get(
+			page_id_t(rseg->space->id, node_addr.page), mtr);
 
-		trx_id_t id = mach_read_from_8(undo_log_hdr + TRX_UNDO_TRX_ID);
+		trx_id_t id = mach_read_from_8(block->frame + node_addr.boffset
+					       + TRX_UNDO_TRX_ID);
 		if (id > max_trx_id) {
 			max_trx_id = id;
 		}
-		id = mach_read_from_8(undo_log_hdr + TRX_UNDO_TRX_NO);
+		id = mach_read_from_8(block->frame + node_addr.boffset
+				      + TRX_UNDO_TRX_NO);
 		if (id > max_trx_id) {
 			max_trx_id = id;
 		}
-		unsigned purge = mach_read_from_2(
-			undo_log_hdr + TRX_UNDO_NEEDS_PURGE);
+		unsigned purge = mach_read_from_2(block->frame
+						  + node_addr.boffset
+						  + TRX_UNDO_NEEDS_PURGE);
 		ut_ad(purge <= 1);
 		rseg->set_last_trx_no(id, purge != 0);
 		rseg->needs_purge = purge != 0;
@@ -638,9 +642,9 @@ trx_rseg_array_init()
 		}
 
 		/* Finally, clear WSREP XID in TRX_SYS page. */
-		const buf_block_t* sys = trx_sysf_get(&mtr);
-		mlog_memset(TRX_SYS + TRX_SYS_WSREP_XID_INFO + sys->frame,
-			    TRX_SYS_WSREP_XID_LEN, 0, &mtr);
+		mtr.memset(trx_sysf_get(&mtr),
+			   TRX_SYS + TRX_SYS_WSREP_XID_INFO,
+			   TRX_SYS_WSREP_XID_LEN, 0);
 		mtr.commit();
 	}
 #endif
@@ -709,55 +713,6 @@ trx_temp_rseg_create()
 	}
 }
 
-/********************************************************************
-Get the number of unique rollback tablespaces in use except space id 0.
-The last space id will be the sentinel value ULINT_UNDEFINED. The array
-will be sorted on space id. Note: space_ids should have have space for
-TRX_SYS_N_RSEGS + 1 elements.
-@return number of unique rollback tablespaces in use. */
-ulint
-trx_rseg_get_n_undo_tablespaces(
-/*============================*/
-	ulint*		space_ids)	/*!< out: array of space ids of
-					UNDO tablespaces */
-{
-	mtr_t mtr;
-	mtr.start();
-
-	buf_block_t* sys_header = trx_sysf_get(&mtr, false);
-	if (!sys_header) {
-		mtr.commit();
-		return 0;
-	}
-
-	ulint* end = space_ids;
-
-	for (ulint rseg_id = 0; rseg_id < TRX_SYS_N_RSEGS; rseg_id++) {
-		uint32_t page_no = trx_sysf_rseg_get_page_no(sys_header,
-							     rseg_id);
-
-		if (page_no == FIL_NULL) {
-			continue;
-		}
-
-		if (ulint space = trx_sysf_rseg_get_space(sys_header,
-							  rseg_id)) {
-			if (std::find(space_ids, end, space) == end) {
-				*end++ = space;
-			}
-		}
-	}
-
-	mtr.commit();
-
-	ut_a(end - space_ids <= TRX_SYS_N_RSEGS);
-	*end = ULINT_UNDEFINED;
-
-	std::sort(space_ids, end);
-
-	return ulint(end - space_ids);
-}
-
 /** Update the offset information about the end of the binlog entry
 which corresponds to the transaction just being committed.
 In a replication slave, this updates the master binlog position
@@ -765,8 +720,8 @@ up to which replication has proceeded.
 @param[in,out]	rseg_header	rollback segment header
 @param[in]	trx		committing transaction
 @param[in,out]	mtr		mini-transaction */
-void
-trx_rseg_update_binlog_offset(byte* rseg_header, const trx_t* trx, mtr_t* mtr)
+void trx_rseg_update_binlog_offset(buf_block_t *rseg_header, const trx_t *trx,
+                                   mtr_t *mtr)
 {
 	DBUG_LOG("trx", "trx_mysql_binlog_offset: " << trx->mysql_log_offset);
 
@@ -778,13 +733,14 @@ trx_rseg_update_binlog_offset(byte* rseg_header, const trx_t* trx, mtr_t* mtr)
 		return;
 	}
 
-	mlog_write_ull(rseg_header + TRX_RSEG_BINLOG_OFFSET,
-		       trx->mysql_log_offset, mtr);
-	byte* p = rseg_header + TRX_RSEG_BINLOG_NAME;
-	const byte* binlog_name = reinterpret_cast<const byte*>
-		(trx->mysql_log_file_name);
+	mtr->write<8,mtr_t::OPT>(*rseg_header,
+				 TRX_RSEG + TRX_RSEG_BINLOG_OFFSET
+				 + rseg_header->frame,
+				 trx->mysql_log_offset);
 
-	if (memcmp(binlog_name, p, len)) {
-		mlog_write_string(p, binlog_name, len, mtr);
+	if (memcmp(trx->mysql_log_file_name, TRX_RSEG + TRX_RSEG_BINLOG_NAME
+		   + rseg_header->frame, len)) {
+		mtr->memcpy(rseg_header, TRX_RSEG + TRX_RSEG_BINLOG_NAME,
+			    trx->mysql_log_file_name, len);
 	}
 }