1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed bugs found by valgrind

Browse Source 
- Some of the bug fixes are backports from 10.5!
- The fix in innobase/fil/fil0fil.cc is just a backport to get less
  error messages in mysqld.1.err when running with valgrind.
- Renamed HAVE_valgrind_or_MSAN to HAVE_valgrind
This commit is contained in:
Monty 2020-06-28 20:07:32 +03:00
parent 29f9e679ad
commit 65f831d17c
32 changed files with 171 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
client/mysqltest.cc
View File

@ -10179,7 +10179,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)
@ -10820,7 +10820,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)+
@ -11132,13 +11132,16 @@ void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val, size_t len)
{ {
/* Convert to lower case, and do this first */ /* Convert to lower case, and do this first */
char *c= lower; char *c= lower;
for (const char *v= val; *v; v++) for (const char *v= val, *end_v= v + len; v < end_v; v++)
*c++= my_tolower(charset_info, *v); *c++= my_tolower(charset_info, *v);
*c= '\0'; *c= '\0';
/* Copy from this buffer instead */ /* Copy from this buffer instead */
} }
else else
memcpy(lower, val, len+1); {
memcpy(lower, val, len);
lower[len]= 0;
}
fix_win_paths(lower, len); fix_win_paths(lower, len);
val= lower; val= lower;
} }

2
include/my_sys.h
View File

@ -535,6 +535,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);
@ -556,6 +557,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;

40
include/my_valgrind.h
View File

@ -24,15 +24,19 @@
# 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_DEFINED(a,len) __msan_unpoison(a,len)
# define MEM_NOACCESS(a,len) ((void) 0)
#if defined(HAVE_VALGRIND_MEMCHECK_H) && defined(HAVE_valgrind) # 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_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)
@ -53,17 +57,6 @@ 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 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) (a), (void) (len))
# define MEM_MAKE_DEFINED(a,len) ((void) 0) # define MEM_MAKE_DEFINED(a,len) ((void) 0)
@ -73,7 +66,14 @@ 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
/* /*

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

@ -80,8 +80,8 @@ end//
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
sql/field.cc
View File

@ -7686,7 +7686,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();

7
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
@ -3466,7 +3466,7 @@ public:
bool memcpy_field_possible(const Field *from) const; bool memcpy_field_possible(const Field *from) const;
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);
@ -4395,7 +4395,8 @@ public:
:Type_handler_hybrid_field_type(&type_handler_null), :Type_handler_hybrid_field_type(&type_handler_null),
compression_method_ptr(0), compression_method_ptr(0),
comment(null_clex_str), comment(null_clex_str),
on_update(NULL), length(0), invisible(VISIBLE), decimals(0), on_update(NULL), length(0), invisible(VISIBLE), char_length(0),
decimals(0),
flags(0), pack_length(0), key_length(0), unireg_check(Field::NONE), flags(0), pack_length(0), key_length(0), unireg_check(Field::NONE),
interval(0), charset(&my_charset_bin), interval(0), charset(&my_charset_bin),
srid(0), geom_type(Field::GEOM_GEOMETRY), srid(0), geom_type(Field::GEOM_GEOMETRY),

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));

2
sql/item_cmpfunc.cc
View File

@ -1176,6 +1176,8 @@ longlong Item_func_truth::val_int()
bool Item_in_optimizer::is_top_level_item() bool Item_in_optimizer::is_top_level_item()
{ {
if (invisible_mode())
return FALSE;
return ((Item_in_subselect *)args[1])->is_top_level_item(); return ((Item_in_subselect *)args[1])->is_top_level_item();
} }

2
sql/item_subselect.cc
View File

@ -717,7 +717,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

1
sql/opt_range.cc
View File

@ -2457,6 +2457,7 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
param.imerge_cost_buff_size= 0; param.imerge_cost_buff_size= 0;
param.using_real_indexes= TRUE; param.using_real_indexes= TRUE;
param.remove_jump_scans= TRUE; param.remove_jump_scans= TRUE;
param.is_ror_scan= 0;
param.remove_false_where_parts= remove_false_parts_of_where; param.remove_false_where_parts= remove_false_parts_of_where;
param.force_default_mrr= ordered_output; param.force_default_mrr= ordered_output;
param.possible_keys.clear_all(); param.possible_keys.clear_all();

5
sql/session_tracker.cc
View File

@ -380,9 +380,10 @@ 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;
size_t length= 1;
void *copy= var->save_result.string_value.str ? void *copy= var->save_result.string_value.str ?
my_memdup(var->save_result.string_value.str, my_memdup(var->save_result.string_value.str,
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)) :
my_strdup("", MYF(MY_WME | MY_THREAD_SPECIFIC)); my_strdup("", MYF(MY_WME | MY_THREAD_SPECIFIC));
@ -402,7 +403,7 @@ bool Session_sysvars_tracker::update(THD *thd, set_var *var)
m_parsed= true; m_parsed= true;
orig_list.copy(&tool_list, thd); orig_list.copy(&tool_list, thd);
orig_list.construct_var_list(thd->variables.session_track_system_variables, orig_list.construct_var_list(thd->variables.session_track_system_variables,
var->save_result.string_value.length + 1); length);
return false; return false;
} }

40
sql/sql_select.cc
View File

@ -6176,9 +6176,11 @@ 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;
keyuse.null_rejecting= FALSE;
return insert_dynamic(keyuse_array,(uchar*) &keyuse); return insert_dynamic(keyuse_array,(uchar*) &keyuse);
} }
@ -17966,16 +17968,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);
} }
} }
@ -17984,7 +17992,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 */
@ -18006,6 +18014,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
@ -18275,8 +18286,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;
@ -18571,6 +18583,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
@ -18765,7 +18781,10 @@ 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)++;
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 else
{ {
@ -19357,11 +19376,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;
@ -27698,7 +27717,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 &&

8
sql/table.cc
View File

@ -1644,8 +1644,7 @@ 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); MEM_NOACCESS(record + share->reclength, rec_buff_length - share->reclength);
MEM_UNDEFINED(record, 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);
@ -3273,7 +3272,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;)
@ -3282,8 +3280,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)*

