xmlmemory.c@ 35499

Last change on this file since 35499 was 6076, checked in by vboxsync, 17 years ago
Merged dmik/s2 branch (r25959:26751) to the trunk.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 23.7 KB

Line
1	/*
2	* xmlmemory.c: libxml memory allocator wrapper.
3	*
4	* [email protected]
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(%d) 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 *
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(%d) 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 *
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 *
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(%d -> %d) 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 *
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
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 == (void *) -1) {
413	xmlGenericError(xmlGenericErrorContext,
414	"trying to free pointer from freed area\n");
415	goto error;
416	}
417
418	if (xmlMemTraceBlockAt == ptr) {
419	xmlGenericError(xmlGenericErrorContext,
420	"%p : Freed()\n", xmlMemTraceBlockAt);
421	xmlMallocBreakpoint();
422	}
423
424	TEST_POINT
425
426	target = (char *) ptr;
427
428	p = CLIENT_2_HDR(ptr);
429	if (p->mh_tag != MEMTAG) {
430	Mem_Tag_Err(p);
431	goto error;
432	}
433	if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
434	p->mh_tag = ~MEMTAG;
435	memset(target, -1, p->mh_size);
436	xmlMutexLock(xmlMemMutex);
437	debugMemSize -= p->mh_size;
438	debugMemBlocks--;
439	#ifdef DEBUG_MEMORY
440	size = p->mh_size;
441	#endif
442	#ifdef MEM_LIST
443	debugmem_list_delete(p);
444	#endif
445	xmlMutexUnlock(xmlMemMutex);
446
447	free(p);
448
449	TEST_POINT
450
451	#ifdef DEBUG_MEMORY
452	xmlGenericError(xmlGenericErrorContext,
453	"Freed(%d) Ok\n", size);
454	#endif
455
456	return;
457
458	error:
459	xmlGenericError(xmlGenericErrorContext,
460	"xmlMemFree(%lX) error\n", (unsigned long) ptr);
461	xmlMallocBreakpoint();
462	return;
463	}
464
465	/**
466	* xmlMemStrdupLoc:
467	* @str: the initial string pointer
468	* @file: the file name or NULL
469	* @line: the line number
470	*
471	* a strdup() equivalent, with logging of the allocation info.
472	*
473	* Returns a pointer to the new string or NULL if allocation error occurred.
474	*/
475
476	char *
477	xmlMemStrdupLoc(const char str, const char file, int line)
478	{
479	char *s;
480	size_t size = strlen(str) + 1;
481	MEMHDR *p;
482
483	if (!xmlMemInitialized) xmlInitMemory();
484	TEST_POINT
485
486	p = (MEMHDR *) malloc(RESERVE_SIZE+size);
487	if (!p) {
488	goto error;
489	}
490	p->mh_tag = MEMTAG;
491	p->mh_size = size;
492	p->mh_type = STRDUP_TYPE;
493	p->mh_file = file;
494	p->mh_line = line;
495	xmlMutexLock(xmlMemMutex);
496	p->mh_number = ++block;
497	debugMemSize += size;
498	debugMemBlocks++;
499	if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
500	#ifdef MEM_LIST
501	debugmem_list_add(p);
502	#endif
503	xmlMutexUnlock(xmlMemMutex);
504
505	s = (char *) HDR_2_CLIENT(p);
506
507	if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
508
509	if (s != NULL)
510	strcpy(s,str);
511	else
512	goto error;
513
514	TEST_POINT
515
516	if (xmlMemTraceBlockAt == s) {
517	xmlGenericError(xmlGenericErrorContext,
518	"%p : Strdup() Ok\n", xmlMemTraceBlockAt);
519	xmlMallocBreakpoint();
520	}
521
522	return(s);
523
524	error:
525	return(NULL);
526	}
527
528	/**
529	* xmlMemoryStrdup:
530	* @str: the initial string pointer
531	*
532	* a strdup() equivalent, with logging of the allocation info.
533	*
534	* Returns a pointer to the new string or NULL if allocation error occurred.
535	*/
536
537	char *
538	xmlMemoryStrdup(const char *str) {
539	return(xmlMemStrdupLoc(str, "none", 0));
540	}
541
542	/**
543	* xmlMemUsed:
544	*
545	* Provides the amount of memory currently allocated
546	*
547	* Returns an int representing the amount of memory allocated.
548	*/
549
550	int
551	xmlMemUsed(void) {
552	return(debugMemSize);
553	}
554
555	/**
556	* xmlMemBlocks:
557	*
558	* Provides the number of memory areas currently allocated
559	*
560	* Returns an int representing the number of blocks
561	*/
562
563	int
564	xmlMemBlocks(void) {
565	return(debugMemBlocks);
566	}
567
568	#ifdef MEM_LIST
569	/**
570	* xmlMemContentShow:
571	* @fp: a FILE descriptor used as the output file
572	* @p: a memory block header
573	*
574	* tries to show some content from the memory block
575	*/
576
577	static void
578	xmlMemContentShow(FILE fp, MEMHDR p)
579	{
580	int i,j,k,len = p->mh_size;
581	const char buf = (const char ) HDR_2_CLIENT(p);
582
583	if (p == NULL) {
584	fprintf(fp, " NULL");
585	return;
586	}
587
588	for (i = 0;i < len;i++) {
589	if (buf[i] == 0) break;
590	if (!isprint((unsigned char) buf[i])) break;
591	}
592	if ((i < 4) && ((buf[i] != 0) \|\| (i == 0))) {
593	if (len >= 4) {
594	MEMHDR *q;
595	void *cur;
596
597	for (j = 0;(j < len -3) && (j < 40);j += 4) {
598	cur = ((void *) &buf[j]);
599	q = CLIENT_2_HDR(cur);
600	p = memlist;
601	k = 0;
602	while (p != NULL) {
603	if (p == q) break;
604	p = p->mh_next;
605	if (k++ > 100) break;
606	}
607	if ((p != NULL) && (p == q)) {
608	fprintf(fp, " pointer to #%lu at index %d",
609	p->mh_number, j);
610	return;
611	}
612	}
613	}
614	} else if ((i == 0) && (buf[i] == 0)) {
615	fprintf(fp," null");
616	} else {
617	if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
618	else {
619	fprintf(fp," [");
620	for (j = 0;j < i;j++)
621	fprintf(fp,"%c", buf[j]);
622	fprintf(fp,"]");
623	}
624	}
625	}
626	#endif
627
628	/**
629	* xmlMemDisplay:
630	* @fp: a FILE descriptor used as the output file, if NULL, the result is
631	* written to the file .memorylist
632	*
633	* show in-extenso the memory blocks allocated
634	*/
635
636	void
637	xmlMemDisplay(FILE *fp)
638	{
639	#ifdef MEM_LIST
640	MEMHDR *p;
641	unsigned idx;
642	int nb = 0;
643	#if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
644	time_t currentTime;
645	char buf[500];
646	struct tm * tstruct;
647	#endif
648	#endif
649	FILE *old_fp = fp;
650
651	if (fp == NULL) {
652	fp = fopen(".memorylist", "w");
653	if (fp == NULL)
654	return;
655	}
656
657	#ifdef MEM_LIST
658	#if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
659	currentTime = time(NULL);
660	tstruct = localtime(&currentTime);
661	strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
662	fprintf(fp," %s\n\n", buf);
663	#endif
664
665
666	fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
667	debugMemSize, debugMaxMemSize);
668	fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
669	idx = 0;
670	xmlMutexLock(xmlMemMutex);
671	p = memlist;
672	while (p) {
673	fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
674	(unsigned long)p->mh_size);
675	switch (p->mh_type) {
676	case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
677	case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
678	case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
679	case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
680	case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
681	default:
682	fprintf(fp,"Unknown memory block, may be corrupted");
683	xmlMutexUnlock(xmlMemMutex);
684	if (old_fp == NULL)
685	fclose(fp);
686	return;
687	}
688	if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
689	if (p->mh_tag != MEMTAG)
690	fprintf(fp," INVALID");
691	nb++;
692	if (nb < 100)
693	xmlMemContentShow(fp, p);
694	else
695	fprintf(fp," skip");
696
697	fprintf(fp,"\n");
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	#ifdef MEM_LIST
709
710	static void debugmem_list_add(MEMHDR *p)
711	{
712	p->mh_next = memlist;
713	p->mh_prev = NULL;
714	if (memlist) memlist->mh_prev = p;
715	memlist = p;
716	#ifdef MEM_LIST_DEBUG
717	if (stderr)
718	Mem_Display(stderr);
719	#endif
720	}
721
722	static void debugmem_list_delete(MEMHDR *p)
723	{
724	if (p->mh_next)
725	p->mh_next->mh_prev = p->mh_prev;
726	if (p->mh_prev)
727	p->mh_prev->mh_next = p->mh_next;
728	else memlist = p->mh_next;
729	#ifdef MEM_LIST_DEBUG
730	if (stderr)
731	Mem_Display(stderr);
732	#endif
733	}
734
735	#endif
736
737	/*
738	* debugmem_tag_error:
739	*
740	* internal error function.
741	*/
742
743	static void debugmem_tag_error(void *p)
744	{
745	xmlGenericError(xmlGenericErrorContext,
746	"Memory tag error occurs :%p \n\t bye\n", p);
747	#ifdef MEM_LIST
748	if (stderr)
749	xmlMemDisplay(stderr);
750	#endif
751	}
752
753	#ifdef MEM_LIST
754	static FILE *xmlMemoryDumpFile = NULL;
755	#endif
756
757	/**
758	* xmlMemShow:
759	* @fp: a FILE descriptor used as the output file
760	* @nr: number of entries to dump
761	*
762	* show a show display of the memory allocated, and dump
763	* the @nr last allocated areas which were not freed
764	*/
765
766	void
767	xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
768	{
769	#ifdef MEM_LIST
770	MEMHDR *p;
771	#endif
772
773	if (fp != NULL)
774	fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
775	debugMemSize, debugMaxMemSize);
776	#ifdef MEM_LIST
777	xmlMutexLock(xmlMemMutex);
778	if (nr > 0) {
779	fprintf(fp,"NUMBER SIZE TYPE WHERE\n");
780	p = memlist;
781	while ((p) && nr > 0) {
782	fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
783	switch (p->mh_type) {
784	case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
785	case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
786	case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
787	case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
788	case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
789	default:fprintf(fp," ??? in ");break;
790	}
791	if (p->mh_file != NULL)
792	fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
793	if (p->mh_tag != MEMTAG)
794	fprintf(fp," INVALID");
795	xmlMemContentShow(fp, p);
796	fprintf(fp,"\n");
797	nr--;
798	p = p->mh_next;
799	}
800	}
801	xmlMutexUnlock(xmlMemMutex);
802	#endif /* MEM_LIST */
803	}
804
805	/**
806	* xmlMemoryDump:
807	*
808	* Dump in-extenso the memory blocks allocated to the file .memorylist
809	*/
810
811	void
812	xmlMemoryDump(void)
813	{
814	#ifdef MEM_LIST
815	FILE *dump;
816
817	if (debugMaxMemSize == 0)
818	return;
819	dump = fopen(".memdump", "w");
820	if (dump == NULL)
821	xmlMemoryDumpFile = stderr;
822	else xmlMemoryDumpFile = dump;
823
824	xmlMemDisplay(xmlMemoryDumpFile);
825
826	if (dump != NULL) fclose(dump);
827	#endif /* MEM_LIST */
828	}
829
830
831	/****************************************************************
832	* *
833	* Initialization Routines *
834	* *
835	****************************************************************/
836
837	/**
838	* xmlInitMemory:
839	*
840	* Initialize the memory layer.
841	*
842	* Returns 0 on success
843	*/
844	int
845	xmlInitMemory(void)
846	{
847	#ifdef HAVE_STDLIB_H
848	char *breakpoint;
849	#endif
850	#ifdef DEBUG_MEMORY
851	xmlGenericError(xmlGenericErrorContext,
852	"xmlInitMemory()\n");
853	#endif
854	/*
855	This is really not good code (see Bug 130419). Suggestions for
856	improvement will be welcome!
857	*/
858	if (xmlMemInitialized) return(-1);
859	xmlMemInitialized = 1;
860	xmlMemMutex = xmlNewMutex();
861
862	#ifdef HAVE_STDLIB_H
863	breakpoint = getenv("XML_MEM_BREAKPOINT");
864	if (breakpoint != NULL) {
865	sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
866	}
867	#endif
868	#ifdef HAVE_STDLIB_H
869	breakpoint = getenv("XML_MEM_TRACE");
870	if (breakpoint != NULL) {
871	sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
872	}
873	#endif
874
875	#ifdef DEBUG_MEMORY
876	xmlGenericError(xmlGenericErrorContext,
877	"xmlInitMemory() Ok\n");
878	#endif
879	return(0);
880	}
881
882	/**
883	* xmlCleanupMemory:
884	*
885	* Free up all the memory allocated by the library for its own
886	* use. This should not be called by user level code.
887	*/
888	void
889	xmlCleanupMemory(void) {
890	#ifdef DEBUG_MEMORY
891	xmlGenericError(xmlGenericErrorContext,
892	"xmlCleanupMemory()\n");
893	#endif
894	if (xmlMemInitialized == 0)
895	return;
896
897	xmlFreeMutex(xmlMemMutex);
898	xmlMemMutex = NULL;
899	xmlMemInitialized = 0;
900	#ifdef DEBUG_MEMORY
901	xmlGenericError(xmlGenericErrorContext,
902	"xmlCleanupMemory() Ok\n");
903	#endif
904	}
905
906	/**
907	* xmlMemSetup:
908	* @freeFunc: the free() function to use
909	* @mallocFunc: the malloc() function to use
910	* @reallocFunc: the realloc() function to use
911	* @strdupFunc: the strdup() function to use
912	*
913	* Override the default memory access functions with a new set
914	* This has to be called before any other libxml routines !
915	*
916	* Should this be blocked if there was already some allocations
917	* done ?
918	*
919	* Returns 0 on success
920	*/
921	int
922	xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
923	xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
924	#ifdef DEBUG_MEMORY
925	xmlGenericError(xmlGenericErrorContext,
926	"xmlMemSetup()\n");
927	#endif
928	if (freeFunc == NULL)
929	return(-1);
930	if (mallocFunc == NULL)
931	return(-1);
932	if (reallocFunc == NULL)
933	return(-1);
934	if (strdupFunc == NULL)
935	return(-1);
936	xmlFree = freeFunc;
937	xmlMalloc = mallocFunc;
938	xmlMallocAtomic = mallocFunc;
939	xmlRealloc = reallocFunc;
940	xmlMemStrdup = strdupFunc;
941	#ifdef DEBUG_MEMORY
942	xmlGenericError(xmlGenericErrorContext,
943	"xmlMemSetup() Ok\n");
944	#endif
945	return(0);
946	}
947
948	/**
949	* xmlMemGet:
950	* @freeFunc: place to save the free() function in use
951	* @mallocFunc: place to save the malloc() function in use
952	* @reallocFunc: place to save the realloc() function in use
953	* @strdupFunc: place to save the strdup() function in use
954	*
955	* Provides the memory access functions set currently in use
956	*
957	* Returns 0 on success
958	*/
959	int
960	xmlMemGet(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
961	xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
962	if (freeFunc != NULL) *freeFunc = xmlFree;
963	if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
964	if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
965	if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
966	return(0);
967	}
968
969	/**
970	* xmlGcMemSetup:
971	* @freeFunc: the free() function to use
972	* @mallocFunc: the malloc() function to use
973	* @mallocAtomicFunc: the malloc() function to use for atomic allocations
974	* @reallocFunc: the realloc() function to use
975	* @strdupFunc: the strdup() function to use
976	*
977	* Override the default memory access functions with a new set
978	* This has to be called before any other libxml routines !
979	* The mallocAtomicFunc is specialized for atomic block
980	* allocations (i.e. of areas useful for garbage collected memory allocators
981	*
982	* Should this be blocked if there was already some allocations
983	* done ?
984	*
985	* Returns 0 on success
986	*/
987	int
988	xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
989	xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
990	xmlStrdupFunc strdupFunc) {
991	#ifdef DEBUG_MEMORY
992	xmlGenericError(xmlGenericErrorContext,
993	"xmlGcMemSetup()\n");
994	#endif
995	if (freeFunc == NULL)
996	return(-1);
997	if (mallocFunc == NULL)
998	return(-1);
999	if (mallocAtomicFunc == NULL)
1000	return(-1);
1001	if (reallocFunc == NULL)
1002	return(-1);
1003	if (strdupFunc == NULL)
1004	return(-1);
1005	xmlFree = freeFunc;
1006	xmlMalloc = mallocFunc;
1007	xmlMallocAtomic = mallocAtomicFunc;
1008	xmlRealloc = reallocFunc;
1009	xmlMemStrdup = strdupFunc;
1010	#ifdef DEBUG_MEMORY
1011	xmlGenericError(xmlGenericErrorContext,
1012	"xmlGcMemSetup() Ok\n");
1013	#endif
1014	return(0);
1015	}
1016
1017	/**
1018	* xmlGcMemGet:
1019	* @freeFunc: place to save the free() function in use
1020	* @mallocFunc: place to save the malloc() function in use
1021	* @mallocAtomicFunc: place to save the atomic malloc() function in use
1022	* @reallocFunc: place to save the realloc() function in use
1023	* @strdupFunc: place to save the strdup() function in use
1024	*
1025	* Provides the memory access functions set currently in use
1026	* The mallocAtomicFunc is specialized for atomic block
1027	* allocations (i.e. of areas useful for garbage collected memory allocators
1028	*
1029	* Returns 0 on success
1030	*/
1031	int
1032	xmlGcMemGet(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1033	xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1034	xmlStrdupFunc *strdupFunc) {
1035	if (freeFunc != NULL) *freeFunc = xmlFree;
1036	if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1037	if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1038	if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1039	if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1040	return(0);
1041	}
1042
1043	#define bottom_xmlmemory
1044	#include "elfgcchack.h"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.30/xmlmemory.c@ 35499

Download in other formats: