Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
glibc/nptl/tst-robust8.c
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
275 lines (236 sloc)
5.15 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <pthread.h> | |
#include <signal.h> | |
#include <stdint.h> | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include <unistd.h> | |
#include <sys/mman.h> | |
#include <sys/wait.h> | |
static void prepare (void); | |
#define PREPARE(argc, argv) prepare () | |
static int do_test (void); | |
#define TEST_FUNCTION do_test () | |
#define TIMEOUT 5 | |
#include "../test-skeleton.c" | |
static int fd; | |
#define N 100 | |
static void | |
prepare (void) | |
{ | |
fd = create_temp_file ("tst-robust8", NULL); | |
if (fd == -1) | |
exit (1); | |
} | |
#define THESIGNAL SIGKILL | |
#define ROUNDS 5 | |
#define THREADS 9 | |
static const struct timespec before = { 0, 0 }; | |
static pthread_mutex_t *map; | |
static void * | |
tf (void *arg) | |
{ | |
long int nr = (long int) arg; | |
int fct = nr % 3; | |
uint8_t state[N]; | |
memset (state, '\0', sizeof (state)); | |
while (1) | |
{ | |
int r = random () % N; | |
if (state[r] == 0) | |
{ | |
int e; | |
switch (fct) | |
{ | |
case 0: | |
e = pthread_mutex_lock (&map[r]); | |
if (e != 0) | |
{ | |
printf ("mutex_lock of %d in thread %ld failed with %d\n", | |
r, nr, e); | |
exit (1); | |
} | |
state[r] = 1; | |
break; | |
case 1: | |
e = pthread_mutex_timedlock (&map[r], &before); | |
if (e != 0 && e != ETIMEDOUT) | |
{ | |
printf ("\ | |
mutex_timedlock of %d in thread %ld failed with %d\n", | |
r, nr, e); | |
exit (1); | |
} | |
break; | |
default: | |
e = pthread_mutex_trylock (&map[r]); | |
if (e != 0 && e != EBUSY) | |
{ | |
printf ("mutex_trylock of %d in thread %ld failed with %d\n", | |
r, nr, e); | |
exit (1); | |
} | |
break; | |
} | |
if (e == EOWNERDEAD) | |
pthread_mutex_consistent_np (&map[r]); | |
if (e == 0 || e == EOWNERDEAD) | |
state[r] = 1; | |
} | |
else | |
{ | |
int e = pthread_mutex_unlock (&map[r]); | |
if (e != 0) | |
{ | |
printf ("mutex_unlock of %d in thread %ld failed with %d\n", | |
r, nr, e); | |
exit (1); | |
} | |
state[r] = 0; | |
} | |
} | |
} | |
static void | |
child (int round) | |
{ | |
for (int thread = 1; thread <= THREADS; ++thread) | |
{ | |
pthread_t th; | |
if (pthread_create (&th, NULL, tf, (void *) (long int) thread) != 0) | |
{ | |
printf ("cannot create thread %d in round %d\n", thread, round); | |
exit (1); | |
} | |
} | |
struct timespec ts; | |
ts.tv_sec = 0; | |
ts.tv_nsec = 1000000000 / ROUNDS; | |
while (nanosleep (&ts, &ts) != 0) | |
/* nothing */; | |
/* Time to die. */ | |
kill (getpid (), THESIGNAL); | |
/* We better never get here. */ | |
abort (); | |
} | |
static int | |
do_test (void) | |
{ | |
if (ftruncate (fd, N * sizeof (pthread_mutex_t)) != 0) | |
{ | |
puts ("cannot size new file"); | |
return 1; | |
} | |
map = mmap (NULL, N * sizeof (pthread_mutex_t), PROT_READ | PROT_WRITE, | |
MAP_SHARED, fd, 0); | |
if (map == MAP_FAILED) | |
{ | |
puts ("mapping failed"); | |
return 1; | |
} | |
pthread_mutexattr_t ma; | |
if (pthread_mutexattr_init (&ma) != 0) | |
{ | |
puts ("mutexattr_init failed"); | |
return 0; | |
} | |
if (pthread_mutexattr_setrobust_np (&ma, PTHREAD_MUTEX_ROBUST_NP) != 0) | |
{ | |
puts ("mutexattr_setrobust failed"); | |
return 1; | |
} | |
if (pthread_mutexattr_setpshared (&ma, PTHREAD_PROCESS_SHARED) != 0) | |
{ | |
puts ("mutexattr_setpshared failed"); | |
return 1; | |
} | |
#ifdef ENABLE_PI | |
if (pthread_mutexattr_setprotocol (&ma, PTHREAD_PRIO_INHERIT) != 0) | |
{ | |
puts ("pthread_mutexattr_setprotocol failed"); | |
return 1; | |
} | |
#endif | |
for (int round = 1; round <= ROUNDS; ++round) | |
{ | |
for (int n = 0; n < N; ++n) | |
{ | |
int e = pthread_mutex_init (&map[n], &ma); | |
if (e == ENOTSUP) | |
{ | |
#ifdef ENABLE_PI | |
puts ("cannot support pshared robust PI mutexes"); | |
#else | |
puts ("cannot support pshared robust mutexes"); | |
#endif | |
return 0; | |
} | |
if (e != 0) | |
{ | |
printf ("mutex_init %d in round %d failed\n", n + 1, round); | |
return 1; | |
} | |
} | |
pid_t p = fork (); | |
if (p == -1) | |
{ | |
printf ("fork in round %d failed\n", round); | |
return 1; | |
} | |
if (p == 0) | |
child (round); | |
int status; | |
if (TEMP_FAILURE_RETRY (waitpid (p, &status, 0)) != p) | |
{ | |
printf ("waitpid in round %d failed\n", round); | |
return 1; | |
} | |
if (!WIFSIGNALED (status)) | |
{ | |
printf ("child did not die of a signal in round %d\n", round); | |
return 1; | |
} | |
if (WTERMSIG (status) != THESIGNAL) | |
{ | |
printf ("child did not die of signal %d in round %d\n", | |
THESIGNAL, round); | |
return 1; | |
} | |
for (int n = 0; n < N; ++n) | |
{ | |
int e = pthread_mutex_lock (&map[n]); | |
if (e != 0 && e != EOWNERDEAD) | |
{ | |
printf ("mutex_lock %d failed in round %d\n", n + 1, round); | |
return 1; | |
} | |
} | |
for (int n = 0; n < N; ++n) | |
if (pthread_mutex_unlock (&map[n]) != 0) | |
{ | |
printf ("mutex_unlock %d failed in round %d\n", n + 1, round); | |
return 1; | |
} | |
for (int n = 0; n < N; ++n) | |
{ | |
int e = pthread_mutex_destroy (&map[n]); | |
if (e != 0) | |
{ | |
printf ("mutex_destroy %d in round %d failed with %d\n", | |
n + 1, round, e); | |
printf("nusers = %d\n", (int) map[n].__data.__nusers); | |
return 1; | |
} | |
} | |
} | |
if (pthread_mutexattr_destroy (&ma) != 0) | |
{ | |
puts ("mutexattr_destroy failed"); | |
return 1; | |
} | |
if (munmap (map, N * sizeof (pthread_mutex_t)) != 0) | |
{ | |
puts ("munmap failed"); | |
return 1; | |
} | |
return 0; | |
} |