xmlmemory.c@ 53372

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

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

source: vbox/trunk/src/libs/libxml2-2.6.31/xmlmemory.c@ 53372

Download in other formats: