Implement new type-of-operation-aware metadata locks.

Add a wait-for graph based deadlock detector to the
MDL subsystem.

Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and
bug #37346 "innodb does not detect deadlock between update and
alter table".

The first bug manifested itself as an unwarranted abort of a
transaction with ER_LOCK_DEADLOCK error by a concurrent ALTER
statement, when this transaction tried to repeat use of a
table, which it has already used in a similar fashion before
ALTER started.

The second bug showed up as a deadlock between table-level
locks and InnoDB row locks, which was "detected" only after
innodb_lock_wait_timeout timeout.

A transaction would start using the table and modify a few
rows.
Then ALTER TABLE would come in, and start copying rows
into a temporary table. Eventually it would stumble on
the modified records and get blocked on a row lock.
The first transaction would try to do more updates, and get
blocked on thr_lock.c lock.
This situation of circular wait would only get resolved
by a timeout.

Both these bugs stemmed from inadequate solutions to the
problem of deadlocks occurring between different
locking subsystems.

In the first case we tried to avoid deadlocks between metadata
locking and table-level locking subsystems, when upgrading shared
metadata lock to exclusive one.
Transactions holding the shared lock on the table and waiting for
some table-level lock used to be aborted too aggressively.

We also allowed ALTER TABLE to start in presence of transactions
that modify the subject table. ALTER TABLE acquires
TL_WRITE_ALLOW_READ lock at start, and that block all writes
against the table (naturally, we don't want any writes to be lost
when switching the old and the new table). TL_WRITE_ALLOW_READ
lock, in turn, would block the started transaction on thr_lock.c
lock, should they do more updates. This, again, lead to the need
to abort such transactions.

The second bug occurred simply because we didn't have any
mechanism to detect deadlocks between the table-level locks
in thr_lock.c and row-level locks in InnoDB, other than
innodb_lock_wait_timeout.

This patch solves both these problems by moving lock conflicts
which are causing these deadlocks into the metadata locking
subsystem, thus making it possible to avoid or detect such
deadlocks inside MDL.

To do this we introduce new type-of-operation-aware metadata
locks, which allow MDL subsystem to know not only the fact that
transaction has used or is going to use some object but also what
kind of operation it has carried out or going to carry out on the
object.

This, along with the addition of a special kind of upgradable
metadata lock, allows ALTER TABLE to wait until all
transactions which has updated the table to go away.
This solves the second issue.
Another special type of upgradable metadata lock is acquired
by LOCK TABLE WRITE. This second lock type allows to solve the
first issue, since abortion of table-level locks in event of
DDL under LOCK TABLES becomes also unnecessary.

Below follows the list of incompatible changes introduced by
this patch:

- From now on, ALTER TABLE and CREATE/DROP TRIGGER SQL (i.e. those
  statements that acquire TL_WRITE_ALLOW_READ lock)
  wait for all transactions which has *updated* the table to
  complete.

- From now on, LOCK TABLES ... WRITE, REPAIR/OPTIMIZE TABLE
  (i.e. all statements which acquire TL_WRITE table-level lock) wait
  for all transaction which *updated or read* from the table
  to complete.
  As a consequence, innodb_table_locks=0 option no longer applies
  to LOCK TABLES ... WRITE.

- DROP DATABASE, DROP TABLE, RENAME TABLE no longer abort
  statements or transactions which use tables being dropped or
  renamed, and instead wait for these transactions to complete.

- Since LOCK TABLES WRITE now takes a special metadata lock,
  not compatible with with reads or writes against the subject table
  and transaction-wide, thr_lock.c deadlock avoidance algorithm
  that used to ensure absence of deadlocks between LOCK TABLES
  WRITE and other statements is no longer sufficient, even for
  MyISAM. The wait-for graph based deadlock detector of MDL
  subsystem may sometimes be necessary and is involved. This may
  lead to ER_LOCK_DEADLOCK error produced for multi-statement
  transactions even if these only use MyISAM:

  session 1:         session 2:
  begin;

  update t1 ...      lock table t2 write, t1 write;
                     -- gets a lock on t2, blocks on t1

  update t2 ...
  (ER_LOCK_DEADLOCK)

- Finally,  support of LOW_PRIORITY option for LOCK TABLES ... WRITE
  was abandoned.
  LOCK TABLE ... LOW_PRIORITY WRITE from now on has the same
  priority as the usual LOCK TABLE ... WRITE.
  SELECT HIGH PRIORITY no longer trumps LOCK TABLE ... WRITE  in
  the wait queue.

