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.
44 #include <sys/time.h> /* getrlimit */
45 #include <sys/resource.h> /* getrlimit */
48 #include <linux/list.h>
56 int eprintf(int level
, int var
, const char *fmt
, ...)
67 ret
= vfprintf(stderr
, fmt
, args
);
74 __attribute__((weak
)) char *get_cpu_str(void)
79 static void addfield(char *map
, char **dst
, const char *sep
,
80 const char *a
, jsmntok_t
*bt
)
82 unsigned int len
= strlen(a
) + 1 + strlen(sep
);
83 int olen
= *dst
? strlen(*dst
) : 0;
84 int blen
= bt
? json_len(bt
) : 0;
87 out
= realloc(*dst
, len
+ olen
+ blen
);
89 /* Don't add field in this case */
100 strncat(*dst
, map
+ bt
->start
, blen
);
103 static void fixname(char *s
)
109 static void fixdesc(char *s
)
111 char *e
= s
+ strlen(s
);
113 /* Remove trailing dots that look ugly in perf list */
115 while (e
>= s
&& isspace(*e
))
121 /* Add escapes for '\' so they are proper C strings. */
122 static char *fixregex(char *s
)
129 /* Count the number of '\' in string */
130 for (p
= s
; *p
; p
++) {
139 /* allocate space for a new string */
140 fixed
= (char *) malloc(len
+ 1);
144 /* copy over the characters */
146 for (p
= s
; *p
; p
++) {
158 static struct msrmap
{
162 { "0x3F6", "ldlat=" },
163 { "0x1A6", "offcore_rsp=" },
164 { "0x1A7", "offcore_rsp=" },
165 { "0x3F7", "frontend=" },
169 static struct field
{
173 { "UMask", "umask=" },
174 { "CounterMask", "cmask=" },
175 { "Invert", "inv=" },
176 { "AnyThread", "any=" },
177 { "EdgeDetect", "edge=" },
178 { "SampleAfterValue", "period=" },
179 { "FCMask", "fc_mask=" },
180 { "PortMask", "ch_mask=" },
184 static void cut_comma(char *map
, jsmntok_t
*newval
)
188 /* Cut off everything after comma */
189 for (i
= newval
->start
; i
< newval
->end
; i
++) {
195 static int match_field(char *map
, jsmntok_t
*field
, int nz
,
196 char **event
, jsmntok_t
*val
)
199 jsmntok_t newval
= *val
;
201 for (f
= fields
; f
->field
; f
++)
202 if (json_streq(map
, field
, f
->field
) && nz
) {
203 cut_comma(map
, &newval
);
204 addfield(map
, event
, ",", f
->kernel
, &newval
);
210 static struct msrmap
*lookup_msr(char *map
, jsmntok_t
*val
)
212 jsmntok_t newval
= *val
;
216 cut_comma(map
, &newval
);
217 for (i
= 0; msrmap
[i
].num
; i
++)
218 if (json_streq(map
, &newval
, msrmap
[i
].num
))
222 pr_err("%s: Unknown MSR in event file %.*s\n", prog
,
223 json_len(val
), map
+ val
->start
);
232 { "CBO", "uncore_cbox" },
233 { "QPI LL", "uncore_qpi" },
234 { "SBO", "uncore_sbox" },
235 { "iMPH-U", "uncore_arb" },
239 static const char *field_to_perf(struct map
*table
, char *map
, jsmntok_t
*val
)
243 for (i
= 0; table
[i
].json
; i
++) {
244 if (json_streq(map
, val
, table
[i
].json
))
245 return table
[i
].perf
;
250 #define EXPECT(e, t, m) do { if (!(e)) { \
251 jsmntok_t *loc = (t); \
252 if (!(t)->start && (t) > tokens) \
254 pr_err("%s:%d: " m ", got %s\n", fn, \
255 json_line(map, loc), \
263 static char *get_topic(void)
268 /* tp is free'd in process_one_file() */
269 i
= asprintf(&tp
, "%s", topic
);
271 pr_info("%s: asprintf() error %s\n", prog
);
275 for (i
= 0; i
< (int) strlen(tp
); i
++) {
289 static int add_topic(char *bname
)
292 topic
= strdup(bname
);
294 pr_info("%s: strdup() error %s for file %s\n", prog
,
295 strerror(errno
), bname
);
301 struct perf_entry_data
{
306 static int close_table
;
308 static void print_events_table_prefix(FILE *fp
, const char *tblname
)
310 fprintf(fp
, "struct pmu_event %s[] = {\n", tblname
);
314 static int print_events_table_entry(void *data
, char *name
, char *event
,
315 char *desc
, char *long_desc
,
316 char *pmu
, char *unit
, char *perpkg
,
318 char *metric_name
, char *metric_group
)
320 struct perf_entry_data
*pd
= data
;
321 FILE *outfp
= pd
->outfp
;
322 char *topic
= pd
->topic
;
325 * TODO: Remove formatting chars after debugging to reduce
328 fprintf(outfp
, "{\n");
331 fprintf(outfp
, "\t.name = \"%s\",\n", name
);
333 fprintf(outfp
, "\t.event = \"%s\",\n", event
);
334 fprintf(outfp
, "\t.desc = \"%s\",\n", desc
);
335 fprintf(outfp
, "\t.topic = \"%s\",\n", topic
);
336 if (long_desc
&& long_desc
[0])
337 fprintf(outfp
, "\t.long_desc = \"%s\",\n", long_desc
);
339 fprintf(outfp
, "\t.pmu = \"%s\",\n", pmu
);
341 fprintf(outfp
, "\t.unit = \"%s\",\n", unit
);
343 fprintf(outfp
, "\t.perpkg = \"%s\",\n", perpkg
);
345 fprintf(outfp
, "\t.metric_expr = \"%s\",\n", metric_expr
);
347 fprintf(outfp
, "\t.metric_name = \"%s\",\n", metric_name
);
349 fprintf(outfp
, "\t.metric_group = \"%s\",\n", metric_group
);
350 fprintf(outfp
, "},\n");
355 struct event_struct
{
356 struct list_head list
;
369 #define ADD_EVENT_FIELD(field) do { if (field) { \
370 es->field = strdup(field); \
375 #define FREE_EVENT_FIELD(field) free(es->field)
377 #define TRY_FIXUP_FIELD(field) do { if (es->field && !*field) {\
378 *field = strdup(es->field); \
383 #define FOR_ALL_EVENT_STRUCT_FIELDS(op) do { \
396 static LIST_HEAD(arch_std_events
);
398 static void free_arch_std_events(void)
400 struct event_struct
*es
, *next
;
402 list_for_each_entry_safe(es
, next
, &arch_std_events
, list
) {
403 FOR_ALL_EVENT_STRUCT_FIELDS(FREE_EVENT_FIELD
);
409 static int save_arch_std_events(void *data
, char *name
, char *event
,
410 char *desc
, char *long_desc
, char *pmu
,
411 char *unit
, char *perpkg
, char *metric_expr
,
412 char *metric_name
, char *metric_group
)
414 struct event_struct
*es
;
415 struct stat
*sb
= data
;
417 es
= malloc(sizeof(*es
));
420 memset(es
, 0, sizeof(*es
));
421 FOR_ALL_EVENT_STRUCT_FIELDS(ADD_EVENT_FIELD
);
422 list_add_tail(&es
->list
, &arch_std_events
);
425 FOR_ALL_EVENT_STRUCT_FIELDS(FREE_EVENT_FIELD
);
430 static void print_events_table_suffix(FILE *outfp
)
432 fprintf(outfp
, "{\n");
434 fprintf(outfp
, "\t.name = 0,\n");
435 fprintf(outfp
, "\t.event = 0,\n");
436 fprintf(outfp
, "\t.desc = 0,\n");
438 fprintf(outfp
, "},\n");
439 fprintf(outfp
, "};\n");
443 static struct fixed
{
447 { "inst_retired.any", "event=0xc0" },
448 { "inst_retired.any_p", "event=0xc0" },
449 { "cpu_clk_unhalted.ref", "event=0x0,umask=0x03" },
450 { "cpu_clk_unhalted.thread", "event=0x3c" },
451 { "cpu_clk_unhalted.thread_any", "event=0x3c,any=1" },
456 * Handle different fixed counter encodings between JSON and perf.
458 static char *real_event(const char *name
, char *event
)
465 for (i
= 0; fixed
[i
].name
; i
++)
466 if (!strcasecmp(name
, fixed
[i
].name
))
467 return (char *)fixed
[i
].event
;
472 try_fixup(const char *fn
, char *arch_std
, char **event
, char **desc
,
473 char **name
, char **long_desc
, char **pmu
, char **filter
,
474 char **perpkg
, char **unit
, char **metric_expr
, char **metric_name
,
475 char **metric_group
, unsigned long long eventcode
)
477 /* try to find matching event from arch standard values */
478 struct event_struct
*es
;
480 list_for_each_entry(es
, &arch_std_events
, list
) {
481 if (!strcmp(arch_std
, es
->name
)) {
482 if (!eventcode
&& es
->event
) {
483 /* allow EventCode to be overridden */
487 FOR_ALL_EVENT_STRUCT_FIELDS(TRY_FIXUP_FIELD
);
492 pr_err("%s: could not find matching %s for %s\n",
497 /* Call func with each event in the json file */
498 int json_events(const char *fn
,
499 int (*func
)(void *data
, char *name
, char *event
, char *desc
,
501 char *pmu
, char *unit
, char *perpkg
,
503 char *metric_name
, char *metric_group
),
508 jsmntok_t
*tokens
, *tok
;
516 tokens
= parse_json(fn
, &map
, &size
, &len
);
519 EXPECT(tokens
->type
== JSMN_ARRAY
, tokens
, "expected top level array");
521 for (i
= 0; i
< tokens
->size
; i
++) {
522 char *event
= NULL
, *desc
= NULL
, *name
= NULL
;
523 char *long_desc
= NULL
;
524 char *extra_desc
= NULL
;
529 char *metric_expr
= NULL
;
530 char *metric_name
= NULL
;
531 char *metric_group
= NULL
;
532 char *arch_std
= NULL
;
533 unsigned long long eventcode
= 0;
534 struct msrmap
*msr
= NULL
;
535 jsmntok_t
*msrval
= NULL
;
536 jsmntok_t
*precise
= NULL
;
537 jsmntok_t
*obj
= tok
++;
539 EXPECT(obj
->type
== JSMN_OBJECT
, obj
, "expected object");
540 for (j
= 0; j
< obj
->size
; j
+= 2) {
541 jsmntok_t
*field
, *val
;
546 EXPECT(field
->type
== JSMN_STRING
, tok
+ j
,
547 "Expected field name");
549 EXPECT(val
->type
== JSMN_STRING
, tok
+ j
+ 1,
550 "Expected string value");
552 nz
= !json_streq(map
, val
, "0");
553 if (match_field(map
, field
, nz
, &event
, val
)) {
555 } else if (json_streq(map
, field
, "EventCode")) {
557 addfield(map
, &code
, "", "", val
);
558 eventcode
|= strtoul(code
, NULL
, 0);
560 } else if (json_streq(map
, field
, "ExtSel")) {
562 addfield(map
, &code
, "", "", val
);
563 eventcode
|= strtoul(code
, NULL
, 0) << 21;
565 } else if (json_streq(map
, field
, "EventName")) {
566 addfield(map
, &name
, "", "", val
);
567 } else if (json_streq(map
, field
, "BriefDescription")) {
568 addfield(map
, &desc
, "", "", val
);
570 } else if (json_streq(map
, field
,
571 "PublicDescription")) {
572 addfield(map
, &long_desc
, "", "", val
);
574 } else if (json_streq(map
, field
, "PEBS") && nz
) {
576 } else if (json_streq(map
, field
, "MSRIndex") && nz
) {
577 msr
= lookup_msr(map
, val
);
578 } else if (json_streq(map
, field
, "MSRValue")) {
580 } else if (json_streq(map
, field
, "Errata") &&
581 !json_streq(map
, val
, "null")) {
582 addfield(map
, &extra_desc
, ". ",
583 " Spec update: ", val
);
584 } else if (json_streq(map
, field
, "Data_LA") && nz
) {
585 addfield(map
, &extra_desc
, ". ",
586 " Supports address when precise",
588 } else if (json_streq(map
, field
, "Unit")) {
591 ppmu
= field_to_perf(unit_to_pmu
, map
, val
);
596 pmu
= strdup("uncore_");
597 addfield(map
, &pmu
, "", "", val
);
598 for (s
= pmu
; *s
; s
++)
601 addfield(map
, &desc
, ". ", "Unit: ", NULL
);
602 addfield(map
, &desc
, "", pmu
, NULL
);
603 addfield(map
, &desc
, "", " ", NULL
);
604 } else if (json_streq(map
, field
, "Filter")) {
605 addfield(map
, &filter
, "", "", val
);
606 } else if (json_streq(map
, field
, "ScaleUnit")) {
607 addfield(map
, &unit
, "", "", val
);
608 } else if (json_streq(map
, field
, "PerPkg")) {
609 addfield(map
, &perpkg
, "", "", val
);
610 } else if (json_streq(map
, field
, "MetricName")) {
611 addfield(map
, &metric_name
, "", "", val
);
612 } else if (json_streq(map
, field
, "MetricGroup")) {
613 addfield(map
, &metric_group
, "", "", val
);
614 } else if (json_streq(map
, field
, "MetricExpr")) {
615 addfield(map
, &metric_expr
, "", "", val
);
616 for (s
= metric_expr
; *s
; s
++)
618 } else if (json_streq(map
, field
, "ArchStdEvent")) {
619 addfield(map
, &arch_std
, "", "", val
);
620 for (s
= arch_std
; *s
; s
++)
623 /* ignore unknown fields */
625 if (precise
&& desc
&& !strstr(desc
, "(Precise Event)")) {
626 if (json_streq(map
, precise
, "2"))
627 addfield(map
, &extra_desc
, " ",
628 "(Must be precise)", NULL
);
630 addfield(map
, &extra_desc
, " ",
631 "(Precise event)", NULL
);
633 snprintf(buf
, sizeof buf
, "event=%#llx", eventcode
);
634 addfield(map
, &event
, ",", buf
, NULL
);
635 if (desc
&& extra_desc
)
636 addfield(map
, &desc
, " ", extra_desc
, NULL
);
637 if (long_desc
&& extra_desc
)
638 addfield(map
, &long_desc
, " ", extra_desc
, NULL
);
640 addfield(map
, &event
, ",", filter
, NULL
);
642 addfield(map
, &event
, ",", msr
->pname
, msrval
);
648 * An arch standard event is referenced, so try to
649 * fixup any unassigned values.
651 err
= try_fixup(fn
, arch_std
, &event
, &desc
, &name
,
652 &long_desc
, &pmu
, &filter
, &perpkg
,
653 &unit
, &metric_expr
, &metric_name
,
654 &metric_group
, eventcode
);
658 err
= func(data
, name
, real_event(name
, event
), desc
, long_desc
,
659 pmu
, unit
, perpkg
, metric_expr
, metric_name
, metric_group
);
679 EXPECT(tok
- tokens
== len
, tok
, "unexpected objects at end");
682 free_json(map
, size
, tokens
);
686 static char *file_name_to_table_name(char *fname
)
694 * Ensure tablename starts with alphabetic character.
695 * Derive rest of table name from basename of the JSON file,
696 * replacing hyphens and stripping out .json suffix.
698 n
= asprintf(&tblname
, "pme_%s", fname
);
700 pr_info("%s: asprintf() error %s for file %s\n", prog
,
701 strerror(errno
), fname
);
705 for (i
= 0; i
< strlen(tblname
); i
++) {
708 if (c
== '-' || c
== '/')
713 } else if (!isalnum(c
) && c
!= '_') {
714 pr_err("%s: Invalid character '%c' in file name %s\n",
715 prog
, c
, basename(fname
));
725 static void print_mapping_table_prefix(FILE *outfp
)
727 fprintf(outfp
, "struct pmu_events_map pmu_events_map[] = {\n");
730 static void print_mapping_table_suffix(FILE *outfp
)
733 * Print the terminating, NULL entry.
735 fprintf(outfp
, "{\n");
736 fprintf(outfp
, "\t.cpuid = 0,\n");
737 fprintf(outfp
, "\t.version = 0,\n");
738 fprintf(outfp
, "\t.type = 0,\n");
739 fprintf(outfp
, "\t.table = 0,\n");
740 fprintf(outfp
, "},\n");
742 /* and finally, the closing curly bracket for the struct */
743 fprintf(outfp
, "};\n");
746 static int process_mapfile(FILE *outfp
, char *fpath
)
755 pr_info("%s: Processing mapfile %s\n", prog
, fpath
);
761 mapfp
= fopen(fpath
, "r");
763 pr_info("%s: Error %s opening %s\n", prog
, strerror(errno
),
768 print_mapping_table_prefix(outfp
);
770 /* Skip first line (header) */
771 p
= fgets(line
, n
, mapfp
);
777 char *cpuid
, *version
, *type
, *fname
;
780 p
= fgets(line
, n
, mapfp
);
784 if (line
[0] == '#' || line
[0] == '\n')
787 if (line
[strlen(line
)-1] != '\n') {
788 /* TODO Deal with lines longer than 16K */
789 pr_info("%s: Mapfile %s: line %d too long, aborting\n",
790 prog
, fpath
, line_num
);
793 line
[strlen(line
)-1] = '\0';
795 cpuid
= fixregex(strtok_r(p
, ",", &save
));
796 version
= strtok_r(NULL
, ",", &save
);
797 fname
= strtok_r(NULL
, ",", &save
);
798 type
= strtok_r(NULL
, ",", &save
);
800 tblname
= file_name_to_table_name(fname
);
801 fprintf(outfp
, "{\n");
802 fprintf(outfp
, "\t.cpuid = \"%s\",\n", cpuid
);
803 fprintf(outfp
, "\t.version = \"%s\",\n", version
);
804 fprintf(outfp
, "\t.type = \"%s\",\n", type
);
807 * CHECK: We can't use the type (eg "core") field in the
808 * table name. For us to do that, we need to somehow tweak
809 * the other caller of file_name_to_table(), process_json()
810 * to determine the type. process_json() file has no way
811 * of knowing these are "core" events unless file name has
812 * core in it. If filename has core in it, we can safely
813 * ignore the type field here also.
815 fprintf(outfp
, "\t.table = %s\n", tblname
);
816 fprintf(outfp
, "},\n");
820 print_mapping_table_suffix(outfp
);
825 * If we fail to locate/process JSON and map files, create a NULL mapping
826 * table. This would at least allow perf to build even if we can't find/use
829 static void create_empty_mapping(const char *output_file
)
833 pr_info("%s: Creating empty pmu_events_map[] table\n", prog
);
835 /* Truncate file to clear any partial writes to it */
836 outfp
= fopen(output_file
, "w");
842 fprintf(outfp
, "#include \"../../pmu-events/pmu-events.h\"\n");
843 print_mapping_table_prefix(outfp
);
844 print_mapping_table_suffix(outfp
);
848 static int get_maxfds(void)
852 if (getrlimit(RLIMIT_NOFILE
, &rlim
) == 0)
853 return min((int)rlim
.rlim_max
/ 2, 512);
859 * nftw() doesn't let us pass an argument to the processing function,
860 * so use a global variables.
862 static FILE *eventsfp
;
863 static char *mapfile
;
865 static int is_leaf_dir(const char *fpath
)
875 while ((dir
= readdir(d
)) != NULL
) {
876 if (!strcmp(dir
->d_name
, ".") || !strcmp(dir
->d_name
, ".."))
879 if (dir
->d_type
== DT_DIR
) {
882 } else if (dir
->d_type
== DT_UNKNOWN
) {
886 sprintf(path
, "%s/%s", fpath
, dir
->d_name
);
890 if (S_ISDIR(st
.st_mode
)) {
902 static int is_json_file(const char *name
)
906 if (strlen(name
) < 5)
909 suffix
= name
+ strlen(name
) - 5;
911 if (strncmp(suffix
, ".json", 5) == 0)
916 static int preprocess_arch_std_files(const char *fpath
, const struct stat
*sb
,
917 int typeflag
, struct FTW
*ftwbuf
)
919 int level
= ftwbuf
->level
;
920 int is_file
= typeflag
== FTW_F
;
922 if (level
== 1 && is_file
&& is_json_file(fpath
))
923 return json_events(fpath
, save_arch_std_events
, (void *)sb
);
928 static int process_one_file(const char *fpath
, const struct stat
*sb
,
929 int typeflag
, struct FTW
*ftwbuf
)
931 char *tblname
, *bname
;
932 int is_dir
= typeflag
== FTW_D
;
933 int is_file
= typeflag
== FTW_F
;
934 int level
= ftwbuf
->level
;
937 if (level
== 2 && is_dir
) {
939 * For level 2 directory, bname will include parent name,
940 * like vendor/platform. So search back from platform dir
943 bname
= (char *) fpath
+ ftwbuf
->base
- 2;
951 bname
= (char *) fpath
+ ftwbuf
->base
;
953 pr_debug("%s %d %7jd %-20s %s\n",
954 is_file
? "f" : is_dir
? "d" : "x",
955 level
, sb
->st_size
, bname
, fpath
);
957 /* base dir or too deep */
958 if (level
== 0 || level
> 3)
962 /* model directory, reset topic */
963 if ((level
== 1 && is_dir
&& is_leaf_dir(fpath
)) ||
964 (level
== 2 && is_dir
)) {
966 print_events_table_suffix(eventsfp
);
969 * Drop file name suffix. Replace hyphens with underscores.
970 * Fail if file name contains any alphanum characters besides
973 tblname
= file_name_to_table_name(bname
);
975 pr_info("%s: Error determining table name for %s\n", prog
,
980 print_events_table_prefix(eventsfp
, tblname
);
985 * Save the mapfile name for now. We will process mapfile
986 * after processing all JSON files (so we can write out the
987 * mapping table after all PMU events tables).
990 if (level
== 1 && is_file
) {
991 if (!strcmp(bname
, "mapfile.csv")) {
992 mapfile
= strdup(fpath
);
996 pr_info("%s: Ignoring file %s\n", prog
, fpath
);
1001 * If the file name does not have a .json extension,
1002 * ignore it. It could be a readme.txt for instance.
1005 if (!is_json_file(bname
)) {
1006 pr_info("%s: Ignoring file without .json suffix %s\n", prog
,
1012 if (level
> 1 && add_topic(bname
))
1016 * Assume all other files are JSON files.
1018 * If mapfile refers to 'power7_core.json', we create a table
1019 * named 'power7_core'. Any inconsistencies between the mapfile
1020 * and directory tree could result in build failure due to table
1021 * names not being found.
1023 * Atleast for now, be strict with processing JSON file names.
1024 * i.e. if JSON file name cannot be mapped to C-style table name,
1028 struct perf_entry_data data
= {
1029 .topic
= get_topic(),
1033 err
= json_events(fpath
, print_events_table_entry
, &data
);
1042 #define PATH_MAX 4096
1046 * Starting in directory 'start_dirname', find the "mapfile.csv" and
1047 * the set of JSON files for the architecture 'arch'.
1049 * From each JSON file, create a C-style "PMU events table" from the
1050 * JSON file (see struct pmu_event).
1052 * From the mapfile, create a mapping between the CPU revisions and
1053 * PMU event tables (see struct pmu_events_map).
1055 * Write out the PMU events tables and the mapping table to pmu-event.c.
1057 int main(int argc
, char *argv
[])
1061 char ldirname
[PATH_MAX
];
1064 const char *output_file
;
1065 const char *start_dirname
;
1068 prog
= basename(argv
[0]);
1070 pr_err("Usage: %s <arch> <starting_dir> <output_file>\n", prog
);
1075 start_dirname
= argv
[2];
1076 output_file
= argv
[3];
1079 verbose
= atoi(argv
[4]);
1081 eventsfp
= fopen(output_file
, "w");
1083 pr_err("%s Unable to create required file %s (%s)\n",
1084 prog
, output_file
, strerror(errno
));
1088 sprintf(ldirname
, "%s/%s", start_dirname
, arch
);
1090 /* If architecture does not have any event lists, bail out */
1091 if (stat(ldirname
, &stbuf
) < 0) {
1092 pr_info("%s: Arch %s has no PMU event lists\n", prog
, arch
);
1096 /* Include pmu-events.h first */
1097 fprintf(eventsfp
, "#include \"../../pmu-events/pmu-events.h\"\n");
1100 * The mapfile allows multiple CPUids to point to the same JSON file,
1101 * so, not sure if there is a need for symlinks within the pmu-events
1104 * For now, treat symlinks of JSON files as regular files and create
1105 * separate tables for each symlink (presumably, each symlink refers
1106 * to specific version of the CPU).
1109 maxfds
= get_maxfds();
1111 rc
= nftw(ldirname
, preprocess_arch_std_files
, maxfds
, 0);
1112 if (rc
&& verbose
) {
1113 pr_info("%s: Error preprocessing arch standard files %s\n",
1116 } else if (rc
< 0) {
1117 /* Make build fail */
1118 free_arch_std_events();
1124 rc
= nftw(ldirname
, process_one_file
, maxfds
, 0);
1125 if (rc
&& verbose
) {
1126 pr_info("%s: Error walking file tree %s\n", prog
, ldirname
);
1128 } else if (rc
< 0) {
1129 /* Make build fail */
1130 free_arch_std_events();
1137 print_events_table_suffix(eventsfp
);
1140 pr_info("%s: No CPU->JSON mapping?\n", prog
);
1144 if (process_mapfile(eventsfp
, mapfile
)) {
1145 pr_info("%s: Error processing mapfile %s\n", prog
, mapfile
);
1146 /* Make build fail */
1154 create_empty_mapping(output_file
);
1155 free_arch_std_events();