4
sql/unireg.cc
View File

@ -436,8 +436,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;

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

@ -1179,12 +1179,12 @@ 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 #ifdef HAVE_valgrind
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 */ #endif /* HAVE_valgrind */
#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;
@ -3295,12 +3295,12 @@ btr_cur_optimistic_insert(
const page_size_t& page_size = block->page.size; const page_size_t& page_size = block->page.size;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
if (page_size.is_compressed()) { if (page_size.is_compressed()) {
MEM_CHECK_DEFINED(page, page_size.logical()); MEM_CHECK_DEFINED(page, page_size.logical());
MEM_CHECK_DEFINED(block->page.zip.data, page_size.physical()); MEM_CHECK_DEFINED(block->page.zip.data, page_size.physical());
} }
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
leaf = page_is_leaf(page); leaf = page_is_leaf(page);

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

@ -393,9 +393,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(buf, srv_page_size); MEM_UNDEFINED(buf, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
block = (buf_block_t*) bpage; block = (buf_block_t*) bpage;
buf_page_mutex_enter(block); buf_page_mutex_enter(block);

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

@ -1609,13 +1609,13 @@ 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 #ifdef HAVE_valgrind
MEM_MAKE_DEFINED(block->frame, srv_page_size); MEM_MAKE_DEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
btr_search_drop_page_hash_index(block); btr_search_drop_page_hash_index(block);
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(block->frame, srv_page_size); MEM_UNDEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
buf_pool_mutex_enter(buf_pool); buf_pool_mutex_enter(buf_pool);
@ -1660,9 +1660,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(block->frame, srv_page_size); MEM_UNDEFINED(block->frame, srv_page_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
/* 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

@ -229,7 +229,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++) {
@ -240,7 +240,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

@ -2281,7 +2281,8 @@ fil_check_pending_ops(const fil_space_t* space, ulint count)
if (ulint n_pending_ops = my_atomic_loadlint(&space->n_pending_ops)) { if (ulint n_pending_ops = my_atomic_loadlint(&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 close/delete/truncate" ib::warn() << "Trying to close/delete/truncate"
" tablespace '" << space->name " tablespace '" << space->name
<< "' but there are " << n_pending_ops << "' but there are " << n_pending_ops

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

@ -7334,9 +7334,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(templ, sizeof *templ); MEM_UNDEFINED(templ, sizeof *templ);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
templ->is_virtual = !field->stored_in_db(); templ->is_virtual = !field->stored_in_db();
if (!templ->is_virtual) { if (!templ->is_virtual) {
@ -8454,9 +8454,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(ufield, sizeof *ufield); MEM_UNDEFINED(ufield, sizeof *ufield);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
/* 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 */
dict_table_stats_unlock(table, RW_X_LATCH); dict_table_stats_unlock(table, RW_X_LATCH);
} }

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); \

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/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]);

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

@ -1243,10 +1243,10 @@ 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 #ifdef HAVE_valgrind
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 */ #endif /* HAVE_valgrind */
bool affects_fulltext = false; bool affects_fulltext = false;

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

