Ejemplo n.º 1
0
int
main(int argc, char **argv)
{
	struct sigaction sa;
	pthread_t tid;
	void *retval;

	bzero(&sa, sizeof(sa));
	sa.sa_handler = handler;
	sa.sa_flags = SA_RESTART;
	CHECKe(sigaction(SIGUSR1, &sa, NULL));
	sa.sa_flags = 0;
	CHECKe(sigaction(SIGUSR2, &sa, NULL));

	CHECKr(pthread_create(&tid, NULL, thr_accept, NULL));
	sleep(2);

	/* Should restart it. */
	CHECKr(pthread_kill(tid, SIGUSR1));
	sleep(1);

	/* Should interrupt it. */
	CHECKr(pthread_kill(tid, SIGUSR2));
	sleep(1);

	CHECKr(pthread_join(tid, &retval));
	ASSERT(retval == (void *)EINTR);
	ASSERT(hits == 2);
	SUCCEED;
}
Ejemplo n.º 2
0
int
main(int argc, char **argv)
{
	pthread_t thread1;
	pthread_t thread2;
	struct sigaction act;

	act.sa_sigaction = act_handler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO | SA_RESETHAND | SA_NODEFER;
	CHECKe(sigaction(SIGUSR1, &act, NULL));
	CHECKr(pthread_create(&thread1, NULL, thread, "T1"));
	CHECKr(pthread_create(&thread2, NULL, thread, "T2"));
	sleep(1);

	/* Signal handler should run once, both threads should awaken */
	CHECKe(kill(getpid(), SIGUSR1));
	sleep(1);

	/* Signal handler run once, only T1 should awaken */
	CHECKe(sigaction(SIGUSR1, &act, NULL));
	CHECKr(pthread_kill(thread1, SIGUSR1));
	sleep(1);

	/* Signal handler run once, only T2 should awaken */
	CHECKe(sigaction(SIGUSR1, &act, NULL));
	CHECKr(pthread_kill(thread2, SIGUSR1));
	sleep(1);

	SUCCEED;
}
Ejemplo n.º 3
0
int
main(int argc, char **argv)
{
	pthread_t d, t, self = pthread_self();
	pid_t pid;

	switch ((pid = fork())) {
	case -1:
		PANIC("cannot fork");
		/* NOTREACHED */

	case 0:
		/* child */
		break;

	default:
		CHECKr(waitpid(pid, NULL, 0));
		_exit(0);
		/* NOTREACHED */
	}

        CHECKr(pthread_create(&d, NULL, deadlock_detector, NULL));
	CHECKr(pthread_create(&t, NULL, joiner, &self));
	CHECKr(pthread_join(t, NULL));
	SUCCEED;
}
Ejemplo n.º 4
0
/*
 * Test that closefrom does the right thing in a threaded programs,
 * specifically that it doesn't kill the thread kernel signal pipe.
 */
int
main(int argc, char *argv[])
{
	pthread_t thread;
	void *status;
	int fd;
	int result;

	/* close files above stderr.   The kernel pipes shouldn't be touched */
	fd = STDERR_FILENO + 1;
	result = closefrom(fd);
	printf("closefrom(%d) == %d/%d\n", fd, result, errno);

	/* do it again: make sure that the result is -1/EBADF */
	result = closefrom(fd);
	printf("closefrom(%d) == %d/%d\n", fd, result, errno);
	ASSERT(result == -1 && errno == EBADF);

	/* start a thread to verify the thread kernel is working */
	CHECKr(pthread_create(&thread, NULL, dummy_thread, NULL));
	CHECKr(pthread_join(thread, &status));
	printf("dummy thread exited with status %p\n", status);

	SUCCEED;
	return 0;
}
Ejemplo n.º 5
0
static void
test_nocontention_lock(pthread_mutex_t *mutex)
{
	printf("  test_nocontention_lock()\n");
	CHECKr(pthread_mutex_lock(mutex));
	CHECKr(pthread_mutex_unlock(mutex));
}
Ejemplo n.º 6
0
static void
test_debug_double_lock(pthread_mutex_t *mutex)
{
	printf("  test_debug_double_lock()\n");
	CHECKr(pthread_mutex_lock(mutex));
	ASSERTe(pthread_mutex_lock(mutex), == EDEADLK);
	CHECKr(pthread_mutex_unlock(mutex));
}
Ejemplo n.º 7
0
int
main(int argc, char **argv)
{
	pthread_t accept_thread;

	CHECKr(pthread_create(&accept_thread, NULL, sock_accept, NULL));
	CHECKr(pthread_join(accept_thread, NULL));
	SUCCEED;
}
Ejemplo n.º 8
0
static void
test_debug_double_unlock(pthread_mutex_t *mutex)
{
	printf("  test_debug_double_unlock()\n");
	CHECKr(pthread_mutex_lock(mutex));
	CHECKr(pthread_mutex_unlock(mutex));
	/* Posix D10 says undefined behaviour? */
	ASSERTe(pthread_mutex_unlock(mutex), != 0);
}
Ejemplo n.º 9
0
/*
 * Install a signal handler for sigusr1 and then wait for it to
 * occur.
 */
