pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2025-12-26 14:41:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename PipeItem to RedPipeItem

Browse Source 
Following internal type naming conventions

Acked-by: Frediano Ziglio <fziglio@redhat.com>
This commit is contained in:
Jonathon Jongsma 2016-04-14 14:09:31 -05:00
parent 64dc3ab244
commit b9720d80e0
22 changed files with 273 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/cache-item.h
View File

@ -25,7 +25,7 @@ typedef struct CacheItem CacheItem;
struct CacheItem {
union {
PipeItem pipe_data;
RedPipeItem pipe_data;
struct {
RingItem lru_link;
CacheItem *next;

2
server/cache-item.tmpl.c
View File

@ -81,7 +81,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
channel_client->VAR_NAME(items)--;
channel_client->VAR_NAME(available) += item->size;
pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
red_channel_client_pipe_add_tail_and_push(&channel_client->common.base, &item->u.pipe_data); // for now
}

22
server/char-device.c
View File

@ -96,7 +96,7 @@ enum {
static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_buf);
static void red_char_device_write_retry(void *opaque);
static PipeItem *
static RedPipeItem *
red_char_device_read_one_msg_from_device(RedCharDevice *dev)
{
RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
@ -106,7 +106,7 @@ red_char_device_read_one_msg_from_device(RedCharDevice *dev)
static void
red_char_device_send_msg_to_client(RedCharDevice *dev,
PipeItem *msg,
RedPipeItem *msg,
RedClient *client)
{
RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
@ -190,7 +190,7 @@ static void red_char_device_client_free(RedCharDevice *dev,
dev_client->wait_for_tokens_timer = NULL;
}
g_queue_free_full(dev_client->send_queue, pipe_item_unref);
g_queue_free_full(dev_client->send_queue, red_pipe_item_unref);
/* remove write buffers that are associated with the client */
spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->priv->write_queue) && !dev->priv->cur_write_buf);
@ -278,7 +278,7 @@ static uint64_t red_char_device_max_send_tokens(RedCharDevice *dev)
}
static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_client,
PipeItem *msg)
RedPipeItem *msg)
{
RedCharDevice *dev = dev_client->dev;
@ -287,7 +287,7 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
return;
}
pipe_item_ref(msg);
red_pipe_item_ref(msg);
g_queue_push_head(dev_client->send_queue, msg);
if (!dev_client->wait_for_tokens_started) {
reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
@ -297,7 +297,7 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
}
static void red_char_device_send_msg_to_clients(RedCharDevice *dev,
PipeItem *msg)
RedPipeItem *msg)
{
RingItem *item, *next;
@ -343,7 +343,7 @@ static int red_char_device_read_from_device(RedCharDevice *dev)
* All messages will be discarded if no client is attached to the device
*/
while ((max_send_tokens || ring_is_empty(&dev->priv->clients)) && dev->priv->running) {
PipeItem *msg;
RedPipeItem *msg;
msg = red_char_device_read_one_msg_from_device(dev);
if (!msg) {
@ -356,7 +356,7 @@ static int red_char_device_read_from_device(RedCharDevice *dev)
}
did_read = TRUE;
red_char_device_send_msg_to_clients(dev, msg);
pipe_item_unref(msg);
red_pipe_item_unref(msg);
max_send_tokens--;
}
dev->priv->during_read_from_device = 0;
@ -371,12 +371,12 @@ static void red_char_device_client_send_queue_push(RedCharDeviceClient *dev_clie
{
while (!g_queue_is_empty(dev_client->send_queue) &&
red_char_device_can_send_to_client(dev_client)) {
PipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
RedPipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
g_assert(msg != NULL);
dev_client->num_send_tokens--;
red_char_device_send_msg_to_client(dev_client->dev, msg,
dev_client->client);
pipe_item_unref(msg);
red_pipe_item_unref(msg);
}
}
@ -851,7 +851,7 @@ void red_char_device_reset(RedCharDevice *dev)
dev_client = SPICE_CONTAINEROF(client_item, RedCharDeviceClient, link);
spice_debug("send_queue_empty %d", g_queue_is_empty(dev_client->send_queue));
dev_client->num_send_tokens += g_queue_get_length(dev_client->send_queue);
g_queue_foreach(dev_client->send_queue, (GFunc)pipe_item_unref, NULL);
g_queue_foreach(dev_client->send_queue, (GFunc)red_pipe_item_unref, NULL);
g_queue_clear(dev_client->send_queue);
}
red_char_device_reset_dev_instance(dev, NULL);

6
server/char-device.h
View File

@ -56,10 +56,10 @@ struct RedCharDeviceClass
/* reads from the device till reaching a msg that should be sent to the client,
* or till the reading fails */
PipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
void *opaque);
RedPipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
void *opaque);
/* after this call, the message is unreferenced */
void (*send_msg_to_client)(PipeItem *msg,
void (*send_msg_to_client)(RedPipeItem *msg,
RedClient *client,
void *opaque);

22
server/cursor-channel.c
View File

@ -46,7 +46,7 @@ typedef struct CursorItem {
G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
typedef struct CursorPipeItem {
PipeItem base;
RedPipeItem base;
CursorItem *cursor_item;
int refs;
} CursorPipeItem;
@ -132,11 +132,11 @@ static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
cursor->item = item ? cursor_item_ref(item) : NULL;
}
static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
{
CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
item->refs = 1;
item->cursor_item = data;
item->cursor_item->refs++;
@ -212,7 +212,7 @@ static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_
return;
}
spice_assert(!pipe_item_is_linked(&pipe_item->base));
spice_assert(!red_pipe_item_is_linked(&pipe_item->base));
cursor_item_unref(pipe_item->cursor_item);
free(pipe_item);
@ -229,7 +229,7 @@ static void cursor_channel_client_on_disconnect(RedChannelClient *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)
RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
@ -249,7 +249,7 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
}
static void cursor_channel_client_release_item_after_push(CursorChannelClient *ccc,
PipeItem *item)
RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
@ -263,7 +263,7 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
}
static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *base_marshaller,
PipeItem *pipe_item)
RedPipeItem *pipe_item)
{
CursorChannel *cursor_channel;
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@ -290,7 +290,7 @@ static void cursor_marshall(RedChannelClient *rcc,
CursorChannel *cursor_channel = 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;
RedPipeItem *pipe_item = &cursor_pipe_item->base;
RedCursorCmd *cmd;
spice_return_if_fail(cursor_channel);
@ -348,7 +348,7 @@ static inline void red_marshall_inval(RedChannelClient *rcc,
spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
}
static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item)
static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@ -389,7 +389,7 @@ static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
}
static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
CursorPipeItem *cursor_pipe_item;
@ -399,7 +399,7 @@ static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
cursor_pipe_item_ref(cursor_pipe_item);
}
static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
static void cursor_channel_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
CursorChannelClient *ccc = RCC_TO_CCC(rcc);

