[qemu.git] / hw / display / vhost-user-gpu.c

/*
 * vhost-user GPU Device
 *
 * Copyright Red Hat, Inc. 2018
 *
 * Authors:
 *     Marc-André Lureau <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"
#include "hw/virtio/virtio-gpu.h"
#include "chardev/char-fe.h"
#include "qapi/error.h"
#include "migration/blocker.h"

#define VHOST_USER_GPU(obj)                                    \
    OBJECT_CHECK(VhostUserGPU, (obj), TYPE_VHOST_USER_GPU)

typedef enum VhostUserGpuRequest {
    VHOST_USER_GPU_NONE = 0,
    VHOST_USER_GPU_GET_PROTOCOL_FEATURES,
    VHOST_USER_GPU_SET_PROTOCOL_FEATURES,
    VHOST_USER_GPU_GET_DISPLAY_INFO,
    VHOST_USER_GPU_CURSOR_POS,
    VHOST_USER_GPU_CURSOR_POS_HIDE,
    VHOST_USER_GPU_CURSOR_UPDATE,
    VHOST_USER_GPU_SCANOUT,
    VHOST_USER_GPU_UPDATE,
    VHOST_USER_GPU_DMABUF_SCANOUT,
    VHOST_USER_GPU_DMABUF_UPDATE,
} VhostUserGpuRequest;

typedef struct VhostUserGpuDisplayInfoReply {
    struct virtio_gpu_resp_display_info info;
} VhostUserGpuDisplayInfoReply;

typedef struct VhostUserGpuCursorPos {
    uint32_t scanout_id;
    uint32_t x;
    uint32_t y;
} QEMU_PACKED VhostUserGpuCursorPos;

typedef struct VhostUserGpuCursorUpdate {
    VhostUserGpuCursorPos pos;
    uint32_t hot_x;
    uint32_t hot_y;
    uint32_t data[64 * 64];
} QEMU_PACKED VhostUserGpuCursorUpdate;

typedef struct VhostUserGpuScanout {
    uint32_t scanout_id;
    uint32_t width;
    uint32_t height;
} QEMU_PACKED VhostUserGpuScanout;

typedef struct VhostUserGpuUpdate {
    uint32_t scanout_id;
    uint32_t x;
    uint32_t y;
    uint32_t width;
    uint32_t height;
    uint8_t data[];
} QEMU_PACKED VhostUserGpuUpdate;

typedef struct VhostUserGpuDMABUFScanout {
    uint32_t scanout_id;
    uint32_t x;
    uint32_t y;
    uint32_t width;
    uint32_t height;
    uint32_t fd_width;
    uint32_t fd_height;
    uint32_t fd_stride;
    uint32_t fd_flags;
    int fd_drm_fourcc;
} QEMU_PACKED VhostUserGpuDMABUFScanout;

typedef struct VhostUserGpuMsg {
    uint32_t request; /* VhostUserGpuRequest */
    uint32_t flags;
    uint32_t size; /* the following payload size */
    union {
        VhostUserGpuCursorPos cursor_pos;
        VhostUserGpuCursorUpdate cursor_update;
        VhostUserGpuScanout scanout;
        VhostUserGpuUpdate update;
        VhostUserGpuDMABUFScanout dmabuf_scanout;
        struct virtio_gpu_resp_display_info display_info;
        uint64_t u64;
    } payload;
} QEMU_PACKED VhostUserGpuMsg;

static VhostUserGpuMsg m __attribute__ ((unused));
#define VHOST_USER_GPU_HDR_SIZE \
    (sizeof(m.request) + sizeof(m.size) + sizeof(m.flags))

#define VHOST_USER_GPU_MSG_FLAG_REPLY 0x4

static void vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked);

static void
vhost_user_gpu_handle_cursor(VhostUserGPU *g, VhostUserGpuMsg *msg)
{
    VhostUserGpuCursorPos *pos = &msg->payload.cursor_pos;
    struct virtio_gpu_scanout *s;

    if (pos->scanout_id >= g->parent_obj.conf.max_outputs) {
        return;
    }
    s = &g->parent_obj.scanout[pos->scanout_id];

    if (msg->request == VHOST_USER_GPU_CURSOR_UPDATE) {
        VhostUserGpuCursorUpdate *up = &msg->payload.cursor_update;
        if (!s->current_cursor) {
            s->current_cursor = cursor_alloc(64, 64);
        }

        s->current_cursor->hot_x = up->hot_x;
        s->current_cursor->hot_y = up->hot_y;

        memcpy(s->current_cursor->data, up->data,
               64 * 64 * sizeof(uint32_t));

        dpy_cursor_define(s->con, s->current_cursor);
    }

    dpy_mouse_set(s->con, pos->x, pos->y,
                  msg->request != VHOST_USER_GPU_CURSOR_POS_HIDE);
}

static void
vhost_user_gpu_send_msg(VhostUserGPU *g, const VhostUserGpuMsg *msg)
{
    qemu_chr_fe_write(&g->vhost_chr, (uint8_t *)msg,
                      VHOST_USER_GPU_HDR_SIZE + msg->size);
}

static void
vhost_user_gpu_unblock(VhostUserGPU *g)
{
    VhostUserGpuMsg msg = {
        .request = VHOST_USER_GPU_DMABUF_UPDATE,
        .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
    };

    vhost_user_gpu_send_msg(g, &msg);
}

