Commit a24fbc61 authored by heikki@donna.mysql.fi's avatar heikki@donna.mysql.fi

Merge heikki@work.mysql.com:/home/my/mysql

into donna.mysql.fi:/home/heikki/mysqlf
parents c55ac34f 59f9fc4f
...@@ -170,7 +170,9 @@ mem_heap_alloc( ...@@ -170,7 +170,9 @@ mem_heap_alloc(
buf = (byte*)buf + MEM_FIELD_HEADER_SIZE; buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
#endif #endif
#ifdef UNIV_SET_MEM_TO_ZERO
memset(buf, '\0', n);
#endif
return(buf); return(buf);
} }
...@@ -494,8 +496,14 @@ mem_alloc_func( ...@@ -494,8 +496,14 @@ mem_alloc_func(
) )
{ {
#ifndef UNIV_MEM_DEBUG #ifndef UNIV_MEM_DEBUG
void* buf;
buf = mem_area_alloc(n, mem_comm_pool);
return(mem_area_alloc(n, mem_comm_pool)); #ifdef UNIV_SET_MEM_TO_ZERO
memset(buf, '\0', n);
#endif
return(buf);
#else #else
......
...@@ -26,12 +26,39 @@ int ...@@ -26,12 +26,39 @@ int
ut_memcmp(void* str1, void* str2, ulint n); ut_memcmp(void* str1, 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. */
void* void*
ut_malloc(ulint n); 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 */
/**************************************************************************
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 */
/**************************************************************************
Frees a memory bloock allocated with ut_malloc. */
void
ut_free(
/*====*/
void* ptr); /* in, own: memory block */
/**************************************************************************
Frees all allocated memory not freed yet. */
UNIV_INLINE
void void
ut_free(void* ptr); ut_free_all_mem(void);
/*=================*/
UNIV_INLINE UNIV_INLINE
char* char*
......
...@@ -27,13 +27,6 @@ ut_memcmp(void* str1, void* str2, ulint n) ...@@ -27,13 +27,6 @@ ut_memcmp(void* str1, void* str2, ulint n)
return(memcmp(str1, str2, n)); return(memcmp(str1, str2, n));
} }
UNIV_INLINE
void
ut_free(void* ptr)
{
free(ptr);
}
UNIV_INLINE UNIV_INLINE
char* char*
ut_strcpy(char* dest, char* sour) ut_strcpy(char* dest, char* sour)
......
...@@ -170,7 +170,11 @@ mem_pool_create( ...@@ -170,7 +170,11 @@ mem_pool_create(
pool = ut_malloc(sizeof(mem_pool_t)); pool = ut_malloc(sizeof(mem_pool_t));
pool->buf = ut_malloc(size); /* 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);
pool->size = size; pool->size = size;
mutex_create(&(pool->mutex)); mutex_create(&(pool->mutex));
......
...@@ -916,5 +916,7 @@ innobase_shutdown_for_mysql(void) ...@@ -916,5 +916,7 @@ innobase_shutdown_for_mysql(void)
logs_empty_and_mark_files_at_shutdown(); logs_empty_and_mark_files_at_shutdown();
ut_free_all_mem();
return((int) DB_SUCCESS); return((int) DB_SUCCESS);
} }
...@@ -14,30 +14,136 @@ Created 5/11/1994 Heikki Tuuri ...@@ -14,30 +14,136 @@ Created 5/11/1994 Heikki Tuuri
#include "mem0mem.h" #include "mem0mem.h"
/* This struct is placed first in every allocated memory block */
typedef struct ut_mem_block_struct ut_mem_block_t;
struct ut_mem_block_struct{
UT_LIST_NODE_T(ut_mem_block_t) mem_block_list;/* mem block list node */
};
/* List of all memory blocks allocated from the operating system
with malloc */
UT_LIST_BASE_NODE_T(ut_mem_block_t) ut_mem_block_list;
os_fast_mutex_t ut_list_mutex; /* this protects the list */
ibool ut_mem_block_list_inited = FALSE;
/**************************************************************************
Initializes the mem block list at database startup. */
static
void
ut_mem_block_list_init(void)
/*========================*/
{
os_fast_mutex_init(&ut_list_mutex);
UT_LIST_INIT(ut_mem_block_list);
ut_mem_block_list_inited = TRUE;
}
/**************************************************************************
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined and set_to_zero is TRUE. */
void* void*
ut_malloc(ulint n) 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 */
{ {
void* ret; void* ret;
/*
ret = VirtualAlloc(NULL, n, MEM_COMMIT, PAGE_READWRITE);
*/
ret = malloc(n); ut_ad((sizeof(ut_mem_block_t) % 8) == 0); /* check alignment ok */
if (!ut_mem_block_list_inited) {
ut_mem_block_list_init();
}
os_fast_mutex_lock(&ut_list_mutex);
ret = malloc(n + sizeof(ut_mem_block_t));
if (ret == NULL) { if (ret == NULL) {
fprintf(stderr, fprintf(stderr,
"Innobase: Fatal error: cannot allocate memory!\n"); "InnoDB: Fatal error: cannot allocate %lu bytes of\n"
fprintf(stderr, "InnoDB: memory with malloc!\n"
"Innobase: Cannot continue operation!\n"); "InnoDB: Operating system errno: %lu\n"
fprintf(stderr, "InnoDB: Cannot continue operation!\n"
"Innobase: Check if you can increase the swap file of your\n"); "InnoDB: Check if you should increase the swap file or\n"
fprintf(stderr, "InnoDB: ulimits of your operating system.\n", n, errno);
"Innobase: operating system.\n");
os_fast_mutex_unlock(&ut_list_mutex);
exit(1); exit(1);
} }
return(ret); if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
memset(ret, '\0', n + sizeof(ut_mem_block_t));
#endif
}
UT_LIST_ADD_FIRST(mem_block_list, ut_mem_block_list,
((ut_mem_block_t*)ret));
os_fast_mutex_unlock(&ut_list_mutex);
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));
}
/**************************************************************************
Frees a memory bloock allocated with ut_malloc. */
void
ut_free(
/*====*/
void* ptr) /* in, own: memory block */
{
ut_mem_block_t* block;
block = (ut_mem_block_t*)((byte*)ptr - sizeof(ut_mem_block_t));
os_fast_mutex_lock(&ut_list_mutex);
UT_LIST_REMOVE(mem_block_list, ut_mem_block_list, block);
free(block);
os_fast_mutex_unlock(&ut_list_mutex);
}
/**************************************************************************
Frees all allocated memory not freed yet. */
void
ut_free_all_mem(void)
/*=================*/
{
ut_mem_block_t* block;
os_fast_mutex_lock(&ut_list_mutex);
while (block = UT_LIST_GET_FIRST(ut_mem_block_list)) {
UT_LIST_REMOVE(mem_block_list, ut_mem_block_list, block);
free(block);
}
os_fast_mutex_unlock(&ut_list_mutex);
} }
/************************************************************************** /**************************************************************************
......
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