22
server/dcc-send.c
View File

@ -186,9 +186,9 @@ static int is_brush_lossy(RedChannelClient *rcc, SpiceBrush *brush,
}
}
static PipeItem *dcc_get_tail(DisplayChannelClient *dcc)
static RedPipeItem *dcc_get_tail(DisplayChannelClient *dcc)
{
return (PipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
return (RedPipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
}
static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
@ -596,15 +596,15 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
SpiceRect *surface_areas[],
int num_surfaces)
{
PipeItem *pipe_item;
RedPipeItem *pipe_item;
Ring *pipe;
spice_assert(num_surfaces);
pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
for (pipe_item = (PipeItem *)ring_get_head(pipe);
for (pipe_item = (RedPipeItem *)ring_get_head(pipe);
pipe_item;
pipe_item = (PipeItem *)ring_next(pipe, &pipe_item->link))
pipe_item = (RedPipeItem *)ring_next(pipe, &pipe_item->link))
{
Drawable *drawable;
@ -685,7 +685,7 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
int resent_surface_ids[MAX_PIPE_SIZE];
SpiceRect resent_areas[MAX_PIPE_SIZE]; // not pointers since drawables may be released
int num_resent;
PipeItem *pipe_item;
RedPipeItem *pipe_item;
Ring *pipe;
resent_surface_ids[0] = first_surface_id;
@ -695,9 +695,9 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
// going from the oldest to the newest
for (pipe_item = (PipeItem *)ring_get_tail(pipe);
for (pipe_item = (RedPipeItem *)ring_get_tail(pipe);
pipe_item;
pipe_item = (PipeItem *)ring_prev(pipe, &pipe_item->link)) {
pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
Drawable *drawable;
DrawablePipeItem *dpi;
ImageItem *image;
@ -2301,7 +2301,7 @@ static void marshall_stream_activate_report(RedChannelClient *rcc,
static void marshall_gl_scanout(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display_channel = DCC_TO_DC(dcc);
@ -2317,7 +2317,7 @@ static void marshall_gl_scanout(RedChannelClient *rcc,
static void marshall_gl_draw(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
@ -2360,7 +2360,7 @@ static void reset_send_data(DisplayChannelClient *dcc)
memset(dcc->send_data.free_list.sync, 0, sizeof(dcc->send_data.free_list.sync));
}
void dcc_send_item(DisplayChannelClient *dcc, PipeItem *pipe_item)
void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
{
RedChannelClient *rcc = RED_CHANNEL_CLIENT(dcc);
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);

58
server/dcc.c
View File

@ -38,7 +38,7 @@ static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
create->surface_create.flags = flags;
create->surface_create.format = format;
pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
return create;
}
@ -64,7 +64,7 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
int wait_if_used)
{
Ring *ring;
PipeItem *item;
RedPipeItem *item;
int x;
RedChannelClient *rcc;
@ -74,8 +74,8 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
rcc = RED_CHANNEL_CLIENT(dcc);
ring = &rcc->pipe;
item = (PipeItem *) ring;
while ((item = (PipeItem *)ring_next(ring, (RingItem *)item))) {
item = (RedPipeItem *) ring;
while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
Drawable *drawable;
DrawablePipeItem *dpi = NULL;
int depend_found = FALSE;
@ -90,11 +90,11 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
}
if (drawable->surface_id == surface_id) {
PipeItem *tmp_item = item;
item = (PipeItem *)ring_prev(ring, (RingItem *)item);
RedPipeItem *tmp_item = item;
item = (RedPipeItem *)ring_prev(ring, (RingItem *)item);
red_channel_client_pipe_remove_and_release(rcc, tmp_item);
if (!item) {
item = (PipeItem *)ring;
item = (RedPipeItem *)ring;
}
continue;
}
@ -163,7 +163,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
// adding the pipe item after pos. If pos == NULL, adding to head.
ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
SpiceRect *area, PipeItem *pos, int can_lossy)
SpiceRect *area, RedPipeItem *pos, int can_lossy)
{
DisplayChannel *display = DCC_TO_DC(dcc);
RedSurface *surface = &display->surfaces[surface_id];
@ -184,7 +184,7 @@ ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
item = (ImageItem *)spice_malloc_n_m(height, stride, sizeof(ImageItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
item->surface_id = surface_id;
item->image_format =
@ -274,7 +274,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
dcc_push_surface_image(dcc, drawable->surface_id);
}
void drawable_pipe_item_free(PipeItem *item)
void drawable_pipe_item_free(RedPipeItem *item)
{
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
spice_assert(item->refcount == 0);
@ -294,8 +294,8 @@ static DrawablePipeItem *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawa
dpi->dcc = dcc;
ring_item_init(&dpi->base);
ring_add(&drawable->pipes, &dpi->base);
pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
(GDestroyNotify)drawable_pipe_item_free);
red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
(GDestroyNotify)drawable_pipe_item_free);
drawable->refs++;
return dpi;
}
@ -316,7 +316,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
}
void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, PipeItem *pos)
void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, RedPipeItem *pos)
{
DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
@ -334,8 +334,8 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
agent->stream = &display->streams_buf[i];
region_init(&agent->vis_region);
region_init(&agent->clip);
pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
}
dcc->use_mjpeg_encoder_rate_control =
red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
@ -505,7 +505,7 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
item->rects->num_rects = n_rects;
region_ret_rects(&agent->clip, item->rects->rects, n_rects);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (PipeItem *)item);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem *)item);
}
static void monitors_config_item_free(MonitorsConfigItem *item)
@ -522,8 +522,8 @@ static MonitorsConfigItem *monitors_config_item_new(RedChannel* channel,
mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci->monitors_config = monitors_config;
pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
(GDestroyNotify)monitors_config_item_free);
red_pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
(GDestroyNotify)monitors_config_item_free);
return mci;
}
@ -556,12 +556,12 @@ static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel,
destroy = spice_malloc(sizeof(SurfaceDestroyItem));
destroy->surface_destroy.surface_id = surface_id;
pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
return destroy;
}
PipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
{
GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
@ -574,12 +574,12 @@ PipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
return NULL;
}
pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
return &item->base;
}
PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
const SpiceMsgDisplayGlDraw *draw = data;
@ -594,7 +594,7 @@ PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
dcc->gl_draw_ongoing = TRUE;
item->draw = *draw;
pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
return &item->base;
}
@ -1589,7 +1589,7 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
return TRUE;
}
static void release_item_after_push(PipeItem *item)
static void release_item_after_push(RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW:
@ -1597,7 +1597,7 @@ static void release_item_after_push(PipeItem *item)
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
case PIPE_ITEM_TYPE_UPGRADE:
pipe_item_unref(item);
red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
@ -1611,7 +1611,7 @@ static void release_item_after_push(PipeItem *item)
// TODO: share code between before/after_push since most of the items need the same
// release
static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
static void release_item_before_push(DisplayChannelClient *dcc, RedPipeItem *item)
{
DisplayChannel *display = DCC_TO_DC(dcc);
@ -1620,7 +1620,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
case PIPE_ITEM_TYPE_DRAW: {
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
ring_remove(&dpi->base);
pipe_item_unref(item);
red_pipe_item_unref(item);
break;
}
case PIPE_ITEM_TYPE_STREAM_CREATE: {
@ -1637,7 +1637,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
case PIPE_ITEM_TYPE_UPGRADE:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
pipe_item_unref(item);
red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_CREATE_SURFACE: {
SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, SurfaceCreateItem,
@ -1667,7 +1667,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
}
}
void dcc_release_item(DisplayChannelClient *dcc, PipeItem *item, int item_pushed)
void dcc_release_item(DisplayChannelClient *dcc, RedPipeItem *item, int item_pushed)
{
if (item_pushed)
release_item_after_push(item);

22
server/dcc.h
View File

@ -123,20 +123,20 @@ struct DisplayChannelClient {
typedef struct SurfaceCreateItem {
SpiceMsgSurfaceCreate surface_create;
PipeItem pipe_item;
RedPipeItem pipe_item;
} SurfaceCreateItem;
typedef struct GlScanoutUnixItem {
PipeItem base;
RedPipeItem base;
} GlScanoutUnixItem;
typedef struct GlDrawItem {
PipeItem base;
RedPipeItem base;
SpiceMsgDisplayGlDraw draw;
} GlDrawItem;
typedef struct ImageItem {
PipeItem base;
RedPipeItem base;
SpicePoint pos;
int width;
int height;
@ -151,7 +151,7 @@ typedef struct ImageItem {
typedef struct DrawablePipeItem {
RingItem base; /* link for a list of pipe items held by Drawable */
PipeItem dpi_pipe_item; /* link for the client's pipe itself */
RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
Drawable *drawable;
DisplayChannelClient *dcc;
uint8_t refs;
@ -189,7 +189,7 @@ void dcc_push_surface_image (DisplayCha
ImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
PipeItem *pos,
RedPipeItem *pos,
int can_lossy);
void dcc_palette_cache_reset (DisplayChannelClient *dcc);
void dcc_palette_cache_palette (DisplayChannelClient *dcc,
@ -203,20 +203,20 @@ void dcc_append_drawable (DisplayCha
Drawable *drawable);
void dcc_add_drawable_after (DisplayChannelClient *dcc,
Drawable *drawable,
PipeItem *pos);
RedPipeItem *pos);
void dcc_release_item (DisplayChannelClient *dcc,
PipeItem *item,
RedPipeItem *item,
int item_pushed);
void dcc_send_item (DisplayChannelClient *dcc,
PipeItem *item);
RedPipeItem *item);
int dcc_clear_surface_drawables_from_pipe (DisplayChannelClient *dcc,
int surface_id,
int wait_if_used);
int dcc_drawable_is_in_pipe (DisplayChannelClient *dcc,
Drawable *drawable);
PipeItem * dcc_gl_scanout_item_new (RedChannelClient *rcc,
RedPipeItem * dcc_gl_scanout_item_new (RedChannelClient *rcc,
void *data, int num);
PipeItem * dcc_gl_draw_item_new (RedChannelClient *rcc,
RedPipeItem * dcc_gl_draw_item_new (RedChannelClient *rcc,
void *data, int num);
typedef struct compress_send_data_t {

10
server/display-channel.c
View File

@ -401,7 +401,7 @@ static void drawable_remove_from_pipes(Drawable *drawable)
RING_FOREACH_SAFE(item, next, &drawable->pipes) {
dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi->dcc),
&dpi->dpi_pipe_item);
}
@ -1958,12 +1958,12 @@ static void on_disconnect(RedChannelClient *rcc)
display->glz_drawable_count);
}
static void send_item(RedChannelClient *rcc, PipeItem *item)
static void send_item(RedChannelClient *rcc, RedPipeItem *item)
{
dcc_send_item(RCC_TO_DCC(rcc), item);
}
static void hold_item(RedChannelClient *rcc, PipeItem *item)
static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
{
spice_return_if_fail(item);
@ -1972,14 +1972,14 @@ static void hold_item(RedChannelClient *rcc, PipeItem *item)
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
pipe_item_ref(item);
red_pipe_item_ref(item);
break;
default:
spice_warn_if_reached();
}
}
static void release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
static void release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);

8
server/display-channel.h
View File

@ -58,7 +58,7 @@ struct Drawable {
RingItem list_link;
DrawItem tree_item;
Ring pipes;
PipeItem *pipe_item_rest;
RedPipeItem *pipe_item_rest;
uint32_t size_pipe_item_rest;
RedDrawable *red_drawable;
@ -120,7 +120,7 @@ typedef struct MonitorsConfig {
} MonitorsConfig;
typedef struct MonitorsConfigItem {
PipeItem pipe_item;
RedPipeItem pipe_item;
MonitorsConfig *monitors_config;
} MonitorsConfigItem;
@ -242,11 +242,11 @@ static inline int get_stream_id(DisplayChannel *display, Stream *stream)
typedef struct SurfaceDestroyItem {
SpiceMsgSurfaceDestroy surface_destroy;
PipeItem pipe_item;
RedPipeItem pipe_item;
} SurfaceDestroyItem;
typedef struct UpgradeItem {
PipeItem base;
RedPipeItem base;
Drawable *drawable;
SpiceClipRects *rects;
} UpgradeItem;

20
server/inputs-channel.c
View File

@ -123,16 +123,16 @@ enum {
};
typedef struct InputsPipeItem {
PipeItem base;
RedPipeItem base;
} InputsPipeItem;
typedef struct KeyModifiersPipeItem {
PipeItem base;
RedPipeItem base;
uint8_t modifiers;
} KeyModifiersPipeItem;
typedef struct InputsInitPipeItem {
PipeItem base;
RedPipeItem base;
uint8_t modifiers;
} InputsInitPipeItem;
@ -229,19 +229,19 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
return sif->get_leds(sin);
}
static PipeItem *inputs_key_modifiers_item_new(
static RedPipeItem *inputs_key_modifiers_item_new(
RedChannelClient *rcc, void *data, int num)
{
KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
item->modifiers = *(uint8_t *)data;
return &item->base;
}
static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
@ -255,12 +255,12 @@ static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
}
static void inputs_channel_release_pipe_item(RedChannelClient *rcc,
PipeItem *base, int item_pushed)
RedPipeItem *base, int item_pushed)
{
free(base);
}
static void inputs_channel_send_item(RedChannelClient *rcc, PipeItem *base)
static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@ -503,7 +503,7 @@ static void inputs_pipe_add_init(RedChannelClient *rcc)
InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
red_channel_client_pipe_add_push(rcc, &item->base);
}
@ -524,7 +524,7 @@ static int inputs_channel_config_socket(RedChannelClient *rcc)
return TRUE;
}
static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
}

