1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2003,2004 Joseph Koshy 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 #include <sys/param.h> 32 #include <sys/queue.h> 33 #include <sys/cpuset.h> 34 #include <sys/sysctl.h> 35 36 #include <assert.h> 37 #include <err.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <limits.h> 41 #include <pmc.h> 42 #include <stdarg.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <sysexits.h> 47 #include <unistd.h> 48 49 /* Compile time defaults */ 50 51 #define PMCC_PRINT_USAGE 0 52 #define PMCC_PRINT_EVENTS 1 53 #define PMCC_LIST_STATE 2 54 #define PMCC_ENABLE_DISABLE 3 55 #define PMCC_SHOW_STATISTICS 4 56 57 #define PMCC_CPU_ALL -1 58 #define PMCC_CPU_WILDCARD '*' 59 60 #define PMCC_PMC_ALL -1 61 #define PMCC_PMC_WILDCARD '*' 62 63 #define PMCC_OP_IGNORE 0 64 #define PMCC_OP_DISABLE 1 65 #define PMCC_OP_ENABLE 2 66 67 #define PMCC_PROGRAM_NAME "pmccontrol" 68 69 static STAILQ_HEAD(pmcc_op_list, pmcc_op) head = STAILQ_HEAD_INITIALIZER(head); 70 71 struct pmcc_op { 72 char op_cpu; 73 char op_pmc; 74 char op_op; 75 STAILQ_ENTRY(pmcc_op) op_next; 76 }; 77 78 /* Function Prototypes */ 79 #if DEBUG 80 static void pmcc_init_debug(void); 81 #endif 82 83 static int pmcc_do_list_state(void); 84 static int pmcc_do_enable_disable(struct pmcc_op_list *); 85 static int pmcc_do_list_events(void); 86 87 /* Globals */ 88 89 static char usage_message[] = 90 "Usage:\n" 91 " " PMCC_PROGRAM_NAME " -L\n" 92 " " PMCC_PROGRAM_NAME " -l\n" 93 " " PMCC_PROGRAM_NAME " -s\n" 94 " " PMCC_PROGRAM_NAME " [-e pmc | -d pmc | -c cpu] ..."; 95 96 #if DEBUG 97 static FILE *debug_stream = NULL; 98 #endif 99 100 #if DEBUG 101 #define DEBUG_MSG(...) \ 102 (void) fprintf(debug_stream, "[pmccontrol] " __VA_ARGS__) 103 #else 104 #define DEBUG_MSG(m) /* */ 105 #endif /* !DEBUG */ 106 107 #if DEBUG 108 /* log debug messages to a separate file */ 109 static void 110 pmcc_init_debug(void) 111 { 112 char *fn; 113 114 fn = getenv("PMCCONTROL_DEBUG"); 115 if (fn != NULL) 116 { 117 debug_stream = fopen(fn, "w"); 118 if (debug_stream == NULL) 119 debug_stream = stderr; 120 } else 121 debug_stream = stderr; 122 } 123 #endif 124 125 static int 126 pmcc_do_enable_disable(struct pmcc_op_list *op_list) 127 { 128 int c, error, i, j, ncpu, npmc, t; 129 struct pmcc_op *np; 130 unsigned char *map; 131 unsigned char op; 132 int cpu, pmc; 133 134 if ((ncpu = pmc_ncpu()) < 0) 135 err(EX_OSERR, "Unable to determine the number of cpus"); 136 137 /* Determine the maximum number of PMCs in any CPU. */ 138 npmc = 0; 139 for (c = 0; c < ncpu; c++) { 140 if ((t = pmc_npmc(c)) < 0) 141 err(EX_OSERR, 142 "Unable to determine the number of PMCs in CPU %d", 143 c); 144 npmc = MAX(t, npmc); 145 } 146 147 if (npmc == 0) 148 errx(EX_CONFIG, "No PMCs found"); 149 150 if ((map = calloc(npmc, ncpu)) == NULL) 151 err(EX_SOFTWARE, "Out of memory"); 152 153 error = 0; 154 STAILQ_FOREACH(np, op_list, op_next) { 155 156 cpu = np->op_cpu; 157 pmc = np->op_pmc; 158 op = np->op_op; 159 160 if (cpu >= ncpu) 161 errx(EX_DATAERR, "CPU id too large: \"%d\"", cpu); 162 163 if (pmc >= npmc) 164 errx(EX_DATAERR, "PMC id too large: \"%d\"", pmc); 165 166 #define MARKMAP(M,C,P,V) do { \ 167 *((M) + (C)*npmc + (P)) = (V); \ 168 } while (0) 169 170 #define SET_PMCS(C,P,V) do { \ 171 if ((P) == PMCC_PMC_ALL) { \ 172 for (j = 0; j < npmc; j++) \ 173 MARKMAP(map, (C), j, (V)); \ 174 } else \ 175 MARKMAP(map, (C), (P), (V)); \ 176 } while (0) 177 178 #define MAP(M,C,P) (*((M) + (C)*npmc + (P))) 179 180 if (cpu == PMCC_CPU_ALL) 181 for (i = 0; i < ncpu; i++) { 182 SET_PMCS(i, pmc, op); 183 } 184 else 185 SET_PMCS(cpu, pmc, op); 186 } 187 188 /* Configure PMCS */ 189 for (i = 0; i < ncpu; i++) 190 for (j = 0; j < npmc; j++) { 191 unsigned char b; 192 193 b = MAP(map, i, j); 194 195 error = 0; 196 197 if (b == PMCC_OP_ENABLE) 198 error = pmc_enable(i, j); 199 else if (b == PMCC_OP_DISABLE) 200 error = pmc_disable(i, j); 201 202 if (error < 0) 203 err(EX_OSERR, "%s of PMC %d on CPU %d failed", 204 b == PMCC_OP_ENABLE ? "Enable" : "Disable", 205 j, i); 206 } 207 208 return error; 209 } 210 211 static int 212 pmcc_do_list_state(void) 213 { 214 cpuset_t logical_cpus_mask; 215 long cpusetsize; 216 size_t setsize; 217 int c, cpu, n, npmc, ncpu; 218 struct pmc_info *pd; 219 struct pmc_pmcinfo *pi; 220 const struct pmc_cpuinfo *pc; 221 222 if (pmc_cpuinfo(&pc) != 0) 223 err(EX_OSERR, "Unable to determine CPU information"); 224 225 printf("%d %s CPUs present, with %d PMCs per CPU\n", pc->pm_ncpu, 226 pmc_name_of_cputype(pc->pm_cputype), 227 pc->pm_npmc); 228 229 /* Determine the set of logical CPUs. */ 230 cpusetsize = sysconf(_SC_CPUSET_SIZE); 231 if (cpusetsize == -1 || (u_long)cpusetsize > sizeof(cpuset_t)) 232 err(EX_OSERR, "Cannot determine which CPUs are logical"); 233 CPU_ZERO(&logical_cpus_mask); 234 setsize = (size_t)cpusetsize; 235 if (sysctlbyname("machdep.logical_cpus_mask", &logical_cpus_mask, 236 &setsize, NULL, 0) < 0) 237 CPU_ZERO(&logical_cpus_mask); 238 239 ncpu = pc->pm_ncpu; 240 241 for (c = cpu = 0; cpu < ncpu; cpu++) { 242 if (pmc_pmcinfo(cpu, &pi) < 0) { 243 if (errno == ENXIO) 244 continue; 245 err(EX_OSERR, "Unable to get PMC status for CPU %d", 246 cpu); 247 } 248 249 printf("#CPU %d:\n", c++); 250 npmc = pmc_npmc(cpu); 251 printf("#N NAME CLASS STATE ROW-DISP\n"); 252 253 for (n = 0; n < npmc; n++) { 254 pd = &pi->pm_pmcs[n]; 255 256 printf(" %-2d %-16s %-6s %-8s %-10s", 257 n, 258 pd->pm_name, 259 pmc_name_of_class(pd->pm_class), 260 pd->pm_enabled ? "ENABLED" : "DISABLED", 261 pmc_name_of_disposition(pd->pm_rowdisp)); 262 263 if (pd->pm_ownerpid != -1) { 264 printf(" (pid %d)", pd->pm_ownerpid); 265 printf(" %-32s", 266 pmc_name_of_event(pd->pm_event)); 267 if (PMC_IS_SAMPLING_MODE(pd->pm_mode)) 268 printf(" (reload count %jd)", 269 pd->pm_reloadcount); 270 } 271 printf("\n"); 272 } 273 free(pi); 274 } 275 return 0; 276 } 277 278 static int 279 pmcc_do_list_events(void) 280 { 281 enum pmc_class c; 282 unsigned int i, j, nevents; 283 const char **eventnamelist; 284 const struct pmc_cpuinfo *ci; 285 286 /* First, try pmu events. */ 287 if (pmc_pmu_enabled()) { 288 pmc_pmu_print_counters(NULL); 289 return (0); 290 } 291 292 /* Otherwise, use the legacy pmc(3) interfaces. */ 293 if (pmc_cpuinfo(&ci) != 0) 294 err(EX_OSERR, "Unable to determine CPU information"); 295 296 eventnamelist = NULL; 297 298 for (i = 0; i < ci->pm_nclass; i++) { 299 c = ci->pm_classes[i].pm_class; 300 301 printf("%s\n", pmc_name_of_class(c)); 302 if (pmc_event_names_of_class(c, &eventnamelist, &nevents) < 0) 303 err(EX_OSERR, 304 "ERROR: Cannot find information for event class \"%s\"", 305 pmc_name_of_class(c)); 306 307 for (j = 0; j < nevents; j++) 308 printf("\t%s\n", eventnamelist[j]); 309 310 free(eventnamelist); 311 } 312 return 0; 313 } 314 315 static int 316 pmcc_show_statistics(void) 317 { 318 319 struct pmc_driverstats gms; 320 321 if (pmc_get_driver_stats(&gms) < 0) 322 err(EX_OSERR, "ERROR: cannot retrieve driver statistics"); 323 324 /* 325 * Print statistics. 326 */ 327 328 #define PRINT(N,V) (void) printf("%-40s %d\n", (N), gms.pm_##V) 329 PRINT("interrupts processed:", intr_processed); 330 PRINT("non-PMC interrupts:", intr_ignored); 331 PRINT("sampling stalls due to space shortages:", intr_bufferfull); 332 PRINT("system calls:", syscalls); 333 PRINT("system calls with errors:", syscall_errors); 334 PRINT("buffer requests:", buffer_requests); 335 PRINT("buffer requests failed:", buffer_requests_failed); 336 PRINT("sampling log sweeps:", log_sweeps); 337 338 return 0; 339 } 340 341 /* 342 * Main 343 */ 344 345 int 346 main(int argc, char **argv) 347 { 348 int error, command, currentcpu, option, pmc; 349 char *dummy; 350 struct pmcc_op *p; 351 352 #if DEBUG 353 pmcc_init_debug(); 354 #endif 355 356 /* parse args */ 357 358 currentcpu = PMCC_CPU_ALL; 359 command = PMCC_PRINT_USAGE; 360 error = 0; 361 362 STAILQ_INIT(&head); 363 364 while ((option = getopt(argc, argv, ":c:d:e:lLs")) != -1) 365 switch (option) { 366 case 'L': 367 if (command != PMCC_PRINT_USAGE) { 368 error = 1; 369 break; 370 } 371 command = PMCC_PRINT_EVENTS; 372 break; 373 374 case 'c': 375 if (command != PMCC_PRINT_USAGE && 376 command != PMCC_ENABLE_DISABLE) { 377 error = 1; 378 break; 379 } 380 command = PMCC_ENABLE_DISABLE; 381 382 if (*optarg == PMCC_CPU_WILDCARD) 383 currentcpu = PMCC_CPU_ALL; 384 else { 385 currentcpu = strtoul(optarg, &dummy, 0); 386 if (*dummy != '\0' || currentcpu < 0) 387 errx(EX_DATAERR, 388 "\"%s\" is not a valid CPU id", 389 optarg); 390 } 391 break; 392 393 case 'd': 394 case 'e': 395 if (command != PMCC_PRINT_USAGE && 396 command != PMCC_ENABLE_DISABLE) { 397 error = 1; 398 break; 399 } 400 command = PMCC_ENABLE_DISABLE; 401 402 if (*optarg == PMCC_PMC_WILDCARD) 403 pmc = PMCC_PMC_ALL; 404 else { 405 pmc = strtoul(optarg, &dummy, 0); 406 if (*dummy != '\0' || pmc < 0) 407 errx(EX_DATAERR, 408 "\"%s\" is not a valid PMC id", 409 optarg); 410 } 411 412 if ((p = malloc(sizeof(*p))) == NULL) 413 err(EX_SOFTWARE, "Out of memory"); 414 415 p->op_cpu = currentcpu; 416 p->op_pmc = pmc; 417 p->op_op = option == 'd' ? PMCC_OP_DISABLE : 418 PMCC_OP_ENABLE; 419 420 STAILQ_INSERT_TAIL(&head, p, op_next); 421 break; 422 423 case 'l': 424 if (command != PMCC_PRINT_USAGE) { 425 error = 1; 426 break; 427 } 428 command = PMCC_LIST_STATE; 429 break; 430 431 case 's': 432 if (command != PMCC_PRINT_USAGE) { 433 error = 1; 434 break; 435 } 436 command = PMCC_SHOW_STATISTICS; 437 break; 438 439 case ':': 440 errx(EX_USAGE, 441 "Missing argument to option '-%c'", optopt); 442 break; 443 444 case '?': 445 warnx("Unrecognized option \"-%c\"", optopt); 446 errx(EX_USAGE, "%s", usage_message); 447 break; 448 449 default: 450 error = 1; 451 break; 452 453 } 454 455 if (command == PMCC_PRINT_USAGE) 456 (void) errx(EX_USAGE, "%s", usage_message); 457 458 if (error) 459 exit(EX_USAGE); 460 461 if (pmc_init() < 0) 462 err(EX_UNAVAILABLE, 463 "Initialization of the pmc(3) library failed"); 464 465 switch (command) { 466 case PMCC_LIST_STATE: 467 error = pmcc_do_list_state(); 468 break; 469 case PMCC_PRINT_EVENTS: 470 error = pmcc_do_list_events(); 471 break; 472 case PMCC_SHOW_STATISTICS: 473 error = pmcc_show_statistics(); 474 break; 475 case PMCC_ENABLE_DISABLE: 476 if (STAILQ_EMPTY(&head)) 477 errx(EX_USAGE, 478 "No PMCs specified to enable or disable"); 479 error = pmcc_do_enable_disable(&head); 480 break; 481 default: 482 assert(0); 483 484 } 485 486 if (error != 0) 487 err(EX_OSERR, "Command failed"); 488 exit(0); 489 } 490