1c2b38b27SPaolo Bonzini /*
2c2b38b27SPaolo Bonzini * QEMU System Emulator
3c2b38b27SPaolo Bonzini *
4c2b38b27SPaolo Bonzini * Copyright (c) 2003-2008 Fabrice Bellard
5c2b38b27SPaolo Bonzini *
6c2b38b27SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy
7c2b38b27SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal
8c2b38b27SPaolo Bonzini * in the Software without restriction, including without limitation the rights
9c2b38b27SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10c2b38b27SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is
11c2b38b27SPaolo Bonzini * furnished to do so, subject to the following conditions:
12c2b38b27SPaolo Bonzini *
13c2b38b27SPaolo Bonzini * The above copyright notice and this permission notice shall be included in
14c2b38b27SPaolo Bonzini * all copies or substantial portions of the Software.
15c2b38b27SPaolo Bonzini *
16c2b38b27SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17c2b38b27SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18c2b38b27SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19c2b38b27SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20c2b38b27SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21c2b38b27SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22c2b38b27SPaolo Bonzini * THE SOFTWARE.
23c2b38b27SPaolo Bonzini */
24c2b38b27SPaolo Bonzini
25c2b38b27SPaolo Bonzini #include "qemu/osdep.h"
26c2b38b27SPaolo Bonzini #include "qemu/main-loop.h"
27c2b38b27SPaolo Bonzini #include "qemu/timer.h"
283284c3ddSStefan Hajnoczi #include "qemu/lockable.h"
29740b1759SClaudio Fontana #include "sysemu/cpu-timers.h"
30c2b38b27SPaolo Bonzini #include "sysemu/replay.h"
31d2528bdcSPaolo Bonzini #include "sysemu/cpus.h"
32c2b38b27SPaolo Bonzini
33c2b38b27SPaolo Bonzini #ifdef CONFIG_POSIX
34c2b38b27SPaolo Bonzini #include <pthread.h>
35c2b38b27SPaolo Bonzini #endif
36c2b38b27SPaolo Bonzini
37c2b38b27SPaolo Bonzini #ifdef CONFIG_PPOLL
38c2b38b27SPaolo Bonzini #include <poll.h>
39c2b38b27SPaolo Bonzini #endif
40c2b38b27SPaolo Bonzini
41c2b38b27SPaolo Bonzini #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
42c2b38b27SPaolo Bonzini #include <sys/prctl.h>
43c2b38b27SPaolo Bonzini #endif
44c2b38b27SPaolo Bonzini
45c2b38b27SPaolo Bonzini /***********************************************************/
46c2b38b27SPaolo Bonzini /* timers */
47c2b38b27SPaolo Bonzini
48c2b38b27SPaolo Bonzini typedef struct QEMUClock {
49c2b38b27SPaolo Bonzini /* We rely on BQL to protect the timerlists */
50c2b38b27SPaolo Bonzini QLIST_HEAD(, QEMUTimerList) timerlists;
51c2b38b27SPaolo Bonzini
52c2b38b27SPaolo Bonzini QEMUClockType type;
53c2b38b27SPaolo Bonzini bool enabled;
54c2b38b27SPaolo Bonzini } QEMUClock;
55c2b38b27SPaolo Bonzini
56c2b38b27SPaolo Bonzini QEMUTimerListGroup main_loop_tlg;
57c2b38b27SPaolo Bonzini static QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
58c2b38b27SPaolo Bonzini
59c2b38b27SPaolo Bonzini /* A QEMUTimerList is a list of timers attached to a clock. More
60c2b38b27SPaolo Bonzini * than one QEMUTimerList can be attached to each clock, for instance
61c2b38b27SPaolo Bonzini * used by different AioContexts / threads. Each clock also has
62c2b38b27SPaolo Bonzini * a list of the QEMUTimerLists associated with it, in order that
63c2b38b27SPaolo Bonzini * reenabling the clock can call all the notifiers.
64c2b38b27SPaolo Bonzini */
65c2b38b27SPaolo Bonzini
66c2b38b27SPaolo Bonzini struct QEMUTimerList {
67c2b38b27SPaolo Bonzini QEMUClock *clock;
68c2b38b27SPaolo Bonzini QemuMutex active_timers_lock;
69c2b38b27SPaolo Bonzini QEMUTimer *active_timers;
70c2b38b27SPaolo Bonzini QLIST_ENTRY(QEMUTimerList) list;
71c2b38b27SPaolo Bonzini QEMUTimerListNotifyCB *notify_cb;
72c2b38b27SPaolo Bonzini void *notify_opaque;
73c2b38b27SPaolo Bonzini
74c2b38b27SPaolo Bonzini /* lightweight method to mark the end of timerlist's running */
75c2b38b27SPaolo Bonzini QemuEvent timers_done_ev;
76c2b38b27SPaolo Bonzini };
77c2b38b27SPaolo Bonzini
78c2b38b27SPaolo Bonzini /**
79c2b38b27SPaolo Bonzini * qemu_clock_ptr:
80c2b38b27SPaolo Bonzini * @type: type of clock
81c2b38b27SPaolo Bonzini *
82c2b38b27SPaolo Bonzini * Translate a clock type into a pointer to QEMUClock object.
83c2b38b27SPaolo Bonzini *
84c2b38b27SPaolo Bonzini * Returns: a pointer to the QEMUClock object
85c2b38b27SPaolo Bonzini */
qemu_clock_ptr(QEMUClockType type)86c2b38b27SPaolo Bonzini static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
87c2b38b27SPaolo Bonzini {
88c2b38b27SPaolo Bonzini return &qemu_clocks[type];
89c2b38b27SPaolo Bonzini }
90c2b38b27SPaolo Bonzini
timer_expired_ns(QEMUTimer * timer_head,int64_t current_time)91c2b38b27SPaolo Bonzini static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
92c2b38b27SPaolo Bonzini {
93c2b38b27SPaolo Bonzini return timer_head && (timer_head->expire_time <= current_time);
94c2b38b27SPaolo Bonzini }
95c2b38b27SPaolo Bonzini
timerlist_new(QEMUClockType type,QEMUTimerListNotifyCB * cb,void * opaque)96c2b38b27SPaolo Bonzini QEMUTimerList *timerlist_new(QEMUClockType type,
97c2b38b27SPaolo Bonzini QEMUTimerListNotifyCB *cb,
98c2b38b27SPaolo Bonzini void *opaque)
99c2b38b27SPaolo Bonzini {
100c2b38b27SPaolo Bonzini QEMUTimerList *timer_list;
101c2b38b27SPaolo Bonzini QEMUClock *clock = qemu_clock_ptr(type);
102c2b38b27SPaolo Bonzini
103b21e2380SMarkus Armbruster timer_list = g_new0(QEMUTimerList, 1);
104c2b38b27SPaolo Bonzini qemu_event_init(&timer_list->timers_done_ev, true);
105c2b38b27SPaolo Bonzini timer_list->clock = clock;
106c2b38b27SPaolo Bonzini timer_list->notify_cb = cb;
107c2b38b27SPaolo Bonzini timer_list->notify_opaque = opaque;
108c2b38b27SPaolo Bonzini qemu_mutex_init(&timer_list->active_timers_lock);
109c2b38b27SPaolo Bonzini QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
110c2b38b27SPaolo Bonzini return timer_list;
111c2b38b27SPaolo Bonzini }
112c2b38b27SPaolo Bonzini
timerlist_free(QEMUTimerList * timer_list)113c2b38b27SPaolo Bonzini void timerlist_free(QEMUTimerList *timer_list)
114c2b38b27SPaolo Bonzini {
115c2b38b27SPaolo Bonzini assert(!timerlist_has_timers(timer_list));
116c2b38b27SPaolo Bonzini if (timer_list->clock) {
117c2b38b27SPaolo Bonzini QLIST_REMOVE(timer_list, list);
118c2b38b27SPaolo Bonzini }
119c2b38b27SPaolo Bonzini qemu_mutex_destroy(&timer_list->active_timers_lock);
120c2b38b27SPaolo Bonzini g_free(timer_list);
121c2b38b27SPaolo Bonzini }
122c2b38b27SPaolo Bonzini
qemu_clock_init(QEMUClockType type,QEMUTimerListNotifyCB * notify_cb)1233f53bc61SPaolo Bonzini static void qemu_clock_init(QEMUClockType type, QEMUTimerListNotifyCB *notify_cb)
124c2b38b27SPaolo Bonzini {
125c2b38b27SPaolo Bonzini QEMUClock *clock = qemu_clock_ptr(type);
126c2b38b27SPaolo Bonzini
127c2b38b27SPaolo Bonzini /* Assert that the clock of type TYPE has not been initialized yet. */
128c2b38b27SPaolo Bonzini assert(main_loop_tlg.tl[type] == NULL);
129c2b38b27SPaolo Bonzini
130c2b38b27SPaolo Bonzini clock->type = type;
131c2b38b27SPaolo Bonzini clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true);
132c2b38b27SPaolo Bonzini QLIST_INIT(&clock->timerlists);
1333f53bc61SPaolo Bonzini main_loop_tlg.tl[type] = timerlist_new(type, notify_cb, NULL);
134c2b38b27SPaolo Bonzini }
135c2b38b27SPaolo Bonzini
qemu_clock_use_for_deadline(QEMUClockType type)136c2b38b27SPaolo Bonzini bool qemu_clock_use_for_deadline(QEMUClockType type)
137c2b38b27SPaolo Bonzini {
138740b1759SClaudio Fontana return !(icount_enabled() && (type == QEMU_CLOCK_VIRTUAL));
139c2b38b27SPaolo Bonzini }
140c2b38b27SPaolo Bonzini
qemu_clock_notify(QEMUClockType type)141c2b38b27SPaolo Bonzini void qemu_clock_notify(QEMUClockType type)
142c2b38b27SPaolo Bonzini {
143c2b38b27SPaolo Bonzini QEMUTimerList *timer_list;
144c2b38b27SPaolo Bonzini QEMUClock *clock = qemu_clock_ptr(type);
145c2b38b27SPaolo Bonzini QLIST_FOREACH(timer_list, &clock->timerlists, list) {
146c2b38b27SPaolo Bonzini timerlist_notify(timer_list);
147c2b38b27SPaolo Bonzini }
148c2b38b27SPaolo Bonzini }
149c2b38b27SPaolo Bonzini
150c2b38b27SPaolo Bonzini /* Disabling the clock will wait for related timerlists to stop
151c2b38b27SPaolo Bonzini * executing qemu_run_timers. Thus, this functions should not
152c2b38b27SPaolo Bonzini * be used from the callback of a timer that is based on @clock.
153c2b38b27SPaolo Bonzini * Doing so would cause a deadlock.
154c2b38b27SPaolo Bonzini *
155c2b38b27SPaolo Bonzini * Caller should hold BQL.
156c2b38b27SPaolo Bonzini */
qemu_clock_enable(QEMUClockType type,bool enabled)157c2b38b27SPaolo Bonzini void qemu_clock_enable(QEMUClockType type, bool enabled)
158c2b38b27SPaolo Bonzini {
159c2b38b27SPaolo Bonzini QEMUClock *clock = qemu_clock_ptr(type);
160c2b38b27SPaolo Bonzini QEMUTimerList *tl;
161c2b38b27SPaolo Bonzini bool old = clock->enabled;
162c2b38b27SPaolo Bonzini clock->enabled = enabled;
163c2b38b27SPaolo Bonzini if (enabled && !old) {
164c2b38b27SPaolo Bonzini qemu_clock_notify(type);
165c2b38b27SPaolo Bonzini } else if (!enabled && old) {
166c2b38b27SPaolo Bonzini QLIST_FOREACH(tl, &clock->timerlists, list) {
167c2b38b27SPaolo Bonzini qemu_event_wait(&tl->timers_done_ev);
168c2b38b27SPaolo Bonzini }
169c2b38b27SPaolo Bonzini }
170c2b38b27SPaolo Bonzini }
171c2b38b27SPaolo Bonzini
timerlist_has_timers(QEMUTimerList * timer_list)172c2b38b27SPaolo Bonzini bool timerlist_has_timers(QEMUTimerList *timer_list)
173c2b38b27SPaolo Bonzini {
174d73415a3SStefan Hajnoczi return !!qatomic_read(&timer_list->active_timers);
175c2b38b27SPaolo Bonzini }
176c2b38b27SPaolo Bonzini
qemu_clock_has_timers(QEMUClockType type)177c2b38b27SPaolo Bonzini bool qemu_clock_has_timers(QEMUClockType type)
178c2b38b27SPaolo Bonzini {
179c2b38b27SPaolo Bonzini return timerlist_has_timers(
180c2b38b27SPaolo Bonzini main_loop_tlg.tl[type]);
181c2b38b27SPaolo Bonzini }
182c2b38b27SPaolo Bonzini
timerlist_expired(QEMUTimerList * timer_list)183c2b38b27SPaolo Bonzini bool timerlist_expired(QEMUTimerList *timer_list)
184c2b38b27SPaolo Bonzini {
185c2b38b27SPaolo Bonzini int64_t expire_time;
186c2b38b27SPaolo Bonzini
187d73415a3SStefan Hajnoczi if (!qatomic_read(&timer_list->active_timers)) {
188c2b38b27SPaolo Bonzini return false;
189c2b38b27SPaolo Bonzini }
190c2b38b27SPaolo Bonzini
1913284c3ddSStefan Hajnoczi WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
192c2b38b27SPaolo Bonzini if (!timer_list->active_timers) {
193c2b38b27SPaolo Bonzini return false;
194c2b38b27SPaolo Bonzini }
195c2b38b27SPaolo Bonzini expire_time = timer_list->active_timers->expire_time;
1963284c3ddSStefan Hajnoczi }
197c2b38b27SPaolo Bonzini
19833bef0b9SPaolo Bonzini return expire_time <= qemu_clock_get_ns(timer_list->clock->type);
199c2b38b27SPaolo Bonzini }
200c2b38b27SPaolo Bonzini
qemu_clock_expired(QEMUClockType type)201c2b38b27SPaolo Bonzini bool qemu_clock_expired(QEMUClockType type)
202c2b38b27SPaolo Bonzini {
203c2b38b27SPaolo Bonzini return timerlist_expired(
204c2b38b27SPaolo Bonzini main_loop_tlg.tl[type]);
205c2b38b27SPaolo Bonzini }
206c2b38b27SPaolo Bonzini
207c2b38b27SPaolo Bonzini /*
208c2b38b27SPaolo Bonzini * As above, but return -1 for no deadline, and do not cap to 2^32
209c2b38b27SPaolo Bonzini * as we know the result is always positive.
210c2b38b27SPaolo Bonzini */
211c2b38b27SPaolo Bonzini
timerlist_deadline_ns(QEMUTimerList * timer_list)212c2b38b27SPaolo Bonzini int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
213c2b38b27SPaolo Bonzini {
214c2b38b27SPaolo Bonzini int64_t delta;
215c2b38b27SPaolo Bonzini int64_t expire_time;
216c2b38b27SPaolo Bonzini
217d73415a3SStefan Hajnoczi if (!qatomic_read(&timer_list->active_timers)) {
218c2b38b27SPaolo Bonzini return -1;
219c2b38b27SPaolo Bonzini }
220c2b38b27SPaolo Bonzini
221c2b38b27SPaolo Bonzini if (!timer_list->clock->enabled) {
222c2b38b27SPaolo Bonzini return -1;
223c2b38b27SPaolo Bonzini }
224c2b38b27SPaolo Bonzini
225c2b38b27SPaolo Bonzini /* The active timers list may be modified before the caller uses our return
226c2b38b27SPaolo Bonzini * value but ->notify_cb() is called when the deadline changes. Therefore
227c2b38b27SPaolo Bonzini * the caller should notice the change and there is no race condition.
228c2b38b27SPaolo Bonzini */
2293284c3ddSStefan Hajnoczi WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
230c2b38b27SPaolo Bonzini if (!timer_list->active_timers) {
231c2b38b27SPaolo Bonzini return -1;
232c2b38b27SPaolo Bonzini }
233c2b38b27SPaolo Bonzini expire_time = timer_list->active_timers->expire_time;
2343284c3ddSStefan Hajnoczi }
235c2b38b27SPaolo Bonzini
236c2b38b27SPaolo Bonzini delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
237c2b38b27SPaolo Bonzini
238c2b38b27SPaolo Bonzini if (delta <= 0) {
239c2b38b27SPaolo Bonzini return 0;
240c2b38b27SPaolo Bonzini }
241c2b38b27SPaolo Bonzini
242c2b38b27SPaolo Bonzini return delta;
243c2b38b27SPaolo Bonzini }
244c2b38b27SPaolo Bonzini
245c2b38b27SPaolo Bonzini /* Calculate the soonest deadline across all timerlists attached
246c2b38b27SPaolo Bonzini * to the clock. This is used for the icount timeout so we
247c2b38b27SPaolo Bonzini * ignore whether or not the clock should be used in deadline
248c2b38b27SPaolo Bonzini * calculations.
249c2b38b27SPaolo Bonzini */
qemu_clock_deadline_ns_all(QEMUClockType type,int attr_mask)250dcb15780SPavel Dovgalyuk int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
251c2b38b27SPaolo Bonzini {
252c2b38b27SPaolo Bonzini int64_t deadline = -1;
253dcb15780SPavel Dovgalyuk int64_t delta;
254dcb15780SPavel Dovgalyuk int64_t expire_time;
255dcb15780SPavel Dovgalyuk QEMUTimer *ts;
256c2b38b27SPaolo Bonzini QEMUTimerList *timer_list;
257c2b38b27SPaolo Bonzini QEMUClock *clock = qemu_clock_ptr(type);
258dcb15780SPavel Dovgalyuk
259dcb15780SPavel Dovgalyuk if (!clock->enabled) {
260dcb15780SPavel Dovgalyuk return -1;
261dcb15780SPavel Dovgalyuk }
262dcb15780SPavel Dovgalyuk
263c2b38b27SPaolo Bonzini QLIST_FOREACH(timer_list, &clock->timerlists, list) {
264*3f42906cSIdan Horowitz if (!qatomic_read(&timer_list->active_timers)) {
265*3f42906cSIdan Horowitz continue;
266*3f42906cSIdan Horowitz }
267dcb15780SPavel Dovgalyuk qemu_mutex_lock(&timer_list->active_timers_lock);
268dcb15780SPavel Dovgalyuk ts = timer_list->active_timers;
269dcb15780SPavel Dovgalyuk /* Skip all external timers */
270dcb15780SPavel Dovgalyuk while (ts && (ts->attributes & ~attr_mask)) {
271dcb15780SPavel Dovgalyuk ts = ts->next;
272dcb15780SPavel Dovgalyuk }
273dcb15780SPavel Dovgalyuk if (!ts) {
274dcb15780SPavel Dovgalyuk qemu_mutex_unlock(&timer_list->active_timers_lock);
275dcb15780SPavel Dovgalyuk continue;
276dcb15780SPavel Dovgalyuk }
277dcb15780SPavel Dovgalyuk expire_time = ts->expire_time;
278dcb15780SPavel Dovgalyuk qemu_mutex_unlock(&timer_list->active_timers_lock);
279dcb15780SPavel Dovgalyuk
280dcb15780SPavel Dovgalyuk delta = expire_time - qemu_clock_get_ns(type);
281dcb15780SPavel Dovgalyuk if (delta <= 0) {
282dcb15780SPavel Dovgalyuk delta = 0;
283dcb15780SPavel Dovgalyuk }
284dcb15780SPavel Dovgalyuk deadline = qemu_soonest_timeout(deadline, delta);
285c2b38b27SPaolo Bonzini }
286c2b38b27SPaolo Bonzini return deadline;
287c2b38b27SPaolo Bonzini }
288c2b38b27SPaolo Bonzini
timerlist_get_clock(QEMUTimerList * timer_list)289c2b38b27SPaolo Bonzini QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
290c2b38b27SPaolo Bonzini {
291c2b38b27SPaolo Bonzini return timer_list->clock->type;
292c2b38b27SPaolo Bonzini }
293c2b38b27SPaolo Bonzini
qemu_clock_get_main_loop_timerlist(QEMUClockType type)294c2b38b27SPaolo Bonzini QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
295c2b38b27SPaolo Bonzini {
296c2b38b27SPaolo Bonzini return main_loop_tlg.tl[type];
297c2b38b27SPaolo Bonzini }
298c2b38b27SPaolo Bonzini
timerlist_notify(QEMUTimerList * timer_list)299c2b38b27SPaolo Bonzini void timerlist_notify(QEMUTimerList *timer_list)
300c2b38b27SPaolo Bonzini {
301c2b38b27SPaolo Bonzini if (timer_list->notify_cb) {
3023f53bc61SPaolo Bonzini timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type);
303c2b38b27SPaolo Bonzini } else {
304c2b38b27SPaolo Bonzini qemu_notify_event();
305c2b38b27SPaolo Bonzini }
306c2b38b27SPaolo Bonzini }
307c2b38b27SPaolo Bonzini
308c2b38b27SPaolo Bonzini /* Transition function to convert a nanosecond timeout to ms
309c2b38b27SPaolo Bonzini * This is used where a system does not support ppoll
310c2b38b27SPaolo Bonzini */
qemu_timeout_ns_to_ms(int64_t ns)311c2b38b27SPaolo Bonzini int qemu_timeout_ns_to_ms(int64_t ns)
312c2b38b27SPaolo Bonzini {
313c2b38b27SPaolo Bonzini int64_t ms;
314c2b38b27SPaolo Bonzini if (ns < 0) {
315c2b38b27SPaolo Bonzini return -1;
316c2b38b27SPaolo Bonzini }
317c2b38b27SPaolo Bonzini
318c2b38b27SPaolo Bonzini if (!ns) {
319c2b38b27SPaolo Bonzini return 0;
320c2b38b27SPaolo Bonzini }
321c2b38b27SPaolo Bonzini
322c2b38b27SPaolo Bonzini /* Always round up, because it's better to wait too long than to wait too
323c2b38b27SPaolo Bonzini * little and effectively busy-wait
324c2b38b27SPaolo Bonzini */
325c2b38b27SPaolo Bonzini ms = DIV_ROUND_UP(ns, SCALE_MS);
326c2b38b27SPaolo Bonzini
327c2b38b27SPaolo Bonzini /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
3285bd34354SFrediano Ziglio return MIN(ms, INT32_MAX);
329c2b38b27SPaolo Bonzini }
330c2b38b27SPaolo Bonzini
331c2b38b27SPaolo Bonzini
332c2b38b27SPaolo Bonzini /* qemu implementation of g_poll which uses a nanosecond timeout but is
333c2b38b27SPaolo Bonzini * otherwise identical to g_poll
334c2b38b27SPaolo Bonzini */
qemu_poll_ns(GPollFD * fds,guint nfds,int64_t timeout)335c2b38b27SPaolo Bonzini int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
336c2b38b27SPaolo Bonzini {
337c2b38b27SPaolo Bonzini #ifdef CONFIG_PPOLL
338c2b38b27SPaolo Bonzini if (timeout < 0) {
339c2b38b27SPaolo Bonzini return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
340c2b38b27SPaolo Bonzini } else {
341c2b38b27SPaolo Bonzini struct timespec ts;
342c2b38b27SPaolo Bonzini int64_t tvsec = timeout / 1000000000LL;
343c2b38b27SPaolo Bonzini /* Avoid possibly overflowing and specifying a negative number of
344c2b38b27SPaolo Bonzini * seconds, which would turn a very long timeout into a busy-wait.
345c2b38b27SPaolo Bonzini */
346c2b38b27SPaolo Bonzini if (tvsec > (int64_t)INT32_MAX) {
347c2b38b27SPaolo Bonzini tvsec = INT32_MAX;
348c2b38b27SPaolo Bonzini }
349c2b38b27SPaolo Bonzini ts.tv_sec = tvsec;
350c2b38b27SPaolo Bonzini ts.tv_nsec = timeout % 1000000000LL;
351c2b38b27SPaolo Bonzini return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
352c2b38b27SPaolo Bonzini }
353c2b38b27SPaolo Bonzini #else
354c2b38b27SPaolo Bonzini return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
355c2b38b27SPaolo Bonzini #endif
356c2b38b27SPaolo Bonzini }
357c2b38b27SPaolo Bonzini
358c2b38b27SPaolo Bonzini
timer_init_full(QEMUTimer * ts,QEMUTimerListGroup * timer_list_group,QEMUClockType type,int scale,int attributes,QEMUTimerCB * cb,void * opaque)35989a603a0SArtem Pisarenko void timer_init_full(QEMUTimer *ts,
36089a603a0SArtem Pisarenko QEMUTimerListGroup *timer_list_group, QEMUClockType type,
36189a603a0SArtem Pisarenko int scale, int attributes,
362c2b38b27SPaolo Bonzini QEMUTimerCB *cb, void *opaque)
363c2b38b27SPaolo Bonzini {
36489a603a0SArtem Pisarenko if (!timer_list_group) {
36589a603a0SArtem Pisarenko timer_list_group = &main_loop_tlg;
36689a603a0SArtem Pisarenko }
36789a603a0SArtem Pisarenko ts->timer_list = timer_list_group->tl[type];
368c2b38b27SPaolo Bonzini ts->cb = cb;
369c2b38b27SPaolo Bonzini ts->opaque = opaque;
370c2b38b27SPaolo Bonzini ts->scale = scale;
37189a603a0SArtem Pisarenko ts->attributes = attributes;
372c2b38b27SPaolo Bonzini ts->expire_time = -1;
373c2b38b27SPaolo Bonzini }
374c2b38b27SPaolo Bonzini
timer_deinit(QEMUTimer * ts)375c2b38b27SPaolo Bonzini void timer_deinit(QEMUTimer *ts)
376c2b38b27SPaolo Bonzini {
377c2b38b27SPaolo Bonzini assert(ts->expire_time == -1);
378c2b38b27SPaolo Bonzini ts->timer_list = NULL;
379c2b38b27SPaolo Bonzini }
380c2b38b27SPaolo Bonzini
timer_del_locked(QEMUTimerList * timer_list,QEMUTimer * ts)381c2b38b27SPaolo Bonzini static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
382c2b38b27SPaolo Bonzini {
383c2b38b27SPaolo Bonzini QEMUTimer **pt, *t;
384c2b38b27SPaolo Bonzini
385c2b38b27SPaolo Bonzini ts->expire_time = -1;
386c2b38b27SPaolo Bonzini pt = &timer_list->active_timers;
387c2b38b27SPaolo Bonzini for(;;) {
388c2b38b27SPaolo Bonzini t = *pt;
389c2b38b27SPaolo Bonzini if (!t)
390c2b38b27SPaolo Bonzini break;
391c2b38b27SPaolo Bonzini if (t == ts) {
392d73415a3SStefan Hajnoczi qatomic_set(pt, t->next);
393c2b38b27SPaolo Bonzini break;
394c2b38b27SPaolo Bonzini }
395c2b38b27SPaolo Bonzini pt = &t->next;
396c2b38b27SPaolo Bonzini }
397c2b38b27SPaolo Bonzini }
398c2b38b27SPaolo Bonzini
timer_mod_ns_locked(QEMUTimerList * timer_list,QEMUTimer * ts,int64_t expire_time)399c2b38b27SPaolo Bonzini static bool timer_mod_ns_locked(QEMUTimerList *timer_list,
400c2b38b27SPaolo Bonzini QEMUTimer *ts, int64_t expire_time)
401c2b38b27SPaolo Bonzini {
402c2b38b27SPaolo Bonzini QEMUTimer **pt, *t;
403c2b38b27SPaolo Bonzini
404c2b38b27SPaolo Bonzini /* add the timer in the sorted list */
405c2b38b27SPaolo Bonzini pt = &timer_list->active_timers;
406c2b38b27SPaolo Bonzini for (;;) {
407c2b38b27SPaolo Bonzini t = *pt;
408c2b38b27SPaolo Bonzini if (!timer_expired_ns(t, expire_time)) {
409c2b38b27SPaolo Bonzini break;
410c2b38b27SPaolo Bonzini }
411c2b38b27SPaolo Bonzini pt = &t->next;
412c2b38b27SPaolo Bonzini }
413c2b38b27SPaolo Bonzini ts->expire_time = MAX(expire_time, 0);
414c2b38b27SPaolo Bonzini ts->next = *pt;
415d73415a3SStefan Hajnoczi qatomic_set(pt, ts);
416c2b38b27SPaolo Bonzini
417c2b38b27SPaolo Bonzini return pt == &timer_list->active_timers;
418c2b38b27SPaolo Bonzini }
419c2b38b27SPaolo Bonzini
timerlist_rearm(QEMUTimerList * timer_list)420c2b38b27SPaolo Bonzini static void timerlist_rearm(QEMUTimerList *timer_list)
421c2b38b27SPaolo Bonzini {
422c2b38b27SPaolo Bonzini /* Interrupt execution to force deadline recalculation. */
423740b1759SClaudio Fontana if (icount_enabled() && timer_list->clock->type == QEMU_CLOCK_VIRTUAL) {
4248191d368SClaudio Fontana icount_start_warp_timer();
425c2b38b27SPaolo Bonzini }
426c2b38b27SPaolo Bonzini timerlist_notify(timer_list);
427c2b38b27SPaolo Bonzini }
428c2b38b27SPaolo Bonzini
429c2b38b27SPaolo Bonzini /* stop a timer, but do not dealloc it */
timer_del(QEMUTimer * ts)430c2b38b27SPaolo Bonzini void timer_del(QEMUTimer *ts)
431c2b38b27SPaolo Bonzini {
432c2b38b27SPaolo Bonzini QEMUTimerList *timer_list = ts->timer_list;
433c2b38b27SPaolo Bonzini
434c2b38b27SPaolo Bonzini if (timer_list) {
435c2b38b27SPaolo Bonzini qemu_mutex_lock(&timer_list->active_timers_lock);
436c2b38b27SPaolo Bonzini timer_del_locked(timer_list, ts);
437c2b38b27SPaolo Bonzini qemu_mutex_unlock(&timer_list->active_timers_lock);
438c2b38b27SPaolo Bonzini }
439c2b38b27SPaolo Bonzini }
440c2b38b27SPaolo Bonzini
441c2b38b27SPaolo Bonzini /* modify the current timer so that it will be fired when current_time
442c2b38b27SPaolo Bonzini >= expire_time. The corresponding callback will be called. */
timer_mod_ns(QEMUTimer * ts,int64_t expire_time)443c2b38b27SPaolo Bonzini void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
444c2b38b27SPaolo Bonzini {
445c2b38b27SPaolo Bonzini QEMUTimerList *timer_list = ts->timer_list;
446c2b38b27SPaolo Bonzini bool rearm;
447c2b38b27SPaolo Bonzini
448c2b38b27SPaolo Bonzini qemu_mutex_lock(&timer_list->active_timers_lock);
449c2b38b27SPaolo Bonzini timer_del_locked(timer_list, ts);
450c2b38b27SPaolo Bonzini rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
451c2b38b27SPaolo Bonzini qemu_mutex_unlock(&timer_list->active_timers_lock);
452c2b38b27SPaolo Bonzini
453c2b38b27SPaolo Bonzini if (rearm) {
454c2b38b27SPaolo Bonzini timerlist_rearm(timer_list);
455c2b38b27SPaolo Bonzini }
456c2b38b27SPaolo Bonzini }
457c2b38b27SPaolo Bonzini
458c2b38b27SPaolo Bonzini /* modify the current timer so that it will be fired when current_time
459c2b38b27SPaolo Bonzini >= expire_time or the current deadline, whichever comes earlier.
460c2b38b27SPaolo Bonzini The corresponding callback will be called. */
timer_mod_anticipate_ns(QEMUTimer * ts,int64_t expire_time)461c2b38b27SPaolo Bonzini void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)
462c2b38b27SPaolo Bonzini {
463c2b38b27SPaolo Bonzini QEMUTimerList *timer_list = ts->timer_list;
464c2b38b27SPaolo Bonzini bool rearm;
465c2b38b27SPaolo Bonzini
4666e8a355dSDaniel Brodsky WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
467c2b38b27SPaolo Bonzini if (ts->expire_time == -1 || ts->expire_time > expire_time) {
468c2b38b27SPaolo Bonzini if (ts->expire_time != -1) {
469c2b38b27SPaolo Bonzini timer_del_locked(timer_list, ts);
470c2b38b27SPaolo Bonzini }
471c2b38b27SPaolo Bonzini rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
472c2b38b27SPaolo Bonzini } else {
473c2b38b27SPaolo Bonzini rearm = false;
474c2b38b27SPaolo Bonzini }
4756e8a355dSDaniel Brodsky }
476c2b38b27SPaolo Bonzini if (rearm) {
477c2b38b27SPaolo Bonzini timerlist_rearm(timer_list);
478c2b38b27SPaolo Bonzini }
479c2b38b27SPaolo Bonzini }
480c2b38b27SPaolo Bonzini
timer_mod(QEMUTimer * ts,int64_t expire_time)481c2b38b27SPaolo Bonzini void timer_mod(QEMUTimer *ts, int64_t expire_time)
482c2b38b27SPaolo Bonzini {
483c2b38b27SPaolo Bonzini timer_mod_ns(ts, expire_time * ts->scale);
484c2b38b27SPaolo Bonzini }
485c2b38b27SPaolo Bonzini
timer_mod_anticipate(QEMUTimer * ts,int64_t expire_time)486c2b38b27SPaolo Bonzini void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time)
487c2b38b27SPaolo Bonzini {
488c2b38b27SPaolo Bonzini timer_mod_anticipate_ns(ts, expire_time * ts->scale);
489c2b38b27SPaolo Bonzini }
490c2b38b27SPaolo Bonzini
timer_pending(QEMUTimer * ts)491c2b38b27SPaolo Bonzini bool timer_pending(QEMUTimer *ts)
492c2b38b27SPaolo Bonzini {
493c2b38b27SPaolo Bonzini return ts->expire_time >= 0;
494c2b38b27SPaolo Bonzini }
495c2b38b27SPaolo Bonzini
timer_expired(QEMUTimer * timer_head,int64_t current_time)496c2b38b27SPaolo Bonzini bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
497c2b38b27SPaolo Bonzini {
498c2b38b27SPaolo Bonzini return timer_expired_ns(timer_head, current_time * timer_head->scale);
499c2b38b27SPaolo Bonzini }
500c2b38b27SPaolo Bonzini
timerlist_run_timers(QEMUTimerList * timer_list)501c2b38b27SPaolo Bonzini bool timerlist_run_timers(QEMUTimerList *timer_list)
502c2b38b27SPaolo Bonzini {
503c2b38b27SPaolo Bonzini QEMUTimer *ts;
504c2b38b27SPaolo Bonzini int64_t current_time;
505c2b38b27SPaolo Bonzini bool progress = false;
506c2b38b27SPaolo Bonzini QEMUTimerCB *cb;
507c2b38b27SPaolo Bonzini void *opaque;
508c2b38b27SPaolo Bonzini
509d73415a3SStefan Hajnoczi if (!qatomic_read(&timer_list->active_timers)) {
510c2b38b27SPaolo Bonzini return false;
511c2b38b27SPaolo Bonzini }
512c2b38b27SPaolo Bonzini
513c2b38b27SPaolo Bonzini qemu_event_reset(&timer_list->timers_done_ev);
514c2b38b27SPaolo Bonzini if (!timer_list->clock->enabled) {
515c2b38b27SPaolo Bonzini goto out;
516c2b38b27SPaolo Bonzini }
517c2b38b27SPaolo Bonzini
518c2b38b27SPaolo Bonzini switch (timer_list->clock->type) {
519c2b38b27SPaolo Bonzini case QEMU_CLOCK_REALTIME:
520c2b38b27SPaolo Bonzini break;
521c2b38b27SPaolo Bonzini default:
522c2b38b27SPaolo Bonzini case QEMU_CLOCK_VIRTUAL:
523c2b38b27SPaolo Bonzini break;
524c2b38b27SPaolo Bonzini case QEMU_CLOCK_HOST:
525c2b38b27SPaolo Bonzini if (!replay_checkpoint(CHECKPOINT_CLOCK_HOST)) {
526c2b38b27SPaolo Bonzini goto out;
527c2b38b27SPaolo Bonzini }
528c2b38b27SPaolo Bonzini break;
529c2b38b27SPaolo Bonzini case QEMU_CLOCK_VIRTUAL_RT:
530c2b38b27SPaolo Bonzini if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL_RT)) {
531c2b38b27SPaolo Bonzini goto out;
532c2b38b27SPaolo Bonzini }
533c2b38b27SPaolo Bonzini break;
534c2b38b27SPaolo Bonzini }
535c2b38b27SPaolo Bonzini
536e81f8679SArtem Pisarenko /*
5373cf10b29SPhilippe Mathieu-Daudé * Extract expired timers from active timers list and process them.
538e81f8679SArtem Pisarenko *
539e81f8679SArtem Pisarenko * In rr mode we need "filtered" checkpointing for virtual clock. The
540e81f8679SArtem Pisarenko * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer,
541e81f8679SArtem Pisarenko * and that must only be done once since the clock value stays the same. Because
542e81f8679SArtem Pisarenko * non-EXTERNAL timers may appear in the timers list while it being processed,
543e81f8679SArtem Pisarenko * the checkpoint can be issued at a time until no timers are left and we are
544e81f8679SArtem Pisarenko * done".
545e81f8679SArtem Pisarenko */
546c2b38b27SPaolo Bonzini current_time = qemu_clock_get_ns(timer_list->clock->type);
547c2b38b27SPaolo Bonzini qemu_mutex_lock(&timer_list->active_timers_lock);
548e81f8679SArtem Pisarenko while ((ts = timer_list->active_timers)) {
549c2b38b27SPaolo Bonzini if (!timer_expired_ns(ts, current_time)) {
550e81f8679SArtem Pisarenko /* No expired timers left. The checkpoint can be skipped
551e81f8679SArtem Pisarenko * if no timers fired or they were all external.
552e81f8679SArtem Pisarenko */
553c2b38b27SPaolo Bonzini break;
554c2b38b27SPaolo Bonzini }
555677a3babSPavel Dovgalyuk /* Checkpoint for virtual clock is redundant in cases where
556677a3babSPavel Dovgalyuk * it's being triggered with only non-EXTERNAL timers, because
557677a3babSPavel Dovgalyuk * these timers don't change guest state directly.
558e81f8679SArtem Pisarenko */
559677a3babSPavel Dovgalyuk if (replay_mode != REPLAY_MODE_NONE
560677a3babSPavel Dovgalyuk && timer_list->clock->type == QEMU_CLOCK_VIRTUAL
561677a3babSPavel Dovgalyuk && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)
562677a3babSPavel Dovgalyuk && !replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL)) {
563677a3babSPavel Dovgalyuk qemu_mutex_unlock(&timer_list->active_timers_lock);
564677a3babSPavel Dovgalyuk goto out;
565e81f8679SArtem Pisarenko }
566c2b38b27SPaolo Bonzini
567c2b38b27SPaolo Bonzini /* remove timer from the list before calling the callback */
568c2b38b27SPaolo Bonzini timer_list->active_timers = ts->next;
569c2b38b27SPaolo Bonzini ts->next = NULL;
570c2b38b27SPaolo Bonzini ts->expire_time = -1;
571c2b38b27SPaolo Bonzini cb = ts->cb;
572c2b38b27SPaolo Bonzini opaque = ts->opaque;
573c2b38b27SPaolo Bonzini
574c2b38b27SPaolo Bonzini /* run the callback (the timer list can be modified) */
575e81f8679SArtem Pisarenko qemu_mutex_unlock(&timer_list->active_timers_lock);
576c2b38b27SPaolo Bonzini cb(opaque);
577e81f8679SArtem Pisarenko qemu_mutex_lock(&timer_list->active_timers_lock);
578e81f8679SArtem Pisarenko
579c2b38b27SPaolo Bonzini progress = true;
580c2b38b27SPaolo Bonzini }
581e81f8679SArtem Pisarenko qemu_mutex_unlock(&timer_list->active_timers_lock);
582c2b38b27SPaolo Bonzini
583c2b38b27SPaolo Bonzini out:
584c2b38b27SPaolo Bonzini qemu_event_set(&timer_list->timers_done_ev);
585c2b38b27SPaolo Bonzini return progress;
586c2b38b27SPaolo Bonzini }
587c2b38b27SPaolo Bonzini
qemu_clock_run_timers(QEMUClockType type)588c2b38b27SPaolo Bonzini bool qemu_clock_run_timers(QEMUClockType type)
589c2b38b27SPaolo Bonzini {
590c2b38b27SPaolo Bonzini return timerlist_run_timers(main_loop_tlg.tl[type]);
591c2b38b27SPaolo Bonzini }
592c2b38b27SPaolo Bonzini
timerlistgroup_init(QEMUTimerListGroup * tlg,QEMUTimerListNotifyCB * cb,void * opaque)593c2b38b27SPaolo Bonzini void timerlistgroup_init(QEMUTimerListGroup *tlg,
594c2b38b27SPaolo Bonzini QEMUTimerListNotifyCB *cb, void *opaque)
595c2b38b27SPaolo Bonzini {
596c2b38b27SPaolo Bonzini QEMUClockType type;
597c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
598c2b38b27SPaolo Bonzini tlg->tl[type] = timerlist_new(type, cb, opaque);
599c2b38b27SPaolo Bonzini }
600c2b38b27SPaolo Bonzini }
601c2b38b27SPaolo Bonzini
timerlistgroup_deinit(QEMUTimerListGroup * tlg)602c2b38b27SPaolo Bonzini void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
603c2b38b27SPaolo Bonzini {
604c2b38b27SPaolo Bonzini QEMUClockType type;
605c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
606c2b38b27SPaolo Bonzini timerlist_free(tlg->tl[type]);
607c2b38b27SPaolo Bonzini }
608c2b38b27SPaolo Bonzini }
609c2b38b27SPaolo Bonzini
timerlistgroup_run_timers(QEMUTimerListGroup * tlg)610c2b38b27SPaolo Bonzini bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
611c2b38b27SPaolo Bonzini {
612c2b38b27SPaolo Bonzini QEMUClockType type;
613c2b38b27SPaolo Bonzini bool progress = false;
614c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
615c2b38b27SPaolo Bonzini progress |= timerlist_run_timers(tlg->tl[type]);
616c2b38b27SPaolo Bonzini }
617c2b38b27SPaolo Bonzini return progress;
618c2b38b27SPaolo Bonzini }
619c2b38b27SPaolo Bonzini
timerlistgroup_deadline_ns(QEMUTimerListGroup * tlg)620c2b38b27SPaolo Bonzini int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
621c2b38b27SPaolo Bonzini {
622c2b38b27SPaolo Bonzini int64_t deadline = -1;
623c2b38b27SPaolo Bonzini QEMUClockType type;
624c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
625c2b38b27SPaolo Bonzini if (qemu_clock_use_for_deadline(type)) {
626c2b38b27SPaolo Bonzini deadline = qemu_soonest_timeout(deadline,
627c2b38b27SPaolo Bonzini timerlist_deadline_ns(tlg->tl[type]));
628c2b38b27SPaolo Bonzini }
629c2b38b27SPaolo Bonzini }
630c2b38b27SPaolo Bonzini return deadline;
631c2b38b27SPaolo Bonzini }
632c2b38b27SPaolo Bonzini
qemu_clock_get_ns(QEMUClockType type)633c2b38b27SPaolo Bonzini int64_t qemu_clock_get_ns(QEMUClockType type)
634c2b38b27SPaolo Bonzini {
635c2b38b27SPaolo Bonzini switch (type) {
636c2b38b27SPaolo Bonzini case QEMU_CLOCK_REALTIME:
637c2b38b27SPaolo Bonzini return get_clock();
638c2b38b27SPaolo Bonzini default:
639c2b38b27SPaolo Bonzini case QEMU_CLOCK_VIRTUAL:
640430065daSClaudio Fontana return cpus_get_virtual_clock();
641c2b38b27SPaolo Bonzini case QEMU_CLOCK_HOST:
6423c2d4c8aSDr. David Alan Gilbert return REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime());
643c2b38b27SPaolo Bonzini case QEMU_CLOCK_VIRTUAL_RT:
644c2b38b27SPaolo Bonzini return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock());
645c2b38b27SPaolo Bonzini }
646c2b38b27SPaolo Bonzini }
647c2b38b27SPaolo Bonzini
init_clocks(QEMUTimerListNotifyCB * notify_cb)6483f53bc61SPaolo Bonzini void init_clocks(QEMUTimerListNotifyCB *notify_cb)
649c2b38b27SPaolo Bonzini {
650c2b38b27SPaolo Bonzini QEMUClockType type;
651c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
6523f53bc61SPaolo Bonzini qemu_clock_init(type, notify_cb);
653c2b38b27SPaolo Bonzini }
654c2b38b27SPaolo Bonzini
655c2b38b27SPaolo Bonzini #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
656c2b38b27SPaolo Bonzini prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
657c2b38b27SPaolo Bonzini #endif
658c2b38b27SPaolo Bonzini }
659c2b38b27SPaolo Bonzini
timer_expire_time_ns(QEMUTimer * ts)660c2b38b27SPaolo Bonzini uint64_t timer_expire_time_ns(QEMUTimer *ts)
661c2b38b27SPaolo Bonzini {
662c2b38b27SPaolo Bonzini return timer_pending(ts) ? ts->expire_time : -1;
663c2b38b27SPaolo Bonzini }
664c2b38b27SPaolo Bonzini
qemu_clock_run_all_timers(void)665c2b38b27SPaolo Bonzini bool qemu_clock_run_all_timers(void)
666c2b38b27SPaolo Bonzini {
667c2b38b27SPaolo Bonzini bool progress = false;
668c2b38b27SPaolo Bonzini QEMUClockType type;
669c2b38b27SPaolo Bonzini
670c2b38b27SPaolo Bonzini for (type = 0; type < QEMU_CLOCK_MAX; type++) {
6716b8f0187SPaolo Bonzini if (qemu_clock_use_for_deadline(type)) {
672c2b38b27SPaolo Bonzini progress |= qemu_clock_run_timers(type);
673c2b38b27SPaolo Bonzini }
6746b8f0187SPaolo Bonzini }
675c2b38b27SPaolo Bonzini
676c2b38b27SPaolo Bonzini return progress;
677c2b38b27SPaolo Bonzini }
678