From a9baddd7d07b9fe15e212985a808a79773ec72e4 Mon Sep 17 00:00:00 2001 From: Rich Felker Date: Sat, 19 Mar 2011 22:26:06 -0400 Subject: initial check-in, taken from old libc svn repo with significant additions --- pthread.c | 161 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 pthread.c (limited to 'pthread.c') diff --git a/pthread.c b/pthread.c new file mode 100644 index 0000000..14fbc4a --- /dev/null +++ b/pthread.c @@ -0,0 +1,161 @@ +#include +#include +#include +#include +#include +#include + +#define TEST(r, f, x, m) ( \ +((r) = (f)) == (x) || \ +(printf(__FILE__ ":%d: %s failed (" m ")\n", __LINE__, #f, r, x), err++, 0) ) + +#define TEST_S(s, x, m) ( \ +!strcmp((s),(x)) || \ +(printf(__FILE__ ":%d: [%s] != [%s] (%s)\n", __LINE__, s, x, m), err++, 0) ) + +static pthread_key_t k1, k2; + +static void dtor(void *p) +{ + *(int *)p = 1; +} + +static void *start1(void *arg) +{ + return arg; +} + +static void *start2(void *arg) +{ + int *p = arg; + if (pthread_setspecific(k1, p) || pthread_setspecific(k2, p+1)) + return arg; + return 0; +} + +static void *start3(void *arg) +{ + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0); + pthread_barrier_wait(arg); + for (;;); + return 0; +} + +static void cleanup4(void *arg) +{ + *(int *)arg = 1; +} + +static void *start4(void *arg) +{ + pthread_cleanup_push(cleanup4, arg); + sleep(3); + pthread_cleanup_pop(0); + return 0; +} + +static void *start5(void *arg) +{ + pthread_mutex_lock(arg); + return 0; +} + +static void *start6(void *arg) +{ + void **args = arg; + pthread_mutex_lock(args[1]); + pthread_barrier_wait(args[0]); + nanosleep(&(struct timespec){ .tv_nsec = 10000000 }, 0); + return 0; +} + + +int test_pthread(void) +{ + pthread_t td; + int err = 0; + int r; + void *res; + int foo[2], bar[2]; + pthread_barrier_t barrier2; + pthread_mutexattr_t mtx_a; + pthread_mutex_t mtx, *sh_mtx; + int fd; + + TEST(r, pthread_barrier_init(&barrier2, 0, 2), 0, "creating barrier"); + + /* Test basic thread creation and joining */ + TEST(r, pthread_create(&td, 0, start1, &res), 0, "failed to create thread"); + res = 0; + TEST(r, pthread_join(td, &res), 0, "failed to join"); + TEST(r, (res==&res), 1, "wrong result from join"); + + /* Test POSIX thread-specific data */ + TEST(r, pthread_key_create(&k1, dtor), 0, "failed to create key"); + TEST(r, pthread_key_create(&k2, dtor), 0, "failed to create key"); + foo[0] = foo[1] = 0; + TEST(r, pthread_setspecific(k1, bar), 0, "failed to set tsd"); + TEST(r, pthread_setspecific(k2, bar+1), 0, "failed to set tsd"); + TEST(r, pthread_create(&td, 0, start2, foo), 0, "failed to create thread"); + TEST(r, pthread_join(td, &res), 0, "failed to join"); + TEST(res, res, 0, "pthread_setspecific failed in thread"); + TEST(r, foo[0], 1, "dtor failed to run"); + TEST(r, foo[1], 1, "dtor failed to run"); + TEST(res, pthread_getspecific(k1), bar, "tsd corrupted"); + TEST(res, pthread_getspecific(k2), bar+1, "tsd corrupted"); + TEST(r, pthread_setspecific(k1, 0), 0, "failed to clear tsd"); + TEST(r, pthread_setspecific(k2, 0), 0, "failed to clear tsd"); + TEST(r, pthread_key_delete(k1), 0, "failed to destroy key"); + TEST(r, pthread_key_delete(k2), 0, "failed to destroy key"); + + /* Asynchronous cancellation */ + TEST(r, pthread_create(&td, 0, start3, &barrier2), 0, "failed to create thread"); + pthread_barrier_wait(&barrier2); + TEST(r, pthread_cancel(td), 0, "cancelling"); + TEST(r, pthread_join(td, &res), 0, "joining cancelled thread"); + TEST(res, res, PTHREAD_CANCELLED, "cancelled thread exit status"); + + /* Cancellation cleanup handlers */ + foo[0] = 0; + TEST(r, pthread_create(&td, 0, start4, foo), 0, "failed to create thread"); + TEST(r, pthread_cancel(td), 0, "cancelling"); + TEST(r, pthread_join(td, &res), 0, "joining cancelled thread"); + TEST(res, res, PTHREAD_CANCELLED, "cancelled thread exit status"); + TEST(r, foo[0], 1, "cleanup handler failed to run"); + + /* Robust mutexes */ + TEST(r, pthread_mutexattr_init(&mtx_a), 0, "initializing mutex attr"); + TEST(r, pthread_mutexattr_setrobust(&mtx_a, PTHREAD_MUTEX_ROBUST), 0, "setting robust attribute"); + TEST(r, pthread_mutex_init(&mtx, &mtx_a), 0, "initializing robust mutex"); + TEST(r, pthread_mutex_lock(&mtx), 0, "locking robust mutex"); + TEST(r, pthread_mutex_unlock(&mtx), 0, "unlocking robust mutex"); + TEST(r, pthread_create(&td, 0, start5, &mtx), 0, "failed to create thread"); + TEST(r, pthread_join(td, &res), 0, "joining thread"); + TEST(r, pthread_mutex_lock(&mtx), EOWNERDEAD, "locking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_unlock(&mtx), 0, "unlocking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_lock(&mtx), ENOTRECOVERABLE, "re-locking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_destroy(&mtx), 0, "destroying unrecoverable mutex %d!=%d"); + + TEST(r, pthread_mutex_init(&mtx, &mtx_a), 0, "initializing robust mutex"); + TEST(r, pthread_create(&td, 0, start5, &mtx), 0, "failed to create thread"); + TEST(r, pthread_join(td, &res), 0, "joining thread"); + TEST(r, pthread_mutex_lock(&mtx), EOWNERDEAD, "locking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_consistent(&mtx), 0, "%d!=%d"); + TEST(r, pthread_mutex_unlock(&mtx), 0, "unlocking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_lock(&mtx), 0, "re-locking orphaned robust mutex %d!=%d"); + TEST(r, pthread_mutex_destroy(&mtx), 0, "destroying mutex %d!=%d"); + + TEST(r, pthread_mutex_init(&mtx, &mtx_a), 0, "%d != %d"); + TEST(r, pthread_create(&td, 0, start6, (void *[]){ &barrier2, &mtx }), 0, "%d != %d"); + pthread_barrier_wait(&barrier2); + TEST(r, pthread_mutex_lock(&mtx), EOWNERDEAD, "%d != %d"); + TEST(r, pthread_join(td, &res), 0, "%d != %d"); + TEST(r, pthread_mutex_consistent(&mtx), 0, "%d != %d"); + TEST(r, pthread_mutex_unlock(&mtx), 0, "%d != %d"); + TEST(r, pthread_mutex_destroy(&mtx), 0, "%d != %d"); + + //TEST(r, (fd=open("/dev/zero", O_RDWR))>=0, 1, "opening zero page file"); + //TEST(r, + + return err; +} -- cgit v1.2.1