pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-01-04 00:06:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

use QXLState instead of RedDispatcher

Browse Source 
Considering that:
- QXLState is the state of QXLInstance implementation;
- RedDispatcher is the implementation of QXL;
- qif (QXLInterface*) field can be computed really easy from QXLInstance;
- most of its state is private.
Make all structure private and use QXLState instead of RedDispatcher.

Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
Acked-by: Jonathon Jongsma <jjongsma@redhat.com>
Acked-by: Christophe Fergeau <cfergeau@redhat.com>
This commit is contained in:
Frediano Ziglio 2016-02-25 18:54:09 +00:00
parent 5916dd8fa6
commit e9ed125dbd
11 changed files with 370 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/cursor-channel.c
View File

@ -116,7 +116,7 @@ static void cursor_item_unref(CursorItem *item)
return; return;
cursor_cmd = item->red_cursor; cursor_cmd = item->red_cursor;
item->qxl->st->qif->release_resource(item->qxl, cursor_cmd->release_info_ext); qxl_get_interface(item->qxl)->release_resource(item->qxl, cursor_cmd->release_info_ext);
red_put_cursor_cmd(cursor_cmd); red_put_cursor_cmd(cursor_cmd);
free(cursor_cmd); free(cursor_cmd);

17
server/dcc-send.c
View File

@ -2306,18 +2306,13 @@ static void marshall_gl_scanout(RedChannelClient *rcc,
DisplayChannelClient *dcc = RCC_TO_DCC(rcc); DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display_channel = DCC_TO_DC(dcc); DisplayChannel *display_channel = DCC_TO_DC(dcc);
QXLInstance* qxl = display_channel->common.qxl; QXLInstance* qxl = display_channel->common.qxl;
SpiceMsgDisplayGlScanoutUnix *so = &qxl->st->scanout;
pthread_mutex_lock(&qxl->st->scanout_mutex); SpiceMsgDisplayGlScanoutUnix *so = red_qxl_get_gl_scanout(qxl->st);
if (so != NULL) {
if (so->drm_dma_buf_fd == -1) red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_SCANOUT_UNIX, NULL);
goto end; spice_marshall_msg_display_gl_scanout_unix(m, so);
}
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_SCANOUT_UNIX, NULL); red_qxl_put_gl_scanout(qxl->st, so);
spice_marshall_msg_display_gl_scanout_unix(m, so);
end:
pthread_mutex_unlock(&qxl->st->scanout_mutex);
} }
static void marshall_gl_draw(RedChannelClient *rcc, static void marshall_gl_draw(RedChannelClient *rcc,

4
server/dcc.c
View File

@ -467,7 +467,8 @@ void dcc_start(DisplayChannelClient *dcc)
dcc_create_all_streams(dcc); dcc_create_all_streams(dcc);
} }
if (qxl->st->scanout.drm_dma_buf_fd >= 0) { SpiceMsgDisplayGlScanoutUnix *scanout = red_qxl_get_gl_scanout(qxl->st);
if (scanout) {
if (reds_stream_is_plain_unix(rcc->stream) && if (reds_stream_is_plain_unix(rcc->stream) &&
red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) { red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) {
red_channel_client_pipe_add(rcc, dcc_gl_scanout_item_new(rcc, NULL, 0)); red_channel_client_pipe_add(rcc, dcc_gl_scanout_item_new(rcc, NULL, 0));
@ -476,6 +477,7 @@ void dcc_start(DisplayChannelClient *dcc)
spice_printerr("FIXME: GL not supported on this kind of connection"); spice_printerr("FIXME: GL not supported on this kind of connection");
} }
} }
red_qxl_put_gl_scanout(qxl->st, scanout);
} }
static void dcc_destroy_stream_agents(DisplayChannelClient *dcc) static void dcc_destroy_stream_agents(DisplayChannelClient *dcc)

8
server/display-channel.c
View File

