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