]>
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 | ||
9c17d615 | 25 | #include "sysemu/sysemu.h" |
83c9089e | 26 | #include "monitor/monitor.h" |
28ecbaee | 27 | #include "ui/console.h" |
db1a4972 PB |
28 | |
29 | #include "hw/hw.h" | |
30 | ||
1de7afc9 | 31 | #include "qemu/timer.h" |
30ea8339 AL |
32 | #ifdef CONFIG_POSIX |
33 | #include <pthread.h> | |
34 | #endif | |
bff9f8bf | 35 | |
db1a4972 | 36 | #ifdef _WIN32 |
db1a4972 PB |
37 | #include <mmsystem.h> |
38 | #endif | |
39 | ||
db1a4972 PB |
40 | /***********************************************************/ |
41 | /* timers */ | |
42 | ||
db1a4972 | 43 | struct QEMUClock { |
688eb389 | 44 | QEMUTimer *active_timers; |
691a0c9c JK |
45 | |
46 | NotifierList reset_notifiers; | |
47 | int64_t last; | |
9a14b298 SW |
48 | |
49 | int type; | |
50 | bool enabled; | |
db1a4972 PB |
51 | }; |
52 | ||
53 | struct QEMUTimer { | |
4a998740 | 54 | int64_t expire_time; /* in nanoseconds */ |
9a14b298 | 55 | QEMUClock *clock; |
db1a4972 PB |
56 | QEMUTimerCB *cb; |
57 | void *opaque; | |
9a14b298 SW |
58 | QEMUTimer *next; |
59 | int scale; | |
db1a4972 PB |
60 | }; |
61 | ||
62 | struct qemu_alarm_timer { | |
63 | char const *name; | |
64 | int (*start)(struct qemu_alarm_timer *t); | |
65 | void (*stop)(struct qemu_alarm_timer *t); | |
f3fc6e2e | 66 | void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns); |
cd0544ee | 67 | #if defined(__linux__) |
cd0544ee | 68 | timer_t timer; |
9a14b298 | 69 | int fd; |
cd0544ee SW |
70 | #elif defined(_WIN32) |
71 | HANDLE timer; | |
72 | #endif | |
5e1ec7b2 SW |
73 | bool expired; |
74 | bool pending; | |
db1a4972 PB |
75 | }; |
76 | ||
77 | static struct qemu_alarm_timer *alarm_timer; | |
78 | ||
e93379b0 | 79 | static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time) |
45c7b37f SW |
80 | { |
81 | return timer_head && (timer_head->expire_time <= current_time); | |
82 | } | |
83 | ||
f3fc6e2e PB |
84 | static int64_t qemu_next_alarm_deadline(void) |
85 | { | |
4ffd16fc | 86 | int64_t delta = INT64_MAX; |
f3fc6e2e PB |
87 | int64_t rtdelta; |
88 | ||
4ffd16fc | 89 | if (!use_icount && vm_clock->enabled && vm_clock->active_timers) { |
f3fc6e2e PB |
90 | delta = vm_clock->active_timers->expire_time - |
91 | qemu_get_clock_ns(vm_clock); | |
f3fc6e2e | 92 | } |
4ffd16fc | 93 | if (host_clock->enabled && host_clock->active_timers) { |
f3fc6e2e PB |
94 | int64_t hdelta = host_clock->active_timers->expire_time - |
95 | qemu_get_clock_ns(host_clock); | |
96 | if (hdelta < delta) { | |
97 | delta = hdelta; | |
98 | } | |
99 | } | |
4ffd16fc | 100 | if (rt_clock->enabled && rt_clock->active_timers) { |
f3fc6e2e PB |
101 | rtdelta = (rt_clock->active_timers->expire_time - |
102 | qemu_get_clock_ns(rt_clock)); | |
103 | if (rtdelta < delta) { | |
104 | delta = rtdelta; | |
105 | } | |
106 | } | |
107 | ||
108 | return delta; | |
109 | } | |
110 | ||
db1a4972 PB |
111 | static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t) |
112 | { | |
8227421e SS |
113 | int64_t nearest_delta_ns = qemu_next_alarm_deadline(); |
114 | if (nearest_delta_ns < INT64_MAX) { | |
115 | t->rearm(t, nearest_delta_ns); | |
f3fc6e2e | 116 | } |
db1a4972 PB |
117 | } |
118 | ||
9c13246a PB |
119 | /* TODO: MIN_TIMER_REARM_NS should be optimized */ |
120 | #define MIN_TIMER_REARM_NS 250000 | |
db1a4972 PB |
121 | |
122 | #ifdef _WIN32 | |
123 | ||
2f9cba0c SW |
124 | static int mm_start_timer(struct qemu_alarm_timer *t); |
125 | static void mm_stop_timer(struct qemu_alarm_timer *t); | |
f3fc6e2e | 126 | static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta); |
2f9cba0c | 127 | |
db1a4972 PB |
128 | static int win32_start_timer(struct qemu_alarm_timer *t); |
129 | static void win32_stop_timer(struct qemu_alarm_timer *t); | |
f3fc6e2e | 130 | static void win32_rearm_timer(struct qemu_alarm_timer *t, int64_t delta); |
db1a4972 PB |
131 | |
132 | #else | |
133 | ||
134 | static int unix_start_timer(struct qemu_alarm_timer *t); | |
135 | static void unix_stop_timer(struct qemu_alarm_timer *t); | |
f3fc6e2e | 136 | static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta); |
db1a4972 PB |
137 | |
138 | #ifdef __linux__ | |
139 | ||
140 | static int dynticks_start_timer(struct qemu_alarm_timer *t); | |
141 | static void dynticks_stop_timer(struct qemu_alarm_timer *t); | |
f3fc6e2e | 142 | static void dynticks_rearm_timer(struct qemu_alarm_timer *t, int64_t delta); |
db1a4972 | 143 | |
db1a4972 PB |
144 | #endif /* __linux__ */ |
145 | ||
146 | #endif /* _WIN32 */ | |
147 | ||
db1a4972 PB |
148 | static struct qemu_alarm_timer alarm_timers[] = { |
149 | #ifndef _WIN32 | |
150 | #ifdef __linux__ | |
151 | {"dynticks", dynticks_start_timer, | |
cd0544ee | 152 | dynticks_stop_timer, dynticks_rearm_timer}, |
db1a4972 | 153 | #endif |
84682834 | 154 | {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer}, |
db1a4972 | 155 | #else |
cca5de73 | 156 | {"mmtimer", mm_start_timer, mm_stop_timer, mm_rearm_timer}, |
cd0544ee | 157 | {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer}, |
db1a4972 PB |
158 | #endif |
159 | {NULL, } | |
160 | }; | |
161 | ||
162 | static void show_available_alarms(void) | |
163 | { | |
164 | int i; | |
165 | ||
166 | printf("Available alarm timers, in order of precedence:\n"); | |
167 | for (i = 0; alarm_timers[i].name; i++) | |
168 | printf("%s\n", alarm_timers[i].name); | |
169 | } | |
170 | ||
171 | void configure_alarms(char const *opt) | |
172 | { | |
173 | int i; | |
174 | int cur = 0; | |
175 | int count = ARRAY_SIZE(alarm_timers) - 1; | |
176 | char *arg; | |
177 | char *name; | |
178 | struct qemu_alarm_timer tmp; | |
179 | ||
c8057f95 | 180 | if (is_help_option(opt)) { |
db1a4972 PB |
181 | show_available_alarms(); |
182 | exit(0); | |
183 | } | |
184 | ||
7267c094 | 185 | arg = g_strdup(opt); |
db1a4972 PB |
186 | |
187 | /* Reorder the array */ | |
188 | name = strtok(arg, ","); | |
189 | while (name) { | |
190 | for (i = 0; i < count && alarm_timers[i].name; i++) { | |
191 | if (!strcmp(alarm_timers[i].name, name)) | |
192 | break; | |
193 | } | |
194 | ||
195 | if (i == count) { | |
196 | fprintf(stderr, "Unknown clock %s\n", name); | |
197 | goto next; | |
198 | } | |
199 | ||
200 | if (i < cur) | |
201 | /* Ignore */ | |
202 | goto next; | |
203 | ||
204 | /* Swap */ | |
205 | tmp = alarm_timers[i]; | |
206 | alarm_timers[i] = alarm_timers[cur]; | |
207 | alarm_timers[cur] = tmp; | |
208 | ||
209 | cur++; | |
210 | next: | |
211 | name = strtok(NULL, ","); | |
212 | } | |
213 | ||
7267c094 | 214 | g_free(arg); |
db1a4972 PB |
215 | |
216 | if (cur) { | |
217 | /* Disable remaining timers */ | |
218 | for (i = cur; i < count; i++) | |
219 | alarm_timers[i].name = NULL; | |
220 | } else { | |
221 | show_available_alarms(); | |
222 | exit(1); | |
223 | } | |
224 | } | |
225 | ||
db1a4972 PB |
226 | QEMUClock *rt_clock; |
227 | QEMUClock *vm_clock; | |
228 | QEMUClock *host_clock; | |
229 | ||
58ac56b9 | 230 | static QEMUClock *qemu_clock_new(int type) |
db1a4972 PB |
231 | { |
232 | QEMUClock *clock; | |
691a0c9c | 233 | |
7267c094 | 234 | clock = g_malloc0(sizeof(QEMUClock)); |
db1a4972 | 235 | clock->type = type; |
5e1ec7b2 | 236 | clock->enabled = true; |
2ff68d07 | 237 | clock->last = INT64_MIN; |
691a0c9c | 238 | notifier_list_init(&clock->reset_notifiers); |
db1a4972 PB |
239 | return clock; |
240 | } | |
241 | ||
5e1ec7b2 | 242 | void qemu_clock_enable(QEMUClock *clock, bool enabled) |
db1a4972 | 243 | { |
fbdc14eb | 244 | bool old = clock->enabled; |
db1a4972 | 245 | clock->enabled = enabled; |
fbdc14eb PB |
246 | if (enabled && !old) { |
247 | qemu_rearm_alarm_timer(alarm_timer); | |
248 | } | |
db1a4972 PB |
249 | } |
250 | ||
dc2dfcf0 PB |
251 | int64_t qemu_clock_has_timers(QEMUClock *clock) |
252 | { | |
253 | return !!clock->active_timers; | |
254 | } | |
255 | ||
256 | int64_t qemu_clock_expired(QEMUClock *clock) | |
257 | { | |
258 | return (clock->active_timers && | |
259 | clock->active_timers->expire_time < qemu_get_clock_ns(clock)); | |
260 | } | |
261 | ||
262 | int64_t qemu_clock_deadline(QEMUClock *clock) | |
263 | { | |
264 | /* To avoid problems with overflow limit this to 2^32. */ | |
265 | int64_t delta = INT32_MAX; | |
266 | ||
267 | if (clock->active_timers) { | |
268 | delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock); | |
269 | } | |
270 | if (delta < 0) { | |
271 | delta = 0; | |
272 | } | |
273 | return delta; | |
274 | } | |
275 | ||
02a03a9f AB |
276 | /* |
277 | * As above, but return -1 for no deadline, and do not cap to 2^32 | |
278 | * as we know the result is always positive. | |
279 | */ | |
280 | ||
281 | int64_t qemu_clock_deadline_ns(QEMUClock *clock) | |
282 | { | |
283 | int64_t delta; | |
284 | ||
285 | if (!clock->enabled || !clock->active_timers) { | |
286 | return -1; | |
287 | } | |
288 | ||
289 | delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock); | |
290 | ||
291 | if (delta <= 0) { | |
292 | return 0; | |
293 | } | |
294 | ||
295 | return delta; | |
296 | } | |
297 | ||
298 | /* Transition function to convert a nanosecond timeout to ms | |
299 | * This is used where a system does not support ppoll | |
300 | */ | |
301 | int qemu_timeout_ns_to_ms(int64_t ns) | |
302 | { | |
303 | int64_t ms; | |
304 | if (ns < 0) { | |
305 | return -1; | |
306 | } | |
307 | ||
308 | if (!ns) { | |
309 | return 0; | |
310 | } | |
311 | ||
312 | /* Always round up, because it's better to wait too long than to wait too | |
313 | * little and effectively busy-wait | |
314 | */ | |
315 | ms = (ns + SCALE_MS - 1) / SCALE_MS; | |
316 | ||
317 | /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */ | |
318 | if (ms > (int64_t) INT32_MAX) { | |
319 | ms = INT32_MAX; | |
320 | } | |
321 | ||
322 | return (int) ms; | |
323 | } | |
324 | ||
325 | ||
4a998740 PB |
326 | QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, |
327 | QEMUTimerCB *cb, void *opaque) | |
db1a4972 PB |
328 | { |
329 | QEMUTimer *ts; | |
330 | ||
7267c094 | 331 | ts = g_malloc0(sizeof(QEMUTimer)); |
db1a4972 PB |
332 | ts->clock = clock; |
333 | ts->cb = cb; | |
334 | ts->opaque = opaque; | |
4a998740 | 335 | ts->scale = scale; |
db1a4972 PB |
336 | return ts; |
337 | } | |
338 | ||
339 | void qemu_free_timer(QEMUTimer *ts) | |
340 | { | |
7267c094 | 341 | g_free(ts); |
db1a4972 PB |
342 | } |
343 | ||
344 | /* stop a timer, but do not dealloc it */ | |
345 | void qemu_del_timer(QEMUTimer *ts) | |
346 | { | |
347 | QEMUTimer **pt, *t; | |
348 | ||
349 | /* NOTE: this code must be signal safe because | |
e93379b0 | 350 | timer_expired() can be called from a signal. */ |
688eb389 | 351 | pt = &ts->clock->active_timers; |
db1a4972 PB |
352 | for(;;) { |
353 | t = *pt; | |
354 | if (!t) | |
355 | break; | |
356 | if (t == ts) { | |
357 | *pt = t->next; | |
358 | break; | |
359 | } | |
360 | pt = &t->next; | |
361 | } | |
362 | } | |
363 | ||
364 | /* modify the current timer so that it will be fired when current_time | |
365 | >= expire_time. The corresponding callback will be called. */ | |
2ff68d07 | 366 | void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time) |
db1a4972 PB |
367 | { |
368 | QEMUTimer **pt, *t; | |
369 | ||
370 | qemu_del_timer(ts); | |
371 | ||
372 | /* add the timer in the sorted list */ | |
373 | /* NOTE: this code must be signal safe because | |
e93379b0 | 374 | timer_expired() can be called from a signal. */ |
688eb389 | 375 | pt = &ts->clock->active_timers; |
db1a4972 PB |
376 | for(;;) { |
377 | t = *pt; | |
e93379b0 | 378 | if (!timer_expired_ns(t, expire_time)) { |
db1a4972 | 379 | break; |
45c7b37f | 380 | } |
db1a4972 PB |
381 | pt = &t->next; |
382 | } | |
383 | ts->expire_time = expire_time; | |
384 | ts->next = *pt; | |
385 | *pt = ts; | |
386 | ||
387 | /* Rearm if necessary */ | |
688eb389 | 388 | if (pt == &ts->clock->active_timers) { |
db1a4972 PB |
389 | if (!alarm_timer->pending) { |
390 | qemu_rearm_alarm_timer(alarm_timer); | |
391 | } | |
392 | /* Interrupt execution to force deadline recalculation. */ | |
ab33fcda PB |
393 | qemu_clock_warp(ts->clock); |
394 | if (use_icount) { | |
db1a4972 | 395 | qemu_notify_event(); |
ab33fcda | 396 | } |
db1a4972 PB |
397 | } |
398 | } | |
399 | ||
4a998740 PB |
400 | void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time) |
401 | { | |
402 | qemu_mod_timer_ns(ts, expire_time * ts->scale); | |
403 | } | |
404 | ||
e93379b0 | 405 | bool timer_pending(QEMUTimer *ts) |
db1a4972 PB |
406 | { |
407 | QEMUTimer *t; | |
688eb389 | 408 | for (t = ts->clock->active_timers; t != NULL; t = t->next) { |
5e1ec7b2 SW |
409 | if (t == ts) { |
410 | return true; | |
411 | } | |
db1a4972 | 412 | } |
5e1ec7b2 | 413 | return false; |
db1a4972 PB |
414 | } |
415 | ||
e93379b0 | 416 | bool timer_expired(QEMUTimer *timer_head, int64_t current_time) |
db1a4972 | 417 | { |
e93379b0 | 418 | return timer_expired_ns(timer_head, current_time * timer_head->scale); |
db1a4972 PB |
419 | } |
420 | ||
8156be56 | 421 | void qemu_run_timers(QEMUClock *clock) |
db1a4972 | 422 | { |
144b97c2 | 423 | QEMUTimer *ts; |
db1a4972 PB |
424 | int64_t current_time; |
425 | ||
426 | if (!clock->enabled) | |
427 | return; | |
428 | ||
4a998740 | 429 | current_time = qemu_get_clock_ns(clock); |
db1a4972 | 430 | for(;;) { |
144b97c2 | 431 | ts = clock->active_timers; |
e93379b0 | 432 | if (!timer_expired_ns(ts, current_time)) { |
db1a4972 | 433 | break; |
45c7b37f | 434 | } |
db1a4972 | 435 | /* remove timer from the list before calling the callback */ |
144b97c2 | 436 | clock->active_timers = ts->next; |
db1a4972 PB |
437 | ts->next = NULL; |
438 | ||
439 | /* run the callback (the timer list can be modified) */ | |
440 | ts->cb(ts->opaque); | |
441 | } | |
442 | } | |
443 | ||
db1a4972 PB |
444 | int64_t qemu_get_clock_ns(QEMUClock *clock) |
445 | { | |
691a0c9c JK |
446 | int64_t now, last; |
447 | ||
db1a4972 PB |
448 | switch(clock->type) { |
449 | case QEMU_CLOCK_REALTIME: | |
450 | return get_clock(); | |
451 | default: | |
452 | case QEMU_CLOCK_VIRTUAL: | |
453 | if (use_icount) { | |
454 | return cpu_get_icount(); | |
455 | } else { | |
456 | return cpu_get_clock(); | |
457 | } | |
458 | case QEMU_CLOCK_HOST: | |
691a0c9c JK |
459 | now = get_clock_realtime(); |
460 | last = clock->last; | |
461 | clock->last = now; | |
462 | if (now < last) { | |
463 | notifier_list_notify(&clock->reset_notifiers, &now); | |
464 | } | |
465 | return now; | |
db1a4972 PB |
466 | } |
467 | } | |
468 | ||
691a0c9c JK |
469 | void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier) |
470 | { | |
471 | notifier_list_add(&clock->reset_notifiers, notifier); | |
472 | } | |
473 | ||
474 | void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier) | |
475 | { | |
31552529 | 476 | notifier_remove(notifier); |
691a0c9c JK |
477 | } |
478 | ||
db1a4972 PB |
479 | void init_clocks(void) |
480 | { | |
744ca8e3 | 481 | if (!rt_clock) { |
58ac56b9 AB |
482 | rt_clock = qemu_clock_new(QEMU_CLOCK_REALTIME); |
483 | vm_clock = qemu_clock_new(QEMU_CLOCK_VIRTUAL); | |
484 | host_clock = qemu_clock_new(QEMU_CLOCK_HOST); | |
744ca8e3 | 485 | } |
db1a4972 PB |
486 | } |
487 | ||
e93379b0 | 488 | uint64_t timer_expire_time_ns(QEMUTimer *ts) |
db1a4972 | 489 | { |
e93379b0 | 490 | return timer_pending(ts) ? ts->expire_time : -1; |
db1a4972 PB |
491 | } |
492 | ||
db1a4972 PB |
493 | void qemu_run_all_timers(void) |
494 | { | |
5e1ec7b2 | 495 | alarm_timer->pending = false; |
ca5a2a4b | 496 | |
158fd3ce PP |
497 | /* vm time timers */ |
498 | qemu_run_timers(vm_clock); | |
499 | qemu_run_timers(rt_clock); | |
500 | qemu_run_timers(host_clock); | |
501 | ||
db1a4972 PB |
502 | /* rearm timer, if not periodic */ |
503 | if (alarm_timer->expired) { | |
5e1ec7b2 | 504 | alarm_timer->expired = false; |
db1a4972 PB |
505 | qemu_rearm_alarm_timer(alarm_timer); |
506 | } | |
db1a4972 PB |
507 | } |
508 | ||
509 | #ifdef _WIN32 | |
68c23e55 | 510 | static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused) |
db1a4972 PB |
511 | #else |
512 | static void host_alarm_handler(int host_signum) | |
513 | #endif | |
514 | { | |
515 | struct qemu_alarm_timer *t = alarm_timer; | |
516 | if (!t) | |
517 | return; | |
518 | ||
8205199d SW |
519 | t->expired = true; |
520 | t->pending = true; | |
521 | qemu_notify_event(); | |
db1a4972 PB |
522 | } |
523 | ||
4c3d45eb PB |
524 | #if defined(__linux__) |
525 | ||
1de7afc9 | 526 | #include "qemu/compatfd.h" |
d25f89c9 | 527 | |
db1a4972 PB |
528 | static int dynticks_start_timer(struct qemu_alarm_timer *t) |
529 | { | |
530 | struct sigevent ev; | |
531 | timer_t host_timer; | |
532 | struct sigaction act; | |
533 | ||
534 | sigfillset(&act.sa_mask); | |
535 | act.sa_flags = 0; | |
536 | act.sa_handler = host_alarm_handler; | |
537 | ||
538 | sigaction(SIGALRM, &act, NULL); | |
539 | ||
540 | /* | |
541 | * Initialize ev struct to 0 to avoid valgrind complaining | |
542 | * about uninitialized data in timer_create call | |
543 | */ | |
544 | memset(&ev, 0, sizeof(ev)); | |
545 | ev.sigev_value.sival_int = 0; | |
546 | ev.sigev_notify = SIGEV_SIGNAL; | |
1e9737da | 547 | #ifdef CONFIG_SIGEV_THREAD_ID |
d25f89c9 JK |
548 | if (qemu_signalfd_available()) { |
549 | ev.sigev_notify = SIGEV_THREAD_ID; | |
550 | ev._sigev_un._tid = qemu_get_thread_id(); | |
551 | } | |
1e9737da | 552 | #endif /* CONFIG_SIGEV_THREAD_ID */ |
db1a4972 PB |
553 | ev.sigev_signo = SIGALRM; |
554 | ||
555 | if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) { | |
556 | perror("timer_create"); | |
db1a4972 PB |
557 | return -1; |
558 | } | |
559 | ||
cd0544ee | 560 | t->timer = host_timer; |
db1a4972 PB |
561 | |
562 | return 0; | |
563 | } | |
564 | ||
565 | static void dynticks_stop_timer(struct qemu_alarm_timer *t) | |
566 | { | |
cd0544ee | 567 | timer_t host_timer = t->timer; |
db1a4972 PB |
568 | |
569 | timer_delete(host_timer); | |
570 | } | |
571 | ||
f3fc6e2e PB |
572 | static void dynticks_rearm_timer(struct qemu_alarm_timer *t, |
573 | int64_t nearest_delta_ns) | |
db1a4972 | 574 | { |
cd0544ee | 575 | timer_t host_timer = t->timer; |
db1a4972 | 576 | struct itimerspec timeout; |
9c13246a | 577 | int64_t current_ns; |
db1a4972 | 578 | |
4c3d45eb PB |
579 | if (nearest_delta_ns < MIN_TIMER_REARM_NS) |
580 | nearest_delta_ns = MIN_TIMER_REARM_NS; | |
db1a4972 PB |
581 | |
582 | /* check whether a timer is already running */ | |
583 | if (timer_gettime(host_timer, &timeout)) { | |
584 | perror("gettime"); | |
585 | fprintf(stderr, "Internal timer error: aborting\n"); | |
586 | exit(1); | |
587 | } | |
9c13246a PB |
588 | current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec; |
589 | if (current_ns && current_ns <= nearest_delta_ns) | |
db1a4972 PB |
590 | return; |
591 | ||
592 | timeout.it_interval.tv_sec = 0; | |
593 | timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */ | |
9c13246a PB |
594 | timeout.it_value.tv_sec = nearest_delta_ns / 1000000000; |
595 | timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000; | |
db1a4972 PB |
596 | if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) { |
597 | perror("settime"); | |
598 | fprintf(stderr, "Internal timer error: aborting\n"); | |
599 | exit(1); | |
600 | } | |
601 | } | |
602 | ||
603 | #endif /* defined(__linux__) */ | |
604 | ||
f26e5a54 SW |
605 | #if !defined(_WIN32) |
606 | ||
db1a4972 PB |
607 | static int unix_start_timer(struct qemu_alarm_timer *t) |
608 | { | |
609 | struct sigaction act; | |
db1a4972 PB |
610 | |
611 | /* timer signal */ | |
612 | sigfillset(&act.sa_mask); | |
613 | act.sa_flags = 0; | |
614 | act.sa_handler = host_alarm_handler; | |
615 | ||
616 | sigaction(SIGALRM, &act, NULL); | |
84682834 PB |
617 | return 0; |
618 | } | |
db1a4972 | 619 | |
f3fc6e2e PB |
620 | static void unix_rearm_timer(struct qemu_alarm_timer *t, |
621 | int64_t nearest_delta_ns) | |
84682834 PB |
622 | { |
623 | struct itimerval itv; | |
84682834 | 624 | int err; |
db1a4972 | 625 | |
84682834 PB |
626 | if (nearest_delta_ns < MIN_TIMER_REARM_NS) |
627 | nearest_delta_ns = MIN_TIMER_REARM_NS; | |
628 | ||
629 | itv.it_interval.tv_sec = 0; | |
630 | itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */ | |
631 | itv.it_value.tv_sec = nearest_delta_ns / 1000000000; | |
632 | itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000; | |
633 | err = setitimer(ITIMER_REAL, &itv, NULL); | |
634 | if (err) { | |
635 | perror("setitimer"); | |
636 | fprintf(stderr, "Internal timer error: aborting\n"); | |
637 | exit(1); | |
638 | } | |
db1a4972 PB |
639 | } |
640 | ||
641 | static void unix_stop_timer(struct qemu_alarm_timer *t) | |
642 | { | |
643 | struct itimerval itv; | |
644 | ||
645 | memset(&itv, 0, sizeof(itv)); | |
646 | setitimer(ITIMER_REAL, &itv, NULL); | |
647 | } | |
648 | ||
649 | #endif /* !defined(_WIN32) */ | |
650 | ||
651 | ||
652 | #ifdef _WIN32 | |
653 | ||
2f9cba0c | 654 | static MMRESULT mm_timer; |
40f08e87 | 655 | static TIMECAPS mm_tc; |
2f9cba0c SW |
656 | |
657 | static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg, | |
658 | DWORD_PTR dwUser, DWORD_PTR dw1, | |
659 | DWORD_PTR dw2) | |
660 | { | |
661 | struct qemu_alarm_timer *t = alarm_timer; | |
662 | if (!t) { | |
663 | return; | |
664 | } | |
8205199d SW |
665 | t->expired = true; |
666 | t->pending = true; | |
667 | qemu_notify_event(); | |
2f9cba0c SW |
668 | } |
669 | ||
670 | static int mm_start_timer(struct qemu_alarm_timer *t) | |
671 | { | |
40f08e87 | 672 | timeGetDevCaps(&mm_tc, sizeof(mm_tc)); |
2f9cba0c SW |
673 | return 0; |
674 | } | |
675 | ||
676 | static void mm_stop_timer(struct qemu_alarm_timer *t) | |
677 | { | |
0727b867 PB |
678 | if (mm_timer) { |
679 | timeKillEvent(mm_timer); | |
680 | } | |
2f9cba0c SW |
681 | } |
682 | ||
f3fc6e2e | 683 | static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta) |
2f9cba0c | 684 | { |
5bfb723f | 685 | int64_t nearest_delta_ms = delta / 1000000; |
40f08e87 SW |
686 | if (nearest_delta_ms < mm_tc.wPeriodMin) { |
687 | nearest_delta_ms = mm_tc.wPeriodMin; | |
688 | } else if (nearest_delta_ms > mm_tc.wPeriodMax) { | |
689 | nearest_delta_ms = mm_tc.wPeriodMax; | |
5bfb723f | 690 | } |
f3fc6e2e | 691 | |
0727b867 PB |
692 | if (mm_timer) { |
693 | timeKillEvent(mm_timer); | |
694 | } | |
40f08e87 SW |
695 | mm_timer = timeSetEvent((UINT)nearest_delta_ms, |
696 | mm_tc.wPeriodMin, | |
2f9cba0c SW |
697 | mm_alarm_handler, |
698 | (DWORD_PTR)t, | |
699 | TIME_ONESHOT | TIME_CALLBACK_FUNCTION); | |
700 | ||
701 | if (!mm_timer) { | |
52ef651f | 702 | fprintf(stderr, "Failed to re-arm win32 alarm timer\n"); |
40f08e87 | 703 | timeEndPeriod(mm_tc.wPeriodMin); |
2f9cba0c SW |
704 | exit(1); |
705 | } | |
706 | } | |
707 | ||
db1a4972 PB |
708 | static int win32_start_timer(struct qemu_alarm_timer *t) |
709 | { | |
68c23e55 PB |
710 | HANDLE hTimer; |
711 | BOOLEAN success; | |
712 | ||
713 | /* If you call ChangeTimerQueueTimer on a one-shot timer (its period | |
714 | is zero) that has already expired, the timer is not updated. Since | |
715 | creating a new timer is relatively expensive, set a bogus one-hour | |
716 | interval in the dynticks case. */ | |
717 | success = CreateTimerQueueTimer(&hTimer, | |
718 | NULL, | |
719 | host_alarm_handler, | |
720 | t, | |
721 | 1, | |
8205199d | 722 | 3600000, |
68c23e55 PB |
723 | WT_EXECUTEINTIMERTHREAD); |
724 | ||
725 | if (!success) { | |
db1a4972 PB |
726 | fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n", |
727 | GetLastError()); | |
db1a4972 PB |
728 | return -1; |
729 | } | |
730 | ||
cd0544ee | 731 | t->timer = hTimer; |
db1a4972 PB |
732 | return 0; |
733 | } | |
734 | ||
735 | static void win32_stop_timer(struct qemu_alarm_timer *t) | |
736 | { | |
cd0544ee | 737 | HANDLE hTimer = t->timer; |
db1a4972 | 738 | |
68c23e55 PB |
739 | if (hTimer) { |
740 | DeleteTimerQueueTimer(NULL, hTimer, NULL); | |
741 | } | |
db1a4972 PB |
742 | } |
743 | ||
f3fc6e2e PB |
744 | static void win32_rearm_timer(struct qemu_alarm_timer *t, |
745 | int64_t nearest_delta_ns) | |
db1a4972 | 746 | { |
cd0544ee | 747 | HANDLE hTimer = t->timer; |
5bfb723f | 748 | int64_t nearest_delta_ms; |
68c23e55 | 749 | BOOLEAN success; |
db1a4972 | 750 | |
5bfb723f | 751 | nearest_delta_ms = nearest_delta_ns / 1000000; |
cfced5b2 PB |
752 | if (nearest_delta_ms < 1) { |
753 | nearest_delta_ms = 1; | |
754 | } | |
5bfb723f SS |
755 | /* ULONG_MAX can be 32 bit */ |
756 | if (nearest_delta_ms > ULONG_MAX) { | |
757 | nearest_delta_ms = ULONG_MAX; | |
758 | } | |
68c23e55 PB |
759 | success = ChangeTimerQueueTimer(NULL, |
760 | hTimer, | |
5bfb723f | 761 | (unsigned long) nearest_delta_ms, |
68c23e55 | 762 | 3600000); |
db1a4972 | 763 | |
68c23e55 PB |
764 | if (!success) { |
765 | fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n", | |
766 | GetLastError()); | |
767 | exit(-1); | |
db1a4972 | 768 | } |
68c23e55 | 769 | |
db1a4972 PB |
770 | } |
771 | ||
772 | #endif /* _WIN32 */ | |
773 | ||
4260a739 PB |
774 | static void quit_timers(void) |
775 | { | |
776 | struct qemu_alarm_timer *t = alarm_timer; | |
777 | alarm_timer = NULL; | |
778 | t->stop(t); | |
779 | } | |
780 | ||
253ecf83 | 781 | #ifdef CONFIG_POSIX |
c8122c35 PB |
782 | static void reinit_timers(void) |
783 | { | |
784 | struct qemu_alarm_timer *t = alarm_timer; | |
785 | t->stop(t); | |
786 | if (t->start(t)) { | |
787 | fprintf(stderr, "Internal timer error: aborting\n"); | |
788 | exit(1); | |
789 | } | |
790 | qemu_rearm_alarm_timer(t); | |
791 | } | |
253ecf83 | 792 | #endif /* CONFIG_POSIX */ |
c8122c35 | 793 | |
db1a4972 PB |
794 | int init_timer_alarm(void) |
795 | { | |
796 | struct qemu_alarm_timer *t = NULL; | |
797 | int i, err = -1; | |
798 | ||
744ca8e3 PB |
799 | if (alarm_timer) { |
800 | return 0; | |
801 | } | |
802 | ||
db1a4972 PB |
803 | for (i = 0; alarm_timers[i].name; i++) { |
804 | t = &alarm_timers[i]; | |
805 | ||
806 | err = t->start(t); | |
807 | if (!err) | |
808 | break; | |
809 | } | |
810 | ||
811 | if (err) { | |
812 | err = -ENOENT; | |
813 | goto fail; | |
814 | } | |
815 | ||
4260a739 | 816 | atexit(quit_timers); |
c8122c35 PB |
817 | #ifdef CONFIG_POSIX |
818 | pthread_atfork(NULL, NULL, reinit_timers); | |
819 | #endif | |
db1a4972 | 820 | alarm_timer = t; |
db1a4972 PB |
821 | return 0; |
822 | ||
823 | fail: | |
824 | return err; | |
825 | } | |
826 |