Merging upstream version 1:10.11.8.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

36 files changed, 202 insertions, 161 deletions

diff --git a/storage/maria/CMakeLists.txt b/storage/maria/CMakeLists.txt
index f55d78f0..426a19f0 100644
--- a/storage/maria/CMakeLists.txt
+++ b/storage/maria/CMakeLists.txt
@@ -124,7 +124,7 @@ ENDIF()
 IF (CURL_FOUND)
   INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIRS})
   MYSQL_ADD_PLUGIN(s3 ha_s3.cc ${S3_SOURCES} COMPONENT s3-engine
-    LINK_LIBRARIES ${CURL_LIBRARIES} z STORAGE_ENGINE NOT_EMBEDDED CONFIG s3.cnf)
+    LINK_LIBRARIES ${CURL_LIBRARIES} ${ZLIB_LIBRARIES} STORAGE_ENGINE NOT_EMBEDDED CONFIG s3.cnf)
 ENDIF()
 
 SET(CPACK_RPM_s3-engine_PACKAGE_SUMMARY "Amazon S3 archival storage engine for MariaDB" PARENT_SCOPE)
@@ -132,7 +132,7 @@ SET(CPACK_RPM_s3-engine_PACKAGE_DESCRIPTION "The S3 storage engine allows one to
 
 IF(TARGET s3)
   MYSQL_ADD_EXECUTABLE(aria_s3_copy aria_s3_copy.cc ${S3_SOURCES} COMPONENT s3-engine)
-  TARGET_LINK_LIBRARIES(aria_s3_copy aria myisam mysys mysys_ssl ${CURL_LIBRARIES} ${ZLIB_LIBRARY})
+  TARGET_LINK_LIBRARIES(aria_s3_copy aria myisam mysys mysys_ssl ${CURL_LIBRARIES} ${ZLIB_LIBRARIES})
   INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/libmarias3)
   ADD_DEFINITIONS(-DWITH_S3_STORAGE_ENGINE)
 ENDIF()
diff --git a/storage/maria/aria_chk.c b/storage/maria/aria_chk.c
index 143110dc..4bbe513b 100644
--- a/storage/maria/aria_chk.c
+++ b/storage/maria/aria_chk.c
@@ -145,7 +145,8 @@ int main(int argc, char **argv)
   {
     if ((ma_control_file_open(FALSE, opt_require_control_file ||
                               !(check_param.testflag & T_SILENT),
-                              TRUE)))
+                              TRUE,
+                              control_file_open_flags)))
     {
       if (opt_require_control_file ||
           (opt_transaction_logging && (check_param.testflag & T_REP_ANY)))
diff --git a/storage/maria/aria_pack.c b/storage/maria/aria_pack.c
index 40e7e399..464a08fb 100644
--- a/storage/maria/aria_pack.c
+++ b/storage/maria/aria_pack.c
@@ -239,7 +239,8 @@ int main(int argc, char **argv)
   if (!opt_ignore_control_file &&
       (no_control_file= ma_control_file_open(FALSE,
                                              (opt_require_control_file ||
-                                              !silent), FALSE)) &&
+                                              !silent), FALSE,
+                                             control_file_open_flags)) &&
        opt_require_control_file)
   {
     error= 1;
diff --git a/storage/maria/aria_read_log.c b/storage/maria/aria_read_log.c
index c0c76ed5..2997314d 100644
--- a/storage/maria/aria_read_log.c
+++ b/storage/maria/aria_read_log.c
@@ -104,7 +104,7 @@ int main(int argc, char **argv)
     goto end;
   }
   /* we don't want to create a control file, it MUST exist */
-  if (ma_control_file_open(FALSE, TRUE, TRUE))
+  if (ma_control_file_open(FALSE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't open control file (%d)\n", errno);
     goto err;
diff --git a/storage/maria/ha_maria.cc b/storage/maria/ha_maria.cc
index 66dd9867..b3b0ba0f 100644
--- a/storage/maria/ha_maria.cc
+++ b/storage/maria/ha_maria.cc
@@ -38,6 +38,7 @@ C_MODE_START
 #include "ma_recovery.h"
 C_MODE_END
 #include "ma_trnman.h"
+#include "ma_loghandler.h"
 
 //#include "sql_priv.h"
 #include "protocol.h"
@@ -45,6 +46,7 @@ C_MODE_END
 #include "key.h"
 #include "log.h"
 #include "sql_parse.h"
+#include "mysql/service_print_check_msg.h"
 #include "debug.h"
 
 /*
@@ -428,10 +430,8 @@ static void _ma_check_print_msg(HA_CHECK *param, const LEX_CSTRING *msg_type,
                                 const char *fmt, va_list args)
 {
   THD *thd= (THD *) param->thd;
-  Protocol *protocol= thd->protocol;
-  size_t length, msg_length;
+  size_t msg_length __attribute__((unused));
   char msgbuf[MYSQL_ERRMSG_SIZE];
-  char name[NAME_LEN * 2 + 2];
 
   if (param->testflag & T_SUPPRESS_ERR_HANDLING)
     return;
@@ -460,27 +460,10 @@ static void _ma_check_print_msg(HA_CHECK *param, const LEX_CSTRING *msg_type,
       _ma_check_print(param, msg_type, msgbuf);
     return;
   }
-  length= (uint) (strxmov(name, param->db_name, ".", param->table_name,
-                          NullS) - name);
-  /*
-    TODO: switch from protocol to push_warning here. The main reason we didn't
-    it yet is parallel repair, which threads have no THD object accessible via
-    current_thd.
-
-    Also we likely need to lock mutex here (in both cases with protocol and
-    push_warning).
-  */
-  protocol->prepare_for_resend();
-  protocol->store(name, (uint)length, system_charset_info);
-  protocol->store(param->op_name, strlen(param->op_name), system_charset_info);
-  protocol->store(msg_type, system_charset_info);
-  protocol->store(msgbuf, msg_length, system_charset_info);
-  if (protocol->write())
-    sql_print_error("Failed on my_net_write, writing to stderr instead: %s.%s: %s\n",
-                    param->db_name, param->table_name, msgbuf);
-  else if (thd->variables.log_warnings > 2)
+  print_check_msg(thd, param->db_name, param->table_name,
+                  param->op_name, msg_type->str, msgbuf, 0);
+  if (thd->variables.log_warnings > 2)
     _ma_check_print(param, msg_type, msgbuf);
-
   return;
 }
 
@@ -1952,41 +1935,46 @@ int ha_maria::preload_keys(THD * thd, HA_CHECK_OPT *check_opt)
 
   SYNOPSIS
     disable_indexes()
-    mode        mode of operation:
-                HA_KEY_SWITCH_NONUNIQ      disable all non-unique keys
-                HA_KEY_SWITCH_ALL          disable all keys
-                HA_KEY_SWITCH_NONUNIQ_SAVE dis. non-uni. and make persistent
-                HA_KEY_SWITCH_ALL_SAVE     dis. all keys and make persistent
 
-  IMPLEMENTATION
-    HA_KEY_SWITCH_NONUNIQ       is not implemented.
-    HA_KEY_SWITCH_ALL_SAVE      is not implemented.
+  DESCRIPTION
+    See handler::ha_disable_indexes()
 
   RETURN
     0  ok
     HA_ERR_WRONG_COMMAND  mode not implemented.
 */
 
-int ha_maria::disable_indexes(uint mode)
+int ha_maria::disable_indexes(key_map map, bool persist)
 {
   int error;
 
-  if (mode == HA_KEY_SWITCH_ALL)
+  if (!persist)
   {
     /* call a storage engine function to switch the key map */
+    DBUG_ASSERT(map.is_clear_all());
     error= maria_disable_indexes(file);
   }
-  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
+  else
   {
-    maria_extra(file, HA_EXTRA_NO_KEYS, 0);
+    /* auto-inc key cannot be disabled */
+    if (table->s->next_number_index < MAX_KEY)
+      DBUG_ASSERT(map.is_set(table->s->next_number_index));
+
+    /* unique keys cannot be disabled either */
+    for (uint i=0; i < table->s->keys; i++)
+      DBUG_ASSERT(!(table->key_info[i].flags & HA_NOSAME) || map.is_set(i));
+
+    ulonglong ullmap= map.to_ulonglong();
+
+    /* make sure auto-inc key is enabled even if it's > 64 */
+    if (map.length() > MARIA_KEYMAP_BITS &&
+        table->s->next_number_index < MAX_KEY)
+      maria_set_key_active(ullmap, table->s->next_number_index);
+
+    maria_extra(file, HA_EXTRA_NO_KEYS, &ullmap);
     info(HA_STATUS_CONST);                      // Read new key info
     error= 0;
   }
-  else
-  {
-    /* mode not implemented */
-    error= HA_ERR_WRONG_COMMAND;
-  }
   return error;
 }
 
@@ -1996,21 +1984,14 @@ int ha_maria::disable_indexes(uint mode)
 
   SYNOPSIS
     enable_indexes()
-    mode        mode of operation:
-                HA_KEY_SWITCH_NONUNIQ      enable all non-unique keys
-                HA_KEY_SWITCH_ALL          enable all keys
-                HA_KEY_SWITCH_NONUNIQ_SAVE en. non-uni. and make persistent
-                HA_KEY_SWITCH_ALL_SAVE     en. all keys and make persistent
 
   DESCRIPTION
     Enable indexes, which might have been disabled by disable_index() before.
-    The modes without _SAVE work only if both data and indexes are empty,
-    since the MARIA repair would enable them persistently.
+    If persist=false, it works only if both data and indexes are empty,
+    since the Aria repair would enable them persistently.
     To be sure in these cases, call handler::delete_all_rows() before.
 
-  IMPLEMENTATION
-    HA_KEY_SWITCH_NONUNIQ       is not implemented.
-    HA_KEY_SWITCH_ALL_SAVE      is not implemented.
+    See also handler::ha_enable_indexes()
 
   RETURN
     0  ok
@@ -2019,18 +2000,19 @@ int ha_maria::disable_indexes(uint mode)
     HA_ERR_WRONG_COMMAND  mode not implemented.
 */
 
-int ha_maria::enable_indexes(uint mode)
+int ha_maria::enable_indexes(key_map map, bool persist)
 {
   int error;
   ha_rows start_rows= file->state->records;
-  DBUG_PRINT("info", ("ha_maria::enable_indexes mode: %d", mode));
+  DBUG_PRINT("info", ("ha_maria::enable_indexes mode: %d", persist));
   if (maria_is_all_keys_active(file->s->state.key_map, file->s->base.keys))
   {
     /* All indexes are enabled already. */
     return 0;
   }
 
-  if (mode == HA_KEY_SWITCH_ALL)
+  DBUG_ASSERT(map.is_prefix(table->s->keys));
+  if (!persist)
   {
     error= maria_enable_indexes(file);
     /*
@@ -2039,7 +2021,7 @@ int ha_maria::enable_indexes(uint mode)
        but mode==HA_KEY_SWITCH_ALL forbids it.
     */
   }
-  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
+  else
   {
     THD *thd= table->in_use;
     HA_CHECK *param= (HA_CHECK*) thd->alloc(sizeof *param);
@@ -2104,11 +2086,6 @@ int ha_maria::enable_indexes(uint mode)
     info(HA_STATUS_CONST);
     thd_proc_info(thd, save_proc_info);
   }
-  else
-  {
-    /* mode not implemented */
-    error= HA_ERR_WRONG_COMMAND;
-  }
   DBUG_EXECUTE_IF("maria_flush_whole_log",
                   {
                     DBUG_PRINT("maria_flush_whole_log", ("now"));
@@ -2311,7 +2288,7 @@ int ha_maria::end_bulk_insert()
 {
   int first_error, first_errno= 0, error;
   my_bool abort= file->s->deleting, empty_table= 0;
-  uint enable_index_mode= HA_KEY_SWITCH_NONUNIQ_SAVE;
+  bool enable_persistently= true;
   DBUG_ENTER("ha_maria::end_bulk_insert");
 
   if ((first_error= maria_end_bulk_insert(file, abort)))
@@ -2340,7 +2317,7 @@ int ha_maria::end_bulk_insert()
         first_error= 1;
         first_errno= my_errno;
       }
-      enable_index_mode= HA_KEY_SWITCH_ALL;
+      enable_persistently= false;
       empty_table= 1;
       /*
         Ignore all changed pages, required by _ma_renable_logging_for_table()
@@ -2352,7 +2329,7 @@ int ha_maria::end_bulk_insert()
 
   if (!abort && can_enable_indexes)
   {
-    if ((error= enable_indexes(enable_index_mode)))
+    if ((error= enable_indexes(key_map(table->s->keys), enable_persistently)))
     {
       if (!first_error)
       {
@@ -3361,6 +3338,8 @@ int ha_maria::create(const char *name, TABLE *table_arg,
   if (ha_create_info->tmp_table())
   {
     create_flags|= HA_CREATE_TMP_TABLE | HA_CREATE_DELAY_KEY_WRITE;
+    if (ha_create_info->options & HA_LEX_CREATE_GLOBAL_TMP_TABLE)
+      create_flags|= HA_CREATE_GLOBAL_TMP_TABLE;
     create_info.transactional= 0;
   }
   if (ha_create_info->options & HA_CREATE_KEEP_FILES)
@@ -3894,7 +3873,8 @@ static int ha_maria_init(void *p)
   if (!aria_readonly)
     res= maria_upgrade();
   res= res || maria_init();
-  tmp= ma_control_file_open(!aria_readonly, !aria_readonly, !aria_readonly);
+  tmp= ma_control_file_open(!aria_readonly, !aria_readonly, !aria_readonly,
+                            control_file_open_flags);
   res= res || aria_readonly ? tmp == CONTROL_FILE_LOCKED : tmp != 0;
   res= res ||
     ((force_start_after_recovery_failures != 0 && !aria_readonly) &&
diff --git a/storage/maria/ha_maria.h b/storage/maria/ha_maria.h
index 2b8b5dc9..41f64436 100644
--- a/storage/maria/ha_maria.h
+++ b/storage/maria/ha_maria.h
@@ -122,8 +122,8 @@ public:
   int external_lock(THD * thd, int lock_type) override;
   int start_stmt(THD *thd, thr_lock_type lock_type) override final;
   int delete_all_rows(void) override final;
-  int disable_indexes(uint mode) override final;
-  int enable_indexes(uint mode) override final;
+  int disable_indexes(key_map map, bool persist) override final;
+  int enable_indexes(key_map map, bool persist) override final;
   int indexes_are_disabled(void) override final;
   void start_bulk_insert(ha_rows rows, uint flags) override final;
   int end_bulk_insert() override final;
diff --git a/storage/maria/ma_bitmap.c b/storage/maria/ma_bitmap.c
index 61fe4f9d..91f93755 100644
--- a/storage/maria/ma_bitmap.c
+++ b/storage/maria/ma_bitmap.c
@@ -232,7 +232,7 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file,
   uint max_page_size;
   MARIA_FILE_BITMAP *bitmap= &share->bitmap;
   uint size= share->block_size;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf flag= MY_WME | share->malloc_flag;
   pgcache_page_no_t first_bitmap_with_space;
 #ifndef DBUG_OFF
   /* We want to have a copy of the bitmap to be able to print differences */
diff --git a/storage/maria/ma_blockrec.c b/storage/maria/ma_blockrec.c
index 543ddcca..561cc324 100644
--- a/storage/maria/ma_blockrec.c
+++ b/storage/maria/ma_blockrec.c
@@ -488,7 +488,7 @@ my_bool _ma_init_block_record(MARIA_HA *info)
 {
   MARIA_ROW *row= &info->cur_row, *new_row= &info->new_row;
   MARIA_SHARE *share= info->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf flag= MY_WME | share->malloc_flag;
   uint default_extents;
   DBUG_ENTER("_ma_init_block_record");
 
@@ -2654,7 +2654,6 @@ static my_bool write_block_record(MARIA_HA *info,
   LSN lsn;
   my_off_t position;
   uint save_my_errno;
-  myf myflag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
   DBUG_ENTER("write_block_record");
 
   head_block= bitmap_blocks->block;
@@ -2721,7 +2720,7 @@ static my_bool write_block_record(MARIA_HA *info,
     for every data segment we want to store.
   */
   if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
-                       row->head_length, myflag))
+                       row->head_length, MY_WME | share->malloc_flag))
     DBUG_RETURN(1);
 
   tmp_data_used= 0;                 /* Either 0 or last used uchar in 'data' */
@@ -4750,7 +4749,7 @@ int _ma_read_block_record2(MARIA_HA *info, uchar *record,
   MARIA_EXTENT_CURSOR extent;
   MARIA_COLUMNDEF *column, *end_column;
   MARIA_ROW *cur_row= &info->cur_row;
-  myf myflag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf myflag= MY_WME | share->malloc_flag;
   DBUG_ENTER("_ma_read_block_record2");
 
   start_of_data= data;
@@ -5089,7 +5088,6 @@ static my_bool read_row_extent_info(MARIA_HA *info, uchar *buff,
   uint flag, row_extents, row_extents_size;
   uint field_lengths __attribute__ ((unused));
   uchar *extents, *end;
-  myf myflag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
   DBUG_ENTER("read_row_extent_info");
 
   if (!(data= get_record_position(share, buff,
@@ -5113,7 +5111,7 @@ static my_bool read_row_extent_info(MARIA_HA *info, uchar *buff,
     if (info->cur_row.extents_buffer_length < row_extents_size &&
         _ma_alloc_buffer(&info->cur_row.extents,
                          &info->cur_row.extents_buffer_length,
-                         row_extents_size, myflag))
+                         row_extents_size, MY_WME | share->malloc_flag))
       DBUG_RETURN(1);
     memcpy(info->cur_row.extents, data, ROW_EXTENT_SIZE);
     data+= ROW_EXTENT_SIZE;
@@ -5283,7 +5281,7 @@ my_bool _ma_cmp_block_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
 my_bool _ma_scan_init_block_record(MARIA_HA *info)
 {
   MARIA_SHARE *share= info->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf flag= MY_WME | share->malloc_flag;
   DBUG_ENTER("_ma_scan_init_block_record");
   DBUG_ASSERT(info->dfile.file == share->bitmap.file.file);
 
diff --git a/storage/maria/ma_check.c b/storage/maria/ma_check.c
index 1f6aa2ee..e4ba0726 100644
--- a/storage/maria/ma_check.c
+++ b/storage/maria/ma_check.c
@@ -125,6 +125,7 @@ void maria_chk_init(HA_CHECK *param)
   param->max_stage= 1;
   param->stack_end_ptr= &my_thread_var->stack_ends_here;
   param->max_allowed_lsn= (LSN) ~0ULL;
+  /* Flag when initializing buffers possible used by parallel repair threads */
   param->malloc_flags= MY_THREAD_SPECIFIC;
 }
 
@@ -1305,7 +1306,6 @@ static int check_dynamic_record(HA_CHECK *param, MARIA_HA *info, int extend,
   ulong UNINIT_VAR(left_length);
   uint	b_type;
   char llbuff[22],llbuff2[22],llbuff3[22];
-  myf myflag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
   DBUG_ENTER("check_dynamic_record");
 
   pos= 0;
@@ -1413,7 +1413,8 @@ static int check_dynamic_record(HA_CHECK *param, MARIA_HA *info, int extend,
         {
           if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
                                block_info.rec_len +
-                               share->base.extra_rec_buff_size, myflag))
+                               share->base.extra_rec_buff_size,
+                               MY_WME | share->malloc_flag))
 
           {
             _ma_check_print_error(param,
@@ -2130,7 +2131,7 @@ int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info, my_bool extend)
 
   if (!(record= (uchar*) my_malloc(PSI_INSTRUMENT_ME,
                                    share->base.default_rec_buff_size,
-                                   MYF(param->malloc_flags))))
+                                   MYF(MY_THREAD_SPECIFIC))))
   {
     _ma_check_print_error(param,"Not enough memory for record");
     DBUG_RETURN(-1);
@@ -2507,6 +2508,11 @@ static int initialize_variables_for_repair(HA_CHECK *param,
   maria_versioning(info, 0);
   /* remember original number of rows */
   *info->state= info->s->state.state;
+  if (share->data_file_type == BLOCK_RECORD)
+    share->state.state.data_file_length= MY_ALIGN(sort_info->filelength,
+                                                  share->block_size);
+  else
+    share->state.state.data_file_length= sort_info->filelength;
   return 0;
 }
 
@@ -2743,7 +2749,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
                       READ_CACHE, share->pack.header_length, 1, MYF(MY_WME)))
       goto err;
   }
-  if (sort_info.new_info->s->data_file_type != BLOCK_RECORD)
+  if (!block_record)
   {
     /* When writing to not block records, we need a write buffer */
     if (!rep_quick)
@@ -2756,7 +2762,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
       sort_info.new_info->opt_flag|=WRITE_CACHE_USED;
     }
   }
-  else if (block_record)
+  else
   {
     scan_inited= 1;
     if (maria_scan_init(sort_info.info))
@@ -2766,10 +2772,10 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
   if (!(sort_param.record=
         (uchar *) my_malloc(PSI_INSTRUMENT_ME, (uint)
                             share->base.default_rec_buff_size,
-                            MYF(param->malloc_flags))) ||
+                            MYF(MY_THREAD_SPECIFIC))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
                        share->base.default_rec_buff_size,
-                       MYF(param->malloc_flags)))
+                       MYF(MY_THREAD_SPECIFIC)))
   {
     _ma_check_print_error(param, "Not enough memory for extra record");
     goto err;
@@ -3389,7 +3395,7 @@ static int sort_one_index(HA_CHECK *param, MARIA_HA *info,
   length= page.size;
   bzero(buff+length,keyinfo->block_length-length);
   if (write_page(share, new_file, buff, keyinfo->block_length,
-                 new_page_pos, MYF(MY_NABP | MY_WAIT_IF_FULL)))
+                 new_page_pos, MYF(MY_NABP | MY_WAIT_IF_FULL) & param->myf_rw))
   {
     _ma_check_print_error(param,"Can't write indexblock, error: %d",my_errno);
     goto err;
@@ -3721,7 +3727,7 @@ int maria_filecopy(HA_CHECK *param, File to,File from,my_off_t start,
 
   buff_length=(ulong) MY_MIN(param->write_buffer_length,length);
   if (!(buff=my_malloc(PSI_INSTRUMENT_ME, buff_length,
-                       MYF(param->malloc_flags))))
+                       MYF(MY_THREAD_SPECIFIC))))
   {
     buff=tmp_buff; buff_length=IO_SIZE;
   }
@@ -3867,10 +3873,10 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
   if (!(sort_param.record=
         (uchar*) my_malloc(PSI_INSTRUMENT_ME,
                            (size_t) share->base.default_rec_buff_size,
-                           MYF(param->malloc_flags))) ||
+                           MYF(MY_THREAD_SPECIFIC))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
                        share->base.default_rec_buff_size,
-                       MYF(param->malloc_flags)))
+                       MYF(MY_THREAD_SPECIFIC)))
   {
     _ma_check_print_error(param, "Not enough memory for extra record");
     goto err;
@@ -3889,7 +3895,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
   sort_param.wordlist=NULL;
   init_alloc_root(PSI_INSTRUMENT_ME, &sort_param.wordroot,
                   FTPARSER_MEMROOT_ALLOC_SIZE, 0,
-                  MYF(param->malloc_flags));
+                  MYF(MY_THREAD_SPECIFIC));
 
   sort_param.key_cmp=sort_key_cmp;
   sort_param.lock_in_memory=maria_lock_memory;
@@ -4109,6 +4115,9 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
         _ma_check_print_error(param, "Couldn't change to new data file");
         goto err;
       }
+      /* Inform sort_delete_record that we are using the new file */
+      sort_info.new_info->dfile.file= info->rec_cache.file= info->dfile.file;
+
       if (param->testflag & T_UNPACK)
         restore_data_file_type(share);
 
@@ -4457,7 +4466,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
   if (!(sort_param=(MARIA_SORT_PARAM *)
         my_malloc(PSI_INSTRUMENT_ME, (uint) share->base.keys *
 		  (sizeof(MARIA_SORT_PARAM) + share->base.pack_reclength),
-		  MYF(MY_ZEROFILL | param->malloc_flags))))
+		  MYF(MY_ZEROFILL | MY_THREAD_SPECIFIC))))
   {
     _ma_check_print_error(param,"Not enough memory for key!");
     goto err;
@@ -4515,9 +4524,10 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
 
     sort_param[i].record= (((uchar *)(sort_param+share->base.keys))+
                           (share->base.pack_reclength * i));
+    /* These buffers are per thread */
     if (_ma_alloc_buffer(&sort_param[i].rec_buff, &sort_param[i].rec_buff_size,
                          share->base.default_rec_buff_size,
-                         MYF(param->malloc_flags)))
+                         MYF(0)))
     {
       _ma_check_print_error(param,"Not enough memory!");
       goto err;
@@ -4546,7 +4556,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
       sort_param[i].key_length+=ft_max_word_len_for_sort-HA_FT_MAXBYTELEN;
       init_alloc_root(PSI_INSTRUMENT_ME, &sort_param[i].wordroot,
                       FTPARSER_MEMROOT_ALLOC_SIZE, 0,
-                      MYF(param->malloc_flags));
+                      MYF(MY_THREAD_SPECIFIC));
     }
   }
   sort_info.total_keys=i;
@@ -6105,7 +6115,7 @@ static MA_SORT_KEY_BLOCKS *alloc_key_blocks(HA_CHECK *param, uint blocks,
   if (!(block= (MA_SORT_KEY_BLOCKS*)
         my_malloc(PSI_INSTRUMENT_ME,
                   (sizeof(MA_SORT_KEY_BLOCKS)+buffer_length+IO_SIZE)*blocks,
-                  MYF(param->malloc_flags))))
+                  MYF(MY_THREAD_SPECIFIC))))
   {
     _ma_check_print_error(param,"Not enough memory for sort-key-blocks");
     return(0);
diff --git a/storage/maria/ma_control_file.c b/storage/maria/ma_control_file.c
index 21befb70..03513c46 100644
--- a/storage/maria/ma_control_file.c
+++ b/storage/maria/ma_control_file.c
@@ -272,7 +272,8 @@ static int lock_control_file(const char *name, my_bool do_retry)
 
 CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
                                         my_bool print_error,
-                                        my_bool wait_for_lock)
+                                        my_bool wait_for_lock,
+                                        int open_flags)
 {
   uchar buffer[CF_MAX_SIZE];
   char name[FN_REFLEN], errmsg_buff[256];
@@ -280,7 +281,6 @@ CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
     " file is probably in use by another process";
   uint new_cf_create_time_size, new_cf_changeable_size, new_block_size;
   my_off_t file_size;
-  int open_flags= O_BINARY | /*O_DIRECT |*/ O_RDWR | O_CLOEXEC;
   int error= CONTROL_FILE_UNKNOWN_ERROR;
   DBUG_ENTER("ma_control_file_open");
 
@@ -460,6 +460,15 @@ err:
   DBUG_RETURN(error);
 }
 
+/*
+  The most common way to open the control file when writing tests
+*/
+
+CONTROL_FILE_ERROR ma_control_file_open_or_create()
+{
+  return ma_control_file_open(TRUE, TRUE, TRUE,
+                              control_file_open_flags);
+}
 
 /*
   Write information durably to the control file; stores this information into
@@ -630,7 +639,7 @@ my_bool print_aria_log_control()
   int error= CONTROL_FILE_UNKNOWN_ERROR;
   uint recovery_fails;
   File file;
-  DBUG_ENTER("ma_control_file_open");
+  DBUG_ENTER("print_aria_log_control");
 
   if (fn_format(name, CONTROL_FILE_BASE_NAME,
                 maria_data_root, "", MYF(MY_WME)) == NullS)
diff --git a/storage/maria/ma_control_file.h b/storage/maria/ma_control_file.h
index 40428f66..b2b95e36 100644
--- a/storage/maria/ma_control_file.h
+++ b/storage/maria/ma_control_file.h
@@ -68,10 +68,13 @@ typedef enum enum_control_file_error {
 
 CONTROL_FILE_ERROR ma_control_file_open(my_bool create_if_missing,
                                         my_bool print_error,
-                                        my_bool wait_for_lock);
+                                        my_bool wait_for_lock,
+                                        int open_flags);
 int ma_control_file_write_and_force(LSN last_checkpoint_lsn_arg,
                                     uint32 last_logno_arg, TrID max_trid_arg,
                                     uint8 recovery_failures_arg);
+/* For simple programs that creates Aria files*/
+CONTROL_FILE_ERROR ma_control_file_open_or_create();
 int ma_control_file_end(void);
 my_bool ma_control_file_inited(void);
 my_bool print_aria_log_control(void);
diff --git a/storage/maria/ma_create.c b/storage/maria/ma_create.c
index 7fd739d1..9ce48ae9 100644
--- a/storage/maria/ma_create.c
+++ b/storage/maria/ma_create.c
@@ -101,7 +101,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
 
   DBUG_ASSERT(maria_inited);
 
-  if (flags & HA_CREATE_TMP_TABLE)
+  if ((flags & HA_CREATE_TMP_TABLE) && !(flags & HA_CREATE_GLOBAL_TMP_TABLE))
     common_flag|= MY_THREAD_SPECIFIC;
 
   if (!ci)
diff --git a/storage/maria/ma_dynrec.c b/storage/maria/ma_dynrec.c
index 33f238d9..fed1bf41 100644
--- a/storage/maria/ma_dynrec.c
+++ b/storage/maria/ma_dynrec.c
@@ -1488,7 +1488,6 @@ int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
   uchar *UNINIT_VAR(to);
   uint UNINIT_VAR(left_length);
   MARIA_SHARE *share= info->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
   DBUG_ENTER("_ma_read_dynamic_record");
 
   if (filepos == HA_OFFSET_ERROR)
@@ -1525,7 +1524,8 @@ int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
       {
         if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
                              block_info.rec_len +
-                             share->base.extra_rec_buff_size, flag))
+                             share->base.extra_rec_buff_size,
+                             MY_WME | share->malloc_flag))
           goto err;
       }
       to= info->rec_buff;
@@ -1784,7 +1784,6 @@ int _ma_read_rnd_dynamic_record(MARIA_HA *info,
   uchar *UNINIT_VAR(to);
   MARIA_BLOCK_INFO block_info;
   MARIA_SHARE *share= info->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
   DBUG_ENTER("_ma_read_rnd_dynamic_record");
 
 #ifdef MARIA_EXTERNAL_LOCKING
@@ -1875,7 +1874,8 @@ int _ma_read_rnd_dynamic_record(MARIA_HA *info,
       {
 	if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
                              block_info.rec_len +
-                             share->base.extra_rec_buff_size, flag))
+                             share->base.extra_rec_buff_size,
+                             MY_WME | share->malloc_flag))
 	  goto err;
       }
       to= info->rec_buff;
diff --git a/storage/maria/ma_extra.c b/storage/maria/ma_extra.c
index 425cb421..9ffc551c 100644
--- a/storage/maria/ma_extra.c
+++ b/storage/maria/ma_extra.c
@@ -239,25 +239,17 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
       break;
 
     /* we're going to modify pieces of the state, stall Checkpoint */
-    mysql_mutex_lock(&share->intern_lock);
     if (info->lock_type == F_UNLCK)
     {
-      mysql_mutex_unlock(&share->intern_lock);
       error= 1;					/* Not possibly if not lock */
       break;
     }
+    mysql_mutex_lock(&share->intern_lock);
     if (maria_is_any_key_active(share->state.key_map))
     {
-      MARIA_KEYDEF *key= share->keyinfo;
-      uint i;
-      for (i =0 ; i < share->base.keys ; i++,key++)
-      {
-        if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
-        {
-          maria_clear_key_active(share->state.key_map, i);
-          info->update|= HA_STATE_CHANGED;
-        }
-      }
+      if (share->state.key_map != *(ulonglong*)extra_arg)
+        info->update|= HA_STATE_CHANGED;
+      share->state.key_map= *(ulonglong*)extra_arg;
 
       if (!share->changed)
       {
@@ -542,7 +534,7 @@ int maria_reset(MARIA_HA *info)
 {
   int error= 0;
   MARIA_SHARE *share= info->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf flag= MY_WME | share->malloc_flag;
   DBUG_ENTER("maria_reset");
   /*
     Free buffers and reset the following flags:
@@ -601,6 +593,20 @@ uint _ma_file_callback_to_id(void *callback_data)
   return share ? share->id : 0;
 }
 
+/*
+  Disable MY_WAIT_IF_FULL flag for temporary tables
+
+  Temporary tables does not have MY_WAIT_IF_FULL in share->write_flags
+*/
+
+uint _ma_write_flags_callback(void *callback_data, myf flags)
+{
+  MARIA_SHARE *share= (MARIA_SHARE*) callback_data;
+  if (share)
+    flags&= ~(~share->write_flag & MY_WAIT_IF_FULL);
+  return flags;
+}
+
 
 /**
    @brief flushes the data and/or index file of a table
diff --git a/storage/maria/ma_loghandler.c b/storage/maria/ma_loghandler.c
index bfeb5e0c..05347b2d 100644
--- a/storage/maria/ma_loghandler.c
+++ b/storage/maria/ma_loghandler.c
@@ -1099,10 +1099,6 @@ static TRANSLOG_FILE *get_current_logfile()
 uchar	maria_trans_file_magic[]=
 { (uchar) 254, (uchar) 254, (uchar) 11, '\001', 'M', 'A', 'R', 'I', 'A',
  'L', 'O', 'G' };
-#define LOG_HEADER_DATA_SIZE (sizeof(maria_trans_file_magic) + \
-                              8 + 4 + 4 + 4 + 2 + 3 + \
-                              LSN_STORE_SIZE)
-
 
 /*
   Write log file page header in the just opened new log file
@@ -3605,6 +3601,9 @@ static my_bool translog_is_LSN_chunk(uchar type)
   @retval 1 Error
 */
 
+/* Stack size 26120 from clang */
+PRAGMA_DISABLE_CHECK_STACK_FRAME
+
 my_bool translog_init_with_table(const char *directory,
                                  uint32 log_file_max_size,
                                  uint32 server_version,
@@ -4238,6 +4237,7 @@ err:
   ma_message_no_user(0, "log initialization failed");
   DBUG_RETURN(1);
 }
+PRAGMA_REENABLE_CHECK_STACK_FRAME
 
 
 /*
diff --git a/storage/maria/ma_loghandler.h b/storage/maria/ma_loghandler.h
index 3e5c58a8..db592adf 100644
--- a/storage/maria/ma_loghandler.h
+++ b/storage/maria/ma_loghandler.h
@@ -534,5 +534,13 @@ typedef enum
 } enum_maria_sync_log_dir;
 extern ulong sync_log_dir;
 
+/* sizeof(maria_trans_file_magic) */
+#define LOG_MAGIC_SIZE 12
+#define LOG_HEADER_DATA_SIZE (LOG_MAGIC_SIZE + \
+                              8 + 4 + 4 + 4 + 2 + 3 + \
+                              LSN_STORE_SIZE)
+/* Flags when creating aria_log_control */
+#define control_file_open_flags (O_BINARY | /*O_DIRECT |*/ O_RDWR | O_CLOEXEC)
+
 C_MODE_END
 #endif
diff --git a/storage/maria/ma_open.c b/storage/maria/ma_open.c
index ad98a534..35578877 100644
--- a/storage/maria/ma_open.c
+++ b/storage/maria/ma_open.c
@@ -94,7 +94,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share,
   uint errpos;
   MARIA_HA info,*m_info;
   my_bitmap_map *changed_fields_bitmap;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
+  myf flag= MY_WME | share->malloc_flag;
   DBUG_ENTER("maria_clone_internal");
 
   errpos= 0;
@@ -171,7 +171,6 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share,
   mysql_mutex_lock(&share->intern_lock);
   info.read_record= share->read_record;
   share->reopen++;
-  share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
     info.lock_type=F_RDLCK;
@@ -266,7 +265,9 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
   uint i,j,len,errpos,head_length,base_pos,keys, realpath_err,
     key_parts,base_key_parts,unique_key_parts,fulltext_keys,uniques;
   uint internal_table= MY_TEST(open_flags & HA_OPEN_INTERNAL_TABLE);
-  myf common_flag= open_flags & HA_OPEN_TMP_TABLE ? MY_THREAD_SPECIFIC : 0;
+  myf common_flag= (((open_flags & HA_OPEN_TMP_TABLE) &&
+                     !(open_flags & HA_OPEN_GLOBAL_TMP_TABLE)) ?
+                    MY_THREAD_SPECIFIC : 0);
   uint file_version;
   size_t info_length;
   char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
@@ -984,11 +985,13 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
       share->options|= HA_OPTION_READ_ONLY_DATA;
     share->is_log_table= FALSE;
 
+    share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
     if (open_flags & HA_OPEN_TMP_TABLE || share->options & HA_OPTION_TMP_TABLE)
     {
-      common_flag|= MY_THREAD_SPECIFIC;
       share->options|= HA_OPTION_TMP_TABLE;
       share->temporary= share->delay_key_write= 1;
+      share->malloc_flag=
+        (open_flags & HA_OPEN_GLOBAL_TMP_TABLE) ? 0 : MY_THREAD_SPECIFIC;
       share->write_flag=MYF(MY_NABP);
       share->w_locks++;			/* We don't have to update status */
       share->tot_locks++;
@@ -1555,6 +1558,9 @@ uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite)
      @retval 1      Error
 */
 
+/* Stack size 26376 from clang */
+PRAGMA_DISABLE_CHECK_STACK_FRAME
+
 uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite)
 {
   uchar  buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE];
@@ -1629,6 +1635,7 @@ uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite)
              MYF(MY_NABP));
   DBUG_RETURN(res != 0);
 }
+PRAGMA_REENABLE_CHECK_STACK_FRAME
 
 
 static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state, myf flag)
@@ -2046,9 +2053,8 @@ void _ma_set_index_pagecache_callbacks(PAGECACHE_FILE *file,
 
 int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share)
 {
-  myf flags= (share->mode & O_NOFOLLOW) ? MY_NOSYMLINKS | MY_WME : MY_WME;
-  if (share->temporary)
-    flags|= MY_THREAD_SPECIFIC;
+  myf flags= ((share->mode & O_NOFOLLOW) ? MY_NOSYMLINKS | MY_WME : MY_WME) |
+    share->malloc_flag;
   DEBUG_SYNC_C("mi_open_datafile");
   info->dfile.file= share->bitmap.file.file=
     mysql_file_open(key_file_dfile, share->data_file_name.str,
diff --git a/storage/maria/ma_packrec.c b/storage/maria/ma_packrec.c
index 19783423..57926ee4 100644
--- a/storage/maria/ma_packrec.c
+++ b/storage/maria/ma_packrec.c
@@ -1417,7 +1417,6 @@ uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
   uchar *header= info->header;
   uint head_length,UNINIT_VAR(ref_length);
   MARIA_SHARE *share= maria->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
 
   if (file >= 0)
   {
@@ -1444,7 +1443,8 @@ uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
     */
     if (_ma_alloc_buffer(rec_buff_p, rec_buff_size_p,
                          info->rec_len + info->blob_len +
-                         share->base.extra_rec_buff_size, flag))
+                         share->base.extra_rec_buff_size,
+                         MY_WME | share->malloc_flag))
       return BLOCK_FATAL_ERROR;			/* not enough memory */
     bit_buff->blob_pos= *rec_buff_p + info->rec_len;
     bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
@@ -1586,7 +1586,6 @@ _ma_mempack_get_block_info(MARIA_HA *maria,
                            uchar *header)
 {
   MARIA_SHARE *share= maria->s;
-  myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
 
   header+= read_pack_length((uint) share->pack.version, header,
                             &info->rec_len);
@@ -1596,7 +1595,8 @@ _ma_mempack_get_block_info(MARIA_HA *maria,
                               &info->blob_len);
     /* _ma_alloc_rec_buff sets my_errno on error */
     if (_ma_alloc_buffer(rec_buff_p, rec_buff_size_p,
-                      info->blob_len + share->base.extra_rec_buff_size, flag))
+                      info->blob_len + share->base.extra_rec_buff_size,
+                      MY_WME | share->malloc_flag))
       return 0;				/* not enough memory */
     bit_buff->blob_pos= *rec_buff_p;
     bit_buff->blob_end= *rec_buff_p + info->blob_len;
diff --git a/storage/maria/ma_pagecache.c b/storage/maria/ma_pagecache.c
index 144b10a8..49981e79 100644
--- a/storage/maria/ma_pagecache.c
+++ b/storage/maria/ma_pagecache.c
@@ -687,6 +687,8 @@ static my_bool pagecache_fwrite(PAGECACHE *pagecache,
   /* FIXME: ENGINE=Aria occasionally writes uninitialized data */
   __msan_unpoison(args.page, pagecache->block_size);
 #endif
+  /* Reset MY_WAIT_IF_FULL for temporary tables */
+  flags= _ma_write_flags_callback(filedesc->callback_data, flags);
   res= (int)my_pwrite(filedesc->file, args.page, pagecache->block_size,
                  ((my_off_t) pageno << pagecache->shift), flags);
   (*filedesc->post_write_hook)(res, &args);
diff --git a/storage/maria/ma_recovery.c b/storage/maria/ma_recovery.c
index 006c8bef..df9b2024 100644
--- a/storage/maria/ma_recovery.c
+++ b/storage/maria/ma_recovery.c
@@ -1163,11 +1163,12 @@ end:
 /*
   The record may come from REPAIR, ALTER TABLE ENABLE KEYS, OPTIMIZE.
 */
+
 prototype_redo_exec_hook(REDO_REPAIR_TABLE)
 {
   int error= 1;
   MARIA_HA *info;
-  HA_CHECK param;
+  HA_CHECK *param;
   char *name;
   my_bool quick_repair;
   DBUG_ENTER("exec_REDO_LOGREC_REDO_REPAIR_TABLE");
@@ -1199,35 +1200,39 @@ prototype_redo_exec_hook(REDO_REPAIR_TABLE)
   */
   tprint(tracef, "   repairing...\n");
 
-  maria_chk_init(&param);
-  param.isam_file_name= name= info->s->open_file_name.str;
-  param.testflag= uint8korr(rec->header + FILEID_STORE_SIZE);
-  param.tmpdir= maria_tmpdir;
-  param.max_trid= max_long_trid;
+  if (!(param= my_malloc(PSI_INSTRUMENT_ME, sizeof(*param), MYF(MY_WME))))
+    DBUG_RETURN(0);
+
+  maria_chk_init(param);
+  param->isam_file_name= name= info->s->open_file_name.str;
+  param->testflag= uint8korr(rec->header + FILEID_STORE_SIZE);
+  param->tmpdir= maria_tmpdir;
+  param->max_trid= max_long_trid;
   DBUG_ASSERT(maria_tmpdir);
 
   info->s->state.key_map= uint8korr(rec->header + FILEID_STORE_SIZE + 8);
-  quick_repair= MY_TEST(param.testflag & T_QUICK);
+  quick_repair= MY_TEST(param->testflag & T_QUICK);
 
-  if (param.testflag & T_REP_PARALLEL)
+  if (param->testflag & T_REP_PARALLEL)
   {
-    if (maria_repair_parallel(&param, info, name, quick_repair))
+    if (maria_repair_parallel(param, info, name, quick_repair))
       goto end;
   }
-  else if (param.testflag & T_REP_BY_SORT)
+  else if (param->testflag & T_REP_BY_SORT)
   {
-    if (maria_repair_by_sort(&param, info, name, quick_repair))
+    if (maria_repair_by_sort(param, info, name, quick_repair))
       goto end;
   }
-  else if (maria_repair(&param, info, name, quick_repair))
+  else if (maria_repair(param, info, name, quick_repair))
     goto end;
 
   if (_ma_update_state_lsns(info->s, rec->lsn, trnman_get_min_safe_trid(),
-                            TRUE, !(param.testflag & T_NO_CREATE_RENAME_LSN)))
+                            TRUE, !(param->testflag & T_NO_CREATE_RENAME_LSN)))
     goto end;
   error= 0;
 
 end:
+  my_free(param);
   DBUG_RETURN(error);
 }
 
@@ -2579,6 +2584,8 @@ prototype_undo_exec_hook(UNDO_BULK_INSERT)
   return error;
 }
 
+/* Stack size 18776 in clang. Ok as this is during recover */
+PRAGMA_DISABLE_CHECK_STACK_FRAME
 
 static int run_redo_phase(LSN lsn, LSN lsn_end, enum maria_apply_log_way apply)
 {
@@ -2822,6 +2829,7 @@ err:
   translog_free_record_header(&rec);
   DBUG_RETURN(1);
 }
+PRAGMA_REENABLE_CHECK_STACK_FRAME
 
 
 /**
diff --git a/storage/maria/ma_rt_test.c b/storage/maria/ma_rt_test.c
index 3af7d938..17145231 100644
--- a/storage/maria/ma_rt_test.c
+++ b/storage/maria/ma_rt_test.c
@@ -101,7 +101,7 @@ int main(int argc, char *argv[])
   if (maria_init() ||
       (init_pagecache(maria_pagecache, maria_block_size * 16, 0, 0,
                       maria_block_size, 0, MY_WME) == 0) ||
-      ma_control_file_open(TRUE, TRUE, TRUE) ||
+      ma_control_file_open_or_create() ||
       (init_pagecache(maria_log_pagecache,
                       TRANSLOG_PAGECACHE_SIZE, 0, 0,
                       TRANSLOG_PAGE_SIZE, 0, MY_WME) == 0) ||
diff --git a/storage/maria/ma_test1.c b/storage/maria/ma_test1.c
index 22f80ca2..a14679d3 100644
--- a/storage/maria/ma_test1.c
+++ b/storage/maria/ma_test1.c
@@ -81,7 +81,7 @@ int main(int argc,char *argv[])
   if (maria_init() ||
       (init_pagecache(maria_pagecache, maria_block_size * 16, 0, 0,
                       maria_block_size, 0, MY_WME) == 0) ||
-      ma_control_file_open(TRUE, TRUE, TRUE) ||
+      ma_control_file_open_or_create() ||
       (init_pagecache(maria_log_pagecache,
                       TRANSLOG_PAGECACHE_SIZE, 0, 0,
                       TRANSLOG_PAGE_SIZE, 0, MY_WME) == 0) ||
diff --git a/storage/maria/ma_test2.c b/storage/maria/ma_test2.c
index 66284653..400e6193 100644
--- a/storage/maria/ma_test2.c
+++ b/storage/maria/ma_test2.c
@@ -90,7 +90,7 @@ int main(int argc, char *argv[])
   if (maria_init() ||
       (init_pagecache(maria_pagecache, pagecache_size, 0, 0,
 		      maria_block_size, 0, MY_WME) == 0) ||
-      ma_control_file_open(TRUE, TRUE, TRUE) ||
+      ma_control_file_open_or_create() ||
       (init_pagecache(maria_log_pagecache,
 		      TRANSLOG_PAGECACHE_SIZE, 0, 0,
 		      TRANSLOG_PAGE_SIZE, 0, MY_WME) == 0) ||
diff --git a/storage/maria/maria_def.h b/storage/maria/maria_def.h
index 91e1b10a..b12f21e3 100644
--- a/storage/maria/maria_def.h
+++ b/storage/maria/maria_def.h
@@ -754,6 +754,11 @@ typedef struct st_maria_share
   ulong max_pack_length;
   ulong state_diff_length;
   uint rec_reflength;			/* rec_reflength in use now */
+  /*
+    Extra flag to use for my_malloc(); set to MY_THREAD_SPECIFIC for temporary
+    tables whose memory allocation should be accounted to the current THD.
+  */
+  uint malloc_flag;
   uint keypage_header;
   uint32 ftkeys;			/* Number of distinct full-text keys
 						   + 1 */
