Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
4 * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
5 * Copyright (C) 2012-2014 Cisco Systems
6 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
7 * Copyright (C) 2019 Intel Corporation
8 */
9
10#include <linux/clockchips.h>
11#include <linux/init.h>
12#include <linux/interrupt.h>
13#include <linux/jiffies.h>
14#include <linux/mm.h>
15#include <linux/sched.h>
16#include <linux/spinlock.h>
17#include <linux/threads.h>
18#include <asm/irq.h>
19#include <asm/param.h>
20#include <kern_util.h>
21#include <os.h>
22#include <linux/time-internal.h>
23#include <linux/um_timetravel.h>
24#include <shared/init.h>
25
26#ifdef CONFIG_UML_TIME_TRAVEL_SUPPORT
27enum time_travel_mode time_travel_mode;
28EXPORT_SYMBOL_GPL(time_travel_mode);
29
30static bool time_travel_start_set;
31static unsigned long long time_travel_start;
32static unsigned long long time_travel_time;
33static LIST_HEAD(time_travel_events);
34static unsigned long long time_travel_timer_interval;
35static unsigned long long time_travel_next_event;
36static struct time_travel_event time_travel_timer_event;
37static int time_travel_ext_fd = -1;
38static unsigned int time_travel_ext_waiting;
39static bool time_travel_ext_prev_request_valid;
40static unsigned long long time_travel_ext_prev_request;
41static bool time_travel_ext_free_until_valid;
42static unsigned long long time_travel_ext_free_until;
43
44static void time_travel_set_time(unsigned long long ns)
45{
46 if (unlikely(ns < time_travel_time))
47 panic("time-travel: time goes backwards %lld -> %lld\n",
48 time_travel_time, ns);
49 time_travel_time = ns;
50}
51
52enum time_travel_message_handling {
53 TTMH_IDLE,
54 TTMH_POLL,
55 TTMH_READ,
56};
57
58static void time_travel_handle_message(struct um_timetravel_msg *msg,
59 enum time_travel_message_handling mode)
60{
61 struct um_timetravel_msg resp = {
62 .op = UM_TIMETRAVEL_ACK,
63 };
64 int ret;
65
66 /*
67 * Poll outside the locked section (if we're not called to only read
68 * the response) so we can get interrupts for e.g. virtio while we're
69 * here, but then we need to lock to not get interrupted between the
70 * read of the message and write of the ACK.
71 */
72 if (mode != TTMH_READ) {
73 while (os_poll(1, &time_travel_ext_fd) != 0) {
74 if (mode == TTMH_IDLE) {
75 BUG_ON(!irqs_disabled());
76 local_irq_enable();
77 local_irq_disable();
78 }
79 }
80 }
81
82 ret = os_read_file(time_travel_ext_fd, msg, sizeof(*msg));
83
84 if (ret == 0)
85 panic("time-travel external link is broken\n");
86 if (ret != sizeof(*msg))
87 panic("invalid time-travel message - %d bytes\n", ret);
88
89 switch (msg->op) {
90 default:
91 WARN_ONCE(1, "time-travel: unexpected message %lld\n",
92 (unsigned long long)msg->op);
93 break;
94 case UM_TIMETRAVEL_ACK:
95 return;
96 case UM_TIMETRAVEL_RUN:
97 time_travel_set_time(msg->time);
98 break;
99 case UM_TIMETRAVEL_FREE_UNTIL:
100 time_travel_ext_free_until_valid = true;
101 time_travel_ext_free_until = msg->time;
102 break;
103 }
104
105 os_write_file(time_travel_ext_fd, &resp, sizeof(resp));
106}
107
108static u64 time_travel_ext_req(u32 op, u64 time)
109{
110 static int seq;
111 int mseq = ++seq;
112 struct um_timetravel_msg msg = {
113 .op = op,
114 .time = time,
115 .seq = mseq,
116 };
117 unsigned long flags;
118
119 /*
120 * We need to save interrupts here and only restore when we
121 * got the ACK - otherwise we can get interrupted and send
122 * another request while we're still waiting for an ACK, but
123 * the peer doesn't know we got interrupted and will send
124 * the ACKs in the same order as the message, but we'd need
125 * to see them in the opposite order ...
126 *
127 * This wouldn't matter *too* much, but some ACKs carry the
128 * current time (for UM_TIMETRAVEL_GET) and getting another
129 * ACK without a time would confuse us a lot!
130 *
131 * The sequence number assignment that happens here lets us
132 * debug such message handling issues more easily.
133 */
134 local_irq_save(flags);
135 os_write_file(time_travel_ext_fd, &msg, sizeof(msg));
136
137 while (msg.op != UM_TIMETRAVEL_ACK)
138 time_travel_handle_message(&msg, TTMH_READ);
139
140 if (msg.seq != mseq)
141 panic("time-travel: ACK message has different seqno! op=%d, seq=%d != %d time=%lld\n",
142 msg.op, msg.seq, mseq, msg.time);
143
144 if (op == UM_TIMETRAVEL_GET)
145 time_travel_set_time(msg.time);
146 local_irq_restore(flags);
147
148 return msg.time;
149}
150
151void __time_travel_wait_readable(int fd)
152{
153 int fds[2] = { fd, time_travel_ext_fd };
154 int ret;
155
156 if (time_travel_mode != TT_MODE_EXTERNAL)
157 return;
158
159 while ((ret = os_poll(2, fds))) {
160 struct um_timetravel_msg msg;
161
162 if (ret == 1)
163 time_travel_handle_message(&msg, TTMH_READ);
164 }
165}
166EXPORT_SYMBOL_GPL(__time_travel_wait_readable);
167
168static void time_travel_ext_update_request(unsigned long long time)
169{
170 if (time_travel_mode != TT_MODE_EXTERNAL)
171 return;
172
173 /* asked for exactly this time previously */
174 if (time_travel_ext_prev_request_valid &&
175 time == time_travel_ext_prev_request)
176 return;
177
178 time_travel_ext_prev_request = time;
179 time_travel_ext_prev_request_valid = true;
180 time_travel_ext_req(UM_TIMETRAVEL_REQUEST, time);
181}
182
183void __time_travel_propagate_time(void)
184{
185 time_travel_ext_req(UM_TIMETRAVEL_UPDATE, time_travel_time);
186}
187EXPORT_SYMBOL_GPL(__time_travel_propagate_time);
188
189/* returns true if we must do a wait to the simtime device */
190static bool time_travel_ext_request(unsigned long long time)
191{
192 /*
193 * If we received an external sync point ("free until") then we
194 * don't have to request/wait for anything until then, unless
195 * we're already waiting.
196 */
197 if (!time_travel_ext_waiting && time_travel_ext_free_until_valid &&
198 time < time_travel_ext_free_until)
199 return false;
200
201 time_travel_ext_update_request(time);
202 return true;
203}
204
205static void time_travel_ext_wait(bool idle)
206{
207 struct um_timetravel_msg msg = {
208 .op = UM_TIMETRAVEL_ACK,
209 };
210
211 time_travel_ext_prev_request_valid = false;
212 time_travel_ext_waiting++;
213
214 time_travel_ext_req(UM_TIMETRAVEL_WAIT, -1);
215
216 /*
217 * Here we are deep in the idle loop, so we have to break out of the
218 * kernel abstraction in a sense and implement this in terms of the
219 * UML system waiting on the VQ interrupt while sleeping, when we get
220 * the signal it'll call time_travel_ext_vq_notify_done() completing the
221 * call.
222 */
223 while (msg.op != UM_TIMETRAVEL_RUN)
224 time_travel_handle_message(&msg, idle ? TTMH_IDLE : TTMH_POLL);
225
226 time_travel_ext_waiting--;
227
228 /* we might request more stuff while polling - reset when we run */
229 time_travel_ext_prev_request_valid = false;
230}
231
232static void time_travel_ext_get_time(void)
233{
234 time_travel_ext_req(UM_TIMETRAVEL_GET, -1);
235}
236
237static void __time_travel_update_time(unsigned long long ns, bool idle)
238{
239 if (time_travel_mode == TT_MODE_EXTERNAL && time_travel_ext_request(ns))
240 time_travel_ext_wait(idle);
241 else
242 time_travel_set_time(ns);
243}
244
245static struct time_travel_event *time_travel_first_event(void)
246{
247 return list_first_entry_or_null(&time_travel_events,
248 struct time_travel_event,
249 list);
250}
251
252static void __time_travel_add_event(struct time_travel_event *e,
253 unsigned long long time)
254{
255 struct time_travel_event *tmp;
256 bool inserted = false;
257
258 if (WARN(time_travel_mode == TT_MODE_BASIC &&
259 e != &time_travel_timer_event,
260 "only timer events can be handled in basic mode"))
261 return;
262
263 if (e->pending)
264 return;
265
266 e->pending = true;
267 e->time = time;
268
269 list_for_each_entry(tmp, &time_travel_events, list) {
270 /*
271 * Add the new entry before one with higher time,
272 * or if they're equal and both on stack, because
273 * in that case we need to unwind the stack in the
274 * right order, and the later event (timer sleep
275 * or such) must be dequeued first.
276 */
277 if ((tmp->time > e->time) ||
278 (tmp->time == e->time && tmp->onstack && e->onstack)) {
279 list_add_tail(&e->list, &tmp->list);
280 inserted = true;
281 break;
282 }
283 }
284
285 if (!inserted)
286 list_add_tail(&e->list, &time_travel_events);
287
288 tmp = time_travel_first_event();
289 time_travel_ext_update_request(tmp->time);
290 time_travel_next_event = tmp->time;
291}
292
293static void time_travel_add_event(struct time_travel_event *e,
294 unsigned long long time)
295{
296 if (WARN_ON(!e->fn))
297 return;
298
299 __time_travel_add_event(e, time);
300}
301
302void time_travel_periodic_timer(struct time_travel_event *e)
303{
304 time_travel_add_event(&time_travel_timer_event,
305 time_travel_time + time_travel_timer_interval);
306 deliver_alarm();
307}
308
309static void time_travel_deliver_event(struct time_travel_event *e)
310{
311 if (e == &time_travel_timer_event) {
312 /*
313 * deliver_alarm() does the irq_enter/irq_exit
314 * by itself, so must handle it specially here
315 */
316 e->fn(e);
317 } else {
318 unsigned long flags;
319
320 local_irq_save(flags);
321 irq_enter();
322 e->fn(e);
323 irq_exit();
324 local_irq_restore(flags);
325 }
326}
327
328static bool time_travel_del_event(struct time_travel_event *e)
329{
330 if (!e->pending)
331 return false;
332 list_del(&e->list);
333 e->pending = false;
334 return true;
335}
336
337static void time_travel_update_time(unsigned long long next, bool idle)
338{
339 struct time_travel_event ne = {
340 .onstack = true,
341 };
342 struct time_travel_event *e;
343 bool finished = idle;
344
345 /* add it without a handler - we deal with that specifically below */
346 __time_travel_add_event(&ne, next);
347
348 do {
349 e = time_travel_first_event();
350
351 BUG_ON(!e);
352 __time_travel_update_time(e->time, idle);
353
354 /* new events may have been inserted while we were waiting */
355 if (e == time_travel_first_event()) {
356 BUG_ON(!time_travel_del_event(e));
357 BUG_ON(time_travel_time != e->time);
358
359 if (e == &ne) {
360 finished = true;
361 } else {
362 if (e->onstack)
363 panic("On-stack event dequeued outside of the stack! time=%lld, event time=%lld, event=%pS\n",
364 time_travel_time, e->time, e);
365 time_travel_deliver_event(e);
366 }
367 }
368
369 e = time_travel_first_event();
370 if (e)
371 time_travel_ext_update_request(e->time);
372 } while (ne.pending && !finished);
373
374 time_travel_del_event(&ne);
375}
376
377void time_travel_ndelay(unsigned long nsec)
378{
379 time_travel_update_time(time_travel_time + nsec, false);
380}
381EXPORT_SYMBOL(time_travel_ndelay);
382
383void time_travel_add_irq_event(struct time_travel_event *e)
384{
385 BUG_ON(time_travel_mode != TT_MODE_EXTERNAL);
386
387 time_travel_ext_get_time();
388 /*
389 * We could model interrupt latency here, for now just
390 * don't have any latency at all and request the exact
391 * same time (again) to run the interrupt...
392 */
393 time_travel_add_event(e, time_travel_time);
394}
395EXPORT_SYMBOL_GPL(time_travel_add_irq_event);
396
397static void time_travel_oneshot_timer(struct time_travel_event *e)
398{
399 deliver_alarm();
400}
401
402void time_travel_sleep(unsigned long long duration)
403{
404 unsigned long long next = time_travel_time + duration;
405
406 if (time_travel_mode == TT_MODE_BASIC)
407 os_timer_disable();
408
409 time_travel_update_time(next, true);
410
411 if (time_travel_mode == TT_MODE_BASIC &&
412 time_travel_timer_event.pending) {
413 if (time_travel_timer_event.fn == time_travel_periodic_timer) {
414 /*
415 * This is somewhat wrong - we should get the first
416 * one sooner like the os_timer_one_shot() below...
417 */
418 os_timer_set_interval(time_travel_timer_interval);
419 } else {
420 os_timer_one_shot(time_travel_timer_event.time - next);
421 }
422 }
423}
424
425static void time_travel_handle_real_alarm(void)
426{
427 time_travel_set_time(time_travel_next_event);
428
429 time_travel_del_event(&time_travel_timer_event);
430
431 if (time_travel_timer_event.fn == time_travel_periodic_timer)
432 time_travel_add_event(&time_travel_timer_event,
433 time_travel_time +
434 time_travel_timer_interval);
435}
436
437static void time_travel_set_interval(unsigned long long interval)
438{
439 time_travel_timer_interval = interval;
440}
441
442static int time_travel_connect_external(const char *socket)
443{
444 const char *sep;
445 unsigned long long id = (unsigned long long)-1;
446 int rc;
447
448 if ((sep = strchr(socket, ':'))) {
449 char buf[25] = {};
450 if (sep - socket > sizeof(buf) - 1)
451 goto invalid_number;
452
453 memcpy(buf, socket, sep - socket);
454 if (kstrtoull(buf, 0, &id)) {
455invalid_number:
456 panic("time-travel: invalid external ID in string '%s'\n",
457 socket);
458 return -EINVAL;
459 }
460
461 socket = sep + 1;
462 }
463
464 rc = os_connect_socket(socket);
465 if (rc < 0) {
466 panic("time-travel: failed to connect to external socket %s\n",
467 socket);
468 return rc;
469 }
470
471 time_travel_ext_fd = rc;
472
473 time_travel_ext_req(UM_TIMETRAVEL_START, id);
474
475 return 1;
476}
477#else /* CONFIG_UML_TIME_TRAVEL_SUPPORT */
478#define time_travel_start_set 0
479#define time_travel_start 0
480#define time_travel_time 0
481
482static inline void time_travel_update_time(unsigned long long ns, bool retearly)
483{
484}
485
486static inline void time_travel_handle_real_alarm(void)
487{
488}
489
490static void time_travel_set_interval(unsigned long long interval)
491{
492}
493
494/* fail link if this actually gets used */
495extern u64 time_travel_ext_req(u32 op, u64 time);
496
497/* these are empty macros so the struct/fn need not exist */
498#define time_travel_add_event(e, time) do { } while (0)
499#define time_travel_del_event(e) do { } while (0)
500#endif
501
502void timer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
503{
504 unsigned long flags;
505
506 /*
507 * In basic time-travel mode we still get real interrupts
508 * (signals) but since we don't read time from the OS, we
509 * must update the simulated time here to the expiry when
510 * we get a signal.
511 * This is not the case in inf-cpu mode, since there we
512 * never get any real signals from the OS.
513 */
514 if (time_travel_mode == TT_MODE_BASIC)
515 time_travel_handle_real_alarm();
516
517 local_irq_save(flags);
518 do_IRQ(TIMER_IRQ, regs);
519 local_irq_restore(flags);
520}
521
522static int itimer_shutdown(struct clock_event_device *evt)
523{
524 if (time_travel_mode != TT_MODE_OFF)
525 time_travel_del_event(&time_travel_timer_event);
526
527 if (time_travel_mode != TT_MODE_INFCPU &&
528 time_travel_mode != TT_MODE_EXTERNAL)
529 os_timer_disable();
530
531 return 0;
532}
533
534static int itimer_set_periodic(struct clock_event_device *evt)
535{
536 unsigned long long interval = NSEC_PER_SEC / HZ;
537
538 if (time_travel_mode != TT_MODE_OFF) {
539 time_travel_del_event(&time_travel_timer_event);
540 time_travel_set_event_fn(&time_travel_timer_event,
541 time_travel_periodic_timer);
542 time_travel_set_interval(interval);
543 time_travel_add_event(&time_travel_timer_event,
544 time_travel_time + interval);
545 }
546
547 if (time_travel_mode != TT_MODE_INFCPU &&
548 time_travel_mode != TT_MODE_EXTERNAL)
549 os_timer_set_interval(interval);
550
551 return 0;
552}
553
554static int itimer_next_event(unsigned long delta,
555 struct clock_event_device *evt)
556{
557 delta += 1;
558
559 if (time_travel_mode != TT_MODE_OFF) {
560 time_travel_del_event(&time_travel_timer_event);
561 time_travel_set_event_fn(&time_travel_timer_event,
562 time_travel_oneshot_timer);
563 time_travel_add_event(&time_travel_timer_event,
564 time_travel_time + delta);
565 }
566
567 if (time_travel_mode != TT_MODE_INFCPU &&
568 time_travel_mode != TT_MODE_EXTERNAL)
569 return os_timer_one_shot(delta);
570
571 return 0;
572}
573
574static int itimer_one_shot(struct clock_event_device *evt)
575{
576 return itimer_next_event(0, evt);
577}
578
579static struct clock_event_device timer_clockevent = {
580 .name = "posix-timer",
581 .rating = 250,
582 .cpumask = cpu_possible_mask,
583 .features = CLOCK_EVT_FEAT_PERIODIC |
584 CLOCK_EVT_FEAT_ONESHOT,
585 .set_state_shutdown = itimer_shutdown,
586 .set_state_periodic = itimer_set_periodic,
587 .set_state_oneshot = itimer_one_shot,
588 .set_next_event = itimer_next_event,
589 .shift = 0,
590 .max_delta_ns = 0xffffffff,
591 .max_delta_ticks = 0xffffffff,
592 .min_delta_ns = TIMER_MIN_DELTA,
593 .min_delta_ticks = TIMER_MIN_DELTA, // microsecond resolution should be enough for anyone, same as 640K RAM
594 .irq = 0,
595 .mult = 1,
596};
597
598static irqreturn_t um_timer(int irq, void *dev)
599{
600 if (get_current()->mm != NULL)
601 {
602 /* userspace - relay signal, results in correct userspace timers */
603 os_alarm_process(get_current()->mm->context.id.u.pid);
604 }
605
606 (*timer_clockevent.event_handler)(&timer_clockevent);
607
608 return IRQ_HANDLED;
609}
610
611static u64 timer_read(struct clocksource *cs)
612{
613 if (time_travel_mode != TT_MODE_OFF) {
614 /*
615 * We make reading the timer cost a bit so that we don't get
616 * stuck in loops that expect time to move more than the
617 * exact requested sleep amount, e.g. python's socket server,
618 * see https://bugs.python.org/issue37026.
619 *
620 * However, don't do that when we're in interrupt or such as
621 * then we might recurse into our own processing, and get to
622 * even more waiting, and that's not good - it messes up the
623 * "what do I do next" and onstack event we use to know when
624 * to return from time_travel_update_time().
625 */
626 if (!irqs_disabled() && !in_interrupt() && !in_softirq())
627 time_travel_update_time(time_travel_time +
628 TIMER_MULTIPLIER,
629 false);
630 return time_travel_time / TIMER_MULTIPLIER;
631 }
632
633 return os_nsecs() / TIMER_MULTIPLIER;
634}
635
636static struct clocksource timer_clocksource = {
637 .name = "timer",
638 .rating = 300,
639 .read = timer_read,
640 .mask = CLOCKSOURCE_MASK(64),
641 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
642};
643
644static void __init um_timer_setup(void)
645{
646 int err;
647
648 err = request_irq(TIMER_IRQ, um_timer, IRQF_TIMER, "hr timer", NULL);
649 if (err != 0)
650 printk(KERN_ERR "register_timer : request_irq failed - "
651 "errno = %d\n", -err);
652
653 err = os_timer_create();
654 if (err != 0) {
655 printk(KERN_ERR "creation of timer failed - errno = %d\n", -err);
656 return;
657 }
658
659 err = clocksource_register_hz(&timer_clocksource, NSEC_PER_SEC/TIMER_MULTIPLIER);
660 if (err) {
661 printk(KERN_ERR "clocksource_register_hz returned %d\n", err);
662 return;
663 }
664 clockevents_register_device(&timer_clockevent);
665}
666
667void read_persistent_clock64(struct timespec64 *ts)
668{
669 long long nsecs;
670
671 if (time_travel_start_set)
672 nsecs = time_travel_start + time_travel_time;
673 else if (time_travel_mode == TT_MODE_EXTERNAL)
674 nsecs = time_travel_ext_req(UM_TIMETRAVEL_GET_TOD, -1);
675 else
676 nsecs = os_persistent_clock_emulation();
677
678 set_normalized_timespec64(ts, nsecs / NSEC_PER_SEC,
679 nsecs % NSEC_PER_SEC);
680}
681
682void __init time_init(void)
683{
684 timer_set_signal_handler();
685 late_time_init = um_timer_setup;
686}
687
688#ifdef CONFIG_UML_TIME_TRAVEL_SUPPORT
689unsigned long calibrate_delay_is_known(void)
690{
691 if (time_travel_mode == TT_MODE_INFCPU ||
692 time_travel_mode == TT_MODE_EXTERNAL)
693 return 1;
694 return 0;
695}
696
697int setup_time_travel(char *str)
698{
699 if (strcmp(str, "=inf-cpu") == 0) {
700 time_travel_mode = TT_MODE_INFCPU;
701 timer_clockevent.name = "time-travel-timer-infcpu";
702 timer_clocksource.name = "time-travel-clock";
703 return 1;
704 }
705
706 if (strncmp(str, "=ext:", 5) == 0) {
707 time_travel_mode = TT_MODE_EXTERNAL;
708 timer_clockevent.name = "time-travel-timer-external";
709 timer_clocksource.name = "time-travel-clock-external";
710 return time_travel_connect_external(str + 5);
711 }
712
713 if (!*str) {
714 time_travel_mode = TT_MODE_BASIC;
715 timer_clockevent.name = "time-travel-timer";
716 timer_clocksource.name = "time-travel-clock";
717 return 1;
718 }
719
720 return -EINVAL;
721}
722
723__setup("time-travel", setup_time_travel);
724__uml_help(setup_time_travel,
725"time-travel\n"
726"This option just enables basic time travel mode, in which the clock/timers\n"
727"inside the UML instance skip forward when there's nothing to do, rather than\n"
728"waiting for real time to elapse. However, instance CPU speed is limited by\n"
729"the real CPU speed, so e.g. a 10ms timer will always fire after ~10ms wall\n"
730"clock (but quicker when there's nothing to do).\n"
731"\n"
732"time-travel=inf-cpu\n"
733"This enables time travel mode with infinite processing power, in which there\n"
734"are no wall clock timers, and any CPU processing happens - as seen from the\n"
735"guest - instantly. This can be useful for accurate simulation regardless of\n"
736"debug overhead, physical CPU speed, etc. but is somewhat dangerous as it can\n"
737"easily lead to getting stuck (e.g. if anything in the system busy loops).\n"
738"\n"
739"time-travel=ext:[ID:]/path/to/socket\n"
740"This enables time travel mode similar to =inf-cpu, except the system will\n"
741"use the given socket to coordinate with a central scheduler, in order to\n"
742"have more than one system simultaneously be on simulated time. The virtio\n"
743"driver code in UML knows about this so you can also simulate networks and\n"
744"devices using it, assuming the device has the right capabilities.\n"
745"The optional ID is a 64-bit integer that's sent to the central scheduler.\n");
746
747int setup_time_travel_start(char *str)
748{
749 int err;
750
751 err = kstrtoull(str, 0, &time_travel_start);
752 if (err)
753 return err;
754
755 time_travel_start_set = 1;
756 return 1;
757}
758
759__setup("time-travel-start", setup_time_travel_start);
760__uml_help(setup_time_travel_start,
761"time-travel-start=<seconds>\n"
762"Configure the UML instance's wall clock to start at this value rather than\n"
763"the host's wall clock at the time of UML boot.\n");
764#endif
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
4 * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
5 * Copyright (C) 2012-2014 Cisco Systems
6 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
7 * Copyright (C) 2019 Intel Corporation
8 */
9
10#include <linux/clockchips.h>
11#include <linux/init.h>
12#include <linux/interrupt.h>
13#include <linux/jiffies.h>
14#include <linux/mm.h>
15#include <linux/sched.h>
16#include <linux/spinlock.h>
17#include <linux/threads.h>
18#include <asm/irq.h>
19#include <asm/param.h>
20#include <kern_util.h>
21#include <os.h>
22#include <linux/delay.h>
23#include <linux/time-internal.h>
24#include <linux/um_timetravel.h>
25#include <shared/init.h>
26
27#ifdef CONFIG_UML_TIME_TRAVEL_SUPPORT
28#include <linux/sched/clock.h>
29
30enum time_travel_mode time_travel_mode;
31EXPORT_SYMBOL_GPL(time_travel_mode);
32
33static bool time_travel_start_set;
34static unsigned long long time_travel_start;
35static unsigned long long time_travel_time;
36static unsigned long long time_travel_shm_offset;
37static LIST_HEAD(time_travel_events);
38static LIST_HEAD(time_travel_irqs);
39static unsigned long long time_travel_timer_interval;
40static unsigned long long time_travel_next_event;
41static struct time_travel_event time_travel_timer_event;
42static int time_travel_ext_fd = -1;
43static unsigned int time_travel_ext_waiting;
44static bool time_travel_ext_prev_request_valid;
45static unsigned long long time_travel_ext_prev_request;
46static unsigned long long *time_travel_ext_free_until;
47static unsigned long long _time_travel_ext_free_until;
48static u16 time_travel_shm_id;
49static struct um_timetravel_schedshm *time_travel_shm;
50static union um_timetravel_schedshm_client *time_travel_shm_client;
51
52unsigned long tt_extra_sched_jiffies;
53
54notrace unsigned long long sched_clock(void)
55{
56 return (unsigned long long)(jiffies - INITIAL_JIFFIES +
57 tt_extra_sched_jiffies)
58 * (NSEC_PER_SEC / HZ);
59}
60
61static void time_travel_set_time(unsigned long long ns)
62{
63 if (unlikely(ns < time_travel_time))
64 panic("time-travel: time goes backwards %lld -> %lld\n",
65 time_travel_time, ns);
66 else if (unlikely(ns >= S64_MAX))
67 panic("The system was going to sleep forever, aborting");
68
69 time_travel_time = ns;
70}
71
72enum time_travel_message_handling {
73 TTMH_IDLE,
74 TTMH_POLL,
75 TTMH_READ,
76 TTMH_READ_START_ACK,
77};
78
79static u64 bc_message;
80int time_travel_should_print_bc_msg;
81
82void _time_travel_print_bc_msg(void)
83{
84 time_travel_should_print_bc_msg = 0;
85 printk(KERN_INFO "time-travel: received broadcast 0x%llx\n", bc_message);
86}
87
88static void time_travel_setup_shm(int fd, u16 id)
89{
90 u32 len;
91
92 time_travel_shm = os_mmap_rw_shared(fd, sizeof(*time_travel_shm));
93
94 if (!time_travel_shm)
95 goto out;
96
97 len = time_travel_shm->len;
98
99 if (time_travel_shm->version != UM_TIMETRAVEL_SCHEDSHM_VERSION ||
100 len < struct_size(time_travel_shm, clients, id + 1)) {
101 os_unmap_memory(time_travel_shm, sizeof(*time_travel_shm));
102 time_travel_shm = NULL;
103 goto out;
104 }
105
106 time_travel_shm = os_mremap_rw_shared(time_travel_shm,
107 sizeof(*time_travel_shm),
108 len);
109 if (!time_travel_shm)
110 goto out;
111
112 time_travel_shm_offset = time_travel_shm->current_time;
113 time_travel_shm_client = &time_travel_shm->clients[id];
114 time_travel_shm_client->capa |= UM_TIMETRAVEL_SCHEDSHM_CAP_TIME_SHARE;
115 time_travel_shm_id = id;
116 /* always look at that free_until from now on */
117 time_travel_ext_free_until = &time_travel_shm->free_until;
118out:
119 os_close_file(fd);
120}
121
122static void time_travel_handle_message(struct um_timetravel_msg *msg,
123 enum time_travel_message_handling mode)
124{
125 struct um_timetravel_msg resp = {
126 .op = UM_TIMETRAVEL_ACK,
127 };
128 int ret;
129
130 /*
131 * We can't unlock here, but interrupt signals with a timetravel_handler
132 * (see um_request_irq_tt) get to the timetravel_handler anyway.
133 */
134 if (mode != TTMH_READ) {
135 BUG_ON(mode == TTMH_IDLE && !irqs_disabled());
136
137 while (os_poll(1, &time_travel_ext_fd) != 0) {
138 /* nothing */
139 }
140 }
141
142 if (unlikely(mode == TTMH_READ_START_ACK)) {
143 int fd[UM_TIMETRAVEL_SHARED_MAX_FDS];
144
145 ret = os_rcv_fd_msg(time_travel_ext_fd, fd,
146 ARRAY_SIZE(fd), msg, sizeof(*msg));
147 if (ret == sizeof(*msg)) {
148 time_travel_setup_shm(fd[UM_TIMETRAVEL_SHARED_MEMFD],
149 msg->time & UM_TIMETRAVEL_START_ACK_ID);
150 /* we don't use the logging for now */
151 os_close_file(fd[UM_TIMETRAVEL_SHARED_LOGFD]);
152 }
153 } else {
154 ret = os_read_file(time_travel_ext_fd, msg, sizeof(*msg));
155 }
156
157 if (ret == 0)
158 panic("time-travel external link is broken\n");
159 if (ret != sizeof(*msg))
160 panic("invalid time-travel message - %d bytes\n", ret);
161
162 switch (msg->op) {
163 default:
164 WARN_ONCE(1, "time-travel: unexpected message %lld\n",
165 (unsigned long long)msg->op);
166 break;
167 case UM_TIMETRAVEL_ACK:
168 return;
169 case UM_TIMETRAVEL_RUN:
170 time_travel_set_time(msg->time);
171 if (time_travel_shm) {
172 /* no request right now since we're running */
173 time_travel_shm_client->flags &=
174 ~UM_TIMETRAVEL_SCHEDSHM_FLAGS_REQ_RUN;
175 /* no ack for shared memory RUN */
176 return;
177 }
178 break;
179 case UM_TIMETRAVEL_FREE_UNTIL:
180 /* not supposed to get this with shm, but ignore it */
181 if (time_travel_shm)
182 break;
183 time_travel_ext_free_until = &_time_travel_ext_free_until;
184 _time_travel_ext_free_until = msg->time;
185 break;
186 case UM_TIMETRAVEL_BROADCAST:
187 bc_message = msg->time;
188 time_travel_should_print_bc_msg = 1;
189 break;
190 }
191
192 resp.seq = msg->seq;
193 os_write_file(time_travel_ext_fd, &resp, sizeof(resp));
194}
195
196static u64 time_travel_ext_req(u32 op, u64 time)
197{
198 static int seq;
199 int mseq = ++seq;
200 struct um_timetravel_msg msg = {
201 .op = op,
202 .time = time,
203 .seq = mseq,
204 };
205
206 /*
207 * We need to block even the timetravel handlers of SIGIO here and
208 * only restore their use when we got the ACK - otherwise we may
209 * (will) get interrupted by that, try to queue the IRQ for future
210 * processing and thus send another request while we're still waiting
211 * for an ACK, but the peer doesn't know we got interrupted and will
212 * send the ACKs in the same order as the message, but we'd need to
213 * see them in the opposite order ...
214 *
215 * This wouldn't matter *too* much, but some ACKs carry the
216 * current time (for UM_TIMETRAVEL_GET) and getting another
217 * ACK without a time would confuse us a lot!
218 *
219 * The sequence number assignment that happens here lets us
220 * debug such message handling issues more easily.
221 */
222 block_signals_hard();
223 os_write_file(time_travel_ext_fd, &msg, sizeof(msg));
224
225 /* no ACK expected for WAIT in shared memory mode */
226 if (msg.op == UM_TIMETRAVEL_WAIT && time_travel_shm)
227 goto done;
228
229 while (msg.op != UM_TIMETRAVEL_ACK)
230 time_travel_handle_message(&msg,
231 op == UM_TIMETRAVEL_START ?
232 TTMH_READ_START_ACK :
233 TTMH_READ);
234
235 if (msg.seq != mseq)
236 panic("time-travel: ACK message has different seqno! op=%d, seq=%d != %d time=%lld\n",
237 msg.op, msg.seq, mseq, msg.time);
238
239 if (op == UM_TIMETRAVEL_GET)
240 time_travel_set_time(msg.time);
241done:
242 unblock_signals_hard();
243
244 return msg.time;
245}
246
247void __time_travel_wait_readable(int fd)
248{
249 int fds[2] = { fd, time_travel_ext_fd };
250 int ret;
251
252 if (time_travel_mode != TT_MODE_EXTERNAL)
253 return;
254
255 while ((ret = os_poll(2, fds))) {
256 struct um_timetravel_msg msg;
257
258 if (ret == 1)
259 time_travel_handle_message(&msg, TTMH_READ);
260 }
261}
262EXPORT_SYMBOL_GPL(__time_travel_wait_readable);
263
264static void time_travel_ext_update_request(unsigned long long time)
265{
266 if (time_travel_mode != TT_MODE_EXTERNAL)
267 return;
268
269 /* asked for exactly this time previously */
270 if (time_travel_ext_prev_request_valid &&
271 time == time_travel_ext_prev_request)
272 return;
273
274 /*
275 * if we're running and are allowed to run past the request
276 * then we don't need to update it either
277 *
278 * Note for shm we ignore FREE_UNTIL messages and leave the pointer
279 * to shared memory, and for non-shm the offset is 0.
280 */
281 if (!time_travel_ext_waiting && time_travel_ext_free_until &&
282 time < (*time_travel_ext_free_until - time_travel_shm_offset))
283 return;
284
285 time_travel_ext_prev_request = time;
286 time_travel_ext_prev_request_valid = true;
287
288 if (time_travel_shm) {
289 union um_timetravel_schedshm_client *running;
290
291 running = &time_travel_shm->clients[time_travel_shm->running_id];
292
293 if (running->capa & UM_TIMETRAVEL_SCHEDSHM_CAP_TIME_SHARE) {
294 time_travel_shm_client->flags |=
295 UM_TIMETRAVEL_SCHEDSHM_FLAGS_REQ_RUN;
296 time += time_travel_shm_offset;
297 time_travel_shm_client->req_time = time;
298 if (time < time_travel_shm->free_until)
299 time_travel_shm->free_until = time;
300 return;
301 }
302 }
303
304 time_travel_ext_req(UM_TIMETRAVEL_REQUEST, time);
305}
306
307void __time_travel_propagate_time(void)
308{
309 static unsigned long long last_propagated;
310
311 if (time_travel_shm) {
312 if (time_travel_shm->running_id != time_travel_shm_id)
313 panic("time-travel: setting time while not running\n");
314 time_travel_shm->current_time = time_travel_time +
315 time_travel_shm_offset;
316 return;
317 }
318
319 if (last_propagated == time_travel_time)
320 return;
321
322 time_travel_ext_req(UM_TIMETRAVEL_UPDATE, time_travel_time);
323 last_propagated = time_travel_time;
324}
325EXPORT_SYMBOL_GPL(__time_travel_propagate_time);
326
327/* returns true if we must do a wait to the simtime device */
328static bool time_travel_ext_request(unsigned long long time)
329{
330 /*
331 * If we received an external sync point ("free until") then we
332 * don't have to request/wait for anything until then, unless
333 * we're already waiting.
334 *
335 * Note for shm we ignore FREE_UNTIL messages and leave the pointer
336 * to shared memory, and for non-shm the offset is 0.
337 */
338 if (!time_travel_ext_waiting && time_travel_ext_free_until &&
339 time < (*time_travel_ext_free_until - time_travel_shm_offset))
340 return false;
341
342 time_travel_ext_update_request(time);
343 return true;
344}
345
346static void time_travel_ext_wait(bool idle)
347{
348 struct um_timetravel_msg msg = {
349 .op = UM_TIMETRAVEL_ACK,
350 };
351
352 time_travel_ext_prev_request_valid = false;
353 if (!time_travel_shm)
354 time_travel_ext_free_until = NULL;
355 time_travel_ext_waiting++;
356
357 time_travel_ext_req(UM_TIMETRAVEL_WAIT, -1);
358
359 /*
360 * Here we are deep in the idle loop, so we have to break out of the
361 * kernel abstraction in a sense and implement this in terms of the
362 * UML system waiting on the VQ interrupt while sleeping, when we get
363 * the signal it'll call time_travel_ext_vq_notify_done() completing the
364 * call.
365 */
366 while (msg.op != UM_TIMETRAVEL_RUN)
367 time_travel_handle_message(&msg, idle ? TTMH_IDLE : TTMH_POLL);
368
369 time_travel_ext_waiting--;
370
371 /* we might request more stuff while polling - reset when we run */
372 time_travel_ext_prev_request_valid = false;
373}
374
375static void time_travel_ext_get_time(void)
376{
377 if (time_travel_shm)
378 time_travel_set_time(time_travel_shm->current_time -
379 time_travel_shm_offset);
380 else
381 time_travel_ext_req(UM_TIMETRAVEL_GET, -1);
382}
383
384static void __time_travel_update_time(unsigned long long ns, bool idle)
385{
386 if (time_travel_mode == TT_MODE_EXTERNAL && time_travel_ext_request(ns))
387 time_travel_ext_wait(idle);
388 else
389 time_travel_set_time(ns);
390}
391
392static struct time_travel_event *time_travel_first_event(void)
393{
394 return list_first_entry_or_null(&time_travel_events,
395 struct time_travel_event,
396 list);
397}
398
399static void __time_travel_add_event(struct time_travel_event *e,
400 unsigned long long time)
401{
402 struct time_travel_event *tmp;
403 bool inserted = false;
404 unsigned long flags;
405
406 if (e->pending)
407 return;
408
409 e->pending = true;
410 e->time = time;
411
412 local_irq_save(flags);
413 list_for_each_entry(tmp, &time_travel_events, list) {
414 /*
415 * Add the new entry before one with higher time,
416 * or if they're equal and both on stack, because
417 * in that case we need to unwind the stack in the
418 * right order, and the later event (timer sleep
419 * or such) must be dequeued first.
420 */
421 if ((tmp->time > e->time) ||
422 (tmp->time == e->time && tmp->onstack && e->onstack)) {
423 list_add_tail(&e->list, &tmp->list);
424 inserted = true;
425 break;
426 }
427 }
428
429 if (!inserted)
430 list_add_tail(&e->list, &time_travel_events);
431
432 tmp = time_travel_first_event();
433 time_travel_ext_update_request(tmp->time);
434 time_travel_next_event = tmp->time;
435 local_irq_restore(flags);
436}
437
438static void time_travel_add_event(struct time_travel_event *e,
439 unsigned long long time)
440{
441 if (WARN_ON(!e->fn))
442 return;
443
444 __time_travel_add_event(e, time);
445}
446
447void time_travel_add_event_rel(struct time_travel_event *e,
448 unsigned long long delay_ns)
449{
450 time_travel_add_event(e, time_travel_time + delay_ns);
451}
452
453static void time_travel_periodic_timer(struct time_travel_event *e)
454{
455 time_travel_add_event(&time_travel_timer_event,
456 time_travel_time + time_travel_timer_interval);
457
458 /* clock tick; decrease extra jiffies by keeping sched_clock constant */
459 if (tt_extra_sched_jiffies > 0)
460 tt_extra_sched_jiffies -= 1;
461
462 deliver_alarm();
463}
464
465void deliver_time_travel_irqs(void)
466{
467 struct time_travel_event *e;
468 unsigned long flags;
469
470 /*
471 * Don't do anything for most cases. Note that because here we have
472 * to disable IRQs (and re-enable later) we'll actually recurse at
473 * the end of the function, so this is strictly necessary.
474 */
475 if (likely(list_empty(&time_travel_irqs)))
476 return;
477
478 local_irq_save(flags);
479 irq_enter();
480 while ((e = list_first_entry_or_null(&time_travel_irqs,
481 struct time_travel_event,
482 list))) {
483 list_del(&e->list);
484 e->pending = false;
485 e->fn(e);
486 }
487 irq_exit();
488 local_irq_restore(flags);
489}
490
491static void time_travel_deliver_event(struct time_travel_event *e)
492{
493 if (e == &time_travel_timer_event) {
494 /*
495 * deliver_alarm() does the irq_enter/irq_exit
496 * by itself, so must handle it specially here
497 */
498 e->fn(e);
499 } else if (irqs_disabled()) {
500 list_add_tail(&e->list, &time_travel_irqs);
501 /*
502 * set pending again, it was set to false when the
503 * event was deleted from the original list, but
504 * now it's still pending until we deliver the IRQ.
505 */
506 e->pending = true;
507 } else {
508 unsigned long flags;
509
510 local_irq_save(flags);
511 irq_enter();
512 e->fn(e);
513 irq_exit();
514 local_irq_restore(flags);
515 }
516}
517
518bool time_travel_del_event(struct time_travel_event *e)
519{
520 unsigned long flags;
521
522 if (!e->pending)
523 return false;
524 local_irq_save(flags);
525 list_del(&e->list);
526 e->pending = false;
527 local_irq_restore(flags);
528 return true;
529}
530
531static void time_travel_update_time(unsigned long long next, bool idle)
532{
533 struct time_travel_event ne = {
534 .onstack = true,
535 };
536 struct time_travel_event *e;
537 bool finished = idle;
538
539 /* add it without a handler - we deal with that specifically below */
540 __time_travel_add_event(&ne, next);
541
542 do {
543 e = time_travel_first_event();
544
545 BUG_ON(!e);
546 __time_travel_update_time(e->time, idle);
547
548 /* new events may have been inserted while we were waiting */
549 if (e == time_travel_first_event()) {
550 BUG_ON(!time_travel_del_event(e));
551 BUG_ON(time_travel_time != e->time);
552
553 if (e == &ne) {
554 finished = true;
555 } else {
556 if (e->onstack)
557 panic("On-stack event dequeued outside of the stack! time=%lld, event time=%lld, event=%pS\n",
558 time_travel_time, e->time, e);
559 time_travel_deliver_event(e);
560 }
561 }
562
563 e = time_travel_first_event();
564 if (e)
565 time_travel_ext_update_request(e->time);
566 } while (ne.pending && !finished);
567
568 time_travel_del_event(&ne);
569}
570
571static void time_travel_update_time_rel(unsigned long long offs)
572{
573 unsigned long flags;
574
575 /*
576 * Disable interrupts before calculating the new time so
577 * that a real timer interrupt (signal) can't happen at
578 * a bad time e.g. after we read time_travel_time but
579 * before we've completed updating the time.
580 */
581 local_irq_save(flags);
582 time_travel_update_time(time_travel_time + offs, false);
583 local_irq_restore(flags);
584}
585
586void time_travel_ndelay(unsigned long nsec)
587{
588 /*
589 * Not strictly needed to use _rel() version since this is
590 * only used in INFCPU/EXT modes, but it doesn't hurt and
591 * is more readable too.
592 */
593 time_travel_update_time_rel(nsec);
594}
595EXPORT_SYMBOL(time_travel_ndelay);
596
597void time_travel_add_irq_event(struct time_travel_event *e)
598{
599 BUG_ON(time_travel_mode != TT_MODE_EXTERNAL);
600
601 time_travel_ext_get_time();
602 /*
603 * We could model interrupt latency here, for now just
604 * don't have any latency at all and request the exact
605 * same time (again) to run the interrupt...
606 */
607 time_travel_add_event(e, time_travel_time);
608}
609EXPORT_SYMBOL_GPL(time_travel_add_irq_event);
610
611static void time_travel_oneshot_timer(struct time_travel_event *e)
612{
613 /* clock tick; decrease extra jiffies by keeping sched_clock constant */
614 if (tt_extra_sched_jiffies > 0)
615 tt_extra_sched_jiffies -= 1;
616
617 deliver_alarm();
618}
619
620void time_travel_sleep(void)
621{
622 /*
623 * Wait "forever" (using S64_MAX because there are some potential
624 * wrapping issues, especially with the current TT_MODE_EXTERNAL
625 * controller application.
626 */
627 unsigned long long next = S64_MAX;
628
629 if (time_travel_mode == TT_MODE_BASIC)
630 os_timer_disable();
631
632 time_travel_update_time(next, true);
633
634 if (time_travel_mode == TT_MODE_BASIC &&
635 time_travel_timer_event.pending) {
636 if (time_travel_timer_event.fn == time_travel_periodic_timer) {
637 /*
638 * This is somewhat wrong - we should get the first
639 * one sooner like the os_timer_one_shot() below...
640 */
641 os_timer_set_interval(time_travel_timer_interval);
642 } else {
643 os_timer_one_shot(time_travel_timer_event.time - next);
644 }
645 }
646}
647
648static void time_travel_handle_real_alarm(void)
649{
650 time_travel_set_time(time_travel_next_event);
651
652 time_travel_del_event(&time_travel_timer_event);
653
654 if (time_travel_timer_event.fn == time_travel_periodic_timer)
655 time_travel_add_event(&time_travel_timer_event,
656 time_travel_time +
657 time_travel_timer_interval);
658}
659
660static void time_travel_set_interval(unsigned long long interval)
661{
662 time_travel_timer_interval = interval;
663}
664
665static int time_travel_connect_external(const char *socket)
666{
667 const char *sep;
668 unsigned long long id = (unsigned long long)-1;
669 int rc;
670
671 if ((sep = strchr(socket, ':'))) {
672 char buf[25] = {};
673 if (sep - socket > sizeof(buf) - 1)
674 goto invalid_number;
675
676 memcpy(buf, socket, sep - socket);
677 if (kstrtoull(buf, 0, &id)) {
678invalid_number:
679 panic("time-travel: invalid external ID in string '%s'\n",
680 socket);
681 return -EINVAL;
682 }
683
684 socket = sep + 1;
685 }
686
687 rc = os_connect_socket(socket);
688 if (rc < 0) {
689 panic("time-travel: failed to connect to external socket %s\n",
690 socket);
691 return rc;
692 }
693
694 time_travel_ext_fd = rc;
695
696 time_travel_ext_req(UM_TIMETRAVEL_START, id);
697
698 return 1;
699}
700
701static void time_travel_set_start(void)
702{
703 if (time_travel_start_set)
704 return;
705
706 switch (time_travel_mode) {
707 case TT_MODE_EXTERNAL:
708 time_travel_start = time_travel_ext_req(UM_TIMETRAVEL_GET_TOD, -1);
709 /* controller gave us the *current* time, so adjust by that */
710 time_travel_ext_get_time();
711 time_travel_start -= time_travel_time;
712 break;
713 case TT_MODE_INFCPU:
714 case TT_MODE_BASIC:
715 if (!time_travel_start_set)
716 time_travel_start = os_persistent_clock_emulation();
717 break;
718 case TT_MODE_OFF:
719 /* we just read the host clock with os_persistent_clock_emulation() */
720 break;
721 }
722
723 time_travel_start_set = true;
724}
725#else /* CONFIG_UML_TIME_TRAVEL_SUPPORT */
726#define time_travel_start_set 0
727#define time_travel_start 0
728#define time_travel_time 0
729#define time_travel_ext_waiting 0
730
731static inline void time_travel_update_time(unsigned long long ns, bool idle)
732{
733}
734
735static inline void time_travel_update_time_rel(unsigned long long offs)
736{
737}
738
739static inline void time_travel_handle_real_alarm(void)
740{
741}
742
743static void time_travel_set_interval(unsigned long long interval)
744{
745}
746
747static inline void time_travel_set_start(void)
748{
749}
750
751/* fail link if this actually gets used */
752extern u64 time_travel_ext_req(u32 op, u64 time);
753
754/* these are empty macros so the struct/fn need not exist */
755#define time_travel_add_event(e, time) do { } while (0)
756/* externally not usable - redefine here so we can */
757#undef time_travel_del_event
758#define time_travel_del_event(e) do { } while (0)
759#endif
760
761void timer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
762{
763 unsigned long flags;
764
765 /*
766 * In basic time-travel mode we still get real interrupts
767 * (signals) but since we don't read time from the OS, we
768 * must update the simulated time here to the expiry when
769 * we get a signal.
770 * This is not the case in inf-cpu mode, since there we
771 * never get any real signals from the OS.
772 */
773 if (time_travel_mode == TT_MODE_BASIC)
774 time_travel_handle_real_alarm();
775
776 local_irq_save(flags);
777 do_IRQ(TIMER_IRQ, regs);
778 local_irq_restore(flags);
779}
780
781static int itimer_shutdown(struct clock_event_device *evt)
782{
783 if (time_travel_mode != TT_MODE_OFF)
784 time_travel_del_event(&time_travel_timer_event);
785
786 if (time_travel_mode != TT_MODE_INFCPU &&
787 time_travel_mode != TT_MODE_EXTERNAL)
788 os_timer_disable();
789
790 return 0;
791}
792
793static int itimer_set_periodic(struct clock_event_device *evt)
794{
795 unsigned long long interval = NSEC_PER_SEC / HZ;
796
797 if (time_travel_mode != TT_MODE_OFF) {
798 time_travel_del_event(&time_travel_timer_event);
799 time_travel_set_event_fn(&time_travel_timer_event,
800 time_travel_periodic_timer);
801 time_travel_set_interval(interval);
802 time_travel_add_event(&time_travel_timer_event,
803 time_travel_time + interval);
804 }
805
806 if (time_travel_mode != TT_MODE_INFCPU &&
807 time_travel_mode != TT_MODE_EXTERNAL)
808 os_timer_set_interval(interval);
809
810 return 0;
811}
812
813static int itimer_next_event(unsigned long delta,
814 struct clock_event_device *evt)
815{
816 delta += 1;
817
818 if (time_travel_mode != TT_MODE_OFF) {
819 time_travel_del_event(&time_travel_timer_event);
820 time_travel_set_event_fn(&time_travel_timer_event,
821 time_travel_oneshot_timer);
822 time_travel_add_event(&time_travel_timer_event,
823 time_travel_time + delta);
824 }
825
826 if (time_travel_mode != TT_MODE_INFCPU &&
827 time_travel_mode != TT_MODE_EXTERNAL)
828 return os_timer_one_shot(delta);
829
830 return 0;
831}
832
833static int itimer_one_shot(struct clock_event_device *evt)
834{
835 return itimer_next_event(0, evt);
836}
837
838static struct clock_event_device timer_clockevent = {
839 .name = "posix-timer",
840 .rating = 250,
841 .cpumask = cpu_possible_mask,
842 .features = CLOCK_EVT_FEAT_PERIODIC |
843 CLOCK_EVT_FEAT_ONESHOT,
844 .set_state_shutdown = itimer_shutdown,
845 .set_state_periodic = itimer_set_periodic,
846 .set_state_oneshot = itimer_one_shot,
847 .set_next_event = itimer_next_event,
848 .shift = 0,
849 .max_delta_ns = 0xffffffff,
850 .max_delta_ticks = 0xffffffff,
851 .min_delta_ns = TIMER_MIN_DELTA,
852 .min_delta_ticks = TIMER_MIN_DELTA, // microsecond resolution should be enough for anyone, same as 640K RAM
853 .irq = 0,
854 .mult = 1,
855};
856
857static irqreturn_t um_timer(int irq, void *dev)
858{
859 if (get_current()->mm != NULL)
860 {
861 /* userspace - relay signal, results in correct userspace timers */
862 os_alarm_process(get_current()->mm->context.id.pid);
863 }
864
865 (*timer_clockevent.event_handler)(&timer_clockevent);
866
867 return IRQ_HANDLED;
868}
869
870static u64 timer_read(struct clocksource *cs)
871{
872 if (time_travel_mode != TT_MODE_OFF) {
873 /*
874 * We make reading the timer cost a bit so that we don't get
875 * stuck in loops that expect time to move more than the
876 * exact requested sleep amount, e.g. python's socket server,
877 * see https://bugs.python.org/issue37026.
878 *
879 * However, don't do that when we're in interrupt or such as
880 * then we might recurse into our own processing, and get to
881 * even more waiting, and that's not good - it messes up the
882 * "what do I do next" and onstack event we use to know when
883 * to return from time_travel_update_time().
884 */
885 if (!irqs_disabled() && !in_interrupt() && !in_softirq() &&
886 !time_travel_ext_waiting)
887 time_travel_update_time_rel(TIMER_MULTIPLIER);
888 return time_travel_time / TIMER_MULTIPLIER;
889 }
890
891 return os_nsecs() / TIMER_MULTIPLIER;
892}
893
894static struct clocksource timer_clocksource = {
895 .name = "timer",
896 .rating = 300,
897 .read = timer_read,
898 .mask = CLOCKSOURCE_MASK(64),
899 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
900};
901
902static void __init um_timer_setup(void)
903{
904 int err;
905
906 err = request_irq(TIMER_IRQ, um_timer, IRQF_TIMER, "hr timer", NULL);
907 if (err != 0)
908 printk(KERN_ERR "register_timer : request_irq failed - "
909 "errno = %d\n", -err);
910
911 err = os_timer_create();
912 if (err != 0) {
913 printk(KERN_ERR "creation of timer failed - errno = %d\n", -err);
914 return;
915 }
916
917 err = clocksource_register_hz(&timer_clocksource, NSEC_PER_SEC/TIMER_MULTIPLIER);
918 if (err) {
919 printk(KERN_ERR "clocksource_register_hz returned %d\n", err);
920 return;
921 }
922 clockevents_register_device(&timer_clockevent);
923}
924
925void read_persistent_clock64(struct timespec64 *ts)
926{
927 long long nsecs;
928
929 time_travel_set_start();
930
931 if (time_travel_mode != TT_MODE_OFF)
932 nsecs = time_travel_start + time_travel_time;
933 else
934 nsecs = os_persistent_clock_emulation();
935
936 set_normalized_timespec64(ts, nsecs / NSEC_PER_SEC,
937 nsecs % NSEC_PER_SEC);
938}
939
940void __init time_init(void)
941{
942 timer_set_signal_handler();
943 late_time_init = um_timer_setup;
944}
945
946#ifdef CONFIG_UML_TIME_TRAVEL_SUPPORT
947unsigned long calibrate_delay_is_known(void)
948{
949 if (time_travel_mode == TT_MODE_INFCPU ||
950 time_travel_mode == TT_MODE_EXTERNAL)
951 return 1;
952 return 0;
953}
954
955static int setup_time_travel(char *str)
956{
957 if (strcmp(str, "=inf-cpu") == 0) {
958 time_travel_mode = TT_MODE_INFCPU;
959 timer_clockevent.name = "time-travel-timer-infcpu";
960 timer_clocksource.name = "time-travel-clock";
961 return 1;
962 }
963
964 if (strncmp(str, "=ext:", 5) == 0) {
965 time_travel_mode = TT_MODE_EXTERNAL;
966 timer_clockevent.name = "time-travel-timer-external";
967 timer_clocksource.name = "time-travel-clock-external";
968 return time_travel_connect_external(str + 5);
969 }
970
971 if (!*str) {
972 time_travel_mode = TT_MODE_BASIC;
973 timer_clockevent.name = "time-travel-timer";
974 timer_clocksource.name = "time-travel-clock";
975 return 1;
976 }
977
978 return -EINVAL;
979}
980
981__setup("time-travel", setup_time_travel);
982__uml_help(setup_time_travel,
983"time-travel\n"
984"This option just enables basic time travel mode, in which the clock/timers\n"
985"inside the UML instance skip forward when there's nothing to do, rather than\n"
986"waiting for real time to elapse. However, instance CPU speed is limited by\n"
987"the real CPU speed, so e.g. a 10ms timer will always fire after ~10ms wall\n"
988"clock (but quicker when there's nothing to do).\n"
989"\n"
990"time-travel=inf-cpu\n"
991"This enables time travel mode with infinite processing power, in which there\n"
992"are no wall clock timers, and any CPU processing happens - as seen from the\n"
993"guest - instantly. This can be useful for accurate simulation regardless of\n"
994"debug overhead, physical CPU speed, etc. but is somewhat dangerous as it can\n"
995"easily lead to getting stuck (e.g. if anything in the system busy loops).\n"
996"\n"
997"time-travel=ext:[ID:]/path/to/socket\n"
998"This enables time travel mode similar to =inf-cpu, except the system will\n"
999"use the given socket to coordinate with a central scheduler, in order to\n"
1000"have more than one system simultaneously be on simulated time. The virtio\n"
1001"driver code in UML knows about this so you can also simulate networks and\n"
1002"devices using it, assuming the device has the right capabilities.\n"
1003"The optional ID is a 64-bit integer that's sent to the central scheduler.\n");
1004
1005static int setup_time_travel_start(char *str)
1006{
1007 int err;
1008
1009 err = kstrtoull(str, 0, &time_travel_start);
1010 if (err)
1011 return err;
1012
1013 time_travel_start_set = 1;
1014 return 1;
1015}
1016
1017__setup("time-travel-start=", setup_time_travel_start);
1018__uml_help(setup_time_travel_start,
1019"time-travel-start=<nanoseconds>\n"
1020"Configure the UML instance's wall clock to start at this value rather than\n"
1021"the host's wall clock at the time of UML boot.\n");
1022static struct kobject *bc_time_kobject;
1023
1024static ssize_t bc_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
1025{
1026 return sprintf(buf, "0x%llx", bc_message);
1027}
1028
1029static ssize_t bc_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
1030{
1031 int ret;
1032 u64 user_bc_message;
1033
1034 ret = kstrtou64(buf, 0, &user_bc_message);
1035 if (ret)
1036 return ret;
1037
1038 bc_message = user_bc_message;
1039
1040 time_travel_ext_req(UM_TIMETRAVEL_BROADCAST, bc_message);
1041 pr_info("um: time: sent broadcast message: 0x%llx\n", bc_message);
1042 return count;
1043}
1044
1045static struct kobj_attribute bc_attribute = __ATTR(bc-message, 0660, bc_show, bc_store);
1046
1047static int __init um_bc_start(void)
1048{
1049 if (time_travel_mode != TT_MODE_EXTERNAL)
1050 return 0;
1051
1052 bc_time_kobject = kobject_create_and_add("um-ext-time", kernel_kobj);
1053 if (!bc_time_kobject)
1054 return 0;
1055
1056 if (sysfs_create_file(bc_time_kobject, &bc_attribute.attr))
1057 pr_debug("failed to create the bc file in /sys/kernel/um_time");
1058
1059 return 0;
1060}
1061late_initcall(um_bc_start);
1062#endif