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