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