xmlmemory.c File Reference

#include "libxml.h"
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <stdlib.h>
#include <ctype.h>
#include <libxml/globals.h>
#include <libxml/xmlmemory.h>
#include <libxml/xmlerror.h>
#include <libxml/threads.h>
#include "elfgcchack.h"

Include dependency graph for xmlmemory.c:

Go to the source code of this file.

Classes
struct	memnod

Macros
#define	IN_LIBXML
#define	MEMTAG   0x5aa5
#define	MALLOC_TYPE   1
#define	REALLOC_TYPE   2
#define	STRDUP_TYPE   3
#define	MALLOC_ATOMIC_TYPE   4
#define	REALLOC_ATOMIC_TYPE   5
#define	ALIGN_SIZE   sizeof(double)
#define	HDR_SIZE   sizeof(MEMHDR)
#define	RESERVE_SIZE
#define	MAX_SIZE_T   ((size_t)-1)
#define	CLIENT_2_HDR(a)   ((void *) (((char *) (a)) - RESERVE_SIZE))
#define	HDR_2_CLIENT(a)   ((void *) (((char *) (a)) + RESERVE_SIZE))
#define	Mem_Tag_Err(a)   debugmem_tag_error(a);
#define	TEST_POINT
#define	bottom_xmlmemory

Typedefs
typedef struct memnod	MEMHDR

