Release 4.7 arch/x86/kernel/kvmclock.c

Directory: arch/x86/kernel
/*  KVM paravirtual clock driver. A clocksource implementation
    Copyright (C) 2008 Glauber de Oliveira Costa, Red Hat Inc.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <linux/clocksource.h>
#include <linux/kvm_para.h>
#include <asm/pvclock.h>
#include <asm/msr.h>
#include <asm/apic.h>
#include <linux/percpu.h>
#include <linux/hardirq.h>
#include <linux/memblock.h>
#include <linux/sched.h>

#include <asm/x86_init.h>
#include <asm/reboot.h>


static int kvmclock = 1;

static int msr_kvm_system_time = MSR_KVM_SYSTEM_TIME;

static int msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK;

static cycle_t kvm_sched_clock_offset;



static int parse_no_kvmclock(char *arg)
{
	kvmclock = 0;
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%

early_param("no-kvmclock", parse_no_kvmclock);

/* The hypervisor will put information about time periodically here */

static struct pvclock_vsyscall_time_info *hv_clock;

static struct pvclock_wall_clock wall_clock;



struct pvclock_vsyscall_time_info *pvclock_pvti_cpu0_va(void)
{
	return hv_clock;
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%

/*
 * The wallclock is the time of day when we booted. Since then, some time may
 * have elapsed since the hypervisor wrote the data. So we try to account for
 * that with system time
 */


static void kvm_get_wallclock(struct timespec *now)
{
	struct pvclock_vcpu_time_info *vcpu_time;
	int low, high;
	int cpu;

	low = (int)__pa_symbol(&wall_clock);
	high = ((u64)__pa_symbol(&wall_clock) >> 32);

	native_write_msr(msr_kvm_wall_clock, low, high);

	cpu = get_cpu();

	vcpu_time = &hv_clock[cpu].pvti;
	pvclock_read_wallclock(&wall_clock, vcpu_time, now);

	put_cpu();
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 51 58.62% 1 11.11%
marcelo tosatti marcelo tosatti 13 14.94% 2 22.22%
gerd hoffmann gerd hoffmann 11 12.64% 1 11.11%
david vrabel david vrabel 6 6.90% 1 11.11%
glauber costa glauber costa 3 3.45% 2 22.22%
tiejun chen tiejun chen 2 2.30% 1 11.11%
ingo molnar ingo molnar 1 1.15% 1 11.11%
Total 87 100.00% 9 100.00%



static int kvm_set_wallclock(const struct timespec *now)
{
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 9 56.25% 1 25.00%
david vrabel david vrabel 4 25.00% 1 25.00%
gerd hoffmann gerd hoffmann 2 12.50% 1 25.00%
ingo molnar ingo molnar 1 6.25% 1 25.00%
Total 16 100.00% 4 100.00%



static cycle_t kvm_clock_read(void)
{
	struct pvclock_vcpu_time_info *src;
	cycle_t ret;
	int cpu;

	preempt_disable_notrace();
	cpu = smp_processor_id();
	src = &hv_clock[cpu].pvti;
	ret = pvclock_clocksource_read(src);
	preempt_enable_notrace();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 19 38.00% 1 20.00%
gerd hoffmann gerd hoffmann 13 26.00% 1 20.00%
marcelo tosatti marcelo tosatti 13 26.00% 2 40.00%
avi kivity avi kivity 5 10.00% 1 20.00%
Total 50 100.00% 5 100.00%



static cycle_t kvm_clock_get_cycles(struct clocksource *cs)
{
	return kvm_clock_read();
}

Contributors
Person Tokens Prop Commits CommitProp
magnus damm magnus damm 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static cycle_t kvm_sched_clock_read(void)
{
	return kvm_clock_read() - kvm_sched_clock_offset;
}

Contributors
Person Tokens Prop Commits CommitProp
radim krcmar radim krcmar 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



static inline void kvm_sched_clock_init(bool stable)
{
	if (!stable) {
		pv_time_ops.sched_clock = kvm_clock_read;
		return;
	}

	kvm_sched_clock_offset = kvm_clock_read();
	pv_time_ops.sched_clock = kvm_sched_clock_read;
	set_sched_clock_stable();

	printk(KERN_INFO "kvm-clock: using sched offset of %llu cycles\n",
			kvm_sched_clock_offset);

	BUILD_BUG_ON(sizeof(kvm_sched_clock_offset) >
	         sizeof(((struct pvclock_vcpu_time_info *)NULL)->system_time));
}

Contributors
Person Tokens Prop Commits CommitProp
radim krcmar radim krcmar 68 100.00% 1 100.00%
Total 68 100.00% 1 100.00%

/*
 * If we don't do that, there is the possibility that the guest
 * will calibrate under heavy load - thus, getting a lower lpj -
 * and execute the delays themselves without load. This is wrong,
 * because no delay loop can finish beforehand.
 * Any heuristics is subject to fail, because ultimately, a large
 * poll of guests can be running and trouble each other. So we preset
 * lpj here
 */


static unsigned long kvm_get_tsc_khz(void)
{
	struct pvclock_vcpu_time_info *src;
	int cpu;
	unsigned long tsc_khz;

	cpu = get_cpu();
	src = &hv_clock[cpu].pvti;
	tsc_khz = pvclock_tsc_khz(src);
	put_cpu();
	return tsc_khz;
}

Contributors
Person Tokens Prop Commits CommitProp
marcelo tosatti marcelo tosatti 23 46.94% 2 40.00%
eduardo habkost eduardo habkost 14 28.57% 1 20.00%
glauber de oliveira costa glauber de oliveira costa 10 20.41% 1 20.00%
tiejun chen tiejun chen 2 4.08% 1 20.00%
Total 49 100.00% 5 100.00%



static void kvm_get_preset_lpj(void)
{
	unsigned long khz;
	u64 lpj;

	khz = kvm_get_tsc_khz();

	lpj = ((u64)khz * 1000);
	do_div(lpj, HZ);
	preset_lpj = lpj;
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 40 95.24% 1 50.00%
eduardo habkost eduardo habkost 2 4.76% 1 50.00%
Total 42 100.00% 2 100.00%



bool kvm_check_and_clear_guest_paused(void)
{
	bool ret = false;
	struct pvclock_vcpu_time_info *src;
	int cpu = smp_processor_id();

	if (!hv_clock)
		return ret;

	src = &hv_clock[cpu].pvti;
	if ((src->flags & PVCLOCK_GUEST_STOPPED) != 0) {
		src->flags &= ~PVCLOCK_GUEST_STOPPED;
		pvclock_touch_watchdogs();
		ret = true;
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric b munson eric b munson 47 65.28% 1 25.00%
marcelo tosatti marcelo tosatti 25 34.72% 3 75.00%
Total 72 100.00% 4 100.00%


static struct clocksource kvm_clock = {
	.name = "kvm-clock",
	.read = kvm_clock_get_cycles,
	.rating = 400,
	.mask = CLOCKSOURCE_MASK(64),
	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
};



int kvm_register_clock(char *txt)
{
	int cpu = smp_processor_id();
	int low, high, ret;
	struct pvclock_vcpu_time_info *src;

	if (!hv_clock)
		return 0;

	src = &hv_clock[cpu].pvti;
	low = (int)slow_virt_to_phys(src) | 1;
	high = ((u64)slow_virt_to_phys(src) >> 32);
	ret = native_write_msr_safe(msr_kvm_system_time, low, high);
	printk(KERN_INFO "kvm-clock: cpu %d, msr %x:%x, %s\n",
	       cpu, high, low, txt);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 41 41.41% 1 14.29%
gerd hoffmann gerd hoffmann 17 17.17% 1 14.29%
arjan koers arjan koers 14 14.14% 1 14.29%
marcelo tosatti marcelo tosatti 13 13.13% 2 28.57%
jan kiszka jan kiszka 12 12.12% 1 14.29%
dave hansen dave hansen 2 2.02% 1 14.29%
Total 99 100.00% 7 100.00%



static void kvm_save_sched_clock_state(void)
{
}

Contributors
Person Tokens Prop Commits CommitProp
marcelo tosatti marcelo tosatti 7 100.00% 1 100.00%
Total 7 100.00% 1 100.00%



static void kvm_restore_sched_clock_state(void)
{
	kvm_register_clock("primary cpu clock, resume");
}

Contributors
Person Tokens Prop Commits CommitProp
marcelo tosatti marcelo tosatti 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

#ifdef CONFIG_X86_LOCAL_APIC


static void kvm_setup_secondary_clock(void)
{
	/*
         * Now that the first cpu already had this clocksource initialized,
         * we shouldn't fail.
         */
	WARN_ON(kvm_register_clock("secondary cpu clock"));
}
Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 14 82.35% 1 50.00%
gerd hoffmann gerd hoffmann 3 17.65% 1 50.00%
Total 17 100.00% 2 100.00%

#endif

/*
 * After the clock is registered, the host will keep writing to the
 * registered memory location. If the guest happens to shutdown, this memory
 * won't be valid. In cases like kexec, in which you install a new kernel, this
 * means a random memory location will be kept being written. So before any
 * kind of shutdown from our side, we unregister the clock by writing anything
 * that does not have the 'enable' bit set in the msr
 */
#ifdef CONFIG_KEXEC_CORE


static void kvm_crash_shutdown(struct pt_regs *regs)
{
	native_write_msr(msr_kvm_system_time, 0, 0);
	kvm_disable_steal_time();
	native_machine_crash_shutdown(regs);
}
Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 23 82.14% 1 33.33%
glauber costa glauber costa 5 17.86% 2 66.67%
Total 28 100.00% 3 100.00%

#endif



static void kvm_shutdown(void)
{
	native_write_msr(msr_kvm_system_time, 0, 0);
	kvm_disable_steal_time();
	native_machine_shutdown();
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 18 78.26% 1 33.33%
glauber costa glauber costa 5 21.74% 2 66.67%
Total 23 100.00% 3 100.00%



void __init kvmclock_init(void)
{
	struct pvclock_vcpu_time_info *vcpu_time;
	unsigned long mem;
	int size, cpu;
	u8 flags;

	size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);

	if (!kvm_para_available())
		return;

	if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE2)) {
		msr_kvm_system_time = MSR_KVM_SYSTEM_TIME_NEW;
		msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK_NEW;
	} else if (!(kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)))
		return;

	printk(KERN_INFO "kvm-clock: Using msrs %x and %x",
		msr_kvm_system_time, msr_kvm_wall_clock);

	mem = memblock_alloc(size, PAGE_SIZE);
	if (!mem)
		return;
	hv_clock = __va(mem);
	memset(hv_clock, 0, size);

	if (kvm_register_clock("primary cpu clock")) {
		hv_clock = NULL;
		memblock_free(mem, size);
		return;
	}

	if (kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE_STABLE_BIT))
		pvclock_set_flags(PVCLOCK_TSC_STABLE_BIT);

	cpu = get_cpu();
	vcpu_time = &hv_clock[cpu].pvti;
	flags = pvclock_read_flags(vcpu_time);

	kvm_sched_clock_init(flags & PVCLOCK_TSC_STABLE_BIT);
	put_cpu();

	x86_platform.calibrate_tsc = kvm_get_tsc_khz;
	x86_platform.get_wallclock = kvm_get_wallclock;
	x86_platform.set_wallclock = kvm_set_wallclock;
#ifdef CONFIG_X86_LOCAL_APIC
	x86_cpuinit.early_percpu_clock_init =
		kvm_setup_secondary_clock;
#endif
	x86_platform.save_sched_clock_state = kvm_save_sched_clock_state;
	x86_platform.restore_sched_clock_state = kvm_restore_sched_clock_state;
	machine_ops.shutdown  = kvm_shutdown;
#ifdef CONFIG_KEXEC_CORE
	machine_ops.crash_shutdown  = kvm_crash_shutdown;
#endif
	kvm_get_preset_lpj();
	clocksource_register_hz(&kvm_clock, NSEC_PER_SEC);
	pv_info.name = "KVM";
}

Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 74 28.57% 4 20.00%
marcelo tosatti marcelo tosatti 67 25.87% 3 15.00%
radim krcmar radim krcmar 41 15.83% 1 5.00%
glauber costa glauber costa 40 15.44% 2 10.00%
luiz fernando capitulino luiz fernando capitulino 10 3.86% 1 5.00%
igor mammedov igor mammedov 10 3.86% 2 10.00%
feng tang feng tang 8 3.09% 1 5.00%
john stultz john stultz 3 1.16% 1 5.00%
gerd hoffmann gerd hoffmann 2 0.77% 1 5.00%
thomas gleixner thomas gleixner 2 0.77% 2 10.00%
dave young dave young 1 0.39% 1 5.00%
fernando luis vazquez cao fernando luis vazquez cao 1 0.39% 1 5.00%
Total 259 100.00% 20 100.00%



int __init kvm_setup_vsyscall_timeinfo(void)
{
#ifdef CONFIG_X86_64
	int cpu;
	u8 flags;
	struct pvclock_vcpu_time_info *vcpu_time;
	unsigned int size;

	if (!hv_clock)
		return 0;

	size = PAGE_ALIGN(sizeof(struct pvclock_vsyscall_time_info)*NR_CPUS);

	cpu = get_cpu();

	vcpu_time = &hv_clock[cpu].pvti;
	flags = pvclock_read_flags(vcpu_time);

	if (!(flags & PVCLOCK_TSC_STABLE_BIT)) {
		put_cpu();
		return 1;
	}

	put_cpu();

	kvm_clock.archdata.vclock_mode = VCLOCK_PVCLOCK;
#endif
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
marcelo tosatti marcelo tosatti 91 89.22% 2 50.00%
jan kiszka jan kiszka 8 7.84% 1 25.00%
tiejun chen tiejun chen 3 2.94% 1 25.00%
Total 102 100.00% 4 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
glauber de oliveira costa glauber de oliveira costa 399 35.85% 4 11.11%
marcelo tosatti marcelo tosatti 274 24.62% 5 13.89%
radim krcmar radim krcmar 127 11.41% 1 2.78%
glauber costa glauber costa 65 5.84% 4 11.11%
gerd hoffmann gerd hoffmann 51 4.58% 1 2.78%
eric b munson eric b munson 50 4.49% 1 2.78%
jan kiszka jan kiszka 20 1.80% 1 2.78%
magnus damm magnus damm 16 1.44% 1 2.78%
eduardo habkost eduardo habkost 16 1.44% 1 2.78%
arjan koers arjan koers 14 1.26% 1 2.78%
luiz fernando capitulino luiz fernando capitulino 13 1.17% 1 2.78%
andy lutomirski andy lutomirski 12 1.08% 1 2.78%
igor mammedov igor mammedov 10 0.90% 2 5.56%
david vrabel david vrabel 10 0.90% 1 2.78%
feng tang feng tang 8 0.72% 1 2.78%
tiejun chen tiejun chen 7 0.63% 1 2.78%
thomas gleixner thomas gleixner 5 0.45% 2 5.56%
avi kivity avi kivity 5 0.45% 1 2.78%
john stultz john stultz 3 0.27% 1 2.78%
dave young dave young 2 0.18% 1 2.78%
dave hansen dave hansen 2 0.18% 1 2.78%
ingo molnar ingo molnar 2 0.18% 1 2.78%
adam buchbinder adam buchbinder 1 0.09% 1 2.78%
fernando luis vazquez cao fernando luis vazquez cao 1 0.09% 1 2.78%
Total 1113 100.00% 36 100.00%
  Directory: arch/x86/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
glauber de oliveira costa	glauber de oliveira costa	17	100.00%	1	100.00%
	Total	17	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 arch/x86/kernel/kvmclock.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
