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