xref: /titanic_51/usr/src/cmd/kvmstat/kvmstat.c (revision 21b926adb26b0bf23fe75045ed308af582303bd0)
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 (c) 2011, Joyent, Inc. All rights reserved.
24  */
25 
26 #include <sys/kstat.h>
27 #include <kstat.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <assert.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <strings.h>
35 #include <alloca.h>
36 #include <signal.h>
37 #include <sys/varargs.h>
38 #include <sys/int_limits.h>
39 
40 #define	KSTAT_FIELD_USEINSTANCE		0x01
41 #define	KSTAT_FIELD_NODELTA		0x02
42 #define	KSTAT_FIELD_FILLER		0x04
43 
44 typedef struct kstat_field {
45 	char *ksf_header;		/* header for field */
46 	char *ksf_name;			/* name of stat, if any */
47 	int ksf_width;			/* width for field in output line */
48 	uint32_t ksf_flags;		/* flags for this field, if any */
49 	int ksf_hint;			/* index hint for field in kstat */
50 } kstat_field_t;
51 
52 typedef struct kstat_instance {
53 	char ksi_name[KSTAT_STRLEN];	/* name of the underlying kstat */
54 	int ksi_instance;		/* instance identifer of this kstat */
55 	kstat_t *ksi_ksp;		/* pointer to the kstat */
56 	uint64_t *ksi_data[2];		/* pointer to two generations of data */
57 	hrtime_t ksi_snaptime[2];	/* hrtime for data generations */
58 	int ksi_gen;			/* current generation */
59 	struct kstat_instance *ksi_next; /* next in instance list */
60 } kstat_instance_t;
61 
62 const char *g_cmd = "kvmstat";
63 
64 static void
65 fatal(char *fmt, ...)
66 {
67 	va_list ap;
68 	int error = errno;
69 
70 	va_start(ap, fmt);
71 
72 	(void) fprintf(stderr, "%s: ", g_cmd);
73 	/*LINTED*/
74 	(void) vfprintf(stderr, fmt, ap);
75 
76 	if (fmt[strlen(fmt) - 1] != '\n')
77 		(void) fprintf(stderr, ": %s\n", strerror(error));
78 
79 	exit(EXIT_FAILURE);
80 }
81 
82 int
83 kstat_field_hint(kstat_t *ksp, kstat_field_t *field)
84 {
85 	kstat_named_t *nm = KSTAT_NAMED_PTR(ksp);
86 	int i;
87 
88 	assert(ksp->ks_type == KSTAT_TYPE_NAMED);
89 
90 	for (i = 0; i < ksp->ks_ndata; i++) {
91 		if (strcmp(field->ksf_name, nm[i].name) == 0)
92 			return (field->ksf_hint = i);
93 	}
94 
95 	fatal("could not find field '%s' in %s:%d\n",
96 	    field->ksf_name, ksp->ks_name, ksp->ks_instance);
97 
98 	return (0);
99 }
100 
101 int
102 kstat_instances_compare(const void *lhs, const void *rhs)
103 {
104 	kstat_instance_t *l = *((kstat_instance_t **)lhs);
105 	kstat_instance_t *r = *((kstat_instance_t **)rhs);
106 	int rval;
107 
108 	if ((rval = strcmp(l->ksi_name, r->ksi_name)) != 0)
109 		return (rval);
110 
111 	if (l->ksi_instance < r->ksi_instance)
112 		return (-1);
113 
114 	if (l->ksi_instance > r->ksi_instance)
115 		return (1);
116 
117 	return (0);
118 }
119 
120 void
121 kstat_instances_update(kstat_ctl_t *kcp, kstat_instance_t **head,
122     boolean_t (*interested)(kstat_t *))
123 {
124 	int ninstances = 0, i;
125 	kstat_instance_t **sorted, *ksi, *next;
126 	kstat_t *ksp;
127 	kid_t kid;
128 
129 	if ((kid = kstat_chain_update(kcp)) == 0 && *head != NULL)
130 		return;
131 
132 	if (kid == -1)
133 		fatal("failed to update kstat chain");
134 
135 	for (ksi = *head; ksi != NULL; ksi = ksi->ksi_next)
136 		ksi->ksi_ksp = NULL;
137 
138 	for (ksp = kcp->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
139 		kstat_instance_t *last = NULL;
140 
141 		if (!interested(ksp))
142 			continue;
143 
144 		/*
145 		 * Now look to see if we have this instance and name.  (Yes,
146 		 * this is a linear search; we're assuming that this list is
147 		 * modest in size.)
148 		 */
149 		for (ksi = *head; ksi != NULL; ksi = ksi->ksi_next) {
150 			last = ksi;
151 
152 			if (ksi->ksi_instance != ksp->ks_instance)
153 				continue;
154 
155 			if (strcmp(ksi->ksi_name, ksp->ks_name) != 0)
156 				continue;
157 
158 			ksi->ksi_ksp = ksp;
159 			ninstances++;
160 			break;
161 		}
162 
163 		if (ksi != NULL)
164 			continue;
165 
166 		if ((ksi = malloc(sizeof (kstat_instance_t))) == NULL)
167 			fatal("could not allocate memory for stat instance");
168 
169 		bzero(ksi, sizeof (kstat_instance_t));
170 		(void) strlcpy(ksi->ksi_name, ksp->ks_name, KSTAT_STRLEN);
171 		ksi->ksi_instance = ksp->ks_instance;
172 		ksi->ksi_ksp = ksp;
173 		ksi->ksi_next = NULL;
174 
175 		if (last == NULL) {
176 			assert(*head == NULL);
177 			*head = ksi;
178 		} else {
179 			last->ksi_next = ksi;
180 		}
181 
182 		ninstances++;
183 	}
184 
185 	/*
186 	 * Now we know how many instances we have; iterate back over them,
187 	 * pruning the stale ones and adding the active ones to a holding
188 	 * array in which to sort them.
189 	 */
190 	sorted = (void *)alloca(ninstances * sizeof (kstat_instance_t *));
191 	ninstances = 0;
192 
193 	for (ksi = *head; ksi != NULL; ksi = next) {
194 		next = ksi->ksi_next;
195 
196 		if (ksi->ksi_ksp == NULL) {
197 			free(ksi);
198 		} else {
199 			sorted[ninstances++] = ksi;
200 		}
201 	}
202 
203 	if (ninstances == 0) {
204 		*head = NULL;
205 		return;
206 	}
207 
208 	qsort(sorted, ninstances, sizeof (kstat_instance_t *),
209 	    kstat_instances_compare);
210 
211 	*head = sorted[0];
212 
213 	for (i = 0; i < ninstances; i++) {
214 		ksi = sorted[i];
215 		ksi->ksi_next = i < ninstances - 1 ? sorted[i + 1] : NULL;
216 	}
217 }
218 
219 void
220 kstat_instances_read(kstat_ctl_t *kcp, kstat_instance_t *instances,
221     kstat_field_t *fields)
222 {
223 	kstat_instance_t *ksi;
224 	int i, nfields;
225 
226 	for (nfields = 0; fields[nfields].ksf_header != NULL; nfields++)
227 		continue;
228 
229 	for (ksi = instances; ksi != NULL; ksi = ksi->ksi_next) {
230 		kstat_t *ksp = ksi->ksi_ksp;
231 
232 		if (ksp == NULL)
233 			continue;
234 
235 		if (kstat_read(kcp, ksp, NULL) == -1) {
236 			if (errno == ENXIO) {
237 				/*
238 				 * Our kstat has been removed since the update;
239 				 * NULL it out to prevent us from trying to read
240 				 * it again (and to indicate that it should not
241 				 * be displayed) and drive on.
242 				 */
243 				ksi->ksi_ksp = NULL;
244 				continue;
245 			}
246 
247 			fatal("failed to read kstat %s:%d",
248 			    ksi->ksi_name, ksi->ksi_instance);
249 		}
250 
251 		if (ksp->ks_type != KSTAT_TYPE_NAMED) {
252 			fatal("%s:%d is not a named kstat", ksi->ksi_name,
253 			    ksi->ksi_instance);
254 		}
255 
256 		if (ksi->ksi_data[0] == NULL) {
257 			size_t size = nfields * sizeof (uint64_t) * 2;
258 			uint64_t *data;
259 
260 			if ((data = malloc(size)) == NULL)
261 				fatal("could not allocate memory");
262 
263 			bzero(data, size);
264 			ksi->ksi_data[0] = data;
265 			ksi->ksi_data[1] = &data[nfields];
266 		}
267 
268 		for (i = 0; i < nfields; i++) {
269 			kstat_named_t *nm = KSTAT_NAMED_PTR(ksp);
270 			kstat_field_t *field = &fields[i];
271 			int hint = field->ksf_hint;
272 
273 			if (field->ksf_name == NULL)
274 				continue;
275 
276 			if (hint < 0 || hint >= ksp->ks_ndata ||
277 			    strcmp(field->ksf_name, nm[hint].name) != 0) {
278 				hint = kstat_field_hint(ksp, field);
279 			}
280 
281 			ksi->ksi_data[ksi->ksi_gen][i] = nm[hint].value.ui64;
282 		}
283 
284 		ksi->ksi_snaptime[ksi->ksi_gen] = ksp->ks_snaptime;
285 		ksi->ksi_gen ^= 1;
286 	}
287 }
288 
289 uint64_t
290 kstat_instances_delta(kstat_instance_t *ksi, int i)
291 {
292 	int gen = ksi->ksi_gen;
293 	uint64_t delta = ksi->ksi_data[gen ^ 1][i] - ksi->ksi_data[gen][i];
294 	uint64_t tdelta = ksi->ksi_snaptime[gen ^ 1] - ksi->ksi_snaptime[gen];
295 
296 	return (((delta * (uint64_t)NANOSEC) + (tdelta / 2)) / tdelta);
297 }
298 
299 void
300 kstat_instances_print(kstat_instance_t *instances, kstat_field_t *fields,
301     boolean_t header)
302 {
303 	kstat_instance_t *ksi = instances;
304 	int i, nfields;
305 
306 	for (nfields = 0; fields[nfields].ksf_header != NULL; nfields++)
307 		continue;
308 
309 	if (header) {
310 		for (i = 0; i < nfields; i++) {
311 			(void) printf("%*s%c", fields[i].ksf_width,
312 			    fields[i].ksf_header, i < nfields - 1 ? ' ' : '\n');
313 		}
314 	}
315 
316 	for (ksi = instances; ksi != NULL; ksi = ksi->ksi_next) {
317 		if (ksi->ksi_snaptime[1] == 0 || ksi->ksi_ksp == NULL)
318 			continue;
319 
320 		for (i = 0; i < nfields; i++) {
321 			char trailer = i < nfields - 1 ? ' ' : '\n';
322 
323 			if (fields[i].ksf_flags & KSTAT_FIELD_FILLER) {
324 				(void) printf("%*s%c", fields[i].ksf_width,
325 				    fields[i].ksf_header, trailer);
326 				continue;
327 			}
328 
329 			(void) printf("%*lld%c", fields[i].ksf_width,
330 			    fields[i].ksf_flags & KSTAT_FIELD_USEINSTANCE ?
331 			    ksi->ksi_instance :
332 			    fields[i].ksf_flags & KSTAT_FIELD_NODELTA ?
333 			    ksi->ksi_data[ksi->ksi_gen ^ 1][i] :
334 			    kstat_instances_delta(ksi, i), trailer);
335 		}
336 	}
337 }
338 
339 boolean_t
340 interested(kstat_t *ksp)
341 {
342 	const char *module = "kvm";
343 	const char *class = "misc";
344 	const char *name = "vcpu-";
345 
346 	if (strcmp(ksp->ks_module, module) != 0)
347 		return (B_FALSE);
348 
349 	if (strcmp(ksp->ks_class, class) != 0)
350 		return (B_FALSE);
351 
352 	if (strstr(ksp->ks_name, name) != ksp->ks_name)
353 		return (B_FALSE);
354 
355 	return (B_TRUE);
356 }
357 
358 /* BEGIN CSTYLED */
359 char *g_usage = "Usage: kvmstat [interval [count]]\n"
360     "\n"
361     "  Displays statistics for running kernel virtual machines, with one line\n"
362     "  per virtual CPU.  All statistics are reported as per-second rates.\n"
363     "\n"
364     "  The columns are as follows:\n"
365     "\n"
366     "    pid    =>  identifier of process controlling the virtual CPU\n"
367     "    vcpu   =>  virtual CPU identifier relative to its virtual machine\n"
368     "    exits  =>  virtual machine exits for the virtual CPU\n"
369     "    haltx  =>  virtual machine exits due to the HLT instruction\n"
370     "    irqx   =>  virtual machine exits due to a pending external interrupt\n"
371     "    irqwx  =>  virtual machine exits due to an open interrupt window\n"
372     "    iox    =>  virtual machine exits due to an I/O instruction\n"
373     "    mmiox  =>  virtual machine exits due to memory mapped I/O \n"
374     "    irqs   =>  interrupts injected into the virtual CPU\n"
375     "    emul   =>  instructions emulated in the kernel\n"
376     "    eptv   =>  extended page table violations\n"
377     "\n";
378 /* END CSTYLED */
379 
380 void
381 usage()
382 {
383 	(void) fprintf(stderr, "%s", g_usage);
384 	exit(EXIT_FAILURE);
385 }
386 
387 /*ARGSUSED*/
388 void
389 intr(int sig)
390 {}
391 
392 /*ARGSUSED*/
393 int
394 main(int argc, char **argv)
395 {
396 	kstat_ctl_t *kcp;
397 	kstat_instance_t *instances = NULL;
398 	int i = 0;
399 	int interval = 1;
400 	int count = INT32_MAX;
401 	struct itimerval itimer;
402 	struct sigaction act;
403 	sigset_t set;
404 	char *endp;
405 
406 	kstat_field_t fields[] =  {
407 		{ "pid", "pid", 6, KSTAT_FIELD_NODELTA },
408 		{ "vcpu", NULL, 4, KSTAT_FIELD_USEINSTANCE },
409 		{ "|", NULL, 1, KSTAT_FIELD_FILLER },
410 		{ "exits", "exits", 6 },
411 		{ ":", NULL, 1, KSTAT_FIELD_FILLER },
412 		{ "haltx", "halt-exits", 6 },
413 		{ "irqx", "irq-exits", 6 },
414 		{ "irqwx", "irq-window-exits", 6 },
415 		{ "iox", "io-exits", 6 },
416 		{ "mmiox", "mmio-exits", 6 },
417 		{ "|", NULL, 1, KSTAT_FIELD_FILLER },
418 		{ "irqs", "irq-injections", 6 },
419 		{ "emul", "insn-emulation", 6 },
420 		{ "eptv", "pf-fixed", 6 },
421 		{ NULL }
422 	};
423 
424 	if (argc > 1) {
425 		interval = strtol(argv[1], &endp, 10);
426 
427 		if (*endp != '\0' || interval <= 0)
428 			usage();
429 	}
430 
431 	if (argc > 2) {
432 		count = strtol(argv[2], &endp, 10);
433 
434 		if (*endp != '\0' || count <= 0)
435 			usage();
436 	}
437 
438 	if ((kcp = kstat_open()) == NULL)
439 		fatal("could not open /dev/kstat");
440 
441 	(void) sigemptyset(&act.sa_mask);
442 	act.sa_flags = 0;
443 	act.sa_handler = intr;
444 	(void) sigaction(SIGALRM, &act, NULL);
445 
446 	(void) sigemptyset(&set);
447 	(void) sigaddset(&set, SIGALRM);
448 	(void) sigprocmask(SIG_BLOCK, &set, NULL);
449 
450 	bzero(&itimer, sizeof (itimer));
451 	itimer.it_value.tv_sec = interval;
452 	itimer.it_interval.tv_sec = interval;
453 
454 	if (setitimer(ITIMER_REAL, &itimer, NULL) != 0) {
455 		fatal("could not set timer to %d second%s", interval,
456 		    interval == 1 ? "" : "s");
457 	}
458 
459 	(void) sigemptyset(&set);
460 
461 	for (;;) {
462 		kstat_instances_update(kcp, &instances, interested);
463 		kstat_instances_read(kcp, instances, fields);
464 
465 		if (i++ > 0) {
466 			kstat_instances_print(instances, fields,
467 			    instances != NULL && instances->ksi_next == NULL ?
468 			    (((i - 2) % 20) == 0) : B_TRUE);
469 		}
470 
471 		if (i > count)
472 			break;
473 
474 		(void) sigsuspend(&set);
475 	}
476 
477 	/*NOTREACHED*/
478 	return (0);
479 }
480