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
16 const char *vcpu_id_str = "vcpu_id";
17 const char *kvm_entry_trace = "kvm_hv:kvm_guest_enter";
18 const char *kvm_exit_trace = "kvm_hv:kvm_guest_exit";
19
20 define_exit_reasons_table(hv_exit_reasons, kvm_trace_symbol_exit);
21 define_exit_reasons_table(hcall_reasons, kvm_trace_symbol_hcall);
22
23 /* Tracepoints specific to ppc_book3s_hv */
24 const 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 */
33 const char *kvm_events_tp[NR_TPS + 1];
34 const char *kvm_exit_reason;
35
36 static 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
44 static 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
59 static 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
66 static 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 }
76 static 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
85 static 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
92 static 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
99 struct 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
105 const char * const kvm_skip_events[] = {
106 NULL,
107 };
108
109
110 static 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
123 static 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 */
149 static 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
160 int setup_kvm_events_tp(struct perf_kvm_stat *kvm)
161 {
162 return ppc__setup_kvm_tp(kvm);
163 }
164
165 int 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 */
187 int 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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.