diff --git a/mysql-test/suite/binlog_in_engine/binlog_flush_purge.result b/mysql-test/suite/binlog_in_engine/binlog_flush_purge.result index 58cb0a0a49d..f0c42d6ee0f 100644 --- a/mysql-test/suite/binlog_in_engine/binlog_flush_purge.result +++ b/mysql-test/suite/binlog_in_engine/binlog_flush_purge.result @@ -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 diff --git a/mysql-test/suite/binlog_in_engine/binlog_flush_purge.test b/mysql-test/suite/binlog_in_engine/binlog_flush_purge.test index 48cc4236f28..3384538dc59 100644 --- a/mysql-test/suite/binlog_in_engine/binlog_flush_purge.test +++ b/mysql-test/suite/binlog_in_engine/binlog_flush_purge.test @@ -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 diff --git a/storage/innobase/fsp/fsp_binlog.cc b/storage/innobase/fsp/fsp_binlog.cc index ab8e3dee8c6..6a3bf3ad9d4 100644 --- a/storage/innobase/fsp/fsp_binlog.cc +++ b/storage/innobase/fsp/fsp_binlog.cc @@ -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(aligned_malloc(srv_page_size, srv_page_size)); + e->page_buf= static_cast(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(aligned_malloc(srv_page_size, srv_page_size)); + static_cast(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 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; diff --git a/storage/innobase/handler/innodb_binlog.cc b/storage/innobase/handler/innodb_binlog.cc index afde1ff9ce7..ca7dd3aab3e 100644 --- a/storage/innobase/handler/innodb_binlog.cc +++ b/storage/innobase/handler/innodb_binlog.cc @@ -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 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; } diff --git a/storage/innobase/include/fsp_binlog.h b/storage/innobase/include/fsp_binlog.h index a71d50e6cbe..e373b7548d5 100644 --- a/storage/innobase/include/fsp_binlog.h +++ b/storage/innobase/include/fsp_binlog.h @@ -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;