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