Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/ut/ut0mem.c File Reference

#include "ut0mem.h"
#include "mem0mem.h"
#include "os0sync.h"
#include "os0thread.h"

Include dependency graph for ut0mem.c:

Go to the source code of this file.

Classes
struct	ut_mem_block_struct
Defines
#define	UT_MEM_MAGIC_N   1601650166
Typedefs
typedef ut_mem_block_struct	ut_mem_block_t
Functions
	UT_LIST_BASE_NODE_T (ut_mem_block_t)
void *	ut_malloc_low (ulint n, ibool set_to_zero, ibool assert_on_error)
void *	ut_malloc (ulint n)
ibool	ut_test_malloc (ulint n)
void	ut_free (void *ptr)
void *	ut_realloc (void *ptr, ulint size)
void	ut_free_all_mem (void)
ulint	ut_strlcpy (char *dst, const char *src, ulint size)
ulint	ut_strlcpy_rev (char *dst, const char *src, ulint size)
char *	ut_strcpyq (char *dest, char q, const char *src)
char *	ut_memcpyq (char *dest, char q, const char *src, ulint len)
ulint	ut_strcount (const char *s1, const char *s2)
char *	ut_strreplace (const char *str, const char *s1, const char *s2)
Variables
ulint	ut_total_allocated_memory = 0

---

Define Documentation

#define UT_MEM_MAGIC_N   1601650166

Definition at line 32 of file ut0mem.c.

Referenced by ut_free(), ut_free_all_mem(), ut_malloc_low(), and ut_realloc().

---

Typedef Documentation

typedef struct ut_mem_block_struct ut_mem_block_t

Definition at line 20 of file ut0mem.c.

---

Function Documentation

void ut_free

(

void *

ptr

)

Definition at line 221 of file ut0mem.c.

References yaSSL::block, free, os_fast_mutex_lock(), os_fast_mutex_unlock(), ut_a, UT_LIST_REMOVE, UT_MEM_MAGIC_N, and ut_total_allocated_memory.

