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