MySQL 8.1.0
Source Code Documentation
binlog.h
Go to the documentation of this file.
1#ifndef BINLOG_H_INCLUDED
2/* Copyright (c) 2010, 2023, 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 "my_dbug.h"
34#include "my_inttypes.h"
35#include "my_io.h"
36#include "my_sharedlib.h"
37#include "my_sys.h"
46#include "mysql_com.h" // Item_result
47#include "sql/binlog_reader.h" // Binlog_file_reader
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#define LOG_INFO_NOT_IN_USE -11
107
108/* bitmap to MYSQL_BIN_LOG::close() */
109#define LOG_CLOSE_INDEX 1
110#define LOG_CLOSE_TO_BE_OPENED 2
111#define LOG_CLOSE_STOP_EVENT 4
112
113struct LOG_INFO {
117 bool fatal; // if the purge happens to give us a negative offset
118 int entry_index; // used in purge_logs(), calculatd in find_log_pos().
124 pos(0),
125 fatal(false),
126 entry_index(0),
128 thread_id(0) {
129 memset(log_file_name, 0, FN_REFLEN);
130 }
131};
132
133/*
134 TODO use mmap instead of IO_CACHE for binlog
135 (mmap+fsync is two times faster than write+fsync)
136*/
137class MYSQL_BIN_LOG : public TC_LOG {
138 public:
139 class Binlog_ofile;
140
141 private:
143
144 /* LOCK_log is inited by init_pthread_objects() */
146 char *name;
148 char db[NAME_LEN + 1];
151
152 /** Instrumentation key to use for file io in @c log_file */
154 /** The instrumentation key to use for @ LOCK_log. */
156 /** The instrumentation key to use for @ LOCK_index. */
158 /** The instrumentation key to use for @ LOCK_binlog_end_pos. */
160 /** The PFS instrumentation key for @ LOCK_commit_queue. */
162 /** The PFS instrumentation key for @ LOCK_after_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_after_commit. */
180 /** The instrumentation key to use for @ LOCK_sync. */
182 /** The instrumentation key to use for @ LOCK_xids. */
184 /** The instrumentation key to use for @ m_key_LOCK_log_info. */
186 /** The instrumentation key to use for @ update_cond. */
188 /** The instrumentation key to use for @ prep_xids_cond. */
190 /** The PFS instrumentation key for @ COND_wait_for_group_turn. */
192 /** The instrumentation key to use for opening the log file. */
194 /** The instrumentation key to use for opening the log index file. */
196 /** The instrumentation key to use for opening a log cache file. */
198 /** The instrumentation key to use for opening a log index cache file. */
200
201 /* POSIX thread objects are inited by init_pthread_objects() */
209
210 std::atomic<my_off_t> atomic_binlog_end_pos;
214 /*
215 crash_safe_index_file is temp file used for guaranteeing
216 index file crash safe when master server restarts.
217 */
220 /*
221 purge_file is a temp file used in purge_logs so that the index file
222 can be updated before deleting files from disk, yielding better crash
223 recovery. It is created on demand the first time purge_logs is called
224 and then reused for subsequent calls. It is cleaned up in cleanup().
225 */
228 /*
229 The max size before rotation (usable only if log_type == LOG_BIN: binary
230 logs and relay logs).
231 For a binlog, max_size should be max_binlog_size.
232 For a relay log, it should be max_relay_log_size if this is non-zero,
233 max_binlog_size otherwise.
234 max_size is set in init(), and dynamically changed (when one does SET
235 GLOBAL MAX_BINLOG_SIZE|MAX_RELAY_LOG_SIZE) by fix_max_binlog_size and
236 fix_max_relay_log_size).
237 */
238 ulong max_size;
239
240 // current file sequence number for load data infile binary logging
242
243 /* pointer to the sync period variable, for binlog this will be
244 sync_binlog_period, for relay log this will be
245 sync_relay_log_period
246 */
249
251 std::atomic<int32> m_atomic_prep_xids{0};
252
253 /**
254 Increment the prepared XID counter.
255 */
256 void inc_prep_xids(THD *thd);
257
258 /**
259 Decrement the prepared XID counter.
260
261 Signal m_prep_xids_cond if the counter reaches zero.
262 */
263 void dec_prep_xids(THD *thd);
264
266
267 inline uint get_sync_period() { return *sync_period_ptr; }
268
269 public:
270 /*
271 This is used to start writing to a new log file. The difference from
272 new_file() is locking. new_file_without_locking() does not acquire
273 LOCK_log.
274 */
276 Format_description_log_event *extra_description_event);
277
278 /**
279 Checks whether binlog caches are disabled (binlog does not cache data) or
280 empty in case binloggging is enabled in the current call to this function.
281 This function may be safely called in case binlogging is disabled.
282 @retval true binlog local caches are empty or disabled and binlogging is
283 enabled
284 @retval false binlog local caches are enabled and contain data or binlogging
285 is disabled
286 */
288
289 private:
290 int new_file_impl(bool need_lock,
291 Format_description_log_event *extra_description_event);
292
293 bool open(PSI_file_key log_file_key, const char *log_name,
294 const char *new_name, uint32 new_index_number);
295 bool init_and_set_log_file_name(const char *log_name, const char *new_name,
296 uint32 new_index_number);
297 int generate_new_name(char *new_name, const char *log_name,
298 uint32 new_index_number = 0);
299 /**
300 * Read binary log stream header and Format_desc event from
301 * binlog_file_reader. Check for LOG_EVENT_BINLOG_IN_USE_F flag.
302 * @param[in] binlog_file_reader
303 * @return true - LOG_EVENT_BINLOG_IN_USE_F is set
304 * false - LOG_EVENT_BINLOG_IN_USE_F is not set or an error occurred
305 * while reading log events
306 */
307 bool read_binlog_in_use_flag(Binlog_file_reader &binlog_file_reader);
308
309 protected:
310 /**
311 @brief Notifies waiting threads that binary log has been updated
312 */
313 void signal_update();
314
315 public:
316 const char *generate_name(const char *log_name, const char *suffix,
317 char *buff);
318 bool is_open() const { return atomic_log_state != LOG_CLOSED; }
319
320 /* This is relay log */
322
323 uint8 checksum_alg_reset; // to contain a new value when binlog is rotated
324 /*
325 Holds the last seen in Relay-Log FD's checksum alg value.
326 The initial value comes from the slave's local FD that heads
327 the very first Relay-Log file. In the following the value may change
328 with each received master's FD_m.
329 Besides to be used in verification events that IO thread receives
330 (except the 1st fake Rotate, see @c Master_info:: checksum_alg_before_fd),
331 the value specifies if/how to compute checksum for slave's local events
332 and the first fake Rotate (R_f^1) coming from the master.
333 R_f^1 needs logging checksum-compatibly with the RL's heading FD_s.
334
335 Legends for the checksum related comments:
336
337 FD - Format-Description event,
338 R - Rotate event
339 R_f - The fake Rotate event
340 E - An arbitrary event
341
342 The underscore indexes for any event
343 `_s' - Indicates the event is generated by the Replica
344 `_m' - By the Source
345
346 Two special underscore indexes of FD:
347 FD_q - Format Description event for queuing (relay-logging)
348 FD_e - Format Description event for executing (relay-logging)
349
350 Upper indexes:
351 E^n - n:th event is a sequence
352
353 RL - Relay Log
354 (A) - checksum algorithm descriptor value
355 FD.(A) - the value of (A) in FD
356 */
358
359 MYSQL_BIN_LOG(uint *sync_period, bool relay_log = false);
360 ~MYSQL_BIN_LOG() override;
361
363 PSI_mutex_key key_LOCK_index, PSI_mutex_key key_LOCK_commit,
364 PSI_mutex_key key_LOCK_commit_queue, PSI_mutex_key key_LOCK_after_commit,
365 PSI_mutex_key key_LOCK_after_commit_queue, PSI_mutex_key key_LOCK_done,
366 PSI_mutex_key key_LOCK_flush_queue, PSI_mutex_key key_LOCK_log,
367 PSI_mutex_key key_LOCK_binlog_end_pos, PSI_mutex_key key_LOCK_sync,
368 PSI_mutex_key key_LOCK_sync_queue, PSI_mutex_key key_LOCK_xids,
369 PSI_mutex_key key_LOCK_log_info,
370 PSI_mutex_key key_LOCK_wait_for_group_turn, PSI_cond_key key_COND_done,
371 PSI_cond_key key_COND_flush_queue, PSI_cond_key key_update_cond,
372 PSI_cond_key key_prep_xids_cond,
373 PSI_cond_key key_COND_wait_for_group_turn, PSI_file_key key_file_log,
374 PSI_file_key key_file_log_index, PSI_file_key key_file_log_cache,
375 PSI_file_key key_file_log_index_cache) {
376 m_key_COND_done = key_COND_done;
377 m_key_COND_flush_queue = key_COND_flush_queue;
378
379 m_key_LOCK_commit_queue = key_LOCK_commit_queue;
380 m_key_LOCK_after_commit_queue = key_LOCK_after_commit_queue;
381 m_key_LOCK_done = key_LOCK_done;
382 m_key_LOCK_flush_queue = key_LOCK_flush_queue;
383 m_key_LOCK_sync_queue = key_LOCK_sync_queue;
384
385 m_key_LOCK_index = key_LOCK_index;
386 m_key_LOCK_log = key_LOCK_log;
387 m_key_LOCK_binlog_end_pos = key_LOCK_binlog_end_pos;
388 m_key_LOCK_commit = key_LOCK_commit;
389 m_key_LOCK_after_commit = key_LOCK_after_commit;
390 m_key_LOCK_sync = key_LOCK_sync;
391 m_key_LOCK_xids = key_LOCK_xids;
392 m_key_LOCK_log_info = key_LOCK_log_info;
393 m_key_update_cond = key_update_cond;
394 m_key_prep_xids_cond = key_prep_xids_cond;
395 m_key_file_log = key_file_log;
396 m_key_file_log_index = key_file_log_index;
397 m_key_file_log_cache = key_file_log_cache;
398 m_key_file_log_index_cache = key_file_log_index_cache;
399
400 m_key_LOCK_wait_for_group_turn = key_LOCK_wait_for_group_turn;
401 m_key_COND_wait_for_group_turn = key_COND_wait_for_group_turn;
402 }
403
404 public:
405 /** Manage the MTS dependency tracking */
407
408 /**
409 Find the oldest binary log referenced by the index file
410
411 @param[out] binlog_file_name the file name of oldest log found
412 @param[out] errmsg the error message outputted, which is left untouched
413 if the function returns false
414 @return false on success, true on error.
415 */
416 bool find_first_log(std::string &binlog_file_name, std::string &errmsg);
417
418 /**
419 Find the oldest binary log that contains any GTID that
420 is not in the given gtid set.
421
422 @param[out] binlog_file_name the file name of oldest binary log found
423 @param[in] gtid_set the given gtid set
424 @param[out] first_gtid the first GTID information from the binary log
425 file returned at binlog_file_name
426 @param[out] errmsg the error message outputted, which is left untouched
427 if the function returns false
428 @return false on success, true on error.
429 */
430 bool find_first_log_not_in_gtid_set(char *binlog_file_name,
431 const Gtid_set *gtid_set,
432 Gtid *first_gtid, std::string &errmsg);
433
434 /**
435 Reads the set of all GTIDs in the binary/relay log, and the set
436 of all lost GTIDs in the binary log, and stores each set in
437 respective argument.
438
439 @param gtid_set Will be filled with all GTIDs in this binary/relay
440 log.
441 @param lost_groups Will be filled with all GTIDs in the
442 Previous_gtids_log_event of the first binary log that has a
443 Previous_gtids_log_event. This is requested to binary logs but not
444 to relay logs.
445 @param verify_checksum If true, checksums will be checked.
446 @param need_lock If true, LOCK_log, LOCK_index, and
447 global_sid_lock->wrlock are acquired; otherwise they are asserted
448 to be taken already.
449 @param [out] trx_parser This will be used to return the actual
450 relaylog transaction parser state because of the possibility
451 of partial transactions.
452 @param [out] partial_trx If a transaction was left incomplete
453 on the relaylog, its GTID information should be returned to be
454 used in the case of the rest of the transaction be added to the
455 relaylog.
456 @param is_server_starting True if the server is starting.
457 @return false on success, true on error.
458 */
459 bool init_gtid_sets(Gtid_set *gtid_set, Gtid_set *lost_groups,
460 bool verify_checksum, bool need_lock,
461 Transaction_boundary_parser *trx_parser,
462 Gtid_monitoring_info *partial_trx,
463 bool is_server_starting = false);
464
465 void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param) {
466 assert(is_relay_log);
467 previous_gtid_set_relaylog = previous_gtid_set_param;
468 }
469 /**
470 If the thread owns a GTID, this function generates an empty
471 transaction and releases ownership of the GTID.
472
473 - If the binary log is disabled for this thread, the GTID is
474 inserted directly into the mysql.gtid_executed table and the
475 GTID is included in @@global.gtid_executed. (This only happens
476 for DDL, since DML will save the GTID into table and release
477 ownership inside ha_commit_trans.)
478
479 - If the binary log is enabled for this thread, an empty
480 transaction consisting of GTID, BEGIN, COMMIT is written to the
481 binary log, the GTID is included in @@global.gtid_executed, and
482 the GTID is added to the mysql.gtid_executed table on the next
483 binlog rotation.
484
485 This function must be called by any committing statement (COMMIT,
486 implicitly committing statements, or Xid_log_event), after the
487 statement has completed execution, regardless of whether the
488 statement updated the database.
489
490 This logic ensures that an empty transaction is generated for the
491 following cases:
492
493 - Explicit empty transaction:
494 SET GTID_NEXT = 'UUID:NUMBER'; BEGIN; COMMIT;
495
496 - Transaction or DDL that gets completely filtered out in the
497 slave thread.
498
499 @param thd The committing thread
500
501 @retval 0 Success
502 @retval nonzero Error
503 */
504 int gtid_end_transaction(THD *thd);
505 /**
506 Re-encrypt previous existent binary/relay logs as below.
507 Starting from the next to last entry on the index file, iterating
508 down to the first one:
509 - If the file is encrypted, re-encrypt it. Otherwise, skip it.
510 - If failed to open the file, report an error.
511
512 @retval False Success
513 @retval True Error
514 */
515 bool reencrypt_logs();
516
517 private:
518 std::atomic<enum_log_state> atomic_log_state{LOG_CLOSED};
519
520 /* The previous gtid set in relay log. */
522
523 int open(const char *opt_name) override { return open_binlog(opt_name); }
524
525 /**
526 Enter a stage of the ordered commit procedure.
527
528 Entering is stage is done by:
529
530 - Atomically entering a queue of THD objects (which is just one for
531 the first phase).
532
533 - If the queue was empty, the thread is the leader for that stage
534 and it should process the entire queue for that stage.
535
536 - If the queue was not empty, the thread is a follower and can go
537 waiting for the commit to finish.
538
539 The function will lock the stage mutex if the calling thread was designated
540 leader for the phase.
541
542 @param[in] thd Session structure
543 @param[in] stage The stage to enter
544 @param[in] queue Thread queue for the stage
545 @param[in] leave_mutex Mutex that will be released when changing stage
546 @param[in] enter_mutex Mutex that will be taken when changing stage
547
548 @retval true In case this thread did not become leader, the function
549 returns true *after* the leader has completed the commit
550 on its behalf, so the thread should continue doing the
551 thread-local processing after the commit
552 (i.e. call finish_commit).
553
554 @retval false The thread is the leader for the stage and should do
555 the processing.
556 */
558 mysql_mutex_t *leave_mutex, mysql_mutex_t *enter_mutex);
559 std::pair<int, my_off_t> flush_thread_caches(THD *thd);
560 int flush_cache_to_file(my_off_t *flush_end_pos);
561 int finish_commit(THD *thd);
562 std::pair<bool, bool> sync_binlog_file(bool force);
564 void process_after_commit_stage_queue(THD *thd, THD *first);
565
566 /**
567 Set thread variables used while flushing a transaction.
568
569 @param[in] thd thread whose variables need to be set
570 @param[in] all This is @c true if this is a real transaction commit, and
571 @c false otherwise.
572 @param[in] skip_commit
573 This is @c true if the call to @c ha_commit_low should
574 be skipped (it is handled by the caller somehow) and @c
575 false otherwise (the normal case).
576 */
577 void init_thd_variables(THD *thd, bool all, bool skip_commit);
578
579 /**
580 Fetch and empty BINLOG_FLUSH_STAGE and COMMIT_ORDER_FLUSH_STAGE flush queues
581 and flush transactions to the disk, and unblock threads executing slave
582 preserve commit order.
583
584 @param[in] check_and_skip_flush_logs
585 if false then flush prepared records of transactions to the log
586 of storage engine.
587 if true then flush prepared records of transactions to the log
588 of storage engine only if COMMIT_ORDER_FLUSH_STAGE queue is
589 non-empty.
590
591 @return Pointer to the first session of the BINLOG_FLUSH_STAGE stage queue.
592 */
594 const bool check_and_skip_flush_logs = false);
595
596 /**
597 Execute the flush stage.
598
599 @param[out] total_bytes_var Pointer to variable that will be set to total
600 number of bytes flushed, or NULL.
601
602 @param[out] rotate_var Pointer to variable that will be set to true if
603 binlog rotation should be performed after releasing
604 locks. If rotate is not necessary, the variable will
605 not be touched.
606
607 @param[out] out_queue_var Pointer to the sessions queue in flush stage.
608
609 @return Error code on error, zero on success
610 */
611 int process_flush_stage_queue(my_off_t *total_bytes_var, bool *rotate_var,
612 THD **out_queue_var);
613
614 /**
615 Flush and commit the transaction.
616
617 This will execute an ordered flush and commit of all outstanding
618 transactions and is the main function for the binary log group
619 commit logic. The function performs the ordered commit in four stages.
620
621 Pre-condition: transactions should have called ha_prepare_low, using
622 HA_IGNORE_DURABILITY, before entering here.
623
624 Stage#0 implements replica-preserve-commit-order for applier threads that
625 write the binary log. i.e. it forces threads to enter the queue in the
626 correct commit order.
627
628 The stage#1 flushes the caches to the binary log and under
629 LOCK_log and marks all threads that were flushed as not pending.
630
631 The stage#2 syncs the binary log for all transactions in the group.
632
633 The stage#3 executes under LOCK_commit and commits all transactions in
634 order.
635
636 There are three queues of THD objects: one for each stage.
637 The Commit_order_manager maintains it own queue and its own order for the
638 commit. So Stage#0 doesn't maintain separate StageID.
639
640 When a transaction enters a stage, it adds itself to a queue. If the queue
641 was empty so that this becomes the first transaction in the queue, the
642 thread is the *leader* of the queue. Otherwise it is a *follower*. The
643 leader will do all work for all threads in the queue, and the followers
644 will wait until the last stage is finished.
645
646 Stage 0 (SLAVE COMMIT ORDER):
647 1. If replica-preserve-commit-order and is slave applier worker thread, then
648 waits until its turn to commit i.e. till it is on the top of the queue.
649 2. When it reaches top of the queue, it signals next worker in the commit
650 order queue to awake.
651
652 Stage 1 (FLUSH):
653 1. Sync the engines (ha_flush_logs), since they prepared using non-durable
654 settings (HA_IGNORE_DURABILITY).
655 2. Generate GTIDs for all transactions in the queue.
656 3. Write the session caches for all transactions in the queue to the binary
657 log.
658 4. Increment the counter of prepared XIDs.
659
660 Stage 2 (SYNC):
661 1. If it is time to sync, based on the sync_binlog option, sync the binlog.
662 2. If sync_binlog==1, signal dump threads that they can read up to the
663 position after the last transaction in the queue
664
665 Stage 3 (COMMIT):
666 This is performed by each thread separately, if binlog_order_commits=0.
667 Otherwise by the leader does it for all threads.
668 1. Call the after_sync hook.
669 2. update the max_committed counter in the dependency_tracker
670 3. call ha_commit_low
671 4. Call the after_commit hook
672 5. Update gtids
673 6. Decrement the counter of prepared transactions
674
675 If the binary log needs to be rotated, it is done after this. During
676 rotation, it takes a lock that prevents new commit groups from executing the
677 flush stage, and waits until the counter of prepared transactions becomes 0,
678 before it creates the new file.
679
680 @param[in] thd Session to commit transaction for
681 @param[in] all This is @c true if this is a real transaction commit, and
682 @c false otherwise.
683 @param[in] skip_commit
684 This is @c true if the call to @c ha_commit_low should
685 be skipped and @c false otherwise (the normal case).
686 */
687 int ordered_commit(THD *thd, bool all, bool skip_commit = false);
688 void handle_binlog_flush_or_sync_error(THD *thd, bool need_lock_log,
689 const char *message);
691 class Binlog_event_writer *writer);
693
694 public:
695 int open_binlog(const char *opt_name);
696 void close() override;
697 enum_result commit(THD *thd, bool all) override;
698 int rollback(THD *thd, bool all) override;
699 bool truncate_relaylog_file(Master_info *mi, my_off_t valid_pos);
700 int prepare(THD *thd, bool all) override;
701#if defined(MYSQL_SERVER)
702
705 bool is_transactional);
706
707#endif /* defined(MYSQL_SERVER) */
710 void harvest_bytes_written(Relay_log_info *rli, bool need_log_space_lock);
711 void set_max_size(ulong max_size_arg);
712
713 void update_binlog_end_pos(bool need_lock = true);
714 void update_binlog_end_pos(const char *file, my_off_t pos);
715
716 /**
717 Wait until we get a signal that the binary log has been updated.
718
719 NOTES
720 @param[in] timeout a pointer to a timespec;
721 NULL means to wait w/o timeout.
722 @retval 0 if got signalled on update
723 @retval non-0 if wait timeout elapsed
724 @note
725 LOCK_binlog_end_pos must be owned before calling this function, may be
726 temporarily released while the thread is waiting and is reacquired before
727 returning from the function
728 */
729 int wait_for_update(const std::chrono::nanoseconds &timeout);
730
731 /**
732 Wait until we get a signal that the binary log has been updated.
733 @retval 0 success
734 @note
735 LOCK_binlog_end_pos must be owned before calling this function, may be
736 temporarily released while the thread is waiting and is reacquired before
737 returning from the function
738 */
739 int wait_for_update();
740
741 public:
743 void cleanup();
744 /**
745 Create a new binary log.
746 @param log_name Name of binlog
747 @param new_name Name of binlog, too. todo: what's the difference
748 between new_name and log_name?
749 @param max_size_arg The size at which this binlog will be rotated.
750 @param null_created_arg If false, and a Format_description_log_event
751 is written, then the Format_description_log_event will have the
752 timestamp 0. Otherwise, it the timestamp will be the time when the
753 event was written to the log.
754 @param need_lock_index If true, LOCK_index is acquired; otherwise
755 LOCK_index must be taken by the caller.
756 @param need_sid_lock If true, the read lock on global_sid_lock
757 will be acquired. Otherwise, the caller must hold the read lock
758 on global_sid_lock.
759 @param extra_description_event The master's FDE to be written by the I/O
760 thread while creating a new relay log file. This should be NULL for
761 binary log files.
762 @param new_index_number The binary log file index number to start from
763 after the RESET MASTER TO command is called.
764 */
765 bool open_binlog(const char *log_name, const char *new_name,
766 ulong max_size_arg, bool null_created_arg,
767 bool need_lock_index, bool need_sid_lock,
768 Format_description_log_event *extra_description_event,
769 uint32 new_index_number = 0);
770 bool open_index_file(const char *index_file_name_arg, const char *log_name,
771 bool need_lock_index);
772 /* Use this to start writing a new log file */
773 int new_file(Format_description_log_event *extra_description_event);
774
775 bool write_event(Log_event *event_info);
776 bool write_cache(THD *thd, class binlog_cache_data *cache_data,
777 class Binlog_event_writer *writer);
778 /**
779 Assign automatic generated GTIDs for all commit group threads in the flush
780 stage having gtid_next.type == AUTOMATIC_GTID.
781
782 @param first_seen The first thread seen entering the flush stage.
783 @return Returns false if succeeds, otherwise true is returned.
784 */
786 bool write_transaction(THD *thd, binlog_cache_data *cache_data,
787 Binlog_event_writer *writer);
788
789 /**
790 Write a dml into statement cache and then flush it into binlog. It writes
791 Gtid_log_event and BEGIN, COMMIT automatically.
792
793 It is aimed to handle cases of "background" logging where a statement is
794 logged indirectly, like "TRUNCATE TABLE a_memory_table". So don't use it on
795 any normal statement.
796
797 @param[in] thd the THD object of current thread.
798 @param[in] stmt the DML statement.
799 @param[in] stmt_len the length of the DML statement.
800 @param[in] sql_command the type of SQL command.
801
802 @return Returns false if succeeds, otherwise true is returned.
803 */
804 bool write_stmt_directly(THD *thd, const char *stmt, size_t stmt_len,
805 enum enum_sql_command sql_command);
806
807 void report_cache_write_error(THD *thd, bool is_transactional);
808 bool check_write_error(const THD *thd);
809 bool write_incident(THD *thd, bool need_lock_log, const char *err_msg,
810 bool do_flush_and_sync = true);
811 bool write_incident(Incident_log_event *ev, THD *thd, bool need_lock_log,
812 const char *err_msg, bool do_flush_and_sync = true);
816 void start_union_events(THD *thd, query_id_t query_id_param);
817 void stop_union_events(THD *thd);
818 bool is_query_in_union(THD *thd, query_id_t query_id_param);
819
820 bool write_buffer(const char *buf, uint len, Master_info *mi);
821 bool write_event(Log_event *ev, Master_info *mi);
822
823 /**
824 Logging XA commit/rollback of a prepared transaction.
825
826 It fills in the appropriate event in the statement cache whenever xid
827 state is marked with is_binlogged() flag that indicates the prepared
828 part of the transaction must've been logged.
829
830 About early returns from the function:
831 - ONE_PHASE option to XA-COMMIT is handled to skip writing XA-commit
832 event now.
833 - check is for the read-only XA that is not to be logged.
834
835 @param thd THD handle
836 @return error code, 0 success
837 */
838 int write_xa_to_cache(THD *thd);
839
840 private:
842 /**
843 * Truncte log file and clear LOG_EVENT_BINLOG_IN_USE_F when update is set.
844 * @param[in] log_name name of the log file to be trunacted
845 * @param[in] valid_pos position at which to truncate the log file
846 * @param[in] binlog_size length of the log file before truncated
847 * @param[in] update should the LOG_EVENT_BINLOG_IN_USE_F flag be cleared
848 * true - set LOG_EVENT_BINLOG_IN_USE_F to 0
849 * false - do not modify LOG_EVENT_BINLOG_IN_USE_F flag
850 * @return true - sucess, false - failed
851 */
852 bool truncate_update_log_file(const char *log_name, my_off_t valid_pos,
853 my_off_t binlog_size, bool update);
854
855 public:
856 void make_log_name(char *buf, const char *log_ident);
857 bool is_active(const char *log_file_name) const;
858 int remove_logs_from_index(LOG_INFO *linfo, bool need_update_threads);
859 int rotate(bool force_rotate, bool *check_purge);
860
861 /**
862 @brief This function runs automatic purge if the conditions to meet
863 automatic purge are met. Such conditions are: log is open, instance is not
864 locked for backup and automatic purge is enabled.
865
866 If all conditions are met, purge is done according to the configuration
867 of the purge window.
868 */
869 void auto_purge();
870
871 /**
872 @brief This member function is to be called at server startup. It checks if
873 purge can be done and does if it can.
874 */
876 int rotate_and_purge(THD *thd, bool force_rotate);
877
878 bool flush();
879 /**
880 Flush binlog cache and synchronize to disk.
881
882 This function flushes events in binlog cache to binary log file,
883 it will do synchronizing according to the setting of system
884 variable 'sync_binlog'. If file is synchronized, @c synced will
885 be set to 1, otherwise 0.
886
887 @param[in] force if true, ignores the 'sync_binlog' and synchronizes the
888 file.
889
890 @retval 0 Success
891 @retval other Failure
892 */
893 bool flush_and_sync(const bool force = false);
894 int purge_logs(const char *to_log, bool included, bool need_lock_index,
895 bool need_update_threads, ulonglong *decrease_log_space,
896 bool auto_purge);
897 int purge_logs_before_date(time_t purge_time, bool auto_purge);
898 int set_crash_safe_index_file_name(const char *base_file_name);
901 int add_log_to_index(uchar *log_file_name, size_t name_len,
902 bool need_lock_index);
903 int move_crash_safe_index_file_to_index_file(bool need_lock_index);
904 int set_purge_index_file_name(const char *base_file_name);
909 int register_purge_index_entry(const char *entry);
910 int register_create_index_entry(const char *entry);
911 int purge_index_entry(THD *thd, ulonglong *decrease_log_space,
912 bool need_lock_index);
913 bool reset_logs(THD *thd, bool delete_only = false);
914 void close(uint exiting, bool need_lock_log, bool need_lock_index);
915
916 // iterating through the log index file
917 int find_log_pos(LOG_INFO *linfo, const char *log_name, bool need_lock_index);
918 int find_next_log(LOG_INFO *linfo, bool need_lock_index);
919 int find_next_relay_log(char log_name[FN_REFLEN + 1]);
920 int get_current_log(LOG_INFO *linfo, bool need_lock_log = true);
921 int raw_get_current_log(LOG_INFO *linfo);
922 uint next_file_id();
923 /**
924 Retrieves the contents of the index file associated with this log object
925 into an `std::list<std::string>` object. The order held by the index file is
926 kept.
927
928 @param need_lock_index whether or not the lock over the index file should be
929 acquired inside the function.
930
931 @return a pair: a function status code; a list of `std::string` objects with
932 the content of the log index file.
933 */
934 std::pair<int, std::list<std::string>> get_log_index(
935 bool need_lock_index = true);
936 inline char *get_index_fname() { return index_file_name; }
937 inline char *get_log_fname() { return log_file_name; }
938 const char *get_name() const { return name; }
939 inline mysql_mutex_t *get_log_lock() { return &LOCK_log; }
943 inline mysql_cond_t *get_log_cond() { return &update_cond; }
945
948 inline IO_CACHE *get_index_file() { return &index_file; }
949
950 /**
951 Function to report the missing GTIDs.
952
953 This function logs the missing transactions on master to its error log
954 as a warning. If the missing GTIDs are too long to print in a message,
955 it suggests the steps to extract the missing transactions.
956
957 This function also informs slave about the GTID set sent by the slave,
958 transactions missing on the master and few suggestions to recover from
959 the error. This message shall be wrapped by
960 ER_SOURCE_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
961 error.
962
963 This function will be called from mysql_binlog_send() function.
964
965 @param slave_executed_gtid_set GTID set executed by slave
966 @param errmsg Pointer to the error message
967 */
968 void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set,
969 std::string &errmsg);
970
971 /**
972 Function to report the missing GTIDs.
973
974 This function logs the missing transactions on master to its error log
975 as a warning. If the missing GTIDs are too long to print in a message,
976 it suggests the steps to extract the missing transactions.
977
978 This function also informs slave about the GTID set sent by the slave,
979 transactions missing on the master and few suggestions to recover from
980 the error. This message shall be wrapped by
981 ER_SOURCE_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
982 error.
983
984 This function will be called from find_first_log_not_in_gtid_set()
985 function.
986
987 @param previous_gtid_set Previous GTID set found
988 @param slave_executed_gtid_set GTID set executed by slave
989 @param errmsg Pointer to the error message
990 */
991 void report_missing_gtids(const Gtid_set *previous_gtid_set,
992 const Gtid_set *slave_executed_gtid_set,
993 std::string &errmsg);
995 /*
996 It is called by the threads (e.g. dump thread, applier thread) which want
997 to read hot log without LOCK_log protection.
998 */
1001 return atomic_binlog_end_pos;
1002 }
1006
1007 /**
1008 Deep copy global_sid_map and gtid_executed.
1009 Both operations are done under LOCK_commit and global_sid_lock
1010 protection.
1011
1012 @param[out] sid_map The Sid_map to which global_sid_map will
1013 be copied.
1014 @param[out] gtid_set The Gtid_set to which gtid_executed will
1015 be copied.
1016
1017 @return the operation status
1018 @retval 0 OK
1019 @retval !=0 Error
1020 */
1021 int get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set);
1022
1023 /*
1024 True while rotating binlog, which is caused by logging Incident_log_event.
1025 */
1027
1028 public:
1029 /**
1030 Register LOG_INFO so that log_in_use and adjust_linfo_offsets can
1031 operate on all logs. Note that register_log_info, unregister_log_info,
1032 log_in_use, adjust_linfo_offsets are is used on global mysql_bin_log object.
1033 @param log_info pointer to LOG_INFO which is registred
1034 */
1036 /**
1037 Unregister LOG_INFO when it is no longer needed.
1038 @param log_info pointer to LOG_INFO which is registred
1039 */
1041 /**
1042 Check if any threads use log name.
1043 @note This method expects the LOCK_index to be taken so there are no
1044 concurrent edits against linfo objects being iterated
1045 @param log_name name of a log which is checked for usage
1046
1047 */
1048 int log_in_use(const char *log_name);
1049 /**
1050 Adjust the position pointer in the binary log file for all running replicas.
1051 SYNOPSIS
1052 adjust_linfo_offsets()
1053 purge_offset Number of bytes removed from start of log index file
1054 NOTES
1055 - This is called when doing a PURGE when we delete lines from the
1056 index log file. This method expects the LOCK_index to be taken so there
1057 are no concurrent edits against linfo objects being iterated. REQUIREMENTS
1058 - Before calling this function, we have to ensure that no threads are
1059 using any binary log file before purge_offset.
1060 TODO
1061 - Inform the replica threads that they should sync the position
1062 in the binary log file with flush_relay_log_info.
1063 Now they sync is done for next read.
1064 */
1065 void adjust_linfo_offsets(my_off_t purge_offset);
1066
1067 private:
1069 // Set of log info objects that are in usage and might prevent some other
1070 // operations from executing.
1071 std::set<LOG_INFO *> log_info_set;
1072};
1073
1078};
1079
1081
1082/**
1083 Check if the the transaction is empty.
1084
1085 @param thd The client thread that executed the current statement.
1086
1087 @retval true No changes found in any storage engine
1088 @retval false Otherwise.
1089
1090**/
1091bool is_transaction_empty(THD *thd);
1092/**
1093 Check if the transaction has no rw flag set for any of the storage engines.
1094
1095 @param thd The client thread that executed the current statement.
1096 @param trx_scope The transaction scope to look into.
1097
1098 @retval the number of engines which have actual changes.
1099 */
1101
1102/**
1103 Check if at least one of transacaction and statement binlog caches contains
1104 an empty transaction, other one is empty or contains an empty transaction,
1105 which has two binlog events "BEGIN" and "COMMIT".
1106
1107 @param thd The client thread that executed the current statement.
1108
1109 @retval true At least one of transacaction and statement binlog caches
1110 contains an empty transaction, other one is empty or
1111 contains an empty transaction.
1112 @retval false Otherwise.
1113*/
1115bool trans_has_updated_trans_table(const THD *thd);
1117bool ending_trans(THD *thd, const bool all);
1118bool ending_single_stmt_trans(THD *thd, const bool all);
1119bool trans_cannot_safely_rollback(const THD *thd);
1120bool stmt_cannot_safely_rollback(const THD *thd);
1121
1123
1124/**
1125 @brief Purges the binary log files up to the file name passed as
1126 a paramenter. Purge will not delete the file passed as
1127 an argument.
1128
1129 @param thd The session context.
1130 @param to_log Up to which log file to purge.
1131 @return true if there was an error.
1132 @return false if there was no error.
1133 */
1134bool purge_source_logs_to_file(THD *thd, const char *to_log);
1135
1136bool purge_source_logs_before_date(THD *thd, time_t purge_time);
1138bool mysql_show_binlog_events(THD *thd);
1139void check_binlog_cache_size(THD *thd);
1141bool binlog_enabled();
1142void register_binlog_handler(THD *thd, bool trx);
1143int query_error_code(const THD *thd, bool not_killed);
1144
1145extern const char *log_bin_index;
1146extern const char *log_bin_basename;
1147extern bool opt_binlog_order_commits;
1148extern ulong rpl_read_size;
1149/**
1150 Turns a relative log binary log path into a full path, based on the
1151 opt_bin_logname or opt_relay_logname. Also trims the cr-lf at the
1152 end of the full_path before return to avoid any server startup
1153 problem on windows.
1154
1155 @param from The log name we want to make into an absolute path.
1156 @param to The buffer where to put the results of the
1157 normalization.
1158 @param is_relay_log Switch that makes is used inside to choose which
1159 option (opt_bin_logname or opt_relay_logname) to
1160 use when calculating the base path.
1161
1162 @returns true if a problem occurs, false otherwise.
1163 */
1164
1165bool normalize_binlog_name(char *to, const char *from, bool is_relay_log);
1166
1167#endif /* BINLOG_H_INCLUDED */
#define log_info
Definition: log_client.h:108
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.
It owns an allocator, a byte stream, an event_data stream and an event object stream.
Definition: binlog_reader.h:290
Byte container that provides a storage for serializing session binlog events.
Definition: binlog_ostream.h:173
Auxiliary class to copy serialized events to the binary log and correct some of the fields that are n...
Definition: binlog.cc:1382
StageID
Constants for queues for different stages.
Definition: rpl_commit_stage_manager.h:165
For binlog version 4.
Definition: log_event.h:1503
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1321
Represents a set of GTIDs.
Definition: rpl_gtid.h:1465
Container to hold and allow iteration over a set of Ha_trx_info objects.
Definition: transaction_info.h:502
Either statement transaction or normal transaction - related thread-specific storage engine data.
Definition: transaction_info.h:402
Class representing an incident, an occurrence out of the ordinary, that happened on the master.
Definition: log_event.h:3413
This is the abstract base class for binary log events.
Definition: log_event.h:542
Logical binlog file which wraps and hides the detail of lower layer storage implementation.
Definition: binlog.cc:382
Definition: binlog.h:137
mysql_mutex_t * get_binlog_end_pos_lock()
Definition: binlog.h:1003
const char * get_name() const
Definition: binlog.h:938
mysql_cond_t m_prep_xids_cond
Definition: binlog.h:250
mysql_mutex_t * get_commit_lock()
Definition: binlog.h:941
mysql_mutex_t LOCK_binlog_end_pos
Definition: binlog.h:206
std::atomic< my_off_t > atomic_binlog_end_pos
Definition: binlog.h:210
void unlock_binlog_end_pos()
Definition: binlog.h:1005
PSI_mutex_key m_key_LOCK_xids
The instrumentation key to use for @ LOCK_xids.
Definition: binlog.h:183
mysql_mutex_t LOCK_commit
Definition: binlog.h:203
char db[NAME_LEN+1]
Definition: binlog.h:148
void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param)
Definition: binlog.h:465
IO_CACHE crash_safe_index_file
Definition: binlog.h:218
void reset_bytes_written()
Definition: binlog.h:709
void lock_binlog_end_pos()
Definition: binlog.h:1004
enum_log_state
Definition: binlog.h:142
@ LOG_OPENED
Definition: binlog.h:142
@ LOG_CLOSED
Definition: binlog.h:142
@ LOG_TO_BE_OPENED
Definition: binlog.h:142
mysql_mutex_t LOCK_index
Definition: binlog.h:202
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:205
PSI_mutex_key m_key_LOCK_after_commit
The instrumentation key to use for @ LOCK_after_commit.
Definition: binlog.h:179
PSI_mutex_key m_key_LOCK_commit_queue
The PFS instrumentation key for @ LOCK_commit_queue.
Definition: binlog.h:161
bool write_event_to_binlog_and_flush(Log_event *ev)
mysql_mutex_t LOCK_after_commit
Definition: binlog.h:204
Binlog_ofile * get_binlog_file()
Definition: binlog.h:944
mysql_mutex_t LOCK_log_info
Definition: binlog.h:1068
int open(const char *opt_name) override
Initialize and open the coordinator log.
Definition: binlog.h:523
mysql_mutex_t * get_log_lock()
Definition: binlog.h:939
bool is_open() const
Definition: binlog.h:318
IO_CACHE purge_index_file
Definition: binlog.h:226
PSI_cond_key m_key_prep_xids_cond
The instrumentation key to use for @ prep_xids_cond.
Definition: binlog.h:189
my_off_t get_binlog_end_pos() const
Definition: binlog.h:999
void lock_index()
Definition: binlog.h:946
PSI_mutex_key m_key_LOCK_flush_queue
The PFS instrumentation key for @ LOCK_flush_queue.
Definition: binlog.h:167
PSI_mutex_key m_key_LOCK_after_commit_queue
The PFS instrumentation key for @ LOCK_after_commit_queue.
Definition: binlog.h:163
int32 get_prep_xids()
Definition: binlog.h:265
std::atomic< enum_log_state > atomic_log_state
Definition: binlog.h:518
Gtid_set * previous_gtid_set_relaylog
Definition: binlog.h:521
PSI_cond_key m_key_update_cond
The instrumentation key to use for @ update_cond.
Definition: binlog.h:187
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_after_commit, PSI_mutex_key key_LOCK_after_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_log_info, 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:362
char * get_index_fname()
Definition: binlog.h:936
bool write_error
Definition: binlog.h:149
uint * sync_period_ptr
Definition: binlog.h:247
mysql_mutex_t * get_after_commit_lock()
Definition: binlog.h:942
PSI_mutex_key m_key_LOCK_done
The PFS instrumentation key for @ LOCK_done.
Definition: binlog.h:165
std::set< LOG_INFO * > log_info_set
Definition: binlog.h:1071
std::atomic< int32 > m_atomic_prep_xids
Definition: binlog.h:251
Binlog_ofile * m_binlog_file
Definition: binlog.h:150
PSI_mutex_key m_key_LOCK_sync
The instrumentation key to use for @ LOCK_sync.
Definition: binlog.h:181
void add_bytes_written(ulonglong inc)
Definition: binlog.h:708
bool inited
Definition: binlog.h:149
PSI_file_key m_key_file_log_index_cache
The instrumentation key to use for opening a log index cache file.
Definition: binlog.h:199
mysql_mutex_t * get_index_lock()
Definition: binlog.h:940
PSI_mutex_key m_key_LOCK_binlog_end_pos
The instrumentation key to use for @ LOCK_binlog_end_pos.
Definition: binlog.h:159
char index_file_name[FN_REFLEN]
Definition: binlog.h:213
IO_CACHE * get_index_file()
Definition: binlog.h:948
mysql_cond_t * get_log_cond()
Definition: binlog.h:943
mysql_mutex_t LOCK_log
Definition: binlog.h:145
ulong max_size
Definition: binlog.h:238
bool is_relay_log
Definition: binlog.h:321
PSI_mutex_key m_key_LOCK_index
The instrumentation key to use for @ LOCK_index.
Definition: binlog.h:157
uint get_sync_period()
Definition: binlog.h:267
PSI_cond_key m_key_COND_wait_for_group_turn
The PFS instrumentation key for @ COND_wait_for_group_turn.
Definition: binlog.h:191
PSI_mutex_key m_key_LOCK_log
The instrumentation key to use for @ LOCK_log.
Definition: binlog.h:155
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:241
ulonglong bytes_written
Definition: binlog.h:211
binary_log::enum_binlog_checksum_alg relay_log_checksum_alg
Definition: binlog.h:357
mysql_cond_t update_cond
Definition: binlog.h:208
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:947
PSI_file_key m_key_file_log
The instrumentation key to use for opening the log file.
Definition: binlog.h:193
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:937
char purge_index_file_name[FN_REFLEN]
Definition: binlog.h:227
Transaction_dependency_tracker m_dependency_tracker
Manage the MTS dependency tracking.
Definition: binlog.h:406
IO_CACHE index_file
Definition: binlog.h:212
mysql_mutex_t LOCK_xids
Definition: binlog.h:207
PSI_file_key m_key_file_log_cache
The instrumentation key to use for opening a log cache file.
Definition: binlog.h:197
uint sync_counter
Definition: binlog.h:248
PSI_file_key m_log_file_key
Instrumentation key to use for file io in log_file.
Definition: binlog.h:153
bool is_rotating_caused_by_incident
Definition: binlog.h:1026
char * name
Definition: binlog.h:146
char log_file_name[FN_REFLEN]
Definition: binlog.h:147
uint8 checksum_alg_reset
Definition: binlog.h:323
PSI_mutex_key m_key_LOCK_log_info
The instrumentation key to use for @ m_key_LOCK_log_info.
Definition: binlog.h:185
char crash_safe_index_file_name[FN_REFLEN]
Definition: binlog.h:219
static const int MAX_RETRIES_FOR_DELETE_RENAME_FAILURE
Definition: binlog.h:994
PSI_file_key m_key_file_log_index
The instrumentation key to use for opening the log index file.
Definition: binlog.h:195
Definition: rpl_mi.h:86
Definition: rpl_rli.h:202
Common base class for all row-containing log events.
Definition: log_event.h:2606
Represents a bidirectional map between SID and SIDNO.
Definition: rpl_gtid.h:734
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:55
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:703
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:7862
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:3182
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:243
int write_xa_to_cache(THD *thd)
Logging XA commit/rollback of a prepared transaction.
Definition: binlog.cc:2485
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:5575
int close_purge_index_file()
Definition: binlog.cc:6093
void set_max_size(ulong max_size_arg)
Definition: binlog.cc:7881
ulong rpl_read_size
Definition: binlog.cc:186
int flush_cache_to_file(my_off_t *flush_end_pos)
Flush the I/O cache to file.
Definition: binlog.cc:8713
void report_cache_write_error(THD *thd, bool is_transactional)
Definition: binlog.cc:5371
bool is_transaction_empty(THD *thd)
Check if the the transaction is empty.
Definition: binlog.cc:3073
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:3331
bool trans_cannot_safely_rollback(const THD *thd)
This function checks if a transaction cannot be rolled back safely.
Definition: binlog.cc:3169
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:8482
int rotate(bool force_rotate, bool *check_purge)
The method executes rotation when LOCK_log is already acquired by the caller.
Definition: binlog.cc:7184
void update_thd_next_event_pos(THD *thd)
Definition: binlog.cc:6958
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:5420
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:3111
void close() override
This is called on shutdown, after ha_panic.
Definition: binlog.cc:8088
int new_file_without_locking(Format_description_log_event *extra_description_event)
Definition: binlog.cc:6485
void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set, std::string &errmsg)
Function to report the missing GTIDs.
Definition: binlog.cc:9230
uint next_file_id()
Definition: binlog.cc:7306
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:8524
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:7412
int rollback(THD *thd, bool all) override
Write a rollback record of the transaction to the binary log.
Definition: binlog.cc:2634
void init_pthread_objects()
Definition: binlog.cc:3567
bool reencrypt_logs()
Re-encrypt previous existent binary/relay logs as below.
Definition: binlog.cc:1901
void unregister_log_info(LOG_INFO *log_info)
Unregister LOG_INFO when it is no longer needed.
Definition: binlog.cc:7343
int log_in_use(const char *log_name)
Check if any threads use log name.
Definition: binlog.cc:7349
const char * log_bin_index
Definition: binlog.cc:182
int open_binlog(const char *opt_name)
Definition: binlog.cc:7927
~MYSQL_BIN_LOG() override
Definition: binlog.cc:3538
bool binlog_enabled()
Check whether binlog_hton has valid slot and enabled.
Definition: binlog.cc:1334
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:3092
int register_purge_index_entry(const char *entry)
Definition: binlog.cc:6124
int sync_purge_index_file()
Definition: binlog.cc:6113
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:1780
void register_log_info(LOG_INFO *log_info)
Register LOG_INFO so that log_in_use and adjust_linfo_offsets can operate on all logs.
Definition: binlog.cc:7337
int set_purge_index_file_name(const char *base_file_name)
Definition: binlog.cc:6058
void process_commit_stage_queue(THD *thd, THD *queue)
Commit a sequence of sessions.
Definition: binlog.cc:8581
void register_binlog_handler(THD *thd, bool trx)
Definition: binlog.cc:9446
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:3796
bool write_buffer(const char *buf, uint len, Master_info *mi)
Definition: binlog.cc:6899
int open_purge_index_file(bool destroy)
Definition: binlog.cc:6070
int set_crash_safe_index_file_name(const char *base_file_name)
Set the name of crash safe index file.
Definition: binlog.cc:5784
const char * log_bin_basename
Definition: binlog.cc:183
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:5937
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:1624
bool truncate_update_log_file(const char *log_name, my_off_t valid_pos, my_off_t binlog_size, bool update)
Truncte log file and clear LOG_EVENT_BINLOG_IN_USE_F when update is set.
Definition: binlog.cc:6840
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:8049
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:1295
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:2933
bool write_event_to_binlog_and_sync(Log_event *ev)
Definition: binlog.cc:7648
bool read_binlog_in_use_flag(Binlog_file_reader &binlog_file_reader)
Read binary log stream header and Format_desc event from binlog_file_reader.
Definition: binlog.cc:7897
bool is_active(const char *log_file_name) const
Check if we are writing/reading to the given log file.
Definition: binlog.cc:6437
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:1315
std::pair< bool, bool > sync_binlog_file(bool force)
Call fsync() to sync the file to disk.
Definition: binlog.cc:8726
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:5554
int generate_new_name(char *new_name, const char *log_name, uint32 new_index_number=0)
Definition: binlog.cc:3731
int flush_and_set_pending_rows_event(THD *thd, Rows_log_event *event, bool is_transactional)
Definition: binlog.cc:6974
int finish_commit(THD *thd)
Helper function executed when leaving ordered_commit.
Definition: binlog.cc:8768
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:7574
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:3158
int raw_get_current_log(LOG_INFO *linfo)
Definition: binlog.cc:5344
int remove_logs_from_index(LOG_INFO *linfo, bool need_update_threads)
Remove logs from index file.
Definition: binlog.cc:5875
enum_result commit(THD *thd, bool all) override
Commit the transaction in the transaction coordinator.
Definition: binlog.cc:8153
bool check_write_error(const THD *thd)
Definition: binlog.cc:5352
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:3197
int get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set)
Deep copy global_sid_map and gtid_executed.
Definition: binlog.cc:7314
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:5508
int wait_for_update()
Wait until we get a signal that the binary log has been updated.
Definition: binlog.cc:7746
void make_log_name(char *buf, const char *log_ident)
Create a new log file name.
Definition: binlog.cc:6426
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:8682
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:4439
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:7686
bool write_event(Log_event *event_info)
Write an event to the binary log cache.
Definition: binlog.cc:7017
void update_binlog_end_pos(bool need_lock=true)
Definition: binlog.cc:9361
int rotate_and_purge(THD *thd, bool force_rotate)
Execute a FLUSH LOGS statement.
Definition: binlog.cc:7274
int get_current_log(LOG_INFO *linfo, bool need_lock_log=true)
Definition: binlog.cc:5336
bool is_query_in_union(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6949
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:6505
bool write_event_to_binlog(Log_event *ev)
Definition: binlog.cc:7627
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:5618
bool purge_source_logs_before_date(THD *thd, time_t purge_time)
Execute a PURGE BINARY LOGS BEFORE <date> command.
Definition: binlog.cc:3236
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:3125
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:3143
int query_error_code(const THD *thd, bool not_killed)
Definition: binlog.cc:3263
void process_after_commit_stage_queue(THD *thd, THD *first)
Process after commit for a sequence of sessions.
Definition: binlog.cc:8654
std::pair< int, my_off_t > flush_thread_caches(THD *thd)
Flush caches for session.
Definition: binlog.cc:8430
int move_crash_safe_index_file_to_index_file(bool need_lock_index)
Move crash safe index file to index file.
Definition: binlog.cc:5135
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:9294
int purge_index_entry(THD *thd, ulonglong *decrease_log_space, bool need_lock_index)
Definition: binlog.cc:6141
bool init_and_set_log_file_name(const char *log_name, const char *new_name, uint32 new_index_number)
Definition: binlog.cc:3771
const char * generate_name(const char *log_name, const char *suffix, char *buff)
Definition: binlog.cc:3752
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:6310
bool opt_binlog_order_commits
Definition: binlog.cc:180
void init_thd_variables(THD *thd, bool all, bool skip_commit)
Set thread variables used while flushing a transaction.
Definition: binlog.cc:8447
int open_crash_safe_index_file()
Open a (new) crash safe index file.
Definition: binlog.cc:5808
void start_union_events(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6936
bool is_inited_purge_index_file()
Definition: binlog.cc:6108
bool open_index_file(const char *index_file_name_arg, const char *log_name, bool need_lock_index)
Definition: binlog.cc:3849
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:7606
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:1569
int register_create_index_entry(const char *entry)
Definition: binlog.cc:6136
int close_crash_safe_index_file()
Close the crash safe index file.
Definition: binlog.cc:5840
void auto_purge()
This function runs automatic purge if the conditions to meet automatic purge are met.
Definition: binlog.cc:7214
int prepare(THD *thd, bool all) override
Log a prepare record of the transaction to the storage engines.
Definition: binlog.cc:8100
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:8872
int ordered_commit(THD *thd, bool all, bool skip_commit=false)
Flush and commit the transaction.
Definition: binlog.cc:8922
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:5293
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:4552
void adjust_linfo_offsets(my_off_t purge_offset)
Adjust the position pointer in the binary log file for all running replicas.
Definition: binlog.cc:7375
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:6926
int new_file(Format_description_log_event *extra_description_event)
Definition: binlog.cc:6476
bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log)
Definition: binlog.cc:3366
void inc_prep_xids(THD *thd)
Increment the prepared XID counter.
Definition: binlog.cc:6441
void dec_prep_xids(THD *thd)
Decrement the prepared XID counter.
Definition: binlog.cc:6452
void stop_union_events(THD *thd)
Definition: binlog.cc:6944
bool flush()
Definition: binlog.cc:6922
void signal_update()
Notifies waiting threads that binary log has been updated.
Definition: binlog.cc:9353
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:3080
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:4454
void report_binlog_write_error()
Definition: binlog.cc:7738
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:6744
void auto_purge_at_server_startup()
This member function is to be called at server startup.
Definition: binlog.cc:7202
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.
uint32 my_thread_id
Definition: my_thread_local.h:33
static int not_killed
Definition: myisamchk.cc:1618
static uint update
Definition: myisamlog.cc:93
static QUEUE queue
Definition: myisampack.cc:209
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:433
Definition: buf0block_hint.cc:29
Definition: os0file.h:85
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:497
static int destroy(mysql_cond_t *that, const char *, unsigned int)
Definition: mysql_cond_v1_native.cc:42
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:1076
Definition: my_sys.h:343
Definition: binlog.h:1074
bool log_delayed
Definition: binlog.h:1077
my_off_t last_pos_in_file
Definition: binlog.h:1076
bool logged_data_file
Definition: binlog.h:1077
THD * thd
Definition: binlog.h:1075
Definition: binlog.h:113
my_thread_id thread_id
Definition: binlog.h:120
my_off_t pos
Definition: binlog.h:116
my_off_t index_file_start_offset
Definition: binlog.h:115
LOG_INFO()
Definition: binlog.h:121
bool fatal
Definition: binlog.h:117
char log_file_name[FN_REFLEN]
Definition: binlog.h:114
my_off_t index_file_offset
Definition: binlog.h:115
int entry_index
Definition: binlog.h:118
int encrypted_header_size
Definition: binlog.h:119
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.
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:38