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