tools/perf/builtin-kvm.c

   1 #include "builtin.h"
   2 #include "perf.h"
   3
   4 #include "util/evsel.h"
   5 #include "util/evlist.h"
   6 #include "util/util.h"
   7 #include "util/cache.h"
   8 #include "util/symbol.h"
   9 #include "util/thread.h"
  10 #include "util/header.h"
  11 #include "util/session.h"
  12 #include "util/intlist.h"
  13 #include "util/parse-options.h"
  14 #include "util/trace-event.h"
  15 #include "util/debug.h"
  16 #include <api/fs/debugfs.h>
  17 #include "util/tool.h"
  18 #include "util/stat.h"
  19 #include "util/top.h"
  20 #include "util/data.h"
  21
  22 #include <sys/prctl.h>
  23 #ifdef HAVE_TIMERFD_SUPPORT
  24 #include <sys/timerfd.h>
  25 #endif
  26
  27 #include <termios.h>
  28 #include <semaphore.h>
  29 #include <pthread.h>
  30 #include <math.h>
  31
  32 #if defined(__i386__) || defined(__x86_64__)
  33 #include <asm/svm.h>
  34 #include <asm/vmx.h>
  35 #include <asm/kvm.h>
  36
  37 struct event_key {
  38         #define INVALID_KEY     (~0ULL)
  39         u64 key;
  40         int info;
  41 };
  42
  43 struct kvm_event_stats {
  44         u64 time;
  45         struct stats stats;
  46 };
  47
  48 struct kvm_event {
  49         struct list_head hash_entry;
  50         struct rb_node rb;
  51
  52         struct event_key key;
  53
  54         struct kvm_event_stats total;
  55
  56         #define DEFAULT_VCPU_NUM 8
  57         int max_vcpu;
  58         struct kvm_event_stats *vcpu;
  59 };
  60
  61 typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int);
  62
  63 struct kvm_event_key {
  64         const char *name;
  65         key_cmp_fun key;
  66 };
  67
  68
  69 struct perf_kvm_stat;
  70
  71 struct kvm_events_ops {
  72         bool (*is_begin_event)(struct perf_evsel *evsel,
  73                                struct perf_sample *sample,
  74                                struct event_key *key);
  75         bool (*is_end_event)(struct perf_evsel *evsel,
  76                              struct perf_sample *sample, struct event_key *key);
  77         void (*decode_key)(struct perf_kvm_stat *kvm, struct event_key *key,
  78                            char decode[20]);
  79         const char *name;
  80 };
  81
  82 struct exit_reasons_table {
  83         unsigned long exit_code;
  84         const char *reason;
  85 };
  86
  87 #define EVENTS_BITS             12
  88 #define EVENTS_CACHE_SIZE       (1UL << EVENTS_BITS)
  89
  90 struct perf_kvm_stat {
  91         struct perf_tool    tool;
  92         struct record_opts  opts;
  93         struct perf_evlist  *evlist;
  94         struct perf_session *session;
  95
  96         const char *file_name;
  97         const char *report_event;
  98         const char *sort_key;
  99         int trace_vcpu;
 100
 101         struct exit_reasons_table *exit_reasons;
 102         int exit_reasons_size;
 103         const char *exit_reasons_isa;
 104
 105         struct kvm_events_ops *events_ops;
 106         key_cmp_fun compare;
 107         struct list_head kvm_events_cache[EVENTS_CACHE_SIZE];
 108
 109         u64 total_time;
 110         u64 total_count;
 111         u64 lost_events;
 112         u64 duration;
 113
 114         const char *pid_str;
 115         struct intlist *pid_list;
 116
 117         struct rb_root result;
 118
 119         int timerfd;
 120         unsigned int display_time;
 121         bool live;
 122 };
 123
 124
 125 static void exit_event_get_key(struct perf_evsel *evsel,
 126                                struct perf_sample *sample,
 127                                struct event_key *key)
 128 {
 129         key->info = 0;
 130         key->key = perf_evsel__intval(evsel, sample, "exit_reason");
 131 }
 132
 133 static bool kvm_exit_event(struct perf_evsel *evsel)
 134 {
 135         return !strcmp(evsel->name, "kvm:kvm_exit");
 136 }
 137
 138 static bool exit_event_begin(struct perf_evsel *evsel,
 139                              struct perf_sample *sample, struct event_key *key)
 140 {
 141         if (kvm_exit_event(evsel)) {
 142                 exit_event_get_key(evsel, sample, key);
 143                 return true;
 144         }
 145
 146         return false;
 147 }
 148
 149 static bool kvm_entry_event(struct perf_evsel *evsel)
 150 {
 151         return !strcmp(evsel->name, "kvm:kvm_entry");
 152 }
 153
 154 static bool exit_event_end(struct perf_evsel *evsel,
 155                            struct perf_sample *sample __maybe_unused,
 156                            struct event_key *key __maybe_unused)
 157 {
 158         return kvm_entry_event(evsel);
 159 }
 160
 161 static struct exit_reasons_table vmx_exit_reasons[] = {
 162         VMX_EXIT_REASONS
 163 };
 164
 165 static struct exit_reasons_table svm_exit_reasons[] = {
 166         SVM_EXIT_REASONS
 167 };
 168
 169 static const char *get_exit_reason(struct perf_kvm_stat *kvm, u64 exit_code)
 170 {
 171         int i = kvm->exit_reasons_size;
 172         struct exit_reasons_table *tbl = kvm->exit_reasons;
 173
 174         while (i--) {
 175                 if (tbl->exit_code == exit_code)
 176                         return tbl->reason;
 177                 tbl++;
 178         }
 179
 180         pr_err("unknown kvm exit code:%lld on %s\n",
 181                 (unsigned long long)exit_code, kvm->exit_reasons_isa);
 182         return "UNKNOWN";
 183 }
 184
 185 static void exit_event_decode_key(struct perf_kvm_stat *kvm,
 186                                   struct event_key *key,
 187                                   char decode[20])
 188 {
 189         const char *exit_reason = get_exit_reason(kvm, key->key);
 190
 191         scnprintf(decode, 20, "%s", exit_reason);
 192 }
 193
 194 static struct kvm_events_ops exit_events = {
 195         .is_begin_event = exit_event_begin,
 196         .is_end_event = exit_event_end,
 197         .decode_key = exit_event_decode_key,
 198         .name = "VM-EXIT"
 199 };
 200
 201 /*
 202  * For the mmio events, we treat:
 203  * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
 204  * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
 205  */
 206 static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample,
 207                                struct event_key *key)
 208 {
 209         key->key  = perf_evsel__intval(evsel, sample, "gpa");
 210         key->info = perf_evsel__intval(evsel, sample, "type");
 211 }
 212
 213 #define KVM_TRACE_MMIO_READ_UNSATISFIED 0
 214 #define KVM_TRACE_MMIO_READ 1
 215 #define KVM_TRACE_MMIO_WRITE 2
 216
 217 static bool mmio_event_begin(struct perf_evsel *evsel,
 218                              struct perf_sample *sample, struct event_key *key)
 219 {
 220         /* MMIO read begin event in kernel. */
 221         if (kvm_exit_event(evsel))
 222                 return true;
 223
 224         /* MMIO write begin event in kernel. */
 225         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
 226             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
 227                 mmio_event_get_key(evsel, sample, key);
 228                 return true;
 229         }
 230
 231         return false;
 232 }
 233
 234 static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample,
 235                            struct event_key *key)
 236 {
 237         /* MMIO write end event in kernel. */
 238         if (kvm_entry_event(evsel))
 239                 return true;
 240
 241         /* MMIO read end event in kernel.*/
 242         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
 243             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
 244                 mmio_event_get_key(evsel, sample, key);
 245                 return true;
 246         }
 247
 248         return false;
 249 }
 250
 251 static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
 252                                   struct event_key *key,
 253                                   char decode[20])
 254 {
 255         scnprintf(decode, 20, "%#lx:%s", (unsigned long)key->key,
 256                                 key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
 257 }
 258
 259 static struct kvm_events_ops mmio_events = {
 260         .is_begin_event = mmio_event_begin,
 261         .is_end_event = mmio_event_end,
 262         .decode_key = mmio_event_decode_key,
 263         .name = "MMIO Access"
 264 };
 265
 266  /* The time of emulation pio access is from kvm_pio to kvm_entry. */
 267 static void ioport_event_get_key(struct perf_evsel *evsel,
 268                                  struct perf_sample *sample,
 269                                  struct event_key *key)
 270 {
 271         key->key  = perf_evsel__intval(evsel, sample, "port");
 272         key->info = perf_evsel__intval(evsel, sample, "rw");
 273 }
 274
 275 static bool ioport_event_begin(struct perf_evsel *evsel,
 276                                struct perf_sample *sample,
 277                                struct event_key *key)
 278 {
 279         if (!strcmp(evsel->name, "kvm:kvm_pio")) {
 280                 ioport_event_get_key(evsel, sample, key);
 281                 return true;
 282         }
 283
 284         return false;
 285 }
 286
 287 static bool ioport_event_end(struct perf_evsel *evsel,
 288                              struct perf_sample *sample __maybe_unused,
 289                              struct event_key *key __maybe_unused)
 290 {
 291         return kvm_entry_event(evsel);
 292 }
 293
 294 static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
 295                                     struct event_key *key,
 296                                     char decode[20])
 297 {
 298         scnprintf(decode, 20, "%#llx:%s", (unsigned long long)key->key,
 299                                 key->info ? "POUT" : "PIN");
 300 }
 301
 302 static struct kvm_events_ops ioport_events = {
 303         .is_begin_event = ioport_event_begin,
 304         .is_end_event = ioport_event_end,
 305         .decode_key = ioport_event_decode_key,
 306         .name = "IO Port Access"
 307 };
 308
 309 static bool register_kvm_events_ops(struct perf_kvm_stat *kvm)
 310 {
 311         bool ret = true;
 312
 313         if (!strcmp(kvm->report_event, "vmexit"))
 314                 kvm->events_ops = &exit_events;
 315         else if (!strcmp(kvm->report_event, "mmio"))
 316                 kvm->events_ops = &mmio_events;
 317         else if (!strcmp(kvm->report_event, "ioport"))
 318                 kvm->events_ops = &ioport_events;
 319         else {
 320                 pr_err("Unknown report event:%s\n", kvm->report_event);
 321                 ret = false;
 322         }
 323
 324         return ret;
 325 }
 326
 327 struct vcpu_event_record {
 328         int vcpu_id;
 329         u64 start_time;
 330         struct kvm_event *last_event;
 331 };
 332
 333
 334 static void init_kvm_event_record(struct perf_kvm_stat *kvm)
 335 {
 336         unsigned int i;
 337
 338         for (i = 0; i < EVENTS_CACHE_SIZE; i++)
 339                 INIT_LIST_HEAD(&kvm->kvm_events_cache[i]);
 340 }
 341
 342 #ifdef HAVE_TIMERFD_SUPPORT
 343 static void clear_events_cache_stats(struct list_head *kvm_events_cache)
 344 {
 345         struct list_head *head;
 346         struct kvm_event *event;
 347         unsigned int i;
 348         int j;
 349
 350         for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
 351                 head = &kvm_events_cache[i];
 352                 list_for_each_entry(event, head, hash_entry) {
 353                         /* reset stats for event */
 354                         event->total.time = 0;
 355                         init_stats(&event->total.stats);
 356
 357                         for (j = 0; j < event->max_vcpu; ++j) {
 358                                 event->vcpu[j].time = 0;
 359                                 init_stats(&event->vcpu[j].stats);
 360                         }
 361                 }
 362         }
 363 }
 364 #endif
 365
 366 static int kvm_events_hash_fn(u64 key)
 367 {
 368         return key & (EVENTS_CACHE_SIZE - 1);
 369 }
 370
 371 static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
 372 {
 373         int old_max_vcpu = event->max_vcpu;
 374         void *prev;
 375
 376         if (vcpu_id < event->max_vcpu)
 377                 return true;
 378
 379         while (event->max_vcpu <= vcpu_id)
 380                 event->max_vcpu += DEFAULT_VCPU_NUM;
 381
 382         prev = event->vcpu;
 383         event->vcpu = realloc(event->vcpu,
 384                               event->max_vcpu * sizeof(*event->vcpu));
 385         if (!event->vcpu) {
 386                 free(prev);
 387                 pr_err("Not enough memory\n");
 388                 return false;
 389         }
 390
 391         memset(event->vcpu + old_max_vcpu, 0,
 392                (event->max_vcpu - old_max_vcpu) * sizeof(*event->vcpu));
 393         return true;
 394 }
 395
 396 static struct kvm_event *kvm_alloc_init_event(struct event_key *key)
 397 {
 398         struct kvm_event *event;
 399
 400         event = zalloc(sizeof(*event));
 401         if (!event) {
 402                 pr_err("Not enough memory\n");
 403                 return NULL;
 404         }
 405
 406         event->key = *key;
 407         return event;
 408 }
 409
 410 static struct kvm_event *find_create_kvm_event(struct perf_kvm_stat *kvm,
 411                                                struct event_key *key)
 412 {
 413         struct kvm_event *event;
 414         struct list_head *head;
 415
 416         BUG_ON(key->key == INVALID_KEY);
 417
 418         head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)];
 419         list_for_each_entry(event, head, hash_entry) {
 420                 if (event->key.key == key->key && event->key.info == key->info)
 421                         return event;
 422         }
 423
 424         event = kvm_alloc_init_event(key);
 425         if (!event)
 426                 return NULL;
 427
 428         list_add(&event->hash_entry, head);
 429         return event;
 430 }
 431
 432 static bool handle_begin_event(struct perf_kvm_stat *kvm,
 433                                struct vcpu_event_record *vcpu_record,
 434                                struct event_key *key, u64 timestamp)
 435 {
 436         struct kvm_event *event = NULL;
 437
 438         if (key->key != INVALID_KEY)
 439                 event = find_create_kvm_event(kvm, key);
 440
 441         vcpu_record->last_event = event;
 442         vcpu_record->start_time = timestamp;
 443         return true;
 444 }
 445
 446 static void
 447 kvm_update_event_stats(struct kvm_event_stats *kvm_stats, u64 time_diff)
 448 {
 449         kvm_stats->time += time_diff;
 450         update_stats(&kvm_stats->stats, time_diff);
 451 }
 452
 453 static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event)
 454 {
 455         struct kvm_event_stats *kvm_stats = &event->total;
 456
 457         if (vcpu_id != -1)
 458                 kvm_stats = &event->vcpu[vcpu_id];
 459
 460         return rel_stddev_stats(stddev_stats(&kvm_stats->stats),
 461                                 avg_stats(&kvm_stats->stats));
 462 }
 463
 464 static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
 465                              u64 time_diff)
 466 {
 467         if (vcpu_id == -1) {
 468                 kvm_update_event_stats(&event->total, time_diff);
 469                 return true;
 470         }
 471
 472         if (!kvm_event_expand(event, vcpu_id))
 473                 return false;
 474
 475         kvm_update_event_stats(&event->vcpu[vcpu_id], time_diff);
 476         return true;
 477 }
 478
 479 static bool handle_end_event(struct perf_kvm_stat *kvm,
 480                              struct vcpu_event_record *vcpu_record,
 481                              struct event_key *key,
 482                              struct perf_sample *sample)
 483 {
 484         struct kvm_event *event;
 485         u64 time_begin, time_diff;
 486         int vcpu;
 487
 488         if (kvm->trace_vcpu == -1)
 489                 vcpu = -1;
 490         else
 491                 vcpu = vcpu_record->vcpu_id;
 492
 493         event = vcpu_record->last_event;
 494         time_begin = vcpu_record->start_time;
 495
 496         /* The begin event is not caught. */
 497         if (!time_begin)
 498                 return true;
 499
 500         /*
 501          * In some case, the 'begin event' only records the start timestamp,
 502          * the actual event is recognized in the 'end event' (e.g. mmio-event).
 503          */
 504
 505         /* Both begin and end events did not get the key. */
 506         if (!event && key->key == INVALID_KEY)
 507                 return true;
 508
 509         if (!event)
 510                 event = find_create_kvm_event(kvm, key);
 511
 512         if (!event)
 513                 return false;
 514
 515         vcpu_record->last_event = NULL;
 516         vcpu_record->start_time = 0;
 517
 518         /* seems to happen once in a while during live mode */
 519         if (sample->time < time_begin) {
 520                 pr_debug("End time before begin time; skipping event.\n");
 521                 return true;
 522         }
 523
 524         time_diff = sample->time - time_begin;
 525
 526         if (kvm->duration && time_diff > kvm->duration) {
 527                 char decode[32];
 528
 529                 kvm->events_ops->decode_key(kvm, &event->key, decode);
 530                 if (strcmp(decode, "HLT")) {
 531                         pr_info("%" PRIu64 " VM %d, vcpu %d: %s event took %" PRIu64 "usec\n",
 532                                  sample->time, sample->pid, vcpu_record->vcpu_id,
 533                                  decode, time_diff/1000);
 534                 }
 535         }
 536
 537         return update_kvm_event(event, vcpu, time_diff);
 538 }
 539
 540 static
 541 struct vcpu_event_record *per_vcpu_record(struct thread *thread,
 542                                           struct perf_evsel *evsel,
 543                                           struct perf_sample *sample)
 544 {
 545         /* Only kvm_entry records vcpu id. */
 546         if (!thread->priv && kvm_entry_event(evsel)) {
 547                 struct vcpu_event_record *vcpu_record;
 548
 549                 vcpu_record = zalloc(sizeof(*vcpu_record));
 550                 if (!vcpu_record) {
 551                         pr_err("%s: Not enough memory\n", __func__);
 552                         return NULL;
 553                 }
 554
 555                 vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id");
 556                 thread->priv = vcpu_record;
 557         }
 558
 559         return thread->priv;
 560 }
 561
 562 static bool handle_kvm_event(struct perf_kvm_stat *kvm,
 563                              struct thread *thread,
 564                              struct perf_evsel *evsel,
 565                              struct perf_sample *sample)
 566 {
 567         struct vcpu_event_record *vcpu_record;
 568         struct event_key key = {.key = INVALID_KEY};
 569
 570         vcpu_record = per_vcpu_record(thread, evsel, sample);
 571         if (!vcpu_record)
 572                 return true;
 573
 574         /* only process events for vcpus user cares about */
 575         if ((kvm->trace_vcpu != -1) &&
 576             (kvm->trace_vcpu != vcpu_record->vcpu_id))
 577                 return true;
 578
 579         if (kvm->events_ops->is_begin_event(evsel, sample, &key))
 580                 return handle_begin_event(kvm, vcpu_record, &key, sample->time);
 581
 582         if (kvm->events_ops->is_end_event(evsel, sample, &key))
 583                 return handle_end_event(kvm, vcpu_record, &key, sample);
 584
 585         return true;
 586 }
 587
 588 #define GET_EVENT_KEY(func, field)                                      \
 589 static u64 get_event_ ##func(struct kvm_event *event, int vcpu)         \
 590 {                                                                       \
 591         if (vcpu == -1)                                                 \
 592                 return event->total.field;                              \
 593                                                                         \
 594         if (vcpu >= event->max_vcpu)                                    \
 595                 return 0;                                               \
 596                                                                         \
 597         return event->vcpu[vcpu].field;                                 \
 598 }
 599
 600 #define COMPARE_EVENT_KEY(func, field)                                  \
 601 GET_EVENT_KEY(func, field)                                              \
 602 static int compare_kvm_event_ ## func(struct kvm_event *one,            \
 603                                         struct kvm_event *two, int vcpu)\
 604 {                                                                       \
 605         return get_event_ ##func(one, vcpu) >                           \
 606                                 get_event_ ##func(two, vcpu);           \
 607 }
 608
 609 GET_EVENT_KEY(time, time);
 610 COMPARE_EVENT_KEY(count, stats.n);
 611 COMPARE_EVENT_KEY(mean, stats.mean);
 612 GET_EVENT_KEY(max, stats.max);
 613 GET_EVENT_KEY(min, stats.min);
 614
 615 #define DEF_SORT_NAME_KEY(name, compare_key)                            \
 616         { #name, compare_kvm_event_ ## compare_key }
 617
 618 static struct kvm_event_key keys[] = {
 619         DEF_SORT_NAME_KEY(sample, count),
 620         DEF_SORT_NAME_KEY(time, mean),
 621         { NULL, NULL }
 622 };
 623
 624 static bool select_key(struct perf_kvm_stat *kvm)
 625 {
 626         int i;
 627
 628         for (i = 0; keys[i].name; i++) {
 629                 if (!strcmp(keys[i].name, kvm->sort_key)) {
 630                         kvm->compare = keys[i].key;
 631                         return true;
 632                 }
 633         }
 634
 635         pr_err("Unknown compare key:%s\n", kvm->sort_key);
 636         return false;
 637 }
 638
 639 static void insert_to_result(struct rb_root *result, struct kvm_event *event,
 640                              key_cmp_fun bigger, int vcpu)
 641 {
 642         struct rb_node **rb = &result->rb_node;
 643         struct rb_node *parent = NULL;
 644         struct kvm_event *p;
 645
 646         while (*rb) {
 647                 p = container_of(*rb, struct kvm_event, rb);
 648                 parent = *rb;
 649
 650                 if (bigger(event, p, vcpu))
 651                         rb = &(*rb)->rb_left;
 652                 else
 653                         rb = &(*rb)->rb_right;
 654         }
 655
 656         rb_link_node(&event->rb, parent, rb);
 657         rb_insert_color(&event->rb, result);
 658 }
 659
 660 static void
 661 update_total_count(struct perf_kvm_stat *kvm, struct kvm_event *event)
 662 {
 663         int vcpu = kvm->trace_vcpu;
 664
 665         kvm->total_count += get_event_count(event, vcpu);
 666         kvm->total_time += get_event_time(event, vcpu);
 667 }
 668
 669 static bool event_is_valid(struct kvm_event *event, int vcpu)
 670 {
 671         return !!get_event_count(event, vcpu);
 672 }
 673
 674 static void sort_result(struct perf_kvm_stat *kvm)
 675 {
 676         unsigned int i;
 677         int vcpu = kvm->trace_vcpu;
 678         struct kvm_event *event;
 679
 680         for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
 681                 list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry) {
 682                         if (event_is_valid(event, vcpu)) {
 683                                 update_total_count(kvm, event);
 684                                 insert_to_result(&kvm->result, event,
 685                                                  kvm->compare, vcpu);
 686                         }
 687                 }
 688         }
 689 }
 690
 691 /* returns left most element of result, and erase it */
 692 static struct kvm_event *pop_from_result(struct rb_root *result)
 693 {
 694         struct rb_node *node = rb_first(result);
 695
 696         if (!node)
 697                 return NULL;
 698
 699         rb_erase(node, result);
 700         return container_of(node, struct kvm_event, rb);
 701 }
 702
 703 static void print_vcpu_info(struct perf_kvm_stat *kvm)
 704 {
 705         int vcpu = kvm->trace_vcpu;
 706
 707         pr_info("Analyze events for ");
 708
 709         if (kvm->live) {
 710                 if (kvm->opts.target.system_wide)
 711                         pr_info("all VMs, ");
 712                 else if (kvm->opts.target.pid)
 713                         pr_info("pid(s) %s, ", kvm->opts.target.pid);
 714                 else
 715                         pr_info("dazed and confused on what is monitored, ");
 716         }
 717
 718         if (vcpu == -1)
 719                 pr_info("all VCPUs:\n\n");
 720         else
 721                 pr_info("VCPU %d:\n\n", vcpu);
 722 }
 723
 724 static void show_timeofday(void)
 725 {
 726         char date[64];
 727         struct timeval tv;
 728         struct tm ltime;
 729
 730         gettimeofday(&tv, NULL);
 731         if (localtime_r(&tv.tv_sec, &ltime)) {
 732                 strftime(date, sizeof(date), "%H:%M:%S", &ltime);
 733                 pr_info("%s.%06ld", date, tv.tv_usec);
 734         } else
 735                 pr_info("00:00:00.000000");
 736
 737         return;
 738 }
 739
 740 static void print_result(struct perf_kvm_stat *kvm)
 741 {
 742         char decode[20];
 743         struct kvm_event *event;
 744         int vcpu = kvm->trace_vcpu;
 745
 746         if (kvm->live) {
 747                 puts(CONSOLE_CLEAR);
 748                 show_timeofday();
 749         }
 750
 751         pr_info("\n\n");
 752         print_vcpu_info(kvm);
 753         pr_info("%20s ", kvm->events_ops->name);
 754         pr_info("%10s ", "Samples");
 755         pr_info("%9s ", "Samples%");
 756
 757         pr_info("%9s ", "Time%");
 758         pr_info("%10s ", "Min Time");
 759         pr_info("%10s ", "Max Time");
 760         pr_info("%16s ", "Avg time");
 761         pr_info("\n\n");
 762
 763         while ((event = pop_from_result(&kvm->result))) {
 764                 u64 ecount, etime, max, min;
 765
 766                 ecount = get_event_count(event, vcpu);
 767                 etime = get_event_time(event, vcpu);
 768                 max = get_event_max(event, vcpu);
 769                 min = get_event_min(event, vcpu);
 770
 771                 kvm->events_ops->decode_key(kvm, &event->key, decode);
 772                 pr_info("%20s ", decode);
 773                 pr_info("%10llu ", (unsigned long long)ecount);
 774                 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100);
 775                 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100);
 776                 pr_info("%8" PRIu64 "us ", min / 1000);
 777                 pr_info("%8" PRIu64 "us ", max / 1000);
 778                 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
 779                         kvm_event_rel_stddev(vcpu, event));
 780                 pr_info("\n");
 781         }
 782
 783         pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n",
 784                 kvm->total_count, kvm->total_time / 1e3);
 785
 786         if (kvm->lost_events)
 787                 pr_info("\nLost events: %" PRIu64 "\n\n", kvm->lost_events);
 788 }
 789
 790 #ifdef HAVE_TIMERFD_SUPPORT
 791 static int process_lost_event(struct perf_tool *tool,
 792                               union perf_event *event __maybe_unused,
 793                               struct perf_sample *sample __maybe_unused,
 794                               struct machine *machine __maybe_unused)
 795 {
 796         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat, tool);
 797
 798         kvm->lost_events++;
 799         return 0;
 800 }
 801 #endif
 802
 803 static bool skip_sample(struct perf_kvm_stat *kvm,
 804                         struct perf_sample *sample)
 805 {
 806         if (kvm->pid_list && intlist__find(kvm->pid_list, sample->pid) == NULL)
 807                 return true;
 808
 809         return false;
 810 }
 811
 812 static int process_sample_event(struct perf_tool *tool,
 813                                 union perf_event *event,
 814                                 struct perf_sample *sample,
 815                                 struct perf_evsel *evsel,
 816                                 struct machine *machine)
 817 {
 818         struct thread *thread;
 819         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat,
 820                                                  tool);
 821
 822         if (skip_sample(kvm, sample))
 823                 return 0;
 824
 825         thread = machine__findnew_thread(machine, sample->pid, sample->tid);
 826         if (thread == NULL) {
 827                 pr_debug("problem processing %d event, skipping it.\n",
 828                         event->header.type);
 829                 return -1;
 830         }
 831
 832         if (!handle_kvm_event(kvm, thread, evsel, sample))
 833                 return -1;
 834
 835         return 0;
 836 }
 837
 838 static int cpu_isa_config(struct perf_kvm_stat *kvm)
 839 {
 840         char buf[64], *cpuid;
 841         int err, isa;
 842
 843         if (kvm->live) {
 844                 err = get_cpuid(buf, sizeof(buf));
 845                 if (err != 0) {
 846                         pr_err("Failed to look up CPU type (Intel or AMD)\n");
 847                         return err;
 848                 }
 849                 cpuid = buf;
 850         } else
 851                 cpuid = kvm->session->header.env.cpuid;
 852
 853         if (strstr(cpuid, "Intel"))
 854                 isa = 1;
 855         else if (strstr(cpuid, "AMD"))
 856                 isa = 0;
 857         else {
 858                 pr_err("CPU %s is not supported.\n", cpuid);
 859                 return -ENOTSUP;
 860         }
 861
 862         if (isa == 1) {
 863                 kvm->exit_reasons = vmx_exit_reasons;
 864                 kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
 865                 kvm->exit_reasons_isa = "VMX";
 866         }
 867
 868         return 0;
 869 }
 870
 871 static bool verify_vcpu(int vcpu)
 872 {
 873         if (vcpu != -1 && vcpu < 0) {
 874                 pr_err("Invalid vcpu:%d.\n", vcpu);
 875                 return false;
 876         }
 877
 878         return true;
 879 }
 880
 881 #ifdef HAVE_TIMERFD_SUPPORT
 882 /* keeping the max events to a modest level to keep
 883  * the processing of samples per mmap smooth.
 884  */
 885 #define PERF_KVM__MAX_EVENTS_PER_MMAP  25
 886
 887 static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
 888                                    u64 *mmap_time)
 889 {
 890         union perf_event *event;
 891         struct perf_sample sample;
 892         s64 n = 0;
 893         int err;
 894
 895         *mmap_time = ULLONG_MAX;
 896         while ((event = perf_evlist__mmap_read(kvm->evlist, idx)) != NULL) {
 897                 err = perf_evlist__parse_sample(kvm->evlist, event, &sample);
 898                 if (err) {
 899                         perf_evlist__mmap_consume(kvm->evlist, idx);
 900                         pr_err("Failed to parse sample\n");
 901                         return -1;
 902                 }
 903
 904                 err = perf_session_queue_event(kvm->session, event, &sample, 0);
 905                 /*
 906                  * FIXME: Here we can't consume the event, as perf_session_queue_event will
 907                  *        point to it, and it'll get possibly overwritten by the kernel.
 908                  */
 909                 perf_evlist__mmap_consume(kvm->evlist, idx);
 910
 911                 if (err) {
 912                         pr_err("Failed to enqueue sample: %d\n", err);
 913                         return -1;
 914                 }
 915
 916                 /* save time stamp of our first sample for this mmap */
 917                 if (n == 0)
 918                         *mmap_time = sample.time;
 919
 920                 /* limit events per mmap handled all at once */
 921                 n++;
 922                 if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
 923                         break;
 924         }
 925
 926         return n;
 927 }
 928
 929 static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
 930 {
 931         int i, err, throttled = 0;
 932         s64 n, ntotal = 0;
 933         u64 flush_time = ULLONG_MAX, mmap_time;
 934
 935         for (i = 0; i < kvm->evlist->nr_mmaps; i++) {
 936                 n = perf_kvm__mmap_read_idx(kvm, i, &mmap_time);
 937                 if (n < 0)
 938                         return -1;
 939
 940                 /* flush time is going to be the minimum of all the individual
 941                  * mmap times. Essentially, we flush all the samples queued up
 942                  * from the last pass under our minimal start time -- that leaves
 943                  * a very small race for samples to come in with a lower timestamp.
 944                  * The ioctl to return the perf_clock timestamp should close the
 945                  * race entirely.
 946                  */
 947                 if (mmap_time < flush_time)
 948                         flush_time = mmap_time;
 949
 950                 ntotal += n;
 951                 if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
 952                         throttled = 1;
 953         }
 954
 955         /* flush queue after each round in which we processed events */
 956         if (ntotal) {
 957                 kvm->session->ordered_samples.next_flush = flush_time;
 958                 err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
 959                 if (err) {
 960                         if (kvm->lost_events)
 961                                 pr_info("\nLost events: %" PRIu64 "\n\n",
 962                                         kvm->lost_events);
 963                         return err;
 964                 }
 965         }
 966
 967         return throttled;
 968 }
 969
 970 static volatile int done;
 971
 972 static void sig_handler(int sig __maybe_unused)
 973 {
 974         done = 1;
 975 }
 976
 977 static int perf_kvm__timerfd_create(struct perf_kvm_stat *kvm)
 978 {
 979         struct itimerspec new_value;
 980         int rc = -1;
 981
 982         kvm->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
 983         if (kvm->timerfd < 0) {
 984                 pr_err("timerfd_create failed\n");
 985                 goto out;
 986         }
 987
 988         new_value.it_value.tv_sec = kvm->display_time;
 989         new_value.it_value.tv_nsec = 0;
 990         new_value.it_interval.tv_sec = kvm->display_time;
 991         new_value.it_interval.tv_nsec = 0;
 992
 993         if (timerfd_settime(kvm->timerfd, 0, &new_value, NULL) != 0) {
 994                 pr_err("timerfd_settime failed: %d\n", errno);
 995                 close(kvm->timerfd);
 996                 goto out;
 997         }
 998
 999         rc = 0;
1000 out:
1001         return rc;
1002 }
1003
1004 static int perf_kvm__handle_timerfd(struct perf_kvm_stat *kvm)
1005 {
1006         uint64_t c;
1007         int rc;
1008
1009         rc = read(kvm->timerfd, &c, sizeof(uint64_t));
1010         if (rc < 0) {
1011                 if (errno == EAGAIN)
1012                         return 0;
1013
1014                 pr_err("Failed to read timer fd: %d\n", errno);
1015                 return -1;
1016         }
1017
1018         if (rc != sizeof(uint64_t)) {
1019                 pr_err("Error reading timer fd - invalid size returned\n");
1020                 return -1;
1021         }
1022
1023         if (c != 1)
1024                 pr_debug("Missed timer beats: %" PRIu64 "\n", c-1);
1025
1026         /* update display */
1027         sort_result(kvm);
1028         print_result(kvm);
1029
1030         /* reset counts */
1031         clear_events_cache_stats(kvm->kvm_events_cache);
1032         kvm->total_count = 0;
1033         kvm->total_time = 0;
1034         kvm->lost_events = 0;
1035
1036         return 0;
1037 }
1038
1039 static int fd_set_nonblock(int fd)
1040 {
1041         long arg = 0;
1042
1043         arg = fcntl(fd, F_GETFL);
1044         if (arg < 0) {
1045                 pr_err("Failed to get current flags for fd %d\n", fd);
1046                 return -1;
1047         }
1048
1049         if (fcntl(fd, F_SETFL, arg | O_NONBLOCK) < 0) {
1050                 pr_err("Failed to set non-block option on fd %d\n", fd);
1051                 return -1;
1052         }
1053
1054         return 0;
1055 }
1056
1057 static
1058 int perf_kvm__handle_stdin(struct termios *tc_now, struct termios *tc_save)
1059 {
1060         int c;
1061
1062         tcsetattr(0, TCSANOW, tc_now);
1063         c = getc(stdin);
1064         tcsetattr(0, TCSAFLUSH, tc_save);
1065
1066         if (c == 'q')
1067                 return 1;
1068
1069         return 0;
1070 }
1071
1072 static int kvm_events_live_report(struct perf_kvm_stat *kvm)
1073 {
1074         struct pollfd *pollfds = NULL;
1075         int nr_fds, nr_stdin, ret, err = -EINVAL;
1076         struct termios tc, save;
1077
1078         /* live flag must be set first */
1079         kvm->live = true;
1080
1081         ret = cpu_isa_config(kvm);
1082         if (ret < 0)
1083                 return ret;
1084
1085         if (!verify_vcpu(kvm->trace_vcpu) ||
1086             !select_key(kvm) ||
1087             !register_kvm_events_ops(kvm)) {
1088                 goto out;
1089         }
1090
1091         init_kvm_event_record(kvm);
1092
1093         tcgetattr(0, &save);
1094         tc = save;
1095         tc.c_lflag &= ~(ICANON | ECHO);
1096         tc.c_cc[VMIN] = 0;
1097         tc.c_cc[VTIME] = 0;
1098
1099         signal(SIGINT, sig_handler);
1100         signal(SIGTERM, sig_handler);
1101
1102         /* copy pollfds -- need to add timerfd and stdin */
1103         nr_fds = kvm->evlist->nr_fds;
1104         pollfds = zalloc(sizeof(struct pollfd) * (nr_fds + 2));
1105         if (!pollfds) {
1106                 err = -ENOMEM;
1107                 goto out;
1108         }
1109         memcpy(pollfds, kvm->evlist->pollfd,
1110                 sizeof(struct pollfd) * kvm->evlist->nr_fds);
1111
1112         /* add timer fd */
1113         if (perf_kvm__timerfd_create(kvm) < 0) {
1114                 err = -1;
1115                 goto out;
1116         }
1117
1118         pollfds[nr_fds].fd = kvm->timerfd;
1119         pollfds[nr_fds].events = POLLIN;
1120         nr_fds++;
1121
1122         pollfds[nr_fds].fd = fileno(stdin);
1123         pollfds[nr_fds].events = POLLIN;
1124         nr_stdin = nr_fds;
1125         nr_fds++;
1126         if (fd_set_nonblock(fileno(stdin)) != 0)
1127                 goto out;
1128
1129         /* everything is good - enable the events and process */
1130         perf_evlist__enable(kvm->evlist);
1131
1132         while (!done) {
1133                 int rc;
1134
1135                 rc = perf_kvm__mmap_read(kvm);
1136                 if (rc < 0)
1137                         break;
1138
1139                 err = perf_kvm__handle_timerfd(kvm);
1140                 if (err)
1141                         goto out;
1142
1143                 if (pollfds[nr_stdin].revents & POLLIN)
1144                         done = perf_kvm__handle_stdin(&tc, &save);
1145
1146                 if (!rc && !done)
1147                         err = poll(pollfds, nr_fds, 100);
1148         }
1149
1150         perf_evlist__disable(kvm->evlist);
1151
1152         if (err == 0) {
1153                 sort_result(kvm);
1154                 print_result(kvm);
1155         }
1156
1157 out:
1158         if (kvm->timerfd >= 0)
1159                 close(kvm->timerfd);
1160
1161         free(pollfds);
1162         return err;
1163 }
1164
1165 static int kvm_live_open_events(struct perf_kvm_stat *kvm)
1166 {
1167         int err, rc = -1;
1168         struct perf_evsel *pos;
1169         struct perf_evlist *evlist = kvm->evlist;
1170
1171         perf_evlist__config(evlist, &kvm->opts);
1172
1173         /*
1174          * Note: exclude_{guest,host} do not apply here.
1175          *       This command processes KVM tracepoints from host only
1176          */
1177         evlist__for_each(evlist, pos) {
1178                 struct perf_event_attr *attr = &pos->attr;
1179
1180                 /* make sure these *are* set */
1181                 perf_evsel__set_sample_bit(pos, TID);
1182                 perf_evsel__set_sample_bit(pos, TIME);
1183                 perf_evsel__set_sample_bit(pos, CPU);
1184                 perf_evsel__set_sample_bit(pos, RAW);
1185                 /* make sure these are *not*; want as small a sample as possible */
1186                 perf_evsel__reset_sample_bit(pos, PERIOD);
1187                 perf_evsel__reset_sample_bit(pos, IP);
1188                 perf_evsel__reset_sample_bit(pos, CALLCHAIN);
1189                 perf_evsel__reset_sample_bit(pos, ADDR);
1190                 perf_evsel__reset_sample_bit(pos, READ);
1191                 attr->mmap = 0;
1192                 attr->comm = 0;
1193                 attr->task = 0;
1194
1195                 attr->sample_period = 1;
1196
1197                 attr->watermark = 0;
1198                 attr->wakeup_events = 1000;
1199
1200                 /* will enable all once we are ready */
1201                 attr->disabled = 1;
1202         }
1203
1204         err = perf_evlist__open(evlist);
1205         if (err < 0) {
1206                 printf("Couldn't create the events: %s\n", strerror(errno));
1207                 goto out;
1208         }
1209
1210         if (perf_evlist__mmap(evlist, kvm->opts.mmap_pages, false) < 0) {
1211                 ui__error("Failed to mmap the events: %s\n", strerror(errno));
1212                 perf_evlist__close(evlist);
1213                 goto out;
1214         }
1215
1216         rc = 0;
1217
1218 out:
1219         return rc;
1220 }
1221 #endif
1222
1223 static int read_events(struct perf_kvm_stat *kvm)
1224 {
1225         int ret;
1226
1227         struct perf_tool eops = {
1228                 .sample                 = process_sample_event,
1229                 .comm                   = perf_event__process_comm,
1230                 .ordered_samples        = true,
1231         };
1232         struct perf_data_file file = {
1233                 .path = kvm->file_name,
1234                 .mode = PERF_DATA_MODE_READ,
1235         };
1236
1237         kvm->tool = eops;
1238         kvm->session = perf_session__new(&file, false, &kvm->tool);
1239         if (!kvm->session) {
1240                 pr_err("Initializing perf session failed\n");
1241                 return -EINVAL;
1242         }
1243
1244         if (!perf_session__has_traces(kvm->session, "kvm record"))
1245                 return -EINVAL;
1246
1247         /*
1248          * Do not use 'isa' recorded in kvm_exit tracepoint since it is not
1249          * traced in the old kernel.
1250          */
1251         ret = cpu_isa_config(kvm);
1252         if (ret < 0)
1253                 return ret;
1254
1255         return perf_session__process_events(kvm->session, &kvm->tool);
1256 }
1257
1258 static int parse_target_str(struct perf_kvm_stat *kvm)
1259 {
1260         if (kvm->pid_str) {
1261                 kvm->pid_list = intlist__new(kvm->pid_str);
1262                 if (kvm->pid_list == NULL) {
1263                         pr_err("Error parsing process id string\n");
1264                         return -EINVAL;
1265                 }
1266         }
1267
1268         return 0;
1269 }
1270
1271 static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm)
1272 {
1273         int ret = -EINVAL;
1274         int vcpu = kvm->trace_vcpu;
1275
1276         if (parse_target_str(kvm) != 0)
1277                 goto exit;
1278
1279         if (!verify_vcpu(vcpu))
1280                 goto exit;
1281
1282         if (!select_key(kvm))
1283                 goto exit;
1284
1285         if (!register_kvm_events_ops(kvm))
1286                 goto exit;
1287
1288         init_kvm_event_record(kvm);
1289         setup_pager();
1290
1291         ret = read_events(kvm);
1292         if (ret)
1293                 goto exit;
1294
1295         sort_result(kvm);
1296         print_result(kvm);
1297
1298 exit:
1299         return ret;
1300 }
1301
1302 static const char * const kvm_events_tp[] = {
1303         "kvm:kvm_entry",
1304         "kvm:kvm_exit",
1305         "kvm:kvm_mmio",
1306         "kvm:kvm_pio",
1307 };
1308
1309 #define STRDUP_FAIL_EXIT(s)             \
1310         ({      char *_p;               \
1311         _p = strdup(s);         \
1312                 if (!_p)                \
1313                         return -ENOMEM; \
1314                 _p;                     \
1315         })
1316
1317 static int
1318 kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
1319 {
1320         unsigned int rec_argc, i, j;
1321         const char **rec_argv;
1322         const char * const record_args[] = {
1323                 "record",
1324                 "-R",
1325                 "-m", "1024",
1326                 "-c", "1",
1327         };
1328
1329         rec_argc = ARRAY_SIZE(record_args) + argc + 2 +
1330                    2 * ARRAY_SIZE(kvm_events_tp);
1331         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1332
1333         if (rec_argv == NULL)
1334                 return -ENOMEM;
1335
1336         for (i = 0; i < ARRAY_SIZE(record_args); i++)
1337                 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]);
1338
1339         for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
1340                 rec_argv[i++] = "-e";
1341                 rec_argv[i++] = STRDUP_FAIL_EXIT(kvm_events_tp[j]);
1342         }
1343
1344         rec_argv[i++] = STRDUP_FAIL_EXIT("-o");
1345         rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name);
1346
1347         for (j = 1; j < (unsigned int)argc; j++, i++)
1348                 rec_argv[i] = argv[j];
1349
1350         return cmd_record(i, rec_argv, NULL);
1351 }
1352
1353 static int
1354 kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
1355 {
1356         const struct option kvm_events_report_options[] = {
1357                 OPT_STRING(0, "event", &kvm->report_event, "report event",
1358                             "event for reporting: vmexit, mmio, ioport"),
1359                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
1360                             "vcpu id to report"),
1361                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
1362                             "key for sorting: sample(sort by samples number)"
1363                             " time (sort by avg time)"),
1364                 OPT_STRING('p', "pid", &kvm->pid_str, "pid",
1365                            "analyze events only for given process id(s)"),
1366                 OPT_END()
1367         };
1368
1369         const char * const kvm_events_report_usage[] = {
1370                 "perf kvm stat report [<options>]",
1371                 NULL
1372         };
1373
1374         symbol__init();
1375
1376         if (argc) {
1377                 argc = parse_options(argc, argv,
1378                                      kvm_events_report_options,
1379                                      kvm_events_report_usage, 0);
1380                 if (argc)
1381                         usage_with_options(kvm_events_report_usage,
1382                                            kvm_events_report_options);
1383         }
1384
1385         return kvm_events_report_vcpu(kvm);
1386 }
1387
1388 #ifdef HAVE_TIMERFD_SUPPORT
1389 static struct perf_evlist *kvm_live_event_list(void)
1390 {
1391         struct perf_evlist *evlist;
1392         char *tp, *name, *sys;
1393         unsigned int j;
1394         int err = -1;
1395
1396         evlist = perf_evlist__new();
1397         if (evlist == NULL)
1398                 return NULL;
1399
1400         for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
1401
1402                 tp = strdup(kvm_events_tp[j]);
1403                 if (tp == NULL)
1404                         goto out;
1405
1406                 /* split tracepoint into subsystem and name */
1407                 sys = tp;
1408                 name = strchr(tp, ':');
1409                 if (name == NULL) {
1410                         pr_err("Error parsing %s tracepoint: subsystem delimiter not found\n",
1411                                 kvm_events_tp[j]);
1412                         free(tp);
1413                         goto out;
1414                 }
1415                 *name = '\0';
1416                 name++;
1417
1418                 if (perf_evlist__add_newtp(evlist, sys, name, NULL)) {
1419                         pr_err("Failed to add %s tracepoint to the list\n", kvm_events_tp[j]);
1420                         free(tp);
1421                         goto out;
1422                 }
1423
1424                 free(tp);
1425         }
1426
1427         err = 0;
1428
1429 out:
1430         if (err) {
1431                 perf_evlist__delete(evlist);
1432                 evlist = NULL;
1433         }
1434
1435         return evlist;
1436 }
1437
1438 static int kvm_events_live(struct perf_kvm_stat *kvm,
1439                            int argc, const char **argv)
1440 {
1441         char errbuf[BUFSIZ];
1442         int err;
1443
1444         const struct option live_options[] = {
1445                 OPT_STRING('p', "pid", &kvm->opts.target.pid, "pid",
1446                         "record events on existing process id"),
1447                 OPT_CALLBACK('m', "mmap-pages", &kvm->opts.mmap_pages, "pages",
1448                         "number of mmap data pages",
1449                         perf_evlist__parse_mmap_pages),
1450                 OPT_INCR('v', "verbose", &verbose,
1451                         "be more verbose (show counter open errors, etc)"),
1452                 OPT_BOOLEAN('a', "all-cpus", &kvm->opts.target.system_wide,
1453                         "system-wide collection from all CPUs"),
1454                 OPT_UINTEGER('d', "display", &kvm->display_time,
1455                         "time in seconds between display updates"),
1456                 OPT_STRING(0, "event", &kvm->report_event, "report event",
1457                         "event for reporting: vmexit, mmio, ioport"),
1458                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
1459                         "vcpu id to report"),
1460                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
1461                         "key for sorting: sample(sort by samples number)"
1462                         " time (sort by avg time)"),
1463                 OPT_U64(0, "duration", &kvm->duration,
1464                     "show events other than HALT that take longer than duration usecs"),
1465                 OPT_END()
1466         };
1467         const char * const live_usage[] = {
1468                 "perf kvm stat live [<options>]",
1469                 NULL
1470         };
1471         struct perf_data_file file = {
1472                 .mode = PERF_DATA_MODE_WRITE,
1473         };
1474
1475
1476         /* event handling */
1477         kvm->tool.sample = process_sample_event;
1478         kvm->tool.comm   = perf_event__process_comm;
1479         kvm->tool.exit   = perf_event__process_exit;
1480         kvm->tool.fork   = perf_event__process_fork;
1481         kvm->tool.lost   = process_lost_event;
1482         kvm->tool.ordered_samples = true;
1483         perf_tool__fill_defaults(&kvm->tool);
1484
1485         /* set defaults */
1486         kvm->display_time = 1;
1487         kvm->opts.user_interval = 1;
1488         kvm->opts.mmap_pages = 512;
1489         kvm->opts.target.uses_mmap = false;
1490         kvm->opts.target.uid_str = NULL;
1491         kvm->opts.target.uid = UINT_MAX;
1492
1493         symbol__init();
1494         disable_buildid_cache();
1495
1496         use_browser = 0;
1497         setup_browser(false);
1498
1499         if (argc) {
1500                 argc = parse_options(argc, argv, live_options,
1501                                      live_usage, 0);
1502                 if (argc)
1503                         usage_with_options(live_usage, live_options);
1504         }
1505
1506         kvm->duration *= NSEC_PER_USEC;   /* convert usec to nsec */
1507
1508         /*
1509          * target related setups
1510          */
1511         err = target__validate(&kvm->opts.target);
1512         if (err) {
1513                 target__strerror(&kvm->opts.target, err, errbuf, BUFSIZ);
1514                 ui__warning("%s", errbuf);
1515         }
1516
1517         if (target__none(&kvm->opts.target))
1518                 kvm->opts.target.system_wide = true;
1519
1520
1521         /*
1522          * generate the event list
1523          */
1524         kvm->evlist = kvm_live_event_list();
1525         if (kvm->evlist == NULL) {
1526                 err = -1;
1527                 goto out;
1528         }
1529
1530         symbol_conf.nr_events = kvm->evlist->nr_entries;
1531
1532         if (perf_evlist__create_maps(kvm->evlist, &kvm->opts.target) < 0)
1533                 usage_with_options(live_usage, live_options);
1534
1535         /*
1536          * perf session
1537          */
1538         kvm->session = perf_session__new(&file, false, &kvm->tool);
1539         if (kvm->session == NULL) {
1540                 err = -ENOMEM;
1541                 goto out;
1542         }
1543         kvm->session->evlist = kvm->evlist;
1544         perf_session__set_id_hdr_size(kvm->session);
1545         machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target,
1546                                     kvm->evlist->threads, false);
1547         err = kvm_live_open_events(kvm);
1548         if (err)
1549                 goto out;
1550
1551         err = kvm_events_live_report(kvm);
1552
1553 out:
1554         exit_browser(0);
1555
1556         if (kvm->session)
1557                 perf_session__delete(kvm->session);
1558         kvm->session = NULL;
1559         if (kvm->evlist)
1560                 perf_evlist__delete(kvm->evlist);
1561
1562         return err;
1563 }
1564 #endif
1565
1566 static void print_kvm_stat_usage(void)
1567 {
1568         printf("Usage: perf kvm stat <command>\n\n");
1569
1570         printf("# Available commands:\n");
1571         printf("\trecord: record kvm events\n");
1572         printf("\treport: report statistical data of kvm events\n");
1573         printf("\tlive:   live reporting of statistical data of kvm events\n");
1574
1575         printf("\nOtherwise, it is the alias of 'perf stat':\n");
1576 }
1577
1578 static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
1579 {
1580         struct perf_kvm_stat kvm = {
1581                 .file_name = file_name,
1582
1583                 .trace_vcpu     = -1,
1584                 .report_event   = "vmexit",
1585                 .sort_key       = "sample",
1586
1587                 .exit_reasons = svm_exit_reasons,
1588                 .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons),
1589                 .exit_reasons_isa = "SVM",
1590         };
1591
1592         if (argc == 1) {
1593                 print_kvm_stat_usage();
1594                 goto perf_stat;
1595         }
1596
1597         if (!strncmp(argv[1], "rec", 3))
1598                 return kvm_events_record(&kvm, argc - 1, argv + 1);
1599
1600         if (!strncmp(argv[1], "rep", 3))
1601                 return kvm_events_report(&kvm, argc - 1 , argv + 1);
1602
1603 #ifdef HAVE_TIMERFD_SUPPORT
1604         if (!strncmp(argv[1], "live", 4))
1605                 return kvm_events_live(&kvm, argc - 1 , argv + 1);
1606 #endif
1607
1608 perf_stat:
1609         return cmd_stat(argc, argv, NULL);
1610 }
1611 #endif
1612
1613 static int __cmd_record(const char *file_name, int argc, const char **argv)
1614 {
1615         int rec_argc, i = 0, j;
1616         const char **rec_argv;
1617
1618         rec_argc = argc + 2;
1619         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1620         rec_argv[i++] = strdup("record");
1621         rec_argv[i++] = strdup("-o");
1622         rec_argv[i++] = strdup(file_name);
1623         for (j = 1; j < argc; j++, i++)
1624                 rec_argv[i] = argv[j];
1625
1626         BUG_ON(i != rec_argc);
1627
1628         return cmd_record(i, rec_argv, NULL);
1629 }
1630
1631 static int __cmd_report(const char *file_name, int argc, const char **argv)
1632 {
1633         int rec_argc, i = 0, j;
1634         const char **rec_argv;
1635
1636         rec_argc = argc + 2;
1637         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1638         rec_argv[i++] = strdup("report");
1639         rec_argv[i++] = strdup("-i");
1640         rec_argv[i++] = strdup(file_name);
1641         for (j = 1; j < argc; j++, i++)
1642                 rec_argv[i] = argv[j];
1643
1644         BUG_ON(i != rec_argc);
1645
1646         return cmd_report(i, rec_argv, NULL);
1647 }
1648
1649 static int
1650 __cmd_buildid_list(const char *file_name, int argc, const char **argv)
1651 {
1652         int rec_argc, i = 0, j;
1653         const char **rec_argv;
1654
1655         rec_argc = argc + 2;
1656         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1657         rec_argv[i++] = strdup("buildid-list");
1658         rec_argv[i++] = strdup("-i");
1659         rec_argv[i++] = strdup(file_name);
1660         for (j = 1; j < argc; j++, i++)
1661                 rec_argv[i] = argv[j];
1662
1663         BUG_ON(i != rec_argc);
1664
1665         return cmd_buildid_list(i, rec_argv, NULL);
1666 }
1667
1668 int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
1669 {
1670         const char *file_name = NULL;
1671         const struct option kvm_options[] = {
1672                 OPT_STRING('i', "input", &file_name, "file",
1673                            "Input file name"),
1674                 OPT_STRING('o', "output", &file_name, "file",
1675                            "Output file name"),
1676                 OPT_BOOLEAN(0, "guest", &perf_guest,
1677                             "Collect guest os data"),
1678                 OPT_BOOLEAN(0, "host", &perf_host,
1679                             "Collect host os data"),
1680                 OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
1681                            "guest mount directory under which every guest os"
1682                            " instance has a subdir"),
1683                 OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
1684                            "file", "file saving guest os vmlinux"),
1685                 OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
1686                            "file", "file saving guest os /proc/kallsyms"),
1687                 OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
1688                            "file", "file saving guest os /proc/modules"),
1689                 OPT_INCR('v', "verbose", &verbose,
1690                             "be more verbose (show counter open errors, etc)"),
1691                 OPT_END()
1692         };
1693
1694         const char *const kvm_subcommands[] = { "top", "record", "report", "diff",
1695                                                 "buildid-list", "stat", NULL };
1696         const char *kvm_usage[] = { NULL, NULL };
1697
1698         perf_host  = 0;
1699         perf_guest = 1;
1700
1701         argc = parse_options_subcommand(argc, argv, kvm_options, kvm_subcommands, kvm_usage,
1702                                         PARSE_OPT_STOP_AT_NON_OPTION);
1703         if (!argc)
1704                 usage_with_options(kvm_usage, kvm_options);
1705
1706         if (!perf_host)
1707                 perf_guest = 1;
1708
1709         if (!file_name) {
1710                 file_name = get_filename_for_perf_kvm();
1711
1712                 if (!file_name) {
1713                         pr_err("Failed to allocate memory for filename\n");
1714                         return -ENOMEM;
1715                 }
1716         }
1717
1718         if (!strncmp(argv[0], "rec", 3))
1719                 return __cmd_record(file_name, argc, argv);
1720         else if (!strncmp(argv[0], "rep", 3))
1721                 return __cmd_report(file_name, argc, argv);
1722         else if (!strncmp(argv[0], "diff", 4))
1723                 return cmd_diff(argc, argv, NULL);
1724         else if (!strncmp(argv[0], "top", 3))
1725                 return cmd_top(argc, argv, NULL);
1726         else if (!strncmp(argv[0], "buildid-list", 12))
1727                 return __cmd_buildid_list(file_name, argc, argv);
1728 #if defined(__i386__) || defined(__x86_64__)
1729         else if (!strncmp(argv[0], "stat", 4))
1730                 return kvm_cmd_stat(file_name, argc, argv);
1731 #endif
1732         else
1733                 usage_with_options(kvm_usage, kvm_options);
1734
1735         return 0;
1736 }