timer.c revision 330897
1/*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2009 Adrian Chadd 5 * Copyright (c) 2012 Spectra Logic Corporation 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 */ 30 31/** 32 * \file dev/xen/timer/timer.c 33 * \brief A timer driver for the Xen hypervisor's PV clock. 34 */ 35 36#include <sys/cdefs.h> 37__FBSDID("$FreeBSD: stable/11/sys/dev/xen/timer/timer.c 330897 2018-03-14 03:19:51Z eadler $"); 38 39#include <sys/param.h> 40#include <sys/systm.h> 41#include <sys/bus.h> 42#include <sys/kernel.h> 43#include <sys/module.h> 44#include <sys/time.h> 45#include <sys/timetc.h> 46#include <sys/timeet.h> 47#include <sys/smp.h> 48#include <sys/limits.h> 49#include <sys/clock.h> 50#include <sys/proc.h> 51 52#include <xen/xen-os.h> 53#include <xen/features.h> 54#include <xen/xen_intr.h> 55#include <xen/hypervisor.h> 56#include <xen/interface/io/xenbus.h> 57#include <xen/interface/vcpu.h> 58#include <xen/error.h> 59 60#include <machine/cpu.h> 61#include <machine/cpufunc.h> 62#include <machine/clock.h> 63#include <machine/_inttypes.h> 64#include <machine/smp.h> 65#include <machine/pvclock.h> 66 67#include <dev/xen/timer/timer.h> 68 69#include "clock_if.h" 70 71static devclass_t xentimer_devclass; 72 73#define NSEC_IN_SEC 1000000000ULL 74#define NSEC_IN_USEC 1000ULL 75/* 18446744073 = int(2^64 / NSEC_IN_SC) = 1 ns in 64-bit fractions */ 76#define FRAC_IN_NSEC 18446744073LL 77 78/* Xen timers may fire up to 100us off */ 79#define XENTIMER_MIN_PERIOD_IN_NSEC 100*NSEC_IN_USEC 80 81/* 82 * The real resolution of the PV clock is 1ns, but the highest 83 * resolution that FreeBSD supports is 1us, so just use that. 84 */ 85#define XENCLOCK_RESOLUTION 1 86 87#define XENTIMER_QUALITY 950 88 89struct xentimer_pcpu_data { 90 uint64_t timer; 91 uint64_t last_processed; 92 void *irq_handle; 93}; 94 95DPCPU_DEFINE(struct xentimer_pcpu_data, xentimer_pcpu); 96 97DPCPU_DECLARE(struct vcpu_info *, vcpu_info); 98 99struct xentimer_softc { 100 device_t dev; 101 struct timecounter tc; 102 struct eventtimer et; 103}; 104 105static void 106xentimer_identify(driver_t *driver, device_t parent) 107{ 108 if (!xen_domain()) 109 return; 110 111 /* Handle all Xen PV timers in one device instance. */ 112 if (devclass_get_device(xentimer_devclass, 0)) 113 return; 114 115 BUS_ADD_CHILD(parent, 0, "xen_et", 0); 116} 117 118static int 119xentimer_probe(device_t dev) 120{ 121 KASSERT((xen_domain()), ("Trying to use Xen timer on bare metal")); 122 /* 123 * In order to attach, this driver requires the following: 124 * - Vector callback support by the hypervisor, in order to deliver 125 * timer interrupts to the correct CPU for CPUs other than 0. 126 * - Access to the hypervisor shared info page, in order to look up 127 * each VCPU's timer information and the Xen wallclock time. 128 * - The hypervisor must say its PV clock is "safe" to use. 129 * - The hypervisor must support VCPUOP hypercalls. 130 * - The maximum number of CPUs supported by FreeBSD must not exceed 131 * the number of VCPUs supported by the hypervisor. 132 */ 133#define XTREQUIRES(condition, reason...) \ 134 if (!(condition)) { \ 135 device_printf(dev, ## reason); \ 136 device_detach(dev); \ 137 return (ENXIO); \ 138 } 139 140 if (xen_hvm_domain()) { 141 XTREQUIRES(xen_vector_callback_enabled, 142 "vector callbacks unavailable\n"); 143 XTREQUIRES(xen_feature(XENFEAT_hvm_safe_pvclock), 144 "HVM safe pvclock unavailable\n"); 145 } 146 XTREQUIRES(HYPERVISOR_shared_info != NULL, 147 "shared info page unavailable\n"); 148 XTREQUIRES(HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, 0, NULL) == 0, 149 "VCPUOPs interface unavailable\n"); 150#undef XTREQUIRES 151 device_set_desc(dev, "Xen PV Clock"); 152 return (BUS_PROBE_NOWILDCARD); 153} 154 155/** 156 * \brief Get the current time, in nanoseconds, since the hypervisor booted. 157 * 158 * \param vcpu vcpu_info structure to fetch the time from. 159 * 160 */ 161static uint64_t 162xen_fetch_vcpu_time(struct vcpu_info *vcpu) 163{ 164 struct pvclock_vcpu_time_info *time; 165 166 time = (struct pvclock_vcpu_time_info *) &vcpu->time; 167 168 return (pvclock_get_timecount(time)); 169} 170 171static uint32_t 172xentimer_get_timecount(struct timecounter *tc) 173{ 174 uint64_t vcpu_time; 175 176 /* 177 * We don't disable preemption here because the worst that can 178 * happen is reading the vcpu_info area of a different CPU than 179 * the one we are currently running on, but that would also 180 * return a valid tc (and we avoid the overhead of 181 * critical_{enter/exit} calls). 182 */ 183 vcpu_time = xen_fetch_vcpu_time(DPCPU_GET(vcpu_info)); 184 185 return (vcpu_time & UINT32_MAX); 186} 187 188/** 189 * \brief Fetch the hypervisor boot time, known as the "Xen wallclock". 190 * 191 * \param ts Timespec to store the current stable value. 192 * \param version Pointer to store the corresponding wallclock version. 193 * 194 * \note This value is updated when Domain-0 shifts its clock to follow 195 * clock drift, e.g. as detected by NTP. 196 */ 197static void 198xen_fetch_wallclock(struct timespec *ts) 199{ 200 shared_info_t *src = HYPERVISOR_shared_info; 201 struct pvclock_wall_clock *wc; 202 203 wc = (struct pvclock_wall_clock *) &src->wc_version; 204 205 pvclock_get_wallclock(wc, ts); 206} 207 208static void 209xen_fetch_uptime(struct timespec *ts) 210{ 211 uint64_t uptime; 212 213 uptime = xen_fetch_vcpu_time(DPCPU_GET(vcpu_info)); 214 215 ts->tv_sec = uptime / NSEC_IN_SEC; 216 ts->tv_nsec = uptime % NSEC_IN_SEC; 217} 218 219static int 220xentimer_settime(device_t dev __unused, struct timespec *ts) 221{ 222 struct xen_platform_op settime; 223 int ret; 224 225 /* 226 * Don't return EINVAL here; just silently fail if the domain isn't 227 * privileged enough to set the TOD. 228 */ 229 if (!xen_initial_domain()) 230 return (0); 231 232 settime.cmd = XENPF_settime64; 233 settime.u.settime64.mbz = 0; 234 settime.u.settime64.secs = ts->tv_sec; 235 settime.u.settime64.nsecs = ts->tv_nsec; 236 settime.u.settime64.system_time = 237 xen_fetch_vcpu_time(DPCPU_GET(vcpu_info)); 238 239 ret = HYPERVISOR_platform_op(&settime); 240 ret = ret != 0 ? xen_translate_error(ret) : 0; 241 if (ret != 0 && bootverbose) 242 device_printf(dev, "failed to set Xen PV clock: %d\n", ret); 243 244 return (ret); 245} 246 247/** 248 * \brief Return current time according to the Xen Hypervisor wallclock. 249 * 250 * \param dev Xentimer device. 251 * \param ts Pointer to store the wallclock time. 252 * 253 * \note The Xen time structures document the hypervisor start time and the 254 * uptime-since-hypervisor-start (in nsec.) They need to be combined 255 * in order to calculate a TOD clock. 256 */ 257static int 258xentimer_gettime(device_t dev, struct timespec *ts) 259{ 260 struct timespec u_ts; 261 262 timespecclear(ts); 263 xen_fetch_wallclock(ts); 264 xen_fetch_uptime(&u_ts); 265 timespecadd(ts, &u_ts); 266 267 return (0); 268} 269 270/** 271 * \brief Handle a timer interrupt for the Xen PV timer driver. 272 * 273 * \param arg Xen timer driver softc that is expecting the interrupt. 274 */ 275static int 276xentimer_intr(void *arg) 277{ 278 struct xentimer_softc *sc = (struct xentimer_softc *)arg; 279 struct xentimer_pcpu_data *pcpu = DPCPU_PTR(xentimer_pcpu); 280 281 pcpu->last_processed = xen_fetch_vcpu_time(DPCPU_GET(vcpu_info)); 282 if (pcpu->timer != 0 && sc->et.et_active) 283 sc->et.et_event_cb(&sc->et, sc->et.et_arg); 284 285 return (FILTER_HANDLED); 286} 287 288static int 289xentimer_vcpu_start_timer(int vcpu, uint64_t next_time) 290{ 291 struct vcpu_set_singleshot_timer single; 292 293 single.timeout_abs_ns = next_time; 294 /* Get an event anyway, even if the timeout is already expired */ 295 single.flags = 0; 296 return (HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, vcpu, &single)); 297} 298 299static int 300xentimer_vcpu_stop_timer(int vcpu) 301{ 302 303 return (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, vcpu, NULL)); 304} 305 306/** 307 * \brief Set the next oneshot time for the current CPU. 308 * 309 * \param et Xen timer driver event timer to schedule on. 310 * \param first Delta to the next time to schedule the interrupt for. 311 * \param period Not used. 312 * 313 * \note See eventtimers(9) for more information. 314 * \note 315 * 316 * \returns 0 317 */ 318static int 319xentimer_et_start(struct eventtimer *et, 320 sbintime_t first, sbintime_t period) 321{ 322 int error; 323 struct xentimer_softc *sc = et->et_priv; 324 int cpu = PCPU_GET(vcpu_id); 325 struct xentimer_pcpu_data *pcpu = DPCPU_PTR(xentimer_pcpu); 326 struct vcpu_info *vcpu = DPCPU_GET(vcpu_info); 327 uint64_t first_in_ns, next_time; 328#ifdef INVARIANTS 329 struct thread *td = curthread; 330#endif 331 332 KASSERT(td->td_critnest != 0, 333 ("xentimer_et_start called without preemption disabled")); 334 335 /* See sbttots() for this formula. */ 336 first_in_ns = (((first >> 32) * NSEC_IN_SEC) + 337 (((uint64_t)NSEC_IN_SEC * (uint32_t)first) >> 32)); 338 339 next_time = xen_fetch_vcpu_time(vcpu) + first_in_ns; 340 error = xentimer_vcpu_start_timer(cpu, next_time); 341 if (error) 342 panic("%s: Error %d setting singleshot timer to %"PRIu64"\n", 343 device_get_nameunit(sc->dev), error, next_time); 344 345 pcpu->timer = next_time; 346 return (error); 347} 348 349/** 350 * \brief Cancel the event timer's currently running timer, if any. 351 */ 352static int 353xentimer_et_stop(struct eventtimer *et) 354{ 355 int cpu = PCPU_GET(vcpu_id); 356 struct xentimer_pcpu_data *pcpu = DPCPU_PTR(xentimer_pcpu); 357 358 pcpu->timer = 0; 359 return (xentimer_vcpu_stop_timer(cpu)); 360} 361 362/** 363 * \brief Attach a Xen PV timer driver instance. 364 * 365 * \param dev Bus device object to attach. 366 * 367 * \note 368 * \returns EINVAL 369 */ 370static int 371xentimer_attach(device_t dev) 372{ 373 struct xentimer_softc *sc = device_get_softc(dev); 374 int error, i; 375 376 sc->dev = dev; 377 378 /* Bind an event channel to a VIRQ on each VCPU. */ 379 CPU_FOREACH(i) { 380 struct xentimer_pcpu_data *pcpu; 381 382 pcpu = DPCPU_ID_PTR(i, xentimer_pcpu); 383 error = HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, i, NULL); 384 if (error) { 385 device_printf(dev, "Error disabling Xen periodic timer " 386 "on CPU %d\n", i); 387 return (error); 388 } 389 390 error = xen_intr_bind_virq(dev, VIRQ_TIMER, i, xentimer_intr, 391 NULL, sc, INTR_TYPE_CLK, &pcpu->irq_handle); 392 if (error) { 393 device_printf(dev, "Error %d binding VIRQ_TIMER " 394 "to VCPU %d\n", error, i); 395 return (error); 396 } 397 xen_intr_describe(pcpu->irq_handle, "c%d", i); 398 } 399 400 /* Register the event timer. */ 401 sc->et.et_name = "XENTIMER"; 402 sc->et.et_quality = XENTIMER_QUALITY; 403 sc->et.et_flags = ET_FLAGS_ONESHOT | ET_FLAGS_PERCPU; 404 sc->et.et_frequency = NSEC_IN_SEC; 405 /* See tstosbt() for this formula */ 406 sc->et.et_min_period = (XENTIMER_MIN_PERIOD_IN_NSEC * 407 (((uint64_t)1 << 63) / 500000000) >> 32); 408 sc->et.et_max_period = ((sbintime_t)4 << 32); 409 sc->et.et_start = xentimer_et_start; 410 sc->et.et_stop = xentimer_et_stop; 411 sc->et.et_priv = sc; 412 et_register(&sc->et); 413 414 /* Register the timecounter. */ 415 sc->tc.tc_name = "XENTIMER"; 416 sc->tc.tc_quality = XENTIMER_QUALITY; 417 /* 418 * FIXME: due to the lack of ordering during resume, FreeBSD cannot 419 * guarantee that the Xen PV timer is resumed before any other device 420 * attempts to make use of it, so mark it as not safe for suspension 421 * (ie: remove the TC_FLAGS_SUSPEND_SAFE flag). 422 * 423 * NB: This was not a problem in previous FreeBSD versions because the 424 * timer was directly attached to the nexus, but it is an issue now 425 * that the timer is attached to the xenpv bus, and thus resumed 426 * later. 427 * 428 * sc->tc.tc_flags = TC_FLAGS_SUSPEND_SAFE; 429 */ 430 /* 431 * The underlying resolution is in nanoseconds, since the timer info 432 * scales TSC frequencies using a fraction that represents time in 433 * terms of nanoseconds. 434 */ 435 sc->tc.tc_frequency = NSEC_IN_SEC; 436 sc->tc.tc_counter_mask = ~0u; 437 sc->tc.tc_get_timecount = xentimer_get_timecount; 438 sc->tc.tc_priv = sc; 439 tc_init(&sc->tc); 440 441 /* Register the Hypervisor wall clock */ 442 clock_register(dev, XENCLOCK_RESOLUTION); 443 444 return (0); 445} 446 447static int 448xentimer_detach(device_t dev) 449{ 450 451 /* Implement Xen PV clock teardown - XXX see hpet_detach ? */ 452 /* If possible: 453 * 1. need to deregister timecounter 454 * 2. need to deregister event timer 455 * 3. need to deregister virtual IRQ event channels 456 */ 457 return (EBUSY); 458} 459 460static void 461xentimer_percpu_resume(void *arg) 462{ 463 device_t dev = (device_t) arg; 464 struct xentimer_softc *sc = device_get_softc(dev); 465 466 xentimer_et_start(&sc->et, sc->et.et_min_period, 0); 467} 468 469static int 470xentimer_resume(device_t dev) 471{ 472 int error; 473 int i; 474 475 /* Disable the periodic timer */ 476 CPU_FOREACH(i) { 477 error = HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, i, NULL); 478 if (error != 0) { 479 device_printf(dev, 480 "Error disabling Xen periodic timer on CPU %d\n", 481 i); 482 return (error); 483 } 484 } 485 486 /* Reset the last uptime value */ 487 pvclock_resume(); 488 489 /* Reset the RTC clock */ 490 inittodr(time_second); 491 492 /* Kick the timers on all CPUs */ 493 smp_rendezvous(NULL, xentimer_percpu_resume, NULL, dev); 494 495 if (bootverbose) 496 device_printf(dev, "resumed operation after suspension\n"); 497 498 return (0); 499} 500 501static int 502xentimer_suspend(device_t dev) 503{ 504 return (0); 505} 506 507/* 508 * Xen early clock init 509 */ 510void 511xen_clock_init(void) 512{ 513} 514 515/* 516 * Xen PV DELAY function 517 * 518 * When running on PVH mode we don't have an emulated i8524, so 519 * make use of the Xen time info in order to code a simple DELAY 520 * function that can be used during early boot. 521 */ 522void 523xen_delay(int n) 524{ 525 struct vcpu_info *vcpu = &HYPERVISOR_shared_info->vcpu_info[0]; 526 uint64_t end_ns; 527 uint64_t current; 528 529 end_ns = xen_fetch_vcpu_time(vcpu); 530 end_ns += n * NSEC_IN_USEC; 531 532 for (;;) { 533 current = xen_fetch_vcpu_time(vcpu); 534 if (current >= end_ns) 535 break; 536 } 537} 538 539static device_method_t xentimer_methods[] = { 540 DEVMETHOD(device_identify, xentimer_identify), 541 DEVMETHOD(device_probe, xentimer_probe), 542 DEVMETHOD(device_attach, xentimer_attach), 543 DEVMETHOD(device_detach, xentimer_detach), 544 DEVMETHOD(device_suspend, xentimer_suspend), 545 DEVMETHOD(device_resume, xentimer_resume), 546 /* clock interface */ 547 DEVMETHOD(clock_gettime, xentimer_gettime), 548 DEVMETHOD(clock_settime, xentimer_settime), 549 DEVMETHOD_END 550}; 551 552static driver_t xentimer_driver = { 553 "xen_et", 554 xentimer_methods, 555 sizeof(struct xentimer_softc), 556}; 557 558DRIVER_MODULE(xentimer, xenpv, xentimer_driver, xentimer_devclass, 0, 0); 559MODULE_DEPEND(xentimer, xenpv, 1, 1, 1); 560