inline void push(int d) { int oldTop, newTop,ret; __VERIFIER_atomic_index_malloc(&newTop); if(newTop == 0) exit(-1); INDIR(newTop,0) = d; while (1) { oldTop = top; INDIR(newTop,1) = oldTop; __VERIFIER_atomic_CAS(&top,oldTop,newTop,&ret); if(ret) return; } }
void push(int d) { int oldTop, newTop; __VERIFIER_atomic_index_malloc(&newTop); if(newTop == 0) exit(-1); INDIR(newTop,0) = d; while (1) { oldTop = top; INDIR(newTop,1) = oldTop; if(__sync_bool_compare_and_swap(&top,oldTop,newTop)) return; } }
inline void push(int d) { int oldTop = -1, newTop = -1; __VERIFIER_atomic_index_malloc(&newTop); if(newTop == 0) exit(-1); else{ INDIR(newTop,0) = d; __VERIFIER_atomic_acquire(); oldTop = top; INDIR(newTop,1) = oldTop; top = newTop; __VERIFIER_atomic_release(); } }
int push(int d) { int oldTop = -1, newTop = -1; newTop = index_malloc(); if(newTop == 0){ return 0; }else{ INDIR(newTop,0) = d; pthread_mutex_lock(&m); oldTop = top; INDIR(newTop,1) = oldTop; top = newTop; pthread_mutex_unlock(&m); return 1; } }
inline int push(int d) { int oldTop = -1, newTop = -1; newTop = index_malloc(); if(newTop == 0){ return 0; }else{ INDIR(newTop,0) = d; __VERIFIER_atomic_acquire(&m); oldTop = top; INDIR(newTop,1) = oldTop; top = newTop; __VERIFIER_atomic_release(&m); return 1; } }
int push(int d) { int oldTop = -1, newTop = -1; newTop = index_malloc(); if(newTop == 0){ return 0; }else{ INDIR(newTop,0) = d; while (1) { oldTop = top; INDIR(newTop,1) = oldTop; if(__sync_bool_compare_and_swap(&top,oldTop,newTop)){ return 1; } } } }
inline int push(int d) { int oldTop = -1, newTop = -1, casret = -1; newTop = index_malloc(); if(newTop == 0){ return 0; }else{ INDIR(newTop,0) = d; while (1) { oldTop = top; INDIR(newTop,1) = oldTop; __VERIFIER_atomic_CAS(&top,oldTop,newTop,&casret); if(casret==1){ return 1; } } } }
int push(E d) { WORDT_Ptr oldTop = -1, newTop = -1; WORDT_Ptr chTop = -1; #if (APRED >= 1) __CPROVER_predicate(s.top == 0); __CPROVER_predicate(newTop == 0); __CPROVER_predicate(s.top == oldTop); #endif newTop = index_malloc(); if(newTop == WORDT_NULL){ assume(newTop == WORDT_NULL); return 0; }else{ assume(!(newTop == WORDT_NULL)); INDIR(newTop,0) = d; while (1) { oldTop = s.top; INDIR(newTop,1) = oldTop; //inlining of cas //atomic_begin(); if (s.top == oldTop) { assume(s.top == oldTop); atomic_begin(); chTop = s.top; s.top = newTop; atomic_end(); //atomic_end(); unsafe_assert(chTop == oldTop); return 1; }else{ assume(!(s.top == oldTop)); //atomic_end(); } } } }
int push(E d) { WORDT_Ptr oldTop = -1, newTop = -1; newTop = index_malloc(); if(newTop == WORDT_NULL){ #ifdef USE_BRANCHING_ASSUMES __CPROVER_assume(newTop == WORDT_NULL); #endif return 0; }else{ #ifdef USE_BRANCHING_ASSUMES __CPROVER_assume(!(newTop == WORDT_NULL)); #endif INDIR(newTop,0) = d; //__CPROVER_atomic_begin(); oldTop = s.top; INDIR(newTop,1) = oldTop; s.top = newTop; //__CPROVER_atomic_end(); return 1; } }
/* * "Resolve" a pathname. * * Makes sure that 'path' falls within the 'dir' after application of * realpath to resolve "..", symlinks, etc. If 'create' is set, it will * create missing intermediate directories. In detail: * * The path (and dir) must be absolute, or it is an error. * If 'create' is zero, then all components of the path must exist * or it is an error. * If 'create' is non-zero, then missing components except the last * will be created. * If 'dir' is non-null, the existing part of the path must resolve * within this directory or it is an error. * If 'dir' is null, then the path is resolved as far as it exists * ('create' is ignored and assumed to be zero). * * Returns NULL on an error, a malloc'ed pointer to a canonicalized * path otherwise. */ char * resolvepath(char *path, char *dir, int create) { char rpath[PATH_MAX], *next, *ep, *pathcopy; struct stat sb; int pathlen = strlen(path); int dirlen = 0; int rpathlen; mode_t omask, cmask; char *npath; if (debug > 1) info("resolvepath '%s' in dir '%s'", path, dir); /* validate path */ if (path == NULL) { if (debug > 1) info(" null path"); return NULL; } if (path[0] != '/') { if (debug > 1) info(" path is not absolute"); return NULL; } if (pathlen >= sizeof rpath) { if (debug > 1) info(" path is too long"); return NULL; } /* validate dir */ if (dir) { dirlen = strlen(dir); if (dir[0] != '/') { if (debug > 1) info(" path and dir (%s) must be absolute", dir); return NULL; } /* XXX make dir=='/' work */ if (dirlen == 1) dirlen = 0; } else { create = 0; } /* * If the full path resolves, make sure it falls in dir (if given) * and is a regular file. */ if (myrealpath(path, rpath) != NULL) { if (dir && !INDIR(dir, dirlen, rpath)) { if (debug > 1) info(" resolved path (%s) not in dir (%s)", rpath, dir); return NULL; } if (stat(rpath, &sb) < 0 || !S_ISREG(sb.st_mode)) { if (debug > 1) info(" not a regular file"); return NULL; } return strdup(rpath); } if (debug > 1) { int oerrno = errno; info(" partially resolved to '%s' (errno %d)", rpath, errno); errno = oerrno; } /* * If create is not set or we failed for any reason other than * a non-existent component, we return an error. */ if (!create || errno != ENOENT) { if (debug > 1) info(" realpath failed at %s with %d", rpath, errno); return NULL; } /* * Need to create intermediate directories. * * First, check that what does exist of the path falls within * the directory given. */ assert(dir != NULL); if (!INDIR(dir, dirlen, rpath)) { if (debug > 1) info(" resolved path (%s) not in dir (%s)", rpath, dir); return NULL; } /* * Establish permission (mode) for new directories. * Start with permission of 'dir'; this will get updated with * every component that resolves, so that new directories will * get created with the permission of the most recent ancestor. */ if (stat(dir, &sb) < 0) { if (debug > 1) info(" stat failed on dir (%s)?!", dir); return NULL; } cmask = (sb.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IRWXU; omask = umask(0); if (debug > 1) info(" umask=0 (was 0%o), initial cmask=0%o", omask, cmask); /* * Find the first component of the original path that does not * exist (i.e., what part of the original path maps to what realpath * returned) and create everything from there on. * * Note that if what realpath returned is a prefix of the original * path then nothing was translated and we are already at the first * component that needs creation. So we find the appropriate location * in the original string and go from there. */ npath = NULL; if ((pathcopy = strdup(path)) == NULL) goto done; rpathlen = strlen(rpath); assert(rpathlen <= pathlen); if (rpathlen > 1 && strncmp(pathcopy, rpath, rpathlen) == 0 && (pathcopy[rpathlen] == '\0' || pathcopy[rpathlen] == '/')) { /* same string, start at last slash in path */ if (pathcopy[rpathlen] == '\0') { next = rindex(pathcopy, '/'); assert(next != NULL); } /* rpath is a prefix, start at last slash in that prefix */ else { next = rindex(rpath, '/'); assert(next != NULL); next = &pathcopy[next-rpath]; } } /* rpath is not a prefix, must scan entire path */ else { next = pathcopy; } assert(next >= pathcopy && next < &pathcopy[pathlen]); assert(*next == '/'); next++; if (debug > 1) info(" pathscan: path='%s', rpath='%s', start at '%s'", pathcopy, rpath, next); while ((ep = index(next, '/')) != NULL) { *ep = '\0'; if (debug > 1) info(" testing: %s", pathcopy); /* * We use realpath here instead of just stat to make * sure someone isn't actively tweaking the filesystem * and messing with our head. * * If realpath fails, it should fail with ENOENT and * the realpath-ified part should fall in our directory. * Otherwise, someone really is playing games. */ if (myrealpath(pathcopy, rpath) == NULL) { if (errno != ENOENT || (dir && !INDIR(dir, dirlen, rpath))) { if (debug > 1) info(" resolves bad (%s)\n", rpath); goto done; } /* * We have hit a missing component. * Create the component and carry on. */ if (mkdir(rpath, cmask) < 0) { if (debug > 1) info(" create failed (%s)\n", rpath); goto done; } if (debug > 1) info(" created (%s)", rpath); } else { if (debug > 1) info(" exists (%s)", rpath); /* * Update the creation permission; see comment above. */ if (stat(rpath, &sb) < 0) { if (debug > 1) info(" stat failed (%s)?!", rpath); goto done; } cmask = (sb.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IRWXU; } *ep = '/'; next = ep+1; } /* * We are down to the final component of the original path. * It should either exist and be a regular file or not * exist at all. */ if (myrealpath(pathcopy, rpath) == NULL && (errno != ENOENT || !INDIR(dir, dirlen, rpath))) { if (debug > 1) info(" final resolved path (%s) bad (%d)", rpath, errno); goto done; } /* * We are in our happy place. rpath is the canonicalized path. */ npath = strdup(rpath); if (debug > 1) info("resolvepath: '%s' resolved to '%s'", path, npath); done: umask(omask); if (pathcopy) free(pathcopy); return npath; }