mymemory.cc

   1 #include "mymemory.h"
   2 #include "snapshot.h"
   3 #include "snapshotimp.h"
   4 #include <stdio.h>
   5 #include <dlfcn.h>
   6 #include <unistd.h>
   7 #include <cstring>
   8 #include "common.h"
   9 #define REQUESTS_BEFORE_ALLOC 1024
  10 size_t allocatedReqs[ REQUESTS_BEFORE_ALLOC ] = { 0 };
  11 int nextRequest = 0;
  12 int howManyFreed = 0;
  13 #if !USE_MPROTECT_SNAPSHOT
  14 static mspace sStaticSpace = NULL;
  15 #endif
  16
  17 /** Non-snapshotting calloc for our use. */
  18 void *model_calloc(size_t count, size_t size)
  19 {
  20 #if USE_MPROTECT_SNAPSHOT
  21         static void *(*callocp)(size_t count, size_t size) = NULL;
  22         char *error;
  23         void *ptr;
  24
  25         /* get address of libc malloc */
  26         if (!callocp) {
  27                 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
  28                 if ((error = dlerror()) != NULL) {
  29                         fputs(error, stderr);
  30                         exit(EXIT_FAILURE);
  31                 }
  32         }
  33         ptr = callocp(count, size);
  34         return ptr;
  35 #else
  36         if (!snapshotrecord) {
  37                 createSharedMemory();
  38         }
  39         if (NULL == sStaticSpace)
  40                 sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1);
  41         return mspace_calloc(sStaticSpace, count, size);
  42 #endif
  43 }
  44
  45 /** Non-snapshotting malloc for our use. */
  46 void *model_malloc(size_t size)
  47 {
  48 #if USE_MPROTECT_SNAPSHOT
  49         static void *(*mallocp)(size_t size) = NULL;
  50         char *error;
  51         void *ptr;
  52
  53         /* get address of libc malloc */
  54         if (!mallocp) {
  55                 mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
  56                 if ((error = dlerror()) != NULL) {
  57                         fputs(error, stderr);
  58                         exit(EXIT_FAILURE);
  59                 }
  60         }
  61         ptr = mallocp(size);
  62         return ptr;
  63 #else
  64         if (!snapshotrecord) {
  65                 createSharedMemory();
  66         }
  67         if (NULL == sStaticSpace)
  68                 sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1);
  69         return mspace_malloc(sStaticSpace, size);
  70 #endif
  71 }
  72
  73 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
  74 void * snapshot_malloc(size_t size)
  75 {
  76         void *tmp = mspace_malloc(model_snapshot_space, size);
  77         ASSERT(tmp);
  78         return tmp;
  79 }
  80
  81 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
  82 void * snapshot_calloc(size_t count, size_t size)
  83 {
  84         void *tmp = mspace_calloc(model_snapshot_space, count, size);
  85         ASSERT(tmp);
  86         return tmp;
  87 }
  88
  89 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
  90 void *snapshot_realloc(void *ptr, size_t size)
  91 {
  92         void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
  93         ASSERT(tmp);
  94         return tmp;
  95 }
  96
  97 /** @brief Snapshotting free, for use by model-checker (not user progs) */
  98 void snapshot_free(void *ptr)
  99 {
 100         mspace_free(model_snapshot_space, ptr);
 101 }
 102
 103 /** Non-snapshotting free for our use. */
 104 void model_free(void *ptr)
 105 {
 106 #if USE_MPROTECT_SNAPSHOT
 107         static void (*freep)(void *);
 108         char *error;
 109
 110         /* get address of libc free */
 111         if (!freep) {
 112                 freep = ( void  ( * )( void *))dlsym(RTLD_NEXT, "free");
 113                 if ((error = dlerror()) != NULL) {
 114                         fputs(error, stderr);
 115                         exit(EXIT_FAILURE);
 116                 }
 117         }
 118         freep(ptr);
 119 #else
 120         mspace_free(sStaticSpace, ptr);
 121 #endif
 122 }
 123
 124 /** Bootstrap allocation.  Problem is that the dynamic linker calls
 125  *  require calloc to work and calloc requires the dynamic linker to
 126  *      work.  */
 127
 128 #define BOOTSTRAPBYTES 4096
 129 char bootstrapmemory[BOOTSTRAPBYTES];
 130 size_t offset = 0;
 131
 132 void * HandleEarlyAllocationRequest(size_t sz)
 133 {
 134         /* Align to 8 byte boundary */
 135         sz = (sz + 7) & ~7;
 136
 137         if (sz > (BOOTSTRAPBYTES-offset)) {
 138                 printf("OUT OF BOOTSTRAP MEMORY\n");
 139                 exit(EXIT_FAILURE);
 140         }
 141
 142         void *pointer= (void *)&bootstrapmemory[offset];
 143         offset += sz;
 144         return pointer;
 145 }
 146
 147 /** @brief Global mspace reference for the model-checker's snapshotting heap */
 148 mspace model_snapshot_space = NULL;
 149
 150 #if USE_MPROTECT_SNAPSHOT
 151
 152 /** @brief Global mspace reference for the user's snapshotting heap */
 153 mspace user_snapshot_space = NULL;
 154
 155 /** Check whether this is bootstrapped memory that we should not free */
 156 static bool DontFree(void *ptr)
 157 {
 158         return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
 159 }
 160
 161 /** @brief Snapshotting malloc implementation for user programs */
 162 void *malloc(size_t size)
 163 {
 164         if (user_snapshot_space) {
 165                 void *tmp = mspace_malloc(user_snapshot_space, size);
 166                 ASSERT(tmp);
 167                 return tmp;
 168         } else
 169                 return HandleEarlyAllocationRequest(size);
 170 }
 171
 172 /** @brief Snapshotting free implementation for user programs */
 173 void free(void * ptr)
 174 {
 175         if (!DontFree(ptr))
 176                 mspace_free(user_snapshot_space, ptr);
 177 }
 178
 179 /** @brief Snapshotting realloc implementation for user programs */
 180 void *realloc(void *ptr, size_t size)
 181 {
 182         void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
 183         ASSERT(tmp);
 184         return tmp;
 185 }
 186
 187 /** @brief Snapshotting calloc implementation for user programs */
 188 void * calloc(size_t num, size_t size)
 189 {
 190         if (user_snapshot_space) {
 191                 void *tmp = mspace_calloc(user_snapshot_space, num, size);
 192                 ASSERT(tmp);
 193                 return tmp;
 194         } else {
 195                 void *tmp = HandleEarlyAllocationRequest(size * num);
 196                 std::memset(tmp, 0, size * num);
 197                 return tmp;
 198         }
 199 }
 200
 201 /** @brief Snapshotting new operator for user programs */
 202 void * operator new(size_t size) throw(std::bad_alloc)
 203 {
 204         return malloc(size);
 205 }
 206
 207 /** @brief Snapshotting delete operator for user programs */
 208 void operator delete(void *p) throw()
 209 {
 210         free(p);
 211 }
 212
 213 /** @brief Snapshotting new[] operator for user programs */
 214 void * operator new[](size_t size) throw(std::bad_alloc)
 215 {
 216         return malloc(size);
 217 }
 218
 219 /** @brief Snapshotting delete[] operator for user programs */
 220 void operator delete[](void *p, size_t size)
 221 {
 222         free(p);
 223 }
 224 #endif /* USE_MPROTECT_SNAPSHOT */