third_party/libxml/src/xmlmemory.c

   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(&currentTime);
 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"