MySQL 8.1.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;
55
57
58typedef enum {
64
65/**
66 MASTER_DELAY can be at most (1 << 31) - 1.
67*/
68#define MASTER_DELAY_MAX (0x7FFFFFFF)
69#if INT_MAX < 0x7FFFFFFF
70#error "don't support platforms where INT_MAX < 0x7FFFFFFF"
71#endif
72
73/**
74 @defgroup Replication Replication
75 @{
76
77 @file
78*/
79
80/**
81 Some of defines are need in parser even though replication is not
82 compiled in (embedded).
83*/
84
85/**
86 The maximum is defined as (ULONG_MAX/1000) with 4 bytes ulong
87*/
88#define SLAVE_MAX_HEARTBEAT_PERIOD 4294967
89
90#define REPLICA_NET_TIMEOUT 60
91
92#define MAX_SLAVE_ERROR 14000
93
94#define MTS_WORKER_UNDEF ((ulong)-1)
95#define MTS_MAX_WORKERS 1024
96#define MAX_SLAVE_RETRY_PAUSE 5
97
98/*
99 When using tables to store the slave workers bitmaps,
100 we use a BLOB field. The maximum size of a BLOB is:
101
102 2^16-1 = 65535 bytes => (2^16-1) * 8 = 524280 bits
103*/
104#define MTS_MAX_BITS_IN_GROUP ((1L << 19) - 8) /* 524280 */
105
106extern bool server_id_supplied;
107
108/*****************************************************************************
109
110 MySQL Replication
111
112 Replication is implemented via two types of threads:
113
114 I/O Thread - One of these threads is started for each master server.
115 They maintain a connection to their master server, read log
116 events from the master as they arrive, and queues them into
117 a single, shared relay log file. A Master_info represents
118 each of these threads.
119
120 SQL Thread - One of these threads is started and reads from the relay log
121 file, executing each event. A Relay_log_info represents this
122 thread.
123
124 Buffering in the relay log file makes it unnecessary to reread events from
125 a master server across a slave restart. It also decouples the slave from
126 the master where long-running updates and event logging are concerned--ie
127 it can continue to log new events while a slow query executes on the slave.
128
129*****************************************************************************/
130
131/*
132 # MUTEXES in replication #
133
134 JAG: TODO: This guide needs to be updated after pushing WL#10406!
135
136 ## In Multisource_info (channel_map) ##
137
138 ### m_channel_map_lock ###
139
140 This rwlock is used to protect the multi source replication data structure
141 (channel_map). Any operation reading contents from the channel_map should
142 hold the rdlock during the operation. Any operation changing the
143 channel_map (either adding/removing channels to/from the channel_map)
144 should hold the wrlock during the operation.
145
146 [init_replica() does not need it it's called early].
147
148 ## In Master_info (mi) ##
149
150 ### m_channel_lock ###
151
152 It is used to SERIALIZE ALL administrative commands of replication: START
153 SLAVE, STOP SLAVE, CHANGE MASTER, RESET SLAVE, delete_slave_info_objects
154 (when mysqld stops)
155
156 This thus protects us against a handful of deadlocks, being the know ones
157 around lock_slave_threads and the mixed order they are acquired in some
158 operations:
159
160 + consider start_slave_thread() which, when starting the I/O thread,
161 releases mi->run_lock, keeps rli->run_lock, and tries to re-acquire
162 mi->run_lock.
163
164 + Same applies to stop_slave() where a stop of the I/O thread will
165 mi->run_lock, keeps rli->run_lock, and tries to re-acquire mi->run_lock.
166 For the SQL thread, the order is the opposite.
167
168 ### run_lock ###
169
170 Protects all information about the running state: slave_running, thd
171 and the existence of the I/O thread itself (to stop/start it, you need
172 this mutex).
173 Check the above m_channel_lock about locking order.
174
175 ### data_lock ###
176
177 Protects some moving members of the struct: counters (log name,
178 position).
179
180 ### sid_lock ###
181
182 Protects the retrieved GTID set and it's SID map from updates.
183
184 ## In Relay_log_info (rli) ##
185
186 ### run_lock ###
187
188 Same as Master_info's one. However, note that run_lock does not protect
189 Relay_log_info.run_state. That is protected by data_lock.
190 Check the above m_channel_lock about locking order.
191
192 ### data_lock ###
193
194 Protects some moving members of the struct: counters (log name,
195 position).
196
197 ## In MYSQL_BIN_LOG (mysql_bin_log,relay_log) ##
198
199 ### LOCK_log ###
200
201 This mutex should be taken when going to write to a log file. Notice that it
202 does not prevent other threads from reading from the file being written (the
203 "hot" file) or any other older file.
204
205 ### LOCK_index ###
206
207 This mutex should be taken when going to create/delete a log file (as those
208 operations will update the .index file).
209
210 ### LOCK_binlog_end_pos ###
211
212 This mutex protects the access to the binlog_end_pos variable. The variable
213 it set with the position that other threads reading from the currently active
214 log file (the "hot" one) should not cross.
215
216 ## Gtid_state (gtid_state, global_sid_map) ##
217
218 ### global_sid_lock ###
219
220 Protects all Gtid_state GTID sets (lost_gtids, executed_gtids,
221 gtids_only_in_table, previous_gtids_logged, owned_gtids) and the global SID
222 map from updates.
223
224 The global_sid_lock must not be taken after LOCK_reset_gtid_table.
225
226 ## Gtid_mode (gtid_mode) ##
227
228 ### Gtid_mode::lock ###
229
230 Used to arbitrate changes on server Gtid_mode.
231
232 # Order of acquisition #
233
234 Here, we list most major functions that acquire multiple locks.
235
236 Notation: For each function, we list the locks it takes, in the
237 order it takes them. If a function holds lock A while taking lock
238 B, then we write "A, B". If a function locks A, unlocks A, then
239 locks B, then we write "A | B". If function F1 invokes function F2,
240 then we write F2's name in parentheses in the list of locks for F1.
241
242 Sys_var_gtid_mode::global_update:
243 Gtid_mode::lock.wrlock, channel_map->wrlock, binlog.LOCK_log,
244 global_sid_lock->wrlock
245
246 change_master_cmd:
247 channel_map.wrlock, (change_master)
248
249 change_master:
250 mi.channel_wrlock, mi.run_lock, rli.run_lock, (global_init_info),
251 (purge_relay_logs), (init_relay_log_pos), rli.err_lock
252
253 global_init_info:
254 mi.data_lock, rli.data_lock
255
256 purge_relay_logs:
257 rli.data_lock, (relay_log.reset_logs)
258
259 relay_log.reset_logs:
260 .LOCK_log, .LOCK_index, .sid_lock->wrlock
261
262 init_relay_log_pos:
263 rli.data_lock
264
265 queue_event:
266 rli.LOCK_log, relay_log.sid_lock->rdlock, mi.data_lock
267
268 stop_slave:
269 channel_map rdlock,
270 ( mi.channel_wrlock, mi.run_lock, thd.LOCK_thd_data
271 | rli.run_lock, thd.LOCK_thd_data
272 | relay.LOCK_log
273 )
274
275 start_slave:
276 mi.channel_wrlock, mi.run_lock, rli.run_lock, rli.data_lock,
277 global_sid_lock->wrlock
278
279 mysql_bin_log.reset_logs:
280 .LOCK_log, .LOCK_index, global_sid_lock->wrlock
281
282 purge_relay_logs:
283 rli.data_lock, (relay.reset_logs) THD::LOCK_thd_data,
284 relay.LOCK_log, relay.LOCK_index, global_sid_lock->wrlock
285
286 reset_master:
287 (binlog.reset_logs) THD::LOCK_thd_data, binlog.LOCK_log,
288 binlog.LOCK_index, global_sid_lock->wrlock, LOCK_reset_gtid_table
289
290 reset_slave:
291 mi.channel_wrlock, mi.run_lock, rli.run_lock, (purge_relay_logs)
292 rli.data_lock, THD::LOCK_thd_data, relay.LOCK_log, relay.LOCK_index,
293 global_sid_lock->wrlock
294
295 purge_logs:
296 .LOCK_index, LOCK_thd_list, thd.linfo.lock
297
298 [Note: purge_logs contains a known bug: LOCK_index should not be
299 taken before LOCK_thd_list. This implies that, e.g.,
300 purge_source_logs_to_file can deadlock with reset_master. However,
301 although purge_first_log and reset_slave take locks in reverse
302 order, they cannot deadlock because they both first acquire
303 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_sid_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_sid_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_sid_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;
358extern const char *master_info_file;
359extern const char *relay_log_info_file;
363extern char *opt_binlog_index_name;
364extern bool opt_skip_replica_start;
365extern bool opt_log_replica_updates;
366extern char *opt_replica_skip_errors;
368
369extern const char *relay_log_index;
370extern const char *relay_log_basename;
371
372/// @brief Helper class used to initialize the replica (includes init_replica())
373/// @details init_replica is called once during the mysqld start-up
375 public:
376 /// @brief Constructor, calls init_replica()
377 /// @param[in] opt_initialize Server option used to indicate whether mysqld
378 /// has been started with --initialize
379 /// @param[in] opt_skip_replica_start When true, skips the start of
380 /// replication threads
381 /// @param[in] filters Replication filters
382 /// @param[in] replica_skip_erors
384 Rpl_channel_filters &filters, char **replica_skip_erors);
385
386 /// @brief Gets initialization code set-up at replica initialization
387 /// @return Error code obtained during the replica initialization
388 int get_initialization_code() const;
389
390 private:
391 /// @brief This function starts replication threads
392 /// @param[in] skip_replica_start When true, skips the start of replication
393 /// threads threads
394 void start_replication_threads(bool skip_replica_start = true);
395
396 /// @brief Initializes replica PSI keys in case PSI interface is available
397 static void init_replica_psi_keys();
398
399 /// @brief Performs replica initialization, creates default replication
400 /// channel and sets channel filters
401 /// @returns Error code
402 int init_replica();
403
404 /// @brief In case debug mode is on, prints channel information
405 void print_channel_info() const;
406
407 /// @brief This function starts replication threads
408 void start_threads();
409
411 false; ///< Indicates whether to initialize replica
413 false; ///< Indicates whether replica threads should be started or not
414 int m_init_code = 0; ///< Replica initialization error code
415 int m_thread_mask = 0; ///< Thread mask indicating type of the thread
416};
417
418/*
419 3 possible values for Master_info::slave_running and
420 Relay_log_info::slave_running.
421 The values 0,1,2 are very important: to keep the diff small, I didn't
422 substitute places where we use 0/1 with the newly defined symbols. So don't
423 change these values. The same way, code is assuming that in Relay_log_info we
424 use only values 0/1. I started with using an enum, but enum_variable=1; is not
425 legal so would have required many line changes.
426*/
427#define MYSQL_SLAVE_NOT_RUN 0
428#define MYSQL_SLAVE_RUN_NOT_CONNECT 1
429#define MYSQL_SLAVE_RUN_CONNECT 2
430
431/*
432 If the following is set, if first gives an error, second will be
433 tried. Otherwise, if first fails, we fail.
434*/
435#define SLAVE_FORCE_ALL 4
436
437/* @todo: see if you can change to int */
438bool start_slave_cmd(THD *thd);
439bool stop_slave_cmd(THD *thd);
440bool change_master_cmd(THD *thd);
441int change_master(THD *thd, Master_info *mi, LEX_MASTER_INFO *lex_mi,
442 bool preserve_logs = false);
443bool reset_slave_cmd(THD *thd);
444bool show_slave_status_cmd(THD *thd);
445bool flush_relay_logs_cmd(THD *thd);
446/**
447 Re-encrypt previous relay logs with current master key for all slave channels.
448
449 @retval false Success.
450 @retval true Error.
451*/
453int flush_relay_logs(Master_info *mi, THD *thd);
454int reset_slave(THD *thd, Master_info *mi, bool reset_all);
455int reset_slave(THD *thd);
457/**
458 Call mi->init_info() and/or mi->rli->init_info(), which will read
459 the replication configuration from repositories.
460
461 This takes care of creating a transaction context in case table
462 repository is needed.
463
464 @param mi The Master_info object to use.
465
466 @param ignore_if_no_info If this is false, and the repository does
467 not exist, it will be created. If this is true, and the repository
468 does not exist, nothing is done.
469
470 @param thread_mask Indicate which repositories will be initialized:
471 if (thread_mask&SLAVE_IO)!=0, then mi->init_info is called; if
472 (thread_mask&SLAVE_SQL)!=0, then mi->rli->init_info is called.
473
474 @param force_load repositories will only read information if they
475 are not yet initialized. When true this flag forces the repositories
476 to load information from table or file.
477
478 @param skip_received_gtid_set_recovery When true, skips the received GTID
479 set recovery.
480
481 @retval 0 Success
482 @retval nonzero Error
483*/
485 Master_info *mi, bool ignore_if_no_info, int thread_mask,
486 bool skip_received_gtid_set_recovery = false, 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_SLAVE_CONNECTION *connection_param,
569 LEX_MASTER_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 */
594int rotate_relay_log(Master_info *mi, bool log_master_fd = true,
595 bool need_lock = true, bool need_log_space_lock = true);
596typedef enum {
602 ulong event_len, bool flush_mi = true);
603
605 std::string binlog_name, uint64_t position,
606 unsigned long &inc_pos, bool &do_flush_mi);
607
608extern "C" void *handle_slave_io(void *arg);
609extern "C" void *handle_slave_sql(void *arg);
610
611/*
612 SYNPOSIS
613 connect_to_master()
614
615 IMPLEMENTATION
616 Try to connect until successful or replica killed or we have retried
617
618 @param[in] thd The thread.
619 @param[in] mysql MySQL connection handle
620 @param[in] mi The Master_info object of the failed connection which
621 needs to be reconnected to the new source.
622 @param[in] reconnect If its need to reconnect to existing source.
623 @param[in] host The Host name or ip address of the source to which
624 connection need to be made.
625 @param[in] port The Port of the source to which connection need to
626 be made.
627 @param[in] is_io_thread To determine if its IO or Monitor IO thread.
628
629 @retval 0 Success connecting to the source.
630 @retval # Error connecting to the source.
631*/
633 bool suppress_warnings,
634 const std::string &host = std::string(),
635 const uint port = 0, bool is_io_thread = true);
636
637bool net_request_file(NET *net, const char *fname);
638
639extern bool replicate_same_server_id;
640
642
643/* the master variables are defaults read from my.cnf or command line */
644extern uint report_port;
645extern const char *master_info_file;
646extern const char *relay_log_info_file;
647extern char *report_user;
649
651/**
652 Processing rli->gaq to find out the low-water-mark (lwm) coordinates
653 which is stored into the central recovery table. rli->data_lock will be
654 required, so the caller should not hold rli->data_lock.
655
656 @param rli pointer to Relay-log-info of Coordinator
657 @param force if true then hang in a loop till some progress
658 @retval false Success
659 @retval true Error
660*/
661bool mta_checkpoint_routine(Relay_log_info *rli, bool force);
662bool sql_slave_killed(THD *thd, Relay_log_info *rli);
663
664/*
665 Check if the error is caused by network.
666 @param[in] errorno Number of the error.
667 RETURNS:
668 true network error
669 false not network error
670*/
671bool is_network_error(uint errorno);
672
673int init_replica_thread(THD *thd, SLAVE_THD_TYPE thd_type);
674
675/**
676 @} (end of group Replication)
677*/
678#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:374
int m_init_code
Replica initialization error code.
Definition: rpl_replica.h:414
int m_thread_mask
Thread mask indicating type of the thread.
Definition: rpl_replica.h:415
bool m_opt_skip_replica_start
Indicates whether replica threads should be started or not.
Definition: rpl_replica.h:412
bool m_opt_initialize_replica
Indicates whether to initialize replica.
Definition: rpl_replica.h:410
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:33
int rotate_relay_log(Master_info *mi, bool log_master_fd, bool need_lock, bool need_log_space_lock)
Definition: rpl_replica.cc:8567
bool stop_slave_cmd(THD *thd)
Entry point for the STOP SLAVE command.
Definition: rpl_replica.cc:814
char * replica_load_tmpdir
Definition: rpl_replica.cc:189
QUEUE_EVENT_RESULT
Definition: rpl_replica.h:596
bool opt_log_replica_updates
Definition: mysqld.cc:1240
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:2259
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:7487
const char * relay_log_basename
Definition: rpl_replica.cc:194
bool net_request_file(NET *net, const char *fname)
Definition: rpl_replica.cc:2366
bool start_slave_threads(bool need_lock_slave, bool wait_for_start, Master_info *mi, int thread_mask)
Definition: rpl_replica.cc:2046
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:6434
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:1386
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:1576
void start_threads()
This function starts replication threads.
Definition: rpl_replica.cc:491
bool change_master_cmd(THD *thd)
Entry point for the CHANGE MASTER command.
Definition: rpl_replica.cc:10978
char * opt_relay_logname
Definition: mysqld.cc:1652
void end_info(Master_info *mi)
Definition: rpl_replica.cc:1374
bool replicate_same_server_id
Definition: rpl_replica.cc:190
int init_replica_thread(THD *thd, SLAVE_THD_TYPE thd_type)
Definition: rpl_replica.cc:4052
int remove_info(Master_info *mi)
Definition: rpl_replica.cc:1406
char * report_password
Definition: rpl_replica.h:648
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:421
const char * print_slave_db_safe(const char *db)
Definition: rpl_replica.cc:2379
ulong master_retry_count
Definition: mysqld.cc:1648
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:10464
bool reencrypt_relay_logs()
Re-encrypt previous relay logs with current master key for all slave channels.
Definition: rpl_replica.cc:8741
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:7592
int disconnect_slave_event_count
Definition: rpl_replica.cc:234
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:8673
char * report_user
Definition: mysqld.cc:1651
static void init_replica_psi_keys()
Initializes replica PSI keys in case PSI interface is available.
Definition: rpl_replica.cc:526
int stop_slave(THD *thd)
Function to stop a slave for all channels.
Definition: rpl_replica.cc:669
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:10813
void * handle_slave_io(void *arg)
Slave IO thread entry point.
Definition: rpl_replica.cc:5319
bool reset_slave_cmd(THD *thd)
Entry function for RESET SLAVE command.
Definition: rpl_replica.cc:9294
bool is_network_error(uint errorno)
Definition: rpl_replica.cc:2385
void add_replica_skip_errors(const char *arg)
Definition: rpl_replica.cc:1625
ulonglong relay_log_space_limit
Definition: rpl_replica.cc:191
bool opt_skip_replica_start
If set, slave is not autostarted.
Definition: mysqld.cc:1235
const char * relay_log_info_file
Definition: rpl_replica.h:646
void start_replication_threads(bool skip_replica_start=true)
This function starts replication threads.
Definition: rpl_replica.cc:485
bool show_slave_status(THD *thd)
Method to the show the replication status in all channels.
Definition: rpl_replica.cc:3732
void print_channel_info() const
In case debug mode is on, prints channel information.
Definition: rpl_replica.cc:464
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:1427
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:1264
const char * relay_log_index
Definition: rpl_replica.cc:193
int init_replica()
Performs replica initialization, creates default replication channel and sets channel filters.
Definition: rpl_replica.cc:539
int flush_relay_logs(Master_info *mi, THD *thd)
flushes the relay logs of a replication channel.
Definition: rpl_replica.cc:8628
void delete_slave_info_objects()
Free all resources used by slave threads at time of executing shutdown.
Definition: rpl_replica.cc:2173
bool mts_recovery_groups(Relay_log_info *rli)
Definition: rpl_replica.cc:6180
bool start_slave_cmd(THD *thd)
Entry point to the START SLAVE command.
Definition: rpl_replica.cc:716
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:1465
char * report_host
Definition: mysqld.cc:1651
uint report_port
Definition: mysqld.cc:1647
bool opt_relaylog_index_name_supplied
Definition: mysqld.cc:1657
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:1970
void set_slave_thread_options(THD *thd)
Set slave thread default options.
Definition: rpl_replica.cc:3981
int get_initialization_code() const
Gets initialization code set-up at replica initialization.
Definition: rpl_replica.cc:419
bool server_id_supplied
Definition: mysqld.cc:1197
int abort_slave_event_count
Definition: rpl_replica.h:641
char * opt_relaylog_index_name
Definition: rpl_replica.h:360
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:8333
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:1697
int init_recovery(Master_info *mi)
Definition: rpl_replica.cc:1144
char slave_skip_error_names[]
Definition: rpl_replica.cc:187
void end_slave()
Definition: rpl_replica.cc:2142
MY_BITMAP slave_error_mask
Definition: rpl_replica.cc:186
char * opt_binlog_index_name
Definition: mysqld.cc:1687
bool show_slave_status_cmd(THD *thd)
Entry point for SHOW REPLICA STATUS command.
Definition: rpl_replica.cc:3936
void * handle_slave_sql(void *arg)
Slave SQL thread entry point.
Definition: rpl_replica.cc:6949
const char * master_info_file
Definition: rpl_replica.h:645
bool use_slave_mask
Definition: rpl_replica.cc:185
void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli)
Definition: rpl_replica.cc:4029
bool opt_relay_logname_supplied
Definition: mysqld.cc:1662
bool start_slave(THD *thd)
Function to start a slave for all channels.
Definition: rpl_replica.cc:607
char * opt_replica_skip_errors
Definition: mysqld.cc:1241
@ QUEUE_EVENT_OK
Definition: rpl_replica.h:597
@ QUEUE_EVENT_ERROR_QUEUING
Definition: rpl_replica.h:598
@ QUEUE_EVENT_ERROR_FLUSHING_INFO
Definition: rpl_replica.h:599
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(void)
Definition: mysql.cc:3183
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:1234
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:29
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
SLAVE_THD_TYPE
Definition: rpl_replica.h:58
@ SLAVE_THD_SQL
Definition: rpl_replica.h:60
@ SLAVE_THD_IO
Definition: rpl_replica.h:59
@ SLAVE_THD_WORKER
Definition: rpl_replica.h:61
@ SLAVE_THD_MONITOR
Definition: rpl_replica.h:62
Declarations for the Debug Sync Facility.
Structure to hold parameters for CHANGE MASTER, START SLAVE, and STOP SLAVE.
Definition: sql_lex.h:350
Definition: mysql.h:299
Definition: my_bitmap.h:42
Definition: mysql_com.h:912
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:2460