WL#7567 "Handlerton MDL callback".

Implemented support for notification of storage engines about
acquisition and release of exclusive metadata locks, which allow
metadata to be changed. Such support allows NDB SE to prevent
concurrent changes to object metadata on different cluster nodes
and opens path to implementation of proper cluster-wide metadata
locking.

Introduced new handlerton method which is called by MDL subsystem each
time before X lock acquisition. This method gets MDL_key in order to
be able to identify object on which lock is acquired. Lock acquisition
can be refused by SE by returning error from this method. The same
method (with a different notification_type argument) is called after
release of X lock.

Since in case of ALTER TABLE statement upgrade to X metadata lock
happens late in the process of statement execution, it is expensive
to abort statement execution as result of failed SE notification at
upgrade time. To alleviate this issue we additionally notify SE at
the start of ALTER TABLE on a base table and at its end. This gives
SE chance to abort execution of ALTER TABLE early in the process
without wasting precious resources.

Author: Dmitry Lenev

include/mysql/psi/mysql_mdl.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -81,7 +81,7 @@ inline_mysql_mdl_create(void *identity,
                         const MDL_key *mdl_key,
                         enum_mdl_type mdl_type,
                         enum_mdl_duration mdl_duration,
-                        MDL_wait::enum_wait_status mdl_status,
+                        MDL_ticket::enum_psi_status mdl_status,
                         const char *src_file, uint src_line)
 {
   PSI_metadata_lock *result;
@@ -100,7 +100,7 @@ inline_mysql_mdl_create(void *identity,
 
 static inline void inline_mysql_mdl_set_status(
   PSI_metadata_lock *psi,
-  MDL_wait::enum_wait_status mdl_status)
+  MDL_ticket::enum_psi_status mdl_status)
 {
   if (psi != NULL)
     PSI_METADATA_CALL(set_metadata_lock_status)(psi, mdl_status);

sql/handler.cc

@@ -8320,3 +8320,148 @@ bool handler::my_eval_gcolumn_expr(THD *thd,
   DBUG_RETURN(res);
 }
 
+
+/**
+  Auxiliary structure for passing information to notify_*_helper()
+  functions.
+*/
+
+struct HTON_NOTIFY_PARAMS
+{
+  const MDL_key *key;
+  const ha_notification_type notification_type;
+  bool some_htons_were_notified;
+};
+
+
+static my_bool
+notify_exclusive_mdl_helper(THD *thd, plugin_ref plugin, void *arg)
+{
+  handlerton *hton= plugin_data<handlerton*>(plugin);
+  if (hton->state == SHOW_OPTION_YES && hton->notify_exclusive_mdl)
+  {
+    HTON_NOTIFY_PARAMS *params= reinterpret_cast<HTON_NOTIFY_PARAMS*>(arg);
+
+    if (hton->notify_exclusive_mdl(thd, params->key,
+                                   params->notification_type))
+    {
+      // Ignore failures from post event notification.
+      if (params->notification_type == HA_NOTIFY_PRE_EVENT)
+        return TRUE;
+    }
+    else
+      params->some_htons_were_notified= true;
+  }
+  return FALSE;
+}
+
+
+/**
+  Notify/get permission from all interested storage engines before
+  acquisition or after release of exclusive metadata lock on object
+  represented by key.
+
+  @param thd                Thread context.
+  @param mdl_key            MDL key identifying object on which exclusive
+                            lock is to be acquired/was released.
+  @param notification_type  Indicates whether this is pre-acquire or
+                            post-release notification.
+
+  @note @see handlerton::notify_exclusive_mdl for details about
+        calling convention and error reporting.
+
+  @return False - if notification was successful/lock can be acquired,
+          True - if it has failed/lock should not be acquired.
+*/
+
+bool ha_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key,
+                             ha_notification_type notification_type)
+{
+  HTON_NOTIFY_PARAMS params = {mdl_key, notification_type, false};
+  if (plugin_foreach(thd, notify_exclusive_mdl_helper,
+                     MYSQL_STORAGE_ENGINE_PLUGIN, &params))
+  {
+    /*
+      If some SE hasn't given its permission to acquire lock and some SEs
+      has given their permissions, we need to notify the latter group about
+      failed lock acquisition. We do this by calling post-release notification
+      for all interested SEs unconditionally.
+    */
+    if (notification_type == HA_NOTIFY_PRE_EVENT &&
+        params.some_htons_were_notified)
+    {
+      HTON_NOTIFY_PARAMS rollback_params = {mdl_key, HA_NOTIFY_POST_EVENT,
+                                            false};
+      (void) plugin_foreach(thd, notify_exclusive_mdl_helper,
+                            MYSQL_STORAGE_ENGINE_PLUGIN, &rollback_params);
+    }
+    return true;
+  }
+  return false;
+}
+
+
+static my_bool
+notify_alter_table_helper(THD *thd, plugin_ref plugin, void *arg)
+{
+  handlerton *hton= plugin_data<handlerton*>(plugin);
+  if (hton->state == SHOW_OPTION_YES && hton->notify_alter_table)
+  {
+    HTON_NOTIFY_PARAMS *params= reinterpret_cast<HTON_NOTIFY_PARAMS*>(arg);
+
+    if (hton->notify_alter_table(thd, params->key, params->notification_type))
+    {
+      // Ignore failures from post event notification.
+      if (params->notification_type == HA_NOTIFY_PRE_EVENT)
+        return TRUE;
+    }
+    else
+      params->some_htons_were_notified= true;
+  }
+  return FALSE;
+}
+
+
+/**
+  Notify/get permission from all interested storage engines before
+  or after executed ALTER TABLE on the table identified by key.
+
+  @param thd                Thread context.
+  @param mdl_key            MDL key identifying table.
+  @param notification_type  Indicates whether this is pre-ALTER or
+                            post-ALTER notification.
+
+  @note @see handlerton::notify_alter_table for rationale,
+        details about calling convention and error reporting.
+
+  @return False - if notification was successful/ALTER TABLE can
+                  proceed.
+          True -  if it has failed/ALTER TABLE should fail.
+*/
+
+bool ha_notify_alter_table(THD *thd, const MDL_key *mdl_key,
+                           ha_notification_type notification_type)
+{
+  HTON_NOTIFY_PARAMS params = {mdl_key, notification_type, false};
+
+  if (plugin_foreach(thd, notify_alter_table_helper,
+                     MYSQL_STORAGE_ENGINE_PLUGIN, &params))
+  {
+    /*
+      If some SE hasn't given its permission to do ALTER TABLE and some SEs
+      has given their permissions, we need to notify the latter group about
+      failed attemopt. We do this by calling post-ALTER TABLE notification
+      for all interested SEs unconditionally.
+    */
+    if (notification_type == HA_NOTIFY_PRE_EVENT &&
+        params.some_htons_were_notified)
+    {
+      HTON_NOTIFY_PARAMS rollback_params = {mdl_key, HA_NOTIFY_POST_EVENT,
+                                            false};
+      (void) plugin_foreach(thd, notify_alter_table_helper,
+                            MYSQL_STORAGE_ENGINE_PLUGIN, &rollback_params);
+    }
+    return true;
+  }
+  return false;
+}

sql/handler.h

@@ -668,6 +668,8 @@ typedef bool (stat_print_fn)(THD *thd, const char *type, size_t type_len,
                              const char *file, size_t file_len,
                              const char *status, size_t status_len);
 enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };
+enum ha_notification_type { HA_NOTIFY_PRE_EVENT, HA_NOTIFY_POST_EVENT };
+
 extern st_plugin_int *hton2plugin[MAX_HA];
 
 class handler;
@@ -901,6 +903,70 @@ struct handlerton
   void (*replace_native_transaction_in_thd)(THD *thd, void *new_trx_arg,
                                             void **ptr_trx_arg);
 
+
+  /**
+    Notify/get permission from storage engine before acquisition or after
+    release of exclusive metadata lock on object represented by key.
+
+    @param thd                Thread context.
+    @param mdl_key            MDL key identifying object on which exclusive
+                              lock is to be acquired/was released.
+    @param notification_type  Indicates whether this is pre-acquire or
+                              post-release notification.
+
+    @note Notification is done only for objects from TABLESPACE, SCHEMA,
+          TABLE, FUNCTION, PROCEDURE, TRIGGER and EVENT namespaces.
+
+    @note Problems during notification are to be reported as warnings, MDL
+          subsystem will report generic error if pre-acquire notification
+          fails/SE refuses lock acquisition.
+    @note Return value is ignored/error is not reported in case of
+          post-release notification.
+
+    @note In some cases post-release notification might happen even if
+          there were no prior pre-acquire notification. For example,
+          when SE was loaded after exclusive lock acquisition, or when
+          we need notify SEs which permitted lock acquisition that it
+          didn't happen because one of SEs didn't allow it (in such case
+          we will do post-release notification for all SEs for simplicity).
+
+    @return False - if notification was successful/lock can be acquired,
+            True - if it has failed/lock should not be acquired.
+  */
+  bool (*notify_exclusive_mdl)(THD *thd, const MDL_key *mdl_key,
+                               ha_notification_type notification_type);
+
+  /**
+    Notify/get permission from storage engine before or after execution of
+    ALTER TABLE operation on the table identified by the MDL key.
+
+    @param thd                Thread context.
+    @param mdl_key            MDL key identifying table which is going to be
+                              or was ALTERed.
+    @param notification_type  Indicates whether this is pre-ALTER TABLE or
+                              post-ALTER TABLE notification.
+
+    @note This hook is necessary because for ALTER TABLE upgrade to X
+          metadata lock happens fairly late during the execution process,
+          so it can be expensive to abort ALTER TABLE operation at this
+          stage by returning failure from notify_exclusive_mdl() hook.
+
+    @note This hook follows the same error reporting convention as
+          @see notify_exclusive_mdl().
+
+    @note Similarly to notify_exclusive_mdl() in some cases post-ALTER
+          notification might happen even if there were no prior pre-ALTER
+          notification.
+
+    @note Post-ALTER notification can happen before post-release notification
+          for exclusive metadata lock acquired by this ALTER TABLE.
+
+    @return False - if notification was successful/ALTER TABLE can proceed.
+            True - if it has failed/ALTER TABLE should be aborted.
+  */
+  bool (*notify_alter_table)(THD *thd, const MDL_key *mdl_key,
+                             ha_notification_type notification_type);
+
    uint32 license; /* Flag for Engine License */
    void *data; /* Location for engines to keep personal structures */
 };
@@ -4013,4 +4079,10 @@ void print_keydup_error(TABLE *table, KEY *key, myf errflag);
 
 void ha_set_normalized_disabled_se_str(const std::string &disabled_se_str);
 bool ha_is_storage_engine_disabled(handlerton *se_engine);
+
+bool ha_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key,
+                             ha_notification_type notification_type);
+bool ha_notify_alter_table(THD *thd, const MDL_key *mdl_key,
+                           ha_notification_type notification_type);
+
 #endif /* HANDLER_INCLUDED */