Changeset 172 for trunk/src


Ignore:
Timestamp:
Aug 7, 2008, 9:13:24 PM (16 years ago)
Author:
katerina
Message:

Documentation update, more dnmalloc fixes.

Location:
trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/dnmalloc.c

    r171 r172  
    11/* DistriNet malloc (dnmalloc): a more secure memory allocator.
    2    Copyright (C) 2005, Yves Younan, Wouter Joosen, Frank Piessens and Rainer Wichmann
     2   Copyright (C) 2005, Yves Younan, Wouter Joosen, Frank Piessens
     3   and Rainer Wichmann
     4
    35   The authors can be contacted by:
    46      Email: dnmalloc@fort-knox.org
    … …  
    2527*/
    2628
    27 /* Current version: dnmalloc 1.0  */
     29/* Current version: dnmalloc 1.0 */
    2830/* Includes arc4random from OpenBSD, which is under the BDS license     */
    2931
    … …  
    9395               works on OpenBSD.
    9496   
     97   further to 1.0:
     98   Valgrind client requests inserted (#define USE_VALGRIND)
     99   Fix malloc_consolidate (nextchunk->fd, nextchunk->bck may be NULL)
     100   Portability: minsize = 32 bit on 64bit architecture
     101   Minor cleanups
     102
    95103   There may be some bugs left in this version. please use with caution.
    96104*/
    … …  
    176184#endif
    177185
     186#ifdef USE_VALGRIND
     187#include <valgrind/memcheck.h>
     188#else
     189#define VALGRIND_FREELIKE_BLOCK(a,b)       ((void)0)
     190#define VALGRIND_MALLOCLIKE_BLOCK(a,b,c,d) ((void)0)
     191#define VALGRIND_CREATE_MEMPOOL(a,b,c)     ((void)0)
     192#define VALGRIND_MEMPOOL_ALLOC(a,b,c)      ((void)0)
     193#define VALGRIND_MEMPOOL_FREE(a,b)         ((void)0)
     194#define VALGRIND_DESTROY_MEMPOOL(a)        ((void)0)
     195#define VALGRIND_MAKE_MEM_DEFINED(a,b)     ((void)0)
     196#define VALGRIND_MAKE_MEM_UNDEFINED(a,b)   ((void)0)
     197#define VALGRIND_MAKE_MEM_NOACCESS(a,b)    ((void)0)
     198#endif
     199
    178200#if defined (__GNUC__) && __GNUC__ > 2
    179201# define LIKELY(expression) (__builtin_expect(!!(expression), 1))
    … …  
    277299#endif
    278300
    279 #if !defined(SAMHAIN)
    280301static void default_assert_handler(const char *error,
    281302                                   const char *file, int line)
    … …  
    300321  fputc('\n', stderr);
    301322#endif
     323  (void) line;
    302324  abort();
    303325}
    304326static assert_handler_tp *assert_handler = default_assert_handler;
    305 #else
    306 extern void safe_fatal(const char *error,
    307                        const char *file, int line);
    308 static assert_handler_tp *assert_handler = safe_fatal;
    309 #endif
     327
    310328
    311329#define assert(x)                               \
    … …  
    337355  /* #define DNMALLOC_DEBUG */
    338356
    339   /* Do some extra checks? */
     357  /* Do some extra checks? if not, covered by assrt()s */
    340358  /* #define DNMALLOC_CHECKS */
    341359
    … …  
    668686
    669687#ifndef HAVE_MMAP
    670 #  ifdef SAMHAIN
    671 #    error mmap not available, use --disable-dnmalloc
    672 #  else
    673 #    error HAVE_MMAP not defined, has your operating system mmap?
    674 #  endif
     688#  error HAVE_MMAP not defined, has your operating system mmap?
    675689#endif
    676690
    … …  
    18981912  guard_set_p = (char*)(chunk(P));                                \
    18991913  guard_set_p += request;                                         \
     1914  VALGRIND_MAKE_MEM_UNDEFINED(guard_set_p,GUARD_SIZE);            \
    19001915  guard_set_q = (char*)(guard);                                   \
    19011916  *guard_set_p = *guard_set_q; ++guard_set_p; ++guard_set_q;      \
    … …  
    19031918  *guard_set_p = *guard_set_q; ++guard_set_p; ++guard_set_q;      \
    19041919  *guard_set_p = *guard_set_q;                                    \
     1920  VALGRIND_MAKE_MEM_NOACCESS((((char*)chunk(P))+request),GUARD_SIZE);   \
    19051921  (P)->req = request
    19061922 
    19071923#define guard_check(guard, P)                                     \
    1908   assert(0 == memcmp((((char *)chunk(P))+(P)->req),(void*)(guard),GUARD_SIZE));
     1924  VALGRIND_MAKE_MEM_DEFINED((((char *)chunk(P))+(P)->req), GUARD_SIZE); \
     1925  assert(0 == memcmp((((char *)chunk(P))+(P)->req),(void*)(guard),GUARD_SIZE));\
     1926  VALGRIND_MAKE_MEM_NOACCESS((((char *)chunk(P))+(P)->req), GUARD_SIZE);
    19091927
    19101928#else
    … …  
    21642182/* #define FIRST_SORTED_BIN_SIZE 65536 */
    21652183
    2166 /*          12288 1m59 1m58 1m58
    2167  *           2560 1m56 1m59 1m57
    2168  * MIN_LARGE_SIZE 2m01 1m56 1m57
    2169  */
    2170 #ifdef SAMHAIN
    2171 #define FIRST_SORTED_BIN_SIZE 2560
    2172 #else
    21732184#define FIRST_SORTED_BIN_SIZE MIN_LARGE_SIZE
    2174 #endif
     2185
    21752186
    21762187/*
    … …  
    23722383
    23732384/* Minimum size of a chunk */
    2374 #define MINCHUNKSIZE 16
     2385
     2386#if (SIZEOF_UNSIGNED_LONG == 8) || defined(__arch64__) || defined(__ia64__) || defined(__x86_64__) || defined(__LP64__) || defined(__64BIT__) || defined(_LP64) || defined(_M_IA64) || (defined(_MIPS_SZLONG) && (_MIPS_SZLONG == 64))
     2387#  define MINCHUNKSIZE 32
     2388#else
     2389#  define MINCHUNKSIZE 16
     2390#endif
     2391
    23752392
    23762393/* The amount of hashtable entries for each page:
    … …  
    25422559           firstciinfo = currciinfo;
    25432560   totalcictr++;
     2561   VALGRIND_CREATE_MEMPOOL(newcireg, 0, 0);
    25442562}
    25452563
    … …  
    25672585   if (freelst)
    25682586   {
    2569       freeci = freelst;
    2570       newciinfo->freelist = freelst->fd;
    2571       newciinfo->freecounter--;
    2572       /* memset(freeci, 0, sizeof(struct chunkinfo)); */
    2573       freeci->prev_size = 0;
    2574       freeci->size      = 0;
    2575       freeci->req       = 0;
    2576       freeci->hash_next = NULL;
    2577       freeci->fd        = NULL;
    2578       freeci->bk        = NULL;
    2579       freeci->chunk     = NULL;
    2580       return (freeci);
     2587     freeci = freelst;
     2588     newciinfo->freecounter--;
     2589     newciinfo->freelist = freelst->fd;
     2590     
     2591     VALGRIND_MEMPOOL_ALLOC((char*)currciinfo, (char*)freeci,
     2592                            sizeof(struct chunkinfo));
     2593     
     2594     freeci->prev_size = 0;
     2595     freeci->size      = 0;
     2596     freeci->req       = 0;
     2597     freeci->hash_next = NULL;
     2598     freeci->fd        = NULL;
     2599     freeci->bk        = NULL;
     2600     freeci->chunk     = NULL;
     2601     return (freeci);
    25812602   }
    25822603   else
    … …  
    25912612     currciinfo->freecounter--;
    25922613     currciinfo->position++;
     2614
     2615     VALGRIND_MEMPOOL_ALLOC((char*)currciinfo, (char*)freeci,
     2616                            sizeof(struct chunkinfo));
     2617
    25932618     return (freeci);
    25942619   }
    … …  
    26002625  struct cireginfo *prevciinfo = firstciinfo;
    26012626  void *unmapme;
     2627
    26022628  while (newciinfo && newciinfo != freeme) {
    26032629    prevciinfo = newciinfo;
    … …  
    26092635    prevciinfo->next = newciinfo->next;
    26102636  unmapme = (void *) ((char*)freeme - PGSIZE);
     2637  VALGRIND_DESTROY_MEMPOOL((char*)freeme);
    26112638#if PARANOIA > 1
    26122639  munmap(unmapme, CIREGSIZE+(2*PGSIZE));
    … …  
    26202647
    26212648  struct cireginfo *newciinfo;
     2649
    26222650  newciinfo = currciinfo;
    26232651  if (((chunkinfoptr) newciinfo < p) && (p  <  (chunkinfoptr) (newciinfo+NUMBER_FREE_CHUNKS))) {
    … …  
    26252653    newciinfo->freelist = p;
    26262654    newciinfo->freecounter++;
     2655    VALGRIND_MEMPOOL_FREE((char*)newciinfo, (char*)p);
     2656    VALGRIND_MAKE_MEM_DEFINED(p,sizeof(struct chunkinfo));
     2657    VALGRIND_MAKE_MEM_NOACCESS(p->size,     sizeof(INTERNAL_SIZE_T));
     2658    VALGRIND_MAKE_MEM_NOACCESS(p->req,      sizeof(INTERNAL_SIZE_T));
     2659    VALGRIND_MAKE_MEM_NOACCESS(p->bk,       sizeof(struct chunkinfo*));
     2660    VALGRIND_MAKE_MEM_NOACCESS(p->chunk,    sizeof(mchunkptr));
    26272661  } else {
    26282662    newciinfo = firstciinfo;
    … …  
    26332667          newciinfo->freelist = p;
    26342668          newciinfo->freecounter++;
     2669          VALGRIND_MEMPOOL_FREE((char*)newciinfo, (char*)p);
     2670          VALGRIND_MAKE_MEM_DEFINED(p,sizeof(struct chunkinfo));
     2671          VALGRIND_MAKE_MEM_NOACCESS(p->size,     sizeof(INTERNAL_SIZE_T));
     2672          VALGRIND_MAKE_MEM_NOACCESS(p->req,      sizeof(INTERNAL_SIZE_T));
     2673          VALGRIND_MAKE_MEM_NOACCESS(p->bk,       sizeof(struct chunkinfo*));
     2674          VALGRIND_MAKE_MEM_NOACCESS(p->chunk,    sizeof(mchunkptr));
    26352675          if (UNLIKELY(newciinfo->freecounter == NUMBER_FREE_CHUNKS))
    26362676            freeciregion(newciinfo);
    … …  
    27382778   }
    27392779   else {
     2780
    27402781      ci_insert->hash_next = ci_orig->hash_next;
    27412782      ci_orig->hash_next = ci_insert;
    … …  
    27972838}
    27982839
    2799 /* mmapped chunks are multiples of pagesize, no hash_nexts, just remove from the hashtable */
     2840/* mmapped chunks are multiples of pagesize, no hash_nexts,
     2841 * just remove from the hashtable
     2842 */
    28002843#define hashtable_remove_mmapped(p) hashtable[hash(p)] = 0;
    28012844
    … …  
    28072850   
    28082851#ifdef DNMALLOC_DEBUG
    2809    fprintf(stderr, "hashtable_ski: %p, %lu\n", chunk(ci_todelete), hash(chunk(ci_todelete)));
     2852   fprintf(stderr, "hashtable_skiprm: %p, %lu\n", chunk(ci_todelete), hash(chunk(ci_todelete)));
    28102853#endif
    28112854
    … …  
    32603303
    32613304  if (have_fastchunks(av)) {
     3305    Void_t * retval;
    32623306    assert(in_smallbin_range(nb));
    32633307    malloc_consolidate(av);
    … …  
    32653309    fprintf(stderr, "Return sysmalloc have_fastchunks\n");
    32663310#endif
    3267     return mALLOc(nb - MALLOC_ALIGN_MASK);
     3311    retval = mALLOc(nb - MALLOC_ALIGN_MASK);
     3312    VALGRIND_FREELIKE_BLOCK(retval, 0);
     3313    return retval;
    32683314  }
    32693315
    … …  
    32963342      if (mm != (char*)(MORECORE_FAILURE)) {
    32973343       
     3344        VALGRIND_MAKE_MEM_NOACCESS(mm,size);
     3345
    32983346        /*
    32993347          The offset to the start of the mmapped region is stored
    … …  
    34043452  if (brk != (char*)(MORECORE_FAILURE)) {
    34053453    av->sbrked_mem += size;
     3454    VALGRIND_MAKE_MEM_NOACCESS(brk,size);
    34063455  }
    34073456
    … …  
    34303479      if (brk != (char*)(MORECORE_FAILURE)) {
    34313480       
     3481        VALGRIND_MAKE_MEM_NOACCESS(brk,size);
     3482
    34323483        av->mmapped_mem += size;
    34333484#ifdef DNMALLOC_DEBUG
    … …  
    35743625          set_noncontiguous(av);
    35753626        }
     3627        else {
     3628          VALGRIND_MAKE_MEM_NOACCESS(snd_brk,correction);
     3629        }
    35763630
    35773631      }
    … …  
    36733727            set_head(old_top, old_size | PREV_INUSE | INUSE);
    36743728            guard_set(av->guard_stored, old_top, 0, old_size);
     3729            VALGRIND_MALLOCLIKE_BLOCK(chunk(old_top), old_size, 0, 0);
    36753730            fREe(chunk(old_top));
    36763731            av->trim_threshold = tt;
    … …  
    38853940      check_remalloced_chunk(victim, nb);
    38863941      guard_set(av->guard_stored, victim, bytes, nb);
     3942      VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    38873943      return chunk(victim);
    38883944    }
    … …  
    39103966      check_malloced_chunk(victim, nb);
    39113967      guard_set(av->guard_stored, victim, bytes, nb);
     3968      VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    39123969      return chunk(victim);
    39133970    }
    … …  
    39704027      check_malloced_chunk(victim, nb);
    39714028      guard_set(av->guard_stored, victim, bytes, nb);
     4029      VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    39724030      return chunk(victim);
    39734031    }
    … …  
    39834041      check_malloced_chunk(victim, nb);
    39844042      guard_set(av->guard_stored, victim, bytes, nb);
     4043      VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    39854044      return chunk(victim);
    39864045    }
    … …  
    40584117            check_malloced_chunk(victim, nb);
    40594118            guard_set(av->guard_stored, victim, bytes, nb);
     4119            VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    40604120            return chunk(victim);
    40614121          }
    … …  
    40654125            check_malloced_chunk(victim, nb);
    40664126            guard_set(av->guard_stored, victim, bytes, nb);
     4127            VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    40674128            return chunk(victim);
    40684129          }
    … …  
    41404201        remainder->bk = remainder->fd = unsorted_chunks(av);
    41414202        /* advertise as last remainder */
    4142         if (in_smallbin_range(nb)) 
    4143           av->last_remainder = remainder;
     4203        if (in_smallbin_range(nb))
     4204          av->last_remainder = remainder;
    41444205       
    41454206        set_head(victim, nb | PREV_INUSE | INUSE);
    … …  
    41484209        check_malloced_chunk(victim, nb);
    41494210        guard_set(av->guard_stored, victim, bytes, nb);
     4211        VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    41504212        return chunk(victim);
    41514213      }
    … …  
    41554217        check_malloced_chunk(victim, nb);
    41564218        guard_set(av->guard_stored, victim, bytes, nb);
     4219        VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    41574220        return chunk(victim);
    41584221      }
    … …  
    41834246 
    41844247  if ((CHUNK_SIZE_T)(size) >= (CHUNK_SIZE_T)(nb + MINSIZE)) {
    4185      remainder = cireg_getfree();
     4248    remainder = cireg_getfree();
    41864249    remainder_size = size - nb;
    41874250    remainder->chunk = chunk_at_offset(chunk(victim), nb);
    … …  
    41924255    check_malloced_chunk(victim, nb);
    41934256    guard_set(av->guard_stored, victim, bytes, nb);
     4257    VALGRIND_MALLOCLIKE_BLOCK(chunk(victim), bytes, 0, 0);
    41944258    return chunk(victim);
    41954259  }
    … …  
    42034267    guard_set(av->guard_stored, victim, bytes, nb);
    42044268  }
     4269  VALGRIND_MALLOCLIKE_BLOCK(retval, bytes, 0, 0);
    42054270  return retval;
    42064271}
    … …  
    42544319      }
    42554320
     4321    VALGRIND_FREELIKE_BLOCK(mem, 0);
     4322 
    42564323    guard_check(av->guard_stored, p);
    4257 
     4324   
    42584325    size = chunksize(p);
    42594326
    … …  
    44714538  */
    44724539  if (av && av->max_fast != 0) {
     4540
    44734541    clear_fastchunks(av);
    44744542
    … …  
    45294597              clear_previnuse(nextchunk);
    45304598           
     4599              /* if mmap is used instead of sbrk, we may have a
     4600               * chunk with !nextchunk->fd && !nextchunk->bk
     4601               */
    45314602              if (!inuse(nextchunk)) {
    4532                 size += nextsize;
    4533                 unlink(nextchunk, bck, fwd);
    4534                 set_head(p, size | PREV_INUSE);
    4535                 hashtable_skiprm(p,nextchunk);
    4536                 freecilst_add(nextchunk);
     4603                if( nextchunk->fd && nextchunk->bk) {
     4604                  size += nextsize;
     4605                  unlink(nextchunk, bck, fwd);
     4606                  set_head(p, size | PREV_INUSE);
     4607                  hashtable_skiprm(p,nextchunk);
     4608                  freecilst_add(nextchunk);
     4609                }
    45374610              }
    45384611             
    … …  
    45514624            }
    45524625         
    4553             else {
     4626            else if (nextchunk == av->top) {
    45544627              size += nextsize;
    45554628              set_head(p, size | PREV_INUSE);
    … …  
    45584631              av->top = p;
    45594632            }
    4560           }
     4633          } /* if (nextchunk) */
    45614634         
    45624635        } while ( (p = nextp) != 0);
    … …  
    46464719  }
    46474720
     4721  VALGRIND_FREELIKE_BLOCK(oldmem, 0);
    46484722  guard_check(av->guard_stored, oldp);
    46494723
    … …  
    46754749         hashtable_insert(oldp, av->top);
    46764750         guard_set(av->guard_stored, oldp, bytes, nb);
     4751         VALGRIND_MALLOCLIKE_BLOCK(chunk(oldp), bytes, 0, 0);
    46774752         return chunk(oldp);
    46784753      }
    … …  
    46964771
    46974772        newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
    4698         if (newmem == 0)
     4773         if (newmem == 0)
    46994774          return 0; /* propagate failure */
    47004775
    … …  
    47024777        newsize = chunksize(newp);
    47034778       
     4779 
    47044780        /* next = next_chunkinfo(oldp); *//* 'next' never used rw 19.05.2008 */
    47054781        /*
    … …  
    47204796          */
    47214797         
     4798          VALGRIND_MALLOCLIKE_BLOCK(chunk(oldp), chunksize(oldp), 0, 0);
     4799
    47224800          copysize = oldsize;
    47234801          s = (INTERNAL_SIZE_T*)(oldmem);
    … …  
    47744852      set_all_inuse(remainder);
    47754853      guard_set(av->guard_stored, remainder, 0, remainder_size);
     4854      VALGRIND_MALLOCLIKE_BLOCK(chunk(remainder), remainder_size, 0, 0);
    47764855      fREe(chunk(remainder));
    47774856    }
    … …  
    47834862    check_inuse_chunk(newp);
    47844863    guard_set(av->guard_stored, newp, bytes, nb);
     4864    VALGRIND_MALLOCLIKE_BLOCK(chunk(newp), bytes, 0, 0);
    47854865    return chunk(newp);
    47864866  }
    … …  
    47984878    CHUNK_SIZE_T  sum;
    47994879   
     4880
    48004881    /* Note the extra SIZE_SZ overhead */
    48014882    //newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
    … …  
    48064887      {
    48074888        guard_set(av->guard_stored, oldp, bytes, nb);
     4889        VALGRIND_FREELIKE_BLOCK(oldmem, 0);
     4890        VALGRIND_MALLOCLIKE_BLOCK(oldmem, bytes, 0, 0);
    48084891        return oldmem;
    48094892      }
    … …  
    48324915     
    48334916      guard_set(av->guard_stored, oldp, bytes, nb);
     4917      VALGRIND_FREELIKE_BLOCK(oldmem, 0);
     4918      VALGRIND_MALLOCLIKE_BLOCK(chunk(oldp), bytes, 0, 0);
    48344919      return chunk(oldp);
    48354920    }
    … …  
    48474932      }
    48484933    }
     4934    VALGRIND_MALLOCLIKE_BLOCK(newmem, bytes, 0, 0);
    48494935    guard_set(av->guard_stored, mem2chunk(newmem), bytes, nb);
    48504936    return newmem;

  • trunk/src/make-tests.sh

    r171 r172  
    5757int main(void)
    5858{
     59#if !defined(USE_SYSTEM_MALLOC)
     60    typedef void assert_handler_tp(const char * error, const char *file, int line);
     61    extern assert_handler_tp *dnmalloc_set_handler(assert_handler_tp *new);
     62    extern void safe_fatal  (const char * details, const char *f, int l);
     63#endif
    5964#if !defined(USE_SYSTEM_MALLOC) && defined(USE_MALLOC_LOCK)
    6065    extern int dnmalloc_pthread_init(void);
    6166    dnmalloc_pthread_init();
     67#endif
     68#if !defined(USE_SYSTEM_MALLOC)
     69    (void) dnmalloc_set_handler(safe_fatal);
    6270#endif
    6371    int retval;

  • trunk/src/samhain.c

    r171 r172  
    12201220  int     my_argc = 0;
    12211221  char  * my_argv[32];
     1222#endif
     1223
     1224#if !defined(USE_SYSTEM_MALLOC)
     1225  typedef void assert_handler_tp(const char * error, const char *file, int line);
     1226  extern assert_handler_tp *dnmalloc_set_handler(assert_handler_tp *new);
     1227  (void) dnmalloc_set_handler(safe_fatal);
    12221228#endif
    12231229

  • trunk/src/sh_unix.c

    r171 r172  
    557557#endif
    558558{
    559 #if defined(SL_DEBUG)
     559#if defined(SL_DEBUG) && (defined(USE_SYSTEM_MALLOC) || !defined(USE_MALLOC_LOCK))
    560560  int retval;
    561561#endif
    … …  
    576576  /* Check whether the heap is ok; otherwise _exit
    577577   */
    578 #if !defined(SL_DEBUG)
     578#if !defined(SL_DEBUG) || (!defined(USE_SYSTEM_MALLOC) && defined(USE_MALLOC_LOCK))
    579579  ++immediate_exit_fast;
    580580  if (skey != NULL && immediate_exit_fast < 2)
Note: See TracChangeset for help on using the changeset viewer.