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