17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5*a08731ecScth * Common Development and Distribution License (the "License"). 6*a08731ecScth * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*a08731ecScth * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate * 257c478bd9Sstevel@tonic-gate * rewritten from UCB 4.13 83/09/25 267c478bd9Sstevel@tonic-gate * rewritten from SunOS 4.1 SID 1.18 89/10/06 277c478bd9Sstevel@tonic-gate */ 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #include <stdio.h> 327c478bd9Sstevel@tonic-gate #include <stdlib.h> 337c478bd9Sstevel@tonic-gate #include <stdarg.h> 347c478bd9Sstevel@tonic-gate #include <ctype.h> 357c478bd9Sstevel@tonic-gate #include <unistd.h> 367c478bd9Sstevel@tonic-gate #include <memory.h> 377c478bd9Sstevel@tonic-gate #include <errno.h> 387c478bd9Sstevel@tonic-gate #include <string.h> 397c478bd9Sstevel@tonic-gate #include <signal.h> 407c478bd9Sstevel@tonic-gate #include <sys/types.h> 417c478bd9Sstevel@tonic-gate #include <time.h> 427c478bd9Sstevel@tonic-gate #include <sys/time.h> 437c478bd9Sstevel@tonic-gate #include <sys/sysinfo.h> 447c478bd9Sstevel@tonic-gate #include <inttypes.h> 457c478bd9Sstevel@tonic-gate #include <strings.h> 467c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 477c478bd9Sstevel@tonic-gate #include <kstat.h> 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate #include "dsr.h" 507c478bd9Sstevel@tonic-gate #include "statcommon.h" 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate #define DISK_OLD 0x0001 537c478bd9Sstevel@tonic-gate #define DISK_NEW 0x0002 547c478bd9Sstevel@tonic-gate #define DISK_EXTENDED 0x0004 557c478bd9Sstevel@tonic-gate #define DISK_ERRORS 0x0008 567c478bd9Sstevel@tonic-gate #define DISK_EXTENDED_ERRORS 0x0010 577c478bd9Sstevel@tonic-gate #define DISK_IOPATH 0x0020 587c478bd9Sstevel@tonic-gate #define DISK_NORMAL (DISK_OLD | DISK_NEW) 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate #define DISK_IO_MASK (DISK_OLD | DISK_NEW | DISK_EXTENDED) 617c478bd9Sstevel@tonic-gate #define DISK_ERROR_MASK (DISK_ERRORS | DISK_EXTENDED_ERRORS) 627c478bd9Sstevel@tonic-gate #define PRINT_VERTICAL (DISK_ERROR_MASK | DISK_EXTENDED | DISK_IOPATH) 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate #define REPRINT 19 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate /* 677c478bd9Sstevel@tonic-gate * It's really a pseudo-gigabyte. We use 1000000000 bytes so that the disk 687c478bd9Sstevel@tonic-gate * labels don't look bad. 1GB is really 1073741824 bytes. 697c478bd9Sstevel@tonic-gate */ 707c478bd9Sstevel@tonic-gate #define DISK_GIGABYTE 1000000000.0 717c478bd9Sstevel@tonic-gate 727c478bd9Sstevel@tonic-gate /* 737c478bd9Sstevel@tonic-gate * Function desciptor to be called when extended 747c478bd9Sstevel@tonic-gate * headers are used. 757c478bd9Sstevel@tonic-gate */ 767c478bd9Sstevel@tonic-gate typedef struct formatter { 777c478bd9Sstevel@tonic-gate void (*nfunc)(void); 787c478bd9Sstevel@tonic-gate struct formatter *next; 797c478bd9Sstevel@tonic-gate } format_t; 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate /* 827c478bd9Sstevel@tonic-gate * Used to get formatting right when printing tty/cpu 837c478bd9Sstevel@tonic-gate * data to the right of disk data 847c478bd9Sstevel@tonic-gate */ 857c478bd9Sstevel@tonic-gate enum show_disk_mode { 867c478bd9Sstevel@tonic-gate SHOW_FIRST_ONLY, 877c478bd9Sstevel@tonic-gate SHOW_SECOND_ONWARDS, 887c478bd9Sstevel@tonic-gate SHOW_ALL 897c478bd9Sstevel@tonic-gate }; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate enum show_disk_mode show_disk_mode = SHOW_ALL; 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate char cmdname[] = "iostat"; 947c478bd9Sstevel@tonic-gate 957c478bd9Sstevel@tonic-gate static char one_blank[] = " "; 967c478bd9Sstevel@tonic-gate static char two_blanks[] = " "; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate /* 997c478bd9Sstevel@tonic-gate * count for number of lines to be emitted before a header is 1007c478bd9Sstevel@tonic-gate * shown again. Only used for the basic format. 1017c478bd9Sstevel@tonic-gate */ 1027c478bd9Sstevel@tonic-gate static uint_t tohdr = 1; 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate /* 1057c478bd9Sstevel@tonic-gate * If we're in raw format, have we printed a header? We only do it 1067c478bd9Sstevel@tonic-gate * once for raw but we emit it every REPRINT lines in non-raw format. 1077c478bd9Sstevel@tonic-gate * This applies only for the basic header. The extended header is 1087c478bd9Sstevel@tonic-gate * done only once in both formats. 1097c478bd9Sstevel@tonic-gate */ 1107c478bd9Sstevel@tonic-gate static uint_t hdr_out; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate /* 1137c478bd9Sstevel@tonic-gate * Flags representing arguments from command line 1147c478bd9Sstevel@tonic-gate */ 1157c478bd9Sstevel@tonic-gate static uint_t do_tty; /* show tty info (-t) */ 1167c478bd9Sstevel@tonic-gate static uint_t do_disk; /* show disk info per selected */ 1177c478bd9Sstevel@tonic-gate /* format (-d, -D, -e, -E, -x -X) */ 1187c478bd9Sstevel@tonic-gate static uint_t do_cpu; /* show cpu info (-c) */ 1197c478bd9Sstevel@tonic-gate static uint_t do_interval; /* do intervals (-I) */ 1207c478bd9Sstevel@tonic-gate static int do_partitions; /* per-partition stats (-p) */ 1217c478bd9Sstevel@tonic-gate static int do_partitions_only; /* per-partition stats only (-P) */ 1227c478bd9Sstevel@tonic-gate /* no per-device stats for disks */ 1237c478bd9Sstevel@tonic-gate static uint_t do_conversions; /* display disks as cXtYdZ (-n) */ 1247c478bd9Sstevel@tonic-gate static uint_t do_megabytes; /* display data in MB/sec (-M) */ 1257c478bd9Sstevel@tonic-gate static uint_t do_controller; /* display controller info (-C) */ 1267c478bd9Sstevel@tonic-gate static uint_t do_raw; /* emit raw format (-r) */ 1277c478bd9Sstevel@tonic-gate static uint_t do_timestamp; /* timestamp each display (-T) */ 1287c478bd9Sstevel@tonic-gate static uint_t do_devid; /* -E should show devid */ 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate /* 1317c478bd9Sstevel@tonic-gate * Definition of allowable types of timestamps 1327c478bd9Sstevel@tonic-gate */ 1337c478bd9Sstevel@tonic-gate #define CDATE 1 1347c478bd9Sstevel@tonic-gate #define UDATE 2 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate /* 1377c478bd9Sstevel@tonic-gate * Default number of disk drives to be displayed in basic format 1387c478bd9Sstevel@tonic-gate */ 1397c478bd9Sstevel@tonic-gate #define DEFAULT_LIMIT 4 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate struct iodev_filter df; 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate static uint_t suppress_state; /* skip state change messages */ 1447c478bd9Sstevel@tonic-gate static uint_t suppress_zero; /* skip zero valued lines */ 1457c478bd9Sstevel@tonic-gate static uint_t show_mountpts; /* show mount points */ 1467c478bd9Sstevel@tonic-gate static int interval; /* interval (seconds) to output */ 1477c478bd9Sstevel@tonic-gate static int iter; /* iterations from command line */ 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate #define SMALL_SCRATCH_BUFLEN 64 1507c478bd9Sstevel@tonic-gate #define DISPLAYED_NAME_FORMAT "%-9.9s" 1517c478bd9Sstevel@tonic-gate 1527c478bd9Sstevel@tonic-gate static char disk_header[132]; 1537c478bd9Sstevel@tonic-gate static uint_t dh_len; /* disk header length for centering */ 1547c478bd9Sstevel@tonic-gate static int lineout; /* data waiting to be printed? */ 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate static struct snapshot *newss; 1577c478bd9Sstevel@tonic-gate static struct snapshot *oldss; 1587c478bd9Sstevel@tonic-gate static double getime; /* elapsed time */ 1597c478bd9Sstevel@tonic-gate static double percent; /* 100 / etime */ 1607c478bd9Sstevel@tonic-gate 1617c478bd9Sstevel@tonic-gate /* 1627c478bd9Sstevel@tonic-gate * List of functions to be called which will construct the desired output 1637c478bd9Sstevel@tonic-gate */ 1647c478bd9Sstevel@tonic-gate static format_t *formatter_list; 1657c478bd9Sstevel@tonic-gate static format_t *formatter_end; 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate static uint64_t hrtime_delta(hrtime_t, hrtime_t); 1687c478bd9Sstevel@tonic-gate static u_longlong_t ull_delta(u_longlong_t, u_longlong_t); 1697c478bd9Sstevel@tonic-gate static uint_t u32_delta(uint_t, uint_t); 1707c478bd9Sstevel@tonic-gate static void setup(void (*nfunc)(void)); 1717c478bd9Sstevel@tonic-gate static void print_timestamp(void); 1727c478bd9Sstevel@tonic-gate static void print_tty_hdr1(void); 1737c478bd9Sstevel@tonic-gate static void print_tty_hdr2(void); 1747c478bd9Sstevel@tonic-gate static void print_cpu_hdr1(void); 1757c478bd9Sstevel@tonic-gate static void print_cpu_hdr2(void); 1767c478bd9Sstevel@tonic-gate static void print_tty_data(void); 1777c478bd9Sstevel@tonic-gate static void print_cpu_data(void); 1787c478bd9Sstevel@tonic-gate static void print_err_hdr(void); 1797c478bd9Sstevel@tonic-gate static void print_disk_header(void); 1807c478bd9Sstevel@tonic-gate static void hdrout(void); 1817c478bd9Sstevel@tonic-gate static void disk_errors(void); 1827c478bd9Sstevel@tonic-gate static void do_newline(void); 1837c478bd9Sstevel@tonic-gate static void push_out(const char *, ...); 1847c478bd9Sstevel@tonic-gate static void printhdr(int); 1857c478bd9Sstevel@tonic-gate static void printxhdr(void); 1867c478bd9Sstevel@tonic-gate static void usage(void); 1877c478bd9Sstevel@tonic-gate static void do_args(int, char **); 1887c478bd9Sstevel@tonic-gate static void do_format(void); 1897c478bd9Sstevel@tonic-gate static void set_timer(int); 1907c478bd9Sstevel@tonic-gate static void handle_sig(int); 1917c478bd9Sstevel@tonic-gate static void show_all_disks(void); 1927c478bd9Sstevel@tonic-gate static void show_first_disk(void); 1937c478bd9Sstevel@tonic-gate static void show_other_disks(void); 1947c478bd9Sstevel@tonic-gate static void show_disk_errors(void *, void *, void *); 1957c478bd9Sstevel@tonic-gate static void write_core_header(void); 1967c478bd9Sstevel@tonic-gate static int fzero(double value); 1977c478bd9Sstevel@tonic-gate static int safe_strtoi(char const *val, char *errmsg); 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate int 2007c478bd9Sstevel@tonic-gate main(int argc, char **argv) 2017c478bd9Sstevel@tonic-gate { 2027c478bd9Sstevel@tonic-gate enum snapshot_types types = SNAP_SYSTEM; 2037c478bd9Sstevel@tonic-gate kstat_ctl_t *kc; 2047c478bd9Sstevel@tonic-gate long hz; 205*a08731ecScth int iiter; 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate do_args(argc, argv); 2087c478bd9Sstevel@tonic-gate do_format(); 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate /* 2117c478bd9Sstevel@tonic-gate * iostat historically showed CPU changes, even though 2127c478bd9Sstevel@tonic-gate * it doesn't provide much useful information 2137c478bd9Sstevel@tonic-gate */ 2147c478bd9Sstevel@tonic-gate types |= SNAP_CPUS; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate if (do_disk) 2177c478bd9Sstevel@tonic-gate types |= SNAP_IODEVS; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate if (do_disk && !do_partitions_only) 2207c478bd9Sstevel@tonic-gate df.if_allowed_types |= IODEV_DISK; 2217c478bd9Sstevel@tonic-gate if (do_disk & DISK_IOPATH) { 2227c478bd9Sstevel@tonic-gate df.if_allowed_types |= IODEV_IOPATH; 2237c478bd9Sstevel@tonic-gate types |= SNAP_IOPATHS; 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate if (do_disk & DISK_ERROR_MASK) 2267c478bd9Sstevel@tonic-gate types |= SNAP_IODEV_ERRORS; 2277c478bd9Sstevel@tonic-gate if (do_partitions || do_partitions_only) 2287c478bd9Sstevel@tonic-gate df.if_allowed_types |= IODEV_PARTITION; 2297c478bd9Sstevel@tonic-gate if (do_conversions) 2307c478bd9Sstevel@tonic-gate types |= SNAP_IODEV_PRETTY; 231*a08731ecScth if (do_devid) 232*a08731ecScth types |= SNAP_IODEV_DEVID; 2337c478bd9Sstevel@tonic-gate if (do_controller) { 2347c478bd9Sstevel@tonic-gate if (!(do_disk & PRINT_VERTICAL) || 2357c478bd9Sstevel@tonic-gate (do_disk & DISK_EXTENDED_ERRORS)) 2367c478bd9Sstevel@tonic-gate fail(0, "-C can only be used with -e or -x."); 2377c478bd9Sstevel@tonic-gate types |= SNAP_CONTROLLERS; 2387c478bd9Sstevel@tonic-gate df.if_allowed_types |= IODEV_CONTROLLER; 2397c478bd9Sstevel@tonic-gate } 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate hz = sysconf(_SC_CLK_TCK); 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate /* 2447c478bd9Sstevel@tonic-gate * Undocumented behavior - sending a SIGCONT will result 2457c478bd9Sstevel@tonic-gate * in a new header being emitted. Used only if we're not 2467c478bd9Sstevel@tonic-gate * doing extended headers. This is a historical 2477c478bd9Sstevel@tonic-gate * artifact. 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate if (!(do_disk & PRINT_VERTICAL)) 2507c478bd9Sstevel@tonic-gate (void) signal(SIGCONT, printhdr); 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate if (interval) 2537c478bd9Sstevel@tonic-gate set_timer(interval); 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate kc = open_kstat(); 2567c478bd9Sstevel@tonic-gate newss = acquire_snapshot(kc, types, &df); 2577c478bd9Sstevel@tonic-gate 258*a08731ecScth iiter = iter; 2597c478bd9Sstevel@tonic-gate do { 2607c478bd9Sstevel@tonic-gate if (do_tty || do_cpu) { 2617c478bd9Sstevel@tonic-gate kstat_t *oldks; 2627c478bd9Sstevel@tonic-gate oldks = oldss ? &oldss->s_sys.ss_agg_sys : NULL; 2637c478bd9Sstevel@tonic-gate getime = cpu_ticks_delta(oldks, 2647c478bd9Sstevel@tonic-gate &newss->s_sys.ss_agg_sys); 2657c478bd9Sstevel@tonic-gate percent = (getime > 0.0) ? 100.0 / getime : 0.0; 2667c478bd9Sstevel@tonic-gate getime = (getime / nr_active_cpus(newss)) / hz; 2677c478bd9Sstevel@tonic-gate if (getime == 0.0) 2687c478bd9Sstevel@tonic-gate getime = (double)interval; 2697c478bd9Sstevel@tonic-gate if (getime == 0.0 || do_interval) 2707c478bd9Sstevel@tonic-gate getime = 1.0; 2717c478bd9Sstevel@tonic-gate } 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate if (formatter_list) { 2747c478bd9Sstevel@tonic-gate format_t *tmp; 2757c478bd9Sstevel@tonic-gate tmp = formatter_list; 2767c478bd9Sstevel@tonic-gate while (tmp) { 2777c478bd9Sstevel@tonic-gate (tmp->nfunc)(); 2787c478bd9Sstevel@tonic-gate tmp = tmp->next; 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate (void) fflush(stdout); 2817c478bd9Sstevel@tonic-gate } 2827c478bd9Sstevel@tonic-gate 283*a08731ecScth /* only doing a single iteration, we are done */ 284*a08731ecScth if (iiter == 1) 285*a08731ecScth continue; 286*a08731ecScth 2877c478bd9Sstevel@tonic-gate if (interval > 0 && iter != 1) 2887c478bd9Sstevel@tonic-gate (void) pause(); 2897c478bd9Sstevel@tonic-gate 2907c478bd9Sstevel@tonic-gate free_snapshot(oldss); 2917c478bd9Sstevel@tonic-gate oldss = newss; 2927c478bd9Sstevel@tonic-gate newss = acquire_snapshot(kc, types, &df); 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate if (!suppress_state) 2957c478bd9Sstevel@tonic-gate snapshot_report_changes(oldss, newss); 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* if config changed, show stats from boot */ 2987c478bd9Sstevel@tonic-gate if (snapshot_has_changed(oldss, newss)) { 2997c478bd9Sstevel@tonic-gate free_snapshot(oldss); 3007c478bd9Sstevel@tonic-gate oldss = NULL; 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate } while (--iter); 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate free_snapshot(oldss); 3067c478bd9Sstevel@tonic-gate free_snapshot(newss); 307*a08731ecScth (void) kstat_close(kc); 308*a08731ecScth 3097c478bd9Sstevel@tonic-gate return (0); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate /* 3137c478bd9Sstevel@tonic-gate * Some magic numbers used in header formatting. 3147c478bd9Sstevel@tonic-gate * 3157c478bd9Sstevel@tonic-gate * DISK_LEN = length of either "kps tps serv" or "wps rps util" 3167c478bd9Sstevel@tonic-gate * using 0 as the first position 3177c478bd9Sstevel@tonic-gate * 3187c478bd9Sstevel@tonic-gate * DISK_ERROR_LEN = length of "s/w h/w trn tot" with one space on 3197c478bd9Sstevel@tonic-gate * either side. Does not use zero as first pos. 3207c478bd9Sstevel@tonic-gate * 3217c478bd9Sstevel@tonic-gate * DEVICE_LEN = length of "device" + 1 character. 3227c478bd9Sstevel@tonic-gate */ 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate #define DISK_LEN 11 3257c478bd9Sstevel@tonic-gate #define DISK_ERROR_LEN 16 3267c478bd9Sstevel@tonic-gate #define DEVICE_LEN 7 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3297c478bd9Sstevel@tonic-gate static void 3307c478bd9Sstevel@tonic-gate show_disk_name(void *v1, void *v2, void *data) 3317c478bd9Sstevel@tonic-gate { 3327c478bd9Sstevel@tonic-gate struct iodev_snapshot *dev = (struct iodev_snapshot *)v2; 3337c478bd9Sstevel@tonic-gate size_t slen; 3347c478bd9Sstevel@tonic-gate char *name; 3357c478bd9Sstevel@tonic-gate char fbuf[SMALL_SCRATCH_BUFLEN]; 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate if (dev == NULL) 3387c478bd9Sstevel@tonic-gate return; 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate name = dev->is_pretty ? dev->is_pretty : dev->is_name; 3417c478bd9Sstevel@tonic-gate if (!do_raw) { 3427c478bd9Sstevel@tonic-gate uint_t width; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate slen = strlen(name); 3457c478bd9Sstevel@tonic-gate /* 3467c478bd9Sstevel@tonic-gate * The length is less 3477c478bd9Sstevel@tonic-gate * than the section 3487c478bd9Sstevel@tonic-gate * which will be displayed 3497c478bd9Sstevel@tonic-gate * on the next line. 3507c478bd9Sstevel@tonic-gate * Center the entry. 3517c478bd9Sstevel@tonic-gate */ 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate width = (DISK_LEN + 1)/2 + (slen / 2); 3547c478bd9Sstevel@tonic-gate (void) snprintf(fbuf, sizeof (fbuf), 3557c478bd9Sstevel@tonic-gate "%*s", width, name); 3567c478bd9Sstevel@tonic-gate name = fbuf; 357*a08731ecScth push_out("%-13.13s ", name); 3587c478bd9Sstevel@tonic-gate } else { 3597c478bd9Sstevel@tonic-gate push_out(name); 3607c478bd9Sstevel@tonic-gate } 3617c478bd9Sstevel@tonic-gate } 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3647c478bd9Sstevel@tonic-gate static void 3657c478bd9Sstevel@tonic-gate show_disk_header(void *v1, void *v2, void *data) 3667c478bd9Sstevel@tonic-gate { 3677c478bd9Sstevel@tonic-gate push_out(disk_header); 3687c478bd9Sstevel@tonic-gate } 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate /* 3717c478bd9Sstevel@tonic-gate * Write out a two line header. What is written out depends on the flags 3727c478bd9Sstevel@tonic-gate * selected but in the worst case consists of a tty header, a disk header 3737c478bd9Sstevel@tonic-gate * providing information for 4 disks and a cpu header. 3747c478bd9Sstevel@tonic-gate * 3757c478bd9Sstevel@tonic-gate * The tty header consists of the word "tty" on the first line above the 3767c478bd9Sstevel@tonic-gate * words "tin tout" on the next line. If present the tty portion consumes 3777c478bd9Sstevel@tonic-gate * the first 10 characters of each line since "tin tout" is surrounded 3787c478bd9Sstevel@tonic-gate * by single spaces. 3797c478bd9Sstevel@tonic-gate * 3807c478bd9Sstevel@tonic-gate * Each of the disk sections is a 14 character "block" in which the name of 3817c478bd9Sstevel@tonic-gate * the disk is centered in the first 12 characters of the first line. 3827c478bd9Sstevel@tonic-gate * 3837c478bd9Sstevel@tonic-gate * The cpu section is an 11 character block with "cpu" centered over the 3847c478bd9Sstevel@tonic-gate * section. 3857c478bd9Sstevel@tonic-gate * 3867c478bd9Sstevel@tonic-gate * The worst case should look as follows: 3877c478bd9Sstevel@tonic-gate * 3887c478bd9Sstevel@tonic-gate * 0---------1--------2---------3---------4---------5---------6---------7------- 3897c478bd9Sstevel@tonic-gate * tty sd0 sd1 sd2 sd3 cpu 3907c478bd9Sstevel@tonic-gate * tin tout kps tps serv kps tps serv kps tps serv kps tps serv us sy wt id 3917c478bd9Sstevel@tonic-gate * NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NN NN NN NN 3927c478bd9Sstevel@tonic-gate * 3937c478bd9Sstevel@tonic-gate * When -D is specified, the disk header looks as follows (worst case): 3947c478bd9Sstevel@tonic-gate * 3957c478bd9Sstevel@tonic-gate * 0---------1--------2---------3---------4---------5---------6---------7------- 3967c478bd9Sstevel@tonic-gate * tty sd0 sd1 sd2 sd3 cpu 3977c478bd9Sstevel@tonic-gate * tin tout rps wps util rps wps util rps wps util rps wps util us sy wt id 3987c478bd9Sstevel@tonic-gate * NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NNN NNN NNNN NN NN NN NN 3997c478bd9Sstevel@tonic-gate */ 4007c478bd9Sstevel@tonic-gate static void 4017c478bd9Sstevel@tonic-gate printhdr(int sig) 4027c478bd9Sstevel@tonic-gate { 4037c478bd9Sstevel@tonic-gate /* 4047c478bd9Sstevel@tonic-gate * If we're here because a signal fired, reenable the 4057c478bd9Sstevel@tonic-gate * signal. 4067c478bd9Sstevel@tonic-gate */ 4077c478bd9Sstevel@tonic-gate if (sig) 4087c478bd9Sstevel@tonic-gate (void) signal(SIGCONT, printhdr); 4097c478bd9Sstevel@tonic-gate /* 4107c478bd9Sstevel@tonic-gate * Horizontal mode headers 4117c478bd9Sstevel@tonic-gate * 4127c478bd9Sstevel@tonic-gate * First line 4137c478bd9Sstevel@tonic-gate */ 4147c478bd9Sstevel@tonic-gate if (do_tty) 4157c478bd9Sstevel@tonic-gate print_tty_hdr1(); 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate if (do_disk & DISK_NORMAL) { 4187c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, NULL, newss, 4197c478bd9Sstevel@tonic-gate show_disk_name, NULL); 4207c478bd9Sstevel@tonic-gate } 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate if (do_cpu) 4237c478bd9Sstevel@tonic-gate print_cpu_hdr1(); 4247c478bd9Sstevel@tonic-gate do_newline(); 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate /* 4277c478bd9Sstevel@tonic-gate * Second line 4287c478bd9Sstevel@tonic-gate */ 4297c478bd9Sstevel@tonic-gate if (do_tty) 4307c478bd9Sstevel@tonic-gate print_tty_hdr2(); 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate if (do_disk & DISK_NORMAL) { 4337c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, NULL, newss, 4347c478bd9Sstevel@tonic-gate show_disk_header, NULL); 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate if (do_cpu) 4387c478bd9Sstevel@tonic-gate print_cpu_hdr2(); 4397c478bd9Sstevel@tonic-gate do_newline(); 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate tohdr = REPRINT; 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate /* 4457c478bd9Sstevel@tonic-gate * Write out the extended header centered over the core information. 4467c478bd9Sstevel@tonic-gate */ 4477c478bd9Sstevel@tonic-gate static void 4487c478bd9Sstevel@tonic-gate write_core_header(void) 4497c478bd9Sstevel@tonic-gate { 4507c478bd9Sstevel@tonic-gate char *edev = "extended device statistics"; 4517c478bd9Sstevel@tonic-gate uint_t lead_space_ct; 4527c478bd9Sstevel@tonic-gate uint_t follow_space_ct; 4537c478bd9Sstevel@tonic-gate size_t edevlen; 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate if (do_raw == 0) { 4567c478bd9Sstevel@tonic-gate /* 4577c478bd9Sstevel@tonic-gate * The things we do to look nice... 4587c478bd9Sstevel@tonic-gate * 4597c478bd9Sstevel@tonic-gate * Center the core output header. Make sure we have the 4607c478bd9Sstevel@tonic-gate * right number of trailing spaces for follow-on headers 4617c478bd9Sstevel@tonic-gate * (i.e., cpu and/or tty and/or errors). 4627c478bd9Sstevel@tonic-gate */ 4637c478bd9Sstevel@tonic-gate edevlen = strlen(edev); 4647c478bd9Sstevel@tonic-gate lead_space_ct = dh_len - edevlen; 4657c478bd9Sstevel@tonic-gate lead_space_ct /= 2; 4667c478bd9Sstevel@tonic-gate if (lead_space_ct > 0) { 4677c478bd9Sstevel@tonic-gate follow_space_ct = dh_len - (lead_space_ct + edevlen); 4687c478bd9Sstevel@tonic-gate if (do_disk & DISK_ERRORS) 4697c478bd9Sstevel@tonic-gate follow_space_ct -= DISK_ERROR_LEN; 4707c478bd9Sstevel@tonic-gate if ((do_disk & DISK_EXTENDED) && do_conversions) 4717c478bd9Sstevel@tonic-gate follow_space_ct -= DEVICE_LEN; 4727c478bd9Sstevel@tonic-gate 4737c478bd9Sstevel@tonic-gate push_out("%1$*2$.*2$s%3$s%4$*5$.*5$s", one_blank, 4747c478bd9Sstevel@tonic-gate lead_space_ct, edev, one_blank, follow_space_ct); 4757c478bd9Sstevel@tonic-gate } else 4767c478bd9Sstevel@tonic-gate push_out("%56s", edev); 4777c478bd9Sstevel@tonic-gate } else 4787c478bd9Sstevel@tonic-gate push_out(edev); 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate /* 4827c478bd9Sstevel@tonic-gate * In extended mode headers, we don't want to reprint the header on 4837c478bd9Sstevel@tonic-gate * signals as they are printed every time anyways. 4847c478bd9Sstevel@tonic-gate */ 4857c478bd9Sstevel@tonic-gate static void 4867c478bd9Sstevel@tonic-gate printxhdr(void) 4877c478bd9Sstevel@tonic-gate { 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate /* 4907c478bd9Sstevel@tonic-gate * Vertical mode headers 4917c478bd9Sstevel@tonic-gate */ 4927c478bd9Sstevel@tonic-gate if (do_disk & DISK_EXTENDED) 4937c478bd9Sstevel@tonic-gate setup(write_core_header); 4947c478bd9Sstevel@tonic-gate if (do_disk & DISK_ERRORS) 4957c478bd9Sstevel@tonic-gate setup(print_err_hdr); 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate if (do_conversions) { 4987c478bd9Sstevel@tonic-gate setup(do_newline); 4997c478bd9Sstevel@tonic-gate if (do_disk & (DISK_EXTENDED | DISK_ERRORS)) 5007c478bd9Sstevel@tonic-gate setup(print_disk_header); 5017c478bd9Sstevel@tonic-gate setup(do_newline); 5027c478bd9Sstevel@tonic-gate } else { 5037c478bd9Sstevel@tonic-gate if (do_tty) 5047c478bd9Sstevel@tonic-gate setup(print_tty_hdr1); 5057c478bd9Sstevel@tonic-gate if (do_cpu) 5067c478bd9Sstevel@tonic-gate setup(print_cpu_hdr1); 5077c478bd9Sstevel@tonic-gate setup(do_newline); 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate if (do_disk & (DISK_EXTENDED | DISK_ERRORS)) 5107c478bd9Sstevel@tonic-gate setup(print_disk_header); 5117c478bd9Sstevel@tonic-gate if (do_tty) 5127c478bd9Sstevel@tonic-gate setup(print_tty_hdr2); 5137c478bd9Sstevel@tonic-gate if (do_cpu) 5147c478bd9Sstevel@tonic-gate setup(print_cpu_hdr2); 5157c478bd9Sstevel@tonic-gate setup(do_newline); 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate /* 5207c478bd9Sstevel@tonic-gate * Write out a line for this disk - note that show_disk writes out 5217c478bd9Sstevel@tonic-gate * full lines or blocks for each selected disk. 5227c478bd9Sstevel@tonic-gate */ 5237c478bd9Sstevel@tonic-gate static void 5247c478bd9Sstevel@tonic-gate show_disk(void *v1, void *v2, void *data) 5257c478bd9Sstevel@tonic-gate { 5267c478bd9Sstevel@tonic-gate struct iodev_snapshot *old = (struct iodev_snapshot *)v1; 5277c478bd9Sstevel@tonic-gate struct iodev_snapshot *new = (struct iodev_snapshot *)v2; 5287c478bd9Sstevel@tonic-gate int *count = (int *)data; 5297c478bd9Sstevel@tonic-gate double rps, wps, tps, mtps, krps, kwps, kps, avw, avr, w_pct, r_pct; 5307c478bd9Sstevel@tonic-gate double wserv, rserv, serv; 5317c478bd9Sstevel@tonic-gate double iosize; /* kb/sec or MB/sec */ 5327c478bd9Sstevel@tonic-gate double etime, hr_etime; 5337c478bd9Sstevel@tonic-gate char *disk_name; 5347c478bd9Sstevel@tonic-gate u_longlong_t ldeltas; 5357c478bd9Sstevel@tonic-gate uint_t udeltas; 5367c478bd9Sstevel@tonic-gate uint64_t t_delta; 5377c478bd9Sstevel@tonic-gate uint64_t w_delta; 5387c478bd9Sstevel@tonic-gate uint64_t r_delta; 5397c478bd9Sstevel@tonic-gate int doit = 1; 5407c478bd9Sstevel@tonic-gate int i; 5417c478bd9Sstevel@tonic-gate uint_t toterrs; 5427c478bd9Sstevel@tonic-gate char *fstr; 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate if (new == NULL) 5457c478bd9Sstevel@tonic-gate return; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate switch (show_disk_mode) { 5487c478bd9Sstevel@tonic-gate case SHOW_FIRST_ONLY: 5497c478bd9Sstevel@tonic-gate if (count != NULL && *count) 5507c478bd9Sstevel@tonic-gate return; 5517c478bd9Sstevel@tonic-gate break; 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate case SHOW_SECOND_ONWARDS: 5547c478bd9Sstevel@tonic-gate if (count != NULL && !*count) { 5557c478bd9Sstevel@tonic-gate (*count)++; 5567c478bd9Sstevel@tonic-gate return; 5577c478bd9Sstevel@tonic-gate } 5587c478bd9Sstevel@tonic-gate break; 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate default: 5617c478bd9Sstevel@tonic-gate break; 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate disk_name = new->is_pretty ? new->is_pretty : new->is_name; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate /* 5677c478bd9Sstevel@tonic-gate * Only do if we want IO stats - Avoids errors traveling this 5687c478bd9Sstevel@tonic-gate * section if that's all we want to see. 5697c478bd9Sstevel@tonic-gate */ 5707c478bd9Sstevel@tonic-gate if (do_disk & DISK_IO_MASK) { 5717c478bd9Sstevel@tonic-gate if (old) { 5727c478bd9Sstevel@tonic-gate t_delta = hrtime_delta(old->is_snaptime, 5737c478bd9Sstevel@tonic-gate new->is_snaptime); 5747c478bd9Sstevel@tonic-gate } else { 5757c478bd9Sstevel@tonic-gate t_delta = hrtime_delta(new->is_crtime, 5767c478bd9Sstevel@tonic-gate new->is_snaptime); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate if (new->is_type == IODEV_CONTROLLER && new->is_nr_children) 5807c478bd9Sstevel@tonic-gate t_delta /= new->is_nr_children; 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate hr_etime = (double)t_delta; 5837c478bd9Sstevel@tonic-gate if (hr_etime == 0.0) 5847c478bd9Sstevel@tonic-gate hr_etime = (double)NANOSEC; 5857c478bd9Sstevel@tonic-gate etime = hr_etime / (double)NANOSEC; 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate /* reads per second */ 5887c478bd9Sstevel@tonic-gate udeltas = u32_delta(old ? old->is_stats.reads : 0, 5897c478bd9Sstevel@tonic-gate new->is_stats.reads); 5907c478bd9Sstevel@tonic-gate rps = (double)udeltas; 5917c478bd9Sstevel@tonic-gate rps /= etime; 5927c478bd9Sstevel@tonic-gate 5937c478bd9Sstevel@tonic-gate /* writes per second */ 5947c478bd9Sstevel@tonic-gate udeltas = u32_delta(old ? old->is_stats.writes : 0, 5957c478bd9Sstevel@tonic-gate new->is_stats.writes); 5967c478bd9Sstevel@tonic-gate wps = (double)udeltas; 5977c478bd9Sstevel@tonic-gate wps /= etime; 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate tps = rps + wps; 6007c478bd9Sstevel@tonic-gate /* transactions per second */ 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate /* 6037c478bd9Sstevel@tonic-gate * report throughput as either kb/sec or MB/sec 6047c478bd9Sstevel@tonic-gate */ 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate if (!do_megabytes) 6077c478bd9Sstevel@tonic-gate iosize = 1024.0; 6087c478bd9Sstevel@tonic-gate else 6097c478bd9Sstevel@tonic-gate iosize = 1048576.0; 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate ldeltas = ull_delta(old ? old->is_stats.nread : 0, 6127c478bd9Sstevel@tonic-gate new->is_stats.nread); 6137c478bd9Sstevel@tonic-gate if (ldeltas) { 6147c478bd9Sstevel@tonic-gate krps = (double)ldeltas; 6157c478bd9Sstevel@tonic-gate krps /= etime; 6167c478bd9Sstevel@tonic-gate krps /= iosize; 6177c478bd9Sstevel@tonic-gate } else 6187c478bd9Sstevel@tonic-gate krps = 0.0; 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate ldeltas = ull_delta(old ? old->is_stats.nwritten : 0, 6217c478bd9Sstevel@tonic-gate new->is_stats.nwritten); 6227c478bd9Sstevel@tonic-gate if (ldeltas) { 6237c478bd9Sstevel@tonic-gate kwps = (double)ldeltas; 6247c478bd9Sstevel@tonic-gate kwps /= etime; 6257c478bd9Sstevel@tonic-gate kwps /= iosize; 6267c478bd9Sstevel@tonic-gate } else 6277c478bd9Sstevel@tonic-gate kwps = 0.0; 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate /* 6307c478bd9Sstevel@tonic-gate * Blocks transferred per second 6317c478bd9Sstevel@tonic-gate */ 6327c478bd9Sstevel@tonic-gate kps = krps + kwps; 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate /* 635c3ac4cfbSpetede * Average number of wait transactions waiting 6367c478bd9Sstevel@tonic-gate */ 6377c478bd9Sstevel@tonic-gate w_delta = hrtime_delta((u_longlong_t) 6387c478bd9Sstevel@tonic-gate (old ? old->is_stats.wlentime : 0), 6397c478bd9Sstevel@tonic-gate new->is_stats.wlentime); 6407c478bd9Sstevel@tonic-gate if (w_delta) { 6417c478bd9Sstevel@tonic-gate avw = (double)w_delta; 6427c478bd9Sstevel@tonic-gate avw /= hr_etime; 6437c478bd9Sstevel@tonic-gate } else 6447c478bd9Sstevel@tonic-gate avw = 0.0; 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate /* 647c3ac4cfbSpetede * Average number of run transactions waiting 6487c478bd9Sstevel@tonic-gate */ 6497c478bd9Sstevel@tonic-gate r_delta = hrtime_delta(old ? old->is_stats.rlentime : 0, 6507c478bd9Sstevel@tonic-gate new->is_stats.rlentime); 6517c478bd9Sstevel@tonic-gate if (r_delta) { 6527c478bd9Sstevel@tonic-gate avr = (double)r_delta; 6537c478bd9Sstevel@tonic-gate avr /= hr_etime; 6547c478bd9Sstevel@tonic-gate } else 6557c478bd9Sstevel@tonic-gate avr = 0.0; 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate /* 6587c478bd9Sstevel@tonic-gate * Average wait service time in milliseconds 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate if (tps > 0.0 && (avw != 0.0 || avr != 0.0)) { 6617c478bd9Sstevel@tonic-gate mtps = 1000.0 / tps; 6627c478bd9Sstevel@tonic-gate if (avw != 0.0) 6637c478bd9Sstevel@tonic-gate wserv = avw * mtps; 6647c478bd9Sstevel@tonic-gate else 6657c478bd9Sstevel@tonic-gate wserv = 0.0; 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate if (avr != 0.0) 6687c478bd9Sstevel@tonic-gate rserv = avr * mtps; 6697c478bd9Sstevel@tonic-gate else 6707c478bd9Sstevel@tonic-gate rserv = 0.0; 6717c478bd9Sstevel@tonic-gate serv = rserv + wserv; 6727c478bd9Sstevel@tonic-gate } else { 6737c478bd9Sstevel@tonic-gate rserv = 0.0; 6747c478bd9Sstevel@tonic-gate wserv = 0.0; 6757c478bd9Sstevel@tonic-gate serv = 0.0; 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate /* % of time there is a transaction waiting for service */ 6797c478bd9Sstevel@tonic-gate t_delta = hrtime_delta(old ? old->is_stats.wtime : 0, 6807c478bd9Sstevel@tonic-gate new->is_stats.wtime); 6817c478bd9Sstevel@tonic-gate if (t_delta) { 6827c478bd9Sstevel@tonic-gate w_pct = (double)t_delta; 6837c478bd9Sstevel@tonic-gate w_pct /= hr_etime; 6847c478bd9Sstevel@tonic-gate w_pct *= 100.0; 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate /* 6877c478bd9Sstevel@tonic-gate * Average the wait queue utilization over the 6887c478bd9Sstevel@tonic-gate * the controller's devices, if this is a controller. 6897c478bd9Sstevel@tonic-gate */ 6907c478bd9Sstevel@tonic-gate if (new->is_type == IODEV_CONTROLLER) 6917c478bd9Sstevel@tonic-gate w_pct /= new->is_nr_children; 6927c478bd9Sstevel@tonic-gate } else 6937c478bd9Sstevel@tonic-gate w_pct = 0.0; 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate /* % of time there is a transaction running */ 6967c478bd9Sstevel@tonic-gate t_delta = hrtime_delta(old ? old->is_stats.rtime : 0, 6977c478bd9Sstevel@tonic-gate new->is_stats.rtime); 6987c478bd9Sstevel@tonic-gate if (t_delta) { 6997c478bd9Sstevel@tonic-gate r_pct = (double)t_delta; 7007c478bd9Sstevel@tonic-gate r_pct /= hr_etime; 7017c478bd9Sstevel@tonic-gate r_pct *= 100.0; 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate /* 7047c478bd9Sstevel@tonic-gate * Average the percent busy over the controller's 7057c478bd9Sstevel@tonic-gate * devices, if this is a controller. 7067c478bd9Sstevel@tonic-gate */ 7077c478bd9Sstevel@tonic-gate if (new->is_type == IODEV_CONTROLLER) 7087c478bd9Sstevel@tonic-gate w_pct /= new->is_nr_children; 7097c478bd9Sstevel@tonic-gate } else { 7107c478bd9Sstevel@tonic-gate r_pct = 0.0; 7117c478bd9Sstevel@tonic-gate } 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate /* % of time there is a transaction running */ 7147c478bd9Sstevel@tonic-gate if (do_interval) { 7157c478bd9Sstevel@tonic-gate rps *= etime; 7167c478bd9Sstevel@tonic-gate wps *= etime; 7177c478bd9Sstevel@tonic-gate tps *= etime; 7187c478bd9Sstevel@tonic-gate krps *= etime; 7197c478bd9Sstevel@tonic-gate kwps *= etime; 7207c478bd9Sstevel@tonic-gate kps *= etime; 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate if (do_disk & (DISK_EXTENDED | DISK_ERRORS)) { 7257c478bd9Sstevel@tonic-gate if ((!do_conversions) && ((suppress_zero == 0) || 7267c478bd9Sstevel@tonic-gate ((do_disk & DISK_EXTENDED) == 0))) { 7277c478bd9Sstevel@tonic-gate if (do_raw == 0) 7287c478bd9Sstevel@tonic-gate push_out(DISPLAYED_NAME_FORMAT, 7297c478bd9Sstevel@tonic-gate disk_name); 7307c478bd9Sstevel@tonic-gate else 7317c478bd9Sstevel@tonic-gate push_out(disk_name); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate } 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate switch (do_disk & DISK_IO_MASK) { 7367c478bd9Sstevel@tonic-gate case DISK_OLD: 7377c478bd9Sstevel@tonic-gate if (do_raw == 0) 7387c478bd9Sstevel@tonic-gate fstr = "%3.0f %3.0f %4.0f "; 7397c478bd9Sstevel@tonic-gate else 7407c478bd9Sstevel@tonic-gate fstr = "%.0f,%.0f,%.0f"; 7417c478bd9Sstevel@tonic-gate push_out(fstr, kps, tps, serv); 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate case DISK_NEW: 7447c478bd9Sstevel@tonic-gate if (do_raw == 0) 7457c478bd9Sstevel@tonic-gate fstr = "%3.0f %3.0f %4.1f "; 7467c478bd9Sstevel@tonic-gate else 7477c478bd9Sstevel@tonic-gate fstr = "%.0f,%.0f,%.1f"; 7487c478bd9Sstevel@tonic-gate push_out(fstr, rps, wps, r_pct); 7497c478bd9Sstevel@tonic-gate break; 7507c478bd9Sstevel@tonic-gate case DISK_EXTENDED: 7517c478bd9Sstevel@tonic-gate if (suppress_zero) { 7527c478bd9Sstevel@tonic-gate if (fzero(rps) && fzero(wps) && fzero(krps) && 7537c478bd9Sstevel@tonic-gate fzero(kwps) && fzero(avw) && fzero(avr) && 7547c478bd9Sstevel@tonic-gate fzero(serv) && fzero(w_pct) && fzero(r_pct)) 7557c478bd9Sstevel@tonic-gate doit = 0; 7567c478bd9Sstevel@tonic-gate else if (do_conversions == 0) { 7577c478bd9Sstevel@tonic-gate if (do_raw == 0) 7587c478bd9Sstevel@tonic-gate push_out(DISPLAYED_NAME_FORMAT, 7597c478bd9Sstevel@tonic-gate disk_name); 7607c478bd9Sstevel@tonic-gate else 7617c478bd9Sstevel@tonic-gate push_out(disk_name); 7627c478bd9Sstevel@tonic-gate } 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate if (doit) { 7657c478bd9Sstevel@tonic-gate if (!do_conversions) { 7667c478bd9Sstevel@tonic-gate if (do_raw == 0) { 7677c478bd9Sstevel@tonic-gate fstr = " %6.1f %6.1f %6.1f %6.1f " 7687c478bd9Sstevel@tonic-gate "%4.1f %4.1f %6.1f %3.0f " 7697c478bd9Sstevel@tonic-gate "%3.0f "; 7707c478bd9Sstevel@tonic-gate } else { 7717c478bd9Sstevel@tonic-gate fstr = "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f," 7727c478bd9Sstevel@tonic-gate "%.1f,%.0f,%.0f"; 7737c478bd9Sstevel@tonic-gate } 7747c478bd9Sstevel@tonic-gate push_out(fstr, rps, wps, krps, kwps, avw, avr, 7757c478bd9Sstevel@tonic-gate serv, w_pct, r_pct); 7767c478bd9Sstevel@tonic-gate } else { 7777c478bd9Sstevel@tonic-gate if (do_raw == 0) { 7787c478bd9Sstevel@tonic-gate fstr = " %6.1f %6.1f %6.1f %6.1f " 7797c478bd9Sstevel@tonic-gate "%4.1f %4.1f %6.1f %6.1f " 7807c478bd9Sstevel@tonic-gate "%3.0f %3.0f "; 7817c478bd9Sstevel@tonic-gate } else { 7827c478bd9Sstevel@tonic-gate fstr = "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f," 7837c478bd9Sstevel@tonic-gate "%.1f,%.1f,%.0f,%.0f"; 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate push_out(fstr, rps, wps, krps, kwps, avw, avr, 7867c478bd9Sstevel@tonic-gate wserv, rserv, w_pct, r_pct); 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate break; 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate if (do_disk & DISK_ERRORS) { 7937c478bd9Sstevel@tonic-gate if ((do_disk == DISK_ERRORS)) { 7947c478bd9Sstevel@tonic-gate if (do_raw == 0) 7957c478bd9Sstevel@tonic-gate push_out(two_blanks); 7967c478bd9Sstevel@tonic-gate } 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate if (new->is_errors.ks_data) { 7997c478bd9Sstevel@tonic-gate kstat_named_t *knp; 8007c478bd9Sstevel@tonic-gate char *efstr; 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate if (do_raw == 0) 8037c478bd9Sstevel@tonic-gate efstr = "%3u "; 8047c478bd9Sstevel@tonic-gate else 8057c478bd9Sstevel@tonic-gate efstr = "%u"; 8067c478bd9Sstevel@tonic-gate toterrs = 0; 8077c478bd9Sstevel@tonic-gate knp = KSTAT_NAMED_PTR(&new->is_errors); 8087c478bd9Sstevel@tonic-gate for (i = 0; i < 3; i++) { 8097c478bd9Sstevel@tonic-gate switch (knp[i].data_type) { 8107c478bd9Sstevel@tonic-gate case KSTAT_DATA_ULONG: 8117c478bd9Sstevel@tonic-gate push_out(efstr, 8127c478bd9Sstevel@tonic-gate knp[i].value.ui32); 8137c478bd9Sstevel@tonic-gate toterrs += knp[i].value.ui32; 8147c478bd9Sstevel@tonic-gate break; 8157c478bd9Sstevel@tonic-gate case KSTAT_DATA_ULONGLONG: 8167c478bd9Sstevel@tonic-gate /* 8177c478bd9Sstevel@tonic-gate * We're only set up to 8187c478bd9Sstevel@tonic-gate * write out the low 8197c478bd9Sstevel@tonic-gate * order 32-bits so 8207c478bd9Sstevel@tonic-gate * just grab that. 8217c478bd9Sstevel@tonic-gate */ 8227c478bd9Sstevel@tonic-gate push_out(efstr, 8237c478bd9Sstevel@tonic-gate knp[i].value.ui32); 8247c478bd9Sstevel@tonic-gate toterrs += knp[i].value.ui32; 8257c478bd9Sstevel@tonic-gate break; 8267c478bd9Sstevel@tonic-gate default: 8277c478bd9Sstevel@tonic-gate break; 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate push_out(efstr, toterrs); 8317c478bd9Sstevel@tonic-gate } else { 8327c478bd9Sstevel@tonic-gate if (do_raw == 0) 8337c478bd9Sstevel@tonic-gate push_out(" 0 0 0 0 "); 8347c478bd9Sstevel@tonic-gate else 8357c478bd9Sstevel@tonic-gate push_out("0,0,0,0"); 8367c478bd9Sstevel@tonic-gate } 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate } 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate if (suppress_zero == 0 || doit == 1) { 8417c478bd9Sstevel@tonic-gate if ((do_disk & (DISK_EXTENDED | DISK_ERRORS)) && 8427c478bd9Sstevel@tonic-gate do_conversions) { 8437c478bd9Sstevel@tonic-gate push_out("%s", disk_name); 8447c478bd9Sstevel@tonic-gate if (show_mountpts && new->is_dname) { 8457c478bd9Sstevel@tonic-gate mnt_t *mount_pt; 8467c478bd9Sstevel@tonic-gate char *lu; 8477c478bd9Sstevel@tonic-gate char lub[SMALL_SCRATCH_BUFLEN]; 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate lu = strrchr(new->is_dname, '/'); 8507c478bd9Sstevel@tonic-gate if (lu) { 8517c478bd9Sstevel@tonic-gate if (strcmp(disk_name, lu) == 0) 8527c478bd9Sstevel@tonic-gate lu = new->is_dname; 8537c478bd9Sstevel@tonic-gate else { 8547c478bd9Sstevel@tonic-gate *lu = 0; 8557c478bd9Sstevel@tonic-gate (void) strcpy(lub, 8567c478bd9Sstevel@tonic-gate new->is_dname); 8577c478bd9Sstevel@tonic-gate *lu = '/'; 8587c478bd9Sstevel@tonic-gate (void) strcat(lub, "/"); 8597c478bd9Sstevel@tonic-gate (void) strcat(lub, 8607c478bd9Sstevel@tonic-gate disk_name); 8617c478bd9Sstevel@tonic-gate lu = lub; 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate } else 8647c478bd9Sstevel@tonic-gate lu = disk_name; 8657c478bd9Sstevel@tonic-gate mount_pt = lookup_mntent_byname(lu); 8667c478bd9Sstevel@tonic-gate if (mount_pt) { 8677c478bd9Sstevel@tonic-gate if (do_raw == 0) 8687c478bd9Sstevel@tonic-gate push_out(" (%s)", 8697c478bd9Sstevel@tonic-gate mount_pt->mount_point); 8707c478bd9Sstevel@tonic-gate else 8717c478bd9Sstevel@tonic-gate push_out("(%s)", 8727c478bd9Sstevel@tonic-gate mount_pt->mount_point); 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate } 8767c478bd9Sstevel@tonic-gate } 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate if ((do_disk & PRINT_VERTICAL) && show_disk_mode != SHOW_FIRST_ONLY) 8797c478bd9Sstevel@tonic-gate do_newline(); 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate if (count != NULL) 8827c478bd9Sstevel@tonic-gate (*count)++; 8837c478bd9Sstevel@tonic-gate } 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate static void 8867c478bd9Sstevel@tonic-gate usage(void) 8877c478bd9Sstevel@tonic-gate { 8887c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 8897c478bd9Sstevel@tonic-gate "Usage: iostat [-cCdDeEiImMnpPrstxXz] " 8907c478bd9Sstevel@tonic-gate " [-l n] [-T d|u] [disk ...] [interval [count]]\n" 8917c478bd9Sstevel@tonic-gate "\t\t-c: report percentage of time system has spent\n" 8927c478bd9Sstevel@tonic-gate "\t\t\tin user/system/wait/idle mode\n" 8937c478bd9Sstevel@tonic-gate "\t\t-C: report disk statistics by controller\n" 8947c478bd9Sstevel@tonic-gate "\t\t-d: display disk Kb/sec, transfers/sec, avg. \n" 8957c478bd9Sstevel@tonic-gate "\t\t\tservice time in milliseconds \n" 8967c478bd9Sstevel@tonic-gate "\t\t-D: display disk reads/sec, writes/sec, \n" 8977c478bd9Sstevel@tonic-gate "\t\t\tpercentage disk utilization \n" 8987c478bd9Sstevel@tonic-gate "\t\t-e: report device error summary statistics\n" 8997c478bd9Sstevel@tonic-gate "\t\t-E: report extended device error statistics\n" 9007c478bd9Sstevel@tonic-gate "\t\t-i: show device IDs for -E output\n" 9017c478bd9Sstevel@tonic-gate "\t\t-I: report the counts in each interval,\n" 9027c478bd9Sstevel@tonic-gate "\t\t\tinstead of rates, where applicable\n" 9037c478bd9Sstevel@tonic-gate "\t\t-l n: Limit the number of disks to n\n" 9047c478bd9Sstevel@tonic-gate "\t\t-m: Display mount points (most useful with -p)\n" 9057c478bd9Sstevel@tonic-gate "\t\t-M: Display data throughput in MB/sec " 9067c478bd9Sstevel@tonic-gate "instead of Kb/sec\n" 9077c478bd9Sstevel@tonic-gate "\t\t-n: convert device names to cXdYtZ format\n" 9087c478bd9Sstevel@tonic-gate "\t\t-p: report per-partition disk statistics\n" 9097c478bd9Sstevel@tonic-gate "\t\t-P: report per-partition disk statistics only,\n" 9107c478bd9Sstevel@tonic-gate "\t\t\tno per-device disk statistics\n" 9117c478bd9Sstevel@tonic-gate "\t\t-r: Display data in comma separated format\n" 9127c478bd9Sstevel@tonic-gate "\t\t-s: Suppress state change messages\n" 9137c478bd9Sstevel@tonic-gate "\t\t-T d|u Display a timestamp in date (d) or unix " 9147c478bd9Sstevel@tonic-gate "time_t (u)\n" 9157c478bd9Sstevel@tonic-gate "\t\t-t: display chars read/written to terminals\n" 9167c478bd9Sstevel@tonic-gate "\t\t-x: display extended disk statistics\n" 9177c478bd9Sstevel@tonic-gate "\t\t-X: display I/O path statistics\n" 9187c478bd9Sstevel@tonic-gate "\t\t-z: Suppress entries with all zero values\n"); 9197c478bd9Sstevel@tonic-gate exit(1); 9207c478bd9Sstevel@tonic-gate } 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9237c478bd9Sstevel@tonic-gate static void 9247c478bd9Sstevel@tonic-gate show_disk_errors(void *v1, void *v2, void *d) 9257c478bd9Sstevel@tonic-gate { 9267c478bd9Sstevel@tonic-gate struct iodev_snapshot *disk = (struct iodev_snapshot *)v2; 9277c478bd9Sstevel@tonic-gate kstat_named_t *knp; 9287c478bd9Sstevel@tonic-gate size_t col; 9297c478bd9Sstevel@tonic-gate int i, len; 9307c478bd9Sstevel@tonic-gate char *dev_name = disk->is_name; 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate if (disk->is_errors.ks_ndata == 0) 9337c478bd9Sstevel@tonic-gate return; 9347c478bd9Sstevel@tonic-gate if (disk->is_type == IODEV_CONTROLLER) 9357c478bd9Sstevel@tonic-gate return; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate if (disk->is_pretty) 9387c478bd9Sstevel@tonic-gate dev_name = disk->is_pretty; 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate len = strlen(dev_name); 9417c478bd9Sstevel@tonic-gate if (len > 20) 9427c478bd9Sstevel@tonic-gate push_out("%s ", dev_name); 9437c478bd9Sstevel@tonic-gate else if (len > 16) 9447c478bd9Sstevel@tonic-gate push_out("%-20.20s ", dev_name); 9457c478bd9Sstevel@tonic-gate else { 9467c478bd9Sstevel@tonic-gate if (do_conversions) 9477c478bd9Sstevel@tonic-gate push_out("%-16.16s ", dev_name); 9487c478bd9Sstevel@tonic-gate else 9497c478bd9Sstevel@tonic-gate push_out("%-9.9s ", dev_name); 9507c478bd9Sstevel@tonic-gate } 9517c478bd9Sstevel@tonic-gate col = 0; 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate knp = KSTAT_NAMED_PTR(&disk->is_errors); 9547c478bd9Sstevel@tonic-gate for (i = 0; i < disk->is_errors.ks_ndata; i++) { 9557c478bd9Sstevel@tonic-gate /* skip kstats that the driver did not kstat_named_init */ 9567c478bd9Sstevel@tonic-gate if (knp[i].name[0] == 0) 9577c478bd9Sstevel@tonic-gate continue; 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate col += strlen(knp[i].name); 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate switch (knp[i].data_type) { 9627c478bd9Sstevel@tonic-gate case KSTAT_DATA_CHAR: 9637c478bd9Sstevel@tonic-gate if ((strcmp(knp[i].name, "Serial No") == 0) && 9647c478bd9Sstevel@tonic-gate do_devid) { 9657c478bd9Sstevel@tonic-gate if (disk->is_devid) { 9667c478bd9Sstevel@tonic-gate push_out("Device Id: %s ", 9677c478bd9Sstevel@tonic-gate disk->is_devid); 9687c478bd9Sstevel@tonic-gate col += strlen(disk->is_devid); 9697c478bd9Sstevel@tonic-gate } else 9707c478bd9Sstevel@tonic-gate push_out("Device Id: "); 9717c478bd9Sstevel@tonic-gate } else { 9727c478bd9Sstevel@tonic-gate push_out("%s: %-.16s ", knp[i].name, 9737c478bd9Sstevel@tonic-gate &knp[i].value.c[0]); 9747c478bd9Sstevel@tonic-gate col += strlen(&knp[i].value.c[0]); 9757c478bd9Sstevel@tonic-gate } 9767c478bd9Sstevel@tonic-gate break; 9777c478bd9Sstevel@tonic-gate case KSTAT_DATA_ULONG: 9787c478bd9Sstevel@tonic-gate push_out("%s: %u ", knp[i].name, 9797c478bd9Sstevel@tonic-gate knp[i].value.ui32); 9807c478bd9Sstevel@tonic-gate col += 4; 9817c478bd9Sstevel@tonic-gate break; 9827c478bd9Sstevel@tonic-gate case KSTAT_DATA_ULONGLONG: 9837c478bd9Sstevel@tonic-gate if (strcmp(knp[i].name, "Size") == 0) { 9847c478bd9Sstevel@tonic-gate push_out("%s: %2.2fGB <%llu bytes>\n", 9857c478bd9Sstevel@tonic-gate knp[i].name, 9867c478bd9Sstevel@tonic-gate (float)knp[i].value.ui64 / 9877c478bd9Sstevel@tonic-gate DISK_GIGABYTE, 9887c478bd9Sstevel@tonic-gate knp[i].value.ui64); 9897c478bd9Sstevel@tonic-gate col = 0; 9907c478bd9Sstevel@tonic-gate break; 9917c478bd9Sstevel@tonic-gate } 9927c478bd9Sstevel@tonic-gate push_out("%s: %u ", knp[i].name, 9937c478bd9Sstevel@tonic-gate knp[i].value.ui32); 9947c478bd9Sstevel@tonic-gate col += 4; 9957c478bd9Sstevel@tonic-gate break; 9967c478bd9Sstevel@tonic-gate } 9977c478bd9Sstevel@tonic-gate if ((col >= 62) || (i == 2)) { 9987c478bd9Sstevel@tonic-gate do_newline(); 9997c478bd9Sstevel@tonic-gate col = 0; 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate } 10027c478bd9Sstevel@tonic-gate if (col > 0) { 10037c478bd9Sstevel@tonic-gate do_newline(); 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate do_newline(); 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate void 10097c478bd9Sstevel@tonic-gate do_args(int argc, char **argv) 10107c478bd9Sstevel@tonic-gate { 10117c478bd9Sstevel@tonic-gate int c; 10127c478bd9Sstevel@tonic-gate int errflg = 0; 10137c478bd9Sstevel@tonic-gate extern char *optarg; 10147c478bd9Sstevel@tonic-gate extern int optind; 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "tdDxXCciIpPnmMeEszrT:l:")) != EOF) 10177c478bd9Sstevel@tonic-gate switch (c) { 10187c478bd9Sstevel@tonic-gate case 't': 10197c478bd9Sstevel@tonic-gate do_tty++; 10207c478bd9Sstevel@tonic-gate break; 10217c478bd9Sstevel@tonic-gate case 'd': 10227c478bd9Sstevel@tonic-gate do_disk |= DISK_OLD; 10237c478bd9Sstevel@tonic-gate break; 10247c478bd9Sstevel@tonic-gate case 'D': 10257c478bd9Sstevel@tonic-gate do_disk |= DISK_NEW; 10267c478bd9Sstevel@tonic-gate break; 10277c478bd9Sstevel@tonic-gate case 'x': 10287c478bd9Sstevel@tonic-gate do_disk |= DISK_EXTENDED; 10297c478bd9Sstevel@tonic-gate break; 10307c478bd9Sstevel@tonic-gate case 'X': 10317c478bd9Sstevel@tonic-gate do_disk |= DISK_IOPATH; 10327c478bd9Sstevel@tonic-gate break; 10337c478bd9Sstevel@tonic-gate case 'C': 10347c478bd9Sstevel@tonic-gate do_controller++; 10357c478bd9Sstevel@tonic-gate break; 10367c478bd9Sstevel@tonic-gate case 'c': 10377c478bd9Sstevel@tonic-gate do_cpu++; 10387c478bd9Sstevel@tonic-gate break; 10397c478bd9Sstevel@tonic-gate case 'I': 10407c478bd9Sstevel@tonic-gate do_interval++; 10417c478bd9Sstevel@tonic-gate break; 10427c478bd9Sstevel@tonic-gate case 'p': 10437c478bd9Sstevel@tonic-gate do_partitions++; 10447c478bd9Sstevel@tonic-gate break; 10457c478bd9Sstevel@tonic-gate case 'P': 10467c478bd9Sstevel@tonic-gate do_partitions_only++; 10477c478bd9Sstevel@tonic-gate break; 10487c478bd9Sstevel@tonic-gate case 'n': 10497c478bd9Sstevel@tonic-gate do_conversions++; 10507c478bd9Sstevel@tonic-gate break; 10517c478bd9Sstevel@tonic-gate case 'M': 10527c478bd9Sstevel@tonic-gate do_megabytes++; 10537c478bd9Sstevel@tonic-gate break; 10547c478bd9Sstevel@tonic-gate case 'e': 10557c478bd9Sstevel@tonic-gate do_disk |= DISK_ERRORS; 10567c478bd9Sstevel@tonic-gate break; 10577c478bd9Sstevel@tonic-gate case 'E': 10587c478bd9Sstevel@tonic-gate do_disk |= DISK_EXTENDED_ERRORS; 10597c478bd9Sstevel@tonic-gate break; 10607c478bd9Sstevel@tonic-gate case 'i': 10617c478bd9Sstevel@tonic-gate do_devid = 1; 10627c478bd9Sstevel@tonic-gate break; 10637c478bd9Sstevel@tonic-gate case 's': 10647c478bd9Sstevel@tonic-gate suppress_state = 1; 10657c478bd9Sstevel@tonic-gate break; 10667c478bd9Sstevel@tonic-gate case 'z': 10677c478bd9Sstevel@tonic-gate suppress_zero = 1; 10687c478bd9Sstevel@tonic-gate break; 10697c478bd9Sstevel@tonic-gate case 'm': 10707c478bd9Sstevel@tonic-gate show_mountpts = 1; 10717c478bd9Sstevel@tonic-gate break; 10727c478bd9Sstevel@tonic-gate case 'T': 10737c478bd9Sstevel@tonic-gate if (optarg) { 10747c478bd9Sstevel@tonic-gate if (*optarg == 'u') 10757c478bd9Sstevel@tonic-gate do_timestamp = UDATE; 10767c478bd9Sstevel@tonic-gate else if (*optarg == 'd') 10777c478bd9Sstevel@tonic-gate do_timestamp = CDATE; 10787c478bd9Sstevel@tonic-gate else 10797c478bd9Sstevel@tonic-gate errflg++; 10807c478bd9Sstevel@tonic-gate } else 10817c478bd9Sstevel@tonic-gate errflg++; 10827c478bd9Sstevel@tonic-gate break; 10837c478bd9Sstevel@tonic-gate case 'r': 10847c478bd9Sstevel@tonic-gate do_raw = 1; 10857c478bd9Sstevel@tonic-gate break; 10867c478bd9Sstevel@tonic-gate case 'l': 10877c478bd9Sstevel@tonic-gate df.if_max_iodevs = safe_strtoi(optarg, "invalid limit"); 10887c478bd9Sstevel@tonic-gate if (df.if_max_iodevs < 1) 10897c478bd9Sstevel@tonic-gate usage(); 10907c478bd9Sstevel@tonic-gate break; 10917c478bd9Sstevel@tonic-gate case '?': 10927c478bd9Sstevel@tonic-gate errflg++; 10937c478bd9Sstevel@tonic-gate } 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate if ((do_disk & DISK_OLD) && (do_disk & DISK_NEW)) { 10967c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "-d and -D are incompatible.\n"); 10977c478bd9Sstevel@tonic-gate usage(); 10987c478bd9Sstevel@tonic-gate } 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate if (errflg) { 11017c478bd9Sstevel@tonic-gate usage(); 11027c478bd9Sstevel@tonic-gate } 11037c478bd9Sstevel@tonic-gate /* if no output classes explicity specified, use defaults */ 11047c478bd9Sstevel@tonic-gate if (do_tty == 0 && do_disk == 0 && do_cpu == 0) 11057c478bd9Sstevel@tonic-gate do_tty = do_cpu = 1, do_disk = DISK_OLD; 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate /* 11087c478bd9Sstevel@tonic-gate * If conflicting options take the preferred 11097c478bd9Sstevel@tonic-gate * -D and -x result in -x 11107c478bd9Sstevel@tonic-gate * -d or -D and -e or -E gives only whatever -d or -D was specified 11117c478bd9Sstevel@tonic-gate */ 11127c478bd9Sstevel@tonic-gate if ((do_disk & DISK_EXTENDED) && (do_disk & DISK_NORMAL)) 11137c478bd9Sstevel@tonic-gate do_disk &= ~DISK_NORMAL; 11147c478bd9Sstevel@tonic-gate if ((do_disk & DISK_NORMAL) && (do_disk & DISK_ERROR_MASK)) 11157c478bd9Sstevel@tonic-gate do_disk &= ~DISK_ERROR_MASK; 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate /* 11187c478bd9Sstevel@tonic-gate * I/O path stats are only available with extended (-x) stats 11197c478bd9Sstevel@tonic-gate */ 11207c478bd9Sstevel@tonic-gate if ((do_disk & DISK_IOPATH) && !(do_disk & DISK_EXTENDED)) 11217c478bd9Sstevel@tonic-gate do_disk &= ~DISK_IOPATH; 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate /* nfs, tape, always shown */ 11247c478bd9Sstevel@tonic-gate df.if_allowed_types = IODEV_NFS | IODEV_TAPE; 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate /* 11277c478bd9Sstevel@tonic-gate * If limit == 0 then no command line limit was set, else if any of 11287c478bd9Sstevel@tonic-gate * the flags that cause unlimited disks were not set, 11297c478bd9Sstevel@tonic-gate * use the default of 4 11307c478bd9Sstevel@tonic-gate */ 11317c478bd9Sstevel@tonic-gate if (df.if_max_iodevs == 0) { 11327c478bd9Sstevel@tonic-gate df.if_max_iodevs = DEFAULT_LIMIT; 11337c478bd9Sstevel@tonic-gate df.if_skip_floppy = 1; 11347c478bd9Sstevel@tonic-gate if (do_disk & (DISK_EXTENDED | DISK_ERRORS | 11357c478bd9Sstevel@tonic-gate DISK_EXTENDED_ERRORS)) { 11367c478bd9Sstevel@tonic-gate df.if_max_iodevs = UNLIMITED_IODEVS; 11377c478bd9Sstevel@tonic-gate df.if_skip_floppy = 0; 11387c478bd9Sstevel@tonic-gate } 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate if (do_disk) { 11417c478bd9Sstevel@tonic-gate size_t count = 0; 11427c478bd9Sstevel@tonic-gate size_t i = optind; 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate while (i < argc && !isdigit(argv[i][0])) { 11457c478bd9Sstevel@tonic-gate count++; 11467c478bd9Sstevel@tonic-gate i++; 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate /* 11507c478bd9Sstevel@tonic-gate * "Note: disks explicitly requested 11517c478bd9Sstevel@tonic-gate * are not subject to this disk limit" 11527c478bd9Sstevel@tonic-gate */ 11537c478bd9Sstevel@tonic-gate if (count > df.if_max_iodevs) 11547c478bd9Sstevel@tonic-gate df.if_max_iodevs = count; 11557c478bd9Sstevel@tonic-gate df.if_names = safe_alloc(count * sizeof (char *)); 11567c478bd9Sstevel@tonic-gate (void) memset(df.if_names, 0, count * sizeof (char *)); 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate while (optind < argc && !isdigit(argv[optind][0])) 11597c478bd9Sstevel@tonic-gate df.if_names[df.if_nr_names++] = argv[optind++]; 11607c478bd9Sstevel@tonic-gate } 11617c478bd9Sstevel@tonic-gate if (optind < argc) { 11627c478bd9Sstevel@tonic-gate interval = safe_strtoi(argv[optind], "invalid interval"); 11637c478bd9Sstevel@tonic-gate if (interval < 1) 11647c478bd9Sstevel@tonic-gate fail(0, "invalid interval"); 11657c478bd9Sstevel@tonic-gate optind++; 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate if (optind < argc) { 11687c478bd9Sstevel@tonic-gate iter = safe_strtoi(argv[optind], "invalid count"); 11697c478bd9Sstevel@tonic-gate if (iter < 1) 11707c478bd9Sstevel@tonic-gate fail(0, "invalid count"); 11717c478bd9Sstevel@tonic-gate optind++; 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate } 11747c478bd9Sstevel@tonic-gate if (interval == 0) 11757c478bd9Sstevel@tonic-gate iter = 1; 11767c478bd9Sstevel@tonic-gate if (optind < argc) 11777c478bd9Sstevel@tonic-gate usage(); 11787c478bd9Sstevel@tonic-gate } 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate /* 11817c478bd9Sstevel@tonic-gate * Driver for doing the extended header formatting. Will produce 11827c478bd9Sstevel@tonic-gate * the function stack needed to output an extended header based 11837c478bd9Sstevel@tonic-gate * on the options selected. 11847c478bd9Sstevel@tonic-gate */ 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate void 11877c478bd9Sstevel@tonic-gate do_format(void) 11887c478bd9Sstevel@tonic-gate { 11897c478bd9Sstevel@tonic-gate char header[SMALL_SCRATCH_BUFLEN]; 11907c478bd9Sstevel@tonic-gate char ch; 11917c478bd9Sstevel@tonic-gate char iosz; 11927c478bd9Sstevel@tonic-gate const char *fstr; 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate disk_header[0] = 0; 11957c478bd9Sstevel@tonic-gate ch = (do_interval ? 'i' : 's'); 11967c478bd9Sstevel@tonic-gate iosz = (do_megabytes ? 'M' : 'k'); 11977c478bd9Sstevel@tonic-gate if (do_disk & DISK_ERRORS) { 11987c478bd9Sstevel@tonic-gate if (do_raw == 0) { 11997c478bd9Sstevel@tonic-gate (void) sprintf(header, "s/w h/w trn tot "); 12007c478bd9Sstevel@tonic-gate } else 12017c478bd9Sstevel@tonic-gate (void) sprintf(header, "s/w,h/w,trn,tot"); 12027c478bd9Sstevel@tonic-gate } else 12037c478bd9Sstevel@tonic-gate *header = NULL; 12047c478bd9Sstevel@tonic-gate switch (do_disk & DISK_IO_MASK) { 12057c478bd9Sstevel@tonic-gate case DISK_OLD: 12067c478bd9Sstevel@tonic-gate if (do_raw == 0) 12077c478bd9Sstevel@tonic-gate fstr = "%cp%c tp%c serv "; 12087c478bd9Sstevel@tonic-gate else 12097c478bd9Sstevel@tonic-gate fstr = "%cp%c,tp%c,serv"; 12107c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, sizeof (disk_header), 12117c478bd9Sstevel@tonic-gate fstr, iosz, ch, ch); 12127c478bd9Sstevel@tonic-gate break; 12137c478bd9Sstevel@tonic-gate case DISK_NEW: 12147c478bd9Sstevel@tonic-gate if (do_raw == 0) 12157c478bd9Sstevel@tonic-gate fstr = "rp%c wp%c util "; 12167c478bd9Sstevel@tonic-gate else 12177c478bd9Sstevel@tonic-gate fstr = "%rp%c,wp%c,util"; 12187c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, sizeof (disk_header), 12197c478bd9Sstevel@tonic-gate fstr, ch, ch); 12207c478bd9Sstevel@tonic-gate break; 12217c478bd9Sstevel@tonic-gate case DISK_EXTENDED: 12227c478bd9Sstevel@tonic-gate if (!do_conversions) { 12237c478bd9Sstevel@tonic-gate if (do_raw == 0) 12247c478bd9Sstevel@tonic-gate fstr = "device r/%c w/%c " 12257c478bd9Sstevel@tonic-gate "%cr/%c %cw/%c wait actv " 12267c478bd9Sstevel@tonic-gate "svc_t %%%%w %%%%b %s"; 12277c478bd9Sstevel@tonic-gate else 12287c478bd9Sstevel@tonic-gate fstr = "device,r/%c,w/%c,%cr/%c,%cw/%c," 12297c478bd9Sstevel@tonic-gate "wait,actv,svc_t,%%%%w," 12307c478bd9Sstevel@tonic-gate "%%%%b,%s"; 12317c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, 12327c478bd9Sstevel@tonic-gate sizeof (disk_header), 12337c478bd9Sstevel@tonic-gate fstr, ch, ch, iosz, ch, iosz, 12347c478bd9Sstevel@tonic-gate ch, header); 12357c478bd9Sstevel@tonic-gate } else { 12367c478bd9Sstevel@tonic-gate if (do_raw == 0) { 12377c478bd9Sstevel@tonic-gate fstr = " r/%c w/%c %cr/%c " 12387c478bd9Sstevel@tonic-gate "%cw/%c wait actv wsvc_t asvc_t " 12397c478bd9Sstevel@tonic-gate "%%%%w %%%%b %sdevice"; 12407c478bd9Sstevel@tonic-gate } else { 12417c478bd9Sstevel@tonic-gate fstr = "r/%c,w/%c,%cr/%c,%cw/%c," 12427c478bd9Sstevel@tonic-gate "wait,actv,wsvc_t,asvc_t," 12437c478bd9Sstevel@tonic-gate "%%%%w,%%%%b,%sdevice"; 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, 12467c478bd9Sstevel@tonic-gate sizeof (disk_header), 12477c478bd9Sstevel@tonic-gate fstr, ch, ch, iosz, ch, iosz, 12487c478bd9Sstevel@tonic-gate ch, header); 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate break; 12517c478bd9Sstevel@tonic-gate default: 12527c478bd9Sstevel@tonic-gate break; 12537c478bd9Sstevel@tonic-gate } 1254*a08731ecScth 1255*a08731ecScth /* do DISK_ERRORS header (already added above for DISK_EXTENDED) */ 1256*a08731ecScth if ((do_disk & DISK_ERRORS) && 1257*a08731ecScth ((do_disk & DISK_IO_MASK) != DISK_EXTENDED)) { 12587c478bd9Sstevel@tonic-gate char *sep; 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate if (!do_conversions) { 12617c478bd9Sstevel@tonic-gate if (do_raw == 0) { 12627c478bd9Sstevel@tonic-gate sep = " "; 12637c478bd9Sstevel@tonic-gate } else 12647c478bd9Sstevel@tonic-gate sep = ","; 12657c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, sizeof (disk_header), 12667c478bd9Sstevel@tonic-gate "%s%s%s", "device", sep, header); 12677c478bd9Sstevel@tonic-gate } else { 12687c478bd9Sstevel@tonic-gate if (do_raw == 0) { 12697c478bd9Sstevel@tonic-gate (void) snprintf(disk_header, 12707c478bd9Sstevel@tonic-gate sizeof (disk_header), 1271*a08731ecScth " %sdevice", header); 1272*a08731ecScth } else { 1273*a08731ecScth (void) snprintf(disk_header, 1274*a08731ecScth sizeof (disk_header), 1275*a08731ecScth "%s,device", header); 1276*a08731ecScth } 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate } else { 12797c478bd9Sstevel@tonic-gate /* 12807c478bd9Sstevel@tonic-gate * Need to subtract two characters for the % escape in 12817c478bd9Sstevel@tonic-gate * the string. 12827c478bd9Sstevel@tonic-gate */ 12837c478bd9Sstevel@tonic-gate dh_len = strlen(disk_header) - 2; 12847c478bd9Sstevel@tonic-gate } 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate if (do_timestamp) 12877c478bd9Sstevel@tonic-gate setup(print_timestamp); 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate /* 12907c478bd9Sstevel@tonic-gate * -n *and* (-E *or* -e *or* -x) 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate if (do_conversions && (do_disk & PRINT_VERTICAL)) { 12937c478bd9Sstevel@tonic-gate if (do_tty) 12947c478bd9Sstevel@tonic-gate setup(print_tty_hdr1); 12957c478bd9Sstevel@tonic-gate if (do_cpu) 12967c478bd9Sstevel@tonic-gate setup(print_cpu_hdr1); 12977c478bd9Sstevel@tonic-gate if (do_tty || do_cpu) 12987c478bd9Sstevel@tonic-gate setup(do_newline); 12997c478bd9Sstevel@tonic-gate if (do_tty) 13007c478bd9Sstevel@tonic-gate setup(print_tty_hdr2); 13017c478bd9Sstevel@tonic-gate if (do_cpu) 13027c478bd9Sstevel@tonic-gate setup(print_cpu_hdr2); 13037c478bd9Sstevel@tonic-gate if (do_tty || do_cpu) 13047c478bd9Sstevel@tonic-gate setup(do_newline); 13057c478bd9Sstevel@tonic-gate if (do_tty) 13067c478bd9Sstevel@tonic-gate setup(print_tty_data); 13077c478bd9Sstevel@tonic-gate if (do_cpu) 13087c478bd9Sstevel@tonic-gate setup(print_cpu_data); 13097c478bd9Sstevel@tonic-gate if (do_tty || do_cpu) 13107c478bd9Sstevel@tonic-gate setup(do_newline); 13117c478bd9Sstevel@tonic-gate printxhdr(); 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate setup(show_all_disks); 13147c478bd9Sstevel@tonic-gate } else { 13157c478bd9Sstevel@tonic-gate /* 13167c478bd9Sstevel@tonic-gate * These unholy gymnastics are necessary to place CPU/tty 13177c478bd9Sstevel@tonic-gate * data to the right of the disks/errors for the first 13187c478bd9Sstevel@tonic-gate * line in vertical mode. 13197c478bd9Sstevel@tonic-gate */ 13207c478bd9Sstevel@tonic-gate if (do_disk & PRINT_VERTICAL) { 13217c478bd9Sstevel@tonic-gate printxhdr(); 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate setup(show_first_disk); 13247c478bd9Sstevel@tonic-gate if (do_tty) 13257c478bd9Sstevel@tonic-gate setup(print_tty_data); 13267c478bd9Sstevel@tonic-gate if (do_cpu) 13277c478bd9Sstevel@tonic-gate setup(print_cpu_data); 13287c478bd9Sstevel@tonic-gate setup(do_newline); 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate setup(show_other_disks); 13317c478bd9Sstevel@tonic-gate } else { 13327c478bd9Sstevel@tonic-gate setup(hdrout); 13337c478bd9Sstevel@tonic-gate if (do_tty) 13347c478bd9Sstevel@tonic-gate setup(print_tty_data); 13357c478bd9Sstevel@tonic-gate setup(show_all_disks); 13367c478bd9Sstevel@tonic-gate if (do_cpu) 13377c478bd9Sstevel@tonic-gate setup(print_cpu_data); 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate setup(do_newline); 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate if (do_disk & DISK_EXTENDED_ERRORS) 13437c478bd9Sstevel@tonic-gate setup(disk_errors); 13447c478bd9Sstevel@tonic-gate } 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate /* 13477c478bd9Sstevel@tonic-gate * Add a new function to the list of functions 13487c478bd9Sstevel@tonic-gate * for this invocation. Once on the stack the 13497c478bd9Sstevel@tonic-gate * function is never removed nor does its place 13507c478bd9Sstevel@tonic-gate * change. 13517c478bd9Sstevel@tonic-gate */ 13527c478bd9Sstevel@tonic-gate void 13537c478bd9Sstevel@tonic-gate setup(void (*nfunc)(void)) 13547c478bd9Sstevel@tonic-gate { 13557c478bd9Sstevel@tonic-gate format_t *tmp; 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate tmp = safe_alloc(sizeof (format_t)); 13587c478bd9Sstevel@tonic-gate tmp->nfunc = nfunc; 13597c478bd9Sstevel@tonic-gate tmp->next = 0; 13607c478bd9Sstevel@tonic-gate if (formatter_end) 13617c478bd9Sstevel@tonic-gate formatter_end->next = tmp; 13627c478bd9Sstevel@tonic-gate else 13637c478bd9Sstevel@tonic-gate formatter_list = tmp; 13647c478bd9Sstevel@tonic-gate formatter_end = tmp; 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* 13697c478bd9Sstevel@tonic-gate * The functions after this comment are devoted to printing 13707c478bd9Sstevel@tonic-gate * various parts of the header. They are selected based on the 13717c478bd9Sstevel@tonic-gate * options provided when the program was invoked. The functions 13727c478bd9Sstevel@tonic-gate * are either directly invoked in printhdr() or are indirectly 13737c478bd9Sstevel@tonic-gate * invoked by being placed on the list of functions used when 13747c478bd9Sstevel@tonic-gate * extended headers are used. 13757c478bd9Sstevel@tonic-gate */ 13767c478bd9Sstevel@tonic-gate void 13777c478bd9Sstevel@tonic-gate print_tty_hdr1(void) 13787c478bd9Sstevel@tonic-gate { 13797c478bd9Sstevel@tonic-gate char *fstr; 13807c478bd9Sstevel@tonic-gate char *dstr; 13817c478bd9Sstevel@tonic-gate 13827c478bd9Sstevel@tonic-gate if (do_raw == 0) { 13837c478bd9Sstevel@tonic-gate fstr = "%10.10s"; 13847c478bd9Sstevel@tonic-gate dstr = "tty "; 13857c478bd9Sstevel@tonic-gate } else { 13867c478bd9Sstevel@tonic-gate fstr = "%s"; 13877c478bd9Sstevel@tonic-gate dstr = "tty"; 13887c478bd9Sstevel@tonic-gate } 13897c478bd9Sstevel@tonic-gate push_out(fstr, dstr); 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate void 13937c478bd9Sstevel@tonic-gate print_tty_hdr2(void) 13947c478bd9Sstevel@tonic-gate { 13957c478bd9Sstevel@tonic-gate if (do_raw == 0) 13967c478bd9Sstevel@tonic-gate push_out("%-10.10s", " tin tout"); 13977c478bd9Sstevel@tonic-gate else 13987c478bd9Sstevel@tonic-gate push_out("tin,tout"); 13997c478bd9Sstevel@tonic-gate } 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate void 14027c478bd9Sstevel@tonic-gate print_cpu_hdr1(void) 14037c478bd9Sstevel@tonic-gate { 14047c478bd9Sstevel@tonic-gate char *dstr; 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate if (do_raw == 0) 14077c478bd9Sstevel@tonic-gate dstr = " cpu"; 14087c478bd9Sstevel@tonic-gate else 14097c478bd9Sstevel@tonic-gate dstr = "cpu"; 14107c478bd9Sstevel@tonic-gate push_out(dstr); 14117c478bd9Sstevel@tonic-gate } 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate void 14147c478bd9Sstevel@tonic-gate print_cpu_hdr2(void) 14157c478bd9Sstevel@tonic-gate { 14167c478bd9Sstevel@tonic-gate char *dstr; 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate if (do_raw == 0) 14197c478bd9Sstevel@tonic-gate dstr = " us sy wt id"; 14207c478bd9Sstevel@tonic-gate else 14217c478bd9Sstevel@tonic-gate dstr = "us,sy,wt,id"; 14227c478bd9Sstevel@tonic-gate push_out(dstr); 14237c478bd9Sstevel@tonic-gate } 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate /* 14267c478bd9Sstevel@tonic-gate * Assumption is that tty data is always first - no need for raw mode leading 14277c478bd9Sstevel@tonic-gate * comma. 14287c478bd9Sstevel@tonic-gate */ 14297c478bd9Sstevel@tonic-gate void 14307c478bd9Sstevel@tonic-gate print_tty_data(void) 14317c478bd9Sstevel@tonic-gate { 14327c478bd9Sstevel@tonic-gate char *fstr; 14337c478bd9Sstevel@tonic-gate uint64_t deltas; 14347c478bd9Sstevel@tonic-gate double raw; 14357c478bd9Sstevel@tonic-gate double outch; 14367c478bd9Sstevel@tonic-gate kstat_t *oldks = NULL; 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate if (oldss) 14397c478bd9Sstevel@tonic-gate oldks = &oldss->s_sys.ss_agg_sys; 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate if (do_raw == 0) 14427c478bd9Sstevel@tonic-gate fstr = " %3.0f %4.0f "; 14437c478bd9Sstevel@tonic-gate else 14447c478bd9Sstevel@tonic-gate fstr = "%.0f,%.0f"; 14457c478bd9Sstevel@tonic-gate deltas = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "rawch"); 14467c478bd9Sstevel@tonic-gate raw = deltas; 14477c478bd9Sstevel@tonic-gate raw /= getime; 14487c478bd9Sstevel@tonic-gate deltas = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "outch"); 14497c478bd9Sstevel@tonic-gate outch = deltas; 14507c478bd9Sstevel@tonic-gate outch /= getime; 14517c478bd9Sstevel@tonic-gate push_out(fstr, raw, outch); 14527c478bd9Sstevel@tonic-gate } 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate /* 14557c478bd9Sstevel@tonic-gate * Write out CPU data 14567c478bd9Sstevel@tonic-gate */ 14577c478bd9Sstevel@tonic-gate void 14587c478bd9Sstevel@tonic-gate print_cpu_data(void) 14597c478bd9Sstevel@tonic-gate { 14607c478bd9Sstevel@tonic-gate char *fstr; 14617c478bd9Sstevel@tonic-gate uint64_t idle; 14627c478bd9Sstevel@tonic-gate uint64_t user; 14637c478bd9Sstevel@tonic-gate uint64_t kern; 14647c478bd9Sstevel@tonic-gate uint64_t wait; 14657c478bd9Sstevel@tonic-gate kstat_t *oldks = NULL; 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate if (oldss) 14687c478bd9Sstevel@tonic-gate oldks = &oldss->s_sys.ss_agg_sys; 14697c478bd9Sstevel@tonic-gate 14707c478bd9Sstevel@tonic-gate if (do_raw == 0) 14717c478bd9Sstevel@tonic-gate fstr = " %2.0f %2.0f %2.0f %2.0f"; 14727c478bd9Sstevel@tonic-gate else 14737c478bd9Sstevel@tonic-gate fstr = "%.0f,%.0f,%.0f,%.0f"; 14747c478bd9Sstevel@tonic-gate 14757c478bd9Sstevel@tonic-gate idle = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_idle"); 14767c478bd9Sstevel@tonic-gate user = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_user"); 14777c478bd9Sstevel@tonic-gate kern = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_kernel"); 14787c478bd9Sstevel@tonic-gate wait = kstat_delta(oldks, &newss->s_sys.ss_agg_sys, "cpu_ticks_wait"); 14797c478bd9Sstevel@tonic-gate push_out(fstr, user * percent, kern * percent, 14807c478bd9Sstevel@tonic-gate wait * percent, idle * percent); 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate /* 14847c478bd9Sstevel@tonic-gate * Emit the appropriate header. 14857c478bd9Sstevel@tonic-gate */ 14867c478bd9Sstevel@tonic-gate void 14877c478bd9Sstevel@tonic-gate hdrout(void) 14887c478bd9Sstevel@tonic-gate { 14897c478bd9Sstevel@tonic-gate if (do_raw == 0) { 14907c478bd9Sstevel@tonic-gate if (--tohdr == 0) 14917c478bd9Sstevel@tonic-gate printhdr(0); 14927c478bd9Sstevel@tonic-gate } else if (hdr_out == 0) { 14937c478bd9Sstevel@tonic-gate printhdr(0); 14947c478bd9Sstevel@tonic-gate hdr_out = 1; 14957c478bd9Sstevel@tonic-gate } 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate /* 14997c478bd9Sstevel@tonic-gate * Write out disk errors when -E is specified. 15007c478bd9Sstevel@tonic-gate */ 15017c478bd9Sstevel@tonic-gate void 15027c478bd9Sstevel@tonic-gate disk_errors(void) 15037c478bd9Sstevel@tonic-gate { 15047c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk_errors, NULL); 15057c478bd9Sstevel@tonic-gate } 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate void 15087c478bd9Sstevel@tonic-gate show_first_disk(void) 15097c478bd9Sstevel@tonic-gate { 15107c478bd9Sstevel@tonic-gate int count = 0; 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate show_disk_mode = SHOW_FIRST_ONLY; 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count); 15157c478bd9Sstevel@tonic-gate } 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate void 15187c478bd9Sstevel@tonic-gate show_other_disks(void) 15197c478bd9Sstevel@tonic-gate { 15207c478bd9Sstevel@tonic-gate int count = 0; 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate show_disk_mode = SHOW_SECOND_ONWARDS; 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count); 15257c478bd9Sstevel@tonic-gate } 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate void 15287c478bd9Sstevel@tonic-gate show_all_disks(void) 15297c478bd9Sstevel@tonic-gate { 15307c478bd9Sstevel@tonic-gate int count = 0; 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate show_disk_mode = SHOW_ALL; 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate (void) snapshot_walk(SNAP_IODEVS, oldss, newss, show_disk, &count); 15357c478bd9Sstevel@tonic-gate } 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate /* 15387c478bd9Sstevel@tonic-gate * Write a newline out and clear the lineout flag. 15397c478bd9Sstevel@tonic-gate */ 15407c478bd9Sstevel@tonic-gate static void 15417c478bd9Sstevel@tonic-gate do_newline(void) 15427c478bd9Sstevel@tonic-gate { 15437c478bd9Sstevel@tonic-gate if (lineout) { 15447c478bd9Sstevel@tonic-gate (void) putchar('\n'); 15457c478bd9Sstevel@tonic-gate lineout = 0; 15467c478bd9Sstevel@tonic-gate } 15477c478bd9Sstevel@tonic-gate } 15487c478bd9Sstevel@tonic-gate 15497c478bd9Sstevel@tonic-gate /* 15507c478bd9Sstevel@tonic-gate * Generalized printf function that determines what extra 15517c478bd9Sstevel@tonic-gate * to print out if we're in raw mode. At this time we 15527c478bd9Sstevel@tonic-gate * don't care about errors. 15537c478bd9Sstevel@tonic-gate */ 15547c478bd9Sstevel@tonic-gate static void 15557c478bd9Sstevel@tonic-gate push_out(const char *message, ...) 15567c478bd9Sstevel@tonic-gate { 15577c478bd9Sstevel@tonic-gate va_list args; 15587c478bd9Sstevel@tonic-gate 15597c478bd9Sstevel@tonic-gate va_start(args, message); 15607c478bd9Sstevel@tonic-gate if (do_raw && lineout == 1) 15617c478bd9Sstevel@tonic-gate (void) putchar(','); 15627c478bd9Sstevel@tonic-gate (void) vprintf(message, args); 15637c478bd9Sstevel@tonic-gate va_end(args); 15647c478bd9Sstevel@tonic-gate lineout = 1; 15657c478bd9Sstevel@tonic-gate } 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate /* 15687c478bd9Sstevel@tonic-gate * Emit the header string when -e is specified. 15697c478bd9Sstevel@tonic-gate */ 15707c478bd9Sstevel@tonic-gate static void 15717c478bd9Sstevel@tonic-gate print_err_hdr(void) 15727c478bd9Sstevel@tonic-gate { 15737c478bd9Sstevel@tonic-gate char obuf[SMALL_SCRATCH_BUFLEN]; 15747c478bd9Sstevel@tonic-gate 1575*a08731ecScth if (do_raw) { 1576*a08731ecScth push_out("errors"); 1577*a08731ecScth return; 1578*a08731ecScth } 1579*a08731ecScth 15807c478bd9Sstevel@tonic-gate if (do_conversions == 0) { 15817c478bd9Sstevel@tonic-gate if (!(do_disk & DISK_EXTENDED)) { 15827c478bd9Sstevel@tonic-gate (void) snprintf(obuf, sizeof (obuf), 15837c478bd9Sstevel@tonic-gate "%11s", one_blank); 15847c478bd9Sstevel@tonic-gate push_out(obuf); 15857c478bd9Sstevel@tonic-gate } 15867c478bd9Sstevel@tonic-gate } else if (do_disk == DISK_ERRORS) 15877c478bd9Sstevel@tonic-gate push_out(two_blanks); 15887c478bd9Sstevel@tonic-gate else 15897c478bd9Sstevel@tonic-gate push_out(one_blank); 15907c478bd9Sstevel@tonic-gate push_out("---- errors --- "); 15917c478bd9Sstevel@tonic-gate } 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate /* 15947c478bd9Sstevel@tonic-gate * Emit the header string when -e is specified. 15957c478bd9Sstevel@tonic-gate */ 15967c478bd9Sstevel@tonic-gate static void 15977c478bd9Sstevel@tonic-gate print_disk_header(void) 15987c478bd9Sstevel@tonic-gate { 15997c478bd9Sstevel@tonic-gate push_out(disk_header); 16007c478bd9Sstevel@tonic-gate } 16017c478bd9Sstevel@tonic-gate 16027c478bd9Sstevel@tonic-gate /* 16037c478bd9Sstevel@tonic-gate * Write out a timestamp. Format is all that goes out on 16047c478bd9Sstevel@tonic-gate * the line so no use of push_out. 16057c478bd9Sstevel@tonic-gate * 16067c478bd9Sstevel@tonic-gate * Write out as decimal reprentation of time_t value 16077c478bd9Sstevel@tonic-gate * (-T u was specified) or the string returned from 16087c478bd9Sstevel@tonic-gate * ctime() (-T d was specified). 16097c478bd9Sstevel@tonic-gate */ 16107c478bd9Sstevel@tonic-gate static void 16117c478bd9Sstevel@tonic-gate print_timestamp(void) 16127c478bd9Sstevel@tonic-gate { 16137c478bd9Sstevel@tonic-gate time_t t; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate if (time(&t) != -1) { 16167c478bd9Sstevel@tonic-gate if (do_timestamp == UDATE) { 16177c478bd9Sstevel@tonic-gate (void) printf("%ld\n", t); 16187c478bd9Sstevel@tonic-gate } else if (do_timestamp == CDATE) { 16197c478bd9Sstevel@tonic-gate char *cpt; 16207c478bd9Sstevel@tonic-gate 16217c478bd9Sstevel@tonic-gate cpt = ctime(&t); 16227c478bd9Sstevel@tonic-gate if (cpt) { 16237c478bd9Sstevel@tonic-gate (void) fputs(cpt, stdout); 16247c478bd9Sstevel@tonic-gate } 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate } 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate /* 16307c478bd9Sstevel@tonic-gate * No, UINTMAX_MAX isn't the right thing here since 16317c478bd9Sstevel@tonic-gate * it is #defined to be either INT32_MAX or INT64_MAX 16327c478bd9Sstevel@tonic-gate * depending on the whether _LP64 is defined. 16337c478bd9Sstevel@tonic-gate * 16347c478bd9Sstevel@tonic-gate * We want to handle the odd future case of having 16357c478bd9Sstevel@tonic-gate * ulonglong_t be more than 64 bits but we have 16367c478bd9Sstevel@tonic-gate * no nice #define MAX value we can drop in place 16377c478bd9Sstevel@tonic-gate * without having to change this code in the future. 16387c478bd9Sstevel@tonic-gate */ 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate u_longlong_t 16417c478bd9Sstevel@tonic-gate ull_delta(u_longlong_t old, u_longlong_t new) 16427c478bd9Sstevel@tonic-gate { 16437c478bd9Sstevel@tonic-gate if (new >= old) 16447c478bd9Sstevel@tonic-gate return (new - old); 16457c478bd9Sstevel@tonic-gate else 16467c478bd9Sstevel@tonic-gate return ((UINT64_MAX - old) + new + 1); 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate /* 16507c478bd9Sstevel@tonic-gate * Return the number of ticks delta between two hrtime_t 16517c478bd9Sstevel@tonic-gate * values. Attempt to cater for various kinds of overflow 16527c478bd9Sstevel@tonic-gate * in hrtime_t - no matter how improbable. 16537c478bd9Sstevel@tonic-gate */ 16547c478bd9Sstevel@tonic-gate uint64_t 16557c478bd9Sstevel@tonic-gate hrtime_delta(hrtime_t old, hrtime_t new) 16567c478bd9Sstevel@tonic-gate { 16577c478bd9Sstevel@tonic-gate uint64_t del; 16587c478bd9Sstevel@tonic-gate 16597c478bd9Sstevel@tonic-gate if ((new >= old) && (old >= 0L)) 16607c478bd9Sstevel@tonic-gate return (new - old); 16617c478bd9Sstevel@tonic-gate else { 16627c478bd9Sstevel@tonic-gate /* 16637c478bd9Sstevel@tonic-gate * We've overflowed the positive portion of an 16647c478bd9Sstevel@tonic-gate * hrtime_t. 16657c478bd9Sstevel@tonic-gate */ 16667c478bd9Sstevel@tonic-gate if (new < 0L) { 16677c478bd9Sstevel@tonic-gate /* 16687c478bd9Sstevel@tonic-gate * The new value is negative. Handle the 16697c478bd9Sstevel@tonic-gate * case where the old value is positive or 16707c478bd9Sstevel@tonic-gate * negative. 16717c478bd9Sstevel@tonic-gate */ 16727c478bd9Sstevel@tonic-gate uint64_t n1; 16737c478bd9Sstevel@tonic-gate uint64_t o1; 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate n1 = -new; 16767c478bd9Sstevel@tonic-gate if (old > 0L) 16777c478bd9Sstevel@tonic-gate return (n1 - old); 16787c478bd9Sstevel@tonic-gate else { 16797c478bd9Sstevel@tonic-gate o1 = -old; 16807c478bd9Sstevel@tonic-gate del = n1 - o1; 16817c478bd9Sstevel@tonic-gate return (del); 16827c478bd9Sstevel@tonic-gate } 16837c478bd9Sstevel@tonic-gate } else { 16847c478bd9Sstevel@tonic-gate /* 16857c478bd9Sstevel@tonic-gate * Either we've just gone from being negative 16867c478bd9Sstevel@tonic-gate * to positive *or* the last entry was positive 16877c478bd9Sstevel@tonic-gate * and the new entry is also positive but *less* 16887c478bd9Sstevel@tonic-gate * than the old entry. This implies we waited 16897c478bd9Sstevel@tonic-gate * quite a few days on a very fast system between 16907c478bd9Sstevel@tonic-gate * iostat displays. 16917c478bd9Sstevel@tonic-gate */ 16927c478bd9Sstevel@tonic-gate if (old < 0L) { 16937c478bd9Sstevel@tonic-gate uint64_t o2; 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate o2 = -old; 16967c478bd9Sstevel@tonic-gate del = UINT64_MAX - o2; 16977c478bd9Sstevel@tonic-gate } else { 16987c478bd9Sstevel@tonic-gate del = UINT64_MAX - old; 16997c478bd9Sstevel@tonic-gate } 17007c478bd9Sstevel@tonic-gate del += new; 17017c478bd9Sstevel@tonic-gate return (del); 17027c478bd9Sstevel@tonic-gate } 17037c478bd9Sstevel@tonic-gate } 17047c478bd9Sstevel@tonic-gate } 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate /* 17077c478bd9Sstevel@tonic-gate * Take the difference of an unsigned 32 17087c478bd9Sstevel@tonic-gate * bit int attempting to cater for 17097c478bd9Sstevel@tonic-gate * overflow. 17107c478bd9Sstevel@tonic-gate */ 17117c478bd9Sstevel@tonic-gate uint_t 17127c478bd9Sstevel@tonic-gate u32_delta(uint_t old, uint_t new) 17137c478bd9Sstevel@tonic-gate { 17147c478bd9Sstevel@tonic-gate if (new >= old) 17157c478bd9Sstevel@tonic-gate return (new - old); 17167c478bd9Sstevel@tonic-gate else 17177c478bd9Sstevel@tonic-gate return ((UINT32_MAX - old) + new + 1); 17187c478bd9Sstevel@tonic-gate } 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate /* 17217c478bd9Sstevel@tonic-gate * Create and arm the timer. Used only when an interval has been specified. 17227c478bd9Sstevel@tonic-gate * Used in lieu of poll to ensure that we provide info for exactly the 17237c478bd9Sstevel@tonic-gate * desired period. 17247c478bd9Sstevel@tonic-gate */ 17257c478bd9Sstevel@tonic-gate void 17267c478bd9Sstevel@tonic-gate set_timer(int interval) 17277c478bd9Sstevel@tonic-gate { 17287c478bd9Sstevel@tonic-gate timer_t t_id; 17297c478bd9Sstevel@tonic-gate itimerspec_t time_struct; 17307c478bd9Sstevel@tonic-gate struct sigevent sig_struct; 17317c478bd9Sstevel@tonic-gate struct sigaction act; 17327c478bd9Sstevel@tonic-gate 17337c478bd9Sstevel@tonic-gate bzero(&sig_struct, sizeof (struct sigevent)); 17347c478bd9Sstevel@tonic-gate bzero(&act, sizeof (struct sigaction)); 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate /* Create timer */ 17377c478bd9Sstevel@tonic-gate sig_struct.sigev_notify = SIGEV_SIGNAL; 17387c478bd9Sstevel@tonic-gate sig_struct.sigev_signo = SIGUSR1; 17397c478bd9Sstevel@tonic-gate sig_struct.sigev_value.sival_int = 0; 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate if (timer_create(CLOCK_REALTIME, &sig_struct, &t_id) != 0) { 17427c478bd9Sstevel@tonic-gate fail(1, "Timer creation failed"); 17437c478bd9Sstevel@tonic-gate } 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate act.sa_handler = handle_sig; 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if (sigaction(SIGUSR1, &act, NULL) != 0) { 17487c478bd9Sstevel@tonic-gate fail(1, "Could not set up signal handler"); 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate time_struct.it_value.tv_sec = interval; 17527c478bd9Sstevel@tonic-gate time_struct.it_value.tv_nsec = 0; 17537c478bd9Sstevel@tonic-gate time_struct.it_interval.tv_sec = interval; 17547c478bd9Sstevel@tonic-gate time_struct.it_interval.tv_nsec = 0; 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate /* Arm timer */ 17577c478bd9Sstevel@tonic-gate if ((timer_settime(t_id, 0, &time_struct, NULL)) != 0) { 17587c478bd9Sstevel@tonic-gate fail(1, "Setting timer failed"); 17597c478bd9Sstevel@tonic-gate } 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate /* ARGSUSED */ 17627c478bd9Sstevel@tonic-gate void 17637c478bd9Sstevel@tonic-gate handle_sig(int x) 17647c478bd9Sstevel@tonic-gate { 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * This is exactly what is needed for standard iostat output, 17697c478bd9Sstevel@tonic-gate * but make sure to use it only for that 17707c478bd9Sstevel@tonic-gate */ 17717c478bd9Sstevel@tonic-gate #define EPSILON (0.1) 17727c478bd9Sstevel@tonic-gate static int 17737c478bd9Sstevel@tonic-gate fzero(double value) 17747c478bd9Sstevel@tonic-gate { 17757c478bd9Sstevel@tonic-gate return (value >= 0.0 && value < EPSILON); 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate static int 17797c478bd9Sstevel@tonic-gate safe_strtoi(char const *val, char *errmsg) 17807c478bd9Sstevel@tonic-gate { 17817c478bd9Sstevel@tonic-gate char *end; 17827c478bd9Sstevel@tonic-gate long tmp; 17837c478bd9Sstevel@tonic-gate 17847c478bd9Sstevel@tonic-gate errno = 0; 17857c478bd9Sstevel@tonic-gate tmp = strtol(val, &end, 10); 17867c478bd9Sstevel@tonic-gate if (*end != '\0' || errno) 17877c478bd9Sstevel@tonic-gate fail(0, "%s %s", errmsg, val); 17887c478bd9Sstevel@tonic-gate return ((int)tmp); 17897c478bd9Sstevel@tonic-gate } 1790