On Mon, 2016-02-15 at 16:01 +0000, Frediano Ziglio wrote:
> From: Jonathon Jongsma <jjongsma@xxxxxxxxxx>
>
> Requires changing a bunch of internal API to take MainDispatcher
> arguments, etc. The main dispatcher object is now owned by RedsState,
> since that is the object that previously created (initialized) it.
> ---
> server/main-channel.c | 3 +-
> server/main-dispatcher.c | 83 ++++++++++++++++++++++++++----------
> ------------
> server/main-dispatcher.h | 12 ++++---
> server/red-channel.c | 4 ++-
> server/reds-private.h | 1 +
> server/reds-stream.c | 4 ++-
> server/reds.c | 7 +++-
> server/reds.h | 2 ++
> server/stream.c | 5 ++-
> 9 files changed, 73 insertions(+), 48 deletions(-)
>
> diff --git a/server/main-channel.c b/server/main-channel.c
> index 6ea47cf..4601b1d 100644
> --- a/server/main-channel.c
> +++ b/server/main-channel.c
> @@ -178,8 +178,9 @@ int main_channel_is_connected(MainChannel
> *main_chan)
> */
> static void main_channel_client_on_disconnect(RedChannelClient *rcc)
> {
> + RedsState *reds = red_channel_get_server(rcc->channel);
> spice_printerr("rcc=%p", rcc);
> - main_dispatcher_client_disconnect(rcc->client);
> + main_dispatcher_client_disconnect(reds_get_main_dispatcher(reds)
> , rcc->client);
> }
>
> RedClient *main_channel_get_client_by_link_id(MainChannel
> *main_chan, uint32_t connection_id)
> diff --git a/server/main-dispatcher.c b/server/main-dispatcher.c
> index 777a44f..298a961 100644
> --- a/server/main-dispatcher.c
> +++ b/server/main-dispatcher.c
> @@ -47,12 +47,11 @@
> * seperate from self because it may send an ack or do other work
> in the future.
> */
>
> -typedef struct {
> +struct MainDispatcher {
> Dispatcher base;
> SpiceCoreInterfaceInternal *core;
> -} MainDispatcher;
> -
> -MainDispatcher main_dispatcher;
> + RedsState *reds;
> +};
>
> enum {
> MAIN_DISPATCHER_CHANNEL_EVENT = 0,
> @@ -82,33 +81,35 @@ typedef struct
> MainDispatcherClientDisconnectMessage {
> } MainDispatcherClientDisconnectMessage;
>
> /* channel_event - calls core->channel_event, must be done in main
> thread */
> -static void main_dispatcher_self_handle_channel_event(
> - int event,
> - SpiceChannelEventInf
> o *info)
> +static void main_dispatcher_self_handle_channel_event(MainDispatcher
> *self,
> + int event,
> + SpiceChannelEv
> entInfo *info)
> {
> - reds_handle_channel_event(reds, event, info);
> + reds_handle_channel_event(self->reds, event, info);
> }
>
> static void main_dispatcher_handle_channel_event(void *opaque,
> void *payload)
> {
> + MainDispatcher *self = opaque;
> MainDispatcherChannelEventMessage *channel_event = payload;
>
> - main_dispatcher_self_handle_channel_event(channel_event->event,
> + main_dispatcher_self_handle_channel_event(self,
> + channel_event->event,
> channel_event->info);
> }
>
> -void main_dispatcher_channel_event(int event, SpiceChannelEventInfo
> *info)
> +void main_dispatcher_channel_event(MainDispatcher *self, int event,
> SpiceChannelEventInfo *info)
> {
> MainDispatcherChannelEventMessage msg = {0,};
>
> - if (pthread_self() == main_dispatcher.base.self) {
> - main_dispatcher_self_handle_channel_event(event, info);
> + if (pthread_self() == self->base.self) {
> + main_dispatcher_self_handle_channel_event(self, event,
> info);
> return;
> }
> msg.event = event;
> msg.info = info;
> - dispatcher_send_message(&main_dispatcher.base,
> MAIN_DISPATCHER_CHANNEL_EVENT,
> + dispatcher_send_message(&self->base,
> MAIN_DISPATCHER_CHANNEL_EVENT,
> &msg);
> }
>
> @@ -116,67 +117,71 @@ void main_dispatcher_channel_event(int event,
> SpiceChannelEventInfo *info)
> static void main_dispatcher_handle_migrate_complete(void *opaque,
> void *payload)
> {
> + MainDispatcher *self = opaque;
> MainDispatcherMigrateSeamlessDstCompleteMessage *mig_complete =
> payload;
>
> - reds_on_client_seamless_migrate_complete(reds, mig_complete-
> >client);
> + reds_on_client_seamless_migrate_complete(self->reds,
> mig_complete->client);
> red_client_unref(mig_complete->client);
> }
>
> static void main_dispatcher_handle_mm_time_latency(void *opaque,
> void *payload)
> {
> + MainDispatcher *self = opaque;
> MainDispatcherMmTimeLatencyMessage *msg = payload;
> - reds_set_client_mm_time_latency(reds, msg->client, msg-
> >latency);
> + reds_set_client_mm_time_latency(self->reds, msg->client, msg-
> >latency);
> red_client_unref(msg->client);
> }
>
> static void main_dispatcher_handle_client_disconnect(void *opaque,
> void *payload)
> {
> + MainDispatcher *self = opaque;
> MainDispatcherClientDisconnectMessage *msg = payload;
>
> spice_debug("client=%p", msg->client);
> - reds_client_disconnect(reds, msg->client);
> + reds_client_disconnect(self->reds, msg->client);
> red_client_unref(msg->client);
> }
>
> -void main_dispatcher_seamless_migrate_dst_complete(RedClient
> *client)
> +void main_dispatcher_seamless_migrate_dst_complete(MainDispatcher
> *self,
> + RedClient
> *client)
> {
> MainDispatcherMigrateSeamlessDstCompleteMessage msg;
>
> - if (pthread_self() == main_dispatcher.base.self) {
> - reds_on_client_seamless_migrate_complete(reds, client);
> + if (pthread_self() == self->base.self) {
> + reds_on_client_seamless_migrate_complete(self->reds,
> client);
> return;
> }
>
> msg.client = red_client_ref(client);
> - dispatcher_send_message(&main_dispatcher.base,
> MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
> + dispatcher_send_message(&self->base,
> MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
> &msg);
> }
>
> -void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t
> latency)
> +void main_dispatcher_set_mm_time_latency(MainDispatcher *self,
> RedClient *client, uint32_t latency)
> {
> MainDispatcherMmTimeLatencyMessage msg;
>
> - if (pthread_self() == main_dispatcher.base.self) {
> - reds_set_client_mm_time_latency(reds, client, latency);
> + if (pthread_self() == self->base.self) {
> + reds_set_client_mm_time_latency(self->reds, client,
> latency);
> return;
> }
>
> msg.client = red_client_ref(client);
> msg.latency = latency;
> - dispatcher_send_message(&main_dispatcher.base,
> MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
> + dispatcher_send_message(&self->base,
> MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
> &msg);
> }
>
> -void main_dispatcher_client_disconnect(RedClient *client)
> +void main_dispatcher_client_disconnect(MainDispatcher *self,
> RedClient *client)
> {
> MainDispatcherClientDisconnectMessage msg;
>
> if (!client->disconnecting) {
> spice_debug("client %p", client);
> msg.client = red_client_ref(client);
> - dispatcher_send_message(&main_dispatcher.base,
> MAIN_DISPATCHER_CLIENT_DISCONNECT,
> + dispatcher_send_message(&self->base,
> MAIN_DISPATCHER_CLIENT_DISCONNECT,
> &msg);
> } else {
> spice_debug("client %p already during disconnection",
> client);
> @@ -185,9 +190,9 @@ void main_dispatcher_client_disconnect(RedClient
> *client)
>
> static void dispatcher_handle_read(int fd, int event, void *opaque)
> {
> - Dispatcher *dispatcher = opaque;
> + MainDispatcher *self = opaque;
>
> - dispatcher_handle_recv_read(dispatcher);
> + dispatcher_handle_recv_read(&self->base);
> }
>
> /*
> @@ -195,23 +200,25 @@ static void dispatcher_handle_read(int fd, int
> event, void *opaque)
> * Reds routines shouldn't be exposed. Instead reds.c should
> register the callbacks,
> * and the corresponding operations should be made only via
> main_dispatcher.
> */
> -void main_dispatcher_init(SpiceCoreInterfaceInternal *core)
> +MainDispatcher* main_dispatcher_new(RedsState *reds,
> SpiceCoreInterfaceInternal *core)
> {
> - memset(&main_dispatcher, 0, sizeof(main_dispatcher));
> - main_dispatcher.core = core;
> - dispatcher_init(&main_dispatcher.base,
> MAIN_DISPATCHER_NUM_MESSAGES, &main_dispatcher.base);
> - core->watch_add(core, main_dispatcher.base.recv_fd,
> SPICE_WATCH_EVENT_READ,
> - dispatcher_handle_read, &main_dispatcher.base);
> - dispatcher_register_handler(&main_dispatcher.base,
> MAIN_DISPATCHER_CHANNEL_EVENT,
> + MainDispatcher *main_dispatcher = g_new0(MainDispatcher, 1);
> + main_dispatcher->core = core;
> + main_dispatcher->reds = reds;
> + dispatcher_init(&main_dispatcher->base,
> MAIN_DISPATCHER_NUM_MESSAGES, main_dispatcher);
> + core->watch_add(core, main_dispatcher->base.recv_fd,
> SPICE_WATCH_EVENT_READ,
> + dispatcher_handle_read, main_dispatcher);
> + dispatcher_register_handler(&main_dispatcher->base,
> MAIN_DISPATCHER_CHANNEL_EVENT,
> main_dispatcher_handle_channel_event
> ,
> sizeof(MainDispatcherChannelEventMes
> sage), 0 /* no ack */);
> - dispatcher_register_handler(&main_dispatcher.base,
> MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
> + dispatcher_register_handler(&main_dispatcher->base,
> MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
> main_dispatcher_handle_migrate_compl
> ete,
> sizeof(MainDispatcherMigrateSeamless
> DstCompleteMessage), 0 /* no ack */);
> - dispatcher_register_handler(&main_dispatcher.base,
> MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
> + dispatcher_register_handler(&main_dispatcher->base,
> MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
> main_dispatcher_handle_mm_time_laten
> cy,
> sizeof(MainDispatcherMmTimeLatencyMe
> ssage), 0 /* no ack */);
> - dispatcher_register_handler(&main_dispatcher.base,
> MAIN_DISPATCHER_CLIENT_DISCONNECT,
> + dispatcher_register_handler(&main_dispatcher->base,
> MAIN_DISPATCHER_CLIENT_DISCONNECT,
> main_dispatcher_handle_client_discon
> nect,
> sizeof(MainDispatcherClientDisconnec
> tMessage), 0 /* no ack */);
> + return main_dispatcher;
> }
> diff --git a/server/main-dispatcher.h b/server/main-dispatcher.h
> index 1a06229..cbc3657 100644
> --- a/server/main-dispatcher.h
> +++ b/server/main-dispatcher.h
> @@ -21,16 +21,18 @@
> #include <spice.h>
> #include "red-channel.h"
>
> -void main_dispatcher_channel_event(int event, SpiceChannelEventInfo
> *info);
> -void main_dispatcher_seamless_migrate_dst_complete(RedClient
> *client);
> -void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t
> latency);
> +typedef struct MainDispatcher MainDispatcher;
> +
> +void main_dispatcher_channel_event(MainDispatcher *self, int event,
> SpiceChannelEventInfo *info);
> +void main_dispatcher_seamless_migrate_dst_complete(MainDispatcher
> *self, RedClient *client);
> +void main_dispatcher_set_mm_time_latency(MainDispatcher *self,
> RedClient *client, uint32_t latency);
> /*
> * Disconnecting the client is always executed asynchronously,
> * in order to protect from expired references in the routines
> * that triggered the client destruction.
> */
> -void main_dispatcher_client_disconnect(RedClient *client);
> +void main_dispatcher_client_disconnect(MainDispatcher *self,
> RedClient *client);
>
> -void main_dispatcher_init(SpiceCoreInterfaceInternal *core);
> +MainDispatcher* main_dispatcher_new(RedsState *reds,
> SpiceCoreInterfaceInternal *core);
>
> #endif //MAIN_DISPATCHER_H
> diff --git a/server/red-channel.c b/server/red-channel.c
> index 757bb6e..d7ff37e 100644
> --- a/server/red-channel.c
> +++ b/server/red-channel.c
> @@ -941,6 +941,7 @@ error:
>
> static void
> red_channel_client_seamless_migration_done(RedChannelClient *rcc)
> {
> + RedsState *reds = red_channel_get_server(rcc->channel);
> rcc->wait_migrate_data = FALSE;
>
> pthread_mutex_lock(&rcc->client->lock);
> @@ -953,7 +954,8 @@ static void
> red_channel_client_seamless_migration_done(RedChannelClient *rcc)
> rcc->client->seamless_migrate = FALSE;
> /* migration completion might have been triggered from a
> different thread
> * than the main thread */
> - main_dispatcher_seamless_migrate_dst_complete(rcc->client);
> + main_dispatcher_seamless_migrate_dst_complete(reds_get_main_
> dispatcher(reds),
> + rcc->client);
> if (rcc->latency_monitor.timer) {
> red_channel_client_start_ping_timer(rcc,
> PING_TEST_IDLE_NET_TIMEOUT_MS);
> }
> diff --git a/server/reds-private.h b/server/reds-private.h
> index c214091..f567929 100644
> --- a/server/reds-private.h
> +++ b/server/reds-private.h
> @@ -242,6 +242,7 @@ struct RedsState {
> RedSSLParameters ssl_parameters;
> SpiceCoreInterfaceInternal *core;
> GList *dispatchers;
> + MainDispatcher *main_dispatcher;
> };
>
> #endif
> diff --git a/server/reds-stream.c b/server/reds-stream.c
> index ec720e0..140b767 100644
> --- a/server/reds-stream.c
> +++ b/server/reds-stream.c
> @@ -349,7 +349,9 @@ void reds_stream_free(RedsStream *s)
>
> void reds_stream_push_channel_event(RedsStream *s, int event)
> {
> - main_dispatcher_channel_event(event, s->priv->info);
> + RedsState *reds = s->priv->reds;
> + MainDispatcher *md = reds_get_main_dispatcher(reds);
> + main_dispatcher_channel_event(md, event, s->priv->info);
> }
>
> static void reds_stream_set_socket(RedsStream *stream, int socket)
> diff --git a/server/reds.c b/server/reds.c
> index 18152f9..dd6ffd9 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -3350,7 +3350,7 @@ static int do_spice_init(RedsState *reds,
> SpiceCoreInterface *core_interface)
> reds_init_vd_agent_resources(reds);
> ring_init(&reds->clients);
> reds->num_clients = 0;
> - main_dispatcher_init(reds->core);
> + reds->main_dispatcher = main_dispatcher_new(reds, reds->core);
> ring_init(&reds->channels);
> ring_init(&reds->mig_target_clients);
> ring_init(&reds->char_devs_states);
> @@ -4197,3 +4197,8 @@ uint32_t reds_qxl_ram_size(RedsState *reds)
> first = reds->dispatchers->data;
> return red_dispatcher_qxl_ram_size(first);
> }
> +
> +MainDispatcher* reds_get_main_dispatcher(RedsState *reds)
> +{
> + return reds->main_dispatcher;
> +}
> diff --git a/server/reds.h b/server/reds.h
> index 686aaac..891a1ea 100644
> --- a/server/reds.h
> +++ b/server/reds.h
> @@ -28,6 +28,7 @@
> #include "common/messages.h"
> #include "spice.h"
> #include "red-channel.h"
> +#include "main-dispatcher.h"
> #include "migration-protocol.h"
>
> typedef struct RedsState RedsState;
> @@ -115,5 +116,6 @@ void reds_update_client_mouse_allowed(RedsState
> *reds);
> gboolean reds_use_client_monitors_config(RedsState *reds);
> void reds_client_monitors_config(RedsState *reds,
> VDAgentMonitorsConfig *monitors_config);
> void reds_set_mm_time(RedsState *reds, uint32_t mm_time);
> +MainDispatcher* reds_get_main_dispatcher(RedsState *reds);
>
> #endif
> diff --git a/server/stream.c b/server/stream.c
> index 3120860..2bfb993 100644
> --- a/server/stream.c
> +++ b/server/stream.c
> @@ -683,6 +683,7 @@ static void update_client_playback_delay(void
> *opaque, uint32_t delay_ms)
> {
> StreamAgent *agent = opaque;
> DisplayChannelClient *dcc = agent->dcc;
> + RedsState *reds = red_channel_get_server(dcc-
> >common.base.channel);
>
> dcc_update_streams_max_latency(dcc, agent);
>
> @@ -691,7 +692,9 @@ static void update_client_playback_delay(void
> *opaque, uint32_t delay_ms)
> agent->dcc->streams_max_latency = delay_ms;
> }
> spice_debug("resetting client latency: %u", agent->dcc-
> >streams_max_latency);
> - main_dispatcher_set_mm_time_latency(RED_CHANNEL_CLIENT(agent-
> >dcc)->client, agent->dcc->streams_max_latency);
> + main_dispatcher_set_mm_time_latency(reds_get_main_dispatcher(red
> s),
> + RED_CHANNEL_CLIENT(agent-
> >dcc)->client,
> + agent->dcc-
> >streams_max_latency);
> }
>
> void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
Acked-by: Fabiano Fidêncio <fidencio@xxxxxxxxxx>
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel