Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

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
pull/843/head
Marko Mäkelä 14 years ago
parent
289af2579b
commit
e498a1bf65
15 changed files with 16 additions and 302 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      storage/innobase/buf/buf0buf.c
  2. 4
      storage/innobase/include/mem0mem.ic
  3. 11
      storage/innobase/include/os0proc.h
  4. 17
      storage/innobase/include/univ.i
  5. 26
      storage/innobase/include/ut0mem.h
  6. 6
      storage/innobase/mem/mem0pool.c
  7. 33
      storage/innobase/os/os0proc.c
  8. 65
      storage/innobase/ut/ut0mem.c
  9. 5
      storage/innodb_plugin/buf/buf0buf.c
  10. 4
      storage/innodb_plugin/include/mem0mem.ic
  11. 17
      storage/innodb_plugin/include/univ.i
  12. 31
      storage/innodb_plugin/include/ut0mem.h
  13. 6
      storage/innodb_plugin/mem/mem0pool.c
  14. 3
      storage/innodb_plugin/os/os0proc.c
  15. 82
      storage/innodb_plugin/ut/ut0mem.c

8
storage/innobase/buf/buf0buf.c
View File

@ -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 */

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

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

11
storage/innobase/include/os0proc.h
View File

@ -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 */
/********************************************************************

17
storage/innobase/include/univ.i
View File

@ -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

26
storage/innobase/include/ut0mem.h
View File

@ -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. */

6
storage/innobase/mem/mem0pool.c
View File

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

33
storage/innobase/os/os0proc.c
View File

@ -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));
}
/********************************************************************

65
storage/innobase/ut/ut0mem.c
View File

@ -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. */

5
storage/innodb_plugin/buf/buf0buf.c
View File

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

4
storage/innodb_plugin/include/mem0mem.ic
View File

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

17
storage/innodb_plugin/include/univ.i
View File

@ -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

31
storage/innodb_plugin/include/ut0mem.h
View File

@ -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. */

6
storage/innodb_plugin/mem/mem0pool.c
View File

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

3
storage/innodb_plugin/os/os0proc.c
View File

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

82
storage/innodb_plugin/ut/ut0mem.c
View File

@ -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. */

Write Preview
Loading…
Cancel
Save