[Spice-devel] [PATCH 06/14] server: move some cursor code to cursor-channel.c
Frediano Ziglio
fziglio at redhat.com
Mon Oct 26 04:01:11 PDT 2015
>
> From: Marc-André Lureau <marcandre.lureau at gmail.com>
>
> Also fix warning due to unexpected pipe item type
>
> The specific item type that was not being handled was
> PIPE_ITEM_TYPE_INVAL_ONE (#102). This item type is used by the cursor
> channel, but the analogous item for the display channel is
> PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE. Use this value instead.
>
> The exact warning follows:
>
> (/usr/bin/qemu-kvm:24458): Spice-Warning **:
> ../../server/dcc-send.c:2442:dcc_send_item: should not be reached
> (/usr/bin/qemu-kvm:24458): Spice-CRITICAL **:
> ../../server/dcc.c:1595:release_item_before_push: invalid item type
>
> Author: Marc-André Lureau <marcandre.lureau at gmail.com>
> Date: Thu Feb 27 19:38:58 2014 +0200
> ---
> server/Makefile.am | 3 +-
> server/cache_item.tmpl.c | 4 +-
> server/cursor-channel.c | 489 ++++++++++++++++++++++++++++++
> server/cursor-channel.h | 103 +++++++
> server/cursor_channel.h | 62 ----
> server/red_dispatcher.c | 1 +
> server/red_worker.c | 751
> ++++++-----------------------------------------
> server/red_worker.h | 71 +++++
> 8 files changed, 759 insertions(+), 725 deletions(-)
> create mode 100644 server/cursor-channel.c
> create mode 100644 server/cursor-channel.h
> delete mode 100644 server/cursor_channel.h
>
> diff --git a/server/Makefile.am b/server/Makefile.am
> index 013188b..43bbf6f 100644
> --- a/server/Makefile.am
> +++ b/server/Makefile.am
> @@ -108,7 +108,8 @@ libspice_server_la_SOURCES = \
> red_worker.c \
> red_worker.h \
> display-channel.h \
> - cursor_channel.h \
> + cursor-channel.c \
> + cursor-channel.h \
> reds.c \
> reds.h \
> reds-private.h \
> diff --git a/server/cache_item.tmpl.c b/server/cache_item.tmpl.c
> index dc314c0..ad2b579 100644
> --- a/server/cache_item.tmpl.c
> +++ b/server/cache_item.tmpl.c
> @@ -21,6 +21,7 @@
> #define CACHE_HASH_KEY CURSOR_CACHE_HASH_KEY
> #define CACHE_HASH_SIZE CURSOR_CACHE_HASH_SIZE
> #define CACHE_INVAL_TYPE SPICE_MSG_CURSOR_INVAL_ONE
> +#define PIPE_ITEM_TYPE PIPE_ITEM_TYPE_INVAL_ONE
> #define FUNC_NAME(name) red_cursor_cache_##name
> #define VAR_NAME(name) cursor_cache_##name
> #define CHANNEL CursorChannel
> @@ -32,6 +33,7 @@
> #define CACHE_HASH_KEY PALETTE_CACHE_HASH_KEY
> #define CACHE_HASH_SIZE PALETTE_CACHE_HASH_SIZE
> #define CACHE_INVAL_TYPE SPICE_MSG_DISPLAY_INVAL_PALETTE
> +#define PIPE_ITEM_TYPE PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE
> #define FUNC_NAME(name) red_palette_cache_##name
> #define VAR_NAME(name) palette_cache_##name
> #define CHANNEL DisplayChannel
> @@ -78,7 +80,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT
> *channel_client, CacheItem *item)
> channel_client->VAR_NAME(items)--;
> channel_client->VAR_NAME(available) += item->size;
>
> - red_channel_pipe_item_init(&channel->common.base, &item->u.pipe_data,
> PIPE_ITEM_TYPE_INVAL_ONE);
> + red_channel_pipe_item_init(&channel->common.base, &item->u.pipe_data,
> PIPE_ITEM_TYPE);
> red_channel_client_pipe_add_tail(&channel_client->common.base,
> &item->u.pipe_data); // for now
> }
>
> diff --git a/server/cursor-channel.c b/server/cursor-channel.c
> new file mode 100644
> index 0000000..adf7d78
> --- /dev/null
> +++ b/server/cursor-channel.c
> @@ -0,0 +1,489 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> + Copyright (C) 2009 Red Hat, Inc.
> +
> + This library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + This library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with this library; if not, see
> <http://www.gnu.org/licenses/>.
> +*/
> +#include <glib.h>
> +#include "common/generated_server_marshallers.h"
> +#include "cursor-channel.h"
> +
> +#define RCC_TO_CCC(rcc) SPICE_CONTAINEROF((rcc), CursorChannelClient,
> common.base)
> +
> +#define CLIENT_CURSOR_CACHE
> +#include "cache_item.tmpl.c"
> +#undef CLIENT_CURSOR_CACHE
> +
> +CursorItem *cursor_item_new(QXLInstance *qxl, RedCursorCmd *cmd, uint32_t
> group_id)
> +{
> + CursorItem *cursor_item;
> +
> + spice_return_val_if_fail(cmd != NULL, NULL);
> +
> + cursor_item = g_slice_new0(CursorItem);
> + cursor_item->qxl = qxl;
> + cursor_item->refs = 1;
> + cursor_item->group_id = group_id;
> + cursor_item->red_cursor = cmd;
> +
> + return cursor_item;
> +}
> +
> +CursorItem *cursor_item_ref(CursorItem *item)
> +{
> + spice_return_val_if_fail(item != NULL, NULL);
> + spice_return_val_if_fail(item->refs > 0, NULL);
> +
> + item->refs++;
> +
> + return item;
> +}
> +
> +void cursor_item_unref(CursorItem *item)
> +{
> + QXLReleaseInfoExt release_info_ext;
> + RedCursorCmd *cursor_cmd;
> +
> + spice_return_if_fail(item != NULL);
> +
> + if (--item->refs)
> + return;
> +
> + cursor_cmd = item->red_cursor;
> + release_info_ext.group_id = item->group_id;
> + release_info_ext.info = cursor_cmd->release_info;
> + item->qxl->st->qif->release_resource(item->qxl, release_info_ext);
> + red_put_cursor_cmd(cursor_cmd);
> + free(cursor_cmd);
> +
> + g_slice_free(CursorItem, item);
> +
> +}
> +
> +static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
> +{
> + if (cursor->item)
> + cursor_item_unref(cursor->item);
> +
> + cursor->item = item ? cursor_item_ref(item) : NULL;
> +}
> +
> +#ifdef DEBUG_CURSORS
> +static int _cursor_count = 0;
> +#endif
> +
> +static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int
> num)
> +{
> + CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
> +
> + red_channel_pipe_item_init(rcc->channel, &item->base,
> PIPE_ITEM_TYPE_CURSOR);
> + item->refs = 1;
> + item->cursor_item = data;
> + item->cursor_item->refs++;
> + return &item->base;
> +}
> +
> +typedef struct {
> + void *data;
> + uint32_t size;
> +} AddBufInfo;
> +
> +static void add_buf_from_info(SpiceMarshaller *m, AddBufInfo *info)
> +{
> + if (info->data) {
> + spice_marshaller_add_ref(m, info->data, info->size);
> + }
> +}
> +
> +static void cursor_fill(CursorChannelClient *ccc, SpiceCursor *red_cursor,
> + CursorItem *cursor, AddBufInfo *addbuf)
> +{
> + RedCursorCmd *cursor_cmd;
> + addbuf->data = NULL;
> +
> + if (!cursor) {
> + red_cursor->flags = SPICE_CURSOR_FLAGS_NONE;
> + return;
> + }
> +
> + cursor_cmd = cursor->red_cursor;
> + *red_cursor = cursor_cmd->u.set.shape;
> +
> + if (red_cursor->header.unique) {
> + if (red_cursor_cache_find(ccc, red_cursor->header.unique)) {
> + red_cursor->flags |= SPICE_CURSOR_FLAGS_FROM_CACHE;
> + return;
> + }
> + if (red_cursor_cache_add(ccc, red_cursor->header.unique, 1)) {
> + red_cursor->flags |= SPICE_CURSOR_FLAGS_CACHE_ME;
> + }
> + }
> +
> + if (red_cursor->data_size) {
> + addbuf->data = red_cursor->data;
> + addbuf->size = red_cursor->data_size;
> + }
> +}
> +
> +
> +static void red_reset_cursor_cache(RedChannelClient *rcc)
> +{
> + red_cursor_cache_reset(RCC_TO_CCC(rcc), CLIENT_CURSOR_CACHE_SIZE);
> +}
> +
> +void cursor_channel_disconnect(CursorChannel *cursor)
> +{
> + RedChannel *channel = (RedChannel *)cursor;
> +
> + if (!channel || !red_channel_is_connected(channel)) {
> + return;
> + }
> +
> + /* TODO: use a class vdispose */
> + red_channel_apply_clients(channel, red_reset_cursor_cache);
> + red_channel_disconnect(channel);
> +}
> +
> +
> +static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem
> *pipe_item)
> +{
> + spice_return_if_fail(pipe_item);
> + spice_return_if_fail(pipe_item->refs > 0);
> +
> + if (--pipe_item->refs) {
> + return;
> + }
> +
> + spice_assert(!pipe_item_is_linked(&pipe_item->base));
> +
> + cursor_item_unref(pipe_item->cursor_item);
> + free(pipe_item);
> +}
> +
> +static void cursor_channel_client_on_disconnect(RedChannelClient *rcc)
> +{
> + if (!rcc) {
> + return;
> + }
> + red_reset_cursor_cache(rcc);
> +}
> +
> +// TODO: share code between before/after_push since most of the items need
> the same
> +// release
> +static void
> cursor_channel_client_release_item_before_push(CursorChannelClient *ccc,
> + PipeItem *item)
> +{
> + switch (item->type) {
> + case PIPE_ITEM_TYPE_CURSOR: {
> + CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item,
> CursorPipeItem, base);
> + put_cursor_pipe_item(ccc, cursor_pipe_item);
> + break;
> + }
> + case PIPE_ITEM_TYPE_INVAL_ONE:
> + case PIPE_ITEM_TYPE_VERB:
> + case PIPE_ITEM_TYPE_CURSOR_INIT:
> + case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
> + free(item);
> + break;
> + default:
> + spice_error("invalid pipe item type");
> + }
> +}
> +
> +static void
> cursor_channel_client_release_item_after_push(CursorChannelClient *ccc,
> + PipeItem *item)
> +{
> + switch (item->type) {
> + case PIPE_ITEM_TYPE_CURSOR: {
> + CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item,
> CursorPipeItem, base);
> + put_cursor_pipe_item(ccc, cursor_pipe_item);
> + break;
> + }
> + default:
> + spice_critical("invalid item type");
> + }
> +}
> +
> +static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller
> *base_marshaller,
> + PipeItem *pipe_item)
> +{
> + CursorChannel *cursor;
> + CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> + SpiceMsgCursorInit msg;
> + AddBufInfo info;
> +
> + spice_assert(rcc);
> + cursor = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
> +
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INIT, NULL);
> + msg.visible = cursor->cursor_visible;
> + msg.position = cursor->cursor_position;
> + msg.trail_length = cursor->cursor_trail_length;
> + msg.trail_frequency = cursor->cursor_trail_frequency;
> +
> + cursor_fill(ccc, &msg.cursor, cursor->item, &info);
> + spice_marshall_msg_cursor_init(base_marshaller, &msg);
> + add_buf_from_info(base_marshaller, &info);
> +}
> +
> +static void cursor_marshall(RedChannelClient *rcc,
> + SpiceMarshaller *m, CursorPipeItem
> *cursor_pipe_item)
> +{
> + CursorChannel *cursor = SPICE_CONTAINEROF(rcc->channel, CursorChannel,
> common.base);
> + CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> + CursorItem *item = cursor_pipe_item->cursor_item;
> + PipeItem *pipe_item = &cursor_pipe_item->base;
> + RedCursorCmd *cmd;
> +
> + spice_return_if_fail(cursor);
> +
> + cmd = item->red_cursor;
> + switch (cmd->type) {
> + case QXL_CURSOR_MOVE:
> + {
> + SpiceMsgCursorMove cursor_move;
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_MOVE,
> pipe_item);
> + cursor_move.position = cmd->u.position;
> + spice_marshall_msg_cursor_move(m, &cursor_move);
> + break;
> + }
> + case QXL_CURSOR_SET:
> + {
> + SpiceMsgCursorSet cursor_set;
> + AddBufInfo info;
> +
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_SET,
> pipe_item);
> + cursor_set.position = cmd->u.set.position;
> + cursor_set.visible = cursor->cursor_visible;
> +
> + cursor_fill(ccc, &cursor_set.cursor, item, &info);
> + spice_marshall_msg_cursor_set(m, &cursor_set);
> + add_buf_from_info(m, &info);
> + break;
> + }
> + case QXL_CURSOR_HIDE:
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_HIDE,
> pipe_item);
> + break;
> + case QXL_CURSOR_TRAIL:
> + {
> + SpiceMsgCursorTrail cursor_trail;
> +
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_TRAIL,
> pipe_item);
> + cursor_trail.length = cmd->u.trail.length;
> + cursor_trail.frequency = cmd->u.trail.frequency;
> + spice_marshall_msg_cursor_trail(m, &cursor_trail);
> + }
> + break;
> + default:
> + spice_error("bad cursor command %d", cmd->type);
> + }
> +}
> +
> +static inline void red_marshall_inval(RedChannelClient *rcc,
> + SpiceMarshaller *base_marshaller,
> CacheItem *cach_item)
> +{
> + SpiceMsgDisplayInvalOne inval_one;
> +
> + red_channel_client_init_send_data(rcc, cach_item->inval_type, NULL);
> + inval_one.id = *(uint64_t *)&cach_item->id;
> +
> + spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
> +}
> +
> +static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem
> *pipe_item)
> +{
> + SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> + CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> +
> + switch (pipe_item->type) {
> + case PIPE_ITEM_TYPE_CURSOR:
> + cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, CursorPipeItem,
> base));
> + break;
> + case PIPE_ITEM_TYPE_INVAL_ONE:
> + red_marshall_inval(rcc, m, (CacheItem *)pipe_item);
> + break;
> + case PIPE_ITEM_TYPE_VERB:
> + red_marshall_verb(rcc, (VerbItem*)pipe_item);
> + break;
> + case PIPE_ITEM_TYPE_CURSOR_INIT:
> + red_reset_cursor_cache(rcc);
> + red_marshall_cursor_init(rcc, m, pipe_item);
> + break;
> + case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
> + red_reset_cursor_cache(rcc);
> + red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INVAL_ALL,
> NULL);
> + break;
> + default:
> + spice_error("invalid pipe item type");
> + }
> +
> + cursor_channel_client_release_item_before_push(ccc, pipe_item);
> + red_channel_client_begin_send_message(rcc);
> +}
> +
> +static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
> +{
> + spice_return_val_if_fail(item, NULL);
> + spice_return_val_if_fail(item->refs > 0, NULL);
> +
> + item->refs++;
> + return item;
> +}
> +
> +
> +static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem
> *item)
> +{
> + CursorPipeItem *cursor_pipe_item;
> +
> + spice_return_if_fail(item);
> +
> + cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
> + /* TODO: refcnt at PipeItem instead ? */
> + cursor_pipe_item_ref(cursor_pipe_item);
> +}
> +
> +static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem
> *item, int item_pushed)
> +{
> + CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> +
> + spice_assert(item);
> +
> + if (item_pushed) {
> + cursor_channel_client_release_item_after_push(ccc, item);
> + } else {
> + spice_debug("not pushed (%d)", item->type);
> + cursor_channel_client_release_item_before_push(ccc, item);
> + }
> +}
> +
> +CursorChannel* cursor_channel_new(RedWorker *worker)
> +{
> + CursorChannel *cursor;
> + RedChannel *channel = NULL;
> + ChannelCbs cbs = {
> + .on_disconnect = cursor_channel_client_on_disconnect,
> + .send_item = cursor_channel_send_item,
> + .hold_item = cursor_channel_hold_pipe_item,
> + .release_item = cursor_channel_release_item
> + };
> +
> + spice_info("create cursor channel");
> + channel = red_worker_new_channel(worker, sizeof(CursorChannel),
> + SPICE_CHANNEL_CURSOR, 0,
> + &cbs,
> red_channel_client_handle_message);
> +
> + cursor = (CursorChannel *)channel;
> + cursor->cursor_visible = TRUE;
> + cursor->mouse_mode = SPICE_MOUSE_MODE_SERVER;
> +
> + return cursor;
> +}
> +
> +CursorChannelClient* cursor_channel_client_new(CursorChannel *cursor,
> RedClient *client, RedsStream *stream,
> + int mig_target,
> + uint32_t *common_caps, int
> num_common_caps,
> + uint32_t *caps, int num_caps)
> +{
> + spice_return_val_if_fail(cursor, NULL);
> + spice_return_val_if_fail(client, NULL);
> + spice_return_val_if_fail(stream, NULL);
> + spice_return_val_if_fail(!num_common_caps || common_caps, NULL);
> + spice_return_val_if_fail(!num_caps || caps, NULL);
> +
> + CursorChannelClient *ccc =
> + (CursorChannelClient*)common_channel_new_client(&cursor->common,
> +
> sizeof(CursorChannelClient),
> + client, stream,
> + mig_target,
> + FALSE,
> + common_caps,
> + num_common_caps,
> + caps,
> + num_caps);
> + spice_return_val_if_fail(ccc != NULL, NULL);
> +
> + ring_init(&ccc->cursor_cache_lru);
> + ccc->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE;
> +
> +
> + return ccc;
> +}
> +
> +void cursor_channel_process_cmd(CursorChannel *cursor, RedCursorCmd
> *cursor_cmd,
> + uint32_t group_id)
> +{
> + CursorItem *cursor_item;
> + int cursor_show = FALSE;
> +
> + spice_return_if_fail(cursor);
> + spice_return_if_fail(cursor_cmd);
> +
> + cursor_item = cursor_item_new(red_worker_get_qxl(cursor->common.worker),
> + cursor_cmd, group_id);
> +
> + switch (cursor_cmd->type) {
> + case QXL_CURSOR_SET:
> + cursor->cursor_visible = cursor_cmd->u.set.visible;
> + cursor_set_item(cursor, cursor_item);
> + break;
> + case QXL_CURSOR_MOVE:
> + cursor_show = !cursor->cursor_visible;
> + cursor->cursor_visible = TRUE;
> + cursor->cursor_position = cursor_cmd->u.position;
> + break;
> + case QXL_CURSOR_HIDE:
> + cursor->cursor_visible = FALSE;
> + break;
> + case QXL_CURSOR_TRAIL:
> + cursor->cursor_trail_length = cursor_cmd->u.trail.length;
> + cursor->cursor_trail_frequency = cursor_cmd->u.trail.frequency;
> + break;
> + default:
> + spice_warning("invalid cursor command %u", cursor_cmd->type);
> + return;
> + }
> +
> + if (cursor->mouse_mode == SPICE_MOUSE_MODE_SERVER
> + || cursor_cmd->type != QXL_CURSOR_MOVE
> + || cursor_show) {
> + red_channel_pipes_new_add(&cursor->common.base,
> + new_cursor_pipe_item, cursor_item);
> + }
> +
> + cursor_item_unref(cursor_item);
> +}
> +
> +void cursor_channel_reset(CursorChannel *cursor)
> +{
> + RedChannel *channel = (RedChannel *)cursor;
> +
> + spice_return_if_fail(cursor);
> +
> + cursor_set_item(cursor, NULL);
> + cursor->cursor_visible = TRUE;
> + cursor->cursor_position.x = cursor->cursor_position.y = 0;
> + cursor->cursor_trail_length = cursor->cursor_trail_frequency = 0;
> +
> + if (red_channel_is_connected(channel)) {
> + red_channel_pipes_add_type(&cursor->common.base,
> PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
> + if (!cursor->common.during_target_migrate) {
> + red_pipes_add_verb(&cursor->common.base,
> SPICE_MSG_CURSOR_RESET);
> + }
> + if (!red_channel_wait_all_sent(&cursor->common.base,
> + DISPLAY_CLIENT_TIMEOUT)) {
> + red_channel_apply_clients(&cursor->common.base,
> +
> red_channel_client_disconnect_if_pending_send);
> + }
> + }
> +}
> diff --git a/server/cursor-channel.h b/server/cursor-channel.h
> new file mode 100644
> index 0000000..e1ef4b6
> --- /dev/null
> +++ b/server/cursor-channel.h
> @@ -0,0 +1,103 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> + Copyright (C) 2009 Red Hat, Inc.
> +
> + This library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + This library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with this library; if not, see
> <http://www.gnu.org/licenses/>.
> +*/
> +#ifndef CURSOR_CHANNEL_H_
> +# define CURSOR_CHANNEL_H_
> +
> +#include "spice.h"
> +#include "reds.h"
> +#include "red_worker.h"
> +#include "red_parse_qxl.h"
> +#include "cache-item.h"
> +#include "stat.h"
> +
> +#define CLIENT_CURSOR_CACHE_SIZE 256
> +
> +#define CURSOR_CACHE_HASH_SHIFT 8
> +#define CURSOR_CACHE_HASH_SIZE (1 << CURSOR_CACHE_HASH_SHIFT)
> +#define CURSOR_CACHE_HASH_MASK (CURSOR_CACHE_HASH_SIZE - 1)
> +#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
> +
> +enum {
> + PIPE_ITEM_TYPE_CURSOR = PIPE_ITEM_TYPE_COMMON_LAST,
> + PIPE_ITEM_TYPE_CURSOR_INIT,
> + PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
> +};
> +
> +typedef struct CursorItem {
> + QXLInstance *qxl;
> + uint32_t group_id;
> + int refs;
> + RedCursorCmd *red_cursor;
> +} CursorItem;
> +
> +typedef struct CursorPipeItem {
> + PipeItem base;
> + CursorItem *cursor_item;
> + int refs;
> +} CursorPipeItem;
> +
> +typedef struct LocalCursor {
> + CursorItem base;
> + SpicePoint16 position;
> + uint32_t data_size;
> + SpiceCursor red_cursor;
> +} LocalCursor;
> +
> +typedef struct CursorChannelClient {
> + CommonChannelClient common;
> +
> + CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
> + Ring cursor_cache_lru;
> + long cursor_cache_available;
> + uint32_t cursor_cache_items;
> +} CursorChannelClient;
> +
> +typedef struct CursorChannel {
> + CommonChannel common; // Must be the first thing
> +
> + CursorItem *item;
> + int cursor_visible;
> + SpicePoint16 cursor_position;
> + uint16_t cursor_trail_length;
> + uint16_t cursor_trail_frequency;
> + uint32_t mouse_mode;
> +
> +#ifdef RED_STATISTICS
> + StatNodeRef stat;
> +#endif
> +} CursorChannel;
> +
> +G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
> +
> +CursorChannel* cursor_channel_new (RedWorker *worker);
> +void cursor_channel_disconnect (CursorChannel *cursor);
> +void cursor_channel_reset (CursorChannel *cursor);
> +void cursor_channel_process_cmd (CursorChannel *cursor,
> RedCursorCmd *cursor_cmd,
> + uint32_t group_id);
> +
> +CursorChannelClient* cursor_channel_client_new (CursorChannel *cursor,
> + RedClient *client,
> RedsStream *stream,
> + int mig_target,
> + uint32_t *common_caps, int
> num_common_caps,
> + uint32_t *caps, int
> num_caps);
> +
> +CursorItem* cursor_item_new (QXLInstance *qxl,
> RedCursorCmd *cmd, uint32_t group_id);
> +CursorItem* cursor_item_ref (CursorItem *cursor);
> +void cursor_item_unref (CursorItem *cursor);
> +
> +#endif /* CURSOR_CHANNEL_H_ */
> diff --git a/server/cursor_channel.h b/server/cursor_channel.h
> deleted file mode 100644
> index 0104988..0000000
> --- a/server/cursor_channel.h
> +++ /dev/null
> @@ -1,62 +0,0 @@
> -#ifndef CURSOR_CHANNEL_H_
> -# define CURSOR_CHANNEL_H_
> -
> -#include "red_worker.h"
> -#include "stat.h"
> -
> -#define CLIENT_CURSOR_CACHE_SIZE 256
> -
> -#define CURSOR_CACHE_HASH_SHIFT 8
> -#define CURSOR_CACHE_HASH_SIZE (1 << CURSOR_CACHE_HASH_SHIFT)
> -#define CURSOR_CACHE_HASH_MASK (CURSOR_CACHE_HASH_SIZE - 1)
> -#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
> -
> -typedef struct CursorItem {
> - uint32_t group_id;
> - int refs;
> - RedCursorCmd *red_cursor;
> -} CursorItem;
> -
> -typedef struct CursorPipeItem {
> - PipeItem base;
> - CursorItem *cursor_item;
> - int refs;
> -} CursorPipeItem;
> -
> -typedef struct LocalCursor {
> - CursorItem base;
> - SpicePoint16 position;
> - uint32_t data_size;
> - SpiceCursor red_cursor;
> -} LocalCursor;
> -
> -typedef struct CursorChannelClient {
> - CommonChannelClient common;
> -
> - CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
> - Ring cursor_cache_lru;
> - long cursor_cache_available;
> - uint32_t cursor_cache_items;
> -} CursorChannelClient;
> -
> -typedef struct CursorChannel {
> - CommonChannel common; // Must be the first thing
> -
> -#ifdef RED_STATISTICS
> - StatNodeRef stat;
> -#endif
> -} CursorChannel;
> -
> -typedef struct _CursorItem _CursorItem;
> -
> -struct _CursorItem {
> - union {
> - CursorItem cursor_item;
> - _CursorItem *next;
> - } u;
> -};
> -
> -G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
> -
> -
> -#endif /* CURSOR_CHANNEL_H_ */
> diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
> index 5e9b5bf..ecfef48 100644
> --- a/server/red_dispatcher.c
> +++ b/server/red_dispatcher.c
> @@ -160,6 +160,7 @@ static void red_dispatcher_set_cursor_peer(RedChannel
> *channel, RedClient *clien
> memcpy(payload.common_caps, common_caps,
> sizeof(uint32_t)*num_common_caps);
> memcpy(payload.caps, caps, sizeof(uint32_t)*num_caps);
>
> + /* TODO serialize it all, no dangling pointers */
> dispatcher_send_message(&dispatcher->dispatcher,
> RED_WORKER_MESSAGE_CURSOR_CONNECT,
> &payload);
> diff --git a/server/red_worker.c b/server/red_worker.c
> index 4b69a38..9741758 100644
> --- a/server/red_worker.c
> +++ b/server/red_worker.c
> @@ -94,7 +94,7 @@
> #include "spice_image_cache.h"
> #include "pixmap-cache.h"
> #include "display-channel.h"
> -#include "cursor_channel.h"
> +#include "cursor-channel.h"
>
> //#define COMPRESS_STAT
> //#define DUMP_BITMAP
> @@ -266,24 +266,15 @@ struct SpiceWatch {
> };
>
> enum {
> - BUF_TYPE_RAW = 1,
> -};
> -
> -enum {
> - PIPE_ITEM_TYPE_DRAW = PIPE_ITEM_TYPE_CHANNEL_BASE,
> - PIPE_ITEM_TYPE_INVAL_ONE,
> - PIPE_ITEM_TYPE_CURSOR,
> - PIPE_ITEM_TYPE_CURSOR_INIT,
> + PIPE_ITEM_TYPE_DRAW = PIPE_ITEM_TYPE_COMMON_LAST,
> PIPE_ITEM_TYPE_IMAGE,
> PIPE_ITEM_TYPE_STREAM_CREATE,
> PIPE_ITEM_TYPE_STREAM_CLIP,
> PIPE_ITEM_TYPE_STREAM_DESTROY,
> PIPE_ITEM_TYPE_UPGRADE,
> - PIPE_ITEM_TYPE_VERB,
> PIPE_ITEM_TYPE_MIGRATE_DATA,
> PIPE_ITEM_TYPE_PIXMAP_SYNC,
> PIPE_ITEM_TYPE_PIXMAP_RESET,
> - PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
> PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
> PIPE_ITEM_TYPE_CREATE_SURFACE,
> PIPE_ITEM_TYPE_DESTROY_SURFACE,
> @@ -291,11 +282,6 @@ enum {
> PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
> };
>
> -typedef struct VerbItem {
> - PipeItem base;
> - uint16_t verb;
> -} VerbItem;
> -
> #define MAX_LZ_ENCODERS MAX_CACHE_CLIENTS
>
> typedef struct SurfaceCreateItem {
> @@ -639,18 +625,9 @@ typedef struct RedWorker {
>
> uint32_t bits_unique;
>
> - CursorItem *cursor;
> - int cursor_visible;
> - SpicePoint16 cursor_position;
> - uint16_t cursor_trail_length;
> - uint16_t cursor_trail_frequency;
> -
> _Drawable drawables[NUM_DRAWABLES];
> _Drawable *free_drawables;
>
> - _CursorItem cursor_items[NUM_CURSORS];
> - _CursorItem *free_cursor_items;
> -
> RedMemSlotInfo mem_slots;
>
> ImageCache image_cache;
> @@ -659,8 +636,6 @@ typedef struct RedWorker {
> spice_wan_compression_t jpeg_state;
> spice_wan_compression_t zlib_glz_state;
>
> - uint32_t mouse_mode;
> -
> uint32_t streaming_video;
> Stream streams_buf[NUM_STREAMS];
> Stream *free_streams;
> @@ -737,7 +712,6 @@ static void red_draw_drawable(RedWorker *worker, Drawable
> *item);
> static void red_update_area(RedWorker *worker, const SpiceRect *area, int
> surface_id);
> static void red_update_area_till(RedWorker *worker, const SpiceRect *area,
> int surface_id,
> Drawable *last);
> -static void red_release_cursor(RedWorker *worker, CursorItem *cursor);
> static inline void release_drawable(RedWorker *worker, Drawable *item);
> static void red_display_release_stream(RedWorker *worker, StreamAgent
> *agent);
> static inline void red_detach_stream(RedWorker *worker, Stream *stream, int
> detach_sized);
> @@ -756,16 +730,11 @@ static ImageItem
> *red_add_surface_area_image(DisplayChannelClient *dcc, int surf
> static BitmapGradualType _get_bitmap_graduality_level(RedWorker *worker,
> SpiceBitmap *bitmap,
> uint32_t group_id);
> static inline int _stride_is_extra(SpiceBitmap *bitmap);
> -static void red_disconnect_cursor(RedChannel *channel);
> +
> static void
> display_channel_client_release_item_before_push(DisplayChannelClient *dcc,
> PipeItem *item);
> static void
> display_channel_client_release_item_after_push(DisplayChannelClient *dcc,
> PipeItem *item);
> -static void
> cursor_channel_client_release_item_before_push(CursorChannelClient *ccc,
> - PipeItem *item);
> -static void
> cursor_channel_client_release_item_after_push(CursorChannelClient *ccc,
> - PipeItem *item);
> -
> static void red_push_monitors_config(DisplayChannelClient *dcc);
>
> /*
> @@ -774,21 +743,6 @@ static void
> red_push_monitors_config(DisplayChannelClient *dcc);
> * given a channel, iterate over it's clients
> */
>
> -/* a generic safe for loop macro */
> -#define SAFE_FOREACH(link, next, cond, ring, data, get_data) \
> - for ((((link) = ((cond) ? ring_get_head(ring) : NULL)), \
> - ((next) = ((link) ? ring_next((ring), (link)) : NULL)), \
> - ((data) = ((link)? (get_data) : NULL))); \
> - (link); \
> - (((link) = (next)), \
> - ((next) = ((link) ? ring_next((ring), (link)) : NULL)), \
> - ((data) = ((link)? (get_data) : NULL))))
> -
> -#define LINK_TO_RCC(ptr) SPICE_CONTAINEROF(ptr, RedChannelClient,
> channel_link)
> -#define RCC_FOREACH_SAFE(link, next, rcc, channel) \
> - SAFE_FOREACH(link, next, channel, &(channel)->clients, rcc,
> LINK_TO_RCC(link))
> -
> -
> #define LINK_TO_DCC(ptr) SPICE_CONTAINEROF(ptr, DisplayChannelClient, \
> common.base.channel_link)
> #define DCC_FOREACH_SAFE(link, next, dcc, channel) \
> @@ -824,7 +778,6 @@ static void red_push_monitors_config(DisplayChannelClient
> *dcc);
> DisplayChannel, common.base)
>
> #define RCC_TO_DCC(rcc) SPICE_CONTAINEROF((rcc), DisplayChannelClient,
> common.base)
> -#define RCC_TO_CCC(rcc) SPICE_CONTAINEROF((rcc), CursorChannelClient,
> common.base)
>
>
>
> @@ -916,6 +869,13 @@ static void print_compress_stats(DisplayChannel
> *display_channel)
>
> #endif
>
> +QXLInstance* red_worker_get_qxl(RedWorker *worker)
> +{
> + spice_return_val_if_fail(worker != NULL, NULL);
> +
> + return worker->qxl;
> +}
> +
> static MonitorsConfig *monitors_config_getref(MonitorsConfig
> *monitors_config)
> {
> monitors_config->refs++;
> @@ -1071,28 +1031,9 @@ static void show_draw_item(RedWorker *worker, DrawItem
> *draw_item, const char *p
> draw_item->base.rgn.extents.y2);
> }
>
> -static void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
> -{
> - VerbItem *item = spice_new(VerbItem, 1);
> -
> - red_channel_pipe_item_init(rcc->channel, &item->base,
> PIPE_ITEM_TYPE_VERB);
> - item->verb = verb;
> - red_channel_client_pipe_add(rcc, &item->base);
> -}
> -
> static inline void red_create_surface_item(DisplayChannelClient *dcc, int
> surface_id);
> static void red_push_surface_image(DisplayChannelClient *dcc, int
> surface_id);
>
> -static void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
> -{
> - RedChannelClient *rcc;
> - RingItem *link, *next;
> -
> - RCC_FOREACH_SAFE(link, next, rcc, channel) {
> - red_pipe_add_verb(rcc, verb);
> - }
> -}
> -
> static inline void red_handle_drawable_surfaces_client_synced(
> DisplayChannelClient *dcc, Drawable *drawable)
> {
> @@ -1325,10 +1266,6 @@ static void common_release_recv_buf(RedChannelClient
> *rcc, uint16_t type, uint32
> }
> }
>
> -#define CLIENT_CURSOR_CACHE
> -#include "cache_item.tmpl.c"
> -#undef CLIENT_CURSOR_CACHE
> -
> #define CLIENT_PALETTE_CACHE
> #include "cache_item.tmpl.c"
> #undef CLIENT_PALETTE_CACHE
> @@ -1338,11 +1275,6 @@ static void
> red_reset_palette_cache(DisplayChannelClient *dcc)
> red_palette_cache_reset(dcc, CLIENT_PALETTE_CACHE_SIZE);
> }
>
> -static void red_reset_cursor_cache(RedChannelClient *rcc)
> -{
> - red_cursor_cache_reset(RCC_TO_CCC(rcc), CLIENT_CURSOR_CACHE_SIZE);
> -}
> -
> static inline Drawable *alloc_drawable(RedWorker *worker)
> {
> Drawable *drawable;
> @@ -4241,153 +4173,6 @@ static void red_update_area(RedWorker *worker, const
> SpiceRect *area, int surfac
> validate_area(worker, area, surface_id);
> }
>
> -static inline void free_cursor_item(RedWorker *worker, CursorItem *item);
> -
> -static void red_release_cursor(RedWorker *worker, CursorItem *cursor)
> -{
> - if (!--cursor->refs) {
> - QXLReleaseInfoExt release_info_ext;
> - RedCursorCmd *cursor_cmd;
> -
> - cursor_cmd = cursor->red_cursor;
> - release_info_ext.group_id = cursor->group_id;
> - release_info_ext.info = cursor_cmd->release_info;
> - worker->qxl->st->qif->release_resource(worker->qxl,
> release_info_ext);
> - free_cursor_item(worker, cursor);
> - red_put_cursor_cmd(cursor_cmd);
> - free(cursor_cmd);
> - }
> -}
> -
> -static void red_set_cursor(RedWorker *worker, CursorItem *cursor)
> -{
> - if (worker->cursor) {
> - red_release_cursor(worker, worker->cursor);
> - }
> - ++cursor->refs;
> - worker->cursor = cursor;
> -}
> -
> -#ifdef DEBUG_CURSORS
> -static int _cursor_count = 0;
> -#endif
> -
> -static inline CursorItem *alloc_cursor_item(RedWorker *worker)
> -{
> - CursorItem *cursor;
> -
> - if (!worker->free_cursor_items) {
> - return NULL;
> - }
> -#ifdef DEBUG_CURSORS
> - --_cursor_count;
> -#endif
> - cursor = &worker->free_cursor_items->u.cursor_item;
> - worker->free_cursor_items = worker->free_cursor_items->u.next;
> - return cursor;
> -}
> -
> -static inline void free_cursor_item(RedWorker *worker, CursorItem *item)
> -{
> - ((_CursorItem *)item)->u.next = worker->free_cursor_items;
> - worker->free_cursor_items = (_CursorItem *)item;
> -#ifdef DEBUG_CURSORS
> - ++_cursor_count;
> - spice_assert(_cursor_count <= NUM_CURSORS);
> -#endif
> -}
> -
> -static void cursor_items_init(RedWorker *worker)
> -{
> - int i;
> -
> - worker->free_cursor_items = NULL;
> - for (i = 0; i < NUM_CURSORS; i++) {
> - free_cursor_item(worker, &worker->cursor_items[i].u.cursor_item);
> - }
> -}
> -
> -static CursorItem *get_cursor_item(RedWorker *worker, RedCursorCmd *cmd,
> uint32_t group_id)
> -{
> - CursorItem *cursor_item;
> -
> - spice_warn_if(!(cursor_item = alloc_cursor_item(worker)));
> -
> - cursor_item->refs = 1;
> - cursor_item->group_id = group_id;
> - cursor_item->red_cursor = cmd;
> -
> - return cursor_item;
> -}
> -
> -static CursorPipeItem *ref_cursor_pipe_item(CursorPipeItem *item)
> -{
> - spice_assert(item);
> - item->refs++;
> - return item;
> -}
> -
> -static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int
> num)
> -{
> - CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
> -
> - red_channel_pipe_item_init(rcc->channel, &item->base,
> PIPE_ITEM_TYPE_CURSOR);
> - item->refs = 1;
> - item->cursor_item = data;
> - item->cursor_item->refs++;
> - return &item->base;
> -}
> -
> -static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem
> *pipe_item)
> -{
> - spice_assert(pipe_item);
> -
> - if (--pipe_item->refs) {
> - return;
> - }
> -
> - spice_assert(!pipe_item_is_linked(&pipe_item->base));
> -
> - red_release_cursor(ccc->common.worker, pipe_item->cursor_item);
> - free(pipe_item);
> -}
> -
> -static void qxl_process_cursor(RedWorker *worker, RedCursorCmd *cursor_cmd,
> uint32_t group_id)
> -{
> - CursorItem *cursor_item;
> - int cursor_show = FALSE;
> -
> - cursor_item = get_cursor_item(worker, cursor_cmd, group_id);
> -
> - switch (cursor_cmd->type) {
> - case QXL_CURSOR_SET:
> - worker->cursor_visible = cursor_cmd->u.set.visible;
> - red_set_cursor(worker, cursor_item);
> - break;
> - case QXL_CURSOR_MOVE:
> - cursor_show = !worker->cursor_visible;
> - worker->cursor_visible = TRUE;
> - worker->cursor_position = cursor_cmd->u.position;
> - break;
> - case QXL_CURSOR_HIDE:
> - worker->cursor_visible = FALSE;
> - break;
> - case QXL_CURSOR_TRAIL:
> - worker->cursor_trail_length = cursor_cmd->u.trail.length;
> - worker->cursor_trail_frequency = cursor_cmd->u.trail.frequency;
> - break;
> - default:
> - spice_error("invalid cursor command %u", cursor_cmd->type);
> - }
> -
> - if (cursor_is_connected(worker) && (worker->mouse_mode ==
> SPICE_MOUSE_MODE_SERVER ||
> - cursor_cmd->type != QXL_CURSOR_MOVE ||
> cursor_show)) {
> - red_channel_pipes_new_add(&worker->cursor_channel->common.base,
> new_cursor_pipe_item,
> - (void*)cursor_item);
> - }
> - red_release_cursor(worker, cursor_item);
> -}
> -
> static int red_process_cursor(RedWorker *worker, uint32_t max_pipe_size, int
> *ring_is_empty)
> {
> QXLCommandExt ext_cmd;
> @@ -4425,12 +4210,11 @@ static int red_process_cursor(RedWorker *worker,
> uint32_t max_pipe_size, int *ri
> free(cursor);
> break;
> }
> -
> - qxl_process_cursor(worker, cursor, ext_cmd.group_id);
> + cursor_channel_process_cmd(worker->cursor_channel, cursor,
> ext_cmd.group_id);
> break;
> }
> default:
> - spice_error("bad command type");
> + spice_warning("bad command type");
> }
> n++;
> }
> @@ -4690,12 +4474,6 @@ static void
> red_push_surface_image(DisplayChannelClient *dcc, int surface_id)
> red_channel_client_push(&dcc->common.base);
> }
>
> -typedef struct {
> - uint32_t type;
> - void *data;
> - uint32_t size;
> -} AddBufInfo;
> -
> static void marshaller_add_compressed(SpiceMarshaller *m,
> RedCompressBuf *comp_buf, size_t size)
> {
> @@ -4710,18 +4488,6 @@ static void marshaller_add_compressed(SpiceMarshaller
> *m,
> } while (max);
> }
>
> -
> -static void add_buf_from_info(SpiceMarshaller *m, AddBufInfo *info)
> -{
> - if (info->data) {
> - switch (info->type) {
> - case BUF_TYPE_RAW:
> - spice_marshaller_add_ref(m, info->data, info->size);
> - break;
> - }
> - }
> -}
> -
> static void fill_base(SpiceMarshaller *base_marshaller, Drawable *drawable)
> {
> SpiceMsgDisplayBase base;
> @@ -6413,37 +6179,6 @@ static void fill_attr(SpiceMarshaller *m,
> SpiceLineAttr *attr, uint32_t group_id
> }
> }
>
> -static void fill_cursor(CursorChannelClient *ccc, SpiceCursor *red_cursor,
> - CursorItem *cursor, AddBufInfo *addbuf)
> -{
> - RedCursorCmd *cursor_cmd;
> - addbuf->data = NULL;
> -
> - if (!cursor) {
> - red_cursor->flags = SPICE_CURSOR_FLAGS_NONE;
> - return;
> - }
> -
> - cursor_cmd = cursor->red_cursor;
> - *red_cursor = cursor_cmd->u.set.shape;
> -
> - if (red_cursor->header.unique) {
> - if (red_cursor_cache_find(ccc, red_cursor->header.unique)) {
> - red_cursor->flags |= SPICE_CURSOR_FLAGS_FROM_CACHE;
> - return;
> - }
> - if (red_cursor_cache_add(ccc, red_cursor->header.unique, 1)) {
> - red_cursor->flags |= SPICE_CURSOR_FLAGS_CACHE_ME;
> - }
> - }
> -
> - if (red_cursor->data_size) {
> - addbuf->type = BUF_TYPE_RAW;
> - addbuf->data = red_cursor->data;
> - addbuf->size = red_cursor->data_size;
> - }
> -}
> -
> static inline void red_display_reset_send_data(DisplayChannelClient *dcc)
> {
> red_display_reset_compress_buf(dcc);
> @@ -8199,23 +7934,6 @@ static inline void
> marshall_qxl_drawable(RedChannelClient *rcc,
> red_lossy_marshall_qxl_drawable(display_channel->common.worker, rcc,
> m, dpi);
> }
>
> -static inline void red_marshall_verb(RedChannelClient *rcc, uint16_t verb)
> -{
> - spice_assert(rcc);
> - red_channel_client_init_send_data(rcc, verb, NULL);
> -}
> -
> -static inline void red_marshall_inval(RedChannelClient *rcc,
> - SpiceMarshaller *base_marshaller, CacheItem *cach_item)
> -{
> - SpiceMsgDisplayInvalOne inval_one;
> -
> - red_channel_client_init_send_data(rcc, cach_item->inval_type, NULL);
> - inval_one.id = *(uint64_t *)&cach_item->id;
> -
> - spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
> -}
> -
> static void
> display_channel_marshall_migrate_data_surfaces(DisplayChannelClient *dcc,
> SpiceMarshaller
> *m,
> int lossy)
> @@ -8591,92 +8309,7 @@ static void
> red_display_marshall_stream_end(RedChannelClient *rcc,
> spice_marshall_msg_display_stream_destroy(base_marshaller, &destroy);
> }
>
> -static void red_cursor_marshall_inval(RedChannelClient *rcc,
> - SpiceMarshaller *m, CacheItem *cach_item)
> -{
> - spice_assert(rcc);
> - red_marshall_inval(rcc, m, cach_item);
> -}
> -
> -static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller
> *base_marshaller,
> - PipeItem *pipe_item)
> -{
> - CursorChannel *cursor_channel;
> - CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> - RedWorker *worker;
> - SpiceMsgCursorInit msg;
> - AddBufInfo info;
> -
> - spice_assert(rcc);
> - cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel,
> common.base);
> - worker = cursor_channel->common.worker;
> -
> - red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INIT, NULL);
> - msg.visible = worker->cursor_visible;
> - msg.position = worker->cursor_position;
> - msg.trail_length = worker->cursor_trail_length;
> - msg.trail_frequency = worker->cursor_trail_frequency;
> -
> - fill_cursor(ccc, &msg.cursor, worker->cursor, &info);
> - spice_marshall_msg_cursor_init(base_marshaller, &msg);
> - add_buf_from_info(base_marshaller, &info);
> -}
> -
> -static void red_marshall_cursor(RedChannelClient *rcc,
> - SpiceMarshaller *m, CursorPipeItem *cursor_pipe_item)
> -{
> - CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel,
> CursorChannel, common.base);
> - CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> - CursorItem *cursor = cursor_pipe_item->cursor_item;
> - PipeItem *pipe_item = &cursor_pipe_item->base;
> - RedCursorCmd *cmd;
> - RedWorker *worker;
> -
> - spice_assert(cursor_channel);
> -
> - worker = cursor_channel->common.worker;
> -
> - cmd = cursor->red_cursor;
> - switch (cmd->type) {
> - case QXL_CURSOR_MOVE:
> - {
> - SpiceMsgCursorMove cursor_move;
> - red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_MOVE,
> pipe_item);
> - cursor_move.position = cmd->u.position;
> - spice_marshall_msg_cursor_move(m, &cursor_move);
> - break;
> - }
> - case QXL_CURSOR_SET:
> - {
> - SpiceMsgCursorSet cursor_set;
> - AddBufInfo info;
> -
> - red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_SET,
> pipe_item);
> - cursor_set.position = cmd->u.set.position;
> - cursor_set.visible = worker->cursor_visible;
> -
> - fill_cursor(ccc, &cursor_set.cursor, cursor, &info);
> - spice_marshall_msg_cursor_set(m, &cursor_set);
> - add_buf_from_info(m, &info);
> - break;
> - }
> - case QXL_CURSOR_HIDE:
> - red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_HIDE,
> pipe_item);
> - break;
> - case QXL_CURSOR_TRAIL:
> - {
> - SpiceMsgCursorTrail cursor_trail;
> -
> - red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_TRAIL,
> pipe_item);
> - cursor_trail.length = cmd->u.trail.length;
> - cursor_trail.frequency = cmd->u.trail.frequency;
> - spice_marshall_msg_cursor_trail(m, &cursor_trail);
> - }
> - break;
> - default:
> - spice_error("bad cursor command %d", cmd->type);
> - }
> -}
> +#define RCC_TO_CCC(rcc) SPICE_CONTAINEROF((rcc), CursorChannelClient,
> common.base)
>
> static void red_marshall_surface_create(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller, SpiceMsgSurfaceCreate *surface_create)
> @@ -8758,9 +8391,6 @@ static void display_channel_send_item(RedChannelClient
> *rcc, PipeItem *pipe_item
> marshall_qxl_drawable(rcc, m, dpi);
> break;
> }
> - case PIPE_ITEM_TYPE_INVAL_ONE:
> - red_marshall_inval(rcc, m, (CacheItem *)pipe_item);
> - break;
> case PIPE_ITEM_TYPE_STREAM_CREATE: {
> StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent,
> create_item);
> red_display_marshall_stream_start(rcc, m, agent);
> @@ -8780,7 +8410,7 @@ static void display_channel_send_item(RedChannelClient
> *rcc, PipeItem *pipe_item
> red_display_marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
> break;
> case PIPE_ITEM_TYPE_VERB:
> - red_marshall_verb(rcc, ((VerbItem*)pipe_item)->verb);
> + red_marshall_verb(rcc, (VerbItem*)pipe_item);
> break;
> case PIPE_ITEM_TYPE_MIGRATE_DATA:
> display_channel_marshall_migrate_data(rcc, m);
> @@ -8796,7 +8426,7 @@ static void display_channel_send_item(RedChannelClient
> *rcc, PipeItem *pipe_item
> break;
> case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
> red_reset_palette_cache(dcc);
> - red_marshall_verb(rcc, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES);
> + red_channel_client_init_send_data(rcc,
> SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, NULL);
> break;
> case PIPE_ITEM_TYPE_CREATE_SURFACE: {
> SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item,
> SurfaceCreateItem,
> @@ -8835,37 +8465,6 @@ static void display_channel_send_item(RedChannelClient
> *rcc, PipeItem *pipe_item
> }
> }
>
> -static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem
> *pipe_item)
> -{
> - SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> - CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> -
> - switch (pipe_item->type) {
> - case PIPE_ITEM_TYPE_CURSOR:
> - red_marshall_cursor(rcc, m, SPICE_CONTAINEROF(pipe_item,
> CursorPipeItem, base));
> - break;
> - case PIPE_ITEM_TYPE_INVAL_ONE:
> - red_cursor_marshall_inval(rcc, m, (CacheItem *)pipe_item);
> - break;
> - case PIPE_ITEM_TYPE_VERB:
> - red_marshall_verb(rcc, ((VerbItem*)pipe_item)->verb);
> - break;
> - case PIPE_ITEM_TYPE_CURSOR_INIT:
> - red_reset_cursor_cache(rcc);
> - red_marshall_cursor_init(rcc, m, pipe_item);
> - break;
> - case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
> - red_reset_cursor_cache(rcc);
> - red_marshall_verb(rcc, SPICE_MSG_CURSOR_INVAL_ALL);
> - break;
> - default:
> - spice_error("invalid pipe item type");
> - }
> -
> - cursor_channel_client_release_item_before_push(ccc, pipe_item);
> - red_channel_client_begin_send_message(rcc);
> -}
> -
> static inline void red_push(RedWorker *worker)
> {
> if (worker->cursor_channel) {
> @@ -9313,7 +8912,8 @@ static inline void flush_cursor_commands(RedWorker
> *worker)
> red_channel_send(channel);
> if (red_now() >= end_time) {
> spice_warning("flush cursor timeout");
> - red_disconnect_cursor(channel);
> + cursor_channel_disconnect(worker->cursor_channel);
> + worker->cursor_channel = NULL;
> } else {
> sleep_count++;
> usleep(DISPLAY_CLIENT_RETRY_INTERVAL);
> @@ -9924,16 +9524,16 @@ SpiceCoreInterface worker_core = {
> .watch_remove = worker_watch_remove,
> };
>
> -static CommonChannelClient *common_channel_client_create(int size,
> - CommonChannel
> *common,
> - RedClient *client,
> - RedsStream *stream,
> - int mig_target,
> - int
> monitor_latency,
> - uint32_t
> *common_caps,
> - int
> num_common_caps,
> - uint32_t *caps,
> - int num_caps)
> +CommonChannelClient *common_channel_new_client(CommonChannel *common,
> + int size,
> + RedClient *client,
> + RedsStream *stream,
> + int mig_target,
> + int monitor_latency,
> + uint32_t *common_caps,
> + int num_common_caps,
> + uint32_t *caps,
> + int num_caps)
> {
> RedChannelClient *rcc =
> red_channel_client_create(size, &common->base, client, stream,
> monitor_latency,
> @@ -9961,8 +9561,8 @@ DisplayChannelClient
> *display_channel_client_create(CommonChannel *common,
> uint32_t *caps, int
> num_caps)
> {
> DisplayChannelClient *dcc =
> - (DisplayChannelClient*)common_channel_client_create(
> - sizeof(DisplayChannelClient), common, client, stream,
> + (DisplayChannelClient*)common_channel_new_client(
> + common, sizeof(DisplayChannelClient), client, stream,
> mig_target,
> TRUE,
> common_caps, num_common_caps,
> @@ -9976,62 +9576,30 @@ DisplayChannelClient
> *display_channel_client_create(CommonChannel *common,
> return dcc;
> }
>
> -CursorChannelClient *cursor_channel_create_rcc(CommonChannel *common,
> - RedClient *client, RedsStream
> *stream,
> - int mig_target,
> - uint32_t *common_caps, int
> num_common_caps,
> - uint32_t *caps, int num_caps)
> -{
> - CursorChannelClient *ccc =
> - (CursorChannelClient*)common_channel_client_create(
> - sizeof(CursorChannelClient), common, client, stream,
> - mig_target,
> - FALSE,
> - common_caps,
> - num_common_caps,
> - caps,
> - num_caps);
> -
> - if (!ccc) {
> - return NULL;
> - }
> - ring_init(&ccc->cursor_cache_lru);
> - ccc->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE;
> - return ccc;
> -}
> -
> -static RedChannel *__new_channel(RedWorker *worker, int size, uint32_t
> channel_type,
> - int migration_flags,
> - channel_disconnect_proc on_disconnect,
> - channel_send_pipe_item_proc send_item,
> - channel_hold_pipe_item_proc hold_item,
> - channel_release_pipe_item_proc
> release_item,
> - channel_handle_parsed_proc handle_parsed,
> - channel_handle_migrate_flush_mark_proc
> handle_migrate_flush_mark,
> - channel_handle_migrate_data_proc
> handle_migrate_data,
> - channel_handle_migrate_data_get_serial_proc
> migrate_get_serial)
> +RedChannel *red_worker_new_channel(RedWorker *worker, int size,
> + uint32_t channel_type, int
> migration_flags,
> + ChannelCbs *channel_cbs,
> + channel_handle_parsed_proc handle_parsed)
> {
> RedChannel *channel = NULL;
> CommonChannel *common;
> - ChannelCbs channel_cbs = { NULL, };
> -
> - channel_cbs.config_socket = common_channel_config_socket;
> - channel_cbs.on_disconnect = on_disconnect;
> - channel_cbs.send_item = send_item;
> - channel_cbs.hold_item = hold_item;
> - channel_cbs.release_item = release_item;
> - channel_cbs.alloc_recv_buf = common_alloc_recv_buf;
> - channel_cbs.release_recv_buf = common_release_recv_buf;
> - channel_cbs.handle_migrate_flush_mark = handle_migrate_flush_mark;
> - channel_cbs.handle_migrate_data = handle_migrate_data;
> - channel_cbs.handle_migrate_data_get_serial = migrate_get_serial;
> +
> + spice_return_val_if_fail(worker, NULL);
> + spice_return_val_if_fail(channel_cbs, NULL);
> + spice_return_val_if_fail(!channel_cbs->config_socket, NULL);
> + spice_return_val_if_fail(!channel_cbs->alloc_recv_buf, NULL);
> + spice_return_val_if_fail(!channel_cbs->release_recv_buf, NULL);
> +
> + channel_cbs->config_socket = common_channel_config_socket;
> + channel_cbs->alloc_recv_buf = common_alloc_recv_buf;
> + channel_cbs->release_recv_buf = common_release_recv_buf;
>
> channel = red_channel_create_parser(size, &worker_core,
> channel_type, worker->id,
> TRUE /* handle_acks */,
> spice_get_client_channel_parser(channel_type,
> NULL),
> handle_parsed,
> - &channel_cbs,
> + channel_cbs,
> migration_flags);
> common = (CommonChannel *)channel;
> if (!channel) {
> @@ -10151,7 +9719,6 @@ static void
> display_channel_client_release_item_before_push(DisplayChannelClient
> free(item);
> break;
> }
> - case PIPE_ITEM_TYPE_INVAL_ONE:
> case PIPE_ITEM_TYPE_VERB:
> case PIPE_ITEM_TYPE_MIGRATE_DATA:
> case PIPE_ITEM_TYPE_PIXMAP_SYNC:
> @@ -10181,25 +9748,26 @@ static void
> display_channel_release_item(RedChannelClient *rcc, PipeItem *item,
> static void display_channel_create(RedWorker *worker, int migrate)
> {
> DisplayChannel *display_channel;
> + ChannelCbs cbs = {
> + .on_disconnect = display_channel_client_on_disconnect,
> + .send_item = display_channel_send_item,
> + .hold_item = display_channel_hold_pipe_item,
> + .release_item = display_channel_release_item,
> + .handle_migrate_flush_mark = display_channel_handle_migrate_mark,
> + .handle_migrate_data = display_channel_handle_migrate_data,
> + .handle_migrate_data_get_serial =
> display_channel_handle_migrate_data_get_serial
> + };
>
> if (worker->display_channel) {
> return;
> }
>
> spice_info("create display channel");
> - if (!(worker->display_channel = (DisplayChannel *)__new_channel(
> + if (!(worker->display_channel = (DisplayChannel
> *)red_worker_new_channel(
> worker, sizeof(*display_channel),
> SPICE_CHANNEL_DISPLAY,
> SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER,
> - display_channel_client_on_disconnect,
> - display_channel_send_item,
> - display_channel_hold_pipe_item,
> - display_channel_release_item,
> - display_channel_handle_message,
> - display_channel_handle_migrate_mark,
> - display_channel_handle_migrate_data,
> - display_channel_handle_migrate_data_get_serial
> - ))) {
> + &cbs, display_channel_handle_message))) {
> spice_warning("failed to create display channel");
> return;
> }
> @@ -10334,129 +9902,6 @@ static void handle_new_display_channel(RedWorker
> *worker, RedClient *client, Red
> on_new_display_channel_client(dcc);
> }
>
> -static void cursor_channel_client_on_disconnect(RedChannelClient *rcc)
> -{
> - if (!rcc) {
> - return;
> - }
> - red_reset_cursor_cache(rcc);
> -}
> -
> -static void red_disconnect_cursor(RedChannel *channel)
> -{
> - CommonChannel *common;
> -
> - if (!channel || !red_channel_is_connected(channel)) {
> - return;
> - }
> - common = SPICE_CONTAINEROF(channel, CommonChannel, base);
> - spice_assert(channel == (RedChannel *)common->worker->cursor_channel);
> - common->worker->cursor_channel = NULL;
> - red_channel_apply_clients(channel, red_reset_cursor_cache);
> - red_channel_disconnect(channel);
> -}
> -
> -static void red_migrate_cursor(RedWorker *worker, RedChannelClient *rcc)
> -{
> - if (red_channel_client_is_connected(rcc)) {
> - red_channel_client_pipe_add_type(rcc,
> - PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
> - red_channel_client_default_migrate(rcc);
> - }
> -}
> -
> -static void on_new_cursor_channel(RedWorker *worker, RedChannelClient *rcc)
> -{
> - CursorChannel *channel = worker->cursor_channel;
> -
> - spice_assert(channel);
> - red_channel_client_ack_zero_messages_window(rcc);
> - red_channel_client_push_set_ack(rcc);
> - // TODO: why do we check for context.canvas? defer this to after display
> cc is connected
> - // and test it's canvas? this is just a test to see if there is an
> active renderer?
> - if (worker->surfaces[0].context.canvas &&
> !channel->common.during_target_migrate) {
> - red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_CURSOR_INIT);
> - }
> -}
> -
> -static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem
> *item)
> -{
> - CursorPipeItem *cursor_pipe_item;
> - spice_assert(item);
> - cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
> - ref_cursor_pipe_item(cursor_pipe_item);
> -}
> -
> -// TODO: share code between before/after_push since most of the items need
> the same
> -// release
> -static void
> cursor_channel_client_release_item_before_push(CursorChannelClient *ccc,
> - PipeItem *item)
> -{
> - switch (item->type) {
> - case PIPE_ITEM_TYPE_CURSOR: {
> - CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item,
> CursorPipeItem, base);
> - put_cursor_pipe_item(ccc, cursor_pipe_item);
> - break;
> - }
> - case PIPE_ITEM_TYPE_INVAL_ONE:
> - case PIPE_ITEM_TYPE_VERB:
> - case PIPE_ITEM_TYPE_CURSOR_INIT:
> - case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
> - free(item);
> - break;
> - default:
> - spice_error("invalid pipe item type");
> - }
> -}
> -
> -static void
> cursor_channel_client_release_item_after_push(CursorChannelClient *ccc,
> - PipeItem *item)
> -{
> - switch (item->type) {
> - case PIPE_ITEM_TYPE_CURSOR: {
> - CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item,
> CursorPipeItem, base);
> - put_cursor_pipe_item(ccc, cursor_pipe_item);
> - break;
> - }
> - default:
> - spice_critical("invalid item type");
> - }
> -}
> -
> -static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem
> *item, int item_pushed)
> -{
> - CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> -
> - spice_assert(item);
> -
> - if (item_pushed) {
> - cursor_channel_client_release_item_after_push(ccc, item);
> - } else {
> - spice_debug("not pushed (%d)", item->type);
> - cursor_channel_client_release_item_before_push(ccc, item);
> - }
> -}
> -
> -static void cursor_channel_create(RedWorker *worker, int migrate)
> -{
> - if (worker->cursor_channel != NULL) {
> - return;
> - }
> - spice_info("create cursor channel");
> - worker->cursor_channel = (CursorChannel *)__new_channel(
> - worker, sizeof(*worker->cursor_channel),
> - SPICE_CHANNEL_CURSOR,
> - 0,
> - cursor_channel_client_on_disconnect,
> - cursor_channel_send_item,
> - cursor_channel_hold_pipe_item,
> - cursor_channel_release_item,
> - red_channel_client_handle_message,
> - NULL,
> - NULL,
> - NULL);
> -}
> -
> static void red_connect_cursor(RedWorker *worker, RedClient *client,
> RedsStream *stream,
> int migrate,
> uint32_t *common_caps, int num_common_caps,
> @@ -10465,24 +9910,28 @@ static void red_connect_cursor(RedWorker *worker,
> RedClient *client, RedsStream
> CursorChannel *channel;
> CursorChannelClient *ccc;
>
> - if (worker->cursor_channel == NULL) {
> - spice_warning("cursor channel was not created");
> - return;
> - }
> + spice_return_if_fail(worker->cursor_channel != NULL);
> +
> channel = worker->cursor_channel;
> spice_info("add cursor channel client");
> - ccc = cursor_channel_create_rcc(&channel->common, client, stream,
> + ccc = cursor_channel_client_new(channel, client, stream,
> migrate,
> common_caps, num_common_caps,
> caps, num_caps);
> - if (!ccc) {
> - return;
> - }
> + spice_return_if_fail(ccc != NULL);
> #ifdef RED_STATISTICS
> channel->stat = stat_add_node(worker->stat, "cursor_channel", TRUE);
> channel->common.base.out_bytes_counter = stat_add_counter(channel->stat,
> "out_bytes", TRUE);
> #endif
> - on_new_cursor_channel(worker, &ccc->common.base);
> +
> + RedChannelClient *rcc = &ccc->common.base;
> + red_channel_client_ack_zero_messages_window(rcc);
> + red_channel_client_push_set_ack(rcc);
> + // TODO: why do we check for context.canvas? defer this to after display
> cc is connected
> + // and test it's canvas? this is just a test to see if there is an
> active renderer?
> + if (worker->surfaces[0].context.canvas &&
> !channel->common.during_target_migrate) {
> + red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_CURSOR_INIT);
> + }
> }
>
> static void surface_dirty_region_to_rects(RedSurface *surface,
> @@ -10636,31 +10085,6 @@ void handle_dev_destroy_surface_wait(void *opaque,
> void *payload)
> dev_destroy_surface_wait(worker, msg->surface_id);
> }
>
> -static inline void red_cursor_reset(RedWorker *worker)
> -{
> - if (worker->cursor) {
> - red_release_cursor(worker, worker->cursor);
> - worker->cursor = NULL;
> - }
> -
> - worker->cursor_visible = TRUE;
> - worker->cursor_position.x = worker->cursor_position.y = 0;
> - worker->cursor_trail_length = worker->cursor_trail_frequency = 0;
> -
> - if (cursor_is_connected(worker)) {
> - red_channel_pipes_add_type(&worker->cursor_channel->common.base,
> - PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
> - if (!worker->cursor_channel->common.during_target_migrate) {
> - red_pipes_add_verb(&worker->cursor_channel->common.base,
> SPICE_MSG_CURSOR_RESET);
> - }
> - if (!red_channel_wait_all_sent(&worker->cursor_channel->common.base,
> - DISPLAY_CLIENT_TIMEOUT)) {
> - red_channel_apply_clients(&worker->cursor_channel->common.base,
> -
> red_channel_client_disconnect_if_pending_send);
> - }
> - }
> -}
> -
> /* called upon device reset */
>
> /* TODO: split me*/
> @@ -10691,7 +10115,7 @@ static inline void dev_destroy_surfaces(RedWorker
> *worker)
>
> red_display_clear_glz_drawables(worker->display_channel);
>
> - red_cursor_reset(worker);
> + cursor_channel_reset(worker->cursor_channel);
> }
>
> void handle_dev_destroy_surfaces(void *opaque, void *payload)
> @@ -10849,10 +10273,9 @@ static void dev_create_primary_surface(RedWorker
> *worker, uint32_t surface_id,
> red_channel_push(&worker->display_channel->common.base);
> }
>
> - if (cursor_is_connected(worker) &&
> !worker->cursor_channel->common.during_target_migrate) {
> + if (!worker->cursor_channel->common.during_target_migrate)
> red_channel_pipes_add_type(&worker->cursor_channel->common.base,
> PIPE_ITEM_TYPE_CURSOR_INIT);
> - }
> }
>
> void handle_dev_create_primary_surface(void *opaque, void *payload)
> @@ -10881,7 +10304,7 @@ static void dev_destroy_primary_surface(RedWorker
> *worker, uint32_t surface_id)
>
> spice_assert(!worker->surfaces[surface_id].context.canvas);
>
> - red_cursor_reset(worker);
> + cursor_channel_reset(worker->cursor_channel);
> }
>
> void handle_dev_destroy_primary_surface(void *opaque, void *payload)
> @@ -11051,7 +10474,9 @@ void handle_dev_oom(void *opaque, void *payload)
>
> void handle_dev_reset_cursor(void *opaque, void *payload)
> {
> - red_cursor_reset((RedWorker *)opaque);
> + RedWorker *worker = opaque;
> +
> + cursor_channel_reset(worker->cursor_channel);
> }
>
> void handle_dev_reset_image_cache(void *opaque, void *payload)
> @@ -11195,8 +10620,12 @@ 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
> - cursor_channel_create(worker, FALSE);
> + if (!worker->cursor_channel) {
> + worker->cursor_channel = cursor_channel_new(worker);
> + } else {
> + spice_warning("cursor channel already created");
> + }
> +
> red_channel = &worker->cursor_channel->common.base;
> send_data(worker->channel, &red_channel, sizeof(RedChannel *));
> }
> @@ -11223,19 +10652,20 @@ void handle_dev_cursor_disconnect(void *opaque,
> void *payload)
> RedChannelClient *rcc = msg->rcc;
>
> spice_info("disconnect cursor client");
> - spice_assert(rcc);
> red_channel_client_disconnect(rcc);
> }
>
> void handle_dev_cursor_migrate(void *opaque, void *payload)
> {
> RedWorkerMessageCursorMigrate *msg = payload;
> - RedWorker *worker = opaque;
> RedChannelClient *rcc = msg->rcc;
>
> spice_info("migrate cursor client");
> - spice_assert(rcc);
> - red_migrate_cursor(worker, rcc);
> + if (!red_channel_client_is_connected(rcc))
> + return;
> +
> + red_channel_client_pipe_add_type(rcc,
> PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
> + red_channel_client_default_migrate(rcc);
> }
>
> void handle_dev_set_compression(void *opaque, void *payload)
> @@ -11312,8 +10742,10 @@ void handle_dev_set_mouse_mode(void *opaque, void
> *payload)
> RedWorkerMessageSetMouseMode *msg = payload;
> RedWorker *worker = opaque;
>
> - worker->mouse_mode = msg->mode;
> - spice_info("mouse mode %u", worker->mouse_mode);
> + spice_info("mouse mode %u", msg->mode);
> + spice_return_if_fail(worker->cursor_channel);
> +
> + worker->cursor_channel->mouse_mode = msg->mode;
> }
>
> void handle_dev_add_memslot_async(void *opaque, void *payload)
> @@ -11350,7 +10782,7 @@ static int loadvm_command(RedWorker *worker,
> QXLCommandExt *ext)
> free(cursor_cmd);
> return FALSE;
> }
> - qxl_process_cursor(worker, cursor_cmd, ext->group_id);
> + cursor_channel_process_cmd(worker->cursor_channel, cursor_cmd,
> ext->group_id);
> break;
> case QXL_CMD_SURFACE:
> surface_cmd = spice_new0(RedSurfaceCmd, 1);
> @@ -11628,12 +11060,10 @@ RedWorker* red_worker_new(QXLInstance *qxl,
> RedDispatcher *red_dispatcher)
> if (worker->record_fd) {
> dispatcher_register_universal_handler(dispatcher,
> worker_dispatcher_record);
> }
> - worker->cursor_visible = TRUE;
> 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 = image_compression;
> worker->jpeg_state = jpeg_state;
> worker->zlib_glz_state = zlib_glz_state;
> @@ -11643,7 +11073,6 @@ RedWorker* red_worker_new(QXLInstance *qxl,
> RedDispatcher *red_dispatcher)
> image_cache_init(&worker->image_cache);
> image_surface_init(worker);
> drawables_init(worker);
> - cursor_items_init(worker);
> red_init_streams(worker);
> stat_init(&worker->add_stat, add_stat_name);
> stat_init(&worker->exclude_stat, exclude_stat_name);
> diff --git a/server/red_worker.h b/server/red_worker.h
> index 0f5fac7..60c326a 100644
> --- a/server/red_worker.h
> +++ b/server/red_worker.h
> @@ -32,6 +32,9 @@ typedef struct CommonChannelClient {
> int is_low_bandwidth;
> } CommonChannelClient;
>
> +
> +#define DISPLAY_CLIENT_TIMEOUT 30000000000ULL //nano
> +
> #define CHANNEL_RECEIVE_BUF_SIZE 1024
> typedef struct CommonChannel {
> RedChannel base; // Must be the first thing
> @@ -45,7 +48,75 @@ typedef struct CommonChannel {
> of the primary surface) */
> } CommonChannel;
>
> +enum {
> + PIPE_ITEM_TYPE_VERB = PIPE_ITEM_TYPE_CHANNEL_BASE,
> + PIPE_ITEM_TYPE_INVAL_ONE,
> +
> + PIPE_ITEM_TYPE_COMMON_LAST
> +};
> +
> +typedef struct VerbItem {
> + PipeItem base;
> + uint16_t verb;
> +} VerbItem;
> +
> +static inline void red_marshall_verb(RedChannelClient *rcc, VerbItem *item)
> +{
> + red_channel_client_init_send_data(rcc, item->verb, NULL);
> +}
> +
> +static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
> +{
> + VerbItem *item = spice_new(VerbItem, 1);
> +
> + red_channel_pipe_item_init(rcc->channel, &item->base,
> PIPE_ITEM_TYPE_VERB);
> + item->verb = verb;
> + red_channel_client_pipe_add(rcc, &item->base);
> +}
> +
> +/* a generic safe for loop macro */
> +#define SAFE_FOREACH(link, next, cond, ring, data, get_data) \
> + for ((((link) = ((cond) ? ring_get_head(ring) : NULL)), \
> + ((next) = ((link) ? ring_next((ring), (link)) : NULL)), \
> + ((data) = ((link)? (get_data) : NULL))); \
> + (link); \
> + (((link) = (next)), \
> + ((next) = ((link) ? ring_next((ring), (link)) : NULL)), \
> + ((data) = ((link)? (get_data) : NULL))))
> +
> +#define LINK_TO_RCC(ptr) SPICE_CONTAINEROF(ptr, RedChannelClient,
> channel_link)
> +#define RCC_FOREACH_SAFE(link, next, rcc, channel) \
> + SAFE_FOREACH(link, next, channel, &(channel)->clients, rcc,
> LINK_TO_RCC(link))
> +
> +static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
> +{
> + RedChannelClient *rcc;
> + RingItem *link, *next;
> +
> + RCC_FOREACH_SAFE(link, next, rcc, channel) {
> + red_pipe_add_verb(rcc, 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_new_channel(RedWorker *worker, int size,
> + uint32_t channel_type, int
> migration_flags,
> + ChannelCbs *channel_cbs,
> + channel_handle_parsed_proc
> handle_parsed);
> +
> +CommonChannelClient *common_channel_new_client(CommonChannel *common,
> + int size,
> + RedClient *client,
> + RedsStream *stream,
> + int mig_target,
> + int monitor_latency,
> + uint32_t *common_caps,
> + int num_common_caps,
> + uint32_t *caps,
> + int num_caps);
>
> #endif
> --
> 2.4.3
>
This patch does a lot of stuff:
- move code to new files;
- change cursor structures (for instance to add qxl pointer);
- renames many functions;
- change cursor memory management;
- fix some bugs.
Not that it looks bad just that I'm still trying to understand all the changes.
Frediano
More information about the Spice-devel
mailing list