From fc2d0dfe60b14992a9b67e7a18394ba6365dc5ed Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= <marcandre.lureau@redhat.com>

Date: Wed, 18 Mar 2020 18:10:40 +0000

Subject: [PATCH 2/2] build-sys: do not make qemu-ga link with pixman

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

RH-Author: Marc-André Lureau <marcandre.lureau@redhat.com>

Message-id: <20200318181040.256425-1-marcandre.lureau@redhat.com>

Patchwork-id: 94381

O-Subject: [RHEL-AV-8.2.0 qemu-kvm PATCH] build-sys: do not make qemu-ga link with pixman

Bugzilla: 1811670

RH-Acked-by: Markus Armbruster <armbru@redhat.com>

RH-Acked-by: John Snow <jsnow@redhat.com>

RH-Acked-by: Daniel P. Berrange <berrange@redhat.com>

Since commit d52c454aadcdae74506f315ebf8b58bb79a05573 ("contrib: add

vhost-user-gpu"), qemu-ga is linking with pixman.

This is because the Make-based build-system use a global namespace for

variables, and we rely on "main.o-libs" for different linking targets.

Note: this kind of variable clashing is hard to fix or prevent

currently.  meson should help, as declarations have a linear

dependency and doesn't rely so much on variables and clever tricks.

Note2: we have a lot of main.c (or other duplicated names!) in

tree. Imho, it would be annoying and a bad workaroud to rename all

those to avoid conflicts like I did here.

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1811670

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Message-Id: <20200311160923.882474-1-marcandre.lureau@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1811670

Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=27330493

(cherry picked from commit 5b42bc5ce9ab4a3171819feea5042931817211fd)

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>

---

 contrib/vhost-user-gpu/Makefile.objs    |    6 +-

 contrib/vhost-user-gpu/main.c           | 1191 -------------------------------

 contrib/vhost-user-gpu/vhost-user-gpu.c | 1191 +++++++++++++++++++++++++++++++

 3 files changed, 1194 insertions(+), 1194 deletions(-)

 delete mode 100644 contrib/vhost-user-gpu/main.c

 create mode 100644 contrib/vhost-user-gpu/vhost-user-gpu.c

diff --git a/contrib/vhost-user-gpu/Makefile.objs b/contrib/vhost-user-gpu/Makefile.objs

index 6170c91..0929609 100644

--- a/contrib/vhost-user-gpu/Makefile.objs

+++ b/contrib/vhost-user-gpu/Makefile.objs

@@ -1,7 +1,7 @@

-vhost-user-gpu-obj-y = main.o virgl.o vugbm.o

+vhost-user-gpu-obj-y = vhost-user-gpu.o virgl.o vugbm.o

-main.o-cflags := $(PIXMAN_CFLAGS) $(GBM_CFLAGS)

-main.o-libs := $(PIXMAN_LIBS)

+vhost-user-gpu.o-cflags := $(PIXMAN_CFLAGS) $(GBM_CFLAGS)

+vhost-user-gpu.o-libs := $(PIXMAN_LIBS)

 virgl.o-cflags := $(VIRGL_CFLAGS) $(GBM_CFLAGS)

 virgl.o-libs := $(VIRGL_LIBS)

diff --git a/contrib/vhost-user-gpu/main.c b/contrib/vhost-user-gpu/main.c

deleted file mode 100644

index b45d201..0000000

--- a/contrib/vhost-user-gpu/main.c

+++ /dev/null

@@ -1,1191 +0,0 @@

-/*

- * Virtio vhost-user GPU Device

- *

- * Copyright Red Hat, Inc. 2013-2018

- *

- * Authors:

- *     Dave Airlie <airlied@redhat.com>

- *     Gerd Hoffmann <kraxel@redhat.com>

- *     Marc-André Lureau <marcandre.lureau@redhat.com>

- *

- * 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 "qemu/drm.h"

-#include "qapi/error.h"

-#include "qemu/sockets.h"

-

-#include <pixman.h>

-#include <glib-unix.h>

-

-#include "vugpu.h"

-#include "hw/virtio/virtio-gpu-bswap.h"

-#include "hw/virtio/virtio-gpu-pixman.h"

-#include "virgl.h"

-#include "vugbm.h"

-

-enum {

-    VHOST_USER_GPU_MAX_QUEUES = 2,

-};

-

-struct virtio_gpu_simple_resource {

-    uint32_t resource_id;

-    uint32_t width;

-    uint32_t height;

-    uint32_t format;

-    struct iovec *iov;

-    unsigned int iov_cnt;

-    uint32_t scanout_bitmask;

-    pixman_image_t *image;

-    struct vugbm_buffer buffer;

-    QTAILQ_ENTRY(virtio_gpu_simple_resource) next;

-};

-

-static gboolean opt_print_caps;

-static int opt_fdnum = -1;

-static char *opt_socket_path;

-static char *opt_render_node;

-static gboolean opt_virgl;

-

-static void vg_handle_ctrl(VuDev *dev, int qidx);

-

-static const char *

-vg_cmd_to_string(int cmd)

-{

-#define CMD(cmd) [cmd] = #cmd

-    static const char *vg_cmd_str[] = {

-        CMD(VIRTIO_GPU_UNDEFINED),

-

-        /* 2d commands */

-        CMD(VIRTIO_GPU_CMD_GET_DISPLAY_INFO),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_CREATE_2D),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_UNREF),

-        CMD(VIRTIO_GPU_CMD_SET_SCANOUT),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_FLUSH),

-        CMD(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING),

-        CMD(VIRTIO_GPU_CMD_GET_CAPSET_INFO),

-        CMD(VIRTIO_GPU_CMD_GET_CAPSET),

-

-        /* 3d commands */

-        CMD(VIRTIO_GPU_CMD_CTX_CREATE),

-        CMD(VIRTIO_GPU_CMD_CTX_DESTROY),

-        CMD(VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE),

-        CMD(VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE),

-        CMD(VIRTIO_GPU_CMD_RESOURCE_CREATE_3D),

-        CMD(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D),

-        CMD(VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D),

-        CMD(VIRTIO_GPU_CMD_SUBMIT_3D),

-

-        /* cursor commands */

-        CMD(VIRTIO_GPU_CMD_UPDATE_CURSOR),

-        CMD(VIRTIO_GPU_CMD_MOVE_CURSOR),

-    };

-#undef REQ

-

-    if (cmd >= 0 && cmd < G_N_ELEMENTS(vg_cmd_str)) {

-        return vg_cmd_str[cmd];

-    } else {

-        return "unknown";

-    }

-}

-

-static int

-vg_sock_fd_read(int sock, void *buf, ssize_t buflen)

-{

-    int ret;

-

-    do {

-        ret = read(sock, buf, buflen);

-    } while (ret < 0 && (errno == EINTR || errno == EAGAIN));

-

-    g_warn_if_fail(ret == buflen);

-    return ret;

-}

-

-static void

-vg_sock_fd_close(VuGpu *g)

-{

-    if (g->sock_fd >= 0) {

-        close(g->sock_fd);

-        g->sock_fd = -1;

-    }

-}

-

-static gboolean

-source_wait_cb(gint fd, GIOCondition condition, gpointer user_data)

-{

-    VuGpu *g = user_data;

-

-    if (!vg_recv_msg(g, VHOST_USER_GPU_DMABUF_UPDATE, 0, NULL)) {

-        return G_SOURCE_CONTINUE;

-    }

-

-    /* resume */

-    g->wait_ok = 0;

-    vg_handle_ctrl(&g->dev.parent, 0);

-

-    return G_SOURCE_REMOVE;

-}

-

-void

-vg_wait_ok(VuGpu *g)

-{

-    assert(g->wait_ok == 0);

-    g->wait_ok = g_unix_fd_add(g->sock_fd, G_IO_IN | G_IO_HUP,

-                               source_wait_cb, g);

-}

-

-static int

-vg_sock_fd_write(int sock, const void *buf, ssize_t buflen, int fd)

