-
Notifications
You must be signed in to change notification settings - Fork 0
/
flood.c
228 lines (193 loc) · 4.4 KB
/
flood.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
/* flood.c - Copyright (c) 2017, Sijmen J. Mulder (see LICENSE.md) */
#define _BSD_SOURCE /* for GNU libc, deprecated */
#define _DEFAULT_SOURCE /* for GNU libc */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <signal.h>
#include <limits.h>
#define ELWAIT 1
static const char usage[] =
"usage: flood [-d delay] [-j maxjobs] [-n count] command [argument ...]\n";
static char **cmdargs; /* command to run */
static int delay = 100, maxjobs, maxtotal; /* command line options */
static int njobs, nfailed, ngood;
static volatile sig_atomic_t bsigint;
static void onsigchld(int sig) { (void)sig; } /* to interrupt nanosleep */
static void onsigint(int sig) { (void)sig; bsigint = 1; }
#ifdef SIGINFO
static volatile sig_atomic_t bsiginfo;
static void onsiginfo(int sig) { (void)sig; bsiginfo = 1; }
#endif
static int
xstrtoi(char *val, char *name)
{
long lval;
char *end;
lval = strtol(val, &end, 10);
if (lval < 0 || lval > INT_MAX || *end) {
fprintf(stderr, "invalid %s\n", name);
exit(1);
}
return (int)lval;
}
static void
parseopts(int argc, char **argv)
{
int c;
while ((c = getopt(argc, argv, "d:j:n:")) != -1) {
switch (c) {
case 'd':
delay = xstrtoi(optarg, "delay (-d)");
break;
case 'j':
maxjobs = xstrtoi(optarg, "maxjobs (-j)");
break;
case 'n':
maxtotal = xstrtoi(optarg, "count (-n)");
break;
default:
fputs(usage, stderr);
exit(1);
}
}
cmdargs = argv + optind;
if (!*cmdargs) {
fputs(usage, stderr);
exit(1);
}
}
static void
startone(void)
{
int outfd;
njobs++;
write(STDOUT_FILENO, ".", 1);
switch (fork()) {
case -1:
perror(NULL);
exit(1);
case 0:
if ((outfd = open("/dev/null", O_WRONLY)) == -1)
goto err;
dup2(outfd, STDOUT_FILENO);
dup2(outfd, STDERR_FILENO);
close(outfd);
execvp(*cmdargs, cmdargs);
err:
putchar('@');
exit(0);
}
}
static void
pstatus(void)
{
int goodpct, badpct;
if (maxjobs)
printf("\nrunning: %6d/%d\n", njobs, maxjobs);
else
printf("\nrunning: %6d\n", njobs);
if (ngood + nfailed) {
goodpct = (ngood * 100) / (ngood + nfailed);
badpct = (nfailed * 100) / (ngood + nfailed);
printf("completed: %6d (%3d%%)\n", ngood, goodpct);
printf("failed: %6d (%3d%%)\n", nfailed, badpct);
} else {
puts("completed: 0");
puts("failed: 0");
}
}
/* Handles pending signal flags and completed child pressess. If the ELBLOCK
flag is set, the function blocks until at least one child process exits.
Returns 0 on success, -1 if a problem occured. */
static int
evtloop(int flags)
{
int status, waitflags;
/* block for one child if ELWAIT is set */
waitflags = (flags & ELWAIT) ? 0 : WNOHANG;
while (1) {
if (bsigint) {
pstatus();
/* exit with proper signal status */
signal(SIGINT, SIG_DFL);
raise(SIGINT);
exit(1); /* fallback */
}
#ifdef SIGINFO
if (bsiginfo) {
pstatus();
bsiginfo = 0;
}
#endif
switch (waitpid(0, &status, waitflags)) {
case -1:
switch (errno) {
case EINTR:
/* continue to handle signal and try again */
break;
case ECHILD:
/* only a problem if we're blocking for the
first child because of ELWAIT */
return (waitflags & WNOHANG) ? 0 : -1;
default:
perror(NULL);
exit(1);
}
break;
case 0:
/* nothing pending (WNOHANG only), we're done */
return 0;
default:
/* child exited */
njobs--;
if (status) {
nfailed++;
write(STDOUT_FILENO, "!", 1);
} else {
ngood++;
write(STDOUT_FILENO, "*", 1);
}
/* ELWAIT is honored */
waitflags = WNOHANG;
break;
}
}
}
int
main(int argc, char **argv)
{
struct timespec ts;
parseopts(argc, argv);
signal(SIGCHLD, onsigchld); /* to interrupt nanosleep() */
signal(SIGINT, onsigint);
#ifdef SIGINFO
signal(SIGINFO, onsiginfo);
#endif
while (!maxtotal || njobs+nfailed+ngood < maxtotal) {
while (maxjobs && njobs >= maxjobs)
evtloop(ELWAIT);
startone();
evtloop(0);
if (delay) {
ts.tv_sec = delay / 1000;
ts.tv_nsec = (long)(delay % 1000) * 1000 * 1000;
/* nanosleep() will be interrupted by SIGCHLD when
a child terminates; which will be handled by
evtloop() */
while (nanosleep(&ts, &ts) == -1 && errno == EINTR)
evtloop(0);
}
}
/* wait for all children */
while (evtloop(ELWAIT) == 0)
;
pstatus();
return 0;
}