]>
Commit | Line | Data |
---|---|---|
db1a4972 PB |
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 | ||
d38ea87a | 25 | #include "qemu/osdep.h" |
1ac0206b | 26 | #include "qemu/main-loop.h" |
1de7afc9 | 27 | #include "qemu/timer.h" |
8eda206e | 28 | #include "sysemu/replay.h" |
d2528bdc | 29 | #include "sysemu/cpus.h" |
1ac0206b | 30 | |
30ea8339 AL |
31 | #ifdef CONFIG_POSIX |
32 | #include <pthread.h> | |
33 | #endif | |
bff9f8bf | 34 | |
4e0c6529 AB |
35 | #ifdef CONFIG_PPOLL |
36 | #include <poll.h> | |
37 | #endif | |
38 | ||
cd758dd0 AB |
39 | #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK |
40 | #include <sys/prctl.h> | |
41 | #endif | |
42 | ||
db1a4972 PB |
43 | /***********************************************************/ |
44 | /* timers */ | |
45 | ||
b4049b74 | 46 | typedef struct QEMUClock { |
3c053411 | 47 | /* We rely on BQL to protect the timerlists */ |
ff83c66e | 48 | QLIST_HEAD(, QEMUTimerList) timerlists; |
691a0c9c | 49 | |
691a0c9c | 50 | int64_t last; |
9a14b298 | 51 | |
ff83c66e | 52 | QEMUClockType type; |
9a14b298 | 53 | bool enabled; |
b4049b74 | 54 | } QEMUClock; |
db1a4972 | 55 | |
754d6a54 | 56 | QEMUTimerListGroup main_loop_tlg; |
fbdb664c | 57 | static QEMUClock qemu_clocks[QEMU_CLOCK_MAX]; |
ff83c66e AB |
58 | |
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 | ||
66 | struct QEMUTimerList { | |
9a14b298 | 67 | QEMUClock *clock; |
978f2205 | 68 | QemuMutex active_timers_lock; |
ff83c66e AB |
69 | QEMUTimer *active_timers; |
70 | QLIST_ENTRY(QEMUTimerList) list; | |
d5541d86 AB |
71 | QEMUTimerListNotifyCB *notify_cb; |
72 | void *notify_opaque; | |
3c053411 LPF |
73 | |
74 | /* lightweight method to mark the end of timerlist's running */ | |
75 | QemuEvent timers_done_ev; | |
db1a4972 PB |
76 | }; |
77 | ||
7bf8fbde AB |
78 | /** |
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 | */ | |
b4049b74 | 86 | static inline QEMUClock *qemu_clock_ptr(QEMUClockType type) |
7bf8fbde AB |
87 | { |
88 | return &qemu_clocks[type]; | |
89 | } | |
90 | ||
e93379b0 | 91 | static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time) |
45c7b37f SW |
92 | { |
93 | return timer_head && (timer_head->expire_time <= current_time); | |
94 | } | |
95 | ||
7bf8fbde AB |
96 | QEMUTimerList *timerlist_new(QEMUClockType type, |
97 | QEMUTimerListNotifyCB *cb, | |
98 | void *opaque) | |
ff83c66e AB |
99 | { |
100 | QEMUTimerList *timer_list; | |
7bf8fbde | 101 | QEMUClock *clock = qemu_clock_ptr(type); |
ff83c66e AB |
102 | |
103 | timer_list = g_malloc0(sizeof(QEMUTimerList)); | |
e4efd8a4 | 104 | qemu_event_init(&timer_list->timers_done_ev, true); |
ff83c66e | 105 | timer_list->clock = clock; |
d5541d86 AB |
106 | timer_list->notify_cb = cb; |
107 | timer_list->notify_opaque = opaque; | |
978f2205 | 108 | qemu_mutex_init(&timer_list->active_timers_lock); |
ff83c66e AB |
109 | QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list); |
110 | return timer_list; | |
111 | } | |
112 | ||
ff83c66e AB |
113 | void timerlist_free(QEMUTimerList *timer_list) |
114 | { | |
115 | assert(!timerlist_has_timers(timer_list)); | |
116 | if (timer_list->clock) { | |
117 | QLIST_REMOVE(timer_list, list); | |
ff83c66e | 118 | } |
978f2205 | 119 | qemu_mutex_destroy(&timer_list->active_timers_lock); |
ff83c66e AB |
120 | g_free(timer_list); |
121 | } | |
122 | ||
3f53bc61 | 123 | static void qemu_clock_init(QEMUClockType type, QEMUTimerListNotifyCB *notify_cb) |
db1a4972 | 124 | { |
7bf8fbde | 125 | QEMUClock *clock = qemu_clock_ptr(type); |
691a0c9c | 126 | |
02ce232c KB |
127 | /* Assert that the clock of type TYPE has not been initialized yet. */ |
128 | assert(main_loop_tlg.tl[type] == NULL); | |
129 | ||
db1a4972 | 130 | clock->type = type; |
3fdd0ee3 | 131 | clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true); |
2ff68d07 | 132 | clock->last = INT64_MIN; |
ff83c66e | 133 | QLIST_INIT(&clock->timerlists); |
3f53bc61 | 134 | main_loop_tlg.tl[type] = timerlist_new(type, notify_cb, NULL); |
db1a4972 PB |
135 | } |
136 | ||
40daca54 | 137 | bool qemu_clock_use_for_deadline(QEMUClockType type) |
ff83c66e | 138 | { |
40daca54 | 139 | return !(use_icount && (type == QEMU_CLOCK_VIRTUAL)); |
ff83c66e AB |
140 | } |
141 | ||
40daca54 | 142 | void qemu_clock_notify(QEMUClockType type) |
b1bbfe72 AB |
143 | { |
144 | QEMUTimerList *timer_list; | |
40daca54 | 145 | QEMUClock *clock = qemu_clock_ptr(type); |
b1bbfe72 AB |
146 | QLIST_FOREACH(timer_list, &clock->timerlists, list) { |
147 | timerlist_notify(timer_list); | |
148 | } | |
149 | } | |
150 | ||
3c053411 LPF |
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 | */ | |
40daca54 | 158 | void qemu_clock_enable(QEMUClockType type, bool enabled) |
db1a4972 | 159 | { |
40daca54 | 160 | QEMUClock *clock = qemu_clock_ptr(type); |
3c053411 | 161 | QEMUTimerList *tl; |
fbdc14eb | 162 | bool old = clock->enabled; |
db1a4972 | 163 | clock->enabled = enabled; |
fbdc14eb | 164 | if (enabled && !old) { |
40daca54 | 165 | qemu_clock_notify(type); |
3c053411 LPF |
166 | } else if (!enabled && old) { |
167 | QLIST_FOREACH(tl, &clock->timerlists, list) { | |
168 | qemu_event_wait(&tl->timers_done_ev); | |
169 | } | |
fbdc14eb | 170 | } |
db1a4972 PB |
171 | } |
172 | ||
ff83c66e | 173 | bool timerlist_has_timers(QEMUTimerList *timer_list) |
dc2dfcf0 | 174 | { |
8caa05d8 | 175 | return !!atomic_read(&timer_list->active_timers); |
dc2dfcf0 PB |
176 | } |
177 | ||
40daca54 | 178 | bool qemu_clock_has_timers(QEMUClockType type) |
dc2dfcf0 | 179 | { |
40daca54 | 180 | return timerlist_has_timers( |
7bf8fbde | 181 | main_loop_tlg.tl[type]); |
dc2dfcf0 PB |
182 | } |
183 | ||
ff83c66e AB |
184 | bool timerlist_expired(QEMUTimerList *timer_list) |
185 | { | |
978f2205 SH |
186 | int64_t expire_time; |
187 | ||
8caa05d8 PB |
188 | if (!atomic_read(&timer_list->active_timers)) { |
189 | return false; | |
190 | } | |
191 | ||
978f2205 SH |
192 | qemu_mutex_lock(&timer_list->active_timers_lock); |
193 | if (!timer_list->active_timers) { | |
194 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
195 | return false; | |
196 | } | |
197 | expire_time = timer_list->active_timers->expire_time; | |
198 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
199 | ||
33bef0b9 | 200 | return expire_time <= qemu_clock_get_ns(timer_list->clock->type); |
ff83c66e AB |
201 | } |
202 | ||
40daca54 | 203 | bool qemu_clock_expired(QEMUClockType type) |
ff83c66e | 204 | { |
40daca54 | 205 | return timerlist_expired( |
7bf8fbde | 206 | main_loop_tlg.tl[type]); |
ff83c66e AB |
207 | } |
208 | ||
02a03a9f AB |
209 | /* |
210 | * As above, but return -1 for no deadline, and do not cap to 2^32 | |
211 | * as we know the result is always positive. | |
212 | */ | |
213 | ||
ff83c66e | 214 | int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) |
02a03a9f AB |
215 | { |
216 | int64_t delta; | |
978f2205 | 217 | int64_t expire_time; |
02a03a9f | 218 | |
8caa05d8 PB |
219 | if (!atomic_read(&timer_list->active_timers)) { |
220 | return -1; | |
221 | } | |
222 | ||
978f2205 | 223 | if (!timer_list->clock->enabled) { |
02a03a9f AB |
224 | return -1; |
225 | } | |
226 | ||
978f2205 SH |
227 | /* The active timers list may be modified before the caller uses our return |
228 | * value but ->notify_cb() is called when the deadline changes. Therefore | |
229 | * the caller should notice the change and there is no race condition. | |
230 | */ | |
231 | qemu_mutex_lock(&timer_list->active_timers_lock); | |
232 | if (!timer_list->active_timers) { | |
233 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
234 | return -1; | |
235 | } | |
236 | expire_time = timer_list->active_timers->expire_time; | |
237 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
238 | ||
239 | delta = expire_time - qemu_clock_get_ns(timer_list->clock->type); | |
02a03a9f AB |
240 | |
241 | if (delta <= 0) { | |
242 | return 0; | |
243 | } | |
244 | ||
245 | return delta; | |
246 | } | |
247 | ||
ac70aafc AB |
248 | /* Calculate the soonest deadline across all timerlists attached |
249 | * to the clock. This is used for the icount timeout so we | |
250 | * ignore whether or not the clock should be used in deadline | |
251 | * calculations. | |
252 | */ | |
40daca54 | 253 | int64_t qemu_clock_deadline_ns_all(QEMUClockType type) |
ac70aafc AB |
254 | { |
255 | int64_t deadline = -1; | |
256 | QEMUTimerList *timer_list; | |
40daca54 | 257 | QEMUClock *clock = qemu_clock_ptr(type); |
ac70aafc AB |
258 | QLIST_FOREACH(timer_list, &clock->timerlists, list) { |
259 | deadline = qemu_soonest_timeout(deadline, | |
260 | timerlist_deadline_ns(timer_list)); | |
261 | } | |
262 | return deadline; | |
263 | } | |
264 | ||
40daca54 | 265 | QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list) |
ff83c66e | 266 | { |
40daca54 | 267 | return timer_list->clock->type; |
ff83c66e AB |
268 | } |
269 | ||
40daca54 | 270 | QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type) |
ff83c66e | 271 | { |
7bf8fbde | 272 | return main_loop_tlg.tl[type]; |
ff83c66e AB |
273 | } |
274 | ||
d5541d86 AB |
275 | void timerlist_notify(QEMUTimerList *timer_list) |
276 | { | |
277 | if (timer_list->notify_cb) { | |
3f53bc61 | 278 | timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type); |
d5541d86 AB |
279 | } else { |
280 | qemu_notify_event(); | |
281 | } | |
282 | } | |
283 | ||
02a03a9f AB |
284 | /* Transition function to convert a nanosecond timeout to ms |
285 | * This is used where a system does not support ppoll | |
286 | */ | |
287 | int qemu_timeout_ns_to_ms(int64_t ns) | |
288 | { | |
289 | int64_t ms; | |
290 | if (ns < 0) { | |
291 | return -1; | |
292 | } | |
293 | ||
294 | if (!ns) { | |
295 | return 0; | |
296 | } | |
297 | ||
298 | /* Always round up, because it's better to wait too long than to wait too | |
299 | * little and effectively busy-wait | |
300 | */ | |
5029b969 | 301 | ms = DIV_ROUND_UP(ns, SCALE_MS); |
02a03a9f AB |
302 | |
303 | /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */ | |
304 | if (ms > (int64_t) INT32_MAX) { | |
305 | ms = INT32_MAX; | |
306 | } | |
307 | ||
308 | return (int) ms; | |
309 | } | |
310 | ||
311 | ||
4e0c6529 AB |
312 | /* qemu implementation of g_poll which uses a nanosecond timeout but is |
313 | * otherwise identical to g_poll | |
314 | */ | |
315 | int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout) | |
316 | { | |
317 | #ifdef CONFIG_PPOLL | |
318 | if (timeout < 0) { | |
319 | return ppoll((struct pollfd *)fds, nfds, NULL, NULL); | |
320 | } else { | |
321 | struct timespec ts; | |
490309fc PM |
322 | int64_t tvsec = timeout / 1000000000LL; |
323 | /* Avoid possibly overflowing and specifying a negative number of | |
324 | * seconds, which would turn a very long timeout into a busy-wait. | |
325 | */ | |
326 | if (tvsec > (int64_t)INT32_MAX) { | |
327 | tvsec = INT32_MAX; | |
328 | } | |
329 | ts.tv_sec = tvsec; | |
4e0c6529 AB |
330 | ts.tv_nsec = timeout % 1000000000LL; |
331 | return ppoll((struct pollfd *)fds, nfds, &ts, NULL); | |
332 | } | |
333 | #else | |
334 | return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout)); | |
335 | #endif | |
336 | } | |
337 | ||
338 | ||
89a603a0 AP |
339 | void timer_init_full(QEMUTimer *ts, |
340 | QEMUTimerListGroup *timer_list_group, QEMUClockType type, | |
341 | int scale, int attributes, | |
342 | QEMUTimerCB *cb, void *opaque) | |
db1a4972 | 343 | { |
89a603a0 AP |
344 | if (!timer_list_group) { |
345 | timer_list_group = &main_loop_tlg; | |
346 | } | |
347 | ts->timer_list = timer_list_group->tl[type]; | |
db1a4972 PB |
348 | ts->cb = cb; |
349 | ts->opaque = opaque; | |
4a998740 | 350 | ts->scale = scale; |
89a603a0 | 351 | ts->attributes = attributes; |
3db1ee7c | 352 | ts->expire_time = -1; |
ff83c66e AB |
353 | } |
354 | ||
cd1bd53a PB |
355 | void timer_deinit(QEMUTimer *ts) |
356 | { | |
357 | assert(ts->expire_time == -1); | |
358 | ts->timer_list = NULL; | |
359 | } | |
360 | ||
978f2205 | 361 | static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts) |
db1a4972 PB |
362 | { |
363 | QEMUTimer **pt, *t; | |
364 | ||
3db1ee7c | 365 | ts->expire_time = -1; |
978f2205 | 366 | pt = &timer_list->active_timers; |
db1a4972 PB |
367 | for(;;) { |
368 | t = *pt; | |
369 | if (!t) | |
370 | break; | |
371 | if (t == ts) { | |
8caa05d8 | 372 | atomic_set(pt, t->next); |
db1a4972 PB |
373 | break; |
374 | } | |
375 | pt = &t->next; | |
376 | } | |
377 | } | |
378 | ||
0f809e5f PB |
379 | static bool timer_mod_ns_locked(QEMUTimerList *timer_list, |
380 | QEMUTimer *ts, int64_t expire_time) | |
381 | { | |
382 | QEMUTimer **pt, *t; | |
383 | ||
384 | /* add the timer in the sorted list */ | |
385 | pt = &timer_list->active_timers; | |
386 | for (;;) { | |
387 | t = *pt; | |
388 | if (!timer_expired_ns(t, expire_time)) { | |
389 | break; | |
390 | } | |
391 | pt = &t->next; | |
392 | } | |
393 | ts->expire_time = MAX(expire_time, 0); | |
394 | ts->next = *pt; | |
8caa05d8 | 395 | atomic_set(pt, ts); |
0f809e5f PB |
396 | |
397 | return pt == &timer_list->active_timers; | |
398 | } | |
399 | ||
400 | static void timerlist_rearm(QEMUTimerList *timer_list) | |
401 | { | |
402 | /* Interrupt execution to force deadline recalculation. */ | |
e76d1798 PD |
403 | if (timer_list->clock->type == QEMU_CLOCK_VIRTUAL) { |
404 | qemu_start_warp_timer(); | |
405 | } | |
0f809e5f PB |
406 | timerlist_notify(timer_list); |
407 | } | |
408 | ||
978f2205 SH |
409 | /* stop a timer, but do not dealloc it */ |
410 | void timer_del(QEMUTimer *ts) | |
411 | { | |
412 | QEMUTimerList *timer_list = ts->timer_list; | |
413 | ||
cd1bd53a PB |
414 | if (timer_list) { |
415 | qemu_mutex_lock(&timer_list->active_timers_lock); | |
416 | timer_del_locked(timer_list, ts); | |
417 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
418 | } | |
978f2205 SH |
419 | } |
420 | ||
db1a4972 PB |
421 | /* modify the current timer so that it will be fired when current_time |
422 | >= expire_time. The corresponding callback will be called. */ | |
40daca54 | 423 | void timer_mod_ns(QEMUTimer *ts, int64_t expire_time) |
db1a4972 | 424 | { |
978f2205 | 425 | QEMUTimerList *timer_list = ts->timer_list; |
0f809e5f | 426 | bool rearm; |
db1a4972 | 427 | |
978f2205 SH |
428 | qemu_mutex_lock(&timer_list->active_timers_lock); |
429 | timer_del_locked(timer_list, ts); | |
0f809e5f | 430 | rearm = timer_mod_ns_locked(timer_list, ts, expire_time); |
978f2205 | 431 | qemu_mutex_unlock(&timer_list->active_timers_lock); |
db1a4972 | 432 | |
0f809e5f PB |
433 | if (rearm) { |
434 | timerlist_rearm(timer_list); | |
db1a4972 PB |
435 | } |
436 | } | |
437 | ||
add40e97 PB |
438 | /* modify the current timer so that it will be fired when current_time |
439 | >= expire_time or the current deadline, whichever comes earlier. | |
440 | The corresponding callback will be called. */ | |
441 | void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time) | |
442 | { | |
443 | QEMUTimerList *timer_list = ts->timer_list; | |
444 | bool rearm; | |
445 | ||
446 | qemu_mutex_lock(&timer_list->active_timers_lock); | |
447 | if (ts->expire_time == -1 || ts->expire_time > expire_time) { | |
448 | if (ts->expire_time != -1) { | |
449 | timer_del_locked(timer_list, ts); | |
450 | } | |
451 | rearm = timer_mod_ns_locked(timer_list, ts, expire_time); | |
452 | } else { | |
453 | rearm = false; | |
454 | } | |
455 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
456 | ||
457 | if (rearm) { | |
458 | timerlist_rearm(timer_list); | |
459 | } | |
460 | } | |
461 | ||
40daca54 | 462 | void timer_mod(QEMUTimer *ts, int64_t expire_time) |
4a998740 | 463 | { |
40daca54 | 464 | timer_mod_ns(ts, expire_time * ts->scale); |
4a998740 PB |
465 | } |
466 | ||
add40e97 PB |
467 | void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time) |
468 | { | |
469 | timer_mod_anticipate_ns(ts, expire_time * ts->scale); | |
470 | } | |
471 | ||
e93379b0 | 472 | bool timer_pending(QEMUTimer *ts) |
db1a4972 | 473 | { |
3db1ee7c | 474 | return ts->expire_time >= 0; |
db1a4972 PB |
475 | } |
476 | ||
e93379b0 | 477 | bool timer_expired(QEMUTimer *timer_head, int64_t current_time) |
db1a4972 | 478 | { |
e93379b0 | 479 | return timer_expired_ns(timer_head, current_time * timer_head->scale); |
db1a4972 PB |
480 | } |
481 | ||
ff83c66e | 482 | bool timerlist_run_timers(QEMUTimerList *timer_list) |
db1a4972 | 483 | { |
144b97c2 | 484 | QEMUTimer *ts; |
db1a4972 | 485 | int64_t current_time; |
f9a976b7 | 486 | bool progress = false; |
978f2205 SH |
487 | QEMUTimerCB *cb; |
488 | void *opaque; | |
e81f8679 | 489 | bool need_replay_checkpoint = false; |
978f2205 | 490 | |
8caa05d8 PB |
491 | if (!atomic_read(&timer_list->active_timers)) { |
492 | return false; | |
493 | } | |
494 | ||
3c053411 | 495 | qemu_event_reset(&timer_list->timers_done_ev); |
8caa05d8 | 496 | if (!timer_list->clock->enabled) { |
3c053411 | 497 | goto out; |
ff83c66e | 498 | } |
db1a4972 | 499 | |
8bd7f71d PD |
500 | switch (timer_list->clock->type) { |
501 | case QEMU_CLOCK_REALTIME: | |
502 | break; | |
503 | default: | |
504 | case QEMU_CLOCK_VIRTUAL: | |
e81f8679 AP |
505 | if (replay_mode != REPLAY_MODE_NONE) { |
506 | /* Checkpoint for virtual clock is redundant in cases where | |
507 | * it's being triggered with only non-EXTERNAL timers, because | |
508 | * these timers don't change guest state directly. | |
509 | * Since it has conditional dependence on specific timers, it is | |
510 | * subject to race conditions and requires special handling. | |
511 | * See below. | |
512 | */ | |
513 | need_replay_checkpoint = true; | |
8bd7f71d PD |
514 | } |
515 | break; | |
516 | case QEMU_CLOCK_HOST: | |
517 | if (!replay_checkpoint(CHECKPOINT_CLOCK_HOST)) { | |
518 | goto out; | |
519 | } | |
520 | break; | |
521 | case QEMU_CLOCK_VIRTUAL_RT: | |
522 | if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL_RT)) { | |
523 | goto out; | |
524 | } | |
525 | break; | |
526 | } | |
527 | ||
e81f8679 AP |
528 | /* |
529 | * Extract expired timers from active timers list and and process them. | |
530 | * | |
531 | * In rr mode we need "filtered" checkpointing for virtual clock. The | |
532 | * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer, | |
533 | * and that must only be done once since the clock value stays the same. Because | |
534 | * non-EXTERNAL timers may appear in the timers list while it being processed, | |
535 | * the checkpoint can be issued at a time until no timers are left and we are | |
536 | * done". | |
537 | */ | |
40daca54 | 538 | current_time = qemu_clock_get_ns(timer_list->clock->type); |
e81f8679 AP |
539 | qemu_mutex_lock(&timer_list->active_timers_lock); |
540 | while ((ts = timer_list->active_timers)) { | |
e93379b0 | 541 | if (!timer_expired_ns(ts, current_time)) { |
e81f8679 AP |
542 | /* No expired timers left. The checkpoint can be skipped |
543 | * if no timers fired or they were all external. | |
544 | */ | |
db1a4972 | 545 | break; |
45c7b37f | 546 | } |
e81f8679 AP |
547 | if (need_replay_checkpoint |
548 | && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)) { | |
549 | /* once we got here, checkpoint clock only once */ | |
550 | need_replay_checkpoint = false; | |
551 | qemu_mutex_unlock(&timer_list->active_timers_lock); | |
552 | if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL)) { | |
553 | goto out; | |
554 | } | |
555 | qemu_mutex_lock(&timer_list->active_timers_lock); | |
556 | /* The lock was released; start over again in case the list was | |
557 | * modified. | |
558 | */ | |
559 | continue; | |
560 | } | |
978f2205 | 561 | |
db1a4972 | 562 | /* remove timer from the list before calling the callback */ |
ff83c66e | 563 | timer_list->active_timers = ts->next; |
db1a4972 | 564 | ts->next = NULL; |
3db1ee7c | 565 | ts->expire_time = -1; |
978f2205 SH |
566 | cb = ts->cb; |
567 | opaque = ts->opaque; | |
db1a4972 PB |
568 | |
569 | /* run the callback (the timer list can be modified) */ | |
e81f8679 | 570 | qemu_mutex_unlock(&timer_list->active_timers_lock); |
978f2205 | 571 | cb(opaque); |
e81f8679 AP |
572 | qemu_mutex_lock(&timer_list->active_timers_lock); |
573 | ||
f9a976b7 | 574 | progress = true; |
db1a4972 | 575 | } |
e81f8679 | 576 | qemu_mutex_unlock(&timer_list->active_timers_lock); |
3c053411 LPF |
577 | |
578 | out: | |
579 | qemu_event_set(&timer_list->timers_done_ev); | |
f9a976b7 | 580 | return progress; |
db1a4972 PB |
581 | } |
582 | ||
40daca54 AB |
583 | bool qemu_clock_run_timers(QEMUClockType type) |
584 | { | |
7bf8fbde | 585 | return timerlist_run_timers(main_loop_tlg.tl[type]); |
40daca54 AB |
586 | } |
587 | ||
d5541d86 AB |
588 | void timerlistgroup_init(QEMUTimerListGroup *tlg, |
589 | QEMUTimerListNotifyCB *cb, void *opaque) | |
754d6a54 AB |
590 | { |
591 | QEMUClockType type; | |
592 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { | |
d5541d86 | 593 | tlg->tl[type] = timerlist_new(type, cb, opaque); |
754d6a54 AB |
594 | } |
595 | } | |
596 | ||
597 | void timerlistgroup_deinit(QEMUTimerListGroup *tlg) | |
598 | { | |
599 | QEMUClockType type; | |
600 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { | |
601 | timerlist_free(tlg->tl[type]); | |
602 | } | |
603 | } | |
604 | ||
605 | bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg) | |
606 | { | |
607 | QEMUClockType type; | |
608 | bool progress = false; | |
609 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { | |
610 | progress |= timerlist_run_timers(tlg->tl[type]); | |
611 | } | |
612 | return progress; | |
613 | } | |
614 | ||
615 | int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg) | |
616 | { | |
617 | int64_t deadline = -1; | |
618 | QEMUClockType type; | |
619 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { | |
8bd7f71d | 620 | if (qemu_clock_use_for_deadline(type)) { |
e4dab944 PD |
621 | deadline = qemu_soonest_timeout(deadline, |
622 | timerlist_deadline_ns(tlg->tl[type])); | |
754d6a54 AB |
623 | } |
624 | } | |
625 | return deadline; | |
626 | } | |
627 | ||
40daca54 | 628 | int64_t qemu_clock_get_ns(QEMUClockType type) |
db1a4972 | 629 | { |
4ea9a0e3 | 630 | int64_t now; |
40daca54 | 631 | QEMUClock *clock = qemu_clock_ptr(type); |
691a0c9c | 632 | |
40daca54 | 633 | switch (type) { |
db1a4972 PB |
634 | case QEMU_CLOCK_REALTIME: |
635 | return get_clock(); | |
636 | default: | |
637 | case QEMU_CLOCK_VIRTUAL: | |
638 | if (use_icount) { | |
639 | return cpu_get_icount(); | |
640 | } else { | |
641 | return cpu_get_clock(); | |
642 | } | |
643 | case QEMU_CLOCK_HOST: | |
8eda206e | 644 | now = REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime()); |
691a0c9c | 645 | clock->last = now; |
691a0c9c | 646 | return now; |
4e7fa73e | 647 | case QEMU_CLOCK_VIRTUAL_RT: |
8eda206e | 648 | return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock()); |
db1a4972 PB |
649 | } |
650 | } | |
651 | ||
4b930d26 PD |
652 | uint64_t qemu_clock_get_last(QEMUClockType type) |
653 | { | |
654 | QEMUClock *clock = qemu_clock_ptr(type); | |
655 | return clock->last; | |
656 | } | |
657 | ||
658 | void qemu_clock_set_last(QEMUClockType type, uint64_t last) | |
659 | { | |
660 | QEMUClock *clock = qemu_clock_ptr(type); | |
661 | clock->last = last; | |
662 | } | |
663 | ||
3f53bc61 | 664 | void init_clocks(QEMUTimerListNotifyCB *notify_cb) |
db1a4972 | 665 | { |
ff83c66e AB |
666 | QEMUClockType type; |
667 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { | |
3f53bc61 | 668 | qemu_clock_init(type, notify_cb); |
744ca8e3 | 669 | } |
ff83c66e | 670 | |
cd758dd0 AB |
671 | #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK |
672 | prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0); | |
673 | #endif | |
db1a4972 PB |
674 | } |
675 | ||
e93379b0 | 676 | uint64_t timer_expire_time_ns(QEMUTimer *ts) |
db1a4972 | 677 | { |
e93379b0 | 678 | return timer_pending(ts) ? ts->expire_time : -1; |
db1a4972 PB |
679 | } |
680 | ||
40daca54 | 681 | bool qemu_clock_run_all_timers(void) |
db1a4972 | 682 | { |
f9a976b7 | 683 | bool progress = false; |
ff83c66e | 684 | QEMUClockType type; |
6d327171 | 685 | |
ff83c66e | 686 | for (type = 0; type < QEMU_CLOCK_MAX; type++) { |
6b8f0187 PB |
687 | if (qemu_clock_use_for_deadline(type)) { |
688 | progress |= qemu_clock_run_timers(type); | |
689 | } | |
ff83c66e | 690 | } |
158fd3ce | 691 | |
f9a976b7 | 692 | return progress; |
db1a4972 | 693 | } |