xref: /third_party/ltp/testcases/kernel/sched/nptl/nptl01.c

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