2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License, version 2, as
4 * published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 * Copyright IBM Corp. 2008
17 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
18 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
21 #include <linux/kvm_host.h>
23 #include <linux/seq_file.h>
24 #include <linux/debugfs.h>
25 #include <linux/uaccess.h>
26 #include <linux/module.h>
29 #include <asm-generic/div64.h>
33 void kvmppc_init_timing_stats(struct kvm_vcpu
*vcpu
)
37 /* Take a lock to avoid concurrent updates */
38 mutex_lock(&vcpu
->arch
.exit_timing_lock
);
40 vcpu
->arch
.last_exit_type
= 0xDEAD;
41 for (i
= 0; i
< __NUMBER_OF_KVM_EXIT_TYPES
; i
++) {
42 vcpu
->arch
.timing_count_type
[i
] = 0;
43 vcpu
->arch
.timing_max_duration
[i
] = 0;
44 vcpu
->arch
.timing_min_duration
[i
] = 0xFFFFFFFF;
45 vcpu
->arch
.timing_sum_duration
[i
] = 0;
46 vcpu
->arch
.timing_sum_quad_duration
[i
] = 0;
48 vcpu
->arch
.timing_last_exit
= 0;
49 vcpu
->arch
.timing_exit
.tv64
= 0;
50 vcpu
->arch
.timing_last_enter
.tv64
= 0;
52 mutex_unlock(&vcpu
->arch
.exit_timing_lock
);
55 static void add_exit_timing(struct kvm_vcpu
*vcpu
, u64 duration
, int type
)
59 do_div(duration
, tb_ticks_per_usec
);
60 if (unlikely(duration
> 0xFFFFFFFF)) {
61 printk(KERN_ERR
"%s - duration too big -> overflow"
62 " duration %lld type %d exit #%d\n",
63 __func__
, duration
, type
,
64 vcpu
->arch
.timing_count_type
[type
]);
68 mutex_lock(&vcpu
->arch
.exit_timing_lock
);
70 vcpu
->arch
.timing_count_type
[type
]++;
73 old
= vcpu
->arch
.timing_sum_duration
[type
];
74 vcpu
->arch
.timing_sum_duration
[type
] += duration
;
75 if (unlikely(old
> vcpu
->arch
.timing_sum_duration
[type
])) {
76 printk(KERN_ERR
"%s - wrap adding sum of durations"
77 " old %lld new %lld type %d exit # of type %d\n",
78 __func__
, old
, vcpu
->arch
.timing_sum_duration
[type
],
79 type
, vcpu
->arch
.timing_count_type
[type
]);
83 old
= vcpu
->arch
.timing_sum_quad_duration
[type
];
84 vcpu
->arch
.timing_sum_quad_duration
[type
] += (duration
*duration
);
85 if (unlikely(old
> vcpu
->arch
.timing_sum_quad_duration
[type
])) {
86 printk(KERN_ERR
"%s - wrap adding sum of squared durations"
87 " old %lld new %lld type %d exit # of type %d\n",
89 vcpu
->arch
.timing_sum_quad_duration
[type
],
90 type
, vcpu
->arch
.timing_count_type
[type
]);
94 if (unlikely(duration
< vcpu
->arch
.timing_min_duration
[type
]))
95 vcpu
->arch
.timing_min_duration
[type
] = duration
;
96 if (unlikely(duration
> vcpu
->arch
.timing_max_duration
[type
]))
97 vcpu
->arch
.timing_max_duration
[type
] = duration
;
99 mutex_unlock(&vcpu
->arch
.exit_timing_lock
);
102 void kvmppc_update_timing_stats(struct kvm_vcpu
*vcpu
)
104 u64 exit
= vcpu
->arch
.timing_last_exit
;
105 u64 enter
= vcpu
->arch
.timing_last_enter
.tv64
;
107 /* save exit time, used next exit when the reenter time is known */
108 vcpu
->arch
.timing_last_exit
= vcpu
->arch
.timing_exit
.tv64
;
110 if (unlikely(vcpu
->arch
.last_exit_type
== 0xDEAD || exit
== 0))
111 return; /* skip incomplete cycle (e.g. after reset) */
113 /* update statistics for average and standard deviation */
114 add_exit_timing(vcpu
, (enter
- exit
), vcpu
->arch
.last_exit_type
);
115 /* enter -> timing_last_exit is time spent in guest - log this too */
116 add_exit_timing(vcpu
, (vcpu
->arch
.timing_last_exit
- enter
),
120 static const char *kvm_exit_names
[__NUMBER_OF_KVM_EXIT_TYPES
] = {
121 [MMIO_EXITS
] = "MMIO",
123 [SIGNAL_EXITS
] = "SIGNAL",
124 [ITLB_REAL_MISS_EXITS
] = "ITLBREAL",
125 [ITLB_VIRT_MISS_EXITS
] = "ITLBVIRT",
126 [DTLB_REAL_MISS_EXITS
] = "DTLBREAL",
127 [DTLB_VIRT_MISS_EXITS
] = "DTLBVIRT",
128 [SYSCALL_EXITS
] = "SYSCALL",
131 [EMULATED_INST_EXITS
] = "EMULINST",
132 [EMULATED_MTMSRWE_EXITS
] = "EMUL_WAIT",
133 [EMULATED_WRTEE_EXITS
] = "EMUL_WRTEE",
134 [EMULATED_MTSPR_EXITS
] = "EMUL_MTSPR",
135 [EMULATED_MFSPR_EXITS
] = "EMUL_MFSPR",
136 [EMULATED_MTMSR_EXITS
] = "EMUL_MTMSR",
137 [EMULATED_MFMSR_EXITS
] = "EMUL_MFMSR",
138 [EMULATED_TLBSX_EXITS
] = "EMUL_TLBSX",
139 [EMULATED_TLBWE_EXITS
] = "EMUL_TLBWE",
140 [EMULATED_RFI_EXITS
] = "EMUL_RFI",
142 [EXT_INTR_EXITS
] = "EXTINT",
143 [HALT_WAKEUP
] = "HALT",
144 [USR_PR_INST
] = "USR_PR_INST",
145 [FP_UNAVAIL
] = "FP_UNAVAIL",
146 [DEBUG_EXITS
] = "DEBUG",
147 [TIMEINGUEST
] = "TIMEINGUEST"
150 static int kvmppc_exit_timing_show(struct seq_file
*m
, void *private)
152 struct kvm_vcpu
*vcpu
= m
->private;
154 u64 min
, max
, sum
, sum_quad
;
156 seq_printf(m
, "%s", "type count min max sum sum_squared\n");
159 for (i
= 0; i
< __NUMBER_OF_KVM_EXIT_TYPES
; i
++) {
161 min
= vcpu
->arch
.timing_min_duration
[i
];
162 do_div(min
, tb_ticks_per_usec
);
163 max
= vcpu
->arch
.timing_max_duration
[i
];
164 do_div(max
, tb_ticks_per_usec
);
165 sum
= vcpu
->arch
.timing_sum_duration
[i
];
166 do_div(sum
, tb_ticks_per_usec
);
167 sum_quad
= vcpu
->arch
.timing_sum_quad_duration
[i
];
168 do_div(sum_quad
, tb_ticks_per_usec
);
170 seq_printf(m
, "%12s %10d %10lld %10lld %20lld %20lld\n",
172 vcpu
->arch
.timing_count_type
[i
],
182 /* Write 'c' to clear the timing statistics. */
183 static ssize_t
kvmppc_exit_timing_write(struct file
*file
,
184 const char __user
*user_buf
,
185 size_t count
, loff_t
*ppos
)
194 if (get_user(c
, user_buf
)) {
200 struct seq_file
*seqf
= file
->private_data
;
201 struct kvm_vcpu
*vcpu
= seqf
->private;
202 /* Write does not affect our buffers previously generated with
203 * show. seq_file is locked here to prevent races of init with
205 mutex_lock(&seqf
->lock
);
206 kvmppc_init_timing_stats(vcpu
);
207 mutex_unlock(&seqf
->lock
);
215 static int kvmppc_exit_timing_open(struct inode
*inode
, struct file
*file
)
217 return single_open(file
, kvmppc_exit_timing_show
, inode
->i_private
);
220 static const struct file_operations kvmppc_exit_timing_fops
= {
221 .owner
= THIS_MODULE
,
222 .open
= kvmppc_exit_timing_open
,
224 .write
= kvmppc_exit_timing_write
,
226 .release
= single_release
,
229 void kvmppc_create_vcpu_debugfs(struct kvm_vcpu
*vcpu
, unsigned int id
)
231 static char dbg_fname
[50];
232 struct dentry
*debugfs_file
;
234 snprintf(dbg_fname
, sizeof(dbg_fname
), "vm%u_vcpu%u_timing",
236 debugfs_file
= debugfs_create_file(dbg_fname
, 0666,
237 kvm_debugfs_dir
, vcpu
,
238 &kvmppc_exit_timing_fops
);
241 printk(KERN_ERR
"%s: error creating debugfs file %s\n",
242 __func__
, dbg_fname
);
246 vcpu
->arch
.debugfs_exit_timing
= debugfs_file
;
249 void kvmppc_remove_vcpu_debugfs(struct kvm_vcpu
*vcpu
)
251 if (vcpu
->arch
.debugfs_exit_timing
) {
252 debugfs_remove(vcpu
->arch
.debugfs_exit_timing
);
253 vcpu
->arch
.debugfs_exit_timing
= NULL
;