@ -268,10 +268,10 @@ void display_channel_surface_unref(DisplayChannel *display, uint32_t surface_id)
surface->context.canvas->ops->destroy(surface->context.canvas); surface->context.canvas->ops->destroy(surface->context.canvas);
if (surface->create.info) { if (surface->create.info) {
qxl->st->qif->release_resource(qxl, surface->create); qxl_get_interface(qxl)->release_resource(qxl, surface->create);
} }
if (surface->destroy.info) { if (surface->destroy.info) {
qxl->st->qif->release_resource(qxl, surface->destroy); qxl_get_interface(qxl)->release_resource(qxl, surface->destroy);
} }
region_destroy(&surface->draw_dirty_region); region_destroy(&surface->draw_dirty_region);
@ -2162,9 +2162,7 @@ static void set_gl_draw_async_count(DisplayChannel *display, int num)
display->gl_draw_async_count = num; display->gl_draw_async_count = num;
if (num == 0) { if (num == 0) {
struct AsyncCommand *async = qxl->st->gl_draw_async; red_qxl_gl_draw_async_complete(qxl->st);
qxl->st->gl_draw_async = NULL;
red_qxl_async_complete(qxl->st->dispatcher, async);
} }
} }

495
server/red-qxl.c
View File

File diff suppressed because it is too large Load Diff

37
server/red-qxl.h
View File

@ -20,27 +20,30 @@
#include "red-channel.h" #include "red-channel.h"
typedef struct RedDispatcher RedDispatcher; typedef struct QXLState QXLState;
typedef struct AsyncCommand AsyncCommand; typedef struct AsyncCommand AsyncCommand;
void red_qxl_init(QXLInstance *qxl); void red_qxl_init(QXLInstance *qxl);
void red_qxl_set_mm_time(RedDispatcher *dispatcher, uint32_t); void red_qxl_set_mm_time(QXLState *qxl_state, uint32_t);
void red_qxl_on_ic_change(RedDispatcher *dispatcher, SpiceImageCompression ic); void red_qxl_on_ic_change(QXLState *qxl_state, SpiceImageCompression ic);
void red_qxl_on_sv_change(RedDispatcher *dispatcher, int sv); void red_qxl_on_sv_change(QXLState *qxl_state, int sv);
void red_qxl_set_mouse_mode(RedDispatcher *dispatcher, uint32_t mode); void red_qxl_set_mouse_mode(QXLState *qxl_state, uint32_t mode);
void red_qxl_attach_worker(RedDispatcher *dispatcher); void red_qxl_attach_worker(QXLState *qxl_state);
void red_qxl_set_compression_level(RedDispatcher *dispatcher, int level); void red_qxl_set_compression_level(QXLState *qxl_state, int level);
void red_qxl_stop(RedDispatcher *dispatcher); void red_qxl_stop(QXLState *qxl_state);
void red_qxl_start(RedDispatcher *dispatcher); void red_qxl_start(QXLState *qxl_state);
uint32_t red_qxl_get_ram_size(RedDispatcher *dispatcher); uint32_t red_qxl_get_ram_size(QXLState *qxl_state);
void red_qxl_async_complete(struct RedDispatcher *, AsyncCommand *); void red_qxl_async_complete(QXLState *qxl_state, AsyncCommand *cmd);
struct Dispatcher *red_qxl_get_dispatcher(struct RedDispatcher *); struct Dispatcher *red_qxl_get_dispatcher(QXLState *qxl_state);
gboolean red_qxl_use_client_monitors_config(RedDispatcher *dispatcher); gboolean red_qxl_use_client_monitors_config(QXLState *qxl_state);
gboolean red_qxl_client_monitors_config(RedDispatcher *dispatcher, VDAgentMonitorsConfig *monitors_config); gboolean red_qxl_client_monitors_config(QXLState *qxl_state, VDAgentMonitorsConfig *monitors_config);
gboolean red_qxl_get_primary_active(RedDispatcher *dispatcher); gboolean red_qxl_get_primary_active(QXLState *qxl_state);
gboolean red_qxl_get_allow_client_mouse(RedDispatcher *dispatcher, gint *x_res, gint *y_res); gboolean red_qxl_get_allow_client_mouse(QXLState *qxl_state, gint *x_res, gint *y_res);
SpiceMsgDisplayGlScanoutUnix *red_qxl_get_gl_scanout(QXLState *qxl_state);
void red_qxl_put_gl_scanout(QXLState *qxl_state, SpiceMsgDisplayGlScanoutUnix *scanout);
void red_qxl_gl_draw_async_complete(QXLState *qxl);
typedef uint32_t RedWorkerMessage; typedef uint32_t RedWorkerMessage;
@ -267,6 +270,6 @@ enum {
RED_DISPATCHER_PENDING_OOM, RED_DISPATCHER_PENDING_OOM,
}; };
void red_qxl_clear_pending(RedDispatcher *red_dispatcher, int pending); void red_qxl_clear_pending(QXLState *qxl_state, int pending);
#endif #endif

57
server/red-worker.c
View File

@ -60,7 +60,7 @@
struct RedWorker { struct RedWorker {
pthread_t thread; pthread_t thread;
QXLInstance *qxl; QXLInstance *qxl;
RedDispatcher *red_dispatcher; QXLState *qxl_state;
SpiceWatch *dispatch_watch; SpiceWatch *dispatch_watch;
int running; int running;
SpiceCoreInterfaceInternal core; SpiceCoreInterfaceInternal core;
@ -127,8 +127,8 @@ void red_drawable_unref(RedDrawable *red_drawable)
if (--red_drawable->refs) { if (--red_drawable->refs) {
return; return;
} }
red_drawable->qxl->st->qif->release_resource(red_drawable->qxl, qxl_get_interface(red_drawable->qxl)->release_resource(red_drawable->qxl,
red_drawable->release_info_ext); red_drawable->release_info_ext);
red_put_drawable(red_drawable); red_put_drawable(red_drawable);
free(red_drawable); free(red_drawable);
} }
@ -145,12 +145,12 @@ static int red_process_cursor(RedWorker *worker, int *ring_is_empty)
*ring_is_empty = FALSE; *ring_is_empty = FALSE;
while (red_channel_max_pipe_size(RED_CHANNEL(worker->cursor_channel)) <= MAX_PIPE_SIZE) { while (red_channel_max_pipe_size(RED_CHANNEL(worker->cursor_channel)) <= MAX_PIPE_SIZE) {
if (!worker->qxl->st->qif->get_cursor_command(worker->qxl, &ext_cmd)) { if (!qxl_get_interface(worker->qxl)->get_cursor_command(worker->qxl, &ext_cmd)) {
*ring_is_empty = TRUE; *ring_is_empty = TRUE;
if (worker->cursor_poll_tries < CMD_RING_POLL_RETRIES) { if (worker->cursor_poll_tries < CMD_RING_POLL_RETRIES) {
worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT); worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT);
} else if (worker->cursor_poll_tries == CMD_RING_POLL_RETRIES && } else if (worker->cursor_poll_tries == CMD_RING_POLL_RETRIES &&
!worker->qxl->st->qif->req_cursor_notification(worker->qxl)) { !qxl_get_interface(worker->qxl)->req_cursor_notification(worker->qxl)) {
continue; continue;
} }
worker->cursor_poll_tries++; worker->cursor_poll_tries++;
@ -203,12 +203,12 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
worker->process_display_generation++; worker->process_display_generation++;
*ring_is_empty = FALSE; *ring_is_empty = FALSE;
while (red_channel_max_pipe_size(RED_CHANNEL(worker->display_channel)) <= MAX_PIPE_SIZE) { while (red_channel_max_pipe_size(RED_CHANNEL(worker->display_channel)) <= MAX_PIPE_SIZE) {
if (!worker->qxl->st->qif->get_command(worker->qxl, &ext_cmd)) { if (!qxl_get_interface(worker->qxl)->get_command(worker->qxl, &ext_cmd)) {
*ring_is_empty = TRUE; *ring_is_empty = TRUE;
if (worker->display_poll_tries < CMD_RING_POLL_RETRIES) { if (worker->display_poll_tries < CMD_RING_POLL_RETRIES) {
worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT); worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT);
} else if (worker->display_poll_tries == CMD_RING_POLL_RETRIES && } else if (worker->display_poll_tries == CMD_RING_POLL_RETRIES &&
!worker->qxl->st->qif->req_cmd_notification(worker->qxl)) { !qxl_get_interface(worker->qxl)->req_cmd_notification(worker->qxl)) {
continue; continue;
} }
worker->display_poll_tries++; worker->display_poll_tries++;
@ -245,9 +245,9 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
spice_warning("Invalid surface in QXL_CMD_UPDATE"); spice_warning("Invalid surface in QXL_CMD_UPDATE");
} else { } else {
display_channel_draw(worker->display_channel, &update.area, update.surface_id); display_channel_draw(worker->display_channel, &update.area, update.surface_id);
worker->qxl->st->qif->notify_update(worker->qxl, update.update_id); qxl_get_interface(worker->qxl)->notify_update(worker->qxl, update.update_id);
} }
worker->qxl->st->qif->release_resource(worker->qxl, update.release_info_ext); qxl_get_interface(worker->qxl)->release_resource(worker->qxl, update.release_info_ext);
red_put_update_cmd(&update); red_put_update_cmd(&update);
break; break;
} }
@ -262,7 +262,7 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
/* alert: accessing message.data is insecure */ /* alert: accessing message.data is insecure */
spice_warning("MESSAGE: %s", message.data); spice_warning("MESSAGE: %s", message.data);
#endif #endif
worker->qxl->st->qif->release_resource(worker->qxl, message.release_info_ext); qxl_get_interface(worker->qxl)->release_resource(worker->qxl, message.release_info_ext);
red_put_message(&message); red_put_message(&message);
break; break;
} }
@ -507,11 +507,12 @@ static void guest_set_client_capabilities(RedWorker *worker)
SPICE_DISPLAY_CAP_COMPOSITE, SPICE_DISPLAY_CAP_COMPOSITE,
SPICE_DISPLAY_CAP_A8_SURFACE, SPICE_DISPLAY_CAP_A8_SURFACE,
}; };
QXLInterface *qif = qxl_get_interface(worker->qxl);
if (worker->qxl->st->qif->base.major_version < 3 || if (qif->base.major_version < 3 ||
(worker->qxl->st->qif->base.major_version == 3 && (qif->base.major_version == 3 &&
worker->qxl->st->qif->base.minor_version < 2) || qif->base.minor_version < 2) ||
!worker->qxl->st->qif->set_client_capabilities) { !qif->set_client_capabilities) {
return; return;
} }
#define SET_CAP(a,c) \ #define SET_CAP(a,c) \
@ -525,7 +526,7 @@ static void guest_set_client_capabilities(RedWorker *worker)
} }
if ((worker->display_channel == NULL) || if ((worker->display_channel == NULL) ||
(RED_CHANNEL(worker->display_channel)->clients_num == 0)) { (RED_CHANNEL(worker->display_channel)->clients_num == 0)) {
worker->qxl->st->qif->set_client_capabilities(worker->qxl, FALSE, caps); qif->set_client_capabilities(worker->qxl, FALSE, caps);
} else { } else {
// Take least common denominator // Take least common denominator
for (i = 0 ; i < sizeof(caps_available) / sizeof(caps_available[0]); ++i) { for (i = 0 ; i < sizeof(caps_available) / sizeof(caps_available[0]); ++i) {
@ -538,7 +539,7 @@ static void guest_set_client_capabilities(RedWorker *worker)
CLEAR_CAP(caps, caps_available[i]); CLEAR_CAP(caps, caps_available[i]);
} }
} }
worker->qxl->st->qif->set_client_capabilities(worker->qxl, TRUE, caps); qif->set_client_capabilities(worker->qxl, TRUE, caps);
} }
} }
@ -577,15 +578,15 @@ static void handle_dev_update_async(void *opaque, void *payload)
uint32_t num_dirty_rects = 0; uint32_t num_dirty_rects = 0;
spice_return_if_fail(worker->running); spice_return_if_fail(worker->running);
spice_return_if_fail(worker->qxl->st->qif->update_area_complete); spice_return_if_fail(qxl_get_interface(worker->qxl)->update_area_complete);
flush_display_commands(worker); flush_display_commands(worker);
display_channel_update(worker->display_channel, display_channel_update(worker->display_channel,
msg->surface_id, &msg->qxl_area, msg->clear_dirty_region, msg->surface_id, &msg->qxl_area, msg->clear_dirty_region,
&qxl_dirty_rects, &num_dirty_rects); &qxl_dirty_rects, &num_dirty_rects);
worker->qxl->st->qif->update_area_complete(worker->qxl, msg->surface_id, qxl_get_interface(worker->qxl)->update_area_complete(worker->qxl, msg->surface_id,
qxl_dirty_rects, num_dirty_rects); qxl_dirty_rects, num_dirty_rects);
free(qxl_dirty_rects); free(qxl_dirty_rects);
} }
@ -823,7 +824,7 @@ static void handle_dev_wakeup(void *opaque, void *payload)
RedWorker *worker = opaque; RedWorker *worker = opaque;
stat_inc_counter(reds, worker->wakeup_counter, 1); stat_inc_counter(reds, worker->wakeup_counter, 1);
red_qxl_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_WAKEUP); red_qxl_clear_pending(worker->qxl_state, RED_DISPATCHER_PENDING_WAKEUP);
} }
static void handle_dev_oom(void *opaque, void *payload) static void handle_dev_oom(void *opaque, void *payload)
@ -844,16 +845,16 @@ static void handle_dev_oom(void *opaque, void *payload)
while (red_process_display(worker, &ring_is_empty)) { while (red_process_display(worker, &ring_is_empty)) {
red_channel_push(display_red_channel); red_channel_push(display_red_channel);
} }
if (worker->qxl->st->qif->flush_resources(worker->qxl) == 0) { if (qxl_get_interface(worker->qxl)->flush_resources(worker->qxl) == 0) {
display_channel_free_some(worker->display_channel); display_channel_free_some(worker->display_channel);
worker->qxl->st->qif->flush_resources(worker->qxl); qxl_get_interface(worker->qxl)->flush_resources(worker->qxl);
} }
spice_debug("OOM2 #draw=%u, #glz_draw=%u current %u pipes %u", spice_debug("OOM2 #draw=%u, #glz_draw=%u current %u pipes %u",
display->drawable_count, display->drawable_count,
display->glz_drawable_count, display->glz_drawable_count,
display->current_size, display->current_size,
red_channel_sum_pipes_size(display_red_channel)); red_channel_sum_pipes_size(display_red_channel));
red_qxl_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_OOM); red_qxl_clear_pending(worker->qxl_state, RED_DISPATCHER_PENDING_OOM);
} }
static void handle_dev_reset_cursor(void *opaque, void *payload) static void handle_dev_reset_cursor(void *opaque, void *payload)
@ -1194,7 +1195,7 @@ static void worker_handle_dispatcher_async_done(void *opaque,
RedWorkerMessageAsync *msg_async = payload; RedWorkerMessageAsync *msg_async = payload;
spice_debug(NULL); spice_debug(NULL);
red_qxl_async_complete(worker->red_dispatcher, msg_async->cmd); red_qxl_async_complete(worker->qxl_state, msg_async->cmd);
} }
static void worker_dispatcher_record(void *opaque, uint32_t message_type, void *payload) static void worker_dispatcher_record(void *opaque, uint32_t message_type, void *payload)
@ -1462,14 +1463,14 @@ static GSourceFuncs worker_source_funcs = {
.dispatch = worker_source_dispatch, .dispatch = worker_source_dispatch,
}; };
RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher) RedWorker* red_worker_new(QXLInstance *qxl, QXLState *qxl_state)
{ {
QXLDevInitInfo init_info; QXLDevInitInfo init_info;
RedWorker *worker; RedWorker *worker;
Dispatcher *dispatcher; Dispatcher *dispatcher;
const char *record_filename; const char *record_filename;
qxl->st->qif->get_init_info(qxl, &init_info); qxl_get_interface(qxl)->get_init_info(qxl, &init_info);
worker = spice_new0(RedWorker, 1); worker = spice_new0(RedWorker, 1);
worker->core = event_loop_core; worker->core = event_loop_core;
@ -1487,10 +1488,10 @@ RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
spice_error("failed to write replay header"); spice_error("failed to write replay header");
} }
} }
dispatcher = red_qxl_get_dispatcher(red_dispatcher); dispatcher = red_qxl_get_dispatcher(qxl_state);
dispatcher_set_opaque(dispatcher, worker); dispatcher_set_opaque(dispatcher, worker);
worker->red_dispatcher = red_dispatcher; worker->qxl_state = qxl_state;
worker->qxl = qxl; worker->qxl = qxl;
register_callbacks(dispatcher); register_callbacks(dispatcher);
if (worker->record_fd) { if (worker->record_fd) {

2
server/red-worker.h
View File

@ -90,7 +90,7 @@ static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
} }
} }
RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher); RedWorker* red_worker_new(QXLInstance *qxl, QXLState *qxl_state);
bool red_worker_run(RedWorker *worker); bool red_worker_run(RedWorker *worker);
RedChannel* red_worker_get_cursor_channel(RedWorker *worker); RedChannel* red_worker_get_cursor_channel(RedWorker *worker);
RedChannel* red_worker_get_display_channel(RedWorker *worker); RedChannel* red_worker_get_display_channel(RedWorker *worker);

