170010018
/
minix3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
minix3/tests/ipc/semctl/semctl01.c

689 lines
15 KiB
C
Raw Permalink Blame History

/*
*
* Copyright (c) International Business Machines Corp., 2001
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* NAME
* semctl01.c
*
* DESCRIPTION
* semctl01 - test the 10 possible semctl() commands
*
* ALGORITHM
* create a semaphore set with read and alter permissions
* loop if that option was specified
* loop through the test cases
* do any setup required for the test case
* make the semctl() call using the TEST() macro
* check the return code
* if failure, issue a FAIL message.
* otherwise,
* if doing functionality testing
* call the appropriate test function
* if correct,
* issue a PASS message
* otherwise
* issue a FAIL message
* call cleanup
*
* USAGE: <for command-line>
* semctl01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
* where, -c n : Run n copies concurrently.
* -f : Turn off functionality Testing.
* -i n : Execute test n times.
* -I x : Execute test for x seconds.
* -P x : Pause for x seconds between iterations.
* -t : Turn on syscall timing.
*
* HISTORY
* 03/2001 - Written by Wayne Boyer
*
* RESTRICTIONS
* none
*/
#include "ipcsem.h"
char *TCID = "semctl01";
int TST_TOTAL = 10;
extern int Tst_count;
int sem_id_1 = -1; /* a semaphore set with read and alter permissions */
/*
* These are the various setup and check functions for the 10 different
* commands that are available for the semctl() call.
*/
void func_stat(int);
void set_setup(int), func_set(int);
void func_gall(int);
void cnt_setup(int), func_cnt(int);
void pid_setup(int), func_pid(int);
void gval_setup(int), func_gval(int);
void sall_setup(int), func_sall(int);
void func_sval(int);
void func_rmid(int);
void child_cnt(void);
void child_pid(void);
struct semid_ds buf;
unsigned short array[PSEMS];
struct sembuf sops;
#define INCVAL 2 /* a semaphore increment value */
#define NEWMODE 066
#define NCHILD 5
#define SEM2 2 /* semaphore to use for GETPID and GETVAL */
#define SEM4 4 /* semaphore to use for GETNCNT and GETZCNT */
#define ONE 1
#define SEMUN_CAST (union semun)
int pid_arr[NCHILD];
#ifdef UCLINUX
static char *argv0;
#endif
struct test_case_t {
int semnum; /* the primitive semaphore to use */
int cmd; /* the command to test */
void (*func_test)(int); /* the test function */
union semun arg;
void (*func_setup)(int); /* the setup function if necessary */
} TC[10];
void setup_test_cases(void)
{
int i;
i = -1;
/* {0, IPC_STAT, func_stat, &buf, NULL}, */
i++;
TC[i].semnum = 0;
TC[i].cmd = IPC_STAT;
TC[i].func_test = func_stat;
TC[i].arg.buf = &buf;
TC[i].func_setup = NULL;
/* {0, IPC_SET, func_set, &buf, set_setup}, */
i++;
TC[i].semnum = 0;
TC[i].cmd = IPC_SET;
TC[i].func_test = func_set;
TC[i].arg.buf = &buf;
TC[i].func_setup = set_setup;
/* {0, GETALL, func_gall, array, NULL}, */
i++;
TC[i].semnum = 0;
TC[i].cmd = GETALL;
TC[i].func_test = func_gall;
TC[i].arg.array = array;
TC[i].func_setup = NULL;
/* {SEM4, GETNCNT, func_cnt, SEMUN_CAST &buf, cnt_setup}, */
i++;
TC[i].semnum = SEM4;
TC[i].cmd = GETNCNT;
TC[i].func_test = func_cnt;
TC[i].arg.buf = &buf;
TC[i].func_setup = cnt_setup;
/* {SEM2, GETPID, func_pid, SEMUN_CAST &buf, pid_setup}, */
i++;
TC[i].semnum = SEM2;
TC[i].cmd = GETPID;
TC[i].func_test = func_pid;
TC[i].arg.buf = &buf;
TC[i].func_setup = pid_setup;
/* {SEM2, GETVAL, func_gval, SEMUN_CAST &buf, NULL}, */
i++;
TC[i].semnum = SEM2;
TC[i].cmd = GETVAL;
TC[i].func_test = func_gval;
TC[i].arg.buf = &buf;
TC[i].func_setup = NULL;
/* {SEM4, GETZCNT, func_cnt, SEMUN_CAST &buf, cnt_setup}, */
i++;
TC[i].semnum = SEM4;
TC[i].cmd = GETZCNT;
TC[i].func_test = func_cnt;
TC[i].arg.buf = &buf;
TC[i].func_setup = cnt_setup;
/* {0, SETALL, func_sall, SEMUN_CAST array, sall_setup}, */
i++;
TC[i].semnum = 0;
TC[i].cmd = SETALL;
TC[i].func_test = func_sall;
TC[i].arg.array = array;
TC[i].func_setup = sall_setup;
/* {SEM4, SETVAL, func_sval, SEMUN_CAST INCVAL, NULL}, */
i++;
TC[i].semnum = SEM4;
TC[i].cmd = SETVAL;
TC[i].func_test = func_sval;
TC[i].arg.val = INCVAL;
TC[i].func_setup = NULL;
/* {0, IPC_RMID, func_rmid, SEMUN_CAST &buf, NULL} */
i++;
TC[i].semnum = 0;
TC[i].cmd = IPC_RMID;
TC[i].func_test = func_rmid;
TC[i].arg.buf = &buf;
TC[i].func_setup = NULL;
}
int main(int ac, char **av)
{
int lc; /* loop counter */
char *msg; /* message returned from parse_opts */
int i, j;
/* parse standard options */
if ((msg = parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *)NULL){
tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
}
#ifdef UCLINUX
argv0 = av[0];
maybe_run_child(&child_pid, "nd", 1, &sem_id_1);
maybe_run_child(&child_cnt, "ndd", 2, &sem_id_1, &sops.sem_op);
#endif
setup(); /* global setup */
/* The following loop checks looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset Tst_count in case we are looping */
Tst_count = 0;
/* loop through the test cases */
for (i=0; i<TST_TOTAL; i++) {
/*
* Set up any conditions if needed
*/
if (TC[i].func_setup != NULL) {
/* call the setup function */
switch (TC[i].cmd) {
case GETNCNT:
(*TC[i].func_setup)(-ONE);
break;
case GETZCNT:
(*TC[i].func_setup)(0);
break;
default:
(*TC[i].func_setup)(ONE);
break;
}
}
/*
* Use TEST macro to make the call
*/
TEST(semctl(sem_id_1, TC[i].semnum, TC[i].cmd,
TC[i].arg));
if (TEST_RETURN == -1) {
tst_resm(TFAIL, "%s call failed - errno = %d "
": %s", TCID, TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
if (STD_FUNCTIONAL_TEST) {
/*
* call the appropriate test function
* and pass the return value where it
* is needed to perform certain tests.
*/
switch (TC[i].cmd) {
case GETNCNT:
/*FALLTHROUGH*/
case GETZCNT:
/*FALLTHROUGH*/
case GETPID:
/*FALLTHROUGH*/
case GETVAL:
(*TC[i].func_test)(TEST_RETURN);
break;
default:
(*TC[i].func_test)(0);
break;
}
} else {
tst_resm(TPASS, "call succeeded");
}
}
/*
* If testing GETNCNT or GETZCNT, clean up the children.
*/
switch (TC[i].cmd) {
case GETNCNT:
/*FALLTHROUGH*/
case GETZCNT:
for (j=0; j<NCHILD; j++) {
if (kill(pid_arr[j], SIGKILL) == -1) {
tst_brkm(TBROK, cleanup,
"child kill failed");
}
}
break;
}
}
/*
* recreate the semaphore resource if looping
*/
if (TEST_LOOPING(lc)) {
if ((sem_id_1 = semget(semkey, PSEMS,
IPC_CREAT | IPC_EXCL | SEM_RA)) == -1 ) {
tst_brkm(TBROK, cleanup, "couldn't recreate "
"semaphore");
}
}
}
cleanup();
/*NOTREACHED*/
return(0);
}
/*
* func_stat() - check the functionality of the IPC_STAT command with semctl()
*/
void
func_stat(int n)
{
/* check the number of semaphores and the ipc_perm.mode value */
if (buf.sem_nsems == PSEMS && buf.sem_perm.mode == (SEM_RA)) {
tst_resm(TPASS, "buf.sem_nsems and buf.sem_perm.mode"
" are correct");
} else {
tst_resm(TFAIL, "semaphore STAT info is incorrect");
}
}
/*
* set_setup() - set up for the IPC_SET command with semctl()
*/
void
set_setup(int n)
{
/* set up a new mode for the semaphore set */
buf.sem_perm.mode = SEM_RA | NEWMODE;
}
/*
* func_set() - check the functionality of the IPC_SET command with semctl()
*/
void
func_set(int n)
{
/* first stat the semaphore to get the new data */
union semun arg;
arg.buf = &buf;
if (semctl(sem_id_1, 0, IPC_STAT, arg) == -1) {
tst_resm(TBROK, "stat failed in func_set()");
return;
}
/* check that the new mode is what we set */
if (buf.sem_perm.mode == (SEM_RA | NEWMODE)) {
tst_resm(TPASS, "buf.sem_perm.mode is correct");
} else {
tst_resm(TFAIL, "semaphore mode info is incorrect");
}
}
/*
* func_gall() - check the functionality of the GETALL command with semctl()
*/
void
func_gall(int n)
{
int i;
/* the initial value of the primitive semaphores should be zero */
for (i=0 ; i<PSEMS; i++) {
if (array[i] != 0) {
tst_resm(TFAIL, "semaphore %d has unexpected value", i);
return;
}
}
tst_resm(TPASS, "semaphores have expected values");
}
/*
* cnt_setup() - set up for the GETNCNT and GETZCNT commands with semctl()
*/
void
cnt_setup(int opval)
{
int pid, i;
sops.sem_num = SEM4;
sops.sem_flg = 0;
/*
* if seting up for GETZCNT, the semaphore value needs to be positive
*/
if (opval == 0) {
/* initialize the semaphore value to ONE */
sops.sem_op = ONE;
if (semop(sem_id_1, &sops, 1) == -1) {
tst_brkm(TBROK, cleanup, "semop #1 failed - cnt_setup");
}
}
sops.sem_op = opval; /* set the correct operation */
for (i=0; i<NCHILD; i++) {
/* fork five children to wait */
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork failed in cnt_setup");
}
if (pid == 0) { /* child */
#ifdef UCLINUX
if (self_exec(argv0, "ndd", 2, sem_id_1,
sops.sem_op) < 0) {
tst_brkm(TBROK, cleanup, "self_exec failed "
"in cnt_setup");
}
#else
child_cnt();
#endif
} else { /* parent */
/* take a quick nap so that commands execute orderly */
usleep(50000);
/* save the pid so we can kill it later */
pid_arr[i] = pid;
}
}
}
void
child_cnt(void)
{
sops.sem_num = SEM4;
sops.sem_flg = 0;
/*
* Do a semop that will cause the child to sleep.
* The child process will be killed in the func_ncnt
* routine which should cause an error to be return
* by the semop() call.
*/
if (semop(sem_id_1, &sops, 1) != -1) {
tst_resm(TBROK, "semop succeeded - cnt_setup");
}
exit(0);
}
/*
* func_cnt() - check the functionality of the GETNCNT and GETZCNT commands
* with semctl()
*/
void
func_cnt(int rval)
{
if (rval == NCHILD) {
tst_resm(TPASS, "number of sleeping processes is correct");
} else {
tst_resm(TFAIL, "number of sleeping processes is not correct");
}
}
/*
* pid_setup() - set up for the GETPID command with semctl()
*/
void
pid_setup(int n)
{
int pid;
/*
* Fork a child to do a semop that will pass.
*/
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork failed in pid_setup()");
}
if (pid == 0) { /* child */
#ifdef UCLINUX
if (self_exec(argv0, "nd", 1, sem_id_1) < 0) {
tst_brkm(TBROK, cleanup, "self_exec failed "
"in pid_setup()");
}
#else
child_pid();
#endif
} else { /* parent */
/* take a quick nap so that commands execute orderly */
usleep(50000);
pid_arr[SEM2] = pid;
}
}
void
child_pid(void)
{
sops.sem_num = SEM2; /* semaphore to change */
sops.sem_op = ONE; /* operation is to increment semaphore */
sops.sem_flg = 0;
/*
* Do a semop that will increment the semaphore.
*/
if (semop(sem_id_1, &sops, 1) == -1) {
tst_resm(TBROK, "semop failed - pid_setup");
}
exit(0);
}
/*
* func_pid() - check the functionality of the GETPID command with semctl()
*/
void
func_pid(int rval)
{
/* compare the rval (pid) to the saved pid from the setup */
if (rval == pid_arr[SEM2]) {
tst_resm(TPASS, "last pid value is correct");
} else {
tst_resm(TFAIL, "last pid value is not correct");
}
}
/*
* func_gval() - check the functionality of the GETVAL command with semctl()
*/
void
func_gval(int rval)
{
/*
* This is a simple test. The semaphore value should be equal
* to ONE as it was set in the last test (GETPID).
*/
if (rval == 1) {
tst_resm(TPASS, "semaphore value is correct");
} else {
tst_resm(TFAIL, "semaphore value is not correct");
}
}
/*
* all_setup() - set up for the SETALL command with semctl()
*/
void
sall_setup(int n)
{
int i;
for (i=0; i<PSEMS; i++) {
/* initialize the array values to 3 */
array[i] = 3;
}
}
/*
* func_sall() - check the functionality of the SETALL command with semctl()
*/
void
func_sall(int n)
{
int i;
unsigned short rarray[PSEMS];
union semun arg;
/*
* do a GETALL and compare the values to those set above
*/
arg.array = rarray;
if (semctl(sem_id_1, 0, GETALL, arg) == -1) {
tst_brkm(TBROK, cleanup, "semctl failed in func_sall");
}
for (i=0; i<PSEMS; i++) {
if (array[i] != rarray[i]) {
tst_resm(TFAIL, "semaphore values are not correct");
return;
}
}
tst_resm(TPASS, "semaphore values are correct");
}
/*
* func_sval() - check the functionality of the SETVAL command with semctl()
*/
void
func_sval(int n)
{
int semv;
union semun arr;
/*
* do a GETVAL and compare it to the value set above
*/
if ((semv = semctl(sem_id_1, SEM4, GETVAL, arr)) == -1) {
tst_brkm(TBROK, cleanup, "semctl failed in func_sval");
}
if (semv != INCVAL) {
tst_resm(TFAIL, "semaphore value is not what was set");
} else {
tst_resm(TPASS, "semaphore value is correct");
}
}
/*
* func_rmid() - check the functionality of the IPC_RMID command with semctl()
*/
void
func_rmid(int n)
{
/*
* do a semop() - we should get EINVAL
*/
if (semop(sem_id_1, &sops, 1) != -1) {
tst_resm(TFAIL, "semop succeeded on expected fail");
}
if (errno != EINVAL) {
tst_resm(TFAIL, "returned errno - %d - is not expected", errno);
} else {
tst_resm(TPASS, "semaphore appears to be removed");
}
sem_id_1 = -1;
}
/*
* setup() - performs all the ONE TIME setup for this test.
*/
void
setup(void)
{
setup_test_cases();
/* capture signals */
tst_sig(FORK, DEF_HANDLER, cleanup);
/* Pause if that option was specified */
TEST_PAUSE;
/*
* Create a temporary directory and cd into it.
* This helps to ensure that a unique msgkey is created.
* See ../lib/libipc.c for more information.
*/
tst_tmpdir();
/* get an IPC resource key */
semkey = getipckey();
/* create a semaphore set with read and alter permissions */
if ((sem_id_1 =
semget(semkey, PSEMS, IPC_CREAT | IPC_EXCL | SEM_RA)) == -1 ) {
tst_brkm(TBROK, cleanup, "couldn't create semaphore in setup");
}
}
/*
* cleanup() - performs all the ONE TIME cleanup for this test at completion
* or premature exit.
*/
void
cleanup(void)
{
/* if it exists, remove the semaphore resource */
rm_sema(sem_id_1);
/* Remove the temporary directory */
tst_rmdir();
/*
* print timing stats if that option was specified.
* print errno log if that option was specified.
*/
TEST_CLEANUP;
/* exit with return code appropriate for results */
tst_exit();
}
Reference in New Issue View Git Blame Copy Permalink