static void
vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
{
    QemuConsole *con = NULL;
    struct virtio_gpu_scanout *s;

    switch (msg->request) {
    case VHOST_USER_GPU_GET_PROTOCOL_FEATURES: {
        VhostUserGpuMsg reply = {
            .request = msg->request,
            .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
            .size = sizeof(uint64_t),
        };

        vhost_user_gpu_send_msg(g, &reply);
        break;
    }
    case VHOST_USER_GPU_SET_PROTOCOL_FEATURES: {
        break;
    }
    case VHOST_USER_GPU_GET_DISPLAY_INFO: {
        struct virtio_gpu_resp_display_info display_info = { {} };
        VhostUserGpuMsg reply = {
            .request = msg->request,
            .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
            .size = sizeof(struct virtio_gpu_resp_display_info),
        };

        display_info.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO;
        virtio_gpu_base_fill_display_info(VIRTIO_GPU_BASE(g), &display_info);
        memcpy(&reply.payload.display_info, &display_info,
               sizeof(display_info));
        vhost_user_gpu_send_msg(g, &reply);
        break;
    }
    case VHOST_USER_GPU_SCANOUT: {
        VhostUserGpuScanout *m = &msg->payload.scanout;

        if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
            return;
        }

        g->parent_obj.enable = 1;
        s = &g->parent_obj.scanout[m->scanout_id];
        con = s->con;

        if (m->scanout_id == 0 && m->width == 0) {
            s->ds = qemu_create_message_surface(640, 480,
                                                "Guest disabled display.");
            dpy_gfx_replace_surface(con, s->ds);
        } else {
            s->ds = qemu_create_displaysurface(m->width, m->height);
            /* replace surface on next update */
        }

        break;
    }
    case VHOST_USER_GPU_DMABUF_SCANOUT: {
        VhostUserGpuDMABUFScanout *m = &msg->payload.dmabuf_scanout;
        int fd = qemu_chr_fe_get_msgfd(&g->vhost_chr);
        QemuDmaBuf *dmabuf;

        if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
            error_report("invalid scanout: %d", m->scanout_id);
            if (fd >= 0) {
                close(fd);
            }
            break;
        }

        g->parent_obj.enable = 1;
        con = g->parent_obj.scanout[m->scanout_id].con;
        dmabuf = &g->dmabuf[m->scanout_id];
        if (dmabuf->fd >= 0) {
            close(dmabuf->fd);
            dmabuf->fd = -1;
        }
        if (!console_has_gl_dmabuf(con)) {
            /* it would be nice to report that error earlier */
            error_report("console doesn't support dmabuf!");
            break;
        }
        dpy_gl_release_dmabuf(con, dmabuf);
        if (fd == -1) {
            dpy_gl_scanout_disable(con);
            break;
        }
        *dmabuf = (QemuDmaBuf) {
            .fd = fd,
            .width = m->fd_width,
            .height = m->fd_height,
            .stride = m->fd_stride,
            .fourcc = m->fd_drm_fourcc,
            .y0_top = m->fd_flags & VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP,
        };
        dpy_gl_scanout_dmabuf(con, dmabuf);
        break;
    }
    case VHOST_USER_GPU_DMABUF_UPDATE: {
        VhostUserGpuUpdate *m = &msg->payload.update;

        if (m->scanout_id >= g->parent_obj.conf.max_outputs ||
            !g->parent_obj.scanout[m->scanout_id].con) {
            error_report("invalid scanout update: %d", m->scanout_id);
            vhost_user_gpu_unblock(g);
            break;
        }

        con = g->parent_obj.scanout[m->scanout_id].con;
        if (!console_has_gl(con)) {
            error_report("console doesn't support GL!");
            vhost_user_gpu_unblock(g);
            break;
        }
        dpy_gl_update(con, m->x, m->y, m->width, m->height);
        g->backend_blocked = true;
        break;
    }
    case VHOST_USER_GPU_UPDATE: {
        VhostUserGpuUpdate *m = &msg->payload.update;

        if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
            break;
        }
        s = &g->parent_obj.scanout[m->scanout_id];
        con = s->con;
        pixman_image_t *image =
            pixman_image_create_bits(PIXMAN_x8r8g8b8,
                                     m->width,
                                     m->height,
                                     (uint32_t *)m->data,
                                     m->width * 4);

        pixman_image_composite(PIXMAN_OP_SRC,
                               image, NULL, s->ds->image,
                               0, 0, 0, 0, m->x, m->y, m->width, m->height);

        pixman_image_unref(image);
        if (qemu_console_surface(con) != s->ds) {
            dpy_gfx_replace_surface(con, s->ds);
        } else {
            dpy_gfx_update(con, m->x, m->y, m->width, m->height);
        }
        break;
    }
    default:
        g_warning("unhandled message %d %d", msg->request, msg->size);
    }

    if (con && qemu_console_is_gl_blocked(con)) {
        vhost_user_gpu_update_blocked(g, true);
    }
}

