MySQL 8.0.32
Source Code Documentation
binlog.h
Go to the documentation of this file.
1#ifndef BINLOG_H_INCLUDED
2/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2.0,
6 as published by the Free Software Foundation.
7
8 This program is also distributed with certain software (including
9 but not limited to OpenSSL) that is licensed under separate terms,
10 as designated in a particular file or component or in included license
11 documentation. The authors of MySQL hereby grant you an additional
12 permission to link the program and your derivative works with the
13 separately licensed software that they have included with MySQL.
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#define BINLOG_H_INCLUDED
25
26#include <string.h>
27#include <sys/types.h>
28#include <time.h>
29#include <atomic>
30#include <utility>
31
32#include "libbinlogevents/include/binlog_event.h" // enum_binlog_checksum_alg
33#include "m_string.h" // llstr
34#include "my_dbug.h"
35#include "my_inttypes.h"
36#include "my_io.h"
37#include "my_sharedlib.h"
38#include "my_sys.h"
47#include "mysql_com.h" // Item_result
50#include "sql/tc_log.h" // TC_LOG
51#include "sql/transaction_info.h" // Transaction_ctx
52#include "thr_mutex.h"
53
56class Gtid_set;
57class Ha_trx_info;
59class Log_event;
60class Master_info;
61class Relay_log_info;
62class Rows_log_event;
63class Sid_map;
64class THD;
67class user_var_entry;
69
70struct Gtid;
71
73
74/*
75 Maximum unique log filename extension.
76 Note: setting to 0x7FFFFFFF due to atol windows
77 overflow/truncate.
78 */
79#define MAX_LOG_UNIQUE_FN_EXT 0x7FFFFFFF
80
81/*
82 Maximum allowed unique log filename extension for
83 RESET MASTER TO command - 2 Billion
84 */
85#define MAX_ALLOWED_FN_EXT_RESET_MASTER 2000000000
86
89 char *value;
90 ulong length;
94};
95
96/* log info errors */
97#define LOG_INFO_EOF -1
98#define LOG_INFO_IO -2
99#define LOG_INFO_INVALID -3
100#define LOG_INFO_SEEK -4
101#define LOG_INFO_MEM -6
102#define LOG_INFO_FATAL -7
103#define LOG_INFO_IN_USE -8
104#define LOG_INFO_EMFILE -9
105#define LOG_INFO_BACKUP_LOCK -10
106
107/* bitmap to MYSQL_BIN_LOG::close() */
108#define LOG_CLOSE_INDEX 1
109#define LOG_CLOSE_TO_BE_OPENED 2
110#define LOG_CLOSE_STOP_EVENT 4
111
112/*
113 Note that we destroy the lock mutex in the destructor here.
114 This means that object instances cannot be destroyed/go out of scope
115 until we have reset thd->current_linfo to NULL;
116 */
117struct LOG_INFO {
121 bool fatal; // if the purge happens to give us a negative offset
122 int entry_index; // used in purge_logs(), calculatd in find_log_pos().
127 pos(0),
128 fatal(false),
129 entry_index(0),
131 memset(log_file_name, 0, FN_REFLEN);
132 }
133};
134
135/*
136 TODO use mmap instead of IO_CACHE for binlog
137 (mmap+fsync is two times faster than write+fsync)
138*/
139class MYSQL_BIN_LOG : public TC_LOG {
140 public:
141 class Binlog_ofile;
142
143 private:
145
146 /* LOCK_log is inited by init_pthread_objects() */
148 char *name;
150 char db[NAME_LEN + 1];
153
154 /** Instrumentation key to use for file io in @c log_file */
156 /** The instrumentation key to use for @ LOCK_log. */
158 /** The instrumentation key to use for @ LOCK_index. */
160 /** The instrumentation key to use for @ LOCK_binlog_end_pos. */
162 /** The PFS instrumentation key for @ LOCK_commit_queue. */
164 /** The PFS instrumentation key for @ LOCK_done. */
166 /** The PFS instrumentation key for @ LOCK_flush_queue. */
168 /** The PFS instrumentation key for @ LOCK_sync_queue. */
170 /** The PFS instrumentation key for @ LOCK_wait_for_group_turn. */
172 /** The PFS instrumentation key for @ COND_done. */
174 /** The PFS instrumentation key for @ COND_flush_queue. */
176 /** The instrumentation key to use for @ LOCK_commit. */
178 /** The instrumentation key to use for @ LOCK_sync. */
180 /** The instrumentation key to use for @ LOCK_xids. */
182 /** The instrumentation key to use for @ update_cond. */
184 /** The instrumentation key to use for @ prep_xids_cond. */
186 /** The PFS instrumentation key for @ COND_wait_for_group_turn. */
188 /** The instrumentation key to use for opening the log file. */
190 /** The instrumentation key to use for opening the log index file. */
192 /** The instrumentation key to use for opening a log cache file. */
194 /** The instrumentation key to use for opening a log index cache file. */
196
197 /* POSIX thread objects are inited by init_pthread_objects() */
204
205 std::atomic<my_off_t> atomic_binlog_end_pos;
209 /*
210 crash_safe_index_file is temp file used for guaranteeing
211 index file crash safe when master server restarts.
212 */
215 /*
216 purge_file is a temp file used in purge_logs so that the index file
217 can be updated before deleting files from disk, yielding better crash
218 recovery. It is created on demand the first time purge_logs is called
219 and then reused for subsequent calls. It is cleaned up in cleanup().
220 */
223 /*
224 The max size before rotation (usable only if log_type == LOG_BIN: binary
225 logs and relay logs).
226 For a binlog, max_size should be max_binlog_size.
227 For a relay log, it should be max_relay_log_size if this is non-zero,
228 max_binlog_size otherwise.
229 max_size is set in init(), and dynamically changed (when one does SET
230 GLOBAL MAX_BINLOG_SIZE|MAX_RELAY_LOG_SIZE) by fix_max_binlog_size and
231 fix_max_relay_log_size).
232 */
233 ulong max_size;
234
235 // current file sequence number for load data infile binary logging
237
238 /* pointer to the sync period variable, for binlog this will be
239 sync_binlog_period, for relay log this will be
240 sync_relay_log_period
241 */
244
246 std::atomic<int32> m_atomic_prep_xids{0};
247
248 /**
249 Increment the prepared XID counter.
250 */
251 void inc_prep_xids(THD *thd);
252
253 /**
254 Decrement the prepared XID counter.
255
256 Signal m_prep_xids_cond if the counter reaches zero.
257 */
258 void dec_prep_xids(THD *thd);
259
261
263
264 public:
265 /*
266 This is used to start writing to a new log file. The difference from
267 new_file() is locking. new_file_without_locking() does not acquire
268 LOCK_log.
269 */
271 Format_description_log_event *extra_description_event);
272
273 /**
274 Checks whether binlog caches are disabled (binlog does not cache data) or
275 empty in case binloggging is enabled in the current call to this function.
276 This function may be safely called in case binlogging is disabled.
277 @retval true binlog local caches are empty or disabled and binlogging is
278 enabled
279 @retval false binlog local caches are enabled and contain data or binlogging
280 is disabled
281 */
283
284 private:
285 int new_file_impl(bool need_lock,
286 Format_description_log_event *extra_description_event);
287
288 bool open(PSI_file_key log_file_key, const char *log_name,
289 const char *new_name, uint32 new_index_number);
290 bool init_and_set_log_file_name(const char *log_name, const char *new_name,
291 uint32 new_index_number);
292 int generate_new_name(char *new_name, const char *log_name,
293 uint32 new_index_number = 0);
294
295 protected:
296 /**
297 @brief Notifies waiting threads that binary log has been updated
298 */
299 void signal_update();
300
301 public:
302 const char *generate_name(const char *log_name, const char *suffix,
303 char *buff);
304 bool is_open() const { return atomic_log_state != LOG_CLOSED; }
305
306 /* This is relay log */
308
309 uint8 checksum_alg_reset; // to contain a new value when binlog is rotated
310 /*
311 Holds the last seen in Relay-Log FD's checksum alg value.
312 The initial value comes from the slave's local FD that heads
313 the very first Relay-Log file. In the following the value may change
314 with each received master's FD_m.
315 Besides to be used in verification events that IO thread receives
316 (except the 1st fake Rotate, see @c Master_info:: checksum_alg_before_fd),
317 the value specifies if/how to compute checksum for slave's local events
318 and the first fake Rotate (R_f^1) coming from the master.
319 R_f^1 needs logging checksum-compatibly with the RL's heading FD_s.
320
321 Legends for the checksum related comments:
322
323 FD - Format-Description event,
324 R - Rotate event
325 R_f - The fake Rotate event
326 E - An arbitrary event
327
328 The underscore indexes for any event
329 `_s' - Indicates the event is generated by the Replica
330 `_m' - By the Source
331
332 Two special underscore indexes of FD:
333 FD_q - Format Description event for queuing (relay-logging)
334 FD_e - Format Description event for executing (relay-logging)
335
336 Upper indexes:
337 E^n - n:th event is a sequence
338
339 RL - Relay Log
340 (A) - checksum algorithm descriptor value
341 FD.(A) - the value of (A) in FD
342 */
344
345 MYSQL_BIN_LOG(uint *sync_period, bool relay_log = false);
346 ~MYSQL_BIN_LOG() override;
347
349 PSI_mutex_key key_LOCK_index, PSI_mutex_key key_LOCK_commit,
350 PSI_mutex_key key_LOCK_commit_queue, PSI_mutex_key key_LOCK_done,
351 PSI_mutex_key key_LOCK_flush_queue, PSI_mutex_key key_LOCK_log,
352 PSI_mutex_key key_LOCK_binlog_end_pos, PSI_mutex_key key_LOCK_sync,
353 PSI_mutex_key key_LOCK_sync_queue, PSI_mutex_key key_LOCK_xids,
354 PSI_mutex_key key_LOCK_wait_for_group_turn, PSI_cond_key key_COND_done,
355 PSI_cond_key key_COND_flush_queue, PSI_cond_key key_update_cond,
356 PSI_cond_key key_prep_xids_cond,
357 PSI_cond_key key_COND_wait_for_group_turn, PSI_file_key key_file_log,
358 PSI_file_key key_file_log_index, PSI_file_key key_file_log_cache,
359 PSI_file_key key_file_log_index_cache) {
360 m_key_COND_done = key_COND_done;
361 m_key_COND_flush_queue = key_COND_flush_queue;
362
363 m_key_LOCK_commit_queue = key_LOCK_commit_queue;
364 m_key_LOCK_done = key_LOCK_done;
365 m_key_LOCK_flush_queue = key_LOCK_flush_queue;
366 m_key_LOCK_sync_queue = key_LOCK_sync_queue;
367
368 m_key_LOCK_index = key_LOCK_index;
369 m_key_LOCK_log = key_LOCK_log;
370 m_key_LOCK_binlog_end_pos = key_LOCK_binlog_end_pos;
371 m_key_LOCK_commit = key_LOCK_commit;
372 m_key_LOCK_sync = key_LOCK_sync;
373 m_key_LOCK_xids = key_LOCK_xids;
374 m_key_update_cond = key_update_cond;
375 m_key_prep_xids_cond = key_prep_xids_cond;
376 m_key_file_log = key_file_log;
377 m_key_file_log_index = key_file_log_index;
378 m_key_file_log_cache = key_file_log_cache;
379 m_key_file_log_index_cache = key_file_log_index_cache;
380
381 m_key_LOCK_wait_for_group_turn = key_LOCK_wait_for_group_turn;
382 m_key_COND_wait_for_group_turn = key_COND_wait_for_group_turn;
383 }
384
385 public:
386 /** Manage the MTS dependency tracking */
388
389 /**
390 Find the oldest binary log referenced by the index file
391
392 @param[out] binlog_file_name the file name of oldest log found
393 @param[out] errmsg the error message outputted, which is left untouched
394 if the function returns false
395 @return false on success, true on error.
396 */
397 bool find_first_log(std::string &binlog_file_name, std::string &errmsg);
398
399 /**
400 Find the oldest binary log that contains any GTID that
401 is not in the given gtid set.
402
403 @param[out] binlog_file_name the file name of oldest binary log found
404 @param[in] gtid_set the given gtid set
405 @param[out] first_gtid the first GTID information from the binary log
406 file returned at binlog_file_name
407 @param[out] errmsg the error message outputted, which is left untouched
408 if the function returns false
409 @return false on success, true on error.
410 */
411 bool find_first_log_not_in_gtid_set(char *binlog_file_name,
412 const Gtid_set *gtid_set,
413 Gtid *first_gtid, std::string &errmsg);
414
415 /**
416 Reads the set of all GTIDs in the binary/relay log, and the set
417 of all lost GTIDs in the binary log, and stores each set in
418 respective argument.
419
420 @param gtid_set Will be filled with all GTIDs in this binary/relay
421 log.
422 @param lost_groups Will be filled with all GTIDs in the
423 Previous_gtids_log_event of the first binary log that has a
424 Previous_gtids_log_event. This is requested to binary logs but not
425 to relay logs.
426 @param verify_checksum If true, checksums will be checked.
427 @param need_lock If true, LOCK_log, LOCK_index, and
428 global_sid_lock->wrlock are acquired; otherwise they are asserted
429 to be taken already.
430 @param [out] trx_parser This will be used to return the actual
431 relaylog transaction parser state because of the possibility
432 of partial transactions.
433 @param [out] partial_trx If a transaction was left incomplete
434 on the relaylog, its GTID information should be returned to be
435 used in the case of the rest of the transaction be added to the
436 relaylog.
437 @param is_server_starting True if the server is starting.
438 @return false on success, true on error.
439 */
440 bool init_gtid_sets(Gtid_set *gtid_set, Gtid_set *lost_groups,
441 bool verify_checksum, bool need_lock,
442 Transaction_boundary_parser *trx_parser,
443 Gtid_monitoring_info *partial_trx,
444 bool is_server_starting = false);
445
446 void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param) {
447 assert(is_relay_log);
448 previous_gtid_set_relaylog = previous_gtid_set_param;
449 }
450 /**
451 If the thread owns a GTID, this function generates an empty
452 transaction and releases ownership of the GTID.
453
454 - If the binary log is disabled for this thread, the GTID is
455 inserted directly into the mysql.gtid_executed table and the
456 GTID is included in @@global.gtid_executed. (This only happens
457 for DDL, since DML will save the GTID into table and release
458 ownership inside ha_commit_trans.)
459
460 - If the binary log is enabled for this thread, an empty
461 transaction consisting of GTID, BEGIN, COMMIT is written to the
462 binary log, the GTID is included in @@global.gtid_executed, and
463 the GTID is added to the mysql.gtid_executed table on the next
464 binlog rotation.
465
466 This function must be called by any committing statement (COMMIT,
467 implicitly committing statements, or Xid_log_event), after the
468 statement has completed execution, regardless of whether the
469 statement updated the database.
470
471 This logic ensures that an empty transaction is generated for the
472 following cases:
473
474 - Explicit empty transaction:
475 SET GTID_NEXT = 'UUID:NUMBER'; BEGIN; COMMIT;
476
477 - Transaction or DDL that gets completely filtered out in the
478 slave thread.
479
480 @param thd The committing thread
481
482 @retval 0 Success
483 @retval nonzero Error
484 */
485 int gtid_end_transaction(THD *thd);
486 /**
487 Re-encrypt previous existent binary/relay logs as below.
488 Starting from the next to last entry on the index file, iterating
489 down to the first one:
490 - If the file is encrypted, re-encrypt it. Otherwise, skip it.
491 - If failed to open the file, report an error.
492
493 @retval False Success
494 @retval True Error
495 */
496 bool reencrypt_logs();
497
498 private:
499 std::atomic<enum_log_state> atomic_log_state{LOG_CLOSED};
500
501 /* The previous gtid set in relay log. */
503
504 int open(const char *opt_name) override { return open_binlog(opt_name); }
505
506 /**
507 Enter a stage of the ordered commit procedure.
508
509 Entering is stage is done by:
510
511 - Atomically entering a queue of THD objects (which is just one for
512 the first phase).
513
514 - If the queue was empty, the thread is the leader for that stage
515 and it should process the entire queue for that stage.
516
517 - If the queue was not empty, the thread is a follower and can go
518 waiting for the commit to finish.
519
520 The function will lock the stage mutex if the calling thread was designated
521 leader for the phase.
522
523 @param[in] thd Session structure
524 @param[in] stage The stage to enter
525 @param[in] queue Thread queue for the stage
526 @param[in] leave_mutex Mutex that will be released when changing stage
527 @param[in] enter_mutex Mutex that will be taken when changing stage
528
529 @retval true In case this thread did not become leader, the function
530 returns true *after* the leader has completed the commit
531 on its behalf, so the thread should continue doing the
532 thread-local processing after the commit
533 (i.e. call finish_commit).
534
535 @retval false The thread is the leader for the stage and should do
536 the processing.
537 */
539 mysql_mutex_t *leave_mutex, mysql_mutex_t *enter_mutex);
540 std::pair<int, my_off_t> flush_thread_caches(THD *thd);
541 int flush_cache_to_file(my_off_t *flush_end_pos);
542 int finish_commit(THD *thd);
543 std::pair<bool, bool> sync_binlog_file(bool force);
545 void process_after_commit_stage_queue(THD *thd, THD *first);
546
547 /**
548 Set thread variables used while flushing a transaction.
549
550 @param[in] thd thread whose variables need to be set
551 @param[in] all This is @c true if this is a real transaction commit, and
552 @c false otherwise.
553 @param[in] skip_commit
554 This is @c true if the call to @c ha_commit_low should
555 be skipped (it is handled by the caller somehow) and @c
556 false otherwise (the normal case).
557 */
558 void init_thd_variables(THD *thd, bool all, bool skip_commit);
559
560 /**
561 Fetch and empty BINLOG_FLUSH_STAGE and COMMIT_ORDER_FLUSH_STAGE flush queues
562 and flush transactions to the disk, and unblock threads executing slave
563 preserve commit order.
564
565 @param[in] check_and_skip_flush_logs
566 if false then flush prepared records of transactions to the log
567 of storage engine.
568 if true then flush prepared records of transactions to the log
569 of storage engine only if COMMIT_ORDER_FLUSH_STAGE queue is
570 non-empty.
571
572 @return Pointer to the first session of the BINLOG_FLUSH_STAGE stage queue.
573 */
575 const bool check_and_skip_flush_logs = false);
576
577 /**
578 Execute the flush stage.
579
580 @param[out] total_bytes_var Pointer to variable that will be set to total
581 number of bytes flushed, or NULL.
582
583 @param[out] rotate_var Pointer to variable that will be set to true if
584 binlog rotation should be performed after releasing
585 locks. If rotate is not necessary, the variable will
586 not be touched.
587
588 @param[out] out_queue_var Pointer to the sessions queue in flush stage.
589
590 @return Error code on error, zero on success
591 */
592 int process_flush_stage_queue(my_off_t *total_bytes_var, bool *rotate_var,
593 THD **out_queue_var);
594
595 /**
596 Flush and commit the transaction.
597
598 This will execute an ordered flush and commit of all outstanding
599 transactions and is the main function for the binary log group
600 commit logic. The function performs the ordered commit in four stages.
601
602 Pre-condition: transactions should have called ha_prepare_low, using
603 HA_IGNORE_DURABILITY, before entering here.
604
605 Stage#0 implements replica-preserve-commit-order for applier threads that
606 write the binary log. i.e. it forces threads to enter the queue in the
607 correct commit order.
608
609 The stage#1 flushes the caches to the binary log and under
610 LOCK_log and marks all threads that were flushed as not pending.
611
612 The stage#2 syncs the binary log for all transactions in the group.
613
614 The stage#3 executes under LOCK_commit and commits all transactions in
615 order.
616
617 There are three queues of THD objects: one for each stage.
618 The Commit_order_manager maintains it own queue and its own order for the
619 commit. So Stage#0 doesn't maintain separate StageID.
620
621 When a transaction enters a stage, it adds itself to a queue. If the queue
622 was empty so that this becomes the first transaction in the queue, the
623 thread is the *leader* of the queue. Otherwise it is a *follower*. The
624 leader will do all work for all threads in the queue, and the followers
625 will wait until the last stage is finished.
626
627 Stage 0 (SLAVE COMMIT ORDER):
628 1. If replica-preserve-commit-order and is slave applier worker thread, then
629 waits until its turn to commit i.e. till it is on the top of the queue.
630 2. When it reaches top of the queue, it signals next worker in the commit
631 order queue to awake.
632
633 Stage 1 (FLUSH):
634 1. Sync the engines (ha_flush_logs), since they prepared using non-durable
635 settings (HA_IGNORE_DURABILITY).
636 2. Generate GTIDs for all transactions in the queue.
637 3. Write the session caches for all transactions in the queue to the binary
638 log.
639 4. Increment the counter of prepared XIDs.
640
641 Stage 2 (SYNC):
642 1. If it is time to sync, based on the sync_binlog option, sync the binlog.
643 2. If sync_binlog==1, signal dump threads that they can read up to the
644 position after the last transaction in the queue
645
646 Stage 3 (COMMIT):
647 This is performed by each thread separately, if binlog_order_commits=0.
648 Otherwise by the leader does it for all threads.
649 1. Call the after_sync hook.
650 2. update the max_committed counter in the dependency_tracker
651 3. call ha_commit_low
652 4. Call the after_commit hook
653 5. Update gtids
654 6. Decrement the counter of prepared transactions
655
656 If the binary log needs to be rotated, it is done after this. During
657 rotation, it takes a lock that prevents new commit groups from executing the
658 flush stage, and waits until the counter of prepared transactions becomes 0,
659 before it creates the new file.
660
661 @param[in] thd Session to commit transaction for
662 @param[in] all This is @c true if this is a real transaction commit, and
663 @c false otherwise.
664 @param[in] skip_commit
665 This is @c true if the call to @c ha_commit_low should
666 be skipped and @c false otherwise (the normal case).
667 */
668 int ordered_commit(THD *thd, bool all, bool skip_commit = false);
669 void handle_binlog_flush_or_sync_error(THD *thd, bool need_lock_log,
670 const char *message);
672 class Binlog_event_writer *writer);
674
675 public:
676 int open_binlog(const char *opt_name);
677 void close() override;
678 enum_result commit(THD *thd, bool all) override;
679 int rollback(THD *thd, bool all) override;
680 bool truncate_relaylog_file(Master_info *mi, my_off_t valid_pos);
681 int prepare(THD *thd, bool all) override;
682#if defined(MYSQL_SERVER)
683
686 bool is_transactional);
687
688#endif /* defined(MYSQL_SERVER) */
691 void harvest_bytes_written(Relay_log_info *rli, bool need_log_space_lock);
692 void set_max_size(ulong max_size_arg);
693
694 void update_binlog_end_pos(bool need_lock = true);
695 void update_binlog_end_pos(const char *file, my_off_t pos);
696
697 /**
698 Wait until we get a signal that the binary log has been updated.
699
700 NOTES
701 @param[in] timeout a pointer to a timespec;
702 NULL means to wait w/o timeout.
703 @retval 0 if got signalled on update
704 @retval non-0 if wait timeout elapsed
705 @note
706 LOCK_binlog_end_pos must be owned before calling this function, may be
707 temporarily released while the thread is waiting and is reacquired before
708 returning from the function
709 */
710 int wait_for_update(const std::chrono::nanoseconds &timeout);
711
712 /**
713 Wait until we get a signal that the binary log has been updated.
714 @retval 0 success
715 @note
716 LOCK_binlog_end_pos must be owned before calling this function, may be
717 temporarily released while the thread is waiting and is reacquired before
718 returning from the function
719 */
720 int wait_for_update();
721
722 public:
724 void cleanup();
725 /**
726 Create a new binary log.
727 @param log_name Name of binlog
728 @param new_name Name of binlog, too. todo: what's the difference
729 between new_name and log_name?
730 @param max_size_arg The size at which this binlog will be rotated.
731 @param null_created_arg If false, and a Format_description_log_event
732 is written, then the Format_description_log_event will have the
733 timestamp 0. Otherwise, it the timestamp will be the time when the
734 event was written to the log.
735 @param need_lock_index If true, LOCK_index is acquired; otherwise
736 LOCK_index must be taken by the caller.
737 @param need_sid_lock If true, the read lock on global_sid_lock
738 will be acquired. Otherwise, the caller must hold the read lock
739 on global_sid_lock.
740 @param extra_description_event The master's FDE to be written by the I/O
741 thread while creating a new relay log file. This should be NULL for
742 binary log files.
743 @param new_index_number The binary log file index number to start from
744 after the RESET MASTER TO command is called.
745 */
746 bool open_binlog(const char *log_name, const char *new_name,
747 ulong max_size_arg, bool null_created_arg,
748 bool need_lock_index, bool need_sid_lock,
749 Format_description_log_event *extra_description_event,
750 uint32 new_index_number = 0);
751 bool open_index_file(const char *index_file_name_arg, const char *log_name,
752 bool need_lock_index);
753 /* Use this to start writing a new log file */
754 int new_file(Format_description_log_event *extra_description_event);
755
756 bool write_event(Log_event *event_info);
757 bool write_cache(THD *thd, class binlog_cache_data *cache_data,
758 class Binlog_event_writer *writer);
759 /**
760 Assign automatic generated GTIDs for all commit group threads in the flush
761 stage having gtid_next.type == AUTOMATIC_GTID.
762
763 @param first_seen The first thread seen entering the flush stage.
764 @return Returns false if succeeds, otherwise true is returned.
765 */
767 bool write_transaction(THD *thd, binlog_cache_data *cache_data,
768 Binlog_event_writer *writer);
769
770 /**
771 Write a dml into statement cache and then flush it into binlog. It writes
772 Gtid_log_event and BEGIN, COMMIT automatically.
773
774 It is aimed to handle cases of "background" logging where a statement is
775 logged indirectly, like "TRUNCATE TABLE a_memory_table". So don't use it on
776 any normal statement.
777
778 @param[in] thd the THD object of current thread.
779 @param[in] stmt the DML statement.
780 @param[in] stmt_len the length of the DML statement.
781 @param[in] sql_command the type of SQL command.
782
783 @return Returns false if succeeds, otherwise true is returned.
784 */
785 bool write_stmt_directly(THD *thd, const char *stmt, size_t stmt_len,
786 enum enum_sql_command sql_command);
787
788 void report_cache_write_error(THD *thd, bool is_transactional);
789 bool check_write_error(const THD *thd);
790 bool write_incident(THD *thd, bool need_lock_log, const char *err_msg,
791 bool do_flush_and_sync = true);
792 bool write_incident(Incident_log_event *ev, THD *thd, bool need_lock_log,
793 const char *err_msg, bool do_flush_and_sync = true);
797 void start_union_events(THD *thd, query_id_t query_id_param);
798 void stop_union_events(THD *thd);
799 bool is_query_in_union(THD *thd, query_id_t query_id_param);
800
801 bool write_buffer(const char *buf, uint len, Master_info *mi);
802 bool write_event(Log_event *ev, Master_info *mi);
803
804 /**
805 Logging XA commit/rollback of a prepared transaction.
806
807 It fills in the appropriate event in the statement cache whenever xid
808 state is marked with is_binlogged() flag that indicates the prepared
809 part of the transaction must've been logged.
810
811 About early returns from the function:
812 - ONE_PHASE option to XA-COMMIT is handled to skip writing XA-commit
813 event now.
814 - check is for the read-only XA that is not to be logged.
815
816 @param thd THD handle
817 @return error code, 0 success
818 */
819 int write_xa_to_cache(THD *thd);
820
821 private:
823
824 public:
825 void make_log_name(char *buf, const char *log_ident);
826 bool is_active(const char *log_file_name) const;
827 int remove_logs_from_index(LOG_INFO *linfo, bool need_update_threads);
828 int rotate(bool force_rotate, bool *check_purge);
829
830 /**
831 @brief This function runs automatic purge if the conditions to meet
832 automatic purge are met. Such conditions are: log is open, instance is not
833 locked for backup and automatic purge is enabled.
834
835 If all conditions are met, purge is done according to the configuration
836 of the purge window.
837 */
838 void auto_purge();
839
840 /**
841 @brief This member function is to be called at server startup. It checks if
842 purge can be done and does if it can.
843 */
845 int rotate_and_purge(THD *thd, bool force_rotate);
846
847 bool flush();
848 /**
849 Flush binlog cache and synchronize to disk.
850
851 This function flushes events in binlog cache to binary log file,
852 it will do synchronizing according to the setting of system
853 variable 'sync_binlog'. If file is synchronized, @c synced will
854 be set to 1, otherwise 0.
855
856 @param[in] force if true, ignores the 'sync_binlog' and synchronizes the
857 file.
858
859 @retval 0 Success
860 @retval other Failure
861 */
862 bool flush_and_sync(const bool force = false);
863 int purge_logs(const char *to_log, bool included, bool need_lock_index,
864 bool need_update_threads, ulonglong *decrease_log_space,
865 bool auto_purge);
866 int purge_logs_before_date(time_t purge_time, bool auto_purge);
867 int set_crash_safe_index_file_name(const char *base_file_name);
870 int add_log_to_index(uchar *log_file_name, size_t name_len,
871 bool need_lock_index);
872 int move_crash_safe_index_file_to_index_file(bool need_lock_index);
873 int set_purge_index_file_name(const char *base_file_name);
878 int register_purge_index_entry(const char *entry);
879 int register_create_index_entry(const char *entry);
880 int purge_index_entry(THD *thd, ulonglong *decrease_log_space,
881 bool need_lock_index);
882 bool reset_logs(THD *thd, bool delete_only = false);
883 void close(uint exiting, bool need_lock_log, bool need_lock_index);
884
885 // iterating through the log index file
886 int find_log_pos(LOG_INFO *linfo, const char *log_name, bool need_lock_index);
887 int find_next_log(LOG_INFO *linfo, bool need_lock_index);
888 int find_next_relay_log(char log_name[FN_REFLEN + 1]);
889 int get_current_log(LOG_INFO *linfo, bool need_lock_log = true);
890 int raw_get_current_log(LOG_INFO *linfo);
892 /**
893 Retrieves the contents of the index file associated with this log object
894 into an `std::list<std::string>` object. The order held by the index file is
895 kept.
896
897 @param need_lock_index whether or not the lock over the index file should be
898 acquired inside the function.
899
900 @return a pair: a function status code; a list of `std::string` objects with
901 the content of the log index file.
902 */
903 std::pair<int, std::list<std::string>> get_log_index(
904 bool need_lock_index = true);
905 inline char *get_index_fname() { return index_file_name; }
906 inline char *get_log_fname() { return log_file_name; }
907 const char *get_name() const { return name; }
908 inline mysql_mutex_t *get_log_lock() { return &LOCK_log; }
910 inline mysql_cond_t *get_log_cond() { return &update_cond; }
912
915 inline IO_CACHE *get_index_file() { return &index_file; }
916
917 /**
918 Function to report the missing GTIDs.
919
920 This function logs the missing transactions on master to its error log
921 as a warning. If the missing GTIDs are too long to print in a message,
922 it suggests the steps to extract the missing transactions.
923
924 This function also informs slave about the GTID set sent by the slave,
925 transactions missing on the master and few suggestions to recover from
926 the error. This message shall be wrapped by
927 ER_MASTER_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
928 error.
929
930 This function will be called from mysql_binlog_send() function.
931
932 @param slave_executed_gtid_set GTID set executed by slave
933 @param errmsg Pointer to the error message
934 */
935 void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set,
936 std::string &errmsg);
937
938 /**
939 Function to report the missing GTIDs.
940
941 This function logs the missing transactions on master to its error log
942 as a warning. If the missing GTIDs are too long to print in a message,
943 it suggests the steps to extract the missing transactions.
944
945 This function also informs slave about the GTID set sent by the slave,
946 transactions missing on the master and few suggestions to recover from
947 the error. This message shall be wrapped by
948 ER_MASTER_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
949 error.
950
951 This function will be called from find_first_log_not_in_gtid_set()
952 function.
953
954 @param previous_gtid_set Previous GTID set found
955 @param slave_executed_gtid_set GTID set executed by slave
956 @param errmsg Pointer to the error message
957 */
958 void report_missing_gtids(const Gtid_set *previous_gtid_set,
959 const Gtid_set *slave_executed_gtid_set,
960 std::string &errmsg);
962 /*
963 It is called by the threads (e.g. dump thread, applier thread) which want
964 to read hot log without LOCK_log protection.
965 */
969 }
973
974 /**
975 Deep copy global_sid_map and gtid_executed.
976 Both operations are done under LOCK_commit and global_sid_lock
977 protection.
978
979 @param[out] sid_map The Sid_map to which global_sid_map will
980 be copied.
981 @param[out] gtid_set The Gtid_set to which gtid_executed will
982 be copied.
983
984 @return the operation status
985 @retval 0 OK
986 @retval !=0 Error
987 */
988 int get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set);
989
990 /*
991 True while rotating binlog, which is caused by logging Incident_log_event.
992 */
994};
995
1000};
1001
1003
1004/**
1005 Check if the the transaction is empty.
1006
1007 @param thd The client thread that executed the current statement.
1008
1009 @retval true No changes found in any storage engine
1010 @retval false Otherwise.
1011
1012**/
1013bool is_transaction_empty(THD *thd);
1014/**
1015 Check if the transaction has no rw flag set for any of the storage engines.
1016
1017 @param thd The client thread that executed the current statement.
1018 @param trx_scope The transaction scope to look into.
1019
1020 @retval the number of engines which have actual changes.
1021 */
1023
1024/**
1025 Check if at least one of transacaction and statement binlog caches contains
1026 an empty transaction, other one is empty or contains an empty transaction,
1027 which has two binlog events "BEGIN" and "COMMIT".
1028
1029 @param thd The client thread that executed the current statement.
1030
1031 @retval true At least one of transacaction and statement binlog caches
1032 contains an empty transaction, other one is empty or
1033 contains an empty transaction.
1034 @retval false Otherwise.
1035*/
1037bool trans_has_updated_trans_table(const THD *thd);
1039bool ending_trans(THD *thd, const bool all);
1040bool ending_single_stmt_trans(THD *thd, const bool all);
1041bool trans_cannot_safely_rollback(const THD *thd);
1042bool stmt_cannot_safely_rollback(const THD *thd);
1043
1045
1046/**
1047 @brief Purges the binary log files up to the file name passed as
1048 a paramenter. Purge will not delete the file passed as
1049 an argument.
1050
1051 @param thd The session context.
1052 @param to_log Up to which log file to purge.
1053 @return true if there was an error.
1054 @return false if there was no error.
1055 */
1056bool purge_source_logs_to_file(THD *thd, const char *to_log);
1057
1058bool purge_source_logs_before_date(THD *thd, time_t purge_time);
1060bool mysql_show_binlog_events(THD *thd);
1061void check_binlog_cache_size(THD *thd);
1063bool binlog_enabled();
1064void register_binlog_handler(THD *thd, bool trx);
1065int query_error_code(const THD *thd, bool not_killed);
1066
1067extern const char *log_bin_index;
1068extern const char *log_bin_basename;
1069extern bool opt_binlog_order_commits;
1070extern ulong rpl_read_size;
1071/**
1072 Turns a relative log binary log path into a full path, based on the
1073 opt_bin_logname or opt_relay_logname. Also trims the cr-lf at the
1074 end of the full_path before return to avoid any server startup
1075 problem on windows.
1076
1077 @param from The log name we want to make into an absolute path.
1078 @param to The buffer where to put the results of the
1079 normalization.
1080 @param is_relay_log Switch that makes is used inside to choose which
1081 option (opt_bin_logname or opt_relay_logname) to
1082 use when calculating the base path.
1083
1084 @returns true if a problem occurs, false otherwise.
1085 */
1086
1087bool normalize_binlog_name(char *to, const char *from, bool is_relay_log);
1088
1089#endif /* BINLOG_H_INCLUDED */
int64 query_id_t
Definition: binlog.h:70
MYSQL_PLUGIN_IMPORT MYSQL_BIN_LOG mysql_bin_log
Contains the classes representing events occurring in the replication stream.
Byte container that provides a storage for serializing session binlog events.
Definition: binlog_ostream.h:172
Auxiliary class to copy serialized events to the binary log and correct some of the fields that are n...
Definition: binlog.cc:1364
StageID
Constants for queues for different stages.
Definition: rpl_commit_stage_manager.h:165
For binlog version 4.
Definition: log_event.h:1501
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1310
Represents a set of GTIDs.
Definition: rpl_gtid.h:1454
Container to hold and allow iteration over a set of Ha_trx_info objects.
Definition: transaction_info.h:501
Either statement transaction or normal transaction - related thread-specific storage engine data.
Definition: transaction_info.h:401
Class representing an incident, an occurrence out of the ordinary, that happened on the master.
Definition: log_event.h:3406
This is the abstract base class for binary log events.
Definition: log_event.h:547
Logical binlog file which wraps and hides the detail of lower layer storage implementation.
Definition: binlog.cc:378
Definition: binlog.h:139
mysql_mutex_t * get_binlog_end_pos_lock()
Definition: binlog.h:970
const char * get_name() const
Definition: binlog.h:907
mysql_cond_t m_prep_xids_cond
Definition: binlog.h:245
mysql_mutex_t * get_commit_lock()
Definition: binlog.h:909
mysql_mutex_t LOCK_binlog_end_pos
Definition: binlog.h:201
std::atomic< my_off_t > atomic_binlog_end_pos
Definition: binlog.h:205
void unlock_binlog_end_pos()
Definition: binlog.h:972
PSI_mutex_key m_key_LOCK_xids
The instrumentation key to use for @ LOCK_xids.
Definition: binlog.h:181
mysql_mutex_t LOCK_commit
Definition: binlog.h:199
char db[NAME_LEN+1]
Definition: binlog.h:150
void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param)
Definition: binlog.h:446
IO_CACHE crash_safe_index_file
Definition: binlog.h:213
void reset_bytes_written()
Definition: binlog.h:690
void lock_binlog_end_pos()
Definition: binlog.h:971
enum_log_state
Definition: binlog.h:144
@ LOG_OPENED
Definition: binlog.h:144
@ LOG_CLOSED
Definition: binlog.h:144
@ LOG_TO_BE_OPENED
Definition: binlog.h:144
mysql_mutex_t LOCK_index
Definition: binlog.h:198
PSI_mutex_key m_key_COND_done
The PFS instrumentation key for @ COND_done.
Definition: binlog.h:173
mysql_mutex_t LOCK_sync
Definition: binlog.h:200
PSI_mutex_key m_key_LOCK_commit_queue
The PFS instrumentation key for @ LOCK_commit_queue.
Definition: binlog.h:163
bool write_event_to_binlog_and_flush(Log_event *ev)
Binlog_ofile * get_binlog_file()
Definition: binlog.h:911
int open(const char *opt_name) override
Initialize and open the coordinator log.
Definition: binlog.h:504
mysql_mutex_t * get_log_lock()
Definition: binlog.h:908
bool is_open() const
Definition: binlog.h:304
IO_CACHE purge_index_file
Definition: binlog.h:221
PSI_cond_key m_key_prep_xids_cond
The instrumentation key to use for @ prep_xids_cond.
Definition: binlog.h:185
my_off_t get_binlog_end_pos() const
Definition: binlog.h:966
void lock_index()
Definition: binlog.h:913
PSI_mutex_key m_key_LOCK_flush_queue
The PFS instrumentation key for @ LOCK_flush_queue.
Definition: binlog.h:167
int32 get_prep_xids()
Definition: binlog.h:260
std::atomic< enum_log_state > atomic_log_state
Definition: binlog.h:499
Gtid_set * previous_gtid_set_relaylog
Definition: binlog.h:502
PSI_cond_key m_key_update_cond
The instrumentation key to use for @ update_cond.
Definition: binlog.h:183
char * get_index_fname()
Definition: binlog.h:905
bool write_error
Definition: binlog.h:151
uint * sync_period_ptr
Definition: binlog.h:242
PSI_mutex_key m_key_LOCK_done
The PFS instrumentation key for @ LOCK_done.
Definition: binlog.h:165
std::atomic< int32 > m_atomic_prep_xids
Definition: binlog.h:246
Binlog_ofile * m_binlog_file
Definition: binlog.h:152
PSI_mutex_key m_key_LOCK_sync
The instrumentation key to use for @ LOCK_sync.
Definition: binlog.h:179
void add_bytes_written(ulonglong inc)
Definition: binlog.h:689
void set_psi_keys(PSI_mutex_key key_LOCK_index, PSI_mutex_key key_LOCK_commit, PSI_mutex_key key_LOCK_commit_queue, PSI_mutex_key key_LOCK_done, PSI_mutex_key key_LOCK_flush_queue, PSI_mutex_key key_LOCK_log, PSI_mutex_key key_LOCK_binlog_end_pos, PSI_mutex_key key_LOCK_sync, PSI_mutex_key key_LOCK_sync_queue, PSI_mutex_key key_LOCK_xids, PSI_mutex_key key_LOCK_wait_for_group_turn, PSI_cond_key key_COND_done, PSI_cond_key key_COND_flush_queue, PSI_cond_key key_update_cond, PSI_cond_key key_prep_xids_cond, PSI_cond_key key_COND_wait_for_group_turn, PSI_file_key key_file_log, PSI_file_key key_file_log_index, PSI_file_key key_file_log_cache, PSI_file_key key_file_log_index_cache)
Definition: binlog.h:348
bool inited
Definition: binlog.h:151
PSI_file_key m_key_file_log_index_cache
The instrumentation key to use for opening a log index cache file.
Definition: binlog.h:195
PSI_mutex_key m_key_LOCK_binlog_end_pos
The instrumentation key to use for @ LOCK_binlog_end_pos.
Definition: binlog.h:161
char index_file_name[FN_REFLEN]
Definition: binlog.h:208
IO_CACHE * get_index_file()
Definition: binlog.h:915
mysql_cond_t * get_log_cond()
Definition: binlog.h:910
mysql_mutex_t LOCK_log
Definition: binlog.h:147
ulong max_size
Definition: binlog.h:233
bool is_relay_log
Definition: binlog.h:307
PSI_mutex_key m_key_LOCK_index
The instrumentation key to use for @ LOCK_index.
Definition: binlog.h:159
uint get_sync_period()
Definition: binlog.h:262
PSI_cond_key m_key_COND_wait_for_group_turn
The PFS instrumentation key for @ COND_wait_for_group_turn.
Definition: binlog.h:187
PSI_mutex_key m_key_LOCK_log
The instrumentation key to use for @ LOCK_log.
Definition: binlog.h:157
PSI_mutex_key m_key_COND_flush_queue
The PFS instrumentation key for @ COND_flush_queue.
Definition: binlog.h:175
uint file_id
Definition: binlog.h:236
ulonglong bytes_written
Definition: binlog.h:206
binary_log::enum_binlog_checksum_alg relay_log_checksum_alg
Definition: binlog.h:343
mysql_cond_t update_cond
Definition: binlog.h:203
PSI_mutex_key m_key_LOCK_commit
The instrumentation key to use for @ LOCK_commit.
Definition: binlog.h:177
PSI_mutex_key m_key_LOCK_wait_for_group_turn
The PFS instrumentation key for @ LOCK_wait_for_group_turn.
Definition: binlog.h:171
void unlock_index()
Definition: binlog.h:914
PSI_file_key m_key_file_log
The instrumentation key to use for opening the log file.
Definition: binlog.h:189
PSI_mutex_key m_key_LOCK_sync_queue
The PFS instrumentation key for @ LOCK_sync_queue.
Definition: binlog.h:169
char * get_log_fname()
Definition: binlog.h:906
char purge_index_file_name[FN_REFLEN]
Definition: binlog.h:222
Transaction_dependency_tracker m_dependency_tracker
Manage the MTS dependency tracking.
Definition: binlog.h:387
IO_CACHE index_file
Definition: binlog.h:207
mysql_mutex_t LOCK_xids
Definition: binlog.h:202
PSI_file_key m_key_file_log_cache
The instrumentation key to use for opening a log cache file.
Definition: binlog.h:193
uint sync_counter
Definition: binlog.h:243
PSI_file_key m_log_file_key
Instrumentation key to use for file io in log_file.
Definition: binlog.h:155
bool is_rotating_caused_by_incident
Definition: binlog.h:993
char * name
Definition: binlog.h:148
char log_file_name[FN_REFLEN]
Definition: binlog.h:149
uint8 checksum_alg_reset
Definition: binlog.h:309
char crash_safe_index_file_name[FN_REFLEN]
Definition: binlog.h:214
static const int MAX_RETRIES_FOR_DELETE_RENAME_FAILURE
Definition: binlog.h:961
PSI_file_key m_key_file_log_index
The instrumentation key to use for opening the log index file.
Definition: binlog.h:191
Definition: rpl_mi.h:86
Definition: rpl_rli.h:201
Common base class for all row-containing log events.
Definition: log_event.h:2598
Represents a bidirectional map between SID and SIDNO.
Definition: rpl_gtid.h:723
Transaction Coordinator Log.
Definition: tc_log.h:143
enum_result
Definition: tc_log.h:159
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:33
This is the base class for verifying transaction boundaries.
Definition: trx_boundary_parser.h:47
enum_trx_scope
Definition: transaction_info.h:54
Dependency tracker is a container singleton that dispatches between the three methods associated with...
Definition: rpl_trx_tracking.h:216
Caches for non-transactional and transactional data before writing it to the binary log.
Definition: binlog.cc:699
Definition: item_func.h:2974
#define mysql_mutex_lock(M)
Definition: mysql_mutex.h:49
#define mysql_mutex_unlock(M)
Definition: mysql_mutex.h:56
void harvest_bytes_written(Relay_log_info *rli, bool need_log_space_lock)
Definition: binlog.cc:7752
bool mysql_show_binlog_events(THD *thd)
Execute a SHOW BINLOG EVENTS statement.
Definition: binlog.cc:3493
bool stmt_cannot_safely_rollback(const THD *thd)
This function checks if current statement cannot be rollded back safely.
Definition: binlog.cc:3139
bool normalize_binlog_name(char *to, const char *from, bool is_relay_log)
Turns a relative log binary log path into a full path, based on the opt_bin_logname or opt_relay_logn...
Definition: binlog.cc:233
int write_xa_to_cache(THD *thd)
Logging XA commit/rollback of a prepared transaction.
Definition: binlog.cc:2347
std::pair< int, std::list< std::string > > get_log_index(bool need_lock_index=true)
Retrieves the contents of the index file associated with this log object into an std::list<std::strin...
Definition: binlog.cc:5574
int close_purge_index_file()
Definition: binlog.cc:6090
void set_max_size(ulong max_size_arg)
Definition: binlog.cc:7771
ulong rpl_read_size
Definition: binlog.cc:175
int flush_cache_to_file(my_off_t *flush_end_pos)
Flush the I/O cache to file.
Definition: binlog.cc:8612
void report_cache_write_error(THD *thd, bool is_transactional)
Definition: binlog.cc:5370
bool is_transaction_empty(THD *thd)
Check if the the transaction is empty.
Definition: binlog.cc:3030
int log_loaded_block(IO_CACHE *file)
Load data's io cache specific hook to be executed before a chunk of data is being read into the cache...
Definition: binlog.cc:3290
bool trans_cannot_safely_rollback(const THD *thd)
This function checks if a transaction cannot be rolled back safely.
Definition: binlog.cc:3126
THD * fetch_and_process_flush_stage_queue(const bool check_and_skip_flush_logs=false)
Fetch and empty BINLOG_FLUSH_STAGE and COMMIT_ORDER_FLUSH_STAGE flush queues and flush transactions t...
Definition: binlog.cc:8378
int rotate(bool force_rotate, bool *check_purge)
The method executes rotation when LOCK_log is already acquired by the caller.
Definition: binlog.cc:7147
void update_thd_next_event_pos(THD *thd)
Definition: binlog.cc:6921
int find_log_pos(LOG_INFO *linfo, const char *log_name, bool need_lock_index)
Find the position in the log-index-file for the given log name.
Definition: binlog.cc:5419
bool trans_has_updated_trans_table(const THD *thd)
This function checks if a transactional table was updated by the current transaction.
Definition: binlog.cc:3068
void close() override
This is called on shutdown, after ha_panic.
Definition: binlog.cc:7984
int new_file_without_locking(Format_description_log_event *extra_description_event)
Definition: binlog.cc:6482
void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set, std::string &errmsg)
Function to report the missing GTIDs.
Definition: binlog.cc:9110
uint next_file_id()
Definition: binlog.cc:7254
void cleanup()
Definition: binlog.cc:3542
int process_flush_stage_queue(my_off_t *total_bytes_var, bool *rotate_var, THD **out_queue_var)
Execute the flush stage.
Definition: binlog.cc:8420
bool do_write_cache(Binlog_cache_storage *cache, class Binlog_event_writer *writer)
Write the contents of the given IO_CACHE to the binary log.
Definition: binlog.cc:7302
int rollback(THD *thd, bool all) override
Write a rollback record of the transaction to the binary log.
Definition: binlog.cc:2496
void init_pthread_objects()
Definition: binlog.cc:3565
bool reencrypt_logs()
Re-encrypt previous existent binary/relay logs as below.
Definition: binlog.cc:1883
const char * log_bin_index
Definition: binlog.cc:171
int open_binlog(const char *opt_name)
Definition: binlog.cc:7795
~MYSQL_BIN_LOG() override
Definition: binlog.cc:3538
bool binlog_enabled()
Check whether binlog_hton has valid slot and enabled.
Definition: binlog.cc:1316
bool is_empty_transaction_in_binlog_cache(const THD *thd)
Check if at least one of transacaction and statement binlog caches contains an empty transaction,...
Definition: binlog.cc:3049
int register_purge_index_entry(const char *entry)
Definition: binlog.cc:6121
int sync_purge_index_file()
Definition: binlog.cc:6110
int gtid_end_transaction(THD *thd)
If the thread owns a GTID, this function generates an empty transaction and releases ownership of the...
Definition: binlog.cc:1762
int set_purge_index_file_name(const char *base_file_name)
Definition: binlog.cc:6055
void process_commit_stage_queue(THD *thd, THD *queue)
Commit a sequence of sessions.
Definition: binlog.cc:8477
void register_binlog_handler(THD *thd, bool trx)
Definition: binlog.cc:9326
bool open(PSI_file_key log_file_key, const char *log_name, const char *new_name, uint32 new_index_number)
Open the logfile and init IO_CACHE.
Definition: binlog.cc:3790
bool write_buffer(const char *buf, uint len, Master_info *mi)
Definition: binlog.cc:6862
int open_purge_index_file(bool destroy)
Definition: binlog.cc:6067
int set_crash_safe_index_file_name(const char *base_file_name)
Set the name of crash safe index file.
Definition: binlog.cc:5783
const char * log_bin_basename
Definition: binlog.cc:172
int purge_logs(const char *to_log, bool included, bool need_lock_index, bool need_update_threads, ulonglong *decrease_log_space, bool auto_purge)
Remove all logs before the given log from disk and from the index file.
Definition: binlog.cc:5936
bool write_transaction(THD *thd, binlog_cache_data *cache_data, Binlog_event_writer *writer)
Write the Gtid_log_event to the binary log (prior to writing the statement or transaction cache).
Definition: binlog.cc:1606
bool truncate_relaylog_file(Master_info *mi, my_off_t valid_pos)
Truncate the active relay log file in the specified position.
Definition: binlog.cc:7945
void check_binlog_cache_size(THD *thd)
Checks if the BINLOG_CACHE_SIZE's value is greater than MAX_BINLOG_CACHE_SIZE.
Definition: binlog.cc:1277
bool is_current_stmt_binlog_enabled_and_caches_empty(const THD *thd) const
Checks whether binlog caches are disabled (binlog does not cache data) or empty in case binloggging i...
Definition: binlog.cc:2795
bool write_event_to_binlog_and_sync(Log_event *ev)
Definition: binlog.cc:7538
bool is_active(const char *log_file_name) const
Check if we are writing/reading to the given log file.
Definition: binlog.cc:6434
void check_binlog_stmt_cache_size(THD *thd)
Checks if the BINLOG_STMT_CACHE_SIZE's value is greater than MAX_BINLOG_STMT_CACHE_SIZE.
Definition: binlog.cc:1297
std::pair< bool, bool > sync_binlog_file(bool force)
Call fsync() to sync the file to disk.
Definition: binlog.cc:8625
int find_next_relay_log(char log_name[FN_REFLEN+1])
Find the relay log name following the given name from relay log index file.
Definition: binlog.cc:5553
int generate_new_name(char *new_name, const char *log_name, uint32 new_index_number=0)
Definition: binlog.cc:3725
int flush_and_set_pending_rows_event(THD *thd, Rows_log_event *event, bool is_transactional)
Definition: binlog.cc:6937
int finish_commit(THD *thd)
Helper function executed when leaving ordered_commit.
Definition: binlog.cc:8667
bool write_stmt_directly(THD *thd, const char *stmt, size_t stmt_len, enum enum_sql_command sql_command)
Write a dml into statement cache and then flush it into binlog.
Definition: binlog.cc:7464
bool ending_single_stmt_trans(THD *thd, const bool all)
This function checks if a single statement transaction is about to commit or not.
Definition: binlog.cc:3115
int raw_get_current_log(LOG_INFO *linfo)
Definition: binlog.cc:5343
int remove_logs_from_index(LOG_INFO *linfo, bool need_update_threads)
Remove logs from index file.
Definition: binlog.cc:5874
enum_result commit(THD *thd, bool all) override
Commit the transaction in the transaction coordinator.
Definition: binlog.cc:8049
bool check_write_error(const THD *thd)
Definition: binlog.cc:5351
bool purge_source_logs_to_file(THD *thd, const char *to_log)
Purges the binary log files up to the file name passed as a paramenter.
Definition: binlog.cc:3154
int get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set)
Deep copy global_sid_map and gtid_executed.
Definition: binlog.cc:7262
int find_next_log(LOG_INFO *linfo, bool need_lock_index)
Find the position in the log-index-file for the given log name.
Definition: binlog.cc:5507
int wait_for_update()
Wait until we get a signal that the binary log has been updated.
Definition: binlog.cc:7636
void make_log_name(char *buf, const char *log_ident)
Create a new log file name.
Definition: binlog.cc:6423
bool change_stage(THD *thd, Commit_stage_manager::StageID stage, THD *queue, mysql_mutex_t *leave_mutex, mysql_mutex_t *enter_mutex)
Enter a stage of the ordered commit procedure.
Definition: binlog.cc:8581
bool find_first_log(std::string &binlog_file_name, std::string &errmsg)
Find the oldest binary log referenced by the index file.
Definition: binlog.cc:4433
bool write_cache(THD *thd, class binlog_cache_data *cache_data, class Binlog_event_writer *writer)
Write the contents of the statement or transaction cache to the binary log.
Definition: binlog.cc:7576
bool write_event(Log_event *event_info)
Write an event to the binary log cache.
Definition: binlog.cc:6980
void update_binlog_end_pos(bool need_lock=true)
Definition: binlog.cc:9241
int rotate_and_purge(THD *thd, bool force_rotate)
Execute a FLUSH LOGS statement.
Definition: binlog.cc:7222
int get_current_log(LOG_INFO *linfo, bool need_lock_log=true)
Definition: binlog.cc:5335
bool is_query_in_union(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6912
int new_file_impl(bool need_lock, Format_description_log_event *extra_description_event)
Start writing to a new log file or reopen the old file.
Definition: binlog.cc:6502
bool write_event_to_binlog(Log_event *ev)
Definition: binlog.cc:7517
bool reset_logs(THD *thd, bool delete_only=false)
Removes files, as part of a RESET MASTER or RESET SLAVE statement, by deleting all logs referred to i...
Definition: binlog.cc:5617
bool purge_source_logs_before_date(THD *thd, time_t purge_time)
Execute a PURGE BINARY LOGS BEFORE <date> command.
Definition: binlog.cc:3182
bool stmt_has_updated_trans_table(Ha_trx_info_list const &ha_list)
This function checks if a transactional table was updated by the current statement.
Definition: binlog.cc:3082
bool ending_trans(THD *thd, const bool all)
This function checks if a transaction, either a multi-statement or a single statement transaction is ...
Definition: binlog.cc:3100
int query_error_code(const THD *thd, bool not_killed)
Definition: binlog.cc:3222
void process_after_commit_stage_queue(THD *thd, THD *first)
Process after commit for a sequence of sessions.
Definition: binlog.cc:8550
std::pair< int, my_off_t > flush_thread_caches(THD *thd)
Flush caches for session.
Definition: binlog.cc:8326
int move_crash_safe_index_file_to_index_file(bool need_lock_index)
Move crash safe index file to index file.
Definition: binlog.cc:5134
void report_missing_gtids(const Gtid_set *previous_gtid_set, const Gtid_set *slave_executed_gtid_set, std::string &errmsg)
Function to report the missing GTIDs.
Definition: binlog.cc:9174
int purge_index_entry(THD *thd, ulonglong *decrease_log_space, bool need_lock_index)
Definition: binlog.cc:6138
bool init_and_set_log_file_name(const char *log_name, const char *new_name, uint32 new_index_number)
Definition: binlog.cc:3765
const char * generate_name(const char *log_name, const char *suffix, char *buff)
Definition: binlog.cc:3746
int purge_logs_before_date(time_t purge_time, bool auto_purge)
Remove all logs before the given file date from disk and from the index file.
Definition: binlog.cc:6307
bool opt_binlog_order_commits
Definition: binlog.cc:169
void init_thd_variables(THD *thd, bool all, bool skip_commit)
Set thread variables used while flushing a transaction.
Definition: binlog.cc:8343
int open_crash_safe_index_file()
Open a (new) crash safe index file.
Definition: binlog.cc:5807
void start_union_events(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6899
bool is_inited_purge_index_file()
Definition: binlog.cc:6105
bool open_index_file(const char *index_file_name_arg, const char *log_name, bool need_lock_index)
Definition: binlog.cc:3843
bool write_incident(THD *thd, bool need_lock_log, const char *err_msg, bool do_flush_and_sync=true)
Creates an incident event and writes it to the binary log.
Definition: binlog.cc:7496
bool assign_automatic_gtids_to_flush_group(THD *first_seen)
Assign automatic generated GTIDs for all commit group threads in the flush stage having gtid_next....
Definition: binlog.cc:1551
int register_create_index_entry(const char *entry)
Definition: binlog.cc:6133
int close_crash_safe_index_file()
Close the crash safe index file.
Definition: binlog.cc:5839
void auto_purge()
This function runs automatic purge if the conditions to meet automatic purge are met.
Definition: binlog.cc:7177
int prepare(THD *thd, bool all) override
Log a prepare record of the transaction to the storage engines.
Definition: binlog.cc:7996
void handle_binlog_flush_or_sync_error(THD *thd, bool need_lock_log, const char *message)
Helper function to handle flush or sync stage errors.
Definition: binlog.cc:8771
int ordered_commit(THD *thd, bool all, bool skip_commit=false)
Flush and commit the transaction.
Definition: binlog.cc:8820
int add_log_to_index(uchar *log_file_name, size_t name_len, bool need_lock_index)
Append log file name to index file.
Definition: binlog.cc:5292
bool init_gtid_sets(Gtid_set *gtid_set, Gtid_set *lost_groups, bool verify_checksum, bool need_lock, Transaction_boundary_parser *trx_parser, Gtid_monitoring_info *partial_trx, bool is_server_starting=false)
Reads the set of all GTIDs in the binary/relay log, and the set of all lost GTIDs in the binary log,...
Definition: binlog.cc:4546
MYSQL_BIN_LOG(uint *sync_period, bool relay_log=false)
Definition: binlog.cc:3514
bool flush_and_sync(const bool force=false)
Flush binlog cache and synchronize to disk.
Definition: binlog.cc:6889
int new_file(Format_description_log_event *extra_description_event)
Definition: binlog.cc:6473
bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log)
Definition: binlog.cc:3325
void inc_prep_xids(THD *thd)
Increment the prepared XID counter.
Definition: binlog.cc:6438
void dec_prep_xids(THD *thd)
Decrement the prepared XID counter.
Definition: binlog.cc:6449
void stop_union_events(THD *thd)
Definition: binlog.cc:6907
bool flush()
Definition: binlog.cc:6885
void signal_update()
Notifies waiting threads that binary log has been updated.
Definition: binlog.cc:9233
int check_trx_rw_engines(THD *thd, Transaction_ctx::enum_trx_scope trx_scope)
Check if the transaction has no rw flag set for any of the storage engines.
Definition: binlog.cc:3037
bool find_first_log_not_in_gtid_set(char *binlog_file_name, const Gtid_set *gtid_set, Gtid *first_gtid, std::string &errmsg)
Find the oldest binary log that contains any GTID that is not in the given gtid set.
Definition: binlog.cc:4448
void report_binlog_write_error()
Definition: binlog.cc:7628
bool after_write_to_relay_log(Master_info *mi)
Called after an event has been written to the relay log by the IO thread.
Definition: binlog.cc:6741
void auto_purge_at_server_startup()
This member function is to be called at server startup.
Definition: binlog.cc:7165
unsigned int PSI_cond_key
Instrumented cond key.
Definition: psi_cond_bits.h:43
unsigned int PSI_file_key
Instrumented file key.
Definition: psi_file_bits.h:47
unsigned int PSI_mutex_key
Instrumented mutex key.
Definition: psi_mutex_bits.h:51
#define mysql_mutex_assert_not_owner(M)
Wrapper, to use safe_mutex_assert_not_owner with instrumented mutexes.
Definition: mysql_mutex.h:125
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
uint8_t uint8
Definition: my_inttypes.h:62
ulonglong my_off_t
Definition: my_inttypes.h:71
unsigned char uchar
Definition: my_inttypes.h:51
int64_t int64
Definition: my_inttypes.h:67
int32_t int32
Definition: my_inttypes.h:65
uint32_t uint32
Definition: my_inttypes.h:66
Common #defines and includes for file and socket I/O.
#define FN_REFLEN
Definition: my_io.h:82
Functions related to handling of plugins and other dynamically loaded libraries.
#define MYSQL_PLUGIN_IMPORT
Definition: my_sharedlib.h:70
enum_sql_command
Definition: my_sqlcommand.h:45
Common header for many mysys elements.
static int not_killed
Definition: myisamchk.cc:1615
static QUEUE queue
Definition: myisampack.cc:206
Common definition between mysql server & client.
#define NAME_LEN
Definition: mysql_com.h:66
Instrumentation helpers for conditions.
ABI for instrumented mutexes.
Type inc(Shards< COUNT > &shards, size_t id)
Increment the counter of a shard by 1.
Definition: ut0counter.h:292
The namespace contains classes representing events that can occur in a replication stream.
enum_binlog_checksum_alg
Enumeration spcifying checksum algorithm used to encode a binary log event.
Definition: binlog_event.h:420
Definition: buf0block_hint.cc:29
Definition: os0file.h:85
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:495
static mysql_service_status_t destroy(reference_caching_channel channel) noexcept
Definition: component.cc:49
Instrumentation helpers for conditions.
Instrumentation helpers for mutexes.
Performance schema instrumentation interface.
Performance schema instrumentation interface.
Instrumentation helpers for mutexes.
required string event
Definition: replication_group_member_actions.proto:31
Definition: binlog.h:87
Item_result type
Definition: binlog.h:91
ulong length
Definition: binlog.h:90
char * value
Definition: binlog.h:89
bool unsigned_flag
Definition: binlog.h:93
user_var_entry * user_var_event
Definition: binlog.h:88
uint charset_number
Definition: binlog.h:92
TODO: Move this structure to libbinlogevents/include/control_events.h when we start using C++11.
Definition: rpl_gtid.h:1065
Definition: my_sys.h:340
Definition: binlog.h:996
bool log_delayed
Definition: binlog.h:999
my_off_t last_pos_in_file
Definition: binlog.h:998
bool logged_data_file
Definition: binlog.h:999
THD * thd
Definition: binlog.h:997
Definition: binlog.h:117
my_off_t pos
Definition: binlog.h:120
my_off_t index_file_start_offset
Definition: binlog.h:119
LOG_INFO()
Definition: binlog.h:124
bool fatal
Definition: binlog.h:121
char log_file_name[FN_REFLEN]
Definition: binlog.h:118
my_off_t index_file_offset
Definition: binlog.h:119
int entry_index
Definition: binlog.h:122
int encrypted_header_size
Definition: binlog.h:123
Definition: completion_hash.h:34
An instrumented cond structure.
Definition: mysql_cond_bits.h:49
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
MySQL mutex implementation.
Include file for Sun RPC to compile out of the box.
unsigned int uint
Definition: uca-dump.cc:29
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:38
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:868