intern/guardedalloc/intern/mallocn.c

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 /**
  30
  31  * $Id$
  32  * Copyright (C) 2001 NaN Technologies B.V.
  33  * Guarded memory allocation, and boundary-write detection.
  34  */
  35
  36 #include <stdlib.h>
  37 #include <string.h>     /* memcpy */
  38 #include <stdarg.h>
  39
  40 /* mmap exception */
  41 #if defined(WIN32)
  42 #include <sys/types.h>
  43 #include "mmap_win.h"
  44 #else
  45 #include <sys/types.h>
  46 #include <sys/mman.h>
  47 #endif
  48
  49 #include "MEM_guardedalloc.h"
  50
  51 /* Only for debugging:
  52  * lets you count the allocations so as to find the allocator of unfreed memory
  53  * in situations where the leak is pradictable */
  54
  55 // #define DEBUG_MEMCOUNTER
  56
  57 #ifdef DEBUG_MEMCOUNTER
  58 #define DEBUG_MEMCOUNTER_ERROR_VAL 0 /* set this to the value that isnt being freed */
  59 static int _mallocn_count = 0;
  60
  61 /* breakpoint here */
  62 static void memcount_raise(const char *name)
  63 {
  64         fprintf(stderr, "%s: memcount-leak, %d\n", name, _mallocn_count);
  65 }
  66 #endif
  67
  68 /* --------------------------------------------------------------------- */
  69 /* Data definition                                                       */
  70 /* --------------------------------------------------------------------- */
  71 /* all memory chunks are put in linked lists */
  72 typedef struct localLink
  73 {
  74         struct localLink *next,*prev;
  75 } localLink;
  76
  77 typedef struct localListBase
  78 {
  79         void *first, *last;
  80 } localListBase;
  81
  82         /* note: keep this struct aligned (e.g., irix/gcc) - Hos */
  83 typedef struct MemHead {
  84         int tag1;
  85         int len;
  86         struct MemHead *next,*prev;
  87         const char * name;
  88         const char * nextname;
  89         int tag2;
  90         int mmap;       /* if true, memory was mmapped */
  91 #ifdef DEBUG_MEMCOUNTER
  92         int _count;
  93 #endif
  94 } MemHead;
  95
  96 typedef struct MemTail {
  97         int tag3, pad;
  98 } MemTail;
  99
 100
 101 /* --------------------------------------------------------------------- */
 102 /* local functions                                                       */
 103 /* --------------------------------------------------------------------- */
 104
 105 static void addtail(volatile localListBase *listbase, void *vlink);
 106 static void remlink(volatile localListBase *listbase, void *vlink);
 107 static void rem_memblock(MemHead *memh);
 108 static void MemorY_ErroR(const char *block, const char *error);
 109 static const char *check_memlist(MemHead *memh);
 110
 111 /* --------------------------------------------------------------------- */
 112 /* locally used defines                                                  */
 113 /* --------------------------------------------------------------------- */
 114
 115 #if defined( __sgi) || defined (__sun) || defined (__sun__) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || (defined (__APPLE__) && !defined(__LITTLE_ENDIAN__))
 116 #define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
 117 #else
 118 #define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
 119 #endif
 120
 121 #define MEMTAG1 MAKE_ID('M', 'E', 'M', 'O')
 122 #define MEMTAG2 MAKE_ID('R', 'Y', 'B', 'L')
 123 #define MEMTAG3 MAKE_ID('O', 'C', 'K', '!')
 124 #define MEMFREE MAKE_ID('F', 'R', 'E', 'E')
 125
 126 #define MEMNEXT(x) ((MemHead *)(((char *) x) - ((char *) & (((MemHead *)0)->next))))
 127
 128 /* --------------------------------------------------------------------- */
 129 /* vars                                                                  */
 130 /* --------------------------------------------------------------------- */
 131
 132
 133 static volatile int totblock= 0;
 134 static volatile uintptr_t mem_in_use= 0, mmap_in_use= 0;
 135
 136 static volatile struct localListBase _membase;
 137 static volatile struct localListBase *membase = &_membase;
 138 static void (*error_callback)(const char *) = NULL;
 139 static void (*thread_lock_callback)(void) = NULL;
 140 static void (*thread_unlock_callback)(void) = NULL;
 141
 142 static int malloc_debug_memset= 0;
 143
 144 #ifdef malloc
 145 #undef malloc
 146 #endif
 147
 148 #ifdef calloc
 149 #undef calloc
 150 #endif
 151
 152 #ifdef free
 153 #undef free
 154 #endif
 155
 156
 157 /* --------------------------------------------------------------------- */
 158 /* implementation                                                        */
 159 /* --------------------------------------------------------------------- */
 160
 161 static void print_error(const char *str, ...)
 162 {
 163         char buf[1024];
 164         va_list ap;
 165
 166         va_start(ap, str);
 167         vsprintf(buf, str, ap);
 168         va_end(ap);
 169
 170         if (error_callback) error_callback(buf);
 171 }
 172
 173 static void mem_lock_thread()
 174 {
 175         if (thread_lock_callback)
 176                 thread_lock_callback();
 177 }
 178
 179 static void mem_unlock_thread()
 180 {
 181         if (thread_unlock_callback)
 182                 thread_unlock_callback();
 183 }
 184
 185 int MEM_check_memory_integrity()
 186 {
 187         const char* err_val = NULL;
 188         MemHead* listend;
 189         /* check_memlist starts from the front, and runs until it finds
 190          * the requested chunk. For this test, that's the last one. */
 191         listend = membase->last;
 192
 193         err_val = check_memlist(listend);
 194
 195         if (err_val == 0) return 0;
 196         return 1;
 197 }
 198
 199
 200 void MEM_set_error_callback(void (*func)(const char *))
 201 {
 202         error_callback = func;
 203 }
 204
 205 void MEM_set_lock_callback(void (*lock)(void), void (*unlock)(void))
 206 {
 207         thread_lock_callback = lock;
 208         thread_unlock_callback = unlock;
 209 }
 210
 211 void MEM_set_memory_debug(void)
 212 {
 213         malloc_debug_memset= 1;
 214 }
 215
 216 int MEM_allocN_len(void *vmemh)
 217 {
 218         if (vmemh) {
 219                 MemHead *memh= vmemh;
 220
 221                 memh--;
 222                 return memh->len;
 223         } else
 224                 return 0;
 225 }
 226
 227 void *MEM_dupallocN(void *vmemh)
 228 {
 229         void *newp= NULL;
 230
 231         if (vmemh) {
 232                 MemHead *memh= vmemh;
 233                 memh--;
 234
 235                 if(memh->mmap)
 236                         newp= MEM_mapallocN(memh->len, "dupli_mapalloc");
 237                 else
 238                         newp= MEM_mallocN(memh->len, "dupli_alloc");
 239
 240                 if (newp == NULL) return NULL;
 241
 242                 memcpy(newp, vmemh, memh->len);
 243         }
 244
 245         return newp;
 246 }
 247
 248 void *MEM_reallocN(void *vmemh, unsigned int len)
 249 {
 250         void *newp= NULL;
 251
 252         if (vmemh) {
 253                 MemHead *memh= vmemh;
 254                 memh--;
 255
 256                 newp= MEM_mallocN(len, memh->name);
 257                 if(newp) {
 258                         if(len < memh->len)
 259                                 memcpy(newp, vmemh, len);
 260                         else
 261                                 memcpy(newp, vmemh, memh->len);
 262                 }
 263
 264                 MEM_freeN(vmemh);
 265         }
 266
 267         return newp;
 268 }
 269
 270 static void make_memhead_header(MemHead *memh, unsigned int len, const char *str)
 271 {
 272         MemTail *memt;
 273
 274         memh->tag1 = MEMTAG1;
 275         memh->name = str;
 276         memh->nextname = 0;
 277         memh->len = len;
 278         memh->mmap = 0;
 279         memh->tag2 = MEMTAG2;
 280
 281         memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + len);
 282         memt->tag3 = MEMTAG3;
 283
 284         addtail(membase,&memh->next);
 285         if (memh->next) memh->nextname = MEMNEXT(memh->next)->name;
 286
 287         totblock++;
 288         mem_in_use += len;
 289 }
 290
 291 void *MEM_mallocN(unsigned int len, const char *str)
 292 {
 293         MemHead *memh;
 294
 295         mem_lock_thread();
 296
 297         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 298
 299         memh= (MemHead *)malloc(len+sizeof(MemHead)+sizeof(MemTail));
 300
 301         if(memh) {
 302                 make_memhead_header(memh, len, str);
 303                 mem_unlock_thread();
 304                 if(malloc_debug_memset && len)
 305                         memset(memh+1, 255, len);
 306
 307 #ifdef DEBUG_MEMCOUNTER
 308                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
 309                         memcount_raise("MEM_mallocN");
 310                 memh->_count= _mallocn_count++;
 311 #endif
 312                 return (++memh);
 313         }
 314         mem_unlock_thread();
 315         print_error("Malloc returns nill: len=%d in %s, total %u\n",len, str, mem_in_use);
 316         return NULL;
 317 }
 318
 319 void *MEM_callocN(unsigned int len, const char *str)
 320 {
 321         MemHead *memh;
 322
 323         mem_lock_thread();
 324
 325         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 326
 327         memh= (MemHead *)calloc(len+sizeof(MemHead)+sizeof(MemTail),1);
 328
 329         if(memh) {
 330                 make_memhead_header(memh, len, str);
 331                 mem_unlock_thread();
 332 #ifdef DEBUG_MEMCOUNTER
 333                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
 334                         memcount_raise("MEM_callocN");
 335                 memh->_count= _mallocn_count++;
 336 #endif
 337                 return (++memh);
 338         }
 339         mem_unlock_thread();
 340         print_error("Calloc returns nill: len=%d in %s, total %u\n",len, str, mem_in_use);
 341         return 0;
 342 }
 343
 344 /* note; mmap returns zero'd memory */
 345 void *MEM_mapallocN(unsigned int len, const char *str)
 346 {
 347         MemHead *memh;
 348
 349         mem_lock_thread();
 350
 351         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 352
 353 #ifdef __sgi
 354         {
 355 #include <fcntl.h>
 356
 357           int fd;
 358           fd = open("/dev/zero", O_RDWR);
 359
 360           memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
 361                      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 362           close(fd);
 363         }
 364 #else
 365         memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
 366                    PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
 367 #endif
 368
 369         if(memh!=(MemHead *)-1) {
 370                 make_memhead_header(memh, len, str);
 371                 memh->mmap= 1;
 372                 mmap_in_use += len;
 373                 mem_unlock_thread();
 374 #ifdef DEBUG_MEMCOUNTER
 375                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
 376                         memcount_raise("MEM_mapallocN");
 377                 memh->_count= _mallocn_count++;
 378 #endif
 379                 return (++memh);
 380         }
 381         else {
 382                 mem_unlock_thread();
 383                 print_error("Mapalloc returns nill, fallback to regular malloc: len=%d in %s, total %u\n",len, str, mmap_in_use);
 384                 return MEM_callocN(len, str);
 385         }
 386 }
 387
 388 /* Memory statistics print */
 389 typedef struct MemPrintBlock {
 390         const char *name;
 391         uintptr_t len;
 392         int items;
 393 } MemPrintBlock;
 394
 395 static int compare_name(const void *p1, const void *p2)
 396 {
 397         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
 398         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
 399
 400         return strcmp(pb1->name, pb2->name);
 401 }
 402
 403 static int compare_len(const void *p1, const void *p2)
 404 {
 405         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
 406         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
 407
 408         if(pb1->len < pb2->len)
 409                 return 1;
 410         else if(pb1->len == pb2->len)
 411                 return 0;
 412         else
 413                 return -1;
 414 }
 415
 416 void MEM_printmemlist_stats()
 417 {
 418         MemHead *membl;
 419         MemPrintBlock *pb, *printblock;
 420         int totpb, a, b;
 421
 422         mem_lock_thread();
 423
 424         /* put memory blocks into array */
 425         printblock= malloc(sizeof(MemPrintBlock)*totblock);
 426
 427         pb= printblock;
 428         totpb= 0;
 429
 430         membl = membase->first;
 431         if (membl) membl = MEMNEXT(membl);
 432
 433         while(membl) {
 434                 pb->name= membl->name;
 435                 pb->len= membl->len;
 436                 pb->items= 1;
 437
 438                 totpb++;
 439                 pb++;
 440
 441                 if(membl->next)
 442                         membl= MEMNEXT(membl->next);
 443                 else break;
 444         }
 445
 446         /* sort by name and add together blocks with the same name */
 447         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_name);
 448         for(a=0, b=0; a<totpb; a++) {
 449                 if(a == b) {
 450                         continue;
 451                 }
 452                 else if(strcmp(printblock[a].name, printblock[b].name) == 0) {
 453                         printblock[b].len += printblock[a].len;
 454                         printblock[b].items++;
 455                 }
 456                 else {
 457                         b++;
 458                         memcpy(&printblock[b], &printblock[a], sizeof(MemPrintBlock));
 459                 }
 460         }
 461         totpb= b+1;
 462
 463         /* sort by length and print */
 464         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_len);
 465         printf("\ntotal memory len: %.3f MB\n", (double)mem_in_use/(double)(1024*1024));
 466         for(a=0, pb=printblock; a<totpb; a++, pb++)
 467                 printf("%s items: %d, len: %.3f MB\n", pb->name, pb->items, (double)pb->len/(double)(1024*1024));
 468
 469         free(printblock);
 470
 471         mem_unlock_thread();
 472 }
 473
 474 /* Prints in python syntax for easy */
 475 static void MEM_printmemlist_internal( int pydict )
 476 {
 477         MemHead *membl;
 478
 479         mem_lock_thread();
 480
 481         membl = membase->first;
 482         if (membl) membl = MEMNEXT(membl);
 483
 484         if (pydict) {
 485                 print_error("# membase_debug.py\n");
 486                 print_error("membase = [\\\n");
 487         }
 488         while(membl) {
 489                 if (pydict) {
 490                         fprintf(stderr, "{'len':%i, 'name':'''%s''', 'pointer':'%p'},\\\n", membl->len, membl->name, membl+1);
 491                 } else {
 492 #ifdef DEBUG_MEMCOUNTER
 493                         print_error("%s len: %d %p, count: %d\n",membl->name,membl->len, membl+1, membl->_count);
 494 #else
 495                         print_error("%s len: %d %p\n",membl->name,membl->len, membl+1);
 496 #endif
 497                 }
 498                 if(membl->next)
 499                         membl= MEMNEXT(membl->next);
 500                 else break;
 501         }
 502         if (pydict) {
 503                 fprintf(stderr, "]\n\n");
 504                 fprintf(stderr,
 505 "mb_userinfo = {}\n"
 506 "totmem = 0\n"
 507 "for mb_item in membase:\n"
 508 "\tmb_item_user_size = mb_userinfo.setdefault(mb_item['name'], [0,0])\n"
 509 "\tmb_item_user_size[0] += 1 # Add a user\n"
 510 "\tmb_item_user_size[1] += mb_item['len'] # Increment the size\n"
 511 "\ttotmem += mb_item['len']\n"
 512 "print '(membase) items:', len(membase), '| unique-names:', len(mb_userinfo), '| total-mem:', totmem\n"
 513 "mb_userinfo_sort = mb_userinfo.items()\n"
 514 "for sort_name, sort_func in (('size', lambda a: -a[1][1]), ('users', lambda a: -a[1][0]), ('name', lambda a: a[0])):\n"
 515 "\tprint '\\nSorting by:', sort_name\n"
 516 "\tmb_userinfo_sort.sort(key = sort_func)\n"
 517 "\tfor item in mb_userinfo_sort:\n"
 518 "\t\tprint 'name:%%s, users:%%i, len:%%i' %% (item[0], item[1][0], item[1][1])\n"
 519                 );
 520         }
 521
 522         mem_unlock_thread();
 523 }
 524
 525 void MEM_callbackmemlist(void (*func)(void*)) {
 526         MemHead *membl;
 527
 528         mem_lock_thread();
 529
 530         membl = membase->first;
 531         if (membl) membl = MEMNEXT(membl);
 532
 533         while(membl) {
 534                 func(membl+1);
 535                 if(membl->next)
 536                         membl= MEMNEXT(membl->next);
 537                 else break;
 538         }
 539
 540         mem_unlock_thread();
 541 }
 542
 543 short MEM_testN(void *vmemh) {
 544         MemHead *membl;
 545
 546         mem_lock_thread();
 547
 548         membl = membase->first;
 549         if (membl) membl = MEMNEXT(membl);
 550
 551         while(membl) {
 552                 if (vmemh == membl+1) {
 553                         mem_unlock_thread();
 554                         return 1;
 555                 }
 556
 557                 if(membl->next)
 558                         membl= MEMNEXT(membl->next);
 559                 else break;
 560         }
 561
 562         mem_unlock_thread();
 563
 564         print_error("Memoryblock %p: pointer not in memlist\n", vmemh);
 565         return 0;
 566 }
 567
 568 void MEM_printmemlist( void ) {
 569         MEM_printmemlist_internal(0);
 570 }
 571 void MEM_printmemlist_pydict( void ) {
 572         MEM_printmemlist_internal(1);
 573 }
 574
 575 short MEM_freeN(void *vmemh)            /* anders compileertie niet meer */
 576 {
 577         short error = 0;
 578         MemTail *memt;
 579         MemHead *memh= vmemh;
 580         const char *name;
 581
 582         if (memh == NULL){
 583                 MemorY_ErroR("free","attempt to free NULL pointer");
 584                 /* print_error(err_stream, "%d\n", (memh+4000)->tag1); */
 585                 return(-1);
 586         }
 587
 588         if(sizeof(intptr_t)==8) {
 589                 if (((intptr_t) memh) & 0x7) {
 590                         MemorY_ErroR("free","attempt to free illegal pointer");
 591                         return(-1);
 592                 }
 593         }
 594         else {
 595                 if (((intptr_t) memh) & 0x3) {
 596                         MemorY_ErroR("free","attempt to free illegal pointer");
 597                         return(-1);
 598                 }
 599         }
 600
 601         memh--;
 602         if(memh->tag1 == MEMFREE && memh->tag2 == MEMFREE) {
 603                 MemorY_ErroR(memh->name,"double free");
 604                 return(-1);
 605         }
 606
 607         mem_lock_thread();
 608         if ((memh->tag1 == MEMTAG1) && (memh->tag2 == MEMTAG2) && ((memh->len & 0x3) == 0)) {
 609                 memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + memh->len);
 610                 if (memt->tag3 == MEMTAG3){
 611
 612                         memh->tag1 = MEMFREE;
 613                         memh->tag2 = MEMFREE;
 614                         memt->tag3 = MEMFREE;
 615                         /* after tags !!! */
 616                         rem_memblock(memh);
 617
 618                         mem_unlock_thread();
 619
 620                         return(0);
 621                 }
 622                 error = 2;
 623                 MemorY_ErroR(memh->name,"end corrupt");
 624                 name = check_memlist(memh);
 625                 if (name != 0){
 626                         if (name != memh->name) MemorY_ErroR(name,"is also corrupt");
 627                 }
 628         } else{
 629                 error = -1;
 630                 name = check_memlist(memh);
 631                 if (name == 0)
 632                         MemorY_ErroR("free","pointer not in memlist");
 633                 else
 634                         MemorY_ErroR(name,"error in header");
 635         }
 636
 637         totblock--;
 638         /* here a DUMP should happen */
 639
 640         mem_unlock_thread();
 641
 642         return(error);
 643 }
 644
 645 /* --------------------------------------------------------------------- */
 646 /* local functions                                                       */
 647 /* --------------------------------------------------------------------- */
 648
 649 static void addtail(volatile localListBase *listbase, void *vlink)
 650 {
 651         struct localLink *link= vlink;
 652
 653         if (link == 0) return;
 654         if (listbase == 0) return;
 655
 656         link->next = 0;
 657         link->prev = listbase->last;
 658
 659         if (listbase->last) ((struct localLink *)listbase->last)->next = link;
 660         if (listbase->first == 0) listbase->first = link;
 661         listbase->last = link;
 662 }
 663
 664 static void remlink(volatile localListBase *listbase, void *vlink)
 665 {
 666         struct localLink *link= vlink;
 667
 668         if (link == 0) return;
 669         if (listbase == 0) return;
 670
 671         if (link->next) link->next->prev = link->prev;
 672         if (link->prev) link->prev->next = link->next;
 673
 674         if (listbase->last == link) listbase->last = link->prev;
 675         if (listbase->first == link) listbase->first = link->next;
 676 }
 677
 678 static void rem_memblock(MemHead *memh)
 679 {
 680     remlink(membase,&memh->next);
 681     if (memh->prev) {
 682         if (memh->next)
 683                         MEMNEXT(memh->prev)->nextname = MEMNEXT(memh->next)->name;
 684         else
 685                         MEMNEXT(memh->prev)->nextname = NULL;
 686     }
 687
 688     totblock--;
 689     mem_in_use -= memh->len;
 690
 691     if(memh->mmap) {
 692         mmap_in_use -= memh->len;
 693         if (munmap(memh, memh->len + sizeof(MemHead) + sizeof(MemTail)))
 694             printf("Couldn't unmap memory %s\n", memh->name);
 695     }
 696         else {
 697                 if(malloc_debug_memset && memh->len)
 698                         memset(memh+1, 255, memh->len);
 699         free(memh);
 700         }
 701 }
 702
 703 static void MemorY_ErroR(const char *block, const char *error)
 704 {
 705         print_error("Memoryblock %s: %s\n",block, error);
 706 }
 707
 708 static const char *check_memlist(MemHead *memh)
 709 {
 710         MemHead *forw,*back,*forwok,*backok;
 711         const char *name;
 712
 713         forw = membase->first;
 714         if (forw) forw = MEMNEXT(forw);
 715         forwok = 0;
 716         while(forw){
 717                 if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
 718                 forwok = forw;
 719                 if (forw->next) forw = MEMNEXT(forw->next);
 720                 else forw = 0;
 721         }
 722
 723         back = (MemHead *) membase->last;
 724         if (back) back = MEMNEXT(back);
 725         backok = 0;
 726         while(back){
 727                 if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
 728                 backok = back;
 729                 if (back->prev) back = MEMNEXT(back->prev);
 730                 else back = 0;
 731         }
 732
 733         if (forw != back) return ("MORE THAN 1 MEMORYBLOCK CORRUPT");
 734
 735         if (forw == 0 && back == 0){
 736                 /* geen foute headers gevonden dan maar op zoek naar memblock*/
 737
 738                 forw = membase->first;
 739                 if (forw) forw = MEMNEXT(forw);
 740                 forwok = 0;
 741                 while(forw){
 742                         if (forw == memh) break;
 743                         if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
 744                         forwok = forw;
 745                         if (forw->next) forw = MEMNEXT(forw->next);
 746                         else forw = 0;
 747                 }
 748                 if (forw == 0) return (0);
 749
 750                 back = (MemHead *) membase->last;
 751                 if (back) back = MEMNEXT(back);
 752                 backok = 0;
 753                 while(back){
 754                         if (back == memh) break;
 755                         if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
 756                         backok = back;
 757                         if (back->prev) back = MEMNEXT(back->prev);
 758                         else back = 0;
 759                 }
 760         }
 761
 762         if (forwok) name = forwok->nextname;
 763         else name = "No name found";
 764
 765         if (forw == memh){
 766                 /* voor alle zekerheid wordt dit block maar uit de lijst gehaald */
 767                 if (forwok){
 768                         if (backok){
 769                                 forwok->next = (MemHead *)&backok->next;
 770                                 backok->prev = (MemHead *)&forwok->next;
 771                                 forwok->nextname = backok->name;
 772                         } else{
 773                                 forwok->next = 0;
 774                                 membase->last = (struct localLink *) &forwok->next;
 775 /*                              membase->last = (struct Link *) &forwok->next; */
 776                         }
 777                 } else{
 778                         if (backok){
 779                                 backok->prev = 0;
 780                                 membase->first = &backok->next;
 781                         } else{
 782                                 membase->first = membase->last = 0;
 783                         }
 784                 }
 785         } else{
 786                 MemorY_ErroR(name,"Additional error in header");
 787                 return("Additional error in header");
 788         }
 789
 790         return(name);
 791 }
 792
 793 uintptr_t MEM_get_memory_in_use(void)
 794 {
 795         uintptr_t _mem_in_use;
 796
 797         mem_lock_thread();
 798         _mem_in_use= mem_in_use;
 799         mem_unlock_thread();
 800
 801         return _mem_in_use;
 802 }
 803
 804 uintptr_t MEM_get_mapped_memory_in_use(void)
 805 {
 806         uintptr_t _mmap_in_use;
 807
 808         mem_lock_thread();
 809         _mmap_in_use= mmap_in_use;
 810         mem_unlock_thread();
 811
 812         return _mmap_in_use;
 813 }
 814
 815 int MEM_get_memory_blocks_in_use(void)
 816 {
 817         int _totblock;
 818
 819         mem_lock_thread();
 820         _totblock= totblock;
 821         mem_unlock_thread();
 822
 823         return _totblock;
 824 }
 825
 826 /* eof */