97
server/main-channel.c
View File

@ -79,28 +79,28 @@ enum {
};
typedef struct RefsPipeItem {
PipeItem base;
RedPipeItem base;
int *refs;
} RefsPipeItem;
typedef struct PingPipeItem {
PipeItem base;
RedPipeItem base;
int size;
} PingPipeItem;
typedef struct MouseModePipeItem {
PipeItem base;
RedPipeItem base;
int current_mode;
int is_client_mouse_allowed;
} MouseModePipeItem;
typedef struct TokensPipeItem {
PipeItem base;
RedPipeItem base;
int tokens;
} TokensPipeItem;
typedef struct AgentDataPipeItem {
PipeItem base;
RedPipeItem base;
uint8_t* data;
size_t len;
spice_marshaller_item_free_func free_data;
@ -108,7 +108,7 @@ typedef struct AgentDataPipeItem {
} AgentDataPipeItem;
typedef struct InitPipeItem {
PipeItem base;
RedPipeItem base;
int connection_id;
int display_channels_hint;
int current_mouse_mode;
@ -118,22 +118,22 @@ typedef struct InitPipeItem {
} InitPipeItem;
typedef struct NamePipeItem {
PipeItem base;
RedPipeItem base;
SpiceMsgMainName msg;
} NamePipeItem;
typedef struct UuidPipeItem {
PipeItem base;
RedPipeItem base;
SpiceMsgMainUuid msg;
} UuidPipeItem;
typedef struct NotifyPipeItem {
PipeItem base;
RedPipeItem base;
char *msg;
} NotifyPipeItem;
typedef struct MultiMediaTimePipeItem {
PipeItem base;
RedPipeItem base;
int time;
} MultiMediaTimePipeItem;
@ -166,7 +166,7 @@ enum NetTestStage {
};
static void main_channel_release_pipe_item(RedChannelClient *rcc,
PipeItem *base, int item_pushed);
RedPipeItem *base, int item_pushed);
int main_channel_is_connected(MainChannel *main_chan)
{
@ -221,42 +221,42 @@ typedef struct MainMouseModeItemInfo {
int is_client_mouse_allowed;
} MainMouseModeItemInfo;
static PipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
{
MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
MainMouseModeItemInfo *info = data;
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
item->current_mode = info->current_mode;
item->is_client_mouse_allowed = info->is_client_mouse_allowed;
return &item->base;
}
static PipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
{
PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
item->size = size;
return &item->base;
}
static PipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
{
TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
item->tokens = num_tokens;
return &item->base;
}
static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data,
void *opaque)
static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data,
void *opaque)
{
AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
item->data = data;
item->len = len;
item->free_data = free_data;
@ -264,14 +264,14 @@ static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data,
return &item->base;
}
static PipeItem *main_init_item_new(MainChannelClient *mcc,
static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
int connection_id, int display_channels_hint, int current_mouse_mode,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
item->connection_id = connection_id;
item->display_channels_hint = display_channels_hint;
item->current_mouse_mode = current_mouse_mode;
@ -281,44 +281,44 @@ static PipeItem *main_init_item_new(MainChannelClient *mcc,
return &item->base;
}
static PipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
{
NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
item->msg.name_len = strlen(name) + 1;
memcpy(&item->msg.name, name, item->msg.name_len);
return &item->base;
}
static PipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
{
UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
return &item->base;
}
static PipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
{
NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
const char *msg = data;
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
item->msg = spice_strdup(msg);
return &item->base;
}
static PipeItem *main_multi_media_time_item_new(
static RedPipeItem *main_multi_media_time_item_new(
RedChannelClient *rcc, void *data, int num)
{
MultiMediaTimePipeItem *item, *info = data;
item = spice_malloc(sizeof(MultiMediaTimePipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item->time = info->time;
return &item->base;
}
@ -335,7 +335,7 @@ static void main_channel_push_channels(MainChannelClient *mcc)
static void main_channel_marshall_channels(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgChannels* channels_info;
@ -349,7 +349,7 @@ static void main_channel_marshall_channels(RedChannelClient *rcc,
int main_channel_client_push_ping(MainChannelClient *mcc, int size)
{
PipeItem *item;
RedPipeItem *item;
if (mcc == NULL) {
return FALSE;
@ -417,7 +417,7 @@ void main_channel_push_agent_connected(MainChannel *main_chan)
static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgMainAgentConnectedTokens connected;
@ -433,7 +433,7 @@ void main_channel_push_agent_disconnected(MainChannel *main_chan)
static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgMainAgentDisconnect disconnect;
@ -444,7 +444,7 @@ static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
{
PipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
RedPipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
red_channel_client_pipe_add_push(&mcc->base, item);
}
@ -462,7 +462,7 @@ static void main_channel_marshall_tokens(RedChannelClient *rcc,
void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data, void *opaque)
{
PipeItem *item;
RedPipeItem *item;
item = main_agent_data_item_new(&mcc->base, data, len, free_data, opaque);
red_channel_client_pipe_add_push(&mcc->base, item);
@ -482,7 +482,8 @@ static void main_channel_push_migrate_data_item(MainChannel *main_chan)
}
static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
SpiceMarshaller *m, PipeItem *item)
SpiceMarshaller *m,
RedPipeItem *item)
{
red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
reds_marshall_migrate_data(rcc->channel->reds, m); // TODO: from reds split. ugly separation.
@ -515,7 +516,7 @@ void main_channel_push_init(MainChannelClient *mcc,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
PipeItem *item;
RedPipeItem *item;
item = main_init_item_new(mcc,
mcc->connection_id, display_channels_hint, current_mouse_mode,
@ -547,7 +548,7 @@ static void main_channel_marshall_init(RedChannelClient *rcc,
void main_channel_push_name(MainChannelClient *mcc, const char *name)
{
PipeItem *item;
RedPipeItem *item;
if (!red_channel_client_test_remote_cap(&mcc->base,
SPICE_MAIN_CAP_NAME_AND_UUID))
@ -559,7 +560,7 @@ void main_channel_push_name(MainChannelClient *mcc, const char *name)
void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
{
PipeItem *item;
RedPipeItem *item;
if (!red_channel_client_test_remote_cap(&mcc->base,
SPICE_MAIN_CAP_NAME_AND_UUID))
@ -571,7 +572,7 @@ void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
{
PipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
RedPipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
red_channel_client_pipe_add_push(&mcc->base, item);
}
@ -608,7 +609,7 @@ static void main_channel_fill_migrate_dst_info(MainChannel *main_channel,
}
static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgMainMigrationBegin migrate;
MainChannel *main_ch;
@ -621,7 +622,7 @@ static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelCl
static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgMainMigrateBeginSeamless migrate_seamless;
MainChannel *main_ch;
@ -665,7 +666,7 @@ void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_targe
}
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
SpiceMsgMainMigrationSwitchHost migrate;
MainChannel *main_ch;
@ -698,7 +699,7 @@ static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
spice_marshall_msg_main_multi_media_time(m, &time_mes);
}
static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
{
MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@ -783,7 +784,7 @@ static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
}
static void main_channel_release_pipe_item(RedChannelClient *rcc,
PipeItem *base, int item_pushed)
RedPipeItem *base, int item_pushed)
{
switch (base->type) {
case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
@ -1022,7 +1023,7 @@ static int main_channel_config_socket(RedChannelClient *rcc)
return TRUE;
}
static void main_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
static void main_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
}

55
server/red-channel.c
View File

@ -45,7 +45,7 @@
#include "utils.h"
typedef struct EmptyMsgPipeItem {
PipeItem base;
RedPipeItem base;
int msg;
} EmptyMsgPipeItem;
@ -510,7 +510,7 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc)
}
static void red_channel_client_send_empty_msg(RedChannelClient *rcc, PipeItem *base)
static void red_channel_client_send_empty_msg(RedChannelClient *rcc, RedPipeItem *base)
{
EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, EmptyMsgPipeItem, base);
@ -557,7 +557,7 @@ static void red_channel_client_send_ping(RedChannelClient *rcc)
red_channel_client_begin_send_message(rcc);
}
static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item)
static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *item)
{
spice_assert(red_channel_client_no_item_being_sent(rcc));
red_channel_client_reset_send_data(rcc);
@ -581,7 +581,7 @@ static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item)
free(item);
}
static void red_channel_client_release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
static void red_channel_client_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
switch (item->type) {
case PIPE_ITEM_TYPE_SET_ACK:
@ -643,7 +643,7 @@ static void red_channel_peer_on_out_msg_done(void *opaque)
}
static void red_channel_client_pipe_remove(RedChannelClient *rcc, PipeItem *item)
static void red_channel_client_pipe_remove(RedChannelClient *rcc, RedPipeItem *item)
{
rcc->pipe_size--;
ring_remove(&item->link);
@ -1324,13 +1324,13 @@ static inline int red_channel_client_waiting_for_ack(RedChannelClient *rcc)
(rcc->ack_data.messages_window > rcc->ack_data.client_window * 2));
}
static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
static inline RedPipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
{
PipeItem *item;
RedPipeItem *item;
if (!rcc || rcc->send_data.blocked
|| red_channel_client_waiting_for_ack(rcc)
|| !(item = (PipeItem *)ring_get_tail(&rcc->pipe))) {
|| !(item = (RedPipeItem *)ring_get_tail(&rcc->pipe))) {
return NULL;
}
red_channel_client_pipe_remove(rcc, item);
@ -1339,7 +1339,7 @@ static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
void red_channel_client_push(RedChannelClient *rcc)
{
PipeItem *pipe_item;
RedPipeItem *pipe_item;
if (!rcc->during_send) {
rcc->during_send = TRUE;
@ -1589,7 +1589,7 @@ static void red_channel_client_event(int fd, int event, void *data)
red_channel_client_unref(rcc);
}
void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, PipeItem *item)
void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, RedPipeItem *item)
{
spice_assert(red_channel_client_no_item_being_sent(rcc));
spice_assert(msg_type != 0);
@ -1658,7 +1658,7 @@ void red_channel_client_set_message_serial(RedChannelClient *rcc, uint64_t seria
rcc->send_data.serial = serial;
}
static inline gboolean client_pipe_add(RedChannelClient *rcc, PipeItem *item, RingItem *pos)
static inline gboolean client_pipe_add(RedChannelClient *rcc, RedPipeItem *item, RingItem *pos)
{
spice_assert(rcc && item);
if (SPICE_UNLIKELY(!red_channel_client_is_connected(rcc))) {
@ -1676,38 +1676,39 @@ static inline gboolean client_pipe_add(RedChannelClient *rcc, PipeItem *item, Ri
return TRUE;
}
void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item)
void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem *item)
{
client_pipe_add(rcc, item, &rcc->pipe);
}
void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item)
void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item)
{
red_channel_client_pipe_add(rcc, item);
red_channel_client_push(rcc);
}
void red_channel_client_pipe_add_after(RedChannelClient *rcc,
PipeItem *item, PipeItem *pos)
RedPipeItem *item,
RedPipeItem *pos)
{
spice_assert(pos);
client_pipe_add(rcc, item, &pos->link);
}
int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
return ring_item_is_linked(&item->link);
}
void red_channel_client_pipe_add_tail(RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
client_pipe_add(rcc, item, rcc->pipe.prev);
}
void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *item)
void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, RedPipeItem *item)
{
if (client_pipe_add(rcc, item, rcc->pipe.prev)) {
red_channel_client_push(rcc);
@ -1716,9 +1717,9 @@ void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *
void red_channel_client_pipe_add_type(RedChannelClient *rcc, int pipe_item_type)
{
PipeItem *item = spice_new(PipeItem, 1);
RedPipeItem *item = spice_new(RedPipeItem, 1);
pipe_item_init(item, pipe_item_type);
red_pipe_item_init(item, pipe_item_type);
red_channel_client_pipe_add(rcc, item);
red_channel_client_push(rcc);
}
@ -1738,7 +1739,7 @@ void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
{
EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
item->msg = msg_type;
red_channel_client_pipe_add(rcc, &item->base);
red_channel_client_push(rcc);
@ -1781,12 +1782,12 @@ void red_channel_client_clear_sent_item(RedChannelClient *rcc)
void red_channel_client_pipe_clear(RedChannelClient *rcc)
{
PipeItem *item;
RedPipeItem *item;
if (rcc) {
red_channel_client_clear_sent_item(rcc);
}
while ((item = (PipeItem *)ring_get_head(&rcc->pipe))) {
while ((item = (RedPipeItem *)ring_get_head(&rcc->pipe))) {
ring_remove(&item->link);
red_channel_client_release_item(rcc, item, FALSE);
}
@ -2029,7 +2030,7 @@ int red_channel_client_no_item_being_sent(RedChannelClient *rcc)
}
void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
red_channel_client_pipe_remove(rcc, item);
red_channel_client_release_item(rcc, item, FALSE);
@ -2231,8 +2232,8 @@ int red_client_during_migrate_at_target(RedClient *client)
* TODO - inline? macro? right now this is the simplest from code amount
*/
typedef void (*rcc_item_t)(RedChannelClient *rcc, PipeItem *item);
typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, PipeItem *item);
typedef void (*rcc_item_t)(RedChannelClient *rcc, RedPipeItem *item);
typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, RedPipeItem *item);
/**
* red_channel_pipes_create_batch:
@ -2249,7 +2250,7 @@ static int red_channel_pipes_create_batch(RedChannel *channel,
{
RingItem *link, *next;
RedChannelClient *rcc;
PipeItem *item;
RedPipeItem *item;
int num = 0, n = 0;
spice_assert(creator != NULL);
@ -2362,7 +2363,7 @@ int red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
/* TODO: more evil sync stuff. anything with the word wait in it's name. */
int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
PipeItem *item,
RedPipeItem *item,
int64_t timeout)
{
uint64_t end_time;

30
server/red-channel.h
View File

@ -158,10 +158,10 @@ typedef void (*channel_release_msg_recv_buf_proc)(RedChannelClient *channel,
uint16_t type, uint32_t size, uint8_t *msg);
typedef void (*channel_disconnect_proc)(RedChannelClient *rcc);
typedef int (*channel_configure_socket_proc)(RedChannelClient *rcc);
typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc, PipeItem *item);
typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc, PipeItem *item);
typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc, RedPipeItem *item);
typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc, RedPipeItem *item);
typedef void (*channel_release_pipe_item_proc)(RedChannelClient *rcc,
PipeItem *item, int item_pushed);
RedPipeItem *item, int item_pushed);
typedef void (*channel_on_incoming_error_proc)(RedChannelClient *rcc);
typedef void (*channel_on_outgoing_error_proc)(RedChannelClient *rcc);
@ -258,7 +258,7 @@ struct RedChannelClient {
SpiceMarshaller *marshaller;
SpiceDataHeaderOpaque header;
uint32_t size;
PipeItem *item;
RedPipeItem *item;
int blocked;
uint64_t serial;
uint64_t last_sent_serial;
@ -266,7 +266,7 @@ struct RedChannelClient {
struct {
SpiceMarshaller *marshaller;
uint8_t *header_data;
PipeItem *item;
RedPipeItem *item;
} main;
struct {
@ -434,7 +434,7 @@ int red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size,
uint16_t type, void *message);
/* when preparing send_data: should call init and then use marshaller */
void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, PipeItem *item);
void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, RedPipeItem *item);
uint64_t red_channel_client_get_message_serial(RedChannelClient *channel);
void red_channel_client_set_message_serial(RedChannelClient *channel, uint64_t);
@ -465,20 +465,20 @@ int red_channel_client_get_roundtrip_ms(RedChannelClient *rcc);
void red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uint32_t timeout_ms);
// TODO: add back the channel_pipe_add functionality - by adding reference counting
// to the PipeItem.
// to the RedPipeItem.
// helper to push a new item to all channels
typedef PipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data, int num);
typedef RedPipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data, int num);
int red_channel_pipes_new_add_push(RedChannel *channel, new_pipe_item_t creator, void *data);
void red_channel_pipes_new_add(RedChannel *channel, new_pipe_item_t creator, void *data);
void red_channel_pipes_new_add_tail(RedChannel *channel, new_pipe_item_t creator, void *data);
void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item);
void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item);
void red_channel_client_pipe_add_after(RedChannelClient *rcc, PipeItem *item, PipeItem *pos);
int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc, PipeItem *item);
void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc, PipeItem *item);
void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *item);
void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem *item);
void red_channel_client_pipe_add_after(RedChannelClient *rcc, RedPipeItem *item, RedPipeItem *pos);
int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc, RedPipeItem *item);
void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc, RedPipeItem *item);
void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, RedPipeItem *item);
/* for types that use this routine -> the pipe item should be freed */
void red_channel_client_pipe_add_type(RedChannelClient *rcc, int pipe_item_type);
void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type);
@ -619,7 +619,7 @@ void red_client_migrate(RedClient *client);
*/
int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
PipeItem *item,
RedPipeItem *item,
int64_t timeout);
int red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
int64_t timeout);

