From: Marc-André Lureau <marcandre.lureau@xxxxxxxxx>
Move code around to declare and place it where it fits better.
---
server/red_dispatcher.c | 106 +++++++++++++-----------------------------------
server/red_dispatcher.h | 7 ++++
server/red_worker.c | 56 +++++++++++++------------
server/red_worker.h | 35 +---------------
server/reds.c | 44 +++++++++++++++++++-
server/reds.h | 16 ++++++++
6 files changed, 125 insertions(+), 139 deletions(-)
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index c43da7d..3e7a5e1 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;
@@ -623,14 +578,24 @@ static void qxl_worker_reset_memslots(QXLWorker *qxl_worker)
red_dispatcher_reset_memslots((RedDispatcher*)qxl_worker);
}
+static bool red_dispatcher_set_pending(RedDispatcher *dispatcher, int pending)
+{
+ // TODO: this is not atomic, do we need atomic?
+ if (test_bit(pending, dispatcher->pending)) {
+ return TRUE;
+ }
+
+ set_bit(pending, &dispatcher->pending);
+ return FALSE;
+}
+
static void red_dispatcher_wakeup(RedDispatcher *dispatcher)
{
RedWorkerMessageWakeup payload;
- if (test_bit(RED_WORKER_PENDING_WAKEUP, dispatcher->pending)) {
+ if (red_dispatcher_set_pending(dispatcher, RED_DISPATCHER_PENDING_WAKEUP))
return;
- }
- set_bit(RED_WORKER_PENDING_WAKEUP, &dispatcher->pending);
+
dispatcher_send_message(&dispatcher->dispatcher,
RED_WORKER_MESSAGE_WAKEUP,
&payload);
@@ -645,10 +610,9 @@ static void red_dispatcher_oom(RedDispatcher *dispatcher)
{
RedWorkerMessageOom payload;
- if (test_bit(RED_WORKER_PENDING_OOM, dispatcher->pending)) {
+ if (red_dispatcher_set_pending(dispatcher, RED_DISPATCHER_PENDING_OOM))
return;
- }
- set_bit(RED_WORKER_PENDING_OOM, &dispatcher->pending);
+
dispatcher_send_message(&dispatcher->dispatcher,
RED_WORKER_MESSAGE_OOM,
&payload);
@@ -1063,12 +1027,11 @@ static RedChannel *red_dispatcher_cursor_channel_create(RedDispatcher *dispatche
RedDispatcher *red_dispatcher_new(QXLInstance *qxl)
{
RedDispatcher *red_dispatcher;
- WorkerInitData init_data;
- QXLDevInitInfo init_info;
RedChannel *display_channel;
RedChannel *cursor_channel;
ClientCbs client_cbs = { NULL, };
+ spice_return_val_if_fail(qxl != NULL, NULL);
spice_return_val_if_fail(qxl->st->dispatcher == NULL, NULL);
static gsize initialized = FALSE;
@@ -1082,22 +1045,11 @@ RedDispatcher *red_dispatcher_new(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;
@@ -1111,7 +1063,6 @@ RedDispatcher *red_dispatcher_new(QXLInstance *qxl)
red_dispatcher->base.destroy_surfaces = qxl_worker_destroy_surfaces;
red_dispatcher->base.create_primary_surface = qxl_worker_create_primary_surface;
red_dispatcher->base.destroy_primary_surface = qxl_worker_destroy_primary_surface;
-
red_dispatcher->base.reset_image_cache = qxl_worker_reset_image_cache;
red_dispatcher->base.reset_cursor = qxl_worker_reset_cursor;
red_dispatcher->base.destroy_surface_wait = qxl_worker_destroy_surface_wait;
@@ -1119,20 +1070,12 @@ RedDispatcher *red_dispatcher_new(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) {
@@ -1173,8 +1116,15 @@ struct Dispatcher *red_dispatcher_get_dispatcher(RedDispatcher *red_dispatcher)
return &red_dispatcher->dispatcher;
}
-void red_dispatcher_set_dispatcher_opaque(struct RedDispatcher *red_dispatcher,
+void red_dispatcher_set_dispatcher_opaque(RedDispatcher *red_dispatcher,
void *opaque)
{
dispatcher_set_opaque(&red_dispatcher->dispatcher, opaque);
}
+
+void red_dispatcher_clear_pending(RedDispatcher *red_dispatcher, int pending)
+{
+ spice_return_if_fail(red_dispatcher != NULL);
+
+ clear_bit(pending, &red_dispatcher->pending);
+}
diff --git a/server/red_dispatcher.h b/server/red_dispatcher.h
index f487317..3bdeac0 100644
--- a/server/red_dispatcher.h
+++ b/server/red_dispatcher.h
@@ -293,4 +293,11 @@ typedef struct RedWorkerMessageMonitorsConfigAsync {
typedef struct RedWorkerMessageDriverUnload {
} RedWorkerMessageDriverUnload;
+enum {
+ RED_DISPATCHER_PENDING_WAKEUP,
+ RED_DISPATCHER_PENDING_OOM,
+};
+
+void red_dispatcher_clear_pending(RedDispatcher *red_dispatcher, int pending);
+
#endif
diff --git a/server/red_worker.c b/server/red_worker.c
index 65961db..7f73409 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -869,10 +869,11 @@ typedef struct RedWorker {
int channel;
int id;
int running;
- uint32_t *pending;
struct pollfd poll_fds[MAX_EVENT_SOURCES];
struct SpiceWatch watches[MAX_EVENT_SOURCES];
unsigned int event_timeout;
+
+ gint timeout;
uint32_t repoll_cmd_ring;
uint32_t repoll_cursor_ring;
uint32_t num_renderers;
@@ -11271,8 +11272,8 @@ void handle_dev_wakeup(void *opaque, void *payload)
{
RedWorker *worker = opaque;
- clear_bit(RED_WORKER_PENDING_WAKEUP, worker->pending);
stat_inc_counter(worker->wakeup_counter, 1);
+ red_dispatcher_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_WAKEUP);
}
void handle_dev_oom(void *opaque, void *payload)
@@ -11305,7 +11306,7 @@ void handle_dev_oom(void *opaque, void *payload)
worker->current_size,
worker->display_channel ?
red_channel_sum_pipes_size(display_red_channel) : 0);
- clear_bit(RED_WORKER_PENDING_OOM, worker->pending);
+ red_dispatcher_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_OOM);
}
void handle_dev_reset_cursor(void *opaque, void *payload)
@@ -11852,15 +11853,20 @@ 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;
spice_assert(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
+ 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";
@@ -11873,27 +11879,27 @@ 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->id = init_data->id;
+
+ worker->red_dispatcher = red_dispatcher;
+ worker->qxl = qxl;
+ worker->id = qxl->id;
worker->channel = dispatcher_get_recv_fd(dispatcher);
register_callbacks(dispatcher);
if (worker->record_fd) {
dispatcher_register_universal_handler(dispatcher, worker_dispatcher_record);
}
- worker->pending = init_data->pending;
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);
@@ -11922,14 +11928,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 c935e0a..c1adca4 100644
--- a/server/red_worker.h
+++ b/server/red_worker.h
@@ -23,42 +23,9 @@
#include "red_common.h"
#include "red_dispatcher.h"
-enum {
- RED_WORKER_PENDING_WAKEUP,
- RED_WORKER_PENDING_OOM,
-};
-
-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;
-
-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 d53ea66..90d14b5 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
--
2.4.3
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/spice-devel