← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/ut0mem.h

New merge for TableShare

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/ut0mem.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/*******************************************************************//**
20
 
@file include/ut0mem.h
21
 
Memory primitives
22
 
 
23
 
Created 5/30/1994 Heikki Tuuri
24
 
************************************************************************/
25
 
 
26
 
#ifndef ut0mem_h
27
 
#define ut0mem_h
28
 
 
29
 
#include "univ.i"
30
 
#include <string.h>
31
 
#include <sys/types.h>
32
 
#ifndef UNIV_HOTBACKUP
33
 
# include "os0sync.h"
34
 
 
35
 
/** The total amount of memory currently allocated from the operating
36
 
system with os_mem_alloc_large() or malloc().  Does not count malloc()
37
 
if srv_use_sys_malloc is set.  Protected by ut_list_mutex. */
38
 
extern ulint            ut_total_allocated_memory;
39
 
 
40
 
/** Mutex protecting ut_total_allocated_memory and ut_mem_block_list */
41
 
extern os_fast_mutex_t  ut_list_mutex;
42
 
#endif /* !UNIV_HOTBACKUP */
43
 
 
44
 
/** Wrapper for memcpy(3).  Copy memory area when the source and
45
 
target are not overlapping.
46
 
* @param dest   in: copy to
47
 
* @param sour   in: copy from
48
 
* @param n      in: number of bytes to copy
49
 
* @return       dest */
50
 
UNIV_INLINE
51
 
void*
52
 
ut_memcpy(void* dest, const void* sour, ulint n);
53
 
 
54
 
/** Wrapper for memmove(3).  Copy memory area when the source and
55
 
target are overlapping.
56
 
* @param dest   in: copy to
57
 
* @param sour   in: copy from
58
 
* @param n      in: number of bytes to copy
59
 
* @return       dest */
60
 
UNIV_INLINE
61
 
void*
62
 
ut_memmove(void* dest, const void* sour, ulint n);
63
 
 
64
 
/** Wrapper for memcmp(3).  Compare memory areas.
65
 
* @param str1   in: first memory block to compare
66
 
* @param str2   in: second memory block to compare
67
 
* @param n      in: number of bytes to compare
68
 
* @return       negative, 0, or positive if str1 is smaller, equal,
69
 
                or greater than str2, respectively. */
70
 
UNIV_INLINE
71
 
int
72
 
ut_memcmp(const void* str1, const void* str2, ulint n);
73
 
 
74
 
/**********************************************************************//**
75
 
Initializes the mem block list at database startup. */
76
 
UNIV_INTERN
77
 
void
78
 
ut_mem_init(void);
79
 
/*=============*/
80
 
 
81
 
/**********************************************************************//**
82
 
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
83
 
defined and set_to_zero is TRUE.
84
 
@return own: allocated memory */
85
 
UNIV_INTERN
86
 
void*
87
 
ut_malloc_low(
88
 
/*==========*/
89
 
        ulint   n,                      /*!< in: number of bytes to allocate */
90
 
        ibool   set_to_zero,            /*!< in: TRUE if allocated memory
91
 
                                        should be set to zero if
92
 
                                        UNIV_SET_MEM_TO_ZERO is defined */
93
 
        ibool   assert_on_error);       /*!< in: if TRUE, we crash mysqld if
94
 
                                        the memory cannot be allocated */
95
 
/**********************************************************************//**
96
 
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
97
 
defined.
98
 
@return own: allocated memory */
99
 
UNIV_INTERN
100
 
void*
101
 
ut_malloc(
102
 
/*======*/
103
 
        ulint   n);     /*!< in: number of bytes to allocate */
104
 
#ifndef UNIV_HOTBACKUP
105
 
/**********************************************************************//**
106
 
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
107
 
out. It cannot be used if we want to return an error message. Prints to
108
 
stderr a message if fails.
109
 
@return TRUE if succeeded */
110
 
UNIV_INTERN
111
 
ibool
112
 
ut_test_malloc(
113
 
/*===========*/
114
 
        ulint   n);     /*!< in: try to allocate this many bytes */
115
 
#endif /* !UNIV_HOTBACKUP */
116
 
/**********************************************************************//**
117
 
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
118
 
a nop. */
119
 
UNIV_INTERN
120
 
void
121
 
