~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/kernel/kvmclock.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <linux/hardirq.h>
 26 #include <linux/memblock.h>
 27 #include <linux/sched.h>
 28 
 29 #include <asm/x86_init.h>
 30 #include <asm/reboot.h>
 31 
 32 static int kvmclock = 1;
 33 static int msr_kvm_system_time = MSR_KVM_SYSTEM_TIME;
 34 static int msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK;
 35 
 36 static int parse_no_kvmclock(char *arg)
 37 {
 38         kvmclock = 0;
 39         return 0;
 40 }
 41 early_param("no-kvmclock", parse_no_kvmclock);
 42 
 43 /* The hypervisor will put information about time periodically here */
 44 static struct pvclock_vsyscall_time_info *hv_clock;
 45 static struct pvclock_wall_clock wall_clock;
 46 
 47 /*
 48  * The wallclock is the time of day when we booted. Since then, some time may
 49  * have elapsed since the hypervisor wrote the data. So we try to account for
 50  * that with system time
 51  */
 52 static void kvm_get_wallclock(struct timespec *now)
 53 {
 54         struct pvclock_vcpu_time_info *vcpu_time;
 55         int low, high;
 56         int cpu;
 57 
 58         low = (int)__pa_symbol(&wall_clock);
 59         high = ((u64)__pa_symbol(&wall_clock) >> 32);
 60 
 61         native_write_msr(msr_kvm_wall_clock, low, high);
 62 
 63         cpu = get_cpu();
 64 
 65         vcpu_time = &hv_clock[cpu].pvti;
 66         pvclock_read_wallclock(&wall_clock, vcpu_time, now);
 67 
 68         put_cpu();
 69 }
 70 
 71 static int kvm_set_wallclock(const struct timespec *now)
 72 {
 73         return -1;
 74 }
 75 
 76 static cycle_t kvm_clock_read(void)
 77 {
 78         struct pvclock_vcpu_time_info *src;
 79         cycle_t ret;
 80         int cpu;
 81 
 82         preempt_disable_notrace();
 83         cpu = smp_processor_id();
 84         src = &hv_clock[cpu].pvti;
 85         ret = pvclock_clocksource_read(src);
 86         preempt_enable_notrace();
 87         return ret;
 88 }
 89 
 90 static cycle_t kvm_clock_get_cycles(struct clocksource *cs)
 91 {
 92         return kvm_clock_read();
 93 }
 94 
 95 /*
 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  */
