1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * builtin-list.c 4 * 5 * Builtin list command: list all event types 6 * 7 * Copyright (C) 2009, Thomas Gleixner <tglx@linutronix.de> 8 * Copyright (C) 2008-2009, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 9 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> 10 */ 11 #include "builtin.h" 12 13 #include "util/print-events.h" 14 #include "util/pmus.h" 15 #include "util/pmu.h" 16 #include "util/debug.h" 17 #include "util/metricgroup.h" 18 #include "util/pfm.h" 19 #include "util/string2.h" 20 #include "util/strlist.h" 21 #include "util/strbuf.h" 22 #include <subcmd/pager.h> 23 #include <subcmd/parse-options.h> 24 #include <linux/zalloc.h> 25 #include <ctype.h> 26 #include <stdarg.h> 27 #include <stdio.h> 28 29 /** 30 * struct print_state - State and configuration passed to the default_print 31 * functions. 32 */ 33 struct print_state { 34 /** @fp: File to write output to. */ 35 FILE *fp; 36 /** 37 * @pmu_glob: Optionally restrict PMU and metric matching to PMU or 38 * debugfs subsystem name. 39 */ 40 char *pmu_glob; 41 /** @event_glob: Optional pattern matching glob. */ 42 char *event_glob; 43 /** @name_only: Print event or metric names only. */ 44 bool name_only; 45 /** @desc: Print the event or metric description. */ 46 bool desc; 47 /** @long_desc: Print longer event or metric description. */ 48 bool long_desc; 49 /** @deprecated: Print deprecated events or metrics. */ 50 bool deprecated; 51 /** 52 * @detailed: Print extra information on the perf event such as names 53 * and expressions used internally by events. 54 */ 55 bool detailed; 56 /** @metrics: Controls printing of metric and metric groups. */ 57 bool metrics; 58 /** @metricgroups: Controls printing of metric and metric groups. */ 59 bool metricgroups; 60 /** @last_topic: The last printed event topic. */ 61 char *last_topic; 62 /** @last_metricgroups: The last printed metric group. */ 63 char *last_metricgroups; 64 /** @visited_metrics: Metrics that are printed to avoid duplicates. */ 65 struct strlist *visited_metrics; 66 }; 67 68 static void default_print_start(void *ps) 69 { 70 struct print_state *print_state = ps; 71 72 if (!print_state->name_only && pager_in_use()) { 73 fprintf(print_state->fp, 74 "\nList of pre-defined events (to be used in -e or -M):\n\n"); 75 } 76 } 77 78 static void default_print_end(void *print_state __maybe_unused) {} 79 80 static const char *skip_spaces_or_commas(const char *str) 81 { 82 while (isspace(*str) || *str == ',') 83 ++str; 84 return str; 85 } 86 87 static void wordwrap(FILE *fp, const char *s, int start, int max, int corr) 88 { 89 int column = start; 90 int n; 91 bool saw_newline = false; 92 bool comma = false; 93 94 while (*s) { 95 int wlen = strcspn(s, " ,\t\n"); 96 const char *sep = comma ? "," : " "; 97 98 if ((column + wlen >= max && column > start) || saw_newline) { 99 fprintf(fp, comma ? ",\n%*s" : "\n%*s", start, ""); 100 column = start + corr; 101 } 102 if (column <= start) 103 sep = ""; 104 n = fprintf(fp, "%s%.*s", sep, wlen, s); 105 if (n <= 0) 106 break; 107 saw_newline = s[wlen] == '\n'; 108 s += wlen; 109 comma = s[0] == ','; 110 column += n; 111 s = skip_spaces_or_commas(s); 112 } 113 } 114 115 static void default_print_event(void *ps, const char *pmu_name, const char *topic, 116 const char *event_name, const char *event_alias, 117 const char *scale_unit __maybe_unused, 118 bool deprecated, const char *event_type_desc, 119 const char *desc, const char *long_desc, 120 const char *encoding_desc) 121 { 122 struct print_state *print_state = ps; 123 int pos; 124 FILE *fp = print_state->fp; 125 126 if (deprecated && !print_state->deprecated) 127 return; 128 129 if (print_state->pmu_glob && pmu_name && !strglobmatch(pmu_name, print_state->pmu_glob)) 130 return; 131 132 if (print_state->event_glob && 133 (!event_name || !strglobmatch(event_name, print_state->event_glob)) && 134 (!event_alias || !strglobmatch(event_alias, print_state->event_glob)) && 135 (!topic || !strglobmatch_nocase(topic, print_state->event_glob))) 136 return; 137 138 if (print_state->name_only) { 139 if (event_alias && strlen(event_alias)) 140 fprintf(fp, "%s ", event_alias); 141 else 142 fprintf(fp, "%s ", event_name); 143 return; 144 } 145 146 if (strcmp(print_state->last_topic, topic ?: "")) { 147 if (topic) 148 fprintf(fp, "\n%s:\n", topic); 149 zfree(&print_state->last_topic); 150 print_state->last_topic = strdup(topic ?: ""); 151 } 152 153 if (event_alias && strlen(event_alias)) 154 pos = fprintf(fp, " %s OR %s", event_name, event_alias); 155 else 156 pos = fprintf(fp, " %s", event_name); 157 158 if (!topic && event_type_desc) { 159 for (; pos < 53; pos++) 160 fputc(' ', fp); 161 fprintf(fp, "[%s]\n", event_type_desc); 162 } else 163 fputc('\n', fp); 164 165 if (long_desc && print_state->long_desc) { 166 fprintf(fp, "%*s", 8, "["); 167 wordwrap(fp, long_desc, 8, pager_get_columns(), 0); 168 fprintf(fp, "]\n"); 169 } else if (desc && print_state->desc) { 170 char *desc_with_unit = NULL; 171 int desc_len = -1; 172 173 if (pmu_name && strcmp(pmu_name, "default_core")) { 174 desc_len = strlen(desc); 175 desc_len = asprintf(&desc_with_unit, 176 desc_len > 0 && desc[desc_len - 1] != '.' 177 ? "%s. Unit: %s" : "%s Unit: %s", 178 desc, pmu_name); 179 } 180 fprintf(fp, "%*s", 8, "["); 181 wordwrap(fp, desc_len > 0 ? desc_with_unit : desc, 8, pager_get_columns(), 0); 182 fprintf(fp, "]\n"); 183 free(desc_with_unit); 184 } 185 186 if (print_state->detailed && encoding_desc) { 187 fprintf(fp, "%*s", 8, ""); 188 wordwrap(fp, encoding_desc, 8, pager_get_columns(), 0); 189 fputc('\n', fp); 190 } 191 } 192 193 static void default_print_metric(void *ps, 194 const char *group, 195 const char *name, 196 const char *desc, 197 const char *long_desc, 198 const char *expr, 199 const char *threshold, 200 const char *unit __maybe_unused) 201 { 202 struct print_state *print_state = ps; 203 FILE *fp = print_state->fp; 204 205 if (print_state->event_glob && 206 (!print_state->metrics || !name || !strglobmatch(name, print_state->event_glob)) && 207 (!print_state->metricgroups || !group || !strglobmatch(group, print_state->event_glob))) 208 return; 209 210 if (!print_state->name_only && !print_state->last_metricgroups) { 211 if (print_state->metricgroups) { 212 fprintf(fp, "\nMetric Groups:\n"); 213 if (!print_state->metrics) 214 fputc('\n', fp); 215 } else { 216 fprintf(fp, "\nMetrics:\n\n"); 217 } 218 } 219 if (!print_state->last_metricgroups || 220 strcmp(print_state->last_metricgroups, group ?: "")) { 221 if (group && print_state->metricgroups) { 222 if (print_state->name_only) { 223 fprintf(fp, "%s ", group); 224 } else { 225 const char *gdesc = print_state->desc 226 ? describe_metricgroup(group) 227 : NULL; 228 const char *print_colon = ""; 229 230 if (print_state->metrics) { 231 print_colon = ":"; 232 fputc('\n', fp); 233 } 234 235 if (gdesc) 236 fprintf(fp, "%s%s [%s]\n", group, print_colon, gdesc); 237 else 238 fprintf(fp, "%s%s\n", group, print_colon); 239 } 240 } 241 zfree(&print_state->last_metricgroups); 242 print_state->last_metricgroups = strdup(group ?: ""); 243 } 244 if (!print_state->metrics) 245 return; 246 247 if (print_state->name_only) { 248 if (print_state->metrics && 249 !strlist__has_entry(print_state->visited_metrics, name)) { 250 fprintf(fp, "%s ", name); 251 strlist__add(print_state->visited_metrics, name); 252 } 253 return; 254 } 255 fprintf(fp, " %s\n", name); 256 257 if (long_desc && print_state->long_desc) { 258 fprintf(fp, "%*s", 8, "["); 259 wordwrap(fp, long_desc, 8, pager_get_columns(), 0); 260 fprintf(fp, "]\n"); 261 } else if (desc && print_state->desc) { 262 fprintf(fp, "%*s", 8, "["); 263 wordwrap(fp, desc, 8, pager_get_columns(), 0); 264 fprintf(fp, "]\n"); 265 } 266 if (expr && print_state->detailed) { 267 fprintf(fp, "%*s", 8, "["); 268 wordwrap(fp, expr, 8, pager_get_columns(), 0); 269 fprintf(fp, "]\n"); 270 } 271 if (threshold && print_state->detailed) { 272 fprintf(fp, "%*s", 8, "["); 273 wordwrap(fp, threshold, 8, pager_get_columns(), 0); 274 fprintf(fp, "]\n"); 275 } 276 } 277 278 struct json_print_state { 279 /** @fp: File to write output to. */ 280 FILE *fp; 281 /** Should a separator be printed prior to the next item? */ 282 bool need_sep; 283 }; 284 285 static void json_print_start(void *ps) 286 { 287 struct json_print_state *print_state = ps; 288 FILE *fp = print_state->fp; 289 290 fprintf(fp, "[\n"); 291 } 292 293 static void json_print_end(void *ps) 294 { 295 struct json_print_state *print_state = ps; 296 FILE *fp = print_state->fp; 297 298 fprintf(fp, "%s]\n", print_state->need_sep ? "\n" : ""); 299 } 300 301 static void fix_escape_fprintf(FILE *fp, struct strbuf *buf, const char *fmt, ...) 302 { 303 va_list args; 304 305 va_start(args, fmt); 306 strbuf_setlen(buf, 0); 307 for (size_t fmt_pos = 0; fmt_pos < strlen(fmt); fmt_pos++) { 308 switch (fmt[fmt_pos]) { 309 case '%': 310 fmt_pos++; 311 switch (fmt[fmt_pos]) { 312 case 's': { 313 const char *s = va_arg(args, const char*); 314 315 strbuf_addstr(buf, s); 316 break; 317 } 318 case 'S': { 319 const char *s = va_arg(args, const char*); 320 321 for (size_t s_pos = 0; s_pos < strlen(s); s_pos++) { 322 switch (s[s_pos]) { 323 case '\n': 324 strbuf_addstr(buf, "\\n"); 325 break; 326 case '\r': 327 strbuf_addstr(buf, "\\r"); 328 break; 329 case '\\': 330 fallthrough; 331 case '\"': 332 strbuf_addch(buf, '\\'); 333 fallthrough; 334 default: 335 strbuf_addch(buf, s[s_pos]); 336 break; 337 } 338 } 339 break; 340 } 341 default: 342 pr_err("Unexpected format character '%c'\n", fmt[fmt_pos]); 343 strbuf_addch(buf, '%'); 344 strbuf_addch(buf, fmt[fmt_pos]); 345 } 346 break; 347 default: 348 strbuf_addch(buf, fmt[fmt_pos]); 349 break; 350 } 351 } 352 va_end(args); 353 fputs(buf->buf, fp); 354 } 355 356 static void json_print_event(void *ps, const char *pmu_name, const char *topic, 357 const char *event_name, const char *event_alias, 358 const char *scale_unit, 359 bool deprecated, const char *event_type_desc, 360 const char *desc, const char *long_desc, 361 const char *encoding_desc) 362 { 363 struct json_print_state *print_state = ps; 364 bool need_sep = false; 365 FILE *fp = print_state->fp; 366 struct strbuf buf; 367 368 strbuf_init(&buf, 0); 369 fprintf(fp, "%s{\n", print_state->need_sep ? ",\n" : ""); 370 print_state->need_sep = true; 371 if (pmu_name) { 372 fix_escape_fprintf(fp, &buf, "\t\"Unit\": \"%S\"", pmu_name); 373 need_sep = true; 374 } 375 if (topic) { 376 fix_escape_fprintf(fp, &buf, "%s\t\"Topic\": \"%S\"", 377 need_sep ? ",\n" : "", 378 topic); 379 need_sep = true; 380 } 381 if (event_name) { 382 fix_escape_fprintf(fp, &buf, "%s\t\"EventName\": \"%S\"", 383 need_sep ? ",\n" : "", 384 event_name); 385 need_sep = true; 386 } 387 if (event_alias && strlen(event_alias)) { 388 fix_escape_fprintf(fp, &buf, "%s\t\"EventAlias\": \"%S\"", 389 need_sep ? ",\n" : "", 390 event_alias); 391 need_sep = true; 392 } 393 if (scale_unit && strlen(scale_unit)) { 394 fix_escape_fprintf(fp, &buf, "%s\t\"ScaleUnit\": \"%S\"", 395 need_sep ? ",\n" : "", 396 scale_unit); 397 need_sep = true; 398 } 399 if (event_type_desc) { 400 fix_escape_fprintf(fp, &buf, "%s\t\"EventType\": \"%S\"", 401 need_sep ? ",\n" : "", 402 event_type_desc); 403 need_sep = true; 404 } 405 if (deprecated) { 406 fix_escape_fprintf(fp, &buf, "%s\t\"Deprecated\": \"%S\"", 407 need_sep ? ",\n" : "", 408 deprecated ? "1" : "0"); 409 need_sep = true; 410 } 411 if (desc) { 412 fix_escape_fprintf(fp, &buf, "%s\t\"BriefDescription\": \"%S\"", 413 need_sep ? ",\n" : "", 414 desc); 415 need_sep = true; 416 } 417 if (long_desc) { 418 fix_escape_fprintf(fp, &buf, "%s\t\"PublicDescription\": \"%S\"", 419 need_sep ? ",\n" : "", 420 long_desc); 421 need_sep = true; 422 } 423 if (encoding_desc) { 424 fix_escape_fprintf(fp, &buf, "%s\t\"Encoding\": \"%S\"", 425 need_sep ? ",\n" : "", 426 encoding_desc); 427 need_sep = true; 428 } 429 fprintf(fp, "%s}", need_sep ? "\n" : ""); 430 strbuf_release(&buf); 431 } 432 433 static void json_print_metric(void *ps __maybe_unused, const char *group, 434 const char *name, const char *desc, 435 const char *long_desc, const char *expr, 436 const char *threshold, const char *unit) 437 { 438 struct json_print_state *print_state = ps; 439 bool need_sep = false; 440 FILE *fp = print_state->fp; 441 struct strbuf buf; 442 443 strbuf_init(&buf, 0); 444 fprintf(fp, "%s{\n", print_state->need_sep ? ",\n" : ""); 445 print_state->need_sep = true; 446 if (group) { 447 fix_escape_fprintf(fp, &buf, "\t\"MetricGroup\": \"%S\"", group); 448 need_sep = true; 449 } 450 if (name) { 451 fix_escape_fprintf(fp, &buf, "%s\t\"MetricName\": \"%S\"", 452 need_sep ? ",\n" : "", 453 name); 454 need_sep = true; 455 } 456 if (expr) { 457 fix_escape_fprintf(fp, &buf, "%s\t\"MetricExpr\": \"%S\"", 458 need_sep ? ",\n" : "", 459 expr); 460 need_sep = true; 461 } 462 if (threshold) { 463 fix_escape_fprintf(fp, &buf, "%s\t\"MetricThreshold\": \"%S\"", 464 need_sep ? ",\n" : "", 465 threshold); 466 need_sep = true; 467 } 468 if (unit) { 469 fix_escape_fprintf(fp, &buf, "%s\t\"ScaleUnit\": \"%S\"", 470 need_sep ? ",\n" : "", 471 unit); 472 need_sep = true; 473 } 474 if (desc) { 475 fix_escape_fprintf(fp, &buf, "%s\t\"BriefDescription\": \"%S\"", 476 need_sep ? ",\n" : "", 477 desc); 478 need_sep = true; 479 } 480 if (long_desc) { 481 fix_escape_fprintf(fp, &buf, "%s\t\"PublicDescription\": \"%S\"", 482 need_sep ? ",\n" : "", 483 long_desc); 484 need_sep = true; 485 } 486 fprintf(fp, "%s}", need_sep ? "\n" : ""); 487 strbuf_release(&buf); 488 } 489 490 static bool json_skip_duplicate_pmus(void *ps __maybe_unused) 491 { 492 return false; 493 } 494 495 static bool default_skip_duplicate_pmus(void *ps) 496 { 497 struct print_state *print_state = ps; 498 499 return !print_state->long_desc; 500 } 501 502 int cmd_list(int argc, const char **argv) 503 { 504 int i, ret = 0; 505 struct print_state default_ps = { 506 .fp = stdout, 507 .desc = true, 508 }; 509 struct print_state json_ps = { 510 .fp = stdout, 511 }; 512 void *ps = &default_ps; 513 struct print_callbacks print_cb = { 514 .print_start = default_print_start, 515 .print_end = default_print_end, 516 .print_event = default_print_event, 517 .print_metric = default_print_metric, 518 .skip_duplicate_pmus = default_skip_duplicate_pmus, 519 }; 520 const char *cputype = NULL; 521 const char *unit_name = NULL; 522 const char *output_path = NULL; 523 bool json = false; 524 struct option list_options[] = { 525 OPT_BOOLEAN(0, "raw-dump", &default_ps.name_only, "Dump raw events"), 526 OPT_BOOLEAN('j', "json", &json, "JSON encode events and metrics"), 527 OPT_BOOLEAN('d', "desc", &default_ps.desc, 528 "Print extra event descriptions. --no-desc to not print."), 529 OPT_BOOLEAN('v', "long-desc", &default_ps.long_desc, 530 "Print longer event descriptions."), 531 OPT_BOOLEAN(0, "details", &default_ps.detailed, 532 "Print information on the perf event names and expressions used internally by events."), 533 OPT_STRING('o', "output", &output_path, "file", "output file name"), 534 OPT_BOOLEAN(0, "deprecated", &default_ps.deprecated, 535 "Print deprecated events."), 536 OPT_STRING(0, "cputype", &cputype, "cpu type", 537 "Limit PMU or metric printing to the given PMU (e.g. cpu, core or atom)."), 538 OPT_STRING(0, "unit", &unit_name, "PMU name", 539 "Limit PMU or metric printing to the specified PMU."), 540 OPT_INCR(0, "debug", &verbose, 541 "Enable debugging output"), 542 OPT_END() 543 }; 544 const char * const list_usage[] = { 545 #ifdef HAVE_LIBPFM 546 "perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|metric|metricgroup|event_glob|pfm]", 547 #else 548 "perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|metric|metricgroup|event_glob]", 549 #endif 550 NULL 551 }; 552 553 set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN); 554 /* Hide hybrid flag for the more generic 'unit' flag. */ 555 set_option_flag(list_options, 0, "cputype", PARSE_OPT_HIDDEN); 556 557 argc = parse_options(argc, argv, list_options, list_usage, 558 PARSE_OPT_STOP_AT_NON_OPTION); 559 560 if (output_path) { 561 default_ps.fp = fopen(output_path, "w"); 562 json_ps.fp = default_ps.fp; 563 } 564 565 setup_pager(); 566 567 if (!default_ps.name_only) 568 setup_pager(); 569 570 if (json) { 571 print_cb = (struct print_callbacks){ 572 .print_start = json_print_start, 573 .print_end = json_print_end, 574 .print_event = json_print_event, 575 .print_metric = json_print_metric, 576 .skip_duplicate_pmus = json_skip_duplicate_pmus, 577 }; 578 ps = &json_ps; 579 } else { 580 default_ps.last_topic = strdup(""); 581 assert(default_ps.last_topic); 582 default_ps.visited_metrics = strlist__new(NULL, NULL); 583 assert(default_ps.visited_metrics); 584 if (unit_name) 585 default_ps.pmu_glob = strdup(unit_name); 586 else if (cputype) { 587 const struct perf_pmu *pmu = perf_pmus__pmu_for_pmu_filter(cputype); 588 589 if (!pmu) { 590 pr_err("ERROR: cputype is not supported!\n"); 591 ret = -1; 592 goto out; 593 } 594 default_ps.pmu_glob = strdup(pmu->name); 595 } 596 } 597 print_cb.print_start(ps); 598 599 if (argc == 0) { 600 default_ps.metrics = true; 601 default_ps.metricgroups = true; 602 print_events(&print_cb, ps); 603 goto out; 604 } 605 606 for (i = 0; i < argc; ++i) { 607 char *sep, *s; 608 609 if (strcmp(argv[i], "tracepoint") == 0) 610 print_tracepoint_events(&print_cb, ps); 611 else if (strcmp(argv[i], "hw") == 0 || 612 strcmp(argv[i], "hardware") == 0) 613 print_symbol_events(&print_cb, ps, PERF_TYPE_HARDWARE, 614 event_symbols_hw, PERF_COUNT_HW_MAX); 615 else if (strcmp(argv[i], "sw") == 0 || 616 strcmp(argv[i], "software") == 0) { 617 print_symbol_events(&print_cb, ps, PERF_TYPE_SOFTWARE, 618 event_symbols_sw, PERF_COUNT_SW_MAX); 619 print_tool_events(&print_cb, ps); 620 } else if (strcmp(argv[i], "cache") == 0 || 621 strcmp(argv[i], "hwcache") == 0) 622 print_hwcache_events(&print_cb, ps); 623 else if (strcmp(argv[i], "pmu") == 0) 624 perf_pmus__print_pmu_events(&print_cb, ps); 625 else if (strcmp(argv[i], "sdt") == 0) 626 print_sdt_events(&print_cb, ps); 627 else if (strcmp(argv[i], "metric") == 0 || strcmp(argv[i], "metrics") == 0) { 628 default_ps.metricgroups = false; 629 default_ps.metrics = true; 630 metricgroup__print(&print_cb, ps); 631 } else if (strcmp(argv[i], "metricgroup") == 0 || 632 strcmp(argv[i], "metricgroups") == 0) { 633 default_ps.metricgroups = true; 634 default_ps.metrics = false; 635 metricgroup__print(&print_cb, ps); 636 } 637 #ifdef HAVE_LIBPFM 638 else if (strcmp(argv[i], "pfm") == 0) 639 print_libpfm_events(&print_cb, ps); 640 #endif 641 else if ((sep = strchr(argv[i], ':')) != NULL) { 642 char *old_pmu_glob = default_ps.pmu_glob; 643 644 default_ps.event_glob = strdup(argv[i]); 645 if (!default_ps.event_glob) { 646 ret = -1; 647 goto out; 648 } 649 650 print_tracepoint_events(&print_cb, ps); 651 print_sdt_events(&print_cb, ps); 652 default_ps.metrics = true; 653 default_ps.metricgroups = true; 654 metricgroup__print(&print_cb, ps); 655 zfree(&default_ps.event_glob); 656 default_ps.pmu_glob = old_pmu_glob; 657 } else { 658 if (asprintf(&s, "*%s*", argv[i]) < 0) { 659 printf("Critical: Not enough memory! Trying to continue...\n"); 660 continue; 661 } 662 default_ps.event_glob = s; 663 print_symbol_events(&print_cb, ps, PERF_TYPE_HARDWARE, 664 event_symbols_hw, PERF_COUNT_HW_MAX); 665 print_symbol_events(&print_cb, ps, PERF_TYPE_SOFTWARE, 666 event_symbols_sw, PERF_COUNT_SW_MAX); 667 print_tool_events(&print_cb, ps); 668 print_hwcache_events(&print_cb, ps); 669 perf_pmus__print_pmu_events(&print_cb, ps); 670 print_tracepoint_events(&print_cb, ps); 671 print_sdt_events(&print_cb, ps); 672 default_ps.metrics = true; 673 default_ps.metricgroups = true; 674 metricgroup__print(&print_cb, ps); 675 free(s); 676 } 677 } 678 679 out: 680 print_cb.print_end(ps); 681 free(default_ps.pmu_glob); 682 free(default_ps.last_topic); 683 free(default_ps.last_metricgroups); 684 strlist__delete(default_ps.visited_metrics); 685 if (output_path) 686 fclose(default_ps.fp); 687 688 return ret; 689 } 690