From: Andrei <andrei.el...@mariadb.com>
XA-Prepare group of events
XA START xid
...
XA END xid
XA PREPARE xid
and its XA-"complete" terminator
XA COMMIT or
XA ROLLBACK
are made distributed Round-Robin across slave parallel workers.
The former hash-based policy was proven to attribute to execution
latency through creating a big - many times larger than the size
of the worker pool - queue of binlog-ordered transactions
to commit.
Acronyms and notations used below:
XAP := XA-Prepare event or the whole prepared XA group of events
XAC := XA-"complete", which is a solitary group of events
|W| := the size of the slave worker pool
Subscripts like `_k' denote order in a corresponding sequence
(e.g binlog file).
KEY CHANGES:
The parallel slave
------------------
driver thread now maintains a list XAP:s currently
in processing. It's purpose is to avoid "wild" parallel execution of XA:s
with duplicate xids (unlikely, but that's the user's right).
The list is arranged as a sliding window with the size of 2*|W| to account
a possibility of XAP_k -> XAP_k+2|W|-1 the largest (in the group-of-events
count sense) dependency.
Say k=1, and |W| the # of Workers is 4. As transactions are distributed
Round-Robin, it's possible to have T^*_1 -> T^*_8 as the largest
dependency ('*' marks the dependents) in runtime.
It can be seen from worker queues, like in the picture below.
Let Q_i worker queues develop downward:
Q1 ... Q4
1^* 2 3 4
5 6 7 8^*
Worker # 1 has assigned with T_1 and T_5.
Worker #4 can take on its T_8 when T_1 is yet at the
beginning of its processing, so even before XA START of that XAP.
XA related
----------
XID_cache_element is extended with two pointers to resolve
two types of dependencies: the duplicate xid XAP_k -> XAP_k+i
and the ordinary completion on the prepare XAP_k -> XAC_k+j.
The former is handled by a wait-for-xid protocol conducted by
xid_cache_delete() and xid_cache_insert_maybe_wait().
The later is done analogously by xid_cache_search_maybe_wait() and
slave_applier_reset_xa_trans().
XA-"complete" are allowed to go forward before its XAP parent
has released the xid (all recovery concerns are covered in MDEV-21496,
MDEV-21777).
Yet XAC is going to wait for it at a critical
point of execution which is at "complete" the work in Engine.
CAVEAT: storage/innobase/trx/trx0undo.cc changes are due to possibly
fixed MDEV-32144,
TODO: to be verified.
Thanks to Brandon Nesterenko at mariadb.com for initial review and
a lot of creative efforts to advance with this work!
---
mysql-test/include/show_binlog_events2.inc | 11 +
.../binlog/r/binlog_xa_prepared_bugs.result | 53 +
.../binlog/t/binlog_xa_prepared_bugs.test | 30 +
.../rpl/include/rpl_xa_concurrent_2pc.inc | 442 ++++++++
.../suite/rpl/r/rpl_xa_concurrent_2pc.result | 953 ++++++++++++++++++
.../rpl/r/rpl_xa_empty_transaction.result | 51 +
.../rpl/r/rpl_xa_prepare_gtid_fail.result | 2 +-
.../suite/rpl/t/rpl_xa_concurrent_2pc.test | 111 ++
.../suite/rpl/t/rpl_xa_empty_transaction.test | 89 ++
.../suite/rpl/t/rpl_xa_prepare_gtid_fail.test | 2 +-
sql/handler.cc | 23 +-
sql/log.cc | 219 +++-
sql/log_event_server.cc | 17 +-
sql/mysqld.cc | 4 +-
sql/mysqld.h | 4 +-
sql/rpl_parallel.cc | 128 ++-
sql/rpl_parallel.h | 16 +
sql/rpl_rli.cc | 6 +-
sql/rpl_rli.h | 8 +
sql/sql_array.h | 4 +-
sql/sql_class.cc | 2 +
sql/sql_class.h | 9 +
sql/xa.cc | 333 +++++-
storage/innobase/trx/trx0undo.cc | 3 +-
24 files changed, 2419 insertions(+), 101 deletions(-)
create mode 100644 mysql-test/suite/binlog/r/binlog_xa_prepared_bugs.result
create mode 100644 mysql-test/suite/binlog/t/binlog_xa_prepared_bugs.test
create mode 100644 mysql-test/suite/rpl/include/rpl_xa_concurrent_2pc.inc
create mode 100644 mysql-test/suite/rpl/r/rpl_xa_concurrent_2pc.result
create mode 100644 mysql-test/suite/rpl/t/rpl_xa_concurrent_2pc.test
diff --git a/mysql-test/include/show_binlog_events2.inc
b/mysql-test/include/show_binlog_events2.inc
index 84c62cced66..416514faea4 100644
--- a/mysql-test/include/show_binlog_events2.inc
+++ b/mysql-test/include/show_binlog_events2.inc
@@ -1,3 +1,9 @@
+# ==== Usage ====
+#
+# [--let $binlog_file= [<FILENAME> | LAST]]
+# [--let $binlog_start= <POSITION> ]
+# [--let $filter_cid= [0 | 1]
+
if ($binlog_start)
{
--let $_binlog_start=$binlog_start
@@ -14,4 +20,9 @@ if ($binlog_file)
--replace_result "$_from_binlog_start" "from <binlog_start>" $MYSQLTEST_VARDIR
MYSQLTEST_VARDIR
--replace_column 2 # 5 #
--replace_regex /\/\* xid=.* \*\//\/* XID *\// /table_id: [0-9]+/table_id: #/
/file_id=[0-9]+/file_id=#/ /GTID [0-9]+-[0-9]+-[0-9]+/GTID #-#-#/
+if ($filter_cid)
+{
+--replace_regex /\/\* xid=.* \*\//\/* XID *\// /table_id: [0-9]+/table_id: #/
/file_id=[0-9]+/file_id=#/ /GTID [0-9]+-[0-9]+-[0-9]+/GTID #-#-#/ / cid=[0-9]+//
+
+}
--eval show binlog events $_in_binlog_file from $_binlog_start
diff --git a/mysql-test/suite/binlog/r/binlog_xa_prepared_bugs.result
b/mysql-test/suite/binlog/r/binlog_xa_prepared_bugs.result
new file mode 100644
index 00000000000..35b7accfb24
--- /dev/null
+++ b/mysql-test/suite/binlog/r/binlog_xa_prepared_bugs.result
@@ -0,0 +1,53 @@
+CREATE TABLE ta (c INT KEY) engine=Aria;
+XA START 'xid_a';
+INSERT INTO ta VALUES (1);
+XA END 'xid_a';
+XA PREPARE 'xid_a';
+Warnings:
+Warning 1030 Got error 131 "Command not supported by the engine"
from storage engine Aria
+LOAD INDEX INTO CACHE c KEY(PRIMARY);
+Table Op Msg_type Msg_text
+test.c preload_keys Error XAER_RMFAIL: The command cannot be executed
when global transaction is in the PREPARED state
+test.c preload_keys Error XAER_RMFAIL: The command cannot be executed
when global transaction is in the PREPARED state
+test.c preload_keys error Corrupt
+Warnings:
+Warning 1196 Some non-transactional changed tables couldn't be
rolled back
+XA ROLLBACK 'xid_a';
+CREATE TABLE ti (c INT KEY) engine=Innodb;
+XA START 'xid_i';
+INSERT INTO ti VALUES (1);
+XA END 'xid_i';
+XA PREPARE 'xid_i';
+LOAD INDEX INTO CACHE c KEY(PRIMARY);
+Table Op Msg_type Msg_text
+test.c preload_keys Error XAER_RMFAIL: The command cannot be executed
when global transaction is in the PREPARED state
+test.c preload_keys Error XAER_RMFAIL: The command cannot be executed
when global transaction is in the PREPARED state
+test.c preload_keys error Corrupt
+XA COMMIT 'xid_i';
+SELECT * FROM ti;
+c
+include/show_binlog_events.inc
+Log_name Pos Event_type Server_id End_log_pos Info
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; CREATE
TABLE ta (c INT KEY) engine=Aria
+master-bin.000001 # Gtid # # BEGIN GTID #-#-#
+master-bin.000001 # Annotate_rows # # INSERT INTO ta
VALUES (1)
+master-bin.000001 # Table_map # # table_id: #
(test.ta)
+master-bin.000001 # Write_rows_v1 # # table_id: #
flags: STMT_END_F
+master-bin.000001 # Query # # COMMIT
+master-bin.000001 # Gtid # # XA START
X'7869645f61',X'',1 GTID #-#-#
+master-bin.000001 # Query # # XA END
X'7869645f61',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7869645f61',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK
X'7869645f61',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; CREATE
TABLE ti (c INT KEY) engine=Innodb
+master-bin.000001 # Gtid # # XA START
X'7869645f69',X'',1 GTID #-#-#
+master-bin.000001 # Annotate_rows # # INSERT INTO ti
VALUES (1)
+master-bin.000001 # Table_map # # table_id: #
(test.ti)
+master-bin.000001 # Write_rows_v1 # # table_id: #
flags: STMT_END_F
+master-bin.000001 # Query # # XA END
X'7869645f69',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7869645f69',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK
X'7869645f69',X'',1
+drop table ta,ti;
diff --git a/mysql-test/suite/binlog/t/binlog_xa_prepared_bugs.test
b/mysql-test/suite/binlog/t/binlog_xa_prepared_bugs.test
new file mode 100644
index 00000000000..3a5bb15968e
--- /dev/null
+++ b/mysql-test/suite/binlog/t/binlog_xa_prepared_bugs.test
@@ -0,0 +1,30 @@
+--source include/have_binlog_format_row.inc
+--source include/have_innodb.inc
+
+CREATE TABLE ta (c INT KEY) engine=Aria;
+XA START 'xid_a';
+INSERT INTO ta VALUES (1);
+XA END 'xid_a';
+XA PREPARE 'xid_a';
+
+#--error ER_XAER_RMFAIL
+LOAD INDEX INTO CACHE c KEY(PRIMARY);
+
+XA ROLLBACK 'xid_a';
+
+CREATE TABLE ti (c INT KEY) engine=Innodb;
+XA START 'xid_i';
+INSERT INTO ti VALUES (1);
+XA END 'xid_i';
+XA PREPARE 'xid_i';
+
+# --error ER_XAER_RMFAIL
+LOAD INDEX INTO CACHE c KEY(PRIMARY);
+
+XA COMMIT 'xid_i';
+SELECT * FROM ti;
+
+#
+--source include/show_binlog_events.inc
+
+drop table ta,ti;
diff --git a/mysql-test/suite/rpl/include/rpl_xa_concurrent_2pc.inc
b/mysql-test/suite/rpl/include/rpl_xa_concurrent_2pc.inc
new file mode 100644
index 00000000000..d1f1868d2c9
--- /dev/null
+++ b/mysql-test/suite/rpl/include/rpl_xa_concurrent_2pc.inc
@@ -0,0 +1,442 @@
+#
+# Helper file to run the 1-4(a,b) test cases for rpl_xa_concurrent_2pc,
+# with either XA COMMIT or XA ROLLBACK used to complete XA transactions.
+#
+# Parameters
+# $xa_complete_sym (string) : COMMIT or ROLLBACK, the action used to complete
+# a prepared XA transaction
+#
+
+if (!$xa_complete_sym)
+{
+ die MTR variable xa_complete_sym not specified, must be either COMMIT or
ROLLBACK;
+}
+
+--let $is_xac= 0
+--let $is_xar= 0
+
+if (`SELECT strcmp("COMMIT", "$xa_complete_sym") = 0`)
+{
+ --let $is_xac= 1
+}
+
+if (`SELECT strcmp("ROLLBACK", "$xa_complete_sym") = 0`)
+{
+ --let $is_xar= 1
+}
+
+if (`SELECT !$is_xar && !$is_xac`)
+{
+ die MTR variable xa_complete_sym invalid, must be either COMMIT or
ROLLBACK;
+}
+
+
+--echo #
+--echo # Initialize test data
+--connection slave
+--source include/stop_slave.inc
+RESET SLAVE;
+set @@global.gtid_slave_pos= "";
+
+if ($is_xac)
+{
+--connection slave
+RESET MASTER;
+
+--connection master
+RESET MASTER;
+}
+
+--connection master
+create table t1 (a int primary key, b int) engine=innodb;
+
+# Slave locks this row before updates to pause transaction progress
+--let $hold_row= -1
+--let $t1_ctr= 0
+--eval insert into t1 values ($hold_row, 0)
+
+--source include/save_master_gtid.inc
+
+--connection slave
+--source include/start_slave.inc
+--source include/sync_with_master_gtid.inc
+--source include/stop_slave.inc
+set @save_debug= @@GLOBAL.debug_dbug;
+set @save_par_thds= @@GLOBAL.slave_parallel_threads;
+set @save_par_mode= @@GLOBAL.slave_parallel_mode;
+set @@GLOBAL.slave_parallel_threads= 4;
+set @@GLOBAL.slave_parallel_mode= optimistic;
+
+set statement sql_log_bin=0 for call mtr.add_suppression("Commit failed due to
failure of an earlier commit on which this one depends");
+
+
+--echo #
+--echo # Test Case 1: Ensure that a 2-phase XA transaction has its XA PREPARE
+--echo # and XA $xa_complete_sym run concurrently. That is, the
+--echo # XA $xa_complete_sym will wait at group commit until the XA PREPARE
+--echo # binlogs, and then it will wait again until the XA PREPARE finishes
+--echo # preparing in all engines. At this point, the XA $xa_complete_sym will
+--echo # run to completion.
+--connection master
+# For worker thread to hold XAP at dequeue time via debug_sync through
+# `hold_worker_on_schedule`.
+set @@session.gtid_seq_no= 100;
+XA START 'x';
+--eval insert into t1 values ($t1_ctr, 0)
+--inc $t1_ctr
+XA END 'x';
+XA PREPARE 'x';
+--eval XA $xa_complete_sym 'x'
+--source include/save_master_gtid.inc
+
+--connection slave
+# For worker to stop at dequeue event time and after binlogging XA PREPARE
+set @@global.debug_dbug=
"+d,hold_worker_on_schedule,stop_after_binlog_prepare";
+--source include/start_slave.inc
+
+--echo # Waiting for XAP to pause when it is pulled from the queue
+set debug_sync= "now wait_for reached_pause";
+
+--echo # Before the XA PREPARE executes, the XA $xa_complete_sym should wait
in group commit..
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior transaction to
commit"
+--source include/wait_condition.inc
+--echo # ..done
+
+
+--echo # Execute the XA PREPARE
+set debug_sync= "now signal continue_worker";
+
+--echo # Wait for XA PREPARE to have binlogged, but hold it before it prepares
in engines
+set debug_sync= "now wait_for xa_prepare_binlogged";
+
+--echo # The XA $xa_complete_sym should move on from binlog to wait for the XA
PREPARE to complete in engines
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior xa transaction"
+--source include/wait_condition.inc
+--echo # ..done
+
+--echo # Signal the XAP to complete in engines (which will automatically
signal XAC)
+set debug_sync= "now signal continue_xap";
+
+--source include/sync_with_master_gtid.inc
+
+--let $diff_tables=master:test.t1, slave:test.t1
+--source include/diff_tables.inc
+
+--connection slave
+--source include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+
+
+--echo #
+--echo # Test Case 2: If two XA $xa_complete_sym transactions have different
+--echo # XIDs, ensure both phases of both transactions all execute
concurrently.
+--echo #
+
+--echo # Ensure slave is stopped
+--connection slave
+--source include/wait_for_slave_to_stop.inc
+
+# Stop both XAP after their binlogging and before their engine changing
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare";
+
+--connection master
+XA START 'x1';
+--eval insert into t1 values ($t1_ctr, 0)
+--inc $t1_ctr
+XA END 'x1';
+XA PREPARE 'x1';
+--eval XA $xa_complete_sym 'x1'
+
+XA START 'x2';
+--eval insert into t1 values ($t1_ctr, 0)
+--inc $t1_ctr
+XA END 'x2';
+XA PREPARE 'x2';
+--eval XA $xa_complete_sym 'x2'
+--source include/save_master_gtid.inc
+
+--connection slave
+--source include/start_slave.inc
+
+# This stage is necessary to avoid XAP_1 <-register-> XAC_2 race in that
+# XAC_2 may get stuck in the below WFPT2C state all time until XAP_1 has
finished.
+# Prove the workers' status are like the following:
+--let $count_wait= 2
+--let $wait_condition=SELECT count(*) = $count_wait FROM
information_schema.processlist WHERE command = 'Slave_worker' AND state LIKE
"Waiting for prior transaction to commit"
+--source include/wait_condition.inc
+
+--let $count_wait= 2
+--let $wait_condition=SELECT count(*) = $count_wait FROM
information_schema.processlist WHERE command = 'Slave_worker' AND state LIKE
"debug sync point: now"
+--source include/wait_condition.inc
+set debug_sync= "now signal binlog_xap";
+
+# wait for two XAP:s arrive at their stations (XAP_1 to next one after binlog
is done)
+--let $wait_condition=SELECT count(*) >= 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "debug sync point: now"
+--source include/wait_condition.inc
+set debug_sync= "now signal binlog_xap";
+
+--echo # Ensuring both phases of both transactions all execute concurrently
+# Waiting for both XA "COMPLETE"s to binlog proves this, as they would not pass
+# group commit if their preceding XA PREPAREs had not also binlogged
+--let $count_xa_wait_workers= 2
+
+--let $wait_condition=SELECT count(*) = $count_xa_wait_workers FROM
information_schema.processlist WHERE command = 'Slave_worker' AND state LIKE
"Waiting for prior xa transaction"
+--source include/wait_condition.inc
+--echo # ..done
+
+--echo # Verify XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+
+--echo # Signal the XAPs to complete in engines (which will automatically
signal XACs)
+set debug_sync= "now signal continue_xap";
+
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "debug sync point: now"
+--source include/wait_condition.inc
+set debug_sync= "now signal continue_xap";
+
+--source include/sync_with_master_gtid.inc
+
+--let $diff_tables=master:test.t1, slave:test.t1
+--source include/diff_tables.inc
+
+--connection slave
+--source include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+
+
+--echo #
+--echo # Test Case 3: Two current 2-phase XA transactions with matching XIDs
+--echo # should run one after the other, while each transaction still allows
+--echo # its XA PREPARE and XA $xa_complete_sym to run concurrently
+
+--echo # Ensure slave is stopped
+--connection slave
+--source include/wait_for_slave_to_stop.inc
+
+# Stop both XAP after their binlogging and before their engine changing
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare,stop_after_binlog_cor_by_xid";
+
+--connection master
+XA START 'x';
+--eval insert into t1 values ($t1_ctr, 0)
+--inc $t1_ctr
+XA END 'x';
+XA PREPARE 'x';
+--eval XA $xa_complete_sym 'x'
+
+XA START 'x';
+--eval insert into t1 values ($t1_ctr, 0)
+--inc $t1_ctr
+XA END 'x';
+XA PREPARE 'x';
+--eval XA $xa_complete_sym 'x'
+--source include/save_master_gtid.inc
+
+--connection slave
+--source include/start_slave.inc
+
+# This stage is necessary to avoid XAP_1 <-register-> XAC_2 race in that
+# XAC_2 may get stuck in the below WFPT2C state all time until XAP_1 has
finished.
+--let $count_wait= 3
+--let $wait_condition=SELECT count(*) = $count_wait FROM
information_schema.processlist WHERE command = 'Slave_worker' AND state LIKE
"Waiting for prior transaction to commit"
+
+--source include/wait_condition.inc
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "debug sync point: now"
+--source include/wait_condition.inc
+set debug_sync= "now signal binlog_xap";
+
+--echo # Verify first XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+
+--echo # Ensure first XA transaction is running concurrently
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior xa
transaction" AND info LIKE "XA $xa_complete_sym%"
+--source include/wait_condition.inc
+
+--echo # Ensure second XA transaction's XAP waits for the first transaction
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior xa
transaction" AND info LIKE "XA START%"
+--source include/wait_condition.inc
+
+--echo # Signal first XA PREPARE to complete
+set debug_sync= "now signal continue_xap";
+
+--echo # Wait for first XA $xa_complete_sym to binlog
+set debug_sync= "now wait_for xa_cor_binlogged";
+
+--echo # Ensure second XA PREPARE doesn't begin yet because the XAC hadn't
released its XID
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior xa transaction"
+--source include/wait_condition.inc
+
+--echo # Signal first XA $xa_complete_sym to complete
+set debug_sync= "now signal continue_xa_cor";
+
+--echo # Wait for second XA PREPARE to binlogged
+--echo # First pass through binlog_xap
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "debug sync point: now"
+--source include/wait_condition.inc
+set debug_sync= "now signal binlog_xap";
+set debug_sync= "now wait_for xa_prepare_binlogged";
+
+--echo # Ensure second XA $xa_complete_sym is concurrent with XAP
+--let $wait_condition=SELECT count(*) = 1 FROM information_schema.processlist
WHERE command = 'Slave_worker' AND state LIKE "Waiting for prior xa transaction"
+--source include/wait_condition.inc
+
+--echo # Signal second XA transaction to complete
+set debug_sync= "now signal continue_xap";
+set debug_sync= "now wait_for xa_cor_binlogged";
+set debug_sync= "now signal continue_xa_cor";
+
+--source include/sync_with_master_gtid.inc
+
+--let $diff_tables=master:test.t1, slave:test.t1
+--source include/diff_tables.inc
+
+--connection slave
+--source include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+
+
+--echo #
+--echo # Test Case 4 (Error Case): If an XA PREPARE errors while its
+--echo # XA $xa_complete_sym is waiting on it, both phases should rollback
+--echo # successfully. Note this tests both:
+--echo # a) XA $xa_complete_sym is waiting in group commit (first phase
+--echo # times out in DMLs)
+--echo # b) XA $xa_complete_sym is waiting in group commit, with another XAP
+--echo # with a duplicate XID waiting on it.
+
+--echo # Case a)
+--echo # Ensure slave is stopped
+--connection slave
+--source include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+
+--connection master
+XA START 'x';
+--eval update t1 set b=b+1 where a=$hold_row
+XA END 'x';
+XA PREPARE 'x';
+--eval XA $xa_complete_sym 'x'
+--source include/save_master_gtid.inc
+
+--connection slave1
+BEGIN;
+--eval select * from t1 where a=$hold_row for update;
+
+--connection slave
+--source include/start_slave.inc
+
+--let $slave_sql_errno= 1205
+--source include/wait_for_slave_sql_error.inc
+
+--connection slave1
+ROLLBACK;
+
+--connection slave
+# Stop the IO thread too
+--source include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+
+--echo # Ensure on slave restart, we can re-execute the XA transaction
+--source include/start_slave.inc
+--source include/save_master_gtid.inc
+--source include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+
+
+--echo # Case b)
+--echo # Ensure slave is stopped
+--connection slave
+--source include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+
+--connection master
+XA START 'x';
+--eval update t1 set b=b+1 where a=$hold_row
+XA END 'x';
+XA PREPARE 'x';
+--eval XA $xa_complete_sym 'x'
+
+XA START 'x';
+--eval insert into t1 values ($t1_ctr, 0)
+--let $new_row_idx= $t1_ctr
+--inc $t1_ctr
+XA END 'x';
+XA PREPARE 'x';
+--source include/save_master_gtid.inc
+--eval XA $xa_complete_sym 'x'
+
+--connection slave1
+BEGIN;
+--eval select * from t1 where a=$hold_row for update;
+
+--connection slave
+--source include/start_slave.inc
+
+--let $slave_sql_errno= 1205
+--source include/wait_for_slave_sql_error.inc
+
+--connection slave1
+ROLLBACK;
+
+--echo # There should not be any prepared rows seen by XA RECOVER
+XA RECOVER;
+
+--echo # Ensuring data from second XAP isn't visible..
+if (`select count(*) from t1 where a=$new_row_idx`)
+{
+ --die Failed, row exists
+}
+--echo # ..done
+
+--connection slave
+--source include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+
+--echo # Ensure on slave restart, we can re-execute the XA transaction
+--source include/start_slave.inc
+--source include/save_master_gtid.inc
+--source include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+--source include/start_slave.inc
+
+--echo # Ensuring data from second XAP is visible..
+if ($is_xac)
+{
+ --let $expected_row_count= 1
+}
+if ($is_xar)
+{
+ --let $expected_row_count= 0
+}
+if (`select count(*) != $expected_row_count from t1 where a=$new_row_idx`)
+{
+ --die Failed, XA $xa_complete_sym was not observed
+}
+--echo # ..done
+
+--echo #
+--echo # Cleanup
+--connection master
+DROP TABLE t1;
+--source include/save_master_gtid.inc
+--let $binlog_file=query_get_value(SHOW MASTER STATUS, File, 1)
+--source include/show_binlog_events.inc
+
+--connection slave
+--source include/sync_with_master_gtid.inc
+--let $binlog_file=query_get_value(SHOW MASTER STATUS, File, 1)
+--let $filter_cid=1
+--source include/show_binlog_events2.inc
+
+--source include/stop_slave.inc
+set @@GLOBAL.slave_parallel_threads= @save_par_thds;
+set @@GLOBAL.slave_parallel_mode= @save_par_mode;
+--source include/start_slave.inc
diff --git a/mysql-test/suite/rpl/r/rpl_xa_concurrent_2pc.result
b/mysql-test/suite/rpl/r/rpl_xa_concurrent_2pc.result
new file mode 100644
index 00000000000..d30943b23da
--- /dev/null
+++ b/mysql-test/suite/rpl/r/rpl_xa_concurrent_2pc.result
@@ -0,0 +1,953 @@
+include/master-slave.inc
+[connection master]
+#
+# Initialize test data
+connection slave;
+include/stop_slave.inc
+RESET SLAVE;
+set @@global.gtid_slave_pos= "";
+connection slave;
+RESET MASTER;
+connection master;
+RESET MASTER;
+connection master;
+create table t1 (a int primary key, b int) engine=innodb;
+insert into t1 values (-1, 0);
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+include/stop_slave.inc
+set @save_debug= @@GLOBAL.debug_dbug;
+set @save_par_thds= @@GLOBAL.slave_parallel_threads;
+set @save_par_mode= @@GLOBAL.slave_parallel_mode;
+set @@GLOBAL.slave_parallel_threads= 4;
+set @@GLOBAL.slave_parallel_mode= optimistic;
+set statement sql_log_bin=0 for call mtr.add_suppression("Commit failed due to
failure of an earlier commit on which this one depends");
+#
+# Test Case 1: Ensure that a 2-phase XA transaction has its XA PREPARE
+# and XA COMMIT run concurrently. That is, the
+# XA COMMIT will wait at group commit until the XA PREPARE
+# binlogs, and then it will wait again until the XA PREPARE finishes
+# preparing in all engines. At this point, the XA COMMIT will
+# run to completion.
+connection master;
+set @@session.gtid_seq_no= 100;
+XA START 'x';
+insert into t1 values (0, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA COMMIT 'x';
+include/save_master_gtid.inc
+connection slave;
+set @@global.debug_dbug=
"+d,hold_worker_on_schedule,stop_after_binlog_prepare";
+include/start_slave.inc
+# Waiting for XAP to pause when it is pulled from the queue
+set debug_sync= "now wait_for reached_pause";
+# Before the XA PREPARE executes, the XA COMMIT should wait in group commit..
+# ..done
+# Execute the XA PREPARE
+set debug_sync= "now signal continue_worker";
+# Wait for XA PREPARE to have binlogged, but hold it before it prepares in
engines
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# The XA COMMIT should move on from binlog to wait for the XA PREPARE to
complete in engines
+# ..done
+# Signal the XAP to complete in engines (which will automatically signal XAC)
+set debug_sync= "now signal continue_xap";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 2: If two XA COMMIT transactions have different
+# XIDs, ensure both phases of both transactions all execute concurrently.
+#
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare";
+connection master;
+XA START 'x1';
+insert into t1 values (1, 0);
+XA END 'x1';
+XA PREPARE 'x1';
+XA COMMIT 'x1';
+XA START 'x2';
+insert into t1 values (2, 0);
+XA END 'x2';
+XA PREPARE 'x2';
+XA COMMIT 'x2';
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+set debug_sync= "now signal binlog_xap";
+set debug_sync= "now signal binlog_xap";
+# Ensuring both phases of both transactions all execute concurrently
+# ..done
+# Verify XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Signal the XAPs to complete in engines (which will automatically signal XACs)
+set debug_sync= "now signal continue_xap";
+set debug_sync= "now signal continue_xap";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 3: Two current 2-phase XA transactions with matching XIDs
+# should run one after the other, while each transaction still allows
+# its XA PREPARE and XA COMMIT to run concurrently
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare,stop_after_binlog_cor_by_xid";
+connection master;
+XA START 'x';
+insert into t1 values (3, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA COMMIT 'x';
+XA START 'x';
+insert into t1 values (4, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA COMMIT 'x';
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+set debug_sync= "now signal binlog_xap";
+# Verify first XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Ensure first XA transaction is running concurrently
+# Ensure second XA transaction's XAP waits for the first transaction
+# Signal first XA PREPARE to complete
+set debug_sync= "now signal continue_xap";
+# Wait for first XA COMMIT to binlog
+set debug_sync= "now wait_for xa_cor_binlogged";
+# Ensure second XA PREPARE doesn't begin yet because the XAC hadn't released
its XID
+# Signal first XA COMMIT to complete
+set debug_sync= "now signal continue_xa_cor";
+# Wait for second XA PREPARE to binlogged
+# First pass through binlog_xap
+set debug_sync= "now signal binlog_xap";
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Ensure second XA COMMIT is concurrent with XAP
+# Signal second XA transaction to complete
+set debug_sync= "now signal continue_xap";
+set debug_sync= "now wait_for xa_cor_binlogged";
+set debug_sync= "now signal continue_xa_cor";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 4 (Error Case): If an XA PREPARE errors while its
+# XA COMMIT is waiting on it, both phases should rollback
+# successfully. Note this tests both:
+# a) XA COMMIT is waiting in group commit (first phase
+# times out in DMLs)
+# b) XA COMMIT is waiting in group commit, with another XAP
+# with a duplicate XID waiting on it.
+# Case a)
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+connection master;
+XA START 'x';
+update t1 set b=b+1 where a=-1;
+XA END 'x';
+XA PREPARE 'x';
+XA COMMIT 'x';
+include/save_master_gtid.inc
+connection slave1;
+BEGIN;
+select * from t1 where a=-1 for update;;
+a b
+-1 0
+connection slave;
+include/start_slave.inc
+include/wait_for_slave_sql_error.inc [errno=1205]
+connection slave1;
+ROLLBACK;
+connection slave;
+include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+# Ensure on slave restart, we can re-execute the XA transaction
+include/start_slave.inc
+include/save_master_gtid.inc
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+# Case b)
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+connection master;
+XA START 'x';
+update t1 set b=b+1 where a=-1;
+XA END 'x';
+XA PREPARE 'x';
+XA COMMIT 'x';
+XA START 'x';
+insert into t1 values (5, 0);
+XA END 'x';
+XA PREPARE 'x';
+include/save_master_gtid.inc
+XA COMMIT 'x';
+connection slave1;
+BEGIN;
+select * from t1 where a=-1 for update;;
+a b
+-1 1
+connection slave;
+include/start_slave.inc
+include/wait_for_slave_sql_error.inc [errno=1205]
+connection slave1;
+ROLLBACK;
+# There should not be any prepared rows seen by XA RECOVER
+XA RECOVER;
+formatID gtrid_length bqual_length data
+# Ensuring data from second XAP isn't visible..
+# ..done
+connection slave;
+include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+# Ensure on slave restart, we can re-execute the XA transaction
+include/start_slave.inc
+include/save_master_gtid.inc
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+include/start_slave.inc
+# Ensuring data from second XAP is visible..
+# ..done
+#
+# Cleanup
+connection master;
+DROP TABLE t1;
+include/save_master_gtid.inc
+include/show_binlog_events.inc
+Log_name Pos Event_type Server_id End_log_pos Info
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+master-bin.000001 # Gtid # # BEGIN GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (-1, 0)
+master-bin.000001 # Xid # # COMMIT /* XID */
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (0, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'7831',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (1, 0)
+master-bin.000001 # Query # # XA END X'7831',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7831',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'7831',X'',1
+master-bin.000001 # Gtid # # XA START X'7832',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (2, 0)
+master-bin.000001 # Query # # XA END X'7832',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7832',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'7832',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (3, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (4, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (5, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; DROP TABLE
`t1` /* generated by server */
+connection slave;
+include/sync_with_master_gtid.inc
+show binlog events in 'slave-bin.000001' from <binlog_start>;
+Log_name Pos Event_type Server_id End_log_pos Info
+slave-bin.000001 # Gtid_list 2 # []
+slave-bin.000001 # Binlog_checkpoint 2 #
slave-bin.000001
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+slave-bin.000001 # Gtid 1 # BEGIN GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (-1, 0)
+slave-bin.000001 # Xid 1 # COMMIT /* XID */
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (0, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7831',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (1, 0)
+slave-bin.000001 # Query 1 # XA END X'7831',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7831',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7831',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7832',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (2, 0)
+slave-bin.000001 # Query 1 # XA END X'7832',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7832',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7832',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (3, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (4, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (5, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; DROP TABLE
IF EXISTS `t1` /* generated by server */
+include/stop_slave.inc
+set @@GLOBAL.slave_parallel_threads= @save_par_thds;
+set @@GLOBAL.slave_parallel_mode= @save_par_mode;
+include/start_slave.inc
+#
+# Initialize test data
+connection slave;
+include/stop_slave.inc
+RESET SLAVE;
+set @@global.gtid_slave_pos= "";
+connection master;
+create table t1 (a int primary key, b int) engine=innodb;
+insert into t1 values (-1, 0);
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+include/stop_slave.inc
+set @save_debug= @@GLOBAL.debug_dbug;
+set @save_par_thds= @@GLOBAL.slave_parallel_threads;
+set @save_par_mode= @@GLOBAL.slave_parallel_mode;
+set @@GLOBAL.slave_parallel_threads= 4;
+set @@GLOBAL.slave_parallel_mode= optimistic;
+set statement sql_log_bin=0 for call mtr.add_suppression("Commit failed due to
failure of an earlier commit on which this one depends");
+#
+# Test Case 1: Ensure that a 2-phase XA transaction has its XA PREPARE
+# and XA ROLLBACK run concurrently. That is, the
+# XA ROLLBACK will wait at group commit until the XA PREPARE
+# binlogs, and then it will wait again until the XA PREPARE finishes
+# preparing in all engines. At this point, the XA ROLLBACK will
+# run to completion.
+connection master;
+set @@session.gtid_seq_no= 100;
+XA START 'x';
+insert into t1 values (0, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA ROLLBACK 'x';
+include/save_master_gtid.inc
+connection slave;
+set @@global.debug_dbug=
"+d,hold_worker_on_schedule,stop_after_binlog_prepare";
+include/start_slave.inc
+# Waiting for XAP to pause when it is pulled from the queue
+set debug_sync= "now wait_for reached_pause";
+# Before the XA PREPARE executes, the XA ROLLBACK should wait in group commit..
+# ..done
+# Execute the XA PREPARE
+set debug_sync= "now signal continue_worker";
+# Wait for XA PREPARE to have binlogged, but hold it before it prepares in
engines
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# The XA ROLLBACK should move on from binlog to wait for the XA PREPARE to
complete in engines
+# ..done
+# Signal the XAP to complete in engines (which will automatically signal XAC)
+set debug_sync= "now signal continue_xap";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 2: If two XA ROLLBACK transactions have different
+# XIDs, ensure both phases of both transactions all execute concurrently.
+#
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare";
+connection master;
+XA START 'x1';
+insert into t1 values (1, 0);
+XA END 'x1';
+XA PREPARE 'x1';
+XA ROLLBACK 'x1';
+XA START 'x2';
+insert into t1 values (2, 0);
+XA END 'x2';
+XA PREPARE 'x2';
+XA ROLLBACK 'x2';
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+set debug_sync= "now signal binlog_xap";
+set debug_sync= "now signal binlog_xap";
+# Ensuring both phases of both transactions all execute concurrently
+# ..done
+# Verify XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Signal the XAPs to complete in engines (which will automatically signal XACs)
+set debug_sync= "now signal continue_xap";
+set debug_sync= "now signal continue_xap";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 3: Two current 2-phase XA transactions with matching XIDs
+# should run one after the other, while each transaction still allows
+# its XA PREPARE and XA ROLLBACK to run concurrently
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @@global.debug_dbug=
"+d,stop_before_binlog_prepare,stop_after_binlog_prepare,stop_after_binlog_cor_by_xid";
+connection master;
+XA START 'x';
+insert into t1 values (3, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA ROLLBACK 'x';
+XA START 'x';
+insert into t1 values (4, 0);
+XA END 'x';
+XA PREPARE 'x';
+XA ROLLBACK 'x';
+include/save_master_gtid.inc
+connection slave;
+include/start_slave.inc
+set debug_sync= "now signal binlog_xap";
+# Verify first XA PREPARE has binlogged
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Ensure first XA transaction is running concurrently
+# Ensure second XA transaction's XAP waits for the first transaction
+# Signal first XA PREPARE to complete
+set debug_sync= "now signal continue_xap";
+# Wait for first XA ROLLBACK to binlog
+set debug_sync= "now wait_for xa_cor_binlogged";
+# Ensure second XA PREPARE doesn't begin yet because the XAC hadn't released
its XID
+# Signal first XA ROLLBACK to complete
+set debug_sync= "now signal continue_xa_cor";
+# Wait for second XA PREPARE to binlogged
+# First pass through binlog_xap
+set debug_sync= "now signal binlog_xap";
+set debug_sync= "now wait_for xa_prepare_binlogged";
+# Ensure second XA ROLLBACK is concurrent with XAP
+# Signal second XA transaction to complete
+set debug_sync= "now signal continue_xap";
+set debug_sync= "now wait_for xa_cor_binlogged";
+set debug_sync= "now signal continue_xa_cor";
+include/sync_with_master_gtid.inc
+include/diff_tables.inc [master:test.t1, slave:test.t1]
+connection slave;
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+#
+# Test Case 4 (Error Case): If an XA PREPARE errors while its
+# XA ROLLBACK is waiting on it, both phases should rollback
+# successfully. Note this tests both:
+# a) XA ROLLBACK is waiting in group commit (first phase
+# times out in DMLs)
+# b) XA ROLLBACK is waiting in group commit, with another XAP
+# with a duplicate XID waiting on it.
+# Case a)
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+connection master;
+XA START 'x';
+update t1 set b=b+1 where a=-1;
+XA END 'x';
+XA PREPARE 'x';
+XA ROLLBACK 'x';
+include/save_master_gtid.inc
+connection slave1;
+BEGIN;
+select * from t1 where a=-1 for update;;
+a b
+-1 0
+connection slave;
+include/start_slave.inc
+include/wait_for_slave_sql_error.inc [errno=1205]
+connection slave1;
+ROLLBACK;
+connection slave;
+include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+# Ensure on slave restart, we can re-execute the XA transaction
+include/start_slave.inc
+include/save_master_gtid.inc
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+# Case b)
+# Ensure slave is stopped
+connection slave;
+include/wait_for_slave_to_stop.inc
+set @save_lock_wait_timeout= @@GLOBAL.innodb_lock_wait_timeout;
+set @save_trans_retries= @@GLOBAL.slave_transaction_retries;
+set @@global.innodb_lock_wait_timeout= 1;
+set @@global.slave_transaction_retries= 0;
+connection master;
+XA START 'x';
+update t1 set b=b+1 where a=-1;
+XA END 'x';
+XA PREPARE 'x';
+XA ROLLBACK 'x';
+XA START 'x';
+insert into t1 values (5, 0);
+XA END 'x';
+XA PREPARE 'x';
+include/save_master_gtid.inc
+XA ROLLBACK 'x';
+connection slave1;
+BEGIN;
+select * from t1 where a=-1 for update;;
+a b
+-1 0
+connection slave;
+include/start_slave.inc
+include/wait_for_slave_sql_error.inc [errno=1205]
+connection slave1;
+ROLLBACK;
+# There should not be any prepared rows seen by XA RECOVER
+XA RECOVER;
+formatID gtrid_length bqual_length data
+# Ensuring data from second XAP isn't visible..
+# ..done
+connection slave;
+include/stop_slave_io.inc
+set @@global.innodb_lock_wait_timeout= @save_lock_wait_timeout;
+set @@global.slave_transaction_retries= @save_trans_retries;
+# Ensure on slave restart, we can re-execute the XA transaction
+include/start_slave.inc
+include/save_master_gtid.inc
+include/stop_slave.inc
+set @@global.debug_dbug= @save_debug;
+include/start_slave.inc
+# Ensuring data from second XAP is visible..
+# ..done
+#
+# Cleanup
+connection master;
+DROP TABLE t1;
+include/save_master_gtid.inc
+include/show_binlog_events.inc
+Log_name Pos Event_type Server_id End_log_pos Info
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+master-bin.000001 # Gtid # # BEGIN GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (-1, 0)
+master-bin.000001 # Xid # # COMMIT /* XID */
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (0, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'7831',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (1, 0)
+master-bin.000001 # Query # # XA END X'7831',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7831',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'7831',X'',1
+master-bin.000001 # Gtid # # XA START X'7832',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (2, 0)
+master-bin.000001 # Query # # XA END X'7832',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7832',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'7832',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (3, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (4, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (5, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA COMMIT X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; DROP TABLE
`t1` /* generated by server */
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+master-bin.000001 # Gtid # # BEGIN GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (-1, 0)
+master-bin.000001 # Xid # # COMMIT /* XID */
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (0, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'7831',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (1, 0)
+master-bin.000001 # Query # # XA END X'7831',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7831',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK
X'7831',X'',1
+master-bin.000001 # Gtid # # XA START X'7832',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (2, 0)
+master-bin.000001 # Query # # XA END X'7832',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'7832',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK
X'7832',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (3, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (4, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; update t1
set b=b+1 where a=-1
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # XA START X'78',X'',1
GTID #-#-#
+master-bin.000001 # Query # # use `test`; insert into
t1 values (5, 0)
+master-bin.000001 # Query # # XA END X'78',X'',1
+master-bin.000001 # XA_prepare # # XA PREPARE
X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # XA ROLLBACK X'78',X'',1
+master-bin.000001 # Gtid # # GTID #-#-#
+master-bin.000001 # Query # # use `test`; DROP TABLE
`t1` /* generated by server */
+connection slave;
+include/sync_with_master_gtid.inc
+show binlog events in 'slave-bin.000001' from <binlog_start>;
+Log_name Pos Event_type Server_id End_log_pos Info
+slave-bin.000001 # Gtid_list 2 # []
+slave-bin.000001 # Binlog_checkpoint 2 #
slave-bin.000001
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+slave-bin.000001 # Gtid 1 # BEGIN GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (-1, 0)
+slave-bin.000001 # Xid 1 # COMMIT /* XID */
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (0, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7831',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (1, 0)
+slave-bin.000001 # Query 1 # XA END X'7831',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7831',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7831',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7832',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (2, 0)
+slave-bin.000001 # Query 1 # XA END X'7832',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7832',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7832',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (3, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (4, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (5, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; DROP TABLE
IF EXISTS `t1` /* generated by server */
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+slave-bin.000001 # Gtid 1 # BEGIN GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (-1, 0)
+slave-bin.000001 # Xid 1 # COMMIT /* XID */
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (0, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7831',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (1, 0)
+slave-bin.000001 # Query 1 # XA END X'7831',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7831',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7831',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7832',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (2, 0)
+slave-bin.000001 # Query 1 # XA END X'7832',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7832',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'7832',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (3, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (4, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (5, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA COMMIT X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; DROP TABLE
IF EXISTS `t1` /* generated by server */
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; create
table t1 (a int primary key, b int) engine=innodb
+slave-bin.000001 # Gtid 1 # BEGIN GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (-1, 0)
+slave-bin.000001 # Xid 1 # COMMIT /* XID */
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (0, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7831',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (1, 0)
+slave-bin.000001 # Query 1 # XA END X'7831',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7831',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK
X'7831',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'7832',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (2, 0)
+slave-bin.000001 # Query 1 # XA END X'7832',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'7832',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK
X'7832',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (3, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (4, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; update t1
set b=b+1 where a=-1
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # XA START X'78',X'',1
GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; insert into
t1 values (5, 0)
+slave-bin.000001 # Query 1 # XA END X'78',X'',1
+slave-bin.000001 # XA_prepare 1 # XA PREPARE
X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # XA ROLLBACK X'78',X'',1
+slave-bin.000001 # Gtid 1 # GTID #-#-#
+slave-bin.000001 # Query 1 # use `test`; DROP TABLE
IF EXISTS `t1` /* generated by server */
+include/stop_slave.inc
+set @@GLOBAL.slave_parallel_threads= @save_par_thds;
+set @@GLOBAL.slave_parallel_mode= @save_par_mode;
+include/start_slave.inc
+#
+# Test Case 5: If an XAP is skipped by the replica (e.g. by incorrectly
+# setting gtid_slave_pos), and only its XAC/XAR is tried to execute, the
+# replica should report ER_XAER_NOTA.
+connection master;
+create table t1 (a int) engine=innodb;
+include/save_master_gtid.inc
+connection slave;
+include/sync_with_master_gtid.inc
+call mtr.add_suppression("XAER_NOTA: Unknown XID");
+include/stop_slave.inc
+change master to master_use_gtid = slave_pos;
+connection master;
+xa start '1';
+insert into t1 set a=1;
+xa end '1';
+xa prepare '1';
+xa rollback '1';
+insert into t1 set a=2;
+include/save_master_gtid.inc
+connection slave;
+set @save_gtid_slave_pos= @@global.gtid_slave_pos;
+SELECT CONCAT(domain_id,"-",server_id,"-", seq_no + 1)
+into @gtid_skip
+FROM mysql.gtid_slave_pos
+WHERE seq_no = (SELECT DISTINCT max(seq_no) FROM mysql.gtid_slave_pos) limit 1;
+set @@global.gtid_slave_pos = @gtid_skip;
+start slave;
+include/wait_for_slave_sql_error.inc [errno=1397]
+select count(*) = 2 % 2 as 'must be true' from t1;;
+must be true
+1
+include/stop_slave.inc
+set @@global.gtid_slave_pos = @save_gtid_slave_pos;
+show warnings;
+Level Code Message
+Warning 1947 Specified GTID <value> conflicts with the binary log
which contains a more recent GTID <value>. If MASTER_GTID_POS=CURRENT_POS is
used, the binlog position will override the new value of @@gtid_slave_pos
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+include/stop_slave.inc
+change master to master_use_gtid = slave_pos;
+connection master;
+xa start '1';
+insert into t1 set a=1;
+xa end '1';
+xa prepare '1';
+xa commit '1';
+insert into t1 set a=2;
+include/save_master_gtid.inc
+connection slave;
+set @save_gtid_slave_pos= @@global.gtid_slave_pos;
+SELECT CONCAT(domain_id,"-",server_id,"-", seq_no + 1)
+into @gtid_skip
+FROM mysql.gtid_slave_pos
+WHERE seq_no = (SELECT DISTINCT max(seq_no) FROM mysql.gtid_slave_pos) limit 1;
+set @@global.gtid_slave_pos = @gtid_skip;
+start slave;
+include/wait_for_slave_sql_error.inc [errno=1397]
+select count(*) = 1 % 2 as 'must be true' from t1;;
+must be true
+1
+include/stop_slave.inc
+set @@global.gtid_slave_pos = @save_gtid_slave_pos;
+show warnings;
+Level Code Message
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+connection master;
+drop table t1;
+connection slave;
+include/rpl_end.inc
+# End of rpl_xa_concurrent_2pc.test
diff --git a/mysql-test/suite/rpl/r/rpl_xa_empty_transaction.result
b/mysql-test/suite/rpl/r/rpl_xa_empty_transaction.result
index f3ea53c219a..92a820d6753 100644
--- a/mysql-test/suite/rpl/r/rpl_xa_empty_transaction.result
+++ b/mysql-test/suite/rpl/r/rpl_xa_empty_transaction.result
@@ -1165,5 +1165,56 @@ connection server_1;
set @@binlog_format = @sav_binlog_format;
set @@global.binlog_format = @sav_binlog_format;
connection server_1;
+create table t_not_in_binlog (a int) engine=innodb;
+flush logs;
+include/save_master_gtid.inc
+connect con1,localhost,root,,;
+call mtr.add_suppression("XAER_NOTA: Unknown XID");
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+disconnect con1;
+connection server_1;
+xa recover;
+formatID gtrid_length bqual_length data
+1 1 0 a
+XA ROLLBACK 'a';
+drop table t_not_in_binlog;
+include/save_master_gtid.inc
+connection server_2;
+XAER_NOTA: Unknown XID
+include/wait_for_slave_sql_error.inc [errno=1397]
+connect con2,127.0.0.1,root,,test,$SERVER_MYPORT_2,;
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+disconnect con2;
+connection server_2;
+xa recover;
+formatID gtrid_length bqual_length data
+1 1 0 a
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+connection server_3;
+XAER_NOTA: Unknown XID
+include/wait_for_slave_sql_error.inc [errno=1397]
+connect con3,127.0.0.1,root,,test,$SERVER_MYPORT_3,;
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+disconnect con3;
+connection server_3;
+xa recover;
+formatID gtrid_length bqual_length data
+1 1 0 a
+include/start_slave.inc
+include/sync_with_master_gtid.inc
+connection server_1;
include/rpl_end.inc
# End of rpl_xa_empty_transaction.test
diff --git a/mysql-test/suite/rpl/r/rpl_xa_prepare_gtid_fail.result
b/mysql-test/suite/rpl/r/rpl_xa_prepare_gtid_fail.result
index dd0d132471e..a3f5414b9da 100644
--- a/mysql-test/suite/rpl/r/rpl_xa_prepare_gtid_fail.result
+++ b/mysql-test/suite/rpl/r/rpl_xa_prepare_gtid_fail.result
@@ -42,7 +42,7 @@ connection master;
drop table t1;
connection slave;
# TODO: Remove after fixing MDEV-21777
-set @@global.gtid_slave_pos= "0-1-100";
+set @@global.gtid_slave_pos= "0-1-101";
set @@global.slave_parallel_threads= @save_par_thds;
set @@global.gtid_strict_mode= @save_strict_mode;
set @@global.innodb_lock_wait_timeout= @save_innodb_lock_wait_timeout;
diff --git a/mysql-test/suite/rpl/t/rpl_xa_concurrent_2pc.test
b/mysql-test/suite/rpl/t/rpl_xa_concurrent_2pc.test
new file mode 100644
index 00000000000..d762114ff26
--- /dev/null
+++ b/mysql-test/suite/rpl/t/rpl_xa_concurrent_2pc.test
@@ -0,0 +1,111 @@
+#
+# This test ensures that two-phase XA transactions have their first and
+# second phases parallelized for both XA COMMIT and XA ROLLBACK. It ensures the
+# following behaviors:
+#
+# Test Case 1: Ensure that a 2-phase XA transaction has its XA PREPARE and
+# XA COMMIT/ROLLBACK run concurrently. That is, the XA COMMIT/ROLLBACK will
+# wait at group commit until the XA PREPARE binlogs, and then it will wait
+# again until the XA PREPARE finishes preparing in all engines. At this point,
+# the XA COMMIT/ROLLBACK will run to completion.
+#
+# Test Case 2: If two XA transactions have different XIDs, if XA COMMIT ends
+# a transaction, ensure both phases of both transactions can all execute
+# concurrently.
+#
+# Test Case 3: Two current 2-phase XA transactions with matching XIDs should
+# run one after the other, while each transaction still allows both phases of
+# its own transaction to run concurrently.
+#
+# Test Case 4: Error Case. If an XAP errors while its XAC/R is waiting on it,
+# both the XAP and XAC/R should rollback successfully. Note this tests both:
+# a) XAC/R is waiting in group commit (first phase times out in DMLs)
+# b) XAC/R is waiting in group commit, with another XAP with a duplicate XID
+# waiting on it.
+#
+# Test Case 5: If an XAP is skipped by the replica (e.g. by incorrectly
+# setting gtid_slave_pos), and only its XAC/XAR is tried to execute, the
+# replica should report ER_XAER_NOTA.
+#
+#
+# References:
+# MDEV-31949: slow parallel replication of user xa
+#
+--source include/have_debug.inc
+--source include/have_innodb.inc
+--source include/have_binlog_format_mixed.inc
+--source include/master-slave.inc
+
+--let $xa_complete_sym= COMMIT
+--source include/rpl_xa_concurrent_2pc.inc
+
+--let $xa_complete_sym= ROLLBACK
+--source include/rpl_xa_concurrent_2pc.inc
+
+
+--echo #
+--echo # Test Case 5: If an XAP is skipped by the replica (e.g. by incorrectly
+--echo # setting gtid_slave_pos), and only its XAC/XAR is tried to execute, the
+--echo # replica should report ER_XAER_NOTA.
+
+--connection master
+create table t1 (a int) engine=innodb;
+--source include/save_master_gtid.inc
+
+--connection slave
+--source include/sync_with_master_gtid.inc
+call mtr.add_suppression("XAER_NOTA: Unknown XID");
+
+--let $i=2
+while ($i)
+{
+ --source include/stop_slave.inc
+ --replace_regex /[0-9]*-[0-9]*-[0-9]*/<value>/
+ change master to master_use_gtid = slave_pos;
+
+ --connection master
+ --let $complete=rollback
+ if ($i == 1)
+ {
+ --let $complete=commit
+ }
+ xa start '1'; insert into t1 set a=1; xa end '1'; xa prepare '1';
+ --eval xa $complete '1'
+ insert into t1 set a=2;
+ --source include/save_master_gtid.inc
+
+ --connection slave
+
+ # reposition the slave to skip one transaction from master
+ set @save_gtid_slave_pos= @@global.gtid_slave_pos;
+ SELECT CONCAT(domain_id,"-",server_id,"-", seq_no + 1)
+ into @gtid_skip
+ FROM mysql.gtid_slave_pos
+ WHERE seq_no = (SELECT DISTINCT max(seq_no)
FROM mysql.gtid_slave_pos) limit 1;
+ set @@global.gtid_slave_pos = @gtid_skip;
+
+ start slave;
+ let $slave_sql_errno= 1397; # ER_XAER_NOTA
+ source include/wait_for_slave_sql_error.inc;
+ --eval select count(*) = $i % 2 as 'must be true' from t1;
+ --source include/stop_slave.inc
+
+ --disable_warnings
+ set @@global.gtid_slave_pos = @save_gtid_slave_pos;
+ --enable_warnings
+ --replace_regex /[0-9]*-[0-9]*-[0-9]*/<value>/
+ show warnings;
+ --source include/start_slave.inc
+ --source include/sync_with_master_gtid.inc
+
+ --dec $i
+}
+
+# MDEV-31949 cleanup
+--connection master
+drop table t1;
+
+--sync_slave_with_master
+
+--source include/rpl_end.inc
+--echo # End of rpl_xa_concurrent_2pc.test
diff --git a/mysql-test/suite/rpl/t/rpl_xa_empty_transaction.test
b/mysql-test/suite/rpl/t/rpl_xa_empty_transaction.test
index 61cc0621d5a..f43af653ace 100644
--- a/mysql-test/suite/rpl/t/rpl_xa_empty_transaction.test
+++ b/mysql-test/suite/rpl/t/rpl_xa_empty_transaction.test
@@ -167,6 +167,95 @@ set @@global.binlog_format = row;
set @@binlog_format = @sav_binlog_format;
set @@global.binlog_format = @sav_binlog_format;
+
+# MDEV-32257 dangling XA-rollback in binlog from emtpy XA
+# create a case of XA ROLLBACK gets to binlog while its XAP was not and
+# try replicate it.
+# Expected result is both slaves error out.
+--connection server_1
+--let $binlog_start = query_get_value(SHOW MASTER STATUS, Position, 1)
+--let $binlog_file = query_get_value(SHOW MASTER STATUS, File, 1)
+create table t_not_in_binlog (a int) engine=innodb;
+flush logs;
+--source include/save_master_gtid.inc
+--let $binlog_file=query_get_value(SHOW MASTER STATUS, File, 1)
+
+# External connection XID access after disconnect is subject to race.
+# "(" open parenthesis to remember # of connection before ...
+--source include/count_sessions.inc
+
+--connect(con1,localhost,root,,)
+call mtr.add_suppression("XAER_NOTA: Unknown XID");
+
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+--disconnect con1
+
+--connection server_1
+# .. ")" close parenthesis, to wait until con1 fully releases access to xid.
+--source include/wait_until_count_sessions.inc
+xa recover;
+#
+# replicate orphan XAR to server 2,3 and expect the error first
+# after that compensate it.
+
+--error 0
+XA ROLLBACK 'a';
+# cleanup at once
+drop table t_not_in_binlog;
+--source include/save_master_gtid.inc
+
+--connection server_2
+--echo XAER_NOTA: Unknown XID
+--let $slave_sql_errno= 1397
+--source include/wait_for_slave_sql_error.inc
+
+# "("
+--source include/count_sessions.inc
+
+--connect (con2,127.0.0.1,root,,test,$SERVER_MYPORT_2,)
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+--disconnect con2
+
+--connection server_2
+# ")"
+--source include/wait_until_count_sessions.inc
+
+xa recover;
+--source include/start_slave.inc
+--source include/sync_with_master_gtid.inc
+
+--connection server_3
+--echo XAER_NOTA: Unknown XID
+--let $slave_sql_errno= 1397
+--source include/wait_for_slave_sql_error.inc
+
+# "("
+--source include/count_sessions.inc
+
+--connect (con3,127.0.0.1,root,,test,$SERVER_MYPORT_3,)
+SET sql_log_bin=0;
+XA START 'a';
+insert into t_not_in_binlog set a=1;
+XA END 'a';
+XA PREPARE 'a';
+--disconnect con3
+
+--connection server_3
+# ")"
+--source include/wait_until_count_sessions.inc
+
+xa recover;
+--source include/start_slave.inc
+--source include/sync_with_master_gtid.inc
+
#
# Cleanup
--connection server_1
diff --git a/mysql-test/suite/rpl/t/rpl_xa_prepare_gtid_fail.test
b/mysql-test/suite/rpl/t/rpl_xa_prepare_gtid_fail.test
index aa1b088ed23..72589953ac0 100644
--- a/mysql-test/suite/rpl/t/rpl_xa_prepare_gtid_fail.test
+++ b/mysql-test/suite/rpl/t/rpl_xa_prepare_gtid_fail.test
@@ -56,8 +56,8 @@ xa start '1';
update t1 set b=b+10 where a=1;
xa end '1';
xa prepare '1';
---let $new_gtid= `SELECT @@global.gtid_binlog_pos`
xa commit '1';
+--let $new_gtid= `SELECT @@global.gtid_binlog_pos`
--source include/save_master_gtid.inc
--connection slave1
diff --git a/sql/handler.cc b/sql/handler.cc
index 1ea1818749c..7fa78e4d9b2 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -2180,13 +2180,13 @@ int ha_rollback_trans(THD *thd, bool all)
rollback without signalling following transactions. And in release
builds, we explicitly do the signalling before rolling back.
*/
- DBUG_ASSERT(
- !(thd->rgi_slave &&
- !thd->rgi_slave->worker_error &&
- thd->rgi_slave->did_mark_start_commit) ||
- (thd->transaction->xid_state.is_explicit_XA() ||
- (thd->rgi_slave->gtid_ev_flags2 & Gtid_log_event::FL_PREPARED_XA)));
-
+ DBUG_ASSERT(!(thd->rgi_slave &&
+ !thd->rgi_slave->worker_error &&
+ thd->rgi_slave->did_mark_start_commit) ||
+ (thd->transaction->xid_state.is_explicit_XA() ||
+ (thd->rgi_slave->gtid_ev_flags2 &
+ (Gtid_log_event::FL_PREPARED_XA |
+ Gtid_log_event::FL_COMPLETED_XA))));
if (thd->rgi_slave &&
!thd->rgi_slave->worker_error &&
thd->rgi_slave->did_mark_start_commit)
@@ -2343,6 +2343,15 @@ int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
else
binlog_rollback_by_xid(binlog_hton, xid);
+#ifdef ENABLED_DEBUG_SYNC
+ DBUG_EXECUTE_IF(
+ "stop_after_binlog_cor_by_xid",
+ DBUG_ASSERT(!debug_sync_set_action(
+ current_thd,
+ STRING_WITH_LEN(
+ "now SIGNAL xa_cor_binlogged WAIT_FOR continue_xa_cor"))););
+#endif
+
plugin_foreach(NULL, commit ? xacommit_handlerton : xarollback_handlerton,
MYSQL_STORAGE_ENGINE_PLUGIN, &xaop);
diff --git a/sql/log.cc b/sql/log.cc
index eef8d86e4da..78a9419fb15 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -101,6 +101,8 @@ static int binlog_flush_cache(THD *thd, binlog_cache_mngr
*cache_mngr,
Log_event *end_ev, bool all, bool using_stmt,
bool using_trx, bool is_ro_1pc);
+XID_cache_element *xid_cache_search_maybe_wait(THD *thd);
+
static const LEX_CSTRING write_error_msg=
{ STRING_WITH_LEN("error writing to the binary log") };
@@ -1751,7 +1753,8 @@ binlog_flush_cache(THD *thd, binlog_cache_mngr
*cache_mngr,
if ((using_stmt && !cache_mngr->stmt_cache.empty()) ||
(using_trx && !cache_mngr->trx_cache.empty()) ||
- thd->transaction->xid_state.is_explicit_XA())
+ (thd->transaction->xid_state.is_explicit_XA() ||
+ (thd->rgi_slave && thd->rgi_slave->is_async_xac)))
{
if (using_stmt && thd->binlog_flush_pending_rows_event(TRUE, FALSE))
DBUG_RETURN(1);
@@ -1858,11 +1861,19 @@ binlog_commit_flush_trx_cache(THD *thd, bool all,
binlog_cache_mngr *cache_mngr,
if (thd->lex->sql_command == SQLCOM_XA_COMMIT &&
thd->lex->xa_opt != XA_ONE_PHASE)
{
- DBUG_ASSERT(thd->transaction->xid_state.is_explicit_XA());
+ bool is_async_xac= (thd->rgi_slave && thd->rgi_slave->is_async_xac);
+ DBUG_ASSERT(thd->transaction->xid_state.is_explicit_XA() || is_async_xac);
DBUG_ASSERT(thd->transaction->xid_state.get_state_code() ==
- XA_PREPARED);
-
- buflen= serialize_with_xid(thd->transaction->xid_state.get_xid(),
+ XA_PREPARED || is_async_xac);
+ DBUG_ASSERT(is_async_xac ||
+ thd->lex->xid->eq(thd->transaction->xid_state.get_xid()));
+ /*
+ While xid_state.get_xid() is a robust method to access `xid`
+ it can't be used on slave by the asynchronously running XA-"complete".
+ In the latter case thd->lex->xid is safely accessible.
+ */
+ buflen= serialize_with_xid(is_async_xac? thd->lex->xid :
+ thd->transaction->xid_state.get_xid(),
buf, query, q_len);
}
Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0);
@@ -1888,13 +1899,19 @@ binlog_rollback_flush_trx_cache(THD *thd, bool all,
const size_t q_len= sizeof(query) - 1; // do not count trailing 0
char buf[q_len + ser_buf_size]= "ROLLBACK";
size_t buflen= sizeof("ROLLBACK") - 1;
+ bool is_async_xac= false;
- if (thd->transaction->xid_state.is_explicit_XA())
+ if (thd->transaction->xid_state.is_explicit_XA() ||
+ (is_async_xac= (thd->rgi_slave && thd->rgi_slave->is_async_xac)))
{
/* for not prepared use plain ROLLBACK */
- if (thd->transaction->xid_state.get_state_code() == XA_PREPARED)
- buflen= serialize_with_xid(thd->transaction->xid_state.get_xid(),
+ if (thd->transaction->xid_state.get_state_code() == XA_PREPARED ||
+ is_async_xac)
+ {
+ buflen= serialize_with_xid(is_async_xac? thd->lex->xid :
+ thd->transaction->xid_state.get_xid(),
buf, query, q_len);
+ }
}
Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0);
@@ -1985,11 +2002,71 @@ inline bool is_preparing_xa(THD *thd)
static int binlog_prepare(handlerton *hton, THD *thd, bool all)
{
+ int rc;
+
/* Do nothing unless the transaction is a user XA. */
- return is_preparing_xa(thd) ? binlog_commit(thd, all, FALSE) : 0;
+ if (is_preparing_xa(thd))
+ {
+ DBUG_EXECUTE_IF(
+ "stop_before_binlog_prepare",
+ DBUG_ASSERT(!debug_sync_set_action(
+ thd, STRING_WITH_LEN("now WAIT_FOR binlog_xap"))););
+
+ rc= binlog_commit(thd, all, FALSE);
+
+#ifdef ENABLED_DEBUG_SYNC
+ DBUG_EXECUTE_IF(
+ "stop_after_binlog_prepare",
+ DBUG_ASSERT(!debug_sync_set_action(
+ thd,
+ STRING_WITH_LEN(
+ "now SIGNAL xa_prepare_binlogged WAIT_FOR continue_xap"))););
+#endif
+ }
+ else
+ {
+ rc= 0;
+ }
+
+ return rc;
}
+/**
+ @c acquire_xid takes control by slave worker's THD over a xid record the
system
+ xid cache. Implicitly provided @c xid corresponds to a being asynchronously
+ handled XA-"complete".
+
+ @param thd the thread handler
+ @return false as success, true otherwise
+*/
+static bool acquire_xid(THD *thd)
+{
+ bool rc= false;
+
+ if (thd->rgi_slave && thd->rgi_slave->is_async_xac &&
+ thd->rgi_slave->gtid_ev_flags2 & Gtid_log_event::FL_COMPLETED_XA)
+ {
+ XID_STATE &xid_state= thd->transaction->xid_state;
+
+ auto xs= xid_cache_search_maybe_wait(thd);
+ xid_state.xid_cache_element= xs;
+ if (!xs)
+ {
+ DBUG_ASSERT(thd->is_killed());
+
+ rpl_gtid *gtid= &thd->rgi_slave->current_gtid;
+ my_error(ER_XAER_RMERR, MYF(0));
+ sql_print_error("XA COMMIT of GTID %u-%u-%ll could not complete "
+ "after having been logged into binary log",
+ gtid->domain_id, gtid->server_id, gtid->seq_no);
+ rc= true;
+ }
+ }
+
+ return rc;
+}
+
int binlog_commit_by_xid(handlerton *hton, XID *xid)
{
int rc= 0;
@@ -1997,28 +2074,38 @@ int binlog_commit_by_xid(handlerton *hton, XID *xid)
if (thd->is_current_stmt_binlog_disabled())
{
- return thd->wait_for_prior_commit();
+ rc= thd->wait_for_prior_commit();
}
+ else
+ {
+ /* the asserted state can't be reachable with xa commit */
+ DBUG_ASSERT(!thd->get_stmt_da()->is_error() ||
+ thd->get_stmt_da()->sql_errno() != ER_XA_RBROLLBACK);
+ /*
+ This is a recovered user xa transaction commit.
+ Create a "temporary" binlog transaction to write the commit record
+ into binlog.
+ */
+ THD_TRANS trans;
+ trans.ha_list= NULL;
- /* the asserted state can't be reachable with xa commit */
- DBUG_ASSERT(!thd->get_stmt_da()->is_error() ||
- thd->get_stmt_da()->sql_errno() != ER_XA_RBROLLBACK);
- /*
- This is a recovered user xa transaction commit.
- Create a "temporary" binlog transaction to write the commit record
- into binlog.
- */
- THD_TRANS trans;
- trans.ha_list= NULL;
-
- thd->ha_data[hton->slot].ha_info[1].register_ha(&trans, hton);
- thd->ha_data[binlog_hton->slot].ha_info[1].set_trx_read_write();
- (void) thd->binlog_setup_trx_data();
+ thd->ha_data[hton->slot].ha_info[1].register_ha(&trans, hton);
+ thd->ha_data[binlog_hton->slot].ha_info[1].set_trx_read_write();
+ (void) thd->binlog_setup_trx_data();
- DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_COMMIT);
+ DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_COMMIT);
- rc= binlog_commit(thd, TRUE, FALSE);
- thd->ha_data[binlog_hton->slot].ha_info[1].reset();
+ rc= binlog_commit(thd, TRUE, FALSE);
+ thd->ha_data[binlog_hton->slot].ha_info[1].reset();
+ }
+ if (!rc)
+ {
+ rc= acquire_xid(thd);
+ }
+ if (thd->is_current_stmt_binlog_disabled())
+ {
+ thd->wakeup_subsequent_commits(rc);
+ }
return rc;
}
@@ -2031,33 +2118,54 @@ int binlog_rollback_by_xid(handlerton *hton, XID *xid)
if (thd->is_current_stmt_binlog_disabled())
{
- return thd->wait_for_prior_commit();
+ rc= thd->wait_for_prior_commit();
}
+ else if (thd->get_stmt_da()->is_error() &&
+ thd->get_stmt_da()->sql_errno() == ER_XA_RBROLLBACK)
+ rc= true;
+ else
+ {
+ THD_TRANS trans;
+ trans.ha_list= NULL;
- if (thd->get_stmt_da()->is_error() &&
- thd->get_stmt_da()->sql_errno() == ER_XA_RBROLLBACK)
- return rc;
-
- THD_TRANS trans;
- trans.ha_list= NULL;
-
- thd->ha_data[hton->slot].ha_info[1].register_ha(&trans, hton);
- thd->ha_data[hton->slot].ha_info[1].set_trx_read_write();
- (void) thd->binlog_setup_trx_data();
+ thd->ha_data[hton->slot].ha_info[1].register_ha(&trans, hton);
+ thd->ha_data[hton->slot].ha_info[1].set_trx_read_write();
+ (void) thd->binlog_setup_trx_data();
- DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_ROLLBACK ||
- (thd->transaction->xid_state.get_state_code() ==
XA_ROLLBACK_ONLY));
+ DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_ROLLBACK ||
+ (thd->transaction->xid_state.get_state_code() ==
XA_ROLLBACK_ONLY));
- rc= binlog_rollback(hton, thd, TRUE);
- thd->ha_data[hton->slot].ha_info[1].reset();
+ rc= binlog_rollback(hton, thd, TRUE);
+ thd->ha_data[hton->slot].ha_info[1].reset();
+ }
+ if (!rc)
+ {
+ rc= acquire_xid(thd);
+ }
+ if (thd->is_current_stmt_binlog_disabled())
+ {
+ thd->wakeup_subsequent_commits(rc);
+ }
return rc;
}
-
+/**
+ @param thd thread handler
+ @return true when thd carries an XA transaction in prepared state,
+ or the XA transaction is being completed by
+ asynchronously running "COMPLETE" by slave parallel thread;
+ false otherwise
+*/
inline bool is_prepared_xa(THD *thd)
{
- return thd->transaction->xid_state.is_explicit_XA() &&
+ bool is_async_xac= (thd->rgi_slave && thd->rgi_slave->is_async_xac);
+ DBUG_ASSERT(!is_async_xac ||
+ thd->lex->sql_command == SQLCOM_XA_ROLLBACK ||
+ thd->lex->sql_command == SQLCOM_XA_COMMIT);
+
+ return is_async_xac ? true :
+ thd->transaction->xid_state.is_explicit_XA() &&
thd->transaction->xid_state.get_state_code() == XA_PREPARED;
}
@@ -2185,7 +2293,9 @@ int binlog_commit(THD *thd, bool all, bool ro_1pc)
}
if (cache_mngr->trx_cache.empty() &&
- (thd->transaction->xid_state.get_state_code() != XA_PREPARED ||
+ ((thd->transaction->xid_state.get_state_code() != XA_PREPARED &&
+ !(thd->rgi_slave && thd->rgi_slave->is_parallel_exec &&
+ thd->lex->sql_command == SQLCOM_XA_COMMIT)) ||
!(thd->ha_data[binlog_hton->slot].ha_info[1].is_started() &&
thd->ha_data[binlog_hton->slot].ha_info[1].is_trx_read_write())))
{
@@ -2279,7 +2389,9 @@ static int binlog_rollback(handlerton *hton, THD *thd,
bool all)
}
if (!cache_mngr->trx_cache.has_incident() && cache_mngr->trx_cache.empty() &&
- (thd->transaction->xid_state.get_state_code() != XA_PREPARED ||
+ ((thd->transaction->xid_state.get_state_code() != XA_PREPARED &&
+ !(thd->rgi_slave && thd->rgi_slave->is_parallel_exec &&
+ thd->lex->sql_command == SQLCOM_XA_ROLLBACK)) ||
!(thd->ha_data[binlog_hton->slot].ha_info[1].is_started() &&
thd->ha_data[binlog_hton->slot].ha_info[1].is_trx_read_write())))
{
@@ -8382,7 +8494,9 @@ MYSQL_BIN_LOG::trx_group_commit_leader(group_commit_entry
*leader)
*/
DBUG_ASSERT(!cache_mngr->stmt_cache.empty() ||
!cache_mngr->trx_cache.empty() ||
- current->thd->transaction->xid_state.is_explicit_XA());
+ (current->thd->transaction->xid_state.is_explicit_XA() ||
+ (current->thd->rgi_slave &&
+ current->thd->rgi_slave->is_async_xac)));
if (unlikely((current->error= write_transaction_or_stmt(current,
commit_id))))
@@ -10510,13 +10624,20 @@ int TC_LOG_BINLOG::unlog_xa_prepare(THD *thd, bool
all)
binlog_cache_mngr *cache_mngr= thd->binlog_setup_trx_data();
int cookie= 0;
+ int rc= 0;
+
+ if (thd->rgi_slave && thd->is_current_stmt_binlog_disabled())
+ {
+ rc= thd->wait_for_prior_commit();
+ if (rc == 0)
+ thd->wakeup_subsequent_commits(rc);
+ return rc;
+ }
if (!cache_mngr->need_unlog)
{
Ha_trx_info *ha_info;
uint rw_count= ha_count_rw_all(thd, &ha_info);
- bool rc= false;
-
/*
This transaction has not been binlogged as indicated by need_unlog.
Such exceptional cases include transactions with no effect to engines,
diff --git a/sql/log_event_server.cc b/sql/log_event_server.cc
index 92ff401a260..230a7a4667f 100644
--- a/sql/log_event_server.cc
+++ b/sql/log_event_server.cc
@@ -3314,16 +3314,22 @@ Gtid_log_event::Gtid_log_event(THD *thd_arg, uint64
seq_no_arg,
XID_STATE &xid_state= thd->transaction->xid_state;
if (is_transactional)
{
- if (xid_state.is_explicit_XA() &&
- (thd->lex->sql_command == SQLCOM_XA_PREPARE ||
- xid_state.get_state_code() == XA_PREPARED))
+ bool is_async_xac= false;
+ if ((xid_state.is_explicit_XA() &&
+ (thd->lex->sql_command == SQLCOM_XA_PREPARE ||
+ xid_state.get_state_code() == XA_PREPARED)) ||
+ (is_async_xac= (thd->rgi_slave && thd->rgi_slave->is_async_xac)))
{
DBUG_ASSERT(!(thd->lex->sql_command == SQLCOM_XA_COMMIT &&
thd->lex->xa_opt == XA_ONE_PHASE));
+ DBUG_ASSERT(!is_async_xac ||
+ thd->lex->sql_command == SQLCOM_XA_ROLLBACK ||
+ thd->lex->sql_command == SQLCOM_XA_COMMIT);
flags2|= thd->lex->sql_command == SQLCOM_XA_PREPARE ?
FL_PREPARED_XA : FL_COMPLETED_XA;
- xid.set(xid_state.get_xid());
+ xid.set(is_async_xac? thd->lex->xid :
+ thd->transaction->xid_state.get_xid());
}
/* count non-zero extra recoverable engines; total = extra + 1 */
if (has_xid)
@@ -4172,9 +4178,6 @@ int XA_prepare_log_event::do_commit()
thd->lex->xid= &xid;
if (!one_phase)
{
- if ((res= thd->wait_for_prior_commit()))
- return res;
-
thd->lex->sql_command= SQLCOM_XA_PREPARE;
res= trans_xa_prepare(thd);
}
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index c0dd56ab3d5..0f76dcc2351 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1055,7 +1055,7 @@ PSI_cond_key key_BINLOG_COND_xid_list,
key_BINLOG_COND_queue_busy;
PSI_cond_key key_RELAYLOG_COND_relay_log_updated,
key_RELAYLOG_COND_bin_log_updated, key_COND_wakeup_ready,
- key_COND_wait_commit;
+ key_COND_wait_commit, key_COND_wait_commit_dep;
PSI_cond_key key_RELAYLOG_COND_queue_busy;
PSI_cond_key key_TC_LOG_MMAP_COND_queue_busy;
PSI_cond_key key_COND_rpl_thread_queue, key_COND_rpl_thread,
@@ -1083,6 +1083,7 @@ static PSI_cond_info all_server_conds[]=
{ &key_RELAYLOG_COND_queue_busy, "MYSQL_RELAY_LOG::COND_queue_busy", 0},
{ &key_COND_wakeup_ready, "THD::COND_wakeup_ready", 0},
{ &key_COND_wait_commit, "wait_for_commit::COND_wait_commit", 0},
+ { &key_COND_wait_commit, "wait_for_commit::COND_wait_commit_dep", 0},
{ &key_COND_cache_status_changed, "Query_cache::COND_cache_status_changed",
0},
{ &key_COND_manager, "COND_manager", PSI_FLAG_GLOBAL},
{ &key_COND_server_started, "COND_server_started", PSI_FLAG_GLOBAL},
@@ -9224,6 +9225,7 @@ PSI_stage_info stage_waiting_for_deadlock_kill= { 0,
"Waiting for parallel repli
PSI_stage_info stage_starting= { 0, "starting", 0};
PSI_stage_info stage_waiting_for_flush= { 0, "Waiting for non trans tables to
be flushed", 0};
PSI_stage_info stage_waiting_for_ddl= { 0, "Waiting for DDLs", 0};
+PSI_stage_info stage_waiting_for_prior_xa_transaction= { 0, "Waiting for prior
xa transaction", 0};
PSI_memory_key key_memory_DATE_TIME_FORMAT;
PSI_memory_key key_memory_DDL_LOG_MEMORY_ENTRY;
diff --git a/sql/mysqld.h b/sql/mysqld.h
index fc8afa06638..4245a1a5e10 100644
--- a/sql/mysqld.h
+++ b/sql/mysqld.h
@@ -376,7 +376,7 @@ extern PSI_cond_key key_BINLOG_COND_xid_list,
key_BINLOG_update_cond,
key_COND_start_thread;
extern PSI_cond_key key_RELAYLOG_COND_relay_log_updated,
key_RELAYLOG_COND_bin_log_updated, key_COND_wakeup_ready,
- key_COND_wait_commit;
+ key_COND_wait_commit, key_COND_wait_commit_dep;
extern PSI_cond_key key_RELAYLOG_COND_queue_busy;
extern PSI_cond_key key_TC_LOG_MMAP_COND_queue_busy;
extern PSI_cond_key key_COND_rpl_thread, key_COND_rpl_thread_queue,
@@ -679,7 +679,7 @@ extern PSI_stage_info
stage_slave_background_process_request;
extern PSI_stage_info stage_slave_background_wait_request;
extern PSI_stage_info stage_waiting_for_deadlock_kill;
extern PSI_stage_info stage_starting;
-
+extern PSI_stage_info stage_waiting_for_prior_xa_transaction;
#ifdef HAVE_PSI_STATEMENT_INTERFACE
/**
Statement instrumentation keys (sql).
diff --git a/sql/rpl_parallel.cc b/sql/rpl_parallel.cc
index c26263401b8..2653e294590 100644
--- a/sql/rpl_parallel.cc
+++ b/sql/rpl_parallel.cc
@@ -9,6 +9,8 @@
#ifdef WITH_WSREP
#include "wsrep_trans_observer.h"
#endif
+#include <algorithm>
+using std::max;
/*
Code for optional parallel execution of replicated events on the slave.
@@ -760,7 +762,8 @@ convert_kill_to_deadlock_error(rpl_group_info *rgi)
return;
err_code= thd->get_stmt_da()->sql_errno();
if ((rgi->speculation == rpl_group_info::SPECULATE_OPTIMISTIC &&
- err_code != ER_PRIOR_COMMIT_FAILED) ||
+ (err_code != ER_PRIOR_COMMIT_FAILED &&
+ err_code != ER_XAER_NOTA)) ||
((err_code == ER_QUERY_INTERRUPTED || err_code == ER_CONNECTION_KILLED)
&&
rgi->killed_for_retry))
{
@@ -2364,16 +2367,9 @@ rpl_parallel_entry::choose_thread(rpl_group_info *rgi,
bool *did_enter_cond,
idx= rpl_thread_idx;
if (gtid_ev)
{
- if (gtid_ev->flags2 &
- (Gtid_log_event::FL_COMPLETED_XA | Gtid_log_event::FL_PREPARED_XA))
- idx= my_hash_sort(&my_charset_bin, gtid_ev->xid.key(),
- gtid_ev->xid.key_length()) % rpl_thread_max;
- else
- {
- ++idx;
- if (idx >= rpl_thread_max)
- idx= 0;
- }
+ ++idx;
+ if (idx >= rpl_thread_max)
+ idx= 0;
rpl_thread_idx= idx;
}
thr= rpl_threads[idx];
@@ -2467,6 +2463,7 @@ free_rpl_parallel_entry(void *element)
}
mysql_cond_destroy(&e->COND_parallel_entry);
mysql_mutex_destroy(&e->LOCK_parallel_entry);
+ e->concurrent_xaps_window.~Dynamic_array();
my_free(e);
}
@@ -2521,6 +2518,19 @@ rpl_parallel::find(uint32 domain_id)
e->domain_id= domain_id;
e->stop_on_error_sub_id= (uint64)ULONGLONG_MAX;
e->pause_sub_id= (uint64)ULONGLONG_MAX;
+
+ e->concurrent_xaps_window.init((PSI_memory_key) PSI_INSTRUMENT_ME,
+ max((decltype(e->rpl_thread_max)) 2,
+ 2*e->rpl_thread_max));
+ e->cxap_lhs= e->cxap_rhs= 0;
+
+ /*
+ 0 initialize each element
+ */
+ for (size_t i= 0; i < e->concurrent_xaps_window.max_size(); i++)
+ {
+ e->concurrent_xaps_window.at(i)= {0, 0};
+ }
mysql_mutex_init(key_LOCK_parallel_entry, &e->LOCK_parallel_entry,
MY_MUTEX_INIT_FAST);
mysql_cond_init(key_COND_parallel_entry, &e->COND_parallel_entry, NULL);
@@ -2798,6 +2808,90 @@ abandon_worker_thread(THD *thd, rpl_parallel_thread
*cur_thread,
mysql_cond_signal(&cur_thread->COND_rpl_thread);
}
+/**
+ Check the concurrency status of @c xid with ones in progress.
+ Any new @c xid of XA-prepare (@c is_xap is true then) is appended to
+ a sliding window designed as circular buffer. Through search in the window
+ the return result is computed.
+
+ @param e parallel entry pointer
+ @param xid a pointer to the xid of either XA-prepare of XA-"complete"
+ @param is_xap
+ true when xid belongs to XA-prepare
+ @return true when there exists a duplicate xid hash value,
+ false otherwise.
+*/
+static bool
+handle_xa_prepera_duplicate_xid(rpl_parallel_entry *e, XID *xid, bool is_xap)
+{
+ DBUG_ASSERT(e->current_group_info ||
+ (e->count_queued_event_groups == 0 &&
+ e->cxap_lhs == e->cxap_rhs && e->cxap_lhs == 0));
+ DBUG_ASSERT(xid);
+ DBUG_ASSERT(!xid->is_null());
+ DBUG_ASSERT(xid->key());
+ DBUG_ASSERT(xid->key_length());
+
+ uint64 curr_event_count= e->count_queued_event_groups;
+ uint32 i;
+ bool rc= false;
+ /*
+ We've seen XAP's before, so move the LHS up to a relevant spot.
+ LHS = RHS indicates the empty buffer (which implies RHS is exclusive "edge"
+ of the window.
+ Otherwise RHS always points to a free cell of which one at least must
+ exist at this point.
+ While transaction disribution is Round-robin, potential conflicts with
+ the current input xid can come only from
+ the preceeding 2*|W| - 1 xids, the 2*|W|th in the past is safe.
+ */
+ for (i= e->cxap_lhs; i != e->cxap_rhs;
+ i= (i+1) % (e->concurrent_xaps_window.max_size()))
+ {
+ uint64 old_event_count= e->concurrent_xaps_window.at(i).second;
+ uint64 queued_event_diff= curr_event_count - old_event_count;
+ if (queued_event_diff >= e->rpl_thread_max)
+ {
+ /*
+ Squeeze the window from the left
+ as this XAP can't run in parallel with us.
+ */
+ e->cxap_lhs= (i+1) % (e->concurrent_xaps_window.max_size());
+ }
+ else
+ {
+ // new LHS is determined
+ DBUG_ASSERT(e->cxap_lhs != e->cxap_rhs);
+ break;
+ }
+ }
+
+ std::size_t xid_hash= std::hash<XID>{}(*xid);
+ for (; i != e->cxap_rhs; i= (i+1) % (e->concurrent_xaps_window.max_size()))
+ {
+ std::size_t old_xid_hash= e->concurrent_xaps_window.at(i).first;
+ if (old_xid_hash == xid_hash)
+ {
+ rc= true;
+ break;
+ }
+ }
+
+ // Add the XAP to the sliding window
+ if (is_xap)
+ {
+ e->concurrent_xaps_window.at(e->cxap_rhs).first= xid_hash;
+ e->concurrent_xaps_window.at(e->cxap_rhs).second= curr_event_count;
+ e->cxap_rhs= (e->cxap_rhs + 1) % (e->concurrent_xaps_window.max_size());
+ if (e->cxap_rhs == e->cxap_lhs)
+ {
+ // the entire array is full therefore the lhs has become stale
+ e->cxap_lhs= (e->cxap_lhs + 1) % (e->concurrent_xaps_window.max_size());
+ }
+ }
+
+ return rc;
+}
/*
do_event() is executed by the sql_driver_thd thread.
@@ -3046,6 +3140,18 @@ rpl_parallel::do_event(rpl_group_info *serial_rgi,
Log_event *ev,
new_gco= true;
force_switch_flag= 0;
gco= e->current_gco;
+ /*
+ Take care of duplicate xids in XA-prepare, XA-"complete" should not
+ race its XA-prepare parent either. When the current transaction's xid
+ was seen and its transaction may still be in process this event group
+ gets flagged to wait for prior commits at the start of execution.
+ */
+ if ((gtid_flags & (Gtid_log_event::FL_PREPARED_XA |
+ Gtid_log_event::FL_COMPLETED_XA)) &&
+ handle_xa_prepera_duplicate_xid(e, >id_ev->xid,
+ gtid_flags &
+ Gtid_log_event::FL_PREPARED_XA))
+ gtid_flags &= ~Gtid_log_event::FL_ALLOW_PARALLEL;
if (likely(gco))
{
uint8 flags= gco->flags;
diff --git a/sql/rpl_parallel.h b/sql/rpl_parallel.h
index 0b1d3cf9d80..b76d6749f6d 100644
--- a/sql/rpl_parallel.h
+++ b/sql/rpl_parallel.h
@@ -324,6 +324,14 @@ struct rpl_parallel_thread_pool {
void release_thread(rpl_parallel_thread *rpt);
};
+template <>
+struct std::hash<XID>
+{
+ std::size_t operator()(const XID& xid) const
+ {
+ return my_hash_sort(&my_charset_bin, xid.key(), xid.key_length());
+ }
+};
struct rpl_parallel_entry {
mysql_mutex_t LOCK_parallel_entry;
@@ -419,6 +427,14 @@ struct rpl_parallel_entry {
/* The group_commit_orderer object for the events currently being queued. */
group_commit_orderer *current_gco;
+ /*
+ Circular buffer of size slave_parallel_threads to hold XIDs of XA-prepare
+ group of events which may be processed concurrently.
+ See how handle_xa_prepera_duplicate_xid operates on it.
+ */
+ Dynamic_array<std::pair<std::size_t, uint32>> concurrent_xaps_window;
+ uint32 cxap_lhs, cxap_rhs;
+
rpl_parallel_thread * choose_thread(rpl_group_info *rgi, bool
*did_enter_cond,
PSI_stage_info *old_stage,
Gtid_log_event *gtid_ev);
diff --git a/sql/rpl_rli.cc b/sql/rpl_rli.cc
index 375fb1d1c58..fdeb0d67872 100644
--- a/sql/rpl_rli.cc
+++ b/sql/rpl_rli.cc
@@ -2155,12 +2155,14 @@ rpl_group_info::reinit(Relay_log_info *rli)
gtid_ignore_duplicate_state= GTID_DUPLICATE_NULL;
speculation= SPECULATE_NO;
commit_orderer.reinit();
+ is_async_xac= false;
}
rpl_group_info::rpl_group_info(Relay_log_info *rli)
: thd(0), wait_commit_sub_id(0),
wait_commit_group_info(0), parallel_entry(0),
- deferred_events(NULL), m_annotate_event(0), is_parallel_exec(false)
+ deferred_events(NULL), m_annotate_event(0), is_parallel_exec(false),
+ is_async_xac(false)
{
reinit(rli);
bzero(¤t_gtid, sizeof(current_gtid));
@@ -2291,7 +2293,7 @@ void rpl_group_info::cleanup_context(THD *thd, bool error)
if (thd->transaction->xid_state.is_explicit_XA() &&
thd->transaction->xid_state.get_state_code() != XA_PREPARED)
xa_trans_force_rollback(thd);
-
+ is_async_xac= false;
thd->release_transactional_locks();
if (thd == rli->sql_driver_thd)
diff --git a/sql/rpl_rli.h b/sql/rpl_rli.h
index cc807852bf2..06eef910de4 100644
--- a/sql/rpl_rli.h
+++ b/sql/rpl_rli.h
@@ -835,6 +835,14 @@ struct rpl_group_info
};
uchar killed_for_retry;
+ /*
+ When true indicates that the user xa transaction is going to
+ complete (with COMMIT or ROLLBACK) by the worker thread,
+ *while* another worker is still preparing it. Once the latter is done
+ the xid will be acquired and the flag gets reset.
+ */
+ bool is_async_xac;
+
rpl_group_info(Relay_log_info *rli_);
~rpl_group_info();
void reinit(Relay_log_info *rli);
diff --git a/sql/sql_array.h b/sql/sql_array.h
index 8610e971016..c79c0c257a0 100644
--- a/sql/sql_array.h
+++ b/sql/sql_array.h
@@ -137,7 +137,7 @@ template <class Elem> class Dynamic_array
*/
Elem& at(size_t idx)
{
- DBUG_ASSERT(idx < array.elements);
+ DBUG_ASSERT(idx < max_size());
return *(((Elem*)array.buffer) + idx);
}
/// Const variant of at(), which cannot change data
@@ -172,6 +172,8 @@ template <class Elem> class Dynamic_array
size_t size() const { return array.elements; }
+ size_t max_size() const { return array.max_element; }
+
const Elem *end() const
{
return back() + 1;
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 1b78f88bd3c..04338831cd7 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -7960,6 +7960,7 @@ wait_for_commit::wait_for_commit()
{
mysql_mutex_init(key_LOCK_wait_commit, &LOCK_wait_commit,
MY_MUTEX_INIT_FAST);
mysql_cond_init(key_COND_wait_commit, &COND_wait_commit, 0);
+ mysql_cond_init(key_COND_wait_commit_dep, &COND_wait_commit_dep, 0);
reinit();
}
@@ -7989,6 +7990,7 @@ wait_for_commit::~wait_for_commit()
mysql_mutex_destroy(&LOCK_wait_commit);
mysql_cond_destroy(&COND_wait_commit);
+ mysql_cond_destroy(&COND_wait_commit_dep);
}
diff --git a/sql/sql_class.h b/sql/sql_class.h
index e6580d2432c..72ca39c7710 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -2367,6 +2367,15 @@ struct wait_for_commit
event group is fully done.
*/
bool wakeup_blocked;
+ /*
+ The condition variable servers as a part of facilities to handle various
+ commit time additional dependency between groups of replication events, e.g
+ XA-Prepare -> XA-Commit, or XA-Prepare -> XA-Prepare all with the same xid.
+ */
+ mysql_cond_t COND_wait_commit_dep;
+#ifndef DBUG_OFF
+ bool debug_done;
+#endif
void register_wait_for_prior_commit(wait_for_commit *waitee);
int wait_for_prior_commit(THD *thd, bool allow_kill=true)
diff --git a/sql/xa.cc b/sql/xa.cc
index 9df9da7acf1..3d1a7a2360a 100644
--- a/sql/xa.cc
+++ b/sql/xa.cc
@@ -22,7 +22,7 @@
#include "my_cpu.h"
#include <pfs_transaction_provider.h>
#include <mysql/psi/mysql_transaction.h>
-
+#include "rpl_rli.h" // rpl_group_info
static bool slave_applier_reset_xa_trans(THD *thd);
/***************************************************************************
@@ -79,6 +79,10 @@ class XID_cache_element
uint rm_error;
enum xa_states xa_state;
XID xid;
+ /* parallel slave worker waiters. `c` stands for complete, `p` prepare */
+ std::atomic<wait_for_commit *> c_waiter; // set by asynch run xa-"complete"
+ std::atomic<wait_for_commit *> p_waiter; // set by duplicate xid xa-start
+
bool is_set(int32_t flag)
{ return m_state.load(std::memory_order_relaxed) & flag; }
void set(int32_t flag)
@@ -134,6 +138,7 @@ class XID_cache_element
element->rm_error= 0;
element->xa_state= new_element->xa_state;
element->xid.set(new_element->xid);
+ element->c_waiter= element->p_waiter= NULL;
new_element->xid_cache_element= element;
}
static void lf_alloc_constructor(uchar *ptr)
@@ -243,7 +248,7 @@ void xid_cache_free()
Find recovered XA transaction by XID.
*/
-static XID_cache_element *xid_cache_search(THD *thd, XID *xid)
+XID_cache_element *xid_cache_search(THD *thd, XID *xid)
{
DBUG_ASSERT(thd->xid_hash_pins);
XID_cache_element *element=
@@ -254,16 +259,221 @@ static XID_cache_element *xid_cache_search(THD *thd, XID
*xid)
/* The element can be removed from lf_hash by other thread, but
element->acquire_recovered() will return false in this case. */
if (!element->acquire_recovered())
+ {
element= 0;
+ if (thd->rgi_slave && thd->rgi_slave->is_parallel_exec)
+ {
+ DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_COMMIT ||
+ thd->lex->sql_command == SQLCOM_XA_ROLLBACK);
+ thd->rgi_slave->is_async_xac= true;
+ }
+ }
lf_hash_search_unpin(thd->xid_hash_pins);
/* Once the element is acquired (i.e. got the ACQUIRED bit) by this thread,
only this thread can delete it. The deletion happens in xid_cache_delete().
See also the XID_cache_element documentation. */
DEBUG_SYNC(thd, "xa_after_search");
}
+ else if (thd->rgi_slave && thd->rgi_slave->is_parallel_exec)
+ {
+ DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_COMMIT ||
+ thd->lex->sql_command == SQLCOM_XA_ROLLBACK);
+ }
+
return element;
}
+const int SPIN_MAX= 20;
+/**
+ The function tries inserting a xid into the system hash until succeeds.
+ Re-trying can be caused solely by existence of an earlier transaction with
+ a duplicate xid.
+ Analogously to @c xid_cache_search_maybe_wait, it is expecting, here the
duplicate,
+ xid in the way will be eventually deleted from the hash.
+
+ @param thd thread handler
+ @return false as success,
+ true otherwise.
+*/
+bool xid_cache_insert_maybe_wait(THD* thd)
+{
+ int i= 0;
+ bool rc;
+
+ do
+ {
+ if ((rc= xid_cache_insert(thd, &thd->transaction->xid_state,
thd->lex->xid)))
+ ut_delay(1 + i++);
+ }
+ while (rc && i < SPIN_MAX);
+
+ if (rc)
+ {
+ wait_for_commit *waiter= NULL;
+ XID *xid= thd->lex->xid;
+ XID_cache_element *element=
+ (XID_cache_element*) lf_hash_search(&xid_cache, thd->xid_hash_pins,
+ xid->key(), xid->key_length());
+ if (element)
+ {
+ PSI_stage_info old_stage;
+ wait_for_commit *exp= NULL, *waiter= thd->wait_for_commit_ptr;
+#ifndef DBUG_OFF
+ waiter->debug_done= false;
+#endif
+
+ while (unlikely(!element->
+ p_waiter.compare_exchange_weak(exp, waiter,
+
std::memory_order_acq_rel)))
+ {
+ if (exp)
+ {
+ DBUG_ASSERT(exp != waiter);
+ waiter= NULL; // notifier is seen
+
+ break;
+ }
+ else
+ {
+ (void) LF_BACKOFF();
+ }
+ }
+ lf_hash_search_unpin(thd->xid_hash_pins);
+
+ if (waiter) // notifier was not seen
+ {
+ mysql_mutex_lock(&waiter->LOCK_wait_commit);
+ thd->ENTER_COND(&waiter->COND_wait_commit_dep,
&waiter->LOCK_wait_commit,
+ &stage_waiting_for_prior_xa_transaction,
+ &old_stage);
+ if ((element=
+ (XID_cache_element*) lf_hash_search(&xid_cache,
thd->xid_hash_pins,
+ xid->key(),
xid->key_length())))
+ {
+ lf_hash_search_unpin(thd->xid_hash_pins);
+ mysql_cond_wait(&waiter->COND_wait_commit_dep,
+ &waiter->LOCK_wait_commit);
+
+ DBUG_ASSERT(waiter->debug_done || thd->check_killed(1));
+ }
+ thd->EXIT_COND(&old_stage);
+ }
+ }
+ if (!(rc= thd->check_killed(1)))
+ {
+ // (element && waiter = NULL) indicates the duplicate xid is coming
+ do
+ rc= xid_cache_insert(thd, &thd->transaction->xid_state, thd->lex->xid);
+ while (rc && element && !waiter && (ut_delay(1), true));
+ }
+ }
+
+ return rc;
+}
+
+/**
+ XA-"complete" run by parallel slave gets access to its xid.
+ Analogously to @c xid_cache_insert_maybe_wait, it is expecting, here its, xid
+ supplied through the THD argument, will be soon (the parent XAP has already
+ waken up transactions before the current one) released for acquisition.
+
+ @param thd thread handler
+ @return XID_cache_element pointer or NULL when the search is interruped
+ by kill.
+*/
+XID_cache_element * xid_cache_search_maybe_wait(THD* thd)
+{
+ if (thd->fix_xid_hash_pins())
+ {
+ my_error(ER_OUT_OF_RESOURCES, MYF(0));
+ return NULL;
+ }
+
+ XID_cache_element *xs;
+ XID *xid= thd->lex->xid;
+ int i= 0;
+ do
+ {
+ if (!(xs= xid_cache_search(thd, thd->lex->xid)))
+ ut_delay(1 + i++);
+ }
+ while (!xs && i < SPIN_MAX);
+
+ if (!xs)
+ {
+ XID_cache_element *element=
+ (XID_cache_element*) lf_hash_search(&xid_cache, thd->xid_hash_pins,
+ xid->key(), xid->key_length());
+ if (element)
+ {
+ lf_hash_search_unpin(thd->xid_hash_pins);
+ if (!element->acquire_recovered())
+ {
+ wait_for_commit *exp= NULL, *waiter= thd->wait_for_commit_ptr;
+ bool waiter_done= true; // assumption
+
+
+ /*
+ Set itself to wait for xid owner while taking care of race with it on
+ marking the xid element. When the element is found to be marked not
+ by us that indicates xid has been released.
+ */
+ while (unlikely(!element->
+ c_waiter.
+ compare_exchange_weak(exp, waiter,
+ std::memory_order_acq_rel)))
+ {
+ if (exp)
+ {
+ DBUG_ASSERT(exp != waiter);
+ waiter= NULL; // notifier is seen
+
+ break;
+ }
+ else
+ {
+ (void) LF_BACKOFF();
+ }
+ }
+
+ if (waiter) // notifier was not seen
+ {
+ PSI_stage_info old_stage;
+ mysql_mutex_lock(&waiter->LOCK_wait_commit);
+ thd->ENTER_COND(&waiter->COND_wait_commit_dep,
&waiter->LOCK_wait_commit,
+ &stage_waiting_for_prior_xa_transaction,
+ &old_stage);
+ if (element->c_waiter.load(std::memory_order_relaxed) &&
+ likely(!thd->check_killed(1)))
+ mysql_cond_wait(&waiter->COND_wait_commit_dep,
+ &waiter->LOCK_wait_commit);
+
+ if (element->c_waiter.load(std::memory_order_relaxed))
+ {
+ waiter_done= false;
+ DBUG_ASSERT(thd->check_killed(1));
+ }
+ thd->EXIT_COND(&old_stage);
+ }
+
+ if (waiter_done &&
+ likely(element->is_set(XID_cache_element::RECOVERED |
+ XID_cache_element::ACQUIRED)))
+ xs= element;
+ else
+ goto end;
+ }
+ else
+ {
+ xs= element;
+ }
+ }
+ }
+
+end:
+ return xs;
+}
+
bool xid_cache_insert(XID *xid)
{
@@ -302,7 +512,8 @@ bool xid_cache_insert(THD *thd, XID_STATE *xid_state, XID
*xid)
xid_state->xid_cache_element->set(XID_cache_element::ACQUIRED);
break;
case 1:
- my_error(ER_XAER_DUPID, MYF(0));
+ if (!(thd->rgi_slave && thd->rgi_slave->is_parallel_exec))
+ my_error(ER_XAER_DUPID, MYF(0));
}
return res;
}
@@ -311,9 +522,39 @@ bool xid_cache_insert(THD *thd, XID_STATE *xid_state, XID
*xid)
static void xid_cache_delete(THD *thd, XID_cache_element *&element)
{
DBUG_ASSERT(thd->xid_hash_pins);
+
element->mark_uninitialized();
+ wait_for_commit *waiter= NULL;
+ if (thd->rgi_slave && thd->rgi_slave->is_parallel_exec)
+ {
+ wait_for_commit *notifier= &thd->rgi_slave->commit_orderer;
+ while (unlikely(!element->
+ p_waiter.compare_exchange_weak(waiter, notifier,
+ std::memory_order_acq_rel)))
+ {
+ if (waiter)
+ {
+ DBUG_ASSERT(notifier != waiter);
+
+ break;
+ }
+ else
+ {
+ (void) LF_BACKOFF();
+ }
+ }
+ }
lf_hash_delete(&xid_cache, thd->xid_hash_pins,
element->xid.key(), element->xid.key_length());
+ if (waiter)
+ {
+ mysql_mutex_lock(&waiter->LOCK_wait_commit);
+#ifndef DBUG_OFF
+ waiter->debug_done= true;
+#endif
+ mysql_cond_signal(&waiter->COND_wait_commit_dep);
+ mysql_mutex_unlock(&waiter->LOCK_wait_commit);
+ }
}
@@ -456,7 +697,23 @@ bool trans_xa_start(THD *thd)
else if (!trans_begin(thd))
{
MYSQL_SET_TRANSACTION_XID(thd->m_transaction_psi, thd->lex->xid,
XA_ACTIVE);
- if (xid_cache_insert(thd, &thd->transaction->xid_state, thd->lex->xid))
+
+ bool parallel_slave_xap_status= true; // `true` presumes ordinary XA START.
+ if (thd->rgi_slave &&
+ thd->rgi_slave->is_parallel_exec)
+ {
+ DBUG_ASSERT(thd->rgi_slave->gtid_ev_flags2 |
+ Gtid_log_event::FL_PREPARED_XA);
+ /*
+ The status gets refined below normally to flip in which case `false`
+ designates the xid insert is done.
+ Possibly incurred wait is when xid is duplicate.
+ */
+ parallel_slave_xap_status= xid_cache_insert_maybe_wait(thd);
+ }
+
+ if (parallel_slave_xap_status &&
+ xid_cache_insert(thd, &thd->transaction->xid_state, thd->lex->xid))
{
trans_rollback(thd);
DBUG_RETURN(true);
@@ -602,12 +859,19 @@ bool trans_xa_commit(THD *thd)
my_error(ER_OUT_OF_RESOURCES, MYF(0));
DBUG_RETURN(TRUE);
}
+ DBUG_ASSERT(!thd->rgi_slave || !thd->rgi_slave->is_async_xac);
- if (auto xs= xid_cache_search(thd, thd->lex->xid))
+ /*
+ Parallel slave may not succeed acquiring xid, in which case
+ @c is_async_xac is @c true, it will do that later.
+ */
+ XID_cache_element *xs;
+ if ((xs= xid_cache_search(thd, thd->lex->xid)) ||
+ (thd->rgi_slave && thd->rgi_slave->is_async_xac))
{
bool xid_deleted= false;
MDL_request mdl_request;
- bool rw_trans= (xs->rm_error != ER_XA_RBROLLBACK);
+ bool rw_trans= (xs && xs->rm_error != ER_XA_RBROLLBACK);
if (rw_trans && thd->is_read_only_ctx())
{
@@ -615,8 +879,7 @@ bool trans_xa_commit(THD *thd)
res= 1;
goto _end_external_xid;
}
-
- res= xa_trans_rolled_back(xs);
+ res= xs ? xa_trans_rolled_back(xs) : 0;
/*
Acquire metadata lock which will ensure that COMMIT is blocked
by active FLUSH TABLES WITH READ LOCK (and vice versa COMMIT in
@@ -645,7 +908,7 @@ bool trans_xa_commit(THD *thd)
}
DBUG_ASSERT(!xid_state.xid_cache_element);
- xid_state.xid_cache_element= xs;
+ xid_state.xid_cache_element= xs; // may be NULL on parallel slave
ha_commit_or_rollback_by_xid(thd->lex->xid, !res);
if (!res && thd->is_error())
{
@@ -654,13 +917,16 @@ bool trans_xa_commit(THD *thd)
res= true;
goto _end_external_xid;
}
- xid_cache_delete(thd, xs);
+ DBUG_ASSERT(xs || (thd->rgi_slave && thd->rgi_slave->is_async_xac &&
+ xid_state.xid_cache_element));
+
+ xid_cache_delete(thd, xid_state.xid_cache_element);
xid_deleted= true;
_end_external_xid:
xid_state.xid_cache_element= 0;
res= res || thd->is_error();
- if (!xid_deleted)
+ if (!xid_deleted && xs)
xs->acquired_to_recovered();
if (mdl_request.ticket)
{
@@ -790,12 +1056,14 @@ bool trans_xa_rollback(THD *thd)
DBUG_RETURN(TRUE);
}
- if (auto xs= xid_cache_search(thd, thd->lex->xid))
+ XID_cache_element *xs;
+ if ((xs= xid_cache_search(thd, thd->lex->xid)) ||
+ (thd->rgi_slave && thd->rgi_slave->is_async_xac))
{
bool res;
bool xid_deleted= false;
MDL_request mdl_request;
- bool rw_trans= (xs->rm_error != ER_XA_RBROLLBACK);
+ bool rw_trans= (xs && xs->rm_error != ER_XA_RBROLLBACK);
if (rw_trans && thd->is_read_only_ctx())
{
@@ -822,7 +1090,7 @@ bool trans_xa_rollback(THD *thd)
{
thd->backup_commit_lock= &mdl_request;
}
- res= xa_trans_rolled_back(xs);
+ res= xs ? xa_trans_rolled_back(xs) : 0;
DBUG_ASSERT(!xid_state.xid_cache_element);
xid_state.xid_cache_element= xs;
@@ -831,12 +1099,15 @@ bool trans_xa_rollback(THD *thd)
{
goto _end_external_xid;
}
- xid_cache_delete(thd, xs);
+ DBUG_ASSERT(xs || (thd->rgi_slave && thd->rgi_slave->is_async_xac &&
+ xid_state.xid_cache_element));
+
+ xid_cache_delete(thd, xid_state.xid_cache_element);
xid_deleted= true;
_end_external_xid:
xid_state.xid_cache_element= 0;
- if (!xid_deleted)
+ if (!xid_deleted && xs)
xs->acquired_to_recovered();
if (mdl_request.ticket)
{
@@ -1146,7 +1417,7 @@ static bool slave_applier_reset_xa_trans(THD *thd)
{
thd->transaction->xid_state.set_error(ER_XA_RBROLLBACK);
}
- thd->transaction->xid_state.xid_cache_element->acquired_to_recovered();
+ auto element= thd->transaction->xid_state.xid_cache_element;
thd->transaction->xid_state.xid_cache_element= 0;
for (Ha_trx_info *ha_info= thd->transaction->all.ha_list, *ha_info_next;
@@ -1158,6 +1429,34 @@ static bool slave_applier_reset_xa_trans(THD *thd)
thd->transaction->all.ha_list= 0;
ha_close_connection(thd);
+ element->acquired_to_recovered();
+ if (thd->rgi_slave && thd->rgi_slave->is_parallel_exec)
+ {
+ /* make the xid available to a possible (xa-"complete") waiter */
+ wait_for_commit *xac_waiter= NULL,
+ *notifier= &thd->rgi_slave->commit_orderer;
+ while (unlikely(!element->
+ c_waiter.compare_exchange_weak(xac_waiter, notifier,
+ std::memory_order_acq_rel)))
+ {
+ if (xac_waiter)
+ {
+ break;
+ }
+ else
+ {
+ (void) LF_BACKOFF();
+ }
+ }
+ if (xac_waiter)
+ {
+ // unmark and signal
+ mysql_mutex_lock(&xac_waiter->LOCK_wait_commit);
+ element->c_waiter.store(NULL, std::memory_order_relaxed);
+ mysql_cond_signal(&xac_waiter->COND_wait_commit_dep);
+ mysql_mutex_unlock(&xac_waiter->LOCK_wait_commit);
+ }
+ }
thd->transaction->cleanup();
thd->transaction->all.reset();
diff --git a/storage/innobase/trx/trx0undo.cc b/storage/innobase/trx/trx0undo.cc
index daf27822085..53ce685fa35 100644
--- a/storage/innobase/trx/trx0undo.cc
+++ b/storage/innobase/trx/trx0undo.cc
@@ -639,8 +639,7 @@ static void trx_undo_write_xid(buf_block_t *block, uint16_t
offset,
static_cast<uint32_t>(xid.bqual_length));
const ulint xid_length= static_cast<ulint>(xid.gtrid_length
+ xid.bqual_length);
- mtr->memcpy(*block, &block->page.frame[offset + TRX_UNDO_XA_XID],
- xid.data, xid_length);
+ mtr->memcpy<mtr_t::MAYBE_NOP>(*block, &block->page.frame[offset +
TRX_UNDO_XA_XID], xid.data, xid_length);
if (UNIV_LIKELY(xid_length < XIDDATASIZE))
mtr->memset(block, offset + TRX_UNDO_XA_XID + xid_length,
XIDDATASIZE - xid_length, 0);
--
2.30.2
_______________________________________________
commits mailing list -- commits@lists.mariadb.org
To unsubscribe send an email to commits-le...@lists.mariadb.org
