[Spice-commits] 9 commits - server/char-device.c server/char-device.h server/inputs-channel.c server/inputs-channel.h server/main-channel.c server/red-channel.c server/red-channel.h server/reds.c server/reds.h server/reds-private.h server/smartcard.c server/spicevmc.c
Frediano Ziglio
fziglio at kemper.freedesktop.org
Thu Feb 11 13:59:12 UTC 2016
server/char-device.c | 34 ++++++++++++----------
server/char-device.h | 9 ++++--
server/inputs-channel.c | 20 +++++++++----
server/inputs-channel.h | 1
server/main-channel.c | 2 -
server/red-channel.c | 5 ++-
server/red-channel.h | 5 ++-
server/reds-private.h | 8 ++++-
server/reds.c | 72 ++++++++++++++++++++++++++++--------------------
server/reds.h | 2 -
server/smartcard.c | 1
server/spicevmc.c | 6 ++--
12 files changed, 103 insertions(+), 62 deletions(-)
New commits:
commit 127e3ad19160f0c4248dfa49ed697ce652c60834
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Fri Jan 30 16:41:57 2015 -0600
Add RedsState arg to activate_modifiers_watch()
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 38b23df..f47a586 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -192,7 +192,7 @@ static void inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) ? VD_AGENT_MBUTTON_MASK : 0) | \
((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) ? VD_AGENT_RBUTTON_MASK : 0))
-static void activate_modifiers_watch(void)
+static void activate_modifiers_watch(RedsState *reds)
{
reds_get_core_interface(reds)->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
}
@@ -312,7 +312,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (key_down->code == CAPS_LOCK_SCAN_CODE ||
key_down->code == NUM_LOCK_SCAN_CODE ||
key_down->code == SCROLL_LOCK_SCAN_CODE) {
- activate_modifiers_watch();
+ activate_modifiers_watch(reds);
}
}
case SPICE_MSGC_INPUTS_KEY_UP: {
@@ -450,7 +450,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE);
kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE | 0x80);
}
- activate_modifiers_watch();
+ activate_modifiers_watch(reds);
break;
}
case SPICE_MSGC_DISCONNECTING:
commit a8dc9b0936e2ec0d7a7daa20949caa0316b08b4a
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Fri Jan 30 16:32:02 2015 -0600
Add RedsState arg to spicevmc_device_connect|disconnect()
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/char-device.h b/server/char-device.h
index b70ffae..b787855 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -214,8 +214,10 @@ void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
/* api for specific char devices */
-SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
+SpiceCharDeviceState *spicevmc_device_connect(struct RedsState *reds,
+ SpiceCharDeviceInstance *sin,
uint8_t channel_type);
-void spicevmc_device_disconnect(SpiceCharDeviceInstance *char_device);
+void spicevmc_device_disconnect(struct RedsState *reds,
+ SpiceCharDeviceInstance *char_device);
#endif // CHAR_DEVICE_H_
diff --git a/server/reds.c b/server/reds.c
index 800f7b3..1c5d52b 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -3103,13 +3103,13 @@ static int spice_server_char_device_add_interface(SpiceServer *s,
}
#endif
else if (strcmp(char_device->subtype, SUBTYPE_USBREDIR) == 0) {
- dev_state = spicevmc_device_connect(char_device, SPICE_CHANNEL_USBREDIR);
+ dev_state = spicevmc_device_connect(reds, char_device, SPICE_CHANNEL_USBREDIR);
}
else if (strcmp(char_device->subtype, SUBTYPE_PORT) == 0) {
if (strcmp(char_device->portname, "org.spice-space.webdav.0") == 0) {
- dev_state = spicevmc_device_connect(char_device, SPICE_CHANNEL_WEBDAV);
+ dev_state = spicevmc_device_connect(reds, char_device, SPICE_CHANNEL_WEBDAV);
} else {
- dev_state = spicevmc_device_connect(char_device, SPICE_CHANNEL_PORT);
+ dev_state = spicevmc_device_connect(reds, char_device, SPICE_CHANNEL_PORT);
}
}
@@ -3147,7 +3147,7 @@ static void spice_server_char_device_remove_interface(RedsState *reds, SpiceBase
#endif
else if (strcmp(char_device->subtype, SUBTYPE_USBREDIR) == 0 ||
strcmp(char_device->subtype, SUBTYPE_PORT) == 0) {
- spicevmc_device_disconnect(char_device);
+ spicevmc_device_disconnect(reds, char_device);
} else {
spice_warning("failed to remove char device %s", char_device->subtype);
}
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 4460eab..4fc95e3 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -504,7 +504,8 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client,
}
}
-SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
+SpiceCharDeviceState *spicevmc_device_connect(RedsState *reds,
+ SpiceCharDeviceInstance *sin,
uint8_t channel_type)
{
static uint8_t id[256] = { 0, };
@@ -554,7 +555,7 @@ SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
}
/* Must be called from RedClient handling thread. */
-void spicevmc_device_disconnect(SpiceCharDeviceInstance *sin)
+void spicevmc_device_disconnect(RedsState *reds, SpiceCharDeviceInstance *sin)
{
SpiceVmcState *state;
commit d576c76a70ffabe92f2b07f9114e5b3cd153c99f
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Fri Jan 30 14:47:14 2015 -0600
Add RedsState arg to red_on_main_agent_tokens()
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/main-channel.c b/server/main-channel.c
index c2a7b8b..d69095d 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -902,7 +902,7 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint
SpiceMsgcMainAgentTokens *tokens;
tokens = (SpiceMsgcMainAgentTokens *)message;
- reds_on_main_agent_tokens(mcc, tokens->num_tokens);
+ reds_on_main_agent_tokens(reds, mcc, tokens->num_tokens);
break;
}
case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
diff --git a/server/reds.c b/server/reds.c
index 4081113..800f7b3 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -940,7 +940,7 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
reds->agent_state.write_filter.discard_all = FALSE;
}
-void reds_on_main_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
+void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens)
{
if (!reds->vdagent) {
return;
diff --git a/server/reds.h b/server/reds.h
index d1a726f..ef34e15 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -93,7 +93,7 @@ void reds_update_stat_value(uint32_t value);
/* callbacks from main channel messages */
void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens);
-void reds_on_main_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens);
+void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens);
uint8_t *reds_get_agent_data_buffer(RedsState *reds, MainChannelClient *mcc, size_t size);
void reds_release_agent_data_buffer(RedsState *reds, uint8_t *buf);
void reds_on_main_agent_data(RedsState *reds, MainChannelClient *mcc, void *message, size_t size);
commit ec7d59c902ef37f2df8bdc2e7be843e9dc35ff51
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Fri Jan 30 14:35:12 2015 -0600
Store a reference to RedsState in RedsMigTargetClient
This allows RedsMigTargetClient methods to use local variables rather
than the global 'reds' variable
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/reds-private.h b/server/reds-private.h
index 94b7af9..109cca1 100644
--- a/server/reds-private.h
+++ b/server/reds-private.h
@@ -114,6 +114,7 @@ typedef struct RedsMigPendingLink {
} RedsMigPendingLink;
typedef struct RedsMigTargetClient {
+ RedsState *reds;
RingItem link;
RedClient *client;
Ring pending_links;
diff --git a/server/reds.c b/server/reds.c
index 91a93a1..4081113 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -166,7 +166,7 @@ struct ChannelSecurityOptions {
static void migrate_timeout(void *opaque);
static RedsMigTargetClient* reds_mig_target_client_find(RedsState *reds, RedClient *client);
-static void reds_mig_target_client_free(RedsState *reds, RedsMigTargetClient *mig_client);
+static void reds_mig_target_client_free(RedsMigTargetClient *mig_client);
static void reds_mig_cleanup_wait_disconnect(RedsState *reds);
static void reds_mig_remove_wait_disconnect_client(RedsState *reds, RedClient *client);
static void reds_char_device_add_state(RedsState *reds, SpiceCharDeviceState *st);
@@ -468,7 +468,7 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
mig_client = reds_mig_target_client_find(reds, client);
if (mig_client) {
- reds_mig_target_client_free(reds, mig_client);
+ reds_mig_target_client_free(mig_client);
}
if (reds->mig_wait_disconnect) {
@@ -1517,6 +1517,7 @@ static void reds_mig_target_client_add(RedsState *reds, RedClient *client)
spice_info(NULL);
mig_client = spice_malloc0(sizeof(RedsMigTargetClient));
mig_client->client = client;
+ mig_client->reds = reds;
ring_init(&mig_client->pending_links);
ring_add(&reds->mig_target_clients, &mig_client->link);
reds->num_mig_target_clients++;
@@ -1544,7 +1545,6 @@ static void reds_mig_target_client_add_pending_link(RedsMigTargetClient *client,
{
RedsMigPendingLink *mig_link;
- spice_assert(reds);
spice_assert(client);
mig_link = spice_malloc0(sizeof(RedsMigPendingLink));
mig_link->link_msg = link_msg;
@@ -1553,12 +1553,12 @@ static void reds_mig_target_client_add_pending_link(RedsMigTargetClient *client,
ring_add(&client->pending_links, &mig_link->ring_link);
}
-static void reds_mig_target_client_free(RedsState *reds, RedsMigTargetClient *mig_client)
+static void reds_mig_target_client_free(RedsMigTargetClient *mig_client)
{
RingItem *now, *next;
ring_remove(&mig_client->link);
- reds->num_mig_target_clients--;
+ mig_client->reds->num_mig_target_clients--;
RING_FOREACH_SAFE(now, next, &mig_client->pending_links) {
RedsMigPendingLink *mig_link = SPICE_CONTAINEROF(now, RedsMigPendingLink, ring_link);
@@ -1777,7 +1777,7 @@ static int reds_link_mig_target_channels(RedsState *reds, RedClient *client)
reds_channel_do_link(channel, client, mig_link->link_msg, mig_link->stream);
}
- reds_mig_target_client_free(reds, mig_client);
+ reds_mig_target_client_free(mig_client);
return TRUE;
}
commit cca32779f579543b20fa24f4b6aec4cc6c0da6ea
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Jan 29 16:56:43 2015 -0600
spice_server_kbd_leds: don't use global 'reds'
Store a reference to the RedsState server in the keyboard state struct
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 5e884f4..38b23df 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -61,11 +61,19 @@ struct SpiceKbdState {
/* track key press state */
bool key[0x7f];
bool key_ext[0x7f];
+ RedsState *reds;
};
-static SpiceKbdState* spice_kbd_state_new(void)
+static SpiceKbdState* spice_kbd_state_new(RedsState *reds)
+{
+ SpiceKbdState *st = spice_new0(SpiceKbdState, 1);
+ st->reds = reds;
+ return st;
+}
+
+RedsState* spice_kbd_state_get_server(SpiceKbdState *dev)
{
- return spice_new0(SpiceKbdState, 1);
+ return dev->reds;
}
struct SpiceMouseState {
@@ -666,7 +674,7 @@ int inputs_channel_set_keyboard(InputsChannel *inputs, SpiceKbdInstance *keyboar
return -1;
}
inputs->keyboard = keyboard;
- inputs->keyboard->st = spice_kbd_state_new();
+ inputs->keyboard->st = spice_kbd_state_new(reds);
return 0;
}
diff --git a/server/inputs-channel.h b/server/inputs-channel.h
index 31574b5..4070a23 100644
--- a/server/inputs-channel.h
+++ b/server/inputs-channel.h
@@ -40,5 +40,6 @@ int inputs_channel_set_tablet(InputsChannel *inputs, SpiceTabletInstance *tablet
int inputs_channel_has_tablet(InputsChannel *inputs);
void inputs_channel_detach_tablet(InputsChannel *inputs, SpiceTabletInstance *tablet);
RedsState* spice_tablet_state_get_server(SpiceTabletState *dev);
+RedsState* spice_kbd_state_get_server(SpiceKbdState *dev);
#endif
diff --git a/server/reds.c b/server/reds.c
index ef6c850..91a93a1 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -3780,6 +3780,7 @@ SPICE_GNUC_VISIBLE int spice_server_add_renderer(SpiceServer *s, const char *nam
SPICE_GNUC_VISIBLE int spice_server_kbd_leds(SpiceKbdInstance *sin, int leds)
{
+ RedsState *reds = spice_kbd_state_get_server(sin->st);
inputs_channel_on_keyboard_leds_change(reds->inputs_channel, leds);
return 0;
}
commit 2dfcf9c6e3e61bdc71f2c0eee50c1cb645750f1d
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Jan 29 16:43:55 2015 -0600
Add reference to server in RedClient
Allows client methods to not use global 'reds' variable
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/red-channel.c b/server/red-channel.c
index f3a1cea..190779a 100644
--- a/server/red-channel.c
+++ b/server/red-channel.c
@@ -2046,11 +2046,12 @@ void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
* pretty tied together.
*/
-RedClient *red_client_new(int migrated)
+RedClient *red_client_new(RedsState *reds, int migrated)
{
RedClient *client;
client = spice_malloc0(sizeof(RedClient));
+ client->reds = reds;
ring_init(&client->channels);
pthread_mutex_init(&client->lock, NULL);
client->thread_id = pthread_self();
@@ -2212,7 +2213,7 @@ void red_client_semi_seamless_migrate_complete(RedClient *client)
}
}
pthread_mutex_unlock(&client->lock);
- reds_on_client_semi_seamless_migrate_complete(reds, client);
+ reds_on_client_semi_seamless_migrate_complete(client->reds, client);
}
/* should be called only from the main thread */
diff --git a/server/red-channel.h b/server/red-channel.h
index fbb93b7..b5ab7ac 100644
--- a/server/red-channel.h
+++ b/server/red-channel.h
@@ -563,7 +563,10 @@ typedef void (*channel_client_callback)(RedChannelClient *rcc);
typedef void (*channel_client_callback_data)(RedChannelClient *rcc, void *data);
void red_channel_apply_clients(RedChannel *channel, channel_client_callback v);
+struct RedsState;
+
struct RedClient {
+ struct RedsState *reds;
RingItem link;
Ring channels;
int channels_num;
@@ -585,7 +588,7 @@ struct RedClient {
int refs;
};
-RedClient *red_client_new(int migrated);
+RedClient *red_client_new(struct RedsState *reds, int migrated);
/*
* disconnects all the client's channels (should be called from the client's thread)
diff --git a/server/reds.c b/server/reds.c
index b74262b..ef6c850 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -1648,7 +1648,7 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
link->link_mess = NULL;
reds_link_free(link);
caps = (uint32_t *)((uint8_t *)link_mess + link_mess->caps_offset);
- client = red_client_new(mig_target);
+ client = red_client_new(reds, mig_target);
ring_add(&reds->clients, &client->link);
reds->num_clients++;
mcc = main_channel_link(reds->main_channel, client,
commit 451ac31a7aa0813b5453ce8b8a0dc33c0b185b69
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Wed Jan 28 15:52:46 2015 -0600
Remove use of global 'reds' from VDIReadBuf functions
Add a new 'state' property to VDIReadBuf so that we can refer back to
the VDIPortState struct from the readbuf functions.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/reds-private.h b/server/reds-private.h
index 21dbe49..94b7af9 100644
--- a/server/reds-private.h
+++ b/server/reds-private.h
@@ -40,7 +40,10 @@ typedef struct MonitorMode {
uint32_t y_res;
} MonitorMode;
+typedef struct VDIPortState VDIPortState;
+
typedef struct VDIReadBuf {
+ VDIPortState *state;
RingItem link;
uint32_t refs;
@@ -54,7 +57,7 @@ enum {
VDI_PORT_READ_STATE_READ_DATA,
};
-typedef struct VDIPortState {
+struct VDIPortState {
SpiceCharDeviceState *base;
uint32_t plug_generation;
int client_agent_started;
@@ -77,7 +80,7 @@ typedef struct VDIPortState {
SpiceMigrateDataMain *mig_data; /* storing it when migration data arrives
before agent is attached */
-} VDIPortState;
+};
/* messages that are addressed to the agent and are created in the server */
typedef struct __attribute__ ((__packed__)) VDInternalBuf {
diff --git a/server/reds.c b/server/reds.c
index 000aa57..b74262b 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -173,9 +173,9 @@ static void reds_char_device_add_state(RedsState *reds, SpiceCharDeviceState *st
static void reds_char_device_remove_state(RedsState *reds, SpiceCharDeviceState *st);
static void reds_send_mm_time(RedsState *reds);
-static VDIReadBuf *reds_get_vdi_port_read_buf(RedsState *reds);
+static VDIReadBuf *vdi_port_state_get_read_buf(VDIPortState *state);
static VDIReadBuf *vdi_port_read_buf_ref(VDIReadBuf *buf);
-static void vdi_port_read_buf_unref(RedsState *reds, VDIReadBuf *buf);
+static void vdi_port_read_buf_unref(VDIReadBuf *buf);
static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int id)
{
@@ -395,7 +395,7 @@ static void reds_reset_vdp(RedsState *reds)
state->receive_len = sizeof(state->vdi_chunk_header);
state->message_receive_len = 0;
if (state->current_read_buf) {
- vdi_port_read_buf_unref(reds, state->current_read_buf);
+ vdi_port_read_buf_unref(state->current_read_buf);
state->current_read_buf = NULL;
}
/* Reset read filter to start with clean state when the agent reconnects */
@@ -614,7 +614,7 @@ static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
VDIReadBuf *buf = (VDIReadBuf *)opaque;
- vdi_port_read_buf_unref(reds, buf);
+ vdi_port_read_buf_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
@@ -646,9 +646,8 @@ static int vdi_port_read_buf_process(RedsState *reds, int port, VDIReadBuf *buf)
}
}
-static VDIReadBuf *reds_get_vdi_port_read_buf(RedsState *reds)
+static VDIReadBuf *vdi_port_state_get_read_buf(VDIPortState *state)
{
- VDIPortState *state = &reds->agent_state;
RingItem *item;
VDIReadBuf *buf;
@@ -671,17 +670,17 @@ static VDIReadBuf* vdi_port_read_buf_ref(VDIReadBuf *buf)
/* FIXME: refactor so that unreffing the VDIReadBuf doesn't require accessing
* RedsState? */
-static void vdi_port_read_buf_unref(RedsState *reds, VDIReadBuf *buf)
+static void vdi_port_read_buf_unref(VDIReadBuf *buf)
{
if (!--buf->refs) {
- ring_add(&reds->agent_state.read_bufs, &buf->link);
+ ring_add(&buf->state->read_bufs, &buf->link);
/* read_one_msg_from_vdi_port may have never completed because the read_bufs
ring was empty. So we call it again so it can complete its work if
necessary. Note that since we can be called from spice_char_device_wakeup
this can cause recursion, but we have protection for that */
- if (reds->agent_state.base) {
- spice_char_device_wakeup(reds->agent_state.base);
+ if (buf->state->base) {
+ spice_char_device_wakeup(buf->state->base);
}
}
}
@@ -716,7 +715,7 @@ static SpiceCharDeviceMsgToClient *vdi_port_read_one_msg_from_device(SpiceCharDe
state->message_receive_len = state->vdi_chunk_header.size;
state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
case VDI_PORT_READ_STATE_GET_BUFF: {
- if (!(state->current_read_buf = reds_get_vdi_port_read_buf(reds))) {
+ if (!(state->current_read_buf = vdi_port_state_get_read_buf(&reds->agent_state))) {
return NULL;
}
state->receive_pos = state->current_read_buf->data;
@@ -748,7 +747,7 @@ static SpiceCharDeviceMsgToClient *vdi_port_read_one_msg_from_device(SpiceCharDe
if (vdi_port_read_buf_process(reds, state->vdi_chunk_header.port, dispatch_buf)) {
return dispatch_buf;
} else {
- vdi_port_read_buf_unref(reds, dispatch_buf);
+ vdi_port_read_buf_unref(dispatch_buf);
}
} /* END switch */
} /* END while */
@@ -756,16 +755,15 @@ static SpiceCharDeviceMsgToClient *vdi_port_read_one_msg_from_device(SpiceCharDe
}
static SpiceCharDeviceMsgToClient *vdi_port_ref_msg_to_client(SpiceCharDeviceMsgToClient *msg,
- void *opaque)
+ void *opaque)
{
return vdi_port_read_buf_ref(msg);
}
static void vdi_port_unref_msg_to_client(SpiceCharDeviceMsgToClient *msg,
- void *opaque)
+ void *opaque)
{
- RedsState *reds = opaque;
- vdi_port_read_buf_unref(reds, msg);
+ vdi_port_read_buf_unref(msg);
}
/* after calling this, we unref the message, and the ref is in the instance side */
@@ -1123,7 +1121,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
vdi_port_read_buf_release,
read_buf);
} else {
- vdi_port_read_buf_unref(reds, read_buf);
+ vdi_port_read_buf_unref(read_buf);
}
spice_assert(agent_state->receive_len);
@@ -1241,7 +1239,7 @@ static int reds_agent_state_restore(RedsState *reds, SpiceMigrateDataMain *mig_d
uint32_t cur_buf_size;
agent_state->read_state = VDI_PORT_READ_STATE_READ_DATA;
- agent_state->current_read_buf = reds_get_vdi_port_read_buf(reds);
+ agent_state->current_read_buf = vdi_port_state_get_read_buf(&reds->agent_state);
spice_assert(agent_state->current_read_buf);
partial_msg_header = (uint8_t *)mig_data + mig_data->agent2client.msg_header_ptr -
sizeof(SpiceMiniDataHeader);
@@ -3308,6 +3306,7 @@ static void reds_init_vd_agent_resources(RedsState *reds)
for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);
+ buf->state = state;
ring_item_init(&buf->link);
ring_add(&reds->agent_state.read_bufs, &buf->link);
}
commit b830f193a190be5394c7987ec0fd69324f89b16a
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Jan 29 13:56:57 2015 -0600
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
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/char-device.c b/server/char-device.c
index 6093599..74b1362 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) {
- 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);
@@ -262,7 +262,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;
}
@@ -362,6 +362,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) {
@@ -370,12 +371,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;
}
}
@@ -456,7 +457,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);
@@ -498,8 +499,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));
@@ -516,7 +517,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);
}
@@ -668,6 +669,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,
@@ -683,6 +685,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;
@@ -742,9 +745,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);
char_dev->write_to_dev_timer = NULL;
}
write_buffers_queue_free(&char_dev->write_queue);
@@ -795,9 +798,10 @@ 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(reds_get_core_interface(reds),
- device_client_wait_for_tokens_timeout,
- dev_client);
+ dev_client->wait_for_tokens_timer =
+ reds_get_core_interface(dev->reds)->timer_add(reds_get_core_interface(dev->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");
}
@@ -862,7 +866,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 a9c666a..b70ffae 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -79,6 +79,8 @@
*
* */
+struct RedsState;
+
/* buffer that is used for writing to the device */
typedef struct SpiceCharDeviceWriteBuffer {
RingItem link;
@@ -128,6 +130,7 @@ typedef struct SpiceCharDeviceCallbacks {
} SpiceCharDeviceCallbacks;
SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+ struct RedsState *reds,
uint32_t client_tokens_interval,
uint32_t self_tokens,
SpiceCharDeviceCallbacks *cbs,
diff --git a/server/reds.c b/server/reds.c
index c5a7b06..000aa57 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -2952,6 +2952,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/smartcard.c b/server/smartcard.c
index 0be3235..0d6ba7b 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -280,6 +280,7 @@ static SmartCardDeviceState *smartcard_device_state_new(SpiceCharDeviceInstance
st = spice_new0(SmartCardDeviceState, 1);
st->chardev_st = spice_char_device_state_create(sin,
+ reds,
0, /* tokens interval */
~0, /* self tokens */
&chardev_cbs,
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 95d840e..4460eab 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -542,6 +542,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,
commit 82fe27d753f3f84b69df95ce4732240acc25aeb4
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Tue Jan 27 16:51:03 2015 -0600
Add RedsState member to RedLinkInfo
This allows us to use local 'reds' variables in all of the various async
callbacks rather than using the global 'reds' variable.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/reds.c b/server/reds.c
index 58af7c4..c5a7b06 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -148,6 +148,7 @@ static long *lock_count;
RedsState *reds = NULL;
typedef struct RedLinkInfo {
+ RedsState *reds;
RedsStream *stream;
SpiceLinkHeader link_header;
SpiceLinkMess *link_mess;
@@ -1341,6 +1342,7 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc,
static void reds_channel_init_auth_caps(RedLinkInfo *link, RedChannel *channel)
{
+ RedsState *reds = link->reds;
if (reds->sasl_enabled && !link->skip_auth) {
red_channel_set_common_cap(channel, SPICE_COMMON_CAP_AUTH_SASL);
} else {
@@ -1893,6 +1895,7 @@ static void reds_handle_link(RedsState *reds, RedLinkInfo *link)
static void reds_handle_ticket(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
char *password;
time_t ltime;
int password_size;
@@ -1977,6 +1980,7 @@ static void reds_handle_auth_sasl_steplen(void *opaque);
static void reds_handle_auth_sasl_step(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
RedsSaslError status;
status = reds_sasl_handle_auth_step(link->stream, reds_handle_auth_sasl_steplen, link);
@@ -2017,6 +2021,7 @@ static void reds_handle_auth_sasl_steplen(void *opaque)
static void reds_handle_auth_sasl_start(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
RedsSaslError status;
status = reds_sasl_handle_auth_start(link->stream, reds_handle_auth_sasl_steplen, link);
@@ -2081,6 +2086,7 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
static void reds_handle_auth_mechanism(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
spice_info("Auth method: %d", link->auth_mechanism.auth_mechanism);
@@ -2106,6 +2112,7 @@ static void reds_handle_auth_mechanism(void *opaque)
static int reds_security_check(RedLinkInfo *link)
{
+ RedsState *reds = link->reds;
ChannelSecurityOptions *security_option = reds_find_channel_security(reds, link->link_mess->channel_type);
uint32_t security = security_option ? security_option->options : reds->default_channel_security;
return (reds_stream_is_ssl(link->stream) && (security & SPICE_CHANNEL_SECURITY_SSL)) ||
@@ -2115,6 +2122,7 @@ static int reds_security_check(RedLinkInfo *link)
static void reds_handle_read_link_done(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
SpiceLinkMess *link_mess = link->link_mess;
uint32_t num_caps;
uint32_t *caps;
@@ -2194,6 +2202,7 @@ static void reds_handle_link_error(void *opaque, int err)
static void reds_handle_read_header_done(void *opaque)
{
RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedsState *reds = link->reds;
SpiceLinkHeader *header = &link->link_header;
header->major_version = GUINT32_FROM_LE(header->major_version);
@@ -2247,6 +2256,7 @@ static void reds_handle_new_link(RedLinkInfo *link)
static void reds_handle_ssl_accept(int fd, int event, void *data)
{
RedLinkInfo *link = (RedLinkInfo *)data;
+ RedsState *reds = link->reds;
int return_code = reds_stream_ssl_accept(link->stream);
switch (return_code) {
@@ -2303,6 +2313,7 @@ static RedLinkInfo *reds_init_client_connection(RedsState *reds, int socket)
}
link = spice_new0(RedLinkInfo, 1);
+ link->reds = reds;
link->stream = reds_stream_new(socket);
/* gather info + send event */
More information about the Spice-commits
mailing list