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