MySQL 8.3.0
Source Code Documentation
rpl_replica.h
Go to the documentation of this file.
1/* Copyright (c) 2000, 2023, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef RPL_REPLICA_H
24#define RPL_REPLICA_H
25
26#include <limits.h>
27#include <sys/types.h>
28#include <atomic>
29
30#include "my_bitmap.h"
31#include "my_dbug.h"
32#include "my_inttypes.h"
33#include "my_psi_config.h"
34#include "my_thread.h" // my_start_routine
35#include "mysql.h" // MYSQL
37#include "mysql_com.h"
39#include "sql/current_thd.h"
40#include "sql/debug_sync.h"
41
42class Master_info;
43class Relay_log_info;
44class THD;
45struct LEX_MASTER_INFO;
46struct mysql_cond_t;
47struct mysql_mutex_t;
49
50/*
51 Statistics go to the error log every # of seconds when
52 --log_error_verbosity > 2
53*/
54const long mts_online_stat_period = 60 * 2;
55const long mts_online_stat_count = 1024;
56
58
59typedef enum {
65
66/**
67 MASTER_DELAY can be at most (1 << 31) - 1.
68*/
69#define MASTER_DELAY_MAX (0x7FFFFFFF)
70#if INT_MAX < 0x7FFFFFFF
71#error "don't support platforms where INT_MAX < 0x7FFFFFFF"
72#endif
73
74/**
75 @defgroup Replication Replication
76 @{
77
78 @file
79*/
80
81/**
82 Some of defines are need in parser even though replication is not
83 compiled in (embedded).
84*/
85
86/**
87 The maximum is defined as (ULONG_MAX/1000) with 4 bytes ulong
88*/
89#define SLAVE_MAX_HEARTBEAT_PERIOD 4294967
90
91#define REPLICA_NET_TIMEOUT 60
92
93#define MAX_SLAVE_ERROR 14000
94
95#define MTS_WORKER_UNDEF ((ulong)-1)
96#define MTS_MAX_WORKERS 1024
97#define MAX_SLAVE_RETRY_PAUSE 5
98
99/*
100 When using tables to store the slave workers bitmaps,
101 we use a BLOB field. The maximum size of a BLOB is:
102
103 2^16-1 = 65535 bytes => (2^16-1) * 8 = 524280 bits
104*/
105#define MTS_MAX_BITS_IN_GROUP ((1L << 19) - 8) /* 524280 */
106
107extern bool server_id_supplied;
108
109/*****************************************************************************
110
111 MySQL Replication
112
113 Replication is implemented via two types of threads:
114
115 I/O Thread - One of these threads is started for each master server.
116 They maintain a connection to their master server, read log
117 events from the master as they arrive, and queues them into
118 a single, shared relay log file. A Master_info represents
119 each of these threads.
120
121 SQL Thread - One of these threads is started and reads from the relay log
122 file, executing each event. A Relay_log_info represents this
123 thread.
124
125 Buffering in the relay log file makes it unnecessary to reread events from
126 a master server across a slave restart. It also decouples the slave from
127 the master where long-running updates and event logging are concerned--ie
128 it can continue to log new events while a slow query executes on the slave.
129
130*****************************************************************************/
131
132/*
133 # MUTEXES in replication #
134
135 JAG: TODO: This guide needs to be updated after pushing WL#10406!
136
137 ## In Multisource_info (channel_map) ##
138
139 ### m_channel_map_lock ###
140
141 This rwlock is used to protect the multi source replication data structure
142 (channel_map). Any operation reading contents from the channel_map should
143 hold the rdlock during the operation. Any operation changing the
144 channel_map (either adding/removing channels to/from the channel_map)
145 should hold the wrlock during the operation.
146
147 [init_replica() does not need it it's called early].
148
149 ## In Master_info (mi) ##
150
151 ### m_channel_lock ###
152
153 It is used to SERIALIZE ALL administrative commands of replication: START
154 SLAVE, STOP SLAVE, CHANGE MASTER, RESET SLAVE, delete_slave_info_objects
155 (when mysqld stops)
156
157 This thus protects us against a handful of deadlocks, being the know ones
158 around lock_slave_threads and the mixed order they are acquired in some
159 operations:
160
161 + consider start_slave_thread() which, when starting the I/O thread,
162 releases mi->run_lock, keeps rli->run_lock, and tries to re-acquire
163 mi->run_lock.
164
165 + Same applies to stop_slave() where a stop of the I/O thread will
166 mi->run_lock, keeps rli->run_lock, and tries to re-acquire mi->run_lock.
167 For the SQL thread, the order is the opposite.
168
169 ### run_lock ###
170
171 Protects all information about the running state: slave_running, thd
172 and the existence of the I/O thread itself (to stop/start it, you need
173 this mutex).
174 Check the above m_channel_lock about locking order.
175
176 ### data_lock ###
177
178 Protects some moving members of the struct: counters (log name,
179 position).
180
181 ### tsid_lock ###
182
183 Protects the retrieved GTID set and it's TSID map from updates.
184
185 ## In Relay_log_info (rli) ##
186
187 ### run_lock ###
188
189 Same as Master_info's one. However, note that run_lock does not protect
190 Relay_log_info.run_state. That is protected by data_lock.
191 Check the above m_channel_lock about locking order.
192
193 ### data_lock ###
194
195 Protects some moving members of the struct: counters (log name,
196 position).
197
198 ## In MYSQL_BIN_LOG (mysql_bin_log,relay_log) ##
199
200 ### LOCK_log ###
201
202 This mutex should be taken when going to write to a log file. Notice that it
203 does not prevent other threads from reading from the file being written (the
204 "hot" file) or any other older file.
205
206 ### LOCK_index ###
207
208 This mutex should be taken when going to create/delete a log file (as those
209 operations will update the .index file).
210
211 ### LOCK_binlog_end_pos ###
212
213 This mutex protects the access to the binlog_end_pos variable. The variable
214 it set with the position that other threads reading from the currently active
215 log file (the "hot" one) should not cross.
216
217 ## Gtid_state (gtid_state, global_tsid_map) ##
218
219 ### global_tsid_lock ###
220
221 Protects all Gtid_state GTID sets (lost_gtids, executed_gtids,
222 gtids_only_in_table, previous_gtids_logged, owned_gtids) and the global TSID
223 map from updates.
224
225 The global_tsid_lock must not be taken after LOCK_reset_gtid_table.
226
227 ## Gtid_mode (gtid_mode) ##
228
229 ### Gtid_mode::lock ###
230
231 Used to arbitrate changes on server Gtid_mode.
232
233 # Order of acquisition #
234
235 Here, we list most major functions that acquire multiple locks.
236
237 Notation: For each function, we list the locks it takes, in the
238 order it takes them. If a function holds lock A while taking lock
239 B, then we write "A, B". If a function locks A, unlocks A, then
240 locks B, then we write "A | B". If function F1 invokes function F2,
241 then we write F2's name in parentheses in the list of locks for F1.
242
243 Sys_var_gtid_mode::global_update:
244 Gtid_mode::lock.wrlock, channel_map->wrlock, binlog.LOCK_log,
245 global_tsid_lock->wrlock
246
247 change_master_cmd:
248 channel_map.wrlock, (change_master)
249
250 change_master:
251 mi.channel_wrlock, mi.run_lock, rli.run_lock, (global_init_info),
252 (purge_relay_logs), (init_relay_log_pos), rli.err_lock
253
254 global_init_info:
255 mi.data_lock, rli.data_lock
256
257 purge_relay_logs:
258 rli.data_lock, (relay_log.reset_logs)
259
260 relay_log.reset_logs:
261 .LOCK_log, .LOCK_index, .tsid_lock->wrlock
262
263 init_relay_log_pos:
264 rli.data_lock
265
266 queue_event:
267 rli.LOCK_log, relay_log.tsid_lock->rdlock, mi.data_lock
268
269 stop_slave:
270 channel_map rdlock,
271 ( mi.channel_wrlock, mi.run_lock, thd.LOCK_thd_data
272 | rli.run_lock, thd.LOCK_thd_data
273 | relay.LOCK_log
274 )
275
276 start_slave:
277 mi.channel_wrlock, mi.run_lock, rli.run_lock, rli.data_lock,
278 global_tsid_lock->wrlock
279
280 mysql_bin_log.reset_logs:
281 .LOCK_log, .LOCK_index, global_tsid_lock->wrlock
282
283 purge_relay_logs:
284 rli.data_lock, (relay.reset_logs) THD::LOCK_thd_data,
285 relay.LOCK_log, relay.LOCK_index, global_tsid_lock->wrlock
286
287 reset_binary_logs_and_gtids:
288 (binlog.reset_logs) THD::LOCK_thd_data, binlog.LOCK_log,
289 binlog.LOCK_index, global_tsid_lock->wrlock, LOCK_reset_gtid_table
290
291 reset_slave:
292 mi.channel_wrlock, mi.run_lock, rli.run_lock, (purge_relay_logs)
293 rli.data_lock, THD::LOCK_thd_data, relay.LOCK_log, relay.LOCK_index,
294 global_tsid_lock->wrlock
295
296 purge_logs:
297 .LOCK_index, LOCK_thd_list, thd.linfo.lock
298
299 [Note: purge_logs contains a known bug: LOCK_index should not be
300 taken before LOCK_thd_list. This implies that, e.g.,
301 purge_source_logs_to_file can deadlock with reset_binary_logs_and_gtids.
302 However, although purge_first_log and reset_slave take locks in reverse order,
303 they cannot deadlock because they both first acquire rli.data_lock.]
304
305 purge_source_logs_to_file, purge_source_logs_before_date, purge:
306 (binlog.purge_logs) binlog.LOCK_index, LOCK_thd_list, thd.linfo.lock
307
308 purge_first_log:
309 rli.data_lock, relay.LOCK_index, rli.log_space_lock,
310 (relay.purge_logs) LOCK_thd_list, thd.linfo.lock
311
312 MYSQL_BIN_LOG::new_file_impl:
313 .LOCK_log, .LOCK_index,
314 ( [ if binlog: LOCK_prep_xids ]
315 | global_tsid_lock->wrlock
316 )
317
318 rotate_relay_log:
319 (relay.new_file_impl) relay.LOCK_log, relay.LOCK_index
320
321 kill_zombie_dump_threads:
322 LOCK_thd_list, thd.LOCK_thd_data
323
324 rli_init_info:
325 rli.data_lock,
326 ( relay.log_lock
327 | global_tsid_lock->wrlock
328 | (relay.open_binlog)
329 | (init_relay_log_pos) rli.data_lock, relay.log_lock
330 )
331
332 So the DAG of lock acquisition order (not counting the buggy
333 purge_logs) is, empirically:
334
335 Gtid_mode::lock, channel_map lock, mi.run_lock, rli.run_lock,
336 ( rli.data_lock,
337 ( LOCK_thd_list,
338 (
339 ( binlog.LOCK_log, binlog.LOCK_index
340 | relay.LOCK_log, relay.LOCK_index
341 ),
342 ( rli.log_space_lock | global_tsid_lock->wrlock )
343 | binlog.LOCK_log, binlog.LOCK_index, LOCK_prep_xids
344 | thd.LOCK_data
345 )
346 | mi.err_lock, rli.err_lock
347 )
348 )
349 )
350 | mi.data_lock, rli.data_lock
351*/
352
353extern ulong master_retry_count;
355extern char slave_skip_error_names[];
356extern bool use_slave_mask;
357extern char *replica_load_tmpdir;
361extern char *opt_binlog_index_name;
362extern bool opt_skip_replica_start;
363extern bool opt_log_replica_updates;
364extern char *opt_replica_skip_errors;
366
367extern const char *relay_log_index;
368extern const char *relay_log_basename;
369
370/// @brief Helper class used to initialize the replica (includes init_replica())
371/// @details init_replica is called once during the mysqld start-up
373 public:
374 /// @brief Constructor, calls init_replica()
375 /// @param[in] opt_initialize Server option used to indicate whether mysqld
376 /// has been started with --initialize
377 /// @param[in] opt_skip_replica_start When true, skips the start of
378 /// replication threads
379 /// @param[in] filters Replication filters
380 /// @param[in] replica_skip_erors TBD
382 Rpl_channel_filters &filters, char **replica_skip_erors);
383
384 /// @brief Gets initialization code set-up at replica initialization
385 /// @return Error code obtained during the replica initialization
386 int get_initialization_code() const;
387
388 private:
389 /// @brief This function starts replication threads
390 /// @param[in] skip_replica_start When true, skips the start of replication
391 /// threads threads
392 void start_replication_threads(bool skip_replica_start = true);
393
394 /// @brief Initializes replica PSI keys in case PSI interface is available
395 static void init_replica_psi_keys();
396
397 /// @brief Performs replica initialization, creates default replication
398 /// channel and sets channel filters
399 /// @returns Error code
400 int init_replica();
401
402 /// @brief In case debug mode is on, prints channel information
403 void print_channel_info() const;
404
405 /// @brief This function starts replication threads
406 void start_threads();
407
409 false; ///< Indicates whether to initialize replica
411 false; ///< Indicates whether replica threads should be started or not
412 int m_init_code = 0; ///< Replica initialization error code
413 int m_thread_mask = 0; ///< Thread mask indicating type of the thread
414};
415
416/*
417 3 possible values for Master_info::slave_running and
418 Relay_log_info::slave_running.
419 The values 0,1,2 are very important: to keep the diff small, I didn't
420 substitute places where we use 0/1 with the newly defined symbols. So don't
421 change these values. The same way, code is assuming that in Relay_log_info we
422 use only values 0/1. I started with using an enum, but enum_variable=1; is not
423 legal so would have required many line changes.
424*/
425#define MYSQL_SLAVE_NOT_RUN 0
426#define MYSQL_SLAVE_RUN_NOT_CONNECT 1
427#define MYSQL_SLAVE_RUN_CONNECT 2
428
429/*
430 If the following is set, if first gives an error, second will be
431 tried. Otherwise, if first fails, we fail.
432*/
433#define SLAVE_FORCE_ALL 4
434
435/* @todo: see if you can change to int */
436bool start_slave_cmd(THD *thd);
437bool stop_slave_cmd(THD *thd);
438bool change_master_cmd(THD *thd);
439int change_master(THD *thd, Master_info *mi, LEX_MASTER_INFO *lex_mi,
440 bool preserve_logs = false);
441bool reset_slave_cmd(THD *thd);
442bool show_slave_status_cmd(THD *thd);
443bool flush_relay_logs_cmd(THD *thd);
444/**
445 Re-encrypt previous relay logs with current master key for all slave channels.
446
447 @retval false Success.
448 @retval true Error.
449*/
451int flush_relay_logs(Master_info *mi, THD *thd);
452int reset_slave(THD *thd, Master_info *mi, bool reset_all);
453int reset_slave(THD *thd);
455/**
456 Call mi->init_info() and/or mi->rli->init_info(), which will read
457 the replication configuration from repositories.
458
459 This takes care of creating a transaction context in case table
460 repository is needed.
461
462 @param mi The Master_info object to use.
463
464 @param ignore_if_no_info If this is false, and the repository does
465 not exist, it will be created. If this is true, and the repository
466 does not exist, nothing is done.
467
468 @param thread_mask Indicate which repositories will be initialized:
469 if (thread_mask&SLAVE_IO)!=0, then mi->init_info is called; if
470 (thread_mask&SLAVE_SQL)!=0, then mi->rli->init_info is called.
471
472 @param force_load repositories will only read information if they
473 are not yet initialized. When true this flag forces the repositories
474 to load information from table or file.
475
476 @param skip_received_gtid_set_recovery When true, skips the received GTID
477 set recovery.
478
479 @retval 0 Success
480 @retval nonzero Error
481*/
483 Master_info *mi, bool ignore_if_no_info, int thread_mask,
484 bool skip_received_gtid_set_recovery = false, bool force_load = false);
485void end_info(Master_info *mi);
486/**
487 Clear the information regarding the `Master_info` and `Relay_log_info` objects
488 represented by the parameter, meaning, setting to `NULL` all attributes that
489 are not meant to be kept between slave resets.
490
491 @param mi the `Master_info` reference that holds both `Master_info` and
492 `Relay_log_info` data.
493 */
494void clear_info(Master_info *mi);
495int remove_info(Master_info *mi);
496/**
497 Resets the information regarding the `Master_info` and `Relay_log_info`
498 objects represented by the parameter, meaning, setting to `NULL` all
499 attributes that are not meant to be kept between slave resets and persisting
500 all other attribute values in the repository.
501
502 @param mi the `Master_info` reference that holds both `Master_info` and
503 `Relay_log_info` data.
504
505 @returns true if an error occurred and false otherwiser.
506 */
507bool reset_info(Master_info *mi);
508
509/**
510 This method flushes the current configuration for the channel into the
511 connection metadata repository. It will also flush the current contents
512 of the relay log file if instructed to.
513
514 @param mi the `Master_info` reference that holds both `Master_info` and
515 `Relay_log_info` data.
516
517 @param force shall the method ignore the server settings that limit flushes
518 to this repository
519
520 @param need_lock shall the method take the associated data lock and log lock
521 if false ownership is asserted
522
523 @param flush_relay_log should the method also flush the relay log file
524
525 @param skip_repo_persistence if this method shall skip the repository flush
526 This won't skip the relay log flush if
527 flush_relay_log = true
528
529 @returns 0 if no error occurred, !=0 if an error occurred
530*/
531int flush_master_info(Master_info *mi, bool force, bool need_lock = true,
532 bool flush_relay_log = true,
533 bool skip_repo_persistence = false);
534void add_replica_skip_errors(const char *arg);
535void set_replica_skip_errors(char **replica_skip_errors_ptr);
536int add_new_channel(Master_info **mi, const char *channel);
537/**
538 Terminates the slave threads according to the given mask.
539
540 @param mi the master info repository
541 @param thread_mask the mask identifying which thread(s) to terminate
542 @param stop_wait_timeout the timeout after which the method returns and error
543 @param need_lock_term
544 If @c false the lock will not be acquired before waiting on
545 the condition. In this case, it is assumed that the calling
546 function acquires the lock before calling this function.
547
548 @return the operation status
549 @retval 0 OK
550 @retval ER_REPLICA_NOT_RUNNING
551 The slave is already stopped
552 @retval ER_STOP_REPLICA_SQL_THREAD_TIMEOUT
553 There was a timeout when stopping the SQL thread
554 @retval ER_STOP_REPLICA_IO_THREAD_TIMEOUT
555 There was a timeout when stopping the IO thread
556 @retval ER_ERROR_DURING_FLUSH_LOGS
557 There was an error while flushing the log/repositories
558*/
559int terminate_slave_threads(Master_info *mi, int thread_mask,
560 ulong stop_wait_timeout,
561 bool need_lock_term = true);
562bool start_slave_threads(bool need_lock_slave, bool wait_for_start,
563 Master_info *mi, int thread_mask);
564bool start_slave(THD *thd);
565int stop_slave(THD *thd);
566bool start_slave(THD *thd, LEX_SLAVE_CONNECTION *connection_param,
567 LEX_MASTER_INFO *master_param, int thread_mask_input,
568 Master_info *mi, bool set_mts_settings);
569int stop_slave(THD *thd, Master_info *mi, bool net_report, bool for_one_channel,
570 bool *push_temp_table_warning);
571/*
572 cond_lock is usually same as start_lock. It is needed for the case when
573 start_lock is 0 which happens if start_slave_thread() is called already
574 inside the start_lock section, but at the same time we want a
575 mysql_cond_wait() on start_cond, start_lock
576*/
578 mysql_mutex_t *start_lock, mysql_mutex_t *cond_lock,
579 mysql_cond_t *start_cond,
580 std::atomic<uint> *slave_running,
581 std::atomic<ulong> *slave_run_id, Master_info *mi);
582
583bool show_slave_status(THD *thd, Master_info *mi);
584bool show_slave_status(THD *thd);
585
586const char *print_slave_db_safe(const char *db);
587
588void end_slave(); /* release slave threads */
589void delete_slave_info_objects(); /* clean up slave threads data */
592int rotate_relay_log(Master_info *mi, bool log_master_fd = true,
593 bool need_lock = true, bool need_log_space_lock = true);
594typedef enum {
600 ulong event_len, bool flush_mi = true);
601
603 std::string binlog_name, uint64_t position,
604 unsigned long &inc_pos, bool &do_flush_mi);
605
606extern "C" void *handle_slave_io(void *arg);
607extern "C" void *handle_slave_sql(void *arg);
608
609/*
610 SYNPOSIS
611 connect_to_master()
612
613 IMPLEMENTATION
614 Try to connect until successful or replica killed or we have retried
615
616 @param[in] thd The thread.
617 @param[in] mysql MySQL connection handle
618 @param[in] mi The Master_info object of the failed connection which
619 needs to be reconnected to the new source.
620 @param[in] reconnect If its need to reconnect to existing source.
621 @param[in] host The Host name or ip address of the source to which
622 connection need to be made.
623 @param[in] port The Port of the source to which connection need to
624 be made.
625 @param[in] is_io_thread To determine if its IO or Monitor IO thread.
626
627 @retval 0 Success connecting to the source.
628 @retval # Error connecting to the source.
629*/
631 bool suppress_warnings,
632 const std::string &host = std::string(),
633 const uint port = 0, bool is_io_thread = true);
634
635bool net_request_file(NET *net, const char *fname);
636
637extern bool replicate_same_server_id;
638/* the master variables are defaults read from my.cnf or command line */
639extern uint report_port;
640extern char *report_user;
642
644/**
645 Processing rli->gaq to find out the low-water-mark (lwm) coordinates
646 which is stored into the central recovery table. rli->data_lock will be
647 required, so the caller should not hold rli->data_lock.
648
649 @param rli pointer to Relay-log-info of Coordinator
650 @param force if true then hang in a loop till some progress
651 @retval false Success
652 @retval true Error
653*/
654bool mta_checkpoint_routine(Relay_log_info *rli, bool force);
655bool sql_slave_killed(THD *thd, Relay_log_info *rli);
656
657/*
658 Check if the error is caused by network.
659 @param[in] errorno Number of the error.
660 RETURNS:
661 true network error
662 false not network error
663*/
664bool is_network_error(uint errorno);
665
666int init_replica_thread(THD *thd, SLAVE_THD_TYPE thd_type);
667
668/**
669 @} (end of group Replication)
670*/
671#endif
Definition: rpl_mi.h:86
Definition: rpl_rli.h:202
Helper class used to initialize the replica (includes init_replica())
Definition: rpl_replica.h:372
int m_init_code
Replica initialization error code.
Definition: rpl_replica.h:412
int m_thread_mask
Thread mask indicating type of the thread.
Definition: rpl_replica.h:413
bool m_opt_skip_replica_start
Indicates whether replica threads should be started or not.
Definition: rpl_replica.h:410
bool m_opt_initialize_replica
Indicates whether to initialize replica.
Definition: rpl_replica.h:408
The class is a container for all the per-channel filters, both a map of Rpl_filter objects and a list...
Definition: rpl_msr.h:472
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:35
int rotate_relay_log(Master_info *mi, bool log_master_fd, bool need_lock, bool need_log_space_lock)
Definition: rpl_replica.cc:8572
bool stop_slave_cmd(THD *thd)
Entry point for the STOP SLAVE command.
Definition: rpl_replica.cc:813
char * replica_load_tmpdir
Definition: rpl_replica.cc:193
QUEUE_EVENT_RESULT
Definition: rpl_replica.h:594
bool opt_log_replica_updates
Definition: mysqld.cc:1246
bool sql_slave_killed(THD *thd, Relay_log_info *rli)
The function analyzes a possible killed status and makes a decision whether to accept it or not.
Definition: rpl_replica.cc:2248
int heartbeat_queue_event(bool is_valid, Master_info *&mi, std::string binlog_name, uint64_t position, unsigned long &inc_pos, bool &do_flush_mi)
Definition: rpl_replica.cc:7488
const char * relay_log_basename
Definition: rpl_replica.cc:198
bool net_request_file(NET *net, const char *fname)
Definition: rpl_replica.cc:2355
bool start_slave_threads(bool need_lock_slave, bool wait_for_start, Master_info *mi, int thread_mask)
Definition: rpl_replica.cc:2040
bool mta_checkpoint_routine(Relay_log_info *rli, bool force)
Processing rli->gaq to find out the low-water-mark (lwm) coordinates which is stored into the central...
Definition: rpl_replica.cc:6446
void clear_info(Master_info *mi)
Clear the information regarding the Master_info and Relay_log_info objects represented by the paramet...
Definition: rpl_replica.cc:1383
void set_replica_skip_errors(char **replica_skip_errors_ptr)
Change arg to the string with the nice, human-readable skip error values.
Definition: rpl_replica.cc:1570
void start_threads()
This function starts replication threads.
Definition: rpl_replica.cc:490
bool change_master_cmd(THD *thd)
Entry point for the CHANGE MASTER command.
Definition: rpl_replica.cc:10960
char * opt_relay_logname
Definition: mysqld.cc:1662
void end_info(Master_info *mi)
Definition: rpl_replica.cc:1371
bool replicate_same_server_id
Definition: rpl_replica.cc:194
int init_replica_thread(THD *thd, SLAVE_THD_TYPE thd_type)
Definition: rpl_replica.cc:4042
int remove_info(Master_info *mi)
Definition: rpl_replica.cc:1403
char * report_password
Definition: rpl_replica.h:641
ReplicaInitializer(bool opt_initialize, bool opt_skip_replica_start, Rpl_channel_filters &filters, char **replica_skip_erors)
Constructor, calls init_replica()
Definition: rpl_replica.cc:420
const char * print_slave_db_safe(const char *db)
Definition: rpl_replica.cc:2368
ulong master_retry_count
Definition: mysqld.cc:1660
int change_master(THD *thd, Master_info *mi, LEX_MASTER_INFO *lex_mi, bool preserve_logs)
Execute a CHANGE MASTER statement.
Definition: rpl_replica.cc:10459
bool reencrypt_relay_logs()
Re-encrypt previous relay logs with current master key for all slave channels.
Definition: rpl_replica.cc:8746
QUEUE_EVENT_RESULT queue_event(Master_info *mi, const char *buf, ulong event_len, bool do_flush_mi)
Store an event received from the master connection into the relay log.
Definition: rpl_replica.cc:7593
bool flush_relay_logs_cmd(THD *thd)
Entry point for FLUSH RELAYLOGS command or to flush relaylogs for the FLUSH LOGS command.
Definition: rpl_replica.cc:8678
char * report_user
Definition: mysqld.cc:1661
static void init_replica_psi_keys()
Initializes replica PSI keys in case PSI interface is available.
Definition: rpl_replica.cc:525
int stop_slave(THD *thd)
Function to stop a slave for all channels.
Definition: rpl_replica.cc:668
int add_new_channel(Master_info **mi, const char *channel)
This function is first called when the Master_info object corresponding to a channel in a multisource...
Definition: rpl_replica.cc:10808
void * handle_slave_io(void *arg)
Slave IO thread entry point.
Definition: rpl_replica.cc:5323
bool reset_slave_cmd(THD *thd)
Entry function for RESET SLAVE command.
Definition: rpl_replica.cc:9299
bool is_network_error(uint errorno)
Definition: rpl_replica.cc:2374
void add_replica_skip_errors(const char *arg)
Definition: rpl_replica.cc:1619
ulonglong relay_log_space_limit
Definition: rpl_replica.cc:195
bool opt_skip_replica_start
If set, slave is not autostarted.
Definition: mysqld.cc:1241
void start_replication_threads(bool skip_replica_start=true)
This function starts replication threads.
Definition: rpl_replica.cc:484
bool show_slave_status(THD *thd)
Method to the show the replication status in all channels.
Definition: rpl_replica.cc:3724
void print_channel_info() const
In case debug mode is on, prints channel information.
Definition: rpl_replica.cc:463
bool reset_info(Master_info *mi)
Resets the information regarding the Master_info and Relay_log_info objects represented by the parame...
Definition: rpl_replica.cc:1424
int load_mi_and_rli_from_repositories(Master_info *mi, bool ignore_if_no_info, int thread_mask, bool skip_received_gtid_set_recovery, bool force_load)
Call mi->init_info() and/or mi->rli->init_info(), which will read the replication configuration from ...
Definition: rpl_replica.cc:1261
const char * relay_log_index
Definition: rpl_replica.cc:197
int init_replica()
Performs replica initialization, creates default replication channel and sets channel filters.
Definition: rpl_replica.cc:538
int flush_relay_logs(Master_info *mi, THD *thd)
flushes the relay logs of a replication channel.
Definition: rpl_replica.cc:8633
void delete_slave_info_objects()
Free all resources used by slave threads at time of executing shutdown.
Definition: rpl_replica.cc:2167
bool mts_recovery_groups(Relay_log_info *rli)
Definition: rpl_replica.cc:6190
bool start_slave_cmd(THD *thd)
Entry point to the START SLAVE command.
Definition: rpl_replica.cc:715
int flush_master_info(Master_info *mi, bool force, bool need_lock, bool do_flush_relay_log, bool skip_repo_persistence)
This method flushes the current configuration for the channel into the connection metadata repository...
Definition: rpl_replica.cc:1459
char * report_host
Definition: mysqld.cc:1661
uint report_port
Definition: mysqld.cc:1659
bool opt_relaylog_index_name_supplied
Definition: mysqld.cc:1667
bool start_slave_thread(PSI_thread_key thread_key, my_start_routine h_func, mysql_mutex_t *start_lock, mysql_mutex_t *cond_lock, mysql_cond_t *start_cond, std::atomic< uint > *slave_running, std::atomic< ulong > *slave_run_id, Master_info *mi)
Definition: rpl_replica.cc:1964
void set_slave_thread_options(THD *thd)
Set slave thread default options.
Definition: rpl_replica.cc:3973
int get_initialization_code() const
Gets initialization code set-up at replica initialization.
Definition: rpl_replica.cc:418
bool server_id_supplied
Definition: mysqld.cc:1203
char * opt_relaylog_index_name
Definition: rpl_replica.h:358
int connect_to_master(THD *thd, MYSQL *mysql, Master_info *mi, bool reconnect, bool suppress_warnings, const std::string &host, const uint port, bool is_io_thread)
Definition: rpl_replica.cc:8336
int terminate_slave_threads(Master_info *mi, int thread_mask, ulong stop_wait_timeout, bool need_lock_term)
Terminates the slave threads according to the given mask.
Definition: rpl_replica.cc:1691
int init_recovery(Master_info *mi)
Definition: rpl_replica.cc:1141
char slave_skip_error_names[]
Definition: rpl_replica.cc:191
void end_slave()
Definition: rpl_replica.cc:2136
MY_BITMAP slave_error_mask
Definition: rpl_replica.cc:190
char * opt_binlog_index_name
Definition: mysqld.cc:1691
bool show_slave_status_cmd(THD *thd)
Entry point for SHOW REPLICA STATUS command.
Definition: rpl_replica.cc:3928
void * handle_slave_sql(void *arg)
Slave SQL thread entry point.
Definition: rpl_replica.cc:6961
bool use_slave_mask
Definition: rpl_replica.cc:189
void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli)
Definition: rpl_replica.cc:4019
bool opt_relay_logname_supplied
Definition: mysqld.cc:1672
bool start_slave(THD *thd)
Function to start a slave for all channels.
Definition: rpl_replica.cc:606
char * opt_replica_skip_errors
Definition: mysqld.cc:1247
@ QUEUE_EVENT_OK
Definition: rpl_replica.h:595
@ QUEUE_EVENT_ERROR_QUEUING
Definition: rpl_replica.h:596
@ QUEUE_EVENT_ERROR_FLUSHING_INFO
Definition: rpl_replica.h:597
unsigned int PSI_thread_key
Instrumented thread key.
Definition: psi_thread_bits.h:49
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
Defines to make different thread packages compatible.
void *(* my_start_routine)(void *)
Definition: my_thread.h:71
static int reconnect()
Definition: mysql.cc:3363
This file defines the client API to MySQL and also the ABI of the dynamically linked libmysqlclient.
Common definition between mysql server & client.
const char * host
Definition: mysqladmin.cc:63
bool opt_initialize
Definition: mysqld.cc:1240
Definition: buf0block_hint.cc:29
constexpr value_type reset_slave
Definition: classic_protocol_constants.h:313
bool is_valid(const dd::Spatial_reference_system *srs, const Geometry *g, const char *func_name, bool *is_valid) noexcept
Decides if a geometry is valid.
Definition: is_valid.cc:94
Definition: instrumented_condition_variable.h:31
Definition: buffer.h:44
Performance schema instrumentation interface.
required uint64 port
Definition: replication_asynchronous_connection_failover.proto:32
const long mts_online_stat_period
Definition: rpl_replica.h:54
const long mts_online_stat_count
Definition: rpl_replica.h:55
SLAVE_THD_TYPE
Definition: rpl_replica.h:59
@ SLAVE_THD_SQL
Definition: rpl_replica.h:61
@ SLAVE_THD_IO
Definition: rpl_replica.h:60
@ SLAVE_THD_WORKER
Definition: rpl_replica.h:62
@ SLAVE_THD_MONITOR
Definition: rpl_replica.h:63
Declarations for the Debug Sync Facility.
Structure to hold parameters for CHANGE MASTER, START SLAVE, and STOP SLAVE.
Definition: sql_lex.h:351
Definition: mysql.h:297
Definition: my_bitmap.h:42
Definition: mysql_com.h:919
Definition: task.h:426
An instrumented cond structure.
Definition: mysql_cond_bits.h:49
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
Definition: sql_lex.h:2514