testsuite/testsuite.c

   1 /*
   2  * Copyright (C) 2012-2013  ProFUSION embedded systems
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (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 the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <dirent.h>
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <getopt.h>
  22 #include <limits.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <time.h>
  28 #include <unistd.h>
  29 #include <sys/epoll.h>
  30 #include <sys/prctl.h>
  31 #include <sys/stat.h>
  32 #include <sys/wait.h>
  33
  34 #include <shared/util.h>
  35
  36 #include "testsuite.h"
  37
  38 static const char *ANSI_HIGHLIGHT_GREEN_ON = "\x1B[1;32m";
  39 static const char *ANSI_HIGHLIGHT_RED_ON =  "\x1B[1;31m";
  40 static const char *ANSI_HIGHLIGHT_OFF = "\x1B[0m";
  41
  42 static const char *progname;
  43 static int oneshot = 0;
  44 static const char options_short[] = "lhn";
  45 static const struct option options[] = {
  46         { "list", no_argument, 0, 'l' },
  47         { "help", no_argument, 0, 'h' },
  48         { NULL, 0, 0, 0 }
  49 };
  50
  51 #define OVERRIDE_LIBDIR ABS_TOP_BUILDDIR "/testsuite/.libs/"
  52
  53 struct _env_config {
  54         const char *key;
  55         const char *ldpreload;
  56 } env_config[_TC_LAST] = {
  57         [TC_UNAME_R] = { S_TC_UNAME_R, OVERRIDE_LIBDIR  "uname.so" },
  58         [TC_ROOTFS] = { S_TC_ROOTFS, OVERRIDE_LIBDIR "path.so" },
  59         [TC_INIT_MODULE_RETCODES] = { S_TC_INIT_MODULE_RETCODES, OVERRIDE_LIBDIR "init_module.so" },
  60         [TC_DELETE_MODULE_RETCODES] = { S_TC_DELETE_MODULE_RETCODES, OVERRIDE_LIBDIR "delete_module.so" },
  61 };
  62
  63 #define USEC_PER_SEC  1000000ULL
  64 #define USEC_PER_MSEC  1000ULL
  65 #define TEST_TIMEOUT_USEC 2 * USEC_PER_SEC
  66 static unsigned long long now_usec(void)
  67 {
  68         struct timespec ts;
  69
  70         if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
  71                 return 0;
  72
  73         return ts_usec(&ts);
  74 }
  75
  76 static void help(void)
  77 {
  78         const struct option *itr;
  79         const char *itr_short;
  80
  81         printf("Usage:\n"
  82                "\t%s [options] <test>\n"
  83                "Options:\n", basename(progname));
  84
  85         for (itr = options, itr_short = options_short;
  86                                 itr->name != NULL; itr++, itr_short++)
  87                 printf("\t-%c, --%s\n", *itr_short, itr->name);
  88 }
  89
  90 static void test_list(const struct test *start, const struct test *stop)
  91 {
  92         const struct test *t;
  93
  94         printf("Available tests:\n");
  95         for (t = start; t < stop; t++)
  96                 printf("\t%s, %s\n", t->name, t->description);
  97 }
  98
  99 int test_init(const struct test *start, const struct test *stop,
 100               int argc, char *const argv[])
 101 {
 102         progname = argv[0];
 103
 104         for (;;) {
 105                 int c, idx = 0;
 106                 c = getopt_long(argc, argv, options_short, options, &idx);
 107                 if (c == -1)
 108                         break;
 109                 switch (c) {
 110                 case 'l':
 111                         test_list(start, stop);
 112                         return 0;
 113                 case 'h':
 114                         help();
 115                         return 0;
 116                 case 'n':
 117                         oneshot = 1;
 118                         break;
 119                 case '?':
 120                         return -1;
 121                 default:
 122                         ERR("unexpected getopt_long() value %c\n", c);
 123                         return -1;
 124                 }
 125         }
 126
 127         if (isatty(STDOUT_FILENO) == 0) {
 128                 ANSI_HIGHLIGHT_OFF = "";
 129                 ANSI_HIGHLIGHT_RED_ON = "";
 130                 ANSI_HIGHLIGHT_GREEN_ON = "";
 131         }
 132
 133         return optind;
 134 }
 135
 136 const struct test *test_find(const struct test *start,
 137                              const struct test *stop, const char *name)
 138 {
 139         const struct test *t;
 140
 141         for (t = start; t < stop; t++) {
 142                 if (streq(t->name, name))
 143                         return t;
 144         }
 145
 146         return NULL;
 147 }
 148
 149 static int test_spawn_test(const struct test *t)
 150 {
 151         const char *const args[] = { progname, "-n", t->name, NULL };
 152
 153         execv(progname, (char *const *) args);
 154
 155         ERR("failed to spawn %s for %s: %m\n", progname, t->name);
 156         return EXIT_FAILURE;
 157 }
 158
 159 static int test_run_spawned(const struct test *t)
 160 {
 161         int err = t->func(t);
 162         exit(err);
 163
 164         return EXIT_FAILURE;
 165 }
 166
 167 int test_spawn_prog(const char *prog, const char *const args[])
 168 {
 169         execv(prog, (char *const *) args);
 170
 171         ERR("failed to spawn %s\n", prog);
 172         ERR("did you forget to build tools?\n");
 173         return EXIT_FAILURE;
 174 }
 175
 176 static void test_export_environ(const struct test *t)
 177 {
 178         char *preload = NULL;
 179         size_t preloadlen = 0;
 180         size_t i;
 181         const struct keyval *env;
 182
 183         unsetenv("LD_PRELOAD");
 184
 185         for (i = 0; i < _TC_LAST; i++) {
 186                 const char *ldpreload;
 187                 size_t ldpreloadlen;
 188                 char *tmp;
 189
 190                 if (t->config[i] == NULL)
 191                         continue;
 192
 193                 setenv(env_config[i].key, t->config[i], 1);
 194
 195                 ldpreload = env_config[i].ldpreload;
 196                 ldpreloadlen = strlen(ldpreload);
 197                 tmp = realloc(preload, preloadlen + 2 + ldpreloadlen);
 198                 if (tmp == NULL) {
 199                         ERR("oom: test_export_environ()\n");
 200                         return;
 201                 }
 202                 preload = tmp;
 203
 204                 if (preloadlen > 0)
 205                         preload[preloadlen++] = ' ';
 206                 memcpy(preload + preloadlen, ldpreload, ldpreloadlen);
 207                 preloadlen += ldpreloadlen;
 208                 preload[preloadlen] = '\0';
 209         }
 210
 211         if (preload != NULL)
 212                 setenv("LD_PRELOAD", preload, 1);
 213
 214         free(preload);
 215
 216         for (env = t->env_vars; env && env->key; env++)
 217                 setenv(env->key, env->val, 1);
 218 }
 219
 220 static inline int test_run_child(const struct test *t, int fdout[2],
 221                                                 int fderr[2], int fdmonitor[2])
 222 {
 223         /* kill child if parent dies */
 224         prctl(PR_SET_PDEATHSIG, SIGTERM);
 225
 226         test_export_environ(t);
 227
 228         /* Close read-fds and redirect std{out,err} to the write-fds */
 229         if (t->output.out != NULL) {
 230                 close(fdout[0]);
 231                 if (dup2(fdout[1], STDOUT_FILENO) < 0) {
 232                         ERR("could not redirect stdout to pipe: %m\n");
 233                         exit(EXIT_FAILURE);
 234                 }
 235         }
 236
 237         if (t->output.err != NULL) {
 238                 close(fderr[0]);
 239                 if (dup2(fderr[1], STDERR_FILENO) < 0) {
 240                         ERR("could not redirect stderr to pipe: %m\n");
 241                         exit(EXIT_FAILURE);
 242                 }
 243         }
 244
 245         close(fdmonitor[0]);
 246
 247         if (t->config[TC_ROOTFS] != NULL) {
 248                 const char *stamp = TESTSUITE_ROOTFS "../stamp-rootfs";
 249                 const char *rootfs = t->config[TC_ROOTFS];
 250                 struct stat rootfsst, stampst;
 251
 252                 if (stat(stamp, &stampst) != 0) {
 253                         ERR("could not stat %s\n - %m", stamp);
 254                         exit(EXIT_FAILURE);
 255                 }
 256
 257                 if (stat(rootfs, &rootfsst) != 0) {
 258                         ERR("could not stat %s\n - %m", rootfs);
 259                         exit(EXIT_FAILURE);
 260                 }
 261
 262                 if (stat_mstamp(&rootfsst) > stat_mstamp(&stampst)) {
 263                         ERR("rootfs %s is dirty, please run 'make rootfs' before runnning this test\n",
 264                                                                 rootfs);
 265                         exit(EXIT_FAILURE);
 266                 }
 267         }
 268
 269         if (t->need_spawn)
 270                 return test_spawn_test(t);
 271         else
 272                 return test_run_spawned(t);
 273 }
 274
 275 static int check_activity(int fd, bool activity,  const char *path,
 276                           const char *stream)
 277 {
 278         struct stat st;
 279
 280         /* not monitoring or monitoring and it has activity */
 281         if (fd < 0 || activity)
 282                 return 0;
 283
 284         /* monitoring, there was no activity and size matches */
 285         if (stat(path, &st) == 0 && st.st_size == 0)
 286                 return 0;
 287
 288         ERR("Expecting output on %s, but test didn't produce any\n", stream);
 289
 290         return -1;
 291 }
 292
 293 static inline bool test_run_parent_check_outputs(const struct test *t,
 294                         int fdout, int fderr, int fdmonitor, pid_t child)
 295 {
 296         struct epoll_event ep_outpipe, ep_errpipe, ep_monitor;
 297         int err, fd_ep, fd_matchout = -1, fd_matcherr = -1;
 298         bool fd_activityout = false, fd_activityerr = false;
 299         unsigned long long end_usec, start_usec;
 300
 301         fd_ep = epoll_create1(EPOLL_CLOEXEC);
 302         if (fd_ep < 0) {
 303                 ERR("could not create epoll fd: %m\n");
 304                 return false;
 305         }
 306
 307         if (t->output.out != NULL) {
 308                 fd_matchout = open(t->output.out, O_RDONLY);
 309                 if (fd_matchout < 0) {
 310                         err = -errno;
 311                         ERR("could not open %s for read: %m\n",
 312                                                         t->output.out);
 313                         goto out;
 314                 }
 315                 memset(&ep_outpipe, 0, sizeof(struct epoll_event));
 316                 ep_outpipe.events = EPOLLIN;
 317                 ep_outpipe.data.ptr = &fdout;
 318                 if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fdout, &ep_outpipe) < 0) {
 319                         err = -errno;
 320                         ERR("could not add fd to epoll: %m\n");
 321                         goto out;
 322                 }
 323         } else
 324                 fdout = -1;
 325
 326         if (t->output.err != NULL) {
 327                 fd_matcherr = open(t->output.err, O_RDONLY);
 328                 if (fd_matcherr < 0) {
 329                         err = -errno;
 330                         ERR("could not open %s for read: %m\n",
 331                                         t->output.err);
 332                         goto out;
 333
 334                 }
 335                 memset(&ep_errpipe, 0, sizeof(struct epoll_event));
 336                 ep_errpipe.events = EPOLLIN;
 337                 ep_errpipe.data.ptr = &fderr;
 338                 if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fderr, &ep_errpipe) < 0) {
 339                         err = -errno;
 340                         ERR("could not add fd to epoll: %m\n");
 341                         goto out;
 342                 }
 343         } else
 344                 fderr = -1;
 345
 346         memset(&ep_monitor, 0, sizeof(struct epoll_event));
 347         ep_monitor.events = EPOLLHUP;
 348         ep_monitor.data.ptr = &fdmonitor;
 349         if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fdmonitor, &ep_monitor) < 0) {
 350                 err = -errno;
 351                 ERR("could not add monitor fd to epoll: %m\n");
 352                 goto out;
 353         }
 354
 355         start_usec = now_usec();
 356         end_usec = start_usec + TEST_TIMEOUT_USEC;
 357
 358         for (err = 0; fdmonitor >= 0 || fdout >= 0 || fderr >= 0;) {
 359                 int fdcount, i, timeout;
 360                 struct epoll_event ev[4];
 361                 unsigned long long curr_usec = now_usec();
 362
 363                 if (curr_usec > end_usec)
 364                         break;
 365
 366                 timeout = (end_usec - curr_usec) / USEC_PER_MSEC;
 367                 fdcount = epoll_wait(fd_ep, ev, 4, timeout);
 368                 if (fdcount < 0) {
 369                         if (errno == EINTR)
 370                                 continue;
 371                         err = -errno;
 372                         ERR("could not poll: %m\n");
 373                         goto out;
 374                 }
 375
 376                 for (i = 0;  i < fdcount; i++) {
 377                         int *fd = ev[i].data.ptr;
 378
 379                         if (ev[i].events & EPOLLIN) {
 380                                 ssize_t r, done = 0;
 381                                 char buf[4096];
 382                                 char bufmatch[4096];
 383                                 int fd_match;
 384
 385                                 /*
 386                                  * compare the output from child with the one
 387                                  * saved as correct
 388                                  */
 389
 390                                 r = read(*fd, buf, sizeof(buf) - 1);
 391                                 if (r <= 0)
 392                                         continue;
 393
 394                                 if (*fd == fdout) {
 395                                         fd_match = fd_matchout;
 396                                         fd_activityout = true;
 397                                 } else if (*fd == fderr) {
 398                                         fd_match = fd_matcherr;
 399                                         fd_activityerr = true;
 400                                 } else {
 401                                         ERR("Unexpected activity on monitor pipe\n");
 402                                         err = -EINVAL;
 403                                         goto out;
 404                                 }
 405
 406                                 for (;;) {
 407                                         int rmatch = read(fd_match,
 408                                                 bufmatch + done, r - done);
 409                                         if (rmatch == 0)
 410                                                 break;
 411
 412                                         if (rmatch < 0) {
 413                                                 if (errno == EINTR)
 414                                                         continue;
 415                                                 err = -errno;
 416                                                 ERR("could not read match fd %d\n",
 417                                                                 fd_match);
 418                                                 goto out;
 419                                         }
 420
 421                                         done += rmatch;
 422                                 }
 423
 424                                 buf[r] = '\0';
 425                                 bufmatch[r] = '\0';
 426
 427                                 if (t->print_outputs)
 428                                         printf("%s: %s\n",
 429                                                fd_match == fd_matchout ? "STDOUT:" : "STDERR:",
 430                                                buf);
 431
 432                                 if (!streq(buf, bufmatch)) {
 433                                         ERR("Outputs do not match on %s:\n",
 434                                                 fd_match == fd_matchout ? "STDOUT" : "STDERR");
 435                                         ERR("correct:\n%s\n", bufmatch);
 436                                         ERR("wrong:\n%s\n", buf);
 437                                         err = -1;
 438                                         goto out;
 439                                 }
 440                         } else if (ev[i].events & EPOLLHUP) {
 441                                 if (epoll_ctl(fd_ep, EPOLL_CTL_DEL,
 442                                                         *fd, NULL) < 0) {
 443                                         ERR("could not remove fd %d from epoll: %m\n",
 444                                                                         *fd);
 445                                 }
 446                                 *fd = -1;
 447                         }
 448                 }
 449         }
 450
 451         err = check_activity(fd_matchout, fd_activityout, t->output.out, "stdout");
 452         err |= check_activity(fd_matcherr, fd_activityerr, t->output.err, "stderr");
 453
 454         if (err == 0 && fdmonitor >= 0) {
 455                 err = -EINVAL;
 456                 ERR("Test '%s' timed out, killing %d\n", t->name, child);
 457                 kill(child, SIGKILL);
 458         }
 459
 460 out:
 461         if (fd_matchout >= 0)
 462                 close(fd_matchout);
 463         if (fd_matcherr >= 0)
 464                 close(fd_matcherr);
 465         if (fd_ep >= 0)
 466                 close(fd_ep);
 467         return err == 0;
 468 }
 469
 470 static inline int safe_read(int fd, void *buf, size_t count)
 471 {
 472         int r;
 473
 474         while (1) {
 475                 r = read(fd, buf, count);
 476                 if (r == -1 && errno == EINTR)
 477                         continue;
 478                 break;
 479         }
 480
 481         return r;
 482 }
 483
 484 static bool check_generated_files(const struct test *t)
 485 {
 486         const struct keyval *k;
 487
 488         /* This is not meant to be a diff replacement, just stupidly check if
 489          * the files match. Bear in mind they can be binary files */
 490         for (k = t->output.files; k && k->key; k++) {
 491                 struct stat sta, stb;
 492                 int fda = -1, fdb = -1;
 493                 char bufa[4096];
 494                 char bufb[4096];
 495
 496                 fda = open(k->key, O_RDONLY);
 497                 if (fda < 0) {
 498                         ERR("could not open %s\n - %m\n", k->key);
 499                         goto fail;
 500                 }
 501
 502                 fdb = open(k->val, O_RDONLY);
 503                 if (fdb < 0) {
 504                         ERR("could not open %s\n - %m\n", k->val);
 505                         goto fail;
 506                 }
 507
 508                 if (fstat(fda, &sta) != 0) {
 509                         ERR("could not fstat %d %s\n - %m\n", fda, k->key);
 510                         goto fail;
 511                 }
 512
 513                 if (fstat(fdb, &stb) != 0) {
 514                         ERR("could not fstat %d %s\n - %m\n", fdb, k->key);
 515                         goto fail;
 516                 }
 517
 518                 if (sta.st_size != stb.st_size) {
 519                         ERR("sizes do not match %s %s\n", k->key, k->val);
 520                         goto fail;
 521                 }
 522
 523                 for (;;) {
 524                         int r, done;
 525
 526                         r = safe_read(fda, bufa, sizeof(bufa));
 527                         if (r < 0)
 528                                 goto fail;
 529
 530                         if (r == 0)
 531                                 /* size is already checked, go to next file */
 532                                 goto next;
 533
 534                         for (done = 0; done < r;) {
 535                                 int r2 = safe_read(fdb, bufb + done, r - done);
 536
 537                                 if (r2 <= 0)
 538                                         goto fail;
 539
 540                                 done += r2;
 541                         }
 542
 543                         if (memcmp(bufa, bufb, r) != 0)
 544                                 goto fail;
 545                 }
 546
 547 next:
 548                 close(fda);
 549                 close(fdb);
 550                 continue;
 551
 552 fail:
 553                 if (fda >= 0)
 554                         close(fda);
 555                 if (fdb >= 0)
 556                         close(fdb);
 557
 558                 return false;
 559         }
 560
 561         return true;
 562 }
 563
 564 static int cmp_modnames(const void *m1, const void *m2)
 565 {
 566         const char *s1 = *(char *const *)m1;
 567         const char *s2 = *(char *const *)m2;
 568         int i;
 569
 570         for (i = 0; s1[i] || s2[i]; i++) {
 571                 char c1 = s1[i], c2 = s2[i];
 572                 if (c1 == '-')
 573                         c1 = '_';
 574                 if (c2 == '-')
 575                         c2 = '_';
 576                 if (c1 != c2)
 577                         return c1 - c2;
 578         }
 579         return 0;
 580 }
 581
 582 /*
 583  * Store the expected module names in buf and return a list of pointers to
 584  * them.
 585  */
 586 static const char **read_expected_modules(const struct test *t,
 587                 char **buf, int *count)
 588 {
 589         const char **res;
 590         int len;
 591         int i;
 592         char *p;
 593
 594         if (t->modules_loaded[0] == '\0') {
 595                 *count = 0;
 596                 *buf = NULL;
 597                 return NULL;
 598         }
 599         *buf = strdup(t->modules_loaded);
 600         if (!*buf) {
 601                 *count = -1;
 602                 return NULL;
 603         }
 604         len = 1;
 605         for (p = *buf; *p; p++)
 606                 if (*p == ',')
 607                         len++;
 608         res = malloc(sizeof(char *) * len);
 609         if (!res) {
 610                 perror("malloc");
 611                 *count = -1;
 612                 free(*buf);
 613                 *buf = NULL;
 614                 return NULL;
 615         }
 616         i = 0;
 617         res[i++] = *buf;
 618         for (p = *buf; i < len; p++)
 619                 if (*p == ',') {
 620                         *p = '\0';
 621                         res[i++] = p + 1;
 622                 }
 623         *count = len;
 624         return res;
 625 }
 626
 627 static char **read_loaded_modules(const struct test *t, char **buf, int *count)
 628 {
 629         char dirname[PATH_MAX];
 630         DIR *dir;
 631         struct dirent *dirent;
 632         int i;
 633         int len = 0, bufsz;
 634         char **res = NULL;
 635         char *p;
 636         const char *rootfs = t->config[TC_ROOTFS] ? t->config[TC_ROOTFS] : "";
 637
 638         /* Store the entries in /sys/module to res */
 639         if (snprintf(dirname, sizeof(dirname), "%s/sys/module", rootfs)
 640                         >= (int)sizeof(dirname)) {
 641                 ERR("rootfs path too long: %s\n", rootfs);
 642                 *buf = NULL;
 643                 len = -1;
 644                 goto out;
 645         }
 646         dir = opendir(dirname);
 647         /* not an error, simply return empty list */
 648         if (!dir) {
 649                 *buf = NULL;
 650                 goto out;
 651         }
 652         bufsz = 0;
 653         while ((dirent = readdir(dir))) {
 654                 if (dirent->d_name[0] == '.')
 655                         continue;
 656                 len++;
 657                 bufsz += strlen(dirent->d_name) + 1;
 658         }
 659         res = malloc(sizeof(char *) * len);
 660         if (!res) {
 661                 perror("malloc");
 662                 len = -1;
 663                 goto out_dir;
 664         }
 665         *buf = malloc(bufsz);
 666         if (!*buf) {
 667                 perror("malloc");
 668                 free(res);
 669                 res = NULL;
 670                 len = -1;
 671                 goto out_dir;
 672         }
 673         rewinddir(dir);
 674         i = 0;
 675         p = *buf;
 676         while ((dirent = readdir(dir))) {
 677                 int size;
 678
 679                 if (dirent->d_name[0] == '.')
 680                         continue;
 681                 size = strlen(dirent->d_name) + 1;
 682                 memcpy(p, dirent->d_name, size);
 683                 res[i++] = p;
 684                 p += size;
 685         }
 686 out_dir:
 687         closedir(dir);
 688 out:
 689         *count = len;
 690         return res;
 691 }
 692
 693 static int check_loaded_modules(const struct test *t)
 694 {
 695         int l1, l2, i1, i2;
 696         const char **a1;
 697         char **a2;
 698         char *buf1, *buf2;
 699         int err = false;
 700
 701         a1 = read_expected_modules(t, &buf1, &l1);
 702         if (l1 < 0)
 703                 return err;
 704         a2 = read_loaded_modules(t, &buf2, &l2);
 705         if (l2 < 0)
 706                 goto out_a1;
 707         qsort(a1, l1, sizeof(char *), cmp_modnames);
 708         qsort(a2, l2, sizeof(char *), cmp_modnames);
 709         i1 = i2 = 0;
 710         err = true;
 711         while (i1 < l1 || i2 < l2) {
 712                 int cmp;
 713
 714                 if (i1 >= l1)
 715                         cmp = 1;
 716                 else if (i2 >= l2)
 717                         cmp = -1;
 718                 else
 719                         cmp = cmp_modnames(&a1[i1], &a2[i2]);
 720                 if (cmp == 0) {
 721                         i1++;
 722                         i2++;
 723                 } else if (cmp < 0) {
 724                         err = false;
 725                         ERR("module %s not loaded\n", a1[i1]);
 726                         i1++;
 727                 } else  {
 728                         err = false;
 729                         ERR("module %s is loaded but should not be \n", a2[i2]);
 730                         i2++;
 731                 }
 732         }
 733         free(a2);
 734         free(buf2);
 735 out_a1:
 736         free(a1);
 737         free(buf1);
 738         return err;
 739 }
 740
 741 static inline int test_run_parent(const struct test *t, int fdout[2],
 742                                 int fderr[2], int fdmonitor[2], pid_t child)
 743 {
 744         pid_t pid;
 745         int err;
 746         bool matchout, match_modules;
 747
 748         /* Close write-fds */
 749         if (t->output.out != NULL)
 750                 close(fdout[1]);
 751         if (t->output.err != NULL)
 752                 close(fderr[1]);
 753         close(fdmonitor[1]);
 754
 755         matchout = test_run_parent_check_outputs(t, fdout[0], fderr[0],
 756                                                         fdmonitor[0], child);
 757
 758         /*
 759          * break pipe on the other end: either child already closed or we want
 760          * to stop it
 761          */
 762         if (t->output.out != NULL)
 763                 close(fdout[0]);
 764         if (t->output.err != NULL)
 765                 close(fderr[0]);
 766         close(fdmonitor[0]);
 767
 768         do {
 769                 pid = wait(&err);
 770                 if (pid == -1) {
 771                         ERR("error waitpid(): %m\n");
 772                         err = EXIT_FAILURE;
 773                         goto exit;
 774                 }
 775         } while (!WIFEXITED(err) && !WIFSIGNALED(err));
 776
 777         if (WIFEXITED(err)) {
 778                 if (WEXITSTATUS(err) != 0)
 779                         ERR("'%s' [%u] exited with return code %d\n",
 780                                         t->name, pid, WEXITSTATUS(err));
 781                 else
 782                         LOG("'%s' [%u] exited with return code %d\n",
 783                                         t->name, pid, WEXITSTATUS(err));
 784         } else if (WIFSIGNALED(err)) {
 785                 ERR("'%s' [%u] terminated by signal %d (%s)\n", t->name, pid,
 786                                 WTERMSIG(err), strsignal(WTERMSIG(err)));
 787                 err = t->expected_fail ? EXIT_SUCCESS : EXIT_FAILURE;
 788                 goto exit;
 789         }
 790
 791         if (matchout)
 792                 matchout = check_generated_files(t);
 793         if (t->modules_loaded)
 794                 match_modules = check_loaded_modules(t);
 795         else
 796                 match_modules = true;
 797
 798         if (t->expected_fail == false) {
 799                 if (err == 0) {
 800                         if (matchout && match_modules)
 801                                 LOG("%sPASSED%s: %s\n",
 802                                         ANSI_HIGHLIGHT_GREEN_ON, ANSI_HIGHLIGHT_OFF,
 803                                         t->name);
 804                         else {
 805                                 ERR("%sFAILED%s: exit ok but %s do not match: %s\n",
 806                                         ANSI_HIGHLIGHT_RED_ON, ANSI_HIGHLIGHT_OFF,
 807                                         matchout ? "loaded modules" : "outputs",
 808                                         t->name);
 809                                 err = EXIT_FAILURE;
 810                         }
 811                 } else {
 812                         ERR("%sFAILED%s: %s\n",
 813                                         ANSI_HIGHLIGHT_RED_ON, ANSI_HIGHLIGHT_OFF,
 814                                         t->name);
 815                 }
 816         } else {
 817                 if (err == 0) {
 818                         if (matchout) {
 819                                 ERR("%sUNEXPECTED PASS%s: exit with 0: %s\n",
 820                                         ANSI_HIGHLIGHT_RED_ON, ANSI_HIGHLIGHT_OFF,
 821                                         t->name);
 822                                 err = EXIT_FAILURE;
 823                         } else {
 824                                 ERR("%sUNEXPECTED PASS%s: exit with 0 and outputs do not match: %s\n",
 825                                         ANSI_HIGHLIGHT_RED_ON, ANSI_HIGHLIGHT_OFF,
 826                                         t->name);
 827                                 err = EXIT_FAILURE;
 828                         }
 829                 } else {
 830                         if (matchout) {
 831                                 LOG("%sEXPECTED FAIL%s: %s\n",
 832                                         ANSI_HIGHLIGHT_GREEN_ON, ANSI_HIGHLIGHT_OFF,
 833                                         t->name);
 834                                 err = EXIT_SUCCESS;
 835                         } else {
 836                                 LOG("%sEXPECTED FAIL%s: exit with %d but outputs do not match: %s\n",
 837                                         ANSI_HIGHLIGHT_GREEN_ON, ANSI_HIGHLIGHT_OFF,
 838                                         WEXITSTATUS(err), t->name);
 839                                 err = EXIT_FAILURE;
 840                         }
 841                 }
 842         }
 843
 844 exit:
 845         LOG("------\n");
 846         return err;
 847 }
 848
 849 static int prepend_path(const char *extra)
 850 {
 851         char *oldpath, *newpath;
 852         int r;
 853
 854         if (extra == NULL)
 855                 return 0;
 856
 857         oldpath = getenv("PATH");
 858         if (oldpath == NULL)
 859                 return setenv("PATH", extra, 1);
 860
 861         if (asprintf(&newpath, "%s:%s", extra, oldpath) < 0) {
 862                 ERR("failed to allocate memory to new PATH\n");
 863                 return -1;
 864         }
 865
 866         r = setenv("PATH", newpath, 1);
 867         free(newpath);
 868
 869         return r;
 870 }
 871
 872 int test_run(const struct test *t)
 873 {
 874         pid_t pid;
 875         int fdout[2];
 876         int fderr[2];
 877         int fdmonitor[2];
 878
 879         if (t->need_spawn && oneshot)
 880                 test_run_spawned(t);
 881
 882         if (t->output.out != NULL) {
 883                 if (pipe(fdout) != 0) {
 884                         ERR("could not create out pipe for %s\n", t->name);
 885                         return EXIT_FAILURE;
 886                 }
 887         }
 888
 889         if (t->output.err != NULL) {
 890                 if (pipe(fderr) != 0) {
 891                         ERR("could not create err pipe for %s\n", t->name);
 892                         return EXIT_FAILURE;
 893                 }
 894         }
 895
 896         if (pipe(fdmonitor) != 0) {
 897                 ERR("could not create monitor pipe for %s\n", t->name);
 898                 return EXIT_FAILURE;
 899         }
 900
 901         if (prepend_path(t->path) < 0) {
 902                 ERR("failed to prepend '%s' to PATH\n", t->path);
 903                 return EXIT_FAILURE;
 904         }
 905
 906         LOG("running %s, in forked context\n", t->name);
 907
 908         pid = fork();
 909         if (pid < 0) {
 910                 ERR("could not fork(): %m\n");
 911                 LOG("FAILED: %s\n", t->name);
 912                 return EXIT_FAILURE;
 913         }
 914
 915         if (pid > 0)
 916                 return test_run_parent(t, fdout, fderr, fdmonitor, pid);
 917
 918         return test_run_child(t, fdout, fderr, fdmonitor);
 919 }