@ -372,9 +372,9 @@ row_log_online_op(
goto err_exit; goto err_exit;
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
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;
@ -459,10 +459,10 @@ write_failed:
index->type |= DICT_CORRUPT; index->type |= DICT_CORRUPT;
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
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 */ #endif /* HAVE_valgrind */
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);
@ -472,9 +472,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
err_exit: err_exit:
mutex_exit(&log->mutex); mutex_exit(&log->mutex);
} }
@ -506,9 +506,9 @@ row_log_table_open(
{ {
mutex_enter(&log->mutex); mutex_enter(&log->mutex);
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
if (log->error != DB_SUCCESS) { if (log->error != DB_SUCCESS) {
err_exit: err_exit:
@ -600,10 +600,10 @@ 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 #ifdef HAVE_valgrind
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 */ #endif /* HAVE_valgrind */
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 {
@ -612,9 +612,9 @@ write_failed:
} }
log->tail.total += size; log->tail.total += size;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf); MEM_UNDEFINED(log->tail.buf, sizeof log->tail.buf);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
err_exit: err_exit:
mutex_exit(&log->mutex); mutex_exit(&log->mutex);
@ -2785,9 +2785,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(&mrec_end, sizeof mrec_end); MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
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);
@ -3696,9 +3696,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(&mrec_end, sizeof mrec_end); MEM_UNDEFINED(&mrec_end, sizeof mrec_end);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
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);

22
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,9 @@ row_merge_write_rec(
return(NULL); return(NULL);
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(&block[0], srv_sort_buf_size); MEM_UNDEFINED(&block[0], srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
/* Copy the rest. */ /* Copy the rest. */
b = &block[0]; b = &block[0];
@ -1477,7 +1477,7 @@ row_merge_write_eof(
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(&block[0], srv_sort_buf_size); MEM_UNDEFINED(&block[0], srv_sort_buf_size);
#endif #endif
DBUG_RETURN(&block[0]); DBUG_RETURN(&block[0]);
@ -2680,10 +2680,10 @@ write_buffers:
break; break;
} }
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED( MEM_UNDEFINED(
&block[0], srv_sort_buf_size); &block[0], srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
} }
} }
merge_buf[i] = row_merge_buf_empty(buf); merge_buf[i] = row_merge_buf_empty(buf);
@ -3203,9 +3203,9 @@ row_merge(
foffs0 = 0; foffs0 = 0;
foffs1 = ihalf; foffs1 = ihalf;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(run_offset, *num_run * sizeof *run_offset); MEM_UNDEFINED(run_offset, *num_run * sizeof *run_offset);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) { for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) {
@ -3286,9 +3286,9 @@ row_merge(
*tmpfd = file->fd; *tmpfd = file->fd;
*file = of; *file = of;
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
MEM_UNDEFINED(&block[0], 3 * srv_sort_buf_size); MEM_UNDEFINED(&block[0], 3 * srv_sort_buf_size);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
return(DB_SUCCESS); return(DB_SUCCESS);
} }

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

@ -982,11 +982,11 @@ 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 #ifdef HAVE_valgrind
/* 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 */ #endif /* HAVE_valgrind */
break; break;
default: default:
goto err_exit; goto err_exit;
@ -2742,9 +2742,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(dest, templ->mysql_col_len); MEM_UNDEFINED(dest, templ->mysql_col_len);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
switch (templ->type) { switch (templ->type) {
const byte* field_end; const byte* field_end;
@ -3653,9 +3653,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(buf, templ->mysql_col_len); MEM_UNDEFINED(buf, templ->mysql_col_len);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
} else { } else {
len = templ->mysql_col_len; len = templ->mysql_col_len;
} }
@ -3724,9 +3724,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(buf, prebuilt->mysql_prefix_len); MEM_UNDEFINED(buf, prebuilt->mysql_prefix_len);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
/* 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);
@ -3810,10 +3810,10 @@ row_sel_fetch_last_buf(
} }
ut_ad(prebuilt->fetch_cache_first == 0); ut_ad(prebuilt->fetch_cache_first == 0);
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
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 */ #endif /* HAVE_valgrind */
return(prebuilt->fetch_cache[prebuilt->n_fetch_cached]); return(prebuilt->fetch_cache[prebuilt->n_fetch_cached]);
} }

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

@ -1869,9 +1869,9 @@ 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 #ifdef HAVE_valgrind
MEM_UNDEFINED(&dfield_len, sizeof dfield_len); MEM_UNDEFINED(&dfield_len, sizeof dfield_len);
#endif /* HAVE_valgrind_or_MSAN */ #endif /* HAVE_valgrind */
/* 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/trx/trx0trx.cc
View File

@ -458,7 +458,7 @@ void trx_free(trx_t*& trx)
MEM_UNDEFINED(&trx->state, sizeof trx->state); MEM_UNDEFINED(&trx->state, sizeof trx->state);
MEM_UNDEFINED(&trx->mysql_thd, sizeof trx->mysql_thd); MEM_UNDEFINED(&trx->mysql_thd, sizeof trx->mysql_thd);
#endif #endif
#ifdef HAVE_valgrind_or_MSAN #ifdef HAVE_valgrind
/* 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

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;
} }