Merge remote-tracking branch 'origin/10.4' into 10.5

40 files changed, 182 insertions, 173 deletions

diff --git a/include/my_valgrind.h b/include/my_valgrind.h
index 1de6714700b..62794a2d70c 100644
--- a/include/my_valgrind.h
+++ b/include/my_valgrind.h
@@ -24,16 +24,22 @@
 # define __SANITIZE_ADDRESS__ 1
 #endif
 
-#ifdef HAVE_valgrind
-#define IF_VALGRIND(A,B) A
-#else
-#define IF_VALGRIND(A,B) B
-#endif
-
-#if defined(HAVE_VALGRIND_MEMCHECK_H) && defined(HAVE_valgrind)
+#if __has_feature(memory_sanitizer)
+# include <sanitizer/msan_interface.h>
+# define HAVE_valgrind
+# define MEM_UNDEFINED(a,len) __msan_allocated_memory(a,len)
+# define MEM_MAKE_ADDRESSABLE(a,len) MEM_UNDEFINED(a,len)
+# define MEM_MAKE_DEFINED(a,len) __msan_unpoison(a,len)
+# define MEM_NOACCESS(a,len) ((void) 0)
+# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
+# define MEM_CHECK_DEFINED(a,len) __msan_check_mem_is_initialized(a,len)
+# define MEM_GET_VBITS(a,b,len) __msan_copy_shadow(b,a,len)
+# define MEM_SET_VBITS(a,b,len) __msan_copy_shadow(a,b,len)
+# define REDZONE_SIZE 8
+#elif defined(HAVE_VALGRIND_MEMCHECK_H) && defined(HAVE_valgrind)
 # include <valgrind/memcheck.h>
-# define HAVE_valgrind_or_MSAN
 # define MEM_UNDEFINED(a,len) VALGRIND_MAKE_MEM_UNDEFINED(a,len)
+# define MEM_MAKE_ADDRESSABLE(a,len) MEM_UNDEFINED(a,len)
 # define MEM_MAKE_DEFINED(a,len) VALGRIND_MAKE_MEM_DEFINED(a,len)
 # define MEM_NOACCESS(a,len) VALGRIND_MAKE_MEM_NOACCESS(a,len)
 # define MEM_CHECK_ADDRESSABLE(a,len) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(a,len)
@@ -45,27 +51,19 @@
 # include <sanitizer/asan_interface.h>
 /* How to do manual poisoning:
 https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning */
-# define MEM_UNDEFINED(a,len) ASAN_UNPOISON_MEMORY_REGION(a,len)
+# define MEM_UNDEFINED(a,len) ((void) 0)
+# define MEM_MAKE_ADDRESSABLE(a,len) ASAN_UNPOISON_MEMORY_REGION(a,len)
 # define MEM_MAKE_DEFINED(a,len) ((void) 0)
 # define MEM_NOACCESS(a,len) ASAN_POISON_MEMORY_REGION(a,len)
-# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
+# define MEM_CHECK_ADDRESSABLE(a,len) \
+  assert(!__asan_region_is_poisoned((void*) a,len))
 # define MEM_CHECK_DEFINED(a,len) ((void) 0)
 # define MEM_GET_VBITS(a,b,len) ((void) 0)
 # define MEM_SET_VBITS(a,b,len) ((void) 0)
 # define REDZONE_SIZE 8
-#elif __has_feature(memory_sanitizer)
-# include <sanitizer/msan_interface.h>
-# define HAVE_valgrind_or_MSAN
-# define MEM_UNDEFINED(a,len) __msan_allocated_memory(a,len)
-# define MEM_MAKE_DEFINED(a,len) __msan_unpoison(a,len)
-# define MEM_NOACCESS(a,len) ((void) 0)
-# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
-# define MEM_CHECK_DEFINED(a,len) __msan_check_mem_is_initialized(a,len)
-# define MEM_GET_VBITS(a,b,len) __msan_copy_shadow(b,a,len)
-# define MEM_SET_VBITS(a,b,len) __msan_copy_shadow(a,b,len)
-# define REDZONE_SIZE 8
 #else
-# define MEM_UNDEFINED(a,len) ((void) (a), (void) (len))
+# define MEM_UNDEFINED(a,len) ((void) 0)
+# define MEM_MAKE_ADDRESSABLE(a,len) ((void) 0)
 # define MEM_MAKE_DEFINED(a,len) ((void) 0)
 # define MEM_NOACCESS(a,len) ((void) 0)
 # define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
@@ -73,25 +71,30 @@ https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning */
 # define MEM_GET_VBITS(a,b,len) ((void) 0)
 # define MEM_SET_VBITS(a,b,len) ((void) 0)
 # define REDZONE_SIZE 0
-#endif /* HAVE_VALGRIND_MEMCHECK_H */
+#endif /* __has_feature(memory_sanitizer) */
+
+#ifdef HAVE_valgrind
+#define IF_VALGRIND(A,B) A
+#else
+#define IF_VALGRIND(A,B) B
+#endif
 
 #ifdef TRASH_FREED_MEMORY
 /*
-  TRASH_FILL() has to call MEM_UNDEFINED() to cancel any effect of TRASH_FREE().
+  _TRASH_FILL() has to call MEM_MAKE_ADDRESSABLE() to cancel any effect of
+  TRASH_FREE().
   This can happen in the case one does
   TRASH_ALLOC(A,B) ; TRASH_FREE(A,B) ; TRASH_ALLOC(A,B)
   to reuse the same memory in an internal memory allocator like MEM_ROOT.
-  For my_malloc() and safemalloc() the extra MEM_UNDEFINED is bit of an
-  overkill.
-  TRASH_FILL() is an internal function and should not be used externally.
+  _TRASH_FILL() is an internal function and should not be used externally.
 */
-#define TRASH_FILL(A,B,C) do { const size_t trash_tmp= (B); MEM_UNDEFINED(A, trash_tmp); memset(A, C, trash_tmp); } while (0)
+#define _TRASH_FILL(A,B,C) do { const size_t trash_tmp= (B); MEM_MAKE_ADDRESSABLE(A, trash_tmp); memset(A, C, trash_tmp); } while (0)
 #else
-#define TRASH_FILL(A,B,C) do { MEM_UNDEFINED((A), (B)); } while (0)
+#define _TRASH_FILL(A,B,C) do { MEM_UNDEFINED((A), (B)); } while (0)
 #endif
-/** Note that some memory became allocated or uninitialized. */
-#define TRASH_ALLOC(A,B) do { TRASH_FILL(A,B,0xA5); MEM_UNDEFINED(A,B); } while(0)
+/** Note that some memory became allocated and/or uninitialized. */
+#define TRASH_ALLOC(A,B) do { _TRASH_FILL(A,B,0xA5); MEM_MAKE_ADDRESSABLE(A,B); } while(0)
 /** Note that some memory became freed. (Prohibit further access to it.) */