ut_free(
122
 
/*====*/
123
 
        void* ptr);  /*!< in, own: memory block, can be NULL */
124
 
#ifndef UNIV_HOTBACKUP
125
 
/**********************************************************************//**
126
 
Implements realloc. This is needed by /pars/lexyy.c. Otherwise, you should not
127
 
use this function because the allocation functions in mem0mem.h are the
128
 
recommended ones in InnoDB.
129
 
 
130
 
man realloc in Linux, 2004:
131
 
 
132
 
       realloc()  changes the size of the memory block pointed to
133
 
       by ptr to size bytes.  The contents will be  unchanged  to
134
 
       the minimum of the old and new sizes; newly allocated mem�
135
 
       ory will be uninitialized.  If ptr is NULL,  the  call  is
136
 
       equivalent  to malloc(size); if size is equal to zero, the
137
 
       call is equivalent to free(ptr).  Unless ptr is  NULL,  it
138
 
       must  have  been  returned by an earlier call to malloc(),
139
 
       calloc() or realloc().
140
 
 
141
 
RETURN VALUE
142
 
       realloc() returns a pointer to the newly allocated memory,
143
 
       which is suitably aligned for any kind of variable and may
144
 
       be different from ptr, or NULL if the  request  fails.  If
145
 
       size  was equal to 0, either NULL or a pointer suitable to
146
 
       be passed to free() is returned.  If realloc()  fails  the
147
 
       original  block  is  left  untouched  - it is not freed or
148
 
       moved.
149
 
@return own: pointer to new mem block or NULL */
150
 
UNIV_INTERN
151
 
void*
152
 
ut_realloc(
153
 
/*=======*/
154
 
        void*   ptr,    /*!< in: pointer to old block or NULL */
155
 
        ulint   size);  /*!< in: desired size */
156
 
/**********************************************************************//**
157
 
Frees in shutdown all allocated memory not freed yet. */
158
 
UNIV_INTERN
159
 
void
160
 
ut_free_all_mem(void);
161
 
/*=================*/
162
 
#endif /* !UNIV_HOTBACKUP */
163
 
 
164
 
/** Wrapper for strcpy(3).  Copy a NUL-terminated string.
165
 
* @param dest   in: copy to
166
 
* @param sour   in: copy from
167
 
* @return       dest */
168
 
UNIV_INLINE
169
 
char*
170
 
ut_strcpy(char* dest, const char* sour);
171
 
 
172
 
/** Wrapper for strlen(3).  Determine the length of a NUL-terminated string.
173
 
* @param str    in: string
174
 
* @return       length of the string in bytes, excluding the terminating NUL */
175
 
UNIV_INLINE
176
 
ulint
177
 
ut_strlen(const char* str);
178
 
 
179
 
/** Wrapper for strcmp(3).  Compare NUL-terminated strings.
180
 
* @param str1   in: first string to compare
181
 
* @param str2   in: second string to compare
182
 
* @return       negative, 0, or positive if str1 is smaller, equal,
183
 
                or greater than str2, respectively. */
184
 
UNIV_INLINE
185
 
int
186
 
ut_strcmp(const char* str1, const char* str2);
187
 
 
188
 
/**********************************************************************//**
189
 
Copies up to size - 1 characters from the NUL-terminated string src to
190
 
dst, NUL-terminating the result. Returns strlen(src), so truncation
191
 
occurred if the return value >= size.
192
 
@return strlen(src) */
193
 
UNIV_INTERN
194
 
ulint
195
 
ut_strlcpy(
196
 
/*=======*/
197
 
        char*           dst,    /*!< in: destination buffer */
198
 
        const char*     src,    /*!< in: source buffer */
199
 
        ulint           size);  /*!< in: size of destination buffer */
200
 
 
201
 
/**********************************************************************//**
202
 
Like ut_strlcpy, but if src doesn't fit in dst completely, copies the last
203
 
(size - 1) bytes of src, not the first.
204
 
@return strlen(src) */
205
 
UNIV_INTERN
206
 
ulint
207
 
ut_strlcpy_rev(
208
 
/*===========*/
209
 
        char*           dst,    /*!< in: destination buffer */
210
 
        const char*     src,    /*!< in: source buffer */
211
 
        ulint           size);  /*!< in: size of destination buffer */
212
 
 
213
 
