[Spice-devel] [PATCH v2 03/15] Rename SpiceCharDeviceState to RedCharDevice
Jonathon Jongsma
jjongsma at redhat.com
Thu Mar 31 21:07:01 UTC 2016
This is more consistent with internal type naming convention, and it
paves the way for a new char device GObject heirarchy
---
server/char-device.c | 107 +++++++++++++++++++++++++-------------------------
server/char-device.h | 58 ++++++++++++++-------------
server/reds-private.h | 2 +-
server/reds.c | 34 ++++++++--------
server/reds.h | 3 +-
server/smartcard.c | 40 +++++++++----------
server/smartcard.h | 2 +-
server/spicevmc.c | 57 ++++++++++++++-------------
8 files changed, 155 insertions(+), 148 deletions(-)
diff --git a/server/char-device.c b/server/char-device.c
index ea1fb17..0ee833f 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -33,7 +33,7 @@
typedef struct SpiceCharDeviceClientState SpiceCharDeviceClientState;
struct SpiceCharDeviceClientState {
RingItem link;
- SpiceCharDeviceState *dev;
+ RedCharDevice *dev;
RedClient *client;
int do_flow_control;
uint64_t num_client_tokens;
@@ -74,6 +74,7 @@ struct RedCharDevicePrivate {
SpiceServer *reds;
};
+/* typedef'ed as RedCharDevice */
struct SpiceCharDeviceState {
struct RedCharDevicePrivate priv[1];
};
@@ -87,8 +88,8 @@ enum {
/* Holding references for avoiding access violation if the char device was
* destroyed during a callback */
-static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev);
-static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev);
+static void spice_char_device_state_ref(RedCharDevice *char_dev);
+static void spice_char_device_state_unref(RedCharDevice *char_dev);
static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_buf);
static void spice_char_dev_write_retry(void *opaque);
@@ -99,27 +100,27 @@ typedef struct RedCharDeviceMsgToClientItem {
} RedCharDeviceMsgToClientItem;
static RedCharDeviceMsgToClient *
-spice_char_device_read_one_msg_from_device(SpiceCharDeviceState *dev)
+spice_char_device_read_one_msg_from_device(RedCharDevice *dev)
{
return dev->priv->cbs.read_one_msg_from_device(dev->priv->sin, dev->priv->opaque);
}
static RedCharDeviceMsgToClient *
-spice_char_device_ref_msg_to_client(SpiceCharDeviceState *dev,
+spice_char_device_ref_msg_to_client(RedCharDevice *dev,
RedCharDeviceMsgToClient *msg)
{
return dev->priv->cbs.ref_msg_to_client(msg, dev->priv->opaque);
}
static void
-spice_char_device_unref_msg_to_client(SpiceCharDeviceState *dev,
+spice_char_device_unref_msg_to_client(RedCharDevice *dev,
RedCharDeviceMsgToClient *msg)
{
dev->priv->cbs.unref_msg_to_client(msg, dev->priv->opaque);
}
static void
-spice_char_device_send_msg_to_client(SpiceCharDeviceState *dev,
+spice_char_device_send_msg_to_client(RedCharDevice *dev,
RedCharDeviceMsgToClient *msg,
RedClient *client)
{
@@ -127,7 +128,7 @@ spice_char_device_send_msg_to_client(SpiceCharDeviceState *dev,
}
static void
-spice_char_device_send_tokens_to_client(SpiceCharDeviceState *dev,
+spice_char_device_send_tokens_to_client(RedCharDevice *dev,
RedClient *client,
uint32_t tokens)
{
@@ -135,7 +136,7 @@ spice_char_device_send_tokens_to_client(SpiceCharDeviceState *dev,
}
static void
-spice_char_device_on_free_self_token(SpiceCharDeviceState *dev)
+spice_char_device_on_free_self_token(RedCharDevice *dev)
{
if (dev->priv->cbs.on_free_self_token != NULL) {
dev->priv->cbs.on_free_self_token(dev->priv->opaque);
@@ -143,7 +144,7 @@ spice_char_device_on_free_self_token(SpiceCharDeviceState *dev)
}
static void
-spice_char_device_remove_client(SpiceCharDeviceState *dev, RedClient *client)
+spice_char_device_remove_client(RedCharDevice *dev, RedClient *client)
{
dev->priv->cbs.remove_client(client, dev->priv->opaque);
}
@@ -169,7 +170,7 @@ static void write_buffers_queue_free(Ring *write_queue)
}
}
-static void spice_char_device_write_buffer_pool_add(SpiceCharDeviceState *dev,
+static void spice_char_device_write_buffer_pool_add(RedCharDevice *dev,
RedCharDeviceWriteBuffer *buf)
{
if (buf->refs == 1 &&
@@ -186,7 +187,7 @@ static void spice_char_device_write_buffer_pool_add(SpiceCharDeviceState *dev,
red_char_device_write_buffer_unref(buf);
}
-static void spice_char_device_client_send_queue_free(SpiceCharDeviceState *dev,
+static void spice_char_device_client_send_queue_free(RedCharDevice *dev,
SpiceCharDeviceClientState *dev_client)
{
spice_debug("send_queue_empty %d", ring_is_empty(&dev_client->send_queue));
@@ -204,7 +205,7 @@ static void spice_char_device_client_send_queue_free(SpiceCharDeviceState *dev,
dev_client->send_queue_size = 0;
}
-static void spice_char_device_client_free(SpiceCharDeviceState *dev,
+static void spice_char_device_client_free(RedCharDevice *dev,
SpiceCharDeviceClientState *dev_client)
{
RingItem *item, *next;
@@ -241,12 +242,12 @@ static void spice_char_device_client_free(SpiceCharDeviceState *dev,
static void spice_char_device_handle_client_overflow(SpiceCharDeviceClientState *dev_client)
{
- SpiceCharDeviceState *dev = dev_client->dev;
+ RedCharDevice *dev = dev_client->dev;
spice_printerr("dev %p client %p ", dev, dev_client);
spice_char_device_remove_client(dev, dev_client->client);
}
-static SpiceCharDeviceClientState *spice_char_device_client_find(SpiceCharDeviceState *dev,
+static SpiceCharDeviceClientState *spice_char_device_client_find(RedCharDevice *dev,
RedClient *client)
{
RingItem *item;
@@ -278,7 +279,7 @@ static int spice_char_device_can_send_to_client(SpiceCharDeviceClientState *dev_
return !dev_client->do_flow_control || dev_client->num_send_tokens;
}
-static uint64_t spice_char_device_max_send_tokens(SpiceCharDeviceState *dev)
+static uint64_t spice_char_device_max_send_tokens(RedCharDevice *dev)
{
RingItem *item;
uint64_t max = 0;
@@ -303,7 +304,7 @@ static uint64_t spice_char_device_max_send_tokens(SpiceCharDeviceState *dev)
static void spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState *dev_client,
RedCharDeviceMsgToClient *msg)
{
- SpiceCharDeviceState *dev = dev_client->dev;
+ RedCharDevice *dev = dev_client->dev;
RedCharDeviceMsgToClientItem *msg_item;
if (dev_client->send_queue_size >= dev_client->max_send_queue_size) {
@@ -322,7 +323,7 @@ static void spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState
}
}
-static void spice_char_device_send_msg_to_clients(SpiceCharDeviceState *dev,
+static void spice_char_device_send_msg_to_clients(RedCharDevice *dev,
RedCharDeviceMsgToClient *msg)
{
RingItem *item, *next;
@@ -343,7 +344,7 @@ static void spice_char_device_send_msg_to_clients(SpiceCharDeviceState *dev,
}
}
-static int spice_char_device_read_from_device(SpiceCharDeviceState *dev)
+static int spice_char_device_read_from_device(RedCharDevice *dev)
{
uint64_t max_send_tokens;
int did_read = FALSE;
@@ -416,7 +417,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;
+ RedCharDevice *dev = dev_client->dev;
dev_client->num_send_tokens += tokens;
if (dev_client->send_queue_size) {
@@ -435,7 +436,7 @@ static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClient
}
}
-void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
+void spice_char_device_send_to_client_tokens_add(RedCharDevice *dev,
RedClient *client,
uint32_t tokens)
{
@@ -450,7 +451,7 @@ void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
}
-void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
+void spice_char_device_send_to_client_tokens_set(RedCharDevice *dev,
RedClient *client,
uint32_t tokens)
{
@@ -471,7 +472,7 @@ void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
* Writing to the device *
***************************/
-static void spice_char_device_client_tokens_add(SpiceCharDeviceState *dev,
+static void spice_char_device_client_tokens_add(RedCharDevice *dev,
SpiceCharDeviceClientState *dev_client,
uint32_t num_tokens)
{
@@ -491,7 +492,7 @@ static void spice_char_device_client_tokens_add(SpiceCharDeviceState *dev,
}
}
-static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
+static int spice_char_device_write_to_device(RedCharDevice *dev)
{
SpiceCharDeviceInterface *sif;
int total = 0;
@@ -566,7 +567,7 @@ static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
static void spice_char_dev_write_retry(void *opaque)
{
- SpiceCharDeviceState *dev = opaque;
+ RedCharDevice *dev = opaque;
if (dev->priv->write_to_dev_timer) {
reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
@@ -575,7 +576,7 @@ static void spice_char_dev_write_retry(void *opaque)
}
static RedCharDeviceWriteBuffer *__spice_char_device_write_buffer_get(
- SpiceCharDeviceState *dev, RedClient *client,
+ RedCharDevice *dev, RedClient *client,
int size, int origin, int migrated_data_tokens)
{
RingItem *item;
@@ -634,7 +635,7 @@ error:
return NULL;
}
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
+RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(RedCharDevice *dev,
RedClient *client,
int size)
{
@@ -644,7 +645,7 @@ RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceStat
}
RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
- SpiceCharDeviceState *dev, int size)
+ RedCharDevice *dev, int size)
{
return __spice_char_device_write_buffer_get(dev, NULL, size,
WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN, 0);
@@ -667,7 +668,7 @@ static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_b
red_char_device_write_buffer_free(write_buf);
}
-void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
+void spice_char_device_write_buffer_add(RedCharDevice *dev,
RedCharDeviceWriteBuffer *write_buf)
{
spice_assert(dev);
@@ -683,7 +684,7 @@ void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
spice_char_device_write_to_device(dev);
}
-void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
+void spice_char_device_write_buffer_release(RedCharDevice *dev,
RedCharDeviceWriteBuffer *write_buf)
{
int buf_origin = write_buf->origin;
@@ -718,14 +719,14 @@ void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
* char_device_state management *
********************************/
-SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
- RedsState *reds,
- uint32_t client_tokens_interval,
- uint32_t self_tokens,
- SpiceCharDeviceCallbacks *cbs,
- void *opaque)
+RedCharDevice *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+ RedsState *reds,
+ uint32_t client_tokens_interval,
+ uint32_t self_tokens,
+ SpiceCharDeviceCallbacks *cbs,
+ void *opaque)
{
- SpiceCharDeviceState *char_dev;
+ RedCharDevice *char_dev;
SpiceCharDeviceInterface *sif;
spice_assert(sin);
@@ -733,7 +734,7 @@ SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *si
cbs->unref_msg_to_client && cbs->send_msg_to_client &&
cbs->send_tokens_to_client && cbs->remove_client);
- char_dev = spice_new0(SpiceCharDeviceState, 1);
+ char_dev = spice_new0(RedCharDevice, 1);
char_dev->priv->sin = sin;
char_dev->priv->reds = reds;
char_dev->priv->cbs = *cbs;
@@ -760,7 +761,7 @@ SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *si
return char_dev;
}
-void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *state,
+void spice_char_device_state_reset_dev_instance(RedCharDevice *state,
SpiceCharDeviceInstance *sin)
{
spice_debug("sin %p dev_state %p", sin, state);
@@ -768,17 +769,17 @@ void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *state,
sin->st = state;
}
-void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev)
+void *spice_char_device_state_opaque_get(RedCharDevice *dev)
{
return dev->priv->opaque;
}
-static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev)
+static void spice_char_device_state_ref(RedCharDevice *char_dev)
{
char_dev->priv->refs++;
}
-static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev)
+static void spice_char_device_state_unref(RedCharDevice *char_dev)
{
/* The refs field protects the char_dev from being deallocated in
* case spice_char_device_state_destroy has been called
@@ -792,7 +793,7 @@ static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev)
}
}
-void spice_char_device_state_destroy(SpiceCharDeviceState *char_dev)
+void spice_char_device_state_destroy(RedCharDevice *char_dev)
{
reds_on_char_device_state_destroy(char_dev->priv->reds, char_dev);
if (char_dev->priv->write_to_dev_timer) {
@@ -848,7 +849,7 @@ static SpiceCharDeviceClientState *red_char_device_client_new(RedClient *client,
return dev_client;
}
-int spice_char_device_client_add(SpiceCharDeviceState *dev,
+int spice_char_device_client_add(RedCharDevice *dev,
RedClient *client,
int do_flow_control,
uint32_t max_send_queue_size,
@@ -882,7 +883,7 @@ int spice_char_device_client_add(SpiceCharDeviceState *dev,
return TRUE;
}
-void spice_char_device_client_remove(SpiceCharDeviceState *dev,
+void spice_char_device_client_remove(RedCharDevice *dev,
RedClient *client)
{
SpiceCharDeviceClientState *dev_client;
@@ -908,13 +909,13 @@ void spice_char_device_client_remove(SpiceCharDeviceState *dev,
}
}
-int spice_char_device_client_exists(SpiceCharDeviceState *dev,
+int spice_char_device_client_exists(RedCharDevice *dev,
RedClient *client)
{
return (spice_char_device_client_find(dev, client) != NULL);
}
-void spice_char_device_start(SpiceCharDeviceState *dev)
+void spice_char_device_start(RedCharDevice *dev)
{
spice_debug("dev_state %p", dev);
dev->priv->running = TRUE;
@@ -924,7 +925,7 @@ void spice_char_device_start(SpiceCharDeviceState *dev)
spice_char_device_state_unref(dev);
}
-void spice_char_device_stop(SpiceCharDeviceState *dev)
+void spice_char_device_stop(RedCharDevice *dev)
{
spice_debug("dev_state %p", dev);
dev->priv->running = FALSE;
@@ -934,7 +935,7 @@ void spice_char_device_stop(SpiceCharDeviceState *dev)
}
}
-void spice_char_device_reset(SpiceCharDeviceState *dev)
+void spice_char_device_reset(RedCharDevice *dev)
{
RingItem *client_item;
@@ -966,7 +967,7 @@ void spice_char_device_reset(SpiceCharDeviceState *dev)
dev->priv->sin = NULL;
}
-void spice_char_device_wakeup(SpiceCharDeviceState *dev)
+void spice_char_device_wakeup(RedCharDevice *dev)
{
spice_char_device_write_to_device(dev);
spice_char_device_read_from_device(dev);
@@ -995,7 +996,7 @@ static void migrate_data_marshaller_write_buffer_free(uint8_t *data, void *opaqu
red_char_device_write_buffer_unref(write_buf);
}
-void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
+void spice_char_device_state_migrate_data_marshall(RedCharDevice *dev,
SpiceMarshaller *m)
{
SpiceCharDeviceClientState *client_state;
@@ -1055,7 +1056,7 @@ void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
dev, *write_to_dev_size_ptr, *write_to_dev_tokens_ptr);
}
-int spice_char_device_state_restore(SpiceCharDeviceState *dev,
+int spice_char_device_state_restore(RedCharDevice *dev,
SpiceMigrateDataCharDevice *mig_data)
{
SpiceCharDeviceClientState *client_state;
@@ -1106,7 +1107,7 @@ int spice_char_device_state_restore(SpiceCharDeviceState *dev,
return TRUE;
}
-SpiceServer* spice_char_device_get_server(SpiceCharDeviceState *dev)
+SpiceServer* spice_char_device_get_server(RedCharDevice *dev)
{
return dev->priv->reds;
}
diff --git a/server/char-device.h b/server/char-device.h
index 1076e07..86bf1b9 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -80,6 +80,8 @@
* */
struct RedsState;
+/* SpiceCharDeviceState is public API, but internally we use RedCharDevice */
+typedef struct SpiceCharDeviceState RedCharDevice;
/* buffer that is used for writing to the device */
typedef struct RedCharDeviceWriteBuffer {
@@ -129,25 +131,25 @@ typedef struct SpiceCharDeviceCallbacks {
void (*remove_client)(RedClient *client, void *opaque);
} SpiceCharDeviceCallbacks;
-SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
- struct RedsState *reds,
- uint32_t client_tokens_interval,
- uint32_t self_tokens,
- SpiceCharDeviceCallbacks *cbs,
- void *opaque);
+RedCharDevice *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+ struct RedsState *reds,
+ uint32_t client_tokens_interval,
+ uint32_t self_tokens,
+ SpiceCharDeviceCallbacks *cbs,
+ void *opaque);
-void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *dev,
+void spice_char_device_state_reset_dev_instance(RedCharDevice *dev,
SpiceCharDeviceInstance *sin);
-void spice_char_device_state_destroy(SpiceCharDeviceState *dev);
+void spice_char_device_state_destroy(RedCharDevice *dev);
-void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev);
+void *spice_char_device_state_opaque_get(RedCharDevice *dev);
/* only one client is supported */
-void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
+void spice_char_device_state_migrate_data_marshall(RedCharDevice *dev,
SpiceMarshaller *m);
void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m);
-int spice_char_device_state_restore(SpiceCharDeviceState *dev,
+int spice_char_device_state_restore(RedCharDevice *dev,
SpiceMigrateDataCharDevice *mig_data);
/*
@@ -165,11 +167,11 @@ int spice_char_device_state_restore(SpiceCharDeviceState *dev,
*
* todo: change AGENT_CONNECT msg to contain tokens count.
*/
-void spice_char_device_reset(SpiceCharDeviceState *dev);
+void spice_char_device_reset(RedCharDevice *dev);
/* max_send_queue_size = how many messages we can read from the device and enqueue for this client,
* when we have tokens for other clients and no tokens for this one */
-int spice_char_device_client_add(SpiceCharDeviceState *dev,
+int spice_char_device_client_add(RedCharDevice *dev,
RedClient *client,
int do_flow_control,
uint32_t max_send_queue_size,
@@ -177,45 +179,45 @@ int spice_char_device_client_add(SpiceCharDeviceState *dev,
uint32_t num_send_tokens,
int wait_for_migrate_data);
-void spice_char_device_client_remove(SpiceCharDeviceState *dev,
+void spice_char_device_client_remove(RedCharDevice *dev,
RedClient *client);
-int spice_char_device_client_exists(SpiceCharDeviceState *dev,
+int spice_char_device_client_exists(RedCharDevice *dev,
RedClient *client);
-void spice_char_device_start(SpiceCharDeviceState *dev);
-void spice_char_device_stop(SpiceCharDeviceState *dev);
-SpiceServer* spice_char_device_get_server(SpiceCharDeviceState *dev);
+void spice_char_device_start(RedCharDevice *dev);
+void spice_char_device_stop(RedCharDevice *dev);
+SpiceServer* spice_char_device_get_server(RedCharDevice *dev);
/** Read from device **/
-void spice_char_device_wakeup(SpiceCharDeviceState *dev);
+void spice_char_device_wakeup(RedCharDevice *dev);
-void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
+void spice_char_device_send_to_client_tokens_add(RedCharDevice *dev,
RedClient *client,
uint32_t tokens);
-void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
+void spice_char_device_send_to_client_tokens_set(RedCharDevice *dev,
RedClient *client,
uint32_t tokens);
/** Write to device **/
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
+RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(RedCharDevice *dev,
RedClient *client, int size);
RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
- SpiceCharDeviceState *dev, int size);
+ RedCharDevice *dev, int size);
/* Either add the buffer to the write queue or release it */
-void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
+void spice_char_device_write_buffer_add(RedCharDevice *dev,
RedCharDeviceWriteBuffer *write_buf);
-void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
+void spice_char_device_write_buffer_release(RedCharDevice *dev,
RedCharDeviceWriteBuffer *write_buf);
/* api for specific char devices */
-SpiceCharDeviceState *spicevmc_device_connect(struct RedsState *reds,
- SpiceCharDeviceInstance *sin,
- uint8_t channel_type);
+RedCharDevice *spicevmc_device_connect(struct RedsState *reds,
+ SpiceCharDeviceInstance *sin,
+ uint8_t channel_type);
void spicevmc_device_disconnect(struct RedsState *reds,
SpiceCharDeviceInstance *char_device);
diff --git a/server/reds-private.h b/server/reds-private.h
index 560a21b..b78e25d 100644
--- a/server/reds-private.h
+++ b/server/reds-private.h
@@ -58,7 +58,7 @@ enum {
};
struct VDIPortState {
- SpiceCharDeviceState *base;
+ RedCharDevice *base;
uint32_t plug_generation;
int client_agent_started;
diff --git a/server/reds.c b/server/reds.c
index 1776186..bb96d09 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -171,8 +171,8 @@ static RedsMigTargetClient* reds_mig_target_client_find(RedsState *reds, RedClie
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);
-static void reds_char_device_remove_state(RedsState *reds, SpiceCharDeviceState *st);
+static void reds_add_char_device(RedsState *reds, RedCharDevice *dev);
+static void reds_remove_char_device(RedsState *reds, RedCharDevice *dev);
static void reds_send_mm_time(RedsState *reds);
static void reds_on_ic_change(RedsState *reds);
static void reds_on_sv_change(RedsState *reds);
@@ -922,7 +922,7 @@ void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info)
void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens)
{
- SpiceCharDeviceState *dev_state = reds->agent_state.base;
+ RedCharDevice *dev_state = reds->agent_state.base;
RedChannelClient *rcc;
if (!reds->vdagent) {
@@ -1176,7 +1176,7 @@ void reds_marshall_migrate_data(RedsState *reds, SpiceMarshaller *m)
uint8_t *null_agent_mig_data;
spice_assert(!agent_state->base); /* MSG_AGENT_CONNECTED_TOKENS is supported by the client
- (see spice_server_migrate_connect), so SpiceCharDeviceState
+ (see spice_server_migrate_connect), so RedCharDevice
is destroyed when the agent is disconnected and
there is no need to track the client tokens
(see reds_reset_vdp) */
@@ -2968,7 +2968,7 @@ void reds_disable_mm_time(RedsState *reds)
reds->mm_time_enabled = FALSE;
}
-static SpiceCharDeviceState *attach_to_red_agent(RedsState *reds, SpiceCharDeviceInstance *sin)
+static RedCharDevice *attach_to_red_agent(RedsState *reds, SpiceCharDeviceInstance *sin)
{
VDIPortState *state = &reds->agent_state;
SpiceCharDeviceInterface *sif;
@@ -3056,7 +3056,7 @@ static SpiceCharDeviceState *attach_to_red_agent(RedsState *reds, SpiceCharDevic
SPICE_GNUC_VISIBLE void spice_server_char_device_wakeup(SpiceCharDeviceInstance* sin)
{
if (!sin->st) {
- spice_warning("no SpiceCharDeviceState attached to instance %p", sin);
+ spice_warning("no RedCharDevice attached to instance %p", sin);
return;
}
spice_char_device_wakeup(sin->st);
@@ -3081,20 +3081,20 @@ SPICE_GNUC_VISIBLE const char** spice_server_char_device_recognized_subtypes(voi
return spice_server_char_device_recognized_subtypes_list;
}
-static void reds_char_device_add_state(RedsState *reds, SpiceCharDeviceState *st)
+static void reds_add_char_device(RedsState *reds, RedCharDevice *dev)
{
- reds->char_devices = g_list_append(reds->char_devices, st);
+ reds->char_devices = g_list_append(reds->char_devices, dev);
}
-static void reds_char_device_remove_state(RedsState *reds, SpiceCharDeviceState *st)
+static void reds_remove_char_device(RedsState *reds, RedCharDevice *dev)
{
- g_warn_if_fail(g_list_find(reds->char_devices, st) != NULL);
- reds->char_devices = g_list_remove(reds->char_devices, st);
+ g_warn_if_fail(g_list_find(reds->char_devices, dev) != NULL);
+ reds->char_devices = g_list_remove(reds->char_devices, dev);
}
-void reds_on_char_device_state_destroy(RedsState *reds, SpiceCharDeviceState *dev)
+void reds_on_char_device_state_destroy(RedsState *reds, RedCharDevice *dev)
{
- reds_char_device_remove_state(reds, dev);
+ reds_remove_char_device(reds, dev);
}
static int spice_server_char_device_add_interface(SpiceServer *reds,
@@ -3102,7 +3102,7 @@ static int spice_server_char_device_add_interface(SpiceServer *reds,
{
SpiceCharDeviceInstance* char_device =
SPICE_CONTAINEROF(sin, SpiceCharDeviceInstance, base);
- SpiceCharDeviceState *dev_state = NULL;
+ RedCharDevice *dev_state = NULL;
spice_info("CHAR_DEVICE %s", char_device->subtype);
if (strcmp(char_device->subtype, SUBTYPE_VDAGENT) == 0) {
@@ -3137,7 +3137,7 @@ static int spice_server_char_device_add_interface(SpiceServer *reds,
if (reds->vm_running) {
spice_char_device_start(char_device->st);
}
- reds_char_device_add_state(reds, char_device->st);
+ reds_add_char_device(reds, char_device->st);
} else {
spice_warning("failed to create device state for %s", char_device->subtype);
return -1;
@@ -3976,7 +3976,7 @@ SPICE_GNUC_VISIBLE void spice_server_vm_start(SpiceServer *reds)
reds->vm_running = TRUE;
for (it = reds->char_devices; it != NULL; it = it->next) {
- spice_char_device_start((SpiceCharDeviceState *)it->data);
+ spice_char_device_start(it->data);
}
reds_on_vm_start(reds);
}
@@ -3987,7 +3987,7 @@ SPICE_GNUC_VISIBLE void spice_server_vm_stop(SpiceServer *reds)
reds->vm_running = FALSE;
for (it = reds->char_devices; it != NULL; it = it->next) {
- spice_char_device_stop((SpiceCharDeviceState *)it->data);
+ spice_char_device_stop(it->data);
}
reds_on_vm_stop(reds);
}
diff --git a/server/reds.h b/server/reds.h
index 5966dc3..83618e9 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -26,6 +26,7 @@
#include "common/marshaller.h"
#include "common/messages.h"
+#include "char-device.h"
#include "spice.h"
#include "red-channel.h"
#include "main-dispatcher.h"
@@ -101,7 +102,7 @@ int reds_on_migrate_dst_set_seamless(RedsState *reds, MainChannelClient *mcc, ui
void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *client);
void reds_on_client_seamless_migrate_complete(RedsState *reds, RedClient *client);
void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc);
-void reds_on_char_device_state_destroy(RedsState *reds, SpiceCharDeviceState *dev);
+void reds_on_char_device_state_destroy(RedsState *reds, RedCharDevice *dev);
void reds_set_client_mm_time_latency(RedsState *reds, RedClient *client, uint32_t latency);
uint32_t reds_get_streaming_video(const RedsState *reds);
diff --git a/server/smartcard.c b/server/smartcard.c
index af282a1..6e32f31 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -63,7 +63,7 @@ typedef struct SmartCardChannelClient {
} SmartCardChannelClient;
struct RedCharDeviceSmartcardPrivate {
- SpiceCharDeviceState *chardev_st;
+ RedCharDevice *chardev;
uint32_t reader_id;
/* read_from_device buffer */
uint8_t *buf;
@@ -286,12 +286,12 @@ static SmartCardDeviceState *smartcard_device_state_new(RedsState *reds, SpiceCh
chardev_cbs.remove_client = smartcard_remove_client;
st = spice_new0(SmartCardDeviceState, 1);
- st->priv->chardev_st = spice_char_device_state_create(sin,
- reds,
- 0, /* tokens interval */
- ~0, /* self tokens */
- &chardev_cbs,
- st);
+ st->priv->chardev = spice_char_device_state_create(sin,
+ reds,
+ 0, /* tokens interval */
+ ~0, /* self tokens */
+ &chardev_cbs,
+ st);
st->priv->reader_id = VSCARD_UNDEFINED_READER_ID;
st->priv->reader_added = FALSE;
st->priv->buf_size = APDUBufSize + sizeof(VSCMsgHeader);
@@ -308,7 +308,7 @@ static void smartcard_device_state_free(SmartCardDeviceState* st)
st->priv->scc->smartcard_state = NULL;
}
free(st->priv->buf);
- spice_char_device_state_destroy(st->priv->chardev_st);
+ spice_char_device_state_destroy(st->priv->chardev);
free(st);
}
@@ -319,7 +319,7 @@ void smartcard_device_disconnect(SpiceCharDeviceInstance *char_device)
smartcard_device_state_free(st);
}
-SpiceCharDeviceState *smartcard_device_connect(RedsState *reds, SpiceCharDeviceInstance *char_device)
+RedCharDevice *smartcard_device_connect(RedsState *reds, SpiceCharDeviceInstance *char_device)
{
SmartCardDeviceState *st;
@@ -328,7 +328,7 @@ SpiceCharDeviceState *smartcard_device_connect(RedsState *reds, SpiceCharDeviceI
smartcard_device_state_free(st);
return NULL;
}
- return st->priv->chardev_st;
+ return st->priv->chardev;
}
static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st)
@@ -336,7 +336,7 @@ static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st)
RedCharDeviceWriteBuffer *write_buf;
VSCMsgHeader *vheader;
- write_buf = spice_char_device_write_buffer_get(st->priv->chardev_st, NULL, sizeof(vheader));
+ write_buf = spice_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
if (!write_buf) {
spice_error("failed to allocate write buffer");
return;
@@ -358,7 +358,7 @@ static void smartcard_char_device_attach_client(SpiceCharDeviceInstance *char_de
spice_assert(!scc->smartcard_state && !st->priv->scc);
st->priv->scc = scc;
scc->smartcard_state = st;
- client_added = spice_char_device_client_add(st->priv->chardev_st,
+ client_added = spice_char_device_client_add(st->priv->chardev,
scc->base.client,
FALSE, /* no flow control yet */
0, /* send queue size */
@@ -383,7 +383,7 @@ static void smartcard_char_device_notify_reader_remove(SmartCardDeviceState *st)
spice_debug("reader add was never sent to the device");
return;
}
- write_buf = spice_char_device_write_buffer_get(st->priv->chardev_st, NULL, sizeof(vheader));
+ write_buf = spice_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
if (!write_buf) {
spice_error("failed to allocate write buffer");
return;
@@ -405,7 +405,7 @@ static void smartcard_char_device_detach_client(SmartCardChannelClient *scc)
}
st = scc->smartcard_state;
spice_assert(st->priv->scc == scc);
- spice_char_device_client_remove(st->priv->chardev_st, scc->base.client);
+ spice_char_device_client_remove(st->priv->chardev, scc->base.client);
scc->smartcard_state = NULL;
st->priv->scc = NULL;
}
@@ -434,7 +434,7 @@ static uint8_t *smartcard_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
st = scc->smartcard_state;
spice_assert(st->priv->scc || scc->smartcard_state);
spice_assert(!scc->write_buf);
- scc->write_buf = spice_char_device_write_buffer_get(st->priv->chardev_st, rcc->client, size);
+ scc->write_buf = spice_char_device_write_buffer_get(st->priv->chardev, rcc->client, size);
if (!scc->write_buf) {
spice_error("failed to allocate write buffer");
@@ -460,11 +460,11 @@ static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
spice_assert(!scc->write_buf);
free(msg);
} else {
- SpiceCharDeviceState *dev_st;
+ RedCharDevice *dev;
if (scc->write_buf) { /* msg hasn't been pushed to the guest */
spice_assert(scc->write_buf->buf == msg);
- dev_st = scc->smartcard_state ? scc->smartcard_state->priv->chardev_st : NULL;
- spice_char_device_write_buffer_release(dev_st, scc->write_buf);
+ dev = scc->smartcard_state ? scc->smartcard_state->priv->chardev : NULL;
+ spice_char_device_write_buffer_release(dev, scc->write_buf);
scc->write_buf = NULL;
}
}
@@ -518,7 +518,7 @@ static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
spice_marshaller_add_uint32(m, 0);
spice_debug("null char dev state");
} else {
- spice_char_device_state_migrate_data_marshall(state->priv->chardev_st, m);
+ spice_char_device_state_migrate_data_marshall(state->priv->chardev, m);
spice_marshaller_add_uint8(m, state->priv->reader_added);
spice_marshaller_add_uint32(m, state->priv->buf_used);
m2 = spice_marshaller_get_ptr_submarshaller(m, 0);
@@ -746,7 +746,7 @@ static int smartcard_channel_client_handle_migrate_data(RedChannelClient *rcc,
scc->smartcard_state->priv->reader_added = mig_data->reader_added;
smartcard_device_state_restore_partial_read(scc->smartcard_state, mig_data);
- return spice_char_device_state_restore(scc->smartcard_state->priv->chardev_st, &mig_data->base);
+ return spice_char_device_state_restore(scc->smartcard_state->priv->chardev, &mig_data->base);
}
static int smartcard_channel_handle_message(RedChannelClient *rcc,
diff --git a/server/smartcard.h b/server/smartcard.h
index 32d2367..9900287 100644
--- a/server/smartcard.h
+++ b/server/smartcard.h
@@ -21,7 +21,7 @@
/*
* connect to smartcard interface, used by smartcard channel
*/
-SpiceCharDeviceState *smartcard_device_connect(RedsState *reds, SpiceCharDeviceInstance *char_device);
+RedCharDevice *smartcard_device_connect(RedsState *reds, SpiceCharDeviceInstance *char_device);
void smartcard_device_disconnect(SpiceCharDeviceInstance *char_device);
#endif // __SMART_CARD_H__
diff --git a/server/spicevmc.c b/server/spicevmc.c
index f263a3d..36c5daf 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -54,7 +54,7 @@ typedef struct SpiceVmcPipeItem {
typedef struct SpiceVmcState {
RedChannel channel; /* Must be the first item */
RedChannelClient *rcc;
- SpiceCharDeviceState *chardev_st;
+ RedCharDevice *chardev;
SpiceCharDeviceInstance *chardev_sin;
SpiceVmcPipeItem *pipe_item;
RedCharDeviceWriteBuffer *recv_from_client_buf;
@@ -220,16 +220,16 @@ static void spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
state = SPICE_CONTAINEROF(rcc->channel, SpiceVmcState, channel);
if (state->recv_from_client_buf) { /* partial message which wasn't pushed to device */
- spice_char_device_write_buffer_release(state->chardev_st, state->recv_from_client_buf);
+ spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
state->recv_from_client_buf = NULL;
}
- if (state->chardev_st) {
- if (spice_char_device_client_exists(state->chardev_st, rcc->client)) {
- spice_char_device_client_remove(state->chardev_st, rcc->client);
+ if (state->chardev) {
+ if (spice_char_device_client_exists(state->chardev, rcc->client)) {
+ spice_char_device_client_remove(state->chardev, rcc->client);
} else {
spice_printerr("client %p have already been removed from char dev %p",
- rcc->client, state->chardev_st);
+ rcc->client, state->chardev);
}
}
@@ -275,7 +275,7 @@ static int spicevmc_channel_client_handle_migrate_data(RedChannelClient *rcc,
spice_error("bad header");
return FALSE;
}
- return spice_char_device_state_restore(state->chardev_st, &mig_data->base);
+ return spice_char_device_state_restore(state->chardev, &mig_data->base);
}
static int spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
@@ -293,7 +293,7 @@ static int spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
case SPICE_MSGC_SPICEVMC_DATA:
spice_assert(state->recv_from_client_buf->buf == msg);
state->recv_from_client_buf->buf_used = size;
- spice_char_device_write_buffer_add(state->chardev_st, state->recv_from_client_buf);
+ spice_char_device_write_buffer_add(state->chardev, state->recv_from_client_buf);
state->recv_from_client_buf = NULL;
break;
case SPICE_MSGC_PORT_EVENT:
@@ -323,7 +323,7 @@ static uint8_t *spicevmc_red_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
case SPICE_MSGC_SPICEVMC_DATA:
assert(!state->recv_from_client_buf);
- state->recv_from_client_buf = spice_char_device_write_buffer_get(state->chardev_st,
+ state->recv_from_client_buf = spice_char_device_write_buffer_get(state->chardev,
rcc->client,
size);
if (!state->recv_from_client_buf) {
@@ -350,7 +350,7 @@ static void spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
switch (type) {
case SPICE_MSGC_SPICEVMC_DATA:
if (state->recv_from_client_buf) { /* buffer wasn't pushed to device */
- spice_char_device_write_buffer_release(state->chardev_st, state->recv_from_client_buf);
+ spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
state->recv_from_client_buf = NULL;
}
break;
@@ -386,7 +386,7 @@ static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_MAGIC);
spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_VERSION);
- spice_char_device_state_migrate_data_marshall(state->chardev_st, m);
+ spice_char_device_state_migrate_data_marshall(state->chardev, m);
}
static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
@@ -486,7 +486,7 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client,
spicevmc_port_send_init(rcc);
}
- if (!spice_char_device_client_add(state->chardev_st, client, FALSE, 0, ~0, ~0,
+ if (!spice_char_device_client_add(state->chardev, client, FALSE, 0, ~0, ~0,
red_channel_client_is_waiting_for_migrate_data(rcc))) {
spice_warning("failed to add client to spicevmc");
red_channel_client_disconnect(rcc);
@@ -499,9 +499,9 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client,
}
}
-SpiceCharDeviceState *spicevmc_device_connect(RedsState *reds,
- SpiceCharDeviceInstance *sin,
- uint8_t channel_type)
+RedCharDevice *spicevmc_device_connect(RedsState *reds,
+ SpiceCharDeviceInstance *sin,
+ uint8_t channel_type)
{
static uint8_t id[256] = { 0, };
SpiceVmcState *state;
@@ -537,16 +537,16 @@ SpiceCharDeviceState *spicevmc_device_connect(RedsState *reds,
char_dev_cbs.send_tokens_to_client = spicevmc_char_dev_send_tokens_to_client;
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,
- state);
+ state->chardev = spice_char_device_state_create(sin,
+ reds,
+ 0, /* tokens interval */
+ ~0, /* self tokens */
+ &char_dev_cbs,
+ state);
state->chardev_sin = sin;
reds_register_channel(reds, &state->channel);
- return state->chardev_st;
+ return state->chardev;
}
/* Must be called from RedClient handling thread. */
@@ -554,13 +554,15 @@ void spicevmc_device_disconnect(RedsState *reds, SpiceCharDeviceInstance *sin)
{
SpiceVmcState *state;
- state = (SpiceVmcState *)spice_char_device_state_opaque_get(sin->st);
+ /* FIXME */
+ state = (SpiceVmcState *)spice_char_device_state_opaque_get((RedCharDevice*)sin->st);
if (state->recv_from_client_buf) {
- spice_char_device_write_buffer_release(state->chardev_st, state->recv_from_client_buf);
+ spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
}
- spice_char_device_state_destroy(sin->st);
- state->chardev_st = NULL;
+ /* FIXME */
+ spice_char_device_state_destroy((RedCharDevice*)sin->st);
+ state->chardev = NULL;
sin->st = NULL;
reds_unregister_channel(reds, &state->channel);
@@ -577,7 +579,8 @@ SPICE_GNUC_VISIBLE void spice_server_port_event(SpiceCharDeviceInstance *sin, ui
return;
}
- state = (SpiceVmcState *)spice_char_device_state_opaque_get(sin->st);
+ /* FIXME */
+ state = (SpiceVmcState *)spice_char_device_state_opaque_get((RedCharDevice*)sin->st);
if (event == SPICE_PORT_EVENT_OPENED) {
state->port_opened = TRUE;
} else if (event == SPICE_PORT_EVENT_CLOSED) {
--
2.4.3
More information about the Spice-devel
mailing list