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