1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright (c) 2019, Joyent, Inc.
14 */
15
16 /*
17 * This program transforms Intel perfmon and AMD PMC data files into C files and
18 * manual pages.
19 */
20
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <unistd.h>
24 #include <err.h>
25 #include <libgen.h>
26 #include <libnvpair.h>
27 #include <strings.h>
28 #include <errno.h>
29 #include <limits.h>
30 #include <sys/mman.h>
31 #include <sys/param.h>
32 #include <assert.h>
33 #include <ctype.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <dirent.h>
38
39 #include <json_nvlist.h>
40
41 #define EXIT_USAGE 2
42 #define CPROC_MAX_STEPPINGS 16
43
44 typedef enum {
45 CPCGEN_MODE_UNKNOWN = 0,
46 CPCGEN_MODE_INTEL,
47 CPCGEN_MODE_AMD
48 } cpc_mode_t;
49
50 typedef struct cpc_proc {
51 struct cpc_proc *cproc_next;
52 uint_t cproc_family;
53 uint_t cproc_model;
54 uint_t cproc_nsteps;
55 uint_t cproc_steppings[CPROC_MAX_STEPPINGS];
56 } cpc_proc_t;
57
58 typedef enum cpc_file_type {
59 CPC_FILE_CORE = 1 << 0,
60 CPC_FILE_OFF_CORE = 1 << 1,
61 CPC_FILE_UNCORE = 1 << 2,
62 CPC_FILE_FP_MATH = 1 << 3,
63 CPC_FILE_UNCORE_EXP = 1 << 4
64 } cpc_type_t;
65
66 typedef struct cpc_map {
67 struct cpc_map *cmap_next;
68 cpc_type_t cmap_type;
69 nvlist_t *cmap_data;
70 char *cmap_path;
71 const char *cmap_name;
72 cpc_proc_t *cmap_procs;
73 } cpc_map_t;
74
75 typedef struct cpc_whitelist {
76 const char *cwhite_short;
77 const char *cwhite_human;
78 uint_t cwhite_mask;
79 } cpc_whitelist_t;
80
81 /*
82 * List of architectures that we support generating this data for. This is done
83 * so that processors that illumos doesn't support or run on aren't generated
84 * (generally the Xeon Phi).
85 */
86 static cpc_whitelist_t cpcgen_intel_whitelist[] = {
87 /* Nehalem */
88 { "NHM-EP", "nhm_ep", CPC_FILE_CORE },
89 { "NHM-EX", "nhm_ex", CPC_FILE_CORE },
90 /* Westmere */
91 { "WSM-EP-DP", "wsm_ep_dp", CPC_FILE_CORE },
92 { "WSM-EP-SP", "wsm_ep_sp", CPC_FILE_CORE },
93 { "WSM-EX", "wsm_ex", CPC_FILE_CORE },
94 /* Sandy Bridge */
95 { "SNB", "snb", CPC_FILE_CORE },
96 { "JKT", "jkt", CPC_FILE_CORE },
97 /* Ivy Bridge */
98 { "IVB", "ivb", CPC_FILE_CORE },
99 { "IVT", "ivt", CPC_FILE_CORE },
100 /* Haswell */
101 { "HSW", "hsw", CPC_FILE_CORE },
102 { "HSX", "hsx", CPC_FILE_CORE },
103 /* Broadwell */
104 { "BDW", "bdw", CPC_FILE_CORE },
105 { "BDW-DE", "bdw_de", CPC_FILE_CORE },
106 { "BDX", "bdx", CPC_FILE_CORE },
107 /* Skylake */
108 { "SKL", "skl", CPC_FILE_CORE },
109 { "SKX", "skx", CPC_FILE_CORE },
110 /* Cascade Lake */
111 { "CLX", "clx", CPC_FILE_CORE },
112 /* Atom */
113 { "BNL", "bnl", CPC_FILE_CORE },
114 { "SLM", "slm", CPC_FILE_CORE },
115 { "GLM", "glm", CPC_FILE_CORE },
116 { "GLP", "glp", CPC_FILE_CORE },
117 { NULL }
118 };
119
120 typedef struct cpc_papi {
121 const char *cpapi_intc;
122 const char *cpapi_papi;
123 } cpc_papi_t;
124
125 /*
126 * This table maps events with an Intel specific name to the corresponding PAPI
127 * name. There may be multiple Intel events which map to the same PAPI event.
128 * This is usually because different processors have different names for an
129 * event. We use the title as opposed to the event codes because those can
130 * change somewhat arbitrarily between processor generations.
131 */
132 static cpc_papi_t cpcgen_intel_papi_map[] = {
133 { "CPU_CLK_UNHALTED.THREAD_P", "PAPI_tot_cyc" },
134 { "INST_RETIRED.ANY_P", "PAPI_tot_ins" },
135 { "BR_INST_RETIRED.ALL_BRANCHES", "PAPI_br_ins" },
136 { "BR_MISP_RETIRED.ALL_BRANCHES", "PAPI_br_msp" },
137 { "BR_INST_RETIRED.CONDITIONAL", "PAPI_br_cn" },
138 { "CYCLE_ACTIVITY.CYCLES_L1D_MISS", "PAPI_l1_dcm" },
139 { "L1I.HITS", "PAPI_l1_ich" },
140 { "ICACHE.HIT", "PAPI_l1_ich" },
141 { "L1I.MISS", "PAPI_L1_icm" },
142 { "ICACHE.MISSES", "PAPI_l1_icm" },
143 { "L1I.READS", "PAPI_l1_ica" },
144 { "ICACHE.ACCESSES", "PAPI_l1_ica" },
145 { "L1I.READS", "PAPI_l1_icr" },
146 { "ICACHE.ACCESSES", "PAPI_l1_icr" },
147 { "L2_RQSTS.CODE_RD_MISS", "PAPI_l2_icm" },
148 { "L2_RQSTS.MISS", "PAPI_l2_tcm" },
149 { "ITLB_MISSES.MISS_CAUSES_A_WALK", "PAPI_tlb_im" },
150 { "DTLB_LOAD_MISSES.MISS_CAUSES_A_WALK", "PAPI_tlb_dm" },
151 { "PAGE_WALKS.D_SIDE_WALKS", "PAPI_tlb_dm" },
152 { "PAGE_WALKS.I_SIDE_WALKS", "PAPI_tlb_im" },
153 { "PAGE_WALKS.WALKS", "PAPI_tlb_tl" },
154 { "INST_QUEUE_WRITES", "PAPI_tot_iis" },
155 { "MEM_INST_RETIRED.STORES" "PAPI_sr_ins" },
156 { "MEM_INST_RETIRED.LOADS" "PAPI_ld_ins" },
157 { NULL, NULL }
158 };
159
160 typedef struct cpcgen_ops {
161 void (*cgen_op_gather)(const char *, const char *);
162 void (*cgen_op_common)(int);
163 char *(*cgen_op_name)(cpc_map_t *);
164 boolean_t (*cgen_op_skip)(nvlist_t *, const char *, uint_t);
165 boolean_t (*cgen_op_file_before)(FILE *, cpc_map_t *);
166 boolean_t (*cgen_op_file_after)(FILE *, cpc_map_t *);
167 boolean_t (*cgen_op_event)(FILE *, nvlist_t *, const char *, uint32_t);
168 } cpcgen_ops_t;
169
170 static cpcgen_ops_t cpcgen_ops;
171 static const char *cpcgen_intel_mapfile = "/mapfile.csv";
172 static const char *cpcgen_progname;
173 static cpc_map_t *cpcgen_maps;
174 static cpc_mode_t cpcgen_mode = CPCGEN_MODE_UNKNOWN;
175
176 /*
177 * Constants used for generating data.
178 */
179 /* BEGIN CSTYLED */
180 static const char *cpcgen_cfile_intel_header = ""
181 "/*\n"
182 " * Copyright (c) 2018, Intel Corporation\n"
183 " * Copyright (c) 2018, Joyent, Inc\n"
184 " * All rights reserved.\n"
185 " *\n"
186 " * Redistribution and use in source and binary forms, with or without\n"
187 " * modification, are permitted provided that the following conditions are met:\n"
188 " * \n"
189 " * 1. Redistributions of source code must retain the above copyright notice,\n"
190 " * this list of conditions and the following disclaimer.\n"
191 " * \n"
192 " * 2. Redistributions in binary form must reproduce the above copyright \n"
193 " * notice, this list of conditions and the following disclaimer in the\n"
194 " * documentation and/or other materials provided with the distribution.\n"
195 " * \n"
196 " * 3. Neither the name of the Intel Corporation nor the names of its \n"
197 " * contributors may be used to endorse or promote products derived from\n"
198 " * this software without specific prior written permission.\n"
199 " *\n"
200 " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n"
201 " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n"
202 " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
203 " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n"
204 " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
205 " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
206 " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n"
207 " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n"
208 " * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n"
209 " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
210 " * POSSIBILITY OF SUCH DAMAGE.\n"
211 " *\n"
212 " * This file was automatically generated by cpcgen from the data file\n"
213 " * data/perfmon%s\n"
214 " *\n"
215 " * Do not modify this file. Your changes will be lost!\n"
216 " */\n"
217 "\n";
218 /* END CSTYLED */
219
220 static const char *cpcgen_cfile_intel_table_start = ""
221 "#include <core_pcbe_table.h>\n"
222 "\n"
223 "const struct events_table_t pcbe_core_events_%s[] = {\n";
224
225 static const char *cpcgen_cfile_intel_table_end = ""
226 "\t{ NT_END, 0, 0, \"\" }\n"
227 "};\n";
228
229 /* BEGIN CSTYLED */
230 static const char *cpcgen_manual_intel_intel_header = ""
231 ".\\\" Copyright (c) 2018, Intel Corporation \n"
232 ".\\\" Copyright (c) 2018, Joyent, Inc.\n"
233 ".\\\" All rights reserved.\n"
234 ".\\\"\n"
235 ".\\\" Redistribution and use in source and binary forms, with or without \n"
236 ".\\\" modification, are permitted provided that the following conditions are met:\n"
237 ".\\\"\n"
238 ".\\\" 1. Redistributions of source code must retain the above copyright notice,\n"
239 ".\\\" this list of conditions and the following disclaimer.\n"
240 ".\\\"\n"
241 ".\\\" 2. Redistributions in binary form must reproduce the above copyright\n"
242 ".\\\" notice, this list of conditions and the following disclaimer in the\n"
243 ".\\\" documentation and/or other materials provided with the distribution.\n"
244 ".\\\"\n"
245 ".\\\" 3. Neither the name of the Intel Corporation nor the names of its\n"
246 ".\\\" contributors may be used to endorse or promote products derived from\n"
247 ".\\\" this software without specific prior written permission.\n"
248 ".\\\"\n"
249 ".\\\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n"
250 ".\\\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n"
251 ".\\\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
252 ".\\\" ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n"
253 ".\\\" LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
254 ".\\\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
255 ".\\\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n"
256 ".\\\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n"
257 ".\\\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n"
258 ".\\\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
259 ".\\\" POSSIBILITY OF SUCH DAMAGE.\n"
260 ".\\\"\n"
261 ".\\\" This file was automatically generated by cpcgen from the data file\n"
262 ".\\\" data/perfmon%s\n"
263 ".\\\"\n"
264 ".\\\" Do not modify this file. Your changes will be lost!\n"
265 ".\\\"\n"
266 ".\\\" We would like to thank Intel for providing the perfmon data for use in\n"
267 ".\\\" our manual pages.\n"
268 ".Dd June 18, 2018\n"
269 ".Dt %s_EVENTS 3CPC\n"
270 ".Os\n"
271 ".Sh NAME\n"
272 ".Nm %s_events\n"
273 ".Nd processor model specific performance counter events\n"
274 ".Sh DESCRIPTION\n"
275 "This manual page describes events specific to the following Intel CPU\n"
276 "models and is derived from Intel's perfmon data.\n"
277 "For more information, please consult the Intel Software Developer's Manual "
278 "or Intel's perfmon website.\n"
279 ".Pp\n"
280 "CPU models described by this document:\n"
281 ".Bl -bullet\n";
282 /* END CSTYLED */
283
284 static const char *cpcgen_manual_intel_data = ""
285 ".El\n"
286 ".Pp\n"
287 "The following events are supported:\n"
288 ".Bl -tag -width Sy\n";
289
290 static const char *cpcgen_manual_intel_trailer = ""
291 ".El\n"
292 ".Sh SEE ALSO\n"
293 ".Xr cpc 3CPC\n"
294 ".Pp\n"
295 ".Lk https://download.01.org/perfmon/index/";
296
297 static const char *cpcgen_cfile_cddl_header = ""
298 "/*\n"
299 " * This file and its contents are supplied under the terms of the\n"
300 " * Common Development and Distribution License (\"CDDL\"), version 1.0.\n"
301 " * You may only use this file in accordance with the terms of version\n"
302 " * 1.0 of the CDDL.\n"
303 " *\n"
304 " * A full copy of the text of the CDDL should have accompanied this\n"
305 " * source. A copy of the CDDL is also available via the Internet at\n"
306 " * http://www.illumos.org/license/CDDL.\n"
307 " */\n"
308 "\n"
309 "/*\n"
310 " * Copyright 2019 Joyent, Inc\n"
311 " */\n"
312 "\n"
313 "/*\n"
314 " * This file was automatically generated by cpcgen.\n"
315 " */\n"
316 "\n"
317 "/*\n"
318 " * Do not modify this file. Your changes will be lost!\n"
319 " */\n"
320 "\n";
321
322 static const char *cpcgen_manual_amd_header = ""
323 ".\\\" This file was automatically generated by cpcgen from the data file\n"
324 ".\\\" data/amdpmc/%s\n"
325 ".\\\"\n"
326 ".\\\" Do not modify this file. Your changes will be lost!\n"
327 ".\\\"\n"
328 ".\\\" We would like to thank AMD for providing the PMC data for use in\n"
329 ".\\\" our manual pages.\n"
330 ".Dd March 25, 2019\n"
331 ".Dt AMD_%s_EVENTS 3CPC\n"
332 ".Os\n"
333 ".Sh NAME\n"
334 ".Nm amd_%s_events\n"
335 ".Nd AMD family %s processor performance monitoring events\n"
336 ".Sh DESCRIPTION\n"
337 "This manual page describes events specfic to AMD family %s processors.\n"
338 "For more information, please consult the appropriate AMD BIOS and Kernel\n"
339 "Developer's guide or Open-Source Register Reference manual.\n"
340 ".Pp\n"
341 "Each of the events listed below includes the AMD mnemonic which matches\n"
342 "the name found in the AMD manual and a brief summary of the event.\n"
343 "If available, a more detailed description of the event follows and then\n"
344 "any additional unit values that modify the event.\n"
345 "Each unit can be combined to create a new event in the system by placing\n"
346 "the '.' character between the event name and the unit name.\n"
347 ".Pp\n"
348 "The following events are supported:\n"
349 ".Bl -tag -width Sy\n";
350
351 static const char *cpcgen_manual_amd_trailer = ""
352 ".El\n"
353 ".Sh SEE ALSO\n"
354 ".Xr cpc 3CPC\n";
355
356 static const char *cpcgen_cfile_amd_header = ""
357 "/*\n"
358 " * This file was automatically generated by cpcgen from the data file\n"
359 " * data/perfmon%s\n"
360 " *\n"
361 " * Do not modify this file. Your changes will be lost!\n"
362 " */\n"
363 "\n";
364
365 static const char *cpcgen_cfile_amd_table_start = ""
366 "#include <opteron_pcbe_table.h>\n"
367 "#include <sys/null.h>\n"
368 "\n"
369 "const amd_event_t opteron_pcbe_%s_events[] = {\n";
370
371 static const char *cpcgen_cfile_amd_table_end = ""
372 "\t{ NULL, 0, 0 }\n"
373 "};\n";
374
375 static cpc_map_t *
376 cpcgen_map_lookup(const char *path)
377 {
378 cpc_map_t *m;
379
380 for (m = cpcgen_maps; m != NULL; m = m->cmap_next) {
381 if (strcmp(path, m->cmap_path) == 0) {
382 return (m);
383 }
384 }
385
386 return (NULL);
387 }
388
389 /*
390 * Parse a string of the form 'GenuineIntel-6-2E' and get out the family and
391 * model.
392 */
393 static void
394 cpcgen_parse_model(char *fsr, uint_t *family, uint_t *model, uint_t *nstepp,
395 uint_t *steppings)
396 {
397 const char *bstr = "GenuineIntel";
398 const char *brand, *fam, *mod, *step;
399 char *last;
400 long l;
401 uint_t nstep = 0;
402
403 /*
404 * Tokeninze the string. There may be an optional stepping portion,
405 * which has a range of steppings enclosed by '[' and ']' characters.
406 * While the other parts are required, the stepping may be missing.
407 */
408 if ((brand = strtok_r(fsr, "-", &last)) == NULL ||
409 (fam = strtok_r(NULL, "-", &last)) == NULL ||
410 (mod = strtok_r(NULL, "-", &last)) == NULL) {
411 errx(EXIT_FAILURE, "failed to parse processor id \"%s\"", fsr);
412 }
413 step = strtok_r(NULL, "-", &last);
414
415 if (strcmp(bstr, brand) != 0) {
416 errx(EXIT_FAILURE, "brand string \"%s\" did not match \"%s\"",
417 brand, bstr);
418 }
419
420 errno = 0;
421 l = strtol(fam, &last, 16);
422 if (errno != 0 || l < 0 || l > UINT_MAX || *last != '\0') {
423 errx(EXIT_FAILURE, "failed to parse family \"%s\"", fam);
424 }
425 *family = (uint_t)l;
426
427 l = strtol(mod, &last, 16);
428 if (errno != 0 || l < 0 || l > UINT_MAX || *last != '\0') {
429 errx(EXIT_FAILURE, "failed to parse model \"%s\"", mod);
430 }
431 *model = (uint_t)l;
432
433 if (step == NULL) {
434 *nstepp = 0;
435 return;
436 }
437
438 if (*step != '[' || ((last = strrchr(step, ']')) == NULL)) {
439 errx(EXIT_FAILURE, "failed to parse stepping \"%s\": missing "
440 "stepping range brackets", step);
441 }
442 step++;
443 *last = '\0';
444 while (*step != '\0') {
445 if (!isxdigit(*step)) {
446 errx(EXIT_FAILURE, "failed to parse stepping: invalid "
447 "stepping identifier '0x%x'", *step);
448 }
449
450 if (nstep >= CPROC_MAX_STEPPINGS) {
451 errx(EXIT_FAILURE, "failed to parse stepping: "
452 "encountered too many steppings");
453 }
454
455 switch (*step) {
456 case '0':
457 steppings[nstep] = 0x0;
458 break;
459 case '1':
460 steppings[nstep] = 0x1;
461 break;
462 case '2':
463 steppings[nstep] = 0x2;
464 break;
465 case '3':
466 steppings[nstep] = 0x3;
467 break;
468 case '4':
469 steppings[nstep] = 0x4;
470 break;
471 case '5':
472 steppings[nstep] = 0x5;
473 break;
474 case '6':
475 steppings[nstep] = 0x6;
476 break;
477 case '7':
478 steppings[nstep] = 0x7;
479 break;
480 case '8':
481 steppings[nstep] = 0x8;
482 break;
483 case '9':
484 steppings[nstep] = 0x9;
485 break;
486 case 'a':
487 case 'A':
488 steppings[nstep] = 0xa;
489 break;
490 case 'b':
491 case 'B':
492 steppings[nstep] = 0xb;
493 break;
494 case 'c':
495 case 'C':
496 steppings[nstep] = 0xc;
497 break;
498 case 'd':
499 case 'D':
500 steppings[nstep] = 0xd;
501 break;
502 case 'e':
503 case 'E':
504 steppings[nstep] = 0xe;
505 break;
506 case 'f':
507 case 'F':
508 steppings[nstep] = 0xf;
509 break;
510 default:
511 errx(EXIT_FAILURE, "encountered non-hex stepping "
512 "character: '%c'", *step);
513 }
514 nstep++;
515 step++;
516 }
517
518 *nstepp = nstep;
519 }
520
521 static nvlist_t *
522 cpcgen_read_datafile(const char *datadir, const char *file)
523 {
524 int fd;
525 char *path;
526 struct stat st;
527 void *map;
528 nvlist_t *nvl;
529 nvlist_parse_json_error_t jerr;
530
531 if (asprintf(&path, "%s/%s", datadir, file) == -1) {
532 err(EXIT_FAILURE, "failed to construct path to data file %s",
533 file);
534 }
535
536 if ((fd = open(path, O_RDONLY)) < 0) {
537 err(EXIT_FAILURE, "failed to open data file %s", path);
538 }
539
540 if (fstat(fd, &st) != 0) {
541 err(EXIT_FAILURE, "failed to stat %s", path);
542 }
543
544 if ((map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
545 fd, 0)) == MAP_FAILED) {
546 err(EXIT_FAILURE, "failed to mmap %s", path);
547 }
548
549 if (nvlist_parse_json(map, st.st_size, &nvl, NVJSON_FORCE_INTEGER,
550 &jerr) != 0) {
551 errx(EXIT_FAILURE, "failed to parse file %s at pos %ld: %s",
552 path, jerr.nje_pos, jerr.nje_message);
553 }
554
555 if (munmap(map, st.st_size) != 0) {
556 err(EXIT_FAILURE, "failed to munmap %s", path);
557 }
558
559 if (close(fd) != 0) {
560 err(EXIT_FAILURE, "failed to close data file %s", path);
561 }
562 free(path);
563
564 return (nvl);
565 }
566
567 /*
568 * Check the whitelist to see if we should use this model.
569 */
570 static const char *
571 cpcgen_use_arch(const char *path, cpc_type_t type, const char *platform)
572 {
573 const char *slash;
574 size_t len;
575 uint_t i;
576
577 if (*path != '/') {
578 errx(EXIT_FAILURE, "invalid path in mapfile: \"%s\": missing "
579 "leading '/'", path);
580 }
581 if ((slash = strchr(path + 1, '/')) == NULL) {
582 errx(EXIT_FAILURE, "invalid path in mapfile: \"%s\": missing "
583 "second '/'", path);
584 }
585 /* Account for the last '/' character. */
586 len = slash - path - 1;
587 assert(len > 0);
588
589 for (i = 0; cpcgen_intel_whitelist[i].cwhite_short != NULL; i++) {
590 if (platform != NULL && strcasecmp(platform,
591 cpcgen_intel_whitelist[i].cwhite_short) != 0)
592 continue;
593 if (strncmp(path + 1, cpcgen_intel_whitelist[i].cwhite_short,
594 len) == 0 &&
595 (cpcgen_intel_whitelist[i].cwhite_mask & type) == type) {
596 return (cpcgen_intel_whitelist[i].cwhite_human);
597 }
598 }
599
600 return (NULL);
601 }
602
603 /*
604 * Determine which CPU Vendor we're transmuting data from.
605 */
606 static void
607 cpcgen_determine_vendor(const char *datadir)
608 {
609 char *mappath;
610 struct stat st;
611
612 if (asprintf(&mappath, "%s/%s", datadir, cpcgen_intel_mapfile) == -1) {
613 err(EXIT_FAILURE, "failed to construct path to mapfile");
614 }
615
616 if (stat(mappath, &st) == 0) {
617 cpcgen_mode = CPCGEN_MODE_INTEL;
618 } else {
619 if (errno != ENOENT) {
620 err(EXIT_FAILURE, "stat(2) of %s failed unexpectedly");
621 }
622
623 cpcgen_mode = CPCGEN_MODE_AMD;
624 }
625
626 free(mappath);
627 }
628
629 /*
630 * Read in all the data files that exist for AMD.
631 *
632 * Our family names for AMD systems are based on the family and type so a given
633 * name will look like f17h_core.json.
634 */
635 static void
636 cpcgen_read_amd(const char *datadir, const char *platform)
637 {
638 DIR *dir;
639 struct dirent *d;
640 const char *suffix = ".json";
641 const size_t slen = strlen(suffix);
642
643 if ((dir = opendir(datadir)) == NULL) {
644 err(EXIT_FAILURE, "failed to open directory %s", datadir);
645 }
646
647 while ((d = readdir(dir)) != NULL) {
648 char *name, *c;
649 cpc_map_t *map;
650 nvlist_t *parsed;
651
652 if ((name = strdup(d->d_name)) == NULL) {
653 errx(EXIT_FAILURE, "ran out of memory duplicating "
654 "name %s", d->d_name);
655 }
656 c = strstr(name, suffix);
657
658 if (c == NULL) {
659 free(name);
660 continue;
661 }
662
663 if (*(c + slen) != '\0') {
664 free(name);
665 continue;
666 }
667
668 *c = '\0';
669 c = strchr(name, '_');
670 if (c == NULL) {
671 free(name);
672 continue;
673 }
674 *c = '\0';
675 c++;
676 if (strcmp(c, "core") != 0) {
677 errx(EXIT_FAILURE, "unexpected AMD JSON file name: %s",
678 d->d_name);
679 }
680
681 if (platform != NULL && strcmp(platform, name) != 0) {
682 free(name);
683 continue;
684 }
685
686 if ((map = calloc(1, sizeof (cpc_map_t))) == NULL) {
687 err(EXIT_FAILURE, "failed to allocate space for cpc "
688 "file");
689 }
690
691 parsed = cpcgen_read_datafile(datadir, d->d_name);
692 if ((map->cmap_path = strdup(d->d_name)) == NULL) {
693 err(EXIT_FAILURE, "failed to duplicate path string");
694 }
695 map->cmap_type = CPC_FILE_CORE;
696 map->cmap_data = parsed;
697 map->cmap_name = name;
698 map->cmap_procs = NULL;
699
700 map->cmap_next = cpcgen_maps;
701 cpcgen_maps = map;
702 }
703 }
704
705 /*
706 * Read in the mapfile.csv that is used to map between processor families and
707 * parse this. Each line has a comma separated value.
708 */
709 static void
710 cpcgen_read_intel(const char *datadir, const char *platform)
711 {
712 FILE *map;
713 char *mappath, *last;
714 char *data = NULL;
715 size_t datalen = 0;
716 uint_t lineno;
717
718 if (asprintf(&mappath, "%s/%s", datadir, cpcgen_intel_mapfile) == -1) {
719 err(EXIT_FAILURE, "failed to construct path to mapfile");
720 }
721
722 if ((map = fopen(mappath, "r")) == NULL) {
723 err(EXIT_FAILURE, "failed to open data mapfile %s", mappath);
724 }
725
726 lineno = 0;
727 while (getline(&data, &datalen, map) != -1) {
728 char *fstr, *path, *tstr;
729 const char *name;
730 uint_t family, model, nsteps;
731 uint_t steppings[CPROC_MAX_STEPPINGS];
732
733 cpc_type_t type;
734 cpc_map_t *map;
735 cpc_proc_t *proc;
736
737 /*
738 * The first line contains the header:
739 * Family-model,Version,Filename,EventType
740 */
741 lineno++;
742 if (lineno == 1) {
743 continue;
744 }
745
746 if ((fstr = strtok_r(data, ",", &last)) == NULL ||
747 strtok_r(NULL, ",", &last) == NULL ||
748 (path = strtok_r(NULL, ",", &last)) == NULL ||
749 (tstr = strtok_r(NULL, "\n", &last)) == NULL) {
750 errx(EXIT_FAILURE, "failed to parse mapfile line "
751 "%u in %s", lineno, mappath);
752 }
753
754 cpcgen_parse_model(fstr, &family, &model, &nsteps, steppings);
755
756 if (strcmp(tstr, "core") == 0) {
757 type = CPC_FILE_CORE;
758 } else if (strcmp(tstr, "offcore") == 0) {
759 type = CPC_FILE_OFF_CORE;
760 } else if (strcmp(tstr, "uncore") == 0) {
761 type = CPC_FILE_UNCORE;
762 } else if (strcmp(tstr, "fp_arith_inst") == 0) {
763 type = CPC_FILE_FP_MATH;
764 } else if (strcmp(tstr, "uncore experimental") == 0) {
765 type = CPC_FILE_UNCORE_EXP;
766 } else {
767 errx(EXIT_FAILURE, "unknown file type \"%s\" on line "
768 "%u", tstr, lineno);
769 }
770
771 if ((name = cpcgen_use_arch(path, type, platform)) == NULL)
772 continue;
773
774 if ((map = cpcgen_map_lookup(path)) == NULL) {
775 nvlist_t *parsed;
776
777 parsed = cpcgen_read_datafile(datadir, path);
778
779 if ((map = calloc(1, sizeof (cpc_map_t))) == NULL) {
780 err(EXIT_FAILURE, "failed to allocate space "
781 "for cpc file");
782 }
783
784 if ((map->cmap_path = strdup(path)) == NULL) {
785 err(EXIT_FAILURE, "failed to duplicate path "
786 "string");
787 }
788
789 map->cmap_type = type;
790 map->cmap_data = parsed;
791 map->cmap_name = name;
792 map->cmap_procs = NULL;
793
794 map->cmap_next = cpcgen_maps;
795 cpcgen_maps = map;
796 }
797
798 if ((proc = calloc(1, sizeof (cpc_proc_t))) == NULL) {
799 err(EXIT_FAILURE, "failed to allocate memory for "
800 "family and model tracking");
801 }
802
803 proc->cproc_family = family;
804 proc->cproc_model = model;
805 proc->cproc_nsteps = nsteps;
806 if (nsteps > 0) {
807 bcopy(steppings, proc->cproc_steppings,
808 sizeof (steppings));
809 }
810 proc->cproc_next = map->cmap_procs;
811 map->cmap_procs = proc;
812 }
813
814 if (errno != 0 || ferror(map)) {
815 err(EXIT_FAILURE, "failed to read %s", mappath);
816 }
817
818 if (fclose(map) == EOF) {
819 err(EXIT_FAILURE, "failed to close %s", mappath);
820 }
821 free(data);
822 free(mappath);
823 }
824
825 static char *
826 cpcgen_manual_intel_name(cpc_map_t *map)
827 {
828 char *name;
829
830 if (asprintf(&name, "%s_events.3cpc", map->cmap_name) == -1) {
831 warn("failed to assemble manual page name for %s",
832 map->cmap_path);
833 return (NULL);
834 }
835
836 return (name);
837 }
838
839 static boolean_t
840 cpcgen_manual_intel_file_before(FILE *f, cpc_map_t *map)
841 {
842 size_t i;
843 char *upper;
844 cpc_proc_t *proc;
845
846 if ((upper = strdup(map->cmap_name)) == NULL) {
847 warn("failed to duplicate manual name for %s", map->cmap_name);
848 return (B_FALSE);
849 }
850
851 for (i = 0; upper[i] != '\0'; i++) {
852 upper[i] = toupper(upper[i]);
853 }
854
855 if (fprintf(f, cpcgen_manual_intel_intel_header, map->cmap_path, upper,
856 map->cmap_name) == -1) {
857 warn("failed to write out manual header for %s",
858 map->cmap_name);
859 free(upper);
860 return (B_FALSE);
861 }
862 free(upper);
863
864 for (proc = map->cmap_procs; proc != NULL; proc = proc->cproc_next) {
865 if (proc->cproc_nsteps > 0) {
866 uint_t step;
867
868 for (step = 0; step < proc->cproc_nsteps; step++) {
869 if (fprintf(f, ".It\n.Sy Family 0x%x, Model "
870 "0x%x, Stepping 0x%x\n",
871 proc->cproc_family, proc->cproc_model,
872 proc->cproc_steppings[step]) == -1) {
873 warn("failed to write out model "
874 "information for %s",
875 map->cmap_name);
876 return (B_FALSE);
877 }
878 }
879 } else {
880 if (fprintf(f, ".It\n.Sy Family 0x%x, Model 0x%x\n",
881 proc->cproc_family, proc->cproc_model) == -1) {
882 warn("failed to write out model information "
883 "for %s", map->cmap_name);
884 return (B_FALSE);
885 }
886 }
887 }
888
889 if (fprintf(f, cpcgen_manual_intel_data) == -1) {
890 warn("failed to write out manual header for %s",
891 map->cmap_name);
892 return (B_FALSE);
893 }
894
895 free(upper);
896 return (B_TRUE);
897 }
898
899 static boolean_t
900 cpcgen_manual_intel_file_after(FILE *f, cpc_map_t *map)
901 {
902 if (fprintf(f, cpcgen_manual_intel_trailer) == -1) {
903 warn("failed to write out manual header for %s",
904 map->cmap_name);
905 return (B_FALSE);
906 }
907
908 return (B_TRUE);
909 }
910
911 static boolean_t
912 cpcgen_manual_intel_event(FILE *f, nvlist_t *nvl, const char *path,
913 uint32_t ent)
914 {
915 char *event, *lname, *brief = NULL, *public = NULL, *errata = NULL;
916 size_t i;
917
918 if (nvlist_lookup_string(nvl, "EventName", &event) != 0) {
919 warnx("Found event without 'EventName' property "
920 "in %s, entry %u", path, ent);
921 return (B_FALSE);
922 }
923
924 /*
925 * Intel uses capital names. CPC historically uses lower case names.
926 */
927 if ((lname = strdup(event)) == NULL) {
928 err(EXIT_FAILURE, "failed to duplicate event name %s", event);
929 }
930 for (i = 0; lname[i] != '\0'; i++) {
931 lname[i] = tolower(event[i]);
932 }
933
934 /*
935 * Try to get the other event fields, but if they're not there, don't
936 * worry about it.
937 */
938 (void) nvlist_lookup_string(nvl, "BriefDescription", &brief);
939 (void) nvlist_lookup_string(nvl, "PublicDescription", &public);
940 (void) nvlist_lookup_string(nvl, "Errata", &errata);
941 if (errata != NULL && (strcmp(errata, "0") == 0 ||
942 strcmp(errata, "null") == 0)) {
943 errata = NULL;
944 }
945
946 if (fprintf(f, ".It Sy %s\n", lname) == -1) {
947 warn("failed to write out event entry %s", event);
948 free(lname);
949 return (B_FALSE);
950 }
951
952 if (public != NULL) {
953 if (fprintf(f, "%s\n", public) == -1) {
954 warn("failed to write out event entry %s", event);
955 free(lname);
956 return (B_FALSE);
957 }
958 } else if (brief != NULL) {
959 if (fprintf(f, "%s\n", brief) == -1) {
960 warn("failed to write out event entry %s", event);
961 free(lname);
962 return (B_FALSE);
963 }
964 }
965
966 if (errata != NULL) {
967 if (fprintf(f, ".Pp\nThe following errata may apply to this: "
968 "%s\n", errata) == -1) {
969
970 warn("failed to write out event entry %s", event);
971 free(lname);
972 return (B_FALSE);
973 }
974 }
975
976 free(lname);
977 return (B_TRUE);
978 }
979
980 static char *
981 cpcgen_cfile_intel_name(cpc_map_t *map)
982 {
983 char *name;
984
985 if (asprintf(&name, "core_pcbe_%s.c", map->cmap_name) == -1) {
986 warn("failed to assemble file name for %s", map->cmap_path);
987 return (NULL);
988 }
989
990 return (name);
991 }
992
993 static boolean_t
994 cpcgen_cfile_intel_before(FILE *f, cpc_map_t *map)
995 {
996 if (fprintf(f, cpcgen_cfile_intel_header, map->cmap_path) == -1) {
997 warn("failed to write header to temporary file for %s",
998 map->cmap_path);
999 return (B_FALSE);
1000 }
1001
1002 if (fprintf(f, cpcgen_cfile_intel_table_start, map->cmap_name) == -1) {
1003 warn("failed to write header to temporary file for %s",
1004 map->cmap_path);
1005 return (B_FALSE);
1006 }
1007
1008 return (B_TRUE);
1009 }
1010
1011 static boolean_t
1012 cpcgen_cfile_intel_after(FILE *f, cpc_map_t *map)
1013 {
1014 if (fprintf(f, cpcgen_cfile_intel_table_end) == -1) {
1015 warn("failed to write footer to temporary file for %s",
1016 map->cmap_path);
1017 return (B_FALSE);
1018 }
1019
1020 return (B_TRUE);
1021 }
1022
1023 static boolean_t
1024 cpcgen_cfile_intel_event(FILE *f, nvlist_t *nvl, const char *path, uint_t ent)
1025 {
1026 char *ecode, *umask, *name, *counter, *lname, *cmask;
1027 size_t i;
1028
1029 if (nvlist_lookup_string(nvl, "EventName", &name) != 0) {
1030 warnx("Found event without 'EventName' property "
1031 "in %s, entry %u", path, ent);
1032 return (B_FALSE);
1033 }
1034
1035 if (nvlist_lookup_string(nvl, "EventCode", &ecode) != 0 ||
1036 nvlist_lookup_string(nvl, "UMask", &umask) != 0 ||
1037 nvlist_lookup_string(nvl, "Counter", &counter) != 0) {
1038 warnx("event %s (index %u) from %s, missing "
1039 "required properties for C file translation",
1040 name, ent, path);
1041 return (B_FALSE);
1042 }
1043
1044 /*
1045 * While we could try and parse the counters manually, just do this the
1046 * max power way for now based on all possible values.
1047 */
1048 if (strcmp(counter, "0") == 0 || strcmp(counter, "0,") == 0) {
1049 cmask = "C0";
1050 } else if (strcmp(counter, "1") == 0) {
1051 cmask = "C1";
1052 } else if (strcmp(counter, "2") == 0) {
1053 cmask = "C2";
1054 } else if (strcmp(counter, "3") == 0) {
1055 cmask = "C3";
1056 } else if (strcmp(counter, "0,1") == 0) {
1057 cmask = "C0|C1";
1058 } else if (strcmp(counter, "0,1,2") == 0) {
1059 cmask = "C0|C1|C2";
1060 } else if (strcmp(counter, "0,1,2,3") == 0) {
1061 cmask = "C0|C1|C2|C3";
1062 } else if (strcmp(counter, "0,2,3") == 0) {
1063 cmask = "C0|C2|C3";
1064 } else if (strcmp(counter, "1,2,3") == 0) {
1065 cmask = "C1|C2|C3";
1066 } else if (strcmp(counter, "2,3") == 0) {
1067 cmask = "C2|C3";
1068 } else {
1069 warnx("event %s (index %u) from %s, has unknown "
1070 "counter value \"%s\"", name, ent, path, counter);
1071 return (B_FALSE);
1072 }
1073
1074
1075 /*
1076 * Intel uses capital names. CPC historically uses lower case names.
1077 */
1078 if ((lname = strdup(name)) == NULL) {
1079 err(EXIT_FAILURE, "failed to duplicate event name %s", name);
1080 }
1081 for (i = 0; lname[i] != '\0'; i++) {
1082 lname[i] = tolower(name[i]);
1083 }
1084
1085 if (fprintf(f, "\t{ %s, %s, %s, \"%s\" },\n", ecode, umask, cmask,
1086 lname) == -1) {
1087 warn("failed to write out entry %s from %s", name, path);
1088 free(lname);
1089 return (B_FALSE);
1090 }
1091
1092 free(lname);
1093
1094 /*
1095 * Check if we have any PAPI aliases.
1096 */
1097 for (i = 0; cpcgen_intel_papi_map[i].cpapi_intc != NULL; i++) {
1098 if (strcmp(name, cpcgen_intel_papi_map[i].cpapi_intc) != 0)
1099 continue;
1100
1101 if (fprintf(f, "\t{ %s, %s, %s, \"%s\" },\n", ecode, umask,
1102 cmask, cpcgen_intel_papi_map[i].cpapi_papi) == -1) {
1103 warn("failed to write out entry %s from %s", name,
1104 path);
1105 return (B_FALSE);
1106 }
1107 }
1108
1109 return (B_TRUE);
1110 }
1111
1112 static boolean_t
1113 cpcgen_generate_map(FILE *f, cpc_map_t *map, boolean_t start)
1114 {
1115 cpc_proc_t *p;
1116
1117 if (fprintf(f, "\t%sif (", start ? "" : "} else ") == -1) {
1118 return (B_FALSE);
1119 }
1120
1121 for (p = map->cmap_procs; p != NULL; p = p->cproc_next) {
1122 /*
1123 * Make sure the line is padded so the generated C code looks
1124 * like reasonable C style.
1125 */
1126 if (p != map->cmap_procs) {
1127 if (fputs("\t ", f) == -1) {
1128 return (B_FALSE);
1129 }
1130 }
1131
1132 if (p->cproc_nsteps > 0) {
1133 uint_t i;
1134
1135 if (fprintf(f, "(model == 0x%x &&\n\t (",
1136 p->cproc_model) == -1) {
1137 return (B_FALSE);
1138 }
1139
1140 for (i = 0; i < p->cproc_nsteps; i++) {
1141 if (fprintf(f, "stepping == 0x%x%s",
1142 p->cproc_steppings[i],
1143 i + 1 != p->cproc_nsteps ?
1144 " ||\n\t " : "") == -1) {
1145 return (B_FALSE);
1146 }
1147 }
1148
1149 if (fputs("))", f) == -1) {
1150 return (B_FALSE);
1151 }
1152 } else if (fprintf(f, "model == 0x%x", p->cproc_model) == -1) {
1153 return (B_FALSE);
1154 }
1155
1156 if (fprintf(f, "%s\n",
1157 p->cproc_next != NULL ? " ||" : ") {") == -1) {
1158 return (B_FALSE);
1159 }
1160 }
1161
1162 if (fprintf(f, "\t\t\treturn (pcbe_core_events_%s);\n",
1163 map->cmap_name) == -1) {
1164 return (B_FALSE);
1165 }
1166
1167 return (B_TRUE);
1168 }
1169
1170 /*
1171 * This is a wrapper around unlinkat that makes sure that we don't clobber
1172 * errno, which is used for properly printing out error messages below.
1173 */
1174 static void
1175 cpcgen_remove_tmpfile(int dirfd, const char *path)
1176 {
1177 int e = errno;
1178 (void) unlinkat(dirfd, path, 0);
1179 errno = e;
1180 }
1181
1182 /*
1183 * Generate a header file that declares all of these arrays and provide a map
1184 * for models to the corresponding table to use.
1185 */
1186 static void
1187 cpcgen_common_intel_files(int dirfd)
1188 {
1189 const char *fname = "core_pcbe_cpcgen.h";
1190 char *tmpname;
1191 int fd;
1192 FILE *f;
1193 cpc_map_t *map;
1194
1195 if (asprintf(&tmpname, ".%s.%d", fname, getpid()) == -1) {
1196 err(EXIT_FAILURE, "failed to construct temporary file name");
1197 }
1198
1199 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0644)) < 0) {
1200 err(EXIT_FAILURE, "failed to create temporary file %s",
1201 tmpname);
1202 }
1203
1204 if ((f = fdopen(fd, "w")) == NULL) {
1205 cpcgen_remove_tmpfile(dirfd, tmpname);
1206 err(EXIT_FAILURE, "failed to fdopen temporary file");
1207 }
1208
1209 if (fprintf(f, cpcgen_cfile_intel_header, cpcgen_intel_mapfile) == -1) {
1210 cpcgen_remove_tmpfile(dirfd, tmpname);
1211 errx(EXIT_FAILURE, "failed to write header to temporary file "
1212 "for %s", fname);
1213 }
1214
1215 if (fprintf(f, "#ifndef _CORE_PCBE_CPCGEN_H\n"
1216 "#define\t_CORE_PCBE_CPCGEN_H\n"
1217 "\n"
1218 "#ifdef __cplusplus\n"
1219 "extern \"C\" {\n"
1220 "#endif\n"
1221 "\n"
1222 "extern const struct events_table_t *core_cpcgen_table(uint_t, "
1223 "uint_t);\n"
1224 "\n") == -1) {
1225 cpcgen_remove_tmpfile(dirfd, tmpname);
1226 errx(EXIT_FAILURE, "failed to write header to "
1227 "temporary file for %s", fname);
1228 }
1229
1230 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
1231 if (fprintf(f, "extern const struct events_table_t "
1232 "pcbe_core_events_%s[];\n", map->cmap_name) == -1) {
1233 cpcgen_remove_tmpfile(dirfd, tmpname);
1234 errx(EXIT_FAILURE, "failed to write entry to "
1235 "temporary file for %s", fname);
1236 }
1237 }
1238
1239 if (fprintf(f, "\n"
1240 "#ifdef __cplusplus\n"
1241 "}\n"
1242 "#endif\n"
1243 "\n"
1244 "#endif /* _CORE_PCBE_CPCGEN_H */\n") == -1) {
1245 cpcgen_remove_tmpfile(dirfd, tmpname);
1246 errx(EXIT_FAILURE, "failed to write header to "
1247 "temporary file for %s", fname);
1248 }
1249
1250 if (fflush(f) != 0 || fclose(f) != 0) {
1251 cpcgen_remove_tmpfile(dirfd, tmpname);
1252 err(EXIT_FAILURE, "failed to flush and close temporary file");
1253 }
1254
1255 if (renameat(dirfd, tmpname, dirfd, fname) != 0) {
1256 err(EXIT_FAILURE, "failed to rename temporary file %s",
1257 tmpname);
1258 }
1259
1260 free(tmpname);
1261
1262 /* Now again for the .c file. */
1263 fname = "core_pcbe_cpcgen.c";
1264 if (asprintf(&tmpname, ".%s.%d", fname, getpid()) == -1) {
1265 err(EXIT_FAILURE, "failed to construct temporary file name");
1266 }
1267
1268 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0644)) < 0) {
1269 err(EXIT_FAILURE, "failed to create temporary file %s",
1270 tmpname);
1271 }
1272
1273 if ((f = fdopen(fd, "w")) == NULL) {
1274 cpcgen_remove_tmpfile(dirfd, tmpname);
1275 err(EXIT_FAILURE, "failed to fdopen temporary file");
1276 }
1277
1278 if (fprintf(f, cpcgen_cfile_intel_header, cpcgen_intel_mapfile) == -1) {
1279 cpcgen_remove_tmpfile(dirfd, tmpname);
1280 errx(EXIT_FAILURE, "failed to write header to temporary file "
1281 "for %s", fname);
1282 }
1283
1284 if (fprintf(f, "#include <core_pcbe_table.h>\n"
1285 "#include <sys/null.h>\n"
1286 "#include \"core_pcbe_cpcgen.h\"\n"
1287 "\n"
1288 "const struct events_table_t *\n"
1289 "core_cpcgen_table(uint_t model, uint_t stepping)\n"
1290 "{\n") == -1) {
1291 cpcgen_remove_tmpfile(dirfd, tmpname);
1292 errx(EXIT_FAILURE, "failed to write header to "
1293 "temporary file for %s", fname);
1294 }
1295
1296 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
1297 if (!cpcgen_generate_map(f, map, map == cpcgen_maps)) {
1298 cpcgen_remove_tmpfile(dirfd, tmpname);
1299 errx(EXIT_FAILURE, "failed to write to temporary "
1300 "file for %s", fname);
1301 }
1302 }
1303
1304 if (fprintf(f, "\t} else {\n"
1305 "\t\t\treturn (NULL);\n"
1306 "\t}\n"
1307 "}\n") == -1) {
1308 cpcgen_remove_tmpfile(dirfd, tmpname);
1309 errx(EXIT_FAILURE, "failed to write header to "
1310 "temporary file for %s", fname);
1311 }
1312
1313 if (fflush(f) != 0 || fclose(f) != 0) {
1314 cpcgen_remove_tmpfile(dirfd, tmpname);
1315 err(EXIT_FAILURE, "failed to flush and close temporary file");
1316 }
1317
1318 if (renameat(dirfd, tmpname, dirfd, fname) != 0) {
1319 err(EXIT_FAILURE, "failed to rename temporary file %s",
1320 tmpname);
1321 }
1322
1323 free(tmpname);
1324 }
1325
1326 /*
1327 * Look at a rule to determine whether or not we should consider including it or
1328 * not. At this point we've already filtered things such that we only get core
1329 * events.
1330 *
1331 * To consider an entry, we currently apply the following criteria:
1332 *
1333 * - The MSRIndex and MSRValue are zero. Programming additional MSRs is no
1334 * supported right now.
1335 * - TakenAlone is non-zero, which means that it cannot run at the same time as
1336 * another field.
1337 * - Offcore is one, indicating that it is off the core and we need to figure
1338 * out if we can support this.
1339 * - If the counter is fixed, don't use it for now.
1340 * - If more than one value is specified in the EventCode or UMask values
1341 */
1342 static boolean_t
1343 cpcgen_skip_intel_entry(nvlist_t *nvl, const char *path, uint_t ent)
1344 {
1345 char *event, *msridx, *msrval, *taken, *offcore, *counter;
1346 char *ecode, *umask;
1347
1348 /*
1349 * Require EventName, it's kind of useless without that.
1350 */
1351 if (nvlist_lookup_string(nvl, "EventName", &event) != 0) {
1352 errx(EXIT_FAILURE, "Found event without 'EventName' property "
1353 "in %s, entry %u", path, ent);
1354 }
1355
1356 /*
1357 * If we can't find an expected value, whine about it.
1358 */
1359 if (nvlist_lookup_string(nvl, "MSRIndex", &msridx) != 0 ||
1360 nvlist_lookup_string(nvl, "MSRValue", &msrval) != 0 ||
1361 nvlist_lookup_string(nvl, "Counter", &counter) != 0 ||
1362 nvlist_lookup_string(nvl, "EventCode", &ecode) != 0 ||
1363 nvlist_lookup_string(nvl, "UMask", &umask) != 0 ||
1364 nvlist_lookup_string(nvl, "Offcore", &offcore) != 0) {
1365 warnx("Skipping event %s (index %u) from %s, missing required "
1366 "property", event, ent, path);
1367 return (B_TRUE);
1368 }
1369
1370 /*
1371 * MSRIndex and MSRvalue comes as either "0" or "0x00".
1372 */
1373 if ((strcmp(msridx, "0") != 0 && strcmp(msridx, "0x00") != 0) ||
1374 (strcmp(msrval, "0") != 0 && strcmp(msridx, "0x00") != 0) ||
1375 strcmp(offcore, "0") != 0 || strchr(ecode, ',') != NULL ||
1376 strchr(umask, ',') != NULL) {
1377 return (B_TRUE);
1378 }
1379
1380 /*
1381 * Unfortunately, not everything actually has "TakenAlone". If it
1382 * doesn't, we assume that it doesn't have to be.
1383 */
1384 if (nvlist_lookup_string(nvl, "TakenAlone", &taken) == 0 &&
1385 strcmp(taken, "0") != 0) {
1386 return (B_TRUE);
1387 }
1388
1389
1390 if (strncasecmp(counter, "fixed", strlen("fixed")) == 0)
1391 return (B_TRUE);
1392
1393 return (B_FALSE);
1394 }
1395 static char *
1396 cpcgen_manual_amd_name(cpc_map_t *map)
1397 {
1398 char *name;
1399
1400 if (asprintf(&name, "amd_%s_events.3cpc", map->cmap_name) == -1) {
1401 warn("failed to assemble file name for %s", map->cmap_path);
1402 return (NULL);
1403 }
1404
1405 return (name);
1406 }
1407
1408 static boolean_t
1409 cpcgen_manual_amd_file_before(FILE *f, cpc_map_t *map)
1410 {
1411 size_t i;
1412 char *upper;
1413 const char *family;
1414
1415 if ((upper = strdup(map->cmap_name)) == NULL) {
1416 warn("failed to duplicate manual name for %s", map->cmap_name);
1417 return (B_FALSE);
1418 }
1419
1420 for (i = 0; upper[i] != '\0'; i++) {
1421 upper[i] = toupper(upper[i]);
1422 }
1423
1424 family = map->cmap_name + 1;
1425
1426 if (fprintf(f, cpcgen_manual_amd_header, map->cmap_path, upper,
1427 family, family, family) == -1) {
1428 warn("failed to write out manual header for %s",
1429 map->cmap_name);
1430 free(upper);
1431 return (B_FALSE);
1432 }
1433
1434 free(upper);
1435 return (B_TRUE);
1436 }
1437
1438 static boolean_t
1439 cpcgen_manual_amd_file_after(FILE *f, cpc_map_t *map)
1440 {
1441 if (fprintf(f, cpcgen_manual_amd_trailer) == -1) {
1442 warn("failed to write out manual header for %s",
1443 map->cmap_name);
1444 return (B_FALSE);
1445 }
1446
1447 return (B_TRUE);
1448 }
1449
1450 static boolean_t
1451 cpcgen_manual_amd_event(FILE *f, nvlist_t *nvl, const char *path, uint32_t ent)
1452 {
1453 char *name, *mnemonic = NULL, *summary = NULL, *desc = NULL;
1454 char *umode;
1455 nvlist_t *units = NULL;
1456 uint32_t i, length;
1457
1458 if (nvlist_lookup_string(nvl, "name", &name) != 0) {
1459 warnx("Found event without 'name' property in %s, entry %u",
1460 path, ent);
1461 return (B_FALSE);
1462 }
1463
1464 if (nvlist_lookup_string(nvl, "mnemonic", &mnemonic) != 0 ||
1465 nvlist_lookup_string(nvl, "summary", &summary) != 0) {
1466 warnx("event %s in %s, entry %u, missing required fields",
1467 name, path, ent);
1468 return (B_FALSE);
1469 }
1470
1471 /*
1472 * Allow the other fields to be missing.
1473 */
1474 (void) nvlist_lookup_string(nvl, "description", &desc);
1475 (void) nvlist_lookup_nvlist(nvl, "units", &units);
1476
1477 if (fprintf(f, ".It Sy %s\n", name) == -1) {
1478 warn("failed to write out event entry %s", name);
1479 }
1480
1481 if (fprintf(f, ".Sy %s -\n"
1482 "%s\n", mnemonic, summary) == -1) {
1483 warn("failed to write out event entry %s", name);
1484 return (B_FALSE);
1485 }
1486
1487 if (desc != NULL) {
1488 if (fprintf(f, ".Pp\n%s\n", desc) == -1) {
1489 warn("failed to write out event entry %s", name);
1490 return (B_FALSE);
1491 }
1492 }
1493
1494 if (units == NULL)
1495 return (B_TRUE);
1496
1497 /*
1498 * Skip units we don't know how to handle.
1499 */
1500 if (nvlist_lookup_string(nvl, "unit_mode", &umode) == 0) {
1501 return (B_TRUE);
1502 }
1503
1504 if (fprintf(f, ".Pp\n"
1505 "This event has the following units which may be used\n"
1506 "to modify the behavior of the event:\n"
1507 ".Bl -tag -width Sy\n") == -1) {
1508 warn("failed to write out event entry %s", name);
1509 return (B_FALSE);
1510 }
1511
1512 if (nvlist_lookup_uint32(units, "length", &length) != 0) {
1513 warnx("found units array, but could not look up length "
1514 "property for events %s (index %u) in file %s",
1515 name, ent, path);
1516 return (B_FALSE);
1517 }
1518
1519 for (i = 0; i < length; i++) {
1520 nvlist_t *uvl;
1521 char num[64];
1522 char *uname, *udesc = NULL;
1523
1524 (void) snprintf(num, sizeof (num), "%u", i);
1525 if (nvlist_lookup_nvlist(units, num, &uvl) != 0) {
1526 warnx("failed to look up unit %u for event %s (index "
1527 "%u) in file %s", i, name, ent, path);
1528 return (B_FALSE);
1529 }
1530
1531 if (nvlist_lookup_string(uvl, "name", &uname) != 0) {
1532 warnx("failed to find required members for unit array "
1533 "entry %u of event %s (index %u) from file %s",
1534 i, name, ent, path);
1535 return (B_FALSE);
1536 }
1537 (void) nvlist_lookup_string(uvl, "description", &udesc);
1538 if (fprintf(f, ".It Sy %s\n", uname) == -1) {
1539 warn("failed to write out event entry %s", name);
1540 return (B_FALSE);
1541 }
1542
1543 if (udesc != NULL) {
1544 if (fprintf(f, "%s\n", udesc) == -1) {
1545 warn("failed to write out event entry %s",
1546 name);
1547 return (B_FALSE);
1548 }
1549 }
1550 }
1551
1552 if (fprintf(f, ".El\n") == -1) {
1553 warn("failed to write out event entry %s",
1554 name);
1555 return (B_FALSE);
1556 }
1557
1558 return (B_TRUE);
1559 }
1560
1561 static char *
1562 cpcgen_cfile_amd_name(cpc_map_t *map)
1563 {
1564 char *name;
1565
1566 if (asprintf(&name, "opteron_pcbe_%s.c", map->cmap_name) == -1) {
1567 warn("failed to assemble file name for %s", map->cmap_path);
1568 return (NULL);
1569 }
1570
1571 return (name);
1572 }
1573
1574 /*
1575 * Generate a header file that can be used to synthesize the data events we care
1576 * about.
1577 */
1578 static void
1579 cpcgen_common_amd_files(int dirfd)
1580 {
1581 const char *fname = "opteron_pcbe_cpcgen.h";
1582 char *tmpname;
1583 int fd;
1584 FILE *f;
1585 cpc_map_t *map;
1586
1587 if (asprintf(&tmpname, ".%s.%d", fname, getpid()) == -1) {
1588 err(EXIT_FAILURE, "failed to construct temporary file name");
1589 }
1590
1591 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0644)) < 0) {
1592 err(EXIT_FAILURE, "failed to create temporary file %s",
1593 tmpname);
1594 }
1595
1596 if ((f = fdopen(fd, "w")) == NULL) {
1597 cpcgen_remove_tmpfile(dirfd, tmpname);
1598 err(EXIT_FAILURE, "failed to fdopen temporary file");
1599 }
1600
1601 if (fprintf(f, cpcgen_cfile_cddl_header) == -1) {
1602 cpcgen_remove_tmpfile(dirfd, tmpname);
1603 err(EXIT_FAILURE, "failed to write header to "
1604 "temporary file for %s", fname);
1605 }
1606
1607 if (fprintf(f, "#ifndef _OPTERON_PCBE_CPCGEN_H\n"
1608 "#define\t_OPTERON_PCBE_CPCGEN_H\n"
1609 "\n"
1610 "#ifdef __cplusplus\n"
1611 "extern \"C\" {\n"
1612 "#endif\n"
1613 "\n") == -1) {
1614 cpcgen_remove_tmpfile(dirfd, tmpname);
1615 err(EXIT_FAILURE, "failed to write header to "
1616 "temporary file for %s", fname);
1617 }
1618
1619 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
1620 if (fprintf(f, "extern const amd_event_t "
1621 "opteron_pcbe_%s_events[];\n", map->cmap_name) == -1) {
1622 cpcgen_remove_tmpfile(dirfd, tmpname);
1623 err(EXIT_FAILURE, "failed to write header to "
1624 "temporary file for %s", fname);
1625 }
1626 }
1627
1628 if (fprintf(f, "\n"
1629 "#ifdef __cplusplus\n"
1630 "}\n"
1631 "#endif\n"
1632 "\n"
1633 "#endif /* _OPTERON_PCBE_CPCGEN_H */\n") == -1) {
1634 cpcgen_remove_tmpfile(dirfd, tmpname);
1635 err(EXIT_FAILURE, "failed to write header to "
1636 "temporary file for %s", fname);
1637 }
1638
1639
1640
1641 if (fflush(f) != 0 || fclose(f) != 0) {
1642 cpcgen_remove_tmpfile(dirfd, tmpname);
1643 err(EXIT_FAILURE, "failed to flush and close temporary file");
1644 }
1645
1646 if (renameat(dirfd, tmpname, dirfd, fname) != 0) {
1647 err(EXIT_FAILURE, "failed to rename temporary file %s",
1648 tmpname);
1649 }
1650
1651 free(tmpname);
1652 }
1653
1654 static boolean_t
1655 cpcgen_cfile_amd_before(FILE *f, cpc_map_t *map)
1656 {
1657 if (fprintf(f, cpcgen_cfile_amd_header, map->cmap_name) == -1) {
1658 warn("failed to write header to temporary file for %s",
1659 map->cmap_path);
1660 return (B_FALSE);
1661 }
1662
1663 if (fprintf(f, cpcgen_cfile_amd_table_start, map->cmap_name) == -1) {
1664 warn("failed to write header to temporary file for %s",
1665 map->cmap_path);
1666 return (B_FALSE);
1667 }
1668
1669
1670 return (B_TRUE);
1671 }
1672
1673 static boolean_t
1674 cpcgen_cfile_amd_after(FILE *f, cpc_map_t *map)
1675 {
1676 if (fprintf(f, cpcgen_cfile_amd_table_end) == -1) {
1677 warn("failed to write footer to temporary file for %s",
1678 map->cmap_path);
1679 return (B_FALSE);
1680 }
1681
1682 return (B_TRUE);
1683 }
1684
1685 static boolean_t
1686 cpcgen_cfile_amd_event(FILE *f, nvlist_t *nvl, const char *path, uint_t ent)
1687 {
1688 char *name, *code, *umode;
1689 uint32_t i, length;
1690 nvlist_t *units;
1691
1692 if (nvlist_lookup_string(nvl, "name", &name) != 0) {
1693 warnx("Found event without 'name' property in %s, entry %u",
1694 path, ent);
1695 return (B_FALSE);
1696 }
1697
1698 if (nvlist_lookup_string(nvl, "code", &code) != 0) {
1699 warnx("event %s (index %u) from %s missing required properties "
1700 "for C translation", name, path, ent);
1701 return (B_FALSE);
1702 }
1703
1704 if (fprintf(f, "\t{ \"%s\", %s, 0 },\n", name, code) == -1) {
1705 warn("failed to write out entry %s from %s", name, path);
1706 return (B_FALSE);
1707 }
1708
1709 /*
1710 * The 'units' array is optional. If the rule has a specific 'unit_mode'
1711 * indicating how the units should be combined, skip that. We don't know
1712 * how to properly process that right now.
1713 */
1714 if (nvlist_lookup_nvlist(nvl, "units", &units) != 0) {
1715 return (B_TRUE);
1716 }
1717
1718 if (nvlist_lookup_string(nvl, "unit_mode", &umode) == 0) {
1719 return (B_TRUE);
1720 }
1721
1722 if (nvlist_lookup_uint32(units, "length", &length) != 0) {
1723 warnx("found units array, but could not look up length "
1724 "property for events %s (index %u) in file %s",
1725 name, ent, path);
1726 return (B_FALSE);
1727 }
1728
1729 for (i = 0; i < length; i++) {
1730 nvlist_t *uvl;
1731 char num[64];
1732 char *uname, *urw;
1733 int32_t bit;
1734
1735 (void) snprintf(num, sizeof (num), "%u", i);
1736 if (nvlist_lookup_nvlist(units, num, &uvl) != 0) {
1737 warnx("failed to look up unit %u for event %s (index "
1738 "%u) in file %s", i, name, ent, path);
1739 return (B_FALSE);
1740 }
1741
1742 if (nvlist_lookup_string(uvl, "name", &uname) != 0 ||
1743 nvlist_lookup_string(uvl, "rw", &urw) != 0 ||
1744 nvlist_lookup_int32(uvl, "bit", &bit) != 0) {
1745 warnx("failed to find required members for unit array "
1746 "entry %u of event %s (index %u) from file %s",
1747 i, name, ent, path);
1748 dump_nvlist(uvl, 0);
1749 return (B_FALSE);
1750 }
1751
1752 if (bit < 0 || bit > 31) {
1753 warnx("event %s (index %u) from file %s has invalid "
1754 "bit value: %d; skipping", name, ent, path, bit);
1755 continue;
1756 }
1757
1758 if (strcasecmp(urw, "Read-write") != 0)
1759 continue;
1760
1761 if (fprintf(f, "\t{ \"%s.%s\", %s, 0x%x },\n", name, uname,
1762 code, 1U << bit) == -1) {
1763 warn("failed to write out entry %s from %s", name,
1764 path);
1765 return (B_FALSE);
1766 }
1767 }
1768
1769 return (B_TRUE);
1770 }
1771
1772 /*
1773 * For each processor family, generate a data file that contains all of the
1774 * events that we support. Also generate a header that can be included that
1775 * declares all of the tables.
1776 */
1777 static void
1778 cpcgen_gen(int dirfd)
1779 {
1780 cpc_map_t *map = cpcgen_maps;
1781
1782 if (map == NULL) {
1783 errx(EXIT_FAILURE, "no platforms found or matched");
1784 }
1785
1786 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
1787 int fd, ret;
1788 FILE *f;
1789 char *tmpname, *name;
1790 uint32_t length, i;
1791
1792 if ((name = cpcgen_ops.cgen_op_name(map)) == NULL) {
1793 exit(EXIT_FAILURE);
1794 }
1795
1796 if (asprintf(&tmpname, ".%s.%d", name, getpid()) == -1) {
1797 err(EXIT_FAILURE, "failed to construct temporary file "
1798 "name");
1799 }
1800
1801 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0444)) < 0) {
1802 err(EXIT_FAILURE, "failed to create temporary file %s",
1803 tmpname);
1804 }
1805
1806 if ((f = fdopen(fd, "w")) == NULL) {
1807 cpcgen_remove_tmpfile(dirfd, tmpname);
1808 err(EXIT_FAILURE, "failed to fdopen temporary file");
1809 }
1810
1811 if (!cpcgen_ops.cgen_op_file_before(f, map)) {
1812 cpcgen_remove_tmpfile(dirfd, tmpname);
1813 exit(EXIT_FAILURE);
1814 }
1815
1816 /*
1817 * Iterate over array contents.
1818 */
1819 if ((ret = nvlist_lookup_uint32(map->cmap_data, "length",
1820 &length)) != 0) {
1821 errx(EXIT_FAILURE, "failed to look up length property "
1822 "in parsed data for %s: %s", map->cmap_path,
1823 strerror(ret));
1824 }
1825
1826 for (i = 0; i < length; i++) {
1827 nvlist_t *nvl;
1828 char num[64];
1829
1830 (void) snprintf(num, sizeof (num), "%u", i);
1831 if ((ret = nvlist_lookup_nvlist(map->cmap_data,
1832 num, &nvl)) != 0) {
1833 cpcgen_remove_tmpfile(dirfd, tmpname);
1834 errx(EXIT_FAILURE, "failed to look up array "
1835 "entry %u in parsed data for %s: %s", i,
1836 map->cmap_path, strerror(ret));
1837 }
1838
1839 if (cpcgen_ops.cgen_op_skip != NULL &&
1840 cpcgen_ops.cgen_op_skip(nvl, map->cmap_path, i)) {
1841 continue;
1842 }
1843
1844 if (!cpcgen_ops.cgen_op_event(f, nvl, map->cmap_path,
1845 i)) {
1846 cpcgen_remove_tmpfile(dirfd, tmpname);
1847 exit(EXIT_FAILURE);
1848 }
1849 }
1850
1851 if (!cpcgen_ops.cgen_op_file_after(f, map)) {
1852 cpcgen_remove_tmpfile(dirfd, tmpname);
1853 exit(EXIT_FAILURE);
1854 }
1855
1856 if (fflush(f) != 0 || fclose(f) != 0) {
1857 cpcgen_remove_tmpfile(dirfd, tmpname);
1858 err(EXIT_FAILURE, "failed to flush and close "
1859 "temporary file");
1860 }
1861
1862 if (renameat(dirfd, tmpname, dirfd, name) != 0) {
1863 err(EXIT_FAILURE, "failed to rename temporary file %s",
1864 tmpname);
1865 }
1866
1867 free(name);
1868 free(tmpname);
1869 }
1870 }
1871
1872 static void
1873 cpcgen_usage(const char *fmt, ...)
1874 {
1875 if (fmt != NULL) {
1876 va_list ap;
1877
1878 (void) fprintf(stderr, "%s: ", cpcgen_progname);
1879 va_start(ap, fmt);
1880 (void) vfprintf(stderr, fmt, ap);
1881 va_end(ap);
1882 }
1883
1884 (void) fprintf(stderr, "Usage: %s -a|-p platform -c|-H|-m -d datadir "
1885 "-o outdir\n"
1886 "\n"
1887 "\t-a generate data for all platforms\n"
1888 "\t-c generate C file for CPC\n"
1889 "\t-d specify the directory containt perfmon data\n"
1890 "\t-H generate header file and common files\n"
1891 "\t-m generate manual pages for CPC data\n"
1892 "\t-o output files in directory outdir\n"
1893 "\t-p generate data for a specified platform\n",
1894 cpcgen_progname);
1895 }
1896
1897 int
1898 main(int argc, char *argv[])
1899 {
1900 int c, outdirfd;
1901 boolean_t do_mpage = B_FALSE, do_cfile = B_FALSE, do_header = B_FALSE,
1902 do_all = B_FALSE;
1903 const char *datadir = NULL, *outdir = NULL, *platform = NULL;
1904 uint_t count = 0;
1905
1906 cpcgen_progname = basename(argv[0]);
1907
1908 while ((c = getopt(argc, argv, ":acd:hHmo:p:")) != -1) {
1909 switch (c) {
1910 case 'a':
1911 do_all = B_TRUE;
1912 break;
1913 case 'c':
1914 do_cfile = B_TRUE;
1915 break;
1916 case 'd':
1917 datadir = optarg;
1918 break;
1919 case 'm':
1920 do_mpage = B_TRUE;
1921 break;
1922 case 'H':
1923 do_header = B_TRUE;
1924 break;
1925 case 'o':
1926 outdir = optarg;
1927 break;
1928 case 'p':
1929 platform = optarg;
1930 break;
1931 case ':':
1932 cpcgen_usage("Option -%c requires an operand\n",
1933 optopt);
1934 return (2);
1935 case '?':
1936 cpcgen_usage("Unknown option: -%c\n", optopt);
1937 return (2);
1938 case 'h':
1939 default:
1940 cpcgen_usage(NULL);
1941 return (2);
1942 }
1943 }
1944
1945 count = 0;
1946 if (do_mpage)
1947 count++;
1948 if (do_cfile)
1949 count++;
1950 if (do_header)
1951 count++;
1952 if (count > 1) {
1953 cpcgen_usage("Only one of -c, -h, and -m may be specified\n");
1954 return (2);
1955 } else if (count == 0) {
1956 cpcgen_usage("One of -c, -h, and -m is required\n");
1957 return (2);
1958 }
1959
1960 count = 0;
1961 if (do_all)
1962 count++;
1963 if (platform != NULL)
1964 count++;
1965 if (count > 1) {
1966 cpcgen_usage("Only one of -a and -p may be specified\n");
1967 return (2);
1968 } else if (count == 0) {
1969 cpcgen_usage("One of -a and -p is required\n");
1970 return (2);
1971 }
1972
1973 if (outdir == NULL) {
1974 cpcgen_usage("Missing required output directory (-o)\n");
1975 return (2);
1976 }
1977
1978 if ((outdirfd = open(outdir, O_RDONLY)) < 0) {
1979 err(EXIT_FAILURE, "failed to open output directory %s", outdir);
1980 }
1981
1982 if (datadir == NULL) {
1983 cpcgen_usage("Missing required data directory (-d)\n");
1984 return (2);
1985 }
1986
1987 cpcgen_determine_vendor(datadir);
1988
1989 switch (cpcgen_mode) {
1990 case CPCGEN_MODE_INTEL:
1991 cpcgen_ops.cgen_op_gather = cpcgen_read_intel;
1992 cpcgen_ops.cgen_op_common = cpcgen_common_intel_files;
1993 cpcgen_ops.cgen_op_skip = cpcgen_skip_intel_entry;
1994 if (do_mpage) {
1995 cpcgen_ops.cgen_op_name = cpcgen_manual_intel_name;
1996 cpcgen_ops.cgen_op_file_before =
1997 cpcgen_manual_intel_file_before;
1998 cpcgen_ops.cgen_op_file_after =
1999 cpcgen_manual_intel_file_after;
2000 cpcgen_ops.cgen_op_event = cpcgen_manual_intel_event;
2001 } else {
2002 cpcgen_ops.cgen_op_name = cpcgen_cfile_intel_name;
2003 cpcgen_ops.cgen_op_file_before =
2004 cpcgen_cfile_intel_before;
2005 cpcgen_ops.cgen_op_file_after =
2006 cpcgen_cfile_intel_after;
2007 cpcgen_ops.cgen_op_event = cpcgen_cfile_intel_event;
2008 }
2009 break;
2010 case CPCGEN_MODE_AMD:
2011 cpcgen_ops.cgen_op_gather = cpcgen_read_amd;
2012 cpcgen_ops.cgen_op_common = cpcgen_common_amd_files;
2013 cpcgen_ops.cgen_op_skip = NULL;
2014 if (do_mpage) {
2015 cpcgen_ops.cgen_op_name = cpcgen_manual_amd_name;
2016 cpcgen_ops.cgen_op_file_before =
2017 cpcgen_manual_amd_file_before;
2018 cpcgen_ops.cgen_op_file_after =
2019 cpcgen_manual_amd_file_after;
2020 cpcgen_ops.cgen_op_event = cpcgen_manual_amd_event;
2021 } else {
2022 cpcgen_ops.cgen_op_name = cpcgen_cfile_amd_name;
2023 cpcgen_ops.cgen_op_file_before =
2024 cpcgen_cfile_amd_before;
2025 cpcgen_ops.cgen_op_file_after = cpcgen_cfile_amd_after;
2026 cpcgen_ops.cgen_op_event = cpcgen_cfile_amd_event;
2027
2028 }
2029 break;
2030 default:
2031 errx(EXIT_FAILURE, "failed to determine if operating on AMD or "
2032 "Intel");
2033 break;
2034 }
2035
2036 cpcgen_ops.cgen_op_gather(datadir, platform);
2037
2038 if (do_header) {
2039 cpcgen_ops.cgen_op_common(outdirfd);
2040 return (0);
2041 }
2042
2043 cpcgen_gen(outdirfd);
2044
2045 return (0);
2046 }