Functions
void	xmlMallocBreakpoint (void)
static void	debugmem_tag_error (void *addr)
void *	xmlMallocLoc (size_t size, const char *file, int line)
void *	xmlMallocAtomicLoc (size_t size, const char *file, int line)
void *	xmlMemMalloc (size_t size)
void *	xmlReallocLoc (void *ptr, size_t size, const char *file, int line)
void *	xmlMemRealloc (void *ptr, size_t size)
void	xmlMemFree (void *ptr)
char *	xmlMemStrdupLoc (const char *str, const char *file, int line)
char *	xmlMemoryStrdup (const char *str)
int	xmlMemUsed (void)
int	xmlMemBlocks (void)
void	xmlMemDisplayLast (FILE *fp, long nbBytes)
void	xmlMemDisplay (FILE *fp)
void	xmlMemShow (FILE *fp, int nr ATTRIBUTE_UNUSED)
void	xmlMemoryDump (void)
int	xmlInitMemory (void)
void	xmlCleanupMemory (void)
int	xmlMemSetup (xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
int	xmlMemGet (xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)
int	xmlGcMemSetup (xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
int	xmlGcMemGet (xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)

Variables
static int	xmlMemInitialized = 0
static unsigned long	debugMemSize = 0
static unsigned long	debugMemBlocks = 0
static unsigned long	debugMaxMemSize = 0
static xmlMutexPtr	xmlMemMutex = NULL
static unsigned int	block =0
static unsigned int	xmlMemStopAtBlock = 0
static void *	xmlMemTraceBlockAt = NULL

Macro Definition Documentation

ALIGN_SIZE

#define ALIGN_SIZE   sizeof(double)

Definition at line 106 of file xmlmemory.c.

bottom_xmlmemory

#define bottom_xmlmemory

Definition at line 1162 of file xmlmemory.c.

CLIENT_2_HDR

#define CLIENT_2_HDR

(

a

)

((void *) (((char *) (a)) - RESERVE_SIZE))

Definition at line 114 of file xmlmemory.c.

HDR_2_CLIENT

#define HDR_2_CLIENT

(

a

)

((void *) (((char *) (a)) + RESERVE_SIZE))

Definition at line 115 of file xmlmemory.c.

HDR_SIZE

#define HDR_SIZE   sizeof(MEMHDR)

Definition at line 108 of file xmlmemory.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 7 of file xmlmemory.c.

MALLOC_ATOMIC_TYPE

#define MALLOC_ATOMIC_TYPE   4

Definition at line 86 of file xmlmemory.c.

MALLOC_TYPE

#define MALLOC_TYPE   1

Definition at line 83 of file xmlmemory.c.

MAX_SIZE_T

#define MAX_SIZE_T   ((size_t)-1)

Definition at line 112 of file xmlmemory.c.

Mem_Tag_Err

#define Mem_Tag_Err

(

a

)

debugmem_tag_error(a);

Definition at line 130 of file xmlmemory.c.

MEMTAG

#define MEMTAG   0x5aa5

Definition at line 81 of file xmlmemory.c.

REALLOC_ATOMIC_TYPE

#define REALLOC_ATOMIC_TYPE   5

Definition at line 87 of file xmlmemory.c.

REALLOC_TYPE

#define REALLOC_TYPE   2

Definition at line 84 of file xmlmemory.c.

RESERVE_SIZE

#define RESERVE_SIZE

Value:

(((HDR_SIZE + (ALIGN_SIZE-1)) \
              / ALIGN_SIZE ) * ALIGN_SIZE)

Definition at line 109 of file xmlmemory.c.

STRDUP_TYPE

#define STRDUP_TYPE   3

Definition at line 85 of file xmlmemory.c.

TEST_POINT

#define TEST_POINT

Definition at line 133 of file xmlmemory.c.

Typedef Documentation

MEMHDR

typedef struct memnod MEMHDR

Function Documentation

debugmem_tag_error()

static void debugmem_tag_error ( void *  addr )

static

Definition at line 862 of file xmlmemory.c.

{
     xmlGenericError(xmlGenericErrorContext,
         "Memory tag error occurs :%p \n\t bye\n", p);
#ifdef MEM_LIST
     if (stderr)
     xmlMemDisplay(stderr);
#endif
}

xmlCleanupMemory()

void xmlCleanupMemory

(

void

)

xmlCleanupMemory:

Free up all the memory allocated by the library for its own use. This should not be called by user level code.

Definition at line 1008 of file xmlmemory.c.

                       {
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlCleanupMemory()\n");
#endif
    if (xmlMemInitialized == 0)
        return;

    xmlFreeMutex(xmlMemMutex);
    xmlMemMutex = NULL;
    xmlMemInitialized = 0;
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlCleanupMemory() Ok\n");
#endif
}

Referenced by xmlCleanupParser().

xmlGcMemGet()

int xmlGcMemGet	(	xmlFreeFunc *	freeFunc,
		xmlMallocFunc *	mallocFunc,
		xmlMallocFunc *	mallocAtomicFunc,
		xmlReallocFunc *	reallocFunc,
		xmlStrdupFunc *	strdupFunc
	)

xmlGcMemGet: @freeFunc: place to save the free() function in use @mallocFunc: place to save the malloc() function in use @mallocAtomicFunc: place to save the atomic malloc() function in use @reallocFunc: place to save the realloc() function in use @strdupFunc: place to save the strdup() function in use

Provides the memory access functions set currently in use The mallocAtomicFunc is specialized for atomic block allocations (i.e. of areas useful for garbage collected memory allocators

Returns 0 on success

Definition at line 1151 of file xmlmemory.c.

                                   {
    if (freeFunc != NULL) *freeFunc = xmlFree;
    if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
    if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
    if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
    if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
    return(0);
}

xmlGcMemSetup()

int xmlGcMemSetup	(	xmlFreeFunc	freeFunc,
		xmlMallocFunc	mallocFunc,
		xmlMallocFunc	mallocAtomicFunc,
		xmlReallocFunc	reallocFunc,
		xmlStrdupFunc	strdupFunc
	)

xmlGcMemSetup: @freeFunc: the free() function to use @mallocFunc: the malloc() function to use @mallocAtomicFunc: the malloc() function to use for atomic allocations @reallocFunc: the realloc() function to use @strdupFunc: the strdup() function to use

Override the default memory access functions with a new set This has to be called before any other libxml routines ! The mallocAtomicFunc is specialized for atomic block allocations (i.e. of areas useful for garbage collected memory allocators

Should this be blocked if there was already some allocations done ?

Returns 0 on success

Definition at line 1107 of file xmlmemory.c.

                                    {
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlGcMemSetup()\n");
#endif
    if (freeFunc == NULL)
    return(-1);
    if (mallocFunc == NULL)
    return(-1);
    if (mallocAtomicFunc == NULL)
    return(-1);
    if (reallocFunc == NULL)
    return(-1);
    if (strdupFunc == NULL)
    return(-1);
    xmlFree = freeFunc;
    xmlMalloc = mallocFunc;
    xmlMallocAtomic = mallocAtomicFunc;
    xmlRealloc = reallocFunc;
    xmlMemStrdup = strdupFunc;
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlGcMemSetup() Ok\n");
#endif
    return(0);
}

xmlInitMemory()

int xmlInitMemory

(

void

)

xmlInitMemory:

Initialize the memory layer.

Returns 0 on success

Definition at line 964 of file xmlmemory.c.

{
#ifdef HAVE_STDLIB_H
     char *breakpoint;
#endif
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlInitMemory()\n");
#endif
    /*
     This is really not good code (see Bug 130419).  Suggestions for
     improvement will be welcome!
    */
     if (xmlMemInitialized) return(-1);
     xmlMemInitialized = 1;
     xmlMemMutex = xmlNewMutex();

#ifdef HAVE_STDLIB_H
     breakpoint = getenv("XML_MEM_BREAKPOINT");
     if (breakpoint != NULL) {
         sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
     }
#endif
#ifdef HAVE_STDLIB_H
     breakpoint = getenv("XML_MEM_TRACE");
     if (breakpoint != NULL) {
         sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
     }
#endif

#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlInitMemory() Ok\n");
#endif
     return(0);
}

Referenced by xmlInitParser(), xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemStrdupLoc(), and xmlReallocLoc().

xmlMallocAtomicLoc()

void* xmlMallocAtomicLoc	(	size_t	size,
		const char *	file,
		int	line
	)

Definition at line 238 of file xmlmemory.c.

{
    MEMHDR *p;
    void *ret;

    if (!xmlMemInitialized) xmlInitMemory();
#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Malloc(%d)\n",size);
#endif

    TEST_POINT

    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocAtomicLoc : Unsigned overflow\n");
    xmlMemoryDump();
    return(NULL);
    }

    p = (MEMHDR *) malloc(RESERVE_SIZE+size);

    if (!p) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocAtomicLoc : Out of free space\n");
    xmlMemoryDump();
    return(NULL);
    }
    p->mh_tag = MEMTAG;
    p->mh_size = size;
    p->mh_type = MALLOC_ATOMIC_TYPE;
    p->mh_file = file;
    p->mh_line = line;
    xmlMutexLock(xmlMemMutex);
    p->mh_number = ++block;
    debugMemSize += size;
    debugMemBlocks++;
    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
    debugmem_list_add(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Malloc(%d) Ok\n",size);
#endif

    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();

    ret = HDR_2_CLIENT(p);

    if (xmlMemTraceBlockAt == ret) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
            (long unsigned)size);
    xmlMallocBreakpoint();
    }

    TEST_POINT

    return(ret);
}

xmlMallocBreakpoint()

void xmlMallocBreakpoint

(

void

)

xmlMallocBreakpoint:

Breakpoint to use in conjunction with xmlMemStopAtBlock. When the block number reaches the specified value this function is called. One need to add a breakpoint to it to get the context in which the given block is allocated.

Definition at line 145 of file xmlmemory.c.

                          {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
}

Referenced by xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemFree(), xmlMemStrdupLoc(), and xmlReallocLoc().

xmlMallocLoc()

void* xmlMallocLoc	(	size_t	size,
		const char *	file,
		int	line
	)

Definition at line 162 of file xmlmemory.c.

{
    MEMHDR *p;
    void *ret;

    if (!xmlMemInitialized) xmlInitMemory();
#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Malloc(%d)\n",size);
#endif

    TEST_POINT

    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocLoc : Unsigned overflow\n");
    xmlMemoryDump();
    return(NULL);
    }

    p = (MEMHDR *) malloc(RESERVE_SIZE+size);

    if (!p) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocLoc : Out of free space\n");
    xmlMemoryDump();
    return(NULL);
    }
    p->mh_tag = MEMTAG;
    p->mh_size = size;
    p->mh_type = MALLOC_TYPE;
    p->mh_file = file;
    p->mh_line = line;
    xmlMutexLock(xmlMemMutex);
    p->mh_number = ++block;
    debugMemSize += size;
    debugMemBlocks++;
    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
    debugmem_list_add(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Malloc(%d) Ok\n",size);
#endif

    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();

    ret = HDR_2_CLIENT(p);

    if (xmlMemTraceBlockAt == ret) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
            (long unsigned)size);
    xmlMallocBreakpoint();
    }

    TEST_POINT

    return(ret);
}

Referenced by xmlMemMalloc(), and xmlReallocLoc().

xmlMemBlocks()

int xmlMemBlocks

(

void

)

xmlMemBlocks:

Provides the number of memory areas currently allocated

Returns an int representing the number of blocks

Definition at line 603 of file xmlmemory.c.

                   {
    int res;

    xmlMutexLock(xmlMemMutex);
    res = debugMemBlocks;
    xmlMutexUnlock(xmlMemMutex);
    return(res);
}

xmlMemDisplay()

void xmlMemDisplay

(

FILE *

fp

)

xmlMemDisplay: @fp: a FILE descriptor used as the output file, if NULL, the result is written to the file .memorylist

show in-extenso the memory blocks allocated

Definition at line 756 of file xmlmemory.c.

{
#ifdef MEM_LIST
    MEMHDR *p;
    unsigned idx;
    int     nb = 0;
#if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
    time_t currentTime;
    char buf[500];
    struct tm * tstruct;
#endif
#endif
    FILE *old_fp = fp;

    if (fp == NULL) {
    fp = fopen(".memorylist", "w");
    if (fp == NULL)
        return;
    }

#ifdef MEM_LIST
#if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
    currentTime = time(NULL);
    tstruct = localtime(&currentTime);
    strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
    fprintf(fp,"      %s\n\n", buf);
#endif


    fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
            debugMemSize, debugMaxMemSize);
    fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
    idx = 0;
    xmlMutexLock(xmlMemMutex);
    p = memlist;
    while (p) {
      fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
          (unsigned long)p->mh_size);
        switch (p->mh_type) {
           case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
           case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
           case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
           case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
           case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
           default:
            fprintf(fp,"Unknown memory block, may be corrupted");
        xmlMutexUnlock(xmlMemMutex);
        if (old_fp == NULL)
            fclose(fp);
        return;
        }
    if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
        if (p->mh_tag != MEMTAG)
          fprintf(fp,"  INVALID");
        nb++;
    if (nb < 100)
        xmlMemContentShow(fp, p);
    else
        fprintf(fp," skip");

        fprintf(fp,"\n");
        p = p->mh_next;
    }
    xmlMutexUnlock(xmlMemMutex);
