?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vhost_net: mergeable buffers support
[qemu.git] / qemu-timer.c
blobbc5f207bb6e5c4cac2edb686286235f7464f772b
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
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <time.h>
35 #include <errno.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #ifdef __FreeBSD__
39 #include <sys/param.h>
40 #endif
41
42 #ifdef __linux__
43 #include <sys/ioctl.h>
44 #include <linux/rtc.h>
45 /* For the benefit of older linux systems which don't supply it,
46 we use a local copy of hpet.h. */
47 /* #include <linux/hpet.h> */
48 #include "hpet.h"
49 #endif
50
51 #ifdef _WIN32
52 #include <windows.h>
53 #include <mmsystem.h>
54 #endif
55
56 #include "qemu-timer.h"
57
58 /* Conversion factor from emulated instructions to virtual clock ticks. */
59 int icount_time_shift;
60 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
61 #define MAX_ICOUNT_SHIFT 10
62 /* Compensate for varying guest execution speed. */
63 int64_t qemu_icount_bias;
64 static QEMUTimer *icount_rt_timer;
65 static QEMUTimer *icount_vm_timer;
66
67
68 /***********************************************************/
69 /* real time host monotonic timer */
70
71
72 static int64_t get_clock_realtime(void)
73 {
74 struct timeval tv;
75
76 gettimeofday(&tv, NULL);
77 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
78 }
79
80 #ifdef WIN32
81
82 static int64_t clock_freq;
83
84 static void init_get_clock(void)
85 {
86 LARGE_INTEGER freq;
87 int ret;
88 ret = QueryPerformanceFrequency(&freq);
89 if (ret == 0) {
90 fprintf(stderr, "Could not calibrate ticks\n");
91 exit(1);
92 }
93 clock_freq = freq.QuadPart;
94 }
95
96 static int64_t get_clock(void)
97 {
98 LARGE_INTEGER ti;
99 QueryPerformanceCounter(&ti);
100 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
101 }
102
103 #else
104
105 static int use_rt_clock;
106
107 static void init_get_clock(void)
108 {
109 use_rt_clock = 0;
110 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
111 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
112 {
113 struct timespec ts;
114 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
115 use_rt_clock = 1;
116 }
117 }
118 #endif
119 }
120
121 static int64_t get_clock(void)
122 {
123 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
124 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
125 if (use_rt_clock) {
126 struct timespec ts;
127 clock_gettime(CLOCK_MONOTONIC, &ts);
128 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
129 } else
130 #endif
131 {
132 /* XXX: using gettimeofday leads to problems if the date
133 changes, so it should be avoided. */
134 return get_clock_realtime();
135 }
136 }
137 #endif
138
139 /***********************************************************/
140 /* guest cycle counter */
141
142 typedef struct TimersState {
143 int64_t cpu_ticks_prev;
144 int64_t cpu_ticks_offset;
145 int64_t cpu_clock_offset;
146 int32_t cpu_ticks_enabled;
147 int64_t dummy;
148 } TimersState;
149
150 TimersState timers_state;
151
152 /* return the host CPU cycle counter and handle stop/restart */
153 int64_t cpu_get_ticks(void)
154 {
155 if (use_icount) {
156 return cpu_get_icount();
157 }
158 if (!timers_state.cpu_ticks_enabled) {
159 return timers_state.cpu_ticks_offset;
160 } else {
161 int64_t ticks;
162 ticks = cpu_get_real_ticks();
163 if (timers_state.cpu_ticks_prev > ticks) {
164 /* Note: non increasing ticks may happen if the host uses
165 software suspend */
166 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
167 }
168 timers_state.cpu_ticks_prev = ticks;
169 return ticks + timers_state.cpu_ticks_offset;
170 }
171 }
172
173 /* return the host CPU monotonic timer and handle stop/restart */
174 static int64_t cpu_get_clock(void)
175 {
176 int64_t ti;
177 if (!timers_state.cpu_ticks_enabled) {
178 return timers_state.cpu_clock_offset;
179 } else {
180 ti = get_clock();
181 return ti + timers_state.cpu_clock_offset;
182 }
183 }
184
185 #ifndef CONFIG_IOTHREAD
186 static int64_t qemu_icount_delta(void)
187 {
188 if (!use_icount) {
189 return 5000 * (int64_t) 1000000;
190 } else if (use_icount == 1) {
191 /* When not using an adaptive execution frequency
192 we tend to get badly out of sync with real time,
193 so just delay for a reasonable amount of time. */
194 return 0;
195 } else {
196 return cpu_get_icount() - cpu_get_clock();
197 }
198 }
199 #endif
200
201 /* enable cpu_get_ticks() */
202 void cpu_enable_ticks(void)
203 {
204 if (!timers_state.cpu_ticks_enabled) {
205 timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
206 timers_state.cpu_clock_offset -= get_clock();
207 timers_state.cpu_ticks_enabled = 1;
208 }
209 }
210
211 /* disable cpu_get_ticks() : the clock is stopped. You must not call
212 cpu_get_ticks() after that. */
213 void cpu_disable_ticks(void)
214 {
215 if (timers_state.cpu_ticks_enabled) {
216 timers_state.cpu_ticks_offset = cpu_get_ticks();
217 timers_state.cpu_clock_offset = cpu_get_clock();
218 timers_state.cpu_ticks_enabled = 0;
219 }
220 }
221
222 /***********************************************************/
223 /* timers */
224
225 #define QEMU_CLOCK_REALTIME 0
226 #define QEMU_CLOCK_VIRTUAL 1
227 #define QEMU_CLOCK_HOST 2
228
229 struct QEMUClock {
230 int type;
231 int enabled;
232 /* XXX: add frequency */
233 };
234
235 struct QEMUTimer {
236 QEMUClock *clock;
237 int64_t expire_time;
238 QEMUTimerCB *cb;
239 void *opaque;
240 struct QEMUTimer *next;
241 };
242
243 struct qemu_alarm_timer {
244 char const *name;
245 int (*start)(struct qemu_alarm_timer *t);
246 void (*stop)(struct qemu_alarm_timer *t);
247 void (*rearm)(struct qemu_alarm_timer *t);
248 void *priv;
249
250 char expired;
251 char pending;
252 };
253
254 static struct qemu_alarm_timer *alarm_timer;
255
256 int qemu_alarm_pending(void)
257 {
258 return alarm_timer->pending;
259 }
260
261 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
262 {
263 return !!t->rearm;
264 }
265
266 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
267 {
268 if (!alarm_has_dynticks(t))
269 return;
270
271 t->rearm(t);
272 }
273
274 /* TODO: MIN_TIMER_REARM_US should be optimized */
275 #define MIN_TIMER_REARM_US 250
276
277 #ifdef _WIN32
278
279 struct qemu_alarm_win32 {
280 MMRESULT timerId;
281 unsigned int period;
282 } alarm_win32_data = {0, 0};
283
284 static int win32_start_timer(struct qemu_alarm_timer *t);
285 static void win32_stop_timer(struct qemu_alarm_timer *t);
286 static void win32_rearm_timer(struct qemu_alarm_timer *t);
287
288 #else
289
290 static int unix_start_timer(struct qemu_alarm_timer *t);
291 static void unix_stop_timer(struct qemu_alarm_timer *t);
292
293 #ifdef __linux__
294
295 static int dynticks_start_timer(struct qemu_alarm_timer *t);
296 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
297 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
298
299 static int hpet_start_timer(struct qemu_alarm_timer *t);
300 static void hpet_stop_timer(struct qemu_alarm_timer *t);
301
302 static int rtc_start_timer(struct qemu_alarm_timer *t);
303 static void rtc_stop_timer(struct qemu_alarm_timer *t);
304
305 #endif /* __linux__ */
306
307 #endif /* _WIN32 */
308
309 /* Correlation between real and virtual time is always going to be
310 fairly approximate, so ignore small variation.
311 When the guest is idle real and virtual time will be aligned in
312 the IO wait loop. */
313 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
314
315 static void icount_adjust(void)
316 {
317 int64_t cur_time;
318 int64_t cur_icount;
319 int64_t delta;
320 static int64_t last_delta;
321 /* If the VM is not running, then do nothing. */
322 if (!vm_running)
323 return;
324
325 cur_time = cpu_get_clock();
326 cur_icount = qemu_get_clock(vm_clock);
327 delta = cur_icount - cur_time;
328 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
329 if (delta > 0
330 && last_delta + ICOUNT_WOBBLE < delta * 2
331 && icount_time_shift > 0) {
332 /* The guest is getting too far ahead. Slow time down. */
333 icount_time_shift--;
334 }
335 if (delta < 0
336 && last_delta - ICOUNT_WOBBLE > delta * 2
337 && icount_time_shift < MAX_ICOUNT_SHIFT) {
338 /* The guest is getting too far behind. Speed time up. */
339 icount_time_shift++;
340 }
341 last_delta = delta;
342 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
343 }
344
345 static void icount_adjust_rt(void * opaque)
346 {
347 qemu_mod_timer(icount_rt_timer,
348 qemu_get_clock(rt_clock) + 1000);
349 icount_adjust();
350 }
351
352 static void icount_adjust_vm(void * opaque)
353 {
354 qemu_mod_timer(icount_vm_timer,
355 qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
356 icount_adjust();
357 }
358
359 int64_t qemu_icount_round(int64_t count)
360 {
361 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
362 }
363
364 static struct qemu_alarm_timer alarm_timers[] = {
365 #ifndef _WIN32
366 #ifdef __linux__
367 {"dynticks", dynticks_start_timer,
368 dynticks_stop_timer, dynticks_rearm_timer, NULL},
369 /* HPET - if available - is preferred */
370 {"hpet", hpet_start_timer, hpet_stop_timer, NULL, NULL},
371 /* ...otherwise try RTC */
372 {"rtc", rtc_start_timer, rtc_stop_timer, NULL, NULL},
373 #endif
374 {"unix", unix_start_timer, unix_stop_timer, NULL, NULL},
375 #else
376 {"dynticks", win32_start_timer,
377 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
378 {"win32", win32_start_timer,
379 win32_stop_timer, NULL, &alarm_win32_data},
380 #endif
381 {NULL, }
382 };
383
384 static void show_available_alarms(void)
385 {
386 int i;
387
388 printf("Available alarm timers, in order of precedence:\n");
389 for (i = 0; alarm_timers[i].name; i++)
390 printf("%s\n", alarm_timers[i].name);
391 }
392
393 void configure_alarms(char const *opt)
394 {
395 int i;
396 int cur = 0;
397 int count = ARRAY_SIZE(alarm_timers) - 1;
398 char *arg;
399 char *name;
400 struct qemu_alarm_timer tmp;
401
402 if (!strcmp(opt, "?")) {
403 show_available_alarms();
404 exit(0);
405 }
406
407 arg = qemu_strdup(opt);
408
409 /* Reorder the array */
410 name = strtok(arg, ",");
411 while (name) {
412 for (i = 0; i < count && alarm_timers[i].name; i++) {
413 if (!strcmp(alarm_timers[i].name, name))
414 break;
415 }
416
417 if (i == count) {
418 fprintf(stderr, "Unknown clock %s\n", name);
419 goto next;
420 }
421
422 if (i < cur)
423 /* Ignore */
424 goto next;
425
426 /* Swap */
427 tmp = alarm_timers[i];
428 alarm_timers[i] = alarm_timers[cur];
429 alarm_timers[cur] = tmp;
430
431 cur++;
432 next:
433 name = strtok(NULL, ",");
434 }
435
436 qemu_free(arg);
437
438 if (cur) {
439 /* Disable remaining timers */
440 for (i = cur; i < count; i++)
441 alarm_timers[i].name = NULL;
442 } else {
443 show_available_alarms();
444 exit(1);
445 }
446 }
447
448 #define QEMU_NUM_CLOCKS 3
449
450 QEMUClock *rt_clock;
451 QEMUClock *vm_clock;
452 QEMUClock *host_clock;
453
454 static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
455
456 static QEMUClock *qemu_new_clock(int type)
457 {
458 QEMUClock *clock;
459 clock = qemu_mallocz(sizeof(QEMUClock));
460 clock->type = type;
461 clock->enabled = 1;
462 return clock;
463 }
464
465 void qemu_clock_enable(QEMUClock *clock, int enabled)
466 {
467 clock->enabled = enabled;
468 }
469
470 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
471 {
472 QEMUTimer *ts;
473
474 ts = qemu_mallocz(sizeof(QEMUTimer));
475 ts->clock = clock;
476 ts->cb = cb;
477 ts->opaque = opaque;
478 return ts;
479 }
480
481 void qemu_free_timer(QEMUTimer *ts)
482 {
483 qemu_free(ts);
484 }
485
486 /* stop a timer, but do not dealloc it */
487 void qemu_del_timer(QEMUTimer *ts)
488 {
489 QEMUTimer **pt, *t;
490
491 /* NOTE: this code must be signal safe because
492 qemu_timer_expired() can be called from a signal. */
493 pt = &active_timers[ts->clock->type];
494 for(;;) {
495 t = *pt;
496 if (!t)
497 break;
498 if (t == ts) {
499 *pt = t->next;
500 break;
501 }
502 pt = &t->next;
503 }
504 }
505
506 /* modify the current timer so that it will be fired when current_time
507 >= expire_time. The corresponding callback will be called. */
508 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
509 {
510 QEMUTimer **pt, *t;
511
512 qemu_del_timer(ts);
513
514 /* add the timer in the sorted list */
515 /* NOTE: this code must be signal safe because
516 qemu_timer_expired() can be called from a signal. */
517 pt = &active_timers[ts->clock->type];
518 for(;;) {
519 t = *pt;
520 if (!t)
521 break;
522 if (t->expire_time > expire_time)
523 break;
524 pt = &t->next;
525 }
526 ts->expire_time = expire_time;
527 ts->next = *pt;
528 *pt = ts;
529
530 /* Rearm if necessary */
531 if (pt == &active_timers[ts->clock->type]) {
532 if (!alarm_timer->pending) {
533 qemu_rearm_alarm_timer(alarm_timer);
534 }
535 /* Interrupt execution to force deadline recalculation. */
536 if (use_icount)
537 qemu_notify_event();
538 }
539 }
540
541 int qemu_timer_pending(QEMUTimer *ts)
542 {
543 QEMUTimer *t;
544 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
545 if (t == ts)
546 return 1;
547 }
548 return 0;
549 }
550
551 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
552 {
553 if (!timer_head)
554 return 0;
555 return (timer_head->expire_time <= current_time);
556 }
557
558 static void qemu_run_timers(QEMUClock *clock)
559 {
560 QEMUTimer **ptimer_head, *ts;
561 int64_t current_time;
562
563 if (!clock->enabled)
564 return;
565
566 current_time = qemu_get_clock (clock);
567 ptimer_head = &active_timers[clock->type];
568 for(;;) {
569 ts = *ptimer_head;
570 if (!ts || ts->expire_time > current_time)
571 break;
572 /* remove timer from the list before calling the callback */
573 *ptimer_head = ts->next;
574 ts->next = NULL;
575
576 /* run the callback (the timer list can be modified) */
577 ts->cb(ts->opaque);
578 }
579 }
580
581 int64_t qemu_get_clock(QEMUClock *clock)
582 {
583 switch(clock->type) {
584 case QEMU_CLOCK_REALTIME:
585 return get_clock() / 1000000;
586 default:
587 case QEMU_CLOCK_VIRTUAL:
588 if (use_icount) {
589 return cpu_get_icount();
590 } else {
591 return cpu_get_clock();
592 }
593 case QEMU_CLOCK_HOST:
594 return get_clock_realtime();
595 }
596 }
597
598 int64_t qemu_get_clock_ns(QEMUClock *clock)
599 {
600 switch(clock->type) {
601 case QEMU_CLOCK_REALTIME:
602 return get_clock();
603 default:
604 case QEMU_CLOCK_VIRTUAL:
605 if (use_icount) {
606 return cpu_get_icount();
607 } else {
608 return cpu_get_clock();
609 }
610 case QEMU_CLOCK_HOST:
611 return get_clock_realtime();
612 }
613 }
614
615 void init_clocks(void)
616 {
617 init_get_clock();
618 rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
619 vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
620 host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
621
622 rtc_clock = host_clock;
623 }
624
625 /* save a timer */
626 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
627 {
628 uint64_t expire_time;
629
630 if (qemu_timer_pending(ts)) {
631 expire_time = ts->expire_time;
632 } else {
633 expire_time = -1;
634 }
635 qemu_put_be64(f, expire_time);
636 }
637
638 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
639 {
640 uint64_t expire_time;
641
642 expire_time = qemu_get_be64(f);
643 if (expire_time != -1) {
644 qemu_mod_timer(ts, expire_time);
645 } else {
646 qemu_del_timer(ts);
647 }
648 }
649
650 static const VMStateDescription vmstate_timers = {
651 .name = "timer",
652 .version_id = 2,
653 .minimum_version_id = 1,
654 .minimum_version_id_old = 1,
655 .fields = (VMStateField []) {
656 VMSTATE_INT64(cpu_ticks_offset, TimersState),
657 VMSTATE_INT64(dummy, TimersState),
658 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
659 VMSTATE_END_OF_LIST()
660 }
661 };
662
663 void configure_icount(const char *option)
664 {
665 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
666 if (!option)
667 return;
668
669 if (strcmp(option, "auto") != 0) {
670 icount_time_shift = strtol(option, NULL, 0);
671 use_icount = 1;
672 return;
673 }
674
675 use_icount = 2;
676
677 /* 125MIPS seems a reasonable initial guess at the guest speed.
678 It will be corrected fairly quickly anyway. */
679 icount_time_shift = 3;
680
681 /* Have both realtime and virtual time triggers for speed adjustment.
682 The realtime trigger catches emulated time passing too slowly,
683 the virtual time trigger catches emulated time passing too fast.
684 Realtime triggers occur even when idle, so use them less frequently
685 than VM triggers. */
686 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
687 qemu_mod_timer(icount_rt_timer,
688 qemu_get_clock(rt_clock) + 1000);
689 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
690 qemu_mod_timer(icount_vm_timer,
691 qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
692 }
693
694 void qemu_run_all_timers(void)
695 {
696 alarm_timer->pending = 0;
697
698 /* rearm timer, if not periodic */
699 if (alarm_timer->expired) {
700 alarm_timer->expired = 0;
701 qemu_rearm_alarm_timer(alarm_timer);
702 }
703
704 /* vm time timers */
705 if (vm_running) {
706 qemu_run_timers(vm_clock);
707 }
708
709 qemu_run_timers(rt_clock);
710 qemu_run_timers(host_clock);
711 }
712
713 #ifdef _WIN32
714 static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
715 DWORD_PTR dwUser, DWORD_PTR dw1,
716 DWORD_PTR dw2)
717 #else
718 static void host_alarm_handler(int host_signum)
719 #endif
720 {
721 struct qemu_alarm_timer *t = alarm_timer;
722 if (!t)
723 return;
724
725 #if 0
726 #define DISP_FREQ 1000
727 {
728 static int64_t delta_min = INT64_MAX;
729 static int64_t delta_max, delta_cum, last_clock, delta, ti;
730 static int count;
731 ti = qemu_get_clock(vm_clock);
732 if (last_clock != 0) {
733 delta = ti - last_clock;
734 if (delta < delta_min)
735 delta_min = delta;
736 if (delta > delta_max)
737 delta_max = delta;
738 delta_cum += delta;
739 if (++count == DISP_FREQ) {
740 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
741 muldiv64(delta_min, 1000000, get_ticks_per_sec()),
742 muldiv64(delta_max, 1000000, get_ticks_per_sec()),
743 muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
744 (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
745 count = 0;
746 delta_min = INT64_MAX;
747 delta_max = 0;
748 delta_cum = 0;
749 }
750 }
751 last_clock = ti;
752 }
753 #endif
754 if (alarm_has_dynticks(t) ||
755 (!use_icount &&
756 qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],
757 qemu_get_clock(vm_clock))) ||
758 qemu_timer_expired(active_timers[QEMU_CLOCK_REALTIME],
759 qemu_get_clock(rt_clock)) ||
760 qemu_timer_expired(active_timers[QEMU_CLOCK_HOST],
761 qemu_get_clock(host_clock))) {
762
763 t->expired = alarm_has_dynticks(t);
764 t->pending = 1;
765 qemu_notify_event();
766 }
767 }
768
769 int64_t qemu_next_deadline(void)
770 {
771 /* To avoid problems with overflow limit this to 2^32. */
772 int64_t delta = INT32_MAX;
773
774 if (active_timers[QEMU_CLOCK_VIRTUAL]) {
775 delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
776 qemu_get_clock(vm_clock);
777 }
778 if (active_timers[QEMU_CLOCK_HOST]) {
779 int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
780 qemu_get_clock(host_clock);
781 if (hdelta < delta)
782 delta = hdelta;
783 }
784
785 if (delta < 0)
786 delta = 0;
787
788 return delta;
789 }
790
791 #ifndef _WIN32
792
793 #if defined(__linux__)
794
795 #define RTC_FREQ 1024
796
797 static uint64_t qemu_next_deadline_dyntick(void)
798 {
799 int64_t delta;
800 int64_t rtdelta;
801
802 if (use_icount)
803 delta = INT32_MAX;
804 else
805 delta = (qemu_next_deadline() + 999) / 1000;
806
807 if (active_timers[QEMU_CLOCK_REALTIME]) {
808 rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
809 qemu_get_clock(rt_clock))*1000;
810 if (rtdelta < delta)
811 delta = rtdelta;
812 }
813
814 if (delta < MIN_TIMER_REARM_US)
815 delta = MIN_TIMER_REARM_US;
816
817 return delta;
818 }
819
820 static void enable_sigio_timer(int fd)
821 {
822 struct sigaction act;
823
824 /* timer signal */
825 sigfillset(&act.sa_mask);
826 act.sa_flags = 0;
827 act.sa_handler = host_alarm_handler;
828
829 sigaction(SIGIO, &act, NULL);
830 fcntl_setfl(fd, O_ASYNC);
831 fcntl(fd, F_SETOWN, getpid());
832 }
833
834 static int hpet_start_timer(struct qemu_alarm_timer *t)
835 {
836 struct hpet_info info;
837 int r, fd;
838
839 fd = qemu_open("/dev/hpet", O_RDONLY);
840 if (fd < 0)
841 return -1;
842
843 /* Set frequency */
844 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
845 if (r < 0) {
846 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
847 "error, but for better emulation accuracy type:\n"
848 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
849 goto fail;
850 }
851
852 /* Check capabilities */
853 r = ioctl(fd, HPET_INFO, &info);
854 if (r < 0)
855 goto fail;
856
857 /* Enable periodic mode */
858 r = ioctl(fd, HPET_EPI, 0);
859 if (info.hi_flags && (r < 0))
860 goto fail;
861
862 /* Enable interrupt */
863 r = ioctl(fd, HPET_IE_ON, 0);
864 if (r < 0)
865 goto fail;
866
867 enable_sigio_timer(fd);
868 t->priv = (void *)(long)fd;
869
870 return 0;
871 fail:
872 close(fd);
873 return -1;
874 }
875
876 static void hpet_stop_timer(struct qemu_alarm_timer *t)
877 {
878 int fd = (long)t->priv;
879
880 close(fd);
881 }
882
883 static int rtc_start_timer(struct qemu_alarm_timer *t)
884 {
885 int rtc_fd;
886 unsigned long current_rtc_freq = 0;
887
888 TFR(rtc_fd = qemu_open("/dev/rtc", O_RDONLY));
889 if (rtc_fd < 0)
890 return -1;
891 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
892 if (current_rtc_freq != RTC_FREQ &&
893 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
894 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
895 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
896 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
897 goto fail;
898 }
899 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
900 fail:
901 close(rtc_fd);
902 return -1;
903 }
904
905 enable_sigio_timer(rtc_fd);
906
907 t->priv = (void *)(long)rtc_fd;
908
909 return 0;
910 }
911
912 static void rtc_stop_timer(struct qemu_alarm_timer *t)
913 {
914 int rtc_fd = (long)t->priv;
915
916 close(rtc_fd);
917 }
918
919 static int dynticks_start_timer(struct qemu_alarm_timer *t)
920 {
921 struct sigevent ev;
922 timer_t host_timer;
923 struct sigaction act;
924
925 sigfillset(&act.sa_mask);
926 act.sa_flags = 0;
927 act.sa_handler = host_alarm_handler;
928
929 sigaction(SIGALRM, &act, NULL);
930
931 /*
932 * Initialize ev struct to 0 to avoid valgrind complaining
933 * about uninitialized data in timer_create call
934 */
935 memset(&ev, 0, sizeof(ev));
936 ev.sigev_value.sival_int = 0;
937 ev.sigev_notify = SIGEV_SIGNAL;
938 ev.sigev_signo = SIGALRM;
939
940 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
941 perror("timer_create");
942
943 /* disable dynticks */
944 fprintf(stderr, "Dynamic Ticks disabled\n");
945
946 return -1;
947 }
948
949 t->priv = (void *)(long)host_timer;
950
951 return 0;
952 }
953
954 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
955 {
956 timer_t host_timer = (timer_t)(long)t->priv;
957
958 timer_delete(host_timer);
959 }
960
961 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
962 {
963 timer_t host_timer = (timer_t)(long)t->priv;
964 struct itimerspec timeout;
965 int64_t nearest_delta_us = INT64_MAX;
966 int64_t current_us;
967
968 assert(alarm_has_dynticks(t));
969 if (!active_timers[QEMU_CLOCK_REALTIME] &&
970 !active_timers[QEMU_CLOCK_VIRTUAL] &&
971 !active_timers[QEMU_CLOCK_HOST])
972 return;
973
974 nearest_delta_us = qemu_next_deadline_dyntick();
975
976 /* check whether a timer is already running */
977 if (timer_gettime(host_timer, &timeout)) {
978 perror("gettime");
979 fprintf(stderr, "Internal timer error: aborting\n");
980 exit(1);
981 }
982 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
983 if (current_us && current_us <= nearest_delta_us)
984 return;
985
986 timeout.it_interval.tv_sec = 0;
987 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
988 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
989 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
990 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
991 perror("settime");
992 fprintf(stderr, "Internal timer error: aborting\n");
993 exit(1);
994 }
995 }
996
997 #endif /* defined(__linux__) */
998
999 static int unix_start_timer(struct qemu_alarm_timer *t)
1000 {
1001 struct sigaction act;
1002 struct itimerval itv;
1003 int err;
1004
1005 /* timer signal */
1006 sigfillset(&act.sa_mask);
1007 act.sa_flags = 0;
1008 act.sa_handler = host_alarm_handler;
1009
1010 sigaction(SIGALRM, &act, NULL);
1011
1012 itv.it_interval.tv_sec = 0;
1013 /* for i386 kernel 2.6 to get 1 ms */
1014 itv.it_interval.tv_usec = 999;
1015 itv.it_value.tv_sec = 0;
1016 itv.it_value.tv_usec = 10 * 1000;
1017
1018 err = setitimer(ITIMER_REAL, &itv, NULL);
1019 if (err)
1020 return -1;
1021
1022 return 0;
1023 }
1024
1025 static void unix_stop_timer(struct qemu_alarm_timer *t)
1026 {
1027 struct itimerval itv;
1028
1029 memset(&itv, 0, sizeof(itv));
1030 setitimer(ITIMER_REAL, &itv, NULL);
1031 }
1032
1033 #endif /* !defined(_WIN32) */
1034
1035
1036 #ifdef _WIN32
1037
1038 static int win32_start_timer(struct qemu_alarm_timer *t)
1039 {
1040 TIMECAPS tc;
1041 struct qemu_alarm_win32 *data = t->priv;
1042 UINT flags;
1043
1044 memset(&tc, 0, sizeof(tc));
1045 timeGetDevCaps(&tc, sizeof(tc));
1046
1047 data->period = tc.wPeriodMin;
1048 timeBeginPeriod(data->period);
1049
1050 flags = TIME_CALLBACK_FUNCTION;
1051 if (alarm_has_dynticks(t))
1052 flags |= TIME_ONESHOT;
1053 else
1054 flags |= TIME_PERIODIC;
1055
1056 data->timerId = timeSetEvent(1, // interval (ms)
1057 data->period, // resolution
1058 host_alarm_handler, // function
1059 (DWORD)t, // parameter
1060 flags);
1061
1062 if (!data->timerId) {
1063 fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
1064 GetLastError());
1065 timeEndPeriod(data->period);
1066 return -1;
1067 }
1068
1069 return 0;
1070 }
1071
1072 static void win32_stop_timer(struct qemu_alarm_timer *t)
1073 {
1074 struct qemu_alarm_win32 *data = t->priv;
1075
1076 timeKillEvent(data->timerId);
1077 timeEndPeriod(data->period);
1078 }
1079
1080 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1081 {
1082 struct qemu_alarm_win32 *data = t->priv;
1083
1084 assert(alarm_has_dynticks(t));
1085 if (!active_timers[QEMU_CLOCK_REALTIME] &&
1086 !active_timers[QEMU_CLOCK_VIRTUAL] &&
1087 !active_timers[QEMU_CLOCK_HOST])
1088 return;
1089
1090 timeKillEvent(data->timerId);
1091
1092 data->timerId = timeSetEvent(1,
1093 data->period,
1094 host_alarm_handler,
1095 (DWORD)t,
1096 TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
1097
1098 if (!data->timerId) {
1099 fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
1100 GetLastError());
1101
1102 timeEndPeriod(data->period);
1103 exit(1);
1104 }
1105 }
1106
1107 #endif /* _WIN32 */
1108
1109 static void alarm_timer_on_change_state_rearm(void *opaque, int running, int reason)
1110 {
1111 if (running)
1112 qemu_rearm_alarm_timer((struct qemu_alarm_timer *) opaque);
1113 }
1114
1115 int init_timer_alarm(void)
1116 {
1117 struct qemu_alarm_timer *t = NULL;
1118 int i, err = -1;
1119
1120 for (i = 0; alarm_timers[i].name; i++) {
1121 t = &alarm_timers[i];
1122
1123 err = t->start(t);
1124 if (!err)
1125 break;
1126 }
1127
1128 if (err) {
1129 err = -ENOENT;
1130 goto fail;
1131 }
1132
1133 /* first event is at time 0 */
1134 t->pending = 1;
1135 alarm_timer = t;
1136 qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm, t);
1137
1138 return 0;
1139
1140 fail:
1141 return err;
1142 }
1143
1144 void quit_timers(void)
1145 {
1146 struct qemu_alarm_timer *t = alarm_timer;
1147 alarm_timer = NULL;
1148 t->stop(t);
1149 }
1150
1151 int qemu_calculate_timeout(void)
1152 {
1153 #ifndef CONFIG_IOTHREAD
1154 int timeout;
1155
1156 if (!vm_running)
1157 timeout = 5000;
1158 else {
1159 /* XXX: use timeout computed from timers */
1160 int64_t add;
1161 int64_t delta;
1162 /* Advance virtual time to the next event. */
1163 delta = qemu_icount_delta();
1164 if (delta > 0) {
1165 /* If virtual time is ahead of real time then just
1166 wait for IO. */
1167 timeout = (delta + 999999) / 1000000;
1168 } else {
1169 /* Wait for either IO to occur or the next
1170 timer event. */
1171 add = qemu_next_deadline();
1172 /* We advance the timer before checking for IO.
1173 Limit the amount we advance so that early IO
1174 activity won't get the guest too far ahead. */
1175 if (add > 10000000)
1176 add = 10000000;
1177 delta += add;
1178 qemu_icount += qemu_icount_round (add);
1179 timeout = delta / 1000000;
1180 if (timeout < 0)
1181 timeout = 0;
1182 }
1183 }
1184
1185 return timeout;
1186 #else /* CONFIG_IOTHREAD */
1187 return 1000;
1188 #endif
1189 }
1190
QEmu