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

MDEV-34705: Binlog-in-engine: Use separate 4k pagesize for binlog files

Browse source 
Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
This commit is contained in:
Kristian Nielsen 2025-03-24 10:32:49 +01:00
commit 881ed99f8f
5 changed files with 98 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

5
mysql-test/suite/binlog_in_engine/binlog_flush_purge.result
View file

@ -18,7 +18,7 @@ binlog-000001.ibb 262144
FLUSH BINARY LOGS;
SHOW BINARY LOGS;
Log_name File_size
binlog-000000.ibb 49152
binlog-000000.ibb 36864
binlog-000001.ibb 262144
binlog-000002.ibb 262144
SET STATEMENT sql_log_bin=0 FOR
@ -57,10 +57,10 @@ SET SESSION binlog_format= ROW;
*** Do 1500 transactions ...
SHOW BINARY LOGS;
Log_name File_size
binlog-000010.ibb 262144
binlog-000011.ibb 262144
binlog-000012.ibb 262144
binlog-000013.ibb 262144
binlog-000014.ibb 262144
*** Test purge by date.
SET GLOBAL max_binlog_total_size= 0;
SET @old_expire= @@GLOBAL.binlog_expire_logs_seconds;
@ -70,7 +70,6 @@ SET GLOBAL binlog_expire_logs_seconds= 0;
*** Do 1000 transactions ...
SHOW BINARY LOGS;
Log_name File_size
binlog-000012.ibb 262144
binlog-000013.ibb 262144
binlog-000014.ibb 262144
binlog-000015.ibb 262144

6
mysql-test/suite/binlog_in_engine/binlog_flush_purge.test
View file

