qemu-timer.c 16.3 KB
Newer Older
P
Paolo Bonzini 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * QEMU System Emulator
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

25
#include "qemu/main-loop.h"
26
#include "qemu/timer.h"
27

28 29 30
#ifdef CONFIG_POSIX
#include <pthread.h>
#endif
31

32 33 34 35
#ifdef CONFIG_PPOLL
#include <poll.h>
#endif

36 37 38 39
#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
#include <sys/prctl.h>
#endif

P
Paolo Bonzini 已提交
40 41 42
/***********************************************************/
/* timers */

43
typedef struct QEMUClock {
44
    /* We rely on BQL to protect the timerlists */
45
    QLIST_HEAD(, QEMUTimerList) timerlists;
46 47 48

    NotifierList reset_notifiers;
    int64_t last;
49

50
    QEMUClockType type;
51
    bool enabled;
52
} QEMUClock;
P
Paolo Bonzini 已提交
53

54
QEMUTimerListGroup main_loop_tlg;
55
static QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
56 57 58 59 60 61 62 63 64

/* A QEMUTimerList is a list of timers attached to a clock. More
 * than one QEMUTimerList can be attached to each clock, for instance
 * used by different AioContexts / threads. Each clock also has
 * a list of the QEMUTimerLists associated with it, in order that
 * reenabling the clock can call all the notifiers.
 */

struct QEMUTimerList {
65
    QEMUClock *clock;
66
    QemuMutex active_timers_lock;
67 68
    QEMUTimer *active_timers;
    QLIST_ENTRY(QEMUTimerList) list;
69 70
    QEMUTimerListNotifyCB *notify_cb;
    void *notify_opaque;
71 72 73

    /* lightweight method to mark the end of timerlist's running */
    QemuEvent timers_done_ev;
P
Paolo Bonzini 已提交
74 75
};

76 77 78 79 80 81 82 83
/**
 * qemu_clock_ptr:
 * @type: type of clock
 *
 * Translate a clock type into a pointer to QEMUClock object.
 *
 * Returns: a pointer to the QEMUClock object
 */
84
static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
85 86 87 88
{
    return &qemu_clocks[type];
}

89
static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
90 91 92 93
{
    return timer_head && (timer_head->expire_time <= current_time);
}

94 95 96
QEMUTimerList *timerlist_new(QEMUClockType type,
                             QEMUTimerListNotifyCB *cb,
                             void *opaque)
97 98
{
    QEMUTimerList *timer_list;
99
    QEMUClock *clock = qemu_clock_ptr(type);
100 101

    timer_list = g_malloc0(sizeof(QEMUTimerList));
102
    qemu_event_init(&timer_list->timers_done_ev, false);
103
    timer_list->clock = clock;
104 105
    timer_list->notify_cb = cb;
    timer_list->notify_opaque = opaque;
106
    qemu_mutex_init(&timer_list->active_timers_lock);
107 108 109 110 111 112 113 114 115 116
    QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
    return timer_list;
}

void timerlist_free(QEMUTimerList *timer_list)
{
    assert(!timerlist_has_timers(timer_list));
    if (timer_list->clock) {
        QLIST_REMOVE(timer_list, list);
    }
117
    qemu_mutex_destroy(&timer_list->active_timers_lock);
118 119 120
    g_free(timer_list);
}

121
static void qemu_clock_init(QEMUClockType type)
P
Paolo Bonzini 已提交
122
{
123
    QEMUClock *clock = qemu_clock_ptr(type);
124

125 126 127
    /* Assert that the clock of type TYPE has not been initialized yet. */
    assert(main_loop_tlg.tl[type] == NULL);

P
Paolo Bonzini 已提交
128
    clock->type = type;
129
    clock->enabled = true;
130
    clock->last = INT64_MIN;
131
    QLIST_INIT(&clock->timerlists);
132
    notifier_list_init(&clock->reset_notifiers);
133
    main_loop_tlg.tl[type] = timerlist_new(type, NULL, NULL);
P
Paolo Bonzini 已提交
134 135
}

136
bool qemu_clock_use_for_deadline(QEMUClockType type)
137
{
138
    return !(use_icount && (type == QEMU_CLOCK_VIRTUAL));
139 140
}

141
void qemu_clock_notify(QEMUClockType type)
142 143
{
    QEMUTimerList *timer_list;
144
    QEMUClock *clock = qemu_clock_ptr(type);
145 146 147 148 149
    QLIST_FOREACH(timer_list, &clock->timerlists, list) {
        timerlist_notify(timer_list);
    }
}

150 151 152 153 154 155 156
/* Disabling the clock will wait for related timerlists to stop
 * executing qemu_run_timers.  Thus, this functions should not
 * be used from the callback of a timer that is based on @clock.
 * Doing so would cause a deadlock.
 *
 * Caller should hold BQL.
 */
157
void qemu_clock_enable(QEMUClockType type, bool enabled)
P
Paolo Bonzini 已提交
158
{
159
    QEMUClock *clock = qemu_clock_ptr(type);
160
    QEMUTimerList *tl;
161
    bool old = clock->enabled;
P
Paolo Bonzini 已提交
162
    clock->enabled = enabled;
163
    if (enabled && !old) {
164
        qemu_clock_notify(type);
165 166 167 168
    } else if (!enabled && old) {
        QLIST_FOREACH(tl, &clock->timerlists, list) {
            qemu_event_wait(&tl->timers_done_ev);
        }
169
    }
P
Paolo Bonzini 已提交
170 171
}

172
bool timerlist_has_timers(QEMUTimerList *timer_list)
P
Paolo Bonzini 已提交
173
{
174
    return !!timer_list->active_timers;
P
Paolo Bonzini 已提交
175 176
}

177
bool qemu_clock_has_timers(QEMUClockType type)
P
Paolo Bonzini 已提交
178
{
179
    return timerlist_has_timers(
180
        main_loop_tlg.tl[type]);
P
Paolo Bonzini 已提交
181 182
}

183 184
bool timerlist_expired(QEMUTimerList *timer_list)
{
185 186 187 188 189 190 191 192 193 194 195
    int64_t expire_time;

    qemu_mutex_lock(&timer_list->active_timers_lock);
    if (!timer_list->active_timers) {
        qemu_mutex_unlock(&timer_list->active_timers_lock);
        return false;
    }
    expire_time = timer_list->active_timers->expire_time;
    qemu_mutex_unlock(&timer_list->active_timers_lock);

    return expire_time < qemu_clock_get_ns(timer_list->clock->type);
196 197
}

198
bool qemu_clock_expired(QEMUClockType type)
199
{
200
    return timerlist_expired(
201
        main_loop_tlg.tl[type]);
202 203
}

204 205 206 207 208
/*
 * As above, but return -1 for no deadline, and do not cap to 2^32
 * as we know the result is always positive.
 */

209
int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
210 211
{
    int64_t delta;
212
    int64_t expire_time;
213

214
    if (!timer_list->clock->enabled) {
215 216 217
        return -1;
    }

218 219 220 221 222 223 224 225 226 227 228 229 230
    /* The active timers list may be modified before the caller uses our return
     * value but ->notify_cb() is called when the deadline changes.  Therefore
     * the caller should notice the change and there is no race condition.
     */
    qemu_mutex_lock(&timer_list->active_timers_lock);
    if (!timer_list->active_timers) {
        qemu_mutex_unlock(&timer_list->active_timers_lock);
        return -1;
    }
    expire_time = timer_list->active_timers->expire_time;
    qemu_mutex_unlock(&timer_list->active_timers_lock);

    delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
231 232 233 234 235 236 237 238

    if (delta <= 0) {
        return 0;
    }

    return delta;
}

239 240 241 242 243
/* Calculate the soonest deadline across all timerlists attached
 * to the clock. This is used for the icount timeout so we
 * ignore whether or not the clock should be used in deadline
 * calculations.
 */
