Added new MDL_BACKUP locks for all backup stages

Part of MDEV-5336 Implement LOCK FOR BACKUP

- Added new locks to MDL_BACKUP for all stages of backup locks and
  a new MDL lock needed for backup stages.
- Renamed MDL_BACKUP_STMT to MDL_BACKUP_DDL
- flush_tables() takes a new parameter that decides what should be flushed.
- InnoDB, Aria (transactional tables with checksums), Blackhole, Federated
  and Federatedx tables are marked to be safe for online backup. We are
  using MDL_BACKUP_TRANS_DML instead of MDL_BACKUP_DML locks for these
  which allows any DML's to proceed for these tables during the whole
  backup process until BACKUP STAGE COMMIT which will block the final
  commit.

25 files changed, 574 insertions, 126 deletions

diff --git a/mysql-test/main/create_or_replace.result b/mysql-test/main/create_or_replace.result
index cdeabfb450d..485091e5810 100644
--- a/mysql-test/main/create_or_replace.result
+++ b/mysql-test/main/create_or_replace.result
@@ -257,12 +257,13 @@ drop table if exists test.t1,mysqltest2.t2;
 Warnings:
 Note	1051	Unknown table 'test.t1'
 Note	1051	Unknown table 'mysqltest2.t2'
-create table test.t1 (i int);
+create table test.t1 (i int) engine=myisam;
 create table mysqltest2.t2 like test.t1;
 lock table test.t1 write, mysqltest2.t2 write;
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
@@ -274,7 +275,8 @@ Tables_in_test
 t2
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
@@ -289,7 +291,8 @@ create table mysqltest2.t2 like test.t1;
 lock table test.t1 write, mysqltest2.t2 write;
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
@@ -301,7 +304,8 @@ Tables_in_test
 t2
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
@@ -311,6 +315,31 @@ select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
 create table t1 (i int);
 drop table t1;
+create table test.t1 (i int) engine=innodb;
+create table mysqltest2.t2 like test.t1;
+lock table test.t1 write, mysqltest2.t2 write;
+select * from information_schema.metadata_lock_info;
+THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
+#	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
+#	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
+#	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
+unlock tables;
+drop table test.t1,mysqltest2.t2;
+create table test.t1 (i int) engine=aria transactional=1 checksum=1;
+create table mysqltest2.t2 like test.t1;
+lock table test.t1 write, mysqltest2.t2 write;
+select * from information_schema.metadata_lock_info;
+THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	mysqltest2	
+#	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
+#	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	mysqltest2	t2
+#	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
+unlock tables;
+drop table t1;
+create table test.t1 (i int);
 drop database mysqltest2;
 #
 # Testing CREATE .. LIKE
@@ -398,28 +427,32 @@ create table t1 (a int);
 lock table t1 write, t2 read;
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
 #	MDL_SHARED_READ	NULL	Table metadata lock	test	t2
 create or replace table t1 (i int);
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
 #	MDL_SHARED_READ	NULL	Table metadata lock	test	t2
 create or replace table t1 like t2;
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
 #	MDL_SHARED_READ	NULL	Table metadata lock	test	t2
 create or replace table t1 select 1 as f1;
 select * from information_schema.metadata_lock_info;
 THREAD_ID	LOCK_MODE	LOCK_DURATION	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-#	MDL_BACKUP_STMT	NULL	Backup lock		
+#	MDL_BACKUP_DDL	NULL	Backup lock		
+#	MDL_BACKUP_DML	NULL	Backup lock		
 #	MDL_INTENTION_EXCLUSIVE	NULL	Schema metadata lock	test	
 #	MDL_SHARED_NO_READ_WRITE	NULL	Table metadata lock	test	t1
 #	MDL_SHARED_READ	NULL	Table metadata lock	test	t2
diff --git a/mysql-test/main/create_or_replace.test b/mysql-test/main/create_or_replace.test
index 4b167663742..1b4994e811f 100644
--- a/mysql-test/main/create_or_replace.test
+++ b/mysql-test/main/create_or_replace.test
@@ -210,7 +210,7 @@ drop table t1,t3,t4;
 create database mysqltest2;
 
 drop table if exists test.t1,mysqltest2.t2;
-create table test.t1 (i int);
+create table test.t1 (i int) engine=myisam;
 create table mysqltest2.t2 like test.t1;
 lock table test.t1 write, mysqltest2.t2 write;
 --replace_column 1 #
@@ -249,6 +249,26 @@ create or replace table mysqltest2.t2 (a int) select 1 as 'a', 2 as 'a';
 select * from information_schema.metadata_lock_info;
 create table t1 (i int);
 drop table t1;
+
+create table test.t1 (i int) engine=innodb;
+create table mysqltest2.t2 like test.t1;
+lock table test.t1 write, mysqltest2.t2 write;
+--replace_column 1 #
+--sorted_result
+select * from information_schema.metadata_lock_info;
+unlock tables;
+drop table test.t1,mysqltest2.t2;
+
+create table test.t1 (i int) engine=aria transactional=1 checksum=1;
+create table mysqltest2.t2 like test.t1;
+lock table test.t1 write, mysqltest2.t2 write;
+--replace_column 1 #
+--sorted_result
+select * from information_schema.metadata_lock_info;
+unlock tables;
+drop table t1;
+
+create table test.t1 (i int);
 drop database mysqltest2;
 
 --echo #
diff --git a/mysql-test/main/mdl.result b/mysql-test/main/mdl.result
index 471146b0407..187d885f29c 100644
--- a/mysql-test/main/mdl.result
+++ b/mysql-test/main/mdl.result
@@ -6,17 +6,84 @@
 #                         failed in MDL_context::upgrade_shared_lock
 #
 CREATE TABLE t1(a INT) ENGINE=InnoDB;
+CREATE TABLE t3(a INT) ENGINE=myisam;
 LOCK TABLES t1 WRITE CONCURRENT, t1 AS t2 READ;
 SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
 LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-MDL_BACKUP_STMT	Backup lock		
+MDL_BACKUP_TRANS_DML	Backup lock		
 MDL_SHARED_NO_READ_WRITE	Table metadata lock	test	t1
 UNLOCK TABLES;
 LOCK TABLES t1 AS t2 READ, t1 WRITE CONCURRENT;
 SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
 LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
-MDL_BACKUP_STMT	Backup lock		
+MDL_BACKUP_TRANS_DML	Backup lock		
 MDL_SHARED_WRITE	Table metadata lock	test	t1
 MDL_SHARED_READ_ONLY	Table metadata lock	test	t1
 UNLOCK TABLES;
