mymemory.cc

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