mymemory.cc

   1
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <dlfcn.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7 #include <new>
   8
   9 #include "mymemory.h"
  10 #include "snapshot.h"
  11 #include "common.h"
  12 #include "threads-model.h"
  13 #include "model.h"
  14
  15 #define REQUESTS_BEFORE_ALLOC 1024
  16
  17 size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
  18 int nextRequest = 0;
  19 int howManyFreed = 0;
  20 #if !USE_MPROTECT_SNAPSHOT
  21 static mspace sStaticSpace = NULL;
  22 #endif
  23
  24 /** Non-snapshotting calloc for our use. */
  25 void *model_calloc(size_t count, size_t size)
  26 {
  27 #if USE_MPROTECT_SNAPSHOT
  28         static void *(*callocp)(size_t count, size_t size) = NULL;
  29         char *error;
  30         void *ptr;
  31
  32         /* get address of libc malloc */
  33         if (!callocp) {
  34                 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
  35                 if ((error = dlerror()) != NULL) {
  36                         fputs(error, stderr);
  37                         exit(EXIT_FAILURE);
  38                 }
  39         }
  40         ptr = callocp(count, size);
  41         return ptr;
  42 #else
  43         if (!sStaticSpace)
  44                 sStaticSpace = create_shared_mspace();
  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 (!sStaticSpace)
  69                 sStaticSpace = create_shared_mspace();
  70         return mspace_malloc(sStaticSpace, size);
  71 #endif
  72 }
  73
  74 /** Non-snapshotting malloc for our use. */
  75 void *model_realloc(void *ptr, size_t size)
  76 {
  77 #if USE_MPROTECT_SNAPSHOT
  78         static void *(*reallocp)(void *ptr, size_t size) = NULL;
  79         char *error;
  80         void *newptr;
  81
  82         /* get address of libc malloc */
  83         if (!reallocp) {
  84                 reallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "realloc");
  85                 if ((error = dlerror()) != NULL) {
  86                         fputs(error, stderr);
  87                         exit(EXIT_FAILURE);
  88                 }
  89         }
  90         newptr = reallocp(ptr, size);
  91         return newptr;
  92 #else
  93         if (!sStaticSpace)
  94                 sStaticSpace = create_shared_mspace();
  95         return mspace_realloc(sStaticSpace, ptr, size);
  96 #endif
  97 }
  98
  99 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
 100 void * snapshot_malloc(size_t size)
 101 {
 102         void *tmp = mspace_malloc(model_snapshot_space, size);
 103         ASSERT(tmp);
 104         return tmp;
 105 }
 106
 107 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
 108 void * snapshot_calloc(size_t count, size_t size)
 109 {
 110         void *tmp = mspace_calloc(model_snapshot_space, count, size);
 111         ASSERT(tmp);
 112         return tmp;
 113 }
 114
 115 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
 116 void *snapshot_realloc(void *ptr, size_t size)
 117 {
 118         void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
 119         ASSERT(tmp);
 120         return tmp;
 121 }
 122
 123 /** @brief Snapshotting free, for use by model-checker (not user progs) */
 124 void snapshot_free(void *ptr)
 125 {
 126         mspace_free(model_snapshot_space, ptr);
 127 }
 128
 129 /** Non-snapshotting free for our use. */
 130 void model_free(void *ptr)
 131 {
 132 #if USE_MPROTECT_SNAPSHOT
 133         static void (*freep)(void *);
 134         char *error;
 135
 136         /* get address of libc free */
 137         if (!freep) {
 138                 freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
 139                 if ((error = dlerror()) != NULL) {
 140                         fputs(error, stderr);
 141                         exit(EXIT_FAILURE);
 142                 }
 143         }
 144         freep(ptr);
 145 #else
 146         mspace_free(sStaticSpace, ptr);
 147 #endif
 148 }
 149
 150 /** Bootstrap allocation. Problem is that the dynamic linker calls require
 151  *  calloc to work and calloc requires the dynamic linker to work. */
 152
 153 #define BOOTSTRAPBYTES 131072
 154 char bootstrapmemory[BOOTSTRAPBYTES];
 155 size_t offset = 0;
 156
 157 void * HandleEarlyAllocationRequest(size_t sz)
 158 {
 159         /* Align to 8 byte boundary */
 160         sz = (sz + 7) & ~7;
 161
 162         if (sz > (BOOTSTRAPBYTES-offset)) {
 163                 model_print("OUT OF BOOTSTRAP MEMORY.  Increase the size of BOOTSTRAPBYTES in mymemory.cc\n");
 164                 exit(EXIT_FAILURE);
 165         }
 166
 167         void *pointer = (void *)&bootstrapmemory[offset];
 168         offset += sz;
 169         return pointer;
 170 }
 171
 172 /** @brief Global mspace reference for the model-checker's snapshotting heap */
 173 mspace model_snapshot_space = NULL;
 174
 175 #if USE_MPROTECT_SNAPSHOT
 176
 177 /** @brief Global mspace reference for the user's snapshotting heap */
 178 mspace user_snapshot_space = NULL;
 179
 180 /** Check whether this is bootstrapped memory that we should not free */
 181 static bool DontFree(void *ptr)
 182 {
 183         return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
 184 }
 185
 186 /**
 187  * @brief The allocator function for "user" allocation
 188  *
 189  * Should only be used for allocations which will not disturb the allocation
 190  * patterns of a user thread.
 191  */
 192 static void * user_malloc(size_t size)
 193 {
 194         void *tmp = mspace_malloc(user_snapshot_space, size);
 195         ASSERT(tmp);
 196         return tmp;
 197 }
 198
 199 /**
 200  * @brief Snapshotting malloc implementation for user programs
 201  *
 202  * Do NOT call this function from a model-checker context. Doing so may disrupt
 203  * the allocation patterns of a user thread.
 204  */
 205 void *malloc(size_t size)
 206 {
 207         if (user_snapshot_space) {
 208                 /* Only perform user allocations from user context */
 209                 ASSERT(!model || thread_current());
 210                 return user_malloc(size);
 211         } else
 212                 return HandleEarlyAllocationRequest(size);
 213 }
 214
 215 /** @brief Snapshotting free implementation for user programs */
 216 void free(void * ptr)
 217 {
 218         if (!DontFree(ptr)) {
 219                 mspace_free(user_snapshot_space, ptr);
 220         }
 221 }
 222
 223 /** @brief Snapshotting realloc implementation for user programs */
 224 void *realloc(void *ptr, size_t size)
 225 {
 226         void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
 227         ASSERT(tmp);
 228         return tmp;
 229 }
 230
 231 /** @brief Snapshotting calloc implementation for user programs */
 232 void * calloc(size_t num, size_t size)
 233 {
 234         if (user_snapshot_space) {
 235                 void *tmp = mspace_calloc(user_snapshot_space, num, size);
 236                 ASSERT(tmp);
 237                 return tmp;
 238         } else {
 239                 void *tmp = HandleEarlyAllocationRequest(size * num);
 240                 memset(tmp, 0, size * num);
 241                 return tmp;
 242         }
 243 }
 244
 245 /** @brief Snapshotting allocation function for use by the Thread class only */
 246 void * Thread_malloc(size_t size)
 247 {
 248         return user_malloc(size);
 249 }
 250
 251 /** @brief Snapshotting free function for use by the Thread class only */
 252 void Thread_free(void *ptr)
 253 {
 254         free(ptr);
 255 }
 256
 257 /** @brief Snapshotting new operator for user programs */
 258 void * operator new(size_t size) throw(std::bad_alloc)
 259 {
 260         return malloc(size);
 261 }
 262
 263 /** @brief Snapshotting delete operator for user programs */
 264 void operator delete(void *p) throw()
 265 {
 266         free(p);
 267 }
 268
 269 /** @brief Snapshotting new[] operator for user programs */
 270 void * operator new[](size_t size) throw(std::bad_alloc)
 271 {
 272         return malloc(size);
 273 }
 274
 275 /** @brief Snapshotting delete[] operator for user programs */
 276 void operator delete[](void *p, size_t size)
 277 {
 278         free(p);
 279 }
 280
 281 #else   /* !USE_MPROTECT_SNAPSHOT */
 282
 283 /** @brief Snapshotting allocation function for use by the Thread class only */
 284 void * Thread_malloc(size_t size)
 285 {
 286         return snapshot_malloc(size);
 287 }
 288
 289 /** @brief Snapshotting free function for use by the Thread class only */
 290 void Thread_free(void *ptr)
 291 {
 292         snapshot_free(ptr);
 293 }
 294
 295 #endif  /* !USE_MPROTECT_SNAPSHOT */