/* * * Copyright (c) International Business Machines Corp., 2002 * * 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 */ /* 06/30/2001 Port to Linux nsharoff@us.ibm.com */ /* 11/11/2002 Port to LTP dbarrera@us.ibm.com */ /* * NAME * msgctl09 * * CALLS * msgget(2) msgctl(2) msgop(2) * * ALGORITHM * Get and manipulate a message queue. * * RESTRICTIONS * */ #define _XOPEN_SOURCE 500 #include #include #include #include #include #include #include #include #include #include #include #include "test.h" #include "usctest.h" #define MAXNREPS 1000 #ifndef CONFIG_COLDFIRE #define MAXNPROCS 1000000 /* This value is set to an arbitrary high limit. */ #else #define MAXNPROCS 100000 /* Coldfire can't deal with 1000000 */ #endif #define MAXNKIDS 10 #define FAIL 1 #define PASS 0 int dotest(key_t,int); int doreader(long,int,int); int dowriter(long,int,int); int fill_buffer(char*,char,int); int verify(char*,char,int,int); void setup(); void cleanup(); /* * These globals must be defined in the test. * */ char *TCID="msgctl09"; /* Test program identifier. */ int TST_TOTAL=1; /* Total number of test cases. */ extern int Tst_count; /* Test Case counter for tst_* routines */ int exp_enos[]={0}; /* List must end with 0 */ key_t keyarray[MAXNPROCS]; struct { long type; struct { char len; char pbytes[99]; } data; } buffer; int pidarray[MAXNPROCS]; int rkidarray[MAXNKIDS]; int wkidarray[MAXNKIDS]; int tid; int nprocs, nreps, nkids, MSGMNI; int procstat; void term(int); #ifdef UCLINUX static char *argv0; void do_child_1_uclinux(); static key_t key_uclinux; static int i_uclinux; void do_child_2_uclinux(); static int pid_uclinux; static int child_process_uclinux; void do_child_3_uclinux(); static int rkid_uclinux; #endif void cleanup_msgqueue(int i, int tid); /*-----------------------------------------------------------------*/ int main(argc, argv) int argc; char *argv[]; { register int i, j, ok, pid; int count, status; #ifdef UCLINUX char *msg; /* message returned from parse_opts */ argv0 = argv[0]; /* parse standard options */ if ((msg = parse_opts(argc, argv, (option_t *)NULL, NULL)) != (char *)NULL) { tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg); } maybe_run_child(&do_child_1_uclinux, "ndd", 1, &key_uclinux, &i_uclinux); maybe_run_child(&do_child_2_uclinux, "nddd", 2, &key_uclinux, &pid_uclinux, &child_process_uclinux); maybe_run_child(&do_child_3_uclinux, "nddd", 3, &key_uclinux, &rkid_uclinux, &child_process_uclinux); #endif setup(); if (argc == 1 ) { /* Set default parameters */ nreps = MAXNREPS; nprocs = MSGMNI; nkids = MAXNKIDS; } else if (argc == 4 ) { if ( atoi(argv[1]) > MAXNREPS ) { tst_resm(TCONF,"Requested number of iterations too large, setting to Max. of %d", MAXNREPS); nreps = MAXNREPS; } else { nreps = atoi(argv[1]); } if (atoi(argv[2]) > MSGMNI ) { tst_resm(TCONF,"Requested number of processes too large, setting to Max. of %d", MSGMNI); nprocs = MSGMNI; } else { nprocs = atoi(argv[2]); } if (atoi(argv[3]) > MAXNKIDS ) { tst_resm(TCONF,"Requested number of read/write pairs too large; setting to Max. of %d", MAXNKIDS); nkids = MAXNKIDS; } else { nkids = atoi(argv[3]); } } else { tst_resm(TCONF," Usage: %s [ number of iterations number of processes number of read/write pairs ]", argv[0]); tst_exit(); } procstat = 0; srand48((unsigned)getpid() + (unsigned)(getppid() << 16)); tid = -1; /* Setup signal handleing routine */ if (sigset(SIGTERM, term) == SIG_ERR) { tst_resm(TFAIL, "Sigset SIGTERM failed"); tst_exit(); } /* Set up array of unique keys for use in allocating message * queues */ for (i = 0; i < nprocs; i++) { ok = 1; do { /* Get random key */ keyarray[i] = (key_t)lrand48(); /* Make sure key is unique and not private */ if (keyarray[i] == IPC_PRIVATE) { ok = 0; continue; } for (j = 0; j < i; j++) { if (keyarray[j] == keyarray[i]) { ok = 0; break; } ok = 1; } } while (ok == 0); } /*-----------------------------------------------------------------*/ /* Fork a number of processes (nprocs), each of which will * create a message queue with several (nkids) reader/writer * pairs which will read and write a number (iterations) * of random length messages with specific values (keys). */ for (i = 0; i < nprocs; i++) { fflush(stdout); if ((pid = FORK_OR_VFORK()) < 0) { tst_resm(TFAIL, "\tFork failed (may be OK if under stress)"); tst_exit(); } /* Child does this */ if (pid == 0) { #ifdef UCLINUX if (self_exec(argv[0], "ndd", 1, keyarray[i], i) < 0) { tst_resm(TFAIL, "\tself_exec failed"); tst_exit(); } #else procstat = 1; exit( dotest(keyarray[i], i) ); #endif } pidarray[i] = pid; } count = 0; while(1) { if (( wait(&status)) > 0) { if (status>>8 != PASS ) { tst_resm(TFAIL, "Child exit status = %d", status>>8); tst_exit(); } count++; } else { if (errno != EINTR) { break; } #ifdef DEBUG tst_resm(TINFO,"Signal detected during wait"); #endif } } /* Make sure proper number of children exited */ if (count != nprocs) { tst_resm(TFAIL, "Wrong number of children exited, Saw %d, Expected %d", count, nprocs); tst_exit(); } tst_resm(TPASS,"msgctl09 ran successfully!"); cleanup(); return (0); } /*--------------------------------------------------------------------*/ #ifdef UCLINUX void do_child_1_uclinux() { procstat = 1; exit(dotest(key_uclinux, i_uclinux)); } void do_child_2_uclinux() { procstat = 2; exit(doreader(key_uclinux, pid_uclinux, child_process_uclinux)); } void do_child_3_uclinux() { procstat = 2; exit(dowriter(key_uclinux, rkid_uclinux, child_process_uclinux)); } #endif void cleanup_msgqueue(int i, int tid) { /* * Decrease the value of i by 1 because it * is getting incremented even if the fork * is failing. */ i--; /* * Kill all children & free message queue. */ for (; i >= 0; i--) { (void)kill(rkidarray[i], SIGKILL); (void)kill(wkidarray[i], SIGKILL); } if (msgctl(tid, IPC_RMID, 0) < 0) { tst_resm(TFAIL, "Msgctl error in cleanup, errno = %d", errno); tst_exit(); } } int dotest(key, child_process) key_t key; int child_process; { int id, pid; int i, count, status, exit_status; sighold(SIGTERM); if ((id = msgget(key, IPC_CREAT | S_IRUSR | S_IWUSR )) < 0) { tst_resm(TFAIL, "Msgget error in child %d, errno = %d", child_process, errno); tst_exit(); } tid = id; sigrelse(SIGTERM); exit_status = PASS; for (i=0; i < nkids; i++) { fflush(stdout); if ((pid = FORK_OR_VFORK()) < 0) { tst_resm(TWARN, "Fork failure in first child of child group %d", child_process); cleanup_msgqueue(i, tid); tst_exit(); } /* First child does this */ if (pid == 0) { #ifdef UCLINUX if (self_exec(argv0, "nddd", 2, key, getpid(), child_process) < 0) { tst_resm(TWARN, "self_exec failed"); cleanup_msgqueue(i, tid); tst_exit(); } #else procstat = 2; exit( doreader( key, getpid(), child_process) ); #endif } rkidarray[i] = pid; fflush(stdout); if ((pid = FORK_OR_VFORK()) < 0) { tst_resm(TWARN, "Fork failure in first child of child group %d", child_process); /* * Kill the reader child process */ (void)kill(rkidarray[i], SIGKILL); cleanup_msgqueue(i, tid); tst_exit(); } /* Second child does this */ if (pid == 0) { #ifdef UCLINUX if (self_exec(argv0, "nddd", 3, key, rkidarray[i], child_process) < 0) { tst_resm(TWARN, "\tFork failure in first child " "of child group %d \n", child_process); /* * Kill the reader child process */ (void)kill(rkidarray[i], SIGKILL); cleanup_msgqueue(i, tid); tst_exit(); } #else procstat = 2; exit( dowriter( key, rkidarray[i], child_process) ); #endif } wkidarray[i] = pid; } /* Parent does this */ count = 0; while(1) { if (( wait(&status)) > 0) { if (status>>8 != PASS ) { tst_resm(TFAIL, "Child exit status = %d from child group %d", status>>8, child_process); for (i = 0; i < nkids; i++) { kill(rkidarray[i], SIGTERM); kill(wkidarray[i], SIGTERM); } if (msgctl(tid, IPC_RMID, 0) < 0) { tst_resm(TFAIL, "Msgctl error, errno = %d", errno); } tst_exit(); } count++; } else { if (errno != EINTR) { break; } } } /* Make sure proper number of children exited */ if (count != (nkids * 2)) { tst_resm(TFAIL, "Wrong number of children exited in child group %d, Saw %d Expected %d", child_process, count, (nkids * 2)); if (msgctl(tid, IPC_RMID, 0) < 0) { tst_resm(TFAIL, "Msgctl error, errno = %d", errno); } tst_exit(); } if (msgctl(id, IPC_RMID, 0) < 0) { tst_resm(TFAIL, "Msgctl failure in child group %d, errno %d", child_process, errno); tst_exit(); } exit(exit_status); } int doreader( key, type, child) int type, child; long key; { int i, size; int id; if ((id = msgget(key, 0)) < 0) { tst_resm(TFAIL, "Msgget error in reader of child group %d, errno = %d", child, errno); tst_exit(); } if (id != tid) { tst_resm(TFAIL, "Message queue mismatch in reader of child group %d for message queue id %d", child, id); tst_exit(); } for (i = 0; i < nreps; i++) { if ((size = msgrcv(id, &buffer, 100, type, 0)) < 0) { tst_resm(TFAIL, "Msgrcv error in child %d, read # = %d, errno = %d", (i + 1), child, errno); tst_exit(); } if (buffer.type != type) { tst_resm(TFAIL, "Size mismatch in child %d, read # = %d", child, (i + 1)); tst_resm(TFAIL, "\tfor message size got %d expected %d %s",size ,buffer.data.len); tst_exit(); } if (buffer.data.len + 1 != size) { tst_resm(TFAIL, "Size mismatch in child %d, read # = %d, size = %d, expected = %d", child, (i + 1), buffer.data.len, size); tst_exit(); } if ( verify(buffer.data.pbytes, (key % 255), size - 1, child) ) { tst_resm(TFAIL, "in read # = %d,key = %x", (i + 1), child, key); tst_exit(); } key++; } exit(PASS); } int dowriter( key, type, child) int type,child; long key; { int i, size; int id; if ((id = msgget(key, 0)) < 0) { tst_resm(TFAIL, "Msgget error in writer of child group %d, errno = %d", child, errno); tst_exit(); } if (id != tid) { tst_resm(TFAIL, "Message queue mismatch in writer of child group %d", child); tst_resm(TFAIL, "\tfor message queue id %d expected %d",id, tid); tst_exit(); } for (i = 0; i < nreps; i++) { do { size = (lrand48() % 99); } while (size == 0); fill_buffer(buffer.data.pbytes, (key % 255), size); buffer.data.len = size; buffer.type = type; if (msgsnd(id, &buffer, size + 1, 0) < 0) { tst_resm(TFAIL, "Msgsnd error in child %d, key = %x errno = %d", child, key, errno); tst_exit(); } key++; } exit(PASS); } int fill_buffer(buf, val, size) register char *buf; char val; register int size; { register int i; for(i = 0; i < size; i++) buf[i] = val; return(0); } /* * verify() * Check a buffer for correct values. */ int verify(buf, val, size, child) register char *buf; char val; register int size; int child; { while(size-- > 0) if (*buf++ != val) { tst_resm(TWARN, "Verify error in child %d, *buf = %x, val = %x, size = %d", child, *buf, val, size); return(FAIL); } return(PASS); } /* ARGSUSED */ void term(int sig) { int i; if (procstat == 0) { #ifdef DEBUG tst_resm(TINFO,"SIGTERM signal received, test killing kids"); #endif for (i = 0; i < nprocs; i++) { if ( pidarray[i] > 0){ if ( kill(pidarray[i], SIGTERM) < 0) { tst_resm(TBROK,"Kill failed to kill child %d", i); exit(FAIL); } } } return; } if (procstat == 2) { fflush(stdout); exit(PASS); } if (tid == -1) { exit(FAIL); } for (i = 0; i < nkids; i++) { if (rkidarray[i] > 0) kill(rkidarray[i], SIGTERM); if (wkidarray[i] > 0) kill(wkidarray[i], SIGTERM); } } #define BUFSIZE 512 /** Get the number of message queues already in use */ static int get_used_msgqueues() { FILE *f; int used_queues; char buff[BUFSIZE]; f = popen("ipcs -q", "r"); if (!f) { tst_resm(TBROK,"Could not run 'ipcs' to calculate used message queues"); tst_exit(); } /* FIXME: Start at -4 because ipcs prints four lines of header */ for (used_queues = -4; fgets(buff, BUFSIZE, f); used_queues++) ; pclose(f); if (used_queues < 0) { tst_resm(TBROK,"Could not read output of 'ipcs' to calculate used message queues"); tst_exit(); } return used_queues; } /** Get the max number of message queues allowed on system */ static int get_max_msgqueues() { FILE *f; char buff[BUFSIZE]; /* Get the max number of message queues allowed on system */ f = fopen("/proc/sys/kernel/msgmni", "r"); if (!f){ tst_resm(TBROK,"Could not open /proc/sys/kernel/msgmni"); tst_exit(); } if (!fgets(buff, BUFSIZE, f)) { tst_resm(TBROK,"Could not read /proc/sys/kernel/msgmni"); tst_exit(); } fclose(f); return atoi(buff); } /*************************************************************** * setup() - performs all ONE TIME setup for this test. *****************************************************************/ void setup() { tst_tmpdir(); /* You will want to enable some signal handling so you can capture * unexpected signals like SIGSEGV. */ tst_sig(FORK, DEF_HANDLER, cleanup); /* Pause if that option was specified */ /* One cavet that hasn't been fixed yet. TEST_PAUSE contains the code to * fork the test with the -c option. You want to make sure you do this * before you create your temporary directory. */ TEST_PAUSE; MSGMNI = get_max_msgqueues() - get_used_msgqueues(); if (MSGMNI <= 0){ tst_resm(TBROK,"Max number of message queues already used, cannot create more."); cleanup(); } } /*************************************************************** * cleanup() - performs all ONE TIME cleanup for this test at * completion or premature exit. ****************************************************************/ void cleanup() { int status; /* * print timing stats if that option was specified. * print errno log if that option was specified. */ TEST_CLEANUP; /* * Remove the message queue from the system */ #ifdef DEBUG tst_resm(TINFO,"Removing the message queue"); #endif fflush (stdout); (void) msgctl(tid, IPC_RMID, (struct msqid_ds *)NULL); if ((status = msgctl(tid, IPC_STAT, (struct msqid_ds *)NULL)) != -1) { (void) msgctl(tid, IPC_RMID, (struct msqid_ds *)NULL); tst_resm(TFAIL, "msgctl(tid, IPC_RMID) failed"); tst_exit(); } fflush (stdout); tst_rmdir(); /* exit with return code appropriate for results */ tst_exit(); }