[mirror_ubuntu-zesty-kernel.git] / arch / x86 / xen / time.c

/*
 * Xen time implementation.
 *
 * This is implemented in terms of a clocksource driver which uses
 * the hypervisor clock as a nanosecond timebase, and a clockevent
 * driver which uses the hypervisor's timer mechanism.
 *
 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
 */
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/kernel_stat.h>
#include <linux/math64.h>
#include <linux/gfp.h>

#include <asm/pvclock.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>

#include <xen/events.h>
#include <xen/features.h>
#include <xen/interface/xen.h>
#include <xen/interface/vcpu.h>

#include "xen-ops.h"

/* Xen may fire a timer up to this many ns early */
#define TIMER_SLOP	100000
#define NS_PER_TICK	(1000000000LL / HZ)

/* runstate info updated by Xen */
static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);

/* snapshots of runstate info */
static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);

/* unused ns of stolen and blocked time */
static DEFINE_PER_CPU(u64, xen_residual_stolen);
static DEFINE_PER_CPU(u64, xen_residual_blocked);

/* return an consistent snapshot of 64-bit time/counter value */
static u64 get64(const u64 *p)
{
	u64 ret;

	if (BITS_PER_LONG < 64) {
		u32 *p32 = (u32 *)p;
		u32 h, l;

		/*
		 * Read high then low, and then make sure high is
		 * still the same; this will only loop if low wraps
		 * and carries into high.
		 * XXX some clean way to make this endian-proof?
		 */
		do {
			h = p32[1];
			barrier();
			l = p32[0];
			barrier();
		} while (p32[1] != h);

		ret = (((u64)h) << 32) | l;
	} else
		ret = *p;

	return ret;
}

/*
 * Runstate accounting
 */
static void get_runstate_snapshot(struct vcpu_runstate_info *res)
{
	u64 state_time;
	struct vcpu_runstate_info *state;

	BUG_ON(preemptible());

	state = &__get_cpu_var(xen_runstate);

	/*
	 * The runstate info is always updated by the hypervisor on
	 * the current CPU, so there's no need to use anything
	 * stronger than a compiler barrier when fetching it.
	 */
	do {
		state_time = get64(&state->state_entry_time);
		barrier();
		*res = *state;
		barrier();
	} while (get64(&state->state_entry_time) != state_time);
}

/* return true when a vcpu could run but has no real cpu to run on */
bool xen_vcpu_stolen(int vcpu)
{
	return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable;
}

void xen_setup_runstate_info(int cpu)
{
	struct vcpu_register_runstate_memory_area area;

	area.addr.v = &per_cpu(xen_runstate, cpu);

	if (HYPERVISOR_vcpu_op(VCPUOP_register_runstate_memory_area,
			       cpu, &area))
		BUG();
}

static void do_stolen_accounting(void)
{
	struct vcpu_runstate_info state;
	struct vcpu_runstate_info *snap;
	s64 blocked, runnable, offline, stolen;
	cputime_t ticks;

	get_runstate_snapshot(&state);

	WARN_ON(state.state != RUNSTATE_running);

	snap = &__get_cpu_var(xen_runstate_snapshot);

	/* work out how much time the VCPU has not been runn*ing*  */
	blocked = state.time[RUNSTATE_blocked] - snap->time[RUNSTATE_blocked];
	runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable];
	offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline];

	*snap = state;

	/* Add the appropriate number of ticks of stolen time,
	   including any left-overs from last time. */
	stolen = runnable + offline + __this_cpu_read(xen_residual_stolen);

	if (stolen < 0)
		stolen = 0;

	ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
	__this_cpu_write(xen_residual_stolen, stolen);
	account_steal_ticks(ticks);

	/* Add the appropriate number of ticks of blocked time,
	   including any left-overs from last time. */
	blocked += __this_cpu_read(xen_residual_blocked);

	if (blocked < 0)
		blocked = 0;

	ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
	__this_cpu_write(xen_residual_blocked, blocked);
	account_idle_ticks(ticks);
}

/* Get the TSC speed from Xen */
static unsigned long xen_tsc_khz(void)
{
	struct pvclock_vcpu_time_info *info =
		&HYPERVISOR_shared_info->vcpu_info[0].time;

	return pvclock_tsc_khz(info);
}

