+ mprot_snap->lastSnapShot = theID;
+ mprot_snap->lastBackingPage = mprot_snap->snapShots[theID].firstBackingPage;
+ mprot_take_snapshot(); //Make sure current snapshot is still good...All later ones are cleared
+}
+
+#else /* !USE_MPROTECT_SNAPSHOT */
+
+#include <ucontext.h>
+
+#define SHARED_MEMORY_DEFAULT (100 * ((size_t)1 << 20)) // 100mb for the shared memory
+#define STACK_SIZE_DEFAULT (((size_t)1 << 20) * 20) // 20 mb out of the above 100 mb for my stack
+
+struct fork_snapshotter {
+ void *mSharedMemoryBase;
+ void *mStackBase;
+ size_t mStackSize;
+ volatile snapshot_id mIDToRollback;
+ ucontext_t mContextToRollback;
+ snapshot_id currSnapShotID;
+};
+
+static struct fork_snapshotter *fork_snap = NULL;
+
+/** @statics
+* These variables are necessary because the stack is shared region and
+* there exists a race between all processes executing the same function.
+* To avoid the problem above, we require variables allocated in 'safe' regions.
+* The bug was actually observed with the forkID, these variables below are
+* used to indicate the various contexts to which to switch to.
+*
+* @savedSnapshotContext: contains the point to which takesnapshot() call should switch to.
+* @savedUserSnapshotContext: contains the point to which the process whose snapshotid is equal to the rollbackid should switch to
+* @snapshotid: it is a running counter for the various forked processes snapshotid. it is incremented and set in a persistently shared record
+*/
+static ucontext_t savedSnapshotContext;
+static ucontext_t savedUserSnapshotContext;
+static snapshot_id snapshotid = 0;
+
+static void createSharedMemory()
+{
+ //step 1. create shared memory.
+ void *memMapBase = mmap(0, SHARED_MEMORY_DEFAULT + STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+ if (MAP_FAILED == memMapBase)
+ FAILURE("mmap");
+
+ //Setup snapshot record at top of free region
+ fork_snap = (struct fork_snapshotter *)memMapBase;
+ fork_snap->mSharedMemoryBase = (void *)((uintptr_t)memMapBase + sizeof(struct fork_snapshotter));
+ fork_snap->mStackBase = (void *)((uintptr_t)memMapBase + SHARED_MEMORY_DEFAULT);
+ fork_snap->mStackSize = STACK_SIZE_DEFAULT;
+ fork_snap->mIDToRollback = -1;
+ fork_snap->currSnapShotID = 0;
+}
+
+/**
+ * Create a new mspace pointer for the non-snapshotting (i.e., inter-process
+ * shared) memory region. Only for fork-based snapshotting.
+ *
+ * @return The shared memory mspace
+ */
+mspace create_shared_mspace()
+{
+ if (!fork_snap)
+ createSharedMemory();
+ return create_mspace_with_base((void *)(fork_snap->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(struct fork_snapshotter), 1);
+}
+
+static void fork_snapshot_init(unsigned int numbackingpages,
+ unsigned int numsnapshots, unsigned int nummemoryregions,
+ unsigned int numheappages, VoidFuncPtr entryPoint)
+{
+ if (!fork_snap)
+ createSharedMemory();
+
+ void *base_model_snapshot_space = malloc((numheappages + 1) * PAGESIZE);
+ void *pagealignedbase = PageAlignAddressUpward(base_model_snapshot_space);
+ model_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
+