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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 /* --------------------------------------------------------------------- */
  52 /* Data definition                                                       */
  53 /* --------------------------------------------------------------------- */
  54 /* all memory chunks are put in linked lists */
  55 typedef struct localLink
  56 {
  57         struct localLink *next,*prev;
  58 } localLink;
  59
  60 typedef struct localListBase
  61 {
  62         void *first, *last;
  63 } localListBase;
  64
  65         /* note: keep this struct aligned (e.g., irix/gcc) - Hos */
  66 typedef struct MemHead {
  67         int tag1;
  68         int len;
  69         struct MemHead *next,*prev;
  70         const char * name;
  71         const char * nextname;
  72         int tag2;
  73         int mmap;       /* if true, memory was mmapped */
  74 } MemHead;
  75
  76 typedef struct MemTail {
  77         int tag3, pad;
  78 } MemTail;
  79
  80
  81 /* --------------------------------------------------------------------- */
  82 /* local functions                                                       */
  83 /* --------------------------------------------------------------------- */
  84
  85 static void addtail(volatile localListBase *listbase, void *vlink);
  86 static void remlink(volatile localListBase *listbase, void *vlink);
  87 static void rem_memblock(MemHead *memh);
  88 static void MemorY_ErroR(const char *block, const char *error);
  89 static const char *check_memlist(MemHead *memh);
  90
  91 /* --------------------------------------------------------------------- */
  92 /* locally used defines                                                  */
  93 /* --------------------------------------------------------------------- */
  94
  95 #if defined( __sgi) || defined (__sun) || defined (__sun__) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || (defined (__APPLE__) && !defined(__LITTLE_ENDIAN__))
  96 #define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
  97 #else
  98 #define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
  99 #endif
 100
 101 #define MEMTAG1 MAKE_ID('M', 'E', 'M', 'O')
 102 #define MEMTAG2 MAKE_ID('R', 'Y', 'B', 'L')
 103 #define MEMTAG3 MAKE_ID('O', 'C', 'K', '!')
 104 #define MEMFREE MAKE_ID('F', 'R', 'E', 'E')
 105
 106 #define MEMNEXT(x) ((MemHead *)(((char *) x) - ((char *) & (((MemHead *)0)->next))))
 107
 108 /* --------------------------------------------------------------------- */
 109 /* vars                                                                  */
 110 /* --------------------------------------------------------------------- */
 111
 112
 113 static volatile int totblock= 0;
 114 static volatile uintptr_t mem_in_use= 0, mmap_in_use= 0;
 115
 116 static volatile struct localListBase _membase;
 117 static volatile struct localListBase *membase = &_membase;
 118 static void (*error_callback)(char *) = NULL;
 119 static void (*thread_lock_callback)(void) = NULL;
 120 static void (*thread_unlock_callback)(void) = NULL;
 121
 122 static int malloc_debug_memset= 0;
 123
 124 #ifdef malloc
 125 #undef malloc
 126 #endif
 127
 128 #ifdef calloc
 129 #undef calloc
 130 #endif
 131
 132 #ifdef free
 133 #undef free
 134 #endif
 135
 136
 137 /* --------------------------------------------------------------------- */
 138 /* implementation                                                        */
 139 /* --------------------------------------------------------------------- */
 140
 141 static void print_error(const char *str, ...)
 142 {
 143         char buf[1024];
 144         va_list ap;
 145
 146         va_start(ap, str);
 147         vsprintf(buf, str, ap);
 148         va_end(ap);
 149
 150         if (error_callback) error_callback(buf);
 151 }
 152
 153 static void mem_lock_thread()
 154 {
 155         if (thread_lock_callback)
 156                 thread_lock_callback();
 157 }
 158
 159 static void mem_unlock_thread()
 160 {
 161         if (thread_unlock_callback)
 162                 thread_unlock_callback();
 163 }
 164
 165 int MEM_check_memory_integrity()
 166 {
 167         const char* err_val = NULL;
 168         MemHead* listend;
 169         /* check_memlist starts from the front, and runs until it finds
 170          * the requested chunk. For this test, that's the last one. */
 171         listend = membase->last;
 172
 173         err_val = check_memlist(listend);
 174
 175         if (err_val == 0) return 0;
 176         return 1;
 177 }
 178
 179
 180 void MEM_set_error_callback(void (*func)(char *))
 181 {
 182         error_callback = func;
 183 }
 184
 185 void MEM_set_lock_callback(void (*lock)(void), void (*unlock)(void))
 186 {
 187         thread_lock_callback = lock;
 188         thread_unlock_callback = unlock;
 189 }
 190
 191 void MEM_set_memory_debug(void)
 192 {
 193         malloc_debug_memset= 1;
 194 }
 195
 196 int MEM_allocN_len(void *vmemh)
 197 {
 198         if (vmemh) {
 199                 MemHead *memh= vmemh;
 200
 201                 memh--;
 202                 return memh->len;
 203         } else
 204                 return 0;
 205 }
 206
 207 void *MEM_dupallocN(void *vmemh)
 208 {
 209         void *newp= NULL;
 210
 211         if (vmemh) {
 212                 MemHead *memh= vmemh;
 213                 memh--;
 214
 215                 if(memh->mmap)
 216                         newp= MEM_mapallocN(memh->len, "dupli_mapalloc");
 217                 else
 218                         newp= MEM_mallocN(memh->len, "dupli_alloc");
 219
 220                 if (newp == NULL) return NULL;
 221
 222                 memcpy(newp, vmemh, memh->len);
 223         }
 224
 225         return newp;
 226 }
 227
 228 static void make_memhead_header(MemHead *memh, unsigned int len, const char *str)
 229 {
 230         MemTail *memt;
 231
 232         memh->tag1 = MEMTAG1;
 233         memh->name = str;
 234         memh->nextname = 0;
 235         memh->len = len;
 236         memh->mmap = 0;
 237         memh->tag2 = MEMTAG2;
 238
 239         memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + len);
 240         memt->tag3 = MEMTAG3;
 241
 242         addtail(membase,&memh->next);
 243         if (memh->next) memh->nextname = MEMNEXT(memh->next)->name;
 244
 245         totblock++;
 246         mem_in_use += len;
 247 }
 248
 249 void *MEM_mallocN(unsigned int len, const char *str)
 250 {
 251         MemHead *memh;
 252
 253         mem_lock_thread();
 254
 255         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 256
 257         memh= (MemHead *)malloc(len+sizeof(MemHead)+sizeof(MemTail));
 258
 259         if(memh) {
 260                 make_memhead_header(memh, len, str);
 261                 mem_unlock_thread();
 262                 if(malloc_debug_memset && len)
 263                         memset(memh+1, 255, len);
 264                 return (++memh);
 265         }
 266         mem_unlock_thread();
 267         print_error("Malloc returns nill: len=%d in %s, total %u\n",len, str, mem_in_use);
 268         return NULL;
 269 }
 270
 271 void *MEM_callocN(unsigned int len, const char *str)
 272 {
 273         MemHead *memh;
 274
 275         mem_lock_thread();
 276
 277         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 278
 279         memh= (MemHead *)calloc(len+sizeof(MemHead)+sizeof(MemTail),1);
 280
 281         if(memh) {
 282                 make_memhead_header(memh, len, str);
 283                 mem_unlock_thread();
 284                 return (++memh);
 285         }
 286         mem_unlock_thread();
 287         print_error("Calloc returns nill: len=%d in %s, total %u\n",len, str, mem_in_use);
 288         return 0;
 289 }
 290
 291 /* note; mmap returns zero'd memory */
 292 void *MEM_mapallocN(unsigned int len, const char *str)
 293 {
 294         MemHead *memh;
 295
 296         mem_lock_thread();
 297
 298         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
 299
 300 #ifdef __sgi
 301         {
 302 #include <fcntl.h>
 303
 304           int fd;
 305           fd = open("/dev/zero", O_RDWR);
 306
 307           memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
 308                      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 309           close(fd);
 310         }
 311 #else
 312         memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
 313                    PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
 314 #endif
 315
 316         if(memh!=(MemHead *)-1) {
 317                 make_memhead_header(memh, len, str);
 318                 memh->mmap= 1;
 319                 mmap_in_use += len;
 320                 mem_unlock_thread();
 321                 return (++memh);
 322         }
 323         else {
 324                 mem_unlock_thread();
 325                 print_error("Mapalloc returns nill, fallback to regular malloc: len=%d in %s, total %u\n",len, str, mmap_in_use);
 326                 return MEM_callocN(len, str);
 327         }
 328 }
 329
 330 /* Memory statistics print */
 331 typedef struct MemPrintBlock {
 332         const char *name;
 333         uintptr_t len;
 334         int items;
 335 } MemPrintBlock;
 336
 337 static int compare_name(const void *p1, const void *p2)
 338 {
 339         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
 340         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
 341
 342         return strcmp(pb1->name, pb2->name);
 343 }
 344
 345 static int compare_len(const void *p1, const void *p2)
 346 {
 347         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
 348         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
 349
 350         if(pb1->len < pb2->len)
 351                 return 1;
 352         else if(pb1->len == pb2->len)
 353                 return 0;
 354         else
 355                 return -1;
 356 }
 357
 358 void MEM_printmemlist_stats()
 359 {
 360         MemHead *membl;
 361         MemPrintBlock *pb, *printblock;
 362         int totpb, a, b;
 363
 364         mem_lock_thread();
 365
 366         /* put memory blocks into array */
 367         printblock= malloc(sizeof(MemPrintBlock)*totblock);
 368
 369         pb= printblock;
 370         totpb= 0;
 371
 372         membl = membase->first;
 373         if (membl) membl = MEMNEXT(membl);
 374
 375         while(membl) {
 376                 pb->name= membl->name;
 377                 pb->len= membl->len;
 378                 pb->items= 1;
 379
 380                 totpb++;
 381                 pb++;
 382
 383                 if(membl->next)
 384                         membl= MEMNEXT(membl->next);
 385                 else break;
 386         }
 387
 388         /* sort by name and add together blocks with the same name */
 389         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_name);
 390         for(a=0, b=0; a<totpb; a++) {
 391                 if(a == b) {
 392                         continue;
 393                 }
 394                 else if(strcmp(printblock[a].name, printblock[b].name) == 0) {
 395                         printblock[b].len += printblock[a].len;
 396                         printblock[b].items++;
 397                 }
 398                 else {
 399                         b++;
 400                         memcpy(&printblock[b], &printblock[a], sizeof(MemPrintBlock));
 401                 }
 402         }
 403         totpb= b+1;
 404
 405         /* sort by length and print */
 406         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_len);
 407         printf("\ntotal memory len: %.3f MB\n", (double)mem_in_use/(double)(1024*1024));
 408         for(a=0, pb=printblock; a<totpb; a++, pb++)
 409                 printf("%s items: %d, len: %.3f MB\n", pb->name, pb->items, (double)pb->len/(double)(1024*1024));
 410
 411         free(printblock);
 412
 413         mem_unlock_thread();
 414 }
 415
 416 /* Prints in python syntax for easy */
 417 static void MEM_printmemlist_internal( int pydict )
 418 {
 419         MemHead *membl;
 420
 421         mem_lock_thread();
 422
 423         membl = membase->first;
 424         if (membl) membl = MEMNEXT(membl);
 425
 426         if (pydict) {
 427                 print_error("# membase_debug.py\n");
 428                 print_error("membase = [\\\n");
 429         }
 430         while(membl) {
 431                 if (pydict) {
 432                         fprintf(stderr, "{'len':%i, 'name':'''%s''', 'pointer':'%p'},\\\n", membl->len, membl->name, membl+1);
 433                 } else {
 434                         print_error("%s len: %d %p\n",membl->name,membl->len, membl+1);
 435                 }
 436                 if(membl->next)
 437                         membl= MEMNEXT(membl->next);
 438                 else break;
 439         }
 440         if (pydict) {
 441                 fprintf(stderr, "]\n\n");
 442                 fprintf(stderr,
 443 "mb_userinfo = {}\n"
 444 "totmem = 0\n"
 445 "for mb_item in membase:\n"
 446 "\tmb_item_user_size = mb_userinfo.setdefault(mb_item['name'], [0,0])\n"
 447 "\tmb_item_user_size[0] += 1 # Add a user\n"
 448 "\tmb_item_user_size[1] += mb_item['len'] # Increment the size\n"
 449 "\ttotmem += mb_item['len']\n"
 450 "print '(membase) items:', len(membase), '| unique-names:', len(mb_userinfo), '| total-mem:', totmem\n"
 451 "mb_userinfo_sort = mb_userinfo.items()\n"
 452 "for sort_name, sort_func in (('size', lambda a: -a[1][1]), ('users', lambda a: -a[1][0]), ('name', lambda a: a[0])):\n"
 453 "\tprint '\\nSorting by:', sort_name\n"
 454 "\tmb_userinfo_sort.sort(key = sort_func)\n"
 455 "\tfor item in mb_userinfo_sort:\n"
 456 "\t\tprint 'name:%%s, users:%%i, len:%%i' %% (item[0], item[1][0], item[1][1])\n"
 457                 );
 458         }
 459
 460         mem_unlock_thread();
 461 }
 462
 463 void MEM_printmemlist( void ) {
 464         MEM_printmemlist_internal(0);
 465 }
 466 void MEM_printmemlist_pydict( void ) {
 467         MEM_printmemlist_internal(1);
 468 }
 469
 470 short MEM_freeN(void *vmemh)            /* anders compileertie niet meer */
 471 {
 472         short error = 0;
 473         MemTail *memt;
 474         MemHead *memh= vmemh;
 475         const char *name;
 476
 477         if (memh == NULL){
 478                 MemorY_ErroR("free","attempt to free NULL pointer");
 479                 /* print_error(err_stream, "%d\n", (memh+4000)->tag1); */
 480                 return(-1);
 481         }
 482
 483         if(sizeof(intptr_t)==8) {
 484                 if (((intptr_t) memh) & 0x7) {
 485                         MemorY_ErroR("free","attempt to free illegal pointer");
 486                         return(-1);
 487                 }
 488         }
 489         else {
 490                 if (((intptr_t) memh) & 0x3) {
 491                         MemorY_ErroR("free","attempt to free illegal pointer");
 492                         return(-1);
 493                 }
 494         }
 495
 496         memh--;
 497         if(memh->tag1 == MEMFREE && memh->tag2 == MEMFREE) {
 498                 MemorY_ErroR(memh->name,"double free");
 499                 return(-1);
 500         }
 501
 502         mem_lock_thread();
 503
 504         if ((memh->tag1 == MEMTAG1) && (memh->tag2 == MEMTAG2) && ((memh->len & 0x3) == 0)) {
 505                 memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + memh->len);
 506                 if (memt->tag3 == MEMTAG3){
 507
 508                         memh->tag1 = MEMFREE;
 509                         memh->tag2 = MEMFREE;
 510                         memt->tag3 = MEMFREE;
 511                         /* after tags !!! */
 512                         rem_memblock(memh);
 513
 514                         mem_unlock_thread();
 515
 516                         return(0);
 517                 }
 518                 error = 2;
 519                 MemorY_ErroR(memh->name,"end corrupt");
 520                 name = check_memlist(memh);
 521                 if (name != 0){
 522                         if (name != memh->name) MemorY_ErroR(name,"is also corrupt");
 523                 }
 524         } else{
 525                 error = -1;
 526                 name = check_memlist(memh);
 527                 if (name == 0)
 528                         MemorY_ErroR("free","pointer not in memlist");
 529                 else
 530                         MemorY_ErroR(name,"error in header");
 531         }
 532
 533         totblock--;
 534         /* here a DUMP should happen */
 535
 536         mem_unlock_thread();
 537
 538         return(error);
 539 }
 540
 541 /* --------------------------------------------------------------------- */
 542 /* local functions                                                       */
 543 /* --------------------------------------------------------------------- */
 544
 545 static void addtail(volatile localListBase *listbase, void *vlink)
 546 {
 547         struct localLink *link= vlink;
 548
 549         if (link == 0) return;
 550         if (listbase == 0) return;
 551
 552         link->next = 0;
 553         link->prev = listbase->last;
 554
 555         if (listbase->last) ((struct localLink *)listbase->last)->next = link;
 556         if (listbase->first == 0) listbase->first = link;
 557         listbase->last = link;
 558 }
 559
 560 static void remlink(volatile localListBase *listbase, void *vlink)
 561 {
 562         struct localLink *link= vlink;
 563
 564         if (link == 0) return;
 565         if (listbase == 0) return;
 566
 567         if (link->next) link->next->prev = link->prev;
 568         if (link->prev) link->prev->next = link->next;
 569
 570         if (listbase->last == link) listbase->last = link->prev;
 571         if (listbase->first == link) listbase->first = link->next;
 572 }
 573
 574 static void rem_memblock(MemHead *memh)
 575 {
 576     remlink(membase,&memh->next);
 577     if (memh->prev) {
 578         if (memh->next)
 579                         MEMNEXT(memh->prev)->nextname = MEMNEXT(memh->next)->name;
 580         else
 581                         MEMNEXT(memh->prev)->nextname = NULL;
 582     }
 583
 584     totblock--;
 585     mem_in_use -= memh->len;
 586
 587     if(memh->mmap) {
 588         mmap_in_use -= memh->len;
 589         if (munmap(memh, memh->len + sizeof(MemHead) + sizeof(MemTail)))
 590             printf("Couldn't unmap memory %s\n", memh->name);
 591     }
 592     else {
 593                 if(malloc_debug_memset && memh->len)
 594                         memset(memh+1, 255, memh->len);
 595         free(memh);
 596         }
 597 }
 598
 599 static void MemorY_ErroR(const char *block, const char *error)
 600 {
 601         print_error("Memoryblock %s: %s\n",block, error);
 602 }
 603
 604 static const char *check_memlist(MemHead *memh)
 605 {
 606         MemHead *forw,*back,*forwok,*backok;
 607         const char *name;
 608
 609         forw = membase->first;
 610         if (forw) forw = MEMNEXT(forw);
 611         forwok = 0;
 612         while(forw){
 613                 if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
 614                 forwok = forw;
 615                 if (forw->next) forw = MEMNEXT(forw->next);
 616                 else forw = 0;
 617         }
 618
 619         back = (MemHead *) membase->last;
 620         if (back) back = MEMNEXT(back);
 621         backok = 0;
 622         while(back){
 623                 if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
 624                 backok = back;
 625                 if (back->prev) back = MEMNEXT(back->prev);
 626                 else back = 0;
 627         }
 628
 629         if (forw != back) return ("MORE THAN 1 MEMORYBLOCK CORRUPT");
 630
 631         if (forw == 0 && back == 0){
 632                 /* geen foute headers gevonden dan maar op zoek naar memblock*/
 633
 634                 forw = membase->first;
 635                 if (forw) forw = MEMNEXT(forw);
 636                 forwok = 0;
 637                 while(forw){
 638                         if (forw == memh) break;
 639                         if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
 640                         forwok = forw;
 641                         if (forw->next) forw = MEMNEXT(forw->next);
 642                         else forw = 0;
 643                 }
 644                 if (forw == 0) return (0);
 645
 646                 back = (MemHead *) membase->last;
 647                 if (back) back = MEMNEXT(back);
 648                 backok = 0;
 649                 while(back){
 650                         if (back == memh) break;
 651                         if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
 652                         backok = back;
 653                         if (back->prev) back = MEMNEXT(back->prev);
 654                         else back = 0;
 655                 }
 656         }
 657
 658         if (forwok) name = forwok->nextname;
 659         else name = "No name found";
 660
 661         if (forw == memh){
 662                 /* voor alle zekerheid wordt dit block maar uit de lijst gehaald */
 663                 if (forwok){
 664                         if (backok){
 665                                 forwok->next = (MemHead *)&backok->next;
 666                                 backok->prev = (MemHead *)&forwok->next;
 667                                 forwok->nextname = backok->name;
 668                         } else{
 669                                 forwok->next = 0;
 670                                 membase->last = (struct localLink *) &forwok->next;
 671 /*                              membase->last = (struct Link *) &forwok->next; */
 672                         }
 673                 } else{
 674                         if (backok){
 675                                 backok->prev = 0;
 676                                 membase->first = &backok->next;
 677                         } else{
 678                                 membase->first = membase->last = 0;
 679                         }
 680                 }
 681         } else{
 682                 MemorY_ErroR(name,"Additional error in header");
 683                 return("Additional error in header");
 684         }
 685
 686         return(name);
 687 }
 688
 689 uintptr_t MEM_get_memory_in_use(void)
 690 {
 691         uintptr_t _mem_in_use;
 692
 693         mem_lock_thread();
 694         _mem_in_use= mem_in_use;
 695         mem_unlock_thread();
 696
 697         return _mem_in_use;
 698 }
 699
 700 uintptr_t MEM_get_mapped_memory_in_use(void)
 701 {
 702         uintptr_t _mmap_in_use;
 703
 704         mem_lock_thread();
 705         _mmap_in_use= mmap_in_use;
 706         mem_unlock_thread();
 707
 708         return _mmap_in_use;
 709 }
 710
 711 int MEM_get_memory_blocks_in_use(void)
 712 {
 713         int _totblock;
 714
 715         mem_lock_thread();
 716         _totblock= totblock;
 717         mem_unlock_thread();
 718
 719         return _totblock;
 720 }
 721
 722 /* eof */