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