Commit 86927cc7 authored by Marko Mäkelä's avatar Marko Mäkelä

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).
parent ed2976ca
......@@ -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(
/*======================*/
......
This diff is collapsed.
......@@ -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. */
......
......@@ -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());
}
};
......
......@@ -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
......
......@@ -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);
}
/********************************************************//**
......
......@@ -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;
......
......@@ -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));
}
}
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment