server: remove dispatching creation of worker channels

Also get rid of pretty bad xread/xwrite macros.

6 files changed, 47 insertions, 133 deletions

diff --git a/server/dispatcher.c b/server/dispatcher.c
index 1f4c68f6..cc34d2d2 100644
--- a/server/dispatcher.c
+++ b/server/dispatcher.c
@@ -202,12 +202,13 @@ unlock:
 
 uint32_t dispatcher_read_message(Dispatcher *dispatcher)
 {
-    uint32_t message;
+    uint32_t message = 0;
 
     spice_return_val_if_fail(dispatcher, 0);
     spice_return_val_if_fail(dispatcher->send_fd != -1, 0);
 
-    xread(dispatcher->send_fd, &message, sizeof(message));
+    if (read_safe(dispatcher->send_fd, (uint8_t*)&message, sizeof(message), 1) == -1)
+        spice_warn_if_reached();
 
     return message;
 }
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index 31fafccb..0e124877 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -1003,35 +1003,10 @@ void red_dispatcher_async_complete(struct RedDispatcher *dispatcher,
     free(async_command);
 }
 
-static RedChannel *red_dispatcher_display_channel_create(RedDispatcher *dispatcher)
-{
-    RedWorkerMessageDisplayChannelCreate payload;
-    RedChannel *display_channel;
-
-    dispatcher_send_message(&dispatcher->dispatcher,
-                            RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
-                            &payload);
-    xread(dispatcher->dispatcher.send_fd, &display_channel, sizeof(RedChannel *));
-    return display_channel;
-}
-
-static RedChannel *red_dispatcher_cursor_channel_create(RedDispatcher *dispatcher)
-{
-    RedWorkerMessageCursorChannelCreate payload;
-    RedChannel *cursor_channel;
-
-    dispatcher_send_message(&dispatcher->dispatcher,
-                            RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
-                            &payload);
-    xread(dispatcher->dispatcher.send_fd, &cursor_channel, sizeof(RedChannel *));
-    return cursor_channel;
-}
-
 RedDispatcher *red_dispatcher_new(QXLInstance *qxl)
 {
     RedDispatcher *red_dispatcher;
-    RedChannel *display_channel;
-    RedChannel *cursor_channel;
+    RedChannel *channel;
     ClientCbs client_cbs = { NULL, };
 
     spice_return_val_if_fail(qxl != NULL, NULL);
@@ -1073,33 +1048,28 @@ RedDispatcher *red_dispatcher_new(QXLInstance *qxl)
 
     // TODO: reference and free
     RedWorker *worker = red_worker_new(qxl, red_dispatcher);
-    red_worker_run(worker);
-
-    num_active_workers = 1;
 
-    display_channel = red_dispatcher_display_channel_create(red_dispatcher);
-
-    if (display_channel) {
-        client_cbs.connect = red_dispatcher_set_display_peer;
-        client_cbs.disconnect = red_dispatcher_disconnect_display_peer;
-        client_cbs.migrate = red_dispatcher_display_migrate;
-        red_channel_register_client_cbs(display_channel, &client_cbs);
-        red_channel_set_data(display_channel, red_dispatcher);
-        red_channel_set_cap(display_channel, SPICE_DISPLAY_CAP_MONITORS_CONFIG);
-        red_channel_set_cap(display_channel, SPICE_DISPLAY_CAP_STREAM_REPORT);
-        reds_register_channel(display_channel);
-    }
-
-    cursor_channel = red_dispatcher_cursor_channel_create(red_dispatcher);
+    // TODO: move to their respective channel files
+    channel = red_worker_get_cursor_channel(worker);
+    client_cbs.connect = red_dispatcher_set_cursor_peer;
+    client_cbs.disconnect = red_dispatcher_disconnect_cursor_peer;
+    client_cbs.migrate = red_dispatcher_cursor_migrate;
+    red_channel_register_client_cbs(channel, &client_cbs);
+    red_channel_set_data(channel, red_dispatcher);
+    reds_register_channel(channel);
+
+    channel = red_worker_get_display_channel(worker);
+    client_cbs.connect = red_dispatcher_set_display_peer;
+    client_cbs.disconnect = red_dispatcher_disconnect_display_peer;
+    client_cbs.migrate = red_dispatcher_display_migrate;
+    red_channel_register_client_cbs(channel, &client_cbs);
+    red_channel_set_data(channel, red_dispatcher);
+    red_channel_set_cap(channel, SPICE_DISPLAY_CAP_MONITORS_CONFIG);
+    red_channel_set_cap(channel, SPICE_DISPLAY_CAP_STREAM_REPORT);
+    reds_register_channel(channel);
 
-    if (cursor_channel) {
-        client_cbs.connect = red_dispatcher_set_cursor_peer;
-        client_cbs.disconnect = red_dispatcher_disconnect_cursor_peer;
-        client_cbs.migrate = red_dispatcher_cursor_migrate;
-        red_channel_register_client_cbs(cursor_channel, &client_cbs);
-        red_channel_set_data(cursor_channel, red_dispatcher);
-        reds_register_channel(cursor_channel);
-    }
+    red_worker_run(worker);
+    num_active_workers = 1;
 
     qxl->st->dispatcher = red_dispatcher;
     red_dispatcher->next = dispatchers;
diff --git a/server/red_dispatcher.h b/server/red_dispatcher.h
index 93925417..1ca41011 100644
--- a/server/red_dispatcher.h
+++ b/server/red_dispatcher.h
@@ -85,9 +85,6 @@ enum {
     /* suspend/windows resolution change command */
     RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC,
 
-    RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
-    RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
-
     RED_WORKER_MESSAGE_MONITORS_CONFIG_ASYNC,
     RED_WORKER_MESSAGE_DRIVER_UNLOAD,
 
diff --git a/server/red_worker.c b/server/red_worker.c
index e36e4631..3301869c 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -612,7 +612,6 @@ typedef struct RedWorker {
     GMainContext *main_context;
     QXLInstance *qxl;
     RedDispatcher *red_dispatcher;
-    int dispatcher_reply_fd;
     int running;
     gint timeout;
 
@@ -10898,23 +10897,6 @@ void handle_dev_create_primary_surface_async(void *opaque, uint32_t message_type
     dev_create_primary_surface(worker, msg->surface_id, msg->surface);
 }
 
-/* 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, uint32_t message_type, void *payload)
-{
-    RedWorker *worker = opaque;
-
-    RedChannel *red_channel;
-    // TODO: handle seemless migration. Temp, setting migrate to FALSE
-    display_channel_create(worker, FALSE);
-    red_channel = &worker->display_channel->common.base;
-    xwrite(worker->dispatcher_reply_fd, &red_channel, sizeof(RedChannel *));
-}
-
 void handle_dev_display_connect(void *opaque, uint32_t message_type, void *payload)
 {
     RedWorkerMessageDisplayConnect *msg = payload;
@@ -10989,21 +10971,6 @@ static void handle_dev_monitors_config_async(void *opaque,
 }
 
 /* TODO: special, perhaps use another dispatcher? */
-void handle_dev_cursor_channel_create(void *opaque, uint32_t message_type, void *payload)
-{
-    RedWorker *worker = opaque;
-    RedChannel *red_channel;
-
-    if (!worker->cursor_channel) {
-        worker->cursor_channel = cursor_channel_new(worker);
-    } else {
-        spice_warning("cursor channel already created");
-    }
-
-    red_channel = RED_CHANNEL(worker->cursor_channel);
-    xwrite(worker->dispatcher_reply_fd, &red_channel, sizeof(RedChannel *));
-}
-
 void handle_dev_cursor_connect(void *opaque, uint32_t message_type, void *payload)
 {
     RedWorkerMessageCursorConnect *msg = payload;
@@ -11353,16 +11320,6 @@ static void worker_dispatcher_register(RedWorker *worker, Dispatcher *dispatcher
                                 sizeof(RedWorkerMessageSetMouseMode),
                                 DISPATCHER_NONE);
     dispatcher_register_handler(dispatcher,
-                                RED_WORKER_MESSAGE_DISPLAY_CHANNEL_CREATE,
-                                handle_dev_display_channel_create,
-                                sizeof(RedWorkerMessageDisplayChannelCreate),
-                                DISPATCHER_NONE);
-    dispatcher_register_handler(dispatcher,
-                                RED_WORKER_MESSAGE_CURSOR_CHANNEL_CREATE,
-                                handle_dev_cursor_channel_create,
-                                sizeof(RedWorkerMessageCursorChannelCreate),
-                                DISPATCHER_NONE);
-    dispatcher_register_handler(dispatcher,
                                 RED_WORKER_MESSAGE_DESTROY_SURFACE_WAIT,
                                 handle_dev_destroy_surface_wait,
                                 sizeof(RedWorkerMessageDestroySurfaceWait),
@@ -11484,7 +11441,6 @@ RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
 
     worker->red_dispatcher = red_dispatcher;
     worker->qxl = qxl;
-    worker->dispatcher_reply_fd = dispatcher_get_recv_fd(dispatcher);
     spice_assert(num_renderers > 0);
     worker->num_renderers = num_renderers;
     memcpy(worker->renderers, renderers, sizeof(worker->renderers));
@@ -11535,6 +11491,10 @@ RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
     red_init_zlib(worker);
     worker->timeout = -1;
 
+    worker->cursor_channel = cursor_channel_new(worker);
+    // TODO: handle seemless migration. Temp, setting migrate to FALSE
+    display_channel_create(worker, FALSE);
+
     return worker;
 }
 
@@ -11550,6 +11510,9 @@ SPICE_GNUC_NORETURN static void *red_worker_main(void *arg)
         spice_warning("getcpuclockid failed");
     }
 
+    RED_CHANNEL(worker->cursor_channel)->thread_id = pthread_self();
+    RED_CHANNEL(worker->display_channel)->thread_id = pthread_self();
+
     GMainLoop *loop = g_main_loop_new(worker->main_context, FALSE);
     g_main_loop_run(loop);
     g_main_loop_unref(loop);
@@ -11579,3 +11542,17 @@ bool red_worker_run(RedWorker *worker)
 
     return r == 0;
 }
+
+RedChannel* red_worker_get_cursor_channel(RedWorker *worker)
+{
+    spice_return_val_if_fail(worker, NULL);
+
+    return RED_CHANNEL(worker->cursor_channel);
+}
+
+RedChannel* red_worker_get_display_channel(RedWorker *worker)
+{
+    spice_return_val_if_fail(worker, NULL);
+
+    return RED_CHANNEL(worker->display_channel);
+}
diff --git a/server/red_worker.h b/server/red_worker.h
index 2efbde5e..23b9c7f1 100644
--- a/server/red_worker.h
+++ b/server/red_worker.h
@@ -110,6 +110,8 @@ static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
 RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher);
 bool       red_worker_run(RedWorker *worker);
 QXLInstance* red_worker_get_qxl(RedWorker *worker);
+RedChannel* red_worker_get_cursor_channel(RedWorker *worker);
+RedChannel* red_worker_get_display_channel(RedWorker *worker);
 
 RedChannel *red_worker_new_channel(RedWorker *worker, int size,
                                    const char *name,
diff --git a/server/spice_server_utils.h b/server/spice_server_utils.h
index 96ffc9e4..ffc1a99c 100644
--- a/server/spice_server_utils.h
+++ b/server/spice_server_utils.h
@@ -24,37 +24,4 @@ static inline int test_bit(int index, uint32_t val)
 {
     return val & (1u << index);
 }
-
-static inline void xwrite(int fd, void *in_buf, int n)
-{
-    uint8_t *buf = in_buf;
-    do {
-        int now;
-        if ((now = write(fd, buf, n)) == -1) {
-            if (errno == EINTR) {
-                continue;
-            }
-            spice_error("%s", strerror(errno));
-        }
-        buf += now;
-        n -= now;
-    } while (n);
-}
-
-static inline void xread(int fd, void *in_buf, int n)
-{
-    uint8_t *buf = in_buf;
-    do {
-        int now;
-        if ((now = read(fd, buf, n)) == -1) {
-            if (errno == EINTR) {
-                continue;
-            }
-            spice_error("%s", strerror(errno));
-        }
-        buf += now;
-        n -= now;
-    } while (n);
-}
-
 #endif