-DROP TABLE t1;
+LOCK TABLES t1 WRITE CONCURRENT, t3 WRITE;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_DDL	Backup lock		
+MDL_BACKUP_DML	Backup lock		
+MDL_SHARED_WRITE	Table metadata lock	test	t1
+MDL_SHARED_NO_READ_WRITE	Table metadata lock	test	t3
+MDL_INTENTION_EXCLUSIVE	Schema metadata lock	test	
+UNLOCK TABLES;
+LOCK TABLES t3 WRITE, t1 WRITE CONCURRENT;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_DDL	Backup lock		
+MDL_BACKUP_DML	Backup lock		
+MDL_SHARED_WRITE	Table metadata lock	test	t1
+MDL_SHARED_NO_READ_WRITE	Table metadata lock	test	t3
+MDL_INTENTION_EXCLUSIVE	Schema metadata lock	test	
+UNLOCK TABLES;
+LOCK TABLES t1 WRITE, mysql.user WRITE;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_DDL	Backup lock		
+MDL_SHARED_NO_READ_WRITE	Table metadata lock	mysql	user
+MDL_SHARED_NO_READ_WRITE	Table metadata lock	test	t1
+MDL_INTENTION_EXCLUSIVE	Schema metadata lock	mysql	
+MDL_INTENTION_EXCLUSIVE	Schema metadata lock	test	
+UNLOCK TABLES;
+LOCK TABLES mysql.general_log WRITE;
+ERROR HY000: You can't use locks with log tables
+LOCK TABLES t1 WRITE,information_schema.tables READ;
+UNLOCK TABLES;
+DROP TABLE t1,t3;
+#
+# Check MDL locks taken for different kind of tables by open
+#
+CREATE TABLE t1(a INT) ENGINE=InnoDB;
+CREATE TABLE t3(a INT) ENGINE=myisam;
+connect  locker,localhost,root,,;
+connection default;
+FLUSH TABLES WITH READ LOCK;
+connection locker;
+insert into t1 values (1);
+connection default;
+connection default;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_FTWRL2	Backup lock		
+MDL_SHARED_WRITE	Table metadata lock	test	t1
+unlock tables;
+connection locker;
+unlock tables;
+connection default;
+FLUSH TABLES WITH READ LOCK;
+connection locker;
+insert into t3 values (2);
+connection default;
+connection default;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_FTWRL2	Backup lock		
+MDL_SHARED_WRITE	Table metadata lock	test	t3
+unlock tables;
+connection locker;
+unlock tables;
+connection default;
+disconnect locker;
+DROP TABLE t1,t3;
diff --git a/mysql-test/main/mdl.test b/mysql-test/main/mdl.test
index b90c74a8f7f..23a862f5212 100644
--- a/mysql-test/main/mdl.test
+++ b/mysql-test/main/mdl.test
@@ -10,10 +10,72 @@
 --echo #
 
 CREATE TABLE t1(a INT) ENGINE=InnoDB;
+CREATE TABLE t3(a INT) ENGINE=myisam;
 LOCK TABLES t1 WRITE CONCURRENT, t1 AS t2 READ;
 SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
 UNLOCK TABLES;
 LOCK TABLES t1 AS t2 READ, t1 WRITE CONCURRENT;
 SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
 UNLOCK TABLES;
-DROP TABLE t1;
+LOCK TABLES t1 WRITE CONCURRENT, t3 WRITE;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+UNLOCK TABLES;
+LOCK TABLES t3 WRITE, t1 WRITE CONCURRENT;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+UNLOCK TABLES;
+LOCK TABLES t1 WRITE, mysql.user WRITE;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+UNLOCK TABLES;
+--error ER_CANT_LOCK_LOG_TABLE
+LOCK TABLES mysql.general_log WRITE;
+# The following may work in embedded server
+--error 0,ER_DBACCESS_DENIED_ERROR
+LOCK TABLES t1 WRITE,information_schema.tables READ;
+UNLOCK TABLES;
+DROP TABLE t1,t3;
+
+--echo #
+--echo # Check MDL locks taken for different kind of tables by open
+--echo #
+
+CREATE TABLE t1(a INT) ENGINE=InnoDB;
+CREATE TABLE t3(a INT) ENGINE=myisam;
+connect (locker,localhost,root,,);
+connection default;
+
+FLUSH TABLES WITH READ LOCK;
+connection locker;
+--send insert into t1 values (1)
+connection default;
+# Wait till above update gets blocked on a user lock.
+let $wait_condition=
+  select count(*) > 0 from information_schema.processlist
+  where state = "Waiting for backup lock";
+--source include/wait_condition.inc
+connection default;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+unlock tables;
+connection locker;
+--reap
+unlock tables;
+connection default;
+
+FLUSH TABLES WITH READ LOCK;
+connection locker;
+--send insert into t3 values (2)
+connection default;
+# Wait till above update gets blocked on a user lock.
+let $wait_condition=
+  select count(*) > 0 from information_schema.processlist
+  where state = "Waiting for backup lock";
+--source include/wait_condition.inc
+connection default;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+unlock tables;
+connection locker;
+--reap
+unlock tables;
+connection default;
+
+disconnect locker;
+DROP TABLE t1,t3;
diff --git a/mysql-test/main/mdl_sync.result b/mysql-test/main/mdl_sync.result
index f5268e557ab..917b97d0295 100644
--- a/mysql-test/main/mdl_sync.result
+++ b/mysql-test/main/mdl_sync.result
@@ -2514,6 +2514,12 @@ connection con2;
 SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
 # Check that FLUSH must wait to get the GRL
 # and let DROP PROCEDURE continue
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_DDL	Backup lock		
+MDL_EXCLUSIVE	Stored procedure metadata lock	test	p1
+MDL_INTENTION_EXCLUSIVE	Schema metadata lock	test	
+MDL_SHARED_WRITE	Table metadata lock	mysql	proc
 SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
 FLUSH TABLES WITH READ LOCK;
 connection default;
@@ -2528,6 +2534,43 @@ connection con2;
 UNLOCK TABLES;
 connection default;
 SET DEBUG_SYNC= 'RESET';
+#
+# UPDATE should wait for FTWRL with non transactional table second
+#
+create table t1 (a int) engine=myisam;
+create table t2 (a int) engine=innodb;
+insert into t1 values (1);
+insert into t2 values (1);
+SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait execute 2';
+update t1,t2 set t1.a=2,t2.a=3;
+connection con2;
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'now SIGNAL grlwait';
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
+FLUSH TABLES WITH READ LOCK;
+connection default;
+# Reaping UPDATE
+connection con2;
+UNLOCK TABLES;
+connection default;
+SET DEBUG_SYNC= 'RESET';
+SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait execute 2';
+update t2,t1 set t1.a=2,t2.a=3;
+connection con2;
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'now SIGNAL grlwait';
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
+FLUSH TABLES WITH READ LOCK;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+LOCK_MODE	LOCK_TYPE	TABLE_SCHEMA	TABLE_NAME
+MDL_BACKUP_FTWRL2	Backup lock		
+unlock tables;
+connection default;
+# Reaping UPDATE
+SET DEBUG_SYNC= 'RESET';
+drop table t1,t2;
 disconnect con2;
 #
 # Bug#50786 Assertion `thd->mdl_context.trans_sentinel() == __null' 
@@ -2535,7 +2578,6 @@ disconnect con2;
 #
 # Supress warnings written to the log file
 call mtr.add_suppression("Wait on a lock was aborted due to a pending exclusive lock");
-DROP TABLE IF EXISTS t1, t2;
 connect  con1,localhost,root;
 connect  con2,localhost,root;
 connect  con3,localhost,root;
diff --git a/mysql-test/main/mdl_sync.test b/mysql-test/main/mdl_sync.test
index 7c19eab5c37..a794dbf4a7a 100644
--- a/mysql-test/main/mdl_sync.test
+++ b/mysql-test/main/mdl_sync.test
@@ -2,6 +2,7 @@
 # We need the Debug Sync Facility.
 #
 --source include/have_debug_sync.inc
+--source include/have_metadata_lock_info.inc
 
 # We need InnoDB tables for some of the tests.
 --source include/have_innodb.inc
