mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-09-06 18:05:37 +00:00
![Markus Armbruster](/assets/img/avatar_default.png)
qemu-common.h includes qemu/option.h, but most places that include the
former don't actually need the latter. Drop the include, and add it
to the places that actually need it.
While there, drop superfluous includes of both headers, and
separate #include from file comment with a blank line.
This cleanup makes the number of objects depending on qemu/option.h
drop from 4545 (out of 4743) to 284 in my "build everything" tree.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20180201111846.21846-20-armbru@redhat.com>
[Semantic conflict with commit bdd6a90a9e
in block/nvme.c resolved]
1071 lines
33 KiB
C
1071 lines
33 KiB
C
/*
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 or
|
|
* (at your option) version 3 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "ui/qemu-spice.h"
|
|
#include "qemu/timer.h"
|
|
#include "qemu/option.h"
|
|
#include "qemu/queue.h"
|
|
#include "ui/console.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "trace.h"
|
|
|
|
#include "ui/spice-display.h"
|
|
|
|
static int debug = 0;
|
|
bool spice_opengl;
|
|
|
|
static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (level <= debug) {
|
|
va_start(args, fmt);
|
|
vfprintf(stderr, fmt, args);
|
|
va_end(args);
|
|
}
|
|
}
|
|
|
|
int qemu_spice_rect_is_empty(const QXLRect* r)
|
|
{
|
|
return r->top == r->bottom || r->left == r->right;
|
|
}
|
|
|
|
void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
|
|
{
|
|
if (qemu_spice_rect_is_empty(r)) {
|
|
return;
|
|
}
|
|
|
|
if (qemu_spice_rect_is_empty(dest)) {
|
|
*dest = *r;
|
|
return;
|
|
}
|
|
|
|
dest->top = MIN(dest->top, r->top);
|
|
dest->left = MIN(dest->left, r->left);
|
|
dest->bottom = MAX(dest->bottom, r->bottom);
|
|
dest->right = MAX(dest->right, r->right);
|
|
}
|
|
|
|
QXLCookie *qxl_cookie_new(int type, uint64_t io)
|
|
{
|
|
QXLCookie *cookie;
|
|
|
|
cookie = g_malloc0(sizeof(*cookie));
|
|
cookie->type = type;
|
|
cookie->io = io;
|
|
return cookie;
|
|
}
|
|
|
|
void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
|
|
qxl_async_io async)
|
|
{
|
|
trace_qemu_spice_add_memslot(ssd->qxl.id, memslot->slot_id,
|
|
memslot->virt_start, memslot->virt_end,
|
|
async);
|
|
|
|
if (async != QXL_SYNC) {
|
|
spice_qxl_add_memslot_async(&ssd->qxl, memslot,
|
|
(uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
|
|
QXL_IO_MEMSLOT_ADD_ASYNC));
|
|
} else {
|
|
spice_qxl_add_memslot(&ssd->qxl, memslot);
|
|
}
|
|
}
|
|
|
|
void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
|
|
{
|
|
trace_qemu_spice_del_memslot(ssd->qxl.id, gid, sid);
|
|
spice_qxl_del_memslot(&ssd->qxl, gid, sid);
|
|
}
|
|
|
|
void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
|
|
QXLDevSurfaceCreate *surface,
|
|
qxl_async_io async)
|
|
{
|
|
trace_qemu_spice_create_primary_surface(ssd->qxl.id, id, surface, async);
|
|
if (async != QXL_SYNC) {
|
|
spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface,
|
|
(uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
|
|
QXL_IO_CREATE_PRIMARY_ASYNC));
|
|
} else {
|
|
spice_qxl_create_primary_surface(&ssd->qxl, id, surface);
|
|
}
|
|
}
|
|
|
|
void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
|
|
uint32_t id, qxl_async_io async)
|
|
{
|
|
trace_qemu_spice_destroy_primary_surface(ssd->qxl.id, id, async);
|
|
if (async != QXL_SYNC) {
|
|
spice_qxl_destroy_primary_surface_async(&ssd->qxl, id,
|
|
(uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
|
|
QXL_IO_DESTROY_PRIMARY_ASYNC));
|
|
} else {
|
|
spice_qxl_destroy_primary_surface(&ssd->qxl, id);
|
|
}
|
|
}
|
|
|
|
void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
|
|
{
|
|
trace_qemu_spice_wakeup(ssd->qxl.id);
|
|
spice_qxl_wakeup(&ssd->qxl);
|
|
}
|
|
|
|
static void qemu_spice_create_one_update(SimpleSpiceDisplay *ssd,
|
|
QXLRect *rect)
|
|
{
|
|
SimpleSpiceUpdate *update;
|
|
QXLDrawable *drawable;
|
|
QXLImage *image;
|
|
QXLCommand *cmd;
|
|
int bw, bh;
|
|
struct timespec time_space;
|
|
pixman_image_t *dest;
|
|
|
|
trace_qemu_spice_create_update(
|
|
rect->left, rect->right,
|
|
rect->top, rect->bottom);
|
|
|
|
update = g_malloc0(sizeof(*update));
|
|
drawable = &update->drawable;
|
|
image = &update->image;
|
|
cmd = &update->ext.cmd;
|
|
|
|
bw = rect->right - rect->left;
|
|
bh = rect->bottom - rect->top;
|
|
update->bitmap = g_malloc(bw * bh * 4);
|
|
|
|
drawable->bbox = *rect;
|
|
drawable->clip.type = SPICE_CLIP_TYPE_NONE;
|
|
drawable->effect = QXL_EFFECT_OPAQUE;
|
|
drawable->release_info.id = (uintptr_t)(&update->ext);
|
|
drawable->type = QXL_DRAW_COPY;
|
|
drawable->surfaces_dest[0] = -1;
|
|
drawable->surfaces_dest[1] = -1;
|
|
drawable->surfaces_dest[2] = -1;
|
|
clock_gettime(CLOCK_MONOTONIC, &time_space);
|
|
/* time in milliseconds from epoch. */
|
|
drawable->mm_time = time_space.tv_sec * 1000
|
|
+ time_space.tv_nsec / 1000 / 1000;
|
|
|
|
drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
|
|
drawable->u.copy.src_bitmap = (uintptr_t)image;
|
|
drawable->u.copy.src_area.right = bw;
|
|
drawable->u.copy.src_area.bottom = bh;
|
|
|
|
QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
|
|
image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
|
|
image->bitmap.flags = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
|
|
image->bitmap.stride = bw * 4;
|
|
image->descriptor.width = image->bitmap.x = bw;
|
|
image->descriptor.height = image->bitmap.y = bh;
|
|
image->bitmap.data = (uintptr_t)(update->bitmap);
|
|
image->bitmap.palette = 0;
|
|
image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
|
|
|
|
dest = pixman_image_create_bits(PIXMAN_LE_x8r8g8b8, bw, bh,
|
|
(void *)update->bitmap, bw * 4);
|
|
pixman_image_composite(PIXMAN_OP_SRC, ssd->surface, NULL, ssd->mirror,
|
|
rect->left, rect->top, 0, 0,
|
|
rect->left, rect->top, bw, bh);
|
|
pixman_image_composite(PIXMAN_OP_SRC, ssd->mirror, NULL, dest,
|
|
rect->left, rect->top, 0, 0,
|
|
0, 0, bw, bh);
|
|
pixman_image_unref(dest);
|
|
|
|
cmd->type = QXL_CMD_DRAW;
|
|
cmd->data = (uintptr_t)drawable;
|
|
|
|
QTAILQ_INSERT_TAIL(&ssd->updates, update, next);
|
|
}
|
|
|
|
static void qemu_spice_create_update(SimpleSpiceDisplay *ssd)
|
|
{
|
|
static const int blksize = 32;
|
|
int blocks = DIV_ROUND_UP(surface_width(ssd->ds), blksize);
|
|
int dirty_top[blocks];
|
|
int y, yoff1, yoff2, x, xoff, blk, bw;
|
|
int bpp = surface_bytes_per_pixel(ssd->ds);
|
|
uint8_t *guest, *mirror;
|
|
|
|
if (qemu_spice_rect_is_empty(&ssd->dirty)) {
|
|
return;
|
|
};
|
|
|
|
for (blk = 0; blk < blocks; blk++) {
|
|
dirty_top[blk] = -1;
|
|
}
|
|
|
|
guest = surface_data(ssd->ds);
|
|
mirror = (void *)pixman_image_get_data(ssd->mirror);
|
|
for (y = ssd->dirty.top; y < ssd->dirty.bottom; y++) {
|
|
yoff1 = y * surface_stride(ssd->ds);
|
|
yoff2 = y * pixman_image_get_stride(ssd->mirror);
|
|
for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
|
|
xoff = x * bpp;
|
|
blk = x / blksize;
|
|
bw = MIN(blksize, ssd->dirty.right - x);
|
|
if (memcmp(guest + yoff1 + xoff,
|
|
mirror + yoff2 + xoff,
|
|
bw * bpp) == 0) {
|
|
if (dirty_top[blk] != -1) {
|
|
QXLRect update = {
|
|
.top = dirty_top[blk],
|
|
.bottom = y,
|
|
.left = x,
|
|
.right = x + bw,
|
|
};
|
|
qemu_spice_create_one_update(ssd, &update);
|
|
dirty_top[blk] = -1;
|
|
}
|
|
} else {
|
|
if (dirty_top[blk] == -1) {
|
|
dirty_top[blk] = y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
|
|
blk = x / blksize;
|
|
bw = MIN(blksize, ssd->dirty.right - x);
|
|
if (dirty_top[blk] != -1) {
|
|
QXLRect update = {
|
|
.top = dirty_top[blk],
|
|
.bottom = ssd->dirty.bottom,
|
|
.left = x,
|
|
.right = x + bw,
|
|
};
|
|
qemu_spice_create_one_update(ssd, &update);
|
|
dirty_top[blk] = -1;
|
|
}
|
|
}
|
|
|
|
memset(&ssd->dirty, 0, sizeof(ssd->dirty));
|
|
}
|
|
|
|
static SimpleSpiceCursor*
|
|
qemu_spice_create_cursor_update(SimpleSpiceDisplay *ssd,
|
|
QEMUCursor *c,
|
|
int on)
|
|
{
|
|
size_t size = c ? c->width * c->height * 4 : 0;
|
|
SimpleSpiceCursor *update;
|
|
QXLCursorCmd *ccmd;
|
|
QXLCursor *cursor;
|
|
QXLCommand *cmd;
|
|
|
|
update = g_malloc0(sizeof(*update) + size);
|
|
ccmd = &update->cmd;
|
|
cursor = &update->cursor;
|
|
cmd = &update->ext.cmd;
|
|
|
|
if (c) {
|
|
ccmd->type = QXL_CURSOR_SET;
|
|
ccmd->u.set.position.x = ssd->ptr_x + ssd->hot_x;
|
|
ccmd->u.set.position.y = ssd->ptr_y + ssd->hot_y;
|
|
ccmd->u.set.visible = true;
|
|
ccmd->u.set.shape = (uintptr_t)cursor;
|
|
cursor->header.unique = ssd->unique++;
|
|
cursor->header.type = SPICE_CURSOR_TYPE_ALPHA;
|
|
cursor->header.width = c->width;
|
|
cursor->header.height = c->height;
|
|
cursor->header.hot_spot_x = c->hot_x;
|
|
cursor->header.hot_spot_y = c->hot_y;
|
|
cursor->data_size = size;
|
|
cursor->chunk.data_size = size;
|
|
memcpy(cursor->chunk.data, c->data, size);
|
|
} else if (!on) {
|
|
ccmd->type = QXL_CURSOR_HIDE;
|
|
} else {
|
|
ccmd->type = QXL_CURSOR_MOVE;
|
|
ccmd->u.position.x = ssd->ptr_x + ssd->hot_x;
|
|
ccmd->u.position.y = ssd->ptr_y + ssd->hot_y;
|
|
}
|
|
ccmd->release_info.id = (uintptr_t)(&update->ext);
|
|
|
|
cmd->type = QXL_CMD_CURSOR;
|
|
cmd->data = (uintptr_t)ccmd;
|
|
|
|
return update;
|
|
}
|
|
|
|
/*
|
|
* Called from spice server thread context (via interface_release_resource)
|
|
* We do *not* hold the global qemu mutex here, so extra care is needed
|
|
* when calling qemu functions. QEMU interfaces used:
|
|
* - g_free (underlying glibc free is re-entrant).
|
|
*/
|
|
void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
|
|
{
|
|
g_free(update->bitmap);
|
|
g_free(update);
|
|
}
|
|
|
|
void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
|
|
{
|
|
QXLDevMemSlot memslot;
|
|
|
|
dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
|
|
memset(&memslot, 0, sizeof(memslot));
|
|
memslot.slot_group_id = MEMSLOT_GROUP_HOST;
|
|
memslot.virt_end = ~0;
|
|
qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
|
|
}
|
|
|
|
void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
|
|
{
|
|
QXLDevSurfaceCreate surface;
|
|
uint64_t surface_size;
|
|
|
|
memset(&surface, 0, sizeof(surface));
|
|
|
|
surface_size = (uint64_t) surface_width(ssd->ds) *
|
|
surface_height(ssd->ds) * 4;
|
|
assert(surface_size > 0);
|
|
assert(surface_size < INT_MAX);
|
|
if (ssd->bufsize < surface_size) {
|
|
ssd->bufsize = surface_size;
|
|
g_free(ssd->buf);
|
|
ssd->buf = g_malloc(ssd->bufsize);
|
|
}
|
|
|
|
dprint(1, "%s/%d: %ux%u (size %" PRIu64 "/%d)\n", __func__, ssd->qxl.id,
|
|
surface_width(ssd->ds), surface_height(ssd->ds),
|
|
surface_size, ssd->bufsize);
|
|
|
|
surface.format = SPICE_SURFACE_FMT_32_xRGB;
|
|
surface.width = surface_width(ssd->ds);
|
|
surface.height = surface_height(ssd->ds);
|
|
surface.stride = -surface.width * 4;
|
|
surface.mouse_mode = true;
|
|
surface.flags = 0;
|
|
surface.type = 0;
|
|
surface.mem = (uintptr_t)ssd->buf;
|
|
surface.group_id = MEMSLOT_GROUP_HOST;
|
|
|
|
qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
|
|
}
|
|
|
|
void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
|
|
{
|
|
dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
|
|
qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
|
|
}
|
|
|
|
void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd)
|
|
{
|
|
qemu_mutex_init(&ssd->lock);
|
|
QTAILQ_INIT(&ssd->updates);
|
|
ssd->mouse_x = -1;
|
|
ssd->mouse_y = -1;
|
|
if (ssd->num_surfaces == 0) {
|
|
ssd->num_surfaces = 1024;
|
|
}
|
|
}
|
|
|
|
/* display listener callbacks */
|
|
|
|
void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
|
|
int x, int y, int w, int h)
|
|
{
|
|
QXLRect update_area;
|
|
|
|
dprint(2, "%s/%d: x %d y %d w %d h %d\n", __func__,
|
|
ssd->qxl.id, x, y, w, h);
|
|
update_area.left = x,
|
|
update_area.right = x + w;
|
|
update_area.top = y;
|
|
update_area.bottom = y + h;
|
|
|
|
if (qemu_spice_rect_is_empty(&ssd->dirty)) {
|
|
ssd->notify++;
|
|
}
|
|
qemu_spice_rect_union(&ssd->dirty, &update_area);
|
|
}
|
|
|
|
void qemu_spice_display_switch(SimpleSpiceDisplay *ssd,
|
|
DisplaySurface *surface)
|
|
{
|
|
SimpleSpiceUpdate *update;
|
|
bool need_destroy;
|
|
|
|
if (surface && ssd->surface &&
|
|
surface_width(surface) == pixman_image_get_width(ssd->surface) &&
|
|
surface_height(surface) == pixman_image_get_height(ssd->surface) &&
|
|
surface_format(surface) == pixman_image_get_format(ssd->surface)) {
|
|
/* no-resize fast path: just swap backing store */
|
|
dprint(1, "%s/%d: fast (%dx%d)\n", __func__, ssd->qxl.id,
|
|
surface_width(surface), surface_height(surface));
|
|
qemu_mutex_lock(&ssd->lock);
|
|
ssd->ds = surface;
|
|
pixman_image_unref(ssd->surface);
|
|
ssd->surface = pixman_image_ref(ssd->ds->image);
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
qemu_spice_display_update(ssd, 0, 0,
|
|
surface_width(surface),
|
|
surface_height(surface));
|
|
return;
|
|
}
|
|
|
|
/* full mode switch */
|
|
dprint(1, "%s/%d: full (%dx%d -> %dx%d)\n", __func__, ssd->qxl.id,
|
|
ssd->surface ? pixman_image_get_width(ssd->surface) : 0,
|
|
ssd->surface ? pixman_image_get_height(ssd->surface) : 0,
|
|
surface ? surface_width(surface) : 0,
|
|
surface ? surface_height(surface) : 0);
|
|
|
|
memset(&ssd->dirty, 0, sizeof(ssd->dirty));
|
|
if (ssd->surface) {
|
|
pixman_image_unref(ssd->surface);
|
|
ssd->surface = NULL;
|
|
pixman_image_unref(ssd->mirror);
|
|
ssd->mirror = NULL;
|
|
}
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
need_destroy = (ssd->ds != NULL);
|
|
ssd->ds = surface;
|
|
while ((update = QTAILQ_FIRST(&ssd->updates)) != NULL) {
|
|
QTAILQ_REMOVE(&ssd->updates, update, next);
|
|
qemu_spice_destroy_update(ssd, update);
|
|
}
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
if (need_destroy) {
|
|
qemu_spice_destroy_host_primary(ssd);
|
|
}
|
|
if (ssd->ds) {
|
|
ssd->surface = pixman_image_ref(ssd->ds->image);
|
|
ssd->mirror = qemu_pixman_mirror_create(ssd->ds->format,
|
|
ssd->ds->image);
|
|
qemu_spice_create_host_primary(ssd);
|
|
}
|
|
|
|
memset(&ssd->dirty, 0, sizeof(ssd->dirty));
|
|
ssd->notify++;
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
if (ssd->cursor) {
|
|
g_free(ssd->ptr_define);
|
|
ssd->ptr_define = qemu_spice_create_cursor_update(ssd, ssd->cursor, 0);
|
|
}
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
}
|
|
|
|
static void qemu_spice_cursor_refresh_unlocked(SimpleSpiceDisplay *ssd)
|
|
{
|
|
if (ssd->cursor) {
|
|
assert(ssd->dcl.con);
|
|
dpy_cursor_define(ssd->dcl.con, ssd->cursor);
|
|
}
|
|
if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
|
|
assert(ssd->dcl.con);
|
|
dpy_mouse_set(ssd->dcl.con, ssd->mouse_x, ssd->mouse_y, 1);
|
|
ssd->mouse_x = -1;
|
|
ssd->mouse_y = -1;
|
|
}
|
|
}
|
|
|
|
void qemu_spice_cursor_refresh_bh(void *opaque)
|
|
{
|
|
SimpleSpiceDisplay *ssd = opaque;
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
qemu_spice_cursor_refresh_unlocked(ssd);
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
}
|
|
|
|
void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
|
|
{
|
|
dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
graphic_hw_update(ssd->dcl.con);
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {
|
|
qemu_spice_create_update(ssd);
|
|
ssd->notify++;
|
|
}
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
|
|
if (ssd->notify) {
|
|
ssd->notify = 0;
|
|
qemu_spice_wakeup(ssd);
|
|
dprint(2, "%s/%d: notify\n", __func__, ssd->qxl.id);
|
|
}
|
|
}
|
|
|
|
/* spice display interface callbacks */
|
|
|
|
static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
|
|
dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
}
|
|
|
|
static void interface_set_compression_level(QXLInstance *sin, int level)
|
|
{
|
|
dprint(1, "%s/%d:\n", __func__, sin->id);
|
|
/* nothing to do */
|
|
}
|
|
|
|
#if SPICE_NEEDS_SET_MM_TIME
|
|
static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
|
|
{
|
|
dprint(3, "%s/%d:\n", __func__, sin->id);
|
|
/* nothing to do */
|
|
}
|
|
#endif
|
|
|
|
static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
|
|
info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
|
|
info->memslot_id_bits = MEMSLOT_SLOT_BITS;
|
|
info->num_memslots = NUM_MEMSLOTS;
|
|
info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
|
|
info->internal_groupslot_id = 0;
|
|
info->qxl_ram_size = 16 * 1024 * 1024;
|
|
info->n_surfaces = ssd->num_surfaces;
|
|
}
|
|
|
|
static int interface_get_command(QXLInstance *sin, QXLCommandExt *ext)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
SimpleSpiceUpdate *update;
|
|
int ret = false;
|
|
|
|
dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
update = QTAILQ_FIRST(&ssd->updates);
|
|
if (update != NULL) {
|
|
QTAILQ_REMOVE(&ssd->updates, update, next);
|
|
*ext = update->ext;
|
|
ret = true;
|
|
}
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int interface_req_cmd_notification(QXLInstance *sin)
|
|
{
|
|
dprint(2, "%s/%d:\n", __func__, sin->id);
|
|
return 1;
|
|
}
|
|
|
|
static void interface_release_resource(QXLInstance *sin,
|
|
QXLReleaseInfoExt rext)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
SimpleSpiceUpdate *update;
|
|
SimpleSpiceCursor *cursor;
|
|
QXLCommandExt *ext;
|
|
|
|
dprint(2, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
ext = (void *)(intptr_t)(rext.info->id);
|
|
switch (ext->cmd.type) {
|
|
case QXL_CMD_DRAW:
|
|
update = container_of(ext, SimpleSpiceUpdate, ext);
|
|
qemu_spice_destroy_update(ssd, update);
|
|
break;
|
|
case QXL_CMD_CURSOR:
|
|
cursor = container_of(ext, SimpleSpiceCursor, ext);
|
|
g_free(cursor);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
}
|
|
|
|
static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
int ret;
|
|
|
|
dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
if (ssd->ptr_define) {
|
|
*ext = ssd->ptr_define->ext;
|
|
ssd->ptr_define = NULL;
|
|
ret = true;
|
|
} else if (ssd->ptr_move) {
|
|
*ext = ssd->ptr_move->ext;
|
|
ssd->ptr_move = NULL;
|
|
ret = true;
|
|
} else {
|
|
ret = false;
|
|
}
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
return ret;
|
|
}
|
|
|
|
static int interface_req_cursor_notification(QXLInstance *sin)
|
|
{
|
|
dprint(2, "%s:\n", __func__);
|
|
return 1;
|
|
}
|
|
|
|
static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
|
|
{
|
|
fprintf(stderr, "%s: abort()\n", __func__);
|
|
abort();
|
|
}
|
|
|
|
static int interface_flush_resources(QXLInstance *sin)
|
|
{
|
|
fprintf(stderr, "%s: abort()\n", __func__);
|
|
abort();
|
|
return 0;
|
|
}
|
|
|
|
static void interface_update_area_complete(QXLInstance *sin,
|
|
uint32_t surface_id,
|
|
QXLRect *dirty, uint32_t num_updated_rects)
|
|
{
|
|
/* should never be called, used in qxl native mode only */
|
|
fprintf(stderr, "%s: abort()\n", __func__);
|
|
abort();
|
|
}
|
|
|
|
/* called from spice server thread context only */
|
|
static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
|
|
{
|
|
QXLCookie *cookie = (QXLCookie *)(uintptr_t)cookie_token;
|
|
|
|
switch (cookie->type) {
|
|
#ifdef HAVE_SPICE_GL
|
|
case QXL_COOKIE_TYPE_GL_DRAW_DONE:
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
qemu_bh_schedule(ssd->gl_unblock_bh);
|
|
break;
|
|
}
|
|
case QXL_COOKIE_TYPE_IO:
|
|
if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
|
|
g_free(cookie->u.data);
|
|
}
|
|
break;
|
|
#endif
|
|
default:
|
|
/* should never be called, used in qxl native mode only */
|
|
fprintf(stderr, "%s: abort()\n", __func__);
|
|
abort();
|
|
}
|
|
g_free(cookie);
|
|
}
|
|
|
|
static void interface_set_client_capabilities(QXLInstance *sin,
|
|
uint8_t client_present,
|
|
uint8_t caps[58])
|
|
{
|
|
dprint(3, "%s:\n", __func__);
|
|
}
|
|
|
|
static int interface_client_monitors_config(QXLInstance *sin,
|
|
VDAgentMonitorsConfig *mc)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
|
|
QemuUIInfo info;
|
|
int head;
|
|
|
|
if (!dpy_ui_info_supported(ssd->dcl.con)) {
|
|
return 0; /* == not supported by guest */
|
|
}
|
|
|
|
if (!mc) {
|
|
return 1;
|
|
}
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
head = qemu_console_get_head(ssd->dcl.con);
|
|
if (mc->num_of_monitors > head) {
|
|
info.width = mc->monitors[head].width;
|
|
info.height = mc->monitors[head].height;
|
|
}
|
|
dpy_set_ui_info(ssd->dcl.con, &info);
|
|
dprint(1, "%s/%d: size %dx%d\n", __func__, ssd->qxl.id,
|
|
info.width, info.height);
|
|
return 1;
|
|
}
|
|
|
|
static const QXLInterface dpy_interface = {
|
|
.base.type = SPICE_INTERFACE_QXL,
|
|
.base.description = "qemu simple display",
|
|
.base.major_version = SPICE_INTERFACE_QXL_MAJOR,
|
|
.base.minor_version = SPICE_INTERFACE_QXL_MINOR,
|
|
|
|
.attache_worker = interface_attach_worker,
|
|
.set_compression_level = interface_set_compression_level,
|
|
#if SPICE_NEEDS_SET_MM_TIME
|
|
.set_mm_time = interface_set_mm_time,
|
|
#endif
|
|
.get_init_info = interface_get_init_info,
|
|
|
|
/* the callbacks below are called from spice server thread context */
|
|
.get_command = interface_get_command,
|
|
.req_cmd_notification = interface_req_cmd_notification,
|
|
.release_resource = interface_release_resource,
|
|
.get_cursor_command = interface_get_cursor_command,
|
|
.req_cursor_notification = interface_req_cursor_notification,
|
|
.notify_update = interface_notify_update,
|
|
.flush_resources = interface_flush_resources,
|
|
.async_complete = interface_async_complete,
|
|
.update_area_complete = interface_update_area_complete,
|
|
.set_client_capabilities = interface_set_client_capabilities,
|
|
.client_monitors_config = interface_client_monitors_config,
|
|
};
|
|
|
|
static void display_update(DisplayChangeListener *dcl,
|
|
int x, int y, int w, int h)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
qemu_spice_display_update(ssd, x, y, w, h);
|
|
}
|
|
|
|
static void display_switch(DisplayChangeListener *dcl,
|
|
DisplaySurface *surface)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
qemu_spice_display_switch(ssd, surface);
|
|
}
|
|
|
|
static void display_refresh(DisplayChangeListener *dcl)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
qemu_spice_display_refresh(ssd);
|
|
}
|
|
|
|
static void display_mouse_set(DisplayChangeListener *dcl,
|
|
int x, int y, int on)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
ssd->ptr_x = x;
|
|
ssd->ptr_y = y;
|
|
g_free(ssd->ptr_move);
|
|
ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL, on);
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
qemu_spice_wakeup(ssd);
|
|
}
|
|
|
|
static void display_mouse_define(DisplayChangeListener *dcl,
|
|
QEMUCursor *c)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
|
|
qemu_mutex_lock(&ssd->lock);
|
|
cursor_get(c);
|
|
cursor_put(ssd->cursor);
|
|
ssd->cursor = c;
|
|
ssd->hot_x = c->hot_x;
|
|
ssd->hot_y = c->hot_y;
|
|
g_free(ssd->ptr_move);
|
|
ssd->ptr_move = NULL;
|
|
g_free(ssd->ptr_define);
|
|
ssd->ptr_define = qemu_spice_create_cursor_update(ssd, c, 0);
|
|
qemu_mutex_unlock(&ssd->lock);
|
|
qemu_spice_wakeup(ssd);
|
|
}
|
|
|
|
static const DisplayChangeListenerOps display_listener_ops = {
|
|
.dpy_name = "spice",
|
|
.dpy_gfx_update = display_update,
|
|
.dpy_gfx_switch = display_switch,
|
|
.dpy_gfx_check_format = qemu_pixman_check_format,
|
|
.dpy_refresh = display_refresh,
|
|
.dpy_mouse_set = display_mouse_set,
|
|
.dpy_cursor_define = display_mouse_define,
|
|
};
|
|
|
|
#ifdef HAVE_SPICE_GL
|
|
|
|
static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
|
|
int x, int y, int w, int h)
|
|
{
|
|
QXLMonitorsConfig *config;
|
|
QXLCookie *cookie;
|
|
|
|
config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
|
|
config->count = 1;
|
|
config->max_allowed = 1;
|
|
config->heads[0].x = x;
|
|
config->heads[0].y = y;
|
|
config->heads[0].width = w;
|
|
config->heads[0].height = h;
|
|
cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
|
|
QXL_IO_MONITORS_CONFIG_ASYNC);
|
|
cookie->u.data = config;
|
|
|
|
spice_qxl_monitors_config_async(&ssd->qxl,
|
|
(uintptr_t)config,
|
|
MEMSLOT_GROUP_HOST,
|
|
(uintptr_t)cookie);
|
|
}
|
|
|
|
static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
|
|
{
|
|
uint64_t timeout;
|
|
|
|
if (block) {
|
|
timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
|
|
timeout += 1000; /* one sec */
|
|
timer_mod(ssd->gl_unblock_timer, timeout);
|
|
} else {
|
|
timer_del(ssd->gl_unblock_timer);
|
|
}
|
|
graphic_hw_gl_block(ssd->dcl.con, block);
|
|
}
|
|
|
|
static void qemu_spice_gl_unblock_bh(void *opaque)
|
|
{
|
|
SimpleSpiceDisplay *ssd = opaque;
|
|
|
|
qemu_spice_gl_block(ssd, false);
|
|
}
|
|
|
|
static void qemu_spice_gl_block_timer(void *opaque)
|
|
{
|
|
warn_report("spice: no gl-draw-done within one second");
|
|
}
|
|
|
|
static void spice_gl_refresh(DisplayChangeListener *dcl)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
uint64_t cookie;
|
|
|
|
if (!ssd->ds || qemu_console_is_gl_blocked(ssd->dcl.con)) {
|
|
return;
|
|
}
|
|
|
|
graphic_hw_update(dcl->con);
|
|
if (ssd->gl_updates && ssd->have_surface) {
|
|
qemu_spice_gl_block(ssd, true);
|
|
cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
|
|
spice_qxl_gl_draw_async(&ssd->qxl, 0, 0,
|
|
surface_width(ssd->ds),
|
|
surface_height(ssd->ds),
|
|
cookie);
|
|
ssd->gl_updates = 0;
|
|
}
|
|
}
|
|
|
|
static void spice_gl_update(DisplayChangeListener *dcl,
|
|
int x, int y, int w, int h)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
|
|
surface_gl_update_texture(ssd->gls, ssd->ds, x, y, w, h);
|
|
ssd->gl_updates++;
|
|
}
|
|
|
|
static void spice_gl_switch(DisplayChangeListener *dcl,
|
|
struct DisplaySurface *new_surface)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
EGLint stride, fourcc;
|
|
int fd;
|
|
|
|
if (ssd->ds) {
|
|
surface_gl_destroy_texture(ssd->gls, ssd->ds);
|
|
}
|
|
ssd->ds = new_surface;
|
|
if (ssd->ds) {
|
|
surface_gl_create_texture(ssd->gls, ssd->ds);
|
|
fd = egl_get_fd_for_texture(ssd->ds->texture,
|
|
&stride, &fourcc);
|
|
if (fd < 0) {
|
|
surface_gl_destroy_texture(ssd->gls, ssd->ds);
|
|
return;
|
|
}
|
|
|
|
dprint(1, "%s: %dx%d (stride %d/%d, fourcc 0x%x)\n", __func__,
|
|
surface_width(ssd->ds), surface_height(ssd->ds),
|
|
surface_stride(ssd->ds), stride, fourcc);
|
|
|
|
/* note: spice server will close the fd */
|
|
spice_qxl_gl_scanout(&ssd->qxl, fd,
|
|
surface_width(ssd->ds),
|
|
surface_height(ssd->ds),
|
|
stride, fourcc, false);
|
|
ssd->have_surface = true;
|
|
ssd->have_scanout = false;
|
|
|
|
qemu_spice_gl_monitor_config(ssd, 0, 0,
|
|
surface_width(ssd->ds),
|
|
surface_height(ssd->ds));
|
|
}
|
|
}
|
|
|
|
static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
|
|
QEMUGLParams *params)
|
|
{
|
|
eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
qemu_egl_rn_ctx);
|
|
return qemu_egl_create_context(dcl, params);
|
|
}
|
|
|
|
static void qemu_spice_gl_scanout_disable(DisplayChangeListener *dcl)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
|
|
dprint(1, "%s: no framebuffer\n", __func__);
|
|
spice_qxl_gl_scanout(&ssd->qxl, -1, 0, 0, 0, 0, false);
|
|
qemu_spice_gl_monitor_config(ssd, 0, 0, 0, 0);
|
|
ssd->have_surface = false;
|
|
ssd->have_scanout = false;
|
|
}
|
|
|
|
static void qemu_spice_gl_scanout_texture(DisplayChangeListener *dcl,
|
|
uint32_t tex_id,
|
|
bool y_0_top,
|
|
uint32_t backing_width,
|
|
uint32_t backing_height,
|
|
uint32_t x, uint32_t y,
|
|
uint32_t w, uint32_t h)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
EGLint stride = 0, fourcc = 0;
|
|
int fd = -1;
|
|
|
|
assert(tex_id);
|
|
fd = egl_get_fd_for_texture(tex_id, &stride, &fourcc);
|
|
if (fd < 0) {
|
|
fprintf(stderr, "%s: failed to get fd for texture\n", __func__);
|
|
return;
|
|
}
|
|
dprint(1, "%s: %dx%d (stride %d, fourcc 0x%x)\n", __func__,
|
|
w, h, stride, fourcc);
|
|
|
|
/* note: spice server will close the fd */
|
|
spice_qxl_gl_scanout(&ssd->qxl, fd, backing_width, backing_height,
|
|
stride, fourcc, y_0_top);
|
|
qemu_spice_gl_monitor_config(ssd, x, y, w, h);
|
|
ssd->have_surface = false;
|
|
ssd->have_scanout = true;
|
|
}
|
|
|
|
static void qemu_spice_gl_update(DisplayChangeListener *dcl,
|
|
uint32_t x, uint32_t y, uint32_t w, uint32_t h)
|
|
{
|
|
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
|
|
uint64_t cookie;
|
|
|
|
if (!ssd->have_scanout) {
|
|
return;
|
|
}
|
|
|
|
dprint(2, "%s: %dx%d+%d+%d\n", __func__, w, h, x, y);
|
|
qemu_spice_gl_block(ssd, true);
|
|
cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
|
|
spice_qxl_gl_draw_async(&ssd->qxl, x, y, w, h, cookie);
|
|
}
|
|
|
|
static const DisplayChangeListenerOps display_listener_gl_ops = {
|
|
.dpy_name = "spice-egl",
|
|
.dpy_gfx_update = spice_gl_update,
|
|
.dpy_gfx_switch = spice_gl_switch,
|
|
.dpy_gfx_check_format = console_gl_check_format,
|
|
.dpy_refresh = spice_gl_refresh,
|
|
.dpy_mouse_set = display_mouse_set,
|
|
.dpy_cursor_define = display_mouse_define,
|
|
|
|
.dpy_gl_ctx_create = qemu_spice_gl_create_context,
|
|
.dpy_gl_ctx_destroy = qemu_egl_destroy_context,
|
|
.dpy_gl_ctx_make_current = qemu_egl_make_context_current,
|
|
.dpy_gl_ctx_get_current = qemu_egl_get_current_context,
|
|
|
|
.dpy_gl_scanout_disable = qemu_spice_gl_scanout_disable,
|
|
.dpy_gl_scanout_texture = qemu_spice_gl_scanout_texture,
|
|
.dpy_gl_update = qemu_spice_gl_update,
|
|
};
|
|
|
|
#endif /* HAVE_SPICE_GL */
|
|
|
|
static void qemu_spice_display_init_one(QemuConsole *con)
|
|
{
|
|
SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
|
|
|
|
qemu_spice_display_init_common(ssd);
|
|
|
|
ssd->dcl.ops = &display_listener_ops;
|
|
#ifdef HAVE_SPICE_GL
|
|
if (spice_opengl) {
|
|
ssd->dcl.ops = &display_listener_gl_ops;
|
|
ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
|
|
ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
|
|
qemu_spice_gl_block_timer, ssd);
|
|
ssd->gls = qemu_gl_init_shader();
|
|
ssd->have_surface = false;
|
|
ssd->have_scanout = false;
|
|
}
|
|
#endif
|
|
ssd->dcl.con = con;
|
|
|
|
ssd->qxl.base.sif = &dpy_interface.base;
|
|
qemu_spice_add_display_interface(&ssd->qxl, con);
|
|
qemu_spice_create_host_memslot(ssd);
|
|
|
|
register_displaychangelistener(&ssd->dcl);
|
|
}
|
|
|
|
void qemu_spice_display_init(void)
|
|
{
|
|
QemuOptsList *olist = qemu_find_opts("spice");
|
|
QemuOpts *opts = QTAILQ_FIRST(&olist->head);
|
|
QemuConsole *spice_con, *con;
|
|
const char *str;
|
|
int i;
|
|
|
|
str = qemu_opt_get(opts, "display");
|
|
if (str) {
|
|
int head = qemu_opt_get_number(opts, "head", 0);
|
|
Error *err = NULL;
|
|
|
|
spice_con = qemu_console_lookup_by_device_name(str, head, &err);
|
|
if (err) {
|
|
error_report("Failed to lookup display/head");
|
|
exit(1);
|
|
}
|
|
} else {
|
|
spice_con = NULL;
|
|
}
|
|
|
|
for (i = 0;; i++) {
|
|
con = qemu_console_lookup_by_index(i);
|
|
if (!con || !qemu_console_is_graphic(con)) {
|
|
break;
|
|
}
|
|
if (qemu_spice_have_display_interface(con)) {
|
|
continue;
|
|
}
|
|
if (spice_con != NULL && spice_con != con) {
|
|
continue;
|
|
}
|
|
qemu_spice_display_init_one(con);
|
|
}
|
|
}
|