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 /* 23 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2013 David Hoeppner. All rights reserved. 25 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 26 */ 27 28 /* 29 * Display kernel statistics 30 * 31 * This is a reimplementation of the perl kstat command originally found 32 * under usr/src/cmd/kstat/kstat.pl 33 * 34 * Incompatibilities: 35 * - perl regular expressions replaced with extended REs bracketed by '/' 36 * - options checking is stricter 37 * 38 * Flags added: 39 * -C similar to the -p option but value is separated by a colon 40 * -h display help 41 * -j json format 42 */ 43 44 #include <assert.h> 45 #include <ctype.h> 46 #include <errno.h> 47 #include <kstat.h> 48 #include <langinfo.h> 49 #include <libgen.h> 50 #include <limits.h> 51 #include <locale.h> 52 #include <signal.h> 53 #include <stddef.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <strings.h> 58 #include <time.h> 59 #include <unistd.h> 60 #include <sys/list.h> 61 #include <sys/time.h> 62 #include <sys/types.h> 63 64 #include "kstat.h" 65 #include "statcommon.h" 66 67 char *cmdname = "kstat"; /* Name of this command */ 68 int caught_cont = 0; /* Have caught a SIGCONT */ 69 70 static uint_t g_timestamp_fmt = NODATE; 71 72 /* Helper flag - header was printed already? */ 73 static boolean_t g_headerflg; 74 75 /* Saved command line options */ 76 static boolean_t g_cflg = B_FALSE; 77 static boolean_t g_jflg = B_FALSE; 78 static boolean_t g_lflg = B_FALSE; 79 static boolean_t g_pflg = B_FALSE; 80 static boolean_t g_qflg = B_FALSE; 81 static ks_pattern_t g_ks_class = {"*", 0}; 82 83 /* Return zero if a selector did match */ 84 static int g_matched = 1; 85 86 /* Sorted list of kstat instances */ 87 static list_t instances_list; 88 static list_t selector_list; 89 90 int 91 main(int argc, char **argv) 92 { 93 ks_selector_t *nselector; 94 ks_selector_t *uselector; 95 kstat_ctl_t *kc; 96 hrtime_t start_n; 97 hrtime_t period_n; 98 boolean_t errflg = B_FALSE; 99 boolean_t nselflg = B_FALSE; 100 boolean_t uselflg = B_FALSE; 101 char *q; 102 int count = 1; 103 int infinite_cycles = 0; 104 int interval = 0; 105 int n = 0; 106 int c, m, tmp; 107 108 (void) setlocale(LC_ALL, ""); 109 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 110 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 111 #endif 112 (void) textdomain(TEXT_DOMAIN); 113 114 /* 115 * Create the selector list and a dummy default selector to match 116 * everything. While we process the cmdline options we will add 117 * selectors to this list. 118 */ 119 list_create(&selector_list, sizeof (ks_selector_t), 120 offsetof(ks_selector_t, ks_next)); 121 122 nselector = new_selector(); 123 124 /* 125 * Parse named command line arguments. 126 */ 127 while ((c = getopt(argc, argv, "h?CqjlpT:m:i:n:s:c:")) != EOF) 128 switch (c) { 129 case 'h': 130 case '?': 131 usage(); 132 exit(0); 133 break; 134 case 'C': 135 g_pflg = g_cflg = B_TRUE; 136 break; 137 case 'q': 138 g_qflg = B_TRUE; 139 break; 140 case 'j': 141 g_jflg = B_TRUE; 142 break; 143 case 'l': 144 g_pflg = g_lflg = B_TRUE; 145 break; 146 case 'p': 147 g_pflg = B_TRUE; 148 break; 149 case 'T': 150 switch (*optarg) { 151 case 'd': 152 g_timestamp_fmt = DDATE; 153 break; 154 case 'u': 155 g_timestamp_fmt = UDATE; 156 break; 157 default: 158 errflg = B_TRUE; 159 } 160 break; 161 case 'm': 162 nselflg = B_TRUE; 163 nselector->ks_module.pstr = 164 (char *)ks_safe_strdup(optarg); 165 break; 166 case 'i': 167 nselflg = B_TRUE; 168 nselector->ks_instance.pstr = 169 (char *)ks_safe_strdup(optarg); 170 break; 171 case 'n': 172 nselflg = B_TRUE; 173 nselector->ks_name.pstr = 174 (char *)ks_safe_strdup(optarg); 175 break; 176 case 's': 177 nselflg = B_TRUE; 178 nselector->ks_statistic.pstr = 179 (char *)ks_safe_strdup(optarg); 180 break; 181 case 'c': 182 g_ks_class.pstr = 183 (char *)ks_safe_strdup(optarg); 184 break; 185 default: 186 errflg = B_TRUE; 187 break; 188 } 189 190 if (g_qflg && (g_jflg || g_pflg)) { 191 (void) fprintf(stderr, gettext( 192 "-q and -lpj are mutually exclusive\n")); 193 errflg = B_TRUE; 194 } 195 196 if (errflg) { 197 usage(); 198 exit(2); 199 } 200 201 argc -= optind; 202 argv += optind; 203 204 /* 205 * Consume the rest of the command line. Parsing the 206 * unnamed command line arguments. 207 */ 208 while (argc--) { 209 errno = 0; 210 tmp = strtoul(*argv, &q, 10); 211 if (tmp == ULONG_MAX && errno == ERANGE) { 212 if (n == 0) { 213 (void) fprintf(stderr, gettext( 214 "Interval is too large\n")); 215 } else if (n == 1) { 216 (void) fprintf(stderr, gettext( 217 "Count is too large\n")); 218 } 219 usage(); 220 exit(2); 221 } 222 223 if (errno != 0 || *q != '\0') { 224 m = 0; 225 uselector = new_selector(); 226 while ((q = (char *)strsep(argv, ":")) != NULL) { 227 m++; 228 if (m > 4) { 229 free(uselector); 230 usage(); 231 exit(2); 232 } 233 234 if (*q != '\0') { 235 switch (m) { 236 case 1: 237 uselector->ks_module.pstr = 238 (char *)ks_safe_strdup(q); 239 break; 240 case 2: 241 uselector->ks_instance.pstr = 242 (char *)ks_safe_strdup(q); 243 break; 244 case 3: 245 uselector->ks_name.pstr = 246 (char *)ks_safe_strdup(q); 247 break; 248 case 4: 249 uselector->ks_statistic.pstr = 250 (char *)ks_safe_strdup(q); 251 break; 252 default: 253 assert(B_FALSE); 254 } 255 } 256 } 257 258 if (m < 4) { 259 free(uselector); 260 usage(); 261 exit(2); 262 } 263 264 uselflg = B_TRUE; 265 list_insert_tail(&selector_list, uselector); 266 } else { 267 if (tmp < 1) { 268 if (n == 0) { 269 (void) fprintf(stderr, gettext( 270 "Interval must be an " 271 "integer >= 1")); 272 } else if (n == 1) { 273 (void) fprintf(stderr, gettext( 274 "Count must be an integer >= 1")); 275 } 276 usage(); 277 exit(2); 278 } else { 279 if (n == 0) { 280 interval = tmp; 281 count = -1; 282 } else if (n == 1) { 283 count = tmp; 284 } else { 285 usage(); 286 exit(2); 287 } 288 } 289 n++; 290 } 291 argv++; 292 } 293 294 /* 295 * Check if we founded a named selector on the cmdline. 296 */ 297 if (uselflg) { 298 if (nselflg) { 299 (void) fprintf(stderr, gettext( 300 "module:instance:name:statistic and " 301 "-m -i -n -s are mutually exclusive")); 302 usage(); 303 exit(2); 304 } else { 305 free(nselector); 306 } 307 } else { 308 list_insert_tail(&selector_list, nselector); 309 } 310 311 assert(!list_is_empty(&selector_list)); 312 313 list_create(&instances_list, sizeof (ks_instance_t), 314 offsetof(ks_instance_t, ks_next)); 315 316 while ((kc = kstat_open()) == NULL) { 317 if (errno == EAGAIN) { 318 (void) poll(NULL, 0, 200); 319 } else { 320 perror("kstat_open"); 321 exit(3); 322 } 323 } 324 325 if (count > 1) { 326 if (signal(SIGCONT, cont_handler) == SIG_ERR) { 327 (void) fprintf(stderr, gettext( 328 "signal failed")); 329 exit(3); 330 } 331 } 332 333 period_n = (hrtime_t)interval * NANOSEC; 334 start_n = gethrtime(); 335 336 while (count == -1 || count-- > 0) { 337 ks_instances_read(kc); 338 ks_instances_print(); 339 340 if (interval && count) { 341 ks_sleep_until(&start_n, period_n, infinite_cycles, 342 &caught_cont); 343 (void) kstat_chain_update(kc); 344 (void) putchar('\n'); 345 } 346 } 347 348 (void) kstat_close(kc); 349 350 return (g_matched); 351 } 352 353 /* 354 * Print usage. 355 */ 356 static void 357 usage(void) 358 { 359 (void) fprintf(stderr, gettext( 360 "Usage:\n" 361 "kstat [ -Cjlpq ] [ -T d|u ] [ -c class ]\n" 362 " [ -m module ] [ -i instance ] [ -n name ] [ -s statistic ]\n" 363 " [ interval [ count ] ]\n" 364 "kstat [ -Cjlpq ] [ -T d|u ] [ -c class ]\n" 365 " [ module:instance:name:statistic ... ]\n" 366 " [ interval [ count ] ]\n")); 367 } 368 369 /* 370 * Sort compare function. 371 */ 372 static int 373 compare_instances(ks_instance_t *l_arg, ks_instance_t *r_arg) 374 { 375 int rval; 376 377 rval = strcasecmp(l_arg->ks_module, r_arg->ks_module); 378 if (rval == 0) { 379 if (l_arg->ks_instance == r_arg->ks_instance) { 380 return (strcasecmp(l_arg->ks_name, r_arg->ks_name)); 381 } else if (l_arg->ks_instance < r_arg->ks_instance) { 382 return (-1); 383 } else { 384 return (1); 385 } 386 } else { 387 return (rval); 388 } 389 } 390 391 static char * 392 ks_safe_strdup(char *str) 393 { 394 char *ret; 395 396 if (str == NULL) { 397 return (NULL); 398 } 399 400 while ((ret = strdup(str)) == NULL) { 401 if (errno == EAGAIN) { 402 (void) poll(NULL, 0, 200); 403 } else { 404 perror("strdup"); 405 exit(3); 406 } 407 } 408 409 return (ret); 410 } 411 412 static void 413 ks_sleep_until(hrtime_t *wakeup, hrtime_t interval, int forever, 414 int *caught_cont) 415 { 416 hrtime_t now, pause, pause_left; 417 struct timespec pause_tv; 418 int status; 419 420 now = gethrtime(); 421 pause = *wakeup + interval - now; 422 423 if (pause <= 0 || pause < (interval / 4)) { 424 if (forever || *caught_cont) { 425 *wakeup = now + interval; 426 pause = interval; 427 } else { 428 pause = interval / 2; 429 *wakeup += interval; 430 } 431 } else { 432 *wakeup += interval; 433 } 434 435 if (pause < 1000) { 436 return; 437 } 438 439 pause_left = pause; 440 do { 441 pause_tv.tv_sec = pause_left / NANOSEC; 442 pause_tv.tv_nsec = pause_left % NANOSEC; 443 status = nanosleep(&pause_tv, (struct timespec *)NULL); 444 if (status < 0) { 445 if (errno == EINTR) { 446 now = gethrtime(); 447 pause_left = *wakeup - now; 448 if (pause_left < 1000) { 449 return; 450 } 451 } else { 452 perror("nanosleep"); 453 exit(3); 454 } 455 } 456 } while (status != 0); 457 } 458 459 /* 460 * Inserts an instance in the per selector list. 461 */ 462 static void 463 nvpair_insert(ks_instance_t *ksi, char *name, ks_value_t *value, 464 uchar_t data_type) 465 { 466 ks_nvpair_t *instance; 467 ks_nvpair_t *tmp; 468 469 instance = (ks_nvpair_t *)malloc(sizeof (ks_nvpair_t)); 470 if (instance == NULL) { 471 perror("malloc"); 472 exit(3); 473 } 474 475 (void) strlcpy(instance->name, name, KSTAT_STRLEN); 476 (void) memcpy(&instance->value, value, sizeof (ks_value_t)); 477 instance->data_type = data_type; 478 479 tmp = list_head(&ksi->ks_nvlist); 480 while (tmp != NULL && strcasecmp(instance->name, tmp->name) > 0) 481 tmp = list_next(&ksi->ks_nvlist, tmp); 482 483 list_insert_before(&ksi->ks_nvlist, tmp, instance); 484 } 485 486 /* 487 * Allocates a new all-matching selector. 488 */ 489 static ks_selector_t * 490 new_selector(void) 491 { 492 ks_selector_t *selector; 493 494 selector = (ks_selector_t *)malloc(sizeof (ks_selector_t)); 495 if (selector == NULL) { 496 perror("malloc"); 497 exit(3); 498 } 499 500 list_link_init(&selector->ks_next); 501 502 selector->ks_module.pstr = "*"; 503 selector->ks_instance.pstr = "*"; 504 selector->ks_name.pstr = "*"; 505 selector->ks_statistic.pstr = "*"; 506 507 return (selector); 508 } 509 510 /* 511 * This function was taken from the perl kstat module code - please 512 * see for further comments there. 513 */ 514 static kstat_raw_reader_t 515 lookup_raw_kstat_fn(char *module, char *name) 516 { 517 char key[KSTAT_STRLEN * 2]; 518 register char *f, *t; 519 int n = 0; 520 521 for (f = module, t = key; *f != '\0'; f++, t++) { 522 while (*f != '\0' && isdigit(*f)) 523 f++; 524 *t = *f; 525 } 526 *t++ = ':'; 527 528 for (f = name; *f != '\0'; f++, t++) { 529 while (*f != '\0' && isdigit(*f)) 530 f++; 531 *t = *f; 532 } 533 *t = '\0'; 534 535 while (ks_raw_lookup[n].fn != NULL) { 536 if (strncmp(ks_raw_lookup[n].name, key, strlen(key)) == 0) 537 return (ks_raw_lookup[n].fn); 538 n++; 539 } 540 541 return (0); 542 } 543 544 /* 545 * Match a string against a shell glob or extended regular expression. 546 */ 547 static boolean_t 548 ks_match(const char *str, ks_pattern_t *pattern) 549 { 550 int regcode; 551 char *regstr; 552 char *errbuf; 553 size_t bufsz; 554 555 if (pattern->pstr != NULL && gmatch(pattern->pstr, "/*/") != 0) { 556 /* All regex patterns are strdup'd copies */ 557 regstr = pattern->pstr + 1; 558 *(strrchr(regstr, '/')) = '\0'; 559 560 regcode = regcomp(&pattern->preg, regstr, 561 REG_EXTENDED | REG_NOSUB); 562 if (regcode != 0) { 563 bufsz = regerror(regcode, NULL, NULL, 0); 564 if (bufsz != 0) { 565 errbuf = malloc(bufsz); 566 if (errbuf == NULL) { 567 perror("malloc"); 568 exit(3); 569 } 570 (void) regerror(regcode, NULL, errbuf, bufsz); 571 (void) fprintf(stderr, "kstat: %s\n", errbuf); 572 } 573 usage(); 574 exit(2); 575 } 576 577 pattern->pstr = NULL; 578 } 579 580 if (pattern->pstr == NULL) { 581 return (regexec(&pattern->preg, str, 0, NULL, 0) == 0); 582 } 583 584 return ((gmatch(str, pattern->pstr) != 0)); 585 } 586 587 /* 588 * Iterate over all kernel statistics and save matches. 589 */ 590 static void 591 ks_instances_read(kstat_ctl_t *kc) 592 { 593 kstat_raw_reader_t save_raw = NULL; 594 kid_t id; 595 ks_selector_t *selector; 596 ks_instance_t *ksi; 597 ks_instance_t *tmp; 598 kstat_t *kp; 599 boolean_t skip; 600 601 for (kp = kc->kc_chain; kp != NULL; kp = kp->ks_next) { 602 /* Don't bother storing the kstat headers */ 603 if (strncmp(kp->ks_name, "kstat_", 6) == 0) { 604 continue; 605 } 606 607 /* Don't bother storing raw stats we don't understand */ 608 if (kp->ks_type == KSTAT_TYPE_RAW) { 609 save_raw = lookup_raw_kstat_fn(kp->ks_module, 610 kp->ks_name); 611 if (save_raw == NULL) { 612 #ifdef REPORT_UNKNOWN 613 (void) fprintf(stderr, 614 "Unknown kstat type %s:%d:%s - " 615 "%d of size %d\n", kp->ks_module, 616 kp->ks_instance, kp->ks_name, 617 kp->ks_ndata, kp->ks_data_size); 618 #endif 619 continue; 620 } 621 } 622 623 /* 624 * Iterate over the list of selectors and skip 625 * instances we dont want. We filter for statistics 626 * later, as we dont know them yet. 627 */ 628 skip = B_TRUE; 629 selector = list_head(&selector_list); 630 while (selector != NULL) { 631 if (ks_match(kp->ks_module, &selector->ks_module) || 632 ks_match(kp->ks_name, &selector->ks_name)) { 633 skip = B_FALSE; 634 break; 635 } 636 selector = list_next(&selector_list, selector); 637 } 638 639 if (skip) { 640 continue; 641 } 642 643 /* 644 * Allocate a new instance and fill in the values 645 * we know so far. 646 */ 647 ksi = (ks_instance_t *)malloc(sizeof (ks_instance_t)); 648 if (ksi == NULL) { 649 perror("malloc"); 650 exit(3); 651 } 652 653 list_link_init(&ksi->ks_next); 654 655 (void) strlcpy(ksi->ks_module, kp->ks_module, KSTAT_STRLEN); 656 (void) strlcpy(ksi->ks_name, kp->ks_name, KSTAT_STRLEN); 657 (void) strlcpy(ksi->ks_class, kp->ks_class, KSTAT_STRLEN); 658 659 ksi->ks_instance = kp->ks_instance; 660 ksi->ks_snaptime = kp->ks_snaptime; 661 ksi->ks_type = kp->ks_type; 662 663 list_create(&ksi->ks_nvlist, sizeof (ks_nvpair_t), 664 offsetof(ks_nvpair_t, nv_next)); 665 666 SAVE_HRTIME_X(ksi, "crtime", kp->ks_crtime); 667 SAVE_HRTIME_X(ksi, "snaptime", kp->ks_snaptime); 668 if (g_pflg) { 669 SAVE_STRING_X(ksi, "class", kp->ks_class); 670 } 671 672 /* Insert this instance into a sorted list */ 673 tmp = list_head(&instances_list); 674 while (tmp != NULL && compare_instances(ksi, tmp) > 0) 675 tmp = list_next(&instances_list, tmp); 676 677 list_insert_before(&instances_list, tmp, ksi); 678 679 /* Read the actual statistics */ 680 id = kstat_read(kc, kp, NULL); 681 if (id == -1) { 682 #ifdef REPORT_UNKNOWN 683 perror("kstat_read"); 684 #endif 685 continue; 686 } 687 688 switch (kp->ks_type) { 689 case KSTAT_TYPE_RAW: 690 save_raw(kp, ksi); 691 break; 692 case KSTAT_TYPE_NAMED: 693 save_named(kp, ksi); 694 break; 695 case KSTAT_TYPE_INTR: 696 save_intr(kp, ksi); 697 break; 698 case KSTAT_TYPE_IO: 699 save_io(kp, ksi); 700 break; 701 case KSTAT_TYPE_TIMER: 702 save_timer(kp, ksi); 703 break; 704 default: 705 assert(B_FALSE); /* Invalid type */ 706 break; 707 } 708 } 709 } 710 711 /* 712 * Print the value of a name-value pair. 713 */ 714 static void 715 ks_value_print(ks_nvpair_t *nvpair) 716 { 717 switch (nvpair->data_type) { 718 case KSTAT_DATA_CHAR: 719 (void) fprintf(stdout, "%s", nvpair->value.c); 720 break; 721 case KSTAT_DATA_INT32: 722 (void) fprintf(stdout, "%d", nvpair->value.i32); 723 break; 724 case KSTAT_DATA_UINT32: 725 (void) fprintf(stdout, "%u", nvpair->value.ui32); 726 break; 727 case KSTAT_DATA_INT64: 728 (void) fprintf(stdout, "%lld", nvpair->value.i64); 729 break; 730 case KSTAT_DATA_UINT64: 731 (void) fprintf(stdout, "%llu", nvpair->value.ui64); 732 break; 733 case KSTAT_DATA_STRING: 734 (void) fprintf(stdout, "%s", KSTAT_NAMED_STR_PTR(nvpair)); 735 break; 736 case KSTAT_DATA_HRTIME: 737 if (nvpair->value.ui64 == 0) 738 (void) fprintf(stdout, "0"); 739 else 740 (void) fprintf(stdout, "%.9f", 741 nvpair->value.ui64 / 1000000000.0); 742 break; 743 default: 744 assert(B_FALSE); 745 } 746 } 747 748 /* 749 * Print a single instance. 750 */ 751 static void 752 ks_instance_print(ks_instance_t *ksi, ks_nvpair_t *nvpair) 753 { 754 if (g_headerflg) { 755 if (!g_pflg) { 756 (void) fprintf(stdout, DFLT_FMT, 757 ksi->ks_module, ksi->ks_instance, 758 ksi->ks_name, ksi->ks_class); 759 } 760 g_headerflg = B_FALSE; 761 } 762 763 if (g_pflg) { 764 (void) fprintf(stdout, KS_PFMT, 765 ksi->ks_module, ksi->ks_instance, 766 ksi->ks_name, nvpair->name); 767 if (!g_lflg) { 768 (void) putchar(g_cflg ? ':': '\t'); 769 ks_value_print(nvpair); 770 } 771 } else { 772 (void) fprintf(stdout, KS_DFMT, nvpair->name); 773 ks_value_print(nvpair); 774 } 775 776 (void) putchar('\n'); 777 } 778 779 /* 780 * Print a single instance in JSON format. 781 */ 782 static void 783 ks_instance_print_json(ks_instance_t *ksi, ks_nvpair_t *nvpair) 784 { 785 if (g_headerflg) { 786 (void) fprintf(stdout, JSON_FMT, 787 ksi->ks_module, ksi->ks_instance, 788 ksi->ks_name, ksi->ks_class, 789 ksi->ks_type); 790 791 if (ksi->ks_snaptime == 0) 792 (void) fprintf(stdout, "\t\"snaptime\": 0,\n"); 793 else 794 (void) fprintf(stdout, "\t\"snaptime\": %.9f,\n", 795 ksi->ks_snaptime / 1000000000.0); 796 797 (void) fprintf(stdout, "\t\"data\": {\n"); 798 799 g_headerflg = B_FALSE; 800 } 801 802 (void) fprintf(stdout, KS_JFMT, nvpair->name); 803 if (nvpair->data_type == KSTAT_DATA_STRING) { 804 (void) putchar('\"'); 805 ks_value_print(nvpair); 806 (void) putchar('\"'); 807 } else { 808 ks_value_print(nvpair); 809 } 810 if (nvpair != list_tail(&ksi->ks_nvlist)) 811 (void) putchar(','); 812 813 (void) putchar('\n'); 814 } 815 816 /* 817 * Print all instances. 818 */ 819 static void 820 ks_instances_print(void) 821 { 822 ks_selector_t *selector; 823 ks_instance_t *ksi, *ktmp; 824 ks_nvpair_t *nvpair, *ntmp; 825 void (*ks_print_fn)(ks_instance_t *, ks_nvpair_t *); 826 char *ks_number; 827 828 if (g_timestamp_fmt != NODATE) 829 print_timestamp(g_timestamp_fmt); 830 831 if (g_jflg) { 832 ks_print_fn = &ks_instance_print_json; 833 (void) putchar('['); 834 } else { 835 ks_print_fn = &ks_instance_print; 836 } 837 838 /* Iterate over each selector */ 839 selector = list_head(&selector_list); 840 while (selector != NULL) { 841 842 /* Iterate over each instance */ 843 for (ksi = list_head(&instances_list); ksi != NULL; 844 ksi = list_next(&instances_list, ksi)) { 845 846 (void) asprintf(&ks_number, "%d", ksi->ks_instance); 847 if (!(ks_match(ksi->ks_module, &selector->ks_module) && 848 ks_match(ksi->ks_name, &selector->ks_name) && 849 ks_match(ks_number, &selector->ks_instance) && 850 ks_match(ksi->ks_class, &g_ks_class))) { 851 free(ks_number); 852 continue; 853 } 854 855 free(ks_number); 856 857 /* Finally iterate over each statistic */ 858 g_headerflg = B_TRUE; 859 for (nvpair = list_head(&ksi->ks_nvlist); 860 nvpair != NULL; 861 nvpair = list_next(&ksi->ks_nvlist, nvpair)) { 862 if (!ks_match(nvpair->name, 863 &selector->ks_statistic)) 864 continue; 865 866 g_matched = 0; 867 if (!g_qflg) 868 (*ks_print_fn)(ksi, nvpair); 869 } 870 871 if (!g_headerflg) { 872 if (g_jflg) { 873 (void) fprintf(stdout, "\t}\n}"); 874 if (ksi != list_tail(&instances_list)) 875 (void) putchar(','); 876 } else if (!g_pflg) { 877 (void) putchar('\n'); 878 } 879 } 880 } 881 882 selector = list_next(&selector_list, selector); 883 } 884 885 if (g_jflg) 886 (void) fprintf(stdout, "]\n"); 887 888 (void) fflush(stdout); 889 890 /* Free the instances list */ 891 ksi = list_head(&instances_list); 892 while (ksi != NULL) { 893 nvpair = list_head(&ksi->ks_nvlist); 894 while (nvpair != NULL) { 895 ntmp = nvpair; 896 nvpair = list_next(&ksi->ks_nvlist, nvpair); 897 list_remove(&ksi->ks_nvlist, ntmp); 898 if (ntmp->data_type == KSTAT_DATA_STRING) 899 free(ntmp->value.str.addr.ptr); 900 free(ntmp); 901 } 902 903 ktmp = ksi; 904 ksi = list_next(&instances_list, ksi); 905 list_remove(&instances_list, ktmp); 906 list_destroy(&ktmp->ks_nvlist); 907 free(ktmp); 908 } 909 } 910 911 static void 912 save_cpu_stat(kstat_t *kp, ks_instance_t *ksi) 913 { 914 cpu_stat_t *stat; 915 cpu_sysinfo_t *sysinfo; 916 cpu_syswait_t *syswait; 917 cpu_vminfo_t *vminfo; 918 919 stat = (cpu_stat_t *)(kp->ks_data); 920 sysinfo = &stat->cpu_sysinfo; 921 syswait = &stat->cpu_syswait; 922 vminfo = &stat->cpu_vminfo; 923 924 SAVE_UINT32_X(ksi, "idle", sysinfo->cpu[CPU_IDLE]); 925 SAVE_UINT32_X(ksi, "user", sysinfo->cpu[CPU_USER]); 926 SAVE_UINT32_X(ksi, "kernel", sysinfo->cpu[CPU_KERNEL]); 927 SAVE_UINT32_X(ksi, "wait", sysinfo->cpu[CPU_WAIT]); 928 SAVE_UINT32_X(ksi, "wait_io", sysinfo->cpu[W_IO]); 929 SAVE_UINT32_X(ksi, "wait_swap", sysinfo->cpu[W_SWAP]); 930 SAVE_UINT32_X(ksi, "wait_pio", sysinfo->cpu[W_PIO]); 931 SAVE_UINT32(ksi, sysinfo, bread); 932 SAVE_UINT32(ksi, sysinfo, bwrite); 933 SAVE_UINT32(ksi, sysinfo, lread); 934 SAVE_UINT32(ksi, sysinfo, lwrite); 935 SAVE_UINT32(ksi, sysinfo, phread); 936 SAVE_UINT32(ksi, sysinfo, phwrite); 937 SAVE_UINT32(ksi, sysinfo, pswitch); 938 SAVE_UINT32(ksi, sysinfo, trap); 939 SAVE_UINT32(ksi, sysinfo, intr); 940 SAVE_UINT32(ksi, sysinfo, syscall); 941 SAVE_UINT32(ksi, sysinfo, sysread); 942 SAVE_UINT32(ksi, sysinfo, syswrite); 943 SAVE_UINT32(ksi, sysinfo, sysfork); 944 SAVE_UINT32(ksi, sysinfo, sysvfork); 945 SAVE_UINT32(ksi, sysinfo, sysexec); 946 SAVE_UINT32(ksi, sysinfo, readch); 947 SAVE_UINT32(ksi, sysinfo, writech); 948 SAVE_UINT32(ksi, sysinfo, rcvint); 949 SAVE_UINT32(ksi, sysinfo, xmtint); 950 SAVE_UINT32(ksi, sysinfo, mdmint); 951 SAVE_UINT32(ksi, sysinfo, rawch); 952 SAVE_UINT32(ksi, sysinfo, canch); 953 SAVE_UINT32(ksi, sysinfo, outch); 954 SAVE_UINT32(ksi, sysinfo, msg); 955 SAVE_UINT32(ksi, sysinfo, sema); 956 SAVE_UINT32(ksi, sysinfo, namei); 957 SAVE_UINT32(ksi, sysinfo, ufsiget); 958 SAVE_UINT32(ksi, sysinfo, ufsdirblk); 959 SAVE_UINT32(ksi, sysinfo, ufsipage); 960 SAVE_UINT32(ksi, sysinfo, ufsinopage); 961 SAVE_UINT32(ksi, sysinfo, inodeovf); 962 SAVE_UINT32(ksi, sysinfo, fileovf); 963 SAVE_UINT32(ksi, sysinfo, procovf); 964 SAVE_UINT32(ksi, sysinfo, intrthread); 965 SAVE_UINT32(ksi, sysinfo, intrblk); 966 SAVE_UINT32(ksi, sysinfo, idlethread); 967 SAVE_UINT32(ksi, sysinfo, inv_swtch); 968 SAVE_UINT32(ksi, sysinfo, nthreads); 969 SAVE_UINT32(ksi, sysinfo, cpumigrate); 970 SAVE_UINT32(ksi, sysinfo, xcalls); 971 SAVE_UINT32(ksi, sysinfo, mutex_adenters); 972 SAVE_UINT32(ksi, sysinfo, rw_rdfails); 973 SAVE_UINT32(ksi, sysinfo, rw_wrfails); 974 SAVE_UINT32(ksi, sysinfo, modload); 975 SAVE_UINT32(ksi, sysinfo, modunload); 976 SAVE_UINT32(ksi, sysinfo, bawrite); 977 #ifdef STATISTICS /* see header file */ 978 SAVE_UINT32(ksi, sysinfo, rw_enters); 979 SAVE_UINT32(ksi, sysinfo, win_uo_cnt); 980 SAVE_UINT32(ksi, sysinfo, win_uu_cnt); 981 SAVE_UINT32(ksi, sysinfo, win_so_cnt); 982 SAVE_UINT32(ksi, sysinfo, win_su_cnt); 983 SAVE_UINT32(ksi, sysinfo, win_suo_cnt); 984 #endif 985 986 SAVE_INT32(ksi, syswait, iowait); 987 SAVE_INT32(ksi, syswait, swap); 988 SAVE_INT32(ksi, syswait, physio); 989 990 SAVE_UINT32(ksi, vminfo, pgrec); 991 SAVE_UINT32(ksi, vminfo, pgfrec); 992 SAVE_UINT32(ksi, vminfo, pgin); 993 SAVE_UINT32(ksi, vminfo, pgpgin); 994 SAVE_UINT32(ksi, vminfo, pgout); 995 SAVE_UINT32(ksi, vminfo, pgpgout); 996 SAVE_UINT32(ksi, vminfo, swapin); 997 SAVE_UINT32(ksi, vminfo, pgswapin); 998 SAVE_UINT32(ksi, vminfo, swapout); 999 SAVE_UINT32(ksi, vminfo, pgswapout); 1000 SAVE_UINT32(ksi, vminfo, zfod); 1001 SAVE_UINT32(ksi, vminfo, dfree); 1002 SAVE_UINT32(ksi, vminfo, scan); 1003 SAVE_UINT32(ksi, vminfo, rev); 1004 SAVE_UINT32(ksi, vminfo, hat_fault); 1005 SAVE_UINT32(ksi, vminfo, as_fault); 1006 SAVE_UINT32(ksi, vminfo, maj_fault); 1007 SAVE_UINT32(ksi, vminfo, cow_fault); 1008 SAVE_UINT32(ksi, vminfo, prot_fault); 1009 SAVE_UINT32(ksi, vminfo, softlock); 1010 SAVE_UINT32(ksi, vminfo, kernel_asflt); 1011 SAVE_UINT32(ksi, vminfo, pgrrun); 1012 SAVE_UINT32(ksi, vminfo, execpgin); 1013 SAVE_UINT32(ksi, vminfo, execpgout); 1014 SAVE_UINT32(ksi, vminfo, execfree); 1015 SAVE_UINT32(ksi, vminfo, anonpgin); 1016 SAVE_UINT32(ksi, vminfo, anonpgout); 1017 SAVE_UINT32(ksi, vminfo, anonfree); 1018 SAVE_UINT32(ksi, vminfo, fspgin); 1019 SAVE_UINT32(ksi, vminfo, fspgout); 1020 SAVE_UINT32(ksi, vminfo, fsfree); 1021 } 1022 1023 static void 1024 save_var(kstat_t *kp, ks_instance_t *ksi) 1025 { 1026 struct var *var = (struct var *)(kp->ks_data); 1027 1028 assert(kp->ks_data_size == sizeof (struct var)); 1029 1030 SAVE_INT32(ksi, var, v_buf); 1031 SAVE_INT32(ksi, var, v_call); 1032 SAVE_INT32(ksi, var, v_proc); 1033 SAVE_INT32(ksi, var, v_maxupttl); 1034 SAVE_INT32(ksi, var, v_nglobpris); 1035 SAVE_INT32(ksi, var, v_maxsyspri); 1036 SAVE_INT32(ksi, var, v_clist); 1037 SAVE_INT32(ksi, var, v_maxup); 1038 SAVE_INT32(ksi, var, v_hbuf); 1039 SAVE_INT32(ksi, var, v_hmask); 1040 SAVE_INT32(ksi, var, v_pbuf); 1041 SAVE_INT32(ksi, var, v_sptmap); 1042 SAVE_INT32(ksi, var, v_maxpmem); 1043 SAVE_INT32(ksi, var, v_autoup); 1044 SAVE_INT32(ksi, var, v_bufhwm); 1045 } 1046 1047 static void 1048 save_ncstats(kstat_t *kp, ks_instance_t *ksi) 1049 { 1050 struct ncstats *ncstats = (struct ncstats *)(kp->ks_data); 1051 1052 assert(kp->ks_data_size == sizeof (struct ncstats)); 1053 1054 SAVE_INT32(ksi, ncstats, hits); 1055 SAVE_INT32(ksi, ncstats, misses); 1056 SAVE_INT32(ksi, ncstats, enters); 1057 SAVE_INT32(ksi, ncstats, dbl_enters); 1058 SAVE_INT32(ksi, ncstats, long_enter); 1059 SAVE_INT32(ksi, ncstats, long_look); 1060 SAVE_INT32(ksi, ncstats, move_to_front); 1061 SAVE_INT32(ksi, ncstats, purges); 1062 } 1063 1064 static void 1065 save_sysinfo(kstat_t *kp, ks_instance_t *ksi) 1066 { 1067 sysinfo_t *sysinfo = (sysinfo_t *)(kp->ks_data); 1068 1069 assert(kp->ks_data_size == sizeof (sysinfo_t)); 1070 1071 SAVE_UINT32(ksi, sysinfo, updates); 1072 SAVE_UINT32(ksi, sysinfo, runque); 1073 SAVE_UINT32(ksi, sysinfo, runocc); 1074 SAVE_UINT32(ksi, sysinfo, swpque); 1075 SAVE_UINT32(ksi, sysinfo, swpocc); 1076 SAVE_UINT32(ksi, sysinfo, waiting); 1077 } 1078 1079 static void 1080 save_vminfo(kstat_t *kp, ks_instance_t *ksi) 1081 { 1082 vminfo_t *vminfo = (vminfo_t *)(kp->ks_data); 1083 1084 assert(kp->ks_data_size == sizeof (vminfo_t)); 1085 1086 SAVE_UINT64(ksi, vminfo, freemem); 1087 SAVE_UINT64(ksi, vminfo, swap_resv); 1088 SAVE_UINT64(ksi, vminfo, swap_alloc); 1089 SAVE_UINT64(ksi, vminfo, swap_avail); 1090 SAVE_UINT64(ksi, vminfo, swap_free); 1091 SAVE_UINT64(ksi, vminfo, updates); 1092 } 1093 1094 static void 1095 save_nfs(kstat_t *kp, ks_instance_t *ksi) 1096 { 1097 struct mntinfo_kstat *mntinfo = (struct mntinfo_kstat *)(kp->ks_data); 1098 1099 assert(kp->ks_data_size == sizeof (struct mntinfo_kstat)); 1100 1101 SAVE_STRING(ksi, mntinfo, mik_proto); 1102 SAVE_UINT32(ksi, mntinfo, mik_vers); 1103 SAVE_UINT32(ksi, mntinfo, mik_flags); 1104 SAVE_UINT32(ksi, mntinfo, mik_secmod); 1105 SAVE_UINT32(ksi, mntinfo, mik_curread); 1106 SAVE_UINT32(ksi, mntinfo, mik_curwrite); 1107 SAVE_INT32(ksi, mntinfo, mik_timeo); 1108 SAVE_INT32(ksi, mntinfo, mik_retrans); 1109 SAVE_UINT32(ksi, mntinfo, mik_acregmin); 1110 SAVE_UINT32(ksi, mntinfo, mik_acregmax); 1111 SAVE_UINT32(ksi, mntinfo, mik_acdirmin); 1112 SAVE_UINT32(ksi, mntinfo, mik_acdirmax); 1113 SAVE_UINT32_X(ksi, "lookup_srtt", mntinfo->mik_timers[0].srtt); 1114 SAVE_UINT32_X(ksi, "lookup_deviate", mntinfo->mik_timers[0].deviate); 1115 SAVE_UINT32_X(ksi, "lookup_rtxcur", mntinfo->mik_timers[0].rtxcur); 1116 SAVE_UINT32_X(ksi, "read_srtt", mntinfo->mik_timers[1].srtt); 1117 SAVE_UINT32_X(ksi, "read_deviate", mntinfo->mik_timers[1].deviate); 1118 SAVE_UINT32_X(ksi, "read_rtxcur", mntinfo->mik_timers[1].rtxcur); 1119 SAVE_UINT32_X(ksi, "write_srtt", mntinfo->mik_timers[2].srtt); 1120 SAVE_UINT32_X(ksi, "write_deviate", mntinfo->mik_timers[2].deviate); 1121 SAVE_UINT32_X(ksi, "write_rtxcur", mntinfo->mik_timers[2].rtxcur); 1122 SAVE_UINT32(ksi, mntinfo, mik_noresponse); 1123 SAVE_UINT32(ksi, mntinfo, mik_failover); 1124 SAVE_UINT32(ksi, mntinfo, mik_remap); 1125 SAVE_STRING(ksi, mntinfo, mik_curserver); 1126 } 1127 1128 #ifdef __sparc 1129 static void 1130 save_sfmmu_global_stat(kstat_t *kp, ks_instance_t *ksi) 1131 { 1132 struct sfmmu_global_stat *sfmmug = 1133 (struct sfmmu_global_stat *)(kp->ks_data); 1134 1135 assert(kp->ks_data_size == sizeof (struct sfmmu_global_stat)); 1136 1137 SAVE_INT32(ksi, sfmmug, sf_tsb_exceptions); 1138 SAVE_INT32(ksi, sfmmug, sf_tsb_raise_exception); 1139 SAVE_INT32(ksi, sfmmug, sf_pagefaults); 1140 SAVE_INT32(ksi, sfmmug, sf_uhash_searches); 1141 SAVE_INT32(ksi, sfmmug, sf_uhash_links); 1142 SAVE_INT32(ksi, sfmmug, sf_khash_searches); 1143 SAVE_INT32(ksi, sfmmug, sf_khash_links); 1144 SAVE_INT32(ksi, sfmmug, sf_swapout); 1145 SAVE_INT32(ksi, sfmmug, sf_tsb_alloc); 1146 SAVE_INT32(ksi, sfmmug, sf_tsb_allocfail); 1147 SAVE_INT32(ksi, sfmmug, sf_tsb_sectsb_create); 1148 SAVE_INT32(ksi, sfmmug, sf_scd_1sttsb_alloc); 1149 SAVE_INT32(ksi, sfmmug, sf_scd_2ndtsb_alloc); 1150 SAVE_INT32(ksi, sfmmug, sf_scd_1sttsb_allocfail); 1151 SAVE_INT32(ksi, sfmmug, sf_scd_2ndtsb_allocfail); 1152 SAVE_INT32(ksi, sfmmug, sf_tteload8k); 1153 SAVE_INT32(ksi, sfmmug, sf_tteload64k); 1154 SAVE_INT32(ksi, sfmmug, sf_tteload512k); 1155 SAVE_INT32(ksi, sfmmug, sf_tteload4m); 1156 SAVE_INT32(ksi, sfmmug, sf_tteload32m); 1157 SAVE_INT32(ksi, sfmmug, sf_tteload256m); 1158 SAVE_INT32(ksi, sfmmug, sf_tsb_load8k); 1159 SAVE_INT32(ksi, sfmmug, sf_tsb_load4m); 1160 SAVE_INT32(ksi, sfmmug, sf_hblk_hit); 1161 SAVE_INT32(ksi, sfmmug, sf_hblk8_ncreate); 1162 SAVE_INT32(ksi, sfmmug, sf_hblk8_nalloc); 1163 SAVE_INT32(ksi, sfmmug, sf_hblk1_ncreate); 1164 SAVE_INT32(ksi, sfmmug, sf_hblk1_nalloc); 1165 SAVE_INT32(ksi, sfmmug, sf_hblk_slab_cnt); 1166 SAVE_INT32(ksi, sfmmug, sf_hblk_reserve_cnt); 1167 SAVE_INT32(ksi, sfmmug, sf_hblk_recurse_cnt); 1168 SAVE_INT32(ksi, sfmmug, sf_hblk_reserve_hit); 1169 SAVE_INT32(ksi, sfmmug, sf_get_free_success); 1170 SAVE_INT32(ksi, sfmmug, sf_get_free_throttle); 1171 SAVE_INT32(ksi, sfmmug, sf_get_free_fail); 1172 SAVE_INT32(ksi, sfmmug, sf_put_free_success); 1173 SAVE_INT32(ksi, sfmmug, sf_put_free_fail); 1174 SAVE_INT32(ksi, sfmmug, sf_pgcolor_conflict); 1175 SAVE_INT32(ksi, sfmmug, sf_uncache_conflict); 1176 SAVE_INT32(ksi, sfmmug, sf_unload_conflict); 1177 SAVE_INT32(ksi, sfmmug, sf_ism_uncache); 1178 SAVE_INT32(ksi, sfmmug, sf_ism_recache); 1179 SAVE_INT32(ksi, sfmmug, sf_recache); 1180 SAVE_INT32(ksi, sfmmug, sf_steal_count); 1181 SAVE_INT32(ksi, sfmmug, sf_pagesync); 1182 SAVE_INT32(ksi, sfmmug, sf_clrwrt); 1183 SAVE_INT32(ksi, sfmmug, sf_pagesync_invalid); 1184 SAVE_INT32(ksi, sfmmug, sf_kernel_xcalls); 1185 SAVE_INT32(ksi, sfmmug, sf_user_xcalls); 1186 SAVE_INT32(ksi, sfmmug, sf_tsb_grow); 1187 SAVE_INT32(ksi, sfmmug, sf_tsb_shrink); 1188 SAVE_INT32(ksi, sfmmug, sf_tsb_resize_failures); 1189 SAVE_INT32(ksi, sfmmug, sf_tsb_reloc); 1190 SAVE_INT32(ksi, sfmmug, sf_user_vtop); 1191 SAVE_INT32(ksi, sfmmug, sf_ctx_inv); 1192 SAVE_INT32(ksi, sfmmug, sf_tlb_reprog_pgsz); 1193 SAVE_INT32(ksi, sfmmug, sf_region_remap_demap); 1194 SAVE_INT32(ksi, sfmmug, sf_create_scd); 1195 SAVE_INT32(ksi, sfmmug, sf_join_scd); 1196 SAVE_INT32(ksi, sfmmug, sf_leave_scd); 1197 SAVE_INT32(ksi, sfmmug, sf_destroy_scd); 1198 } 1199 #endif 1200 1201 #ifdef __sparc 1202 static void 1203 save_sfmmu_tsbsize_stat(kstat_t *kp, ks_instance_t *ksi) 1204 { 1205 struct sfmmu_tsbsize_stat *sfmmut; 1206 1207 assert(kp->ks_data_size == sizeof (struct sfmmu_tsbsize_stat)); 1208 sfmmut = (struct sfmmu_tsbsize_stat *)(kp->ks_data); 1209 1210 SAVE_INT32(ksi, sfmmut, sf_tsbsz_8k); 1211 SAVE_INT32(ksi, sfmmut, sf_tsbsz_16k); 1212 SAVE_INT32(ksi, sfmmut, sf_tsbsz_32k); 1213 SAVE_INT32(ksi, sfmmut, sf_tsbsz_64k); 1214 SAVE_INT32(ksi, sfmmut, sf_tsbsz_128k); 1215 SAVE_INT32(ksi, sfmmut, sf_tsbsz_256k); 1216 SAVE_INT32(ksi, sfmmut, sf_tsbsz_512k); 1217 SAVE_INT32(ksi, sfmmut, sf_tsbsz_1m); 1218 SAVE_INT32(ksi, sfmmut, sf_tsbsz_2m); 1219 SAVE_INT32(ksi, sfmmut, sf_tsbsz_4m); 1220 } 1221 #endif 1222 1223 #ifdef __sparc 1224 static void 1225 save_simmstat(kstat_t *kp, ks_instance_t *ksi) 1226 { 1227 uchar_t *simmstat; 1228 char *simm_buf; 1229 char *list = NULL; 1230 int i; 1231 1232 assert(kp->ks_data_size == sizeof (uchar_t) * SIMM_COUNT); 1233 1234 for (i = 0, simmstat = (uchar_t *)(kp->ks_data); i < SIMM_COUNT - 1; 1235 i++, simmstat++) { 1236 if (list == NULL) { 1237 (void) asprintf(&simm_buf, "%d,", *simmstat); 1238 } else { 1239 (void) asprintf(&simm_buf, "%s%d,", list, *simmstat); 1240 free(list); 1241 } 1242 list = simm_buf; 1243 } 1244 1245 (void) asprintf(&simm_buf, "%s%d", list, *simmstat); 1246 SAVE_STRING_X(ksi, "status", simm_buf); 1247 free(list); 1248 free(simm_buf); 1249 } 1250 #endif 1251 1252 #ifdef __sparc 1253 /* 1254 * Helper function for save_temperature(). 1255 */ 1256 static char * 1257 short_array_to_string(short *shortp, int len) 1258 { 1259 char *list = NULL; 1260 char *list_buf; 1261 1262 for (; len > 1; len--, shortp++) { 1263 if (list == NULL) { 1264 (void) asprintf(&list_buf, "%hd,", *shortp); 1265 } else { 1266 (void) asprintf(&list_buf, "%s%hd,", list, *shortp); 1267 free(list); 1268 } 1269 list = list_buf; 1270 } 1271 1272 (void) asprintf(&list_buf, "%s%hd", list, *shortp); 1273 free(list); 1274 return (list_buf); 1275 } 1276 1277 static void 1278 save_temperature(kstat_t *kp, ks_instance_t *ksi) 1279 { 1280 struct temp_stats *temps = (struct temp_stats *)(kp->ks_data); 1281 char *buf; 1282 1283 assert(kp->ks_data_size == sizeof (struct temp_stats)); 1284 1285 SAVE_UINT32(ksi, temps, index); 1286 1287 buf = short_array_to_string(temps->l1, L1_SZ); 1288 SAVE_STRING_X(ksi, "l1", buf); 1289 free(buf); 1290 1291 buf = short_array_to_string(temps->l2, L2_SZ); 1292 SAVE_STRING_X(ksi, "l2", buf); 1293 free(buf); 1294 1295 buf = short_array_to_string(temps->l3, L3_SZ); 1296 SAVE_STRING_X(ksi, "l3", buf); 1297 free(buf); 1298 1299 buf = short_array_to_string(temps->l4, L4_SZ); 1300 SAVE_STRING_X(ksi, "l4", buf); 1301 free(buf); 1302 1303 buf = short_array_to_string(temps->l5, L5_SZ); 1304 SAVE_STRING_X(ksi, "l5", buf); 1305 free(buf); 1306 1307 SAVE_INT32(ksi, temps, max); 1308 SAVE_INT32(ksi, temps, min); 1309 SAVE_INT32(ksi, temps, state); 1310 SAVE_INT32(ksi, temps, temp_cnt); 1311 SAVE_INT32(ksi, temps, shutdown_cnt); 1312 SAVE_INT32(ksi, temps, version); 1313 SAVE_INT32(ksi, temps, trend); 1314 SAVE_INT32(ksi, temps, override); 1315 } 1316 #endif 1317 1318 #ifdef __sparc 1319 static void 1320 save_temp_over(kstat_t *kp, ks_instance_t *ksi) 1321 { 1322 short *sh = (short *)(kp->ks_data); 1323 char *value; 1324 1325 assert(kp->ks_data_size == sizeof (short)); 1326 1327 (void) asprintf(&value, "%hu", *sh); 1328 SAVE_STRING_X(ksi, "override", value); 1329 free(value); 1330 } 1331 #endif 1332 1333 #ifdef __sparc 1334 static void 1335 save_ps_shadow(kstat_t *kp, ks_instance_t *ksi) 1336 { 1337 uchar_t *uchar = (uchar_t *)(kp->ks_data); 1338 1339 assert(kp->ks_data_size == SYS_PS_COUNT); 1340 1341 SAVE_CHAR_X(ksi, "core_0", *uchar++); 1342 SAVE_CHAR_X(ksi, "core_1", *uchar++); 1343 SAVE_CHAR_X(ksi, "core_2", *uchar++); 1344 SAVE_CHAR_X(ksi, "core_3", *uchar++); 1345 SAVE_CHAR_X(ksi, "core_4", *uchar++); 1346 SAVE_CHAR_X(ksi, "core_5", *uchar++); 1347 SAVE_CHAR_X(ksi, "core_6", *uchar++); 1348 SAVE_CHAR_X(ksi, "core_7", *uchar++); 1349 SAVE_CHAR_X(ksi, "pps_0", *uchar++); 1350 SAVE_CHAR_X(ksi, "clk_33", *uchar++); 1351 SAVE_CHAR_X(ksi, "clk_50", *uchar++); 1352 SAVE_CHAR_X(ksi, "v5_p", *uchar++); 1353 SAVE_CHAR_X(ksi, "v12_p", *uchar++); 1354 SAVE_CHAR_X(ksi, "v5_aux", *uchar++); 1355 SAVE_CHAR_X(ksi, "v5_p_pch", *uchar++); 1356 SAVE_CHAR_X(ksi, "v12_p_pch", *uchar++); 1357 SAVE_CHAR_X(ksi, "v3_pch", *uchar++); 1358 SAVE_CHAR_X(ksi, "v5_pch", *uchar++); 1359 SAVE_CHAR_X(ksi, "p_fan", *uchar++); 1360 } 1361 #endif 1362 1363 #ifdef __sparc 1364 static void 1365 save_fault_list(kstat_t *kp, ks_instance_t *ksi) 1366 { 1367 struct ft_list *fault; 1368 char name[KSTAT_STRLEN + 7]; 1369 int i; 1370 1371 for (i = 1, fault = (struct ft_list *)(kp->ks_data); 1372 i <= 999999 && i <= kp->ks_data_size / sizeof (struct ft_list); 1373 i++, fault++) { 1374 (void) snprintf(name, sizeof (name), "unit_%d", i); 1375 SAVE_INT32_X(ksi, name, fault->unit); 1376 (void) snprintf(name, sizeof (name), "type_%d", i); 1377 SAVE_INT32_X(ksi, name, fault->type); 1378 (void) snprintf(name, sizeof (name), "fclass_%d", i); 1379 SAVE_INT32_X(ksi, name, fault->fclass); 1380 (void) snprintf(name, sizeof (name), "create_time_%d", i); 1381 SAVE_HRTIME_X(ksi, name, fault->create_time); 1382 (void) snprintf(name, sizeof (name), "msg_%d", i); 1383 SAVE_STRING_X(ksi, name, fault->msg); 1384 } 1385 } 1386 #endif 1387 1388 static void 1389 save_named(kstat_t *kp, ks_instance_t *ksi) 1390 { 1391 kstat_named_t *knp; 1392 int n; 1393 1394 for (n = kp->ks_ndata, knp = KSTAT_NAMED_PTR(kp); n > 0; n--, knp++) { 1395 switch (knp->data_type) { 1396 case KSTAT_DATA_CHAR: 1397 nvpair_insert(ksi, knp->name, 1398 (ks_value_t *)&knp->value, KSTAT_DATA_CHAR); 1399 break; 1400 case KSTAT_DATA_INT32: 1401 nvpair_insert(ksi, knp->name, 1402 (ks_value_t *)&knp->value, KSTAT_DATA_INT32); 1403 break; 1404 case KSTAT_DATA_UINT32: 1405 nvpair_insert(ksi, knp->name, 1406 (ks_value_t *)&knp->value, KSTAT_DATA_UINT32); 1407 break; 1408 case KSTAT_DATA_INT64: 1409 nvpair_insert(ksi, knp->name, 1410 (ks_value_t *)&knp->value, KSTAT_DATA_INT64); 1411 break; 1412 case KSTAT_DATA_UINT64: 1413 nvpair_insert(ksi, knp->name, 1414 (ks_value_t *)&knp->value, KSTAT_DATA_UINT64); 1415 break; 1416 case KSTAT_DATA_STRING: 1417 SAVE_STRING_X(ksi, knp->name, KSTAT_NAMED_STR_PTR(knp)); 1418 break; 1419 default: 1420 assert(B_FALSE); /* Invalid data type */ 1421 break; 1422 } 1423 } 1424 } 1425 1426 static void 1427 save_intr(kstat_t *kp, ks_instance_t *ksi) 1428 { 1429 kstat_intr_t *intr = KSTAT_INTR_PTR(kp); 1430 char *intr_names[] = {"hard", "soft", "watchdog", "spurious", 1431 "multiple_service"}; 1432 int n; 1433 1434 for (n = 0; n < KSTAT_NUM_INTRS; n++) 1435 SAVE_UINT32_X(ksi, intr_names[n], intr->intrs[n]); 1436 } 1437 1438 static void 1439 save_io(kstat_t *kp, ks_instance_t *ksi) 1440 { 1441 kstat_io_t *ksio = KSTAT_IO_PTR(kp); 1442 1443 SAVE_UINT64(ksi, ksio, nread); 1444 SAVE_UINT64(ksi, ksio, nwritten); 1445 SAVE_UINT32(ksi, ksio, reads); 1446 SAVE_UINT32(ksi, ksio, writes); 1447 SAVE_HRTIME(ksi, ksio, wtime); 1448 SAVE_HRTIME(ksi, ksio, wlentime); 1449 SAVE_HRTIME(ksi, ksio, wlastupdate); 1450 SAVE_HRTIME(ksi, ksio, rtime); 1451 SAVE_HRTIME(ksi, ksio, rlentime); 1452 SAVE_HRTIME(ksi, ksio, rlastupdate); 1453 SAVE_UINT32(ksi, ksio, wcnt); 1454 SAVE_UINT32(ksi, ksio, rcnt); 1455 } 1456 1457 static void 1458 save_timer(kstat_t *kp, ks_instance_t *ksi) 1459 { 1460 kstat_timer_t *ktimer = KSTAT_TIMER_PTR(kp); 1461 1462 SAVE_STRING(ksi, ktimer, name); 1463 SAVE_UINT64(ksi, ktimer, num_events); 1464 SAVE_HRTIME(ksi, ktimer, elapsed_time); 1465 SAVE_HRTIME(ksi, ktimer, min_time); 1466 SAVE_HRTIME(ksi, ktimer, max_time); 1467 SAVE_HRTIME(ksi, ktimer, start_time); 1468 SAVE_HRTIME(ksi, ktimer, stop_time); 1469 } 1470