more racing test cases

Author: dabund24

tests/regression/90-races_ancestor_locksets/10-maybe_lock_racing.c

@@ -0,0 +1,29 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+// TODO broken, since locksets have more granular path sensitivity than creation locksets
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+void *t1(void *arg) {
+  pthread_mutex_lock(&mutex);
+  global++; // RACE!
+  pthread_mutex_unlock(&mutex);
+  return NULL;
+}
+
+void *t2(void *arg) { // t2 is not protected by mutex locked in main thread, since the mutex does not have to be locked during creation
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_create(&id1, NULL, t1, NULL);
+  int maybe;
+  if (maybe) { 
+    pthread_mutex_lock(&mutex);
+  }
+  pthread_create(&id2, NULL, t2, NULL);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/11-maybe_unlock_racing.c

@@ -0,0 +1,31 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+// TODO broken, since locksets have more granular path sensitivity than creation locksets
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+void *t1(void *arg) {
+  pthread_mutex_lock(&mutex);
+  global++; // RACE!
+  pthread_mutex_unlock(&mutex);
+  return NULL;
+}
+
+void *t2(void *arg) { // t2 is not protected by mutex locked in main thread, since an unlock may happen before joining
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_create(&id1, NULL, t1, NULL);
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id2, NULL, t2, NULL);
+  int maybe;
+  if (maybe) { 
+    pthread_mutex_unlock(&mutex);
+  }
+  pthread_join(id2, NULL);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/12-random_mutex_unlock_racing.c

@@ -0,0 +1,34 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+// TODO broken, since locksets have more granular path sensitivity than creation locksets
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER, mutex_alt = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+void *t1(void *arg) {
+  pthread_mutex_lock(&mutex);
+  global++; // RACE!
+  pthread_mutex_unlock(&mutex);
+  return NULL;
+}
+
+void *t2(void *arg) { // t2 is not protected by mutex locked in main thread, since an unlock may happen before joining
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_create(&id1, NULL, t1, NULL);
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id2, NULL, t2, NULL);
+  pthread_mutex_lock(&mutex_alt);
+  pthread_mutex_t *mutex_ref = &mutex_alt;
+  int maybe;
+  if (maybe) { 
+    mutex_ref = &mutex;
+  }
+  pthread_mutex_unlock(mutex_ref);
+  pthread_join(id2, NULL);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/13-unknown_mutex_unlock_racing.c

@@ -0,0 +1,28 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+void *t1(void *arg) {
+  pthread_mutex_lock(&mutex);
+  global++; // RACE!
+  pthread_mutex_unlock(&mutex);
+  return NULL;
+}
+
+void *t2(void *arg) { // t2 is not protected by mutex locked in main thread, since an unlock could happen before joining
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_create(&id1, NULL, t1, NULL);
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id2, NULL, t2, NULL);
+  pthread_mutex_t *mutex_ref;
+  pthread_mutex_unlock(mutex_ref); // unlock of unknown mutex
+  pthread_join(id2, NULL);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/14-maybe_join_racing.c

@@ -0,0 +1,30 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+void *t1(void *arg) {
+  pthread_mutex_lock(&mutex);
+  global++; // RACE!
+  pthread_mutex_unlock(&mutex);
+  return NULL;
+}
+
+void *t2(void *arg) { // t2 is not protected by mutex locked in main thread, joining may happen before unlocking
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_create(&id1, NULL, t1, NULL);
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id2, NULL, t2, NULL);
+  int maybe;
+  if (maybe) { 
+    pthread_join(id2, NULL);
+  }
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/15-lock_from_same_thread_one_lockset_one_interthreaded_racing.c

@@ -0,0 +1,22 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1;
+
+// both accesses are protected by same mutex **locked in same thread**
+
+void *t1(void *arg) {
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id1, NULL, t1, NULL);
+  global++; // RACE!
+  pthread_join(id1, NULL);
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}

tests/regression/90-races_ancestor_locksets/16-lock_from_same_thread_both_interthreaded_racing.c

@@ -0,0 +1,23 @@
+// PARAM: --set ana.activated[+] taintedCreationLockset --set ana.activated[+] threadJoins --set ana.activated[+] transitiveDescendants --set ana.activated[+] creationLockset
+#include <pthread.h>
+
+int global = 0;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t id1, id2;
+
+// both accesses are protected by same mutex **locked in same thread**
+
+void *tc(void *arg) {
+  global++; // RACE!
+  return NULL;
+}
+
+int main(void) {
+  pthread_mutex_lock(&mutex);
+  pthread_create(&id1, NULL, tc, NULL);
+  pthread_create(&id2, NULL, tc, NULL);
+  pthread_join(id1, NULL);
+  pthread_join(id2, NULL);
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}