plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Copyright (c) International Business Machines Corp., 2001 |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation; either version 2 of the License, or |
| 8 | * (at your option) any later version. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| 13 | * the GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, write to the Free Software |
Wanlong Gao | 4548c6c | 2012-10-19 18:03:36 +0800 | [diff] [blame] | 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
| 20 | /* |
| 21 | * NAME |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 22 | * waitpid10.c |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 23 | * |
| 24 | * DESCRIPTION |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 25 | * Tests to see if pid's returned from fork and waitpid are same |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 26 | * |
| 27 | * ALGORITHM |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 28 | * Set up to catch SIGINTs, SIGALRMs, and the real time timer. |
| 29 | * Until the timer interrupts, do the following. Fork 8 kids. |
| 30 | * 2 will immediately exit, 2 will sleep, 2 will be compute bound, |
| 31 | * and 2 will fork another child, both which will do mkdirs on |
| 32 | * the same directory 50 times. When the timer expires, kill all |
| 33 | * kids and remove the directory. |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 34 | * |
| 35 | * USAGE: <for command-line> |
| 36 | * waitpid10 [-c n] [-i n] [-I x] [-P x] [-t] |
| 37 | * where, -c n : Run n copies concurrently. |
| 38 | * -i n : Execute test n times. |
| 39 | * -I x : Execute test for x seconds. |
| 40 | * -P x : Pause for x seconds between iterations. |
| 41 | * -t : Turn on syscall timing. |
| 42 | * |
| 43 | * NOTE |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 44 | * This test was designed to see if the intermittant occurrance |
| 45 | * of a waitpid returning a pid different from that returned by the |
| 46 | * fork can be reproduced. |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 47 | * |
| 48 | * History |
| 49 | * 07/2001 John George |
| 50 | * -Ported |
robbiew | 4644c7e | 2002-04-26 14:33:32 +0000 | [diff] [blame] | 51 | * 04/2002 wjhuie sigset cleanups |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 52 | * |
| 53 | * Restrictions |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 54 | * None |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 55 | */ |
| 56 | |
plars | 74948ad | 2002-11-14 16:16:14 +0000 | [diff] [blame] | 57 | #include <sys/types.h> |
| 58 | #include <sys/stat.h> |
| 59 | #include <sys/wait.h> |
| 60 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 61 | #include <stdio.h> |
| 62 | #include <signal.h> |
| 63 | #include <errno.h> |
Garrett Cooper | e8530df | 2010-12-21 11:37:57 -0800 | [diff] [blame] | 64 | #include "test.h" |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 65 | |
| 66 | #define MAXKIDS 8 |
| 67 | |
| 68 | char *TCID = "waitpid10"; |
| 69 | int TST_TOTAL = 1; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 70 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 71 | static int alrmintr; |
robbiew | 3d5c735 | 2003-01-13 17:49:51 +0000 | [diff] [blame] | 72 | volatile int intintr; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 73 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 74 | static void setup(void); |
| 75 | static void cleanup(void); |
| 76 | static void inthandlr(); |
| 77 | static void alrmhandlr(); |
| 78 | static void wait_for_parent(void); |
| 79 | static void do_exit(void); |
| 80 | static void do_compute(void); |
| 81 | static void do_fork(void); |
| 82 | static void do_sleep(void); |
| 83 | static void do_mkdir(void); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 84 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 85 | static int fail; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 86 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 87 | #ifdef UCLINUX |
| 88 | static char *argv0; |
| 89 | #endif |
| 90 | |
plars | 74948ad | 2002-11-14 16:16:14 +0000 | [diff] [blame] | 91 | int main(int ac, char **av) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 92 | { |
| 93 | int kid_count, ret_val, status, nkids; |
plars | 74948ad | 2002-11-14 16:16:14 +0000 | [diff] [blame] | 94 | int i, j, k, found; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 95 | int fork_kid_pid[MAXKIDS], wait_kid_pid[MAXKIDS]; |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 96 | int runtime; /* time(sec) to run this process */ |
subrata_modak | bdbaec5 | 2009-02-26 12:14:51 +0000 | [diff] [blame] | 97 | |
Cyril Hrubis | 89af32a | 2012-10-24 16:39:11 +0200 | [diff] [blame] | 98 | int lc; |
Cyril Hrubis | 0b9589f | 2014-05-27 17:40:33 +0200 | [diff] [blame] | 99 | const char *msg; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 100 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 101 | msg = parse_opts(ac, av, NULL, NULL); |
| 102 | if (msg != NULL) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 103 | tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 104 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 105 | #ifdef UCLINUX |
| 106 | argv0 = av[0]; |
| 107 | |
| 108 | maybe_run_child(&do_exit, "n", 1); |
| 109 | maybe_run_child(&do_compute, "n", 2); |
| 110 | maybe_run_child(&do_fork, "n", 3); |
| 111 | maybe_run_child(&do_sleep, "n", 4); |
| 112 | maybe_run_child(&do_mkdir, "n", 5); |
| 113 | #endif |
subrata_modak | bdbaec5 | 2009-02-26 12:14:51 +0000 | [diff] [blame] | 114 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 115 | /* |
| 116 | * process the arg -- If there is one arg, it is the |
| 117 | * number of seconds to run. If there is no arg the program |
| 118 | * defaults to 60 sec runtime. |
| 119 | */ |
| 120 | if (ac == 2) { |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 121 | if (sscanf(av[1], "%d", &runtime) != 1) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 122 | tst_resm(TFAIL, "%s is an invalid argument", av[1]); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 123 | } else { |
| 124 | runtime = 60; |
| 125 | } |
| 126 | |
| 127 | setup(); |
| 128 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 129 | for (lc = 0; TEST_LOOPING(lc); lc++) { |
Caspar Zhang | d59a659 | 2013-03-07 14:59:12 +0800 | [diff] [blame] | 130 | /* reset tst_count in case we are looping */ |
| 131 | tst_count = 0; |
subrata_modak | 6c9301a | 2008-02-25 09:31:51 +0000 | [diff] [blame] | 132 | fail = 0; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 133 | |
robbiew | 4644c7e | 2002-04-26 14:33:32 +0000 | [diff] [blame] | 134 | if (signal(SIGALRM, alrmhandlr) == SIG_ERR) { |
| 135 | tst_resm(TFAIL, "signal SIGALRM failed. errno = %d", |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 136 | errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 137 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 138 | } |
| 139 | alrmintr = 0; |
| 140 | |
| 141 | /* |
| 142 | * Set up to catch SIGINT. The kids will wait till a SIGINT |
| 143 | * has been received before they proceed. |
| 144 | */ |
robbiew | 4644c7e | 2002-04-26 14:33:32 +0000 | [diff] [blame] | 145 | if (signal(SIGINT, inthandlr) == SIG_ERR) { |
| 146 | tst_resm(TFAIL, "signal SIGINT failed. errno = %d", |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 147 | errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 148 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 149 | } |
| 150 | intintr = 0; |
| 151 | |
| 152 | /* Turn on the real time interval timer. */ |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 153 | if ((alarm(runtime)) < 0) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 154 | tst_resm(TFAIL, "alarm failed. errno = %d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 155 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 156 | /* Run the test over and over until the timer expires */ |
| 157 | for (;;) { |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 158 | if (alrmintr) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 159 | break; |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 160 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 161 | /* |
| 162 | * Fork 8 kids. There will be 4 sets of 2 processes |
| 163 | * doing the same thing. Save all kid pid's in an |
| 164 | * array for future use. The kids will first wait for |
| 165 | * the parent to send SIGINT. Then will proceed to |
| 166 | * their assigned tasks. |
| 167 | */ |
| 168 | kid_count = 0; |
robbiew | 9400d95 | 2005-02-22 22:18:49 +0000 | [diff] [blame] | 169 | /* |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 170 | * Clearing the intinitr flag here for all the children. |
| 171 | * So that we may not miss any signals ! |
| 172 | */ |
robbiew | 9400d95 | 2005-02-22 22:18:49 +0000 | [diff] [blame] | 173 | intintr = 0; |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 174 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 175 | if (ret_val == 0) { /* child 0 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 176 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 177 | if (self_exec(argv0, "n", 1) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 178 | tst_resm(TFAIL, "self_exec 0 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 179 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 180 | do_exit(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 181 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 182 | } |
| 183 | if (ret_val < 0) { |
| 184 | tst_resm(TFAIL, "Fork kid 0 failed. errno = " |
| 185 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 186 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | /* parent */ |
| 190 | fork_kid_pid[kid_count++] = ret_val; |
| 191 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 192 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 193 | if (ret_val == 0) { /* child 1 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 194 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 195 | if (self_exec(argv0, "n", 1) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 196 | tst_resm(TFAIL, "self_exec 1 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 197 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 198 | do_exit(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 199 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 200 | } |
| 201 | if (ret_val < 0) { |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 202 | tst_resm(TFAIL, "Fork kid 1 failed. errno = " |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 203 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 204 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | /* parent */ |
| 208 | fork_kid_pid[kid_count++] = ret_val; |
| 209 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 210 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 211 | if (ret_val == 0) { /* child 2 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 212 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 213 | if (self_exec(argv0, "n", 2) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 214 | tst_resm(TFAIL, "self_exec 2 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 215 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 216 | do_compute(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 217 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 218 | } |
| 219 | if (ret_val < 0) { |
| 220 | tst_resm(TFAIL, "Fork kid 2 failed. errno = " |
| 221 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 222 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | /* parent */ |
| 226 | fork_kid_pid[kid_count++] = ret_val; |
| 227 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 228 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 229 | if (ret_val == 0) { /* child 3 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 230 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 231 | if (self_exec(argv0, "n", 2) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 232 | tst_resm(TFAIL, "self_exec 3 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 233 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 234 | do_compute(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 235 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 236 | } |
| 237 | if (ret_val < 0) { |
| 238 | tst_resm(TFAIL, "Fork kid 3 failed. errno = " |
| 239 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 240 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | /* parent */ |
| 244 | fork_kid_pid[kid_count++] = ret_val; |
| 245 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 246 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 247 | if (ret_val == 0) { /* child 4 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 248 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 249 | if (self_exec(argv0, "n", 3) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 250 | tst_resm(TFAIL, "self_exec 4 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 251 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 252 | do_fork(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 253 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 254 | } |
| 255 | if (ret_val < 0) { |
| 256 | tst_resm(TFAIL, "Fork kid 4 failed. errno = " |
| 257 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 258 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | /* parent */ |
| 262 | fork_kid_pid[kid_count++] = ret_val; |
| 263 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 264 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 265 | if (ret_val == 0) { /* child 5 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 266 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 267 | if (self_exec(argv0, "n", 3) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 268 | tst_resm(TFAIL, "self_exec 5 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 269 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 270 | do_fork(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 271 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 272 | } |
| 273 | if (ret_val < 0) { |
| 274 | tst_resm(TFAIL, "Fork kid 5 failed. errno = " |
| 275 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 276 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | /* parent */ |
| 280 | fork_kid_pid[kid_count++] = ret_val; |
| 281 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 282 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 283 | if (ret_val == 0) { /* child 6 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 284 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 285 | if (self_exec(argv0, "n", 4) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 286 | tst_resm(TFAIL, "self_exec 6 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 287 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 288 | do_sleep(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 289 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 290 | } |
| 291 | if (ret_val < 0) { |
| 292 | tst_resm(TFAIL, "Fork kid 6 failed. errno = " |
| 293 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 294 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | /* parent */ |
| 298 | fork_kid_pid[kid_count++] = ret_val; |
| 299 | |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 300 | ret_val = FORK_OR_VFORK(); |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 301 | if (ret_val == 0) { /* child 7 */ |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 302 | #ifdef UCLINUX |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 303 | if (self_exec(argv0, "n", 4) < 0) |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 304 | tst_resm(TFAIL, "self_exec 7 failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 305 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 306 | do_sleep(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 307 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 308 | } |
| 309 | if (ret_val < 0) { |
| 310 | tst_resm(TFAIL, "Fork kid 7 failed. errno = " |
| 311 | "%d", errno); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 312 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 313 | } |
| 314 | |
| 315 | /* parent */ |
| 316 | fork_kid_pid[kid_count++] = ret_val; |
| 317 | |
| 318 | nkids = kid_count; |
| 319 | |
| 320 | /* |
| 321 | * Now send all the kids a SIGINT to tell them to |
| 322 | * proceed. We sleep for a while first to allow the |
| 323 | * children to initialize their "intintr" variables |
| 324 | * and get set up. |
| 325 | */ |
| 326 | sleep(15); |
| 327 | |
| 328 | for (i = 0; i < nkids; i++) { |
| 329 | if (kill(fork_kid_pid[i], SIGINT) < 0) { |
| 330 | tst_resm(TFAIL, "Kill of child %d " |
| 331 | "failed, errno = %d", i, |
| 332 | errno); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 333 | } |
| 334 | } |
| 335 | |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 336 | /* Wait till all kids have terminated. */ |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 337 | kid_count = 0; |
| 338 | errno = 0; |
| 339 | for (i = 0; i < nkids; i++) { |
| 340 | while (((ret_val = waitpid(fork_kid_pid[i], |
| 341 | &status, 0)) != -1) |
| 342 | || (errno == EINTR)) { |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 343 | if (ret_val == -1) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 344 | continue; |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 345 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 346 | wait_kid_pid[kid_count++] = ret_val; |
| 347 | } |
| 348 | } |
| 349 | |
| 350 | /* |
| 351 | * Check that for every entry in the fork_kid_pid |
| 352 | * array, there is a matching pid in the |
| 353 | * wait_kid_pid array. |
| 354 | */ |
| 355 | for (i = 0; i < MAXKIDS; i++) { |
| 356 | found = 0; |
| 357 | for (j = 0; j < MAXKIDS; j++) { |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 358 | if (fork_kid_pid[i] == wait_kid_pid[j]) { |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 359 | found = 1; |
| 360 | break; |
| 361 | } |
| 362 | } |
| 363 | if (!found) { |
| 364 | tst_resm(TFAIL, "Did not find a " |
| 365 | "wait_kid_pid for the " |
| 366 | "fork_kid_pid of %d", |
| 367 | fork_kid_pid[i]); |
| 368 | for (k = 0; k < nkids; k++) { |
| 369 | tst_resm(TFAIL, |
| 370 | "fork_kid_pid[%d] = " |
| 371 | "%d", k, |
| 372 | fork_kid_pid[k]); |
| 373 | } |
| 374 | for (k = 0; k < kid_count; k++) { |
| 375 | tst_resm(TFAIL, |
| 376 | "wait_kid_pid[%d] = " |
| 377 | "%d", k, |
| 378 | wait_kid_pid[k]); |
| 379 | } |
| 380 | fail = 1; |
| 381 | } |
| 382 | } |
| 383 | } |
| 384 | |
| 385 | /* Kill kids and remove file from do_mkdir */ |
| 386 | rmdir("waitpid14.ttt.ttt"); |
| 387 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 388 | if (fail) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 389 | tst_resm(TFAIL, "Test FAILED"); |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 390 | else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 391 | tst_resm(TPASS, "Test PASSED"); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 392 | } |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 393 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 394 | cleanup(); |
Garrett Cooper | 7d0a4a5 | 2010-12-16 10:05:08 -0800 | [diff] [blame] | 395 | tst_exit(); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 396 | } |
| 397 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 398 | static void setup(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 399 | { |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 400 | tst_sig(FORK, DEF_HANDLER, cleanup); |
| 401 | |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 402 | TEST_PAUSE; |
| 403 | } |
| 404 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 405 | static void cleanup(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 406 | { |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 407 | } |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 408 | |
Mike Frysinger | c57fba5 | 2014-04-09 18:56:30 -0400 | [diff] [blame] | 409 | static void alrmhandlr(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 410 | { |
| 411 | alrmintr++; |
| 412 | } |
| 413 | |
Mike Frysinger | c57fba5 | 2014-04-09 18:56:30 -0400 | [diff] [blame] | 414 | static void inthandlr(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 415 | { |
| 416 | intintr++; |
| 417 | } |
| 418 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 419 | static void wait_for_parent(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 420 | { |
| 421 | int testvar; |
| 422 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 423 | while (!intintr) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 424 | testvar = 0; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 425 | } |
| 426 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 427 | static void do_exit(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 428 | { |
| 429 | wait_for_parent(); |
| 430 | exit(3); |
| 431 | } |
| 432 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 433 | static void do_compute(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 434 | { |
| 435 | int i; |
| 436 | |
| 437 | wait_for_parent(); |
| 438 | |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 439 | for (i = 0; i < 100000; i++) ; |
| 440 | for (i = 0; i < 100000; i++) ; |
| 441 | for (i = 0; i < 100000; i++) ; |
| 442 | for (i = 0; i < 100000; i++) ; |
| 443 | for (i = 0; i < 100000; i++) ; |
| 444 | for (i = 0; i < 100000; i++) ; |
| 445 | for (i = 0; i < 100000; i++) ; |
| 446 | for (i = 0; i < 100000; i++) ; |
| 447 | for (i = 0; i < 100000; i++) ; |
| 448 | for (i = 0; i < 100000; i++) ; |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 449 | |
| 450 | exit(4); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 451 | } |
| 452 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 453 | static void do_fork(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 454 | { |
plars | 74948ad | 2002-11-14 16:16:14 +0000 | [diff] [blame] | 455 | int fork_pid, wait_pid; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 456 | int status, i; |
| 457 | |
| 458 | wait_for_parent(); |
| 459 | |
| 460 | /* |
| 461 | * Fork a kid. Keep track of the kid's pid, have the kid do_mkdir, |
| 462 | * and wait for it. Compare the fork_pid with the wait_pid to be |
| 463 | * sure they are the same. |
| 464 | */ |
| 465 | for (i = 0; i < 50; i++) { |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 466 | fork_pid = FORK_OR_VFORK(); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 467 | if (fork_pid < 0) { |
Cyril Hrubis | 526fdf8 | 2014-12-04 14:35:01 +0100 | [diff] [blame] | 468 | tst_brkm(TFAIL, NULL, "Fork failed"); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 469 | } |
| 470 | if (fork_pid == 0) { |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 471 | #ifdef UCLINUX |
| 472 | if (self_exec(argv0, "n", 5) < 0) { |
Cyril Hrubis | 526fdf8 | 2014-12-04 14:35:01 +0100 | [diff] [blame] | 473 | tst_brkm(TFAIL, NULL, |
| 474 | "do_fork self_exec failed"); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 475 | } |
| 476 | #else |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 477 | do_mkdir(); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 478 | #endif |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 479 | } |
| 480 | |
| 481 | errno = 0; |
| 482 | while (((wait_pid = waitpid(fork_pid, &status, 0)) != -1) || |
subrata_modak | 56207ce | 2009-03-23 13:35:39 +0000 | [diff] [blame] | 483 | (errno == EINTR)) { |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 484 | if (wait_pid == -1) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 485 | continue; |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 486 | |
| 487 | if (fork_pid != wait_pid) { |
| 488 | tst_resm(TFAIL, "Didnt get a pid returned " |
| 489 | "from waitpid that matches the one " |
| 490 | "returned by fork"); |
| 491 | tst_resm(TFAIL, "fork pid = %d, wait pid = " |
| 492 | "%d", fork_pid, wait_pid); |
| 493 | fail = 1; |
| 494 | } |
| 495 | } |
| 496 | } |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 497 | |
| 498 | exit(4); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 499 | } |
| 500 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 501 | static void do_sleep(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 502 | { |
| 503 | wait_for_parent(); |
| 504 | sleep(1); |
| 505 | sleep(1); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 506 | |
| 507 | exit(4); |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 508 | } |
| 509 | |
Wanlong Gao | bfca91c | 2012-11-20 10:32:33 +0800 | [diff] [blame] | 510 | static void do_mkdir(void) |
plars | 865695b | 2001-08-27 22:15:12 +0000 | [diff] [blame] | 511 | { |
| 512 | int ret_val; |
| 513 | |
| 514 | /* |
| 515 | * Please note that this will succeed once, and then fail. That's |
| 516 | * part of the test. |
| 517 | */ |
| 518 | ret_val = mkdir("waitpid14.ttt.ttt", 0777); |
robbiew | d34d581 | 2005-07-11 22:28:09 +0000 | [diff] [blame] | 519 | |
| 520 | exit(4); |
Chris Dearman | ec6edca | 2012-10-17 19:54:01 -0700 | [diff] [blame] | 521 | } |