]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - arch/x86/xen/time.c
xen/time: Encapsulate the struct clock_event_device in another structure.
[mirror_ubuntu-zesty-kernel.git] / arch / x86 / xen / time.c
CommitLineData
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 */
30#define TIMER_SLOP 100000
f91a8b44 31#define NS_PER_TICK (1000000000LL / HZ)
15c84731 32
f91a8b44 33/* runstate info updated by Xen */
c6e22f9e 34static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);
f91a8b44
JF
35
36/* snapshots of runstate info */
c6e22f9e 37static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);
f91a8b44
JF
38
39/* unused ns of stolen and blocked time */
c6e22f9e
TH
40static DEFINE_PER_CPU(u64, xen_residual_stolen);
41static DEFINE_PER_CPU(u64, xen_residual_blocked);
f91a8b44
JF
42
43/* return an consistent snapshot of 64-bit time/counter value */
44static 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 */
75static 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}
96
f0d73394
JF
97/* return true when a vcpu could run but has no real cpu to run on */
98bool xen_vcpu_stolen(int vcpu)
99{
c6e22f9e 100 return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable;
f0d73394
JF
101}
102
be012920 103void 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
114static 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 runn*ing* */
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
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}
156
e93ef949 157/* Get the TSC speed from Xen */
409771d2 158static 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;
162
3807f345 163 return pvclock_tsc_khz(info);
15c84731
JF
164}
165
ee7686bc 166cycle_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();
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
178static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
179{
180 return xen_clocksource_read();
181}
182
15c84731
JF
183static void xen_read_wallclock(struct timespec *ts)
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}
193
409771d2 194static 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 202static 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
222static 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*/
261static s64 get_abs_timeout(unsigned long delta)
262{
263 return xen_clocksource_read() + delta;
264}
265
266static 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
286static 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
301static 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
318static 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:
340 break;
15c84731
JF
341 }
342}
343
344static 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
363static 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
378static const struct clock_event_device *xen_clockevent =
379 &xen_timerop_clockevent;
31620a19
KRW
380
381struct xen_clock_event_device {
382 struct clock_event_device evt;
383 char *name;
384};
385static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };
15c84731
JF
386
387static 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();
399
15c84731
JF
400 return ret;
401}
402
f87e4cac 403void 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);
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);
423
15c84731
JF
424 memcpy(evt, xen_clockevent, sizeof(*evt));
425
320ab2b0 426 evt->cpumask = cpumask_of(cpu);
15c84731 427 evt->irq = irq;
f87e4cac
JF
428}
429
d68d82af
AN
430void 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}
438
f87e4cac
JF
439void 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}
445
d07af1f0
JF
446void xen_timer_resume(void)
447{
448 int cpu;
449
e7a3481c
JF
450 pvclock_resume();
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 461static const struct pv_time_ops xen_time_ops __initconst = {
ca50a5f3 462 .sched_clock = xen_clocksource_read,
409771d2
SS
463};
464
fb6ce5de 465static void __init xen_time_init(void)
15c84731
JF
466{
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
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);
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 490void __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
504static 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 516void __init xen_hvm_init_time_ops(void)
409771d2
SS
517{
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