-#define TRASH_FREE(A,B) do { TRASH_FILL(A,B,0x8F); MEM_NOACCESS(A,B); } while(0)
+#define TRASH_FREE(A,B) do { _TRASH_FILL(A,B,0x8F); MEM_NOACCESS(A,B); } while(0)
 
 #endif /* MY_VALGRIND_INCLUDED */
diff --git a/libmysqld/libmysql.c b/libmysqld/libmysql.c
index 8b48d6d4bcb..e269840d674 100644
--- a/libmysqld/libmysql.c
+++ b/libmysqld/libmysql.c
@@ -1164,6 +1164,7 @@ my_bool STDCALL mysql_embedded(void)
 void my_net_local_init(NET *net)
 {
   net->max_packet=   (uint) net_buffer_length;
+  net->read_timeout= net->write_timeout= 0;
   my_net_set_read_timeout(net, CLIENT_NET_READ_TIMEOUT);
   my_net_set_write_timeout(net, CLIENT_NET_WRITE_TIMEOUT);
   net->retry_count=  1;
diff --git a/mysql-test/main/mysql_upgrade.test b/mysql-test/main/mysql_upgrade.test
index 5c07d3858d3..42c4a545dd7 100644
--- a/mysql-test/main/mysql_upgrade.test
+++ b/mysql-test/main/mysql_upgrade.test
@@ -17,7 +17,7 @@ let $MYSQLD_DATADIR= `select @@datadir`;
 file_exists $MYSQLD_DATADIR/mysql_upgrade_info;
 
 --echo Run it again - should say already completed
---replace_result $MYSQL_SERVER_VERSION VERSION
+--replace_regex /upgraded to .*, use/upgraded to VERSION, use/
 --exec $MYSQL_UPGRADE 2>&1
 
 # It should have created a file in the MySQL Servers datadir
diff --git a/mysql-test/main/type_temporal_innodb.result b/mysql-test/main/type_temporal_innodb.result
index 2aad1e02d02..b11ea8476bd 100644
--- a/mysql-test/main/type_temporal_innodb.result
+++ b/mysql-test/main/type_temporal_innodb.result
@@ -173,6 +173,9 @@ ERROR 22007: Truncated incorrect datetime value: '0000-00-00 00:00:00'
 DROP TABLE t1,t2;
 SET sql_mode=DEFAULT;
 #
+# End of 10.3 tests
+#
+#
 # MDEV-19166 Assertion `!is_zero_datetime()' failed in Timestamp_or_zero_datetime::tv
 #
 CREATE TABLE t1 (f TIMESTAMP DEFAULT 0) ENGINE=InnoDB;
diff --git a/mysql-test/main/type_temporal_innodb.test b/mysql-test/main/type_temporal_innodb.test
index b8c7720f8b6..4adaa483ca2 100644
--- a/mysql-test/main/type_temporal_innodb.test
+++ b/mysql-test/main/type_temporal_innodb.test
@@ -82,6 +82,9 @@ CREATE TABLE tbl SELECT * FROM t1 WHERE t1.c1 = (SELECT c2 FROM t2 WHERE pk = 6)
 DROP TABLE t1,t2;
 SET sql_mode=DEFAULT;
 
+--echo #
+--echo # End of 10.3 tests
+--echo #
 
 --echo #
 --echo # MDEV-19166 Assertion `!is_zero_datetime()' failed in Timestamp_or_zero_datetime::tv
@@ -92,7 +95,6 @@ INSERT INTO t1 VALUES ('2024-02-29');
 SELECT * FROM t1 WHERE SUBSTR(1 FROM BIT_LENGTH(f) FOR DEFAULT(f));
 DROP TABLE t1;
 
-
 --echo #
 --echo # End of 10.4 tests
 --echo #
diff --git a/mysql-test/suite/csv/read_only.test b/mysql-test/suite/csv/read_only.test
index 2af209182d0..a3c851a6a70 100644
--- a/mysql-test/suite/csv/read_only.test
+++ b/mysql-test/suite/csv/read_only.test
@@ -1,3 +1,4 @@
+--source include/not_as_root.inc
 #
 # MDEV-11883 MariaDB crashes with out-of-memory when query information_schema
 #
diff --git a/mysql-test/suite/galera/r/galera_lock_tables_in_transaction.result b/mysql-test/suite/galera/r/galera_lock_tables_in_transaction.result
new file mode 100644
index 00000000000..68691a4efd2
--- /dev/null
+++ b/mysql-test/suite/galera/r/galera_lock_tables_in_transaction.result
@@ -0,0 +1,12 @@
+connection node_2;
+connection node_1;
+CREATE TABLE t1 (a INT) ENGINE=InnoDB;
+START TRANSACTION;
+INSERT INTO t1 VALUES (1);
+LOCK TABLES t2 READ;
+ERROR 42S02: Table 'test.t2' doesn't exist
+START TRANSACTION;
+INSERT INTO t1 VALUES (1);
+LOCK TABLES t1 READ;
+UNLOCK TABLES;
+DROP TABLE t1;
diff --git a/mysql-test/suite/galera/t/galera_lock_tables_in_transaction.test b/mysql-test/suite/galera/t/galera_lock_tables_in_transaction.test
new file mode 100644
index 00000000000..5cb7347639c
--- /dev/null
+++ b/mysql-test/suite/galera/t/galera_lock_tables_in_transaction.test
@@ -0,0 +1,21 @@
+#
+# Check `LOCK TABLES` command with or without existing table in database.
+# Test case for MDEV-22222 / MDEV-22223
+#
+
+--source include/galera_cluster.inc
+--source include/have_innodb.inc
+
+CREATE TABLE t1 (a INT) ENGINE=InnoDB;
+
+START TRANSACTION;
+INSERT INTO t1 VALUES (1);
+--error ER_NO_SUCH_TABLE
+LOCK TABLES t2 READ;
+
+START TRANSACTION;
+INSERT INTO t1 VALUES (1);
+LOCK TABLES t1 READ;
+UNLOCK TABLES;
+
+DROP TABLE t1;
diff --git a/mysys/my_alloc.c b/mysys/my_alloc.c
index f5537885227..b4a63e93be3 100644
--- a/mysys/my_alloc.c
+++ b/mysys/my_alloc.c
@@ -205,7 +205,7 @@ void *alloc_root(MEM_ROOT *mem_root, size_t length)
   uchar* point;
   reg1 USED_MEM *next= 0;
   reg2 USED_MEM **prev;
-  size_t original_length = length;
+  size_t original_length __attribute__((unused)) = length;
   DBUG_ENTER("alloc_root");
   DBUG_PRINT("enter",("root: %p  name: %s", mem_root, root_name(mem_root)));
   DBUG_ASSERT(alloc_root_inited(mem_root));
diff --git a/sql/field.cc b/sql/field.cc
index 9b6f117a82e..e73cc380196 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -7698,7 +7698,7 @@ my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
 }
 
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 void Field_varstring::mark_unused_memory_as_defined()
 {
   uint used_length= get_length();
diff --git a/sql/field.h b/sql/field.h
index 420ff6866bd..72c99c37fb7 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -997,7 +997,7 @@ public:
   */
   virtual int store_from_statistical_minmax_field(Field *field, String *str);
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
   /**
     Mark unused memory in the field as defined. Mainly used to ensure
     that if we write full field to disk (for example in
@@ -4136,7 +4136,7 @@ public:
   }
   int  store(const char *to,size_t length,CHARSET_INFO *charset) override;
   using Field_str::store;
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
   void mark_unused_memory_as_defined() override;
 #endif
   double val_real() override;
diff --git a/sql/session_tracker.cc b/sql/session_tracker.cc
index d94ecdc2b24..4cee6cb0dfa 100644
--- a/sql/session_tracker.cc
+++ b/sql/session_tracker.cc
@@ -381,16 +381,14 @@ bool Session_sysvars_tracker::enable(THD *thd)
 bool Session_sysvars_tracker::update(THD *thd, set_var *var)
 {
   vars_list tool_list;
-  void *copy;
   size_t length= 1;
 
-  if (var->save_result.string_value.str)
-    copy= my_memdup(PSI_INSTRUMENT_ME, var->save_result.string_value.str,
-                    (length= var->save_result.string_value.length + 1),
-                    MYF(MY_WME | MY_THREAD_SPECIFIC));
-    else
-      copy= my_strdup(PSI_INSTRUMENT_ME, "", MYF(MY_WME | MY_THREAD_SPECIFIC));
-
+  void *copy= var->save_result.string_value.str ?
+              my_memdup(PSI_INSTRUMENT_ME, var->save_result.string_value.str,
+                        (length= var->save_result.string_value.length + 1),
+                        MYF(MY_WME | MY_THREAD_SPECIFIC)) :
+              my_strdup(PSI_INSTRUMENT_ME, "",
+                        MYF(MY_WME | MY_THREAD_SPECIFIC));
   if (!copy)
     return true;
 
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index c3e301cd39d..2869011e313 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -2029,8 +2029,8 @@ int READ_INFO::read_xml(THD *thd)
       
     case '=': /* attribute name end - read the value */
       //check for tag field and attribute name
-      if(!memcmp(tag.c_ptr_safe(), STRING_WITH_LEN("field")) &&
-         !memcmp(attribute.c_ptr_safe(), STRING_WITH_LEN("name")))
+      if(!strcmp(tag.c_ptr_safe(), "field") &&
+         !strcmp(attribute.c_ptr_safe(), "name"))
       {
         /*
           this is format <field name="xx">xx</field>
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 167aefee7a6..8d074e13d1f 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -5058,6 +5058,12 @@ mysql_execute_command(THD *thd)
     if (res)
       goto error;
 
+#ifdef WITH_WSREP
+    /* Clean up the previous transaction on implicit commit. */
+    if (wsrep_on(thd) && !wsrep_not_committed(thd) && wsrep_after_statement(thd))
+      goto error;
+#endif
+
     /* We can't have any kind of table locks while backup is active */
     if (thd->current_backup_stage != BACKUP_FINISHED)
     {
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 896e7fdf5e7..9cc4a9c4626 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -6562,6 +6562,7 @@ add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
   keyuse.keypart= FT_KEYPART;
   keyuse.used_tables=cond_func->key_item()->used_tables();
   keyuse.optimize= 0;
+  keyuse.ref_table_rows= 0;
   keyuse.keypart_map= 0;
   keyuse.sj_pred_no= UINT_MAX;
   keyuse.validity_ref= 0;
@@ -18641,17 +18642,15 @@ bool Create_tmp_table::finalize(THD *thd,
   uint null_pack_length[2];
   uint null_pack_base[2];
   uint null_counter[2]= {0, 0};
-
   uint whole_null_pack_length;
-
   bool  use_packed_rows= false;
+  bool  save_abort_on_warning;
   uchar *pos;
   uchar *null_flags;
   KEY *keyinfo;
   TMP_ENGINE_COLUMNDEF *recinfo;
   TABLE_SHARE  *share= table->s;
   Copy_field *copy= param->copy_field;
-
   MEM_ROOT *mem_root_save= thd->mem_root;
   thd->mem_root= &table->mem_root;
 
@@ -18752,6 +18751,11 @@ bool Create_tmp_table::finalize(THD *thd,
   {
     null_counter[(m_field_count[other] ? other : distinct)]++;
   }
+
+  /* Protect against warnings in field_conv() in the next loop*/
+  save_abort_on_warning= thd->abort_on_warning;
+  thd->abort_on_warning= 0;
+
   for (uint i= 0; i < share->fields; i++, recinfo++)
   {
     Field *field= table->field[i];
@@ -18795,25 +18799,31 @@ bool Create_tmp_table::finalize(THD *thd,
          inherit the default value that is defined for the field referred
          by the Item_field object from which 'field' has been created.
       */
-      const Field *orig_field= m_default_field[i];
+      Field *orig_field= m_default_field[i];
       /* Get the value from default_values */
       if (orig_field->is_null_in_record(orig_field->table->s->default_values))
         field->set_null();
       else
       {
+        /*
+          Copy default value. We have to use field_conv() for copy, instead of
+          memcpy(), because bit_fields may be stored differently
+        */
+        my_ptrdiff_t ptr_diff= (orig_field->table->s->default_values -
+                                orig_field->table->record[0]);
         field->set_notnull();
-        memcpy(field->ptr,
-               orig_field->ptr_in_record(orig_field->table->s->default_values),
-               field->pack_length_in_rec());
+        orig_field->move_field_offset(ptr_diff);
+        field_conv(field, orig_field);
+        orig_field->move_field_offset(-ptr_diff);
       }
-    } 
+    }
 
     if (m_from_field[i])
     {						/* Not a table Item */
       copy->set(field, m_from_field[i], m_save_sum_fields);
       copy++;
     }
-    length=field->pack_length();
+    length=field->pack_length_in_rec();
     pos+= length;
 
     /* Make entry for create table */
@@ -18823,7 +18833,11 @@ bool Create_tmp_table::finalize(THD *thd,
     // fix table name in field entry
     field->set_table_name(&table->alias);
   }
+  /* Handle group_null_items */
+  bzero(pos, table->s->reclength - (pos - table->record[0]));
+  MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
 
+  thd->abort_on_warning= save_abort_on_warning;
   param->copy_field_end= copy;
   param->recinfo= recinfo;              	// Pointer to after last field
   store_record(table,s->default_values);        // Make empty default record
@@ -19086,8 +19100,9 @@ bool Create_tmp_table::finalize(THD *thd,
       goto err;
   }
 
-  // Make empty record so random data is not written to disk
-  empty_record(table);
+  /* record[0] and share->default_values should now have been set up */
+  MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
+  MEM_CHECK_DEFINED(share->default_values, table->s->reclength);
 
   thd->mem_root= mem_root_save;
 
@@ -19483,7 +19498,11 @@ bool create_internal_tmp_table(TABLE *table, KEY *keyinfo,
       (*recinfo)->type=   FIELD_CHECK;
       (*recinfo)->length= MARIA_UNIQUE_HASH_LENGTH;
       (*recinfo)++;
-      share->reclength+=      MARIA_UNIQUE_HASH_LENGTH;
+
+      /* Avoid warnings from valgrind */
+      bzero(table->record[0]+ share->reclength, MARIA_UNIQUE_HASH_LENGTH);
+      bzero(share->default_values+ share->reclength, MARIA_UNIQUE_HASH_LENGTH);
+      share->reclength+= MARIA_UNIQUE_HASH_LENGTH;
     }
     else
     {
@@ -19677,7 +19696,10 @@ bool create_internal_tmp_table(TABLE *table, KEY *keyinfo,
       (*recinfo)->type= FIELD_CHECK;
       (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
       (*recinfo)++;
-      share->reclength+=MI_UNIQUE_HASH_LENGTH;
+      /* Avoid warnings from valgrind */
+      bzero(table->record[0]+ share->reclength, MI_UNIQUE_HASH_LENGTH);
+      bzero(share->default_values+ share->reclength, MI_UNIQUE_HASH_LENGTH);
+      share->reclength+= MI_UNIQUE_HASH_LENGTH;
     }
     else
     {
@@ -20269,11 +20291,11 @@ bool instantiate_tmp_table(TABLE *table, KEY *keyinfo,
       If it is not heap (in-memory) table then convert index to unique
       constrain.
     */
+    MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
     if (create_internal_tmp_table(table, keyinfo, start_recinfo, recinfo,
                                   options))
       return TRUE;
-    // Make empty record so random data is not written to disk
-    empty_record(table);
+    MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
   }
   if (open_tmp_table(table))
     return TRUE;
@@ -28795,7 +28817,6 @@ AGGR_OP::prepare_tmp_table()
                               join->select_options))
       return true;
     (void) table->file->extra(HA_EXTRA_WRITE_CACHE);
-    empty_record(table);
   }
   /* If it wasn't already, start index scan for grouping using table index. */
   if (!table->file->inited && table->group &&
diff --git a/sql/table.cc b/sql/table.cc
index 9e7592e4b97..06178f8e789 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -2109,8 +2109,8 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
   share->rec_buff_length= rec_buff_length;
   if (!(record= (uchar *) alloc_root(&share->mem_root, rec_buff_length)))
     goto err;                          /* purecov: inspected */
-  MEM_NOACCESS(record, rec_buff_length);
-  MEM_UNDEFINED(record, share->reclength);
+  /* Mark bytes after record as not accessable to catch overrun bugs */
+  MEM_NOACCESS(record + share->reclength, rec_buff_length - share->reclength);
   share->default_values= record;
   memcpy(record, frm_image + record_offset, share->reclength);
 
@@ -3959,7 +3959,6 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
     if (!(record= (uchar*) alloc_root(&outparam->mem_root,
                                       share->rec_buff_length * records)))
       goto err;                                   /* purecov: inspected */
-    MEM_NOACCESS(record, share->rec_buff_length * records);
   }
 
   for (i= 0; i < 3;)
@@ -3968,8 +3967,10 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
     if (++i < records)
       record+= share->rec_buff_length;
   }
+  /* Mark bytes between records as not accessable to catch overrun bugs */
   for (i= 0; i < records; i++)
-    MEM_UNDEFINED(outparam->record[i], share->reclength);
+    MEM_NOACCESS(outparam->record[i] + share->reclength,
+                 share->rec_buff_length - share->reclength);
 
   if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
                                           (uint) ((share->fields+1)*
diff --git a/sql/unireg.cc b/sql/unireg.cc
index fa193a7712d..525e7a8a56a 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -592,8 +592,8 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING &table,
     pos+= create_info->comment.length;
   }
 
-  memcpy(frm_ptr + filepos, forminfo, 288);
-  pos= frm_ptr + filepos + 288;
+  memcpy(frm_ptr + filepos, forminfo, FRM_FORMINFO_SIZE);
+  pos= frm_ptr + filepos + FRM_FORMINFO_SIZE;
   if (pack_fields(&pos, create_fields, create_info, data_offset))
     goto err;
 
diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc
index a282826b8de..550e3f36c6c 100644
--- a/storage/innobase/btr/btr0cur.cc
+++ b/storage/innobase/btr/btr0cur.cc
@@ -1299,12 +1299,10 @@ btr_cur_search_to_nth_level_func(
 	ut_ad(!(index->type & DICT_FTS));
 	ut_ad(index->page != FIL_NULL);
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(&cursor->up_match, sizeof cursor->up_match);
 	MEM_UNDEFINED(&cursor->up_bytes, sizeof cursor->up_bytes);
 	MEM_UNDEFINED(&cursor->low_match, sizeof cursor->low_match);
 	MEM_UNDEFINED(&cursor->low_bytes, sizeof cursor->low_bytes);
-#endif /* HAVE_valgrind_or_MSAN */
 #ifdef UNIV_DEBUG
 	cursor->up_match = ULINT_UNDEFINED;
 	cursor->low_match = ULINT_UNDEFINED;
@@ -3367,12 +3365,12 @@ btr_cur_optimistic_insert(
 	      || (flags & BTR_CREATE_FLAG));
 	ut_ad(dtuple_check_typed(entry));
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 	if (block->page.zip.data) {
 		MEM_CHECK_DEFINED(page, srv_page_size);
 		MEM_CHECK_DEFINED(block->page.zip.data, block->zip_size());
 	}
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 
 	leaf = page_is_leaf(page);
 
diff --git a/storage/innobase/buf/buf0buddy.cc b/storage/innobase/buf/buf0buddy.cc
index bedf00441ec..8280377b42a 100644
--- a/storage/innobase/buf/buf0buddy.cc
+++ b/storage/innobase/buf/buf0buddy.cc
@@ -364,9 +364,7 @@ buf_buddy_block_free(void* buf)
 	HASH_DELETE(buf_page_t, hash, &buf_pool.zip_hash, fold, bpage);
 
 	ut_d(memset(buf, 0, srv_page_size));
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(buf, srv_page_size);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	block = (buf_block_t*) bpage;
 	buf_LRU_block_free_non_file_page(block);
diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc
index 1e2abc2e04d..4deb34efc74 100644
--- a/storage/innobase/buf/buf0buf.cc
+++ b/storage/innobase/buf/buf0buf.cc
@@ -1356,6 +1356,8 @@ inline bool buf_pool_t::chunk_t::create(size_t bytes)
   if (UNIV_UNLIKELY(!mem))
     return false;
 
+  MEM_MAKE_ADDRESSABLE(mem, mem_size());
+
 #ifdef HAVE_LIBNUMA
   if (srv_numa_interleave)
   {
@@ -1736,9 +1738,7 @@ inline bool buf_pool_t::realloc(buf_block_t *block)
 			      "not perfect alignment");
 		memset_aligned<2>(block->frame
 				  + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, 0xff, 4);
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(block->frame, srv_page_size);
-#endif /* HAVE_valgrind_or_MSAN */
 		block->page.set_state(BUF_BLOCK_REMOVE_HASH);
 
 		/* Relocate flush_list. */
@@ -2257,6 +2257,8 @@ withdraw_retry:
 		ulint	sum_freed = 0;
 
 		while (chunk < echunk) {
+			MEM_MAKE_ADDRESSABLE(chunk->mem, chunk->size);
+
 			buf_block_t*	block = chunk->blocks;
 
 			for (ulint j = chunk->size; j--; block++) {
@@ -3382,9 +3384,7 @@ evict_from_pool:
 		block->page.set_io_fix(BUF_IO_READ);
 		rw_lock_x_lock_inline(&block->lock, 0, file, line);
 
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(bpage, sizeof *bpage);
-#endif /* HAVE_valgrind_or_MSAN */
 
 		mutex_exit(&buf_pool.mutex);
 		hash_lock->write_unlock();
diff --git a/storage/innobase/buf/buf0lru.cc b/storage/innobase/buf/buf0lru.cc
index 41d1e40a730..577f1dae91c 100644
--- a/storage/innobase/buf/buf0lru.cc
+++ b/storage/innobase/buf/buf0lru.cc
@@ -626,7 +626,7 @@ buf_block_t* buf_LRU_get_free_only()
 			assert_block_ahi_empty(block);
 
 			block->page.set_state(BUF_BLOCK_MEMORY);
-			MEM_UNDEFINED(block->frame, srv_page_size);
+			MEM_MAKE_ADDRESSABLE(block->frame, srv_page_size);
 			break;
 		}
 
@@ -1307,13 +1307,9 @@ func_exit:
 	order to avoid bogus Valgrind or MSAN warnings.*/
 	buf_block_t* block = reinterpret_cast<buf_block_t*>(bpage);
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_MAKE_DEFINED(block->frame, srv_page_size);
-#endif /* HAVE_valgrind_or_MSAN */
 	btr_search_drop_page_hash_index(block);
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(block->frame, srv_page_size);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	if (UNIV_LIKELY_NULL(b)) {
 		ut_ad(b->zip_size());
@@ -1511,9 +1507,7 @@ static bool buf_LRU_block_remove_hashed(buf_page_t *bpage, const page_id_t id,
 			      "not perfect alignment");
 		memset_aligned<2>(reinterpret_cast<buf_block_t*>(bpage)->frame
 				  + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, 0xff, 4);
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(((buf_block_t*) bpage)->frame, srv_page_size);
-#endif /* HAVE_valgrind_or_MSAN */
 		bpage->set_state(BUF_BLOCK_REMOVE_HASH);
 
 		/* Question: If we release hash_lock here
diff --git a/storage/innobase/data/data0data.cc b/storage/innobase/data/data0data.cc
index 0fb9f5e66af..1341136d8d6 100644
--- a/storage/innobase/data/data0data.cc
+++ b/storage/innobase/data/data0data.cc
@@ -234,7 +234,7 @@ dtuple_validate(
 	const dtuple_t*	tuple)	/*!< in: tuple */
 {
 	ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 	const ulint n_fields = dtuple_get_n_fields(tuple);
 
 	for (ulint i = 0; i < n_fields; i++) {
@@ -245,7 +245,7 @@ dtuple_validate(
 					  dfield_get_len(field));
 		}
 	}
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 	ut_ad(dtuple_check_typed(tuple));
 
 	return(TRUE);
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 9344ec660b9..858fefaf2de 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -7033,9 +7033,7 @@ build_template_field(
 	ut_ad(clust_index->table == index->table);
 
 	templ = prebuilt->mysql_template + prebuilt->n_template++;
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(templ, sizeof *templ);
-#endif /* HAVE_valgrind_or_MSAN */
 	templ->is_virtual = !field->stored_in_db();
 
 	if (!templ->is_virtual) {
@@ -8146,9 +8144,7 @@ calc_row_difference(
 			/* The field has changed */
 
 			ufield = uvect->fields + n_changed;
-#ifdef HAVE_valgrind_or_MSAN
 			MEM_UNDEFINED(ufield, sizeof *ufield);
-#endif /* HAVE_valgrind_or_MSAN */
 
 			/* Let us use a dummy dfield to make the conversion
 			from the MySQL column format to the InnoDB format */
diff --git a/storage/innobase/include/buf0buf.ic b/storage/innobase/include/buf0buf.ic
index 242c9cbb65d..cda7d435725 100644
--- a/storage/innobase/include/buf0buf.ic
+++ b/storage/innobase/include/buf0buf.ic
@@ -185,9 +185,7 @@ buf_page_alloc_descriptor(void)
 
 	bpage = (buf_page_t*) ut_zalloc_nokey(sizeof *bpage);
 	ut_ad(bpage);
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(bpage, sizeof *bpage);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	return(bpage);
 }
diff --git a/storage/innobase/include/dict0stats.ic b/storage/innobase/include/dict0stats.ic
index dbdbceab9ba..0b8c57a5eba 100644
--- a/storage/innobase/include/dict0stats.ic
+++ b/storage/innobase/include/dict0stats.ic
@@ -187,7 +187,7 @@ dict_stats_deinit(
 
 	table->stat_initialized = FALSE;
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 	MEM_UNDEFINED(&table->stat_n_rows, sizeof table->stat_n_rows);
 	MEM_UNDEFINED(&table->stat_clustered_index_size,
 		      sizeof table->stat_clustered_index_size);
@@ -220,7 +220,7 @@ dict_stats_deinit(
 			&index->stat_n_leaf_pages,
 			sizeof(index->stat_n_leaf_pages));
 	}
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 
 	rw_lock_x_unlock(&table->stats_latch);
 }
diff --git a/storage/innobase/include/mem0mem.ic b/storage/innobase/include/mem0mem.ic
index c1e7348a548..9236bbef05d 100644
--- a/storage/innobase/include/mem0mem.ic
+++ b/storage/innobase/include/mem0mem.ic
@@ -203,7 +203,7 @@ mem_heap_alloc(
 	mem_block_set_free(block, free + MEM_SPACE_NEEDED(n));
 
 	buf = buf + REDZONE_SIZE;
-	MEM_UNDEFINED(buf, n - REDZONE_SIZE);
+	MEM_MAKE_ADDRESSABLE(buf, n - REDZONE_SIZE);
 	return(buf);
 }
 
diff --git a/storage/innobase/include/srv0mon.h b/storage/innobase/include/srv0mon.h
index 8e833642ee0..325bb3a2cee 100644
--- a/storage/innobase/include/srv0mon.h
+++ b/storage/innobase/include/srv0mon.h
@@ -651,14 +651,14 @@ Use MONITOR_DEC if appropriate mutex protection exists.
 		}							\
 	}
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 # define MONITOR_CHECK_DEFINED(value) do {	\
 	mon_type_t m = value;			\
 	MEM_CHECK_DEFINED(&m, sizeof m);	\
 } while (0)
-#else /* HAVE_valgrind_or_MSAN */
+#else /* HAVE_valgrind */
 # define MONITOR_CHECK_DEFINED(value) (void) 0
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 
 #define	MONITOR_INC_VALUE(monitor, value)				\
 	MONITOR_CHECK_DEFINED(value);					\
diff --git a/storage/innobase/include/ut0pool.h b/storage/innobase/include/ut0pool.h
index 703a07a23f2..4a5f58f6fae 100644
--- a/storage/innobase/include/ut0pool.h
+++ b/storage/innobase/include/ut0pool.h
@@ -89,13 +89,12 @@ struct Pool {
 			ut_ad(elem->m_pool == this);
 #ifdef __SANITIZE_ADDRESS__
 			/* Unpoison the memory for AddressSanitizer */
-			MEM_UNDEFINED(&elem->m_type, sizeof elem->m_type);
+			MEM_MAKE_ADDRESSABLE(&elem->m_type,
+					     sizeof elem->m_type);
 #endif
-#ifdef HAVE_valgrind
-			/* Declare the contents as initialized for Valgrind;
+			/* Declare the contents initialized;
 			we checked this in mem_free(). */
 			MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type);
-#endif
 			Factory::destroy(&elem->m_type);
 		}
 
@@ -134,14 +133,13 @@ struct Pool {
 		if (elem) {
 # ifdef __SANITIZE_ADDRESS__
 			/* Unpoison the memory for AddressSanitizer */
-			MEM_UNDEFINED(&elem->m_type, sizeof elem->m_type);
+			MEM_MAKE_ADDRESSABLE(&elem->m_type,
+					     sizeof elem->m_type);
 # endif
-# ifdef HAVE_valgrind
-			/* Declare the memory initialized for Valgrind.
+			/* Declare the memory initialized.
 			The trx_t that are released to the pool are
 			actually initialized; we checked that by
 			MEM_CHECK_DEFINED() in mem_free() below. */
-# endif
 			MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type);
 		}
 #endif
diff --git a/storage/innobase/mtr/mtr0mtr.cc b/storage/innobase/mtr/mtr0mtr.cc
index 16a0ecc051c..940429b2cd6 100644
--- a/storage/innobase/mtr/mtr0mtr.cc
+++ b/storage/innobase/mtr/mtr0mtr.cc
@@ -354,10 +354,9 @@ struct mtr_write_log_t {
 /** Start a mini-transaction. */
 void mtr_t::start()
 {
-#ifdef HAVE_valgrind_or_MSAN
+  ut_ad(!m_freed_pages);
   MEM_UNDEFINED(this, sizeof *this);
   MEM_MAKE_DEFINED(&m_freed_pages, sizeof(m_freed_pages));
-#endif /* HAVE_valgrind_or_MSAN */
 
   ut_d(m_start= true);
   ut_d(m_commit= false);
@@ -376,7 +375,6 @@ void mtr_t::start()
   m_user_space= nullptr;
   m_commit_lsn= 0;
   m_freed_in_system_tablespace= m_trim_pages= false;
-  ut_ad(!m_freed_pages);
 }
 
 /** Release the resources */
diff --git a/storage/innobase/page/page0cur.cc b/storage/innobase/page/page0cur.cc
index 92e7ce5e60d..36fdde82cb3 100644
--- a/storage/innobase/page/page0cur.cc
+++ b/storage/innobase/page/page0cur.cc
@@ -1302,7 +1302,7 @@ page_cur_insert_rec_low(
   /* 1. Get the size of the physical record in the page */
   const ulint rec_size= rec_offs_size(offsets);
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
   {
     const void *rec_start= rec - rec_offs_extra_size(offsets);
     ulint extra_size= rec_offs_extra_size(offsets) -
@@ -1314,7 +1314,7 @@ page_cur_insert_rec_low(
     /* The variable-length header must be valid. */
     MEM_CHECK_DEFINED(rec_start, extra_size);
   }
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 
   /* 2. Try to find suitable space from page memory management */
   bool reuse= false;
@@ -1702,7 +1702,7 @@ page_cur_insert_rec_zip(
   /* 1. Get the size of the physical record in the page */
   const ulint rec_size= rec_offs_size(offsets);
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
   {
     const void *rec_start= rec - rec_offs_extra_size(offsets);
     ulint extra_size= rec_offs_extra_size(offsets) - REC_N_NEW_EXTRA_BYTES;
@@ -1711,7 +1711,7 @@ page_cur_insert_rec_zip(
     /* The variable-length header must be valid. */
     MEM_CHECK_DEFINED(rec_start, extra_size);
   }
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
   const bool reorg_before_insert= page_has_garbage(cursor->block->frame) &&
     rec_size > page_get_max_insert_size(cursor->block->frame, 1) &&
     rec_size <= page_get_max_insert_size_after_reorganize(cursor->block->frame,
diff --git a/storage/innobase/page/page0zip.cc b/storage/innobase/page/page0zip.cc
index a89ae5b3a64..0f6a1c33e54 100644
--- a/storage/innobase/page/page0zip.cc
+++ b/storage/innobase/page/page0zip.cc
@@ -1552,11 +1552,11 @@ err_exit:
 	ut_ad(buf + c_stream.total_out == c_stream.next_out);
 	ut_ad((ulint) (storage - c_stream.next_out) >= c_stream.avail_out);
 
-#ifdef HAVE_valgrind
+#if defined HAVE_valgrind && !__has_feature(memory_sanitizer)
 	/* Valgrind believes that zlib does not initialize some bits
 	in the last 7 or 8 bytes of the stream.  Make Valgrind happy. */
 	MEM_MAKE_DEFINED(buf, c_stream.total_out);
-#endif /* HAVE_valgrind */
+#endif /* HAVE_valgrind && !memory_sanitizer */
 
 	/* Zero out the area reserved for the modification log.
 	Space for the end marker of the modification log is not
@@ -3076,9 +3076,7 @@ page_zip_decompress_low(
 	/* Clear the uncompressed page, except the header. */
 	memset(PAGE_DATA + page, 0x55, srv_page_size - PAGE_DATA);
 #endif /* UNIV_ZIP_DEBUG */
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(PAGE_DATA + page, srv_page_size - PAGE_DATA);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	/* Copy the page directory. */
 	if (UNIV_UNLIKELY(!page_zip_dir_decode(page_zip, page, recs,
diff --git a/storage/innobase/row/row0ftsort.cc b/storage/innobase/row/row0ftsort.cc
index 4698f25428c..29197fde46b 100644
--- a/storage/innobase/row/row0ftsort.cc
+++ b/storage/innobase/row/row0ftsort.cc
@@ -982,14 +982,14 @@ exit:
 					goto func_exit;
 				}
 
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 				MEM_UNDEFINED(block[i], srv_sort_buf_size);
 
 				if (crypt_block[i]) {
 					MEM_UNDEFINED(crypt_block[i],
 						      srv_sort_buf_size);
 				}
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 			}
 
 			buf[i] = row_merge_buf_empty(buf[i]);
diff --git a/storage/innobase/row/row0ins.cc b/storage/innobase/row/row0ins.cc
index 5f3cdb4356e..0f1e8007d36 100644
--- a/storage/innobase/row/row0ins.cc
+++ b/storage/innobase/row/row0ins.cc
@@ -1240,10 +1240,8 @@ row_ins_foreign_check_on_constraint(
 
 		update->info_bits = 0;
 		update->n_fields = foreign->n_fields;
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(update->fields,
 			      update->n_fields * sizeof *update->fields);
-#endif /* HAVE_valgrind_or_MSAN */
 
 		bool affects_fulltext = false;
 
diff --git a/storage/innobase/row/row0log.cc b/storage/innobase/row/row0log.cc
index 78f605c373d..4db1b7cfa7f 100644
--- a/storage/innobase/row/row0log.cc
+++ b/storage/innobase/row/row0log.cc
@@ -375,9 +375,7 @@ row_log_online_op(
 		goto err_exit;
 	}
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	ut_ad(log->tail.bytes < srv_sort_buf_size);
 	avail_size = srv_sort_buf_size - log->tail.bytes;
@@ -462,10 +460,8 @@ write_failed:
 			index->type |= DICT_CORRUPT;
 		}
 
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(log->tail.block, srv_sort_buf_size);
 		MEM_UNDEFINED(buf, srv_sort_buf_size);
-#endif /* HAVE_valgrind_or_MSAN */
 
 		memcpy(log->tail.block, log->tail.buf + avail_size,
 		       mrec_size - avail_size);
@@ -475,9 +471,7 @@ write_failed:
 		ut_ad(b == log->tail.block + log->tail.bytes);
 	}
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
-#endif /* HAVE_valgrind_or_MSAN */
 err_exit:
 	mutex_exit(&log->mutex);
 }
@@ -509,9 +503,7 @@ row_log_table_open(
 {
 	mutex_enter(&log->mutex);
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	if (log->error != DB_SUCCESS) {
 err_exit:
@@ -603,10 +595,9 @@ row_log_table_close_func(
 write_failed:
 			log->error = DB_ONLINE_LOG_TOO_BIG;
 		}
-#ifdef HAVE_valgrind_or_MSAN
+
 		MEM_UNDEFINED(log->tail.block, srv_sort_buf_size);
 		MEM_UNDEFINED(buf, srv_sort_buf_size);
-#endif /* HAVE_valgrind_or_MSAN */
 		memcpy(log->tail.block, log->tail.buf + avail, size - avail);
 		log->tail.bytes = size - avail;
 	} else {
@@ -615,9 +606,7 @@ write_failed:
 	}
 
 	log->tail.total += size;
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
-#endif /* HAVE_valgrind_or_MSAN */
 err_exit:
 	mutex_exit(&log->mutex);
 
@@ -2789,9 +2778,7 @@ row_log_table_apply_ops(
 	ut_ad(new_trx_id_col > 0);
 	ut_ad(new_trx_id_col != ULINT_UNDEFINED);
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets));
 	rec_offs_set_n_alloc(offsets, i);
@@ -3703,9 +3690,8 @@ row_log_apply_ops(
 	ut_ad(!index->is_committed());
 	ut_ad(rw_lock_own(dict_index_get_lock(index), RW_LOCK_X));
 	ut_ad(index->online_log);
-#ifdef HAVE_valgrind_or_MSAN
+
 	MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets));
 	rec_offs_set_n_alloc(offsets, i);
diff --git a/storage/innobase/row/row0merge.cc b/storage/innobase/row/row0merge.cc
index d1074f74725..3e0ffcf28b9 100644
--- a/storage/innobase/row/row0merge.cc
+++ b/storage/innobase/row/row0merge.cc
@@ -1021,11 +1021,11 @@ row_merge_buf_write(
 	ut_a(b < &block[srv_sort_buf_size]);
 	ut_a(b == &block[0] + buf->total_size);
 	*b++ = 0;
-#ifdef HAVE_valgrind_or_MSAN
+#ifdef HAVE_valgrind
 	/* The rest of the block is uninitialized.  Initialize it
 	to avoid bogus warnings. */
 	memset(b, 0xff, &block[srv_sort_buf_size] - b);
-#endif /* HAVE_valgrind_or_MSAN */
+#endif /* HAVE_valgrind */
 	DBUG_LOG("ib_merge_sort",
 		 "write " << reinterpret_cast<const void*>(b) << ','
 		 << of->fd << ',' << of->offset << " EOF");
@@ -1418,9 +1418,7 @@ row_merge_write_rec(
 			return(NULL);
 		}
 
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(&block[0], srv_sort_buf_size);
-#endif /* HAVE_valgrind_or_MSAN */
 
 		/* Copy the rest. */
 		b = &block[0];
@@ -1471,9 +1469,7 @@ row_merge_write_eof(
 		DBUG_RETURN(NULL);
 	}
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(&block[0], srv_sort_buf_size);
-#endif
 	DBUG_RETURN(&block[0]);
 }
 
@@ -2661,10 +2657,8 @@ write_buffers:
 						break;
 					}
 
-#ifdef HAVE_valgrind_or_MSAN
 					MEM_UNDEFINED(
 						&block[0], srv_sort_buf_size);
-#endif /* HAVE_valgrind_or_MSAN */
 				}
 			}
 			merge_buf[i] = row_merge_buf_empty(buf);
@@ -3164,9 +3158,7 @@ row_merge(
 	foffs0 = 0;
 	foffs1 = ihalf;
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(run_offset, *num_run * sizeof *run_offset);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) {
 
@@ -3247,9 +3239,7 @@ row_merge(
 	*tmpfd = file->fd;
 	*file = of;
 
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(&block[0], 3 * srv_sort_buf_size);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	return(DB_SUCCESS);
 }
diff --git a/storage/innobase/row/row0sel.cc b/storage/innobase/row/row0sel.cc
index 8b46364c744..595a72eb415 100644
--- a/storage/innobase/row/row0sel.cc
+++ b/storage/innobase/row/row0sel.cc
@@ -974,11 +974,9 @@ row_sel_get_clust_rec(
 		switch (err) {
 		case DB_SUCCESS:
 		case DB_SUCCESS_LOCKED_REC:
-#ifdef HAVE_valgrind_or_MSAN
 			/* Declare the variable uninitialized.
 			It should be set to DB_SUCCESS at func_exit. */
 			MEM_UNDEFINED(&err, sizeof err);
-#endif /* HAVE_valgrind_or_MSAN */
 			break;
 		default:
 			goto err_exit;
@@ -2686,9 +2684,7 @@ row_sel_field_store_in_mysql_format_func(
 	ut_ad(len != UNIV_SQL_NULL);
 	MEM_CHECK_DEFINED(data, len);
 	MEM_CHECK_ADDRESSABLE(dest, templ->mysql_col_len);
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(dest, templ->mysql_col_len);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	byte* pad = dest + len;
 
@@ -3615,9 +3611,7 @@ row_sel_copy_cached_field_for_mysql(
 		row_mysql_read_true_varchar(
 			&len, cache, templ->mysql_length_bytes);
 		len += templ->mysql_length_bytes;
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(buf, templ->mysql_col_len);
-#endif /* HAVE_valgrind_or_MSAN */
 	} else {
 		len = templ->mysql_col_len;
 	}
@@ -3693,9 +3687,7 @@ row_sel_dequeue_cached_row_for_mysql(
 		/* The record is long. Copy it field by field, in case
 		there are some long VARCHAR column of which only a
 		small length is being used. */
-#ifdef HAVE_valgrind_or_MSAN
 		MEM_UNDEFINED(buf, prebuilt->mysql_prefix_len);
-#endif /* HAVE_valgrind_or_MSAN */
 
 		/* First copy the NULL bits. */
 		memcpy(buf, cached_rec, prebuilt->null_bitmap_len);
@@ -3779,10 +3771,8 @@ row_sel_fetch_last_buf(
 	}
 
 	ut_ad(prebuilt->fetch_cache_first == 0);
-#ifdef HAVE_valgrind_or_MSAN
 	MEM_UNDEFINED(prebuilt->fetch_cache[prebuilt->n_fetch_cached],
 		      prebuilt->mysql_row_len);
-#endif /* HAVE_valgrind_or_MSAN */
 
 	return(prebuilt->fetch_cache[prebuilt->n_fetch_cached]);
 }
diff --git a/storage/innobase/row/row0upd.cc b/storage/innobase/row/row0upd.cc
index 969d0017eeb..fe81cb46916 100644
--- a/storage/innobase/row/row0upd.cc
+++ b/storage/innobase/row/row0upd.cc
@@ -1542,9 +1542,7 @@ row_upd_changes_ord_field_binary_func(
 			/* Silence a compiler warning without
 			silencing a Valgrind error. */
 			dfield_len = 0;
-#ifdef HAVE_valgrind_or_MSAN
 			MEM_UNDEFINED(&dfield_len, sizeof dfield_len);
-#endif /* HAVE_valgrind_or_MSAN */
 			/* See if the column is stored externally. */
 			buf = row_ext_lookup(ext, col_no, &dfield_len);
 
diff --git a/storage/innobase/sync/sync0arr.cc b/storage/innobase/sync/sync0arr.cc
index a0203ca6bde..1e8ef62b429 100644
--- a/storage/innobase/sync/sync0arr.cc
+++ b/storage/innobase/sync/sync0arr.cc
@@ -891,7 +891,7 @@ sync_array_print_long_waits_low(
 		return(false);
 	}
 
-#ifdef HAVE_valgrind
+#if defined HAVE_valgrind && !__has_feature(memory_sanitizer)
 	/* Increase the timeouts if running under valgrind because it executes
 	extremely slowly. HAVE_valgrind does not necessary mean that
 	we are running under valgrind but we have no better way to tell.
diff --git a/storage/innobase/trx/trx0trx.cc b/storage/innobase/trx/trx0trx.cc
index eaf127b5a43..a8d3c2ed9b9 100644
--- a/storage/innobase/trx/trx0trx.cc
+++ b/storage/innobase/trx/trx0trx.cc
@@ -454,15 +454,11 @@ void trx_free(trx_t*& trx)
 #ifdef __SANITIZE_ADDRESS__
 	/* Unpoison the memory for innodb_monitor_set_option;
 	it is operating also on the freed transaction objects. */
-	MEM_UNDEFINED(&trx->mutex, sizeof trx->mutex);
+	MEM_MAKE_ADDRESSABLE(&trx->mutex, sizeof trx->mutex);
 	/* For innobase_kill_connection() */
-# ifdef WITH_WSREP
-	MEM_UNDEFINED(&trx->wsrep, sizeof trx->wsrep);
-# endif
-	MEM_UNDEFINED(&trx->state, sizeof trx->state);
-	MEM_UNDEFINED(&trx->mysql_thd, sizeof trx->mysql_thd);
+	MEM_MAKE_ADDRESSABLE(&trx->state, sizeof trx->state);
+	MEM_MAKE_ADDRESSABLE(&trx->mysql_thd, sizeof trx->mysql_thd);
 #endif
-#ifdef HAVE_valgrind_or_MSAN
 	/* Unpoison the memory for innodb_monitor_set_option;
 	it is operating also on the freed transaction objects.
 	We checked that these were initialized in
@@ -474,7 +470,6 @@ void trx_free(trx_t*& trx)
 # endif
 	MEM_MAKE_DEFINED(&trx->state, sizeof trx->state);
 	MEM_MAKE_DEFINED(&trx->mysql_thd, sizeof trx->mysql_thd);
-#endif
 
 	trx = NULL;
 }
diff --git a/storage/tokudb/ha_tokudb.cc b/storage/tokudb/ha_tokudb.cc
index 0b74414a6ae..4555ab3a862 100644
--- a/storage/tokudb/ha_tokudb.cc
+++ b/storage/tokudb/ha_tokudb.cc
@@ -6123,6 +6123,11 @@ void ha_tokudb::position(const uchar * record) {
         //
         memcpy(ref, &key.size, sizeof(uint32_t));
     }
+    /*
+      tokudb doesn't always write the last byte. Don't that cause problems with
+      MariaDB
+    */
+    MEM_MAKE_DEFINED(ref, ref_length);
     TOKUDB_HANDLER_DBUG_VOID_RETURN;
 }