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 file transforms the perfmon data files into C files and manual pages.
18 */
19
20 #include <stdio.h>
21 #include <stdarg.h>
22 #include <unistd.h>
23 #include <err.h>
24 #include <libgen.h>
25 #include <libnvpair.h>
26 #include <strings.h>
27 #include <errno.h>
28 #include <limits.h>
29 #include <sys/mman.h>
30 #include <sys/param.h>
31 #include <assert.h>
32 #include <ctype.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <fcntl.h>
36
37 #include <json_nvlist.h>
38
39 #define EXIT_USAGE 2
40
41
42 typedef struct cpc_proc {
43 struct cpc_proc *cproc_next;
44 uint_t cproc_family;
45 uint_t cproc_model;
46 } cpc_proc_t;
47
48 typedef enum cpc_file_type {
49 CPC_FILE_CORE = 1 << 0,
50 CPC_FILE_OFF_CORE = 1 << 1,
51 CPC_FILE_UNCORE = 1 << 2,
52 CPC_FILE_FP_MATH = 1 << 3,
53 CPC_FILE_UNCORE_EXP = 1 << 4
54 } cpc_type_t;
55
56 typedef struct cpc_map {
57 struct cpc_map *cmap_next;
58 cpc_type_t cmap_type;
59 nvlist_t *cmap_data;
60 char *cmap_path;
61 const char *cmap_name;
62 cpc_proc_t *cmap_procs;
63 } cpc_map_t;
64
65 typedef struct cpc_whitelist {
66 const char *cwhite_short;
67 const char *cwhite_human;
68 uint_t cwhite_mask;
69 } cpc_whitelist_t;
70
71 /*
72 * List of architectures that we support generating this data for. This is done
73 * so that processors that illumos doesn't support or run on aren't generated
74 * (generally the Xeon Phi).
75 */
76 static cpc_whitelist_t cpcgen_whitelist[] = {
77 /* Nehalem */
78 { "NHM-EP", "nhm_ep", CPC_FILE_CORE },
79 { "NHM-EX", "nhm_ex", CPC_FILE_CORE },
80 /* Westmere */
81 { "WSM-EP-DP", "wsm_ep_dp", CPC_FILE_CORE },
82 { "WSM-EP-SP", "wsm_ep_sp", CPC_FILE_CORE },
83 { "WSM-EX", "wsm_ex", CPC_FILE_CORE },
84 /* Sandy Bridge */
85 { "SNB", "snb", CPC_FILE_CORE },
86 { "JKT", "jkt", CPC_FILE_CORE },
87 /* Ivy Bridge */
88 { "IVB", "ivb", CPC_FILE_CORE },
89 { "IVT", "ivt", CPC_FILE_CORE },
90 /* Haswell */
91 { "HSW", "hsw", CPC_FILE_CORE },
92 { "HSX", "hsx", CPC_FILE_CORE },
93 /* Broadwell */
94 { "BDW", "bdw", CPC_FILE_CORE },
95 { "BDW-DE", "bdw_de", CPC_FILE_CORE },
96 { "BDX", "bdx", CPC_FILE_CORE },
97 /* Skylake */
98 { "SKL", "skl", CPC_FILE_CORE },
99 { "SKX", "skx", CPC_FILE_CORE },
100 /* Atom */
101 { "BNL", "bnl", CPC_FILE_CORE },
102 { "SLM", "slm", CPC_FILE_CORE },
103 { "GLM", "glm", CPC_FILE_CORE },
104 { "GLP", "glp", CPC_FILE_CORE },
105 { NULL }
106 };
107
108 typedef struct cpc_papi {
109 const char *cpapi_intc;
110 const char *cpapi_papi;
111 } cpc_papi_t;
112
113 /*
114 * This table maps events with an Intel specific name to the corresponding PAPI
115 * name. There may be multiple INtel events which map to the same PAPI event.
116 * This is usually because different processors have different names for an
117 * event. We use the title as opposed to the event codes because those can
118 * change somewhat arbitrarily between processor generations.
119 */
120 static cpc_papi_t cpcgen_papi_map[] = {
121 { "CPU_CLK_UNHALTED.THREAD_P", "PAPI_tot_cyc" },
122 { "INST_RETIRED.ANY_P", "PAPI_tot_ins" },
123 { "BR_INST_RETIRED.ALL_BRANCHES", "PAPI_br_ins" },
124 { "BR_MISP_RETIRED.ALL_BRANCHES", "PAPI_br_msp" },
125 { "BR_INST_RETIRED.CONDITIONAL", "PAPI_br_cn" },
126 { "CYCLE_ACTIVITY.CYCLES_L1D_MISS", "PAPI_l1_dcm" },
127 { "L1I.HITS", "PAPI_l1_ich" },
128 { "ICACHE.HIT", "PAPI_l1_ich" },
129 { "L1I.MISS", "PAPI_L1_icm" },
130 { "ICACHE.MISSES", "PAPI_l1_icm" },
131 { "L1I.READS", "PAPI_l1_ica" },
132 { "ICACHE.ACCESSES", "PAPI_l1_ica" },
133 { "L1I.READS", "PAPI_l1_icr" },
134 { "ICACHE.ACCESSES", "PAPI_l1_icr" },
135 { "L2_RQSTS.CODE_RD_MISS", "PAPI_l2_icm" },
136 { "L2_RQSTS.MISS", "PAPI_l2_tcm" },
137 { "ITLB_MISSES.MISS_CAUSES_A_WALK", "PAPI_tlb_im" },
138 { "DTLB_LOAD_MISSES.MISS_CAUSES_A_WALK", "PAPI_tlb_dm" },
139 { "PAGE_WALKS.D_SIDE_WALKS", "PAPI_tlb_dm" },
140 { "PAGE_WALKS.I_SIDE_WALKS", "PAPI_tlb_im" },
141 { "PAGE_WALKS.WALKS", "PAPI_tlb_tl" },
142 { "INST_QUEUE_WRITES", "PAPI_tot_iis" },
143 { "MEM_INST_RETIRED.STORES" "PAPI_sr_ins" },
144 { "MEM_INST_RETIRED.LOADS" "PAPI_ld_ins" },
145 { NULL, NULL }
146 };
147
148 typedef struct cpcgen_ops {
149 char *(*cgen_op_name)(cpc_map_t *);
150 boolean_t (*cgen_op_file_before)(FILE *, cpc_map_t *);
151 boolean_t (*cgen_op_file_after)(FILE *, cpc_map_t *);
152 boolean_t (*cgen_op_event)(FILE *, nvlist_t *, const char *, uint32_t);
153 } cpcgen_ops_t;
154
155 static cpcgen_ops_t cpcgen_ops;
156 static const char *cpcgen_mapfile = "/mapfile.csv";
157 static const char *cpcgen_progname;
158 static cpc_map_t *cpcgen_maps;
159
160 /*
161 * Constants used for generating data.
162 */
163 /* BEGIN CSTYLED */
164 static const char *cpcgen_cfile_header = ""
165 "/*\n"
166 " * Copyright (c) 2018, Intel Corporation\n"
167 " * Copyright (c) 2018, Joyent, Inc\n"
168 " * All rights reserved.\n"
169 " *\n"
170 " * Redistribution and use in source and binary forms, with or without\n"
171 " * modification, are permitted provided that the following conditions are met:\n"
172 " * \n"
173 " * 1. Redistributions of source code must retain the above copyright notice,\n"
174 " * this list of conditions and the following disclaimer.\n"
175 " * \n"
176 " * 2. Redistributions in binary form must reproduce the above copyright \n"
177 " * notice, this list of conditions and the following disclaimer in the\n"
178 " * documentation and/or other materials provided with the distribution.\n"
179 " * \n"
180 " * 3. Neither the name of the Intel Corporation nor the names of its \n"
181 " * contributors may be used to endorse or promote products derived from\n"
182 " * this software without specific prior written permission.\n"
183 " *\n"
184 " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n"
185 " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n"
186 " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
187 " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n"
188 " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
189 " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
190 " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n"
191 " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n"
192 " * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n"
193 " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
194 " * POSSIBILITY OF SUCH DAMAGE.\n"
195 " *\n"
196 " * This file was automatically generated by cpcgen from the data file\n"
197 " * data/perfmon%s\n"
198 " *\n"
199 " * Do not modify this file. Your changes will be lost!\n"
200 " */\n"
201 "\n";
202 /* END CSTYLED */
203
204 static const char *cpcgen_cfile_table_start = ""
205 "#include <core_pcbe_table.h>\n"
206 "\n"
207 "const struct events_table_t pcbe_core_events_%s[] = {\n";
208
209 static const char *cpcgen_cfile_table_end = ""
210 "\t{ NT_END, 0, 0, \"\" }\n"
211 "};\n";
212
213 /* BEGIN CSTYLED */
214 static const char *cpcgen_manual_header = ""
215 ".\\\" Copyright (c) 2018, Intel Corporation \n"
216 ".\\\" Copyright (c) 2018, Joyent, Inc.\n"
217 ".\\\" All rights reserved.\n"
218 ".\\\"\n"
219 ".\\\" Redistribution and use in source and binary forms, with or without \n"
220 ".\\\" modification, are permitted provided that the following conditions are met:\n"
221 ".\\\"\n"
222 ".\\\" 1. Redistributions of source code must retain the above copyright notice,\n"
223 ".\\\" this list of conditions and the following disclaimer.\n"
224 ".\\\"\n"
225 ".\\\" 2. Redistributions in binary form must reproduce the above copyright\n"
226 ".\\\" notice, this list of conditions and the following disclaimer in the\n"
227 ".\\\" documentation and/or other materials provided with the distribution.\n"
228 ".\\\"\n"
229 ".\\\" 3. Neither the name of the Intel Corporation nor the names of its\n"
230 ".\\\" contributors may be used to endorse or promote products derived from\n"
231 ".\\\" this software without specific prior written permission.\n"
232 ".\\\"\n"
233 ".\\\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n"
234 ".\\\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n"
235 ".\\\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
236 ".\\\" ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n"
237 ".\\\" LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
238 ".\\\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
239 ".\\\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n"
240 ".\\\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n"
241 ".\\\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n"
242 ".\\\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
243 ".\\\" POSSIBILITY OF SUCH DAMAGE.\n"
244 ".\\\"\n"
245 ".\\\" This file was automatically generated by cpcgen from the data file\n"
246 ".\\\" data/perfmon%s\n"
247 ".\\\"\n"
248 ".\\\" Do not modify this file. Your changes will be lost!\n"
249 ".\\\"\n"
250 ".\\\" We would like to thank Intel for providing the perfmon data for use in\n"
251 ".\\\" our manual pages.\n"
252 ".Dd June 18, 2018\n"
253 ".Dt %s_EVENTS 3CPC\n"
254 ".Os\n"
255 ".Sh NAME\n"
256 ".Nm %s_events\n"
257 ".Nd processor model specific performance counter events\n"
258 ".Sh DESCRIPTION\n"
259 "This manual page describes events specific to the following Intel CPU\n"
260 "models and is derived from Intel's perfmon data.\n"
261 "For more information, please consult the Intel Software Developer's Manual "
262 "or Intel's perfmon website.\n"
263 ".Pp\n"
264 "CPU models described by this document:\n"
265 ".Bl -bullet\n";
266 /* END CSTYLED */
267
268 static const char *cpcgen_manual_data = ""
269 ".El\n"
270 ".Pp\n"
271 "The following events are supported:\n"
272 ".Bl -tag -width Sy\n";
273
274 static const char *cpcgen_manual_trailer = ""
275 ".El\n"
276 ".Sh SEE ALSO\n"
277 ".Xr cpc 3CPC\n"
278 ".Pp\n"
279 ".Lk https://download.01.org/perfmon/index/";
280
281 static cpc_map_t *
282 cpcgen_map_lookup(const char *path)
283 {
284 cpc_map_t *m;
285
286 for (m = cpcgen_maps; m != NULL; m = m->cmap_next) {
287 if (strcmp(path, m->cmap_path) == 0) {
288 return (m);
289 }
290 }
291
292 return (NULL);
293 }
294
295 /*
296 * Parse a string of the form 'GenuineIntel-6-2E' and get out the family and
297 * model.
298 */
299 static void
300 cpcgen_parse_model(char *fsr, uint_t *family, uint_t *model)
301 {
302 const char *bstr = "GenuineIntel";
303 const char *brand, *fam, *mod;
304 char *last;
305 long l;
306
307 if ((brand = strtok_r(fsr, "-", &last)) == NULL ||
308 (fam = strtok_r(NULL, "-", &last)) == NULL ||
309 (mod = strtok_r(NULL, "-", &last)) == NULL) {
310 errx(EXIT_FAILURE, "failed to parse processor id \"%s\"", fsr);
311 }
312
313 if (strcmp(bstr, brand) != 0) {
314 errx(EXIT_FAILURE, "brand string \"%s\" did not match \"%s\"",
315 brand, bstr);
316 }
317
318 errno = 0;
319 l = strtol(fam, &last, 16);
320 if (errno != 0 || l < 0 || l >= INT_MAX || *last != '\0') {
321 errx(EXIT_FAILURE, "failed to parse family \"%s\"", fam);
322 }
323 *family = (uint_t)l;
324
325 l = strtol(mod, &last, 16);
326 if (errno != 0 || l < 0 || l >= INT_MAX || *last != '\0') {
327 errx(EXIT_FAILURE, "failed to parse model \"%s\"", mod);
328 }
329 *model = (uint_t)l;
330 }
331
332 static nvlist_t *
333 cpcgen_read_datafile(const char *datadir, const char *file)
334 {
335 int fd;
336 char *path;
337 struct stat st;
338 void *map;
339 nvlist_t *nvl;
340 nvlist_parse_json_error_t jerr;
341
342 if (asprintf(&path, "%s/%s", datadir, file) == -1) {
343 err(EXIT_FAILURE, "failed to construct path to data file %s",
344 file);
345 }
346
347 if ((fd = open(path, O_RDONLY)) < 0) {
348 err(EXIT_FAILURE, "failed to open data file %s", path);
349 }
350
351 if (fstat(fd, &st) != 0) {
352 err(EXIT_FAILURE, "failed to stat %s", path);
353 }
354
355 if ((map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
356 fd, 0)) == MAP_FAILED) {
357 err(EXIT_FAILURE, "failed to mmap %s", path);
358 }
359
360 if (nvlist_parse_json(map, st.st_size, &nvl, NVJSON_FORCE_INTEGER,
361 &jerr) != 0) {
362 errx(EXIT_FAILURE, "failed to parse file %s at pos %ld: %s",
363 path, jerr.nje_pos, jerr.nje_message);
364 }
365
366 if (munmap(map, st.st_size) != 0) {
367 err(EXIT_FAILURE, "failed to munmap %s", path);
368 }
369
370 if (close(fd) != 0) {
371 err(EXIT_FAILURE, "failed to close data file %s", path);
372 }
373 free(path);
374
375 return (nvl);
376 }
377
378 /*
379 * Check the whitelist to see if we should use this model.
380 */
381 static const char *
382 cpcgen_use_arch(const char *path, cpc_type_t type, const char *platform)
383 {
384 const char *slash;
385 size_t len;
386 uint_t i;
387
388 if (*path != '/') {
389 errx(EXIT_FAILURE, "invalid path in mapfile: \"%s\": missing "
390 "leading '/'", path);
391 }
392 if ((slash = strchr(path + 1, '/')) == NULL) {
393 errx(EXIT_FAILURE, "invalid path in mapfile: \"%s\": missing "
394 "second '/'", path);
395 }
396 /* Account for the last '/' character. */
397 len = slash - path - 1;
398 assert(len > 0);
399
400 for (i = 0; cpcgen_whitelist[i].cwhite_short != NULL; i++) {
401 if (platform != NULL && strcasecmp(platform,
402 cpcgen_whitelist[i].cwhite_short) != 0)
403 continue;
404 if (strncmp(path + 1, cpcgen_whitelist[i].cwhite_short,
405 len) == 0 &&
406 (cpcgen_whitelist[i].cwhite_mask & type) == type) {
407 return (cpcgen_whitelist[i].cwhite_human);
408 }
409 }
410
411 return (NULL);
412 }
413
414 /*
415 * Read in the mapfile.csv that is used to map between processor families and
416 * parse this. Each line has a comma separated value.
417 */
418 static void
419 cpcgen_read_mapfile(const char *datadir, const char *platform)
420 {
421 FILE *map;
422 char *mappath, *last;
423 char *data = NULL;
424 size_t datalen = 0;
425 uint_t lineno;
426
427 if (asprintf(&mappath, "%s/%s", datadir, cpcgen_mapfile) == -1) {
428 err(EXIT_FAILURE, "failed to construct path to mapfile");
429 }
430
431 if ((map = fopen(mappath, "r")) == NULL) {
432 err(EXIT_FAILURE, "failed to open data mapfile %s", mappath);
433 }
434
435 lineno = 0;
436 while (getline(&data, &datalen, map) != -1) {
437 char *fstr, *path, *tstr;
438 const char *name;
439 uint_t family, model;
440 cpc_type_t type;
441 cpc_map_t *map;
442 cpc_proc_t *proc;
443
444 /*
445 * The first line contains the header:
446 * Family-model,Version,Filename,EventType
447 */
448 lineno++;
449 if (lineno == 1) {
450 continue;
451 }
452
453 if ((fstr = strtok_r(data, ",", &last)) == NULL ||
454 strtok_r(NULL, ",", &last) == NULL ||
455 (path = strtok_r(NULL, ",", &last)) == NULL ||
456 (tstr = strtok_r(NULL, "\n", &last)) == NULL) {
457 errx(EXIT_FAILURE, "failed to parse mapfile line "
458 "%u in %s", lineno, mappath);
459 }
460
461 cpcgen_parse_model(fstr, &family, &model);
462
463 if (strcmp(tstr, "core") == 0) {
464 type = CPC_FILE_CORE;
465 } else if (strcmp(tstr, "offcore") == 0) {
466 type = CPC_FILE_OFF_CORE;
467 } else if (strcmp(tstr, "uncore") == 0) {
468 type = CPC_FILE_UNCORE;
469 } else if (strcmp(tstr, "fp_arith_inst") == 0) {
470 type = CPC_FILE_FP_MATH;
471 } else if (strcmp(tstr, "uncore experimental") == 0) {
472 type = CPC_FILE_UNCORE_EXP;
473 } else {
474 errx(EXIT_FAILURE, "unknown file type \"%s\" on line "
475 "%u", tstr, lineno);
476 }
477
478 if ((name = cpcgen_use_arch(path, type, platform)) == NULL)
479 continue;
480
481 if ((map = cpcgen_map_lookup(path)) == NULL) {
482 nvlist_t *parsed;
483
484 parsed = cpcgen_read_datafile(datadir, path);
485
486 if ((map = calloc(1, sizeof (cpc_map_t))) == NULL) {
487 err(EXIT_FAILURE, "failed to allocate space "
488 "for cpc file");
489 }
490
491 if ((map->cmap_path = strdup(path)) == NULL) {
492 err(EXIT_FAILURE, "failed to duplicate path "
493 "string");
494 }
495
496 map->cmap_type = type;
497 map->cmap_data = parsed;
498 map->cmap_next = cpcgen_maps;
499 map->cmap_name = name;
500 cpcgen_maps = map;
501 }
502
503 if ((proc = malloc(sizeof (cpc_proc_t))) == NULL) {
504 err(EXIT_FAILURE, "failed to allocate memory for "
505 "family and model tracking");
506 }
507
508 proc->cproc_family = family;
509 proc->cproc_model = model;
510 proc->cproc_next = map->cmap_procs;
511 map->cmap_procs = proc;
512 }
513
514 if (errno != 0 || ferror(map)) {
515 err(EXIT_FAILURE, "failed to read %s", mappath);
516 }
517
518 if (fclose(map) == EOF) {
519 err(EXIT_FAILURE, "failed to close %s", mappath);
520 }
521 free(data);
522 free(mappath);
523 }
524
525 static char *
526 cpcgen_manual_name(cpc_map_t *map)
527 {
528 char *name;
529
530 if (asprintf(&name, "%s_events.3cpc", map->cmap_name) == -1) {
531 warn("failed to assemble manual page name for %s",
532 map->cmap_path);
533 return (NULL);
534 }
535
536 return (name);
537 }
538
539 static boolean_t
540 cpcgen_manual_file_before(FILE *f, cpc_map_t *map)
541 {
542 size_t i;
543 char *upper;
544 cpc_proc_t *proc;
545
546 if ((upper = strdup(map->cmap_name)) == NULL) {
547 warn("failed to duplicate manual name for %s", map->cmap_name);
548 return (B_FALSE);
549 }
550
551 for (i = 0; upper[i] != '\0'; i++) {
552 upper[i] = toupper(upper[i]);
553 }
554
555 if (fprintf(f, cpcgen_manual_header, map->cmap_path, upper,
556 map->cmap_name) == -1) {
557 warn("failed to write out manual header for %s",
558 map->cmap_name);
559 free(upper);
560 return (B_FALSE);
561 }
562
563 for (proc = map->cmap_procs; proc != NULL; proc = proc->cproc_next) {
564 if (fprintf(f, ".It\n.Sy Family 0x%x, Model 0x%x\n",
565 proc->cproc_family, proc->cproc_model) == -1) {
566 warn("failed to write out model information for %s",
567 map->cmap_name);
568 free(upper);
569 return (B_FALSE);
570 }
571 }
572
573 if (fprintf(f, cpcgen_manual_data, map->cmap_path, upper,
574 map->cmap_name) == -1) {
575 warn("failed to write out manual header for %s",
576 map->cmap_name);
577 free(upper);
578 return (B_FALSE);
579 }
580
581 free(upper);
582 return (B_TRUE);
583 }
584
585 static boolean_t
586 cpcgen_manual_file_after(FILE *f, cpc_map_t *map)
587 {
588 if (fprintf(f, cpcgen_manual_trailer) == -1) {
589 warn("failed to write out manual header for %s",
590 map->cmap_name);
591 return (B_FALSE);
592 }
593
594 return (B_TRUE);
595 }
596
597 static boolean_t
598 cpcgen_manual_event(FILE *f, nvlist_t *nvl, const char *path, uint32_t ent)
599 {
600 char *event, *lname, *brief = NULL, *public = NULL, *errata = NULL;
601 size_t i;
602
603 if (nvlist_lookup_string(nvl, "EventName", &event) != 0) {
604 warnx("Found event without 'EventName' property "
605 "in %s, entry %u", path, ent);
606 return (B_FALSE);
607 }
608
609 /*
610 * Intel uses capital names. CPC historically uses lower case names.
611 */
612 if ((lname = strdup(event)) == NULL) {
613 err(EXIT_FAILURE, "failed to duplicate event name %s", event);
614 }
615 for (i = 0; lname[i] != '\0'; i++) {
616 lname[i] = tolower(event[i]);
617 }
618
619 /*
620 * Try to get the other event fields, but if they're not there, don't
621 * worry about it.
622 */
623 (void) nvlist_lookup_string(nvl, "BriefDescription", &brief);
624 (void) nvlist_lookup_string(nvl, "PublicDescription", &public);
625 (void) nvlist_lookup_string(nvl, "Errata", &errata);
626 if (errata != NULL && (strcmp(errata, "0") == 0 ||
627 strcmp(errata, "null") == 0)) {
628 errata = NULL;
629 }
630
631 if (fprintf(f, ".It Sy %s\n", lname) == -1) {
632 warn("failed to write out probe entry %s", event);
633 free(lname);
634 return (B_FALSE);
635 }
636
637 if (public != NULL) {
638 if (fprintf(f, "%s\n", public) == -1) {
639 warn("failed to write out probe entry %s", event);
640 free(lname);
641 return (B_FALSE);
642 }
643 } else if (brief != NULL) {
644 if (fprintf(f, "%s\n", brief) == -1) {
645 warn("failed to write out probe entry %s", event);
646 free(lname);
647 return (B_FALSE);
648 }
649 }
650
651 if (errata != NULL) {
652 if (fprintf(f, ".Pp\nThe following errata may apply to this: "
653 "%s\n", errata) == -1) {
654
655 warn("failed to write out probe entry %s", event);
656 free(lname);
657 return (B_FALSE);
658 }
659 }
660
661 free(lname);
662 return (B_TRUE);
663 }
664
665 static char *
666 cpcgen_cfile_name(cpc_map_t *map)
667 {
668 char *name;
669
670 if (asprintf(&name, "core_pcbe_%s.c", map->cmap_name) == -1) {
671 warn("failed to assemble file name for %s", map->cmap_path);
672 return (NULL);
673 }
674
675 return (name);
676 }
677
678 static boolean_t
679 cpcgen_cfile_file_before(FILE *f, cpc_map_t *map)
680 {
681 if (fprintf(f, cpcgen_cfile_header, map->cmap_path) == -1) {
682 warn("failed to write header to temporary file for %s",
683 map->cmap_path);
684 return (B_FALSE);
685 }
686
687 if (fprintf(f, cpcgen_cfile_table_start, map->cmap_name) == -1) {
688 warn("failed to write header to temporary file for %s",
689 map->cmap_path);
690 return (B_FALSE);
691 }
692
693 return (B_TRUE);
694 }
695
696 static boolean_t
697 cpcgen_cfile_file_after(FILE *f, cpc_map_t *map)
698 {
699 if (fprintf(f, cpcgen_cfile_table_end) == -1) {
700 warn("failed to write footer to temporary file for %s",
701 map->cmap_path);
702 return (B_FALSE);
703 }
704
705 return (B_TRUE);
706 }
707
708 static boolean_t
709 cpcgen_cfile_event(FILE *f, nvlist_t *nvl, const char *path, uint_t ent)
710 {
711 char *ecode, *umask, *name, *counter, *lname, *cmask;
712 size_t i;
713
714 if (nvlist_lookup_string(nvl, "EventName", &name) != 0) {
715 warnx("Found event without 'EventName' property "
716 "in %s, entry %u", path, ent);
717 return (B_FALSE);
718 }
719
720 if (nvlist_lookup_string(nvl, "EventCode", &ecode) != 0 ||
721 nvlist_lookup_string(nvl, "UMask", &umask) != 0 ||
722 nvlist_lookup_string(nvl, "Counter", &counter) != 0) {
723 warnx("event %s (index %u) from %s, missing "
724 "required properties for C file translation",
725 name, ent, path);
726 return (B_FALSE);
727 }
728
729 /*
730 * While we could try and parse the counters manually, just do this the
731 * max power way for now based on all possible values.
732 */
733 if (strcmp(counter, "0") == 0 || strcmp(counter, "0,") == 0) {
734 cmask = "C0";
735 } else if (strcmp(counter, "1") == 0) {
736 cmask = "C1";
737 } else if (strcmp(counter, "2") == 0) {
738 cmask = "C2";
739 } else if (strcmp(counter, "3") == 0) {
740 cmask = "C3";
741 } else if (strcmp(counter, "0,1") == 0) {
742 cmask = "C0|C1";
743 } else if (strcmp(counter, "0,1,2") == 0) {
744 cmask = "C0|C1|C2";
745 } else if (strcmp(counter, "0,1,2,3") == 0) {
746 cmask = "C0|C1|C2|C3";
747 } else if (strcmp(counter, "0,2,3") == 0) {
748 cmask = "C0|C2|C3";
749 } else if (strcmp(counter, "1,2,3") == 0) {
750 cmask = "C1|C2|C3";
751 } else if (strcmp(counter, "2,3") == 0) {
752 cmask = "C2|C3";
753 } else {
754 warnx("event %s (index %u) from %s, has unknown "
755 "counter value \"%s\"", name, ent, path, counter);
756 return (B_FALSE);
757 }
758
759
760 /*
761 * Intel uses capital names. CPC historically uses lower case names.
762 */
763 if ((lname = strdup(name)) == NULL) {
764 err(EXIT_FAILURE, "failed to duplicate event name %s", name);
765 }
766 for (i = 0; lname[i] != '\0'; i++) {
767 lname[i] = tolower(name[i]);
768 }
769
770 if (fprintf(f, "\t{ %s, %s, %s, \"%s\" },\n", ecode, umask, cmask,
771 lname) == -1) {
772 warn("failed to write out entry %s from %s", name, path);
773 free(lname);
774 return (B_FALSE);
775 }
776
777 free(lname);
778
779 /*
780 * Check if we have any PAPI aliases.
781 */
782 for (i = 0; cpcgen_papi_map[i].cpapi_intc != NULL; i++) {
783 if (strcmp(name, cpcgen_papi_map[i].cpapi_intc) != 0)
784 continue;
785
786 if (fprintf(f, "\t{ %s, %s, %s, \"%s\" },\n", ecode, umask,
787 cmask, cpcgen_papi_map[i].cpapi_papi) == -1) {
788 warn("failed to write out entry %s from %s", name,
789 path);
790 return (B_FALSE);
791 }
792 }
793
794 return (B_TRUE);
795 }
796
797 /*
798 * Generate a header file that declares all of these arrays and provide a map
799 * for models to the corresponding table to use.
800 */
801 static void
802 cpcgen_common_files(int dirfd)
803 {
804 const char *fname = "core_pcbe_cpcgen.h";
805 char *tmpname;
806 int fd;
807 FILE *f;
808 cpc_map_t *map;
809
810 if (asprintf(&tmpname, ".%s.%d", fname, getpid()) == -1) {
811 err(EXIT_FAILURE, "failed to construct temporary file name");
812 }
813
814 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0644)) < 0) {
815 err(EXIT_FAILURE, "failed to create temporary file %s",
816 tmpname);
817 }
818
819 if ((f = fdopen(fd, "w")) == NULL) {
820 int e = errno;
821 (void) unlinkat(dirfd, tmpname, 0);
822 errno = e;
823 err(EXIT_FAILURE, "failed to fdopen temporary file");
824 }
825
826 if (fprintf(f, cpcgen_cfile_header, cpcgen_mapfile) == -1) {
827 int e = errno;
828 (void) unlinkat(dirfd, tmpname, 0);
829 errno = e;
830 errx(EXIT_FAILURE, "failed to write header to temporary file "
831 "for %s", fname);
832 }
833
834 if (fprintf(f, "#ifndef _CORE_PCBE_CPCGEN_H\n"
835 "#define\t_CORE_PCBE_CPCGEN_H\n"
836 "\n"
837 "#ifdef __cplusplus\n"
838 "extern \"C\" {\n"
839 "#endif\n"
840 "\n"
841 "extern const struct events_table_t *core_cpcgen_table(uint_t);\n"
842 "\n") == -1) {
843 int e = errno;
844 (void) unlinkat(dirfd, tmpname, 0);
845 errno = e;
846 errx(EXIT_FAILURE, "failed to write header to "
847 "temporary file for %s", fname);
848 }
849
850 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
851 if (fprintf(f, "extern const struct events_table_t "
852 "pcbe_core_events_%s[];\n", map->cmap_name) == -1) {
853 int e = errno;
854 (void) unlinkat(dirfd, tmpname, 0);
855 errno = e;
856 errx(EXIT_FAILURE, "failed to write entry to "
857 "temporary file for %s", fname);
858 }
859 }
860
861 if (fprintf(f, "\n"
862 "#ifdef __cplusplus\n"
863 "}\n"
864 "#endif\n"
865 "\n"
866 "#endif /* _CORE_PCBE_CPCGEN_H */\n") == -1) {
867 int e = errno;
868 (void) unlinkat(dirfd, tmpname, 0);
869 errno = e;
870 errx(EXIT_FAILURE, "failed to write header to "
871 "temporary file for %s", fname);
872 }
873
874 if (fflush(f) != 0 || fclose(f) != 0) {
875 int e = errno;
876 (void) unlinkat(dirfd, tmpname, 0);
877 errno = e;
878 err(EXIT_FAILURE, "failed to flush and close temporary file");
879 }
880
881 if (renameat(dirfd, tmpname, dirfd, fname) != 0) {
882 err(EXIT_FAILURE, "failed to rename temporary file %s",
883 tmpname);
884 }
885
886 free(tmpname);
887
888 /* Now again for the .c file. */
889 fname = "core_pcbe_cpcgen.c";
890 if (asprintf(&tmpname, ".%s.%d", fname, getpid()) == -1) {
891 err(EXIT_FAILURE, "failed to construct temporary file name");
892 }
893
894 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0644)) < 0) {
895 err(EXIT_FAILURE, "failed to create temporary file %s",
896 tmpname);
897 }
898
899 if ((f = fdopen(fd, "w")) == NULL) {
900 int e = errno;
901 (void) unlinkat(dirfd, tmpname, 0);
902 errno = e;
903 err(EXIT_FAILURE, "failed to fdopen temporary file");
904 }
905
906 if (fprintf(f, cpcgen_cfile_header, cpcgen_mapfile) == -1) {
907 int e = errno;
908 (void) unlinkat(dirfd, tmpname, 0);
909 errno = e;
910 errx(EXIT_FAILURE, "failed to write header to temporary file "
911 "for %s", fname);
912 }
913
914 if (fprintf(f, "#include <core_pcbe_table.h>\n"
915 "#include <sys/null.h>\n"
916 "#include \"core_pcbe_cpcgen.h\"\n"
917 "\n"
918 "const struct events_table_t *\n"
919 "core_cpcgen_table(uint_t model)\n"
920 "{\n"
921 "\tswitch (model) {\n") == -1) {
922 int e = errno;
923 (void) unlinkat(dirfd, tmpname, 0);
924 errno = e;
925 errx(EXIT_FAILURE, "failed to write header to "
926 "temporary file for %s", fname);
927 }
928
929 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
930 cpc_proc_t *p;
931 for (p = map->cmap_procs; p != NULL; p = p->cproc_next) {
932 assert(p->cproc_family == 6);
933 if (fprintf(f, "\t\tcase 0x%x:\n", p->cproc_model) ==
934 -1) {
935 int e = errno;
936 (void) unlinkat(dirfd, tmpname, 0);
937 errno = e;
938 errx(EXIT_FAILURE, "failed to write header to "
939 "temporary file for %s", fname);
940 }
941 }
942 if (fprintf(f, "\t\t\treturn (pcbe_core_events_%s);\n",
943 map->cmap_name) == -1) {
944 int e = errno;
945 (void) unlinkat(dirfd, tmpname, 0);
946 errno = e;
947 errx(EXIT_FAILURE, "failed to write entry to "
948 "temporary file for %s", fname);
949 }
950 }
951
952 if (fprintf(f, "\t\tdefault:\n"
953 "\t\t\treturn (NULL);\n"
954 "\t}\n"
955 "}\n") == -1) {
956 int e = errno;
957 (void) unlinkat(dirfd, tmpname, 0);
958 errno = e;
959 errx(EXIT_FAILURE, "failed to write header to "
960 "temporary file for %s", fname);
961 }
962
963 if (fflush(f) != 0 || fclose(f) != 0) {
964 int e = errno;
965 (void) unlinkat(dirfd, tmpname, 0);
966 errno = e;
967 err(EXIT_FAILURE, "failed to flush and close temporary file");
968 }
969
970 if (renameat(dirfd, tmpname, dirfd, fname) != 0) {
971 err(EXIT_FAILURE, "failed to rename temporary file %s",
972 tmpname);
973 }
974
975 free(tmpname);
976 }
977
978 /*
979 * Look at a rule to determine whether or not we should consider including it or
980 * not. At this point we've already filtered things such that we only get core
981 * events.
982 *
983 * To consider an entry, we currently apply the following criteria:
984 *
985 * - The MSRIndex and MSRValue are zero. Programming additional MSRs is no
986 * supported right now.
987 * - TakenAlone is non-zero, which means that it cannot run at the same time as
988 * another field.
989 * - Offcore is one, indicating that it is off the core and we need to figure
990 * out if we can support this.
991 * - If the counter is fixed, don't use it for now.
992 * - If more than one value is specified in the EventCode or UMask values
993 */
994 static boolean_t
995 cpcgen_skip_entry(nvlist_t *nvl, const char *path, uint_t ent)
996 {
997 char *event, *msridx, *msrval, *taken, *offcore, *counter;
998 char *ecode, *umask;
999
1000 /*
1001 * Require EventName, it's kind of useless without that.
1002 */
1003 if (nvlist_lookup_string(nvl, "EventName", &event) != 0) {
1004 errx(EXIT_FAILURE, "Found event without 'EventName' property "
1005 "in %s, entry %u", path, ent);
1006 }
1007
1008 /*
1009 * If we can't find an expected value, whine about it.
1010 */
1011 if (nvlist_lookup_string(nvl, "MSRIndex", &msridx) != 0 ||
1012 nvlist_lookup_string(nvl, "MSRValue", &msrval) != 0 ||
1013 nvlist_lookup_string(nvl, "Counter", &counter) != 0 ||
1014 nvlist_lookup_string(nvl, "EventCode", &ecode) != 0 ||
1015 nvlist_lookup_string(nvl, "UMask", &umask) != 0 ||
1016 nvlist_lookup_string(nvl, "Offcore", &offcore) != 0) {
1017 warnx("Skipping event %s (index %u) from %s, missing required "
1018 "property", event, ent, path);
1019 return (B_TRUE);
1020 }
1021
1022 /*
1023 * MSRIndex and MSRvalue comes as either "0" or "0x00".
1024 */
1025 if ((strcmp(msridx, "0") != 0 && strcmp(msridx, "0x00") != 0) ||
1026 (strcmp(msrval, "0") != 0 && strcmp(msridx, "0x00") != 0) ||
1027 strcmp(offcore, "0") != 0 || strchr(ecode, ',') != NULL ||
1028 strchr(umask, ',') != NULL) {
1029 return (B_TRUE);
1030 }
1031
1032 /*
1033 * Unfortunately, not everything actually has "TakenAlone". If it
1034 * doesn't, we assume that it doesn't have to be.
1035 */
1036 if (nvlist_lookup_string(nvl, "TakenAlone", &taken) == 0 &&
1037 strcmp(taken, "0") != 0) {
1038 return (B_TRUE);
1039 }
1040
1041
1042 if (strncasecmp(counter, "fixed", strlen("fixed")) == 0)
1043 return (B_TRUE);
1044
1045 return (B_FALSE);
1046 }
1047
1048 /*
1049 * For each processor family, generate a data file that contains all of the
1050 * events that we support. Also generate a header that can be included that
1051 * declares all of the tables.
1052 */
1053 static void
1054 cpcgen_gen(int dirfd)
1055 {
1056 cpc_map_t *map = cpcgen_maps;
1057
1058 if (map == NULL) {
1059 errx(EXIT_FAILURE, "no platforms found or matched");
1060 }
1061
1062 for (map = cpcgen_maps; map != NULL; map = map->cmap_next) {
1063 int fd, ret;
1064 FILE *f;
1065 char *tmpname, *name;
1066 uint32_t length, i;
1067
1068 if ((name = cpcgen_ops.cgen_op_name(map)) == NULL) {
1069 exit(EXIT_FAILURE);
1070 }
1071
1072 if (asprintf(&tmpname, ".%s.%d", name, getpid()) == -1) {
1073 err(EXIT_FAILURE, "failed to construct temporary file "
1074 "name");
1075 }
1076
1077 if ((fd = openat(dirfd, tmpname, O_RDWR | O_CREAT, 0444)) < 0) {
1078 err(EXIT_FAILURE, "failed to create temporary file %s",
1079 tmpname);
1080 }
1081
1082 if ((f = fdopen(fd, "w")) == NULL) {
1083 int e = errno;
1084 (void) unlinkat(dirfd, tmpname, 0);
1085 errno = e;
1086 err(EXIT_FAILURE, "failed to fdopen temporary file");
1087 }
1088
1089 if (!cpcgen_ops.cgen_op_file_before(f, map)) {
1090 (void) unlinkat(dirfd, tmpname, 0);
1091 exit(EXIT_FAILURE);
1092 }
1093
1094 /*
1095 * Iterate over array contents.
1096 */
1097 if ((ret = nvlist_lookup_uint32(map->cmap_data, "length",
1098 &length)) != 0) {
1099 errx(EXIT_FAILURE, "failed to look up length property "
1100 "in parsed data for %s: %s", map->cmap_path,
1101 strerror(ret));
1102 }
1103
1104 for (i = 0; i < length; i++) {
1105 nvlist_t *nvl;
1106 char num[64];
1107
1108 (void) snprintf(num, sizeof (num), "%u", i);
1109 if ((ret = nvlist_lookup_nvlist(map->cmap_data,
1110 num, &nvl)) != 0) {
1111 errx(EXIT_FAILURE, "failed to look up array "
1112 "entry %u in parsed data for %s: %s", i,
1113 map->cmap_path, strerror(ret));
1114 }
1115
1116 if (cpcgen_skip_entry(nvl, map->cmap_path, i))
1117 continue;
1118
1119 if (!cpcgen_ops.cgen_op_event(f, nvl, map->cmap_path,
1120 i)) {
1121 (void) unlinkat(dirfd, tmpname, 0);
1122 exit(EXIT_FAILURE);
1123 }
1124 }
1125
1126 if (!cpcgen_ops.cgen_op_file_after(f, map)) {
1127 (void) unlinkat(dirfd, tmpname, 0);
1128 exit(EXIT_FAILURE);
1129 }
1130
1131 if (fflush(f) != 0 || fclose(f) != 0) {
1132 int e = errno;
1133 (void) unlinkat(dirfd, tmpname, 0);
1134 errno = e;
1135 err(EXIT_FAILURE, "failed to flush and close "
1136 "temporary file");
1137 }
1138
1139 if (renameat(dirfd, tmpname, dirfd, name) != 0) {
1140 err(EXIT_FAILURE, "failed to rename temporary file %s",
1141 tmpname);
1142 }
1143
1144 free(name);
1145 free(tmpname);
1146 }
1147 }
1148
1149 static void
1150 cpcgen_usage(const char *fmt, ...)
1151 {
1152 if (fmt != NULL) {
1153 va_list ap;
1154
1155 (void) fprintf(stderr, "%s: ", cpcgen_progname);
1156 va_start(ap, fmt);
1157 (void) vfprintf(stderr, fmt, ap);
1158 va_end(ap);
1159 }
1160
1161 (void) fprintf(stderr, "Usage: %s -a|-p platform -c|-H|-m -d datadir "
1162 "-o outdir\n"
1163 "\n"
1164 "\t-a generate data for all platforms\n"
1165 "\t-c generate C file for CPC\n"
1166 "\t-d specify the directory containt perfmon data\n"
1167 "\t-h generate header file and common files\n"
1168 "\t-m generate manual pages for CPC data\n"
1169 "\t-o outut files in directory outdir\n"
1170 "\t-p generate data for a specified platform\n",
1171 cpcgen_progname);
1172 }
1173
1174 int
1175 main(int argc, char *argv[])
1176 {
1177 int c, outdirfd;
1178 boolean_t do_mpage = B_FALSE, do_cfile = B_FALSE, do_header = B_FALSE,
1179 do_all = B_FALSE;
1180 const char *datadir = NULL, *outdir = NULL, *platform = NULL;
1181 uint_t count = 0;
1182
1183 cpcgen_progname = basename(argv[0]);
1184
1185 while ((c = getopt(argc, argv, ":acd:hHmo:p:")) != -1) {
1186 switch (c) {
1187 case 'a':
1188 do_all = B_TRUE;
1189 break;
1190 case 'c':
1191 do_cfile = B_TRUE;
1192 break;
1193 case 'd':
1194 datadir = optarg;
1195 break;
1196 case 'm':
1197 do_mpage = B_TRUE;
1198 break;
1199 case 'H':
1200 do_header = B_TRUE;
1201 break;
1202 case 'o':
1203 outdir = optarg;
1204 break;
1205 case 'p':
1206 platform = optarg;
1207 break;
1208 case ':':
1209 cpcgen_usage("Option -%c requires an operand\n",
1210 optopt);
1211 return (2);
1212 case '?':
1213 cpcgen_usage("Unknown option: -%c\n", optopt);
1214 return (2);
1215 case 'h':
1216 default:
1217 cpcgen_usage(NULL);
1218 return (2);
1219 }
1220 }
1221
1222 count = 0;
1223 if (do_mpage)
1224 count++;
1225 if (do_cfile)
1226 count++;
1227 if (do_header)
1228 count++;
1229 if (count > 1) {
1230 cpcgen_usage("Only one of -c, -h, and -m may be specified\n");
1231 return (2);
1232 } else if (count == 0) {
1233 cpcgen_usage("One of -c, -h, and -m is required\n");
1234 return (2);
1235 }
1236
1237 count = 0;
1238 if (do_all)
1239 count++;
1240 if (platform != NULL)
1241 count++;
1242 if (count > 1) {
1243 cpcgen_usage("Only one of -a and -p may be specified\n");
1244 return (2);
1245 } else if (count == 0) {
1246 cpcgen_usage("One of -a and -p is required\n");
1247 return (2);
1248 }
1249
1250
1251 if (outdir == NULL) {
1252 cpcgen_usage("Missing required output directory (-o)\n");
1253 return (2);
1254 }
1255
1256 if ((outdirfd = open(outdir, O_RDONLY)) < 0) {
1257 err(EXIT_FAILURE, "failed to open output directory %s", outdir);
1258 }
1259
1260 if (datadir == NULL) {
1261 cpcgen_usage("Missing required data directory (-d)\n");
1262 return (2);
1263 }
1264
1265 cpcgen_read_mapfile(datadir, platform);
1266
1267 if (do_header) {
1268 cpcgen_common_files(outdirfd);
1269 return (0);
1270 }
1271
1272 if (do_mpage) {
1273 cpcgen_ops.cgen_op_name = cpcgen_manual_name;
1274 cpcgen_ops.cgen_op_file_before = cpcgen_manual_file_before;
1275 cpcgen_ops.cgen_op_file_after = cpcgen_manual_file_after;
1276 cpcgen_ops.cgen_op_event = cpcgen_manual_event;
1277 }
1278
1279 if (do_cfile) {
1280 cpcgen_ops.cgen_op_name = cpcgen_cfile_name;
1281 cpcgen_ops.cgen_op_file_before = cpcgen_cfile_file_before;
1282 cpcgen_ops.cgen_op_file_after = cpcgen_cfile_file_after;
1283 cpcgen_ops.cgen_op_event = cpcgen_cfile_event;
1284 }
1285
1286
1287 cpcgen_gen(outdirfd);
1288
1289 return (0);
1290 }