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 CONFIG_PPOLL 37 #include <poll.h> 38 #endif 39 40 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK 41 #include <sys/prctl.h> 42 #endif 43 44 /***********************************************************/ 45 /* timers */ 46 47 typedef struct QEMUClock { 48 /* We rely on BQL to protect the timerlists */ 49 QLIST_HEAD(, QEMUTimerList) timerlists; 50 51 NotifierList reset_notifiers; 52 int64_t last; 53 54 QEMUClockType type; 55 bool enabled; 56 } QEMUClock; 57 58 QEMUTimerListGroup main_loop_tlg; 59 QEMUClock qemu_clocks[QEMU_CLOCK_MAX]; 60 61 /* A QEMUTimerList is a list of timers attached to a clock. More 62 * than one QEMUTimerList can be attached to each clock, for instance 63 * used by different AioContexts / threads. Each clock also has 64 * a list of the QEMUTimerLists associated with it, in order that 65 * reenabling the clock can call all the notifiers. 66 */ 67 68 struct QEMUTimerList { 69 QEMUClock *clock; 70 QemuMutex active_timers_lock; 71 QEMUTimer *active_timers; 72 QLIST_ENTRY(QEMUTimerList) list; 73 QEMUTimerListNotifyCB *notify_cb; 74 void *notify_opaque; 75 76 /* lightweight method to mark the end of timerlist's running */ 77 QemuEvent timers_done_ev; 78 }; 79 80 /** 81 * qemu_clock_ptr: 82 * @type: type of clock 83 * 84 * Translate a clock type into a pointer to QEMUClock object. 85 * 86 * Returns: a pointer to the QEMUClock object 87 */ 88 static inline QEMUClock *qemu_clock_ptr(QEMUClockType type) 89 { 90 return &qemu_clocks[type]; 91 } 92 93 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time) 94 { 95 return timer_head && (timer_head->expire_time <= current_time); 96 } 97 98 QEMUTimerList *timerlist_new(QEMUClockType type, 99 QEMUTimerListNotifyCB *cb, 100 void *opaque) 101 { 102 QEMUTimerList *timer_list; 103 QEMUClock *clock = qemu_clock_ptr(type); 104 105 timer_list = g_malloc0(sizeof(QEMUTimerList)); 106 qemu_event_init(&timer_list->timers_done_ev, false); 107 timer_list->clock = clock; 108 timer_list->notify_cb = cb; 109 timer_list->notify_opaque = opaque; 110 qemu_mutex_init(&timer_list->active_timers_lock); 111 QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list); 112 return timer_list; 113 } 114 115 void timerlist_free(QEMUTimerList *timer_list) 116 { 117 assert(!timerlist_has_timers(timer_list)); 118 if (timer_list->clock) { 119 QLIST_REMOVE(timer_list, list); 120 } 121 qemu_mutex_destroy(&timer_list->active_timers_lock); 122 g_free(timer_list); 123 } 124 125 static void qemu_clock_init(QEMUClockType type) 126 { 127 QEMUClock *clock = qemu_clock_ptr(type); 128 129 clock->type = type; 130 clock->enabled = true; 131 clock->last = INT64_MIN; 132 QLIST_INIT(&clock->timerlists); 133 notifier_list_init(&clock->reset_notifiers); 134 main_loop_tlg.tl[type] = timerlist_new(type, NULL, 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 !!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 qemu_mutex_lock(&timer_list->active_timers_lock); 189 if (!timer_list->active_timers) { 190 qemu_mutex_unlock(&timer_list->active_timers_lock); 191 return false; 192 } 193 expire_time = timer_list->active_timers->expire_time; 194 qemu_mutex_unlock(&timer_list->active_timers_lock); 195 196 return expire_time < qemu_clock_get_ns(timer_list->clock->type); 197 } 198 199 bool qemu_clock_expired(QEMUClockType type) 200 { 201 return timerlist_expired( 202 main_loop_tlg.tl[type]); 203 } 204 205 /* 206 * As above, but return -1 for no deadline, and do not cap to 2^32 207 * as we know the result is always positive. 208 */ 209 210 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) 211 { 212 int64_t delta; 213 int64_t expire_time; 214 215 if (!timer_list->clock->enabled) { 216 return -1; 217 } 218 219 /* The active timers list may be modified before the caller uses our return 220 * value but ->notify_cb() is called when the deadline changes. Therefore 221 * the caller should notice the change and there is no race condition. 222 */ 223 qemu_mutex_lock(&timer_list->active_timers_lock); 224 if (!timer_list->active_timers) { 225 qemu_mutex_unlock(&timer_list->active_timers_lock); 226 return -1; 227 } 228 expire_time = timer_list->active_timers->expire_time; 229 qemu_mutex_unlock(&timer_list->active_timers_lock); 230 231 delta = expire_time - qemu_clock_get_ns(timer_list->clock->type); 232 233 if (delta <= 0) { 234 return 0; 235 } 236 237 return delta; 238 } 239 240 /* Calculate the soonest deadline across all timerlists attached 241 * to the clock. This is used for the icount timeout so we 242 * ignore whether or not the clock should be used in deadline 243 * calculations. 244 */ 245 int64_t qemu_clock_deadline_ns_all(QEMUClockType type) 246 { 247 int64_t deadline = -1; 248 QEMUTimerList *timer_list; 249 QEMUClock *clock = qemu_clock_ptr(type); 250 QLIST_FOREACH(timer_list, &clock->timerlists, list) { 251 deadline = qemu_soonest_timeout(deadline, 252 timerlist_deadline_ns(timer_list)); 253 } 254 return deadline; 255 } 256 257 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list) 258 { 259 return timer_list->clock->type; 260 } 261 262 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type) 263 { 264 return main_loop_tlg.tl[type]; 265 } 266 267 void timerlist_notify(QEMUTimerList *timer_list) 268 { 269 if (timer_list->notify_cb) { 270 timer_list->notify_cb(timer_list->notify_opaque); 271 } else { 272 qemu_notify_event(); 273 } 274 } 275 276 /* Transition function to convert a nanosecond timeout to ms 277 * This is used where a system does not support ppoll 278 */ 279 int qemu_timeout_ns_to_ms(int64_t ns) 280 { 281 int64_t ms; 282 if (ns < 0) { 283 return -1; 284 } 285 286 if (!ns) { 287 return 0; 288 } 289 290 /* Always round up, because it's better to wait too long than to wait too 291 * little and effectively busy-wait 292 */ 293 ms = (ns + SCALE_MS - 1) / SCALE_MS; 294 295 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */ 296 if (ms > (int64_t) INT32_MAX) { 297 ms = INT32_MAX; 298 } 299 300 return (int) ms; 301 } 302 303 304 /* qemu implementation of g_poll which uses a nanosecond timeout but is 305 * otherwise identical to g_poll 306 */ 307 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout) 308 { 309 #ifdef CONFIG_PPOLL 310 if (timeout < 0) { 311 return ppoll((struct pollfd *)fds, nfds, NULL, NULL); 312 } else { 313 struct timespec ts; 314 ts.tv_sec = timeout / 1000000000LL; 315 ts.tv_nsec = timeout % 1000000000LL; 316 return ppoll((struct pollfd *)fds, nfds, &ts, NULL); 317 } 318 #else 319 return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout)); 320 #endif 321 } 322 323 324 void timer_init(QEMUTimer *ts, 325 QEMUTimerList *timer_list, int scale, 326 QEMUTimerCB *cb, void *opaque) 327 { 328 ts->timer_list = timer_list; 329 ts->cb = cb; 330 ts->opaque = opaque; 331 ts->scale = scale; 332 ts->expire_time = -1; 333 } 334 335 void timer_free(QEMUTimer *ts) 336 { 337 g_free(ts); 338 } 339 340 static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts) 341 { 342 QEMUTimer **pt, *t; 343 344 ts->expire_time = -1; 345 pt = &timer_list->active_timers; 346 for(;;) { 347 t = *pt; 348 if (!t) 349 break; 350 if (t == ts) { 351 *pt = t->next; 352 break; 353 } 354 pt = &t->next; 355 } 356 } 357 358 /* stop a timer, but do not dealloc it */ 359 void timer_del(QEMUTimer *ts) 360 { 361 QEMUTimerList *timer_list = ts->timer_list; 362 363 qemu_mutex_lock(&timer_list->active_timers_lock); 364 timer_del_locked(timer_list, ts); 365 qemu_mutex_unlock(&timer_list->active_timers_lock); 366 } 367 368 /* modify the current timer so that it will be fired when current_time 369 >= expire_time. The corresponding callback will be called. */ 370 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time) 371 { 372 QEMUTimerList *timer_list = ts->timer_list; 373 QEMUTimer **pt, *t; 374 375 qemu_mutex_lock(&timer_list->active_timers_lock); 376 timer_del_locked(timer_list, ts); 377 378 /* add the timer in the sorted list */ 379 pt = &timer_list->active_timers; 380 for(;;) { 381 t = *pt; 382 if (!timer_expired_ns(t, expire_time)) { 383 break; 384 } 385 pt = &t->next; 386 } 387 ts->expire_time = MAX(expire_time, 0); 388 ts->next = *pt; 389 *pt = ts; 390 qemu_mutex_unlock(&timer_list->active_timers_lock); 391 392 /* Rearm if necessary */ 393 if (pt == &timer_list->active_timers) { 394 /* Interrupt execution to force deadline recalculation. */ 395 qemu_clock_warp(timer_list->clock->type); 396 timerlist_notify(timer_list); 397 } 398 } 399 400 void timer_mod(QEMUTimer *ts, int64_t expire_time) 401 { 402 timer_mod_ns(ts, expire_time * ts->scale); 403 } 404 405 bool timer_pending(QEMUTimer *ts) 406 { 407 return ts->expire_time >= 0; 408 } 409 410 bool timer_expired(QEMUTimer *timer_head, int64_t current_time) 411 { 412 return timer_expired_ns(timer_head, current_time * timer_head->scale); 413 } 414 415 bool timerlist_run_timers(QEMUTimerList *timer_list) 416 { 417 QEMUTimer *ts; 418 int64_t current_time; 419 bool progress = false; 420 QEMUTimerCB *cb; 421 void *opaque; 422 423 qemu_event_reset(&timer_list->timers_done_ev); 424 if (!timer_list->clock->enabled) { 425 goto out; 426 } 427 428 current_time = qemu_clock_get_ns(timer_list->clock->type); 429 for(;;) { 430 qemu_mutex_lock(&timer_list->active_timers_lock); 431 ts = timer_list->active_timers; 432 if (!timer_expired_ns(ts, current_time)) { 433 qemu_mutex_unlock(&timer_list->active_timers_lock); 434 break; 435 } 436 437 /* remove timer from the list before calling the callback */ 438 timer_list->active_timers = ts->next; 439 ts->next = NULL; 440 ts->expire_time = -1; 441 cb = ts->cb; 442 opaque = ts->opaque; 443 qemu_mutex_unlock(&timer_list->active_timers_lock); 444 445 /* run the callback (the timer list can be modified) */ 446 cb(opaque); 447 progress = true; 448 } 449 450 out: 451 qemu_event_set(&timer_list->timers_done_ev); 452 return progress; 453 } 454 455 bool qemu_clock_run_timers(QEMUClockType type) 456 { 457 return timerlist_run_timers(main_loop_tlg.tl[type]); 458 } 459 460 void timerlistgroup_init(QEMUTimerListGroup *tlg, 461 QEMUTimerListNotifyCB *cb, void *opaque) 462 { 463 QEMUClockType type; 464 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 465 tlg->tl[type] = timerlist_new(type, cb, opaque); 466 } 467 } 468 469 void timerlistgroup_deinit(QEMUTimerListGroup *tlg) 470 { 471 QEMUClockType type; 472 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 473 timerlist_free(tlg->tl[type]); 474 } 475 } 476 477 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg) 478 { 479 QEMUClockType type; 480 bool progress = false; 481 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 482 progress |= timerlist_run_timers(tlg->tl[type]); 483 } 484 return progress; 485 } 486 487 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg) 488 { 489 int64_t deadline = -1; 490 QEMUClockType type; 491 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 492 if (qemu_clock_use_for_deadline(tlg->tl[type]->clock->type)) { 493 deadline = qemu_soonest_timeout(deadline, 494 timerlist_deadline_ns( 495 tlg->tl[type])); 496 } 497 } 498 return deadline; 499 } 500 501 int64_t qemu_clock_get_ns(QEMUClockType type) 502 { 503 int64_t now, last; 504 QEMUClock *clock = qemu_clock_ptr(type); 505 506 switch (type) { 507 case QEMU_CLOCK_REALTIME: 508 return get_clock(); 509 default: 510 case QEMU_CLOCK_VIRTUAL: 511 if (use_icount) { 512 return cpu_get_icount(); 513 } else { 514 return cpu_get_clock(); 515 } 516 case QEMU_CLOCK_HOST: 517 now = get_clock_realtime(); 518 last = clock->last; 519 clock->last = now; 520 if (now < last) { 521 notifier_list_notify(&clock->reset_notifiers, &now); 522 } 523 return now; 524 } 525 } 526 527 void qemu_clock_register_reset_notifier(QEMUClockType type, 528 Notifier *notifier) 529 { 530 QEMUClock *clock = qemu_clock_ptr(type); 531 notifier_list_add(&clock->reset_notifiers, notifier); 532 } 533 534 void qemu_clock_unregister_reset_notifier(QEMUClockType type, 535 Notifier *notifier) 536 { 537 notifier_remove(notifier); 538 } 539 540 void init_clocks(void) 541 { 542 QEMUClockType type; 543 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 544 qemu_clock_init(type); 545 } 546 547 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK 548 prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0); 549 #endif 550 } 551 552 uint64_t timer_expire_time_ns(QEMUTimer *ts) 553 { 554 return timer_pending(ts) ? ts->expire_time : -1; 555 } 556 557 bool qemu_clock_run_all_timers(void) 558 { 559 bool progress = false; 560 QEMUClockType type; 561 562 for (type = 0; type < QEMU_CLOCK_MAX; type++) { 563 progress |= qemu_clock_run_timers(type); 564 } 565 566 return progress; 567 } 568