2012-10-10 08:47:27 +02:00
|
|
|
/* Verify that condition variables synchronized by PI mutexes don't hang on
|
|
|
|
on cancellation.
|
2015-01-02 17:28:19 +01:00
|
|
|
Copyright (C) 2012-2015 Free Software Foundation, Inc.
|
2012-10-10 08:47:27 +02:00
|
|
|
This file is part of the GNU C Library.
|
|
|
|
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
|
License as published by the Free Software Foundation; either
|
|
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with the GNU C Library; if not, see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2012-10-25 23:43:10 +02:00
|
|
|
#include <stdint.h>
|
2012-10-10 08:47:27 +02:00
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
#define NUM 5
|
|
|
|
#define ITERS 10000
|
|
|
|
#define COUNT 100
|
|
|
|
|
|
|
|
typedef void *(*thr_func) (void *);
|
|
|
|
|
|
|
|
pthread_mutex_t mutex;
|
|
|
|
pthread_cond_t cond;
|
|
|
|
|
|
|
|
void cleanup (void *u)
|
|
|
|
{
|
|
|
|
/* pthread_cond_wait should always return with the mutex locked. */
|
|
|
|
if (pthread_mutex_unlock (&mutex))
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
signaller (void *u)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
void *tret = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < ITERS; i++)
|
|
|
|
{
|
|
|
|
if ((ret = pthread_mutex_lock (&mutex)) != 0)
|
|
|
|
{
|
|
|
|
tret = (void *)1;
|
|
|
|
printf ("signaller:mutex_lock failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if ((ret = pthread_cond_signal (&cond)) != 0)
|
|
|
|
{
|
|
|
|
tret = (void *)1;
|
|
|
|
printf ("signaller:signal failed: %s\n", strerror (ret));
|
|
|
|
goto unlock_out;
|
|
|
|
}
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
{
|
|
|
|
tret = (void *)1;
|
|
|
|
printf ("signaller:mutex_unlock failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pthread_testcancel ();
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return tret;
|
|
|
|
|
|
|
|
unlock_out:
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
printf ("signaller:mutex_unlock[2] failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
waiter (void *u)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
void *tret = NULL;
|
2012-10-25 23:43:10 +02:00
|
|
|
int seq = (uintptr_t) u;
|
2012-10-10 08:47:27 +02:00
|
|
|
|
|
|
|
for (i = 0; i < ITERS / NUM; i++)
|
|
|
|
{
|
|
|
|
if ((ret = pthread_mutex_lock (&mutex)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pthread_cleanup_push (cleanup, NULL);
|
|
|
|
|
|
|
|
if ((ret = pthread_cond_wait (&cond, &mutex)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:wait failed: %s\n", seq, strerror (ret));
|
|
|
|
goto unlock_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pthread_cleanup_pop (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
puts ("waiter tests done");
|
|
|
|
return tret;
|
|
|
|
|
|
|
|
unlock_out:
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
printf ("waiter:mutex_unlock[2] failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
timed_waiter (void *u)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
void *tret = NULL;
|
2012-10-25 23:43:10 +02:00
|
|
|
int seq = (uintptr_t) u;
|
2012-10-10 08:47:27 +02:00
|
|
|
|
|
|
|
for (i = 0; i < ITERS / NUM; i++)
|
|
|
|
{
|
|
|
|
struct timespec ts;
|
|
|
|
|
|
|
|
if ((ret = clock_gettime(CLOCK_REALTIME, &ts)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("%u:clock_gettime failed: %s\n", seq, strerror (errno));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ts.tv_sec += 20;
|
|
|
|
|
|
|
|
if ((ret = pthread_mutex_lock (&mutex)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pthread_cleanup_push (cleanup, NULL);
|
|
|
|
|
|
|
|
/* We should not time out either. */
|
|
|
|
if ((ret = pthread_cond_timedwait (&cond, &mutex, &ts)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:timedwait failed: %s\n", seq, strerror (ret));
|
|
|
|
goto unlock_out;
|
|
|
|
}
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
{
|
2012-10-25 23:43:10 +02:00
|
|
|
tret = (void *) (uintptr_t) 1;
|
2012-10-10 08:47:27 +02:00
|
|
|
printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pthread_cleanup_pop (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
puts ("timed_waiter tests done");
|
|
|
|
return tret;
|
|
|
|
|
|
|
|
unlock_out:
|
|
|
|
if ((ret = pthread_mutex_unlock (&mutex)) != 0)
|
|
|
|
printf ("waiter[%u]:mutex_unlock[2] failed: %s\n", seq, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
do_test_wait (thr_func f)
|
|
|
|
{
|
|
|
|
pthread_t w[NUM];
|
|
|
|
pthread_t s;
|
|
|
|
pthread_mutexattr_t attr;
|
|
|
|
int i, j, ret = 0;
|
|
|
|
void *thr_ret;
|
|
|
|
|
|
|
|
for (i = 0; i < COUNT; i++)
|
|
|
|
{
|
|
|
|
if ((ret = pthread_mutexattr_init (&attr)) != 0)
|
|
|
|
{
|
|
|
|
printf ("mutexattr_init failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-10-25 23:43:10 +02:00
|
|
|
if ((ret = pthread_mutexattr_setprotocol (&attr,
|
|
|
|
PTHREAD_PRIO_INHERIT)) != 0)
|
2012-10-10 08:47:27 +02:00
|
|
|
{
|
|
|
|
printf ("mutexattr_setprotocol failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret = pthread_cond_init (&cond, NULL)) != 0)
|
|
|
|
{
|
|
|
|
printf ("cond_init failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret = pthread_mutex_init (&mutex, &attr)) != 0)
|
|
|
|
{
|
|
|
|
printf ("mutex_init failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < NUM; j++)
|
2012-10-25 23:43:10 +02:00
|
|
|
if ((ret = pthread_create (&w[j], NULL,
|
|
|
|
f, (void *) (uintptr_t) j)) != 0)
|
2012-10-10 08:47:27 +02:00
|
|
|
{
|
|
|
|
printf ("waiter[%d]: create failed: %s\n", j, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret = pthread_create (&s, NULL, signaller, NULL)) != 0)
|
|
|
|
{
|
|
|
|
printf ("signaller: create failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < NUM; j++)
|
|
|
|
{
|
2012-10-17 17:32:56 +02:00
|
|
|
pthread_cancel (w[j]);
|
2012-10-10 08:47:27 +02:00
|
|
|
|
|
|
|
if ((ret = pthread_join (w[j], &thr_ret)) != 0)
|
|
|
|
{
|
|
|
|
printf ("waiter[%d]: join failed: %s\n", j, strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
|
|
|
|
{
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The signalling thread could have ended before it was cancelled. */
|
|
|
|
pthread_cancel (s);
|
|
|
|
|
|
|
|
if ((ret = pthread_join (s, &thr_ret)) != 0)
|
|
|
|
{
|
|
|
|
printf ("signaller: join failed: %s\n", strerror (ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
|
|
|
|
{
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
do_test (int argc, char **argv)
|
|
|
|
{
|
|
|
|
int ret = do_test_wait (waiter);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return do_test_wait (timed_waiter);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define TIMEOUT 5
|
|
|
|
#include "../test-skeleton.c"
|