- We do not take upgradable metadata locks on implicitly
  locked tables. So if one has, say, a view v1 that uses
  table t1, and issues:
  LOCK TABLE v1 WRITE;
  FLUSH TABLE t1; -- (or just 'FLUSH TABLES'),
  an error is produced.
  In order to be able to perform DDL on a table under LOCK TABLES,
  the table must be locked explicitly in the LOCK TABLES list.

mysql-test/include/handler.inc:
  Adjusted test case to trigger an execution path on which bug 41110
  "crash with handler command when used concurrently with alter
  table" and bug 41112 "crash in mysql_ha_close_table/get_lock_data
  with alter table" were originally discovered. Left old test case
  which no longer triggers this execution path for the sake of
  coverage.
  Added test coverage for HANDLER SQL statements and type-aware
  metadata locks.
  Added a test for the global shared lock and HANDLER SQL.
  Updated tests to take into account that the old simple deadlock
  detection heuristics was replaced with a graph-based deadlock
  detector.
mysql-test/r/debug_sync.result:
  Updated results (see debug_sync.test).
mysql-test/r/handler_innodb.result:
  Updated results (see handler.inc test).
mysql-test/r/handler_myisam.result:
  Updated results (see handler.inc test).
mysql-test/r/innodb-lock.result:
  Updated results (see innodb-lock.test).
mysql-test/r/innodb_mysql_lock.result:
  Updated results (see innodb_mysql_lock.test).
mysql-test/r/lock.result:
  Updated results (see lock.test).
mysql-test/r/lock_multi.result:
  Updated results (see lock_multi.test).
mysql-test/r/lock_sync.result:
  Updated results (see lock_sync.test).
mysql-test/r/mdl_sync.result:
  Updated results (see mdl_sync.test).
mysql-test/r/sp-threads.result:
  SHOW PROCESSLIST output has changed due to the fact that waiting
  for LOCK TABLES WRITE now happens within metadata locking
  subsystem.
mysql-test/r/truncate_coverage.result:
  Updated results (see truncate_coverage.test).
mysql-test/suite/funcs_1/datadict/processlist_val.inc:
  SELECT FROM I_S.PROCESSLIST output has changed due to fact that
  waiting for LOCK TABLES WRITE now happens within metadata locking
  subsystem.
mysql-test/suite/funcs_1/r/processlist_val_no_prot.result:
  SELECT FROM I_S.PROCESSLIST output has changed due to fact that
  waiting for LOCK TABLES WRITE now happens within metadata locking
  subsystem.
mysql-test/suite/rpl/t/rpl_sp.test:
  Updated to a new SHOW PROCESSLIST state name.
mysql-test/t/debug_sync.test:
  Use LOCK TABLES READ instead of LOCK TABLES WRITE as the latter
  no longer allows to trigger execution path involving waiting on
  thr_lock.c lock and therefore reaching debug sync-point covered
  by this test.
mysql-test/t/innodb-lock.test:
  Adjusted test case to the fact that innodb_table_locks=0 option is
  no longer supported, since LOCK TABLES WRITE handles all its
  conflicts within MDL subsystem.
mysql-test/t/innodb_mysql_lock.test:
  Added test for bug #37346 "innodb does not detect deadlock between
  update and alter table".
mysql-test/t/lock.test:
  Added test coverage which checks the fact that we no longer support
  DDL under LOCK TABLES on tables which were locked implicitly.
  Adjusted existing test cases accordingly.
mysql-test/t/lock_multi.test:
  Added test for bug #46272 "MySQL 5.4.4, new MDL: unnecessary
  deadlock".  Adjusted other test cases to take into account the
  fact that waiting for LOCK TABLES ... WRITE now happens within MDL
  subsystem.
mysql-test/t/lock_sync.test:
  Since LOCK TABLES ... WRITE now takes SNRW metadata lock for
  tables locked explicitly we have to implicitly lock InnoDB tables
  (through view) to trigger the table-level lock conflict between
  TL_WRITE and TL_WRITE_ALLOW_WRITE.
mysql-test/t/mdl_sync.test:
  Added basic test coverage for type-of-operation-aware metadata
  locks. Also covered with tests some use cases involving HANDLER
  statements in which a deadlock could arise.
  Adjusted existing tests to take type-of-operation-aware MDL into
  account.
mysql-test/t/multi_update.test:
  Update to a new SHOW PROCESSLIST state name.
mysql-test/t/truncate_coverage.test:
  Adjusted test case after making LOCK TABLES WRITE to wait until
  transactions that use the table to be locked are completed.
  Updated to the changed name of DEBUG_SYNC point.
sql/handler.cc:
  Global read lock functionality has been
  moved into a class.
sql/lock.cc:
  Global read lock functionality has been
  moved into a class.
  Updated code to use the new MDL API.
