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.cc

@@ -564,7 +564,6 @@ enum options_xtrabackup
   OPT_INNODB_LOG_BUFFER_SIZE,
   OPT_INNODB_LOG_FILE_SIZE,
   OPT_INNODB_LOG_FILES_IN_GROUP,
-  OPT_INNODB_MIRRORED_LOG_GROUPS,
   OPT_INNODB_OPEN_FILES,
   OPT_INNODB_SYNC_SPIN_LOOPS,
   OPT_INNODB_THREAD_CONCURRENCY,
@@ -2605,96 +2604,6 @@ xtrabackup_copy_datafile(fil_node_t* node, uint thread_n)
 	return(FALSE);
 }
 
-static
-void
-xtrabackup_choose_lsn_offset(lsn_t start_lsn)
-{
-#if SUPPORT_PERCONA_5_5
-	ulint no, alt_no, expected_no;
-	ulint blocks_in_group;
-	lsn_t tmp_offset, end_lsn;
-	int lsn_chosen = 0;
-	log_group_t *group;
-
-	start_lsn = ut_uint64_align_down(start_lsn, OS_FILE_LOG_BLOCK_SIZE);
-	end_lsn = start_lsn + RECV_SCAN_SIZE;
-
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	if (mysql_server_version < 50500 || mysql_server_version > 50600) {
-		/* only make sense for Percona Server 5.5 */
-		return;
-	}
-
-	if (server_flavor == FLAVOR_PERCONA_SERVER) {
-		/* it is Percona Server 5.5 */
-		group->alt_offset_chosen = true;
-		group->lsn_offset = group->lsn_offset_alt;
-		return;
-	}
-
-	if (group->lsn_offset_alt == group->lsn_offset ||
-	    group->lsn_offset_alt == (lsn_t) -1) {
-		/* we have only one option */
-		return;
-	}
-
-	no = alt_no = (ulint) -1;
-	lsn_chosen = 0;
-
-	blocks_in_group = log_block_convert_lsn_to_no(
-		log_group_get_capacity(group)) - 1;
-
-	/* read log block number from usual offset */
-	if (group->lsn_offset < group->file_size * group->n_files &&
-	    (log_group_calc_lsn_offset(start_lsn, group) %
-	     UNIV_PAGE_SIZE) % OS_MIN_LOG_BLOCK_SIZE == 0) {
-		log_group_read_log_seg(LOG_RECOVER, log_sys->buf,
-				       group, start_lsn, end_lsn);
-		no = log_block_get_hdr_no(log_sys->buf);
-	}
-
-	/* read log block number from Percona Server 5.5 offset */
-	tmp_offset = group->lsn_offset;
-	group->lsn_offset = group->lsn_offset_alt;
-
-	if (group->lsn_offset < group->file_size * group->n_files &&
-	    (log_group_calc_lsn_offset(start_lsn, group) %
-	     UNIV_PAGE_SIZE) % OS_MIN_LOG_BLOCK_SIZE == 0) {
-		log_group_read_log_seg(LOG_RECOVER, log_sys->buf,
-				       group, start_lsn, end_lsn);
-		alt_no = log_block_get_hdr_no(log_sys->buf);
-	}
-
-	expected_no = log_block_convert_lsn_to_no(start_lsn);
-
-	ut_a(!(no == expected_no && alt_no == expected_no));
-
-	group->lsn_offset = tmp_offset;
-
-	if ((no <= expected_no &&
-		((expected_no - no) % blocks_in_group) == 0) ||
-	    ((expected_no | 0x40000000UL) - no) % blocks_in_group == 0) {
-		/* default offset looks ok */
-		++lsn_chosen;
-	}
-
-	if ((alt_no <= expected_no &&
-		((expected_no - alt_no) % blocks_in_group) == 0) ||
-	    ((expected_no | 0x40000000UL) - alt_no) % blocks_in_group == 0) {
-		/* PS 5.5 style offset looks ok */
-		++lsn_chosen;
-		group->alt_offset_chosen = true;
-		group->lsn_offset = group->lsn_offset_alt;
-	}
-
-	/* We are in trouble, because we can not make a
-	decision to choose one over the other. Die just
-	like a Buridan's ass */
-	ut_a(lsn_chosen == 1);
-#endif
-}
-
 extern ibool log_block_checksum_is_ok_or_old_format(const byte*	block);
 
 /*******************************************************//**
@@ -2862,8 +2771,6 @@ static my_bool
 xtrabackup_copy_logfile(lsn_t from_lsn, my_bool is_last)
 {
 	/* definition from recv_recovery_from_checkpoint_start() */
