tools/testing/selftests/bpf/veristat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
   3 #define _GNU_SOURCE
   4 #include <argp.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <linux/compiler.h>
   8 #include <sched.h>
   9 #include <pthread.h>
  10 #include <dirent.h>
  11 #include <signal.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <sys/time.h>
  15 #include <sys/sysinfo.h>
  16 #include <sys/stat.h>
  17 #include <bpf/libbpf.h>
  18 #include <bpf/btf.h>
  19 #include <libelf.h>
  20 #include <gelf.h>
  21 #include <float.h>
  22
  23 enum stat_id {
  24         VERDICT,
  25         DURATION,
  26         TOTAL_INSNS,
  27         TOTAL_STATES,
  28         PEAK_STATES,
  29         MAX_STATES_PER_INSN,
  30         MARK_READ_MAX_LEN,
  31
  32         FILE_NAME,
  33         PROG_NAME,
  34
  35         ALL_STATS_CNT,
  36         NUM_STATS_CNT = FILE_NAME - VERDICT,
  37 };
  38
  39 /* In comparison mode each stat can specify up to four different values:
  40  *   - A side value;
  41  *   - B side value;
  42  *   - absolute diff value;
  43  *   - relative (percentage) diff value.
  44  *
  45  * When specifying stat specs in comparison mode, user can use one of the
  46  * following variant suffixes to specify which exact variant should be used for
  47  * ordering or filtering:
  48  *   - `_a` for A side value;
  49  *   - `_b` for B side value;
  50  *   - `_diff` for absolute diff value;
  51  *   - `_pct` for relative (percentage) diff value.
  52  *
  53  * If no variant suffix is provided, then `_b` (control data) is assumed.
  54  *
  55  * As an example, let's say instructions stat has the following output:
  56  *
  57  * Insns (A)  Insns (B)  Insns   (DIFF)
  58  * ---------  ---------  --------------
  59  * 21547      20920       -627 (-2.91%)
  60  *
  61  * Then:
  62  *   - 21547 is A side value (insns_a);
  63  *   - 20920 is B side value (insns_b);
  64  *   - -627 is absolute diff value (insns_diff);
  65  *   - -2.91% is relative diff value (insns_pct).
  66  *
  67  * For verdict there is no verdict_pct variant.
  68  * For file and program name, _a and _b variants are equivalent and there are
  69  * no _diff or _pct variants.
  70  */
  71 enum stat_variant {
  72         VARIANT_A,
  73         VARIANT_B,
  74         VARIANT_DIFF,
  75         VARIANT_PCT,
  76 };
  77
  78 struct verif_stats {
  79         char *file_name;
  80         char *prog_name;
  81
  82         long stats[NUM_STATS_CNT];
  83 };
  84
  85 /* joined comparison mode stats */
  86 struct verif_stats_join {
  87         char *file_name;
  88         char *prog_name;
  89
  90         const struct verif_stats *stats_a;
  91         const struct verif_stats *stats_b;
  92 };
  93
  94 struct stat_specs {
  95         int spec_cnt;
  96         enum stat_id ids[ALL_STATS_CNT];
  97         enum stat_variant variants[ALL_STATS_CNT];
  98         bool asc[ALL_STATS_CNT];
  99         int lens[ALL_STATS_CNT * 3]; /* 3x for comparison mode */
 100 };
 101
 102 enum resfmt {
 103         RESFMT_TABLE,
 104         RESFMT_TABLE_CALCLEN, /* fake format to pre-calculate table's column widths */
 105         RESFMT_CSV,
 106 };
 107
 108 enum filter_kind {
 109         FILTER_NAME,
 110         FILTER_STAT,
 111 };
 112
 113 enum operator_kind {
 114         OP_EQ,          /* == or = */
 115         OP_NEQ,         /* != or <> */
 116         OP_LT,          /* < */
 117         OP_LE,          /* <= */
 118         OP_GT,          /* > */
 119         OP_GE,          /* >= */
 120 };
 121
 122 struct filter {
 123         enum filter_kind kind;
 124         /* FILTER_NAME */
 125         char *any_glob;
 126         char *file_glob;
 127         char *prog_glob;
 128         /* FILTER_STAT */
 129         enum operator_kind op;
 130         int stat_id;
 131         enum stat_variant stat_var;
 132         long value;
 133 };
 134
 135 static struct env {
 136         char **filenames;
 137         int filename_cnt;
 138         bool verbose;
 139         bool debug;
 140         bool quiet;
 141         int log_level;
 142         enum resfmt out_fmt;
 143         bool comparison_mode;
 144         bool replay_mode;
 145
 146         struct verif_stats *prog_stats;
 147         int prog_stat_cnt;
 148
 149         /* baseline_stats is allocated and used only in comparison mode */
 150         struct verif_stats *baseline_stats;
 151         int baseline_stat_cnt;
 152
 153         struct verif_stats_join *join_stats;
 154         int join_stat_cnt;
 155
 156         struct stat_specs output_spec;
 157         struct stat_specs sort_spec;
 158
 159         struct filter *allow_filters;
 160         struct filter *deny_filters;
 161         int allow_filter_cnt;
 162         int deny_filter_cnt;
 163
 164         int files_processed;
 165         int files_skipped;
 166         int progs_processed;
 167         int progs_skipped;
 168 } env;
 169
 170 static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
 171 {
 172         if (!env.verbose)
 173                 return 0;
 174         if (level == LIBBPF_DEBUG  && !env.debug)
 175                 return 0;
 176         return vfprintf(stderr, format, args);
 177 }
 178
 179 const char *argp_program_version = "veristat";
 180 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
 181 const char argp_program_doc[] =
 182 "veristat    BPF verifier stats collection and comparison tool.\n"
 183 "\n"
 184 "USAGE: veristat <obj-file> [<obj-file>...]\n"
 185 "   OR: veristat -C <baseline.csv> <comparison.csv>\n";
 186
 187 static const struct argp_option opts[] = {
 188         { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" },
 189         { "verbose", 'v', NULL, 0, "Verbose mode" },
 190         { "log-level", 'l', "LEVEL", 0, "Verifier log level (default 0 for normal mode, 1 for verbose mode)" },
 191         { "debug", 'd', NULL, 0, "Debug mode (turns on libbpf debug logging)" },
 192         { "quiet", 'q', NULL, 0, "Quiet mode" },
 193         { "emit", 'e', "SPEC", 0, "Specify stats to be emitted" },
 194         { "sort", 's', "SPEC", 0, "Specify sort order" },
 195         { "output-format", 'o', "FMT", 0, "Result output format (table, csv), default is table." },
 196         { "compare", 'C', NULL, 0, "Comparison mode" },
 197         { "replay", 'R', NULL, 0, "Replay mode" },
 198         { "filter", 'f', "FILTER", 0, "Filter expressions (or @filename for file with expressions)." },
 199         {},
 200 };
 201
 202 static int parse_stats(const char *stats_str, struct stat_specs *specs);
 203 static int append_filter(struct filter **filters, int *cnt, const char *str);
 204 static int append_filter_file(const char *path);
 205
 206 static error_t parse_arg(int key, char *arg, struct argp_state *state)
 207 {
 208         void *tmp;
 209         int err;
 210
 211         switch (key) {
 212         case 'h':
 213                 argp_state_help(state, stderr, ARGP_HELP_STD_HELP);
 214                 break;
 215         case 'v':
 216                 env.verbose = true;
 217                 break;
 218         case 'd':
 219                 env.debug = true;
 220                 env.verbose = true;
 221                 break;
 222         case 'q':
 223                 env.quiet = true;
 224                 break;
 225         case 'e':
 226                 err = parse_stats(arg, &env.output_spec);
 227                 if (err)
 228                         return err;
 229                 break;
 230         case 's':
 231                 err = parse_stats(arg, &env.sort_spec);
 232                 if (err)
 233                         return err;
 234                 break;
 235         case 'o':
 236                 if (strcmp(arg, "table") == 0) {
 237                         env.out_fmt = RESFMT_TABLE;
 238                 } else if (strcmp(arg, "csv") == 0) {
 239                         env.out_fmt = RESFMT_CSV;
 240                 } else {
 241                         fprintf(stderr, "Unrecognized output format '%s'\n", arg);
 242                         return -EINVAL;
 243                 }
 244                 break;
 245         case 'l':
 246                 errno = 0;
 247                 env.log_level = strtol(arg, NULL, 10);
 248                 if (errno) {
 249                         fprintf(stderr, "invalid log level: %s\n", arg);
 250                         argp_usage(state);
 251                 }
 252                 break;
 253         case 'C':
 254                 env.comparison_mode = true;
 255                 break;
 256         case 'R':
 257                 env.replay_mode = true;
 258                 break;
 259         case 'f':
 260                 if (arg[0] == '@')
 261                         err = append_filter_file(arg + 1);
 262                 else if (arg[0] == '!')
 263                         err = append_filter(&env.deny_filters, &env.deny_filter_cnt, arg + 1);
 264                 else
 265                         err = append_filter(&env.allow_filters, &env.allow_filter_cnt, arg);
 266                 if (err) {
 267                         fprintf(stderr, "Failed to collect program filter expressions: %d\n", err);
 268                         return err;
 269                 }
 270                 break;
 271         case ARGP_KEY_ARG:
 272                 tmp = realloc(env.filenames, (env.filename_cnt + 1) * sizeof(*env.filenames));
 273                 if (!tmp)
 274                         return -ENOMEM;
 275                 env.filenames = tmp;
 276                 env.filenames[env.filename_cnt] = strdup(arg);
 277                 if (!env.filenames[env.filename_cnt])
 278                         return -ENOMEM;
 279                 env.filename_cnt++;
 280                 break;
 281         default:
 282                 return ARGP_ERR_UNKNOWN;
 283         }
 284         return 0;
 285 }
 286
 287 static const struct argp argp = {
 288         .options = opts,
 289         .parser = parse_arg,
 290         .doc = argp_program_doc,
 291 };
 292
 293
 294 /* Adapted from perf/util/string.c */
 295 static bool glob_matches(const char *str, const char *pat)
 296 {
 297         while (*str && *pat && *pat != '*') {
 298                 if (*str != *pat)
 299                         return false;
 300                 str++;
 301                 pat++;
 302         }
 303         /* Check wild card */
 304         if (*pat == '*') {
 305                 while (*pat == '*')
 306                         pat++;
 307                 if (!*pat) /* Tail wild card matches all */
 308                         return true;
 309                 while (*str)
 310                         if (glob_matches(str++, pat))
 311                                 return true;
 312         }
 313         return !*str && !*pat;
 314 }
 315
 316 static bool is_bpf_obj_file(const char *path) {
 317         Elf64_Ehdr *ehdr;
 318         int fd, err = -EINVAL;
 319         Elf *elf = NULL;
 320
 321         fd = open(path, O_RDONLY | O_CLOEXEC);
 322         if (fd < 0)
 323                 return true; /* we'll fail later and propagate error */
 324
 325         /* ensure libelf is initialized */
 326         (void)elf_version(EV_CURRENT);
 327
 328         elf = elf_begin(fd, ELF_C_READ, NULL);
 329         if (!elf)
 330                 goto cleanup;
 331
 332         if (elf_kind(elf) != ELF_K_ELF || gelf_getclass(elf) != ELFCLASS64)
 333                 goto cleanup;
 334
 335         ehdr = elf64_getehdr(elf);
 336         /* Old LLVM set e_machine to EM_NONE */
 337         if (!ehdr || ehdr->e_type != ET_REL || (ehdr->e_machine && ehdr->e_machine != EM_BPF))
 338                 goto cleanup;
 339
 340         err = 0;
 341 cleanup:
 342         if (elf)
 343                 elf_end(elf);
 344         close(fd);
 345         return err == 0;
 346 }
 347
 348 static bool should_process_file_prog(const char *filename, const char *prog_name)
 349 {
 350         struct filter *f;
 351         int i, allow_cnt = 0;
 352
 353         for (i = 0; i < env.deny_filter_cnt; i++) {
 354                 f = &env.deny_filters[i];
 355                 if (f->kind != FILTER_NAME)
 356                         continue;
 357
 358                 if (f->any_glob && glob_matches(filename, f->any_glob))
 359                         return false;
 360                 if (f->any_glob && prog_name && glob_matches(prog_name, f->any_glob))
 361                         return false;
 362                 if (f->file_glob && glob_matches(filename, f->file_glob))
 363                         return false;
 364                 if (f->prog_glob && prog_name && glob_matches(prog_name, f->prog_glob))
 365                         return false;
 366         }
 367
 368         for (i = 0; i < env.allow_filter_cnt; i++) {
 369                 f = &env.allow_filters[i];
 370                 if (f->kind != FILTER_NAME)
 371                         continue;
 372
 373                 allow_cnt++;
 374                 if (f->any_glob) {
 375                         if (glob_matches(filename, f->any_glob))
 376                                 return true;
 377                         /* If we don't know program name yet, any_glob filter
 378                          * has to assume that current BPF object file might be
 379                          * relevant; we'll check again later on after opening
 380                          * BPF object file, at which point program name will
 381                          * be known finally.
 382                          */
 383                         if (!prog_name || glob_matches(prog_name, f->any_glob))
 384                                 return true;
 385                 } else {
 386                         if (f->file_glob && !glob_matches(filename, f->file_glob))
 387                                 continue;
 388                         if (f->prog_glob && prog_name && !glob_matches(prog_name, f->prog_glob))
 389                                 continue;
 390                         return true;
 391                 }
 392         }
 393
 394         /* if there are no file/prog name allow filters, allow all progs,
 395          * unless they are denied earlier explicitly
 396          */
 397         return allow_cnt == 0;
 398 }
 399
 400 static struct {
 401         enum operator_kind op_kind;
 402         const char *op_str;
 403 } operators[] = {
 404         /* Order of these definitions matter to avoid situations like '<'
 405          * matching part of what is actually a '<>' operator. That is,
 406          * substrings should go last.
 407          */
 408         { OP_EQ, "==" },
 409         { OP_NEQ, "!=" },
 410         { OP_NEQ, "<>" },
 411         { OP_LE, "<=" },
 412         { OP_LT, "<" },
 413         { OP_GE, ">=" },
 414         { OP_GT, ">" },
 415         { OP_EQ, "=" },
 416 };
 417
 418 static bool parse_stat_id_var(const char *name, size_t len, int *id, enum stat_variant *var);
 419
 420 static int append_filter(struct filter **filters, int *cnt, const char *str)
 421 {
 422         struct filter *f;
 423         void *tmp;
 424         const char *p;
 425         int i;
 426
 427         tmp = realloc(*filters, (*cnt + 1) * sizeof(**filters));
 428         if (!tmp)
 429                 return -ENOMEM;
 430         *filters = tmp;
 431
 432         f = &(*filters)[*cnt];
 433         memset(f, 0, sizeof(*f));
 434
 435         /* First, let's check if it's a stats filter of the following form:
 436          * <stat><op><value, where:
 437          *   - <stat> is one of supported numerical stats (verdict is also
 438          *     considered numerical, failure == 0, success == 1);
 439          *   - <op> is comparison operator (see `operators` definitions);
 440          *   - <value> is an integer (or failure/success, or false/true as
 441          *     special aliases for 0 and 1, respectively).
 442          * If the form doesn't match what user provided, we assume file/prog
 443          * glob filter.
 444          */
 445         for (i = 0; i < ARRAY_SIZE(operators); i++) {
 446                 enum stat_variant var;
 447                 int id;
 448                 long val;
 449                 const char *end = str;
 450                 const char *op_str;
 451
 452                 op_str = operators[i].op_str;
 453                 p = strstr(str, op_str);
 454                 if (!p)
 455                         continue;
 456
 457                 if (!parse_stat_id_var(str, p - str, &id, &var)) {
 458                         fprintf(stderr, "Unrecognized stat name in '%s'!\n", str);
 459                         return -EINVAL;
 460                 }
 461                 if (id >= FILE_NAME) {
 462                         fprintf(stderr, "Non-integer stat is specified in '%s'!\n", str);
 463                         return -EINVAL;
 464                 }
 465
 466                 p += strlen(op_str);
 467
 468                 if (strcasecmp(p, "true") == 0 ||
 469                     strcasecmp(p, "t") == 0 ||
 470                     strcasecmp(p, "success") == 0 ||
 471                     strcasecmp(p, "succ") == 0 ||
 472                     strcasecmp(p, "s") == 0 ||
 473                     strcasecmp(p, "match") == 0 ||
 474                     strcasecmp(p, "m") == 0) {
 475                         val = 1;
 476                 } else if (strcasecmp(p, "false") == 0 ||
 477                            strcasecmp(p, "f") == 0 ||
 478                            strcasecmp(p, "failure") == 0 ||
 479                            strcasecmp(p, "fail") == 0 ||
 480                            strcasecmp(p, "mismatch") == 0 ||
 481                            strcasecmp(p, "mis") == 0) {
 482                         val = 0;
 483                 } else {
 484                         errno = 0;
 485                         val = strtol(p, (char **)&end, 10);
 486                         if (errno || end == p || *end != '\0' ) {
 487                                 fprintf(stderr, "Invalid integer value in '%s'!\n", str);
 488                                 return -EINVAL;
 489                         }
 490                 }
 491
 492                 f->kind = FILTER_STAT;
 493                 f->stat_id = id;
 494                 f->stat_var = var;
 495                 f->op = operators[i].op_kind;
 496                 f->value = val;
 497
 498                 *cnt += 1;
 499                 return 0;
 500         }
 501
 502         /* File/prog filter can be specified either as '<glob>' or
 503          * '<file-glob>/<prog-glob>'. In the former case <glob> is applied to
 504          * both file and program names. This seems to be way more useful in
 505          * practice. If user needs full control, they can use '/<prog-glob>'
 506          * form to glob just program name, or '<file-glob>/' to glob only file
 507          * name. But usually common <glob> seems to be the most useful and
 508          * ergonomic way.
 509          */
 510         f->kind = FILTER_NAME;
 511         p = strchr(str, '/');
 512         if (!p) {
 513                 f->any_glob = strdup(str);
 514                 if (!f->any_glob)
 515                         return -ENOMEM;
 516         } else {
 517                 if (str != p) {
 518                         /* non-empty file glob */
 519                         f->file_glob = strndup(str, p - str);
 520                         if (!f->file_glob)
 521                                 return -ENOMEM;
 522                 }
 523                 if (strlen(p + 1) > 0) {
 524                         /* non-empty prog glob */
 525                         f->prog_glob = strdup(p + 1);
 526                         if (!f->prog_glob) {
 527                                 free(f->file_glob);
 528                                 f->file_glob = NULL;
 529                                 return -ENOMEM;
 530                         }
 531                 }
 532         }
 533
 534         *cnt += 1;
 535         return 0;
 536 }
 537
 538 static int append_filter_file(const char *path)
 539 {
 540         char buf[1024];
 541         FILE *f;
 542         int err = 0;
 543
 544         f = fopen(path, "r");
 545         if (!f) {
 546                 err = -errno;
 547                 fprintf(stderr, "Failed to open filters in '%s': %d\n", path, err);
 548                 return err;
 549         }
 550
 551         while (fscanf(f, " %1023[^\n]\n", buf) == 1) {
 552                 /* lines starting with # are comments, skip them */
 553                 if (buf[0] == '\0' || buf[0] == '#')
 554                         continue;
 555                 /* lines starting with ! are negative match filters */
 556                 if (buf[0] == '!')
 557                         err = append_filter(&env.deny_filters, &env.deny_filter_cnt, buf + 1);
 558                 else
 559                         err = append_filter(&env.allow_filters, &env.allow_filter_cnt, buf);
 560                 if (err)
 561                         goto cleanup;
 562         }
 563
 564 cleanup:
 565         fclose(f);
 566         return err;
 567 }
 568
 569 static const struct stat_specs default_output_spec = {
 570         .spec_cnt = 7,
 571         .ids = {
 572                 FILE_NAME, PROG_NAME, VERDICT, DURATION,
 573                 TOTAL_INSNS, TOTAL_STATES, PEAK_STATES,
 574         },
 575 };
 576
 577 static const struct stat_specs default_csv_output_spec = {
 578         .spec_cnt = 9,
 579         .ids = {
 580                 FILE_NAME, PROG_NAME, VERDICT, DURATION,
 581                 TOTAL_INSNS, TOTAL_STATES, PEAK_STATES,
 582                 MAX_STATES_PER_INSN, MARK_READ_MAX_LEN,
 583         },
 584 };
 585
 586 static const struct stat_specs default_sort_spec = {
 587         .spec_cnt = 2,
 588         .ids = {
 589                 FILE_NAME, PROG_NAME,
 590         },
 591         .asc = { true, true, },
 592 };
 593
 594 /* sorting for comparison mode to join two data sets */
 595 static const struct stat_specs join_sort_spec = {
 596         .spec_cnt = 2,
 597         .ids = {
 598                 FILE_NAME, PROG_NAME,
 599         },
 600         .asc = { true, true, },
 601 };
 602
 603 static struct stat_def {
 604         const char *header;
 605         const char *names[4];
 606         bool asc_by_default;
 607         bool left_aligned;
 608 } stat_defs[] = {
 609         [FILE_NAME] = { "File", {"file_name", "filename", "file"}, true /* asc */, true /* left */ },
 610         [PROG_NAME] = { "Program", {"prog_name", "progname", "prog"}, true /* asc */, true /* left */ },
 611         [VERDICT] = { "Verdict", {"verdict"}, true /* asc: failure, success */, true /* left */ },
 612         [DURATION] = { "Duration (us)", {"duration", "dur"}, },
 613         [TOTAL_INSNS] = { "Insns", {"total_insns", "insns"}, },
 614         [TOTAL_STATES] = { "States", {"total_states", "states"}, },
 615         [PEAK_STATES] = { "Peak states", {"peak_states"}, },
 616         [MAX_STATES_PER_INSN] = { "Max states per insn", {"max_states_per_insn"}, },
 617         [MARK_READ_MAX_LEN] = { "Max mark read length", {"max_mark_read_len", "mark_read"}, },
 618 };
 619
 620 static bool parse_stat_id_var(const char *name, size_t len, int *id, enum stat_variant *var)
 621 {
 622         static const char *var_sfxs[] = {
 623                 [VARIANT_A] = "_a",
 624                 [VARIANT_B] = "_b",
 625                 [VARIANT_DIFF] = "_diff",
 626                 [VARIANT_PCT] = "_pct",
 627         };
 628         int i, j, k;
 629
 630         for (i = 0; i < ARRAY_SIZE(stat_defs); i++) {
 631                 struct stat_def *def = &stat_defs[i];
 632                 size_t alias_len, sfx_len;
 633                 const char *alias;
 634
 635                 for (j = 0; j < ARRAY_SIZE(stat_defs[i].names); j++) {
 636                         alias = def->names[j];
 637                         if (!alias)
 638                                 continue;
 639
 640                         alias_len = strlen(alias);
 641                         if (strncmp(name, alias, alias_len) != 0)
 642                                 continue;
 643
 644                         if (alias_len == len) {
 645                                 /* If no variant suffix is specified, we
 646                                  * assume control group (just in case we are
 647                                  * in comparison mode. Variant is ignored in
 648                                  * non-comparison mode.
 649                                  */
 650                                 *var = VARIANT_B;
 651                                 *id = i;
 652                                 return true;
 653                         }
 654
 655                         for (k = 0; k < ARRAY_SIZE(var_sfxs); k++) {
 656                                 sfx_len = strlen(var_sfxs[k]);
 657                                 if (alias_len + sfx_len != len)
 658                                         continue;
 659
 660                                 if (strncmp(name + alias_len, var_sfxs[k], sfx_len) == 0) {
 661                                         *var = (enum stat_variant)k;
 662                                         *id = i;
 663                                         return true;
 664                                 }
 665                         }
 666                 }
 667         }
 668
 669         return false;
 670 }
 671
 672 static bool is_asc_sym(char c)
 673 {
 674         return c == '^';
 675 }
 676
 677 static bool is_desc_sym(char c)
 678 {
 679         return c == 'v' || c == 'V' || c == '.' || c == '!' || c == '_';
 680 }
 681
 682 static int parse_stat(const char *stat_name, struct stat_specs *specs)
 683 {
 684         int id;
 685         bool has_order = false, is_asc = false;
 686         size_t len = strlen(stat_name);
 687         enum stat_variant var;
 688
 689         if (specs->spec_cnt >= ARRAY_SIZE(specs->ids)) {
 690                 fprintf(stderr, "Can't specify more than %zd stats\n", ARRAY_SIZE(specs->ids));
 691                 return -E2BIG;
 692         }
 693
 694         if (len > 1 && (is_asc_sym(stat_name[len - 1]) || is_desc_sym(stat_name[len - 1]))) {
 695                 has_order = true;
 696                 is_asc = is_asc_sym(stat_name[len - 1]);
 697                 len -= 1;
 698         }
 699
 700         if (!parse_stat_id_var(stat_name, len, &id, &var)) {
 701                 fprintf(stderr, "Unrecognized stat name '%s'\n", stat_name);
 702                 return -ESRCH;
 703         }
 704
 705         specs->ids[specs->spec_cnt] = id;
 706         specs->variants[specs->spec_cnt] = var;
 707         specs->asc[specs->spec_cnt] = has_order ? is_asc : stat_defs[id].asc_by_default;
 708         specs->spec_cnt++;
 709
 710         return 0;
 711 }
 712
 713 static int parse_stats(const char *stats_str, struct stat_specs *specs)
 714 {
 715         char *input, *state = NULL, *next;
 716         int err;
 717
 718         input = strdup(stats_str);
 719         if (!input)
 720                 return -ENOMEM;
 721
 722         while ((next = strtok_r(state ? NULL : input, ",", &state))) {
 723                 err = parse_stat(next, specs);
 724                 if (err)
 725                         return err;
 726         }
 727
 728         return 0;
 729 }
 730
 731 static void free_verif_stats(struct verif_stats *stats, size_t stat_cnt)
 732 {
 733         int i;
 734
 735         if (!stats)
 736                 return;
 737
 738         for (i = 0; i < stat_cnt; i++) {
 739                 free(stats[i].file_name);
 740                 free(stats[i].prog_name);
 741         }
 742         free(stats);
 743 }
 744
 745 static char verif_log_buf[64 * 1024];
 746
 747 #define MAX_PARSED_LOG_LINES 100
 748
 749 static int parse_verif_log(char * const buf, size_t buf_sz, struct verif_stats *s)
 750 {
 751         const char *cur;
 752         int pos, lines;
 753
 754         buf[buf_sz - 1] = '\0';
 755
 756         for (pos = strlen(buf) - 1, lines = 0; pos >= 0 && lines < MAX_PARSED_LOG_LINES; lines++) {
 757                 /* find previous endline or otherwise take the start of log buf */
 758                 for (cur = &buf[pos]; cur > buf && cur[0] != '\n'; cur--, pos--) {
 759                 }
 760                 /* next time start from end of previous line (or pos goes to <0) */
 761                 pos--;
 762                 /* if we found endline, point right after endline symbol;
 763                  * otherwise, stay at the beginning of log buf
 764                  */
 765                 if (cur[0] == '\n')
 766                         cur++;
 767
 768                 if (1 == sscanf(cur, "verification time %ld usec\n", &s->stats[DURATION]))
 769                         continue;
 770                 if (6 == sscanf(cur, "processed %ld insns (limit %*d) max_states_per_insn %ld total_states %ld peak_states %ld mark_read %ld",
 771                                 &s->stats[TOTAL_INSNS],
 772                                 &s->stats[MAX_STATES_PER_INSN],
 773                                 &s->stats[TOTAL_STATES],
 774                                 &s->stats[PEAK_STATES],
 775                                 &s->stats[MARK_READ_MAX_LEN]))
 776                         continue;
 777         }
 778
 779         return 0;
 780 }
 781
 782 static int guess_prog_type_by_ctx_name(const char *ctx_name,
 783                                        enum bpf_prog_type *prog_type,
 784                                        enum bpf_attach_type *attach_type)
 785 {
 786         /* We need to guess program type based on its declared context type.
 787          * This guess can't be perfect as many different program types might
 788          * share the same context type.  So we can only hope to reasonably
 789          * well guess this and get lucky.
 790          *
 791          * Just in case, we support both UAPI-side type names and
 792          * kernel-internal names.
 793          */
 794         static struct {
 795                 const char *uapi_name;
 796                 const char *kern_name;
 797                 enum bpf_prog_type prog_type;
 798                 enum bpf_attach_type attach_type;
 799         } ctx_map[] = {
 800                 /* __sk_buff is most ambiguous, for now we assume cgroup_skb */
 801                 { "__sk_buff", "sk_buff", BPF_PROG_TYPE_SCHED_CLS },
 802                 { "bpf_sock", "sock", BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET4_POST_BIND },
 803                 { "bpf_sock_addr", "bpf_sock_addr_kern",  BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_BIND },
 804                 { "bpf_sock_ops", "bpf_sock_ops_kern", BPF_PROG_TYPE_SOCK_OPS, BPF_CGROUP_SOCK_OPS },
 805                 { "sk_msg_md", "sk_msg", BPF_PROG_TYPE_SK_MSG, BPF_SK_MSG_VERDICT },
 806                 { "bpf_cgroup_dev_ctx", "bpf_cgroup_dev_ctx", BPF_PROG_TYPE_CGROUP_DEVICE, BPF_CGROUP_DEVICE },
 807                 { "bpf_sysctl", "bpf_sysctl_kern", BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_CGROUP_SYSCTL },
 808                 { "bpf_sockopt", "bpf_sockopt_kern", BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_SETSOCKOPT },
 809                 { "sk_reuseport_md", "sk_reuseport_kern", BPF_PROG_TYPE_SK_REUSEPORT, BPF_SK_REUSEPORT_SELECT_OR_MIGRATE },
 810                 { "bpf_sk_lookup", "bpf_sk_lookup_kern", BPF_PROG_TYPE_SK_LOOKUP, BPF_SK_LOOKUP },
 811                 { "xdp_md", "xdp_buff", BPF_PROG_TYPE_XDP, BPF_XDP },
 812                 /* tracing types with no expected attach type */
 813                 { "bpf_user_pt_regs_t", "pt_regs", BPF_PROG_TYPE_KPROBE },
 814                 { "bpf_perf_event_data", "bpf_perf_event_data_kern", BPF_PROG_TYPE_PERF_EVENT },
 815                 /* raw_tp programs use u64[] from kernel side, we don't want
 816                  * to match on that, probably; so NULL for kern-side type
 817                  */
 818                 { "bpf_raw_tracepoint_args", NULL, BPF_PROG_TYPE_RAW_TRACEPOINT },
 819         };
 820         int i;
 821
 822         if (!ctx_name)
 823                 return -EINVAL;
 824
 825         for (i = 0; i < ARRAY_SIZE(ctx_map); i++) {
 826                 if (strcmp(ctx_map[i].uapi_name, ctx_name) == 0 ||
 827                     (ctx_map[i].kern_name && strcmp(ctx_map[i].kern_name, ctx_name) == 0)) {
 828                         *prog_type = ctx_map[i].prog_type;
 829                         *attach_type = ctx_map[i].attach_type;
 830                         return 0;
 831                 }
 832         }
 833
 834         return -ESRCH;
 835 }
 836
 837 static void fixup_obj(struct bpf_object *obj, struct bpf_program *prog, const char *filename)
 838 {
 839         struct bpf_map *map;
 840
 841         bpf_object__for_each_map(map, obj) {
 842                 /* disable pinning */
 843                 bpf_map__set_pin_path(map, NULL);
 844
 845                 /* fix up map size, if necessary */
 846                 switch (bpf_map__type(map)) {
 847                 case BPF_MAP_TYPE_SK_STORAGE:
 848                 case BPF_MAP_TYPE_TASK_STORAGE:
 849                 case BPF_MAP_TYPE_INODE_STORAGE:
 850                 case BPF_MAP_TYPE_CGROUP_STORAGE:
 851                         break;
 852                 default:
 853                         if (bpf_map__max_entries(map) == 0)
 854                                 bpf_map__set_max_entries(map, 1);
 855                 }
 856         }
 857
 858         /* SEC(freplace) programs can't be loaded with veristat as is,
 859          * but we can try guessing their target program's expected type by
 860          * looking at the type of program's first argument and substituting
 861          * corresponding program type
 862          */
 863         if (bpf_program__type(prog) == BPF_PROG_TYPE_EXT) {
 864                 const struct btf *btf = bpf_object__btf(obj);
 865                 const char *prog_name = bpf_program__name(prog);
 866                 enum bpf_prog_type prog_type;
 867                 enum bpf_attach_type attach_type;
 868                 const struct btf_type *t;
 869                 const char *ctx_name;
 870                 int id;
 871
 872                 if (!btf)
 873                         goto skip_freplace_fixup;
 874
 875                 id = btf__find_by_name_kind(btf, prog_name, BTF_KIND_FUNC);
 876                 t = btf__type_by_id(btf, id);
 877                 t = btf__type_by_id(btf, t->type);
 878                 if (!btf_is_func_proto(t) || btf_vlen(t) != 1)
 879                         goto skip_freplace_fixup;
 880
 881                 /* context argument is a pointer to a struct/typedef */
 882                 t = btf__type_by_id(btf, btf_params(t)[0].type);
 883                 while (t && btf_is_mod(t))
 884                         t = btf__type_by_id(btf, t->type);
 885                 if (!t || !btf_is_ptr(t))
 886                         goto skip_freplace_fixup;
 887                 t = btf__type_by_id(btf, t->type);
 888                 while (t && btf_is_mod(t))
 889                         t = btf__type_by_id(btf, t->type);
 890                 if (!t)
 891                         goto skip_freplace_fixup;
 892
 893                 ctx_name = btf__name_by_offset(btf, t->name_off);
 894
 895                 if (guess_prog_type_by_ctx_name(ctx_name, &prog_type, &attach_type) == 0) {
 896                         bpf_program__set_type(prog, prog_type);
 897                         bpf_program__set_expected_attach_type(prog, attach_type);
 898
 899                         if (!env.quiet) {
 900                                 printf("Using guessed program type '%s' for %s/%s...\n",
 901                                         libbpf_bpf_prog_type_str(prog_type),
 902                                         filename, prog_name);
 903                         }
 904                 } else {
 905                         if (!env.quiet) {
 906                                 printf("Failed to guess program type for freplace program with context type name '%s' for %s/%s. Consider using canonical type names to help veristat...\n",
 907                                         ctx_name, filename, prog_name);
 908                         }
 909                 }
 910         }
 911 skip_freplace_fixup:
 912         return;
 913 }
 914
 915 static int process_prog(const char *filename, struct bpf_object *obj, struct bpf_program *prog)
 916 {
 917         const char *prog_name = bpf_program__name(prog);
 918         const char *base_filename = basename(filename);
 919         size_t buf_sz = sizeof(verif_log_buf);
 920         char *buf = verif_log_buf;
 921         struct verif_stats *stats;
 922         int err = 0;
 923         void *tmp;
 924
 925         if (!should_process_file_prog(base_filename, bpf_program__name(prog))) {
 926                 env.progs_skipped++;
 927                 return 0;
 928         }
 929
 930         tmp = realloc(env.prog_stats, (env.prog_stat_cnt + 1) * sizeof(*env.prog_stats));
 931         if (!tmp)
 932                 return -ENOMEM;
 933         env.prog_stats = tmp;
 934         stats = &env.prog_stats[env.prog_stat_cnt++];
 935         memset(stats, 0, sizeof(*stats));
 936
 937         if (env.verbose) {
 938                 buf_sz = 16 * 1024 * 1024;
 939                 buf = malloc(buf_sz);
 940                 if (!buf)
 941                         return -ENOMEM;
 942                 bpf_program__set_log_buf(prog, buf, buf_sz);
 943                 bpf_program__set_log_level(prog, env.log_level | 4); /* stats + log */
 944         } else {
 945                 bpf_program__set_log_buf(prog, buf, buf_sz);
 946                 bpf_program__set_log_level(prog, 4); /* only verifier stats */
 947         }
 948         verif_log_buf[0] = '\0';
 949
 950         /* increase chances of successful BPF object loading */
 951         fixup_obj(obj, prog, base_filename);
 952
 953         err = bpf_object__load(obj);
 954         env.progs_processed++;
 955
 956         stats->file_name = strdup(base_filename);
 957         stats->prog_name = strdup(bpf_program__name(prog));
 958         stats->stats[VERDICT] = err == 0; /* 1 - success, 0 - failure */
 959         parse_verif_log(buf, buf_sz, stats);
 960
 961         if (env.verbose) {
 962                 printf("PROCESSING %s/%s, DURATION US: %ld, VERDICT: %s, VERIFIER LOG:\n%s\n",
 963                        filename, prog_name, stats->stats[DURATION],
 964                        err ? "failure" : "success", buf);
 965         }
 966
 967         if (verif_log_buf != buf)
 968                 free(buf);
 969
 970         return 0;
 971 };
 972
 973 static int process_obj(const char *filename)
 974 {
 975         struct bpf_object *obj = NULL, *tobj;
 976         struct bpf_program *prog, *tprog, *lprog;
 977         libbpf_print_fn_t old_libbpf_print_fn;
 978         LIBBPF_OPTS(bpf_object_open_opts, opts);
 979         int err = 0, prog_cnt = 0;
 980
 981         if (!should_process_file_prog(basename(filename), NULL)) {
 982                 if (env.verbose)
 983                         printf("Skipping '%s' due to filters...\n", filename);
 984                 env.files_skipped++;
 985                 return 0;
 986         }
 987         if (!is_bpf_obj_file(filename)) {
 988                 if (env.verbose)
 989                         printf("Skipping '%s' as it's not a BPF object file...\n", filename);
 990                 env.files_skipped++;
 991                 return 0;
 992         }
 993
 994         if (!env.quiet && env.out_fmt == RESFMT_TABLE)
 995                 printf("Processing '%s'...\n", basename(filename));
 996
 997         old_libbpf_print_fn = libbpf_set_print(libbpf_print_fn);
 998         obj = bpf_object__open_file(filename, &opts);
 999         if (!obj) {
1000                 /* if libbpf can't open BPF object file, it could be because
1001                  * that BPF object file is incomplete and has to be statically
1002                  * linked into a final BPF object file; instead of bailing
1003                  * out, report it into stderr, mark it as skipped, and
1004                  * proceed
1005                  */
1006                 fprintf(stderr, "Failed to open '%s': %d\n", filename, -errno);
1007                 env.files_skipped++;
1008                 err = 0;
1009                 goto cleanup;
1010         }
1011
1012         env.files_processed++;
1013
1014         bpf_object__for_each_program(prog, obj) {
1015                 prog_cnt++;
1016         }
1017
1018         if (prog_cnt == 1) {
1019                 prog = bpf_object__next_program(obj, NULL);
1020                 bpf_program__set_autoload(prog, true);
1021                 process_prog(filename, obj, prog);
1022                 goto cleanup;
1023         }
1024
1025         bpf_object__for_each_program(prog, obj) {
1026                 const char *prog_name = bpf_program__name(prog);
1027
1028                 tobj = bpf_object__open_file(filename, &opts);
1029                 if (!tobj) {
1030                         err = -errno;
1031                         fprintf(stderr, "Failed to open '%s': %d\n", filename, err);
1032                         goto cleanup;
1033                 }
1034
1035                 bpf_object__for_each_program(tprog, tobj) {
1036                         const char *tprog_name = bpf_program__name(tprog);
1037
1038                         if (strcmp(prog_name, tprog_name) == 0) {
1039                                 bpf_program__set_autoload(tprog, true);
1040                                 lprog = tprog;
1041                         } else {
1042                                 bpf_program__set_autoload(tprog, false);
1043                         }
1044                 }
1045
1046                 process_prog(filename, tobj, lprog);
1047                 bpf_object__close(tobj);
1048         }
1049
1050 cleanup:
1051         bpf_object__close(obj);
1052         libbpf_set_print(old_libbpf_print_fn);
1053         return err;
1054 }
1055
1056 static int cmp_stat(const struct verif_stats *s1, const struct verif_stats *s2,
1057                     enum stat_id id, bool asc)
1058 {
1059         int cmp = 0;
1060
1061         switch (id) {
1062         case FILE_NAME:
1063                 cmp = strcmp(s1->file_name, s2->file_name);
1064                 break;
1065         case PROG_NAME:
1066                 cmp = strcmp(s1->prog_name, s2->prog_name);
1067                 break;
1068         case VERDICT:
1069         case DURATION:
1070         case TOTAL_INSNS:
1071         case TOTAL_STATES:
1072         case PEAK_STATES:
1073         case MAX_STATES_PER_INSN:
1074         case MARK_READ_MAX_LEN: {
1075                 long v1 = s1->stats[id];
1076                 long v2 = s2->stats[id];
1077
1078                 if (v1 != v2)
1079                         cmp = v1 < v2 ? -1 : 1;
1080                 break;
1081         }
1082         default:
1083                 fprintf(stderr, "Unrecognized stat #%d\n", id);
1084                 exit(1);
1085         }
1086
1087         return asc ? cmp : -cmp;
1088 }
1089
1090 static int cmp_prog_stats(const void *v1, const void *v2)
1091 {
1092         const struct verif_stats *s1 = v1, *s2 = v2;
1093         int i, cmp;
1094
1095         for (i = 0; i < env.sort_spec.spec_cnt; i++) {
1096                 cmp = cmp_stat(s1, s2, env.sort_spec.ids[i], env.sort_spec.asc[i]);
1097                 if (cmp != 0)
1098                         return cmp;
1099         }
1100
1101         /* always disambiguate with file+prog, which are unique */
1102         cmp = strcmp(s1->file_name, s2->file_name);
1103         if (cmp != 0)
1104                 return cmp;
1105         return strcmp(s1->prog_name, s2->prog_name);
1106 }
1107
1108 static void fetch_join_stat_value(const struct verif_stats_join *s,
1109                                   enum stat_id id, enum stat_variant var,
1110                                   const char **str_val,
1111                                   double *num_val)
1112 {
1113         long v1, v2;
1114
1115         if (id == FILE_NAME) {
1116                 *str_val = s->file_name;
1117                 return;
1118         }
1119         if (id == PROG_NAME) {
1120                 *str_val = s->prog_name;
1121                 return;
1122         }
1123
1124         v1 = s->stats_a ? s->stats_a->stats[id] : 0;
1125         v2 = s->stats_b ? s->stats_b->stats[id] : 0;
1126
1127         switch (var) {
1128         case VARIANT_A:
1129                 if (!s->stats_a)
1130                         *num_val = -DBL_MAX;
1131                 else
1132                         *num_val = s->stats_a->stats[id];
1133                 return;
1134         case VARIANT_B:
1135                 if (!s->stats_b)
1136                         *num_val = -DBL_MAX;
1137                 else
1138                         *num_val = s->stats_b->stats[id];
1139                 return;
1140         case VARIANT_DIFF:
1141                 if (!s->stats_a || !s->stats_b)
1142                         *num_val = -DBL_MAX;
1143                 else if (id == VERDICT)
1144                         *num_val = v1 == v2 ? 1.0 /* MATCH */ : 0.0 /* MISMATCH */;
1145                 else
1146                         *num_val = (double)(v2 - v1);
1147                 return;
1148         case VARIANT_PCT:
1149                 if (!s->stats_a || !s->stats_b) {
1150                         *num_val = -DBL_MAX;
1151                 } else if (v1 == 0) {
1152                         if (v1 == v2)
1153                                 *num_val = 0.0;
1154                         else
1155                                 *num_val = v2 < v1 ? -100.0 : 100.0;
1156                 } else {
1157                          *num_val = (v2 - v1) * 100.0 / v1;
1158                 }
1159                 return;
1160         }
1161 }
1162
1163 static int cmp_join_stat(const struct verif_stats_join *s1,
1164                          const struct verif_stats_join *s2,
1165                          enum stat_id id, enum stat_variant var, bool asc)
1166 {
1167         const char *str1 = NULL, *str2 = NULL;
1168         double v1, v2;
1169         int cmp = 0;
1170
1171         fetch_join_stat_value(s1, id, var, &str1, &v1);
1172         fetch_join_stat_value(s2, id, var, &str2, &v2);
1173
1174         if (str1)
1175                 cmp = strcmp(str1, str2);
1176         else if (v1 != v2)
1177                 cmp = v1 < v2 ? -1 : 1;
1178
1179         return asc ? cmp : -cmp;
1180 }
1181
1182 static int cmp_join_stats(const void *v1, const void *v2)
1183 {
1184         const struct verif_stats_join *s1 = v1, *s2 = v2;
1185         int i, cmp;
1186
1187         for (i = 0; i < env.sort_spec.spec_cnt; i++) {
1188                 cmp = cmp_join_stat(s1, s2,
1189                                     env.sort_spec.ids[i],
1190                                     env.sort_spec.variants[i],
1191                                     env.sort_spec.asc[i]);
1192                 if (cmp != 0)
1193                         return cmp;
1194         }
1195
1196         /* always disambiguate with file+prog, which are unique */
1197         cmp = strcmp(s1->file_name, s2->file_name);
1198         if (cmp != 0)
1199                 return cmp;
1200         return strcmp(s1->prog_name, s2->prog_name);
1201 }
1202
1203 #define HEADER_CHAR '-'
1204 #define COLUMN_SEP "  "
1205
1206 static void output_header_underlines(void)
1207 {
1208         int i, j, len;
1209
1210         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1211                 len = env.output_spec.lens[i];
1212
1213                 printf("%s", i == 0 ? "" : COLUMN_SEP);
1214                 for (j = 0; j < len; j++)
1215                         printf("%c", HEADER_CHAR);
1216         }
1217         printf("\n");
1218 }
1219
1220 static void output_headers(enum resfmt fmt)
1221 {
1222         const char *fmt_str;
1223         int i, len;
1224
1225         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1226                 int id = env.output_spec.ids[i];
1227                 int *max_len = &env.output_spec.lens[i];
1228
1229                 switch (fmt) {
1230                 case RESFMT_TABLE_CALCLEN:
1231                         len = snprintf(NULL, 0, "%s", stat_defs[id].header);
1232                         if (len > *max_len)
1233                                 *max_len = len;
1234                         break;
1235                 case RESFMT_TABLE:
1236                         fmt_str = stat_defs[id].left_aligned ? "%s%-*s" : "%s%*s";
1237                         printf(fmt_str, i == 0 ? "" : COLUMN_SEP,  *max_len, stat_defs[id].header);
1238                         if (i == env.output_spec.spec_cnt - 1)
1239                                 printf("\n");
1240                         break;
1241                 case RESFMT_CSV:
1242                         printf("%s%s", i == 0 ? "" : ",", stat_defs[id].names[0]);
1243                         if (i == env.output_spec.spec_cnt - 1)
1244                                 printf("\n");
1245                         break;
1246                 }
1247         }
1248
1249         if (fmt == RESFMT_TABLE)
1250                 output_header_underlines();
1251 }
1252
1253 static void prepare_value(const struct verif_stats *s, enum stat_id id,
1254                           const char **str, long *val)
1255 {
1256         switch (id) {
1257         case FILE_NAME:
1258                 *str = s ? s->file_name : "N/A";
1259                 break;
1260         case PROG_NAME:
1261                 *str = s ? s->prog_name : "N/A";
1262                 break;
1263         case VERDICT:
1264                 if (!s)
1265                         *str = "N/A";
1266                 else
1267                         *str = s->stats[VERDICT] ? "success" : "failure";
1268                 break;
1269         case DURATION:
1270         case TOTAL_INSNS:
1271         case TOTAL_STATES:
1272         case PEAK_STATES:
1273         case MAX_STATES_PER_INSN:
1274         case MARK_READ_MAX_LEN:
1275                 *val = s ? s->stats[id] : 0;
1276                 break;
1277         default:
1278                 fprintf(stderr, "Unrecognized stat #%d\n", id);
1279                 exit(1);
1280         }
1281 }
1282
1283 static void output_stats(const struct verif_stats *s, enum resfmt fmt, bool last)
1284 {
1285         int i;
1286
1287         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1288                 int id = env.output_spec.ids[i];
1289                 int *max_len = &env.output_spec.lens[i], len;
1290                 const char *str = NULL;
1291                 long val = 0;
1292
1293                 prepare_value(s, id, &str, &val);
1294
1295                 switch (fmt) {
1296                 case RESFMT_TABLE_CALCLEN:
1297                         if (str)
1298                                 len = snprintf(NULL, 0, "%s", str);
1299                         else
1300                                 len = snprintf(NULL, 0, "%ld", val);
1301                         if (len > *max_len)
1302                                 *max_len = len;
1303                         break;
1304                 case RESFMT_TABLE:
1305                         if (str)
1306                                 printf("%s%-*s", i == 0 ? "" : COLUMN_SEP, *max_len, str);
1307                         else
1308                                 printf("%s%*ld", i == 0 ? "" : COLUMN_SEP,  *max_len, val);
1309                         if (i == env.output_spec.spec_cnt - 1)
1310                                 printf("\n");
1311                         break;
1312                 case RESFMT_CSV:
1313                         if (str)
1314                                 printf("%s%s", i == 0 ? "" : ",", str);
1315                         else
1316                                 printf("%s%ld", i == 0 ? "" : ",", val);
1317                         if (i == env.output_spec.spec_cnt - 1)
1318                                 printf("\n");
1319                         break;
1320                 }
1321         }
1322
1323         if (last && fmt == RESFMT_TABLE) {
1324                 output_header_underlines();
1325                 printf("Done. Processed %d files, %d programs. Skipped %d files, %d programs.\n",
1326                        env.files_processed, env.files_skipped, env.progs_processed, env.progs_skipped);
1327         }
1328 }
1329
1330 static int parse_stat_value(const char *str, enum stat_id id, struct verif_stats *st)
1331 {
1332         switch (id) {
1333         case FILE_NAME:
1334                 st->file_name = strdup(str);
1335                 if (!st->file_name)
1336                         return -ENOMEM;
1337                 break;
1338         case PROG_NAME:
1339                 st->prog_name = strdup(str);
1340                 if (!st->prog_name)
1341                         return -ENOMEM;
1342                 break;
1343         case VERDICT:
1344                 if (strcmp(str, "success") == 0) {
1345                         st->stats[VERDICT] = true;
1346                 } else if (strcmp(str, "failure") == 0) {
1347                         st->stats[VERDICT] = false;
1348                 } else {
1349                         fprintf(stderr, "Unrecognized verification verdict '%s'\n", str);
1350                         return -EINVAL;
1351                 }
1352                 break;
1353         case DURATION:
1354         case TOTAL_INSNS:
1355         case TOTAL_STATES:
1356         case PEAK_STATES:
1357         case MAX_STATES_PER_INSN:
1358         case MARK_READ_MAX_LEN: {
1359                 long val;
1360                 int err, n;
1361
1362                 if (sscanf(str, "%ld %n", &val, &n) != 1 || n != strlen(str)) {
1363                         err = -errno;
1364                         fprintf(stderr, "Failed to parse '%s' as integer\n", str);
1365                         return err;
1366                 }
1367
1368                 st->stats[id] = val;
1369                 break;
1370         }
1371         default:
1372                 fprintf(stderr, "Unrecognized stat #%d\n", id);
1373                 return -EINVAL;
1374         }
1375         return 0;
1376 }
1377
1378 static int parse_stats_csv(const char *filename, struct stat_specs *specs,
1379                            struct verif_stats **statsp, int *stat_cntp)
1380 {
1381         char line[4096];
1382         FILE *f;
1383         int err = 0;
1384         bool header = true;
1385
1386         f = fopen(filename, "r");
1387         if (!f) {
1388                 err = -errno;
1389                 fprintf(stderr, "Failed to open '%s': %d\n", filename, err);
1390                 return err;
1391         }
1392
1393         *stat_cntp = 0;
1394
1395         while (fgets(line, sizeof(line), f)) {
1396                 char *input = line, *state = NULL, *next;
1397                 struct verif_stats *st = NULL;
1398                 int col = 0;
1399
1400                 if (!header) {
1401                         void *tmp;
1402
1403                         tmp = realloc(*statsp, (*stat_cntp + 1) * sizeof(**statsp));
1404                         if (!tmp) {
1405                                 err = -ENOMEM;
1406                                 goto cleanup;
1407                         }
1408                         *statsp = tmp;
1409
1410                         st = &(*statsp)[*stat_cntp];
1411                         memset(st, 0, sizeof(*st));
1412
1413                         *stat_cntp += 1;
1414                 }
1415
1416                 while ((next = strtok_r(state ? NULL : input, ",\n", &state))) {
1417                         if (header) {
1418                                 /* for the first line, set up spec stats */
1419                                 err = parse_stat(next, specs);
1420                                 if (err)
1421                                         goto cleanup;
1422                                 continue;
1423                         }
1424
1425                         /* for all other lines, parse values based on spec */
1426                         if (col >= specs->spec_cnt) {
1427                                 fprintf(stderr, "Found extraneous column #%d in row #%d of '%s'\n",
1428                                         col, *stat_cntp, filename);
1429                                 err = -EINVAL;
1430                                 goto cleanup;
1431                         }
1432                         err = parse_stat_value(next, specs->ids[col], st);
1433                         if (err)
1434                                 goto cleanup;
1435                         col++;
1436                 }
1437
1438                 if (header) {
1439                         header = false;
1440                         continue;
1441                 }
1442
1443                 if (col < specs->spec_cnt) {
1444                         fprintf(stderr, "Not enough columns in row #%d in '%s'\n",
1445                                 *stat_cntp, filename);
1446                         err = -EINVAL;
1447                         goto cleanup;
1448                 }
1449
1450                 if (!st->file_name || !st->prog_name) {
1451                         fprintf(stderr, "Row #%d in '%s' is missing file and/or program name\n",
1452                                 *stat_cntp, filename);
1453                         err = -EINVAL;
1454                         goto cleanup;
1455                 }
1456
1457                 /* in comparison mode we can only check filters after we
1458                  * parsed entire line; if row should be ignored we pretend we
1459                  * never parsed it
1460                  */
1461                 if (!should_process_file_prog(st->file_name, st->prog_name)) {
1462                         free(st->file_name);
1463                         free(st->prog_name);
1464                         *stat_cntp -= 1;
1465                 }
1466         }
1467
1468         if (!feof(f)) {
1469                 err = -errno;
1470                 fprintf(stderr, "Failed I/O for '%s': %d\n", filename, err);
1471         }
1472
1473 cleanup:
1474         fclose(f);
1475         return err;
1476 }
1477
1478 /* empty/zero stats for mismatched rows */
1479 static const struct verif_stats fallback_stats = { .file_name = "", .prog_name = "" };
1480
1481 static bool is_key_stat(enum stat_id id)
1482 {
1483         return id == FILE_NAME || id == PROG_NAME;
1484 }
1485
1486 static void output_comp_header_underlines(void)
1487 {
1488         int i, j, k;
1489
1490         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1491                 int id = env.output_spec.ids[i];
1492                 int max_j = is_key_stat(id) ? 1 : 3;
1493
1494                 for (j = 0; j < max_j; j++) {
1495                         int len = env.output_spec.lens[3 * i + j];
1496
1497                         printf("%s", i + j == 0 ? "" : COLUMN_SEP);
1498
1499                         for (k = 0; k < len; k++)
1500                                 printf("%c", HEADER_CHAR);
1501                 }
1502         }
1503         printf("\n");
1504 }
1505
1506 static void output_comp_headers(enum resfmt fmt)
1507 {
1508         static const char *table_sfxs[3] = {" (A)", " (B)", " (DIFF)"};
1509         static const char *name_sfxs[3] = {"_base", "_comp", "_diff"};
1510         int i, j, len;
1511
1512         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1513                 int id = env.output_spec.ids[i];
1514                 /* key stats don't have A/B/DIFF columns, they are common for both data sets */
1515                 int max_j = is_key_stat(id) ? 1 : 3;
1516
1517                 for (j = 0; j < max_j; j++) {
1518                         int *max_len = &env.output_spec.lens[3 * i + j];
1519                         bool last = (i == env.output_spec.spec_cnt - 1) && (j == max_j - 1);
1520                         const char *sfx;
1521
1522                         switch (fmt) {
1523                         case RESFMT_TABLE_CALCLEN:
1524                                 sfx = is_key_stat(id) ? "" : table_sfxs[j];
1525                                 len = snprintf(NULL, 0, "%s%s", stat_defs[id].header, sfx);
1526                                 if (len > *max_len)
1527                                         *max_len = len;
1528                                 break;
1529                         case RESFMT_TABLE:
1530                                 sfx = is_key_stat(id) ? "" : table_sfxs[j];
1531                                 printf("%s%-*s%s", i + j == 0 ? "" : COLUMN_SEP,
1532                                        *max_len - (int)strlen(sfx), stat_defs[id].header, sfx);
1533                                 if (last)
1534                                         printf("\n");
1535                                 break;
1536                         case RESFMT_CSV:
1537                                 sfx = is_key_stat(id) ? "" : name_sfxs[j];
1538                                 printf("%s%s%s", i + j == 0 ? "" : ",", stat_defs[id].names[0], sfx);
1539                                 if (last)
1540                                         printf("\n");
1541                                 break;
1542                         }
1543                 }
1544         }
1545
1546         if (fmt == RESFMT_TABLE)
1547                 output_comp_header_underlines();
1548 }
1549
1550 static void output_comp_stats(const struct verif_stats_join *join_stats,
1551                               enum resfmt fmt, bool last)
1552 {
1553         const struct verif_stats *base = join_stats->stats_a;
1554         const struct verif_stats *comp = join_stats->stats_b;
1555         char base_buf[1024] = {}, comp_buf[1024] = {}, diff_buf[1024] = {};
1556         int i;
1557
1558         for (i = 0; i < env.output_spec.spec_cnt; i++) {
1559                 int id = env.output_spec.ids[i], len;
1560                 int *max_len_base = &env.output_spec.lens[3 * i + 0];
1561                 int *max_len_comp = &env.output_spec.lens[3 * i + 1];
1562                 int *max_len_diff = &env.output_spec.lens[3 * i + 2];
1563                 const char *base_str = NULL, *comp_str = NULL;
1564                 long base_val = 0, comp_val = 0, diff_val = 0;
1565
1566                 prepare_value(base, id, &base_str, &base_val);
1567                 prepare_value(comp, id, &comp_str, &comp_val);
1568
1569                 /* normalize all the outputs to be in string buffers for simplicity */
1570                 if (is_key_stat(id)) {
1571                         /* key stats (file and program name) are always strings */
1572                         if (base)
1573                                 snprintf(base_buf, sizeof(base_buf), "%s", base_str);
1574                         else
1575                                 snprintf(base_buf, sizeof(base_buf), "%s", comp_str);
1576                 } else if (base_str) {
1577                         snprintf(base_buf, sizeof(base_buf), "%s", base_str);
1578                         snprintf(comp_buf, sizeof(comp_buf), "%s", comp_str);
1579                         if (!base || !comp)
1580                                 snprintf(diff_buf, sizeof(diff_buf), "%s", "N/A");
1581                         else if (strcmp(base_str, comp_str) == 0)
1582                                 snprintf(diff_buf, sizeof(diff_buf), "%s", "MATCH");
1583                         else
1584                                 snprintf(diff_buf, sizeof(diff_buf), "%s", "MISMATCH");
1585                 } else {
1586                         double p = 0.0;
1587
1588                         if (base)
1589                                 snprintf(base_buf, sizeof(base_buf), "%ld", base_val);
1590                         else
1591                                 snprintf(base_buf, sizeof(base_buf), "%s", "N/A");
1592                         if (comp)
1593                                 snprintf(comp_buf, sizeof(comp_buf), "%ld", comp_val);
1594                         else
1595                                 snprintf(comp_buf, sizeof(comp_buf), "%s", "N/A");
1596
1597                         diff_val = comp_val - base_val;
1598                         if (!base || !comp) {
1599                                 snprintf(diff_buf, sizeof(diff_buf), "%s", "N/A");
1600                         } else {
1601                                 if (base_val == 0) {
1602                                         if (comp_val == base_val)
1603                                                 p = 0.0; /* avoid +0 (+100%) case */
1604                                         else
1605                                                 p = comp_val < base_val ? -100.0 : 100.0;
1606                                 } else {
1607                                          p = diff_val * 100.0 / base_val;
1608                                 }
1609                                 snprintf(diff_buf, sizeof(diff_buf), "%+ld (%+.2lf%%)", diff_val, p);
1610                         }
1611                 }
1612
1613                 switch (fmt) {
1614                 case RESFMT_TABLE_CALCLEN:
1615                         len = strlen(base_buf);
1616                         if (len > *max_len_base)
1617                                 *max_len_base = len;
1618                         if (!is_key_stat(id)) {
1619                                 len = strlen(comp_buf);
1620                                 if (len > *max_len_comp)
1621                                         *max_len_comp = len;
1622                                 len = strlen(diff_buf);
1623                                 if (len > *max_len_diff)
1624                                         *max_len_diff = len;
1625                         }
1626                         break;
1627                 case RESFMT_TABLE: {
1628                         /* string outputs are left-aligned, number outputs are right-aligned */
1629                         const char *fmt = base_str ? "%s%-*s" : "%s%*s";
1630
1631                         printf(fmt, i == 0 ? "" : COLUMN_SEP, *max_len_base, base_buf);
1632                         if (!is_key_stat(id)) {
1633                                 printf(fmt, COLUMN_SEP, *max_len_comp, comp_buf);
1634                                 printf(fmt, COLUMN_SEP, *max_len_diff, diff_buf);
1635                         }
1636                         if (i == env.output_spec.spec_cnt - 1)
1637                                 printf("\n");
1638                         break;
1639                 }
1640                 case RESFMT_CSV:
1641                         printf("%s%s", i == 0 ? "" : ",", base_buf);
1642                         if (!is_key_stat(id)) {
1643                                 printf("%s%s", i == 0 ? "" : ",", comp_buf);
1644                                 printf("%s%s", i == 0 ? "" : ",", diff_buf);
1645                         }
1646                         if (i == env.output_spec.spec_cnt - 1)
1647                                 printf("\n");
1648                         break;
1649                 }
1650         }
1651
1652         if (last && fmt == RESFMT_TABLE)
1653                 output_comp_header_underlines();
1654 }
1655
1656 static int cmp_stats_key(const struct verif_stats *base, const struct verif_stats *comp)
1657 {
1658         int r;
1659
1660         r = strcmp(base->file_name, comp->file_name);
1661         if (r != 0)
1662                 return r;
1663         return strcmp(base->prog_name, comp->prog_name);
1664 }
1665
1666 static bool is_join_stat_filter_matched(struct filter *f, const struct verif_stats_join *stats)
1667 {
1668         static const double eps = 1e-9;
1669         const char *str = NULL;
1670         double value = 0.0;
1671
1672         fetch_join_stat_value(stats, f->stat_id, f->stat_var, &str, &value);
1673
1674         switch (f->op) {
1675         case OP_EQ: return value > f->value - eps && value < f->value + eps;
1676         case OP_NEQ: return value < f->value - eps || value > f->value + eps;
1677         case OP_LT: return value < f->value - eps;
1678         case OP_LE: return value <= f->value + eps;
1679         case OP_GT: return value > f->value + eps;
1680         case OP_GE: return value >= f->value - eps;
1681         }
1682
1683         fprintf(stderr, "BUG: unknown filter op %d!\n", f->op);
1684         return false;
1685 }
1686
1687 static bool should_output_join_stats(const struct verif_stats_join *stats)
1688 {
1689         struct filter *f;
1690         int i, allow_cnt = 0;
1691
1692         for (i = 0; i < env.deny_filter_cnt; i++) {
1693                 f = &env.deny_filters[i];
1694                 if (f->kind != FILTER_STAT)
1695                         continue;
1696
1697                 if (is_join_stat_filter_matched(f, stats))
1698                         return false;
1699         }
1700
1701         for (i = 0; i < env.allow_filter_cnt; i++) {
1702                 f = &env.allow_filters[i];
1703                 if (f->kind != FILTER_STAT)
1704                         continue;
1705                 allow_cnt++;
1706
1707                 if (is_join_stat_filter_matched(f, stats))
1708                         return true;
1709         }
1710
1711         /* if there are no stat allowed filters, pass everything through */
1712         return allow_cnt == 0;
1713 }
1714
1715 static int handle_comparison_mode(void)
1716 {
1717         struct stat_specs base_specs = {}, comp_specs = {};
1718         struct stat_specs tmp_sort_spec;
1719         enum resfmt cur_fmt;
1720         int err, i, j, last_idx;
1721
1722         if (env.filename_cnt != 2) {
1723                 fprintf(stderr, "Comparison mode expects exactly two input CSV files!\n\n");
1724                 argp_help(&argp, stderr, ARGP_HELP_USAGE, "veristat");
1725                 return -EINVAL;
1726         }
1727
1728         err = parse_stats_csv(env.filenames[0], &base_specs,
1729                               &env.baseline_stats, &env.baseline_stat_cnt);
1730         if (err) {
1731                 fprintf(stderr, "Failed to parse stats from '%s': %d\n", env.filenames[0], err);
1732                 return err;
1733         }
1734         err = parse_stats_csv(env.filenames[1], &comp_specs,
1735                               &env.prog_stats, &env.prog_stat_cnt);
1736         if (err) {
1737                 fprintf(stderr, "Failed to parse stats from '%s': %d\n", env.filenames[1], err);
1738                 return err;
1739         }
1740
1741         /* To keep it simple we validate that the set and order of stats in
1742          * both CSVs are exactly the same. This can be lifted with a bit more
1743          * pre-processing later.
1744          */
1745         if (base_specs.spec_cnt != comp_specs.spec_cnt) {
1746                 fprintf(stderr, "Number of stats in '%s' and '%s' differs (%d != %d)!\n",
1747                         env.filenames[0], env.filenames[1],
1748                         base_specs.spec_cnt, comp_specs.spec_cnt);
1749                 return -EINVAL;
1750         }
1751         for (i = 0; i < base_specs.spec_cnt; i++) {
1752                 if (base_specs.ids[i] != comp_specs.ids[i]) {
1753                         fprintf(stderr, "Stats composition differs between '%s' and '%s' (%s != %s)!\n",
1754                                 env.filenames[0], env.filenames[1],
1755                                 stat_defs[base_specs.ids[i]].names[0],
1756                                 stat_defs[comp_specs.ids[i]].names[0]);
1757                         return -EINVAL;
1758                 }
1759         }
1760
1761         /* Replace user-specified sorting spec with file+prog sorting rule to
1762          * be able to join two datasets correctly. Once we are done, we will
1763          * restore the original sort spec.
1764          */
1765         tmp_sort_spec = env.sort_spec;
1766         env.sort_spec = join_sort_spec;
1767         qsort(env.prog_stats, env.prog_stat_cnt, sizeof(*env.prog_stats), cmp_prog_stats);
1768         qsort(env.baseline_stats, env.baseline_stat_cnt, sizeof(*env.baseline_stats), cmp_prog_stats);
1769         env.sort_spec = tmp_sort_spec;
1770
1771         /* Join two datasets together. If baseline and comparison datasets
1772          * have different subset of rows (we match by 'object + prog' as
1773          * a unique key) then assume empty/missing/zero value for rows that
1774          * are missing in the opposite data set.
1775          */
1776         i = j = 0;
1777         while (i < env.baseline_stat_cnt || j < env.prog_stat_cnt) {
1778                 const struct verif_stats *base, *comp;
1779                 struct verif_stats_join *join;
1780                 void *tmp;
1781                 int r;
1782
1783                 base = i < env.baseline_stat_cnt ? &env.baseline_stats[i] : &fallback_stats;
1784                 comp = j < env.prog_stat_cnt ? &env.prog_stats[j] : &fallback_stats;
1785
1786                 if (!base->file_name || !base->prog_name) {
1787                         fprintf(stderr, "Entry #%d in '%s' doesn't have file and/or program name specified!\n",
1788                                 i, env.filenames[0]);
1789                         return -EINVAL;
1790                 }
1791                 if (!comp->file_name || !comp->prog_name) {
1792                         fprintf(stderr, "Entry #%d in '%s' doesn't have file and/or program name specified!\n",
1793                                 j, env.filenames[1]);
1794                         return -EINVAL;
1795                 }
1796
1797                 tmp = realloc(env.join_stats, (env.join_stat_cnt + 1) * sizeof(*env.join_stats));
1798                 if (!tmp)
1799                         return -ENOMEM;
1800                 env.join_stats = tmp;
1801
1802                 join = &env.join_stats[env.join_stat_cnt];
1803                 memset(join, 0, sizeof(*join));
1804
1805                 r = cmp_stats_key(base, comp);
1806                 if (r == 0) {
1807                         join->file_name = base->file_name;
1808                         join->prog_name = base->prog_name;
1809                         join->stats_a = base;
1810                         join->stats_b = comp;
1811                         i++;
1812                         j++;
1813                 } else if (comp == &fallback_stats || r < 0) {
1814                         join->file_name = base->file_name;
1815                         join->prog_name = base->prog_name;
1816                         join->stats_a = base;
1817                         join->stats_b = NULL;
1818                         i++;
1819                 } else {
1820                         join->file_name = comp->file_name;
1821                         join->prog_name = comp->prog_name;
1822                         join->stats_a = NULL;
1823                         join->stats_b = comp;
1824                         j++;
1825                 }
1826                 env.join_stat_cnt += 1;
1827         }
1828
1829         /* now sort joined results accorsing to sort spec */
1830         qsort(env.join_stats, env.join_stat_cnt, sizeof(*env.join_stats), cmp_join_stats);
1831
1832         /* for human-readable table output we need to do extra pass to
1833          * calculate column widths, so we substitute current output format
1834          * with RESFMT_TABLE_CALCLEN and later revert it back to RESFMT_TABLE
1835          * and do everything again.
1836          */
1837         if (env.out_fmt == RESFMT_TABLE)
1838                 cur_fmt = RESFMT_TABLE_CALCLEN;
1839         else
1840                 cur_fmt = env.out_fmt;
1841
1842 one_more_time:
1843         output_comp_headers(cur_fmt);
1844
1845         for (i = 0; i < env.join_stat_cnt; i++) {
1846                 const struct verif_stats_join *join = &env.join_stats[i];
1847
1848                 if (!should_output_join_stats(join))
1849                         continue;
1850
1851                 if (cur_fmt == RESFMT_TABLE_CALCLEN)
1852                         last_idx = i;
1853
1854                 output_comp_stats(join, cur_fmt, i == last_idx);
1855         }
1856
1857         if (cur_fmt == RESFMT_TABLE_CALCLEN) {
1858                 cur_fmt = RESFMT_TABLE;
1859                 goto one_more_time; /* ... this time with feeling */
1860         }
1861
1862         return 0;
1863 }
1864
1865 static bool is_stat_filter_matched(struct filter *f, const struct verif_stats *stats)
1866 {
1867         long value = stats->stats[f->stat_id];
1868
1869         switch (f->op) {
1870         case OP_EQ: return value == f->value;
1871         case OP_NEQ: return value != f->value;
1872         case OP_LT: return value < f->value;
1873         case OP_LE: return value <= f->value;
1874         case OP_GT: return value > f->value;
1875         case OP_GE: return value >= f->value;
1876         }
1877
1878         fprintf(stderr, "BUG: unknown filter op %d!\n", f->op);
1879         return false;
1880 }
1881
1882 static bool should_output_stats(const struct verif_stats *stats)
1883 {
1884         struct filter *f;
1885         int i, allow_cnt = 0;
1886
1887         for (i = 0; i < env.deny_filter_cnt; i++) {
1888                 f = &env.deny_filters[i];
1889                 if (f->kind != FILTER_STAT)
1890                         continue;
1891
1892                 if (is_stat_filter_matched(f, stats))
1893                         return false;
1894         }
1895
1896         for (i = 0; i < env.allow_filter_cnt; i++) {
1897                 f = &env.allow_filters[i];
1898                 if (f->kind != FILTER_STAT)
1899                         continue;
1900                 allow_cnt++;
1901
1902                 if (is_stat_filter_matched(f, stats))
1903                         return true;
1904         }
1905
1906         /* if there are no stat allowed filters, pass everything through */
1907         return allow_cnt == 0;
1908 }
1909
1910 static void output_prog_stats(void)
1911 {
1912         const struct verif_stats *stats;
1913         int i, last_stat_idx = 0;
1914
1915         if (env.out_fmt == RESFMT_TABLE) {
1916                 /* calculate column widths */
1917                 output_headers(RESFMT_TABLE_CALCLEN);
1918                 for (i = 0; i < env.prog_stat_cnt; i++) {
1919                         stats = &env.prog_stats[i];
1920                         if (!should_output_stats(stats))
1921                                 continue;
1922                         output_stats(stats, RESFMT_TABLE_CALCLEN, false);
1923                         last_stat_idx = i;
1924                 }
1925         }
1926
1927         /* actually output the table */
1928         output_headers(env.out_fmt);
1929         for (i = 0; i < env.prog_stat_cnt; i++) {
1930                 stats = &env.prog_stats[i];
1931                 if (!should_output_stats(stats))
1932                         continue;
1933                 output_stats(stats, env.out_fmt, i == last_stat_idx);
1934         }
1935 }
1936
1937 static int handle_verif_mode(void)
1938 {
1939         int i, err;
1940
1941         if (env.filename_cnt == 0) {
1942                 fprintf(stderr, "Please provide path to BPF object file!\n\n");
1943                 argp_help(&argp, stderr, ARGP_HELP_USAGE, "veristat");
1944                 return -EINVAL;
1945         }
1946
1947         for (i = 0; i < env.filename_cnt; i++) {
1948                 err = process_obj(env.filenames[i]);
1949                 if (err) {
1950                         fprintf(stderr, "Failed to process '%s': %d\n", env.filenames[i], err);
1951                         return err;
1952                 }
1953         }
1954
1955         qsort(env.prog_stats, env.prog_stat_cnt, sizeof(*env.prog_stats), cmp_prog_stats);
1956
1957         output_prog_stats();
1958
1959         return 0;
1960 }
1961
1962 static int handle_replay_mode(void)
1963 {
1964         struct stat_specs specs = {};
1965         int err;
1966
1967         if (env.filename_cnt != 1) {
1968                 fprintf(stderr, "Replay mode expects exactly one input CSV file!\n\n");
1969                 argp_help(&argp, stderr, ARGP_HELP_USAGE, "veristat");
1970                 return -EINVAL;
1971         }
1972
1973         err = parse_stats_csv(env.filenames[0], &specs,
1974                               &env.prog_stats, &env.prog_stat_cnt);
1975         if (err) {
1976                 fprintf(stderr, "Failed to parse stats from '%s': %d\n", env.filenames[0], err);
1977                 return err;
1978         }
1979
1980         qsort(env.prog_stats, env.prog_stat_cnt, sizeof(*env.prog_stats), cmp_prog_stats);
1981
1982         output_prog_stats();
1983
1984         return 0;
1985 }
1986
1987 int main(int argc, char **argv)
1988 {
1989         int err = 0, i;
1990
1991         if (argp_parse(&argp, argc, argv, 0, NULL, NULL))
1992                 return 1;
1993
1994         if (env.verbose && env.quiet) {
1995                 fprintf(stderr, "Verbose and quiet modes are incompatible, please specify just one or neither!\n\n");
1996                 argp_help(&argp, stderr, ARGP_HELP_USAGE, "veristat");
1997                 return 1;
1998         }
1999         if (env.verbose && env.log_level == 0)
2000                 env.log_level = 1;
2001
2002         if (env.output_spec.spec_cnt == 0) {
2003                 if (env.out_fmt == RESFMT_CSV)
2004                         env.output_spec = default_csv_output_spec;
2005                 else
2006                         env.output_spec = default_output_spec;
2007         }
2008         if (env.sort_spec.spec_cnt == 0)
2009                 env.sort_spec = default_sort_spec;
2010
2011         if (env.comparison_mode && env.replay_mode) {
2012                 fprintf(stderr, "Can't specify replay and comparison mode at the same time!\n\n");
2013                 argp_help(&argp, stderr, ARGP_HELP_USAGE, "veristat");
2014                 return 1;
2015         }
2016
2017         if (env.comparison_mode)
2018                 err = handle_comparison_mode();
2019         else if (env.replay_mode)
2020                 err = handle_replay_mode();
2021         else
2022                 err = handle_verif_mode();
2023
2024         free_verif_stats(env.prog_stats, env.prog_stat_cnt);
2025         free_verif_stats(env.baseline_stats, env.baseline_stat_cnt);
2026         free(env.join_stats);
2027         for (i = 0; i < env.filename_cnt; i++)
2028                 free(env.filenames[i]);
2029         free(env.filenames);
2030         for (i = 0; i < env.allow_filter_cnt; i++) {
2031                 free(env.allow_filters[i].any_glob);
2032                 free(env.allow_filters[i].file_glob);
2033                 free(env.allow_filters[i].prog_glob);
2034         }
2035         free(env.allow_filters);
2036         for (i = 0; i < env.deny_filter_cnt; i++) {
2037                 free(env.deny_filters[i].any_glob);
2038                 free(env.deny_filters[i].file_glob);
2039                 free(env.deny_filters[i].prog_glob);
2040         }
2041         free(env.deny_filters);
2042         return -err;
2043 }