cycle_t xen_clocksource_read(void)
{
        struct pvclock_vcpu_time_info *src;
	cycle_t ret;

	preempt_disable_notrace();
	src = &__get_cpu_var(xen_vcpu)->time;
	ret = pvclock_clocksource_read(src);
	preempt_enable_notrace();
	return ret;
}

static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
{
	return xen_clocksource_read();
}

static void xen_read_wallclock(struct timespec *ts)
{
	struct shared_info *s = HYPERVISOR_shared_info;
	struct pvclock_wall_clock *wall_clock = &(s->wc);
        struct pvclock_vcpu_time_info *vcpu_time;

	vcpu_time = &get_cpu_var(xen_vcpu)->time;
	pvclock_read_wallclock(wall_clock, vcpu_time, ts);
	put_cpu_var(xen_vcpu);
}

static unsigned long xen_get_wallclock(void)
{
	struct timespec ts;

	xen_read_wallclock(&ts);
	return ts.tv_sec;
}

static int xen_set_wallclock(unsigned long now)
{
	struct xen_platform_op op;
	int rc;

	/* do nothing for domU */
	if (!xen_initial_domain())
		return -1;

	op.cmd = XENPF_settime;
	op.u.settime.secs = now;
	op.u.settime.nsecs = 0;
	op.u.settime.system_time = xen_clocksource_read();

	rc = HYPERVISOR_dom0_op(&op);
	WARN(rc != 0, "XENPF_settime failed: now=%ld\n", now);

	return rc;
}

static struct clocksource xen_clocksource __read_mostly = {
	.name = "xen",
	.rating = 400,
	.read = xen_clocksource_get_cycles,
	.mask = ~0,
	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
};

/*
   Xen clockevent implementation

   Xen has two clockevent implementations:

   The old timer_op one works with all released versions of Xen prior
   to version 3.0.4.  This version of the hypervisor provides a
   single-shot timer with nanosecond resolution.  However, sharing the
   same event channel is a 100Hz tick which is delivered while the
   vcpu is running.  We don't care about or use this tick, but it will
   cause the core time code to think the timer fired too soon, and
   will end up resetting it each time.  It could be filtered, but
   doing so has complications when the ktime clocksource is not yet
   the xen clocksource (ie, at boot time).

   The new vcpu_op-based timer interface allows the tick timer period
   to be changed or turned off.  The tick timer is not useful as a
   periodic timer because events are only delivered to running vcpus.
   The one-shot timer can report when a timeout is in the past, so
   set_next_event is capable of returning -ETIME when appropriate.
   This interface is used when available.
*/


/*
  Get a hypervisor absolute time.  In theory we could maintain an
  offset between the kernel's time and the hypervisor's time, and
  apply that to a kernel's absolute timeout.  Unfortunately the
  hypervisor and kernel times can drift even if the kernel is using
  the Xen clocksource, because ntp can warp the kernel's clocksource.
*/
static s64 get_abs_timeout(unsigned long delta)
{
	return xen_clocksource_read() + delta;
}

static void xen_timerop_set_mode(enum clock_event_mode mode,
				 struct clock_event_device *evt)
{
	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
		/* unsupported */
		WARN_ON(1);
		break;

	case CLOCK_EVT_MODE_ONESHOT:
	case CLOCK_EVT_MODE_RESUME:
		break;

	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		HYPERVISOR_set_timer_op(0);  /* cancel timeout */
		break;
	}
}

static int xen_timerop_set_next_event(unsigned long delta,
				      struct clock_event_device *evt)
{
	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);

	if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
		BUG();

	/* We may have missed the deadline, but there's no real way of
	   knowing for sure.  If the event was in the past, then we'll
	   get an immediate interrupt. */

	return 0;
}

static const struct clock_event_device xen_timerop_clockevent = {
	.name = "xen",
	.features = CLOCK_EVT_FEAT_ONESHOT,

	.max_delta_ns = 0xffffffff,
	.min_delta_ns = TIMER_SLOP,

	.mult = 1,
	.shift = 0,
	.rating = 500,

	.set_mode = xen_timerop_set_mode,
	.set_next_event = xen_timerop_set_next_event,
};


static void xen_vcpuop_set_mode(enum clock_event_mode mode,
				struct clock_event_device *evt)
{
	int cpu = smp_processor_id();

	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
		WARN_ON(1);	/* unsupported */
		break;

