From 708b54cada892fbaa79bc68156aeea7359721039 Mon Sep 17 00:00:00 2001 From: thorpej Date: Wed, 25 Aug 1999 04:35:34 +0000 Subject: [PATCH] Add a simple (very simple) test program for the System V Semaphores facility. XXX No, really, this is very simple. It tests but a small fraction of this facility, but it is enough to verify that I didn't break anything with some forthcoming changes to the kernel. --- regress/sys/kern/sysvsem/Makefile | 14 ++ regress/sys/kern/sysvsem/semtest.c | 331 +++++++++++++++++++++++++++++ 2 files changed, 345 insertions(+) create mode 100644 regress/sys/kern/sysvsem/Makefile create mode 100644 regress/sys/kern/sysvsem/semtest.c diff --git a/regress/sys/kern/sysvsem/Makefile b/regress/sys/kern/sysvsem/Makefile new file mode 100644 index 000000000000..1df8911b3a0f --- /dev/null +++ b/regress/sys/kern/sysvsem/Makefile @@ -0,0 +1,14 @@ +# $NetBSD: Makefile,v 1.1 1999/08/25 04:35:34 thorpej Exp $ + +PROG= semtest +MKMAN= no +WARNS= 1 + +regress: + @if ./semtest ${.OBJDIR}/semtest; then \ + echo "PASSED"; \ + else \ + echo "FAILED"; \ + fi + +.include diff --git a/regress/sys/kern/sysvsem/semtest.c b/regress/sys/kern/sysvsem/semtest.c new file mode 100644 index 000000000000..fa66ee5a79f3 --- /dev/null +++ b/regress/sys/kern/sysvsem/semtest.c @@ -0,0 +1,331 @@ +/* $NetBSD: semtest.c,v 1.1 1999/08/25 04:35:34 thorpej Exp $ */ + +/*- + * Copyright (c) 1999 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, + * NASA Ames Research Center. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Test the SVID-compatible Semaphore facility. + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +int main __P((int, char *[])); +void print_semid_ds __P((struct semid_ds *, mode_t)); +void sigsys_handler __P((int)); +void sigchld_handler __P((int)); +void cleanup __P((void)); +void waiter __P((void)); +void usage __P((void)); + +int sender_semid = -1; +pid_t child_pid; +int child_count; +int signal_was_sigchld; + +key_t semkey; + +int +main(argc, argv) + int argc; + char *argv[]; +{ + struct sigaction sa; + struct semid_ds s_ds; + sigset_t sigmask; + int i; + + if (argc != 2) + usage(); + + /* + * Install a SIGSYS handler so that we can exit gracefully if + * System V Semaphore support isn't in the kernel. + */ + sa.sa_handler = sigsys_handler; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + if (sigaction(SIGSYS, &sa, NULL) == -1) + err(1, "sigaction SIGSYS"); + + /* + * Install and SIGCHLD handler to deal with all possible exit + * conditions of the receiver. + */ + sa.sa_handler = sigchld_handler; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + if (sigaction(SIGCHLD, &sa, NULL) == -1) + err(1, "sigaction SIGCHLD"); + + semkey = ftok(argv[1], 4160); + + /* + * Initialize child_pid to ourselves to that the cleanup function + * works before we create the receiver. + */ + child_pid = getpid(); + + /* + * Make sure that when the sender exits, the message queue is + * removed. + */ + if (atexit(cleanup) == -1) + err(1, "atexit"); + + if ((sender_semid = semget(semkey, 1, IPC_CREAT | 0640)) == -1) + err(1, "semget"); + + if (semctl(sender_semid, 0, IPC_STAT, &s_ds) == -1) + err(1, "semctl IPC_STAT"); + + print_semid_ds(&s_ds, 0640); + + s_ds.sem_perm.mode = (s_ds.sem_perm.mode & ~0777) | 0600; + + if (semctl(sender_semid, 0, IPC_SET, &s_ds) == -1) + err(1, "semctl IPC_SET"); + + memset(&s_ds, 0, sizeof(s_ds)); + + if (semctl(sender_semid, 0, IPC_STAT, &s_ds) == -1) + err(1, "semctl IPC_STAT"); + + if ((s_ds.sem_perm.mode & 0777) != 0600) + err(1, "IPC_SET of mode didn't hold"); + + print_semid_ds(&s_ds, 0600); + + for (child_count = 0; child_count < 5; child_count++) { + switch ((child_pid = fork())) { + case -1: + err(1, "fork"); + /* NOTREACHED */ + + case 0: + waiter(); + break; + + default: + break; + } + } + + /* + * Wait for all of the waiters to be attempting to acquire the + * semaphore. + */ + for (;;) { + i = semctl(sender_semid, 0, GETNCNT); + if (i == -1) + err(1, "semctl GETNCNT"); + if (i == 5) + break; + } + + /* + * Now set the thundering herd in motion by initializing the + * semaphore to the value 1. + */ + if (semctl(sender_semid, 0, SETVAL, 1) == -1) + err(1, "sender: semctl SETVAL to 1"); + + /* + * Suspend forever; when we get SIGCHLD, the handler will exit. + */ + sigemptyset(&sigmask); + for (;;) { + (void) sigsuspend(&sigmask); + if (signal_was_sigchld) + signal_was_sigchld = 0; + else + break; + } + + /* + * ...and any other signal is an unexpected error. + */ + errx(1, "sender: received unexpected signal"); +} + +void +sigsys_handler(signo) + int signo; +{ + + errx(1, "System V Semaphore support is not present in the kernel"); +} + +void +sigchld_handler(signo) + int signo; +{ + struct semid_ds s_ds; + int cstatus; + + /* + * Reap the child; if it exited successfully, then we're on the + * right track! + */ + if (wait(&cstatus) == -1) + err(1, "wait"); + + if (WIFEXITED(cstatus) == 0) + errx(1, "receiver exited abnormally"); + + if (WEXITSTATUS(cstatus) != 0) + errx(1, "receiver exited with status %d\n", + WEXITSTATUS(cstatus)); + + /* + * If we get here, the child has exited normally, and we should + * decrement the child count. If the child_count reaches 0, we + * should exit. + */ + + if (semctl(sender_semid, 0, IPC_STAT, &s_ds) == -1) + err(1, "semctl IPC_STAT"); + + print_semid_ds(&s_ds, 0600); + + if (--child_count != 0) { + signal_was_sigchld = 1; + return; + } + + exit(0); +} + +void +cleanup() +{ + + /* + * If we're the sender, and it exists, remove the message queue. + */ + if (child_pid != 0 && sender_semid != -1) { + if (semctl(sender_semid, 0, IPC_RMID) == -1) + warn("semctl IPC_RMID"); + } +} + +void +print_semid_ds(sp, mode) + struct semid_ds *sp; + mode_t mode; +{ + uid_t uid = geteuid(); + gid_t gid = getegid(); + + printf("PERM: uid %d, gid %d, cuid %d, cgid %d, mode 0%o\n", + sp->sem_perm.uid, sp->sem_perm.gid, + sp->sem_perm.cuid, sp->sem_perm.cgid, + sp->sem_perm.mode & 0777); + + printf("nsems %u\n", sp->sem_nsems); + + printf("otime: %s", ctime(&sp->sem_otime)); + printf("ctime: %s", ctime(&sp->sem_ctime)); + + /* + * Sanity check a few things. + */ + + if (sp->sem_perm.uid != uid || sp->sem_perm.cuid != uid) + errx(1, "uid mismatch"); + + if (sp->sem_perm.gid != gid || sp->sem_perm.cgid != gid) + errx(1, "gid mismatch"); + + if ((sp->sem_perm.mode & 0777) != mode) + errx(1, "mode mismatch"); +} + +void +usage() +{ + extern const char *__progname; + + fprintf(stderr, "usage: %s keypath\n", __progname); + exit(1); +} + +void +waiter() +{ + struct sembuf s; + int semid; + + if ((semid = semget(semkey, 1, 0)) == -1) + err(1, "waiter: semget"); + + /* + * Attempt to acquire the semaphore. + */ + s.sem_num = 0; + s.sem_op = -1; + s.sem_flg = SEM_UNDO; + + if (semop(semid, &s, 1) == -1) + err(1, "waiter: semop -1"); + + printf("WOO! GOT THE SEMAPHORE!\n"); + sleep(1); + + /* + * Release the semaphore and exit. + */ + s.sem_num = 0; + s.sem_op = 1; + s.sem_flg = SEM_UNDO; + + if (semop(semid, &s, 1) == -1) + err(1, "waiter: semop +1"); + + exit(0); +}