1 files changed, 42 insertions, 96 deletions

diff --git a/storage/innobase/log/log0log.cc b/storage/innobase/log/log0log.cc
index 7d4e0459610..d8e4ba6fe98 100644
--- a/storage/innobase/log/log0log.cc
+++ b/storage/innobase/log/log0log.cc
@@ -44,6 +44,7 @@ Created 12/9/1995 Heikki Tuuri
 #include "fil0fil.h"
 #include "dict0boot.h"
 #include "dict0stats_bg.h"
+#include "btr0defragment.h"
 #include "srv0srv.h"
 #include "srv0start.h"
 #include "trx0sys.h"
@@ -666,18 +667,14 @@ log_group_set_fields(
 	group->lsn = lsn;
 }
 
-/*****************************************************************//**
-Calculates the recommended highest values for lsn - last_checkpoint_lsn
+/** Calculate the recommended highest values for lsn - last_checkpoint_lsn
 and lsn - buf_get_oldest_modification().
 @retval true on success
 @retval false if the smallest log group is too small to
 accommodate the number of OS threads in the database server */
-static MY_ATTRIBUTE((warn_unused_result))
 bool
-log_calc_max_ages(void)
-/*===================*/
+log_set_capacity()
 {
-	log_group_t*	group;
 	lsn_t		margin;
 	ulint		free;
 	bool		success	= true;
@@ -685,21 +682,7 @@ log_calc_max_ages(void)
 
 	log_mutex_enter();
 
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	ut_ad(group);
-
-	smallest_capacity = LSN_MAX;
-
-	while (group) {
-		if (log_group_get_capacity(group) < smallest_capacity) {
-
-			smallest_capacity = log_group_get_capacity(group);
-		}
-
-		group = UT_LIST_GET_NEXT(log_groups, group);
-	}
-
+	smallest_capacity = log_group_get_capacity(&log_sys->log);
 	/* Add extra safety */
 	smallest_capacity = smallest_capacity - smallest_capacity / 10;
 
@@ -746,11 +729,9 @@ failure:
 	return(success);
 }
 
-/******************************************************//**
-Initializes the log. */
+/** Initializes the redo logging subsystem. */
 void
-log_init(void)
-/*==========*/
+log_sys_init()
 {
 	log_sys = static_cast<log_t*>(ut_zalloc_nokey(sizeof(log_t)));
 
@@ -779,7 +760,6 @@ log_init(void)
 	log_sys->max_buf_free = log_sys->buf_size / LOG_BUF_FLUSH_RATIO
 		- LOG_BUF_FLUSH_MARGIN;
 	log_sys->check_flush_or_checkpoint = true;
-	UT_LIST_INIT(log_sys->log_groups, &log_group_t::log_groups);
 
 	log_sys->n_log_ios_old = log_sys->n_log_ios;
 	log_sys->last_printout_time = time(NULL);
@@ -823,32 +803,20 @@ log_init(void)
 	}
 }
 