	case CLOCK_EVT_MODE_ONESHOT:
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
			BUG();
		break;

	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) ||
		    HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
			BUG();
		break;
	case CLOCK_EVT_MODE_RESUME:
		break;
	}
}

static int xen_vcpuop_set_next_event(unsigned long delta,
				     struct clock_event_device *evt)
{
	int cpu = smp_processor_id();
	struct vcpu_set_singleshot_timer single;
	int ret;

	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);

	single.timeout_abs_ns = get_abs_timeout(delta);
	single.flags = VCPU_SSHOTTMR_future;

	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);

	BUG_ON(ret != 0 && ret != -ETIME);

	return ret;
}

static const struct clock_event_device xen_vcpuop_clockevent = {
	.name = "xen",
	.features = CLOCK_EVT_FEAT_ONESHOT,

	.max_delta_ns = 0xffffffff,
	.min_delta_ns = TIMER_SLOP,

	.mult = 1,
	.shift = 0,
	.rating = 500,

	.set_mode = xen_vcpuop_set_mode,
	.set_next_event = xen_vcpuop_set_next_event,
};

static const struct clock_event_device *xen_clockevent =
	&xen_timerop_clockevent;

struct xen_clock_event_device {
	struct clock_event_device evt;
	char *name;
};
static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };

static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evt = &__get_cpu_var(xen_clock_events).evt;
	irqreturn_t ret;

	ret = IRQ_NONE;
	if (evt->event_handler) {
		evt->event_handler(evt);
		ret = IRQ_HANDLED;
	}

	do_stolen_accounting();

	return ret;
}

void xen_setup_timer(int cpu)
{
	const char *name;
	struct clock_event_device *evt;
	int irq;

	evt = &per_cpu(xen_clock_events, cpu).evt;
	WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);

	printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);

	name = kasprintf(GFP_KERNEL, "timer%d", cpu);
	if (!name)
		name = "<timer kasprintf failed>";

	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
				      IRQF_DISABLED|IRQF_PERCPU|
				      IRQF_NOBALANCING|IRQF_TIMER|
				      IRQF_FORCE_RESUME,
				      name, NULL);

	memcpy(evt, xen_clockevent, sizeof(*evt));

	evt->cpumask = cpumask_of(cpu);
	evt->irq = irq;
}

void xen_teardown_timer(int cpu)
{
	struct clock_event_device *evt;
	BUG_ON(cpu == 0);
	evt = &per_cpu(xen_clock_events, cpu).evt;
	unbind_from_irqhandler(evt->irq, NULL);
	evt->irq = -1;
}

void xen_setup_cpu_clockevents(void)
{
	BUG_ON(preemptible());

	clockevents_register_device(&__get_cpu_var(xen_clock_events).evt);
}

void xen_timer_resume(void)
{
	int cpu;

	pvclock_resume();

	if (xen_clockevent != &xen_vcpuop_clockevent)
		return;

	for_each_online_cpu(cpu) {
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
			BUG();
	}
}

static const struct pv_time_ops xen_time_ops __initconst = {
	.sched_clock = xen_clocksource_read,
};

static void __init xen_time_init(void)
{
	int cpu = smp_processor_id();
	struct timespec tp;

	clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);

	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL) == 0) {
		/* Successfully turned off 100Hz tick, so we have the
		   vcpuop-based timer interface */
		printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
		xen_clockevent = &xen_vcpuop_clockevent;
	}

	/* Set initial system time with full resolution */
	xen_read_wallclock(&tp);
	do_settimeofday(&tp);

	setup_force_cpu_cap(X86_FEATURE_TSC);

	xen_setup_runstate_info(cpu);
	xen_setup_timer(cpu);
	xen_setup_cpu_clockevents();
}

void __init xen_init_time_ops(void)
{
	pv_time_ops = xen_time_ops;

	x86_init.timers.timer_init = xen_time_init;
	x86_init.timers.setup_percpu_clockev = x86_init_noop;
	x86_cpuinit.setup_percpu_clockev = x86_init_noop;

	x86_platform.calibrate_tsc = xen_tsc_khz;
	x86_platform.get_wallclock = xen_get_wallclock;
	x86_platform.set_wallclock = xen_set_wallclock;
}

