> > In general, it sounds like good stuff, but can we wait with this stuff until > after we finish merging the refactory branch? I haven't looked in detail, but > it > seems to me that at least some of this stuff is already handled in the > refactory > branch (for instance, there is a common-worker-channel.[ch] in the refactory > branch already). I'm reluctant to commit things that will create conflicts > when > rebasing or merging the stuff we've already got. > Actually there is a small fix for this... develop on top of refactory ! Really... I though it just now... don't know why, beside I cannot test refactory as never full worked for me, perhaps also because being the maintainer of this branch I feel a bit assertive. Frediano > > On Fri, 2016-01-22 at 17:57 +0000, Frediano Ziglio wrote: > > This patch try to make sure that CursorChannel and DisplayChannel don't > > know RedWorker existence. > > Definition common to CursorChannel and DisplayChannel are moved to a new > > common-channel.h header. > > RedWorker pointers are removed from CommonChannel and CommonChannelClient. > > red_drawable_ref declaration is moved to display-channel.h and accept > > a DisplayChannel* instead of a RedWorker* (perhaps should be moved to > > display-channel.c too with red_drawable_new). > > As a small hack red_worker_new_channel is renamed to common_channel_new > > accepting a pointer to a structure with finally is a RedWorker*. > > A good thing you can see is that red_worker_get_qxl and > > red_worker_get_memslot went away. > > There are only 4 function declaration for RedWorker (red-worker.h) and I > > already have a patch to remove the red_worker_get_* ones. > > Result is that only RedDispatcher know of the existence of RedWorker! > > > > Signed-off-by: Frediano Ziglio <fziglio@xxxxxxxxxx> > > --- > > server/Makefile.am | 1 + > > server/common-channel.h | 107 > > +++++++++++++++++++++++++++++++++++++++++++++++ > > server/cursor-channel.c | 10 ++--- > > server/cursor-channel.h | 4 +- > > server/dcc-encoders.c | 3 +- > > server/dcc.c | 2 +- > > server/dcc.h | 4 +- > > server/display-channel.c | 15 +++---- > > server/display-channel.h | 12 ++++-- > > server/red-record-qxl.c | 1 - > > server/red-replay-qxl.c | 2 +- > > server/red-worker.c | 44 +++++++------------ > > server/red-worker.h | 91 +--------------------------------------- > > 13 files changed, 152 insertions(+), 144 deletions(-) > > create mode 100644 server/common-channel.h > > > > diff --git a/server/Makefile.am b/server/Makefile.am > > index 92b716f..feb69c5 100644 > > --- a/server/Makefile.am > > +++ b/server/Makefile.am > > @@ -106,6 +106,7 @@ libserver_la_SOURCES = \ > > red-parse-qxl.h \ > > red-worker.c \ > > red-worker.h \ > > + common-channel.h \ > > display-channel.c \ > > display-channel.h \ > > cursor-channel.c \ > > diff --git a/server/common-channel.h b/server/common-channel.h > > new file mode 100644 > > index 0000000..5bd85d3 > > --- /dev/null > > +++ b/server/common-channel.h > > @@ -0,0 +1,107 @@ > > +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */ > > +/* > > + Copyright (C) 2009-2015 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 COMMON_CHANNEL_H_ > > +#define COMMON_CHANNEL_H_ > > + > > +typedef struct CommonChannelClient { > > + RedChannelClient base; > > + > > + uint32_t id; > > + int is_low_bandwidth; > > +} CommonChannelClient; > > + > > +#define COMMON_CHANNEL_CLIENT(Client) ((CommonChannelClient*)(Client)) > > +#define COMMON_CLIENT_TIMEOUT (NSEC_PER_SEC * 30) > > + > > +#define CHANNEL_RECEIVE_BUF_SIZE 1024 > > +typedef struct CommonChannel { > > + RedChannel base; // Must be the first thing > > + > > + QXLInstance *qxl; > > + uint8_t recv_buf[CHANNEL_RECEIVE_BUF_SIZE]; > > + uint32_t id_alloc; // bitfield. TODO - use this instead of shift > > scheme. > > + int during_target_migrate; /* TRUE when the client that is associated > > with the channel > > + is during migration. Turned off when the > > vm > > is started. > > + The flag is used to avoid sending > > messages > > that are artifacts > > + of the transition from stopped vm to > > loaded > > vm (e.g., recreation > > + of the primary surface) */ > > +} CommonChannel; > > + > > +#define COMMON_CHANNEL(Channel) ((CommonChannel*)(Channel)) > > + > > +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); > > +} > > + > > +#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); > > + } > > +} > > + > > +typedef struct CommonChannelNewParam CommonChannelNewParam; > > + > > +CommonChannel *common_channel_new(CommonChannelNewParam *param, int size, > > + const char *name, > > + 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 > > diff --git a/server/cursor-channel.c b/server/cursor-channel.c > > index 4c15582..917cf4b 100644 > > --- a/server/cursor-channel.c > > +++ b/server/cursor-channel.c > > @@ -424,7 +424,7 @@ static void > > cursor_channel_release_item(RedChannelClient > > *rcc, PipeItem *item, i > > } > > } > > > > -CursorChannel* cursor_channel_new(RedWorker *worker) > > +CursorChannel* cursor_channel_new(CommonChannelNewParam *param) > > { > > CursorChannel *cursor_channel; > > CommonChannel *channel = NULL; > > @@ -436,9 +436,9 @@ CursorChannel* cursor_channel_new(RedWorker *worker) > > }; > > > > spice_info("create cursor channel"); > > - channel = red_worker_new_channel(worker, sizeof(CursorChannel), > > "cursor_channel", > > - SPICE_CHANNEL_CURSOR, 0, > > - &cbs, > > red_channel_client_handle_message); > > + channel = common_channel_new(param, sizeof(CursorChannel), > > "cursor_channel", > > + SPICE_CHANNEL_CURSOR, 0, > > + &cbs, red_channel_client_handle_message); > > > > cursor_channel = (CursorChannel *)channel; > > cursor_channel->cursor_visible = TRUE; > > @@ -496,7 +496,7 @@ void cursor_channel_process_cmd(CursorChannel *cursor, > > RedCursorCmd *cursor_cmd, > > spice_return_if_fail(cursor); > > spice_return_if_fail(cursor_cmd); > > > > - cursor_item = > > cursor_item_new(red_worker_get_qxl(cursor->common.worker), > > + cursor_item = cursor_item_new(cursor->common.qxl, > > cursor_cmd, group_id); > > > > switch (cursor_cmd->type) { > > diff --git a/server/cursor-channel.h b/server/cursor-channel.h > > index 104af20..c4381c7 100644 > > --- a/server/cursor-channel.h > > +++ b/server/cursor-channel.h > > @@ -20,7 +20,7 @@ > > > > #include "spice.h" > > #include "reds.h" > > -#include "red-worker.h" > > +#include "common-channel.h" > > #include "red-parse-qxl.h" > > #include "cache-item.h" > > #include "stat.h" > > @@ -30,7 +30,7 @@ typedef struct CursorChannelClient CursorChannelClient; > > > > #define CURSOR_CHANNEL_CLIENT(Client) ((CursorChannelClient*)(Client)) > > > > -CursorChannel* cursor_channel_new (RedWorker *worker); > > +CursorChannel* cursor_channel_new (CommonChannelNewParam > > *param); > > void cursor_channel_disconnect (CursorChannel > > *cursor_channel); > > void cursor_channel_reset (CursorChannel *cursor); > > void cursor_channel_init (CursorChannel *cursor, > > CursorChannelClient* client); > > diff --git a/server/dcc-encoders.c b/server/dcc-encoders.c > > index 0923c9c..c810b8e 100644 > > --- a/server/dcc-encoders.c > > +++ b/server/dcc-encoders.c > > @@ -456,7 +456,6 @@ void > > dcc_free_glz_drawable_instance(DisplayChannelClient > > *dcc, > > GlzDrawableInstanceItem *instance) > > { > > DisplayChannel *display_channel = DCC_TO_DC(dcc); > > - RedWorker *worker = display_channel->common.worker; > > RedGlzDrawable *glz_drawable; > > > > spice_assert(instance); > > @@ -484,7 +483,7 @@ void > > dcc_free_glz_drawable_instance(DisplayChannelClient > > *dcc, > > if (drawable) { > > ring_remove(&glz_drawable->drawable_link); > > } > > - red_drawable_unref(worker, glz_drawable->red_drawable, > > + red_drawable_unref(display_channel, glz_drawable->red_drawable, > > glz_drawable->group_id); > > display_channel->glz_drawable_count--; > > if (ring_item_is_linked(&glz_drawable->link)) { > > diff --git a/server/dcc.c b/server/dcc.c > > index bf692f8..3f02a98 100644 > > --- a/server/dcc.c > > +++ b/server/dcc.c > > @@ -1085,7 +1085,7 @@ int dcc_compress_image(DisplayChannelClient *dcc, > > if (drawable != NULL) { > > group_id = drawable->group_id; > > } else { > > - group_id = red_worker_get_memslot(display_channel->common.worker) > > ->internal_groupslot_id; > > + group_id = display_channel->groupslot_id; > > } > > > > if (quic_compress) { > > diff --git a/server/dcc.h b/server/dcc.h > > index f715792..e4592b4 100644 > > --- a/server/dcc.h > > +++ b/server/dcc.h > > @@ -16,14 +16,14 @@ > > License along with this library; if not, see > > <http://www.gnu.org/licenses/ > > >. > > */ > > #ifndef DCC_H_ > > -# define DCC_H_ > > +#define DCC_H_ > > > > -#include "red-worker.h" > > #include "pixmap-cache.h" > > #include "cache-item.h" > > #include "dcc-encoders.h" > > #include "stream.h" > > #include "display-limits.h" > > +#include "common-channel.h" > > > > #define PALETTE_CACHE_HASH_SHIFT 8 > > #define PALETTE_CACHE_HASH_SIZE (1 << PALETTE_CACHE_HASH_SHIFT) > > diff --git a/server/display-channel.c b/server/display-channel.c > > index f0d133a..12f44e9 100644 > > --- a/server/display-channel.c > > +++ b/server/display-channel.c > > @@ -241,8 +241,7 @@ static void stop_streams(DisplayChannel *display) > > void display_channel_surface_unref(DisplayChannel *display, uint32_t > > surface_id) > > { > > RedSurface *surface = &display->surfaces[surface_id]; > > - RedWorker *worker = COMMON_CHANNEL(display)->worker; > > - QXLInstance *qxl = red_worker_get_qxl(worker); > > + QXLInstance *qxl = display->common.qxl; > > DisplayChannelClient *dcc; > > RingItem *link, *next; > > > > @@ -1445,7 +1444,7 @@ void display_channel_drawable_unref(DisplayChannel > > *display, Drawable *drawable) > > ring_remove(item); > > } > > if (drawable->red_drawable) { > > - red_drawable_unref(COMMON_CHANNEL(display)->worker, drawable > > ->red_drawable, drawable->group_id); > > + red_drawable_unref(display, drawable->red_drawable, drawable > > ->group_id); > > } > > drawable_free(display, drawable); > > display->drawable_count--; > > @@ -2014,8 +2013,8 @@ static SpiceCanvas > > *image_surfaces_get(SpiceImageSurfaces *surfaces, uint32_t su > > return display->surfaces[surface_id].context.canvas; > > } > > > > -DisplayChannel* display_channel_new(RedWorker *worker, int migrate, int > > stream_video, > > - uint32_t n_surfaces) > > +DisplayChannel* display_channel_new(CommonChannelNewParam *param, int > > migrate, int stream_video, > > + uint32_t n_surfaces, uint32_t > > groupslot_id) > > { > > DisplayChannel *display; > > ChannelCbs cbs = { > > @@ -2034,13 +2033,15 @@ DisplayChannel* display_channel_new(RedWorker > > *worker, > > int migrate, int stream_v > > spice_return_val_if_fail(num_renderers > 0, NULL); > > > > spice_info("create display channel"); > > - display = (DisplayChannel *)red_worker_new_channel( > > - worker, sizeof(*display), "display_channel", > > + display = (DisplayChannel *)common_channel_new( > > + param, sizeof(*display), "display_channel", > > SPICE_CHANNEL_DISPLAY, > > SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER, > > &cbs, dcc_handle_message); > > spice_return_val_if_fail(display, NULL); > > > > + display->groupslot_id = groupslot_id; > > + > > clockid_t stat_clock = CLOCK_THREAD_CPUTIME_ID; > > stat_init(&display->add_stat, "add", stat_clock); > > stat_init(&display->exclude_stat, "exclude", stat_clock); > > diff --git a/server/display-channel.h b/server/display-channel.h > > index bf29cd3..73289f2 100644 > > --- a/server/display-channel.h > > +++ b/server/display-channel.h > > @@ -21,7 +21,6 @@ > > #include <setjmp.h> > > > > #include "common/rect.h" > > -#include "red-worker.h" > > #include "reds-stream.h" > > #include "cache-item.h" > > #include "pixmap-cache.h" > > @@ -200,6 +199,8 @@ struct DisplayChannel { > > ImageCache image_cache; > > RedCompressBuf *free_compress_bufs; > > > > + uint32_t groupslot_id; > > + > > /* TODO: some day unify this, make it more runtime.. */ > > stat_info_t add_stat; > > stat_info_t exclude_stat; > > @@ -248,11 +249,11 @@ typedef struct UpgradeItem { > > SpiceClipRects *rects; > > } UpgradeItem; > > > > - > > -DisplayChannel* display_channel_new > > (RedWorker *worker, > > +DisplayChannel* display_channel_new > > (CommonChannelNewParam *param, > > int > > migrate, > > int > > stream_video, > > - > > uint32_t n_surfaces); > > + > > uint32_t n_surfaces, > > + > > uint32_t groupslot_id); > > void display_channel_create_surface > > (DisplayChannel *display, uint32_t surface_id, > > > > uint32_t width, uint32_t height, > > int32_t > > stride, uint32_t format, void *line_0, > > @@ -307,6 +308,9 @@ void > > display_channel_process_surface_cmd (DisplayCha > > void display_channel_update_compression > > (DisplayChannel *display, > > > > DisplayChannelClient *dcc); > > > > +void red_drawable_unref(DisplayChannel *display, RedDrawable > > *red_drawable, > > + uint32_t group_id); > > + > > static inline int validate_surface(DisplayChannel *display, uint32_t > > surface_id) > > { > > if SPICE_UNLIKELY(surface_id >= display->n_surfaces) { > > diff --git a/server/red-record-qxl.c b/server/red-record-qxl.c > > index 9c9dd62..2791903 100644 > > --- a/server/red-record-qxl.c > > +++ b/server/red-record-qxl.c > > @@ -21,7 +21,6 @@ > > > > #include <stdbool.h> > > #include <inttypes.h> > > -#include "red-worker.h" > > #include "red-common.h" > > #include "memslot.h" > > #include "red-parse-qxl.h" > > diff --git a/server/red-replay-qxl.c b/server/red-replay-qxl.c > > index 17ee022..0c0515b 100644 > > --- a/server/red-replay-qxl.c > > +++ b/server/red-replay-qxl.c > > @@ -24,7 +24,7 @@ > > #include <zlib.h> > > #include <pthread.h> > > #include "reds.h" > > -#include "red-worker.h" > > +#include "red-dispatcher.h" > > #include "red-common.h" > > #include "memslot.h" > > #include "red-parse-qxl.h" > > diff --git a/server/red-worker.c b/server/red-worker.c > > index ad8ba1a..c27533f 100644 > > --- a/server/red-worker.c > > +++ b/server/red-worker.c > > @@ -99,20 +99,6 @@ struct RedWorker { > > FILE *record_fd; > > }; > > > > -QXLInstance* red_worker_get_qxl(RedWorker *worker) > > -{ > > - spice_return_val_if_fail(worker != NULL, NULL); > > - > > - return worker->qxl; > > -} > > - > > -RedMemSlotInfo* red_worker_get_memslot(RedWorker *worker) > > -{ > > - spice_return_val_if_fail(worker != NULL, NULL); > > - > > - return &worker->mem_slots; > > -} > > - > > static int display_is_connected(RedWorker *worker) > > { > > return (worker->display_channel && red_channel_is_connected( > > @@ -149,7 +135,7 @@ static void common_release_recv_buf(RedChannelClient > > *rcc, > > uint16_t type, uint32 > > } > > } > > > > -void red_drawable_unref(RedWorker *worker, RedDrawable *red_drawable, > > +void red_drawable_unref(DisplayChannel *display, RedDrawable > > *red_drawable, > > uint32_t group_id) > > { > > QXLReleaseInfoExt release_info_ext; > > @@ -157,10 +143,10 @@ void red_drawable_unref(RedWorker *worker, > > RedDrawable > > *red_drawable, > > if (--red_drawable->refs) { > > return; > > } > > - worker->display_channel->red_drawable_count--; > > + display->red_drawable_count--; > > release_info_ext.group_id = group_id; > > release_info_ext.info = red_drawable->release_info; > > - worker->qxl->st->qif->release_resource(worker->qxl, release_info_ext); > > + display->common.qxl->st->qif->release_resource(display->common.qxl, > > release_info_ext); > > red_put_drawable(red_drawable); > > free(red_drawable); > > } > > @@ -270,7 +256,7 @@ static int red_process_display(RedWorker *worker, > > uint32_t > > max_pipe_size, int *r > > worker > > ->process_display_generation); > > } > > // release the red_drawable > > - red_drawable_unref(worker, red_drawable, ext_cmd.group_id); > > + red_drawable_unref(worker->display_channel, red_drawable, > > ext_cmd.group_id); > > break; > > } > > case QXL_CMD_UPDATE: { > > @@ -606,8 +592,7 @@ CommonChannelClient > > *common_channel_new_client(CommonChannel *common, > > return NULL; > > } > > CommonChannelClient *common_cc = (CommonChannelClient*)rcc; > > - common_cc->worker = common->worker; > > - common_cc->id = common->worker->qxl->id; > > + common_cc->id = common->qxl->id; > > common->during_target_migrate = mig_target; > > > > // TODO: move wide/narrow ack setting to red_channel. > > @@ -618,12 +603,13 @@ CommonChannelClient > > *common_channel_new_client(CommonChannel *common, > > } > > > > > > -CommonChannel *red_worker_new_channel(RedWorker *worker, int size, > > - const char *name, > > - uint32_t channel_type, int > > migration_flags, > > - ChannelCbs *channel_cbs, > > - channel_handle_parsed_proc > > handle_parsed) > > +CommonChannel *common_channel_new(CommonChannelNewParam *param, int size, > > + const char *name, > > + uint32_t channel_type, int > > migration_flags, > > + ChannelCbs *channel_cbs, > > + channel_handle_parsed_proc > > handle_parsed) > > { > > + RedWorker *worker = (RedWorker *) param; > > RedChannel *channel = NULL; > > CommonChannel *common; > > > > @@ -648,7 +634,7 @@ CommonChannel *red_worker_new_channel(RedWorker > > *worker, > > int size, > > red_channel_set_stat_node(channel, stat_add_node(worker->stat, name, > > TRUE)); > > > > common = (CommonChannel *)channel; > > - common->worker = worker; > > + common->qxl = worker->qxl; > > return common; > > } > > > > @@ -1597,10 +1583,10 @@ RedWorker* red_worker_new(QXLInstance *qxl, > > RedDispatcher *red_dispatcher) > > > > worker->event_timeout = INF_EVENT_WAIT; > > > > - worker->cursor_channel = cursor_channel_new(worker); > > + worker->cursor_channel = cursor_channel_new((CommonChannelNewParam*) > > worker); > > // TODO: handle seemless migration. Temp, setting migrate to FALSE > > - worker->display_channel = display_channel_new(worker, FALSE, > > streaming_video, > > - init_info.n_surfaces); > > + worker->display_channel = display_channel_new((CommonChannelNewParam*) > > worker, FALSE, streaming_video, > > + init_info.n_surfaces, > > worker->mem_slots.internal_groupslot_id); > > > > return worker; > > } > > diff --git a/server/red-worker.h b/server/red-worker.h > > index 91533e1..f6db1d5 100644 > > --- a/server/red-worker.h > > +++ b/server/red-worker.h > > @@ -21,102 +21,13 @@ > > #include "red-common.h" > > #include "red-dispatcher.h" > > #include "red-parse-qxl.h" > > +#include "common-channel.h" > > > > typedef struct RedWorker RedWorker; > > > > -typedef struct CommonChannelClient { > > - RedChannelClient base; > > - > > - uint32_t id; > > - RedWorker *worker; > > - int is_low_bandwidth; > > -} CommonChannelClient; > > - > > -#define COMMON_CHANNEL_CLIENT(Client) ((CommonChannelClient*)(Client)) > > -#define COMMON_CLIENT_TIMEOUT (NSEC_PER_SEC * 30) > > - > > -#define CHANNEL_RECEIVE_BUF_SIZE 1024 > > -typedef struct CommonChannel { > > - RedChannel base; // Must be the first thing > > - > > - struct RedWorker *worker; > > - uint8_t recv_buf[CHANNEL_RECEIVE_BUF_SIZE]; > > - uint32_t id_alloc; // bitfield. TODO - use this instead of shift > > scheme. > > - int during_target_migrate; /* TRUE when the client that is associated > > with the channel > > - is during migration. Turned off when the > > vm > > is started. > > - The flag is used to avoid sending > > messages > > that are artifacts > > - of the transition from stopped vm to > > loaded > > vm (e.g., recreation > > - of the primary surface) */ > > -} CommonChannel; > > - > > -#define COMMON_CHANNEL(Channel) ((CommonChannel*)(Channel)) > > - > > -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); > > -} > > - > > -#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_get_cursor_channel(RedWorker *worker); > > RedChannel* red_worker_get_display_channel(RedWorker *worker); > > -RedMemSlotInfo* red_worker_get_memslot(RedWorker *worker); > > - > > -void red_drawable_unref(RedWorker *worker, RedDrawable *red_drawable, > > - uint32_t group_id); > > - > > -CommonChannel *red_worker_new_channel(RedWorker *worker, int size, > > - const char *name, > > - 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 > _______________________________________________ Spice-devel mailing list Spice-devel@xxxxxxxxxxxxxxxxxxxxx http://lists.freedesktop.org/mailman/listinfo/spice-devel