xmlmemory.c@ 58072

Last change on this file since 58072 was 58072, checked in by vboxsync, 9 years ago
libxml 2.9.2 unmodified
Property svn:eol-style set to `native`
File size: 25.6 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(%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"

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

source: vbox/trunk/src/libs/libxml2-2.9.2/xmlmemory.c@ 58072

Download in other formats: