Merge 10.4 into 10.5

9 files changed, 84 insertions, 63 deletions

diff --git a/storage/maria/ma_bitmap.c b/storage/maria/ma_bitmap.c
index bf0f97984a7..49604fa43f6 100644
--- a/storage/maria/ma_bitmap.c
+++ b/storage/maria/ma_bitmap.c
@@ -232,15 +232,16 @@ 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);
   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 */
   size*= 2;
 #endif
 
-  if (!((bitmap->map= (uchar*) my_malloc(PSI_INSTRUMENT_ME, size, MYF(MY_WME)))) ||
+  if (!((bitmap->map= (uchar*) my_malloc(PSI_INSTRUMENT_ME, size, flag))) ||
       my_init_dynamic_array(PSI_INSTRUMENT_ME, &bitmap->pinned_pages,
-                            sizeof(MARIA_PINNED_PAGE), 1, 1, MYF(0)))
+                            sizeof(MARIA_PINNED_PAGE), 1, 1, flag))
     return 1;
 
   bitmap->share= share;
diff --git a/storage/maria/ma_blockrec.c b/storage/maria/ma_blockrec.c
index 067dbaa8233..ad4ffa349d0 100644
--- a/storage/maria/ma_blockrec.c
+++ b/storage/maria/ma_blockrec.c
@@ -488,10 +488,11 @@ 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);
   uint default_extents;
   DBUG_ENTER("_ma_init_block_record");
 
-  if (!my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME),
+  if (!my_multi_malloc(PSI_INSTRUMENT_ME, flag,
                        &row->empty_bits, share->base.pack_bytes,
                        &row->field_lengths,
                        share->base.max_field_lengths + 2,
@@ -531,13 +532,13 @@ my_bool _ma_init_block_record(MARIA_HA *info)
                      BLOB_SEGMENT_MIN_SIZE));
 
   if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &info->bitmap_blocks,
-                            sizeof(MARIA_BITMAP_BLOCK), default_extents,
-                            64, MYF(0)))
+                            sizeof(MARIA_BITMAP_BLOCK),
+                            default_extents, 64, flag))
     goto err;
   info->cur_row.extents_buffer_length= default_extents * ROW_EXTENT_SIZE;
   if (!(info->cur_row.extents= my_malloc(PSI_INSTRUMENT_ME,
                                          info->cur_row.extents_buffer_length,
-                                         MYF(MY_WME))))
+                                         flag)))
     goto err;
 
   info->row_base_length= share->base_length;
@@ -2647,6 +2648,7 @@ 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;
@@ -2713,7 +2715,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))
+                       row->head_length, myflag))
     DBUG_RETURN(1);
 
   tmp_data_used= 0;                 /* Either 0 or last used uchar in 'data' */
@@ -4732,6 +4734,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);
   DBUG_ENTER("_ma_read_block_record2");
 
   start_of_data= data;
@@ -4777,7 +4780,7 @@ int _ma_read_block_record2(MARIA_HA *info, uchar *record,
     if (cur_row->extents_buffer_length < row_extent_size &&
         _ma_alloc_buffer(&cur_row->extents,
                          &cur_row->extents_buffer_length,
-                         row_extent_size))
+                         row_extent_size, myflag))
       DBUG_RETURN(my_errno);
     memcpy(cur_row->extents, data, ROW_EXTENT_SIZE);
     data+= ROW_EXTENT_SIZE;
@@ -4958,7 +4961,7 @@ int _ma_read_block_record2(MARIA_HA *info, uchar *record,
         cur_row->blob_length= blob_lengths;
         DBUG_PRINT("info", ("Total blob length: %lu", blob_lengths));
         if (_ma_alloc_buffer(&info->blob_buff, &info->blob_buff_size,
-                             blob_lengths))
+                             blob_lengths, myflag))
           DBUG_RETURN(my_errno);
         blob_buffer= info->blob_buff;
       }