-/******************************************************************//**
-Inits a log group to the log system.
-@return true if success, false if not */
-MY_ATTRIBUTE((warn_unused_result))
-bool
-log_group_init(
-/*===========*/
-	ulint	id,			/*!< in: group id */
-	ulint	n_files,		/*!< in: number of log files */
-	lsn_t	file_size,		/*!< in: log file size in bytes */
-	ulint	space_id)		/*!< in: space id of the file space
-					which contains the log files of this
-					group */
+/** Initialize the redo log.
+@param[in]	n_files		number of files
+@param[in]	file_size	file size in bytes */
+void
+log_init(ulint n_files, lsn_t file_size)
 {
 	ulint	i;
-	log_group_t*	group;
+	log_group_t*	group = &log_sys->log;
 
-	group = static_cast<log_group_t*>(ut_malloc_nokey(sizeof(log_group_t)));
-
-	group->id = id;
 	group->n_files = n_files;
 	group->format = srv_encrypt_log
 		? LOG_HEADER_FORMAT_CURRENT | LOG_HEADER_FORMAT_ENCRYPTED
 		: LOG_HEADER_FORMAT_CURRENT;
 	group->file_size = file_size;
-	group->space_id = space_id;
 	group->state = LOG_GROUP_OK;
 	group->lsn = LOG_START_LSN;
 	group->lsn_offset = LOG_FILE_HDR_SIZE;
@@ -874,9 +842,6 @@ log_group_init(
 
 	group->checkpoint_buf = static_cast<byte*>(
 		ut_align(group->checkpoint_buf_ptr,OS_FILE_LOG_BLOCK_SIZE));
-
-	UT_LIST_ADD_LAST(log_sys->log_groups, group);
-	return(log_calc_max_ages());
 }
 
 /******************************************************//**
@@ -899,12 +864,11 @@ log_io_complete(
 		case SRV_O_DIRECT:
 		case SRV_O_DIRECT_NO_FSYNC:
 		case SRV_ALL_O_DIRECT_FSYNC:
-			fil_flush(group->space_id);
+			fil_flush(SRV_LOG_SPACE_FIRST_ID);
 		}
 
 
-		DBUG_PRINT("ib_log", ("checkpoint info written to group %u",
-				      unsigned(group->id)));
+		DBUG_PRINT("ib_log", ("checkpoint info written"));
 		log_io_complete_checkpoint();
 
 		return;
@@ -931,7 +895,6 @@ log_group_file_header_flush(
 
 	ut_ad(log_write_mutex_own());
 	ut_ad(!recv_no_log_write);
-	ut_ad(group->id == 0);
 	ut_a(nth_file < group->n_files);
 	ut_ad((group->format & ~LOG_HEADER_FORMAT_ENCRYPTED)
 	      == LOG_HEADER_FORMAT_CURRENT);
@@ -950,9 +913,8 @@ log_group_file_header_flush(
 	dest_offset = nth_file * group->file_size;
 
 	DBUG_PRINT("ib_log", ("write " LSN_PF
-			      " group " ULINTPF
 			      " file " ULINTPF " header",
-			      start_lsn, group->id, nth_file));
+			      start_lsn, nth_file));
 
 	log_sys->n_log_ios++;
 
@@ -964,7 +926,7 @@ log_group_file_header_flush(
 		= (ulint) (dest_offset / univ_page_size.physical());
 
 	fil_io(IORequestLogWrite, true,
-	       page_id_t(group->space_id, page_no),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID, page_no),
 	       univ_page_size,
 	       (ulint) (dest_offset % univ_page_size.physical()),
 	       OS_FILE_LOG_BLOCK_SIZE, buf, group);
@@ -1050,10 +1012,10 @@ loop:
 
 	DBUG_PRINT("ib_log",
 		   ("write " LSN_PF " to " LSN_PF
-		    ": group " ULINTPF " len " ULINTPF
+		    ": len " ULINTPF
 		    " blocks " ULINTPF ".." ULINTPF,
 		    start_lsn, next_offset,
-		    group->id, write_len,
+		    write_len,
 		    log_block_get_hdr_no(buf),
 		    log_block_get_hdr_no(
 			    buf + write_len
@@ -1091,7 +1053,7 @@ loop:
 		= (ulint) (next_offset / univ_page_size.physical());
 
 	fil_io(IORequestLogWrite, true,
-	       page_id_t(group->space_id, page_no),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID, page_no),
 	       univ_page_size,
 	       (ulint) (next_offset % UNIV_PAGE_SIZE), write_len, buf,
 	       group);
@@ -1259,7 +1221,6 @@ loop:
 		return;
 	}
 
-	log_group_t*	group;
 	ulint		start_offset;
 	ulint		end_offset;
 	ulint		area_start;
@@ -1303,9 +1264,7 @@ loop:
 
 	log_buffer_switch();
 
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	log_group_set_fields(group, log_sys->write_lsn);
+	log_group_set_fields(&log_sys->log, log_sys->write_lsn);
 
 	log_mutex_exit();
 	/* Calculate pad_size if needed. */
@@ -1316,7 +1275,7 @@ loop:
 		end_offset = log_group_calc_lsn_offset(
 			ut_uint64_align_up(write_lsn,
 					   OS_FILE_LOG_BLOCK_SIZE),
-			group);
+			&log_sys->log);
 		end_offset_in_unit = (ulint) (end_offset % write_ahead_size);
 
 		if (end_offset_in_unit > 0
@@ -1335,7 +1294,7 @@ loop:
 	}
 	/* Do the write to the log files */
 	log_group_write_buf(
-		group, write_buf + area_start,
+		&log_sys->log, write_buf + area_start,
 		area_end - area_start + pad_size,
 #ifdef UNIV_DEBUG
 		pad_size,
@@ -1538,11 +1497,10 @@ log_io_complete_checkpoint(void)
 }
 
 /** Write checkpoint info to the log header.
-@param[in,out]	group	redo log
 @param[in]	end_lsn	start LSN of the MLOG_CHECKPOINT mini-transaction */
 static
 void