#ifdef CONFIG_XEN_PVHVM
static void xen_hvm_setup_cpu_clockevents(void)
{
	int cpu = smp_processor_id();
	xen_setup_runstate_info(cpu);
	/*
	 * xen_setup_timer(cpu) - snprintf is bad in atomic context. Hence
	 * doing it xen_hvm_cpu_notify (which gets called by smp_init during
	 * early bootup and also during CPU hotplug events).
	 */
	xen_setup_cpu_clockevents();
}

void __init xen_hvm_init_time_ops(void)
{
	/* vector callback is needed otherwise we cannot receive interrupts
	 * on cpu > 0 and at this point we don't know how many cpus are
	 * available */
	if (!xen_have_vector_callback)
		return;
	if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
		printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
				"disable pv timer\n");
		return;
	}

	pv_time_ops = xen_time_ops;
	x86_init.timers.setup_percpu_clockev = xen_time_init;
	x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;

	x86_platform.calibrate_tsc = xen_tsc_khz;
	x86_platform.get_wallclock = xen_get_wallclock;
	x86_platform.set_wallclock = xen_set_wallclock;
}
#endif
Commit	Line	Data
15c84731 JF	1	/*
	2	* Xen time implementation.
	3	*
	4	* This is implemented in terms of a clocksource driver which uses
	5	* the hypervisor clock as a nanosecond timebase, and a clockevent
	6	* driver which uses the hypervisor's timer mechanism.
	7	*
	8	* Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
	9	*/
	10	#include <linux/kernel.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/clocksource.h>
	13	#include <linux/clockchips.h>
f91a8b44	14	#include <linux/kernel_stat.h>
f595ec96	15	#include <linux/math64.h>
5a0e3ad6	16	#include <linux/gfp.h>
15c84731	17
1c7b67f7	18	#include <asm/pvclock.h>
15c84731 JF	19	#include <asm/xen/hypervisor.h>
	20	#include <asm/xen/hypercall.h>
	21
	22	#include <xen/events.h>
409771d2	23	#include <xen/features.h>
15c84731 JF	24	#include <xen/interface/xen.h>
	25	#include <xen/interface/vcpu.h>
	26
	27	#include "xen-ops.h"
	28
15c84731 JF	29	/* Xen may fire a timer up to this many ns early */
15c84731 JF	30	#define TIMER_SLOP 100000
f91a8b44	31	#define NS_PER_TICK (1000000000LL / HZ)
15c84731	32
f91a8b44	33	/* runstate info updated by Xen */
c6e22f9e	34	static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);
f91a8b44 JF	35
f91a8b44 JF	36	/* snapshots of runstate info */
c6e22f9e	37	static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);
f91a8b44 JF	38
f91a8b44 JF	39	/* unused ns of stolen and blocked time */
c6e22f9e TH	40	static DEFINE_PER_CPU(u64, xen_residual_stolen);
c6e22f9e TH	41	static DEFINE_PER_CPU(u64, xen_residual_blocked);
f91a8b44 JF	42
	43	/* return an consistent snapshot of 64-bit time/counter value */
	44	static u64 get64(const u64 *p)
	45	{
	46	u64 ret;
	47
	48	if (BITS_PER_LONG < 64) {
	49	u32 p32 = (u32 )p;
	50	u32 h, l;
	51
	52	/*
	53	* Read high then low, and then make sure high is
	54	* still the same; this will only loop if low wraps
	55	* and carries into high.
	56	* XXX some clean way to make this endian-proof?
	57	*/
	58	do {
	59	h = p32[1];
	60	barrier();
	61	l = p32[0];
	62	barrier();
	63	} while (p32[1] != h);
	64
	65	ret = (((u64)h) << 32) \| l;
	66	} else
	67	ret = *p;
	68
	69	return ret;
	70	}
	71
	72	/*
	73	* Runstate accounting
	74	*/
	75	static void get_runstate_snapshot(struct vcpu_runstate_info *res)
	76	{
	77	u64 state_time;
	78	struct vcpu_runstate_info *state;
	79
f120f13e	80	BUG_ON(preemptible());
f91a8b44	81
c6e22f9e	82	state = &__get_cpu_var(xen_runstate);
f91a8b44 JF	83
	84	/*
	85	* The runstate info is always updated by the hypervisor on
	86	* the current CPU, so there's no need to use anything
	87	* stronger than a compiler barrier when fetching it.
	88	*/
	89	do {
	90	state_time = get64(&state->state_entry_time);
	91	barrier();
	92	res = state;
	93	barrier();
	94	} while (get64(&state->state_entry_time) != state_time);
f91a8b44 JF	95	}
f91a8b44 JF	96
f0d73394 JF	97	/* return true when a vcpu could run but has no real cpu to run on */
	98	bool xen_vcpu_stolen(int vcpu)
	99	{
c6e22f9e	100	return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable;
f0d73394 JF	101	}
f0d73394 JF	102
be012920	103	void xen_setup_runstate_info(int cpu)
f91a8b44 JF	104	{
	105	struct vcpu_register_runstate_memory_area area;
	106
c6e22f9e	107	area.addr.v = &per_cpu(xen_runstate, cpu);
f91a8b44 JF	108
	109	if (HYPERVISOR_vcpu_op(VCPUOP_register_runstate_memory_area,
	110	cpu, &area))
	111	BUG();
	112	}
	113
	114	static void do_stolen_accounting(void)
	115	{
	116	struct vcpu_runstate_info state;
	117	struct vcpu_runstate_info *snap;
	118	s64 blocked, runnable, offline, stolen;
	119	cputime_t ticks;
	120
	121	get_runstate_snapshot(&state);
	122
	123	WARN_ON(state.state != RUNSTATE_running);
	124
c6e22f9e	125	snap = &__get_cpu_var(xen_runstate_snapshot);
f91a8b44 JF	126
	127	/* work out how much time the VCPU has not been running */
	128	blocked = state.time[RUNSTATE_blocked] - snap->time[RUNSTATE_blocked];
	129	runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable];
	130	offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline];
	131
	132	*snap = state;
	133
	134	/* Add the appropriate number of ticks of stolen time,
79741dd3	135	including any left-overs from last time. */
780f36d8	136	stolen = runnable + offline + __this_cpu_read(xen_residual_stolen);
f91a8b44 JF	137
	138	if (stolen < 0)
	139	stolen = 0;
	140
