xref: /PHP-7.3/ext/mysqlnd/mysqlnd_alloc.c (revision a6519d05)
1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 7                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 2006-2018 The PHP Group                                |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.01 of the PHP license,      |
8   | that is bundled with this package in the file LICENSE, and is        |
9   | available through the world-wide-web at the following url:           |
10   | http://www.php.net/license/3_01.txt                                  |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Authors: Andrey Hristov <andrey@php.net>                             |
16   |          Ulf Wendel <uw@php.net>                                     |
17   +----------------------------------------------------------------------+
18 */
19 
20 #include "php.h"
21 #include "mysqlnd.h"
22 #include "mysqlnd_priv.h"
23 #include "mysqlnd_debug.h"
24 #include "mysqlnd_wireprotocol.h"
25 #include "mysqlnd_statistics.h"
26 
27 #define MYSQLND_DEBUG_MEMORY 1
28 
29 static const char mysqlnd_emalloc_name[]	= "_mysqlnd_emalloc";
30 static const char mysqlnd_pemalloc_name[]	= "_mysqlnd_pemalloc";
31 static const char mysqlnd_ecalloc_name[]	= "_mysqlnd_ecalloc";
32 static const char mysqlnd_pecalloc_name[]	= "_mysqlnd_pecalloc";
33 static const char mysqlnd_erealloc_name[]	= "_mysqlnd_erealloc";
34 static const char mysqlnd_perealloc_name[]	= "_mysqlnd_perealloc";
35 static const char mysqlnd_efree_name[]		= "_mysqlnd_efree";
36 static const char mysqlnd_pefree_name[]		= "_mysqlnd_pefree";
37 static const char mysqlnd_malloc_name[]		= "_mysqlnd_malloc";
38 static const char mysqlnd_calloc_name[]		= "_mysqlnd_calloc";
39 static const char mysqlnd_realloc_name[]	= "_mysqlnd_realloc";
40 static const char mysqlnd_free_name[]		= "_mysqlnd_free";
41 static const char mysqlnd_pememdup_name[]	= "_mysqlnd_pememdup";
42 static const char mysqlnd_pestrndup_name[]	= "_mysqlnd_pestrndup";
43 static const char mysqlnd_pestrdup_name[]	= "_mysqlnd_pestrdup";
44 
45 PHPAPI const char * mysqlnd_debug_std_no_trace_funcs[] =
46 {
47 	mysqlnd_emalloc_name,
48 	mysqlnd_ecalloc_name,
49 	mysqlnd_efree_name,
50 	mysqlnd_erealloc_name,
51 	mysqlnd_pemalloc_name,
52 	mysqlnd_pecalloc_name,
53 	mysqlnd_pefree_name,
54 	mysqlnd_perealloc_name,
55 	mysqlnd_malloc_name,
56 	mysqlnd_calloc_name,
57 	mysqlnd_realloc_name,
58 	mysqlnd_free_name,
59 	mysqlnd_pestrndup_name,
60 	mysqlnd_read_header_name,
61 	mysqlnd_read_body_name,
62 	NULL /* must be always last */
63 };
64 
65 #if MYSQLND_DEBUG_MEMORY
66 
67 
68 #if ZEND_DEBUG
69 #else
70 #define __zend_orig_filename "/unknown/unknown"
71 #define __zend_orig_lineno   0
72 #endif
73 
74 #define REAL_SIZE(s) (collect_memory_statistics? (s) + sizeof(size_t) : (s))
75 #define REAL_PTR(p) (collect_memory_statistics && (p)? (((char *)(p)) - sizeof(size_t)) : (p))
76 #define FAKE_PTR(p) (collect_memory_statistics && (p)? (((char *)(p)) + sizeof(size_t)) : (p))
77 
78 /* {{{ _mysqlnd_emalloc */
_mysqlnd_emalloc(size_t size MYSQLND_MEM_D)79 static void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D)
80 {
81 	void *ret;
82 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
83 #if PHP_DEBUG
84 	zend_long * threshold = &MYSQLND_G(debug_emalloc_fail_threshold);
85 #endif
86 	TRACE_ALLOC_ENTER(mysqlnd_emalloc_name);
87 
88 #if PHP_DEBUG
89 	{
90 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
91 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
92 	}
93 #endif
94 
95 #if PHP_DEBUG
96 	/* -1 is also "true" */
97 	if (*threshold) {
98 #endif
99 		ret = emalloc_rel(REAL_SIZE(size));
100 #if PHP_DEBUG
101 		--*threshold;
102 	} else if (*threshold == 0) {
103 		ret = NULL;
104 	}
105 #endif
106 
107 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret);
108 
109 	if (ret && collect_memory_statistics) {
110 		*(size_t *) ret = size;
111 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMOUNT, size);
112 	}
113 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
114 }
115 /* }}} */
116 
117 
118 /* {{{ _mysqlnd_pemalloc */
_mysqlnd_pemalloc(size_t size,zend_bool persistent MYSQLND_MEM_D)119 static void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
120 {
121 	void *ret;
122 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
123 #if PHP_DEBUG
124 	zend_long * threshold = persistent? &MYSQLND_G(debug_malloc_fail_threshold):&MYSQLND_G(debug_emalloc_fail_threshold);
125 #endif
126 	TRACE_ALLOC_ENTER(mysqlnd_pemalloc_name);
127 
128 #if PHP_DEBUG
129 	{
130 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
131 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
132 	}
133 #endif
134 
135 #if PHP_DEBUG
136 	/* -1 is also "true" */
137 	if (*threshold) {
138 #endif
139 		ret = pemalloc_rel(REAL_SIZE(size), persistent);
140 #if PHP_DEBUG
141 		--*threshold;
142 	} else if (*threshold == 0) {
143 		ret = NULL;
144 	}
145 #endif
146 
147 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p persistent=%u", size, ret, persistent);
148 
149 	if (ret && collect_memory_statistics) {
150 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_MALLOC_COUNT:STAT_MEM_EMALLOC_COUNT;
151 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_MALLOC_AMOUNT:STAT_MEM_EMALLOC_AMOUNT;
152 		*(size_t *) ret = size;
153 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
154 	}
155 
156 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
157 }
158 /* }}} */
159 
160 
161 /* {{{ _mysqlnd_ecalloc */
_mysqlnd_ecalloc(unsigned int nmemb,size_t size MYSQLND_MEM_D)162 static void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
163 {
164 	void *ret;
165 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
166 #if PHP_DEBUG
167 	zend_long * threshold = &MYSQLND_G(debug_ecalloc_fail_threshold);
168 #endif
169 	TRACE_ALLOC_ENTER(mysqlnd_ecalloc_name);
170 
171 #if PHP_DEBUG
172 	{
173 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
174 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
175 	}
176 #endif
177 	TRACE_ALLOC_INF_FMT("before: %lu", zend_memory_usage(FALSE));
178 
179 #if PHP_DEBUG
180 	/* -1 is also "true" */
181 	if (*threshold) {
182 #endif
183 		ret = ecalloc_rel(nmemb, REAL_SIZE(size));
184 #if PHP_DEBUG
185 		--*threshold;
186 	} else if (*threshold == 0) {
187 		ret = NULL;
188 	}
189 #endif
190 
191 	TRACE_ALLOC_INF_FMT("after : %lu", zend_memory_usage(FALSE));
192 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret);
193 	if (ret && collect_memory_statistics) {
194 		*(size_t *) ret = size;
195 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMOUNT, size);
196 	}
197 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
198 }
199 /* }}} */
200 
201 
202 /* {{{ _mysqlnd_pecalloc */
_mysqlnd_pecalloc(unsigned int nmemb,size_t size,zend_bool persistent MYSQLND_MEM_D)203 static void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D)
204 {
205 	void *ret;
206 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
207 #if PHP_DEBUG
208 	zend_long * threshold = persistent? &MYSQLND_G(debug_calloc_fail_threshold):&MYSQLND_G(debug_ecalloc_fail_threshold);
209 #endif
210 	TRACE_ALLOC_ENTER(mysqlnd_pecalloc_name);
211 #if PHP_DEBUG
212 	{
213 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
214 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
215 	}
216 #endif
217 
218 #if PHP_DEBUG
219 	/* -1 is also "true" */
220 	if (*threshold) {
221 #endif
222 		ret = pecalloc_rel(nmemb, REAL_SIZE(size), persistent);
223 #if PHP_DEBUG
224 		--*threshold;
225 	} else if (*threshold == 0) {
226 		ret = NULL;
227 	}
228 #endif
229 
230 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret);
231 
232 	if (ret && collect_memory_statistics) {
233 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_CALLOC_COUNT:STAT_MEM_ECALLOC_COUNT;
234 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_CALLOC_AMOUNT:STAT_MEM_ECALLOC_AMOUNT;
235 		*(size_t *) ret = size;
236 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
237 	}
238 
239 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
240 }
241 /* }}} */
242 
243 
244 /* {{{ _mysqlnd_erealloc */
_mysqlnd_erealloc(void * ptr,size_t new_size MYSQLND_MEM_D)245 static void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D)
246 {
247 	void *ret;
248 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
249 	size_t old_size = collect_memory_statistics && ptr? *(size_t *) (((char*)ptr) - sizeof(size_t)) : 0;
250 #if PHP_DEBUG
251 	zend_long * threshold = &MYSQLND_G(debug_erealloc_fail_threshold);
252 #endif
253 	TRACE_ALLOC_ENTER(mysqlnd_erealloc_name);
254 
255 #if PHP_DEBUG
256 	{
257 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
258 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
259 	}
260 #endif
261 	TRACE_ALLOC_INF_FMT("ptr=%p old_size=%lu, new_size=%lu", ptr, old_size, new_size);
262 
263 #if PHP_DEBUG
264 	/* -1 is also "true" */
265 	if (*threshold) {
266 #endif
267 		ret = erealloc_rel(REAL_PTR(ptr), REAL_SIZE(new_size));
268 #if PHP_DEBUG
269 		--*threshold;
270 	} else if (*threshold == 0) {
271 		ret = NULL;
272 	}
273 #endif
274 
275 	TRACE_ALLOC_INF_FMT("new_ptr=%p", (char*)ret);
276 	if (ret && collect_memory_statistics) {
277 		*(size_t *) ret = new_size;
278 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EREALLOC_COUNT, 1, STAT_MEM_EREALLOC_AMOUNT, new_size);
279 	}
280 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
281 }
282 /* }}} */
283 
284 
285 /* {{{ _mysqlnd_perealloc */
_mysqlnd_perealloc(void * ptr,size_t new_size,zend_bool persistent MYSQLND_MEM_D)286 static void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D)
287 {
288 	void *ret;
289 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
290 	size_t old_size = collect_memory_statistics && ptr? *(size_t *) (((char*)ptr) - sizeof(size_t)) : 0;
291 #if PHP_DEBUG
292 	zend_long * threshold = persistent? &MYSQLND_G(debug_realloc_fail_threshold):&MYSQLND_G(debug_erealloc_fail_threshold);
293 #endif
294 	TRACE_ALLOC_ENTER(mysqlnd_perealloc_name);
295 
296 #if PHP_DEBUG
297 	{
298 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
299 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
300 	}
301 #endif
302 	TRACE_ALLOC_INF_FMT("ptr=%p old_size=%lu new_size=%lu   persistent=%u", ptr, old_size, new_size, persistent);
303 
304 #if PHP_DEBUG
305 	/* -1 is also "true" */
306 	if (*threshold) {
307 #endif
308 		ret = perealloc_rel(REAL_PTR(ptr), REAL_SIZE(new_size), persistent);
309 #if PHP_DEBUG
310 		--*threshold;
311 	} else if (*threshold == 0) {
312 		ret = NULL;
313 	}
314 #endif
315 
316 	TRACE_ALLOC_INF_FMT("new_ptr=%p", (char*)ret);
317 
318 	if (ret && collect_memory_statistics) {
319 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_REALLOC_COUNT:STAT_MEM_EREALLOC_COUNT;
320 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_REALLOC_AMOUNT:STAT_MEM_EREALLOC_AMOUNT;
321 		*(size_t *) ret = new_size;
322 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, new_size);
323 	}
324 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
325 }
326 /* }}} */
327 
328 
329 /* {{{ _mysqlnd_efree */
_mysqlnd_efree(void * ptr MYSQLND_MEM_D)330 static void _mysqlnd_efree(void *ptr MYSQLND_MEM_D)
331 {
332 	size_t free_amount = 0;
333 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
334 	TRACE_ALLOC_ENTER(mysqlnd_efree_name);
335 
336 #if PHP_DEBUG
337 	{
338 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
339 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
340 	}
341 #endif
342 	TRACE_ALLOC_INF_FMT("ptr=%p", ptr);
343 
344 	if (ptr) {
345 		if (collect_memory_statistics) {
346 			free_amount = *(size_t *)(((char*)ptr) - sizeof(size_t));
347 			TRACE_ALLOC_INF_FMT("ptr=%p size=%u", ((char*)ptr) - sizeof(size_t), (unsigned int) free_amount);
348 		}
349 		efree_rel(REAL_PTR(ptr));
350 	}
351 
352 	if (collect_memory_statistics) {
353 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EFREE_COUNT, 1, STAT_MEM_EFREE_AMOUNT, free_amount);
354 	}
355 	TRACE_ALLOC_VOID_RETURN;
356 }
357 /* }}} */
358 
359 
360 /* {{{ _mysqlnd_pefree */
_mysqlnd_pefree(void * ptr,zend_bool persistent MYSQLND_MEM_D)361 static void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D)
362 {
363 	size_t free_amount = 0;
364 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
365 	TRACE_ALLOC_ENTER(mysqlnd_pefree_name);
366 
367 #if PHP_DEBUG
368 	{
369 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
370 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
371 	}
372 #endif
373 	TRACE_ALLOC_INF_FMT("ptr=%p persistent=%u", ptr, persistent);
374 
375 	if (ptr) {
376 		if (collect_memory_statistics) {
377 			free_amount = *(size_t *)(((char*)ptr) - sizeof(size_t));
378 			TRACE_ALLOC_INF_FMT("ptr=%p size=%u", ((char*)ptr) - sizeof(size_t), (unsigned int) free_amount);
379 		}
380 		pefree_rel(REAL_PTR(ptr), persistent);
381 	}
382 
383 	if (collect_memory_statistics) {
384 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(persistent? STAT_MEM_FREE_COUNT:STAT_MEM_EFREE_COUNT, 1,
385 											  persistent? STAT_MEM_FREE_AMOUNT:STAT_MEM_EFREE_AMOUNT, free_amount);
386 	}
387 	TRACE_ALLOC_VOID_RETURN;
388 }
389 /* }}} */
390 
391 
392 /* {{{ _mysqlnd_malloc */
_mysqlnd_malloc(size_t size MYSQLND_MEM_D)393 static void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D)
394 {
395 	void *ret;
396 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
397 #if PHP_DEBUG
398 	zend_long * threshold = &MYSQLND_G(debug_malloc_fail_threshold);
399 #endif
400 	TRACE_ALLOC_ENTER(mysqlnd_malloc_name);
401 
402 #if PHP_DEBUG
403 	{
404 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
405 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
406 	}
407 #endif
408 
409 #if PHP_DEBUG
410 	/* -1 is also "true" */
411 	if (*threshold) {
412 #endif
413 		ret = malloc(REAL_SIZE(size));
414 #if PHP_DEBUG
415 		--*threshold;
416 	} else if (*threshold == 0) {
417 		ret = NULL;
418 	}
419 #endif
420 
421 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret);
422 	if (ret && collect_memory_statistics) {
423 		*(size_t *) ret = size;
424 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMOUNT, size);
425 	}
426 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
427 }
428 /* }}} */
429 
430 
431 /* {{{ _mysqlnd_calloc */
_mysqlnd_calloc(unsigned int nmemb,size_t size MYSQLND_MEM_D)432 static void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
433 {
434 	void *ret;
435 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
436 #if PHP_DEBUG
437 	zend_long * threshold = &MYSQLND_G(debug_calloc_fail_threshold);
438 #endif
439 	TRACE_ALLOC_ENTER(mysqlnd_calloc_name);
440 
441 #if PHP_DEBUG
442 	{
443 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
444 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
445 	}
446 #endif
447 
448 #if PHP_DEBUG
449 	/* -1 is also "true" */
450 	if (*threshold) {
451 #endif
452 		ret = calloc(nmemb, REAL_SIZE(size));
453 #if PHP_DEBUG
454 		--*threshold;
455 	} else if (*threshold == 0) {
456 		ret = NULL;
457 	}
458 #endif
459 
460 	TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret);
461 	if (ret && collect_memory_statistics) {
462 		*(size_t *) ret = size;
463 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMOUNT, size);
464 	}
465 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
466 }
467 /* }}} */
468 
469 
470 /* {{{ _mysqlnd_realloc */
_mysqlnd_realloc(void * ptr,size_t new_size MYSQLND_MEM_D)471 static void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D)
472 {
473 	void *ret;
474 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
475 #if PHP_DEBUG
476 	zend_long * threshold = &MYSQLND_G(debug_realloc_fail_threshold);
477 #endif
478 	TRACE_ALLOC_ENTER(mysqlnd_realloc_name);
479 
480 #if PHP_DEBUG
481 	{
482 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
483 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
484 	}
485 #endif
486 	TRACE_ALLOC_INF_FMT("ptr=%p new_size=%lu ", new_size, ptr);
487 	TRACE_ALLOC_INF_FMT("before: %lu", zend_memory_usage(TRUE));
488 
489 #if PHP_DEBUG
490 	/* -1 is also "true" */
491 	if (*threshold) {
492 #endif
493 		ret = realloc(REAL_PTR(ptr), REAL_SIZE(new_size));
494 #if PHP_DEBUG
495 		--*threshold;
496 	} else if (*threshold == 0) {
497 		ret = NULL;
498 	}
499 #endif
500 
501 	TRACE_ALLOC_INF_FMT("new_ptr=%p", (char*)ret);
502 
503 	if (ret && collect_memory_statistics) {
504 		*(size_t *) ret = new_size;
505 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_REALLOC_COUNT, 1, STAT_MEM_REALLOC_AMOUNT, new_size);
506 	}
507 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
508 }
509 /* }}} */
510 
511 
512 /* {{{ _mysqlnd_free */
_mysqlnd_free(void * ptr MYSQLND_MEM_D)513 static void _mysqlnd_free(void *ptr MYSQLND_MEM_D)
514 {
515 	size_t free_amount = 0;
516 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
517 	TRACE_ALLOC_ENTER(mysqlnd_free_name);
518 
519 #if PHP_DEBUG
520 	{
521 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
522 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
523 	}
524 #endif
525 	TRACE_ALLOC_INF_FMT("ptr=%p", ptr);
526 
527 	if (ptr) {
528 		if (collect_memory_statistics) {
529 			free_amount = *(size_t *)(((char*)ptr) - sizeof(size_t));
530 			TRACE_ALLOC_INF_FMT("ptr=%p size=%u", ((char*)ptr) - sizeof(size_t), (unsigned int) free_amount);
531 		}
532 		free(REAL_PTR(ptr));
533 	}
534 
535 	if (collect_memory_statistics) {
536 		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_FREE_COUNT, 1, STAT_MEM_FREE_AMOUNT, free_amount);
537 	}
538 	TRACE_ALLOC_VOID_RETURN;
539 }
540 /* }}} */
541 
542 
543 /* {{{ _mysqlnd_pememdup */
_mysqlnd_pememdup(const char * const ptr,size_t length,zend_bool persistent MYSQLND_MEM_D)544 static char * _mysqlnd_pememdup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D)
545 {
546 	char * ret;
547 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
548 	TRACE_ALLOC_ENTER(mysqlnd_pememdup_name);
549 
550 #if PHP_DEBUG
551 	{
552 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
553 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
554 	}
555 #endif
556 	TRACE_ALLOC_INF_FMT("ptr=%p", ptr);
557 
558 	ret = pemalloc_rel(REAL_SIZE(length + 1), persistent);
559 	{
560 		char * dest = (char *) FAKE_PTR(ret);
561 		memcpy(dest, ptr, length);
562 	}
563 
564 	if (collect_memory_statistics) {
565 		*(size_t *) ret = length;
566 		MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_DUP_COUNT : STAT_MEM_EDUP_COUNT);
567 	}
568 
569 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
570 }
571 /* }}} */
572 
573 
574 /* {{{ _mysqlnd_pestrndup */
_mysqlnd_pestrndup(const char * const ptr,size_t length,zend_bool persistent MYSQLND_MEM_D)575 static char * _mysqlnd_pestrndup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D)
576 {
577 	char * ret;
578 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
579 	TRACE_ALLOC_ENTER(mysqlnd_pestrndup_name);
580 
581 #if PHP_DEBUG
582 	{
583 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
584 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
585 	}
586 #endif
587 	TRACE_ALLOC_INF_FMT("ptr=%p", ptr);
588 
589 	ret = pemalloc_rel(REAL_SIZE(length + 1), persistent);
590 	{
591 		size_t l = length;
592 		char * p = (char *) ptr;
593 		char * dest = (char *) FAKE_PTR(ret);
594 		while (*p && l--) {
595 			*dest++ = *p++;
596 		}
597 		*dest = '\0';
598 	}
599 
600 	if (collect_memory_statistics) {
601 		*(size_t *) ret = length;
602 		MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRNDUP_COUNT : STAT_MEM_ESTRNDUP_COUNT);
603 	}
604 
605 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
606 }
607 /* }}} */
608 
609 
610 #define SMART_STR_START_SIZE 2048
611 #define SMART_STR_PREALLOC 512
612 #include "zend_smart_str.h"
613 
614 
615 /* {{{ _mysqlnd_pestrdup */
_mysqlnd_pestrdup(const char * const ptr,zend_bool persistent MYSQLND_MEM_D)616 static char * _mysqlnd_pestrdup(const char * const ptr, zend_bool persistent MYSQLND_MEM_D)
617 {
618 	char * ret;
619 	smart_str tmp_str = {0, 0};
620 	const char * p = ptr;
621 	zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
622 	TRACE_ALLOC_ENTER(mysqlnd_pestrdup_name);
623 #if PHP_DEBUG
624 	{
625 		char * fn = strrchr(__zend_filename, PHP_DIR_SEPARATOR);
626 		TRACE_ALLOC_INF_FMT("file=%-15s line=%4d", fn? fn + 1:__zend_filename, __zend_lineno);
627 	}
628 #endif
629 	TRACE_ALLOC_INF_FMT("ptr=%p", ptr);
630 	do {
631 		smart_str_appendc(&tmp_str, *p);
632 	} while (*p++);
633 
634 	ret = pemalloc_rel(ZSTR_LEN(tmp_str.s) + sizeof(size_t), persistent);
635 	memcpy(FAKE_PTR(ret), ZSTR_VAL(tmp_str.s), ZSTR_LEN(tmp_str.s));
636 
637 	if (ret && collect_memory_statistics) {
638 		*(size_t *) ret = ZSTR_LEN(tmp_str.s);
639 		MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRDUP_COUNT : STAT_MEM_ESTRDUP_COUNT);
640 	}
641 	smart_str_free(&tmp_str);
642 
643 	TRACE_ALLOC_RETURN(FAKE_PTR(ret));
644 }
645 /* }}} */
646 
647 
648 
649 
650 #endif /* MYSQLND_DEBUG_MEMORY */
651 
652 /* {{{ _mysqlnd_sprintf_free */
_mysqlnd_sprintf_free(char * p)653 static void _mysqlnd_sprintf_free(char * p)
654 {
655 	efree(p);
656 }
657 /* }}} */
658 
659 
660 /* {{{ _mysqlnd_sprintf */
_mysqlnd_sprintf(char ** pbuf,size_t max_len,const char * format,...)661 static int _mysqlnd_sprintf(char ** pbuf, size_t max_len, const char *format, ...)
662 {
663 	int len;
664 	va_list ap;
665 	va_start(ap, format);
666 	len = vspprintf(pbuf, max_len, format, ap);
667 	va_end(ap);
668 	return len;
669 }
670 /* }}} */
671 
672 /* {{{ _mysqlnd_vsprintf */
_mysqlnd_vsprintf(char ** pbuf,size_t max_len,const char * format,va_list ap)673 static int _mysqlnd_vsprintf(char ** pbuf, size_t max_len, const char * format, va_list ap)
674 {
675 	return vspprintf(pbuf, max_len, format, ap);
676 }
677 /* }}} */
678 
679 
680 
681 #if MYSQLND_DEBUG_MEMORY == 0
682 
683 /* {{{ mysqlnd_zend_mm_emalloc */
mysqlnd_zend_mm_emalloc(size_t size MYSQLND_MEM_D)684 static void * mysqlnd_zend_mm_emalloc(size_t size MYSQLND_MEM_D)
685 {
686 	return emalloc_rel(size);
687 }
688 /* }}} */
689 
690 
691 /* {{{ mysqlnd_zend_mm_pemalloc */
mysqlnd_zend_mm_pemalloc(size_t size,zend_bool persistent MYSQLND_MEM_D)692 static void * mysqlnd_zend_mm_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
693 {
694 	return pemalloc_rel(size, persistent);
695 }
696 /* }}} */
697 
698 
699 /* {{{ mysqlnd_zend_mm_ecalloc */
mysqlnd_zend_mm_ecalloc(unsigned int nmemb,size_t size MYSQLND_MEM_D)700 static void * mysqlnd_zend_mm_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
701 {
702 	return ecalloc_rel(nmemb, size);
703 }
704 /* }}} */
705 
706 
707 /* {{{ mysqlnd_zend_mm_pecalloc */
mysqlnd_zend_mm_pecalloc(unsigned int nmemb,size_t size,zend_bool persistent MYSQLND_MEM_D)708 static void * mysqlnd_zend_mm_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D)
709 {
710 	return pecalloc_rel(nmemb, size, persistent);
711 }
712 /* }}} */
713 
714 
715 /* {{{ mysqlnd_zend_mm_erealloc */
mysqlnd_zend_mm_erealloc(void * ptr,size_t new_size MYSQLND_MEM_D)716 static void * mysqlnd_zend_mm_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D)
717 {
718 	return erealloc_rel(ptr, new_size);
719 }
720 /* }}} */
721 
722 
723 /* {{{ mysqlnd_zend_mm_perealloc */
mysqlnd_zend_mm_perealloc(void * ptr,size_t new_size,zend_bool persistent MYSQLND_MEM_D)724 static void * mysqlnd_zend_mm_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D)
725 {
726 	return perealloc_rel(ptr, new_size, persistent);
727 }
728 /* }}} */
729 
730 
731 /* {{{ mysqlnd_zend_mm_efree */
mysqlnd_zend_mm_efree(void * ptr MYSQLND_MEM_D)732 static void mysqlnd_zend_mm_efree(void * ptr MYSQLND_MEM_D)
733 {
734 	efree_rel(ptr);
735 }
736 /* }}} */
737 
738 
739 /* {{{ mysqlnd_zend_mm_pefree */
mysqlnd_zend_mm_pefree(void * ptr,zend_bool persistent MYSQLND_MEM_D)740 static void mysqlnd_zend_mm_pefree(void * ptr, zend_bool persistent MYSQLND_MEM_D)
741 {
742 	pefree_rel(ptr, persistent);
743 }
744 /* }}} */
745 
746 
747 /* {{{ mysqlnd_zend_mm_malloc */
mysqlnd_zend_mm_malloc(size_t size MYSQLND_MEM_D)748 static void * mysqlnd_zend_mm_malloc(size_t size MYSQLND_MEM_D)
749 {
750 	return malloc(size);
751 }
752 /* }}} */
753 
754 
755 /* {{{ mysqlnd_zend_mm_calloc */
mysqlnd_zend_mm_calloc(unsigned int nmemb,size_t size MYSQLND_MEM_D)756 static void * mysqlnd_zend_mm_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
757 {
758 	return calloc(nmemb, size);
759 }
760 /* }}} */
761 
762 
763 /* {{{ mysqlnd_zend_mm_realloc */
mysqlnd_zend_mm_realloc(void * ptr,size_t new_size MYSQLND_MEM_D)764 static void * mysqlnd_zend_mm_realloc(void * ptr, size_t new_size MYSQLND_MEM_D)
765 {
766 	return realloc(ptr, new_size);
767 }
768 /* }}} */
769 
770 
771 /* {{{ mysqlnd_zend_mm_free */
mysqlnd_zend_mm_free(void * ptr MYSQLND_MEM_D)772 static void mysqlnd_zend_mm_free(void * ptr MYSQLND_MEM_D)
773 {
774 	free(ptr);
775 }
776 /* }}} */
777 
778 
779 /* {{{ mysqlnd_zend_mm_pememdup */
mysqlnd_zend_mm_pememdup(const char * const ptr,size_t length,zend_bool persistent MYSQLND_MEM_D)780 static char * mysqlnd_zend_mm_pememdup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D)
781 {
782 	char * dest = pemalloc_rel(length, persistent);
783 	if (dest) {
784 		memcpy(dest, ptr, length);
785 	}
786 	return dest;
787 }
788 /* }}} */
789 
790 
791 /* {{{ mysqlnd_zend_mm_pestrndup */
mysqlnd_zend_mm_pestrndup(const char * const ptr,size_t length,zend_bool persistent MYSQLND_MEM_D)792 static char * mysqlnd_zend_mm_pestrndup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D)
793 {
794 	return persistent? zend_strndup(ptr, length ) : estrndup_rel(ptr, length);
795 }
796 /* }}} */
797 
798 
799 /* {{{ mysqlnd_zend_mm_pestrdup */
mysqlnd_zend_mm_pestrdup(const char * const ptr,zend_bool persistent MYSQLND_MEM_D)800 static char * mysqlnd_zend_mm_pestrdup(const char * const ptr, zend_bool persistent MYSQLND_MEM_D)
801 {
802 	return pestrdup_rel(ptr, persistent);
803 }
804 /* }}} */
805 
806 #endif
807 
808 
809 PHPAPI struct st_mysqlnd_allocator_methods mysqlnd_allocator =
810 {
811 #if MYSQLND_DEBUG_MEMORY == 1
812 	_mysqlnd_emalloc,
813 	_mysqlnd_pemalloc,
814 	_mysqlnd_ecalloc,
815 	_mysqlnd_pecalloc,
816 	_mysqlnd_erealloc,
817 	_mysqlnd_perealloc,
818 	_mysqlnd_efree,
819 	_mysqlnd_pefree,
820 	_mysqlnd_malloc,
821 	_mysqlnd_calloc,
822 	_mysqlnd_realloc,
823 	_mysqlnd_free,
824 	_mysqlnd_pememdup,
825 	_mysqlnd_pestrndup,
826 	_mysqlnd_pestrdup,
827 	_mysqlnd_sprintf,
828 	_mysqlnd_vsprintf,
829 	_mysqlnd_sprintf_free
830 #else
831 	mysqlnd_zend_mm_emalloc,
832 	mysqlnd_zend_mm_pemalloc,
833 	mysqlnd_zend_mm_ecalloc,
834 	mysqlnd_zend_mm_pecalloc,
835 	mysqlnd_zend_mm_erealloc,
836 	mysqlnd_zend_mm_perealloc,
837 	mysqlnd_zend_mm_efree,
838 	mysqlnd_zend_mm_pefree,
839 	mysqlnd_zend_mm_malloc,
840 	mysqlnd_zend_mm_calloc,
841 	mysqlnd_zend_mm_realloc,
842 	mysqlnd_zend_mm_free,
843 	mysqlnd_zend_mm_pememdup,
844 	mysqlnd_zend_mm_pestrndup,
845 	mysqlnd_zend_mm_pestrdup,
846 	_mysqlnd_sprintf,
847 	_mysqlnd_vsprintf,
848 	_mysqlnd_sprintf_free,
849 #endif
850 };
851 
852 
853 /*
854  * Local variables:
855  * tab-width: 4
856  * c-basic-offset: 4
857  * End:
858  * vim600: noet sw=4 ts=4 fdm=marker
859  * vim<600: noet sw=4 ts=4
860  */
861