database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-08 11:22:35 +03:00
Code Activity

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

Browse Source
This commit is contained in:
Monty
2020-07-03 00:35:28 +03:00
parent f347b3e0e6 b6ec1e8bbf
commit 5211af1c16
39 changed files with 165 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
client/mysqltest.cc
View File

@@ -10126,7 +10126,7 @@ void append_replace_regex(char* expr, char *expr_end, struct st_replace_regex* r
/* Allow variable for the *entire* list of replacements */ /* Allow variable for the *entire* list of replacements */
if (*p == '$') if (*p == '$')
{ {
const char *v_end; const char *v_end= 0;
VAR *val= var_get(p, &v_end, 0, 1); VAR *val= var_get(p, &v_end, 0, 1);
if (val) if (val)
@@ -10767,7 +10767,7 @@ REPLACE *init_replace(char * *from, char * *to,uint count,
for (i=1 ; i <= found_sets ; i++) for (i=1 ; i <= found_sets ; i++)
{ {
pos=from[found_set[i-1].table_offset]; pos=from[found_set[i-1].table_offset];
rep_str[i].found= !memcmp(pos, "\\^", 3) ? 2 : 1; rep_str[i].found= !strncmp(pos, "\\^", 3) ? 2 : 1;
rep_str[i].replace_string=to_array[found_set[i-1].table_offset]; rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos); rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+ rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+

2
include/my_sys.h
View File

@@ -534,6 +534,7 @@ static inline int my_b_read(IO_CACHE *info, uchar *Buffer, size_t Count)
static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count) static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{ {
MEM_CHECK_DEFINED(Buffer, Count);
if (info->write_pos + Count <= info->write_end) if (info->write_pos + Count <= info->write_end)
{ {
memcpy(info->write_pos, Buffer, Count); memcpy(info->write_pos, Buffer, Count);
@@ -555,6 +556,7 @@ static inline int my_b_get(IO_CACHE *info)
static inline my_bool my_b_write_byte(IO_CACHE *info, uchar chr) static inline my_bool my_b_write_byte(IO_CACHE *info, uchar chr)
{ {
MEM_CHECK_DEFINED(&chr, 1);
if (info->write_pos >= info->write_end) if (info->write_pos >= info->write_end)
if (my_b_flush_io_cache(info, 1)) if (my_b_flush_io_cache(info, 1))
return 1; return 1;

67
include/my_valgrind.h
View File

@@ -24,16 +24,22 @@
# define __SANITIZE_ADDRESS__ 1 # define __SANITIZE_ADDRESS__ 1
#endif #endif
#ifdef HAVE_valgrind #if __has_feature(memory_sanitizer)
#define IF_VALGRIND(A,B) A # include <sanitizer/msan_interface.h>
#else # define HAVE_valgrind
#define IF_VALGRIND(A,B) B # define MEM_UNDEFINED(a,len) __msan_allocated_memory(a,len)
#endif # define MEM_MAKE_ADDRESSABLE(a,len) MEM_UNDEFINED(a,len)
# define MEM_MAKE_DEFINED(a,len) __msan_unpoison(a,len)
#if defined(HAVE_VALGRIND_MEMCHECK_H) && defined(HAVE_valgrind) # 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> # include <valgrind/memcheck.h>
# define HAVE_valgrind_or_MSAN
# define MEM_UNDEFINED(a,len) VALGRIND_MAKE_MEM_UNDEFINED(a,len) # 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_MAKE_DEFINED(a,len) VALGRIND_MAKE_MEM_DEFINED(a,len)
# define MEM_NOACCESS(a,len) VALGRIND_MAKE_MEM_NOACCESS(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) # define MEM_CHECK_ADDRESSABLE(a,len) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(a,len)
@@ -45,27 +51,19 @@
# include <sanitizer/asan_interface.h> # include <sanitizer/asan_interface.h>
/* How to do manual poisoning: /* How to do manual poisoning:
https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning */ 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_MAKE_DEFINED(a,len) ((void) 0)
# define MEM_NOACCESS(a,len) ASAN_POISON_MEMORY_REGION(a,len) # 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_CHECK_DEFINED(a,len) ((void) 0)
# define MEM_GET_VBITS(a,b,len) ((void) 0) # define MEM_GET_VBITS(a,b,len) ((void) 0)
# define MEM_SET_VBITS(a,b,len) ((void) 0) # define MEM_SET_VBITS(a,b,len) ((void) 0)
# define REDZONE_SIZE 8 # 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 #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_MAKE_DEFINED(a,len) ((void) 0)
# define MEM_NOACCESS(a,len) ((void) 0) # define MEM_NOACCESS(a,len) ((void) 0)
# define MEM_CHECK_ADDRESSABLE(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_GET_VBITS(a,b,len) ((void) 0)
# define MEM_SET_VBITS(a,b,len) ((void) 0) # define MEM_SET_VBITS(a,b,len) ((void) 0)
# define REDZONE_SIZE 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 #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 This can happen in the case one does
TRASH_ALLOC(A,B) ; TRASH_FREE(A,B) ; TRASH_ALLOC(A,B) 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. 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 _TRASH_FILL() is an internal function and should not be used externally.
overkill.
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 #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 #endif
/** Note that some memory became allocated or uninitialized. */ /** Note that some memory became allocated and/or uninitialized. */
#define TRASH_ALLOC(A,B) do { TRASH_FILL(A,B,0xA5); MEM_UNDEFINED(A,B); } while(0) #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.) */ /** 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 */ #endif /* MY_VALGRIND_INCLUDED */

4
mysql-test/main/sp-big.result
View File

@@ -82,8 +82,8 @@ Warning 1287 '<select expression> INTO <destination>;' is deprecated and will be
insert t1 select seq, seq, 1, 1, seq, seq, seq from seq_1_to_2000; insert t1 select seq, seq, 1, 1, seq, seq, seq from seq_1_to_2000;
set @before=unix_timestamp(); set @before=unix_timestamp();
call select_test(); call select_test();
select unix_timestamp() - @before < 60; select unix_timestamp() - @before < @time;
unix_timestamp() - @before < 60 unix_timestamp() - @before < @time
1 1
drop procedure select_test; drop procedure select_test;
drop table t1; drop table t1;

13
mysql-test/main/sp-big.test
View File

@@ -112,6 +112,17 @@ delimiter ;//
insert t1 select seq, seq, 1, 1, seq, seq, seq from seq_1_to_2000; insert t1 select seq, seq, 1, 1, seq, seq, seq from seq_1_to_2000;
set @before=unix_timestamp(); set @before=unix_timestamp();
call select_test(); call select_test();
select unix_timestamp() - @before < 60;
--let $time=60
if ($VALGRIND_TEST)
{
--let $time=600
}
--disable_query_log
--eval set @time=$time;
--enable_query_log
select unix_timestamp() - @before < @time;
drop procedure select_test; drop procedure select_test;
drop table t1; drop table t1;

2
mysys/my_alloc.c
View File

@@ -212,7 +212,7 @@ void *alloc_root(MEM_ROOT *mem_root, size_t length)
uchar* point; uchar* point;
reg1 USED_MEM *next= 0; reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev; reg2 USED_MEM **prev;
size_t original_length = length; size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root"); DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p name: %s", mem_root, mem_root->name)); DBUG_PRINT("enter",("root: %p name: %s", mem_root, mem_root->name));
DBUG_ASSERT(alloc_root_inited(mem_root)); DBUG_ASSERT(alloc_root_inited(mem_root));

13
sql/field.cc
View File

@@ -7647,6 +7647,17 @@ int Field_varstring::save_field_metadata(uchar *metadata_ptr)
return 2; return 2;
} }
bool Field_varstring::memcpy_field_possible(const Field *from) const
{
return (Field_str::memcpy_field_possible(from) &&
!compression_method() == !from->compression_method() &&
length_bytes == ((Field_varstring*) from)->length_bytes &&
(table->file && !(table->file->ha_table_flags() &
HA_RECORD_MUST_BE_CLEAN_ON_WRITE)));
}
int Field_varstring::store(const char *from,size_t length,CHARSET_INFO *cs) int Field_varstring::store(const char *from,size_t length,CHARSET_INFO *cs)
{ {
DBUG_ASSERT(marked_for_write_or_computed()); DBUG_ASSERT(marked_for_write_or_computed());
@@ -7709,7 +7720,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() void Field_varstring::mark_unused_memory_as_defined()
{ {
uint used_length= get_length(); uint used_length= get_length();

11
sql/field.h
View File

@@ -826,7 +826,7 @@ public:
return store(ls.str, (uint) ls.length, cs); return store(ls.str, (uint) ls.length, cs);
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
/** /**
Mark unused memory in the field as defined. Mainly used to ensure Mark unused memory in the field as defined. Mainly used to ensure
that if we write full field to disk (for example in that if we write full field to disk (for example in
@@ -3692,15 +3692,10 @@ public:
length_bytes : 0); length_bytes : 0);
} }
Copy_func *get_copy_func(const Field *from) const; Copy_func *get_copy_func(const Field *from) const;
bool memcpy_field_possible(const Field *from) const bool memcpy_field_possible(const Field *from) const;
{
return Field_str::memcpy_field_possible(from) &&
!compression_method() == !from->compression_method() &&
length_bytes == ((Field_varstring*) from)->length_bytes;
}
int store(const char *to,size_t length,CHARSET_INFO *charset); int store(const char *to,size_t length,CHARSET_INFO *charset);
using Field_str::store; using Field_str::store;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
void mark_unused_memory_as_defined(); void mark_unused_memory_as_defined();
#endif #endif
double val_real(void); double val_real(void);

2
sql/ha_partition.cc
View File

@@ -2548,7 +2548,7 @@ register_query_cache_dependant_tables(THD *thd,
sub_elem= subpart_it++; sub_elem= subpart_it++;
part= i * num_subparts + j; part= i * num_subparts + j;
/* we store the end \0 as part of the key */ /* we store the end \0 as part of the key */
end= strmov(engine_pos, sub_elem->partition_name); end= strmov(engine_pos, sub_elem->partition_name) + 1;
length= (uint)(end - engine_key); length= (uint)(end - engine_key);
/* Copy the suffix also to query cache key */ /* Copy the suffix also to query cache key */
memcpy(query_cache_key_end, engine_key_end, (end - engine_key_end)); memcpy(query_cache_key_end, engine_key_end, (end - engine_key_end));

3
sql/handler.h
View File

@@ -213,7 +213,8 @@ enum enum_alter_inplace_result {
#define HA_HAS_NEW_CHECKSUM (1ULL << 38) #define HA_HAS_NEW_CHECKSUM (1ULL << 38)
#define HA_CAN_VIRTUAL_COLUMNS (1ULL << 39) #define HA_CAN_VIRTUAL_COLUMNS (1ULL << 39)
#define HA_MRR_CANT_SORT (1ULL << 40) #define HA_MRR_CANT_SORT (1ULL << 40)
#define HA_RECORD_MUST_BE_CLEAN_ON_WRITE (1ULL << 41) /* unused */ /* All of VARCHAR is stored, including bytes after real varchar data */
#define HA_RECORD_MUST_BE_CLEAN_ON_WRITE (1ULL << 41)
/* /*
This storage engine supports condition pushdown This storage engine supports condition pushdown

2
sql/item_subselect.cc
View File

@@ -727,7 +727,7 @@ bool Item_subselect::exec()
push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE, push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
ER_UNKNOWN_ERROR, "DBUG: Item_subselect::exec %.*s", ER_UNKNOWN_ERROR, "DBUG: Item_subselect::exec %.*s",
print.length(),print.c_ptr()); print.length(),print.ptr());
); );
/* /*
Do not execute subselect in case of a fatal error Do not execute subselect in case of a fatal error

12
sql/session_tracker.cc
View File

@@ -380,16 +380,12 @@ bool Session_sysvars_tracker::enable(THD *thd)
bool Session_sysvars_tracker::update(THD *thd, set_var *var) bool Session_sysvars_tracker::update(THD *thd, set_var *var)
{ {
vars_list tool_list; vars_list tool_list;
void *copy;
size_t length= 1; size_t length= 1;
void *copy= var->save_result.string_value.str ?
if (var->save_result.string_value.str) my_memdup(var->save_result.string_value.str,
copy= my_memdup(var->save_result.string_value.str,
(length= var->save_result.string_value.length + 1), (length= var->save_result.string_value.length + 1),
MYF(MY_WME | MY_THREAD_SPECIFIC)); MYF(MY_WME | MY_THREAD_SPECIFIC)) :
else my_strdup("", MYF(MY_WME | MY_THREAD_SPECIFIC));
copy= my_strdup("", MYF(MY_WME | MY_THREAD_SPECIFIC));
if (!copy) if (!copy)
return true; return true;

39
sql/sql_select.cc
View File

@@ -6585,6 +6585,7 @@ add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
keyuse.keypart= FT_KEYPART; keyuse.keypart= FT_KEYPART;
keyuse.used_tables=cond_func->key_item()->used_tables(); keyuse.used_tables=cond_func->key_item()->used_tables();
keyuse.optimize= 0; keyuse.optimize= 0;
keyuse.ref_table_rows= 0;
keyuse.keypart_map= 0; keyuse.keypart_map= 0;
keyuse.sj_pred_no= UINT_MAX; keyuse.sj_pred_no= UINT_MAX;
keyuse.validity_ref= 0; keyuse.validity_ref= 0;
@@ -9154,7 +9155,7 @@ double table_cond_selectivity(JOIN *join, uint idx, JOIN_TAB *s,
/* /*
Check if we have a prefix of key=const that matches a quick select. Check if we have a prefix of key=const that matches a quick select.
*/ */
if (!is_hash_join_key_no(key)) if (!is_hash_join_key_no(key) && table->quick_keys.is_set(key))
{ {
key_part_map quick_key_map= (key_part_map(1) << table->quick_key_parts[key]) - 1; key_part_map quick_key_map= (key_part_map(1) << table->quick_key_parts[key]) - 1;
if (table->quick_rows[key] && if (table->quick_rows[key] &&
@@ -18653,16 +18654,22 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
inherit the default value that is defined for the field referred inherit the default value that is defined for the field referred
by the Item_field object from which 'field' has been created. by the Item_field object from which 'field' has been created.
*/ */
const Field *orig_field= default_field[i]; Field *orig_field= default_field[i];
/* Get the value from default_values */ /* Get the value from default_values */
if (orig_field->is_null_in_record(orig_field->table->s->default_values)) if (orig_field->is_null_in_record(orig_field->table->s->default_values))
field->set_null(); field->set_null();
else 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(); field->set_notnull();
memcpy(field->ptr, orig_field->move_field_offset(ptr_diff);
orig_field->ptr_in_record(orig_field->table->s->default_values), field_conv(field, orig_field);
field->pack_length_in_rec()); orig_field->move_field_offset(-ptr_diff);
} }
} }
@@ -18671,7 +18678,7 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
copy->set(field,from_field[i],save_sum_fields); copy->set(field,from_field[i],save_sum_fields);
copy++; copy++;
} }
length=field->pack_length(); length=field->pack_length_in_rec();
pos+= length; pos+= length;
/* Make entry for create table */ /* Make entry for create table */
@@ -18693,6 +18700,9 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
// fix table name in field entry // fix table name in field entry
field->set_table_name(&table->alias); 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);
param->copy_field_end=copy; param->copy_field_end=copy;
param->recinfo= recinfo; // Pointer to after last field param->recinfo= recinfo; // Pointer to after last field
@@ -18962,8 +18972,9 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
goto err; goto err;
} }
// Make empty record so random data is not written to disk /* record[0] and share->default_values should now have been set up */
empty_record(table); MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
MEM_CHECK_DEFINED(share->default_values, table->s->reclength);
thd->mem_root= mem_root_save; thd->mem_root= mem_root_save;
@@ -19256,6 +19267,10 @@ bool create_internal_tmp_table(TABLE *table, KEY *keyinfo,
(*recinfo)->type= FIELD_CHECK; (*recinfo)->type= FIELD_CHECK;
(*recinfo)->length= MARIA_UNIQUE_HASH_LENGTH; (*recinfo)->length= MARIA_UNIQUE_HASH_LENGTH;
(*recinfo)++; (*recinfo)++;
/* 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; share->reclength+= MARIA_UNIQUE_HASH_LENGTH;
} }
else else
@@ -19450,6 +19465,9 @@ bool create_internal_tmp_table(TABLE *table, KEY *keyinfo,
(*recinfo)->type= FIELD_CHECK; (*recinfo)->type= FIELD_CHECK;
(*recinfo)->length=MI_UNIQUE_HASH_LENGTH; (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
(*recinfo)++; (*recinfo)++;
/* 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; share->reclength+= MI_UNIQUE_HASH_LENGTH;
} }
else else
@@ -20042,11 +20060,11 @@ bool instantiate_tmp_table(TABLE *table, KEY *keyinfo,
If it is not heap (in-memory) table then convert index to unique If it is not heap (in-memory) table then convert index to unique
constrain. constrain.
*/ */
MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
if (create_internal_tmp_table(table, keyinfo, start_recinfo, recinfo, if (create_internal_tmp_table(table, keyinfo, start_recinfo, recinfo,
options)) options))
return TRUE; return TRUE;
// Make empty record so random data is not written to disk MEM_CHECK_DEFINED(table->record[0], table->s->reclength);
empty_record(table);
} }
if (open_tmp_table(table)) if (open_tmp_table(table))
return TRUE; return TRUE;
@@ -28601,7 +28619,6 @@ AGGR_OP::prepare_tmp_table()
join->select_options)) join->select_options))
return true; return true;
(void) table->file->extra(HA_EXTRA_WRITE_CACHE); (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 it wasn't already, start index scan for grouping using table index. */
if (!table->file->inited && table->group && if (!table->file->inited && table->group &&

17
sql/table.cc
View File

@@ -1962,8 +1962,8 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
share->rec_buff_length= rec_buff_length; share->rec_buff_length= rec_buff_length;
if (!(record= (uchar *) alloc_root(&share->mem_root, rec_buff_length))) if (!(record= (uchar *) alloc_root(&share->mem_root, rec_buff_length)))
goto err; /* purecov: inspected */ goto err; /* purecov: inspected */
MEM_NOACCESS(record, rec_buff_length); /* Mark bytes after record as not accessable to catch overrun bugs */
MEM_UNDEFINED(record, share->reclength); MEM_NOACCESS(record + share->reclength, rec_buff_length - share->reclength);
share->default_values= record; share->default_values= record;
memcpy(record, frm_image + record_offset, share->reclength); memcpy(record, frm_image + record_offset, share->reclength);
@@ -3690,7 +3690,6 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
if (!(record= (uchar*) alloc_root(&outparam->mem_root, if (!(record= (uchar*) alloc_root(&outparam->mem_root,
share->rec_buff_length * records))) share->rec_buff_length * records)))
goto err; /* purecov: inspected */ goto err; /* purecov: inspected */
MEM_NOACCESS(record, share->rec_buff_length * records);
} }
for (i= 0; i < 3;) for (i= 0; i < 3;)
@@ -3699,8 +3698,10 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
if (++i < records) if (++i < records)
record+= share->rec_buff_length; record+= share->rec_buff_length;
} }
/* Mark bytes between records as not accessable to catch overrun bugs */
for (i= 0; i < records; i++) 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, if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
(uint) ((share->fields+1)* (uint) ((share->fields+1)*
@@ -9700,10 +9701,10 @@ bool TABLE::export_structure(THD *thd, Row_definition_list *defs)
void TABLE::initialize_quick_structures() void TABLE::initialize_quick_structures()
{ {
bzero(quick_rows, sizeof(quick_rows)); TRASH_ALLOC(quick_rows, sizeof(quick_rows));
bzero(quick_key_parts, sizeof(quick_key_parts)); TRASH_ALLOC(quick_key_parts, sizeof(quick_key_parts));
bzero(quick_costs, sizeof(quick_costs)); TRASH_ALLOC(quick_costs, sizeof(quick_costs));
bzero(quick_n_ranges, sizeof(quick_n_ranges)); TRASH_ALLOC(quick_n_ranges, sizeof(quick_n_ranges));
} }
/* /*

4
sql/unireg.cc
View File

@@ -477,8 +477,8 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING &table,
pos+= create_info->comment.length; pos+= create_info->comment.length;
} }
memcpy(frm_ptr + filepos, forminfo, 288); memcpy(frm_ptr + filepos, forminfo, FRM_FORMINFO_SIZE);
pos= frm_ptr + filepos + 288; pos= frm_ptr + filepos + FRM_FORMINFO_SIZE;
if (pack_fields(&pos, create_fields, create_info, data_offset)) if (pack_fields(&pos, create_fields, create_info, data_offset))
goto err; goto err;

6
storage/innobase/btr/btr0cur.cc
View File

@@ -1314,12 +1314,10 @@ btr_cur_search_to_nth_level_func(
ut_ad(!(index->type & DICT_FTS)); ut_ad(!(index->type & DICT_FTS));
ut_ad(index->page != FIL_NULL); ut_ad(index->page != FIL_NULL);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&cursor->up_match, sizeof cursor->up_match); MEM_UNDEFINED(&cursor->up_match, sizeof cursor->up_match);
MEM_UNDEFINED(&cursor->up_bytes, sizeof cursor->up_bytes); MEM_UNDEFINED(&cursor->up_bytes, sizeof cursor->up_bytes);
MEM_UNDEFINED(&cursor->low_match, sizeof cursor->low_match); MEM_UNDEFINED(&cursor->low_match, sizeof cursor->low_match);
MEM_UNDEFINED(&cursor->low_bytes, sizeof cursor->low_bytes); MEM_UNDEFINED(&cursor->low_bytes, sizeof cursor->low_bytes);
#endif /* HAVE_valgrind_or_MSAN */
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
cursor->up_match = ULINT_UNDEFINED; cursor->up_match = ULINT_UNDEFINED;
cursor->low_match = ULINT_UNDEFINED; cursor->low_match = ULINT_UNDEFINED;
@@ -3426,12 +3424,12 @@ btr_cur_optimistic_insert(
|| (flags & BTR_CREATE_FLAG)); || (flags & BTR_CREATE_FLAG));
ut_ad(dtuple_check_typed(entry)); ut_ad(dtuple_check_typed(entry));
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
if (block->page.zip.data) { if (block->page.zip.data) {
MEM_CHECK_DEFINED(page, srv_page_size); MEM_CHECK_DEFINED(page, srv_page_size);
MEM_CHECK_DEFINED(block->page.zip.data, block->zip_size()); MEM_CHECK_DEFINED(block->page.zip.data, block->zip_size());
} }
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
leaf = page_is_leaf(page); leaf = page_is_leaf(page);

2
storage/innobase/buf/buf0buddy.cc
View File

@@ -393,9 +393,7 @@ buf_buddy_block_free(
HASH_DELETE(buf_page_t, hash, buf_pool->zip_hash, fold, bpage); HASH_DELETE(buf_page_t, hash, buf_pool->zip_hash, fold, bpage);
ut_d(memset(buf, 0, srv_page_size)); ut_d(memset(buf, 0, srv_page_size));
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(buf, srv_page_size); MEM_UNDEFINED(buf, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */
block = (buf_block_t*) bpage; block = (buf_block_t*) bpage;
buf_page_mutex_enter(block); buf_page_mutex_enter(block);

8
storage/innobase/buf/buf0lru.cc
View File

@@ -806,7 +806,7 @@ buf_LRU_get_free_only(
assert_block_ahi_empty(block); assert_block_ahi_empty(block);
buf_block_set_state(block, BUF_BLOCK_READY_FOR_USE); buf_block_set_state(block, BUF_BLOCK_READY_FOR_USE);
MEM_UNDEFINED(block->frame, srv_page_size); MEM_MAKE_ADDRESSABLE(block->frame, srv_page_size);
ut_ad(buf_pool_from_block(block) == buf_pool); ut_ad(buf_pool_from_block(block) == buf_pool);
@@ -1605,13 +1605,9 @@ func_exit:
order to avoid bogus Valgrind or MSAN warnings.*/ order to avoid bogus Valgrind or MSAN warnings.*/
buf_block_t* block = reinterpret_cast<buf_block_t*>(bpage); buf_block_t* block = reinterpret_cast<buf_block_t*>(bpage);
#ifdef HAVE_valgrind_or_MSAN
MEM_MAKE_DEFINED(block->frame, srv_page_size); MEM_MAKE_DEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */
btr_search_drop_page_hash_index(block); btr_search_drop_page_hash_index(block);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(block->frame, srv_page_size); MEM_UNDEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */
buf_pool_mutex_enter(buf_pool); buf_pool_mutex_enter(buf_pool);
@@ -1656,9 +1652,7 @@ buf_LRU_block_free_non_file_page(
buf_block_set_state(block, BUF_BLOCK_NOT_USED); buf_block_set_state(block, BUF_BLOCK_NOT_USED);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(block->frame, srv_page_size); MEM_UNDEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */
/* Wipe page_no and space_id */ /* Wipe page_no and space_id */
memset(block->frame + FIL_PAGE_OFFSET, 0xfe, 4); memset(block->frame + FIL_PAGE_OFFSET, 0xfe, 4);
memset(block->frame + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, 0xfe, 4); memset(block->frame + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, 0xfe, 4);

4
storage/innobase/data/data0data.cc
View File

@@ -234,7 +234,7 @@ dtuple_validate(
const dtuple_t* tuple) /*!< in: tuple */ const dtuple_t* tuple) /*!< in: tuple */
{ {
ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N); 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); const ulint n_fields = dtuple_get_n_fields(tuple);
for (ulint i = 0; i < n_fields; i++) { for (ulint i = 0; i < n_fields; i++) {
@@ -245,7 +245,7 @@ dtuple_validate(
dfield_get_len(field)); dfield_get_len(field));
} }
} }
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
ut_ad(dtuple_check_typed(tuple)); ut_ad(dtuple_check_typed(tuple));
return(TRUE); return(TRUE);

3
storage/innobase/fil/fil0fil.cc
View File

@@ -2212,7 +2212,8 @@ static ulint fil_check_pending_ops(const fil_space_t* space, ulint count)
if (ulint n_pending_ops = space->n_pending_ops) { if (ulint n_pending_ops = space->n_pending_ops) {
if (count > 5000) { /* Give a warning every 10 second, starting after 1 second */
if ((count % 500) == 50) {
ib::warn() << "Trying to delete" ib::warn() << "Trying to delete"
" tablespace '" << space->name " tablespace '" << space->name
<< "' but there are " << n_pending_ops << "' but there are " << n_pending_ops

4
storage/innobase/handler/ha_innodb.cc
View File

@@ -7333,9 +7333,7 @@ build_template_field(
ut_ad(clust_index->table == index->table); ut_ad(clust_index->table == index->table);
templ = prebuilt->mysql_template + prebuilt->n_template++; templ = prebuilt->mysql_template + prebuilt->n_template++;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(templ, sizeof *templ); MEM_UNDEFINED(templ, sizeof *templ);
#endif /* HAVE_valgrind_or_MSAN */
templ->is_virtual = !field->stored_in_db(); templ->is_virtual = !field->stored_in_db();
if (!templ->is_virtual) { if (!templ->is_virtual) {
@@ -8445,9 +8443,7 @@ calc_row_difference(
/* The field has changed */ /* The field has changed */
ufield = uvect->fields + n_changed; ufield = uvect->fields + n_changed;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(ufield, sizeof *ufield); MEM_UNDEFINED(ufield, sizeof *ufield);
#endif /* HAVE_valgrind_or_MSAN */
/* Let us use a dummy dfield to make the conversion /* Let us use a dummy dfield to make the conversion
from the MySQL column format to the InnoDB format */ from the MySQL column format to the InnoDB format */

4
storage/innobase/include/dict0stats.ic
View File

@@ -187,7 +187,7 @@ dict_stats_deinit(
table->stat_initialized = FALSE; 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_n_rows, sizeof table->stat_n_rows);
MEM_UNDEFINED(&table->stat_clustered_index_size, MEM_UNDEFINED(&table->stat_clustered_index_size,
sizeof table->stat_clustered_index_size); sizeof table->stat_clustered_index_size);
@@ -220,7 +220,7 @@ dict_stats_deinit(
&index->stat_n_leaf_pages, &index->stat_n_leaf_pages,
sizeof(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); rw_lock_x_unlock(&table->stats_latch);
} }

2
storage/innobase/include/mem0mem.ic
View File

@@ -203,7 +203,7 @@ mem_heap_alloc(
mem_block_set_free(block, free + MEM_SPACE_NEEDED(n)); mem_block_set_free(block, free + MEM_SPACE_NEEDED(n));
buf = buf + REDZONE_SIZE; buf = buf + REDZONE_SIZE;
MEM_UNDEFINED(buf, n - REDZONE_SIZE); MEM_MAKE_ADDRESSABLE(buf, n - REDZONE_SIZE);
return(buf); return(buf);
} }

6
storage/innobase/include/srv0mon.h
View File

@@ -654,14 +654,14 @@ Use MONITOR_DEC if appropriate mutex protection exists.
} \ } \
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
# define MONITOR_CHECK_DEFINED(value) do { \ # define MONITOR_CHECK_DEFINED(value) do { \
mon_type_t m = value; \ mon_type_t m = value; \
MEM_CHECK_DEFINED(&m, sizeof m); \ MEM_CHECK_DEFINED(&m, sizeof m); \
} while (0) } while (0)
#else /* HAVE_valgrind_or_MSAN */ #else /* HAVE_valgrind */
# define MONITOR_CHECK_DEFINED(value) (void) 0 # define MONITOR_CHECK_DEFINED(value) (void) 0
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
#define MONITOR_INC_VALUE(monitor, value) \ #define MONITOR_INC_VALUE(monitor, value) \
MONITOR_CHECK_DEFINED(value); \ MONITOR_CHECK_DEFINED(value); \

14
storage/innobase/include/ut0pool.h
View File

@@ -89,13 +89,12 @@ struct Pool {
ut_ad(elem->m_pool == this); ut_ad(elem->m_pool == this);
#ifdef __SANITIZE_ADDRESS__ #ifdef __SANITIZE_ADDRESS__
/* Unpoison the memory for AddressSanitizer */ /* 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 #endif
#ifdef HAVE_valgrind /* Declare the contents initialized;
/* Declare the contents as initialized for Valgrind;
we checked this in mem_free(). */ we checked this in mem_free(). */
MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type); MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type);
#endif
Factory::destroy(&elem->m_type); Factory::destroy(&elem->m_type);
} }
@@ -134,14 +133,13 @@ struct Pool {
if (elem) { if (elem) {
# ifdef __SANITIZE_ADDRESS__ # ifdef __SANITIZE_ADDRESS__
/* Unpoison the memory for AddressSanitizer */ /* 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 # endif
# ifdef HAVE_valgrind /* Declare the memory initialized.
/* Declare the memory initialized for Valgrind.
The trx_t that are released to the pool are The trx_t that are released to the pool are
actually initialized; we checked that by actually initialized; we checked that by
MEM_CHECK_DEFINED() in mem_free() below. */ MEM_CHECK_DEFINED() in mem_free() below. */
# endif
MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type); MEM_MAKE_DEFINED(&elem->m_type, sizeof elem->m_type);
} }
#endif #endif

