1 /* 2 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* 7 * Copyright (c) 1980 Regents of the University of California. 8 * All rights reserved. The Berkeley software License Agreement 9 * specifies the terms and conditions for redistribution. 10 */ 11 12 /* from UCB 5.4 5/17/86 */ 13 /* from SunOS 4.1, SID 1.31 */ 14 15 #include <stdio.h> 16 #include <stdlib.h> 17 #include <stdarg.h> 18 #include <ctype.h> 19 #include <unistd.h> 20 #include <memory.h> 21 #include <string.h> 22 #include <fcntl.h> 23 #include <errno.h> 24 #include <signal.h> 25 #include <values.h> 26 #include <poll.h> 27 #include <locale.h> 28 29 #include "statcommon.h" 30 31 char *cmdname = "vmstat"; 32 int caught_cont = 0; 33 34 extern uint_t timestamp_fmt; 35 36 static int hz; 37 static int pagesize; 38 static double etime; 39 static int lines = 1; 40 static int swflag = 0, cflag = 0, pflag = 0; 41 static int suppress_state; 42 static long iter = 0; 43 static hrtime_t period_n = 0; 44 static struct snapshot *ss; 45 46 struct iodev_filter df; 47 48 #define pgtok(a) ((a) * (pagesize >> 10)) 49 #define denom(x) ((x) ? (x) : 1) 50 #define REPRINT 19 51 52 static void dovmstats(struct snapshot *old, struct snapshot *new); 53 static void printhdr(int); 54 static void dosum(struct sys_snapshot *ss); 55 static void dointr(struct snapshot *ss); 56 static void docachestats(kstat_ctl_t *kc, hrtime_t interval, int forever); 57 static void usage(void); 58 59 int 60 main(int argc, char **argv) 61 { 62 struct snapshot *old = NULL; 63 enum snapshot_types types = SNAP_SYSTEM; 64 int summary = 0; 65 int intr = 0; 66 kstat_ctl_t *kc; 67 int forever = 0; 68 hrtime_t start_n; 69 int c; 70 71 (void) setlocale(LC_ALL, ""); 72 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 73 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 74 #endif 75 (void) textdomain(TEXT_DOMAIN); 76 77 pagesize = sysconf(_SC_PAGESIZE); 78 hz = sysconf(_SC_CLK_TCK); 79 80 while ((c = getopt(argc, argv, "cipqsST:")) != EOF) 81 switch (c) { 82 case 'S': 83 swflag = !swflag; 84 break; 85 case 's': 86 summary = 1; 87 break; 88 case 'i': 89 intr = 1; 90 break; 91 case 'c': 92 cflag++; 93 break; 94 case 'q': 95 suppress_state = 1; 96 break; 97 case 'p': 98 pflag++; /* detailed paging info */ 99 break; 100 case 'T': 101 if (optarg) { 102 if (*optarg == 'u') 103 timestamp_fmt = UDATE; 104 else if (*optarg == 'd') 105 timestamp_fmt = DDATE; 106 else 107 usage(); 108 } else { 109 usage(); 110 } 111 break; 112 default: 113 usage(); 114 } 115 116 argc -= optind; 117 argv += optind; 118 119 /* consistency with iostat */ 120 types |= SNAP_CPUS; 121 122 if (intr) 123 types |= SNAP_INTERRUPTS; 124 if (cflag) 125 types |= SNAP_FLUSHES; 126 if (!intr) 127 types |= SNAP_IODEVS; 128 129 /* max to fit in less than 80 characters */ 130 df.if_max_iodevs = 4; 131 df.if_allowed_types = IODEV_DISK; 132 df.if_nr_names = 0; 133 df.if_names = safe_alloc(df.if_max_iodevs * sizeof (char *)); 134 (void) memset(df.if_names, 0, df.if_max_iodevs * sizeof (char *)); 135 136 while (argc > 0 && !isdigit(argv[0][0]) && 137 df.if_nr_names < df.if_max_iodevs) { 138 df.if_names[df.if_nr_names] = *argv; 139 df.if_nr_names++; 140 argc--, argv++; 141 } 142 143 kc = open_kstat(); 144 145 start_n = gethrtime(); 146 147 ss = acquire_snapshot(kc, types, &df); 148 149 /* time, in seconds, since boot */ 150 etime = ss->s_sys.ss_ticks / hz; 151 152 if (intr) { 153 dointr(ss); 154 free_snapshot(ss); 155 exit(0); 156 } 157 if (summary) { 158 dosum(&ss->s_sys); 159 free_snapshot(ss); 160 exit(0); 161 } 162 163 if (argc > 0) { 164 long interval; 165 char *endptr; 166 167 errno = 0; 168 interval = strtol(argv[0], &endptr, 10); 169 170 if (errno > 0 || *endptr != '\0' || interval <= 0 || 171 interval > MAXINT) 172 usage(); 173 period_n = (hrtime_t)interval * NANOSEC; 174 if (period_n <= 0) 175 usage(); 176 iter = MAXLONG; 177 if (argc > 1) { 178 iter = strtol(argv[1], NULL, 10); 179 if (errno > 0 || *endptr != '\0' || iter <= 0) 180 usage(); 181 } else 182 forever = 1; 183 if (argc > 2) 184 usage(); 185 } 186 187 if (cflag) { 188 free_snapshot(ss); 189 docachestats(kc, period_n, forever); 190 exit(0); 191 } 192 193 (void) sigset(SIGCONT, printhdr); 194 195 dovmstats(old, ss); 196 while (forever || --iter > 0) { 197 /* (void) poll(NULL, 0, poll_interval); */ 198 199 /* Have a kip */ 200 sleep_until(&start_n, period_n, forever, &caught_cont); 201 202 free_snapshot(old); 203 old = ss; 204 ss = acquire_snapshot(kc, types, &df); 205 206 if (!suppress_state) 207 snapshot_report_changes(old, ss); 208 209 /* if config changed, show stats from boot */ 210 if (snapshot_has_changed(old, ss)) { 211 free_snapshot(old); 212 old = NULL; 213 } 214 215 dovmstats(old, ss); 216 } 217 218 free_snapshot(old); 219 free_snapshot(ss); 220 free(df.if_names); 221 (void) kstat_close(kc); 222 return (0); 223 } 224 225 #define DELTA(v) (new->v - (old ? old->v : 0)) 226 #define ADJ(n) ((adj <= 0) ? n : (adj >= n) ? 1 : n - adj) 227 #define adjprintf(fmt, n, val) adj -= (n + 1) - printf(fmt, ADJ(n), val) 228 229 static int adj; /* number of excess columns */ 230 231 /*ARGSUSED*/ 232 static void 233 show_disk(void *v1, void *v2, void *d) 234 { 235 struct iodev_snapshot *old = (struct iodev_snapshot *)v1; 236 struct iodev_snapshot *new = (struct iodev_snapshot *)v2; 237 hrtime_t oldtime = new->is_crtime; 238 double hr_etime; 239 double reads, writes; 240 241 if (new == NULL) 242 return; 243 244 if (old) 245 oldtime = old->is_stats.wlastupdate; 246 hr_etime = new->is_stats.wlastupdate - oldtime; 247 if (hr_etime == 0.0) 248 hr_etime = NANOSEC; 249 reads = new->is_stats.reads - (old ? old->is_stats.reads : 0); 250 writes = new->is_stats.writes - (old ? old->is_stats.writes : 0); 251 adjprintf(" %*.0f", 2, (reads + writes) / hr_etime * NANOSEC); 252 } 253 254 static void 255 dovmstats(struct snapshot *old, struct snapshot *new) 256 { 257 kstat_t *oldsys = NULL; 258 kstat_t *newsys = &new->s_sys.ss_agg_sys; 259 kstat_t *oldvm = NULL; 260 kstat_t *newvm = &new->s_sys.ss_agg_vm; 261 double percent_factor; 262 ulong_t updates; 263 int count; 264 265 adj = 0; 266 267 if (old) { 268 oldsys = &old->s_sys.ss_agg_sys; 269 oldvm = &old->s_sys.ss_agg_vm; 270 } 271 272 etime = cpu_ticks_delta(oldsys, newsys); 273 274 percent_factor = 100.0 / denom(etime); 275 /* 276 * If any time has passed, convert etime to seconds per CPU 277 */ 278 etime = etime >= 1.0 ? (etime / nr_active_cpus(new)) / hz : 1.0; 279 updates = denom(DELTA(s_sys.ss_sysinfo.updates)); 280 281 if (timestamp_fmt != NODATE) { 282 print_timestamp(); 283 lines--; 284 } 285 286 if (--lines <= 0) 287 printhdr(0); 288 289 adj = 0; 290 291 if (pflag) { 292 adjprintf(" %*u", 6, 293 pgtok((int)(DELTA(s_sys.ss_vminfo.swap_avail) / updates))); 294 adjprintf(" %*u", 5, 295 pgtok((int)(DELTA(s_sys.ss_vminfo.freemem) / updates))); 296 adjprintf(" %*.0f", 3, kstat_delta(oldvm, newvm, "pgrec") 297 / etime); 298 adjprintf(" %*.0f", 3, (kstat_delta(oldvm, newvm, "hat_fault") + 299 kstat_delta(oldvm, newvm, "as_fault")) / etime); 300 adjprintf(" %*.0f", 3, pgtok(kstat_delta(oldvm, newvm, "dfree")) 301 / etime); 302 adjprintf(" %*ld", 3, pgtok(new->s_sys.ss_deficit)); 303 adjprintf(" %*.0f", 3, kstat_delta(oldvm, newvm, "scan") 304 / etime); 305 adjprintf(" %*.0f", 4, 306 pgtok(kstat_delta(oldvm, newvm, "execpgin")) / etime); 307 adjprintf(" %*.0f", 4, 308 pgtok(kstat_delta(oldvm, newvm, "execpgout")) / etime); 309 adjprintf(" %*.0f", 4, 310 pgtok(kstat_delta(oldvm, newvm, "execfree")) / etime); 311 adjprintf(" %*.0f", 4, 312 pgtok(kstat_delta(oldvm, newvm, "anonpgin")) / etime); 313 adjprintf(" %*.0f", 4, 314 pgtok(kstat_delta(oldvm, newvm, "anonpgout")) / etime); 315 adjprintf(" %*.0f", 4, 316 pgtok(kstat_delta(oldvm, newvm, "anonfree")) / etime); 317 adjprintf(" %*.0f", 4, 318 pgtok(kstat_delta(oldvm, newvm, "fspgin")) / etime); 319 adjprintf(" %*.0f", 4, 320 pgtok(kstat_delta(oldvm, newvm, "fspgout")) / etime); 321 adjprintf(" %*.0f\n", 4, 322 pgtok(kstat_delta(oldvm, newvm, "fsfree")) / etime); 323 (void) fflush(stdout); 324 return; 325 } 326 327 adjprintf(" %*lu", 1, DELTA(s_sys.ss_sysinfo.runque) / updates); 328 adjprintf(" %*lu", 1, DELTA(s_sys.ss_sysinfo.waiting) / updates); 329 adjprintf(" %*lu", 1, DELTA(s_sys.ss_sysinfo.swpque) / updates); 330 adjprintf(" %*u", 6, pgtok((int)(DELTA(s_sys.ss_vminfo.swap_avail) 331 / updates))); 332 adjprintf(" %*u", 5, pgtok((int)(DELTA(s_sys.ss_vminfo.freemem) 333 / updates))); 334 adjprintf(" %*.0f", 3, swflag? 335 kstat_delta(oldvm, newvm, "swapin") / etime : 336 kstat_delta(oldvm, newvm, "pgrec") / etime); 337 adjprintf(" %*.0f", 3, swflag? 338 kstat_delta(oldvm, newvm, "swapout") / etime : 339 (kstat_delta(oldvm, newvm, "hat_fault") 340 + kstat_delta(oldvm, newvm, "as_fault")) 341 / etime); 342 adjprintf(" %*.0f", 2, pgtok(kstat_delta(oldvm, newvm, "pgpgin")) 343 / etime); 344 adjprintf(" %*.0f", 2, pgtok(kstat_delta(oldvm, newvm, "pgpgout")) 345 / etime); 346 adjprintf(" %*.0f", 2, pgtok(kstat_delta(oldvm, newvm, "dfree")) 347 / etime); 348 adjprintf(" %*ld", 2, pgtok(new->s_sys.ss_deficit)); 349 adjprintf(" %*.0f", 2, kstat_delta(oldvm, newvm, "scan") / etime); 350 351 (void) snapshot_walk(SNAP_IODEVS, old, new, show_disk, NULL); 352 353 count = df.if_max_iodevs - new->s_nr_iodevs; 354 while (count-- > 0) 355 adjprintf(" %*d", 2, 0); 356 357 adjprintf(" %*.0f", 4, kstat_delta(oldsys, newsys, "intr") / etime); 358 adjprintf(" %*.0f", 4, kstat_delta(oldsys, newsys, "syscall") / etime); 359 adjprintf(" %*.0f", 4, kstat_delta(oldsys, newsys, "pswitch") / etime); 360 adjprintf(" %*.0f", 2, 361 kstat_delta(oldsys, newsys, "cpu_ticks_user") * percent_factor); 362 adjprintf(" %*.0f", 2, kstat_delta(oldsys, newsys, "cpu_ticks_kernel") 363 * percent_factor); 364 adjprintf(" %*.0f\n", 2, (kstat_delta(oldsys, newsys, "cpu_ticks_idle") 365 + kstat_delta(oldsys, newsys, "cpu_ticks_wait")) 366 * percent_factor); 367 (void) fflush(stdout); 368 } 369 370 /*ARGSUSED*/ 371 static void 372 print_disk(void *v, void *v2, void *d) 373 { 374 struct iodev_snapshot *iodev = (struct iodev_snapshot *)v2; 375 376 if (iodev == NULL) 377 return; 378 379 (void) printf("%c%c ", iodev->is_name[0], iodev->is_name[2]); 380 } 381 382 /* ARGSUSED */ 383 static void 384 printhdr(int sig) 385 { 386 int i = df.if_max_iodevs - ss->s_nr_iodevs; 387 388 if (sig == SIGCONT) 389 caught_cont = 1; 390 391 if (pflag) { 392 (void) printf(" memory page "); 393 (void) printf("executable anonymous filesystem \n"); 394 (void) printf(" swap free re mf fr de sr "); 395 (void) printf("epi epo epf api apo apf fpi fpo fpf\n"); 396 lines = REPRINT; 397 return; 398 } 399 400 (void) printf(" kthr memory page "); 401 (void) printf("disk faults cpu\n"); 402 403 if (swflag) 404 (void) printf(" r b w swap free si so pi po fr de sr "); 405 else 406 (void) printf(" r b w swap free re mf pi po fr de sr "); 407 408 (void) snapshot_walk(SNAP_IODEVS, NULL, ss, print_disk, NULL); 409 410 while (i-- > 0) 411 (void) printf("-- "); 412 413 (void) printf(" in sy cs us sy id\n"); 414 lines = REPRINT; 415 } 416 417 static void 418 sum_out(char const *pretty, kstat_t *ks, char *name) 419 { 420 kstat_named_t *ksn = kstat_data_lookup(ks, name); 421 if (ksn == NULL) { 422 fail(0, "kstat_data_lookup('%s', '%s') failed", 423 ks->ks_name, name); 424 } 425 426 (void) printf("%9llu %s\n", ksn->value.ui64, pretty); 427 } 428 429 static void 430 dosum(struct sys_snapshot *ss) 431 { 432 uint64_t total_faults; 433 kstat_named_t *ksn; 434 long double nchtotal; 435 uint64_t nchhits; 436 437 sum_out("swap ins", &ss->ss_agg_vm, "swapin"); 438 sum_out("swap outs", &ss->ss_agg_vm, "swapout"); 439 sum_out("pages swapped in", &ss->ss_agg_vm, "pgswapin"); 440 sum_out("pages swapped out", &ss->ss_agg_vm, "pgswapout"); 441 442 ksn = kstat_data_lookup(&ss->ss_agg_vm, "hat_fault"); 443 if (ksn == NULL) { 444 fail(0, "kstat_data_lookup('%s', 'hat_fault') failed", 445 ss->ss_agg_vm.ks_name); 446 } 447 total_faults = ksn->value.ui64; 448 ksn = kstat_data_lookup(&ss->ss_agg_vm, "as_fault"); 449 if (ksn == NULL) { 450 fail(0, "kstat_data_lookup('%s', 'as_fault') failed", 451 ss->ss_agg_vm.ks_name); 452 } 453 total_faults += ksn->value.ui64; 454 455 (void) printf("%9llu total address trans. faults taken\n", 456 total_faults); 457 458 sum_out("page ins", &ss->ss_agg_vm, "pgin"); 459 sum_out("page outs", &ss->ss_agg_vm, "pgout"); 460 sum_out("pages paged in", &ss->ss_agg_vm, "pgpgin"); 461 sum_out("pages paged out", &ss->ss_agg_vm, "pgpgout"); 462 sum_out("total reclaims", &ss->ss_agg_vm, "pgrec"); 463 sum_out("reclaims from free list", &ss->ss_agg_vm, "pgfrec"); 464 sum_out("micro (hat) faults", &ss->ss_agg_vm, "hat_fault"); 465 sum_out("minor (as) faults", &ss->ss_agg_vm, "as_fault"); 466 sum_out("major faults", &ss->ss_agg_vm, "maj_fault"); 467 sum_out("copy-on-write faults", &ss->ss_agg_vm, "cow_fault"); 468 sum_out("zero fill page faults", &ss->ss_agg_vm, "zfod"); 469 sum_out("pages examined by the clock daemon", &ss->ss_agg_vm, "scan"); 470 sum_out("revolutions of the clock hand", &ss->ss_agg_vm, "rev"); 471 sum_out("pages freed by the clock daemon", &ss->ss_agg_vm, "dfree"); 472 sum_out("forks", &ss->ss_agg_sys, "sysfork"); 473 sum_out("vforks", &ss->ss_agg_sys, "sysvfork"); 474 sum_out("execs", &ss->ss_agg_sys, "sysexec"); 475 sum_out("cpu context switches", &ss->ss_agg_sys, "pswitch"); 476 sum_out("device interrupts", &ss->ss_agg_sys, "intr"); 477 sum_out("traps", &ss->ss_agg_sys, "trap"); 478 sum_out("system calls", &ss->ss_agg_sys, "syscall"); 479 480 nchtotal = (long double) ss->ss_nc.ncs_hits.value.ui64 + 481 (long double) ss->ss_nc.ncs_misses.value.ui64; 482 nchhits = ss->ss_nc.ncs_hits.value.ui64; 483 (void) printf("%9.0Lf total name lookups (cache hits %.0Lf%%)\n", 484 nchtotal, nchhits / denom(nchtotal) * 100); 485 486 sum_out("user cpu", &ss->ss_agg_sys, "cpu_ticks_user"); 487 sum_out("system cpu", &ss->ss_agg_sys, "cpu_ticks_kernel"); 488 sum_out("idle cpu", &ss->ss_agg_sys, "cpu_ticks_idle"); 489 sum_out("wait cpu", &ss->ss_agg_sys, "cpu_ticks_wait"); 490 } 491 492 static void 493 dointr(struct snapshot *ss) 494 { 495 size_t i; 496 ulong_t total = 0; 497 498 (void) printf("interrupt total rate\n"); 499 (void) printf("--------------------------------\n"); 500 501 for (i = 0; i < ss->s_nr_intrs; i++) { 502 (void) printf("%-12.8s %10lu %8.0f\n", 503 ss->s_intrs[i].is_name, ss->s_intrs[i].is_total, 504 ss->s_intrs[i].is_total / etime); 505 total += ss->s_intrs[i].is_total; 506 } 507 508 (void) printf("--------------------------------\n"); 509 (void) printf("Total %10lu %8.0f\n", total, total / etime); 510 } 511 512 static void 513 docachestats(kstat_ctl_t *kc, hrtime_t interval, int forever) 514 { 515 struct snapshot *old; 516 struct snapshot *new; 517 int i; 518 hrtime_t start; 519 520 start = gethrtime(); 521 old = acquire_snapshot(kc, SNAP_FLUSHES, NULL); 522 523 if (iter == 0) { 524 (void) printf("flush statistics: (totals)\n"); 525 (void) printf("%8s%8s%8s%8s%8s%8s\n", 526 "usr", "ctx", "rgn", "seg", "pag", "par"); 527 (void) printf(" %7d %7d %7d %7d %7d %7d\n", 528 old->s_flushes.f_usr, old->s_flushes.f_ctx, 529 old->s_flushes.f_region, old->s_flushes.f_segment, 530 old->s_flushes.f_page, old->s_flushes.f_partial); 531 return; 532 } 533 534 (void) printf("flush statistics: (interval based)\n"); 535 for (i = 0; i < iter; i++) { 536 if (i % REPRINT == 0) 537 (void) printf("%8s%8s%8s%8s%8s%8s\n", 538 "usr", "ctx", "rgn", "seg", "pag", "par"); 539 540 /* Have a kip */ 541 sleep_until(&start, interval, forever, &caught_cont); 542 543 new = acquire_snapshot(kc, SNAP_FLUSHES, NULL); 544 545 (void) printf(" %7d %7d %7d %7d %7d %7d\n", 546 new->s_flushes.f_usr - old->s_flushes.f_usr, 547 new->s_flushes.f_ctx - old->s_flushes.f_ctx, 548 new->s_flushes.f_region - old->s_flushes.f_region, 549 new->s_flushes.f_segment - old->s_flushes.f_segment, 550 new->s_flushes.f_page - old->s_flushes.f_page, 551 new->s_flushes.f_partial- old->s_flushes.f_partial); 552 (void) fflush(stdout); 553 free_snapshot(old); 554 old = new; 555 } 556 } 557 558 static void 559 usage(void) 560 { 561 (void) fprintf(stderr, 562 "Usage: vmstat [-cipqsS] [-T d|u] [disk ...] " 563 "[interval [count]]\n"); 564 exit(1); 565 } 566