-	log_group_t*	group;
-	lsn_t		group_scanned_lsn;
 	lsn_t		contiguous_lsn;
 
 	ut_a(dst_log_file != NULL);
@@ -2873,66 +2780,50 @@ xtrabackup_copy_logfile(lsn_t from_lsn, my_bool is_last)
 
 	/* TODO: We must check the contiguous_lsn still exists in log file.. */
 
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	while (group) {
 	bool	finished;
 	lsn_t	start_lsn;
 	lsn_t	end_lsn;
 
 	/* reference recv_group_scan_log_recs() */
-		finished = false;
 
 	start_lsn = contiguous_lsn;
 
-		while (!finished) {
-
+	do {
 		end_lsn = start_lsn + RECV_SCAN_SIZE;
 
 		xtrabackup_io_throttling();
 
-			mutex_enter(&log_sys->mutex);
+		log_mutex_enter();
 
 		log_group_read_log_seg(LOG_RECOVER, log_sys->buf,
-					       group, start_lsn, end_lsn, false);
-
-			 if (!xtrabackup_scan_log_recs(group, is_last,
-				start_lsn, &contiguous_lsn, &group_scanned_lsn,
-				&finished)) {
-				goto error;
-			 }
+				       &log_sys->log, start_lsn, end_lsn);
 
-			mutex_exit(&log_sys->mutex);
+		bool success = xtrabackup_scan_log_recs(
+			&log_sys->log, is_last,
+			start_lsn, &contiguous_lsn,
+			&log_sys->log.scanned_lsn,
+			&finished);
 
-			start_lsn = end_lsn;
+		log_mutex_exit();
 
+		if (!success) {
+			ds_close(dst_log_file);
+			msg("xtrabackup: Error: xtrabackup_copy_logfile()"
+			    " failed.\n");
+			return(TRUE);
 		}
 
-		group->scanned_lsn = group_scanned_lsn;
+		start_lsn = end_lsn;
+	} while (!finished);
 
 	msg_ts(">> log scanned up to (" LSN_PF ")\n",
-		       group->scanned_lsn);
-
-		group = UT_LIST_GET_NEXT(log_groups, group);
+	       log_sys->log.scanned_lsn);
 
 	/* update global variable*/
-		log_copy_scanned_lsn = group_scanned_lsn;
-
-		/* innodb_mirrored_log_groups must be 1, no other groups */
-		ut_a(group == NULL);
+	log_copy_scanned_lsn = log_sys->log.scanned_lsn;
 
 	debug_sync_point("xtrabackup_copy_logfile_pause");
-
-	}
-
-
 	return(FALSE);
-
-error:
-	mutex_exit(&log_sys->mutex);
-	ds_close(dst_log_file);
-	msg("xtrabackup: Error: xtrabackup_copy_logfile() failed.\n");
-	return(TRUE);
 }
 
 static
@@ -3244,13 +3135,12 @@ xb_fil_io_init(void)
 Populates the tablespace memory cache by scanning for and opening data files.
 @returns DB_SUCCESS or error code.*/
 static