-{

-    ssize_t ret;

-    struct iovec iov = {

-        .iov_base = (void *)buf,

-        .iov_len = buflen,

-    };

-    struct msghdr msg = {

-        .msg_iov = &iov,

-        .msg_iovlen = 1,

-    };

-    union {

-        struct cmsghdr cmsghdr;

-        char control[CMSG_SPACE(sizeof(int))];

-    } cmsgu;

-    struct cmsghdr *cmsg;

-

-    if (fd != -1) {

-        msg.msg_control = cmsgu.control;

-        msg.msg_controllen = sizeof(cmsgu.control);

-

-        cmsg = CMSG_FIRSTHDR(&msg;;

-        cmsg->cmsg_len = CMSG_LEN(sizeof(int));

-        cmsg->cmsg_level = SOL_SOCKET;

-        cmsg->cmsg_type = SCM_RIGHTS;

-

-        *((int *)CMSG_DATA(cmsg)) = fd;

-    }

-

-    do {

-        ret = sendmsg(sock, &msg, 0);

-    } while (ret == -1 && (errno == EINTR || errno == EAGAIN));

-

-    g_warn_if_fail(ret == buflen);

-    return ret;

-}

-

-void

-vg_send_msg(VuGpu *vg, const VhostUserGpuMsg *msg, int fd)

-{

-    if (vg_sock_fd_write(vg->sock_fd, msg,

-                         VHOST_USER_GPU_HDR_SIZE + msg->size, fd) < 0) {

-        vg_sock_fd_close(vg);

-    }

-}

-

-bool

-vg_recv_msg(VuGpu *g, uint32_t expect_req, uint32_t expect_size,

-            gpointer payload)

-{

-    uint32_t req, flags, size;

-

-    if (vg_sock_fd_read(g->sock_fd, &req, sizeof(req)) < 0 ||

-        vg_sock_fd_read(g->sock_fd, &flags, sizeof(flags)) < 0 ||

-        vg_sock_fd_read(g->sock_fd, &size, sizeof(size)) < 0) {

-        goto err;

-    }

-

-    g_return_val_if_fail(req == expect_req, false);

-    g_return_val_if_fail(flags & VHOST_USER_GPU_MSG_FLAG_REPLY, false);

-    g_return_val_if_fail(size == expect_size, false);

-

-    if (size && vg_sock_fd_read(g->sock_fd, payload, size) != size) {

-        goto err;

-    }

-

-    return true;

-

-err:

-    vg_sock_fd_close(g);

-    return false;

-}

-

-static struct virtio_gpu_simple_resource *

-virtio_gpu_find_resource(VuGpu *g, uint32_t resource_id)

-{

-    struct virtio_gpu_simple_resource *res;

-

-    QTAILQ_FOREACH(res, &g->reslist, next) {

-        if (res->resource_id == resource_id) {

-            return res;

-        }

-    }

-    return NULL;

-}

-

-void

-vg_ctrl_response(VuGpu *g,

-                 struct virtio_gpu_ctrl_command *cmd,

-                 struct virtio_gpu_ctrl_hdr *resp,

-                 size_t resp_len)

-{

-    size_t s;

-

-    if (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_FENCE) {

-        resp->flags |= VIRTIO_GPU_FLAG_FENCE;

-        resp->fence_id = cmd->cmd_hdr.fence_id;

-        resp->ctx_id = cmd->cmd_hdr.ctx_id;

-    }

-    virtio_gpu_ctrl_hdr_bswap(resp);

-    s = iov_from_buf(cmd->elem.in_sg, cmd->elem.in_num, 0, resp, resp_len);

-    if (s != resp_len) {

-        g_critical("%s: response size incorrect %zu vs %zu",

-                   __func__, s, resp_len);

-    }

-    vu_queue_push(&g->dev.parent, cmd->vq, &cmd->elem, s);

-    vu_queue_notify(&g->dev.parent, cmd->vq);

-    cmd->finished = true;

-}

-

-void

-vg_ctrl_response_nodata(VuGpu *g,

-                        struct virtio_gpu_ctrl_command *cmd,

-                        enum virtio_gpu_ctrl_type type)

-{

-    struct virtio_gpu_ctrl_hdr resp = {

-        .type = type,

-    };

-

-    vg_ctrl_response(g, cmd, &resp, sizeof(resp));

-}

-

-void

-vg_get_display_info(VuGpu *vg, struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_resp_display_info dpy_info = { {} };

-    VhostUserGpuMsg msg = {

-        .request = VHOST_USER_GPU_GET_DISPLAY_INFO,

-        .size = 0,

-    };

-

-    assert(vg->wait_ok == 0);

-

-    vg_send_msg(vg, &msg, -1);

-    if (!vg_recv_msg(vg, msg.request, sizeof(dpy_info), &dpy_info)) {

-        return;

-    }

-

-    vg_ctrl_response(vg, cmd, &dpy_info.hdr, sizeof(dpy_info));

-}

-

-static void

-vg_resource_create_2d(VuGpu *g,

-                      struct virtio_gpu_ctrl_command *cmd)

-{

-    pixman_format_code_t pformat;

-    struct virtio_gpu_simple_resource *res;

-    struct virtio_gpu_resource_create_2d c2d;

-

-    VUGPU_FILL_CMD(c2d);

-    virtio_gpu_bswap_32(&c2d, sizeof(c2d));

-

-    if (c2d.resource_id == 0) {

-        g_critical("%s: resource id 0 is not allowed", __func__);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    res = virtio_gpu_find_resource(g, c2d.resource_id);

-    if (res) {

-        g_critical("%s: resource already exists %d", __func__, c2d.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    res = g_new0(struct virtio_gpu_simple_resource, 1);

-    res->width = c2d.width;

-    res->height = c2d.height;

-    res->format = c2d.format;

-    res->resource_id = c2d.resource_id;

-

-    pformat = virtio_gpu_get_pixman_format(c2d.format);

-    if (!pformat) {

-        g_critical("%s: host couldn't handle guest format %d",

-                   __func__, c2d.format);

-        g_free(res);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;

-        return;

-    }

-    vugbm_buffer_create(&res->buffer, &g->gdev, c2d.width, c2d.height);

-    res->image = pixman_image_create_bits(pformat,

-                                          c2d.width,

-                                          c2d.height,

-                                          (uint32_t *)res->buffer.mmap,

-                                          res->buffer.stride);

-    if (!res->image) {

-        g_critical("%s: resource creation failed %d %d %d",

-                   __func__, c2d.resource_id, c2d.width, c2d.height);

-        g_free(res);

-        cmd->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY;

-        return;

-    }

-

-    QTAILQ_INSERT_HEAD(&g->reslist, res, next);

-}

-

-static void

-vg_disable_scanout(VuGpu *g, int scanout_id)

-{

-    struct virtio_gpu_scanout *scanout = &g->scanout[scanout_id];

-    struct virtio_gpu_simple_resource *res;

-

-    if (scanout->resource_id == 0) {

-        return;

-    }

-

-    res = virtio_gpu_find_resource(g, scanout->resource_id);

-    if (res) {

-        res->scanout_bitmask &= ~(1 << scanout_id);

-    }

-

-    scanout->width = 0;

-    scanout->height = 0;

-

-    if (g->sock_fd >= 0) {

-        VhostUserGpuMsg msg = {

-            .request = VHOST_USER_GPU_SCANOUT,

-            .size = sizeof(VhostUserGpuScanout),

-            .payload.scanout.scanout_id = scanout_id,

-        };

-        vg_send_msg(g, &msg, -1);

-    }

-}

-

-static void

-vg_resource_destroy(VuGpu *g,

-                    struct virtio_gpu_simple_resource *res)

-{

-    int i;

-

-    if (res->scanout_bitmask) {

-        for (i = 0; i < VIRTIO_GPU_MAX_SCANOUTS; i++) {

-            if (res->scanout_bitmask & (1 << i)) {

-                vg_disable_scanout(g, i);

-            }

-        }

-    }

-

-    vugbm_buffer_destroy(&res->buffer);

-    pixman_image_unref(res->image);

-    QTAILQ_REMOVE(&g->reslist, res, next);

-    g_free(res);

-}

-

-static void

-vg_resource_unref(VuGpu *g,

-                  struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_simple_resource *res;

-    struct virtio_gpu_resource_unref unref;

-

-    VUGPU_FILL_CMD(unref);

-    virtio_gpu_bswap_32(&unref, sizeof(unref));

-

-    res = virtio_gpu_find_resource(g, unref.resource_id);

-    if (!res) {

-        g_critical("%s: illegal resource specified %d",

-                   __func__, unref.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-    vg_resource_destroy(g, res);

-}

-

-int

-vg_create_mapping_iov(VuGpu *g,

-                      struct virtio_gpu_resource_attach_backing *ab,

-                      struct virtio_gpu_ctrl_command *cmd,

-                      struct iovec **iov)

-{

-    struct virtio_gpu_mem_entry *ents;

-    size_t esize, s;

-    int i;

-

-    if (ab->nr_entries > 16384) {

-        g_critical("%s: nr_entries is too big (%d > 16384)",

-                   __func__, ab->nr_entries);

-        return -1;

-    }

-

-    esize = sizeof(*ents) * ab->nr_entries;

-    ents = g_malloc(esize);

-    s = iov_to_buf(cmd->elem.out_sg, cmd->elem.out_num,

-                   sizeof(*ab), ents, esize);

-    if (s != esize) {

-        g_critical("%s: command data size incorrect %zu vs %zu",

-                   __func__, s, esize);

-        g_free(ents);

-        return -1;

-    }

-

-    *iov = g_malloc0(sizeof(struct iovec) * ab->nr_entries);

-    for (i = 0; i < ab->nr_entries; i++) {

-        uint64_t len = ents[i].length;

-        (*iov)[i].iov_len = ents[i].length;

-        (*iov)[i].iov_base = vu_gpa_to_va(&g->dev.parent, &len, ents[i].addr);

-        if (!(*iov)[i].iov_base || len != ents[i].length) {

-            g_critical("%s: resource %d element %d",

-                       __func__, ab->resource_id, i);

-            g_free(*iov);

-            g_free(ents);

-            *iov = NULL;

-            return -1;

-        }

-    }

-    g_free(ents);

-    return 0;

-}

-

-static void

-vg_resource_attach_backing(VuGpu *g,

-                           struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_simple_resource *res;

-    struct virtio_gpu_resource_attach_backing ab;

-    int ret;

-

-    VUGPU_FILL_CMD(ab);

-    virtio_gpu_bswap_32(&ab, sizeof(ab));

-

-    res = virtio_gpu_find_resource(g, ab.resource_id);

-    if (!res) {

-        g_critical("%s: illegal resource specified %d",

-                   __func__, ab.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    ret = vg_create_mapping_iov(g, &ab, cmd, &res->iov);

-    if (ret != 0) {

-        cmd->error = VIRTIO_GPU_RESP_ERR_UNSPEC;

-        return;

-    }

-

-    res->iov_cnt = ab.nr_entries;

-}

-

-static void

-vg_resource_detach_backing(VuGpu *g,

-                           struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_simple_resource *res;

-    struct virtio_gpu_resource_detach_backing detach;

-

-    VUGPU_FILL_CMD(detach);

-    virtio_gpu_bswap_32(&detach, sizeof(detach));

-

-    res = virtio_gpu_find_resource(g, detach.resource_id);

-    if (!res || !res->iov) {

-        g_critical("%s: illegal resource specified %d",

-                   __func__, detach.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    g_free(res->iov);

-    res->iov = NULL;

-    res->iov_cnt = 0;

-}

-

-static void

-vg_transfer_to_host_2d(VuGpu *g,

-                       struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_simple_resource *res;

-    int h;

-    uint32_t src_offset, dst_offset, stride;

-    int bpp;

-    pixman_format_code_t format;

-    struct virtio_gpu_transfer_to_host_2d t2d;

-

-    VUGPU_FILL_CMD(t2d);

-    virtio_gpu_t2d_bswap(&t2d);

-

-    res = virtio_gpu_find_resource(g, t2d.resource_id);

-    if (!res || !res->iov) {

-        g_critical("%s: illegal resource specified %d",

-                   __func__, t2d.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    if (t2d.r.x > res->width ||

-        t2d.r.y > res->height ||

-        t2d.r.width > res->width ||

-        t2d.r.height > res->height ||

-        t2d.r.x + t2d.r.width > res->width ||

-        t2d.r.y + t2d.r.height > res->height) {

-        g_critical("%s: transfer bounds outside resource"

-                   " bounds for resource %d: %d %d %d %d vs %d %d",

-                   __func__, t2d.resource_id, t2d.r.x, t2d.r.y,

-                   t2d.r.width, t2d.r.height, res->width, res->height);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;

-        return;

-    }

-

-    format = pixman_image_get_format(res->image);

-    bpp = (PIXMAN_FORMAT_BPP(format) + 7) / 8;

-    stride = pixman_image_get_stride(res->image);

-

-    if (t2d.offset || t2d.r.x || t2d.r.y ||

-        t2d.r.width != pixman_image_get_width(res->image)) {

-        void *img_data = pixman_image_get_data(res->image);

-        for (h = 0; h < t2d.r.height; h++) {

-            src_offset = t2d.offset + stride * h;

-            dst_offset = (t2d.r.y + h) * stride + (t2d.r.x * bpp);

-

-            iov_to_buf(res->iov, res->iov_cnt, src_offset,

-                       img_data

-                       + dst_offset, t2d.r.width * bpp);

-        }

-    } else {

-        iov_to_buf(res->iov, res->iov_cnt, 0,

-                   pixman_image_get_data(res->image),

-                   pixman_image_get_stride(res->image)

-                   * pixman_image_get_height(res->image));

-    }

-}

-

-static void

-vg_set_scanout(VuGpu *g,

-               struct virtio_gpu_ctrl_command *cmd)

-{

-    struct virtio_gpu_simple_resource *res, *ores;

-    struct virtio_gpu_scanout *scanout;

-    struct virtio_gpu_set_scanout ss;

-    int fd;

-

-    VUGPU_FILL_CMD(ss);

-    virtio_gpu_bswap_32(&ss, sizeof(ss));

-

-    if (ss.scanout_id >= VIRTIO_GPU_MAX_SCANOUTS) {

-        g_critical("%s: illegal scanout id specified %d",

-                   __func__, ss.scanout_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID;

-        return;

-    }

-

-    if (ss.resource_id == 0) {

-        vg_disable_scanout(g, ss.scanout_id);

-        return;

-    }

-

-    /* create a surface for this scanout */

-    res = virtio_gpu_find_resource(g, ss.resource_id);

-    if (!res) {

-        g_critical("%s: illegal resource specified %d",

-                      __func__, ss.resource_id);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;

-        return;

-    }

-

-    if (ss.r.x > res->width ||

-        ss.r.y > res->height ||

-        ss.r.width > res->width ||

-        ss.r.height > res->height ||

-        ss.r.x + ss.r.width > res->width ||

-        ss.r.y + ss.r.height > res->height) {

-        g_critical("%s: illegal scanout %d bounds for"

-                   " resource %d, (%d,%d)+%d,%d vs %d %d",

-                   __func__, ss.scanout_id, ss.resource_id, ss.r.x, ss.r.y,

-                   ss.r.width, ss.r.height, res->width, res->height);

-        cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;

-        return;

-    }

-

-    scanout = &g->scanout[ss.scanout_id];

-

-    ores = virtio_gpu_find_resource(g, scanout->resource_id);

-    if (ores) {

-        ores->scanout_bitmask &= ~(1 << ss.scanout_id);

-    }

-

-    res->scanout_bitmask |= (1 << ss.scanout_id);

-    scanout->resource_id = ss.resource_id;

-    scanout->x = ss.r.x;

-    scanout->y = ss.r.y;

-    scanout->width = ss.r.width;

-    scanout->height = ss.r.height;

-

-    struct vugbm_buffer *buffer = &res->buffer;

-

-    if (vugbm_buffer_can_get_dmabuf_fd(buffer)) {

-        VhostUserGpuMsg msg = {

-            .request = VHOST_USER_GPU_DMABUF_SCANOUT,

-            .size = sizeof(VhostUserGpuDMABUFScanout),

-            .payload.dmabuf_scanout = (VhostUserGpuDMABUFScanout) {

-                .scanout_id = ss.scanout_id,

-                .x = ss.r.x,

-                .y = ss.r.y,

-                .width = ss.r.width,

-                .height = ss.r.height,

-                .fd_width = buffer->width,

-                .fd_height = buffer->height,

-                .fd_stride = buffer->stride,

-                .fd_drm_fourcc = buffer->format

-            }

-        };

-

-        if (vugbm_buffer_get_dmabuf_fd(buffer, &fd)) {

-            vg_send_msg(g, &msg, fd);

-            close(fd);

-        }

-    } else {

-        VhostUserGpuMsg msg = {

-            .request = VHOST_USER_GPU_SCANOUT,