f595ec96	141	ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
780f36d8	142	__this_cpu_write(xen_residual_stolen, stolen);
79741dd3	143	account_steal_ticks(ticks);
f91a8b44 JF	144
f91a8b44 JF	145	/* Add the appropriate number of ticks of blocked time,
79741dd3	146	including any left-overs from last time. */
780f36d8	147	blocked += __this_cpu_read(xen_residual_blocked);
f91a8b44 JF	148
	149	if (blocked < 0)
	150	blocked = 0;
	151
f595ec96	152	ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
780f36d8	153	__this_cpu_write(xen_residual_blocked, blocked);
79741dd3	154	account_idle_ticks(ticks);
f91a8b44 JF	155	}
f91a8b44 JF	156
e93ef949	157	/* Get the TSC speed from Xen */
409771d2	158	static unsigned long xen_tsc_khz(void)
15c84731	159	{
3807f345	160	struct pvclock_vcpu_time_info *info =
15c84731 JF	161	&HYPERVISOR_shared_info->vcpu_info[0].time;
15c84731 JF	162
3807f345	163	return pvclock_tsc_khz(info);
15c84731 JF	164	}
15c84731 JF	165
ee7686bc	166	cycle_t xen_clocksource_read(void)
15c84731	167	{
1c7b67f7	168	struct pvclock_vcpu_time_info *src;
15c84731	169	cycle_t ret;
15c84731	170
f1c39625 JF	171	preempt_disable_notrace();
f1c39625 JF	172	src = &__get_cpu_var(xen_vcpu)->time;
1c7b67f7	173	ret = pvclock_clocksource_read(src);
f1c39625	174	preempt_enable_notrace();
15c84731 JF	175	return ret;
	176	}
	177
8e19608e MD	178	static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
	179	{
	180	return xen_clocksource_read();
	181	}
	182
15c84731 JF	183	static void xen_read_wallclock(struct timespec *ts)
15c84731 JF	184	{
1c7b67f7 GH	185	struct shared_info *s = HYPERVISOR_shared_info;
	186	struct pvclock_wall_clock *wall_clock = &(s->wc);
	187	struct pvclock_vcpu_time_info *vcpu_time;
15c84731	188
1c7b67f7 GH	189	vcpu_time = &get_cpu_var(xen_vcpu)->time;
	190	pvclock_read_wallclock(wall_clock, vcpu_time, ts);
	191	put_cpu_var(xen_vcpu);
15c84731 JF	192	}
15c84731 JF	193
409771d2	194	static unsigned long xen_get_wallclock(void)
15c84731 JF	195	{
	196	struct timespec ts;
	197
	198	xen_read_wallclock(&ts);
15c84731 JF	199	return ts.tv_sec;
	200	}
	201