static void
vhost_user_gpu_chr_read(void *opaque)
{
    VhostUserGPU *g = opaque;
    VhostUserGpuMsg *msg = NULL;
    VhostUserGpuRequest request;
    uint32_t size, flags;
    int r;

    r = qemu_chr_fe_read_all(&g->vhost_chr,
                             (uint8_t *)&request, sizeof(uint32_t));
    if (r != sizeof(uint32_t)) {
        error_report("failed to read msg header: %d, %d", r, errno);
        goto end;
    }

    r = qemu_chr_fe_read_all(&g->vhost_chr,
                             (uint8_t *)&flags, sizeof(uint32_t));
    if (r != sizeof(uint32_t)) {
        error_report("failed to read msg flags");
        goto end;
    }

    r = qemu_chr_fe_read_all(&g->vhost_chr,
                             (uint8_t *)&size, sizeof(uint32_t));
    if (r != sizeof(uint32_t)) {
        error_report("failed to read msg size");
        goto end;
    }

    msg = g_malloc(VHOST_USER_GPU_HDR_SIZE + size);
    g_return_if_fail(msg != NULL);

    r = qemu_chr_fe_read_all(&g->vhost_chr,
                             (uint8_t *)&msg->payload, size);
    if (r != size) {
        error_report("failed to read msg payload %d != %d", r, size);
        goto end;
    }

    msg->request = request;
    msg->flags = size;
    msg->size = size;

    if (request == VHOST_USER_GPU_CURSOR_UPDATE ||
        request == VHOST_USER_GPU_CURSOR_POS ||
        request == VHOST_USER_GPU_CURSOR_POS_HIDE) {
        vhost_user_gpu_handle_cursor(g, msg);
    } else {
        vhost_user_gpu_handle_display(g, msg);
    }

end:
    g_free(msg);
}

static void
vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked)
{
    qemu_set_fd_handler(g->vhost_gpu_fd,
                        blocked ? NULL : vhost_user_gpu_chr_read, NULL, g);
}

static void
vhost_user_gpu_gl_unblock(VirtIOGPUBase *b)
{
    VhostUserGPU *g = VHOST_USER_GPU(b);

    if (g->backend_blocked) {
        vhost_user_gpu_unblock(VHOST_USER_GPU(g));
        g->backend_blocked = false;
    }

    vhost_user_gpu_update_blocked(VHOST_USER_GPU(g), false);
}

static bool
vhost_user_gpu_do_set_socket(VhostUserGPU *g, Error **errp)
{
    Chardev *chr;
    int sv[2];

    if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
        error_setg_errno(errp, errno, "socketpair() failed");
        return false;
    }

    chr = CHARDEV(object_new(TYPE_CHARDEV_SOCKET));
    if (!chr || qemu_chr_add_client(chr, sv[0]) == -1) {
        error_setg(errp, "Failed to make socket chardev");
        goto err;
    }
    if (!qemu_chr_fe_init(&g->vhost_chr, chr, errp)) {
        goto err;
    }
    if (vhost_user_gpu_set_socket(&g->vhost->dev, sv[1]) < 0) {
        error_setg(errp, "Failed to set vhost-user-gpu socket");
        qemu_chr_fe_deinit(&g->vhost_chr, false);
        goto err;
    }

    g->vhost_gpu_fd = sv[0];
    vhost_user_gpu_update_blocked(g, false);
    close(sv[1]);
    return true;

err:
    close(sv[0]);
    close(sv[1]);
    if (chr) {
        object_unref(OBJECT(chr));
    }
    return false;
}

static void
vhost_user_gpu_get_config(VirtIODevice *vdev, uint8_t *config_data)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);
    VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
    struct virtio_gpu_config *vgconfig =
        (struct virtio_gpu_config *)config_data;
    int ret;

    memset(config_data, 0, sizeof(struct virtio_gpu_config));

    ret = vhost_dev_get_config(&g->vhost->dev,
                               config_data, sizeof(struct virtio_gpu_config));
    if (ret) {
        error_report("vhost-user-gpu: get device config space failed");
        return;
    }

    /* those fields are managed by qemu */
    vgconfig->num_scanouts = b->virtio_config.num_scanouts;
    vgconfig->events_read = b->virtio_config.events_read;
    vgconfig->events_clear = b->virtio_config.events_clear;
}

static void
vhost_user_gpu_set_config(VirtIODevice *vdev,
                          const uint8_t *config_data)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);
    VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
    const struct virtio_gpu_config *vgconfig =
        (const struct virtio_gpu_config *)config_data;
    int ret;

    if (vgconfig->events_clear) {
        b->virtio_config.events_read &= ~vgconfig->events_clear;
    }

    ret = vhost_dev_set_config(&g->vhost->dev, config_data,
                               0, sizeof(struct virtio_gpu_config),
                               VHOST_SET_CONFIG_TYPE_MASTER);
    if (ret) {
        error_report("vhost-user-gpu: set device config space failed");
        return;
    }
}

static void
vhost_user_gpu_set_status(VirtIODevice *vdev, uint8_t val)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);
    Error *err = NULL;

    if (val & VIRTIO_CONFIG_S_DRIVER_OK && vdev->vm_running) {
        if (!vhost_user_gpu_do_set_socket(g, &err)) {
            error_report_err(err);
            return;
        }
        vhost_user_backend_start(g->vhost);
    } else {
        /* unblock any wait and stop processing */
        if (g->vhost_gpu_fd != -1) {
            vhost_user_gpu_update_blocked(g, true);
            qemu_chr_fe_deinit(&g->vhost_chr, true);
            g->vhost_gpu_fd = -1;
        }
        vhost_user_backend_stop(g->vhost);
    }
}

