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 "qemu/osdep.h" 26 #include "qemu/main-loop.h" 27 #include "qemu/timer.h" 28 #include "sysemu/replay.h" 29 #include "sysemu/cpus.h" 30 31 #ifdef CONFIG_POSIX 32 #include <pthread.h> 33 #endif 34 35 #ifdef CONFIG_PPOLL 36 #include <poll.h> 37 #endif 38 39 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK 40 #include <sys/prctl.h> 41 #endif 42 43 /***********************************************************/ 44 /* timers */ 45 46 typedef struct QEMUClock { 47 /* We rely on BQL to protect the timerlists */ 48 QLIST_HEAD(, QEMUTimerList) timerlists; 49 50 int64_t last; 51 52 QEMUClockType type; 53 bool enabled; 54 } QEMUClock; 55 56 QEMUTimerListGroup main_loop_tlg; 57 static QEMUClock qemu_clocks[QEMU_CLOCK_MAX]; 58 59 /* A QEMUTimerList is a list of timers attached to a clock. More 60 * than one QEMUTimerList can be attached to each clock, for instance 61 * used by different AioContexts / threads. Each clock also has 62 * a list of the QEMUTimerLists associated with it, in order that 63 * reenabling the clock can call all the notifiers. 64 */ 65 66 struct QEMUTimerList { 67 QEMUClock *clock; 68 QemuMutex active_timers_lock; 69 QEMUTimer *active_timers; 70 QLIST_ENTRY(QEMUTimerList) list; 71 QEMUTimerListNotifyCB *notify_cb; 72 void *notify_opaque; 73 74 /* lightweight method to mark the end of timerlist's running */ 75 QemuEvent timers_done_ev; 76 }; 77 78 /** 79 * qemu_clock_ptr: 80 * @type: type of clock 81 * 82 * Translate a clock type into a pointer to QEMUClock object. 83 * 84 * Returns: a pointer to the QEMUClock object 85 */ 86 static inline QEMUClock *qemu_clock_ptr(QEMUClockType type) 87 { 88 return &qemu_clocks[type]; 89 } 90 91 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time) 92 { 93 return timer_head && (timer_head->expire_time <= current_time); 94 } 95 96 QEMUTimerList *timerlist_new(QEMUClockType type, 97 QEMUTimerListNotifyCB *cb, 98 void *opaque) 99 { 100 QEMUTimerList *timer_list; 101 QEMUClock *clock = qemu_clock_ptr(type); 102 103 timer_list = g_malloc0(sizeof(QEMUTimerList)); 104 qemu_event_init(&timer_list->timers_done_ev, true); 105 timer_list->clock = clock; 106 timer_list->notify_cb = cb; 107 timer_list->notify_opaque = opaque; 108 qemu_mutex_init(&timer_list->active_timers_lock); 109 QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list); 110 return timer_list; 111 } 112 113 void timerlist_free(QEMUTimerList *timer_list) 114 { 115 assert(!timerlist_has_timers(timer_list)); 116 if (timer_list->clock) { 117 QLIST_REMOVE(timer_list, list); 118 } 119 qemu_mutex_destroy(&timer_list->active_timers_lock); 120 g_free(timer_list); 121 } 122 123 static void qemu_clock_init(QEMUClockType type, QEMUTimerListNotifyCB *notify_cb) 124 { 125 QEMUClock *clock = qemu_clock_ptr(type); 126 127 /* Assert that the clock of type TYPE has not been initialized yet. */ 128 assert(main_loop_tlg.tl[type] == NULL); 129 130 clock->type = type; 131 clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true); 132 clock->last = INT64_MIN; 133 QLIST_INIT(&clock->timerlists); 134 main_loop_tlg.tl[type] = timerlist_new(type, notify_cb, NULL); 135 } 136 137 bool qemu_clock_use_for_deadline(QEMUClockType type) 138 { 139 return !(use_icount && (type == QEMU_CLOCK_VIRTUAL)); 140 } 141 142 void qemu_clock_notify(QEMUClockType type) 143 { 144 QEMUTimerList *timer_list; 145 QEMUClock *clock = qemu_clock_ptr(type); 146 QLIST_FOREACH(timer_list, &clock->timerlists, list) { 147 timerlist_notify(timer_list); 148 } 149 } 150 151 /* Disabling the clock will wait for related timerlists to stop 152 * executing qemu_run_timers. Thus, this functions should not 153 * be used from the callback of a timer that is based on @clock. 154 * Doing so would cause a deadlock. 155 * 156 * Caller should hold BQL. 157 */ 158 void qemu_clock_enable(QEMUClockType type, bool enabled) 159 { 160 QEMUClock *clock = qemu_clock_ptr(type); 161 QEMUTimerList *tl; 162 bool old = clock->enabled; 163 clock->enabled = enabled; 164 if (enabled && !old) { 165 qemu_clock_notify(type); 166 } else if (!enabled && old) { 167 QLIST_FOREACH(tl, &clock->timerlists, list) { 168 qemu_event_wait(&tl->timers_done_ev); 169 } 170 } 171 } 172 173 bool timerlist_has_timers(QEMUTimerList *timer_list) 174 { 175 return !!atomic_read(&timer_list->active_timers); 176 } 177 178 bool qemu_clock_has_timers(QEMUClockType type) 179 { 180 return timerlist_has_timers( 181 main_loop_tlg.tl[type]); 182 } 183 184 bool timerlist_expired(QEMUTimerList *timer_list) 185 { 186 int64_t expire_time; 187 188 if (!atomic_read(&timer_list->active_timers)) { 189 return false; 190 } 191 192 qemu_mutex_lock(&timer_list->active_timers_lock); 193 if (!timer_list->active_timers) { 194 qemu_mutex_unlock(&timer_list->active_timers_lock); 195 return false; 196 } 197 expire_time = timer_list->active_timers->expire_time; 198 qemu_mutex_unlock(&timer_list->active_timers_lock); 199 200 return expire_time <= qemu_clock_get_ns(timer_list->clock->type); 201 } 202 203 bool qemu_clock_expired(QEMUClockType type) 204 { 205 return timerlist_expired( 206 main_loop_tlg.tl[type]); 207 } 208 209 /* 210 * As above, but return -1 for no deadline, and do not cap to 2^32 211 * as we know the result is always positive. 212 */ 213 214 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) 215 { 216 int64_t delta; 217 int64_t expire_time; 218 219 if (!atomic_read(&timer_list->active_timers)) { 220 return -1; 221 } 222 223 if (!timer_list->clock->enabled) { 224 return -1; 225 } 226 227 /* The active timers list may be modified before the caller uses our return 228 * value but ->notify_cb() is called when the deadline changes. Therefore 229 * the caller should notice the change and there is no race condition. 230 */ 231 qemu_mutex_lock(&timer_list->active_timers_lock); 232 if (!timer_list->active_timers) { 233 qemu_mutex_unlock(&timer_list->active_timers_lock); 234 return -1; 235 } 236 expire_time = timer_list->active_timers->expire_time; 237 qemu_mutex_unlock(&timer_list->active_timers_lock); 238 239 delta = expire_time - qemu_clock_get_ns(timer_list->clock->type); 240 241 if (delta <= 0) { 242 return 0; 243 } 244 245 return delta; 246 } 247 248 /* Calculate the soonest deadline across all timerlists attached 249 * to the clock. This is used for the icount timeout so we 250 * ignore whether or not the clock should be used in deadline 251 * calculations. 252 */ 253 int64_t qemu_clock_deadline_ns_all(QEMUClockType type) 254 { 255 int64_t deadline = -1; 256 QEMUTimerList *timer_list; 257 QEMUClock *clock = qemu_clock_ptr(type); 258 QLIST_FOREACH(timer_list, &clock->timerlists, list) { 259 deadline = qemu_soonest_timeout(deadline, 260 timerlist_deadline_ns(timer_list)); 261 } 262 return deadline; 263 } 264 265 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list) 266 { 267 return timer_list->clock->type; 268 } 269 270 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type) 271 { 272 return main_loop_tlg.tl[type]; 273 } 274 275 void timerlist_notify(QEMUTimerList *timer_list) 276 { 277 if (timer_list->notify_cb) { 278 timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type); 279 } else { 280 qemu_notify_event(); 281 } 282 } 283 284 /* Transition function to convert a nanosecond timeout to ms 285 * This is used where a system does not support ppoll 286 */ 287 int qemu_timeout_ns_to_ms(int64_t ns) 288 { 289 int64_t ms; 290 if (ns < 0) { 291 return -1; 292 } 293 294 if (!ns) { 295 return 0; 296 } 297 298 /* Always round up, because it's better to wait too long than to wait too 299 * little and effectively busy-wait 300 */ 301 ms = DIV_ROUND_UP(ns, SCALE_MS); 302 303 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */ 304 if (ms > (int64_t) INT32_MAX) { 305 ms = INT32_MAX; 306 } 307 308 return (int) ms; 309 } 310 311 312 /* qemu implementation of g_poll which uses a nanosecond timeout but is 313 * otherwise identical to g_poll 314 */ 315 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout) 316 { 317 #ifdef CONFIG_PPOLL 318 if (timeout < 0) { 319 return ppoll((struct pollfd *)fds, nfds, NULL, NULL); 320 } else { 321 struct timespec ts; 322 int64_t tvsec = timeout / 1000000000LL; 323 /* Avoid possibly overflowing and specifying a negative number of 324 * seconds, which would turn a very long timeout into a busy-wait. 325 */ 326 if (tvsec > (int64_t)INT32_MAX) { 327 tvsec = INT32_MAX; 328 } 329 ts.tv_sec = tvsec; 330 ts.tv_nsec = timeout % 1000000000LL; 331 return ppoll((struct pollfd *)fds, nfds, &ts, NULL); 332 } 333 #else 334 return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout)); 335 #endif 336 } 337 338 339 void timer_init_full(QEMUTimer *ts, 340 QEMUTimerListGroup *timer_list_group, QEMUClockType type, 341 int scale, int attributes, 342 QEMUTimerCB *cb, void *opaque) 343 { 344 if (!timer_list_group) { 345 timer_list_group = &main_loop_tlg; 346 } 347 ts->timer_list = timer_list_group->tl[type]; 348 ts->cb = cb; 349 ts->opaque = opaque; 350 ts->scale = scale; 351 ts->attributes = attributes; 352 ts->expire_time = -1; 353 } 354 355 void timer_deinit(QEMUTimer *ts) 356 { 357 assert(ts->expire_time == -1); 358 ts->timer_list = NULL; 359 } 360 361 static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts) 362 { 363 QEMUTimer **pt, *t; 364 365 ts->expire_time = -1; 366 pt = &timer_list->active_timers; 367 for(;;) { 368 t = *pt; 369 if (!t) 370 break; 371 if (t == ts) { 372 atomic_set(pt, t->next); 373 break; 374 } 375 pt = &t->next; 376 } 377 } 378 379 static bool timer_mod_ns_locked(QEMUTimerList *timer_list, 380 QEMUTimer *ts, int64_t expire_time) 381 { 382 QEMUTimer **pt, *t; 383 384 /* add the timer in the sorted list */ 385 pt = &timer_list->active_timers; 386 for (;;) { 387 t = *pt; 388 if (!timer_expired_ns(t, expire_time)) { 389 break; 390 } 391 pt = &t->next; 392 } 393 ts->expire_time = MAX(expire_time, 0); 394 ts->next = *pt; 395 atomic_set(pt, ts); 396 397 return pt == &timer_list->active_timers; 398 } 399 400 static void timerlist_rearm(QEMUTimerList *timer_list) 401 { 402 /* Interrupt execution to force deadline recalculation. */ 403 if (timer_list->clock->type == QEMU_CLOCK_VIRTUAL) { 404 qemu_start_warp_timer(); 405 } 406 timerlist_notify(timer_list); 407 } 408 409 /* stop a timer, but do not dealloc it */ 410 void timer_del(QEMUTimer *ts) 411 { 412 QEMUTimerList *timer_list = ts->timer_list; 413 414 if (timer_list) { 415 qemu_mutex_lock(&timer_list->active_timers_lock); 416 timer_del_locked(timer_list, ts); 417 qemu_mutex_unlock(&timer_list->active_timers_lock); 418 } 419 } 420 421 /* modify the current timer so that it will be fired when current_time 422 >= expire_time. The corresponding callback will be called. */ 423 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time) 424 { 425 QEMUTimerList *timer_list = ts->timer_list; 426 bool rearm; 427 428 qemu_mutex_lock(&timer_list->active_timers_lock); 429 timer_del_locked(timer_list, ts); 430 rearm = timer_mod_ns_locked(timer_list, ts, expire_time); 431 qemu_mutex_unlock(&timer_list->active_timers_lock); 432 433 if (rearm) { 434 timerlist_rearm(timer_list); 435 } 436 } 437 438 /* modify the current timer so that it will be fired when current_time 439 >= expire_time or the current deadline, whichever comes earlier. 440 The corresponding callback will be called. */ 441 void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time) 442 { 443 QEMUTimerList *timer_list = ts->timer_list; 444 bool rearm; 445 446 qemu_mutex_lock(&timer_list->active_timers_lock); 447 if (ts->expire_time == -1 || ts->expire_time > expire_time) { 448 if (ts->expire_time != -1) { 449 timer_del_locked(timer_list, ts); 450 } 451 rearm = timer_mod_ns_locked(timer_list, ts, expire_time); 452 } else { 453 rearm = false; 454 } 455 qemu_mutex_unlock(&timer_list->active_timers_lock); 456 457 if (rearm) { 458 timerlist_rearm(timer_list); 459 } 460 } 461 462 void timer_mod(QEMUTimer *ts, int64_t expire_time) 463 { 464 timer_mod_ns(ts, expire_time * ts->scale); 465 } 466 467 void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time) 468 { 469 timer_mod_anticipate_ns(ts, expire_time * ts->scale); 470 } 471 472 bool timer_pending(QEMUTimer *ts) 473 { 474 return ts->expire_time >= 0; 475 } 476 477 bool timer_expired(QEMUTimer *timer_head, int64_t current_time) 478 { 479 return timer_expired_ns(timer_head, current_time * timer_head->scale); 480 } 481 482 bool timerlist_run_timers(QEMUTimerList *timer_list) 483 { 484 QEMUTimer *ts; 485 int64_t current_time; 486 bool progress = false; 487 QEMUTimerCB *cb; 488 void *opaque; 489 bool need_replay_checkpoint = false; 490 491 if (!atomic_read(&timer_list->active_timers)) { 492 return false; 493 } 494 495 qemu_event_reset(&timer_list->timers_done_ev); 496 if (!timer_list->clock->enabled) { 497 goto out; 498 } 499 500 switch (timer_list->clock->type) { 501 case QEMU_CLOCK_REALTIME: 502 break; 503 default: 504 case QEMU_CLOCK_VIRTUAL: 505 if (replay_mode != REPLAY_MODE_NONE) { 506 /* Checkpoint for virtual clock is redundant in cases where 507 * it's being triggered with only non-EXTERNAL timers, because 508 * these timers don't change guest state directly. 509 * Since it has conditional dependence on specific timers, it is 510 * subject to race conditions and requires special handling. 511 * See below. 512 */ 513 need_replay_checkpoint = true; 514 } 515 break; 516 case QEMU_CLOCK_HOST: 517 if (!replay_checkpoint(CHECKPOINT_CLOCK_HOST)) { 518 goto out; 519 } 520 break; 521 case QEMU_CLOCK_VIRTUAL_RT: 522 if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL_RT)) { 523 goto out; 524 } 525 break; 526 } 527 528 /* 529 * Extract expired timers from active timers list and and process them. 530 * 531 * In rr mode we need "filtered" checkpointing for virtual clock. The 532 * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer, 533 * and that must only be done once since the clock value stays the same. Because 534 * non-EXTERNAL timers may appear in the timers list while it being processed, 535 * the checkpoint can be issued at a time until no timers are left and we are 536 * done". 537 */ 538 current_time = qemu_clock_get_ns(timer_list->clock->type); 539 qemu_mutex_lock(&timer_list->active_timers_lock); 540 while ((ts = timer_list->active_timers)) { 541 if (!timer_expired_ns(ts, current_time)) { 542 /* No expired timers left. The checkpoint can be skipped 543 * if no timers fired or they were all external. 544 */ 545 break; 546 } 547 if (need_replay_checkpoint 548 && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)) { 549 /* once we got here, checkpoint clock only once */ 550 need_replay_checkpoint = false; 551 qemu_mutex_unlock(&timer_list->active_timers_lock); 552 if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL)) { 553 goto out; 554 } 555 qemu_mutex_lock(&timer_list->active_timers_lock); 556 /* The lock was released; start over again in case the list was 557 * modified. 558 */ 559 continue; 560 } 561 562 /* remove timer from the list before calling the callback */ 563 timer_list->active_timers = ts->next; 564 ts->next = NULL; 565 ts->expire_time = -1; 566 cb = ts->cb; 567 opaque = ts->opaque; 568 569 /* run the callback (the timer list can be modified) */ 570 qemu_mutex_unlock(&timer_list->active_timers_lock); 571 cb(opaque); 572 qemu_mutex_lock(&timer_list->active_timers_lock); 573 574 progress = true; 575 } 576 qemu_mutex_unlock(&timer_list->active_timers_lock); 577 578 out: 579 qemu_event_set(&timer_list->timers_done_ev); 580 return progress; 581 } 582 583 bool qemu_clock_run_timers(QEMUClockType type) 584 { 585 return timerlist_run_timers(main_loop_tlg.tl[type]); 586 } 587 588 void timerlistgroup_init(QEMUTimerListGroup *tlg, 589 QEMUTimerListNotifyCB *cb, void *opaque) 590 { 591 QEMUClockType type; 592 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 593 tlg->tl[type] = timerlist_new(type, cb, opaque); 594 } 595 } 596 597 void timerlistgroup_deinit(QEMUTimerListGroup *tlg) 598 { 599 QEMUClockType type; 600 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 601 timerlist_free(tlg->tl[type]); 602 } 603 } 604 605 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg) 606 { 607 QEMUClockType type; 608 bool progress = false; 609 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 610 progress |= timerlist_run_timers(tlg->tl[type]); 611 } 612 return progress; 613 } 614 615 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg) 616 { 617 int64_t deadline = -1; 618 QEMUClockType type; 619 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 620 if (qemu_clock_use_for_deadline(type)) { 621 deadline = qemu_soonest_timeout(deadline, 622 timerlist_deadline_ns(tlg->tl[type])); 623 } 624 } 625 return deadline; 626 } 627 628 int64_t qemu_clock_get_ns(QEMUClockType type) 629 { 630 int64_t now; 631 QEMUClock *clock = qemu_clock_ptr(type); 632 633 switch (type) { 634 case QEMU_CLOCK_REALTIME: 635 return get_clock(); 636 default: 637 case QEMU_CLOCK_VIRTUAL: 638 if (use_icount) { 639 return cpu_get_icount(); 640 } else { 641 return cpu_get_clock(); 642 } 643 case QEMU_CLOCK_HOST: 644 now = REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime()); 645 clock->last = now; 646 return now; 647 case QEMU_CLOCK_VIRTUAL_RT: 648 return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock()); 649 } 650 } 651 652 uint64_t qemu_clock_get_last(QEMUClockType type) 653 { 654 QEMUClock *clock = qemu_clock_ptr(type); 655 return clock->last; 656 } 657 658 void qemu_clock_set_last(QEMUClockType type, uint64_t last) 659 { 660 QEMUClock *clock = qemu_clock_ptr(type); 661 clock->last = last; 662 } 663 664 void init_clocks(QEMUTimerListNotifyCB *notify_cb) 665 { 666 QEMUClockType type; 667 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 668 qemu_clock_init(type, notify_cb); 669 } 670 671 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK 672 prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0); 673 #endif 674 } 675 676 uint64_t timer_expire_time_ns(QEMUTimer *ts) 677 { 678 return timer_pending(ts) ? ts->expire_time : -1; 679 } 680 681 bool qemu_clock_run_all_timers(void) 682 { 683 bool progress = false; 684 QEMUClockType type; 685 686 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 687 if (qemu_clock_use_for_deadline(type)) { 688 progress |= qemu_clock_run_timers(type); 689 } 690 } 691 692 return progress; 693 } 694