From: Brian Norris Date: Wed, 2 Jan 2013 23:43:54 +0000 (-0800) Subject: fixup style X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=commitdiff_plain;h=6e5c0bb2359b9fba6160957ffa88974233ba18ac fixup style --- diff --git a/clockvector.cc b/clockvector.cc index 6cd943b8..14bb809d 100644 --- a/clockvector.cc +++ b/clockvector.cc @@ -43,7 +43,7 @@ void ClockVector::merge(const ClockVector *cv) if (cv->num_threads > num_threads) { clock = (modelclock_t *)snapshot_realloc(clock, cv->num_threads * sizeof(modelclock_t)); - for (int i= num_threads; i < cv->num_threads; i++) + for (int i = num_threads; i < cv->num_threads; i++) clock[i] = 0; num_threads = cv->num_threads; } diff --git a/common.cc b/common.cc index e6c6cce6..b71c00ab 100644 --- a/common.cc +++ b/common.cc @@ -47,7 +47,7 @@ void model_print_summary(void) void assert_hook(void) { - model_print("Add breakpoint to line %u in file %s.\n",__LINE__,__FILE__); + model_print("Add breakpoint to line %u in file %s.\n", __LINE__, __FILE__); } void model_assert(bool expr, const char *file, int line) diff --git a/cyclegraph.cc b/cyclegraph.cc index 51066c94..2eaec368 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -155,12 +155,12 @@ void CycleGraph::dumpNodes(FILE *file) void CycleGraph::dumpGraphToFile(const char *filename) { char buffer[200]; - sprintf(buffer, "%s.dot",filename); + sprintf(buffer, "%s.dot", filename); FILE *file = fopen(buffer, "w"); - fprintf(file, "digraph %s {\n",filename); + fprintf(file, "digraph %s {\n", filename); dumpNodes(file); - fprintf(file,"}\n"); - fclose(file); + fprintf(file, "}\n"); + fclose(file); } #endif @@ -189,7 +189,7 @@ bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to) */ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) { - std::vector > queue; + std::vector< CycleNode *, ModelAlloc > queue; discovered->reset(); queue.push_back(from); @@ -203,7 +203,7 @@ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) for (unsigned int i = 0; i < node->getNumEdges(); i++) { CycleNode *next = node->getEdge(i); if (!discovered->contains(next)) { - discovered->put(next,next); + discovered->put(next, next); queue.push_back(next); } } @@ -213,7 +213,7 @@ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) { - std::vector > queue; + std::vector< CycleNode *, ModelAlloc > queue; discovered->reset(); CycleNode *from = actionToNode.get(fromact); @@ -230,7 +230,7 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) for (unsigned int i = 0; i < node->getNumEdges(); i++) { CycleNode *next = node->getEdge(i); if (!discovered->contains(next)) { - discovered->put(next,next); + discovered->put(next, next); queue.push_back(next); } } diff --git a/librace.cc b/librace.cc index 95b97aa9..5e775f3f 100644 --- a/librace.cc +++ b/librace.cc @@ -10,8 +10,8 @@ void store_8(void *addr, uint8_t val) { DEBUG("addr = %p, val = %" PRIu8 "\n", addr, val); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckWrite(tid, addr, cv); (*(uint8_t *)addr) = val; } @@ -19,46 +19,46 @@ void store_8(void *addr, uint8_t val) void store_16(void *addr, uint16_t val) { DEBUG("addr = %p, val = %" PRIu16 "\n", addr, val); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckWrite(tid, addr, cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv); (*(uint16_t *)addr) = val; } void store_32(void *addr, uint32_t val) { DEBUG("addr = %p, val = %" PRIu32 "\n", addr, val); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckWrite(tid, addr, cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+2), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+3), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3), cv); (*(uint32_t *)addr) = val; } void store_64(void *addr, uint64_t val) { DEBUG("addr = %p, val = %" PRIu64 "\n", addr, val); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckWrite(tid, addr, cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+2), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+3), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+4), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+5), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+6), cv); - raceCheckWrite(tid, (void *)(((uintptr_t)addr)+7), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 4), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 5), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 6), cv); + raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 7), cv); (*(uint64_t *)addr) = val; } uint8_t load_8(const void *addr) { DEBUG("addr = %p\n", addr); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckRead(tid, addr, cv); return *((uint8_t *)addr); } @@ -66,37 +66,37 @@ uint8_t load_8(const void *addr) uint16_t load_16(const void *addr) { DEBUG("addr = %p\n", addr); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckRead(tid, addr, cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv); return *((uint16_t *)addr); } uint32_t load_32(const void *addr) { DEBUG("addr = %p\n", addr); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckRead(tid, addr, cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+2), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+3), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3), cv); return *((uint32_t *)addr); } uint64_t load_64(const void *addr) { DEBUG("addr = %p\n", addr); - thread_id_t tid=thread_current()->get_id(); - ClockVector * cv=model->get_cv(tid); + thread_id_t tid = thread_current()->get_id(); + ClockVector *cv = model->get_cv(tid); raceCheckRead(tid, addr, cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+2), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+3), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+4), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+5), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+6), cv); - raceCheckRead(tid, (const void *)(((uintptr_t)addr)+7), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 4), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 5), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 6), cv); + raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 7), cv); return *((uint64_t *)addr); } diff --git a/mymemory.cc b/mymemory.cc index e05cb783..a15a13dd 100644 --- a/mymemory.cc +++ b/mymemory.cc @@ -12,7 +12,7 @@ #define REQUESTS_BEFORE_ALLOC 1024 -size_t allocatedReqs[ REQUESTS_BEFORE_ALLOC ] = { 0 }; +size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 }; int nextRequest = 0; int howManyFreed = 0; #if !USE_MPROTECT_SNAPSHOT @@ -38,11 +38,10 @@ void *model_calloc(size_t count, size_t size) ptr = callocp(count, size); return ptr; #else - if (!snapshotrecord) { + if (!snapshotrecord) createSharedMemory(); - } - if (NULL == sStaticSpace) - sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1); + if (!sStaticSpace) + sStaticSpace = create_mspace_with_base((void *)(snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(struct SnapShot), 1); return mspace_calloc(sStaticSpace, count, size); #endif } @@ -66,11 +65,10 @@ void *model_malloc(size_t size) ptr = mallocp(size); return ptr; #else - if (!snapshotrecord) { + if (!snapshotrecord) createSharedMemory(); - } - if (NULL == sStaticSpace) - sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1); + if (!sStaticSpace) + sStaticSpace = create_mspace_with_base((void *)(snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(struct SnapShot), 1); return mspace_malloc(sStaticSpace, size); #endif } @@ -114,7 +112,7 @@ void model_free(void *ptr) /* get address of libc free */ if (!freep) { - freep = ( void ( * )( void *))dlsym(RTLD_NEXT, "free"); + freep = (void (*)(void *))dlsym(RTLD_NEXT, "free"); if ((error = dlerror()) != NULL) { fputs(error, stderr); exit(EXIT_FAILURE); @@ -126,9 +124,8 @@ void model_free(void *ptr) #endif } -/** Bootstrap allocation. Problem is that the dynamic linker calls - * require calloc to work and calloc requires the dynamic linker to - * work. */ +/** Bootstrap allocation. Problem is that the dynamic linker calls require + * calloc to work and calloc requires the dynamic linker to work. */ #define BOOTSTRAPBYTES 4096 char bootstrapmemory[BOOTSTRAPBYTES]; @@ -144,7 +141,7 @@ void * HandleEarlyAllocationRequest(size_t sz) exit(EXIT_FAILURE); } - void *pointer= (void *)&bootstrapmemory[offset]; + void *pointer = (void *)&bootstrapmemory[offset]; offset += sz; return pointer; } diff --git a/snapshot-interface.cc b/snapshot-interface.cc index c8afa8f9..974e436f 100644 --- a/snapshot-interface.cc +++ b/snapshot-interface.cc @@ -20,13 +20,14 @@ SnapshotStack * snapshotObject; * that may contain globals and then configures the snapshotting * library to snapshot them. */ -static void SnapshotGlobalSegments(){ +static void SnapshotGlobalSegments() +{ int pid = getpid(); char buf[9000], execname[100]; FILE *map; sprintf(execname, "vmmap -interleaved %d", pid); - map=popen(execname, "r"); + map = popen(execname, "r"); if (!map) { perror("popen"); @@ -49,7 +50,7 @@ static void SnapshotGlobalSegments(){ void *begin, *end; //Skip out at the end of the section - if (buf[0]=='\n') + if (buf[0] == '\n') break; sscanf(buf, "%22s %p-%p [%5dK] %c%c%c/%c%c%c SM=%3s %200s\n", type, &begin, &end, &size, &r, &w, &x, &mr, &mw, &mx, smstr, regionname); @@ -76,7 +77,8 @@ static void get_binary_name(char *buf, size_t len) * that may contain globals and then configures the snapshotting * library to snapshot them. */ -static void SnapshotGlobalSegments(){ +static void SnapshotGlobalSegments() +{ char buf[9000]; char binary_name[800]; FILE *map; @@ -104,12 +106,14 @@ static void SnapshotGlobalSegments(){ } #endif -SnapshotStack::SnapshotStack(){ +SnapshotStack::SnapshotStack() +{ SnapshotGlobalSegments(); - stack=NULL; + stack = NULL; } -SnapshotStack::~SnapshotStack(){ +SnapshotStack::~SnapshotStack() +{ } @@ -119,24 +123,26 @@ SnapshotStack::~SnapshotStack(){ * @param seqindex is the sequence number to rollback before. * @return is the sequence number we actually rolled back to. */ -int SnapshotStack::backTrackBeforeStep(int seqindex) { - while(true) { - if (stack->index<=seqindex) { +int SnapshotStack::backTrackBeforeStep(int seqindex) +{ + while (true) { + if (stack->index <= seqindex) { //have right entry rollBack(stack->snapshotid); return stack->index; } - struct stackEntry *tmp=stack; - stack=stack->next; + struct stackEntry *tmp = stack; + stack = stack->next; model_free(tmp); } } /** This method takes a snapshot at the given sequence number. */ -void SnapshotStack::snapshotStep(int seqindex) { - struct stackEntry *tmp=(struct stackEntry *)model_malloc(sizeof(struct stackEntry)); - tmp->next=stack; - tmp->index=seqindex; - tmp->snapshotid=takeSnapshot(); - stack=tmp; +void SnapshotStack::snapshotStep(int seqindex) +{ + struct stackEntry *tmp = (struct stackEntry *)model_malloc(sizeof(struct stackEntry)); + tmp->next = stack; + tmp->index = seqindex; + tmp->snapshotid = takeSnapshot(); + stack = tmp; } diff --git a/snapshot-interface.h b/snapshot-interface.h index c0db0d0c..ecc60ec6 100644 --- a/snapshot-interface.h +++ b/snapshot-interface.h @@ -15,25 +15,25 @@ void initSnapshotLibrary(unsigned int numbackingpages, unsigned int numheappages, VoidFuncPtr entryPoint); struct stackEntry { - struct stackEntry *next; - snapshot_id snapshotid; - int index; + struct stackEntry *next; + snapshot_id snapshotid; + int index; }; class SnapshotStack { public: - MEMALLOC - SnapshotStack( ); - ~SnapshotStack(); - int backTrackBeforeStep(int seq_index); - void snapshotStep(int seq_index); + SnapshotStack(); + ~SnapshotStack(); + int backTrackBeforeStep(int seq_index); + void snapshotStep(int seq_index); + MEMALLOC private: - struct stackEntry * stack; + struct stackEntry *stack; }; /* Not sure what it even means to have more than one snapshot object, so let's just make a global reference to it.*/ -extern SnapshotStack * snapshotObject; +extern SnapshotStack *snapshotObject; #endif diff --git a/snapshot.cc b/snapshot.cc index 8bc685c5..5ac9b46c 100644 --- a/snapshot.cc +++ b/snapshot.cc @@ -14,7 +14,7 @@ #include "mymemory.h" #include "common.h" -#define FAILURE(mesg) { model_print("failed in the API: %s with errno relative message: %s\n", mesg, strerror( errno ) ); exit(EXIT_FAILURE); } +#define FAILURE(mesg) { model_print("failed in the API: %s with errno relative message: %s\n", mesg, strerror(errno)); exit(EXIT_FAILURE); } #ifdef CONFIG_SSDEBUG #define SSDEBUG model_print @@ -23,13 +23,14 @@ #endif /* extern declaration definition */ -struct SnapShot * snapshotrecord = NULL; +struct SnapShot *snapshotrecord = NULL; /** PageAlignedAdressUpdate return a page aligned address for the * address being added as a side effect the numBytes are also changed. */ -static void * PageAlignAddressUpward(void * addr) { - return (void *)((((uintptr_t)addr)+PAGESIZE-1)&~(PAGESIZE-1)); +static void * PageAlignAddressUpward(void *addr) +{ + return (void *)((((uintptr_t)addr) + PAGESIZE - 1) & ~(PAGESIZE - 1)); } #if !USE_MPROTECT_SNAPSHOT @@ -53,54 +54,57 @@ static snapshot_id snapshotid = 0; /** ReturnPageAlignedAddress returns a page aligned address for the * address being added as a side effect the numBytes are also changed. */ -static void * ReturnPageAlignedAddress(void * addr) { - return (void *)(((uintptr_t)addr)&~(PAGESIZE-1)); +static void * ReturnPageAlignedAddress(void *addr) +{ + return (void *)(((uintptr_t)addr) & ~(PAGESIZE - 1)); } /** The initSnapShotRecord method initialized the snapshotting data * structures for the mprotect based snapshot. */ -static void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions) { - snapshotrecord=( struct SnapShot * )model_malloc(sizeof(struct SnapShot)); - snapshotrecord->regionsToSnapShot=( struct MemoryRegion * )model_malloc(sizeof(struct MemoryRegion)*nummemoryregions); - snapshotrecord->backingStoreBasePtr= ( struct SnapShotPage * )model_malloc( sizeof( struct SnapShotPage ) * (numbackingpages + 1) ); +static void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions) +{ + snapshotrecord = (struct SnapShot *)model_malloc(sizeof(struct SnapShot)); + snapshotrecord->regionsToSnapShot = (struct MemoryRegion *)model_malloc(sizeof(struct MemoryRegion) * nummemoryregions); + snapshotrecord->backingStoreBasePtr = (struct SnapShotPage *)model_malloc(sizeof(struct SnapShotPage) * (numbackingpages + 1)); //Page align the backingstorepages - snapshotrecord->backingStore=( struct SnapShotPage * )PageAlignAddressUpward(snapshotrecord->backingStoreBasePtr); - snapshotrecord->backingRecords=( struct BackingPageRecord * )model_malloc(sizeof(struct BackingPageRecord)*numbackingpages); - snapshotrecord->snapShots= ( struct SnapShotRecord * )model_malloc(sizeof(struct SnapShotRecord)*numsnapshots); - snapshotrecord->lastSnapShot=0; - snapshotrecord->lastBackingPage=0; - snapshotrecord->lastRegion=0; - snapshotrecord->maxRegions=nummemoryregions; - snapshotrecord->maxBackingPages=numbackingpages; - snapshotrecord->maxSnapShots=numsnapshots; + snapshotrecord->backingStore = (struct SnapShotPage *)PageAlignAddressUpward(snapshotrecord->backingStoreBasePtr); + snapshotrecord->backingRecords = (struct BackingPageRecord *)model_malloc(sizeof(struct BackingPageRecord) * numbackingpages); + snapshotrecord->snapShots = (struct SnapShotRecord *)model_malloc(sizeof(struct SnapShotRecord) * numsnapshots); + snapshotrecord->lastSnapShot = 0; + snapshotrecord->lastBackingPage = 0; + snapshotrecord->lastRegion = 0; + snapshotrecord->maxRegions = nummemoryregions; + snapshotrecord->maxBackingPages = numbackingpages; + snapshotrecord->maxSnapShots = numsnapshots; } /** HandlePF is the page fault handler for mprotect based snapshotting * algorithm. */ -static void HandlePF( int sig, siginfo_t *si, void * unused){ - if( si->si_code == SEGV_MAPERR ){ +static void HandlePF(int sig, siginfo_t *si, void *unused) +{ + if (si->si_code == SEGV_MAPERR) { model_print("Real Fault at %p\n", si->si_addr); print_trace(); model_print("For debugging, place breakpoint at: %s:%d\n", __FILE__, __LINE__); - exit( EXIT_FAILURE ); + exit(EXIT_FAILURE); } void* addr = ReturnPageAlignedAddress(si->si_addr); - unsigned int backingpage=snapshotrecord->lastBackingPage++; //Could run out of pages... - if (backingpage==snapshotrecord->maxBackingPages) { + unsigned int backingpage = snapshotrecord->lastBackingPage++; //Could run out of pages... + if (backingpage == snapshotrecord->maxBackingPages) { model_print("Out of backing pages at %p\n", si->si_addr); - exit( EXIT_FAILURE ); + exit(EXIT_FAILURE); } //copy page memcpy(&(snapshotrecord->backingStore[backingpage]), addr, sizeof(struct SnapShotPage)); //remember where to copy page back to - snapshotrecord->backingRecords[backingpage].basePtrOfPage=addr; + snapshotrecord->backingRecords[backingpage].basePtrOfPage = addr; //set protection to read/write - if (mprotect( addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE )) { + if (mprotect(addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE)) { perror("mprotect"); // Handle error by quitting? } @@ -108,14 +112,15 @@ static void HandlePF( int sig, siginfo_t *si, void * unused){ #endif /* USE_MPROTECT_SNAPSHOT */ #if !USE_MPROTECT_SNAPSHOT -void createSharedMemory(){ +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 ) + 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 - snapshotrecord = ( struct SnapShot * )memMapBase; + snapshotrecord = (struct SnapShot *)memMapBase; snapshotrecord->mSharedMemoryBase = (void *)((uintptr_t)memMapBase + sizeof(struct SnapShot)); snapshotrecord->mStackBase = (void *)((uintptr_t)memMapBase + SHARED_MEMORY_DEFAULT); snapshotrecord->mStackSize = STACK_SIZE_DEFAULT; @@ -132,25 +137,26 @@ void createSharedMemory(){ void initSnapshotLibrary(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions, - unsigned int numheappages, VoidFuncPtr entryPoint) { + unsigned int numheappages, VoidFuncPtr entryPoint) +{ /* Setup a stack for our signal handler.... */ stack_t ss; - ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE+PAGESIZE-1)); + ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE + PAGESIZE - 1)); ss.ss_size = SIGSTACKSIZE; ss.ss_flags = 0; sigaltstack(&ss, NULL); struct sigaction sa; sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART | SA_ONSTACK; - sigemptyset( &sa.sa_mask ); + sigemptyset(&sa.sa_mask); sa.sa_sigaction = HandlePF; #ifdef MAC - if( sigaction( SIGBUS, &sa, NULL ) == -1 ){ + if (sigaction(SIGBUS, &sa, NULL) == -1) { model_print("SIGACTION CANNOT BE INSTALLED\n"); exit(EXIT_FAILURE); } #endif - if( sigaction( SIGSEGV, &sa, NULL ) == -1 ){ + if (sigaction(SIGSEGV, &sa, NULL) == -1) { model_print("SIGACTION CANNOT BE INSTALLED\n"); exit(EXIT_FAILURE); } @@ -163,12 +169,12 @@ void initSnapshotLibrary(unsigned int numbackingpages, siginfo_t si; memset(&si, 0, sizeof(si)); - si.si_addr=ss.ss_sp; + si.si_addr = ss.ss_sp; HandlePF(SIGSEGV, &si, NULL); snapshotrecord->lastBackingPage--; //remove the fake page we copied - void *basemySpace = model_malloc((numheappages+1)*PAGESIZE); - void * pagealignedbase=PageAlignAddressUpward(basemySpace); + void *basemySpace = model_malloc((numheappages + 1) * PAGESIZE); + void *pagealignedbase = PageAlignAddressUpward(basemySpace); user_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1); addMemoryRegionToSnapShot(pagealignedbase, numheappages); @@ -182,7 +188,8 @@ void initSnapshotLibrary(unsigned int numbackingpages, #else void initSnapshotLibrary(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions, - unsigned int numheappages, VoidFuncPtr entryPoint) { + unsigned int numheappages, VoidFuncPtr entryPoint) +{ if (!snapshotrecord) createSharedMemory(); @@ -192,10 +199,10 @@ void initSnapshotLibrary(unsigned int numbackingpages, //step 2 setup the stack context. ucontext_t newContext; - getcontext( &newContext ); + getcontext(&newContext); newContext.uc_stack.ss_sp = snapshotrecord->mStackBase; newContext.uc_stack.ss_size = STACK_SIZE_DEFAULT; - makecontext( &newContext, entryPoint, 0 ); + makecontext(&newContext, entryPoint, 0); /* switch to a new entryPoint context, on a new stack */ swapcontext(&savedSnapshotContext, &newContext); @@ -206,32 +213,32 @@ void initSnapshotLibrary(unsigned int numbackingpages, as the id to which the rollback needs to occur */ bool rollback = false; - while( true ){ - snapshotrecord->currSnapShotID=snapshotid+1; + while (true) { + snapshotrecord->currSnapShotID = snapshotid + 1; forkedID = fork(); - if( 0 == forkedID ){ + if (0 == forkedID) { /* If the rollback bool is set, switch to the context we need to return to during a rollback. */ - if( rollback) { - setcontext( &( snapshotrecord->mContextToRollback ) ); + if (rollback) { + setcontext(&(snapshotrecord->mContextToRollback)); } else { /*Child process which is forked as a result of takesnapshot call should switch back to the takesnapshot context*/ - setcontext( &savedUserSnapshotContext ); + setcontext(&savedUserSnapshotContext); } } else { int status; int retVal; SSDEBUG("The process id of child is %d and the process id of this process is %d and snapshot id is %d\n", - forkedID, getpid(), snapshotid ); + forkedID, getpid(), snapshotid); do { - retVal=waitpid( forkedID, &status, 0 ); - } while( -1 == retVal && errno == EINTR ); + retVal = waitpid(forkedID, &status, 0); + } while (-1 == retVal && errno == EINTR); - if( snapshotrecord->mIDToRollback != snapshotid ) { + if (snapshotrecord->mIDToRollback != snapshotid) { exit(EXIT_SUCCESS); } rollback = true; @@ -242,41 +249,43 @@ void initSnapshotLibrary(unsigned int numbackingpages, /** The addMemoryRegionToSnapShot function assumes that addr is page aligned. */ -void addMemoryRegionToSnapShot( void * addr, unsigned int numPages) { +void addMemoryRegionToSnapShot(void *addr, unsigned int numPages) +{ #if USE_MPROTECT_SNAPSHOT - unsigned int memoryregion=snapshotrecord->lastRegion++; - if (memoryregion==snapshotrecord->maxRegions) { + unsigned int memoryregion = snapshotrecord->lastRegion++; + if (memoryregion == snapshotrecord->maxRegions) { model_print("Exceeded supported number of memory regions!\n"); exit(EXIT_FAILURE); } - snapshotrecord->regionsToSnapShot[ memoryregion ].basePtr=addr; - snapshotrecord->regionsToSnapShot[ memoryregion ].sizeInPages=numPages; + snapshotrecord->regionsToSnapShot[memoryregion].basePtr = addr; + snapshotrecord->regionsToSnapShot[memoryregion].sizeInPages = numPages; #endif //NOT REQUIRED IN THE CASE OF FORK BASED SNAPSHOTS. } /** The takeSnapshot function takes a snapshot. * @return The snapshot identifier. */ -snapshot_id takeSnapshot( ){ +snapshot_id takeSnapshot() +{ #if USE_MPROTECT_SNAPSHOT - for(unsigned int region=0; regionlastRegion;region++) { - if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ ) == -1 ){ + for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) { + if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(struct SnapShotPage), PROT_READ) == -1) { perror("mprotect"); model_print("Failed to mprotect inside of takeSnapShot\n"); exit(EXIT_FAILURE); } } - unsigned int snapshot=snapshotrecord->lastSnapShot++; - if (snapshot==snapshotrecord->maxSnapShots) { + unsigned int snapshot = snapshotrecord->lastSnapShot++; + if (snapshot == snapshotrecord->maxSnapShots) { model_print("Out of snapshots\n"); exit(EXIT_FAILURE); } - snapshotrecord->snapShots[snapshot].firstBackingPage=snapshotrecord->lastBackingPage; + snapshotrecord->snapShots[snapshot].firstBackingPage = snapshotrecord->lastBackingPage; return snapshot; #else - swapcontext( &savedUserSnapshotContext, &savedSnapshotContext ); + swapcontext(&savedUserSnapshotContext, &savedSnapshotContext); SSDEBUG("TAKESNAPSHOT RETURN\n"); return snapshotid; #endif @@ -285,10 +294,11 @@ snapshot_id takeSnapshot( ){ /** The rollBack function rollback to the given snapshot identifier. * @param theID is the snapshot identifier to rollback to. */ -void rollBack( snapshot_id theID ){ -#if USE_MPROTECT_SNAPSHOT==2 - if (snapshotrecord->lastSnapShot==(theID+1)) { - for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; pagelastBackingPage; page++) { +void rollBack(snapshot_id theID) +{ +#if USE_MPROTECT_SNAPSHOT == 2 + if (snapshotrecord->lastSnapShot == (theID + 1)) { + for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) { memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage)); } return; @@ -297,42 +307,40 @@ void rollBack( snapshot_id theID ){ #if USE_MPROTECT_SNAPSHOT HashTable< void *, bool, uintptr_t, 4, model_malloc, model_calloc, model_free> duplicateMap; - for(unsigned int region=0; regionlastRegion;region++) { - if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ) == -1 ){ + for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) { + if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE) == -1) { perror("mprotect"); model_print("Failed to mprotect inside of takeSnapShot\n"); exit(EXIT_FAILURE); } } - for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; pagelastBackingPage; page++) { - if( !duplicateMap.contains(snapshotrecord->backingRecords[page].basePtrOfPage )) { + for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) { + if (!duplicateMap.contains(snapshotrecord->backingRecords[page].basePtrOfPage)) { duplicateMap.put(snapshotrecord->backingRecords[page].basePtrOfPage, true); memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage)); } } - snapshotrecord->lastSnapShot=theID; - snapshotrecord->lastBackingPage=snapshotrecord->snapShots[theID].firstBackingPage; + snapshotrecord->lastSnapShot = theID; + snapshotrecord->lastBackingPage = snapshotrecord->snapShots[theID].firstBackingPage; takeSnapshot(); //Make sure current snapshot is still good...All later ones are cleared #else snapshotrecord->mIDToRollback = theID; volatile int sTemp = 0; - getcontext( &snapshotrecord->mContextToRollback ); + getcontext(&snapshotrecord->mContextToRollback); /* * This is used to quit the process on rollback, so that the process * which needs to rollback can quit allowing the process whose * snapshotid matches the rollbackid to switch to this context and * continue.... */ - if( !sTemp ){ + if (!sTemp) { sTemp = 1; SSDEBUG("Invoked rollback\n"); exit(EXIT_SUCCESS); } /* * This fix obviates the need for a finalize call. hence less dependences for model-checker.... - * */ snapshotrecord->mIDToRollback = -1; #endif } - diff --git a/snapshot.h b/snapshot.h index f8995923..76d63acf 100644 --- a/snapshot.h +++ b/snapshot.h @@ -8,9 +8,9 @@ #include "snapshot-interface.h" #include "config.h" -void addMemoryRegionToSnapShot( void * ptr, unsigned int numPages ); -snapshot_id takeSnapshot( ); -void rollBack( snapshot_id theSnapShot ); +void addMemoryRegionToSnapShot(void *ptr, unsigned int numPages); +snapshot_id takeSnapshot(); +void rollBack(snapshot_id theSnapShot); #if !USE_MPROTECT_SNAPSHOT void createSharedMemory(); diff --git a/snapshotimp.h b/snapshotimp.h index 0560203f..fbff35f4 100644 --- a/snapshotimp.h +++ b/snapshotimp.h @@ -25,22 +25,22 @@ struct SnapShotPage { //List the base address of the corresponding page in the backing store so we know where to copy it to struct BackingPageRecord { - void * basePtrOfPage; + void *basePtrOfPage; }; //Stuct for each memory region struct MemoryRegion { - void * basePtr; //base of memory region + void *basePtr; //base of memory region int sizeInPages; //size of memory region in pages }; //Primary struct for snapshotting system.... struct SnapShot { - struct MemoryRegion * regionsToSnapShot; //This pointer references an array of memory regions to snapshot - struct SnapShotPage * backingStore; //This pointer references an array of snapshotpage's that form the backing store - void * backingStoreBasePtr; //This pointer references an array of snapshotpage's that form the backing store - struct BackingPageRecord * backingRecords; //This pointer references an array of backingpagerecord's (same number of elements as backingstore - struct SnapShotRecord * snapShots; //This pointer references the snapshot array + struct MemoryRegion *regionsToSnapShot; //This pointer references an array of memory regions to snapshot + struct SnapShotPage *backingStore; //This pointer references an array of snapshotpage's that form the backing store + void *backingStoreBasePtr; //This pointer references an array of snapshotpage's that form the backing store + struct BackingPageRecord *backingRecords; //This pointer references an array of backingpagerecord's (same number of elements as backingstore + struct SnapShotRecord *snapShots; //This pointer references the snapshot array unsigned int lastSnapShot; //Stores the next snapshot record we should use unsigned int lastBackingPage; //Stores the next backingpage we should use @@ -66,6 +66,6 @@ struct SnapShot { #endif //Global reference to snapshot data structure -extern struct SnapShot * snapshotrecord; +extern struct SnapShot *snapshotrecord; #endif /* __SNAPSHOTIMP_H__ */