sql/mdl.cc:
  Introduced new type-of-operation aware metadata locks.
  To do this:
  - Changed MDL_lock to use one list for waiting requests and one
    list for granted requests. For each list, added a bitmap
    that holds information what lock types a list contains.
    Added a helper class MDL_lock::List to manipulate with granted
    and waited lists while keeping the bitmaps in sync
    with list contents.
  - Changed lock-compatibility functions to use bitmaps that
    define compatibility.
  - Introduced a graph based deadlock detector inspired by
    waiting_threads.c from Maria implementation.
  - Now that we have a deadlock detector, and no longer have
    a global lock to protect individual lock objects, but rather
    use an rw lock per object, removed redundant code for upgrade,
    and the global read lock. Changed the MDL API to
    no longer require the caller to acquire the global
    intention exclusive lock by means of a separate method.
    Removed a few more methods that became redundant.
  - Removed deadlock detection heuristic, it has been made
    obsolete by the deadlock detector.
  - With operation-type-aware metadata locks, MDL subsystem has
    become aware of potential conflicts between DDL and open
    transactions. This made it possible to remove calls to
    mysql_abort_transactions_with_shared_lock() from acquisition
    paths for exclusive lock and lock upgrade. Now we can simply
    wait for these transactions to complete without fear of
    deadlock. Function mysql_lock_abort() has also become
    unnecessary for all conflicting cases except when a DDL
    conflicts with a connection that has an open HANDLER.
sql/mdl.h:
  Introduced new type-of-operation aware metadata locks.
  Introduced a graph based deadlock detector and supporting
  methods.
  Added comments.
  God rid of redundant API calls.
  Renamed m_lt_or_ha_sentinel to m_trans_sentinel,
  since now it guards the global read lock as well as
  LOCK TABLES and HANDLER locks.
sql/mysql_priv.h:
  Moved the global read lock functionality into a
  class.
  Added MYSQL_OPEN_FORCE_SHARED_MDL flag which forces
  open_tables() to take MDL_SHARED on tables instead of
  metadata locks specified in the parser. We use this to
  allow PREPARE run concurrently in presence of
  LOCK TABLES ... WRITE.
  Added signature for find_table_for_mdl_ugprade().
sql/set_var.cc:
  Global read lock functionality has been
  moved into a class.
sql/sp_head.cc:
  When creating TABLE_LIST elements for prelocking or
  system tables set the type of request for metadata
  lock according to the operation that will be performed
  on the table.
sql/sql_base.cc:
  - Updated code to use the new MDL API.
  - In order to avoid locks starvation we take upgradable
    locks all at once. As result implicitly locked tables no
    longer get an upgradable lock. Consequently DDL and FLUSH
    TABLES for such tables is prohibited.
    find_write_locked_table() was replaced by
    find_table_for_mdl_upgrade() function.
    open_table() was adjusted to return TABLE instance with
    upgradable ticket when necessary.
  - We no longer wait for all locks on OT_WAIT back off
    action -- only on the lock that caused the wait
    conflict. Moreover, now we distinguish cases when we
    have to wait due to conflict in MDL and old version
    of table in TDC.
  - Upate mysql_notify_threads_having_share_locks()
    to only abort thr_lock.c waits of threads that
    have open HANDLERs, since lock conflicts with only
    these threads now can lead to deadlocks not detectable
    by the MDL deadlock detector.
  - Remove mysql_abort_transactions_with_shared_locks()
    which is no longer needed.
sql/sql_class.cc:
  Global read lock functionality has been moved into a class.
  Re-arranged code in THD::cleanup() to simplify assert.
sql/sql_class.h:
  Introduced class to incapsulate global read lock
  functionality.
  Now sentinel in MDL subsystem guards the global read lock
  as well as LOCK TABLES and HANDLER locks. Adjusted code
  accordingly.
sql/sql_db.cc:
  Global read lock functionality has been moved into a class.
sql/sql_delete.cc:
  We no longer acquire upgradable metadata locks on tables
  which are locked by LOCK TABLES implicitly. As result
  TRUNCATE TABLE is no longer allowed for such tables.
  Updated code to use the new MDL API.
sql/sql_handler.cc:
  Inform MDL_context about presence of open HANDLERs.
  Since HANLDERs break MDL protocol by acquiring table-level
  lock while holding only S metadata lock on a table MDL
  subsystem should take special care about such contexts (Now
  this is the only case when mysql_lock_abort() is used).
sql/sql_parse.cc:
  Global read lock functionality has been moved into a class.
  Do not take upgradable metadata locks when opening tables
  for CREATE TABLE SELECT as it is not necessary and limits
  concurrency.
  When initializing TABLE_LIST objects before adding them
  to the table list set the type of request for metadata lock
  according to the operation that will be performed on the
  table.
  We no longer acquire upgradable metadata locks on tables
  which are locked by LOCK TABLES implicitly. As result FLUSH
  TABLES is no longer allowed for such tables.