2
server/reds-private.h
View File

@ -241,7 +241,7 @@ struct RedsState {
RedSSLParameters ssl_parameters; RedSSLParameters ssl_parameters;
SpiceCoreInterfaceInternal *core; SpiceCoreInterfaceInternal *core;
GList *dispatchers; GList *qxl_states;
MainDispatcher *main_dispatcher; MainDispatcher *main_dispatcher;
}; };

80
server/reds.c
View File

@ -570,8 +570,8 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode)
} }
reds->mouse_mode = mode; reds->mouse_mode = mode;
for (l = reds->dispatchers; l != NULL; l = l->next) for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_set_mouse_mode(l->data, mode); red_qxl_set_mouse_mode((QXLState*) l->data, mode);
main_channel_push_mouse_mode(reds->main_channel, reds->mouse_mode, reds->is_client_mouse_allowed); main_channel_push_mouse_mode(reds->main_channel, reds->mouse_mode, reds->is_client_mouse_allowed);
} }
@ -584,7 +584,7 @@ gboolean reds_get_agent_mouse(const RedsState *reds)
static void reds_update_mouse_mode(RedsState *reds) static void reds_update_mouse_mode(RedsState *reds)
{ {
int allowed = 0; int allowed = 0;
int qxl_count = g_list_length(reds->dispatchers); int qxl_count = g_list_length(reds->qxl_states);
if ((reds->agent_mouse && reds->vdagent) || if ((reds->agent_mouse && reds->vdagent) ||
(inputs_channel_has_tablet(reds->inputs_channel) && qxl_count == 1)) { (inputs_channel_has_tablet(reds->inputs_channel) && qxl_count == 1)) {
@ -1681,7 +1681,7 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
} }
if (!mig_target) { if (!mig_target) {
main_channel_push_init(mcc, g_list_length(reds->dispatchers), main_channel_push_init(mcc, g_list_length(reds->qxl_states),
reds->mouse_mode, reds->is_client_mouse_allowed, reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA, reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds)); reds_qxl_ram_size(reds));
@ -1827,7 +1827,7 @@ void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *c
mcc = red_client_get_main(client); mcc = red_client_get_main(client);
// TODO: not doing net test. consider doing it on client_migrate_info // TODO: not doing net test. consider doing it on client_migrate_info
main_channel_push_init(mcc, g_list_length(reds->dispatchers), main_channel_push_init(mcc, g_list_length(reds->qxl_states),
reds->mouse_mode, reds->is_client_mouse_allowed, reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA, reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds)); reds_qxl_ram_size(reds));
@ -3199,7 +3199,7 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
} }
} else if (strcmp(interface->type, SPICE_INTERFACE_QXL) == 0) { } else if (strcmp(interface->type, SPICE_INTERFACE_QXL) == 0) {
QXLInstance *qxl; QXLInstance *qxl;
RedDispatcher *dispatcher; QXLState *qxl_state;
spice_info("SPICE_INTERFACE_QXL"); spice_info("SPICE_INTERFACE_QXL");
if (interface->major_version != SPICE_INTERFACE_QXL_MAJOR || if (interface->major_version != SPICE_INTERFACE_QXL_MAJOR ||
@ -3209,21 +3209,17 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
} }
qxl = SPICE_CONTAINEROF(sin, QXLInstance, base); qxl = SPICE_CONTAINEROF(sin, QXLInstance, base);
qxl->st = spice_new0(QXLState, 1);
pthread_mutex_init(&qxl->st->scanout_mutex, NULL);
qxl->st->scanout.drm_dma_buf_fd = -1;
qxl->st->qif = SPICE_CONTAINEROF(interface, QXLInterface, base);
red_qxl_init(qxl); red_qxl_init(qxl);
dispatcher = qxl->st->dispatcher; qxl_state = qxl->st;
reds->dispatchers = g_list_prepend(reds->dispatchers, dispatcher); reds->qxl_states = g_list_prepend(reds->qxl_states, qxl_state);
/* this function has to be called after the dispatcher is on the list /* this function has to be called after the qxl is on the list
* as QXLInstance clients expect the dispatcher to be on the list when * as QXLInstance clients expect the qxl to be on the list when
* this callback is called. This as clients assume they can start the * this callback is called. This as clients assume they can start the
* dispatchers. Also note that this should be the first callback to * qxl_states. Also note that this should be the first callback to
* be called. */ * be called. */
red_qxl_attach_worker(dispatcher); red_qxl_attach_worker(qxl_state);
red_qxl_set_compression_level(dispatcher, calc_compression_level(reds)); red_qxl_set_compression_level(qxl_state, calc_compression_level(reds));
} else if (strcmp(interface->type, SPICE_INTERFACE_TABLET) == 0) { } else if (strcmp(interface->type, SPICE_INTERFACE_TABLET) == 0) {
SpiceTabletInstance *tablet = SPICE_CONTAINEROF(sin, SpiceTabletInstance, base); SpiceTabletInstance *tablet = SPICE_CONTAINEROF(sin, SpiceTabletInstance, base);
spice_info("SPICE_INTERFACE_TABLET"); spice_info("SPICE_INTERFACE_TABLET");
@ -4150,13 +4146,13 @@ void reds_update_client_mouse_allowed(RedsState *reds)
int x_res = 0; int x_res = 0;
int y_res = 0; int y_res = 0;
GList *l; GList *l;
int num_active_workers = g_list_length(reds->dispatchers); int num_active_workers = g_list_length(reds->qxl_states);
if (num_active_workers > 0) { if (num_active_workers > 0) {
allow_now = TRUE; allow_now = TRUE;
for (l = reds->dispatchers; l != NULL && allow_now; l = l->next) { for (l = reds->qxl_states; l != NULL && allow_now; l = l->next) {
RedDispatcher *now = l->data; QXLState *now = l->data;
if (red_qxl_get_primary_active(now)) { if (red_qxl_get_primary_active(now)) {
allow_now = red_qxl_get_allow_client_mouse(now, &x_res, &y_res); allow_now = red_qxl_get_allow_client_mouse(now, &x_res, &y_res);
break; break;
@ -4174,12 +4170,12 @@ gboolean reds_use_client_monitors_config(RedsState *reds)
{ {
GList *l; GList *l;
if (reds->dispatchers == NULL) { if (reds->qxl_states == NULL) {
return FALSE; return FALSE;
} }
for (l = reds->dispatchers; l != NULL ; l = l->next) { for (l = reds->qxl_states; l != NULL ; l = l->next) {
RedDispatcher *now = l->data; QXLState *now = l->data;
if (!red_qxl_use_client_monitors_config(now)) if (!red_qxl_use_client_monitors_config(now))
return FALSE; return FALSE;
@ -4191,8 +4187,8 @@ void reds_client_monitors_config(RedsState *reds, VDAgentMonitorsConfig *monitor
{ {
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) { for (l = reds->qxl_states; l != NULL; l = l->next) {
RedDispatcher *now = l->data; QXLState *now = l->data;
if (!red_qxl_client_monitors_config(now, monitors_config)) { if (!red_qxl_client_monitors_config(now, monitors_config)) {
/* this is a normal condition, some qemu devices might not implement it */ /* this is a normal condition, some qemu devices might not implement it */
spice_debug("QXLInterface::client_monitors_config failed\n"); spice_debug("QXLInterface::client_monitors_config failed\n");
@ -4204,8 +4200,8 @@ void reds_set_mm_time(RedsState *reds, uint32_t mm_time)
{ {
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) { for (l = reds->qxl_states; l != NULL; l = l->next) {
RedDispatcher *now = l->data; QXLState *now = l->data;
red_qxl_set_mm_time(now, mm_time); red_qxl_set_mm_time(now, mm_time);
} }
} }
@ -4227,10 +4223,10 @@ void reds_on_ic_change(RedsState *reds)
int compression_level = calc_compression_level(reds); int compression_level = calc_compression_level(reds);
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) { for (l = reds->qxl_states; l != NULL; l = l->next) {
RedDispatcher *d = l->data; QXLState *q = l->data;
red_qxl_set_compression_level(d, compression_level); red_qxl_set_compression_level(q, compression_level);
red_qxl_on_ic_change(d, spice_server_get_image_compression(reds)); red_qxl_on_ic_change(q, spice_server_get_image_compression(reds));
} }
} }
@ -4239,10 +4235,10 @@ void reds_on_sv_change(RedsState *reds)
int compression_level = calc_compression_level(reds); int compression_level = calc_compression_level(reds);
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) { for (l = reds->qxl_states; l != NULL; l = l->next) {
RedDispatcher *d = l->data; QXLState *q = l->data;
red_qxl_set_compression_level(d, compression_level); red_qxl_set_compression_level(q, compression_level);
red_qxl_on_sv_change(d, reds_get_streaming_video(reds)); red_qxl_on_sv_change(q, reds_get_streaming_video(reds));
} }
} }
@ -4250,26 +4246,26 @@ void reds_on_vm_stop(RedsState *reds)
{ {
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_stop(l->data); red_qxl_stop((QXLState*) l->data);
} }
void reds_on_vm_start(RedsState *reds) void reds_on_vm_start(RedsState *reds)
{ {
GList *l; GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_start(l->data); red_qxl_start((QXLState*) l->data);
} }
uint32_t reds_qxl_ram_size(RedsState *reds) uint32_t reds_qxl_ram_size(RedsState *reds)
{ {
RedDispatcher *first; QXLState *first;
if (!reds->dispatchers) { if (!reds->qxl_states) {
return 0; return 0;
} }
first = reds->dispatchers->data; first = reds->qxl_states->data;
return red_qxl_get_ram_size(first); return red_qxl_get_ram_size(first);
} }

11
server/reds.h
View File

@ -34,13 +34,10 @@
typedef struct RedsState RedsState; typedef struct RedsState RedsState;
extern RedsState *reds; extern RedsState *reds;
struct QXLState { static inline QXLInterface * qxl_get_interface(QXLInstance *qxl)
QXLInterface *qif; {
struct RedDispatcher *dispatcher; return SPICE_CONTAINEROF(qxl->base.sif, QXLInterface, base);
pthread_mutex_t scanout_mutex; }
SpiceMsgDisplayGlScanoutUnix scanout;
struct AsyncCommand *gl_draw_async;
};
struct TunnelWorker; struct TunnelWorker;
struct SpiceNetWireState { struct SpiceNetWireState {