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