]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - tools/perf/pmu-events/jevents.c
eed09346a72afab1ede36b7b3b507f3dc5d62a84
1 #define _XOPEN_SOURCE 500 /* needed for nftw() */
2 #define _GNU_SOURCE /* needed for asprintf() */
4 /* Parse event JSON files */
7 * Copyright (c) 2014, Intel Corporation
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions are met:
13 * 1. Redistributions of source code must retain the above copyright notice,
14 * this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
31 * OF THE POSSIBILITY OF SUCH DAMAGE.
43 #include <sys/time.h> /* getrlimit */
44 #include <sys/resource.h> /* getrlimit */
51 #ifndef __maybe_unused
52 #define __maybe_unused __attribute__((unused))
58 int eprintf(int level
, int var
, const char *fmt
, ...)
69 ret
= vfprintf(stderr
, fmt
, args
);
76 __attribute__((weak
)) char *get_cpu_str(void)
81 static void addfield(char *map
, char **dst
, const char *sep
,
82 const char *a
, jsmntok_t
*bt
)
84 unsigned int len
= strlen(a
) + 1 + strlen(sep
);
85 int olen
= *dst
? strlen(*dst
) : 0;
86 int blen
= bt
? json_len(bt
) : 0;
89 out
= realloc(*dst
, len
+ olen
+ blen
);
91 /* Don't add field in this case */
102 strncat(*dst
, map
+ bt
->start
, blen
);
105 static void fixname(char *s
)
111 static void fixdesc(char *s
)
113 char *e
= s
+ strlen(s
);
115 /* Remove trailing dots that look ugly in perf list */
117 while (e
>= s
&& isspace(*e
))
123 static struct msrmap
{
127 { "0x3F6", "ldlat=" },
128 { "0x1A6", "offcore_rsp=" },
129 { "0x1A7", "offcore_rsp=" },
130 { "0x3F7", "frontend=" },
134 static struct field
{
138 { "UMask", "umask=" },
139 { "CounterMask", "cmask=" },
140 { "Invert", "inv=" },
141 { "AnyThread", "any=" },
142 { "EdgeDetect", "edge=" },
143 { "SampleAfterValue", "period=" },
147 static void cut_comma(char *map
, jsmntok_t
*newval
)
151 /* Cut off everything after comma */
152 for (i
= newval
->start
; i
< newval
->end
; i
++) {
158 static int match_field(char *map
, jsmntok_t
*field
, int nz
,
159 char **event
, jsmntok_t
*val
)
162 jsmntok_t newval
= *val
;
164 for (f
= fields
; f
->field
; f
++)
165 if (json_streq(map
, field
, f
->field
) && nz
) {
166 cut_comma(map
, &newval
);
167 addfield(map
, event
, ",", f
->kernel
, &newval
);
173 static struct msrmap
*lookup_msr(char *map
, jsmntok_t
*val
)
175 jsmntok_t newval
= *val
;
179 cut_comma(map
, &newval
);
180 for (i
= 0; msrmap
[i
].num
; i
++)
181 if (json_streq(map
, &newval
, msrmap
[i
].num
))
185 pr_err("%s: Unknown MSR in event file %.*s\n", prog
,
186 json_len(val
), map
+ val
->start
);
195 { "CBO", "uncore_cbox" },
196 { "QPI LL", "uncore_qpi" },
197 { "SBO", "uncore_sbox" },
201 static const char *field_to_perf(struct map
*table
, char *map
, jsmntok_t
*val
)
205 for (i
= 0; table
[i
].json
; i
++) {
206 if (json_streq(map
, val
, table
[i
].json
))
207 return table
[i
].perf
;
212 #define EXPECT(e, t, m) do { if (!(e)) { \
213 jsmntok_t *loc = (t); \
214 if (!(t)->start && (t) > tokens) \
216 pr_err("%s:%d: " m ", got %s\n", fn, \
217 json_line(map, loc), \
222 #define TOPIC_DEPTH 256
223 static char *topic_array
[TOPIC_DEPTH
];
224 static int topic_level
;
226 static char *get_topic(void)
228 char *tp_old
, *tp
= NULL
;
231 for (i
= 0; i
< topic_level
+ 1; i
++) {
235 n
= asprintf(&tp
, "%s%s", tp
?: "", topic_array
[i
]);
237 pr_info("%s: asprintf() error %s\n", prog
);
243 for (i
= 0; i
< (int) strlen(tp
); i
++) {
257 static int add_topic(int level
, char *bname
)
263 if (level
>= TOPIC_DEPTH
)
266 topic
= strdup(bname
);
268 pr_info("%s: strdup() error %s for file %s\n", prog
,
269 strerror(errno
), bname
);
273 free(topic_array
[topic_level
]);
274 topic_array
[topic_level
] = topic
;
279 struct perf_entry_data
{
284 static int close_table
;
286 static void print_events_table_prefix(FILE *fp
, const char *tblname
)
288 fprintf(fp
, "struct pmu_event %s[] = {\n", tblname
);
292 static int print_events_table_entry(void *data
, char *name
, char *event
,
293 char *desc
, char *long_desc
,
294 char *pmu
, char *unit
, char *perpkg
)
296 struct perf_entry_data
*pd
= data
;
297 FILE *outfp
= pd
->outfp
;
298 char *topic
= pd
->topic
;
301 * TODO: Remove formatting chars after debugging to reduce
304 fprintf(outfp
, "{\n");
306 fprintf(outfp
, "\t.name = \"%s\",\n", name
);
307 fprintf(outfp
, "\t.event = \"%s\",\n", event
);
308 fprintf(outfp
, "\t.desc = \"%s\",\n", desc
);
309 fprintf(outfp
, "\t.topic = \"%s\",\n", topic
);
310 if (long_desc
&& long_desc
[0])
311 fprintf(outfp
, "\t.long_desc = \"%s\",\n", long_desc
);
313 fprintf(outfp
, "\t.pmu = \"%s\",\n", pmu
);
315 fprintf(outfp
, "\t.unit = \"%s\",\n", unit
);
317 fprintf(outfp
, "\t.perpkg = \"%s\",\n", perpkg
);
318 fprintf(outfp
, "},\n");
323 static void print_events_table_suffix(FILE *outfp
)
325 fprintf(outfp
, "{\n");
327 fprintf(outfp
, "\t.name = 0,\n");
328 fprintf(outfp
, "\t.event = 0,\n");
329 fprintf(outfp
, "\t.desc = 0,\n");
331 fprintf(outfp
, "},\n");
332 fprintf(outfp
, "};\n");
336 static struct fixed
{
340 { "inst_retired.any", "event=0xc0" },
341 { "inst_retired.any_p", "event=0xc0" },
342 { "cpu_clk_unhalted.ref", "event=0x0,umask=0x03" },
343 { "cpu_clk_unhalted.thread", "event=0x3c" },
344 { "cpu_clk_unhalted.thread_any", "event=0x3c,any=1" },
349 * Handle different fixed counter encodings between JSON and perf.
351 static char *real_event(const char *name
, char *event
)
355 for (i
= 0; fixed
[i
].name
; i
++)
356 if (!strcasecmp(name
, fixed
[i
].name
))
357 return (char *)fixed
[i
].event
;
361 /* Call func with each event in the json file */
362 int json_events(const char *fn
,
363 int (*func
)(void *data
, char *name
, char *event
, char *desc
,
365 char *pmu
, char *unit
, char *perpkg
),
370 jsmntok_t
*tokens
, *tok
;
378 tokens
= parse_json(fn
, &map
, &size
, &len
);
381 EXPECT(tokens
->type
== JSMN_ARRAY
, tokens
, "expected top level array");
383 for (i
= 0; i
< tokens
->size
; i
++) {
384 char *event
= NULL
, *desc
= NULL
, *name
= NULL
;
385 char *long_desc
= NULL
;
386 char *extra_desc
= NULL
;
391 unsigned long long eventcode
= 0;
392 struct msrmap
*msr
= NULL
;
393 jsmntok_t
*msrval
= NULL
;
394 jsmntok_t
*precise
= NULL
;
395 jsmntok_t
*obj
= tok
++;
397 EXPECT(obj
->type
== JSMN_OBJECT
, obj
, "expected object");
398 for (j
= 0; j
< obj
->size
; j
+= 2) {
399 jsmntok_t
*field
, *val
;
403 EXPECT(field
->type
== JSMN_STRING
, tok
+ j
,
404 "Expected field name");
406 EXPECT(val
->type
== JSMN_STRING
, tok
+ j
+ 1,
407 "Expected string value");
409 nz
= !json_streq(map
, val
, "0");
410 if (match_field(map
, field
, nz
, &event
, val
)) {
412 } else if (json_streq(map
, field
, "EventCode")) {
414 addfield(map
, &code
, "", "", val
);
415 eventcode
|= strtoul(code
, NULL
, 0);
417 } else if (json_streq(map
, field
, "ExtSel")) {
419 addfield(map
, &code
, "", "", val
);
420 eventcode
|= strtoul(code
, NULL
, 0) << 21;
422 } else if (json_streq(map
, field
, "EventName")) {
423 addfield(map
, &name
, "", "", val
);
424 } else if (json_streq(map
, field
, "BriefDescription")) {
425 addfield(map
, &desc
, "", "", val
);
427 } else if (json_streq(map
, field
,
428 "PublicDescription")) {
429 addfield(map
, &long_desc
, "", "", val
);
431 } else if (json_streq(map
, field
, "PEBS") && nz
) {
433 } else if (json_streq(map
, field
, "MSRIndex") && nz
) {
434 msr
= lookup_msr(map
, val
);
435 } else if (json_streq(map
, field
, "MSRValue")) {
437 } else if (json_streq(map
, field
, "Errata") &&
438 !json_streq(map
, val
, "null")) {
439 addfield(map
, &extra_desc
, ". ",
440 " Spec update: ", val
);
441 } else if (json_streq(map
, field
, "Data_LA") && nz
) {
442 addfield(map
, &extra_desc
, ". ",
443 " Supports address when precise",
445 } else if (json_streq(map
, field
, "Unit")) {
449 ppmu
= field_to_perf(unit_to_pmu
, map
, val
);
454 pmu
= strdup("uncore_");
455 addfield(map
, &pmu
, "", "", val
);
456 for (s
= pmu
; *s
; s
++)
459 addfield(map
, &desc
, ". ", "Unit: ", NULL
);
460 addfield(map
, &desc
, "", pmu
, NULL
);
461 } else if (json_streq(map
, field
, "Filter")) {
462 addfield(map
, &filter
, "", "", val
);
463 } else if (json_streq(map
, field
, "ScaleUnit")) {
464 addfield(map
, &unit
, "", "", val
);
465 } else if (json_streq(map
, field
, "PerPkg")) {
466 addfield(map
, &perpkg
, "", "", val
);
468 /* ignore unknown fields */
470 if (precise
&& desc
&& !strstr(desc
, "(Precise Event)")) {
471 if (json_streq(map
, precise
, "2"))
472 addfield(map
, &extra_desc
, " ",
473 "(Must be precise)", NULL
);
475 addfield(map
, &extra_desc
, " ",
476 "(Precise event)", NULL
);
478 snprintf(buf
, sizeof buf
, "event=%#llx", eventcode
);
479 addfield(map
, &event
, ",", buf
, NULL
);
480 if (desc
&& extra_desc
)
481 addfield(map
, &desc
, " ", extra_desc
, NULL
);
482 if (long_desc
&& extra_desc
)
483 addfield(map
, &long_desc
, " ", extra_desc
, NULL
);
485 addfield(map
, &event
, ",", filter
, NULL
);
487 addfield(map
, &event
, ",", msr
->pname
, msrval
);
490 err
= func(data
, name
, real_event(name
, event
), desc
, long_desc
,
505 EXPECT(tok
- tokens
== len
, tok
, "unexpected objects at end");
508 free_json(map
, size
, tokens
);
512 static char *file_name_to_table_name(char *fname
)
520 * Ensure tablename starts with alphabetic character.
521 * Derive rest of table name from basename of the JSON file,
522 * replacing hyphens and stripping out .json suffix.
524 n
= asprintf(&tblname
, "pme_%s", basename(fname
));
526 pr_info("%s: asprintf() error %s for file %s\n", prog
,
527 strerror(errno
), fname
);
531 for (i
= 0; i
< strlen(tblname
); i
++) {
539 } else if (!isalnum(c
) && c
!= '_') {
540 pr_err("%s: Invalid character '%c' in file name %s\n",
541 prog
, c
, basename(fname
));
551 static void print_mapping_table_prefix(FILE *outfp
)
553 fprintf(outfp
, "struct pmu_events_map pmu_events_map[] = {\n");
556 static void print_mapping_table_suffix(FILE *outfp
)
559 * Print the terminating, NULL entry.
561 fprintf(outfp
, "{\n");
562 fprintf(outfp
, "\t.cpuid = 0,\n");
563 fprintf(outfp
, "\t.version = 0,\n");
564 fprintf(outfp
, "\t.type = 0,\n");
565 fprintf(outfp
, "\t.table = 0,\n");
566 fprintf(outfp
, "},\n");
568 /* and finally, the closing curly bracket for the struct */
569 fprintf(outfp
, "};\n");
572 static int process_mapfile(FILE *outfp
, char *fpath
)
581 pr_info("%s: Processing mapfile %s\n", prog
, fpath
);
587 mapfp
= fopen(fpath
, "r");
589 pr_info("%s: Error %s opening %s\n", prog
, strerror(errno
),
594 print_mapping_table_prefix(outfp
);
596 /* Skip first line (header) */
597 p
= fgets(line
, n
, mapfp
);
603 char *cpuid
, *version
, *type
, *fname
;
606 p
= fgets(line
, n
, mapfp
);
610 if (line
[0] == '#' || line
[0] == '\n')
613 if (line
[strlen(line
)-1] != '\n') {
614 /* TODO Deal with lines longer than 16K */
615 pr_info("%s: Mapfile %s: line %d too long, aborting\n",
616 prog
, fpath
, line_num
);
619 line
[strlen(line
)-1] = '\0';
621 cpuid
= strtok_r(p
, ",", &save
);
622 version
= strtok_r(NULL
, ",", &save
);
623 fname
= strtok_r(NULL
, ",", &save
);
624 type
= strtok_r(NULL
, ",", &save
);
626 tblname
= file_name_to_table_name(fname
);
627 fprintf(outfp
, "{\n");
628 fprintf(outfp
, "\t.cpuid = \"%s\",\n", cpuid
);
629 fprintf(outfp
, "\t.version = \"%s\",\n", version
);
630 fprintf(outfp
, "\t.type = \"%s\",\n", type
);
633 * CHECK: We can't use the type (eg "core") field in the
634 * table name. For us to do that, we need to somehow tweak
635 * the other caller of file_name_to_table(), process_json()
636 * to determine the type. process_json() file has no way
637 * of knowing these are "core" events unless file name has
638 * core in it. If filename has core in it, we can safely
639 * ignore the type field here also.
641 fprintf(outfp
, "\t.table = %s\n", tblname
);
642 fprintf(outfp
, "},\n");
646 print_mapping_table_suffix(outfp
);
651 * If we fail to locate/process JSON and map files, create a NULL mapping
652 * table. This would at least allow perf to build even if we can't find/use
655 static void create_empty_mapping(const char *output_file
)
659 pr_info("%s: Creating empty pmu_events_map[] table\n", prog
);
661 /* Truncate file to clear any partial writes to it */
662 outfp
= fopen(output_file
, "w");
668 fprintf(outfp
, "#include \"../../pmu-events/pmu-events.h\"\n");
669 print_mapping_table_prefix(outfp
);
670 print_mapping_table_suffix(outfp
);
674 static int get_maxfds(void)
678 if (getrlimit(RLIMIT_NOFILE
, &rlim
) == 0)
679 return min((int)rlim
.rlim_max
/ 2, 512);
685 * nftw() doesn't let us pass an argument to the processing function,
686 * so use a global variables.
688 static FILE *eventsfp
;
689 static char *mapfile
;
691 static int process_one_file(const char *fpath
, const struct stat
*sb
,
692 int typeflag
, struct FTW
*ftwbuf
)
694 char *tblname
, *bname
= (char *) fpath
+ ftwbuf
->base
;
695 int is_dir
= typeflag
== FTW_D
;
696 int is_file
= typeflag
== FTW_F
;
697 int level
= ftwbuf
->level
;
700 pr_debug("%s %d %7jd %-20s %s\n",
701 is_file
? "f" : is_dir
? "d" : "x",
702 level
, sb
->st_size
, bname
, fpath
);
708 /* model directory, reset topic */
709 if (level
== 1 && is_dir
) {
711 print_events_table_suffix(eventsfp
);
714 * Drop file name suffix. Replace hyphens with underscores.
715 * Fail if file name contains any alphanum characters besides
718 tblname
= file_name_to_table_name(bname
);
720 pr_info("%s: Error determining table name for %s\n", prog
,
725 print_events_table_prefix(eventsfp
, tblname
);
730 * Save the mapfile name for now. We will process mapfile
731 * after processing all JSON files (so we can write out the
732 * mapping table after all PMU events tables).
734 * TODO: Allow for multiple mapfiles? Punt for now.
736 if (level
== 1 && is_file
) {
737 if (!strncmp(bname
, "mapfile.csv", 11)) {
739 pr_info("%s: Many mapfiles? Using %s, ignoring %s\n",
740 prog
, mapfile
, fpath
);
742 mapfile
= strdup(fpath
);
747 pr_info("%s: Ignoring file %s\n", prog
, fpath
);
752 * If the file name does not have a .json extension,
753 * ignore it. It could be a readme.txt for instance.
756 char *suffix
= bname
+ strlen(bname
) - 5;
758 if (strncmp(suffix
, ".json", 5)) {
759 pr_info("%s: Ignoring file without .json suffix %s\n", prog
,
765 if (level
> 1 && add_topic(level
, bname
))
769 * Assume all other files are JSON files.
771 * If mapfile refers to 'power7_core.json', we create a table
772 * named 'power7_core'. Any inconsistencies between the mapfile
773 * and directory tree could result in build failure due to table
774 * names not being found.
776 * Atleast for now, be strict with processing JSON file names.
777 * i.e. if JSON file name cannot be mapped to C-style table name,
781 struct perf_entry_data data
= {
782 .topic
= get_topic(),
786 err
= json_events(fpath
, print_events_table_entry
, &data
);
795 #define PATH_MAX 4096
799 * Starting in directory 'start_dirname', find the "mapfile.csv" and
800 * the set of JSON files for the architecture 'arch'.
802 * From each JSON file, create a C-style "PMU events table" from the
803 * JSON file (see struct pmu_event).
805 * From the mapfile, create a mapping between the CPU revisions and
806 * PMU event tables (see struct pmu_events_map).
808 * Write out the PMU events tables and the mapping table to pmu-event.c.
810 * If unable to process the JSON or arch files, create an empty mapping
811 * table so we can continue to build/use perf even if we cannot use the
814 int main(int argc
, char *argv
[])
818 char ldirname
[PATH_MAX
];
821 const char *output_file
;
822 const char *start_dirname
;
824 prog
= basename(argv
[0]);
826 pr_err("Usage: %s <arch> <starting_dir> <output_file>\n", prog
);
831 start_dirname
= argv
[2];
832 output_file
= argv
[3];
835 verbose
= atoi(argv
[4]);
837 eventsfp
= fopen(output_file
, "w");
839 pr_err("%s Unable to create required file %s (%s)\n",
840 prog
, output_file
, strerror(errno
));
844 /* Include pmu-events.h first */
845 fprintf(eventsfp
, "#include \"../../pmu-events/pmu-events.h\"\n");
847 sprintf(ldirname
, "%s/%s", start_dirname
, arch
);
850 * The mapfile allows multiple CPUids to point to the same JSON file,
851 * so, not sure if there is a need for symlinks within the pmu-events
854 * For now, treat symlinks of JSON files as regular files and create
855 * separate tables for each symlink (presumably, each symlink refers
856 * to specific version of the CPU).
859 maxfds
= get_maxfds();
861 rc
= nftw(ldirname
, process_one_file
, maxfds
, 0);
863 pr_info("%s: Error walking file tree %s\n", prog
, ldirname
);
870 print_events_table_suffix(eventsfp
);
873 pr_info("%s: No CPU->JSON mapping?\n", prog
);
877 if (process_mapfile(eventsfp
, mapfile
)) {
878 pr_info("%s: Error processing mapfile %s\n", prog
, mapfile
);
886 create_empty_mapping(output_file
);