2
storage/innobase/os/os0proc.cc
View File

@@ -158,7 +158,7 @@ os_mem_free_large(
// And we must unpoison it by ourself as specified in documentation // And we must unpoison it by ourself as specified in documentation
// for __asan_poison_memory_region() in sanitizer/asan_interface.h // for __asan_poison_memory_region() in sanitizer/asan_interface.h
// munmap() doesn't do it for us automatically. // munmap() doesn't do it for us automatically.
MEM_UNDEFINED(ptr, size); MEM_MAKE_ADDRESSABLE(ptr, size);
#endif /* __SANITIZE_ADDRESS__ */ #endif /* __SANITIZE_ADDRESS__ */
#ifdef HAVE_LINUX_LARGE_PAGES #ifdef HAVE_LINUX_LARGE_PAGES

8
storage/innobase/page/page0cur.cc
View File

@@ -1248,7 +1248,7 @@ page_cur_insert_rec_low(
/* 1. Get the size of the physical record in the page */ /* 1. Get the size of the physical record in the page */
rec_size = rec_offs_size(offsets); rec_size = rec_offs_size(offsets);
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
{ {
const void* rec_start const void* rec_start
= rec - rec_offs_extra_size(offsets); = rec - rec_offs_extra_size(offsets);
@@ -1263,7 +1263,7 @@ page_cur_insert_rec_low(
/* The variable-length header must be valid. */ /* The variable-length header must be valid. */
MEM_CHECK_DEFINED(rec_start, extra_size); 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 */ /* 2. Try to find suitable space from page memory management */
@@ -1478,7 +1478,7 @@ page_cur_insert_rec_zip(
/* 1. Get the size of the physical record in the page */ /* 1. Get the size of the physical record in the page */
rec_size = rec_offs_size(offsets); rec_size = rec_offs_size(offsets);
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
{ {
const void* rec_start const void* rec_start
= rec - rec_offs_extra_size(offsets); = rec - rec_offs_extra_size(offsets);
@@ -1493,7 +1493,7 @@ page_cur_insert_rec_zip(
/* The variable-length header must be valid. */ /* The variable-length header must be valid. */
MEM_CHECK_DEFINED(rec_start, extra_size); MEM_CHECK_DEFINED(rec_start, extra_size);
} }
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
const bool reorg_before_insert = page_has_garbage(page) const bool reorg_before_insert = page_has_garbage(page)
&& rec_size > page_get_max_insert_size(page, 1) && rec_size > page_get_max_insert_size(page, 1)

4
storage/innobase/page/page0zip.cc
View File

@@ -1530,11 +1530,11 @@ err_exit:
ut_ad(buf + c_stream.total_out == c_stream.next_out); ut_ad(buf + c_stream.total_out == c_stream.next_out);
ut_ad((ulint) (storage - c_stream.next_out) >= c_stream.avail_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 /* Valgrind believes that zlib does not initialize some bits
in the last 7 or 8 bytes of the stream. Make Valgrind happy. */ in the last 7 or 8 bytes of the stream. Make Valgrind happy. */
MEM_MAKE_DEFINED(buf, c_stream.total_out); 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. /* Zero out the area reserved for the modification log.
Space for the end marker of the modification log is not Space for the end marker of the modification log is not

4
storage/innobase/row/row0ftsort.cc
View File

@@ -998,14 +998,14 @@ exit:
goto func_exit; goto func_exit;
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(block[i], srv_sort_buf_size); MEM_UNDEFINED(block[i], srv_sort_buf_size);
if (crypt_block[i]) { if (crypt_block[i]) {
MEM_UNDEFINED(crypt_block[i], MEM_UNDEFINED(crypt_block[i],
srv_sort_buf_size); srv_sort_buf_size);
} }
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
} }
buf[i] = row_merge_buf_empty(buf[i]); buf[i] = row_merge_buf_empty(buf[i]);

2
storage/innobase/row/row0ins.cc
View File

@@ -1242,10 +1242,8 @@ row_ins_foreign_check_on_constraint(
update->info_bits = 0; update->info_bits = 0;
update->n_fields = foreign->n_fields; update->n_fields = foreign->n_fields;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(update->fields, MEM_UNDEFINED(update->fields,
update->n_fields * sizeof *update->fields); update->n_fields * sizeof *update->fields);
#endif /* HAVE_valgrind_or_MSAN */
bool affects_fulltext = false; bool affects_fulltext = false;

18
storage/innobase/row/row0log.cc
View File

@@ -374,9 +374,7 @@ row_log_online_op(
goto err_exit; goto err_exit;
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */
ut_ad(log->tail.bytes < srv_sort_buf_size); ut_ad(log->tail.bytes < srv_sort_buf_size);
avail_size = srv_sort_buf_size - log->tail.bytes; avail_size = srv_sort_buf_size - log->tail.bytes;
@@ -461,10 +459,8 @@ write_failed:
index->type |= DICT_CORRUPT; index->type |= DICT_CORRUPT;
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.block, srv_sort_buf_size); MEM_UNDEFINED(log->tail.block, srv_sort_buf_size);
MEM_UNDEFINED(buf, 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, memcpy(log->tail.block, log->tail.buf + avail_size,
mrec_size - avail_size); mrec_size - avail_size);
@@ -474,9 +470,7 @@ write_failed:
ut_ad(b == log->tail.block + log->tail.bytes); ut_ad(b == log->tail.block + log->tail.bytes);
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */
err_exit: err_exit:
mutex_exit(&log->mutex); mutex_exit(&log->mutex);
} }
@@ -508,9 +502,7 @@ row_log_table_open(
{ {
mutex_enter(&log->mutex); mutex_enter(&log->mutex);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */
if (log->error != DB_SUCCESS) { if (log->error != DB_SUCCESS) {
err_exit: err_exit:
@@ -602,10 +594,9 @@ row_log_table_close_func(
write_failed: write_failed:
log->error = DB_ONLINE_LOG_TOO_BIG; log->error = DB_ONLINE_LOG_TOO_BIG;
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.block, srv_sort_buf_size); MEM_UNDEFINED(log->tail.block, srv_sort_buf_size);
MEM_UNDEFINED(buf, 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); memcpy(log->tail.block, log->tail.buf + avail, size - avail);
log->tail.bytes = size - avail; log->tail.bytes = size - avail;
} else { } else {
@@ -614,9 +605,7 @@ write_failed:
} }
log->tail.total += size; log->tail.total += size;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */
err_exit: err_exit:
mutex_exit(&log->mutex); 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 > 0);
ut_ad(new_trx_id_col != ULINT_UNDEFINED); ut_ad(new_trx_id_col != ULINT_UNDEFINED);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&mrec_end, sizeof mrec_end); MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
#endif /* HAVE_valgrind_or_MSAN */
offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets)); offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets));
rec_offs_set_n_alloc(offsets, i); rec_offs_set_n_alloc(offsets, i);
@@ -3701,9 +3688,8 @@ row_log_apply_ops(
ut_ad(!index->is_committed()); ut_ad(!index->is_committed());
ut_ad(rw_lock_own(dict_index_get_lock(index), RW_LOCK_X)); ut_ad(rw_lock_own(dict_index_get_lock(index), RW_LOCK_X));
ut_ad(index->online_log); ut_ad(index->online_log);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&mrec_end, sizeof mrec_end); MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
#endif /* HAVE_valgrind_or_MSAN */
offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets)); offsets = static_cast<rec_offs*>(ut_malloc_nokey(i * sizeof *offsets));
rec_offs_set_n_alloc(offsets, i); rec_offs_set_n_alloc(offsets, i);

14
storage/innobase/row/row0merge.cc
View File

@@ -1027,11 +1027,11 @@ row_merge_buf_write(
ut_a(b < &block[srv_sort_buf_size]); ut_a(b < &block[srv_sort_buf_size]);
ut_a(b == &block[0] + buf->total_size); ut_a(b == &block[0] + buf->total_size);
*b++ = 0; *b++ = 0;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
/* The rest of the block is uninitialized. Initialize it /* The rest of the block is uninitialized. Initialize it
to avoid bogus warnings. */ to avoid bogus warnings. */
memset(b, 0xff, &block[srv_sort_buf_size] - b); memset(b, 0xff, &block[srv_sort_buf_size] - b);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
DBUG_LOG("ib_merge_sort", DBUG_LOG("ib_merge_sort",
"write " << reinterpret_cast<const void*>(b) << ',' "write " << reinterpret_cast<const void*>(b) << ','
<< of->fd << ',' << of->offset << " EOF"); << of->fd << ',' << of->offset << " EOF");
@@ -1424,9 +1424,7 @@ row_merge_write_rec(
return(NULL); return(NULL);
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&block[0], srv_sort_buf_size); MEM_UNDEFINED(&block[0], srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */
/* Copy the rest. */ /* Copy the rest. */
b = &block[0]; b = &block[0];
@@ -1477,9 +1475,7 @@ row_merge_write_eof(
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&block[0], srv_sort_buf_size); MEM_UNDEFINED(&block[0], srv_sort_buf_size);
#endif
DBUG_RETURN(&block[0]); DBUG_RETURN(&block[0]);
} }
@@ -2679,10 +2675,8 @@ write_buffers:
break; break;
} }
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED( MEM_UNDEFINED(
&block[0], srv_sort_buf_size); &block[0], srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */
} }
} }
merge_buf[i] = row_merge_buf_empty(buf); merge_buf[i] = row_merge_buf_empty(buf);
@@ -3202,9 +3196,7 @@ row_merge(
foffs0 = 0; foffs0 = 0;
foffs1 = ihalf; foffs1 = ihalf;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(run_offset, *num_run * sizeof *run_offset); MEM_UNDEFINED(run_offset, *num_run * sizeof *run_offset);
#endif /* HAVE_valgrind_or_MSAN */
for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) { for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) {
@@ -3285,9 +3277,7 @@ row_merge(
*tmpfd = file->fd; *tmpfd = file->fd;
*file = of; *file = of;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&block[0], 3 * srv_sort_buf_size); MEM_UNDEFINED(&block[0], 3 * srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */
return(DB_SUCCESS); return(DB_SUCCESS);
} }