static void *
do_nothing (void *arg)
{
	SET_NAME("nothing");

	ASSERT(signal(SIGUSR1, sighandler) != SIG_ERR);
	CHECKr(pthread_mutex_lock(&sync_mutex));
	ASSERT(got_signal != 0);
	CHECKr(pthread_mutex_unlock(&sync_mutex));
	return 0;
}
Ejemplo n.º 10
0
static void
test_mutex_fast(void)
{
	pthread_mutex_t mutex_fast; 

	printf("test_mutex_fast()\n");
	CHECKr(pthread_mutex_init(&mutex_fast, NULL));
	test_nocontention_lock(&mutex_fast);
	test_nocontention_trylock(&mutex_fast);
	test_contention_lock(&mutex_fast);
	CHECKr(pthread_mutex_destroy(&mutex_fast));
}
Ejemplo n.º 11
0
static void * 
thread_contention(void *arg)
{
	pthread_mutex_t *mutex = arg;

	SET_NAME("cntntn");

	CHECKr(pthread_mutex_lock(mutex));
	ASSERT(contention_variable == 1);
	contention_variable = 2;
	CHECKr(pthread_mutex_unlock(mutex));
	pthread_exit(NULL);
}
Ejemplo n.º 12
0
int
main(int argc, char *argv[])
{
	pthread_t thread;
	int pipe_fd[2];

	CHECKe(pipe(pipe_fd));
	CHECKr(pthread_create(&thread, NULL, select_thread, pipe_fd));
	sleep(2);
	CHECKr(pthread_cancel(thread));
	CHECKr(pthread_join(thread, NULL));
	SUCCEED;
}
Ejemplo n.º 13
0
int
main(int argc, char **argv)
{
	pthread_t tid;

	CHECKr(pthread_create(&tid, NULL, forker1, NULL));
	CHECKr(pthread_join(tid, NULL));
	ASSERT(cnt == 1);
	CHECKr(pthread_create(&tid, NULL, forker2, NULL));
	CHECKr(pthread_join(tid, NULL));
	ASSERT(cnt == 0);
	SUCCEED;
}
Ejemplo n.º 14
0
/*
 * Test that masked signals with a default action of terminate process
 * do NOT terminate the process.
 */
