xref: /qemu/util/qemu-timer.c (revision 3c05341157f4d08dc3cc8ffa675a0aaa4818d028)
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "sysemu/sysemu.h"
26 #include "monitor/monitor.h"
27 #include "ui/console.h"
28 
29 #include "hw/hw.h"
30 
31 #include "qemu/timer.h"
32 #ifdef CONFIG_POSIX
33 #include <pthread.h>
34 #endif
35 
36 #ifdef CONFIG_PPOLL
37 #include <poll.h>
38 #endif
39 
40 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
41 #include <sys/prctl.h>
42 #endif
43 
44 /***********************************************************/
45 /* timers */
46 
47 typedef struct QEMUClock {
48     /* We rely on BQL to protect the timerlists */
49     QLIST_HEAD(, QEMUTimerList) timerlists;
50 
51     NotifierList reset_notifiers;
52     int64_t last;
53 
54     QEMUClockType type;
55     bool enabled;
56 } QEMUClock;
57 
58 QEMUTimerListGroup main_loop_tlg;
59 QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
60 
61 /* A QEMUTimerList is a list of timers attached to a clock. More
62  * than one QEMUTimerList can be attached to each clock, for instance
63  * used by different AioContexts / threads. Each clock also has
64  * a list of the QEMUTimerLists associated with it, in order that
65  * reenabling the clock can call all the notifiers.
66  */
67 
68 struct QEMUTimerList {
69     QEMUClock *clock;
70     QemuMutex active_timers_lock;
71     QEMUTimer *active_timers;
72     QLIST_ENTRY(QEMUTimerList) list;
73     QEMUTimerListNotifyCB *notify_cb;
74     void *notify_opaque;
75 
76     /* lightweight method to mark the end of timerlist's running */
77     QemuEvent timers_done_ev;
78 };
79 
80 /**
81  * qemu_clock_ptr:
82  * @type: type of clock
83  *
84  * Translate a clock type into a pointer to QEMUClock object.
85  *
86  * Returns: a pointer to the QEMUClock object
87  */
88 static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
89 {
90     return &qemu_clocks[type];
91 }
92 
93 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
94 {
95     return timer_head && (timer_head->expire_time <= current_time);
96 }
97 
98 QEMUTimerList *timerlist_new(QEMUClockType type,
99                              QEMUTimerListNotifyCB *cb,
100                              void *opaque)
101 {
102     QEMUTimerList *timer_list;
103     QEMUClock *clock = qemu_clock_ptr(type);
104 
105     timer_list = g_malloc0(sizeof(QEMUTimerList));
106     qemu_event_init(&timer_list->timers_done_ev, false);
107     timer_list->clock = clock;
108     timer_list->notify_cb = cb;
109     timer_list->notify_opaque = opaque;
110     qemu_mutex_init(&timer_list->active_timers_lock);
111     QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
112     return timer_list;
113 }
114 
115 void timerlist_free(QEMUTimerList *timer_list)
116 {
117     assert(!timerlist_has_timers(timer_list));
118     if (timer_list->clock) {
119         QLIST_REMOVE(timer_list, list);
120     }
121     qemu_mutex_destroy(&timer_list->active_timers_lock);
122     g_free(timer_list);
123 }
124 
125 static void qemu_clock_init(QEMUClockType type)
126 {
127     QEMUClock *clock = qemu_clock_ptr(type);
128 
129     clock->type = type;
130     clock->enabled = true;
131     clock->last = INT64_MIN;
132     QLIST_INIT(&clock->timerlists);
133     notifier_list_init(&clock->reset_notifiers);
134     main_loop_tlg.tl[type] = timerlist_new(type, NULL, NULL);
135 }
136 
137 bool qemu_clock_use_for_deadline(QEMUClockType type)
138 {
139     return !(use_icount && (type == QEMU_CLOCK_VIRTUAL));
140 }
141 
142 void qemu_clock_notify(QEMUClockType type)
143 {
144     QEMUTimerList *timer_list;
145     QEMUClock *clock = qemu_clock_ptr(type);
146     QLIST_FOREACH(timer_list, &clock->timerlists, list) {
147         timerlist_notify(timer_list);
148     }
149 }
150 
151 /* Disabling the clock will wait for related timerlists to stop
152  * executing qemu_run_timers.  Thus, this functions should not
153  * be used from the callback of a timer that is based on @clock.
154  * Doing so would cause a deadlock.
155  *
156  * Caller should hold BQL.
157  */
158 void qemu_clock_enable(QEMUClockType type, bool enabled)
159 {
160     QEMUClock *clock = qemu_clock_ptr(type);
161     QEMUTimerList *tl;
162     bool old = clock->enabled;
163     clock->enabled = enabled;
164     if (enabled && !old) {
165         qemu_clock_notify(type);
166     } else if (!enabled && old) {
167         QLIST_FOREACH(tl, &clock->timerlists, list) {
168             qemu_event_wait(&tl->timers_done_ev);
169         }
170     }
171 }
172 
173 bool timerlist_has_timers(QEMUTimerList *timer_list)
174 {
175     return !!timer_list->active_timers;
176 }
177 
178 bool qemu_clock_has_timers(QEMUClockType type)
179 {
180     return timerlist_has_timers(
181         main_loop_tlg.tl[type]);
182 }
183 
184 bool timerlist_expired(QEMUTimerList *timer_list)
185 {
186     int64_t expire_time;
187 
188     qemu_mutex_lock(&timer_list->active_timers_lock);
189     if (!timer_list->active_timers) {
190         qemu_mutex_unlock(&timer_list->active_timers_lock);
191         return false;
192     }
193     expire_time = timer_list->active_timers->expire_time;
194     qemu_mutex_unlock(&timer_list->active_timers_lock);
195 
196     return expire_time < qemu_clock_get_ns(timer_list->clock->type);
197 }
198 
199 bool qemu_clock_expired(QEMUClockType type)
200 {
201     return timerlist_expired(
202         main_loop_tlg.tl[type]);
203 }
204 
205 /*
206  * As above, but return -1 for no deadline, and do not cap to 2^32
207  * as we know the result is always positive.
208  */
209 
210 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
211 {
212     int64_t delta;
213     int64_t expire_time;
214 
215     if (!timer_list->clock->enabled) {
216         return -1;
217     }
218 
219     /* The active timers list may be modified before the caller uses our return
220      * value but ->notify_cb() is called when the deadline changes.  Therefore
221      * the caller should notice the change and there is no race condition.
222      */
223     qemu_mutex_lock(&timer_list->active_timers_lock);
224     if (!timer_list->active_timers) {
225         qemu_mutex_unlock(&timer_list->active_timers_lock);
226         return -1;
227     }
228     expire_time = timer_list->active_timers->expire_time;
229     qemu_mutex_unlock(&timer_list->active_timers_lock);
230 
231     delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
232 
233     if (delta <= 0) {
234         return 0;
235     }
236 
237     return delta;
238 }
239 
240 /* Calculate the soonest deadline across all timerlists attached
241  * to the clock. This is used for the icount timeout so we
242  * ignore whether or not the clock should be used in deadline
243  * calculations.
244  */
245 int64_t qemu_clock_deadline_ns_all(QEMUClockType type)
246 {
247     int64_t deadline = -1;
248     QEMUTimerList *timer_list;
249     QEMUClock *clock = qemu_clock_ptr(type);
250     QLIST_FOREACH(timer_list, &clock->timerlists, list) {
251         deadline = qemu_soonest_timeout(deadline,
252                                         timerlist_deadline_ns(timer_list));
253     }
254     return deadline;
255 }
256 
257 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
258 {
259     return timer_list->clock->type;
260 }
261 
262 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
263 {
264     return main_loop_tlg.tl[type];
265 }
266 
267 void timerlist_notify(QEMUTimerList *timer_list)
268 {
269     if (timer_list->notify_cb) {
270         timer_list->notify_cb(timer_list->notify_opaque);
271     } else {
272         qemu_notify_event();
273     }
274 }
275 
276 /* Transition function to convert a nanosecond timeout to ms
277  * This is used where a system does not support ppoll
278  */
279 int qemu_timeout_ns_to_ms(int64_t ns)
280 {
281     int64_t ms;
282     if (ns < 0) {
283         return -1;
284     }
285 
286     if (!ns) {
287         return 0;
288     }
289 
290     /* Always round up, because it's better to wait too long than to wait too
291      * little and effectively busy-wait
292      */
293     ms = (ns + SCALE_MS - 1) / SCALE_MS;
294 
295     /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
296     if (ms > (int64_t) INT32_MAX) {
297         ms = INT32_MAX;
298     }
299 
300     return (int) ms;
301 }
302 
303 
304 /* qemu implementation of g_poll which uses a nanosecond timeout but is
305  * otherwise identical to g_poll
306  */
307 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
308 {
309 #ifdef CONFIG_PPOLL
310     if (timeout < 0) {
311         return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
312     } else {
313         struct timespec ts;
314         ts.tv_sec = timeout / 1000000000LL;
315         ts.tv_nsec = timeout % 1000000000LL;
316         return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
317     }
318 #else
319     return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
320 #endif
321 }
322 
323 
324 void timer_init(QEMUTimer *ts,
325                 QEMUTimerList *timer_list, int scale,
326                 QEMUTimerCB *cb, void *opaque)
327 {
328     ts->timer_list = timer_list;
329     ts->cb = cb;
330     ts->opaque = opaque;
331     ts->scale = scale;
332     ts->expire_time = -1;
333 }
334 
335 void timer_free(QEMUTimer *ts)
336 {
337     g_free(ts);
338 }
339 
340 static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
341 {
342     QEMUTimer **pt, *t;
343 
344     ts->expire_time = -1;
345     pt = &timer_list->active_timers;
346     for(;;) {
347         t = *pt;
348         if (!t)
349             break;
350         if (t == ts) {
351             *pt = t->next;
352             break;
353         }
354         pt = &t->next;
355     }
356 }
357 
358 /* stop a timer, but do not dealloc it */
359 void timer_del(QEMUTimer *ts)
360 {
361     QEMUTimerList *timer_list = ts->timer_list;
362 
363     qemu_mutex_lock(&timer_list->active_timers_lock);
364     timer_del_locked(timer_list, ts);
365     qemu_mutex_unlock(&timer_list->active_timers_lock);
366 }
367 
368 /* modify the current timer so that it will be fired when current_time
369    >= expire_time. The corresponding callback will be called. */
370 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
371 {
372     QEMUTimerList *timer_list = ts->timer_list;
373     QEMUTimer **pt, *t;
374 
375     qemu_mutex_lock(&timer_list->active_timers_lock);
376     timer_del_locked(timer_list, ts);
377 
378     /* add the timer in the sorted list */
379     pt = &timer_list->active_timers;
380     for(;;) {
381         t = *pt;
382         if (!timer_expired_ns(t, expire_time)) {
383             break;
384         }
385         pt = &t->next;
386     }
387     ts->expire_time = MAX(expire_time, 0);
388     ts->next = *pt;
389     *pt = ts;
390     qemu_mutex_unlock(&timer_list->active_timers_lock);
391 
392     /* Rearm if necessary  */
393     if (pt == &timer_list->active_timers) {
394         /* Interrupt execution to force deadline recalculation.  */
395         qemu_clock_warp(timer_list->clock->type);
396         timerlist_notify(timer_list);
397     }
398 }
399 
400 void timer_mod(QEMUTimer *ts, int64_t expire_time)
401 {
402     timer_mod_ns(ts, expire_time * ts->scale);
403 }
404 
405 bool timer_pending(QEMUTimer *ts)
406 {
407     return ts->expire_time >= 0;
408 }
409 
410 bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
411 {
412     return timer_expired_ns(timer_head, current_time * timer_head->scale);
413 }
414 
415 bool timerlist_run_timers(QEMUTimerList *timer_list)
416 {
417     QEMUTimer *ts;
418     int64_t current_time;
419     bool progress = false;
420     QEMUTimerCB *cb;
421     void *opaque;
422 
423     qemu_event_reset(&timer_list->timers_done_ev);
424     if (!timer_list->clock->enabled) {
425         goto out;
426     }
427 
428     current_time = qemu_clock_get_ns(timer_list->clock->type);
429     for(;;) {
430         qemu_mutex_lock(&timer_list->active_timers_lock);
431         ts = timer_list->active_timers;
432         if (!timer_expired_ns(ts, current_time)) {
433             qemu_mutex_unlock(&timer_list->active_timers_lock);
434             break;
435         }
436 
437         /* remove timer from the list before calling the callback */
438         timer_list->active_timers = ts->next;
439         ts->next = NULL;
440         ts->expire_time = -1;
441         cb = ts->cb;
442         opaque = ts->opaque;
443         qemu_mutex_unlock(&timer_list->active_timers_lock);
444 
445         /* run the callback (the timer list can be modified) */
446         cb(opaque);
447         progress = true;
448     }
449 
450 out:
451     qemu_event_set(&timer_list->timers_done_ev);
452     return progress;
453 }
454 
455 bool qemu_clock_run_timers(QEMUClockType type)
456 {
457     return timerlist_run_timers(main_loop_tlg.tl[type]);
458 }
459 
460 void timerlistgroup_init(QEMUTimerListGroup *tlg,
461                          QEMUTimerListNotifyCB *cb, void *opaque)
462 {
463     QEMUClockType type;
464     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
465         tlg->tl[type] = timerlist_new(type, cb, opaque);
466     }
467 }
468 
469 void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
470 {
471     QEMUClockType type;
472     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
473         timerlist_free(tlg->tl[type]);
474     }
475 }
476 
477 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
478 {
479     QEMUClockType type;
480     bool progress = false;
481     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
482         progress |= timerlist_run_timers(tlg->tl[type]);
483     }
484     return progress;
485 }
486 
487 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
488 {
489     int64_t deadline = -1;
490     QEMUClockType type;
491     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
492         if (qemu_clock_use_for_deadline(tlg->tl[type]->clock->type)) {
493             deadline = qemu_soonest_timeout(deadline,
494                                             timerlist_deadline_ns(
495                                                 tlg->tl[type]));
496         }
497     }
498     return deadline;
499 }
500 
501 int64_t qemu_clock_get_ns(QEMUClockType type)
502 {
503     int64_t now, last;
504     QEMUClock *clock = qemu_clock_ptr(type);
505 
506     switch (type) {
507     case QEMU_CLOCK_REALTIME:
508         return get_clock();
509     default:
510     case QEMU_CLOCK_VIRTUAL:
511         if (use_icount) {
512             return cpu_get_icount();
513         } else {
514             return cpu_get_clock();
515         }
516     case QEMU_CLOCK_HOST:
517         now = get_clock_realtime();
518         last = clock->last;
519         clock->last = now;
520         if (now < last) {
521             notifier_list_notify(&clock->reset_notifiers, &now);
522         }
523         return now;
524     }
525 }
526 
527 void qemu_clock_register_reset_notifier(QEMUClockType type,
528                                         Notifier *notifier)
529 {
530     QEMUClock *clock = qemu_clock_ptr(type);
531     notifier_list_add(&clock->reset_notifiers, notifier);
532 }
533 
534 void qemu_clock_unregister_reset_notifier(QEMUClockType type,
535                                           Notifier *notifier)
536 {
537     notifier_remove(notifier);
538 }
539 
540 void init_clocks(void)
541 {
542     QEMUClockType type;
543     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
544         qemu_clock_init(type);
545     }
546 
547 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
548     prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
549 #endif
550 }
551 
552 uint64_t timer_expire_time_ns(QEMUTimer *ts)
553 {
554     return timer_pending(ts) ? ts->expire_time : -1;
555 }
556 
557 bool qemu_clock_run_all_timers(void)
558 {
559     bool progress = false;
560     QEMUClockType type;
561 
562     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
563         progress |= qemu_clock_run_timers(type);
564     }
565 
566     return progress;
567 }
568