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 "qemu-timer.h" 33 34 #ifdef _WIN32 35 #include <mmsystem.h> 36 #endif 37 38 /***********************************************************/ 39 /* timers */ 40 41 #define QEMU_CLOCK_REALTIME 0 42 #define QEMU_CLOCK_VIRTUAL 1 43 #define QEMU_CLOCK_HOST 2 44 45 struct QEMUClock { 46 QEMUTimer *active_timers; 47 48 NotifierList reset_notifiers; 49 int64_t last; 50 51 int type; 52 bool enabled; 53 }; 54 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; 62 }; 63 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; 77 }; 78 79 static struct qemu_alarm_timer *alarm_timer; 80 81 static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time) 82 { 83 return timer_head && (timer_head->expire_time <= current_time); 84 } 85 86 static int64_t qemu_next_alarm_deadline(void) 87 { 88 int64_t delta = INT64_MAX; 89 int64_t rtdelta; 90 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); 94 } 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; 100 } 101 } 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; 107 } 108 } 109 110 return delta; 111 } 112 113 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t) 114 { 115 int64_t nearest_delta_ns = qemu_next_alarm_deadline(); 116 if (nearest_delta_ns < INT64_MAX) { 117 t->rearm(t, nearest_delta_ns); 118 } 119 } 120 121 /* TODO: MIN_TIMER_REARM_NS should be optimized */ 122 #define MIN_TIMER_REARM_NS 250000 123 124 #ifdef _WIN32 125 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); 129 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); 133 134 #else 135 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); 139 140 #ifdef __linux__ 141 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); 145 146 #endif /* __linux__ */ 147 148 #endif /* _WIN32 */ 149 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, } 162 }; 163 164 static void show_available_alarms(void) 165 { 166 int i; 167 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); 171 } 172 173 void configure_alarms(char const *opt) 174 { 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; 181 182 if (is_help_option(opt)) { 183 show_available_alarms(); 184 exit(0); 185 } 186 187 arg = g_strdup(opt); 188 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; 195 } 196 197 if (i == count) { 198 fprintf(stderr, "Unknown clock %s\n", name); 199 goto next; 200 } 201 202 if (i < cur) 203 /* Ignore */ 204 goto next; 205 206 /* Swap */ 207 tmp = alarm_timers[i]; 208 alarm_timers[i] = alarm_timers[cur]; 209 alarm_timers[cur] = tmp; 210 211 cur++; 212 next: 213 name = strtok(NULL, ","); 214 } 215 216 g_free(arg); 217 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); 225 } 226 } 227 228 QEMUClock *rt_clock; 229 QEMUClock *vm_clock; 230 QEMUClock *host_clock; 231 232 static QEMUClock *qemu_new_clock(int type) 233 { 234 QEMUClock *clock; 235 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; 242 } 243 244 void qemu_clock_enable(QEMUClock *clock, bool enabled) 245 { 246 bool old = clock->enabled; 247 clock->enabled = enabled; 248 if (enabled && !old) { 249 qemu_rearm_alarm_timer(alarm_timer); 250 } 251 } 252 253 int64_t qemu_clock_has_timers(QEMUClock *clock) 254 { 255 return !!clock->active_timers; 256 } 257 258 int64_t qemu_clock_expired(QEMUClock *clock) 259 { 260 return (clock->active_timers && 261 clock->active_timers->expire_time < qemu_get_clock_ns(clock)); 262 } 263 264 int64_t qemu_clock_deadline(QEMUClock *clock) 265 { 266 /* To avoid problems with overflow limit this to 2^32. */ 267 int64_t delta = INT32_MAX; 268 269 if (clock->active_timers) { 270 delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock); 271 } 272 if (delta < 0) { 273 delta = 0; 274 } 275 return delta; 276 } 277 278 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, 279 QEMUTimerCB *cb, void *opaque) 280 { 281 QEMUTimer *ts; 282 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; 289 } 290 291 void qemu_free_timer(QEMUTimer *ts) 292 { 293 g_free(ts); 294 } 295 296 /* stop a timer, but do not dealloc it */ 297 void qemu_del_timer(QEMUTimer *ts) 298 { 299 QEMUTimer **pt, *t; 300 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; 311 } 312 pt = &t->next; 313 } 314 } 315 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) 319 { 320 QEMUTimer **pt, *t; 321 322 qemu_del_timer(ts); 323 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; 332 } 333 pt = &t->next; 334 } 335 ts->expire_time = expire_time; 336 ts->next = *pt; 337 *pt = ts; 338 339 /* Rearm if necessary */ 340 if (pt == &ts->clock->active_timers) { 341 if (!alarm_timer->pending) { 342 qemu_rearm_alarm_timer(alarm_timer); 343 } 344 /* Interrupt execution to force deadline recalculation. */ 345 qemu_clock_warp(ts->clock); 346 if (use_icount) { 347 qemu_notify_event(); 348 } 349 } 350 } 351 352 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time) 353 { 354 qemu_mod_timer_ns(ts, expire_time * ts->scale); 355 } 356 357 bool qemu_timer_pending(QEMUTimer *ts) 358 { 359 QEMUTimer *t; 360 for (t = ts->clock->active_timers; t != NULL; t = t->next) { 361 if (t == ts) { 362 return true; 363 } 364 } 365 return false; 366 } 367 368 bool qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time) 369 { 370 return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale); 371 } 372 373 void qemu_run_timers(QEMUClock *clock) 374 { 375 QEMUTimer *ts; 376 int64_t current_time; 377 378 if (!clock->enabled) 379 return; 380 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; 386 } 387 /* remove timer from the list before calling the callback */ 388 clock->active_timers = ts->next; 389 ts->next = NULL; 390 391 /* run the callback (the timer list can be modified) */ 392 ts->cb(ts->opaque); 393 } 394 } 395 396 int64_t qemu_get_clock_ns(QEMUClock *clock) 397 { 398 int64_t now, last; 399 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(); 409 } 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); 416 } 417 return now; 418 } 419 } 420 421 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier) 422 { 423 notifier_list_add(&clock->reset_notifiers, notifier); 424 } 425 426 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier) 427 { 428 notifier_remove(notifier); 429 } 430 431 void init_clocks(void) 432 { 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); 436 } 437 438 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts) 439 { 440 return qemu_timer_pending(ts) ? ts->expire_time : -1; 441 } 442 443 void qemu_run_all_timers(void) 444 { 445 alarm_timer->pending = false; 446 447 /* vm time timers */ 448 qemu_run_timers(vm_clock); 449 qemu_run_timers(rt_clock); 450 qemu_run_timers(host_clock); 451 452 /* rearm timer, if not periodic */ 453 if (alarm_timer->expired) { 454 alarm_timer->expired = false; 455 qemu_rearm_alarm_timer(alarm_timer); 456 } 457 } 458 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 464 { 465 struct qemu_alarm_timer *t = alarm_timer; 466 if (!t) 467 return; 468 469 t->expired = true; 470 t->pending = true; 471 qemu_notify_event(); 472 } 473 474 #if defined(__linux__) 475 476 #include "compatfd.h" 477 478 static int dynticks_start_timer(struct qemu_alarm_timer *t) 479 { 480 struct sigevent ev; 481 timer_t host_timer; 482 struct sigaction act; 483 484 sigfillset(&act.sa_mask); 485 act.sa_flags = 0; 486 act.sa_handler = host_alarm_handler; 487 488 sigaction(SIGALRM, &act, NULL); 489 490 /* 491 * Initialize ev struct to 0 to avoid valgrind complaining 492 * about uninitialized data in timer_create call 493 */ 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(); 501 } 502 #endif /* SIGEV_THREAD_ID */ 503 ev.sigev_signo = SIGALRM; 504 505 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) { 506 perror("timer_create"); 507 return -1; 508 } 509 510 t->timer = host_timer; 511 512 return 0; 513 } 514 515 static void dynticks_stop_timer(struct qemu_alarm_timer *t) 516 { 517 timer_t host_timer = t->timer; 518 519 timer_delete(host_timer); 520 } 521 522 static void dynticks_rearm_timer(struct qemu_alarm_timer *t, 523 int64_t nearest_delta_ns) 524 { 525 timer_t host_timer = t->timer; 526 struct itimerspec timeout; 527 int64_t current_ns; 528 529 if (nearest_delta_ns < MIN_TIMER_REARM_NS) 530 nearest_delta_ns = MIN_TIMER_REARM_NS; 531 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); 537 } 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; 541 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); 550 } 551 } 552 553 #endif /* defined(__linux__) */ 554 555 #if !defined(_WIN32) 556 557 static int unix_start_timer(struct qemu_alarm_timer *t) 558 { 559 struct sigaction act; 560 561 /* timer signal */ 562 sigfillset(&act.sa_mask); 563 act.sa_flags = 0; 564 act.sa_handler = host_alarm_handler; 565 566 sigaction(SIGALRM, &act, NULL); 567 return 0; 568 } 569 570 static void unix_rearm_timer(struct qemu_alarm_timer *t, 571 int64_t nearest_delta_ns) 572 { 573 struct itimerval itv; 574 int err; 575 576 if (nearest_delta_ns < MIN_TIMER_REARM_NS) 577 nearest_delta_ns = MIN_TIMER_REARM_NS; 578 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); 588 } 589 } 590 591 static void unix_stop_timer(struct qemu_alarm_timer *t) 592 { 593 struct itimerval itv; 594 595 memset(&itv, 0, sizeof(itv)); 596 setitimer(ITIMER_REAL, &itv, NULL); 597 } 598 599 #endif /* !defined(_WIN32) */ 600 601 602 #ifdef _WIN32 603 604 static MMRESULT mm_timer; 605 static TIMECAPS mm_tc; 606 607 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg, 608 DWORD_PTR dwUser, DWORD_PTR dw1, 609 DWORD_PTR dw2) 610 { 611 struct qemu_alarm_timer *t = alarm_timer; 612 if (!t) { 613 return; 614 } 615 t->expired = true; 616 t->pending = true; 617 qemu_notify_event(); 618 } 619 620 static int mm_start_timer(struct qemu_alarm_timer *t) 621 { 622 timeGetDevCaps(&mm_tc, sizeof(mm_tc)); 623 624 timeBeginPeriod(mm_tc.wPeriodMin); 625 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); 631 632 if (!mm_timer) { 633 fprintf(stderr, "Failed to initialize win32 alarm timer\n"); 634 timeEndPeriod(mm_tc.wPeriodMin); 635 return -1; 636 } 637 638 return 0; 639 } 640 641 static void mm_stop_timer(struct qemu_alarm_timer *t) 642 { 643 timeKillEvent(mm_timer); 644 timeEndPeriod(mm_tc.wPeriodMin); 645 } 646 647 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta) 648 { 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; 654 } 655 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); 662 663 if (!mm_timer) { 664 fprintf(stderr, "Failed to re-arm win32 alarm timer\n"); 665 timeEndPeriod(mm_tc.wPeriodMin); 666 exit(1); 667 } 668 } 669 670 static int win32_start_timer(struct qemu_alarm_timer *t) 671 { 672 HANDLE hTimer; 673 BOOLEAN success; 674 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, 682 t, 683 1, 684 3600000, 685 WT_EXECUTEINTIMERTHREAD); 686 687 if (!success) { 688 fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n", 689 GetLastError()); 690 return -1; 691 } 692 693 t->timer = hTimer; 694 return 0; 695 } 696 697 static void win32_stop_timer(struct qemu_alarm_timer *t) 698 { 699 HANDLE hTimer = t->timer; 700 701 if (hTimer) { 702 DeleteTimerQueueTimer(NULL, hTimer, NULL); 703 } 704 } 705 706 static void win32_rearm_timer(struct qemu_alarm_timer *t, 707 int64_t nearest_delta_ns) 708 { 709 HANDLE hTimer = t->timer; 710 int64_t nearest_delta_ms; 711 BOOLEAN success; 712 713 nearest_delta_ms = nearest_delta_ns / 1000000; 714 if (nearest_delta_ms < 1) { 715 nearest_delta_ms = 1; 716 } 717 /* ULONG_MAX can be 32 bit */ 718 if (nearest_delta_ms > ULONG_MAX) { 719 nearest_delta_ms = ULONG_MAX; 720 } 721 success = ChangeTimerQueueTimer(NULL, 722 hTimer, 723 (unsigned long) nearest_delta_ms, 724 3600000); 725 726 if (!success) { 727 fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n", 728 GetLastError()); 729 exit(-1); 730 } 731 732 } 733 734 #endif /* _WIN32 */ 735 736 static void quit_timers(void) 737 { 738 struct qemu_alarm_timer *t = alarm_timer; 739 alarm_timer = NULL; 740 t->stop(t); 741 } 742 743 int init_timer_alarm(void) 744 { 745 struct qemu_alarm_timer *t = NULL; 746 int i, err = -1; 747 748 for (i = 0; alarm_timers[i].name; i++) { 749 t = &alarm_timers[i]; 750 751 err = t->start(t); 752 if (!err) 753 break; 754 } 755 756 if (err) { 757 err = -ENOENT; 758 goto fail; 759 } 760 761 atexit(quit_timers); 762 alarm_timer = t; 763 return 0; 764 765 fail: 766 return err; 767 } 768 769