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.
> 

Not so easy to do and can be done with an additional patch to this.

> >  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
> 

Acked-by: Frediano Ziglio <fziglio@xxxxxxxxxx>

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]