static bool
vhost_user_gpu_guest_notifier_pending(VirtIODevice *vdev, int idx)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);

    return vhost_virtqueue_pending(&g->vhost->dev, idx);
}

static void
vhost_user_gpu_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);

    vhost_virtqueue_mask(&g->vhost->dev, vdev, idx, mask);
}

static void
vhost_user_gpu_instance_init(Object *obj)
{
    VhostUserGPU *g = VHOST_USER_GPU(obj);

    g->vhost = VHOST_USER_BACKEND(object_new(TYPE_VHOST_USER_BACKEND));
    object_property_add_alias(obj, "chardev",
                              OBJECT(g->vhost), "chardev", &error_abort);
}

static void
vhost_user_gpu_instance_finalize(Object *obj)
{
    VhostUserGPU *g = VHOST_USER_GPU(obj);

    object_unref(OBJECT(g->vhost));
}

static void
vhost_user_gpu_reset(VirtIODevice *vdev)
{
    VhostUserGPU *g = VHOST_USER_GPU(vdev);

    virtio_gpu_base_reset(VIRTIO_GPU_BASE(vdev));

    vhost_user_backend_stop(g->vhost);
}

static int
vhost_user_gpu_config_change(struct vhost_dev *dev)
{
    error_report("vhost-user-gpu: unhandled backend config change");
    return -1;
}

static const VhostDevConfigOps config_ops = {
    .vhost_dev_config_notifier = vhost_user_gpu_config_change,
};

static void
vhost_user_gpu_device_realize(DeviceState *qdev, Error **errp)
{
    VhostUserGPU *g = VHOST_USER_GPU(qdev);
    VirtIODevice *vdev = VIRTIO_DEVICE(g);

    vhost_dev_set_config_notifier(&g->vhost->dev, &config_ops);
    if (vhost_user_backend_dev_init(g->vhost, vdev, 2, errp) < 0) {
        return;
    }

    if (virtio_has_feature(g->vhost->dev.features, VIRTIO_GPU_F_VIRGL)) {
        g->parent_obj.conf.flags |= 1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED;
    }

    if (!virtio_gpu_base_device_realize(qdev, NULL, NULL, errp)) {
        return;
    }

    g->vhost_gpu_fd = -1;
}

static Property vhost_user_gpu_properties[] = {
    VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU, parent_obj.conf),
    DEFINE_PROP_END_OF_LIST(),
};

static void
vhost_user_gpu_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
    VirtIOGPUBaseClass *vgc = VIRTIO_GPU_BASE_CLASS(klass);

    vgc->gl_unblock = vhost_user_gpu_gl_unblock;

    vdc->realize = vhost_user_gpu_device_realize;
    vdc->reset = vhost_user_gpu_reset;
    vdc->set_status   = vhost_user_gpu_set_status;
    vdc->guest_notifier_mask = vhost_user_gpu_guest_notifier_mask;
    vdc->guest_notifier_pending = vhost_user_gpu_guest_notifier_pending;
    vdc->get_config = vhost_user_gpu_get_config;
    vdc->set_config = vhost_user_gpu_set_config;

    dc->props = vhost_user_gpu_properties;
}

static const TypeInfo vhost_user_gpu_info = {
    .name = TYPE_VHOST_USER_GPU,
    .parent = TYPE_VIRTIO_GPU_BASE,
    .instance_size = sizeof(VhostUserGPU),
    .instance_init = vhost_user_gpu_instance_init,
    .instance_finalize = vhost_user_gpu_instance_finalize,
    .class_init = vhost_user_gpu_class_init,
};

static void vhost_user_gpu_register_types(void)
{
    type_register_static(&vhost_user_gpu_info);
}