@@ -5064,6 +5067,7 @@ 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,
@@ -5087,7 +5091,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))
+                         row_extents_size, myflag))
       DBUG_RETURN(1);
     memcpy(info->cur_row.extents, data, ROW_EXTENT_SIZE);
     data+= ROW_EXTENT_SIZE;
@@ -5257,6 +5261,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);
   DBUG_ENTER("_ma_scan_init_block_record");
   DBUG_ASSERT(info->dfile.file == share->bitmap.file.file);
 
@@ -5267,7 +5272,7 @@ my_bool _ma_scan_init_block_record(MARIA_HA *info)
   if (!(info->scan.bitmap_buff ||
         ((info->scan.bitmap_buff=
           (uchar *) my_malloc(PSI_INSTRUMENT_ME, share->block_size * 2,
-                              MYF(MY_WME))))))
+                              flag)))))
     DBUG_RETURN(1);
   info->scan.page_buff= info->scan.bitmap_buff + share->block_size;
   info->scan.bitmap_end= info->scan.bitmap_buff + share->bitmap.max_total_size;
diff --git a/storage/maria/ma_check.c b/storage/maria/ma_check.c
index c63b5319346..d63e7bee3c1 100644
--- a/storage/maria/ma_check.c
+++ b/storage/maria/ma_check.c
@@ -1279,6 +1279,7 @@ 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;
@@ -1386,7 +1387,7 @@ 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))
+                               share->base.extra_rec_buff_size, myflag))
 
           {
             _ma_check_print_error(param,
@@ -2720,7 +2721,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
         (uchar *) my_malloc(PSI_INSTRUMENT_ME, (uint)
                             share->base.default_rec_buff_size, MYF(0))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
-                       share->base.default_rec_buff_size))
+                       share->base.default_rec_buff_size, MYF(0)))
   {
     _ma_check_print_error(param, "Not enough memory for extra record");
     goto err;
@@ -3813,7 +3814,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
                            (size_t) share->base.default_rec_buff_size,
                            MYF(0))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
-                       share->base.default_rec_buff_size))
+                       share->base.default_rec_buff_size, MYF(0)))
   {
     _ma_check_print_error(param, "Not enough memory for extra record");
     goto err;
@@ -4456,7 +4457,7 @@ 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));
     if (_ma_alloc_buffer(&sort_param[i].rec_buff, &sort_param[i].rec_buff_size,
-                         share->base.default_rec_buff_size))
+                         share->base.default_rec_buff_size, MYF(0)))
     {
       _ma_check_print_error(param,"Not enough memory!");
       goto err;
@@ -5188,7 +5189,7 @@ static int sort_get_next_record(MARIA_SORT_PARAM *sort_param)
 	    if (_ma_alloc_buffer(&sort_param->rec_buff,
                                  &sort_param->rec_buff_size,
                                  block_info.rec_len +
-                                 share->base.extra_rec_buff_size))
+                                 share->base.extra_rec_buff_size, MYF(0)))
 
 	    {
 	      if (param->max_record_length >= block_info.rec_len)
diff --git a/storage/maria/ma_create.c b/storage/maria/ma_create.c
index abac01d87a7..91344a835df 100644
--- a/storage/maria/ma_create.c
+++ b/storage/maria/ma_create.c
@@ -64,10 +64,10 @@ int maria_create(const char *name, enum data_file_type datafile_type,
                  uint uniques, MARIA_UNIQUEDEF *uniquedefs,
                  MARIA_CREATE_INFO *ci,uint flags)
 {
-  register uint i,j;
+  uint i,j;
   File UNINIT_VAR(dfile), UNINIT_VAR(file);
   int errpos,save_errno, create_mode= O_RDWR | O_TRUNC, res;
-  myf create_flag;
+  myf create_flag, common_flag= MY_WME, sync_dir= 0;
   uint length,max_key_length,packed,pack_bytes,pointer,real_length_diff,
        key_length,info_length,key_segs,options,min_key_length,
        base_pos,long_varchar_count,
@@ -93,7 +93,6 @@ int maria_create(const char *name, enum data_file_type datafile_type,
   MARIA_CREATE_INFO tmp_create_info;
   my_bool tmp_table= FALSE; /* cache for presence of HA_OPTION_TMP_TABLE */
   my_bool forced_packed;
-  myf     sync_dir=  0;
   uchar   *log_data= NULL;
   my_bool encrypted= ci->encrypted && datafile_type == BLOCK_RECORD;
   my_bool insert_order= MY_TEST(flags & HA_PRESERVE_INSERT_ORDER);
@@ -104,6 +103,9 @@ int maria_create(const char *name, enum data_file_type datafile_type,
 
   DBUG_ASSERT(maria_inited);
 
+  if (flags & HA_CREATE_TMP_TABLE)
+    common_flag|= MY_THREAD_SPECIFIC;
+
   if (!ci)
   {
     bzero((char*) &tmp_create_info,sizeof(tmp_create_info));
@@ -149,7 +151,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
                             (keys + uniques)*HA_MAX_KEY_SEG*sizeof(double) +
                             (keys + uniques)*HA_MAX_KEY_SEG*sizeof(ulong) +
                             sizeof(uint16) * columns,
-                            MYF(MY_WME | MY_ZEROFILL))))
+                            MYF(common_flag | MY_ZEROFILL))))
     DBUG_RETURN(my_errno);
   nulls_per_key_part= (ulong*) (rec_per_key_part +
                                 (keys + uniques) * HA_MAX_KEY_SEG);
