Bug #46272 New MDL: unnecessary deadlock
Submitted: 17 Jul 2009 17:54 Modified: 7 Mar 2010 2:07
Reporter: Konstantin Osipov (OCA) Email Updates:
Status: Closed Impact on me:
None 
Category:MySQL Server: Locking Severity:S3 (Non-critical)
Version:6.0-codebase OS:Any
Assigned to: Dmitry Lenev CPU Architecture:Any
Tags: regression
Triage: Triaged: D2 (Serious) / R2 (Low) / E3 (Medium)

[17 Jul 2009 17:54] Konstantin Osipov
Description:
When trying to alter a table used in a transaction, the transaction gets an unnecessary ER_LOCK_DEADLOCK error.

Example:

mysql> create table t1 (c1 int primary key, c2 int, c3 int) engine=myisam;
Query OK, 0 rows affected (0.07 sec)

mysql> insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0);
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> update t1 set c3=c3+1 where c2=3;                                        Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Switch to another connection:

mysql> alter table t1 engine=innodb;

(Correctly waits for the pending transaction to commit or rollback).

Switch back to the original connection:

mysql> update t1 set c3=c3+1 where c2=4;
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

Note, that the first connection's only option is to rollback now.
This shouldn't be the case.

Compare with drop table:

(Switch to the second connection):

mysql> drop table t1;

(Correctly waits till the first connection commits or rolls back).

(Switch to the first connection):

mysql> update t1 set c3=c3+1 where c2=4;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> commit;
Query OK, 0 rows affected (0.08 sec)

(Proceeds successfully till commit, after which the second connection
proceeds as well).

How to repeat:
--disable_warnings
drop table if exists t1;
--enable_warnings
connect (con1,localhost,root,,test,,);

connection default;
create table t1 (c1 int primary key, c2 int, c3 int) engine=myisam;
insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0);
set autocommit=0;
begin;
update t1 set c3=c3+1 where c2=3;

connection con1;
send alter table t1 add column e int;

connection default;
sleep 3;
--error ER_LOCK_DEADLOCK
update t1 set c3=c3+1 where c2=4;
rollback;

connection con1;
reap;

connection default;
disconnect con1;
drop table t1;

Suggested fix:
ALTER should work the same way as DROP, and not abort transactions unnecessarily.
To see DROP behaviour, change ALTER to DROP in the test.
[18 Jul 2009 12:20] Valeriy Kravchuk
Thank you for the bug report. Verified just as described:

openxs@suse:/home2/openxs/dbs/azalea/mysql-test> ./mysql-test-run.pl bug46272
Logging: ./mysql-test-run.pl  bug46272
091023 22:41:04 [Note] Plugin 'FEDERATED' is disabled.
091023 22:41:04 [Note] Plugin 'ndbcluster' is disabled.
091023 22:41:04 [Warning] Forcing shutdown of 2 plugins
MySQL Version 5.4.4
Checking supported features...
 - using ndbcluster when necessary, mysqld supports it
 - SSL connections supported
 - binaries are debug compiled
Collecting tests...
vardir: /home2/openxs/dbs/azalea/mysql-test/var
Removing old var directory...
Creating var directory '/home2/openxs/dbs/azalea/mysql-test/var'...
Installing system database...
Using server port 32769
worker[1] Using MTR_BUILD_THREAD 300, with reserved ports 13000..13009

==============================================================================

TEST                                      RESULT   TIME (ms)
------------------------------------------------------------

main.bug46272                            [ fail ]
        Test ended at 2009-10-23 22:41:15

CURRENT_TEST: main.bug46272
--- /home2/openxs/dbs/azalea/mysql-test/r/bug46272.result       2009-10-23 22:40:46.000000000 +0300
+++ /home2/openxs/dbs/azalea/mysql-test/r/bug46272.reject       2009-10-23 22:41:15.000000000 +0300
@@ -0,0 +1,13 @@
+drop table if exists t1;
+create table t1 (c1 int primary key, c2 int, c3 int) engine=myisam;
+insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0);
+set autocommit=0;
+begin;
+update t1 set c3=c3+1 where c2=3;
+alter table t1 add column e int;
+update t1 set c3=c3+1 where c2=4;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+Warnings:
+Warning        1196    Some non-transactional changed tables couldn't be rolled back
+drop table t1;

mysqltest: Result length mismatch
...
[18 Jul 2009 12:24] Valeriy Kravchuk
We do not have deadlock in 5.1.38, so this is a regression.
[20 Jul 2009 7:31] Konstantin Osipov
Valeriy, careful, more deadlocks - is a documented incompatible change of WL#4284.
E.g. if one tried to use table t2 in connection 1, which was being altered by connection 2, a deadlock error would have been a documented result.
But using the table that was already used in a transaction should be allowed, this is why it's a bug.
[27 Aug 2009 9:19] Jon Olav Hauglid
Test case using sync points:

--source include/have_debug_sync.inc

--echo #
--echo # Bug#46272 MySQL 5.4.4, new MDL: unnecessary deadlock
--echo #

--disable_warnings
drop table if exists t1;
--enable_warnings

CREATE TABLE t1 (c1 INT PRIMARY KEY, c2 INT, c3 INT);
INSERT INTO t1 VALUES (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0);
connect (con1,localhost,root,,test,,);

--echo # Connection 1
connection default;
SET autocommit=0;
BEGIN;
UPDATE t1 SET c3=c3+1 WHERE c2=3;

--echo # Connection 2
connection con1;
SET DEBUG_SYNC= 'mdl_upgrade_shared_lock_to_exclusive_wait SIGNAL lock_wait';
--send ALTER TABLE t1 ADD COLUMN e INT

--echo # Connection 1
connection default;
SET DEBUG_SYNC= 'now WAIT_FOR lock_wait';
--error ER_LOCK_DEADLOCK
UPDATE t1 SET c3=c3+1 WHERE c2=4;
ROLLBACK;

connection con1;
reap;

connection default;
disconnect con1;
DROP TABLE t1;
SET DEBUG_SYNC= 'RESET';
[27 Aug 2009 10:58] Jon Olav Hauglid
ALTER TABLE calls wait_while_table_is_used() which sets TABLE_SHARE's version = 0.
This happens before ALTER TABLE starts waiting for the shared lock to disappear inside upgrade_shared_lock_to_exclusive().

The following UPDATE will notice that share->version now is different from  refresh_version and call Open_table_context::request_backoff_action() which triggers the DEADLOCK error.
[28 Aug 2009 8:57] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/81810

2803 Jon Olav Hauglid	2009-08-28
      Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock
      
      The problem was that ALTER TABLE calls wait_while_table_is_used() 
      which set TABLE_SHARE's version = 0. This happened before 
      ALTER TABLE starts waiting for the shared lock to disappear inside
      upgrade_shared_lock_to_exclusive(). The following UPDATE noticed 
      that share->version now was different from refresh_version and 
      called Open_table_context::request_backoff_action() which 
      triggered the DEADLOCK error.
      
      This patch removes the setting of TABLE_SHARE's version to 0 
      inside wait_while_table_is_used(), since this anyway will 
      be done by close_all_tables_for_name() which is called right
      after the return from wait_while_table_is_used().
      
      Test case added to mdl_sync.test.
[21 Dec 2009 14:12] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/95248