@@ -1740,6 +1745,7 @@ extern my_bool ma_yield_and_check_if_killed(MARIA_HA *info, int inx);
 extern my_bool ma_killed_standalone(MARIA_HA *);
 
 extern uint _ma_file_callback_to_id(void *callback_data);
+extern uint _ma_write_flags_callback(void *callback_data, myf flags);
 extern void free_maria_share(MARIA_SHARE *share);
 
 static inline void unmap_file(MARIA_HA *info __attribute__((unused)))
diff --git a/storage/maria/test_ma_backup.c b/storage/maria/test_ma_backup.c
index c57ec6ec..5cb2b074 100644
--- a/storage/maria/test_ma_backup.c
+++ b/storage/maria/test_ma_backup.c
@@ -47,7 +47,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   if (maria_init() ||
       (init_pagecache(maria_pagecache, maria_block_size * 2000, 0, 0,
                       maria_block_size, 0, MY_WME) == 0) ||
-      ma_control_file_open(TRUE, TRUE, TRUE) ||
+      ma_control_file_open_or_create() ||
       (init_pagecache(maria_log_pagecache,
                       TRANSLOG_PAGECACHE_SIZE, 0, 0,
                       TRANSLOG_PAGE_SIZE, 0, MY_WME) == 0) ||
diff --git a/storage/maria/unittest/CMakeLists.txt b/storage/maria/unittest/CMakeLists.txt
index a2da1507..a7b34410 100644
--- a/storage/maria/unittest/CMakeLists.txt
+++ b/storage/maria/unittest/CMakeLists.txt
@@ -15,7 +15,7 @@
 
 INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/zlib
                     ${CMAKE_SOURCE_DIR}/unittest/mytap)
-LINK_LIBRARIES(aria myisam mytap mysys dbug strings ${ZLIB_LIBRARY})
+LINK_LIBRARIES(aria myisam mytap mysys dbug strings ${ZLIB_LIBRARIES})
 
 MY_ADD_TESTS(ma_control_file trnman)
 
diff --git a/storage/maria/unittest/ma_control_file-t.c b/storage/maria/unittest/ma_control_file-t.c
index 859d5514..fdbe86de 100644
--- a/storage/maria/unittest/ma_control_file-t.c
+++ b/storage/maria/unittest/ma_control_file-t.c
@@ -114,7 +114,7 @@ static CONTROL_FILE_ERROR local_ma_control_file_open(void)
 {
   CONTROL_FILE_ERROR error;
   error_handler_hook= my_ignore_message;
-  error= ma_control_file_open(TRUE, TRUE, TRUE);
+  error= ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags);
   error_handler_hook= default_error_handler_hook;
   return error;
 }
diff --git a/storage/maria/unittest/ma_test_loghandler-t.c b/storage/maria/unittest/ma_test_loghandler-t.c
index ccda66af..0a1d396e 100644
--- a/storage/maria/unittest/ma_test_loghandler-t.c
+++ b/storage/maria/unittest/ma_test_loghandler-t.c
@@ -143,6 +143,8 @@ static my_bool read_and_check_content(TRANSLOG_HEADER_BUFFER *rec,
 }
 
 
+PRAGMA_DISABLE_CHECK_STACK_FRAME
+
 int main(int argc __attribute__((unused)), char *argv[])
 {
   uint32 i;
@@ -197,7 +199,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
@@ -664,5 +666,6 @@ err:
   my_end(0);
   return(MY_TEST(exit_status()));
 }
+PRAGMA_REENABLE_CHECK_STACK_FRAME
 
 #include "../ma_check_standalone.h"
diff --git a/storage/maria/unittest/ma_test_loghandler_first_lsn-t.c b/storage/maria/unittest/ma_test_loghandler_first_lsn-t.c
index 21f6b7d7..5c4045cc 100644
--- a/storage/maria/unittest/ma_test_loghandler_first_lsn-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_first_lsn-t.c
@@ -66,7 +66,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE,TRUE))
+  if (ma_control_file_open(TRUE, TRUE,TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_max_lsn-t.c b/storage/maria/unittest/ma_test_loghandler_max_lsn-t.c
index 391d7851..eedeb9d7 100644
--- a/storage/maria/unittest/ma_test_loghandler_max_lsn-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_max_lsn-t.c
@@ -64,7 +64,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_multigroup-t.c b/storage/maria/unittest/ma_test_loghandler_multigroup-t.c
index e8e114dd..b0e1be8f 100644
--- a/storage/maria/unittest/ma_test_loghandler_multigroup-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_multigroup-t.c
@@ -280,7 +280,7 @@ int main(int argc __attribute__((unused)), char *argv[])
 
   bzero(long_tr_id, 6);
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
@@ -443,7 +443,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   end_pagecache(&pagecache, 1);
   ma_control_file_end();
 
-  if (ma_control_file_open(TRUE,TRUE,TRUE))
+  if (ma_control_file_open(TRUE,TRUE,TRUE, control_file_open_flags))
   {
     fprintf(stderr, "pass2: Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_multithread-t.c b/storage/maria/unittest/ma_test_loghandler_multithread-t.c
index be6046ab..9b7e239b 100644
--- a/storage/maria/unittest/ma_test_loghandler_multithread-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_multithread-t.c
@@ -331,7 +331,7 @@ int main(int argc __attribute__((unused)),
     exit(1);
   }
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_noflush-t.c b/storage/maria/unittest/ma_test_loghandler_noflush-t.c
index 46b3a8e7..28cac2ee 100644
--- a/storage/maria/unittest/ma_test_loghandler_noflush-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_noflush-t.c
@@ -65,7 +65,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_nologs-t.c b/storage/maria/unittest/ma_test_loghandler_nologs-t.c
index b95d8bee..a7c526b2 100644
--- a/storage/maria/unittest/ma_test_loghandler_nologs-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_nologs-t.c
@@ -66,7 +66,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
@@ -139,7 +139,7 @@ int main(int argc __attribute__((unused)), char *argv[])
     }
   }
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_pagecache-t.c b/storage/maria/unittest/ma_test_loghandler_pagecache-t.c
index 892a773b..4ecc8f1f 100644
--- a/storage/maria/unittest/ma_test_loghandler_pagecache-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_pagecache-t.c
@@ -69,7 +69,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);
diff --git a/storage/maria/unittest/ma_test_loghandler_purge-t.c b/storage/maria/unittest/ma_test_loghandler_purge-t.c
index 07b50f19..b26a2f99 100644
--- a/storage/maria/unittest/ma_test_loghandler_purge-t.c
+++ b/storage/maria/unittest/ma_test_loghandler_purge-t.c
@@ -67,7 +67,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   }
 #endif
 
-  if (ma_control_file_open(TRUE, TRUE, TRUE))
+  if (ma_control_file_open(TRUE, TRUE, TRUE, control_file_open_flags))
   {
     fprintf(stderr, "Can't init control file (%d)\n", errno);
     exit(1);