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