14
server/red-pipe-item.c
View File

@ -20,9 +20,9 @@
#include "red-channel.h"
#include "red-pipe-item.h"
PipeItem *pipe_item_ref(gpointer object)
RedPipeItem *red_pipe_item_ref(gpointer object)
{
PipeItem *item = object;
RedPipeItem *item = object;
g_return_val_if_fail(item->refcount > 0, NULL);
@ -31,9 +31,9 @@ PipeItem *pipe_item_ref(gpointer object)
return item;
}
void pipe_item_unref(gpointer object)
void red_pipe_item_unref(gpointer object)
{
PipeItem *item = object;
RedPipeItem *item = object;
g_return_if_fail(item->refcount > 0);
@ -42,9 +42,9 @@ void pipe_item_unref(gpointer object)
}
}
void pipe_item_init_full(PipeItem *item,
gint type,
GDestroyNotify free_func)
void red_pipe_item_init_full(RedPipeItem *item,
gint type,
GDestroyNotify free_func)
{
ring_item_init(&item->link);
item->type = type;

14
server/red-pipe-item.h
View File

@ -28,19 +28,19 @@ typedef struct {
int refcount;
GDestroyNotify free_func;
} PipeItem;
} RedPipeItem;
void pipe_item_init_full(PipeItem *item, int type, GDestroyNotify free_func);
PipeItem *pipe_item_ref(gpointer item);
void pipe_item_unref(gpointer item);
void red_pipe_item_init_full(RedPipeItem *item, int type, GDestroyNotify free_func);
RedPipeItem *red_pipe_item_ref(gpointer item);
void red_pipe_item_unref(gpointer item);
static inline int pipe_item_is_linked(PipeItem *item)
static inline int red_pipe_item_is_linked(RedPipeItem *item)
{
return ring_item_is_linked(&item->link);
}
static inline void pipe_item_init(PipeItem *item, int type)
static inline void red_pipe_item_init(RedPipeItem *item, int type)
{
pipe_item_init_full(item, type, NULL);
red_pipe_item_init_full(item, type, NULL);
}
#endif