sql/sql_prepare.cc:
  Use MYSQL_OPEN_FORCE_SHARED_MDL flag when opening
  tables during PREPARE. This allows PREPARE to run
  concurrently in presence of LOCK TABLES ... WRITE.
sql/sql_rename.cc:
  Global read lock functionality has been moved into a class.
sql/sql_show.cc:
  Updated code to use the new MDL API.
sql/sql_table.cc:
  Global read lock functionality has been moved into a class.
  We no longer acquire upgradable metadata locks on tables
  which are locked by LOCK TABLES implicitly. As result DROP
  TABLE is no longer allowed for such tables.
  Updated code to use the new MDL API.
sql/sql_trigger.cc:
  Global read lock functionality has been moved into a class.
  We no longer acquire upgradable metadata locks on tables
  which are locked by LOCK TABLES implicitly. As result
  CREATE/DROP TRIGGER is no longer allowed for such tables.
  Updated code to use the new MDL API.
sql/sql_view.cc:
  Global read lock functionality has been moved into a class.
  Fixed results of wrong merge that led to misuse of GLR API.
  CREATE VIEW statement is not a commit statement.
sql/table.cc:
  When resetting TABLE_LIST objects for PS or SP re-execution
  set the type of request for metadata lock according to the
  operation that will be performed on the table. Do the same
  in auxiliary function initializing metadata lock requests
  in a table list.
sql/table.h:
  When initializing TABLE_LIST objects set the type of request
  for metadata lock according to the operation that will be
  performed on the table.
sql/transaction.cc:
  Global read lock functionality has been moved into a class.

1 files changed, 301 insertions, 83 deletions

diff --git a/sql/mdl.h b/sql/mdl.h
index 3ae7cdc743d..848c446496f 100644
--- a/sql/mdl.h
+++ b/sql/mdl.h
@@ -26,28 +26,121 @@ class THD;
 class MDL_context;
 class MDL_lock;
 class MDL_ticket;
+class Deadlock_detection_context;
 
 /**
   Type of metadata lock request.
 
-  - High-priority shared locks differ from ordinary shared locks by
-    that they ignore pending requests for exclusive locks.
-  - Upgradable shared locks can be later upgraded to exclusive
-    (because of that their acquisition involves implicit
-     acquisition of global intention-exclusive lock).
-
   @sa Comments for MDL_object_lock::can_grant_lock() and
-  MDL_global_lock::can_grant_lock() for details.
+      MDL_global_lock::can_grant_lock() for details.
 */
 
