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