4
server/red-worker.h
View File

@ -57,7 +57,7 @@ enum {
};
typedef struct VerbItem {
PipeItem base;
RedPipeItem base;
uint16_t verb;
} VerbItem;
@ -70,7 +70,7 @@ static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
{
VerbItem *item = spice_new(VerbItem, 1);
pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
item->verb = verb;
red_channel_client_pipe_add(rcc, &item->base);
}

26
server/reds.c
View File

@ -167,7 +167,7 @@ struct ChannelSecurityOptions {
};
typedef struct VDIReadBuf {
PipeItem parent;
RedPipeItem parent;
RedCharDeviceVDIPort *dev;
int len;
@ -482,7 +482,7 @@ static void reds_reset_vdp(RedsState *reds)
dev->priv->receive_len = sizeof(dev->priv->vdi_chunk_header);
dev->priv->message_receive_len = 0;
if (dev->priv->current_read_buf) {
pipe_item_unref(dev->priv->current_read_buf);
red_pipe_item_unref(dev->priv->current_read_buf);
dev->priv->current_read_buf = NULL;
}
/* Reset read filter to start with clean state when the agent reconnects */
@ -705,7 +705,7 @@ static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
VDIReadBuf *buf = (VDIReadBuf *)opaque;
pipe_item_unref(buf);
red_pipe_item_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
@ -744,8 +744,8 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
/* Bogus pipe item type, we only need the RingItem and refcounting
* from the base class and are not going to use the type
*/
pipe_item_init_full(&buf->parent, -1,
(GDestroyNotify)vdi_port_read_buf_free);
red_pipe_item_init_full(&buf->parent, -1,
(GDestroyNotify)vdi_port_read_buf_free);
}
static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
@ -782,8 +782,8 @@ static void vdi_port_read_buf_free(VDIReadBuf *buf)
/* reads from the device till completes reading a message that is addressed to the client,
* or otherwise, when reading from the device fails */
static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
void *opaque)
static RedPipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
void *opaque)
{
RedsState *reds;
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
@ -843,12 +843,12 @@ static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
dev->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
}
if (vdi_port_read_buf_process(reds->agent_dev, dispatch_buf, &error)) {
return (PipeItem *)dispatch_buf;
return (RedPipeItem *)dispatch_buf;
} else {
if (error) {
reds_agent_remove(reds);
}
pipe_item_unref(dispatch_buf);
red_pipe_item_unref(dispatch_buf);
}
}
} /* END switch */
@ -857,13 +857,13 @@ static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
}
/* after calling this, we unref the message, and the ref is in the instance side */
static void vdi_port_send_msg_to_client(PipeItem *msg,
static void vdi_port_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
pipe_item_ref(agent_data_buf);
red_pipe_item_ref(agent_data_buf);
main_channel_client_push_agent_data(red_client_get_main(client),
agent_data_buf->data,
agent_data_buf->len,
@ -1218,7 +1218,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
if (error) {
reds_agent_remove(reds);
}
pipe_item_unref(read_buf);
red_pipe_item_unref(read_buf);
}
spice_assert(agent_dev->priv->receive_len);
@ -4297,7 +4297,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort *self)
/* This ensures the newly created buffer is placed in the
* RedCharDeviceVDIPort::read_bufs queue ready to be reused
*/
pipe_item_unref(buf);
red_pipe_item_unref(buf);
}
}

