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
Indexes created Wed May 16 21:33:57 UTC 2012