[Spice-devel] [RFC 3/3] server/red_worker: reuse dispatcher
Alon Levy
alevy at redhat.com
Tue Nov 1 01:10:03 PDT 2011
This patch reuses Dispatcher in RedDispatcher. It adds two helpers
to red_worker to keep RedWorker opaque to the outside. The dispatcher is
abused in three places that use the underlying socket directly:
once sending a READY after red_init completes
once for each channel creation, replying with the RedChannel instance
for cursor and display.
Code is being added, not removed.
Readability?
---
server/red_dispatcher.c | 585 +++++++++++++++++++++++++++------------
server/red_dispatcher.h | 182 ++++++++++++
server/red_worker.c | 716 +++++++++++++++++++++++++----------------------
server/red_worker.h | 2 +
4 files changed, 979 insertions(+), 506 deletions(-)
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index 7a0033f..4680b50 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -37,6 +37,7 @@
#include "reds_gl_canvas.h"
#endif // USE_OPENGL
#include "reds.h"
+#include "dispatcher.h"
#include "red_dispatcher.h"
#include "red_parse_qxl.h"
@@ -53,7 +54,7 @@ struct AsyncCommand {
struct RedDispatcher {
QXLWorker base;
QXLInstance *qxl;
- int channel;
+ Dispatcher dispatcher;
pthread_t worker_thread;
uint32_t pending;
int primary_active;
@@ -83,24 +84,196 @@ extern spice_wan_compression_t zlib_glz_state;
static RedDispatcher *dispatchers = NULL;
+static void register_callbacks(RedDispatcher *dispatcher)
+{
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_CONNECT,
+ handle_dev_display_connect,
+ sizeof(RedWorkerMessageDisplayConnect),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_DISCONNECT,
+ handle_dev_display_disconnect,
+ sizeof(RedWorkerMessageDisplayDisconnect),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_MIGRATE,
+ handle_dev_display_migrate,
+ sizeof(RedWorkerMessageDisplayMigrate),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_CONNECT,
+ handle_dev_cursor_connect,
+ sizeof(RedWorkerMessageCursorConnect),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_DISCONNECT,
+ handle_dev_cursor_disconnect,
+ sizeof(RedWorkerMessageCursorDisconnect),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_MIGRATE,
+ handle_dev_cursor_migrate,
+ sizeof(RedWorkerMessageCursorMigrate),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_UPDATE,
+ handle_dev_update,
+ sizeof(RedWorkerMessageUpdate),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_UPDATE_ASYNC,
+ handle_dev_update_async,
+ sizeof(RedWorkerMessageUpdateAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_ADD_MEMSLOT,
+ handle_dev_add_memslot,
+ sizeof(RedWorkerMessageAddMemslot),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_ADD_MEMSLOT_ASYNC,
+ handle_dev_add_memslot_async,
+ sizeof(RedWorkerMessageAddMemslotAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DEL_MEMSLOT,
+ handle_dev_del_memslot,
+ sizeof(RedWorkerMessageDelMemslot),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACES,
+ handle_dev_destroy_surfaces,
+ sizeof(RedWorkerMessageDestroySurfaces),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACES_ASYNC,
+ handle_dev_destroy_surfaces_async,
+ sizeof(RedWorkerMessageDestroySurfacesAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE,
+ handle_dev_destroy_primary_surface,
+ sizeof(RedWorkerMessageDestroyPrimarySurface),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE_ASYNC,
+ handle_dev_destroy_primary_surface_async,
+ sizeof(RedWorkerMessageDestroyPrimarySurfaceAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE_ASYNC,
+ handle_dev_create_primary_surface_async,
+ sizeof(RedWorkerMessageCreatePrimarySurfaceAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE,
+ handle_dev_create_primary_surface,
+ sizeof(RedWorkerMessageCreatePrimarySurface),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_IMAGE_CACHE,
+ handle_dev_reset_image_cache,
+ sizeof(RedWorkerMessageResetImageCache),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_CURSOR,
+ handle_dev_reset_cursor,
+ sizeof(RedWorkerMessageResetCursor),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_WAKEUP,
+ handle_dev_wakeup,
+ sizeof(RedWorkerMessageWakeup),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_OOM,
+ handle_dev_oom,
+ sizeof(RedWorkerMessageOom),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_START,
+ handle_dev_start,
+ sizeof(RedWorkerMessageStart),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC,
+ handle_dev_flush_surfaces_async,
+ sizeof(RedWorkerMessageFlushSurfacesAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_STOP,
+ handle_dev_stop,
+ sizeof(RedWorkerMessageStop),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_LOADVM_COMMANDS,
+ handle_dev_loadvm_commands,
+ sizeof(RedWorkerMessageLoadvmCommands),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_SET_COMPRESSION,
+ handle_dev_set_compression,
+ sizeof(RedWorkerMessageSetCompression),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_SET_STREAMING_VIDEO,
+ handle_dev_set_streaming_video,
+ sizeof(RedWorkerMessageSetStreamingVideo),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_SET_MOUSE_MODE,
+ handle_dev_set_mouse_mode,
+ sizeof(RedWorkerMessageSetMouseMode),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
+ handle_dev_display_channel_create,
+ sizeof(RedWorkerMessageDisplayChannelCreate),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
+ handle_dev_cursor_channel_create,
+ sizeof(RedWorkerMessageCursorChannelCreate),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT,
+ handle_dev_destroy_surface_wait,
+ sizeof(RedWorkerMessageDestroySurfaceWait),
+ 1);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT_ASYNC,
+ handle_dev_destroy_surface_wait_async,
+ sizeof(RedWorkerMessageDestroySurfaceWaitAsync),
+ 0);
+ dispatcher_register_handler(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_MEMSLOTS,
+ handle_dev_reset_memslots,
+ sizeof(RedWorkerMessageResetMemslots),
+ 0);
+}
+
static void red_dispatcher_set_display_peer(RedChannel *channel, RedClient *client,
RedsStream *stream, int migration,
int num_common_caps, uint32_t *common_caps, int num_caps,
uint32_t *caps)
{
+ RedWorkerMessageDisplayConnect payload;
RedDispatcher *dispatcher;
red_printf("");
dispatcher = (RedDispatcher *)channel->data;
- RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_CONNECT;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &client, sizeof(RedClient *));
- send_data(dispatcher->channel, &stream, sizeof(RedsStream *));
- send_data(dispatcher->channel, &migration, sizeof(int));
+ payload.client = client;
+ payload.stream = stream;
+ payload.migration = migration;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_CONNECT,
+ &payload);
}
static void red_dispatcher_disconnect_display_peer(RedChannelClient *rcc)
{
+ RedWorkerMessageDisplayDisconnect payload;
RedDispatcher *dispatcher;
if (!rcc->channel) {
@@ -110,27 +283,28 @@ static void red_dispatcher_disconnect_display_peer(RedChannelClient *rcc)
dispatcher = (RedDispatcher *)rcc->channel->data;
red_printf("");
- RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_DISCONNECT;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &rcc, sizeof(RedChannelClient *));
+ payload.rcc = rcc;
// TODO: we turned it to be sync, due to client_destroy . Should we support async? - for this we will need ref count
// for channels
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_DISCONNECT,
+ &payload);
}
static void red_dispatcher_display_migrate(RedChannelClient *rcc)
{
+ RedWorkerMessageDisplayMigrate payload;
RedDispatcher *dispatcher;
if (!rcc->channel) {
return;
}
dispatcher = (RedDispatcher *)rcc->channel->data;
red_printf("channel type %u id %u", rcc->channel->type, rcc->channel->id);
- RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_MIGRATE;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &rcc, sizeof(RedChannelClient *));
+ payload.rcc = rcc;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_MIGRATE,
+ &payload);
}
static void red_dispatcher_set_cursor_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
@@ -138,17 +312,20 @@ static void red_dispatcher_set_cursor_peer(RedChannel *channel, RedClient *clien
uint32_t *common_caps, int num_caps,
uint32_t *caps)
{
+ RedWorkerMessageCursorConnect payload;
RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
red_printf("");
- RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_CONNECT;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &client, sizeof(RedClient *));
- send_data(dispatcher->channel, &stream, sizeof(RedsStream *));
- send_data(dispatcher->channel, &migration, sizeof(int));
+ payload.client = client;
+ payload.stream = stream;
+ payload.migration = migration;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_CONNECT,
+ &payload);
}
static void red_dispatcher_disconnect_cursor_peer(RedChannelClient *rcc)
{
+ RedWorkerMessageCursorDisconnect payload;
RedDispatcher *dispatcher;
if (!rcc->channel) {
@@ -157,16 +334,16 @@ static void red_dispatcher_disconnect_cursor_peer(RedChannelClient *rcc)
dispatcher = (RedDispatcher *)rcc->channel->data;
red_printf("");
- RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_DISCONNECT;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &rcc, sizeof(RedChannelClient *));
+ payload.rcc = rcc;
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_DISCONNECT,
+ &payload);
}
static void red_dispatcher_cursor_migrate(RedChannelClient *rcc)
{
+ RedWorkerMessageCursorMigrate payload;
RedDispatcher *dispatcher;
if (!rcc->channel) {
@@ -174,8 +351,10 @@ static void red_dispatcher_cursor_migrate(RedChannelClient *rcc)
}
dispatcher = (RedDispatcher *)rcc->channel->data;
red_printf("channel type %u id %u", rcc->channel->type, rcc->channel->id);
- RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_MIGRATE;
- write_message(dispatcher->channel, &message);
+ payload.rcc = rcc;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_MIGRATE,
+ &payload);
}
typedef struct RendererInfo {
@@ -258,16 +437,16 @@ static void red_dispatcher_update_area(RedDispatcher *dispatcher, uint32_t surfa
QXLRect *qxl_area, QXLRect *qxl_dirty_rects,
uint32_t num_dirty_rects, uint32_t clear_dirty_region)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_UPDATE;
+ RedWorkerMessageUpdate payload;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &surface_id, sizeof(uint32_t));
- send_data(dispatcher->channel, &qxl_area, sizeof(QXLRect *));
- send_data(dispatcher->channel, &qxl_dirty_rects, sizeof(QXLRect *));
- send_data(dispatcher->channel, &num_dirty_rects, sizeof(uint32_t));
- send_data(dispatcher->channel, &clear_dirty_region, sizeof(uint32_t));
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ payload.surface_id = surface_id;
+ payload.qxl_area = qxl_area;
+ payload.qxl_dirty_rects = qxl_dirty_rects;
+ payload.num_dirty_rects = num_dirty_rects;
+ payload.clear_dirty_region = clear_dirty_region;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_UPDATE,
+ &payload);
}
static AsyncCommand *push_async_command(RedDispatcher *dispatcher,
@@ -299,13 +478,15 @@ static void red_dispatcher_update_area_async(RedDispatcher *dispatcher,
uint64_t cookie)
{
RedWorkerMessage message = RED_WORKER_MESSAGE_UPDATE_ASYNC;
- AsyncCommand *cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ RedWorkerMessageUpdateAsync payload;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, cmd, sizeof(cmd));
- send_data(dispatcher->channel, &surface_id, sizeof(uint32_t));
- send_data(dispatcher->channel, qxl_area, sizeof(QXLRect));
- send_data(dispatcher->channel, &clear_dirty_region, sizeof(uint32_t));
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ payload.surface_id = surface_id;
+ payload.qxl_area = *qxl_area;
+ payload.clear_dirty_region = clear_dirty_region;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ message,
+ &payload);
}
static void qxl_worker_update_area(QXLWorker *qxl_worker, uint32_t surface_id,
@@ -318,12 +499,12 @@ static void qxl_worker_update_area(QXLWorker *qxl_worker, uint32_t surface_id,
static void red_dispatcher_add_memslot(RedDispatcher *dispatcher, QXLDevMemSlot *mem_slot)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_ADD_MEMSLOT;
+ RedWorkerMessageAddMemslot payload;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, mem_slot, sizeof(QXLDevMemSlot));
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ payload.mem_slot = *mem_slot;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_ADD_MEMSLOT,
+ &payload);
}
static void qxl_worker_add_memslot(QXLWorker *qxl_worker, QXLDevMemSlot *mem_slot)
@@ -333,21 +514,22 @@ static void qxl_worker_add_memslot(QXLWorker *qxl_worker, QXLDevMemSlot *mem_slo
static void red_dispatcher_add_memslot_async(RedDispatcher *dispatcher, QXLDevMemSlot *mem_slot, uint64_t cookie)
{
+ RedWorkerMessageAddMemslotAsync payload;
RedWorkerMessage message = RED_WORKER_MESSAGE_ADD_MEMSLOT_ASYNC;
- AsyncCommand *cmd = red_dispatcher_async_start(dispatcher, message, cookie);
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
- send_data(dispatcher->channel, mem_slot, sizeof(QXLDevMemSlot));
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ payload.mem_slot = *mem_slot;
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
}
static void red_dispatcher_del_memslot(RedDispatcher *dispatcher, uint32_t slot_group_id, uint32_t slot_id)
{
+ RedWorkerMessageDelMemslot payload;
RedWorkerMessage message = RED_WORKER_MESSAGE_DEL_MEMSLOT;
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &slot_group_id, sizeof(uint32_t));
- send_data(dispatcher->channel, &slot_id, sizeof(uint32_t));
+ payload.slot_group_id = slot_group_id;
+ payload.slot_id = slot_id;
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
}
static void qxl_worker_del_memslot(QXLWorker *qxl_worker, uint32_t slot_group_id, uint32_t slot_id)
@@ -357,11 +539,11 @@ static void qxl_worker_del_memslot(QXLWorker *qxl_worker, uint32_t slot_group_id
static void red_dispatcher_destroy_surfaces(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_DESTROY_SURFACES;
+ RedWorkerMessageDestroySurfaces payload;
- write_message(dispatcher->channel, &message);
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACES,
+ &payload);
}
static void qxl_worker_destroy_surfaces(QXLWorker *qxl_worker)
@@ -371,11 +553,11 @@ static void qxl_worker_destroy_surfaces(QXLWorker *qxl_worker)
static void red_dispatcher_destroy_surfaces_async(RedDispatcher *dispatcher, uint64_t cookie)
{
+ RedWorkerMessageDestroySurfacesAsync payload;
RedWorkerMessage message = RED_WORKER_MESSAGE_DESTROY_SURFACES_ASYNC;
- AsyncCommand *cmd = red_dispatcher_async_start(dispatcher, message, cookie);
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
}
static void red_dispatcher_destroy_primary_surface_complete(RedDispatcher *dispatcher)
@@ -389,28 +571,37 @@ static void red_dispatcher_destroy_primary_surface_complete(RedDispatcher *dispa
}
static void
+red_dispatcher_destroy_primary_surface_sync(RedDispatcher *dispatcher,
+ uint32_t surface_id)
+{
+ RedWorkerMessageDestroyPrimarySurface payload;
+ payload.surface_id = surface_id;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE,
+ &payload);
+ red_dispatcher_destroy_primary_surface_complete(dispatcher);
+}
+
+static void
+red_dispatcher_destroy_primary_surface_async(RedDispatcher *dispatcher,
+ uint32_t surface_id, uint64_t cookie)
+{
+ RedWorkerMessageDestroyPrimarySurfaceAsync payload;
+ RedWorkerMessage message = RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE_ASYNC;
+
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ payload.surface_id = surface_id;
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
+}
+
+static void
red_dispatcher_destroy_primary_surface(RedDispatcher *dispatcher,
uint32_t surface_id, int async, uint64_t cookie)
{
- RedWorkerMessage message;
- AsyncCommand *cmd;
-
if (async) {
- message = RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE_ASYNC;
- cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ red_dispatcher_destroy_primary_surface_async(dispatcher, surface_id, cookie);
} else {
- message = RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE;
- }
-
- write_message(dispatcher->channel, &message);
- if (async) {
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
- }
- send_data(dispatcher->channel, &surface_id, sizeof(uint32_t));
- if (!async) {
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
- red_dispatcher_destroy_primary_surface_complete(dispatcher);
+ red_dispatcher_destroy_primary_surface_sync(dispatcher, surface_id);
}
}
@@ -433,30 +624,42 @@ static void red_dispatcher_create_primary_surface_complete(RedDispatcher *dispat
}
static void
-red_dispatcher_create_primary_surface(RedDispatcher *dispatcher, uint32_t surface_id,
- QXLDevSurfaceCreate *surface, int async, uint64_t cookie)
+red_dispatcher_create_primary_surface_async(RedDispatcher *dispatcher, uint32_t surface_id,
+ QXLDevSurfaceCreate *surface, uint64_t cookie)
{
- RedWorkerMessage message;
- AsyncCommand *cmd;
+ RedWorkerMessageCreatePrimarySurfaceAsync payload;
+ RedWorkerMessage message = RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE_ASYNC;
- if (async) {
- message = RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE_ASYNC;
- cmd = red_dispatcher_async_start(dispatcher, message, cookie);
- } else {
- message = RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE;
- }
dispatcher->surface_create = *surface;
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ payload.surface_id = surface_id;
+ payload.surface = *surface;
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
+}
- write_message(dispatcher->channel, &message);
+static void
+red_dispatcher_create_primary_surface_sync(RedDispatcher *dispatcher, uint32_t surface_id,
+ QXLDevSurfaceCreate *surface)
+{
+ RedWorkerMessageCreatePrimarySurface payload;
+
+ dispatcher->surface_create = *surface;
+ payload.surface_id = surface_id;
+ payload.surface = *surface;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE,
+ &payload);
+ red_dispatcher_create_primary_surface_complete(dispatcher);
+}
+
+static void
+red_dispatcher_create_primary_surface(RedDispatcher *dispatcher, uint32_t surface_id,
+ QXLDevSurfaceCreate *surface, int async, uint64_t cookie)
+{
if (async) {
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
- }
- send_data(dispatcher->channel, &surface_id, sizeof(uint32_t));
- send_data(dispatcher->channel, surface, sizeof(QXLDevSurfaceCreate));
- if (!async) {
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
- red_dispatcher_create_primary_surface_complete(dispatcher);
+ red_dispatcher_create_primary_surface_async(dispatcher, surface_id, surface, cookie);
+ } else {
+ red_dispatcher_create_primary_surface_sync(dispatcher, surface_id, surface);
}
}
@@ -468,11 +671,11 @@ static void qxl_worker_create_primary_surface(QXLWorker *qxl_worker, uint32_t su
static void red_dispatcher_reset_image_cache(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_RESET_IMAGE_CACHE;
+ RedWorkerMessageResetImageCache payload;
- write_message(dispatcher->channel, &message);
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_IMAGE_CACHE,
+ &payload);
}
static void qxl_worker_reset_image_cache(QXLWorker *qxl_worker)
@@ -482,11 +685,11 @@ static void qxl_worker_reset_image_cache(QXLWorker *qxl_worker)
static void red_dispatcher_reset_cursor(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_RESET_CURSOR;
+ RedWorkerMessageResetCursor payload;
- write_message(dispatcher->channel, &message);
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_CURSOR,
+ &payload);
}
static void qxl_worker_reset_cursor(QXLWorker *qxl_worker)
@@ -494,29 +697,35 @@ static void qxl_worker_reset_cursor(QXLWorker *qxl_worker)
red_dispatcher_reset_cursor((RedDispatcher*)qxl_worker);
}
-static void red_dispatcher_destroy_surface_wait(RedDispatcher *dispatcher, uint32_t surface_id,
- int async, uint64_t cookie)
+static void red_dispatcher_destroy_surface_wait_sync(RedDispatcher *dispatcher, uint32_t surface_id)
{
- RedWorkerMessage message;
- AsyncCommand *cmd;
+ RedWorkerMessageDestroySurfaceWait payload;
- if (async ) {
- message = RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT_ASYNC;
- cmd = red_dispatcher_async_start(dispatcher, message, cookie);
- } else {
- message = RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT;
- }
+ payload.surface_id = surface_id;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT,
+ &payload);
+}
+
+static void red_dispatcher_destroy_surface_wait_async(RedDispatcher *dispatcher, uint32_t surface_id,
+ uint64_t cookie)
+{
+ RedWorkerMessageDestroySurfaceWaitAsync payload;
+ RedWorkerMessage message = RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT_ASYNC;
- write_message(dispatcher->channel, &message);
- if (async) {
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
- }
- send_data(dispatcher->channel, &surface_id, sizeof(uint32_t));
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ payload.surface_id = surface_id;
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
+}
+
+static void red_dispatcher_destroy_surface_wait(RedDispatcher *dispatcher, uint32_t surface_id,
+ int async, uint64_t cookie)
+{
if (async) {
- return;
+ red_dispatcher_destroy_surface_wait_async(dispatcher, surface_id, cookie);
+ } else {
+ red_dispatcher_destroy_surface_wait_sync(dispatcher, surface_id);
}
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
}
static void qxl_worker_destroy_surface_wait(QXLWorker *qxl_worker, uint32_t surface_id)
@@ -526,9 +735,11 @@ static void qxl_worker_destroy_surface_wait(QXLWorker *qxl_worker, uint32_t surf
static void red_dispatcher_reset_memslots(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_RESET_MEMSLOTS;
+ RedWorkerMessageResetMemslots payload;
- write_message(dispatcher->channel, &message);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_RESET_MEMSLOTS,
+ &payload);
}
static void qxl_worker_reset_memslots(QXLWorker *qxl_worker)
@@ -538,11 +749,15 @@ static void qxl_worker_reset_memslots(QXLWorker *qxl_worker)
static void red_dispatcher_wakeup(RedDispatcher *dispatcher)
{
- if (!test_bit(RED_WORKER_PENDING_WAKEUP, dispatcher->pending)) {
- RedWorkerMessage message = RED_WORKER_MESSAGE_WAKEUP;
- set_bit(RED_WORKER_PENDING_WAKEUP, &dispatcher->pending);
- write_message(dispatcher->channel, &message);
+ RedWorkerMessageWakeup payload;
+
+ if (test_bit(RED_WORKER_PENDING_WAKEUP, dispatcher->pending)) {
+ return;
}
+ set_bit(RED_WORKER_PENDING_WAKEUP, &dispatcher->pending);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_WAKEUP,
+ &payload);
}
static void qxl_worker_wakeup(QXLWorker *qxl_worker)
@@ -552,11 +767,15 @@ static void qxl_worker_wakeup(QXLWorker *qxl_worker)
static void red_dispatcher_oom(RedDispatcher *dispatcher)
{
- if (!test_bit(RED_WORKER_PENDING_OOM, dispatcher->pending)) {
- RedWorkerMessage message = RED_WORKER_MESSAGE_OOM;
- set_bit(RED_WORKER_PENDING_OOM, &dispatcher->pending);
- write_message(dispatcher->channel, &message);
+ RedWorkerMessageOom payload;
+
+ if (test_bit(RED_WORKER_PENDING_OOM, dispatcher->pending)) {
+ return;
}
+ set_bit(RED_WORKER_PENDING_OOM, &dispatcher->pending);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_OOM,
+ &payload);
}
static void qxl_worker_oom(QXLWorker *qxl_worker)
@@ -566,9 +785,11 @@ static void qxl_worker_oom(QXLWorker *qxl_worker)
static void red_dispatcher_start(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_START;
+ RedWorkerMessageStart payload;
- write_message(dispatcher->channel, &message);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_START,
+ &payload);
}
static void qxl_worker_start(QXLWorker *qxl_worker)
@@ -578,20 +799,20 @@ static void qxl_worker_start(QXLWorker *qxl_worker)
static void red_dispatcher_flush_surfaces_async(RedDispatcher *dispatcher, uint64_t cookie)
{
+ RedWorkerMessageFlushSurfacesAsync payload;
RedWorkerMessage message = RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC;
- AsyncCommand *cmd = red_dispatcher_async_start(dispatcher, message, cookie);
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &cmd, sizeof(cmd));
+ payload.cmd = red_dispatcher_async_start(dispatcher, message, cookie);
+ dispatcher_send_message(&dispatcher->dispatcher, message, &payload);
}
static void red_dispatcher_stop(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_STOP;
+ RedWorkerMessageStop payload;
- write_message(dispatcher->channel, &message);
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_STOP,
+ &payload);
}
static void qxl_worker_stop(QXLWorker *qxl_worker)
@@ -603,14 +824,14 @@ static void red_dispatcher_loadvm_commands(RedDispatcher *dispatcher,
struct QXLCommandExt *ext,
uint32_t count)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_LOADVM_COMMANDS;
+ RedWorkerMessageLoadvmCommands payload;
red_printf("");
- write_message(dispatcher->channel, &message);
- send_data(dispatcher->channel, &count, sizeof(uint32_t));
- send_data(dispatcher->channel, ext, sizeof(QXLCommandExt) * count);
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ payload.count = count;
+ payload.ext = ext;
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_LOADVM_COMMANDS,
+ &payload);
}
static void qxl_worker_loadvm_commands(QXLWorker *qxl_worker,
@@ -642,37 +863,44 @@ static inline int calc_compression_level(void)
void red_dispatcher_on_ic_change(void)
{
+ RedWorkerMessageSetCompression payload;
int compression_level = calc_compression_level();
RedDispatcher *now = dispatchers;
+
while (now) {
- RedWorkerMessage message = RED_WORKER_MESSAGE_SET_COMPRESSION;
now->qxl->st->qif->set_compression_level(now->qxl, compression_level);
- write_message(now->channel, &message);
- send_data(now->channel, &image_compression, sizeof(spice_image_compression_t));
+ payload.image_compression = image_compression;
+ dispatcher_send_message(&now->dispatcher,
+ RED_WORKER_MESSAGE_SET_COMPRESSION,
+ &payload);
now = now->next;
}
}
void red_dispatcher_on_sv_change(void)
{
+ RedWorkerMessageSetStreamingVideo payload;
int compression_level = calc_compression_level();
RedDispatcher *now = dispatchers;
while (now) {
- RedWorkerMessage message = RED_WORKER_MESSAGE_SET_STREAMING_VIDEO;
now->qxl->st->qif->set_compression_level(now->qxl, compression_level);
- write_message(now->channel, &message);
- send_data(now->channel, &streaming_video, sizeof(uint32_t));
+ payload.streaming_video = streaming_video;
+ dispatcher_send_message(&now->dispatcher,
+ RED_WORKER_MESSAGE_SET_STREAMING_VIDEO,
+ &payload);
now = now->next;
}
}
void red_dispatcher_set_mouse_mode(uint32_t mode)
{
+ RedWorkerMessageSetMouseMode payload;
RedDispatcher *now = dispatchers;
while (now) {
- RedWorkerMessage message = RED_WORKER_MESSAGE_SET_MOUSE_MODE;
- write_message(now->channel, &message);
- send_data(now->channel, &mode, sizeof(uint32_t));
+ payload.mode = mode;
+ dispatcher_send_message(&now->dispatcher,
+ RED_WORKER_MESSAGE_SET_MOUSE_MODE,
+ &payload);
now = now->next;
}
}
@@ -891,34 +1119,31 @@ end:
static RedChannel *red_dispatcher_display_channel_create(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE;
+ RedWorkerMessageDisplayChannelCreate payload;
RedChannel *display_channel;
- write_message(dispatcher->channel, &message);
-
- receive_data(dispatcher->channel, &display_channel, sizeof(RedChannel *));
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
+ &payload);
+ receive_data(dispatcher->dispatcher.send_fd, &display_channel, sizeof(RedChannel *));
return display_channel;
}
static RedChannel *red_dispatcher_cursor_channel_create(RedDispatcher *dispatcher)
{
- RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE;
+ RedWorkerMessageCursorChannelCreate payload;
RedChannel *cursor_channel;
- write_message(dispatcher->channel, &message);
-
- receive_data(dispatcher->channel, &cursor_channel, sizeof(RedChannel *));
- read_message(dispatcher->channel, &message);
- ASSERT(message == RED_WORKER_MESSAGE_READY);
+ dispatcher_send_message(&dispatcher->dispatcher,
+ RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
+ &payload);
+ receive_data(dispatcher->dispatcher.send_fd, &cursor_channel, sizeof(RedChannel *));
return cursor_channel;
}
RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
{
RedDispatcher *dispatcher;
- int channels[2];
RedWorkerMessage message;
WorkerInitData init_data;
QXLDevInitInfo init_info;
@@ -935,15 +1160,12 @@ RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
gl_canvas_init();
#endif // USE_OPENGL
- if (socketpair(AF_LOCAL, SOCK_STREAM, 0, channels) == -1) {
- red_error("socketpair failed %s", strerror(errno));
- }
-
dispatcher = spice_new0(RedDispatcher, 1);
- dispatcher->channel = channels[0];
+ dispatcher_init(&dispatcher->dispatcher, NULL, RED_WORKER_MESSAGE_COUNT, NULL);
+ register_callbacks(dispatcher);
init_data.qxl = dispatcher->qxl = qxl;
init_data.id = qxl->id;
- init_data.channel = channels[1];
+ init_data.channel = dispatcher->dispatcher.recv_fd;
init_data.pending = &dispatcher->pending;
init_data.num_renderers = num_renderers;
memcpy(init_data.renderers, renderers, sizeof(init_data.renderers));
@@ -995,7 +1217,7 @@ RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
}
pthread_sigmask(SIG_SETMASK, &curr_sig_mask, NULL);
- read_message(dispatcher->channel, &message);
+ read_message(dispatcher->dispatcher.send_fd, &message);
ASSERT(message == RED_WORKER_MESSAGE_READY);
display_channel = red_dispatcher_display_channel_create(dispatcher);
@@ -1027,3 +1249,14 @@ RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
dispatchers = dispatcher;
return dispatcher;
}
+
+void red_dispatcher_handle_read(RedDispatcher *red_dispatcher)
+{
+ dispatcher_handle_read(0, 0, &red_dispatcher->dispatcher);
+}
+
+void red_dispatcher_set_dispatcher_opaque(struct RedDispatcher *red_dispatcher,
+ void *opaque)
+{
+ dispatcher_set_opaque(&red_dispatcher->dispatcher, opaque);
+}
diff --git a/server/red_dispatcher.h b/server/red_dispatcher.h
index c2582f4..c5399a6 100644
--- a/server/red_dispatcher.h
+++ b/server/red_dispatcher.h
@@ -33,4 +33,186 @@ uint32_t red_dispatcher_qxl_ram_size(void);
int red_dispatcher_qxl_count(void);
void red_dispatcher_async_complete(struct RedDispatcher *, AsyncCommand *);
+void red_dispatcher_handle_read(struct RedDispatcher *);
+void red_dispatcher_set_dispatcher_opaque(struct RedDispatcher *, void *);
+
+/* all the call backs are implemented in red_worker.c */
+void handle_dev_display_connect(void *opaque, void *payload);
+void handle_dev_display_disconnect(void *opaque, void *payload);
+void handle_dev_display_migrate(void *opaque, void *payload);
+void handle_dev_cursor_connect(void *opaque, void *payload);
+void handle_dev_cursor_disconnect(void *opaque, void *payload);
+void handle_dev_cursor_migrate(void *opaque, void *payload);
+void handle_dev_update(void *opaque, void *payload);
+void handle_dev_update_async(void *opaque, void *payload);
+void handle_dev_add_memslot(void *opaque, void *payload);
+void handle_dev_add_memslot_async(void *opaque, void *payload);
+void handle_dev_del_memslot(void *opaque, void *payload);
+void handle_dev_destroy_surfaces(void *opaque, void *payload);
+void handle_dev_destroy_surfaces_async(void *opaque, void *payload);
+void handle_dev_destroy_primary_surface(void *opaque, void *payload);
+void handle_dev_destroy_primary_surface_async(void *opaque, void *payload);
+void handle_dev_create_primary_surface_async(void *opaque, void *payload);
+void handle_dev_create_primary_surface(void *opaque, void *payload);
+void handle_dev_reset_image_cache(void *opaque, void *payload);
+void handle_dev_reset_cursor(void *opaque, void *payload);
+void handle_dev_wakeup(void *opaque, void *payload);
+void handle_dev_oom(void *opaque, void *payload);
+void handle_dev_start(void *opaque, void *payload);
+void handle_dev_flush_surfaces_async(void *opaque, void *payload);
+void handle_dev_stop(void *opaque, void *payload);
+void handle_dev_loadvm_commands(void *opaque, void *payload);
+void handle_dev_set_compression(void *opaque, void *payload);
+void handle_dev_set_streaming_video(void *opaque, void *payload);
+void handle_dev_set_mouse_mode(void *opaque, void *payload);
+void handle_dev_display_channel_create(void *opaque, void *payload);
+void handle_dev_cursor_channel_create(void *opaque, void *payload);
+void handle_dev_destroy_surface_wait(void *opaque, void *payload);
+void handle_dev_destroy_surface_wait_async(void *opaque, void *payload);
+void handle_dev_reset_memslots(void *opaque, void *payload);
+
+typedef struct RedWorkerMessageDisplayConnect {
+ RedClient * client;
+ RedsStream * stream;
+ int migration;
+} RedWorkerMessageDisplayConnect;
+
+typedef struct RedWorkerMessageDisplayDisconnect {
+ RedChannelClient *rcc;
+} RedWorkerMessageDisplayDisconnect;
+
+typedef struct RedWorkerMessageDisplayMigrate {
+ RedChannelClient *rcc;
+} RedWorkerMessageDisplayMigrate;
+
+typedef struct RedWorkerMessageCursorConnect {
+ RedClient *client;
+ RedsStream *stream;
+ int migration;
+} RedWorkerMessageCursorConnect;
+
+typedef struct RedWorkerMessageCursorDisconnect {
+ RedChannelClient *rcc;
+} RedWorkerMessageCursorDisconnect;
+
+typedef struct RedWorkerMessageCursorMigrate {
+ RedChannelClient *rcc;
+} RedWorkerMessageCursorMigrate;
+
+typedef struct RedWorkerMessageUpdate {
+ uint32_t surface_id;
+ QXLRect * qxl_area;
+ QXLRect * qxl_dirty_rects;
+ uint32_t num_dirty_rects;
+ uint32_t clear_dirty_region;
+} RedWorkerMessageUpdate;
+
+typedef struct RedWorkerMessageUpdateAsync {
+ AsyncCommand *cmd;
+ uint32_t surface_id;
+ QXLRect qxl_area;
+ uint32_t clear_dirty_region;
+} RedWorkerMessageUpdateAsync;
+
+typedef struct RedWorkerMessageAddMemslot {
+ QXLDevMemSlot mem_slot;
+} RedWorkerMessageAddMemslot;
+
+typedef struct RedWorkerMessageAddMemslotAsync {
+ AsyncCommand *cmd;
+ QXLDevMemSlot mem_slot;
+} RedWorkerMessageAddMemslotAsync;
+
+typedef struct RedWorkerMessageDelMemslot {
+ uint32_t slot_group_id;
+ uint32_t slot_id;
+} RedWorkerMessageDelMemslot;
+
+typedef struct RedWorkerMessageDestroySurfaces {
+} RedWorkerMessageDestroySurfaces;
+
+typedef struct RedWorkerMessageDestroySurfacesAsync {
+ AsyncCommand *cmd;
+} RedWorkerMessageDestroySurfacesAsync;
+
+
+typedef struct RedWorkerMessageDestroyPrimarySurface {
+ uint32_t surface_id;
+} RedWorkerMessageDestroyPrimarySurface;
+
+typedef struct RedWorkerMessageDestroyPrimarySurfaceAsync {
+ AsyncCommand *cmd;
+ uint32_t surface_id;
+} RedWorkerMessageDestroyPrimarySurfaceAsync;
+
+typedef struct RedWorkerMessageCreatePrimarySurfaceAsync {
+ AsyncCommand *cmd;
+ uint32_t surface_id;
+ QXLDevSurfaceCreate surface;
+} RedWorkerMessageCreatePrimarySurfaceAsync;
+
+typedef struct RedWorkerMessageCreatePrimarySurface {
+ uint32_t surface_id;
+ QXLDevSurfaceCreate surface;
+} RedWorkerMessageCreatePrimarySurface;
+
+typedef struct RedWorkerMessageResetImageCache {
+} RedWorkerMessageResetImageCache;
+
+typedef struct RedWorkerMessageResetCursor {
+} RedWorkerMessageResetCursor;
+
+typedef struct RedWorkerMessageWakeup {
+} RedWorkerMessageWakeup;
+
+typedef struct RedWorkerMessageOom {
+} RedWorkerMessageOom;
+
+typedef struct RedWorkerMessageStart {
+} RedWorkerMessageStart;
+
+typedef struct RedWorkerMessageFlushSurfacesAsync {
+ AsyncCommand *cmd;
+} RedWorkerMessageFlushSurfacesAsync;
+
+typedef struct RedWorkerMessageStop {
+} RedWorkerMessageStop;
+
+/* this command is sync, so it's ok to pass a pointer */
+typedef struct RedWorkerMessageLoadvmCommands {
+ uint32_t count;
+ QXLCommandExt *ext;
+} RedWorkerMessageLoadvmCommands;
+
+typedef struct RedWorkerMessageSetCompression {
+ spice_image_compression_t image_compression;
+} RedWorkerMessageSetCompression;
+
+typedef struct RedWorkerMessageSetStreamingVideo {
+ uint32_t streaming_video;
+} RedWorkerMessageSetStreamingVideo;
+
+typedef struct RedWorkerMessageSetMouseMode {
+ uint32_t mode;
+} RedWorkerMessageSetMouseMode;
+
+typedef struct RedWorkerMessageDisplayChannelCreate {
+} RedWorkerMessageDisplayChannelCreate;
+
+typedef struct RedWorkerMessageCursorChannelCreate {
+} RedWorkerMessageCursorChannelCreate;
+
+typedef struct RedWorkerMessageDestroySurfaceWait {
+ uint32_t surface_id;
+} RedWorkerMessageDestroySurfaceWait;
+
+typedef struct RedWorkerMessageDestroySurfaceWaitAsync {
+ AsyncCommand *cmd;
+ uint32_t surface_id;
+} RedWorkerMessageDestroySurfaceWaitAsync;
+
+typedef struct RedWorkerMessageResetMemslots {
+} RedWorkerMessageResetMemslots;
+
+
#endif
diff --git a/server/red_worker.c b/server/red_worker.c
index 00efc05..6e5a238 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -866,8 +866,8 @@ typedef struct RedWorker {
CursorChannel *cursor_channel;
QXLInstance *qxl;
RedDispatcher *dispatcher;
- int id;
int channel;
+ int id;
int running;
uint32_t *pending;
int epoll;
@@ -10102,21 +10102,19 @@ static void surface_dirty_region_to_rects(RedSurface *surface,
free(dirty_rects);
}
-static inline void handle_dev_update_async(RedWorker *worker)
+void handle_dev_update_async(void *opaque, void *payload)
{
- QXLRect qxl_rect;
+ RedWorker *worker = opaque;
+ RedWorkerMessageUpdateAsync *msg = payload;
SpiceRect rect;
- uint32_t surface_id;
- uint32_t clear_dirty_region;
QXLRect *qxl_dirty_rects;
uint32_t num_dirty_rects;
RedSurface *surface;
+ uint32_t surface_id = msg->surface_id;
+ QXLRect qxl_area = msg->qxl_area;
+ uint32_t clear_dirty_region = msg->clear_dirty_region;
- receive_data(worker->channel, &surface_id, sizeof(uint32_t));
- receive_data(worker->channel, &qxl_rect, sizeof(QXLRect));
- receive_data(worker->channel, &clear_dirty_region, sizeof(uint32_t));
-
- red_get_rect_ptr(&rect, &qxl_rect);
+ red_get_rect_ptr(&rect, &qxl_area);
flush_display_commands(worker);
ASSERT(worker->running);
@@ -10124,12 +10122,12 @@ static inline void handle_dev_update_async(RedWorker *worker)
validate_surface(worker, surface_id);
red_update_area(worker, &rect, surface_id);
if (!worker->qxl->st->qif->update_area_complete) {
- return;
+ goto complete;
}
surface = &worker->surfaces[surface_id];
num_dirty_rects = pixman_region32_n_rects(&surface->draw_dirty_region);
if (num_dirty_rects == 0) {
- return;
+ goto complete;
}
qxl_dirty_rects = spice_new0(QXLRect, num_dirty_rects);
surface_dirty_region_to_rects(surface, qxl_dirty_rects, num_dirty_rects,
@@ -10137,26 +10135,25 @@ static inline void handle_dev_update_async(RedWorker *worker)
worker->qxl->st->qif->update_area_complete(worker->qxl, surface_id,
qxl_dirty_rects, num_dirty_rects);
free(qxl_dirty_rects);
+
+complete:
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
}
-static inline void handle_dev_update(RedWorker *worker)
+void handle_dev_update(void *opaque, void *payload)
{
- const QXLRect *qxl_rect;
+ RedWorker *worker = opaque;
+ RedWorkerMessageUpdate *msg = payload;
SpiceRect *rect = spice_new0(SpiceRect, 1);
- QXLRect *qxl_dirty_rects;
RedSurface *surface;
- uint32_t num_dirty_rects;
- uint32_t surface_id;
- uint32_t clear_dirty_region;
-
- receive_data(worker->channel, &surface_id, sizeof(uint32_t));
- receive_data(worker->channel, &qxl_rect, sizeof(QXLRect *));
- receive_data(worker->channel, &qxl_dirty_rects, sizeof(QXLRect *));
- receive_data(worker->channel, &num_dirty_rects, sizeof(uint32_t));
- receive_data(worker->channel, &clear_dirty_region, sizeof(uint32_t));
+ uint32_t surface_id = msg->surface_id;
+ const QXLRect *qxl_area = msg->qxl_area;
+ uint32_t num_dirty_rects = msg->num_dirty_rects;
+ QXLRect *qxl_dirty_rects = msg->qxl_dirty_rects;
+ uint32_t clear_dirty_region = msg->clear_dirty_region;
surface = &worker->surfaces[surface_id];
- red_get_rect_ptr(rect, qxl_rect);
+ red_get_rect_ptr(rect, qxl_area);
flush_display_commands(worker);
ASSERT(worker->running);
@@ -10169,28 +10166,36 @@ static inline void handle_dev_update(RedWorker *worker)
clear_dirty_region);
}
-static inline void handle_dev_add_memslot(RedWorker *worker)
+static void dev_add_memslot(RedWorker *worker, QXLDevMemSlot mem_slot)
{
- QXLDevMemSlot dev_slot;
+ red_memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
+ mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
+ mem_slot.generation);
+}
- receive_data(worker->channel, &dev_slot, sizeof(QXLDevMemSlot));
+void handle_dev_add_memslot(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+ RedWorkerMessageAddMemslot *msg = payload;
+ QXLDevMemSlot mem_slot = msg->mem_slot;
- red_memslot_info_add_slot(&worker->mem_slots, dev_slot.slot_group_id, dev_slot.slot_id,
- dev_slot.addr_delta, dev_slot.virt_start, dev_slot.virt_end,
- dev_slot.generation);
+ red_memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
+ mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
+ mem_slot.generation);
}
-static inline void handle_dev_del_memslot(RedWorker *worker)
+void handle_dev_del_memslot(void *opaque, void *payload)
{
- uint32_t slot_id;
- uint32_t slot_group_id;
-
- receive_data(worker->channel, &slot_group_id, sizeof(uint32_t));
- receive_data(worker->channel, &slot_id, sizeof(uint32_t));
+ RedWorker *worker = opaque;
+ RedWorkerMessageDelMemslot *msg = payload;
+ uint32_t slot_id = msg->slot_id;
+ uint32_t slot_group_id = msg->slot_group_id;
red_memslot_info_del_slot(&worker->mem_slots, slot_group_id, slot_id);
}
+/* TODO: destroy_surface_wait, dev_destroy_surface_wait - confusing. one asserts
+ * surface_id == 0, maybe move the assert upward and merge the two functions? */
static inline void destroy_surface_wait(RedWorker *worker, int surface_id)
{
if (!worker->surfaces[surface_id].context.canvas) {
@@ -10205,12 +10210,8 @@ static inline void destroy_surface_wait(RedWorker *worker, int surface_id)
red_clear_surface_drawables_from_pipes(worker, surface_id, TRUE, TRUE);
}
-static inline void handle_dev_destroy_surface_wait(RedWorker *worker)
+static void dev_destroy_surface_wait(RedWorker *worker, uint32_t surface_id)
{
- uint32_t surface_id;
-
- receive_data(worker->channel, &surface_id, sizeof(uint32_t));
-
ASSERT(surface_id == 0);
flush_all_qxl_commands(worker);
@@ -10220,6 +10221,14 @@ static inline void handle_dev_destroy_surface_wait(RedWorker *worker)
}
}
+void handle_dev_destroy_surface_wait(void *opaque, void *payload)
+{
+ RedWorkerMessageDestroySurfaceWait *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_destroy_surface_wait(worker, msg->surface_id);
+}
+
static inline void red_cursor_reset(RedWorker *worker)
{
if (worker->cursor) {
@@ -10243,7 +10252,7 @@ static inline void red_cursor_reset(RedWorker *worker)
/* called upon device reset */
/* TODO: split me*/
-static inline void handle_dev_destroy_surfaces(RedWorker *worker)
+static inline void dev_destroy_surfaces(RedWorker *worker)
{
int i;
@@ -10272,14 +10281,17 @@ static inline void handle_dev_destroy_surfaces(RedWorker *worker)
red_cursor_reset(worker);
}
-static inline void handle_dev_create_primary_surface(RedWorker *worker)
+void handle_dev_destroy_surfaces(void *opaque, void *payload)
{
- uint32_t surface_id;
- QXLDevSurfaceCreate surface;
- uint8_t *line_0;
+ RedWorker *worker = opaque;
- receive_data(worker->channel, &surface_id, sizeof(uint32_t));
- receive_data(worker->channel, &surface, sizeof(QXLDevSurfaceCreate));
+ dev_destroy_surfaces(worker);
+}
+
+static void dev_create_primary_surface(RedWorker *worker, uint32_t surface_id,
+ QXLDevSurfaceCreate surface)
+{
+ uint8_t *line_0;
PANIC_ON(surface_id != 0);
PANIC_ON(surface.height == 0);
@@ -10307,12 +10319,16 @@ static inline void handle_dev_create_primary_surface(RedWorker *worker)
}
}
-static inline void handle_dev_destroy_primary_surface(RedWorker *worker)
+void handle_dev_create_primary_surface(void *opaque, void *payload)
{
- uint32_t surface_id;
+ RedWorkerMessageCreatePrimarySurface *msg = payload;
+ RedWorker *worker = opaque;
- receive_data(worker->channel, &surface_id, sizeof(uint32_t));
+ dev_create_primary_surface(worker, msg->surface_id, msg->surface);
+}
+static void dev_destroy_primary_surface(RedWorker *worker, uint32_t surface_id)
+{
PANIC_ON(surface_id != 0);
if (!worker->surfaces[surface_id].context.canvas) {
@@ -10321,7 +10337,7 @@ static inline void handle_dev_destroy_primary_surface(RedWorker *worker)
}
flush_all_qxl_commands(worker);
- destroy_surface_wait(worker, 0);
+ dev_destroy_surface_wait(worker, 0);
red_destroy_surface(worker, 0);
ASSERT(ring_is_empty(&worker->streams));
@@ -10330,6 +10346,25 @@ static inline void handle_dev_destroy_primary_surface(RedWorker *worker)
red_cursor_reset(worker);
}
+void handle_dev_destroy_primary_surface(void *opaque, void *payload)
+{
+ RedWorkerMessageDestroyPrimarySurface *msg = payload;
+ RedWorker *worker = opaque;
+ uint32_t surface_id = msg->surface_id;
+
+ dev_destroy_primary_surface(worker, surface_id);
+}
+
+void handle_dev_destroy_primary_surface_async(void *opaque, void *payload)
+{
+ RedWorkerMessageDestroyPrimarySurfaceAsync *msg = payload;
+ RedWorker *worker = opaque;
+ uint32_t surface_id = msg->surface_id;
+
+ dev_destroy_primary_surface(worker, surface_id);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
static void flush_all_surfaces(RedWorker *worker)
{
int x;
@@ -10341,7 +10376,7 @@ static void flush_all_surfaces(RedWorker *worker)
}
}
-static void handle_dev_flush_surfaces(RedWorker *worker)
+static void dev_flush_surfaces(RedWorker *worker)
{
flush_all_qxl_commands(worker);
flush_all_surfaces(worker);
@@ -10349,8 +10384,27 @@ static void handle_dev_flush_surfaces(RedWorker *worker)
red_wait_outgoing_items(&worker->cursor_channel->common.base);
}
-static void handle_dev_stop(RedWorker *worker)
+void handle_dev_flush_surfaces(void *opaque, void *payload)
{
+ RedWorker *worker = opaque;
+
+ dev_flush_surfaces(worker);
+}
+
+void handle_dev_flush_surfaces_async(void *opaque, void *payload)
+{
+ RedWorkerMessageFlushSurfacesAsync *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_flush_surfaces(worker);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
+void handle_dev_stop(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+
+ red_printf("stop");
ASSERT(worker->running);
worker->running = FALSE;
red_display_clear_glz_drawables(worker->display_channel);
@@ -10359,8 +10413,9 @@ static void handle_dev_stop(RedWorker *worker)
red_wait_outgoing_items(&worker->cursor_channel->common.base);
}
-static void handle_dev_start(RedWorker *worker)
+void handle_dev_start(void *opaque, void *payload)
{
+ RedWorker *worker = opaque;
RedChannel *cursor_red_channel = &worker->cursor_channel->common.base;
RedChannel *display_red_channel = &worker->display_channel->common.base;
@@ -10374,306 +10429,306 @@ static void handle_dev_start(RedWorker *worker)
worker->running = TRUE;
}
-static void handle_dev_input(EventListener *listener, uint32_t events)
+void handle_dev_wakeup(void *opaque, void *payload)
{
- RedWorker *worker = SPICE_CONTAINEROF(listener, RedWorker, dev_listener);
- RedWorkerMessage message;
+ RedWorker *worker = opaque;
+
+ clear_bit(RED_WORKER_PENDING_WAKEUP, worker->pending);
+ stat_inc_counter(worker->wakeup_counter, 1);
+}
+
+void handle_dev_oom(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+
RedChannel *display_red_channel = &worker->display_channel->common.base;
int ring_is_empty;
- int call_async_complete = 0;
- int write_ready = 0;
- AsyncCommand *cmd;
-
- read_message(worker->channel, &message);
- /* for async messages we do the common work in the handler, and
- * send a ready or call async_complete from here, hence the added switch. */
- switch (message) {
- case RED_WORKER_MESSAGE_UPDATE_ASYNC:
- case RED_WORKER_MESSAGE_ADD_MEMSLOT_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_SURFACES_ASYNC:
- case RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT_ASYNC:
- case RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC:
- call_async_complete = 1;
- receive_data(worker->channel, &cmd, sizeof(cmd));
- break;
- case RED_WORKER_MESSAGE_UPDATE:
- case RED_WORKER_MESSAGE_ADD_MEMSLOT:
- case RED_WORKER_MESSAGE_DESTROY_SURFACES:
- case RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE:
- case RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE:
- case RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT:
- case RED_WORKER_MESSAGE_RESET_CURSOR:
- case RED_WORKER_MESSAGE_RESET_IMAGE_CACHE:
- case RED_WORKER_MESSAGE_STOP:
- case RED_WORKER_MESSAGE_LOADVM_COMMANDS:
- case RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE:
- case RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE:
- case RED_WORKER_MESSAGE_DISPLAY_DISCONNECT:
- case RED_WORKER_MESSAGE_CURSOR_DISCONNECT:
- write_ready = 1;
- default:
- break;
+ ASSERT(worker->running);
+ // streams? but without streams also leak
+ red_printf_debug(1, "OOM1 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
+ worker->drawable_count,
+ worker->red_drawable_count,
+ worker->glz_drawable_count,
+ worker->current_size,
+ worker->display_channel ?
+ red_channel_sum_pipes_size(display_red_channel) : 0);
+ while (red_process_commands(worker, MAX_PIPE_SIZE, &ring_is_empty)) {
+ red_channel_push(&worker->display_channel->common.base);
}
-
- switch (message) {
- case RED_WORKER_MESSAGE_UPDATE_ASYNC:
- handle_dev_update_async(worker);
- break;
- case RED_WORKER_MESSAGE_UPDATE:
- handle_dev_update(worker);
- break;
- case RED_WORKER_MESSAGE_WAKEUP:
- clear_bit(RED_WORKER_PENDING_WAKEUP, worker->pending);
- stat_inc_counter(worker->wakeup_counter, 1);
- break;
- case RED_WORKER_MESSAGE_OOM:
- ASSERT(worker->running);
- // streams? but without streams also leak
- red_printf_debug(1, "OOM1 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
- worker->drawable_count,
- worker->red_drawable_count,
- worker->glz_drawable_count,
- worker->current_size,
- worker->display_channel ?
- red_channel_sum_pipes_size(display_red_channel) : 0);
- while (red_process_commands(worker, MAX_PIPE_SIZE, &ring_is_empty)) {
- red_channel_push(&worker->display_channel->common.base);
- }
- if (worker->qxl->st->qif->flush_resources(worker->qxl) == 0) {
- red_free_some(worker);
- worker->qxl->st->qif->flush_resources(worker->qxl);
- }
- red_printf_debug(1, "OOM2 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
- worker->drawable_count,
- worker->red_drawable_count,
- worker->glz_drawable_count,
- worker->current_size,
- worker->display_channel ?
- red_channel_sum_pipes_size(display_red_channel) : 0);
- clear_bit(RED_WORKER_PENDING_OOM, worker->pending);
- break;
- case RED_WORKER_MESSAGE_RESET_CURSOR:
- red_cursor_reset(worker);
- break;
- case RED_WORKER_MESSAGE_RESET_IMAGE_CACHE:
- image_cache_reset(&worker->image_cache);
- break;
- case RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT:
- handle_dev_destroy_surface_wait(worker);
- break;
- case RED_WORKER_MESSAGE_DESTROY_SURFACES_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_SURFACES:
- handle_dev_destroy_surfaces(worker);
- break;
- case RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE_ASYNC:
- case RED_WORKER_MESSAGE_CREATE_PRIMARY_SURFACE:
- handle_dev_create_primary_surface(worker);
- break;
- case RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE_ASYNC:
- case RED_WORKER_MESSAGE_DESTROY_PRIMARY_SURFACE:
- handle_dev_destroy_primary_surface(worker);
- break;
- case RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE: {
- RedChannel *red_channel;
- // TODO: handle seemless migration. Temp, setting migrate to FALSE
- ensure_display_channel_created(worker, FALSE);
- red_channel = &worker->display_channel->common.base;
- send_data(worker->channel, &red_channel, sizeof(RedChannel *));
- break;
+ if (worker->qxl->st->qif->flush_resources(worker->qxl) == 0) {
+ red_free_some(worker);
+ worker->qxl->st->qif->flush_resources(worker->qxl);
}
- case RED_WORKER_MESSAGE_DISPLAY_CONNECT: {
- RedsStream *stream;
- RedClient *client;
- int migrate;
- red_printf("connect");
+ red_printf_debug(1, "OOM2 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
+ worker->drawable_count,
+ worker->red_drawable_count,
+ worker->glz_drawable_count,
+ worker->current_size,
+ worker->display_channel ?
+ red_channel_sum_pipes_size(display_red_channel) : 0);
+ clear_bit(RED_WORKER_PENDING_OOM, worker->pending);
+}
- receive_data(worker->channel, &client, sizeof(RedClient *));
- receive_data(worker->channel, &stream, sizeof(RedsStream *));
- receive_data(worker->channel, &migrate, sizeof(int));
- handle_new_display_channel(worker, client, stream, migrate);
- break;
- }
- case RED_WORKER_MESSAGE_DISPLAY_DISCONNECT: {
- RedChannelClient *rcc;
+void handle_dev_reset_cursor(void *opaque, void *payload)
+{
+ red_cursor_reset((RedWorker *)opaque);
+}
- red_printf("disconnect display client");
- receive_data(worker->channel, &rcc, sizeof(RedChannelClient *));
- ASSERT(rcc);
- display_channel_client_disconnect(rcc);
- break;
- }
- case RED_WORKER_MESSAGE_STOP: {
- red_printf("stop");
- handle_dev_stop(worker);
+void handle_dev_reset_image_cache(void *opaque, void *payload)
+{
+ image_cache_reset(&((RedWorker *)opaque)->image_cache);
+}
+
+void handle_dev_destroy_surface_wait_async(void *opaque, void *payload)
+{
+ RedWorkerMessageDestroySurfaceWaitAsync *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_destroy_surface_wait(worker, msg->surface_id);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
+void handle_dev_destroy_surfaces_async(void *opaque, void *payload)
+{
+ RedWorkerMessageDestroySurfacesAsync *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_destroy_surfaces(worker);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
+void handle_dev_create_primary_surface_async(void *opaque, void *payload)
+{
+ RedWorkerMessageCreatePrimarySurfaceAsync *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_create_primary_surface(worker, msg->surface_id, msg->surface);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
+/* exception for Dispatcher, data going from red_worker to main thread,
+ * TODO: use a different dispatcher?
+ * TODO: leave direct usage of channel(fd)? It's only used right after the
+ * pthread is created, since the channel duration is the lifetime of the spice
+ * server. */
+
+void handle_dev_display_channel_create(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+
+ RedChannel *red_channel;
+ // TODO: handle seemless migration. Temp, setting migrate to FALSE
+ ensure_display_channel_created(worker, FALSE);
+ red_channel = &worker->display_channel->common.base;
+ send_data(worker->channel, &red_channel, sizeof(RedChannel *));
+}
+
+void handle_dev_display_connect(void *opaque, void *payload)
+{
+ RedWorkerMessageDisplayConnect *msg = payload;
+ RedWorker *worker = opaque;
+ RedsStream *stream = msg->stream;
+ RedClient *client = msg->client;
+ int migration = msg->migration;
+
+ red_printf("connect");
+ handle_new_display_channel(worker, client, stream, migration);
+}
+
+void handle_dev_display_disconnect(void *opaque, void *payload)
+{
+ RedWorkerMessageDisplayDisconnect *msg = payload;
+ RedChannelClient *rcc = msg->rcc;
+
+ red_printf("disconnect display client");
+ ASSERT(rcc);
+ display_channel_client_disconnect(rcc);
+}
+
+void handle_dev_display_migrate(void *opaque, void *payload)
+{
+ RedWorkerMessageDisplayMigrate *msg = payload;
+ RedWorker *worker = opaque;
+
+ RedChannelClient *rcc = msg->rcc;
+ red_printf("migrate display client");
+ ASSERT(rcc);
+ red_migrate_display(worker, rcc);
+}
+
+/* TODO: special, perhaps use another dispatcher? */
+void handle_dev_cursor_channel_create(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+ RedChannel *red_channel;
+
+ // TODO: handle seemless migration. Temp, setting migrate to FALSE
+ ensure_cursor_channel_created(worker, FALSE);
+ red_channel = &worker->cursor_channel->common.base;
+ send_data(worker->channel, &red_channel, sizeof(RedChannel *));
+}
+
+void handle_dev_cursor_connect(void *opaque, void *payload)
+{
+ RedWorkerMessageCursorConnect *msg = payload;
+ RedWorker *worker = opaque;
+ RedsStream *stream = msg->stream;
+ RedClient *client = msg->client;
+ int migration = msg->migration;
+
+ red_printf("cursor connect");
+ red_connect_cursor(worker, client, stream, migration);
+}
+
+void handle_dev_cursor_disconnect(void *opaque, void *payload)
+{
+ RedWorkerMessageCursorDisconnect *msg = payload;
+ RedChannelClient *rcc = msg->rcc;
+
+ red_printf("disconnect cursor client");
+ ASSERT(rcc);
+ cursor_channel_client_disconnect(rcc);
+}
+
+void handle_dev_cursor_migrate(void *opaque, void *payload)
+{
+ RedWorkerMessageCursorMigrate *msg = payload;
+ RedWorker *worker = opaque;
+ RedChannelClient *rcc = msg->rcc;
+
+ red_printf("migrate cursor client");
+ ASSERT(rcc);
+ red_migrate_cursor(worker, rcc);
+}
+
+void handle_dev_set_compression(void *opaque, void *payload)
+{
+ RedWorkerMessageSetCompression *msg = payload;
+ RedWorker *worker = opaque;
+
+ worker->image_compression = msg->image_compression;
+ switch (worker->image_compression) {
+ case SPICE_IMAGE_COMPRESS_AUTO_LZ:
+ red_printf("ic auto_lz");
break;
- }
- case RED_WORKER_MESSAGE_START:
- red_printf("start");
- handle_dev_start(worker);
+ case SPICE_IMAGE_COMPRESS_AUTO_GLZ:
+ red_printf("ic auto_glz");
break;
- case RED_WORKER_MESSAGE_DISPLAY_MIGRATE: {
- RedChannelClient *rcc;
- red_printf("migrate display client");
- receive_data(worker->channel, &rcc, sizeof(RedChannelClient *));
- ASSERT(rcc);
- red_migrate_display(worker, rcc);
+ case SPICE_IMAGE_COMPRESS_QUIC:
+ red_printf("ic quic");
break;
- }
- case RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE: {
- RedChannel *red_channel;
- // TODO: handle seemless migration. Temp, setting migrate to FALSE
- ensure_cursor_channel_created(worker, FALSE);
- red_channel = &worker->cursor_channel->common.base;
- send_data(worker->channel, &red_channel, sizeof(RedChannel *));
+ case SPICE_IMAGE_COMPRESS_LZ:
+ red_printf("ic lz");
break;
- }
- case RED_WORKER_MESSAGE_CURSOR_CONNECT: {
- RedsStream *stream;
- RedClient *client;
- int migrate;
-
- red_printf("cursor connect");
- receive_data(worker->channel, &client, sizeof(RedClient *));
- receive_data(worker->channel, &stream, sizeof(RedsStream *));
- receive_data(worker->channel, &migrate, sizeof(int));
- red_connect_cursor(worker, client, stream, migrate);
+ case SPICE_IMAGE_COMPRESS_GLZ:
+ red_printf("ic glz");
break;
- }
- case RED_WORKER_MESSAGE_CURSOR_DISCONNECT: {
- RedChannelClient *rcc;
-
- red_printf("disconnect cursor client");
- receive_data(worker->channel, &rcc, sizeof(RedChannelClient *));
- ASSERT(rcc);
- cursor_channel_client_disconnect(rcc);
+ case SPICE_IMAGE_COMPRESS_OFF:
+ red_printf("ic off");
break;
+ default:
+ red_printf("ic invalid");
}
- case RED_WORKER_MESSAGE_CURSOR_MIGRATE: {
- RedChannelClient *rcc;
- red_printf("migrate cursor client");
- receive_data(worker->channel, &rcc, sizeof(RedChannelClient *));
- ASSERT(rcc);
- red_migrate_cursor(worker, rcc);
- break;
+#ifdef COMPRESS_STAT
+ print_compress_stats(worker->display_channel);
+ if (worker->display_channel) {
+ stat_reset(&worker->display_channel->quic_stat);
+ stat_reset(&worker->display_channel->lz_stat);
+ stat_reset(&worker->display_channel->glz_stat);
+ stat_reset(&worker->display_channel->jpeg_stat);
+ stat_reset(&worker->display_channel->zlib_glz_stat);
+ stat_reset(&worker->display_channel->jpeg_alpha_stat);
}
- case RED_WORKER_MESSAGE_SET_COMPRESSION:
- receive_data(worker->channel, &worker->image_compression,
- sizeof(spice_image_compression_t));
- switch (worker->image_compression) {
- case SPICE_IMAGE_COMPRESS_AUTO_LZ:
- red_printf("ic auto_lz");
- break;
- case SPICE_IMAGE_COMPRESS_AUTO_GLZ:
- red_printf("ic auto_glz");
+#endif
+}
+
+void handle_dev_set_streaming_video(void *opaque, void *payload)
+{
+ RedWorkerMessageSetStreamingVideo *msg = payload;
+ RedWorker *worker = opaque;
+
+ worker->streaming_video = msg->streaming_video;
+ ASSERT(worker->streaming_video != STREAM_VIDEO_INVALID);
+ switch(worker->streaming_video) {
+ case STREAM_VIDEO_ALL:
+ red_printf("sv all");
break;
- case SPICE_IMAGE_COMPRESS_QUIC:
- red_printf("ic quic");
+ case STREAM_VIDEO_FILTER:
+ red_printf("sv filter");
break;
- case SPICE_IMAGE_COMPRESS_LZ:
- red_printf("ic lz");
+ case STREAM_VIDEO_OFF:
+ red_printf("sv off");
break;
- case SPICE_IMAGE_COMPRESS_GLZ:
- red_printf("ic glz");
+ default:
+ red_printf("sv invalid");
+ }
+}
+
+void handle_dev_set_mouse_mode(void *opaque, void *payload)
+{
+ RedWorkerMessageSetMouseMode *msg = payload;
+ RedWorker *worker = opaque;
+
+ worker->mouse_mode = msg->mode;
+ red_printf("mouse mode %u", worker->mouse_mode);
+}
+
+void handle_dev_add_memslot_async(void *opaque, void *payload)
+{
+ RedWorkerMessageAddMemslotAsync *msg = payload;
+ RedWorker *worker = opaque;
+
+ dev_add_memslot(worker, msg->mem_slot);
+ red_dispatcher_async_complete(worker->dispatcher, msg->cmd);
+}
+
+void handle_dev_reset_memslots(void *opaque, void *payload)
+{
+ RedWorker *worker = opaque;
+
+ red_memslot_info_reset(&worker->mem_slots);
+}
+
+void handle_dev_loadvm_commands(void *opaque, void *payload)
+{
+ RedWorkerMessageLoadvmCommands *msg = payload;
+ RedWorker *worker = opaque;
+ uint32_t i;
+ RedCursorCmd *cursor_cmd;
+ RedSurfaceCmd *surface_cmd;
+ uint32_t count = msg->count;
+ QXLCommandExt *ext = msg->ext;
+
+ red_printf("loadvm_commands");
+ for (i = 0 ; i < count ; ++i) {
+ switch (ext[i].cmd.type) {
+ case QXL_CMD_CURSOR:
+ cursor_cmd = spice_new0(RedCursorCmd, 1);
+ red_get_cursor_cmd(&worker->mem_slots, ext[i].group_id,
+ cursor_cmd, ext[i].cmd.data);
+ qxl_process_cursor(worker, cursor_cmd, ext[i].group_id);
break;
- case SPICE_IMAGE_COMPRESS_OFF:
- red_printf("ic off");
+ case QXL_CMD_SURFACE:
+ surface_cmd = spice_new0(RedSurfaceCmd, 1);
+ red_get_surface_cmd(&worker->mem_slots, ext[i].group_id,
+ surface_cmd, ext[i].cmd.data);
+ red_process_surface(worker, surface_cmd, ext[i].group_id, TRUE);
break;
default:
- red_printf("ic invalid");
- }
-#ifdef COMPRESS_STAT
- print_compress_stats(worker->display_channel);
- if (worker->display_channel) {
- stat_reset(&worker->display_channel->quic_stat);
- stat_reset(&worker->display_channel->lz_stat);
- stat_reset(&worker->display_channel->glz_stat);
- stat_reset(&worker->display_channel->jpeg_stat);
- stat_reset(&worker->display_channel->zlib_glz_stat);
- stat_reset(&worker->display_channel->jpeg_alpha_stat);
- }
-#endif
- break;
- case RED_WORKER_MESSAGE_SET_STREAMING_VIDEO:
- receive_data(worker->channel, &worker->streaming_video, sizeof(uint32_t));
- ASSERT(worker->streaming_video != STREAM_VIDEO_INVALID);
- switch(worker->streaming_video) {
- case STREAM_VIDEO_ALL:
- red_printf("sv all");
- break;
- case STREAM_VIDEO_FILTER:
- red_printf("sv filter");
- break;
- case STREAM_VIDEO_OFF:
- red_printf("sv off");
- break;
- default:
- red_printf("sv invalid");
- }
- break;
- case RED_WORKER_MESSAGE_SET_MOUSE_MODE:
- receive_data(worker->channel, &worker->mouse_mode, sizeof(uint32_t));
- red_printf("mouse mode %u", worker->mouse_mode);
- break;
- case RED_WORKER_MESSAGE_ADD_MEMSLOT_ASYNC:
- case RED_WORKER_MESSAGE_ADD_MEMSLOT:
- handle_dev_add_memslot(worker);
- break;
- case RED_WORKER_MESSAGE_DEL_MEMSLOT:
- handle_dev_del_memslot(worker);
- break;
- case RED_WORKER_MESSAGE_RESET_MEMSLOTS:
- red_memslot_info_reset(&worker->mem_slots);
- break;
- case RED_WORKER_MESSAGE_LOADVM_COMMANDS: {
- uint32_t count;
- QXLCommandExt ext;
- RedCursorCmd *cursor_cmd;
- RedSurfaceCmd *surface_cmd;
-
- red_printf("loadvm_commands");
- receive_data(worker->channel, &count, sizeof(uint32_t));
- while (count > 0) {
- receive_data(worker->channel, &ext, sizeof(QXLCommandExt));
- switch (ext.cmd.type) {
- case QXL_CMD_CURSOR:
- cursor_cmd = spice_new0(RedCursorCmd, 1);
- red_get_cursor_cmd(&worker->mem_slots, ext.group_id,
- cursor_cmd, ext.cmd.data);
- qxl_process_cursor(worker, cursor_cmd, ext.group_id);
- break;
- case QXL_CMD_SURFACE:
- surface_cmd = spice_new0(RedSurfaceCmd, 1);
- red_get_surface_cmd(&worker->mem_slots, ext.group_id,
- surface_cmd, ext.cmd.data);
- red_process_surface(worker, surface_cmd, ext.group_id, TRUE);
- break;
- default:
- red_printf("unhandled loadvm command type (%d)", ext.cmd.type);
- break;
- }
- count--;
+ red_printf("unhandled loadvm command type (%d)", ext[i].cmd.type);
+ break;
}
- break;
- }
- case RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC:
- handle_dev_flush_surfaces(worker);
- break;
- default:
- red_error("message error");
- }
- if (call_async_complete) {
- red_dispatcher_async_complete(worker->dispatcher, cmd);
- }
- if (write_ready) {
- message = RED_WORKER_MESSAGE_READY;
- write_message(worker->channel, &message);
}
}
+static void handle_dev_input(EventListener *listener, uint32_t events)
+{
+ RedWorker *worker = SPICE_CONTAINEROF(listener, RedWorker, dev_listener);
+
+ red_dispatcher_handle_read(worker->dispatcher);
+}
+
static void handle_dev_free(EventListener *ctx)
{
free(ctx);
@@ -10689,6 +10744,7 @@ static void red_init(RedWorker *worker, WorkerInitData *init_data)
memset(worker, 0, sizeof(RedWorker));
worker->dispatcher = init_data->dispatcher;
+ red_dispatcher_set_dispatcher_opaque(worker->dispatcher, worker);
worker->qxl = init_data->qxl;
worker->id = init_data->id;
worker->channel = init_data->channel;
diff --git a/server/red_worker.h b/server/red_worker.h
index 26c43ad..d7a2f70 100644
--- a/server/red_worker.h
+++ b/server/red_worker.h
@@ -84,6 +84,8 @@ enum {
RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
+
+ RED_WORKER_MESSAGE_COUNT // LAST
};
typedef uint32_t RedWorkerMessage;
--
1.7.7
More information about the Spice-devel
mailing list