snapshot.cc

   1 #include <inttypes.h>
   2 #include <sys/mman.h>
   3 #include <unistd.h>
   4 #include <signal.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <sys/wait.h>
   9 #include <ucontext.h>
  10
  11 #include "hashtable.h"
  12 #include "snapshot.h"
  13 #include "snapshotimp.h"
  14 #include "mymemory.h"
  15 #include "common.h"
  16
  17 #define FAILURE(mesg) { model_print("failed in the API: %s with errno relative message: %s\n", mesg, strerror(errno)); exit(EXIT_FAILURE); }
  18
  19 #ifdef CONFIG_SSDEBUG
  20 #define SSDEBUG         model_print
  21 #else
  22 #define SSDEBUG(...)    do { } while (0)
  23 #endif
  24
  25 /* extern declaration definition */
  26 struct SnapShot *snapshotrecord = NULL;
  27
  28 /** PageAlignedAdressUpdate return a page aligned address for the
  29  * address being added as a side effect the numBytes are also changed.
  30  */
  31 static void * PageAlignAddressUpward(void *addr)
  32 {
  33         return (void *)((((uintptr_t)addr) + PAGESIZE - 1) & ~(PAGESIZE - 1));
  34 }
  35
  36 #if !USE_MPROTECT_SNAPSHOT
  37 /** @statics
  38 *   These variables are necessary because the stack is shared region and
  39 *   there exists a race between all processes executing the same function.
  40 *   To avoid the problem above, we require variables allocated in 'safe' regions.
  41 *   The bug was actually observed with the forkID, these variables below are
  42 *   used to indicate the various contexts to which to switch to.
  43 *
  44 *   @savedSnapshotContext: contains the point to which takesnapshot() call should switch to.
  45 *   @savedUserSnapshotContext: contains the point to which the process whose snapshotid is equal to the rollbackid should switch to
  46 *   @snapshotid: it is a running counter for the various forked processes snapshotid. it is incremented and set in a persistently shared record
  47 */
  48 static ucontext_t savedSnapshotContext;
  49 static ucontext_t savedUserSnapshotContext;
  50 static snapshot_id snapshotid = 0;
  51
  52 #else /* USE_MPROTECT_SNAPSHOT */
  53
  54 /** ReturnPageAlignedAddress returns a page aligned address for the
  55  * address being added as a side effect the numBytes are also changed.
  56  */
  57 static void * ReturnPageAlignedAddress(void *addr)
  58 {
  59         return (void *)(((uintptr_t)addr) & ~(PAGESIZE - 1));
  60 }
  61
  62 /** The initSnapShotRecord method initialized the snapshotting data
  63  *  structures for the mprotect based snapshot.
  64  */
  65 static void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions)
  66 {
  67         snapshotrecord = (struct SnapShot *)model_malloc(sizeof(struct SnapShot));
  68         snapshotrecord->regionsToSnapShot = (struct MemoryRegion *)model_malloc(sizeof(struct MemoryRegion) * nummemoryregions);
  69         snapshotrecord->backingStoreBasePtr = (void *)model_malloc(sizeof(snapshot_page_t) * (numbackingpages + 1));
  70         //Page align the backingstorepages
  71         snapshotrecord->backingStore = (snapshot_page_t *)PageAlignAddressUpward(snapshotrecord->backingStoreBasePtr);
  72         snapshotrecord->backingRecords = (struct BackingPageRecord *)model_malloc(sizeof(struct BackingPageRecord) * numbackingpages);
  73         snapshotrecord->snapShots = (struct SnapShotRecord *)model_malloc(sizeof(struct SnapShotRecord) * numsnapshots);
  74         snapshotrecord->lastSnapShot = 0;
  75         snapshotrecord->lastBackingPage = 0;
  76         snapshotrecord->lastRegion = 0;
  77         snapshotrecord->maxRegions = nummemoryregions;
  78         snapshotrecord->maxBackingPages = numbackingpages;
  79         snapshotrecord->maxSnapShots = numsnapshots;
  80 }
  81
  82 /** HandlePF is the page fault handler for mprotect based snapshotting
  83  * algorithm.
  84  */
  85 static void HandlePF(int sig, siginfo_t *si, void *unused)
  86 {
  87         if (si->si_code == SEGV_MAPERR) {
  88                 model_print("Real Fault at %p\n", si->si_addr);
  89                 print_trace();
  90                 model_print("For debugging, place breakpoint at: %s:%d\n",
  91                                 __FILE__, __LINE__);
  92                 exit(EXIT_FAILURE);
  93         }
  94         void* addr = ReturnPageAlignedAddress(si->si_addr);
  95
  96         unsigned int backingpage = snapshotrecord->lastBackingPage++; //Could run out of pages...
  97         if (backingpage == snapshotrecord->maxBackingPages) {
  98                 model_print("Out of backing pages at %p\n", si->si_addr);
  99                 exit(EXIT_FAILURE);
 100         }
 101
 102         //copy page
 103         memcpy(&(snapshotrecord->backingStore[backingpage]), addr, sizeof(snapshot_page_t));
 104         //remember where to copy page back to
 105         snapshotrecord->backingRecords[backingpage].basePtrOfPage = addr;
 106         //set protection to read/write
 107         if (mprotect(addr, sizeof(snapshot_page_t), PROT_READ | PROT_WRITE)) {
 108                 perror("mprotect");
 109                 // Handle error by quitting?
 110         }
 111 }
 112 #endif /* USE_MPROTECT_SNAPSHOT */
 113
 114 #if !USE_MPROTECT_SNAPSHOT
 115 void createSharedMemory()
 116 {
 117         //step 1. create shared memory.
 118         void *memMapBase = mmap(0, SHARED_MEMORY_DEFAULT + STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 119         if (MAP_FAILED == memMapBase)
 120                 FAILURE("mmap");
 121
 122         //Setup snapshot record at top of free region
 123         snapshotrecord = (struct SnapShot *)memMapBase;
 124         snapshotrecord->mSharedMemoryBase = (void *)((uintptr_t)memMapBase + sizeof(struct SnapShot));
 125         snapshotrecord->mStackBase = (void *)((uintptr_t)memMapBase + SHARED_MEMORY_DEFAULT);
 126         snapshotrecord->mStackSize = STACK_SIZE_DEFAULT;
 127         snapshotrecord->mIDToRollback = -1;
 128         snapshotrecord->currSnapShotID = 0;
 129 }
 130 #endif
 131
 132
 133 /** The initSnapshotLibrary function initializes the snapshot library.
 134  *  @param entryPoint the function that should run the program.
 135  */
 136 #if USE_MPROTECT_SNAPSHOT
 137
 138 void initSnapshotLibrary(unsigned int numbackingpages,
 139                 unsigned int numsnapshots, unsigned int nummemoryregions,
 140                 unsigned int numheappages, VoidFuncPtr entryPoint)
 141 {
 142         /* Setup a stack for our signal handler....  */
 143         stack_t ss;
 144         ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE + PAGESIZE - 1));
 145         ss.ss_size = SIGSTACKSIZE;
 146         ss.ss_flags = 0;
 147         sigaltstack(&ss, NULL);
 148
 149         struct sigaction sa;
 150         sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART | SA_ONSTACK;
 151         sigemptyset(&sa.sa_mask);
 152         sa.sa_sigaction = HandlePF;
 153 #ifdef MAC
 154         if (sigaction(SIGBUS, &sa, NULL) == -1) {
 155                 model_print("SIGACTION CANNOT BE INSTALLED\n");
 156                 exit(EXIT_FAILURE);
 157         }
 158 #endif
 159         if (sigaction(SIGSEGV, &sa, NULL) == -1) {
 160                 model_print("SIGACTION CANNOT BE INSTALLED\n");
 161                 exit(EXIT_FAILURE);
 162         }
 163
 164         initSnapShotRecord(numbackingpages, numsnapshots, nummemoryregions);
 165
 166         // EVIL HACK: We need to make sure that calls into the HandlePF method don't cause dynamic links
 167         // The problem is that we end up protecting state in the dynamic linker...
 168         // Solution is to call our signal handler before we start protecting stuff...
 169
 170         siginfo_t si;
 171         memset(&si, 0, sizeof(si));
 172         si.si_addr = ss.ss_sp;
 173         HandlePF(SIGSEGV, &si, NULL);
 174         snapshotrecord->lastBackingPage--; //remove the fake page we copied
 175
 176         void *basemySpace = model_malloc((numheappages + 1) * PAGESIZE);
 177         void *pagealignedbase = PageAlignAddressUpward(basemySpace);
 178         user_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
 179         addMemoryRegionToSnapShot(pagealignedbase, numheappages);
 180
 181         void *base_model_snapshot_space = model_malloc((numheappages + 1) * PAGESIZE);
 182         pagealignedbase = PageAlignAddressUpward(base_model_snapshot_space);
 183         model_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
 184         addMemoryRegionToSnapShot(pagealignedbase, numheappages);
 185
 186         entryPoint();
 187 }
 188 #else
 189 void initSnapshotLibrary(unsigned int numbackingpages,
 190                 unsigned int numsnapshots, unsigned int nummemoryregions,
 191                 unsigned int numheappages, VoidFuncPtr entryPoint)
 192 {
 193         if (!snapshotrecord)
 194                 createSharedMemory();
 195
 196         void *base_model_snapshot_space = malloc((numheappages + 1) * PAGESIZE);
 197         void *pagealignedbase = PageAlignAddressUpward(base_model_snapshot_space);
 198         model_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
 199
 200         //step 2 setup the stack context.
 201         ucontext_t newContext;
 202         getcontext(&newContext);
 203         newContext.uc_stack.ss_sp = snapshotrecord->mStackBase;
 204         newContext.uc_stack.ss_size = STACK_SIZE_DEFAULT;
 205         makecontext(&newContext, entryPoint, 0);
 206         /* switch to a new entryPoint context, on a new stack */
 207         swapcontext(&savedSnapshotContext, &newContext);
 208
 209         /* switch back here when takesnapshot is called */
 210         pid_t forkedID = 0;
 211         snapshotid = snapshotrecord->currSnapShotID;
 212         /* This bool indicates that the current process's snapshotid is same
 213                  as the id to which the rollback needs to occur */
 214
 215         bool rollback = false;
 216         while (true) {
 217                 snapshotrecord->currSnapShotID = snapshotid + 1;
 218                 forkedID = fork();
 219
 220                 if (0 == forkedID) {
 221                         /* If the rollback bool is set, switch to the context we need to
 222                                  return to during a rollback. */
 223                         if (rollback) {
 224                                 setcontext(&(snapshotrecord->mContextToRollback));
 225                         } else {
 226                                 /*Child process which is forked as a result of takesnapshot
 227                                         call should switch back to the takesnapshot context*/
 228                                 setcontext(&savedUserSnapshotContext);
 229                         }
 230                 } else {
 231                         int status;
 232                         int retVal;
 233
 234                         SSDEBUG("The process id of child is %d and the process id of this process is %d and snapshot id is %d\n",
 235                                 forkedID, getpid(), snapshotid);
 236
 237                         do {
 238                                 retVal = waitpid(forkedID, &status, 0);
 239                         } while (-1 == retVal && errno == EINTR);
 240
 241                         if (snapshotrecord->mIDToRollback != snapshotid) {
 242                                 exit(EXIT_SUCCESS);
 243                         }
 244                         rollback = true;
 245                 }
 246         }
 247 }
 248 #endif
 249
 250 /** The addMemoryRegionToSnapShot function assumes that addr is page aligned.
 251  */
 252 void addMemoryRegionToSnapShot(void *addr, unsigned int numPages)
 253 {
 254 #if USE_MPROTECT_SNAPSHOT
 255         unsigned int memoryregion = snapshotrecord->lastRegion++;
 256         if (memoryregion == snapshotrecord->maxRegions) {
 257                 model_print("Exceeded supported number of memory regions!\n");
 258                 exit(EXIT_FAILURE);
 259         }
 260
 261         snapshotrecord->regionsToSnapShot[memoryregion].basePtr = addr;
 262         snapshotrecord->regionsToSnapShot[memoryregion].sizeInPages = numPages;
 263 #endif //NOT REQUIRED IN THE CASE OF FORK BASED SNAPSHOTS.
 264 }
 265
 266 /** The takeSnapshot function takes a snapshot.
 267  * @return The snapshot identifier.
 268  */
 269 snapshot_id takeSnapshot()
 270 {
 271 #if USE_MPROTECT_SNAPSHOT
 272         for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) {
 273                 if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(snapshot_page_t), PROT_READ) == -1) {
 274                         perror("mprotect");
 275                         model_print("Failed to mprotect inside of takeSnapShot\n");
 276                         exit(EXIT_FAILURE);
 277                 }
 278         }
 279         unsigned int snapshot = snapshotrecord->lastSnapShot++;
 280         if (snapshot == snapshotrecord->maxSnapShots) {
 281                 model_print("Out of snapshots\n");
 282                 exit(EXIT_FAILURE);
 283         }
 284         snapshotrecord->snapShots[snapshot].firstBackingPage = snapshotrecord->lastBackingPage;
 285
 286         return snapshot;
 287 #else
 288         swapcontext(&savedUserSnapshotContext, &savedSnapshotContext);
 289         SSDEBUG("TAKESNAPSHOT RETURN\n");
 290         return snapshotid;
 291 #endif
 292 }
 293
 294 /** The rollBack function rollback to the given snapshot identifier.
 295  *  @param theID is the snapshot identifier to rollback to.
 296  */
 297 void rollBack(snapshot_id theID)
 298 {
 299 #if USE_MPROTECT_SNAPSHOT == 2
 300         if (snapshotrecord->lastSnapShot == (theID + 1)) {
 301                 for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) {
 302                         memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(snapshot_page_t));
 303                 }
 304                 return;
 305         }
 306 #endif
 307
 308 #if USE_MPROTECT_SNAPSHOT
 309         HashTable< void *, bool, uintptr_t, 4, model_malloc, model_calloc, model_free> duplicateMap;
 310         for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) {
 311                 if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(snapshot_page_t), PROT_READ | PROT_WRITE) == -1) {
 312                         perror("mprotect");
 313                         model_print("Failed to mprotect inside of takeSnapShot\n");
 314                         exit(EXIT_FAILURE);
 315                 }
 316         }
 317         for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) {
 318                 if (!duplicateMap.contains(snapshotrecord->backingRecords[page].basePtrOfPage)) {
 319                         duplicateMap.put(snapshotrecord->backingRecords[page].basePtrOfPage, true);
 320                         memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(snapshot_page_t));
 321                 }
 322         }
 323         snapshotrecord->lastSnapShot = theID;
 324         snapshotrecord->lastBackingPage = snapshotrecord->snapShots[theID].firstBackingPage;
 325         takeSnapshot(); //Make sure current snapshot is still good...All later ones are cleared
 326 #else
 327         snapshotrecord->mIDToRollback = theID;
 328         volatile int sTemp = 0;
 329         getcontext(&snapshotrecord->mContextToRollback);
 330         /*
 331          * This is used to quit the process on rollback, so that the process
 332          * which needs to rollback can quit allowing the process whose
 333          * snapshotid matches the rollbackid to switch to this context and
 334          * continue....
 335          */
 336         if (!sTemp) {
 337                 sTemp = 1;
 338                 SSDEBUG("Invoked rollback\n");
 339                 exit(EXIT_SUCCESS);
 340         }
 341         /*
 342          * This fix obviates the need for a finalize call. hence less dependences for model-checker....
 343          */
 344         snapshotrecord->mIDToRollback = -1;
 345 #endif
 346 }