@ -92,11 +92,11 @@ while ($i < $num_trx) {
#
# In this case, just check that the general structure of the present binlogs
# is similar, and then update the $binlog_name waited for and the .result file.
--let $binlog_name= binlog-000009.ibb
--let $binlog_name= binlog-000010.ibb
--let $binlog_size= 262144
--let $wait_notfound= 1
--source include/wait_for_engine_binlog.inc
--let $binlog_name= binlog-000013.ibb
--let $binlog_name= binlog-000014.ibb
--let $binlog_size= 262144
--source include/wait_for_engine_binlog.inc
SHOW BINARY LOGS;
@ -117,7 +117,7 @@ while ($i < $num_insert) {
}
COMMIT;
--enable_query_log
--let $binlog_name= binlog-000011.ibb
--let $binlog_name= binlog-000012.ibb
--let $binlog_size= 262144
--let $wait_notfound= 1
--source include/wait_for_engine_binlog.inc

82
storage/innobase/fsp/fsp_binlog.cc
View file

@ -32,6 +32,24 @@ InnoDB implementation of binlog.
#include "log.h"
/*
The page size used for binlog pages.
For now, we just use a 4k page size. It could be changed later to be
configurable, changing the page size of the binlog is much easier than for
normal InnoDB tablespaces, as we could simply flush out the current file and
create the next file with a different page size, just need to put the page
size somewhere in the file header.
On the other hand, the page size does not seem to be very significant for
performance or anything. All data can be split across to the next page, and
everything is written in sequence through the kernel buffer cache which is
then free to flush it to disk in whatever chunk sizes it wants.
*/
uint32_t ibb_page_size_shift= 12;
ulong ibb_page_size= (1 << ibb_page_size_shift);
/*
How often (in terms of pages written) to dump a (differential) binlog state
at the start of the page, to speed up finding the initial GTID position for
@ -109,9 +127,9 @@ fsp_binlog_page_fifo::create_page(uint64_t file_no, uint32_t page_no)
fsp_binlog_page_entry *e= (fsp_binlog_page_entry *)ut_malloc(sizeof(*e), mem_key_binlog);
ut_a(e);
e->next= nullptr;
e->page_buf= static_cast<byte*>(aligned_malloc(srv_page_size, srv_page_size));
e->page_buf= static_cast<byte*>(aligned_malloc(ibb_page_size, ibb_page_size));
ut_a(e->page_buf);
memset(e->page_buf, 0, srv_page_size);
memset(e->page_buf, 0, ibb_page_size);
e->file_no= file_no;
e->page_no= page_no;
e->last_page= (page_no + 1 == size_in_pages(file_no));
@ -254,7 +272,7 @@ fsp_binlog_page_fifo::flush_one_page(uint64_t file_no, bool force)
File fh= get_fh(file_no);
ut_a(pl->fh >= (File)0);
size_t res= crc32_pwrite_page(fh, e->page_buf, page_no, MYF(MY_WME));
ut_a(res == srv_page_size);
ut_a(res == ibb_page_size);
e->flushed_clean= true;
}
mysql_mutex_lock(&m_mutex);
@ -394,9 +412,9 @@ fsp_binlog_page_fifo::create_tablespace(uint64_t file_no,
ut_a(e);
e->next= nullptr;
e->page_buf=
static_cast<byte*>(aligned_malloc(srv_page_size, srv_page_size));
static_cast<byte*>(aligned_malloc(ibb_page_size, ibb_page_size));
ut_a(e->page_buf);
memcpy(e->page_buf, partial_page, srv_page_size);
memcpy(e->page_buf, partial_page, ibb_page_size);
e->file_no= file_no;
e->page_no= init_page;
e->last_page= (init_page + 1 == size_in_pages);
@ -578,25 +596,25 @@ fsp_binlog_page_fifo::flush_thread_run()
size_t
crc32_pwrite_page(File fd, byte *buf, uint32_t page_no, myf MyFlags) noexcept
{
const uint32_t payload= (uint32_t)srv_page_size - BINLOG_PAGE_CHECKSUM;
const uint32_t payload= (uint32_t)ibb_page_size - BINLOG_PAGE_CHECKSUM;
mach_write_to_4(buf + payload, my_crc32c(0, buf, payload));
return my_pwrite(fd, (const uchar *)buf, srv_page_size,
(my_off_t)page_no << srv_page_size_shift, MyFlags);
return my_pwrite(fd, (const uchar *)buf, ibb_page_size,
(my_off_t)page_no << ibb_page_size_shift, MyFlags);
}
size_t
crc32_pread_page(File fd, byte *buf, uint32_t page_no, myf MyFlags) noexcept
{
size_t res= my_pread(fd, buf, srv_page_size,
(my_off_t)page_no << srv_page_size_shift, MyFlags);
if (UNIV_LIKELY(res == srv_page_size))
size_t res= my_pread(fd, buf, ibb_page_size,
(my_off_t)page_no << ibb_page_size_shift, MyFlags);
if (UNIV_LIKELY(res == ibb_page_size))
{
const uint32_t payload= (uint32_t)srv_page_size - BINLOG_PAGE_CHECKSUM;
const uint32_t payload= (uint32_t)ibb_page_size - BINLOG_PAGE_CHECKSUM;
uint32_t crc32= mach_read_from_4(buf + payload);
/* Allow a completely zero (empty) page as well. */
if (UNIV_UNLIKELY(crc32 != my_crc32c(0, buf, payload)) &&
(buf[0] != 0 || 0 != memcmp(buf, buf+1, srv_page_size - 1)))
(buf[0] != 0 || 0 != memcmp(buf, buf+1, ibb_page_size - 1)))
{
res= -1;
my_errno= EIO;
@ -642,7 +660,7 @@ fsp_log_binlog_write(mtr_t *mtr, fsp_binlog_page_entry *page,
{
uint64_t file_no= page->file_no;
uint32_t page_no= page->page_no;
if (page_offset + len >= srv_page_size - BINLOG_PAGE_DATA_END)
if (page_offset + len >= ibb_page_size - BINLOG_PAGE_DATA_END)
page->complete= true;
if (page->flushed_clean)
{
@ -713,10 +731,10 @@ fsp_binlog_open(const char *file_name, pfs_os_file_t fh,
uint64_t file_no, size_t file_size,
uint32_t init_page, byte *partial_page)
{
const uint32_t page_size= (uint32_t)srv_page_size;
const uint32_t page_size_shift= srv_page_size_shift;
const uint32_t page_size= (uint32_t)ibb_page_size;
const uint32_t page_size_shift= ibb_page_size_shift;
os_offset_t binlog_size= innodb_binlog_size_in_pages << srv_page_size_shift;
os_offset_t binlog_size= innodb_binlog_size_in_pages << ibb_page_size_shift;
if (init_page == ~(uint32_t)0 && file_size < binlog_size) {
/*
A crash may have left a partially pre-allocated file. If so, extend it
@ -785,7 +803,7 @@ dberr_t fsp_binlog_tablespace_create(uint64_t file_no, uint32_t size_in_pages)
/* We created the binlog file and now write it full of zeros */
if (!os_file_set_size(name, fh,
os_offset_t{size_in_pages} << srv_page_size_shift)
os_offset_t{size_in_pages} << ibb_page_size_shift)
) {
sql_print_error("InnoDB: Unable to allocate file %s", name);
os_file_close(fh);
@ -812,8 +830,8 @@ dberr_t fsp_binlog_tablespace_create(uint64_t file_no, uint32_t size_in_pages)
std::pair<uint64_t, uint64_t>
fsp_binlog_write_rec(chunk_data_base *chunk_data, mtr_t *mtr, byte chunk_type)
{
uint32_t page_size= (uint32_t)srv_page_size;
uint32_t page_size_shift= srv_page_size_shift;
uint32_t page_size= (uint32_t)ibb_page_size;
uint32_t page_size_shift= ibb_page_size_shift;
const uint32_t page_end= page_size - BINLOG_PAGE_DATA_END;
uint32_t page_no= binlog_cur_page_no;
uint32_t page_offset= binlog_cur_page_offset;
@ -1035,7 +1053,7 @@ fsp_binlog_flush()
return true;
}
if (my_chsize(fh, ((uint64_t)page_no + 1) << srv_page_size_shift, 0,
if (my_chsize(fh, ((uint64_t)page_no + 1) << ibb_page_size_shift, 0,
MYF(MY_WME)))
{
binlog_page_fifo->unlock();
@ -1055,7 +1073,7 @@ fsp_binlog_flush()
uint32_t page_offset= binlog_cur_page_offset;
if (page_offset > BINLOG_PAGE_DATA ||
page_offset < srv_page_size - BINLOG_PAGE_DATA_END)
page_offset < ibb_page_size - BINLOG_PAGE_DATA_END)
{
/*
If we are not precisely the end of a page, fill up that page with a dummy
@ -1071,7 +1089,7 @@ fsp_binlog_flush()
{
binlog_page_fifo->truncate_file_size(file_no, page_no + 1);
size_t reclaimed= (binlog_page_fifo->size_in_pages(file_no) - (page_no + 1))
<< srv_page_size_shift;
<< ibb_page_size_shift;
if (UNIV_LIKELY(total_binlog_used_size >= reclaimed))
total_binlog_used_size-= reclaimed;
else
@ -1144,7 +1162,7 @@ binlog_chunk_reader::fetch_current_page()
uint64_t active2= active_binlog_file_no.load(std::memory_order_acquire);
for (;;) {
fsp_binlog_page_entry *block= nullptr;
uint64_t offset= (s.page_no << srv_page_size_shift) | s.in_page_offset;
uint64_t offset= (s.page_no << ibb_page_size_shift) | s.in_page_offset;
uint64_t active= active2;
uint64_t end_offset=
binlog_cur_end_offset[s.file_no&1].load(std::memory_order_acquire);
@ -1296,17 +1314,17 @@ read_more_data:
if (0)
static_assert(BINLOG_PAGE_DATA == 0,
"Replace static_assert with code from above comment");
else if (s.in_page_offset >= srv_page_size - (BINLOG_PAGE_DATA_END + 3) ||
else if (s.in_page_offset >= ibb_page_size - (BINLOG_PAGE_DATA_END + 3) ||
page_ptr[s.in_page_offset] == FSP_BINLOG_TYPE_FILLER)
{
ut_ad(s.in_page_offset >= srv_page_size - BINLOG_PAGE_DATA_END ||
ut_ad(s.in_page_offset >= ibb_page_size - BINLOG_PAGE_DATA_END ||
page_ptr[s.in_page_offset] == FSP_BINLOG_TYPE_FILLER);
goto go_next_page;
}
/* Check for end-of-file. */
if (cur_end_offset == ~(uint64_t)0 ||
(s.page_no << srv_page_size_shift) + s.in_page_offset >= cur_end_offset)
(s.page_no << ibb_page_size_shift) + s.in_page_offset >= cur_end_offset)
return sofar;
type= page_ptr[s.in_page_offset];
@ -1413,7 +1431,7 @@ skip_chunk:
s.skip_current= false;
}
if (s.in_page_offset >= srv_page_size - (BINLOG_PAGE_DATA_END + 3))
if (s.in_page_offset >= ibb_page_size - (BINLOG_PAGE_DATA_END + 3))
{
go_next_page:
/* End of page reached, move to the next page. */
@ -1427,7 +1445,7 @@ go_next_page:
s.in_page_offset= 0;
if (cur_file_handle >= (File)0 &&
(s.page_no << srv_page_size_shift) >= cur_file_length)
(s.page_no << ibb_page_size_shift) >= cur_file_length)
{
/* Move to the next file. */
/*
@ -1481,8 +1499,8 @@ void
binlog_chunk_reader::seek(uint64_t file_no, uint64_t offset)
{
saved_position pos {
file_no, (uint32_t)(offset >> srv_page_size_shift),
(uint32_t)(offset & (srv_page_size - 1)),
file_no, (uint32_t)(offset >> ibb_page_size_shift),
(uint32_t)(offset & (ibb_page_size - 1)),
0, 0, FSP_BINLOG_TYPE_FILLER, false, false };
restore_pos(&pos);
}
@ -1525,7 +1543,7 @@ bool binlog_chunk_reader::data_available()
return true; // Active moved while we were checking
if (end_offset == ~(uint64_t)0)
return false; // Nothing in this binlog file yet
uint64_t offset= (s.page_no << srv_page_size_shift) | s.in_page_offset;
uint64_t offset= (s.page_no << ibb_page_size_shift) | s.in_page_offset;
if (offset < end_offset)
return true;

82
storage/innobase/handler/innodb_binlog.cc
View file

@ -536,7 +536,7 @@ binlog_recovery::get_header(uint64_t file_no, lsn_t &out_lsn, bool &out_empty)
File fh= my_open(full_path, O_RDONLY | O_BINARY, MYF(0));
if (fh < (File)0)
return (my_errno == ENOENT ? 0 : -1);
size_t read= my_pread(fh, page_buf, srv_page_size, 0, MYF(0));
size_t read= my_pread(fh, page_buf, ibb_page_size, 0, MYF(0));
my_close(fh, MYF(0));
if (UNIV_UNLIKELY(read == (size_t)-1))
return -1;
@ -546,7 +546,7 @@ binlog_recovery::get_header(uint64_t file_no, lsn_t &out_lsn, bool &out_empty)
If the crc32 does not match, the page was not written properly, so treat
it as an empty file.
*/
const uint32_t payload= (uint32_t)srv_page_size - BINLOG_PAGE_CHECKSUM;
const uint32_t payload= (uint32_t)ibb_page_size - BINLOG_PAGE_CHECKSUM;
uint32_t crc32= mach_read_from_4(page_buf + payload);
if (UNIV_UNLIKELY(crc32 != my_crc32c(0, page_buf, payload)))
return 0;
@ -571,12 +571,12 @@ bool binlog_recovery::init_recovery(bool space_id, uint32_t page_no,
{
/* Start by initializing resource pointers so we are safe to releaes(). */
cur_file_fh= (File)-1;
if (!(page_buf= (byte *)ut_malloc(srv_page_size, mem_key_binlog)))
if (!(page_buf= (byte *)ut_malloc(ibb_page_size, mem_key_binlog)))
{
my_error(ER_OUTOFMEMORY, MYF(MY_WME), srv_page_size);
my_error(ER_OUTOFMEMORY, MYF(MY_WME), ibb_page_size);
return true;
}
memset(page_buf, 0, srv_page_size);
memset(page_buf, 0, ibb_page_size);
inited= true;
/*
ToDo: It would be good to find a way to not duplicate this logic for
@ -837,10 +837,10 @@ binlog_recovery::flush_page() noexcept
return true;
size_t res=
crc32_pwrite_page(cur_file_fh, page_buf, cur_page_no, MYF(MY_WME));
if (res != srv_page_size)
if (res != ibb_page_size)
return true;
cur_page_offset= 0;
memset(page_buf, 0, srv_page_size);
memset(page_buf, 0, ibb_page_size);
return false;
}
@ -853,7 +853,7 @@ binlog_recovery::zero_out_cur_file()
/* Recover the original size from the current file. */
size_t read= crc32_pread_page(cur_file_fh, page_buf, 0, MYF(0));
if (read != (size_t)srv_page_size)
if (read != (size_t)ibb_page_size)
{
sql_print_warning("InnoDB: Could not read last binlog file during recovery");
return;
@ -873,23 +873,23 @@ binlog_recovery::zero_out_cur_file()
}
/* Fill up or truncate the file to its original size. */
if (my_chsize(cur_file_fh, (my_off_t)header.page_count << srv_page_size_shift,
if (my_chsize(cur_file_fh, (my_off_t)header.page_count << ibb_page_size_shift,
0, MYF(0)))
sql_print_warning("InnoDB: Could not change the size of last binlog file "
"during recovery (error: %d)", my_errno);
for (uint32_t i= cur_page_no + 1; i < header.page_count; ++i)
{
if (my_pread(cur_file_fh, page_buf, srv_page_size,
(my_off_t)i << srv_page_size_shift, MYF(0)) <
(size_t)srv_page_size)
if (my_pread(cur_file_fh, page_buf, ibb_page_size,
(my_off_t)i << ibb_page_size_shift, MYF(0)) <
(size_t)ibb_page_size)
break;
/* Check if page already zeroed out. */
if (page_buf[0] == 0 && !memcmp(page_buf, page_buf+1, srv_page_size - 1))
if (page_buf[0] == 0 && !memcmp(page_buf, page_buf+1, ibb_page_size - 1))
continue;
memset(page_buf, 0, srv_page_size);
if (my_pwrite(cur_file_fh, page_buf, srv_page_size,
(uint64_t)i << srv_page_size_shift, MYF(MY_WME)) <
(size_t)srv_page_size)
memset(page_buf, 0, ibb_page_size);
if (my_pwrite(cur_file_fh, page_buf, ibb_page_size,
(uint64_t)i << ibb_page_size_shift, MYF(MY_WME)) <
(size_t)ibb_page_size)
{
sql_print_warning("InnoDB: Error writing to last binlog file during "
"recovery (error code: %d)", my_errno);
@ -981,9 +981,9 @@ binlog_recovery::apply_redo(bool space_id, uint32_t page_no, uint16_t offset,
{
/* Check that we recovered all of this file. */
if ( ( (cur_page_offset > BINLOG_PAGE_DATA &&
cur_page_offset < srv_page_size - BINLOG_PAGE_DATA_END) ||
cur_page_offset < ibb_page_size - BINLOG_PAGE_DATA_END) ||
cur_page_no + (cur_page_offset > BINLOG_PAGE_DATA) <
cur_phys_size >> srv_page_size_shift) &&
cur_phys_size >> ibb_page_size_shift) &&
!srv_force_recovery)
{
sql_print_error("InnoDB: Missing recovery record at end of file_no=%"
@ -1005,7 +1005,7 @@ binlog_recovery::apply_redo(bool space_id, uint32_t page_no, uint16_t offset,
/* Test for moving to the next page. */
else if (page_no != cur_page_no)
{
if (cur_page_offset < srv_page_size - BINLOG_PAGE_DATA_END &&
if (cur_page_offset < ibb_page_size - BINLOG_PAGE_DATA_END &&
!srv_force_recovery)
{
sql_print_error("InnoDB: Missing recovery record in file_no=%"
@ -1037,7 +1037,7 @@ binlog_recovery::apply_redo(bool space_id, uint32_t page_no, uint16_t offset,
return true;
}
if (offset + size >= srv_page_size)
if (offset + size >= ibb_page_size)
return !srv_force_recovery;
update_page_from_record(offset, buf, size);
@ -1107,9 +1107,9 @@ innodb_binlog_init_state()
binlog_cur_page_no= 0;
binlog_cur_page_offset= BINLOG_PAGE_DATA;
current_binlog_state_interval=
(uint32_t)(innodb_binlog_state_interval >> srv_page_size_shift);
(uint32_t)(innodb_binlog_state_interval >> ibb_page_size_shift);
ut_a(innodb_binlog_state_interval ==
(current_binlog_state_interval << srv_page_size_shift));
(current_binlog_state_interval << ibb_page_size_shift));
}
@ -1160,17 +1160,17 @@ binlog_sync_initial()
bool
innodb_binlog_init(size_t binlog_size, const char *directory)
{
uint64_t pages= binlog_size >> srv_page_size_shift;
uint64_t pages= binlog_size >> ibb_page_size_shift;
if (UNIV_LIKELY(pages > (uint64_t)UINT32_MAX)) {
pages= UINT32_MAX;
sql_print_warning("Requested max_binlog_size is larger than the maximum "
"InnoDB tablespace size, truncated to %llu",
(pages << srv_page_size_shift));
(pages << ibb_page_size_shift));
} else if (pages < 2) { /* Minimum one data page and one index page. */
pages= 2;
sql_print_warning("Requested max_binlog_size is smaller than the minimum "
"size supported by InnoDB, truncated to %llu",
(pages << srv_page_size_shift));
(pages << ibb_page_size_shift));
}
innodb_binlog_size_in_pages= (uint32_t)pages;
@ -1302,8 +1302,8 @@ static int
find_pos_in_binlog(uint64_t file_no, size_t file_size, byte *page_buf,
uint32_t *out_page_no, uint32_t *out_pos_in_page)
{
const uint32_t page_size= (uint32_t)srv_page_size;
const uint32_t page_size_shift= (uint32_t)srv_page_size_shift;
const uint32_t page_size= (uint32_t)ibb_page_size;
const uint32_t page_size_shift= (uint32_t)ibb_page_size_shift;
const uint32_t idx= file_no & 1;
char file_name[OS_FILE_MAX_PATH];
uint32_t p_0, p_1, p_2, last_nonempty;
@ -1413,8 +1413,8 @@ static int
innodb_binlog_discover()
{
uint64_t file_no;
const uint32_t page_size= (uint32_t)srv_page_size;
const uint32_t page_size_shift= (uint32_t)srv_page_size_shift;
const uint32_t page_size= (uint32_t)ibb_page_size;
const uint32_t page_size_shift= (uint32_t)ibb_page_size_shift;
struct found_binlogs UNINIT_VAR(binlog_files);
int res= scan_for_binlogs(innodb_binlog_directory, &binlog_files, false);
@ -1572,7 +1572,7 @@ innodb_binlog_prealloc_thread()
dberr_t res2= fsp_binlog_tablespace_create(last_created, size_in_pages);
if (earliest_binlog_file_no == ~(uint64_t)0)
earliest_binlog_file_no= last_created;
total_binlog_used_size+= (size_in_pages << srv_page_size_shift);
total_binlog_used_size+= (size_in_pages << ibb_page_size_shift);
innodb_binlog_autopurge(first_open);
mysql_mutex_unlock(&purge_binlog_mutex);
@ -1716,7 +1716,7 @@ binlog_gtid_state(rpl_binlog_state_base *state, mtr_t *mtr,
}
}
const uint32_t page_size= (uint32_t)srv_page_size;
const uint32_t page_size= (uint32_t)ibb_page_size;
const uint32_t page_room= page_size - (BINLOG_PAGE_DATA + BINLOG_PAGE_DATA_END);
uint32_t needed_pages= (uint32_t)((used_bytes + page_room - 1) / page_room);
@ -1903,7 +1903,7 @@ read_gtid_state(rpl_binlog_state_base *state, File file, uint32_t page_no,
binlog_header_data *out_header_data)
{
std::unique_ptr<byte [], void (*)(void *)> page_buf
((byte *)my_malloc(PSI_NOT_INSTRUMENTED, srv_page_size, MYF(MY_WME)),
((byte *)my_malloc(PSI_NOT_INSTRUMENTED, ibb_page_size, MYF(MY_WME)),
&my_free);
if (UNIV_UNLIKELY(!page_buf))
return -1;
@ -1972,7 +1972,7 @@ binlog_state_recover()
ha_innodb_binlog_reader reader(active_binlog_file_no.load
(std::memory_order_relaxed),
page_no << srv_page_size_shift);
page_no << ibb_page_size_shift);
return binlog_recover_gtid_state(&state, &reader);
}
@ -2408,7 +2408,7 @@ ha_innodb_binlog_reader::ha_innodb_binlog_reader(uint64_t file_no,
uint64_t offset)
: rd_buf_len(0), rd_buf_sofar(0), state(ST_read_next_event_group)
{
page_buf= (uchar *)ut_malloc(srv_page_size, mem_key_binlog);
page_buf= (uchar *)ut_malloc(ibb_page_size, mem_key_binlog);
chunk_rd.set_page_buf(page_buf);
chunk_rd.seek(file_no, offset);
chunk_rd.skip_partial(true);
@ -2635,7 +2635,7 @@ gtid_search::read_gtid_state_file_no(rpl_binlog_state_base *state,
if (file_no + 1 >= active &&
end_offset != ~(uint64_t)0 &&
page_no <= (end_offset >> srv_page_size_shift))
page_no <= (end_offset >> ibb_page_size_shift))
{
/*
See if the page is available in the buffer pool.
@ -2665,7 +2665,7 @@ gtid_search::read_gtid_state_file_no(rpl_binlog_state_base *state,
and we fall through to the file-reading code below, no need for an
extra conditional jump here.
*/
if (page_no > (end_offset >> srv_page_size_shift))
if (page_no > (end_offset >> ibb_page_size_shift))
{
ut_ad(!block);
return READ_NOT_FOUND;
@ -2792,7 +2792,7 @@ gtid_search::find_gtid_pos(slave_connection_state *pos,
*/
uint32_t page0= 0;
uint32_t page2= (uint32_t)
(diff_state_page_interval + ((file_end - 1) >> srv_page_size_shift));
(diff_state_page_interval + ((file_end - 1) >> ibb_page_size_shift));
/* Round to the next diff_state_page_interval after file_end. */
page2-= page2 % diff_state_page_interval;
uint32_t page1= (page0 + page2) / 2;
@ -2835,7 +2835,7 @@ gtid_search::find_gtid_pos(slave_connection_state *pos,
ut_ad(page1 >= page0);
out_state->load_nolock(&page0_diff_state);
*out_file_no= file_no;
*out_offset= (uint64_t)page0 << srv_page_size_shift;
*out_offset= (uint64_t)page0 << ibb_page_size_shift;
return 1;
}
@ -2876,7 +2876,7 @@ ha_innodb_binlog_reader::init_legacy_pos(const char *filename, ulonglong offset)
my_error(ER_UNKNOWN_TARGET_BINLOG, MYF(0));
return -1;
}
if ((uint64_t)offset >= (uint64_t)(UINT32_MAX) << srv_page_size_shift)
if ((uint64_t)offset >= (uint64_t)(UINT32_MAX) << ibb_page_size_shift)
{
my_error(ER_BINLOG_POS_INVALID, MYF(0), offset);
return -1;
@ -2971,7 +2971,7 @@ innodb_binlog_status(char out_filename[FN_REFLEN], ulonglong *out_pos)
uint32_t page_no= binlog_cur_page_no;
uint32_t in_page_offset= binlog_cur_page_offset;
binlog_name_make_short(out_filename, file_no);
*out_pos= ((ulonglong)page_no << srv_page_size_shift) | in_page_offset;
*out_pos= ((ulonglong)page_no << ibb_page_size_shift) | in_page_offset;
}

2
storage/innobase/include/fsp_binlog.h
View file

@ -292,6 +292,8 @@ public:
};
extern uint32_t ibb_page_size_shift;
extern ulong ibb_page_size;
extern uint32_t current_binlog_state_interval;
extern mysql_mutex_t active_binlog_mutex;
extern pthread_cond_t active_binlog_cond;