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