-ulint
-xb_load_tablespaces(void)
-/*=====================*/
+dberr_t
+xb_load_tablespaces()
 {
 	ulint	i;
 	ibool	create_new_db;
-	ulint	err;
+	dberr_t	err;
 	ulint   sum_of_new_sizes;
 	lsn_t min_arch_logno, max_arch_logno;
 
@@ -3321,9 +3211,9 @@ xb_load_tablespaces(void)
 Initialize the tablespace memory cache and populate it by scanning for and
 opening data files.
 @returns DB_SUCCESS or error code.*/
-ulint
-xb_data_files_init(void)
-/*====================*/
+static
+dberr_t
+xb_data_files_init()
 {
 	xb_fil_io_init();
 
@@ -3332,9 +3222,9 @@ xb_data_files_init(void)
 
 /************************************************************************
 Destroy the tablespace memory cache. */
+static
 void
-xb_data_files_close(void)
-/*====================*/
+xb_data_files_close()
 {
 	ulint	i;
 
@@ -3745,7 +3635,6 @@ open_or_create_log_file(
 	ibool	log_file_has_been_opened,/*!< in: TRUE if a log file has been
 					opened before: then it is an error
 					to try to create another log file */
-	ulint	k,			/*!< in: log group number */
 	ulint	i)			/*!< in: log file number in group */
 {
 	ibool	ret;
@@ -3755,8 +3644,6 @@ open_or_create_log_file(
 
 	UT_NOT_USED(create_new_db);
 	UT_NOT_USED(log_file_has_been_opened);
-	UT_NOT_USED(k);
-	ut_ad(k == 0);
 
 	*log_file_created = FALSE;
 
@@ -3804,20 +3691,14 @@ open_or_create_log_file(
 		which is for this log group */
 
 		fil_space_create(name,
-				 2 * k + SRV_LOG_SPACE_FIRST_ID, 0, FIL_LOG, 0, 0);
+				 SRV_LOG_SPACE_FIRST_ID, 0, FIL_TYPE_LOG, 0, 0);
+		log_init(srv_n_log_files, srv_log_file_size * UNIV_PAGE_SIZE);
 	}
 
 	ut_a(fil_validate());
 
 	ut_a(fil_node_create(name, (ulint)srv_log_file_size,
-			     2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE));
-	if (i == 0) {
-		log_group_init(k, srv_n_log_files,
-			       srv_log_file_size * UNIV_PAGE_SIZE,
-			       2 * k + SRV_LOG_SPACE_FIRST_ID,
-			       SRV_LOG_SPACE_FIRST_ID + 1); /* dummy arch
-							    space id */
-	}
+			     SRV_LOG_SPACE_FIRST_ID, FALSE));
 
 	return(DB_SUCCESS);
 }
@@ -3911,7 +3792,7 @@ xtrabackup_backup_func(void)
 	lsn_t			 latest_cp;
 	uint			 i;
 	uint			 count;
-	os_ib_mutex_t		 count_mutex;
+	pthread_mutex_t		 count_mutex;
 	data_thread_ctxt_t 	*data_threads;
 
 #ifdef USE_POSIX_FADVISE
@@ -4031,13 +3912,13 @@ xtrabackup_backup_func(void)
 
 	xb_fil_io_init();
 
-	log_init();
+	log_sys_init();
 
 	lock_sys_create(srv_lock_table_size);
 
 	for (i = 0; i < srv_n_log_files; i++) {
 		err = open_or_create_log_file(FALSE, &log_file_created,
-					      log_opened, 0, i);
+					      log_opened, i);
 		if (err != DB_SUCCESS) {
 
 			//return((int) err);
@@ -4092,72 +3973,60 @@ xtrabackup_backup_func(void)
         fil_system_t*   f_system = fil_system;
 
 	/* definition from recv_recovery_from_checkpoint_start() */
-	log_group_t*	max_cp_group;
 	ulint		max_cp_field;
-	byte*		buf;
-	byte*		log_hdr_buf_;
-	byte*		log_hdr_buf;
-	ulint		err;
 
 	/* start back ground thread to copy newer log */
 	os_thread_id_t log_copying_thread_id;
 	datafiles_iter_t *it;
 
-	log_hdr_buf_ = static_cast<byte *>
-		(ut_malloc(LOG_FILE_HDR_SIZE + UNIV_PAGE_SIZE_MAX));
-	log_hdr_buf = static_cast<byte *>
-		(ut_align(log_hdr_buf_, UNIV_PAGE_SIZE_MAX));
-
 	/* get current checkpoint_lsn */
 	/* Look for the latest checkpoint from any of the log groups */
 
-	mutex_enter(&log_sys->mutex);
+	log_mutex_enter();
 
-	err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
+	dberr_t err = recv_find_max_checkpoint(&max_cp_field);
 
 	if (err != DB_SUCCESS) {
+		exit(EXIT_FAILURE);
+	}
 
-		ut_free(log_hdr_buf_);
+	if (log_sys->log.format == 0) {
+old_format:
+		msg("xtrabackup: Error: cannot process redo log"
+		    " before MariaDB 10.2.2\n");
 		exit(EXIT_FAILURE);
 	}
 
-	log_group_read_checkpoint_info(max_cp_group, max_cp_field);
-	buf = log_sys->checkpoint_buf;
+	ut_ad(!((log_sys->log.format ^ LOG_HEADER_FORMAT_CURRENT)
+		& ~LOG_HEADER_FORMAT_ENCRYPTED));
+
+	const byte* buf = log_sys->checkpoint_buf;
 
 	checkpoint_lsn_start = mach_read_from_8(buf + LOG_CHECKPOINT_LSN);
 	checkpoint_no_start = mach_read_from_8(buf + LOG_CHECKPOINT_NO);
 
-	mutex_exit(&log_sys->mutex);
-
 reread_log_header:
-	fil_io(OS_FILE_READ | OS_FILE_LOG, true, max_cp_group->space_id,
-				0,
-				0, 0, LOG_FILE_HDR_SIZE,
-				log_hdr_buf, max_cp_group, NULL);
-
-	/* check consistency of log file header to copy */
-	mutex_enter(&log_sys->mutex);
-
-	err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
+	err = recv_find_max_checkpoint(&max_cp_field);
 
 	if (err != DB_SUCCESS) {
-
-		ut_free(log_hdr_buf_);
 		exit(EXIT_FAILURE);
 	}
 
-        log_group_read_checkpoint_info(max_cp_group, max_cp_field);
-        buf = log_sys->checkpoint_buf;
+	if (log_sys->log.format == 0) {
+		goto old_format;
+	}
+
+	ut_ad(!((log_sys->log.format ^ LOG_HEADER_FORMAT_CURRENT)
+		& ~LOG_HEADER_FORMAT_ENCRYPTED));
 
 	if(checkpoint_no_start != mach_read_from_8(buf + LOG_CHECKPOINT_NO)) {
 
 		checkpoint_lsn_start = mach_read_from_8(buf + LOG_CHECKPOINT_LSN);
 		checkpoint_no_start = mach_read_from_8(buf + LOG_CHECKPOINT_NO);
-		mutex_exit(&log_sys->mutex);
 		goto reread_log_header;
 	}
 
-	mutex_exit(&log_sys->mutex);
+	log_mutex_exit();
 
 	xtrabackup_init_datasinks();
 
@@ -4204,10 +4073,6 @@ xtrabackup_backup_func(void)
 				 &io_watching_thread_id);
 	}
 
