tools/testing/selftests/arm64/fp/fp-stress.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2022 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
  29 #define MAX_VLS 16
  30
  31 #define SIGNAL_INTERVAL_MS 25
  32 #define LOG_INTERVALS (1000 / SIGNAL_INTERVAL_MS)
  33
  34 struct child_data {
  35         char *name, *output;
  36         pid_t pid;
  37         int stdout;
  38         bool output_seen;
  39         bool exited;
  40         int exit_status;
  41 };
  42
  43 static int epoll_fd;
  44 static struct child_data *children;
  45 static struct epoll_event *evs;
  46 static int tests;
  47 static int num_children;
  48 static bool terminate;
  49
  50 static int startup_pipe[2];
  51
  52 static int num_processors(void)
  53 {
  54         long nproc = sysconf(_SC_NPROCESSORS_CONF);
  55         if (nproc < 0) {
  56                 perror("Unable to read number of processors\n");
  57                 exit(EXIT_FAILURE);
  58         }
  59
  60         return nproc;
  61 }
  62
  63 static void child_start(struct child_data *child, const char *program)
  64 {
  65         int ret, pipefd[2], i;
  66         struct epoll_event ev;
  67
  68         ret = pipe(pipefd);
  69         if (ret != 0)
  70                 ksft_exit_fail_msg("Failed to create stdout pipe: %s (%d)\n",
  71                                    strerror(errno), errno);
  72
  73         child->pid = fork();
  74         if (child->pid == -1)
  75                 ksft_exit_fail_msg("fork() failed: %s (%d)\n",
  76                                    strerror(errno), errno);
  77
  78         if (!child->pid) {
  79                 /*
  80                  * In child, replace stdout with the pipe, errors to
  81                  * stderr from here as kselftest prints to stdout.
  82                  */
  83                 ret = dup2(pipefd[1], 1);
  84                 if (ret == -1) {
  85                         printf("dup2() %d\n", errno);
  86                         exit(EXIT_FAILURE);
  87                 }
  88
  89                 /*
  90                  * Duplicate the read side of the startup pipe to
  91                  * FD 3 so we can close everything else.
  92                  */
  93                 ret = dup2(startup_pipe[0], 3);
  94                 if (ret == -1) {
  95                         printf("dup2() %d\n", errno);
  96                         exit(EXIT_FAILURE);
  97                 }
  98
  99                 /*
 100                  * Very dumb mechanism to clean open FDs other than
 101                  * stdio. We don't want O_CLOEXEC for the pipes...
 102                  */
 103                 for (i = 4; i < 8192; i++)
 104                         close(i);
 105
 106                 /*
 107                  * Read from the startup pipe, there should be no data
 108                  * and we should block until it is closed.  We just
 109                  * carry on on error since this isn't super critical.
 110                  */
 111                 ret = read(3, &i, sizeof(i));
 112                 if (ret < 0)
 113                         printf("read(startp pipe) failed: %s (%d)\n",
 114                                strerror(errno), errno);
 115                 if (ret > 0)
 116                         printf("%d bytes of data on startup pipe\n", ret);
 117                 close(3);
 118
 119                 ret = execl(program, program, NULL);
 120                 printf("execl(%s) failed: %d (%s)\n",
 121                        program, errno, strerror(errno));
 122
 123                 exit(EXIT_FAILURE);
 124         } else {
 125                 /*
 126                  * In parent, remember the child and close our copy of the
 127                  * write side of stdout.
 128                  */
 129                 close(pipefd[1]);
 130                 child->stdout = pipefd[0];
 131                 child->output = NULL;
 132                 child->exited = false;
 133                 child->output_seen = false;
 134
 135                 ev.events = EPOLLIN | EPOLLHUP;
 136                 ev.data.ptr = child;
 137
 138                 ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, child->stdout, &ev);
 139                 if (ret < 0) {
 140                         ksft_exit_fail_msg("%s EPOLL_CTL_ADD failed: %s (%d)\n",
 141                                            child->name, strerror(errno), errno);
 142                 }
 143         }
 144 }
 145
 146 static bool child_output_read(struct child_data *child)
 147 {
 148         char read_data[1024];
 149         char work[1024];
 150         int ret, len, cur_work, cur_read;
 151
 152         ret = read(child->stdout, read_data, sizeof(read_data));
 153         if (ret < 0) {
 154                 if (errno == EINTR)
 155                         return true;
 156
 157                 ksft_print_msg("%s: read() failed: %s (%d)\n",
 158                                child->name, strerror(errno),
 159                                errno);
 160                 return false;
 161         }
 162         len = ret;
 163
 164         child->output_seen = true;
 165
 166         /* Pick up any partial read */
 167         if (child->output) {
 168                 strncpy(work, child->output, sizeof(work) - 1);
 169                 cur_work = strnlen(work, sizeof(work));
 170                 free(child->output);
 171                 child->output = NULL;
 172         } else {
 173                 cur_work = 0;
 174         }
 175
 176         cur_read = 0;
 177         while (cur_read < len) {
 178                 work[cur_work] = read_data[cur_read++];
 179
 180                 if (work[cur_work] == '\n') {
 181                         work[cur_work] = '\0';
 182                         ksft_print_msg("%s: %s\n", child->name, work);
 183                         cur_work = 0;
 184                 } else {
 185                         cur_work++;
 186                 }
 187         }
 188
 189         if (cur_work) {
 190                 work[cur_work] = '\0';
 191                 ret = asprintf(&child->output, "%s", work);
 192                 if (ret == -1)
 193                         ksft_exit_fail_msg("Out of memory\n");
 194         }
 195
 196         return false;
 197 }
 198
 199 static void child_output(struct child_data *child, uint32_t events,
 200                          bool flush)
 201 {
 202         bool read_more;
 203
 204         if (events & EPOLLIN) {
 205                 do {
 206                         read_more = child_output_read(child);
 207                 } while (read_more);
 208         }
 209
 210         if (events & EPOLLHUP) {
 211                 close(child->stdout);
 212                 child->stdout = -1;
 213                 flush = true;
 214         }
 215
 216         if (flush && child->output) {
 217                 ksft_print_msg("%s: %s<EOF>\n", child->name, child->output);
 218                 free(child->output);
 219                 child->output = NULL;
 220         }
 221 }
 222
 223 static void child_tickle(struct child_data *child)
 224 {
 225         if (child->output_seen && !child->exited)
 226                 kill(child->pid, SIGUSR1);
 227 }
 228
 229 static void child_stop(struct child_data *child)
 230 {
 231         if (!child->exited)
 232                 kill(child->pid, SIGTERM);
 233 }
 234
 235 static void child_cleanup(struct child_data *child)
 236 {
 237         pid_t ret;
 238         int status;
 239         bool fail = false;
 240
 241         if (!child->exited) {
 242                 do {
 243                         ret = waitpid(child->pid, &status, 0);
 244                         if (ret == -1 && errno == EINTR)
 245                                 continue;
 246
 247                         if (ret == -1) {
 248                                 ksft_print_msg("waitpid(%d) failed: %s (%d)\n",
 249                                                child->pid, strerror(errno),
 250                                                errno);
 251                                 fail = true;
 252                                 break;
 253                         }
 254                 } while (!WIFEXITED(status));
 255                 child->exit_status = WEXITSTATUS(status);
 256         }
 257
 258         if (!child->output_seen) {
 259                 ksft_print_msg("%s no output seen\n", child->name);
 260                 fail = true;
 261         }
 262
 263         if (child->exit_status != 0) {
 264                 ksft_print_msg("%s exited with error code %d\n",
 265                                child->name, child->exit_status);
 266                 fail = true;
 267         }
 268
 269         ksft_test_result(!fail, "%s\n", child->name);
 270 }
 271
 272 static void handle_child_signal(int sig, siginfo_t *info, void *context)
 273 {
 274         int i;
 275         bool found = false;
 276
 277         for (i = 0; i < num_children; i++) {
 278                 if (children[i].pid == info->si_pid) {
 279                         children[i].exited = true;
 280                         children[i].exit_status = info->si_status;
 281                         found = true;
 282                         break;
 283                 }
 284         }
 285
 286         if (!found)
 287                 ksft_print_msg("SIGCHLD for unknown PID %d with status %d\n",
 288                                info->si_pid, info->si_status);
 289 }
 290
 291 static void handle_exit_signal(int sig, siginfo_t *info, void *context)
 292 {
 293         int i;
 294
 295         /* If we're already exiting then don't signal again */
 296         if (terminate)
 297                 return;
 298
 299         ksft_print_msg("Got signal, exiting...\n");
 300
 301         terminate = true;
 302
 303         /*
 304          * This should be redundant, the main loop should clean up
 305          * after us, but for safety stop everything we can here.
 306          */
 307         for (i = 0; i < num_children; i++)
 308                 child_stop(&children[i]);
 309 }
 310
 311 static void start_fpsimd(struct child_data *child, int cpu, int copy)
 312 {
 313         int ret;
 314
 315         ret = asprintf(&child->name, "FPSIMD-%d-%d", cpu, copy);
 316         if (ret == -1)
 317                 ksft_exit_fail_msg("asprintf() failed\n");
 318
 319         child_start(child, "./fpsimd-test");
 320
 321         ksft_print_msg("Started %s\n", child->name);
 322 }
 323
 324 static void start_kernel(struct child_data *child, int cpu, int copy)
 325 {
 326         int ret;
 327
 328         ret = asprintf(&child->name, "KERNEL-%d-%d", cpu, copy);
 329         if (ret == -1)
 330                 ksft_exit_fail_msg("asprintf() failed\n");
 331
 332         child_start(child, "./kernel-test");
 333
 334         ksft_print_msg("Started %s\n", child->name);
 335 }
 336
 337 static void start_sve(struct child_data *child, int vl, int cpu)
 338 {
 339         int ret;
 340
 341         ret = prctl(PR_SVE_SET_VL, vl | PR_SVE_VL_INHERIT);
 342         if (ret < 0)
 343                 ksft_exit_fail_msg("Failed to set SVE VL %d\n", vl);
 344
 345         ret = asprintf(&child->name, "SVE-VL-%d-%d", vl, cpu);
 346         if (ret == -1)
 347                 ksft_exit_fail_msg("asprintf() failed\n");
 348
 349         child_start(child, "./sve-test");
 350
 351         ksft_print_msg("Started %s\n", child->name);
 352 }
 353
 354 static void start_ssve(struct child_data *child, int vl, int cpu)
 355 {
 356         int ret;
 357
 358         ret = asprintf(&child->name, "SSVE-VL-%d-%d", vl, cpu);
 359         if (ret == -1)
 360                 ksft_exit_fail_msg("asprintf() failed\n");
 361
 362         ret = prctl(PR_SME_SET_VL, vl | PR_SME_VL_INHERIT);
 363         if (ret < 0)
 364                 ksft_exit_fail_msg("Failed to set SME VL %d\n", ret);
 365
 366         child_start(child, "./ssve-test");
 367
 368         ksft_print_msg("Started %s\n", child->name);
 369 }
 370
 371 static void start_za(struct child_data *child, int vl, int cpu)
 372 {
 373         int ret;
 374
 375         ret = prctl(PR_SME_SET_VL, vl | PR_SVE_VL_INHERIT);
 376         if (ret < 0)
 377                 ksft_exit_fail_msg("Failed to set SME VL %d\n", ret);
 378
 379         ret = asprintf(&child->name, "ZA-VL-%d-%d", vl, cpu);
 380         if (ret == -1)
 381                 ksft_exit_fail_msg("asprintf() failed\n");
 382
 383         child_start(child, "./za-test");
 384
 385         ksft_print_msg("Started %s\n", child->name);
 386 }
 387
 388 static void start_zt(struct child_data *child, int cpu)
 389 {
 390         int ret;
 391
 392         ret = asprintf(&child->name, "ZT-%d", cpu);
 393         if (ret == -1)
 394                 ksft_exit_fail_msg("asprintf() failed\n");
 395
 396         child_start(child, "./zt-test");
 397
 398         ksft_print_msg("Started %s\n", child->name);
 399 }
 400
 401 static void probe_vls(int vls[], int *vl_count, int set_vl)
 402 {
 403         unsigned int vq;
 404         int vl;
 405
 406         *vl_count = 0;
 407
 408         for (vq = SVE_VQ_MAX; vq > 0; vq /= 2) {
 409                 vl = prctl(set_vl, vq * 16);
 410                 if (vl == -1)
 411                         ksft_exit_fail_msg("SET_VL failed: %s (%d)\n",
 412                                            strerror(errno), errno);
 413
 414                 vl &= PR_SVE_VL_LEN_MASK;
 415
 416                 if (*vl_count && (vl == vls[*vl_count - 1]))
 417                         break;
 418
 419                 vq = sve_vq_from_vl(vl);
 420
 421                 vls[*vl_count] = vl;
 422                 *vl_count += 1;
 423         }
 424 }
 425
 426 /* Handle any pending output without blocking */
 427 static void drain_output(bool flush)
 428 {
 429         int ret = 1;
 430         int i;
 431
 432         while (ret > 0) {
 433                 ret = epoll_wait(epoll_fd, evs, tests, 0);
 434                 if (ret < 0) {
 435                         if (errno == EINTR)
 436                                 continue;
 437                         ksft_print_msg("epoll_wait() failed: %s (%d)\n",
 438                                        strerror(errno), errno);
 439                 }
 440
 441                 for (i = 0; i < ret; i++)
 442                         child_output(evs[i].data.ptr, evs[i].events, flush);
 443         }
 444 }
 445
 446 static const struct option options[] = {
 447         { "timeout",    required_argument, NULL, 't' },
 448         { }
 449 };
 450
 451 int main(int argc, char **argv)
 452 {
 453         int ret;
 454         int timeout = 10 * (1000 / SIGNAL_INTERVAL_MS);
 455         int poll_interval = 5000;
 456         int cpus, i, j, c;
 457         int sve_vl_count, sme_vl_count;
 458         bool all_children_started = false;
 459         int seen_children;
 460         int sve_vls[MAX_VLS], sme_vls[MAX_VLS];
 461         bool have_sme2;
 462         struct sigaction sa;
 463
 464         while ((c = getopt_long(argc, argv, "t:", options, NULL)) != -1) {
 465                 switch (c) {
 466                 case 't':
 467                         ret = sscanf(optarg, "%d", &timeout);
 468                         if (ret != 1)
 469                                 ksft_exit_fail_msg("Failed to parse timeout %s\n",
 470                                                    optarg);
 471                         break;
 472                 default:
 473                         ksft_exit_fail_msg("Unknown argument\n");
 474                 }
 475         }
 476
 477         cpus = num_processors();
 478         tests = 0;
 479
 480         if (getauxval(AT_HWCAP) & HWCAP_SVE) {
 481                 probe_vls(sve_vls, &sve_vl_count, PR_SVE_SET_VL);
 482                 tests += sve_vl_count * cpus;
 483         } else {
 484                 sve_vl_count = 0;
 485         }
 486
 487         if (getauxval(AT_HWCAP2) & HWCAP2_SME) {
 488                 probe_vls(sme_vls, &sme_vl_count, PR_SME_SET_VL);
 489                 tests += sme_vl_count * cpus * 2;
 490         } else {
 491                 sme_vl_count = 0;
 492         }
 493
 494         if (getauxval(AT_HWCAP2) & HWCAP2_SME2) {
 495                 tests += cpus;
 496                 have_sme2 = true;
 497         } else {
 498                 have_sme2 = false;
 499         }
 500
 501         tests += cpus * 2;
 502
 503         ksft_print_header();
 504         ksft_set_plan(tests);
 505
 506         ksft_print_msg("%d CPUs, %d SVE VLs, %d SME VLs, SME2 %s\n",
 507                        cpus, sve_vl_count, sme_vl_count,
 508                        have_sme2 ? "present" : "absent");
 509
 510         if (timeout > 0)
 511                 ksft_print_msg("Will run for %d\n", timeout);
 512         else
 513                 ksft_print_msg("Will run until terminated\n");
 514
 515         children = calloc(sizeof(*children), tests);
 516         if (!children)
 517                 ksft_exit_fail_msg("Unable to allocate child data\n");
 518
 519         ret = epoll_create1(EPOLL_CLOEXEC);
 520         if (ret < 0)
 521                 ksft_exit_fail_msg("epoll_create1() failed: %s (%d)\n",
 522                                    strerror(errno), ret);
 523         epoll_fd = ret;
 524
 525         /* Create a pipe which children will block on before execing */
 526         ret = pipe(startup_pipe);
 527         if (ret != 0)
 528                 ksft_exit_fail_msg("Failed to create startup pipe: %s (%d)\n",
 529                                    strerror(errno), errno);
 530
 531         /* Get signal handers ready before we start any children */
 532         memset(&sa, 0, sizeof(sa));
 533         sa.sa_sigaction = handle_exit_signal;
 534         sa.sa_flags = SA_RESTART | SA_SIGINFO;
 535         sigemptyset(&sa.sa_mask);
 536         ret = sigaction(SIGINT, &sa, NULL);
 537         if (ret < 0)
 538                 ksft_print_msg("Failed to install SIGINT handler: %s (%d)\n",
 539                                strerror(errno), errno);
 540         ret = sigaction(SIGTERM, &sa, NULL);
 541         if (ret < 0)
 542                 ksft_print_msg("Failed to install SIGTERM handler: %s (%d)\n",
 543                                strerror(errno), errno);
 544         sa.sa_sigaction = handle_child_signal;
 545         ret = sigaction(SIGCHLD, &sa, NULL);
 546         if (ret < 0)
 547                 ksft_print_msg("Failed to install SIGCHLD handler: %s (%d)\n",
 548                                strerror(errno), errno);
 549
 550         evs = calloc(tests, sizeof(*evs));
 551         if (!evs)
 552                 ksft_exit_fail_msg("Failed to allocated %d epoll events\n",
 553                                    tests);
 554
 555         for (i = 0; i < cpus; i++) {
 556                 start_fpsimd(&children[num_children++], i, 0);
 557                 start_kernel(&children[num_children++], i, 0);
 558
 559                 for (j = 0; j < sve_vl_count; j++)
 560                         start_sve(&children[num_children++], sve_vls[j], i);
 561
 562                 for (j = 0; j < sme_vl_count; j++) {
 563                         start_ssve(&children[num_children++], sme_vls[j], i);
 564                         start_za(&children[num_children++], sme_vls[j], i);
 565                 }
 566
 567                 if (have_sme2)
 568                         start_zt(&children[num_children++], i);
 569         }
 570
 571         /*
 572          * All children started, close the startup pipe and let them
 573          * run.
 574          */
 575         close(startup_pipe[0]);
 576         close(startup_pipe[1]);
 577
 578         for (;;) {
 579                 /* Did we get a signal asking us to exit? */
 580                 if (terminate)
 581                         break;
 582
 583                 /*
 584                  * Timeout is counted in poll intervals with no
 585                  * output, the tests print during startup then are
 586                  * silent when running so this should ensure they all
 587                  * ran enough to install the signal handler, this is
 588                  * especially useful in emulation where we will both
 589                  * be slow and likely to have a large set of VLs.
 590                  */
 591                 ret = epoll_wait(epoll_fd, evs, tests, poll_interval);
 592                 if (ret < 0) {
 593                         if (errno == EINTR)
 594                                 continue;
 595                         ksft_exit_fail_msg("epoll_wait() failed: %s (%d)\n",
 596                                            strerror(errno), errno);
 597                 }
 598
 599                 /* Output? */
 600                 if (ret > 0) {
 601                         for (i = 0; i < ret; i++) {
 602                                 child_output(evs[i].data.ptr, evs[i].events,
 603                                              false);
 604                         }
 605                         continue;
 606                 }
 607
 608                 /* Otherwise epoll_wait() timed out */
 609
 610                 /*
 611                  * If the child processes have not produced output they
 612                  * aren't actually running the tests yet .
 613                  */
 614                 if (!all_children_started) {
 615                         seen_children = 0;
 616
 617                         for (i = 0; i < num_children; i++)
 618                                 if (children[i].output_seen ||
 619                                     children[i].exited)
 620                                         seen_children++;
 621
 622                         if (seen_children != num_children) {
 623                                 ksft_print_msg("Waiting for %d children\n",
 624                                                num_children - seen_children);
 625                                 continue;
 626                         }
 627
 628                         all_children_started = true;
 629                         poll_interval = SIGNAL_INTERVAL_MS;
 630                 }
 631
 632                 if ((timeout % LOG_INTERVALS) == 0)
 633                         ksft_print_msg("Sending signals, timeout remaining: %d\n",
 634                                        timeout);
 635
 636                 for (i = 0; i < num_children; i++)
 637                         child_tickle(&children[i]);
 638
 639                 /* Negative timeout means run indefinitely */
 640                 if (timeout < 0)
 641                         continue;
 642                 if (--timeout == 0)
 643                         break;
 644         }
 645
 646         ksft_print_msg("Finishing up...\n");
 647         terminate = true;
 648
 649         for (i = 0; i < tests; i++)
 650                 child_stop(&children[i]);
 651
 652         drain_output(false);
 653
 654         for (i = 0; i < tests; i++)
 655                 child_cleanup(&children[i]);
 656
 657         drain_output(true);
 658
 659         ksft_finished();
 660 }