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.
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.
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]
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 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
30 * Display kernel statistics
32 * This is a reimplementation of the perl kstat command originally found
33 * under usr/src/cmd/kstat/kstat.pl
36 * - perl regular expressions replaced with extended REs bracketed by '/'
39 * -C similar to the -p option but value is separated by a colon
62 #include <sys/types.h>
65 #include "statcommon.h"
67 char *cmdname
= "kstat"; /* Name of this command */
68 int caught_cont
= 0; /* Have caught a SIGCONT */
70 static uint_t g_timestamp_fmt
= NODATE
;
72 /* Helper flag - header was printed already? */
73 static boolean_t g_headerflg
;
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};
83 /* Return zero if a selector did match */
84 static int g_matched
= 1;
86 /* Sorted list of kstat instances */
87 static list_t instances_list
;
88 static list_t selector_list
;
91 main(int argc
, char **argv
)
93 ks_selector_t
*nselector
;
94 ks_selector_t
*uselector
;
98 boolean_t errflg
= B_FALSE
;
99 boolean_t nselflg
= B_FALSE
;
100 boolean_t uselflg
= B_FALSE
;
103 int infinite_cycles
= 0;
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 */
112 (void) textdomain(TEXT_DOMAIN
);
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.
119 list_create(&selector_list
, sizeof (ks_selector_t
),
120 offsetof(ks_selector_t
, ks_next
));
122 nselector
= new_selector();
125 * Parse named command line arguments.
127 while ((c
= getopt(argc
, argv
, "h?CqjlpT:m:i:n:s:c:")) != EOF
)
135 g_pflg
= g_cflg
= B_TRUE
;
144 g_pflg
= g_lflg
= B_TRUE
;
152 g_timestamp_fmt
= DDATE
;
155 g_timestamp_fmt
= UDATE
;
163 nselector
->ks_module
.pstr
=
164 (char *)ks_safe_strdup(optarg
);
168 nselector
->ks_instance
.pstr
=
169 (char *)ks_safe_strdup(optarg
);
173 nselector
->ks_name
.pstr
=
174 (char *)ks_safe_strdup(optarg
);
178 nselector
->ks_statistic
.pstr
=
179 (char *)ks_safe_strdup(optarg
);
183 (char *)ks_safe_strdup(optarg
);
190 if (g_qflg
&& (g_jflg
|| g_pflg
)) {
191 (void) fprintf(stderr
, gettext(
192 "-q and -lpj are mutually exclusive\n"));
205 * Consume the rest of the command line. Parsing the
206 * unnamed command line arguments.
210 tmp
= strtoul(*argv
, &q
, 10);
211 if (tmp
== ULONG_MAX
&& errno
== ERANGE
) {
213 (void) fprintf(stderr
, gettext(
214 "Interval is too large\n"));
216 (void) fprintf(stderr
, gettext(
217 "Count is too large\n"));
223 if (errno
!= 0 || *q
!= '\0') {
225 uselector
= new_selector();
226 while ((q
= (char *)strsep(argv
, ":")) != NULL
) {
237 uselector
->ks_module
.pstr
=
238 (char *)ks_safe_strdup(q
);
241 uselector
->ks_instance
.pstr
=
242 (char *)ks_safe_strdup(q
);
245 uselector
->ks_name
.pstr
=
246 (char *)ks_safe_strdup(q
);
249 uselector
->ks_statistic
.pstr
=
250 (char *)ks_safe_strdup(q
);
259 list_insert_tail(&selector_list
, uselector
);
263 (void) fprintf(stderr
, gettext(
264 "Interval must be an "
267 (void) fprintf(stderr
, gettext(
268 "Count must be an integer >= 1"));
289 * Check if we founded a named selector on the cmdline.
293 (void) fprintf(stderr
, gettext(
294 "[module[:instance[:name[:statistic]]]] and "
295 "-m -i -n -s are mutually exclusive"));
302 list_insert_tail(&selector_list
, nselector
);
305 assert(!list_is_empty(&selector_list
));
307 list_create(&instances_list
, sizeof (ks_instance_t
),
308 offsetof(ks_instance_t
, ks_next
));
310 while ((kc
= kstat_open()) == NULL
) {
311 if (errno
== EAGAIN
) {
312 (void) poll(NULL
, 0, 200);
314 perror("kstat_open");
320 if (signal(SIGCONT
, cont_handler
) == SIG_ERR
) {
321 (void) fprintf(stderr
, gettext(
327 period_n
= (hrtime_t
)interval
* NANOSEC
;
328 start_n
= gethrtime();
330 while (count
== -1 || count
-- > 0) {
331 ks_instances_read(kc
);
332 ks_instances_print();
334 if (interval
&& count
) {
335 ks_sleep_until(&start_n
, period_n
, infinite_cycles
,
337 (void) kstat_chain_update(kc
);
338 (void) putchar('\n');
342 (void) kstat_close(kc
);
353 (void) fprintf(stderr
, gettext(
355 "kstat [ -Cjlpq ] [ -T d|u ] [ -c class ]\n"
356 " [ -m module ] [ -i instance ] [ -n name ] [ -s statistic ]\n"
357 " [ interval [ count ] ]\n"
358 "kstat [ -Cjlpq ] [ -T d|u ] [ -c class ]\n"
359 " [ module[:instance[:name[:statistic]]] ... ]\n"
360 " [ interval [ count ] ]\n"));
364 * Sort compare function.
367 compare_instances(ks_instance_t
*l_arg
, ks_instance_t
*r_arg
)
371 rval
= strcasecmp(l_arg
->ks_module
, r_arg
->ks_module
);
373 if (l_arg
->ks_instance
== r_arg
->ks_instance
) {
374 return (strcasecmp(l_arg
->ks_name
, r_arg
->ks_name
));
375 } else if (l_arg
->ks_instance
< r_arg
->ks_instance
) {
386 ks_safe_strdup(char *str
)
394 while ((ret
= strdup(str
)) == NULL
) {
395 if (errno
== EAGAIN
) {
396 (void) poll(NULL
, 0, 200);
407 ks_sleep_until(hrtime_t
*wakeup
, hrtime_t interval
, int forever
,
410 hrtime_t now
, pause
, pause_left
;
411 struct timespec pause_tv
;
415 pause
= *wakeup
+ interval
- now
;
417 if (pause
<= 0 || pause
< (interval
/ 4)) {
418 if (forever
|| *caught_cont
) {
419 *wakeup
= now
+ interval
;
422 pause
= interval
/ 2;
435 pause_tv
.tv_sec
= pause_left
/ NANOSEC
;
436 pause_tv
.tv_nsec
= pause_left
% NANOSEC
;
437 status
= nanosleep(&pause_tv
, (struct timespec
*)NULL
);
439 if (errno
== EINTR
) {
441 pause_left
= *wakeup
- now
;
442 if (pause_left
< 1000) {
450 } while (status
!= 0);
454 * Inserts an instance in the per selector list.
457 nvpair_insert(ks_instance_t
*ksi
, char *name
, ks_value_t
*value
,
460 ks_nvpair_t
*instance
;
463 instance
= (ks_nvpair_t
*)malloc(sizeof (ks_nvpair_t
));
464 if (instance
== NULL
) {
469 (void) strlcpy(instance
->name
, name
, KSTAT_STRLEN
);
470 (void) memcpy(&instance
->value
, value
, sizeof (ks_value_t
));
471 instance
->data_type
= data_type
;
473 tmp
= list_head(&ksi
->ks_nvlist
);
474 while (tmp
!= NULL
&& strcasecmp(instance
->name
, tmp
->name
) > 0)
475 tmp
= list_next(&ksi
->ks_nvlist
, tmp
);
477 list_insert_before(&ksi
->ks_nvlist
, tmp
, instance
);
481 * Allocates a new all-matching selector.
483 static ks_selector_t
*
486 ks_selector_t
*selector
;
488 selector
= (ks_selector_t
*)malloc(sizeof (ks_selector_t
));
489 if (selector
== NULL
) {
494 list_link_init(&selector
->ks_next
);
496 selector
->ks_module
.pstr
= "*";
497 selector
->ks_instance
.pstr
= "*";
498 selector
->ks_name
.pstr
= "*";
499 selector
->ks_statistic
.pstr
= "*";
505 * This function was taken from the perl kstat module code - please
506 * see for further comments there.
508 static kstat_raw_reader_t
509 lookup_raw_kstat_fn(char *module
, char *name
)
511 char key
[KSTAT_STRLEN
* 2];
512 register char *f
, *t
;
515 for (f
= module
, t
= key
; *f
!= '\0'; f
++, t
++) {
516 while (*f
!= '\0' && isdigit(*f
))
522 for (f
= name
; *f
!= '\0'; f
++, t
++) {
523 while (*f
!= '\0' && isdigit(*f
))
529 while (ks_raw_lookup
[n
].fn
!= NULL
) {
530 if (strncmp(ks_raw_lookup
[n
].name
, key
, strlen(key
)) == 0)
531 return (ks_raw_lookup
[n
].fn
);
539 * Match a string against a shell glob or extended regular expression.
542 ks_match(const char *str
, ks_pattern_t
*pattern
)
549 if (pattern
->pstr
!= NULL
&& gmatch(pattern
->pstr
, "/*/") != 0) {
550 /* All regex patterns are strdup'd copies */
551 regstr
= pattern
->pstr
+ 1;
552 *(strrchr(regstr
, '/')) = '\0';
554 regcode
= regcomp(&pattern
->preg
, regstr
,
555 REG_EXTENDED
| REG_NOSUB
);
557 bufsz
= regerror(regcode
, NULL
, NULL
, 0);
559 errbuf
= malloc(bufsz
);
560 if (errbuf
== NULL
) {
564 (void) regerror(regcode
, NULL
, errbuf
, bufsz
);
565 (void) fprintf(stderr
, "kstat: %s\n", errbuf
);
571 pattern
->pstr
= NULL
;
574 if (pattern
->pstr
== NULL
) {
575 return (regexec(&pattern
->preg
, str
, 0, NULL
, 0) == 0);
578 return ((gmatch(str
, pattern
->pstr
) != 0));
582 * Iterate over all kernel statistics and save matches.
585 ks_instances_read(kstat_ctl_t
*kc
)
587 kstat_raw_reader_t save_raw
= NULL
;
589 ks_selector_t
*selector
;
595 for (kp
= kc
->kc_chain
; kp
!= NULL
; kp
= kp
->ks_next
) {
596 /* Don't bother storing the kstat headers */
597 if (strncmp(kp
->ks_name
, "kstat_", 6) == 0) {
601 /* Don't bother storing raw stats we don't understand */
602 if (kp
->ks_type
== KSTAT_TYPE_RAW
) {
603 save_raw
= lookup_raw_kstat_fn(kp
->ks_module
,
605 if (save_raw
== NULL
) {
606 #ifdef REPORT_UNKNOWN
607 (void) fprintf(stderr
,
608 "Unknown kstat type %s:%d:%s - "
609 "%d of size %d\n", kp
->ks_module
,
610 kp
->ks_instance
, kp
->ks_name
,
611 kp
->ks_ndata
, kp
->ks_data_size
);
618 * Iterate over the list of selectors and skip
619 * instances we dont want. We filter for statistics
620 * later, as we dont know them yet.
623 selector
= list_head(&selector_list
);
624 while (selector
!= NULL
) {
625 if (ks_match(kp
->ks_module
, &selector
->ks_module
) &&
626 ks_match(kp
->ks_name
, &selector
->ks_name
)) {
630 selector
= list_next(&selector_list
, selector
);
638 * Allocate a new instance and fill in the values
641 ksi
= (ks_instance_t
*)malloc(sizeof (ks_instance_t
));
647 list_link_init(&ksi
->ks_next
);
649 (void) strlcpy(ksi
->ks_module
, kp
->ks_module
, KSTAT_STRLEN
);
650 (void) strlcpy(ksi
->ks_name
, kp
->ks_name
, KSTAT_STRLEN
);
651 (void) strlcpy(ksi
->ks_class
, kp
->ks_class
, KSTAT_STRLEN
);
653 ksi
->ks_instance
= kp
->ks_instance
;
654 ksi
->ks_snaptime
= kp
->ks_snaptime
;
655 ksi
->ks_type
= kp
->ks_type
;
657 list_create(&ksi
->ks_nvlist
, sizeof (ks_nvpair_t
),
658 offsetof(ks_nvpair_t
, nv_next
));
660 SAVE_HRTIME_X(ksi
, "crtime", kp
->ks_crtime
);
661 SAVE_HRTIME_X(ksi
, "snaptime", kp
->ks_snaptime
);
663 SAVE_STRING_X(ksi
, "class", kp
->ks_class
);
666 /* Insert this instance into a sorted list */
667 tmp
= list_head(&instances_list
);
668 while (tmp
!= NULL
&& compare_instances(ksi
, tmp
) > 0)
669 tmp
= list_next(&instances_list
, tmp
);
671 list_insert_before(&instances_list
, tmp
, ksi
);
673 /* Read the actual statistics */
674 id
= kstat_read(kc
, kp
, NULL
);
676 #ifdef REPORT_UNKNOWN
677 perror("kstat_read");
682 switch (kp
->ks_type
) {
686 case KSTAT_TYPE_NAMED
:
689 case KSTAT_TYPE_INTR
:
695 case KSTAT_TYPE_TIMER
:
699 assert(B_FALSE
); /* Invalid type */
706 * Print the value of a name-value pair.
709 ks_value_print(ks_nvpair_t
*nvpair
)
711 switch (nvpair
->data_type
) {
712 case KSTAT_DATA_CHAR
:
713 (void) fprintf(stdout
, "%s", nvpair
->value
.c
);
715 case KSTAT_DATA_INT32
:
716 (void) fprintf(stdout
, "%d", nvpair
->value
.i32
);
718 case KSTAT_DATA_UINT32
:
719 (void) fprintf(stdout
, "%u", nvpair
->value
.ui32
);
721 case KSTAT_DATA_INT64
:
722 (void) fprintf(stdout
, "%lld", nvpair
->value
.i64
);
724 case KSTAT_DATA_UINT64
:
725 (void) fprintf(stdout
, "%llu", nvpair
->value
.ui64
);
727 case KSTAT_DATA_STRING
:
728 (void) fprintf(stdout
, "%s", KSTAT_NAMED_STR_PTR(nvpair
));
730 case KSTAT_DATA_HRTIME
:
731 if (nvpair
->value
.ui64
== 0)
732 (void) fprintf(stdout
, "0");
734 (void) fprintf(stdout
, "%.9f",
735 nvpair
->value
.ui64
/ 1000000000.0);
743 * Print a single instance.
746 ks_instance_print(ks_instance_t
*ksi
, ks_nvpair_t
*nvpair
)
750 (void) fprintf(stdout
, DFLT_FMT
,
751 ksi
->ks_module
, ksi
->ks_instance
,
752 ksi
->ks_name
, ksi
->ks_class
);
754 g_headerflg
= B_FALSE
;
758 (void) fprintf(stdout
, KS_PFMT
,
759 ksi
->ks_module
, ksi
->ks_instance
,
760 ksi
->ks_name
, nvpair
->name
);
762 (void) putchar(g_cflg
? ':': '\t');
763 ks_value_print(nvpair
);
766 (void) fprintf(stdout
, KS_DFMT
, nvpair
->name
);
767 ks_value_print(nvpair
);
770 (void) putchar('\n');
774 * Print a single instance in JSON format.
777 ks_instance_print_json(ks_instance_t
*ksi
, ks_nvpair_t
*nvpair
)
780 (void) fprintf(stdout
, JSON_FMT
,
781 ksi
->ks_module
, ksi
->ks_instance
,
782 ksi
->ks_name
, ksi
->ks_class
,
785 if (ksi
->ks_snaptime
== 0)
786 (void) fprintf(stdout
, "\t\"snaptime\": 0,\n");
788 (void) fprintf(stdout
, "\t\"snaptime\": %.9f,\n",
789 ksi
->ks_snaptime
/ 1000000000.0);
791 (void) fprintf(stdout
, "\t\"data\": {\n");
793 g_headerflg
= B_FALSE
;
796 (void) fprintf(stdout
, KS_JFMT
, nvpair
->name
);
797 if (nvpair
->data_type
== KSTAT_DATA_STRING
) {
798 (void) putchar('\"');
799 ks_value_print(nvpair
);
800 (void) putchar('\"');
802 ks_value_print(nvpair
);
804 if (nvpair
!= list_tail(&ksi
->ks_nvlist
))
807 (void) putchar('\n');
811 * Print all instances.
814 ks_instances_print(void)
816 ks_selector_t
*selector
;
817 ks_instance_t
*ksi
, *ktmp
;
818 ks_nvpair_t
*nvpair
, *ntmp
;
819 void (*ks_print_fn
)(ks_instance_t
*, ks_nvpair_t
*);
822 if (g_timestamp_fmt
!= NODATE
)
823 print_timestamp(g_timestamp_fmt
);
826 ks_print_fn
= &ks_instance_print_json
;
829 ks_print_fn
= &ks_instance_print
;
832 /* Iterate over each selector */
833 selector
= list_head(&selector_list
);
834 while (selector
!= NULL
) {
836 /* Iterate over each instance */
837 for (ksi
= list_head(&instances_list
); ksi
!= NULL
;
838 ksi
= list_next(&instances_list
, ksi
)) {
840 (void) asprintf(&ks_number
, "%d", ksi
->ks_instance
);
841 if (!(ks_match(ksi
->ks_module
, &selector
->ks_module
) &&
842 ks_match(ksi
->ks_name
, &selector
->ks_name
) &&
843 ks_match(ks_number
, &selector
->ks_instance
) &&
844 ks_match(ksi
->ks_class
, &g_ks_class
))) {
851 /* Finally iterate over each statistic */
852 g_headerflg
= B_TRUE
;
853 for (nvpair
= list_head(&ksi
->ks_nvlist
);
855 nvpair
= list_next(&ksi
->ks_nvlist
, nvpair
)) {
856 if (!ks_match(nvpair
->name
,
857 &selector
->ks_statistic
))
862 (*ks_print_fn
)(ksi
, nvpair
);
867 (void) fprintf(stdout
, "\t}\n}");
868 if (ksi
!= list_tail(&instances_list
))
870 } else if (!g_pflg
) {
871 (void) putchar('\n');
876 selector
= list_next(&selector_list
, selector
);
880 (void) fprintf(stdout
, "]\n");
882 (void) fflush(stdout
);
884 /* Free the instances list */
885 ksi
= list_head(&instances_list
);
886 while (ksi
!= NULL
) {
887 nvpair
= list_head(&ksi
->ks_nvlist
);
888 while (nvpair
!= NULL
) {
890 nvpair
= list_next(&ksi
->ks_nvlist
, nvpair
);
891 list_remove(&ksi
->ks_nvlist
, ntmp
);
892 if (ntmp
->data_type
== KSTAT_DATA_STRING
)
893 free(ntmp
->value
.str
.addr
.ptr
);
898 ksi
= list_next(&instances_list
, ksi
);
899 list_remove(&instances_list
, ktmp
);
900 list_destroy(&ktmp
->ks_nvlist
);
906 save_cpu_stat(kstat_t
*kp
, ks_instance_t
*ksi
)
909 cpu_sysinfo_t
*sysinfo
;
910 cpu_syswait_t
*syswait
;
911 cpu_vminfo_t
*vminfo
;
913 stat
= (cpu_stat_t
*)(kp
->ks_data
);
914 sysinfo
= &stat
->cpu_sysinfo
;
915 syswait
= &stat
->cpu_syswait
;
916 vminfo
= &stat
->cpu_vminfo
;
918 SAVE_UINT32_X(ksi
, "idle", sysinfo
->cpu
[CPU_IDLE
]);
919 SAVE_UINT32_X(ksi
, "user", sysinfo
->cpu
[CPU_USER
]);
920 SAVE_UINT32_X(ksi
, "kernel", sysinfo
->cpu
[CPU_KERNEL
]);
921 SAVE_UINT32_X(ksi
, "wait", sysinfo
->cpu
[CPU_WAIT
]);
922 SAVE_UINT32_X(ksi
, "wait_io", sysinfo
->wait
[W_IO
]);
923 SAVE_UINT32_X(ksi
, "wait_swap", sysinfo
->wait
[W_SWAP
]);
924 SAVE_UINT32_X(ksi
, "wait_pio", sysinfo
->wait
[W_PIO
]);
925 SAVE_UINT32(ksi
, sysinfo
, bread
);
926 SAVE_UINT32(ksi
, sysinfo
, bwrite
);
927 SAVE_UINT32(ksi
, sysinfo
, lread
);
928 SAVE_UINT32(ksi
, sysinfo
, lwrite
);
929 SAVE_UINT32(ksi
, sysinfo
, phread
);
930 SAVE_UINT32(ksi
, sysinfo
, phwrite
);
931 SAVE_UINT32(ksi
, sysinfo
, pswitch
);
932 SAVE_UINT32(ksi
, sysinfo
, trap
);
933 SAVE_UINT32(ksi
, sysinfo
, intr
);
934 SAVE_UINT32(ksi
, sysinfo
, syscall
);
935 SAVE_UINT32(ksi
, sysinfo
, sysread
);
936 SAVE_UINT32(ksi
, sysinfo
, syswrite
);
937 SAVE_UINT32(ksi
, sysinfo
, sysfork
);
938 SAVE_UINT32(ksi
, sysinfo
, sysvfork
);
939 SAVE_UINT32(ksi
, sysinfo
, sysexec
);
940 SAVE_UINT32(ksi
, sysinfo
, readch
);
941 SAVE_UINT32(ksi
, sysinfo
, writech
);
942 SAVE_UINT32(ksi
, sysinfo
, rcvint
);
943 SAVE_UINT32(ksi
, sysinfo
, xmtint
);
944 SAVE_UINT32(ksi
, sysinfo
, mdmint
);
945 SAVE_UINT32(ksi
, sysinfo
, rawch
);
946 SAVE_UINT32(ksi
, sysinfo
, canch
);
947 SAVE_UINT32(ksi
, sysinfo
, outch
);
948 SAVE_UINT32(ksi
, sysinfo
, msg
);
949 SAVE_UINT32(ksi
, sysinfo
, sema
);
950 SAVE_UINT32(ksi
, sysinfo
, namei
);
951 SAVE_UINT32(ksi
, sysinfo
, ufsiget
);
952 SAVE_UINT32(ksi
, sysinfo
, ufsdirblk
);
953 SAVE_UINT32(ksi
, sysinfo
, ufsipage
);
954 SAVE_UINT32(ksi
, sysinfo
, ufsinopage
);
955 SAVE_UINT32(ksi
, sysinfo
, inodeovf
);
956 SAVE_UINT32(ksi
, sysinfo
, fileovf
);
957 SAVE_UINT32(ksi
, sysinfo
, procovf
);
958 SAVE_UINT32(ksi
, sysinfo
, intrthread
);
959 SAVE_UINT32(ksi
, sysinfo
, intrblk
);
960 SAVE_UINT32(ksi
, sysinfo
, idlethread
);
961 SAVE_UINT32(ksi
, sysinfo
, inv_swtch
);
962 SAVE_UINT32(ksi
, sysinfo
, nthreads
);
963 SAVE_UINT32(ksi
, sysinfo
, cpumigrate
);
964 SAVE_UINT32(ksi
, sysinfo
, xcalls
);
965 SAVE_UINT32(ksi
, sysinfo
, mutex_adenters
);
966 SAVE_UINT32(ksi
, sysinfo
, rw_rdfails
);
967 SAVE_UINT32(ksi
, sysinfo
, rw_wrfails
);
968 SAVE_UINT32(ksi
, sysinfo
, modload
);
969 SAVE_UINT32(ksi
, sysinfo
, modunload
);
970 SAVE_UINT32(ksi
, sysinfo
, bawrite
);
971 #ifdef STATISTICS /* see header file */
972 SAVE_UINT32(ksi
, sysinfo
, rw_enters
);
973 SAVE_UINT32(ksi
, sysinfo
, win_uo_cnt
);
974 SAVE_UINT32(ksi
, sysinfo
, win_uu_cnt
);
975 SAVE_UINT32(ksi
, sysinfo
, win_so_cnt
);
976 SAVE_UINT32(ksi
, sysinfo
, win_su_cnt
);
977 SAVE_UINT32(ksi
, sysinfo
, win_suo_cnt
);
980 SAVE_INT32(ksi
, syswait
, iowait
);
981 SAVE_INT32(ksi
, syswait
, swap
);
982 SAVE_INT32(ksi
, syswait
, physio
);
984 SAVE_UINT32(ksi
, vminfo
, pgrec
);
985 SAVE_UINT32(ksi
, vminfo
, pgfrec
);
986 SAVE_UINT32(ksi
, vminfo
, pgin
);
987 SAVE_UINT32(ksi
, vminfo
, pgpgin
);
988 SAVE_UINT32(ksi
, vminfo
, pgout
);
989 SAVE_UINT32(ksi
, vminfo
, pgpgout
);
990 SAVE_UINT32(ksi
, vminfo
, swapin
);
991 SAVE_UINT32(ksi
, vminfo
, pgswapin
);
992 SAVE_UINT32(ksi
, vminfo
, swapout
);
993 SAVE_UINT32(ksi
, vminfo
, pgswapout
);
994 SAVE_UINT32(ksi
, vminfo
, zfod
);
995 SAVE_UINT32(ksi
, vminfo
, dfree
);
996 SAVE_UINT32(ksi
, vminfo
, scan
);
997 SAVE_UINT32(ksi
, vminfo
, rev
);
998 SAVE_UINT32(ksi
, vminfo
, hat_fault
);
999 SAVE_UINT32(ksi
, vminfo
, as_fault
);
1000 SAVE_UINT32(ksi
, vminfo
, maj_fault
);
1001 SAVE_UINT32(ksi
, vminfo
, cow_fault
);
1002 SAVE_UINT32(ksi
, vminfo
, prot_fault
);
1003 SAVE_UINT32(ksi
, vminfo
, softlock
);
1004 SAVE_UINT32(ksi
, vminfo
, kernel_asflt
);
1005 SAVE_UINT32(ksi
, vminfo
, pgrrun
);
1006 SAVE_UINT32(ksi
, vminfo
, execpgin
);
1007 SAVE_UINT32(ksi
, vminfo
, execpgout
);
1008 SAVE_UINT32(ksi
, vminfo
, execfree
);
1009 SAVE_UINT32(ksi
, vminfo
, anonpgin
);
1010 SAVE_UINT32(ksi
, vminfo
, anonpgout
);
1011 SAVE_UINT32(ksi
, vminfo
, anonfree
);
1012 SAVE_UINT32(ksi
, vminfo
, fspgin
);
1013 SAVE_UINT32(ksi
, vminfo
, fspgout
);
1014 SAVE_UINT32(ksi
, vminfo
, fsfree
);
1018 save_var(kstat_t
*kp
, ks_instance_t
*ksi
)
1020 struct var
*var
= (struct var
*)(kp
->ks_data
);
1022 assert(kp
->ks_data_size
== sizeof (struct var
));
1024 SAVE_INT32(ksi
, var
, v_buf
);
1025 SAVE_INT32(ksi
, var
, v_call
);
1026 SAVE_INT32(ksi
, var
, v_proc
);
1027 SAVE_INT32(ksi
, var
, v_maxupttl
);
1028 SAVE_INT32(ksi
, var
, v_nglobpris
);
1029 SAVE_INT32(ksi
, var
, v_maxsyspri
);
1030 SAVE_INT32(ksi
, var
, v_clist
);
1031 SAVE_INT32(ksi
, var
, v_maxup
);
1032 SAVE_INT32(ksi
, var
, v_hbuf
);
1033 SAVE_INT32(ksi
, var
, v_hmask
);
1034 SAVE_INT32(ksi
, var
, v_pbuf
);
1035 SAVE_INT32(ksi
, var
, v_sptmap
);
1036 SAVE_INT32(ksi
, var
, v_maxpmem
);
1037 SAVE_INT32(ksi
, var
, v_autoup
);
1038 SAVE_INT32(ksi
, var
, v_bufhwm
);
1042 save_ncstats(kstat_t
*kp
, ks_instance_t
*ksi
)
1044 struct ncstats
*ncstats
= (struct ncstats
*)(kp
->ks_data
);
1046 assert(kp
->ks_data_size
== sizeof (struct ncstats
));
1048 SAVE_INT32(ksi
, ncstats
, hits
);
1049 SAVE_INT32(ksi
, ncstats
, misses
);
1050 SAVE_INT32(ksi
, ncstats
, enters
);
1051 SAVE_INT32(ksi
, ncstats
, dbl_enters
);
1052 SAVE_INT32(ksi
, ncstats
, long_enter
);
1053 SAVE_INT32(ksi
, ncstats
, long_look
);
1054 SAVE_INT32(ksi
, ncstats
, move_to_front
);
1055 SAVE_INT32(ksi
, ncstats
, purges
);
1059 save_sysinfo(kstat_t
*kp
, ks_instance_t
*ksi
)
1061 sysinfo_t
*sysinfo
= (sysinfo_t
*)(kp
->ks_data
);
1063 assert(kp
->ks_data_size
== sizeof (sysinfo_t
));
1065 SAVE_UINT32(ksi
, sysinfo
, updates
);
1066 SAVE_UINT32(ksi
, sysinfo
, runque
);
1067 SAVE_UINT32(ksi
, sysinfo
, runocc
);
1068 SAVE_UINT32(ksi
, sysinfo
, swpque
);
1069 SAVE_UINT32(ksi
, sysinfo
, swpocc
);
1070 SAVE_UINT32(ksi
, sysinfo
, waiting
);
1074 save_vminfo(kstat_t
*kp
, ks_instance_t
*ksi
)
1076 vminfo_t
*vminfo
= (vminfo_t
*)(kp
->ks_data
);
1078 assert(kp
->ks_data_size
== sizeof (vminfo_t
));
1080 SAVE_UINT64(ksi
, vminfo
, freemem
);
1081 SAVE_UINT64(ksi
, vminfo
, swap_resv
);
1082 SAVE_UINT64(ksi
, vminfo
, swap_alloc
);
1083 SAVE_UINT64(ksi
, vminfo
, swap_avail
);
1084 SAVE_UINT64(ksi
, vminfo
, swap_free
);
1085 SAVE_UINT64(ksi
, vminfo
, updates
);
1089 save_nfs(kstat_t
*kp
, ks_instance_t
*ksi
)
1091 struct mntinfo_kstat
*mntinfo
= (struct mntinfo_kstat
*)(kp
->ks_data
);
1093 assert(kp
->ks_data_size
== sizeof (struct mntinfo_kstat
));
1095 SAVE_STRING(ksi
, mntinfo
, mik_proto
);
1096 SAVE_UINT32(ksi
, mntinfo
, mik_vers
);
1097 SAVE_UINT32(ksi
, mntinfo
, mik_flags
);
1098 SAVE_UINT32(ksi
, mntinfo
, mik_secmod
);
1099 SAVE_UINT32(ksi
, mntinfo
, mik_curread
);
1100 SAVE_UINT32(ksi
, mntinfo
, mik_curwrite
);
1101 SAVE_INT32(ksi
, mntinfo
, mik_timeo
);
1102 SAVE_INT32(ksi
, mntinfo
, mik_retrans
);
1103 SAVE_UINT32(ksi
, mntinfo
, mik_acregmin
);
1104 SAVE_UINT32(ksi
, mntinfo
, mik_acregmax
);
1105 SAVE_UINT32(ksi
, mntinfo
, mik_acdirmin
);
1106 SAVE_UINT32(ksi
, mntinfo
, mik_acdirmax
);
1107 SAVE_UINT32_X(ksi
, "lookup_srtt", mntinfo
->mik_timers
[0].srtt
);
1108 SAVE_UINT32_X(ksi
, "lookup_deviate", mntinfo
->mik_timers
[0].deviate
);
1109 SAVE_UINT32_X(ksi
, "lookup_rtxcur", mntinfo
->mik_timers
[0].rtxcur
);
1110 SAVE_UINT32_X(ksi
, "read_srtt", mntinfo
->mik_timers
[1].srtt
);
1111 SAVE_UINT32_X(ksi
, "read_deviate", mntinfo
->mik_timers
[1].deviate
);
1112 SAVE_UINT32_X(ksi
, "read_rtxcur", mntinfo
->mik_timers
[1].rtxcur
);
1113 SAVE_UINT32_X(ksi
, "write_srtt", mntinfo
->mik_timers
[2].srtt
);
1114 SAVE_UINT32_X(ksi
, "write_deviate", mntinfo
->mik_timers
[2].deviate
);
1115 SAVE_UINT32_X(ksi
, "write_rtxcur", mntinfo
->mik_timers
[2].rtxcur
);
1116 SAVE_UINT32(ksi
, mntinfo
, mik_noresponse
);
1117 SAVE_UINT32(ksi
, mntinfo
, mik_failover
);
1118 SAVE_UINT32(ksi
, mntinfo
, mik_remap
);
1119 SAVE_STRING(ksi
, mntinfo
, mik_curserver
);
1124 save_sfmmu_global_stat(kstat_t
*kp
, ks_instance_t
*ksi
)
1126 struct sfmmu_global_stat
*sfmmug
=
1127 (struct sfmmu_global_stat
*)(kp
->ks_data
);
1129 assert(kp
->ks_data_size
== sizeof (struct sfmmu_global_stat
));
1131 SAVE_INT32(ksi
, sfmmug
, sf_tsb_exceptions
);
1132 SAVE_INT32(ksi
, sfmmug
, sf_tsb_raise_exception
);
1133 SAVE_INT32(ksi
, sfmmug
, sf_pagefaults
);
1134 SAVE_INT32(ksi
, sfmmug
, sf_uhash_searches
);
1135 SAVE_INT32(ksi
, sfmmug
, sf_uhash_links
);
1136 SAVE_INT32(ksi
, sfmmug
, sf_khash_searches
);
1137 SAVE_INT32(ksi
, sfmmug
, sf_khash_links
);
1138 SAVE_INT32(ksi
, sfmmug
, sf_swapout
);
1139 SAVE_INT32(ksi
, sfmmug
, sf_tsb_alloc
);
1140 SAVE_INT32(ksi
, sfmmug
, sf_tsb_allocfail
);
1141 SAVE_INT32(ksi
, sfmmug
, sf_tsb_sectsb_create
);
1142 SAVE_INT32(ksi
, sfmmug
, sf_scd_1sttsb_alloc
);
1143 SAVE_INT32(ksi
, sfmmug
, sf_scd_2ndtsb_alloc
);
1144 SAVE_INT32(ksi
, sfmmug
, sf_scd_1sttsb_allocfail
);
1145 SAVE_INT32(ksi
, sfmmug
, sf_scd_2ndtsb_allocfail
);
1146 SAVE_INT32(ksi
, sfmmug
, sf_tteload8k
);
1147 SAVE_INT32(ksi
, sfmmug
, sf_tteload64k
);
1148 SAVE_INT32(ksi
, sfmmug
, sf_tteload512k
);
1149 SAVE_INT32(ksi
, sfmmug
, sf_tteload4m
);
1150 SAVE_INT32(ksi
, sfmmug
, sf_tteload32m
);
1151 SAVE_INT32(ksi
, sfmmug
, sf_tteload256m
);
1152 SAVE_INT32(ksi
, sfmmug
, sf_tsb_load8k
);
1153 SAVE_INT32(ksi
, sfmmug
, sf_tsb_load4m
);
1154 SAVE_INT32(ksi
, sfmmug
, sf_hblk_hit
);
1155 SAVE_INT32(ksi
, sfmmug
, sf_hblk8_ncreate
);
1156 SAVE_INT32(ksi
, sfmmug
, sf_hblk8_nalloc
);
1157 SAVE_INT32(ksi
, sfmmug
, sf_hblk1_ncreate
);
1158 SAVE_INT32(ksi
, sfmmug
, sf_hblk1_nalloc
);
1159 SAVE_INT32(ksi
, sfmmug
, sf_hblk_slab_cnt
);
1160 SAVE_INT32(ksi
, sfmmug
, sf_hblk_reserve_cnt
);
1161 SAVE_INT32(ksi
, sfmmug
, sf_hblk_recurse_cnt
);
1162 SAVE_INT32(ksi
, sfmmug
, sf_hblk_reserve_hit
);
1163 SAVE_INT32(ksi
, sfmmug
, sf_get_free_success
);
1164 SAVE_INT32(ksi
, sfmmug
, sf_get_free_throttle
);
1165 SAVE_INT32(ksi
, sfmmug
, sf_get_free_fail
);
1166 SAVE_INT32(ksi
, sfmmug
, sf_put_free_success
);
1167 SAVE_INT32(ksi
, sfmmug
, sf_put_free_fail
);
1168 SAVE_INT32(ksi
, sfmmug
, sf_pgcolor_conflict
);
1169 SAVE_INT32(ksi
, sfmmug
, sf_uncache_conflict
);
1170 SAVE_INT32(ksi
, sfmmug
, sf_unload_conflict
);
1171 SAVE_INT32(ksi
, sfmmug
, sf_ism_uncache
);
1172 SAVE_INT32(ksi
, sfmmug
, sf_ism_recache
);
1173 SAVE_INT32(ksi
, sfmmug
, sf_recache
);
1174 SAVE_INT32(ksi
, sfmmug
, sf_steal_count
);
1175 SAVE_INT32(ksi
, sfmmug
, sf_pagesync
);
1176 SAVE_INT32(ksi
, sfmmug
, sf_clrwrt
);
1177 SAVE_INT32(ksi
, sfmmug
, sf_pagesync_invalid
);
1178 SAVE_INT32(ksi
, sfmmug
, sf_kernel_xcalls
);
1179 SAVE_INT32(ksi
, sfmmug
, sf_user_xcalls
);
1180 SAVE_INT32(ksi
, sfmmug
, sf_tsb_grow
);
1181 SAVE_INT32(ksi
, sfmmug
, sf_tsb_shrink
);
1182 SAVE_INT32(ksi
, sfmmug
, sf_tsb_resize_failures
);
1183 SAVE_INT32(ksi
, sfmmug
, sf_tsb_reloc
);
1184 SAVE_INT32(ksi
, sfmmug
, sf_user_vtop
);
1185 SAVE_INT32(ksi
, sfmmug
, sf_ctx_inv
);
1186 SAVE_INT32(ksi
, sfmmug
, sf_tlb_reprog_pgsz
);
1187 SAVE_INT32(ksi
, sfmmug
, sf_region_remap_demap
);
1188 SAVE_INT32(ksi
, sfmmug
, sf_create_scd
);
1189 SAVE_INT32(ksi
, sfmmug
, sf_join_scd
);
1190 SAVE_INT32(ksi
, sfmmug
, sf_leave_scd
);
1191 SAVE_INT32(ksi
, sfmmug
, sf_destroy_scd
);
1197 save_sfmmu_tsbsize_stat(kstat_t
*kp
, ks_instance_t
*ksi
)
1199 struct sfmmu_tsbsize_stat
*sfmmut
;
1201 assert(kp
->ks_data_size
== sizeof (struct sfmmu_tsbsize_stat
));
1202 sfmmut
= (struct sfmmu_tsbsize_stat
*)(kp
->ks_data
);
1204 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_8k
);
1205 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_16k
);
1206 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_32k
);
1207 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_64k
);
1208 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_128k
);
1209 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_256k
);
1210 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_512k
);
1211 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_1m
);
1212 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_2m
);
1213 SAVE_INT32(ksi
, sfmmut
, sf_tsbsz_4m
);
1219 save_simmstat(kstat_t
*kp
, ks_instance_t
*ksi
)
1226 assert(kp
->ks_data_size
== sizeof (uchar_t
) * SIMM_COUNT
);
1228 for (i
= 0, simmstat
= (uchar_t
*)(kp
->ks_data
); i
< SIMM_COUNT
- 1;
1231 (void) asprintf(&simm_buf
, "%d,", *simmstat
);
1233 (void) asprintf(&simm_buf
, "%s%d,", list
, *simmstat
);
1239 (void) asprintf(&simm_buf
, "%s%d", list
, *simmstat
);
1240 SAVE_STRING_X(ksi
, "status", simm_buf
);
1248 * Helper function for save_temperature().
1251 short_array_to_string(short *shortp
, int len
)
1256 for (; len
> 1; len
--, shortp
++) {
1258 (void) asprintf(&list_buf
, "%hd,", *shortp
);
1260 (void) asprintf(&list_buf
, "%s%hd,", list
, *shortp
);
1266 (void) asprintf(&list_buf
, "%s%hd", list
, *shortp
);
1272 save_temperature(kstat_t
*kp
, ks_instance_t
*ksi
)
1274 struct temp_stats
*temps
= (struct temp_stats
*)(kp
->ks_data
);
1277 assert(kp
->ks_data_size
== sizeof (struct temp_stats
));
1279 SAVE_UINT32(ksi
, temps
, index
);
1281 buf
= short_array_to_string(temps
->l1
, L1_SZ
);
1282 SAVE_STRING_X(ksi
, "l1", buf
);
1285 buf
= short_array_to_string(temps
->l2
, L2_SZ
);
1286 SAVE_STRING_X(ksi
, "l2", buf
);
1289 buf
= short_array_to_string(temps
->l3
, L3_SZ
);
1290 SAVE_STRING_X(ksi
, "l3", buf
);
1293 buf
= short_array_to_string(temps
->l4
, L4_SZ
);
1294 SAVE_STRING_X(ksi
, "l4", buf
);
1297 buf
= short_array_to_string(temps
->l5
, L5_SZ
);
1298 SAVE_STRING_X(ksi
, "l5", buf
);
1301 SAVE_INT32(ksi
, temps
, max
);
1302 SAVE_INT32(ksi
, temps
, min
);
1303 SAVE_INT32(ksi
, temps
, state
);
1304 SAVE_INT32(ksi
, temps
, temp_cnt
);
1305 SAVE_INT32(ksi
, temps
, shutdown_cnt
);
1306 SAVE_INT32(ksi
, temps
, version
);
1307 SAVE_INT32(ksi
, temps
, trend
);
1308 SAVE_INT32(ksi
, temps
, override
);
1314 save_temp_over(kstat_t
*kp
, ks_instance_t
*ksi
)
1316 short *sh
= (short *)(kp
->ks_data
);
1319 assert(kp
->ks_data_size
== sizeof (short));
1321 (void) asprintf(&value
, "%hu", *sh
);
1322 SAVE_STRING_X(ksi
, "override", value
);
1329 save_ps_shadow(kstat_t
*kp
, ks_instance_t
*ksi
)
1331 uchar_t
*uchar
= (uchar_t
*)(kp
->ks_data
);
1333 assert(kp
->ks_data_size
== SYS_PS_COUNT
);
1335 SAVE_CHAR_X(ksi
, "core_0", *uchar
++);
1336 SAVE_CHAR_X(ksi
, "core_1", *uchar
++);
1337 SAVE_CHAR_X(ksi
, "core_2", *uchar
++);
1338 SAVE_CHAR_X(ksi
, "core_3", *uchar
++);
1339 SAVE_CHAR_X(ksi
, "core_4", *uchar
++);
1340 SAVE_CHAR_X(ksi
, "core_5", *uchar
++);
1341 SAVE_CHAR_X(ksi
, "core_6", *uchar
++);
1342 SAVE_CHAR_X(ksi
, "core_7", *uchar
++);
1343 SAVE_CHAR_X(ksi
, "pps_0", *uchar
++);
1344 SAVE_CHAR_X(ksi
, "clk_33", *uchar
++);
1345 SAVE_CHAR_X(ksi
, "clk_50", *uchar
++);
1346 SAVE_CHAR_X(ksi
, "v5_p", *uchar
++);
1347 SAVE_CHAR_X(ksi
, "v12_p", *uchar
++);
1348 SAVE_CHAR_X(ksi
, "v5_aux", *uchar
++);
1349 SAVE_CHAR_X(ksi
, "v5_p_pch", *uchar
++);
1350 SAVE_CHAR_X(ksi
, "v12_p_pch", *uchar
++);
1351 SAVE_CHAR_X(ksi
, "v3_pch", *uchar
++);
1352 SAVE_CHAR_X(ksi
, "v5_pch", *uchar
++);
1353 SAVE_CHAR_X(ksi
, "p_fan", *uchar
++);
1359 save_fault_list(kstat_t
*kp
, ks_instance_t
*ksi
)
1361 struct ft_list
*fault
;
1362 char name
[KSTAT_STRLEN
+ 7];
1365 for (i
= 1, fault
= (struct ft_list
*)(kp
->ks_data
);
1366 i
<= 999999 && i
<= kp
->ks_data_size
/ sizeof (struct ft_list
);
1368 (void) snprintf(name
, sizeof (name
), "unit_%d", i
);
1369 SAVE_INT32_X(ksi
, name
, fault
->unit
);
1370 (void) snprintf(name
, sizeof (name
), "type_%d", i
);
1371 SAVE_INT32_X(ksi
, name
, fault
->type
);
1372 (void) snprintf(name
, sizeof (name
), "fclass_%d", i
);
1373 SAVE_INT32_X(ksi
, name
, fault
->fclass
);
1374 (void) snprintf(name
, sizeof (name
), "create_time_%d", i
);
1375 SAVE_HRTIME_X(ksi
, name
, fault
->create_time
);
1376 (void) snprintf(name
, sizeof (name
), "msg_%d", i
);
1377 SAVE_STRING_X(ksi
, name
, fault
->msg
);
1383 save_named(kstat_t
*kp
, ks_instance_t
*ksi
)
1388 for (n
= kp
->ks_ndata
, knp
= KSTAT_NAMED_PTR(kp
); n
> 0; n
--, knp
++) {
1389 switch (knp
->data_type
) {
1390 case KSTAT_DATA_CHAR
:
1391 nvpair_insert(ksi
, knp
->name
,
1392 (ks_value_t
*)&knp
->value
, KSTAT_DATA_CHAR
);
1394 case KSTAT_DATA_INT32
:
1395 nvpair_insert(ksi
, knp
->name
,
1396 (ks_value_t
*)&knp
->value
, KSTAT_DATA_INT32
);
1398 case KSTAT_DATA_UINT32
:
1399 nvpair_insert(ksi
, knp
->name
,
1400 (ks_value_t
*)&knp
->value
, KSTAT_DATA_UINT32
);
1402 case KSTAT_DATA_INT64
:
1403 nvpair_insert(ksi
, knp
->name
,
1404 (ks_value_t
*)&knp
->value
, KSTAT_DATA_INT64
);
1406 case KSTAT_DATA_UINT64
:
1407 nvpair_insert(ksi
, knp
->name
,
1408 (ks_value_t
*)&knp
->value
, KSTAT_DATA_UINT64
);
1410 case KSTAT_DATA_STRING
:
1411 SAVE_STRING_X(ksi
, knp
->name
, KSTAT_NAMED_STR_PTR(knp
));
1414 assert(B_FALSE
); /* Invalid data type */
1421 save_intr(kstat_t
*kp
, ks_instance_t
*ksi
)
1423 kstat_intr_t
*intr
= KSTAT_INTR_PTR(kp
);
1424 char *intr_names
[] = {"hard", "soft", "watchdog", "spurious",
1425 "multiple_service"};
1428 for (n
= 0; n
< KSTAT_NUM_INTRS
; n
++)
1429 SAVE_UINT32_X(ksi
, intr_names
[n
], intr
->intrs
[n
]);
1433 save_io(kstat_t
*kp
, ks_instance_t
*ksi
)
1435 kstat_io_t
*ksio
= KSTAT_IO_PTR(kp
);
1437 SAVE_UINT64(ksi
, ksio
, nread
);
1438 SAVE_UINT64(ksi
, ksio
, nwritten
);
1439 SAVE_UINT32(ksi
, ksio
, reads
);
1440 SAVE_UINT32(ksi
, ksio
, writes
);
1441 SAVE_HRTIME(ksi
, ksio
, wtime
);
1442 SAVE_HRTIME(ksi
, ksio
, wlentime
);
1443 SAVE_HRTIME(ksi
, ksio
, wlastupdate
);
1444 SAVE_HRTIME(ksi
, ksio
, rtime
);
1445 SAVE_HRTIME(ksi
, ksio
, rlentime
);
1446 SAVE_HRTIME(ksi
, ksio
, rlastupdate
);
1447 SAVE_UINT32(ksi
, ksio
, wcnt
);
1448 SAVE_UINT32(ksi
, ksio
, rcnt
);
1452 save_timer(kstat_t
*kp
, ks_instance_t
*ksi
)
1454 kstat_timer_t
*ktimer
= KSTAT_TIMER_PTR(kp
);
1456 SAVE_STRING(ksi
, ktimer
, name
);
1457 SAVE_UINT64(ksi
, ktimer
, num_events
);
1458 SAVE_HRTIME(ksi
, ktimer
, elapsed_time
);
1459 SAVE_HRTIME(ksi
, ktimer
, min_time
);
1460 SAVE_HRTIME(ksi
, ktimer
, max_time
);
1461 SAVE_HRTIME(ksi
, ktimer
, start_time
);
1462 SAVE_HRTIME(ksi
, ktimer
, stop_time
);