MySQL 9.3.0
Source Code Documentation
binlog.h
Go to the documentation of this file.
1/* Copyright (c) 2010, 2025, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is designed to work with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have either included with
13 the program or referenced in the documentation.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
23#ifndef BINLOG_H_INCLUDED
24#define BINLOG_H_INCLUDED
25
26#include <string.h>
27#include <sys/types.h>
28#include <time.h>
29#include <atomic>
30#include <string_view>
31#include <utility>
32
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"
38#include "mysql/binlog/event/binlog_event.h" // enum_binlog_checksum_alg
48#include "mysql_com.h" // Item_result
49#include "sql/binlog_index.h" // Log_info, Binlog_index
50#include "sql/binlog_reader.h" // Binlog_file_reader
53#include "sql/tc_log.h" // TC_LOG
54#include "sql/transaction_info.h" // Transaction_ctx
55#include "thr_mutex.h"
56
59class Gtid_set;
60class Ha_trx_info;
61class Log_event;
62class Master_info;
63class Relay_log_info;
64class Rows_log_event;
65class Tsid_map;
66class THD;
67class Transaction_boundary_parser;
69class user_var_entry;
71
72struct Gtid;
73
75
76/*
77 Maximum unique log filename extension.
78 Note: setting to 0x7FFFFFFF due to atol windows
79 overflow/truncate.
80 */
81#define MAX_LOG_UNIQUE_FN_EXT 0x7FFFFFFF
82
83/*
84 Maximum allowed unique log filename extension for
85 RESET BINARY LOGS AND GTIDS command - 2 Billion
86 */
87#define MAX_ALLOWED_FN_EXT_RESET_BIN_LOGS 2000000000
88
91 char *value;
92 ulong length;
96};
97
98/* bitmap to MYSQL_BIN_LOG::close() */
99#define LOG_CLOSE_INDEX 1
100#define LOG_CLOSE_TO_BE_OPENED 2
101#define LOG_CLOSE_STOP_EVENT 4
102
103/*
104 TODO use mmap instead of IO_CACHE for binlog
105 (mmap+fsync is two times faster than write+fsync)
106*/
107class MYSQL_BIN_LOG : public TC_LOG {
108 public:
109 class Binlog_ofile;
110
111 private:
113
114 /* LOCK_log is inited by init_pthread_objects() */
116 char *name;
118 char db[NAME_LEN + 1];
121
122 /** Instrumentation key to use for file io in @c log_file */
124 /** The instrumentation key to use for @ LOCK_log. */
126 /** The instrumentation key to use for @ LOCK_binlog_end_pos. */
128 /** The PFS instrumentation key for @ LOCK_commit_queue. */
130 /** The PFS instrumentation key for @ LOCK_after_commit_queue. */
132 /** The PFS instrumentation key for @ LOCK_done. */
134 /** The PFS instrumentation key for @ LOCK_flush_queue. */
136 /** The PFS instrumentation key for @ LOCK_sync_queue. */
138 /** The PFS instrumentation key for @ LOCK_wait_for_group_turn. */
140 /** The PFS instrumentation key for @ COND_done. */
142 /** The PFS instrumentation key for @ COND_flush_queue. */
144 /** The instrumentation key to use for @ LOCK_commit. */
146 /** The instrumentation key to use for @ LOCK_after_commit. */
148 /** The instrumentation key to use for @ LOCK_sync. */
150 /** The instrumentation key to use for @ LOCK_xids. */
152 /** The instrumentation key to use for @ m_key_LOCK_log_info. */
154 /** The instrumentation key to use for @ update_cond. */
156 /** The instrumentation key to use for @ prep_xids_cond. */
158 /** The PFS instrumentation key for @ COND_wait_for_group_turn. */
160 /** The instrumentation key to use for opening the log file. */
162 /** The instrumentation key to use for opening a log cache file. */
164
165 /* POSIX thread objects are inited by init_pthread_objects() */
172
173 std::atomic<my_off_t> atomic_binlog_end_pos;
175
176 /** Concurrent access to binlog index file */
178
179 /*
180 The max size before rotation (usable only if log_type == LOG_BIN: binary
181 logs and relay logs).
182 For a binlog, max_size should be max_binlog_size.
183 For a relay log, it should be max_relay_log_size if this is non-zero,
184 max_binlog_size otherwise.
185 max_size is set in init(), and dynamically changed (when one does SET
186 GLOBAL MAX_BINLOG_SIZE|MAX_RELAY_LOG_SIZE) by fix_max_binlog_size and
187 fix_max_relay_log_size).
188 */
189 ulong max_size;
190
191 // current file sequence number for load data infile binary logging
193
194 /* pointer to the sync period variable, for binlog this will be
195 sync_binlog_period, for relay log this will be
196 sync_relay_log_period
197 */
200
202 std::atomic<int32> m_atomic_prep_xids{0};
203
204 /**
205 Increment the prepared XID counter.
206 */
207 void inc_prep_xids(THD *thd);
208
209 /**
210 Decrement the prepared XID counter.
211
212 Signal m_prep_xids_cond if the counter reaches zero.
213 */
214 void dec_prep_xids(THD *thd);
215
217
218 inline uint get_sync_period() { return *sync_period_ptr; }
219
220 public:
221 /**
222 Wait until the number of prepared XIDs are zero.
223 */
224 void wait_for_prep_xids();
225
226 /*
227 This is used to start writing to a new log file. The difference from
228 new_file() is locking. new_file_without_locking() does not acquire
229 LOCK_log.
230 */
232 Format_description_log_event *extra_description_event);
233
234 /**
235 Checks whether binlog caches are disabled (binlog does not cache data) or
236 empty in case binloggging is enabled in the current call to this function.
237 This function may be safely called in case binlogging is disabled.
238 @retval true binlog local caches are empty or disabled and binlogging is
239 enabled
240 @retval false binlog local caches are enabled and contain data or binlogging
241 is disabled
242 */
244
245 private:
246 int new_file_impl(bool need_lock,
247 Format_description_log_event *extra_description_event);
248
249 bool open(PSI_file_key log_file_key, const char *log_name,
250 const char *new_name, uint32 new_index_number);
251 bool init_and_set_log_file_name(const char *log_name, const char *new_name,
252 uint32 new_index_number);
253 int generate_new_name(char *new_name, const char *log_name,
254 uint32 new_index_number = 0);
255 /**
256 * Read binary log stream header and Format_desc event from
257 * binlog_file_reader. Check for LOG_EVENT_BINLOG_IN_USE_F flag.
258 * @param[in] binlog_file_reader a Binlog_file_reader
259 * @return true - LOG_EVENT_BINLOG_IN_USE_F is set
260 * false - LOG_EVENT_BINLOG_IN_USE_F is not set or an error occurred
261 * while reading log events
262 */
263 bool read_binlog_in_use_flag(Binlog_file_reader &binlog_file_reader);
264
265 protected:
266 /**
267 @brief Notifies waiting threads that binary log has been updated
268 */
269 void signal_update();
270
271 public:
272 const char *generate_name(const char *log_name, const char *suffix,
273 char *buff);
274 bool is_open() const { return atomic_log_state != LOG_CLOSED; }
275
276 /** @see Binlog_index_monitor::get_filename_list */
277 std::pair<std::list<std::string>, mysql::utils::Error> get_filename_list();
278
279 /* This is relay log */
281
282 uint8 checksum_alg_reset; // to contain a new value when binlog is rotated
283 /*
284 Holds the last seen in Relay-Log FD's checksum alg value.
285 The initial value comes from the slave's local FD that heads
286 the very first Relay-Log file. In the following the value may change
287 with each received master's FD_m.
288 Besides to be used in verification events that IO thread receives
289 (except the 1st fake Rotate, see @c Master_info:: checksum_alg_before_fd),
290 the value specifies if/how to compute checksum for slave's local events
291 and the first fake Rotate (R_f^1) coming from the master.
292 R_f^1 needs logging checksum-compatibly with the RL's heading FD_s.
293
294 Legends for the checksum related comments:
295
296 FD - Format-Description event,
297 R - Rotate event
298 R_f - The fake Rotate event
299 E - An arbitrary event
300
301 The underscore indexes for any event
302 `_s' - Indicates the event is generated by the Replica
303 `_m' - By the Source
304
305 Two special underscore indexes of FD:
306 FD_q - Format Description event for queuing (relay-logging)
307 FD_e - Format Description event for executing (relay-logging)
308
309 Upper indexes:
310 E^n - n:th event is a sequence
311
312 RL - Relay Log
313 (A) - checksum algorithm descriptor value
314 FD.(A) - the value of (A) in FD
315 */
317
318 MYSQL_BIN_LOG(uint *sync_period, bool relay_log = false);
319 ~MYSQL_BIN_LOG() override;
320
322 PSI_mutex_key key_LOCK_index, PSI_mutex_key key_LOCK_commit,
323 PSI_mutex_key key_LOCK_commit_queue, PSI_mutex_key key_LOCK_after_commit,
324 PSI_mutex_key key_LOCK_after_commit_queue, PSI_mutex_key key_LOCK_done,
325 PSI_mutex_key key_LOCK_flush_queue, PSI_mutex_key key_LOCK_log,
326 PSI_mutex_key key_LOCK_binlog_end_pos, PSI_mutex_key key_LOCK_sync,
327 PSI_mutex_key key_LOCK_sync_queue, PSI_mutex_key key_LOCK_xids,
328 PSI_mutex_key key_LOCK_log_info,
329 PSI_mutex_key key_LOCK_wait_for_group_turn, PSI_cond_key key_COND_done,
330 PSI_cond_key key_COND_flush_queue, PSI_cond_key key_update_cond,
331 PSI_cond_key key_prep_xids_cond,
332 PSI_cond_key key_COND_wait_for_group_turn, PSI_file_key key_file_log,
333 PSI_file_key key_file_log_index, PSI_file_key key_file_log_cache,
334 PSI_file_key key_file_log_index_cache) {
335 m_key_COND_done = key_COND_done;
336 m_key_COND_flush_queue = key_COND_flush_queue;
337
338 m_key_LOCK_commit_queue = key_LOCK_commit_queue;
339 m_key_LOCK_after_commit_queue = key_LOCK_after_commit_queue;
340 m_key_LOCK_done = key_LOCK_done;
341 m_key_LOCK_flush_queue = key_LOCK_flush_queue;
342 m_key_LOCK_sync_queue = key_LOCK_sync_queue;
343
344 m_key_LOCK_log = key_LOCK_log;
345 m_key_LOCK_binlog_end_pos = key_LOCK_binlog_end_pos;
346 m_key_LOCK_commit = key_LOCK_commit;
347 m_key_LOCK_after_commit = key_LOCK_after_commit;
348 m_key_LOCK_sync = key_LOCK_sync;
349 m_key_LOCK_xids = key_LOCK_xids;
350 m_key_LOCK_log_info = key_LOCK_log_info;
351 m_key_update_cond = key_update_cond;
352 m_key_prep_xids_cond = key_prep_xids_cond;
353 m_key_file_log = key_file_log;
354 m_key_file_log_cache = key_file_log_cache;
355
356 m_binlog_index_monitor.set_psi_keys(key_LOCK_index, key_file_log_index,
357 key_file_log_index_cache);
358
359 m_key_LOCK_wait_for_group_turn = key_LOCK_wait_for_group_turn;
360 m_key_COND_wait_for_group_turn = key_COND_wait_for_group_turn;
361 }
362
363 public:
364 /** Manage the MTS dependency tracking */
366
367 /**
368 Find the oldest binary log referenced by the index file
369
370 @param[out] binlog_file_name the file name of oldest log found
371 @param[out] errmsg the error message outputted, which is left untouched
372 if the function returns false
373 @return false on success, true on error.
374 */
375 bool find_first_log(std::string &binlog_file_name, std::string &errmsg);
376
377 /**
378 Find the oldest binary log that contains any GTID that
379 is not in the given gtid set.
380
381 @param[out] binlog_file_name the file name of oldest binary log found
382 @param[in] gtid_set the given gtid set
383 @param[out] first_gtid the first GTID information from the binary log
384 file returned at binlog_file_name
385 @param[out] errmsg the error message outputted, which is left untouched
386 if the function returns false
387 @return false on success, true on error.
388 */
389 bool find_first_log_not_in_gtid_set(char *binlog_file_name,
390 const Gtid_set *gtid_set,
391 Gtid *first_gtid, std::string &errmsg);
392
393 /**
394 Reads the set of all GTIDs in the binary/relay log, and the set
395 of all lost GTIDs in the binary log, and stores each set in
396 respective argument.
397
398 @param all_gtids Will be filled with all GTIDs in this binary/relay
399 log.
400 @param lost_gtids Will be filled with all GTIDs in the
401 Previous_gtids_log_event of the first binary log that has a
402 Previous_gtids_log_event. This is requested to binary logs but not
403 to relay logs.
404 @param verify_checksum If true, checksums will be checked.
405 @param need_lock If true, LOCK_log, LOCK_index, and
406 global_tsid_lock->wrlock are acquired; otherwise they are asserted
407 to be taken already.
408 @param [out] trx_parser This will be used to return the actual
409 relaylog transaction parser state because of the possibility
410 of partial transactions.
411 @param [out] partial_trx If a transaction was left incomplete
412 on the relaylog, its GTID information should be returned to be
413 used in the case of the rest of the transaction be added to the
414 relaylog.
415 @param is_server_starting True if the server is starting.
416 @return false on success, true on error.
417 */
418 bool init_gtid_sets(
419 Gtid_set *all_gtids, Gtid_set *lost_gtids, bool verify_checksum,
420 bool need_lock,
422 Gtid_monitoring_info *partial_trx, bool is_server_starting = false);
423
424 void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param) {
425 assert(is_relay_log);
426 previous_gtid_set_relaylog = previous_gtid_set_param;
427 }
428 /**
429 If the thread owns a GTID, this function generates an empty
430 transaction and releases ownership of the GTID.
431
432 - If the binary log is disabled for this thread, the GTID is
433 inserted directly into the mysql.gtid_executed table and the
434 GTID is included in @@global.gtid_executed. (This only happens
435 for DDL, since DML will save the GTID into table and release
436 ownership inside ha_commit_trans.)
437
438 - If the binary log is enabled for this thread, an empty
439 transaction consisting of GTID, BEGIN, COMMIT is written to the
440 binary log, the GTID is included in @@global.gtid_executed, and
441 the GTID is added to the mysql.gtid_executed table on the next
442 binlog rotation.
443
444 This function must be called by any committing statement (COMMIT,
445 implicitly committing statements, or Xid_log_event), after the
446 statement has completed execution, regardless of whether the
447 statement updated the database.
448
449 This logic ensures that an empty transaction is generated for the
450 following cases:
451
452 - Explicit empty transaction:
453 SET GTID_NEXT = 'UUID:NUMBER'; BEGIN; COMMIT;
454
455 - Transaction or DDL that gets completely filtered out in the
456 slave thread.
457
458 @param thd The committing thread
459
460 @retval 0 Success
461 @retval nonzero Error
462 */
463 int gtid_end_transaction(THD *thd);
464 /**
465 Re-encrypt previous existent binary/relay logs as below.
466 Starting from the next to last entry on the index file, iterating
467 down to the first one:
468 - If the file is encrypted, re-encrypt it. Otherwise, skip it.
469 - If failed to open the file, report an error.
470
471 @retval False Success
472 @retval True Error
473 */
474 bool reencrypt_logs();
475
476 private:
477 std::atomic<enum_log_state> atomic_log_state{LOG_CLOSED};
478
479 /* The previous gtid set in relay log. */
481
482 int open(const char *opt_name) override { return open_binlog(opt_name); }
483
484 /**
485 Enter a stage of the ordered commit procedure.
486
487 Entering is stage is done by:
488
489 - Atomically entering a queue of THD objects (which is just one for
490 the first phase).
491
492 - If the queue was empty, the thread is the leader for that stage
493 and it should process the entire queue for that stage.
494
495 - If the queue was not empty, the thread is a follower and can go
496 waiting for the commit to finish.
497
498 The function will lock the stage mutex if the calling thread was designated
499 leader for the phase.
500
501 @param[in] thd Session structure
502 @param[in] stage The stage to enter
503 @param[in] queue Thread queue for the stage
504 @param[in] leave_mutex Mutex that will be released when changing stage
505 @param[in] enter_mutex Mutex that will be taken when changing stage
506
507 @retval true In case this thread did not become leader, the function
508 returns true *after* the leader has completed the commit
509 on its behalf, so the thread should continue doing the
510 thread-local processing after the commit
511 (i.e. call finish_commit).
512
513 @retval false The thread is the leader for the stage and should do
514 the processing.
515 */
517 mysql_mutex_t *leave_mutex, mysql_mutex_t *enter_mutex);
518 std::pair<int, my_off_t> flush_thread_caches(THD *thd);
519 int flush_cache_to_file(my_off_t *flush_end_pos);
520 int finish_commit(THD *thd);
521 std::pair<bool, bool> sync_binlog_file(bool force);
523 void process_after_commit_stage_queue(THD *thd, THD *first);
524
525 /**
526 Set thread variables used while flushing a transaction.
527
528 @param[in] thd thread whose variables need to be set
529 @param[in] all This is @c true if this is a real transaction commit, and
530 @c false otherwise.
531 @param[in] skip_commit
532 This is @c true if the call to @c ha_commit_low should
533 be skipped (it is handled by the caller somehow) and @c
534 false otherwise (the normal case).
535 */
536 void init_thd_variables(THD *thd, bool all, bool skip_commit);
537
538 /**
539 Fetch and empty BINLOG_FLUSH_STAGE and COMMIT_ORDER_FLUSH_STAGE flush queues
540 and flush transactions to the disk, and unblock threads executing slave
541 preserve commit order.
542
543 @param[in] check_and_skip_flush_logs
544 if false then flush prepared records of transactions to the log
545 of storage engine.
546 if true then flush prepared records of transactions to the log
547 of storage engine only if COMMIT_ORDER_FLUSH_STAGE queue is
548 non-empty.
549
550 @return Pointer to the first session of the BINLOG_FLUSH_STAGE stage queue.
551 */
553 const bool check_and_skip_flush_logs = false);
554
555 /**
556 Execute the flush stage.
557
558 @param[out] total_bytes_var Pointer to variable that will be set to total
559 number of bytes flushed, or NULL.
560
561 @param[out] out_queue_var Pointer to the sessions queue in flush stage.
562
563 @return Error code on error, zero on success
564 */
565 int process_flush_stage_queue(my_off_t *total_bytes_var, THD **out_queue_var);
566
567 /**
568 Flush and commit the transaction.
569
570 This will execute an ordered flush and commit of all outstanding
571 transactions and is the main function for the binary log group
572 commit logic. The function performs the ordered commit in four stages.
573
574 Pre-condition: transactions should have called ha_prepare_low, using
575 HA_IGNORE_DURABILITY, before entering here.
576
577 Stage#0 implements replica-preserve-commit-order for applier threads that
578 write the binary log. i.e. it forces threads to enter the queue in the
579 correct commit order.
580
581 The stage#1 flushes the caches to the binary log and under
582 LOCK_log and marks all threads that were flushed as not pending.
583
584 The stage#2 syncs the binary log for all transactions in the group.
585
586 The stage#3 executes under LOCK_commit and commits all transactions in
587 order.
588
589 There are three queues of THD objects: one for each stage.
590 The Commit_order_manager maintains it own queue and its own order for the
591 commit. So Stage#0 doesn't maintain separate StageID.
592
593 When a transaction enters a stage, it adds itself to a queue. If the queue
594 was empty so that this becomes the first transaction in the queue, the
595 thread is the *leader* of the queue. Otherwise it is a *follower*. The
596 leader will do all work for all threads in the queue, and the followers
597 will wait until the last stage is finished.
598
599 Stage 0 (SLAVE COMMIT ORDER):
600 1. If replica-preserve-commit-order and is slave applier worker thread, then
601 waits until its turn to commit i.e. till it is on the top of the queue.
602 2. When it reaches top of the queue, it signals next worker in the commit
603 order queue to awake.
604
605 Stage 1 (FLUSH):
606 1. Sync the engines (ha_flush_logs), since they prepared using non-durable
607 settings (HA_IGNORE_DURABILITY).
608 2. Generate GTIDs for all transactions in the queue.
609 3. Write the session caches for all transactions in the queue to the binary
610 log.
611 4. Increment the counter of prepared XIDs.
612
613 Stage 2 (SYNC):
614 1. If it is time to sync, based on the sync_binlog option, sync the binlog.
615 2. If sync_binlog==1, signal dump threads that they can read up to the
616 position after the last transaction in the queue
617
618 Stage 3 (COMMIT):
619 This is performed by each thread separately, if binlog_order_commits=0.
620 Otherwise by the leader does it for all threads.
621 1. Call the after_sync hook.
622 2. update the max_committed counter in the dependency_tracker
623 3. call ha_commit_low
624 4. Call the after_commit hook
625 5. Update gtids
626 6. Decrement the counter of prepared transactions
627
628 If the binary log needs to be rotated, it is done after this. During
629 rotation, it takes a lock that prevents new commit groups from executing the
630 flush stage, and waits until the counter of prepared transactions becomes 0,
631 before it creates the new file.
632
633 @param[in] thd Session to commit transaction for
634 @param[in] all This is @c true if this is a real transaction commit, and
635 @c false otherwise.
636 @param[in] skip_commit
637 This is @c true if the call to @c ha_commit_low should
638 be skipped and @c false otherwise (the normal case).
639 */
640 int ordered_commit(THD *thd, bool all, bool skip_commit = false);
641 void handle_binlog_flush_or_sync_error(THD *thd, bool need_lock_log,
642 const char *message);
644 class Binlog_event_writer *writer);
646
647 public:
648 int open_binlog(const char *opt_name);
649 void close() override;
650 enum_result commit(THD *thd, bool all) override;
651 int rollback(THD *thd, bool all) override;
652 bool truncate_relaylog_file(Master_info *mi, my_off_t valid_pos);
653 int prepare(THD *thd, bool all) override;
654#if defined(MYSQL_SERVER)
655
658 bool is_transactional);
659
660#endif /* defined(MYSQL_SERVER) */
663 /// @brief Adds bytes written in the current relay log into the variable
664 /// handling the total number of bytes acquired by the replica. Resets the
665 /// counter of bytes written. If requested by caller,
666 /// acquires relay log space lock
667 /// @param rli Pointer to the applier metadata object
668 /// @param need_log_space_lock Information on whether to acquire the
669 /// lock protecting data responsible for keeping the relay log space at bay
670 void harvest_bytes_written(Relay_log_info *rli, bool need_log_space_lock);
671 void set_max_size(ulong max_size_arg);
672
673 void update_binlog_end_pos(bool need_lock = true);
674 void update_binlog_end_pos(const char *file, my_off_t pos);
675
676 /**
677 Wait until we get a signal that the binary log has been updated.
678
679 NOTES
680 @param[in] timeout a pointer to a timespec;
681 NULL means to wait w/o timeout.
682 @retval 0 if got signalled on update
683 @retval non-0 if wait timeout elapsed
684 @note
685 LOCK_binlog_end_pos must be owned before calling this function, may be
686 temporarily released while the thread is waiting and is reacquired before
687 returning from the function
688 */
689 int wait_for_update(const std::chrono::nanoseconds &timeout);
690
691 /**
692 Wait until we get a signal that the binary log has been updated.
693 @retval 0 success
694 @note
695 LOCK_binlog_end_pos must be owned before calling this function, may be
696 temporarily released while the thread is waiting and is reacquired before
697 returning from the function
698 */
699 int wait_for_update();
700
701 public:
703 void cleanup();
704 /**
705 Create a new binary log.
706 @param log_name Name of binlog
707 @param new_name Name of binlog, too. todo: what's the difference
708 between new_name and log_name?
709 @param max_size_arg The size at which this binlog will be rotated.
710 @param null_created_arg If false, and a Format_description_log_event
711 is written, then the Format_description_log_event will have the
712 timestamp 0. Otherwise, it the timestamp will be the time when the
713 event was written to the log.
714 @param need_lock_index If true, LOCK_index is acquired; otherwise
715 LOCK_index must be taken by the caller.
716 @param need_tsid_lock If true, the read lock on global_tsid_lock
717 will be acquired. Otherwise, the caller must hold the read lock
718 on global_tsid_lock.
719 @param extra_description_event The master's FDE to be written by the I/O
720 thread while creating a new relay log file. This should be NULL for
721 binary log files.
722 @param new_index_number The binary log file index number to start from
723 after the RESET BINARY LOGS AND GTIDS command is called.
724 */
725 bool open_binlog(const char *log_name, const char *new_name,
726 ulong max_size_arg, bool null_created_arg,
727 bool need_lock_index, bool need_tsid_lock,
728 Format_description_log_event *extra_description_event,
729 uint32 new_index_number = 0);
730 bool open_index_file(const char *index_file_name_arg, const char *log_name,
731 bool need_lock_index);
732 /* Use this to start writing a new log file */
733 int new_file(Format_description_log_event *extra_description_event);
734
735 bool write_event(Log_event *event_info);
736 bool write_cache(THD *thd, class binlog_cache_data *cache_data,
737 class Binlog_event_writer *writer);
738 /**
739 Assign automatic generated GTIDs for all commit group threads in the flush
740 stage having gtid_next.type == AUTOMATIC_GTID.
741
742 @param first_seen The first thread seen entering the flush stage.
743 @return Returns false if succeeds, otherwise true is returned.
744 */
746 bool write_transaction(THD *thd, binlog_cache_data *cache_data,
747 Binlog_event_writer *writer,
748 bool parallelization_barrier);
749
750 /**
751 Write a dml into statement cache and then flush it into binlog. It writes
752 Gtid_log_event and BEGIN, COMMIT automatically.
753
754 It is aimed to handle cases of "background" logging where a statement is
755 logged indirectly, like "TRUNCATE TABLE a_memory_table". So don't use it on
756 any normal statement.
757
758 @param[in] thd the THD object of current thread.
759 @param[in] stmt the DML statement.
760 @param[in] stmt_len the length of the DML statement.
761 @param[in] sql_command the type of SQL command.
762
763 @return Returns false if succeeds, otherwise true is returned.
764 */
765 bool write_stmt_directly(THD *thd, const char *stmt, size_t stmt_len,
766 enum enum_sql_command sql_command);
767
768 void report_cache_write_error(THD *thd, bool is_transactional);
769 bool check_write_error(const THD *thd);
772 void start_union_events(THD *thd, query_id_t query_id_param);
773 void stop_union_events(THD *thd);
774 bool is_query_in_union(THD *thd, query_id_t query_id_param);
775
776 bool write_buffer(const char *buf, uint len, Master_info *mi);
777 bool write_event(Log_event *ev, Master_info *mi);
778
779 /**
780 Logging XA commit/rollback of a prepared transaction.
781
782 It fills in the appropriate event in the statement cache whenever xid
783 state is marked with is_binlogged() flag that indicates the prepared
784 part of the transaction must've been logged.
785
786 About early returns from the function:
787 - ONE_PHASE option to XA-COMMIT is handled to skip writing XA-commit
788 event now.
789 - check is for the read-only XA that is not to be logged.
790
791 @param thd THD handle
792 @return error code, 0 success
793 */
794 int write_xa_to_cache(THD *thd);
795
796 ///
797 /// Write an incident and call commit.
798 ///
799 /// The incident is written by marking the transaction cache as having an
800 /// incident and then commit it to binlog. During commit, the flush stage will
801 /// write and Incident_log_event and preceding Gtid_log_event to give the
802 /// incident a proper GTID. The incident will also cause the binlog to be
803 /// rotated and check if some purge is applicable.
804 ///
805 /// @param[in] thd the THD object of current thread.
806 /// @param[in] incident_message A message describing the incident.
807 ///
808 /// @return Returns false if succeeds, otherwise true is returned.
809 ///
810 bool write_incident_commit(THD *thd, std::string_view incident_message);
811
812 private:
814
815 public:
816 /**
817 * Truncte log file and clear LOG_EVENT_BINLOG_IN_USE_F when update is set.
818 * @param[in] log_name name of the log file to be trunacted
819 * @param[in] valid_pos position at which to truncate the log file
820 * @param[in] binlog_size length of the log file before truncated
821 * @param[in] update should the LOG_EVENT_BINLOG_IN_USE_F flag be cleared
822 * true - set LOG_EVENT_BINLOG_IN_USE_F to 0
823 * false - do not modify LOG_EVENT_BINLOG_IN_USE_F flag
824 * @return true - sucess, false - failed
825 */
826 bool truncate_update_log_file(const char *log_name, my_off_t valid_pos,
827 my_off_t binlog_size, bool update);
828
829 void make_log_name(char *buf, const char *log_ident);
830 bool is_active(const char *log_file_name) const;
831
832 /** @see Binlog_index_monitor::remove_logs_outside_range_from_index */
833 int remove_logs_outside_range_from_index(const std::string &first,
834 const std::string &last);
835 int rotate(bool force_rotate, bool *check_purge);
836
837 /**
838 @brief This function runs automatic purge if the conditions to meet
839 automatic purge are met. Such conditions are: log is open, instance is not
840 locked for backup and automatic purge is enabled.
841
842 If all conditions are met, purge is done according to the configuration
843 of the purge window.
844 */
845 void auto_purge();
846
847 /**
848 @brief This member function is to be called at server startup. It checks if
849 purge can be done and does if it can.
850 */
852 int rotate_and_purge(THD *thd, bool force_rotate);
853
854 bool flush();
855 /**
856 Flush binlog cache and synchronize to disk.
857
858 This function flushes events in binlog cache to binary log file,
859 it will do synchronizing according to the setting of system
860 variable 'sync_binlog'. If file is synchronized, @c synced will
861 be set to 1, otherwise 0.
862
863 @param[in] force if true, ignores the 'sync_binlog' and synchronizes the
864 file.
865
866 @retval 0 Success
867 @retval other Failure
868 */
869 bool flush_and_sync(const bool force = false);
870 int purge_logs(const char *to_log, bool included, bool need_lock_index,
871 bool need_update_threads, ulonglong *decrease_log_space,
872 bool auto_purge);
873 int purge_logs_before_date(time_t purge_time, bool auto_purge);
874 int purge_index_entry(THD *thd, ulonglong *decrease_log_space,
875 bool need_lock_index);
876 bool reset_logs(THD *thd, bool delete_only = false);
877 void close(uint exiting, bool need_lock_log, bool need_lock_index);
878
879 // iterating through the log index file
880 int find_log_pos(Log_info *linfo, const char *log_name, bool need_lock_index);
881 int find_next_log(Log_info *linfo, bool need_lock_index);
882 int find_next_relay_log(char log_name[FN_REFLEN + 1]);
883 int get_current_log(Log_info *linfo, bool need_lock_log = true);
884 int raw_get_current_log(Log_info *linfo);
885 uint next_file_id();
886 /** @see Binlog_index_monitor::get_log_index */
887 std::pair<int, std::list<std::string>> get_log_index(
888 bool need_lock_index = true);
889 inline const char *get_index_fname() {
891 }
892 inline char *get_log_fname() { return log_file_name; }
893 const char *get_name() const { return name; }
894 inline mysql_mutex_t *get_log_lock() { return &LOCK_log; }
897 inline mysql_cond_t *get_log_cond() { return &update_cond; }
899
902 }
907 }
908
909 /**
910 Function to report the missing GTIDs.
911
912 This function logs the missing transactions on master to its error log
913 as a warning. If the missing GTIDs are too long to print in a message,
914 it suggests the steps to extract the missing transactions.
915
916 This function also informs slave about the GTID set sent by the slave,
917 transactions missing on the master and few suggestions to recover from
918 the error. This message shall be wrapped by
919 ER_SOURCE_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
920 error.
921
922 This function will be called from mysql_binlog_send() function.
923
924 @param slave_executed_gtid_set GTID set executed by slave
925 @param errmsg Pointer to the error message
926 */
927 void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set,
928 std::string &errmsg);
929
930 /**
931 Function to report the missing GTIDs.
932
933 This function logs the missing transactions on master to its error log
934 as a warning. If the missing GTIDs are too long to print in a message,
935 it suggests the steps to extract the missing transactions.
936
937 This function also informs slave about the GTID set sent by the slave,
938 transactions missing on the master and few suggestions to recover from
939 the error. This message shall be wrapped by
940 ER_SOURCE_FATAL_ERROR_READING_BINLOG on slave and will be logged as an
941 error.
942
943 This function will be called from find_first_log_not_in_gtid_set()
944 function.
945
946 @param previous_gtid_set Previous GTID set found
947 @param slave_executed_gtid_set GTID set executed by slave
948 @param errmsg Pointer to the error message
949 */
950 void report_missing_gtids(const Gtid_set *previous_gtid_set,
951 const Gtid_set *slave_executed_gtid_set,
952 std::string &errmsg);
953 /*
954 It is called by the threads (e.g. dump thread, applier thread) which want
955 to read hot log without LOCK_log protection.
956 */
960 }
964
965 /**
966 Deep copy global_tsid_map and gtid_executed.
967 Both operations are done under LOCK_commit and global_tsid_lock
968 protection.
969
970 @param[out] tsid_map The Tsid_map to which global_tsid_map will
971 be copied.
972 @param[out] gtid_set The Gtid_set to which gtid_executed will
973 be copied.
974
975 @return the operation status
976 @retval 0 OK
977 @retval !=0 Error
978 */
979 int get_gtid_executed(Tsid_map *tsid_map, Gtid_set *gtid_set);
980
981 public:
982 /**
983 Register Log_info so that log_in_use and adjust_linfo_offsets can
984 operate on all logs. Note that register_log_info, unregister_log_info,
985 log_in_use, adjust_linfo_offsets are is used on global mysql_bin_log object.
986 @param log_info pointer to Log_info which is registred
987 */
989 /**
990 Unregister Log_info when it is no longer needed.
991 @param log_info pointer to Log_info which is registred
992 */
994 /**
995 Check if any threads use log name.
996 @note This method expects the LOCK_index to be taken so there are no
997 concurrent edits against linfo objects being iterated
998 @param log_name name of a log which is checked for usage
999
1000 */
1001 int log_in_use(const char *log_name);
1002 /**
1003 Adjust the position pointer in the binary log file for all running replicas.
1004 SYNOPSIS
1005 adjust_linfo_offsets()
1006 purge_offset Number of bytes removed from start of log index file
1007 NOTES
1008 - This is called when doing a PURGE when we delete lines from the
1009 index log file. This method expects the LOCK_index to be taken so there
1010 are no concurrent edits against linfo objects being iterated. REQUIREMENTS
1011 - Before calling this function, we have to ensure that no threads are
1012 using any binary log file before purge_offset.
1013 TODO
1014 - Inform the replica threads that they should sync the position
1015 in the binary log file with flush_relay_log_info.
1016 Now they sync is done for next read.
1017 */
1018 void adjust_linfo_offsets(my_off_t purge_offset);
1019
1020 private:
1022};
1023
1028};
1029
1031
1032/**
1033 Check if the the transaction is empty.
1034
1035 @param thd The client thread that executed the current statement.
1036
1037 @retval true No changes found in any storage engine
1038 @retval false Otherwise.
1039
1040**/
1041bool is_transaction_empty(THD *thd);
1042/**
1043 Check if the transaction has no rw flag set for any of the storage engines.
1044
1045 @param thd The client thread that executed the current statement.
1046 @param trx_scope The transaction scope to look into.
1047
1048 @retval the number of engines which have actual changes.
1049 */
1051
1052/**
1053 Check if at least one of transacaction and statement binlog caches contains
1054 an empty transaction, other one is empty or contains an empty transaction,
1055 which has two binlog events "BEGIN" and "COMMIT".
1056
1057 @param thd The client thread that executed the current statement.
1058
1059 @retval true At least one of transacaction and statement binlog caches
1060 contains an empty transaction, other one is empty or
1061 contains an empty transaction.
1062 @retval false Otherwise.
1063*/
1065bool trans_has_updated_trans_table(const THD *thd);
1067bool ending_trans(THD *thd, const bool all);
1068bool ending_single_stmt_trans(THD *thd, const bool all);
1069bool trans_cannot_safely_rollback(const THD *thd);
1070bool stmt_cannot_safely_rollback(const THD *thd);
1071
1073
1074/**
1075 @brief Purges the binary log files up to the file name passed as
1076 a paramenter. Purge will not delete the file passed as
1077 an argument.
1078
1079 @param thd The session context.
1080 @param to_log Up to which log file to purge.
1081 @return true if there was an error.
1082 @return false if there was no error.
1083 */
1084bool purge_source_logs_to_file(THD *thd, const char *to_log);
1085
1086bool purge_source_logs_before_date(THD *thd, time_t purge_time);
1088bool mysql_show_binlog_events(THD *thd);
1089void check_binlog_cache_size(THD *thd);
1091bool binlog_enabled();
1092int query_error_code(const THD *thd, bool not_killed);
1093
1094extern const char *log_bin_index;
1095extern const char *log_bin_basename;
1096extern bool opt_binlog_order_commits;
1097extern ulong rpl_read_size;
1098
1099#endif /* BINLOG_H_INCLUDED */
int64 query_id_t
Definition: binlog.h:72
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:295
Byte container that provides a storage for serializing session binlog events.
Definition: binlog_ostream.h:174
Auxiliary class to copy serialized events to the binary log and correct some of the fields that are n...
Definition: binlog.cc:1359
Binlog_index_monitor synchronizes access to Binlog_index object.
Definition: binlog_index.h:343
void lock()
Definition: binlog_index.h:554
IO_CACHE * get_index_file()
Definition: binlog_index.h:521
const char * get_index_fname() const
Definition: binlog_index.cc:1095
void unlock()
Definition: binlog_index.h:555
mysql_mutex_t * get_index_lock()
Definition: binlog_index.h:553
void set_psi_keys(PSI_mutex_key key_LOCK_index, PSI_file_key key_file_log_index, PSI_file_key key_file_log_index_cache)
Definition: binlog_index.cc:773
StageID
Constants for queues for different stages.
Definition: rpl_commit_stage_manager.h:166
For binlog version 4.
Definition: log_event.h:1536
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1413
Represents a set of GTIDs.
Definition: rpl_gtid.h:1557
Container to hold and allow iteration over a set of Ha_trx_info objects.
Definition: transaction_info.h:514
Either statement transaction or normal transaction - related thread-specific storage engine data.
Definition: transaction_info.h:414
This is the abstract base class for binary log events.
Definition: log_event.h:538
Logical binlog file which wraps and hides the detail of lower layer storage implementation.
Definition: binlog.cc:324
Definition: binlog.h:107
mysql_mutex_t * get_binlog_end_pos_lock()
Definition: binlog.h:961
const char * get_name() const
Definition: binlog.h:893
mysql_cond_t m_prep_xids_cond
Definition: binlog.h:201
mysql_mutex_t * get_commit_lock()
Definition: binlog.h:895
mysql_mutex_t LOCK_binlog_end_pos
Definition: binlog.h:169
std::atomic< my_off_t > atomic_binlog_end_pos
Definition: binlog.h:173
void unlock_binlog_end_pos()
Definition: binlog.h:963
PSI_mutex_key m_key_LOCK_xids
The instrumentation key to use for @ LOCK_xids.
Definition: binlog.h:151
mysql_mutex_t LOCK_commit
Definition: binlog.h:166
char db[NAME_LEN+1]
Definition: binlog.h:118
void set_previous_gtid_set_relaylog(Gtid_set *previous_gtid_set_param)
Definition: binlog.h:424
void reset_bytes_written()
Definition: binlog.h:662
void lock_binlog_end_pos()
Definition: binlog.h:962
enum_log_state
Definition: binlog.h:112
@ LOG_OPENED
Definition: binlog.h:112
@ LOG_CLOSED
Definition: binlog.h:112
@ LOG_TO_BE_OPENED
Definition: binlog.h:112
PSI_mutex_key m_key_COND_done
The PFS instrumentation key for @ COND_done.
Definition: binlog.h:141
mysql_mutex_t LOCK_sync
Definition: binlog.h:168
PSI_mutex_key m_key_LOCK_after_commit
The instrumentation key to use for @ LOCK_after_commit.
Definition: binlog.h:147
PSI_mutex_key m_key_LOCK_commit_queue
The PFS instrumentation key for @ LOCK_commit_queue.
Definition: binlog.h:129
const char * get_index_fname()
Definition: binlog.h:889
mysql_mutex_t LOCK_after_commit
Definition: binlog.h:167
Binlog_ofile * get_binlog_file()
Definition: binlog.h:898
mysql_mutex_t LOCK_log_info
Definition: binlog.h:1021
int open(const char *opt_name) override
Initialize and open the coordinator log.
Definition: binlog.h:482
mysql_mutex_t * get_log_lock()
Definition: binlog.h:894
bool is_open() const
Definition: binlog.h:274
PSI_cond_key m_key_prep_xids_cond
The instrumentation key to use for @ prep_xids_cond.
Definition: binlog.h:157
my_off_t get_binlog_end_pos() const
Definition: binlog.h:957
void lock_index()
Definition: binlog.h:903
PSI_mutex_key m_key_LOCK_flush_queue
The PFS instrumentation key for @ LOCK_flush_queue.
Definition: binlog.h:135
PSI_mutex_key m_key_LOCK_after_commit_queue
The PFS instrumentation key for @ LOCK_after_commit_queue.
Definition: binlog.h:131
int32 get_prep_xids()
Definition: binlog.h:216
std::atomic< enum_log_state > atomic_log_state
Definition: binlog.h:477
Gtid_set * previous_gtid_set_relaylog
Definition: binlog.h:480
PSI_cond_key m_key_update_cond
The instrumentation key to use for @ update_cond.
Definition: binlog.h:155
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:321
bool write_error
Definition: binlog.h:119
uint * sync_period_ptr
Definition: binlog.h:198
mysql_mutex_t * get_after_commit_lock()
Definition: binlog.h:896
PSI_mutex_key m_key_LOCK_done
The PFS instrumentation key for @ LOCK_done.
Definition: binlog.h:133
Binlog_index_monitor m_binlog_index_monitor
Concurrent access to binlog index file.
Definition: binlog.h:177
std::atomic< int32 > m_atomic_prep_xids
Definition: binlog.h:202
Binlog_ofile * m_binlog_file
Definition: binlog.h:120
PSI_mutex_key m_key_LOCK_sync
The instrumentation key to use for @ LOCK_sync.
Definition: binlog.h:149
void add_bytes_written(ulonglong inc)
Definition: binlog.h:661
bool inited
Definition: binlog.h:119
mysql_mutex_t * get_index_lock()
Definition: binlog.h:900
PSI_mutex_key m_key_LOCK_binlog_end_pos
The instrumentation key to use for @ LOCK_binlog_end_pos.
Definition: binlog.h:127
IO_CACHE * get_index_file()
Definition: binlog.h:905
mysql_cond_t * get_log_cond()
Definition: binlog.h:897
mysql_mutex_t LOCK_log
Definition: binlog.h:115
ulong max_size
Definition: binlog.h:189
bool is_relay_log
Definition: binlog.h:280
uint get_sync_period()
Definition: binlog.h:218
PSI_cond_key m_key_COND_wait_for_group_turn
The PFS instrumentation key for @ COND_wait_for_group_turn.
Definition: binlog.h:159
PSI_mutex_key m_key_LOCK_log
The instrumentation key to use for @ LOCK_log.
Definition: binlog.h:125
PSI_mutex_key m_key_COND_flush_queue
The PFS instrumentation key for @ COND_flush_queue.
Definition: binlog.h:143
uint file_id
Definition: binlog.h:192
ulonglong bytes_written
Definition: binlog.h:174
mysql_cond_t update_cond
Definition: binlog.h:171
PSI_mutex_key m_key_LOCK_commit
The instrumentation key to use for @ LOCK_commit.
Definition: binlog.h:145
PSI_mutex_key m_key_LOCK_wait_for_group_turn
The PFS instrumentation key for @ LOCK_wait_for_group_turn.
Definition: binlog.h:139
void unlock_index()
Definition: binlog.h:904
PSI_file_key m_key_file_log
The instrumentation key to use for opening the log file.
Definition: binlog.h:161
PSI_mutex_key m_key_LOCK_sync_queue
The PFS instrumentation key for @ LOCK_sync_queue.
Definition: binlog.h:137
char * get_log_fname()
Definition: binlog.h:892
mysql::binlog::event::enum_binlog_checksum_alg relay_log_checksum_alg
Definition: binlog.h:316
Transaction_dependency_tracker m_dependency_tracker
Manage the MTS dependency tracking.
Definition: binlog.h:365
mysql_mutex_t LOCK_xids
Definition: binlog.h:170
PSI_file_key m_key_file_log_cache
The instrumentation key to use for opening a log cache file.
Definition: binlog.h:163
uint sync_counter
Definition: binlog.h:199
PSI_file_key m_log_file_key
Instrumentation key to use for file io in log_file.
Definition: binlog.h:123
char * name
Definition: binlog.h:116
char log_file_name[FN_REFLEN]
Definition: binlog.h:117
uint8 checksum_alg_reset
Definition: binlog.h:282
PSI_mutex_key m_key_LOCK_log_info
The instrumentation key to use for @ m_key_LOCK_log_info.
Definition: binlog.h:153
Definition: rpl_mi.h:87
Definition: rpl_rli.h:206
Common base class for all row-containing log events.
Definition: log_event.h:2785
Transaction Coordinator Log.
Definition: tc_log.h:144
enum_result
Definition: tc_log.h:160
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
enum_trx_scope
Definition: transaction_info.h:57
Dependency tracker is a container singleton that dispatches between the three methods associated with...
Definition: rpl_trx_tracking.h:186
Represents a bidirectional map between TSID and SIDNO.
Definition: rpl_gtid.h:750
Caches for non-transactional and transactional data before writing it to the binary log.
Definition: binlog.cc:645
This is the base class for verifying transaction boundaries.
Definition: trx_boundary_parser.h:50
Error representation used internally in case final error code is unknown and error situation handling...
Definition: error.h:45
Definition: item_func.h:3096
#define mysql_mutex_lock(M)
Definition: mysql_mutex.h:50
#define mysql_mutex_unlock(M)
Definition: mysql_mutex.h:57
void harvest_bytes_written(Relay_log_info *rli, bool need_log_space_lock)
Adds bytes written in the current relay log into the variable handling the total number of bytes acqu...
Definition: binlog.cc:6799
bool mysql_show_binlog_events(THD *thd)
Execute a SHOW BINLOG EVENTS statement.
Definition: binlog.cc:3474
bool stmt_cannot_safely_rollback(const THD *thd)
This function checks if current statement cannot be rollded back safely.
Definition: binlog.cc:3200
int write_xa_to_cache(THD *thd)
Logging XA commit/rollback of a prepared transaction.
Definition: binlog.cc:2528
std::pair< int, std::list< std::string > > get_log_index(bool need_lock_index=true)
Definition: binlog.cc:5097
int raw_get_current_log(Log_info *linfo)
Definition: binlog.cc:5037
std::pair< std::list< std::string >, mysql::utils::Error > get_filename_list()
Definition: binlog.cc:1899
void set_max_size(ulong max_size_arg)
Definition: binlog.cc:6818
ulong rpl_read_size
Definition: binlog.cc:188
int flush_cache_to_file(my_off_t *flush_end_pos)
Flush the I/O cache to file.
Definition: binlog.cc:7661
void report_cache_write_error(THD *thd, bool is_transactional)
Definition: binlog.cc:5064
bool is_transaction_empty(THD *thd)
Check if the the transaction is empty.
Definition: binlog.cc:3091
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:3311
bool trans_cannot_safely_rollback(const THD *thd)
This function checks if a transaction cannot be rolled back safely.
Definition: binlog.cc:3187
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:7431
int rotate(bool force_rotate, bool *check_purge)
The method executes rotation when LOCK_log is already acquired by the caller.
Definition: binlog.cc:6334
void update_thd_next_event_pos(THD *thd)
Definition: binlog.cc:6114
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:3129
void close() override
This is called on shutdown, after ha_panic.
Definition: binlog.cc:7025
int new_file_without_locking(Format_description_log_event *extra_description_event)
Definition: binlog.cc:5644
void report_missing_purged_gtids(const Gtid_set *slave_executed_gtid_set, std::string &errmsg)
Function to report the missing GTIDs.
Definition: binlog.cc:8180
uint next_file_id()
Definition: binlog.cc:6456
void cleanup()
Definition: binlog.cc:3522
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:6532
int rollback(THD *thd, bool all) override
Write a rollback record of the transaction to the binary log.
Definition: binlog.cc:2655
int remove_logs_outside_range_from_index(const std::string &first, const std::string &last)
Definition: binlog.cc:5282
void init_pthread_objects()
Definition: binlog.cc:3547
int get_current_log(Log_info *linfo, bool need_lock_log=true)
Definition: binlog.cc:5029
bool reencrypt_logs()
Re-encrypt previous existent binary/relay logs as below.
Definition: binlog.cc:1903
int log_in_use(const char *log_name)
Check if any threads use log name.
Definition: binlog.cc:6499
const char * log_bin_index
Definition: binlog.cc:184
int open_binlog(const char *opt_name)
Definition: binlog.cc:6864
~MYSQL_BIN_LOG() override
Definition: binlog.cc:3518
bool binlog_enabled()
Check whether binlog_hton has valid slot and enabled.
Definition: binlog.cc:1311
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:3110
int get_gtid_executed(Tsid_map *tsid_map, Gtid_set *gtid_set)
Deep copy global_tsid_map and gtid_executed.
Definition: binlog.cc:6464
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:1777
void process_commit_stage_queue(THD *thd, THD *queue)
Commit a sequence of sessions.
Definition: binlog.cc:7529
void wait_for_prep_xids()
Wait until the number of prepared XIDs are zero.
Definition: binlog.cc:5614
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:3777
bool write_buffer(const char *buf, uint len, Master_info *mi)
Definition: binlog.cc:6055
const char * log_bin_basename
Definition: binlog.cc:185
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:5312
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:5996
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:6986
int find_log_pos(Log_info *linfo, const char *log_name, bool need_lock_index)
Definition: binlog.cc:5084
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:1272
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:2951
bool write_event_to_binlog_and_sync(Log_event *ev)
Definition: binlog.cc:6603
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:6834
bool is_active(const char *log_file_name) const
Check if we are writing/reading to the given log file.
Definition: binlog.cc:5587
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:1292
std::pair< bool, bool > sync_binlog_file(bool force)
Call fsync() to sync the file to disk.
Definition: binlog.cc:7674
int find_next_relay_log(char log_name[FN_REFLEN+1])
Definition: binlog.cc:5093
int generate_new_name(char *new_name, const char *log_name, uint32 new_index_number=0)
Definition: binlog.cc:3711
int flush_and_set_pending_rows_event(THD *thd, Rows_log_event *event, bool is_transactional)
Definition: binlog.cc:6130
int finish_commit(THD *thd)
Helper function executed when leaving ordered_commit.
Definition: binlog.cc:7717
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:6558
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:3176
void unregister_log_info(Log_info *log_info)
Unregister Log_info when it is no longer needed.
Definition: binlog.cc:6493
enum_result commit(THD *thd, bool all) override
Commit the transaction in the transaction coordinator.
Definition: binlog.cc:7090
bool check_write_error(const THD *thd)
Definition: binlog.cc:5045
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:3215
int process_flush_stage_queue(my_off_t *total_bytes_var, THD **out_queue_var)
Execute the flush stage.
Definition: binlog.cc:7473
int wait_for_update()
Wait until we get a signal that the binary log has been updated.
Definition: binlog.cc:6690
void make_log_name(char *buf, const char *log_ident)
Create a new log file name.
Definition: binlog.cc:5576
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:7630
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:4343
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:6640
bool write_event(Log_event *event_info)
Write an event to the binary log cache.
Definition: binlog.cc:6171
void update_binlog_end_pos(bool need_lock=true)
Definition: binlog.cc:8311
int rotate_and_purge(THD *thd, bool force_rotate)
Execute a FLUSH LOGS statement.
Definition: binlog.cc:6424
bool is_query_in_union(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6105
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:5664
bool write_event_to_binlog(Log_event *ev)
Definition: binlog.cc:6582
bool reset_logs(THD *thd, bool delete_only=false)
Removes files, as part of a RESET BINARY LOGS AND GTIDS or RESET REPLICA statement,...
Definition: binlog.cc:5121
bool purge_source_logs_before_date(THD *thd, time_t purge_time)
Execute a PURGE BINARY LOGS BEFORE <date> command.
Definition: binlog.cc:3255
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:3143
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:3161
int query_error_code(const THD *thd, bool not_killed)
Definition: binlog.cc:3283
void process_after_commit_stage_queue(THD *thd, THD *first)
Process after commit for a sequence of sessions.
Definition: binlog.cc:7602
std::pair< int, my_off_t > flush_thread_caches(THD *thd)
Flush caches for session.
Definition: binlog.cc:7379
bool write_transaction(THD *thd, binlog_cache_data *cache_data, Binlog_event_writer *writer, bool parallelization_barrier)
Write the Gtid_log_event to the binary log (prior to writing the statement or transaction cache).
Definition: binlog.cc:1619
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:8244
int purge_index_entry(THD *thd, ulonglong *decrease_log_space, bool need_lock_index)
Definition: binlog.cc:5435
bool init_and_set_log_file_name(const char *log_name, const char *new_name, uint32 new_index_number)
Definition: binlog.cc:3751
const char * generate_name(const char *log_name, const char *suffix, char *buff)
Definition: binlog.cc:3732
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:5460
bool opt_binlog_order_commits
Definition: binlog.cc:182
void init_thd_variables(THD *thd, bool all, bool skip_commit)
Set thread variables used while flushing a transaction.
Definition: binlog.cc:7396
int find_next_log(Log_info *linfo, bool need_lock_index)
Definition: binlog.cc:5089
void start_union_events(THD *thd, query_id_t query_id_param)
Definition: binlog.cc:6092
bool init_gtid_sets(Gtid_set *all_gtids, Gtid_set *lost_gtids, bool verify_checksum, bool need_lock, mysql::binlog::event::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:4456
bool open_index_file(const char *index_file_name_arg, const char *log_name, bool need_lock_index)
Definition: binlog.cc:3830
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:1554
void auto_purge()
This function runs automatic purge if the conditions to meet automatic purge are met.
Definition: binlog.cc:6364
int prepare(THD *thd, bool all) override
Log a prepare record of the transaction to the storage engines.
Definition: binlog.cc:7037
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:6487
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:7821
int ordered_commit(THD *thd, bool all, bool skip_commit=false)
Flush and commit the transaction.
Definition: binlog.cc:7869
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:6509
MYSQL_BIN_LOG(uint *sync_period, bool relay_log=false)
Definition: binlog.cc:3495
bool flush_and_sync(const bool force=false)
Flush binlog cache and synchronize to disk.
Definition: binlog.cc:6082
int new_file(Format_description_log_event *extra_description_event)
Definition: binlog.cc:5635
bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log)
Definition: binlog.cc:3346
void inc_prep_xids(THD *thd)
Increment the prepared XID counter.
Definition: binlog.cc:5591
void dec_prep_xids(THD *thd)
Decrement the prepared XID counter.
Definition: binlog.cc:5602
void stop_union_events(THD *thd)
Definition: binlog.cc:6100
bool flush()
Definition: binlog.cc:6078
void signal_update()
Notifies waiting threads that binary log has been updated.
Definition: binlog.cc:8303
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:3098
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:4358
void report_binlog_write_error()
Definition: binlog.cc:6682
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:5900
void auto_purge_at_server_startup()
This member function is to be called at server startup.
Definition: binlog.cc:6352
bool write_incident_commit(THD *thd, std::string_view incident_message)
Write an incident and call commit.
Definition: binlog.cc:2556
#define log_info(...)
Definition: log_client.h:153
unsigned int PSI_cond_key
Instrumented cond key.
Definition: psi_cond_bits.h:44
unsigned int PSI_file_key
Instrumented file key.
Definition: psi_file_bits.h:48
unsigned int PSI_mutex_key
Instrumented mutex key.
Definition: psi_mutex_bits.h:52
#define mysql_mutex_assert_not_owner(M)
Wrapper, to use safe_mutex_assert_not_owner with instrumented mutexes.
Definition: mysql_mutex.h:126
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
uint8_t uint8
Definition: my_inttypes.h:63
ulonglong my_off_t
Definition: my_inttypes.h:72
int64_t int64
Definition: my_inttypes.h:68
int32_t int32
Definition: my_inttypes.h:66
uint32_t uint32
Definition: my_inttypes.h:67
Common #defines and includes for file and socket I/O.
#define FN_REFLEN
Definition: my_io.h:87
Functions related to handling of plugins and other dynamically loaded libraries.
#define MYSQL_PLUGIN_IMPORT
Definition: my_sharedlib.h:71
enum_sql_command
Definition: my_sqlcommand.h:46
Common header for many mysys elements.
static int not_killed
Definition: myisamchk.cc:1619
static uint update
Definition: myisamlog.cc:94
static QUEUE queue
Definition: myisampack.cc:210
Common definition between mysql server & client.
#define NAME_LEN
Definition: mysql_com.h:67
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:293
Definition: base.h:75
Definition: buf0block_hint.cc:30
const std::string opt_name("mysql_option_tracker_option")
Definition: os0file.h:89
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:498
enum_binlog_checksum_alg
Enumeration spcifying checksum algorithm used to encode a binary log event.
Definition: binlog_event.h:454
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:32
Definition: binlog.h:89
Item_result type
Definition: binlog.h:93
ulong length
Definition: binlog.h:92
char * value
Definition: binlog.h:91
bool unsigned_flag
Definition: binlog.h:95
user_var_entry * user_var_event
Definition: binlog.h:90
uint charset_number
Definition: binlog.h:94
TODO: Move this structure to mysql/binlog/event/control_events.h when we start using C++11.
Definition: rpl_gtid.h:1101
Definition: my_sys.h:337
Definition: binlog.h:1024
bool log_delayed
Definition: binlog.h:1027
my_off_t last_pos_in_file
Definition: binlog.h:1026
bool logged_data_file
Definition: binlog.h:1027
THD * thd
Definition: binlog.h:1025
Definition: binlog_index.h:86
An instrumented cond structure.
Definition: mysql_cond_bits.h:50
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:50
MySQL mutex implementation.
Include file for Sun RPC to compile out of the box.
Transaction boundary parser definitions.
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:39
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:890