Re: [PATCH 05/18] Move 'core' into RedsState struct

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

 



> 
> From: Jonathon Jongsma <jjongsma@xxxxxxxxxx>
> 
> Also add reds_get_core_interface() accessor for external use.
> ---
>  server/char-device.c    | 32 ++++++++++++++++---------------
>  server/inputs-channel.c |  7 ++++---
>  server/main-channel.c   | 13 +++++++------
>  server/reds-private.h   |  2 ++
>  server/reds-stream.c    | 12 ++++++------
>  server/reds.c           | 51
>  ++++++++++++++++++++++++++-----------------------
>  server/reds.h           |  3 +--
>  server/smartcard.c      |  3 ++-
>  server/sound.c          | 13 +++++++------
>  server/spicevmc.c       |  2 +-
>  10 files changed, 74 insertions(+), 64 deletions(-)
> 
> diff --git a/server/char-device.c b/server/char-device.c
> index aa2eafd..6093599 100644
> --- a/server/char-device.c
> +++ b/server/char-device.c
> @@ -156,7 +156,7 @@ static void
> spice_char_device_client_free(SpiceCharDeviceState *dev,
>      RingItem *item, *next;
>  
>      if (dev_client->wait_for_tokens_timer) {
> -        core->timer_remove(dev_client->wait_for_tokens_timer);
> +
> reds_get_core_interface(reds)->timer_remove(dev_client->wait_for_tokens_timer);
>      }
>  
>      spice_char_device_client_send_queue_free(dev, dev_client);
> @@ -262,8 +262,8 @@ static void
> spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState
>      ring_add(&dev_client->send_queue, &msg_item->link);
>      dev_client->send_queue_size++;
>      if (!dev_client->wait_for_tokens_started) {
> -        core->timer_start(dev_client->wait_for_tokens_timer,
> -                          SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> +
> reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
> +
> SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
>          dev_client->wait_for_tokens_started = TRUE;
>      }
>  }
> @@ -370,12 +370,12 @@ static void
> spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClient
>      }
>  
>      if (spice_char_device_can_send_to_client(dev_client)) {
> -        core->timer_cancel(dev_client->wait_for_tokens_timer);
> +
> reds_get_core_interface(reds)->timer_cancel(dev_client->wait_for_tokens_timer);
>          dev_client->wait_for_tokens_started = FALSE;
>          spice_char_device_read_from_device(dev_client->dev);
>      } else if (dev_client->send_queue_size) {
> -        core->timer_start(dev_client->wait_for_tokens_timer,
> -                          SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
> +
> reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
> +
> SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
>          dev_client->wait_for_tokens_started = TRUE;
>      }
>  }
> @@ -456,7 +456,7 @@ static int
> spice_char_device_write_to_device(SpiceCharDeviceState *dev)
>      spice_char_device_state_ref(dev);
>  
>      if (dev->write_to_dev_timer) {
> -        core->timer_cancel(dev->write_to_dev_timer);
> +
> reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
>      }
>  
>      sif = SPICE_CONTAINEROF(dev->sin->base.sif, SpiceCharDeviceInterface,
>      base);
> @@ -498,8 +498,8 @@ static int
> spice_char_device_write_to_device(SpiceCharDeviceState *dev)
>      if (dev->running) {
>          if (dev->cur_write_buf) {
>              if (dev->write_to_dev_timer) {
> -                core->timer_start(dev->write_to_dev_timer,
> -                                  CHAR_DEVICE_WRITE_TO_TIMEOUT);
> +
> reds_get_core_interface(reds)->timer_start(dev->write_to_dev_timer,
> +
> CHAR_DEVICE_WRITE_TO_TIMEOUT);
>              }
>          } else {
>              spice_assert(ring_is_empty(&dev->write_queue));
> @@ -516,7 +516,7 @@ static void spice_char_dev_write_retry(void *opaque)
>      SpiceCharDeviceState *dev = opaque;
>  
>      if (dev->write_to_dev_timer) {
> -        core->timer_cancel(dev->write_to_dev_timer);
> +
> reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
>      }
>      spice_char_device_write_to_device(dev);
>  }
> @@ -695,7 +695,8 @@ SpiceCharDeviceState
> *spice_char_device_state_create(SpiceCharDeviceInstance *si
>      sif = SPICE_CONTAINEROF(char_dev->sin->base.sif,
>      SpiceCharDeviceInterface, base);
>      if (sif->base.minor_version <= 2 ||
>          !(sif->flags & SPICE_CHAR_DEVICE_NOTIFY_WRITABLE)) {
> -        char_dev->write_to_dev_timer = core->timer_add(core,
> spice_char_dev_write_retry, char_dev);
> +        char_dev->write_to_dev_timer =
> reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
> +
> spice_char_dev_write_retry,
> char_dev);
>          if (!char_dev->write_to_dev_timer) {
>              spice_error("failed creating char dev write timer");
>          }
> @@ -743,7 +744,7 @@ void spice_char_device_state_destroy(SpiceCharDeviceState
> *char_dev)
>  {
>      reds_on_char_device_state_destroy(reds, char_dev);
>      if (char_dev->write_to_dev_timer) {
> -        core->timer_remove(char_dev->write_to_dev_timer);
> +
> reds_get_core_interface(reds)->timer_remove(char_dev->write_to_dev_timer);
>          char_dev->write_to_dev_timer = NULL;
>      }
>      write_buffers_queue_free(&char_dev->write_queue);
> @@ -794,8 +795,9 @@ int spice_char_device_client_add(SpiceCharDeviceState
> *dev,
>      dev_client->max_send_queue_size = max_send_queue_size;
>      dev_client->do_flow_control = do_flow_control;
>      if (do_flow_control) {
> -        dev_client->wait_for_tokens_timer = core->timer_add(core,
> device_client_wait_for_tokens_timeout,
> -                                                            dev_client);
> +        dev_client->wait_for_tokens_timer =
> reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
> +
> device_client_wait_for_tokens_timeout,
> +
> dev_client);
>          if (!dev_client->wait_for_tokens_timer) {
>              spice_error("failed to create wait for tokens timer");
>          }
> @@ -860,7 +862,7 @@ void spice_char_device_stop(SpiceCharDeviceState *dev)
>      dev->running = FALSE;
>      dev->active = FALSE;
>      if (dev->write_to_dev_timer) {
> -        core->timer_cancel(dev->write_to_dev_timer);
> +
> reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
>      }
>  }
>  
> diff --git a/server/inputs-channel.c b/server/inputs-channel.c
> index 319d26c..5e884f4 100644
> --- a/server/inputs-channel.c
> +++ b/server/inputs-channel.c
> @@ -186,7 +186,7 @@ static void
> inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
>  
>  static void activate_modifiers_watch(void)
>  {
> -    core->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
> +    reds_get_core_interface(reds)->timer_start(key_modifiers_timer,
> KEY_MODIFIERS_TTL);
>  }
>  
>  static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
> @@ -628,7 +628,7 @@ InputsChannel* inputs_channel_new(void)
>  
>      inputs = (InputsChannel *)red_channel_create_parser(
>                                      sizeof(InputsChannel),
> -                                    core,
> +                                    reds_get_core_interface(reds),
>                                      SPICE_CHANNEL_INPUTS, 0,
>                                      FALSE, /* handle_acks */
>                                      spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS,
>                                      NULL),
> @@ -647,7 +647,8 @@ InputsChannel* inputs_channel_new(void)
>      red_channel_set_cap(&inputs->base, SPICE_INPUTS_CAP_KEY_SCANCODE);
>      reds_register_channel(reds, &inputs->base);
>  
> -    if (!(key_modifiers_timer = core->timer_add(core, key_modifiers_sender,
> inputs))) {
> +    if (!(key_modifiers_timer =
> reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
> +
> key_modifiers_sender,
> inputs))) {
>          spice_error("key modifiers timer create failed");
>      }
>      return inputs;
> diff --git a/server/main-channel.c b/server/main-channel.c
> index aa2b03c..c2a7b8b 100644
> --- a/server/main-channel.c
> +++ b/server/main-channel.c
> @@ -1052,9 +1052,9 @@ static void do_ping_client(MainChannelClient *mcc,
>          if (has_interval && interval > 0) {
>              mcc->ping_interval = interval * MSEC_PER_SEC;
>          }
> -        core->timer_start(mcc->ping_timer, mcc->ping_interval);
> +        reds_get_core_interface(reds)->timer_start(mcc->ping_timer,
> mcc->ping_interval);
>      } else if (!strcmp(opt, "off")) {
> -        core->timer_cancel(mcc->ping_timer);
> +        reds_get_core_interface(reds)->timer_cancel(mcc->ping_timer);
>      } else {
>          return;
>      }
> @@ -1066,11 +1066,11 @@ static void ping_timer_cb(void *opaque)
>  
>      if (!red_channel_client_is_connected(&mcc->base)) {
>          spice_printerr("not connected to peer, ping off");
> -        core->timer_cancel(mcc->ping_timer);
> +        reds_get_core_interface(reds)->timer_cancel(mcc->ping_timer);
>          return;
>      }
>      do_ping_client(mcc, NULL, 0, 0);
> -    core->timer_start(mcc->ping_timer, mcc->ping_interval);
> +    reds_get_core_interface(reds)->timer_start(mcc->ping_timer,
> mcc->ping_interval);
>  }
>  #endif /* RED_STATISTICS */
>  
> @@ -1087,7 +1087,8 @@ static MainChannelClient
> *main_channel_client_create(MainChannel *main_chan, Red
>      mcc->connection_id = connection_id;
>      mcc->bitrate_per_sec = ~0;
>  #ifdef RED_STATISTICS
> -    if (!(mcc->ping_timer = core->timer_add(core, ping_timer_cb, NULL))) {
> +    if (!(mcc->ping_timer =
> reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
> +
> ping_timer_cb,
> NULL))) {
>          spice_error("ping timer create failed");
>      }
>      mcc->ping_interval = PING_INTERVAL;
> @@ -1178,7 +1179,7 @@ MainChannel* main_channel_new(void)
>      channel_cbs.handle_migrate_data = main_channel_handle_migrate_data;
>  
>      // TODO: set the migration flag of the channel
> -    channel = red_channel_create_parser(sizeof(MainChannel), core,
> +    channel = red_channel_create_parser(sizeof(MainChannel),
> reds_get_core_interface(reds),
>                                          SPICE_CHANNEL_MAIN, 0,
>                                          FALSE, /* handle_acks */
>                                          spice_get_client_channel_parser(SPICE_CHANNEL_MAIN,
>                                          NULL),
> diff --git a/server/reds-private.h b/server/reds-private.h
> index 9db0da2..e5444d6 100644
> --- a/server/reds-private.h
> +++ b/server/reds-private.h
> @@ -236,6 +236,8 @@ struct RedsState {
>      gboolean exit_on_disconnect;
>  
>      RedSSLParameters ssl_parameters;
> +    SpiceCoreInterfaceInternal *core;
> +
>  };
>  
>  #endif
> diff --git a/server/reds-stream.c b/server/reds-stream.c
> index 2b1c5b9..2eb8f89 100644
> --- a/server/reds-stream.c
> +++ b/server/reds-stream.c
> @@ -22,6 +22,7 @@
>  #include "main-dispatcher.h"
>  #include "red-common.h"
>  #include "reds-stream.h"
> +#include "reds.h"
>  #include "common/log.h"
>  
>  #include <errno.h>
> @@ -44,8 +45,6 @@ struct AsyncRead {
>  };
>  typedef struct AsyncRead AsyncRead;
>  
> -extern SpiceCoreInterfaceInternal *core;
> -
>  #if HAVE_SASL
>  #include <sasl/sasl.h>
>  
> @@ -168,7 +167,7 @@ static ssize_t stream_ssl_read_cb(RedsStream *s, void
> *buf, size_t size)
>  void reds_stream_remove_watch(RedsStream* s)
>  {
>      if (s->watch) {
> -        core->watch_remove(s->watch);
> +        reds_get_core_interface(reds)->watch_remove(s->watch);
>          s->watch = NULL;
>      }
>  }
> @@ -497,9 +496,10 @@ static void async_read_handler(G_GNUC_UNUSED int fd,
>                  switch (errno) {
>                  case EAGAIN:
>                      if (!async->stream->watch) {
> -                        async->stream->watch = core->watch_add(core,
> async->stream->socket,
> -
> SPICE_WATCH_EVENT_READ,
> -
> async_read_handler,
> async);
> +                        async->stream->watch =
> reds_get_core_interface(reds)->watch_add(reds_get_core_interface(reds),
> +
> async->stream->socket,
> +
> SPICE_WATCH_EVENT_READ,
> +
> async_read_handler,
> async);
>                      }
>                      return;
>                  case EINTR:
> diff --git a/server/reds.c b/server/reds.c
> index bff64d6..6467c7e 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -72,8 +72,6 @@
>  
>  #include "reds-private.h"
>  
> -SpiceCoreInterfaceInternal *core = NULL;
> -
>  static SpiceCoreInterface *core_public = NULL;
>  

core_public should be moved too.
Note that this variable was not present when this patch was written.
I'll post an update.

>  static SpiceTimer *adapter_timer_add(const SpiceCoreInterfaceInternal
>  *iface, SpiceTimerFunc func, void *opaque)
> @@ -189,7 +187,7 @@ static ChannelSecurityOptions
> *reds_find_channel_security(RedsState *reds, int i
>  
>  void reds_handle_channel_event(int event, SpiceChannelEventInfo *info)
>  {
> -    core->channel_event(event, info);
> +    reds->core->channel_event(event, info);
>  
>      if (event == SPICE_CHANNEL_EVENT_DISCONNECTED) {
>          free(info);
> @@ -381,7 +379,7 @@ static void reds_mig_cleanup(RedsState *reds)
>          reds->mig_inprogress = FALSE;
>          reds->mig_wait_connect = FALSE;
>          reds->mig_wait_disconnect = FALSE;
> -        core->timer_cancel(reds->mig_timer);
> +        reds->core->timer_cancel(reds->mig_timer);
>          reds_mig_cleanup_wait_disconnect(reds);
>      }
>  }
> @@ -2256,10 +2254,10 @@ static void reds_handle_ssl_accept(int fd, int event,
> void *data)
>              reds_link_free(link);
>              return;
>          case REDS_STREAM_SSL_STATUS_WAIT_FOR_READ:
> -            core->watch_update_mask(link->stream->watch,
> SPICE_WATCH_EVENT_READ);
> +            reds->core->watch_update_mask(link->stream->watch,
> SPICE_WATCH_EVENT_READ);
>              return;
>          case REDS_STREAM_SSL_STATUS_WAIT_FOR_WRITE:
> -            core->watch_update_mask(link->stream->watch,
> SPICE_WATCH_EVENT_WRITE);
> +            reds->core->watch_update_mask(link->stream->watch,
> SPICE_WATCH_EVENT_WRITE);
>              return;
>          case REDS_STREAM_SSL_STATUS_OK:
>              reds_stream_remove_watch(link->stream);
> @@ -2337,12 +2335,12 @@ static RedLinkInfo
> *reds_init_client_ssl_connection(int socket)
>          case REDS_STREAM_SSL_STATUS_ERROR:
>              goto error;
>          case REDS_STREAM_SSL_STATUS_WAIT_FOR_READ:
> -            link->stream->watch = core->watch_add(core,
> link->stream->socket, SPICE_WATCH_EVENT_READ,
> -                                            reds_handle_ssl_accept, link);
> +            link->stream->watch = reds->core->watch_add(reds->core,
> link->stream->socket, SPICE_WATCH_EVENT_READ,
> +
> reds_handle_ssl_accept,
> link);
>              break;
>          case REDS_STREAM_SSL_STATUS_WAIT_FOR_WRITE:
> -            link->stream->watch = core->watch_add(core,
> link->stream->socket, SPICE_WATCH_EVENT_WRITE,
> -                                                  reds_handle_ssl_accept,
> link);
> +            link->stream->watch = reds->core->watch_add(reds->core,
> link->stream->socket, SPICE_WATCH_EVENT_WRITE,
> +
> reds_handle_ssl_accept,
> link);
>              break;
>      }
>      return link;
> @@ -2534,9 +2532,9 @@ static int reds_init_net(RedsState *reds)
>          if (-1 == reds->listen_socket) {
>              return -1;
>          }
> -        reds->listen_watch = core->watch_add(core, reds->listen_socket,
> -                                             SPICE_WATCH_EVENT_READ,
> -                                             reds_accept, NULL);
> +        reds->listen_watch = reds->core->watch_add(reds->core,
> reds->listen_socket,
> +                                                   SPICE_WATCH_EVENT_READ,
> +                                                   reds_accept, NULL);
>          if (reds->listen_watch == NULL) {
>              spice_warning("set fd handle failed");
>              return -1;
> @@ -2549,9 +2547,9 @@ static int reds_init_net(RedsState *reds)
>          if (-1 == reds->secure_listen_socket) {
>              return -1;
>          }
> -        reds->secure_listen_watch = core->watch_add(core,
> reds->secure_listen_socket,
> -                                                    SPICE_WATCH_EVENT_READ,
> -
> reds_accept_ssl_connection,
> NULL);
> +        reds->secure_listen_watch = reds->core->watch_add(reds->core,
> reds->secure_listen_socket,
> +
> SPICE_WATCH_EVENT_READ,
> +
> reds_accept_ssl_connection,
> reds);
>          if (reds->secure_listen_watch == NULL) {
>              spice_warning("set fd handle failed");
>              return -1;
> @@ -2560,9 +2558,9 @@ static int reds_init_net(RedsState *reds)
>  
>      if (reds->spice_listen_socket_fd != -1 ) {
>          reds->listen_socket = reds->spice_listen_socket_fd;
> -        reds->listen_watch = core->watch_add(core, reds->listen_socket,
> -                                             SPICE_WATCH_EVENT_READ,
> -                                             reds_accept, NULL);
> +        reds->listen_watch = reds->core->watch_add(reds->core,
> reds->listen_socket,
> +                                                   SPICE_WATCH_EVENT_READ,
> +                                                   reds_accept, NULL);
>          if (reds->listen_watch == NULL) {
>              spice_warning("set fd handle failed");
>              return -1;
> @@ -2797,7 +2795,7 @@ static void reds_mig_started(RedsState *reds)
>  
>      reds->mig_inprogress = TRUE;
>      reds->mig_wait_connect = TRUE;
> -    core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
> +    reds->core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
>  }
>  
>  static void reds_mig_fill_wait_disconnect(RedsState *reds)
> @@ -2816,7 +2814,7 @@ static void reds_mig_fill_wait_disconnect(RedsState
> *reds)
>          ring_add(&reds->mig_wait_disconnect_clients, &wait_client->link);
>      }
>      reds->mig_wait_disconnect = TRUE;
> -    core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
> +    reds->core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
>  }
>  
>  static void reds_mig_cleanup_wait_disconnect(RedsState *reds)
> @@ -3308,20 +3306,20 @@ static int do_spice_init(RedsState *reds,
> SpiceCoreInterface *core_interface)
>          goto err;
>      }
>      core_public = core_interface;
> -    core = &core_interface_adapter;
> +    reds->core = &core_interface_adapter;
>      reds->listen_socket = -1;
>      reds->secure_listen_socket = -1;
>      reds_init_vd_agent_resources(reds);
>      ring_init(&reds->clients);
>      reds->num_clients = 0;
> -    main_dispatcher_init(core);
> +    main_dispatcher_init(reds->core);
>      ring_init(&reds->channels);
>      ring_init(&reds->mig_target_clients);
>      ring_init(&reds->char_devs_states);
>      ring_init(&reds->mig_wait_disconnect_clients);
>      reds->vm_running = TRUE; /* for backward compatibility */
>  
> -    if (!(reds->mig_timer = core->timer_add(core, migrate_timeout, reds))) {
> +    if (!(reds->mig_timer = reds->core->timer_add(reds->core,
> migrate_timeout, reds))) {
>          spice_error("migration timer create failed");
>      }
>  
> @@ -4021,3 +4019,8 @@ spice_wan_compression_t reds_get_zlib_glz_state(const
> RedsState *reds)
>  {
>      return reds->zlib_glz_state;
>  }
> +
> +SpiceCoreInterfaceInternal* reds_get_core_interface(RedsState *reds)
> +{
> +    return reds->core;
> +}
> diff --git a/server/reds.h b/server/reds.h
> index b1622b0..3a05019 100644
> --- a/server/reds.h
> +++ b/server/reds.h
> @@ -72,8 +72,6 @@ enum {
>      RED_RENDERER_LAST
>  };
>  
> -extern struct SpiceCoreInterfaceInternal *core;
> -
>  // Temporary measures to make splitting reds.c to inputs-channel.c easier
>  
>  /* should be called only from main_dispatcher */
> @@ -112,5 +110,6 @@ void reds_set_client_mm_time_latency(RedsState *reds,
> RedClient *client, uint32_
>  uint32_t reds_get_streaming_video(const RedsState *reds);
>  spice_wan_compression_t reds_get_jpeg_state(const RedsState *reds);
>  spice_wan_compression_t reds_get_zlib_glz_state(const RedsState *reds);
> +SpiceCoreInterfaceInternal* reds_get_core_interface(RedsState *reds);
>  
>  #endif
> diff --git a/server/smartcard.c b/server/smartcard.c
> index 9b8f7c6..0be3235 100644
> --- a/server/smartcard.c
> +++ b/server/smartcard.c
> @@ -848,7 +848,8 @@ static void smartcard_init(void)
>      channel_cbs.handle_migrate_data =
>      smartcard_channel_client_handle_migrate_data;
>  
>      g_smartcard_channel =
>      (SmartCardChannel*)red_channel_create(sizeof(SmartCardChannel),
> -                                             core, SPICE_CHANNEL_SMARTCARD,
> 0,
> +                                             reds_get_core_interface(reds),
> +                                             SPICE_CHANNEL_SMARTCARD, 0,
>                                               FALSE /* handle_acks */,
>                                               smartcard_channel_handle_message,
>                                               &channel_cbs,
> diff --git a/server/sound.c b/server/sound.c
> index 0890a87..3c77d77 100644
> --- a/server/sound.c
> +++ b/server/sound.c
> @@ -213,7 +213,7 @@ static void snd_disconnect_channel(SndChannel *channel)
>      channel->cleanup(channel);
>      red_channel_client_disconnect(worker->connection->channel_client);
>      worker->connection->channel_client = NULL;
> -    core->watch_remove(channel->stream->watch);
> +    reds_get_core_interface(reds)->watch_remove(channel->stream->watch);
>      channel->stream->watch = NULL;
>      reds_stream_free(channel->stream);
>      channel->stream = NULL;
> @@ -266,7 +266,7 @@ static int snd_send_data(SndChannel *channel)
>  
>              if (channel->blocked) {
>                  channel->blocked = FALSE;
> -                core->watch_update_mask(channel->stream->watch,
> SPICE_WATCH_EVENT_READ);
> +
> reds_get_core_interface(reds)->watch_update_mask(channel->stream->watch,
> SPICE_WATCH_EVENT_READ);
>              }
>              break;
>          }
> @@ -278,8 +278,8 @@ static int snd_send_data(SndChannel *channel)
>              switch (errno) {
>              case EAGAIN:
>                  channel->blocked = TRUE;
> -                core->watch_update_mask(channel->stream->watch,
> SPICE_WATCH_EVENT_READ |
> -                                        SPICE_WATCH_EVENT_WRITE);
> +
> reds_get_core_interface(reds)->watch_update_mask(channel->stream->watch,
> SPICE_WATCH_EVENT_READ |
> +
> SPICE_WATCH_EVENT_WRITE);
>                  return FALSE;
>              case EINTR:
>                  break;
> @@ -947,8 +947,9 @@ static SndChannel *__new_channel(SndWorker *worker, int
> size, uint32_t channel_i
>      channel->receive_data.end = channel->receive_data.buf +
>      sizeof(channel->receive_data.buf);
>      channel->send_data.marshaller = spice_marshaller_new();
>  
> -    stream->watch = core->watch_add(core, stream->socket,
> SPICE_WATCH_EVENT_READ,
> -                                  snd_event, channel);
> +    stream->watch =
> reds_get_core_interface(reds)->watch_add(reds_get_core_interface(reds),
> +                                                             stream->socket,
> SPICE_WATCH_EVENT_READ,
> +                                                             snd_event,
> channel);
>      if (stream->watch == NULL) {
>          spice_printerr("watch_add failed, %s", strerror(errno));
>          goto error2;
> diff --git a/server/spicevmc.c b/server/spicevmc.c
> index 28a65d7..95d840e 100644
> --- a/server/spicevmc.c
> +++ b/server/spicevmc.c
> @@ -524,7 +524,7 @@ SpiceCharDeviceState
> *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
>      channel_cbs.handle_migrate_data =
>      spicevmc_channel_client_handle_migrate_data;
>  
>      state = (SpiceVmcState*)red_channel_create(sizeof(SpiceVmcState),
> -                                   core, channel_type, id[channel_type]++,
> +                                   reds_get_core_interface(reds),
> channel_type, id[channel_type]++,
>                                     FALSE /* handle_acks */,
>                                     spicevmc_red_channel_client_handle_message,
>                                     &channel_cbs,

Other part seems ok.
I think Christophe patches now would help. I'll try to move them

Frediano
_______________________________________________
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]