244
int64_t qemu_clock_deadline_ns_all(QEMUClockType type)
245 246 247
{
    int64_t deadline = -1;
    QEMUTimerList *timer_list;
248
    QEMUClock *clock = qemu_clock_ptr(type);
249 250 251 252 253 254 255
    QLIST_FOREACH(timer_list, &clock->timerlists, list) {
        deadline = qemu_soonest_timeout(deadline,
                                        timerlist_deadline_ns(timer_list));
    }
    return deadline;
}

256
QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
257
{
258
    return timer_list->clock->type;
259 260
}

261
QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
262
{
263
    return main_loop_tlg.tl[type];
264 265
}

266 267 268 269 270 271 272 273 274
void timerlist_notify(QEMUTimerList *timer_list)
{
    if (timer_list->notify_cb) {
        timer_list->notify_cb(timer_list->notify_opaque);
    } else {
        qemu_notify_event();
    }
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
/* Transition function to convert a nanosecond timeout to ms
 * This is used where a system does not support ppoll
 */
int qemu_timeout_ns_to_ms(int64_t ns)
{
    int64_t ms;
    if (ns < 0) {
        return -1;
    }

    if (!ns) {
        return 0;
    }

    /* Always round up, because it's better to wait too long than to wait too
     * little and effectively busy-wait
     */
    ms = (ns + SCALE_MS - 1) / SCALE_MS;

    /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
    if (ms > (int64_t) INT32_MAX) {
        ms = INT32_MAX;
    }

    return (int) ms;
}


303 304 305 306 307 308 309 310 311 312
/* qemu implementation of g_poll which uses a nanosecond timeout but is
 * otherwise identical to g_poll
 */
int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
{
#ifdef CONFIG_PPOLL
    if (timeout < 0) {
        return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
    } else {
        struct timespec ts;
313 314 315 316 317 318 319 320
        int64_t tvsec = timeout / 1000000000LL;
        /* Avoid possibly overflowing and specifying a negative number of
         * seconds, which would turn a very long timeout into a busy-wait.
         */
        if (tvsec > (int64_t)INT32_MAX) {
            tvsec = INT32_MAX;
        }
        ts.tv_sec = tvsec;
321 322 323 324 325 326 327 328 329
        ts.tv_nsec = timeout % 1000000000LL;
        return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
    }
#else
    return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
#endif
}


330 331 332
void timer_init_tl(QEMUTimer *ts,
                   QEMUTimerList *timer_list, int scale,
                   QEMUTimerCB *cb, void *opaque)
P
Paolo Bonzini 已提交
333
{
334
    ts->timer_list = timer_list;
P
Paolo Bonzini 已提交
335 336
    ts->cb = cb;
    ts->opaque = opaque;
337
    ts->scale = scale;
338
    ts->expire_time = -1;
339 340
}

341 342 343 344 345 346
void timer_deinit(QEMUTimer *ts)
{
    assert(ts->expire_time == -1);
    ts->timer_list = NULL;
}

347
void timer_free(QEMUTimer *ts)
P
Paolo Bonzini 已提交
348
{
349
    g_free(ts);
P
Paolo Bonzini 已提交
350 351
}

352
static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
P
Paolo Bonzini 已提交
353 354 355
{
    QEMUTimer **pt, *t;

356
    ts->expire_time = -1;
357
    pt = &timer_list->active_timers;
P
Paolo Bonzini 已提交
358 359 360 361 362 363 364 365 366 367 368 369
    for(;;) {
        t = *pt;
        if (!t)
            break;
        if (t == ts) {
            *pt = t->next;
            break;
        }
        pt = &t->next;
    }
}

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
static bool timer_mod_ns_locked(QEMUTimerList *timer_list,
                                QEMUTimer *ts, int64_t expire_time)
{
    QEMUTimer **pt, *t;

    /* add the timer in the sorted list */
    pt = &timer_list->active_timers;
    for (;;) {
        t = *pt;
        if (!timer_expired_ns(t, expire_time)) {
            break;
        }
        pt = &t->next;
    }
    ts->expire_time = MAX(expire_time, 0);
    ts->next = *pt;
    *pt = ts;

    return pt == &timer_list->active_timers;
}

static void timerlist_rearm(QEMUTimerList *timer_list)
{
    /* Interrupt execution to force deadline recalculation.  */
    qemu_clock_warp(timer_list->clock->type);
    timerlist_notify(timer_list);
}

398 399 400 401 402
/* stop a timer, but do not dealloc it */
void timer_del(QEMUTimer *ts)
{
    QEMUTimerList *timer_list = ts->timer_list;

403 404 405 406 407
    if (timer_list) {
        qemu_mutex_lock(&timer_list->active_timers_lock);
        timer_del_locked(timer_list, ts);
        qemu_mutex_unlock(&timer_list->active_timers_lock);
    }
408 409
}

P
Paolo Bonzini 已提交
410 411
/* modify the current timer so that it will be fired when current_time
   >= expire_time. The corresponding callback will be called. */
412
void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
P
Paolo Bonzini 已提交
413
{
414
    QEMUTimerList *timer_list = ts->timer_list;
415
    bool rearm;
P
Paolo Bonzini 已提交
416

417 418
    qemu_mutex_lock(&timer_list->active_timers_lock);
    timer_del_locked(timer_list, ts);
419
    rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
420
    qemu_mutex_unlock(&timer_list->active_timers_lock);
P
Paolo Bonzini 已提交
421

422 423
    if (rearm) {
        timerlist_rearm(timer_list);
P
Paolo Bonzini 已提交
424 425 426
    }
}

427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
/* modify the current timer so that it will be fired when current_time
   >= expire_time or the current deadline, whichever comes earlier.
   The corresponding callback will be called. */
void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)
{
    QEMUTimerList *timer_list = ts->timer_list;
    bool rearm;

    qemu_mutex_lock(&timer_list->active_timers_lock);
    if (ts->expire_time == -1 || ts->expire_time > expire_time) {
        if (ts->expire_time != -1) {
            timer_del_locked(timer_list, ts);
        }
        rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
    } else {
        rearm = false;
    }
    qemu_mutex_unlock(&timer_list->active_timers_lock);

    if (rearm) {
        timerlist_rearm(timer_list);
    }
}

