1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <stdio.h> 27 #include <stdarg.h> 28 #include <dtrace.h> 29 #include <errno.h> 30 #include <string.h> 31 #include <stdlib.h> 32 #include <unistd.h> 33 #include <limits.h> 34 #include <strings.h> 35 #include <termio.h> 36 #include <signal.h> 37 #include <locale.h> 38 39 #include "statcommon.h" 40 41 #define INTRSTAT_COLUMN_OFFS 14 42 #define INTRSTAT_COLUMNS_PER_CPU 15 43 #define INTRSTAT_CPUS_PER_LINE(w) \ 44 (((w) - INTRSTAT_COLUMN_OFFS) / INTRSTAT_COLUMNS_PER_CPU) 45 #define INTRSTAT_OPTSTR "x:c:C:T:" 46 47 static uint_t timestamp_fmt = NODATE; 48 49 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 50 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't */ 51 #endif 52 53 static dtrace_hdl_t *g_dtp; 54 static int *g_present; 55 static int g_max_cpus; 56 static int g_start, g_end; 57 static int g_header; 58 static long g_sleeptime = 1; 59 static hrtime_t g_interval = NANOSEC; 60 static int g_intr; 61 static psetid_t g_pset = PS_NONE; 62 static processorid_t *g_pset_cpus; 63 static uint_t g_pset_ncpus; 64 static int g_cpus_per_line = INTRSTAT_CPUS_PER_LINE(80); 65 66 static const char *g_pname = "intrstat"; 67 static const char *g_prog = 68 "interrupt-start" 69 "/arg0 != NULL/" 70 "{" 71 " self->ts = vtimestamp;" 72 "}" 73 "" 74 "interrupt-complete" 75 "/self->ts/" 76 "{" 77 " this->devi = (struct dev_info *)arg0;" 78 " @counts[stringof(`devnamesp[this->devi->devi_major].dn_name)," 79 " this->devi->devi_instance] = count();" 80 " @times[stringof(`devnamesp[this->devi->devi_major].dn_name)," 81 " this->devi->devi_instance] = sum(vtimestamp - self->ts);" 82 " self->ts = 0;" 83 "}"; 84 85 static void 86 usage(void) 87 { 88 (void) fprintf(stderr, 89 "usage: intrstat [ -C psrset | -c cpulist ] [-x opt[=val]] " 90 "[-T d|u] [interval [ count]]\n"); 91 92 exit(EXIT_FAILURE); 93 } 94 95 static void 96 fatal(const char *fmt, ...) 97 { 98 va_list ap; 99 100 va_start(ap, fmt); 101 102 (void) fprintf(stderr, "%s: ", g_pname); 103 (void) vfprintf(stderr, fmt, ap); 104 105 if (fmt[strlen(fmt) - 1] != '\n') 106 (void) fprintf(stderr, ": %s\n", 107 dtrace_errmsg(g_dtp, dtrace_errno(g_dtp))); 108 109 exit(EXIT_FAILURE); 110 } 111 112 /*ARGSUSED*/ 113 static void 114 intr(int signo) 115 { 116 g_intr++; 117 } 118 119 static void 120 status(int signal __unused) 121 { 122 } 123 124 static void 125 set_width(int sig __unused) 126 { 127 struct winsize win; 128 129 if (!isatty(fileno(stdout))) 130 return; 131 132 if (ioctl(fileno(stdout), TIOCGWINSZ, &win) == -1) 133 return; 134 135 if (win.ws_col == 0) { 136 /* 137 * If TIOCGWINSZ returned 0 for the columns, just return -- 138 * thereby using the default value of g_cpus_per_line. (This 139 * happens, e.g., when running over a tip line.) 140 */ 141 return; 142 } 143 144 g_cpus_per_line = INTRSTAT_CPUS_PER_LINE(win.ws_col); 145 146 if (g_cpus_per_line < 1) 147 g_cpus_per_line = 1; 148 } 149 150 static void 151 print_header() 152 { 153 int i, j; 154 char c[256]; 155 156 if (!g_header) 157 return; 158 159 (void) printf("\n%12s |", "device"); 160 for (i = g_start, j = 0; i < g_max_cpus; i++) { 161 if (!g_present[i]) 162 continue; 163 164 (void) sprintf(c, "cpu%d", i); 165 (void) printf(" %9s %%tim", c); 166 167 if (++j >= g_cpus_per_line) 168 break; 169 } 170 171 (void) printf("\n-------------+"); 172 173 while (j--) 174 (void) printf("---------------"); 175 176 (void) printf("\n"); 177 g_header = 0; 178 } 179 180 /*ARGSUSED*/ 181 static int 182 walk(const dtrace_aggdata_t *data, void *arg) 183 { 184 dtrace_aggdesc_t *aggdesc = data->dtada_desc; 185 dtrace_recdesc_t *nrec, *irec; 186 char *name, c[256]; 187 int32_t *instance; 188 static const dtrace_aggdata_t *count; 189 int i, j; 190 191 if (count == NULL) { 192 count = data; 193 return (DTRACE_AGGWALK_NEXT); 194 } 195 196 nrec = &aggdesc->dtagd_rec[1]; 197 irec = &aggdesc->dtagd_rec[2]; 198 199 name = data->dtada_data + nrec->dtrd_offset; 200 /* LINTED - alignment */ 201 instance = (int32_t *)(data->dtada_data + irec->dtrd_offset); 202 203 for (i = g_start, j = 0; i < g_max_cpus && j < g_cpus_per_line; i++) { 204 /* LINTED - alignment */ 205 uint64_t time = *((uint64_t *)(data->dtada_percpu[i])); 206 /* LINTED - alignment */ 207 uint64_t n = *((uint64_t *)(count->dtada_percpu[i])); 208 209 if (!g_present[i]) 210 continue; 211 212 if (j++ == 0) { 213 print_header(); 214 (void) snprintf(c, sizeof (c), "%s#%d", 215 name, *instance); 216 (void) printf("%12s |", c); 217 } 218 219 (void) printf(" %9lld %4.1f", 220 (unsigned long long)((double)n / 221 ((double)g_interval / (double)NANOSEC)), 222 ((double)time * (double)100.0) / (double)g_interval); 223 } 224 225 (void) printf(j ? "\n" : ""); 226 g_end = i; 227 count = NULL; 228 return (DTRACE_AGGWALK_NEXT); 229 } 230 231 static void 232 select_cpu(processorid_t cpu) 233 { 234 if (g_pset != PS_NONE) 235 fatal("cannot specify both a processor set and a processor\n"); 236 237 if (cpu < 0 || cpu >= g_max_cpus) 238 fatal("cpu %d out of range\n", cpu); 239 240 if (p_online(cpu, P_STATUS) == -1) { 241 if (errno != EINVAL) 242 fatal("could not get status for cpu %d", cpu); 243 fatal("cpu %d not present\n", cpu); 244 } 245 246 g_present[cpu] = 1; 247 } 248 249 static void 250 select_cpus(processorid_t low, processorid_t high) 251 { 252 if (g_pset != PS_NONE) 253 fatal("cannot specify both a processor set and processors\n"); 254 255 if (low < 0 || low >= g_max_cpus) 256 fatal("invalid cpu '%d'\n", low); 257 258 if (high < 0 || high >= g_max_cpus) 259 fatal("invalid cpu '%d'\n", high); 260 261 if (low >= high) 262 fatal("invalid range '%d' to '%d'\n", low, high); 263 264 do { 265 if (p_online(low, P_STATUS) != -1) 266 g_present[low] = 1; 267 } while (++low <= high); 268 } 269 270 static void 271 select_pset(psetid_t pset) 272 { 273 processorid_t i; 274 275 if (pset < 0) 276 fatal("processor set %d is out of range\n", pset); 277 278 /* 279 * Only one processor set can be specified. 280 */ 281 if (g_pset != PS_NONE) 282 fatal("at most one processor set may be specified\n"); 283 284 /* 285 * One cannot select processors _and_ a processor set. 286 */ 287 for (i = 0; i < g_max_cpus; i++) 288 if (g_present[i]) 289 break; 290 291 if (i != g_max_cpus) 292 fatal("cannot specify both a processor and a processor set\n"); 293 294 g_pset = pset; 295 g_pset_ncpus = g_max_cpus; 296 297 if (pset_info(g_pset, NULL, &g_pset_ncpus, g_pset_cpus) == -1) 298 fatal("invalid processor set: %d\n", g_pset); 299 300 if (g_pset_ncpus == 0) 301 fatal("processor set %d empty\n", g_pset); 302 303 for (i = 0; i < g_pset_ncpus; i++) 304 g_present[g_pset_cpus[i]] = 1; 305 } 306 307 static void 308 check_pset(void) 309 { 310 uint_t ncpus = g_max_cpus; 311 processorid_t i; 312 313 if (g_pset == PS_NONE) 314 return; 315 316 if (pset_info(g_pset, NULL, &ncpus, g_pset_cpus) == -1) { 317 if (errno == EINVAL) 318 fatal("processor set %d destroyed\n", g_pset); 319 320 fatal("couldn't get info for processor set %d", g_pset); 321 } 322 323 if (ncpus == 0) 324 fatal("processor set %d empty\n", g_pset); 325 326 if (ncpus == g_pset_ncpus) { 327 for (i = 0; i < g_pset_ncpus; i++) { 328 if (!g_present[g_pset_cpus[i]]) 329 break; 330 } 331 332 /* 333 * If the number of CPUs hasn't changed, and every CPU 334 * in the processor set is also selected, we know that the 335 * processor set itself hasn't changed. 336 */ 337 if (i == g_pset_ncpus) 338 return; 339 } 340 341 /* 342 * If we're here, we have a new processor set. First, we need 343 * to zero out the present array. 344 */ 345 bzero(g_present, sizeof (processorid_t) * g_max_cpus); 346 347 g_pset_ncpus = ncpus; 348 349 for (i = 0; i < g_pset_ncpus; i++) 350 g_present[g_pset_cpus[i]] = 1; 351 } 352 353 int 354 main(int argc, char **argv) 355 { 356 dtrace_prog_t *prog; 357 dtrace_proginfo_t info; 358 int err, i, indefinite = 1; 359 long iter; 360 processorid_t id; 361 struct sigaction act; 362 struct itimerspec ts; 363 struct sigevent ev; 364 sigset_t set; 365 timer_t tid; 366 char *end, *p; 367 int c; 368 hrtime_t last, now; 369 dtrace_optval_t statustime; 370 371 (void) setlocale(LC_ALL, ""); 372 (void) textdomain(TEXT_DOMAIN); 373 374 (void) sigemptyset(&act.sa_mask); 375 act.sa_flags = 0; 376 act.sa_handler = set_width; 377 (void) sigaction(SIGWINCH, &act, NULL); 378 379 (void) sigemptyset(&act.sa_mask); 380 act.sa_flags = 0; 381 act.sa_handler = intr; 382 (void) sigaction(SIGUSR1, &act, NULL); 383 384 (void) sigemptyset(&act.sa_mask); 385 act.sa_flags = 0; 386 act.sa_handler = status; 387 (void) sigaction(SIGUSR2, &act, NULL); 388 389 act.sa_handler = set_width; 390 (void) sigaction(SIGWINCH, &act, NULL); 391 set_width(0); 392 393 (void) sigemptyset(&set); 394 (void) sigaddset(&set, SIGUSR1); 395 (void) sigaddset(&set, SIGWINCH); 396 (void) sigprocmask(SIG_BLOCK, &set, NULL); 397 398 ev.sigev_notify = SIGEV_SIGNAL; 399 ev.sigev_signo = SIGUSR1; 400 401 if (timer_create(CLOCK_REALTIME, &ev, &tid) == -1) 402 fatal("cannot create CLOCK_HIGHRES timer"); 403 404 g_max_cpus = sysconf(_SC_CPUID_MAX) + 1; 405 406 if ((g_present = malloc(sizeof (processorid_t) * g_max_cpus)) == NULL) 407 fatal("could not allocate g_present array\n"); 408 409 bzero(g_present, sizeof (processorid_t) * g_max_cpus); 410 411 g_pset_cpus = malloc(sizeof (processorid_t) * g_max_cpus); 412 if (g_pset_cpus == NULL) 413 fatal("could not allocate g_pset_cpus"); 414 415 bzero(g_pset_cpus, sizeof (processorid_t) * g_max_cpus); 416 417 while ((c = getopt(argc, argv, INTRSTAT_OPTSTR)) != EOF) { 418 switch (c) { 419 case 'c': { 420 /* 421 * We allow CPUs to be specified as an optionally 422 * comma separated list of either CPU IDs or ranges 423 * of CPU IDs. 424 */ 425 char *s = strtok(optarg, ","); 426 427 while (s != NULL) { 428 id = strtoul(s, &end, 0); 429 430 if (id == ULONG_MAX && errno == ERANGE) { 431 *end = '\0'; 432 fatal("invalid cpu '%s'\n", s); 433 } 434 435 if (*(s = end) != '\0') { 436 processorid_t p; 437 438 if (*s != '-') 439 fatal("invalid cpu '%s'\n", s); 440 p = strtoul(++s, &end, 0); 441 442 if (*end != '\0' || 443 (p == ULONG_MAX && errno == ERANGE)) 444 fatal("invalid cpu '%s'\n", s); 445 446 select_cpus(id, p); 447 } else { 448 select_cpu(id); 449 } 450 451 s = strtok(NULL, ","); 452 } 453 454 break; 455 } 456 457 case 'C': { 458 psetid_t pset = strtoul(optarg, &end, 0); 459 460 if (*end != '\0' || 461 (pset == ULONG_MAX && errno == ERANGE)) 462 fatal("invalid processor set '%s'\n", optarg); 463 464 select_pset(pset); 465 break; 466 } 467 468 case 'T': 469 if (optarg) { 470 if (*optarg == 'u') 471 timestamp_fmt = UDATE; 472 else if (*optarg == 'd') 473 timestamp_fmt = DDATE; 474 else 475 usage(); 476 } else { 477 usage(); 478 } 479 break; 480 481 default: 482 if (strchr(INTRSTAT_OPTSTR, c) == NULL) 483 usage(); 484 } 485 } 486 487 if ((g_dtp = dtrace_open(DTRACE_VERSION, 0, &err)) == NULL) { 488 fatal("cannot open dtrace library: %s\n", 489 dtrace_errmsg(NULL, err)); 490 } 491 492 if ((prog = dtrace_program_strcompile(g_dtp, g_prog, 493 DTRACE_PROBESPEC_NAME, 0, 0, NULL)) == NULL) 494 fatal("invalid program"); 495 496 if (dtrace_program_exec(g_dtp, prog, &info) == -1) 497 fatal("failed to enable probes"); 498 499 if (dtrace_setopt(g_dtp, "aggsize", "128k") == -1) 500 fatal("failed to set 'aggsize'"); 501 502 if (dtrace_setopt(g_dtp, "aggrate", "0") == -1) 503 fatal("failed to set 'aggrate'"); 504 505 if (dtrace_setopt(g_dtp, "aggpercpu", 0) == -1) 506 fatal("failed to set 'aggpercpu'"); 507 508 optind = 1; 509 while ((c = getopt(argc, argv, INTRSTAT_OPTSTR)) != EOF) { 510 switch (c) { 511 case 'x': 512 if ((p = strchr(optarg, '=')) != NULL) 513 *p++ = '\0'; 514 515 if (dtrace_setopt(g_dtp, optarg, p) != 0) 516 fatal("failed to set -x %s", optarg); 517 break; 518 } 519 } 520 521 if (optind != argc) { 522 g_sleeptime = strtol(argv[optind], &end, 10); 523 524 if (*end != '\0' || g_sleeptime == 0) 525 fatal("invalid interval '%s'\n", argv[1]); 526 527 if (g_sleeptime <= 0) 528 fatal("interval must be greater than zero.\n"); 529 530 if (g_sleeptime == LONG_MAX && errno == ERANGE) 531 fatal("invalid interval '%s'\n", argv[optind]); 532 533 if (++optind != argc) { 534 char *s = argv[optind]; 535 536 iter = strtol(s, &end, 0); 537 indefinite = 0; 538 539 if (*end != '\0' || iter <= 0 || 540 (iter == LONG_MAX && errno == ERANGE)) 541 fatal("invalid count '%s'\n", s); 542 } 543 } 544 545 ts.it_value.tv_sec = g_sleeptime; 546 ts.it_value.tv_nsec = 0; 547 ts.it_interval.tv_sec = g_sleeptime; 548 ts.it_interval.tv_nsec = 0; 549 550 if (timer_settime(tid, TIMER_RELTIME, &ts, NULL) == -1) 551 fatal("cannot set time on CLOCK_REALTIME timer"); 552 553 for (i = 0; i < g_max_cpus && !g_present[i]; i++) 554 continue; 555 556 if (i == g_max_cpus) { 557 for (i = 0; i < g_max_cpus; i++) 558 g_present[i] = p_online(i, P_STATUS) == -1 ? 0 : 1; 559 } 560 561 if (dtrace_go(g_dtp) != 0) 562 fatal("dtrace_go()"); 563 564 last = gethrtime(); 565 566 if (dtrace_getopt(g_dtp, "statusrate", &statustime) == -1) 567 fatal("failed to get 'statusrate'"); 568 569 if (statustime < ((dtrace_optval_t)g_sleeptime * NANOSEC)) { 570 ev.sigev_notify = SIGEV_SIGNAL; 571 ev.sigev_signo = SIGUSR2; 572 573 if (timer_create(CLOCK_REALTIME, &ev, &tid) == -1) 574 fatal("cannot create status timer"); 575 576 ts.it_value.tv_sec = statustime / NANOSEC; 577 ts.it_value.tv_nsec = statustime % NANOSEC; 578 ts.it_interval = ts.it_value; 579 580 if (timer_settime(tid, TIMER_RELTIME, &ts, NULL) == -1) 581 fatal("cannot set time on status timer"); 582 } 583 584 (void) sigemptyset(&set); 585 586 while (indefinite || iter) { 587 588 (void) sigsuspend(&set); 589 590 if (dtrace_status(g_dtp) == -1) 591 fatal("dtrace_status()"); 592 593 if (g_intr == 0) 594 continue; 595 596 iter--; 597 g_intr--; 598 check_pset(); 599 600 now = gethrtime(); 601 g_interval = now - last; 602 last = now; 603 604 if (dtrace_aggregate_snap(g_dtp) != 0) 605 fatal("failed to add to aggregate"); 606 607 g_start = g_end = 0; 608 609 if (timestamp_fmt != NODATE) 610 print_timestamp(timestamp_fmt); 611 612 do { 613 g_header = 1; 614 615 if (dtrace_aggregate_walk_keyvarsorted(g_dtp, 616 walk, NULL) != 0) 617 fatal("failed to sort aggregate"); 618 619 if (g_start == g_end) 620 break; 621 } while ((g_start = g_end) < g_max_cpus); 622 623 dtrace_aggregate_clear(g_dtp); 624 } 625 626 return (0); 627 } 628