type_init(vhost_user_gpu_register_types)
Commit	Line	Data
267f6646 MAL	1	/*
	2	* vhost-user GPU Device
	3	*
	4	* Copyright Red Hat, Inc. 2018
	5	*
	6	* Authors:
	7	* Marc-André Lureau <[email protected]>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12
	13	#include "qemu/osdep.h"
	14	#include "hw/virtio/virtio-gpu.h"
	15	#include "chardev/char-fe.h"
	16	#include "qapi/error.h"
	17	#include "migration/blocker.h"
	18
	19	#define VHOST_USER_GPU(obj) \
	20	OBJECT_CHECK(VhostUserGPU, (obj), TYPE_VHOST_USER_GPU)
	21
	22	typedef enum VhostUserGpuRequest {
	23	VHOST_USER_GPU_NONE = 0,
	24	VHOST_USER_GPU_GET_PROTOCOL_FEATURES,
	25	VHOST_USER_GPU_SET_PROTOCOL_FEATURES,
	26	VHOST_USER_GPU_GET_DISPLAY_INFO,
	27	VHOST_USER_GPU_CURSOR_POS,
	28	VHOST_USER_GPU_CURSOR_POS_HIDE,
	29	VHOST_USER_GPU_CURSOR_UPDATE,
	30	VHOST_USER_GPU_SCANOUT,
	31	VHOST_USER_GPU_UPDATE,
	32	VHOST_USER_GPU_DMABUF_SCANOUT,
	33	VHOST_USER_GPU_DMABUF_UPDATE,
	34	} VhostUserGpuRequest;
	35
	36	typedef struct VhostUserGpuDisplayInfoReply {
	37	struct virtio_gpu_resp_display_info info;
	38	} VhostUserGpuDisplayInfoReply;
	39
	40	typedef struct VhostUserGpuCursorPos {
	41	uint32_t scanout_id;
	42	uint32_t x;
	43	uint32_t y;
	44	} QEMU_PACKED VhostUserGpuCursorPos;
	45
	46	typedef struct VhostUserGpuCursorUpdate {
	47	VhostUserGpuCursorPos pos;
	48	uint32_t hot_x;
	49	uint32_t hot_y;
	50	uint32_t data[64 * 64];
	51	} QEMU_PACKED VhostUserGpuCursorUpdate;
	52
	53	typedef struct VhostUserGpuScanout {
	54	uint32_t scanout_id;
	55	uint32_t width;
	56	uint32_t height;
	57	} QEMU_PACKED VhostUserGpuScanout;
	58
	59	typedef struct VhostUserGpuUpdate {
	60	uint32_t scanout_id;
	61	uint32_t x;
	62	uint32_t y;
	63	uint32_t width;
	64	uint32_t height;
65	uint8_t data[];
66	} QEMU_PACKED VhostUserGpuUpdate;
67
68	typedef struct VhostUserGpuDMABUFScanout {
69	uint32_t scanout_id;
70	uint32_t x;
71	uint32_t y;
72	uint32_t width;
73	uint32_t height;
74	uint32_t fd_width;
75	uint32_t fd_height;
76	uint32_t fd_stride;
77	uint32_t fd_flags;
78	int fd_drm_fourcc;
79	} QEMU_PACKED VhostUserGpuDMABUFScanout;
80
81	typedef struct VhostUserGpuMsg {
82	uint32_t request; /* VhostUserGpuRequest */
83	uint32_t flags;
84	uint32_t size; /* the following payload size */
85	union {
86	VhostUserGpuCursorPos cursor_pos;
87	VhostUserGpuCursorUpdate cursor_update;
88	VhostUserGpuScanout scanout;
89	VhostUserGpuUpdate update;
90	VhostUserGpuDMABUFScanout dmabuf_scanout;
91	struct virtio_gpu_resp_display_info display_info;
92	uint64_t u64;
93	} payload;
94	} QEMU_PACKED VhostUserGpuMsg;
95
96	static VhostUserGpuMsg m __attribute__ ((unused));
97	#define VHOST_USER_GPU_HDR_SIZE \
98	(sizeof(m.request) + sizeof(m.size) + sizeof(m.flags))
99
100	#define VHOST_USER_GPU_MSG_FLAG_REPLY 0x4
101
102	static void vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked);
103
104	static void
105	vhost_user_gpu_handle_cursor(VhostUserGPU g, VhostUserGpuMsg msg)
106	{
107	VhostUserGpuCursorPos *pos = &msg->payload.cursor_pos;
108	struct virtio_gpu_scanout *s;
109
110	if (pos->scanout_id >= g->parent_obj.conf.max_outputs) {
111	return;
112	}
113	s = &g->parent_obj.scanout[pos->scanout_id];
114
115	if (msg->request == VHOST_USER_GPU_CURSOR_UPDATE) {
116	VhostUserGpuCursorUpdate *up = &msg->payload.cursor_update;
117	if (!s->current_cursor) {
118	s->current_cursor = cursor_alloc(64, 64);
119	}
120
121	s->current_cursor->hot_x = up->hot_x;
122	s->current_cursor->hot_y = up->hot_y;
123
124	memcpy(s->current_cursor->data, up->data,
125	64 * 64 * sizeof(uint32_t));
126
127	dpy_cursor_define(s->con, s->current_cursor);
128	}
129
130	dpy_mouse_set(s->con, pos->x, pos->y,
131	msg->request != VHOST_USER_GPU_CURSOR_POS_HIDE);
132	}
133
134	static void
135	vhost_user_gpu_send_msg(VhostUserGPU g, const VhostUserGpuMsg msg)
136	{
137	qemu_chr_fe_write(&g->vhost_chr, (uint8_t *)msg,
138	VHOST_USER_GPU_HDR_SIZE + msg->size);
139	}
140
141	static void
142	vhost_user_gpu_unblock(VhostUserGPU *g)
143	{
144	VhostUserGpuMsg msg = {
145	.request = VHOST_USER_GPU_DMABUF_UPDATE,
146	.flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
147	};
148
149	vhost_user_gpu_send_msg(g, &msg);
150	}
151
152	static void
153	vhost_user_gpu_handle_display(VhostUserGPU g, VhostUserGpuMsg msg)
154	{
155	QemuConsole *con = NULL;
156	struct virtio_gpu_scanout *s;
157
158	switch (msg->request) {
159	case VHOST_USER_GPU_GET_PROTOCOL_FEATURES: {
160	VhostUserGpuMsg reply = {
161	.request = msg->request,
162	.flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
163	.size = sizeof(uint64_t),
164	};
165
166	vhost_user_gpu_send_msg(g, &reply);
167	break;
168	}
169	case VHOST_USER_GPU_SET_PROTOCOL_FEATURES: {
170	break;
171	}
172	case VHOST_USER_GPU_GET_DISPLAY_INFO: {
173	struct virtio_gpu_resp_display_info display_info = { {} };
174	VhostUserGpuMsg reply = {
175	.request = msg->request,
176	.flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
177	.size = sizeof(struct virtio_gpu_resp_display_info),
178	};
179
180	display_info.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO;
181	virtio_gpu_base_fill_display_info(VIRTIO_GPU_BASE(g), &display_info);
182	memcpy(&reply.payload.display_info, &display_info,
183	sizeof(display_info));
184	vhost_user_gpu_send_msg(g, &reply);
185	break;
186	}
187	case VHOST_USER_GPU_SCANOUT: {
188	VhostUserGpuScanout *m = &msg->payload.scanout;
189
190	if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
191	return;
192	}
193
194	g->parent_obj.enable = 1;
195	s = &g->parent_obj.scanout[m->scanout_id];
196	con = s->con;
197
198	if (m->scanout_id == 0 && m->width == 0) {
199	s->ds = qemu_create_message_surface(640, 480,
200	"Guest disabled display.");
201	dpy_gfx_replace_surface(con, s->ds);
202	} else {
203	s->ds = qemu_create_displaysurface(m->width, m->height);
204	/* replace surface on next update */
205	}
206
207	break;
208	}
209	case VHOST_USER_GPU_DMABUF_SCANOUT: {
210	VhostUserGpuDMABUFScanout *m = &msg->payload.dmabuf_scanout;
211	int fd = qemu_chr_fe_get_msgfd(&g->vhost_chr);
212	QemuDmaBuf *dmabuf;
213
214	if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
215	error_report("invalid scanout: %d", m->scanout_id);
216	if (fd >= 0) {
217	close(fd);
218	}
219	break;
220	}
221
222	g->parent_obj.enable = 1;
223	con = g->parent_obj.scanout[m->scanout_id].con;
224	dmabuf = &g->dmabuf[m->scanout_id];
225	if (dmabuf->fd >= 0) {
226	close(dmabuf->fd);
227	dmabuf->fd = -1;
228	}
229	if (!console_has_gl_dmabuf(con)) {
230	/* it would be nice to report that error earlier */
231	error_report("console doesn't support dmabuf!");
232	break;
233	}
234	dpy_gl_release_dmabuf(con, dmabuf);
235	if (fd == -1) {
236	dpy_gl_scanout_disable(con);
237	break;
238	}
239	*dmabuf = (QemuDmaBuf) {
240	.fd = fd,
241	.width = m->fd_width,
242	.height = m->fd_height,
243	.stride = m->fd_stride,
244	.fourcc = m->fd_drm_fourcc,
245	.y0_top = m->fd_flags & VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP,
246	};
247	dpy_gl_scanout_dmabuf(con, dmabuf);
248	break;
249	}
250	case VHOST_USER_GPU_DMABUF_UPDATE: {
251	VhostUserGpuUpdate *m = &msg->payload.update;
252
253	if (m->scanout_id >= g->parent_obj.conf.max_outputs \|\|
254	!g->parent_obj.scanout[m->scanout_id].con) {
255	error_report("invalid scanout update: %d", m->scanout_id);
256	vhost_user_gpu_unblock(g);
257	break;
258	}
259
260	con = g->parent_obj.scanout[m->scanout_id].con;
261	if (!console_has_gl(con)) {
262	error_report("console doesn't support GL!");
263	vhost_user_gpu_unblock(g);
264	break;
265	}
266	dpy_gl_update(con, m->x, m->y, m->width, m->height);
267	g->backend_blocked = true;
268	break;
269	}
270	case VHOST_USER_GPU_UPDATE: {
271	VhostUserGpuUpdate *m = &msg->payload.update;
272
273	if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
274	break;
275	}
276	s = &g->parent_obj.scanout[m->scanout_id];
277	con = s->con;
278	pixman_image_t *image =
279	pixman_image_create_bits(PIXMAN_x8r8g8b8,
280	m->width,
281	m->height,
282	(uint32_t *)m->data,
283	m->width * 4);
284
285	pixman_image_composite(PIXMAN_OP_SRC,
286	image, NULL, s->ds->image,
287	0, 0, 0, 0, m->x, m->y, m->width, m->height);
288
289	pixman_image_unref(image);
290	if (qemu_console_surface(con) != s->ds) {
291	dpy_gfx_replace_surface(con, s->ds);
292	} else {
293	dpy_gfx_update(con, m->x, m->y, m->width, m->height);
294	}
295	break;
296	}
297	default:
298	g_warning("unhandled message %d %d", msg->request, msg->size);
299	}
300
301	if (con && qemu_console_is_gl_blocked(con)) {
302	vhost_user_gpu_update_blocked(g, true);
303	}
304	}
305
306	static void
307	vhost_user_gpu_chr_read(void *opaque)
308	{
309	VhostUserGPU *g = opaque;
310	VhostUserGpuMsg *msg = NULL;
311	VhostUserGpuRequest request;
312	uint32_t size, flags;
313	int r;
314
315	r = qemu_chr_fe_read_all(&g->vhost_chr,
316	(uint8_t *)&request, sizeof(uint32_t));
317	if (r != sizeof(uint32_t)) {
318	error_report("failed to read msg header: %d, %d", r, errno);
319	goto end;
320	}
321
322	r = qemu_chr_fe_read_all(&g->vhost_chr,
323	(uint8_t *)&flags, sizeof(uint32_t));
324	if (r != sizeof(uint32_t)) {
325	error_report("failed to read msg flags");
326	goto end;
327	}
328
329	r = qemu_chr_fe_read_all(&g->vhost_chr,
330	(uint8_t *)&size, sizeof(uint32_t));
331	if (r != sizeof(uint32_t)) {
332	error_report("failed to read msg size");
333	goto end;
334	}
335
336	msg = g_malloc(VHOST_USER_GPU_HDR_SIZE + size);
337	g_return_if_fail(msg != NULL);
338
339	r = qemu_chr_fe_read_all(&g->vhost_chr,
340	(uint8_t *)&msg->payload, size);
341	if (r != size) {
342	error_report("failed to read msg payload %d != %d", r, size);
343	goto end;
344	}
345
346	msg->request = request;
347	msg->flags = size;
348	msg->size = size;
349
350	if (request == VHOST_USER_GPU_CURSOR_UPDATE \|\|
351	request == VHOST_USER_GPU_CURSOR_POS \|\|
352	request == VHOST_USER_GPU_CURSOR_POS_HIDE) {
353	vhost_user_gpu_handle_cursor(g, msg);
354	} else {
355	vhost_user_gpu_handle_display(g, msg);
356	}
357
358	end:
359	g_free(msg);
360	}
361
362	static void
363	vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked)
364	{
365	qemu_set_fd_handler(g->vhost_gpu_fd,
366	blocked ? NULL : vhost_user_gpu_chr_read, NULL, g);
367	}
368
369	static void
370	vhost_user_gpu_gl_unblock(VirtIOGPUBase *b)
371	{
372	VhostUserGPU *g = VHOST_USER_GPU(b);
373
374	if (g->backend_blocked) {
375	vhost_user_gpu_unblock(VHOST_USER_GPU(g));
376	g->backend_blocked = false;
377	}
378
379	vhost_user_gpu_update_blocked(VHOST_USER_GPU(g), false);
380	}
381
382	static bool
383	vhost_user_gpu_do_set_socket(VhostUserGPU g, Error *errp)
384	{
385	Chardev *chr;
386	int sv[2];
387
388	if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
389	error_setg_errno(errp, errno, "socketpair() failed");
390	return false;
391	}
392
393	chr = CHARDEV(object_new(TYPE_CHARDEV_SOCKET));
394	if (!chr \|\| qemu_chr_add_client(chr, sv[0]) == -1) {
395	error_setg(errp, "Failed to make socket chardev");
396	goto err;
397	}
398	if (!qemu_chr_fe_init(&g->vhost_chr, chr, errp)) {
399	goto err;
400	}
401	if (vhost_user_gpu_set_socket(&g->vhost->dev, sv[1]) < 0) {
402	error_setg(errp, "Failed to set vhost-user-gpu socket");
403	qemu_chr_fe_deinit(&g->vhost_chr, false);
404	goto err;
405	}
406
407	g->vhost_gpu_fd = sv[0];
408	vhost_user_gpu_update_blocked(g, false);
409	close(sv[1]);
410	return true;
411
412	err:
413	close(sv[0]);
414	close(sv[1]);
415	if (chr) {
416	object_unref(OBJECT(chr));
417	}
418	return false;
419	}
420
421	static void
422	vhost_user_gpu_get_config(VirtIODevice vdev, uint8_t config_data)
423	{
424	VhostUserGPU *g = VHOST_USER_GPU(vdev);
425	VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
426	struct virtio_gpu_config *vgconfig =
427	(struct virtio_gpu_config *)config_data;
428	int ret;
429
430	memset(config_data, 0, sizeof(struct virtio_gpu_config));
431
432	ret = vhost_dev_get_config(&g->vhost->dev,
433	config_data, sizeof(struct virtio_gpu_config));
434	if (ret) {
435	error_report("vhost-user-gpu: get device config space failed");
436	return;
437	}
438
439	/* those fields are managed by qemu */
440	vgconfig->num_scanouts = b->virtio_config.num_scanouts;
441	vgconfig->events_read = b->virtio_config.events_read;
442	vgconfig->events_clear = b->virtio_config.events_clear;
443	}
444
445	static void
446	vhost_user_gpu_set_config(VirtIODevice *vdev,
447	const uint8_t *config_data)
448	{
449	VhostUserGPU *g = VHOST_USER_GPU(vdev);
450	VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
451	const struct virtio_gpu_config *vgconfig =
452	(const struct virtio_gpu_config *)config_data;
453	int ret;
454
455	if (vgconfig->events_clear) {
456	b->virtio_config.events_read &= ~vgconfig->events_clear;
457	}
458
459	ret = vhost_dev_set_config(&g->vhost->dev, config_data,
460	0, sizeof(struct virtio_gpu_config),
461	VHOST_SET_CONFIG_TYPE_MASTER);
462	if (ret) {
463	error_report("vhost-user-gpu: set device config space failed");
464	return;
465	}
466	}
467
468	static void
469	vhost_user_gpu_set_status(VirtIODevice *vdev, uint8_t val)
470	{
471	VhostUserGPU *g = VHOST_USER_GPU(vdev);
472	Error *err = NULL;
473
474	if (val & VIRTIO_CONFIG_S_DRIVER_OK && vdev->vm_running) {
475	if (!vhost_user_gpu_do_set_socket(g, &err)) {
476	error_report_err(err);
477	return;
478	}
479	vhost_user_backend_start(g->vhost);
480	} else {
481	/* unblock any wait and stop processing */
482	if (g->vhost_gpu_fd != -1) {
483	vhost_user_gpu_update_blocked(g, true);
484	qemu_chr_fe_deinit(&g->vhost_chr, true);
485	g->vhost_gpu_fd = -1;
486	}
487	vhost_user_backend_stop(g->vhost);
488	}
489	}
490
491	static bool
492	vhost_user_gpu_guest_notifier_pending(VirtIODevice *vdev, int idx)
493	{
494	VhostUserGPU *g = VHOST_USER_GPU(vdev);
495
496	return vhost_virtqueue_pending(&g->vhost->dev, idx);
497	}
498
499	static void
500	vhost_user_gpu_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
501	{
502	VhostUserGPU *g = VHOST_USER_GPU(vdev);
503
504	vhost_virtqueue_mask(&g->vhost->dev, vdev, idx, mask);
505	}
506
507	static void
508	vhost_user_gpu_instance_init(Object *obj)
509	{
510	VhostUserGPU *g = VHOST_USER_GPU(obj);
511
512	g->vhost = VHOST_USER_BACKEND(object_new(TYPE_VHOST_USER_BACKEND));
513	object_property_add_alias(obj, "chardev",
514	OBJECT(g->vhost), "chardev", &error_abort);
515	}
516
517	static void
518	vhost_user_gpu_instance_finalize(Object *obj)
519	{
520	VhostUserGPU *g = VHOST_USER_GPU(obj);
521
522	object_unref(OBJECT(g->vhost));
523	}
524
525	static void
526	vhost_user_gpu_reset(VirtIODevice *vdev)
527	{
528	VhostUserGPU *g = VHOST_USER_GPU(vdev);
529
530	virtio_gpu_base_reset(VIRTIO_GPU_BASE(vdev));
531
532	vhost_user_backend_stop(g->vhost);
533	}
534
535	static int
536	vhost_user_gpu_config_change(struct vhost_dev *dev)
537	{
538	error_report("vhost-user-gpu: unhandled backend config change");
539	return -1;
540	}
541
542	static const VhostDevConfigOps config_ops = {
543	.vhost_dev_config_notifier = vhost_user_gpu_config_change,
544	};
545
546	static void
547	vhost_user_gpu_device_realize(DeviceState qdev, Error *errp)
548	{
549	VhostUserGPU *g = VHOST_USER_GPU(qdev);
550	VirtIODevice *vdev = VIRTIO_DEVICE(g);
551
552	vhost_dev_set_config_notifier(&g->vhost->dev, &config_ops);
553	if (vhost_user_backend_dev_init(g->vhost, vdev, 2, errp) < 0) {
554	return;
555	}
556
557	if (virtio_has_feature(g->vhost->dev.features, VIRTIO_GPU_F_VIRGL)) {
558	g->parent_obj.conf.flags \|= 1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED;
559	}
560
561	if (!virtio_gpu_base_device_realize(qdev, NULL, NULL, errp)) {
562	return;
563	}
564
565	g->vhost_gpu_fd = -1;
566	}
567
568	static Property vhost_user_gpu_properties[] = {
569	VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU, parent_obj.conf),
570	DEFINE_PROP_END_OF_LIST(),
571	};
572
573	static void
574	vhost_user_gpu_class_init(ObjectClass klass, void data)
575	{
576	DeviceClass *dc = DEVICE_CLASS(klass);
577	VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
578	VirtIOGPUBaseClass *vgc = VIRTIO_GPU_BASE_CLASS(klass);
579
580	vgc->gl_unblock = vhost_user_gpu_gl_unblock;
581
582	vdc->realize = vhost_user_gpu_device_realize;
583	vdc->reset = vhost_user_gpu_reset;
584	vdc->set_status = vhost_user_gpu_set_status;
585	vdc->guest_notifier_mask = vhost_user_gpu_guest_notifier_mask;
586	vdc->guest_notifier_pending = vhost_user_gpu_guest_notifier_pending;
587	vdc->get_config = vhost_user_gpu_get_config;
588	vdc->set_config = vhost_user_gpu_set_config;
589
590	dc->props = vhost_user_gpu_properties;
591	}
592
593	static const TypeInfo vhost_user_gpu_info = {
594	.name = TYPE_VHOST_USER_GPU,
595	.parent = TYPE_VIRTIO_GPU_BASE,
596	.instance_size = sizeof(VhostUserGPU),
597	.instance_init = vhost_user_gpu_instance_init,
598	.instance_finalize = vhost_user_gpu_instance_finalize,
599	.class_init = vhost_user_gpu_class_init,
600	};
601
602	static void vhost_user_gpu_register_types(void)
603	{
604	type_register_static(&vhost_user_gpu_info);
605	}
606
607	type_init(vhost_user_gpu_register_types)