@@ -928,7 +930,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
 
   if ((file= mysql_file_create_with_symlink(key_file_kfile, klinkname_ptr,
                                             kfilename, 0, create_mode,
-                                            MYF(MY_WME|create_flag))) < 0)
+                                            MYF(common_flag|create_flag))) < 0)
     goto err;
   errpos=1;
 
@@ -1032,7 +1034,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     if (!(col_order= (MARIA_COLUMNDEF**) my_malloc(PSI_INSTRUMENT_ME,
                                                    share.base.fields *
                                                    sizeof(MARIA_COLUMNDEF*),
-                                                   MYF(MY_WME))))
+                                                   common_flag)))
       goto err;
     for (column= columndef, pos= col_order ;
          column != end_column ;
@@ -1212,8 +1214,8 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     }
     if ((dfile=
          mysql_file_create_with_symlink(key_file_dfile, dlinkname_ptr,
-                                        dfilename, 0, create_mode,
-                                        MYF(MY_WME | create_flag | sync_dir))) < 0)
+                              dfilename, 0, create_mode,
+                              MYF(common_flag | create_flag | sync_dir))) < 0)
       goto err;
     errpos=3;
 
diff --git a/storage/maria/ma_dynrec.c b/storage/maria/ma_dynrec.c
index a6dee74e57b..f36e7dd9363 100644
--- a/storage/maria/ma_dynrec.c
+++ b/storage/maria/ma_dynrec.c
@@ -1485,6 +1485,8 @@ int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
   File file;
   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)
@@ -1515,13 +1517,13 @@ int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
     if (block_of_record++ == 0)			/* First block */
     {
       info->cur_row.total_length= block_info.rec_len;
-      if (block_info.rec_len > (uint) info->s->base.max_pack_length)
+      if (block_info.rec_len > (uint) share->base.max_pack_length)
         goto panic;
-      if (info->s->base.blobs)
+      if (share->base.blobs)
       {
         if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
                              block_info.rec_len +
-                             info->s->base.extra_rec_buff_size))
+                             share->base.extra_rec_buff_size, flag))
           goto err;
       }
       to= info->rec_buff;
