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