104 static unsigned long kvm_get_tsc_khz(void)
105 {
106         struct pvclock_vcpu_time_info *src;
107         int cpu;
108         unsigned long tsc_khz;
109 
110         cpu = get_cpu();
111         src = &hv_clock[cpu].pvti;
112         tsc_khz = pvclock_tsc_khz(src);
113         put_cpu();
114         return tsc_khz;
115 }
116 
117 static void kvm_get_preset_lpj(void)
118 {
119         unsigned long khz;
120         u64 lpj;
121 
122         khz = kvm_get_tsc_khz();
123 
124         lpj = ((u64)khz * 1000);
125         do_div(lpj, HZ);
126         preset_lpj = lpj;
127 }
128 
129 bool kvm_check_and_clear_guest_paused(void)
130 {
131         bool ret = false;
132         struct pvclock_vcpu_time_info *src;
133         int cpu = smp_processor_id();
134 
135         if (!hv_clock)
136                 return ret;
137 
138         src = &hv_clock[cpu].pvti;
139         if ((src->flags & PVCLOCK_GUEST_STOPPED) != 0) {
140                 src->flags &= ~PVCLOCK_GUEST_STOPPED;
141                 pvclock_touch_watchdogs();
142                 ret = true;
143         }
144 
145         return ret;
146 }
147 
148 static struct clocksource kvm_clock = {
149         .name = "kvm-clock",
150         .read = kvm_clock_get_cycles,
151         .rating = 400,
152         .mask = CLOCKSOURCE_MASK(64),
153         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
154 };
155 
156 int kvm_register_clock(char *txt)
157 {
158         int cpu = smp_processor_id();
159         int low, high, ret;
160         struct pvclock_vcpu_time_info *src;
161 
162         if (!hv_clock)
163                 return 0;
164 
165         src = &hv_clock[cpu].pvti;
166         low = (int)slow_virt_to_phys(src) | 1;
167         high = ((u64)slow_virt_to_phys(src) >> 32);
168         ret = native_write_msr_safe(msr_kvm_system_time, low, high);
169         printk(KERN_INFO "kvm-clock: cpu %d, msr %x:%x, %s\n",
170                cpu, high, low, txt);
171 
172         return ret;
173 }
174 
175 static void kvm_save_sched_clock_state(void)
176 {
177 }
178 
179 static void kvm_restore_sched_clock_state(void)
180 {
181         kvm_register_clock("primary cpu clock, resume");
182 }
183 
184 #ifdef CONFIG_X86_LOCAL_APIC
185 static void kvm_setup_secondary_clock(void)
186 {
187         /*
188          * Now that the first cpu already had this clocksource initialized,
189          * we shouldn't fail.
190          */
191         WARN_ON(kvm_register_clock("secondary cpu clock"));
192 }
193 #endif
194 
195 /*
196  * After the clock is registered, the host will keep writing to the
197  * registered memory location. If the guest happens to shutdown, this memory
198  * won't be valid. In cases like kexec, in which you install a new kernel, this
199  * means a random memory location will be kept being written. So before any
200  * kind of shutdown from our side, we unregister the clock by writting anything
201  * that does not have the 'enable' bit set in the msr
202  */
203 #ifdef CONFIG_KEXEC
204 static void kvm_crash_shutdown(struct pt_regs *regs)
205 {
206         native_write_msr(msr_kvm_system_time, 0, 0);
207         kvm_disable_steal_time();
208         native_machine_crash_shutdown(regs);
209 }
210 #endif
211 
212 static void kvm_shutdown(void)
213 {
214         native_write_msr(msr_kvm_system_time, 0, 0);
215         kvm_disable_steal_time();
216         native_machine_shutdown();
217 }
218 
219 void __init kvmclock_init(void)
220 {
221         struct pvclock_vcpu_time_info *vcpu_time;
222         unsigned long mem;
223         int size, cpu;
224         u8 flags;
225 
226         size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);
227 
228         if (!kvm_para_available())
229                 return;
230 
231         if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE2)) {
232                 msr_kvm_system_time = MSR_KVM_SYSTEM_TIME_NEW;
233                 msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK_NEW;
234         } else if (!(kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)))
235                 return;
236 
237         printk(KERN_INFO "kvm-clock: Using msrs %x and %x",
238                 msr_kvm_system_time, msr_kvm_wall_clock);
239 
240         mem = memblock_alloc(size, PAGE_SIZE);
241         if (!mem)
242                 return;
243         hv_clock = __va(mem);
244         memset(hv_clock, 0, size);
245 
246         if (kvm_register_clock("primary cpu clock")) {
247                 hv_clock = NULL;
248                 memblock_free(mem, size);
249                 return;
250         }
251         pv_time_ops.sched_clock = kvm_clock_read;
252         x86_platform.calibrate_tsc = kvm_get_tsc_khz;
253         x86_platform.get_wallclock = kvm_get_wallclock;
254         x86_platform.set_wallclock = kvm_set_wallclock;
255 #ifdef CONFIG_X86_LOCAL_APIC
256         x86_cpuinit.early_percpu_clock_init =
257                 kvm_setup_secondary_clock;
258 #endif
259         x86_platform.save_sched_clock_state = kvm_save_sched_clock_state;
260         x86_platform.restore_sched_clock_state = kvm_restore_sched_clock_state;
261         machine_ops.shutdown  = kvm_shutdown;
262 #ifdef CONFIG_KEXEC
263         machine_ops.crash_shutdown  = kvm_crash_shutdown;
264 #endif
265         kvm_get_preset_lpj();
266         clocksource_register_hz(&kvm_clock, NSEC_PER_SEC);
267         pv_info.name = "KVM";
268 
269         if (kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE_STABLE_BIT))
270                 pvclock_set_flags(~0);
271 
272         cpu = get_cpu();
273         vcpu_time = &hv_clock[cpu].pvti;
274         flags = pvclock_read_flags(vcpu_time);
275         if (flags & PVCLOCK_COUNTS_FROM_ZERO)
276                 set_sched_clock_stable();
277         put_cpu();
278 }
279 
280 int __init kvm_setup_vsyscall_timeinfo(void)
281 {
282 #ifdef CONFIG_X86_64
283         int cpu;
284         int ret;
285         u8 flags;
286         struct pvclock_vcpu_time_info *vcpu_time;
287         unsigned int size;
288 
289         if (!hv_clock)
290                 return 0;
291 
292         size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);
293 
294         cpu = get_cpu();
295 
296         vcpu_time = &hv_clock[cpu].pvti;
297         flags = pvclock_read_flags(vcpu_time);
298 
299         if (!(flags & PVCLOCK_TSC_STABLE_BIT)) {
300                 put_cpu();
301                 return 1;
302         }
303 
304         if ((ret = pvclock_init_vsyscall(hv_clock, size))) {
305                 put_cpu();
306                 return ret;
307         }
308 
309         put_cpu();
310 
311         kvm_clock.archdata.vclock_mode = VCLOCK_PVCLOCK;
312 #endif
313         return 0;
314 }
315 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp