char-device: use local 'reds' variable

Store a reference to the server in the SpiceCharDeviceState struct and
use that rather than the global 'reds' variable

4 files changed, 22 insertions, 15 deletions

diff --git a/server/char-device.c b/server/char-device.c
index 6c64480c..c9265e29 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -67,7 +67,7 @@ struct SpiceCharDeviceState {
 
     SpiceCharDeviceCallbacks cbs;
     void *opaque;
-    void *reds;
+    RedsState *reds;
 };
 
 enum {
@@ -146,7 +146,7 @@ static void spice_char_device_client_free(SpiceCharDeviceState *dev,
     RingItem *item, *next;
 
     if (dev_client->wait_for_tokens_timer) {
-        reds_get_core_interface(reds)->timer_remove(dev_client->wait_for_tokens_timer);
+        reds_get_core_interface(dev->reds)->timer_remove(dev_client->wait_for_tokens_timer);
     }
 
     spice_char_device_client_send_queue_free(dev, dev_client);
@@ -252,7 +252,7 @@ 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) {
-        reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
+        reds_get_core_interface(dev->reds)->timer_start(dev_client->wait_for_tokens_timer,
                                                    SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
@@ -352,6 +352,7 @@ static void spice_char_device_client_send_queue_push(SpiceCharDeviceClientState
 static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClientState *dev_client,
                                                            uint32_t tokens)
 {
+    SpiceCharDeviceState *dev = dev_client->dev;
     dev_client->num_send_tokens += tokens;
 
     if (dev_client->send_queue_size) {
@@ -360,12 +361,12 @@ static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClient
     }
 
     if (spice_char_device_can_send_to_client(dev_client)) {
-        reds_get_core_interface(reds)->timer_cancel(dev_client->wait_for_tokens_timer);
+        reds_get_core_interface(dev->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) {
-        reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
-                                                   SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+        reds_get_core_interface(dev->reds)->timer_start(dev_client->wait_for_tokens_timer,
+                                                        SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
 }
@@ -441,7 +442,7 @@ static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
     spice_char_device_state_ref(dev);
 
     if (dev->write_to_dev_timer) {
-        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(dev->reds)->timer_cancel(dev->write_to_dev_timer);
     }
 
     sif = SPICE_CONTAINEROF(dev->sin->base.sif, SpiceCharDeviceInterface, base);
@@ -478,8 +479,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) {
-                reds_get_core_interface(reds)->timer_start(dev->write_to_dev_timer,
-                                                           CHAR_DEVICE_WRITE_TO_TIMEOUT);
+                reds_get_core_interface(dev->reds)->timer_start(dev->write_to_dev_timer,
+                                                                CHAR_DEVICE_WRITE_TO_TIMEOUT);
             }
         } else {
             spice_assert(ring_is_empty(&dev->write_queue));
@@ -495,7 +496,7 @@ static void spice_char_dev_write_retry(void *opaque)
     SpiceCharDeviceState *dev = opaque;
 
     if (dev->write_to_dev_timer) {
-        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(dev->reds)->timer_cancel(dev->write_to_dev_timer);
     }
     spice_char_device_write_to_device(dev);
 }
@@ -637,6 +638,7 @@ void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
  ********************************/
 
 SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+                                                     RedsState *reds,
                                                      uint32_t client_tokens_interval,
                                                      uint32_t self_tokens,
                                                      SpiceCharDeviceCallbacks *cbs,
@@ -652,6 +654,7 @@ SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *si
 
     char_dev = spice_new0(SpiceCharDeviceState, 1);
     char_dev->sin = sin;
+    char_dev->reds = reds;
     char_dev->cbs = *cbs;
     char_dev->opaque = opaque;
     char_dev->client_tokens_interval = client_tokens_interval;
@@ -710,9 +713,9 @@ static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev)
 
 void spice_char_device_state_destroy(SpiceCharDeviceState *char_dev)
 {
-    reds_on_char_device_state_destroy(reds, char_dev);
+    reds_on_char_device_state_destroy(char_dev->reds, char_dev);
     if (char_dev->write_to_dev_timer) {
-        reds_get_core_interface(reds)->timer_remove(char_dev->write_to_dev_timer);
+        reds_get_core_interface(char_dev->reds)->timer_remove(char_dev->write_to_dev_timer);
     }
     write_buffers_queue_free(&char_dev->write_queue);
     write_buffers_queue_free(&char_dev->write_bufs_pool);
@@ -762,8 +765,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 = reds_get_core_interface(reds)->timer_add(device_client_wait_for_tokens_timeout,
-                                                                                     dev_client);
+        dev_client->wait_for_tokens_timer =
+            reds_get_core_interface(dev->reds)->timer_add(device_client_wait_for_tokens_timeout,
+                                                          dev_client);
         if (!dev_client->wait_for_tokens_timer) {
             spice_error("failed to create wait for tokens timer");
         }
@@ -822,7 +826,7 @@ void spice_char_device_stop(SpiceCharDeviceState *dev)
     dev->running = FALSE;
     dev->active = FALSE;
     if (dev->write_to_dev_timer) {
-        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(dev->reds)->timer_cancel(dev->write_to_dev_timer);
     }
 }
 
diff --git a/server/char-device.h b/server/char-device.h
index c4039712..349dc808 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -111,6 +111,7 @@ typedef struct SpiceCharDeviceCallbacks {
 } SpiceCharDeviceCallbacks;
 
 SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+                                                     RedsState *reds,
                                                      uint32_t client_tokens_interval,
                                                      uint32_t self_tokens,
                                                      SpiceCharDeviceCallbacks *cbs,
diff --git a/server/reds.c b/server/reds.c
index 9ad2d5b5..45b26c8a 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -2836,6 +2836,7 @@ static SpiceCharDeviceState *attach_to_red_agent(RedsState *reds, SpiceCharDevic
         char_dev_state_cbs.on_free_self_token = vdi_port_on_free_self_token;
 
         state->base = spice_char_device_state_create(sin,
+                                                     reds,
                                                      REDS_TOKENS_TO_SEND,
                                                      REDS_NUM_INTERNAL_AGENT_MESSAGES,
                                                      &char_dev_state_cbs,
diff --git a/server/spicevmc.c b/server/spicevmc.c
index d4426caa..c717cd9b 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -537,6 +537,7 @@ SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
     char_dev_cbs.remove_client = spicevmc_char_dev_remove_client;
 
     state->chardev_st = spice_char_device_state_create(sin,
+                                                       reds,
                                                        0, /* tokens interval */
                                                        ~0, /* self tokens */
                                                        &char_dev_cbs,