src/xbt/mmalloc/mm_legacy.c

   1 /* Copyright (c) 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 /* Redefine the classical malloc/free/realloc functions so that they fit well in the mmalloc framework */
   8
   9 #include "mmprivate.h"
  10 #include "gras_config.h"
  11 #include <math.h>
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_mm_legacy, xbt,
  14                                 "Logging specific to mm_legacy in mmalloc");
  15
  16 static void *__mmalloc_current_heap = NULL;     /* The heap we are currently using. */
  17
  18 #include "xbt_modinter.h"
  19
  20 void *mmalloc_get_current_heap(void)
  21 {
  22   return __mmalloc_current_heap;
  23 }
  24
  25 void mmalloc_set_current_heap(void *new_heap)
  26 {
  27   __mmalloc_current_heap = new_heap;
  28 }
  29
  30 #ifdef MMALLOC_WANT_OVERIDE_LEGACY
  31 void *malloc(size_t n)
  32 {
  33   void *mdp = __mmalloc_current_heap;
  34 #ifdef HAVE_MMAP
  35   if (!mdp)
  36     mmalloc_preinit();
  37 #endif
  38   LOCK(mdp);
  39   void *ret = mmalloc(mdp, n);
  40   UNLOCK(mdp);
  41
  42   return ret;
  43 }
  44
  45 void *calloc(size_t nmemb, size_t size)
  46 {
  47   size_t total_size = nmemb * size;
  48   void *mdp = __mmalloc_current_heap;
  49 #ifdef HAVE_MMAP
  50   if (!mdp)
  51     mmalloc_preinit();
  52 #endif
  53   LOCK(mdp);
  54   void *ret = mmalloc(mdp, total_size);
  55   UNLOCK(mdp);
  56
  57   /* Fill the allocated memory with zeroes to mimic calloc behaviour */
  58   memset(ret, '\0', total_size);
  59
  60   return ret;
  61 }
  62
  63 void *realloc(void *p, size_t s)
  64 {
  65   void *ret = NULL;
  66   void *mdp = __mmalloc_current_heap;
  67 #ifdef HAVE_MMAP
  68   if (!mdp)
  69     mmalloc_preinit();
  70 #endif
  71   LOCK(mdp);
  72   if (s) {
  73     if (p)
  74       ret = mrealloc(mdp, p, s);
  75     else
  76       ret = mmalloc(mdp, s);
  77   } else {
  78     mfree(mdp, p);
  79   }
  80   UNLOCK(mdp);
  81
  82   return ret;
  83 }
  84
  85 void free(void *p)
  86 {
  87   void *mdp = __mmalloc_current_heap;
  88 #ifdef HAVE_GTNETS
  89   if(!mdp) return;
  90 #endif
  91   LOCK(mdp);
  92   mfree(mdp, p);
  93   UNLOCK(mdp);
  94 }
  95 #endif
  96
  97 /* Make sure it works with md==NULL */
  98
  99 /* Safety gap from the heap's break address.
 100  * Try to increase this first if you experience strange errors under
 101  * valgrind. */
 102 #define HEAP_OFFSET   (128UL<<20)
 103
 104 void *mmalloc_get_default_md(void)
 105 {
 106   xbt_assert(__mmalloc_default_mdp);
 107   return __mmalloc_default_mdp;
 108 }
 109
 110 static void mmalloc_fork_prepare(void)
 111 {
 112   struct mdesc* mdp = NULL;
 113   if ((mdp =__mmalloc_default_mdp)){
 114     while(mdp){
 115       LOCK(mdp);
 116       if(mdp->fd >= 0){
 117         mdp->refcount++;
 118       }
 119       mdp = mdp->next_mdesc;
 120     }
 121   }
 122 }
 123
 124 static void mmalloc_fork_parent(void)
 125 {
 126   struct mdesc* mdp = NULL;
 127   if ((mdp =__mmalloc_default_mdp)){
 128     while(mdp){
 129       if(mdp->fd < 0)
 130         UNLOCK(mdp);
 131       mdp = mdp->next_mdesc;
 132     }
 133   }
 134 }
 135
 136 static void mmalloc_fork_child(void)
 137 {
 138   struct mdesc* mdp = NULL;
 139   if ((mdp =__mmalloc_default_mdp)){
 140     while(mdp){
 141       UNLOCK(mdp);
 142       mdp = mdp->next_mdesc;
 143     }
 144   }
 145 }
 146
 147 /* Initialize the default malloc descriptor. */
 148 void mmalloc_preinit(void)
 149 {
 150   int res;
 151   if (!__mmalloc_default_mdp) {
 152     unsigned long mask = ~((unsigned long)getpagesize() - 1);
 153     void *addr = (void*)(((unsigned long)sbrk(0) + HEAP_OFFSET) & mask);
 154     __mmalloc_default_mdp = mmalloc_attach(-1, addr);
 155     /* Fixme? only the default mdp in protected against forks */
 156     res = xbt_os_thread_atfork(mmalloc_fork_prepare,
 157                                mmalloc_fork_parent, mmalloc_fork_child);
 158     if (res != 0)
 159       THROWF(system_error,0,"xbt_os_thread_atfork() failed: return value %d",res);
 160   }
 161   xbt_assert(__mmalloc_default_mdp != NULL);
 162 }
 163
 164 void mmalloc_postexit(void)
 165 {
 166   /* Do not detach the default mdp or ldl won't be able to free the memory it allocated since we're in memory */
 167   //  mmalloc_detach(__mmalloc_default_mdp);
 168   mmalloc_pre_detach(__mmalloc_default_mdp);
 169 }
 170
 171 int mmalloc_compare_heap(void *h1, void *h2){
 172
 173   if(h1 == NULL && h2 == NULL){
 174     XBT_DEBUG("Malloc descriptors null");
 175     return 0;
 176   }
 177
 178   /* Heapstats */
 179
 180   struct mstats ms1 = mmstats(h1);
 181   struct mstats ms2 = mmstats(h2);
 182
 183   if(ms1.chunks_used !=  ms2.chunks_used){
 184     XBT_DEBUG("Different chunks allocated by the user : %Zu - %Zu", ms1.chunks_used, ms2.chunks_used);
 185     return 1;
 186   }
 187
 188   if(ms1.bytes_used !=  ms2.bytes_used){
 189     XBT_DEBUG("Different byte total of user-allocated chunks : %Zu - %Zu", ms1.bytes_used, ms2.bytes_used);
 190     return 1;
 191   }
 192
 193   if(ms1.bytes_free !=  ms2.bytes_free){
 194     XBT_DEBUG("Different byte total of chunks in the free list : %Zu - %Zu", ms1.bytes_free, ms2.bytes_free);
 195     return 1;
 196   }
 197
 198   if(ms1.chunks_free !=  ms2.chunks_free){
 199     XBT_DEBUG("Different chunks in the free list : %Zu - %Zu", ms1.chunks_free, ms2.chunks_free);
 200     return 1;
 201   }
 202
 203   struct mdesc *mdp1, *mdp2;
 204   mdp1 = MD_TO_MDP(h1);
 205   mdp2 = MD_TO_MDP(h2);
 206
 207   return mmalloc_compare_mdesc(mdp1, mdp2);
 208
 209 }
 210
 211 int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
 212
 213   if(mdp1->headersize != mdp2->headersize){
 214     XBT_DEBUG("Different size of the file header for the mapped files");
 215     return 1;
 216   }
 217
 218   if(mdp1->refcount != mdp2->refcount){
 219     XBT_DEBUG("Different number of processes that attached the heap");
 220     return 1;
 221   }
 222
 223   if(strcmp(mdp1->magic, mdp2->magic) != 0){
 224     XBT_DEBUG("Different magic number");
 225     return 1;
 226   }
 227
 228   if(mdp1->flags != mdp2->flags){
 229     XBT_DEBUG("Different flags");
 230     return 1;
 231   }
 232
 233   if(mdp1->heapsize != mdp2->heapsize){
 234     XBT_DEBUG("Different number of info entries");
 235     return 1;
 236   }
 237
 238   //XBT_DEBUG("Heap size : %Zu", mdp1->heapsize);
 239
 240   if(mdp1->heapbase != mdp2->heapbase){
 241     XBT_DEBUG("Different first block of the heap");
 242     return 1;
 243   }
 244
 245
 246   if(mdp1->heapindex != mdp2->heapindex){
 247     XBT_DEBUG("Different index for the heap table : %Zu - %Zu", mdp1->heapindex, mdp2->heapindex);
 248     return 1;
 249   }
 250
 251   //XBT_DEBUG("Heap index : %Zu", mdp1->heapindex);
 252
 253   if(mdp1->base != mdp2->base){
 254     XBT_DEBUG("Different base address of the memory region");
 255     return 1;
 256   }
 257
 258   if(mdp1->breakval != mdp2->breakval){
 259     XBT_DEBUG("Different current location in the memory region");
 260     return 1;
 261   }
 262
 263   if(mdp1->top != mdp2->top){
 264     XBT_DEBUG("Different end of the current location in the memory region");
 265     return 1;
 266   }
 267
 268   if(mdp1->heaplimit != mdp2->heaplimit){
 269     XBT_DEBUG("Different limit of valid info table indices");
 270     return 1;
 271   }
 272
 273   //XBT_DEBUG("Heap limit : %Zu", mdp1->heaplimit);
 274
 275
 276   if(mdp1->fd != mdp2->fd){
 277     XBT_DEBUG("Different file descriptor for the file to which this malloc heap is mapped");
 278     return 1;
 279   }
 280
 281   if(mdp1->saved_errno != mdp2->saved_errno){
 282     XBT_DEBUG("Different errno");
 283     return 1;
 284   }
 285
 286   if(mdp1->version != mdp2->version){
 287     XBT_DEBUG("Different version of the mmalloc package");
 288     return 1;
 289   }
 290
 291
 292   size_t block_free1, block_free2 , next_block_free, first_block_free, block_free ;
 293   size_t i, j;
 294   void *addr_block1, *addr_block2;
 295   size_t frag_size;
 296
 297
 298   /* Search index of the first free block */
 299
 300   block_free1 = mdp1->heapindex;
 301   block_free2 = mdp2->heapindex;
 302
 303   while(mdp1->heapinfo[block_free1].free.prev != 0){
 304     block_free1 = mdp1->heapinfo[block_free1].free.prev;
 305   }
 306
 307   while(mdp2->heapinfo[block_free2].free.prev != 0){
 308     block_free2 = mdp1->heapinfo[block_free2].free.prev;
 309   }
 310
 311   if(block_free1 !=  block_free2){
 312     XBT_DEBUG("Different first free block");
 313     return 1;
 314   }
 315
 316   first_block_free = block_free1;
 317
 318   if(mdp1->heapinfo[first_block_free].free.size != mdp2->heapinfo[first_block_free].free.size){
 319     XBT_DEBUG("Different size (in blocks) of the first free cluster");
 320     return 1;
 321   }
 322
 323   /* Check busy blocks (circular checking)*/
 324
 325   i = first_block_free + mdp1->heapinfo[first_block_free].free.size;
 326
 327   if(mdp1->heapinfo[first_block_free].free.next != mdp2->heapinfo[first_block_free].free.next){
 328     XBT_DEBUG("Different next block free");
 329     return 1;
 330   }
 331
 332   block_free = first_block_free;
 333   next_block_free = mdp1->heapinfo[first_block_free].free.next;
 334
 335   //XBT_DEBUG("First block free : %Zu (size=%Zu), Next block free : %Zu", first_block_free, mdp1->heapinfo[block_free1].free.size, next_block_free);
 336
 337   if(next_block_free == 0)
 338     next_block_free = mdp1->heaplimit;
 339
 340
 341   while(i != first_block_free){
 342
 343     while(i<next_block_free){
 344
 345       if(mdp1->heapinfo[i].busy.type != mdp2->heapinfo[i].busy.type){
 346         XBT_DEBUG("Different type of busy block");
 347         return 1;
 348       }else{
 349
 350         addr_block1 = (char *)mdp1 + sizeof(struct mdesc) + ((i-1) * BLOCKSIZE);
 351         addr_block2 = (char *)mdp2 + sizeof(struct mdesc) + ((i-1) * BLOCKSIZE);
 352
 353         switch(mdp1->heapinfo[i].busy.type){
 354         case 0 :
 355           if(mdp1->heapinfo[i].busy.info.size != mdp2->heapinfo[i].busy.info.size){
 356             XBT_DEBUG("Different size of a large cluster");
 357             return 1;
 358           }else{
 359             if(memcmp(addr_block1, addr_block2, (mdp1->heapinfo[i].busy.info.size * BLOCKSIZE)) != 0){
 360               XBT_DEBUG("Different data in block %Zu", i);
 361               return 1;
 362             }
 363           }
 364           i = i+mdp1->heapinfo[i].busy.info.size;
 365           break;
 366         default :
 367           if(mdp1->heapinfo[i].busy.info.frag.nfree != mdp2->heapinfo[i].busy.info.frag.nfree){
 368             XBT_DEBUG("Different free fragments in the fragmented block %Zu", i);
 369             return 1;
 370           }else{
 371             if(mdp1->heapinfo[i].busy.info.frag.first != mdp2->heapinfo[i].busy.info.frag.first){
 372               XBT_DEBUG("Different first free fragments in the block %Zu", i);
 373               return 1;
 374             }else{
 375               frag_size = pow(2,mdp1->heapinfo[i].busy.type);
 376               for(j=0 ; j< (BLOCKSIZE/frag_size); j++){
 377                 if(memcmp((char *)addr_block1 + (j * frag_size), (char *)addr_block2 + (j * frag_size), frag_size) != 0){
 378                   XBT_DEBUG("Different data in fragment %d of block %Zu", j + 1, i);
 379                   return 1;
 380                 }
 381               }
 382             }
 383           }
 384           i++;
 385           break;
 386         }
 387
 388       }
 389     }
 390
 391     if(mdp1->heapinfo[block_free].free.next != mdp2->heapinfo[block_free].free.next){
 392       XBT_DEBUG("Different next block free");
 393       return 1;
 394     }
 395
 396     block_free = mdp1->heapinfo[block_free].free.next;
 397     next_block_free = mdp1->heapinfo[block_free].free.next;
 398     if(i != first_block_free){
 399       if(block_free != 0){
 400         if(mdp1->heapinfo[block_free].free.size != mdp2->heapinfo[block_free].free.size){
 401           XBT_DEBUG("Different size of block free");
 402           return 1;
 403         }
 404         i = block_free + mdp1->heapinfo[block_free].free.size;
 405       }else{
 406         i = 0;
 407       }
 408     }
 409
 410   }
 411
 412   return 0;
 413
 414
 415 }
 416
 417
 418
 419
 420