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