4 #include "util/evsel.h"
5 #include "util/evlist.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"
20 #include "util/data.h"
22 #include <sys/prctl.h>
23 #ifdef HAVE_TIMERFD_SUPPORT
24 #include <sys/timerfd.h>
28 #include <semaphore.h>
32 #ifdef HAVE_KVM_STAT_SUPPORT
33 #include <asm/kvm_perf.h>
34 #include "util/kvm-stat.h"
36 void exit_event_get_key(struct perf_evsel
*evsel
,
37 struct perf_sample
*sample
,
38 struct event_key
*key
)
41 key
->key
= perf_evsel__intval(evsel
, sample
, KVM_EXIT_REASON
);
44 bool kvm_exit_event(struct perf_evsel
*evsel
)
46 return !strcmp(evsel
->name
, KVM_EXIT_TRACE
);
49 bool exit_event_begin(struct perf_evsel
*evsel
,
50 struct perf_sample
*sample
, struct event_key
*key
)
52 if (kvm_exit_event(evsel
)) {
53 exit_event_get_key(evsel
, sample
, key
);
60 bool kvm_entry_event(struct perf_evsel
*evsel
)
62 return !strcmp(evsel
->name
, KVM_ENTRY_TRACE
);
65 bool exit_event_end(struct perf_evsel
*evsel
,
66 struct perf_sample
*sample __maybe_unused
,
67 struct event_key
*key __maybe_unused
)
69 return kvm_entry_event(evsel
);
72 static const char *get_exit_reason(struct perf_kvm_stat
*kvm
,
73 struct exit_reasons_table
*tbl
,
76 while (tbl
->reason
!= NULL
) {
77 if (tbl
->exit_code
== exit_code
)
82 pr_err("unknown kvm exit code:%lld on %s\n",
83 (unsigned long long)exit_code
, kvm
->exit_reasons_isa
);
87 void exit_event_decode_key(struct perf_kvm_stat
*kvm
,
88 struct event_key
*key
,
91 const char *exit_reason
= get_exit_reason(kvm
, key
->exit_reasons
,
94 scnprintf(decode
, DECODE_STR_LEN
, "%s", exit_reason
);
97 static bool register_kvm_events_ops(struct perf_kvm_stat
*kvm
)
99 struct kvm_reg_events_ops
*events_ops
= kvm_reg_events_ops
;
101 for (events_ops
= kvm_reg_events_ops
; events_ops
->name
; events_ops
++) {
102 if (!strcmp(events_ops
->name
, kvm
->report_event
)) {
103 kvm
->events_ops
= events_ops
->ops
;
111 struct vcpu_event_record
{
114 struct kvm_event
*last_event
;
118 static void init_kvm_event_record(struct perf_kvm_stat
*kvm
)
122 for (i
= 0; i
< EVENTS_CACHE_SIZE
; i
++)
123 INIT_LIST_HEAD(&kvm
->kvm_events_cache
[i
]);
126 #ifdef HAVE_TIMERFD_SUPPORT
127 static void clear_events_cache_stats(struct list_head
*kvm_events_cache
)
129 struct list_head
*head
;
130 struct kvm_event
*event
;
134 for (i
= 0; i
< EVENTS_CACHE_SIZE
; i
++) {
135 head
= &kvm_events_cache
[i
];
136 list_for_each_entry(event
, head
, hash_entry
) {
137 /* reset stats for event */
138 event
->total
.time
= 0;
139 init_stats(&event
->total
.stats
);
141 for (j
= 0; j
< event
->max_vcpu
; ++j
) {
142 event
->vcpu
[j
].time
= 0;
143 init_stats(&event
->vcpu
[j
].stats
);
150 static int kvm_events_hash_fn(u64 key
)
152 return key
& (EVENTS_CACHE_SIZE
- 1);
155 static bool kvm_event_expand(struct kvm_event
*event
, int vcpu_id
)
157 int old_max_vcpu
= event
->max_vcpu
;
160 if (vcpu_id
< event
->max_vcpu
)
163 while (event
->max_vcpu
<= vcpu_id
)
164 event
->max_vcpu
+= DEFAULT_VCPU_NUM
;
167 event
->vcpu
= realloc(event
->vcpu
,
168 event
->max_vcpu
* sizeof(*event
->vcpu
));
171 pr_err("Not enough memory\n");
175 memset(event
->vcpu
+ old_max_vcpu
, 0,
176 (event
->max_vcpu
- old_max_vcpu
) * sizeof(*event
->vcpu
));
180 static struct kvm_event
*kvm_alloc_init_event(struct event_key
*key
)
182 struct kvm_event
*event
;
184 event
= zalloc(sizeof(*event
));
186 pr_err("Not enough memory\n");
191 init_stats(&event
->total
.stats
);
195 static struct kvm_event
*find_create_kvm_event(struct perf_kvm_stat
*kvm
,
196 struct event_key
*key
)
198 struct kvm_event
*event
;
199 struct list_head
*head
;
201 BUG_ON(key
->key
== INVALID_KEY
);
203 head
= &kvm
->kvm_events_cache
[kvm_events_hash_fn(key
->key
)];
204 list_for_each_entry(event
, head
, hash_entry
) {
205 if (event
->key
.key
== key
->key
&& event
->key
.info
== key
->info
)
209 event
= kvm_alloc_init_event(key
);
213 list_add(&event
->hash_entry
, head
);
217 static bool handle_begin_event(struct perf_kvm_stat
*kvm
,
218 struct vcpu_event_record
*vcpu_record
,
219 struct event_key
*key
, u64 timestamp
)
221 struct kvm_event
*event
= NULL
;
223 if (key
->key
!= INVALID_KEY
)
224 event
= find_create_kvm_event(kvm
, key
);
226 vcpu_record
->last_event
= event
;
227 vcpu_record
->start_time
= timestamp
;
232 kvm_update_event_stats(struct kvm_event_stats
*kvm_stats
, u64 time_diff
)
234 kvm_stats
->time
+= time_diff
;
235 update_stats(&kvm_stats
->stats
, time_diff
);
238 static double kvm_event_rel_stddev(int vcpu_id
, struct kvm_event
*event
)
240 struct kvm_event_stats
*kvm_stats
= &event
->total
;
243 kvm_stats
= &event
->vcpu
[vcpu_id
];
245 return rel_stddev_stats(stddev_stats(&kvm_stats
->stats
),
246 avg_stats(&kvm_stats
->stats
));
249 static bool update_kvm_event(struct kvm_event
*event
, int vcpu_id
,
253 kvm_update_event_stats(&event
->total
, time_diff
);
257 if (!kvm_event_expand(event
, vcpu_id
))
260 kvm_update_event_stats(&event
->vcpu
[vcpu_id
], time_diff
);
264 static bool is_child_event(struct perf_kvm_stat
*kvm
,
265 struct perf_evsel
*evsel
,
266 struct perf_sample
*sample
,
267 struct event_key
*key
)
269 struct child_event_ops
*child_ops
;
271 child_ops
= kvm
->events_ops
->child_ops
;
276 for (; child_ops
->name
; child_ops
++) {
277 if (!strcmp(evsel
->name
, child_ops
->name
)) {
278 child_ops
->get_key(evsel
, sample
, key
);
286 static bool handle_child_event(struct perf_kvm_stat
*kvm
,
287 struct vcpu_event_record
*vcpu_record
,
288 struct event_key
*key
,
289 struct perf_sample
*sample __maybe_unused
)
291 struct kvm_event
*event
= NULL
;
293 if (key
->key
!= INVALID_KEY
)
294 event
= find_create_kvm_event(kvm
, key
);
296 vcpu_record
->last_event
= event
;
301 static bool skip_event(const char *event
)
303 const char * const *skip_events
;
305 for (skip_events
= kvm_skip_events
; *skip_events
; skip_events
++)
306 if (!strcmp(event
, *skip_events
))
312 static bool handle_end_event(struct perf_kvm_stat
*kvm
,
313 struct vcpu_event_record
*vcpu_record
,
314 struct event_key
*key
,
315 struct perf_sample
*sample
)
317 struct kvm_event
*event
;
318 u64 time_begin
, time_diff
;
321 if (kvm
->trace_vcpu
== -1)
324 vcpu
= vcpu_record
->vcpu_id
;
326 event
= vcpu_record
->last_event
;
327 time_begin
= vcpu_record
->start_time
;
329 /* The begin event is not caught. */
334 * In some case, the 'begin event' only records the start timestamp,
335 * the actual event is recognized in the 'end event' (e.g. mmio-event).
338 /* Both begin and end events did not get the key. */
339 if (!event
&& key
->key
== INVALID_KEY
)
343 event
= find_create_kvm_event(kvm
, key
);
348 vcpu_record
->last_event
= NULL
;
349 vcpu_record
->start_time
= 0;
351 /* seems to happen once in a while during live mode */
352 if (sample
->time
< time_begin
) {
353 pr_debug("End time before begin time; skipping event.\n");
357 time_diff
= sample
->time
- time_begin
;
359 if (kvm
->duration
&& time_diff
> kvm
->duration
) {
360 char decode
[DECODE_STR_LEN
];
362 kvm
->events_ops
->decode_key(kvm
, &event
->key
, decode
);
363 if (!skip_event(decode
)) {
364 pr_info("%" PRIu64
" VM %d, vcpu %d: %s event took %" PRIu64
"usec\n",
365 sample
->time
, sample
->pid
, vcpu_record
->vcpu_id
,
366 decode
, time_diff
/1000);
370 return update_kvm_event(event
, vcpu
, time_diff
);
374 struct vcpu_event_record
*per_vcpu_record(struct thread
*thread
,
375 struct perf_evsel
*evsel
,
376 struct perf_sample
*sample
)
378 /* Only kvm_entry records vcpu id. */
379 if (!thread
->priv
&& kvm_entry_event(evsel
)) {
380 struct vcpu_event_record
*vcpu_record
;
382 vcpu_record
= zalloc(sizeof(*vcpu_record
));
384 pr_err("%s: Not enough memory\n", __func__
);
388 vcpu_record
->vcpu_id
= perf_evsel__intval(evsel
, sample
, VCPU_ID
);
389 thread
->priv
= vcpu_record
;
395 static bool handle_kvm_event(struct perf_kvm_stat
*kvm
,
396 struct thread
*thread
,
397 struct perf_evsel
*evsel
,
398 struct perf_sample
*sample
)
400 struct vcpu_event_record
*vcpu_record
;
401 struct event_key key
= { .key
= INVALID_KEY
,
402 .exit_reasons
= kvm
->exit_reasons
};
404 vcpu_record
= per_vcpu_record(thread
, evsel
, sample
);
408 /* only process events for vcpus user cares about */
409 if ((kvm
->trace_vcpu
!= -1) &&
410 (kvm
->trace_vcpu
!= vcpu_record
->vcpu_id
))
413 if (kvm
->events_ops
->is_begin_event(evsel
, sample
, &key
))
414 return handle_begin_event(kvm
, vcpu_record
, &key
, sample
->time
);
416 if (is_child_event(kvm
, evsel
, sample
, &key
))
417 return handle_child_event(kvm
, vcpu_record
, &key
, sample
);
419 if (kvm
->events_ops
->is_end_event(evsel
, sample
, &key
))
420 return handle_end_event(kvm
, vcpu_record
, &key
, sample
);
425 #define GET_EVENT_KEY(func, field) \
426 static u64 get_event_ ##func(struct kvm_event *event, int vcpu) \
429 return event->total.field; \
431 if (vcpu >= event->max_vcpu) \
434 return event->vcpu[vcpu].field; \
437 #define COMPARE_EVENT_KEY(func, field) \
438 GET_EVENT_KEY(func, field) \
439 static int compare_kvm_event_ ## func(struct kvm_event *one, \
440 struct kvm_event *two, int vcpu)\
442 return get_event_ ##func(one, vcpu) > \
443 get_event_ ##func(two, vcpu); \
446 GET_EVENT_KEY(time
, time
);
447 COMPARE_EVENT_KEY(count
, stats
.n
);
448 COMPARE_EVENT_KEY(mean
, stats
.mean
);
449 GET_EVENT_KEY(max
, stats
.max
);
450 GET_EVENT_KEY(min
, stats
.min
);
452 #define DEF_SORT_NAME_KEY(name, compare_key) \
453 { #name, compare_kvm_event_ ## compare_key }
455 static struct kvm_event_key keys
[] = {
456 DEF_SORT_NAME_KEY(sample
, count
),
457 DEF_SORT_NAME_KEY(time
, mean
),
461 static bool select_key(struct perf_kvm_stat
*kvm
)
465 for (i
= 0; keys
[i
].name
; i
++) {
466 if (!strcmp(keys
[i
].name
, kvm
->sort_key
)) {
467 kvm
->compare
= keys
[i
].key
;
472 pr_err("Unknown compare key:%s\n", kvm
->sort_key
);
476 static void insert_to_result(struct rb_root
*result
, struct kvm_event
*event
,
477 key_cmp_fun bigger
, int vcpu
)
479 struct rb_node
**rb
= &result
->rb_node
;
480 struct rb_node
*parent
= NULL
;
484 p
= container_of(*rb
, struct kvm_event
, rb
);
487 if (bigger(event
, p
, vcpu
))
488 rb
= &(*rb
)->rb_left
;
490 rb
= &(*rb
)->rb_right
;
493 rb_link_node(&event
->rb
, parent
, rb
);
494 rb_insert_color(&event
->rb
, result
);
498 update_total_count(struct perf_kvm_stat
*kvm
, struct kvm_event
*event
)
500 int vcpu
= kvm
->trace_vcpu
;
502 kvm
->total_count
+= get_event_count(event
, vcpu
);
503 kvm
->total_time
+= get_event_time(event
, vcpu
);
506 static bool event_is_valid(struct kvm_event
*event
, int vcpu
)
508 return !!get_event_count(event
, vcpu
);
511 static void sort_result(struct perf_kvm_stat
*kvm
)
514 int vcpu
= kvm
->trace_vcpu
;
515 struct kvm_event
*event
;
517 for (i
= 0; i
< EVENTS_CACHE_SIZE
; i
++) {
518 list_for_each_entry(event
, &kvm
->kvm_events_cache
[i
], hash_entry
) {
519 if (event_is_valid(event
, vcpu
)) {
520 update_total_count(kvm
, event
);
521 insert_to_result(&kvm
->result
, event
,
528 /* returns left most element of result, and erase it */
529 static struct kvm_event
*pop_from_result(struct rb_root
*result
)
531 struct rb_node
*node
= rb_first(result
);
536 rb_erase(node
, result
);
537 return container_of(node
, struct kvm_event
, rb
);
540 static void print_vcpu_info(struct perf_kvm_stat
*kvm
)
542 int vcpu
= kvm
->trace_vcpu
;
544 pr_info("Analyze events for ");
546 if (kvm
->opts
.target
.system_wide
)
547 pr_info("all VMs, ");
548 else if (kvm
->opts
.target
.pid
)
549 pr_info("pid(s) %s, ", kvm
->opts
.target
.pid
);
551 pr_info("dazed and confused on what is monitored, ");
554 pr_info("all VCPUs:\n\n");
556 pr_info("VCPU %d:\n\n", vcpu
);
559 static void show_timeofday(void)
565 gettimeofday(&tv
, NULL
);
566 if (localtime_r(&tv
.tv_sec
, <ime
)) {
567 strftime(date
, sizeof(date
), "%H:%M:%S", <ime
);
568 pr_info("%s.%06ld", date
, tv
.tv_usec
);
570 pr_info("00:00:00.000000");
575 static void print_result(struct perf_kvm_stat
*kvm
)
577 char decode
[DECODE_STR_LEN
];
578 struct kvm_event
*event
;
579 int vcpu
= kvm
->trace_vcpu
;
587 print_vcpu_info(kvm
);
588 pr_info("%*s ", DECODE_STR_LEN
, kvm
->events_ops
->name
);
589 pr_info("%10s ", "Samples");
590 pr_info("%9s ", "Samples%");
592 pr_info("%9s ", "Time%");
593 pr_info("%11s ", "Min Time");
594 pr_info("%11s ", "Max Time");
595 pr_info("%16s ", "Avg time");
598 while ((event
= pop_from_result(&kvm
->result
))) {
599 u64 ecount
, etime
, max
, min
;
601 ecount
= get_event_count(event
, vcpu
);
602 etime
= get_event_time(event
, vcpu
);
603 max
= get_event_max(event
, vcpu
);
604 min
= get_event_min(event
, vcpu
);
606 kvm
->events_ops
->decode_key(kvm
, &event
->key
, decode
);
607 pr_info("%*s ", DECODE_STR_LEN
, decode
);
608 pr_info("%10llu ", (unsigned long long)ecount
);
609 pr_info("%8.2f%% ", (double)ecount
/ kvm
->total_count
* 100);
610 pr_info("%8.2f%% ", (double)etime
/ kvm
->total_time
* 100);
611 pr_info("%9.2fus ", (double)min
/ 1e3
);
612 pr_info("%9.2fus ", (double)max
/ 1e3
);
613 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime
/ ecount
/1e3
,
614 kvm_event_rel_stddev(vcpu
, event
));
618 pr_info("\nTotal Samples:%" PRIu64
", Total events handled time:%.2fus.\n\n",
619 kvm
->total_count
, kvm
->total_time
/ 1e3
);
621 if (kvm
->lost_events
)
622 pr_info("\nLost events: %" PRIu64
"\n\n", kvm
->lost_events
);
625 #ifdef HAVE_TIMERFD_SUPPORT
626 static int process_lost_event(struct perf_tool
*tool
,
627 union perf_event
*event __maybe_unused
,
628 struct perf_sample
*sample __maybe_unused
,
629 struct machine
*machine __maybe_unused
)
631 struct perf_kvm_stat
*kvm
= container_of(tool
, struct perf_kvm_stat
, tool
);
638 static bool skip_sample(struct perf_kvm_stat
*kvm
,
639 struct perf_sample
*sample
)
641 if (kvm
->pid_list
&& intlist__find(kvm
->pid_list
, sample
->pid
) == NULL
)
647 static int process_sample_event(struct perf_tool
*tool
,
648 union perf_event
*event
,
649 struct perf_sample
*sample
,
650 struct perf_evsel
*evsel
,
651 struct machine
*machine
)
653 struct thread
*thread
;
654 struct perf_kvm_stat
*kvm
= container_of(tool
, struct perf_kvm_stat
,
657 if (skip_sample(kvm
, sample
))
660 thread
= machine__findnew_thread(machine
, sample
->pid
, sample
->tid
);
661 if (thread
== NULL
) {
662 pr_debug("problem processing %d event, skipping it.\n",
667 if (!handle_kvm_event(kvm
, thread
, evsel
, sample
))
673 static int cpu_isa_config(struct perf_kvm_stat
*kvm
)
675 char buf
[64], *cpuid
;
679 err
= get_cpuid(buf
, sizeof(buf
));
681 pr_err("Failed to look up CPU type\n");
686 cpuid
= kvm
->session
->header
.env
.cpuid
;
689 pr_err("Failed to look up CPU type\n");
693 err
= cpu_isa_init(kvm
, cpuid
);
695 pr_err("CPU %s is not supported.\n", cpuid
);
700 static bool verify_vcpu(int vcpu
)
702 if (vcpu
!= -1 && vcpu
< 0) {
703 pr_err("Invalid vcpu:%d.\n", vcpu
);
710 #ifdef HAVE_TIMERFD_SUPPORT
711 /* keeping the max events to a modest level to keep
712 * the processing of samples per mmap smooth.
714 #define PERF_KVM__MAX_EVENTS_PER_MMAP 25
716 static s64
perf_kvm__mmap_read_idx(struct perf_kvm_stat
*kvm
, int idx
,
719 union perf_event
*event
;
720 struct perf_sample sample
;
724 *mmap_time
= ULLONG_MAX
;
725 while ((event
= perf_evlist__mmap_read(kvm
->evlist
, idx
)) != NULL
) {
726 err
= perf_evlist__parse_sample(kvm
->evlist
, event
, &sample
);
728 perf_evlist__mmap_consume(kvm
->evlist
, idx
);
729 pr_err("Failed to parse sample\n");
733 err
= perf_session_queue_event(kvm
->session
, event
, &kvm
->tool
, &sample
, 0);
735 * FIXME: Here we can't consume the event, as perf_session_queue_event will
736 * point to it, and it'll get possibly overwritten by the kernel.
738 perf_evlist__mmap_consume(kvm
->evlist
, idx
);
741 pr_err("Failed to enqueue sample: %d\n", err
);
745 /* save time stamp of our first sample for this mmap */
747 *mmap_time
= sample
.time
;
749 /* limit events per mmap handled all at once */
751 if (n
== PERF_KVM__MAX_EVENTS_PER_MMAP
)
758 static int perf_kvm__mmap_read(struct perf_kvm_stat
*kvm
)
760 int i
, err
, throttled
= 0;
762 u64 flush_time
= ULLONG_MAX
, mmap_time
;
764 for (i
= 0; i
< kvm
->evlist
->nr_mmaps
; i
++) {
765 n
= perf_kvm__mmap_read_idx(kvm
, i
, &mmap_time
);
769 /* flush time is going to be the minimum of all the individual
770 * mmap times. Essentially, we flush all the samples queued up
771 * from the last pass under our minimal start time -- that leaves
772 * a very small race for samples to come in with a lower timestamp.
773 * The ioctl to return the perf_clock timestamp should close the
776 if (mmap_time
< flush_time
)
777 flush_time
= mmap_time
;
780 if (n
== PERF_KVM__MAX_EVENTS_PER_MMAP
)
784 /* flush queue after each round in which we processed events */
786 kvm
->session
->ordered_events
.next_flush
= flush_time
;
787 err
= kvm
->tool
.finished_round(&kvm
->tool
, NULL
, kvm
->session
);
789 if (kvm
->lost_events
)
790 pr_info("\nLost events: %" PRIu64
"\n\n",
799 static volatile int done
;
801 static void sig_handler(int sig __maybe_unused
)
806 static int perf_kvm__timerfd_create(struct perf_kvm_stat
*kvm
)
808 struct itimerspec new_value
;
811 kvm
->timerfd
= timerfd_create(CLOCK_MONOTONIC
, TFD_NONBLOCK
);
812 if (kvm
->timerfd
< 0) {
813 pr_err("timerfd_create failed\n");
817 new_value
.it_value
.tv_sec
= kvm
->display_time
;
818 new_value
.it_value
.tv_nsec
= 0;
819 new_value
.it_interval
.tv_sec
= kvm
->display_time
;
820 new_value
.it_interval
.tv_nsec
= 0;
822 if (timerfd_settime(kvm
->timerfd
, 0, &new_value
, NULL
) != 0) {
823 pr_err("timerfd_settime failed: %d\n", errno
);
833 static int perf_kvm__handle_timerfd(struct perf_kvm_stat
*kvm
)
838 rc
= read(kvm
->timerfd
, &c
, sizeof(uint64_t));
843 pr_err("Failed to read timer fd: %d\n", errno
);
847 if (rc
!= sizeof(uint64_t)) {
848 pr_err("Error reading timer fd - invalid size returned\n");
853 pr_debug("Missed timer beats: %" PRIu64
"\n", c
-1);
860 clear_events_cache_stats(kvm
->kvm_events_cache
);
861 kvm
->total_count
= 0;
863 kvm
->lost_events
= 0;
868 static int fd_set_nonblock(int fd
)
872 arg
= fcntl(fd
, F_GETFL
);
874 pr_err("Failed to get current flags for fd %d\n", fd
);
878 if (fcntl(fd
, F_SETFL
, arg
| O_NONBLOCK
) < 0) {
879 pr_err("Failed to set non-block option on fd %d\n", fd
);
886 static int perf_kvm__handle_stdin(void)
897 static int kvm_events_live_report(struct perf_kvm_stat
*kvm
)
899 struct pollfd
*pollfds
= NULL
;
900 int nr_fds
, nr_stdin
, ret
, err
= -EINVAL
;
903 /* live flag must be set first */
906 ret
= cpu_isa_config(kvm
);
910 if (!verify_vcpu(kvm
->trace_vcpu
) ||
912 !register_kvm_events_ops(kvm
)) {
916 set_term_quiet_input(&save
);
917 init_kvm_event_record(kvm
);
919 signal(SIGINT
, sig_handler
);
920 signal(SIGTERM
, sig_handler
);
922 /* use pollfds -- need to add timerfd and stdin */
923 nr_fds
= kvm
->evlist
->pollfd
.nr
;
926 if (perf_kvm__timerfd_create(kvm
) < 0) {
931 if (perf_evlist__add_pollfd(kvm
->evlist
, kvm
->timerfd
))
936 if (perf_evlist__add_pollfd(kvm
->evlist
, fileno(stdin
)))
941 if (fd_set_nonblock(fileno(stdin
)) != 0)
944 pollfds
= kvm
->evlist
->pollfd
.entries
;
946 /* everything is good - enable the events and process */
947 perf_evlist__enable(kvm
->evlist
);
952 rc
= perf_kvm__mmap_read(kvm
);
956 err
= perf_kvm__handle_timerfd(kvm
);
960 if (pollfds
[nr_stdin
].revents
& POLLIN
)
961 done
= perf_kvm__handle_stdin();
964 err
= poll(pollfds
, nr_fds
, 100);
967 perf_evlist__disable(kvm
->evlist
);
975 if (kvm
->timerfd
>= 0)
978 tcsetattr(0, TCSAFLUSH
, &save
);
982 static int kvm_live_open_events(struct perf_kvm_stat
*kvm
)
985 struct perf_evsel
*pos
;
986 struct perf_evlist
*evlist
= kvm
->evlist
;
987 char sbuf
[STRERR_BUFSIZE
];
989 perf_evlist__config(evlist
, &kvm
->opts
);
992 * Note: exclude_{guest,host} do not apply here.
993 * This command processes KVM tracepoints from host only
995 evlist__for_each(evlist
, pos
) {
996 struct perf_event_attr
*attr
= &pos
->attr
;
998 /* make sure these *are* set */
999 perf_evsel__set_sample_bit(pos
, TID
);
1000 perf_evsel__set_sample_bit(pos
, TIME
);
1001 perf_evsel__set_sample_bit(pos
, CPU
);
1002 perf_evsel__set_sample_bit(pos
, RAW
);
1003 /* make sure these are *not*; want as small a sample as possible */
1004 perf_evsel__reset_sample_bit(pos
, PERIOD
);
1005 perf_evsel__reset_sample_bit(pos
, IP
);
1006 perf_evsel__reset_sample_bit(pos
, CALLCHAIN
);
1007 perf_evsel__reset_sample_bit(pos
, ADDR
);
1008 perf_evsel__reset_sample_bit(pos
, READ
);
1013 attr
->sample_period
= 1;
1015 attr
->watermark
= 0;
1016 attr
->wakeup_events
= 1000;
1018 /* will enable all once we are ready */
1022 err
= perf_evlist__open(evlist
);
1024 printf("Couldn't create the events: %s\n",
1025 strerror_r(errno
, sbuf
, sizeof(sbuf
)));
1029 if (perf_evlist__mmap(evlist
, kvm
->opts
.mmap_pages
, false) < 0) {
1030 ui__error("Failed to mmap the events: %s\n",
1031 strerror_r(errno
, sbuf
, sizeof(sbuf
)));
1032 perf_evlist__close(evlist
);
1043 static int read_events(struct perf_kvm_stat
*kvm
)
1047 struct perf_tool eops
= {
1048 .sample
= process_sample_event
,
1049 .comm
= perf_event__process_comm
,
1050 .ordered_events
= true,
1052 struct perf_data_file file
= {
1053 .path
= kvm
->file_name
,
1054 .mode
= PERF_DATA_MODE_READ
,
1058 kvm
->session
= perf_session__new(&file
, false, &kvm
->tool
);
1059 if (!kvm
->session
) {
1060 pr_err("Initializing perf session failed\n");
1064 symbol__init(&kvm
->session
->header
.env
);
1066 if (!perf_session__has_traces(kvm
->session
, "kvm record"))
1070 * Do not use 'isa' recorded in kvm_exit tracepoint since it is not
1071 * traced in the old kernel.
1073 ret
= cpu_isa_config(kvm
);
1077 return perf_session__process_events(kvm
->session
, &kvm
->tool
);
1080 static int parse_target_str(struct perf_kvm_stat
*kvm
)
1082 if (kvm
->opts
.target
.pid
) {
1083 kvm
->pid_list
= intlist__new(kvm
->opts
.target
.pid
);
1084 if (kvm
->pid_list
== NULL
) {
1085 pr_err("Error parsing process id string\n");
1093 static int kvm_events_report_vcpu(struct perf_kvm_stat
*kvm
)
1096 int vcpu
= kvm
->trace_vcpu
;
1098 if (parse_target_str(kvm
) != 0)
1101 if (!verify_vcpu(vcpu
))
1104 if (!select_key(kvm
))
1107 if (!register_kvm_events_ops(kvm
))
1110 init_kvm_event_record(kvm
);
1113 ret
= read_events(kvm
);
1124 #define STRDUP_FAIL_EXIT(s) \
1133 kvm_events_record(struct perf_kvm_stat
*kvm
, int argc
, const char **argv
)
1135 unsigned int rec_argc
, i
, j
, events_tp_size
;
1136 const char **rec_argv
;
1137 const char * const record_args
[] = {
1143 const char * const *events_tp
;
1146 for (events_tp
= kvm_events_tp
; *events_tp
; events_tp
++)
1149 rec_argc
= ARRAY_SIZE(record_args
) + argc
+ 2 +
1151 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1153 if (rec_argv
== NULL
)
1156 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
1157 rec_argv
[i
] = STRDUP_FAIL_EXIT(record_args
[i
]);
1159 for (j
= 0; j
< events_tp_size
; j
++) {
1160 rec_argv
[i
++] = "-e";
1161 rec_argv
[i
++] = STRDUP_FAIL_EXIT(kvm_events_tp
[j
]);
1164 rec_argv
[i
++] = STRDUP_FAIL_EXIT("-o");
1165 rec_argv
[i
++] = STRDUP_FAIL_EXIT(kvm
->file_name
);
1167 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
1168 rec_argv
[i
] = argv
[j
];
1170 return cmd_record(i
, rec_argv
, NULL
);
1174 kvm_events_report(struct perf_kvm_stat
*kvm
, int argc
, const char **argv
)
1176 const struct option kvm_events_report_options
[] = {
1177 OPT_STRING(0, "event", &kvm
->report_event
, "report event",
1178 "event for reporting: vmexit, "
1179 "mmio (x86 only), ioport (x86 only)"),
1180 OPT_INTEGER(0, "vcpu", &kvm
->trace_vcpu
,
1181 "vcpu id to report"),
1182 OPT_STRING('k', "key", &kvm
->sort_key
, "sort-key",
1183 "key for sorting: sample(sort by samples number)"
1184 " time (sort by avg time)"),
1185 OPT_STRING('p', "pid", &kvm
->opts
.target
.pid
, "pid",
1186 "analyze events only for given process id(s)"),
1190 const char * const kvm_events_report_usage
[] = {
1191 "perf kvm stat report [<options>]",
1196 argc
= parse_options(argc
, argv
,
1197 kvm_events_report_options
,
1198 kvm_events_report_usage
, 0);
1200 usage_with_options(kvm_events_report_usage
,
1201 kvm_events_report_options
);
1204 if (!kvm
->opts
.target
.pid
)
1205 kvm
->opts
.target
.system_wide
= true;
1207 return kvm_events_report_vcpu(kvm
);
1210 #ifdef HAVE_TIMERFD_SUPPORT
1211 static struct perf_evlist
*kvm_live_event_list(void)
1213 struct perf_evlist
*evlist
;
1214 char *tp
, *name
, *sys
;
1216 const char * const *events_tp
;
1218 evlist
= perf_evlist__new();
1222 for (events_tp
= kvm_events_tp
; *events_tp
; events_tp
++) {
1224 tp
= strdup(*events_tp
);
1228 /* split tracepoint into subsystem and name */
1230 name
= strchr(tp
, ':');
1232 pr_err("Error parsing %s tracepoint: subsystem delimiter not found\n",
1240 if (perf_evlist__add_newtp(evlist
, sys
, name
, NULL
)) {
1241 pr_err("Failed to add %s tracepoint to the list\n", *events_tp
);
1253 perf_evlist__delete(evlist
);
1260 static int kvm_events_live(struct perf_kvm_stat
*kvm
,
1261 int argc
, const char **argv
)
1263 char errbuf
[BUFSIZ
];
1266 const struct option live_options
[] = {
1267 OPT_STRING('p', "pid", &kvm
->opts
.target
.pid
, "pid",
1268 "record events on existing process id"),
1269 OPT_CALLBACK('m', "mmap-pages", &kvm
->opts
.mmap_pages
, "pages",
1270 "number of mmap data pages",
1271 perf_evlist__parse_mmap_pages
),
1272 OPT_INCR('v', "verbose", &verbose
,
1273 "be more verbose (show counter open errors, etc)"),
1274 OPT_BOOLEAN('a', "all-cpus", &kvm
->opts
.target
.system_wide
,
1275 "system-wide collection from all CPUs"),
1276 OPT_UINTEGER('d', "display", &kvm
->display_time
,
1277 "time in seconds between display updates"),
1278 OPT_STRING(0, "event", &kvm
->report_event
, "report event",
1279 "event for reporting: vmexit, mmio, ioport"),
1280 OPT_INTEGER(0, "vcpu", &kvm
->trace_vcpu
,
1281 "vcpu id to report"),
1282 OPT_STRING('k', "key", &kvm
->sort_key
, "sort-key",
1283 "key for sorting: sample(sort by samples number)"
1284 " time (sort by avg time)"),
1285 OPT_U64(0, "duration", &kvm
->duration
,
1286 "show events other than"
1287 " HLT (x86 only) or Wait state (s390 only)"
1288 " that take longer than duration usecs"),
1291 const char * const live_usage
[] = {
1292 "perf kvm stat live [<options>]",
1295 struct perf_data_file file
= {
1296 .mode
= PERF_DATA_MODE_WRITE
,
1300 /* event handling */
1301 kvm
->tool
.sample
= process_sample_event
;
1302 kvm
->tool
.comm
= perf_event__process_comm
;
1303 kvm
->tool
.exit
= perf_event__process_exit
;
1304 kvm
->tool
.fork
= perf_event__process_fork
;
1305 kvm
->tool
.lost
= process_lost_event
;
1306 kvm
->tool
.ordered_events
= true;
1307 perf_tool__fill_defaults(&kvm
->tool
);
1310 kvm
->display_time
= 1;
1311 kvm
->opts
.user_interval
= 1;
1312 kvm
->opts
.mmap_pages
= 512;
1313 kvm
->opts
.target
.uses_mmap
= false;
1314 kvm
->opts
.target
.uid_str
= NULL
;
1315 kvm
->opts
.target
.uid
= UINT_MAX
;
1318 disable_buildid_cache();
1321 setup_browser(false);
1324 argc
= parse_options(argc
, argv
, live_options
,
1327 usage_with_options(live_usage
, live_options
);
1330 kvm
->duration
*= NSEC_PER_USEC
; /* convert usec to nsec */
1333 * target related setups
1335 err
= target__validate(&kvm
->opts
.target
);
1337 target__strerror(&kvm
->opts
.target
, err
, errbuf
, BUFSIZ
);
1338 ui__warning("%s", errbuf
);
1341 if (target__none(&kvm
->opts
.target
))
1342 kvm
->opts
.target
.system_wide
= true;
1346 * generate the event list
1348 kvm
->evlist
= kvm_live_event_list();
1349 if (kvm
->evlist
== NULL
) {
1354 symbol_conf
.nr_events
= kvm
->evlist
->nr_entries
;
1356 if (perf_evlist__create_maps(kvm
->evlist
, &kvm
->opts
.target
) < 0)
1357 usage_with_options(live_usage
, live_options
);
1362 kvm
->session
= perf_session__new(&file
, false, &kvm
->tool
);
1363 if (kvm
->session
== NULL
) {
1367 kvm
->session
->evlist
= kvm
->evlist
;
1368 perf_session__set_id_hdr_size(kvm
->session
);
1369 machine__synthesize_threads(&kvm
->session
->machines
.host
, &kvm
->opts
.target
,
1370 kvm
->evlist
->threads
, false);
1371 err
= kvm_live_open_events(kvm
);
1375 err
= kvm_events_live_report(kvm
);
1381 perf_session__delete(kvm
->session
);
1382 kvm
->session
= NULL
;
1384 perf_evlist__delete(kvm
->evlist
);
1390 static void print_kvm_stat_usage(void)
1392 printf("Usage: perf kvm stat <command>\n\n");
1394 printf("# Available commands:\n");
1395 printf("\trecord: record kvm events\n");
1396 printf("\treport: report statistical data of kvm events\n");
1397 printf("\tlive: live reporting of statistical data of kvm events\n");
1399 printf("\nOtherwise, it is the alias of 'perf stat':\n");
1402 static int kvm_cmd_stat(const char *file_name
, int argc
, const char **argv
)
1404 struct perf_kvm_stat kvm
= {
1405 .file_name
= file_name
,
1408 .report_event
= "vmexit",
1409 .sort_key
= "sample",
1414 print_kvm_stat_usage();
1418 if (!strncmp(argv
[1], "rec", 3))
1419 return kvm_events_record(&kvm
, argc
- 1, argv
+ 1);
1421 if (!strncmp(argv
[1], "rep", 3))
1422 return kvm_events_report(&kvm
, argc
- 1 , argv
+ 1);
1424 #ifdef HAVE_TIMERFD_SUPPORT
1425 if (!strncmp(argv
[1], "live", 4))
1426 return kvm_events_live(&kvm
, argc
- 1 , argv
+ 1);
1430 return cmd_stat(argc
, argv
, NULL
);
1432 #endif /* HAVE_KVM_STAT_SUPPORT */
1434 static int __cmd_record(const char *file_name
, int argc
, const char **argv
)
1436 int rec_argc
, i
= 0, j
;
1437 const char **rec_argv
;
1439 rec_argc
= argc
+ 2;
1440 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1441 rec_argv
[i
++] = strdup("record");
1442 rec_argv
[i
++] = strdup("-o");
1443 rec_argv
[i
++] = strdup(file_name
);
1444 for (j
= 1; j
< argc
; j
++, i
++)
1445 rec_argv
[i
] = argv
[j
];
1447 BUG_ON(i
!= rec_argc
);
1449 return cmd_record(i
, rec_argv
, NULL
);
1452 static int __cmd_report(const char *file_name
, int argc
, const char **argv
)
1454 int rec_argc
, i
= 0, j
;
1455 const char **rec_argv
;
1457 rec_argc
= argc
+ 2;
1458 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1459 rec_argv
[i
++] = strdup("report");
1460 rec_argv
[i
++] = strdup("-i");
1461 rec_argv
[i
++] = strdup(file_name
);
1462 for (j
= 1; j
< argc
; j
++, i
++)
1463 rec_argv
[i
] = argv
[j
];
1465 BUG_ON(i
!= rec_argc
);
1467 return cmd_report(i
, rec_argv
, NULL
);
1471 __cmd_buildid_list(const char *file_name
, int argc
, const char **argv
)
1473 int rec_argc
, i
= 0, j
;
1474 const char **rec_argv
;
1476 rec_argc
= argc
+ 2;
1477 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1478 rec_argv
[i
++] = strdup("buildid-list");
1479 rec_argv
[i
++] = strdup("-i");
1480 rec_argv
[i
++] = strdup(file_name
);
1481 for (j
= 1; j
< argc
; j
++, i
++)
1482 rec_argv
[i
] = argv
[j
];
1484 BUG_ON(i
!= rec_argc
);
1486 return cmd_buildid_list(i
, rec_argv
, NULL
);
1489 int cmd_kvm(int argc
, const char **argv
, const char *prefix __maybe_unused
)
1491 const char *file_name
= NULL
;
1492 const struct option kvm_options
[] = {
1493 OPT_STRING('i', "input", &file_name
, "file",
1495 OPT_STRING('o', "output", &file_name
, "file",
1496 "Output file name"),
1497 OPT_BOOLEAN(0, "guest", &perf_guest
,
1498 "Collect guest os data"),
1499 OPT_BOOLEAN(0, "host", &perf_host
,
1500 "Collect host os data"),
1501 OPT_STRING(0, "guestmount", &symbol_conf
.guestmount
, "directory",
1502 "guest mount directory under which every guest os"
1503 " instance has a subdir"),
1504 OPT_STRING(0, "guestvmlinux", &symbol_conf
.default_guest_vmlinux_name
,
1505 "file", "file saving guest os vmlinux"),
1506 OPT_STRING(0, "guestkallsyms", &symbol_conf
.default_guest_kallsyms
,
1507 "file", "file saving guest os /proc/kallsyms"),
1508 OPT_STRING(0, "guestmodules", &symbol_conf
.default_guest_modules
,
1509 "file", "file saving guest os /proc/modules"),
1510 OPT_INCR('v', "verbose", &verbose
,
1511 "be more verbose (show counter open errors, etc)"),
1515 const char *const kvm_subcommands
[] = { "top", "record", "report", "diff",
1516 "buildid-list", "stat", NULL
};
1517 const char *kvm_usage
[] = { NULL
, NULL
};
1522 argc
= parse_options_subcommand(argc
, argv
, kvm_options
, kvm_subcommands
, kvm_usage
,
1523 PARSE_OPT_STOP_AT_NON_OPTION
);
1525 usage_with_options(kvm_usage
, kvm_options
);
1531 file_name
= get_filename_for_perf_kvm();
1534 pr_err("Failed to allocate memory for filename\n");
1539 if (!strncmp(argv
[0], "rec", 3))
1540 return __cmd_record(file_name
, argc
, argv
);
1541 else if (!strncmp(argv
[0], "rep", 3))
1542 return __cmd_report(file_name
, argc
, argv
);
1543 else if (!strncmp(argv
[0], "diff", 4))
1544 return cmd_diff(argc
, argv
, NULL
);
1545 else if (!strncmp(argv
[0], "top", 3))
1546 return cmd_top(argc
, argv
, NULL
);
1547 else if (!strncmp(argv
[0], "buildid-list", 12))
1548 return __cmd_buildid_list(file_name
, argc
, argv
);
1549 #ifdef HAVE_KVM_STAT_SUPPORT
1550 else if (!strncmp(argv
[0], "stat", 4))
1551 return kvm_cmd_stat(file_name
, argc
, argv
);
1554 usage_with_options(kvm_usage
, kvm_options
);