#else
    fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
#endif
    if (old_fp == NULL)
    fclose(fp);
}

Referenced by debugmem_tag_error(), and xmlMemoryDump().

xmlMemDisplayLast()

void xmlMemDisplayLast	(	FILE *	fp,
		long	nbBytes
	)

xmlMemDisplayLast: @fp: a FILE descriptor used as the output file, if NULL, the result is written to the file .memorylist @nbBytes: the amount of memory to dump

the last nbBytes of memory allocated and not freed, useful for dumping the memory left allocated between two places at runtime.

Definition at line 685 of file xmlmemory.c.

{
#ifdef MEM_LIST
    MEMHDR *p;
    unsigned idx;
    int     nb = 0;
#endif
    FILE *old_fp = fp;

    if (nbBytes <= 0)
        return;

    if (fp == NULL) {
    fp = fopen(".memorylist", "w");
    if (fp == NULL)
        return;
    }

#ifdef MEM_LIST
    fprintf(fp,"   Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
            nbBytes, debugMemSize, debugMaxMemSize);
    fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
    idx = 0;
    xmlMutexLock(xmlMemMutex);
    p = memlist;
    while ((p) && (nbBytes > 0)) {
      fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
          (unsigned long)p->mh_size);
        switch (p->mh_type) {
           case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
           case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
           case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
           case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
           case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
           default:
            fprintf(fp,"Unknown memory block, may be corrupted");
        xmlMutexUnlock(xmlMemMutex);
        if (old_fp == NULL)
            fclose(fp);
        return;
        }
    if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
        if (p->mh_tag != MEMTAG)
          fprintf(fp,"  INVALID");
        nb++;
    if (nb < 100)
        xmlMemContentShow(fp, p);
    else
        fprintf(fp," skip");

        fprintf(fp,"\n");
    nbBytes -= (unsigned long)p->mh_size;
        p = p->mh_next;
    }
    xmlMutexUnlock(xmlMemMutex);
#else
    fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
#endif
    if (old_fp == NULL)
    fclose(fp);
}

xmlMemFree()

void xmlMemFree

(

void *

ptr

)

xmlMemFree: @ptr: the memory block pointer

