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