]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - tools/perf/builtin-kvm.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[karo-tx-linux.git] / tools / perf / builtin-kvm.c
1 #include "builtin.h"
2 #include "perf.h"
3
4 #include "util/evsel.h"
5 #include "util/evlist.h"
6 #include "util/util.h"
7 #include "util/cache.h"
8 #include "util/symbol.h"
9 #include "util/thread.h"
10 #include "util/header.h"
11 #include "util/session.h"
12 #include "util/intlist.h"
13 #include "util/parse-options.h"
14 #include "util/trace-event.h"
15 #include "util/debug.h"
16 #include <api/fs/debugfs.h>
17 #include "util/tool.h"
18 #include "util/stat.h"
19 #include "util/top.h"
20 #include "util/data.h"
21
22 #include <sys/prctl.h>
23 #ifdef HAVE_TIMERFD_SUPPORT
24 #include <sys/timerfd.h>
25 #endif
26
27 #include <termios.h>
28 #include <semaphore.h>
29 #include <pthread.h>
30 #include <math.h>
31
32 #if defined(__i386__) || defined(__x86_64__)
33 #include <asm/svm.h>
34 #include <asm/vmx.h>
35 #include <asm/kvm.h>
36
37 struct event_key {
38         #define INVALID_KEY     (~0ULL)
39         u64 key;
40         int info;
41 };
42
43 struct kvm_event_stats {
44         u64 time;
45         struct stats stats;
46 };
47
48 struct kvm_event {
49         struct list_head hash_entry;
50         struct rb_node rb;
51
52         struct event_key key;
53
54         struct kvm_event_stats total;
55
56         #define DEFAULT_VCPU_NUM 8
57         int max_vcpu;
58         struct kvm_event_stats *vcpu;
59 };
60
61 typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int);
62
63 struct kvm_event_key {
64         const char *name;
65         key_cmp_fun key;
66 };
67
68
69 struct perf_kvm_stat;
70
71 struct kvm_events_ops {
72         bool (*is_begin_event)(struct perf_evsel *evsel,
73                                struct perf_sample *sample,
74                                struct event_key *key);
75         bool (*is_end_event)(struct perf_evsel *evsel,
76                              struct perf_sample *sample, struct event_key *key);
77         void (*decode_key)(struct perf_kvm_stat *kvm, struct event_key *key,
78                            char decode[20]);
79         const char *name;
80 };
81
82 struct exit_reasons_table {
83         unsigned long exit_code;
84         const char *reason;
85 };
86
87 #define EVENTS_BITS             12
88 #define EVENTS_CACHE_SIZE       (1UL << EVENTS_BITS)
89
90 struct perf_kvm_stat {
91         struct perf_tool    tool;
92         struct record_opts  opts;
93         struct perf_evlist  *evlist;
94         struct perf_session *session;
95
96         const char *file_name;
97         const char *report_event;
98         const char *sort_key;
99         int trace_vcpu;
100
101         struct exit_reasons_table *exit_reasons;
102         int exit_reasons_size;
103         const char *exit_reasons_isa;
104
105         struct kvm_events_ops *events_ops;
106         key_cmp_fun compare;
107         struct list_head kvm_events_cache[EVENTS_CACHE_SIZE];
108
109         u64 total_time;
110         u64 total_count;
111         u64 lost_events;
112         u64 duration;
113
114         const char *pid_str;
115         struct intlist *pid_list;
116
117         struct rb_root result;
118
119         int timerfd;
120         unsigned int display_time;
121         bool live;
122 };
123
124
125 static void exit_event_get_key(struct perf_evsel *evsel,
126                                struct perf_sample *sample,
127                                struct event_key *key)
128 {
129         key->info = 0;
130         key->key = perf_evsel__intval(evsel, sample, "exit_reason");
131 }
132
133 static bool kvm_exit_event(struct perf_evsel *evsel)
134 {
135         return !strcmp(evsel->name, "kvm:kvm_exit");
136 }
137
138 static bool exit_event_begin(struct perf_evsel *evsel,
139                              struct perf_sample *sample, struct event_key *key)
140 {
141         if (kvm_exit_event(evsel)) {
142                 exit_event_get_key(evsel, sample, key);
143                 return true;
144         }
145
146         return false;
147 }
148
149 static bool kvm_entry_event(struct perf_evsel *evsel)
150 {
151         return !strcmp(evsel->name, "kvm:kvm_entry");
152 }
153
154 static bool exit_event_end(struct perf_evsel *evsel,
155                            struct perf_sample *sample __maybe_unused,
156                            struct event_key *key __maybe_unused)
157 {
158         return kvm_entry_event(evsel);
159 }
160
161 static struct exit_reasons_table vmx_exit_reasons[] = {
162         VMX_EXIT_REASONS
163 };
164
165 static struct exit_reasons_table svm_exit_reasons[] = {
166         SVM_EXIT_REASONS
167 };
168
169 static const char *get_exit_reason(struct perf_kvm_stat *kvm, u64 exit_code)
170 {
171         int i = kvm->exit_reasons_size;
172         struct exit_reasons_table *tbl = kvm->exit_reasons;
173
174         while (i--) {
175                 if (tbl->exit_code == exit_code)
176                         return tbl->reason;
177                 tbl++;
178         }
179
180         pr_err("unknown kvm exit code:%lld on %s\n",
181                 (unsigned long long)exit_code, kvm->exit_reasons_isa);
182         return "UNKNOWN";
183 }
184
185 static void exit_event_decode_key(struct perf_kvm_stat *kvm,
186                                   struct event_key *key,
187                                   char decode[20])
188 {
189         const char *exit_reason = get_exit_reason(kvm, key->key);
190
191         scnprintf(decode, 20, "%s", exit_reason);
192 }
193
194 static struct kvm_events_ops exit_events = {
195         .is_begin_event = exit_event_begin,
196         .is_end_event = exit_event_end,
197         .decode_key = exit_event_decode_key,
198         .name = "VM-EXIT"
199 };
200
201 /*
202  * For the mmio events, we treat:
203  * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
204  * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
205  */
206 static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample,
207                                struct event_key *key)
208 {
209         key->key  = perf_evsel__intval(evsel, sample, "gpa");
210         key->info = perf_evsel__intval(evsel, sample, "type");
211 }
212
213 #define KVM_TRACE_MMIO_READ_UNSATISFIED 0
214 #define KVM_TRACE_MMIO_READ 1
215 #define KVM_TRACE_MMIO_WRITE 2
216
217 static bool mmio_event_begin(struct perf_evsel *evsel,
218                              struct perf_sample *sample, struct event_key *key)
219 {
220         /* MMIO read begin event in kernel. */
221         if (kvm_exit_event(evsel))
222                 return true;
223
224         /* MMIO write begin event in kernel. */
225         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
226             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
227                 mmio_event_get_key(evsel, sample, key);
228                 return true;
229         }
230
231         return false;
232 }
233
234 static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample,
235                            struct event_key *key)
236 {
237         /* MMIO write end event in kernel. */
238         if (kvm_entry_event(evsel))
239                 return true;
240
241         /* MMIO read end event in kernel.*/
242         if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
243             perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
244                 mmio_event_get_key(evsel, sample, key);
245                 return true;
246         }
247
248         return false;
249 }
250
251 static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
252                                   struct event_key *key,
253                                   char decode[20])
254 {
255         scnprintf(decode, 20, "%#lx:%s", (unsigned long)key->key,
256                                 key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
257 }
258
259 static struct kvm_events_ops mmio_events = {
260         .is_begin_event = mmio_event_begin,
261         .is_end_event = mmio_event_end,
262         .decode_key = mmio_event_decode_key,
263         .name = "MMIO Access"
264 };
265
266  /* The time of emulation pio access is from kvm_pio to kvm_entry. */
267 static void ioport_event_get_key(struct perf_evsel *evsel,
268                                  struct perf_sample *sample,
269                                  struct event_key *key)
270 {
271         key->key  = perf_evsel__intval(evsel, sample, "port");
272         key->info = perf_evsel__intval(evsel, sample, "rw");
273 }
274
275 static bool ioport_event_begin(struct perf_evsel *evsel,
276                                struct perf_sample *sample,
277                                struct event_key *key)
278 {
279         if (!strcmp(evsel->name, "kvm:kvm_pio")) {
280                 ioport_event_get_key(evsel, sample, key);
281                 return true;
282         }
283
284         return false;
285 }
286
287 static bool ioport_event_end(struct perf_evsel *evsel,
288                              struct perf_sample *sample __maybe_unused,
289                              struct event_key *key __maybe_unused)
290 {
291         return kvm_entry_event(evsel);
292 }
293
294 static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
295                                     struct event_key *key,
296                                     char decode[20])
297 {
298         scnprintf(decode, 20, "%#llx:%s", (unsigned long long)key->key,
299                                 key->info ? "POUT" : "PIN");
300 }
301
302 static struct kvm_events_ops ioport_events = {
303         .is_begin_event = ioport_event_begin,
304         .is_end_event = ioport_event_end,
305         .decode_key = ioport_event_decode_key,
306         .name = "IO Port Access"
307 };
308
309 static bool register_kvm_events_ops(struct perf_kvm_stat *kvm)
310 {
311         bool ret = true;
312
313         if (!strcmp(kvm->report_event, "vmexit"))
314                 kvm->events_ops = &exit_events;
315         else if (!strcmp(kvm->report_event, "mmio"))
316                 kvm->events_ops = &mmio_events;
317         else if (!strcmp(kvm->report_event, "ioport"))
318                 kvm->events_ops = &ioport_events;
319         else {
320                 pr_err("Unknown report event:%s\n", kvm->report_event);
321                 ret = false;
322         }
323
324         return ret;
325 }
326
327 struct vcpu_event_record {
328         int vcpu_id;
329         u64 start_time;
330         struct kvm_event *last_event;
331 };
332
333
334 static void init_kvm_event_record(struct perf_kvm_stat *kvm)
335 {
336         unsigned int i;
337
338         for (i = 0; i < EVENTS_CACHE_SIZE; i++)
339                 INIT_LIST_HEAD(&kvm->kvm_events_cache[i]);
340 }
341
342 #ifdef HAVE_TIMERFD_SUPPORT
343 static void clear_events_cache_stats(struct list_head *kvm_events_cache)
344 {
345         struct list_head *head;
346         struct kvm_event *event;
347         unsigned int i;
348         int j;
349
350         for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
351                 head = &kvm_events_cache[i];
352                 list_for_each_entry(event, head, hash_entry) {
353                         /* reset stats for event */
354                         event->total.time = 0;
355                         init_stats(&event->total.stats);
356
357                         for (j = 0; j < event->max_vcpu; ++j) {
358                                 event->vcpu[j].time = 0;
359                                 init_stats(&event->vcpu[j].stats);
360                         }
361                 }
362         }
363 }
364 #endif
365
366 static int kvm_events_hash_fn(u64 key)
367 {
368         return key & (EVENTS_CACHE_SIZE - 1);
369 }
370
371 static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
372 {
373         int old_max_vcpu = event->max_vcpu;
374         void *prev;
375
376         if (vcpu_id < event->max_vcpu)
377                 return true;
378
379         while (event->max_vcpu <= vcpu_id)
380                 event->max_vcpu += DEFAULT_VCPU_NUM;
381
382         prev = event->vcpu;
383         event->vcpu = realloc(event->vcpu,
384                               event->max_vcpu * sizeof(*event->vcpu));
385         if (!event->vcpu) {
386                 free(prev);
387                 pr_err("Not enough memory\n");
388                 return false;
389         }
390
391         memset(event->vcpu + old_max_vcpu, 0,
392                (event->max_vcpu - old_max_vcpu) * sizeof(*event->vcpu));
393         return true;
394 }
395
396 static struct kvm_event *kvm_alloc_init_event(struct event_key *key)
397 {
398         struct kvm_event *event;
399
400         event = zalloc(sizeof(*event));
401         if (!event) {
402                 pr_err("Not enough memory\n");
403                 return NULL;
404         }
405
406         event->key = *key;
407         init_stats(&event->total.stats);
408         return event;
409 }
410
411 static struct kvm_event *find_create_kvm_event(struct perf_kvm_stat *kvm,
412                                                struct event_key *key)
413 {
414         struct kvm_event *event;
415         struct list_head *head;
416
417         BUG_ON(key->key == INVALID_KEY);
418
419         head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)];
420         list_for_each_entry(event, head, hash_entry) {
421                 if (event->key.key == key->key && event->key.info == key->info)
422                         return event;
423         }
424
425         event = kvm_alloc_init_event(key);
426         if (!event)
427                 return NULL;
428
429         list_add(&event->hash_entry, head);
430         return event;
431 }
432
433 static bool handle_begin_event(struct perf_kvm_stat *kvm,
434                                struct vcpu_event_record *vcpu_record,
435                                struct event_key *key, u64 timestamp)
436 {
437         struct kvm_event *event = NULL;
438
439         if (key->key != INVALID_KEY)
440                 event = find_create_kvm_event(kvm, key);
441
442         vcpu_record->last_event = event;
443         vcpu_record->start_time = timestamp;
444         return true;
445 }
446
447 static void
448 kvm_update_event_stats(struct kvm_event_stats *kvm_stats, u64 time_diff)
449 {
450         kvm_stats->time += time_diff;
451         update_stats(&kvm_stats->stats, time_diff);
452 }
453
454 static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event)
455 {
456         struct kvm_event_stats *kvm_stats = &event->total;
457
458         if (vcpu_id != -1)
459                 kvm_stats = &event->vcpu[vcpu_id];
460
461         return rel_stddev_stats(stddev_stats(&kvm_stats->stats),
462                                 avg_stats(&kvm_stats->stats));
463 }
464
465 static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
466                              u64 time_diff)
467 {
468         if (vcpu_id == -1) {
469                 kvm_update_event_stats(&event->total, time_diff);
470                 return true;
471         }
472
473         if (!kvm_event_expand(event, vcpu_id))
474                 return false;
475
476         kvm_update_event_stats(&event->vcpu[vcpu_id], time_diff);
477         return true;
478 }
479
480 static bool handle_end_event(struct perf_kvm_stat *kvm,
481                              struct vcpu_event_record *vcpu_record,
482                              struct event_key *key,
483                              struct perf_sample *sample)
484 {
485         struct kvm_event *event;
486         u64 time_begin, time_diff;
487         int vcpu;
488
489         if (kvm->trace_vcpu == -1)
490                 vcpu = -1;
491         else
492                 vcpu = vcpu_record->vcpu_id;
493
494         event = vcpu_record->last_event;
495         time_begin = vcpu_record->start_time;
496
497         /* The begin event is not caught. */
498         if (!time_begin)
499                 return true;
500
501         /*
502          * In some case, the 'begin event' only records the start timestamp,
503          * the actual event is recognized in the 'end event' (e.g. mmio-event).
504          */
505
506         /* Both begin and end events did not get the key. */
507         if (!event && key->key == INVALID_KEY)
508                 return true;
509
510         if (!event)
511                 event = find_create_kvm_event(kvm, key);
512
513         if (!event)
514                 return false;
515
516         vcpu_record->last_event = NULL;
517         vcpu_record->start_time = 0;
518
519         /* seems to happen once in a while during live mode */
520         if (sample->time < time_begin) {
521                 pr_debug("End time before begin time; skipping event.\n");
522                 return true;
523         }
524
525         time_diff = sample->time - time_begin;
526
527         if (kvm->duration && time_diff > kvm->duration) {
528                 char decode[32];
529
530                 kvm->events_ops->decode_key(kvm, &event->key, decode);
531                 if (strcmp(decode, "HLT")) {
532                         pr_info("%" PRIu64 " VM %d, vcpu %d: %s event took %" PRIu64 "usec\n",
533                                  sample->time, sample->pid, vcpu_record->vcpu_id,
534                                  decode, time_diff/1000);
535                 }
536         }
537
538         return update_kvm_event(event, vcpu, time_diff);
539 }
540
541 static
542 struct vcpu_event_record *per_vcpu_record(struct thread *thread,
543                                           struct perf_evsel *evsel,
544                                           struct perf_sample *sample)
545 {
546         /* Only kvm_entry records vcpu id. */
547         if (!thread->priv && kvm_entry_event(evsel)) {
548                 struct vcpu_event_record *vcpu_record;
549
550                 vcpu_record = zalloc(sizeof(*vcpu_record));
551                 if (!vcpu_record) {
552                         pr_err("%s: Not enough memory\n", __func__);
553                         return NULL;
554                 }
555
556                 vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id");
557                 thread->priv = vcpu_record;
558         }
559
560         return thread->priv;
561 }
562
563 static bool handle_kvm_event(struct perf_kvm_stat *kvm,
564                              struct thread *thread,
565                              struct perf_evsel *evsel,
566                              struct perf_sample *sample)
567 {
568         struct vcpu_event_record *vcpu_record;
569         struct event_key key = {.key = INVALID_KEY};
570
571         vcpu_record = per_vcpu_record(thread, evsel, sample);
572         if (!vcpu_record)
573                 return true;
574
575         /* only process events for vcpus user cares about */
576         if ((kvm->trace_vcpu != -1) &&
577             (kvm->trace_vcpu != vcpu_record->vcpu_id))
578                 return true;
579
580         if (kvm->events_ops->is_begin_event(evsel, sample, &key))
581                 return handle_begin_event(kvm, vcpu_record, &key, sample->time);
582
583         if (kvm->events_ops->is_end_event(evsel, sample, &key))
584                 return handle_end_event(kvm, vcpu_record, &key, sample);
585
586         return true;
587 }
588
589 #define GET_EVENT_KEY(func, field)                                      \
590 static u64 get_event_ ##func(struct kvm_event *event, int vcpu)         \
591 {                                                                       \
592         if (vcpu == -1)                                                 \
593                 return event->total.field;                              \
594                                                                         \
595         if (vcpu >= event->max_vcpu)                                    \
596                 return 0;                                               \
597                                                                         \
598         return event->vcpu[vcpu].field;                                 \
599 }
600
601 #define COMPARE_EVENT_KEY(func, field)                                  \
602 GET_EVENT_KEY(func, field)                                              \
603 static int compare_kvm_event_ ## func(struct kvm_event *one,            \
604                                         struct kvm_event *two, int vcpu)\
605 {                                                                       \
606         return get_event_ ##func(one, vcpu) >                           \
607                                 get_event_ ##func(two, vcpu);           \
608 }
609
610 GET_EVENT_KEY(time, time);
611 COMPARE_EVENT_KEY(count, stats.n);
612 COMPARE_EVENT_KEY(mean, stats.mean);
613 GET_EVENT_KEY(max, stats.max);
614 GET_EVENT_KEY(min, stats.min);
615
616 #define DEF_SORT_NAME_KEY(name, compare_key)                            \
617         { #name, compare_kvm_event_ ## compare_key }
618
619 static struct kvm_event_key keys[] = {
620         DEF_SORT_NAME_KEY(sample, count),
621         DEF_SORT_NAME_KEY(time, mean),
622         { NULL, NULL }
623 };
624
625 static bool select_key(struct perf_kvm_stat *kvm)
626 {
627         int i;
628
629         for (i = 0; keys[i].name; i++) {
630                 if (!strcmp(keys[i].name, kvm->sort_key)) {
631                         kvm->compare = keys[i].key;
632                         return true;
633                 }
634         }
635
636         pr_err("Unknown compare key:%s\n", kvm->sort_key);
637         return false;
638 }
639
640 static void insert_to_result(struct rb_root *result, struct kvm_event *event,
641                              key_cmp_fun bigger, int vcpu)
642 {
643         struct rb_node **rb = &result->rb_node;
644         struct rb_node *parent = NULL;
645         struct kvm_event *p;
646
647         while (*rb) {
648                 p = container_of(*rb, struct kvm_event, rb);
649                 parent = *rb;
650
651                 if (bigger(event, p, vcpu))
652                         rb = &(*rb)->rb_left;
653                 else
654                         rb = &(*rb)->rb_right;
655         }
656
657         rb_link_node(&event->rb, parent, rb);
658         rb_insert_color(&event->rb, result);
659 }
660
661 static void
662 update_total_count(struct perf_kvm_stat *kvm, struct kvm_event *event)
663 {
664         int vcpu = kvm->trace_vcpu;
665
666         kvm->total_count += get_event_count(event, vcpu);
667         kvm->total_time += get_event_time(event, vcpu);
668 }
669
670 static bool event_is_valid(struct kvm_event *event, int vcpu)
671 {
672         return !!get_event_count(event, vcpu);
673 }
674
675 static void sort_result(struct perf_kvm_stat *kvm)
676 {
677         unsigned int i;
678         int vcpu = kvm->trace_vcpu;
679         struct kvm_event *event;
680
681         for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
682                 list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry) {
683                         if (event_is_valid(event, vcpu)) {
684                                 update_total_count(kvm, event);
685                                 insert_to_result(&kvm->result, event,
686                                                  kvm->compare, vcpu);
687                         }
688                 }
689         }
690 }
691
692 /* returns left most element of result, and erase it */
693 static struct kvm_event *pop_from_result(struct rb_root *result)
694 {
695         struct rb_node *node = rb_first(result);
696
697         if (!node)
698                 return NULL;
699
700         rb_erase(node, result);
701         return container_of(node, struct kvm_event, rb);
702 }
703
704 static void print_vcpu_info(struct perf_kvm_stat *kvm)
705 {
706         int vcpu = kvm->trace_vcpu;
707
708         pr_info("Analyze events for ");
709
710         if (kvm->live) {
711                 if (kvm->opts.target.system_wide)
712                         pr_info("all VMs, ");
713                 else if (kvm->opts.target.pid)
714                         pr_info("pid(s) %s, ", kvm->opts.target.pid);
715                 else
716                         pr_info("dazed and confused on what is monitored, ");
717         }
718
719         if (vcpu == -1)
720                 pr_info("all VCPUs:\n\n");
721         else
722                 pr_info("VCPU %d:\n\n", vcpu);
723 }
724
725 static void show_timeofday(void)
726 {
727         char date[64];
728         struct timeval tv;
729         struct tm ltime;
730
731         gettimeofday(&tv, NULL);
732         if (localtime_r(&tv.tv_sec, &ltime)) {
733                 strftime(date, sizeof(date), "%H:%M:%S", &ltime);
734                 pr_info("%s.%06ld", date, tv.tv_usec);
735         } else
736                 pr_info("00:00:00.000000");
737
738         return;
739 }
740
741 static void print_result(struct perf_kvm_stat *kvm)
742 {
743         char decode[20];
744         struct kvm_event *event;
745         int vcpu = kvm->trace_vcpu;
746
747         if (kvm->live) {
748                 puts(CONSOLE_CLEAR);
749                 show_timeofday();
750         }
751
752         pr_info("\n\n");
753         print_vcpu_info(kvm);
754         pr_info("%20s ", kvm->events_ops->name);
755         pr_info("%10s ", "Samples");
756         pr_info("%9s ", "Samples%");
757
758         pr_info("%9s ", "Time%");
759         pr_info("%10s ", "Min Time");
760         pr_info("%10s ", "Max Time");
761         pr_info("%16s ", "Avg time");
762         pr_info("\n\n");
763
764         while ((event = pop_from_result(&kvm->result))) {
765                 u64 ecount, etime, max, min;
766
767                 ecount = get_event_count(event, vcpu);
768                 etime = get_event_time(event, vcpu);
769                 max = get_event_max(event, vcpu);
770                 min = get_event_min(event, vcpu);
771
772                 kvm->events_ops->decode_key(kvm, &event->key, decode);
773                 pr_info("%20s ", decode);
774                 pr_info("%10llu ", (unsigned long long)ecount);
775                 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100);
776                 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100);
777                 pr_info("%8" PRIu64 "us ", min / 1000);
778                 pr_info("%8" PRIu64 "us ", max / 1000);
779                 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
780                         kvm_event_rel_stddev(vcpu, event));
781                 pr_info("\n");
782         }
783
784         pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n",
785                 kvm->total_count, kvm->total_time / 1e3);
786
787         if (kvm->lost_events)
788                 pr_info("\nLost events: %" PRIu64 "\n\n", kvm->lost_events);
789 }
790
791 #ifdef HAVE_TIMERFD_SUPPORT
792 static int process_lost_event(struct perf_tool *tool,
793                               union perf_event *event __maybe_unused,
794                               struct perf_sample *sample __maybe_unused,
795                               struct machine *machine __maybe_unused)
796 {
797         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat, tool);
798
799         kvm->lost_events++;
800         return 0;
801 }
802 #endif
803
804 static bool skip_sample(struct perf_kvm_stat *kvm,
805                         struct perf_sample *sample)
806 {
807         if (kvm->pid_list && intlist__find(kvm->pid_list, sample->pid) == NULL)
808                 return true;
809
810         return false;
811 }
812
813 static int process_sample_event(struct perf_tool *tool,
814                                 union perf_event *event,
815                                 struct perf_sample *sample,
816                                 struct perf_evsel *evsel,
817                                 struct machine *machine)
818 {
819         struct thread *thread;
820         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat,
821                                                  tool);
822
823         if (skip_sample(kvm, sample))
824                 return 0;
825
826         thread = machine__findnew_thread(machine, sample->pid, sample->tid);
827         if (thread == NULL) {
828                 pr_debug("problem processing %d event, skipping it.\n",
829                         event->header.type);
830                 return -1;
831         }
832
833         if (!handle_kvm_event(kvm, thread, evsel, sample))
834                 return -1;
835
836         return 0;
837 }
838
839 static int cpu_isa_config(struct perf_kvm_stat *kvm)
840 {
841         char buf[64], *cpuid;
842         int err, isa;
843
844         if (kvm->live) {
845                 err = get_cpuid(buf, sizeof(buf));
846                 if (err != 0) {
847                         pr_err("Failed to look up CPU type (Intel or AMD)\n");
848                         return err;
849                 }
850                 cpuid = buf;
851         } else
852                 cpuid = kvm->session->header.env.cpuid;
853
854         if (strstr(cpuid, "Intel"))
855                 isa = 1;
856         else if (strstr(cpuid, "AMD"))
857                 isa = 0;
858         else {
859                 pr_err("CPU %s is not supported.\n", cpuid);
860                 return -ENOTSUP;
861         }
862
863         if (isa == 1) {
864                 kvm->exit_reasons = vmx_exit_reasons;
865                 kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
866                 kvm->exit_reasons_isa = "VMX";
867         }
868
869         return 0;
870 }
871
872 static bool verify_vcpu(int vcpu)
873 {
874         if (vcpu != -1 && vcpu < 0) {
875                 pr_err("Invalid vcpu:%d.\n", vcpu);
876                 return false;
877         }
878
879         return true;
880 }
881
882 #ifdef HAVE_TIMERFD_SUPPORT
883 /* keeping the max events to a modest level to keep
884  * the processing of samples per mmap smooth.
885  */
886 #define PERF_KVM__MAX_EVENTS_PER_MMAP  25
887
888 static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
889                                    u64 *mmap_time)
890 {
891         union perf_event *event;
892         struct perf_sample sample;
893         s64 n = 0;
894         int err;
895
896         *mmap_time = ULLONG_MAX;
897         while ((event = perf_evlist__mmap_read(kvm->evlist, idx)) != NULL) {
898                 err = perf_evlist__parse_sample(kvm->evlist, event, &sample);
899                 if (err) {
900                         perf_evlist__mmap_consume(kvm->evlist, idx);
901                         pr_err("Failed to parse sample\n");
902                         return -1;
903                 }
904
905                 err = perf_session_queue_event(kvm->session, event, &sample, 0);
906                 /*
907                  * FIXME: Here we can't consume the event, as perf_session_queue_event will
908                  *        point to it, and it'll get possibly overwritten by the kernel.
909                  */
910                 perf_evlist__mmap_consume(kvm->evlist, idx);
911
912                 if (err) {
913                         pr_err("Failed to enqueue sample: %d\n", err);
914                         return -1;
915                 }
916
917                 /* save time stamp of our first sample for this mmap */
918                 if (n == 0)
919                         *mmap_time = sample.time;
920
921                 /* limit events per mmap handled all at once */
922                 n++;
923                 if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
924                         break;
925         }
926
927         return n;
928 }
929
930 static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
931 {
932         int i, err, throttled = 0;
933         s64 n, ntotal = 0;
934         u64 flush_time = ULLONG_MAX, mmap_time;
935
936         for (i = 0; i < kvm->evlist->nr_mmaps; i++) {
937                 n = perf_kvm__mmap_read_idx(kvm, i, &mmap_time);
938                 if (n < 0)
939                         return -1;
940
941                 /* flush time is going to be the minimum of all the individual
942                  * mmap times. Essentially, we flush all the samples queued up
943                  * from the last pass under our minimal start time -- that leaves
944                  * a very small race for samples to come in with a lower timestamp.
945                  * The ioctl to return the perf_clock timestamp should close the
946                  * race entirely.
947                  */
948                 if (mmap_time < flush_time)
949                         flush_time = mmap_time;
950
951                 ntotal += n;
952                 if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
953                         throttled = 1;
954         }
955
956         /* flush queue after each round in which we processed events */
957         if (ntotal) {
958                 kvm->session->ordered_samples.next_flush = flush_time;
959                 err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
960                 if (err) {
961                         if (kvm->lost_events)
962                                 pr_info("\nLost events: %" PRIu64 "\n\n",
963                                         kvm->lost_events);
964                         return err;
965                 }
966         }
967
968         return throttled;
969 }
970
971 static volatile int done;
972
973 static void sig_handler(int sig __maybe_unused)
974 {
975         done = 1;
976 }
977
978 static int perf_kvm__timerfd_create(struct perf_kvm_stat *kvm)
979 {
980         struct itimerspec new_value;
981         int rc = -1;
982
983         kvm->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
984         if (kvm->timerfd < 0) {
985                 pr_err("timerfd_create failed\n");
986                 goto out;
987         }
988
989         new_value.it_value.tv_sec = kvm->display_time;
990         new_value.it_value.tv_nsec = 0;
991         new_value.it_interval.tv_sec = kvm->display_time;
992         new_value.it_interval.tv_nsec = 0;
993
994         if (timerfd_settime(kvm->timerfd, 0, &new_value, NULL) != 0) {
995                 pr_err("timerfd_settime failed: %d\n", errno);
996                 close(kvm->timerfd);
997                 goto out;
998         }
999
1000         rc = 0;
1001 out:
1002         return rc;
1003 }
1004
1005 static int perf_kvm__handle_timerfd(struct perf_kvm_stat *kvm)
1006 {
1007         uint64_t c;
1008         int rc;
1009
1010         rc = read(kvm->timerfd, &c, sizeof(uint64_t));
1011         if (rc < 0) {
1012                 if (errno == EAGAIN)
1013                         return 0;
1014
1015                 pr_err("Failed to read timer fd: %d\n", errno);
1016                 return -1;
1017         }
1018
1019         if (rc != sizeof(uint64_t)) {
1020                 pr_err("Error reading timer fd - invalid size returned\n");
1021                 return -1;
1022         }
1023
1024         if (c != 1)
1025                 pr_debug("Missed timer beats: %" PRIu64 "\n", c-1);
1026
1027         /* update display */
1028         sort_result(kvm);
1029         print_result(kvm);
1030
1031         /* reset counts */
1032         clear_events_cache_stats(kvm->kvm_events_cache);
1033         kvm->total_count = 0;
1034         kvm->total_time = 0;
1035         kvm->lost_events = 0;
1036
1037         return 0;
1038 }
1039
1040 static int fd_set_nonblock(int fd)
1041 {
1042         long arg = 0;
1043
1044         arg = fcntl(fd, F_GETFL);
1045         if (arg < 0) {
1046                 pr_err("Failed to get current flags for fd %d\n", fd);
1047                 return -1;
1048         }
1049
1050         if (fcntl(fd, F_SETFL, arg | O_NONBLOCK) < 0) {
1051                 pr_err("Failed to set non-block option on fd %d\n", fd);
1052                 return -1;
1053         }
1054
1055         return 0;
1056 }
1057
1058 static
1059 int perf_kvm__handle_stdin(struct termios *tc_now, struct termios *tc_save)
1060 {
1061         int c;
1062
1063         tcsetattr(0, TCSANOW, tc_now);
1064         c = getc(stdin);
1065         tcsetattr(0, TCSAFLUSH, tc_save);
1066
1067         if (c == 'q')
1068                 return 1;
1069
1070         return 0;
1071 }
1072
1073 static int kvm_events_live_report(struct perf_kvm_stat *kvm)
1074 {
1075         struct pollfd *pollfds = NULL;
1076         int nr_fds, nr_stdin, ret, err = -EINVAL;
1077         struct termios tc, save;
1078
1079         /* live flag must be set first */
1080         kvm->live = true;
1081
1082         ret = cpu_isa_config(kvm);
1083         if (ret < 0)
1084                 return ret;
1085
1086         if (!verify_vcpu(kvm->trace_vcpu) ||
1087             !select_key(kvm) ||
1088             !register_kvm_events_ops(kvm)) {
1089                 goto out;
1090         }
1091
1092         init_kvm_event_record(kvm);
1093
1094         tcgetattr(0, &save);
1095         tc = save;
1096         tc.c_lflag &= ~(ICANON | ECHO);
1097         tc.c_cc[VMIN] = 0;
1098         tc.c_cc[VTIME] = 0;
1099
1100         signal(SIGINT, sig_handler);
1101         signal(SIGTERM, sig_handler);
1102
1103         /* copy pollfds -- need to add timerfd and stdin */
1104         nr_fds = kvm->evlist->nr_fds;
1105         pollfds = zalloc(sizeof(struct pollfd) * (nr_fds + 2));
1106         if (!pollfds) {
1107                 err = -ENOMEM;
1108                 goto out;
1109         }
1110         memcpy(pollfds, kvm->evlist->pollfd,
1111                 sizeof(struct pollfd) * kvm->evlist->nr_fds);
1112
1113         /* add timer fd */
1114         if (perf_kvm__timerfd_create(kvm) < 0) {
1115                 err = -1;
1116                 goto out;
1117         }
1118
1119         pollfds[nr_fds].fd = kvm->timerfd;
1120         pollfds[nr_fds].events = POLLIN;
1121         nr_fds++;
1122
1123         pollfds[nr_fds].fd = fileno(stdin);
1124         pollfds[nr_fds].events = POLLIN;
1125         nr_stdin = nr_fds;
1126         nr_fds++;
1127         if (fd_set_nonblock(fileno(stdin)) != 0)
1128                 goto out;
1129
1130         /* everything is good - enable the events and process */
1131         perf_evlist__enable(kvm->evlist);
1132
1133         while (!done) {
1134                 int rc;
1135
1136                 rc = perf_kvm__mmap_read(kvm);
1137                 if (rc < 0)
1138                         break;
1139
1140                 err = perf_kvm__handle_timerfd(kvm);
1141                 if (err)
1142                         goto out;
1143
1144                 if (pollfds[nr_stdin].revents & POLLIN)
1145                         done = perf_kvm__handle_stdin(&tc, &save);
1146
1147                 if (!rc && !done)
1148                         err = poll(pollfds, nr_fds, 100);
1149         }
1150
1151         perf_evlist__disable(kvm->evlist);
1152
1153         if (err == 0) {
1154                 sort_result(kvm);
1155                 print_result(kvm);
1156         }
1157
1158 out:
1159         if (kvm->timerfd >= 0)
1160                 close(kvm->timerfd);
1161
1162         free(pollfds);
1163         return err;
1164 }
1165
1166 static int kvm_live_open_events(struct perf_kvm_stat *kvm)
1167 {
1168         int err, rc = -1;
1169         struct perf_evsel *pos;
1170         struct perf_evlist *evlist = kvm->evlist;
1171
1172         perf_evlist__config(evlist, &kvm->opts);
1173
1174         /*
1175          * Note: exclude_{guest,host} do not apply here.
1176          *       This command processes KVM tracepoints from host only
1177          */
1178         evlist__for_each(evlist, pos) {
1179                 struct perf_event_attr *attr = &pos->attr;
1180
1181                 /* make sure these *are* set */
1182                 perf_evsel__set_sample_bit(pos, TID);
1183                 perf_evsel__set_sample_bit(pos, TIME);
1184                 perf_evsel__set_sample_bit(pos, CPU);
1185                 perf_evsel__set_sample_bit(pos, RAW);
1186                 /* make sure these are *not*; want as small a sample as possible */
1187                 perf_evsel__reset_sample_bit(pos, PERIOD);
1188                 perf_evsel__reset_sample_bit(pos, IP);
1189                 perf_evsel__reset_sample_bit(pos, CALLCHAIN);
1190                 perf_evsel__reset_sample_bit(pos, ADDR);
1191                 perf_evsel__reset_sample_bit(pos, READ);
1192                 attr->mmap = 0;
1193                 attr->comm = 0;
1194                 attr->task = 0;
1195
1196                 attr->sample_period = 1;
1197
1198                 attr->watermark = 0;
1199                 attr->wakeup_events = 1000;
1200
1201                 /* will enable all once we are ready */
1202                 attr->disabled = 1;
1203         }
1204
1205         err = perf_evlist__open(evlist);
1206         if (err < 0) {
1207                 printf("Couldn't create the events: %s\n", strerror(errno));
1208                 goto out;
1209         }
1210
1211         if (perf_evlist__mmap(evlist, kvm->opts.mmap_pages, false) < 0) {
1212                 ui__error("Failed to mmap the events: %s\n", strerror(errno));
1213                 perf_evlist__close(evlist);
1214                 goto out;
1215         }
1216
1217         rc = 0;
1218
1219 out:
1220         return rc;
1221 }
1222 #endif
1223
1224 static int read_events(struct perf_kvm_stat *kvm)
1225 {
1226         int ret;
1227
1228         struct perf_tool eops = {
1229                 .sample                 = process_sample_event,
1230                 .comm                   = perf_event__process_comm,
1231                 .ordered_samples        = true,
1232         };
1233         struct perf_data_file file = {
1234                 .path = kvm->file_name,
1235                 .mode = PERF_DATA_MODE_READ,
1236         };
1237
1238         kvm->tool = eops;
1239         kvm->session = perf_session__new(&file, false, &kvm->tool);
1240         if (!kvm->session) {
1241                 pr_err("Initializing perf session failed\n");
1242                 return -EINVAL;
1243         }
1244
1245         if (!perf_session__has_traces(kvm->session, "kvm record"))
1246                 return -EINVAL;
1247
1248         /*
1249          * Do not use 'isa' recorded in kvm_exit tracepoint since it is not
1250          * traced in the old kernel.
1251          */
1252         ret = cpu_isa_config(kvm);
1253         if (ret < 0)
1254                 return ret;
1255
1256         return perf_session__process_events(kvm->session, &kvm->tool);
1257 }
1258
1259 static int parse_target_str(struct perf_kvm_stat *kvm)
1260 {
1261         if (kvm->pid_str) {
1262                 kvm->pid_list = intlist__new(kvm->pid_str);
1263                 if (kvm->pid_list == NULL) {
1264                         pr_err("Error parsing process id string\n");
1265                         return -EINVAL;
1266                 }
1267         }
1268
1269         return 0;
1270 }
1271
1272 static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm)
1273 {
1274         int ret = -EINVAL;
1275         int vcpu = kvm->trace_vcpu;
1276
1277         if (parse_target_str(kvm) != 0)
1278                 goto exit;
1279
1280         if (!verify_vcpu(vcpu))
1281                 goto exit;
1282
1283         if (!select_key(kvm))
1284                 goto exit;
1285
1286         if (!register_kvm_events_ops(kvm))
1287                 goto exit;
1288
1289         init_kvm_event_record(kvm);
1290         setup_pager();
1291
1292         ret = read_events(kvm);
1293         if (ret)
1294                 goto exit;
1295
1296         sort_result(kvm);
1297         print_result(kvm);
1298
1299 exit:
1300         return ret;
1301 }
1302
1303 static const char * const kvm_events_tp[] = {
1304         "kvm:kvm_entry",
1305         "kvm:kvm_exit",
1306         "kvm:kvm_mmio",
1307         "kvm:kvm_pio",
1308 };
1309
1310 #define STRDUP_FAIL_EXIT(s)             \
1311         ({      char *_p;               \
1312         _p = strdup(s);         \
1313                 if (!_p)                \
1314                         return -ENOMEM; \
1315                 _p;                     \
1316         })
1317
1318 static int
1319 kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
1320 {
1321         unsigned int rec_argc, i, j;
1322         const char **rec_argv;
1323         const char * const record_args[] = {
1324                 "record",
1325                 "-R",
1326                 "-m", "1024",
1327                 "-c", "1",
1328         };
1329
1330         rec_argc = ARRAY_SIZE(record_args) + argc + 2 +
1331                    2 * ARRAY_SIZE(kvm_events_tp);
1332         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1333
1334         if (rec_argv == NULL)
1335                 return -ENOMEM;
1336
1337         for (i = 0; i < ARRAY_SIZE(record_args); i++)
1338                 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]);
1339
1340         for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
1341                 rec_argv[i++] = "-e";
1342                 rec_argv[i++] = STRDUP_FAIL_EXIT(kvm_events_tp[j]);
1343         }
1344
1345         rec_argv[i++] = STRDUP_FAIL_EXIT("-o");
1346         rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name);
1347
1348         for (j = 1; j < (unsigned int)argc; j++, i++)
1349                 rec_argv[i] = argv[j];
1350
1351         return cmd_record(i, rec_argv, NULL);
1352 }
1353
1354 static int
1355 kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
1356 {
1357         const struct option kvm_events_report_options[] = {
1358                 OPT_STRING(0, "event", &kvm->report_event, "report event",
1359                             "event for reporting: vmexit, mmio, ioport"),
1360                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
1361                             "vcpu id to report"),
1362                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
1363                             "key for sorting: sample(sort by samples number)"
1364                             " time (sort by avg time)"),
1365                 OPT_STRING('p', "pid", &kvm->pid_str, "pid",
1366                            "analyze events only for given process id(s)"),
1367                 OPT_END()
1368         };
1369
1370         const char * const kvm_events_report_usage[] = {
1371                 "perf kvm stat report [<options>]",
1372                 NULL
1373         };
1374
1375         symbol__init();
1376
1377         if (argc) {
1378                 argc = parse_options(argc, argv,
1379                                      kvm_events_report_options,
1380                                      kvm_events_report_usage, 0);
1381                 if (argc)
1382                         usage_with_options(kvm_events_report_usage,
1383                                            kvm_events_report_options);
1384         }
1385
1386         return kvm_events_report_vcpu(kvm);
1387 }
1388
1389 #ifdef HAVE_TIMERFD_SUPPORT
1390 static struct perf_evlist *kvm_live_event_list(void)
1391 {
1392         struct perf_evlist *evlist;
1393         char *tp, *name, *sys;
1394         unsigned int j;
1395         int err = -1;
1396
1397         evlist = perf_evlist__new();
1398         if (evlist == NULL)
1399                 return NULL;
1400
1401         for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
1402
1403                 tp = strdup(kvm_events_tp[j]);
1404                 if (tp == NULL)
1405                         goto out;
1406
1407                 /* split tracepoint into subsystem and name */
1408                 sys = tp;
1409                 name = strchr(tp, ':');
1410                 if (name == NULL) {
1411                         pr_err("Error parsing %s tracepoint: subsystem delimiter not found\n",
1412                                 kvm_events_tp[j]);
1413                         free(tp);
1414                         goto out;
1415                 }
1416                 *name = '\0';
1417                 name++;
1418
1419                 if (perf_evlist__add_newtp(evlist, sys, name, NULL)) {
1420                         pr_err("Failed to add %s tracepoint to the list\n", kvm_events_tp[j]);
1421                         free(tp);
1422                         goto out;
1423                 }
1424
1425                 free(tp);
1426         }
1427
1428         err = 0;
1429
1430 out:
1431         if (err) {
1432                 perf_evlist__delete(evlist);
1433                 evlist = NULL;
1434         }
1435
1436         return evlist;
1437 }
1438
1439 static int kvm_events_live(struct perf_kvm_stat *kvm,
1440                            int argc, const char **argv)
1441 {
1442         char errbuf[BUFSIZ];
1443         int err;
1444
1445         const struct option live_options[] = {
1446                 OPT_STRING('p', "pid", &kvm->opts.target.pid, "pid",
1447                         "record events on existing process id"),
1448                 OPT_CALLBACK('m', "mmap-pages", &kvm->opts.mmap_pages, "pages",
1449                         "number of mmap data pages",
1450                         perf_evlist__parse_mmap_pages),
1451                 OPT_INCR('v', "verbose", &verbose,
1452                         "be more verbose (show counter open errors, etc)"),
1453                 OPT_BOOLEAN('a', "all-cpus", &kvm->opts.target.system_wide,
1454                         "system-wide collection from all CPUs"),
1455                 OPT_UINTEGER('d', "display", &kvm->display_time,
1456                         "time in seconds between display updates"),
1457                 OPT_STRING(0, "event", &kvm->report_event, "report event",
1458                         "event for reporting: vmexit, mmio, ioport"),
1459                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
1460                         "vcpu id to report"),
1461                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
1462                         "key for sorting: sample(sort by samples number)"
1463                         " time (sort by avg time)"),
1464                 OPT_U64(0, "duration", &kvm->duration,
1465                     "show events other than HALT that take longer than duration usecs"),
1466                 OPT_END()
1467         };
1468         const char * const live_usage[] = {
1469                 "perf kvm stat live [<options>]",
1470                 NULL
1471         };
1472         struct perf_data_file file = {
1473                 .mode = PERF_DATA_MODE_WRITE,
1474         };
1475
1476
1477         /* event handling */
1478         kvm->tool.sample = process_sample_event;
1479         kvm->tool.comm   = perf_event__process_comm;
1480         kvm->tool.exit   = perf_event__process_exit;
1481         kvm->tool.fork   = perf_event__process_fork;
1482         kvm->tool.lost   = process_lost_event;
1483         kvm->tool.ordered_samples = true;
1484         perf_tool__fill_defaults(&kvm->tool);
1485
1486         /* set defaults */
1487         kvm->display_time = 1;
1488         kvm->opts.user_interval = 1;
1489         kvm->opts.mmap_pages = 512;
1490         kvm->opts.target.uses_mmap = false;
1491         kvm->opts.target.uid_str = NULL;
1492         kvm->opts.target.uid = UINT_MAX;
1493
1494         symbol__init();
1495         disable_buildid_cache();
1496
1497         use_browser = 0;
1498         setup_browser(false);
1499
1500         if (argc) {
1501                 argc = parse_options(argc, argv, live_options,
1502                                      live_usage, 0);
1503                 if (argc)
1504                         usage_with_options(live_usage, live_options);
1505         }
1506
1507         kvm->duration *= NSEC_PER_USEC;   /* convert usec to nsec */
1508
1509         /*
1510          * target related setups
1511          */
1512         err = target__validate(&kvm->opts.target);
1513         if (err) {
1514                 target__strerror(&kvm->opts.target, err, errbuf, BUFSIZ);
1515                 ui__warning("%s", errbuf);
1516         }
1517
1518         if (target__none(&kvm->opts.target))
1519                 kvm->opts.target.system_wide = true;
1520
1521
1522         /*
1523          * generate the event list
1524          */
1525         kvm->evlist = kvm_live_event_list();
1526         if (kvm->evlist == NULL) {
1527                 err = -1;
1528                 goto out;
1529         }
1530
1531         symbol_conf.nr_events = kvm->evlist->nr_entries;
1532
1533         if (perf_evlist__create_maps(kvm->evlist, &kvm->opts.target) < 0)
1534                 usage_with_options(live_usage, live_options);
1535
1536         /*
1537          * perf session
1538          */
1539         kvm->session = perf_session__new(&file, false, &kvm->tool);
1540         if (kvm->session == NULL) {
1541                 err = -ENOMEM;
1542                 goto out;
1543         }
1544         kvm->session->evlist = kvm->evlist;
1545         perf_session__set_id_hdr_size(kvm->session);
1546         machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target,
1547                                     kvm->evlist->threads, false);
1548         err = kvm_live_open_events(kvm);
1549         if (err)
1550                 goto out;
1551
1552         err = kvm_events_live_report(kvm);
1553
1554 out:
1555         exit_browser(0);
1556
1557         if (kvm->session)
1558                 perf_session__delete(kvm->session);
1559         kvm->session = NULL;
1560         if (kvm->evlist)
1561                 perf_evlist__delete(kvm->evlist);
1562
1563         return err;
1564 }
1565 #endif
1566
1567 static void print_kvm_stat_usage(void)
1568 {
1569         printf("Usage: perf kvm stat <command>\n\n");
1570
1571         printf("# Available commands:\n");
1572         printf("\trecord: record kvm events\n");
1573         printf("\treport: report statistical data of kvm events\n");
1574         printf("\tlive:   live reporting of statistical data of kvm events\n");
1575
1576         printf("\nOtherwise, it is the alias of 'perf stat':\n");
1577 }
1578
1579 static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
1580 {
1581         struct perf_kvm_stat kvm = {
1582                 .file_name = file_name,
1583
1584                 .trace_vcpu     = -1,
1585                 .report_event   = "vmexit",
1586                 .sort_key       = "sample",
1587
1588                 .exit_reasons = svm_exit_reasons,
1589                 .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons),
1590                 .exit_reasons_isa = "SVM",
1591         };
1592
1593         if (argc == 1) {
1594                 print_kvm_stat_usage();
1595                 goto perf_stat;
1596         }
1597
1598         if (!strncmp(argv[1], "rec", 3))
1599                 return kvm_events_record(&kvm, argc - 1, argv + 1);
1600
1601         if (!strncmp(argv[1], "rep", 3))
1602                 return kvm_events_report(&kvm, argc - 1 , argv + 1);
1603
1604 #ifdef HAVE_TIMERFD_SUPPORT
1605         if (!strncmp(argv[1], "live", 4))
1606                 return kvm_events_live(&kvm, argc - 1 , argv + 1);
1607 #endif
1608
1609 perf_stat:
1610         return cmd_stat(argc, argv, NULL);
1611 }
1612 #endif
1613
1614 static int __cmd_record(const char *file_name, int argc, const char **argv)
1615 {
1616         int rec_argc, i = 0, j;
1617         const char **rec_argv;
1618
1619         rec_argc = argc + 2;
1620         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1621         rec_argv[i++] = strdup("record");
1622         rec_argv[i++] = strdup("-o");
1623         rec_argv[i++] = strdup(file_name);
1624         for (j = 1; j < argc; j++, i++)
1625                 rec_argv[i] = argv[j];
1626
1627         BUG_ON(i != rec_argc);
1628
1629         return cmd_record(i, rec_argv, NULL);
1630 }
1631
1632 static int __cmd_report(const char *file_name, int argc, const char **argv)
1633 {
1634         int rec_argc, i = 0, j;
1635         const char **rec_argv;
1636
1637         rec_argc = argc + 2;
1638         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1639         rec_argv[i++] = strdup("report");
1640         rec_argv[i++] = strdup("-i");
1641         rec_argv[i++] = strdup(file_name);
1642         for (j = 1; j < argc; j++, i++)
1643                 rec_argv[i] = argv[j];
1644
1645         BUG_ON(i != rec_argc);
1646
1647         return cmd_report(i, rec_argv, NULL);
1648 }
1649
1650 static int
1651 __cmd_buildid_list(const char *file_name, int argc, const char **argv)
1652 {
1653         int rec_argc, i = 0, j;
1654         const char **rec_argv;
1655
1656         rec_argc = argc + 2;
1657         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1658         rec_argv[i++] = strdup("buildid-list");
1659         rec_argv[i++] = strdup("-i");
1660         rec_argv[i++] = strdup(file_name);
1661         for (j = 1; j < argc; j++, i++)
1662                 rec_argv[i] = argv[j];
1663
1664         BUG_ON(i != rec_argc);
1665
1666         return cmd_buildid_list(i, rec_argv, NULL);
1667 }
1668
1669 int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
1670 {
1671         const char *file_name = NULL;
1672         const struct option kvm_options[] = {
1673                 OPT_STRING('i', "input", &file_name, "file",
1674                            "Input file name"),
1675                 OPT_STRING('o', "output", &file_name, "file",
1676                            "Output file name"),
1677                 OPT_BOOLEAN(0, "guest", &perf_guest,
1678                             "Collect guest os data"),
1679                 OPT_BOOLEAN(0, "host", &perf_host,
1680                             "Collect host os data"),
1681                 OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
1682                            "guest mount directory under which every guest os"
1683                            " instance has a subdir"),
1684                 OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
1685                            "file", "file saving guest os vmlinux"),
1686                 OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
1687                            "file", "file saving guest os /proc/kallsyms"),
1688                 OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
1689                            "file", "file saving guest os /proc/modules"),
1690                 OPT_INCR('v', "verbose", &verbose,
1691                             "be more verbose (show counter open errors, etc)"),
1692                 OPT_END()
1693         };
1694
1695         const char *const kvm_subcommands[] = { "top", "record", "report", "diff",
1696                                                 "buildid-list", "stat", NULL };
1697         const char *kvm_usage[] = { NULL, NULL };
1698
1699         perf_host  = 0;
1700         perf_guest = 1;
1701
1702         argc = parse_options_subcommand(argc, argv, kvm_options, kvm_subcommands, kvm_usage,
1703                                         PARSE_OPT_STOP_AT_NON_OPTION);
1704         if (!argc)
1705                 usage_with_options(kvm_usage, kvm_options);
1706
1707         if (!perf_host)
1708                 perf_guest = 1;
1709
1710         if (!file_name) {
1711                 file_name = get_filename_for_perf_kvm();
1712
1713                 if (!file_name) {
1714                         pr_err("Failed to allocate memory for filename\n");
1715                         return -ENOMEM;
1716                 }
1717         }
1718
1719         if (!strncmp(argv[0], "rec", 3))
1720                 return __cmd_record(file_name, argc, argv);
1721         else if (!strncmp(argv[0], "rep", 3))
1722                 return __cmd_report(file_name, argc, argv);
1723         else if (!strncmp(argv[0], "diff", 4))
1724                 return cmd_diff(argc, argv, NULL);
1725         else if (!strncmp(argv[0], "top", 3))
1726                 return cmd_top(argc, argv, NULL);
1727         else if (!strncmp(argv[0], "buildid-list", 12))
1728                 return __cmd_buildid_list(file_name, argc, argv);
1729 #if defined(__i386__) || defined(__x86_64__)
1730         else if (!strncmp(argv[0], "stat", 4))
1731                 return kvm_cmd_stat(file_name, argc, argv);
1732 #endif
1733         else
1734                 usage_with_options(kvm_usage, kvm_options);
1735
1736         return 0;
1737 }