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); }