Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
perf list: Share print state with JSON output
The JSON print state has only one different field (need_sep). Let's
add the default print state to the json state and use it. Then we can
use the 'ps' variable to update the state properly.
This is a preparation for the next commit.
Reviewed-by: Ian Rogers <irogers@google.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
+65
-62
+65
-62
tools/perf/builtin-list.c
+65
-62
tools/perf/builtin-list.c
···
283
283
}
284
284
285
285
struct json_print_state {
286
-
/** @fp: File to write output to. */
287
-
FILE *fp;
286
+
/** The shared print_state */
287
+
struct print_state common;
288
288
/** Should a separator be printed prior to the next item? */
289
289
bool need_sep;
290
290
};
···
292
292
static void json_print_start(void *ps)
293
293
{
294
294
struct json_print_state *print_state = ps;
295
-
FILE *fp = print_state->fp;
295
+
FILE *fp = print_state->common.fp;
296
296
297
297
fprintf(fp, "[\n");
298
298
}
···
300
300
static void json_print_end(void *ps)
301
301
{
302
302
struct json_print_state *print_state = ps;
303
-
FILE *fp = print_state->fp;
303
+
FILE *fp = print_state->common.fp;
304
304
305
305
fprintf(fp, "%s]\n", print_state->need_sep ? "\n" : "");
306
306
}
···
370
370
{
371
371
struct json_print_state *print_state = ps;
372
372
bool need_sep = false;
373
-
FILE *fp = print_state->fp;
373
+
FILE *fp = print_state->common.fp;
374
374
struct strbuf buf;
375
375
376
376
strbuf_init(&buf, 0);
···
446
446
{
447
447
struct json_print_state *print_state = ps;
448
448
bool need_sep = false;
449
-
FILE *fp = print_state->fp;
449
+
FILE *fp = print_state->common.fp;
450
450
struct strbuf buf;
451
451
452
452
strbuf_init(&buf, 0);
···
521
521
.fp = stdout,
522
522
.desc = true,
523
523
};
524
-
struct print_state json_ps = {
525
-
.fp = stdout,
524
+
struct json_print_state json_ps = {
525
+
.common = {
526
+
.fp = stdout,
527
+
},
526
528
};
527
-
void *ps = &default_ps;
529
+
struct print_state *ps = &default_ps;
528
530
struct print_callbacks print_cb = {
529
531
.print_start = default_print_start,
530
532
.print_end = default_print_end,
···
574
572
argc = parse_options(argc, argv, list_options, list_usage,
575
573
PARSE_OPT_STOP_AT_NON_OPTION);
576
574
575
+
if (json)
576
+
ps = &json_ps.common;
577
+
577
578
if (output_path) {
578
-
default_ps.fp = fopen(output_path, "w");
579
-
json_ps.fp = default_ps.fp;
579
+
ps->fp = fopen(output_path, "w");
580
580
}
581
581
582
582
setup_pager();
···
594
590
.print_metric = json_print_metric,
595
591
.skip_duplicate_pmus = json_skip_duplicate_pmus,
596
592
};
597
-
ps = &json_ps;
598
593
} else {
599
-
default_ps.last_topic = strdup("");
600
-
assert(default_ps.last_topic);
601
-
default_ps.visited_metrics = strlist__new(NULL, NULL);
602
-
assert(default_ps.visited_metrics);
594
+
ps->last_topic = strdup("");
595
+
assert(ps->last_topic);
596
+
ps->visited_metrics = strlist__new(NULL, NULL);
597
+
assert(ps->visited_metrics);
603
598
if (unit_name)
604
-
default_ps.pmu_glob = strdup(unit_name);
599
+
ps->pmu_glob = strdup(unit_name);
605
600
else if (cputype) {
606
601
const struct perf_pmu *pmu = perf_pmus__pmu_for_pmu_filter(cputype);
607
602
···
609
606
ret = -1;
610
607
goto out;
611
608
}
612
-
default_ps.pmu_glob = strdup(pmu->name);
609
+
ps->pmu_glob = strdup(pmu->name);
613
610
}
614
611
}
615
612
print_cb.print_start(ps);
616
613
617
614
if (argc == 0) {
618
615
if (!unit_name) {
619
-
default_ps.metrics = true;
620
-
default_ps.metricgroups = true;
616
+
ps->metrics = true;
617
+
ps->metricgroups = true;
621
618
}
622
619
print_events(&print_cb, ps);
623
620
goto out;
···
639
636
default_ps.pmu_glob = old_pmu_glob;
640
637
} else if (strcmp(argv[i], "hw") == 0 ||
641
638
strcmp(argv[i], "hardware") == 0) {
642
-
char *old_event_glob = default_ps.event_glob;
639
+
char *old_event_glob = ps->event_glob;
643
640
644
-
default_ps.event_glob = strdup("legacy hardware");
645
-
if (!default_ps.event_glob) {
641
+
ps->event_glob = strdup("legacy hardware");
642
+
if (!ps->event_glob) {
646
643
ret = -1;
647
644
goto out;
648
645
}
649
646
perf_pmus__print_pmu_events(&print_cb, ps);
650
-
zfree(&default_ps.event_glob);
651
-
default_ps.event_glob = old_event_glob;
647
+
zfree(&ps->event_glob);
648
+
ps->event_glob = old_event_glob;
652
649
} else if (strcmp(argv[i], "sw") == 0 ||
653
650
strcmp(argv[i], "software") == 0) {
654
-
char *old_pmu_glob = default_ps.pmu_glob;
651
+
char *old_pmu_glob = ps->pmu_glob;
655
652
static const char * const sw_globs[] = { "software", "tool" };
656
653
657
654
for (size_t j = 0; j < ARRAY_SIZE(sw_globs); j++) {
658
-
default_ps.pmu_glob = strdup(sw_globs[j]);
659
-
if (!default_ps.pmu_glob) {
655
+
ps->pmu_glob = strdup(sw_globs[j]);
656
+
if (!ps->pmu_glob) {
660
657
ret = -1;
661
658
goto out;
662
659
}
663
660
perf_pmus__print_pmu_events(&print_cb, ps);
664
-
zfree(&default_ps.pmu_glob);
661
+
zfree(&ps->pmu_glob);
665
662
}
666
-
default_ps.pmu_glob = old_pmu_glob;
663
+
ps->pmu_glob = old_pmu_glob;
667
664
} else if (strcmp(argv[i], "cache") == 0 ||
668
665
strcmp(argv[i], "hwcache") == 0) {
669
-
char *old_event_glob = default_ps.event_glob;
666
+
char *old_event_glob = ps->event_glob;
670
667
671
-
default_ps.event_glob = strdup("legacy cache");
672
-
if (!default_ps.event_glob) {
668
+
ps->event_glob = strdup("legacy cache");
669
+
if (!ps->event_glob) {
673
670
ret = -1;
674
671
goto out;
675
672
}
676
673
perf_pmus__print_pmu_events(&print_cb, ps);
677
-
zfree(&default_ps.event_glob);
678
-
default_ps.event_glob = old_event_glob;
674
+
zfree(&ps->event_glob);
675
+
ps->event_glob = old_event_glob;
679
676
} else if (strcmp(argv[i], "pmu") == 0) {
680
-
default_ps.exclude_abi = true;
677
+
ps->exclude_abi = true;
681
678
perf_pmus__print_pmu_events(&print_cb, ps);
682
-
default_ps.exclude_abi = false;
679
+
ps->exclude_abi = false;
683
680
} else if (strcmp(argv[i], "sdt") == 0)
684
681
print_sdt_events(&print_cb, ps);
685
682
else if (strcmp(argv[i], "metric") == 0 || strcmp(argv[i], "metrics") == 0) {
686
-
default_ps.metricgroups = false;
687
-
default_ps.metrics = true;
683
+
ps->metricgroups = false;
684
+
ps->metrics = true;
688
685
metricgroup__print(&print_cb, ps);
689
686
} else if (strcmp(argv[i], "metricgroup") == 0 ||
690
687
strcmp(argv[i], "metricgroups") == 0) {
691
-
default_ps.metricgroups = true;
692
-
default_ps.metrics = false;
688
+
ps->metricgroups = true;
689
+
ps->metrics = false;
693
690
metricgroup__print(&print_cb, ps);
694
691
}
695
692
#ifdef HAVE_LIBPFM
···
697
694
print_libpfm_events(&print_cb, ps);
698
695
#endif
699
696
else if ((sep = strchr(argv[i], ':')) != NULL) {
700
-
char *old_pmu_glob = default_ps.pmu_glob;
701
-
char *old_event_glob = default_ps.event_glob;
697
+
char *old_pmu_glob = ps->pmu_glob;
698
+
char *old_event_glob = ps->event_glob;
702
699
703
-
default_ps.event_glob = strdup(argv[i]);
704
-
if (!default_ps.event_glob) {
700
+
ps->event_glob = strdup(argv[i]);
701
+
if (!ps->event_glob) {
705
702
ret = -1;
706
703
goto out;
707
704
}
708
705
709
-
default_ps.pmu_glob = strdup("tracepoint");
710
-
if (!default_ps.pmu_glob) {
711
-
zfree(&default_ps.event_glob);
706
+
ps->pmu_glob = strdup("tracepoint");
707
+
if (!ps->pmu_glob) {
708
+
zfree(&ps->event_glob);
712
709
ret = -1;
713
710
goto out;
714
711
}
715
712
perf_pmus__print_pmu_events(&print_cb, ps);
716
-
zfree(&default_ps.pmu_glob);
717
-
default_ps.pmu_glob = old_pmu_glob;
713
+
zfree(&ps->pmu_glob);
714
+
ps->pmu_glob = old_pmu_glob;
718
715
print_sdt_events(&print_cb, ps);
719
-
default_ps.metrics = true;
720
-
default_ps.metricgroups = true;
716
+
ps->metrics = true;
717
+
ps->metricgroups = true;
721
718
metricgroup__print(&print_cb, ps);
722
-
zfree(&default_ps.event_glob);
723
-
default_ps.event_glob = old_event_glob;
719
+
zfree(&ps->event_glob);
720
+
ps->event_glob = old_event_glob;
724
721
} else {
725
722
if (asprintf(&s, "*%s*", argv[i]) < 0) {
726
723
printf("Critical: Not enough memory! Trying to continue...\n");
727
724
continue;
728
725
}
729
-
default_ps.event_glob = s;
726
+
ps->event_glob = s;
730
727
perf_pmus__print_pmu_events(&print_cb, ps);
731
728
print_sdt_events(&print_cb, ps);
732
-
default_ps.metrics = true;
733
-
default_ps.metricgroups = true;
729
+
ps->metrics = true;
730
+
ps->metricgroups = true;
734
731
metricgroup__print(&print_cb, ps);
735
732
free(s);
736
733
}
···
738
735
739
736
out:
740
737
print_cb.print_end(ps);
741
-
free(default_ps.pmu_glob);
742
-
free(default_ps.last_topic);
743
-
free(default_ps.last_metricgroups);
744
-
strlist__delete(default_ps.visited_metrics);
738
+
free(ps->pmu_glob);
739
+
free(ps->last_topic);
740
+
free(ps->last_metricgroups);
741
+
strlist__delete(ps->visited_metrics);
745
742
if (output_path)
746
-
fclose(default_ps.fp);
743
+
fclose(ps->fp);
747
744
748
745
return ret;
749
746
}