42
server/smartcard.c
View File

@ -83,19 +83,19 @@ enum {
};
typedef struct ErrorItem {
PipeItem base;
RedPipeItem base;
VSCMsgHeader vheader;
VSCMsgError error;
} ErrorItem;
typedef struct MsgItem {
PipeItem base;
RedPipeItem base;
VSCMsgHeader* vheader;
} MsgItem;
static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item);
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
typedef struct SmartCardChannel {
RedChannel base;
@ -129,8 +129,8 @@ static void smartcard_read_buf_prepare(RedCharDeviceSmartcard *dev, VSCMsgHeader
}
}
static PipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
void *opaque)
static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
void *opaque)
{
RedCharDeviceSmartcard *dev = opaque;
SpiceCharDeviceInterface *sif = spice_char_device_get_interface(sin);
@ -160,19 +160,19 @@ static PipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
dev->priv->buf_pos = dev->priv->buf;
dev->priv->buf_used = remaining;
if (msg_to_client) {
return (PipeItem *)msg_to_client;
return (RedPipeItem *)msg_to_client;
}
}
return NULL;
}
static void smartcard_send_msg_to_client(PipeItem *msg,
static void smartcard_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
RedCharDeviceSmartcard *dev = opaque;
spice_assert(dev->priv->scc && dev->priv->scc->base.client == client);
smartcard_channel_client_pipe_add_push(&dev->priv->scc->base, (PipeItem *)msg);
smartcard_channel_client_pipe_add_push(&dev->priv->scc->base, (RedPipeItem *)msg);
}
@ -427,7 +427,7 @@ static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
}
static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *m,
PipeItem *item, VSCMsgHeader *vheader)
RedPipeItem *item, VSCMsgHeader *vheader)
{
spice_assert(rcc);
spice_assert(vheader);
@ -439,7 +439,7 @@ static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *
}
static void smartcard_channel_send_error(
RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item)
RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
{
ErrorItem* error_item = (ErrorItem*)item;
@ -447,7 +447,7 @@ static void smartcard_channel_send_error(
}
static void smartcard_channel_send_msg(RedChannelClient *rcc,
SpiceMarshaller *m, PipeItem *item)
SpiceMarshaller *m, RedPipeItem *item)
{
MsgItem* msg_item = (MsgItem*)item;
@ -455,7 +455,7 @@ static void smartcard_channel_send_msg(RedChannelClient *rcc,
}
static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
SpiceMarshaller *m, PipeItem *item)
SpiceMarshaller *m, RedPipeItem *item)
{
SmartCardChannelClient *scc;
RedCharDeviceSmartcard *dev;
@ -483,7 +483,7 @@ static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
}
}
static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem *item)
static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@ -506,10 +506,10 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem *item)
}
static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
PipeItem *item, int item_pushed)
RedPipeItem *item, int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
pipe_item_unref(item);
red_pipe_item_unref(item);
} else {
free(item);
}
@ -530,7 +530,8 @@ static void smartcard_channel_on_disconnect(RedChannelClient *rcc)
/* this is called from both device input and client input. since the device is
* a usb device, the context is still the main thread (kvm_main_loop, timers)
* so no mutex is required. */
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item)
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
RedPipeItem *item)
{
red_channel_client_pipe_add_push(rcc, item);
}
@ -539,7 +540,7 @@ static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCE
{
ErrorItem *error_item = spice_new0(ErrorItem, 1);
pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
red_pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
error_item->base.type = PIPE_ITEM_TYPE_ERROR;
error_item->vheader.reader_id = reader_id;
@ -559,8 +560,8 @@ static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *
{
MsgItem *msg_item = spice_new0(MsgItem, 1);
pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
(GDestroyNotify)smartcard_free_vsc_msg_item);
red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
(GDestroyNotify)smartcard_free_vsc_msg_item);
msg_item->vheader = vheader;
return msg_item;
}
@ -747,7 +748,8 @@ static int smartcard_channel_handle_message(RedChannelClient *rcc,
return TRUE;
}
static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc,
RedPipeItem *item)
{
}

