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