blob: d9156ceecdff03ca0d55ab2834df0d4f7e828203 [file] [log] [blame]
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -02001/* KVM paravirtual clock driver. A clocksource implementation
2 Copyright (C) 2008 Glauber de Oliveira Costa, Red Hat Inc.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17*/
18
19#include <linux/clocksource.h>
20#include <linux/kvm_para.h>
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020021#include <asm/pvclock.h>
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020022#include <asm/msr.h>
23#include <asm/apic.h>
24#include <linux/percpu.h>
Eric B Munson3b5d56b2012-03-10 14:37:26 -050025#include <linux/hardirq.h>
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020026#include <linux/memblock.h>
Thomas Gleixner736deca2009-08-19 12:35:53 +020027
28#include <asm/x86_init.h>
Glauber Costa1e977aa2008-03-17 16:08:40 -030029#include <asm/reboot.h>
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020030
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020031static int kvmclock = 1;
Glauber Costa838815a2010-05-11 12:17:44 -040032static int msr_kvm_system_time = MSR_KVM_SYSTEM_TIME;
33static int msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020034
35static int parse_no_kvmclock(char *arg)
36{
37 kvmclock = 0;
38 return 0;
39}
40early_param("no-kvmclock", parse_no_kvmclock);
41
42/* The hypervisor will put information about time periodically here */
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -020043static struct pvclock_vsyscall_time_info *hv_clock;
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020044static struct pvclock_wall_clock wall_clock;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020045
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020046/*
47 * The wallclock is the time of day when we booted. Since then, some time may
48 * have elapsed since the hypervisor wrote the data. So we try to account for
49 * that with system time
50 */
David Vrabel35651842013-05-13 18:56:06 +010051static void kvm_get_wallclock(struct timespec *now)
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020052{
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020053 struct pvclock_vcpu_time_info *vcpu_time;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020054 int low, high;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020055 int cpu;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020056
Glauber Costaa20316d2009-08-31 03:04:31 -040057 low = (int)__pa_symbol(&wall_clock);
58 high = ((u64)__pa_symbol(&wall_clock) >> 32);
Glauber Costa838815a2010-05-11 12:17:44 -040059
60 native_write_msr(msr_kvm_wall_clock, low, high);
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020061
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020062 preempt_disable();
63 cpu = smp_processor_id();
64
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -020065 vcpu_time = &hv_clock[cpu].pvti;
David Vrabel35651842013-05-13 18:56:06 +010066 pvclock_read_wallclock(&wall_clock, vcpu_time, now);
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020067
68 preempt_enable();
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020069}
70
David Vrabel35651842013-05-13 18:56:06 +010071static int kvm_set_wallclock(const struct timespec *now)
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020072{
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020073 return -1;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020074}
75
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020076static cycle_t kvm_clock_read(void)
77{
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020078 struct pvclock_vcpu_time_info *src;
79 cycle_t ret;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020080 int cpu;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020081
Avi Kivity95ef1e52011-11-15 14:59:07 +020082 preempt_disable_notrace();
Marcelo Tosatti7069ed62012-11-27 23:28:48 -020083 cpu = smp_processor_id();
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -020084 src = &hv_clock[cpu].pvti;
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020085 ret = pvclock_clocksource_read(src);
Avi Kivity95ef1e52011-11-15 14:59:07 +020086 preempt_enable_notrace();
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020087 return ret;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020088}
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +020089
Magnus Damm8e196082009-04-21 12:24:00 -070090static cycle_t kvm_clock_get_cycles(struct clocksource *cs)
91{
92 return kvm_clock_read();
93}
94
Glauber Costa02936152008-07-28 11:47:53 -030095/*
96 * If we don't do that, there is the possibility that the guest
97 * will calibrate under heavy load - thus, getting a lower lpj -
98 * and execute the delays themselves without load. This is wrong,
99 * because no delay loop can finish beforehand.
100 * Any heuristics is subject to fail, because ultimately, a large
101 * poll of guests can be running and trouble each other. So we preset
102 * lpj here
103 */
104static unsigned long kvm_get_tsc_khz(void)
105{
Eduardo Habkoste93353c92008-12-05 18:36:45 -0200106 struct pvclock_vcpu_time_info *src;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200107 int cpu;
108 unsigned long tsc_khz;
109
110 preempt_disable();
111 cpu = smp_processor_id();
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -0200112 src = &hv_clock[cpu].pvti;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200113 tsc_khz = pvclock_tsc_khz(src);
114 preempt_enable();
115 return tsc_khz;
Glauber Costa02936152008-07-28 11:47:53 -0300116}
117
118static void kvm_get_preset_lpj(void)
119{
Glauber Costa02936152008-07-28 11:47:53 -0300120 unsigned long khz;
121 u64 lpj;
122
Eduardo Habkoste93353c92008-12-05 18:36:45 -0200123 khz = kvm_get_tsc_khz();
Glauber Costa02936152008-07-28 11:47:53 -0300124
125 lpj = ((u64)khz * 1000);
126 do_div(lpj, HZ);
127 preset_lpj = lpj;
128}
129
Eric B Munson3b5d56b2012-03-10 14:37:26 -0500130bool kvm_check_and_clear_guest_paused(void)
131{
132 bool ret = false;
133 struct pvclock_vcpu_time_info *src;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200134 int cpu = smp_processor_id();
Eric B Munson3b5d56b2012-03-10 14:37:26 -0500135
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200136 if (!hv_clock)
137 return ret;
138
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -0200139 src = &hv_clock[cpu].pvti;
Eric B Munson3b5d56b2012-03-10 14:37:26 -0500140 if ((src->flags & PVCLOCK_GUEST_STOPPED) != 0) {
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200141 src->flags &= ~PVCLOCK_GUEST_STOPPED;
Marcelo Tosattid63285e2013-10-11 21:39:25 -0300142 pvclock_touch_watchdogs();
Eric B Munson3b5d56b2012-03-10 14:37:26 -0500143 ret = true;
144 }
145
146 return ret;
147}
Eric B Munson3b5d56b2012-03-10 14:37:26 -0500148
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200149static struct clocksource kvm_clock = {
150 .name = "kvm-clock",
Magnus Damm8e196082009-04-21 12:24:00 -0700151 .read = kvm_clock_get_cycles,
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200152 .rating = 400,
153 .mask = CLOCKSOURCE_MASK(64),
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200154 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
155};
156
Gleb Natapovca3f1012010-10-14 11:22:49 +0200157int kvm_register_clock(char *txt)
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200158{
159 int cpu = smp_processor_id();
Arjan Koers19b6a852010-08-02 23:35:28 +0200160 int low, high, ret;
Jan Kiszkafe1140c2013-02-23 17:05:29 +0100161 struct pvclock_vcpu_time_info *src;
Arjan Koers19b6a852010-08-02 23:35:28 +0200162
Jan Kiszkafe1140c2013-02-23 17:05:29 +0100163 if (!hv_clock)
164 return 0;
165
166 src = &hv_clock[cpu].pvti;
Dave Hansen5dfd4862013-01-22 13:24:35 -0800167 low = (int)slow_virt_to_phys(src) | 1;
168 high = ((u64)slow_virt_to_phys(src) >> 32);
Arjan Koers19b6a852010-08-02 23:35:28 +0200169 ret = native_write_msr_safe(msr_kvm_system_time, low, high);
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +0200170 printk(KERN_INFO "kvm-clock: cpu %d, msr %x:%x, %s\n",
171 cpu, high, low, txt);
Glauber Costa838815a2010-05-11 12:17:44 -0400172
Arjan Koers19b6a852010-08-02 23:35:28 +0200173 return ret;
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200174}
175
Marcelo Tosattib74f05d62012-02-13 11:07:27 -0200176static void kvm_save_sched_clock_state(void)
177{
178}
179
180static void kvm_restore_sched_clock_state(void)
181{
182 kvm_register_clock("primary cpu clock, resume");
183}
184
Glauber Costab8ba5f12008-04-30 12:39:05 -0300185#ifdef CONFIG_X86_LOCAL_APIC
Paul Gortmaker148f9bb2013-06-18 18:23:59 -0400186static void kvm_setup_secondary_clock(void)
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200187{
188 /*
189 * Now that the first cpu already had this clocksource initialized,
190 * we shouldn't fail.
191 */
Gerd Hoffmannf6e16d52008-06-03 16:17:32 +0200192 WARN_ON(kvm_register_clock("secondary cpu clock"));
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200193}
Glauber Costab8ba5f12008-04-30 12:39:05 -0300194#endif
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200195
Glauber Costa1e977aa2008-03-17 16:08:40 -0300196/*
197 * After the clock is registered, the host will keep writing to the
198 * registered memory location. If the guest happens to shutdown, this memory
199 * won't be valid. In cases like kexec, in which you install a new kernel, this
200 * means a random memory location will be kept being written. So before any
201 * kind of shutdown from our side, we unregister the clock by writting anything
202 * that does not have the 'enable' bit set in the msr
203 */
204#ifdef CONFIG_KEXEC
205static void kvm_crash_shutdown(struct pt_regs *regs)
206{
Glauber Costa838815a2010-05-11 12:17:44 -0400207 native_write_msr(msr_kvm_system_time, 0, 0);
Glauber Costad910f5c2011-07-11 15:28:19 -0400208 kvm_disable_steal_time();
Glauber Costa1e977aa2008-03-17 16:08:40 -0300209 native_machine_crash_shutdown(regs);
210}
211#endif
212
213static void kvm_shutdown(void)
214{
Glauber Costa838815a2010-05-11 12:17:44 -0400215 native_write_msr(msr_kvm_system_time, 0, 0);
Glauber Costad910f5c2011-07-11 15:28:19 -0400216 kvm_disable_steal_time();
Glauber Costa1e977aa2008-03-17 16:08:40 -0300217 native_machine_shutdown();
218}
219
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200220void __init kvmclock_init(void)
221{
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200222 unsigned long mem;
Marcelo Tosattied557052013-02-18 22:58:14 -0300223 int size;
224
225 size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200226
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200227 if (!kvm_para_available())
228 return;
229
Glauber Costa838815a2010-05-11 12:17:44 -0400230 if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE2)) {
231 msr_kvm_system_time = MSR_KVM_SYSTEM_TIME_NEW;
232 msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK_NEW;
233 } else if (!(kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)))
234 return;
235
236 printk(KERN_INFO "kvm-clock: Using msrs %x and %x",
237 msr_kvm_system_time, msr_kvm_wall_clock);
238
Marcelo Tosattied557052013-02-18 22:58:14 -0300239 mem = memblock_alloc(size, PAGE_SIZE);
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200240 if (!mem)
Glauber Costa838815a2010-05-11 12:17:44 -0400241 return;
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200242 hv_clock = __va(mem);
Igor Mammedov07868fc2013-06-10 18:31:11 +0200243 memset(hv_clock, 0, size);
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200244
Fernando Luis Vázquez Cao0d75de42014-02-18 19:09:11 +0900245 if (kvm_register_clock("primary cpu clock")) {
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200246 hv_clock = NULL;
Marcelo Tosattied557052013-02-18 22:58:14 -0300247 memblock_free(mem, size);
Marcelo Tosatti7069ed62012-11-27 23:28:48 -0200248 return;
249 }
Glauber Costa838815a2010-05-11 12:17:44 -0400250 pv_time_ops.sched_clock = kvm_clock_read;
251 x86_platform.calibrate_tsc = kvm_get_tsc_khz;
252 x86_platform.get_wallclock = kvm_get_wallclock;
253 x86_platform.set_wallclock = kvm_set_wallclock;
Glauber Costab8ba5f12008-04-30 12:39:05 -0300254#ifdef CONFIG_X86_LOCAL_APIC
Igor Mammedovdf156f92012-02-07 15:52:44 +0100255 x86_cpuinit.early_percpu_clock_init =
Glauber Costa838815a2010-05-11 12:17:44 -0400256 kvm_setup_secondary_clock;
Glauber Costab8ba5f12008-04-30 12:39:05 -0300257#endif
Marcelo Tosattib74f05d62012-02-13 11:07:27 -0200258 x86_platform.save_sched_clock_state = kvm_save_sched_clock_state;
259 x86_platform.restore_sched_clock_state = kvm_restore_sched_clock_state;
Glauber Costa838815a2010-05-11 12:17:44 -0400260 machine_ops.shutdown = kvm_shutdown;
Glauber Costa1e977aa2008-03-17 16:08:40 -0300261#ifdef CONFIG_KEXEC
Glauber Costa838815a2010-05-11 12:17:44 -0400262 machine_ops.crash_shutdown = kvm_crash_shutdown;
Glauber Costa1e977aa2008-03-17 16:08:40 -0300263#endif
Glauber Costa838815a2010-05-11 12:17:44 -0400264 kvm_get_preset_lpj();
John Stultzb01cc1b2010-04-26 19:03:05 -0700265 clocksource_register_hz(&kvm_clock, NSEC_PER_SEC);
Glauber Costa838815a2010-05-11 12:17:44 -0400266 pv_info.paravirt_enabled = 1;
267 pv_info.name = "KVM";
Glauber Costa3a0d7252010-05-11 12:17:45 -0400268
269 if (kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE_STABLE_BIT))
270 pvclock_set_flags(PVCLOCK_TSC_STABLE_BIT);
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200271}
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -0200272
273int __init kvm_setup_vsyscall_timeinfo(void)
274{
275#ifdef CONFIG_X86_64
276 int cpu;
277 int ret;
278 u8 flags;
279 struct pvclock_vcpu_time_info *vcpu_time;
280 unsigned int size;
281
Jan Kiszkafe1140c2013-02-23 17:05:29 +0100282 if (!hv_clock)
283 return 0;
284
Marcelo Tosattied557052013-02-18 22:58:14 -0300285 size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);
Marcelo Tosatti3dc4f7c2012-11-27 23:28:56 -0200286
287 preempt_disable();
288 cpu = smp_processor_id();
289
290 vcpu_time = &hv_clock[cpu].pvti;
291 flags = pvclock_read_flags(vcpu_time);
292
293 if (!(flags & PVCLOCK_TSC_STABLE_BIT)) {
294 preempt_enable();
295 return 1;
296 }
297
298 if ((ret = pvclock_init_vsyscall(hv_clock, size))) {
299 preempt_enable();
300 return ret;
301 }
302
303 preempt_enable();
304
305 kvm_clock.archdata.vclock_mode = VCLOCK_PVCLOCK;
306#endif
307 return 0;
308}