1 /*
2 * Copyright (c) International Business Machines Corp., 2001
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12 * the GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 /*
20 * NAME
21 * semctl01.c
22 *
23 * DESCRIPTION
24 * semctl01 - test the 13 possible semctl() commands
25 *
26 * ALGORITHM
27 * create a semaphore set with read and alter permissions
28 * loop if that option was specified
29 * loop through the test cases
30 * do any setup required for the test case
31 * make the semctl() call using the TEST() macro
32 * check the return code
33 * if failure, issue a FAIL message.
34 * otherwise,
35 * if doing functionality testing
36 * call the appropriate test function
37 * if correct,
38 * issue a PASS message
39 * otherwise
40 * issue a FAIL message
41 * call cleanup
42 */
43
44
45 #ifndef _GNU_SOURCE
46 #define _GNU_SOURCE
47 #endif
48 #include <sys/wait.h>
49 #include "ipcsem.h"
50
51 char *TCID = "semctl01";
52
53 static int sem_id_1 = -1;
54 static int sem_index;
55
56 /*
57 * These are the various setup and check functions for the 10 different
58 * commands that are available for the semctl() call.
59 */
60 static void func_stat(void);
61 static void set_setup(void), func_set(void);
62 static void func_gall(void);
63 static void cnt_setup(int), func_cnt(int);
64 static void pid_setup(void), func_pid(int);
65 static void func_gval(int);
66 static void sall_setup(void), func_sall(void);
67 static void func_sval(void);
68 static void func_rmid(void);
69 static void child_cnt(void);
70 static void child_pid(void);
71 static void func_iinfo(int);
72 static void func_sinfo(void);
73 static void func_sstat(int);
74
75 static struct semid_ds buf;
76 static struct seminfo ipc_buf;
77 static unsigned short array[PSEMS];
78 static struct sembuf sops;
79
80 #define INCVAL 2
81 #define NEWMODE 066
82 #define NCHILD 5
83 #define SEM2 2
84 #define SEM4 4
85 #define ONE 1
86 #ifdef _XLC_COMPILER
87 #define SEMUN_CAST
88 #else
89 #define SEMUN_CAST (union semun)
90 #endif
91
92 static int pid_arr[NCHILD];
93
94 #ifdef UCLINUX
95 #define PIPE_NAME "semctl01"
96 static char *argv0;
97 static int sem_op;
98 #endif
99
100 static struct test_case_t {
101 int *semid;
102 int semnum;
103 int cmd;
104 void (*func_test) ();
105 union semun arg;
106 void (*func_setup) ();
107 } TC[] = {
108 {&sem_id_1, 0, IPC_STAT, func_stat, SEMUN_CAST & buf, NULL},
109 {&sem_id_1, 0, IPC_SET, func_set, SEMUN_CAST & buf, set_setup},
110 {&sem_id_1, 0, GETALL, func_gall, SEMUN_CAST array, NULL},
111 {&sem_id_1, SEM4, GETNCNT, func_cnt, SEMUN_CAST & buf, cnt_setup},
112 {&sem_id_1, SEM2, GETPID, func_pid, SEMUN_CAST & buf, pid_setup},
113 {&sem_id_1, SEM2, GETVAL, func_gval, SEMUN_CAST & buf, NULL},
114 {&sem_id_1, SEM4, GETZCNT, func_cnt, SEMUN_CAST & buf, cnt_setup},
115 {&sem_id_1, 0, SETALL, func_sall, SEMUN_CAST array, sall_setup},
116 {&sem_id_1, SEM4, SETVAL, func_sval, SEMUN_CAST INCVAL, NULL},
117 {&sem_id_1, 0, IPC_INFO, func_iinfo, SEMUN_CAST & ipc_buf, NULL},
118 {&sem_id_1, 0, SEM_INFO, func_sinfo, SEMUN_CAST & ipc_buf, NULL},
119 {&sem_index, 0, SEM_STAT, func_sstat, SEMUN_CAST & buf, NULL},
120 {&sem_id_1, 0, IPC_RMID, func_rmid, SEMUN_CAST & buf, NULL},
121 };
122
123 int TST_TOTAL = ARRAY_SIZE(TC);
124
kill_all_children(void)125 static void kill_all_children(void)
126 {
127 int j, status;
128
129 for (j = 0; j < NCHILD; j++) {
130 if (kill(pid_arr[j], SIGKILL) == -1)
131 tst_brkm(TBROK | TERRNO, cleanup, "child kill failed");
132 }
133
134 /*
135 * make sure children finished before we proceed with next testcase
136 */
137 for (j = 0; j < NCHILD; j++) {
138 if (wait(&status) == -1)
139 tst_brkm(TBROK | TERRNO, cleanup, "wait() failed");
140 }
141 }
142
main(int argc,char * argv[])143 int main(int argc, char *argv[])
144 {
145 int lc;
146 int i;
147
148 tst_parse_opts(argc, argv, NULL, NULL);
149
150 #ifdef UCLINUX
151 argv0 = argv[0];
152 maybe_run_child(&child_pid, "nd", 1, &sem_id_1);
153 maybe_run_child(&child_cnt, "ndd", 2, &sem_id_1, &sem_op);
154 #endif
155
156 setup();
157
158 for (lc = 0; TEST_LOOPING(lc); lc++) {
159 tst_count = 0;
160
161 for (i = 0; i < TST_TOTAL; i++) {
162
163 /*
164 * Set up any conditions if needed
165 */
166 if (TC[i].func_setup != NULL) {
167 /* call the setup function */
168 switch (TC[i].cmd) {
169 case GETNCNT:
170 (*TC[i].func_setup) (-ONE);
171 break;
172 case GETZCNT:
173 (*TC[i].func_setup) (0);
174 break;
175 default:
176 (*TC[i].func_setup) ();
177 break;
178 }
179 }
180
181 TEST(semctl(*(TC[i].semid), TC[i].semnum, TC[i].cmd,
182 TC[i].arg));
183
184 if (TEST_RETURN == -1) {
185 tst_resm(TFAIL, "%s call failed - errno = %d "
186 ": %s", TCID, TEST_ERRNO,
187 strerror(TEST_ERRNO));
188 } else {
189 /*
190 * call the appropriate test function
191 * and pass the return value where it
192 * is needed to perform certain tests.
193 */
194 switch (TC[i].cmd) {
195 case GETNCNT:
196 case GETZCNT:
197 case GETPID:
198 case GETVAL:
199 case IPC_INFO:
200 case SEM_STAT:
201 (*TC[i].func_test) (TEST_RETURN);
202 break;
203 default:
204 (*TC[i].func_test) ();
205 break;
206 }
207 }
208
209 /*
210 * If testing GETNCNT or GETZCNT, clean up the children.
211 */
212 switch (TC[i].cmd) {
213 case GETNCNT:
214 case GETZCNT:
215 kill_all_children();
216 break;
217 }
218 }
219 /*
220 * recreate the semaphore resource if looping
221 */
222 if (TEST_LOOPING(lc)) {
223 sem_id_1 = semget(semkey, PSEMS,
224 IPC_CREAT | IPC_EXCL | SEM_RA);
225 if (sem_id_1 == -1)
226 tst_brkm(TBROK, cleanup,
227 "couldn't recreate " "semaphore");
228 }
229 }
230
231 cleanup();
232
233 tst_exit();
234 }
235
236 /*
237 * func_stat() - check the functionality of the IPC_STAT command with semctl()
238 */
func_stat(void)239 static void func_stat(void)
240 {
241 /* check the number of semaphores and the ipc_perm.mode value */
242 if (buf.sem_nsems == PSEMS && buf.sem_perm.mode == (SEM_RA))
243 tst_resm(TPASS, "buf.sem_nsems and buf.sem_perm.mode"
244 " are correct");
245 else
246 tst_resm(TFAIL, "semaphore STAT info is incorrect");
247 }
248
249 /*
250 * set_setup() - set up for the IPC_SET command with semctl()
251 */
set_setup(void)252 static void set_setup(void)
253 {
254 /* set up a new mode for the semaphore set */
255 buf.sem_perm.mode = SEM_RA | NEWMODE;
256 }
257
258 /*
259 * func_set() - check the functionality of the IPC_SET command with semctl()
260 */
func_set(void)261 static void func_set(void)
262 {
263 /* first stat the semaphore to get the new data */
264 if (semctl(sem_id_1, 0, IPC_STAT, (union semun)&buf) == -1) {
265 tst_resm(TBROK, "stat failed in func_set()");
266 return;
267 }
268
269 /* check that the new mode is what we set */
270 if (buf.sem_perm.mode == (SEM_RA | NEWMODE))
271 tst_resm(TPASS, "buf.sem_perm.mode is correct");
272 else
273 tst_resm(TFAIL, "semaphore mode info is incorrect");
274 }
275
276 /*
277 * func_gall() - check the functionality of the GETALL command with semctl()
278 */
func_gall(void)279 static void func_gall(void)
280 {
281 int i;
282
283 /* the initial value of the primitive semaphores should be zero */
284 for (i = 0; i < PSEMS; i++) {
285 if (array[i] != 0) {
286 tst_resm(TFAIL, "semaphore %d has unexpected value", i);
287 return;
288 }
289 }
290 tst_resm(TPASS, "semaphores have expected values");
291 }
292
293 /*
294 * cnt_setup() - set up for the GETNCNT and GETZCNT commands with semctl()
295 */
cnt_setup(int opval)296 static void cnt_setup(int opval)
297 {
298 int pid, i;
299
300 sops.sem_num = SEM4;
301 sops.sem_flg = 0;
302
303 /*
304 * if seting up for GETZCNT, the semaphore value needs to be positive
305 */
306 if (opval == 0) {
307 /* initialize the semaphore value to ONE */
308 sops.sem_op = ONE;
309 if (semop(sem_id_1, &sops, 1) == -1)
310 tst_brkm(TBROK, cleanup, "semop #1 failed - cnt_setup");
311 }
312
313 /* set the correct operation */
314 sops.sem_op = opval;
315 for (i = 0; i < NCHILD; i++) {
316 /* fork five children to wait */
317 pid = FORK_OR_VFORK();
318 if (pid == -1)
319 tst_brkm(TBROK, cleanup, "fork failed in cnt_setup");
320
321 if (pid == 0) {
322 #ifdef UCLINUX
323 sem_op = sops.sem_op;
324 if (self_exec(argv0, "ndd", 2, sem_id_1, sem_op) < 0)
325 tst_brkm(TBROK, cleanup, "self_exec failed "
326 "in cnt_setup");
327 #else
328 child_cnt();
329 #endif
330 } else {
331 TST_PROCESS_STATE_WAIT(cleanup, pid, 'S');
332 /* save the pid so we can kill it later */
333 pid_arr[i] = pid;
334 }
335 }
336 }
337
child_cnt(void)338 static void child_cnt(void)
339 {
340 #ifdef UCLINUX
341 sops.sem_op = (short int)sem_op;
342 #endif
343
344 sops.sem_num = SEM4;
345 sops.sem_flg = 0;
346
347 /*
348 * Do a semop that will cause the child to sleep.
349 * The child process will be killed in the func_ncnt
350 * routine which should cause an error to be return
351 * by the semop() call.
352 */
353 if (semop(sem_id_1, &sops, 1) != -1)
354 tst_resm(TBROK, "semop succeeded - cnt_setup");
355
356 exit(0);
357 }
358
359 /*
360 * func_cnt() - check the functionality of the GETNCNT and GETZCNT commands
361 * with semctl()
362 */
func_cnt(int rval)363 static void func_cnt(int rval)
364 {
365
366 if (rval == NCHILD)
367 tst_resm(TPASS, "number of sleeping processes is correct");
368 else
369 tst_resm(TFAIL, "number of sleeping processes is not correct");
370 }
371
372 /*
373 * pid_setup() - set up for the GETPID command with semctl()
374 */
pid_setup(void)375 static void pid_setup(void)
376 {
377 int pid;
378
379 /*
380 * Fork a child to do a semop that will pass.
381 */
382 pid = FORK_OR_VFORK();
383 if (pid == -1)
384 tst_brkm(TBROK, cleanup, "fork failed in pid_setup()");
385
386 if (pid == 0) { /* child */
387 #ifdef UCLINUX
388 if (self_exec(argv0, "nd", 1, sem_id_1) < 0)
389 tst_brkm(TBROK, cleanup, "self_exec failed "
390 "in pid_setup()");
391 #else
392 child_pid();
393 #endif
394 } else {
395 pid_arr[SEM2] = pid;
396 TST_PROCESS_STATE_WAIT(cleanup, pid, 'Z');
397 }
398 }
399
child_pid(void)400 static void child_pid(void)
401 {
402 sops.sem_num = SEM2;
403 sops.sem_op = ONE;
404 sops.sem_flg = 0;
405 /*
406 * Do a semop that will increment the semaphore.
407 */
408 if (semop(sem_id_1, &sops, 1) == -1)
409 tst_resm(TBROK, "semop failed - pid_setup");
410 exit(0);
411 }
412
413 /*
414 * func_pid() - check the functionality of the GETPID command with semctl()
415 */
func_pid(int rval)416 static void func_pid(int rval)
417 {
418 /* compare the rval (pid) to the saved pid from the setup */
419 if (rval == pid_arr[SEM2])
420 tst_resm(TPASS, "last pid value is correct");
421 else
422 tst_resm(TFAIL, "last pid value is not correct");
423 }
424
425 /*
426 * func_gval() - check the functionality of the GETVAL command with semctl()
427 */
func_gval(int rval)428 static void func_gval(int rval)
429 {
430 /*
431 * This is a simple test. The semaphore value should be equal
432 * to ONE as it was set in the last test (GETPID).
433 */
434 if (rval == 1)
435 tst_resm(TPASS, "semaphore value is correct");
436 else
437 tst_resm(TFAIL, "semaphore value is not correct");
438 }
439
440 /*
441 * all_setup() - set up for the SETALL command with semctl()
442 */
sall_setup(void)443 static void sall_setup(void)
444 {
445 int i;
446
447 for (i = 0; i < PSEMS; i++) {
448 /* initialize the array values to 3 */
449 array[i] = 3;
450 }
451 }
452
453 /*
454 * func_sall() - check the functionality of the SETALL command with semctl()
455 */
func_sall(void)456 static void func_sall(void)
457 {
458 int i;
459 unsigned short rarray[PSEMS];
460
461 /*
462 * do a GETALL and compare the values to those set above
463 */
464
465 if (semctl(sem_id_1, 0, GETALL, (union semun)rarray) == -1)
466 tst_brkm(TBROK, cleanup, "semctl failed in func_sall");
467
468 for (i = 0; i < PSEMS; i++) {
469 if (array[i] != rarray[i]) {
470 tst_resm(TFAIL, "semaphore values are not correct");
471 return;
472 }
473 }
474
475 tst_resm(TPASS, "semaphore values are correct");
476 }
477
478 /*
479 * func_sval() - check the functionality of the SETVAL command with semctl()
480 */
func_sval(void)481 static void func_sval(void)
482 {
483 int semv;
484 union semun arr;
485
486 /*
487 * do a GETVAL and compare it to the value set above
488 */
489
490 semv = semctl(sem_id_1, SEM4, GETVAL, arr);
491 if (semv == -1)
492 tst_brkm(TBROK, cleanup, "semctl failed in func_sval");
493
494 if (semv != INCVAL)
495 tst_resm(TFAIL, "semaphore value is not what was set");
496 else
497 tst_resm(TPASS, "semaphore value is correct");
498 }
499
500 /*
501 * func_rmid() - check the functionality of the IPC_RMID command with semctl()
502 */
func_rmid(void)503 static void func_rmid(void)
504 {
505
506 /*
507 * do a semop() - we should get EINVAL
508 */
509 if (semop(sem_id_1, &sops, 1) != -1)
510 tst_resm(TFAIL, "semop succeeded on expected fail");
511
512 if (errno != EINVAL)
513 tst_resm(TFAIL, "returned errno - %d - is not expected", errno);
514 else
515 tst_resm(TPASS, "semaphore appears to be removed");
516
517 sem_id_1 = -1;
518 }
519
func_iinfo(int hidx)520 static void func_iinfo(int hidx)
521 {
522 if (hidx >= 0) {
523 sem_index = hidx;
524 tst_resm(TPASS, "the highest index is correct");
525 } else {
526 sem_index = 0;
527 tst_resm(TFAIL, "the highest index is incorrect");
528 }
529 }
530
func_sinfo(void)531 static void func_sinfo(void)
532 {
533 if (ipc_buf.semusz < 1)
534 tst_resm(TFAIL, "number of semaphore sets is incorrect");
535 else
536 tst_resm(TPASS, "number of semaphore sets is correct");
537 }
538
func_sstat(int semidx)539 static void func_sstat(int semidx)
540 {
541 if (semidx >= 0)
542 tst_resm(TPASS, "id of the semaphore set is correct");
543 else
544 tst_resm(TFAIL, "id of the semaphore set is incorrect");
545 }
546
setup(void)547 void setup(void)
548 {
549
550 tst_sig(FORK, DEF_HANDLER, cleanup);
551
552 TEST_PAUSE;
553
554 tst_tmpdir();
555
556 TST_CHECKPOINT_INIT(tst_rmdir);
557
558 /* get an IPC resource key */
559 semkey = getipckey();
560
561 /* create a semaphore set with read and alter permissions */
562 sem_id_1 = semget(semkey, PSEMS, IPC_CREAT | IPC_EXCL | SEM_RA);
563 if (sem_id_1 == -1)
564 tst_brkm(TBROK, cleanup, "couldn't create semaphore in setup");
565 }
566
cleanup(void)567 void cleanup(void)
568 {
569 /* if it exists, remove the semaphore resource */
570 rm_sema(sem_id_1);
571
572 tst_rmdir();
573 }
574