451
void timer_mod(QEMUTimer *ts, int64_t expire_time)
452
{
453
    timer_mod_ns(ts, expire_time * ts->scale);
454 455
}

456 457 458 459 460
void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time)
{
    timer_mod_anticipate_ns(ts, expire_time * ts->scale);
}

461
bool timer_pending(QEMUTimer *ts)
P
Paolo Bonzini 已提交
462
{
463
    return ts->expire_time >= 0;
P
Paolo Bonzini 已提交
464 465
}

466
bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
P
Paolo Bonzini 已提交
467
{
468
    return timer_expired_ns(timer_head, current_time * timer_head->scale);
P
Paolo Bonzini 已提交
469 470
}

471
bool timerlist_run_timers(QEMUTimerList *timer_list)
P
Paolo Bonzini 已提交
472
{
473
    QEMUTimer *ts;
P
Paolo Bonzini 已提交
474
    int64_t current_time;
475
    bool progress = false;
476 477 478
    QEMUTimerCB *cb;
    void *opaque;

479
    qemu_event_reset(&timer_list->timers_done_ev);
480
    if (!timer_list->clock->enabled) {
481
        goto out;
482
    }
P
Paolo Bonzini 已提交
483

484
    current_time = qemu_clock_get_ns(timer_list->clock->type);
P
Paolo Bonzini 已提交
485
    for(;;) {
486
        qemu_mutex_lock(&timer_list->active_timers_lock);
487
        ts = timer_list->active_timers;
488
        if (!timer_expired_ns(ts, current_time)) {
489
            qemu_mutex_unlock(&timer_list->active_timers_lock);
P
Paolo Bonzini 已提交
490
            break;
491
        }
492

P
Paolo Bonzini 已提交
493
        /* remove timer from the list before calling the callback */
494
        timer_list->active_timers = ts->next;
P
Paolo Bonzini 已提交
495
        ts->next = NULL;
496
        ts->expire_time = -1;
497 498 499
        cb = ts->cb;
        opaque = ts->opaque;
        qemu_mutex_unlock(&timer_list->active_timers_lock);
P
Paolo Bonzini 已提交
500 501

        /* run the callback (the timer list can be modified) */
502
        cb(opaque);
503
        progress = true;
P
Paolo Bonzini 已提交
504
    }
505 506 507

out:
    qemu_event_set(&timer_list->timers_done_ev);
508
    return progress;
P
Paolo Bonzini 已提交
509 510
}

