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