mirror of
https://github.com/MariaDB/server.git
synced 2025-01-18 04:53:01 +01:00
378cdc58c1
bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ LOCK" and bug #54673 "It takes too long to get readlock for 'FLUSH TABLES WITH READ LOCK'". The first bug manifested itself as a deadlock which occurred when a connection, which had some table open through HANDLER statement, tried to update some data through DML statement while another connection tried to execute FLUSH TABLES WITH READ LOCK concurrently. What happened was that FTWRL in the second connection managed to perform first step of GRL acquisition and thus blocked all upcoming DML. After that it started to wait for table open through HANDLER statement to be flushed. When the first connection tried to execute DML it has started to wait for GRL/the second connection creating deadlock. The second bug manifested itself as starvation of FLUSH TABLES WITH READ LOCK statements in cases when there was a constant stream of concurrent DML statements (in two or more connections). This has happened because requests for protection against GRL which were acquired by DML statements were ignoring presence of pending GRL and thus the latter was starved. This patch solves both these problems by re-implementing GRL using metadata locks. Similar to the old implementation acquisition of GRL in new implementation is two-step. During the first step we block all concurrent DML and DDL statements by acquiring global S metadata lock (each DML and DDL statement acquires global IX lock for its duration). During the second step we block commits by acquiring global S lock in COMMIT namespace (commit code acquires global IX lock in this namespace). Note that unlike in old implementation acquisition of protection against GRL in DML and DDL is semi-automatic. We assume that any statement which should be blocked by GRL will either open and acquires write-lock on tables or acquires metadata locks on objects it is going to modify. For any such statement global IX metadata lock is automatically acquired for its duration. The first problem is solved because waits for GRL become visible to deadlock detector in metadata locking subsystem and thus deadlocks like one in the first bug become impossible. The second problem is solved because global S locks which are used for GRL implementation are given preference over IX locks which are acquired by concurrent DML (and we can switch to fair scheduling in future if needed). Important change: FTWRL/GRL no longer blocks DML and DDL on temporary tables. Before this patch behavior was not consistent in this respect: in some cases DML/DDL statements on temporary tables were blocked while in others they were not. Since the main use cases for FTWRL are various forms of backups and temporary tables are not preserved during backups we have opted for consistently allowing DML/DDL on temporary tables during FTWRL/GRL. Important change: This patch changes thread state names which are used when DML/DDL of FTWRL is waiting for global read lock. It is now either "Waiting for global read lock" or "Waiting for commit lock" depending on the stage on which FTWRL is. Incompatible change: To solve deadlock in events code which was exposed by this patch we have to replace LOCK_event_metadata mutex with metadata locks on events. As result we have to prohibit DDL on events under LOCK TABLES. This patch also adds extensive test coverage for interaction of DML/DDL and FTWRL. Performance of new and old global read lock implementations in sysbench tests were compared. There were no significant difference between new and old implementations.
38 lines
1.1 KiB
Text
38 lines
1.1 KiB
Text
DROP TABLE IF EXISTS t1;
|
|
SET DEBUG_SYNC= 'RESET';
|
|
CREATE TABLE t1 (kill_id INT) engine = InnoDB;
|
|
INSERT INTO t1 VALUES(connection_id());
|
|
# Switching to connection 'default'.
|
|
# Start transaction.
|
|
BEGIN;
|
|
INSERT INTO t1 VALUES(connection_id());
|
|
# Ensure that COMMIT will pause once it acquires protection
|
|
# against its global read lock.
|
|
SET DEBUG_SYNC='ha_commit_trans_after_acquire_commit_lock SIGNAL acquired WAIT_FOR go';
|
|
# Sending:
|
|
COMMIT;
|
|
# Switching to 'con1'.
|
|
# Wait till COMMIT acquires protection against global read
|
|
# lock and pauses.
|
|
SET DEBUG_SYNC='now WAIT_FOR acquired';
|
|
# Sending:
|
|
FLUSH TABLES WITH READ LOCK;
|
|
# Switching to 'con2'.
|
|
SELECT ((@id := kill_id) - kill_id) FROM t1 LIMIT 1;
|
|
((@id := kill_id) - kill_id)
|
|
0
|
|
# Wait till FLUSH TABLES WITH READ LOCK blocks due
|
|
# to active COMMIT
|
|
# Kill connection 'con1'.
|
|
KILL CONNECTION @id;
|
|
# Switching to 'con1'.
|
|
# Try to reap FLUSH TABLES WITH READ LOCK,
|
|
# it fail due to killed statement and connection.
|
|
Got one of the listed errors
|
|
# Switching to 'con2'.
|
|
# Resume COMMIT.
|
|
SET DEBUG_SYNC='now SIGNAL go';
|
|
# Switching to 'default'.
|
|
# Reaping COMMIT.
|
|
DROP TABLE t1;
|
|
SET DEBUG_SYNC= 'RESET';
|