arch/x86/xen/time.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Xen time implementation.
   4  *
   5  * This is implemented in terms of a clocksource driver which uses
   6  * the hypervisor clock as a nanosecond timebase, and a clockevent
   7  * driver which uses the hypervisor's timer mechanism.
   8  *
   9  * Jeremy Fitzhardinge <[email protected]>, XenSource Inc, 2007
  10  */
  11 #include <linux/kernel.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/clocksource.h>
  14 #include <linux/clockchips.h>
  15 #include <linux/gfp.h>
  16 #include <linux/slab.h>
  17 #include <linux/pvclock_gtod.h>
  18 #include <linux/timekeeper_internal.h>
  19
  20 #include <asm/pvclock.h>
  21 #include <asm/xen/hypervisor.h>
  22 #include <asm/xen/hypercall.h>
  23
  24 #include <xen/events.h>
  25 #include <xen/features.h>
  26 #include <xen/interface/xen.h>
  27 #include <xen/interface/vcpu.h>
  28
  29 #include "xen-ops.h"
  30
  31 /* Minimum amount of time until next clock event fires */
  32 #define TIMER_SLOP      100000
  33
  34 static u64 xen_sched_clock_offset __read_mostly;
  35
  36 /* Get the TSC speed from Xen */
  37 static unsigned long xen_tsc_khz(void)
  38 {
  39         struct pvclock_vcpu_time_info *info =
  40                 &HYPERVISOR_shared_info->vcpu_info[0].time;
  41
  42         return pvclock_tsc_khz(info);
  43 }
  44
  45 static u64 xen_clocksource_read(void)
  46 {
  47         struct pvclock_vcpu_time_info *src;
  48         u64 ret;
  49
  50         preempt_disable_notrace();
  51         src = &__this_cpu_read(xen_vcpu)->time;
  52         ret = pvclock_clocksource_read(src);
  53         preempt_enable_notrace();
  54         return ret;
  55 }
  56
  57 static u64 xen_clocksource_get_cycles(struct clocksource *cs)
  58 {
  59         return xen_clocksource_read();
  60 }
  61
  62 static u64 xen_sched_clock(void)
  63 {
  64         return xen_clocksource_read() - xen_sched_clock_offset;
  65 }
  66
  67 static void xen_read_wallclock(struct timespec64 *ts)
  68 {
  69         struct shared_info *s = HYPERVISOR_shared_info;
  70         struct pvclock_wall_clock *wall_clock = &(s->wc);
  71         struct pvclock_vcpu_time_info *vcpu_time;
  72
  73         vcpu_time = &get_cpu_var(xen_vcpu)->time;
  74         pvclock_read_wallclock(wall_clock, vcpu_time, ts);
  75         put_cpu_var(xen_vcpu);
  76 }
  77
  78 static void xen_get_wallclock(struct timespec64 *now)
  79 {
  80         xen_read_wallclock(now);
  81 }
  82
  83 static int xen_set_wallclock(const struct timespec64 *now)
  84 {
  85         return -ENODEV;
  86 }
  87
  88 static int xen_pvclock_gtod_notify(struct notifier_block *nb,
  89                                    unsigned long was_set, void *priv)
  90 {
  91         /* Protected by the calling core code serialization */
  92         static struct timespec64 next_sync;
  93
  94         struct xen_platform_op op;
  95         struct timespec64 now;
  96         struct timekeeper *tk = priv;
  97         static bool settime64_supported = true;
  98         int ret;
  99
 100         now.tv_sec = tk->xtime_sec;
 101         now.tv_nsec = (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);
 102
 103         /*
 104          * We only take the expensive HV call when the clock was set
 105          * or when the 11 minutes RTC synchronization time elapsed.
 106          */
 107         if (!was_set && timespec64_compare(&now, &next_sync) < 0)
 108                 return NOTIFY_OK;
 109
 110 again:
 111         if (settime64_supported) {
 112                 op.cmd = XENPF_settime64;
 113                 op.u.settime64.mbz = 0;
 114                 op.u.settime64.secs = now.tv_sec;
 115                 op.u.settime64.nsecs = now.tv_nsec;
 116                 op.u.settime64.system_time = xen_clocksource_read();
 117         } else {
 118                 op.cmd = XENPF_settime32;
 119                 op.u.settime32.secs = now.tv_sec;
 120                 op.u.settime32.nsecs = now.tv_nsec;
 121                 op.u.settime32.system_time = xen_clocksource_read();
 122         }
 123
 124         ret = HYPERVISOR_platform_op(&op);
 125
 126         if (ret == -ENOSYS && settime64_supported) {
 127                 settime64_supported = false;
 128                 goto again;
 129         }
 130         if (ret < 0)
 131                 return NOTIFY_BAD;
 132
 133         /*
 134          * Move the next drift compensation time 11 minutes
 135          * ahead. That's emulating the sync_cmos_clock() update for
 136          * the hardware RTC.
 137          */
 138         next_sync = now;
 139         next_sync.tv_sec += 11 * 60;
 140
 141         return NOTIFY_OK;
 142 }
 143
 144 static struct notifier_block xen_pvclock_gtod_notifier = {
 145         .notifier_call = xen_pvclock_gtod_notify,
 146 };
 147
 148 static int xen_cs_enable(struct clocksource *cs)
 149 {
 150         vclocks_set_used(VDSO_CLOCKMODE_PVCLOCK);
 151         return 0;
 152 }
 153
 154 static struct clocksource xen_clocksource __read_mostly = {
 155         .name   = "xen",
 156         .rating = 400,
 157         .read   = xen_clocksource_get_cycles,
 158         .mask   = CLOCKSOURCE_MASK(64),
 159         .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 160         .enable = xen_cs_enable,
 161 };
 162
 163 /*
 164    Xen clockevent implementation
 165
 166    Xen has two clockevent implementations:
 167
 168    The old timer_op one works with all released versions of Xen prior
 169    to version 3.0.4.  This version of the hypervisor provides a
 170    single-shot timer with nanosecond resolution.  However, sharing the
 171    same event channel is a 100Hz tick which is delivered while the
 172    vcpu is running.  We don't care about or use this tick, but it will
 173    cause the core time code to think the timer fired too soon, and
 174    will end up resetting it each time.  It could be filtered, but
 175    doing so has complications when the ktime clocksource is not yet
 176    the xen clocksource (ie, at boot time).
 177
 178    The new vcpu_op-based timer interface allows the tick timer period
 179    to be changed or turned off.  The tick timer is not useful as a
 180    periodic timer because events are only delivered to running vcpus.
 181    The one-shot timer can report when a timeout is in the past, so
 182    set_next_event is capable of returning -ETIME when appropriate.
 183    This interface is used when available.
 184 */
 185
 186
 187 /*
 188   Get a hypervisor absolute time.  In theory we could maintain an
 189   offset between the kernel's time and the hypervisor's time, and
 190   apply that to a kernel's absolute timeout.  Unfortunately the
 191   hypervisor and kernel times can drift even if the kernel is using
 192   the Xen clocksource, because ntp can warp the kernel's clocksource.
 193 */
 194 static s64 get_abs_timeout(unsigned long delta)
 195 {
 196         return xen_clocksource_read() + delta;
 197 }
 198
 199 static int xen_timerop_shutdown(struct clock_event_device *evt)
 200 {
 201         /* cancel timeout */
 202         HYPERVISOR_set_timer_op(0);
 203
 204         return 0;
 205 }
 206
 207 static int xen_timerop_set_next_event(unsigned long delta,
 208                                       struct clock_event_device *evt)
 209 {
 210         WARN_ON(!clockevent_state_oneshot(evt));
 211
 212         if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
 213                 BUG();
 214
 215         /* We may have missed the deadline, but there's no real way of
 216            knowing for sure.  If the event was in the past, then we'll
 217            get an immediate interrupt. */
 218
 219         return 0;
 220 }
 221
 222 static struct clock_event_device xen_timerop_clockevent __ro_after_init = {
 223         .name                   = "xen",
 224         .features               = CLOCK_EVT_FEAT_ONESHOT,
 225
 226         .max_delta_ns           = 0xffffffff,
 227         .max_delta_ticks        = 0xffffffff,
 228         .min_delta_ns           = TIMER_SLOP,
 229         .min_delta_ticks        = TIMER_SLOP,
 230
 231         .mult                   = 1,
 232         .shift                  = 0,
 233         .rating                 = 500,
 234
 235         .set_state_shutdown     = xen_timerop_shutdown,
 236         .set_next_event         = xen_timerop_set_next_event,
 237 };
 238
 239 static int xen_vcpuop_shutdown(struct clock_event_device *evt)
 240 {
 241         int cpu = smp_processor_id();
 242
 243         if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, xen_vcpu_nr(cpu),
 244                                NULL) ||
 245             HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
 246                                NULL))
 247                 BUG();
 248
 249         return 0;
 250 }
 251
 252 static int xen_vcpuop_set_oneshot(struct clock_event_device *evt)
 253 {
 254         int cpu = smp_processor_id();
 255
 256         if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
 257                                NULL))
 258                 BUG();
 259
 260         return 0;
 261 }
 262
 263 static int xen_vcpuop_set_next_event(unsigned long delta,
 264                                      struct clock_event_device *evt)
 265 {
 266         int cpu = smp_processor_id();
 267         struct vcpu_set_singleshot_timer single;
 268         int ret;
 269
 270         WARN_ON(!clockevent_state_oneshot(evt));
 271
 272         single.timeout_abs_ns = get_abs_timeout(delta);
 273         /* Get an event anyway, even if the timeout is already expired */
 274         single.flags = 0;
 275
 276         ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, xen_vcpu_nr(cpu),
 277                                  &single);
 278         BUG_ON(ret != 0);
 279
 280         return ret;
 281 }
 282
 283 static struct clock_event_device xen_vcpuop_clockevent __ro_after_init = {
 284         .name = "xen",
 285         .features = CLOCK_EVT_FEAT_ONESHOT,
 286
 287         .max_delta_ns = 0xffffffff,
 288         .max_delta_ticks = 0xffffffff,
 289         .min_delta_ns = TIMER_SLOP,
 290         .min_delta_ticks = TIMER_SLOP,
 291
 292         .mult = 1,
 293         .shift = 0,
 294         .rating = 500,
 295
 296         .set_state_shutdown = xen_vcpuop_shutdown,
 297         .set_state_oneshot = xen_vcpuop_set_oneshot,
 298         .set_next_event = xen_vcpuop_set_next_event,
 299 };
 300
 301 static const struct clock_event_device *xen_clockevent =
 302         &xen_timerop_clockevent;
 303
 304 struct xen_clock_event_device {
 305         struct clock_event_device evt;
 306         char name[16];
 307 };
 308 static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };
 309
 310 static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
 311 {
 312         struct clock_event_device *evt = this_cpu_ptr(&xen_clock_events.evt);
 313         irqreturn_t ret;
 314
 315         ret = IRQ_NONE;
 316         if (evt->event_handler) {
 317                 evt->event_handler(evt);
 318                 ret = IRQ_HANDLED;
 319         }
 320
 321         return ret;
 322 }
 323
 324 void xen_teardown_timer(int cpu)
 325 {
 326         struct clock_event_device *evt;
 327         evt = &per_cpu(xen_clock_events, cpu).evt;
 328
 329         if (evt->irq >= 0) {
 330                 unbind_from_irqhandler(evt->irq, NULL);
 331                 evt->irq = -1;
 332         }
 333 }
 334
 335 void xen_setup_timer(int cpu)
 336 {
 337         struct xen_clock_event_device *xevt = &per_cpu(xen_clock_events, cpu);
 338         struct clock_event_device *evt = &xevt->evt;
 339         int irq;
 340
 341         WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);
 342         if (evt->irq >= 0)
 343                 xen_teardown_timer(cpu);
 344
 345         printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);
 346
 347         snprintf(xevt->name, sizeof(xevt->name), "timer%d", cpu);
 348
 349         irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
 350                                       IRQF_PERCPU|IRQF_NOBALANCING|IRQF_TIMER|
 351                                       IRQF_FORCE_RESUME|IRQF_EARLY_RESUME,
 352                                       xevt->name, NULL);
 353         (void)xen_set_irq_priority(irq, XEN_IRQ_PRIORITY_MAX);
 354
 355         memcpy(evt, xen_clockevent, sizeof(*evt));
 356
 357         evt->cpumask = cpumask_of(cpu);
 358         evt->irq = irq;
 359 }
 360
 361
 362 void xen_setup_cpu_clockevents(void)
 363 {
 364         clockevents_register_device(this_cpu_ptr(&xen_clock_events.evt));
 365 }
 366
 367 void xen_timer_resume(void)
 368 {
 369         int cpu;
 370
 371         if (xen_clockevent != &xen_vcpuop_clockevent)
 372                 return;
 373
 374         for_each_online_cpu(cpu) {
 375                 if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer,
 376                                        xen_vcpu_nr(cpu), NULL))
 377                         BUG();
 378         }
 379 }
 380
 381 static const struct pv_time_ops xen_time_ops __initconst = {
 382         .sched_clock = xen_sched_clock,
 383         .steal_clock = xen_steal_clock,
 384 };
 385
 386 static struct pvclock_vsyscall_time_info *xen_clock __read_mostly;
 387 static u64 xen_clock_value_saved;
 388
 389 void xen_save_time_memory_area(void)
 390 {
 391         struct vcpu_register_time_memory_area t;
 392         int ret;
 393
 394         xen_clock_value_saved = xen_clocksource_read() - xen_sched_clock_offset;
 395
 396         if (!xen_clock)
 397                 return;
 398
 399         t.addr.v = NULL;
 400
 401         ret = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_time_memory_area, 0, &t);
 402         if (ret != 0)
 403                 pr_notice("Cannot save secondary vcpu_time_info (err %d)",
 404                           ret);
 405         else
 406                 clear_page(xen_clock);
 407 }
 408
 409 void xen_restore_time_memory_area(void)
 410 {
 411         struct vcpu_register_time_memory_area t;
 412         int ret;
 413
 414         if (!xen_clock)
 415                 goto out;
 416
 417         t.addr.v = &xen_clock->pvti;
 418
 419         ret = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_time_memory_area, 0, &t);
 420
 421         /*
 422          * We don't disable VDSO_CLOCKMODE_PVCLOCK entirely if it fails to
 423          * register the secondary time info with Xen or if we migrated to a
 424          * host without the necessary flags. On both of these cases what
 425          * happens is either process seeing a zeroed out pvti or seeing no
 426          * PVCLOCK_TSC_STABLE_BIT bit set. Userspace checks the latter and
 427          * if 0, it discards the data in pvti and fallbacks to a system
 428          * call for a reliable timestamp.
 429          */
 430         if (ret != 0)
 431                 pr_notice("Cannot restore secondary vcpu_time_info (err %d)",
 432                           ret);
 433
 434 out:
 435         /* Need pvclock_resume() before using xen_clocksource_read(). */
 436         pvclock_resume();
 437         xen_sched_clock_offset = xen_clocksource_read() - xen_clock_value_saved;
 438 }
 439
 440 static void xen_setup_vsyscall_time_info(void)
 441 {
 442         struct vcpu_register_time_memory_area t;
 443         struct pvclock_vsyscall_time_info *ti;
 444         int ret;
 445
 446         ti = (struct pvclock_vsyscall_time_info *)get_zeroed_page(GFP_KERNEL);
 447         if (!ti)
 448                 return;
 449
 450         t.addr.v = &ti->pvti;
 451
 452         ret = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_time_memory_area, 0, &t);
 453         if (ret) {
 454                 pr_notice("xen: VDSO_CLOCKMODE_PVCLOCK not supported (err %d)\n", ret);
 455                 free_page((unsigned long)ti);
 456                 return;
 457         }
 458
 459         /*
 460          * If primary time info had this bit set, secondary should too since
 461          * it's the same data on both just different memory regions. But we
 462          * still check it in case hypervisor is buggy.
 463          */
 464         if (!(ti->pvti.flags & PVCLOCK_TSC_STABLE_BIT)) {
 465                 t.addr.v = NULL;
 466                 ret = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_time_memory_area,
 467                                          0, &t);
 468                 if (!ret)
 469                         free_page((unsigned long)ti);
 470
 471                 pr_notice("xen: VDSO_CLOCKMODE_PVCLOCK not supported (tsc unstable)\n");
 472                 return;
 473         }
 474
 475         xen_clock = ti;
 476         pvclock_set_pvti_cpu0_va(xen_clock);
 477
 478         xen_clocksource.vdso_clock_mode = VDSO_CLOCKMODE_PVCLOCK;
 479 }
 480
 481 static void __init xen_time_init(void)
 482 {
 483         struct pvclock_vcpu_time_info *pvti;
 484         int cpu = smp_processor_id();
 485         struct timespec64 tp;
 486
 487         /* As Dom0 is never moved, no penalty on using TSC there */
 488         if (xen_initial_domain())
 489                 xen_clocksource.rating = 275;
 490
 491         clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);
 492
 493         if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
 494                                NULL) == 0) {
 495                 /* Successfully turned off 100Hz tick, so we have the
 496                    vcpuop-based timer interface */
 497                 printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
 498                 xen_clockevent = &xen_vcpuop_clockevent;
 499         }
 500
 501         /* Set initial system time with full resolution */
 502         xen_read_wallclock(&tp);
 503         do_settimeofday64(&tp);
 504
 505         setup_force_cpu_cap(X86_FEATURE_TSC);
 506
 507         /*
 508          * We check ahead on the primary time info if this
 509          * bit is supported hence speeding up Xen clocksource.
 510          */
 511         pvti = &__this_cpu_read(xen_vcpu)->time;
 512         if (pvti->flags & PVCLOCK_TSC_STABLE_BIT) {
 513                 pvclock_set_flags(PVCLOCK_TSC_STABLE_BIT);
 514                 xen_setup_vsyscall_time_info();
 515         }
 516
 517         xen_setup_runstate_info(cpu);
 518         xen_setup_timer(cpu);
 519         xen_setup_cpu_clockevents();
 520
 521         xen_time_setup_guest();
 522
 523         if (xen_initial_domain())
 524                 pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
 525 }
 526
 527 void __init xen_init_time_ops(void)
 528 {
 529         xen_sched_clock_offset = xen_clocksource_read();
 530         pv_ops.time = xen_time_ops;
 531
 532         x86_init.timers.timer_init = xen_time_init;
 533         x86_init.timers.setup_percpu_clockev = x86_init_noop;
 534         x86_cpuinit.setup_percpu_clockev = x86_init_noop;
 535
 536         x86_platform.calibrate_tsc = xen_tsc_khz;
 537         x86_platform.get_wallclock = xen_get_wallclock;
 538         /* Dom0 uses the native method to set the hardware RTC. */
 539         if (!xen_initial_domain())
 540                 x86_platform.set_wallclock = xen_set_wallclock;
 541 }
 542
 543 #ifdef CONFIG_XEN_PVHVM
 544 static void xen_hvm_setup_cpu_clockevents(void)
 545 {
 546         int cpu = smp_processor_id();
 547         xen_setup_runstate_info(cpu);
 548         /*
 549          * xen_setup_timer(cpu) - snprintf is bad in atomic context. Hence
 550          * doing it xen_hvm_cpu_notify (which gets called by smp_init during
 551          * early bootup and also during CPU hotplug events).
 552          */
 553         xen_setup_cpu_clockevents();
 554 }
 555
 556 void __init xen_hvm_init_time_ops(void)
 557 {
 558         /*
 559          * vector callback is needed otherwise we cannot receive interrupts
 560          * on cpu > 0 and at this point we don't know how many cpus are
 561          * available.
 562          */
 563         if (!xen_have_vector_callback)
 564                 return;
 565
 566         if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
 567                 pr_info("Xen doesn't support pvclock on HVM, disable pv timer");
 568                 return;
 569         }
 570
 571         xen_sched_clock_offset = xen_clocksource_read();
 572         pv_ops.time = xen_time_ops;
 573         x86_init.timers.setup_percpu_clockev = xen_time_init;
 574         x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;
 575
 576         x86_platform.calibrate_tsc = xen_tsc_khz;
 577         x86_platform.get_wallclock = xen_get_wallclock;
 578         x86_platform.set_wallclock = xen_set_wallclock;
 579 }
 580 #endif
 581
 582 /* Kernel parameter to specify Xen timer slop */
 583 static int __init parse_xen_timer_slop(char *ptr)
 584 {
 585         unsigned long slop = memparse(ptr, NULL);
 586
 587         xen_timerop_clockevent.min_delta_ns = slop;
 588         xen_timerop_clockevent.min_delta_ticks = slop;
 589         xen_vcpuop_clockevent.min_delta_ns = slop;
 590         xen_vcpuop_clockevent.min_delta_ticks = slop;
 591
 592         return 0;
 593 }
 594 early_param("xen_timer_slop", parse_xen_timer_slop);