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