tools/perf/builtin-kvm.c

   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 "util/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         int i;
 318
 319         for (i = 0; i < (int)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
 332         if (vcpu_id < event->max_vcpu)
 333                 return true;
 334
 335         while (event->max_vcpu <= vcpu_id)
 336                 event->max_vcpu += DEFAULT_VCPU_NUM;
 337
 338         event->vcpu = realloc(event->vcpu,
 339                               event->max_vcpu * sizeof(*event->vcpu));
 340         if (!event->vcpu) {
 341                 pr_err("Not enough memory\n");
 342                 return false;
 343         }
 344
 345         memset(event->vcpu + old_max_vcpu, 0,
 346                (event->max_vcpu - old_max_vcpu) * sizeof(*event->vcpu));
 347         return true;
 348 }
 349
 350 static struct kvm_event *kvm_alloc_init_event(struct event_key *key)
 351 {
 352         struct kvm_event *event;
 353
 354         event = zalloc(sizeof(*event));
 355         if (!event) {
 356                 pr_err("Not enough memory\n");
 357                 return NULL;
 358         }
 359
 360         event->key = *key;
 361         return event;
 362 }
 363
 364 static struct kvm_event *find_create_kvm_event(struct perf_kvm_stat *kvm,
 365                                                struct event_key *key)
 366 {
 367         struct kvm_event *event;
 368         struct list_head *head;
 369
 370         BUG_ON(key->key == INVALID_KEY);
 371
 372         head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)];
 373         list_for_each_entry(event, head, hash_entry)
 374                 if (event->key.key == key->key && event->key.info == key->info)
 375                         return event;
 376
 377         event = kvm_alloc_init_event(key);
 378         if (!event)
 379                 return NULL;
 380
 381         list_add(&event->hash_entry, head);
 382         return event;
 383 }
 384
 385 static bool handle_begin_event(struct perf_kvm_stat *kvm,
 386                                struct vcpu_event_record *vcpu_record,
 387                                struct event_key *key, u64 timestamp)
 388 {
 389         struct kvm_event *event = NULL;
 390
 391         if (key->key != INVALID_KEY)
 392                 event = find_create_kvm_event(kvm, key);
 393
 394         vcpu_record->last_event = event;
 395         vcpu_record->start_time = timestamp;
 396         return true;
 397 }
 398
 399 static void
 400 kvm_update_event_stats(struct kvm_event_stats *kvm_stats, u64 time_diff)
 401 {
 402         kvm_stats->time += time_diff;
 403         update_stats(&kvm_stats->stats, time_diff);
 404 }
 405
 406 static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event)
 407 {
 408         struct kvm_event_stats *kvm_stats = &event->total;
 409
 410         if (vcpu_id != -1)
 411                 kvm_stats = &event->vcpu[vcpu_id];
 412
 413         return rel_stddev_stats(stddev_stats(&kvm_stats->stats),
 414                                 avg_stats(&kvm_stats->stats));
 415 }
 416
 417 static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
 418                              u64 time_diff)
 419 {
 420         kvm_update_event_stats(&event->total, time_diff);
 421
 422         if (!kvm_event_expand(event, vcpu_id))
 423                 return false;
 424
 425         kvm_update_event_stats(&event->vcpu[vcpu_id], time_diff);
 426         return true;
 427 }
 428
 429 static bool handle_end_event(struct perf_kvm_stat *kvm,
 430                              struct vcpu_event_record *vcpu_record,
 431                              struct event_key *key,
 432                              u64 timestamp)
 433 {
 434         struct kvm_event *event;
 435         u64 time_begin, time_diff;
 436
 437         event = vcpu_record->last_event;
 438         time_begin = vcpu_record->start_time;
 439
 440         /* The begin event is not caught. */
 441         if (!time_begin)
 442                 return true;
 443
 444         /*
 445          * In some case, the 'begin event' only records the start timestamp,
 446          * the actual event is recognized in the 'end event' (e.g. mmio-event).
 447          */
 448
 449         /* Both begin and end events did not get the key. */
 450         if (!event && key->key == INVALID_KEY)
 451                 return true;
 452
 453         if (!event)
 454                 event = find_create_kvm_event(kvm, key);
 455
 456         if (!event)
 457                 return false;
 458
 459         vcpu_record->last_event = NULL;
 460         vcpu_record->start_time = 0;
 461
 462         BUG_ON(timestamp < time_begin);
 463
 464         time_diff = timestamp - time_begin;
 465         return update_kvm_event(event, vcpu_record->vcpu_id, time_diff);
 466 }
 467
 468 static
 469 struct vcpu_event_record *per_vcpu_record(struct thread *thread,
 470                                           struct perf_evsel *evsel,
 471                                           struct perf_sample *sample)
 472 {
 473         /* Only kvm_entry records vcpu id. */
 474         if (!thread->priv && kvm_entry_event(evsel)) {
 475                 struct vcpu_event_record *vcpu_record;
 476
 477                 vcpu_record = zalloc(sizeof(*vcpu_record));
 478                 if (!vcpu_record) {
 479                         pr_err("%s: Not enough memory\n", __func__);
 480                         return NULL;
 481                 }
 482
 483                 vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id");
 484                 thread->priv = vcpu_record;
 485         }
 486
 487         return thread->priv;
 488 }
 489
 490 static bool handle_kvm_event(struct perf_kvm_stat *kvm,
 491                              struct thread *thread,
 492                              struct perf_evsel *evsel,
 493                              struct perf_sample *sample)
 494 {
 495         struct vcpu_event_record *vcpu_record;
 496         struct event_key key = {.key = INVALID_KEY};
 497
 498         vcpu_record = per_vcpu_record(thread, evsel, sample);
 499         if (!vcpu_record)
 500                 return true;
 501
 502         if (kvm->events_ops->is_begin_event(evsel, sample, &key))
 503                 return handle_begin_event(kvm, vcpu_record, &key, sample->time);
 504
 505         if (kvm->events_ops->is_end_event(evsel, sample, &key))
 506                 return handle_end_event(kvm, vcpu_record, &key, sample->time);
 507
 508         return true;
 509 }
 510
 511 #define GET_EVENT_KEY(func, field)                                      \
 512 static u64 get_event_ ##func(struct kvm_event *event, int vcpu)         \
 513 {                                                                       \
 514         if (vcpu == -1)                                                 \
 515                 return event->total.field;                              \
 516                                                                         \
 517         if (vcpu >= event->max_vcpu)                                    \
 518                 return 0;                                               \
 519                                                                         \
 520         return event->vcpu[vcpu].field;                                 \
 521 }
 522
 523 #define COMPARE_EVENT_KEY(func, field)                                  \
 524 GET_EVENT_KEY(func, field)                                              \
 525 static int compare_kvm_event_ ## func(struct kvm_event *one,            \
 526                                         struct kvm_event *two, int vcpu)\
 527 {                                                                       \
 528         return get_event_ ##func(one, vcpu) >                           \
 529                                 get_event_ ##func(two, vcpu);           \
 530 }
 531
 532 GET_EVENT_KEY(time, time);
 533 COMPARE_EVENT_KEY(count, stats.n);
 534 COMPARE_EVENT_KEY(mean, stats.mean);
 535
 536 #define DEF_SORT_NAME_KEY(name, compare_key)                            \
 537         { #name, compare_kvm_event_ ## compare_key }
 538
 539 static struct kvm_event_key keys[] = {
 540         DEF_SORT_NAME_KEY(sample, count),
 541         DEF_SORT_NAME_KEY(time, mean),
 542         { NULL, NULL }
 543 };
 544
 545 static bool select_key(struct perf_kvm_stat *kvm)
 546 {
 547         int i;
 548
 549         for (i = 0; keys[i].name; i++) {
 550                 if (!strcmp(keys[i].name, kvm->sort_key)) {
 551                         kvm->compare = keys[i].key;
 552                         return true;
 553                 }
 554         }
 555
 556         pr_err("Unknown compare key:%s\n", kvm->sort_key);
 557         return false;
 558 }
 559
 560 static void insert_to_result(struct rb_root *result, struct kvm_event *event,
 561                              key_cmp_fun bigger, int vcpu)
 562 {
 563         struct rb_node **rb = &result->rb_node;
 564         struct rb_node *parent = NULL;
 565         struct kvm_event *p;
 566
 567         while (*rb) {
 568                 p = container_of(*rb, struct kvm_event, rb);
 569                 parent = *rb;
 570
 571                 if (bigger(event, p, vcpu))
 572                         rb = &(*rb)->rb_left;
 573                 else
 574                         rb = &(*rb)->rb_right;
 575         }
 576
 577         rb_link_node(&event->rb, parent, rb);
 578         rb_insert_color(&event->rb, result);
 579 }
 580
 581 static void
 582 update_total_count(struct perf_kvm_stat *kvm, struct kvm_event *event)
 583 {
 584         int vcpu = kvm->trace_vcpu;
 585
 586         kvm->total_count += get_event_count(event, vcpu);
 587         kvm->total_time += get_event_time(event, vcpu);
 588 }
 589
 590 static bool event_is_valid(struct kvm_event *event, int vcpu)
 591 {
 592         return !!get_event_count(event, vcpu);
 593 }
 594
 595 static void sort_result(struct perf_kvm_stat *kvm)
 596 {
 597         unsigned int i;
 598         int vcpu = kvm->trace_vcpu;
 599         struct kvm_event *event;
 600
 601         for (i = 0; i < EVENTS_CACHE_SIZE; i++)
 602                 list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry)
 603                         if (event_is_valid(event, vcpu)) {
 604                                 update_total_count(kvm, event);
 605                                 insert_to_result(&kvm->result, event,
 606                                                  kvm->compare, vcpu);
 607                         }
 608 }
 609
 610 /* returns left most element of result, and erase it */
 611 static struct kvm_event *pop_from_result(struct rb_root *result)
 612 {
 613         struct rb_node *node = rb_first(result);
 614
 615         if (!node)
 616                 return NULL;
 617
 618         rb_erase(node, result);
 619         return container_of(node, struct kvm_event, rb);
 620 }
 621
 622 static void print_vcpu_info(int vcpu)
 623 {
 624         pr_info("Analyze events for ");
 625
 626         if (vcpu == -1)
 627                 pr_info("all VCPUs:\n\n");
 628         else
 629                 pr_info("VCPU %d:\n\n", vcpu);
 630 }
 631
 632 static void print_result(struct perf_kvm_stat *kvm)
 633 {
 634         char decode[20];
 635         struct kvm_event *event;
 636         int vcpu = kvm->trace_vcpu;
 637
 638         pr_info("\n\n");
 639         print_vcpu_info(vcpu);
 640         pr_info("%20s ", kvm->events_ops->name);
 641         pr_info("%10s ", "Samples");
 642         pr_info("%9s ", "Samples%");
 643
 644         pr_info("%9s ", "Time%");
 645         pr_info("%16s ", "Avg time");
 646         pr_info("\n\n");
 647
 648         while ((event = pop_from_result(&kvm->result))) {
 649                 u64 ecount, etime;
 650
 651                 ecount = get_event_count(event, vcpu);
 652                 etime = get_event_time(event, vcpu);
 653
 654                 kvm->events_ops->decode_key(kvm, &event->key, decode);
 655                 pr_info("%20s ", decode);
 656                 pr_info("%10llu ", (unsigned long long)ecount);
 657                 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100);
 658                 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100);
 659                 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
 660                         kvm_event_rel_stddev(vcpu, event));
 661                 pr_info("\n");
 662         }
 663
 664         pr_info("\nTotal Samples:%lld, Total events handled time:%.2fus.\n\n",
 665                 (unsigned long long)kvm->total_count, kvm->total_time / 1e3);
 666 }
 667
 668 static int process_sample_event(struct perf_tool *tool,
 669                                 union perf_event *event,
 670                                 struct perf_sample *sample,
 671                                 struct perf_evsel *evsel,
 672                                 struct machine *machine)
 673 {
 674         struct thread *thread = machine__findnew_thread(machine, sample->tid);
 675         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat,
 676                                                  tool);
 677
 678         if (thread == NULL) {
 679                 pr_debug("problem processing %d event, skipping it.\n",
 680                         event->header.type);
 681                 return -1;
 682         }
 683
 684         if (!handle_kvm_event(kvm, thread, evsel, sample))
 685                 return -1;
 686
 687         return 0;
 688 }
 689
 690 static int get_cpu_isa(struct perf_session *session)
 691 {
 692         char *cpuid = session->header.env.cpuid;
 693         int isa;
 694
 695         if (strstr(cpuid, "Intel"))
 696                 isa = 1;
 697         else if (strstr(cpuid, "AMD"))
 698                 isa = 0;
 699         else {
 700                 pr_err("CPU %s is not supported.\n", cpuid);
 701                 isa = -ENOTSUP;
 702         }
 703
 704         return isa;
 705 }
 706
 707 static int read_events(struct perf_kvm_stat *kvm)
 708 {
 709         int ret;
 710
 711         struct perf_tool eops = {
 712                 .sample                 = process_sample_event,
 713                 .comm                   = perf_event__process_comm,
 714                 .ordered_samples        = true,
 715         };
 716
 717         kvm->tool = eops;
 718         kvm->session = perf_session__new(kvm->file_name, O_RDONLY, 0, false,
 719                                          &kvm->tool);
 720         if (!kvm->session) {
 721                 pr_err("Initializing perf session failed\n");
 722                 return -EINVAL;
 723         }
 724
 725         if (!perf_session__has_traces(kvm->session, "kvm record"))
 726                 return -EINVAL;
 727
 728         /*
 729          * Do not use 'isa' recorded in kvm_exit tracepoint since it is not
 730          * traced in the old kernel.
 731          */
 732         ret = get_cpu_isa(kvm->session);
 733
 734         if (ret < 0)
 735                 return ret;
 736
 737         if (ret == 1) {
 738                 kvm->exit_reasons = vmx_exit_reasons;
 739                 kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
 740                 kvm->exit_reasons_isa = "VMX";
 741         }
 742
 743         return perf_session__process_events(kvm->session, &kvm->tool);
 744 }
 745
 746 static bool verify_vcpu(int vcpu)
 747 {
 748         if (vcpu != -1 && vcpu < 0) {
 749                 pr_err("Invalid vcpu:%d.\n", vcpu);
 750                 return false;
 751         }
 752
 753         return true;
 754 }
 755
 756 static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm)
 757 {
 758         int ret = -EINVAL;
 759         int vcpu = kvm->trace_vcpu;
 760
 761         if (!verify_vcpu(vcpu))
 762                 goto exit;
 763
 764         if (!select_key(kvm))
 765                 goto exit;
 766
 767         if (!register_kvm_events_ops(kvm))
 768                 goto exit;
 769
 770         init_kvm_event_record(kvm);
 771         setup_pager();
 772
 773         ret = read_events(kvm);
 774         if (ret)
 775                 goto exit;
 776
 777         sort_result(kvm);
 778         print_result(kvm);
 779
 780 exit:
 781         return ret;
 782 }
 783
 784 static const char * const record_args[] = {
 785         "record",
 786         "-R",
 787         "-f",
 788         "-m", "1024",
 789         "-c", "1",
 790         "-e", "kvm:kvm_entry",
 791         "-e", "kvm:kvm_exit",
 792         "-e", "kvm:kvm_mmio",
 793         "-e", "kvm:kvm_pio",
 794 };
 795
 796 #define STRDUP_FAIL_EXIT(s)             \
 797         ({      char *_p;               \
 798         _p = strdup(s);         \
 799                 if (!_p)                \
 800                         return -ENOMEM; \
 801                 _p;                     \
 802         })
 803
 804 static int
 805 kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
 806 {
 807         unsigned int rec_argc, i, j;
 808         const char **rec_argv;
 809
 810         rec_argc = ARRAY_SIZE(record_args) + argc + 2;
 811         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 812
 813         if (rec_argv == NULL)
 814                 return -ENOMEM;
 815
 816         for (i = 0; i < ARRAY_SIZE(record_args); i++)
 817                 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]);
 818
 819         rec_argv[i++] = STRDUP_FAIL_EXIT("-o");
 820         rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name);
 821
 822         for (j = 1; j < (unsigned int)argc; j++, i++)
 823                 rec_argv[i] = argv[j];
 824
 825         return cmd_record(i, rec_argv, NULL);
 826 }
 827
 828 static int
 829 kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
 830 {
 831         const struct option kvm_events_report_options[] = {
 832                 OPT_STRING(0, "event", &kvm->report_event, "report event",
 833                             "event for reporting: vmexit, mmio, ioport"),
 834                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
 835                             "vcpu id to report"),
 836                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
 837                             "key for sorting: sample(sort by samples number)"
 838                             " time (sort by avg time)"),
 839                 OPT_END()
 840         };
 841
 842         const char * const kvm_events_report_usage[] = {
 843                 "perf kvm stat report [<options>]",
 844                 NULL
 845         };
 846
 847         symbol__init();
 848
 849         if (argc) {
 850                 argc = parse_options(argc, argv,
 851                                      kvm_events_report_options,
 852                                      kvm_events_report_usage, 0);
 853                 if (argc)
 854                         usage_with_options(kvm_events_report_usage,
 855                                            kvm_events_report_options);
 856         }
 857
 858         return kvm_events_report_vcpu(kvm);
 859 }
 860
 861 static void print_kvm_stat_usage(void)
 862 {
 863         printf("Usage: perf kvm stat <command>\n\n");
 864
 865         printf("# Available commands:\n");
 866         printf("\trecord: record kvm events\n");
 867         printf("\treport: report statistical data of kvm events\n");
 868
 869         printf("\nOtherwise, it is the alias of 'perf stat':\n");
 870 }
 871
 872 static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
 873 {
 874         struct perf_kvm_stat kvm = {
 875                 .file_name = file_name,
 876
 877                 .trace_vcpu     = -1,
 878                 .report_event   = "vmexit",
 879                 .sort_key       = "sample",
 880
 881                 .exit_reasons = svm_exit_reasons,
 882                 .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons),
 883                 .exit_reasons_isa = "SVM",
 884         };
 885
 886         if (argc == 1) {
 887                 print_kvm_stat_usage();
 888                 goto perf_stat;
 889         }
 890
 891         if (!strncmp(argv[1], "rec", 3))
 892                 return kvm_events_record(&kvm, argc - 1, argv + 1);
 893
 894         if (!strncmp(argv[1], "rep", 3))
 895                 return kvm_events_report(&kvm, argc - 1 , argv + 1);
 896
 897 perf_stat:
 898         return cmd_stat(argc, argv, NULL);
 899 }
 900 #endif
 901
 902 static int __cmd_record(const char *file_name, int argc, const char **argv)
 903 {
 904         int rec_argc, i = 0, j;
 905         const char **rec_argv;
 906
 907         rec_argc = argc + 2;
 908         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 909         rec_argv[i++] = strdup("record");
 910         rec_argv[i++] = strdup("-o");
 911         rec_argv[i++] = strdup(file_name);
 912         for (j = 1; j < argc; j++, i++)
 913                 rec_argv[i] = argv[j];
 914
 915         BUG_ON(i != rec_argc);
 916
 917         return cmd_record(i, rec_argv, NULL);
 918 }
 919
 920 static int __cmd_report(const char *file_name, int argc, const char **argv)
 921 {
 922         int rec_argc, i = 0, j;
 923         const char **rec_argv;
 924
 925         rec_argc = argc + 2;
 926         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 927         rec_argv[i++] = strdup("report");
 928         rec_argv[i++] = strdup("-i");
 929         rec_argv[i++] = strdup(file_name);
 930         for (j = 1; j < argc; j++, i++)
 931                 rec_argv[i] = argv[j];
 932
 933         BUG_ON(i != rec_argc);
 934
 935         return cmd_report(i, rec_argv, NULL);
 936 }
 937
 938 static int
 939 __cmd_buildid_list(const char *file_name, int argc, const char **argv)
 940 {
 941         int rec_argc, i = 0, j;
 942         const char **rec_argv;
 943
 944         rec_argc = argc + 2;
 945         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 946         rec_argv[i++] = strdup("buildid-list");
 947         rec_argv[i++] = strdup("-i");
 948         rec_argv[i++] = strdup(file_name);
 949         for (j = 1; j < argc; j++, i++)
 950                 rec_argv[i] = argv[j];
 951
 952         BUG_ON(i != rec_argc);
 953
 954         return cmd_buildid_list(i, rec_argv, NULL);
 955 }
 956
 957 int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
 958 {
 959         const char *file_name;
 960
 961         const struct option kvm_options[] = {
 962                 OPT_STRING('i', "input", &file_name, "file",
 963                            "Input file name"),
 964                 OPT_STRING('o', "output", &file_name, "file",
 965                            "Output file name"),
 966                 OPT_BOOLEAN(0, "guest", &perf_guest,
 967                             "Collect guest os data"),
 968                 OPT_BOOLEAN(0, "host", &perf_host,
 969                             "Collect host os data"),
 970                 OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
 971                            "guest mount directory under which every guest os"
 972                            " instance has a subdir"),
 973                 OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
 974                            "file", "file saving guest os vmlinux"),
 975                 OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
 976                            "file", "file saving guest os /proc/kallsyms"),
 977                 OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
 978                            "file", "file saving guest os /proc/modules"),
 979                 OPT_END()
 980         };
 981
 982
 983         const char * const kvm_usage[] = {
 984                 "perf kvm [<options>] {top|record|report|diff|buildid-list|stat}",
 985                 NULL
 986         };
 987
 988         perf_host  = 0;
 989         perf_guest = 1;
 990
 991         argc = parse_options(argc, argv, kvm_options, kvm_usage,
 992                         PARSE_OPT_STOP_AT_NON_OPTION);
 993         if (!argc)
 994                 usage_with_options(kvm_usage, kvm_options);
 995
 996         if (!perf_host)
 997                 perf_guest = 1;
 998
 999         if (!file_name) {
1000                 if (perf_host && !perf_guest)
1001                         file_name = strdup("perf.data.host");
1002                 else if (!perf_host && perf_guest)
1003                         file_name = strdup("perf.data.guest");
1004                 else
1005                         file_name = strdup("perf.data.kvm");
1006
1007                 if (!file_name) {
1008                         pr_err("Failed to allocate memory for filename\n");
1009                         return -ENOMEM;
1010                 }
1011         }
1012
1013         if (!strncmp(argv[0], "rec", 3))
1014                 return __cmd_record(file_name, argc, argv);
1015         else if (!strncmp(argv[0], "rep", 3))
1016                 return __cmd_report(file_name, argc, argv);
1017         else if (!strncmp(argv[0], "diff", 4))
1018                 return cmd_diff(argc, argv, NULL);
1019         else if (!strncmp(argv[0], "top", 3))
1020                 return cmd_top(argc, argv, NULL);
1021         else if (!strncmp(argv[0], "buildid-list", 12))
1022                 return __cmd_buildid_list(file_name, argc, argv);
1023 #if defined(__i386__) || defined(__x86_64__)
1024         else if (!strncmp(argv[0], "stat", 4))
1025                 return kvm_cmd_stat(file_name, argc, argv);
1026 #endif
1027         else
1028                 usage_with_options(kvm_usage, kvm_options);
1029
1030         return 0;
1031 }