-enum enum_mdl_type {MDL_SHARED=0, MDL_SHARED_HIGH_PRIO,
-                    MDL_SHARED_UPGRADABLE, MDL_INTENTION_EXCLUSIVE,
-                    MDL_EXCLUSIVE};
-
-
-/** States which a metadata lock ticket can have. */
+enum enum_mdl_type {
+  /*
+    An intention exclusive metadata lock. Used only for global locks.
+    Owner of this type of lock can acquire upgradable exclusive locks on
+    individual objects.
+    Compatible with other IX locks, but is incompatible with global S lock.
+  */
+  MDL_INTENTION_EXCLUSIVE= 0,
+  /*
+    A shared metadata lock.
+    To be used in cases when we are interested in object metadata only
+    and there is no intention to access object data (e.g. for stored
+    routines or during preparing prepared statements).
+    We also mis-use this type of lock for open HANDLERs, since lock
+    acquired by this statement has to be compatible with lock acquired
+    by LOCK TABLES ... WRITE statement, i.e. SNRW (We can't get by by
+    acquiring S lock at HANDLER ... OPEN time and upgrading it to SR
+    lock for HANDLER ... READ as it doesn't solve problem with need
+    to abort DML statements which wait on table level lock while having
+    open HANDLER in the same connection).
+    To avoid deadlock which may occur when SNRW lock is being upgraded to
+    X lock for table on which there is an active S lock which is owned by
+    thread which waits in its turn for table-level lock owned by thread
+    performing upgrade we have to use thr_abort_locks_for_thread()
+    facility in such situation.
+    This problem does not arise for locks on stored routines as we don't
+    use SNRW locks for them. It also does not arise when S locks are used
+    during PREPARE calls as table-level locks are not acquired in this
+    case.
+  */
+  MDL_SHARED,
+  /*
+    A high priority shared metadata lock.
+    Used for cases when there is no intention to access object data (i.e.
+    data in the table).
+    "High priority" means that, unlike other shared locks, it is granted
+    ignoring pending requests for exclusive locks. Intended for use in
+    cases when we only need to access metadata and not data, e.g. when
+    filling an INFORMATION_SCHEMA table.
+    Since SH lock is compatible with SNRW lock, the connection that
+    holds SH lock lock should not try to acquire any kind of table-level
+    or row-level lock, as this can lead to a deadlock. Moreover, after
+    acquiring SH lock, the connection should not wait for any other
+    resource, as it might cause starvation for X locks and a potential
+    deadlock during upgrade of SNW or SNRW to X lock (e.g. if the
+    upgrading connection holds the resource that is being waited for).
+  */
+  MDL_SHARED_HIGH_PRIO,
+  /*
+    A shared metadata lock for cases when there is an intention to read data
+    from table.
+    A connection holding this kind of lock can read table metadata and read
+    table data (after acquiring appropriate table and row-level locks).
+    This means that one can only acquire TL_READ, TL_READ_NO_INSERT, and
+    similar table-level locks on table if one holds SR MDL lock on it.
+    To be used for tables in SELECTs, subqueries, and LOCK TABLE ...  READ
+    statements.
+  */
+  MDL_SHARED_READ,
+  /*
+    A shared metadata lock for cases when there is an intention to modify
+    (and not just read) data in the table.
+    A connection holding SW lock can read table metadata and modify or read
+    table data (after acquiring appropriate table and row-level locks).
+    To be used for tables to be modified by INSERT, UPDATE, DELETE
+    statements, but not LOCK TABLE ... WRITE or DDL). Also taken by
+    SELECT ... FOR UPDATE.
+  */
+  MDL_SHARED_WRITE,
+  /*
+    An upgradable shared metadata lock which blocks all attempts to update
+    table data, allowing reads.
+    A connection holding this kind of lock can read table metadata and read
+    table data.
+    Can be upgraded to X metadata lock.
+    Note, that since this type of lock is not compatible with SNRW or SW
+    lock types, acquiring appropriate engine-level locks for reading
+    (TL_READ* for MyISAM, shared row locks in InnoDB) should be
+    contention-free.
+    To be used for the first phase of ALTER TABLE, when copying data between
+    tables, to allow concurrent SELECTs from the table, but not UPDATEs.
+  */
+  MDL_SHARED_NO_WRITE,
+  /*
+    An upgradable shared metadata lock which allows other connections
+    to access table metadata, but not data.
+    It blocks all attempts to read or update table data, while allowing
+    INFORMATION_SCHEMA and SHOW queries.
+    A connection holding this kind of lock can read table metadata modify and
+    read table data.
+    Can be upgraded to X metadata lock.
+    To be used for LOCK TABLES WRITE statement.
+    Not compatible with any other lock type except S and SH.
+  */
+  MDL_SHARED_NO_READ_WRITE,
+  /*
+    An exclusive metadata lock.
+    A connection holding this lock can modify both table's metadata and data.
+    No other type of metadata lock can be granted while this lock is held.
+    To be used for CREATE/DROP/RENAME TABLE statements and for execution of
+    certain phases of other DDL statements.
+  */
+  MDL_EXCLUSIVE,
+  /* This should be the last !!! */
+  MDL_TYPE_END};
 
-enum enum_mdl_state { MDL_PENDING, MDL_ACQUIRED };
 
 /** Maximal length of key for metadata locking subsystem. */
 #define MAX_MDLKEY_LENGTH (1 + NAME_LEN + 1 + NAME_LEN + 1)
@@ -77,11 +170,11 @@ public:
     it's necessary to have a separate namespace for them since
     MDL_key is also used outside of the MDL subsystem.
   */
-  enum enum_mdl_namespace { TABLE=0,
+  enum enum_mdl_namespace { GLOBAL=0,
+                            TABLE,
                             FUNCTION,
                             PROCEDURE,
-                            TRIGGER,
-                            GLOBAL };
+                            TRIGGER };
 
   const uchar *ptr() const { return (uchar*) m_ptr; }
   uint length() const { return m_length; }
@@ -217,7 +310,7 @@ public:
     DBUG_ASSERT(ticket == NULL);
     type= type_arg;
   }
