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
51static int xmlMemInitialized = 0;
52static unsigned long debugMemSize = 0;
53static unsigned long debugMemBlocks = 0;
54static unsigned long debugMaxMemSize = 0;
55static xmlMutexPtr xmlMemMutex = NULL;
56
57void 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
89typedef 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
118static unsigned int block=0;
119static unsigned int xmlMemStopAtBlock = 0;
120static void *xmlMemTraceBlockAt = NULL;
121#ifdef MEM_LIST
122static MEMHDR *memlist = NULL;
123#endif
124
125static void debugmem_tag_error(void *addr);
126#ifdef MEM_LIST
127static void debugmem_list_add(MEMHDR *);
128static 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
144void
145xmlMallocBreakpoint(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
161void *
162xmlMallocLoc(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
237void *
238xmlMallocAtomicLoc(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
310void *
311xmlMemMalloc(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
328void *
329xmlReallocLoc(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
405error:
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
419void *
420xmlMemRealloc(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 */
430void
431xmlMemFree(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
488error:
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
506char *
507xmlMemStrdupLoc(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
558error:
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
571char *
572xmlMemoryStrdup(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
584int
585xmlMemUsed(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
602int
603xmlMemBlocks(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
621static void
622xmlMemContentShow(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
684void
685xmlMemDisplayLast(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
755void
756xmlMemDisplay(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(&currentTime);
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
829static 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
841static 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
862static 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
873static 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
885void
886xmlMemShow(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
930void
931xmlMemoryDump(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 */
963int
964xmlInitMemory(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 */
1007void
1008xmlCleanupMemory(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 */
1040int
1041xmlMemSetup(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 */
1078int
1079xmlMemGet(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 */
1106int
1107xmlGcMemSetup(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 */
1150int
1151xmlGcMemGet(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