@@ -1557,7 +1559,7 @@ int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
         there is no equivalent without seeking. We are at the right
         position already. :(
       */
-      if (info->s->file_read(info, to, block_info.data_len,
+      if (share->file_read(info, to, block_info.data_len,
                              filepos, MYF(MY_NABP)))
         goto panic;
       left_length-=block_info.data_len;
@@ -1780,6 +1782,7 @@ 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
@@ -1870,7 +1873,7 @@ int _ma_read_rnd_dynamic_record(MARIA_HA *info,
       {
 	if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
                              block_info.rec_len +
-                             info->s->base.extra_rec_buff_size))
+                             share->base.extra_rec_buff_size, flag))
 	  goto err;
       }
       to= info->rec_buff;
diff --git a/storage/maria/ma_extra.c b/storage/maria/ma_extra.c
index 042a96efabf..59ee2e00356 100644
--- a/storage/maria/ma_extra.c
+++ b/storage/maria/ma_extra.c
@@ -536,6 +536,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);
   DBUG_ENTER("maria_reset");
   /*
     Free buffers and reset the following flags:
@@ -556,13 +557,13 @@ int maria_reset(MARIA_HA *info)
     {
       info->rec_buff_size= 1;                 /* Force realloc */
       _ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
-                       share->base.default_rec_buff_size);
+                       share->base.default_rec_buff_size, flag);
     }
     if (info->blob_buff_size > MARIA_SMALL_BLOB_BUFFER)
     {
       info->blob_buff_size= 1;                 /* Force realloc */
       _ma_alloc_buffer(&info->blob_buff, &info->blob_buff_size,
-                       MARIA_SMALL_BLOB_BUFFER);
+                       MARIA_SMALL_BLOB_BUFFER, flag);
     }
   }
 #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
diff --git a/storage/maria/ma_open.c b/storage/maria/ma_open.c
index 28c24dc6ed1..9e7106ab5d3 100644
--- a/storage/maria/ma_open.c
+++ b/storage/maria/ma_open.c
@@ -1,5 +1,5 @@
 /* Copyright (C) 2006 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
-   Copyright (c) 2009, 2020, MariaDB Corporation Ab
+   Copyright (c) 2009, 2021, MariaDB Corporation Ab
 
    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
@@ -39,7 +39,7 @@ static my_bool maria_scan_init_dummy(MARIA_HA *info);
 static void maria_scan_end_dummy(MARIA_HA *info);
 static my_bool maria_once_init_dummy(MARIA_SHARE *, File);
 static my_bool maria_once_end_dummy(MARIA_SHARE *);
-static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state);
+static uchar *_ma_state_info_read(uchar *, MARIA_STATE_INFO *, myf);
 
 #define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \
 					pos+=size;}
@@ -98,6 +98,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);
   DBUG_ENTER("maria_clone_internal");
 
   errpos= 0;
@@ -115,7 +116,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share,
   errpos= 5;
 
   /* alloc and set up private structure parts */
-  if (!my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME),
+  if (!my_multi_malloc(PSI_INSTRUMENT_ME, flag,
 		       &m_info,sizeof(MARIA_HA),
 		       &info.blobs,sizeof(MARIA_BLOB)*share->base.blobs,
 		       &info.buff,(share->base.max_key_block_length*2+
@@ -168,7 +169,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share,
   if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &info.pinned_pages,
                             sizeof(MARIA_PINNED_PAGE),
                             MY_MAX(share->base.blobs*2 + 4,
-                                MARIA_MAX_TREE_LEVELS*3), 16, MYF(0)))
+                            MARIA_MAX_TREE_LEVELS*3), 16, flag))
     goto err;
 
 
@@ -204,7 +205,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share,
   /* Allocate buffer for one record */
   /* prerequisites: info->rec_buffer == 0 && info->rec_buff_size == 0 */
   if (_ma_alloc_buffer(&info.rec_buff, &info.rec_buff_size,
-                       share->base.default_rec_buff_size))
+                       share->base.default_rec_buff_size, flag))
     goto err;
 
   bzero(info.rec_buff, share->base.default_rec_buff_size);