-  bool is_shared() const { return type < MDL_INTENTION_EXCLUSIVE; }
+  uint get_deadlock_weight() const;
 
   static MDL_request *create(MDL_key::enum_mdl_namespace mdl_namespace,
                              const char *db, const char *name,
@@ -297,21 +390,25 @@ public:
   void set_cached_object(void *cached_object,
                          mdl_cached_object_release_hook release_hook);
   MDL_context *get_ctx() const { return m_ctx; }
-  bool is_shared() const { return m_type < MDL_INTENTION_EXCLUSIVE; }
   bool is_upgradable_or_exclusive() const
   {
-    return m_type == MDL_SHARED_UPGRADABLE || m_type == MDL_EXCLUSIVE;
+    return m_type == MDL_SHARED_NO_WRITE ||
+           m_type == MDL_SHARED_NO_READ_WRITE ||
+           m_type == MDL_EXCLUSIVE;
   }
-  bool upgrade_shared_lock_to_exclusive();
-  void downgrade_exclusive_lock();
+  enum_mdl_type get_type() const { return m_type; }
+  void downgrade_exclusive_lock(enum_mdl_type type);
+
+  bool has_stronger_or_equal_type(enum_mdl_type type) const;
+
+  bool is_incompatible_when_granted(enum_mdl_type type) const;
+  bool is_incompatible_when_waiting(enum_mdl_type type) const;
+
 private:
   friend class MDL_context;
-  friend class MDL_global_lock;
-  friend class MDL_object_lock;
 
   MDL_ticket(MDL_context *ctx_arg, enum_mdl_type type_arg)
    : m_type(type_arg),
-     m_state(MDL_PENDING),
      m_ctx(ctx_arg),
      m_lock(NULL)
   {}
@@ -321,9 +418,6 @@ private:
 private:
   /** Type of metadata lock. Externally accessible. */
   enum enum_mdl_type m_type;
-  /** State of the metadata lock ticket. Context private. */
-  enum enum_mdl_state m_state;
-
   /**
     Context of the owner of the metadata lock ticket. Externally accessible.
   */
@@ -331,6 +425,7 @@ private:
 
   /** Pointer to the lock object for this lock ticket. Context private. */
   MDL_lock *m_lock;
+
 private:
   MDL_ticket(const MDL_ticket &);               /* not implemented */
   MDL_ticket &operator=(const MDL_ticket &);    /* not implemented */
@@ -359,26 +454,29 @@ public:
 
   typedef Ticket_list::Iterator Ticket_iterator;
 
+  enum mdl_signal_type { NO_WAKE_UP = 0,
+                         NORMAL_WAKE_UP,
+                         VICTIM_WAKE_UP,
+                         TIMEOUT_WAKE_UP };
+
   MDL_context();
   void destroy();
 
-  bool try_acquire_shared_lock(MDL_request *mdl_request);
-  bool acquire_exclusive_lock(MDL_request *mdl_request);
-  bool acquire_exclusive_locks(MDL_request_list *requests);
-  bool try_acquire_exclusive_lock(MDL_request *mdl_request);
+  bool try_acquire_lock(MDL_request *mdl_request);
+  bool acquire_lock(MDL_request *mdl_request);
+  bool acquire_locks(MDL_request_list *requests);
+  bool upgrade_shared_lock_to_exclusive(MDL_ticket *mdl_ticket);
+
   bool clone_ticket(MDL_request *mdl_request);
 
-  bool wait_for_locks(MDL_request_list *requests);
+  bool wait_for_lock(MDL_request *mdl_request);
 
   void release_all_locks_for_name(MDL_ticket *ticket);
   void release_lock(MDL_ticket *ticket);
 
-  bool is_exclusive_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
-                               const char *db,
-                               const char *name);
   bool is_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
-                     const char *db, const char *name);
-
+                     const char *db, const char *name,
+                     enum_mdl_type mdl_type);
 
   bool has_lock(MDL_ticket *mdl_savepoint, MDL_ticket *mdl_ticket);
 
@@ -391,88 +489,208 @@ public:
   {
     /*
       NULL savepoint represents the start of the transaction.
-      Checking for m_lt_or_ha_sentinel also makes sure we never
+      Checking for m_trans_sentinel also makes sure we never
       return a pointer to HANDLER ticket as a savepoint.
     */
-    return m_tickets.front() == m_lt_or_ha_sentinel ? NULL : m_tickets.front();
+    return m_tickets.front() == m_trans_sentinel ? NULL : m_tickets.front();
   }
 
-  void set_lt_or_ha_sentinel()
+  void set_trans_sentinel()
   {
-    m_lt_or_ha_sentinel= mdl_savepoint();
+    m_trans_sentinel= mdl_savepoint();
   }
-  MDL_ticket *lt_or_ha_sentinel() const { return m_lt_or_ha_sentinel; }
+  MDL_ticket *trans_sentinel() const { return m_trans_sentinel; }
 
-  void clear_lt_or_ha_sentinel()
+  void reset_trans_sentinel(MDL_ticket *sentinel_arg)
   {
-    m_lt_or_ha_sentinel= NULL;
+    m_trans_sentinel= sentinel_arg;
   }
