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}
220