void DBus_RemoveTimeout(DBusTimeout *timeout, void *data) { Tcl_TimerToken token; token = dbus_timeout_get_data(timeout); Tcl_DeleteTimerHandler(token); }
/** * Computes the time until the next timeout expiration. * @note Interface lock must be held. * @return The time in milliseconds until the next expiration, * or -1 if there are no pending timeouts. */ static int next_timeout(intf_thread_t *intf) { intf_sys_t *sys = intf->p_sys; mtime_t next_timeout = LAST_MDATE; unsigned count = vlc_array_count(sys->p_timeouts); for (unsigned i = 0; i < count; i++) { DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i); if (!dbus_timeout_get_enabled(to)) continue; mtime_t *expiry = dbus_timeout_get_data(to); if (next_timeout > *expiry) next_timeout = *expiry; } if (next_timeout >= LAST_MDATE) return -1; next_timeout /= 1000; if (next_timeout > INT_MAX) return INT_MAX; return (int)next_timeout; }
/** * UpdateTimeouts() updates the remaining time for each timeout and * returns how much time is left until the next timeout. * * This function must be called with p_sys->lock locked * * @return int The time remaining until the next timeout, in milliseconds * or -1 if there are no timeouts * * @param intf_thread_t *p_intf This interface thread's state * @param mtime_t i_loop_interval The time which has elapsed since the last * call to this function */ static int UpdateTimeouts( intf_thread_t *p_intf, mtime_t i_loop_interval ) { intf_sys_t *p_sys = p_intf->p_sys; mtime_t i_next_timeout = LAST_MDATE; unsigned int i_timeouts = vlc_array_count( p_sys->p_timeouts ); if( 0 == i_timeouts ) return -1; for( unsigned int i = 0; i < i_timeouts; i++ ) { timeout_info_t *p_info = NULL; DBusTimeout *p_timeout = NULL; mtime_t i_interval = 0; p_timeout = vlc_array_item_at_index( p_sys->p_timeouts, i ); i_interval = dbus_timeout_get_interval( p_timeout ) * 1000; /* µs */ p_info = (timeout_info_t*) dbus_timeout_get_data( p_timeout ); p_info->i_remaining -= __MAX( 0, i_loop_interval ) % i_interval; if( !dbus_timeout_get_enabled( p_timeout ) ) continue; /* The correct poll timeout value is the shortest one * in the dbus timeouts list */ i_next_timeout = __MIN( i_next_timeout, __MAX( 0, p_info->i_remaining ) ); } /* next timeout in milliseconds */ return i_next_timeout / 1000; }
static void connection_setup_remove_timeout (ConnectionSetup *cs, DBusTimeout *timeout) { TimeoutHandler *handler = dbus_timeout_get_data (timeout); if (handler != NULL) timeout_handler_destroy_source (handler); }
static void timeout_toggle(DBusTimeout *timeout, void *data) { struct timeout *t; (void)data; lem_debug("timeout = %p, interval = %d, enabled = %s", (void *)timeout, dbus_timeout_get_interval(timeout), dbus_timeout_get_enabled(timeout) ? "true" : "false"); t = dbus_timeout_get_data(timeout); if (dbus_timeout_get_enabled(timeout)) { ev_tstamp interval = ((ev_tstamp)dbus_timeout_get_interval(timeout))/1000.0; if (ev_is_active(&t->ev)) ev_timer_stop(EV_G_ &t->ev); ev_timer_set(&t->ev, interval, interval); ev_timer_start(EV_G_ &t->ev); } else ev_timer_stop(EV_G_ &t->ev); }
static void toggle_timeout(DBusTimeout *timeout, void *data){ /* reset expiration data */ struct timeval *expires = dbus_timeout_get_data(timeout); timer_remove_by_data (timeout); asdbus_set_dbus_timer (expires, timeout); }
static void timeout_toggled(DBusTimeout *dbus_timeout, AVAHI_GCC_UNUSED void *userdata) { TimeoutData *timeout; assert(dbus_timeout); timeout = dbus_timeout_get_data(dbus_timeout); assert(timeout); update_timeout(timeout); }
/** * Callback for removing D-Bus timeout. */ static void cdbus_callback_remove_timeout(DBusTimeout *timeout, void *data) { session_t *ps = data; timeout_t *ptmout = dbus_timeout_get_data(timeout); assert(ptmout); if (ptmout) timeout_drop(ps, ptmout); }
static void weston_dbus_remove_timeout(DBusTimeout *timeout, void *data) { struct wl_event_source *s; s = dbus_timeout_get_data(timeout); if (!s) return; wl_event_source_remove(s); }
/* DBusRemoveTimeoutFunction callback for pa mainloop */ static void remove_timeout(DBusTimeout *timeout, void *data) { pa_dbus_wrap_connection *c = data; pa_time_event *ev; pa_assert(timeout); pa_assert(c); if ((ev = dbus_timeout_get_data(timeout))) c->mainloop->time_free(ev); }
static void weston_dbus_toggle_timeout(DBusTimeout *timeout, void *data) { struct wl_event_source *s; s = dbus_timeout_get_data(timeout); if (!s) return; weston_dbus_adjust_timeout(timeout, s); }
void DBusHandler::Callbacks::removeTimeout(DBusTimeout* timeout, void* data) { wl_event_source* s = (wl_event_source*) dbus_timeout_get_data(timeout); if(!s) { ny::sendWarning("dbusRemoveTimeout: dbus timeout has no data"); return; } wl_event_source_remove(s); }
void DBusHandler::Callbacks::toggleTimeout(DBusTimeout* timeout, void* data) { wl_event_source* s = (wl_event_source*) dbus_timeout_get_data(timeout); if(!s) { ny::sendWarning("dbusToggleTimeout: dbus timeout has no data"); return; } adjustTimeout(timeout, s); }
static void pcmk_dbus_timeout_remove(DBusTimeout *timeout, void *data){ void *vid = dbus_timeout_get_data(timeout); guint id = GPOINTER_TO_UINT(vid); crm_trace("Removing timeout %p (%p)", timeout, data); if(id) { g_source_remove(id); dbus_timeout_set_data(timeout, 0, NULL); } }
/** * Callback for toggling a D-Bus timeout. */ static void cdbus_callback_timeout_toggled(DBusTimeout *timeout, void *data) { timeout_t *ptmout = dbus_timeout_get_data(timeout); assert(ptmout); if (ptmout) { ptmout->enabled = dbus_timeout_get_enabled(timeout); // Refresh interval as libdbus doc says: "Whenever a timeout is toggled, // its interval may change." ptmout->interval = dbus_timeout_get_interval(timeout); } }
static void remove_timeout(DBusTimeout *timeout, void *data) { EpollData _cleanup_free_ *e = NULL; assert(timeout); e = dbus_timeout_get_data(timeout); if (!e) return; assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0); close_nointr_nofail(e->fd); }
static void remove_timeout(DBusTimeout *dbus_timeout, void *userdata) { ConnectionData *d = userdata; TimeoutData *timeout; assert(dbus_timeout); assert(d); timeout = dbus_timeout_get_data(dbus_timeout); assert(timeout); d->poll_api->timeout_free(timeout->avahi_timeout); timeout->avahi_timeout = NULL; }
static void toggle_timeout(DBusTimeout *to, void *data) { intf_thread_t *intf = data; intf_sys_t *sys = intf->p_sys; mtime_t *expiry = dbus_timeout_get_data(to); vlc_mutex_lock(&sys->lock); if (dbus_timeout_get_enabled(to)) *expiry = mdate() + UINT64_C(1000) * dbus_timeout_get_interval(to); vlc_mutex_unlock(&sys->lock); wakeup_main_loop(intf); }
static void toggle_timeout(DBusTimeout *timeout, void *data) { EpollData *e; int r; assert(timeout); e = dbus_timeout_get_data(timeout); if (!e) return; r = timeout_arm(e); if (r < 0) log_error("Failed to rearm timer: %s", strerror(-r)); }
static void timeout_remove(DBusTimeout *timeout, void *data) { struct timeout *t; (void)data; lem_debug("timeout = %p, interval = %d, enabled = %s", (void *)timeout, dbus_timeout_get_interval(timeout), dbus_timeout_get_enabled(timeout) ? "true" : "false"); t = dbus_timeout_get_data(timeout); ev_timer_stop(EV_G_ &t->ev); free(t); }
/* DBusTimeoutToggledFunction callback for pa mainloop */ static void toggle_timeout(DBusTimeout *timeout, void *data) { struct timeout_data *d = data; pa_time_event *ev; struct timeval tv; pa_assert(d); pa_assert(d->connection); pa_assert(timeout); pa_assert_se(ev = dbus_timeout_get_data(timeout)); if (dbus_timeout_get_enabled(timeout)) d->connection->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, pa_rtclock_now() + dbus_timeout_get_interval(timeout) * PA_USEC_PER_MSEC, d->connection->use_rtclock)); else d->connection->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, PA_USEC_INVALID, d->connection->use_rtclock)); }
static void connection_setup_add_timeout (ConnectionSetup *cs, DBusTimeout *timeout) { TimeoutHandler *handler; if (!dbus_timeout_get_enabled (timeout)) return; g_assert (dbus_timeout_get_data (timeout) == NULL); handler = g_new0 (TimeoutHandler, 1); handler->cs = cs; handler->timeout = timeout; handler->source = g_timeout_source_new (dbus_timeout_get_interval (timeout)); g_source_set_callback (handler->source, timeout_handler_dispatch, handler, timeout_handler_source_finalized); g_source_attach (handler->source, handler->cs->context); cs->timeouts = g_slist_prepend (cs->timeouts, handler); dbus_timeout_set_data (timeout, handler, timeout_handler_timeout_freed); }
/** * ProcessTimeouts() handles DBus timeouts * * This function must be called with p_sys->lock locked * * @param intf_thread_t *p_intf This interface thread state * @param DBusTimeout **p_timeouts List of timeouts to process * @param int i_timeouts Size of p_timeouts */ static void ProcessTimeouts( intf_thread_t *p_intf, DBusTimeout **p_timeouts, int i_timeouts ) { VLC_UNUSED( p_intf ); for( int i = 0; i < i_timeouts; i++ ) { timeout_info_t *p_info = NULL; p_info = (timeout_info_t*) dbus_timeout_get_data( p_timeouts[i] ); if( !dbus_timeout_get_enabled( p_info->p_timeout ) ) continue; if( p_info->i_remaining > 0 ) continue; dbus_timeout_handle( p_info->p_timeout ); p_info->i_remaining = dbus_timeout_get_interval( p_info->p_timeout ); } }
/** * Process pending D-Bus timeouts. * * @note Interface lock must be held. */ static void process_timeouts(intf_thread_t *intf) { intf_sys_t *sys = intf->p_sys; for (int i = 0; i < vlc_array_count(sys->p_timeouts); i++) { DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i); if (!dbus_timeout_get_enabled(to)) continue; mtime_t *expiry = dbus_timeout_get_data(to); if (*expiry > mdate()) continue; expiry += UINT64_C(1000) * dbus_timeout_get_interval(to); vlc_mutex_unlock(&sys->lock); dbus_timeout_handle(to); vlc_mutex_lock(&sys->lock); i = -1; /* lost track of state, restart from beginning */ } }