mem0mem.ic Changes to eliminate unnecessary Purify warnings

ut0mem.h	Changes to eliminate unnecessary Purify warnings
ut0mem.ic	Changes to eliminate unnecessary Purify warnings
srv0start.c	Changes to eliminate unnecessary Purify warnings
mem0pool.c	Changes to eliminate unnecessary Purify warnings
ut0mem.c	Changes to eliminate unnecessary Purify warnings

1 files changed, 119 insertions, 13 deletions

diff --git a/innobase/ut/ut0mem.c b/innobase/ut/ut0mem.c
index 492f57670a9..ebeefe0c297 100644
--- a/innobase/ut/ut0mem.c
+++ b/innobase/ut/ut0mem.c
@@ -14,30 +14,136 @@ Created 5/11/1994 Heikki Tuuri
 
 #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*
-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;
-	/*
-	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) {
 		fprintf(stderr,
-		"Innobase: Fatal error: cannot allocate memory!\n");
-		fprintf(stderr,
-		"Innobase: Cannot continue operation!\n");
-		fprintf(stderr,
-		"Innobase: Check if you can increase the swap file of your\n");
-		fprintf(stderr,
-		"Innobase: operating system.\n");
+		"InnoDB: Fatal error: cannot allocate %lu bytes of\n"
+		"InnoDB: memory with malloc!\n"
+		"InnoDB: Operating system errno: %lu\n"
+		"InnoDB: Cannot continue operation!\n"
+		"InnoDB: Check if you should increase the swap file or\n"
+		"InnoDB: ulimits of your operating system.\n", n, errno);
+
+	        os_fast_mutex_unlock(&ut_list_mutex);
 
 		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);
 }
 
 /**************************************************************************