dbs/mysql-server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mysql-server/sql/rpl_gtid.h
Ho Sy Tan 4a107fd10e 2025-03-05 14:31:08
2025-03-05 14:31:37 +07:00

4327 lines
149 KiB
C++
Raw Permalink Blame History

/* Copyright (c) 2011, 2024, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef RPL_GTID_H_INCLUDED
#define RPL_GTID_H_INCLUDED
#include <atomic>
#include <cinttypes>
#include <list>
#include <mutex> // std::adopt_lock_t
#include <vector>
#include "map_helpers.h"
#include "my_dbug.h"
#include "my_thread_local.h"
#include "mysql/binlog/event/compression/base.h" // mysql::binlog::event::compression::type
#include "mysql/gtid/global.h"
#include "mysql/gtid/gtid.h"
#include "mysql/gtid/tsid.h"
#include "mysql/gtid/uuid.h"
#include "mysql/psi/mysql_cond.h"
#include "mysql/psi/mysql_rwlock.h" // mysql_rwlock_t
#include "mysql/strings/m_ctype.h" // my_isspace
#include "mysql/utils/return_status.h"
#include "prealloced_array.h" // Prealloced_array
#include "sql/changestreams/index/locked_sidno_set.h" // Locked_sidno_set
#include "sql/changestreams/index/sidno.h"
#include "sql/rpl_reporting.h" // MAX_SLAVE_ERRMSG
#include "template_utils.h"
class Table_ref;
class THD;
/**
Report an error from code that can be linked into either the server
or mysqlbinlog. There is no common error reporting mechanism, so we
have to duplicate the error message (write it out in the source file
for mysqlbinlog, write it in share/messages_to_clients.txt for the
server).
@param MYSQLBINLOG_ERROR arguments to mysqlbinlog's 'error'
function, including the function call parentheses
@param SERVER_ERROR arguments to my_error, including the function
call parentheses.
*/
#ifndef MYSQL_SERVER
#define BINLOG_ERROR(MYSQLBINLOG_ERROR, SERVER_ERROR) error MYSQLBINLOG_ERROR
#else
#define BINLOG_ERROR(MYSQLBINLOG_ERROR, SERVER_ERROR) my_error SERVER_ERROR
#endif
extern PSI_memory_key key_memory_Gtid_set_to_string;
extern PSI_memory_key key_memory_Owned_gtids_to_string;
extern PSI_memory_key key_memory_Gtid_state_to_string;
extern PSI_memory_key key_memory_Gtid_cache_to_string;
extern PSI_memory_key key_memory_Gtid_set_Interval_chunk;
extern PSI_memory_key key_memory_Gtid_state_group_commit_sidno;
/**
This macro is used to check that the given character, pointed to by the
character pointer, is a space or not.
*/
#define SKIP_WHITESPACE() \
while (my_isspace(&my_charset_utf8mb3_general_ci, *s)) s++
/*
This macro must be used to filter out parts of the code that
is not used now but may be useful in future. In other words,
we want to keep such code until we make up our minds on whether
it should be removed or not.
*/
#undef NON_DISABLED_GTID
/*
This macro must be used to filter out parts of the code that
is not used now but we are not sure if there is a bug around
them. In other words, we want to keep such code until we have
time to investigate it.
*/
#undef NON_ERROR_GTID
#ifdef MYSQL_SERVER
class String;
class THD;
#endif // ifdef MYSQL_SERVER
/// Type of SIDNO (source ID number, first component of GTID)
using rpl_sidno = cs::index::rpl_sidno;
/// GNO, the second (numeric) component of a GTID, is an alias of
/// mysql::gtid::gno_t
using rpl_gno = mysql::gtid::gno_t;
typedef int64 rpl_binlog_pos;
namespace cs::index {
class Locked_sidno_set;
} // namespace cs::index
/**
Generic return type for many functions that can succeed or fail.
This is used in conjunction with the macros below for functions where
the return status either indicates "success" or "failure". It
provides the following features:
- The macros can be used to conveniently propagate errors from
called functions back to the caller.
- If a function is expected to print an error using my_error before
it returns an error status, then the macros assert that my_error
has been called.
- Does a DBUG_PRINT before returning failure.
*/
enum enum_return_status {
/// The function completed successfully.
RETURN_STATUS_OK = 0,
/// The function completed with error but did not report it.
RETURN_STATUS_UNREPORTED_ERROR = 1,
/// The function completed with error and has called my_error.
RETURN_STATUS_REPORTED_ERROR = 2
};
/**
@def __CHECK_RETURN_STATUS
Lowest level macro used in the PROPAGATE_* and RETURN_* macros
below.
If NDEBUG is defined, does nothing. Otherwise, if STATUS is
RETURN_STATUS_OK, does nothing; otherwise, make a dbug printout and
(if ALLOW_UNREPORTED==0) assert that STATUS !=
RETURN_STATUS_UNREPORTED.
@param STATUS The status to return.
@param ACTION A text that describes what we are doing: either
"Returning" or "Propagating" (used in DBUG_PRINT macros)
@param STATUS_NAME The stringified version of the STATUS (used in
DBUG_PRINT macros).
@param ALLOW_UNREPORTED If false, the macro asserts that STATUS is
not RETURN_STATUS_UNREPORTED_ERROR.
*/
#ifdef NDEBUG
#define __CHECK_RETURN_STATUS(STATUS, ACTION, STATUS_NAME, ALLOW_UNREPORTED)
#else
extern void check_return_status(enum_return_status status, const char *action,
const char *status_name, int allow_unreported);
#define __CHECK_RETURN_STATUS(STATUS, ACTION, STATUS_NAME, ALLOW_UNREPORTED) \
check_return_status(STATUS, ACTION, STATUS_NAME, ALLOW_UNREPORTED);
#endif
/**
Low-level macro that checks if STATUS is RETURN_STATUS_OK; if it is
not, then RETURN_VALUE is returned.
@see __DO_RETURN_STATUS
*/
#define __PROPAGATE_ERROR(STATUS, RETURN_VALUE, ALLOW_UNREPORTED) \
do { \
enum_return_status __propagate_error_status = STATUS; \
if (__propagate_error_status != RETURN_STATUS_OK) { \
__CHECK_RETURN_STATUS(__propagate_error_status, "Propagating", #STATUS, \
ALLOW_UNREPORTED); \
return RETURN_VALUE; \
} \
} while (0)
/// Low-level macro that returns STATUS. @see __DO_RETURN_STATUS
#define __RETURN_STATUS(STATUS, ALLOW_UNREPORTED) \
do { \
enum_return_status __return_status_status = STATUS; \
__CHECK_RETURN_STATUS(__return_status_status, "Returning", #STATUS, \
ALLOW_UNREPORTED); \
return __return_status_status; \
} while (0)
/**
If STATUS (of type enum_return_status) returns RETURN_STATUS_OK,
does nothing; otherwise, does a DBUG_PRINT and returns STATUS.
*/
#define PROPAGATE_ERROR(STATUS) \
__PROPAGATE_ERROR(STATUS, __propagate_error_status, true)
/**
If STATUS (of type enum_return_status) returns RETURN_STATUS_OK,
does nothing; otherwise asserts that STATUS ==
RETURN_STATUS_REPORTED_ERROR, does a DBUG_PRINT, and returns STATUS.
*/
#define PROPAGATE_REPORTED_ERROR(STATUS) \
__PROPAGATE_ERROR(STATUS, __propagate_error_status, false)
/**
If STATUS (of type enum_return_status) returns RETURN_STATUS_OK,
does nothing; otherwise asserts that STATUS ==
RETURN_STATUS_REPORTED_ERROR, does a DBUG_PRINT, and returns 1.
*/
#define PROPAGATE_REPORTED_ERROR_INT(STATUS) __PROPAGATE_ERROR(STATUS, 1, false)
/**
If STATUS returns something else than RETURN_STATUS_OK, does a
DBUG_PRINT. Then, returns STATUS.
*/
#define RETURN_STATUS(STATUS) __RETURN_STATUS(STATUS, true)
/**
Asserts that STATUS is not RETURN_STATUS_UNREPORTED_ERROR. Then, if
STATUS is RETURN_STATUS_REPORTED_ERROR, does a DBUG_PRINT. Then,
returns STATUS.
*/
#define RETURN_REPORTED_STATUS(STATUS) __RETURN_STATUS(STATUS, false)
/// Returns RETURN_STATUS_OK.
#define RETURN_OK return RETURN_STATUS_OK
/// Does a DBUG_PRINT and returns RETURN_STATUS_REPORTED_ERROR.
#define RETURN_REPORTED_ERROR RETURN_STATUS(RETURN_STATUS_REPORTED_ERROR)
/// Does a DBUG_PRINT and returns RETURN_STATUS_UNREPORTED_ERROR.
#define RETURN_UNREPORTED_ERROR RETURN_STATUS(RETURN_STATUS_UNREPORTED_ERROR)
/**
enum to map the result of Uuid::parse to the above Macros
*/
inline enum_return_status map_macro_enum(int status) {
DBUG_TRACE;
if (status == 0)
RETURN_OK;
else
RETURN_UNREPORTED_ERROR;
}
/**
Possible values for ENFORCE_GTID_CONSISTENCY.
*/
enum enum_gtid_consistency_mode {
GTID_CONSISTENCY_MODE_OFF = 0,
GTID_CONSISTENCY_MODE_ON = 1,
GTID_CONSISTENCY_MODE_WARN = 2
};
/**
Strings holding the enumeration values for
gtid_consistency_mode_names. Use get_gtid_consistency_mode_string
instead of accessing this directly.
*/
extern const char *gtid_consistency_mode_names[];
/**
Current value for ENFORCE_GTID_CONSISTENCY.
Don't use this directly; use get_gtid_consistency_mode.
*/
extern ulong _gtid_consistency_mode;
/**
Return the current value of ENFORCE_GTID_CONSISTENCY.
Caller must hold global_tsid_lock.rdlock.
*/
enum_gtid_consistency_mode get_gtid_consistency_mode();
/// Return the given GTID_CONSISTENCY_MODE as a string.
inline const char *get_gtid_consistency_mode_string(
enum_gtid_consistency_mode mode) {
return gtid_consistency_mode_names[(int)mode];
}
/**
Return the current value of ENFORCE_GTID_CONSISTENCY as a string.
Caller must hold global_tsid_lock.rdlock.
*/
inline const char *get_gtid_consistency_mode_string() {
return get_gtid_consistency_mode_string(get_gtid_consistency_mode());
}
/// One-past-the-max value of GNO
const rpl_gno GNO_END = INT64_MAX;
/// If the GNO goes above the number, generate a warning.
const rpl_gno GNO_WARNING_THRESHOLD = (GNO_END / 100) * 99;
/// The length of MAX_GNO when printed in decimal.
const int MAX_GNO_TEXT_LENGTH = 19;
/// The maximal possible length of thread_id when printed in decimal.
const int MAX_THREAD_ID_TEXT_LENGTH = 19;
/**
Parse a GNO from a string.
@param s Pointer to the string. *s will advance to the end of the
parsed GNO, if a correct GNO is found.
@retval GNO if a correct GNO (i.e., 0 or positive number) was found.
@retval -1 otherwise.
*/
rpl_gno parse_gno(const char **s);
/**
Formats a GNO as a string.
@param s The buffer.
@param gno The GNO.
@return Length of the generated string.
*/
int format_gno(char *s, rpl_gno gno);
typedef mysql::gtid::Uuid rpl_sid;
/**
This has the functionality of mysql_rwlock_t, with two differences:
1. It has additional operations to check if the read and/or write lock
is held at the moment.
2. It is wrapped in an object-oriented interface.
Note that the assertions do not check whether *this* thread has
taken the lock (that would be more complicated as it would require a
dynamic data structure). Luckily, it is still likely that the
assertions find bugs where a thread forgot to take a lock, because
most of the time most locks are only used by one thread at a time.
The assertions are no-ops when DBUG is off.
*/
class Checkable_rwlock {
public:
/// Initialize this Checkable_rwlock.
Checkable_rwlock(
#if defined(HAVE_PSI_INTERFACE)
PSI_rwlock_key psi_key [[maybe_unused]] = 0
#endif
) {
#ifndef NDEBUG
m_lock_state.store(0);
m_dbug_trace = true;
#else
m_is_write_lock = false;
#endif
#if defined(HAVE_PSI_INTERFACE)
mysql_rwlock_init(psi_key, &m_rwlock);
#else
mysql_rwlock_init(0, &m_rwlock);
#endif
}
/// Destroy this Checkable_lock.
~Checkable_rwlock() { mysql_rwlock_destroy(&m_rwlock); }
enum enum_lock_type {
NO_LOCK,
READ_LOCK,
WRITE_LOCK,
TRY_READ_LOCK,
TRY_WRITE_LOCK
};
/**
RAII class to acquire a lock for the duration of a block.
*/
class Guard {
Checkable_rwlock &m_lock;
enum_lock_type m_lock_type;
public:
/**
Create a guard, and optionally acquire a lock on it.
*/
Guard(Checkable_rwlock &lock, enum_lock_type lock_type)
: m_lock(lock), m_lock_type(NO_LOCK) {
DBUG_TRACE;
switch (lock_type) {
case READ_LOCK:
rdlock();
break;
case WRITE_LOCK:
wrlock();
break;
case TRY_READ_LOCK:
tryrdlock();
break;
case TRY_WRITE_LOCK:
trywrlock();
break;
case NO_LOCK:
break;
}
}
/**
Create a guard, assuming the caller already holds a lock on it.
*/
Guard(Checkable_rwlock &lock, enum_lock_type lock_type,
std::adopt_lock_t t [[maybe_unused]])
: m_lock(lock), m_lock_type(lock_type) {
DBUG_TRACE;
switch (lock_type) {
case READ_LOCK:
lock.assert_some_rdlock();
break;
case WRITE_LOCK:
lock.assert_some_wrlock();
break;
case TRY_READ_LOCK:
case TRY_WRITE_LOCK:
case NO_LOCK:
break;
}
}
/// Objects of this class should not be copied or moved.
Guard(Guard const &copy) = delete;
Guard(Guard const &&copy) = delete;
/// Unlock on destruct.
~Guard() {
DBUG_TRACE;
unlock_if_locked();
}
/// Acquire the read lock.
void rdlock() {
DBUG_TRACE;
assert(m_lock_type == NO_LOCK);
m_lock.rdlock();
m_lock_type = READ_LOCK;
}
/// Acquire the write lock.
void wrlock() {
DBUG_TRACE;
assert(m_lock_type == NO_LOCK);
m_lock.wrlock();
m_lock_type = WRITE_LOCK;
}
/**
Try to acquire the write lock, and fail if it cannot be
immediately granted.
*/
int trywrlock() {
DBUG_TRACE;
assert(m_lock_type == NO_LOCK);
int ret = m_lock.trywrlock();
if (ret == 0) m_lock_type = WRITE_LOCK;
return ret;
}
/**
Try to acquire a read lock, and fail if it cannot be
immediately granted.
*/
int tryrdlock() {
DBUG_TRACE;
assert(m_lock_type == NO_LOCK);
int ret = m_lock.tryrdlock();
if (ret == 0) m_lock_type = READ_LOCK;
return ret;
}
/// Unlock the lock.
void unlock() {
DBUG_TRACE;
assert(m_lock_type != NO_LOCK);
m_lock.unlock();
}
/// Unlock the lock, if it was acquired by this guard.
void unlock_if_locked() {
DBUG_TRACE;
if (m_lock_type != NO_LOCK) unlock();
}
/// Return the underlying Checkable_rwlock object.
Checkable_rwlock &get_lock() const { return m_lock; }
/// Return true if this object is read locked.
bool is_rdlocked() const { return m_lock_type == READ_LOCK; }
/// Return true if this object is write locked.
bool is_wrlocked() const { return m_lock_type == WRITE_LOCK; }
/// Return true if this object is either read locked or write locked.
bool is_locked() const { return m_lock_type != NO_LOCK; }
};
/// Acquire the read lock.
inline void rdlock() {
mysql_rwlock_rdlock(&m_rwlock);
assert_no_wrlock();
#ifndef NDEBUG
if (m_dbug_trace) DBUG_PRINT("info", ("%p.rdlock()", this));
++m_lock_state;
#endif
}
/// Acquire the write lock.
inline void wrlock() {
mysql_rwlock_wrlock(&m_rwlock);
assert_no_lock();
#ifndef NDEBUG
if (m_dbug_trace) DBUG_PRINT("info", ("%p.wrlock()", this));
m_lock_state.store(-1);
#else
m_is_write_lock = true;
#endif
}
/// Release the lock (whether it is a write or read lock).
inline void unlock() {
assert_some_lock();
#ifndef NDEBUG
if (m_dbug_trace) DBUG_PRINT("info", ("%p.unlock()", this));
int val = m_lock_state.load();
if (val > 0)
--m_lock_state;
else if (val == -1)
m_lock_state.store(0);
else
assert(0);
#else
m_is_write_lock = false;
#endif
mysql_rwlock_unlock(&m_rwlock);
}
/**
Return true if the write lock is held. Must only be called by
threads that hold a lock.
*/
inline bool is_wrlock() {
assert_some_lock();
#ifndef NDEBUG
return get_state() == -1;
#else
return m_is_write_lock;
#endif
}
/**
Return 0 if the write lock is held, otherwise an error will be returned.
*/
inline int trywrlock() {
int ret = mysql_rwlock_trywrlock(&m_rwlock);
if (ret == 0) {
assert_no_lock();
#ifndef NDEBUG
if (m_dbug_trace) DBUG_PRINT("info", ("%p.wrlock()", this));
m_lock_state.store(-1);
#else
m_is_write_lock = true;
#endif
}
return ret;
}
/**
Return 0 if the read lock is held, otherwise an error will be returned.
*/
inline int tryrdlock() {
int ret = mysql_rwlock_tryrdlock(&m_rwlock);
if (ret == 0) {
assert_no_wrlock();
#ifndef NDEBUG
if (m_dbug_trace) DBUG_PRINT("info", ("%p.rdlock()", this));
++m_lock_state;
#endif
}
return ret;
}
/// Assert that some thread holds either the read or the write lock.
inline void assert_some_lock() const { assert(get_state() != 0); }
/// Assert that some thread holds the read lock.
inline void assert_some_rdlock() const { assert(get_state() > 0); }
/// Assert that some thread holds the write lock.
inline void assert_some_wrlock() const { assert(get_state() == -1); }
/// Assert that no thread holds the write lock.
inline void assert_no_wrlock() const { assert(get_state() >= 0); }
/// Assert that no thread holds the read lock.
inline void assert_no_rdlock() const { assert(get_state() <= 0); }
/// Assert that no thread holds read or write lock.
inline void assert_no_lock() const { assert(get_state() == 0); }
#ifndef NDEBUG
/// If enabled, print any lock/unlock operations to the DBUG trace.
bool m_dbug_trace;
private:
/**
The state of the lock:
0 - not locked
-1 - write locked
>0 - read locked by that many threads
*/
std::atomic<int32> m_lock_state;
/// Read lock_state atomically and return the value.
inline int32 get_state() const { return m_lock_state.load(); }
#else
private:
bool m_is_write_lock;
#endif
/// The rwlock.
mysql_rwlock_t m_rwlock{};
};
/// Protects Gtid_state. See comment above gtid_state for details.
extern Checkable_rwlock *global_tsid_lock;
/**
Class to access the value of @@global.gtid_mode in an efficient and
thread-safe manner.
*/
class Gtid_mode {
private:
std::atomic<int> m_atomic_mode;
public:
Gtid_mode() : m_atomic_mode(0) {}
/**
The sys_var framework needs a variable of type ulong to store the
value in. The sys_var framework takes the value from there, but
we copy it (in the methods of sys_var_gtid_mode) to the atomic
value Gtid_mode::mode, and use only that in all other places.
*/
static ulong sysvar_mode;
/// Possible values for @@global.gtid_mode.
enum value_type {
/**
New transactions are anonymous. Replicated transactions must be
anonymous; replicated GTID-transactions generate an error.
*/
OFF = 0,
DEFAULT = OFF,
/**
New transactions are anonyomus. Replicated transactions can be
either anonymous or GTID-transactions.
*/
OFF_PERMISSIVE = 1,
/**
New transactions are GTID-transactions. Replicated transactions
can be either anonymous or GTID-transactions.
*/
ON_PERMISSIVE = 2,
/**
New transactions are GTID-transactions. Replicated transactions
must be GTID-transactions; replicated anonymous transactions
generate an error.
*/
ON = 3
};
/**
Strings holding the enumeration values for gtid_mode. Use
Gtid_mode::get_string instead of accessing this directly.
*/
static const char *names[];
/**
Protects updates to @@global.gtid_mode.
SET @@global.gtid_mode will try to take the write lock. If the
lock is not granted immediately, SET will fail.
Thus, any other operation can block updates to
@@global.gtid_mode by acquiring the read lock.
*/
static Checkable_rwlock lock;
/**
Set a new value for @@global.gtid_mode.
This should only be called from Sys_var_gtid_mode::global_update
and gtid_server_init.
*/
void set(value_type value);
public:
/**
Return the current gtid_mode as an enumeration value.
*/
value_type get() const;
#ifndef NDEBUG
/**
Return the current gtid_mode as a string.
Used only for debugging. Non-debug code typically reads and acts
on the enum value before printing it. Then it is better to print
the enum value.
*/
const char *get_string() const;
#endif // ifndef NDEBUG
/**
Return the given string gtid_mode as an enumeration value.
@param s The string to decode.
@return A pair, where the first component indicates failure and
the second component is the GTID_MODE. Specifically, the first
component is false if the string is a valid GTID_MODE, and true if
it is not.
*/
static std::pair<bool, value_type> from_string(std::string s);
/// Return the given gtid_mode as a string.
static const char *to_string(value_type value);
};
std::ostream &operator<<(std::ostream &oss, Gtid_mode::value_type const &mode);
#ifndef NDEBUG
/**
Typically, code will print Gtid_mode only after reading and acting
on the enum value. Then it is better to print the enum value than to
read the shared resource again. Hence we enable this only in debug
mode, since it makes more sense to just get the string when doing a
debug printout.
*/
std::ostream &operator<<(std::ostream &oss, Gtid_mode const &mode);
#endif
/**
The one and only instance of Gtid_mode.
All access to @@global.gtid_mode should use this object.
*/
extern Gtid_mode global_gtid_mode;
/**
Represents a bidirectional map between TSID and SIDNO.
SIDNOs are always numbers greater or equal to 1.
This data structure OPTIONALLY knows of a read-write lock that
protects the number of SIDNOs. The lock is provided by the invoker
of the constructor and it is generally the caller's responsibility
to acquire the read lock. If the lock is not NULL, access methods
assert that the caller already holds the read (or write) lock. If
the lock is not NULL and a method of this class grows the number of
SIDNOs, then the method temporarily upgrades this lock to a write
lock and then degrades it to a read lock again; there will be a
short period when the lock is not held at all.
*/
class Tsid_map {
public:
/**
Create this Tsid_map.
@param tsid_lock Read-write lock that protects updates to the
number of SIDNOs.
*/
Tsid_map(Checkable_rwlock *tsid_lock);
/// Destroy this Tsid_map.
~Tsid_map();
/**
Clears this Tsid_map (for RESET REPLICA)
@return RETURN_STATUS_OK or RETURN_STAUTS_REPORTED_ERROR
*/
enum_return_status clear();
using Tsid = mysql::gtid::Tsid;
using Tag = mysql::gtid::Tag;
using Tsid_to_sidno_allocator = Map_allocator_type<Tsid, rpl_sidno>;
using Tsid_to_sidno_umap = malloc_unordered_map<Tsid, rpl_sidno, Tsid::Hash>;
using Tsid_to_sidno_map = Map_myalloc<Tsid, rpl_sidno>;
using Tsid_to_sidno_it = Tsid_to_sidno_map::const_iterator;
using Tsid_ref = std::reference_wrapper<const Tsid>;
using Sidno_to_tsid_cont = std::vector<Tsid_ref, Malloc_allocator<Tsid_ref>>;
/**
Add the given TSID to this map if it does not already exist.
The caller must hold the read lock or write lock on tsid_lock
before invoking this function. If the TSID does not exist in this
map, it will release the read lock, take a write lock, update the
map, release the write lock, and take the read lock again.
@param tsid The TSID.
@retval SIDNO The SIDNO for the TSID (a new SIDNO if the TSID did
not exist, an existing if it did exist).
@retval negative Error. This function calls my_error.
*/
[[NODISCARD]] rpl_sidno add_tsid(const Tsid &tsid);
/**
Get the SIDNO for a given TSID
The caller must hold the read lock on tsid_lock before invoking
this function.
@param tsid The TSID.
@retval SIDNO if the given TSID exists in this map.
@retval 0 if the given TSID does not exist in this map.
*/
rpl_sidno tsid_to_sidno(const Tsid &tsid) const {
if (tsid_lock != nullptr) tsid_lock->assert_some_lock();
const auto it = _tsid_to_sidno.find(tsid);
if (it == _tsid_to_sidno.end()) return 0;
return it->second;
}
/**
Get the TSID for a given SIDNO.
Raises an assertion if the SIDNO is not valid.
If need_lock is true, acquires tsid_lock->rdlock; otherwise asserts
that it is held already.
@param sidno The SIDNO.
@param need_lock If true, and tsid_lock!=NULL, this function will
acquire tsid_lock before looking up the sid, and then release
it. If false, and tsid_lock!=NULL, this function will assert the
tsid_lock is already held. If tsid_lock==NULL, nothing is done
w.r.t. locking.
@retval NULL The SIDNO does not exist in this map.
@retval ref Reference to the TSID. The data is shared with this
Tsid_map, so should not be modified. It is safe to read the data
even after this Tsid_map is modified, but not if this Tsid_map is
destroyed.
*/
const Tsid &sidno_to_tsid(rpl_sidno sidno, bool need_lock = false) const {
if (tsid_lock != nullptr) {
if (need_lock)
tsid_lock->rdlock();
else
tsid_lock->assert_some_lock();
}
assert(sidno >= 1 && sidno <= get_max_sidno());
const auto &ret = (_sidno_to_tsid[sidno - 1]);
if (tsid_lock != nullptr && need_lock) tsid_lock->unlock();
return ret.get();
}
/**
Returns TSID to SID map
The caller must hold the read or write lock on tsid_lock before
invoking this function.
@return constant reference to sid_to_sidno container
*/
const Tsid_to_sidno_map &get_sorted_sidno() const { return _sorted; }
const rpl_sidno &get_sidno(const Tsid_to_sidno_it &it) const {
if (tsid_lock != nullptr) tsid_lock->assert_some_lock();
return it->second;
}
const Tsid &get_tsid(const Tsid_to_sidno_it &it) const {
if (tsid_lock != nullptr) tsid_lock->assert_some_lock();
return it->first;
}
/**
Return the biggest sidno in this Tsid_map.
The caller must hold the read or write lock on tsid_lock before
invoking this function.
*/
rpl_sidno get_max_sidno() const {
if (tsid_lock != nullptr) tsid_lock->assert_some_lock();
return static_cast<rpl_sidno>(_sidno_to_tsid.size());
}
/// Return the tsid_lock.
Checkable_rwlock *get_tsid_lock() const { return tsid_lock; }
/**
Deep copy this Tsid_map to dest.
The caller must hold:
* the read lock on this tsid_lock
* the write lock on the dest tsid_lock
before invoking this function.
@param[out] dest The Tsid_map to which the tsids and sidnos will
be copied.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status copy(Tsid_map *dest);
private:
/**
Create a Node from the given SIDNO and a TSID and add it to
_sidno_to_tsid, _tsid_to_sidno, and _sorted.
The caller must hold the write lock on tsid_lock before invoking
this function.
@param sidno The SIDNO to add.
@param tsid The TSID to add.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
[[NODISCARD]] enum_return_status add_node(rpl_sidno sidno, const Tsid &tsid);
/// Read-write lock that protects updates to the number of SIDNOs.
mutable Checkable_rwlock *tsid_lock;
/**
Array that maps SIDNO to TSID; the element at index N points to a
Node with SIDNO N-1.
*/
Sidno_to_tsid_cont _sidno_to_tsid{
Malloc_allocator<Tsid_ref>{key_memory_tsid_map_Node}};
/**
Hash that maps TSID to SIDNO.
*/
Tsid_to_sidno_umap _tsid_to_sidno{key_memory_tsid_map_Node};
/**
Data structure that maps numbers in the interval [0, get_max_sidno()-1] to
SIDNOs, in order of increasing TSID.
@see Tsid_map::get_sorted_sidno.
*/
Tsid_to_sidno_map _sorted{Tsid_to_sidno_allocator{key_memory_tsid_map_Node}};
};
extern Tsid_map *global_tsid_map;
/**
Represents a growable array where each element contains a mutex and
a condition variable.
Each element can be locked, unlocked, broadcast, or waited for, and
it is possible to call "THD::enter_cond" for the condition. The
allowed indexes range from 0, inclusive, to get_max_index(),
inclusive. Initially there are zero elements (and get_max_index()
returns -1); more elements can be allocated by calling
ensure_index().
This data structure has a read-write lock that protects the number
of elements. The lock is provided by the invoker of the constructor
and it is generally the caller's responsibility to acquire the read
lock. Access methods assert that the caller already holds the read
(or write) lock. If a method of this class grows the number of
elements, then the method temporarily upgrades this lock to a write
lock and then degrades it to a read lock again; there will be a
short period when the lock is not held at all.
*/
class Mutex_cond_array {
public:
/**
Create a new Mutex_cond_array.
@param global_lock Read-write lock that protects updates to the
number of elements.
*/
Mutex_cond_array(Checkable_rwlock *global_lock);
/// Destroy this object.
~Mutex_cond_array();
/// Lock the n'th mutex.
inline void lock(int n) const {
assert_not_owner(n);
mysql_mutex_lock(&get_mutex_cond(n)->mutex);
}
/// Unlock the n'th mutex.
inline void unlock(int n) const {
assert_owner(n);
mysql_mutex_unlock(&get_mutex_cond(n)->mutex);
}
/// Broadcast the n'th condition.
inline void broadcast(int n) const {
mysql_cond_broadcast(&get_mutex_cond(n)->cond);
}
/**
Assert that this thread owns the n'th mutex.
This is a no-op if NDEBUG is on.
*/
inline void assert_owner(int n [[maybe_unused]]) const {
#ifndef NDEBUG
mysql_mutex_assert_owner(&get_mutex_cond(n)->mutex);
#endif
}
/**
Assert that this thread does not own the n'th mutex.
This is a no-op if NDEBUG is on.
*/
inline void assert_not_owner(int n [[maybe_unused]]) const {
#ifndef NDEBUG
mysql_mutex_assert_not_owner(&get_mutex_cond(n)->mutex);
#endif
}
/**
Wait for signal on the n'th condition variable.
The caller must hold the read lock or write lock on tsid_lock, as
well as the nth mutex lock, before invoking this function. The
tsid_lock will be released, whereas the mutex will be released
during the wait and (atomically) re-acquired when the wait ends
or the timeout is reached.
@param[in] thd THD object for the calling thread.
@param[in] sidno Condition variable to wait for.
@param[in] abstime The absolute point in time when the wait times
out and stops, or NULL to wait indefinitely.
@retval false Success.
@retval true Failure: either timeout or thread was killed. If
thread was killed, the error has been generated.
*/
inline bool wait(const THD *thd, int sidno, struct timespec *abstime) const {
DBUG_TRACE;
int error = 0;
Mutex_cond *mutex_cond = get_mutex_cond(sidno);
global_lock->unlock();
mysql_mutex_assert_owner(&mutex_cond->mutex);
if (is_thd_killed(thd)) return true;
if (abstime != nullptr)
error =
mysql_cond_timedwait(&mutex_cond->cond, &mutex_cond->mutex, abstime);
else
mysql_cond_wait(&mutex_cond->cond, &mutex_cond->mutex);
mysql_mutex_assert_owner(&mutex_cond->mutex);
return is_timeout(error);
}
#ifdef MYSQL_SERVER
/// Execute THD::enter_cond for the n'th condition variable.
void enter_cond(THD *thd, int n, PSI_stage_info *stage,
PSI_stage_info *old_stage) const;
#endif // ifdef MYSQL_SERVER
/// Return the greatest addressable index in this Mutex_cond_array.
inline int get_max_index() const {
global_lock->assert_some_lock();
return static_cast<int>(m_array.size() - 1);
}
/**
Grows the array so that the given index fits.
If the array is grown, the global_lock is temporarily upgraded to
a write lock and then degraded again; there will be a
short period when the lock is not held at all.
@param n The index.
@return RETURN_OK or RETURN_REPORTED_ERROR
*/
enum_return_status ensure_index(int n);
private:
/**
Return true if the given THD is killed.
@param[in] thd - The thread object
@retval true - thread is killed
false - thread not killed
*/
bool is_thd_killed(const THD *thd) const;
/// A mutex/cond pair.
struct Mutex_cond {
mysql_mutex_t mutex;
mysql_cond_t cond;
};
/// Return the Nth Mutex_cond object
inline Mutex_cond *get_mutex_cond(int n) const {
global_lock->assert_some_lock();
assert(n <= get_max_index());
Mutex_cond *ret = m_array[n];
assert(ret);
return ret;
}
/// Read-write lock that protects updates to the number of elements.
mutable Checkable_rwlock *global_lock;
Prealloced_array<Mutex_cond *, 8> m_array;
};
/**
Holds information about a GTID interval: the sidno, the first gno
and the last gno of this interval.
*/
struct Gtid_interval {
/* SIDNO of this Gtid interval. */
rpl_sidno sidno;
/* The first GNO of this Gtid interval. */
rpl_gno gno_start;
/* The last GNO of this Gtid interval. */
rpl_gno gno_end;
void set(rpl_sidno sid_no, rpl_gno start, rpl_gno end) {
sidno = sid_no;
gno_start = start;
gno_end = end;
}
};
/**
TODO: Move this structure to mysql/binlog/event/control_events.h
when we start using C++11.
Holds information about a GTID: the sidno and the gno.
This is a POD. It has to be a POD because it is part of
Gtid_specification, which has to be a POD because it is used in
THD::variables.
*/
struct Gtid {
using Tsid = mysql::gtid::Tsid;
using Tag = mysql::gtid::Tag;
/// SIDNO of this Gtid.
rpl_sidno sidno;
/// GNO of this Gtid.
rpl_gno gno;
/// Set both components to 0.
void clear() {
sidno = 0;
gno = 0;
}
/// Set both components to the given, positive values.
void set(rpl_sidno sidno_arg, rpl_gno gno_arg) {
assert(sidno_arg > 0);
assert(gno_arg > 0);
assert(gno_arg < GNO_END);
sidno = sidno_arg;
gno = gno_arg;
}
/**
Return true if sidno is zero (and assert that gno is zero too in
this case).
*/
bool is_empty() const {
// check that gno is not set inconsistently
if (sidno <= 0)
assert(gno == 0);
else
assert(gno > 0);
return sidno == 0;
}
/**
The maximal length of the textual representation of a TSID, not
including the terminating '\0'.
*/
static const int MAX_TEXT_LENGTH =
mysql::gtid::tsid_max_length + 1 + MAX_GNO_TEXT_LENGTH;
/**
Returns true if parse() would succeed, but doesn't store the
result anywhere
*/
static bool is_valid(const char *text);
/**
Convert a Gtid to a string.
@param tsid the TSID to use. This overrides the sidno of this Gtid.
@param[out] buf Buffer to store the Gtid in (normally
MAX_TEXT_LENGTH+1 bytes long).
@return Length of the string, not counting '\0'.
*/
int to_string(const Tsid &tsid, char *buf) const;
/**
Convert this Gtid to a string.
@param tsid_map tsid_map to use when converting sidno to a TSID.
@param[out] buf Buffer to store the Gtid in (normally
MAX_TEXT_LENGTH+1 bytes long).
@param need_lock If true, the function will acquire tsid_map->tsid_lock;
otherwise it will assert that the lock is held.
@return Length of the string, not counting '\0'.
*/
int to_string(const Tsid_map *tsid_map, char *buf,
bool need_lock = false) const;
/// Returns true if this Gtid has the same sid and gno as 'other'.
bool equals(const Gtid &other) const {
return sidno == other.sidno && gno == other.gno;
}
/**
Parses the given string and stores in this Gtid.
@param tsid_map tsid_map to use when converting TSID to a sidno.
@param text The text to parse
@return status of operation
*/
[[NODISCARD]] mysql::utils::Return_status parse(Tsid_map *tsid_map,
const char *text);
/// @brief Parses TAG from a textual representation of the GTID (text)
/// @param[in] text String with full GTID specification
/// @param[in] pos Current position within a text
/// @return Parsed tag
/// Updated position within text
static std::pair<Tag, std::size_t> parse_tag_str(const char *text,
std::size_t pos);
/// @brief Helper used to report BINLOG error
/// @param[in] text String with full GTID specification
static void report_parsing_error(const char *text);
/// @brief Parses GTID from text. In case GTID is valid, it will return
/// "ok" status code and a valid mysql::gtid::Gtid object. Otherwise,
/// it will return an empty Gtid and error
/// @param[in] text Text containing textual representation of a GTID
static std::pair<mysql::utils::Return_status, mysql::gtid::Gtid>
parse_gtid_from_cstring(const char *text);
/// @brief Definition of GTID separator (colon) which separates UUID and GNO
static constexpr auto gtid_separator = ':';
#ifndef NDEBUG
/// Debug only: print this Gtid to stdout.
void print(const Tsid_map *tsid_map) const {
char buf[MAX_TEXT_LENGTH + 1];
to_string(tsid_map, buf);
printf("%s\n", buf);
}
#endif
/// Print this Gtid to the trace file if debug is enabled; no-op otherwise.
void dbug_print(const Tsid_map *tsid_map [[maybe_unused]],
const char *text [[maybe_unused]] = "",
bool need_lock [[maybe_unused]] = false) const {
#ifndef NDEBUG
char buf[MAX_TEXT_LENGTH + 1];
to_string(tsid_map, buf, need_lock);
DBUG_PRINT("info", ("%s%s%s", text, *text ? ": " : "", buf));
#endif
}
protected:
/// @brief Converts internal gno into the string
/// @param[out] buf Buffer to store the GNO in
/// @return Length of the string
int to_string_gno(char *buf) const;
/// @brief Helper function used to skip whitespaces in GTID specification
/// @param[in] text String with full GTID specification
/// @param[in] pos Current position within a text
/// @return Updated position in text
static std::size_t skip_whitespace(const char *text, std::size_t pos);
/// @brief Parses SID from a textual representation of the GTID.
/// @param[in] text String with full GTID specification
/// @param[in] pos Current position within a text
/// @return operation status;
/// Parsed sidno in case status is equal to true,
/// 0 otherwise;
/// Updated position within text up to which characters has
/// been accepted
static std::tuple<mysql::utils::Return_status, rpl_sid, std::size_t>
parse_sid_str(const char *text, std::size_t pos);
/// @brief Parses GNO from a textual representation of the GTID (text)
/// @param[in] text String with full GTID specification
/// @param[in] pos Current position within a text
/// @return operation status;
/// Parsed gno in case status is equal to true or 0;
/// Updated position within text
static std::tuple<mysql::utils::Return_status, rpl_gno, std::size_t>
parse_gno_str(const char *text, std::size_t pos);
/// @brief Parses GTID separator from a textual representation of the GTID
/// (text)
/// @param[in] text String with full GTID specification
/// @param[in] pos Current position within a text
/// @return parsing status, error in case separator could not have been parsed
/// Updated position within text
static std::pair<mysql::utils::Return_status, std::size_t>
parse_gtid_separator(const char *text, std::size_t pos);
};
/// Structure to store the GTID and timing information.
struct Trx_monitoring_info {
/// GTID being monitored.
Gtid gtid;
/// OCT of the GTID being monitored.
ulonglong original_commit_timestamp;
/// ICT of the GTID being monitored.
ulonglong immediate_commit_timestamp;
/// When the GTID transaction started to be processed.
ulonglong start_time;
/// When the GTID transaction finished to be processed.
ulonglong end_time;
/// True if the GTID is being applied but will be skipped.
bool skipped;
/// True when this information contains useful data.
bool is_info_set;
/// Number of the last transient error of this transaction
uint last_transient_error_number;
/// Message of the last transient error of this transaction
char last_transient_error_message[MAX_SLAVE_ERRMSG];
/// Timestamp in microseconds of the last transient error of this transaction
ulonglong last_transient_error_timestamp;
/// Number of times this transaction was retried
ulong transaction_retries;
/// True when the transaction is retrying
bool is_retrying;
/// The compression type
mysql::binlog::event::compression::type compression_type;
/// The compressed bytes
ulonglong compressed_bytes;
/// The uncompressed bytes
ulonglong uncompressed_bytes;
/// Constructor
Trx_monitoring_info();
/// Copy constructor
Trx_monitoring_info(const Trx_monitoring_info &info);
Trx_monitoring_info &operator=(const Trx_monitoring_info &) = default;
/// Clear all fields of the structure.
void clear();
/**
Copies this transaction monitoring information to the output parameters
passed as input, which are the corresponding fields in a replication
performance schema table.
@param[in] tsid_map The TSID map for the GTID.
@param[out] gtid_arg GTID field in the PS table.
@param[out] gtid_length_arg Length of the GTID as string.
@param[out] original_commit_ts_arg The original commit timestamp.
@param[out] immediate_commit_ts_arg The immediate commit timestamp.
@param[out] start_time_arg The start time field.
*/
void copy_to_ps_table(Tsid_map *tsid_map, char *gtid_arg,
uint *gtid_length_arg,
ulonglong *original_commit_ts_arg,
ulonglong *immediate_commit_ts_arg,
ulonglong *start_time_arg) const;
/**
Copies this transaction monitoring information to the output parameters
passed as input, which are the corresponding fields in a replication
performance schema table.
@param[in] tsid_map The TSID map for the GTID.
@param[out] gtid_arg GTID field in the PS table.
@param[out] gtid_length_arg Length of the GTID as string.
@param[out] original_commit_ts_arg The original commit timestamp.
@param[out] immediate_commit_ts_arg The immediate commit timestamp.
@param[out] start_time_arg The start time field.
@param[out] end_time_arg The end time field. This can be null
when the PS table fields are for the
"still processing" information.
*/
void copy_to_ps_table(Tsid_map *tsid_map, char *gtid_arg,
uint *gtid_length_arg,
ulonglong *original_commit_ts_arg,
ulonglong *immediate_commit_ts_arg,
ulonglong *start_time_arg,
ulonglong *end_time_arg) const;
/**
Copies this transaction monitoring information to the output parameters
passed as input, which are the corresponding fields in a replication
performance schema table.
@param[in] tsid_map The TSID map for the GTID.
@param[out] gtid_arg GTID field in the PS table.
@param[out] gtid_length_arg Length of the GTID as string.
@param[out] original_commit_ts_arg The original commit timestamp.
@param[out] immediate_commit_ts_arg The immediate commit timestamp.
@param[out] start_time_arg The start time field.
@param[out] last_transient_errno_arg The last transient error
number.
@param[out] last_transient_errmsg_arg The last transient error
message.
@param[out] last_transient_errmsg_length_arg Length of the last transient
error message.
@param[out] last_transient_timestamp_arg The last transient error
timestamp.
@param[out] retries_count_arg The total number of retries for
this transaction.
*/
void copy_to_ps_table(
Tsid_map *tsid_map, char *gtid_arg, uint *gtid_length_arg,
ulonglong *original_commit_ts_arg, ulonglong *immediate_commit_ts_arg,
ulonglong *start_time_arg, uint *last_transient_errno_arg,
char *last_transient_errmsg_arg, uint *last_transient_errmsg_length_arg,
ulonglong *last_transient_timestamp_arg, ulong *retries_count_arg) const;
/**
Copies this transaction monitoring information to the output parameters
passed as input, which are the corresponding fields in a replication
performance schema table.
@param[in] tsid_map The TSID map for the GTID.
@param[out] gtid_arg GTID field in the PS table.
@param[out] gtid_length_arg Length of the GTID as string.
@param[out] original_commit_ts_arg The original commit timestamp.
@param[out] immediate_commit_ts_arg The immediate commit timestamp.
@param[out] start_time_arg The start time field.
@param[out] end_time_arg The end time field. This can be
null when the PS table fields
are for the "still processing"
information.
@param[out] last_transient_errno_arg The last transient error
number.
@param[out] last_transient_errmsg_arg The last transient error
message.
@param[out] last_transient_errmsg_length_arg Length of the last transient
error message.
@param[out] last_transient_timestamp_arg The last transient error
timestamp.
@param[out] retries_count_arg The total number of retries for
this transaction.
*/
void copy_to_ps_table(
Tsid_map *tsid_map, char *gtid_arg, uint *gtid_length_arg,
ulonglong *original_commit_ts_arg, ulonglong *immediate_commit_ts_arg,
ulonglong *start_time_arg, ulonglong *end_time_arg,
uint *last_transient_errno_arg, char *last_transient_errmsg_arg,
uint *last_transient_errmsg_length_arg,
ulonglong *last_transient_timestamp_arg, ulong *retries_count_arg) const;
};
/**
Stores information to monitor a transaction during the different replication
stages.
*/
class Gtid_monitoring_info {
public:
/**
Create this GTID monitoring info object.
@param atomic_mutex_arg When specified, this object will rely on the mutex
to arbitrate the read/update access to object data.
This will be used by the receiver thread, relying
on mi->data_lock. When no mutex is specified, the
object will rely on its own atomic mechanism.
*/
Gtid_monitoring_info(mysql_mutex_t *atomic_mutex_arg = nullptr);
/// Destroy this GTID monitoring info object.
~Gtid_monitoring_info();
protected:
/// Holds information about transaction being processed.
Trx_monitoring_info *processing_trx;
/// Holds information about the last processed transaction.
Trx_monitoring_info *last_processed_trx;
private:
/**
Mutex arbitrating the atomic access to the object.
Some Gtid_monitoring_info will rely on replication thread locks
(i.e.: the Master_info's one rely on mi->data_lock, that is already
acquired every time the Gtid_monitoring_info needs to be updated).
Other Gtid_monitoring_info will rely on an atomic lock implemented
in this class to avoid overlapped reads and writes over the information.
(i.e.: the Relay_log_info's one sometimes is updated without rli locks).
When atomic_mutex is NULL, the object will rely on its own atomic
mechanism.
*/
mysql_mutex_t *atomic_mutex;
/// The atomic locked flag.
std::atomic<bool> atomic_locked{false};
#ifndef NDEBUG
/// Flag to assert the atomic lock behavior.
bool is_locked = false;
#endif
public:
/**
Lock this object when no thread mutex is used to arbitrate the access.
*/
void atomic_lock();
/**
Unlock this object when no thread mutex is used to arbitrate the access.
*/
void atomic_unlock();
/**
Clear all monitoring information.
*/
void clear();
/**
Clear only the processing_trx monitoring info.
*/
void clear_processing_trx();
/**
Clear only the last_processed_trx monitoring info.
*/
void clear_last_processed_trx();
/**
Sets the initial monitoring information.
@param gtid_arg The Gtid to be stored.
@param original_ts_arg The original commit timestamp of the GTID.
@param immediate_ts_arg The immediate commit timestamp of the GTID.
@param skipped_arg True if the GTID was already applied.
This only make sense for applier threads.
That's why it is false by default.
*/
void start(Gtid gtid_arg, ulonglong original_ts_arg,
ulonglong immediate_ts_arg, bool skipped_arg = false);
void update(mysql::binlog::event::compression::type t, size_t payload_size,
size_t uncompressed_size);
/**
Sets the final information, copy processing info to last_processed
and clears processing info.
*/
void finish();
/**
Copies both processing_trx and last_processed_trx info to other
Trx_monitoring_info structures.
@param[out] processing_dest The destination of processing_trx.
@param[out] last_processed_dest The destination of last_processed_trx.
*/
void copy_info_to(Trx_monitoring_info *processing_dest,
Trx_monitoring_info *last_processed_dest);
/**
Copies all monitoring info to other Gtid_monitoring_info object.
@param[out] dest The destination Gtid_monitoring_info.
*/
void copy_info_to(Gtid_monitoring_info *dest);
/// Returns true if the processing_trx is set, false otherwise.
bool is_processing_trx_set();
/// Returns the GTID of the processing_trx.
const Gtid *get_processing_trx_gtid();
/**
Stores the information about the last transient error in the current
transaction, namely: the error number, message and total number of retries.
It also sets the timestamp for this error.
@param transient_errno_arg The number of the transient error in this
transaction.
@param transient_err_message_arg The message of this transient error.
@param trans_retries_arg The number of times this transaction has
been retried.
*/
void store_transient_error(uint transient_errno_arg,
const char *transient_err_message_arg,
ulong trans_retries_arg);
};
/**
Represents a set of GTIDs.
This is structured as an array, indexed by SIDNO, where each element
contains a linked list of intervals.
This data structure OPTIONALLY knows of a Tsid_map that gives a
correspondence between SIDNO and TSID. If the Tsid_map is NULL, then
operations that require a Tsid_map - printing and parsing - raise an
assertion.
This data structure OPTIONALLY knows of a read-write lock that
protects the number of SIDNOs. The lock is provided by the invoker
of the constructor and it is generally the caller's responsibility
to acquire the read lock. If the lock is not NULL, access methods
assert that the caller already holds the read (or write) lock. If
the lock is not NULL and a method of this class grows the number of
SIDNOs, then the method temporarily upgrades this lock to a write
lock and then degrades it to a read lock again; there will be a
short period when the lock is not held at all.
*/
class Gtid_set {
public:
static PSI_mutex_key key_gtid_executed_free_intervals_mutex;
/**
Constructs a new, empty Gtid_set.
@param tsid_map The Tsid_map to use, or NULL if this Gtid_set
should not have a Tsid_map.
@param tsid_lock Read-write lock that protects updates to the
number of TSIDs. This may be NULL if such changes do not need to be
protected.
*/
Gtid_set(Tsid_map *tsid_map, Checkable_rwlock *tsid_lock = nullptr);
/**
Constructs a new Gtid_set that contains the gtids in the given
string, in the same format as add_gtid_text(char *).
@param tsid_map The Tsid_map to use for TSIDs.
@param text The text to parse.
@param status Will be set to RETURN_STATUS_OK on success or
RETURN_STATUS_REPORTED_ERROR on error.
@param tsid_lock Read/write lock to protect changes in the number
of SIDs with. This may be NULL if such changes do not need to be
protected.
If tsid_lock != NULL, then the read lock on tsid_lock must be held
before calling this function. If the array is grown, tsid_lock is
temporarily upgraded to a write lock and then degraded again;
there will be a short period when the lock is not held at all.
*/
Gtid_set(Tsid_map *tsid_map, const char *text, enum_return_status *status,
Checkable_rwlock *tsid_lock = nullptr);
private:
/// Worker for the constructor.
void init();
public:
/// Destroy this Gtid_set.
~Gtid_set();
/**
Claim ownership of memory.
@param claim claim ownership of memory.
*/
void claim_memory_ownership(bool claim);
/**
Removes all gtids from this Gtid_set.
This does not deallocate anything: if gtids are added later,
existing allocated memory will be re-used.
*/
void clear();
/**
Removes all gtids from this Gtid_set and clear all the sidnos
used by the Gtid_set and it's TSID map.
This does not deallocate anything: if gtids are added later,
existing allocated memory will be re-used.
*/
void clear_set_and_tsid_map();
/**
Adds the given GTID to this Gtid_set.
The SIDNO must exist in the Gtid_set before this function is called.
@param sidno SIDNO of the GTID to add.
@param gno GNO of the GTID to add.
*/
void _add_gtid(rpl_sidno sidno, rpl_gno gno) {
DBUG_TRACE;
assert(sidno > 0);
assert(gno > 0);
assert(gno < GNO_END);
Interval_iterator ivit(this, sidno);
Free_intervals_lock lock(this);
add_gno_interval(&ivit, gno, gno + 1, &lock);
return;
}
/**
Removes the given GTID from this Gtid_set.
@param sidno SIDNO of the GTID to remove.
@param gno GNO of the GTID to remove.
*/
void _remove_gtid(rpl_sidno sidno, rpl_gno gno) {
DBUG_TRACE;
if (sidno <= get_max_sidno()) {
Interval_iterator ivit(this, sidno);
Free_intervals_lock lock(this);
remove_gno_interval(&ivit, gno, gno + 1, &lock);
}
return;
}
/**
Adds the given GTID to this Gtid_set.
The SIDNO must exist in the Gtid_set before this function is called.
@param gtid Gtid to add.
*/
void _add_gtid(const Gtid &gtid) { _add_gtid(gtid.sidno, gtid.gno); }
/**
Removes the given GTID from this Gtid_set.
@param gtid Gtid to remove.
*/
void _remove_gtid(const Gtid &gtid) { _remove_gtid(gtid.sidno, gtid.gno); }
/**
Adds all gtids from the given Gtid_set to this Gtid_set.
If tsid_lock != NULL, then the read lock must be held before
calling this function. If a new sidno is added so that the array
of lists of intervals is grown, tsid_lock is temporarily upgraded
to a write lock and then degraded again; there will be a short
period when the lock is not held at all.
@param other The Gtid_set to add.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status add_gtid_set(const Gtid_set *other);
/**
Removes all gtids in the given Gtid_set from this Gtid_set.
@param other The Gtid_set to remove.
*/
void remove_gtid_set(const Gtid_set *other);
/**
Removes all intervals of 'other' for a given SIDNO, from 'this'.
Example:
this = A:1-100, B:1-100
other = A:1-100, B:1-50, C:1-100
this.remove_intervals_for_sidno(other, B) = A:1-100, B:51-100
It is not required that the intervals exist in this Gtid_set.
@param other The set to remove.
@param sidno The sidno to remove.
*/
void remove_intervals_for_sidno(Gtid_set *other, rpl_sidno sidno);
/**
Adds the set of GTIDs represented by the given string to this Gtid_set.
The string must have the format of a comma-separated list of zero
or more of the following items:
XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX(:NUMBER+(-NUMBER)?)*
| ANONYMOUS
Each X is a hexadecimal digit (upper- or lowercase).
NUMBER is a decimal, 0xhex, or 0oct number.
The start of an interval must be greater than 0. The end of an
interval may be 0, but any interval that has an endpoint that
is smaller than the start is discarded.
The string can start with an optional '+' appender qualifier
which triggers @c executed_gtids and @c lost_gtids set examination
on the matter of disjointness with the one being added.
If tsid_lock != NULL, then the read lock on tsid_lock must be held
before calling this function. If a new sidno is added so that the
array of lists of intervals is grown, tsid_lock is temporarily
upgraded to a write lock and then degraded again; there will be a
short period when the lock is not held at all.
@param text The string to parse.
@param [in,out] anonymous If this is NULL, ANONYMOUS is not
allowed. If this is not NULL, it will be set to true if the
anonymous GTID was found; false otherwise.
@param[in,out] starts_with_plus If this is not NULL, the string may
optionally begin with a '+' character, and *starts_with_plus will
be set to true if the plus character is present. If this is NULL,
no plus is allowed at the begin of the string.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status add_gtid_text(const char *text, bool *anonymous = nullptr,
bool *starts_with_plus = nullptr);
/// @brief Adds specified GTID (TSID+GNO) to this Gtid_set.
/// @param gtid mysql::gtid::Gtid object
/// @return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
[[NODISCARD]] enum_return_status add_gtid(const mysql::gtid::Gtid &gtid);
/**
Decodes a Gtid_set from the given string.
@param encoded The string to parse.
@param length The number of bytes.
@param actual_length If this is not NULL, it is set to the number
of bytes used by the encoding (which may be less than 'length').
If this is NULL, an error is generated if the encoding is shorter
than the given 'length'.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status add_gtid_encoding(const uchar *encoded, size_t length,
size_t *actual_length = nullptr);
/// Return true iff the given GTID exists in this set.
bool contains_gtid(rpl_sidno sidno, rpl_gno gno) const;
/// Return true iff the given GTID exists in this set.
bool contains_gtid(const Gtid &gtid) const {
return contains_gtid(gtid.sidno, gtid.gno);
}
// Get last gno or 0 if this set is empty.
rpl_gno get_last_gno(rpl_sidno sidno) const;
/// Returns the maximal sidno that this Gtid_set currently has space for.
rpl_sidno get_max_sidno() const {
if (tsid_lock) tsid_lock->assert_some_lock();
return static_cast<rpl_sidno>(m_intervals.size());
}
/**
Allocates space for all sidnos up to the given sidno in the array of
intervals. The sidno must exist in the Tsid_map associated with this
Gtid_set.
If tsid_lock != NULL, then the read lock on tsid_lock must be held
before calling this function. If the array is grown, tsid_lock is
temporarily upgraded to a write lock and then degraded again;
there will be a short period when the lock is not held at all.
@param sidno The SIDNO.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status ensure_sidno(rpl_sidno sidno);
/// Returns true if this Gtid_set is a subset of the other Gtid_set.
bool is_subset(const Gtid_set *super) const;
/// Returns true if this Gtid_set is a non equal subset of the other Gtid_set.
bool is_subset_not_equals(const Gtid_set *super) const {
return (is_subset(super) && !equals(super));
}
/**
Returns true if this Gtid_set is a subset of the given gtid_set
on the given superset_sidno and subset_sidno.
@param super Gtid_set with which this->gtid_set needs to be
compared
@param superset_sidno The sidno that will be compared, relative to
super->tsid_map.
@param subset_sidno The sidno that will be compared, relative to
this->tsid_map.
@return true If 'this' Gtid_set is subset of given
'super' Gtid_set.
false If 'this' Gtid_set is *not* subset of given
'super' Gtid_set.
*/
bool is_subset_for_sidno(const Gtid_set *super, rpl_sidno superset_sidno,
rpl_sidno subset_sidno) const;
/// @brief Returns true if this Gtid_set is a subset of the given gtid_set
/// with respect to the given sid
/// @details This function will traverse all TSIDs with SID equal
/// to "sid" parameter (all registered tags for a given SID)
/// @param super Gtid_set with which this->gtid_set needs to be compared
/// @param sid Sid for which we will do the testing
/// @return True in case super is a superset for this gtid set w.r.t. the
/// given sid; false otherwise
bool is_subset_for_sid(const Gtid_set *super, const rpl_sid &sid) const;
/// Returns true if there is a least one element of this Gtid_set in
/// the other Gtid_set.
bool is_intersection_nonempty(const Gtid_set *other) const;
/**
Add the intersection of this Gtid_set and the other Gtid_set to result.
@param other The Gtid_set to intersect with this Gtid_set
@param result Gtid_set where the result will be stored.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status intersection(const Gtid_set *other, Gtid_set *result);
/// Returns true if this Gtid_set is empty.
bool is_empty() const {
Gtid_iterator git(this);
return git.get().sidno == 0;
}
/**
Return true if the size of the set is greater than or equal to the given
number. The size is measure in number of GTIDs, i.e., total length of all
intervals.
@param num Number to compare with
@retval true if the set contains >= num GTIDs.
@retval false if the set contains < num GTIDs.
*/
bool is_size_greater_than_or_equal(ulonglong num) const;
/**
What is the count of all the GTIDs in all intervals for a sidno
@param sidno The sidno that contains the intervals
@return the number of all GTIDs in all intervals
*/
ulonglong get_gtid_count(rpl_sidno sidno) const {
Const_interval_iterator ivit(this, sidno);
ulonglong ret = 0;
while (ivit.get() != nullptr) {
ret += ivit.get()->end - ivit.get()->start;
ivit.next();
}
return ret;
}
/**
Returns true if this Gtid_set contains at least one GTID with
the given SIDNO.
@param sidno The SIDNO to test.
@retval true The SIDNO is less than or equal to the max SIDNO, and
there is at least one GTID with this SIDNO.
@retval false The SIDNO is greater than the max SIDNO, or there is
no GTID with this SIDNO.
*/
bool contains_sidno(rpl_sidno sidno) const {
assert(sidno >= 1);
if (sidno > get_max_sidno()) return false;
Const_interval_iterator ivit(this, sidno);
return ivit.get() != nullptr;
}
/**
Returns true if the given string is a valid specification of a
Gtid_set, false otherwise.
*/
static bool is_valid(const char *text);
/**
Class Gtid_set::String_format defines the separators used by
Gtid_set::to_string.
*/
struct String_format {
/// The generated string begins with this.
const char *begin;
/// The generated string begins with this.
const char *end;
/// In 'SID:TAG', this is the ':'
const char *tag_sid_separator;
/// In 'TSID:GNO', this is the ':'
const char *tsid_gno_separator;
/// In 'SID:GNO-GNO', this is the '-'
const char *gno_start_end_separator;
/// In 'SID:GNO:GNO', this is the second ':'
const char *gno_gno_separator;
/// In 'SID:GNO,SID:GNO', this is the ','
const char *gno_sid_separator;
/// If the set is empty and this is not NULL, then this string is generated.
const char *empty_set_string;
/// The following fields are the lengths of each field above.
const int begin_length;
const int end_length;
const int tag_sid_separator_length;
const int tsid_gno_separator_length;
const int gno_start_end_separator_length;
const int gno_gno_separator_length;
const int gno_sid_separator_length;
const int empty_set_string_length;
};
/// @brief Checks if this Gtid set contains any tagged GTIDs
/// @retval true This gtid set contains tagged GTIDs
/// @retval false This gtid set contains only untagged GTIDs
bool contains_tags() const;
/**
Returns the length of the output from to_string.
@warning This does not include the trailing '\0', so your buffer
needs space for get_string_length() + 1 characters.
@param string_format String_format object that specifies
separators in the resulting text.
@return The length.
*/
size_t get_string_length(const String_format *string_format = nullptr) const;
/**
Formats this Gtid_set as a string and saves in a given buffer.
@param[out] buf Pointer to the buffer where the string should be
stored. This should have size at least get_string_length()+1.
@param need_lock If this Gtid_set has a tsid_lock, then the write
lock must be held while generating the string. If this parameter
is true, then this function acquires and releases the lock;
otherwise it asserts that the caller holds the lock.
@param string_format String_format object that specifies
separators in the resulting text.
@return Length of the generated string.
*/
size_t to_string(char *buf, bool need_lock = false,
const String_format *string_format = nullptr) const;
/**
Formats a Gtid_set as a string and saves in a newly allocated buffer.
@param[out] buf Pointer to pointer to string. The function will
set it to point to the newly allocated buffer, or NULL on out of memory.
@param need_lock If this Gtid_set has a tsid_lock, then the write
lock must be held while generating the string. If this parameter
is true, then this function acquires and releases the lock;
otherwise it asserts that the caller holds the lock.
@param string_format Specifies how to format the string.
@retval Length of the generated string, or -1 on out of memory.
*/
long to_string(char **buf, bool need_lock = false,
const String_format *string_format = nullptr) const;
#ifndef NDEBUG
/// Debug only: Print this Gtid_set to stdout.
/// For use with C `printf`
void print(bool need_lock = false,
const Gtid_set::String_format *sf = nullptr) const {
char *str;
to_string(&str, need_lock, sf);
printf("%s\n", str ? str : "out of memory in Gtid_set::print");
my_free(str);
}
/// For use with C++ `std::ostream`
inline friend std::ostream &operator<<(std::ostream &os, const Gtid_set &in) {
char *str;
in.to_string(&str, true, nullptr);
os << std::string(str) << std::flush;
my_free(str);
return os;
}
#endif
/**
Print this Gtid_set to the trace file if debug is enabled; no-op
otherwise.
*/
void dbug_print(const char *text [[maybe_unused]] = "",
bool need_lock [[maybe_unused]] = false,
const Gtid_set::String_format *sf
[[maybe_unused]] = nullptr) const {
#ifndef NDEBUG
char *str;
to_string(&str, need_lock, sf);
DBUG_PRINT("info", ("%s%s'%s'", text, *text ? ": " : "",
str ? str : "out of memory in Gtid_set::dbug_print"));
my_free(str);
#endif
}
/**
Gets all gtid intervals from this Gtid_set.
@param[out] gtid_intervals Store all gtid intervals from this Gtid_set.
*/
void get_gtid_intervals(std::list<Gtid_interval> *gtid_intervals) const;
/**
The default String_format: the format understood by
add_gtid_text(const char *).
*/
static const String_format default_string_format;
/**
String_format useful to generate an SQL string: the string is
wrapped in single quotes and there is a newline between SIDs.
*/
static const String_format sql_string_format;
/**
String_format for printing the Gtid_set commented: the string is
not quote-wrapped, and every TSID is on a new line with a leading '# '.
*/
static const String_format commented_string_format;
/// Return the Tsid_map associated with this Gtid_set.
Tsid_map *get_tsid_map() const { return tsid_map; }
/**
Represents one element in the linked list of intervals associated
with a SIDNO.
*/
struct Interval {
public:
/// The first GNO of this interval.
rpl_gno start;
/// The first GNO after this interval.
rpl_gno end;
/// Return true iff this interval is equal to the given interval.
bool equals(const Interval &other) const {
return start == other.start && end == other.end;
}
/// Pointer to next interval in list.
Interval *next;
};
/**
Provides an array of Intervals that this Gtid_set can use when
gtids are subsequently added. This can be used as an
optimization, to reduce allocation for sets that have a known
number of intervals.
@param n_intervals The number of intervals to add.
@param intervals_param Array of n_intervals intervals.
*/
void add_interval_memory(int n_intervals, Interval *intervals_param) {
if (tsid_lock != nullptr) mysql_mutex_lock(&free_intervals_mutex);
add_interval_memory_lock_taken(n_intervals, intervals_param);
if (tsid_lock != nullptr) mysql_mutex_unlock(&free_intervals_mutex);
}
/**
Iterator over intervals for a given SIDNO.
This is an abstract template class, used as a common base class
for Const_interval_iterator and Interval_iterator.
The iterator always points to an interval pointer. The interval
pointer is either the initial pointer into the list, or the next
pointer of one of the intervals in the list.
*/
template <typename Gtid_set_p, typename Interval_p>
class Interval_iterator_base {
public:
/**
Construct a new iterator over the GNO intervals for a given Gtid_set.
@param gtid_set The Gtid_set.
@param sidno The SIDNO.
*/
Interval_iterator_base(Gtid_set_p gtid_set, rpl_sidno sidno) {
assert(sidno >= 1 && sidno <= gtid_set->get_max_sidno());
init(gtid_set, sidno);
}
/// Construct a new iterator over the free intervals of a Gtid_set.
Interval_iterator_base(Gtid_set_p gtid_set) {
p = const_cast<Interval_p *>(&gtid_set->free_intervals);
}
/// Reset this iterator.
inline void init(Gtid_set_p gtid_set, rpl_sidno sidno) {
p = const_cast<Interval_p *>(&gtid_set->m_intervals[sidno - 1]);
}
/// Advance current_elem one step.
inline void next() {
assert(*p != nullptr);
p = const_cast<Interval_p *>(&(*p)->next);
}
/// Return current_elem.
inline Interval_p get() const { return *p; }
protected:
/**
Holds the address of the 'next' pointer of the previous element,
or the address of the initial pointer into the list, if the
current element is the first element.
*/
Interval_p *p;
};
/**
Iterator over intervals of a const Gtid_set.
*/
class Const_interval_iterator
: public Interval_iterator_base<const Gtid_set *, const Interval *> {
public:
/// Create this Const_interval_iterator.
Const_interval_iterator(const Gtid_set *gtid_set, rpl_sidno sidno)
: Interval_iterator_base<const Gtid_set *, const Interval *>(gtid_set,
sidno) {}
/// Create this Const_interval_iterator.
Const_interval_iterator(const Gtid_set *gtid_set)
: Interval_iterator_base<const Gtid_set *, const Interval *>(gtid_set) {
}
};
/**
Iterator over intervals of a non-const Gtid_set, with additional
methods to modify the Gtid_set.
*/
class Interval_iterator
: public Interval_iterator_base<Gtid_set *, Interval *> {
public:
/// Create this Interval_iterator.
Interval_iterator(Gtid_set *gtid_set, rpl_sidno sidno)
: Interval_iterator_base<Gtid_set *, Interval *>(gtid_set, sidno) {}
/// Destroy this Interval_iterator.
Interval_iterator(Gtid_set *gtid_set)
: Interval_iterator_base<Gtid_set *, Interval *>(gtid_set) {}
private:
/**
Set current_elem to the given Interval but do not touch the
next pointer of the given Interval.
*/
inline void set(Interval *iv) { *p = iv; }
/// Insert the given element before current_elem.
inline void insert(Interval *iv) {
iv->next = *p;
set(iv);
}
/// Remove current_elem.
inline void remove(Gtid_set *gtid_set) {
assert(get() != nullptr);
Interval *next = (*p)->next;
gtid_set->put_free_interval(*p);
set(next);
}
/**
Only Gtid_set is allowed to use set/insert/remove.
They are not safe to use from other code because: (1) very easy
to make a mistakes (2) they don't clear cached_string_format or
cached_string_length.
*/
friend class Gtid_set;
};
/**
Iterator over all gtids in a Gtid_set. This is a const
iterator; it does not allow modification of the Gtid_set.
*/
class Gtid_iterator {
public:
Gtid_iterator(const Gtid_set *gs) : gtid_set(gs), sidno(0), ivit(gs) {
if (gs->tsid_lock != nullptr) gs->tsid_lock->assert_some_wrlock();
next_sidno();
}
/// Advance to next gtid.
inline void next() {
assert(gno > 0 && sidno > 0);
// go to next GTID in current interval
gno++;
// end of interval? then go to next interval for this sidno
if (gno == ivit.get()->end) {
ivit.next();
const Interval *iv = ivit.get();
// last interval for this sidno? then go to next sidno
if (iv == nullptr) {
next_sidno();
// last sidno? then don't try more
if (sidno == 0) return;
iv = ivit.get();
}
gno = iv->start;
}
}
/// Return next gtid, or {0,0} if we reached the end.
inline Gtid get() const {
Gtid ret = {sidno, gno};
return ret;
}
private:
/// Find the next sidno that has one or more intervals.
inline void next_sidno() {
const Interval *iv;
do {
sidno++;
if (sidno > gtid_set->get_max_sidno()) {
sidno = 0;
gno = 0;
return;
}
ivit.init(gtid_set, sidno);
iv = ivit.get();
} while (iv == nullptr);
gno = iv->start;
}
/// The Gtid_set we iterate over.
const Gtid_set *gtid_set;
/**
The SIDNO of the current element, or 0 if the iterator is past
the last element.
*/
rpl_sidno sidno;
/**
The GNO of the current element, or 0 if the iterator is past the
last element.
*/
rpl_gno gno;
/// Iterator over the intervals for the current SIDNO.
Const_interval_iterator ivit;
};
public:
/// @brief Encodes this Gtid_set as a binary string.
/// @param buf Buffer to write into
/// @param skip_tagged_gtids When true, tagged GTIDS will be filtered out
void encode(uchar *buf, bool skip_tagged_gtids = false) const;
/// @brief Returns the length of this Gtid_set when encoded using the
/// encode() function. Before calculation, analyzes GTID set format
/// @param skip_tagged_gtids When true, tagged GTIDS will be filtered out
/// @return length of Gtid_set encoding
size_t get_encoded_length(bool skip_tagged_gtids = false) const;
/// Returns the length of this Gtid_set when encoded using the
/// encode() function. Uses already analyzed GTID set format (faster version)
/// @param format Gtid format
/// @param skip_tagged_gtids When true, tagged GTIDS will be filtered out
/// @return Encoded gtid_set length
std::size_t get_encoded_length(const mysql::gtid::Gtid_format &format,
bool skip_tagged_gtids) const;
/// Returns true if this Gtid_set is equal to the other Gtid_set.
/// @param[in] other Gtid set to compare against
/// @return true in case gtid sets contain the same GTIDs
bool equals(const Gtid_set *other) const;
private:
/**
Contains a list of intervals allocated by this Gtid_set. When a
method of this class needs a new interval and there are no more
free intervals, a new Interval_chunk is allocated and the
intervals of it are added to the list of free intervals.
*/
struct Interval_chunk {
Interval_chunk *next;
Interval intervals[1];
};
/// The default number of intervals in an Interval_chunk.
static const int CHUNK_GROW_SIZE = 8;
/**
Return true if the given sidno of this Gtid_set contains the same
intervals as the given sidno of the other Gtid_set.
@param sidno SIDNO to check for this Gtid_set.
@param other Other Gtid_set
@param other_sidno SIDNO to check in other.
@return true if equal, false is not equal.
*/
bool sidno_equals(rpl_sidno sidno, const Gtid_set *other,
rpl_sidno other_sidno) const;
/// Return the number of intervals for the given sidno.
int get_n_intervals(rpl_sidno sidno) const {
Const_interval_iterator ivit(this, sidno);
int ret = 0;
while (ivit.get() != nullptr) {
ret++;
ivit.next();
}
return ret;
}
/// Return the number of intervals in this Gtid_set.
int get_n_intervals() const {
if (tsid_lock != nullptr) tsid_lock->assert_some_wrlock();
rpl_sidno max_sidno = get_max_sidno();
int ret = 0;
for (rpl_sidno sidno = 1; sidno < max_sidno; sidno++)
ret += get_n_intervals(sidno);
return ret;
}
/// @brief Goes through recorded tsids. In case any of the TSIDs has a tag,
/// this function will return Gtid_format::tagged. Otherwise, it will
/// return Gtid_format::untagged
/// @param skip_tagged_gtids When true, function will always return
/// Gtid_format::untagged
/// @returns Gtid encoding format
mysql::gtid::Gtid_format analyze_encoding_format(
bool skip_tagged_gtids) const;
/**
Allocates a new chunk of Intervals and adds them to the list of
unused intervals.
@param size The number of intervals in this chunk
*/
void create_new_chunk(int size);
/**
Returns a fresh new Interval object.
This usually does not require any real allocation, it only pops
the first interval from the list of free intervals. If there are
no free intervals, it calls create_new_chunk.
@param out The resulting Interval* will be stored here.
*/
void get_free_interval(Interval **out);
/**
Puts the given interval in the list of free intervals. Does not
unlink it from its place in any other list.
*/
void put_free_interval(Interval *iv);
/**
Like add_interval_memory, but does not acquire
free_intervals_mutex.
@see Gtid_set::add_interval_memory
*/
void add_interval_memory_lock_taken(int n_ivs, Interval *ivs);
/// Read-write lock that protects updates to the number of TSIDs.
mutable Checkable_rwlock *tsid_lock;
/**
Lock protecting the list of free intervals. This lock is only
used if tsid_lock is not NULL.
*/
mysql_mutex_t free_intervals_mutex;
/**
Class representing a lock on free_intervals_mutex.
This is used by the add_* and remove_* functions. The lock is
declared by the top-level function and a pointer to the lock is
passed down to low-level functions. If the low-level function
decides to access the free intervals list, then it acquires the
lock. The lock is then automatically released by the destructor
when the top-level function returns.
The lock is not taken if Gtid_set->tsid_lock == NULL; such
Gtid_sets are assumed to be thread-local.
*/
class Free_intervals_lock {
public:
/// Create a new lock, but do not acquire it.
Free_intervals_lock(Gtid_set *_gtid_set)
: gtid_set(_gtid_set), locked(false) {}
/// Lock the lock if it is not already locked.
void lock_if_not_locked() {
if (gtid_set->tsid_lock && !locked) {
mysql_mutex_lock(&gtid_set->free_intervals_mutex);
locked = true;
}
}
/// Lock the lock if it is locked.
void unlock_if_locked() {
if (gtid_set->tsid_lock && locked) {
mysql_mutex_unlock(&gtid_set->free_intervals_mutex);
locked = false;
}
}
/// Destroy this object and unlock the lock if it is locked.
~Free_intervals_lock() { unlock_if_locked(); }
private:
Gtid_set *gtid_set;
bool locked;
};
void assert_free_intervals_locked() {
if (tsid_lock != nullptr) mysql_mutex_assert_owner(&free_intervals_mutex);
}
/**
Adds the interval (start, end) to the given Interval_iterator.
This is the lowest-level function that adds gtids; this is where
Interval objects are added, grown, or merged.
@param ivitp Pointer to iterator. After this function returns,
the current_element of the iterator will be the interval that
contains start and end.
@param start The first GNO in the interval.
@param end The first GNO after the interval.
@param lock If this function has to add or remove an interval,
then this lock will be taken unless it is already taken. This
mechanism means that the lock will be taken lazily by
e.g. add_gtid_set() the first time that the list of free intervals
is accessed, and automatically released when add_gtid_set()
returns.
*/
void add_gno_interval(Interval_iterator *ivitp, rpl_gno start, rpl_gno end,
Free_intervals_lock *lock);
/**
Removes the interval (start, end) from the given
Interval_iterator. This is the lowest-level function that removes
gtids; this is where Interval objects are removed, truncated, or
split.
It is not required that the gtids in the interval exist in this
Gtid_set.
@param ivitp Pointer to iterator. After this function returns,
the current_element of the iterator will be the next interval
after end.
@param start The first GNO in the interval.
@param end The first GNO after the interval.
@param lock If this function has to add or remove an interval,
then this lock will be taken unless it is already taken. This
mechanism means that the lock will be taken lazily by
e.g. add_gtid_set() the first time that the list of free intervals
is accessed, and automatically released when add_gtid_set()
returns.
*/
void remove_gno_interval(Interval_iterator *ivitp, rpl_gno start, rpl_gno end,
Free_intervals_lock *lock);
/**
Adds a list of intervals to the given SIDNO.
The SIDNO must exist in the Gtid_set before this function is called.
@param sidno The SIDNO to which intervals will be added.
@param ivit Iterator over the intervals to add. This is typically
an iterator over some other Gtid_set.
@param lock If this function has to add or remove an interval,
then this lock will be taken unless it is already taken. This
mechanism means that the lock will be taken lazily by
e.g. add_gtid_set() the first time that the list of free intervals
is accessed, and automatically released when add_gtid_set()
returns.
*/
void add_gno_intervals(rpl_sidno sidno, Const_interval_iterator ivit,
Free_intervals_lock *lock);
/**
Removes a list of intervals from the given SIDNO.
It is not required that the intervals exist in this Gtid_set.
@param sidno The SIDNO from which intervals will be removed.
@param ivit Iterator over the intervals to remove. This is typically
an iterator over some other Gtid_set.
@param lock If this function has to add or remove an interval,
then this lock will be taken unless it is already taken. This
mechanism means that the lock will be taken lazily by
e.g. add_gtid_set() the first time that the list of free intervals
is accessed, and automatically released when add_gtid_set()
returns.
*/
void remove_gno_intervals(rpl_sidno sidno, Const_interval_iterator ivit,
Free_intervals_lock *lock);
/// Returns true if every interval of sub is a subset of some
/// interval of super.
static bool is_interval_subset(Const_interval_iterator *sub,
Const_interval_iterator *super);
/// Returns true if at least one sidno in ivit1 is also in ivit2.
static bool is_interval_intersection_nonempty(Const_interval_iterator *ivit1,
Const_interval_iterator *ivit2);
/// Tsid_map associated with this Gtid_set.
Tsid_map *tsid_map;
/**
Array where the N'th element contains the head pointer to the
intervals of SIDNO N+1.
*/
Prealloced_array<Interval *, 8> m_intervals;
/// Linked list of free intervals.
Interval *free_intervals;
/// Linked list of chunks.
Interval_chunk *chunks;
/// If the string is cached.
mutable bool has_cached_string_length;
/// The string length.
mutable size_t cached_string_length;
/// The String_format that was used when cached_string_length was computed.
mutable const String_format *cached_string_format;
#ifndef NDEBUG
/**
The number of chunks. Used only to check some invariants when
DBUG is on.
*/
int n_chunks;
#endif
/// Used by unit tests that need to access private members.
#ifdef FRIEND_OF_GTID_SET
friend FRIEND_OF_GTID_SET;
#endif
/// Only Free_intervals_lock is allowed to access free_intervals_mutex.
friend class Gtid_set::Free_intervals_lock;
};
/**
Holds information about a Gtid_set. Can also be NULL.
This is used as backend storage for @@session.gtid_next_list. The
idea is that we allow the user to set this to NULL, but we keep the
Gtid_set object so that we can re-use the allocated memory and
avoid costly allocations later.
This is stored in struct system_variables (defined in sql_class.h),
which is cleared using memset(0); hence the negated form of
is_non_null.
The convention is: if is_non_null is false, then the value of the
session variable is NULL, and the field gtid_set may be NULL or
non-NULL. If is_non_null is true, then the value of the session
variable is not NULL, and the field gtid_set has to be non-NULL.
This is a POD. It has to be a POD because it is stored in
THD::variables.
*/
struct Gtid_set_or_null {
/// Pointer to the Gtid_set.
Gtid_set *gtid_set;
/// True if this Gtid_set is NULL.
bool is_non_null;
/// Return NULL if this is NULL, otherwise return the Gtid_set.
inline Gtid_set *get_gtid_set() const {
assert(!(is_non_null && gtid_set == nullptr));
return is_non_null ? gtid_set : nullptr;
}
/**
Do nothing if this object is non-null; set to empty set otherwise.
@return NULL if out of memory; Gtid_set otherwise.
*/
Gtid_set *set_non_null(Tsid_map *sm) {
if (!is_non_null) {
if (gtid_set == nullptr)
gtid_set = new Gtid_set(sm);
else
gtid_set->clear();
}
is_non_null = (gtid_set != nullptr);
return gtid_set;
}
/// Set this Gtid_set to NULL.
inline void set_null() { is_non_null = false; }
};
/**
Represents the set of GTIDs that are owned by some thread.
This data structure has a read-write lock that protects the number
of SIDNOs. The lock is provided by the invoker of the constructor
and it is generally the caller's responsibility to acquire the read
lock. Access methods assert that the caller already holds the read
(or write) lock. If a method of this class grows the number of
SIDNOs, then the method temporarily upgrades this lock to a write
lock and then degrades it to a read lock again; there will be a
short period when the lock is not held at all.
The internal representation is a multi-valued map from GTIDs to
threads, mapping GTIDs to one or more threads that owns it.
In Group Replication multiple threads can own a GTID whereas if GR
is disabeld there is at most one owner per GTID.
*/
class Owned_gtids {
public:
/**
Constructs a new, empty Owned_gtids object.
@param tsid_lock Read-write lock that protects updates to the
number of TSIDs.
*/
Owned_gtids(Checkable_rwlock *tsid_lock);
/// Destroys this Owned_gtids.
~Owned_gtids();
/**
Add a GTID to this Owned_gtids.
@param gtid The Gtid to add.
@param owner The my_thread_id of the gtid to add.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status add_gtid_owner(const Gtid &gtid, my_thread_id owner);
/*
Fill all gtids into the given Gtid_set object. It doesn't clear the given
gtid set before filling its owned gtids into it.
*/
void get_gtids(Gtid_set &gtid_set) const;
/**
Removes the given GTID.
If the gtid does not exist in this Owned_gtids object, does
nothing.
@param gtid The Gtid.
@param owner thread_id of the owner thread
*/
void remove_gtid(const Gtid &gtid, const my_thread_id owner);
/**
Ensures that this Owned_gtids object can accommodate SIDNOs up to
the given SIDNO.
If this Owned_gtids object needs to be resized, then the lock
will be temporarily upgraded to a write lock and then degraded to
a read lock again; there will be a short period when the lock is
not held at all.
@param sidno The SIDNO.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status ensure_sidno(rpl_sidno sidno);
/// Returns true if there is a least one element of this Owned_gtids
/// set in the other Gtid_set.
bool is_intersection_nonempty(const Gtid_set *other) const;
/// Returns true if this Owned_gtids is empty.
bool is_empty() const {
Gtid_iterator git(this);
return git.get().sidno == 0;
}
/// Returns the maximal sidno that this Owned_gtids currently has space for.
rpl_sidno get_max_sidno() const {
if (tsid_lock != nullptr) {
tsid_lock->assert_some_lock();
}
return static_cast<rpl_sidno>(sidno_to_hash.size());
}
/**
Write a string representation of this Owned_gtids to the given buffer.
@param out Buffer to write to.
@return Number of characters written.
*/
int to_string(char *out) const {
char *p = out;
rpl_sidno max_sidno = get_max_sidno();
for (const auto &sid_it : global_tsid_map->get_sorted_sidno()) {
rpl_sidno sidno = sid_it.second;
if (sidno > max_sidno) continue;
bool printed_sid = false;
for (const auto &key_and_value : *get_hash(sidno)) {
Node *node = key_and_value.second.get();
assert(node != nullptr);
if (!printed_sid) {
p += global_tsid_map->sidno_to_tsid(sidno).to_string(p);
printed_sid = true;
}
p += sprintf(p, ":%" PRId64 "#%u", node->gno, node->owner);
}
}
*p = 0;
return (int)(p - out);
}
/**
Return an upper bound on the length of the string representation
of this Owned_gtids. The actual length may be smaller. This
includes the trailing '\0'.
*/
size_t get_max_string_length() const {
rpl_sidno max_sidno = get_max_sidno();
size_t ret = 0;
for (rpl_sidno sidno = 1; sidno <= max_sidno; sidno++) {
size_t records = get_hash(sidno)->size();
if (records > 0)
ret +=
mysql::gtid::tsid_max_length +
records * (1 + MAX_GNO_TEXT_LENGTH + 1 + MAX_THREAD_ID_TEXT_LENGTH);
}
return 1 + ret;
}
/**
Return true if the given thread is the owner of any gtids.
*/
bool thread_owns_anything(my_thread_id thd_id) const {
Gtid_iterator git(this);
Node *node = git.get_node();
while (node != nullptr) {
if (node->owner == thd_id) return true;
git.next();
node = git.get_node();
}
return false;
}
#ifndef NDEBUG
/**
Debug only: return a newly allocated string representation of
this Owned_gtids.
*/
char *to_string() const {
char *str = (char *)my_malloc(key_memory_Owned_gtids_to_string,
get_max_string_length(), MYF(MY_WME));
assert(str != nullptr);
to_string(str);
return str;
}
/// Debug only: print this Owned_gtids to stdout.
void print() const {
char *str = to_string();
printf("%s\n", str);
my_free(str);
}
#endif
/**
Print this Owned_gtids to the trace file if debug is enabled; no-op
otherwise.
*/
void dbug_print(const char *text [[maybe_unused]] = "") const {
#ifndef NDEBUG
char *str = to_string();
DBUG_PRINT("info", ("%s%s%s", text, *text ? ": " : "", str));
my_free(str);
#endif
}
/**
If thd_id==0, returns true when gtid is not owned by any thread.
If thd_id!=0, returns true when gtid is owned by that thread.
*/
bool is_owned_by(const Gtid &gtid, const my_thread_id thd_id) const;
private:
/// Represents one owned GTID.
struct Node {
/// GNO of the GTID.
rpl_gno gno;
/// Owner of the GTID.
my_thread_id owner;
};
/// Read-write lock that protects updates to the number of TSIDs.
mutable Checkable_rwlock *tsid_lock;
/// Returns the hash for the given SIDNO.
malloc_unordered_multimap<rpl_gno, unique_ptr_my_free<Node>> *get_hash(
rpl_sidno sidno) const {
assert(sidno >= 1 && sidno <= get_max_sidno());
if (tsid_lock != nullptr) {
tsid_lock->assert_some_lock();
}
return sidno_to_hash[sidno - 1];
}
/// Return true iff this Owned_gtids object contains the given gtid.
bool contains_gtid(const Gtid &gtid) const;
/// Growable array of hashes.
Prealloced_array<
malloc_unordered_multimap<rpl_gno, unique_ptr_my_free<Node>> *, 8>
sidno_to_hash;
public:
/**
Iterator over all gtids in a Owned_gtids set. This is a const
iterator; it does not allow modification of the set.
*/
class Gtid_iterator {
public:
Gtid_iterator(const Owned_gtids *og)
: owned_gtids(og), sidno(1), hash(nullptr), node(nullptr) {
max_sidno = owned_gtids->get_max_sidno();
if (sidno <= max_sidno) {
hash = owned_gtids->get_hash(sidno);
node_it = hash->begin();
}
next();
}
/// Advance to next GTID.
inline void next() {
#ifndef NDEBUG
if (owned_gtids->tsid_lock) owned_gtids->tsid_lock->assert_some_wrlock();
#endif
while (sidno <= max_sidno) {
assert(hash != nullptr);
if (node_it != hash->end()) {
node = node_it->second.get();
assert(node != nullptr);
// Jump to next node on next iteration.
++node_it;
return;
}
// hash is initialized on constructor or in previous iteration
// for current SIDNO, so we must increment for next iteration.
sidno++;
if (sidno <= max_sidno) {
hash = owned_gtids->get_hash(sidno);
node_it = hash->begin();
}
}
node = nullptr;
}
/// Return next GTID, or {0,0} if we reached the end.
inline Gtid get() const {
Gtid ret = {0, 0};
if (node) {
ret.sidno = sidno;
ret.gno = node->gno;
}
return ret;
}
/// Return the current GTID Node, or NULL if we reached the end.
inline Node *get_node() const { return node; }
private:
/// The Owned_gtids set we iterate over.
const Owned_gtids *owned_gtids;
/// The SIDNO of the current element, or 1 in the initial iteration.
rpl_sidno sidno;
/// Max SIDNO of the current iterator.
rpl_sidno max_sidno;
/// Current SIDNO hash.
malloc_unordered_multimap<rpl_gno, unique_ptr_my_free<Node>> *hash;
/// Current node iterator on current SIDNO hash.
malloc_unordered_multimap<rpl_gno, unique_ptr_my_free<Node>>::const_iterator
node_it;
/// Current node on current SIDNO hash.
Node *node;
};
};
/**
Represents the server's GTID state: the set of committed GTIDs, the
set of lost gtids, the set of owned gtids, the owner of each owned
gtid, and a Mutex_cond_array that protects updates to gtids of
each SIDNO.
Locking:
This data structure has a read-write lock that protects the number
of SIDNOs, and a Mutex_cond_array that contains one mutex per SIDNO.
The rwlock is always the global_tsid_lock.
Access methods generally assert that the caller already holds the
appropriate lock:
- before accessing any global data, hold at least the rdlock.
- before accessing a specific SIDNO in a Gtid_set or Owned_gtids
(e.g., calling Gtid_set::_add_gtid(Gtid)), hold either the rdlock
and the SIDNO's mutex lock; or the wrlock. If you need to hold
multiple mutexes, they must be acquired in order of increasing
SIDNO.
- before starting an operation that needs to access all SIDs
(e.g. Gtid_set::to_string()), hold the wrlock.
The access type (read/write) does not matter; the write lock only
implies that the entire data structure is locked whereas the read
lock implies that everything except TSID-specific data is locked.
*/
class Gtid_state {
public:
/**
Constructs a new Gtid_state object.
@param _tsid_lock Read-write lock that protects updates to the
number of TSIDs.
@param _tsid_map Tsid_map used by this Gtid_state.
*/
Gtid_state(Checkable_rwlock *_tsid_lock, Tsid_map *_tsid_map)
: tsid_lock(_tsid_lock),
tsid_map(_tsid_map),
tsid_locks(tsid_lock),
lost_gtids(tsid_map, tsid_lock),
executed_gtids(tsid_map, tsid_lock),
gtids_only_in_table(tsid_map, tsid_lock),
previous_gtids_logged(tsid_map, tsid_lock),
owned_gtids(tsid_lock),
commit_group_sidnos(key_memory_Gtid_state_group_commit_sidno) {}
/**
Add @@GLOBAL.SERVER_UUID to this binlog's Tsid_map.
This can't be done in the constructor because the constructor is
invoked at server startup before SERVER_UUID is initialized.
The caller must hold the read lock or write lock on tsid_locks
before invoking this function.
@retval 0 Success
@retval 1 Error (out of memory or IO error).
*/
int init();
/**
Reset the state and persistor after RESET BINARY LOGS AND GTIDS:
remove all logged and lost gtids, but keep owned gtids as they are.
The caller must hold the write lock on tsid_lock before calling
this function.
@param thd Thread requesting to reset the persistor
@retval 0 Success
@retval -1 Error
*/
int clear(THD *thd);
/**
Returns true if the given GTID is logged.
@param gtid The Gtid to check.
@retval true The gtid is logged in the binary log.
@retval false The gtid is not logged in the binary log.
*/
bool is_executed(const Gtid &gtid) const {
DBUG_TRACE;
tsid_locks.assert_owner(gtid.sidno);
bool ret = executed_gtids.contains_gtid(gtid);
return ret;
}
/**
Returns true if GTID is owned, otherwise returns 0.
@param gtid The Gtid to check.
@return true if some thread owns the gtid, false if the gtid is
not owned
*/
bool is_owned(const Gtid &gtid) const {
return !owned_gtids.is_owned_by(gtid, 0);
}
#ifdef MYSQL_SERVER
/**
Acquires ownership of the given GTID, on behalf of the given thread.
The caller must lock the SIDNO before invoking this function.
@param thd The thread that will own the GTID.
@param gtid The Gtid to acquire ownership of.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status acquire_ownership(THD *thd, const Gtid &gtid);
/**
This function updates both the THD and the Gtid_state to reflect that
the transaction set of transactions has ended, and it does this for the
whole commit group (by following the thd->next_to_commit pointer).
It will:
- Clean up the thread state when a thread owned GTIDs is empty.
- Release ownership of all GTIDs owned by the THDs. This removes
the GTIDs from Owned_gtids and clears the ownership status in the
THDs object.
- Add the owned GTIDs to executed_gtids when the thread is committing.
- Decrease counters of GTID-violating transactions.
- Send a broadcast on the condition variable for every sidno for
which we released ownership.
@param first_thd The first thread of the group commit that needs GTIDs to
be updated.
*/
void update_commit_group(THD *first_thd);
/**
Remove the GTID owned by thread from owned GTIDs, stating that
thd->owned_gtid was committed.
This will:
- remove owned GTID from owned_gtids;
- remove all owned GTIDS from thd->owned_gtid and thd->owned_gtid_set;
@param thd Thread for which owned gtids are updated.
*/
void update_on_commit(THD *thd);
/**
Update the state after the given thread has rollbacked.
This will:
- release ownership of all GTIDs owned by the THD;
- remove owned GTID from owned_gtids;
- remove all owned GTIDS from thd->owned_gtid and thd->owned_gtid_set;
- send a broadcast on the condition variable for every sidno for
which we released ownership.
@param thd Thread for which owned gtids are updated.
*/
void update_on_rollback(THD *thd);
/**
Acquire anonymous ownership.
The caller must hold either tsid_lock.rdlock or
tsid_lock.wrlock. (The caller must have taken the lock and checked
that gtid_mode!=ON before calling this function, or else the
gtid_mode could have changed to ON by a concurrent SET GTID_MODE.)
*/
void acquire_anonymous_ownership() {
DBUG_TRACE;
tsid_lock->assert_some_lock();
assert(global_gtid_mode.get() != Gtid_mode::ON);
#ifndef NDEBUG
int32 new_value =
#endif
++atomic_anonymous_gtid_count;
DBUG_PRINT("info",
("atomic_anonymous_gtid_count increased to %d", new_value));
assert(new_value >= 1);
return;
}
/// Release anonymous ownership.
void release_anonymous_ownership() {
DBUG_TRACE;
tsid_lock->assert_some_lock();
assert(global_gtid_mode.get() != Gtid_mode::ON);
#ifndef NDEBUG
int32 new_value =
#endif
--atomic_anonymous_gtid_count;
DBUG_PRINT("info",
("atomic_anonymous_gtid_count decreased to %d", new_value));
assert(new_value >= 0);
return;
}
/// Return the number of clients that hold anonymous ownership.
int32 get_anonymous_ownership_count() { return atomic_anonymous_gtid_count; }
/**
Increase the global counter when starting a GTID-violating
transaction having GTID_NEXT=AUTOMATIC.
*/
void begin_automatic_gtid_violating_transaction() {
DBUG_TRACE;
assert(global_gtid_mode.get() <= Gtid_mode::OFF_PERMISSIVE);
assert(get_gtid_consistency_mode() != GTID_CONSISTENCY_MODE_ON);
#ifndef NDEBUG
int32 new_value =
#endif
++atomic_automatic_gtid_violation_count;
DBUG_PRINT(
"info",
("ongoing_automatic_gtid_violating_transaction_count increased to %d",
new_value));
assert(new_value >= 1);
return;
}
/**
Decrease the global counter when ending a GTID-violating
transaction having GTID_NEXT=AUTOMATIC.
*/
void end_automatic_gtid_violating_transaction() {
DBUG_TRACE;
#ifndef NDEBUG
global_tsid_lock->rdlock();
assert(global_gtid_mode.get() <= Gtid_mode::OFF_PERMISSIVE);
assert(get_gtid_consistency_mode() != GTID_CONSISTENCY_MODE_ON);
global_tsid_lock->unlock();
int32 new_value =
#endif
--atomic_automatic_gtid_violation_count;
DBUG_PRINT(
"info",
("ongoing_automatic_gtid_violating_transaction_count decreased to %d",
new_value));
assert(new_value >= 0);
return;
}
/**
Return the number of ongoing GTID-violating transactions having
GTID_NEXT=AUTOMATIC.
*/
int32 get_automatic_gtid_violating_transaction_count() {
return atomic_automatic_gtid_violation_count;
}
/**
Increase the global counter when starting a GTID-violating
transaction having GTID_NEXT=ANONYMOUS.
*/
void begin_anonymous_gtid_violating_transaction() {
DBUG_TRACE;
assert(global_gtid_mode.get() != Gtid_mode::ON);
assert(get_gtid_consistency_mode() != GTID_CONSISTENCY_MODE_ON);
#ifndef NDEBUG
int32 new_value =
#endif
++atomic_anonymous_gtid_violation_count;
DBUG_PRINT("info", ("atomic_anonymous_gtid_violation_count increased to %d",
new_value));
assert(new_value >= 1);
return;
}
/**
Decrease the global counter when ending a GTID-violating
transaction having GTID_NEXT=ANONYMOUS.
*/
void end_anonymous_gtid_violating_transaction() {
DBUG_TRACE;
#ifndef NDEBUG
global_tsid_lock->rdlock();
assert(global_gtid_mode.get() != Gtid_mode::ON);
assert(get_gtid_consistency_mode() != GTID_CONSISTENCY_MODE_ON);
global_tsid_lock->unlock();
int32 new_value =
#endif
--atomic_anonymous_gtid_violation_count;
DBUG_PRINT(
"info",
("ongoing_anonymous_gtid_violating_transaction_count decreased to %d",
new_value));
assert(new_value >= 0);
return;
}
void end_gtid_violating_transaction(THD *thd);
/**
Return the number of ongoing GTID-violating transactions having
GTID_NEXT=AUTOMATIC.
*/
int32 get_anonymous_gtid_violating_transaction_count() {
return atomic_anonymous_gtid_violation_count;
}
/**
Increase the global counter when starting a call to
WAIT_FOR_EXECUTED_GTID_SET.
*/
void begin_gtid_wait() {
DBUG_TRACE;
assert(global_gtid_mode.get() != Gtid_mode::OFF);
#ifndef NDEBUG
int32 new_value =
#endif
++atomic_gtid_wait_count;
DBUG_PRINT("info", ("atomic_gtid_wait_count changed from %d to %d",
new_value - 1, new_value));
assert(new_value >= 1);
return;
}
/**
Decrease the global counter when ending a call to
WAIT_FOR_EXECUTED_GTID_SET.
*/
void end_gtid_wait() {
DBUG_TRACE;
assert(global_gtid_mode.get() != Gtid_mode::OFF);
#ifndef NDEBUG
int32 new_value =
#endif
--atomic_gtid_wait_count;
DBUG_PRINT("info", ("atomic_gtid_wait_count changed from %d to %d",
new_value + 1, new_value));
assert(new_value >= 0);
return;
}
/**
Return the number of clients that have an ongoing call to
WAIT_FOR_EXECUTED_GTID_SET.
*/
int32 get_gtid_wait_count() { return atomic_gtid_wait_count; }
#endif // ifdef MYSQL_SERVER
/**
Computes the next available GNO.
@param sidno The GTID's SIDNO.
@retval -1 The range of GNOs was exhausted (i.e., more than 1<<63-1
GTIDs with the same UUID have been generated).
@retval >0 The GNO for the GTID.
*/
rpl_gno get_automatic_gno(rpl_sidno sidno) const;
private:
/**
The next_free_gno map contains next_free_gno for recorded sidnos.
The next_free_gno variable will be set with the supposed next free GNO
every time a new GNO is delivered automatically or when a transaction is
rolled back, releasing a GNO smaller than the last one delivered.
It was introduced in an optimization of Gtid_state::get_automatic_gno and
Gtid_state::generate_automatic_gtid functions.
Locking scheme
This variable can be read and modified in four places:
- During server startup, holding global_tsid_lock.wrlock;
- By a client thread holding global_tsid_lock.wrlock
when executing RESET BINARY LOGS AND GTIDS
- By a client thread calling MYSQL_BIN_LOG::write_transaction function
(often the group commit FLUSH stage leader). It will call
Gtid_state::generate_automatic_gtid, that will acquire
global_tsid_lock.rdlock and lock_sidno(get_server_sidno()) when getting a
new automatically generated GTID;
- By a client thread rolling back, holding global_tsid_lock.rdlock
and lock_sidno(get_server_sidno()).
*/
std::unordered_map<rpl_sidno, rpl_gno> next_free_gno_map;
public:
using Locked_sidno_set = cs::index::Locked_sidno_set;
using Tsid = mysql::gtid::Tsid;
/**
Return the last executed GNO for a given SIDNO, e.g.
for the following set: UUID:1-10, UUID:12, UUID:15-20
20 will be returned.
@param sidno The GTID's SIDNO.
@retval The GNO or 0 if set is empty.
*/
rpl_gno get_last_executed_gno(rpl_sidno sidno) const;
/**
Generates the GTID (or ANONYMOUS, if GTID_MODE = OFF or
OFF_PERMISSIVE) for the THD, and acquires ownership.
Before this function, the caller needs to assign sidnos for automatic
transactions and lock sidno_set (see specify_transaction_sidno).
@param thd The thread.
@param specified_sidno Externally generated sidno.
@param specified_gno Externally generated gno.
@see Locked_sidno_set
@return RETURN_STATUS_OK or RETURN_STATUS_ERROR. Error can happen
in case of out of memory or if the range of GNOs was exhausted.
*/
enum_return_status generate_automatic_gtid(THD *thd,
rpl_sidno specified_sidno = 0,
rpl_gno specified_gno = 0);
/// @brief Determines sidno for thd transaction. In case transaction
/// is automatic, sidno is generated and added to sidno_set for future
/// locking (after all transactions from binlog commit group have been added)
/// @details The usage scheme is as follows: transaction for the binlog
/// commit group are assigned a sidno. Sidnos are added to sidno_set in this
/// function.
/// Afterwards, sidno_set must be locked by the caller. This operation must
/// be performed before the call to generate_automatic_gtid
/// @returns sidno specified for thd transaction
rpl_sidno specify_transaction_sidno(THD *thd,
Gtid_state::Locked_sidno_set &sidno_set);
/// Locks a mutex for the given SIDNO.
void lock_sidno(rpl_sidno sidno) { tsid_locks.lock(sidno); }
/// Unlocks a mutex for the given SIDNO.
void unlock_sidno(rpl_sidno sidno) { tsid_locks.unlock(sidno); }
/// Broadcasts updates for the given SIDNO.
void broadcast_sidno(rpl_sidno sidno) { tsid_locks.broadcast(sidno); }
/// Assert that we own the given SIDNO.
void assert_sidno_lock_owner(rpl_sidno sidno) const {
tsid_locks.assert_owner(sidno);
}
#ifdef MYSQL_SERVER
/**
Wait for a signal on the given SIDNO.
NOTE: This releases a lock!
This requires that the caller holds a read lock on tsid_lock. It
will release the lock before waiting; neither global_tsid_lock nor
the mutex lock on SIDNO will not be held when this function
returns.
@param thd THD object of the caller.
@param sidno Sidno to wait for.
@param[in] abstime The absolute point in time when the wait times
out and stops, or NULL to wait indefinitely.
@param[in] update_thd_status when true updates the stage info with
the new wait condition, when false keeps the current stage info.
@retval false Success.
@retval true Failure: either timeout or thread was killed. If
thread was killed, the error has been generated.
*/
bool wait_for_sidno(THD *thd, rpl_sidno sidno, struct timespec *abstime,
bool update_thd_status = true);
/**
This is only a shorthand for wait_for_sidno, which contains
additional debug printouts and assertions for the case when the
caller waits for one specific GTID.
*/
bool wait_for_gtid(THD *thd, const Gtid &gtid,
struct timespec *abstime = nullptr);
/**
Wait until the given Gtid_set is included in @@GLOBAL.GTID_EXECUTED.
@param thd The calling thread.
@param gtid_set Gtid_set to wait for.
@param[in] timeout The maximum number of milliseconds that the
function should wait, or 0 to wait indefinitely.
@param[in] update_thd_status when true updates the stage info with
the new wait condition, when false keeps the current stage info.
@retval false Success.
@retval true Failure: either timeout or thread was killed. If
thread was killed, the error has been generated.
*/
bool wait_for_gtid_set(THD *thd, Gtid_set *gtid_set, double timeout,
bool update_thd_status = true);
#endif // ifdef MYSQL_SERVER
/**
Locks one mutex for each SIDNO where the given Gtid_set has at
least one GTID. Locks are acquired in order of increasing SIDNO.
*/
void lock_sidnos(const Gtid_set *set);
/**
Unlocks the mutex for each SIDNO where the given Gtid_set has at
least one GTID.
*/
void unlock_sidnos(const Gtid_set *set);
/**
Broadcasts the condition variable for each SIDNO where the given
Gtid_set has at least one GTID.
*/
void broadcast_sidnos(const Gtid_set *set);
/**
Ensure that owned_gtids, executed_gtids, lost_gtids, gtids_only_in_table,
previous_gtids_logged and tsid_locks have room for at least as many SIDNOs
as tsid_map.
This function must only be called in one place:
Tsid_map::add_tsid().
Requires that the write lock on tsid_locks is held. If any object
needs to be resized, then the lock will be temporarily upgraded to
a write lock and then degraded to a read lock again; there will be
a short period when the lock is not held at all.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status ensure_sidno();
/**
Adds the given Gtid_set to lost_gtids and executed_gtids.
lost_gtids must be a subset of executed_gtids.
purged_gtid and executed_gtid sets are appended with the argument set
provided the latter is disjoint with gtid_executed owned_gtids.
Requires that the caller holds global_tsid_lock.wrlock.
@param[in,out] gtid_set The gtid_set to add. If the gtid_set
does not start with a plus sign (starts_with_plus is false),
@@GLOBAL.GTID_PURGED will be removed from the gtid_set.
@param starts_with_plus If true, the gtid_set passed is required to
be disjoint from @@GLOBAL.GTID_PURGED; if false, the gtid_set passed
is required to be a superset of @@GLOBAL.GTID_PURGED.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status add_lost_gtids(Gtid_set *gtid_set, bool starts_with_plus);
/** Updates previously logged GTID set before writing to table. */
void update_prev_gtids(Gtid_set *write_gtid_set);
/// Return a pointer to the Gtid_set that contains the lost gtids.
const Gtid_set *get_lost_gtids() const { return &lost_gtids; }
/*
Return a pointer to the Gtid_set that contains the stored gtids
in gtid_executed table.
*/
const Gtid_set *get_executed_gtids() const { return &executed_gtids; }
/*
Return a pointer to the Gtid_set that contains the stored gtids
only in gtid_executed table, not in binlog files.
*/
const Gtid_set *get_gtids_only_in_table() const {
return &gtids_only_in_table;
}
/*
Return a pointer to the Gtid_set that contains the previous stored
gtids in the last binlog file.
*/
const Gtid_set *get_previous_gtids_logged() const {
return &previous_gtids_logged;
}
/// Return a pointer to the Owned_gtids that contains the owned gtids.
const Owned_gtids *get_owned_gtids() const { return &owned_gtids; }
/// Return the server's SIDNO
rpl_sidno get_server_sidno() const { return server_sidno; }
/// Return the server's TSID
const Tsid &get_server_tsid() const {
return global_tsid_map->sidno_to_tsid(server_sidno);
}
/// @brief Increments atomic_automatic_tagged_gtid_session_count
void increase_gtid_automatic_tagged_count() {
++atomic_automatic_tagged_gtid_session_count;
}
/// @brief Decrements atomic_automatic_tagged_gtid_session_count
void decrease_gtid_automatic_tagged_count() {
--atomic_automatic_tagged_gtid_session_count;
}
/// @brief Checks whether there are ongoing sessions executing transactions
/// with GTID_NEXT set to AUTOMATIC:tag
/// @return true in case there are ongoing sessions with GTID_NEXT set
/// to automatic, tagged
bool is_any_session_assigning_automatic_tagged_gtids() {
return atomic_automatic_tagged_gtid_session_count.load() != 0;
}
#ifndef NDEBUG
/**
Debug only: Returns an upper bound on the length of the string
generated by to_string(), not counting '\0'. The actual length
may be shorter.
*/
size_t get_max_string_length() const {
return owned_gtids.get_max_string_length() +
executed_gtids.get_string_length() + lost_gtids.get_string_length() +
gtids_only_in_table.get_string_length() +
previous_gtids_logged.get_string_length() + 150;
}
/// Debug only: Generate a string in the given buffer and return the length.
int to_string(char *buf) const {
char *p = buf;
p += sprintf(p, "Executed GTIDs:\n");
p += executed_gtids.to_string(p);
p += sprintf(p, "\nOwned GTIDs:\n");
p += owned_gtids.to_string(p);
p += sprintf(p, "\nLost GTIDs:\n");
p += lost_gtids.to_string(p);
p += sprintf(p, "\nGTIDs only_in_table:\n");
p += lost_gtids.to_string(p);
return (int)(p - buf);
}
/// Debug only: return a newly allocated string, or NULL on out-of-memory.
char *to_string() const {
char *str = (char *)my_malloc(key_memory_Gtid_state_to_string,
get_max_string_length(), MYF(MY_WME));
to_string(str);
return str;
}
/// Debug only: print this Gtid_state to stdout.
void print() const {
char *str = to_string();
printf("%s", str);
my_free(str);
}
#endif
/**
Print this Gtid_state to the trace file if debug is enabled; no-op
otherwise.
*/
void dbug_print(const char *text [[maybe_unused]] = "") const {
#ifndef NDEBUG
tsid_lock->assert_some_wrlock();
char *str = to_string();
DBUG_PRINT("info", ("%s%s%s", text, *text ? ": " : "", str));
my_free(str);
#endif
}
/**
Save gtid owned by the thd into executed_gtids variable
and gtid_executed table.
@param thd Session to commit
@retval
0 OK
@retval
-1 Error
*/
int save(THD *thd);
/**
Insert the gtid set into table.
@param gtid_set contains a set of gtid, which holds
the sidno and the gno.
@retval
0 OK
@retval
-1 Error
*/
int save(const Gtid_set *gtid_set);
/**
Save the set of gtids logged in the last binlog into gtid_executed table.
@retval
0 OK
@retval
-1 Error
*/
int save_gtids_of_last_binlog_into_table();
/**
Fetch gtids from gtid_executed table and store them into
gtid_executed set.
@retval
0 OK
@retval
1 The table was not found.
@retval
-1 Error
*/
int read_gtid_executed_from_table();
/**
Compress the gtid_executed table, read each row by the PK(sid, gno_start)
in increasing order, compress the first consecutive gtids range
(delete consecutive gtids from the second consecutive gtid, then
update the first gtid) within a single transaction.
@param thd Thread requesting to compress the table
@retval
0 OK
@retval
1 The table was not found.
@retval
-1 Error
*/
int compress(THD *thd);
#ifdef MYSQL_SERVER
/**
Push a warning to client if user is modifying the gtid_executed
table explicitly by a non-XA transaction. Push an error to client
if user is modifying it explicitly by a XA transaction.
@param thd Thread requesting to access the table
@param table The table is being accessed.
@retval 0 No warning or error was pushed to the client.
@retval 1 Push a warning to client.
@retval 2 Push an error to client.
*/
int warn_or_err_on_modify_gtid_table(THD *thd, Table_ref *table);
#endif
private:
/**
Remove the GTID owned by thread from owned GTIDs.
This will:
- Clean up the thread state if the thread owned GTIDs is empty.
- Release ownership of all GTIDs owned by the THD. This removes
the GTID from Owned_gtids and clears the ownership status in the
THD object.
- Add the owned GTID to executed_gtids if the is_commit flag is
set.
- Decrease counters of GTID-violating transactions.
- Send a broadcast on the condition variable for every sidno for
which we released ownership.
@param[in] thd Thread for which owned gtids are updated.
@param[in] is_commit If true, the update is for a commit (not a rollback).
*/
void update_gtids_impl(THD *thd, bool is_commit);
#ifdef HAVE_GTID_NEXT_LIST
/// Lock all SIDNOs owned by the given THD.
void lock_owned_sidnos(const THD *thd);
#endif
/// Unlock all SIDNOs owned by the given THD.
void unlock_owned_sidnos(const THD *thd);
/// Broadcast the condition for all SIDNOs owned by the given THD.
void broadcast_owned_sidnos(const THD *thd);
/// Read-write lock that protects updates to the number of TSIDs.
mutable Checkable_rwlock *tsid_lock;
/// The Tsid_map used by this Gtid_state.
mutable Tsid_map *tsid_map;
/// Contains one mutex/cond pair for every SIDNO.
Mutex_cond_array tsid_locks;
/**
The set of GTIDs that existed in some previously purged binary log.
This is always a subset of executed_gtids.
*/
Gtid_set lost_gtids;
/*
The set of GTIDs that has been executed and
stored into gtid_executed table.
*/
Gtid_set executed_gtids;
/*
The set of GTIDs that exists only in gtid_executed table, not in
binlog files.
*/
Gtid_set gtids_only_in_table;
/* The previous GTIDs in the last binlog. */
Gtid_set previous_gtids_logged;
/// The set of GTIDs that are owned by some thread.
Owned_gtids owned_gtids;
/// The SIDNO for this server.
rpl_sidno server_sidno;
/// The number of anonymous transactions owned by any client.
std::atomic<int32> atomic_anonymous_gtid_count{0};
/// The number of GTID-violating transactions that use GTID_NEXT=AUTOMATIC.
std::atomic<int32> atomic_automatic_gtid_violation_count{0};
/// The number of GTID-violating transactions that use GTID_NEXT=AUTOMATIC.
std::atomic<int32> atomic_anonymous_gtid_violation_count{0};
/// The number of clients that are executing
/// WAIT_FOR_EXECUTED_GTID_SET.
std::atomic<int32> atomic_gtid_wait_count{0};
/// The number of sessions that have GTID_NEXT set to AUTOMATIC with tag
/// assigned
std::atomic<int64_t> atomic_automatic_tagged_gtid_session_count{0};
/// Used by unit tests that need to access private members.
#ifdef FRIEND_OF_GTID_STATE
friend FRIEND_OF_GTID_STATE;
#endif
/**
This is a sub task of update_on_rollback responsible only to handle
the case of a thread that needs to skip GTID operations when it has
"failed to commit".
Administrative commands [CHECK|REPAIR|OPTIMIZE|ANALYZE] TABLE
are written to the binary log even when they fail. When the
commands fail, they will call update_on_rollback; later they will
write the binary log. But we must not do any of the things in
update_gtids_impl if we are going to write the binary log. So
these statements set the skip_gtid_rollback flag, which tells
update_on_rollback to return early. When the statements are
written to the binary log they will call update_on_commit as
usual.
@param[in] thd - Thread to be evaluated.
@retval true The transaction should skip the rollback, false otherwise.
*/
bool update_gtids_impl_check_skip_gtid_rollback(THD *thd);
/**
This is a sub task of update_gtids_impl responsible only to handle
the case of a thread that owns nothing and does not violate GTID
consistency.
If the THD does not own anything, there is nothing to do, so we can do an
early return of the update process. Except if there is a GTID consistency
violation; then we need to decrease the counter, so then we can continue
executing inside update_gtids_impl.
@param[in] thd - Thread to be evaluated.
@retval true The transaction can be skipped because it owns nothing and
does not violate GTID consistency, false otherwise.
*/
bool update_gtids_impl_do_nothing(THD *thd);
/**
This is a sub task of update_gtids_impl responsible only to evaluate
if the thread is committing in the middle of a statement by checking
THD's is_commit_in_middle_of_statement flag.
This flag is true for anonymous transactions, when the
'transaction' has been split into multiple transactions in the
binlog, and the present transaction is not the last one.
This means two things:
- We should not release anonymous ownership in case
gtid_next=anonymous. If we did, it would be possible for user
to set GTID_MODE=ON from a concurrent transaction, making it
impossible to commit the current transaction.
- We should not decrease the counters for GTID-violating
statements. If we did, it would be possible for a concurrent
client to set ENFORCE_GTID_CONSISTENCY=ON despite there is an
ongoing transaction that violates GTID consistency.
The flag is set in two cases:
1. We are committing the statement cache when there are more
changes in the transaction cache.
This happens either because a single statement in the
beginning of a transaction updates both transactional and
non-transactional tables, or because we are committing a
non-transactional update in the middle of a transaction when
binlog_direct_non_transactional_updates=1.
In this case, the flag is set further down in this function.
2. The statement is one of the special statements that may
generate multiple transactions: CREATE...SELECT, DROP TABLE,
DROP DATABASE. See comment for THD::owned_gtid in
sql/sql_class.h.
In this case, the THD::is_commit_in_middle_of_statement flag
is set by the caller and the flag becomes true here.
@param[in] thd - Thread to be evaluated.
@return The value of thread's is_commit_in_middle_of_statement flag.
*/
bool update_gtids_impl_begin(THD *thd);
/**
Handle the case that the thread own a set of GTIDs.
This is a sub task of update_gtids_impl responsible only to handle
the case of a thread with a set of GTIDs being updated.
- Release ownership of the GTIDs owned by the THD. This removes
the GTID from Owned_gtids and clears the ownership status in the
THD object.
- Add the owned GTIDs to executed_gtids if the is_commit flag is set.
- Send a broadcast on the condition variable for the sidno which we
released ownership.
@param[in] thd - Thread for which owned GTID set should be updated.
@param[in] is_commit - If the thread is being updated by a commit.
*/
void update_gtids_impl_own_gtid_set(THD *thd, bool is_commit);
/**
Lock a given sidno of a transaction being updated.
This is a sub task of update_gtids_impl responsible only to lock the
sidno of the GTID being updated.
@param[in] sidno - The sidno to be locked.
*/
void update_gtids_impl_lock_sidno(rpl_sidno sidno);
/**
Locks the sidnos of all the GTIDs of the commit group starting on the
transaction passed as parameter.
This is a sub task of update_commit_group responsible only to lock the
sidno(s) of the GTID(s) being updated.
The function should follow thd->next_to_commit to lock all sidnos of all
transactions being updated in a group.
@param[in] thd - Thread that owns the GTID(s) to be updated or leader
of the commit group in the case of a commit group
update.
*/
void update_gtids_impl_lock_sidnos(THD *thd);
/**
Handle the case that the thread own a single non-anonymous GTID.
This is a sub task of update_gtids_impl responsible only to handle
the case of a thread with a single non-anonymous GTID being updated
either for commit or rollback.
- Release ownership of the GTID owned by the THD. This removes
the GTID from Owned_gtids and clears the ownership status in the
THD object.
- Add the owned GTID to executed_gtids if the is_commit flag is set.
- Send a broadcast on the condition variable for the sidno which we
released ownership.
@param[in] thd - Thread to be updated that owns single non-anonymous GTID.
@param[in] is_commit - If the thread is being updated by a commit.
*/
void update_gtids_impl_own_gtid(THD *thd, bool is_commit);
/**
Unlock a given sidno after broadcasting its changes.
This is a sub task of update_gtids_impl responsible only to
unlock the sidno of the GTID being updated after broadcasting
its changes.
@param[in] sidno - The sidno to be broadcasted and unlocked.
*/
void update_gtids_impl_broadcast_and_unlock_sidno(rpl_sidno sidno);
/**
Unlocks all locked sidnos after broadcasting their changes.
This is a sub task of update_commit_group responsible only to
unlock the sidno(s) of the GTID(s) being updated after broadcasting
their changes.
*/
void update_gtids_impl_broadcast_and_unlock_sidnos();
/**
Handle the case that the thread owns ANONYMOUS GTID.
This is a sub task of update_gtids_impl responsible only to handle
the case of a thread with an ANONYMOUS GTID being updated.
- Release ownership of the anonymous GTID owned by the THD and clears
the ownership status in the THD object.
- Decrease counters of GTID-violating transactions.
@param[in] thd - Thread to be updated that owns anonymous GTID.
@param[in,out] more_trx - If the 'transaction' has been split into
multiple transactions in the binlog.
This is firstly assigned with the return of
Gtid_state::update_gtids_impl_begin function, and
its value can be set to true when
Gtid_state::update_gtids_impl_anonymous_gtid
detects more content on the transaction cache.
*/
void update_gtids_impl_own_anonymous(THD *thd, bool *more_trx);
/**
Handle the case that the thread owns nothing.
This is a sub task of update_gtids_impl responsible only to handle
the case of a thread that owns nothing being updated.
There are two cases when this happens:
- Normally, it is a rollback of an automatic transaction, so
the is_commit is false and gtid_next=automatic.
- There is also a corner case. This case may happen for a transaction
that uses GTID_NEXT=AUTOMATIC, and violates GTID_CONSISTENCY, and
commits changes to the database, but does not write to the binary log,
so that no GTID is generated. An example is CREATE TEMPORARY TABLE
inside a transaction when binlog_format=row. Despite the thread does
not own anything, the GTID consistency violation makes it necessary to
call end_gtid_violating_transaction. Therefore
MYSQL_BIN_LOG::gtid_end_transaction will call
gtid_state->update_on_commit in this case, and subsequently we will
reach this case.
@param[in] thd - Thread to be updated that owns anonymous GTID.
*/
void update_gtids_impl_own_nothing(THD *thd);
/**
Handle the final part of update_gtids_impl.
This is a sub task of update_gtids_impl responsible only to handle
the call to end_gtid_violating_transaction function when there is no
more transactions split after the current transaction.
@param[in] thd - Thread for which owned GTID is updated.
@param[in] more_trx - This is the value returned from
Gtid_state::update_gtids_impl_begin and can be
changed for transactions owning anonymous GTID at
Gtid_state::update_gtids_impl_own_anonymous.
*/
void update_gtids_impl_end(THD *thd, bool more_trx);
/**
This array is used by Gtid_state_update_gtids_impl* functions.
The array items (one per sidno of the tsid_map) will be set as true for
each sidno that requires to be locked when updating a set of GTIDs
(at Gtid_set::update_gtids_impl_lock_sidnos).
The array items will be set false at
Gtid_set::update_gtids_impl_broadcast_and_unlock_sidnos.
It is used to so that lock, unlock, and broadcast operations are only
called once per sidno per commit group, instead of once per transaction.
Its access is protected by:
- global_tsid_lock->wrlock when growing and cleaning up;
- MYSQL_BIN_LOG::LOCK_commit when setting true/false on array items.
*/
Prealloced_array<bool, 8> commit_group_sidnos;
/**
Ensure that commit_group_sidnos have room for the SIDNO passed as
parameter.
This function must only be called in one place:
Gtid_state::ensure_sidno().
@param sidno The SIDNO.
@return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
*/
enum_return_status ensure_commit_group_sidnos(rpl_sidno sidno);
};
/*
BUG# #18089914 - REFACTORING: RENAME GROUP TO GTID
changed AUTOMATIC_GROUP to AUTOMATIC_GTID
changed ANONYMOUS_GROUP to ANONYMOUS_GTID
changed INVALID_GROUP to INVALID_GTID
changed UNDEFINED_GROUP to UNDEFINED_GTID
changed GTID_GROUPto ASSIGNED_GTID
changed NOT_YET_DETERMINED_GROUP to NOT_YET_DETERMINED_GTID
*/
/**
Enumeration of different types of values for Gtid_specification,
i.e, the different internal states that @@session.gtid_next can be in.
*/
enum enum_gtid_type {
/**
Specifies that the GTID has not been generated yet; it will be
generated on commit. It will depend on the GTID_MODE: if
GTID_MODE<=OFF_PERMISSIVE, then the transaction will be anonymous;
if GTID_MODE>=ON_PERMISSIVE, then the transaction will be assigned
a new GTID.
In the latter case, the Gtid_specification may hold a tag. Then,
the new GTID will be generated with that tag.
AUTOMATIC_GTID with an empty tag is the default value:
thd->variables.gtid_next has this state when GTID_NEXT="AUTOMATIC".
It is important that AUTOMATIC_GTID==0 so that the default value
for thd->variables->gtid_next.type is AUTOMATIC_GTID.
*/
AUTOMATIC_GTID = 0,
/**
Specifies that the transaction has been assigned a GTID (UUID:NUMBER).
thd->variables.gtid_next has this state when GTID_NEXT="UUID:NUMBER".
This is the state of GTID-transactions replicated to the slave.
*/
ASSIGNED_GTID,
/**
Specifies that the transaction is anonymous, i.e., it does not
have a GTID and will never be assigned one.
thd->variables.gtid_next has this state when GTID_NEXT="ANONYMOUS".
This is the state of any transaction generated on a pre-GTID
server, or on a server with GTID_MODE==OFF.
*/
ANONYMOUS_GTID,
/**
GTID_NEXT is set to this state after a transaction with
GTID_NEXT=='UUID:NUMBER' is committed.
This is used to protect against a special case of unsafe
non-transactional updates.
Background: Non-transactional updates are allowed as long as they
are sane. Non-transactional updates must be single-statement
transactions; they must not be mixed with transactional updates in
the same statement or in the same transaction. Since
non-transactional updates must be logged separately from
transactional updates, a single mixed statement would generate two
different transactions.
Problematic case: Consider a transaction, Tx1, that updates two
transactional tables on the master, t1 and t2. Then slave (s1) later
replays Tx1. However, t2 is a non-transactional table at s1. As such, s1
will report an error because it cannot split Tx1 into two different
transactions. Had no error been reported, then Tx1 would be split into Tx1
and Tx2, potentially causing severe harm in case some form of fail-over
procedure is later engaged by s1.
To detect this case on the slave and generate an appropriate error
message rather than causing an inconsistency in the GTID state, we
do as follows. When committing a transaction that has
GTID_NEXT==UUID:NUMBER, we set GTID_NEXT to UNDEFINED_GTID. When
the next part of the transaction is being processed, an error is
generated, because it is not allowed to execute a transaction when
GTID_NEXT==UNDEFINED. In the normal case, the error is not
generated, because there will always be a Gtid_log_event after the
next transaction.
*/
UNDEFINED_GTID,
/**
GTID_NEXT is set to this state by the slave applier thread when it
reads a Format_description_log_event that does not originate from
this server.
Background: when the slave applier thread reads a relay log that
comes from a pre-GTID master, it must preserve the transactions as
anonymous transactions, even if GTID_MODE>=ON_PERMISSIVE. This
may happen, e.g., if the relay log was received when master and
slave had GTID_MODE=OFF or when master and slave were old, and the
relay log is applied when slave has GTID_MODE>=ON_PERMISSIVE.
So the slave thread should set GTID_NEXT=ANONYMOUS for the next
transaction when it starts to process an old binary log. However,
there is no way for the slave to tell if the binary log is old,
until it sees the first transaction. If the first transaction
begins with a Gtid_log_event, we have the GTID there; if it begins
with query_log_event, row events, etc, then this is an old binary
log. So at the time the binary log begins, we just set
GTID_NEXT=NOT_YET_DETERMINED_GTID. If it remains
NOT_YET_DETERMINED when the next transaction begins,
gtid_pre_statement_checks will automatically turn it into an
anonymous transaction. If a Gtid_log_event comes across before
the next transaction starts, then the Gtid_log_event will just set
GTID_NEXT='UUID:NUMBER' accordingly.
*/
NOT_YET_DETERMINED_GTID,
/**
The applier sets GTID_NEXT this state internally, when it
processes an Anonymous_gtid_log_event on a channel having
ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS, before it calls
set_gtid_next. This tells set_gtid_next to generate a new,
sequential GTID, and acquire ownership for it. Thus, this state
is only used for a very brief period of time. It is not
user-visible.
*/
PRE_GENERATE_GTID,
};
/// Global state of GTIDs.
extern Gtid_state *gtid_state;
/**
This struct represents a specification of a GTID for a statement to
be executed: either "AUTOMATIC", "AUTOMATIC:<tag>", "ANONYMOUS" or "TSID:GNO".
This is a POD. It has to be a POD because it is used in THD::variables.
*/
struct Gtid_specification {
// Constants used in gtid specification
static constexpr auto str_automatic = "AUTOMATIC";
static constexpr auto str_automatic_tagged = "AUTOMATIC:";
static constexpr auto str_automatic_sep = ":";
static constexpr auto str_pre_generated = "PRE_GENERATE_GTID";
static constexpr auto str_not_yet_determined = "NOT_YET_DETERMINED";
static constexpr auto str_anonymous = "ANONYMOUS";
using Tsid = mysql::gtid::Tsid;
using Tag = mysql::gtid::Tag;
using Tag_plain = mysql::gtid::Tag_plain;
/// The type of this GTID
enum_gtid_type type;
/**
The GTID:
{ SIDNO, GNO } if type == GTID;
{ 0, 0 } if type == AUTOMATIC or ANONYMOUS.
*/
Gtid gtid;
/// @brief Tag defined by the user while specifying GTID_NEXT="AUTOMATIC:TAG".
/// We must store here the information about tag, because automatic
/// tagged GTID does not have sidno assigned
Tag_plain automatic_tag;
/// @brief Prints automatic tag specification to the given buffer
/// @param[in,out] buf Buffer to write to, must be allocated
/// @return The number of bytes written to the buffer
std::size_t automatic_to_string(char *buf) const;
/// Set the type to ASSIGNED_GTID and SIDNO, GNO to the given values.
void set(rpl_sidno sidno, rpl_gno gno) {
gtid.set(sidno, gno);
type = ASSIGNED_GTID;
automatic_tag.clear();
}
/// @brief Helper function indicating whether this is to-be-generated GTID
/// @param[in] type Type of the GTID
/// @retval true This GTID will be generated
/// @retval false Other type of the GTID
static bool is_automatic(const enum_gtid_type &type) {
return type == AUTOMATIC_GTID;
}
/// @brief Helper function indicating whether this is to-be-generated GTID
/// @retval true This GTID will be generated
/// @retval false Other type of the GTID
bool is_automatic() const { return is_automatic(type); }
/// @brief Helper function indicating whether this is an undefined GTID
/// @return Returns true for undefined GTIDs
bool is_undefined() const { return type == UNDEFINED_GTID; }
/// @brief Helper function indicating whether this is an assigned GTID
/// @return Returns true for assigned GTIDs
bool is_assigned() const { return type == ASSIGNED_GTID; }
/// @brief Returns tag object generated from internal tag data
/// @return Tag object
Tag generate_tag() const;
/// @brief Helper function indicating whether this is to-be-generated GTID
/// with a tag assigned
/// @retval true This GTID will be generated with assigned tag
/// @retval false Other type of the GTID
bool is_automatic_tagged() const;
/// Set the type to ASSIGNED_GTID and TSID, GNO to the given Gtid.
/// @brief gtid_param GTID to copy from
void set(const Gtid &gtid_param) { set(gtid_param.sidno, gtid_param.gno); }
/// @brief Set the type to AUTOMATIC_GTID.
void set_automatic() {
type = AUTOMATIC_GTID;
automatic_tag.clear();
}
/// @brief Copy spec from other
/// @param[in] other Pattern to copy from
void set(const Gtid_specification &other);
/// Set the type to ANONYMOUS_GTID.
void set_anonymous() {
type = ANONYMOUS_GTID;
automatic_tag.clear();
}
/// Set the type to NOT_YET_DETERMINED_GTID.
void set_not_yet_determined() {
type = NOT_YET_DETERMINED_GTID;
automatic_tag.clear();
}
/// Set to undefined. Must only be called if the type is ASSIGNED_GTID.
void set_undefined() {
assert(type == ASSIGNED_GTID);
type = UNDEFINED_GTID;
automatic_tag.clear();
}
/// Return true if this Gtid_specification is equal to 'other'.
bool equals(const Gtid_specification &other) const {
return (type == other.type &&
(type != ASSIGNED_GTID || gtid.equals(other.gtid)));
}
/**
Return true if this Gtid_specification is a ASSIGNED_GTID with the
same TSID, GNO as 'other_gtid'.
*/
bool equals(const Gtid &other_gtid) const {
return type == ASSIGNED_GTID && gtid.equals(other_gtid);
}
#ifdef MYSQL_SERVER
/**
Parses the given string and stores in this Gtid_specification.
@param tsid_map tsid_map to use when converting TSID to a sidno.
@param text The text to parse
@return operation status
*/
[[NODISCARD]] mysql::utils::Return_status parse(Tsid_map *tsid_map,
const char *text);
/// @brief Returns true if the given string is a valid Gtid_specification.
/// @param[in] text Textual representation of the GTID specification
static bool is_valid(const char *text);
/// @brief Returns true if the given string is a tagged Gtid_specification.
/// @param[in] text Textual representation of the GTID specification
static bool is_tagged(const char *text);
#endif
static const int MAX_TEXT_LENGTH = Gtid::MAX_TEXT_LENGTH;
/**
Writes this Gtid_specification to the given string buffer.
@param tsid_map Tsid_map to use if the type of this
Gtid_specification is ASSIGNED_GTID.
@param [out] buf The buffer
@param need_lock If true, this function acquires global_tsid_lock
before looking up the sidno in tsid_map, and then releases it. If
false, this function asserts that the lock is held by the caller.
@retval The number of characters written.
*/
int to_string(const Tsid_map *tsid_map, char *buf,
bool need_lock = false) const;
/**
Writes this Gtid_specification to the given string buffer.
@param tsid TSID to use if the type of this Gtid_specification is
ASSIGNED_GTID. Can be NULL if this Gtid_specification is
ANONYMOUS_GTID or AUTOMATIC_GTID.
@param[out] buf The buffer
@retval The number of characters written.
*/
int to_string(const Tsid &tsid, char *buf) const;
#ifndef NDEBUG
/// Debug only: print this Gtid_specification to stdout.
void print() const {
char buf[MAX_TEXT_LENGTH + 1];
to_string(global_tsid_map, buf);
printf("%s\n", buf);
}
#endif
/**
Print this Gtid_specification to the trace file if debug is
enabled; no-op otherwise.
*/
void dbug_print(const char *text [[maybe_unused]] = "",
bool need_lock [[maybe_unused]] = false) const {
#ifndef NDEBUG
char buf[MAX_TEXT_LENGTH + 1];
to_string(global_tsid_map, buf, need_lock);
DBUG_PRINT("info", ("%s%s%s", text, *text ? ": " : "", buf));
#endif
}
};
static_assert(std::is_trivial_v<Gtid_specification>);
static_assert(std::is_standard_layout_v<Gtid_specification>);
/**
Indicates if a statement should be skipped or not. Used as return
value from gtid_before_statement.
*/
enum enum_gtid_statement_status {
/// Statement can execute.
GTID_STATEMENT_EXECUTE,
/// Statement should be cancelled.
GTID_STATEMENT_CANCEL,
/**
Statement should be skipped, but there may be an implicit commit
after the statement if gtid_commit is set.
*/
GTID_STATEMENT_SKIP
};
#ifdef MYSQL_SERVER
/**
Check if current transaction should be skipped, that is, if GTID_NEXT
was already logged.
@param thd The calling thread.
@retval true Transaction was already logged.
@retval false Transaction must be executed.
*/
bool is_already_logged_transaction(const THD *thd);
/**
Perform GTID-related checks before executing a statement:
- Check that the current statement does not contradict
enforce_gtid_consistency.
- Check that there is no implicit commit in a transaction when
GTID_NEXT==UUID:NUMBER.
- Change thd->variables.gtid_next.type to ANONYMOUS_GTID if it is
currently NOT_YET_DETERMINED_GTID.
- Check whether the statement should be cancelled.
@param thd THD object for the session.
@retval GTID_STATEMENT_EXECUTE The normal case: the checks
succeeded, and statement can execute.
@retval GTID_STATEMENT_CANCEL The checks failed; an
error has be generated and the statement must stop.
@retval GTID_STATEMENT_SKIP The checks succeeded, but the GTID has
already been executed (exists in GTID_EXECUTED). So the statement
must not execute; however, if there are implicit commits, then the
implicit commits must execute.
*/
enum_gtid_statement_status gtid_pre_statement_checks(THD *thd);
/**
Perform GTID-related checks before executing a statement, but after
executing an implicit commit before the statement, if any:
If gtid_next=anonymous, but the thread does not hold anonymous
ownership, then acquire anonymous ownership. (Do this only if this
is not an 'innocent' statement, i.e., SET/SHOW/DO/SELECT that does
not invoke a stored function.)
It is important that this is done after the implicit commit, because
the implicit commit may release anonymous ownership.
@param thd THD object for the session
@retval false Success.
@retval true Error. Error can happen if GTID_MODE=ON. The error has
been reported by (a function called by) this function.
*/
bool gtid_pre_statement_post_implicit_commit_checks(THD *thd);
/**
Acquire ownership of the given Gtid_specification.
The Gtid_specification must be of type ASSIGNED_GTID or ANONYMOUS_GTID.
The caller must hold global_tsid_lock (normally the rdlock). The
lock may be temporarily released and acquired again. In the end,
the lock will be released, so the caller should *not* release the
lock.
The function will try to acquire ownership of the GTID and update
both THD::gtid_next, Gtid_state::owned_gtids, and
THD::owned_gtid / THD::owned_sid.
@param thd The thread that acquires ownership.
@param spec The Gtid_specification.
@retval false Success: either we have acquired ownership of the
GTID, or it is already included in GTID_EXECUTED and will be
skipped.
@retval true Failure; the thread was killed or an error occurred.
The error has been reported using my_error.
*/
bool set_gtid_next(THD *thd, const Gtid_specification &spec);
#ifdef HAVE_GTID_NEXT_LIST
int gtid_acquire_ownership_multiple(THD *thd);
#endif
/**
Return sidno for a given tsid, see Tsid_map::add_sid() for details.
*/
rpl_sidno get_sidno_from_global_tsid_map(const mysql::gtid::Tsid &tsid);
/**
Return Tsid for a given sidno on the global_tsid_map.
See Tsid_map::sidno_to_tsid() for details.
*/
const mysql::gtid::Tsid &get_tsid_from_global_tsid_map(rpl_sidno sidno);
/**
Return last gno for a given sidno, see
Gtid_state::get_last_executed_gno() for details.
*/
rpl_gno get_last_executed_gno(rpl_sidno sidno);
void gtid_set_performance_schema_values(const THD *thd);
/**
If gtid_next=ANONYMOUS or NOT_YET_DETERMINED, but the thread does
not hold anonymous ownership, acquire anonymous ownership.
@param thd Thread.
@retval true Error (can happen if gtid_mode=ON and
gtid_next=anonymous). The error has already been reported using
my_error.
@retval false Success.
*/
bool gtid_reacquire_ownership_if_anonymous(THD *thd);
/**
The function commits or rolls back the gtid state if it needs to.
It's supposed to be invoked at the end of transaction commit or
rollback, as well as as at the end of XA prepare.
@param thd Thread context
@param needs_to The actual work will be done when the parameter is true
@param do_commit When true the gtid state changes are committed, otherwise
they are rolled back.
*/
inline void gtid_state_commit_or_rollback(THD *thd, bool needs_to,
bool do_commit) {
if (needs_to) {
if (do_commit)
gtid_state->update_on_commit(thd);
else
gtid_state->update_on_rollback(thd);
}
}
#endif // ifdef MYSQL_SERVER
#endif /* RPL_GTID_H_INCLUDED */
Reference in a new issue View git blame Copy permalink