10
storage/innobase/row/row0sel.cc
View File

@@ -984,11 +984,9 @@ row_sel_get_clust_rec(
switch (err) { switch (err) {
case DB_SUCCESS: case DB_SUCCESS:
case DB_SUCCESS_LOCKED_REC: case DB_SUCCESS_LOCKED_REC:
#ifdef HAVE_valgrind_or_MSAN
/* Declare the variable uninitialized. /* Declare the variable uninitialized.
It should be set to DB_SUCCESS at func_exit. */ It should be set to DB_SUCCESS at func_exit. */
MEM_UNDEFINED(&err, sizeof err); MEM_UNDEFINED(&err, sizeof err);
#endif /* HAVE_valgrind_or_MSAN */
break; break;
default: default:
goto err_exit; goto err_exit;
@@ -2705,9 +2703,7 @@ row_sel_field_store_in_mysql_format_func(
ut_ad(len != UNIV_SQL_NULL); ut_ad(len != UNIV_SQL_NULL);
MEM_CHECK_DEFINED(data, len); MEM_CHECK_DEFINED(data, len);
MEM_CHECK_ADDRESSABLE(dest, templ->mysql_col_len); MEM_CHECK_ADDRESSABLE(dest, templ->mysql_col_len);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(dest, templ->mysql_col_len); MEM_UNDEFINED(dest, templ->mysql_col_len);
#endif /* HAVE_valgrind_or_MSAN */
byte* pad = dest + len; byte* pad = dest + len;
@@ -3612,9 +3608,7 @@ row_sel_copy_cached_field_for_mysql(
row_mysql_read_true_varchar( row_mysql_read_true_varchar(
&len, cache, templ->mysql_length_bytes); &len, cache, templ->mysql_length_bytes);
len += templ->mysql_length_bytes; len += templ->mysql_length_bytes;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(buf, templ->mysql_col_len); MEM_UNDEFINED(buf, templ->mysql_col_len);
#endif /* HAVE_valgrind_or_MSAN */
} else { } else {
len = templ->mysql_col_len; len = templ->mysql_col_len;
} }
@@ -3683,9 +3677,7 @@ row_sel_dequeue_cached_row_for_mysql(
/* The record is long. Copy it field by field, in case /* The record is long. Copy it field by field, in case
there are some long VARCHAR column of which only a there are some long VARCHAR column of which only a
small length is being used. */ small length is being used. */
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(buf, prebuilt->mysql_prefix_len); MEM_UNDEFINED(buf, prebuilt->mysql_prefix_len);
#endif /* HAVE_valgrind_or_MSAN */
/* First copy the NULL bits. */ /* First copy the NULL bits. */
ut_memcpy(buf, cached_rec, prebuilt->null_bitmap_len); ut_memcpy(buf, cached_rec, prebuilt->null_bitmap_len);
@@ -3769,10 +3761,8 @@ row_sel_fetch_last_buf(
} }
ut_ad(prebuilt->fetch_cache_first == 0); ut_ad(prebuilt->fetch_cache_first == 0);
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(prebuilt->fetch_cache[prebuilt->n_fetch_cached], MEM_UNDEFINED(prebuilt->fetch_cache[prebuilt->n_fetch_cached],
prebuilt->mysql_row_len); prebuilt->mysql_row_len);
#endif /* HAVE_valgrind_or_MSAN */
return(prebuilt->fetch_cache[prebuilt->n_fetch_cached]); return(prebuilt->fetch_cache[prebuilt->n_fetch_cached]);
} }

2
storage/innobase/row/row0upd.cc
View File

@@ -1849,9 +1849,7 @@ row_upd_changes_ord_field_binary_func(
/* Silence a compiler warning without /* Silence a compiler warning without
silencing a Valgrind error. */ silencing a Valgrind error. */
dfield_len = 0; dfield_len = 0;
#ifdef HAVE_valgrind_or_MSAN
MEM_UNDEFINED(&dfield_len, sizeof dfield_len); MEM_UNDEFINED(&dfield_len, sizeof dfield_len);
#endif /* HAVE_valgrind_or_MSAN */
/* See if the column is stored externally. */ /* See if the column is stored externally. */
buf = row_ext_lookup(ext, col_no, &dfield_len); buf = row_ext_lookup(ext, col_no, &dfield_len);

2
storage/innobase/sync/sync0arr.cc
View File

@@ -976,7 +976,7 @@ sync_array_print_long_waits_low(
return(false); return(false);
} }
#ifdef HAVE_valgrind #if defined HAVE_valgrind && !__has_feature(memory_sanitizer)
/* Increase the timeouts if running under valgrind because it executes /* Increase the timeouts if running under valgrind because it executes
extremely slowly. HAVE_valgrind does not necessary mean that extremely slowly. HAVE_valgrind does not necessary mean that
we are running under valgrind but we have no better way to tell. we are running under valgrind but we have no better way to tell.

11
storage/innobase/trx/trx0trx.cc
View File

@@ -457,15 +457,11 @@ void trx_free(trx_t*& trx)
#ifdef __SANITIZE_ADDRESS__ #ifdef __SANITIZE_ADDRESS__
/* Unpoison the memory for innodb_monitor_set_option; /* Unpoison the memory for innodb_monitor_set_option;
it is operating also on the freed transaction objects. */ 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() */ /* For innobase_kill_connection() */
# ifdef WITH_WSREP MEM_MAKE_ADDRESSABLE(&trx->state, sizeof trx->state);
MEM_UNDEFINED(&trx->wsrep, sizeof trx->wsrep); MEM_MAKE_ADDRESSABLE(&trx->mysql_thd, sizeof trx->mysql_thd);
#endif #endif
MEM_UNDEFINED(&trx->state, sizeof trx->state);
MEM_UNDEFINED(&trx->mysql_thd, sizeof trx->mysql_thd);
#endif
#ifdef HAVE_valgrind_or_MSAN
/* Unpoison the memory for innodb_monitor_set_option; /* Unpoison the memory for innodb_monitor_set_option;
it is operating also on the freed transaction objects. it is operating also on the freed transaction objects.
We checked that these were initialized in We checked that these were initialized in
@@ -477,7 +473,6 @@ void trx_free(trx_t*& trx)
# endif # endif
MEM_MAKE_DEFINED(&trx->state, sizeof trx->state); MEM_MAKE_DEFINED(&trx->state, sizeof trx->state);
MEM_MAKE_DEFINED(&trx->mysql_thd, sizeof trx->mysql_thd); MEM_MAKE_DEFINED(&trx->mysql_thd, sizeof trx->mysql_thd);
#endif
trx = NULL; trx = NULL;
} }

2
storage/maria/ha_maria.cc
View File

@@ -1201,7 +1201,7 @@ int ha_maria::open(const char *name, int mode, uint test_if_locked)
that all bytes in the row is properly reset. that all bytes in the row is properly reset.
*/ */
if (file->s->data_file_type == STATIC_RECORD && if (file->s->data_file_type == STATIC_RECORD &&
(file->s->has_varchar_fields | file->s->has_null_fields)) (file->s->has_varchar_fields || file->s->has_null_fields))
int_table_flags|= HA_RECORD_MUST_BE_CLEAN_ON_WRITE; int_table_flags|= HA_RECORD_MUST_BE_CLEAN_ON_WRITE;
for (i= 0; i < table->s->keys; i++) for (i= 0; i < table->s->keys; i++)

5
storage/myisam/ha_myisam.cc
View File

@@ -887,8 +887,9 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked)
the full row to ensure we don't get any errors from valgrind and the full row to ensure we don't get any errors from valgrind and
that all bytes in the row is properly reset. that all bytes in the row is properly reset.
*/ */
if ((file->s->options & HA_OPTION_PACK_RECORD) && if (!(file->s->options &
(file->s->has_varchar_fields | file->s->has_null_fields)) (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
(file->s->has_varchar_fields || file->s->has_null_fields))
int_table_flags|= HA_RECORD_MUST_BE_CLEAN_ON_WRITE; int_table_flags|= HA_RECORD_MUST_BE_CLEAN_ON_WRITE;
for (i= 0; i < table->s->keys; i++) for (i= 0; i < table->s->keys; i++)

5
storage/tokudb/ha_tokudb.cc
View File

@@ -6123,6 +6123,11 @@ void ha_tokudb::position(const uchar * record) {
// //
memcpy(ref, &key.size, sizeof(uint32_t)); 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; TOKUDB_HANDLER_DBUG_VOID_RETURN;
} }