clocksource: pass clocksource to read() callback
[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 static cycle_t kvm_clock_get_cycles(struct clocksource *cs)
81 {
82         return kvm_clock_read();
83 }
84
85 /*
86  * If we don't do that, there is the possibility that the guest
87  * will calibrate under heavy load - thus, getting a lower lpj -
88  * and execute the delays themselves without load. This is wrong,
89  * because no delay loop can finish beforehand.
90  * Any heuristics is subject to fail, because ultimately, a large
91  * poll of guests can be running and trouble each other. So we preset
92  * lpj here
93  */
94 static unsigned long kvm_get_tsc_khz(void)
95 {
96         struct pvclock_vcpu_time_info *src;
97         src = &per_cpu(hv_clock, 0);
98         return pvclock_tsc_khz(src);
99 }
100
101 static void kvm_get_preset_lpj(void)
102 {
103         unsigned long khz;
104         u64 lpj;
105
106         khz = kvm_get_tsc_khz();
107
108         lpj = ((u64)khz * 1000);
109         do_div(lpj, HZ);
110         preset_lpj = lpj;
111 }
112
113 static struct clocksource kvm_clock = {
114         .name = "kvm-clock",
115         .read = kvm_clock_get_cycles,
116         .rating = 400,
117         .mask = CLOCKSOURCE_MASK(64),
118         .mult = 1 << KVM_SCALE,
119         .shift = KVM_SCALE,
120         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
121 };
122
123 static int kvm_register_clock(char *txt)
124 {
125         int cpu = smp_processor_id();
126         int low, high;
127         low = (int)__pa(&per_cpu(hv_clock, cpu)) | 1;
128         high = ((u64)__pa(&per_cpu(hv_clock, cpu)) >> 32);
129         printk(KERN_INFO "kvm-clock: cpu %d, msr %x:%x, %s\n",
130                cpu, high, low, txt);
131         return native_write_msr_safe(MSR_KVM_SYSTEM_TIME, low, high);
132 }
133
134 #ifdef CONFIG_X86_LOCAL_APIC
135 static void __cpuinit kvm_setup_secondary_clock(void)
136 {
137         /*
138          * Now that the first cpu already had this clocksource initialized,
139          * we shouldn't fail.
140          */
141         WARN_ON(kvm_register_clock("secondary cpu clock"));
142         /* ok, done with our trickery, call native */
143         setup_secondary_APIC_clock();
144 }
145 #endif
146
147 #ifdef CONFIG_SMP
148 static void __init kvm_smp_prepare_boot_cpu(void)
149 {
150         WARN_ON(kvm_register_clock("primary cpu clock"));
151         native_smp_prepare_boot_cpu();
152 }
153 #endif
154
155 /*
156  * After the clock is registered, the host will keep writing to the
157  * registered memory location. If the guest happens to shutdown, this memory
158  * won't be valid. In cases like kexec, in which you install a new kernel, this
159  * means a random memory location will be kept being written. So before any
160  * kind of shutdown from our side, we unregister the clock by writting anything
161  * that does not have the 'enable' bit set in the msr
162  */
163 #ifdef CONFIG_KEXEC
164 static void kvm_crash_shutdown(struct pt_regs *regs)
165 {
166         native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
167         native_machine_crash_shutdown(regs);
168 }
169 #endif
170
171 static void kvm_shutdown(void)
172 {
173         native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
174         native_machine_shutdown();
175 }
176
177 void __init kvmclock_init(void)
178 {
179         if (!kvm_para_available())
180                 return;
181
182         if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)) {
183                 if (kvm_register_clock("boot clock"))
184                         return;
185                 pv_time_ops.get_wallclock = kvm_get_wallclock;
186                 pv_time_ops.set_wallclock = kvm_set_wallclock;
187                 pv_time_ops.sched_clock = kvm_clock_read;
188                 pv_time_ops.get_tsc_khz = kvm_get_tsc_khz;
189 #ifdef CONFIG_X86_LOCAL_APIC
190                 pv_apic_ops.setup_secondary_clock = kvm_setup_secondary_clock;
191 #endif
192 #ifdef CONFIG_SMP
193                 smp_ops.smp_prepare_boot_cpu = kvm_smp_prepare_boot_cpu;
194 #endif
195                 machine_ops.shutdown  = kvm_shutdown;
196 #ifdef CONFIG_KEXEC
197                 machine_ops.crash_shutdown  = kvm_crash_shutdown;
198 #endif
199                 kvm_get_preset_lpj();
200                 clocksource_register(&kvm_clock);
201                 pv_info.paravirt_enabled = 1;
202                 pv_info.name = "KVM";
203         }
204 }