mirror of
https://github.com/MariaDB/server.git
synced 2025-01-20 14:02:32 +01:00
307 lines
10 KiB
C
307 lines
10 KiB
C
|
/*****************************************************************************
|
|||
|
|
|
|||
|
|
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
|
|||
|
|
|
|||
|
|
This program is free software; you can redistribute it and/or modify it under
|
|||
|
|
the terms of the GNU General Public License as published by the Free Software
|
|||
|
|
Foundation; version 2 of the License.
|
|||
|
|
|
|||
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|||
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|||
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|||
|
|
|
|||
|
|
You should have received a copy of the GNU General Public License along with
|
|||
|
|
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|||
|
|
Place, Suite 330, Boston, MA 02111-1307 USA
|
|||
|
|
|
|||
|
|
*****************************************************************************/
|
|||
|
|
|
|||
|
|
/*******************************************************************//**
|
|||
|
|
@file include/ut0mem.h
|
|||
|
|
Memory primitives
|
|||
|
|
|
|||
|
|
Created 5/30/1994 Heikki Tuuri
|
|||
|
|
************************************************************************/
|
|||
|
|
|
|||
|
|
#ifndef ut0mem_h
|
|||
|
|
#define ut0mem_h
|
|||
|
|
|
|||
|
|
#include "univ.i"
|
|||
|
|
#include <string.h>
|
|||
|
|
#ifndef UNIV_HOTBACKUP
|
|||
|
|
# include "os0sync.h"
|
|||
|
|
|
|||
|
|
/** The total amount of memory currently allocated from the operating
|
|||
|
|
system with os_mem_alloc_large() or malloc(). Does not count malloc()
|
|||
|
|
if srv_use_sys_malloc is set. Protected by ut_list_mutex. */
|
|||
|
|
extern ulint ut_total_allocated_memory;
|
|||
|
|
|
|||
|
|
/** Mutex protecting ut_total_allocated_memory and ut_mem_block_list */
|
|||
|
|
extern os_fast_mutex_t ut_list_mutex;
|
|||
|
|
#endif /* !UNIV_HOTBACKUP */
|
|||
|
|
|
|||
|
|
/** Wrapper for memcpy(3). Copy memory area when the source and
|
|||
|
|
target are not overlapping.
|
|||
|
|
* @param dest in: copy to
|
|||
|
|
* @param sour in: copy from
|
|||
|
|
* @param n in: number of bytes to copy
|
|||
|
|
* @return dest */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
void*
|
|||
|
|
ut_memcpy(void* dest, const void* sour, ulint n);
|
|||
|
|
|
|||
|
|
/** Wrapper for memmove(3). Copy memory area when the source and
|
|||
|
|
target are overlapping.
|
|||
|
|
* @param dest in: copy to
|
|||
|
|
* @param sour in: copy from
|
|||
|
|
* @param n in: number of bytes to copy
|
|||
|
|
* @return dest */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
void*
|
|||
|
|
ut_memmove(void* dest, const void* sour, ulint n);
|
|||
|
|
|
|||
|
|
/** Wrapper for memcmp(3). Compare memory areas.
|
|||
|
|
* @param str1 in: first memory block to compare
|
|||
|
|
* @param str2 in: second memory block to compare
|
|||
|
|
* @param n in: number of bytes to compare
|
|||
|
|
* @return negative, 0, or positive if str1 is smaller, equal,
|
|||
|
|
or greater than str2, respectively. */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
int
|
|||
|
|
ut_memcmp(const void* str1, const void* str2, ulint n);
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Initializes the mem block list at database startup. */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
void
|
|||
|
|
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.
|
|||
|
|
@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 */
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
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 */
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Frees a memory block allocated with ut_malloc. */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
void
|
|||
|
|
ut_free(
|
|||
|
|
/*====*/
|
|||
|
|
void* ptr); /*!< in, own: memory block */
|
|||
|
|
#ifndef UNIV_HOTBACKUP
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Implements realloc. This is needed by /pars/lexyy.c. Otherwise, you should not
|
|||
|
|
use this function because the allocation functions in mem0mem.h are the
|
|||
|
|
recommended ones in InnoDB.
|
|||
|
|
|
|||
|
|
man realloc in Linux, 2004:
|
|||
|
|
|
|||
|
|
realloc() changes the size of the memory block pointed to
|
|||
|
|
by ptr to size bytes. The contents will be unchanged to
|
|||
|
|
the minimum of the old and new sizes; newly allocated mem<EFBFBD>
|
|||
|
|
ory will be uninitialized. If ptr is NULL, the call is
|
|||
|
|
equivalent to malloc(size); if size is equal to zero, the
|
|||
|
|
call is equivalent to free(ptr). Unless ptr is NULL, it
|
|||
|
|
must have been returned by an earlier call to malloc(),
|
|||
|
|
calloc() or realloc().
|
|||
|
|
|
|||
|
|
RETURN VALUE
|
|||
|
|
realloc() returns a pointer to the newly allocated memory,
|
|||
|
|
which is suitably aligned for any kind of variable and may
|
|||
|
|
be different from ptr, or NULL if the request fails. If
|
|||
|
|
size was equal to 0, either NULL or a pointer suitable to
|
|||
|
|
be passed to free() is returned. If realloc() fails the
|
|||
|
|
original block is left untouched - it is not freed or
|
|||
|
|
moved.
|
|||
|
|
@return own: pointer to new mem block or NULL */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
void*
|
|||
|
|
ut_realloc(
|
|||
|
|
/*=======*/
|
|||
|
|
void* ptr, /*!< in: pointer to old block or NULL */
|
|||
|
|
ulint size); /*!< in: desired size */
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Frees in shutdown all allocated memory not freed yet. */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
void
|
|||
|
|
ut_free_all_mem(void);
|
|||
|
|
/*=================*/
|
|||
|
|
#endif /* !UNIV_HOTBACKUP */
|
|||
|
|
|
|||
|
|
/** Wrapper for strcpy(3). Copy a NUL-terminated string.
|
|||
|
|
* @param dest in: copy to
|
|||
|
|
* @param sour in: copy from
|
|||
|
|
* @return dest */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
char*
|
|||
|
|
ut_strcpy(char* dest, const char* sour);
|
|||
|
|
|
|||
|
|
/** Wrapper for strlen(3). Determine the length of a NUL-terminated string.
|
|||
|
|
* @param str in: string
|
|||
|
|
* @return length of the string in bytes, excluding the terminating NUL */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
ulint
|
|||
|
|
ut_strlen(const char* str);
|
|||
|
|
|
|||
|
|
/** Wrapper for strcmp(3). Compare NUL-terminated strings.
|
|||
|
|
* @param str1 in: first string to compare
|
|||
|
|
* @param str2 in: second string to compare
|
|||
|
|
* @return negative, 0, or positive if str1 is smaller, equal,
|
|||
|
|
or greater than str2, respectively. */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
int
|
|||
|
|
ut_strcmp(const char* str1, const char* str2);
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Copies up to size - 1 characters from the NUL-terminated string src to
|
|||
|
|
dst, NUL-terminating the result. Returns strlen(src), so truncation
|
|||
|
|
occurred if the return value >= size.
|
|||
|
|
@return strlen(src) */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
ulint
|
|||
|
|
ut_strlcpy(
|
|||
|
|
/*=======*/
|
|||
|
|
char* dst, /*!< in: destination buffer */
|
|||
|
|
const char* src, /*!< in: source buffer */
|
|||
|
|
ulint size); /*!< in: size of destination buffer */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Like ut_strlcpy, but if src doesn't fit in dst completely, copies the last
|
|||
|
|
(size - 1) bytes of src, not the first.
|
|||
|
|
@return strlen(src) */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
ulint
|
|||
|
|
ut_strlcpy_rev(
|
|||
|
|
/*===========*/
|
|||
|
|
char* dst, /*!< in: destination buffer */
|
|||
|
|
const char* src, /*!< in: source buffer */
|
|||
|
|
ulint size); /*!< in: size of destination buffer */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Compute strlen(ut_strcpyq(str, q)).
|
|||
|
|
@return length of the string when quoted */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
ulint
|
|||
|
|
ut_strlenq(
|
|||
|
|
/*=======*/
|
|||
|
|
const char* str, /*!< in: null-terminated string */
|
|||
|
|
char q); /*!< in: the quote character */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Make a quoted copy of a NUL-terminated string. Leading and trailing
|
|||
|
|
quotes will not be included; only embedded quotes will be escaped.
|
|||
|
|
See also ut_strlenq() and ut_memcpyq().
|
|||
|
|
@return pointer to end of dest */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
char*
|
|||
|
|
ut_strcpyq(
|
|||
|
|
/*=======*/
|
|||
|
|
char* dest, /*!< in: output buffer */
|
|||
|
|
char q, /*!< in: the quote character */
|
|||
|
|
const char* src); /*!< in: null-terminated string */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Make a quoted copy of a fixed-length string. Leading and trailing
|
|||
|
|
quotes will not be included; only embedded quotes will be escaped.
|
|||
|
|
See also ut_strlenq() and ut_strcpyq().
|
|||
|
|
@return pointer to end of dest */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
char*
|
|||
|
|
ut_memcpyq(
|
|||
|
|
/*=======*/
|
|||
|
|
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 */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Return the number of times s2 occurs in s1. Overlapping instances of s2
|
|||
|
|
are only counted once.
|
|||
|
|
@return the number of times s2 occurs in s1 */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
ulint
|
|||
|
|
ut_strcount(
|
|||
|
|
/*========*/
|
|||
|
|
const char* s1, /*!< in: string to search in */
|
|||
|
|
const char* s2); /*!< in: string to search for */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Replace every occurrence of s1 in str with s2. Overlapping instances of s1
|
|||
|
|
are only replaced once.
|
|||
|
|
@return own: modified string, must be freed with mem_free() */
|
|||
|
|
UNIV_INTERN
|
|||
|
|
char*
|
|||
|
|
ut_strreplace(
|
|||
|
|
/*==========*/
|
|||
|
|
const char* str, /*!< in: string to operate on */
|
|||
|
|
const char* s1, /*!< in: string to replace */
|
|||
|
|
const char* s2); /*!< in: string to replace s1 with */
|
|||
|
|
|
|||
|
|
/**********************************************************************//**
|
|||
|
|
Converts a raw binary data to a NUL-terminated hex string. The output is
|
|||
|
|
truncated if there is not enough space in "hex", make sure "hex_size" is at
|
|||
|
|
least (2 * raw_size + 1) if you do not want this to happen. Returns the
|
|||
|
|
actual number of characters written to "hex" (including the NUL).
|
|||
|
|
@return number of chars written */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
ulint
|
|||
|
|
ut_raw_to_hex(
|
|||
|
|
/*==========*/
|
|||
|
|
const void* raw, /*!< in: raw data */
|
|||
|
|
ulint raw_size, /*!< in: "raw" length in bytes */
|
|||
|
|
char* hex, /*!< out: hex string */
|
|||
|
|
ulint hex_size); /*!< in: "hex" size in bytes */
|
|||
|
|
|
|||
|
|
/*******************************************************************//**
|
|||
|
|
Adds single quotes to the start and end of string and escapes any quotes
|
|||
|
|
by doubling them. Returns the number of bytes that were written to "buf"
|
|||
|
|
(including the terminating NUL). If buf_size is too small then the
|
|||
|
|
trailing bytes from "str" are discarded.
|
|||
|
|
@return number of bytes that were written */
|
|||
|
|
UNIV_INLINE
|
|||
|
|
ulint
|
|||
|
|
ut_str_sql_format(
|
|||
|
|
/*==============*/
|
|||
|
|
const char* str, /*!< in: string */
|
|||
|
|
ulint str_len, /*!< in: string length in bytes */
|
|||
|
|
char* buf, /*!< out: output buffer */
|
|||
|
|
ulint buf_size); /*!< in: output buffer size
|
|||
|
|
in bytes */
|
|||
|
|
|
|||
|
|
#ifndef UNIV_NONINL
|
|||
|
|
#include "ut0mem.ic"
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#endif
|