-	mutex_enter(&log_sys->mutex);
-	xtrabackup_choose_lsn_offset(checkpoint_lsn_start);
-	mutex_exit(&log_sys->mutex);
-
 	/* copy log file by current position */
 	if(xtrabackup_copy_logfile(checkpoint_lsn_start, FALSE))
 		exit(EXIT_FAILURE);
@@ -4220,7 +4085,7 @@ xtrabackup_backup_func(void)
 	err = xb_load_tablespaces();
 	if (err != DB_SUCCESS) {
 		msg("xtrabackup: error: xb_load_tablespaces() failed with"
-		    "error code %lu\n", err);
+		    "error code %u\n", err);
 		exit(EXIT_FAILURE);
 	}
 
@@ -4297,35 +4162,24 @@ xtrabackup_backup_func(void)
 	}
 
 	/* read the latest checkpoint lsn */
-	latest_cp = 0;
 	{
-		log_group_t*	max_cp_group;
 		ulint	max_cp_field;
-		ulint	err;
-
-		mutex_enter(&log_sys->mutex);
 
-		err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
-
-		if (err != DB_SUCCESS) {
-			msg("xtrabackup: Error: recv_find_max_checkpoint() failed.\n");
-			mutex_exit(&log_sys->mutex);
-			goto skip_last_cp;
-		}
-
-		log_group_read_checkpoint_info(max_cp_group, max_cp_field);
-
-		xtrabackup_choose_lsn_offset(checkpoint_lsn_start);
+		log_mutex_enter();
 
+		if (recv_find_max_checkpoint(&max_cp_field) == DB_SUCCESS
+		    && log_sys->log.format != 0) {
 			latest_cp = mach_read_from_8(log_sys->checkpoint_buf +
 						     LOG_CHECKPOINT_LSN);
-
-		mutex_exit(&log_sys->mutex);
-
-		msg("xtrabackup: The latest check point (for incremental): "
-		    "'" LSN_PF "'\n", latest_cp);
+			msg("xtrabackup: The latest check point"
+			    " (for incremental): '" LSN_PF "'\n", latest_cp);
+		} else {
+			latest_cp = 0;
+			msg("xtrabackup: Error: recv_find_max_checkpoint() failed.\n");
+		}
+		log_mutex_exit();
 	}
-skip_last_cp:
+
 	/* stop log_copying_thread */
 	log_copying = FALSE;
 	os_event_set(log_copying_stop);

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;
-
-	group = static_cast<log_group_t*>(ut_malloc_nokey(sizeof(log_group_t)));
+	log_group_t*	group = &log_sys->log;
 
-	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/log/log0recv.cc

@@ -717,7 +717,7 @@ log_group_read_log_seg(
 		= (ulint) (source_offset / univ_page_size.physical());
 
 	fil_io(IORequestLogRead, true,
-	       page_id_t(group->space_id, page_no),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID, page_no),
 	       univ_page_size,
 	       (ulint) (source_offset % univ_page_size.physical()),
 	       len, buf, NULL);
@@ -787,20 +787,13 @@ recv_synchronize_groups()
 
 	const lsn_t start_lsn = ut_uint64_align_down(recovered_lsn,
 						     OS_FILE_LOG_BLOCK_SIZE);
-	log_group_read_log_seg(log_sys->buf,
-			       UT_LIST_GET_FIRST(log_sys->log_groups),
+	log_group_read_log_seg(log_sys->buf, &log_sys->log,
 			       start_lsn, start_lsn + OS_FILE_LOG_BLOCK_SIZE);
 
-	ut_ad(UT_LIST_GET_LEN(log_sys->log_groups) == 1);
-
-	for (log_group_t* group = UT_LIST_GET_FIRST(log_sys->log_groups);
-	     group;
-	     group = UT_LIST_GET_NEXT(log_groups, group)) {
 	/* Update the fields in the group struct to correspond to
 	recovered_lsn */
 
-		log_group_set_fields(group, recovered_lsn);
-	}
+	log_group_set_fields(&log_sys->log, recovered_lsn);
 
 	/* Copy the checkpoint info to the log; remember that we have
 	incremented checkpoint_no by one, and the info will not be written
@@ -831,17 +824,14 @@ recv_check_log_header_checksum(
 @return error code or DB_SUCCESS */
 static MY_ATTRIBUTE((warn_unused_result))
 dberr_t
-recv_find_max_checkpoint_0(
-	log_group_t**	max_group,
-	ulint*		max_field)
+recv_find_max_checkpoint_0(log_group_t** max_group, ulint* max_field)
 {
-	log_group_t*	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+	log_group_t*	group = &log_sys->log;
 	ib_uint64_t	max_no = 0;
 	ib_uint64_t	checkpoint_no;
 	byte*		buf	= log_sys->checkpoint_buf;
 
 	ut_ad(group->format == 0);
-	ut_ad(UT_LIST_GET_NEXT(log_groups, group) == NULL);
 
 	/** Offset of the first checkpoint checksum */
 	static const uint CHECKSUM_1 = 288;
@@ -852,6 +842,8 @@ recv_find_max_checkpoint_0(
 	/** Least significant bits of the checkpoint offset */
 	static const uint OFFSET_LOW32 = 16;
 
+	*max_group = NULL;
+
 	for (ulint field = LOG_CHECKPOINT_1; field <= LOG_CHECKPOINT_2;
 	     field += LOG_CHECKPOINT_2 - LOG_CHECKPOINT_1) {
 		log_group_header_read(group, field);
@@ -883,9 +875,8 @@ recv_find_max_checkpoint_0(
 		}
 
 		DBUG_PRINT("ib_log",
-			   ("checkpoint " UINT64PF " at " LSN_PF
-			    " found in group " ULINTPF,
-			    checkpoint_no, group->lsn, group->id));
+			   ("checkpoint " UINT64PF " at " LSN_PF " found",
+			    checkpoint_no, group->lsn));
 
 		if (checkpoint_no >= max_no) {
 			*max_group = group;
@@ -916,7 +907,7 @@ dberr_t
 recv_log_format_0_recover(lsn_t lsn)
 {
 	log_mutex_enter();
-	log_group_t*	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+	log_group_t*	group = &log_sys->log;
 	const lsn_t	source_offset
 		= log_group_calc_lsn_offset(lsn, group);
 	log_mutex_exit();
@@ -932,7 +923,7 @@ recv_log_format_0_recover(lsn_t lsn)
 		REFMAN "upgrading.html";
 
 	fil_io(IORequestLogRead, true,
-	       page_id_t(group->space_id, page_no),
+	       page_id_t(SRV_LOG_SPACE_FIRST_ID, page_no),
 	       univ_page_size,
 	       (ulint) ((source_offset & ~(OS_FILE_LOG_BLOCK_SIZE - 1))
 			% univ_page_size.physical()),
@@ -968,14 +959,10 @@ recv_log_format_0_recover(lsn_t lsn)
 }
 
 /** Find the latest checkpoint in the log header.
-@param[out]	max_group	log group, or NULL
 @param[out]	max_field	LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2
 @return error code or DB_SUCCESS */
-static MY_ATTRIBUTE((warn_unused_result))
 dberr_t
-recv_find_max_checkpoint(
-	log_group_t**	max_group,
-	ulint*		max_field)
+recv_find_max_checkpoint(ulint* max_field)
 {
 	log_group_t*	group;
 	ib_uint64_t	max_no;
@@ -983,15 +970,13 @@ recv_find_max_checkpoint(
 	ulint		field;
 	byte*		buf;
 
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+	group = &log_sys->log;
 
 	max_no = 0;
-	*max_group = NULL;
 	*max_field = 0;
 
 	buf = log_sys->checkpoint_buf;
 
-	while (group) {
 	group->state = LOG_GROUP_CORRUPTED;
 
 	log_group_header_read(group, 0);
@@ -1006,8 +991,7 @@ recv_find_max_checkpoint(
 
 	switch (group->format) {
 	case 0:
-			return(recv_find_max_checkpoint_0(
-				       max_group, max_field));
+		return(recv_find_max_checkpoint_0(&group, max_field));
 	case LOG_HEADER_FORMAT_CURRENT:
 	case LOG_HEADER_FORMAT_CURRENT | LOG_HEADER_FORMAT_ENCRYPTED:
 		break;
@@ -1038,11 +1022,10 @@ recv_find_max_checkpoint(
 		if (crc32 != cksum) {
 			DBUG_PRINT("ib_log",
 				   ("invalid checkpoint,"
-					    " group " ULINTPF " at " ULINTPF
-					    ", checksum %x expected %x",
-					    group->id, field,
-					    (unsigned) cksum,
-					    (unsigned) crc32));
+				    " at " ULINTPF
+				    ", checksum " ULINTPFx
+				    " expected " ULINTPFx,
+				    field, cksum, crc32));
 			continue;
 		}
 
@@ -1063,21 +1046,16 @@ recv_find_max_checkpoint(
 			buf + LOG_CHECKPOINT_NO);
 
 		DBUG_PRINT("ib_log",
-				   ("checkpoint " UINT64PF " at " LSN_PF
-				    " found in group " ULINTPF,
-				    checkpoint_no, group->lsn, group->id));
+			   ("checkpoint " UINT64PF " at " LSN_PF " found ",
+			    checkpoint_no, group->lsn));
 
 		if (checkpoint_no >= max_no) {
-				*max_group = group;
 			*max_field = field;
 			max_no = checkpoint_no;
 		}
 	}
 
-		group = UT_LIST_GET_NEXT(log_groups, group);
-	}
-
-	if (*max_group == NULL) {
+	if (*max_field == 0) {
 		/* Before 5.7.9, we could get here during database
 		initialization if we created an ib_logfile0 file that
 		was filled with zeroes, and were killed. After
@@ -1798,8 +1776,7 @@ recv_recover_page(bool just_read_in, buf_block_t* block)
 	while (recv) {
 		end_lsn = recv->end_lsn;
 
-		ut_ad(end_lsn
-		      <= UT_LIST_GET_FIRST(log_sys->log_groups)->scanned_lsn);
+		ut_ad(end_lsn <= log_sys->log.scanned_lsn);
 
 		if (recv->len > RECV_DATA_BLOCK_SIZE) {
 			/* We have to copy the record body to a separate
@@ -2988,10 +2965,9 @@ recv_group_scan_log_recs(
 		DBUG_RETURN(false);
 	}
 
-	DBUG_PRINT("ib_log", ("%s " LSN_PF
-			      " completed for log group " ULINTPF,
+	DBUG_PRINT("ib_log", ("%s " LSN_PF " completed",
 			      last_phase ? "rescan" : "scan",
-			      group->scanned_lsn, group->id));
+			      group->scanned_lsn));
 
 	DBUG_RETURN(store_to_hash == STORE_NO);
 }
@@ -3142,11 +3118,9 @@ recv_init_crash_recovery_spaces()
 of first system tablespace page
 @return error code or DB_SUCCESS */
 dberr_t
-recv_recovery_from_checkpoint_start(
-	lsn_t	flush_lsn)
+recv_recovery_from_checkpoint_start(lsn_t flush_lsn)
 {
 	log_group_t*	group;
-	log_group_t*	max_cp_group;
 	ulint		max_cp_field;
 	lsn_t		checkpoint_lsn;
 	bool		rescan;
@@ -3172,14 +3146,14 @@ recv_recovery_from_checkpoint_start(
 
 	/* Look for the latest checkpoint from any of the log groups */
 
-	err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
+	err = recv_find_max_checkpoint(&max_cp_field);
 
 	if (err != DB_SUCCESS) {
 		log_mutex_exit();
 		return(err);
 	}
 
-	log_group_header_read(max_cp_group, max_cp_field);
+	log_group_header_read(&log_sys->log, max_cp_field);
 
 	buf = log_sys->checkpoint_buf;
 
@@ -3194,8 +3168,7 @@ recv_recovery_from_checkpoint_start(
 
 	ut_ad(RECV_SCAN_SIZE <= log_sys->buf_size);
 
-	ut_ad(UT_LIST_GET_LEN(log_sys->log_groups) == 1);
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+	group = &log_sys->log;
 	const lsn_t	end_lsn = mach_read_from_8(
 		buf + LOG_CHECKPOINT_END_LSN);
 
@@ -3483,11 +3456,8 @@ recv_reset_logs(
 
 	log_sys->lsn = ut_uint64_align_up(lsn, OS_FILE_LOG_BLOCK_SIZE);
 
-	for (log_group_t* group = UT_LIST_GET_FIRST(log_sys->log_groups);
-	     group; group = UT_LIST_GET_NEXT(log_groups, group)) {
-		group->lsn = log_sys->lsn;
-		group->lsn_offset = LOG_FILE_HDR_SIZE;
-	}
+	log_sys->log.lsn = log_sys->lsn;
+	log_sys->log.lsn_offset = LOG_FILE_HDR_SIZE;
 
 	log_sys->buf_next_to_write = 0;
 	log_sys->write_lsn = log_sys->lsn;

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));
 		}
 	}