int main (int argc, char *argv[])
{
	sigset_t mask;
	int sig;
	int r;

	/* any two (or more) command line args should cause the program
	   to die */
	if (argc > 2) {
		printf("trigger sigalrm[1] [test should die]\n");
		ualarm(100000, 0);
		CHECKe(sleep(1));
	}

	/* mask sigalrm */
	CHECKe(sigemptyset(&mask));
	CHECKe(sigaddset(&mask, SIGALRM));
	CHECKr(pthread_sigmask(SIG_BLOCK, &mask, NULL));

	/* make sure pthread_sigmask() returns the right value on failure */
	r = pthread_sigmask(-1, &mask, NULL);
	ASSERTe(r, == EINVAL);

	/* now trigger sigalrm and wait for it */
	printf("trigger sigalrm[2] [masked, test should not die]\n");
	ualarm(100000, 0);
	CHECKe(sleep(1));

	/* sigwait for sigalrm, it should be pending.   If it is not
	   the test will hang. */
	CHECKr(sigwait(&mask, &sig));
	ASSERT(sig == SIGALRM);

	/* make sure sigwait didn't muck with the mask by triggering
	   sigalrm, again */
	printf("trigger sigalrm[3] after sigwait [masked, test should not die]\n");
	ualarm(100000, 0);
	CHECKe(sleep(1));

	/* any single command line arg will run this code wich unmasks the
	   signal and then makes sure the program terminates when sigalrm
	   is triggered. */
	if (argc > 1) {
		printf("trigger sigalrm[4] [unmasked, test should die]\n");
		CHECKr(pthread_sigmask(SIG_UNBLOCK, &mask, NULL));
		ualarm(100000, 0);
		CHECKe(sleep(1));
	}
	
	SUCCEED;
}
Ejemplo n.º 15
0
static void
test_mutex_recursive_trylock(pthread_mutex_t *mutex)
{
	int i;
	int j = 9;

	printf("  %s()\n", __func__);
	CHECKr(pthread_mutex_trylock(mutex));
	for (i = 0; i < j; i++)
		CHECKr(pthread_mutex_trylock(mutex));
	for (i = 0; i < j; i++)
		CHECKr(pthread_mutex_unlock(mutex));
	CHECKr(pthread_mutex_unlock(mutex));
}
Ejemplo n.º 16
0
int
main(int argc, char **argv)
{
	pthread_t prod_th, cons_th;
	long counter = 4;

	CHECKn(sem_destroy(&cons_sem));
	ASSERT(errno == EINVAL);

	val = 0;

	CHECKr(sem_init(&cons_sem, 0, 0));
	CHECKr(sem_init(&prod_sem, 0, 1));

	CHECKr(pthread_create(&prod_th, NULL, producer, &counter));
	CHECKr(pthread_create(&cons_th, NULL, consumer, &counter));

	CHECKr(pthread_join(prod_th, NULL));
	CHECKr(pthread_join(cons_th, NULL));

	pthread_exit(NULL);

	CHECKr(sem_destroy(&prod_sem));
	CHECKr(sem_destroy(&cons_sem));

	SUCCEED;
}
Ejemplo n.º 17
0
int
main(int argc, char *argv[])
{
	pthread_t thread;

	setbuf(stdout, NULL);
	setbuf(stderr, NULL);

	CHECKr(pthread_create(&thread, NULL, sock_accept, 
	    (void *)0xdeadbeaf));

	CHECKr(pthread_join(thread, NULL));

	SUCCEED;
}
Ejemplo n.º 18
0
static void *
sock_connect(void *arg)
{
	struct timeval to;
	pid_t child_pid;
	int status;
	int s;

	CHECKe(s = socket(AF_INET, SOCK_STREAM, 0));
	to.tv_sec = 2;
	to.tv_usec = 0.5 * 1e6;
	CHECKe(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to)));
	CHECKe(child_pid = fork());
	if (child_pid == 0) {
		char *argv[3];
		char fdstr[3];
		snprintf(fdstr, sizeof(fdstr), "%d", s);
		argv[0] = "setsockopt3a";
		argv[1] = fdstr;
		argv[2] = NULL;
		execv(argv[0], argv);
		_exit(NOTOK);
	}
	ASSERTe(wait(&status), == child_pid);
	ASSERT(WIFEXITED(status));
	CHECKr(WEXITSTATUS(status));
	return (NULL);
}
Ejemplo n.º 19
0
static void *
waiter(void *arg)
{
	int status;
	pid_t pid;

	SET_NAME("waiter");
	CHECKr(pthread_mutex_lock(&waiter_mutex));
	printf("waiting for child\n");
	CHECKe(pid = wait(&status));
	ASSERT(WIFEXITED(status));
	ASSERT(WEXITSTATUS(status) == 0);
	printf("child exited\n");
	CHECKr(pthread_mutex_unlock(&waiter_mutex));
	return (NULL);
}
Ejemplo n.º 20
0
static void
test_contention_lock(pthread_mutex_t *mutex)
{
	pthread_t thread;

	printf("  test_contention_lock()\n");
	CHECKr(pthread_mutex_lock(mutex));
	contention_variable = 0;
	CHECKr(pthread_create(&thread, NULL, thread_contention, mutex));
	pthread_yield();
	contention_variable = 1;
	CHECKr(pthread_mutex_unlock(mutex));
	pthread_yield();
	CHECKr(pthread_mutex_lock(mutex));
	ASSERT(contention_variable == 2);
	CHECKr(pthread_mutex_unlock(mutex));
}
Ejemplo n.º 21
0
static void
test_mutex_recursive(void)
{
	pthread_mutexattr_t mutex_recursive_attr; 
	pthread_mutex_t mutex_recursive; 

	printf("test_mutex_recursive()\n");
	CHECKr(pthread_mutexattr_init(&mutex_recursive_attr));
	CHECKr(pthread_mutexattr_settype(&mutex_recursive_attr, 
	    PTHREAD_MUTEX_RECURSIVE));
	CHECKr(pthread_mutex_init(&mutex_recursive, &mutex_recursive_attr));
	test_mutex_recursive_lock(&mutex_recursive);
	test_mutex_recursive_trylock(&mutex_recursive);
	/* Posix D10 says undefined behaviour? */
	ASSERTe(pthread_mutex_unlock(&mutex_recursive), != 0);
	CHECKr(pthread_mutex_destroy(&mutex_recursive));
}
Ejemplo n.º 22
0
static void
test_mutex_debug(void)
{
	pthread_mutexattr_t mutex_debug_attr; 
	pthread_mutex_t mutex_debug; 

	printf("test_mutex_debug()\n");
	CHECKr(pthread_mutexattr_init(&mutex_debug_attr));
	CHECKr(pthread_mutexattr_settype(&mutex_debug_attr, 
	    PTHREAD_MUTEX_ERRORCHECK));
	CHECKr(pthread_mutex_init(&mutex_debug, &mutex_debug_attr));
	test_nocontention_lock(&mutex_debug);
	test_nocontention_trylock(&mutex_debug);
	test_contention_lock(&mutex_debug);
	test_debug_double_lock(&mutex_debug);
	test_debug_double_unlock(&mutex_debug);
	CHECKr(pthread_mutex_destroy(&mutex_debug));
}
Ejemplo n.º 23
0
void *
thr_join(void *arg)
{
	pthread_t tid = *(pthread_t *)arg;
	void *retval;

	CHECKr(pthread_join(tid, &retval));
	return (retval);
}
Ejemplo n.º 24
0
int
main(int argc, char *argv[])
{
	pthread_t thread;
	pthread_attr_t attr;
	struct sockaddr_in addr;
	int ret;

	/* fork and have the child open a listener */
	signal(SIGCHLD, SIG_IGN);
	switch (fork()) {
	case 0:
		server();
		exit(0);
	case -1:
		exit(errno);
	default:
		sleep(2);
	}

	/* Open up a TCP connection to the local discard port */
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	addr.sin_port = htons(TEST_PORT);

	CHECKe(fd = socket(AF_INET, SOCK_STREAM, 0));
	printf("main: connecting to test port with fd %d\n", fd);
	ret = connect(fd, (struct sockaddr *)&addr, sizeof addr);
	if (ret == -1)
		fprintf(stderr, "connect() failed\n");
	CHECKe(ret);
	printf("main: connected on fd %d\n", fd);

	CHECKr(pthread_attr_init(&attr));
	CHECKr(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
	printf("starting child thread\n");
	CHECKr(pthread_create(&thread, &attr, new_thread, NULL));
	sleep(1);
	printf("main: closing fd %d\n", fd);
	CHECKe(close(fd));
	printf("main: closed\n");
	sleep(1);
	SUCCEED;
}
Ejemplo n.º 25
0
static void *
sock_accept(void *arg)
{
	pthread_t connect_thread;
	struct sockaddr_in sin;
	int s;

	CHECKe(s = socket(AF_INET, SOCK_STREAM, 0));
	bzero(&sin, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_len = sizeof(sin);
	sin.sin_port = htons(6543);
	sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	CHECKe(bind(s, (struct sockaddr *)&sin, sizeof(sin)));
	CHECKe(listen(s, 2));

	CHECKr(pthread_create(&connect_thread, NULL, sock_connect, NULL));
	CHECKr(pthread_join(connect_thread, NULL));
	return (NULL);
}
Ejemplo n.º 26
0
int
main(int argc, char *argv[])
{
	pthread_t waiting_threads[WAITING_THREADS];
	pthread_t deadlock_thread;
	struct sockaddr_in addr;
	int fd, newfd, i, j;
	void *value_ptr;
	struct timespec rqtp;

	rqtp.tv_sec = 0;
	rqtp.tv_nsec = 1000000;

	bzero((char *) &addr, sizeof addr);
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	addr.sin_port = htons(0);

	CHECKr(pthread_create(&deadlock_thread, NULL,
	    deadlock_detector, NULL));

	CHECKe(fd = socket(AF_INET, SOCK_DGRAM, 0));
 	CHECKr(bind(fd, (struct sockaddr *)&addr, sizeof(addr)));

	CHECKe(newfd = socket(AF_INET, SOCK_DGRAM, 0));
 	CHECKr(bind(newfd, (struct sockaddr *)&addr, sizeof(addr)));

	for (i = 0; i < ITERATIONS; i++) {
		for (j = 0; j < WAITING_THREADS; j++)
			CHECKr(pthread_create(&waiting_threads[j], NULL,
			    waiting_read, (void *)&newfd));
		nanosleep(&rqtp, NULL);
		CHECKe(dup2(fd, newfd));
		for (j = 0; j < WAITING_THREADS; j++) {
			CHECKr(pthread_join(waiting_threads[j], &value_ptr));
			ASSERT(value_ptr == (void *)EBADF);
		}
	}	
	SUCCEED;
}
Ejemplo n.º 27
0
int
main(int argc, char **argv)
{
	struct sigaction sa;
	pthread_t tid[2];
	void *retval;

	bzero(&sa, sizeof(sa));
	sa.sa_handler = handler;
	CHECKe(sigaction(SIGUSR1, &sa, NULL));

	CHECKr(pthread_create(&tid[0], NULL, thr_sleep, NULL));
	CHECKr(pthread_create(&tid[1], NULL, thr_join, &tid[0]));
	sleep(2);

	CHECKr(pthread_kill(tid[1], SIGUSR1));
	sleep(2);

	ASSERT(hits == 1);
	CHECKr(pthread_join(tid[1], &retval));
	ASSERT(retval == (void *)0);
	SUCCEED;
}
Ejemplo n.º 28
0
static void *
sigwaiter (void *arg)
{
	int signo;

	SET_NAME("sigwaiter");

	/* Block all of the signals that the function will wait for */
	CHECKe(sigprocmask (SIG_BLOCK, &wait_mask, NULL));

	while (sigcounts[SIGINT] == 0) {
		printf("Sigwait waiting (thread %p)\n", pthread_self());
		CHECKe(sigwait (&wait_mask, &signo));
		sigcounts[signo]++;
		printf ("Sigwait caught signal %d (%s)\n", signo, 
		    strsignal(signo));

		/* Allow the main thread to prevent the sigwait. */
		CHECKr(pthread_mutex_lock (&waiter_mutex));
		CHECKr(pthread_mutex_unlock (&waiter_mutex));
	}

	return (arg);
}
Ejemplo n.º 29
0
int
main(int argc, char *argv[])
{
	pthread_t slpr;

	ASSERT(signal(SIGALRM, handler) != SIG_ERR);
	CHECKe(alarm(1));
	CHECKr(pthread_create(&slpr, NULL, sleeper, NULL));
	/* ASSERT(sleep(1) == 0); */
	for (;;) {
		if (alarmed) {
			alarmed = 0;
			CHECKe(write(STDOUT_FILENO, "!", 1));
		}
	}
}
Ejemplo n.º 30
0
int
main(int argc, char *argv[])
{
	pthread_t thread;
	int ch, count = 4;
	long i;

	/* Getopt variables. */
	extern char *optarg;

	while ((ch = getopt(argc, argv, "c:?")) != -1)
	  switch (ch)
	    {
	    case 'c':
	      count = atoi(optarg);
	      if ((count > 26) || (count < 2)) {
			  count = 2;
	      }
	      break;
	    case '?':
	      usage();
	      return(OK);
	    default:
	      usage();
	      return(NOTOK);
	    }

	/* create the threads */
	for (i = 0; i < count; i++)
		CHECKr(pthread_create(&thread, NULL, new_thread, 
		    (void*)(buf+i)));

	/* give all threads a chance to run */
	sleep (2);

	ending = 1;
	for (i = 0; i < count; i++)
		ASSERT(x[i]);	/* make sure each thread ran */

	CHECKe(write(STDOUT_FILENO, "\n", 1));
	SUCCEED;
}