1 files changed, 26 insertions, 41 deletions

diff --git a/storage/innobase/include/dict0dict.h b/storage/innobase/include/dict0dict.h
index 5fafb2c5..3baac658 100644
--- a/storage/innobase/include/dict0dict.h
+++ b/storage/innobase/include/dict0dict.h
@@ -35,6 +35,7 @@ Created 1/8/1996 Heikki Tuuri
 #include <my_sys.h>
 #include <deque>
 
+class MDL_context;
 class MDL_ticket;
 
 /** the first table or index ID for other than hard-coded system tables */
@@ -139,6 +140,21 @@ dict_acquire_mdl_shared(dict_table_t *table,
                         MDL_ticket **mdl,
                         dict_table_op_t table_op= DICT_TABLE_OP_NORMAL);
 
+/** Acquire MDL shared for the table name.
+@tparam trylock whether to use non-blocking operation
+@param[in,out]  table           table object
+@param[in,out]  mdl_context     MDL context
+@param[out]     mdl             MDL ticket
+@param[in]      table_op        operation to perform when opening
+@return table object after locking MDL shared
+@retval nullptr if the table is not readable, or if trylock && MDL blocked */
+template<bool trylock>
+__attribute__((nonnull, warn_unused_result))
+dict_table_t*
+dict_acquire_mdl_shared(dict_table_t *table,
+                        MDL_context *mdl_context, MDL_ticket **mdl,
+                        dict_table_op_t table_op);
+
 /** Look up a table by numeric identifier.
 @param[in]      table_id        table identifier
 @param[in]      dict_locked     data dictionary locked
@@ -1314,13 +1330,7 @@ class dict_sys_t
   std::atomic<ulonglong> latch_ex_wait_start;
 
   /** the rw-latch protecting the data dictionary cache */
-  alignas(CPU_LEVEL1_DCACHE_LINESIZE) srw_lock latch;
-#ifdef UNIV_DEBUG
-  /** whether latch is being held in exclusive mode (by any thread) */
-  Atomic_relaxed<pthread_t> latch_ex;
-  /** number of S-latch holders */
-  Atomic_counter<uint32_t> latch_readers;
-#endif
+  alignas(CPU_LEVEL1_DCACHE_LINESIZE) IF_DBUG(srw_lock_debug,srw_lock) latch;
 public:
   /** Indexes of SYS_TABLE[] */
   enum
@@ -1488,15 +1498,12 @@ public:
   }
 
 #ifdef UNIV_DEBUG
-  /** @return whether any thread (not necessarily the current thread)
-  is holding the latch; that is, this check may return false
-  positives */
-  bool frozen() const { return latch_readers || latch_ex; }
-  /** @return whether any thread (not necessarily the current thread)
-  is holding a shared latch */
-  bool frozen_not_locked() const { return latch_readers; }
+  /** @return whether the current thread is holding the latch */
+  bool frozen() const { return latch.have_any(); }
+  /** @return whether the current thread is holding a shared latch */
+  bool frozen_not_locked() const { return latch.have_rd(); }
   /** @return whether the current thread holds the exclusive latch */
-  bool locked() const { return latch_ex == pthread_self(); }
+  bool locked() const { return latch.have_wr(); }
 #endif
 private:
   /** Acquire the exclusive latch */
@@ -1511,13 +1518,7 @@ public:
   /** Exclusively lock the dictionary cache. */
   void lock(SRW_LOCK_ARGS(const char *file, unsigned line))
   {
-    if (latch.wr_lock_try())
-    {
-      ut_ad(!latch_readers);
-      ut_ad(!latch_ex);
-      ut_d(latch_ex= pthread_self());
-    }
-    else
+    if (!latch.wr_lock_try())
       lock_wait(SRW_LOCK_ARGS(file, line));
   }
 
@@ -1530,27 +1531,11 @@ public:
   ATTRIBUTE_NOINLINE void unfreeze();
 #else
   /** Unlock the data dictionary cache. */
-  void unlock()
-  {
-    ut_ad(latch_ex == pthread_self());
-    ut_ad(!latch_readers);
-    ut_d(latch_ex= 0);
-    latch.wr_unlock();
-  }
+  void unlock() { latch.wr_unlock(); }
   /** Acquire a shared lock on the dictionary cache. */
-  void freeze()
-  {
-    latch.rd_lock();
-    ut_ad(!latch_ex);
-    ut_d(latch_readers++);
-  }
+  void freeze() { latch.rd_lock(); }
   /** Release a shared lock on the dictionary cache. */
-  void unfreeze()
-  {
-    ut_ad(!latch_ex);
-    ut_ad(latch_readers--);
-    latch.rd_unlock();
-  }
+  void unfreeze() { latch.rd_unlock(); }
 #endif
 
   /** Estimate the used memory occupied by the data dictionary