tools/perf/arch/x86/util/kvm-stat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <errno.h>
   3 #include "../../util/kvm-stat.h"
   4 #include <asm/svm.h>
   5 #include <asm/vmx.h>
   6 #include <asm/kvm.h>
   7
   8 define_exit_reasons_table(vmx_exit_reasons, VMX_EXIT_REASONS);
   9 define_exit_reasons_table(svm_exit_reasons, SVM_EXIT_REASONS);
  10
  11 static struct kvm_events_ops exit_events = {
  12         .is_begin_event = exit_event_begin,
  13         .is_end_event = exit_event_end,
  14         .decode_key = exit_event_decode_key,
  15         .name = "VM-EXIT"
  16 };
  17
  18 const char *vcpu_id_str = "vcpu_id";
  19 const int decode_str_len = 20;
  20 const char *kvm_exit_reason = "exit_reason";
  21 const char *kvm_entry_trace = "kvm:kvm_entry";
  22 const char *kvm_exit_trace = "kvm:kvm_exit";
  23
  24 /*
  25  * For the mmio events, we treat:
  26  * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
  27  * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
  28  */
  29 static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample,
  30                                struct event_key *key)
  31 {
  32         key->key  = perf_evsel__intval(evsel, sample, "gpa");
  33         key->info = perf_evsel__intval(evsel, sample, "type");
  34 }
  35
  36 #define KVM_TRACE_MMIO_READ_UNSATISFIED 0
  37 #define KVM_TRACE_MMIO_READ 1
  38 #define KVM_TRACE_MMIO_WRITE 2
  39
  40 static bool mmio_event_begin(struct perf_evsel *evsel,
  41                              struct perf_sample *sample, struct event_key *key)
  42 {
  43         /* MMIO read begin event in kernel. */
  44         if (kvm_exit_event(evsel))
  45                 return true;
  46
  47         /* MMIO write begin event in kernel. */
  48         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
  49             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
  50                 mmio_event_get_key(evsel, sample, key);
  51                 return true;
  52         }
  53
  54         return false;
  55 }
  56
  57 static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample,
  58                            struct event_key *key)
  59 {
  60         /* MMIO write end event in kernel. */
  61         if (kvm_entry_event(evsel))
  62                 return true;
  63
  64         /* MMIO read end event in kernel.*/
  65         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
  66             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
  67                 mmio_event_get_key(evsel, sample, key);
  68                 return true;
  69         }
  70
  71         return false;
  72 }
  73
  74 static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
  75                                   struct event_key *key,
  76                                   char *decode)
  77 {
  78         scnprintf(decode, decode_str_len, "%#lx:%s",
  79                   (unsigned long)key->key,
  80                   key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
  81 }
  82
  83 static struct kvm_events_ops mmio_events = {
  84         .is_begin_event = mmio_event_begin,
  85         .is_end_event = mmio_event_end,
  86         .decode_key = mmio_event_decode_key,
  87         .name = "MMIO Access"
  88 };
  89
  90  /* The time of emulation pio access is from kvm_pio to kvm_entry. */
  91 static void ioport_event_get_key(struct perf_evsel *evsel,
  92                                  struct perf_sample *sample,
  93                                  struct event_key *key)
  94 {
  95         key->key  = perf_evsel__intval(evsel, sample, "port");
  96         key->info = perf_evsel__intval(evsel, sample, "rw");
  97 }
  98
  99 static bool ioport_event_begin(struct perf_evsel *evsel,
 100                                struct perf_sample *sample,
 101                                struct event_key *key)
 102 {
 103         if (!strcmp(evsel->name, "kvm:kvm_pio")) {
 104                 ioport_event_get_key(evsel, sample, key);
 105                 return true;
 106         }
 107
 108         return false;
 109 }
 110
 111 static bool ioport_event_end(struct perf_evsel *evsel,
 112                              struct perf_sample *sample __maybe_unused,
 113                              struct event_key *key __maybe_unused)
 114 {
 115         return kvm_entry_event(evsel);
 116 }
 117
 118 static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
 119                                     struct event_key *key,
 120                                     char *decode)
 121 {
 122         scnprintf(decode, decode_str_len, "%#llx:%s",
 123                   (unsigned long long)key->key,
 124                   key->info ? "POUT" : "PIN");
 125 }
 126
 127 static struct kvm_events_ops ioport_events = {
 128         .is_begin_event = ioport_event_begin,
 129         .is_end_event = ioport_event_end,
 130         .decode_key = ioport_event_decode_key,
 131         .name = "IO Port Access"
 132 };
 133
 134 const char *kvm_events_tp[] = {
 135         "kvm:kvm_entry",
 136         "kvm:kvm_exit",
 137         "kvm:kvm_mmio",
 138         "kvm:kvm_pio",
 139         NULL,
 140 };
 141
 142 struct kvm_reg_events_ops kvm_reg_events_ops[] = {
 143         { .name = "vmexit", .ops = &exit_events },
 144         { .name = "mmio", .ops = &mmio_events },
 145         { .name = "ioport", .ops = &ioport_events },
 146         { NULL, NULL },
 147 };
 148
 149 const char * const kvm_skip_events[] = {
 150         "HLT",
 151         NULL,
 152 };
 153
 154 int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid)
 155 {
 156         if (strstr(cpuid, "Intel")) {
 157                 kvm->exit_reasons = vmx_exit_reasons;
 158                 kvm->exit_reasons_isa = "VMX";
 159         } else if (strstr(cpuid, "AMD")) {
 160                 kvm->exit_reasons = svm_exit_reasons;
 161                 kvm->exit_reasons_isa = "SVM";
 162         } else
 163                 return -ENOTSUP;
 164
 165         return 0;
 166 }