-  void move_ticket_after_lt_or_ha_sentinel(MDL_ticket *mdl_ticket);
+  void move_ticket_after_trans_sentinel(MDL_ticket *mdl_ticket);
 
   void release_transactional_locks();
   void rollback_to_savepoint(MDL_ticket *mdl_savepoint);
 
-  bool can_wait_lead_to_deadlock() const;
-
   inline THD *get_thd() const { return m_thd; }
 
+  bool acquire_global_intention_exclusive_lock(MDL_request *mdl_request);
+
   /**
     Wake up context which is waiting for a change of MDL_lock state.
   */
-  void awake()
+  void awake(mdl_signal_type signal)
   {
-    pthread_cond_signal(&m_ctx_wakeup_cond);
+    pthread_mutex_lock(&m_signal_lock);
+    m_signal= signal;
+    pthread_cond_signal(&m_signal_cond);
+    pthread_mutex_unlock(&m_signal_lock);
   }
 
-  bool try_acquire_global_intention_exclusive_lock(MDL_request *mdl_request);
-  bool acquire_global_intention_exclusive_lock(MDL_request *mdl_request);
-
-  bool acquire_global_shared_lock();
-  void release_global_shared_lock();
+  void init(THD *thd_arg) { m_thd= thd_arg; }
 
-  /**
-    Check if this context owns global lock of particular type.
-  */
-  bool is_global_lock_owner(enum_mdl_type type_arg)
+  void set_needs_thr_lock_abort(bool needs_thr_lock_abort)
   {
-    MDL_request mdl_request;
-    bool not_used;
-    mdl_request.init(MDL_key::GLOBAL, "", "", type_arg);
-    return find_ticket(&mdl_request, &not_used);
+    /*
+      @note In theory, this member should be modified under protection
+            of some lock since it can be accessed from different threads.
+            In practice, this is not necessary as code which reads this
+            value and so might miss the fact that value was changed will
+            always re-try reading it after small timeout and therefore
+            will see the new value eventually.
+    */
+    m_needs_thr_lock_abort= TRUE;
+  }
+  bool get_needs_thr_lock_abort() const
+  {
+    return m_needs_thr_lock_abort;
   }
 
-  void init(THD *thd_arg) { m_thd= thd_arg; }
+  bool find_deadlock(Deadlock_detection_context *deadlock_ctx);
 private:
+  /**
+    All MDL tickets acquired by this connection.
+
+    The order of tickets in m_tickets list.
+    ---------------------------------------
+    The entire set of locks acquired by a connection
+    can be separated in two subsets: transactional and
+    non-transactional locks.
+
+    Transactional locks are locks with automatic scope. They
+    are accumulated in the course of a transaction, and
+    released only on COMMIT, ROLLBACK or ROLLBACK TO SAVEPOINT.
+    They must not be (and never are) released manually,
+    i.e. with release_lock() call.
+
+    Non-transactional locks are taken for locks that span
+    multiple transactions or savepoints.
+    These are: HANDLER SQL locks (HANDLER SQL is
+    transaction-agnostic), LOCK TABLES locks (you can COMMIT/etc
+    under LOCK TABLES, and the locked tables stay locked), and
+    SET GLOBAL READ_ONLY=1 global shared lock.
+
+    Transactional locks are always prepended to the beginning
+    of the list. In other words, they are stored in reverse
+    temporal order. Thus, when we rollback to a savepoint,
+    we start popping and releasing tickets from the front
+    until we reach the last ticket acquired after the
+    savepoint.
+
+    Non-transactional locks are always stored after
+    transactional ones, and among each other can be
+    split into three sets:
+
+    [LOCK TABLES locks] [HANDLER locks] [GLOBAL READ LOCK locks]
+
+    The following is known about these sets:
+
+    * we can never have both HANDLER and LOCK TABLES locks
+      together -- HANDLER statements are prohibited under LOCK
+      TABLES, entering LOCK TABLES implicitly closes all open
+      HANDLERs.
+    * GLOBAL READ LOCK locks are always stored after LOCK TABLES
+      locks and after HANDLER locks. This is because one can't say
+      SET GLOBAL read_only=1 or FLUSH TABLES WITH READ LOCK
+      if one has locked tables. One can, however, LOCK TABLES
+      after having entered the read only mode. Note, that
+      subsequent LOCK TABLES statement will unlock the previous
+      set of tables, but not the GRL!
+      There are no HANDLER locks after GRL locks because
+      SET GLOBAL read_only performs a FLUSH TABLES WITH
+      READ LOCK internally, and FLUSH TABLES, in turn, implicitly
+      closes all open HANDLERs.
+      However, one can open a few HANDLERs after entering the
+      read only mode.
+  */
   Ticket_list m_tickets;
   /**
-    This member has two uses:
-    1) When entering LOCK TABLES mode, remember the last taken
-    metadata lock. COMMIT/ROLLBACK must preserve these metadata
-    locks.
-    2) When we have an open HANDLER tables, store the position
-    in the list beyond which we keep locks for HANDLER tables.
-    COMMIT/ROLLBACK must, again, preserve HANDLER metadata locks.
+    Separates transactional and non-transactional locks
+    in m_tickets list, @sa m_tickets.
   */