409771d2	202	static int xen_set_wallclock(unsigned long now)
15c84731	203	{
fdb9eb9f JF	204	struct xen_platform_op op;
	205	int rc;
	206
15c84731	207	/* do nothing for domU */
fdb9eb9f JF	208	if (!xen_initial_domain())
	209	return -1;
	210
	211	op.cmd = XENPF_settime;
	212	op.u.settime.secs = now;
	213	op.u.settime.nsecs = 0;
	214	op.u.settime.system_time = xen_clocksource_read();
	215
	216	rc = HYPERVISOR_dom0_op(&op);
	217	WARN(rc != 0, "XENPF_settime failed: now=%ld\n", now);
	218
	219	return rc;
15c84731 JF	220	}
	221
	222	static struct clocksource xen_clocksource __read_mostly = {
	223	.name = "xen",
	224	.rating = 400,
8e19608e	225	.read = xen_clocksource_get_cycles,
15c84731	226	.mask = ~0,
15c84731 JF	227	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
	228	};
	229
	230	/*
	231	Xen clockevent implementation
	232
	233	Xen has two clockevent implementations:
	234
	235	The old timer_op one works with all released versions of Xen prior
	236	to version 3.0.4. This version of the hypervisor provides a
	237	single-shot timer with nanosecond resolution. However, sharing the
	238	same event channel is a 100Hz tick which is delivered while the
	239	vcpu is running. We don't care about or use this tick, but it will
	240	cause the core time code to think the timer fired too soon, and
	241	will end up resetting it each time. It could be filtered, but
	242	doing so has complications when the ktime clocksource is not yet
	243	the xen clocksource (ie, at boot time).
	244
	245	The new vcpu_op-based timer interface allows the tick timer period
	246	to be changed or turned off. The tick timer is not useful as a
	247	periodic timer because events are only delivered to running vcpus.
	248	The one-shot timer can report when a timeout is in the past, so
	249	set_next_event is capable of returning -ETIME when appropriate.
	250	This interface is used when available.
	251	*/
	252
	253
	254	/*
	255	Get a hypervisor absolute time. In theory we could maintain an
	256	offset between the kernel's time and the hypervisor's time, and
	257	apply that to a kernel's absolute timeout. Unfortunately the
	258	hypervisor and kernel times can drift even if the kernel is using
	259	the Xen clocksource, because ntp can warp the kernel's clocksource.
	260	*/
	261	static s64 get_abs_timeout(unsigned long delta)
	262	{
	263	return xen_clocksource_read() + delta;
	264	}
	265
	266	static void xen_timerop_set_mode(enum clock_event_mode mode,
	267	struct clock_event_device *evt)
	268	{
	269	switch (mode) {
	270	case CLOCK_EVT_MODE_PERIODIC:
	271	/* unsupported */
	272	WARN_ON(1);
	273	break;
	274
	275	case CLOCK_EVT_MODE_ONESHOT:
18de5bc4	276	case CLOCK_EVT_MODE_RESUME:
15c84731 JF	277	break;
	278
	279	case CLOCK_EVT_MODE_UNUSED:
	280	case CLOCK_EVT_MODE_SHUTDOWN:
	281	HYPERVISOR_set_timer_op(0); /* cancel timeout */
	282	break;
	283	}
	284	}
	285
	286	static int xen_timerop_set_next_event(unsigned long delta,
	287	struct clock_event_device *evt)
	288	{
	289	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);
	290
	291	if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
	292	BUG();
	293
	294	/* We may have missed the deadline, but there's no real way of
	295	knowing for sure. If the event was in the past, then we'll
	296	get an immediate interrupt. */
	297
	298	return 0;
	299	}
	300
	301	static const struct clock_event_device xen_timerop_clockevent = {
	302	.name = "xen",
	303	.features = CLOCK_EVT_FEAT_ONESHOT,
	304
	305	.max_delta_ns = 0xffffffff,
	306	.min_delta_ns = TIMER_SLOP,
	307
	308	.mult = 1,
	309	.shift = 0,
	310	.rating = 500,
	311
	312	.set_mode = xen_timerop_set_mode,
	313	.set_next_event = xen_timerop_set_next_event,
	314	};
	315
	316
	317
	318	static void xen_vcpuop_set_mode(enum clock_event_mode mode,
	319	struct clock_event_device *evt)
	320	{
	321	int cpu = smp_processor_id();
	322
	323	switch (mode) {
	324	case CLOCK_EVT_MODE_PERIODIC:
	325	WARN_ON(1); /* unsupported */
	326	break;
	327
	328	case CLOCK_EVT_MODE_ONESHOT:
	329	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	330	BUG();
	331	break;
	332
	333	case CLOCK_EVT_MODE_UNUSED:
	334	case CLOCK_EVT_MODE_SHUTDOWN:
	335	if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) \|\|
	336	HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	337	BUG();
	338	break;
18de5bc4 TG	339	case CLOCK_EVT_MODE_RESUME:
18de5bc4 TG	340	break;
15c84731 JF	341	}
	342	}
	343
	344	static int xen_vcpuop_set_next_event(unsigned long delta,
	345	struct clock_event_device *evt)
	346	{
	347	int cpu = smp_processor_id();
	348	struct vcpu_set_singleshot_timer single;
	349	int ret;
	350
	351	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);
	352
	353	single.timeout_abs_ns = get_abs_timeout(delta);
	354	single.flags = VCPU_SSHOTTMR_future;
	355
	356	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
	357
	358	BUG_ON(ret != 0 && ret != -ETIME);
	359
	360	return ret;
	361	}
	362
	363	static const struct clock_event_device xen_vcpuop_clockevent = {
	364	.name = "xen",
	365	.features = CLOCK_EVT_FEAT_ONESHOT,
	366
	367	.max_delta_ns = 0xffffffff,
	368	.min_delta_ns = TIMER_SLOP,
	369
	370	.mult = 1,
	371	.shift = 0,
	372	.rating = 500,
	373
	374	.set_mode = xen_vcpuop_set_mode,
	375	.set_next_event = xen_vcpuop_set_next_event,
	376	};
	377
	378	static const struct clock_event_device *xen_clockevent =
	379	&xen_timerop_clockevent;