@@ -269,6 +270,7 @@ 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;
   uint file_version;
   size_t info_length;
   char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
@@ -349,13 +351,13 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
       DEBUG_SYNC_C("mi_open_kfile");
       if ((kfile=mysql_file_open(key_file_kfile, name_buff,
                                  (open_mode=O_RDWR) | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
-                                 MYF(MY_NOSYMLINKS))) < 0)
+                                 MYF(common_flag | MY_NOSYMLINKS))) < 0)
       {
         if ((errno != EROFS && errno != EACCES) ||
             mode != O_RDONLY ||
             (kfile=mysql_file_open(key_file_kfile, name_buff,
                                    (open_mode=O_RDONLY) | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
-                                   MYF(MY_NOSYMLINKS))) < 0)
+                                   MYF(common_flag | MY_NOSYMLINKS))) < 0)
           goto err;
       }
       errpos= 1;
@@ -465,7 +467,8 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
       Allocate space for header information and for data that is too
       big to keep on stack
     */
-    if (!(disk_cache= my_malloc(PSI_INSTRUMENT_ME, info_length+128, MYF(MY_WME))))
+    if (!(disk_cache= my_malloc(PSI_INSTRUMENT_ME, info_length+128,
+                                MYF(MY_WME | common_flag))))
     {
       my_errno=ENOMEM;
       goto err;
@@ -507,7 +510,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
     }
     share->state_diff_length=len-MARIA_STATE_INFO_SIZE;
 
-    if (!_ma_state_info_read(disk_cache, &share->state))
+    if (!_ma_state_info_read(disk_cache, &share->state, common_flag))
       goto err;
     len= mi_uint2korr(share->state.header.base_info_length);
     if (len != MARIA_BASE_INFO_SIZE)
@@ -648,12 +651,10 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
     share->index_file_name.length=  strlen(index_name);
     share->data_file_name.length=   strlen(data_name);
     share->open_file_name.length=   strlen(name);
-    if (!my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME),
+    if (!my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME | common_flag),
 			 &share,sizeof(*share),
-			 &rec_per_key_part,
-                         sizeof(double) * key_parts,
-                         &nulls_per_key_part,
-                         sizeof(long)* key_parts,
+			 &rec_per_key_part, sizeof(double) * key_parts,
+                         &nulls_per_key_part, sizeof(long)* key_parts,
 			 &share->keyinfo,keys*sizeof(MARIA_KEYDEF),
 			 &share->uniqueinfo,uniques*sizeof(MARIA_UNIQUEDEF),
 			 &share->keyparts,
@@ -983,9 +984,9 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags,
       share->options|= HA_OPTION_READ_ONLY_DATA;
     share->is_log_table= FALSE;
 
-    if (open_flags & HA_OPEN_TMP_TABLE ||
-        (share->options & HA_OPTION_TMP_TABLE))
+    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->write_flag=MYF(MY_NABP);
@@ -1244,13 +1245,13 @@ err:
 */
 
 my_bool _ma_alloc_buffer(uchar **old_addr, size_t *old_size,
-                         size_t new_size)
+                         size_t new_size, myf flag)
 {
   if (*old_size < new_size)
   {
     uchar *addr;
     if (!(addr= (uchar*) my_realloc(PSI_INSTRUMENT_ME, *old_addr, new_size,
-                                    MYF(MY_ALLOW_ZERO_PTR))))
+                                    MYF(MY_ALLOW_ZERO_PTR | flag))))
       return 1;
     *old_addr= addr;
     *old_size= new_size;
@@ -1629,7 +1630,7 @@ uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite)
 }
 
 
