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 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 *
26 * rewritten from UCB 4.13 83/09/25
27 * rewritten from SunOS 4.1 SID 1.18 89/10/06
28 */
29 /*
30 * Copyright (c) 2012 by Delphix. All rights reserved.
31 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
32 * Copyright 2016 James S. Blachly, MD. All rights reserved.
33 */
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <stdarg.h>
38 #include <ctype.h>
39 #include <unistd.h>
40 #include <memory.h>
41 #include <errno.h>
42 #include <string.h>
43 #include <signal.h>
44 #include <sys/types.h>
45 #include <time.h>
46 #include <sys/time.h>
47 #include <sys/sysinfo.h>
48 #include <inttypes.h>
49 #include <strings.h>
50 #include <sys/systeminfo.h>
51 #include <kstat.h>
52 #include <locale.h>
53
54 #include "dsr.h"
55 #include "statcommon.h"
56
57 #define DISK_OLD 0x0001
58 #define DISK_NEW 0x0002
59 #define DISK_EXTENDED 0x0004
60 #define DISK_ERRORS 0x0008
61 #define DISK_EXTENDED_ERRORS 0x0010
62 #define DISK_IOPATH_LI 0x0020 /* LunInitiator */
63 #define DISK_IOPATH_LTI 0x0040 /* LunTargetInitiator */
64
65 #define DISK_NORMAL (DISK_OLD | DISK_NEW)
66 #define DISK_IO_MASK (DISK_OLD | DISK_NEW | DISK_EXTENDED)
67 #define DISK_ERROR_MASK (DISK_ERRORS | DISK_EXTENDED_ERRORS)
68 #define PRINT_VERTICAL (DISK_ERROR_MASK | DISK_EXTENDED)
69
70 #define REPRINT 19
71
72 #define NUMBER_OF_ERR_COUNTERS 3
73
74 /*
75 * It's really a pseudo-gigabyte. We use 1000000000 bytes so that the disk
76 * labels don't look bad. 1GB is really 1073741824 bytes.
77 */
78 #define DISK_GIGABYTE 1000000000.0
79
80 /*
81 * Function desciptor to be called when extended
82 * headers are used.
83 */
84 typedef struct formatter {
85 void (*nfunc)(void);
86 struct formatter *next;
87 } format_t;
88
89 /*
90 * Used to get formatting right when printing tty/cpu
91 * data to the right of disk data
92 */
93 enum show_disk_mode {
94 SHOW_FIRST_ONLY,
95 SHOW_SECOND_ONWARDS,
96 SHOW_ALL
97 };
98
99 enum show_disk_mode show_disk_mode = SHOW_ALL;
100
101 char *cmdname = "iostat";
102 int caught_cont = 0;
103
104 static char one_blank[] = " ";
105 static char two_blanks[] = " ";
106
107 /*
108 * count for number of lines to be emitted before a header is
109 * shown again. Only used for the basic format.
110 */
111 static uint_t tohdr = 1;
112
113 /*
114 * If we're in raw format, have we printed a header? We only do it
115 * once for raw but we emit it every REPRINT lines in non-raw format.
116 * This applies only for the basic header. The extended header is
117 * done only once in both formats.
118 */
119 static uint_t hdr_out;
120
121 /*
122 * Flags representing arguments from command line
123 */
124 static uint_t do_tty; /* show tty info (-t) */
125 static uint_t do_disk; /* show disk info per selected */
126 /* format (-d, -D, -e, -E, -x -X -Y) */
127 static uint_t do_cpu; /* show cpu info (-c) */
128 static uint_t do_interval; /* do intervals (-I) */
129 static int do_partitions; /* per-partition stats (-p) */
130 static int do_partitions_only; /* per-partition stats only (-P) */
131 /* no per-device stats for disks */
132 static uint_t do_conversions; /* display disks as cXtYdZ (-n) */
133 static uint_t do_megabytes; /* display data in MB/sec (-M) */
134 static uint_t do_controller; /* display controller info (-C) */
135 static uint_t do_raw; /* emit raw format (-r) */
136 static uint_t timestamp_fmt = NODATE; /* timestamp each display (-T) */
137 static uint_t do_devid; /* -E should show devid */
138
139 /*
140 * Default number of disk drives to be displayed in basic format
141 */
142 #define DEFAULT_LIMIT 4
143
144 struct iodev_filter df;
145
146 static uint_t suppress_state; /* skip state change messages */
147 static uint_t suppress_zero; /* skip zero valued lines */
148 static uint_t show_mountpts; /* show mount points */
149 static int interval; /* interval (seconds) to output */
150 static int iter; /* iterations from command line */
151
152 #define SMALL_SCRATCH_BUFLEN MAXNAMELEN
153
154 static int iodevs_nl; /* name field width */
155 #define IODEVS_NL_MIN 6 /* not too thin for "device" */
156 #define IODEVS_NL_MAX 24 /* but keep full width under 80 */
157
158 static char disk_header[132];
159 static uint_t dh_len; /* disk header length for centering */
160 static int lineout; /* data waiting to be printed? */
161
162 static struct snapshot *newss;
163 static struct snapshot *oldss;
164 static double getime; /* elapsed time */
165 static double percent; /* 100 / etime */
166
167 /*
168 * List of functions to be called which will construct the desired output
169 */
170 static format_t *formatter_list;
171 static format_t *formatter_end;
172
173 static u_longlong_t ull_delta(u_longlong_t, u_longlong_t);
174 static uint_t u32_delta(uint_t, uint_t);
175 static void setup(void (*nfunc)(void));
176 static void print_tty_hdr1(void);
177 static void print_tty_hdr2(void);
178 static void print_cpu_hdr1(void);
179 static void print_cpu_hdr2(void);
180 static void print_tty_data(void);
181 static void print_cpu_data(void);
182 static void print_err_hdr(void);
183 static void print_disk_header(void);
184 static void hdrout(void);
185 static void disk_errors(void);
186 static void do_newline(void);
187 static void push_out(const char *, ...);
188 static void printhdr(int);
189 static void printxhdr(void);
190 static void usage(void);
191 static void do_args(int, char **);
192 static void do_format(void);
193 static void show_all_disks(void);
194 static void show_first_disk(void);
195 static void show_other_disks(void);
196 static void show_disk_errors(void *, void *, void *);
197 static void write_core_header(void);
198 static int fzero(double value);
199 static int safe_strtoi(char const *val, char *errmsg);
200
201 int
main(int argc,char ** argv)202 main(int argc, char **argv)
203 {
204 enum snapshot_types types = SNAP_SYSTEM;
205 kstat_ctl_t *kc;
206 long hz;
207 int forever;
208 hrtime_t start_n;
209 hrtime_t period_n = 0;
210
211 (void) setlocale(LC_ALL, "");
212 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
213 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
214 #endif
215 (void) textdomain(TEXT_DOMAIN);
216
217 do_args(argc, argv);
218
219 /*
220 * iostat historically showed CPU changes, even though
221 * it doesn't provide much useful information
222 */
223 types |= SNAP_CPUS;
224
225 if (do_disk)
226 types |= SNAP_IODEVS;
227
228 if (do_disk && !do_partitions_only)
229 df.if_allowed_types |= IODEV_DISK;
230 if (do_disk & DISK_IOPATH_LI) {
231 df.if_allowed_types |= IODEV_IOPATH_LTI;
232 types |= SNAP_IOPATHS_LI;
233 }
234 if (do_disk & DISK_IOPATH_LTI) {
235 df.if_allowed_types |= IODEV_IOPATH_LTI;
236 types |= SNAP_IOPATHS_LTI;
237 }
238 if (do_disk & DISK_ERROR_MASK)
239 types |= SNAP_IODEV_ERRORS;
240 if (do_partitions || do_partitions_only)
241 df.if_allowed_types |= IODEV_PARTITION;
242 if (do_conversions)
243 types |= SNAP_IODEV_PRETTY;
244 if (do_devid)
245 types |= SNAP_IODEV_DEVID;
246 if (do_controller) {
247 if (!(do_disk & PRINT_VERTICAL) ||
248 (do_disk & DISK_EXTENDED_ERRORS))
249 fail(0, "-C can only be used with -e or -x.");
250 types |= SNAP_CONTROLLERS;
251 df.if_allowed_types |= IODEV_CONTROLLER;
252 }
253
254 hz = sysconf(_SC_CLK_TCK);
255
256 /*
257 * Undocumented behavior - sending a SIGCONT will result
258 * in a new header being emitted. Used only if we're not
259 * doing extended headers. This is a historical
260 * artifact.
261 */
262 if (!(do_disk & PRINT_VERTICAL))
263 (void) signal(SIGCONT, printhdr);
264
265 if (interval)
266 period_n = (hrtime_t)interval * NANOSEC;
267
268 kc = open_kstat();
269 if (interval)
270 start_n = gethrtime();
271 newss = acquire_snapshot(kc, types, &df);
272
273 /* compute width of "device" field */
274 iodevs_nl = newss->s_iodevs_is_name_maxlen;
275 iodevs_nl = (iodevs_nl < IODEVS_NL_MIN) ?
276 IODEVS_NL_MIN : iodevs_nl;
277 iodevs_nl = (iodevs_nl > IODEVS_NL_MAX) ?
278 IODEVS_NL_MAX : iodevs_nl;
279
280 do_format();
281
282 forever = (iter == 0);
283 do {
284 if (do_conversions && show_mountpts)
285 do_mnttab();
286
287 if (do_tty || do_cpu) {
288 kstat_t *oldks;
289 oldks = oldss ? &oldss->s_sys.ss_agg_sys : NULL;
290 getime = cpu_ticks_delta(oldks,
291 &newss->s_sys.ss_agg_sys);
292 percent = (getime > 0.0) ? 100.0 / getime : 0.0;
293 getime = (getime / nr_active_cpus(newss)) / hz;
294 if (getime == 0.0)
295 getime = (double)interval;
296 if (getime == 0.0 || do_interval)
297 getime = 1.0;
298 }
299
300 if (formatter_list) {
301 format_t *tmp;
302 tmp = formatter_list;
303
304 if (timestamp_fmt != NODATE)
305 print_timestamp(timestamp_fmt);
306
307 while (tmp) {
308 (tmp->nfunc)();
309 tmp = tmp->next;
310 }
311 (void) fflush(stdout);
312 }
313
314 /* only remaining/doing a single iteration, we are done */
315 if (iter == 1)
316 continue;
317
318 if (interval > 0)
319 /* Have a kip */
320 sleep_until(&start_n, period_n, forever, &caught_cont);
321
322 free_snapshot(oldss);
323 oldss = newss;
324 newss = acquire_snapshot(kc, types, &df);
325 iodevs_nl = (newss->s_iodevs_is_name_maxlen > iodevs_nl) ?
326 newss->s_iodevs_is_name_maxlen : iodevs_nl;
327 iodevs_nl = (iodevs_nl < IODEVS_NL_MIN) ?
328 IODEVS_NL_MIN : iodevs_nl;
329 iodevs_nl = (iodevs_nl > IODEVS_NL_MAX) ?
330 IODEVS_NL_MAX : iodevs_nl;
331
332 if (!suppress_state)
333 snapshot_report_changes(oldss, newss);
334
335 /* if config changed, show stats from boot */
336 if (snapshot_has_changed(oldss, newss)) {
337 free_snapshot(oldss);
338 oldss = NULL;
339 }
340
341 } while (--iter);
342
343 free_snapshot(oldss);
344 free_snapshot(newss);
345 (void) kstat_close(kc);
346 free(df.if_names);
347 return (0);
348 }
349
350 /*
351 * Some magic numbers used in header formatting.
352 *
353 * DISK_LEN = length of either "kps tps serv" or "wps rps util"
354 * using 0 as the first position
355 *
356 * DISK_ERROR_LEN = length of "s/w h/w trn tot" with one space on
357 * either side. Does not use zero as first pos.
358 *
359 * DEVICE_LEN = length of "device" + 1 character.
360 */
361
362 #define DISK_LEN 11
363 #define DISK_ERROR_LEN 16
364 #define DEVICE_LEN 7
365
366 /*ARGSUSED*/
367 static void
show_disk_name(void * v1,void * v2,void * data)368 show_disk_name(void *v1, void *v2, void *data)
369 {
370 struct iodev_snapshot *dev = (struct iodev_snapshot *)v2;
371 size_t slen;
372 char *name;
373 char fbuf[SMALL_SCRATCH_BUFLEN];
374
375 if (dev == NULL)
376 return;
377
378 name = do_conversions ? dev->is_pretty : dev->is_name;
379 name = name ? name : dev->is_name;
380
381 if (!do_raw) {
382 uint_t width;
383
384 slen = strlen(name);
385 /*
386 * The length is less
387 * than the section
388 * which will be displayed
389 * on the next line.
390 * Center the entry.
391 */
392
393 width = (DISK_LEN + 1)/2 + (slen / 2);
394 (void) snprintf(fbuf, sizeof (fbuf),
395 "%*s", width, name);
396 name = fbuf;
397 push_out("%-13.13s ", name);
398 } else {
399 push_out(name);
400 }
401 }
402
403 /*ARGSUSED*/
404 static void
show_disk_header(void * v1,void * v2,void * data)405 show_disk_header(void *v1, void *v2, void *data)
406 {
407 push_out(disk_header);
408 }
409
410 /*
411 * Write out a two line header. What is written out depends on the flags
412 * selected but in the worst case consists of a tty header, a disk header
413 * providing information for 4 disks and a cpu header.
414 *
415 * The tty header consists of the word "tty" on the first line above the
416 * words "tin tout" on the next line. If present the tty portion consumes
417 * the first 10 characters of each line since "tin tout" is surrounded
418 * by single spaces.
419 *
420 * Each of the disk sections is a 14 character "block" in which the name of
421 * the disk is centered in the first 12 characters of the first line.
422 *
423 * The cpu section is an 11 character block with "cpu" centered over the
424 * section.
425 *
426 * The worst case should look as follows:
427 *
428 * 0---------1--------2---------3---------4---------5---------6---------7-------
429 * tty sd0 sd1 sd2 sd3 cpu
430 * tin tout kps tps serv kps tps serv kps tps serv kps tps serv us sy dt id
431 * NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NN NN NN NN
432 *
433 * When -D is specified, the disk header looks as follows (worst case):
434 *
435 * 0---------1--------2---------3---------4---------5---------6---------7-------
436 * tty sd0 sd1 sd2 sd3 cpu
437 * tin tout rps wps util rps wps util rps wps util rps wps util us sy dt id
438 * NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NN NN NN NN
439 */
440 static void
printhdr(int sig)441 printhdr(int sig)
442 {
443 /*
444 * If we're here because a signal fired, reenable the
445 * signal.
446 */
447 if (sig)
448 (void) signal(SIGCONT, printhdr);
449 if (sig == SIGCONT)
450 caught_cont = 1;
451 /*
452 * Horizontal mode headers
453 *
454 * First line
455 */
456 if (do_tty)
457 print_tty_hdr1();
458
459 if (do_disk & DISK_NORMAL) {
460 (void) snapshot_walk(SNAP_IODEVS, NULL, newss,
461 show_disk_name, NULL);
462 }
463
464 if (do_cpu)
465 print_cpu_hdr1();
466 do_newline();
467
468 /*
469 * Second line
470 */
471 if (do_tty)
472 print_tty_hdr2();
473
474 if (do_disk & DISK_NORMAL) {
475 (void) snapshot_walk(SNAP_IODEVS, NULL, newss,
476 show_disk_header, NULL);
477 }
478
479 if (do_cpu)
480 print_cpu_hdr2();
481 do_newline();
482
483 tohdr = REPRINT;
484 }
485
486 /*
487 * Write out the extended header centered over the core information.
488 */
489 static void
write_core_header(void)490 write_core_header(void)
491 {
492 char *edev = "extended device statistics";
493 uint_t lead_space_ct;
494 uint_t follow_space_ct;
495 size_t edevlen;
496
497 if (do_raw == 0) {
498 /*
499 * The things we do to look nice...
500 *
501 * Center the core output header. Make sure we have the
502 * right number of trailing spaces for follow-on headers
503 * (i.e., cpu and/or tty and/or errors).
504 */
505 edevlen = strlen(edev);
506 lead_space_ct = dh_len - edevlen;
507 lead_space_ct /= 2;
508 if (lead_space_ct > 0) {
509 follow_space_ct = dh_len - (lead_space_ct + edevlen);
510 if (do_disk & DISK_ERRORS)
511 follow_space_ct -= DISK_ERROR_LEN;
512 if ((do_disk & DISK_EXTENDED) && do_conversions)
513 follow_space_ct -= DEVICE_LEN;
514
515 push_out("%1$*2$.*2$s%3$s%4$*5$.*5$s", one_blank,
516 lead_space_ct, edev, one_blank, follow_space_ct);
517 } else
518 push_out("%56s", edev);
519 } else
520 push_out(edev);
521 }
522
523 /*
524 * In extended mode headers, we don't want to reprint the header on
525 * signals as they are printed every time anyways.
526 */
527 static void
printxhdr(void)528 printxhdr(void)
529 {
530
531 /*
532 * Vertical mode headers
533 */
534 if (do_disk & DISK_EXTENDED)
535 setup(write_core_header);
536 if (do_disk & DISK_ERRORS)
537 setup(print_err_hdr);
538
539 if (do_conversions) {
540 setup(do_newline);
541 if (do_disk & (DISK_EXTENDED | DISK_ERRORS))
542 setup(print_disk_header);
543 setup(do_newline);
544 } else {
545 if (do_tty)
546 setup(print_tty_hdr1);
547 if (do_cpu)
548 setup(print_cpu_hdr1);
549 setup(do_newline);
550
551 if (do_disk & (DISK_EXTENDED | DISK_ERRORS))
552 setup(print_disk_header);
553 if (do_tty)
554 setup(print_tty_hdr2);
555 if (do_cpu)
556 setup(print_cpu_hdr2);
557 setup(do_newline);
558 }
559 }
560
561 /*
562 * Write out a line for this disk - note that show_disk writes out
563 * full lines or blocks for each selected disk.
564 */
565 static void
show_disk(void * v1,void * v2,void * data)566 show_disk(void *v1, void *v2, void *data)
567 {
568 uint32_t err_counters[NUMBER_OF_ERR_COUNTERS];
569 boolean_t display_err_counters = do_disk & DISK_ERRORS;
570 struct iodev_snapshot *old = (struct iodev_snapshot *)v1;
571 struct iodev_snapshot *new = (struct iodev_snapshot *)v2;
572 int *count = (int *)data;
573 double rps = 0, wps = 0, tps = 0, mtps, krps = 0, kwps = 0;
574 double kps = 0, avw = 0, avr = 0, w_pct = 0, r_pct = 0;
575 double wserv = 0, rserv = 0, serv = 0;
576 double iosize; /* kb/sec or MB/sec */
577 double etime, hr_etime;
578 char *disk_name;
579 u_longlong_t ldeltas;
580 uint_t udeltas;
581 uint64_t t_delta;
582 uint64_t w_delta;
583 uint64_t r_delta;
584 int doit = 1;
585 uint_t toterrs;
586 char *fstr;
587
588 if (new == NULL)
589 return;
590
591 switch (show_disk_mode) {
592 case SHOW_FIRST_ONLY:
593 if (count != NULL && *count)
594 return;
595 break;
596
597 case SHOW_SECOND_ONWARDS:
598 if (count != NULL && !*count) {
599 (*count)++;
600 return;
601 }
602 break;
603
604 default:
605 break;
606 }
607
608 disk_name = do_conversions ? new->is_pretty : new->is_name;
609 disk_name = disk_name ? disk_name : new->is_name;
610
611 /*
612 * Only do if we want IO stats - Avoids errors traveling this
613 * section if that's all we want to see.
614 */
615 if (do_disk & DISK_IO_MASK) {
616 if (old) {
617 t_delta = hrtime_delta(old->is_snaptime,
618 new->is_snaptime);
619 } else {
620 t_delta = hrtime_delta(new->is_crtime,
621 new->is_snaptime);
622 }
623
624 if (new->is_nr_children) {
625 if (new->is_type == IODEV_CONTROLLER) {
626 t_delta /= new->is_nr_children;
627 } else if ((new->is_type == IODEV_IOPATH_LT) ||
628 (new->is_type == IODEV_IOPATH_LI)) {
629 /* synthetic path */
630 if (!old) {
631 t_delta = new->is_crtime;
632 }
633 t_delta /= new->is_nr_children;
634 }
635 }
636
637 hr_etime = (double)t_delta;
638 if (hr_etime == 0.0)
639 hr_etime = (double)NANOSEC;
640 etime = hr_etime / (double)NANOSEC;
641
642 /* reads per second */
643 udeltas = u32_delta(old ? old->is_stats.reads : 0,
644 new->is_stats.reads);
645 rps = (double)udeltas;
646 rps /= etime;
647
648 /* writes per second */
649 udeltas = u32_delta(old ? old->is_stats.writes : 0,
650 new->is_stats.writes);
651 wps = (double)udeltas;
652 wps /= etime;
653
654 tps = rps + wps;
655 /* transactions per second */
656
657 /*
658 * report throughput as either kb/sec or MB/sec
659 */
660
661 if (!do_megabytes)
662 iosize = 1024.0;
663 else
664 iosize = 1048576.0;
665
666 ldeltas = ull_delta(old ? old->is_stats.nread : 0,
667 new->is_stats.nread);
668 if (ldeltas) {
669 krps = (double)ldeltas;
670 krps /= etime;
671 krps /= iosize;
672 } else
673 krps = 0.0;
674
675 ldeltas = ull_delta(old ? old->is_stats.nwritten : 0,
676 new->is_stats.nwritten);
677 if (ldeltas) {
678 kwps = (double)ldeltas;
679 kwps /= etime;
680 kwps /= iosize;
681 } else
682 kwps = 0.0;
683
684 /*
685 * Blocks transferred per second
686 */
687 kps = krps + kwps;
688
689 /*
690 * Average number of wait transactions waiting
691 */
692 w_delta = hrtime_delta((u_longlong_t)
693 (old ? old->is_stats.wlentime : 0),
694 new->is_stats.wlentime);
695 if (w_delta) {
696 avw = (double)w_delta;
697 avw /= hr_etime;
698 } else
699 avw = 0.0;
700
701 /*
702 * Average number of run transactions waiting
703 */
704 r_delta = hrtime_delta(old ? old->is_stats.rlentime : 0,
705 new->is_stats.rlentime);
706 if (r_delta) {
707 avr = (double)r_delta;
708 avr /= hr_etime;
709 } else
710 avr = 0.0;
711
712 /*
713 * Average wait service time in milliseconds
714 */
715 if (tps > 0.0 && (avw != 0.0 || avr != 0.0)) {
716 mtps = 1000.0 / tps;
717 if (avw != 0.0)
718 wserv = avw * mtps;
719 else
720 wserv = 0.0;
721
722 if (avr != 0.0)
723 rserv = avr * mtps;
724 else
725 rserv = 0.0;
726 serv = rserv + wserv;
727 } else {
728 rserv = 0.0;
729 wserv = 0.0;
730 serv = 0.0;
731 }
732
733 /* % of time there is a transaction waiting for service */
734 t_delta = hrtime_delta(old ? old->is_stats.wtime : 0,
735 new->is_stats.wtime);
736 if (t_delta) {
737 w_pct = (double)t_delta;
738 w_pct /= hr_etime;
739 w_pct *= 100.0;
740
741 /*
742 * Average the wait queue utilization over the
743 * the controller's devices, if this is a controller.
744 */
745 if (new->is_type == IODEV_CONTROLLER)
746 w_pct /= new->is_nr_children;
747 } else
748 w_pct = 0.0;
749
750 /* % of time there is a transaction running */
751 t_delta = hrtime_delta(old ? old->is_stats.rtime : 0,
752 new->is_stats.rtime);
753 if (t_delta) {
754 r_pct = (double)t_delta;
755 r_pct /= hr_etime;
756 r_pct *= 100.0;
757
758 /*
759 * Average the percent busy over the controller's
760 * devices, if this is a controller.
761 */
762 if (new->is_type == IODEV_CONTROLLER)
763 w_pct /= new->is_nr_children;
764 } else {
765 r_pct = 0.0;
766 }
767
768 /* % of time there is a transaction running */
769 if (do_interval) {
770 rps *= etime;
771 wps *= etime;
772 tps *= etime;
773 krps *= etime;
774 kwps *= etime;
775 kps *= etime;
776 }
777 }
778
779 if (do_disk & (DISK_EXTENDED | DISK_ERRORS)) {
780 if ((!do_conversions) && ((suppress_zero == 0) ||
781 ((do_disk & DISK_EXTENDED) == 0))) {
782 if (do_raw == 0) {
783 push_out("%-*.*s",
784 iodevs_nl, iodevs_nl, disk_name);
785 } else {
786 push_out(disk_name);
787 }
788 }
789 }
790
791 /*
792 * The error counters are read first (if asked for and if they are
793 * available).
794 */
795 bzero(err_counters, sizeof (err_counters));
796 toterrs = 0;
797 if (display_err_counters && (new->is_errors.ks_data != NULL)) {
798 kstat_named_t *knp;
799 int i;
800
801 knp = KSTAT_NAMED_PTR(&new->is_errors);
802 for (i = 0; i < NUMBER_OF_ERR_COUNTERS; i++) {
803 switch (knp[i].data_type) {
804 case KSTAT_DATA_ULONG:
805 case KSTAT_DATA_ULONGLONG:
806 err_counters[i] = knp[i].value.ui32;
807 toterrs += knp[i].value.ui32;
808 break;
809 default:
810 break;
811 }
812 }
813 }
814
815 switch (do_disk & DISK_IO_MASK) {
816 case DISK_OLD:
817 if (do_raw == 0)
818 fstr = "%3.0f %3.0f %4.0f ";
819 else
820 fstr = "%.0f,%.0f,%.0f";
821 push_out(fstr, kps, tps, serv);
822 break;
823 case DISK_NEW:
824 if (do_raw == 0)
825 fstr = "%3.0f %3.0f %4.1f ";
826 else
827 fstr = "%.0f,%.0f,%.1f";
828 push_out(fstr, rps, wps, r_pct);
829 break;
830 case DISK_EXTENDED:
831 if (suppress_zero) {
832 if (fzero(rps) && fzero(wps) && fzero(krps) &&
833 fzero(kwps) && fzero(avw) && fzero(avr) &&
834 fzero(serv) && fzero(w_pct) && fzero(r_pct) &&
835 (toterrs == 0)) {
836 doit = 0;
837 display_err_counters = B_FALSE;
838 } else if (do_conversions == 0) {
839 if (do_raw == 0) {
840 push_out("%-*.*s",
841 iodevs_nl, iodevs_nl, disk_name);
842 } else {
843 push_out(disk_name);
844 }
845 }
846 }
847 if (doit) {
848 if (!do_conversions) {
849 if (do_raw == 0) {
850 fstr = " %6.1f %6.1f %6.1f %6.1f "
851 "%4.1f %4.1f %6.1f %3.0f "
852 "%3.0f ";
853 } else {
854 fstr = "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,"
855 "%.1f,%.0f,%.0f";
856 }
857 push_out(fstr, rps, wps, krps, kwps, avw, avr,
858 serv, w_pct, r_pct);
859 } else {
860 if (do_raw == 0) {
861 fstr = " %6.1f %6.1f %6.1f %6.1f "
862 "%4.1f %4.1f %6.1f %6.1f "
863 "%3.0f %3.0f ";
864 } else {
865 fstr = "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,"
866 "%.1f,%.1f,%.0f,%.0f";
867 }
868 push_out(fstr, rps, wps, krps, kwps, avw, avr,
869 wserv, rserv, w_pct, r_pct);
870 }
871 }
872 break;
873 }
874
875 if (display_err_counters) {
876 char *efstr;
877 int i;
878
879 if (do_raw == 0) {
880 if (do_disk == DISK_ERRORS)
881 push_out(two_blanks);
882 efstr = "%3u ";
883 } else {
884 efstr = "%u";
885 }
886
887 for (i = 0; i < NUMBER_OF_ERR_COUNTERS; i++)
888 push_out(efstr, err_counters[i]);
889
890 push_out(efstr, toterrs);
891 }
892
893 if (suppress_zero == 0 || doit == 1) {
894 if ((do_disk & (DISK_EXTENDED | DISK_ERRORS)) &&
895 do_conversions) {
896 push_out("%s", disk_name);
897 if (show_mountpts && new->is_dname) {
898 mnt_t *mount_pt;
899 char *lu;
900 char *dnlu;
901 char lub[SMALL_SCRATCH_BUFLEN];
902
903 lu = strrchr(new->is_dname, '/');
904 if (lu) {
905 /* only the part after a possible '/' */
906 dnlu = strrchr(disk_name, '/');
907 if (dnlu != NULL &&
908 strcmp(dnlu, lu) == 0)
909 lu = new->is_dname;
910 else {
911 *lu = 0;
912 (void) strcpy(lub,
913 new->is_dname);
914 *lu = '/';
915 (void) strcat(lub, "/");
916 (void) strcat(lub,
917 disk_name);
918 lu = lub;
919 }
920 } else
921 lu = disk_name;
922 mount_pt = lookup_mntent_byname(lu);
923 if (mount_pt) {
924 if (do_raw == 0)
925 push_out(" (%s)",
926 mount_pt->mount_point);
927 else
928 push_out("(%s)",
929 mount_pt->mount_point);
930 }
931 }
932 }
933 }
934
935 if ((do_disk & PRINT_VERTICAL) && show_disk_mode != SHOW_FIRST_ONLY)
936 do_newline();
937
938 if (count != NULL)
939 (*count)++;
940 }
941
942 static void
usage(void)943 usage(void)
944 {
945 (void) fprintf(stderr,
946 "Usage: iostat [-cCdDeEiImMnpPrstxXYz] "
947 " [-l n] [-T d|u] [disk ...] [interval [count]]\n"
948 "\t\t-c: report percentage of time system has spent\n"
949 "\t\t\tin user/system/dtrace/idle mode\n"
950 "\t\t-C: report disk statistics by controller\n"
951 "\t\t-d: display disk Kb/sec, transfers/sec, avg. \n"
952 "\t\t\tservice time in milliseconds \n"
953 "\t\t-D: display disk reads/sec, writes/sec, \n"
954 "\t\t\tpercentage disk utilization \n"
955 "\t\t-e: report device error summary statistics\n"
956 "\t\t-E: report extended device error statistics\n"
957 "\t\t-i: show device IDs for -E output\n"
958 "\t\t-I: report the counts in each interval,\n"
959 "\t\t\tinstead of rates, where applicable\n"
960 "\t\t-l n: Limit the number of disks to n\n"
961 "\t\t-m: Display mount points (most useful with -p)\n"
962 "\t\t-M: Display data throughput in MB/sec "
963 "instead of Kb/sec\n"
964 "\t\t-n: convert device names to cXdYtZ format\n"
965 "\t\t-p: report per-partition disk statistics\n"
966 "\t\t-P: report per-partition disk statistics only,\n"
967 "\t\t\tno per-device disk statistics\n"
968 "\t\t-r: Display data in comma separated format\n"
969 "\t\t-s: Suppress state change messages\n"
970 "\t\t-T d|u Display a timestamp in date (d) or unix "
971 "time_t (u)\n"
972 "\t\t-t: display chars read/written to terminals\n"
973 "\t\t-x: display extended disk statistics\n"
974 "\t\t-X: display I/O path statistics\n"
975 "\t\t-Y: display I/O path (I/T/L) statistics\n"
976 "\t\t-z: Suppress entries with all zero values\n");
977 exit(1);
978 }
979
980 /*ARGSUSED*/
981 static void
show_disk_errors(void * v1,void * v2,void * d)982 show_disk_errors(void *v1, void *v2, void *d)
983 {
984 struct iodev_snapshot *disk = (struct iodev_snapshot *)v2;
985 kstat_named_t *knp;
986 size_t col;
987 int i, len;
988 char *dev_name;
989
990 if (disk->is_errors.ks_ndata == 0)
991 return;
992 if (disk->is_type == IODEV_CONTROLLER)
993 return;
994
995 dev_name = do_conversions ? disk->is_pretty : disk->is_name;
996 dev_name = dev_name ? dev_name : disk->is_name;
997
998 len = strlen(dev_name);
999 if (len > 20)
1000 push_out("%s ", dev_name);
1001 else if (len > 16)
1002 push_out("%-20.20s ", dev_name);
1003 else {
1004 if (do_conversions)
1005 push_out("%-16.16s ", dev_name);
1006 else
1007 push_out("%-9.9s ", dev_name);
1008 }
1009 col = 0;
1010
1011 knp = KSTAT_NAMED_PTR(&disk->is_errors);
1012 for (i = 0; i < disk->is_errors.ks_ndata; i++) {
1013 /* skip kstats that the driver did not kstat_named_init */
1014 if (knp[i].name[0] == 0)
1015 continue;
1016
1017 col += strlen(knp[i].name);
1018
1019 switch (knp[i].data_type) {
1020 case KSTAT_DATA_CHAR:
1021 case KSTAT_DATA_STRING:
1022 if ((strcmp(knp[i].name, "Serial No") == 0) &&
1023 do_devid) {
1024 if (disk->is_devid) {
1025 push_out("Device Id: %s ",
1026 disk->is_devid);
1027 col += strlen(disk->is_devid);
1028 } else {
1029 push_out("Device Id: ");
1030 }
1031
1032 break;
1033 }
1034 if (knp[i].data_type == KSTAT_DATA_CHAR) {
1035 push_out("%s: %-.16s ", knp[i].name,
1036 &knp[i].value.c[0]);
1037 col += strnlen(&knp[i].value.c[0], 16);
1038 } else {
1039 push_out("%s: %s ", knp[i].name,
1040 KSTAT_NAMED_STR_PTR(&knp[i]));
1041 col +=
1042 KSTAT_NAMED_STR_BUFLEN(&knp[i]) - 1;
1043 }
1044 break;
1045 case KSTAT_DATA_ULONG:
1046 push_out("%s: %u ", knp[i].name,
1047 knp[i].value.ui32);
1048 col += 4;
1049 break;
1050 case KSTAT_DATA_ULONGLONG:
1051 if (strcmp(knp[i].name, "Size") == 0) {
1052 do_newline();
1053 push_out("%s: %2.2fGB <%llu bytes>",
1054 knp[i].name,
1055 (float)knp[i].value.ui64 /
1056 DISK_GIGABYTE,
1057 knp[i].value.ui64);
1058 do_newline();
1059 col = 0;
1060 break;
1061 }
1062 push_out("%s: %u ", knp[i].name,
1063 knp[i].value.ui32);
1064 col += 4;
1065 break;
1066 }
1067 if ((col >= 62) || (i == 2)) {
1068 do_newline();
1069 col = 0;
1070 }
1071 }
1072 if (col > 0) {
1073 do_newline();
1074 }
1075 do_newline();
1076 }
1077
1078 void
do_args(int argc,char ** argv)1079 do_args(int argc, char **argv)
1080 {
1081 int c;
1082 int errflg = 0;
1083 extern char *optarg;
1084 extern int optind;
1085
1086 while ((c = getopt(argc, argv, "tdDxXYCciIpPnmMeEszrT:l:")) != EOF)
1087 switch (c) {
1088 case 't':
1089 do_tty++;
1090 break;
1091 case 'd':
1092 do_disk |= DISK_OLD;
1093 break;
1094 case 'D':
1095 do_disk |= DISK_NEW;
1096 break;
1097 case 'x':
1098 do_disk |= DISK_EXTENDED;
1099 break;
1100 case 'X':
1101 if (do_disk & DISK_IOPATH_LTI)
1102 errflg++; /* -Y already used */
1103 else
1104 do_disk |= DISK_IOPATH_LI;
1105 break;
1106 case 'Y':
1107 if (do_disk & DISK_IOPATH_LI)
1108 errflg++; /* -X already used */
1109 else
1110 do_disk |= DISK_IOPATH_LTI;
1111 break;
1112 case 'C':
1113 do_controller++;
1114 break;
1115 case 'c':
1116 do_cpu++;
1117 break;
1118 case 'I':
1119 do_interval++;
1120 break;
1121 case 'p':
1122 do_partitions++;
1123 break;
1124 case 'P':
1125 do_partitions_only++;
1126 break;
1127 case 'n':
1128 do_conversions++;
1129 break;
1130 case 'M':
1131 do_megabytes++;
1132 break;
1133 case 'e':
1134 do_disk |= DISK_ERRORS;
1135 break;
1136 case 'E':
1137 do_disk |= DISK_EXTENDED_ERRORS;
1138 break;
1139 case 'i':
1140 do_devid = 1;
1141 break;
1142 case 's':
1143 suppress_state = 1;
1144 break;
1145 case 'z':
1146 suppress_zero = 1;
1147 break;
1148 case 'm':
1149 show_mountpts = 1;
1150 break;
1151 case 'T':
1152 if (optarg) {
1153 if (*optarg == 'u')
1154 timestamp_fmt = UDATE;
1155 else if (*optarg == 'd')
1156 timestamp_fmt = DDATE;
1157 else
1158 errflg++;
1159 } else {
1160 errflg++;
1161 }
1162 break;
1163 case 'r':
1164 do_raw = 1;
1165 break;
1166 case 'l':
1167 df.if_max_iodevs = safe_strtoi(optarg, "invalid limit");
1168 if (df.if_max_iodevs < 1)
1169 usage();
1170 break;
1171 case '?':
1172 errflg++;
1173 }
1174
1175 if ((do_disk & DISK_OLD) && (do_disk & DISK_NEW)) {
1176 (void) fprintf(stderr, "-d and -D are incompatible.\n");
1177 usage();
1178 }
1179
1180 if (errflg) {
1181 usage();
1182 }
1183
1184 /* if no output classes explicity specified, use defaults */
1185 if (do_tty == 0 && do_disk == 0 && do_cpu == 0)
1186 do_tty = do_cpu = 1, do_disk = DISK_OLD;
1187
1188 /*
1189 * multi-path options (-X, -Y) without a specific vertical
1190 * output format (-x, -e, -E) imply extended -x format
1191 */
1192 if ((do_disk & (DISK_IOPATH_LI | DISK_IOPATH_LTI)) &&
1193 !(do_disk & PRINT_VERTICAL))
1194 do_disk |= DISK_EXTENDED;
1195
1196 /*
1197 * If conflicting options take the preferred
1198 * -D and -x result in -x
1199 * -d or -D and -e or -E gives only whatever -d or -D was specified
1200 */
1201 if ((do_disk & DISK_EXTENDED) && (do_disk & DISK_NORMAL))
1202 do_disk &= ~DISK_NORMAL;
1203 if ((do_disk & DISK_NORMAL) && (do_disk & DISK_ERROR_MASK))
1204 do_disk &= ~DISK_ERROR_MASK;
1205
1206 /* nfs, tape, always shown */
1207 df.if_allowed_types = IODEV_NFS | IODEV_TAPE;
1208
1209 /*
1210 * If limit == 0 then no command line limit was set, else if any of
1211 * the flags that cause unlimited disks were not set,
1212 * use the default of 4
1213 */
1214 if (df.if_max_iodevs == 0) {
1215 df.if_max_iodevs = DEFAULT_LIMIT;
1216 df.if_skip_floppy = 1;
1217 if (do_disk & (DISK_EXTENDED | DISK_ERRORS |
1218 DISK_EXTENDED_ERRORS)) {
1219 df.if_max_iodevs = UNLIMITED_IODEVS;
1220 df.if_skip_floppy = 0;
1221 }
1222 }
1223 if (do_disk) {
1224 size_t count = 0;
1225 size_t i = optind;
1226
1227 while (i < argc && !isdigit(argv[i][0])) {
1228 count++;
1229 i++;
1230 }
1231
1232 /*
1233 * "Note: disks explicitly requested
1234 * are not subject to this disk limit"
1235 */
1236 if ((count > df.if_max_iodevs) ||
1237 (count && (df.if_max_iodevs == UNLIMITED_IODEVS)))
1238 df.if_max_iodevs = count;
1239
1240 df.if_names = safe_alloc(count * sizeof (char *));
1241 (void) memset(df.if_names, 0, count * sizeof (char *));
1242
1243 df.if_nr_names = 0;
1244 while (optind < argc && !isdigit(argv[optind][0]))
1245 df.if_names[df.if_nr_names++] = argv[optind++];
1246 }
1247 if (optind < argc) {
1248 interval = safe_strtoi(argv[optind], "invalid interval");
1249 if (interval < 1)
1250 fail(0, "invalid interval");
1251 optind++;
1252
1253 if (optind < argc) {
1254 iter = safe_strtoi(argv[optind], "invalid count");
1255 if (iter < 1)
1256 fail(0, "invalid count");
1257 optind++;
1258 }
1259 }
1260 if (interval == 0)
1261 iter = 1;
1262 if (optind < argc)
1263 usage();
1264 }
1265
1266 /*
1267 * Driver for doing the extended header formatting. Will produce
1268 * the function stack needed to output an extended header based
1269 * on the options selected.
1270 */
1271
1272 void
do_format(void)1273 do_format(void)
1274 {
1275 char header[SMALL_SCRATCH_BUFLEN] = {0};
1276 char ch;
1277 char iosz;
1278 const char *fstr;
1279
1280 disk_header[0] = 0;
1281 ch = (do_interval ? 'i' : 's');
1282 iosz = (do_megabytes ? 'M' : 'k');
1283 if (do_disk & DISK_ERRORS) {
1284 if (do_raw == 0) {
1285 (void) sprintf(header, "s/w h/w trn tot ");
1286 } else
1287 (void) sprintf(header, "s/w,h/w,trn,tot");
1288 }
1289 switch (do_disk & DISK_IO_MASK) {
1290 case DISK_OLD:
1291 if (do_raw == 0)
1292 fstr = "%cp%c tp%c serv ";
1293 else
1294 fstr = "%cp%c,tp%c,serv";
1295 (void) snprintf(disk_header, sizeof (disk_header),
1296 fstr, iosz, ch, ch);
1297 break;
1298 case DISK_NEW:
1299 if (do_raw == 0)
1300 fstr = "rp%c wp%c util ";
1301 else
1302 fstr = "%rp%c,wp%c,util";
1303 (void) snprintf(disk_header, sizeof (disk_header),
1304 fstr, ch, ch);
1305 break;
1306 case DISK_EXTENDED:
1307 /* This is -x option */
1308 if (!do_conversions) {
1309 /* without -n option */
1310 if (do_raw == 0) {
1311 /* without -r option */
1312 (void) snprintf(disk_header,
1313 sizeof (disk_header),
1314 "%-*.*s r/%c w/%c "
1315 "%cr/%c %cw/%c wait actv "
1316 "svc_t %%%%w %%%%b %s",
1317 iodevs_nl, iodevs_nl, "device",
1318 ch, ch, iosz, ch, iosz, ch, header);
1319 } else {
1320 /* with -r option */
1321 (void) snprintf(disk_header,
1322 sizeof (disk_header),
1323 "device,r/%c,w/%c,%cr/%c,%cw/%c,"
1324 "wait,actv,svc_t,%%%%w,"
1325 "%%%%b%s%s",
1326 ch, ch, iosz, ch, iosz, ch,
1327 *header == '\0' ? "" : ",",
1328 header);
1329 /*
1330 * if no -e flag, header == '\0...'
1331 * Ternary operator above is to prevent
1332 * trailing comma in full disk_header
1333 */
1334 }
1335 } else {
1336 /* with -n option */
1337 if (do_raw == 0) {
1338 fstr = " r/%c w/%c %cr/%c "
1339 "%cw/%c wait actv wsvc_t asvc_t "
1340 "%%%%w %%%%b %sdevice";
1341 } else {
1342 fstr = "r/%c,w/%c,%cr/%c,%cw/%c,"
1343 "wait,actv,wsvc_t,asvc_t,"
1344 "%%%%w,%%%%b,%sdevice";
1345 /*
1346 * if -rnxe, "tot" (from -e) and
1347 * "device" are run together
1348 * due to lack of trailing comma
1349 * in 'header'. However, adding
1350 * trailing comma to header at
1351 * its definition leads to prob-
1352 * lems elsewhere so it's added
1353 * here in this edge case -rnxe
1354 */
1355 if (*header != '\0')
1356 (void) strcat(header, ",");
1357 }
1358 (void) snprintf(disk_header,
1359 sizeof (disk_header),
1360 fstr, ch, ch, iosz, ch, iosz,
1361 ch, header);
1362 }
1363 break;
1364 default:
1365 break;
1366 }
1367
1368 /* do DISK_ERRORS header (already added above for DISK_EXTENDED) */
1369 if ((do_disk & DISK_ERRORS) &&
1370 ((do_disk & DISK_IO_MASK) != DISK_EXTENDED)) {
1371 if (!do_conversions) {
1372 if (do_raw == 0)
1373 (void) snprintf(disk_header,
1374 sizeof (disk_header), "%-*.*s %s",
1375 iodevs_nl, iodevs_nl, "device", header);
1376 else
1377 (void) snprintf(disk_header,
1378 sizeof (disk_header), "device,%s", header);
1379 } else {
1380 if (do_raw == 0) {
1381 (void) snprintf(disk_header,
1382 sizeof (disk_header),
1383 " %sdevice", header);
1384 } else {
1385 (void) snprintf(disk_header,
1386 sizeof (disk_header),
1387 "%s,device", header);
1388 }
1389 }
1390 } else {
1391 /*
1392 * Need to subtract two characters for the % escape in
1393 * the string.
1394 */
1395 dh_len = strlen(disk_header) - 2;
1396 }
1397
1398 /*
1399 * -n *and* (-E *or* -e *or* -x)
1400 */
1401 if (do_conversions && (do_disk & PRINT_VERTICAL)) {
1402 if (do_tty)
1403 setup(print_tty_hdr1);
1404 if (do_cpu)
1405 setup(print_cpu_hdr1);
1406 if (do_tty || do_cpu)
1407 setup(do_newline);
1408 if (do_tty)
1409 setup(print_tty_hdr2);
1410 if (do_cpu)
1411 setup(print_cpu_hdr2);
1412 if (do_tty || do_cpu)
1413 setup(do_newline);
1414 if (do_tty)
1415 setup(print_tty_data);
1416 if (do_cpu)
1417 setup(print_cpu_data);
1418 if (do_tty || do_cpu)
1419 setup(do_newline);
1420 printxhdr();
1421
1422 setup(show_all_disks);
1423 } else {
1424 /*
1425 * These unholy gymnastics are necessary to place CPU/tty
1426 * data to the right of the disks/errors for the first
1427 * line in vertical mode.
1428 */
1429 if (do_disk & PRINT_VERTICAL) {
1430 printxhdr();
1431
1432 setup(show_first_disk);
1433 if (do_tty)
1434 setup(print_tty_data);
1435 if (do_cpu)
1436 setup(print_cpu_data);
1437 setup(do_newline);
1438
1439 setup(show_other_disks);
1440 } else {
1441 setup(hdrout);
1442 if (do_tty)
1443 setup(print_tty_data);
1444 setup(show_all_disks);
1445 if (do_cpu)
1446 setup(print_cpu_data);
1447 }
1448
1449 setup(do_newline);
1450 }
1451 if (do_disk & DISK_EXTENDED_ERRORS)
1452 setup(disk_errors);
1453 }
1454
1455 /*
1456 * Add a new function to the list of functions
1457 * for this invocation. Once on the stack the
1458 * function is never removed nor does its place
1459 * change.
1460 */
1461 void
setup(void (* nfunc)(void))1462 setup(void (*nfunc)(void))
1463 {
1464 format_t *tmp;
1465
1466 tmp = safe_alloc(sizeof (format_t));
1467 tmp->nfunc = nfunc;
1468 tmp->next = 0;
1469 if (formatter_end)
1470 formatter_end->next = tmp;
1471 else
1472 formatter_list = tmp;
1473 formatter_end = tmp;
1474
1475 }
1476
1477 /*
1478 * The functions after this comment are devoted to printing
1479 * various parts of the header. They are selected based on the
1480 * options provided when the program was invoked. The functions
1481 * are either directly invoked in printhdr() or are indirectly
1482 * invoked by being placed on the list of functions used when
1483 * extended headers are used.
1484 */
1485 void
print_tty_hdr1(void)1486 print_tty_hdr1(void)
1487 {
1488 char *fstr;
1489 char *dstr;
1490
1491 if (do_raw == 0) {
1492 fstr = "%10.10s";
1493 dstr = "tty ";
1494 } else {
1495 fstr = "%s";
1496 dstr = "tty";
1497 }
1498 push_out(fstr, dstr);
1499 }
1500
1501 void
print_tty_hdr2(void)1502 print_tty_hdr2(void)
1503 {
1504 if (do_raw == 0)
1505 push_out("%-10.10s", " tin tout");
1506 else
1507 push_out("tin,tout");
1508 }
1509
1510 void
print_cpu_hdr1(void)1511 print_cpu_hdr1(void)
1512 {
1513 char *dstr;
1514
1515 if (do_raw == 0)
1516 dstr = " cpu";
1517 else
1518 dstr = "cpu";
1519 push_out(dstr);
1520 }
1521
1522 void
print_cpu_hdr2(void)1523 print_cpu_hdr2(void)
1524 {
1525 char *dstr;
1526
1527 if (do_raw == 0)
1528 dstr = " us sy dt id";
1529 else
1530 dstr = "us,sy,dt,id";
1531 push_out(dstr);
1532 }
1533
1534 /*
1535 * Assumption is that tty data is always first - no need for raw mode leading
1536 * comma.
1537 */
1538 void
print_tty_data(void)1539 print_tty_data(void)
1540 {
1541 char *fstr;
1542 uint64_t deltas;
1543 double raw;
1544 double outch;
1545 kstat_t *oldks = NULL;
1546
1547 if (oldss)
1548 oldks = &oldss->s_sys.ss_agg_sys;
1549
1550 if (do_raw == 0)
1551 fstr = " %3.0f %4.0f ";
1552 else
1553 fstr = "%.0f,%.0f";
1554 deltas = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "rawch");
1555 raw = deltas;
1556 raw /= getime;
1557 deltas = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "outch");
1558 outch = deltas;
1559 outch /= getime;
1560 push_out(fstr, raw, outch);
1561 }
1562
1563 /*
1564 * Write out CPU data
1565 */
1566 void
print_cpu_data(void)1567 print_cpu_data(void)
1568 {
1569 char *fstr;
1570 uint64_t idle;
1571 uint64_t user;
1572 uint64_t kern;
1573 uint64_t dtrace;
1574 uint64_t nsec_elapsed;
1575 kstat_t *oldks = NULL;
1576
1577 if (oldss)
1578 oldks = &oldss->s_sys.ss_agg_sys;
1579
1580 if (do_raw == 0)
1581 fstr = " %2.0f %2.0f %2.0f %2.0f";
1582 else
1583 fstr = "%.0f,%.0f,%.0f,%.0f";
1584
1585 idle = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_idle");
1586 user = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_user");
1587 kern = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_kernel");
1588 dtrace = kstat_delta(oldks, &newss->s_sys.ss_agg_sys,
1589 "cpu_nsec_dtrace");
1590 nsec_elapsed = newss->s_sys.ss_agg_sys.ks_snaptime -
1591 (oldks == NULL ? 0 : oldks->ks_snaptime);
1592 push_out(fstr, user * percent, kern * percent,
1593 dtrace * 100.0 / nsec_elapsed / newss->s_nr_active_cpus,
1594 idle * percent);
1595 }
1596
1597 /*
1598 * Emit the appropriate header.
1599 */
1600 void
hdrout(void)1601 hdrout(void)
1602 {
1603 if (do_raw == 0) {
1604 if (--tohdr == 0)
1605 printhdr(0);
1606 } else if (hdr_out == 0) {
1607 printhdr(0);
1608 hdr_out = 1;
1609 }
1610 }
1611
1612 /*
1613 * Write out disk errors when -E is specified.
1614 */
1615 void
disk_errors(void)1616 disk_errors(void)
1617 {
1618 (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk_errors, NULL);
1619 }
1620
1621 void
show_first_disk(void)1622 show_first_disk(void)
1623 {
1624 int count = 0;
1625
1626 show_disk_mode = SHOW_FIRST_ONLY;
1627
1628 (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count);
1629 }
1630
1631 void
show_other_disks(void)1632 show_other_disks(void)
1633 {
1634 int count = 0;
1635
1636 show_disk_mode = SHOW_SECOND_ONWARDS;
1637
1638 (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count);
1639 }
1640
1641 void
show_all_disks(void)1642 show_all_disks(void)
1643 {
1644 int count = 0;
1645
1646 show_disk_mode = SHOW_ALL;
1647
1648 (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count);
1649 }
1650
1651 /*
1652 * Write a newline out and clear the lineout flag.
1653 */
1654 static void
do_newline(void)1655 do_newline(void)
1656 {
1657 if (lineout) {
1658 (void) putchar('\n');
1659 lineout = 0;
1660 }
1661 }
1662
1663 /*
1664 * Generalized printf function that determines what extra
1665 * to print out if we're in raw mode. At this time we
1666 * don't care about errors.
1667 */
1668 static void
push_out(const char * message,...)1669 push_out(const char *message, ...)
1670 {
1671 va_list args;
1672
1673 va_start(args, message);
1674 if (do_raw && lineout == 1)
1675 (void) putchar(',');
1676 (void) vprintf(message, args);
1677 va_end(args);
1678 lineout = 1;
1679 }
1680
1681 /*
1682 * Emit the header string when -e is specified.
1683 */
1684 static void
print_err_hdr(void)1685 print_err_hdr(void)
1686 {
1687 char obuf[SMALL_SCRATCH_BUFLEN];
1688
1689 if (do_raw) {
1690 push_out("errors");
1691 return;
1692 }
1693
1694 if (do_conversions == 0) {
1695 if (!(do_disk & DISK_EXTENDED)) {
1696 (void) snprintf(obuf, sizeof (obuf),
1697 "%11s", one_blank);
1698 push_out(obuf);
1699 }
1700 } else if (do_disk == DISK_ERRORS)
1701 push_out(two_blanks);
1702 else
1703 push_out(one_blank);
1704 push_out("---- errors --- ");
1705 }
1706
1707 /*
1708 * Emit the header string when -e is specified.
1709 */
1710 static void
print_disk_header(void)1711 print_disk_header(void)
1712 {
1713 push_out(disk_header);
1714 }
1715
1716 /*
1717 * No, UINTMAX_MAX isn't the right thing here since
1718 * it is #defined to be either INT32_MAX or INT64_MAX
1719 * depending on the whether _LP64 is defined.
1720 *
1721 * We want to handle the odd future case of having
1722 * ulonglong_t be more than 64 bits but we have
1723 * no nice #define MAX value we can drop in place
1724 * without having to change this code in the future.
1725 */
1726
1727 u_longlong_t
ull_delta(u_longlong_t old,u_longlong_t new)1728 ull_delta(u_longlong_t old, u_longlong_t new)
1729 {
1730 if (new >= old)
1731 return (new - old);
1732 else
1733 return ((UINT64_MAX - old) + new + 1);
1734 }
1735
1736 /*
1737 * Take the difference of an unsigned 32
1738 * bit int attempting to cater for
1739 * overflow.
1740 */
1741 uint_t
u32_delta(uint_t old,uint_t new)1742 u32_delta(uint_t old, uint_t new)
1743 {
1744 if (new >= old)
1745 return (new - old);
1746 else
1747 return ((UINT32_MAX - old) + new + 1);
1748 }
1749
1750 /*
1751 * This is exactly what is needed for standard iostat output,
1752 * but make sure to use it only for that
1753 */
1754 #define EPSILON (0.1)
1755 static int
fzero(double value)1756 fzero(double value)
1757 {
1758 return (value >= 0.0 && value < EPSILON);
1759 }
1760
1761 static int
safe_strtoi(char const * val,char * errmsg)1762 safe_strtoi(char const *val, char *errmsg)
1763 {
1764 char *end;
1765 long tmp;
1766
1767 errno = 0;
1768 tmp = strtol(val, &end, 10);
1769 if (*end != '\0' || errno)
1770 fail(0, "%s %s", errmsg, val);
1771 return ((int)tmp);
1772 }
1773