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