/*
|
* Copyright (c) International Business Machines Corp., 2004.
|
*
|
* This program is free software; you can redistribute it and/or modify it
|
* under the terms of version 2 of the GNU General Public License as
|
* published by the Free Software Foundation.
|
*
|
* This program is distributed in the hope that it would be useful, but
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
*
|
* You should have received a copy of the GNU General Public License along
|
* with this program; if not, write the Free Software Foundation, Inc.,
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
*
|
*/
|
/**********************************************************
|
*
|
* TEST IDENTIFIER : nptl01
|
*
|
* EXECUTED BY : root
|
*
|
* TEST TITLE : NPTL test for pthread_cond_timedwait() error
|
* path bug.
|
*
|
* TEST CASE TOTAL : 1
|
*
|
* AUTHOR : Neil Richards <neil_richards@uk.ibm.com>
|
*
|
* DESCRIPTION
|
* This is a test for a bug found in the pthread_cond_timedwait() system call.
|
* of the Native POSIX Thread Library (NPTL) library code.
|
* There was an error path in the system call, where the sequence counters were
|
* getting updated w/o holding the internal condvar lock. A FAIL is indicated
|
* by the test hanging and not completing execution.
|
*
|
****************************************************************/
|
#define _GNU_SOURCE
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <pthread.h>
|
#include <errno.h>
|
#include <unistd.h>
|
#include <time.h>
|
#include <sys/time.h>
|
#include "test.h"
|
|
#define MAXTIME 72000 /* Maximum # of secs to wait before failing */
|
#define NUMLOOPS 100000 /* # of loops */
|
|
char *TCID = "nptl01"; /* Test program identifier. */
|
int TST_TOTAL = 1; /* Total number of test cases. */
|
void cleanup();
|
|
pthread_mutex_t req;
|
pthread_mutex_t ack;
|
pthread_mutex_t wait;
|
pthread_cond_t parent;
|
pthread_cond_t child;
|
int idle_count = 0;
|
|
/*
|
* The time to wait should be set appropriately so that the waiting thread
|
* is coming out of the wait at around the same time as the other thread is
|
* signalling it.
|
* The value of 1000 seems to work (ie. demonstrate the problem) on my
|
* 8 way (hyperthreaded) 2GHz Xeon box.
|
*/
|
#define NSECS_TO_WAIT (1)
|
|
void call_mutex_init(pthread_mutex_t * mutex, char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_mutex_init(mutex, NULL)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_mutex_init failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void call_mutex_lock(pthread_mutex_t * mutex, char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_mutex_lock(mutex)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_mutex_lock failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void call_mutex_unlock(pthread_mutex_t * mutex, char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_mutex_unlock(mutex)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_mutex_unlock failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void call_cond_init(pthread_cond_t * cond, char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_cond_init(cond, NULL)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_cond_init failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void call_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex,
|
char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_cond_wait(cond, mutex)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_cond_wait failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void call_cond_signal(pthread_cond_t * cond, char *buf, size_t buf_len)
|
{
|
int ret;
|
|
if ((ret = pthread_cond_signal(cond)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_cond_signal failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void do_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex,
|
char *buf, size_t buf_len, int i)
|
{
|
struct timeval tv;
|
struct timespec ts;
|
int ret;
|
|
if (gettimeofday(&tv, NULL) != 0) {
|
tst_brkm(TBROK, cleanup, "gettimeofday failed: %s",
|
strerror_r(errno, buf, buf_len));
|
}
|
|
ts.tv_sec = tv.tv_sec;
|
ts.tv_nsec = (tv.tv_usec * 1000) + NSECS_TO_WAIT;
|
ts.tv_sec += ts.tv_nsec / 1000000000;
|
ts.tv_nsec = ts.tv_nsec % 1000000000;
|
|
call_mutex_lock(mutex, buf, buf_len);
|
if ((ret = pthread_cond_timedwait(cond, mutex, &ts)) != ETIMEDOUT) {
|
#if DEBUG
|
tst_resm(TINFO,
|
"Loop %d of 1000000: pthread_cond_timedwait() didn't timeout",
|
i);
|
tst_resm(TINFO,
|
"You may want to try reducing the value of NSECS_TO_WAIT (currently=%d)",
|
NSECS_TO_WAIT);
|
#endif
|
}
|
call_mutex_unlock(mutex, buf, buf_len);
|
|
}
|
|
void *run(void *arg)
|
{
|
char buf[1024];
|
|
while (1) {
|
call_mutex_lock(&ack, buf, sizeof(buf));
|
idle_count = 1;
|
call_cond_signal(&parent, buf, sizeof(buf));
|
call_mutex_lock(&req, buf, sizeof(buf));
|
call_mutex_unlock(&ack, buf, sizeof(buf));
|
|
call_mutex_lock(&wait, buf, sizeof(buf));
|
call_cond_signal(&parent, buf, sizeof(buf));
|
call_mutex_unlock(&wait, buf, sizeof(buf));
|
|
call_cond_wait(&child, &req, buf, sizeof(buf));
|
call_mutex_unlock(&req, buf, sizeof(buf));
|
}
|
}
|
|
void create_child_thread(char *buf, size_t buf_len)
|
{
|
pthread_attr_t attr;
|
pthread_t child_tid;
|
int ret;
|
|
if ((ret = pthread_attr_init(&attr)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_attr_init failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
if ((ret = pthread_attr_setdetachstate(&attr,
|
PTHREAD_CREATE_DETACHED)) != 0) {
|
tst_brkm(TBROK, cleanup,
|
"pthread_attr_setdetachstate failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
if ((ret = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_attr_setscope failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
|
if ((ret = pthread_create(&child_tid, &attr, run, NULL)) != 0) {
|
tst_brkm(TBROK, cleanup, "pthread_create failed: %s",
|
strerror_r(ret, buf, buf_len));
|
}
|
}
|
|
void trap_alarm(int sig)
|
{
|
tst_brkm(TFAIL, cleanup, "Test hang longer than %d sec detected",
|
MAXTIME);
|
}
|
|
static void usage(const char *progname)
|
{
|
fprintf(stderr, "usage: %s -l loops\n", progname);
|
fprintf(stderr, "\t-l specify the number of loops to carry out\n");
|
}
|
|
int main(int argc, char **argv)
|
{
|
#ifdef USING_NPTL
|
char buf[1024];
|
int i;
|
extern char *optarg;
|
int numloops = NUMLOOPS;
|
|
while ((i = getopt(argc, argv, "l:")) != -1) {
|
switch (i) {
|
case 'l':
|
if (optarg)
|
numloops = atoi(optarg);
|
else
|
fprintf(stderr,
|
"%s: option -l requires an argument\n",
|
argv[0]);
|
break;
|
default:
|
usage(argv[0]);
|
exit(1);
|
}
|
}
|
|
signal(SIGALRM, trap_alarm);
|
alarm(MAXTIME);
|
|
call_mutex_init(&req, buf, sizeof(buf));
|
call_mutex_init(&ack, buf, sizeof(buf));
|
call_mutex_init(&wait, buf, sizeof(buf));
|
call_cond_init(&parent, buf, sizeof(buf));
|
call_cond_init(&child, buf, sizeof(buf));
|
|
call_mutex_lock(&ack, buf, sizeof(buf));
|
|
create_child_thread(buf, sizeof(buf));
|
|
tst_resm(TINFO, "Starting test, please wait.");
|
for (i = 0; i < numloops; i++) {
|
while (idle_count == 0) {
|
call_cond_wait(&parent, &ack, buf, sizeof(buf));
|
};
|
idle_count = 0;
|
call_mutex_unlock(&ack, buf, sizeof(buf));
|
|
do_timedwait(&parent, &wait, buf, sizeof(buf), i);
|
|
call_mutex_lock(&req, buf, sizeof(buf));
|
call_cond_signal(&child, buf, sizeof(buf));
|
call_mutex_unlock(&req, buf, sizeof(buf));
|
#ifdef DEBUG
|
tst_resm(TINFO, "Success in loop %d", i);
|
#else
|
if (((i % (numloops / 10)) == 0) && (i != 0))
|
tst_resm(TINFO, "Success thru loop %d of %i", i,
|
numloops);
|
#endif
|
call_mutex_lock(&ack, buf, sizeof(buf));
|
}
|
|
alarm(0);
|
tst_resm(TPASS, "Test completed successfully!");
|
cleanup();
|
|
#else
|
tst_brkm(TCONF, NULL,
|
"Skipping Execution - This system is not using NPTL");
|
#endif
|
|
return 1;
|
}
|
|
/*
|
*cleanup() - performs all ONE TIME cleanup for this test at
|
* completion or premature exit.
|
*/
|
void cleanup()
|
{
|
|
tst_exit();
|
}
|
