SSL rpl_rli.cc
Interaktion und
/* Copyright (c) 2006, 2017, Oracle and/or its affiliates. Copyright ( c ) 2010 , 2020 , MariaDB Corporation . This program is free software ; you can redistribute it and / or modify it under the terms of the GNU General Public License as published by the Free Software Foundation ; version 2 of the License . This program is distributed in the hope that it will be useful , but WITHOUT ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License for more details . You should have received a copy of the GNU General Public License along with this program ; if not , write to the Free Software Foundation , #include "mariadb.h" #include "sql_priv.h" #include "unireg.h" // HAVE_* #include "rpl_mi.h" #include "rpl_rli.h" #include "sql_base.h" // close_thread_tables #include <my_dir.h> // For MY_STAT #include "sql_repl.h" // For check_binlog_magic #include "log_event.h" // Format_description_log_event, Log_event, // FORMAT_DESCRIPTION_LOG_EVENT, ROTATE_EVENT, // PREFIX_SQL_LOAD #include "rpl_utility.h" #include "transaction.h" #include "sql_parse.h" // end_trans, ROLLBACK #include "slave.h" #include <mysql/plugin.h>#include <mysql/service_thd_wait.h>#include "lock.h" #include "sql_table.h" static int count_relay_log_space(Relay_log_info* rli);bool xa_trans_force_rollback(THD *thd);/** Current replication state ( hash of last GTID executed , per replication domain ) . /* Object used for MASTER_GTID_WAIT(). */ bool is_slave_recovery, const char * thread_name)1 ), cur_log_fd(-1 ), relay_log(&sync_relaylog_period),0 ), is_relay_log_recovery(is_slave_recovery),0 ),0 ), inuse_relaylog_list(0 ), last_inuse_relaylog(0 ),0 ), error_on_rli_init_info(false ),0 ), log_space_total(0 ), ignore_log_space_limit(0 ),true ),0 ), newest_master_timestamp(0 ), slave_timestamp(0 ),0 ),0 ), slave_run_id(0 ), sql_driver_thd(),0 ), abort_slave(0 ), stop_for_until(0 ),0 ), is_until_before_gtids(false ),0 ), executed_entries(0 ),0 ), sql_delay_end(0 ),false ),0 )"Relay_log_info::Relay_log_info" );0 ;TRUE ;#ifdef HAVE_PSI_INTERFACE#endif 0 ]= event_relay_log_name[0 ]=0 ]= 0 ;0 ]= ign_master_log_name_end[0 ]= 0 ;char *) &info_file, sizeof (info_file));char *) &cache_buf, sizeof (cache_buf));sizeof (last_seen_gtid));"Relay_log_info::~Relay_log_info" );/** Read the relay_log . info file . @ param info_fname The name of the file to read from . @ retval 0 success @ retval 1 failure int Relay_log_info::init(const char * info_fname)char fname[FN_REFLEN+128 ];const char * msg = 0 ;int error = 0 ;"Relay_log_info::init" );if (inited) // Set if this function called 0 );"" , 4 +32 );1 ;0 ;0 ;0 ;if (unlikely(error_on_rli_init_info))goto err;char pattern[FN_REFLEN];void ) my_realpath(pattern, slave_load_tmpdir, 0 );if (fn_format(pattern, PREFIX_SQL_LOAD, pattern, "" ,"Unable to use slave's temporary directory %s" ,1 );/* The relay log will now be opened , as a SEQ_READ_APPEND IO_CACHE . Note that the I / O thread flushes it to disk after writing every event , in flush_master_info ( mi , 1 , ? ) . /* Reports an error and returns, if the --relay-log's path if (opt_relay_logname && 1 ] == FN_LIBCHAR)"Path '%s' is a directory name, please specify \ for --relay-log option", opt_relay_logname); 1 );/* Reports an error and returns, if the --relay-log-index's path if (opt_relaylog_index_name && 1 ] "Path '%s' is a directory name, please specify \ for --relay-log-index option", opt_relaylog_index_name); 1 );char buf[FN_REFLEN];const char *ln;static bool name_warning_sent= 0 ;"-relay-bin" ,1 , buf);/* We send the warning only at startup, not after every RESET SLAVE */ if (!opt_relay_logname && !opt_relaylog_index_name && !name_warning_sent &&/* User didn ' t give us info to name the relay log index file . Picking ` hostname ` - relay - bin . index like we do , causes replication to fail if this slave ' s hostname is changed later . So , we would like to instead require a name . But as we don ' t want to break many existing setups , we only give warning , not error . "Neither --relay-log nor --relay-log-index were used;" " so replication " "may break when this MariaDB server acts as a " "slave and has its hostname changed. Please " "use '--log-basename=#' or '--relay-log=%s' to avoid " "this problem." , ln);1 ;/* For multimaster, add connection name to relay log filenames */ char buf_relay_logname[FN_REFLEN], buf_relaylog_index_name_buff[FN_REFLEN];char *buf_relaylog_index_name= opt_relaylog_index_name;sizeof (buf_relay_logname),1 , &mi->cmp_connection_name);if (opt_relaylog_index_name)sizeof (buf_relaylog_index_name_buff),0 ,/* note , that if open ( ) fails , we ' ll still have index file open but a destructor will take care of that if (relay_log.open_index_file(buf_relaylog_index_name, ln, TRUE ) ||0 , 0 , SEQ_READ_APPEND,1 , TRUE ))"Failed when trying to open logs for '%s' in Relay_log_info::init(). Error: %iE" , ln, my_errno);1 );/* if file does not exist */ if (access(fname,F_OK))/* If someone removed the file from underneath our feet , just close the old descriptor and re - create the old file if (info_fd >= 0 )if ((info_fd= mysql_file_open(key_file_relay_log_info,0 )"Failed to create a new relay log info file (" "file '%s', errno %d)" , fname, my_errno);goto err;if (init_io_cache(&info_file, info_fd, LOG_BIN_IO_SIZE, READ_CACHE, 0 L,0 ,"Failed to create a cache on relay log info file '%s'" ,goto err;/* Init relay log with first entry in the relay index file */ if (init_relay_log_pos(this ,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */, 0 ))"Failed to open the relay log 'FIRST' (relay_log_pos 4)" );goto err;0 ]= 0 ;0 ;else // file exists if (info_fd >= 0 )0 L,0 ,0 );else int error=0 ;if ((info_fd= mysql_file_open(key_file_relay_log_info,0 )"\ '%s' (errno %d)", 1 ;else if (init_io_cache(&info_file, info_fd,0 L, 0 , MYF(MY_WME)))"Failed to create a cache on relay log info file '%s'" ,1 ;if (unlikely(error))if (info_fd >= 0 )0 ));1 ;1 );if (load_from_file())goto err;if (is_relay_log_recovery && init_recovery(mi, &msg))goto err;if (init_relay_log_pos(this ,0 /* no data lock*/, 0 ))"Failed to open the relay log '%s' (relay_log_pos %llu)" ,goto err;"info" , ("my_b_tell(cur_log)=%llu event_relay_log_pos=%llu" ,/* Now change the cache from READ to WRITE - must do this before Relay_log_info : : flush ( ) 0 L,0 ,1 );if (unlikely((error= flush())))"Failed to flush relay log info file" ;goto err;if (count_relay_log_space(this ))"Error counting relay log space" ;goto err;1 ;false ;0 );true ;if (msg)"%s" , msg);if (info_fd >= 0 )0 ));1 ;1 );static inline int add_relay_log(Relay_log_info* rli,LOG_INFO* linfo)"add_relay_log" );if (!mysql_file_stat(key_file_relaylog,0 )))"log %s listed in the index, but failed to stat" ,1 );"info" ,("log_space_total: %llu" , uint64(rli->log_space_total)));0 );static int count_relay_log_space(Relay_log_info* rli)"count_relay_log_space" );0 ;if (rli->relay_log.find_log_pos(&linfo, NullS, 1 ))"Could not find first log while counting relay log space" );1 );do if (add_relay_log(rli,&linfo))1 );while (!rli->relay_log.find_next_log(&linfo, 1 ));/* As we have counted everything , including what may have written in a preceding write , we must reset bytes_written , or we may count some space twice . 0 );/* Reset UNTIL condition for Relay_log_info SYNOPSYS clear_until_condition ( ) rli - Relay_log_info structure where UNTIL condition should be reset void Relay_log_info::clear_until_condition()"clear_until_condition" );0 ]= 0 ;0 ;false ;/* Read the correct format description event for starting to replicate from a given position in a relay log file . const char **errmsg)bool found= false ;new Format_description_log_event(4 );while (!found)/* Read the possible Format_description_log_event ; if position was 4 , no need , it will be read naturally . "info" ,("looking for a Format_description_log_event" ));if (my_b_tell(cur_log) >= start_pos)break ;int read_error;if (!(ev= Log_event::read_log_event(cur_log, &read_error, fdev,"info" ,("could not read event, read_error=%d" ,if (read_error) /* not EOF */ "I/O error reading event at position 4" ;delete fdev;return NULL;break ;if (typ == FORMAT_DESCRIPTION_EVENT)"info" ,("found Format_description_log_event" ));delete old;/* As ev was returned by read_log_event , it has passed is_valid ( ) , so my_malloc ( ) in ctor worked , no need to check again . /* Ok , we found a Format_description event . But it is not sure that this describes the whole relay log ; indeed , one can have this sequence ( starting from position 4 ) : Format_desc ( of slave ) Rotate ( of master ) Format_desc ( of master ) So the Format_desc which really describes the rest of the relay log is the 3 rd event ( it can ' t be further than that , because we rotate the relay log when we queue a Rotate event from the master ) . But what describes the Rotate is the first Format_desc . So what we do is : go on searching for Format_description events , until you exceed the position ( argument ' pos ' ) or until you find another event than Rotate or Format_desc . else if (typ == START_ENCRYPTION_EVENT)if (fdev->start_decryption((Start_encryption_log_event*) ev))"Unable to set up decryption of binlog." ;delete ev;delete fdev;return NULL;delete ev;else "info" ,("found event of another type=%d" , typ));delete ev;return fdev;/* Open the given relay log SYNOPSIS init_relay_log_pos ( ) rli Relay information ( will be initialized ) log Name of relay log file to read from . NULL = First log pos Position in relay log file need_data_lock Set to 1 if this functions should do mutex locks errmsg Store pointer to error message here look_for_description_event 1 if we should look for such an event . We only need this when the SQL thread starts and opens an existing relay log and has to execute it ( possibly from an offset > 4 ) ; then we need to read the first event of the relay log to be able to parse the events we have to execute . DESCRIPTION - Close old open relay log files . - If we are using the same relay log as the running IO - thread , then set rli - > cur_log to point to the same IO_CACHE entry . - If not , open the ' log ' binary file . TODO - check proper initialization of group_master_log_name / group_master_log_pos RETURN VALUES 0 ok 1 error . errmsg is set to point to the error message int init_relay_log_pos(Relay_log_info* rli,const char * log,bool need_data_lock,const char ** errmsg,bool look_for_description_event)"init_relay_log_pos" );"info" , ("pos: %lu" , (ulong) pos));0 ;if (need_data_lock)/* Slave threads are not the only users of init_relay_log_pos ( ) . CHANGE MASTER is , too , and init_slave ( ) too ; these 2 functions allocate a description event in init_relay_log_pos , which is not freed by the terminating SQL slave thread as that thread is not started by these functions . So we have to free the description_event here , in case , so that there is no memory leak in running , say , CHANGE MASTER . delete rli->relay_log.description_event_for_sql_thread;new Format_description_log_event(4 );/* Close log file and free buffers if it's already open */ if (rli->cur_log_fd >= 0 )1 ;/* Test to see if the previous run was with the skip of purging If yes , we do not purge when we restart if (rli->relay_log.find_log_pos(&rli->linfo, NullS, 1 ))"Could not find first log during relay log initialization" ;goto err;if (log && rli->relay_log.find_log_pos(&rli->linfo, log, 1 ))"Could not find target log during relay log initialization" ;goto err;if (rli->relay_log.is_active(rli->linfo.log_file_name))/* The IO thread is using this log file . In this case , we will use the same IO_CACHE pointer to read data as the IO thread is using to write data . 0 );if (check_binlog_magic(rli->cur_log,errmsg))goto err;else /* Open the relay log and set rli - > cur_log to point at this one if ((rli->cur_log_fd=open_binlog(&rli->cache_buf,0 )goto err;/* In all cases , check_binlog_magic ( ) has been called so we ' re at offset 4 for sure . if (pos > BIN_LOG_HEADER_SIZE) /* If pos<=4, we stay at 4 */ if (look_for_description_event)if (!(fdev= read_relay_log_description_event(rli->cur_log, pos, errmsg)))goto err;delete rli->relay_log.description_event_for_sql_thread;"info" , ("my_b_tell(rli->cur_log)=%llu rli->event_relay_log_pos=%llu" ,/* If we don ' t purge , we can ' t honour relay_log_space_limit ; silently discard it if (!relay_log_purge)0 ;if (need_data_lock)if (!rli->relay_log.description_event_for_sql_thread->is_valid() && !*errmsg)"Invalid Format_description log event; could be out of memory" ;"info" , ("Returning %d from init_relay_log_pos" , (*errmsg)?1 :0 ));1 : 0 );/* Waits until the SQL thread reaches ( has executed up to ) the log / position or timed out . SYNOPSIS wait_for_pos ( ) thd client thread that sent SELECT MASTER_POS_WAIT log_name log name to wait for log_pos position to wait for timeout timeout in seconds before giving up waiting NOTES timeout is longlong whereas it should be ulong ; but this is to catch if the user submitted a negative timeout . RETURN VALUES - 2 improper arguments ( log_pos < 0 ) or slave not running , or master info changed during the function ' s execution , or client thread killed . - 2 is translated to NULL by caller - 1 timed out > = 0 number of log events the function had to wait before reaching the desired log / position int Relay_log_info::wait_for_pos(THD* thd, String* log_name,int event_count = 0 ;int error=0 ;struct timespec abstime; // for timeout checking "Relay_log_info::wait_for_pos" );if (!inited)2 );"enter" ,("log_name: '%s' log_pos: %lu timeout: %lu" ,/* This function will abort when it notices that some CHANGE MASTER or RESET MASTER has changed the master info . To catch this , these commands modify abort_pos_wait ; We just monitor abort_pos_wait and see if it has changed . Why do we have this mechanism instead of simply monitoring slave_running in the loop ( we do this too ) , as CHANGE MASTER / RESET SLAVE require that the SQL thread be stopped ? This is becasue if someones does : STOP SLAVE ; CHANGE MASTER / RESET SLAVE ; START SLAVE ; the change may happen very quickly and we may not notice that slave_running briefly switches between 1 / 0 / 1 . /* We ' ll need to handle all possible log names comparisons ( e . g . 999 vs 1000 ) . We use ulong for string - > number conversion ; this is no stronger limitation than in find_uniq_filename in sql / log . cc char log_name_tmp[FN_REFLEN]; //make a char[] from String 1 ));char *p= fn_ext(log_name_tmp);char *p_end;if (!*p || log_pos<0 )2 ; //means improper arguments goto err;// Convert 0-3 to 4 /* p points to '.' */ 10 );/* p_end points to the first invalid character . If it equals to p , no digits were found , error . If it contains ' \ 0 ' it means conversion went ok . if (p_end==p || *p_end)2 ;goto err;/* The "compare and wait" main loop */ while (!thd->killed &&bool pos_reached;int cmp_result= 0 ;"info" ,"init_abort_pos_wait: %ld abort_pos_wait: %ld" ,"info" ,("group_master_log_name: '%s' pos: %lu" ,/* group_master_log_name can be " " , if we are just after a fresh replication start or after a CHANGE MASTER TO MASTER_HOST / PORT ( before we have executed one Rotate event from the master ) or ( rare ) if the user is doing a weird slave setup ( see next paragraph ) . If group_master_log_name is " " , we assume we don ' t have enough info to do the comparison yet , so we just wait until more data . In this case master_log_pos is always 0 except if somebody ( wrongly ) sets this slave to be a slave of itself without using - - replicate - same - server - id ( an unsupported configuration which does nothing ) , then group_master_log_pos will grow and group_master_log_name will stay " " . if (*group_master_log_name)char *basename= (group_master_log_name +/* First compare the parts before the extension . Find the dot in the master ' s log basename , and protect against user ' s input error : if the names do not match up to ' . ' included , return error char *q= (char *)(fn_ext(basename)+1 );if (strncmp(basename, log_name_tmp, (int )(q-basename)))2 ;break ;// Now compare extensions. char *q_end;10 );if (group_master_log_name_extension < log_name_extension)1 ;else 1 : 0 ;0 );if (pos_reached || thd->killed)break ;//wait for master update, with optional timeout. "info" ,("Waiting for master update" ));/* We are going to mysql_cond_ ( timed ) wait ( ) ; if the SQL thread stops it will wake us up . if (timeout > 0 )/* Note that mysql_cond_timedwait checks for the timeout before for the condition ; i . e . it returns ETIMEDOUT if the system time equals or exceeds the time specified by abstime before the condition variable is signaled or broadcast , _ or_ if the absolute time specified by abstime has already passed at the time of the call . For that reason , mysql_cond_timedwait will do the " timeoutting " job even if its condition is always immediately signaled ( case of a loaded master ) . else "info" ,("Got signal of master update or timed out" ));if (error == ETIMEDOUT || error == ETIME)"Timeout waiting for %s:%llu. Current pos is %s:%llu" ,1 ;break ;0 ;"info" ,("Testing if killed or SQL thread not running" ));"exit" ,("killed: %d abort: %d slave_running: %d \ ", int ) (init_abort_pos_wait != abort_pos_wait),int ) slave_running,int ) (error == -2 ),int ) (error == -1 )));if (thd->killed || init_abort_pos_wait != abort_pos_wait ||const char *cause= 0 ;if (init_abort_pos_wait != abort_pos_wait)"CHANGE MASTER detected" ;else if (!slave_running)"slave is not running" ;else "connection was killed" ;"master_pos_wait() was aborted because %s" ,2 ;void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,bool skip_lock)"Relay_log_info::inc_group_relay_log_pos" );if (skip_lock)else "info" , ("log_pos: %lu group_master_log_pos: %lu" ,long ) log_pos, (long ) group_master_log_pos));if (rgi->is_parallel_exec)/* In case of parallel replication, do not update the position backwards. */ int cmp= compare_log_name(group_relay_log_name, rgi->event_relay_log_name);if (cmp < 0 )else if (cmp == 0 && group_relay_log_pos < rgi->future_event_relay_log_pos)/* In the parallel case we need to update the master_log_name here , rather than in Rotate_log_event : : do_update_pos ( ) . if (cmp <= 0 )if (cmp < 0 )sizeof (group_master_log_name),else if (group_master_log_pos < log_pos)/* In the parallel case , we only update the Seconds_Behind_Master at the end of a transaction . In the non - parallel case , the value is updated as soon as an event is read from the relay log ; however this would be too confusing for the user , seeing the slave reported as up - to - date when potentially thousands of events are still queued up for worker threads waiting for execution . else /* Non-parallel case. */ if (log_pos) // not 3.23 binlogs (no log_pos there) and not Stop_log_event /* If the slave does not support transactions and replicates a transaction , users should not trust group_master_log_pos ( which they can display with SHOW SLAVE STATUS or read from relay - log . info ) , because to compute group_master_log_pos the slave relies on log_pos stored in the master ' s binlog , but if we are in a master ' s transaction these positions are always the BEGIN ' s one ( excepted for the COMMIT ) , so group_master_log_pos does not advance as it should on the non - transactional slave ( it advances by big leaps , whereas it should advance by small leaps ) . /* In 4 . x we used the event ' s len to compute the positions here . This is wrong if the event was 3 . 23 / 4 . 0 and has been converted to 5 . 0 , because then the event ' s len is not what is was in the master ' s binlog , so this will make a wrong group_master_log_pos ( yes it ' s a bug in 3 . 23 - > 4 . 0 replication : Exec_master_log_pos is wrong ) . Only way to solve this is to have the original offset of the end of the event the relay log . This is what we do in 5 . 0 : log_pos has become " end_log_pos " ( because the real use of log_pos in 4 . 0 was to compute the end_log_pos ; so better to store end_log_pos instead of begin_log_pos . If we had not done this fix here , the problem would also have appeared when the slave and master are 5 . 0 but with different event length ( for example the slave is more recent than the master and features the event UID ) . It would give false MASTER_POS_WAIT , false Exec_master_log_pos in SHOW SLAVE STATUS , and so the user would do some CHANGE MASTER using this value which would lead to badly broken replication . Even the relay_log_pos will be corrupted in this case , because the len is the relay log is not " val " . With the end_log_pos solution , we avoid computations involving lengthes . if (!skip_lock)void Relay_log_info::close_temporary_tables()"Relay_log_info::close_temporary_tables" );if (!save_temporary_tables)/* There are no temporary tables. */ while ((share= save_temporary_tables->pop_front()))/* Iterate over the list of tables for this TABLE_SHARE and close them . while ((table= share->all_tmp_tables.pop_front()))"tmptable" , ("closing table: '%s'.'%s'" ,/* Reset in_use as the table may have been created by another thd */ 0 ;/* Lets not free TABLE_SHARE here as there could be multiple TABLEs opened for the same table ( TABLE_SHARE ) . /* Don ' t ask for disk deletion . For now , anyway they will be deleted when slave restarts , but it is a better intention to not delete them . /* By now, there mustn't be any elements left in the list. */ 0 ;/* purge_relay_logs ( ) @ param rli Relay log information @ param thd thread id . May be zero during startup NOTES Assumes to have a run lock on rli and that no slave thread are running . int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,const char ** errmsg)int error=0 ;const char *ln;char name_buf[FN_REFLEN];"purge_relay_logs" );/* Even if rli - > inited = = 0 , we still try to empty rli - > master_log_ * variables . Indeed , rli - > inited = = 0 does not imply that they already are empty . It could be that slave ' s info initialization partly succeeded : for example if relay - log . info existed but * relay - bin * . * have been manually removed , Relay_log_info : : init ( ) reads the old relay - log . info and fills rli - > master_log_ * , then Relay_log_info : : init ( ) checks for the existence of the relay log , this fails and Relay_log_info : : init ( ) leaves rli - > inited to 0 . In that pathological case , rli - > master_log_pos * will be properly reinited at the next START SLAVE ( as RESET SLAVE or CHANGE MASTER , the callers of purge_relay_logs , will delete bogus * . info files or replace them with correct files ) , however if the user does SHOW SLAVE STATUS before START SLAVE , he will see old , confusing rli - > master_log_ * . In other words , we reinit rli - > master_log_ * for SHOW SLAVE STATUS to display fine in any case . 0 ]= 0 ;0 ;if (!rli->inited)"info" , ("rli->inited == 0" ));if (rli->error_on_rli_init_info)"-relay-bin" ,1 , name_buf);if (rli->relay_log.open_index_file(opt_relaylog_index_name, ln, TRUE ))"Unable to purge relay log files. Failed to open relay " "log index file:%s." , rli->relay_log.get_index_fname());1 );if (rli->relay_log.open(ln, 0 , 0 , SEQ_READ_APPEND,1 , TRUE ))"Unable to purge relay log files. Failed to open relay " "log file:%s." , rli->relay_log.get_log_fname());1 );else 0 );else 0 );0 );/* we close the relay log fd possibly left open by the slave SQL thread , to be able to delete it ; the relay log fd possibly left open by the slave I / O thread will be closed naturally in reset_logs ( ) by the close ( LOG_CLOSE_TO_BE_OPENED ) call if (rli->cur_log_fd >= 0 )1 ;if (rli->relay_log.reset_logs(thd, !just_reset, NULL, 0 , 0 ))"Failed during log reset" ;1 ;goto err;if (!just_reset)/* Save name of used relay log file */ 0 ;if (count_relay_log_space(rli))"Error counting relay log space" ;1 ;goto err;0 /* do not need data lock */, errmsg, 0); else /* Ensure relay log names are not used */ 0 ]= rli->event_relay_log_name[0 ]= 0 ;if (!rli->inited && rli->error_on_rli_init_info)"info" ,("log_space_total: %llu" , uint64(rli->log_space_total)));/* Check if condition stated in UNTIL clause of START SLAVE is reached . SYNOPSYS Relay_log_info : : is_until_satisfied ( ) master_beg_pos position of the beginning of to be executed event ( not log_pos member of the event that points to the beginning of the following event ) DESCRIPTION Checks if UNTIL condition is reached . Uses caching result of last comparison of current log file name and target log file name . So cached value should be invalidated if current log file name changes ( see Relay_log_info : : notify_ . . . functions ) . This caching is needed to avoid of expensive string comparisons and strtol ( ) conversions needed for log names comparison . We don ' t need to compare them each time this function is called , we only need to do this when current log name changes . If we have UNTIL_MASTER_POS condition we need to do this only after Rotate_log_event : : do_apply_event ( ) ( which is rare , so caching gives real benefit ) , and if we have UNTIL_RELAY_POS condition then we should invalidate cached comarison value after inc_group_relay_log_pos ( ) which called for each group of events ( so we have some benefit if we have something like queries that use autoincrement or if we have transactions ) . Should be called ONLY if until_condition ! = UNTIL_NONE ! In the parallel execution mode and UNTIL_MASTER_POS the file name is presented by future_event_master_log_name which may be ahead of group_master_log_name . Log_event : : log_pos does relate to it nevertheless so the pair comprises a correct binlog coordinate . Internal group events and events that have zero log_pos also produce the zero for the local log_pos which may not lead to the function falsely return true . In UNTIL_RELAY_POS the original caching and notification are simplified to straightforward files comparison when the current event can ' t be a part of an event group . RETURN VALUE true - condition met or error happened ( condition seems to have bad log file name ) false - condition not met bool Relay_log_info::is_until_satisfied(Log_event *ev)const char *log_name;/* Prevents stopping within transaction; needed solely for Relay UNTIL. */ bool in_trans= false ;"Relay_log_info::is_until_satisfied" );if (until_condition == UNTIL_MASTER_POS)0 : group_master_log_pos) :else if (!mi->using_parallel())else /* until_log_names_cmp_result is set to UNKNOWN either - by a non - group event * and * only when it is in the middle of a group - or by a group event when the preceding group made the above non - group event to defer the resetting . if ((ev && !Log_event::is_group_event(ev->get_type_code())))if (in_trans)true ;else false ;else if (!in_trans && until_relay_log_names_defer)false ;"info" , ("group_master_log_name='%s', group_master_log_pos=%llu" ,"info" , ("group_relay_log_name='%s', group_relay_log_pos=%llu" ,"info" , ("(%s) log_name='%s', log_pos=%llu" ,"master" : "relay" ,"info" , ("(%s) until_log_name='%s', until_log_pos=%llu" ,"master" : "relay" ,if (until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_UNKNOWN)/* We have no cached comparison results so we should compare log names and cache result . If we are after RESET SLAVE , and the SQL slave thread has not processed any event yet , it could be that group_master_log_name is " " . In that case , just wait for more events ( as there is no sensible comparison to do ) . if (*log_name)const char *basename= log_name + dirname_length(log_name);const char *q= (const char *)(fn_ext(basename)+1 );if (strncmp(basename, until_log_name, (int )(q-basename)) == 0 )/* Now compare extensions. */ char *q_end;10 );if (log_name_extension < until_log_name_extension)else else /* Probably error so we aborting */ "Slave SQL thread is stopped because UNTIL " "condition is bad." );TRUE );else 0 );bool Relay_log_info::stmt_done(my_off_t event_master_log_pos, THD *thd,int error= 0 ;"Relay_log_info::stmt_done" );this );/* If in a transaction , and if the slave supports transactions , just inc_event_relay_log_pos ( ) . We only have to check for OPTION_BEGIN ( not OPTION_NOT_AUTOCOMMIT ) as transactions are logged with BEGIN / COMMIT , not with SET AUTOCOMMIT = . We can ' t use rgi - > rli - > get_flag ( IN_TRANSACTION ) here as OPTION_BEGIN is also used for single row transactions . CAUTION : opt_using_transactions means innodb | | bdb ; suppose the master supports InnoDB and BDB , but the slave supports only BDB , problems will arise : - suppose an InnoDB table is created on the master , - then it will be MyISAM on the slave - but as opt_using_transactions is true , the slave will believe he is transactional with the MyISAM table . And problems will come when one does START SLAVE ; STOP SLAVE ; START SLAVE ; ( the slave will resume at BEGIN whereas there has not been any rollback ) . This is the problem of using opt_using_transactions instead of a finer " does the slave support _ transactional handler used on the master_ " . More generally , we ' ll have problems when a query mixes a transactional handler and MyISAM and STOP SLAVE is issued in the middle of the " transaction " . START SLAVE will resume at BEGIN while the MyISAM table has already been updated . if ((rgi->thd->variables.option_bits & OPTION_BEGIN) &&else if (rpl_global_gtid_slave_state->record_and_update_gtid(thd, rgi))"Failed to update GTID state in %s.%s, slave state may become " "inconsistent: %d: %s" ,"mysql" , rpl_gtid_slave_state_table_name.str,/* At this point we are not in a transaction ( for example after DDL ) , so we can not roll back . Anyway , normally updates to the slave state table should not fail , and if they do , at least we made the DBA aware of the problem in the error log . "inject_crash_before_flush_rli" , DBUG_SUICIDE(););if (mi->using_gtid == Master_info::USE_GTID_NO)if (rgi->is_parallel_exec)if (flush())1 ;if (rgi->is_parallel_exec)"inject_crash_after_flush_rli" , DBUG_SUICIDE(););int const char *name)if (!(gtid_list= (rpl_gtid *)my_malloc(PSI_INSTRUMENT_ME,sizeof (*gtid_list)*gtid_count, MYF(MY_WME))))0 ), (int )sizeof (*gtid_list)*gtid_count);return 1 ;if (!(ir= new inuse_relaylog(this , gtid_list, gtid_count, name)))0 ), (int ) sizeof (*ir));return 1 ;if (relay_log_state.get_gtid_list(gtid_list, gtid_count))delete ir;0 /* Should not be possible as we allocated correct length */); 0 ));return 1 ;if (!inuse_relaylog_list)else true ;return 0 ;void delete ir;void while (cur)int int res= 0 ;while (count)if (relay_log_state.update_nolock(gtid_list))1 ;return res;#if !defined (MYSQL_CLIENT) && defined (HAVE_REPLICATION)struct gtid_pos_element { uint64 sub_id; rpl_gtid gtid; void *hton; };static int void **out_hton)bool table_opened= false ;bool table_scanned= false ;struct gtid_pos_element tmp_entry, *entry;int err= 0 ;if ((err= open_and_lock_tables(thd, &tlist, FALSE , 0 )))goto end;true ;if ((err= gtid_check_rpl_slave_state_table(table)))goto end;if (unlikely(err= table->file->ha_rnd_init_with_error(1 )))goto end;true ;for (;;)if ((err= table->file->ha_rnd_next(table->record[0 ])))if (err == HA_ERR_END_OF_FILE)break ;else 0 ));goto end;0 ]->val_int();1 ]->val_int();2 ]->val_int();3 ]->val_int();"info" , ("Read slave state row: %u-%u-%lu sub_id=%lu" ,unsigned )domain_id, (unsigned )server_id,if ((err= insert_dynamic(array, (uchar *)&tmp_entry)))0 ));goto end;if ((rec= my_hash_search(hash, (const uchar *)&domain_id,sizeof (domain_id))))struct gtid_pos_element *)rec;if (entry->sub_id >= sub_id)continue ;else if (!(entry= (struct gtid_pos_element *)my_malloc(PSI_INSTRUMENT_ME,sizeof (*entry), MYF(MY_WME))))0 ), (int )sizeof (*entry));1 ;goto end;if ((err= my_hash_insert(hash, (uchar *)entry)))0 ));goto end;0 ; /* Clear HA_ERR_END_OF_FILE */ if (table_scanned)FALSE );if (table_opened)return err;/* Look for all tables mysql . gtid_slave_pos * . Read all rows from each such table found into ARRAY . For each domain id , put the row with highest sub_id into HASH . static int int (*cb)(THD *, LEX_CSTRING *, void *),void *cb_data)char path[FN_REFLEN];if (lock_schema_name(thd, Lex_ident_db_normalized(MYSQL_SCHEMA_NAME)))return 1 ;sizeof (path) - 1 , MYSQL_SCHEMA_NAME.str, "" , "" , 0 );if (!(dirp= my_dir(path, MYF(MY_DONT_SORT))))0 ), path, my_errno);return 1 ;else int err;false );if (err)return err;for (i = 0 ; i < files.elements(); ++i)if (strncmp(files.at(i)->str,0 )if ((err= (*cb)(thd, files.at(i), cb_data)))return err;return 0 ;struct load_gtid_state_cb_data {struct rpl_slave_state::gtid_pos_table *table_list;struct rpl_slave_state::gtid_pos_table *default_entry;static int void *hton,struct load_gtid_state_cb_data *data)struct rpl_slave_state::gtid_pos_table *p, *entry, **next_ptr;bool is_default=0 );/* Ignore tables with duplicate storage engine , with a warning . Prefer the default mysql . gtid_slave_pos over another table mysql . gtid_slave_posXXX with the same storage engine . while (entry)if (entry->table_hton == hton)static const char *warning_msg= "Ignoring redundant table mysql.%s " "since mysql.%s has the same storage engine" ;if (!is_default)/* Ignore the redundant table. */ return 0 ;else /* Delete the redundant table, and proceed to add this one instead. */ break ;if (!p)return 1 ;if (is_default)return 0 ;/* Put tables corresponding to @ @ gtid_pos_auto_engines at the end of the list , marked to be auto - created if needed . static int int err= 0 ;for (auto_engines= opt_gtid_pos_auto_plugins;void *hton= plugin_hton(*auto_engines);/* See if this engine is already in the list. */ while (entry)if (entry->table_hton == hton)break ;if (entry)continue ;/* Add an auto-create entry for this engine at end of list. */ "_" )})if (!entry)1 ;break ;return err;static int void *arg)int err;static_cast <load_gtid_state_cb_data *>(arg);void *hton;if ((err= scan_one_gtid_slave_pos_table(thd, data->hash, data->array,return err;return process_gtid_pos_table(thd, table_name, hton, data);int bool array_inited= false ;struct gtid_pos_element tmp_entry, *entry;int err= 0 ;"rpl_load_gtid_slave_state" );bool loaded= rpl_global_gtid_slave_state->loaded;if (loaded)0 );32 ,sizeof (uint32), NULL, my_free, HASH_UNIQUE);if ((err= my_init_dynamic_array(PSI_INSTRUMENT_ME, &array,sizeof (gtid_pos_element), 0 , 0 , MYF(0 ))))goto end;true ;if ((err= scan_all_gtid_slave_pos_table(thd, load_gtid_state_cb, &cb_data)))goto end;if (!cb_data.default_entry)/* If the mysql . gtid_slave_pos table does not exist , but at least one other table is available , arbitrarily pick the first in the list to use as default . if ((err= gtid_pos_auto_create_tables(&cb_data.table_list)))goto end;if (rpl_global_gtid_slave_state->loaded)goto end;if (!cb_data.table_list)0 ), "mysql" ,1 ;goto end;for (i= 0 ; i < array.elements; ++i)if ((err= rpl_global_gtid_slave_state->update_nolock(tmp_entry.gtid.domain_id,0 ));goto end;for (i= 0 ; i < hash.records; ++i)struct gtid_pos_element *)my_hash_element(&hash, i);if (opt_bin_log &&0 ));goto end;true ;/* Clear out no longer needed elements now. */ if (old_gtids_list)if (array_inited)if (cb_data.table_list)static int void *arg)static_cast <load_gtid_state_cb_data *>(arg);int err;if ((err= open_and_lock_tables(thd, &tlist, FALSE , 0 )))goto end;if ((err= gtid_check_rpl_slave_state_table(table)))goto end;if (table)FALSE );return err;/* Re - compute the list of available mysql . gtid_slave_posXXX tables . This is done at START SLAVE to pick up any newly created tables without requiring server restart . int int err= 0 ;bool loaded= rpl_global_gtid_slave_state->loaded;if (!loaded)return 0 ;if ((err= scan_all_gtid_slave_pos_table(thd, find_gtid_pos_tables_cb, &cb_data)))goto end;if (!cb_data.table_list)0 ), "mysql" ,1 ;goto end;if (!cb_data.default_entry)/* If the mysql . gtid_slave_pos table does not exist , but at least one other table is available , arbitrarily pick the first in the list to use as default . if ((err= gtid_pos_auto_create_tables(&cb_data.table_list)))goto end;true );if (num_running <= 1 )/* If no slave is running now , the count will be 1 , since this SQL thread which is starting is included in the count . In this case , we can safely replace the list , no - one can be trying to read it without lock . 1 );else /* If there are SQL threads running , we cannot safely remove the old list . However we can add new entries , and warn about any tables that disappeared , but may still be visible to running SQL threads . auto old_entry= rpl_global_gtid_slave_state->while (old_entry)while (new_entry)if (new_entry->table_hton == old_entry->table_hton)break ;if (!new_entry)"The table mysql.%s was removed. " "This change will not take full effect " "until all SQL threads have been restarted" ,while (new_entry)/* Check if we already have a table with this storage engine. */ while (old_entry)if (new_entry->table_hton == old_entry->table_hton)break ;if (old_entry)/* This new_entry is already available in the list. */ else /* Move this new_entry to the list. */ if (cb_data.table_list)return err;void this ->rli= rli;0 ;0 ;0 ;0 ;0 ;false ;0 ;0 ;false ;false ;0 ;0 ;0 ;0 ;0 ;false ;0 ), wait_commit_sub_id(0 ),0 ), parallel_entry(0 ),0 ), is_parallel_exec(false ),0 ), gtid_ev_flags_extra(0 ), gtid_ev_sa_seq_no(0 ),0 ), finish_event_group_called(0 ), rpt(NULL),false ), sa_info(NULL),false ), assembler(NULL)sizeof (current_gtid));delete deferred_events;int if (!sub_id)/* Out of memory caused hash insertion to fail. */ return 1 ;true ;return 0 ;void /* ToDo : This needs to work on rpl_group_info , not Relay_log_info , to be thread - safe for parallel replication . switch (typ) {case FORMAT_DESCRIPTION_EVENT:/* Format_description_log_event should not be deleted because it will be used to read info about the relay log ' s format ; it will be deleted when the SQL thread does not need it , i . e . when this thread terminates . break ;case ANNOTATE_ROWS_EVENT:/* Annotate_rows event should not be deleted because after it has been applied , thd - > query points to the string inside this event . The thd - > query will be used to generate new Annotate_rows event during applying the subsequent Rows events . break ;case DELETE_ROWS_EVENT_V1:case UPDATE_ROWS_EVENT_V1:case WRITE_ROWS_EVENT_V1:case DELETE_ROWS_EVENT:case UPDATE_ROWS_EVENT:case WRITE_ROWS_EVENT:case WRITE_ROWS_COMPRESSED_EVENT:case DELETE_ROWS_COMPRESSED_EVENT:case UPDATE_ROWS_COMPRESSED_EVENT:case WRITE_ROWS_COMPRESSED_EVENT_V1:case UPDATE_ROWS_COMPRESSED_EVENT_V1:case DELETE_ROWS_COMPRESSED_EVENT_V1:/* After the last Rows event has been applied , the saved Annotate_rows event ( if any ) is not needed anymore and can be deleted . if (((Rows_log_event*)ev)->get_flags(Rows_log_event::STMT_END_F))/* fall through */ default :"info" , ("Deleting the event after it has been executed" ));if (!rgi->is_deferred_event(ev))delete ev;break ;void rpl_group_info::cleanup_context(THD *thd, bool error, bool keep_domain_owner)"rpl_group_info::cleanup_context" );"enter" , ("error: %d" , (int ) error));this ->thd == thd);/* 1 ) Instances of Table_map_log_event , if : : do_apply_event ( ) was called on them , may have opened tables , which we cannot be sure have been closed ( because maybe the Rows_log_event have not been found or will not be , because slave SQL thread is stopping , or relay log has a missing tail etc ) . So we close all thread ' s tables . And so the table mappings have to be cancelled . 2 ) Rows_log_event : : do_apply_event ( ) may even have started statements or transactions on them , which we need to rollback in case of error . 3 ) If finding a Format_description_log_event after a BEGIN , we also need to rollback before continuing with the next events . 4 ) so we need this " context cleanup " function . if (unlikely(error))/* We have to reset the error as otherwise we get an assert in trans_rollback ( ) when it checks if the rollback caused an error . // if a "statement transaction" /* trans_rollback() also resets OPTION_GTID_BEGIN */ // if a "real transaction" /* Now that we have rolled back the transaction , make sure we do not erroneously update the GTID position . false ;if (unlikely(error))// leave alone any XA prepared transactions if (thd->transaction->xid_state.is_explicit_XA() &&if (thd == rli->sql_driver_thd)/* Reset flags . This is needed to handle incident events and errors in the relay log noticed by the sql driver thread . /* Ensure we always release the domain for others to process , when using - - gtid - ignore - duplicates . if (gtid_ignore_duplicate_state != GTID_DUPLICATE_NULL && !keep_domain_owner)this );/* Cleanup for the flags that have been set at do_apply_event . /* Reset state related to long_find_row notes in the error log : - timestamp - flag that decides whether the slave prints or not "inject_sleep_gtid_100_x_x" , {if (current_gtid.domain_id == 100 )50000 );void rpl_group_info::clear_tables_to_lock()"rpl_group_info::clear_tables_to_lock()" );#ifndef DBUG_OFF/** When replicating in RBR and MyISAM Merge tables are involved open_and_lock_tables ( called in do_apply_event ) appends the base tables to the list of tables_to_lock . Then these are removed from the list in close_thread_tables ( which is called before we reach this point ) . This assertion just confirms that we get no surprises at this point . 0 ;for (TABLE_LIST *ptr= tables_to_lock ; ptr ; ptr= ptr->next_global, i++) ;#endif while (tables_to_lock)reinterpret_cast <uchar*>(tables_to_lock);if (tables_to_lock->m_tabledef_valid)FALSE ;/* If blob fields were used during conversion of field values from the master table into the slave table , then we need to free the memory used temporarily to store their values before copying into the slave ' s table . if (tables_to_lock->m_conv_table)static_cast <RPL_TABLE_LIST*>(tables_to_lock->next_global);0 );void rpl_group_info::slave_close_thread_tables(THD *thd)"rpl_group_info::slave_close_thread_tables(THD *thd)" );true );#ifdef WITH_WSREP// This can happen e.g. when table_def::compatible_with fails and sets a error // but thd->is_error() is false then. However, we do not want to commit // statement on Galera instead we want to rollback it as later in // apply_write_set we rollback transaction and that can't be done // after wsrep transaction state is s_committed. if (WSREP(thd))thd);else #endif false );/* - If transaction rollback was requested due to deadlock perform it and release metadata locks . - If inside a multi - statement transaction , defer the release of metadata locks until the current transaction is either committed or rolled back . This prevents other statements from modifying the table for the entire duration of this transaction . This provides commit ordering and guarantees serializability across multiple transactions . - If in autocommit mode , or outside a transactional context , automatically release metadata locks of the current statement . if (thd->transaction_rollback_request)else if (! thd->in_multi_stmt_transaction_mode())else static void /* Signal any following GCO whose wait_count has been reached now. */ while ((tmp= tmp->next_gco))if (wait_count > count)break ;void if (did_mark_start_commit)return ;true ;this );void if (did_mark_start_commit)return ;true ;this ->parallel_entry;this );/* Format the current GTID as a string suitable for printing in error messages . The string is stored in a buffer inside rpl_group_info , so remains valid until next call to gtid_info ( ) or until destruction of rpl_group_info . If no GTID is available , then NULL is returned . char *const if (!gtid_sub_id || !current_gtid.seq_no)return NULL;sizeof (gtid_info_buf), "Gtid %u-%u-%llu" ,return gtid_info_buf;/* Undo the effect of a prior mark_start_commit ( ) . This is only used for retrying a transaction in parallel replication , after we have encountered a deadlock or other temporary error . When we get such a deadlock , it means that the current group of transactions did not yet all start committing ( else they would not have deadlocked ) . So we will not yet have woken up anything in the next group , our rgi - > gco is still live , and we can simply decrement the counter ( to be incremented again later , when the retry succeeds and reaches the commit step ) . void if (!did_mark_start_commit)return ;false ;this ->parallel_entry;/* Assert that we have not already wrongly completed this GCO and signalled the next one to start , only to now unmark and make the signal invalid . This is to catch problems like MDEV - 34696 . The error inject rpl_parallel_simulate_temp_err_xid is used to test this precise situation , that we handle it gracefully if it somehow occurs in a release build . So disable the assert in this case . #ifndef DBUG_OFFbool allow_unmark_after_complete= false ;"rpl_parallel_simulate_temp_err_xid" ,true ;);#endif void rpl_sql_thread_info::cached_charset_invalidate()"rpl_group_info::cached_charset_invalidate" );/* Full of zeroes means uninitialized. */ sizeof (cached_charset));bool rpl_sql_thread_info::cached_charset_compare(char *charset) const "rpl_group_info::cached_charset_compare" );if (memcmp(cached_charset, charset, sizeof (cached_charset)))const_cast <char *>(cached_charset), charset, sizeof (cached_charset));1 );0 );/** Store the file and position where the slave ' s SQL thread are in the relay log . Notes : - This function should be called either from the slave SQL thread , or when the slave thread is not running . ( It reads the group_ { relay | master } _ log_ { pos | name } and delay fields in the rli object . These may only be modified by the slave SQL thread or by a client thread when the slave SQL thread is not running . ) - If there is an active transaction , then we do not update the position in the relay log . This is to ensure that we re - execute statements if we die in the middle of an transaction that was rolled back . - As a transaction never spans binary logs , we don ' t have to handle the case where we do a relay - log - rotation in the middle of the transaction . If transactions could span several binlogs , we would have to ensure that we do not delete the relay log file where the transaction started before switching to a new relay log file . - Error can happen if writing to file fails or if flushing the file fails . @ return 0 on success , 1 on error . bool Relay_log_info::flush()bool error=0 ;"Relay_log_info::flush()" );if (flush_io_cache(file))1 ;if (sync_relayloginfo_period &&if (my_sync(info_fd, MYF(MY_WME)))1 ;0 ;/* Flushing the relay log is done by the slave I / O thread or by the user on STOP SLAVE . #endif
Messung V0.5 in Prozent C=95 H=81 G=88
¤ Dauer der Verarbeitung: 0.85 Sekunden
(vorverarbeitet am 2026-10-08)
¤ *© Formatika GbR, Deutschland
2026-10-09
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=1126438 #Domains=1867298
