blob: 6a0de33dd2b86c339dc9dc5abe6548e44c918cb4 [file] [log] [blame]
Paolo Bonzinidb1a4972010-03-10 11:38:55 +01001/*
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
Peter Maydelld38ea872016-01-29 17:50:05 +000025#include "qemu/osdep.h"
Peter Maydell1ac02062015-01-20 16:16:40 +000026#include "qemu/main-loop.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010027#include "qemu/timer.h"
Stefan Hajnoczi3284c3d2020-03-16 11:09:56 +000028#include "qemu/lockable.h"
Claudio Fontana740b1752020-08-19 13:17:19 +020029#include "sysemu/cpu-timers.h"
Pavel Dovgalyuk8eda2062015-09-17 19:24:28 +030030#include "sysemu/replay.h"
Paolo Bonzinid2528bd2017-03-03 12:01:16 +010031#include "sysemu/cpus.h"
Peter Maydell1ac02062015-01-20 16:16:40 +000032
Anthony Liguori30ea8332012-11-02 16:12:53 -050033#ifdef CONFIG_POSIX
34#include <pthread.h>
35#endif
Stefan Weilbff9f8b2012-04-20 10:27:06 +020036
Alex Bligh4e0c6522013-08-21 16:02:43 +010037#ifdef CONFIG_PPOLL
38#include <poll.h>
39#endif
40
Alex Blighcd758dd2013-08-21 16:02:44 +010041#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
42#include <sys/prctl.h>
43#endif
44
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010045/***********************************************************/
46/* timers */
47
Alex Blighb4049b72013-08-21 16:03:09 +010048typedef struct QEMUClock {
Liu Ping Fan3c053412013-09-25 14:21:00 +080049 /* We rely on BQL to protect the timerlists */
Alex Blighff83c662013-08-21 16:02:46 +010050 QLIST_HEAD(, QEMUTimerList) timerlists;
Jan Kiszka691a0c92011-06-20 14:06:27 +020051
Alex Blighff83c662013-08-21 16:02:46 +010052 QEMUClockType type;
Stefan Weil9a14b292012-04-20 11:51:58 +020053 bool enabled;
Alex Blighb4049b72013-08-21 16:03:09 +010054} QEMUClock;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010055
Alex Bligh754d6a52013-08-21 16:02:48 +010056QEMUTimerListGroup main_loop_tlg;
Stefan Weilfbdb6642014-05-03 08:12:15 +020057static QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
Alex Blighff83c662013-08-21 16:02:46 +010058
59/* A QEMUTimerList is a list of timers attached to a clock. More
60 * than one QEMUTimerList can be attached to each clock, for instance
61 * used by different AioContexts / threads. Each clock also has
62 * a list of the QEMUTimerLists associated with it, in order that
63 * reenabling the clock can call all the notifiers.
64 */
65
66struct QEMUTimerList {
Stefan Weil9a14b292012-04-20 11:51:58 +020067 QEMUClock *clock;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +020068 QemuMutex active_timers_lock;
Alex Blighff83c662013-08-21 16:02:46 +010069 QEMUTimer *active_timers;
70 QLIST_ENTRY(QEMUTimerList) list;
Alex Blighd5541d82013-08-21 16:02:50 +010071 QEMUTimerListNotifyCB *notify_cb;
72 void *notify_opaque;
Liu Ping Fan3c053412013-09-25 14:21:00 +080073
74 /* lightweight method to mark the end of timerlist's running */
75 QemuEvent timers_done_ev;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010076};
77
Alex Bligh7bf8fbd2013-08-21 16:03:03 +010078/**
79 * qemu_clock_ptr:
80 * @type: type of clock
81 *
82 * Translate a clock type into a pointer to QEMUClock object.
83 *
84 * Returns: a pointer to the QEMUClock object
85 */
Alex Blighb4049b72013-08-21 16:03:09 +010086static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
Alex Bligh7bf8fbd2013-08-21 16:03:03 +010087{
88 return &qemu_clocks[type];
89}
90
Alex Blighe93379b2013-08-21 16:02:39 +010091static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
Stefan Weil45c7b372011-03-24 21:31:24 +010092{
93 return timer_head && (timer_head->expire_time <= current_time);
94}
95
Alex Bligh7bf8fbd2013-08-21 16:03:03 +010096QEMUTimerList *timerlist_new(QEMUClockType type,
97 QEMUTimerListNotifyCB *cb,
98 void *opaque)
Alex Blighff83c662013-08-21 16:02:46 +010099{
100 QEMUTimerList *timer_list;
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100101 QEMUClock *clock = qemu_clock_ptr(type);
Alex Blighff83c662013-08-21 16:02:46 +0100102
Markus Armbrusterb21e2382022-03-15 15:41:56 +0100103 timer_list = g_new0(QEMUTimerList, 1);
Paolo Bonzinie4efd8a2015-07-21 16:07:48 +0200104 qemu_event_init(&timer_list->timers_done_ev, true);
Alex Blighff83c662013-08-21 16:02:46 +0100105 timer_list->clock = clock;
Alex Blighd5541d82013-08-21 16:02:50 +0100106 timer_list->notify_cb = cb;
107 timer_list->notify_opaque = opaque;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200108 qemu_mutex_init(&timer_list->active_timers_lock);
Alex Blighff83c662013-08-21 16:02:46 +0100109 QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
110 return timer_list;
111}
112
Alex Blighff83c662013-08-21 16:02:46 +0100113void timerlist_free(QEMUTimerList *timer_list)
114{
115 assert(!timerlist_has_timers(timer_list));
116 if (timer_list->clock) {
117 QLIST_REMOVE(timer_list, list);
Alex Blighff83c662013-08-21 16:02:46 +0100118 }
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200119 qemu_mutex_destroy(&timer_list->active_timers_lock);
Alex Blighff83c662013-08-21 16:02:46 +0100120 g_free(timer_list);
121}
122
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100123static void qemu_clock_init(QEMUClockType type, QEMUTimerListNotifyCB *notify_cb)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100124{
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100125 QEMUClock *clock = qemu_clock_ptr(type);
Jan Kiszka691a0c92011-06-20 14:06:27 +0200126
Kirill Batuzov02ce2322014-05-06 16:59:53 +0400127 /* Assert that the clock of type TYPE has not been initialized yet. */
128 assert(main_loop_tlg.tl[type] == NULL);
129
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100130 clock->type = type;
Gonglei3fdd0ee2016-08-09 15:49:15 +0800131 clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true);
Alex Blighff83c662013-08-21 16:02:46 +0100132 QLIST_INIT(&clock->timerlists);
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100133 main_loop_tlg.tl[type] = timerlist_new(type, notify_cb, NULL);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100134}
135
Alex Bligh40daca52013-08-21 16:03:02 +0100136bool qemu_clock_use_for_deadline(QEMUClockType type)
Alex Blighff83c662013-08-21 16:02:46 +0100137{
Claudio Fontana740b1752020-08-19 13:17:19 +0200138 return !(icount_enabled() && (type == QEMU_CLOCK_VIRTUAL));
Alex Blighff83c662013-08-21 16:02:46 +0100139}
140
Alex Bligh40daca52013-08-21 16:03:02 +0100141void qemu_clock_notify(QEMUClockType type)
Alex Blighb1bbfe72013-08-21 16:02:55 +0100142{
143 QEMUTimerList *timer_list;
Alex Bligh40daca52013-08-21 16:03:02 +0100144 QEMUClock *clock = qemu_clock_ptr(type);
Alex Blighb1bbfe72013-08-21 16:02:55 +0100145 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
146 timerlist_notify(timer_list);
147 }
148}
149
Liu Ping Fan3c053412013-09-25 14:21:00 +0800150/* Disabling the clock will wait for related timerlists to stop
151 * executing qemu_run_timers. Thus, this functions should not
152 * be used from the callback of a timer that is based on @clock.
153 * Doing so would cause a deadlock.
154 *
155 * Caller should hold BQL.
156 */
Alex Bligh40daca52013-08-21 16:03:02 +0100157void qemu_clock_enable(QEMUClockType type, bool enabled)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100158{
Alex Bligh40daca52013-08-21 16:03:02 +0100159 QEMUClock *clock = qemu_clock_ptr(type);
Liu Ping Fan3c053412013-09-25 14:21:00 +0800160 QEMUTimerList *tl;
Paolo Bonzinifbdc14e2011-09-27 18:23:14 +0200161 bool old = clock->enabled;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100162 clock->enabled = enabled;
Paolo Bonzinifbdc14e2011-09-27 18:23:14 +0200163 if (enabled && !old) {
Alex Bligh40daca52013-08-21 16:03:02 +0100164 qemu_clock_notify(type);
Liu Ping Fan3c053412013-09-25 14:21:00 +0800165 } else if (!enabled && old) {
166 QLIST_FOREACH(tl, &clock->timerlists, list) {
167 qemu_event_wait(&tl->timers_done_ev);
168 }
Paolo Bonzinifbdc14e2011-09-27 18:23:14 +0200169 }
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100170}
171
Alex Blighff83c662013-08-21 16:02:46 +0100172bool timerlist_has_timers(QEMUTimerList *timer_list)
Paolo Bonzinidc2dfcf2011-09-12 15:50:16 +0200173{
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100174 return !!qatomic_read(&timer_list->active_timers);
Paolo Bonzinidc2dfcf2011-09-12 15:50:16 +0200175}
176
Alex Bligh40daca52013-08-21 16:03:02 +0100177bool qemu_clock_has_timers(QEMUClockType type)
Paolo Bonzinidc2dfcf2011-09-12 15:50:16 +0200178{
Alex Bligh40daca52013-08-21 16:03:02 +0100179 return timerlist_has_timers(
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100180 main_loop_tlg.tl[type]);
Paolo Bonzinidc2dfcf2011-09-12 15:50:16 +0200181}
182
Alex Blighff83c662013-08-21 16:02:46 +0100183bool timerlist_expired(QEMUTimerList *timer_list)
184{
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200185 int64_t expire_time;
186
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100187 if (!qatomic_read(&timer_list->active_timers)) {
Paolo Bonzini8caa05d2016-12-01 09:58:02 +0100188 return false;
189 }
190
Stefan Hajnoczi3284c3d2020-03-16 11:09:56 +0000191 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
192 if (!timer_list->active_timers) {
193 return false;
194 }
195 expire_time = timer_list->active_timers->expire_time;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200196 }
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200197
Paolo Bonzini33bef0b2017-03-03 11:37:57 +0100198 return expire_time <= qemu_clock_get_ns(timer_list->clock->type);
Alex Blighff83c662013-08-21 16:02:46 +0100199}
200
Alex Bligh40daca52013-08-21 16:03:02 +0100201bool qemu_clock_expired(QEMUClockType type)
Alex Blighff83c662013-08-21 16:02:46 +0100202{
Alex Bligh40daca52013-08-21 16:03:02 +0100203 return timerlist_expired(
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100204 main_loop_tlg.tl[type]);
Alex Blighff83c662013-08-21 16:02:46 +0100205}
206
Alex Bligh02a03a92013-08-21 16:02:41 +0100207/*
208 * As above, but return -1 for no deadline, and do not cap to 2^32
209 * as we know the result is always positive.
210 */
211
Alex Blighff83c662013-08-21 16:02:46 +0100212int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
Alex Bligh02a03a92013-08-21 16:02:41 +0100213{
214 int64_t delta;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200215 int64_t expire_time;
Alex Bligh02a03a92013-08-21 16:02:41 +0100216
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100217 if (!qatomic_read(&timer_list->active_timers)) {
Paolo Bonzini8caa05d2016-12-01 09:58:02 +0100218 return -1;
219 }
220
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200221 if (!timer_list->clock->enabled) {
Alex Bligh02a03a92013-08-21 16:02:41 +0100222 return -1;
223 }
224
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200225 /* The active timers list may be modified before the caller uses our return
226 * value but ->notify_cb() is called when the deadline changes. Therefore
227 * the caller should notice the change and there is no race condition.
228 */
Stefan Hajnoczi3284c3d2020-03-16 11:09:56 +0000229 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
230 if (!timer_list->active_timers) {
231 return -1;
232 }
233 expire_time = timer_list->active_timers->expire_time;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200234 }
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200235
236 delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
Alex Bligh02a03a92013-08-21 16:02:41 +0100237
238 if (delta <= 0) {
239 return 0;
240 }
241
242 return delta;
243}
244
Alex Blighac70aaf2013-08-21 16:02:57 +0100245/* Calculate the soonest deadline across all timerlists attached
246 * to the clock. This is used for the icount timeout so we
247 * ignore whether or not the clock should be used in deadline
248 * calculations.
249 */
Pavel Dovgalyukdcb15782019-07-25 11:44:26 +0300250int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
Alex Blighac70aaf2013-08-21 16:02:57 +0100251{
252 int64_t deadline = -1;
Pavel Dovgalyukdcb15782019-07-25 11:44:26 +0300253 int64_t delta;
254 int64_t expire_time;
255 QEMUTimer *ts;
Alex Blighac70aaf2013-08-21 16:02:57 +0100256 QEMUTimerList *timer_list;
Alex Bligh40daca52013-08-21 16:03:02 +0100257 QEMUClock *clock = qemu_clock_ptr(type);
Pavel Dovgalyukdcb15782019-07-25 11:44:26 +0300258
259 if (!clock->enabled) {
260 return -1;
261 }
262
Alex Blighac70aaf2013-08-21 16:02:57 +0100263 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
Idan Horowitz3f429062022-01-14 02:43:58 +0200264 if (!qatomic_read(&timer_list->active_timers)) {
265 continue;
266 }
Pavel Dovgalyukdcb15782019-07-25 11:44:26 +0300267 qemu_mutex_lock(&timer_list->active_timers_lock);
268 ts = timer_list->active_timers;
269 /* Skip all external timers */
270 while (ts && (ts->attributes & ~attr_mask)) {
271 ts = ts->next;
272 }
273 if (!ts) {
274 qemu_mutex_unlock(&timer_list->active_timers_lock);
275 continue;
276 }
277 expire_time = ts->expire_time;
278 qemu_mutex_unlock(&timer_list->active_timers_lock);
279
280 delta = expire_time - qemu_clock_get_ns(type);
281 if (delta <= 0) {
282 delta = 0;
283 }
284 deadline = qemu_soonest_timeout(deadline, delta);
Alex Blighac70aaf2013-08-21 16:02:57 +0100285 }
286 return deadline;
287}
288
Alex Bligh40daca52013-08-21 16:03:02 +0100289QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
Alex Blighff83c662013-08-21 16:02:46 +0100290{
Alex Bligh40daca52013-08-21 16:03:02 +0100291 return timer_list->clock->type;
Alex Blighff83c662013-08-21 16:02:46 +0100292}
293
Alex Bligh40daca52013-08-21 16:03:02 +0100294QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
Alex Blighff83c662013-08-21 16:02:46 +0100295{
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100296 return main_loop_tlg.tl[type];
Alex Blighff83c662013-08-21 16:02:46 +0100297}
298
Alex Blighd5541d82013-08-21 16:02:50 +0100299void timerlist_notify(QEMUTimerList *timer_list)
300{
301 if (timer_list->notify_cb) {
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100302 timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type);
Alex Blighd5541d82013-08-21 16:02:50 +0100303 } else {
304 qemu_notify_event();
305 }
306}
307
Alex Bligh02a03a92013-08-21 16:02:41 +0100308/* Transition function to convert a nanosecond timeout to ms
309 * This is used where a system does not support ppoll
310 */
311int qemu_timeout_ns_to_ms(int64_t ns)
312{
313 int64_t ms;
314 if (ns < 0) {
315 return -1;
316 }
317
318 if (!ns) {
319 return 0;
320 }
321
322 /* Always round up, because it's better to wait too long than to wait too
323 * little and effectively busy-wait
324 */
Laurent Vivier5029b962016-05-31 18:36:04 +0200325 ms = DIV_ROUND_UP(ns, SCALE_MS);
Alex Bligh02a03a92013-08-21 16:02:41 +0100326
327 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
Frediano Ziglio5bd34352019-10-23 13:26:52 +0100328 return MIN(ms, INT32_MAX);
Alex Bligh02a03a92013-08-21 16:02:41 +0100329}
330
331
Alex Bligh4e0c6522013-08-21 16:02:43 +0100332/* qemu implementation of g_poll which uses a nanosecond timeout but is
333 * otherwise identical to g_poll
334 */
335int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
336{
337#ifdef CONFIG_PPOLL
338 if (timeout < 0) {
339 return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
340 } else {
341 struct timespec ts;
Peter Maydell490309f2014-11-25 18:21:45 +0000342 int64_t tvsec = timeout / 1000000000LL;
343 /* Avoid possibly overflowing and specifying a negative number of
344 * seconds, which would turn a very long timeout into a busy-wait.
345 */
346 if (tvsec > (int64_t)INT32_MAX) {
347 tvsec = INT32_MAX;
348 }
349 ts.tv_sec = tvsec;
Alex Bligh4e0c6522013-08-21 16:02:43 +0100350 ts.tv_nsec = timeout % 1000000000LL;
351 return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
352 }
353#else
354 return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
355#endif
356}
357
358
Artem Pisarenko89a603a2018-10-17 14:24:19 +0600359void timer_init_full(QEMUTimer *ts,
360 QEMUTimerListGroup *timer_list_group, QEMUClockType type,
361 int scale, int attributes,
362 QEMUTimerCB *cb, void *opaque)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100363{
Artem Pisarenko89a603a2018-10-17 14:24:19 +0600364 if (!timer_list_group) {
365 timer_list_group = &main_loop_tlg;
366 }
367 ts->timer_list = timer_list_group->tl[type];
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100368 ts->cb = cb;
369 ts->opaque = opaque;
Paolo Bonzini4a998742011-03-11 16:33:58 +0100370 ts->scale = scale;
Artem Pisarenko89a603a2018-10-17 14:24:19 +0600371 ts->attributes = attributes;
Paolo Bonzini3db1ee72013-09-12 11:02:20 +0200372 ts->expire_time = -1;
Alex Blighff83c662013-08-21 16:02:46 +0100373}
374
Paolo Bonzinicd1bd532014-12-24 10:57:04 +0100375void timer_deinit(QEMUTimer *ts)
376{
377 assert(ts->expire_time == -1);
378 ts->timer_list = NULL;
379}
380
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200381static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100382{
383 QEMUTimer **pt, *t;
384
Paolo Bonzini3db1ee72013-09-12 11:02:20 +0200385 ts->expire_time = -1;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200386 pt = &timer_list->active_timers;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100387 for(;;) {
388 t = *pt;
389 if (!t)
390 break;
391 if (t == ts) {
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100392 qatomic_set(pt, t->next);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100393 break;
394 }
395 pt = &t->next;
396 }
397}
398
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200399static bool timer_mod_ns_locked(QEMUTimerList *timer_list,
400 QEMUTimer *ts, int64_t expire_time)
401{
402 QEMUTimer **pt, *t;
403
404 /* add the timer in the sorted list */
405 pt = &timer_list->active_timers;
406 for (;;) {
407 t = *pt;
408 if (!timer_expired_ns(t, expire_time)) {
409 break;
410 }
411 pt = &t->next;
412 }
413 ts->expire_time = MAX(expire_time, 0);
414 ts->next = *pt;
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100415 qatomic_set(pt, ts);
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200416
417 return pt == &timer_list->active_timers;
418}
419
420static void timerlist_rearm(QEMUTimerList *timer_list)
421{
422 /* Interrupt execution to force deadline recalculation. */
Claudio Fontana740b1752020-08-19 13:17:19 +0200423 if (icount_enabled() && timer_list->clock->type == QEMU_CLOCK_VIRTUAL) {
Claudio Fontana8191d362020-08-31 16:18:34 +0200424 icount_start_warp_timer();
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300425 }
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200426 timerlist_notify(timer_list);
427}
428
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200429/* stop a timer, but do not dealloc it */
430void timer_del(QEMUTimer *ts)
431{
432 QEMUTimerList *timer_list = ts->timer_list;
433
Paolo Bonzinicd1bd532014-12-24 10:57:04 +0100434 if (timer_list) {
435 qemu_mutex_lock(&timer_list->active_timers_lock);
436 timer_del_locked(timer_list, ts);
437 qemu_mutex_unlock(&timer_list->active_timers_lock);
438 }
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200439}
440
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100441/* modify the current timer so that it will be fired when current_time
442 >= expire_time. The corresponding callback will be called. */
Alex Bligh40daca52013-08-21 16:03:02 +0100443void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100444{
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200445 QEMUTimerList *timer_list = ts->timer_list;
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200446 bool rearm;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100447
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200448 qemu_mutex_lock(&timer_list->active_timers_lock);
449 timer_del_locked(timer_list, ts);
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200450 rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200451 qemu_mutex_unlock(&timer_list->active_timers_lock);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100452
Paolo Bonzini0f809e52013-10-03 15:06:39 +0200453 if (rearm) {
454 timerlist_rearm(timer_list);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100455 }
456}
457
Paolo Bonziniadd40e92013-10-03 15:11:43 +0200458/* modify the current timer so that it will be fired when current_time
459 >= expire_time or the current deadline, whichever comes earlier.
460 The corresponding callback will be called. */
461void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)
462{
463 QEMUTimerList *timer_list = ts->timer_list;
464 bool rearm;
465
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700466 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
467 if (ts->expire_time == -1 || ts->expire_time > expire_time) {
468 if (ts->expire_time != -1) {
469 timer_del_locked(timer_list, ts);
470 }
471 rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
472 } else {
473 rearm = false;
Paolo Bonziniadd40e92013-10-03 15:11:43 +0200474 }
Paolo Bonziniadd40e92013-10-03 15:11:43 +0200475 }
Paolo Bonziniadd40e92013-10-03 15:11:43 +0200476 if (rearm) {
477 timerlist_rearm(timer_list);
478 }
479}
480
Alex Bligh40daca52013-08-21 16:03:02 +0100481void timer_mod(QEMUTimer *ts, int64_t expire_time)
Paolo Bonzini4a998742011-03-11 16:33:58 +0100482{
Alex Bligh40daca52013-08-21 16:03:02 +0100483 timer_mod_ns(ts, expire_time * ts->scale);
Paolo Bonzini4a998742011-03-11 16:33:58 +0100484}
485
Paolo Bonziniadd40e92013-10-03 15:11:43 +0200486void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time)
487{
488 timer_mod_anticipate_ns(ts, expire_time * ts->scale);
489}
490
Alex Blighe93379b2013-08-21 16:02:39 +0100491bool timer_pending(QEMUTimer *ts)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100492{
Paolo Bonzini3db1ee72013-09-12 11:02:20 +0200493 return ts->expire_time >= 0;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100494}
495
Alex Blighe93379b2013-08-21 16:02:39 +0100496bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100497{
Alex Blighe93379b2013-08-21 16:02:39 +0100498 return timer_expired_ns(timer_head, current_time * timer_head->scale);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100499}
500
Alex Blighff83c662013-08-21 16:02:46 +0100501bool timerlist_run_timers(QEMUTimerList *timer_list)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100502{
Paolo Bonzini144b97c2012-09-19 15:52:44 +0200503 QEMUTimer *ts;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100504 int64_t current_time;
Alex Blighf9a976b2013-08-21 16:02:45 +0100505 bool progress = false;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200506 QEMUTimerCB *cb;
507 void *opaque;
508
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100509 if (!qatomic_read(&timer_list->active_timers)) {
Paolo Bonzini8caa05d2016-12-01 09:58:02 +0100510 return false;
511 }
512
Liu Ping Fan3c053412013-09-25 14:21:00 +0800513 qemu_event_reset(&timer_list->timers_done_ev);
Paolo Bonzini8caa05d2016-12-01 09:58:02 +0100514 if (!timer_list->clock->enabled) {
Liu Ping Fan3c053412013-09-25 14:21:00 +0800515 goto out;
Alex Blighff83c662013-08-21 16:02:46 +0100516 }
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100517
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300518 switch (timer_list->clock->type) {
519 case QEMU_CLOCK_REALTIME:
520 break;
521 default:
522 case QEMU_CLOCK_VIRTUAL:
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300523 break;
524 case QEMU_CLOCK_HOST:
525 if (!replay_checkpoint(CHECKPOINT_CLOCK_HOST)) {
526 goto out;
527 }
528 break;
529 case QEMU_CLOCK_VIRTUAL_RT:
530 if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL_RT)) {
531 goto out;
532 }
533 break;
534 }
535
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600536 /*
Philippe Mathieu-Daudé3cf10b22020-08-11 17:16:42 +0200537 * Extract expired timers from active timers list and process them.
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600538 *
539 * In rr mode we need "filtered" checkpointing for virtual clock. The
540 * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer,
541 * and that must only be done once since the clock value stays the same. Because
542 * non-EXTERNAL timers may appear in the timers list while it being processed,
543 * the checkpoint can be issued at a time until no timers are left and we are
544 * done".
545 */
Alex Bligh40daca52013-08-21 16:03:02 +0100546 current_time = qemu_clock_get_ns(timer_list->clock->type);
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600547 qemu_mutex_lock(&timer_list->active_timers_lock);
548 while ((ts = timer_list->active_timers)) {
Alex Blighe93379b2013-08-21 16:02:39 +0100549 if (!timer_expired_ns(ts, current_time)) {
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600550 /* No expired timers left. The checkpoint can be skipped
551 * if no timers fired or they were all external.
552 */
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100553 break;
Stefan Weil45c7b372011-03-24 21:31:24 +0100554 }
Pavel Dovgalyuk677a3ba2020-05-22 09:35:27 +0300555 /* Checkpoint for virtual clock is redundant in cases where
556 * it's being triggered with only non-EXTERNAL timers, because
557 * these timers don't change guest state directly.
558 */
559 if (replay_mode != REPLAY_MODE_NONE
560 && timer_list->clock->type == QEMU_CLOCK_VIRTUAL
561 && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)
562 && !replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL)) {
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600563 qemu_mutex_unlock(&timer_list->active_timers_lock);
Pavel Dovgalyuk677a3ba2020-05-22 09:35:27 +0300564 goto out;
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600565 }
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200566
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100567 /* remove timer from the list before calling the callback */
Alex Blighff83c662013-08-21 16:02:46 +0100568 timer_list->active_timers = ts->next;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100569 ts->next = NULL;
Paolo Bonzini3db1ee72013-09-12 11:02:20 +0200570 ts->expire_time = -1;
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200571 cb = ts->cb;
572 opaque = ts->opaque;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100573
574 /* run the callback (the timer list can be modified) */
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600575 qemu_mutex_unlock(&timer_list->active_timers_lock);
Stefan Hajnoczi978f2202013-09-12 11:02:19 +0200576 cb(opaque);
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600577 qemu_mutex_lock(&timer_list->active_timers_lock);
578
Alex Blighf9a976b2013-08-21 16:02:45 +0100579 progress = true;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100580 }
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600581 qemu_mutex_unlock(&timer_list->active_timers_lock);
Liu Ping Fan3c053412013-09-25 14:21:00 +0800582
583out:
584 qemu_event_set(&timer_list->timers_done_ev);
Alex Blighf9a976b2013-08-21 16:02:45 +0100585 return progress;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100586}
587
Alex Bligh40daca52013-08-21 16:03:02 +0100588bool qemu_clock_run_timers(QEMUClockType type)
589{
Alex Bligh7bf8fbd2013-08-21 16:03:03 +0100590 return timerlist_run_timers(main_loop_tlg.tl[type]);
Alex Bligh40daca52013-08-21 16:03:02 +0100591}
592
Alex Blighd5541d82013-08-21 16:02:50 +0100593void timerlistgroup_init(QEMUTimerListGroup *tlg,
594 QEMUTimerListNotifyCB *cb, void *opaque)
Alex Bligh754d6a52013-08-21 16:02:48 +0100595{
596 QEMUClockType type;
597 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
Alex Blighd5541d82013-08-21 16:02:50 +0100598 tlg->tl[type] = timerlist_new(type, cb, opaque);
Alex Bligh754d6a52013-08-21 16:02:48 +0100599 }
600}
601
602void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
603{
604 QEMUClockType type;
605 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
606 timerlist_free(tlg->tl[type]);
607 }
608}
609
610bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
611{
612 QEMUClockType type;
613 bool progress = false;
614 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
615 progress |= timerlist_run_timers(tlg->tl[type]);
616 }
617 return progress;
618}
619
620int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
621{
622 int64_t deadline = -1;
623 QEMUClockType type;
624 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300625 if (qemu_clock_use_for_deadline(type)) {
Pavel Dovgalyuke4dab942018-07-25 15:15:26 +0300626 deadline = qemu_soonest_timeout(deadline,
627 timerlist_deadline_ns(tlg->tl[type]));
Alex Bligh754d6a52013-08-21 16:02:48 +0100628 }
629 }
630 return deadline;
631}
632
Alex Bligh40daca52013-08-21 16:03:02 +0100633int64_t qemu_clock_get_ns(QEMUClockType type)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100634{
Alex Bligh40daca52013-08-21 16:03:02 +0100635 switch (type) {
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100636 case QEMU_CLOCK_REALTIME:
637 return get_clock();
638 default:
639 case QEMU_CLOCK_VIRTUAL:
Claudio Fontana430065d2020-07-31 12:23:42 +0200640 return cpus_get_virtual_clock();
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100641 case QEMU_CLOCK_HOST:
Dr. David Alan Gilbert3c2d4c82019-07-24 12:58:23 +0100642 return REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime());
Pavel Dovgalyuk4e7fa732014-11-26 13:40:50 +0300643 case QEMU_CLOCK_VIRTUAL_RT:
Pavel Dovgalyuk8eda2062015-09-17 19:24:28 +0300644 return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock());
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100645 }
646}
647
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100648void init_clocks(QEMUTimerListNotifyCB *notify_cb)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100649{
Alex Blighff83c662013-08-21 16:02:46 +0100650 QEMUClockType type;
651 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100652 qemu_clock_init(type, notify_cb);
Paolo Bonzini744ca8e2012-10-29 15:26:28 +0100653 }
Alex Blighff83c662013-08-21 16:02:46 +0100654
Alex Blighcd758dd2013-08-21 16:02:44 +0100655#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
656 prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
657#endif
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100658}
659
Alex Blighe93379b2013-08-21 16:02:39 +0100660uint64_t timer_expire_time_ns(QEMUTimer *ts)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100661{
Alex Blighe93379b2013-08-21 16:02:39 +0100662 return timer_pending(ts) ? ts->expire_time : -1;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100663}
664
Alex Bligh40daca52013-08-21 16:03:02 +0100665bool qemu_clock_run_all_timers(void)
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100666{
Alex Blighf9a976b2013-08-21 16:02:45 +0100667 bool progress = false;
Alex Blighff83c662013-08-21 16:02:46 +0100668 QEMUClockType type;
Alex Bligh6d327172013-08-21 16:02:59 +0100669
Alex Blighff83c662013-08-21 16:02:46 +0100670 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
Paolo Bonzini6b8f0182017-03-02 19:56:40 +0100671 if (qemu_clock_use_for_deadline(type)) {
672 progress |= qemu_clock_run_timers(type);
673 }
Alex Blighff83c662013-08-21 16:02:46 +0100674 }
Peter Portante158fd3c2012-04-05 11:00:45 -0400675
Alex Blighf9a976b2013-08-21 16:02:45 +0100676 return progress;
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100677}