1 #include "builtin.h" 2 #include "perf.h" 3 4 #include "util/evsel.h" 5 #include "util/util.h" 6 #include "util/cache.h" 7 #include "util/symbol.h" 8 #include "util/thread.h" 9 #include "util/header.h" 10 #include "util/session.h" 11 12 #include "util/parse-options.h" 13 #include "util/trace-event.h" 14 #include "util/debug.h" 15 #include <lk/debugfs.h> 16 #include "util/tool.h" 17 #include "util/stat.h" 18 19 #include <sys/prctl.h> 20 21 #include <semaphore.h> 22 #include <pthread.h> 23 #include <math.h> 24 25 #if defined(__i386__) || defined(__x86_64__) 26 #include <asm/svm.h> 27 #include <asm/vmx.h> 28 #include <asm/kvm.h> 29 30 struct event_key { 31 #define INVALID_KEY (~0ULL) 32 u64 key; 33 int info; 34 }; 35 36 struct kvm_event_stats { 37 u64 time; 38 struct stats stats; 39 }; 40 41 struct kvm_event { 42 struct list_head hash_entry; 43 struct rb_node rb; 44 45 struct event_key key; 46 47 struct kvm_event_stats total; 48 49 #define DEFAULT_VCPU_NUM 8 50 int max_vcpu; 51 struct kvm_event_stats *vcpu; 52 }; 53 54 typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int); 55 56 struct kvm_event_key { 57 const char *name; 58 key_cmp_fun key; 59 }; 60 61 62 struct perf_kvm_stat; 63 64 struct kvm_events_ops { 65 bool (*is_begin_event)(struct perf_evsel *evsel, 66 struct perf_sample *sample, 67 struct event_key *key); 68 bool (*is_end_event)(struct perf_evsel *evsel, 69 struct perf_sample *sample, struct event_key *key); 70 void (*decode_key)(struct perf_kvm_stat *kvm, struct event_key *key, 71 char decode[20]); 72 const char *name; 73 }; 74 75 struct exit_reasons_table { 76 unsigned long exit_code; 77 const char *reason; 78 }; 79 80 #define EVENTS_BITS 12 81 #define EVENTS_CACHE_SIZE (1UL << EVENTS_BITS) 82 83 struct perf_kvm_stat { 84 struct perf_tool tool; 85 struct perf_session *session; 86 87 const char *file_name; 88 const char *report_event; 89 const char *sort_key; 90 int trace_vcpu; 91 92 struct exit_reasons_table *exit_reasons; 93 int exit_reasons_size; 94 const char *exit_reasons_isa; 95 96 struct kvm_events_ops *events_ops; 97 key_cmp_fun compare; 98 struct list_head kvm_events_cache[EVENTS_CACHE_SIZE]; 99 u64 total_time; 100 u64 total_count; 101 102 struct rb_root result; 103 }; 104 105 106 static void exit_event_get_key(struct perf_evsel *evsel, 107 struct perf_sample *sample, 108 struct event_key *key) 109 { 110 key->info = 0; 111 key->key = perf_evsel__intval(evsel, sample, "exit_reason"); 112 } 113 114 static bool kvm_exit_event(struct perf_evsel *evsel) 115 { 116 return !strcmp(evsel->name, "kvm:kvm_exit"); 117 } 118 119 static bool exit_event_begin(struct perf_evsel *evsel, 120 struct perf_sample *sample, struct event_key *key) 121 { 122 if (kvm_exit_event(evsel)) { 123 exit_event_get_key(evsel, sample, key); 124 return true; 125 } 126 127 return false; 128 } 129 130 static bool kvm_entry_event(struct perf_evsel *evsel) 131 { 132 return !strcmp(evsel->name, "kvm:kvm_entry"); 133 } 134 135 static bool exit_event_end(struct perf_evsel *evsel, 136 struct perf_sample *sample __maybe_unused, 137 struct event_key *key __maybe_unused) 138 { 139 return kvm_entry_event(evsel); 140 } 141 142 static struct exit_reasons_table vmx_exit_reasons[] = { 143 VMX_EXIT_REASONS 144 }; 145 146 static struct exit_reasons_table svm_exit_reasons[] = { 147 SVM_EXIT_REASONS 148 }; 149 150 static const char *get_exit_reason(struct perf_kvm_stat *kvm, u64 exit_code) 151 { 152 int i = kvm->exit_reasons_size; 153 struct exit_reasons_table *tbl = kvm->exit_reasons; 154 155 while (i--) { 156 if (tbl->exit_code == exit_code) 157 return tbl->reason; 158 tbl++; 159 } 160 161 pr_err("unknown kvm exit code:%lld on %s\n", 162 (unsigned long long)exit_code, kvm->exit_reasons_isa); 163 return "UNKNOWN"; 164 } 165 166 static void exit_event_decode_key(struct perf_kvm_stat *kvm, 167 struct event_key *key, 168 char decode[20]) 169 { 170 const char *exit_reason = get_exit_reason(kvm, key->key); 171 172 scnprintf(decode, 20, "%s", exit_reason); 173 } 174 175 static struct kvm_events_ops exit_events = { 176 .is_begin_event = exit_event_begin, 177 .is_end_event = exit_event_end, 178 .decode_key = exit_event_decode_key, 179 .name = "VM-EXIT" 180 }; 181 182 /* 183 * For the mmio events, we treat: 184 * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry 185 * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...). 186 */ 187 static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample, 188 struct event_key *key) 189 { 190 key->key = perf_evsel__intval(evsel, sample, "gpa"); 191 key->info = perf_evsel__intval(evsel, sample, "type"); 192 } 193 194 #define KVM_TRACE_MMIO_READ_UNSATISFIED 0 195 #define KVM_TRACE_MMIO_READ 1 196 #define KVM_TRACE_MMIO_WRITE 2 197 198 static bool mmio_event_begin(struct perf_evsel *evsel, 199 struct perf_sample *sample, struct event_key *key) 200 { 201 /* MMIO read begin event in kernel. */ 202 if (kvm_exit_event(evsel)) 203 return true; 204 205 /* MMIO write begin event in kernel. */ 206 if (!strcmp(evsel->name, "kvm:kvm_mmio") && 207 perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) { 208 mmio_event_get_key(evsel, sample, key); 209 return true; 210 } 211 212 return false; 213 } 214 215 static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample, 216 struct event_key *key) 217 { 218 /* MMIO write end event in kernel. */ 219 if (kvm_entry_event(evsel)) 220 return true; 221 222 /* MMIO read end event in kernel.*/ 223 if (!strcmp(evsel->name, "kvm:kvm_mmio") && 224 perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) { 225 mmio_event_get_key(evsel, sample, key); 226 return true; 227 } 228 229 return false; 230 } 231 232 static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused, 233 struct event_key *key, 234 char decode[20]) 235 { 236 scnprintf(decode, 20, "%#lx:%s", (unsigned long)key->key, 237 key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R"); 238 } 239 240 static struct kvm_events_ops mmio_events = { 241 .is_begin_event = mmio_event_begin, 242 .is_end_event = mmio_event_end, 243 .decode_key = mmio_event_decode_key, 244 .name = "MMIO Access" 245 }; 246 247 /* The time of emulation pio access is from kvm_pio to kvm_entry. */ 248 static void ioport_event_get_key(struct perf_evsel *evsel, 249 struct perf_sample *sample, 250 struct event_key *key) 251 { 252 key->key = perf_evsel__intval(evsel, sample, "port"); 253 key->info = perf_evsel__intval(evsel, sample, "rw"); 254 } 255 256 static bool ioport_event_begin(struct perf_evsel *evsel, 257 struct perf_sample *sample, 258 struct event_key *key) 259 { 260 if (!strcmp(evsel->name, "kvm:kvm_pio")) { 261 ioport_event_get_key(evsel, sample, key); 262 return true; 263 } 264 265 return false; 266 } 267 268 static bool ioport_event_end(struct perf_evsel *evsel, 269 struct perf_sample *sample __maybe_unused, 270 struct event_key *key __maybe_unused) 271 { 272 return kvm_entry_event(evsel); 273 } 274 275 static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused, 276 struct event_key *key, 277 char decode[20]) 278 { 279 scnprintf(decode, 20, "%#llx:%s", (unsigned long long)key->key, 280 key->info ? "POUT" : "PIN"); 281 } 282 283 static struct kvm_events_ops ioport_events = { 284 .is_begin_event = ioport_event_begin, 285 .is_end_event = ioport_event_end, 286 .decode_key = ioport_event_decode_key, 287 .name = "IO Port Access" 288 }; 289 290 static bool register_kvm_events_ops(struct perf_kvm_stat *kvm) 291 { 292 bool ret = true; 293 294 if (!strcmp(kvm->report_event, "vmexit")) 295 kvm->events_ops = &exit_events; 296 else if (!strcmp(kvm->report_event, "mmio")) 297 kvm->events_ops = &mmio_events; 298 else if (!strcmp(kvm->report_event, "ioport")) 299 kvm->events_ops = &ioport_events; 300 else { 301 pr_err("Unknown report event:%s\n", kvm->report_event); 302 ret = false; 303 } 304 305 return ret; 306 } 307 308 struct vcpu_event_record { 309 int vcpu_id; 310 u64 start_time; 311 struct kvm_event *last_event; 312 }; 313 314 315 static void init_kvm_event_record(struct perf_kvm_stat *kvm) 316 { 317 unsigned int i; 318 319 for (i = 0; i < EVENTS_CACHE_SIZE; i++) 320 INIT_LIST_HEAD(&kvm->kvm_events_cache[i]); 321 } 322 323 static int kvm_events_hash_fn(u64 key) 324 { 325 return key & (EVENTS_CACHE_SIZE - 1); 326 } 327 328 static bool kvm_event_expand(struct kvm_event *event, int vcpu_id) 329 { 330 int old_max_vcpu = event->max_vcpu; 331 void *prev; 332 333 if (vcpu_id < event->max_vcpu) 334 return true; 335 336 while (event->max_vcpu <= vcpu_id) 337 event->max_vcpu += DEFAULT_VCPU_NUM; 338 339 prev = event->vcpu; 340 event->vcpu = realloc(event->vcpu, 341 event->max_vcpu * sizeof(*event->vcpu)); 342 if (!event->vcpu) { 343 free(prev); 344 pr_err("Not enough memory\n"); 345 return false; 346 } 347 348 memset(event->vcpu + old_max_vcpu, 0, 349 (event->max_vcpu - old_max_vcpu) * sizeof(*event->vcpu)); 350 return true; 351 } 352 353 static struct kvm_event *kvm_alloc_init_event(struct event_key *key) 354 { 355 struct kvm_event *event; 356 357 event = zalloc(sizeof(*event)); 358 if (!event) { 359 pr_err("Not enough memory\n"); 360 return NULL; 361 } 362 363 event->key = *key; 364 return event; 365 } 366 367 static struct kvm_event *find_create_kvm_event(struct perf_kvm_stat *kvm, 368 struct event_key *key) 369 { 370 struct kvm_event *event; 371 struct list_head *head; 372 373 BUG_ON(key->key == INVALID_KEY); 374 375 head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)]; 376 list_for_each_entry(event, head, hash_entry) { 377 if (event->key.key == key->key && event->key.info == key->info) 378 return event; 379 } 380 381 event = kvm_alloc_init_event(key); 382 if (!event) 383 return NULL; 384 385 list_add(&event->hash_entry, head); 386 return event; 387 } 388 389 static bool handle_begin_event(struct perf_kvm_stat *kvm, 390 struct vcpu_event_record *vcpu_record, 391 struct event_key *key, u64 timestamp) 392 { 393 struct kvm_event *event = NULL; 394 395 if (key->key != INVALID_KEY) 396 event = find_create_kvm_event(kvm, key); 397 398 vcpu_record->last_event = event; 399 vcpu_record->start_time = timestamp; 400 return true; 401 } 402 403 static void 404 kvm_update_event_stats(struct kvm_event_stats *kvm_stats, u64 time_diff) 405 { 406 kvm_stats->time += time_diff; 407 update_stats(&kvm_stats->stats, time_diff); 408 } 409 410 static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event) 411 { 412 struct kvm_event_stats *kvm_stats = &event->total; 413 414 if (vcpu_id != -1) 415 kvm_stats = &event->vcpu[vcpu_id]; 416 417 return rel_stddev_stats(stddev_stats(&kvm_stats->stats), 418 avg_stats(&kvm_stats->stats)); 419 } 420 421 static bool update_kvm_event(struct kvm_event *event, int vcpu_id, 422 u64 time_diff) 423 { 424 if (vcpu_id == -1) { 425 kvm_update_event_stats(&event->total, time_diff); 426 return true; 427 } 428 429 if (!kvm_event_expand(event, vcpu_id)) 430 return false; 431 432 kvm_update_event_stats(&event->vcpu[vcpu_id], time_diff); 433 return true; 434 } 435 436 static bool handle_end_event(struct perf_kvm_stat *kvm, 437 struct vcpu_event_record *vcpu_record, 438 struct event_key *key, 439 u64 timestamp) 440 { 441 struct kvm_event *event; 442 u64 time_begin, time_diff; 443 int vcpu; 444 445 if (kvm->trace_vcpu == -1) 446 vcpu = -1; 447 else 448 vcpu = vcpu_record->vcpu_id; 449 450 event = vcpu_record->last_event; 451 time_begin = vcpu_record->start_time; 452 453 /* The begin event is not caught. */ 454 if (!time_begin) 455 return true; 456 457 /* 458 * In some case, the 'begin event' only records the start timestamp, 459 * the actual event is recognized in the 'end event' (e.g. mmio-event). 460 */ 461 462 /* Both begin and end events did not get the key. */ 463 if (!event && key->key == INVALID_KEY) 464 return true; 465 466 if (!event) 467 event = find_create_kvm_event(kvm, key); 468 469 if (!event) 470 return false; 471 472 vcpu_record->last_event = NULL; 473 vcpu_record->start_time = 0; 474 475 BUG_ON(timestamp < time_begin); 476 477 time_diff = timestamp - time_begin; 478 return update_kvm_event(event, vcpu, time_diff); 479 } 480 481 static 482 struct vcpu_event_record *per_vcpu_record(struct thread *thread, 483 struct perf_evsel *evsel, 484 struct perf_sample *sample) 485 { 486 /* Only kvm_entry records vcpu id. */ 487 if (!thread->priv && kvm_entry_event(evsel)) { 488 struct vcpu_event_record *vcpu_record; 489 490 vcpu_record = zalloc(sizeof(*vcpu_record)); 491 if (!vcpu_record) { 492 pr_err("%s: Not enough memory\n", __func__); 493 return NULL; 494 } 495 496 vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id"); 497 thread->priv = vcpu_record; 498 } 499 500 return thread->priv; 501 } 502 503 static bool handle_kvm_event(struct perf_kvm_stat *kvm, 504 struct thread *thread, 505 struct perf_evsel *evsel, 506 struct perf_sample *sample) 507 { 508 struct vcpu_event_record *vcpu_record; 509 struct event_key key = {.key = INVALID_KEY}; 510 511 vcpu_record = per_vcpu_record(thread, evsel, sample); 512 if (!vcpu_record) 513 return true; 514 515 /* only process events for vcpus user cares about */ 516 if ((kvm->trace_vcpu != -1) && 517 (kvm->trace_vcpu != vcpu_record->vcpu_id)) 518 return true; 519 520 if (kvm->events_ops->is_begin_event(evsel, sample, &key)) 521 return handle_begin_event(kvm, vcpu_record, &key, sample->time); 522 523 if (kvm->events_ops->is_end_event(evsel, sample, &key)) 524 return handle_end_event(kvm, vcpu_record, &key, sample->time); 525 526 return true; 527 } 528 529 #define GET_EVENT_KEY(func, field) \ 530 static u64 get_event_ ##func(struct kvm_event *event, int vcpu) \ 531 { \ 532 if (vcpu == -1) \ 533 return event->total.field; \ 534 \ 535 if (vcpu >= event->max_vcpu) \ 536 return 0; \ 537 \ 538 return event->vcpu[vcpu].field; \ 539 } 540 541 #define COMPARE_EVENT_KEY(func, field) \ 542 GET_EVENT_KEY(func, field) \ 543 static int compare_kvm_event_ ## func(struct kvm_event *one, \ 544 struct kvm_event *two, int vcpu)\ 545 { \ 546 return get_event_ ##func(one, vcpu) > \ 547 get_event_ ##func(two, vcpu); \ 548 } 549 550 GET_EVENT_KEY(time, time); 551 COMPARE_EVENT_KEY(count, stats.n); 552 COMPARE_EVENT_KEY(mean, stats.mean); 553 554 #define DEF_SORT_NAME_KEY(name, compare_key) \ 555 { #name, compare_kvm_event_ ## compare_key } 556 557 static struct kvm_event_key keys[] = { 558 DEF_SORT_NAME_KEY(sample, count), 559 DEF_SORT_NAME_KEY(time, mean), 560 { NULL, NULL } 561 }; 562 563 static bool select_key(struct perf_kvm_stat *kvm) 564 { 565 int i; 566 567 for (i = 0; keys[i].name; i++) { 568 if (!strcmp(keys[i].name, kvm->sort_key)) { 569 kvm->compare = keys[i].key; 570 return true; 571 } 572 } 573 574 pr_err("Unknown compare key:%s\n", kvm->sort_key); 575 return false; 576 } 577 578 static void insert_to_result(struct rb_root *result, struct kvm_event *event, 579 key_cmp_fun bigger, int vcpu) 580 { 581 struct rb_node **rb = &result->rb_node; 582 struct rb_node *parent = NULL; 583 struct kvm_event *p; 584 585 while (*rb) { 586 p = container_of(*rb, struct kvm_event, rb); 587 parent = *rb; 588 589 if (bigger(event, p, vcpu)) 590 rb = &(*rb)->rb_left; 591 else 592 rb = &(*rb)->rb_right; 593 } 594 595 rb_link_node(&event->rb, parent, rb); 596 rb_insert_color(&event->rb, result); 597 } 598 599 static void 600 update_total_count(struct perf_kvm_stat *kvm, struct kvm_event *event) 601 { 602 int vcpu = kvm->trace_vcpu; 603 604 kvm->total_count += get_event_count(event, vcpu); 605 kvm->total_time += get_event_time(event, vcpu); 606 } 607 608 static bool event_is_valid(struct kvm_event *event, int vcpu) 609 { 610 return !!get_event_count(event, vcpu); 611 } 612 613 static void sort_result(struct perf_kvm_stat *kvm) 614 { 615 unsigned int i; 616 int vcpu = kvm->trace_vcpu; 617 struct kvm_event *event; 618 619 for (i = 0; i < EVENTS_CACHE_SIZE; i++) { 620 list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry) { 621 if (event_is_valid(event, vcpu)) { 622 update_total_count(kvm, event); 623 insert_to_result(&kvm->result, event, 624 kvm->compare, vcpu); 625 } 626 } 627 } 628 } 629 630 /* returns left most element of result, and erase it */ 631 static struct kvm_event *pop_from_result(struct rb_root *result) 632 { 633 struct rb_node *node = rb_first(result); 634 635 if (!node) 636 return NULL; 637 638 rb_erase(node, result); 639 return container_of(node, struct kvm_event, rb); 640 } 641 642 static void print_vcpu_info(int vcpu) 643 { 644 pr_info("Analyze events for "); 645 646 if (vcpu == -1) 647 pr_info("all VCPUs:\n\n"); 648 else 649 pr_info("VCPU %d:\n\n", vcpu); 650 } 651 652 static void print_result(struct perf_kvm_stat *kvm) 653 { 654 char decode[20]; 655 struct kvm_event *event; 656 int vcpu = kvm->trace_vcpu; 657 658 pr_info("\n\n"); 659 print_vcpu_info(vcpu); 660 pr_info("%20s ", kvm->events_ops->name); 661 pr_info("%10s ", "Samples"); 662 pr_info("%9s ", "Samples%"); 663 664 pr_info("%9s ", "Time%"); 665 pr_info("%16s ", "Avg time"); 666 pr_info("\n\n"); 667 668 while ((event = pop_from_result(&kvm->result))) { 669 u64 ecount, etime; 670 671 ecount = get_event_count(event, vcpu); 672 etime = get_event_time(event, vcpu); 673 674 kvm->events_ops->decode_key(kvm, &event->key, decode); 675 pr_info("%20s ", decode); 676 pr_info("%10llu ", (unsigned long long)ecount); 677 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100); 678 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100); 679 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3, 680 kvm_event_rel_stddev(vcpu, event)); 681 pr_info("\n"); 682 } 683 684 pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n", 685 kvm->total_count, kvm->total_time / 1e3); 686 } 687 688 static int process_sample_event(struct perf_tool *tool, 689 union perf_event *event, 690 struct perf_sample *sample, 691 struct perf_evsel *evsel, 692 struct machine *machine) 693 { 694 struct thread *thread = machine__findnew_thread(machine, sample->tid); 695 struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat, 696 tool); 697 698 if (thread == NULL) { 699 pr_debug("problem processing %d event, skipping it.\n", 700 event->header.type); 701 return -1; 702 } 703 704 if (!handle_kvm_event(kvm, thread, evsel, sample)) 705 return -1; 706 707 return 0; 708 } 709 710 static int get_cpu_isa(struct perf_session *session) 711 { 712 char *cpuid = session->header.env.cpuid; 713 int isa; 714 715 if (strstr(cpuid, "Intel")) 716 isa = 1; 717 else if (strstr(cpuid, "AMD")) 718 isa = 0; 719 else { 720 pr_err("CPU %s is not supported.\n", cpuid); 721 isa = -ENOTSUP; 722 } 723 724 return isa; 725 } 726 727 static int read_events(struct perf_kvm_stat *kvm) 728 { 729 int ret; 730 731 struct perf_tool eops = { 732 .sample = process_sample_event, 733 .comm = perf_event__process_comm, 734 .ordered_samples = true, 735 }; 736 737 kvm->tool = eops; 738 kvm->session = perf_session__new(kvm->file_name, O_RDONLY, 0, false, 739 &kvm->tool); 740 if (!kvm->session) { 741 pr_err("Initializing perf session failed\n"); 742 return -EINVAL; 743 } 744 745 if (!perf_session__has_traces(kvm->session, "kvm record")) 746 return -EINVAL; 747 748 /* 749 * Do not use 'isa' recorded in kvm_exit tracepoint since it is not 750 * traced in the old kernel. 751 */ 752 ret = get_cpu_isa(kvm->session); 753 754 if (ret < 0) 755 return ret; 756 757 if (ret == 1) { 758 kvm->exit_reasons = vmx_exit_reasons; 759 kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons); 760 kvm->exit_reasons_isa = "VMX"; 761 } 762 763 return perf_session__process_events(kvm->session, &kvm->tool); 764 } 765 766 static bool verify_vcpu(int vcpu) 767 { 768 if (vcpu != -1 && vcpu < 0) { 769 pr_err("Invalid vcpu:%d.\n", vcpu); 770 return false; 771 } 772 773 return true; 774 } 775 776 static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm) 777 { 778 int ret = -EINVAL; 779 int vcpu = kvm->trace_vcpu; 780 781 if (!verify_vcpu(vcpu)) 782 goto exit; 783 784 if (!select_key(kvm)) 785 goto exit; 786 787 if (!register_kvm_events_ops(kvm)) 788 goto exit; 789 790 init_kvm_event_record(kvm); 791 setup_pager(); 792 793 ret = read_events(kvm); 794 if (ret) 795 goto exit; 796 797 sort_result(kvm); 798 print_result(kvm); 799 800 exit: 801 return ret; 802 } 803 804 static const char * const record_args[] = { 805 "record", 806 "-R", 807 "-f", 808 "-m", "1024", 809 "-c", "1", 810 "-e", "kvm:kvm_entry", 811 "-e", "kvm:kvm_exit", 812 "-e", "kvm:kvm_mmio", 813 "-e", "kvm:kvm_pio", 814 }; 815 816 #define STRDUP_FAIL_EXIT(s) \ 817 ({ char *_p; \ 818 _p = strdup(s); \ 819 if (!_p) \ 820 return -ENOMEM; \ 821 _p; \ 822 }) 823 824 static int 825 kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv) 826 { 827 unsigned int rec_argc, i, j; 828 const char **rec_argv; 829 830 rec_argc = ARRAY_SIZE(record_args) + argc + 2; 831 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 832 833 if (rec_argv == NULL) 834 return -ENOMEM; 835 836 for (i = 0; i < ARRAY_SIZE(record_args); i++) 837 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]); 838 839 rec_argv[i++] = STRDUP_FAIL_EXIT("-o"); 840 rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name); 841 842 for (j = 1; j < (unsigned int)argc; j++, i++) 843 rec_argv[i] = argv[j]; 844 845 return cmd_record(i, rec_argv, NULL); 846 } 847 848 static int 849 kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv) 850 { 851 const struct option kvm_events_report_options[] = { 852 OPT_STRING(0, "event", &kvm->report_event, "report event", 853 "event for reporting: vmexit, mmio, ioport"), 854 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu, 855 "vcpu id to report"), 856 OPT_STRING('k', "key", &kvm->sort_key, "sort-key", 857 "key for sorting: sample(sort by samples number)" 858 " time (sort by avg time)"), 859 OPT_END() 860 }; 861 862 const char * const kvm_events_report_usage[] = { 863 "perf kvm stat report [<options>]", 864 NULL 865 }; 866 867 symbol__init(); 868 869 if (argc) { 870 argc = parse_options(argc, argv, 871 kvm_events_report_options, 872 kvm_events_report_usage, 0); 873 if (argc) 874 usage_with_options(kvm_events_report_usage, 875 kvm_events_report_options); 876 } 877 878 return kvm_events_report_vcpu(kvm); 879 } 880 881 static void print_kvm_stat_usage(void) 882 { 883 printf("Usage: perf kvm stat <command>\n\n"); 884 885 printf("# Available commands:\n"); 886 printf("\trecord: record kvm events\n"); 887 printf("\treport: report statistical data of kvm events\n"); 888 889 printf("\nOtherwise, it is the alias of 'perf stat':\n"); 890 } 891 892 static int kvm_cmd_stat(const char *file_name, int argc, const char **argv) 893 { 894 struct perf_kvm_stat kvm = { 895 .file_name = file_name, 896 897 .trace_vcpu = -1, 898 .report_event = "vmexit", 899 .sort_key = "sample", 900 901 .exit_reasons = svm_exit_reasons, 902 .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons), 903 .exit_reasons_isa = "SVM", 904 }; 905 906 if (argc == 1) { 907 print_kvm_stat_usage(); 908 goto perf_stat; 909 } 910 911 if (!strncmp(argv[1], "rec", 3)) 912 return kvm_events_record(&kvm, argc - 1, argv + 1); 913 914 if (!strncmp(argv[1], "rep", 3)) 915 return kvm_events_report(&kvm, argc - 1 , argv + 1); 916 917 perf_stat: 918 return cmd_stat(argc, argv, NULL); 919 } 920 #endif 921 922 static int __cmd_record(const char *file_name, int argc, const char **argv) 923 { 924 int rec_argc, i = 0, j; 925 const char **rec_argv; 926 927 rec_argc = argc + 2; 928 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 929 rec_argv[i++] = strdup("record"); 930 rec_argv[i++] = strdup("-o"); 931 rec_argv[i++] = strdup(file_name); 932 for (j = 1; j < argc; j++, i++) 933 rec_argv[i] = argv[j]; 934 935 BUG_ON(i != rec_argc); 936 937 return cmd_record(i, rec_argv, NULL); 938 } 939 940 static int __cmd_report(const char *file_name, int argc, const char **argv) 941 { 942 int rec_argc, i = 0, j; 943 const char **rec_argv; 944 945 rec_argc = argc + 2; 946 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 947 rec_argv[i++] = strdup("report"); 948 rec_argv[i++] = strdup("-i"); 949 rec_argv[i++] = strdup(file_name); 950 for (j = 1; j < argc; j++, i++) 951 rec_argv[i] = argv[j]; 952 953 BUG_ON(i != rec_argc); 954 955 return cmd_report(i, rec_argv, NULL); 956 } 957 958 static int 959 __cmd_buildid_list(const char *file_name, int argc, const char **argv) 960 { 961 int rec_argc, i = 0, j; 962 const char **rec_argv; 963 964 rec_argc = argc + 2; 965 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 966 rec_argv[i++] = strdup("buildid-list"); 967 rec_argv[i++] = strdup("-i"); 968 rec_argv[i++] = strdup(file_name); 969 for (j = 1; j < argc; j++, i++) 970 rec_argv[i] = argv[j]; 971 972 BUG_ON(i != rec_argc); 973 974 return cmd_buildid_list(i, rec_argv, NULL); 975 } 976 977 int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused) 978 { 979 const char *file_name = NULL; 980 const struct option kvm_options[] = { 981 OPT_STRING('i', "input", &file_name, "file", 982 "Input file name"), 983 OPT_STRING('o', "output", &file_name, "file", 984 "Output file name"), 985 OPT_BOOLEAN(0, "guest", &perf_guest, 986 "Collect guest os data"), 987 OPT_BOOLEAN(0, "host", &perf_host, 988 "Collect host os data"), 989 OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory", 990 "guest mount directory under which every guest os" 991 " instance has a subdir"), 992 OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name, 993 "file", "file saving guest os vmlinux"), 994 OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms, 995 "file", "file saving guest os /proc/kallsyms"), 996 OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules, 997 "file", "file saving guest os /proc/modules"), 998 OPT_END() 999 }; 1000 1001 1002 const char * const kvm_usage[] = { 1003 "perf kvm [<options>] {top|record|report|diff|buildid-list|stat}", 1004 NULL 1005 }; 1006 1007 perf_host = 0; 1008 perf_guest = 1; 1009 1010 argc = parse_options(argc, argv, kvm_options, kvm_usage, 1011 PARSE_OPT_STOP_AT_NON_OPTION); 1012 if (!argc) 1013 usage_with_options(kvm_usage, kvm_options); 1014 1015 if (!perf_host) 1016 perf_guest = 1; 1017 1018 if (!file_name) { 1019 if (perf_host && !perf_guest) 1020 file_name = strdup("perf.data.host"); 1021 else if (!perf_host && perf_guest) 1022 file_name = strdup("perf.data.guest"); 1023 else 1024 file_name = strdup("perf.data.kvm"); 1025 1026 if (!file_name) { 1027 pr_err("Failed to allocate memory for filename\n"); 1028 return -ENOMEM; 1029 } 1030 } 1031 1032 if (!strncmp(argv[0], "rec", 3)) 1033 return __cmd_record(file_name, argc, argv); 1034 else if (!strncmp(argv[0], "rep", 3)) 1035 return __cmd_report(file_name, argc, argv); 1036 else if (!strncmp(argv[0], "diff", 4)) 1037 return cmd_diff(argc, argv, NULL); 1038 else if (!strncmp(argv[0], "top", 3)) 1039 return cmd_top(argc, argv, NULL); 1040 else if (!strncmp(argv[0], "buildid-list", 12)) 1041 return __cmd_buildid_list(file_name, argc, argv); 1042 #if defined(__i386__) || defined(__x86_64__) 1043 else if (!strncmp(argv[0], "stat", 4)) 1044 return kvm_cmd_stat(file_name, argc, argv); 1045 #endif 1046 else 1047 usage_with_options(kvm_usage, kvm_options); 1048 1049 return 0; 1050 } 1051