1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2022-3 ARM Limited.
4 */
5
6#define _GNU_SOURCE
7#define _POSIX_C_SOURCE 199309L
8
9#include <errno.h>
10#include <getopt.h>
11#include <poll.h>
12#include <signal.h>
13#include <stdbool.h>
14#include <stddef.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18#include <unistd.h>
19#include <sys/auxv.h>
20#include <sys/epoll.h>
21#include <sys/prctl.h>
22#include <sys/types.h>
23#include <sys/uio.h>
24#include <sys/wait.h>
25#include <asm/hwcap.h>
26
27#include "kselftest.h"
28
29struct child_data {
30 char *name, *output;
31 pid_t pid;
32 int stdout;
33 bool output_seen;
34 bool exited;
35 int exit_status;
36 int exit_signal;
37};
38
39static int epoll_fd;
40static struct child_data *children;
41static struct epoll_event *evs;
42static int tests;
43static int num_children;
44static bool terminate;
45
46static int startup_pipe[2];
47
48static int num_processors(void)
49{
50 long nproc = sysconf(_SC_NPROCESSORS_CONF);
51 if (nproc < 0) {
52 perror("Unable to read number of processors\n");
53 exit(EXIT_FAILURE);
54 }
55
56 return nproc;
57}
58
59static void start_thread(struct child_data *child, int id)
60{
61 int ret, pipefd[2], i;
62 struct epoll_event ev;
63
64 ret = pipe(pipefd);
65 if (ret != 0)
66 ksft_exit_fail_msg("Failed to create stdout pipe: %s (%d)\n",
67 strerror(errno), errno);
68
69 child->pid = fork();
70 if (child->pid == -1)
71 ksft_exit_fail_msg("fork() failed: %s (%d)\n",
72 strerror(errno), errno);
73
74 if (!child->pid) {
75 /*
76 * In child, replace stdout with the pipe, errors to
77 * stderr from here as kselftest prints to stdout.
78 */
79 ret = dup2(pipefd[1], 1);
80 if (ret == -1) {
81 fprintf(stderr, "dup2() %d\n", errno);
82 exit(EXIT_FAILURE);
83 }
84
85 /*
86 * Duplicate the read side of the startup pipe to
87 * FD 3 so we can close everything else.
88 */
89 ret = dup2(startup_pipe[0], 3);
90 if (ret == -1) {
91 fprintf(stderr, "dup2() %d\n", errno);
92 exit(EXIT_FAILURE);
93 }
94
95 /*
96 * Very dumb mechanism to clean open FDs other than
97 * stdio. We don't want O_CLOEXEC for the pipes...
98 */
99 for (i = 4; i < 8192; i++)
100 close(i);
101
102 /*
103 * Read from the startup pipe, there should be no data
104 * and we should block until it is closed. We just
105 * carry on on error since this isn't super critical.
106 */
107 ret = read(3, &i, sizeof(i));
108 if (ret < 0)
109 fprintf(stderr, "read(startp pipe) failed: %s (%d)\n",
110 strerror(errno), errno);
111 if (ret > 0)
112 fprintf(stderr, "%d bytes of data on startup pipe\n",
113 ret);
114 close(3);
115
116 ret = execl("gcs-stress-thread", "gcs-stress-thread", NULL);
117 fprintf(stderr, "execl(gcs-stress-thread) failed: %d (%s)\n",
118 errno, strerror(errno));
119
120 exit(EXIT_FAILURE);
121 } else {
122 /*
123 * In parent, remember the child and close our copy of the
124 * write side of stdout.
125 */
126 close(pipefd[1]);
127 child->stdout = pipefd[0];
128 child->output = NULL;
129 child->exited = false;
130 child->output_seen = false;
131
132 ev.events = EPOLLIN | EPOLLHUP;
133 ev.data.ptr = child;
134
135 ret = asprintf(&child->name, "Thread-%d", id);
136 if (ret == -1)
137 ksft_exit_fail_msg("asprintf() failed\n");
138
139 ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, child->stdout, &ev);
140 if (ret < 0) {
141 ksft_exit_fail_msg("%s EPOLL_CTL_ADD failed: %s (%d)\n",
142 child->name, strerror(errno), errno);
143 }
144 }
145
146 ksft_print_msg("Started %s\n", child->name);
147 num_children++;
148}
149
150static bool child_output_read(struct child_data *child)
151{
152 char read_data[1024];
153 char work[1024];
154 int ret, len, cur_work, cur_read;
155
156 ret = read(child->stdout, read_data, sizeof(read_data));
157 if (ret < 0) {
158 if (errno == EINTR)
159 return true;
160
161 ksft_print_msg("%s: read() failed: %s (%d)\n",
162 child->name, strerror(errno),
163 errno);
164 return false;
165 }
166 len = ret;
167
168 child->output_seen = true;
169
170 /* Pick up any partial read */
171 if (child->output) {
172 strncpy(work, child->output, sizeof(work) - 1);
173 cur_work = strnlen(work, sizeof(work));
174 free(child->output);
175 child->output = NULL;
176 } else {
177 cur_work = 0;
178 }
179
180 cur_read = 0;
181 while (cur_read < len) {
182 work[cur_work] = read_data[cur_read++];
183
184 if (work[cur_work] == '\n') {
185 work[cur_work] = '\0';
186 ksft_print_msg("%s: %s\n", child->name, work);
187 cur_work = 0;
188 } else {
189 cur_work++;
190 }
191 }
192
193 if (cur_work) {
194 work[cur_work] = '\0';
195 ret = asprintf(&child->output, "%s", work);
196 if (ret == -1)
197 ksft_exit_fail_msg("Out of memory\n");
198 }
199
200 return false;
201}
202
203static void child_output(struct child_data *child, uint32_t events,
204 bool flush)
205{
206 bool read_more;
207
208 if (events & EPOLLIN) {
209 do {
210 read_more = child_output_read(child);
211 } while (read_more);
212 }
213
214 if (events & EPOLLHUP) {
215 close(child->stdout);
216 child->stdout = -1;
217 flush = true;
218 }
219
220 if (flush && child->output) {
221 ksft_print_msg("%s: %s<EOF>\n", child->name, child->output);
222 free(child->output);
223 child->output = NULL;
224 }
225}
226
227static void child_tickle(struct child_data *child)
228{
229 if (child->output_seen && !child->exited)
230 kill(child->pid, SIGUSR1);
231}
232
233static void child_stop(struct child_data *child)
234{
235 if (!child->exited)
236 kill(child->pid, SIGTERM);
237}
238
239static void child_cleanup(struct child_data *child)
240{
241 pid_t ret;
242 int status;
243 bool fail = false;
244
245 if (!child->exited) {
246 do {
247 ret = waitpid(child->pid, &status, 0);
248 if (ret == -1 && errno == EINTR)
249 continue;
250
251 if (ret == -1) {
252 ksft_print_msg("waitpid(%d) failed: %s (%d)\n",
253 child->pid, strerror(errno),
254 errno);
255 fail = true;
256 break;
257 }
258
259 if (WIFEXITED(status)) {
260 child->exit_status = WEXITSTATUS(status);
261 child->exited = true;
262 }
263
264 if (WIFSIGNALED(status)) {
265 child->exit_signal = WTERMSIG(status);
266 ksft_print_msg("%s: Exited due to signal %d\n",
267 child->name, child->exit_signal);
268 fail = true;
269 child->exited = true;
270 }
271 } while (!child->exited);
272 }
273
274 if (!child->output_seen) {
275 ksft_print_msg("%s no output seen\n", child->name);
276 fail = true;
277 }
278
279 if (child->exit_status != 0) {
280 ksft_print_msg("%s exited with error code %d\n",
281 child->name, child->exit_status);
282 fail = true;
283 }
284
285 ksft_test_result(!fail, "%s\n", child->name);
286}
287
288static void handle_child_signal(int sig, siginfo_t *info, void *context)
289{
290 int i;
291 bool found = false;
292
293 for (i = 0; i < num_children; i++) {
294 if (children[i].pid == info->si_pid) {
295 children[i].exited = true;
296 children[i].exit_status = info->si_status;
297 found = true;
298 break;
299 }
300 }
301
302 if (!found)
303 ksft_print_msg("SIGCHLD for unknown PID %d with status %d\n",
304 info->si_pid, info->si_status);
305}
306
307static void handle_exit_signal(int sig, siginfo_t *info, void *context)
308{
309 int i;
310
311 /* If we're already exiting then don't signal again */
312 if (terminate)
313 return;
314
315 ksft_print_msg("Got signal, exiting...\n");
316
317 terminate = true;
318
319 /*
320 * This should be redundant, the main loop should clean up
321 * after us, but for safety stop everything we can here.
322 */
323 for (i = 0; i < num_children; i++)
324 child_stop(child: &children[i]);
325}
326
327/* Handle any pending output without blocking */
328static void drain_output(bool flush)
329{
330 int ret = 1;
331 int i;
332
333 while (ret > 0) {
334 ret = epoll_wait(epoll_fd, evs, tests, 0);
335 if (ret < 0) {
336 if (errno == EINTR)
337 continue;
338 ksft_print_msg("epoll_wait() failed: %s (%d)\n",
339 strerror(errno), errno);
340 }
341
342 for (i = 0; i < ret; i++)
343 child_output(evs[i].data.ptr, evs[i].events, flush);
344 }
345}
346
347static const struct option options[] = {
348 { "timeout", required_argument, NULL, 't' },
349 { }
350};
351
352int main(int argc, char **argv)
353{
354 int seen_children;
355 bool all_children_started = false;
356 int gcs_threads;
357 int timeout = 10;
358 int ret, cpus, i, c;
359 struct sigaction sa;
360
361 while ((c = getopt_long(argc, argv, "t:", options, NULL)) != -1) {
362 switch (c) {
363 case 't':
364 ret = sscanf(optarg, "%d", &timeout);
365 if (ret != 1)
366 ksft_exit_fail_msg("Failed to parse timeout %s\n",
367 optarg);
368 break;
369 default:
370 ksft_exit_fail_msg("Unknown argument\n");
371 }
372 }
373
374 cpus = num_processors();
375 tests = 0;
376
377 if (getauxval(AT_HWCAP) & HWCAP_GCS) {
378 /* One extra thread, trying to trigger migrations */
379 gcs_threads = cpus + 1;
380 tests += gcs_threads;
381 } else {
382 gcs_threads = 0;
383 }
384
385 ksft_print_header();
386 ksft_set_plan(tests);
387
388 ksft_print_msg("%d CPUs, %d GCS threads\n",
389 cpus, gcs_threads);
390
391 if (!tests)
392 ksft_exit_skip("No tests scheduled\n");
393
394 if (timeout > 0)
395 ksft_print_msg("Will run for %ds\n", timeout);
396 else
397 ksft_print_msg("Will run until terminated\n");
398
399 children = calloc(sizeof(*children), tests);
400 if (!children)
401 ksft_exit_fail_msg("Unable to allocate child data\n");
402
403 ret = epoll_create1(EPOLL_CLOEXEC);
404 if (ret < 0)
405 ksft_exit_fail_msg("epoll_create1() failed: %s (%d)\n",
406 strerror(errno), ret);
407 epoll_fd = ret;
408
409 /* Create a pipe which children will block on before execing */
410 ret = pipe(startup_pipe);
411 if (ret != 0)
412 ksft_exit_fail_msg("Failed to create startup pipe: %s (%d)\n",
413 strerror(errno), errno);
414
415 /* Get signal handers ready before we start any children */
416 memset(&sa, 0, sizeof(sa));
417 sa.sa_sigaction = handle_exit_signal;
418 sa.sa_flags = SA_RESTART | SA_SIGINFO;
419 sigemptyset(&sa.sa_mask);
420 ret = sigaction(SIGINT, &sa, NULL);
421 if (ret < 0)
422 ksft_print_msg("Failed to install SIGINT handler: %s (%d)\n",
423 strerror(errno), errno);
424 ret = sigaction(SIGTERM, &sa, NULL);
425 if (ret < 0)
426 ksft_print_msg("Failed to install SIGTERM handler: %s (%d)\n",
427 strerror(errno), errno);
428 sa.sa_sigaction = handle_child_signal;
429 ret = sigaction(SIGCHLD, &sa, NULL);
430 if (ret < 0)
431 ksft_print_msg("Failed to install SIGCHLD handler: %s (%d)\n",
432 strerror(errno), errno);
433
434 evs = calloc(tests, sizeof(*evs));
435 if (!evs)
436 ksft_exit_fail_msg("Failed to allocate %d epoll events\n",
437 tests);
438
439 for (i = 0; i < gcs_threads; i++)
440 start_thread(child: &children[i], id: i);
441
442 /*
443 * All children started, close the startup pipe and let them
444 * run.
445 */
446 close(startup_pipe[0]);
447 close(startup_pipe[1]);
448
449 timeout *= 10;
450 for (;;) {
451 /* Did we get a signal asking us to exit? */
452 if (terminate)
453 break;
454
455 /*
456 * Timeout is counted in 100ms with no output, the
457 * tests print during startup then are silent when
458 * running so this should ensure they all ran enough
459 * to install the signal handler, this is especially
460 * useful in emulation where we will both be slow and
461 * likely to have a large set of VLs.
462 */
463 ret = epoll_wait(epoll_fd, evs, tests, 100);
464 if (ret < 0) {
465 if (errno == EINTR)
466 continue;
467 ksft_exit_fail_msg("epoll_wait() failed: %s (%d)\n",
468 strerror(errno), errno);
469 }
470
471 /* Output? */
472 if (ret > 0) {
473 for (i = 0; i < ret; i++) {
474 child_output(evs[i].data.ptr, evs[i].events,
475 false);
476 }
477 continue;
478 }
479
480 /* Otherwise epoll_wait() timed out */
481
482 /*
483 * If the child processes have not produced output they
484 * aren't actually running the tests yet.
485 */
486 if (!all_children_started) {
487 seen_children = 0;
488
489 for (i = 0; i < num_children; i++)
490 if (children[i].output_seen ||
491 children[i].exited)
492 seen_children++;
493
494 if (seen_children != num_children) {
495 ksft_print_msg("Waiting for %d children\n",
496 num_children - seen_children);
497 continue;
498 }
499
500 all_children_started = true;
501 }
502
503 ksft_print_msg("Sending signals, timeout remaining: %d00ms\n",
504 timeout);
505
506 for (i = 0; i < num_children; i++)
507 child_tickle(child: &children[i]);
508
509 /* Negative timeout means run indefinitely */
510 if (timeout < 0)
511 continue;
512 if (--timeout == 0)
513 break;
514 }
515
516 ksft_print_msg("Finishing up...\n");
517 terminate = true;
518
519 for (i = 0; i < tests; i++)
520 child_stop(child: &children[i]);
521
522 drain_output(false);
523
524 for (i = 0; i < tests; i++)
525 child_cleanup(child: &children[i]);
526
527 drain_output(true);
528
529 ksft_finished();
530}
531

source code of linux/tools/testing/selftests/arm64/gcs/gcs-stress.c