41
server/spicevmc.c
View File

@ -43,7 +43,7 @@
#define BUF_SIZE (64 * 1024 + 32)
typedef struct SpiceVmcPipeItem {
PipeItem base;
RedPipeItem base;
/* writes which don't fit this will get split, this is not a problem */
uint8_t buf[BUF_SIZE];
@ -88,13 +88,13 @@ static RedCharDevice *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc, RED_TYPE_CHAR_DEVICE)
typedef struct PortInitPipeItem {
PipeItem base;
RedPipeItem base;
char* name;
uint8_t opened;
} PortInitPipeItem;
typedef struct PortEventPipeItem {
PipeItem base;
RedPipeItem base;
uint8_t event;
} PortEventPipeItem;
@ -105,8 +105,8 @@ enum {
PIPE_ITEM_TYPE_PORT_EVENT,
};
static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
void *opaque)
static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
void *opaque)
{
SpiceVmcState *state = opaque;
SpiceCharDeviceInterface *sif;
@ -121,7 +121,7 @@ static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
if (!state->pipe_item) {
msg_item = spice_new0(SpiceVmcPipeItem, 1);
pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
red_pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
} else {
spice_assert(state->pipe_item->buf_used == 0);
msg_item = state->pipe_item;
@ -133,14 +133,14 @@ static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
if (n > 0) {
spice_debug("read from dev %d", n);
msg_item->buf_used = n;
return (PipeItem *)msg_item;
return (RedPipeItem *)msg_item;
} else {
state->pipe_item = msg_item;
return NULL;
}
}
static void spicevmc_chardev_send_msg_to_client(PipeItem *msg,
static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
@ -148,8 +148,8 @@ static void spicevmc_chardev_send_msg_to_client(PipeItem *msg,
SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
spice_assert(state->rcc->client == client);
pipe_item_ref(vmc_msg);
red_channel_client_pipe_add_push(state->rcc, (PipeItem *)vmc_msg);
red_pipe_item_ref(vmc_msg);
red_channel_client_pipe_add_push(state->rcc, (RedPipeItem *)vmc_msg);
}
static void spicevmc_port_send_init(RedChannelClient *rcc)
@ -158,7 +158,7 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
SpiceCharDeviceInstance *sin = state->chardev_sin;
PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
item->name = strdup(sin->portname);
item->opened = state->port_opened;
red_channel_client_pipe_add_push(rcc, &item->base);
@ -168,7 +168,7 @@ static void spicevmc_port_send_event(RedChannelClient *rcc, uint8_t event)
{
PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
item->event = event;
red_channel_client_pipe_add_push(rcc, &item->base);
}
@ -360,14 +360,14 @@ static void spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
}
static void spicevmc_red_channel_hold_pipe_item(RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
/* NOOP */
}
static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
@ -377,7 +377,7 @@ static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
SpiceVmcState *state;
@ -391,7 +391,7 @@ static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
SpiceMsgPortInit init;
@ -405,7 +405,7 @@ static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
SpiceMarshaller *m,
PipeItem *item)
RedPipeItem *item)
{
PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem, base);
SpiceMsgPortEvent event;
@ -416,7 +416,7 @@ static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
}
static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
PipeItem *item)
RedPipeItem *item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@ -442,10 +442,11 @@ static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
}
static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
PipeItem *item, int item_pushed)
RedPipeItem *item,
int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
pipe_item_unref(item);
red_pipe_item_unref(item);
} else {
free(item);
}

