This is a preparatory commit for pre-computing checksums outside of holding LOCK_log, no functional changes. Which checksum algorithm is used (if any) when writing an event does not belong in the event, it is a property of the log being written to. Instead decide the checksum algorithm when constructing the Log_event_writer object, and store it there. Introduce a client-only Log_event::read_checksum_alg to be able to print the checksum read, and a Format_description_log_event::source_checksum_alg which is the checksum algorithm (if any) to use when reading events from a log. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org> --- .../r/binlog_mysqlbinlog_raw_flush.result | 1 + .../t/binlog_mysqlbinlog_raw_flush.test | 2 + sql/log.cc | 104 +++++++++------- sql/log.h | 12 +- sql/log_event.cc | 27 +++-- sql/log_event.h | 52 +++++--- sql/log_event_client.cc | 22 ++-- sql/log_event_server.cc | 114 ++++-------------- sql/slave.cc | 60 ++++----- sql/sql_repl.cc | 2 +- sql/wsrep_binlog.cc | 6 +- sql/wsrep_mysqld.cc | 12 +- 12 files changed, 202 insertions(+), 212 deletions(-) diff --git a/mysql-test/suite/binlog/r/binlog_mysqlbinlog_raw_flush.result b/mysql-test/suite/binlog/r/binlog_mysqlbinlog_raw_flush.result index 294e96e5997..d697788047f 100644 --- a/mysql-test/suite/binlog/r/binlog_mysqlbinlog_raw_flush.result +++ b/mysql-test/suite/binlog/r/binlog_mysqlbinlog_raw_flush.result @@ -1,3 +1,4 @@ +RESET MASTER; # # MDEV-30698 Cover missing test cases for mariadb-binlog options # --raw [and] --flashback diff --git a/mysql-test/suite/binlog/t/binlog_mysqlbinlog_raw_flush.test b/mysql-test/suite/binlog/t/binlog_mysqlbinlog_raw_flush.test index 252a8577b6c..7d0a96fc087 100644 --- a/mysql-test/suite/binlog/t/binlog_mysqlbinlog_raw_flush.test +++ b/mysql-test/suite/binlog/t/binlog_mysqlbinlog_raw_flush.test @@ -21,6 +21,8 @@ --source include/linux.inc --source include/have_log_bin.inc +RESET MASTER; + --echo # --echo # MDEV-30698 Cover missing test cases for mariadb-binlog options --echo # --raw [and] --flashback diff --git a/sql/log.cc b/sql/log.cc index ab7c9e8ba0d..bcb89e79dd0 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -3886,32 +3886,34 @@ bool MYSQL_BIN_LOG::open(const char *log_name, In 4.x we put Start event only in the first binlog. But from 5.0 we want a Start event even if this is not the very first binlog. */ - Format_description_log_event s(BINLOG_VERSION); - /* - don't set LOG_EVENT_BINLOG_IN_USE_F for SEQ_READ_APPEND io_cache - as we won't be able to reset it later - */ - if (io_cache_type == WRITE_CACHE) - s.flags |= LOG_EVENT_BINLOG_IN_USE_F; - + enum enum_binlog_checksum_alg checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF; if (is_relay_log) { if (relay_log_checksum_alg == BINLOG_CHECKSUM_ALG_UNDEF) relay_log_checksum_alg= opt_slave_sql_verify_checksum ? (enum_binlog_checksum_alg) binlog_checksum_options : BINLOG_CHECKSUM_ALG_OFF; - s.checksum_alg= relay_log_checksum_alg; - s.set_relay_log_event(); + checksum_alg= relay_log_checksum_alg; } else - s.checksum_alg= (enum_binlog_checksum_alg)binlog_checksum_options; + checksum_alg= (enum_binlog_checksum_alg)binlog_checksum_options; + DBUG_ASSERT(checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); + + Format_description_log_event s(BINLOG_VERSION, NULL, checksum_alg); + if (is_relay_log) + s.set_relay_log_event(); + /* + don't set LOG_EVENT_BINLOG_IN_USE_F for SEQ_READ_APPEND io_cache + as we won't be able to reset it later + */ + if (io_cache_type == WRITE_CACHE) + s.flags |= LOG_EVENT_BINLOG_IN_USE_F; crypto.scheme = 0; - DBUG_ASSERT(s.checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); if (!s.is_valid()) goto err; s.dont_set_created= null_created_arg; - if (write_event(&s)) + if (write_event(&s, checksum_alg)) goto err; bytes_written+= s.data_written; @@ -3930,8 +3932,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name, goto err; Start_encryption_log_event sele(1, key_version, crypto.nonce); - sele.checksum_alg= s.checksum_alg; - if (write_event(&sele)) + if (write_event(&sele, checksum_alg)) goto err; // Start_encryption_log_event is written, enable the encryption @@ -4057,7 +4058,8 @@ bool MYSQL_BIN_LOG::open(const char *log_name, /* Don't set log_pos in event header */ description_event_for_queue->set_artificial_event(); - if (write_event(description_event_for_queue)) + if (write_event(description_event_for_queue, + description_event_for_queue->used_checksum_alg)) goto err; bytes_written+= description_event_for_queue->data_written; } @@ -5500,17 +5502,19 @@ int MYSQL_BIN_LOG::new_file_impl() */ Rotate_log_event r(new_name + dirname_length(new_name), 0, LOG_EVENT_OFFSET, is_relay_log ? Rotate_log_event::RELAY_LOG : 0); + enum enum_binlog_checksum_alg checksum_alg = BINLOG_CHECKSUM_ALG_UNDEF; /* The current relay-log's closing Rotate event must have checksum value computed with an algorithm of the last relay-logged FD event. */ if (is_relay_log) - r.checksum_alg= relay_log_checksum_alg; - DBUG_ASSERT(!is_relay_log || - relay_log_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); + checksum_alg= relay_log_checksum_alg; + else + checksum_alg= (enum_binlog_checksum_alg)binlog_checksum_options; + DBUG_ASSERT(checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); if ((DBUG_IF("fault_injection_new_file_rotate_event") && (error= close_on_error= TRUE)) || - (error= write_event(&r))) + (error= write_event(&r, checksum_alg))) { DBUG_EXECUTE_IF("fault_injection_new_file_rotate_event", errno= 2;); close_on_error= TRUE; @@ -5627,10 +5631,22 @@ int MYSQL_BIN_LOG::new_file_impl() DBUG_RETURN(error); } -bool MYSQL_BIN_LOG::write_event(Log_event *ev, binlog_cache_data *cache_data, +bool MYSQL_BIN_LOG::write_event(Log_event *ev, binlog_cache_data *data, IO_CACHE *file) { - Log_event_writer writer(file, 0, &crypto); + return write_event(ev, ev->select_checksum_alg(), data, file); +} + +bool MYSQL_BIN_LOG::write_event(Log_event *ev) +{ + return write_event(ev, ev->select_checksum_alg(), 0, &log_file); +} + +bool MYSQL_BIN_LOG::write_event(Log_event *ev, + enum enum_binlog_checksum_alg checksum_alg, + binlog_cache_data *cache_data, IO_CACHE *file) +{ + Log_event_writer writer(file, 0, checksum_alg, &crypto); if (crypto.scheme && file == &log_file) { writer.ctx= alloca(crypto.ctx_size); @@ -5641,17 +5657,19 @@ bool MYSQL_BIN_LOG::write_event(Log_event *ev, binlog_cache_data *cache_data, return writer.write(ev); } -bool MYSQL_BIN_LOG::append(Log_event *ev) +bool MYSQL_BIN_LOG::append(Log_event *ev, + enum enum_binlog_checksum_alg checksum_alg) { bool res; mysql_mutex_lock(&LOCK_log); - res= append_no_lock(ev); + res= append_no_lock(ev, checksum_alg); mysql_mutex_unlock(&LOCK_log); return res; } -bool MYSQL_BIN_LOG::append_no_lock(Log_event* ev) +bool MYSQL_BIN_LOG::append_no_lock(Log_event* ev, + enum enum_binlog_checksum_alg checksum_alg) { bool error = 0; DBUG_ENTER("MYSQL_BIN_LOG::append"); @@ -5659,7 +5677,7 @@ bool MYSQL_BIN_LOG::append_no_lock(Log_event* ev) mysql_mutex_assert_owner(&LOCK_log); DBUG_ASSERT(log_file.type == SEQ_READ_APPEND); - if (write_event(ev)) + if (write_event(ev, checksum_alg)) { error=1; goto err; @@ -6051,7 +6069,8 @@ THD::binlog_start_trans_and_stmt() uchar *buf= 0; size_t len= 0; IO_CACHE tmp_io_cache; - Log_event_writer writer(&tmp_io_cache, 0); + // Replicated events in writeset doesn't have checksum + Log_event_writer writer(&tmp_io_cache, 0, BINLOG_CHECKSUM_ALG_OFF, NULL); if(!open_cached_file(&tmp_io_cache, mysql_tmpdir, TEMP_PREFIX, 128, MYF(MY_WME))) { @@ -6066,8 +6085,6 @@ THD::binlog_start_trans_and_stmt() } Gtid_log_event gtid_event(this, seqno, domain_id, true, LOG_EVENT_SUPPRESS_USE_F, true, 0); - // Replicated events in writeset doesn't have checksum - gtid_event.checksum_alg= BINLOG_CHECKSUM_ALG_OFF; gtid_event.server_id= server_id; writer.write(>id_event); wsrep_write_cache_buf(&tmp_io_cache, &buf, &len); @@ -6270,7 +6287,7 @@ bool THD::binlog_write_table_map(TABLE *table, bool with_annotate) binlog_cache_data *cache_data= (cache_mngr-> get_binlog_cache_data(is_transactional)); IO_CACHE *file= &cache_data->cache_log; - Log_event_writer writer(file, cache_data); + Log_event_writer writer(file, cache_data, the_event.select_checksum_alg(), NULL); if (with_annotate) if (binlog_write_annotated_row(&writer)) @@ -6424,7 +6441,8 @@ MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd, if (Rows_log_event* pending= cache_data->pending()) { - Log_event_writer writer(&cache_data->cache_log, cache_data); + Log_event_writer writer(&cache_data->cache_log, cache_data, + pending->select_checksum_alg(), NULL); /* Write pending event to the cache. @@ -7472,11 +7490,13 @@ class CacheWriter: public Log_event_writer public: size_t remains; - CacheWriter(THD *thd_arg, IO_CACHE *file_arg, bool do_checksum, + CacheWriter(THD *thd_arg, IO_CACHE *file_arg, + enum enum_binlog_checksum_alg checksum_alg, Binlog_crypt_data *cr) - : Log_event_writer(file_arg, 0, cr), remains(0), thd(thd_arg), + : Log_event_writer(file_arg, 0, checksum_alg, cr), remains(0), thd(thd_arg), first(true) - { checksum_len= do_checksum ? BINLOG_CHECKSUM_LEN : 0; } + { + } ~CacheWriter() { status_var_add(thd->status_var.binlog_bytes_written, bytes_written); } @@ -7527,7 +7547,9 @@ int MYSQL_BIN_LOG::write_cache(THD *thd, IO_CACHE *cache) size_t val; size_t end_log_pos_inc= 0; // each event processed adds BINLOG_CHECKSUM_LEN 2 t uchar header[LOG_EVENT_HEADER_LEN]; - CacheWriter writer(thd, &log_file, binlog_checksum_options, &crypto); + CacheWriter writer(thd, &log_file, + (enum_binlog_checksum_alg)binlog_checksum_options, + &crypto); if (crypto.scheme) { @@ -9070,11 +9092,11 @@ void MYSQL_BIN_LOG::close(uint exiting) { Stop_log_event s; // the checksumming rule for relay-log case is similar to Rotate - s.checksum_alg= is_relay_log ? relay_log_checksum_alg - : (enum_binlog_checksum_alg)binlog_checksum_options; - DBUG_ASSERT(!is_relay_log || - relay_log_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); - write_event(&s); + enum enum_binlog_checksum_alg checksum_alg= is_relay_log ? + relay_log_checksum_alg : + (enum_binlog_checksum_alg)binlog_checksum_options; + DBUG_ASSERT(checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); + write_event(&s, checksum_alg); bytes_written+= s.data_written; flush_io_cache(&log_file); update_binlog_end_pos(); @@ -11242,7 +11264,7 @@ bool Recovery_context::decide_or_assess(xid_recovery_member *member, int round, if (truncate_gtid.seq_no == 0 /* was reset or never set */ || (truncate_set_in_1st && round == 2 /* reevaluted at round turn */)) { - if (set_truncate_coord(linfo, round, fdle->checksum_alg)) + if (set_truncate_coord(linfo, round, fdle->used_checksum_alg)) return true; } else diff --git a/sql/log.h b/sql/log.h index c20f0fe5a57..f02b20c12bf 100644 --- a/sql/log.h +++ b/sql/log.h @@ -829,12 +829,18 @@ class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG void stop_union_events(THD *thd); bool is_query_in_union(THD *thd, query_id_t query_id_param); + bool write_event(Log_event *ev, enum enum_binlog_checksum_alg checksum_alg, + binlog_cache_data *data, IO_CACHE *file); bool write_event(Log_event *ev, binlog_cache_data *data, IO_CACHE *file); - bool write_event(Log_event *ev) { return write_event(ev, 0, &log_file); } + bool write_event(Log_event *ev, enum enum_binlog_checksum_alg checksum_alg) + { + return write_event(ev, checksum_alg, 0, &log_file); + } + bool write_event(Log_event *ev); bool write_event_buffer(uchar* buf,uint len); - bool append(Log_event* ev); - bool append_no_lock(Log_event* ev); + bool append(Log_event* ev, enum enum_binlog_checksum_alg checksum_alg); + bool append_no_lock(Log_event* ev, enum enum_binlog_checksum_alg checksum_alg); void mark_xids_active(ulong cookie, uint xid_count); void mark_xid_done(ulong cookie, bool write_checkpoint); diff --git a/sql/log_event.cc b/sql/log_event.cc index 5e255646528..7825e25086f 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -718,8 +718,7 @@ const char* Log_event::get_type_str() Log_event::Log_event(const uchar *buf, const Format_description_log_event* description_event) - :temp_buf(0), exec_time(0), cache_type(Log_event::EVENT_INVALID_CACHE), - checksum_alg(BINLOG_CHECKSUM_ALG_UNDEF) + :temp_buf(0), exec_time(0), cache_type(Log_event::EVENT_INVALID_CACHE) { #ifndef MYSQL_CLIENT thd= 0; @@ -1017,7 +1016,8 @@ Log_event* Log_event::read_log_event(const uchar *buf, uint event_len, uint event_type= buf[EVENT_TYPE_OFFSET]; // all following START events in the current file are without checksum if (event_type == START_EVENT_V3) - (const_cast< Format_description_log_event *>(fdle))->checksum_alg= BINLOG_CHECKSUM_ALG_OFF; + (const_cast< Format_description_log_event *>(fdle))->used_checksum_alg= + BINLOG_CHECKSUM_ALG_OFF; /* CRC verification by SQL and Show-Binlog-Events master side. The caller has to provide @fdle->checksum_alg to @@ -1038,7 +1038,7 @@ Log_event* Log_event::read_log_event(const uchar *buf, uint event_len, Notice, a pre-checksum FD version forces alg := BINLOG_CHECKSUM_ALG_UNDEF. */ alg= (event_type != FORMAT_DESCRIPTION_EVENT) ? - fdle->checksum_alg : get_checksum_alg(buf, event_len); + fdle->used_checksum_alg : get_checksum_alg(buf, event_len); // Emulate the corruption during reading an event DBUG_EXECUTE_IF("corrupt_read_log_event_char", if (event_type != FORMAT_DESCRIPTION_EVENT) @@ -1258,11 +1258,10 @@ Log_event* Log_event::read_log_event(const uchar *buf, uint event_len, if (ev) { - ev->checksum_alg= alg; #ifdef MYSQL_CLIENT - if (ev->checksum_alg != BINLOG_CHECKSUM_ALG_OFF && - ev->checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) - ev->crc= uint4korr(buf + (event_len)); + ev->read_checksum_alg= alg; + if (alg != BINLOG_CHECKSUM_ALG_OFF && alg != BINLOG_CHECKSUM_ALG_UNDEF) + ev->read_checksum_value= uint4korr(buf + (event_len)); #endif } @@ -2039,8 +2038,10 @@ Start_log_event_v3::Start_log_event_v3(const uchar *buf, uint event_len, */ Format_description_log_event:: -Format_description_log_event(uint8 binlog_ver, const char* server_ver) - :Start_log_event_v3(), event_type_permutation(0) +Format_description_log_event(uint8 binlog_ver, const char* server_ver, + enum enum_binlog_checksum_alg checksum_alg) + :Start_log_event_v3(), event_type_permutation(0), + used_checksum_alg(checksum_alg) { binlog_version= binlog_ver; switch (binlog_ver) { @@ -2205,7 +2206,6 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver) } calc_server_version_split(); deduct_options_written_to_bin_log(); - checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF; reset_crypto(); } @@ -2236,6 +2236,7 @@ Format_description_log_event(const uchar *buf, uint event_len, common_header_len(0), post_header_len(NULL), event_type_permutation(0) { DBUG_ENTER("Format_description_log_event::Format_description_log_event(char*,...)"); + used_checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF; if (!Start_log_event_v3::is_valid()) DBUG_VOID_RETURN; /* sanity check */ buf+= LOG_EVENT_MINIMAL_HEADER_LEN; @@ -2257,11 +2258,11 @@ Format_description_log_event(const uchar *buf, uint event_len, { /* the last bytes are the checksum alg desc and value (or value's room) */ number_of_event_types -= BINLOG_CHECKSUM_ALG_DESC_LEN; - checksum_alg= (enum_binlog_checksum_alg)post_header_len[number_of_event_types]; + used_checksum_alg= (enum_binlog_checksum_alg)post_header_len[number_of_event_types]; } else { - checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF; + used_checksum_alg= BINLOG_CHECKSUM_ALG_OFF; } deduct_options_written_to_bin_log(); reset_crypto(); diff --git a/sql/log_event.h b/sql/log_event.h index acdedb606c1..33f689c9330 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -991,6 +991,13 @@ class Log_event_writer public: ulonglong bytes_written; void *ctx; ///< Encryption context or 0 if no encryption is needed + /* + The length of a checksum written at the end of the event, if any. + Currently this is always either 0, when checksums are disabled, or + BINLOG_CHECKSUM_LEN when using BINLOG_CHECKSUM_ALG_CRC32. + (If we ever add another checksum algorithm, we will need to instead store + here the algorithm to use instead of just the length). + */ uint checksum_len; int write(Log_event *ev); int write_header(uchar *pos, size_t len); @@ -1001,11 +1008,29 @@ class Log_event_writer void set_incident(); void set_encrypted_writer() { encrypt_or_write= &Log_event_writer::encrypt_and_write; } + /* + Set a specific checksum setting. Used to ensure that + Format_description_log_event is always written with a checksum. + */ + enum enum_binlog_checksum_alg set_checksum_alg(enum enum_binlog_checksum_alg alg) + { + /* Must be adapted to store the actual algorithm if we add another. */ + enum enum_binlog_checksum_alg orig= + (checksum_len ? BINLOG_CHECKSUM_ALG_CRC32 : BINLOG_CHECKSUM_ALG_OFF); + checksum_len= + (alg != BINLOG_CHECKSUM_ALG_OFF && alg != BINLOG_CHECKSUM_ALG_UNDEF) ? + BINLOG_CHECKSUM_LEN : 0; + return orig; + } Log_event_writer(IO_CACHE *file_arg, binlog_cache_data *cache_data_arg, - Binlog_crypt_data *cr= 0) + enum enum_binlog_checksum_alg checksum_alg, + Binlog_crypt_data *cr) :encrypt_or_write(&Log_event_writer::write_internal), bytes_written(0), ctx(0), + checksum_len(( checksum_alg != BINLOG_CHECKSUM_ALG_OFF && + checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) ? + BINLOG_CHECKSUM_LEN : 0), file(file_arg), cache_data(cache_data_arg), crypto(cr) { } private: @@ -1323,7 +1348,9 @@ class Log_event } #else Log_event() : temp_buf(0), when(0), flags(0) {} - ha_checksum crc; + /* The checksum algorithm used (if any) when the event was read. */ + enum enum_binlog_checksum_alg read_checksum_alg; + ha_checksum read_checksum_value; /* print*() functions are used by mysqlbinlog */ virtual bool print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0; bool print_timestamp(IO_CACHE* file, time_t *ts = 0); @@ -1405,16 +1432,6 @@ class Log_event static int read_log_event(IO_CACHE* file, String* packet, const Format_description_log_event *fdle, enum enum_binlog_checksum_alg checksum_alg_arg); - /* - The value is set by caller of FD constructor and - Log_event::write_header() for the rest. - In the FD case it's propagated into the last byte - of post_header_len[] at FD::write(). - On the slave side the value is assigned from post_header_len[last] - of the last seen FD event. - */ - enum enum_binlog_checksum_alg checksum_alg; - static void *operator new(size_t size) { extern PSI_memory_key key_memory_log_event; @@ -1439,7 +1456,7 @@ class Log_event bool write_footer(Log_event_writer *writer) { return writer->write_footer(); } - my_bool need_checksum(); + enum enum_binlog_checksum_alg select_checksum_alg(); virtual bool write(Log_event_writer *writer) { @@ -2877,8 +2894,15 @@ class Format_description_log_event: public Start_log_event_v3 master_version_split server_version_split; const uint8 *event_type_permutation; uint32 options_written_to_bin_log; + /* + The checksum algorithm used in the binlog or relaylog following this + Format_description_event. Or BINLOG_CHECKSUM_ALG_UNDEF for a + Format_description_event which is not part of a binlog or relaylog file. + */ + enum enum_binlog_checksum_alg used_checksum_alg; - Format_description_log_event(uint8 binlog_ver, const char* server_ver=0); + Format_description_log_event(uint8 binlog_ver, const char* server_ver= 0, + enum enum_binlog_checksum_alg checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF); Format_description_log_event(const uchar *buf, uint event_len, const Format_description_log_event *description_event); diff --git a/sql/log_event_client.cc b/sql/log_event_client.cc index 4ae8bffcad7..a4d3ffae085 100644 --- a/sql/log_event_client.cc +++ b/sql/log_event_client.cc @@ -346,14 +346,14 @@ bool Log_event::print_header(IO_CACHE* file, /* print the checksum */ - if (checksum_alg != BINLOG_CHECKSUM_ALG_OFF && - checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) + if (read_checksum_alg != BINLOG_CHECKSUM_ALG_OFF && + read_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) { char checksum_buf[BINLOG_CHECKSUM_LEN * 2 + 4]; // to fit to "%p " size_t const bytes_written= - my_snprintf(checksum_buf, sizeof(checksum_buf), "0x%08x ", crc); + my_snprintf(checksum_buf, sizeof(checksum_buf), "0x%08x ", read_checksum_value); if (my_b_printf(file, "%s ", get_type(&binlog_checksum_typelib, - checksum_alg)) || + read_checksum_alg)) || my_b_printf(file, checksum_buf, bytes_written)) goto err; } @@ -1604,8 +1604,8 @@ bool Log_event::print_base64(IO_CACHE* file, uint tmp_size= size; Rows_log_event *ev= NULL; Log_event_type ev_type = (enum Log_event_type) ptr[EVENT_TYPE_OFFSET]; - if (checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF && - checksum_alg != BINLOG_CHECKSUM_ALG_OFF) + if (read_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF && + read_checksum_alg != BINLOG_CHECKSUM_ALG_OFF) tmp_size-= BINLOG_CHECKSUM_LEN; // checksum is displayed through the header switch (ev_type) { case WRITE_ROWS_EVENT: @@ -1672,8 +1672,8 @@ bool Log_event::print_base64(IO_CACHE* file, Rows_log_event *ev= NULL; Log_event_type et= (Log_event_type) ptr[EVENT_TYPE_OFFSET]; - if (checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF && - checksum_alg != BINLOG_CHECKSUM_ALG_OFF) + if (read_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF && + read_checksum_alg != BINLOG_CHECKSUM_ALG_OFF) size-= BINLOG_CHECKSUM_LEN; // checksum is displayed through the header switch (et) @@ -3680,7 +3680,7 @@ bool Write_rows_compressed_log_event::print(FILE *file, ulong len; bool is_malloc = false; if(!row_log_event_uncompress(glob_description_event, - checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, + read_checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, temp_buf, UINT_MAX32, NULL, 0, &is_malloc, &new_buf, &len)) { @@ -3717,7 +3717,7 @@ bool Delete_rows_compressed_log_event::print(FILE *file, ulong len; bool is_malloc = false; if(!row_log_event_uncompress(glob_description_event, - checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, + read_checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, temp_buf, UINT_MAX32, NULL, 0, &is_malloc, &new_buf, &len)) { @@ -3754,7 +3754,7 @@ Update_rows_compressed_log_event::print(FILE *file, ulong len; bool is_malloc= false; if(!row_log_event_uncompress(glob_description_event, - checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, + read_checksum_alg == BINLOG_CHECKSUM_ALG_CRC32, temp_buf, UINT_MAX32, NULL, 0, &is_malloc, &new_buf, &len)) { diff --git a/sql/log_event_server.cc b/sql/log_event_server.cc index 5d07a6d853e..bee594291d6 100644 --- a/sql/log_event_server.cc +++ b/sql/log_event_server.cc @@ -574,8 +574,7 @@ int append_query_string(CHARSET_INFO *csinfo, String *to, **************************************************************************/ Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans) - :log_pos(0), temp_buf(0), exec_time(0), thd(thd_arg), - checksum_alg(BINLOG_CHECKSUM_ALG_UNDEF) + :log_pos(0), temp_buf(0), exec_time(0), thd(thd_arg) { server_id= thd->variables.server_id; when= thd->start_time; @@ -599,7 +598,7 @@ Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans) Log_event::Log_event() :temp_buf(0), exec_time(0), flags(0), cache_type(EVENT_INVALID_CACHE), - thd(0), checksum_alg(BINLOG_CHECKSUM_ALG_UNDEF) + thd(0) { server_id= global_system_variables.server_id; /* @@ -737,82 +736,17 @@ void Log_event::init_show_field_list(THD *thd, List<Item>* field_list) } /** - A decider of whether to trigger checksum computation or not. - To be invoked in Log_event::write() stack. - The decision is positive - - S,M) if it's been marked for checksumming with @c checksum_alg - - M) otherwise, if @@global.binlog_checksum is not NONE and the event is - directly written to the binlog file. - The to-be-cached event decides at @c write_cache() time. - - Otherwise the decision is negative. - - @note A side effect of the method is altering Log_event::checksum_alg - it the latter was undefined at calling. - - @return true Checksum should be used. Log_event::checksum_alg is set. - @return false No checksum + Select if and how to write checksum for an event written to the binlog. + It returns the actively configured binlog checksum option, unless the event + is being written to a cache (in which case the checksum, if any, is added + later when the cache is copied to the real binlog). */ - -my_bool Log_event::need_checksum() +enum enum_binlog_checksum_alg Log_event::select_checksum_alg() { - my_bool ret; - DBUG_ENTER("Log_event::need_checksum"); - - /* - few callers of Log_event::write - (incl FD::write, FD constructing code on the slave side, Rotate relay log - and Stop event) - provides their checksum alg preference through Log_event::checksum_alg. - */ - if (checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) - ret= checksum_alg != BINLOG_CHECKSUM_ALG_OFF; + if (cache_type == Log_event::EVENT_NO_CACHE) + return (enum_binlog_checksum_alg)binlog_checksum_options; else - { - ret= binlog_checksum_options && cache_type == Log_event::EVENT_NO_CACHE; - checksum_alg= ret ? (enum_binlog_checksum_alg)binlog_checksum_options - : BINLOG_CHECKSUM_ALG_OFF; - } - /* - FD calls the methods before data_written has been calculated. - The following invariant claims if the current is not the first - call (and therefore data_written is not zero) then `ret' must be - TRUE. It may not be null because FD is always checksummed. - */ - - DBUG_ASSERT(get_type_code() != FORMAT_DESCRIPTION_EVENT || ret || - data_written == 0); - - DBUG_ASSERT(!ret || - ((checksum_alg == binlog_checksum_options || - /* - Stop event closes the relay-log and its checksum alg - preference is set by the caller can be different - from the server's binlog_checksum_options. - */ - get_type_code() == STOP_EVENT || - /* - Rotate:s can be checksummed regardless of the server's - binlog_checksum_options. That applies to both - the local RL's Rotate and the master's Rotate - which IO thread instantiates via queue_binlog_ver_3_event. - */ - get_type_code() == ROTATE_EVENT || - get_type_code() == START_ENCRYPTION_EVENT || - /* FD is always checksummed */ - get_type_code() == FORMAT_DESCRIPTION_EVENT) && - checksum_alg != BINLOG_CHECKSUM_ALG_OFF)); - - DBUG_ASSERT(checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); - - DBUG_ASSERT(((get_type_code() != ROTATE_EVENT && - get_type_code() != STOP_EVENT) || - get_type_code() != FORMAT_DESCRIPTION_EVENT) || - cache_type == Log_event::EVENT_NO_CACHE); - - DBUG_RETURN(ret); + return BINLOG_CHECKSUM_ALG_OFF; } int Log_event_writer::write_internal(const uchar *pos, size_t len) @@ -959,8 +893,6 @@ bool Log_event::write_header(Log_event_writer *writer, size_t event_data_length) (longlong) writer->pos(), event_data_length, (int) get_type_code())); - writer->checksum_len= need_checksum() ? BINLOG_CHECKSUM_LEN : 0; - /* Store number of bytes that will be written by this event */ data_written= event_data_length + sizeof(header) + writer->checksum_len; @@ -2609,7 +2541,6 @@ int Start_log_event_v3::do_apply_event(rpl_group_info *rgi) bool Format_description_log_event::write(Log_event_writer *writer) { bool ret; - bool no_checksum; /* We don't call Start_log_event_v3::write() because this would make 2 my_b_safe_write(). @@ -2632,11 +2563,9 @@ bool Format_description_log_event::write(Log_event_writer *writer) FD_queue checksum_alg value. */ compile_time_assert(BINLOG_CHECKSUM_ALG_DESC_LEN == 1); -#ifdef DBUG_ASSERT_EXISTS - data_written= 0; // to prepare for need_checksum assert -#endif - uint8 checksum_byte= (uint8) - (need_checksum() ? checksum_alg : BINLOG_CHECKSUM_ALG_OFF); + uint8 checksum_byte= (uint8) (used_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF ? + used_checksum_alg : BINLOG_CHECKSUM_ALG_OFF); + DBUG_ASSERT(used_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); /* FD of checksum-aware server is always checksum-equipped, (V) is in, regardless of @@global.binlog_checksum policy. @@ -2650,17 +2579,16 @@ bool Format_description_log_event::write(Log_event_writer *writer) 1 + 4 bytes bigger comparing to the former FD. */ - if ((no_checksum= (checksum_alg == BINLOG_CHECKSUM_ALG_OFF))) - { - checksum_alg= BINLOG_CHECKSUM_ALG_CRC32; // Forcing (V) room to fill anyway - } + enum enum_binlog_checksum_alg old_checksum_alg= BINLOG_CHECKSUM_ALG_UNDEF; + if (checksum_byte == BINLOG_CHECKSUM_ALG_OFF) + old_checksum_alg= writer->set_checksum_alg(BINLOG_CHECKSUM_ALG_CRC32); ret= write_header(writer, rec_size) || write_data(writer, buff, sizeof(buff)) || write_data(writer, post_header_len, number_of_event_types) || write_data(writer, &checksum_byte, sizeof(checksum_byte)) || write_footer(writer); - if (no_checksum) - checksum_alg= BINLOG_CHECKSUM_ALG_OFF; + if (checksum_byte == BINLOG_CHECKSUM_ALG_OFF) + writer->set_checksum_alg(old_checksum_alg); return ret; } @@ -5025,9 +4953,11 @@ int Create_file_log_event::do_apply_event(rpl_group_info *rgi) char *ext; int fd = -1; IO_CACHE file; - Log_event_writer lew(&file, 0); - int error = 1; Relay_log_info const *rli= rgi->rli; + enum enum_binlog_checksum_alg checksum_alg= + rli->relay_log.description_event_for_exec->used_checksum_alg; + Log_event_writer lew(&file, 0, checksum_alg, NULL); + int error = 1; THD_STAGE_INFO(thd, stage_making_temp_file_create_before_load_data); bzero((char*)&file, sizeof(file)); diff --git a/sql/slave.cc b/sql/slave.cc index 30ddb4949e8..08ac2e65779 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -1795,11 +1795,13 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi) break; case 3: mi->rli.relay_log.description_event_for_queue= new - Format_description_log_event(1, mysql->server_version); + Format_description_log_event(1, mysql->server_version, + mi->rli.relay_log.relay_log_checksum_alg); break; case 4: mi->rli.relay_log.description_event_for_queue= new - Format_description_log_event(3, mysql->server_version); + Format_description_log_event(3, mysql->server_version, + mi->rli.relay_log.relay_log_checksum_alg); break; default: /* @@ -1811,7 +1813,8 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi) master is 3.23, 4.0, etc. */ mi->rli.relay_log.description_event_for_queue= new - Format_description_log_event(4, mysql->server_version); + Format_description_log_event(4, mysql->server_version, + mi->rli.relay_log.relay_log_checksum_alg); break; } } @@ -1870,10 +1873,8 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi) until it has received a new FD_m. */ - mi->rli.relay_log.description_event_for_queue->checksum_alg= - mi->rli.relay_log.relay_log_checksum_alg; - DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->checksum_alg != + DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->used_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); DBUG_ASSERT(mi->rli.relay_log.relay_log_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF); @@ -2762,7 +2763,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi) { DBUG_PRINT("info",("writing a Rotate event to track down ignored events")); rev->server_id= 0; // don't be ignored by slave SQL thread - if (unlikely(rli->relay_log.append(rev))) + if (unlikely(rli->relay_log.append(rev, rli->relay_log.relay_log_checksum_alg))) mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, NULL, ER_THD(thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), "failed to write a Rotate event" @@ -2775,7 +2776,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi) DBUG_PRINT("info",("writing a Gtid_list event to track down ignored events")); glev->server_id= 0; // don't be ignored by slave SQL thread glev->set_artificial_event(); // Don't mess up Exec_Master_Log_Pos - if (unlikely(rli->relay_log.append(glev))) + if (unlikely(rli->relay_log.append(glev, rli->relay_log.relay_log_checksum_alg))) mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, NULL, ER_THD(thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), "failed to write a Gtid_list event to the relay log, " @@ -5961,7 +5962,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev) break; Execute_load_log_event xev(thd,0,0); xev.log_pos = cev->log_pos; - if (unlikely(mi->rli.relay_log.append(&xev))) + if (unlikely(mi->rli.relay_log.append(&xev, mi->rli.relay_log.relay_log_checksum_alg))) { mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, NULL, ER_THD(thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), @@ -5975,7 +5976,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev) { cev->block = net->read_pos; cev->block_len = num_bytes; - if (unlikely(mi->rli.relay_log.append(cev))) + if (unlikely(mi->rli.relay_log.append(cev, mi->rli.relay_log.relay_log_checksum_alg))) { mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, NULL, ER_THD(thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), @@ -5990,7 +5991,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev) aev.block = net->read_pos; aev.block_len = num_bytes; aev.log_pos = cev->log_pos; - if (unlikely(mi->rli.relay_log.append(&aev))) + if (unlikely(mi->rli.relay_log.append(&aev, mi->rli.relay_log.relay_log_checksum_alg))) { mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, NULL, ER_THD(thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), @@ -6060,15 +6061,13 @@ static int process_io_rotate(Master_info *mi, Rotate_log_event *rev) */ if (mi->rli.relay_log.description_event_for_queue->binlog_version >= 4) { - DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->checksum_alg == + DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->used_checksum_alg == mi->rli.relay_log.relay_log_checksum_alg); delete mi->rli.relay_log.description_event_for_queue; /* start from format 3 (MySQL 4.0) again */ mi->rli.relay_log.description_event_for_queue= new - Format_description_log_event(3); - mi->rli.relay_log.description_event_for_queue->checksum_alg= - mi->rli.relay_log.relay_log_checksum_alg; + Format_description_log_event(3, NULL, mi->rli.relay_log.relay_log_checksum_alg); } /* Rotate the relay log makes binlog format detection easier (at next slave @@ -6176,13 +6175,15 @@ static int queue_binlog_ver_1_event(Master_info *mi, const uchar *buf, } if (likely(!ignore_event)) { + enum enum_binlog_checksum_alg checksum_alg= + mi->rli.relay_log.description_event_for_queue->used_checksum_alg; if (ev->log_pos) /* Don't do it for fake Rotate events (see comment in Log_event::Log_event(const char* buf...) in log_event.cc). */ ev->log_pos+= event_len; /* make log_pos be the pos of the end of the event */ - if (unlikely(rli->relay_log.append(ev))) + if (unlikely(rli->relay_log.append(ev, checksum_alg))) { delete ev; mysql_mutex_unlock(&mi->data_lock); @@ -6208,6 +6209,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const uchar *buf, ulong inc_pos; char *tmp_buf = 0; Relay_log_info *rli= &mi->rli; + enum enum_binlog_checksum_alg checksum_alg; DBUG_ENTER("queue_binlog_ver_3_event"); /* read_log_event() will adjust log_pos to be end_log_pos */ @@ -6240,7 +6242,8 @@ static int queue_binlog_ver_3_event(Master_info *mi, const uchar *buf, break; } - if (unlikely(rli->relay_log.append(ev))) + checksum_alg= mi->rli.relay_log.description_event_for_queue->used_checksum_alg; + if (unlikely(rli->relay_log.append(ev, checksum_alg))) { delete ev; mysql_mutex_unlock(&mi->data_lock); @@ -6342,7 +6345,7 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) { // checksum behaviour is similar to the pre-checksum FD handling mi->checksum_alg_before_fd= BINLOG_CHECKSUM_ALG_UNDEF; - mi->rli.relay_log.description_event_for_queue->checksum_alg= + mi->rli.relay_log.description_event_for_queue->used_checksum_alg= mi->rli.relay_log.relay_log_checksum_alg= checksum_alg= BINLOG_CHECKSUM_ALG_OFF; } @@ -6471,8 +6474,7 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) We detect this case by noticing a change of server_id and in this case likewise rollback the partially received event group. */ - Format_description_log_event fdle(4); - fdle.checksum_alg= checksum_alg; + Format_description_log_event fdle(4, NULL, checksum_alg); /* Possible crash is flagged in being created FD' common header @@ -6504,7 +6506,7 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) rev.new_log_ident); } mysql_mutex_lock(log_lock); - if (likely(!rli->relay_log.write_event(&fdle) && + if (likely(!rli->relay_log.write_event(&fdle, checksum_alg) && !rli->relay_log.flush_and_sync(NULL))) { rli->relay_log.harvest_bytes_written(&rli->log_space_total); @@ -6553,7 +6555,7 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) event_len - BINLOG_CHECKSUM_LEN); int4store(&rot_buf[event_len - BINLOG_CHECKSUM_LEN], rot_crc); DBUG_ASSERT(event_len == uint4korr(&rot_buf[EVENT_LEN_OFFSET])); - DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->checksum_alg == + DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->used_checksum_alg == mi->rli.relay_log.relay_log_checksum_alg); /* the first one */ DBUG_ASSERT(mi->checksum_alg_before_fd != BINLOG_CHECKSUM_ALG_UNDEF); @@ -6573,7 +6575,7 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) int4store(&rot_buf[EVENT_LEN_OFFSET], uint4korr(&rot_buf[EVENT_LEN_OFFSET]) - BINLOG_CHECKSUM_LEN); DBUG_ASSERT(event_len == uint4korr(&rot_buf[EVENT_LEN_OFFSET])); - DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->checksum_alg == + DBUG_ASSERT(mi->rli.relay_log.description_event_for_queue->used_checksum_alg == mi->rli.relay_log.relay_log_checksum_alg); /* the first one */ DBUG_ASSERT(mi->checksum_alg_before_fd != BINLOG_CHECKSUM_ALG_UNDEF); @@ -6613,11 +6615,11 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) tmp->copy_crypto_data(mi->rli.relay_log.description_event_for_queue); delete mi->rli.relay_log.description_event_for_queue; mi->rli.relay_log.description_event_for_queue= tmp; - if (tmp->checksum_alg == BINLOG_CHECKSUM_ALG_UNDEF) - tmp->checksum_alg= BINLOG_CHECKSUM_ALG_OFF; + if (tmp->used_checksum_alg == BINLOG_CHECKSUM_ALG_UNDEF) + tmp->used_checksum_alg= BINLOG_CHECKSUM_ALG_OFF; /* installing new value of checksum Alg for relay log */ - mi->rli.relay_log.relay_log_checksum_alg= tmp->checksum_alg; + mi->rli.relay_log.relay_log_checksum_alg= tmp->used_checksum_alg; /* Do not queue any format description event that we receive after a @@ -7182,7 +7184,8 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) rli->relay_log.description_event_for_queue->created= 0; rli->relay_log.description_event_for_queue->set_artificial_event(); if (rli->relay_log.append_no_lock - (rli->relay_log.description_event_for_queue)) + (rli->relay_log.description_event_for_queue, + rli->relay_log.relay_log_checksum_alg)) error= ER_SLAVE_RELAY_LOG_WRITE_FAILURE; else rli->relay_log.harvest_bytes_written(&rli->log_space_total); @@ -7195,7 +7198,8 @@ static int queue_event(Master_info* mi, const uchar *buf, ulong event_len) */ Rotate_log_event fake_rev(mi->master_log_name, 0, mi->master_log_pos, 0); fake_rev.server_id= mi->master_id; - if (rli->relay_log.append_no_lock(&fake_rev)) + if (rli->relay_log.append_no_lock(&fake_rev, + rli->relay_log.relay_log_checksum_alg)) error= ER_SLAVE_RELAY_LOG_WRITE_FAILURE; else rli->relay_log.harvest_bytes_written(&rli->log_space_total); diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 8bde0f3bd53..69c4c9e889d 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -4267,7 +4267,7 @@ bool mysql_show_binlog_events(THD* thd) if (lex_mi->pos > BIN_LOG_HEADER_SIZE) { - checksum_alg= description_event->checksum_alg; + checksum_alg= description_event->used_checksum_alg; /* Validate user given position using checksum */ if (checksum_alg != BINLOG_CHECKSUM_ALG_OFF && checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) diff --git a/sql/wsrep_binlog.cc b/sql/wsrep_binlog.cc index 5e1fa137fed..f71b1245bcc 100644 --- a/sql/wsrep_binlog.cc +++ b/sql/wsrep_binlog.cc @@ -236,7 +236,9 @@ void wsrep_dump_rbr_buf_with_header(THD *thd, const void *rbr_buf, File file; IO_CACHE cache; - Log_event_writer writer(&cache, 0); + enum enum_binlog_checksum_alg checksum_alg= + (enum_binlog_checksum_alg) binlog_checksum_options; + Log_event_writer writer(&cache, 0, checksum_alg, NULL); Format_description_log_event *ev= 0; longlong thd_trx_seqno= (long long)wsrep_thd_trx_seqno(thd); @@ -288,7 +290,7 @@ void wsrep_dump_rbr_buf_with_header(THD *thd, const void *rbr_buf, to the dump file). */ ev= (thd->wsrep_applier) ? wsrep_get_apply_format(thd) : - (new Format_description_log_event(4)); + (new Format_description_log_event(4, NULL, checksum_alg)); if (writer.write(ev) || my_b_write(&cache, (uchar*)rbr_buf, buf_len) || flush_io_cache(&cache)) diff --git a/sql/wsrep_mysqld.cc b/sql/wsrep_mysqld.cc index 91abf1dffe8..0073f846ab3 100644 --- a/sql/wsrep_mysqld.cc +++ b/sql/wsrep_mysqld.cc @@ -2150,16 +2150,16 @@ int wsrep_to_buf_helper( THD* thd, const char *query, uint query_len, uchar** buf, size_t* buf_len) { IO_CACHE tmp_io_cache; - Log_event_writer writer(&tmp_io_cache, 0); + enum enum_binlog_checksum_alg current_binlog_check_alg= + (enum_binlog_checksum_alg) binlog_checksum_options; + Log_event_writer writer(&tmp_io_cache, NULL, current_binlog_check_alg, NULL); if (open_cached_file(&tmp_io_cache, mysql_tmpdir, TEMP_PREFIX, 65536, MYF(MY_WME))) return 1; int ret(0); - enum enum_binlog_checksum_alg current_binlog_check_alg= - (enum_binlog_checksum_alg) binlog_checksum_options; - Format_description_log_event *tmp_fd= new Format_description_log_event(4); - tmp_fd->checksum_alg= current_binlog_check_alg; + Format_description_log_event *tmp_fd= + new Format_description_log_event(4, NULL, current_binlog_check_alg); writer.write(tmp_fd); delete tmp_fd; @@ -2208,7 +2208,6 @@ int wsrep_to_buf_helper( Query_log_event ev(thd, thd->wsrep_TOI_pre_query, thd->wsrep_TOI_pre_query_len, FALSE, FALSE, FALSE, 0); - ev.checksum_alg= current_binlog_check_alg; if (writer.write(&ev)) ret= 1; } @@ -2217,7 +2216,6 @@ int wsrep_to_buf_helper( /* WSREP GTID mode, we need to change server_id */ if (wsrep_gtid_mode && !thd->variables.gtid_seq_no) ev.server_id= wsrep_gtid_server.server_id; - ev.checksum_alg= current_binlog_check_alg; if (!ret && writer.write(&ev)) ret= 1; if (!ret && wsrep_write_cache_buf(&tmp_io_cache, buf, buf_len)) ret= 1; close_cached_file(&tmp_io_cache); -- 2.30.2