1 /*
2 * xmlmemory.c: libxml memory allocator wrapper.
3 *
4 * daniel@veillard.com
5 */
6
7 #define IN_LIBXML
8 #include "libxml.h"
9
10 #include <string.h>
11
12 #ifdef HAVE_SYS_TYPES_H
13 #include <sys/types.h>
14 #endif
15
16 #ifdef HAVE_TIME_H
17 #include <time.h>
18 #endif
19
20 #ifdef HAVE_STDLIB_H
21 #include <stdlib.h>
22 #else
23 #ifdef HAVE_MALLOC_H
24 #include <malloc.h>
25 #endif
26 #endif
27
28 #ifdef HAVE_CTYPE_H
29 #include <ctype.h>
30 #endif
31
32 /* #define DEBUG_MEMORY */
33
34 /**
35 * MEM_LIST:
36 *
37 * keep track of all allocated blocks for error reporting
38 * Always build the memory list !
39 */
40 #ifdef DEBUG_MEMORY_LOCATION
41 #ifndef MEM_LIST
42 #define MEM_LIST /* keep a list of all the allocated memory blocks */
43 #endif
44 #endif
45
46 #include <libxml/globals.h> /* must come before xmlmemory.h */
47 #include <libxml/xmlmemory.h>
48 #include <libxml/xmlerror.h>
49 #include <libxml/threads.h>
50
51 static int xmlMemInitialized = 0;
52 static unsigned long debugMemSize = 0;
53 static unsigned long debugMemBlocks = 0;
54 static unsigned long debugMaxMemSize = 0;
55 static xmlMutexPtr xmlMemMutex = NULL;
56
57 void xmlMallocBreakpoint(void);
58
59 /************************************************************************
60 * *
61 * Macros, variables and associated types *
62 * *
63 ************************************************************************/
64
65 #if !defined(LIBXML_THREAD_ENABLED) && !defined(LIBXML_THREAD_ALLOC_ENABLED)
66 #ifdef xmlMalloc
67 #undef xmlMalloc
68 #endif
69 #ifdef xmlRealloc
70 #undef xmlRealloc
71 #endif
72 #ifdef xmlMemStrdup
73 #undef xmlMemStrdup
74 #endif
75 #endif
76
77 /*
78 * Each of the blocks allocated begin with a header containing information
79 */
80
81 #define MEMTAG 0x5aa5U
82
83 #define MALLOC_TYPE 1
84 #define REALLOC_TYPE 2
85 #define STRDUP_TYPE 3
86 #define MALLOC_ATOMIC_TYPE 4
87 #define REALLOC_ATOMIC_TYPE 5
88
89 typedef struct memnod {
90 unsigned int mh_tag;
91 unsigned int mh_type;
92 unsigned long mh_number;
93 size_t mh_size;
94 #ifdef MEM_LIST
95 struct memnod *mh_next;
96 struct memnod *mh_prev;
97 #endif
98 const char *mh_file;
99 unsigned int mh_line;
100 } MEMHDR;
101
102
103 #ifdef SUN4
104 #define ALIGN_SIZE 16
105 #else
106 #define ALIGN_SIZE sizeof(double)
107 #endif
108 #define HDR_SIZE sizeof(MEMHDR)
109 #define RESERVE_SIZE (((HDR_SIZE + (ALIGN_SIZE-1)) \
110 / ALIGN_SIZE ) * ALIGN_SIZE)
111
112 #define MAX_SIZE_T ((size_t)-1)
113
114 #define CLIENT_2_HDR(a) ((void *) (((char *) (a)) - RESERVE_SIZE))
115 #define HDR_2_CLIENT(a) ((void *) (((char *) (a)) + RESERVE_SIZE))
116
117
118 static unsigned int block=0;
119 static unsigned int xmlMemStopAtBlock = 0;
120 static void *xmlMemTraceBlockAt = NULL;
121 #ifdef MEM_LIST
122 static MEMHDR *memlist = NULL;
123 #endif
124
125 static void debugmem_tag_error(void *addr);
126 #ifdef MEM_LIST
127 static void debugmem_list_add(MEMHDR *);
128 static void debugmem_list_delete(MEMHDR *);
129 #endif
130 #define Mem_Tag_Err(a) debugmem_tag_error(a);
131
132 #ifndef TEST_POINT
133 #define TEST_POINT
134 #endif
135
136 /**
137 * xmlMallocBreakpoint:
138 *
139 * Breakpoint to use in conjunction with xmlMemStopAtBlock. When the block
140 * number reaches the specified value this function is called. One need to add a breakpoint
141 * to it to get the context in which the given block is allocated.
142 */
143
144 void
xmlMallocBreakpoint(void)145 xmlMallocBreakpoint(void) {
146 xmlGenericError(xmlGenericErrorContext,
147 "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
148 }
149
150 /**
151 * xmlMallocLoc:
152 * @size: an int specifying the size in byte to allocate.
153 * @file: the file name or NULL
154 * @line: the line number
155 *
156 * a malloc() equivalent, with logging of the allocation info.
157 *
158 * Returns a pointer to the allocated area or NULL in case of lack of memory.
159 */
160
161 void *
xmlMallocLoc(size_t size,const char * file,int line)162 xmlMallocLoc(size_t size, const char * file, int line)
163 {
164 MEMHDR *p;
165 void *ret;
166
167 if (!xmlMemInitialized) xmlInitMemory();
168 #ifdef DEBUG_MEMORY
169 xmlGenericError(xmlGenericErrorContext,
170 "Malloc(%d)\n",size);
171 #endif
172
173 TEST_POINT
174
175 if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
176 xmlGenericError(xmlGenericErrorContext,
177 "xmlMallocLoc : Unsigned overflow\n");
178 xmlMemoryDump();
179 return(NULL);
180 }
181
182 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
183
184 if (!p) {
185 xmlGenericError(xmlGenericErrorContext,
186 "xmlMallocLoc : Out of free space\n");
187 xmlMemoryDump();
188 return(NULL);
189 }
190 p->mh_tag = MEMTAG;
191 p->mh_size = size;
192 p->mh_type = MALLOC_TYPE;
193 p->mh_file = file;
194 p->mh_line = line;
195 xmlMutexLock(xmlMemMutex);
196 p->mh_number = ++block;
197 debugMemSize += size;
198 debugMemBlocks++;
199 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
200 #ifdef MEM_LIST
201 debugmem_list_add(p);
202 #endif
203 xmlMutexUnlock(xmlMemMutex);
204
205 #ifdef DEBUG_MEMORY
206 xmlGenericError(xmlGenericErrorContext,
207 "Malloc(%d) Ok\n",size);
208 #endif
209
210 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
211
212 ret = HDR_2_CLIENT(p);
213
214 if (xmlMemTraceBlockAt == ret) {
215 xmlGenericError(xmlGenericErrorContext,
216 "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
217 (long unsigned)size);
218 xmlMallocBreakpoint();
219 }
220
221 TEST_POINT
222
223 return(ret);
224 }
225
226 /**
227 * xmlMallocAtomicLoc:
228 * @size: an unsigned int specifying the size in byte to allocate.
229 * @file: the file name or NULL
230 * @line: the line number
231 *
232 * a malloc() equivalent, with logging of the allocation info.
233 *
234 * Returns a pointer to the allocated area or NULL in case of lack of memory.
235 */
236
237 void *
xmlMallocAtomicLoc(size_t size,const char * file,int line)238 xmlMallocAtomicLoc(size_t size, const char * file, int line)
239 {
240 MEMHDR *p;
241 void *ret;
242
243 if (!xmlMemInitialized) xmlInitMemory();
244 #ifdef DEBUG_MEMORY
245 xmlGenericError(xmlGenericErrorContext,
246 "Malloc(%d)\n",size);
247 #endif
248
249 TEST_POINT
250
251 if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
252 xmlGenericError(xmlGenericErrorContext,
253 "xmlMallocAtomicLoc : Unsigned overflow\n");
254 xmlMemoryDump();
255 return(NULL);
256 }
257
258 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
259
260 if (!p) {
261 xmlGenericError(xmlGenericErrorContext,
262 "xmlMallocAtomicLoc : Out of free space\n");
263 xmlMemoryDump();
264 return(NULL);
265 }
266 p->mh_tag = MEMTAG;
267 p->mh_size = size;
268 p->mh_type = MALLOC_ATOMIC_TYPE;
269 p->mh_file = file;
270 p->mh_line = line;
271 xmlMutexLock(xmlMemMutex);
272 p->mh_number = ++block;
273 debugMemSize += size;
274 debugMemBlocks++;
275 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
276 #ifdef MEM_LIST
277 debugmem_list_add(p);
278 #endif
279 xmlMutexUnlock(xmlMemMutex);
280
281 #ifdef DEBUG_MEMORY
282 xmlGenericError(xmlGenericErrorContext,
283 "Malloc(%d) Ok\n",size);
284 #endif
285
286 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
287
288 ret = HDR_2_CLIENT(p);
289
290 if (xmlMemTraceBlockAt == ret) {
291 xmlGenericError(xmlGenericErrorContext,
292 "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
293 (long unsigned)size);
294 xmlMallocBreakpoint();
295 }
296
297 TEST_POINT
298
299 return(ret);
300 }
301 /**
302 * xmlMemMalloc:
303 * @size: an int specifying the size in byte to allocate.
304 *
305 * a malloc() equivalent, with logging of the allocation info.
306 *
307 * Returns a pointer to the allocated area or NULL in case of lack of memory.
308 */
309
310 void *
xmlMemMalloc(size_t size)311 xmlMemMalloc(size_t size)
312 {
313 return(xmlMallocLoc(size, "none", 0));
314 }
315
316 /**
317 * xmlReallocLoc:
318 * @ptr: the initial memory block pointer
319 * @size: an int specifying the size in byte to allocate.
320 * @file: the file name or NULL
321 * @line: the line number
322 *
323 * a realloc() equivalent, with logging of the allocation info.
324 *
325 * Returns a pointer to the allocated area or NULL in case of lack of memory.
326 */
327
328 void *
xmlReallocLoc(void * ptr,size_t size,const char * file,int line)329 xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
330 {
331 MEMHDR *p, *tmp;
332 unsigned long number;
333 #ifdef DEBUG_MEMORY
334 size_t oldsize;
335 #endif
336
337 if (ptr == NULL)
338 return(xmlMallocLoc(size, file, line));
339
340 if (!xmlMemInitialized) xmlInitMemory();
341 TEST_POINT
342
343 p = CLIENT_2_HDR(ptr);
344 number = p->mh_number;
345 if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
346 if (p->mh_tag != MEMTAG) {
347 Mem_Tag_Err(p);
348 goto error;
349 }
350 p->mh_tag = ~MEMTAG;
351 xmlMutexLock(xmlMemMutex);
352 debugMemSize -= p->mh_size;
353 debugMemBlocks--;
354 #ifdef DEBUG_MEMORY
355 oldsize = p->mh_size;
356 #endif
357 #ifdef MEM_LIST
358 debugmem_list_delete(p);
359 #endif
360 xmlMutexUnlock(xmlMemMutex);
361
362 if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
363 xmlGenericError(xmlGenericErrorContext,
364 "xmlReallocLoc : Unsigned overflow\n");
365 xmlMemoryDump();
366 return(NULL);
367 }
368
369 tmp = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
370 if (!tmp) {
371 free(p);
372 goto error;
373 }
374 p = tmp;
375 if (xmlMemTraceBlockAt == ptr) {
376 xmlGenericError(xmlGenericErrorContext,
377 "%p : Realloced(%lu -> %lu) Ok\n",
378 xmlMemTraceBlockAt, (long unsigned)p->mh_size,
379 (long unsigned)size);
380 xmlMallocBreakpoint();
381 }
382 p->mh_tag = MEMTAG;
383 p->mh_number = number;
384 p->mh_type = REALLOC_TYPE;
385 p->mh_size = size;
386 p->mh_file = file;
387 p->mh_line = line;
388 xmlMutexLock(xmlMemMutex);
389 debugMemSize += size;
390 debugMemBlocks++;
391 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
392 #ifdef MEM_LIST
393 debugmem_list_add(p);
394 #endif
395 xmlMutexUnlock(xmlMemMutex);
396
397 TEST_POINT
398
399 #ifdef DEBUG_MEMORY
400 xmlGenericError(xmlGenericErrorContext,
401 "Realloced(%d to %d) Ok\n", oldsize, size);
402 #endif
403 return(HDR_2_CLIENT(p));
404
405 error:
406 return(NULL);
407 }
408
409 /**
410 * xmlMemRealloc:
411 * @ptr: the initial memory block pointer
412 * @size: an int specifying the size in byte to allocate.
413 *
414 * a realloc() equivalent, with logging of the allocation info.
415 *
416 * Returns a pointer to the allocated area or NULL in case of lack of memory.
417 */
418
419 void *
xmlMemRealloc(void * ptr,size_t size)420 xmlMemRealloc(void *ptr,size_t size) {
421 return(xmlReallocLoc(ptr, size, "none", 0));
422 }
423
424 /**
425 * xmlMemFree:
426 * @ptr: the memory block pointer
427 *
428 * a free() equivalent, with error checking.
429 */
430 void
xmlMemFree(void * ptr)431 xmlMemFree(void *ptr)
432 {
433 MEMHDR *p;
434 char *target;
435 #ifdef DEBUG_MEMORY
436 size_t size;
437 #endif
438
439 if (ptr == NULL)
440 return;
441
442 if (ptr == (void *) -1) {
443 xmlGenericError(xmlGenericErrorContext,
444 "trying to free pointer from freed area\n");
445 goto error;
446 }
447
448 if (xmlMemTraceBlockAt == ptr) {
449 xmlGenericError(xmlGenericErrorContext,
450 "%p : Freed()\n", xmlMemTraceBlockAt);
451 xmlMallocBreakpoint();
452 }
453
454 TEST_POINT
455
456 target = (char *) ptr;
457
458 p = CLIENT_2_HDR(ptr);
459 if (p->mh_tag != MEMTAG) {
460 Mem_Tag_Err(p);
461 goto error;
462 }
463 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
464 p->mh_tag = ~MEMTAG;
465 memset(target, -1, p->mh_size);
466 xmlMutexLock(xmlMemMutex);
467 debugMemSize -= p->mh_size;
468 debugMemBlocks--;
469 #ifdef DEBUG_MEMORY
470 size = p->mh_size;
471 #endif
472 #ifdef MEM_LIST
473 debugmem_list_delete(p);
474 #endif
475 xmlMutexUnlock(xmlMemMutex);
476
477 free(p);
478
479 TEST_POINT
480
481 #ifdef DEBUG_MEMORY
482 xmlGenericError(xmlGenericErrorContext,
483 "Freed(%d) Ok\n", size);
484 #endif
485
486 return;
487
488 error:
489 xmlGenericError(xmlGenericErrorContext,
490 "xmlMemFree(%p) error\n", ptr);
491 xmlMallocBreakpoint();
492 return;
493 }
494
495 /**
496 * xmlMemStrdupLoc:
497 * @str: the initial string pointer
498 * @file: the file name or NULL
499 * @line: the line number
500 *
501 * a strdup() equivalent, with logging of the allocation info.
502 *
503 * Returns a pointer to the new string or NULL if allocation error occurred.
504 */
505
506 char *
xmlMemStrdupLoc(const char * str,const char * file,int line)507 xmlMemStrdupLoc(const char *str, const char *file, int line)
508 {
509 char *s;
510 size_t size = strlen(str) + 1;
511 MEMHDR *p;
512
513 if (!xmlMemInitialized) xmlInitMemory();
514 TEST_POINT
515
516 if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
517 xmlGenericError(xmlGenericErrorContext,
518 "xmlMemStrdupLoc : Unsigned overflow\n");
519 xmlMemoryDump();
520 return(NULL);
521 }
522
523 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
524 if (!p) {
525 goto error;
526 }
527 p->mh_tag = MEMTAG;
528 p->mh_size = size;
529 p->mh_type = STRDUP_TYPE;
530 p->mh_file = file;
531 p->mh_line = line;
532 xmlMutexLock(xmlMemMutex);
533 p->mh_number = ++block;
534 debugMemSize += size;
535 debugMemBlocks++;
536 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
537 #ifdef MEM_LIST
538 debugmem_list_add(p);
539 #endif
540 xmlMutexUnlock(xmlMemMutex);
541
542 s = (char *) HDR_2_CLIENT(p);
543
544 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
545
546 strcpy(s,str);
547
548 TEST_POINT
549
550 if (xmlMemTraceBlockAt == s) {
551 xmlGenericError(xmlGenericErrorContext,
552 "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
553 xmlMallocBreakpoint();
554 }
555
556 return(s);
557
558 error:
559 return(NULL);
560 }
561
562 /**
563 * xmlMemoryStrdup:
564 * @str: the initial string pointer
565 *
566 * a strdup() equivalent, with logging of the allocation info.
567 *
568 * Returns a pointer to the new string or NULL if allocation error occurred.
569 */
570
571 char *
xmlMemoryStrdup(const char * str)572 xmlMemoryStrdup(const char *str) {
573 return(xmlMemStrdupLoc(str, "none", 0));
574 }
575
576 /**
577 * xmlMemUsed:
578 *
579 * Provides the amount of memory currently allocated
580 *
581 * Returns an int representing the amount of memory allocated.
582 */
583
584 int
xmlMemUsed(void)585 xmlMemUsed(void) {
586 int res;
587
588 xmlMutexLock(xmlMemMutex);
589 res = debugMemSize;
590 xmlMutexUnlock(xmlMemMutex);
591 return(res);
592 }
593
594 /**
595 * xmlMemBlocks:
596 *
597 * Provides the number of memory areas currently allocated
598 *
599 * Returns an int representing the number of blocks
600 */
601
602 int
xmlMemBlocks(void)603 xmlMemBlocks(void) {
604 int res;
605
606 xmlMutexLock(xmlMemMutex);
607 res = debugMemBlocks;
608 xmlMutexUnlock(xmlMemMutex);
609 return(res);
610 }
611
612 #ifdef MEM_LIST
613 /**
614 * xmlMemContentShow:
615 * @fp: a FILE descriptor used as the output file
616 * @p: a memory block header
617 *
618 * tries to show some content from the memory block
619 */
620
621 static void
xmlMemContentShow(FILE * fp,MEMHDR * p)622 xmlMemContentShow(FILE *fp, MEMHDR *p)
623 {
624 int i,j,k,len;
625 const char *buf;
626
627 if (p == NULL) {
628 fprintf(fp, " NULL");
629 return;
630 }
631 len = p->mh_size;
632 buf = (const char *) HDR_2_CLIENT(p);
633
634 for (i = 0;i < len;i++) {
635 if (buf[i] == 0) break;
636 if (!isprint((unsigned char) buf[i])) break;
637 }
638 if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
639 if (len >= 4) {
640 MEMHDR *q;
641 void *cur;
642
643 for (j = 0;(j < len -3) && (j < 40);j += 4) {
644 cur = *((void **) &buf[j]);
645 q = CLIENT_2_HDR(cur);
646 p = memlist;
647 k = 0;
648 while (p != NULL) {
649 if (p == q) break;
650 p = p->mh_next;
651 if (k++ > 100) break;
652 }
653 if ((p != NULL) && (p == q)) {
654 fprintf(fp, " pointer to #%lu at index %d",
655 p->mh_number, j);
656 return;
657 }
658 }
659 }
660 } else if ((i == 0) && (buf[i] == 0)) {
661 fprintf(fp," null");
662 } else {
663 if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
664 else {
665 fprintf(fp," [");
666 for (j = 0;j < i;j++)
667 fprintf(fp,"%c", buf[j]);
668 fprintf(fp,"]");
669 }
670 }
671 }
672 #endif
673
674 /**
675 * xmlMemDisplayLast:
676 * @fp: a FILE descriptor used as the output file, if NULL, the result is
677 * written to the file .memorylist
678 * @nbBytes: the amount of memory to dump
679 *
680 * the last nbBytes of memory allocated and not freed, useful for dumping
681 * the memory left allocated between two places at runtime.
682 */
683
684 void
xmlMemDisplayLast(FILE * fp,long nbBytes)685 xmlMemDisplayLast(FILE *fp, long nbBytes)
686 {
687 #ifdef MEM_LIST
688 MEMHDR *p;
689 unsigned idx;
690 int nb = 0;
691 #endif
692 FILE *old_fp = fp;
693
694 if (nbBytes <= 0)
695 return;
696
697 if (fp == NULL) {
698 fp = fopen(".memorylist", "w");
699 if (fp == NULL)
700 return;
701 }
702
703 #ifdef MEM_LIST
704 fprintf(fp," Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
705 nbBytes, debugMemSize, debugMaxMemSize);
706 fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
707 idx = 0;
708 xmlMutexLock(xmlMemMutex);
709 p = memlist;
710 while ((p) && (nbBytes > 0)) {
711 fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
712 (unsigned long)p->mh_size);
713 switch (p->mh_type) {
714 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
715 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
716 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
717 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
718 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
719 default:
720 fprintf(fp,"Unknown memory block, may be corrupted");
721 xmlMutexUnlock(xmlMemMutex);
722 if (old_fp == NULL)
723 fclose(fp);
724 return;
725 }
726 if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
727 if (p->mh_tag != MEMTAG)
728 fprintf(fp," INVALID");
729 nb++;
730 if (nb < 100)
731 xmlMemContentShow(fp, p);
732 else
733 fprintf(fp," skip");
734
735 fprintf(fp,"\n");
736 nbBytes -= (unsigned long)p->mh_size;
737 p = p->mh_next;
738 }
739 xmlMutexUnlock(xmlMemMutex);
740 #else
741 fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
742 #endif
743 if (old_fp == NULL)
744 fclose(fp);
745 }
746
747 /**
748 * xmlMemDisplay:
749 * @fp: a FILE descriptor used as the output file, if NULL, the result is
750 * written to the file .memorylist
751 *
752 * show in-extenso the memory blocks allocated
753 */
754
755 void
xmlMemDisplay(FILE * fp)756 xmlMemDisplay(FILE *fp)
757 {
758 #ifdef MEM_LIST
759 MEMHDR *p;
760 unsigned idx;
761 int nb = 0;
762 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
763 time_t currentTime;
764 char buf[500];
765 struct tm * tstruct;
766 #endif
767 #endif
768 FILE *old_fp = fp;
769
770 if (fp == NULL) {
771 fp = fopen(".memorylist", "w");
772 if (fp == NULL)
773 return;
774 }
775
776 #ifdef MEM_LIST
777 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
778 currentTime = time(NULL);
779 tstruct = localtime(¤tTime);
780 strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
781 fprintf(fp," %s\n\n", buf);
782 #endif
783
784
785 fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
786 debugMemSize, debugMaxMemSize);
787 fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
788 idx = 0;
789 xmlMutexLock(xmlMemMutex);
790 p = memlist;
791 while (p) {
792 fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
793 (unsigned long)p->mh_size);
794 switch (p->mh_type) {
795 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
796 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
797 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
798 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
799 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
800 default:
801 fprintf(fp,"Unknown memory block, may be corrupted");
802 xmlMutexUnlock(xmlMemMutex);
803 if (old_fp == NULL)
804 fclose(fp);
805 return;
806 }
807 if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
808 if (p->mh_tag != MEMTAG)
809 fprintf(fp," INVALID");
810 nb++;
811 if (nb < 100)
812 xmlMemContentShow(fp, p);
813 else
814 fprintf(fp," skip");
815
816 fprintf(fp,"\n");
817 p = p->mh_next;
818 }
819 xmlMutexUnlock(xmlMemMutex);
820 #else
821 fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
822 #endif
823 if (old_fp == NULL)
824 fclose(fp);
825 }
826
827 #ifdef MEM_LIST
828
debugmem_list_add(MEMHDR * p)829 static void debugmem_list_add(MEMHDR *p)
830 {
831 p->mh_next = memlist;
832 p->mh_prev = NULL;
833 if (memlist) memlist->mh_prev = p;
834 memlist = p;
835 #ifdef MEM_LIST_DEBUG
836 if (stderr)
837 Mem_Display(stderr);
838 #endif
839 }
840
debugmem_list_delete(MEMHDR * p)841 static void debugmem_list_delete(MEMHDR *p)
842 {
843 if (p->mh_next)
844 p->mh_next->mh_prev = p->mh_prev;
845 if (p->mh_prev)
846 p->mh_prev->mh_next = p->mh_next;
847 else memlist = p->mh_next;
848 #ifdef MEM_LIST_DEBUG
849 if (stderr)
850 Mem_Display(stderr);
851 #endif
852 }
853
854 #endif
855
856 /*
857 * debugmem_tag_error:
858 *
859 * internal error function.
860 */
861
debugmem_tag_error(void * p)862 static void debugmem_tag_error(void *p)
863 {
864 xmlGenericError(xmlGenericErrorContext,
865 "Memory tag error occurs :%p \n\t bye\n", p);
866 #ifdef MEM_LIST
867 if (stderr)
868 xmlMemDisplay(stderr);
869 #endif
870 }
871
872 #ifdef MEM_LIST
873 static FILE *xmlMemoryDumpFile = NULL;
874 #endif
875
876 /**
877 * xmlMemShow:
878 * @fp: a FILE descriptor used as the output file
879 * @nr: number of entries to dump
880 *
881 * show a show display of the memory allocated, and dump
882 * the @nr last allocated areas which were not freed
883 */
884
885 void
xmlMemShow(FILE * fp,int nr ATTRIBUTE_UNUSED)886 xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
887 {
888 #ifdef MEM_LIST
889 MEMHDR *p;
890 #endif
891
892 if (fp != NULL)
893 fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
894 debugMemSize, debugMaxMemSize);
895 #ifdef MEM_LIST
896 xmlMutexLock(xmlMemMutex);
897 if (nr > 0) {
898 fprintf(fp,"NUMBER SIZE TYPE WHERE\n");
899 p = memlist;
900 while ((p) && nr > 0) {
901 fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
902 switch (p->mh_type) {
903 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
904 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
905 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
906 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
907 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
908 default:fprintf(fp," ??? in ");break;
909 }
910 if (p->mh_file != NULL)
911 fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
912 if (p->mh_tag != MEMTAG)
913 fprintf(fp," INVALID");
914 xmlMemContentShow(fp, p);
915 fprintf(fp,"\n");
916 nr--;
917 p = p->mh_next;
918 }
919 }
920 xmlMutexUnlock(xmlMemMutex);
921 #endif /* MEM_LIST */
922 }
923
924 /**
925 * xmlMemoryDump:
926 *
927 * Dump in-extenso the memory blocks allocated to the file .memorylist
928 */
929
930 void
xmlMemoryDump(void)931 xmlMemoryDump(void)
932 {
933 #ifdef MEM_LIST
934 FILE *dump;
935
936 if (debugMaxMemSize == 0)
937 return;
938 dump = fopen(".memdump", "w");
939 if (dump == NULL)
940 xmlMemoryDumpFile = stderr;
941 else xmlMemoryDumpFile = dump;
942
943 xmlMemDisplay(xmlMemoryDumpFile);
944
945 if (dump != NULL) fclose(dump);
946 #endif /* MEM_LIST */
947 }
948
949
950 /****************************************************************
951 * *
952 * Initialization Routines *
953 * *
954 ****************************************************************/
955
956 /**
957 * xmlInitMemory:
958 *
959 * Initialize the memory layer.
960 *
961 * Returns 0 on success
962 */
963 int
xmlInitMemory(void)964 xmlInitMemory(void)
965 {
966 #ifdef HAVE_STDLIB_H
967 char *breakpoint;
968 #endif
969 #ifdef DEBUG_MEMORY
970 xmlGenericError(xmlGenericErrorContext,
971 "xmlInitMemory()\n");
972 #endif
973 /*
974 This is really not good code (see Bug 130419). Suggestions for
975 improvement will be welcome!
976 */
977 if (xmlMemInitialized) return(-1);
978 xmlMemInitialized = 1;
979 xmlMemMutex = xmlNewMutex();
980
981 #ifdef HAVE_STDLIB_H
982 breakpoint = getenv("XML_MEM_BREAKPOINT");
983 if (breakpoint != NULL) {
984 sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
985 }
986 #endif
987 #ifdef HAVE_STDLIB_H
988 breakpoint = getenv("XML_MEM_TRACE");
989 if (breakpoint != NULL) {
990 sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
991 }
992 #endif
993
994 #ifdef DEBUG_MEMORY
995 xmlGenericError(xmlGenericErrorContext,
996 "xmlInitMemory() Ok\n");
997 #endif
998 return(0);
999 }
1000
1001 /**
1002 * xmlCleanupMemory:
1003 *
1004 * Free up all the memory allocated by the library for its own
1005 * use. This should not be called by user level code.
1006 */
1007 void
xmlCleanupMemory(void)1008 xmlCleanupMemory(void) {
1009 #ifdef DEBUG_MEMORY
1010 xmlGenericError(xmlGenericErrorContext,
1011 "xmlCleanupMemory()\n");
1012 #endif
1013 if (xmlMemInitialized == 0)
1014 return;
1015
1016 xmlFreeMutex(xmlMemMutex);
1017 xmlMemMutex = NULL;
1018 xmlMemInitialized = 0;
1019 #ifdef DEBUG_MEMORY
1020 xmlGenericError(xmlGenericErrorContext,
1021 "xmlCleanupMemory() Ok\n");
1022 #endif
1023 }
1024
1025 /**
1026 * xmlMemSetup:
1027 * @freeFunc: the free() function to use
1028 * @mallocFunc: the malloc() function to use
1029 * @reallocFunc: the realloc() function to use
1030 * @strdupFunc: the strdup() function to use
1031 *
1032 * Override the default memory access functions with a new set
1033 * This has to be called before any other libxml routines !
1034 *
1035 * Should this be blocked if there was already some allocations
1036 * done ?
1037 *
1038 * Returns 0 on success
1039 */
1040 int
xmlMemSetup(xmlFreeFunc freeFunc,xmlMallocFunc mallocFunc,xmlReallocFunc reallocFunc,xmlStrdupFunc strdupFunc)1041 xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1042 xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
1043 #ifdef DEBUG_MEMORY
1044 xmlGenericError(xmlGenericErrorContext,
1045 "xmlMemSetup()\n");
1046 #endif
1047 if (freeFunc == NULL)
1048 return(-1);
1049 if (mallocFunc == NULL)
1050 return(-1);
1051 if (reallocFunc == NULL)
1052 return(-1);
1053 if (strdupFunc == NULL)
1054 return(-1);
1055 xmlFree = freeFunc;
1056 xmlMalloc = mallocFunc;
1057 xmlMallocAtomic = mallocFunc;
1058 xmlRealloc = reallocFunc;
1059 xmlMemStrdup = strdupFunc;
1060 #ifdef DEBUG_MEMORY
1061 xmlGenericError(xmlGenericErrorContext,
1062 "xmlMemSetup() Ok\n");
1063 #endif
1064 return(0);
1065 }
1066
1067 /**
1068 * xmlMemGet:
1069 * @freeFunc: place to save the free() function in use
1070 * @mallocFunc: place to save the malloc() function in use
1071 * @reallocFunc: place to save the realloc() function in use
1072 * @strdupFunc: place to save the strdup() function in use
1073 *
1074 * Provides the memory access functions set currently in use
1075 *
1076 * Returns 0 on success
1077 */
1078 int
xmlMemGet(xmlFreeFunc * freeFunc,xmlMallocFunc * mallocFunc,xmlReallocFunc * reallocFunc,xmlStrdupFunc * strdupFunc)1079 xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1080 xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
1081 if (freeFunc != NULL) *freeFunc = xmlFree;
1082 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1083 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1084 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1085 return(0);
1086 }
1087
1088 /**
1089 * xmlGcMemSetup:
1090 * @freeFunc: the free() function to use
1091 * @mallocFunc: the malloc() function to use
1092 * @mallocAtomicFunc: the malloc() function to use for atomic allocations
1093 * @reallocFunc: the realloc() function to use
1094 * @strdupFunc: the strdup() function to use
1095 *
1096 * Override the default memory access functions with a new set
1097 * This has to be called before any other libxml routines !
1098 * The mallocAtomicFunc is specialized for atomic block
1099 * allocations (i.e. of areas useful for garbage collected memory allocators
1100 *
1101 * Should this be blocked if there was already some allocations
1102 * done ?
1103 *
1104 * Returns 0 on success
1105 */
1106 int
xmlGcMemSetup(xmlFreeFunc freeFunc,xmlMallocFunc mallocFunc,xmlMallocFunc mallocAtomicFunc,xmlReallocFunc reallocFunc,xmlStrdupFunc strdupFunc)1107 xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1108 xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1109 xmlStrdupFunc strdupFunc) {
1110 #ifdef DEBUG_MEMORY
1111 xmlGenericError(xmlGenericErrorContext,
1112 "xmlGcMemSetup()\n");
1113 #endif
1114 if (freeFunc == NULL)
1115 return(-1);
1116 if (mallocFunc == NULL)
1117 return(-1);
1118 if (mallocAtomicFunc == NULL)
1119 return(-1);
1120 if (reallocFunc == NULL)
1121 return(-1);
1122 if (strdupFunc == NULL)
1123 return(-1);
1124 xmlFree = freeFunc;
1125 xmlMalloc = mallocFunc;
1126 xmlMallocAtomic = mallocAtomicFunc;
1127 xmlRealloc = reallocFunc;
1128 xmlMemStrdup = strdupFunc;
1129 #ifdef DEBUG_MEMORY
1130 xmlGenericError(xmlGenericErrorContext,
1131 "xmlGcMemSetup() Ok\n");
1132 #endif
1133 return(0);
1134 }
1135
1136 /**
1137 * xmlGcMemGet:
1138 * @freeFunc: place to save the free() function in use
1139 * @mallocFunc: place to save the malloc() function in use
1140 * @mallocAtomicFunc: place to save the atomic malloc() function in use
1141 * @reallocFunc: place to save the realloc() function in use
1142 * @strdupFunc: place to save the strdup() function in use
1143 *
1144 * Provides the memory access functions set currently in use
1145 * The mallocAtomicFunc is specialized for atomic block
1146 * allocations (i.e. of areas useful for garbage collected memory allocators
1147 *
1148 * Returns 0 on success
1149 */
1150 int
xmlGcMemGet(xmlFreeFunc * freeFunc,xmlMallocFunc * mallocFunc,xmlMallocFunc * mallocAtomicFunc,xmlReallocFunc * reallocFunc,xmlStrdupFunc * strdupFunc)1151 xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1152 xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
1153 xmlStrdupFunc *strdupFunc) {
1154 if (freeFunc != NULL) *freeFunc = xmlFree;
1155 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1156 if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1157 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1158 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1159 return(0);
1160 }
1161
1162 #define bottom_xmlmemory
1163 #include "elfgcchack.h"
1164