kvm-stat.c

  1// SPDX-License-Identifier: GPL-2.0
  2#include <errno.h>
  3#include "util/kvm-stat.h"
  4#include "util/parse-events.h"
  5#include "util/debug.h"
  6#include "util/evsel.h"
  7#include "util/evlist.h"
  8#include "util/pmus.h"
  9
 10#include "book3s_hv_exits.h"
 11#include "book3s_hcalls.h"
 12#include <subcmd/parse-options.h>
 13
 14#define NR_TPS 4
 15
 16const char *vcpu_id_str = "vcpu_id";
 17const char *kvm_entry_trace = "kvm_hv:kvm_guest_enter";
 18const char *kvm_exit_trace = "kvm_hv:kvm_guest_exit";
 19
 20define_exit_reasons_table(hv_exit_reasons, kvm_trace_symbol_exit);
 21define_exit_reasons_table(hcall_reasons, kvm_trace_symbol_hcall);
 22
 23/* Tracepoints specific to ppc_book3s_hv */
 24const char *ppc_book3s_hv_kvm_tp[] = {
 25	"kvm_hv:kvm_guest_enter",
 26	"kvm_hv:kvm_guest_exit",
 27	"kvm_hv:kvm_hcall_enter",
 28	"kvm_hv:kvm_hcall_exit",
 29	NULL,
 30};
 31
 32/* 1 extra placeholder for NULL */
 33const char *kvm_events_tp[NR_TPS + 1];
 34const char *kvm_exit_reason;
 35
 36static void hcall_event_get_key(struct evsel *evsel,
 37				struct perf_sample *sample,
 38				struct event_key *key)
 39{
 40	key->info = 0;
 41	key->key = evsel__intval(evsel, sample, "req");
 42}
 43
 44static const char *get_hcall_exit_reason(u64 exit_code)
 45{
 46	struct exit_reasons_table *tbl = hcall_reasons;
 47
 48	while (tbl->reason != NULL) {
 49		if (tbl->exit_code == exit_code)
 50			return tbl->reason;
 51		tbl++;
 52	}
 53
 54	pr_debug("Unknown hcall code: %lld\n",
 55	       (unsigned long long)exit_code);
 56	return "UNKNOWN";
 57}
 58
 59static bool hcall_event_end(struct evsel *evsel,
 60			    struct perf_sample *sample __maybe_unused,
 61			    struct event_key *key __maybe_unused)
 62{
 63	return (evsel__name_is(evsel, kvm_events_tp[3]));
 64}
 65
 66static bool hcall_event_begin(struct evsel *evsel,
 67			      struct perf_sample *sample, struct event_key *key)
 68{
 69	if (evsel__name_is(evsel, kvm_events_tp[2])) {
 70		hcall_event_get_key(evsel, sample, key);
 71		return true;
 72	}
 73
 74	return false;
 75}
 76static void hcall_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
 77				   struct event_key *key,
 78				   char *decode)
 79{
 80	const char *hcall_reason = get_hcall_exit_reason(key->key);
 81
 82	scnprintf(decode, KVM_EVENT_NAME_LEN, "%s", hcall_reason);
 83}
 84
 85static struct kvm_events_ops hcall_events = {
 86	.is_begin_event = hcall_event_begin,
 87	.is_end_event = hcall_event_end,
 88	.decode_key = hcall_event_decode_key,
 89	.name = "HCALL-EVENT",
 90};
 91
 92static struct kvm_events_ops exit_events = {
 93	.is_begin_event = exit_event_begin,
 94	.is_end_event = exit_event_end,
 95	.decode_key = exit_event_decode_key,
 96	.name = "VM-EXIT"
 97};
 98
 99struct kvm_reg_events_ops kvm_reg_events_ops[] = {
100	{ .name = "vmexit", .ops = &exit_events },
101	{ .name = "hcall", .ops = &hcall_events },
102	{ NULL, NULL },
103};
104
105const char * const kvm_skip_events[] = {
106	NULL,
107};
108
109
110static int is_tracepoint_available(const char *str, struct evlist *evlist)
111{
112	struct parse_events_error err;
113	int ret;
114
115	parse_events_error__init(&err);
116	ret = parse_events(evlist, str, &err);
117	if (ret)
118		parse_events_error__print(&err, "tracepoint");
119	parse_events_error__exit(&err);
120	return ret;
121}
122
123static int ppc__setup_book3s_hv(struct perf_kvm_stat *kvm,
124				struct evlist *evlist)
125{
126	const char **events_ptr;
127	int i, nr_tp = 0, err = -1;
128
129	/* Check for book3s_hv tracepoints */
130	for (events_ptr = ppc_book3s_hv_kvm_tp; *events_ptr; events_ptr++) {
131		err = is_tracepoint_available(*events_ptr, evlist);
132		if (err)
133			return -1;
134		nr_tp++;
135	}
136
137	for (i = 0; i < nr_tp; i++)
138		kvm_events_tp[i] = ppc_book3s_hv_kvm_tp[i];
139
140	kvm_events_tp[i] = NULL;
141	kvm_exit_reason = "trap";
142	kvm->exit_reasons = hv_exit_reasons;
143	kvm->exit_reasons_isa = "HV";
144
145	return 0;
146}
147
148/* Wrapper to setup kvm tracepoints */
149static int ppc__setup_kvm_tp(struct perf_kvm_stat *kvm)
150{
151	struct evlist *evlist = evlist__new();
152
153	if (evlist == NULL)
154		return -ENOMEM;
155
156	/* Right now, only supported on book3s_hv */
157	return ppc__setup_book3s_hv(kvm, evlist);
158}
159
160int setup_kvm_events_tp(struct perf_kvm_stat *kvm)
161{
162	return ppc__setup_kvm_tp(kvm);
163}
164
165int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid __maybe_unused)
166{
167	int ret;
168
169	ret = ppc__setup_kvm_tp(kvm);
170	if (ret) {
171		kvm->exit_reasons = NULL;
172		kvm->exit_reasons_isa = NULL;
173	}
174
175	return ret;
176}
177
178/*
179 * In case of powerpc architecture, pmu registers are programmable
180 * by guest kernel. So monitoring guest via host may not provide
181 * valid samples with default 'cycles' event. It is better to use
182 * 'trace_imc/trace_cycles' event for guest profiling, since it
183 * can track the guest instruction pointer in the trace-record.
184 *
185 * Function to parse the arguments and return appropriate values.
186 */
187int kvm_add_default_arch_event(int *argc, const char **argv)
188{
189	const char **tmp;
190	bool event = false;
191	int i, j = *argc;
192
193	const struct option event_options[] = {
194		OPT_BOOLEAN('e', "event", &event, NULL),
195		OPT_END()
196	};
197
198	tmp = calloc(j + 1, sizeof(char *));
199	if (!tmp)
200		return -EINVAL;
201
202	for (i = 0; i < j; i++)
203		tmp[i] = argv[i];
204
205	parse_options(j, tmp, event_options, NULL, PARSE_OPT_KEEP_UNKNOWN);
206	if (!event) {
207		if (perf_pmus__have_event("trace_imc", "trace_cycles")) {
208			argv[j++] = strdup("-e");
209			argv[j++] = strdup("trace_imc/trace_cycles/");
210			*argc += 2;
211		} else {
212			free(tmp);
213			return -EINVAL;
214		}
215	}
216
217	free(tmp);
218	return 0;
219}