Re: [PATCH 15/18] Remove global main_dispatcher variable

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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




[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]