Skip to content

M
mariadb
Commit a290a844 authored by Marko Mäkelä's avatar Marko Mäkelä
Browse files
Options

Bug#13418934 REMOVE HAVE_PURIFY DEPENDENCES FROM INNODB 

InnoDB: Remove HAVE_purify, UNIV_INIT_MEM_TO_ZERO, UNIV_SET_MEM_TO_ZERO.

The compile-time setting HAVE_purify can mask potential bugs.
It is being set in PB2 Valgrind runs. We should simply get rid of it,
and replace it with UNIV_MEM_INVALID() to declare uninitialized memory
as such in Valgrind-instrumented binaries.

os_mem_alloc_large(), ut_malloc_low(): Remove the parameter set_to_zero.

ut_malloc(): Define as a macro that invokes ut_malloc_low().

buf_pool_init(): Never initialize the buffer pool frames. All pages
must be initialized before flushing them to disk.

mem_heap_alloc(): Never initialize the allocated memory block.

os_mem_alloc_nocache(), ut_test_malloc(): Unused function, remove.

rb:813 approved by Jimmy Yang
parent 5e6ff79a
Hide whitespace changes
Inline Side-by-side
Showing with 16 additions and 302 deletions
storage/innobase/buf/buf0buf.c
View file @ a290a844
......@@ -634,7 +634,7 @@ buf_pool_init(
/*----------------------------------------*/
} else {
buf_pool->frame_mem = os_mem_alloc_large(
UNIV_PAGE_SIZE * (n_frames + 1), TRUE, FALSE);
UNIV_PAGE_SIZE * (n_frames + 1), FALSE);
}
if (buf_pool->frame_mem == NULL) {
......@@ -756,12 +756,8 @@ buf_pool_init(
block = buf_pool_get_nth_block(buf_pool, i);
if (block->frame) {
/* Wipe contents of frame to eliminate a Purify
warning */
UNIV_MEM_INVALID(block->frame, UNIV_PAGE_SIZE);
#ifdef HAVE_purify
memset(block->frame, '\0', UNIV_PAGE_SIZE);
#endif
if (srv_use_awe) {
/* Add to the list of blocks mapped to
frames */
......
storage/innobase/include/mem0mem.ic
View file @ a290a844
......@@ -194,10 +194,6 @@ mem_heap_alloc(
caller */
buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
#endif
#ifdef UNIV_SET_MEM_TO_ZERO
UNIV_MEM_ALLOC(buf, n);
memset(buf, '\0', n);
#endif
UNIV_MEM_ALLOC(buf, n);
return(buf);
......
storage/innobase/include/os0proc.h
View file @ a290a844
......@@ -104,14 +104,6 @@ ulint
os_proc_get_number(void);
/*====================*/
/********************************************************************
Allocates non-cacheable memory. */
void*
os_mem_alloc_nocache(
/*=================*/
/* out: allocated memory */
ulint n); /* in: number of bytes */
/********************************************************************
Allocates large pages memory. */
void*
......@@ -119,9 +111,6 @@ os_mem_alloc_large(
/*===============*/
/* out: allocated memory */
ulint n, /* in: number of bytes */
ibool set_to_zero, /* in: TRUE if allocated memory
should be set to zero if
UNIV_SET_MEM_TO_ZERO is defined */
ibool assert_on_error);/* in: if TRUE, we crash mysqld if
the memory cannot be allocated */
/********************************************************************
......
storage/innobase/include/univ.i
View file @ a290a844
......@@ -72,14 +72,6 @@ Microsoft Visual C++ */
/* DEBUG VERSION CONTROL
===================== */
/* The following flag will make InnoDB to initialize
all memory it allocates to zero. It hides Purify
warnings about reading unallocated memory unless
memory is read outside the allocated blocks. */
/*
#define UNIV_INIT_MEM_TO_ZERO
*/
/* Make a non-inline debug version */
#if defined HAVE_VALGRIND
......@@ -112,15 +104,6 @@ operations (very slow); also UNIV_DEBUG must be defined */
#define UNIV_BTR_DEBUG /* check B-tree links */
#define UNIV_LIGHT_MEM_DEBUG /* light memory debugging */
#ifdef HAVE_purify
/* The following sets all new allocated memory to zero before use:
this can be used to eliminate unnecessary Purify warnings, but note that
it also masks many bugs Purify could detect. For detailed Purify analysis it
is best to remove the define below and look through the warnings one
by one. */
#define UNIV_SET_MEM_TO_ZERO
#endif
/*
#define UNIV_SQL_DEBUG
#define UNIV_LOG_DEBUG
......
storage/innobase/include/ut0mem.h
View file @ a290a844
......@@ -30,38 +30,18 @@ ut_memcmp(const void* str1, const void* str2, ulint n);
/**************************************************************************
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined and set_to_zero is TRUE. */
Allocates memory. */
void*
ut_malloc_low(
/*==========*/
/* out, own: allocated memory */
ulint n, /* in: number of bytes to allocate */
ibool set_to_zero, /* in: TRUE if allocated memory
should be set to zero if
UNIV_SET_MEM_TO_ZERO is defined */
ibool assert_on_error); /* in: if TRUE, we crash mysqld if
the memory cannot be allocated */
/**************************************************************************
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined. */
void*
ut_malloc(
/*======*/
/* out, own: allocated memory */
ulint n); /* in: number of bytes to allocate */
/**************************************************************************
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails. */
ibool
ut_test_malloc(
/*===========*/
/* out: TRUE if succeeded */
ulint n); /* in: try to allocate this many bytes */
Allocates memory. */
#define ut_malloc(n) ut_malloc_low(n, TRUE)
/**************************************************************************
Frees a memory block allocated with ut_malloc. */
......
storage/innobase/mem/mem0pool.c
View file @ a290a844
......@@ -196,11 +196,7 @@ mem_pool_create(
pool = ut_malloc(sizeof(mem_pool_t));
/* We do not set the memory to zero (FALSE) in the pool,
but only when allocated at a higher level in mem0mem.c.
This is to avoid masking useful Purify warnings. */
pool->buf = ut_malloc_low(size, FALSE, TRUE);
pool->buf = ut_malloc_low(size, TRUE);
pool->size = size;
mutex_create(&pool->mutex, SYNC_MEM_POOL);
......
storage/innobase/os/os0proc.c
View file @ a290a844
......@@ -531,28 +531,6 @@ os_proc_get_number(void)
#endif
}
/********************************************************************
Allocates non-cacheable memory. */
void*
os_mem_alloc_nocache(
/*=================*/
/* out: allocated memory */
ulint n) /* in: number of bytes */
{
#ifdef __WIN__
void* ptr;
ptr = VirtualAlloc(NULL, n, MEM_COMMIT,
PAGE_READWRITE | PAGE_NOCACHE);
ut_a(ptr);
return(ptr);
#else
return(ut_malloc(n));
#endif
}
/********************************************************************
Allocates large pages memory. */
......@@ -561,9 +539,6 @@ os_mem_alloc_large(
/*===============*/
/* out: allocated memory */
ulint n, /* in: number of bytes */
ibool set_to_zero, /* in: TRUE if allocated memory
should be set to zero if
UNIV_SET_MEM_TO_ZERO is defined */
ibool assert_on_error)/* in: if TRUE, we crash mysqld if
the memory cannot be allocated */
{
......@@ -602,12 +577,6 @@ os_mem_alloc_large(
#endif
if (ptr) {
if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
memset(ptr, '\0', size);
#endif
}
return(ptr);
}
......@@ -616,7 +585,7 @@ os_mem_alloc_large(
skip:
#endif /* HAVE_LARGE_PAGES */
return(ut_malloc_low(n, set_to_zero, assert_on_error));
return(ut_malloc_low(n, assert_on_error));
}
/********************************************************************
......
storage/innobase/ut/ut0mem.c
View file @ a290a844
......@@ -54,17 +54,13 @@ ut_mem_block_list_init(void)
}
/**************************************************************************
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined and set_to_zero is TRUE. */
Allocates memory. */
void*
ut_malloc_low(
/*==========*/
/* out, own: allocated memory */
ulint n, /* in: number of bytes to allocate */
ibool set_to_zero, /* in: TRUE if allocated memory should be
set to zero if UNIV_SET_MEM_TO_ZERO is
defined */
ibool assert_on_error)/* in: if TRUE, we crash mysqld if the
memory cannot be allocated */
{
......@@ -156,12 +152,6 @@ retry:
#endif
}
if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
memset(ret, '\0', n + sizeof(ut_mem_block_t));
#endif
}
UNIV_MEM_ALLOC(ret, n + sizeof(ut_mem_block_t));
((ut_mem_block_t*)ret)->size = n + sizeof(ut_mem_block_t);
......@@ -176,59 +166,6 @@ retry:
return((void*)((byte*)ret + sizeof(ut_mem_block_t)));
}
/**************************************************************************
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined. */
void*
ut_malloc(
/*======*/
/* out, own: allocated memory */
ulint n) /* in: number of bytes to allocate */
{
return(ut_malloc_low(n, TRUE, TRUE));
}
/**************************************************************************
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails. */
ibool
ut_test_malloc(
/*===========*/
/* out: TRUE if succeeded */
ulint n) /* in: try to allocate this many bytes */
{
void* ret;
ret = malloc(n);
if (ret == NULL) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: cannot allocate"
" %lu bytes of memory for\n"
"InnoDB: a BLOB with malloc! Total allocated memory\n"
"InnoDB: by InnoDB %lu bytes."
" Operating system errno: %d\n"
"InnoDB: Check if you should increase"
" the swap file or\n"
"InnoDB: ulimits of your operating system.\n"
"InnoDB: On FreeBSD check you have"
" compiled the OS with\n"
"InnoDB: a big enough maximum process size.\n",
(ulong) n,
(ulong) ut_total_allocated_memory,
(int) errno);
return(FALSE);
}
free(ret);
return(TRUE);
}
/**************************************************************************
Frees a memory block allocated with ut_malloc. */
......
storage/innodb_plugin/buf/buf0buf.c
View file @ a290a844
......@@ -750,11 +750,8 @@ buf_chunk_init(
for (i = chunk->size; i--; ) {
buf_block_init(block, frame);
UNIV_MEM_INVALID(block->frame, UNIV_PAGE_SIZE);
#ifdef HAVE_purify
/* Wipe contents of frame to eliminate a Purify warning */
memset(block->frame, '\0', UNIV_PAGE_SIZE);
#endif
/* Add the block to the free list */
UT_LIST_ADD_LAST(list, buf_pool->free, (&block->page));
ut_d(block->page.in_free_list = TRUE);
......
storage/innodb_plugin/include/mem0mem.ic
View file @ a290a844
......@@ -208,10 +208,6 @@ mem_heap_alloc(
caller */
buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
#endif
#ifdef UNIV_SET_MEM_TO_ZERO
UNIV_MEM_ALLOC(buf, n);
memset(buf, '\0', n);
#endif
UNIV_MEM_ALLOC(buf, n);
return(buf);
......
storage/innodb_plugin/include/univ.i
View file @ a290a844
......@@ -146,14 +146,6 @@ Sun Studio */
/* DEBUG VERSION CONTROL
===================== */
/* The following flag will make InnoDB to initialize
all memory it allocates to zero. It hides Purify
warnings about reading unallocated memory unless
memory is read outside the allocated blocks. */
/*
#define UNIV_INIT_MEM_TO_ZERO
*/
/* When this macro is defined then additional test functions will be
compiled. These functions live at the end of each relevant source file
and have "test_" prefix. These functions are not called from anywhere in
......@@ -218,15 +210,6 @@ operations (very slow); also UNIV_DEBUG must be defined */
#define UNIV_BTR_DEBUG /* check B-tree links */
#define UNIV_LIGHT_MEM_DEBUG /* light memory debugging */
#ifdef HAVE_purify
/* The following sets all new allocated memory to zero before use:
this can be used to eliminate unnecessary Purify warnings, but note that
it also masks many bugs Purify could detect. For detailed Purify analysis it
is best to remove the define below and look through the warnings one
by one. */
#define UNIV_SET_MEM_TO_ZERO
#endif
/*
#define UNIV_SQL_DEBUG
#define UNIV_LOG_DEBUG
......
storage/innodb_plugin/include/ut0mem.h
View file @ a290a844
......@@ -78,40 +78,19 @@ ut_mem_init(void);
/*=============*/
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined and set_to_zero is TRUE.
Allocates memory.
@return own: allocated memory */
UNIV_INTERN
void*
ut_malloc_low(
/*==========*/
ulint n, /*!< in: number of bytes to allocate */
ibool set_to_zero, /*!< in: TRUE if allocated memory
should be set to zero if
UNIV_SET_MEM_TO_ZERO is defined */
ibool assert_on_error); /*!< in: if TRUE, we crash mysqld if
ibool assert_on_error) /*!< in: if TRUE, we crash mysqld if
the memory cannot be allocated */
__attribute__((malloc));
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined.
@return own: allocated memory */
UNIV_INTERN
void*
ut_malloc(
/*======*/
ulint n); /*!< in: number of bytes to allocate */
#ifndef UNIV_HOTBACKUP
/**********************************************************************//**
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails.
@return TRUE if succeeded */
UNIV_INTERN
ibool
ut_test_malloc(
/*===========*/
ulint n); /*!< in: try to allocate this many bytes */
#endif /* !UNIV_HOTBACKUP */
Allocates memory. */
#define ut_malloc(n) ut_malloc_low(n, TRUE)
/**********************************************************************//**
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
a nop. */
......
storage/innodb_plugin/mem/mem0pool.c
View file @ a290a844
......@@ -223,11 +223,7 @@ mem_pool_create(
pool = ut_malloc(sizeof(mem_pool_t));
/* We do not set the memory to zero (FALSE) in the pool,
but only when allocated at a higher level in mem0mem.c.
This is to avoid masking useful Purify warnings. */
pool->buf = ut_malloc_low(size, FALSE, TRUE);
pool->buf = ut_malloc_low(size, TRUE);
pool->size = size;
mutex_create(&pool->mutex, SYNC_MEM_POOL);
......
storage/innodb_plugin/os/os0proc.c
View file @ a290a844
......@@ -111,9 +111,6 @@ os_mem_alloc_large(
os_fast_mutex_lock(&ut_list_mutex);
ut_total_allocated_memory += size;
os_fast_mutex_unlock(&ut_list_mutex);
# ifdef UNIV_SET_MEM_TO_ZERO
memset(ptr, '\0', size);
# endif
UNIV_MEM_ALLOC(ptr, size);
return(ptr);
}
......
storage/innodb_plugin/ut/ut0mem.c
View file @ a290a844
......@@ -84,17 +84,13 @@ ut_mem_init(void)
#endif /* !UNIV_HOTBACKUP */
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined and set_to_zero is TRUE.
Allocates memory.
@return own: allocated memory */
UNIV_INTERN
void*
ut_malloc_low(
/*==========*/
ulint n, /*!< in: number of bytes to allocate */
ibool set_to_zero, /*!< in: TRUE if allocated memory should be
set to zero if UNIV_SET_MEM_TO_ZERO is
defined */
ibool assert_on_error)/*!< in: if TRUE, we crash mysqld if the
memory cannot be allocated */
{
......@@ -106,12 +102,6 @@ ut_malloc_low(
ret = malloc(n);
ut_a(ret || !assert_on_error);
#ifdef UNIV_SET_MEM_TO_ZERO
if (set_to_zero) {
memset(ret, '\0', n);
UNIV_MEM_ALLOC(ret, n);
}
#endif
return(ret);
}
......@@ -199,12 +189,6 @@ retry:
#endif
}
if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
memset(ret, '\0', n + sizeof(ut_mem_block_t));
#endif
}
UNIV_MEM_ALLOC(ret, n + sizeof(ut_mem_block_t));
((ut_mem_block_t*)ret)->size = n + sizeof(ut_mem_block_t);
......@@ -221,74 +205,10 @@ retry:
void* ret = malloc(n);
ut_a(ret || !assert_on_error);
# ifdef UNIV_SET_MEM_TO_ZERO
if (set_to_zero) {
memset(ret, '\0', n);
}
# endif
return(ret);
#endif /* !UNIV_HOTBACKUP */
}
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined.
@return own: allocated memory */
UNIV_INTERN
void*
ut_malloc(
/*======*/
ulint n) /*!< in: number of bytes to allocate */
{
#ifndef UNIV_HOTBACKUP
return(ut_malloc_low(n, TRUE, TRUE));
#else /* !UNIV_HOTBACKUP */
return(malloc(n));
#endif /* !UNIV_HOTBACKUP */
}
#ifndef UNIV_HOTBACKUP
/**********************************************************************//**
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails.
@return TRUE if succeeded */
UNIV_INTERN
ibool
ut_test_malloc(
/*===========*/
ulint n) /*!< in: try to allocate this many bytes */
{
void* ret;
ret = malloc(n);
if (ret == NULL) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: cannot allocate"
" %lu bytes of memory for\n"
"InnoDB: a BLOB with malloc! Total allocated memory\n"
"InnoDB: by InnoDB %lu bytes."
" Operating system errno: %d\n"
"InnoDB: Check if you should increase"
" the swap file or\n"
"InnoDB: ulimits of your operating system.\n"
"InnoDB: On FreeBSD check you have"
" compiled the OS with\n"
"InnoDB: a big enough maximum process size.\n",
(ulong) n,
(ulong) ut_total_allocated_memory,
(int) errno);
return(FALSE);
}
free(ret);
return(TRUE);
}
#endif /* !UNIV_HOTBACKUP */
/**********************************************************************//**
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
a nop. */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7