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;
}
int
main()
{
int flags, newflags, child;
CHECKe(flags = fcntl(0, F_GETFL));
printf("flags = %x\n", flags);
CHECKe(child = fork());
switch(child) {
case 0: /* child */
CHECKe(execlp("./pthread_create", "./pthread_create",
(char *)NULL));
/* NOTREACHED */
default: /* parent */
CHECKe(wait(NULL));
break;
}
while(1){
CHECKe(newflags = fcntl(0, F_GETFL));
printf ("parent %d flags = %x\n", child, newflags);
sleep(1);
}
}
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;
}
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);
}
int
main(int argc, char **argv)
{
struct sigaction act;
act.sa_sigaction = act_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
ASSERT(sigaction(SIGUSR1, &act, NULL) == 0);
/* see if the signal handler recurses */
CHECKe(kill(getpid(), SIGUSR1));
sleep(1);
ASSERT(was_active == 0);
/* allow recursive handlers, see that it is handled right */
act.sa_flags |= SA_NODEFER;
ASSERT(sigaction(SIGUSR1, &act, NULL) == 0);
/* see if the signal handler recurses */
CHECKe(kill(getpid(), SIGUSR1));
sleep(1);
ASSERT(was_active == 1);
SUCCEED;
}
int
main(int argc, char *argv[])
{
int fd;
printf("This is the first message\n");
if (isatty(STDOUT_FILENO)) {
char *ttynm;
CHECKn(ttynm = ttyname(STDOUT_FILENO));
printf("tty is %s\n", ttynm);
CHECKe(fd = open(ttynm, O_RDWR));
} else {
printf("IGNORED: stdout is not a tty: this test needs a tty\n");
SUCCEED;
}
CHECKn(printf("This output is necessary to set the stdout fd to NONBLOCKING\n"));
/* do a dup2 */
CHECKe(dup2(fd, STDOUT_FILENO));
CHECKe(write(STDOUT_FILENO, should_succeed,
(size_t)strlen(should_succeed)));
CHECKe(execve(new_argv[0], new_argv, environ));
DIE(errno, "execve %s", new_argv[0]);
}
static void *
sleeper(void *arg)
{
sigset_t mask;
/* Ignore all signals in this thread */
sigfillset(&mask);
CHECKe(sigprocmask(SIG_SETMASK, &mask, NULL));
ASSERT(sleep(3) == 0);
CHECKe(write(STDOUT_FILENO, "\n", 1));
SUCCEED;
}
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));
}
}
}
void *
thr_accept(void *arg)
{
struct sockaddr_in sa;
socklen_t salen;
int s;
CHECKe(s = socket(AF_INET, SOCK_STREAM, 0));
bzero(&sa, sizeof(sa));
sa.sin_port = htons(6543);
CHECKe(bind(s, (const void*)&sa, sizeof(sa)));
CHECKe(listen(s, 10));
salen = sizeof(sa);
ASSERT(accept(s, (struct sockaddr *)&sa, &salen) == -1);
return ((caddr_t)NULL + errno);
}
static void *
sock_write(void *arg)
{
int fd = *(int *)arg;
SET_NAME("writer");
CHECKe(write(fd, MESSAGE5, sizeof(MESSAGE5)));
return(NULL);
}
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;
}
void *
thr_kevent(void *arg)
{
struct kevent ev;
struct timespec ts = { 10, 0 };
int kq;
CHECKe(kq = kqueue());
ASSERT(kevent(kq, NULL, 0, &ev, 1, &ts) == -1);
return ((caddr_t)NULL + errno);
}
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);
}
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;
}
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;
}
void *
thr_readv(void *arg)
{
struct iovec iov;
int fds[2];
char buf;
CHECKe(pipe(fds));
iov.iov_base = &buf;
iov.iov_len = 1;
ASSERT(readv(fds[0], &iov, 1) == -1);
return ((caddr_t)NULL + errno);
}
static void *
new_thread(void *arg)
{
int i;
SET_NAME("writer");
while (!ending) {
CHECKe(write (fd, (char *) arg, 1));
x[(char *)arg - buf] = 1;
for (i = 0; i < 999999; i += 1)
;
}
return NULL;
}
static void
act_handler(int signal, siginfo_t *siginfo, void *context)
{
struct sigaction sa;
char *str;
CHECKe(sigaction(SIGUSR1, NULL, &sa));
ASSERT(sa.sa_handler == SIG_DFL);
ASSERT(siginfo != NULL);
asprintf(&str, "act_handler: signal %d, siginfo %p, context %p\n",
signal, siginfo, context);
write(STDOUT_FILENO, str, strlen(str));
free(str);
}
static void
act_handler(int signal, siginfo_t *siginfo, void *context)
{
char *str;
/* how many times has the handler been called */
was_active += sigactive++;
sigcount += 1;
/* verify siginfo since we asked for it. */
ASSERT(siginfo != NULL);
asprintf(&str,
"%sact_handler/%d, signal %d, siginfo %p, context %p\n",
was_active ? "[recurse] " : "",
sigcount, signal, siginfo, context);
CHECKe(write(STDOUT_FILENO, str, strlen(str)));
/* Odd times entered send ourself the same signal */
if (sigcount & 1)
CHECKe(kill(getpid(), SIGUSR1));
sigactive = 0;
}
void *
thr_connect(void *arg)
{
struct sockaddr_in sa;
int s;
CHECKe(s = socket(AF_INET, SOCK_STREAM, 0));
bzero(&sa, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(23);
sa.sin_addr.s_addr = htonl(0xc7b98903); /* cvs.openbsd.org */
ASSERT(connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1);
return ((caddr_t)NULL + errno);
}
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);
}
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);
}
/*
* 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;
}
static void *
new_thread(void* arg)
{
fd_set r;
int ret;
char garbage[] = "blah blah blah";
FD_ZERO(&r);
FD_SET(fd, &r);
printf("child: writing some garbage to fd %d\n", fd);
CHECKe(write(fd, garbage, sizeof garbage));
printf("child: calling select() with fd %d\n", fd);
ASSERT((ret = select(fd + 1, &r, NULL, NULL, NULL)) == -1);
ASSERT(errno == EBADF);
printf("child: select() returned %d, errno %d = %s [correct]\n", ret,
errno, strerror(errno));
return NULL;
}
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;
}
static void *
thread(void * arg)
{
sigset_t run_mask;
sigset_t suspender_mask;
/* wait for sigusr1 */
SET_NAME(arg);
/* Run with all signals blocked, then suspend for SIGUSR1 */
sigfillset(&run_mask);
CHECKe(sigprocmask(SIG_SETMASK, &run_mask, NULL));
sigfillset(&suspender_mask);
sigdelset(&suspender_mask, SIGUSR1);
for (;;) {
sigsuspend(&suspender_mask);
ASSERT(errno == EINTR);
printf("Thread %s woke up\n", (char*) arg);
}
}
static void *
sigsuspender (void *arg)
{
int save_count, status, i;
sigset_t run_mask;
SET_NAME("sigsuspender");
/* Run with all signals blocked. */
sigfillset (&run_mask);
CHECKe(sigprocmask (SIG_SETMASK, &run_mask, NULL));
/* Allow these signals to wake us up during a sigsuspend. */
sigfillset (&suspender_mask); /* Default action */
sigdelset (&suspender_mask, SIGINT); /* terminate */
sigdelset (&suspender_mask, SIGHUP); /* terminate */
sigdelset (&suspender_mask, SIGQUIT); /* create core image */
sigdelset (&suspender_mask, SIGURG); /* ignore */
sigdelset (&suspender_mask, SIGIO); /* ignore */
sigdelset (&suspender_mask, SIGUSR2); /* terminate */
sigdelset (&suspender_mask, SIGSTOP); /* unblockable */
sigdelset (&suspender_mask, SIGKILL); /* unblockable */
while (sigcounts[SIGINT] == 0) {
save_count = sigcounts[SIGUSR2];
status = sigsuspend (&suspender_mask);
if ((status == 0) || (errno != EINTR)) {
DIE(errno, "Unable to suspend for signals, "
"return value %d\n",
status);
}
for (i = 0; i < fifo_depth; i++)
printf ("Sigsuspend woke up by signal %d (%s)\n",
sigfifo[i], strsignal(sigfifo[i]));
fifo_depth = 0;
}
return (arg);
}
int
main(int argc, char **argv)
{
int status;
pid_t pid;
ASSERT(signal(SIGCHLD, SIG_IGN) != SIG_ERR);
switch ((pid = fork())) {
case -1:
PANIC("fork");
case 0:
execl("/usr/bin/false", "false", NULL);
PANIC("execlp");
default:
break;
}
CHECKe(alarm(2));
ASSERT(wait(&status) == -1);
ASSERT(errno == ECHILD);
SUCCEED;
}
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;
}
static void
server(void)
{
int sock;
int client;
socklen_t client_addr_len;
struct sockaddr_in serv_addr;
struct sockaddr client_addr;
CHECKe(sock = socket(AF_INET, SOCK_STREAM, 0));
bzero((char *) &serv_addr, sizeof serv_addr);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
serv_addr.sin_port = htons(TEST_PORT);
CHECKe(bind(sock, (struct sockaddr *) &serv_addr, sizeof serv_addr));
CHECKe(listen(sock,3));
client_addr_len = sizeof client_addr;
CHECKe(client = accept(sock, &client_addr, &client_addr_len ));
CHECKe(close(sock));
discard(client);
CHECKe(close(client));
exit(0);
}