a free() equivalent, with error checking.

Definition at line 431 of file xmlmemory.c.

{
    MEMHDR *p;
    char *target;
#ifdef DEBUG_MEMORY
    size_t size;
#endif

    if (ptr == NULL)
    return;

    if (ptr == (void *) -1) {
    xmlGenericError(xmlGenericErrorContext,
        "trying to free pointer from freed area\n");
        goto error;
    }

    if (xmlMemTraceBlockAt == ptr) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Freed()\n", xmlMemTraceBlockAt);
    xmlMallocBreakpoint();
    }

    TEST_POINT

    target = (char *) ptr;

    p = CLIENT_2_HDR(ptr);
    if (p->mh_tag != MEMTAG) {
        Mem_Tag_Err(p);
        goto error;
    }
    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
    p->mh_tag = ~MEMTAG;
    memset(target, -1, p->mh_size);
    xmlMutexLock(xmlMemMutex);
    debugMemSize -= p->mh_size;
    debugMemBlocks--;
#ifdef DEBUG_MEMORY
    size = p->mh_size;
#endif
#ifdef MEM_LIST
    debugmem_list_delete(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

    free(p);

    TEST_POINT

#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Freed(%d) Ok\n", size);
#endif

    return;

error:
    xmlGenericError(xmlGenericErrorContext,
        "xmlMemFree(%p) error\n", ptr);
    xmlMallocBreakpoint();
    return;
}

Referenced by myFreeFunc(), myMallocFunc(), myReallocFunc(), and xmlInitializeGlobalState().

xmlMemGet()

int xmlMemGet	(	xmlFreeFunc *	freeFunc,
		xmlMallocFunc *	mallocFunc,
		xmlReallocFunc *	reallocFunc,
		xmlStrdupFunc *	strdupFunc
	)

xmlMemGet: @freeFunc: place to save the free() function in use @mallocFunc: place to save the malloc() function in use @reallocFunc: place to save the realloc() function in use @strdupFunc: place to save the strdup() function in use

Provides the memory access functions set currently in use

Returns 0 on success

Definition at line 1079 of file xmlmemory.c.

                                                              {
    if (freeFunc != NULL) *freeFunc = xmlFree;
    if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
    if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
    if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
    return(0);
}

xmlMemMalloc()

void* xmlMemMalloc

(

size_t

size

)

xmlMemMalloc: @size: an int specifying the size in byte to allocate.

a malloc() equivalent, with logging of the allocation info.

Returns a pointer to the allocated area or NULL in case of lack of memory.

Definition at line 311 of file xmlmemory.c.

{
    return(xmlMallocLoc(size, "none", 0));
}

Referenced by myMallocFunc(), and xmlInitializeGlobalState().

xmlMemoryDump()

void xmlMemoryDump

(

void

)

xmlMemoryDump:

Dump in-extenso the memory blocks allocated to the file .memorylist

Definition at line 931 of file xmlmemory.c.

{
#ifdef MEM_LIST
    FILE *dump;

    if (debugMaxMemSize == 0)
    return;
    dump = fopen(".memdump", "w");
    if (dump == NULL)
    xmlMemoryDumpFile = stderr;
    else xmlMemoryDumpFile = dump;

    xmlMemDisplay(xmlMemoryDumpFile);

    if (dump != NULL) fclose(dump);
#endif /* MEM_LIST */
}

Referenced by main(), xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemStrdupLoc(), and xmlReallocLoc().

xmlMemoryStrdup()

char* xmlMemoryStrdup

(

const char *

str

)

xmlMemoryStrdup: @str: the initial string pointer

a strdup() equivalent, with logging of the allocation info.

Returns a pointer to the new string or NULL if allocation error occurred.

Definition at line 572 of file xmlmemory.c.

                                 {
    return(xmlMemStrdupLoc(str, "none", 0));
}

Referenced by myStrdupFunc(), and xmlInitializeGlobalState().

xmlMemRealloc()

void* xmlMemRealloc	(	void *	ptr,
		size_t	size
	)

xmlMemRealloc: @ptr: the initial memory block pointer @size: an int specifying the size in byte to allocate.

a realloc() equivalent, with logging of the allocation info.

Returns a pointer to the allocated area or NULL in case of lack of memory.