-  MDL_ticket *m_lt_or_ha_sentinel;
+  MDL_ticket *m_trans_sentinel;
   THD *m_thd;
   /**
+    TRUE -  if for this context we will break protocol and try to
+            acquire table-level locks while having only S lock on
+            some table.
+            To avoid deadlocks which might occur during concurrent
+            upgrade of SNRW lock on such object to X lock we have to
+            abort waits for table-level locks for such connections.
+    FALSE - Otherwise.
+  */
+  bool m_needs_thr_lock_abort;
+
+  /**
+    Read-write lock protecting m_waiting_for member.
+
+    TODO/FIXME: Replace with RW-lock which will prefer readers
+                on all platforms and not only on Linux.
+  */
+  rw_lock_t m_waiting_for_lock;
+  MDL_ticket *m_waiting_for;
+  uint m_deadlock_weight;
+  /**
     Condvar which is used for waiting until this context's pending
     request can be satisfied or this thread has to perform actions
-    to resolve potential deadlock (we subscribe for such notification
-    by adding ticket corresponding to the request to an appropriate
-    queue of waiters).
+    to resolve a potential deadlock (we subscribe to such
+    notification by adding a ticket corresponding to the request
+    to an appropriate queue of waiters).
   */
-  pthread_cond_t m_ctx_wakeup_cond;
+  pthread_mutex_t m_signal_lock;
+  pthread_cond_t m_signal_cond;
+  mdl_signal_type m_signal;
+
 private:
   MDL_ticket *find_ticket(MDL_request *mdl_req,
-                          bool *is_lt_or_ha);
+                          bool *is_transactional);
   void release_locks_stored_before(MDL_ticket *sentinel);
-
-  bool try_acquire_lock_impl(MDL_request *mdl_request);
   bool acquire_lock_impl(MDL_request *mdl_request);
-  bool acquire_exclusive_lock_impl(MDL_request *mdl_request);
 
-  friend bool MDL_ticket::upgrade_shared_lock_to_exclusive();
+  bool find_deadlock();
+
+  void will_wait_for(MDL_ticket *pending_ticket)
+  {
+    rw_wrlock(&m_waiting_for_lock);
+    m_waiting_for= pending_ticket;
+    rw_unlock(&m_waiting_for_lock);
+  }
+
+  void set_deadlock_weight(uint weight)
+  {
+    /*
+      m_deadlock_weight should not be modified while m_waiting_for is
+      non-NULL as in this case this context might participate in deadlock
+      and so m_deadlock_weight can be accessed from other threads.
+    */
+    DBUG_ASSERT(m_waiting_for == NULL);
+    m_deadlock_weight= weight;
+  }
+
+  void stop_waiting()
+  {
+    rw_wrlock(&m_waiting_for_lock);
+    m_waiting_for= NULL;
+    rw_unlock(&m_waiting_for_lock);
+  }
+
+  void wait_reset()
+  {
+    pthread_mutex_lock(&m_signal_lock);
+    m_signal= NO_WAKE_UP;
+    pthread_mutex_unlock(&m_signal_lock);
+  }
+
+  mdl_signal_type wait();
+  mdl_signal_type timed_wait(ulong timeout);
+
+  mdl_signal_type peek_signal()
+  {
+    mdl_signal_type result;
+    pthread_mutex_lock(&m_signal_lock);
+    result= m_signal;
+    pthread_mutex_unlock(&m_signal_lock);
+    return result;
+  }
+
 private:
   MDL_context(const MDL_context &rhs);          /* not implemented */
   MDL_context &operator=(MDL_context &rhs);     /* not implemented */
@@ -487,9 +705,9 @@ void mdl_destroy();
   Functions in the server's kernel used by metadata locking subsystem.
 */
 
-extern bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use);
+extern bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use,
+                                                   bool needs_thr_lock_abort);
 extern void mysql_ha_flush(THD *thd);
-extern void mysql_abort_transactions_with_shared_lock(const MDL_key *mdl_key);
 extern "C" const char *set_thd_proc_info(THD *thd, const char *info,
                                          const char *calling_function,
                                          const char *calling_file,