31620a19 KRW	380
	381	struct xen_clock_event_device {
	382	struct clock_event_device evt;
	383	char *name;
	384	};
	385	static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };
15c84731 JF	386
	387	static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
	388	{
31620a19	389	struct clock_event_device *evt = &__get_cpu_var(xen_clock_events).evt;
15c84731 JF	390	irqreturn_t ret;
	391
	392	ret = IRQ_NONE;
	393	if (evt->event_handler) {
	394	evt->event_handler(evt);
	395	ret = IRQ_HANDLED;
	396	}
	397
f91a8b44 JF	398	do_stolen_accounting();
f91a8b44 JF	399
15c84731 JF	400	return ret;
	401	}
	402
f87e4cac	403	void xen_setup_timer(int cpu)
15c84731 JF	404	{
	405	const char *name;
	406	struct clock_event_device *evt;
	407	int irq;
	408
31620a19	409	evt = &per_cpu(xen_clock_events, cpu).evt;
ef35a4e6 KRW	410	WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);
ef35a4e6 KRW	411
15c84731 JF	412	printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);
	413
	414	name = kasprintf(GFP_KERNEL, "timer%d", cpu);
	415	if (!name)
	416	name = "<timer kasprintf failed>";
	417
	418	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
f611f2da IC	419	IRQF_DISABLED\|IRQF_PERCPU\|
	420	IRQF_NOBALANCING\|IRQF_TIMER\|
	421	IRQF_FORCE_RESUME,
