mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-15 03:17:20 +02:00
Code Issues Projects Releases Packages Wiki Activity

Remove traces of multiple InnoDB redo logs

Browse source 
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).
This commit is contained in:
Marko Mäkelä 2017-05-26 14:04:19 +03:00
commit 86927cc712
8 changed files with 238 additions and 480 deletions
Download patch file Download diff file Expand all files Collapse all files

1
extra/mariabackup/xb0xb.h
View file

@ -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(
/*======================*/

302
extra/mariabackup/xtrabackup.cc
View file

@ -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 @@ skip:
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);
bool finished;
lsn_t start_lsn;
lsn_t end_lsn;
while (group) {
bool finished;
lsn_t start_lsn;
lsn_t end_lsn;
/* reference recv_group_scan_log_recs() */
/* reference recv_group_scan_log_recs() */
finished = false;
start_lsn = contiguous_lsn;
start_lsn = contiguous_lsn;
do {
end_lsn = start_lsn + RECV_SCAN_SIZE;
while (!finished) {
xtrabackup_io_throttling();
end_lsn = start_lsn + RECV_SCAN_SIZE;
log_mutex_enter();
xtrabackup_io_throttling();
log_group_read_log_seg(LOG_RECOVER, log_sys->buf,
&log_sys->log, start_lsn, end_lsn);
mutex_enter(&log_sys->mutex);
bool success = xtrabackup_scan_log_recs(
&log_sys->log, is_last,
start_lsn, &contiguous_lsn,
&log_sys->log.scanned_lsn,
&finished);
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;
}
mutex_exit(&log_sys->mutex);
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);
/* update global variable*/
log_copy_scanned_lsn = group_scanned_lsn;
/* innodb_mirrored_log_groups must be 1, no other groups */
ut_a(group == NULL);
debug_sync_point("xtrabackup_copy_logfile_pause");
}
msg_ts(">> log scanned up to (" LSN_PF ")\n",
log_sys->log.scanned_lsn);
/* update global variable*/
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) {
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) {
old_format:
msg("xtrabackup: Error: cannot process redo log"
" before MariaDB 10.2.2\n");
exit(EXIT_FAILURE);
}
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);
err = recv_find_max_checkpoint(&max_cp_field);
/* check consistency of log file header to copy */
mutex_enter(&log_sys->mutex);
if (err != DB_SUCCESS) {
exit(EXIT_FAILURE);
}
err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
if (log_sys->log.format == 0) {
goto old_format;
}
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;
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 @@ reread_log_header:
&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 @@ reread_log_header:
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 @@ reread_log_header:
}
/* 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);
log_mutex_enter();
err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
if (err != DB_SUCCESS) {
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);
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");
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);
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);
log_mutex_exit();
}
skip_last_cp:
/* stop log_copying_thread */
log_copying = FALSE;
os_event_set(log_copying_stop);

9
extra/mariabackup/xtrabackup.h
View file

@ -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. */