mirror of
https://github.com/MariaDB/server.git
synced 2025-01-20 05:52:27 +01:00
e5a397e28f
The problem is that some DDL statements (ALTER TABLE, CREATE TRIGGER, FLUSH TABLES, ...) when under LOCK TABLES need to momentarily drop the lock, reopen the table and grab the write lock again (using reopen_tables). When grabbing the lock again, reopen_tables doesn't pass a flag to mysql_lock_tables in order to ignore the impending global read lock, which causes a assertion because LOCK_open is being hold. Also dropping the lock must not signal to any threads that the table has been relinquished (related to the locking/flushing protocol). The solution is to correct the way the table is reopenned and the locks grabbed. When reopening the table and under LOCK TABLES, the table version should be set to 0 so other threads have to wait for the table. When grabbing the lock, any other flush should be ignored because it's theoretically a atomic operation. The chosen solution also fixes a potential discrepancy between binlog and GRL (global read lock) because table placeholders were being ignored, now a FLUSH TABLES WITH READ LOCK will properly for table with open placeholders. It's also important to mention that this patch doesn't fix a potential deadlock if one uses two GRLs under LOCK TABLES concurrently. mysql-test/r/lock_multi.result: Add test case result for Bug#32395 mysql-test/r/trigger_notembedded.result: Add test case result for Bug#32395 mysql-test/t/lock_multi.test: Add test case for Bug#32395 mysql-test/t/trigger_notembedded.test: Enable test case for Bug#32395 sql/ha_ndbcluster.cc: Update close_cached_tables usage. sql/ha_ndbcluster_binlog.cc: Update close_cached_tables usage. sql/mysql_priv.h: Update close_cache_tables prototype. sql/set_var.cc: Update close_cached_tables usage and set flag to wait for tables with placeholders. This is one of the places where a GRL can be obtained. sql/sql_base.cc: Preserve old version for write locked tables and ignore pending flushes and update close_cache_tables to take into account name locked tables. sql/sql_parse.cc: Update close_cached_tables usage and pass flag so that name locked tables are waited for. sql/sql_table.cc: Protect the table against a impending GRL if under LOCK TABLES.
442 lines
11 KiB
Text
442 lines
11 KiB
Text
-- source include/not_embedded.inc
|
|
--disable_warnings
|
|
drop table if exists t1,t2;
|
|
--enable_warnings
|
|
|
|
# Test to see if select will get the lock ahead of low priority update
|
|
|
|
connect (locker,localhost,root,,);
|
|
connect (reader,localhost,root,,);
|
|
connect (writer,localhost,root,,);
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
lock tables t1 write;
|
|
connection writer;
|
|
send update low_priority t1 set n = 4;
|
|
connection reader;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
send select n from t1;
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "select n from t1";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection writer;
|
|
reap;
|
|
connection reader;
|
|
reap;
|
|
drop table t1;
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
lock tables t1 read;
|
|
connection writer;
|
|
send update low_priority t1 set n = 4;
|
|
connection reader;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
select n from t1;
|
|
connection locker;
|
|
unlock tables;
|
|
connection writer;
|
|
reap;
|
|
drop table t1;
|
|
|
|
#
|
|
# Test problem when using locks with multi-updates
|
|
# It should not block when multi-update is reading on a read-locked table
|
|
#
|
|
|
|
connection locker;
|
|
create table t1 (a int, b int);
|
|
create table t2 (c int, d int);
|
|
insert into t1 values(1,1);
|
|
insert into t1 values(2,2);
|
|
insert into t2 values(1,2);
|
|
lock table t1 read;
|
|
connection writer;
|
|
update t1,t2 set c=a where b=d;
|
|
connection reader;
|
|
select c from t2;
|
|
connection locker;
|
|
drop table t1;
|
|
drop table t2;
|
|
|
|
#
|
|
# Test problem when using locks on many tables and droping a table that
|
|
# is to-be-locked by another thread
|
|
#
|
|
#
|
|
connection locker;
|
|
create table t1 (a int);
|
|
create table t2 (a int);
|
|
lock table t1 write, t2 write;
|
|
connection reader;
|
|
send insert t1 select * from t2;
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
connection reader;
|
|
--error 1146
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
|
|
#
|
|
# Same test as above, but with the dropped table locked twice
|
|
#
|
|
|
|
connection locker;
|
|
create table t1 (a int);
|
|
create table t2 (a int);
|
|
lock table t1 write, t2 write, t1 as t1_2 write, t2 as t2_2 write;
|
|
connection reader;
|
|
send insert t1 select * from t2;
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
connection reader;
|
|
--error 1146
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
|
|
|
|
--echo End of 4.1 tests
|
|
|
|
#
|
|
# BUG#9998 - MySQL client hangs on USE "database"
|
|
#
|
|
create table t1(a int);
|
|
lock tables t1 write;
|
|
connection reader;
|
|
show columns from t1;
|
|
connection locker;
|
|
unlock tables;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#16986 - Deadlock condition with MyISAM tables
|
|
#
|
|
|
|
# Need a matching user in mysql.user for multi-table select
|
|
--source include/add_anonymous_users.inc
|
|
|
|
connection locker;
|
|
use mysql;
|
|
LOCK TABLES columns_priv WRITE, db WRITE, host WRITE, user WRITE;
|
|
FLUSH TABLES;
|
|
#
|
|
connection reader;
|
|
use mysql;
|
|
#NOTE: This must be a multi-table select, otherwise the deadlock will not occur
|
|
send SELECT user.Select_priv FROM user, db WHERE user.user = db.user LIMIT 1;
|
|
#
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table" and info =
|
|
"SELECT user.Select_priv FROM user, db WHERE user.user = db.user LIMIT 1";
|
|
--source include/wait_condition.inc
|
|
# Make test case independent from earlier grants.
|
|
--replace_result "Table is already up to date" "OK"
|
|
OPTIMIZE TABLES columns_priv, db, host, user;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection reader;
|
|
reap;
|
|
use test;
|
|
#
|
|
connection locker;
|
|
use test;
|
|
#
|
|
connection default;
|
|
#
|
|
# Test if CREATE TABLE with LOCK TABLE deadlocks.
|
|
#
|
|
connection writer;
|
|
CREATE TABLE t1 (c1 int);
|
|
LOCK TABLE t1 WRITE;
|
|
#
|
|
# This waits until t1 is unlocked.
|
|
connection locker;
|
|
send FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
connection writer;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables" and info = "FLUSH TABLES WITH READ LOCK";
|
|
--source include/wait_condition.inc
|
|
# This must not block.
|
|
CREATE TABLE t2 (c1 int);
|
|
UNLOCK TABLES;
|
|
#
|
|
# This awakes now.
|
|
connection locker;
|
|
reap;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection default;
|
|
DROP TABLE t1, t2;
|
|
#
|
|
# Test if CREATE TABLE SELECT with LOCK TABLE deadlocks.
|
|
#
|
|
connection writer;
|
|
CREATE TABLE t1 (c1 int);
|
|
LOCK TABLE t1 WRITE;
|
|
#
|
|
# This waits until t1 is unlocked.
|
|
connection locker;
|
|
send FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
# This must not block.
|
|
connection writer;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables" and info = "FLUSH TABLES WITH READ LOCK";
|
|
--source include/wait_condition.inc
|
|
--error 1100
|
|
CREATE TABLE t2 AS SELECT * FROM t1;
|
|
UNLOCK TABLES;
|
|
#
|
|
# This awakes now.
|
|
connection locker;
|
|
reap;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection default;
|
|
DROP TABLE t1;
|
|
|
|
--source include/delete_anonymous_users.inc
|
|
|
|
#
|
|
# Bug#19815 - CREATE/RENAME/DROP DATABASE can deadlock on a global read lock
|
|
#
|
|
connect (con1,localhost,root,,);
|
|
connect (con2,localhost,root,,);
|
|
#
|
|
connection con1;
|
|
CREATE DATABASE mysqltest_1;
|
|
FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
# With bug in place: acquire LOCK_mysql_create_table and
|
|
# wait in wait_if_global_read_lock().
|
|
connection con2;
|
|
send DROP DATABASE mysqltest_1;
|
|
#
|
|
# With bug in place: try to acquire LOCK_mysql_create_table...
|
|
# When fixed: Reject dropping db because of the read lock.
|
|
connection con1;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for release of readlock"
|
|
and info = "DROP DATABASE mysqltest_1";
|
|
--source include/wait_condition.inc
|
|
--error ER_CANT_UPDATE_WITH_READLOCK
|
|
DROP DATABASE mysqltest_1;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection con2;
|
|
reap;
|
|
#
|
|
connection default;
|
|
disconnect con1;
|
|
disconnect con2;
|
|
# This must have been dropped by connection 2 already,
|
|
# which waited until the global read lock was released.
|
|
--error ER_DB_DROP_EXISTS
|
|
DROP DATABASE mysqltest_1;
|
|
|
|
#
|
|
# Bug #17264: MySQL Server freeze
|
|
#
|
|
connection locker;
|
|
# Disable warnings to allow test to run also without InnoDB
|
|
--disable_warnings
|
|
create table t1 (f1 int(12) unsigned not null auto_increment, primary key(f1)) engine=innodb;
|
|
--enable_warnings
|
|
lock tables t1 write;
|
|
connection writer;
|
|
send alter table t1 auto_increment=0;
|
|
connection reader;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "alter table t1 auto_increment=0";
|
|
--source include/wait_condition.inc
|
|
send alter table t1 auto_increment=0;
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 2 from information_schema.processlist
|
|
where state = "Locked" and info = "alter table t1 auto_increment=0";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection writer;
|
|
reap;
|
|
connection reader;
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
#
|
|
--echo End of 5.0 tests
|
|
|
|
|
|
#
|
|
# Bug #21281 "Pending write lock is incorrectly removed when its
|
|
# statement being KILLed"
|
|
#
|
|
create table t1 (i int);
|
|
connection locker;
|
|
lock table t1 read;
|
|
connection writer;
|
|
--send update t1 set i= 10;
|
|
connection reader;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "update t1 set i= 10";
|
|
--source include/wait_condition.inc
|
|
--send select * from t1;
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Locked" and info = "select * from t1";
|
|
--source include/wait_condition.inc
|
|
let $ID= `select id from information_schema.processlist where state = "Locked" and info = "update t1 set i= 10"`;
|
|
--replace_result $ID ID
|
|
eval kill query $ID;
|
|
connection reader;
|
|
--reap
|
|
connection writer;
|
|
--error ER_QUERY_INTERRUPTED
|
|
--reap
|
|
connection locker;
|
|
unlock tables;
|
|
connection default;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#25856 - HANDLER table OPEN in one connection lock DROP TABLE in another one
|
|
#
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (a int) ENGINE=MEMORY;
|
|
--echo --> client 2
|
|
connection locker;
|
|
--error 1031
|
|
handler t1 open;
|
|
--echo --> client 1
|
|
connection default;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#32395 Alter table under a impending global read lock causes a server crash
|
|
#
|
|
|
|
#
|
|
# Test ALTER TABLE under LOCK TABLES and FLUSH TABLES WITH READ LOCK
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (i int);
|
|
connect (flush,localhost,root,,test,,);
|
|
connection default;
|
|
--echo connection: default
|
|
lock tables t1 write;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--send flush tables with read lock;
|
|
connection default;
|
|
--echo connection: default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables";
|
|
--source include/wait_condition.inc
|
|
alter table t1 add column j int;
|
|
connect (insert,localhost,root,,test,,);
|
|
connection insert;
|
|
--echo connection: insert
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables";
|
|
--source include/wait_condition.inc
|
|
--send insert into t1 values (1,2);
|
|
--echo connection: default
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for release of readlock";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--reap
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for release of readlock";
|
|
--source include/wait_condition.inc
|
|
select * from t1;
|
|
unlock tables;
|
|
connection insert;
|
|
--reap
|
|
connection default;
|
|
select * from t1;
|
|
drop table t1;
|
|
disconnect flush;
|
|
disconnect insert;
|
|
|
|
#
|
|
# Test that FLUSH TABLES under LOCK TABLES protects write locked tables
|
|
# from a impending FLUSH TABLES WITH READ LOCK
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (i int);
|
|
connect (flush,localhost,root,,test,,);
|
|
connection default;
|
|
--echo connection: default
|
|
lock tables t1 write;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--send flush tables with read lock;
|
|
connection default;
|
|
--echo connection: default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables";
|
|
--source include/wait_condition.inc
|
|
flush tables;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Flushing tables";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
let $wait_condition=
|
|
select count(*) = 0 from information_schema.processlist
|
|
where state = "Flushing tables";
|
|
--source include/wait_condition.inc
|
|
connection flush;
|
|
--reap
|
|
connection default;
|
|
disconnect flush;
|
|
drop table t1;
|
|
|
|
--echo End of 5.1 tests
|