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