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