Definition at line 420 of file xmlmemory.c.

                                     {
    return(xmlReallocLoc(ptr, size, "none", 0));
}

Referenced by myReallocFunc(), and xmlInitializeGlobalState().

xmlMemSetup()

int xmlMemSetup	(	xmlFreeFunc	freeFunc,
		xmlMallocFunc	mallocFunc,
		xmlReallocFunc	reallocFunc,
		xmlStrdupFunc	strdupFunc
	)

xmlMemSetup: @freeFunc: the free() function to use @mallocFunc: the malloc() function to use @reallocFunc: the realloc() function to use @strdupFunc: the strdup() function to use

Override the default memory access functions with a new set This has to be called before any other libxml routines !

Should this be blocked if there was already some allocations done ?

Returns 0 on success

Definition at line 1041 of file xmlmemory.c.

                                                                  {
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlMemSetup()\n");
#endif
    if (freeFunc == NULL)
    return(-1);
    if (mallocFunc == NULL)
    return(-1);
    if (reallocFunc == NULL)
    return(-1);
    if (strdupFunc == NULL)
    return(-1);
    xmlFree = freeFunc;
    xmlMalloc = mallocFunc;
    xmlMallocAtomic = mallocFunc;
    xmlRealloc = reallocFunc;
    xmlMemStrdup = strdupFunc;
#ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
         "xmlMemSetup() Ok\n");
#endif
    return(0);
}

Referenced by main().

xmlMemShow()

void xmlMemShow	(	FILE *	fp,
		int nr	ATTRIBUTE_UNUSED
	)

xmlMemShow: @fp: a FILE descriptor used as the output file @nr: number of entries to dump

show a show display of the memory allocated, and dump the @nr last allocated areas which were not freed

Definition at line 886 of file xmlmemory.c.

{
#ifdef MEM_LIST
    MEMHDR *p;
#endif

    if (fp != NULL)
    fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
        debugMemSize, debugMaxMemSize);
#ifdef MEM_LIST
    xmlMutexLock(xmlMemMutex);
    if (nr > 0) {
    fprintf(fp,"NUMBER   SIZE  TYPE   WHERE\n");
    p = memlist;
    while ((p) && nr > 0) {
          fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
        switch (p->mh_type) {
           case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
           case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
           case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
          case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
          case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
        default:fprintf(fp,"   ???    in ");break;
        }
        if (p->mh_file != NULL)
            fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
        if (p->mh_tag != MEMTAG)
        fprintf(fp,"  INVALID");
        xmlMemContentShow(fp, p);
        fprintf(fp,"\n");
        nr--;
        p = p->mh_next;
    }
    }
    xmlMutexUnlock(xmlMemMutex);
#endif /* MEM_LIST */
}

xmlMemStrdupLoc()

char* xmlMemStrdupLoc	(	const char *	str,
		const char *	file,
		int	line
	)

Definition at line 507 of file xmlmemory.c.

{
    char *s;
    size_t size = strlen(str) + 1;
    MEMHDR *p;

    if (!xmlMemInitialized) xmlInitMemory();
    TEST_POINT

    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMemStrdupLoc : Unsigned overflow\n");
    xmlMemoryDump();
    return(NULL);
    }

    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
    if (!p) {
      goto error;
    }
    p->mh_tag = MEMTAG;
    p->mh_size = size;
    p->mh_type = STRDUP_TYPE;
    p->mh_file = file;
    p->mh_line = line;
    xmlMutexLock(xmlMemMutex);
    p->mh_number = ++block;
    debugMemSize += size;
    debugMemBlocks++;
    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
    debugmem_list_add(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

    s = (char *) HDR_2_CLIENT(p);

    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();

    strcpy(s,str);

    TEST_POINT

    if (xmlMemTraceBlockAt == s) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
    xmlMallocBreakpoint();
    }

    return(s);

error:
    return(NULL);
}

Referenced by xmlMemoryStrdup().

xmlMemUsed()

int xmlMemUsed

(

void

)

xmlMemUsed:

Provides the amount of memory currently allocated

Returns an int representing the amount of memory allocated.

Definition at line 585 of file xmlmemory.c.

                 {
    int res;

    xmlMutexLock(xmlMemMutex);
    res = debugMemSize;
    xmlMutexUnlock(xmlMemMutex);
    return(res);
}

Referenced by myMallocFunc(), myReallocFunc(), and myStrdupFunc().

xmlReallocLoc()

void* xmlReallocLoc	(	void *	ptr,
		size_t	size,
		const char *	file,
		int	line
	)

Definition at line 329 of file xmlmemory.c.

{
    MEMHDR *p, *tmp;
    unsigned long number;
#ifdef DEBUG_MEMORY
    size_t oldsize;
#endif

    if (ptr == NULL)
        return(xmlMallocLoc(size, file, line));

    if (!xmlMemInitialized) xmlInitMemory();
    TEST_POINT

    p = CLIENT_2_HDR(ptr);
    number = p->mh_number;
    if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
    if (p->mh_tag != MEMTAG) {
       Mem_Tag_Err(p);
     goto error;
    }
    p->mh_tag = ~MEMTAG;
    xmlMutexLock(xmlMemMutex);
    debugMemSize -= p->mh_size;
    debugMemBlocks--;
#ifdef DEBUG_MEMORY
    oldsize = p->mh_size;
#endif
#ifdef MEM_LIST
    debugmem_list_delete(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlReallocLoc : Unsigned overflow\n");
    xmlMemoryDump();
    return(NULL);
    }

    tmp = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
    if (!tmp) {
     free(p);
     goto error;
    }
    p = tmp;
    if (xmlMemTraceBlockAt == ptr) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Realloced(%lu -> %lu) Ok\n",
            xmlMemTraceBlockAt, (long unsigned)p->mh_size,
            (long unsigned)size);
    xmlMallocBreakpoint();
    }
    p->mh_tag = MEMTAG;
    p->mh_number = number;
    p->mh_type = REALLOC_TYPE;
    p->mh_size = size;
    p->mh_file = file;
    p->mh_line = line;
    xmlMutexLock(xmlMemMutex);
    debugMemSize += size;
    debugMemBlocks++;
    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
    debugmem_list_add(p);
#endif
    xmlMutexUnlock(xmlMemMutex);

    TEST_POINT

#ifdef DEBUG_MEMORY
    xmlGenericError(xmlGenericErrorContext,
        "Realloced(%d to %d) Ok\n", oldsize, size);
#endif
    return(HDR_2_CLIENT(p));

error:
    return(NULL);
}

Referenced by xmlMemRealloc().

Variable Documentation

block

unsigned int block =0

static

Definition at line 118 of file xmlmemory.c.

