Annotation of embedaddon/libxml2/xmlmemory.c, revision 1.1
1.1 ! misho 1: /*
! 2: * xmlmemory.c: libxml memory allocator wrapper.
! 3: *
! 4: * daniel@veillard.com
! 5: */
! 6:
! 7: #define IN_LIBXML
! 8: #include "libxml.h"
! 9:
! 10: #include <string.h>
! 11:
! 12: #ifdef HAVE_SYS_TYPES_H
! 13: #include <sys/types.h>
! 14: #endif
! 15:
! 16: #ifdef HAVE_TIME_H
! 17: #include <time.h>
! 18: #endif
! 19:
! 20: #ifdef HAVE_STDLIB_H
! 21: #include <stdlib.h>
! 22: #else
! 23: #ifdef HAVE_MALLOC_H
! 24: #include <malloc.h>
! 25: #endif
! 26: #endif
! 27:
! 28: #ifdef HAVE_CTYPE_H
! 29: #include <ctype.h>
! 30: #endif
! 31:
! 32: /* #define DEBUG_MEMORY */
! 33:
! 34: /**
! 35: * MEM_LIST:
! 36: *
! 37: * keep track of all allocated blocks for error reporting
! 38: * Always build the memory list !
! 39: */
! 40: #ifdef DEBUG_MEMORY_LOCATION
! 41: #ifndef MEM_LIST
! 42: #define MEM_LIST /* keep a list of all the allocated memory blocks */
! 43: #endif
! 44: #endif
! 45:
! 46: #include <libxml/globals.h> /* must come before xmlmemory.h */
! 47: #include <libxml/xmlmemory.h>
! 48: #include <libxml/xmlerror.h>
! 49: #include <libxml/threads.h>
! 50:
! 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(%ld) 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(%ld) 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(%ld -> %ld) 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: * xmlMemDisplayLast:
! 633: * @fp: a FILE descriptor used as the output file, if NULL, the result is
! 634: * written to the file .memorylist
! 635: * @nbBytes: the amount of memory to dump
! 636: *
! 637: * the last nbBytes of memory allocated and not freed, useful for dumping
! 638: * the memory left allocated between two places at runtime.
! 639: */
! 640:
! 641: void
! 642: xmlMemDisplayLast(FILE *fp, long nbBytes)
! 643: {
! 644: #ifdef MEM_LIST
! 645: MEMHDR *p;
! 646: unsigned idx;
! 647: int nb = 0;
! 648: #endif
! 649: FILE *old_fp = fp;
! 650:
! 651: if (nbBytes <= 0)
! 652: return;
! 653:
! 654: if (fp == NULL) {
! 655: fp = fopen(".memorylist", "w");
! 656: if (fp == NULL)
! 657: return;
! 658: }
! 659:
! 660: #ifdef MEM_LIST
! 661: fprintf(fp," Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
! 662: nbBytes, debugMemSize, debugMaxMemSize);
! 663: fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
! 664: idx = 0;
! 665: xmlMutexLock(xmlMemMutex);
! 666: p = memlist;
! 667: while ((p) && (nbBytes > 0)) {
! 668: fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
! 669: (unsigned long)p->mh_size);
! 670: switch (p->mh_type) {
! 671: case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
! 672: case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
! 673: case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
! 674: case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
! 675: case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
! 676: default:
! 677: fprintf(fp,"Unknown memory block, may be corrupted");
! 678: xmlMutexUnlock(xmlMemMutex);
! 679: if (old_fp == NULL)
! 680: fclose(fp);
! 681: return;
! 682: }
! 683: if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
! 684: if (p->mh_tag != MEMTAG)
! 685: fprintf(fp," INVALID");
! 686: nb++;
! 687: if (nb < 100)
! 688: xmlMemContentShow(fp, p);
! 689: else
! 690: fprintf(fp," skip");
! 691:
! 692: fprintf(fp,"\n");
! 693: nbBytes -= (unsigned long)p->mh_size;
! 694: p = p->mh_next;
! 695: }
! 696: xmlMutexUnlock(xmlMemMutex);
! 697: #else
! 698: fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
! 699: #endif
! 700: if (old_fp == NULL)
! 701: fclose(fp);
! 702: }
! 703:
! 704: /**
! 705: * xmlMemDisplay:
! 706: * @fp: a FILE descriptor used as the output file, if NULL, the result is
! 707: * written to the file .memorylist
! 708: *
! 709: * show in-extenso the memory blocks allocated
! 710: */
! 711:
! 712: void
! 713: xmlMemDisplay(FILE *fp)
! 714: {
! 715: #ifdef MEM_LIST
! 716: MEMHDR *p;
! 717: unsigned idx;
! 718: int nb = 0;
! 719: #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
! 720: time_t currentTime;
! 721: char buf[500];
! 722: struct tm * tstruct;
! 723: #endif
! 724: #endif
! 725: FILE *old_fp = fp;
! 726:
! 727: if (fp == NULL) {
! 728: fp = fopen(".memorylist", "w");
! 729: if (fp == NULL)
! 730: return;
! 731: }
! 732:
! 733: #ifdef MEM_LIST
! 734: #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
! 735: currentTime = time(NULL);
! 736: tstruct = localtime(¤tTime);
! 737: strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
! 738: fprintf(fp," %s\n\n", buf);
! 739: #endif
! 740:
! 741:
! 742: fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
! 743: debugMemSize, debugMaxMemSize);
! 744: fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
! 745: idx = 0;
! 746: xmlMutexLock(xmlMemMutex);
! 747: p = memlist;
! 748: while (p) {
! 749: fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
! 750: (unsigned long)p->mh_size);
! 751: switch (p->mh_type) {
! 752: case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
! 753: case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
! 754: case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
! 755: case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
! 756: case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
! 757: default:
! 758: fprintf(fp,"Unknown memory block, may be corrupted");
! 759: xmlMutexUnlock(xmlMemMutex);
! 760: if (old_fp == NULL)
! 761: fclose(fp);
! 762: return;
! 763: }
! 764: if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
! 765: if (p->mh_tag != MEMTAG)
! 766: fprintf(fp," INVALID");
! 767: nb++;
! 768: if (nb < 100)
! 769: xmlMemContentShow(fp, p);
! 770: else
! 771: fprintf(fp," skip");
! 772:
! 773: fprintf(fp,"\n");
! 774: p = p->mh_next;
! 775: }
! 776: xmlMutexUnlock(xmlMemMutex);
! 777: #else
! 778: fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
! 779: #endif
! 780: if (old_fp == NULL)
! 781: fclose(fp);
! 782: }
! 783:
! 784: #ifdef MEM_LIST
! 785:
! 786: static void debugmem_list_add(MEMHDR *p)
! 787: {
! 788: p->mh_next = memlist;
! 789: p->mh_prev = NULL;
! 790: if (memlist) memlist->mh_prev = p;
! 791: memlist = p;
! 792: #ifdef MEM_LIST_DEBUG
! 793: if (stderr)
! 794: Mem_Display(stderr);
! 795: #endif
! 796: }
! 797:
! 798: static void debugmem_list_delete(MEMHDR *p)
! 799: {
! 800: if (p->mh_next)
! 801: p->mh_next->mh_prev = p->mh_prev;
! 802: if (p->mh_prev)
! 803: p->mh_prev->mh_next = p->mh_next;
! 804: else memlist = p->mh_next;
! 805: #ifdef MEM_LIST_DEBUG
! 806: if (stderr)
! 807: Mem_Display(stderr);
! 808: #endif
! 809: }
! 810:
! 811: #endif
! 812:
! 813: /*
! 814: * debugmem_tag_error:
! 815: *
! 816: * internal error function.
! 817: */
! 818:
! 819: static void debugmem_tag_error(void *p)
! 820: {
! 821: xmlGenericError(xmlGenericErrorContext,
! 822: "Memory tag error occurs :%p \n\t bye\n", p);
! 823: #ifdef MEM_LIST
! 824: if (stderr)
! 825: xmlMemDisplay(stderr);
! 826: #endif
! 827: }
! 828:
! 829: #ifdef MEM_LIST
! 830: static FILE *xmlMemoryDumpFile = NULL;
! 831: #endif
! 832:
! 833: /**
! 834: * xmlMemShow:
! 835: * @fp: a FILE descriptor used as the output file
! 836: * @nr: number of entries to dump
! 837: *
! 838: * show a show display of the memory allocated, and dump
! 839: * the @nr last allocated areas which were not freed
! 840: */
! 841:
! 842: void
! 843: xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
! 844: {
! 845: #ifdef MEM_LIST
! 846: MEMHDR *p;
! 847: #endif
! 848:
! 849: if (fp != NULL)
! 850: fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
! 851: debugMemSize, debugMaxMemSize);
! 852: #ifdef MEM_LIST
! 853: xmlMutexLock(xmlMemMutex);
! 854: if (nr > 0) {
! 855: fprintf(fp,"NUMBER SIZE TYPE WHERE\n");
! 856: p = memlist;
! 857: while ((p) && nr > 0) {
! 858: fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
! 859: switch (p->mh_type) {
! 860: case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
! 861: case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
! 862: case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
! 863: case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
! 864: case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
! 865: default:fprintf(fp," ??? in ");break;
! 866: }
! 867: if (p->mh_file != NULL)
! 868: fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
! 869: if (p->mh_tag != MEMTAG)
! 870: fprintf(fp," INVALID");
! 871: xmlMemContentShow(fp, p);
! 872: fprintf(fp,"\n");
! 873: nr--;
! 874: p = p->mh_next;
! 875: }
! 876: }
! 877: xmlMutexUnlock(xmlMemMutex);
! 878: #endif /* MEM_LIST */
! 879: }
! 880:
! 881: /**
! 882: * xmlMemoryDump:
! 883: *
! 884: * Dump in-extenso the memory blocks allocated to the file .memorylist
! 885: */
! 886:
! 887: void
! 888: xmlMemoryDump(void)
! 889: {
! 890: #ifdef MEM_LIST
! 891: FILE *dump;
! 892:
! 893: if (debugMaxMemSize == 0)
! 894: return;
! 895: dump = fopen(".memdump", "w");
! 896: if (dump == NULL)
! 897: xmlMemoryDumpFile = stderr;
! 898: else xmlMemoryDumpFile = dump;
! 899:
! 900: xmlMemDisplay(xmlMemoryDumpFile);
! 901:
! 902: if (dump != NULL) fclose(dump);
! 903: #endif /* MEM_LIST */
! 904: }
! 905:
! 906:
! 907: /****************************************************************
! 908: * *
! 909: * Initialization Routines *
! 910: * *
! 911: ****************************************************************/
! 912:
! 913: /**
! 914: * xmlInitMemory:
! 915: *
! 916: * Initialize the memory layer.
! 917: *
! 918: * Returns 0 on success
! 919: */
! 920: int
! 921: xmlInitMemory(void)
! 922: {
! 923: #ifdef HAVE_STDLIB_H
! 924: char *breakpoint;
! 925: #endif
! 926: #ifdef DEBUG_MEMORY
! 927: xmlGenericError(xmlGenericErrorContext,
! 928: "xmlInitMemory()\n");
! 929: #endif
! 930: /*
! 931: This is really not good code (see Bug 130419). Suggestions for
! 932: improvement will be welcome!
! 933: */
! 934: if (xmlMemInitialized) return(-1);
! 935: xmlMemInitialized = 1;
! 936: xmlMemMutex = xmlNewMutex();
! 937:
! 938: #ifdef HAVE_STDLIB_H
! 939: breakpoint = getenv("XML_MEM_BREAKPOINT");
! 940: if (breakpoint != NULL) {
! 941: sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
! 942: }
! 943: #endif
! 944: #ifdef HAVE_STDLIB_H
! 945: breakpoint = getenv("XML_MEM_TRACE");
! 946: if (breakpoint != NULL) {
! 947: sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
! 948: }
! 949: #endif
! 950:
! 951: #ifdef DEBUG_MEMORY
! 952: xmlGenericError(xmlGenericErrorContext,
! 953: "xmlInitMemory() Ok\n");
! 954: #endif
! 955: return(0);
! 956: }
! 957:
! 958: /**
! 959: * xmlCleanupMemory:
! 960: *
! 961: * Free up all the memory allocated by the library for its own
! 962: * use. This should not be called by user level code.
! 963: */
! 964: void
! 965: xmlCleanupMemory(void) {
! 966: #ifdef DEBUG_MEMORY
! 967: xmlGenericError(xmlGenericErrorContext,
! 968: "xmlCleanupMemory()\n");
! 969: #endif
! 970: if (xmlMemInitialized == 0)
! 971: return;
! 972:
! 973: xmlFreeMutex(xmlMemMutex);
! 974: xmlMemMutex = NULL;
! 975: xmlMemInitialized = 0;
! 976: #ifdef DEBUG_MEMORY
! 977: xmlGenericError(xmlGenericErrorContext,
! 978: "xmlCleanupMemory() Ok\n");
! 979: #endif
! 980: }
! 981:
! 982: /**
! 983: * xmlMemSetup:
! 984: * @freeFunc: the free() function to use
! 985: * @mallocFunc: the malloc() function to use
! 986: * @reallocFunc: the realloc() function to use
! 987: * @strdupFunc: the strdup() function to use
! 988: *
! 989: * Override the default memory access functions with a new set
! 990: * This has to be called before any other libxml routines !
! 991: *
! 992: * Should this be blocked if there was already some allocations
! 993: * done ?
! 994: *
! 995: * Returns 0 on success
! 996: */
! 997: int
! 998: xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
! 999: xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
! 1000: #ifdef DEBUG_MEMORY
! 1001: xmlGenericError(xmlGenericErrorContext,
! 1002: "xmlMemSetup()\n");
! 1003: #endif
! 1004: if (freeFunc == NULL)
! 1005: return(-1);
! 1006: if (mallocFunc == NULL)
! 1007: return(-1);
! 1008: if (reallocFunc == NULL)
! 1009: return(-1);
! 1010: if (strdupFunc == NULL)
! 1011: return(-1);
! 1012: xmlFree = freeFunc;
! 1013: xmlMalloc = mallocFunc;
! 1014: xmlMallocAtomic = mallocFunc;
! 1015: xmlRealloc = reallocFunc;
! 1016: xmlMemStrdup = strdupFunc;
! 1017: #ifdef DEBUG_MEMORY
! 1018: xmlGenericError(xmlGenericErrorContext,
! 1019: "xmlMemSetup() Ok\n");
! 1020: #endif
! 1021: return(0);
! 1022: }
! 1023:
! 1024: /**
! 1025: * xmlMemGet:
! 1026: * @freeFunc: place to save the free() function in use
! 1027: * @mallocFunc: place to save the malloc() function in use
! 1028: * @reallocFunc: place to save the realloc() function in use
! 1029: * @strdupFunc: place to save the strdup() function in use
! 1030: *
! 1031: * Provides the memory access functions set currently in use
! 1032: *
! 1033: * Returns 0 on success
! 1034: */
! 1035: int
! 1036: xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
! 1037: xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
! 1038: if (freeFunc != NULL) *freeFunc = xmlFree;
! 1039: if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
! 1040: if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
! 1041: if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
! 1042: return(0);
! 1043: }
! 1044:
! 1045: /**
! 1046: * xmlGcMemSetup:
! 1047: * @freeFunc: the free() function to use
! 1048: * @mallocFunc: the malloc() function to use
! 1049: * @mallocAtomicFunc: the malloc() function to use for atomic allocations
! 1050: * @reallocFunc: the realloc() function to use
! 1051: * @strdupFunc: the strdup() function to use
! 1052: *
! 1053: * Override the default memory access functions with a new set
! 1054: * This has to be called before any other libxml routines !
! 1055: * The mallocAtomicFunc is specialized for atomic block
! 1056: * allocations (i.e. of areas useful for garbage collected memory allocators
! 1057: *
! 1058: * Should this be blocked if there was already some allocations
! 1059: * done ?
! 1060: *
! 1061: * Returns 0 on success
! 1062: */
! 1063: int
! 1064: xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
! 1065: xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
! 1066: xmlStrdupFunc strdupFunc) {
! 1067: #ifdef DEBUG_MEMORY
! 1068: xmlGenericError(xmlGenericErrorContext,
! 1069: "xmlGcMemSetup()\n");
! 1070: #endif
! 1071: if (freeFunc == NULL)
! 1072: return(-1);
! 1073: if (mallocFunc == NULL)
! 1074: return(-1);
! 1075: if (mallocAtomicFunc == NULL)
! 1076: return(-1);
! 1077: if (reallocFunc == NULL)
! 1078: return(-1);
! 1079: if (strdupFunc == NULL)
! 1080: return(-1);
! 1081: xmlFree = freeFunc;
! 1082: xmlMalloc = mallocFunc;
! 1083: xmlMallocAtomic = mallocAtomicFunc;
! 1084: xmlRealloc = reallocFunc;
! 1085: xmlMemStrdup = strdupFunc;
! 1086: #ifdef DEBUG_MEMORY
! 1087: xmlGenericError(xmlGenericErrorContext,
! 1088: "xmlGcMemSetup() Ok\n");
! 1089: #endif
! 1090: return(0);
! 1091: }
! 1092:
! 1093: /**
! 1094: * xmlGcMemGet:
! 1095: * @freeFunc: place to save the free() function in use
! 1096: * @mallocFunc: place to save the malloc() function in use
! 1097: * @mallocAtomicFunc: place to save the atomic malloc() function in use
! 1098: * @reallocFunc: place to save the realloc() function in use
! 1099: * @strdupFunc: place to save the strdup() function in use
! 1100: *
! 1101: * Provides the memory access functions set currently in use
! 1102: * The mallocAtomicFunc is specialized for atomic block
! 1103: * allocations (i.e. of areas useful for garbage collected memory allocators
! 1104: *
! 1105: * Returns 0 on success
! 1106: */
! 1107: int
! 1108: xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
! 1109: xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
! 1110: xmlStrdupFunc *strdupFunc) {
! 1111: if (freeFunc != NULL) *freeFunc = xmlFree;
! 1112: if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
! 1113: if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
! 1114: if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
! 1115: if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
! 1116: return(0);
! 1117: }
! 1118:
! 1119: #define bottom_xmlmemory
! 1120: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlmemory.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2