/* * 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 * * 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 #include #include #include #include #include #include #include #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(); }