-static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state)
+static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state, myf flag)
 {
   uint i,keys,key_parts;
   DBUG_ENTER("_ma_state_info_read");
@@ -1641,7 +1642,7 @@ static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state)
 
   /* Allocate memory for key parts if not already done */
   if (!state->rec_per_key_part &&
-      !my_multi_malloc(PSI_INSTRUMENT_ME, MY_WME,
+      !my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME | flag),
                        &state->rec_per_key_part,
                        sizeof(*state->rec_per_key_part) * key_parts,
                        &state->nulls_per_key_part,
@@ -2044,11 +2045,13 @@ void _ma_set_index_pagecache_callbacks(PAGECACHE_FILE *file,
 
 int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share)
 {
-  myf flags= MY_WME | (share->mode & O_NOFOLLOW ? MY_NOSYMLINKS : 0);
+  myf flags= (share->mode & O_NOFOLLOW) ? MY_NOSYMLINKS | MY_WME : MY_WME;
+  if (share->temporary)
+    flags|= MY_THREAD_SPECIFIC;
   DEBUG_SYNC_C("mi_open_datafile");
   info->dfile.file= share->bitmap.file.file=
     mysql_file_open(key_file_dfile, share->data_file_name.str,
-                    share->mode | O_SHARE | O_CLOEXEC, MYF(flags));
+                    share->mode | O_SHARE | O_CLOEXEC, flags);
   return info->dfile.file >= 0 ? 0 : 1;
 }
 
diff --git a/storage/maria/ma_packrec.c b/storage/maria/ma_packrec.c
index 5eec3faa88f..d7f86a9a7ae 100644
--- a/storage/maria/ma_packrec.c
+++ b/storage/maria/ma_packrec.c
@@ -1416,10 +1416,12 @@ 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)
   {
-    ref_length=maria->s->pack.ref_length;
+    ref_length=share->pack.ref_length;
     /*
       We can't use my_pread() here because _ma_read_rnd_pack_record assumes
       position is ok
@@ -1429,11 +1431,11 @@ uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
       return BLOCK_FATAL_ERROR;
     DBUG_DUMP("header", header, ref_length);
   }
-  head_length= read_pack_length((uint) maria->s->pack.version, header,
+  head_length= read_pack_length((uint) share->pack.version, header,
                                 &info->rec_len);
-  if (maria->s->base.blobs)
+  if (share->base.blobs)
   {
-    head_length+= read_pack_length((uint) maria->s->pack.version,
+    head_length+= read_pack_length((uint) share->pack.version,
                                    header + head_length, &info->blob_len);
     /*
       Ensure that the record buffer is big enough for the compressed
@@ -1442,7 +1444,7 @@ 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 +
-                         maria->s->base.extra_rec_buff_size))
+                         share->base.extra_rec_buff_size, 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;
@@ -1583,15 +1585,18 @@ _ma_mempack_get_block_info(MARIA_HA *maria,
                            size_t *rec_buff_size_p,
                            uchar *header)
 {
-  header+= read_pack_length((uint) maria->s->pack.version, 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);
-  if (maria->s->base.blobs)
+  if (share->base.blobs)
   {
-    header+= read_pack_length((uint) maria->s->pack.version, header,
+    header+= read_pack_length((uint) share->pack.version, header,
                               &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 + maria->s->base.extra_rec_buff_size))
+                      info->blob_len + share->base.extra_rec_buff_size, 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/maria_def.h b/storage/maria/maria_def.h
index e22b841dcaf..0002048d924 100644
--- a/storage/maria/maria_def.h
+++ b/storage/maria/maria_def.h
@@ -1511,7 +1511,7 @@ extern my_bool _ma_read_cache(MARIA_HA *, IO_CACHE *info, uchar *buff,
                               uint re_read_if_possibly);
 extern ulonglong ma_retrieve_auto_increment(const uchar *key, uint8 key_type);
 extern my_bool _ma_alloc_buffer(uchar **old_addr, size_t *old_size,
-                                size_t new_size);
+                                size_t new_size, myf flag);
 extern size_t _ma_rec_unpack(MARIA_HA *info, uchar *to, uchar *from,
                             size_t reclength);
 extern my_bool _ma_rec_check(MARIA_HA *info, const uchar *record,