Referenced by __find_get_block(), __getblk(), _chm_decompress_block(), _chm_get_cmpblock_bounds(), absynth_1to1_i486(), add_block(), add_block_index(), add_data_block(), add_data_to_folder(), add_typeinfo_block(), adns__transfer_interim(), tinyxml2::MemPoolT< sizeof(tinyxml2::XMLElement) >::Alloc(), alloc_pioinfo_block(), allocate_block(), append_data(), AVIFILE_SamplesToBlock(), Base64ToBinary(), blake2b_compress(), block_size(), BlockChainStream_GetBlockAtOffset(), chksum_crc32(), codeview_snarf(), copy_data_blocks(), create_io_inherit_block(), create_library_block(), ctl2_alloc_segment(), decode_mcu(), decode_mcu_AC_first(), decode_mcu_AC_refine(), decode_mcu_DC_first(), decode_mcu_sub(), desfunc(), dwarf2_parse_inlined_subroutine(), dwarf2_parse_subprogram_block(), dwarf2_parse_variable(), encode_mcu(), encode_mcu_AC_first(), encode_mcu_AC_refine(), encode_one_block(), Slicer::evalRBArray(), ext2_alloc_block(), ext2_block_map(), ext2_mkdir(), ext2_new_dir_block(), ext2_read_block(), ext2_test_block_bitmap(), ext2_test_block_bitmap_range(), ext2_write_block(), Ext2AddDotEntries(), Ext2LoadBuffer(), Ext2SaveBuffer(), Ext2ZeroBuffer(), ext3_add_entry(), ext3_append(), ext3_bread(), ext3_find_entry(), ext4_block_in_group(), ext4_ext_binsearch(), ext4_ext_binsearch_idx(), ext4_ext_find_goal(), ext4_ext_pblock(), ext4_ext_rm_leaf(), ext4_ext_search_right(), ext4_find_extent(), ext4_free_blocks(), ext4_idx_pblock(), ext4_new_meta_blocks(), ext_to_block(), extents_bread(), extents_bwrite(), FCIDestroy(), FDSA_InsertItem(), fill_delegated_proxy_table(), fill_delegated_stub_table(), fill_stubless_table(), free_data_block(), free_folder(), ft_free(), ft_mem_alloc(), ft_mem_qalloc(), ft_mem_qrealloc(), ft_mem_realloc(), ft_realloc(), fwpolicy2_get_BlockAllInboundTraffic(), fwpolicy2_put_BlockAllInboundTraffic(), get_block_bh(), get_block_bh_mdl(), get_block_bh_pin(), get_cache_glyph(), get_cache_glyph_widths(), get_file_version(), gl_destroy_list(), hash(), htest_one_block(), IAVIStream_fnRead(), idx_to_block(), III_hybrid(), ImmDestroyIMCC(), ldap_memfreeA(), ldap_memfreeW(), map_bh(), ntom_ins2outs(), OleUnblockServer(), ParseSharedPacket(), pending_flush(), ptegreload(), reiserfs_new_unf_blocknrs(), reiserfs_new_unf_blocknrs2(), sb_bread(), sb_find_get_block(), sb_getblk(), sb_getblk_zero(), set_cache_glyph(), set_cache_glyph_widths(), sltg_add_typeinfo(), sltg_write_header(), sltg_write_typeinfo(), stabs_parse(), StartBalanceW(), surface_cpu_blt_compressed(), swap_endian(), symt_add_func_local(), symt_close_func_block(), symt_enum_locals_helper(), symt_open_func_block(), tcpip_callback_with_block(), test_FDICopy(), test_fdsa(), UDFProcessSequence(), UDFReadVDS(), UDFUpdateVDS(), UDFVerifySequence(), urlcache_entry_alloc(), urlcache_entry_free(), write_data_blocks(), xmlMallocAtomicLoc(), xmlMallocLoc(), and xmlMemStrdupLoc().

debugMaxMemSize

unsigned long debugMaxMemSize = 0

static

Definition at line 54 of file xmlmemory.c.

Referenced by xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemDisplay(), xmlMemDisplayLast(), xmlMemoryDump(), xmlMemShow(), xmlMemStrdupLoc(), and xmlReallocLoc().

debugMemBlocks

unsigned long debugMemBlocks = 0

static

Definition at line 53 of file xmlmemory.c.

Referenced by xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemBlocks(), xmlMemFree(), xmlMemStrdupLoc(), and xmlReallocLoc().

debugMemSize

unsigned long debugMemSize = 0

static

Definition at line 52 of file xmlmemory.c.

Referenced by xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemDisplay(), xmlMemDisplayLast(), xmlMemFree(), xmlMemShow(), xmlMemStrdupLoc(), xmlMemUsed(), and xmlReallocLoc().

xmlMemInitialized

int xmlMemInitialized = 0

static

MEM_LIST:

keep track of all allocated blocks for error reporting Always build the memory list !

Definition at line 51 of file xmlmemory.c.

Referenced by xmlCleanupMemory(), xmlInitMemory(), xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemStrdupLoc(), and xmlReallocLoc().

xmlMemMutex

xmlMutexPtr xmlMemMutex = NULL

static

Definition at line 55 of file xmlmemory.c.

Referenced by xmlCleanupMemory(), xmlInitMemory(), xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemBlocks(), xmlMemDisplay(), xmlMemDisplayLast(), xmlMemFree(), xmlMemShow(), xmlMemStrdupLoc(), xmlMemUsed(), and xmlReallocLoc().

xmlMemStopAtBlock

unsigned int xmlMemStopAtBlock = 0

static

Definition at line 119 of file xmlmemory.c.

Referenced by xmlInitMemory(), xmlMallocAtomicLoc(), xmlMallocBreakpoint(), xmlMallocLoc(), xmlMemFree(), xmlMemStrdupLoc(), and xmlReallocLoc().

xmlMemTraceBlockAt

void* xmlMemTraceBlockAt = NULL

static

Definition at line 120 of file xmlmemory.c.

Referenced by xmlInitMemory(), xmlMallocAtomicLoc(), xmlMallocLoc(), xmlMemFree(), xmlMemStrdupLoc(), and xmlReallocLoc().