15c84731 JF	422	name, NULL);
15c84731 JF	423
15c84731 JF	424	memcpy(evt, xen_clockevent, sizeof(*evt));
15c84731 JF	425
320ab2b0	426	evt->cpumask = cpumask_of(cpu);
15c84731	427	evt->irq = irq;
f87e4cac JF	428	}
f87e4cac JF	429
d68d82af AN	430	void xen_teardown_timer(int cpu)
	431	{
	432	struct clock_event_device *evt;
	433	BUG_ON(cpu == 0);
31620a19	434	evt = &per_cpu(xen_clock_events, cpu).evt;
d68d82af	435	unbind_from_irqhandler(evt->irq, NULL);
ef35a4e6	436	evt->irq = -1;
d68d82af AN	437	}
d68d82af AN	438
f87e4cac JF	439	void xen_setup_cpu_clockevents(void)
	440	{
	441	BUG_ON(preemptible());
f91a8b44	442
31620a19	443	clockevents_register_device(&__get_cpu_var(xen_clock_events).evt);
15c84731 JF	444	}
15c84731 JF	445
d07af1f0 JF	446	void xen_timer_resume(void)
	447	{
	448	int cpu;
	449
e7a3481c JF	450	pvclock_resume();
e7a3481c JF	451
d07af1f0 JF	452	if (xen_clockevent != &xen_vcpuop_clockevent)
	453	return;
	454
	455	for_each_online_cpu(cpu) {
	456	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	457	BUG();
	458	}
	459	}
	460
fb6ce5de	461	static const struct pv_time_ops xen_time_ops __initconst = {
ca50a5f3	462	.sched_clock = xen_clocksource_read,
409771d2 SS	463	};
409771d2 SS	464
fb6ce5de	465	static void __init xen_time_init(void)
15c84731 JF	466	{
15c84731 JF	467	int cpu = smp_processor_id();
c4507257	468	struct timespec tp;
15c84731	469
b01cc1b0	470	clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);
15c84731 JF	471
15c84731 JF	472	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL) == 0) {
f91a8b44	473	/* Successfully turned off 100Hz tick, so we have the
15c84731 JF	474	vcpuop-based timer interface */
	475	printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
	476	xen_clockevent = &xen_vcpuop_clockevent;
	477	}
	478
	479	/* Set initial system time with full resolution */
c4507257 JS	480	xen_read_wallclock(&tp);
c4507257 JS	481	do_settimeofday(&tp);
15c84731	482
404ee5b1	483	setup_force_cpu_cap(X86_FEATURE_TSC);
15c84731	484
be012920	485	xen_setup_runstate_info(cpu);
15c84731	486	xen_setup_timer(cpu);
f87e4cac	487	xen_setup_cpu_clockevents();
15c84731	488	}
409771d2	489
fb6ce5de	490	void __init xen_init_time_ops(void)
409771d2 SS	491	{
	492	pv_time_ops = xen_time_ops;
	493
	494	x86_init.timers.timer_init = xen_time_init;
	495	x86_init.timers.setup_percpu_clockev = x86_init_noop;
	496	x86_cpuinit.setup_percpu_clockev = x86_init_noop;
	497
	498	x86_platform.calibrate_tsc = xen_tsc_khz;
	499	x86_platform.get_wallclock = xen_get_wallclock;
	500	x86_platform.set_wallclock = xen_set_wallclock;
	501	}
	502
ca65f9fc	503	#ifdef CONFIG_XEN_PVHVM
409771d2 SS	504	static void xen_hvm_setup_cpu_clockevents(void)
	505	{
	506	int cpu = smp_processor_id();
	507	xen_setup_runstate_info(cpu);
7918c92a KRW	508	/*
	509	* xen_setup_timer(cpu) - snprintf is bad in atomic context. Hence
	510	* doing it xen_hvm_cpu_notify (which gets called by smp_init during
	511	* early bootup and also during CPU hotplug events).
	512	*/
409771d2 SS	513	xen_setup_cpu_clockevents();
	514	}
	515
fb6ce5de	516	void __init xen_hvm_init_time_ops(void)
409771d2 SS	517	{
409771d2 SS	518	/* vector callback is needed otherwise we cannot receive interrupts
31e7e931 SS	519	* on cpu > 0 and at this point we don't know how many cpus are
	520	* available */
	521	if (!xen_have_vector_callback)
409771d2 SS	522	return;
	523	if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
	524	printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
	525	"disable pv timer\n");
	526	return;
	527	}
	528
	529	pv_time_ops = xen_time_ops;
	530	x86_init.timers.setup_percpu_clockev = xen_time_init;
	531	x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;
	532
	533	x86_platform.calibrate_tsc = xen_tsc_khz;
	534	x86_platform.get_wallclock = xen_get_wallclock;
	535	x86_platform.set_wallclock = xen_set_wallclock;
	536	}
ca65f9fc	537	#endif