-log_group_checkpoint(log_group_t* group, lsn_t end_lsn)
+log_group_checkpoint(lsn_t end_lsn)
 {
 	lsn_t		lsn_offset;
 	byte*		buf;
@@ -1555,10 +1513,11 @@ log_group_checkpoint(log_group_t* group, lsn_t end_lsn)
 	      || srv_shutdown_state != SRV_SHUTDOWN_NONE);
 
 	DBUG_PRINT("ib_log", ("checkpoint " UINT64PF " at " LSN_PF
-			      " written to group " ULINTPF,
+			      " written",
 			      log_sys->next_checkpoint_no,
-			      log_sys->next_checkpoint_lsn,
-			      group->id));
+			      log_sys->next_checkpoint_lsn));
+
+	log_group_t*	group = &log_sys->log;
 
 	buf = group->checkpoint_buf;
 	memset(buf, 0, OS_FILE_LOG_BLOCK_SIZE);
@@ -1600,7 +1559,7 @@ log_group_checkpoint(log_group_t* group, lsn_t end_lsn)
 	file write and a checkpoint field write */
 
 	fil_io(IORequestLogWrite, false,
-	       page_id_t(group->space_id, 0),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID, 0),
 	       univ_page_size,
 	       (log_sys->next_checkpoint_no & 1)
 	       ? LOG_CHECKPOINT_2 : LOG_CHECKPOINT_1,
@@ -1625,7 +1584,8 @@ log_group_header_read(
 	MONITOR_INC(MONITOR_LOG_IO);
 
 	fil_io(IORequestLogRead, true,
-	       page_id_t(group->space_id, header / univ_page_size.physical()),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID,
+			 header / univ_page_size.physical()),
 	       univ_page_size, header % univ_page_size.physical(),
 	       OS_FILE_LOG_BLOCK_SIZE, log_sys->checkpoint_buf, NULL);
 }
@@ -1639,12 +1599,7 @@ log_write_checkpoint_info(bool sync, lsn_t end_lsn)
 	ut_ad(log_mutex_own());
 	ut_ad(!srv_read_only_mode);
 
-	for (log_group_t* group = UT_LIST_GET_FIRST(log_sys->log_groups);
-	     group;
-	     group = UT_LIST_GET_NEXT(log_groups, group)) {
-
-		log_group_checkpoint(group, end_lsn);
-	}
+	log_group_checkpoint(end_lsn);
 
 	log_mutex_exit();
 
@@ -2010,6 +1965,8 @@ loop:
 		thread_name = "lock_wait_timeout_thread";
 	} else if (srv_buf_dump_thread_active) {
 		thread_name = "buf_dump_thread";
+	} else if (btr_defragment_thread_active) {
+		thread_name = "btr_defragment_thread";
 	} else if (srv_fast_shutdown != 2 && trx_rollback_or_clean_is_active) {
 		thread_name = "rollback of recovered transactions";
 	} else {
@@ -2031,8 +1988,8 @@ wait_suspend_loop:
 
 	switch (srv_get_active_thread_type()) {
 	case SRV_NONE:
-		srv_shutdown_state = SRV_SHUTDOWN_FLUSH_PHASE;
 		if (!srv_n_fil_crypt_threads_started) {
+			srv_shutdown_state = SRV_SHUTDOWN_FLUSH_PHASE;
 			break;
 		}
 		os_event_set(fil_crypt_threads_event);
@@ -2280,13 +2237,11 @@ log_refresh_stats(void)
 	log_sys->last_printout_time = time(NULL);
 }
 
-/********************************************************//**
-Closes a log group. */
+/** Close a log group.
+@param[in,out]	group	log group to close */
 static
 void
-log_group_close(
-/*===========*/
-	log_group_t*	group)		/* in,own: log group to close */
+log_group_close(log_group_t* group)
 {
 	ulint	i;
 
@@ -2297,7 +2252,10 @@ log_group_close(
 	ut_free(group->file_header_bufs_ptr);
 	ut_free(group->file_header_bufs);
 	ut_free(group->checkpoint_buf_ptr);
-	ut_free(group);
+	group->n_files = 0;
+	group->file_header_bufs_ptr = NULL;
+	group->file_header_bufs = NULL;
+	group->checkpoint_buf_ptr = NULL;
 }
 
 /********************************************************//**
@@ -2306,19 +2264,7 @@ void
 log_group_close_all(void)
 /*=====================*/
 {
-	log_group_t*	group;
-
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	while (UT_LIST_GET_LEN(log_sys->log_groups) > 0) {
-		log_group_t*	prev_group = group;
-
-		group = UT_LIST_GET_NEXT(log_groups, group);
-
-		UT_LIST_REMOVE(log_sys->log_groups, prev_group);
-
-		log_group_close(prev_group);
-	}
+	log_group_close(&log_sys->log);
 }
 
 /********************************************************//**