Referenced by fil_create_new_single_table_tablespace(), fil_load_single_table_tablespace(), fil_node_open_file(), fil_open_single_table_tablespace(), fil_read_flushed_lsn_and_arch_log_no(), fil_reset_too_high_lsns(), hash_table_free(), mem_area_free(), os_event_free(), os_file_opendir(), os_file_readdir_next_file(), os_file_set_size(), os_mem_free_large(), os_mutex_free(), recv_sys_free(), sync_array_free(), trx_sys_doublewrite_init_or_restore_pages(), and ut_realloc().

                              : 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_a(block->magic_n == UT_MEM_MAGIC_N);
        ut_a(ut_total_allocated_memory >= block->size);

        ut_total_allocated_memory -= block->size;

        UT_LIST_REMOVE(mem_block_list, ut_mem_block_list, block);
        free(block);

        os_fast_mutex_unlock(&ut_list_mutex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ut_free_all_mem

(

void

)

Definition at line 321 of file ut0mem.c.

References yaSSL::block, free, os_fast_mutex_free(), ut_a, UT_LIST_GET_FIRST, UT_LIST_REMOVE, UT_MEM_MAGIC_N, and ut_total_allocated_memory.

Referenced by innobase_shutdown_for_mysql().

{
        ut_mem_block_t* block;

        os_fast_mutex_free(&ut_list_mutex);

        while ((block = UT_LIST_GET_FIRST(ut_mem_block_list))) {

                ut_a(block->magic_n == UT_MEM_MAGIC_N);
                ut_a(ut_total_allocated_memory >= block->size);

                ut_total_allocated_memory -= block->size;

                UT_LIST_REMOVE(mem_block_list, ut_mem_block_list, block);
                free(block);
        }

        if (ut_total_allocated_memory != 0) {
                fprintf(stderr,
"InnoDB: Warning: after shutdown total allocated memory is %lu\n",
                  (ulong) ut_total_allocated_memory);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

UT_LIST_BASE_NODE_T

(

ut_mem_block_t

)

Definition at line 36 of file ut0mem.c.

References os_fast_mutex_init(), TRUE, and UT_LIST_INIT.

{
        os_fast_mutex_init(&ut_list_mutex);
        UT_LIST_INIT(ut_mem_block_list);
        ut_mem_block_list_inited = TRUE;
}

Here is the call graph for this function:

void* ut_malloc

(

ulint

n

)

Definition at line 173 of file ut0mem.c.

References TRUE, and ut_malloc_low().

Referenced by buf_pool_init(), fil_create_new_single_table_tablespace(), fil_load_single_table_tablespace(), fil_node_open_file(), fil_open_single_table_tablespace(), fil_read_flushed_lsn_and_arch_log_no(), fil_reset_too_high_lsns(), hash_create(), log_init(), mem_area_alloc(), mem_pool_create(), os_aio_array_create(), os_aio_init(), os_awe_allocate_physical_mem(), os_awe_allocate_virtual_mem_window(), os_event_create(), os_file_opendir(), os_file_readdir_next_file(), os_file_set_size(), os_mem_alloc_nocache(), os_mutex_create(), recv_sys_init(), srv_add_path_separator_if_needed(), srv_parse_data_file_paths_and_sizes(), srv_parse_log_group_home_dirs(), sync_array_create(), sync_init(), sync_thread_add_level(), trx_doublewrite_init(), trx_sys_doublewrite_init_or_restore_pages(), and ut_realloc().

                                   : allocated memory */
        ulint   n)      /* in: number of bytes to allocate */
{
        return(ut_malloc_low(n, TRUE, TRUE));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* ut_malloc_low	(	ulint	n,
		ibool	set_to_zero,
		ibool	assert_on_error
	)

Definition at line 61 of file ut0mem.c.

References __WIN__, errno, malloc, memset, NULL, os_fast_mutex_lock(), os_fast_mutex_unlock(), os_thread_sleep(), ut_a, ut_ad, UT_LIST_ADD_FIRST, UT_MEM_MAGIC_N, ut_print_timestamp(), and ut_total_allocated_memory.

Referenced by mem_pool_create(), os_mem_alloc_large(), and ut_malloc().

                                           : 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 */
{
        ulint   retry_count     = 0;
        void*   ret;

        ut_ad((sizeof(ut_mem_block_t) % 8) == 0); /* check alignment ok */

        if (!ut_mem_block_list_inited) {
                ut_mem_block_list_init();
        }
retry:
        os_fast_mutex_lock(&ut_list_mutex);

        ret = malloc(n + sizeof(ut_mem_block_t));

        if (ret == NULL && retry_count < 60) {
                if (retry_count == 0) {
                        ut_print_timestamp(stderr);

                        fprintf(stderr,
                "  InnoDB: Error: cannot allocate %lu bytes of\n"
                "InnoDB: memory with malloc! Total allocated memory\n"
                "InnoDB: by InnoDB %lu bytes. Operating system errno: %lu\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"
                "InnoDB: Note that in most 32-bit computers the process\n"
                "InnoDB: memory space is limited to 2 GB or 4 GB.\n"
                "InnoDB: We keep retrying the allocation for 60 seconds...\n",
                                  (ulong) n, (ulong) ut_total_allocated_memory,
#ifdef __WIN__
                        (ulong) GetLastError()
#else
                        (ulong) errno
#endif
                        );
                }

                os_fast_mutex_unlock(&ut_list_mutex);

                /* Sleep for a second and retry the allocation; maybe this is
                just a temporary shortage of memory */

                os_thread_sleep(1000000);

                retry_count++;

                goto retry;
        }

        if (ret == NULL) {
                /* Flush stderr to make more probable that the error
                message gets in the error file before we generate a seg
                fault */

                fflush(stderr);

                os_fast_mutex_unlock(&ut_list_mutex);

                /* Make an intentional seg fault so that we get a stack
                trace */
                /* Intentional segfault on NetWare causes an abend. Avoid this
                by graceful exit handling in ut_a(). */
#if (!defined __NETWARE__)
                if (assert_on_error) {
                        ut_print_timestamp(stderr);

                        fprintf(stderr,
                "  InnoDB: We now intentionally generate a seg fault so that\n"
                "InnoDB: on Linux we get a stack trace.\n");

                        if (*ut_mem_null_ptr) ut_mem_null_ptr = 0;
                } else {
                        return(NULL);
                }
#else
                ut_a(0);
#endif
        }

        if (set_to_zero) {
#ifdef UNIV_SET_MEM_TO_ZERO
                memset(ret, '\0', n + sizeof(ut_mem_block_t));
#endif
        }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

char* ut_memcpyq	(	char *	dest,
		char	q,
		const char *	src,
		ulint	len
	)

Definition at line 422 of file ut0mem.c.

                                      : pointer to end of dest */
        char*           dest,   /* in: output buffer */
        char            q,      /* in: the quote character */
        const char*     src,    /* in: string to be quoted */
        ulint           len)    /* in: length of src */
{
        const char*     srcend = src + len;

        while (src < srcend) {
                if ((*dest++ = *src++) == q) {
                        *dest++ = q;
                }
        }

        return(dest);
}

void* ut_realloc	(	void *	ptr,
		ulint	size
	)

Definition at line 268 of file ut0mem.c.

References yaSSL::block, NULL, ut_a, ut_free(), ut_malloc(), UT_MEM_MAGIC_N, and ut_memcpy().

                                   : pointer to new mem block or NULL */
        void*   ptr,    /* in: pointer to old block or NULL */
        ulint   size)   /* in: desired size */
{
        ut_mem_block_t* block;
        ulint           old_size;
        ulint           min_size;
        void*           new_ptr;

        if (ptr == NULL) {

                return(ut_malloc(size));
        }

        if (size == 0) {
                ut_free(ptr);

                return(NULL);
        }

        block = (ut_mem_block_t*)((byte*)ptr - sizeof(ut_mem_block_t));

        ut_a(block->magic_n == UT_MEM_MAGIC_N);

        old_size = block->size - sizeof(ut_mem_block_t);

        if (size < old_size) {
                min_size = size;
        } else {
                min_size = old_size;
        }

        new_ptr = ut_malloc(size);

        if (new_ptr == NULL) {

                return(NULL);
        }

        /* Copy the old data from ptr */
        ut_memcpy(new_ptr, ptr, min_size);

        ut_free(ptr);

        return(new_ptr);
}

Here is the call graph for this function:

ulint ut_strcount	(	const char *	s1,
		const char *	s2
	)

Definition at line 446 of file ut0mem.c.

References count, strlen(), and strstr().

Referenced by ut_strreplace().

                                      : the number of times s2 occurs in s1 */
        const char*     s1,     /* in: string to search in */
        const char*     s2)     /* in: string to search for */
{
        ulint   count = 0;
        ulint   len = strlen(s2);

        if (len == 0) {
                
                return(0);
        }

        for (;;) {
                s1 = strstr(s1, s2);

                if (!s1) {
                        
                        break;
                }

                count++;
                s1 += len;
        }

        return(count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ut_strcpyq	(	char *	dest,
		char	q,
		const char *	src
	)

Definition at line 400 of file ut0mem.c.

                                      : pointer to end of dest */
        char*           dest,   /* in: output buffer */
        char            q,      /* in: the quote character */
        const char*     src)    /* in: null-terminated string */
{
        while (*src) {
                if ((*dest++ = *src++) == q) {
                        *dest++ = q;
                }
        }

        return(dest);
}

ulint ut_strlcpy	(	char *	dst,
		const char *	src,
		ulint	size
	)

Definition at line 352 of file ut0mem.c.

References memcpy, n, strlen(), and ut_min().

Referenced by trx_set_detailed_error().

                                      : strlen(src) */
        char*           dst,    /* in: destination buffer */
        const char*     src,    /* in: source buffer */
        ulint           size)   /* in: size of destination buffer */
{
        ulint   src_size = strlen(src);

        if (size != 0) {
                ulint   n = ut_min(src_size, size - 1);

                memcpy(dst, src, n);
                dst[n] = '\0';
        }

        return(src_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint ut_strlcpy_rev	(	char *	dst,
		const char *	src,
		ulint	size
	)

Definition at line 376 of file ut0mem.c.

References memcpy, n, strlen(), and ut_min().

Referenced by mem_heap_create_block().

                                      : strlen(src) */
        char*           dst,    /* in: destination buffer */
        const char*     src,    /* in: source buffer */
        ulint           size)   /* in: size of destination buffer */
{
        ulint   src_size = strlen(src);

        if (size != 0) {
                ulint   n = ut_min(src_size, size - 1);

                memcpy(dst, src + src_size - n, n + 1);
        }

        return(src_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ut_strreplace	(	const char *	str,
		const char *	s1,
		const char *	s2
	)

Definition at line 480 of file ut0mem.c.

References count, int(), mem_alloc, memcpy, strlen(), strstr(), and ut_strcount().

                                           : modified string, must be
                                freed with mem_free() */
        const char*     str,    /* in: string to operate on */
        const char*     s1,     /* in: string to replace */
        const char*     s2)     /* in: string to replace s1 with */
{
        char*           new_str;
        char*           ptr;
        const char*     str_end;
        ulint           str_len = strlen(str);
        ulint           s1_len = strlen(s1);
        ulint           s2_len = strlen(s2);
        ulint           count = 0;
        int             len_delta = (int)s2_len - (int)s1_len;

        str_end = str + str_len;
        
        if (len_delta <= 0) {
                len_delta = 0;          
        } else {
                count = ut_strcount(str, s1);
        }
        
        new_str = mem_alloc(str_len + count * len_delta + 1);
        ptr = new_str;
        
        while (str) {
                const char*     next = strstr(str, s1);
                
                if (!next) {
                        next = str_end;
                }

                memcpy(ptr, str, next - str);
                ptr += next - str;

                if (next == str_end) {
                        
                        break;
                }

                memcpy(ptr, s2, s2_len);
                ptr += s2_len;
                
                str = next + s1_len;
        }

        *ptr = '\0';
        
        return(new_str);
}

Here is the call graph for this function:

ibool ut_test_malloc

(

ulint

n

)

Definition at line 187 of file ut0mem.c.

References errno, FALSE, free, malloc, NULL, TRUE, ut_print_timestamp(), and ut_total_allocated_memory.

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

Here is the call graph for this function:

---

Variable Documentation

ulint ut_total_allocated_memory = 0

Definition at line 23 of file ut0mem.c.

Referenced by os_awe_allocate_physical_mem(), os_awe_allocate_virtual_mem_window(), srv_printf_innodb_monitor(), ut_free(), ut_free_all_mem(), ut_malloc_low(), and ut_test_malloc().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.