3628 Dmitry Lenev	2009-12-21
      Tentative patch implementing new type-of-operation-aware metadata locks.
      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 has manifested itself as unwarranted abort of transaction
      with ER_LOCK_DEADLOCK error in cases when transaction tried to use table
      being currently altered even although the same transaction has already
      used the same table in the same fashion.
      
      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. The deadlock occured when ALTER TABLE
      tried to change table which was already updated by some transaction
      (and on which this transaction held X row-lock) and so had to wait for
      this transaction to complete while holding table-level lock preventing
      further updates on the table even those which were coming from the
      the transaction for which it was waiting.
      
      Both these bugs stemmed from inadequate solutions to problem of
      deadlocks occuring between different 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, and aborted transactions holding
      shared lock on table and waiting for some table-level lock too
      eagerly. We also allowed ALTER TABLE to proceed and acquire
      TL_WRITE_ALLOW_READ lock in cases when there were some transactions
      which already managed to update table which inevitably led to
      necessity to abort such transactions once they tried to perform
      yet another update on the table.
      
      The second bug occurred simply because we didn't have any means to
      handle deadlocks between table-level in the core server and row-level
      locks in InnoDB other than timeout.
      
      This patch tries to solve both this problems by moving all conflicts
      which are causing these deadlocks into metadata locking subsystem,
      thus making it possible to avoid or detect such deadlocks by its
      means.
      
      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 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 addition of special kind of upgradable metadata lock,
      allows ALTER TABLE to wait before doing anything else until all
      transactions which has updated the table go away. This solves the
      the second issue.
      And along with addition of special kind of upgradable metadata lock
      to be acquired by LOCK TABLES WRITE it allows to solve the first issue
      as well, since aborting of table-level locks becomes unnecessary (see
      comment for sql/sql_base.cc for detailed explanation).
      
      Here are the list of incompatible changes introduced by this patch:
      
      - Now ALTER TABLE and CREATE/DROP TRIGGER statements (i.e. those
        which acquire TL_WRITE_ALLOW_READ lock) before doing anything
        else wait until all transactions which has updated the table
        being changed complete.
      - LOCK TABLES ... WRITE, REPAIR/OPTIMIZE TABLE (i.e. all statements
        which acquire upgradable metadata lock and TL_WRITE table-level
        lock) now wait before doing anything else untill all transactions
        which somehow used table to be locked or changed complete.
        As a consequence innodb_table_locks=0 option no longer applies
        to LOCK TABLES ... WRITE.
      - DROP TABLES/DATABASE and RENAME TABLE no longer abort statements
        or transactions which use tables being changed and are waiting for
        some table-level locks.
      - Transactions which try to change some table for the first time or
        use some table for the first time may fail with ER_LOCK_DEADLOCK
        error if there is a concurrent LOCK TABLES ... WRITE statement
        for this table and transaction is likely to create deadlock by
        waiting for it to go away (note that unlike before this also
        applies to transactions involving non-InnoDB tables or even
        using only non-InnoDB tables).
      - Finally, this patch temporarily disables support of LOW_PRIORITY
        option for LOCK TABLES ... WRITE.
      
      As usual questions for reviewer are marked by QQ.
     @ mysql-test/include/handler.inc
        Adjusted test case to trigger 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.
     @ mysql-test/include/locktrans.inc
        Adjusted test case to take into account facts:
        - that now waiting for table locked by LOCK TABLES ... WRITE happens
          within metadata locking subsystem and therefore different status is
          shown in I_S.PROCESSLIST in this case.
        - that now LOCK TABLES ... WRITE has to wait until transactions using
          the table being locked are commited or rolled back.
        Also temporarily disabled part of the test which uses LOCK TABLES ...
        LOW_PRIORITY WRITE - feature which is not yet supported by this
        version of this patch.
     @ mysql-test/r/events_2.result
        Disabled part of the test which started to cause deadlocks after
        changing LOCK TABLES WRITE to be a metadata level lock. We need
        to make decision how to handle such situation.
     @ mysql-test/r/handler_innodb.result
        Adjusted test case to trigger 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.
     @ mysql-test/r/handler_myisam.result
        Adjusted test case to trigger 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.
     @ mysql-test/r/innodb-lock.result
        Disabled part of test case which uses innodb_table_locks=0 option.
        It is unlikely that we will be able to support this option with
        LOCK TABLES ... WRITE implemented on metadata locking level.
     @ mysql-test/r/innodb_mysql_lock.result
        Added test for bug #37346 "innodb does not detect deadlock between
        update and alter table".
     @ mysql-test/r/lock_multi.result
        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 metadata locking subsystem.
     @ mysql-test/r/locktrans_innodb.result
        Adjusted test case to take into account fact that now LOCK TABLES ...
        WRITE has to wait until transactions using the table being locked are
        commited or rolled back.
        Also temporarily disabled part of the test which uses LOCK TABLES ...
        LOW_PRIORITY WRITE - feature which is not yet supported by this
        version of this patch.
     @ mysql-test/r/locktrans_myisam.result
        Adjusted test case to take into account fact that now LOCK TABLES ...
        WRITE has to wait until transactions using the table being locked are
        commited or rolled back.
        Also temporarily disabled part of the test which uses LOCK TABLES ...
        LOW_PRIORITY WRITE - feature which is not yet supported by this
        version of this patch.
     @ mysql-test/r/mdl_sync.result
        Added basic test coverage for type-of-operation aware metadata locks.
        Also covered with tests some use cases involving HANDLER statements
        in which deadlock might have arisen.
     @ mysql-test/r/merge-sync.result
        Use LOCK TABLES READ instead of LOCK TABLES WRITE in order to trigger
        the same execution patch as before.
     @ mysql-test/r/sp-threads.result
        SHOW PROCESSLIST has changed due to fact that waiting for LOCK TABLES
        WRITE now happens within metadata locking subsystem.
     @ mysql-test/r/truncate_coverage.result
        Adjusted test case after making LOCK TABLES WRITE to wait until
        transactions using the table to be locked are completed.
     @ mysql-test/suite/rpl/r/rpl_locktrans_innodb.result
        Adjusted test case to take into account fact that now LOCK TABLES ...
        WRITE has to wait until transactions using the table being locked are
        commited or rolled back.
        Also temporarily disabled part of the test which uses LOCK TABLES ...
        LOW_PRIORITY WRITE - feature which is not yet supported by this
        version of this patch.
     @ mysql-test/suite/rpl/r/rpl_locktrans_myisam.result
        Adjusted test case to take into account fact that now LOCK TABLES ...
        WRITE has to wait until transactions using the table being locked are
        commited or rolled back.
        Also temporarily disabled part of the test which uses LOCK TABLES ...
        LOW_PRIORITY WRITE - feature which is not yet supported by this
        version of this patch.
     @ mysql-test/t/events_2.test
        Disabled part of the test which started to cause deadlocks after
        changing LOCK TABLES WRITE to be a metadata level lock. We need
        to make decision how to handle such situation.
     @ mysql-test/t/innodb-lock.test
        Disabled part of test case which uses innodb_table_locks=0 option.
        It is unlikely that we will be able to support this option with
        LOCK TABLES ... WRITE implemented on metadata locking level.
     @ 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_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 metadata locking subsystem.
     @ 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 deadlock might have arisen.
     @ mysql-test/t/merge-sync.test
        Use LOCK TABLES READ instead of LOCK TABLES WRITE in order to trigger
        the same execution patch as before.
     @ mysql-test/t/multi_update.test
        Changed test case due to fact that waiting for LOCK TABLES WRITE now
        happens within metadata locking subsystem.
     @ mysql-test/t/truncate_coverage.test
        Adjusted test case after making LOCK TABLES WRITE to wait until
        transactions using the table to be locked are completed.
     @ 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. Added auxiliary methods to manipulate
          with those lists while keeping the rest of the MDL_lock's state
          in sync with their content.
        - Adjusted compatibility matrices which are implemented by
          MDL_global_lock::is_lock_type_compatible() and
          MDL_lock::can_grant_lock() methods.
        - Adjusted rest of MDL subsystem implementation to take into account
          new types of locks (e.g. to the fact that now we have two types of
          upgradable locks).
        - Removed call to mysql_abort_transactions_with_shared_lock() from
          MDL_ticket::upgrade_shared_lock_to_exclusive() since with advent
          of new locks deadlocks between deadlocks between table-level locks
          and MDL subsystem should not be possible (since thread which has
          managed to acquire metadata lock compatible with UNW, should be
          able to acquire table-level lock without waiting, and thread which
          has lock compatible with UNRW lock should not acquire table-level
          locks at all (S lock acquired by HANDLER statement being an
          exception, which is handled through aborts of table-level locks)).
     @ sql/mdl.h
        Introduced new type-of-operation-aware metadata locks.
        Added MDL_context::m_needs_thr_lock_abort flag to be able to
        distinguish contexts used for opening HANDLERs.
        Got rid of mysql_abort_transactions_with_shared_lock() function
        which became unnecessary with advent of new locks.
     @ sql/mysql_priv.h
        Added MYSQL_OPEN_FORCE_SHARED_MDL flag which forces open_tables() to
        take MDL_SHARED on tables instead of metadata locks specified in parser.
        We use this to allow PREPARE statements not to wait for LOCK TABLES ...
        WRITE on tables used in the prepared statements.
     @ sql/sp_head.cc
        When creating table list elements for prelocking or system tables set
        type of request for metadata lock according to the type of table-level
        lock which we are going to acquire and thus operation we are going to
        perform on the table.
     @ sql/sql_base.cc
        wait_while_table_is_used()/mysql_notify_thread_having_shared_lock():
          When upgrading metadata lock or acquiring an exclusive metadata lock
          we no longer abort threads which hold conflicting metadata lock and
          are waiting on table-level lock (in general case). Doing so led to
          aborts of transactions which were not causing deadlocks and should
          have continued their execution (see bug#46272).
          It became possible to remove these aborts without opening gap for
          deadlock situations after introduction of type-of-operation-aware
          metadata locks.
          Note that even before this change deadlock could have not arisen
          in cases when one tried to acquire X metadata lock, since in it
          all waiting happened within MDL subsystem and thus deadlocks were
          successfully detected and reported by our trivial, empiric-based
          deadlock detector.
          But this change helps to avoid deadlock in scenarios when shared
          metadata lock is upgraded to X lock.
          Particularly, in case when UNW lock is being upgraded there
          cannot be any threads waiting for thread performing upgrade due
          to table-level lock and therefore possible deadlocks limited to
          MDL subsystem and should be detected. This is because any thread
          which managed to acquire metadata lock compatible with UNW, i.e.
          SR lock, can request only read table-level locks which will be
          granted without any waiting (NB: this means that thread that
          acquires UNW locks should not mix them with any other kinds of
          metadata locks).
          In case when UNRW lock is upgraded to X lock, thread preventing
          upgrade can hold only S or SH types of lock on the table. The
          latter type is used only for filling of I_S tables during which
          no table-level locks are acquired so no deadlocks outside of MDL
          can occur. The former type is used in PREPARE statement which
          also does not aacquire table-level locks and by open HANDLERs
          for which we still abort table-level locks.
        open_table_get_mdl_lock():
          Adjusted code to the fact that now we have two kind of upgradable
          metadata locks which exact type is determined according to type of
          table-level lock to be acquired (for TL_WRITE table-level lock we
          acquire UNRW metadata lock and for TL_WRITE_ALLOW_READ we acquire
          UNW lock).
        open_tables():
          In order to avoid starvation pre-acquire upgradable metadata locks
          using acquire_exclusive_locks() method instead of acquiring them in
          one-by-one fashion using try_acquire_shared_lock().
        mysql_abort_transactions_with_shared_lock():
          We no longer need this function since after introduction
          of type-of-operation-aware metadata locks deadlocks between
          table-level locks and MDL subsystem should not be possible
          (since thread which has managed to acquire metadata lock
          compatible with UNW, should be able to acquire table-level
          lock without waiting, and thread which has lock compatible
          with UNRW lock should not acquire table-level locks at all
          (S lock acquired by HANDLER statement being an exception,
          which is handled through aborts of table-level locks)).
     @ sql/sql_class.h
        Mark MDL_context used for open HANDLERs as breaking metadata locking
        protocol and thus requiring aborting of waits on table-level locks.
     @ sql/sql_handler.cc
        Don't try flush HANDLERs for temporary tables. Such tables are not
        visible outside of this connection anyway. This is temporary fix
        which will go away once Kostja pushes his patch refactoring use
        of metadata locks for HANDLERs.
     @ sql/sql_parse.cc
        Don't take upgradable metadata locks when opening tables for
        CREATE TABLE ... SELECT statement. This is not needed until support
        for engine-agnostic foreign keys is implemented and creates problems
        with acquiring exclusive metadata lock on target table and with
        tables from SELECT part if FOR UPDATE clause is specified.
        When initializing metadata lock request for table list element set
        metadata lock type according to the type of table-level lock to be
        acquired and thus operation we are going to perform on the table.
     @ sql/sql_prepare.cc
        Use MYSQL_OPEN_FORCE_SHARED_MDL flag when calling open_tables() during
        PREPARE of prepared statement in order to not be blocked by concurrent
        LOCK TABLES WRITE.
     @ sql/sql_table.cc
        Don't take upgradable metadata locks when opening tables for
        CREATE TABLE statement. This is not needed until support for
        engine-agnostic foreign keys is implemented and creates problems
        with acquiring exclusive metadata lock on target table.
     @ sql/table.cc
        When initializing or resetting metadata lock request for table list
        element set metadata lock type according to the type of table-level
        lock to be acquired and thus operation we are going to perform on
        the table.
     @ sql/table.h
        When initializing metadata lock request for table list element set
        metadata lock type according to the type of table-level lock to be
        acquired and thus operation we are going to perform on the table.
[12 Jan 2010 19:37] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/96667

3049 Konstantin Osipov	2010-01-12
      A prerequisite patch for the fix for Bug#46272
      "Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock".
      Instead of a single global mutex that protects the MDL
      subsystem, use a mutex per one MDL lock.
      Commit the patch into the staging tree to be able to 
      use work on review comments.
[15 Jan 2010 21:57] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97165

3050 Dmitry Lenev	2010-01-16
      A prerequisite patch for the fix for Bug#46272
      "Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock".
      Instead of a single global mutex that protects the MDL
      subsystem, use a mutex per one MDL lock.
      
      Work on after review comments in progress.
[16 Jan 2010 9:27] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97173

3051 Dmitry Lenev	2010-01-16
      A prerequisite patch for the fix for Bug#46272
      "Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock".
      Instead of a single global mutex that protects the MDL
      subsystem, use a mutex per one MDL lock.
      
      Work on after review comments in progress.
      
      Reduce critical sections by moving context-private
      assignments out of them.
[18 Jan 2010 20:04] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97298

3052 Dmitry Lenev	2010-01-18
      A prerequisite patch for the fix for Bug#46272
      "Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock".
      Instead of a single global mutex that protects the MDL
      subsystem, use a mutex per one MDL lock.
      
      Work on after review comments in progress.
[19 Jan 2010 21:07] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97447

3054 Dmitry Lenev	2010-01-20
      A prerequisite patch for the fix for Bug#46272
      "Bug #46272 MySQL 5.4.4, new MDL: unnecessary deadlock".
      Instead of a single global mutex that protects the MDL
      subsystem, use a mutex per one MDL lock.
      
      Work on after review comments in progress.
      
      Implemented Mikael's idea with reference counting variables
      which ensure that we can release LOCK_mdl_hash mutex before
      acquiring MDL_lock::lock in performance critical code.
[20 Jan 2010 10:18] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97520

3057 Konstantin Osipov	2010-01-20
      Bug#46272/Bug#38924 review fixes in progress.
      Rename a few members, realign comments to fit 66 characters, 
      update comments.
[20 Jan 2010 10:42] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97529

3058 Konstantin Osipov	2010-01-20
      Bug#46272/Bug#38924 review fixes in progress.
      Update MDL_key class to be more compact.
      Simplify the comparison method, used when sorting MDL_keys.
[20 Jan 2010 11:20] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97535

3059 Konstantin Osipov	2010-01-20
      Bug#46272/Bug#38924 review fixes in progress.
      Misc fixes.
[20 Jan 2010 12:31] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97548

3060 Konstantin Osipov	2010-01-20
      Bug#46272/Bug#38924 review fixes in progress.
      Introduce class MDL_map to hold all MDL locks
      taken in the server.
[20 Jan 2010 13:44] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97578

3061 Konstantin Osipov	2010-01-20
      Bug#46272/Bug#38924 review fixes in progress.
      Misc. fixes.
[21 Jan 2010 8:35] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97687

3062 Konstantin Osipov	2010-01-21
      Apply the second patch for Bug#46272.
[21 Jan 2010 8:36] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97689

3062 Konstantin Osipov	2010-01-21
      Apply the second patch for Bug#46272.
[21 Jan 2010 16:11] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97746

3063 Konstantin Osipov	2010-01-21
      Bug#46272 review fixes: remove an unnecessary friend.
[21 Jan 2010 17:11] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97760

3064 Konstantin Osipov	2010-01-21
      Bug#46272, review comments, remove an unused friend.
[22 Jan 2010 5:57] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97795

3055 Dmitry Lenev	2010-01-22
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      Commit to the tree to be used for review work.
[22 Jan 2010 9:34] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97814

3063 Konstantin Osipov	2010-01-22
      Bug#46272 review fixes: remove an unnecessary friend.
      ******
      Bug#46272, review comments, remove an unused friend.
      ******
      Bug#46262 review comments: remove unnecessary friends.
      Bug#46272: change wait_for_locks() to wait for one lock only.
[22 Jan 2010 9:39] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97816

3056 Konstantin Osipov	2010-01-22
      Bug#46272, review comments: remove unnecessary friends, 
      change wait_for_locks() to wait_for_lock() (waits for
      only one lock).
[22 Jan 2010 11:54] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/97856

3057 Konstantin Osipov	2010-01-22
      Bug#46272, a review comment: update a waiting state in
      processlist_val_no_prot.test to reflect the new value.
[25 Jan 2010 12:45] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98052

3058 Dmitry Lenev	2010-01-25
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After review fixes in progress.
      
      Changed metadata locking code to use compatibility matrices specified
      through bitmaps rather than hard-coded by switch() statements.
[25 Jan 2010 17:35] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98106

3059 Dmitry Lenev	2010-01-25
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After review fixes in progress.
      
      Changed metadata locking code to use compatibility matrices specified
      through bitmaps rather than hard-coded by switch() statements.
[25 Jan 2010 20:29] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98119

3059 Dmitry Lenev	2010-01-25
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After review fixes in progress.
      
      Changed metadata locking code to use compatibility matrices specified
      through bitmaps rather than hard-coded by switch() statements.
[25 Jan 2010 21:09] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98121

3060 Konstantin Osipov	2010-01-26
      Bug#46272, code review, update a comment.
[26 Jan 2010 17:23] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98227

3061 Konstantin Osipov	2010-01-26
      Bug#46272, review fixes. 
      Check the life cycle of trans_sentinel, add more tests.
      Rename lt_or_ha_sentinel to trans-sentinel to reflect
      the fact that it can now also separate the global shared
      lock taken for the global read lock.
[26 Jan 2010 17:47] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98228

3060 Dmitry Lenev	2010-01-26
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After review fixes in progress.
      Disallowing DDL under LOCK TABLES on implicitly locked tables allows
      to simplify metadata locking.
[26 Jan 2010 18:22] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98233

3061 Konstantin Osipov	2010-01-26
      Bug#46272, code review, update a comment.
      ******
      Bug#46272, review fixes. 
      Check the life cycle of trans_sentinel, add more tests.
      Rename lt_or_ha_sentinel to trans-sentinel to reflect
      the fact that it can now also separate the global shared
      lock taken for the global read lock.
[26 Jan 2010 19:37] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98240

3062 Konstantin Osipov	2010-01-26
      Bug#46272, review fixes, a commit to save work.
[26 Jan 2010 20:00] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98242

3063 Konstantin Osipov	2010-01-26
      Bug#46272, review fixes. Commit to save work (2).
[26 Jan 2010 20:41] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98244

3064 Konstantin Osipov	2010-01-26
      Bug#46272, review fixes. Commit to save work (3).
[27 Jan 2010 8:52] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98283

3062 Dmitry Lenev	2010-01-27
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After review fixes in progress.
[27 Jan 2010 9:09] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98291

3065 Konstantin Osipov	2010-01-27
      Bug#46272, review fixes (4).
[27 Jan 2010 10:15] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98301

3063 Dmitry Lenev	2010-01-27
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After-review fixes in progress.
[27 Jan 2010 13:16] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98330

3064 Konstantin Osipov	2010-01-27
      Bug#46272, review fixes: remove an unused member.
[27 Jan 2010 16:45] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98373

3065 Dmitry Lenev	2010-01-27
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After-review fixes in progress.
[27 Jan 2010 21:45] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98414

3067 Konstantin Osipov	2010-01-28
      Bug#46272, review fixes. Remove redundant methods.
[28 Jan 2010 9:36] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98430

3068 Konstantin Osipov	2010-01-28
      Bug#46272, review fixes.
[28 Jan 2010 12:09] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98457

3069 Dmitry Lenev	2010-01-28
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      Work in progress. Implemented advanced deadlock detector inspired
      by mysys's waiting_threads.c. This step should decrease probability
      of unwarranted ER_LOCK_DEADLOCK errors which has increased in some
      situations after introduction of type-of-operation-aware metadata
      locks.
[28 Jan 2010 12:47] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98473

3070 Konstantin Osipov	2010-01-28
      Bug#46272, review fixes.
[28 Jan 2010 13:20] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98475

3071 Dmitry Lenev	2010-01-28
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After-review fixes in progress. Do not rely on numeric values of
      enum_mdl_type elements in order to find out which lock type is stronger.
[28 Jan 2010 15:17] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98487

3072 Dmitry Lenev	2010-01-28
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After-review fixes in progress.
[28 Jan 2010 15:48] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98491

3073 Konstantin Osipov	2010-01-28
      Bug#46272, review comments. Reuse code, remove HANDLER-related
      deadlock detection heuristics that is no longer needed with
      graph-based deadlock detector. Update comments.
[28 Jan 2010 17:46] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98497

3075 Dmitry Lenev	2010-01-28
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      After-review fixes in progress.
[29 Jan 2010 8:35] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98541

3076 Dmitry Lenev	2010-01-29
      Tentative patch implementing new type-of-operation-aware metadata locks.
      Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug
      #37346 "innodb does not detect deadlock between update and alter table".
      
      More after review fixes.
[29 Jan 2010 10:44] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98579

3077 Dmitry Lenev	2010-01-29
      Tentative patch implementing new type-of-operation-aware metadata
      locks. Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary
      deadlock" and bug #37346 "innodb does not detect deadlock between
      update and alter table".
      
      More after review fixes.
[29 Jan 2010 11:01] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98588

3075 Konstantin Osipov	2010-01-29
      Bug#46272, review fixes.
[29 Jan 2010 11:02] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98590

3078 Konstantin Osipov	2010-01-29
      Bug#46272, review fixes.
[29 Jan 2010 14:41] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98630

3079 Dmitry Lenev	2010-01-29
      Tentative patch implementing new type-of-operation-aware metadata
      locks. Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary
      deadlock" and bug #37346 "innodb does not detect deadlock between
      update and alter table".
      
      More after review fixes.
[29 Jan 2010 14:45] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98638

3080 Konstantin Osipov	2010-01-29
      Bug#46272, review fixes.
      Now that we don't self-deadlock on incompatible locks, 
      we no longer need to check for the global shared lock
      in MDL. 
      Fix a merge bug in sql_view.cc when the global read lock
      API was misused.
[29 Jan 2010 15:00] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98650

3081 Konstantin Osipov	2010-01-29 [merge]
      Bug#46272, review comments.
      Simplify the MDL API by removing acquire_exclusive_locks(),
      acquire_global_intention_exclusive_lock().
[29 Jan 2010 15:10] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98655

3082 Konstantin Osipov	2010-01-29
      Bug#46272, rename the sync point.
[29 Jan 2010 15:26] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98660

3083 Dmitry Lenev	2010-01-29
      Tentative patch implementing new type-of-operation-aware metadata
      locks. Fixes bug #46272 "MySQL 5.4.4, new MDL: unnecessary
      deadlock" and bug #37346 "innodb does not detect deadlock between
      update and alter table".
      
      More after review fixes.
[29 Jan 2010 15:38] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98663

3083 Konstantin Osipov	2010-01-29
      Bug#46272, review comments: introduce MDL_lock::bitmap_t.
[29 Jan 2010 15:47] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98665

3084 Konstantin Osipov	2010-01-29
      Bug#46272, review comments: introduce MDL_lock::bitmap_t.
[1 Feb 2010 14:37] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98826

3056 Dmitry Lenev	2010-02-01
      Fix for sporadical crashes of lock_multi_bug38499.test
      caused by patch which implemented new type-of-operation-aware
      metadata locks and added a wait-for graph based deadlock
      detector to the MDL subsystem (this patch fixed bug #46272
      "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug #37346
      "innodb does not detect deadlock between update and alter
      table").
      
      Crashes were caused by a race in MDL_context::try_acquire_lock().
      This method added MDL_ticket to the list of granted tickets and
      released lock protecting list before setting MDL_ticket::m_lock.
      Thus some other thread was able to see ticket without properly
      set m_lock member for some short period of time. If this thread
      called method involving this member during this period crash
      happened.
      
      This fix ensures that MDL_ticket::m_lock is set in all cases
      when ticket is added to granted/pending lists in MDL_lock.
     @ sql/mdl.cc
        We must set MDL_ticket::m_lock member before adding ticket
        to the list of granted tickets, since such tickets can be
        accessed by other threads which might call methods using
        this member.
        Added assert which ensures that all MDL_tickets which are
        added to the granted/pending lists have properly set
        MDL_ticket::m_lock member.
     @ sql/mdl.h
        Adjusted comment describing MDL_ticket::m_lock member to
        reflect current reality.
        Added accessor method for this member.
[1 Feb 2010 14:39] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98827

3057 Dmitry Lenev	2010-02-01
      Fix for sporadical crashes of lock_multi_bug38499.test
      caused by patch which implemented new type-of-operation-aware
      metadata locks and added a wait-for graph based deadlock
      detector to the MDL subsystem (this patch fixed bug #46272
      "MySQL 5.4.4, new MDL: unnecessary deadlock" and bug #37346
      "innodb does not detect deadlock between update and alter
      table").
      
      Crashes were caused by a race in MDL_context::try_acquire_lock().
      This method added MDL_ticket to the list of granted tickets and
      released lock protecting list before setting MDL_ticket::m_lock.
      Thus some other thread was able to see ticket without properly
      set m_lock member for some short period of time. If this thread
      called method involving this member during this period crash
      happened.
      
      This fix ensures that MDL_ticket::m_lock is set in all cases
      when ticket is added to granted/pending lists in MDL_lock.
     @ sql/mdl.cc
        We must set MDL_ticket::m_lock member before adding ticket
        to the list of granted tickets, since such tickets can be
        accessed by other threads which might call methods using
        this member.
        Added assert which ensures that all MDL_tickets which are
        added to the granted/pending lists have properly set
        MDL_ticket::m_lock member.
     @ sql/mdl.h
        Adjusted comment describing MDL_ticket::m_lock member to
        reflect current reality.
        Added accessor method for this member.
[1 Feb 2010 18:00] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/98840

3058 Dmitry Lenev	2010-02-01
      Fix for sporadical hangs of mdl_sync.test caused by patch
      which implemented new type-of-operation-aware metadata
      locks and added a wait-for graph based deadlock detector
      to the MDL subsystem (this patch fixed bug #46272 "MySQL
      5.4.4, new MDL: unnecessary deadlock" and bug #37346
      "innodb does not detect deadlock between update and alter
      table").
      
      These hangs were caused by missing include of
      wait_condition.inc. This fix simply adds them.
     @ mysql-test/t/mdl_sync.test
        Added missing include of wait_condition.inc.
[3 Feb 2010 19:56] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/99143

3070 Dmitry Lenev	2010-02-03
      A follow-up for the patch which implemented new
      type-of-operation-aware metadata locks and added a
      wait-for graph based deadlock detector to the MDL
      subsystem (this patch fixed bug #46272 "MySQL 5.4.4,
      new MDL: unnecessary deadlock" and bug #37346
      "innodb does not detect deadlock between update and
      alter table").
      
      Removed unused and redundant method.
[4 Feb 2010 10:33] Jon Olav Hauglid
Bug#44836 was marked as a duplicate of this bug.
[15 Feb 2010 22:13] Bugs System
A patch for this bug has been committed. After review, it may
be pushed to the relevant source trees for release in the next
version. You can access the patch from:

  http://lists.mysql.com/commits/100451

3101 Konstantin Osipov	2010-02-16
      Bug#46272, review comments:
      a preview of the patch that removes the infinite loops
      around thr_lock.c API and mysql_lock_tables().
[16 Feb 2010 16:45] Bugs System
Pushed into 6.0.14-alpha (revid:alik@sun.com-20100216101445-2ofzkh48aq2e0e8o) (version source revid:kostja@sun.com-20100210211106-nq8ztcq2z9o4csit) (merge vers: 6.0.14-alpha) (pib:16)
[16 Feb 2010 16:55] Bugs System
Pushed into mysql-next-mr (revid:alik@sun.com-20100216101208-33qkfwdr0tep3pf2) (version source revid:kostja@sun.com-20100203220607-r41c9nlz73rllxso) (pib:16)
[2 Mar 2010 1:02] Paul Dubois
Not present in any released version. No changelog entry needed.

Setting report to Need Merge pending push of Celosia into release tree.
[6 Mar 2010 11:00] Bugs System
Pushed into 5.5.3-m3 (revid:alik@sun.com-20100306103849-hha31z2enhh7jwt3) (version source revid:vvaintroub@mysql.com-20100216221947-luyhph0txl2c5tc8) (merge vers: 5.5.99-m3) (pib:16)
[7 Mar 2010 2:07] Paul Dubois
No changelog entry needed.
[30 Nov 2011 16:17] Paul Dubois
Correction: A 5.5.3 changelog entry is needed. As part of this work, the LOW_PRIORITY modifier for LOCK TABLES ... WRITE now has no effect.