137f2e8132df1b0f5ac953134a5e0f727573edbe
[linux-2.6.git] / arch / x86 / kernel / kvmclock.c
1 /*  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>
21 #include <asm/pvclock.h>
22 #include <asm/msr.h>
23 #include <asm/apic.h>
24 #include <linux/percpu.h>
25 #include <asm/reboot.h>
26
27 #define KVM_SCALE 22
28
29 static int kvmclock = 1;
30
31 static int parse_no_kvmclock(char *arg)
32 {
33         kvmclock = 0;
34         return 0;
35 }
36 early_param("no-kvmclock", parse_no_kvmclock);
37
38 /* The hypervisor will put information about time periodically here */
39 static DEFINE_PER_CPU_SHARED_ALIGNED(struct pvclock_vcpu_time_info, hv_clock);
40 static struct pvclock_wall_clock wall_clock;
41
42 /*
43  * The wallclock is the time of day when we booted. Since then, some time may
44  * have elapsed since the hypervisor wrote the data. So we try to account for
45  * that with system time
46  */
47 static unsigned long kvm_get_wallclock(void)
48 {
49         struct pvclock_vcpu_time_info *vcpu_time;
50         struct timespec ts;
51         int low, high;
52
53         low = (int)__pa(&wall_clock);
54         high = ((u64)__pa(&wall_clock) >> 32);
55         native_write_msr(MSR_KVM_WALL_CLOCK, low, high);
56
57         vcpu_time = &get_cpu_var(hv_clock);
58         pvclock_read_wallclock(&wall_clock, vcpu_time, &ts);
59         put_cpu_var(hv_clock);
60
61         return ts.tv_sec;
62 }
63
64 static int kvm_set_wallclock(unsigned long now)
65 {
66         return -1;
67 }
68
69 static cycle_t kvm_clock_read(void)
70 {
71         struct pvclock_vcpu_time_info *src;
72         cycle_t ret;
73
74         src = &get_cpu_var(hv_clock);
75         ret = pvclock_clocksource_read(src);
76         put_cpu_var(hv_clock);
77         return ret;
78 }
79
80 /*
81  * If we don't do that, there is the possibility that the guest
82  * will calibrate under heavy load - thus, getting a lower lpj -
83  * and execute the delays themselves without load. This is wrong,
84  * because no delay loop can finish beforehand.
85  * Any heuristics is subject to fail, because ultimately, a large
86  * poll of guests can be running and trouble each other. So we preset
87  * lpj here
88  */
89 static unsigned long kvm_get_tsc_khz(void)
90 {
91         struct pvclock_vcpu_time_info *src;
92         src = &per_cpu(hv_clock, 0);
93         return pvclock_tsc_khz(src);
94 }
95
96 static void kvm_get_preset_lpj(void)
97 {
98         unsigned long khz;
99         u64 lpj;
100
101         khz = kvm_get_tsc_khz();
102
103         lpj = ((u64)khz * 1000);
104         do_div(lpj, HZ);
105         preset_lpj = lpj;
106 }
107
108 static struct clocksource kvm_clock = {
109         .name = "kvm-clock",
110         .read = kvm_clock_read,
111         .rating = 400,
112         .mask = CLOCKSOURCE_MASK(64),
113         .mult = 1 << KVM_SCALE,
114         .shift = KVM_SCALE,
115         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
116 };
117
118 static int kvm_register_clock(char *txt)
119 {
120         int cpu = smp_processor_id();
121         int low, high;
122         low = (int)__pa(&per_cpu(hv_clock, cpu)) | 1;
123         high = ((u64)__pa(&per_cpu(hv_clock, cpu)) >> 32);
124         printk(KERN_INFO "kvm-clock: cpu %d, msr %x:%x, %s\n",
125                cpu, high, low, txt);
126         return native_write_msr_safe(MSR_KVM_SYSTEM_TIME, low, high);
127 }
128
129 #ifdef CONFIG_X86_LOCAL_APIC
130 static void __cpuinit kvm_setup_secondary_clock(void)
131 {
132         /*
133          * Now that the first cpu already had this clocksource initialized,
134          * we shouldn't fail.
135          */
136         WARN_ON(kvm_register_clock("secondary cpu clock"));
137         /* ok, done with our trickery, call native */
138         setup_secondary_APIC_clock();
139 }
140 #endif
141
142 #ifdef CONFIG_SMP
143 static void __init kvm_smp_prepare_boot_cpu(void)
144 {
145         WARN_ON(kvm_register_clock("primary cpu clock"));
146         native_smp_prepare_boot_cpu();
147 }
148 #endif
149
150 /*
151  * After the clock is registered, the host will keep writing to the
152  * registered memory location. If the guest happens to shutdown, this memory
153  * won't be valid. In cases like kexec, in which you install a new kernel, this
154  * means a random memory location will be kept being written. So before any
155  * kind of shutdown from our side, we unregister the clock by writting anything
156  * that does not have the 'enable' bit set in the msr
157  */
158 #ifdef CONFIG_KEXEC
159 static void kvm_crash_shutdown(struct pt_regs *regs)
160 {
161         native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
162         native_machine_crash_shutdown(regs);
163 }
164 #endif
165
166 static void kvm_shutdown(void)
167 {
168         native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
169         native_machine_shutdown();
170 }
171
172 void __init kvmclock_init(void)
173 {
174         if (!kvm_para_available())
175                 return;
176
177         if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)) {
178                 if (kvm_register_clock("boot clock"))
179                         return;
180                 pv_time_ops.get_wallclock = kvm_get_wallclock;
181                 pv_time_ops.set_wallclock = kvm_set_wallclock;
182                 pv_time_ops.sched_clock = kvm_clock_read;
183                 pv_time_ops.get_tsc_khz = kvm_get_tsc_khz;
184 #ifdef CONFIG_X86_LOCAL_APIC
185                 pv_apic_ops.setup_secondary_clock = kvm_setup_secondary_clock;
186 #endif
187 #ifdef CONFIG_SMP
188                 smp_ops.smp_prepare_boot_cpu = kvm_smp_prepare_boot_cpu;
189 #endif
190                 machine_ops.shutdown  = kvm_shutdown;
191 #ifdef CONFIG_KEXEC
192                 machine_ops.crash_shutdown  = kvm_crash_shutdown;
193 #endif
194                 kvm_get_preset_lpj();
195                 clocksource_register(&kvm_clock);
196                 pv_info.paravirt_enabled = 1;
197                 pv_info.name = "KVM";
198         }
199 }