Lines Matching +full:timeout +full:- +full:active +full:- +full:ms
4 * Copyright (c) 2003-2008 Fabrice Bellard
26 #include "qemu/main-loop.h"
29 #include "sysemu/cpu-timers.h"
93 return timer_head && (timer_head->expire_time <= current_time);
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);
116 if (timer_list->clock) {
119 qemu_mutex_destroy(&timer_list->active_timers_lock);
130 clock->type = type;
131 clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true);
132 QLIST_INIT(&clock->timerlists);
145 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
161 bool old = clock->enabled;
162 clock->enabled = enabled;
166 QLIST_FOREACH(tl, &clock->timerlists, list) {
167 qemu_event_wait(&tl->timers_done_ev);
174 return !!qatomic_read(&timer_list->active_timers);
187 if (!qatomic_read(&timer_list->active_timers)) {
191 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
192 if (!timer_list->active_timers) {
195 expire_time = timer_list->active_timers->expire_time;
198 return expire_time <= qemu_clock_get_ns(timer_list->clock->type);
208 * As above, but return -1 for no deadline, and do not cap to 2^32
217 if (!qatomic_read(&timer_list->active_timers)) {
218 return -1;
221 if (!timer_list->clock->enabled) {
222 return -1;
225 /* The active timers list may be modified before the caller uses our return
226 * value but ->notify_cb() is called when the deadline changes. Therefore
229 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
230 if (!timer_list->active_timers) {
231 return -1;
233 expire_time = timer_list->active_timers->expire_time;
236 delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
246 * to the clock. This is used for the icount timeout so we
252 int64_t deadline = -1;
259 if (!clock->enabled) {
260 return -1;
263 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
264 if (!qatomic_read(&timer_list->active_timers)) {
267 qemu_mutex_lock(&timer_list->active_timers_lock);
268 ts = timer_list->active_timers;
270 while (ts && (ts->attributes & ~attr_mask)) {
271 ts = ts->next;
274 qemu_mutex_unlock(&timer_list->active_timers_lock);
277 expire_time = ts->expire_time;
278 qemu_mutex_unlock(&timer_list->active_timers_lock);
280 delta = expire_time - qemu_clock_get_ns(type);
291 if (timer_list->notify_cb) {
292 timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type);
298 /* Transition function to convert a nanosecond timeout to ms
303 int64_t ms;
305 return -1;
313 * little and effectively busy-wait
315 ms = DIV_ROUND_UP(ns, SCALE_MS);
318 return MIN(ms, INT32_MAX);
322 /* qemu implementation of g_poll which uses a nanosecond timeout but is
325 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
328 if (timeout < 0) {
332 int64_t tvsec = timeout / 1000000000LL;
334 * seconds, which would turn a very long timeout into a busy-wait.
340 ts.tv_nsec = timeout % 1000000000LL;
344 return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
357 ts->timer_list = timer_list_group->tl[type];
358 ts->cb = cb;
359 ts->opaque = opaque;
360 ts->scale = scale;
361 ts->attributes = attributes;
362 ts->expire_time = -1;
367 assert(ts->expire_time == -1);
368 ts->timer_list = NULL;
375 ts->expire_time = -1;
376 pt = &timer_list->active_timers;
382 qatomic_set(pt, t->next);
385 pt = &t->next;
395 pt = &timer_list->active_timers;
401 pt = &t->next;
403 ts->expire_time = MAX(expire_time, 0);
404 ts->next = *pt;
407 return pt == &timer_list->active_timers;
418 QEMUTimerList *timer_list = ts->timer_list;
421 qemu_mutex_lock(&timer_list->active_timers_lock);
423 qemu_mutex_unlock(&timer_list->active_timers_lock);
431 QEMUTimerList *timer_list = ts->timer_list;
434 qemu_mutex_lock(&timer_list->active_timers_lock);
437 qemu_mutex_unlock(&timer_list->active_timers_lock);
449 QEMUTimerList *timer_list = ts->timer_list;
452 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
453 if (ts->expire_time == -1 || ts->expire_time > expire_time) {
454 if (ts->expire_time != -1) {
469 timer_mod_ns(ts, expire_time * ts->scale);
474 timer_mod_anticipate_ns(ts, expire_time * ts->scale);
479 return ts->expire_time >= 0;
484 return timer_expired_ns(timer_head, current_time * timer_head->scale);
495 if (!qatomic_read(&timer_list->active_timers)) {
499 qemu_event_reset(&timer_list->timers_done_ev);
500 if (!timer_list->clock->enabled) {
504 switch (timer_list->clock->type) {
523 * Extract expired timers from active timers list and process them.
526 * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer,
528 * non-EXTERNAL timers may appear in the timers list while it being processed,
532 current_time = qemu_clock_get_ns(timer_list->clock->type);
533 qemu_mutex_lock(&timer_list->active_timers_lock);
534 while ((ts = timer_list->active_timers)) {
542 * it's being triggered with only non-EXTERNAL timers, because
546 && timer_list->clock->type == QEMU_CLOCK_VIRTUAL
547 && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)
549 qemu_mutex_unlock(&timer_list->active_timers_lock);
554 timer_list->active_timers = ts->next;
555 ts->next = NULL;
556 ts->expire_time = -1;
557 cb = ts->cb;
558 opaque = ts->opaque;
561 qemu_mutex_unlock(&timer_list->active_timers_lock);
563 qemu_mutex_lock(&timer_list->active_timers_lock);
567 qemu_mutex_unlock(&timer_list->active_timers_lock);
570 qemu_event_set(&timer_list->timers_done_ev);
584 tlg->tl[type] = timerlist_new(type, cb, opaque);
592 timerlist_free(tlg->tl[type]);
601 progress |= timerlist_run_timers(tlg->tl[type]);
608 int64_t deadline = -1;
613 timerlist_deadline_ns(tlg->tl[type]));
653 return timer_pending(ts) ? ts->expire_time : -1;
685 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
690 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);