/**********************************************************************//**
214
 
Compute strlen(ut_strcpyq(str, q)).
215
 
@return length of the string when quoted */
216
 
UNIV_INLINE
217
 
ulint
218
 
ut_strlenq(
219
 
/*=======*/
220
 
        const char*     str,    /*!< in: null-terminated string */
221
 
        char            q);     /*!< in: the quote character */
222
 
 
223
 
/**********************************************************************//**
224
 
Make a quoted copy of a NUL-terminated string.  Leading and trailing
225
 
quotes will not be included; only embedded quotes will be escaped.
226
 
See also ut_strlenq() and ut_memcpyq().
227
 
@return pointer to end of dest */
228
 
UNIV_INTERN
229
 
char*
230
 
ut_strcpyq(
231
 
/*=======*/
232
 
        char*           dest,   /*!< in: output buffer */
233
 
        char            q,      /*!< in: the quote character */
234
 
        const char*     src);   /*!< in: null-terminated string */
235
 
 
236
 
/**********************************************************************//**
237
 
Make a quoted copy of a fixed-length string.  Leading and trailing
238
 
quotes will not be included; only embedded quotes will be escaped.
239
 
See also ut_strlenq() and ut_strcpyq().
240
 
@return pointer to end of dest */
241
 
UNIV_INTERN
242
 
char*
243
 
ut_memcpyq(
244
 
/*=======*/
245
 
        char*           dest,   /*!< in: output buffer */
246
 
        char            q,      /*!< in: the quote character */
247
 
        const char*     src,    /*!< in: string to be quoted */
248
 
        ulint           len);   /*!< in: length of src */
249
 
 
250
 
/**********************************************************************//**
251
 
Return the number of times s2 occurs in s1. Overlapping instances of s2
252
 
are only counted once.
253
 
@return the number of times s2 occurs in s1 */
254
 
UNIV_INTERN
255
 
ulint
256
 
ut_strcount(
257
 
/*========*/
258
 
        const char*     s1,     /*!< in: string to search in */
259
 
        const char*     s2);    /*!< in: string to search for */
260
 
 
261
 
/**********************************************************************//**
262
 
Replace every occurrence of s1 in str with s2. Overlapping instances of s1
263
 
are only replaced once.
264
 
@return own: modified string, must be freed with mem_free() */
265
 
UNIV_INTERN
266
 
char*
267
 
ut_strreplace(
268
 
/*==========*/
269
 
        const char*     str,    /*!< in: string to operate on */
270
 
        const char*     s1,     /*!< in: string to replace */
271
 
        const char*     s2);    /*!< in: string to replace s1 with */
272
 
 
273
 
/**********************************************************************//**
274
 
Converts a raw binary data to a NUL-terminated hex string. The output is
275
 
truncated if there is not enough space in "hex", make sure "hex_size" is at
276
 
least (2 * raw_size + 1) if you do not want this to happen. Returns the
277
 
actual number of characters written to "hex" (including the NUL).
278
 
@return number of chars written */
279
 
UNIV_INLINE
280
 
ulint
281
 
ut_raw_to_hex(
282
 
/*==========*/
283
 
        const void*     raw,            /*!< in: raw data */
284
 
        ulint           raw_size,       /*!< in: "raw" length in bytes */
285
 
        char*           hex,            /*!< out: hex string */
286
 
        ulint           hex_size);      /*!< in: "hex" size in bytes */
287
 
 
288
 
/*******************************************************************//**
289
 
Adds single quotes to the start and end of string and escapes any quotes
290
 
by doubling them. Returns the number of bytes that were written to "buf"
291
 
(including the terminating NUL). If buf_size is too small then the
292
 
trailing bytes from "str" are discarded.
293
 
@return number of bytes that were written */
294
 
UNIV_INLINE
295
 
ulint
296
 
ut_str_sql_format(
297
 
/*==============*/
298
 
        const char*     str,            /*!< in: string */
299
 
        ulint           str_len,        /*!< in: string length in bytes */
300
 
        char*           buf,            /*!< out: output buffer */
301
 
        ulint           buf_size);      /*!< in: output buffer size
302
 
                                        in bytes */
303
 
 
304
 
#ifndef UNIV_NONINL
305
 
#include "ut0mem.ic"
306
 
#endif
307
 
 
308
 
#endif