[Spice-commits] server/red_dispatcher.c server/reds.c server/reds.h server/red_worker.c server/red_worker.h
Frediano Ziglio
fziglio at kemper.freedesktop.org
Mon Oct 26 02:14:26 PDT 2015
server/red_dispatcher.c | 75 +++---------------------------------------------
server/red_worker.c | 46 ++++++++++++++++-------------
server/red_worker.h | 30 -------------------
server/reds.c | 44 ++++++++++++++++++++++++++--
server/reds.h | 16 ++++++++++
5 files changed, 90 insertions(+), 121 deletions(-)
New commits:
commit f7b48981e37eec27327a010296008ffa6c727d68
Author: Marc-André Lureau <marcandre.lureau at gmail.com>
Date: Fri Oct 23 10:34:24 2015 +0100
worker: remove need for WorkerInitData
Move code around to declare and place it where it fits better.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index 1ad13b8..43f061d 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -68,11 +68,6 @@ struct RedDispatcher {
unsigned int max_monitors;
};
-extern uint32_t streaming_video;
-extern SpiceImageCompression image_compression;
-extern spice_wan_compression_t jpeg_state;
-extern spice_wan_compression_t zlib_glz_state;
-
static RedDispatcher *dispatchers = NULL;
static int red_dispatcher_check_qxl_version(RedDispatcher *rd, int major, int minor)
@@ -204,46 +199,6 @@ static void red_dispatcher_cursor_migrate(RedChannelClient *rcc)
&payload);
}
-typedef struct RendererInfo {
- int id;
- const char *name;
-} RendererInfo;
-
-static RendererInfo renderers_info[] = {
- {RED_RENDERER_SW, "sw"},
-#ifdef USE_OPENGL
- {RED_RENDERER_OGL_PBUF, "oglpbuf"},
- {RED_RENDERER_OGL_PIXMAP, "oglpixmap"},
-#endif
- {RED_RENDERER_INVALID, NULL},
-};
-
-static uint32_t renderers[RED_RENDERER_LAST];
-static uint32_t num_renderers = 0;
-
-static RendererInfo *find_renderer(const char *name)
-{
- RendererInfo *inf = renderers_info;
- while (inf->name) {
- if (strcmp(name, inf->name) == 0) {
- return inf;
- }
- inf++;
- }
- return NULL;
-}
-
-int red_dispatcher_add_renderer(const char *name)
-{
- RendererInfo *inf;
-
- if (num_renderers == RED_RENDERER_LAST || !(inf = find_renderer(name))) {
- return FALSE;
- }
- renderers[num_renderers++] = inf->id;
- return TRUE;
-}
-
int red_dispatcher_qxl_count(void)
{
return num_active_workers;
@@ -1073,12 +1028,11 @@ static RedChannel *red_dispatcher_cursor_channel_create(RedDispatcher *dispatche
void red_dispatcher_init(QXLInstance *qxl)
{
RedDispatcher *red_dispatcher;
- WorkerInitData init_data;
- QXLDevInitInfo init_info;
RedChannel *display_channel;
RedChannel *cursor_channel;
ClientCbs client_cbs = { NULL, };
+ spice_return_if_fail(qxl != NULL);
spice_return_if_fail(qxl->st->dispatcher == NULL);
static gsize initialized = FALSE;
@@ -1092,22 +1046,11 @@ void red_dispatcher_init(QXLInstance *qxl)
}
red_dispatcher = spice_new0(RedDispatcher, 1);
+ red_dispatcher->qxl = qxl;
ring_init(&red_dispatcher->async_commands);
spice_debug("red_dispatcher->async_commands.next %p", red_dispatcher->async_commands.next);
dispatcher_init(&red_dispatcher->dispatcher, RED_WORKER_MESSAGE_COUNT, NULL);
- init_data.qxl = red_dispatcher->qxl = qxl;
- init_data.id = qxl->id;
- init_data.red_dispatcher = red_dispatcher;
- init_data.pending = &red_dispatcher->pending;
- init_data.num_renderers = num_renderers;
- memcpy(init_data.renderers, renderers, sizeof(init_data.renderers));
-
pthread_mutex_init(&red_dispatcher->async_lock, NULL);
- init_data.image_compression = image_compression;
- init_data.jpeg_state = jpeg_state;
- init_data.zlib_glz_state = zlib_glz_state;
- init_data.streaming_video = streaming_video;
-
red_dispatcher->base.major_version = SPICE_INTERFACE_QXL_MAJOR;
red_dispatcher->base.minor_version = SPICE_INTERFACE_QXL_MINOR;
red_dispatcher->base.wakeup = qxl_worker_wakeup;
@@ -1129,20 +1072,12 @@ void red_dispatcher_init(QXLInstance *qxl)
red_dispatcher->max_monitors = UINT_MAX;
- qxl->st->qif->get_init_info(qxl, &init_info);
-
- init_data.memslot_id_bits = init_info.memslot_id_bits;
- init_data.memslot_gen_bits = init_info.memslot_gen_bits;
- init_data.num_memslots = init_info.num_memslots;
- init_data.num_memslots_groups = init_info.num_memslots_groups;
- init_data.internal_groupslot_id = init_info.internal_groupslot_id;
- init_data.n_surfaces = init_info.n_surfaces;
+ // TODO: reference and free
+ RedWorker *worker = red_worker_new(qxl, red_dispatcher);
+ red_worker_run(worker);
num_active_workers = 1;
- // TODO: reference and free
- RedWorker *worker = red_worker_new(&init_data);
- red_worker_run(worker);
display_channel = red_dispatcher_display_channel_create(red_dispatcher);
if (display_channel) {
diff --git a/server/red_worker.c b/server/red_worker.c
index 719ffd1..6584ec3 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -11587,13 +11587,18 @@ static void handle_dev_input(int fd, int event, void *opaque)
dispatcher_handle_recv_read(red_dispatcher_get_dispatcher(worker->red_dispatcher));
}
-RedWorker* red_worker_new(WorkerInitData *init_data)
+RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
{
- RedWorker *worker = spice_new0(RedWorker, 1);
+ QXLDevInitInfo init_info;
+ RedWorker *worker;
Dispatcher *dispatcher;
int i;
const char *record_filename;
+ qxl->st->qif->get_init_info(qxl, &init_info);
+
+ worker = spice_new0(RedWorker, 1);
+
record_filename = getenv("SPICE_WORKER_RECORD_FILENAME");
if (record_filename) {
static const char header[] = "SPICE_REPLAY 1\n";
@@ -11606,25 +11611,26 @@ RedWorker* red_worker_new(WorkerInitData *init_data)
spice_error("failed to write replay header");
}
}
- dispatcher = red_dispatcher_get_dispatcher(init_data->red_dispatcher);
+ dispatcher = red_dispatcher_get_dispatcher(red_dispatcher);
dispatcher_set_opaque(dispatcher, worker);
- worker->red_dispatcher = init_data->red_dispatcher;
- worker->qxl = init_data->qxl;
+
+ worker->red_dispatcher = red_dispatcher;
+ worker->qxl = qxl;
worker->channel = dispatcher_get_recv_fd(dispatcher);
register_callbacks(dispatcher);
if (worker->record_fd) {
dispatcher_register_universal_handler(dispatcher, worker_dispatcher_record);
}
worker->cursor_visible = TRUE;
- spice_assert(init_data->num_renderers > 0);
- worker->num_renderers = init_data->num_renderers;
- memcpy(worker->renderers, init_data->renderers, sizeof(worker->renderers));
+ spice_assert(num_renderers > 0);
+ worker->num_renderers = num_renderers;
+ memcpy(worker->renderers, renderers, sizeof(worker->renderers));
worker->renderer = RED_RENDERER_INVALID;
worker->mouse_mode = SPICE_MOUSE_MODE_SERVER;
- worker->image_compression = init_data->image_compression;
- worker->jpeg_state = init_data->jpeg_state;
- worker->zlib_glz_state = init_data->zlib_glz_state;
- worker->streaming_video = init_data->streaming_video;
+ worker->image_compression = image_compression;
+ worker->jpeg_state = jpeg_state;
+ worker->zlib_glz_state = zlib_glz_state;
+ worker->streaming_video = streaming_video;
worker->driver_cap_monitors_config = 0;
ring_init(&worker->current_list);
image_cache_init(&worker->image_cache);
@@ -11653,14 +11659,14 @@ RedWorker* red_worker_new(WorkerInitData *init_data)
worker->watches[0].watch_func_opaque = worker;
red_memslot_info_init(&worker->mem_slots,
- init_data->num_memslots_groups,
- init_data->num_memslots,
- init_data->memslot_gen_bits,
- init_data->memslot_id_bits,
- init_data->internal_groupslot_id);
-
- spice_warn_if(init_data->n_surfaces > NUM_SURFACES);
- worker->n_surfaces = init_data->n_surfaces;
+ init_info.num_memslots_groups,
+ init_info.num_memslots,
+ init_info.memslot_gen_bits,
+ init_info.memslot_id_bits,
+ init_info.internal_groupslot_id);
+
+ spice_warn_if(init_info.n_surfaces > NUM_SURFACES);
+ worker->n_surfaces = init_info.n_surfaces;
if (!spice_timer_queue_create()) {
spice_error("failed to create timer queue");
diff --git a/server/red_worker.h b/server/red_worker.h
index e2443c4..0f5fac7 100644
--- a/server/red_worker.h
+++ b/server/red_worker.h
@@ -23,36 +23,8 @@
#include "red_common.h"
#include "red_dispatcher.h"
-enum {
- RED_RENDERER_INVALID,
- RED_RENDERER_SW,
- RED_RENDERER_OGL_PBUF,
- RED_RENDERER_OGL_PIXMAP,
-
- RED_RENDERER_LAST
-};
-
typedef struct RedWorker RedWorker;
-typedef struct WorkerInitData {
- struct QXLInstance *qxl;
- int id;
- uint32_t *pending;
- uint32_t num_renderers;
- uint32_t renderers[RED_RENDERER_LAST];
- SpiceImageCompression image_compression;
- spice_wan_compression_t jpeg_state;
- spice_wan_compression_t zlib_glz_state;
- int streaming_video;
- uint32_t num_memslots;
- uint32_t num_memslots_groups;
- uint8_t memslot_gen_bits;
- uint8_t memslot_id_bits;
- uint8_t internal_groupslot_id;
- uint32_t n_surfaces;
- RedDispatcher *red_dispatcher;
-} WorkerInitData;
-
typedef struct CommonChannelClient {
RedChannelClient base;
uint32_t id;
@@ -73,7 +45,7 @@ typedef struct CommonChannel {
of the primary surface) */
} CommonChannel;
-RedWorker* red_worker_new(WorkerInitData *init_data);
+RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher);
bool red_worker_run(RedWorker *worker);
#endif
diff --git a/server/reds.c b/server/reds.c
index 2aea688..1f6774e 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -3364,6 +3364,46 @@ SPICE_GNUC_VISIBLE SpiceServer *spice_server_new(void)
return reds;
}
+typedef struct RendererInfo {
+ int id;
+ const char *name;
+} RendererInfo;
+
+static RendererInfo renderers_info[] = {
+ {RED_RENDERER_SW, "sw"},
+#ifdef USE_OPENGL
+ {RED_RENDERER_OGL_PBUF, "oglpbuf"},
+ {RED_RENDERER_OGL_PIXMAP, "oglpixmap"},
+#endif
+ {RED_RENDERER_INVALID, NULL},
+};
+
+uint32_t renderers[RED_RENDERER_LAST];
+uint32_t num_renderers = 0;
+
+static RendererInfo *find_renderer(const char *name)
+{
+ RendererInfo *inf = renderers_info;
+ while (inf->name) {
+ if (strcmp(name, inf->name) == 0) {
+ return inf;
+ }
+ inf++;
+ }
+ return NULL;
+}
+
+static int red_add_renderer(const char *name)
+{
+ RendererInfo *inf;
+
+ if (num_renderers == RED_RENDERER_LAST || !(inf = find_renderer(name))) {
+ return FALSE;
+ }
+ renderers[num_renderers++] = inf->id;
+ return TRUE;
+}
+
SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *s, SpiceCoreInterface *core)
{
int ret;
@@ -3371,7 +3411,7 @@ SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *s, SpiceCoreInterface *cor
spice_assert(reds == s);
ret = do_spice_init(core);
if (default_renderer) {
- red_dispatcher_add_renderer(default_renderer);
+ red_add_renderer(default_renderer);
}
return ret;
}
@@ -3664,7 +3704,7 @@ SPICE_GNUC_VISIBLE int spice_server_is_server_mouse(SpiceServer *s)
SPICE_GNUC_VISIBLE int spice_server_add_renderer(SpiceServer *s, const char *name)
{
spice_assert(reds == s);
- if (!red_dispatcher_add_renderer(name)) {
+ if (!red_add_renderer(name)) {
return -1;
}
default_renderer = NULL;
diff --git a/server/reds.h b/server/reds.h
index a9c2df9..7937d2d 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -59,7 +59,23 @@ int reds_get_agent_mouse(void); // used by inputs_channel
int reds_has_vdagent(void); // used by inputs channel
void reds_handle_agent_mouse_event(const VDAgentMouseState *mouse_state); // used by inputs_channel
+enum {
+ RED_RENDERER_INVALID,
+ RED_RENDERER_SW,
+ RED_RENDERER_OGL_PBUF,
+ RED_RENDERER_OGL_PIXMAP,
+
+ RED_RENDERER_LAST
+};
+
+extern uint32_t renderers[RED_RENDERER_LAST];
+extern uint32_t num_renderers;
+
extern struct SpiceCoreInterface *core;
+extern uint32_t streaming_video;
+extern SpiceImageCompression image_compression;
+extern spice_wan_compression_t jpeg_state;
+extern spice_wan_compression_t zlib_glz_state;
// Temporary measures to make splitting reds.c to inputs_channel.c easier
More information about the Spice-commits
mailing list