511 512
bool qemu_clock_run_timers(QEMUClockType type)
{
513
    return timerlist_run_timers(main_loop_tlg.tl[type]);
514 515
}

516 517
void timerlistgroup_init(QEMUTimerListGroup *tlg,
                         QEMUTimerListNotifyCB *cb, void *opaque)
518 519 520
{
    QEMUClockType type;
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
521
        tlg->tl[type] = timerlist_new(type, cb, opaque);
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
    }
}

void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
{
    QEMUClockType type;
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
        timerlist_free(tlg->tl[type]);
    }
}

bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
{
    QEMUClockType type;
    bool progress = false;
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
        progress |= timerlist_run_timers(tlg->tl[type]);
    }
    return progress;
}

int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
{
    int64_t deadline = -1;
    QEMUClockType type;
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
548
        if (qemu_clock_use_for_deadline(tlg->tl[type]->clock->type)) {
549 550 551 552 553 554 555 556
            deadline = qemu_soonest_timeout(deadline,
                                            timerlist_deadline_ns(
                                                tlg->tl[type]));
        }
    }
    return deadline;
}

557
int64_t qemu_clock_get_ns(QEMUClockType type)
P
Paolo Bonzini 已提交
558
{
559
    int64_t now, last;
560
    QEMUClock *clock = qemu_clock_ptr(type);
561

562
    switch (type) {
P
Paolo Bonzini 已提交
563 564 565 566 567 568 569 570 571 572
    case QEMU_CLOCK_REALTIME:
        return get_clock();
    default:
    case QEMU_CLOCK_VIRTUAL:
        if (use_icount) {
            return cpu_get_icount();
        } else {
            return cpu_get_clock();
        }
    case QEMU_CLOCK_HOST:
573 574 575
        now = get_clock_realtime();
        last = clock->last;
        clock->last = now;
576
        if (now < last || now > (last + get_max_clock_jump())) {
577 578 579
            notifier_list_notify(&clock->reset_notifiers, &now);
        }
        return now;
580 581
    case QEMU_CLOCK_VIRTUAL_RT:
        return cpu_get_clock();
P
Paolo Bonzini 已提交
582 583 584
    }
}

585 586 587 588
void qemu_clock_register_reset_notifier(QEMUClockType type,
                                        Notifier *notifier)
{
    QEMUClock *clock = qemu_clock_ptr(type);
589 590 591
    notifier_list_add(&clock->reset_notifiers, notifier);
}

592 593
void qemu_clock_unregister_reset_notifier(QEMUClockType type,
                                          Notifier *notifier)
594
{
P
Paolo Bonzini 已提交
595
    notifier_remove(notifier);
596 597
}

P
Paolo Bonzini 已提交
598 599
void init_clocks(void)
{
600 601
    QEMUClockType type;
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
602
        qemu_clock_init(type);
603
    }
604

605 606 607
#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
    prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
#endif
P
Paolo Bonzini 已提交
608 609
}

610
uint64_t timer_expire_time_ns(QEMUTimer *ts)
P
Paolo Bonzini 已提交
611
{
612
    return timer_pending(ts) ? ts->expire_time : -1;
P
Paolo Bonzini 已提交
613 614
}

615
bool qemu_clock_run_all_timers(void)
P
Paolo Bonzini 已提交
616
{
617
    bool progress = false;
618
    QEMUClockType type;
A
Alex Bligh 已提交
619

620
    for (type = 0; type < QEMU_CLOCK_MAX; type++) {
621
        progress |= qemu_clock_run_timers(type);
622
    }
623

624
    return progress;
P
Paolo Bonzini 已提交
625
}