ut0mem.c 5.65 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/************************************************************************
Memory primitives

(c) 1994, 1995 Innobase Oy

Created 5/11/1994 Heikki Tuuri
*************************************************************************/

#include "ut0mem.h"

#ifdef UNIV_NONINL
#include "ut0mem.ic"
#endif

#include "mem0mem.h"
16
#include "os0sync.h"
17 18 19 20

/* This struct is placed first in every allocated memory block */
typedef struct ut_mem_block_struct ut_mem_block_t;

21 22 23
/* The total amount of memory currently allocated from the OS with malloc */
ulint	ut_total_allocated_memory	= 0;

24
struct ut_mem_block_struct{
25 26 27 28
        UT_LIST_NODE_T(ut_mem_block_t) mem_block_list;
			/* mem block list node */
	ulint	size;	/* size of allocated memory */
	ulint	magic_n;
29 30
};

31
#define UT_MEM_MAGIC_N	1601650166
32 33 34 35 36 37 38 39 40

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
41 42
ulint*	ut_mem_null_ptr	= NULL;

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
/**************************************************************************
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. */

59
void*
60 61 62 63 64 65
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 */
66 67 68
{
	void*	ret;

69 70 71 72 73 74 75 76 77
	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));
78 79 80

	if (ret == NULL) {
		fprintf(stderr,
81
		"InnoDB: Fatal error: cannot allocate %lu bytes of\n"
82
		"InnoDB: memory with malloc! Total allocated memory\n"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
83
		"InnoDB: by InnoDB %lu bytes. Operating system errno: %lu\n"
84 85
		"InnoDB: Cannot continue operation!\n"
		"InnoDB: Check if you should increase the swap file or\n"
heikki@donna.mysql.fi's avatar
heikki@donna.mysql.fi committed
86 87
		"InnoDB: ulimits of your operating system.\n"
		"InnoDB: On FreeBSD check you have compiled the OS with\n"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
88 89 90
		"InnoDB: a big enough maximum process size.\n"
		"InnoDB: We now intentionally generate a seg fault so that\n"
		"InnoDB: on Linux we get a stack trace.\n",
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
91 92 93 94 95 96 97
		                  n, ut_total_allocated_memory,
#ifdef __WIN__
			(ulint)GetLastError()
#else
			(ulint)errno
#endif
			);
98

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
99 100 101 102 103 104
		/* Flush stderr to make more probable that the error
		message gets in the error file before we generate a seg
		fault */

		fflush(stderr);

105
	        os_fast_mutex_unlock(&ut_list_mutex);
106

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
107 108 109
		/* Make an intentional seg fault so that we get a stack
		trace */
		printf("%lu\n", *ut_mem_null_ptr);	
110
	}		
111

112 113 114 115 116 117
	if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
	        memset(ret, '\0', n + sizeof(ut_mem_block_t));
#endif
	}

118 119 120 121 122
	((ut_mem_block_t*)ret)->size = n + sizeof(ut_mem_block_t);
	((ut_mem_block_t*)ret)->magic_n = UT_MEM_MAGIC_N;

	ut_total_allocated_memory += n + sizeof(ut_mem_block_t);
	
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
	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));
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
142

143
/**************************************************************************
144
Frees a memory block allocated with ut_malloc. */
145 146 147 148 149 150 151 152 153 154 155 156

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

157 158 159 160 161
	ut_a(block->magic_n == UT_MEM_MAGIC_N);
	ut_a(ut_total_allocated_memory >= block->size);

	ut_total_allocated_memory -= block->size;
	
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
	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);

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
179
	while ((block = UT_LIST_GET_FIRST(ut_mem_block_list))) {
180

181 182 183 184 185
		ut_a(block->magic_n == UT_MEM_MAGIC_N);
		ut_a(ut_total_allocated_memory >= block->size);

		ut_total_allocated_memory -= block->size;
	
186 187 188 189 190
	        UT_LIST_REMOVE(mem_block_list, ut_mem_block_list, block);
	        free(block);
	}
		                      
	os_fast_mutex_unlock(&ut_list_mutex);
191 192

	ut_a(ut_total_allocated_memory == 0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
193 194

        os_fast_mutex_free(&ut_list_mutex);
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
}

/**************************************************************************
Catenates two strings into newly allocated memory. The memory must be freed
using mem_free. */

char*
ut_str_catenate(
/*============*/
			/* out, own: catenated null-terminated string */
	char*	str1,	/* in: null-terminated string */
	char*	str2)	/* in: null-terminated string */
{
	ulint	len1;
	ulint	len2;
	char*	str;

	len1 = ut_strlen(str1);
	len2 = ut_strlen(str2);

	str = mem_alloc(len1 + len2 + 1);

	ut_memcpy(str, str1, len1);
	ut_memcpy(str + len1, str2, len2);

	str[len1 + len2] = '\0';

	return(str);
}