16
server/stream.c
View File

@ -78,7 +78,7 @@ void stream_stop(DisplayChannel *display, Stream *stream)
stream_agent = &dcc->stream_agents[get_stream_id(display, stream)];
region_clear(&stream_agent->vis_region);
region_clear(&stream_agent->clip);
spice_assert(!pipe_item_is_linked(&stream_agent->destroy_item));
spice_assert(!red_pipe_item_is_linked(&stream_agent->destroy_item));
if (stream_agent->mjpeg_encoder && dcc->use_mjpeg_encoder_rate_control) {
uint64_t stream_bit_rate = mjpeg_encoder_get_bit_rate(stream_agent->mjpeg_encoder);
@ -148,8 +148,8 @@ void stream_clip_item_free(StreamClipItem *item)
StreamClipItem *stream_clip_item_new(StreamAgent *agent)
{
StreamClipItem *item = spice_new(StreamClipItem, 1);
pipe_item_init_full((PipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
(GDestroyNotify)stream_clip_item_free);
red_pipe_item_init_full((RedPipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
(GDestroyNotify)stream_clip_item_free);
item->stream_agent = agent;
agent->stream->refs++;
@ -343,7 +343,7 @@ static void before_reattach_stream(DisplayChannel *display,
continue;
}
if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
#ifdef STREAM_STATS
agent->stats.num_drops_pipe++;
#endif
@ -734,8 +734,8 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
StreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
agent->report_id = rand();
pipe_item_init(&report_pipe_item->pipe_item,
PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
red_pipe_item_init(&report_pipe_item->pipe_item,
PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &report_pipe_item->pipe_item);
}
@ -808,8 +808,8 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
upgrade_item = spice_new(UpgradeItem, 1);
pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
(GDestroyNotify)upgrade_item_free);
red_pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
(GDestroyNotify)upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
n_rects = pixman_region32_n_rects(&upgrade_item->drawable->tree_item.base.rgn);

8
server/stream.h
View File

@ -47,7 +47,7 @@ typedef struct DisplayChannel DisplayChannel;
typedef struct Stream Stream;
typedef struct StreamActivateReportItem {
PipeItem pipe_item;
RedPipeItem pipe_item;
uint32_t stream_id;
} StreamActivateReportItem;
@ -81,8 +81,8 @@ typedef struct StreamAgent {
vis_region will contain c2 and also the part of c1/c2 that still
displays fragments of the video */
PipeItem create_item;
PipeItem destroy_item;
RedPipeItem create_item;
RedPipeItem destroy_item;
Stream *stream;
uint64_t last_send_time;
MJpegEncoder *mjpeg_encoder;
@ -100,7 +100,7 @@ typedef struct StreamAgent {
} StreamAgent;
typedef struct StreamClipItem {
PipeItem base;
RedPipeItem base;
StreamAgent *stream_agent;
int clip_type;
SpiceClipRects *rects;