VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.14/xmlmemory.c@ 102654

Last change on this file since 102654 was 96464, checked in by vboxsync, 2 years ago

libs/libxml2-2.9.14: Made it build in no-CRT mode. bugref:10261
  • Property svn:eol-style set to native
File size: 26.5 KB
Line 
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 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
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#ifdef VBOX
968 const char *breakpoint;
969#else
970 char *breakpoint;
971#endif
972#endif
973#ifdef DEBUG_MEMORY
974 xmlGenericError(xmlGenericErrorContext,
975 "xmlInitMemory()\n");
976#endif
977 /*
978 This is really not good code (see Bug 130419). Suggestions for
979 improvement will be welcome!
980 */
981 if (xmlMemInitialized) return(-1);
982 xmlMemInitialized = 1;
983 xmlMemMutex = xmlNewMutex();
984
985#ifdef HAVE_STDLIB_H
986 breakpoint = getenv("XML_MEM_BREAKPOINT");
987 if (breakpoint != NULL) {
988 sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
989 }
990#endif
991#ifdef HAVE_STDLIB_H
992 breakpoint = getenv("XML_MEM_TRACE");
993 if (breakpoint != NULL) {
994 sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
995 }
996#endif
997
998#ifdef DEBUG_MEMORY
999 xmlGenericError(xmlGenericErrorContext,
1000 "xmlInitMemory() Ok\n");
1001#endif
1002 return(0);
1003}
1004
1005/**
1006 * xmlCleanupMemory:
1007 *
1008 * Free up all the memory allocated by the library for its own
1009 * use. This should not be called by user level code.
1010 */
1011void
1012xmlCleanupMemory(void) {
1013#ifdef DEBUG_MEMORY
1014 xmlGenericError(xmlGenericErrorContext,
1015 "xmlCleanupMemory()\n");
1016#endif
1017 if (xmlMemInitialized == 0)
1018 return;
1019
1020 xmlFreeMutex(xmlMemMutex);
1021 xmlMemMutex = NULL;
1022 xmlMemInitialized = 0;
1023#ifdef DEBUG_MEMORY
1024 xmlGenericError(xmlGenericErrorContext,
1025 "xmlCleanupMemory() Ok\n");
1026#endif
1027}
1028
1029/**
1030 * xmlMemSetup:
1031 * @freeFunc: the free() function to use
1032 * @mallocFunc: the malloc() function to use
1033 * @reallocFunc: the realloc() function to use
1034 * @strdupFunc: the strdup() function to use
1035 *
1036 * Override the default memory access functions with a new set
1037 * This has to be called before any other libxml routines !
1038 *
1039 * Should this be blocked if there was already some allocations
1040 * done ?
1041 *
1042 * Returns 0 on success
1043 */
1044int
1045xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1046 xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
1047#ifdef DEBUG_MEMORY
1048 xmlGenericError(xmlGenericErrorContext,
1049 "xmlMemSetup()\n");
1050#endif
1051 if (freeFunc == NULL)
1052 return(-1);
1053 if (mallocFunc == NULL)
1054 return(-1);
1055 if (reallocFunc == NULL)
1056 return(-1);
1057 if (strdupFunc == NULL)
1058 return(-1);
1059 xmlFree = freeFunc;
1060 xmlMalloc = mallocFunc;
1061 xmlMallocAtomic = mallocFunc;
1062 xmlRealloc = reallocFunc;
1063 xmlMemStrdup = strdupFunc;
1064#ifdef DEBUG_MEMORY
1065 xmlGenericError(xmlGenericErrorContext,
1066 "xmlMemSetup() Ok\n");
1067#endif
1068 return(0);
1069}
1070
1071/**
1072 * xmlMemGet:
1073 * @freeFunc: place to save the free() function in use
1074 * @mallocFunc: place to save the malloc() function in use
1075 * @reallocFunc: place to save the realloc() function in use
1076 * @strdupFunc: place to save the strdup() function in use
1077 *
1078 * Provides the memory access functions set currently in use
1079 *
1080 * Returns 0 on success
1081 */
1082int
1083xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1084 xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
1085 if (freeFunc != NULL) *freeFunc = xmlFree;
1086 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1087 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1088 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1089 return(0);
1090}
1091
1092/**
1093 * xmlGcMemSetup:
1094 * @freeFunc: the free() function to use
1095 * @mallocFunc: the malloc() function to use
1096 * @mallocAtomicFunc: the malloc() function to use for atomic allocations
1097 * @reallocFunc: the realloc() function to use
1098 * @strdupFunc: the strdup() function to use
1099 *
1100 * Override the default memory access functions with a new set
1101 * This has to be called before any other libxml routines !
1102 * The mallocAtomicFunc is specialized for atomic block
1103 * allocations (i.e. of areas useful for garbage collected memory allocators
1104 *
1105 * Should this be blocked if there was already some allocations
1106 * done ?
1107 *
1108 * Returns 0 on success
1109 */
1110int
1111xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1112 xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1113 xmlStrdupFunc strdupFunc) {
1114#ifdef DEBUG_MEMORY
1115 xmlGenericError(xmlGenericErrorContext,
1116 "xmlGcMemSetup()\n");
1117#endif
1118 if (freeFunc == NULL)
1119 return(-1);
1120 if (mallocFunc == NULL)
1121 return(-1);
1122 if (mallocAtomicFunc == NULL)
1123 return(-1);
1124 if (reallocFunc == NULL)
1125 return(-1);
1126 if (strdupFunc == NULL)
1127 return(-1);
1128 xmlFree = freeFunc;
1129 xmlMalloc = mallocFunc;
1130 xmlMallocAtomic = mallocAtomicFunc;
1131 xmlRealloc = reallocFunc;
1132 xmlMemStrdup = strdupFunc;
1133#ifdef DEBUG_MEMORY
1134 xmlGenericError(xmlGenericErrorContext,
1135 "xmlGcMemSetup() Ok\n");
1136#endif
1137 return(0);
1138}
1139
1140/**
1141 * xmlGcMemGet:
1142 * @freeFunc: place to save the free() function in use
1143 * @mallocFunc: place to save the malloc() function in use
1144 * @mallocAtomicFunc: place to save the atomic malloc() function in use
1145 * @reallocFunc: place to save the realloc() function in use
1146 * @strdupFunc: place to save the strdup() function in use
1147 *
1148 * Provides the memory access functions set currently in use
1149 * The mallocAtomicFunc is specialized for atomic block
1150 * allocations (i.e. of areas useful for garbage collected memory allocators
1151 *
1152 * Returns 0 on success
1153 */
1154int
1155xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1156 xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
1157 xmlStrdupFunc *strdupFunc) {
1158 if (freeFunc != NULL) *freeFunc = xmlFree;
1159 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1160 if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1161 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1162 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1163 return(0);
1164}
1165
1166#define bottom_xmlmemory
1167#include "elfgcchack.h"
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette