[Spice-devel] [PATCH spice-server 2/2] event-loop: Change internal core interface
Victor Toso
victortoso at redhat.com
Thu Oct 10 09:54:35 UTC 2019
Hi,
On Tue, Aug 06, 2019 at 03:52:50PM +0100, Frediano Ziglio wrote:
> Allow to modify/cancel timers/watches without having to
> retrieve the code interface.
> This will make sure that you are not using the wrong interface.
> Simplify code to deal with timers/watches.
> Remove the requirement to have the core interface available
> for removing timers/watches.
>
> Signed-off-by: Frediano Ziglio <fziglio at redhat.com>
Sorry to ask but could you please send a rebased version?
> ---
> server/char-device.c | 28 ++---
> server/event-loop.c | 206 ++++++++++++++++++++++++--------
> server/inputs-channel.c | 6 +-
> server/main-dispatcher.c | 2 +-
> server/red-channel-client.c | 43 +++----
> server/red-common.h | 15 ++-
> server/red-stream-device.c | 5 +-
> server/red-stream.c | 2 +-
> server/red-worker.c | 2 +-
> server/reds.c | 69 ++---------
> server/reds.h | 12 --
> server/tests/basic-event-loop.c | 35 +-----
> 12 files changed, 211 insertions(+), 214 deletions(-)
>
> diff --git a/server/char-device.c b/server/char-device.c
> index cfcc29da0..1ac54d5c5 100644
> --- a/server/char-device.c
> +++ b/server/char-device.c
> @@ -163,7 +163,7 @@ static void red_char_device_client_free(RedCharDevice *dev,
> {
> GList *l, *next;
>
> - reds_core_timer_remove(dev->priv->reds, dev_client->wait_for_tokens_timer);
> + red_timer_remove(dev_client->wait_for_tokens_timer);
> dev_client->wait_for_tokens_timer = NULL;
>
> g_queue_free_full(dev_client->send_queue, (GDestroyNotify)red_pipe_item_unref);
> @@ -249,8 +249,6 @@ static uint64_t red_char_device_max_send_tokens(RedCharDevice *dev)
> static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_client,
> RedPipeItem *msg)
> {
> - RedCharDevice *dev = dev_client->dev;
> -
> if (g_queue_get_length(dev_client->send_queue) >= dev_client->max_send_queue_size) {
> red_char_device_handle_client_overflow(dev_client);
> return;
> @@ -259,8 +257,8 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
> red_pipe_item_ref(msg);
> g_queue_push_head(dev_client->send_queue, msg);
> if (!dev_client->wait_for_tokens_started) {
> - reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
> - RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> + red_timer_start(dev_client->wait_for_tokens_timer,
> + RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> dev_client->wait_for_tokens_started = TRUE;
> }
> }
> @@ -372,12 +370,12 @@ red_char_device_send_to_client_tokens_absorb(RedCharDevice *dev,
> }
>
> if (red_char_device_can_send_to_client(dev_client)) {
> - reds_core_timer_cancel(dev->priv->reds, dev_client->wait_for_tokens_timer);
> + red_timer_cancel(dev_client->wait_for_tokens_timer);
> dev_client->wait_for_tokens_started = FALSE;
> red_char_device_read_from_device(dev_client->dev);
> } else if (!g_queue_is_empty(dev_client->send_queue)) {
> - reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
> - RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> + red_timer_start(dev_client->wait_for_tokens_timer,
> + RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> dev_client->wait_for_tokens_started = TRUE;
> }
> }
> @@ -438,7 +436,7 @@ static int red_char_device_write_to_device(RedCharDevice *dev)
> g_object_ref(dev);
>
> if (dev->priv->write_to_dev_timer) {
> - reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
> + red_timer_cancel(dev->priv->write_to_dev_timer);
> }
>
> sif = spice_char_device_get_interface(dev->priv->sin);
> @@ -475,8 +473,8 @@ static int red_char_device_write_to_device(RedCharDevice *dev)
> if (dev->priv->running) {
> if (dev->priv->cur_write_buf) {
> if (dev->priv->write_to_dev_timer) {
> - reds_core_timer_start(dev->priv->reds, dev->priv->write_to_dev_timer,
> - CHAR_DEVICE_WRITE_TO_TIMEOUT);
> + red_timer_start(dev->priv->write_to_dev_timer,
> + CHAR_DEVICE_WRITE_TO_TIMEOUT);
> }
> } else {
> spice_assert(g_queue_is_empty(&dev->priv->write_queue));
> @@ -493,7 +491,7 @@ static void red_char_device_write_retry(void *opaque)
> RedCharDevice *dev = opaque;
>
> if (dev->priv->write_to_dev_timer) {
> - reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
> + red_timer_cancel(dev->priv->write_to_dev_timer);
> }
> red_char_device_write_to_device(dev);
> }
> @@ -762,7 +760,7 @@ void red_char_device_stop(RedCharDevice *dev)
> dev->priv->running = FALSE;
> dev->priv->active = FALSE;
> if (dev->priv->write_to_dev_timer) {
> - reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
> + red_timer_cancel(dev->priv->write_to_dev_timer);
> }
> }
>
> @@ -947,7 +945,7 @@ static void red_char_device_init_device_instance(RedCharDevice *self)
>
> g_return_if_fail(self->priv->reds);
>
> - reds_core_timer_remove(self->priv->reds, self->priv->write_to_dev_timer);
> + red_timer_remove(self->priv->write_to_dev_timer);
> self->priv->write_to_dev_timer = NULL;
>
> if (self->priv->sin == NULL) {
> @@ -1037,7 +1035,7 @@ red_char_device_finalize(GObject *object)
> {
> RedCharDevice *self = RED_CHAR_DEVICE(object);
>
> - reds_core_timer_remove(self->priv->reds, self->priv->write_to_dev_timer);
> + red_timer_remove(self->priv->write_to_dev_timer);
> self->priv->write_to_dev_timer = NULL;
>
> write_buffers_queue_free(&self->priv->write_queue);
> diff --git a/server/event-loop.c b/server/event-loop.c
> index 1ccfd671f..6d2de95f2 100644
> --- a/server/event-loop.c
> +++ b/server/event-loop.c
> @@ -25,28 +25,83 @@
>
> #include "red-common.h"
>
> +typedef struct SpiceCoreFuncs {
> + void (*timer_start)(SpiceTimer *timer, uint32_t ms);
> + void (*timer_cancel)(SpiceTimer *timer);
> + void (*timer_remove)(SpiceTimer *timer);
> + void (*watch_update_mask)(SpiceWatch *watch, int event_mask);
> + void (*watch_remove)(SpiceWatch *watch);
> +} SpiceCoreFuncs;
> +
> struct SpiceTimer {
> + const SpiceCoreFuncs *funcs;
> +};
> +
> +struct SpiceWatch {
> + const SpiceCoreFuncs *funcs;
> +};
> +
> +void red_timer_start(SpiceTimer *timer, uint32_t ms)
> +{
> + if (timer) {
> + timer->funcs->timer_start(timer, ms);
> + }
> +}
> +
> +void red_timer_cancel(SpiceTimer *timer)
> +{
> + if (timer) {
> + timer->funcs->timer_cancel(timer);
> + }
> +}
> +
> +void red_timer_remove(SpiceTimer *timer)
> +{
> + if (timer) {
> + timer->funcs->timer_remove(timer);
> + }
> +}
> +
> +void red_watch_update_mask(SpiceWatch *watch, int event_mask)
> +{
> + if (watch) {
> + watch->funcs->watch_update_mask(watch, event_mask);
> + }
> +}
> +
> +void red_watch_remove(SpiceWatch *watch)
> +{
> + if (watch) {
> + watch->funcs->watch_remove(watch);
> + }
> +}
> +
> +static const SpiceCoreFuncs glib_core_funcs;
> +
> +typedef struct SpiceTimerGlib {
> + SpiceTimer base;
> GMainContext *context;
> SpiceTimerFunc func;
> void *opaque;
> GSource *source;
> -};
> +} SpiceTimerGlib;
>
> static SpiceTimer* timer_add(const SpiceCoreInterfaceInternal *iface,
> SpiceTimerFunc func, void *opaque)
> {
> - SpiceTimer *timer = g_new0(SpiceTimer, 1);
> + SpiceTimerGlib *timer = g_new0(SpiceTimerGlib, 1);
>
> + timer->base.funcs = &glib_core_funcs;
> timer->context = iface->main_context;
> timer->func = func;
> timer->opaque = opaque;
>
> - return timer;
> + return &timer->base;
> }
>
> static gboolean timer_func(gpointer user_data)
> {
> - SpiceTimer *timer = user_data;
> + SpiceTimerGlib *timer = (SpiceTimerGlib*) user_data;
>
> timer->func(timer->opaque);
> /* timer might be free after func(), don't touch */
> @@ -54,9 +109,9 @@ static gboolean timer_func(gpointer user_data)
> return FALSE;
> }
>
> -static void timer_cancel(const SpiceCoreInterfaceInternal *iface,
> - SpiceTimer *timer)
> +static void timer_cancel(SpiceTimer *timer_base)
> {
> + SpiceTimerGlib *timer = SPICE_UPCAST(SpiceTimerGlib, timer_base);
> if (timer->source) {
> g_source_destroy(timer->source);
> g_source_unref(timer->source);
> @@ -64,10 +119,11 @@ static void timer_cancel(const SpiceCoreInterfaceInternal *iface,
> }
> }
>
> -static void timer_start(const SpiceCoreInterfaceInternal *iface,
> - SpiceTimer *timer, uint32_t ms)
> +static void timer_start(SpiceTimer *timer_base, uint32_t ms)
> {
> - timer_cancel(iface, timer);
> + timer_cancel(timer_base);
> +
> + SpiceTimerGlib *timer = SPICE_UPCAST(SpiceTimerGlib, timer_base);
>
> timer->source = g_timeout_source_new(ms);
> spice_assert(timer->source != NULL);
> @@ -77,10 +133,11 @@ static void timer_start(const SpiceCoreInterfaceInternal *iface,
> g_source_attach(timer->source, timer->context);
> }
>
> -static void timer_remove(const SpiceCoreInterfaceInternal *iface,
> - SpiceTimer *timer)
> +static void timer_remove(SpiceTimer *timer_base)
> {
> - timer_cancel(iface, timer);
> + timer_cancel(timer_base);
> +
> + SpiceTimerGlib *timer = SPICE_UPCAST(SpiceTimerGlib, timer_base);
> spice_assert(timer->source == NULL);
> g_free(timer);
> }
> @@ -110,18 +167,19 @@ static int giocondition_to_spice_event(GIOCondition condition)
> }
>
> #ifdef _WIN32
> -struct SpiceWatch {
> +typedef struct SpiceWatchGlib {
> + SpiceWatch base;
> GMainContext *context;
> void *opaque;
> GSource *source;
> GIOChannel *channel;
> SpiceWatchFunc func;
> -};
> +} SpiceWatchGlib;
>
> static gboolean watch_func(GIOChannel *source, GIOCondition condition,
> gpointer data)
> {
> - SpiceWatch *watch = data;
> + SpiceWatchGlib *watch = (SpiceWatchGlib*) data;
> // this works also under Windows despite the name
> int fd = g_io_channel_unix_get_fd(source);
>
> @@ -130,9 +188,9 @@ static gboolean watch_func(GIOChannel *source, GIOCondition condition,
> return TRUE;
> }
>
> -static void watch_update_mask(const SpiceCoreInterfaceInternal *iface,
> - SpiceWatch *watch, int event_mask)
> +static void watch_update_mask(SpiceWatch *watch_base, int event_mask)
> {
> + SpiceWatchGlib *watch = SPICE_UPCAST(SpiceWatchGlib, watch_base);
> if (watch->source) {
> g_source_destroy(watch->source);
> g_source_unref(watch->source);
> @@ -155,26 +213,27 @@ static void watch_update_mask(const SpiceCoreInterfaceInternal *iface,
> static SpiceWatch *watch_add(const SpiceCoreInterfaceInternal *iface,
> int fd, int event_mask, SpiceWatchFunc func, void *opaque)
> {
> - SpiceWatch *watch;
> + SpiceWatchGlib *watch;
>
> spice_return_val_if_fail(fd != -1, NULL);
> spice_return_val_if_fail(func != NULL, NULL);
>
> - watch = g_new0(SpiceWatch, 1);
> + watch = g_new0(SpiceWatchGlib, 1);
> + watch->base.funcs = &glib_core_funcs;
> watch->context = iface->main_context;
> watch->channel = g_io_channel_win32_new_socket(fd);
> watch->func = func;
> watch->opaque = opaque;
>
> - watch_update_mask(iface, watch, event_mask);
> + watch_update_mask(&watch->base, event_mask);
>
> - return watch;
> + return &watch->base;
> }
>
> -static void watch_remove(const SpiceCoreInterfaceInternal *iface,
> - SpiceWatch *watch)
> +static void watch_remove(SpiceWatch *watch_base)
> {
> - watch_update_mask(iface, watch, 0);
> + SpiceWatchGlib *watch = SPICE_UPCAST(SpiceWatchGlib, watch_base);
> + watch_update_mask(watch_base, 0);
> spice_assert(watch->source == NULL);
>
> g_io_channel_unref(watch->channel);
> @@ -183,16 +242,17 @@ static void watch_remove(const SpiceCoreInterfaceInternal *iface,
>
> #else
>
> -struct SpiceWatch {
> +typedef struct SpiceWatchGlib {
> GSource source;
> + SpiceWatch spice_base;
> gpointer unix_fd;
> int fd;
> -};
> +} SpiceWatchGlib;
>
> static gboolean
> spice_watch_check(GSource *source)
> {
> - SpiceWatch *watch = SPICE_CONTAINEROF(source, SpiceWatch, source);
> + SpiceWatchGlib *watch = SPICE_CONTAINEROF(source, SpiceWatchGlib, source);
>
> return g_source_query_unix_fd(&watch->source, watch->unix_fd) != 0;
> }
> @@ -202,7 +262,7 @@ spice_watch_dispatch(GSource *source,
> GSourceFunc callback,
> gpointer user_data)
> {
> - SpiceWatch *watch = SPICE_CONTAINEROF(source, SpiceWatch, source);
> + SpiceWatchGlib *watch = SPICE_CONTAINEROF(source, SpiceWatchGlib, source);
> SpiceWatchFunc func = (SpiceWatchFunc)(void*) callback;
> GIOCondition condition = g_source_query_unix_fd(&watch->source, watch->unix_fd);
>
> @@ -217,9 +277,9 @@ static GSourceFuncs spice_watch_funcs = {
> .dispatch = spice_watch_dispatch,
> };
>
> -static void watch_update_mask(const SpiceCoreInterfaceInternal *iface,
> - SpiceWatch *watch, int event_mask)
> +static void watch_update_mask(SpiceWatch *watch_base, int event_mask)
> {
> + SpiceWatchGlib *watch = SPICE_CONTAINEROF(watch_base, SpiceWatchGlib, spice_base);
> GIOCondition condition = spice_event_to_giocondition(event_mask);
>
> g_source_modify_unix_fd(&watch->source, watch->unix_fd, condition);
> @@ -228,11 +288,14 @@ static void watch_update_mask(const SpiceCoreInterfaceInternal *iface,
> static SpiceWatch *watch_add(const SpiceCoreInterfaceInternal *iface,
> int fd, int event_mask, SpiceWatchFunc func, void *opaque)
> {
> - SpiceWatch *watch = (SpiceWatch *) g_source_new(&spice_watch_funcs, sizeof(SpiceWatch));
> + SPICE_VERIFY(SPICE_OFFSETOF(SpiceWatchGlib, source) == 0);
> + SpiceWatchGlib *watch =
> + (SpiceWatchGlib *) g_source_new(&spice_watch_funcs, sizeof(SpiceWatchGlib));
>
> spice_return_val_if_fail(fd != -1, NULL);
> spice_return_val_if_fail(func != NULL, NULL);
>
> + watch->spice_base.funcs = &glib_core_funcs;
> watch->fd = fd;
>
> g_source_set_callback(&watch->source, (GSourceFunc)(void*)(SpiceWatchFunc) func, opaque, NULL);
> @@ -242,68 +305,103 @@ static SpiceWatch *watch_add(const SpiceCoreInterfaceInternal *iface,
> GIOCondition condition = spice_event_to_giocondition(event_mask);
> watch->unix_fd = g_source_add_unix_fd(&watch->source, watch->fd, condition);
>
> - return watch;
> + return &watch->spice_base;
> }
>
> -static void watch_remove(const SpiceCoreInterfaceInternal *iface,
> - SpiceWatch *watch)
> +static void watch_remove(SpiceWatch *watch_base)
> {
> + SpiceWatchGlib *watch = SPICE_CONTAINEROF(watch_base, SpiceWatchGlib, spice_base);
> +
> g_source_remove_unix_fd(&watch->source, watch->unix_fd);
> g_source_destroy(&watch->source);
> g_source_unref(&watch->source);
> }
> #endif
>
> -const SpiceCoreInterfaceInternal event_loop_core = {
> - .timer_add = timer_add,
> +static const SpiceCoreFuncs glib_core_funcs = {
> .timer_start = timer_start,
> .timer_cancel = timer_cancel,
> .timer_remove = timer_remove,
>
> - .watch_add = watch_add,
> .watch_update_mask = watch_update_mask,
> .watch_remove = watch_remove,
> };
>
> +const SpiceCoreInterfaceInternal event_loop_core = {
> + .timer_add = timer_add,
> + .watch_add = watch_add,
> +};
> +
> /*
> * Adapter for SpiceCodeInterface
> */
>
> +static const SpiceCoreFuncs qemu_core_funcs;
> +
> +typedef struct SpiceTimerQemu {
> + SpiceTimer base;
> + SpiceCoreInterface *core;
> + SpiceTimer *qemu_timer;
> +} SpiceTimerQemu;
> +
> static SpiceTimer *adapter_timer_add(const SpiceCoreInterfaceInternal *iface, SpiceTimerFunc func, void *opaque)
> {
> - return iface->public_interface->timer_add(func, opaque);
> + SpiceTimerQemu *timer = g_new0(SpiceTimerQemu, 1);
> +
> + timer->base.funcs = &qemu_core_funcs;
> + timer->core = iface->public_interface;
> + timer->qemu_timer = timer->core->timer_add(func, opaque);
> + return &timer->base;
> }
>
> -static void adapter_timer_start(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer, uint32_t ms)
> +static void adapter_timer_start(SpiceTimer *timer_, uint32_t ms)
> {
> - iface->public_interface->timer_start(timer, ms);
> + SpiceTimerQemu *timer = SPICE_UPCAST(SpiceTimerQemu, timer_);
> + timer->core->timer_start(timer->qemu_timer, ms);
> }
>
> -static void adapter_timer_cancel(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer)
> +static void adapter_timer_cancel(SpiceTimer *timer_)
> {
> - iface->public_interface->timer_cancel(timer);
> + SpiceTimerQemu *timer = SPICE_UPCAST(SpiceTimerQemu, timer_);
> + timer->core->timer_cancel(timer->qemu_timer);
> }
>
> -static void adapter_timer_remove(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer)
> +static void adapter_timer_remove(SpiceTimer *timer_)
> {
> - iface->public_interface->timer_remove(timer);
> + SpiceTimerQemu *timer = SPICE_UPCAST(SpiceTimerQemu, timer_);
> + timer->core->timer_remove(timer->qemu_timer);
> + g_free(timer);
> }
>
> +typedef struct SpiceWatchQemu {
> + SpiceWatch base;
> + SpiceCoreInterface *core;
> + SpiceWatch *qemu_watch;
> +} SpiceWatchQemu;
> +
> static SpiceWatch *adapter_watch_add(const SpiceCoreInterfaceInternal *iface,
> int fd, int event_mask, SpiceWatchFunc func, void *opaque)
> {
> // note: Qemu API is fine having a SOCKET on Windows
> - return iface->public_interface->watch_add(fd, event_mask, func, opaque);
> + SpiceWatchQemu *watch = g_new0(SpiceWatchQemu, 1);
> +
> + watch->base.funcs = &qemu_core_funcs;
> + watch->core = iface->public_interface;
> + watch->qemu_watch = watch->core->watch_add(fd, event_mask, func, opaque);
> + return &watch->base;
> }
>
> -static void adapter_watch_update_mask(const SpiceCoreInterfaceInternal *iface, SpiceWatch *watch, int event_mask)
> +static void adapter_watch_update_mask(SpiceWatch *watch_, int event_mask)
> {
> - iface->public_interface->watch_update_mask(watch, event_mask);
> + SpiceWatchQemu *watch = SPICE_UPCAST(SpiceWatchQemu, watch_);
> + watch->core->watch_update_mask(watch->qemu_watch, event_mask);
> }
>
> -static void adapter_watch_remove(const SpiceCoreInterfaceInternal *iface, SpiceWatch *watch)
> +static void adapter_watch_remove(SpiceWatch *watch_)
> {
> - iface->public_interface->watch_remove(watch);
> + SpiceWatchQemu *watch = SPICE_UPCAST(SpiceWatchQemu, watch_);
> + watch->core->watch_remove(watch->qemu_watch);
> + g_free(watch);
> }
>
> static void adapter_channel_event(const SpiceCoreInterfaceInternal *iface, int event, SpiceChannelEventInfo *info)
> @@ -312,13 +410,17 @@ static void adapter_channel_event(const SpiceCoreInterfaceInternal *iface, int e
> iface->public_interface->channel_event(event, info);
> }
>
> -const SpiceCoreInterfaceInternal core_interface_adapter = {
> - .timer_add = adapter_timer_add,
> +static const SpiceCoreFuncs qemu_core_funcs = {
> .timer_start = adapter_timer_start,
> .timer_cancel = adapter_timer_cancel,
> .timer_remove = adapter_timer_remove,
> - .watch_add = adapter_watch_add,
> +
> .watch_update_mask = adapter_watch_update_mask,
> .watch_remove = adapter_watch_remove,
> +};
> +
> +const SpiceCoreInterfaceInternal core_interface_adapter = {
> + .timer_add = adapter_timer_add,
> + .watch_add = adapter_watch_add,
> .channel_event = adapter_channel_event,
> };
> diff --git a/server/inputs-channel.c b/server/inputs-channel.c
> index a1c35565c..280783c17 100644
> --- a/server/inputs-channel.c
> +++ b/server/inputs-channel.c
> @@ -162,8 +162,7 @@ const VDAgentMouseState *inputs_channel_get_mouse_state(InputsChannel *inputs)
>
> static void activate_modifiers_watch(InputsChannel *inputs)
> {
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(RED_CHANNEL(inputs));
> - core->timer_start(core, inputs->key_modifiers_timer, KEY_MODIFIERS_TTL);
> + red_timer_start(inputs->key_modifiers_timer, KEY_MODIFIERS_TTL);
> }
>
> static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
> @@ -600,10 +599,9 @@ static void
> inputs_channel_finalize(GObject *object)
> {
> InputsChannel *self = INPUTS_CHANNEL(object);
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(RED_CHANNEL(self));
>
> inputs_channel_detach_tablet(self, self->tablet);
> - core->timer_remove(core, self->key_modifiers_timer);
> + red_timer_remove(self->key_modifiers_timer);
>
> G_OBJECT_CLASS(inputs_channel_parent_class)->finalize(object);
> }
> diff --git a/server/main-dispatcher.c b/server/main-dispatcher.c
> index 2ca68a4d1..7579fd379 100644
> --- a/server/main-dispatcher.c
> +++ b/server/main-dispatcher.c
> @@ -288,7 +288,7 @@ static void main_dispatcher_finalize(GObject *object)
> {
> MainDispatcher *self = MAIN_DISPATCHER(object);
>
> - reds_core_watch_remove(self->priv->reds, self->priv->watch);
> + red_watch_remove(self->priv->watch);
> self->priv->watch = NULL;
> G_OBJECT_CLASS(main_dispatcher_parent_class)->finalize(object);
> }
> diff --git a/server/red-channel-client.c b/server/red-channel-client.c
> index 337733d5d..d19eafe78 100644
> --- a/server/red-channel-client.c
> +++ b/server/red-channel-client.c
> @@ -216,8 +216,6 @@ typedef struct MarkerPipeItem {
>
> static void red_channel_client_start_ping_timer(RedChannelClient *rcc, uint32_t timeout)
> {
> - SpiceCoreInterfaceInternal *core;
> -
> if (!rcc->priv->latency_monitor.timer) {
> return;
> }
> @@ -226,14 +224,11 @@ static void red_channel_client_start_ping_timer(RedChannelClient *rcc, uint32_t
> }
> rcc->priv->latency_monitor.state = PING_STATE_TIMER;
>
> - core = red_channel_get_core_interface(rcc->priv->channel);
> - core->timer_start(core, rcc->priv->latency_monitor.timer, timeout);
> + red_timer_start(rcc->priv->latency_monitor.timer, timeout);
> }
>
> static void red_channel_client_cancel_ping_timer(RedChannelClient *rcc)
> {
> - SpiceCoreInterfaceInternal *core;
> -
> if (!rcc->priv->latency_monitor.timer) {
> return;
> }
> @@ -241,8 +236,7 @@ static void red_channel_client_cancel_ping_timer(RedChannelClient *rcc)
> return;
> }
>
> - core = red_channel_get_core_interface(rcc->priv->channel);
> - core->timer_cancel(core, rcc->priv->latency_monitor.timer);
> + red_timer_cancel(rcc->priv->latency_monitor.timer);
> rcc->priv->latency_monitor.state = PING_STATE_NONE;
> }
>
> @@ -332,13 +326,12 @@ red_channel_client_finalize(GObject *object)
> {
> RedChannelClient *self = RED_CHANNEL_CLIENT(object);
>
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(self->priv->channel);
> if (self->priv->latency_monitor.timer) {
> - core->timer_remove(core, self->priv->latency_monitor.timer);
> + red_timer_remove(self->priv->latency_monitor.timer);
> self->priv->latency_monitor.timer = NULL;
> }
> if (self->priv->connectivity_monitor.timer) {
> - core->timer_remove(core, self->priv->connectivity_monitor.timer);
> + red_timer_remove(self->priv->connectivity_monitor.timer);
> self->priv->connectivity_monitor.timer = NULL;
> }
>
> @@ -756,7 +749,6 @@ static void red_channel_client_connectivity_timer(void *opaque)
> }
>
> if (is_alive) {
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(rcc->priv->channel);
> monitor->received_bytes = false;
> monitor->sent_bytes = false;
> if (red_channel_client_is_blocked(rcc) || red_channel_client_waiting_for_ack(rcc)) {
> @@ -767,7 +759,7 @@ static void red_channel_client_connectivity_timer(void *opaque)
> } else {
> monitor->state = CONNECTIVITY_STATE_CONNECTED;
> }
> - core->timer_start(core, rcc->priv->connectivity_monitor.timer,
> + red_timer_start(rcc->priv->connectivity_monitor.timer,
> rcc->priv->connectivity_monitor.timeout);
> } else {
> monitor->state = CONNECTIVITY_STATE_DISCONNECTED;
> @@ -806,7 +798,7 @@ void red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uin
> core, red_channel_client_connectivity_timer, rcc);
> rcc->priv->connectivity_monitor.timeout = timeout_ms;
> if (!red_client_during_migrate_at_target(rcc->priv->client)) {
> - core->timer_start(core, rcc->priv->connectivity_monitor.timer,
> + red_timer_start(rcc->priv->connectivity_monitor.timer,
> rcc->priv->connectivity_monitor.timeout);
> }
> }
> @@ -964,14 +956,11 @@ cleanup:
> static void
> red_channel_client_watch_update_mask(RedChannelClient *rcc, int event_mask)
> {
> - SpiceCoreInterfaceInternal *core;
> -
> if (!rcc->priv->stream->watch) {
> return;
> }
>
> - core = red_channel_get_core_interface(rcc->priv->channel);
> - core->watch_update_mask(core, rcc->priv->stream->watch, event_mask);
> + red_watch_update_mask(rcc->priv->stream->watch, event_mask);
> }
>
> static void red_channel_client_seamless_migration_done(RedChannelClient *rcc)
> @@ -981,8 +970,7 @@ static void red_channel_client_seamless_migration_done(RedChannelClient *rcc)
> if (red_client_seamless_migration_done_for_channel(rcc->priv->client)) {
> red_channel_client_start_ping_timer(rcc, PING_TEST_IDLE_NET_TIMEOUT_MS);
> if (rcc->priv->connectivity_monitor.timer) {
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(rcc->priv->channel);
> - core->timer_start(core, rcc->priv->connectivity_monitor.timer,
> + red_timer_start(rcc->priv->connectivity_monitor.timer,
> rcc->priv->connectivity_monitor.timeout);
> }
> }
> @@ -1000,14 +988,13 @@ bool red_channel_client_is_waiting_for_migrate_data(RedChannelClient *rcc)
>
> void red_channel_client_default_migrate(RedChannelClient *rcc)
> {
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(rcc->priv->channel);
> if (rcc->priv->latency_monitor.timer) {
> red_channel_client_cancel_ping_timer(rcc);
> - core->timer_remove(core, rcc->priv->latency_monitor.timer);
> + red_timer_remove(rcc->priv->latency_monitor.timer);
> rcc->priv->latency_monitor.timer = NULL;
> }
> if (rcc->priv->connectivity_monitor.timer) {
> - core->timer_remove(core, rcc->priv->connectivity_monitor.timer);
> + red_timer_remove(rcc->priv->connectivity_monitor.timer);
> rcc->priv->connectivity_monitor.timer = NULL;
> }
> red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_MIGRATE);
> @@ -1024,8 +1011,7 @@ void red_channel_client_destroy(RedChannelClient *rcc)
> void red_channel_client_shutdown(RedChannelClient *rcc)
> {
> if (rcc->priv->stream && rcc->priv->stream->watch) {
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(rcc->priv->channel);
> - core->watch_remove(core, rcc->priv->stream->watch);
> + red_watch_remove(rcc->priv->stream->watch);
> rcc->priv->stream->watch = NULL;
> shutdown(rcc->priv->stream->socket, SHUT_RDWR);
> }
> @@ -1719,22 +1705,21 @@ static void red_channel_client_on_disconnect(RedChannelClient *rcc)
> void red_channel_client_disconnect(RedChannelClient *rcc)
> {
> RedChannel *channel = rcc->priv->channel;
> - SpiceCoreInterfaceInternal *core = red_channel_get_core_interface(channel);
>
> if (!red_channel_client_is_connected(rcc)) {
> return;
> }
> red_channel_client_pipe_clear(rcc);
> if (rcc->priv->stream->watch) {
> - core->watch_remove(core, rcc->priv->stream->watch);
> + red_watch_remove(rcc->priv->stream->watch);
> rcc->priv->stream->watch = NULL;
> }
> if (rcc->priv->latency_monitor.timer) {
> - core->timer_remove(core, rcc->priv->latency_monitor.timer);
> + red_timer_remove(rcc->priv->latency_monitor.timer);
> rcc->priv->latency_monitor.timer = NULL;
> }
> if (rcc->priv->connectivity_monitor.timer) {
> - core->timer_remove(core, rcc->priv->connectivity_monitor.timer);
> + red_timer_remove(rcc->priv->connectivity_monitor.timer);
> rcc->priv->connectivity_monitor.timer = NULL;
> }
> red_channel_remove_client(channel, rcc);
> diff --git a/server/red-common.h b/server/red-common.h
> index 22ea8fc37..4b2e9f87c 100644
> --- a/server/red-common.h
> +++ b/server/red-common.h
> @@ -40,17 +40,20 @@
> #define SPICE_UPCAST(type, ptr) \
> (verify_expr(SPICE_OFFSETOF(type, base) == 0,SPICE_CONTAINEROF(ptr, type, base)))
>
> +SPICE_BEGIN_DECLS
> +
> +void red_timer_start(SpiceTimer *timer, uint32_t ms);
> +void red_timer_cancel(SpiceTimer *timer);
> +void red_timer_remove(SpiceTimer *timer);
> +void red_watch_update_mask(SpiceWatch *watch, int event_mask);
> +void red_watch_remove(SpiceWatch *watch);
> +
> typedef struct SpiceCoreInterfaceInternal SpiceCoreInterfaceInternal;
>
> struct SpiceCoreInterfaceInternal {
> SpiceTimer *(*timer_add)(const SpiceCoreInterfaceInternal *iface, SpiceTimerFunc func, void *opaque);
> - void (*timer_start)(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer, uint32_t ms);
> - void (*timer_cancel)(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer);
> - void (*timer_remove)(const SpiceCoreInterfaceInternal *iface, SpiceTimer *timer);
>
> SpiceWatch *(*watch_add)(const SpiceCoreInterfaceInternal *iface, int fd, int event_mask, SpiceWatchFunc func, void *opaque);
> - void (*watch_update_mask)(const SpiceCoreInterfaceInternal *iface, SpiceWatch *watch, int event_mask);
> - void (*watch_remove)(const SpiceCoreInterfaceInternal *iface, SpiceWatch *watch);
>
> void (*channel_event)(const SpiceCoreInterfaceInternal *iface, int event, SpiceChannelEventInfo *info);
>
> @@ -126,4 +129,6 @@ typedef struct GListIter {
> { return G_TYPE_INSTANCE_GET_CLASS(obj, \
> module_obj_name ## _get_type(), ModuleObjName ## Class); }
>
> +SPICE_END_DECLS
> +
> #endif /* RED_COMMON_H_ */
> diff --git a/server/red-stream-device.c b/server/red-stream-device.c
> index 620e581ef..44d9cd09d 100644
> --- a/server/red-stream-device.c
> +++ b/server/red-stream-device.c
> @@ -120,7 +120,7 @@ stream_device_partial_read(StreamDevice *dev, SpiceCharDeviceInstance *sin)
> if (!dev->close_timer) {
> dev->close_timer = reds_core_timer_add(reds, close_timer_func, dev);
> }
> - reds_core_timer_start(reds, dev->close_timer, 0);
> + red_timer_start(dev->close_timer, 0);
> return false;
> }
>
> @@ -649,8 +649,7 @@ stream_device_dispose(GObject *object)
> {
> StreamDevice *dev = STREAM_DEVICE(object);
>
> - RedsState *reds = red_char_device_get_server(RED_CHAR_DEVICE(dev));
> - reds_core_timer_remove(reds, dev->close_timer);
> + red_timer_remove(dev->close_timer);
>
> if (dev->stream_channel) {
> // close all current connections and drop the reference
> diff --git a/server/red-stream.c b/server/red-stream.c
> index 04be3af37..aec482fb8 100644
> --- a/server/red-stream.c
> +++ b/server/red-stream.c
> @@ -213,7 +213,7 @@ static ssize_t stream_ssl_read_cb(RedStream *s, void *buf, size_t size)
> void red_stream_remove_watch(RedStream* s)
> {
> if (s->watch) {
> - s->priv->core->watch_remove(s->priv->core, s->watch);
> + red_watch_remove(s->watch);
> s->watch = NULL;
> }
> }
> diff --git a/server/red-worker.c b/server/red-worker.c
> index 98a4a9dc3..12a8e7398 100644
> --- a/server/red-worker.c
> +++ b/server/red-worker.c
> @@ -1185,7 +1185,7 @@ void red_worker_free(RedWorker *worker)
> worker->display_channel = NULL;
>
> if (worker->dispatch_watch) {
> - worker->core.watch_remove(&worker->core, worker->dispatch_watch);
> + red_watch_remove(worker->dispatch_watch);
> }
>
> g_main_context_unref(worker->core.main_context);
> diff --git a/server/reds.c b/server/reds.c
> index f432f55a4..96dd58433 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -410,7 +410,7 @@ static void reds_mig_cleanup(RedsState *reds)
> reds->mig_inprogress = FALSE;
> reds->mig_wait_connect = FALSE;
> reds->mig_wait_disconnect = FALSE;
> - reds_core_timer_cancel(reds, reds->mig_timer);
> + red_timer_cancel(reds->mig_timer);
> reds_mig_cleanup_wait_disconnect(reds);
> }
> }
> @@ -2429,7 +2429,6 @@ static void reds_handle_new_link(RedLinkInfo *link)
> static void reds_handle_ssl_accept(int fd, int event, void *data)
> {
> RedLinkInfo *link = (RedLinkInfo *)data;
> - RedsState *reds = link->reds;
> RedStreamSslStatus return_code = red_stream_ssl_accept(link->stream);
>
> switch (return_code) {
> @@ -2437,12 +2436,10 @@ static void reds_handle_ssl_accept(int fd, int event, void *data)
> reds_link_free(link);
> return;
> case RED_STREAM_SSL_STATUS_WAIT_FOR_READ:
> - reds_core_watch_update_mask(reds, link->stream->watch,
> - SPICE_WATCH_EVENT_READ);
> + red_watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_READ);
> return;
> case RED_STREAM_SSL_STATUS_WAIT_FOR_WRITE:
> - reds_core_watch_update_mask(reds, link->stream->watch,
> - SPICE_WATCH_EVENT_WRITE);
> + red_watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_WRITE);
> return;
> case RED_STREAM_SSL_STATUS_OK:
> red_stream_remove_watch(link->stream);
> @@ -2702,7 +2699,7 @@ void reds_set_client_mm_time_latency(RedsState *reds, RedClient *client, uint32_
> static void reds_cleanup_net(SpiceServer *reds)
> {
> if (reds->listen_socket != -1) {
> - reds_core_watch_remove(reds, reds->listen_watch);
> + red_watch_remove(reds->listen_watch);
> if (reds->config->spice_listen_socket_fd != reds->listen_socket) {
> socket_close(reds->listen_socket);
> }
> @@ -2710,7 +2707,7 @@ static void reds_cleanup_net(SpiceServer *reds)
> reds->listen_socket = -1;
> }
> if (reds->secure_listen_socket != -1) {
> - reds_core_watch_remove(reds, reds->secure_listen_watch);
> + red_watch_remove(reds->secure_listen_watch);
> socket_close(reds->secure_listen_socket);
> reds->secure_listen_watch = NULL;
> reds->secure_listen_socket = -1;
> @@ -3031,7 +3028,7 @@ static void reds_mig_started(RedsState *reds)
>
> reds->mig_inprogress = TRUE;
> reds->mig_wait_connect = TRUE;
> - reds_core_timer_start(reds, reds->mig_timer, MIGRATE_TIMEOUT);
> + red_timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
> }
>
> static void reds_mig_fill_wait_disconnect(RedsState *reds)
> @@ -3046,7 +3043,7 @@ static void reds_mig_fill_wait_disconnect(RedsState *reds)
> }
> reds->mig_wait_connect = FALSE;
> reds->mig_wait_disconnect = TRUE;
> - reds_core_timer_start(reds, reds->mig_timer, MIGRATE_TIMEOUT);
> + red_timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
> }
>
> static void reds_mig_cleanup_wait_disconnect(RedsState *reds)
> @@ -3863,7 +3860,7 @@ SPICE_GNUC_VISIBLE void spice_server_destroy(SpiceServer *reds)
> if (reds->main_channel) {
> red_channel_destroy(RED_CHANNEL(reds->main_channel));
> }
> - reds_core_timer_remove(reds, reds->mig_timer);
> + red_timer_remove(reds->mig_timer);
>
> if (reds->ctx) {
> SSL_CTX_free(reds->ctx);
> @@ -4437,24 +4434,6 @@ SpiceWatch *reds_core_watch_add(RedsState *reds,
> return reds->core.watch_add(&reds->core, fd, event_mask, func, opaque);
> }
>
> -void reds_core_watch_update_mask(RedsState *reds,
> - SpiceWatch *watch,
> - int event_mask)
> -{
> - g_return_if_fail(reds != NULL);
> - g_return_if_fail(reds->core.watch_update_mask != NULL);
> -
> - reds->core.watch_update_mask(&reds->core, watch, event_mask);
> -}
> -
> -void reds_core_watch_remove(RedsState *reds, SpiceWatch *watch)
> -{
> - g_return_if_fail(reds != NULL);
> - g_return_if_fail(reds->core.watch_remove != NULL);
> -
> - reds->core.watch_remove(&reds->core, watch);
> -}
> -
> SpiceTimer *reds_core_timer_add(RedsState *reds,
> SpiceTimerFunc func,
> void *opaque)
> @@ -4466,38 +4445,6 @@ SpiceTimer *reds_core_timer_add(RedsState *reds,
>
> }
>
> -void reds_core_timer_start(RedsState *reds,
> - SpiceTimer *timer,
> - uint32_t ms)
> -{
> - g_return_if_fail(reds != NULL);
> - g_return_if_fail(reds->core.timer_start != NULL);
> -
> - return reds->core.timer_start(&reds->core, timer, ms);
> -}
> -
> -void reds_core_timer_cancel(RedsState *reds,
> - SpiceTimer *timer)
> -{
> - g_return_if_fail(reds != NULL);
> - g_return_if_fail(reds->core.timer_cancel != NULL);
> -
> - return reds->core.timer_cancel(&reds->core, timer);
> -}
> -
> -void reds_core_timer_remove(RedsState *reds,
> - SpiceTimer *timer)
> -{
> - if (timer == NULL) {
> - return;
> - }
> -
> - g_return_if_fail(reds != NULL);
> - g_return_if_fail(reds->core.timer_remove != NULL);
> -
> - reds->core.timer_remove(&reds->core, timer);
> -}
> -
> void reds_update_client_mouse_allowed(RedsState *reds)
> {
> int allow_now = FALSE;
> diff --git a/server/reds.h b/server/reds.h
> index e3355f817..e2b6904ab 100644
> --- a/server/reds.h
> +++ b/server/reds.h
> @@ -115,20 +115,8 @@ SpiceWatch *reds_core_watch_add(RedsState *reds,
> int fd, int event_mask,
> SpiceWatchFunc func,
> void *opaque);
> -void reds_core_watch_update_mask(RedsState *reds,
> - SpiceWatch *watch,
> - int event_mask);
> -void reds_core_watch_remove(RedsState *reds, SpiceWatch *watch);
> -
> SpiceTimer *reds_core_timer_add(RedsState *reds,
> SpiceTimerFunc func,
> void *opaque);
> -void reds_core_timer_start(RedsState *reds,
> - SpiceTimer *timer,
> - uint32_t ms);
> -void reds_core_timer_cancel(RedsState *reds,
> - SpiceTimer *timer);
> -void reds_core_timer_remove(RedsState *reds,
> - SpiceTimer *timer);
>
> #endif /* REDS_H_ */
> diff --git a/server/tests/basic-event-loop.c b/server/tests/basic-event-loop.c
> index e331e8522..70c9a4df5 100644
> --- a/server/tests/basic-event-loop.c
> +++ b/server/tests/basic-event-loop.c
> @@ -83,48 +83,23 @@ static SpiceTimer* base_timer_add(SpiceTimerFunc func, void *opaque)
> return base_core_interface.timer_add(&base_core_interface, func, opaque);
> }
>
> -static void base_timer_start(SpiceTimer *timer, uint32_t ms)
> -{
> - base_core_interface.timer_start(&base_core_interface, timer, ms);
> -}
> -
> -static void base_timer_cancel(SpiceTimer *timer)
> -{
> - base_core_interface.timer_cancel(&base_core_interface, timer);
> -}
> -
> -static void base_timer_remove(SpiceTimer *timer)
> -{
> - base_core_interface.timer_remove(&base_core_interface, timer);
> -}
> -
> static SpiceWatch *base_watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
> {
> return base_core_interface.watch_add(&base_core_interface, fd, event_mask, func, opaque);
> }
>
> -static void base_watch_update_mask(SpiceWatch *watch, int event_mask)
> -{
> - base_core_interface.watch_update_mask(&base_core_interface, watch, event_mask);
> -}
> -
> -static void base_watch_remove(SpiceWatch *watch)
> -{
> - base_core_interface.watch_remove(&base_core_interface, watch);
> -}
> -
> static SpiceCoreInterface core = {
> .base = {
> .major_version = SPICE_INTERFACE_CORE_MAJOR,
> .minor_version = SPICE_INTERFACE_CORE_MINOR,
> },
> .timer_add = base_timer_add,
> - .timer_start = base_timer_start,
> - .timer_cancel = base_timer_cancel,
> - .timer_remove = base_timer_remove,
> + .timer_start = red_timer_start,
> + .timer_cancel = red_timer_cancel,
> + .timer_remove = red_timer_remove,
> .watch_add = base_watch_add,
> - .watch_update_mask = base_watch_update_mask,
> - .watch_remove = base_watch_remove,
> + .watch_update_mask = red_watch_update_mask,
> + .watch_remove = red_watch_remove,
> .channel_event = event_loop_channel_event,
> };
>
> --
> 2.20.1
>
> _______________________________________________
> Spice-devel mailing list
> Spice-devel at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 833 bytes
Desc: not available
URL: <https://lists.freedesktop.org/archives/spice-devel/attachments/20191010/f9904330/attachment-0001.sig>
More information about the Spice-devel
mailing list