@@ -3248,6 +3249,7 @@ connection con2;
 SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
 --echo # Check that FLUSH must wait to get the GRL
 --echo # and let DROP PROCEDURE continue
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
 SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
 --send FLUSH TABLES WITH READ LOCK
 
@@ -3264,12 +3266,59 @@ connection con2;
 --echo # Reaping FTWRL.
 --reap
 UNLOCK TABLES;
+connection default;
+SET DEBUG_SYNC= 'RESET';
+
+--echo #
+--echo # UPDATE should wait for FTWRL with non transactional table second
+--echo #
+
+create table t1 (a int) engine=myisam;
+create table t2 (a int) engine=innodb;
+insert into t1 values (1);
+insert into t2 values (1);
+
+SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait execute 2';
+--send update t1,t2 set t1.a=2,t2.a=3
+
+connection con2;
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'now SIGNAL grlwait';
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
+FLUSH TABLES WITH READ LOCK;
+
+connection default;
+--echo # Reaping UPDATE
+--reap
+
+connection con2;
+UNLOCK TABLES;
 
 connection default;
 SET DEBUG_SYNC= 'RESET';
 
-disconnect con2;
+# This will cause a wait as we first get lock for innodb table t2 but FTWRL
+# will cause lock for t1 to wait
+
+SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait execute 2';
+--send update t2,t1 set t1.a=2,t2.a=3
+
+connection con2;
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'now SIGNAL grlwait';
+SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
+SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
+FLUSH TABLES WITH READ LOCK;
+SELECT LOCK_MODE, LOCK_TYPE, TABLE_SCHEMA, TABLE_NAME FROM information_schema.metadata_lock_info;
+unlock tables;
 
+connection default;
+--echo # Reaping UPDATE
+--reap
+SET DEBUG_SYNC= 'RESET';
+drop table t1,t2;
+disconnect con2;
 
 --echo #
 --echo # Bug#50786 Assertion `thd->mdl_context.trans_sentinel() == __null' 
@@ -3278,9 +3327,6 @@ disconnect con2;
 
 --echo # Supress warnings written to the log file
 call mtr.add_suppression("Wait on a lock was aborted due to a pending exclusive lock");
---disable_warnings
-DROP TABLE IF EXISTS t1, t2;
---enable_warnings
 
 connect (con1,localhost,root);
 connect (con2,localhost,root);
diff --git a/mysql-test/suite/compat/oracle/r/sp-package-mdl.result b/mysql-test/suite/compat/oracle/r/sp-package-mdl.result
index bc4e56c1ce6..bb46341f202 100644
--- a/mysql-test/suite/compat/oracle/r/sp-package-mdl.result
+++ b/mysql-test/suite/compat/oracle/r/sp-package-mdl.result
@@ -61,7 +61,7 @@ TABLE_NAME	pkg1.p1
 CONN	2
 INFO	DROP PACKAGE pkg1
 STATE	Waiting for stored package body metadata lock
-LOCK_MODE	MDL_BACKUP_STMT
+LOCK_MODE	MDL_BACKUP_DDL
 LOCK_TYPE	Backup lock
 TABLE_NAME	
 CONN	2
diff --git a/sql/handler.h b/sql/handler.h
index df31ae4898a..a0739d75aaf 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -316,6 +316,9 @@ enum enum_alter_inplace_result {
 */
 #define HA_SLOW_RND_POS  (1ULL << 55)
 
+/* Safe for online backup */
+#define HA_CAN_ONLINE_BACKUPS (1ULL << 56)
+
 /* bits in index_flags(index_number) for what you can do with index */
 #define HA_READ_NEXT            1       /* TODO really use this flag */
 #define HA_READ_PREV            2       /* supports ::index_prev */
diff --git a/sql/lock.cc b/sql/lock.cc
index 1103bc96f1a..f6a4ea00a33 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -863,7 +863,7 @@ bool lock_schema_name(THD *thd, const char *db)
 
   if (thd->global_read_lock.can_acquire_protection())
     return TRUE;
-  global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_STMT, MDL_STATEMENT);
+  global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_DDL, MDL_STATEMENT);
   mdl_request.init(MDL_key::SCHEMA, db, "", MDL_EXCLUSIVE, MDL_TRANSACTION);
 
   mdl_requests.push_front(&mdl_request);
@@ -921,7 +921,7 @@ bool lock_object_name(THD *thd, MDL_key::enum_mdl_namespace mdl_type,
 
   if (thd->global_read_lock.can_acquire_protection())
     return TRUE;
-  global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_STMT, MDL_STATEMENT);
+  global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_DDL, MDL_STATEMENT);
   schema_request.init(MDL_key::SCHEMA, db, "", MDL_INTENTION_EXCLUSIVE,
                       MDL_TRANSACTION);
   mdl_request.init(mdl_type, db, name, MDL_EXCLUSIVE, MDL_TRANSACTION);
@@ -996,7 +996,8 @@ bool lock_object_name(THD *thd, MDL_key::enum_mdl_namespace mdl_type,
 /**
   Take global read lock, wait if there is protection against lock.
 
-  If the global read lock is already taken by this thread, then nothing is done.
+  If the global read lock is already taken by this thread, then nothing is
+  done.
 
   Concurrent thread can acquire protection against global read lock either
   before or after it got table metadata lock. This may lead to a deadlock if
@@ -1011,7 +1012,7 @@ bool lock_object_name(THD *thd, MDL_key::enum_mdl_namespace mdl_type,
 
   See also "Handling of global read locks" above.
 
-  @param thd     Reference to thread.
+  @param thd         Reference to thread.
 
   @retval False  Success, global read lock set, commits are NOT blocked.
   @retval True   Failure, thread was killed.
@@ -1033,7 +1034,8 @@ bool Global_read_lock::lock_global_read_lock(THD *thd)
                                                  MDL_BACKUP_FTWRL1));
     DBUG_ASSERT(! thd->mdl_context.is_lock_owner(MDL_key::BACKUP, "", "",
                                                  MDL_BACKUP_FTWRL2));
-    mdl_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_FTWRL1, MDL_EXPLICIT);
+    mdl_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_FTWRL1,
+                     MDL_EXPLICIT);
 
     do
     {
diff --git a/sql/mdl.cc b/sql/mdl.cc
index b096f944fb5..40ef4c04676 100644
--- a/sql/mdl.cc
+++ b/sql/mdl.cc
@@ -109,12 +109,23 @@ static const LEX_STRING lock_types[]=
 
 static const LEX_STRING backup_lock_types[]=
 {
+  { C_STRING_WITH_LEN("MDL_BACKUP_START") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_FLUSH") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_WAIT_FLUSH") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_WAIT_DDL") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_WAIT_COMMIT") },
   { C_STRING_WITH_LEN("MDL_BACKUP_FTWRL1") },
   { C_STRING_WITH_LEN("MDL_BACKUP_FTWRL2") },
-  { C_STRING_WITH_LEN("MDL_BACKUP_STMT") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_DML") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_TRANS_DML") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_SYS_DML") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_DDL") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_BLOCK_DDL") },
+  { C_STRING_WITH_LEN("MDL_BACKUP_ALTER_COPY") },
   { C_STRING_WITH_LEN("MDL_BACKUP_COMMIT") }
 };
 
+
 #ifdef HAVE_PSI_INTERFACE
 void MDL_key::init_psi_keys()
 {
@@ -300,8 +311,6 @@ Deadlock_detection_visitor::opt_change_victim_to(MDL_context *new_victim)
   and compatibility matrices.
 */
 
-#define MDL_BIT(A) static_cast<MDL_lock::bitmap_t>(1U << A)
-
 /**
   The lock context. Created internally for an acquired lock.
   For a given name, there exists only one MDL_lock instance,
@@ -316,7 +325,7 @@ Deadlock_detection_visitor::opt_change_victim_to(MDL_context *new_victim)
 class MDL_lock
 {
 public:
-  typedef unsigned short bitmap_t;
+  typedef mdl_bitmap_t bitmap_t;
 
   class Ticket_list
   {
@@ -416,9 +425,10 @@ public:
     { return m_waiting_incompatible; }
     virtual bool needs_notification(const MDL_ticket *ticket) const
     {
-      return ticket->get_type() == MDL_SHARED_NO_WRITE ||
-             ticket->get_type() == MDL_SHARED_NO_READ_WRITE ||
-             ticket->get_type() == MDL_EXCLUSIVE;
+      return (MDL_BIT(ticket->get_type()) &
+              (MDL_BIT(MDL_SHARED_NO_WRITE) |
+               MDL_BIT(MDL_SHARED_NO_READ_WRITE) |
+               MDL_BIT(MDL_EXCLUSIVE)));
     }
 
     /**
@@ -459,17 +469,19 @@ public:
     { return m_waiting_incompatible; }
     virtual bool needs_notification(const MDL_ticket *ticket) const
     {
-      return ticket->get_type() == MDL_BACKUP_FTWRL1;
+      return (MDL_BIT(ticket->get_type()) & MDL_BIT(MDL_BACKUP_FTWRL1));
     }
 
     /**
-      Threads having aninsert delayed thread may hold STMT lock. We
-      need to kill such threads in order to get backup lock for FTWRL
-      or BACKUP statements. We do this my calling code outside of MDL.
+       Insert delayed threads may hold DML or TRANS_DML lock.
+       We need to kill such threads in order to get lock for FTWRL statements.
+       We do this by calling code outside of MDL.
     */
     virtual bool conflicting_locks(const MDL_ticket *ticket) const
     {
-      return ticket->get_type() == MDL_BACKUP_STMT;
+      return (MDL_BIT(ticket->get_type()) &
+              (MDL_BIT(MDL_BACKUP_DML) |
+               MDL_BIT(MDL_BACKUP_TRANS_DML)));
     }
 
     /*
@@ -1488,41 +1500,41 @@ MDL_lock::MDL_scoped_lock::m_waiting_incompatible[MDL_TYPE_END]=
   The first array specifies if particular type of request can be satisfied
   if there is granted lock of certain type.
 
-     Request  |  Granted requests for lock            |
-      type    | S  SH  SR  SW  SU  SRO  SNW  SNRW  X  |
-    ----------+---------------------------------------+
-    S         | +   +   +   +   +   +    +    +    -  |
-    SH        | +   +   +   +   +   +    +    +    -  |
-    SR        | +   +   +   +   +   +    +    -    -  |
-    SW        | +   +   +   +   +   -    -    -    -  |
-    SU        | +   +   +   +   -   +    -    -    -  |
-    SRO       | +   +   +   -   +   +    +    -    -  |
-    SNW       | +   +   +   -   -   +    -    -    -  |
-    SNRW      | +   +   -   -   -   -    -    -    -  |
-    X         | -   -   -   -   -   -    -    -    -  |
-    SU -> X   | -   -   -   -   0   -    0    0    0  |
-    SNW -> X  | -   -   -   0   0   -    0    0    0  |
-    SNRW -> X | -   -   0   0   0   0    0    0    0  |
+     Request  |  Granted requests for lock         |
+      type    | S  SH  SR  SW  SU  SRO SNW SNRW X  |
+    ----------+------------------------------------+
+    S         | +   +   +   +   +   +   +   +   -  |
+    SH        | +   +   +   +   +   +   +   +   -  |
+    SR        | +   +   +   +   +   +   +   -   -  |
+    SW        | +   +   +   +   +   -   -   -   -  |
+    SU        | +   +   +   +   -   +   -   -   -  |
+    SRO       | +   +   +   -   +   +   +   -   -  |
+    SNW       | +   +   +   -   -   +   -   -   -  |
+    SNRW      | +   +   -   -   -   -   -   -   -  |
+    X         | -   -   -   -   -   -   -   -   -  |
+    SU -> X   | -   -   -   -   0   -   0   0   0  |
+    SNW -> X  | -   -   -   0   0   -   0   0   0  |
+    SNRW -> X | -   -   0   0   0   0   0   0   0  |
 
   The second array specifies if particular type of request can be satisfied
   if there is waiting request for the same lock of certain type. In other
   words it specifies what is the priority of different lock types.
 
-     Request  |  Pending requests for lock           |
-      type    | S  SH  SR  SW  SU  SRO  SNW  SNRW  X |
-    ----------+--------------------------------------+
-    S         | +   +   +   +   +   +    +     +   - |
-    SH        | +   +   +   +   +   +    +     +   + |
-    SR        | +   +   +   +   +   +    +     -   - |
-    SW        | +   +   +   +   +   +    -     -   - |
-    SU        | +   +   +   +   +   +    +     +   - |
-    SRO       | +   +   +   -   +   +    +     -   - |
-    SNW       | +   +   +   +   +   +    +     +   - |
-    SNRW      | +   +   +   +   +   +    +     +   - |
-    X         | +   +   +   +   +   +    +     +   + |
-    SU -> X   | +   +   +   +   +   +    +     +   + |
-    SNW -> X  | +   +   +   +   +   +    +     +   + |
-    SNRW -> X | +   +   +   +   +   +    +     +   + |
+     Request  |  Pending requests for lock        |
+      type    | S  SH  SR  SW  SU  SRO SNW SNRW X |
+    ----------+-----------------------------------+
+    S         | +   +   +   +   +   +   +   +   - |
+    SH        | +   +   +   +   +   +   +   +   + |
+    SR        | +   +   +   +   +   +   +   -   - |
+    SW        | +   +   +   +   +   +   -   -   - |
+    SU        | +   +   +   +   +   +   +   +   - |
+    SRO       | +   +   +   -   +   +   +   -   - |
+    SNW       | +   +   +   +   +   +   +   +   - |
+    SNRW      | +   +   +   +   +   +   +   +   - |
+    X         | +   +   +   +   +   +   +   +   + |
+    SU -> X   | +   +   +   +   +   +   +   +   + |
+    SNW -> X  | +   +   +   +   +   +   +   +   + |
+    SNRW -> X | +   +   +   +   +   +   +   +   + |
 
   Here: "+" -- means that request can be satisfied
         "-" -- means that request can't be satisfied and should wait
@@ -1590,49 +1602,106 @@ MDL_lock::MDL_object_lock::m_waiting_incompatible[MDL_TYPE_END]=
   The first array specifies if particular type of request can be satisfied
   if there is granted backup lock of certain type.
 
-             | Type of active  |
-     Request |   backup lock   |
-      type   | F1  F2   S   C  |
-    ---------+-----------------+
-    FTWRL1   |  +   +   -   +  |
-    FTWRL2   |  +   +   -   -  |
-    STMT     |  -   -   +   +  |
-    COMMIT   |  +   -   +   +  |
+     Request  |           Type of active backup lock                    |
+      type    | S0  S1  S2  S3  S4  F1  F2   D  TD  SD   DD  BL  AC  C  |
+    ----------+---------------------------------------------------------+
+    S0        |  -   -   -   -   -   +   +   +   +   +   +   +   +   +  |
+    S1        |  -   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    S2        |  -   +   +   +   +   +   +   -   +   +   +   +   +   +  |
+    S3        |  -   +   +   +   +   +   +   -   +   +   -   +   +   +  |
+    S4        |  -   +   +   +   +   +   +   -   +   -   -   +   +   -  |
+    FTWRL1    |  +   +   +   +   +   +   +   -   -   -   -   +   -   +  |
+    FTWRL2    |  +   +   +   +   +   +   +   -   -   -   -   +   -   -  |
+    D         |  +   -   -   -   -   -   -   +   +   +   +   +   +   +  |
+    TD        |  +   +   +   +   +   -   -   +   +   +   +   +   +   +  |
+    SD        |  +   +   +   +   -   -   -   +   +   +   +   +   +   +  |
+    DDL       |  +   +   +   -   -   -   -   +   +   +   +   -   +   +  |
+    BLOCK_DDL |  +   +   +   +   +   +   +   +   +   +   -   +   +   +  |
+    ALTER_COP |  +   +   +   +   +   -   -   +   +   +   +   +   +   +  |
+    COMMIT    |  +   +   +   +   -   +   -   +   +   +   +   +   +   +  |
 
   The second array specifies if particular type of request can be satisfied
   if there is already waiting request for the backup lock of certain type.
   I.e. it specifies what is the priority of different lock types.
 
-             |     Pending     |
-     Request |   backup lock   |
-      type   | F1  F2   S   C  |
-    ---------+-----------------+
-    FTWRL1   |  +   +   +   +  |
-    FTWRL2   |  +   +   +   +  |
-    STMT     |  -   -   +   +  |
-    COMMIT   |  +   -   +   +  |
+     Request  |               Pending backup lock                       |
+      type    | S0  S1  S2  S3  S4  F1  F2   D  TD  SD   DD  BL  AC  C  |
+    ----------+---------------------------------------------------------+
+    S0        |  -   -   -   -   -   +   +   +   +   +   +   +   +   +  |
+    S1        |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    S2        |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    S3        |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    S4        |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    FTWRL1    |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    FTWRL2    |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    D         |  +   -   -   -   -   -   -   +   +   +   +   +   +   +  |
+    TD        |  +   +   +   +   +   -   -   +   +   +   +   +   +   +  |
+    SD        |  +   +   +   +   -   -   -   +   +   +   +   +   +   +  |
+    DDL       |  +   +   +   -   -   -   -   +   +   +   +   -   +   +  |
+    BLOCK_DDL |  +   +   +   +   +   +   +   +   +   +   +   +   +   +  |
+    ALTER_COP |  +   +   +   +   +   -   -   +   +   +   +   +   +   +  |
+    COMMIT    |  +   +   +   +   -   +   -   +   +   +   +   +   +   +  |
 
   Here: "+" -- means that request can be satisfied
         "-" -- means that request can't be satisfied and should wait
 */
 
+/*
+  NOTE: If you add a new MDL_BACKUP_XXX level lock, you have to also add it
+  to MDL_BACKUP_START in the two arrays below!
+*/
+
 const MDL_lock::bitmap_t
 MDL_lock::MDL_backup_lock::m_granted_incompatible[MDL_BACKUP_END]=
 {
-  MDL_BIT(MDL_BACKUP_STMT),
-  MDL_BIT(MDL_BACKUP_STMT) | MDL_BIT(MDL_BACKUP_COMMIT),
+  /* MDL_BACKUP_START */
+  MDL_BIT(MDL_BACKUP_START) | MDL_BIT(MDL_BACKUP_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT),
+  MDL_BIT(MDL_BACKUP_START),
+  MDL_BIT(MDL_BACKUP_START) | MDL_BIT(MDL_BACKUP_DML),
+  MDL_BIT(MDL_BACKUP_START) | MDL_BIT(MDL_BACKUP_DML) | MDL_BIT(MDL_BACKUP_DDL),
+  MDL_BIT(MDL_BACKUP_START) | MDL_BIT(MDL_BACKUP_DML) | MDL_BIT(MDL_BACKUP_SYS_DML) | MDL_BIT(MDL_BACKUP_DDL) | MDL_BIT(MDL_BACKUP_COMMIT),
+
+  /* MDL_BACKUP_FTWRL1 */
+  MDL_BIT(MDL_BACKUP_DML) | MDL_BIT(MDL_BACKUP_TRANS_DML) | MDL_BIT(MDL_BACKUP_SYS_DML) | MDL_BIT(MDL_BACKUP_DDL) | MDL_BIT(MDL_BACKUP_ALTER_COPY),
+  MDL_BIT(MDL_BACKUP_DML) | MDL_BIT(MDL_BACKUP_TRANS_DML) | MDL_BIT(MDL_BACKUP_SYS_DML) | MDL_BIT(MDL_BACKUP_DDL) | MDL_BIT(MDL_BACKUP_ALTER_COPY) | MDL_BIT(MDL_BACKUP_COMMIT),
+  /* MDL_BACKUP_DML */
+  MDL_BIT(MDL_BACKUP_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  /* MDL_BACKUP_DDL */
+  MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2) | MDL_BIT(MDL_BACKUP_BLOCK_DDL),
+  /* MDL_BACKUP_BLOCK_DDL */
+  MDL_BIT(MDL_BACKUP_DDL),
   MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
-  MDL_BIT(MDL_BACKUP_FTWRL2)
+  /* MDL_BACKUP_COMMIT */
+  MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL2)
 };
 
 
 const MDL_lock::bitmap_t
 MDL_lock::MDL_backup_lock::m_waiting_incompatible[MDL_BACKUP_END]=
 {
+  /* MDL_BACKUP_START */
+  MDL_BIT(MDL_BACKUP_START) | MDL_BIT(MDL_BACKUP_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT),
   0,
   0,
+  0,
+  0,
+  /* MDL_BACKUP_FTWRL1 */
+  0,
+  0,
+
+  /* MDL_BACKUP_DML */
+  MDL_BIT(MDL_BACKUP_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_FLUSH) | MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
+  /* MDL_BACKUP_DDL */
+  MDL_BIT(MDL_BACKUP_WAIT_DDL) | MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2) | MDL_BIT(MDL_BACKUP_BLOCK_DDL),
+  /* MDL_BACKUP_BLOCK_DDL */
+  0,
   MDL_BIT(MDL_BACKUP_FTWRL1) | MDL_BIT(MDL_BACKUP_FTWRL2),
-  MDL_BIT(MDL_BACKUP_FTWRL2)
+  /* MDL_BACKUP_COMMIT */
+  MDL_BIT(MDL_BACKUP_WAIT_COMMIT) | MDL_BIT(MDL_BACKUP_FTWRL2)
 };
 
 
@@ -2454,8 +2523,14 @@ MDL_context::upgrade_shared_lock(MDL_ticket *mdl_ticket,
   /*
     Do nothing if already upgraded. Used when we FLUSH TABLE under
     LOCK TABLES and a table is listed twice in LOCK TABLES list.
+
+    In BACKUP namespace upgrade must always happen. Even though
+    MDL_BACKUP_START is not stronger than MDL_BACKUP_FLUSH from
+    has_stronger_or_equal_type(), the latter effectively blocks
+    new MDL_BACKUP_DML while the former doesn't.
   */
-  if (mdl_ticket->has_stronger_or_equal_type(new_type))
+  if (mdl_ticket->has_stronger_or_equal_type(new_type) &&
+      mdl_ticket->get_key()->mdl_namespace() != MDL_key::BACKUP)
     DBUG_RETURN(FALSE);
 
   mdl_xlock_request.init(&mdl_ticket->m_lock->key, new_type,
@@ -2856,9 +2931,13 @@ void MDL_ticket::downgrade_lock(enum_mdl_type type)
   if (m_type == type || !has_stronger_or_equal_type(type))
     return;
 
-  /* Only allow downgrade from EXCLUSIVE and SHARED_NO_WRITE. */
-  DBUG_ASSERT(m_type == MDL_EXCLUSIVE ||
-              m_type == MDL_SHARED_NO_WRITE);
+  /* Only allow downgrade in some specific known cases */
+  DBUG_ASSERT((get_key()->mdl_namespace() != MDL_key::BACKUP &&
+               (m_type == MDL_EXCLUSIVE ||
+                m_type == MDL_SHARED_NO_WRITE)) ||
+              (get_key()->mdl_namespace() == MDL_key::BACKUP &&
+               (m_type == MDL_BACKUP_DDL ||
+                m_type == MDL_BACKUP_WAIT_FLUSH)));
 
   mysql_prlock_wrlock(&m_lock->m_rwlock);
   /*
diff --git a/sql/mdl.h b/sql/mdl.h
index 425c7a43ea6..63cec3b65cf 100644
--- a/sql/mdl.h
+++ b/sql/mdl.h
@@ -28,6 +28,10 @@ class MDL_lock;
 class MDL_ticket;
 bool  ok_for_lower_case_names(const char *name);
 
+typedef unsigned short mdl_bitmap_t;
+#define MDL_BIT(A) static_cast<mdl_bitmap_t>(1U << A)
+
+
 /**
   @def ENTER_COND(C, M, S, O)
   Start a wait on a condition.
@@ -250,28 +254,68 @@ enum enum_mdl_type {
 /** Backup locks */
 
 /**
+  Block concurrent backup
+*/
+#define MDL_BACKUP_START enum_mdl_type(0)
+/**
+   Block new write requests to non transactional tables
+*/
+#define MDL_BACKUP_FLUSH enum_mdl_type(1)
+/**
+   In addition to previous locks, blocks running requests to non trans tables
+   Used to wait until all DML usage of on trans tables are finished
+*/
+#define MDL_BACKUP_WAIT_FLUSH enum_mdl_type(2)
+/**
+   In addition to previous locks, blocks new DDL's from starting
+*/
+#define MDL_BACKUP_WAIT_DDL enum_mdl_type(3)
+/**
+   In addition to previous locks, blocks commits
+*/
+#define MDL_BACKUP_WAIT_COMMIT enum_mdl_type(4)
+
+/**
   Blocks (or is blocked by) statements that intend to modify data. Acquired
   before commit lock by FLUSH TABLES WITH READ LOCK.
 */
-#define MDL_BACKUP_FTWRL1 enum_mdl_type(0)
+#define MDL_BACKUP_FTWRL1 enum_mdl_type(5)
 
 /**
   Blocks (or is blocked by) commits. Acquired after global read lock by
   FLUSH TABLES WITH READ LOCK.
 */
-#define MDL_BACKUP_FTWRL2 enum_mdl_type(1)
+#define MDL_BACKUP_FTWRL2 enum_mdl_type(6)
+
+#define MDL_BACKUP_DML enum_mdl_type(7)
+#define MDL_BACKUP_TRANS_DML enum_mdl_type(8)
+#define MDL_BACKUP_SYS_DML enum_mdl_type(9)
 
 /**
-  Must be acquired by statements that intend to modify data.
+  Must be acquired by DDL statements that intend to modify data.
+  Currently it's also used for LOCK TABLES.
 */
-#define MDL_BACKUP_STMT enum_mdl_type(2)
+#define MDL_BACKUP_DDL enum_mdl_type(10)
 
 /**
-  Must be acquired during commit.
+   Blocks new DDL's. Used by backup code to enable DDL logging
 */
-#define MDL_BACKUP_COMMIT enum_mdl_type(3)
-#define MDL_BACKUP_END enum_mdl_type(4)
+#define MDL_BACKUP_BLOCK_DDL enum_mdl_type(11)
 
+/*
+  Statement is modifying data, but will not block MDL_BACKUP_DDL or earlier
+  BACKUP stages.
+  ALTER TABLE is started with MDL_BACKUP_DDL, but changed to
+  MDL_BACKUP_ALTER_COPY while alter table is copying or modifing data.
+*/
+
+#define MDL_BACKUP_ALTER_COPY enum_mdl_type(12)
+
+/**
+  Must be acquired during commit.
+*/
+#define MDL_BACKUP_COMMIT enum_mdl_type(13)
+#define MDL_BACKUP_END enum_mdl_type(14)
 
 
 /** Duration of metadata lock. */
diff --git a/sql/sp.cc b/sql/sp.cc
index 665a47cc384..6b38a0ddeb5 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -1795,7 +1795,7 @@ bool lock_db_routines(THD *thd, const char *db)
 
   /* We should already hold a global IX lock and a schema X lock. */
   DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::BACKUP, "", "",
-                                             MDL_BACKUP_STMT) &&
+                                             MDL_BACKUP_DDL) &&
               thd->mdl_context.is_lock_owner(MDL_key::SCHEMA, db, "",
                                              MDL_EXCLUSIVE));
   DBUG_RETURN(thd->mdl_context.acquire_locks(&mdl_requests,
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index a9184d1cdf1..0fa6f4b3c68 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -460,6 +460,7 @@ bool close_cached_tables(THD *thd, TABLE_LIST *tables,
 struct tc_collect_arg
 {
   DYNAMIC_ARRAY shares;
+  flush_tables_type flush_type;
 };
 
 static my_bool tc_collect_used_shares(TDC_element *element,
@@ -472,9 +473,27 @@ static my_bool tc_collect_used_shares(TDC_element *element,
   if (element->ref_count > 0 && !element->share->is_view)
   {
     DBUG_ASSERT(element->share);
-    element->ref_count++;                       // Protect against delete
-    if (push_dynamic(shares,(uchar*) &element->share))
-      result= TRUE;
+    bool do_flush= 0;
+    switch (arg->flush_type) {
+    case FLUSH_ALL:
+      do_flush= 1;
+      break;
+    case FLUSH_NON_TRANS_TABLES:
+      if (!element->share->online_backup &&
+          element->share->table_category == TABLE_CATEGORY_USER)
+        do_flush= 1;
+      break;
+    case FLUSH_SYS_TABLES:
+      if (!element->share->online_backup &&
+          element->share->table_category != TABLE_CATEGORY_USER)
+        do_flush= 1;
+    }
+    if (do_flush)
+    {
+      element->ref_count++;                       // Protect against delete
+      if (push_dynamic(shares, (uchar*) &element->share))
+        result= TRUE;
+    }
   }
   mysql_mutex_unlock(&element->LOCK_table_share);
   return result;
@@ -494,7 +513,7 @@ static my_bool tc_collect_used_shares(TDC_element *element,
    possible tables, even if some flush fails.
 */
 
-bool flush_tables(THD *thd)
+bool flush_tables(THD *thd, flush_tables_type flag)
 {
   bool result= TRUE;
   uint open_errors= 0;
@@ -517,6 +536,7 @@ bool flush_tables(THD *thd)
 
   my_init_dynamic_array(&collect_arg.shares, sizeof(TABLE_SHARE*), 100, 100,
                         MYF(0));
+  collect_arg.flush_type= flag;
   if (tdc_iterate(thd, (my_hash_walk_action) tc_collect_used_shares,
                   &collect_arg, true))
   {
@@ -2062,12 +2082,19 @@ retry_share:
             pre-acquiring metadata locks at the beggining of
             open_tables() call.
     */
+    enum enum_mdl_type mdl_type= MDL_BACKUP_DML;
+
+    if (table->s->table_category != TABLE_CATEGORY_USER)
+      mdl_type= MDL_BACKUP_SYS_DML;
+    else if (table->s->online_backup)
+      mdl_type= MDL_BACKUP_TRANS_DML;
+
     if (table_list->mdl_request.is_write_lock_request() &&
         ! (flags & (MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK |
                     MYSQL_OPEN_FORCE_SHARED_MDL |
                     MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL |
                     MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK)) &&
-        ! ot_ctx->has_protection_against_grl())
+        ! ot_ctx->has_protection_against_grl(mdl_type))
     {
       MDL_request protection_request;
       MDL_deadlock_handler mdl_deadlock_handler(ot_ctx);
@@ -2079,7 +2106,7 @@ retry_share:
         DBUG_RETURN(TRUE);
       }
 
-      protection_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_STMT,
+      protection_request.init(MDL_key::BACKUP, "", "", mdl_type,
                               MDL_STATEMENT);
 
       /*
@@ -2098,7 +2125,7 @@ retry_share:
         DBUG_RETURN(TRUE);
       }
 
-      ot_ctx->set_has_protection_against_grl();
+      ot_ctx->set_has_protection_against_grl(mdl_type);
     }
   }
 
@@ -2219,7 +2246,7 @@ TABLE *find_table_for_mdl_upgrade(THD *thd, const char *db,
     global read lock.
   */
   if (unlikely(!thd->mdl_context.is_lock_owner(MDL_key::BACKUP, "", "",
-                                               MDL_BACKUP_STMT)))
+                                               MDL_BACKUP_DDL)))
   {
     error= ER_TABLE_NOT_LOCKED_FOR_WRITE;
     goto err_exit;
@@ -2976,7 +3003,7 @@ Open_table_context::Open_table_context(THD *thd, uint flags)
    m_flags(flags),
    m_action(OT_NO_ACTION),
    m_has_locks(thd->mdl_context.has_locks()),
-   m_has_protection_against_grl(FALSE)
+   m_has_protection_against_grl(0)
 {}
 
 
@@ -3192,7 +3219,7 @@ Open_table_context::recover_from_failed_open()
     against GRL. It is no longer valid as the corresponding lock was
     released by close_tables_for_reopen().
   */
-  m_has_protection_against_grl= FALSE;
+  m_has_protection_against_grl= 0;
   /* Prepare for possible another back-off. */
   m_action= OT_NO_ACTION;
   return result;
@@ -3952,7 +3979,7 @@ lock_table_names(THD *thd, const DDL_options_st &options,
     */
     if (thd->global_read_lock.can_acquire_protection())
       DBUG_RETURN(TRUE);
-    global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_STMT,
+    global_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_DDL,
                         MDL_STATEMENT);
     mdl_requests.push_front(&global_request);
 
diff --git a/sql/sql_base.h b/sql/sql_base.h
index 47ca2229af5..2b245217bce 100644
--- a/sql/sql_base.h
+++ b/sql/sql_base.h
@@ -57,6 +57,13 @@ enum enum_resolution_type {
   RESOLVED_AGAINST_ALIAS
 };
 
+/* Argument to flush_tables() of what to flush */
+enum flush_tables_type {
+  FLUSH_ALL,
+  FLUSH_NON_TRANS_TABLES,
+  FLUSH_SYS_TABLES
+};
+
 enum find_item_error_report_type {REPORT_ALL_ERRORS, REPORT_EXCEPT_NOT_FOUND,
 				  IGNORE_ERRORS, REPORT_EXCEPT_NON_UNIQUE,
                                   IGNORE_EXCEPT_NON_UNIQUE};
@@ -291,7 +298,7 @@ void close_log_table(THD *thd, Open_tables_backup *backup);
 bool close_cached_tables(THD *thd, TABLE_LIST *tables,
                          bool wait_for_refresh, ulong timeout);
 void purge_tables(bool purge_flag);
-bool flush_tables(THD *thd);
+bool flush_tables(THD *thd, flush_tables_type flag);
 bool close_cached_connection_tables(THD *thd, LEX_CSTRING *connect_string);
 void close_all_tables_for_name(THD *thd, TABLE_SHARE *share,
                                ha_extra_function extra,
@@ -552,14 +559,14 @@ public:
     Set flag indicating that we have already acquired metadata lock
     protecting this statement against GRL while opening tables.
   */
-  void set_has_protection_against_grl()
+  void set_has_protection_against_grl(enum_mdl_type mdl_type)
   {
-    m_has_protection_against_grl= TRUE;
+    m_has_protection_against_grl|= MDL_BIT(mdl_type);
   }
 
-  bool has_protection_against_grl() const
+  bool has_protection_against_grl(enum_mdl_type mdl_type) const
   {
-    return m_has_protection_against_grl;
+    return (bool) (m_has_protection_against_grl & MDL_BIT(mdl_type));
   }
 
 private:
@@ -591,7 +598,7 @@ private:
     Indicates that in the process of opening tables we have acquired
     protection against global read lock.
   */
-  bool m_has_protection_against_grl;
+  mdl_bitmap_t m_has_protection_against_grl;
 };
 
 
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index fb4c5309b23..c741400b741 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -550,7 +550,7 @@ bool open_and_lock_for_insert_delayed(THD *thd, TABLE_LIST *table_list)
   if (thd->global_read_lock.can_acquire_protection())
     DBUG_RETURN(TRUE);
 
-  protection_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_STMT,
+  protection_request.init(MDL_key::BACKUP, "", "", MDL_BACKUP_DML,
                           MDL_STATEMENT);
 
   if (thd->mdl_context.acquire_lock(&protection_request,
@@ -2374,9 +2374,12 @@ bool delayed_get_table(THD *thd, MDL_request *grl_protection_request,
       di->table_list.alias.str=    di->table_list.table_name.str=    di->thd.query();
       di->table_list.alias.length= di->table_list.table_name.length= di->thd.query_length();
       di->table_list.db= di->thd.db;
-      /* We need the tickets so that they can be cloned in handle_delayed_insert */
+      /*
+        We need the tickets so that they can be cloned in
+        handle_delayed_insert
+      */
       di->grl_protection.init(MDL_key::BACKUP, "", "",
-                              MDL_BACKUP_STMT, MDL_STATEMENT);
+                              MDL_BACKUP_DML, MDL_STATEMENT);
       di->grl_protection.ticket= grl_protection_request->ticket;
       init_mdl_requests(&di->table_list);
       di->table_list.mdl_request.ticket= table_list->mdl_request.ticket;
diff --git a/sql/sql_reload.cc b/sql/sql_reload.cc
index 6035800c973..334e1697abd 100644
--- a/sql/sql_reload.cc
+++ b/sql/sql_reload.cc
@@ -250,7 +250,7 @@ bool reload_acl_and_cache(THD *thd, unsigned long long options,
       tmp_write_to_binlog= 0;
       if (thd->global_read_lock.lock_global_read_lock(thd))
 	return 1;                               // Killed
-      if (flush_tables(thd))
+      if (flush_tables(thd, FLUSH_ALL))
       {
         /*
           NOTE: my_error() has been already called by reopen_tables() within
@@ -273,7 +273,7 @@ bool reload_acl_and_cache(THD *thd, unsigned long long options,
         make_global_read_lock_block_commit(thd) above since they could have
         modified the tables too.
       */
-      if (WSREP(thd) && flush_tables(thd))
+      if (WSREP(thd) && flush_tables(thd, FLUSH_ALL))
         result= 1;
     }
     else
@@ -309,7 +309,7 @@ bool reload_acl_and_cache(THD *thd, unsigned long long options,
           */
           if (thd->open_tables &&
               !thd->mdl_context.is_lock_owner(MDL_key::BACKUP, "", "",
-                                              MDL_BACKUP_STMT))
+                                              MDL_BACKUP_DDL))
           {
             my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
                      thd->open_tables->s->table_name.str);
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 3a6e3112c77..3c95c6b2eec 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -9200,7 +9200,7 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db,
       */
       DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::BACKUP,
                                                  "", "",
-                                                 MDL_BACKUP_STMT));
+                                                 MDL_BACKUP_DDL));
 
       if (thd->mdl_context.acquire_locks(&mdl_requests,
                                          thd->variables.lock_wait_timeout))
diff --git a/sql/table.cc b/sql/table.cc
index 8630320090f..b68edd064f5 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -3561,6 +3561,8 @@ partititon_err:
       share->no_replicate= TRUE;
     if (outparam->file->table_cache_type() & HA_CACHE_TBL_NOCACHE)
       share->not_usable_by_query_cache= TRUE;
+    if (outparam->file->ha_table_flags() & HA_CAN_ONLINE_BACKUPS)
+      share->online_backup= 1;
   }
 
   if (share->no_replicate || !binlog_filter->db_ok(share->db.str))
diff --git a/sql/table.h b/sql/table.h
index 38129ef98f8..2732a6b8f76 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -732,6 +732,7 @@ struct TABLE_SHARE
   bool null_field_first;
   bool system;                          /* Set if system table (one record) */
   bool not_usable_by_query_cache;
+  bool online_backup;                   /* Set if on-line backup supported */
   bool no_replicate;
   bool crashed;
   bool is_view;
diff --git a/storage/blackhole/ha_blackhole.h b/storage/blackhole/ha_blackhole.h
index 9a4b34809f8..345d6683938 100644
--- a/storage/blackhole/ha_blackhole.h
+++ b/storage/blackhole/ha_blackhole.h
@@ -55,7 +55,7 @@ public:
   {
     return(HA_NULL_IN_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER |
            HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE |
-           HA_CAN_INDEX_BLOBS | HA_AUTO_PART_KEY |
+           HA_CAN_INDEX_BLOBS | HA_AUTO_PART_KEY | HA_CAN_ONLINE_BACKUPS |
            HA_FILE_BASED | HA_CAN_GEOMETRY | HA_CAN_INSERT_DELAYED);
   }
   ulong index_flags(uint inx, uint part, bool all_parts) const
diff --git a/storage/federated/ha_federated.h b/storage/federated/ha_federated.h
index 8fe42bd2b08..45318f4c594 100644
--- a/storage/federated/ha_federated.h
+++ b/storage/federated/ha_federated.h
@@ -146,6 +146,7 @@ public:
             HA_NO_PREFIX_CHAR_KEYS | HA_PRIMARY_KEY_REQUIRED_FOR_DELETE |
             HA_NO_TRANSACTIONS /* until fixed by WL#2952 */ |
             HA_PARTIAL_COLUMN_READ | HA_NULL_IN_KEY |
+            HA_CAN_ONLINE_BACKUPS |
             HA_CAN_REPAIR);
   }
   /*
diff --git a/storage/federatedx/ha_federatedx.h b/storage/federatedx/ha_federatedx.h
index 16a1944b172..7eed0fa539e 100644
--- a/storage/federatedx/ha_federatedx.h
+++ b/storage/federatedx/ha_federatedx.h
@@ -333,7 +333,7 @@ public:
     return (HA_PRIMARY_KEY_IN_READ_INDEX | HA_FILE_BASED
             | HA_REC_NOT_IN_SEQ | HA_AUTO_PART_KEY | HA_CAN_INDEX_BLOBS |
             HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE | HA_CAN_REPAIR |
-            HA_PRIMARY_KEY_REQUIRED_FOR_DELETE |
+            HA_PRIMARY_KEY_REQUIRED_FOR_DELETE | HA_CAN_ONLINE_BACKUPS |
             HA_PARTIAL_COLUMN_READ | HA_NULL_IN_KEY);
   }
   /*
diff --git a/storage/heap/ha_heap.h b/storage/heap/ha_heap.h
index e17c18c8b14..3a7e0060a05 100644
--- a/storage/heap/ha_heap.h
+++ b/storage/heap/ha_heap.h
@@ -49,7 +49,7 @@ public:
   {
     return (HA_FAST_KEY_READ | HA_NO_BLOBS | HA_NULL_IN_KEY |
             HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
-            HA_CAN_SQL_HANDLER |
+            HA_CAN_SQL_HANDLER | HA_CAN_ONLINE_BACKUPS |
             HA_REC_NOT_IN_SEQ | HA_CAN_INSERT_DELAYED | HA_NO_TRANSACTIONS |
             HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT);
   }
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index e0a066a595a..f293dce063f 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -2911,6 +2911,7 @@ ha_innobase::ha_innobase(
 			  | HA_CAN_EXPORT
 			  | HA_CAN_RTREEKEYS
                           | HA_CAN_TABLES_WITHOUT_ROLLBACK
+                          | HA_CAN_ONLINE_BACKUPS
 			  | HA_CONCURRENT_OPTIMIZE
 			  |  (srv_force_primary_key ? HA_REQUIRE_PRIMARY_KEY : 0)
 		  ),
diff --git a/storage/maria/ha_maria.cc b/storage/maria/ha_maria.cc
index c551923f660..30f8724aebd 100644
--- a/storage/maria/ha_maria.cc
+++ b/storage/maria/ha_maria.cc
@@ -1261,6 +1261,14 @@ int ha_maria::open(const char *name, int mode, uint test_if_locked)
     int_table_flags |= HA_HAS_NEW_CHECKSUM;
 
   /*
+    We can only do online backup on transactional tables with checksum.
+    Checksums are needed to avoid half writes.
+  */
+  if (file->s->options & HA_OPTION_PAGE_CHECKSUM &&
+      file->s->base.born_transactional)
+    int_table_flags |= HA_CAN_ONLINE_BACKUPS;
+
+  /*
     For static size rows, tell MariaDB that we will access all bytes
     in the record when writing it.  This signals MariaDB to initalize
     the full row to ensure we don't get any errors from valgrind and