kvm-stat.c

  1// SPDX-License-Identifier: GPL-2.0
  2#include <errno.h>
  3#include <string.h>
  4#include "../../../util/kvm-stat.h"
  5#include "../../../util/evsel.h"
  6#include "../../../util/env.h"
  7#include <asm/svm.h>
  8#include <asm/vmx.h>
  9#include <asm/kvm.h>
 10#include <subcmd/parse-options.h>
 11
 12define_exit_reasons_table(vmx_exit_reasons, VMX_EXIT_REASONS);
 13define_exit_reasons_table(svm_exit_reasons, SVM_EXIT_REASONS);
 14
 15static struct kvm_events_ops exit_events = {
 16	.is_begin_event = exit_event_begin,
 17	.is_end_event = exit_event_end,
 18	.decode_key = exit_event_decode_key,
 19	.name = "VM-EXIT"
 20};
 21
 22const char *vcpu_id_str = "vcpu_id";
 23const char *kvm_exit_reason = "exit_reason";
 24const char *kvm_entry_trace = "kvm:kvm_entry";
 25const char *kvm_exit_trace = "kvm:kvm_exit";
 26
 27/*
 28 * For the mmio events, we treat:
 29 * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
 30 * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
 31 */
 32static void mmio_event_get_key(struct evsel *evsel, struct perf_sample *sample,
 33			       struct event_key *key)
 34{
 35	key->key  = evsel__intval(evsel, sample, "gpa");
 36	key->info = evsel__intval(evsel, sample, "type");
 37}
 38
 39#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
 40#define KVM_TRACE_MMIO_READ 1
 41#define KVM_TRACE_MMIO_WRITE 2
 42
 43static bool mmio_event_begin(struct evsel *evsel,
 44			     struct perf_sample *sample, struct event_key *key)
 45{
 46	/* MMIO read begin event in kernel. */
 47	if (kvm_exit_event(evsel))
 48		return true;
 49
 50	/* MMIO write begin event in kernel. */
 51	if (evsel__name_is(evsel, "kvm:kvm_mmio") &&
 52	    evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
 53		mmio_event_get_key(evsel, sample, key);
 54		return true;
 55	}
 56
 57	return false;
 58}
 59
 60static bool mmio_event_end(struct evsel *evsel, struct perf_sample *sample,
 61			   struct event_key *key)
 62{
 63	/* MMIO write end event in kernel. */
 64	if (kvm_entry_event(evsel))
 65		return true;
 66
 67	/* MMIO read end event in kernel.*/
 68	if (evsel__name_is(evsel, "kvm:kvm_mmio") &&
 69	    evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
 70		mmio_event_get_key(evsel, sample, key);
 71		return true;
 72	}
 73
 74	return false;
 75}
 76
 77static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
 78				  struct event_key *key,
 79				  char *decode)
 80{
 81	scnprintf(decode, KVM_EVENT_NAME_LEN, "%#lx:%s",
 82		  (unsigned long)key->key,
 83		  key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
 84}
 85
 86static struct kvm_events_ops mmio_events = {
 87	.is_begin_event = mmio_event_begin,
 88	.is_end_event = mmio_event_end,
 89	.decode_key = mmio_event_decode_key,
 90	.name = "MMIO Access"
 91};
 92
 93 /* The time of emulation pio access is from kvm_pio to kvm_entry. */
 94static void ioport_event_get_key(struct evsel *evsel,
 95				 struct perf_sample *sample,
 96				 struct event_key *key)
 97{
 98	key->key  = evsel__intval(evsel, sample, "port");
 99	key->info = evsel__intval(evsel, sample, "rw");
100}
101
102static bool ioport_event_begin(struct evsel *evsel,
103			       struct perf_sample *sample,
104			       struct event_key *key)
105{
106	if (evsel__name_is(evsel, "kvm:kvm_pio")) {
107		ioport_event_get_key(evsel, sample, key);
108		return true;
109	}
110
111	return false;
112}
113
114static bool ioport_event_end(struct evsel *evsel,
115			     struct perf_sample *sample __maybe_unused,
116			     struct event_key *key __maybe_unused)
117{
118	return kvm_entry_event(evsel);
119}
120
121static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
122				    struct event_key *key,
123				    char *decode)
124{
125	scnprintf(decode, KVM_EVENT_NAME_LEN, "%#llx:%s",
126		  (unsigned long long)key->key,
127		  key->info ? "POUT" : "PIN");
128}
129
130static struct kvm_events_ops ioport_events = {
131	.is_begin_event = ioport_event_begin,
132	.is_end_event = ioport_event_end,
133	.decode_key = ioport_event_decode_key,
134	.name = "IO Port Access"
135};
136
137 /* The time of emulation msr is from kvm_msr to kvm_entry. */
138static void msr_event_get_key(struct evsel *evsel,
139				 struct perf_sample *sample,
140				 struct event_key *key)
141{
142	key->key  = evsel__intval(evsel, sample, "ecx");
143	key->info = evsel__intval(evsel, sample, "write");
144}
145
146static bool msr_event_begin(struct evsel *evsel,
147			       struct perf_sample *sample,
148			       struct event_key *key)
149{
150	if (evsel__name_is(evsel, "kvm:kvm_msr")) {
151		msr_event_get_key(evsel, sample, key);
152		return true;
153	}
154
155	return false;
156}
157
158static bool msr_event_end(struct evsel *evsel,
159			     struct perf_sample *sample __maybe_unused,
160			     struct event_key *key __maybe_unused)
161{
162	return kvm_entry_event(evsel);
163}
164
165static void msr_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
166				    struct event_key *key,
167				    char *decode)
168{
169	scnprintf(decode, KVM_EVENT_NAME_LEN, "%#llx:%s",
170		  (unsigned long long)key->key,
171		  key->info ? "W" : "R");
172}
173
174static struct kvm_events_ops msr_events = {
175	.is_begin_event = msr_event_begin,
176	.is_end_event = msr_event_end,
177	.decode_key = msr_event_decode_key,
178	.name = "MSR Access"
179};
180
181const char *kvm_events_tp[] = {
182	"kvm:kvm_entry",
183	"kvm:kvm_exit",
184	"kvm:kvm_mmio",
185	"kvm:kvm_pio",
186	"kvm:kvm_msr",
187	NULL,
188};
189
190struct kvm_reg_events_ops kvm_reg_events_ops[] = {
191	{ .name = "vmexit", .ops = &exit_events },
192	{ .name = "mmio", .ops = &mmio_events },
193	{ .name = "ioport", .ops = &ioport_events },
194	{ .name = "msr", .ops = &msr_events },
195	{ NULL, NULL },
196};
197
198const char * const kvm_skip_events[] = {
199	"HLT",
200	NULL,
201};
202
203int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid)
204{
205	if (strstr(cpuid, "Intel")) {
206		kvm->exit_reasons = vmx_exit_reasons;
207		kvm->exit_reasons_isa = "VMX";
208	} else if (strstr(cpuid, "AMD") || strstr(cpuid, "Hygon")) {
209		kvm->exit_reasons = svm_exit_reasons;
210		kvm->exit_reasons_isa = "SVM";
211	} else
212		return -ENOTSUP;
213
214	return 0;
215}
216
217/*
218 * After KVM supports PEBS for guest on Intel platforms
219 * (https://lore.kernel.org/all/20220411101946.20262-1-likexu@tencent.com/),
220 * host loses the capability to sample guest with PEBS since all PEBS related
221 * MSRs are switched to guest value after vm-entry, like IA32_DS_AREA MSR is
222 * switched to guest GVA at vm-entry. This would lead to "perf kvm record"
223 * fails to sample guest on Intel platforms since "cycles:P" event is used to
224 * sample guest by default.
225 *
226 * So, to avoid this issue explicitly use "cycles" instead of "cycles:P" event
227 * by default to sample guest on Intel platforms.
228 */
229int kvm_add_default_arch_event(int *argc, const char **argv)
230{
231	const char **tmp;
232	bool event = false;
233	int ret = 0, i, j = *argc;
234
235	const struct option event_options[] = {
236		OPT_BOOLEAN('e', "event", &event, NULL),
237		OPT_BOOLEAN(0, "pfm-events", &event, NULL),
238		OPT_END()
239	};
240
241	if (!x86__is_intel_cpu())
242		return 0;
243
244	tmp = calloc(j + 1, sizeof(char *));
245	if (!tmp)
246		return -ENOMEM;
247
248	for (i = 0; i < j; i++)
249		tmp[i] = argv[i];
250
251	parse_options(j, tmp, event_options, NULL, PARSE_OPT_KEEP_UNKNOWN);
252	if (!event) {
253		argv[j++] = STRDUP_FAIL_EXIT("-e");
254		argv[j++] = STRDUP_FAIL_EXIT("cycles");
255		*argc += 2;
256	}
257
258	free(tmp);
259	return 0;
260
261EXIT:
262	free(tmp);
263	return ret;
264}