]>
Commit | Line | Data |
---|---|---|
a1645ce1 ZY |
1 | #include "builtin.h" |
2 | #include "perf.h" | |
3 | ||
bcf6edcd | 4 | #include "util/evsel.h" |
a1645ce1 ZY |
5 | #include "util/util.h" |
6 | #include "util/cache.h" | |
7 | #include "util/symbol.h" | |
8 | #include "util/thread.h" | |
9 | #include "util/header.h" | |
10 | #include "util/session.h" | |
11 | ||
12 | #include "util/parse-options.h" | |
13 | #include "util/trace-event.h" | |
a1645ce1 | 14 | #include "util/debug.h" |
bcf6edcd XG |
15 | #include "util/debugfs.h" |
16 | #include "util/tool.h" | |
17 | #include "util/stat.h" | |
a1645ce1 ZY |
18 | |
19 | #include <sys/prctl.h> | |
20 | ||
21 | #include <semaphore.h> | |
22 | #include <pthread.h> | |
23 | #include <math.h> | |
24 | ||
bcf6edcd XG |
25 | #include "../../arch/x86/include/asm/svm.h" |
26 | #include "../../arch/x86/include/asm/vmx.h" | |
27 | #include "../../arch/x86/include/asm/kvm.h" | |
28 | ||
29 | struct event_key { | |
30 | #define INVALID_KEY (~0ULL) | |
31 | u64 key; | |
32 | int info; | |
33 | }; | |
34 | ||
de332ac4 DA |
35 | struct kvm_event_stats { |
36 | u64 time; | |
37 | struct stats stats; | |
38 | }; | |
39 | ||
40 | struct kvm_event { | |
41 | struct list_head hash_entry; | |
42 | struct rb_node rb; | |
43 | ||
44 | struct event_key key; | |
45 | ||
46 | struct kvm_event_stats total; | |
47 | ||
48 | #define DEFAULT_VCPU_NUM 8 | |
49 | int max_vcpu; | |
50 | struct kvm_event_stats *vcpu; | |
51 | }; | |
52 | ||
53 | typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int); | |
54 | ||
55 | struct kvm_event_key { | |
56 | const char *name; | |
57 | key_cmp_fun key; | |
58 | }; | |
59 | ||
60 | ||
61 | struct perf_kvm; | |
62 | ||
bcf6edcd | 63 | struct kvm_events_ops { |
14907e73 ACM |
64 | bool (*is_begin_event)(struct perf_evsel *evsel, |
65 | struct perf_sample *sample, | |
66 | struct event_key *key); | |
67 | bool (*is_end_event)(struct perf_evsel *evsel, | |
68 | struct perf_sample *sample, struct event_key *key); | |
de332ac4 DA |
69 | void (*decode_key)(struct perf_kvm *kvm, struct event_key *key, |
70 | char decode[20]); | |
bcf6edcd XG |
71 | const char *name; |
72 | }; | |
73 | ||
de332ac4 DA |
74 | struct exit_reasons_table { |
75 | unsigned long exit_code; | |
76 | const char *reason; | |
77 | }; | |
78 | ||
79 | #define EVENTS_BITS 12 | |
80 | #define EVENTS_CACHE_SIZE (1UL << EVENTS_BITS) | |
81 | ||
82 | struct perf_kvm { | |
83 | struct perf_tool tool; | |
84 | struct perf_session *session; | |
85 | ||
86 | const char *file_name; | |
87 | const char *report_event; | |
88 | const char *sort_key; | |
89 | int trace_vcpu; | |
90 | ||
91 | struct exit_reasons_table *exit_reasons; | |
92 | int exit_reasons_size; | |
93 | const char *exit_reasons_isa; | |
94 | ||
95 | struct kvm_events_ops *events_ops; | |
96 | key_cmp_fun compare; | |
97 | struct list_head kvm_events_cache[EVENTS_CACHE_SIZE]; | |
98 | u64 total_time; | |
99 | u64 total_count; | |
100 | ||
101 | struct rb_root result; | |
102 | }; | |
103 | ||
104 | ||
14907e73 ACM |
105 | static void exit_event_get_key(struct perf_evsel *evsel, |
106 | struct perf_sample *sample, | |
107 | struct event_key *key) | |
bcf6edcd XG |
108 | { |
109 | key->info = 0; | |
14907e73 | 110 | key->key = perf_evsel__intval(evsel, sample, "exit_reason"); |
bcf6edcd XG |
111 | } |
112 | ||
14907e73 | 113 | static bool kvm_exit_event(struct perf_evsel *evsel) |
bcf6edcd | 114 | { |
14907e73 | 115 | return !strcmp(evsel->name, "kvm:kvm_exit"); |
bcf6edcd XG |
116 | } |
117 | ||
14907e73 ACM |
118 | static bool exit_event_begin(struct perf_evsel *evsel, |
119 | struct perf_sample *sample, struct event_key *key) | |
bcf6edcd | 120 | { |
14907e73 ACM |
121 | if (kvm_exit_event(evsel)) { |
122 | exit_event_get_key(evsel, sample, key); | |
bcf6edcd XG |
123 | return true; |
124 | } | |
125 | ||
126 | return false; | |
127 | } | |
128 | ||
14907e73 | 129 | static bool kvm_entry_event(struct perf_evsel *evsel) |
bcf6edcd | 130 | { |
14907e73 | 131 | return !strcmp(evsel->name, "kvm:kvm_entry"); |
bcf6edcd XG |
132 | } |
133 | ||
14907e73 ACM |
134 | static bool exit_event_end(struct perf_evsel *evsel, |
135 | struct perf_sample *sample __maybe_unused, | |
136 | struct event_key *key __maybe_unused) | |
bcf6edcd | 137 | { |
14907e73 | 138 | return kvm_entry_event(evsel); |
bcf6edcd XG |
139 | } |
140 | ||
de332ac4 | 141 | static struct exit_reasons_table vmx_exit_reasons[] = { |
bcf6edcd XG |
142 | VMX_EXIT_REASONS |
143 | }; | |
144 | ||
de332ac4 | 145 | static struct exit_reasons_table svm_exit_reasons[] = { |
bcf6edcd XG |
146 | SVM_EXIT_REASONS |
147 | }; | |
148 | ||
de332ac4 | 149 | static const char *get_exit_reason(struct perf_kvm *kvm, u64 exit_code) |
bcf6edcd | 150 | { |
de332ac4 DA |
151 | int i = kvm->exit_reasons_size; |
152 | struct exit_reasons_table *tbl = kvm->exit_reasons; | |
bcf6edcd | 153 | |
de332ac4 DA |
154 | while (i--) { |
155 | if (tbl->exit_code == exit_code) | |
156 | return tbl->reason; | |
157 | tbl++; | |
bcf6edcd XG |
158 | } |
159 | ||
160 | pr_err("unknown kvm exit code:%lld on %s\n", | |
de332ac4 | 161 | (unsigned long long)exit_code, kvm->exit_reasons_isa); |
bcf6edcd XG |
162 | return "UNKNOWN"; |
163 | } | |
164 | ||
de332ac4 DA |
165 | static void exit_event_decode_key(struct perf_kvm *kvm, |
166 | struct event_key *key, | |
167 | char decode[20]) | |
bcf6edcd | 168 | { |
de332ac4 | 169 | const char *exit_reason = get_exit_reason(kvm, key->key); |
bcf6edcd XG |
170 | |
171 | scnprintf(decode, 20, "%s", exit_reason); | |
172 | } | |
173 | ||
174 | static struct kvm_events_ops exit_events = { | |
175 | .is_begin_event = exit_event_begin, | |
176 | .is_end_event = exit_event_end, | |
177 | .decode_key = exit_event_decode_key, | |
178 | .name = "VM-EXIT" | |
179 | }; | |
180 | ||
de332ac4 DA |
181 | /* |
182 | * For the mmio events, we treat: | |
183 | * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry | |
184 | * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...). | |
185 | */ | |
14907e73 ACM |
186 | static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample, |
187 | struct event_key *key) | |
bcf6edcd | 188 | { |
14907e73 ACM |
189 | key->key = perf_evsel__intval(evsel, sample, "gpa"); |
190 | key->info = perf_evsel__intval(evsel, sample, "type"); | |
bcf6edcd XG |
191 | } |
192 | ||
193 | #define KVM_TRACE_MMIO_READ_UNSATISFIED 0 | |
194 | #define KVM_TRACE_MMIO_READ 1 | |
195 | #define KVM_TRACE_MMIO_WRITE 2 | |
196 | ||
14907e73 ACM |
197 | static bool mmio_event_begin(struct perf_evsel *evsel, |
198 | struct perf_sample *sample, struct event_key *key) | |
bcf6edcd XG |
199 | { |
200 | /* MMIO read begin event in kernel. */ | |
14907e73 | 201 | if (kvm_exit_event(evsel)) |
bcf6edcd XG |
202 | return true; |
203 | ||
204 | /* MMIO write begin event in kernel. */ | |
14907e73 ACM |
205 | if (!strcmp(evsel->name, "kvm:kvm_mmio") && |
206 | perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) { | |
207 | mmio_event_get_key(evsel, sample, key); | |
bcf6edcd XG |
208 | return true; |
209 | } | |
210 | ||
211 | return false; | |
212 | } | |
213 | ||
14907e73 ACM |
214 | static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample, |
215 | struct event_key *key) | |
bcf6edcd XG |
216 | { |
217 | /* MMIO write end event in kernel. */ | |
14907e73 | 218 | if (kvm_entry_event(evsel)) |
bcf6edcd XG |
219 | return true; |
220 | ||
221 | /* MMIO read end event in kernel.*/ | |
14907e73 ACM |
222 | if (!strcmp(evsel->name, "kvm:kvm_mmio") && |
223 | perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) { | |
224 | mmio_event_get_key(evsel, sample, key); | |
bcf6edcd XG |
225 | return true; |
226 | } | |
227 | ||
228 | return false; | |
229 | } | |
230 | ||
de332ac4 DA |
231 | static void mmio_event_decode_key(struct perf_kvm *kvm __maybe_unused, |
232 | struct event_key *key, | |
233 | char decode[20]) | |
bcf6edcd XG |
234 | { |
235 | scnprintf(decode, 20, "%#lx:%s", (unsigned long)key->key, | |
236 | key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R"); | |
237 | } | |
238 | ||
239 | static struct kvm_events_ops mmio_events = { | |
240 | .is_begin_event = mmio_event_begin, | |
241 | .is_end_event = mmio_event_end, | |
242 | .decode_key = mmio_event_decode_key, | |
243 | .name = "MMIO Access" | |
244 | }; | |
245 | ||
246 | /* The time of emulation pio access is from kvm_pio to kvm_entry. */ | |
14907e73 ACM |
247 | static void ioport_event_get_key(struct perf_evsel *evsel, |
248 | struct perf_sample *sample, | |
249 | struct event_key *key) | |
bcf6edcd | 250 | { |
14907e73 ACM |
251 | key->key = perf_evsel__intval(evsel, sample, "port"); |
252 | key->info = perf_evsel__intval(evsel, sample, "rw"); | |
bcf6edcd XG |
253 | } |
254 | ||
14907e73 ACM |
255 | static bool ioport_event_begin(struct perf_evsel *evsel, |
256 | struct perf_sample *sample, | |
257 | struct event_key *key) | |
bcf6edcd | 258 | { |
14907e73 ACM |
259 | if (!strcmp(evsel->name, "kvm:kvm_pio")) { |
260 | ioport_event_get_key(evsel, sample, key); | |
bcf6edcd XG |
261 | return true; |
262 | } | |
263 | ||
264 | return false; | |
265 | } | |
266 | ||
14907e73 ACM |
267 | static bool ioport_event_end(struct perf_evsel *evsel, |
268 | struct perf_sample *sample __maybe_unused, | |
bcf6edcd XG |
269 | struct event_key *key __maybe_unused) |
270 | { | |
14907e73 | 271 | return kvm_entry_event(evsel); |
bcf6edcd XG |
272 | } |
273 | ||
de332ac4 DA |
274 | static void ioport_event_decode_key(struct perf_kvm *kvm __maybe_unused, |
275 | struct event_key *key, | |
276 | char decode[20]) | |
bcf6edcd XG |
277 | { |
278 | scnprintf(decode, 20, "%#llx:%s", (unsigned long long)key->key, | |
279 | key->info ? "POUT" : "PIN"); | |
280 | } | |
281 | ||
282 | static struct kvm_events_ops ioport_events = { | |
283 | .is_begin_event = ioport_event_begin, | |
284 | .is_end_event = ioport_event_end, | |
285 | .decode_key = ioport_event_decode_key, | |
286 | .name = "IO Port Access" | |
287 | }; | |
288 | ||
de332ac4 | 289 | static bool register_kvm_events_ops(struct perf_kvm *kvm) |
bcf6edcd XG |
290 | { |
291 | bool ret = true; | |
292 | ||
de332ac4 DA |
293 | if (!strcmp(kvm->report_event, "vmexit")) |
294 | kvm->events_ops = &exit_events; | |
295 | else if (!strcmp(kvm->report_event, "mmio")) | |
296 | kvm->events_ops = &mmio_events; | |
297 | else if (!strcmp(kvm->report_event, "ioport")) | |
298 | kvm->events_ops = &ioport_events; | |
bcf6edcd | 299 | else { |
de332ac4 | 300 | pr_err("Unknown report event:%s\n", kvm->report_event); |
bcf6edcd XG |
301 | ret = false; |
302 | } | |
303 | ||
304 | return ret; | |
305 | } | |
306 | ||
bcf6edcd XG |
307 | struct vcpu_event_record { |
308 | int vcpu_id; | |
309 | u64 start_time; | |
310 | struct kvm_event *last_event; | |
311 | }; | |
312 | ||
bcf6edcd | 313 | |
de332ac4 | 314 | static void init_kvm_event_record(struct perf_kvm *kvm) |
bcf6edcd XG |
315 | { |
316 | int i; | |
317 | ||
318 | for (i = 0; i < (int)EVENTS_CACHE_SIZE; i++) | |
de332ac4 | 319 | INIT_LIST_HEAD(&kvm->kvm_events_cache[i]); |
bcf6edcd XG |
320 | } |
321 | ||
322 | static int kvm_events_hash_fn(u64 key) | |
323 | { | |
324 | return key & (EVENTS_CACHE_SIZE - 1); | |
325 | } | |
326 | ||
327 | static bool kvm_event_expand(struct kvm_event *event, int vcpu_id) | |
328 | { | |
329 | int old_max_vcpu = event->max_vcpu; | |
330 | ||
331 | if (vcpu_id < event->max_vcpu) | |
332 | return true; | |
333 | ||
334 | while (event->max_vcpu <= vcpu_id) | |
335 | event->max_vcpu += DEFAULT_VCPU_NUM; | |
336 | ||
337 | event->vcpu = realloc(event->vcpu, | |
338 | event->max_vcpu * sizeof(*event->vcpu)); | |
339 | if (!event->vcpu) { | |
340 | pr_err("Not enough memory\n"); | |
341 | return false; | |
342 | } | |
343 | ||
344 | memset(event->vcpu + old_max_vcpu, 0, | |
345 | (event->max_vcpu - old_max_vcpu) * sizeof(*event->vcpu)); | |
346 | return true; | |
347 | } | |
348 | ||
349 | static struct kvm_event *kvm_alloc_init_event(struct event_key *key) | |
350 | { | |
351 | struct kvm_event *event; | |
352 | ||
353 | event = zalloc(sizeof(*event)); | |
354 | if (!event) { | |
355 | pr_err("Not enough memory\n"); | |
356 | return NULL; | |
357 | } | |
358 | ||
359 | event->key = *key; | |
360 | return event; | |
361 | } | |
362 | ||
de332ac4 DA |
363 | static struct kvm_event *find_create_kvm_event(struct perf_kvm *kvm, |
364 | struct event_key *key) | |
bcf6edcd XG |
365 | { |
366 | struct kvm_event *event; | |
367 | struct list_head *head; | |
368 | ||
369 | BUG_ON(key->key == INVALID_KEY); | |
370 | ||
de332ac4 | 371 | head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)]; |
bcf6edcd XG |
372 | list_for_each_entry(event, head, hash_entry) |
373 | if (event->key.key == key->key && event->key.info == key->info) | |
374 | return event; | |
375 | ||
376 | event = kvm_alloc_init_event(key); | |
377 | if (!event) | |
378 | return NULL; | |
379 | ||
380 | list_add(&event->hash_entry, head); | |
381 | return event; | |
382 | } | |
383 | ||
de332ac4 DA |
384 | static bool handle_begin_event(struct perf_kvm *kvm, |
385 | struct vcpu_event_record *vcpu_record, | |
bcf6edcd XG |
386 | struct event_key *key, u64 timestamp) |
387 | { | |
388 | struct kvm_event *event = NULL; | |
389 | ||
390 | if (key->key != INVALID_KEY) | |
de332ac4 | 391 | event = find_create_kvm_event(kvm, key); |
bcf6edcd XG |
392 | |
393 | vcpu_record->last_event = event; | |
394 | vcpu_record->start_time = timestamp; | |
395 | return true; | |
396 | } | |
397 | ||
398 | static void | |
399 | kvm_update_event_stats(struct kvm_event_stats *kvm_stats, u64 time_diff) | |
400 | { | |
401 | kvm_stats->time += time_diff; | |
402 | update_stats(&kvm_stats->stats, time_diff); | |
403 | } | |
404 | ||
405 | static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event) | |
406 | { | |
407 | struct kvm_event_stats *kvm_stats = &event->total; | |
408 | ||
409 | if (vcpu_id != -1) | |
410 | kvm_stats = &event->vcpu[vcpu_id]; | |
411 | ||
412 | return rel_stddev_stats(stddev_stats(&kvm_stats->stats), | |
413 | avg_stats(&kvm_stats->stats)); | |
414 | } | |
415 | ||
416 | static bool update_kvm_event(struct kvm_event *event, int vcpu_id, | |
417 | u64 time_diff) | |
418 | { | |
2aa8eab0 DA |
419 | if (vcpu_id == -1) { |
420 | kvm_update_event_stats(&event->total, time_diff); | |
421 | return true; | |
422 | } | |
bcf6edcd XG |
423 | |
424 | if (!kvm_event_expand(event, vcpu_id)) | |
425 | return false; | |
426 | ||
427 | kvm_update_event_stats(&event->vcpu[vcpu_id], time_diff); | |
428 | return true; | |
429 | } | |
430 | ||
de332ac4 DA |
431 | static bool handle_end_event(struct perf_kvm *kvm, |
432 | struct vcpu_event_record *vcpu_record, | |
433 | struct event_key *key, | |
434 | u64 timestamp) | |
bcf6edcd XG |
435 | { |
436 | struct kvm_event *event; | |
437 | u64 time_begin, time_diff; | |
2aa8eab0 DA |
438 | int vcpu; |
439 | ||
440 | if (kvm->trace_vcpu == -1) | |
441 | vcpu = -1; | |
442 | else | |
443 | vcpu = vcpu_record->vcpu_id; | |
bcf6edcd XG |
444 | |
445 | event = vcpu_record->last_event; | |
446 | time_begin = vcpu_record->start_time; | |
447 | ||
448 | /* The begin event is not caught. */ | |
449 | if (!time_begin) | |
450 | return true; | |
451 | ||
452 | /* | |
453 | * In some case, the 'begin event' only records the start timestamp, | |
454 | * the actual event is recognized in the 'end event' (e.g. mmio-event). | |
455 | */ | |
456 | ||
457 | /* Both begin and end events did not get the key. */ | |
458 | if (!event && key->key == INVALID_KEY) | |
459 | return true; | |
460 | ||
461 | if (!event) | |
de332ac4 | 462 | event = find_create_kvm_event(kvm, key); |
bcf6edcd XG |
463 | |
464 | if (!event) | |
465 | return false; | |
466 | ||
467 | vcpu_record->last_event = NULL; | |
468 | vcpu_record->start_time = 0; | |
469 | ||
470 | BUG_ON(timestamp < time_begin); | |
471 | ||
472 | time_diff = timestamp - time_begin; | |
2aa8eab0 | 473 | return update_kvm_event(event, vcpu, time_diff); |
bcf6edcd XG |
474 | } |
475 | ||
14907e73 ACM |
476 | static |
477 | struct vcpu_event_record *per_vcpu_record(struct thread *thread, | |
478 | struct perf_evsel *evsel, | |
479 | struct perf_sample *sample) | |
bcf6edcd XG |
480 | { |
481 | /* Only kvm_entry records vcpu id. */ | |
14907e73 | 482 | if (!thread->priv && kvm_entry_event(evsel)) { |
bcf6edcd XG |
483 | struct vcpu_event_record *vcpu_record; |
484 | ||
14907e73 | 485 | vcpu_record = zalloc(sizeof(*vcpu_record)); |
bcf6edcd | 486 | if (!vcpu_record) { |
14907e73 | 487 | pr_err("%s: Not enough memory\n", __func__); |
bcf6edcd XG |
488 | return NULL; |
489 | } | |
490 | ||
14907e73 | 491 | vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id"); |
bcf6edcd XG |
492 | thread->priv = vcpu_record; |
493 | } | |
494 | ||
14907e73 | 495 | return thread->priv; |
bcf6edcd XG |
496 | } |
497 | ||
de332ac4 DA |
498 | static bool handle_kvm_event(struct perf_kvm *kvm, |
499 | struct thread *thread, | |
500 | struct perf_evsel *evsel, | |
14907e73 | 501 | struct perf_sample *sample) |
bcf6edcd XG |
502 | { |
503 | struct vcpu_event_record *vcpu_record; | |
504 | struct event_key key = {.key = INVALID_KEY}; | |
505 | ||
14907e73 | 506 | vcpu_record = per_vcpu_record(thread, evsel, sample); |
bcf6edcd XG |
507 | if (!vcpu_record) |
508 | return true; | |
509 | ||
2aa8eab0 DA |
510 | /* only process events for vcpus user cares about */ |
511 | if ((kvm->trace_vcpu != -1) && | |
512 | (kvm->trace_vcpu != vcpu_record->vcpu_id)) | |
513 | return true; | |
514 | ||
de332ac4 DA |
515 | if (kvm->events_ops->is_begin_event(evsel, sample, &key)) |
516 | return handle_begin_event(kvm, vcpu_record, &key, sample->time); | |
bcf6edcd | 517 | |
de332ac4 DA |
518 | if (kvm->events_ops->is_end_event(evsel, sample, &key)) |
519 | return handle_end_event(kvm, vcpu_record, &key, sample->time); | |
bcf6edcd XG |
520 | |
521 | return true; | |
522 | } | |
523 | ||
bcf6edcd XG |
524 | #define GET_EVENT_KEY(func, field) \ |
525 | static u64 get_event_ ##func(struct kvm_event *event, int vcpu) \ | |
526 | { \ | |
527 | if (vcpu == -1) \ | |
528 | return event->total.field; \ | |
529 | \ | |
530 | if (vcpu >= event->max_vcpu) \ | |
531 | return 0; \ | |
532 | \ | |
533 | return event->vcpu[vcpu].field; \ | |
534 | } | |
535 | ||
536 | #define COMPARE_EVENT_KEY(func, field) \ | |
537 | GET_EVENT_KEY(func, field) \ | |
538 | static int compare_kvm_event_ ## func(struct kvm_event *one, \ | |
539 | struct kvm_event *two, int vcpu)\ | |
540 | { \ | |
541 | return get_event_ ##func(one, vcpu) > \ | |
542 | get_event_ ##func(two, vcpu); \ | |
543 | } | |
544 | ||
545 | GET_EVENT_KEY(time, time); | |
546 | COMPARE_EVENT_KEY(count, stats.n); | |
547 | COMPARE_EVENT_KEY(mean, stats.mean); | |
548 | ||
549 | #define DEF_SORT_NAME_KEY(name, compare_key) \ | |
550 | { #name, compare_kvm_event_ ## compare_key } | |
551 | ||
552 | static struct kvm_event_key keys[] = { | |
553 | DEF_SORT_NAME_KEY(sample, count), | |
554 | DEF_SORT_NAME_KEY(time, mean), | |
555 | { NULL, NULL } | |
556 | }; | |
557 | ||
de332ac4 | 558 | static bool select_key(struct perf_kvm *kvm) |
bcf6edcd XG |
559 | { |
560 | int i; | |
561 | ||
562 | for (i = 0; keys[i].name; i++) { | |
de332ac4 DA |
563 | if (!strcmp(keys[i].name, kvm->sort_key)) { |
564 | kvm->compare = keys[i].key; | |
bcf6edcd XG |
565 | return true; |
566 | } | |
567 | } | |
568 | ||
de332ac4 | 569 | pr_err("Unknown compare key:%s\n", kvm->sort_key); |
bcf6edcd XG |
570 | return false; |
571 | } | |
572 | ||
de332ac4 DA |
573 | static void insert_to_result(struct rb_root *result, struct kvm_event *event, |
574 | key_cmp_fun bigger, int vcpu) | |
bcf6edcd | 575 | { |
de332ac4 | 576 | struct rb_node **rb = &result->rb_node; |
bcf6edcd XG |
577 | struct rb_node *parent = NULL; |
578 | struct kvm_event *p; | |
579 | ||
580 | while (*rb) { | |
581 | p = container_of(*rb, struct kvm_event, rb); | |
582 | parent = *rb; | |
583 | ||
584 | if (bigger(event, p, vcpu)) | |
585 | rb = &(*rb)->rb_left; | |
586 | else | |
587 | rb = &(*rb)->rb_right; | |
588 | } | |
589 | ||
590 | rb_link_node(&event->rb, parent, rb); | |
de332ac4 | 591 | rb_insert_color(&event->rb, result); |
bcf6edcd XG |
592 | } |
593 | ||
de332ac4 | 594 | static void update_total_count(struct perf_kvm *kvm, struct kvm_event *event) |
bcf6edcd | 595 | { |
de332ac4 DA |
596 | int vcpu = kvm->trace_vcpu; |
597 | ||
598 | kvm->total_count += get_event_count(event, vcpu); | |
599 | kvm->total_time += get_event_time(event, vcpu); | |
bcf6edcd XG |
600 | } |
601 | ||
602 | static bool event_is_valid(struct kvm_event *event, int vcpu) | |
603 | { | |
604 | return !!get_event_count(event, vcpu); | |
605 | } | |
606 | ||
de332ac4 | 607 | static void sort_result(struct perf_kvm *kvm) |
bcf6edcd XG |
608 | { |
609 | unsigned int i; | |
de332ac4 | 610 | int vcpu = kvm->trace_vcpu; |
bcf6edcd XG |
611 | struct kvm_event *event; |
612 | ||
613 | for (i = 0; i < EVENTS_CACHE_SIZE; i++) | |
de332ac4 | 614 | list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry) |
bcf6edcd | 615 | if (event_is_valid(event, vcpu)) { |
de332ac4 DA |
616 | update_total_count(kvm, event); |
617 | insert_to_result(&kvm->result, event, | |
618 | kvm->compare, vcpu); | |
bcf6edcd XG |
619 | } |
620 | } | |
621 | ||
622 | /* returns left most element of result, and erase it */ | |
de332ac4 | 623 | static struct kvm_event *pop_from_result(struct rb_root *result) |
bcf6edcd | 624 | { |
de332ac4 | 625 | struct rb_node *node = rb_first(result); |
bcf6edcd XG |
626 | |
627 | if (!node) | |
628 | return NULL; | |
629 | ||
de332ac4 | 630 | rb_erase(node, result); |
bcf6edcd XG |
631 | return container_of(node, struct kvm_event, rb); |
632 | } | |
633 | ||
634 | static void print_vcpu_info(int vcpu) | |
635 | { | |
636 | pr_info("Analyze events for "); | |
637 | ||
638 | if (vcpu == -1) | |
639 | pr_info("all VCPUs:\n\n"); | |
640 | else | |
641 | pr_info("VCPU %d:\n\n", vcpu); | |
642 | } | |
643 | ||
de332ac4 | 644 | static void print_result(struct perf_kvm *kvm) |
bcf6edcd XG |
645 | { |
646 | char decode[20]; | |
647 | struct kvm_event *event; | |
de332ac4 | 648 | int vcpu = kvm->trace_vcpu; |
bcf6edcd XG |
649 | |
650 | pr_info("\n\n"); | |
651 | print_vcpu_info(vcpu); | |
de332ac4 | 652 | pr_info("%20s ", kvm->events_ops->name); |
bcf6edcd XG |
653 | pr_info("%10s ", "Samples"); |
654 | pr_info("%9s ", "Samples%"); | |
655 | ||
656 | pr_info("%9s ", "Time%"); | |
657 | pr_info("%16s ", "Avg time"); | |
658 | pr_info("\n\n"); | |
659 | ||
de332ac4 | 660 | while ((event = pop_from_result(&kvm->result))) { |
bcf6edcd XG |
661 | u64 ecount, etime; |
662 | ||
663 | ecount = get_event_count(event, vcpu); | |
664 | etime = get_event_time(event, vcpu); | |
665 | ||
de332ac4 | 666 | kvm->events_ops->decode_key(kvm, &event->key, decode); |
bcf6edcd XG |
667 | pr_info("%20s ", decode); |
668 | pr_info("%10llu ", (unsigned long long)ecount); | |
de332ac4 DA |
669 | pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100); |
670 | pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100); | |
bcf6edcd XG |
671 | pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3, |
672 | kvm_event_rel_stddev(vcpu, event)); | |
673 | pr_info("\n"); | |
674 | } | |
675 | ||
676 | pr_info("\nTotal Samples:%lld, Total events handled time:%.2fus.\n\n", | |
de332ac4 | 677 | (unsigned long long)kvm->total_count, kvm->total_time / 1e3); |
bcf6edcd XG |
678 | } |
679 | ||
de332ac4 | 680 | static int process_sample_event(struct perf_tool *tool, |
bcf6edcd XG |
681 | union perf_event *event, |
682 | struct perf_sample *sample, | |
683 | struct perf_evsel *evsel, | |
684 | struct machine *machine) | |
685 | { | |
686 | struct thread *thread = machine__findnew_thread(machine, sample->tid); | |
de332ac4 | 687 | struct perf_kvm *kvm = container_of(tool, struct perf_kvm, tool); |
bcf6edcd XG |
688 | |
689 | if (thread == NULL) { | |
690 | pr_debug("problem processing %d event, skipping it.\n", | |
691 | event->header.type); | |
692 | return -1; | |
693 | } | |
694 | ||
de332ac4 | 695 | if (!handle_kvm_event(kvm, thread, evsel, sample)) |
bcf6edcd XG |
696 | return -1; |
697 | ||
698 | return 0; | |
699 | } | |
700 | ||
bcf6edcd XG |
701 | static int get_cpu_isa(struct perf_session *session) |
702 | { | |
2f9e97aa | 703 | char *cpuid = session->header.env.cpuid; |
bcf6edcd XG |
704 | int isa; |
705 | ||
bcf6edcd XG |
706 | if (strstr(cpuid, "Intel")) |
707 | isa = 1; | |
708 | else if (strstr(cpuid, "AMD")) | |
709 | isa = 0; | |
710 | else { | |
711 | pr_err("CPU %s is not supported.\n", cpuid); | |
712 | isa = -ENOTSUP; | |
713 | } | |
714 | ||
bcf6edcd XG |
715 | return isa; |
716 | } | |
717 | ||
de332ac4 | 718 | static int read_events(struct perf_kvm *kvm) |
bcf6edcd | 719 | { |
bcf6edcd XG |
720 | int ret; |
721 | ||
de332ac4 DA |
722 | struct perf_tool eops = { |
723 | .sample = process_sample_event, | |
724 | .comm = perf_event__process_comm, | |
725 | .ordered_samples = true, | |
726 | }; | |
727 | ||
728 | kvm->tool = eops; | |
729 | kvm->session = perf_session__new(kvm->file_name, O_RDONLY, 0, false, | |
730 | &kvm->tool); | |
731 | if (!kvm->session) { | |
bcf6edcd XG |
732 | pr_err("Initializing perf session failed\n"); |
733 | return -EINVAL; | |
734 | } | |
735 | ||
de332ac4 | 736 | if (!perf_session__has_traces(kvm->session, "kvm record")) |
bcf6edcd XG |
737 | return -EINVAL; |
738 | ||
739 | /* | |
740 | * Do not use 'isa' recorded in kvm_exit tracepoint since it is not | |
741 | * traced in the old kernel. | |
742 | */ | |
de332ac4 | 743 | ret = get_cpu_isa(kvm->session); |
bcf6edcd XG |
744 | |
745 | if (ret < 0) | |
746 | return ret; | |
747 | ||
de332ac4 DA |
748 | if (ret == 1) { |
749 | kvm->exit_reasons = vmx_exit_reasons; | |
750 | kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons); | |
751 | kvm->exit_reasons_isa = "VMX"; | |
752 | } | |
bcf6edcd | 753 | |
de332ac4 | 754 | return perf_session__process_events(kvm->session, &kvm->tool); |
bcf6edcd XG |
755 | } |
756 | ||
757 | static bool verify_vcpu(int vcpu) | |
758 | { | |
759 | if (vcpu != -1 && vcpu < 0) { | |
760 | pr_err("Invalid vcpu:%d.\n", vcpu); | |
761 | return false; | |
762 | } | |
763 | ||
764 | return true; | |
765 | } | |
766 | ||
de332ac4 | 767 | static int kvm_events_report_vcpu(struct perf_kvm *kvm) |
bcf6edcd XG |
768 | { |
769 | int ret = -EINVAL; | |
de332ac4 | 770 | int vcpu = kvm->trace_vcpu; |
bcf6edcd XG |
771 | |
772 | if (!verify_vcpu(vcpu)) | |
773 | goto exit; | |
774 | ||
de332ac4 | 775 | if (!select_key(kvm)) |
bcf6edcd XG |
776 | goto exit; |
777 | ||
de332ac4 | 778 | if (!register_kvm_events_ops(kvm)) |
bcf6edcd XG |
779 | goto exit; |
780 | ||
de332ac4 | 781 | init_kvm_event_record(kvm); |
bcf6edcd XG |
782 | setup_pager(); |
783 | ||
de332ac4 | 784 | ret = read_events(kvm); |
bcf6edcd XG |
785 | if (ret) |
786 | goto exit; | |
787 | ||
de332ac4 DA |
788 | sort_result(kvm); |
789 | print_result(kvm); | |
790 | ||
bcf6edcd XG |
791 | exit: |
792 | return ret; | |
793 | } | |
794 | ||
795 | static const char * const record_args[] = { | |
796 | "record", | |
797 | "-R", | |
798 | "-f", | |
799 | "-m", "1024", | |
800 | "-c", "1", | |
801 | "-e", "kvm:kvm_entry", | |
802 | "-e", "kvm:kvm_exit", | |
803 | "-e", "kvm:kvm_mmio", | |
804 | "-e", "kvm:kvm_pio", | |
805 | }; | |
806 | ||
807 | #define STRDUP_FAIL_EXIT(s) \ | |
808 | ({ char *_p; \ | |
809 | _p = strdup(s); \ | |
810 | if (!_p) \ | |
811 | return -ENOMEM; \ | |
812 | _p; \ | |
813 | }) | |
814 | ||
de332ac4 | 815 | static int kvm_events_record(struct perf_kvm *kvm, int argc, const char **argv) |
bcf6edcd XG |
816 | { |
817 | unsigned int rec_argc, i, j; | |
818 | const char **rec_argv; | |
819 | ||
820 | rec_argc = ARRAY_SIZE(record_args) + argc + 2; | |
821 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); | |
822 | ||
823 | if (rec_argv == NULL) | |
824 | return -ENOMEM; | |
825 | ||
826 | for (i = 0; i < ARRAY_SIZE(record_args); i++) | |
827 | rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]); | |
828 | ||
829 | rec_argv[i++] = STRDUP_FAIL_EXIT("-o"); | |
de332ac4 | 830 | rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name); |
bcf6edcd XG |
831 | |
832 | for (j = 1; j < (unsigned int)argc; j++, i++) | |
833 | rec_argv[i] = argv[j]; | |
834 | ||
835 | return cmd_record(i, rec_argv, NULL); | |
836 | } | |
837 | ||
de332ac4 DA |
838 | static int kvm_events_report(struct perf_kvm *kvm, int argc, const char **argv) |
839 | { | |
840 | const struct option kvm_events_report_options[] = { | |
841 | OPT_STRING(0, "event", &kvm->report_event, "report event", | |
842 | "event for reporting: vmexit, mmio, ioport"), | |
843 | OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu, | |
844 | "vcpu id to report"), | |
845 | OPT_STRING('k', "key", &kvm->sort_key, "sort-key", | |
846 | "key for sorting: sample(sort by samples number)" | |
847 | " time (sort by avg time)"), | |
848 | OPT_END() | |
849 | }; | |
bcf6edcd | 850 | |
de332ac4 DA |
851 | const char * const kvm_events_report_usage[] = { |
852 | "perf kvm stat report [<options>]", | |
853 | NULL | |
854 | }; | |
bcf6edcd | 855 | |
bcf6edcd XG |
856 | symbol__init(); |
857 | ||
858 | if (argc) { | |
859 | argc = parse_options(argc, argv, | |
860 | kvm_events_report_options, | |
861 | kvm_events_report_usage, 0); | |
862 | if (argc) | |
863 | usage_with_options(kvm_events_report_usage, | |
864 | kvm_events_report_options); | |
865 | } | |
866 | ||
de332ac4 | 867 | return kvm_events_report_vcpu(kvm); |
bcf6edcd XG |
868 | } |
869 | ||
870 | static void print_kvm_stat_usage(void) | |
871 | { | |
872 | printf("Usage: perf kvm stat <command>\n\n"); | |
873 | ||
874 | printf("# Available commands:\n"); | |
875 | printf("\trecord: record kvm events\n"); | |
876 | printf("\treport: report statistical data of kvm events\n"); | |
877 | ||
878 | printf("\nOtherwise, it is the alias of 'perf stat':\n"); | |
879 | } | |
880 | ||
de332ac4 | 881 | static int kvm_cmd_stat(struct perf_kvm *kvm, int argc, const char **argv) |
bcf6edcd XG |
882 | { |
883 | if (argc == 1) { | |
884 | print_kvm_stat_usage(); | |
885 | goto perf_stat; | |
886 | } | |
887 | ||
888 | if (!strncmp(argv[1], "rec", 3)) | |
de332ac4 | 889 | return kvm_events_record(kvm, argc - 1, argv + 1); |
bcf6edcd XG |
890 | |
891 | if (!strncmp(argv[1], "rep", 3)) | |
de332ac4 | 892 | return kvm_events_report(kvm, argc - 1 , argv + 1); |
bcf6edcd XG |
893 | |
894 | perf_stat: | |
895 | return cmd_stat(argc, argv, NULL); | |
896 | } | |
897 | ||
de332ac4 | 898 | static int __cmd_record(struct perf_kvm *kvm, int argc, const char **argv) |
a1645ce1 ZY |
899 | { |
900 | int rec_argc, i = 0, j; | |
901 | const char **rec_argv; | |
902 | ||
903 | rec_argc = argc + 2; | |
904 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); | |
905 | rec_argv[i++] = strdup("record"); | |
906 | rec_argv[i++] = strdup("-o"); | |
de332ac4 | 907 | rec_argv[i++] = strdup(kvm->file_name); |
a1645ce1 ZY |
908 | for (j = 1; j < argc; j++, i++) |
909 | rec_argv[i] = argv[j]; | |
910 | ||
911 | BUG_ON(i != rec_argc); | |
912 | ||
913 | return cmd_record(i, rec_argv, NULL); | |
914 | } | |
915 | ||
de332ac4 | 916 | static int __cmd_report(struct perf_kvm *kvm, int argc, const char **argv) |
a1645ce1 ZY |
917 | { |
918 | int rec_argc, i = 0, j; | |
919 | const char **rec_argv; | |
920 | ||
921 | rec_argc = argc + 2; | |
922 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); | |
923 | rec_argv[i++] = strdup("report"); | |
924 | rec_argv[i++] = strdup("-i"); | |
de332ac4 | 925 | rec_argv[i++] = strdup(kvm->file_name); |
a1645ce1 ZY |
926 | for (j = 1; j < argc; j++, i++) |
927 | rec_argv[i] = argv[j]; | |
928 | ||
929 | BUG_ON(i != rec_argc); | |
930 | ||
931 | return cmd_report(i, rec_argv, NULL); | |
932 | } | |
933 | ||
de332ac4 | 934 | static int __cmd_buildid_list(struct perf_kvm *kvm, int argc, const char **argv) |
a1645ce1 ZY |
935 | { |
936 | int rec_argc, i = 0, j; | |
937 | const char **rec_argv; | |
938 | ||
939 | rec_argc = argc + 2; | |
940 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); | |
941 | rec_argv[i++] = strdup("buildid-list"); | |
942 | rec_argv[i++] = strdup("-i"); | |
de332ac4 | 943 | rec_argv[i++] = strdup(kvm->file_name); |
a1645ce1 ZY |
944 | for (j = 1; j < argc; j++, i++) |
945 | rec_argv[i] = argv[j]; | |
946 | ||
947 | BUG_ON(i != rec_argc); | |
948 | ||
949 | return cmd_buildid_list(i, rec_argv, NULL); | |
950 | } | |
951 | ||
1d037ca1 | 952 | int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused) |
a1645ce1 | 953 | { |
de332ac4 DA |
954 | struct perf_kvm kvm = { |
955 | .trace_vcpu = -1, | |
956 | .report_event = "vmexit", | |
957 | .sort_key = "sample", | |
958 | ||
959 | .exit_reasons = svm_exit_reasons, | |
960 | .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons), | |
961 | .exit_reasons_isa = "SVM", | |
962 | }; | |
963 | ||
964 | const struct option kvm_options[] = { | |
965 | OPT_STRING('i', "input", &kvm.file_name, "file", | |
966 | "Input file name"), | |
967 | OPT_STRING('o', "output", &kvm.file_name, "file", | |
968 | "Output file name"), | |
969 | OPT_BOOLEAN(0, "guest", &perf_guest, | |
970 | "Collect guest os data"), | |
971 | OPT_BOOLEAN(0, "host", &perf_host, | |
972 | "Collect host os data"), | |
973 | OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory", | |
974 | "guest mount directory under which every guest os" | |
975 | " instance has a subdir"), | |
976 | OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name, | |
977 | "file", "file saving guest os vmlinux"), | |
978 | OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms, | |
979 | "file", "file saving guest os /proc/kallsyms"), | |
980 | OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules, | |
981 | "file", "file saving guest os /proc/modules"), | |
982 | OPT_END() | |
983 | }; | |
984 | ||
985 | ||
986 | const char * const kvm_usage[] = { | |
987 | "perf kvm [<options>] {top|record|report|diff|buildid-list|stat}", | |
988 | NULL | |
989 | }; | |
990 | ||
1aed2671 JR |
991 | perf_host = 0; |
992 | perf_guest = 1; | |
a1645ce1 ZY |
993 | |
994 | argc = parse_options(argc, argv, kvm_options, kvm_usage, | |
995 | PARSE_OPT_STOP_AT_NON_OPTION); | |
996 | if (!argc) | |
997 | usage_with_options(kvm_usage, kvm_options); | |
998 | ||
999 | if (!perf_host) | |
1000 | perf_guest = 1; | |
1001 | ||
de332ac4 | 1002 | if (!kvm.file_name) { |
a1645ce1 | 1003 | if (perf_host && !perf_guest) |
de332ac4 | 1004 | kvm.file_name = strdup("perf.data.host"); |
a1645ce1 | 1005 | else if (!perf_host && perf_guest) |
de332ac4 | 1006 | kvm.file_name = strdup("perf.data.guest"); |
a1645ce1 | 1007 | else |
de332ac4 DA |
1008 | kvm.file_name = strdup("perf.data.kvm"); |
1009 | ||
1010 | if (!kvm.file_name) { | |
1011 | pr_err("Failed to allocate memory for filename\n"); | |
1012 | return -ENOMEM; | |
1013 | } | |
a1645ce1 ZY |
1014 | } |
1015 | ||
1016 | if (!strncmp(argv[0], "rec", 3)) | |
de332ac4 | 1017 | return __cmd_record(&kvm, argc, argv); |
a1645ce1 | 1018 | else if (!strncmp(argv[0], "rep", 3)) |
de332ac4 | 1019 | return __cmd_report(&kvm, argc, argv); |
a1645ce1 ZY |
1020 | else if (!strncmp(argv[0], "diff", 4)) |
1021 | return cmd_diff(argc, argv, NULL); | |
1022 | else if (!strncmp(argv[0], "top", 3)) | |
1023 | return cmd_top(argc, argv, NULL); | |
1024 | else if (!strncmp(argv[0], "buildid-list", 12)) | |
de332ac4 | 1025 | return __cmd_buildid_list(&kvm, argc, argv); |
bcf6edcd | 1026 | else if (!strncmp(argv[0], "stat", 4)) |
de332ac4 | 1027 | return kvm_cmd_stat(&kvm, argc, argv); |
a1645ce1 ZY |
1028 | else |
1029 | usage_with_options(kvm_usage, kvm_options); | |
1030 | ||
1031 | return 0; | |
1032 | } |