Remove traces of multiple InnoDB redo logs

InnoDB never supported more than one copy of a redo log.
There were provisions to do that. For Mariabackup, let us clean up
this code.

log_sys_init(): Renamed from log_init().

log_set_capacity(): Renamed from log_calc_max_ages().

log_init(): Renamed from log_group_init(). Remove the parameters
id, space_id. Let the caller invoke log_set_capacity() when needed.

log_group_t: Remove id, space_id, log_groups.

log_t: Replace log_groups with a single log.

recv_find_max_checkpoint(): Declare globally. Remove the first parameter.

xtrabackup_choose_lsn_offset(): Remove (dead code).

extra/mariabackup/xb0xb.h

@@ -66,7 +66,6 @@ void
 innodb_log_checksum_func_update(
 /*============================*/
 ulint	algorithm)	/*!< in: algorithm */;
-dberr_t recv_find_max_checkpoint(log_group_t**	max_group, ulint*		max_field);
 dberr_t
 srv_undo_tablespaces_init(
 /*======================*/

extra/mariabackup/xtrabackup.h

@@ -182,15 +182,6 @@ datafiles_iter_t *datafiles_iter_new(fil_system_t *f_system);
 fil_node_t *datafiles_iter_next(datafiles_iter_t *it);
 void datafiles_iter_free(datafiles_iter_t *it);
 
-/************************************************************************
-Initialize the tablespace memory cache and populate it by scanning for and
-opening data files */
-ulint xb_data_files_init(void);
-
-/************************************************************************
-Destroy the tablespace memory cache. */
-void xb_data_files_close(void);
-
 /***********************************************************************
 Reads the space flags from a given data file and returns the compressed
 page size, or 0 if the space is not compressed. */

storage/innobase/include/log0log.h

@@ -151,24 +151,24 @@ UNIV_INLINE
 lsn_t
 log_get_max_modified_age_async(void);
 /*================================*/
-/******************************************************//**
-Initializes the log. */
+/** Initializes the redo logging subsystem. */
 void
-log_init(void);
-/*==========*/
-/******************************************************************//**
-Inits a log group to the log system.
-@return true if success, false if not */
-MY_ATTRIBUTE((warn_unused_result))
+log_sys_init();
+
+/** 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);
+/** 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 */
 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 */
+log_set_capacity()
+	MY_ATTRIBUTE((warn_unused_result));
+
 /******************************************************//**
 Completes an i/o to a log file. */
 void
@@ -552,16 +552,12 @@ Currently, this is only protected by log_sys->mutex. However, in the case
 of log_write_up_to(), we will access some members only with the protection
 of log_sys->write_mutex, which should affect nothing for now. */
 struct log_group_t{
-	/** log group identifier (always 0) */
-	ulint				id;
 	/** number of files in the group */
 	ulint				n_files;
 	/** format of the redo log: e.g., LOG_HEADER_FORMAT_CURRENT */
 	ulint				format;
 	/** individual log file size in bytes, including the header */
-	lsn_t				file_size
-	/** file space which implements the log group */;
-	ulint				space_id;
+	lsn_t				file_size;
 	/** corruption status */
 	log_group_state_t		state;
 	/** lsn used to fix coordinates within the log group */
@@ -580,8 +576,6 @@ struct log_group_t{
 	byte*				checkpoint_buf_ptr;
 	/** buffer for writing a checkpoint header */
 	byte*				checkpoint_buf;
-	/** list of log groups */
-	UT_LIST_NODE_T(log_group_t)	log_groups;
 
 	/** @return whether the redo log is encrypted */
 	bool is_encrypted() const
@@ -639,8 +633,8 @@ struct log_t{
 					max_checkpoint_age; this flag is
 					peeked at by log_free_check(), which
 					does not reserve the log mutex */
-	UT_LIST_BASE_NODE_T(log_group_t)
-			log_groups;	/*!< log groups */
+	/** the redo log */
+	log_group_t			log;
 
 	/** The fields involved in the log buffer flush @{ */
 
@@ -729,7 +723,7 @@ struct log_t{
 	/** @return whether the redo log is encrypted */
 	bool is_encrypted() const
 	{
-		return(UT_LIST_GET_FIRST(log_groups)->is_encrypted());
+		return(log.is_encrypted());
 	}
 };
 

storage/innobase/include/log0recv.h

@@ -41,6 +41,13 @@ Created 9/20/1997 Heikki Tuuri
 /** @return whether recovery is currently running. */
 #define recv_recovery_is_on() recv_recovery_on
 
+/** Find the latest checkpoint in the log header.
+@param[out]	max_field	LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2
+@return error code or DB_SUCCESS */
+dberr_t
+recv_find_max_checkpoint(ulint* max_field)
+	MY_ATTRIBUTE((nonnull, warn_unused_result));
+
 /** Apply the hashed log records to the page, if the page lsn is less than the
 lsn of a log record.
 @param just_read_in	whether the page recently arrived to the I/O handler

storage/innobase/log/log0log.cc

@@ -667,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;
@@ -686,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;
 
@@ -747,11 +729,9 @@ log_calc_max_ages(void)
 	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)));
 
@@ -780,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);
@@ -824,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;
@@ -875,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());
 }
 
 /******************************************************//**
@@ -900,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;
@@ -932,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);
@@ -951,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++;
 
@@ -965,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);
@@ -1051,10 +1012,10 @@ log_group_write_buf(
 
 	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
@@ -1092,7 +1053,7 @@ log_group_write_buf(
 		= (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);
@@ -1260,7 +1221,6 @@ log_write_up_to(
 		return;
 	}
 
-	log_group_t*	group;
 	ulint		start_offset;
 	ulint		end_offset;
 	ulint		area_start;
@@ -1304,9 +1264,7 @@ log_write_up_to(
 
 	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. */
@@ -1317,7 +1275,7 @@ log_write_up_to(
 		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
@@ -1336,7 +1294,7 @@ log_write_up_to(
 	}
 	/* 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,
@@ -1539,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;
@@ -1556,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);
@@ -1601,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,
@@ -1626,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);
 }
@@ -1640,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();
 
@@ -2283,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;
 
@@ -2300,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;
 }
 
 /********************************************************//**
@@ -2309,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);
 }
 
 /********************************************************//**

storage/innobase/srv/srv0start.cc

@@ -478,9 +478,8 @@ create_log_files(
 		}
 	}
 
-	if (!log_group_init(0, srv_n_log_files,
-			    srv_log_file_size * UNIV_PAGE_SIZE,
-			    SRV_LOG_SPACE_FIRST_ID)) {
+	log_init(srv_n_log_files, srv_log_file_size * UNIV_PAGE_SIZE);
+	if (!log_set_capacity()) {
 		return(DB_ERROR);
 	}
 
@@ -1835,7 +1834,7 @@ innobase_start_or_create_for_mysql(void)
 #endif /* UNIV_DEBUG */
 
 	fsp_init();
-	log_init();
+	log_sys_init();
 
 	recv_sys_create();
 	recv_sys_init(buf_pool_get_curr_size());
@@ -2091,8 +2090,9 @@ innobase_start_or_create_for_mysql(void)
 			}
 		}
 
-		if (!log_group_init(0, i, srv_log_file_size * UNIV_PAGE_SIZE,
-				    SRV_LOG_SPACE_FIRST_ID)) {
+		log_init(i, srv_log_file_size * UNIV_PAGE_SIZE);
+
+		if (!log_set_capacity()) {
 			return(srv_init_abort(DB_ERROR));
 		}
 	}