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