Makefile: Forbid out-of-tree build from a source tree that has been built in
[qemu/pbrook.git] / qemu-timer.c
blob908a1030b602248d5b18b407a87131e4385269b6
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
25 #include "sysemu.h"
26 #include "net.h"
27 #include "monitor.h"
28 #include "console.h"
30 #include "hw/hw.h"
32 #include "qemu-timer.h"
34 #ifdef _WIN32
35 #include <mmsystem.h>
36 #endif
38 /***********************************************************/
39 /* timers */
41 #define QEMU_CLOCK_REALTIME 0
42 #define QEMU_CLOCK_VIRTUAL 1
43 #define QEMU_CLOCK_HOST 2
45 struct QEMUClock {
46 QEMUTimer *active_timers;
48 NotifierList reset_notifiers;
49 int64_t last;
51 int type;
52 bool enabled;
55 struct QEMUTimer {
56 int64_t expire_time; /* in nanoseconds */
57 QEMUClock *clock;
58 QEMUTimerCB *cb;
59 void *opaque;
60 QEMUTimer *next;
61 int scale;
64 struct qemu_alarm_timer {
65 char const *name;
66 int (*start)(struct qemu_alarm_timer *t);
67 void (*stop)(struct qemu_alarm_timer *t);
68 void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns);
69 #if defined(__linux__)
70 timer_t timer;
71 int fd;
72 #elif defined(_WIN32)
73 HANDLE timer;
74 #endif
75 bool expired;
76 bool pending;
79 static struct qemu_alarm_timer *alarm_timer;
81 static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
83 return timer_head && (timer_head->expire_time <= current_time);
86 static int64_t qemu_next_alarm_deadline(void)
88 int64_t delta = INT64_MAX;
89 int64_t rtdelta;
91 if (!use_icount && vm_clock->enabled && vm_clock->active_timers) {
92 delta = vm_clock->active_timers->expire_time -
93 qemu_get_clock_ns(vm_clock);
95 if (host_clock->enabled && host_clock->active_timers) {
96 int64_t hdelta = host_clock->active_timers->expire_time -
97 qemu_get_clock_ns(host_clock);
98 if (hdelta < delta) {
99 delta = hdelta;
102 if (rt_clock->enabled && rt_clock->active_timers) {
103 rtdelta = (rt_clock->active_timers->expire_time -
104 qemu_get_clock_ns(rt_clock));
105 if (rtdelta < delta) {
106 delta = rtdelta;
110 return delta;
113 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
115 int64_t nearest_delta_ns = qemu_next_alarm_deadline();
116 if (nearest_delta_ns < INT64_MAX) {
117 t->rearm(t, nearest_delta_ns);
121 /* TODO: MIN_TIMER_REARM_NS should be optimized */
122 #define MIN_TIMER_REARM_NS 250000
124 #ifdef _WIN32
126 static int mm_start_timer(struct qemu_alarm_timer *t);
127 static void mm_stop_timer(struct qemu_alarm_timer *t);
128 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
130 static int win32_start_timer(struct qemu_alarm_timer *t);
131 static void win32_stop_timer(struct qemu_alarm_timer *t);
132 static void win32_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
134 #else
136 static int unix_start_timer(struct qemu_alarm_timer *t);
137 static void unix_stop_timer(struct qemu_alarm_timer *t);
138 static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
140 #ifdef __linux__
142 static int dynticks_start_timer(struct qemu_alarm_timer *t);
143 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
144 static void dynticks_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
146 #endif /* __linux__ */
148 #endif /* _WIN32 */
150 static struct qemu_alarm_timer alarm_timers[] = {
151 #ifndef _WIN32
152 #ifdef __linux__
153 {"dynticks", dynticks_start_timer,
154 dynticks_stop_timer, dynticks_rearm_timer},
155 #endif
156 {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
157 #else
158 {"mmtimer", mm_start_timer, mm_stop_timer, mm_rearm_timer},
159 {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
160 #endif
161 {NULL, }
164 static void show_available_alarms(void)
166 int i;
168 printf("Available alarm timers, in order of precedence:\n");
169 for (i = 0; alarm_timers[i].name; i++)
170 printf("%s\n", alarm_timers[i].name);
173 void configure_alarms(char const *opt)
175 int i;
176 int cur = 0;
177 int count = ARRAY_SIZE(alarm_timers) - 1;
178 char *arg;
179 char *name;
180 struct qemu_alarm_timer tmp;
182 if (is_help_option(opt)) {
183 show_available_alarms();
184 exit(0);
187 arg = g_strdup(opt);
189 /* Reorder the array */
190 name = strtok(arg, ",");
191 while (name) {
192 for (i = 0; i < count && alarm_timers[i].name; i++) {
193 if (!strcmp(alarm_timers[i].name, name))
194 break;
197 if (i == count) {
198 fprintf(stderr, "Unknown clock %s\n", name);
199 goto next;
202 if (i < cur)
203 /* Ignore */
204 goto next;
206 /* Swap */
207 tmp = alarm_timers[i];
208 alarm_timers[i] = alarm_timers[cur];
209 alarm_timers[cur] = tmp;
211 cur++;
212 next:
213 name = strtok(NULL, ",");
216 g_free(arg);
218 if (cur) {
219 /* Disable remaining timers */
220 for (i = cur; i < count; i++)
221 alarm_timers[i].name = NULL;
222 } else {
223 show_available_alarms();
224 exit(1);
228 QEMUClock *rt_clock;
229 QEMUClock *vm_clock;
230 QEMUClock *host_clock;
232 static QEMUClock *qemu_new_clock(int type)
234 QEMUClock *clock;
236 clock = g_malloc0(sizeof(QEMUClock));
237 clock->type = type;
238 clock->enabled = true;
239 clock->last = INT64_MIN;
240 notifier_list_init(&clock->reset_notifiers);
241 return clock;
244 void qemu_clock_enable(QEMUClock *clock, bool enabled)
246 bool old = clock->enabled;
247 clock->enabled = enabled;
248 if (enabled && !old) {
249 qemu_rearm_alarm_timer(alarm_timer);
253 int64_t qemu_clock_has_timers(QEMUClock *clock)
255 return !!clock->active_timers;
258 int64_t qemu_clock_expired(QEMUClock *clock)
260 return (clock->active_timers &&
261 clock->active_timers->expire_time < qemu_get_clock_ns(clock));
264 int64_t qemu_clock_deadline(QEMUClock *clock)
266 /* To avoid problems with overflow limit this to 2^32. */
267 int64_t delta = INT32_MAX;
269 if (clock->active_timers) {
270 delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock);
272 if (delta < 0) {
273 delta = 0;
275 return delta;
278 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
279 QEMUTimerCB *cb, void *opaque)
281 QEMUTimer *ts;
283 ts = g_malloc0(sizeof(QEMUTimer));
284 ts->clock = clock;
285 ts->cb = cb;
286 ts->opaque = opaque;
287 ts->scale = scale;
288 return ts;
291 void qemu_free_timer(QEMUTimer *ts)
293 g_free(ts);
296 /* stop a timer, but do not dealloc it */
297 void qemu_del_timer(QEMUTimer *ts)
299 QEMUTimer **pt, *t;
301 /* NOTE: this code must be signal safe because
302 qemu_timer_expired() can be called from a signal. */
303 pt = &ts->clock->active_timers;
304 for(;;) {
305 t = *pt;
306 if (!t)
307 break;
308 if (t == ts) {
309 *pt = t->next;
310 break;
312 pt = &t->next;
316 /* modify the current timer so that it will be fired when current_time
317 >= expire_time. The corresponding callback will be called. */
318 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
320 QEMUTimer **pt, *t;
322 qemu_del_timer(ts);
324 /* add the timer in the sorted list */
325 /* NOTE: this code must be signal safe because
326 qemu_timer_expired() can be called from a signal. */
327 pt = &ts->clock->active_timers;
328 for(;;) {
329 t = *pt;
330 if (!qemu_timer_expired_ns(t, expire_time)) {
331 break;
333 pt = &t->next;
335 ts->expire_time = expire_time;
336 ts->next = *pt;
337 *pt = ts;
339 /* Rearm if necessary */
340 if (pt == &ts->clock->active_timers) {
341 if (!alarm_timer->pending) {
342 qemu_rearm_alarm_timer(alarm_timer);
344 /* Interrupt execution to force deadline recalculation. */
345 qemu_clock_warp(ts->clock);
346 if (use_icount) {
347 qemu_notify_event();
352 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
354 qemu_mod_timer_ns(ts, expire_time * ts->scale);
357 bool qemu_timer_pending(QEMUTimer *ts)
359 QEMUTimer *t;
360 for (t = ts->clock->active_timers; t != NULL; t = t->next) {
361 if (t == ts) {
362 return true;
365 return false;
368 bool qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
370 return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
373 void qemu_run_timers(QEMUClock *clock)
375 QEMUTimer *ts;
376 int64_t current_time;
378 if (!clock->enabled)
379 return;
381 current_time = qemu_get_clock_ns(clock);
382 for(;;) {
383 ts = clock->active_timers;
384 if (!qemu_timer_expired_ns(ts, current_time)) {
385 break;
387 /* remove timer from the list before calling the callback */
388 clock->active_timers = ts->next;
389 ts->next = NULL;
391 /* run the callback (the timer list can be modified) */
392 ts->cb(ts->opaque);
396 int64_t qemu_get_clock_ns(QEMUClock *clock)
398 int64_t now, last;
400 switch(clock->type) {
401 case QEMU_CLOCK_REALTIME:
402 return get_clock();
403 default:
404 case QEMU_CLOCK_VIRTUAL:
405 if (use_icount) {
406 return cpu_get_icount();
407 } else {
408 return cpu_get_clock();
410 case QEMU_CLOCK_HOST:
411 now = get_clock_realtime();
412 last = clock->last;
413 clock->last = now;
414 if (now < last) {
415 notifier_list_notify(&clock->reset_notifiers, &now);
417 return now;
421 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
423 notifier_list_add(&clock->reset_notifiers, notifier);
426 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
428 notifier_remove(notifier);
431 void init_clocks(void)
433 rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
434 vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
435 host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
438 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts)
440 return qemu_timer_pending(ts) ? ts->expire_time : -1;
443 void qemu_run_all_timers(void)
445 alarm_timer->pending = false;
447 /* vm time timers */
448 qemu_run_timers(vm_clock);
449 qemu_run_timers(rt_clock);
450 qemu_run_timers(host_clock);
452 /* rearm timer, if not periodic */
453 if (alarm_timer->expired) {
454 alarm_timer->expired = false;
455 qemu_rearm_alarm_timer(alarm_timer);
459 #ifdef _WIN32
460 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
461 #else
462 static void host_alarm_handler(int host_signum)
463 #endif
465 struct qemu_alarm_timer *t = alarm_timer;
466 if (!t)
467 return;
469 t->expired = true;
470 t->pending = true;
471 qemu_notify_event();
474 #if defined(__linux__)
476 #include "compatfd.h"
478 static int dynticks_start_timer(struct qemu_alarm_timer *t)
480 struct sigevent ev;
481 timer_t host_timer;
482 struct sigaction act;
484 sigfillset(&act.sa_mask);
485 act.sa_flags = 0;
486 act.sa_handler = host_alarm_handler;
488 sigaction(SIGALRM, &act, NULL);
491 * Initialize ev struct to 0 to avoid valgrind complaining
492 * about uninitialized data in timer_create call
494 memset(&ev, 0, sizeof(ev));
495 ev.sigev_value.sival_int = 0;
496 ev.sigev_notify = SIGEV_SIGNAL;
497 #ifdef SIGEV_THREAD_ID
498 if (qemu_signalfd_available()) {
499 ev.sigev_notify = SIGEV_THREAD_ID;
500 ev._sigev_un._tid = qemu_get_thread_id();
502 #endif /* SIGEV_THREAD_ID */
503 ev.sigev_signo = SIGALRM;
505 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
506 perror("timer_create");
507 return -1;
510 t->timer = host_timer;
512 return 0;
515 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
517 timer_t host_timer = t->timer;
519 timer_delete(host_timer);
522 static void dynticks_rearm_timer(struct qemu_alarm_timer *t,
523 int64_t nearest_delta_ns)
525 timer_t host_timer = t->timer;
526 struct itimerspec timeout;
527 int64_t current_ns;
529 if (nearest_delta_ns < MIN_TIMER_REARM_NS)
530 nearest_delta_ns = MIN_TIMER_REARM_NS;
532 /* check whether a timer is already running */
533 if (timer_gettime(host_timer, &timeout)) {
534 perror("gettime");
535 fprintf(stderr, "Internal timer error: aborting\n");
536 exit(1);
538 current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
539 if (current_ns && current_ns <= nearest_delta_ns)
540 return;
542 timeout.it_interval.tv_sec = 0;
543 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
544 timeout.it_value.tv_sec = nearest_delta_ns / 1000000000;
545 timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
546 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
547 perror("settime");
548 fprintf(stderr, "Internal timer error: aborting\n");
549 exit(1);
553 #endif /* defined(__linux__) */
555 #if !defined(_WIN32)
557 static int unix_start_timer(struct qemu_alarm_timer *t)
559 struct sigaction act;
561 /* timer signal */
562 sigfillset(&act.sa_mask);
563 act.sa_flags = 0;
564 act.sa_handler = host_alarm_handler;
566 sigaction(SIGALRM, &act, NULL);
567 return 0;
570 static void unix_rearm_timer(struct qemu_alarm_timer *t,
571 int64_t nearest_delta_ns)
573 struct itimerval itv;
574 int err;
576 if (nearest_delta_ns < MIN_TIMER_REARM_NS)
577 nearest_delta_ns = MIN_TIMER_REARM_NS;
579 itv.it_interval.tv_sec = 0;
580 itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
581 itv.it_value.tv_sec = nearest_delta_ns / 1000000000;
582 itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
583 err = setitimer(ITIMER_REAL, &itv, NULL);
584 if (err) {
585 perror("setitimer");
586 fprintf(stderr, "Internal timer error: aborting\n");
587 exit(1);
591 static void unix_stop_timer(struct qemu_alarm_timer *t)
593 struct itimerval itv;
595 memset(&itv, 0, sizeof(itv));
596 setitimer(ITIMER_REAL, &itv, NULL);
599 #endif /* !defined(_WIN32) */
602 #ifdef _WIN32
604 static MMRESULT mm_timer;
605 static TIMECAPS mm_tc;
607 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
608 DWORD_PTR dwUser, DWORD_PTR dw1,
609 DWORD_PTR dw2)
611 struct qemu_alarm_timer *t = alarm_timer;
612 if (!t) {
613 return;
615 t->expired = true;
616 t->pending = true;
617 qemu_notify_event();
620 static int mm_start_timer(struct qemu_alarm_timer *t)
622 timeGetDevCaps(&mm_tc, sizeof(mm_tc));
624 timeBeginPeriod(mm_tc.wPeriodMin);
626 mm_timer = timeSetEvent(mm_tc.wPeriodMin, /* interval (ms) */
627 mm_tc.wPeriodMin, /* resolution */
628 mm_alarm_handler, /* function */
629 (DWORD_PTR)t, /* parameter */
630 TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
632 if (!mm_timer) {
633 fprintf(stderr, "Failed to initialize win32 alarm timer\n");
634 timeEndPeriod(mm_tc.wPeriodMin);
635 return -1;
638 return 0;
641 static void mm_stop_timer(struct qemu_alarm_timer *t)
643 timeKillEvent(mm_timer);
644 timeEndPeriod(mm_tc.wPeriodMin);
647 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta)
649 int64_t nearest_delta_ms = delta / 1000000;
650 if (nearest_delta_ms < mm_tc.wPeriodMin) {
651 nearest_delta_ms = mm_tc.wPeriodMin;
652 } else if (nearest_delta_ms > mm_tc.wPeriodMax) {
653 nearest_delta_ms = mm_tc.wPeriodMax;
656 timeKillEvent(mm_timer);
657 mm_timer = timeSetEvent((UINT)nearest_delta_ms,
658 mm_tc.wPeriodMin,
659 mm_alarm_handler,
660 (DWORD_PTR)t,
661 TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
663 if (!mm_timer) {
664 fprintf(stderr, "Failed to re-arm win32 alarm timer\n");
665 timeEndPeriod(mm_tc.wPeriodMin);
666 exit(1);
670 static int win32_start_timer(struct qemu_alarm_timer *t)
672 HANDLE hTimer;
673 BOOLEAN success;
675 /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
676 is zero) that has already expired, the timer is not updated. Since
677 creating a new timer is relatively expensive, set a bogus one-hour
678 interval in the dynticks case. */
679 success = CreateTimerQueueTimer(&hTimer,
680 NULL,
681 host_alarm_handler,
684 3600000,
685 WT_EXECUTEINTIMERTHREAD);
687 if (!success) {
688 fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
689 GetLastError());
690 return -1;
693 t->timer = hTimer;
694 return 0;
697 static void win32_stop_timer(struct qemu_alarm_timer *t)
699 HANDLE hTimer = t->timer;
701 if (hTimer) {
702 DeleteTimerQueueTimer(NULL, hTimer, NULL);
706 static void win32_rearm_timer(struct qemu_alarm_timer *t,
707 int64_t nearest_delta_ns)
709 HANDLE hTimer = t->timer;
710 int64_t nearest_delta_ms;
711 BOOLEAN success;
713 nearest_delta_ms = nearest_delta_ns / 1000000;
714 if (nearest_delta_ms < 1) {
715 nearest_delta_ms = 1;
717 /* ULONG_MAX can be 32 bit */
718 if (nearest_delta_ms > ULONG_MAX) {
719 nearest_delta_ms = ULONG_MAX;
721 success = ChangeTimerQueueTimer(NULL,
722 hTimer,
723 (unsigned long) nearest_delta_ms,
724 3600000);
726 if (!success) {
727 fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
728 GetLastError());
729 exit(-1);
734 #endif /* _WIN32 */
736 static void quit_timers(void)
738 struct qemu_alarm_timer *t = alarm_timer;
739 alarm_timer = NULL;
740 t->stop(t);
743 int init_timer_alarm(void)
745 struct qemu_alarm_timer *t = NULL;
746 int i, err = -1;
748 for (i = 0; alarm_timers[i].name; i++) {
749 t = &alarm_timers[i];
751 err = t->start(t);
752 if (!err)
753 break;
756 if (err) {
757 err = -ENOENT;
758 goto fail;
761 atexit(quit_timers);
762 alarm_timer = t;
763 return 0;
765 fail:
766 return err;