Sometimes the virtio_gpu in guest_vm doesn't pass the zero coord_x/y for the
displayed framebuffer. In such case the offset should be calibrated for pixman_image/dmabuf
so that it can display the image from the correct image.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 2 ++
devicemodel/hw/vdisplay_sdl.c | 2 +-
devicemodel/include/vdisplay.h | 1 +
3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index 81ea82889..42d07e053 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -881,6 +881,7 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)
surf.stride = pixman_image_get_stride(r2d->image);
surf.surf_format = r2d->format;
surf.surf_type = SURFACE_PIXMAN;
+ surf.pixel += 4 * (surf.x + surf.y * surf.stride);
vdpy_surface_set(gpu->vdpy_handle, req.scanout_id, &surf);
pixman_image_unref(r2d->image);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
@@ -1298,6 +1299,7 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
surf.stride = req.strides[0];
surf.dma_info.dmabuf_fd = r2d->dma_info->dmabuf_fd;
surf.surf_type = SURFACE_DMABUF;
+ surf.dma_info.dmabuf_offset = req.offsets[0] + 4 * (surf.x + surf.y * surf.stride);
switch (req.format) {
case VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM:
drm_fourcc = DRM_FORMAT_XRGB8888;
diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 65fd78d93..12140d6be 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -700,7 +700,7 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT;
attrs[i++] = surf->stride;
attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT;
- attrs[i++] = 0;
+ attrs[i++] = surf->dma_info.dmabuf_offset;
attrs[i++] = EGL_NONE;

egl_img = gl_ops->eglCreateImageKHR(vdpy.eglDisplay,
diff --git a/devicemodel/include/vdisplay.h b/devicemodel/include/vdisplay.h
index c1214a461..e24a4c625 100644
--- a/devicemodel/include/vdisplay.h
+++ b/devicemodel/include/vdisplay.h
@@ -67,6 +67,7 @@ struct surface {
struct {
int dmabuf_fd;
uint32_t surf_fourcc;
+ uint32_t dmabuf_offset;
} dma_info;
};

--
2.25.1

The virtio-gpu display will be handled by the below cmd sequence:
1. Virtio_GPU_CMD_CREATE_RESOURCE
2. VIRTIO_GPU_CMD_SET_SCANOUT/SET_SCANOUT_BLOB
3. VIRTIO_GPU_CMD_FLUSH

The virtio_gpu_cmd_flush doesn't pass the scanout info.Instead it only passes the
flushed_region and the resouce_id. So it needs to check whether the scanout_region
is covered by the flushed_region and then decide whether the scanout_win needs
to be displayed.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 80 +++++++++++++++++++++-----
1 file changed, 67 insertions(+), 13 deletions(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index f33809eee..81ea82889 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -975,6 +975,46 @@ virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_command *cmd)
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
}

+static bool
+virtio_gpu_scanout_needs_flush(struct virtio_gpu *gpu,
+ int scanout_id,
+ int resource_id,
+ struct virtio_gpu_rect *flush_rect)
+{
+ struct virtio_gpu_scanout *gpu_scanout;
+ pixman_region16_t flush_region, final_region, scanout_region;
+
+ /* the scanout_id is already checked. So it is ignored in this function */
+ gpu_scanout = gpu->gpu_scanouts + scanout_id;
+
+ /* if the different resource_id is used, flush can be skipped */
+ if (resource_id != gpu_scanout->resource_id)
+ return false;
+
+ pixman_region_init(&final_region);
+ pixman_region_init_rect(&scanout_region,
+ gpu_scanout->scanout_rect.x,
+ gpu_scanout->scanout_rect.y,
+ gpu_scanout->scanout_rect.width,
+ gpu_scanout->scanout_rect.height);
+ pixman_region_init_rect(&flush_region,
+ flush_rect->x, flush_rect->y,
+ flush_rect->width, flush_rect->height);
+
+ /* Check intersect region to determine whether scanout_region
+ * needs to be flushed.
+ */
+ pixman_region_intersect(&final_region, &scanout_region, &flush_region);
+
+ /* if intersection_region is empty, it means that the scanout_region is not
+ * covered by the flushed_region. And it is unnecessary to update
+ */
+ if (pixman_region_not_empty(&final_region))
+ return true;
+ else
+ return false;
+}
+
static void
virtio_gpu_cmd_resource_flush(struct virtio_gpu_command *cmd)
{
@@ -983,6 +1023,8 @@ virtio_gpu_cmd_resource_flush(struct virtio_gpu_command *cmd)
struct virtio_gpu_resource_2d *r2d;
struct surface surf;
struct virtio_gpu *gpu;
+ int i;
+ struct virtio_gpu_scanout *gpu_scanout;

gpu = cmd->gpu;
memcpy(&req, cmd->iov[0].iov_base, sizeof(req));
@@ -999,24 +1041,36 @@ virtio_gpu_cmd_resource_flush(struct virtio_gpu_command *cmd)
}
if (r2d->blob) {
virtio_gpu_dmabuf_ref(r2d->dma_info);
- surf.dma_info.dmabuf_fd = r2d->dma_info->dmabuf_fd;
- surf.surf_type = SURFACE_DMABUF;
- vdpy_surface_update(gpu->vdpy_handle, 0, &surf);
+ for (i = 0; i < gpu->scanout_num; i++) {
+ if (!virtio_gpu_scanout_needs_flush(gpu, i, req.resource_id, &req.r))
+ continue;
+
+ surf.dma_info.dmabuf_fd = r2d->dma_info->dmabuf_fd;
+ surf.surf_type = SURFACE_DMABUF;
+ vdpy_surface_update(gpu->vdpy_handle, i, &surf);
+ }
+ virtio_gpu_dmabuf_unref(r2d->dma_info);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
- virtio_gpu_dmabuf_unref(r2d->dma_info);
return;
}
pixman_image_ref(r2d->image);
- surf.pixel = pixman_image_get_data(r2d->image);
- surf.x = req.r.x;
- surf.y = req.r.y;
- surf.width = r2d->width;
- surf.height = r2d->height;
- surf.stride = pixman_image_get_stride(r2d->image);
- surf.surf_format = r2d->format;
- surf.surf_type = SURFACE_PIXMAN;
- vdpy_surface_update(gpu->vdpy_handle, 0, &surf);
+ for (i = 0; i < gpu->scanout_num; i++) {
+ if (!virtio_gpu_scanout_needs_flush(gpu, i, req.resource_id, &req.r))
+ continue;
+
+ gpu_scanout = gpu->gpu_scanouts + i;
+ surf.pixel = pixman_image_get_data(r2d->image);
+ surf.x = gpu_scanout->scanout_rect.x;
+ surf.y = gpu_scanout->scanout_rect.y;
+ surf.width = gpu_scanout->scanout_rect.width;
+ surf.height = gpu_scanout->scanout_rect.height;
+ surf.stride = pixman_image_get_stride(r2d->image);
+ surf.surf_format = r2d->format;
+ surf.surf_type = SURFACE_PIXMAN;
+ surf.pixel += 4 * (surf.x + surf.y * surf.stride);
+ vdpy_surface_update(gpu->vdpy_handle, i, &surf);
+ }
pixman_image_unref(r2d->image);

cmd->iolen = sizeof(resp);
--
2.25.1

The virtio-gpu in guest_vm also passes the scanout_id for cursor operation.
And this scanout_id should be handled in course of handling cursor cmds.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index aa955ba23..f33809eee 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -1389,7 +1389,7 @@ virtio_gpu_cmd_update_cursor(struct virtio_gpu_command *cmd)
cur.height = r2d->height;
pixman_image_ref(r2d->image);
cur.data = pixman_image_get_data(r2d->image);
- vdpy_cursor_define(gpu->vdpy_handle, 0, &cur);
+ vdpy_cursor_define(gpu->vdpy_handle, req.pos.scanout_id, &cur);
pixman_image_unref(r2d->image);
}
}
@@ -1402,7 +1402,7 @@ virtio_gpu_cmd_move_cursor(struct virtio_gpu_command *cmd)

gpu = cmd->gpu;
memcpy(&req, cmd->iov[0].iov_base, sizeof(req));
- vdpy_cursor_move(gpu->vdpy_handle, 0, req.pos.x, req.pos.y);
+ vdpy_cursor_move(gpu->vdpy_handle, req.pos.scanout_id, req.pos.x, req.pos.y);
}

static void
--
2.25.1

The scanout_id is included in the below virtio-gpu-cmd request.
VIRTIO_GPU_GET_EDID
VIRTIO_GPU_SET_SCANOUT
VIRTIO_GPU_SET_SCANOUT_BLOB

So the scanout_id and scanout_rect should be handled correctly.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 88 ++++++++++++++++++++------
1 file changed, 67 insertions(+), 21 deletions(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index 768e188d2..aa955ba23 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -564,11 +564,17 @@ virtio_gpu_cmd_get_edid(struct virtio_gpu_command *cmd)
memcpy(&req, cmd->iov[0].iov_base, sizeof(req));
cmd->iolen = sizeof(resp);
memset(&resp, 0, sizeof(resp));
+ virtio_gpu_update_resp_fence(&cmd->hdr, &resp.hdr);
+ if (req.scanout >= gpu->scanout_num) {
+ pr_err("%s: Incorrect scanout_id %d\n", req.scanout);
+ resp.hdr.type = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID;
+ memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
+ return;
+ }
/* Only one EDID block is enough */
resp.size = 128;
resp.hdr.type = VIRTIO_GPU_RESP_OK_EDID;
- virtio_gpu_update_resp_fence(&cmd->hdr, &resp.hdr);
- vdpy_get_edid(gpu->vdpy_handle, 0, resp.edid, resp.size);
+ vdpy_get_edid(gpu->vdpy_handle, req.scanout, resp.edid, resp.size);
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
}

@@ -578,18 +584,21 @@ virtio_gpu_cmd_get_display_info(struct virtio_gpu_command *cmd)
struct virtio_gpu_resp_display_info resp;
struct display_info info;
struct virtio_gpu *gpu;
+ int i;

gpu = cmd->gpu;
cmd->iolen = sizeof(resp);
memset(&resp, 0, sizeof(resp));
- vdpy_get_display_info(gpu->vdpy_handle, 0, &info);
resp.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO;
virtio_gpu_update_resp_fence(&cmd->hdr, &resp.hdr);
- resp.pmodes[0].enabled = 1;
- resp.pmodes[0].r.x = info.xoff;
- resp.pmodes[0].r.y = info.yoff;
- resp.pmodes[0].r.width = info.width;
- resp.pmodes[0].r.height = info.height;
+ for (i = 0; i < gpu->scanout_num; i++) {
+ vdpy_get_display_info(gpu->vdpy_handle, i, &info);
+ resp.pmodes[i].enabled = 1;
+ resp.pmodes[i].r.x = info.xoff;
+ resp.pmodes[i].r.y = info.yoff;
+ resp.pmodes[i].r.width = info.width;
+ resp.pmodes[i].r.height = info.height;
+ }
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
}

@@ -640,6 +649,40 @@ virtio_gpu_get_pixman_format(uint32_t format)
}
}

+static void
+virtio_gpu_update_scanout(struct virtio_gpu *gpu, int scanout_id, int resource_id,
+ struct virtio_gpu_rect *scan_rect)
+{
+ struct virtio_gpu_scanout *gpu_scanout;
+ struct virtio_gpu_resource_2d *r2d;
+
+ /* as it is already checked, this is not checked again */
+ gpu_scanout = gpu->gpu_scanouts + scanout_id;
+ if (gpu_scanout->dma_buf) {
+ virtio_gpu_dmabuf_unref(gpu_scanout->dma_buf);
+ gpu_scanout->dma_buf = NULL;
+ }
+ if (gpu_scanout->cur_img) {
+ pixman_image_unref(gpu_scanout->cur_img);
+ gpu_scanout->cur_img = NULL;
+ }
+ gpu_scanout->resource_id = resource_id;
+ r2d = virtio_gpu_find_resource_2d(gpu, resource_id);
+ if (r2d) {
+ gpu_scanout->active = true;
+ if (r2d->blob) {
+ virtio_gpu_dmabuf_ref(r2d->dma_info);
+ gpu_scanout->dma_buf = r2d->dma_info;
+ } else {
+ pixman_image_ref(r2d->image);
+ gpu_scanout->cur_img = r2d->image;
+ }
+ } else {
+ gpu_scanout->active = false;
+ }
+ memcpy(&gpu_scanout->scanout_rect, scan_rect, sizeof(*scan_rect));
+}
+
static void
virtio_gpu_cmd_resource_create_2d(struct virtio_gpu_command *cmd)
{
@@ -812,7 +855,8 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)

r2d = virtio_gpu_find_resource_2d(gpu, req.resource_id);
if ((req.resource_id == 0) || (r2d == NULL)) {
- vdpy_surface_set(gpu->vdpy_handle, 0, NULL);
+ virtio_gpu_update_scanout(gpu, req.scanout_id, 0, &req.r);
+ vdpy_surface_set(gpu->vdpy_handle, req.scanout_id, NULL);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
return;
@@ -827,16 +871,17 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)
__func__);
resp.type = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;
} else {
+ virtio_gpu_update_scanout(gpu, req.scanout_id, req.resource_id, &req.r);
pixman_image_ref(r2d->image);
surf.pixel = pixman_image_get_data(r2d->image);
- surf.x = 0;
- surf.y = 0;
- surf.width = r2d->width;
- surf.height = r2d->height;
+ surf.x = req.r.x;
+ surf.y = req.r.y;
+ surf.width = req.r.width;
+ surf.height = req.r.height;
surf.stride = pixman_image_get_stride(r2d->image);
surf.surf_format = r2d->format;
surf.surf_type = SURFACE_PIXMAN;
- vdpy_surface_set(gpu->vdpy_handle, 0, &surf);
+ vdpy_surface_set(gpu->vdpy_handle, req.scanout_id, &surf);
pixman_image_unref(r2d->image);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
}
@@ -1172,9 +1217,10 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
gpu_scanout = gpu->gpu_scanouts + req.scanout_id;
gpu_scanout->scanout_id = req.scanout_id;
if (req.resource_id == 0) {
+ virtio_gpu_update_scanout(gpu, req.scanout_id, 0, &req.r);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
- vdpy_surface_set(gpu->vdpy_handle, 0, NULL);
+ vdpy_surface_set(gpu->vdpy_handle, req.scanout_id, NULL);
return;
}
r2d = virtio_gpu_find_resource_2d(cmd->gpu, req.resource_id);
@@ -1183,18 +1229,18 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
return;
}
-
if (r2d->blob == false) {
/* Maybe the resource is not blob, fallback to set_scanout */
virtio_gpu_cmd_set_scanout(cmd);
return;
}

+ virtio_gpu_update_scanout(gpu, req.scanout_id, req.resource_id, &req.r);
virtio_gpu_dmabuf_ref(r2d->dma_info);
- surf.width = req.width;
- surf.height = req.height;
- surf.x = 0;
- surf.y = 0;
+ surf.width = req.r.width;
+ surf.height = req.r.height;
+ surf.x = req.r.x;
+ surf.y = req.r.y;
surf.stride = req.strides[0];
surf.dma_info.dmabuf_fd = r2d->dma_info->dmabuf_fd;
surf.surf_type = SURFACE_DMABUF;
@@ -1218,7 +1264,7 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
break;
}
surf.dma_info.surf_fourcc = drm_fourcc;
- vdpy_surface_set(gpu->vdpy_handle, 0, &surf);
+ vdpy_surface_set(gpu->vdpy_handle, req.scanout_id, &surf);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
virtio_gpu_dmabuf_unref(r2d->dma_info);
--
2.25.1

Now it only supports one scanout panel for virtio-gpu. So the scanout_id is ignored in
course of handling virtio-gpu-cmd. In order to handle the virtio-gpu-cmds correctly, it
adds the virtio_gpu_scanout structure so that it can record the scanout info.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 63 ++++++++++++++++++++++++++
1 file changed, 63 insertions(+)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index cf3d20823..768e188d2 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -348,6 +348,16 @@ enum vga_thread_status {
VGA_THREAD_EOL = 0,
VGA_THREAD_RUNNING
};
+
+struct virtio_gpu_scanout {
+ int scanout_id;
+ uint32_t resource_id;
+ struct virtio_gpu_rect scanout_rect;
+ pixman_image_t *cur_img;
+ struct dma_buf_info *dma_buf;
+ bool active;
+};
+
/*
* Per-device struct
*/
@@ -366,6 +376,8 @@ struct virtio_gpu {
int32_t vga_thread_status;
uint8_t edid[VIRTIO_GPU_EDID_SIZE];
bool is_blob_supported;
+ int scanout_num;
+ struct virtio_gpu_scanout *gpu_scanouts;
};

struct virtio_gpu_command {
@@ -782,12 +794,22 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)
struct virtio_gpu_ctrl_hdr resp;
struct surface surf;
struct virtio_gpu *gpu;
+ struct virtio_gpu_scanout *gpu_scanout;

gpu = cmd->gpu;
memcpy(&req, cmd->iov[0].iov_base, sizeof(req));
memset(&resp, 0, sizeof(resp));
virtio_gpu_update_resp_fence(&cmd->hdr, &resp);

+ if (req.scanout_id >= gpu->scanout_num) {
+ pr_err("%s: Incorrect scanout_id %d\n", req.scanout_id);
+ resp.type = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID;
+ memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
+ return;
+ }
+ gpu_scanout = gpu->gpu_scanouts + req.scanout_id;
+ gpu_scanout->scanout_id = req.scanout_id;
+
r2d = virtio_gpu_find_resource_2d(gpu, req.resource_id);
if ((req.resource_id == 0) || (r2d == NULL)) {
vdpy_surface_set(gpu->vdpy_handle, 0, NULL);
@@ -1130,6 +1152,7 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
struct surface surf;
uint32_t drm_fourcc;
struct virtio_gpu *gpu;
+ struct virtio_gpu_scanout *gpu_scanout;

gpu = cmd->gpu;
memset(&surf, 0, sizeof(surf));
@@ -1140,6 +1163,14 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
if (cmd->gpu->vga.enable) {
cmd->gpu->vga.enable = false;
}
+ if (req.scanout_id >= gpu->scanout_num) {
+ pr_err("%s: Incorrect scanout_id %d\n", req.scanout_id);
+ resp.type = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID;
+ memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
+ return;
+ }
+ gpu_scanout = gpu->gpu_scanouts + req.scanout_id;
+ gpu_scanout->scanout_id = req.scanout_id;
if (req.resource_id == 0) {
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
@@ -1485,10 +1516,22 @@ virtio_gpu_init(struct vmctx *ctx, struct pci_vdev *dev, char *opts)
gpu->vq,
BACKEND_VBSU);

+ gpu->scanout_num = 1;
gpu->vdpy_handle = vdpy_init(NULL);
gpu->base.mtx = &gpu->mtx;
gpu->base.device_caps = VIRTIO_GPU_S_HOSTCAPS;

+ if (gpu->scanout_num < 0) {
+ pr_err("%s: return incorrect scanout num %d\n", gpu->scanout_num);
+ return -1;
+ }
+ gpu->gpu_scanouts = calloc(gpu->scanout_num, sizeof(struct virtio_gpu_scanout));
+ if (gpu->gpu_scanouts == NULL) {
+ pr_err("%s: out of memory for gpu_scanouts\n", __func__);
+ free(gpu);
+ return -1;
+ }
+
if (vm_allow_dmabuf(gpu->base.dev->vmctx)) {
FILE *fp;
char buf[16];
@@ -1643,6 +1686,7 @@ virtio_gpu_deinit(struct vmctx *ctx, struct pci_vdev *dev, char *opts)
{
struct virtio_gpu *gpu;
struct virtio_gpu_resource_2d *r2d;
+ int i;

gpu = (struct virtio_gpu *)dev->arg;
gpu->vga.enable = false;
@@ -1661,6 +1705,25 @@ virtio_gpu_deinit(struct vmctx *ctx, struct pci_vdev *dev, char *opts)
gpu->vga.gc = NULL;
}

+ for (i=0; i < gpu->scanout_num; i++) {
+ struct virtio_gpu_scanout *gpu_scanout;
+
+ gpu_scanout = gpu->gpu_scanouts + i;
+ if (gpu_scanout && gpu_scanout->active) {
+ if (gpu_scanout->cur_img) {
+ pixman_image_unref(gpu_scanout->cur_img);
+ gpu_scanout->cur_img = NULL;
+ }
+ if (gpu_scanout->dma_buf) {
+ virtio_gpu_dmabuf_unref(gpu_scanout->dma_buf);
+ gpu_scanout->dma_buf = NULL;
+ }
+ gpu_scanout->active = false;
+ }
+ }
+ free(gpu->gpu_scanouts);
+ gpu->gpu_scanouts = NULL;
+
pthread_mutex_destroy(&gpu->vga_thread_mtx);
while (LIST_FIRST(&gpu->r2d_list)) {
r2d = LIST_FIRST(&gpu->r2d_list);
--
2.25.1

Vdisplay module will create the gui_window based on the virtio-gpu parameter. When it tries
to establish the connection with vdisplay module, it will return the supported number of window.
Then the virtio-gpu device can initialize the correct info for the guest_vm.

BTW: The number is fixed to 1.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 2 +-
devicemodel/hw/vdisplay_sdl.c | 4 +++-
devicemodel/include/vdisplay.h | 2 +-
3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index 2f8c4362e..cf3d20823 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -1485,7 +1485,7 @@ virtio_gpu_init(struct vmctx *ctx, struct pci_vdev *dev, char *opts)
gpu->vq,
BACKEND_VBSU);

- gpu->vdpy_handle = vdpy_init();
+ gpu->vdpy_handle = vdpy_init(NULL);
gpu->base.mtx = &gpu->mtx;
gpu->base.device_caps = VIRTIO_GPU_S_HOSTCAPS;

diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 567a2de6f..65fd78d93 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -1069,7 +1069,7 @@ bool vdpy_submit_bh(int handle, struct vdpy_display_bh *bh_task)
}

int
-vdpy_init()
+vdpy_init(int *supported_wins)
{
int err, count;

@@ -1100,6 +1100,8 @@ vdpy_init()
}

vdpy.s.n_connect++;
+ if (supported_wins)
+ *supported_wins = 1;
return vdpy.s.n_connect;
}

diff --git a/devicemodel/include/vdisplay.h b/devicemodel/include/vdisplay.h
index fc0e91b46..c1214a461 100644
--- a/devicemodel/include/vdisplay.h
+++ b/devicemodel/include/vdisplay.h
@@ -85,7 +85,7 @@ struct cursor {

int vdpy_parse_cmd_option(const char *opts);
int gfx_ui_init();
-int vdpy_init();
+int vdpy_init(int *supported_wins);
void vdpy_get_display_info(int handle, int scanout_id, struct display_info *info);
void vdpy_surface_set(int handle, int scanout_id, struct surface *surf);
void vdpy_surface_update(int handle, int scanout_id, struct surface *surf);
--
2.25.1

Currenly it can support only one display_win. When virtio-gpu wants to display
the framebuffer from Guest_vm, it will render it into the default win. In order
to support multi-window, the scanout_id is added for display API.
After display API is refined, the vdisplay and virtio-gpu can support the multi-win
independently.

BTW: Now the scanout_id is not implemented in vdisplay module and the virtio-gpu always
passes the zero. It will be implemeneted in the later patches.

Signed-off-by: Zhao Yakui <yakui.zhao@...>
---
devicemodel/hw/pci/virtio/virtio_gpu.c | 28 +++++++++++++-------------
devicemodel/hw/vdisplay_sdl.c | 12 +++++------
devicemodel/include/vdisplay.h | 12 +++++------
3 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/devicemodel/hw/pci/virtio/virtio_gpu.c b/devicemodel/hw/pci/virtio/virtio_gpu.c
index 4ba219bc1..2f8c4362e 100644
--- a/devicemodel/hw/pci/virtio/virtio_gpu.c
+++ b/devicemodel/hw/pci/virtio/virtio_gpu.c
@@ -556,7 +556,7 @@ virtio_gpu_cmd_get_edid(struct virtio_gpu_command *cmd)
resp.size = 128;
resp.hdr.type = VIRTIO_GPU_RESP_OK_EDID;
virtio_gpu_update_resp_fence(&cmd->hdr, &resp.hdr);
- vdpy_get_edid(gpu->vdpy_handle, resp.edid, resp.size);
+ vdpy_get_edid(gpu->vdpy_handle, 0, resp.edid, resp.size);
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
}

@@ -570,7 +570,7 @@ virtio_gpu_cmd_get_display_info(struct virtio_gpu_command *cmd)
gpu = cmd->gpu;
cmd->iolen = sizeof(resp);
memset(&resp, 0, sizeof(resp));
- vdpy_get_display_info(gpu->vdpy_handle, &info);
+ vdpy_get_display_info(gpu->vdpy_handle, 0, &info);
resp.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO;
virtio_gpu_update_resp_fence(&cmd->hdr, &resp.hdr);
resp.pmodes[0].enabled = 1;
@@ -790,7 +790,7 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)

r2d = virtio_gpu_find_resource_2d(gpu, req.resource_id);
if ((req.resource_id == 0) || (r2d == NULL)) {
- vdpy_surface_set(gpu->vdpy_handle, NULL);
+ vdpy_surface_set(gpu->vdpy_handle, 0, NULL);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
return;
@@ -814,7 +814,7 @@ virtio_gpu_cmd_set_scanout(struct virtio_gpu_command *cmd)
surf.stride = pixman_image_get_stride(r2d->image);
surf.surf_format = r2d->format;
surf.surf_type = SURFACE_PIXMAN;
- vdpy_surface_set(gpu->vdpy_handle, &surf);
+ vdpy_surface_set(gpu->vdpy_handle, 0, &surf);
pixman_image_unref(r2d->image);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
}
@@ -934,7 +934,7 @@ virtio_gpu_cmd_resource_flush(struct virtio_gpu_command *cmd)
virtio_gpu_dmabuf_ref(r2d->dma_info);
surf.dma_info.dmabuf_fd = r2d->dma_info->dmabuf_fd;
surf.surf_type = SURFACE_DMABUF;
- vdpy_surface_update(gpu->vdpy_handle, &surf);
+ vdpy_surface_update(gpu->vdpy_handle, 0, &surf);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[1].iov_base, &resp, sizeof(resp));
virtio_gpu_dmabuf_unref(r2d->dma_info);
@@ -949,7 +949,7 @@ virtio_gpu_cmd_resource_flush(struct virtio_gpu_command *cmd)
surf.stride = pixman_image_get_stride(r2d->image);
surf.surf_format = r2d->format;
surf.surf_type = SURFACE_PIXMAN;
- vdpy_surface_update(gpu->vdpy_handle, &surf);
+ vdpy_surface_update(gpu->vdpy_handle, 0, &surf);
pixman_image_unref(r2d->image);

cmd->iolen = sizeof(resp);
@@ -1143,7 +1143,7 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
if (req.resource_id == 0) {
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
- vdpy_surface_set(gpu->vdpy_handle, NULL);
+ vdpy_surface_set(gpu->vdpy_handle, 0, NULL);
return;
}
r2d = virtio_gpu_find_resource_2d(cmd->gpu, req.resource_id);
@@ -1187,7 +1187,7 @@ virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_command *cmd)
break;
}
surf.dma_info.surf_fourcc = drm_fourcc;
- vdpy_surface_set(gpu->vdpy_handle, &surf);
+ vdpy_surface_set(gpu->vdpy_handle, 0, &surf);
resp.type = VIRTIO_GPU_RESP_OK_NODATA;
memcpy(cmd->iov[cmd->iovcnt - 1].iov_base, &resp, sizeof(resp));
virtio_gpu_dmabuf_unref(r2d->dma_info);
@@ -1312,7 +1312,7 @@ virtio_gpu_cmd_update_cursor(struct virtio_gpu_command *cmd)
cur.height = r2d->height;
pixman_image_ref(r2d->image);
cur.data = pixman_image_get_data(r2d->image);
- vdpy_cursor_define(gpu->vdpy_handle, &cur);
+ vdpy_cursor_define(gpu->vdpy_handle, 0, &cur);
pixman_image_unref(r2d->image);
}
}
@@ -1325,7 +1325,7 @@ virtio_gpu_cmd_move_cursor(struct virtio_gpu_command *cmd)

gpu = cmd->gpu;
memcpy(&req, cmd->iov[0].iov_base, sizeof(req));
- vdpy_cursor_move(gpu->vdpy_handle, req.pos.x, req.pos.y);
+ vdpy_cursor_move(gpu->vdpy_handle, 0, req.pos.x, req.pos.y);
}

static void
@@ -1397,10 +1397,10 @@ virtio_gpu_vga_bh(void *param)
gpu->vga.surf.pixel = gpu->vga.gc->gc_image->data;
gpu->vga.surf.surf_format = PIXMAN_a8r8g8b8;
gpu->vga.surf.surf_type = SURFACE_PIXMAN;
- vdpy_surface_set(gpu->vdpy_handle, &gpu->vga.surf);
+ vdpy_surface_set(gpu->vdpy_handle, 0, &gpu->vga.surf);
}

- vdpy_surface_update(gpu->vdpy_handle, &gpu->vga.surf);
+ vdpy_surface_update(gpu->vdpy_handle, 0, &gpu->vga.surf);
}

static void *
@@ -1553,7 +1553,7 @@ virtio_gpu_init(struct vmctx *ctx, struct pci_vdev *dev, char *opts)
pci_set_cfgdata16(dev, PCIR_SUBVEND_0, VIRTIO_VENDOR);

LIST_INIT(&gpu->r2d_list);
- vdpy_get_display_info(gpu->vdpy_handle, &info);
+ vdpy_get_display_info(gpu->vdpy_handle, 0, &info);

/*** PCI Config BARs setup ***/
/** BAR0: VGA framebuffer **/
@@ -1566,7 +1566,7 @@ virtio_gpu_init(struct vmctx *ctx, struct pci_vdev *dev, char *opts)

/** BAR2: VGA & Virtio Modern regs **/
/* EDID data blob [0x000~0x3ff] */
- vdpy_get_edid(gpu->vdpy_handle, gpu->edid, VIRTIO_GPU_EDID_SIZE);
+ vdpy_get_edid(gpu->vdpy_handle, 0, gpu->edid, VIRTIO_GPU_EDID_SIZE);
/* VGA ioports regs [0x400~0x41f] */
gpu->vga.gc = gc_init(info.width, info.height, ctx->fb_base);
gpu->vga.dev = vga_init(gpu->vga.gc, 0);
diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 21ceb2325..567a2de6f 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -510,7 +510,7 @@ vdpy_edid_generate(uint8_t *edid, size_t size, struct edid_info *info)
}

void
-vdpy_get_edid(int handle, uint8_t *edid, size_t size)
+vdpy_get_edid(int handle, int scanout_id, uint8_t *edid, size_t size)
{
struct edid_info edid_info;

@@ -534,7 +534,7 @@ vdpy_get_edid(int handle, uint8_t *edid, size_t size)
}

void
-vdpy_get_display_info(int handle, struct display_info *info)
+vdpy_get_display_info(int handle, int scanout_id, struct display_info *info)
{
if (handle == vdpy.s.n_connect) {
info->xoff = vdpy.info.xoff;
@@ -582,7 +582,7 @@ sdl_gl_display_init(void)
}

void
-vdpy_surface_set(int handle, struct surface *surf)
+vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
{
pixman_image_t *src_img;
int format;
@@ -749,7 +749,7 @@ vdpy_cursor_position_transformation(struct display *vdpy, SDL_Rect *rect)
}

void
-vdpy_surface_update(int handle, struct surface *surf)
+vdpy_surface_update(int handle, int scanout_id, struct surface *surf)
{
SDL_Rect cursor_rect;

@@ -792,7 +792,7 @@ vdpy_surface_update(int handle, struct surface *surf)
}

void
-vdpy_cursor_define(int handle, struct cursor *cur)
+vdpy_cursor_define(int handle, int scanout_id, struct cursor *cur)
{
if (handle != vdpy.s.n_connect) {
return;
@@ -826,7 +826,7 @@ vdpy_cursor_define(int handle, struct cursor *cur)
}

void
-vdpy_cursor_move(int handle, uint32_t x, uint32_t y)
+vdpy_cursor_move(int handle, int scanout_id, uint32_t x, uint32_t y)
{
if (handle != vdpy.s.n_connect) {
return;
diff --git a/devicemodel/include/vdisplay.h b/devicemodel/include/vdisplay.h
index 99506469b..fc0e91b46 100644
--- a/devicemodel/include/vdisplay.h
+++ b/devicemodel/include/vdisplay.h
@@ -86,13 +86,13 @@ struct cursor {
int vdpy_parse_cmd_option(const char *opts);
int gfx_ui_init();
int vdpy_init();
-void vdpy_get_display_info(int handle, struct display_info *info);
-void vdpy_surface_set(int handle, struct surface *surf);
-void vdpy_surface_update(int handle, struct surface *surf);
+void vdpy_get_display_info(int handle, int scanout_id, struct display_info *info);
+void vdpy_surface_set(int handle, int scanout_id, struct surface *surf);
+void vdpy_surface_update(int handle, int scanout_id, struct surface *surf);
bool vdpy_submit_bh(int handle, struct vdpy_display_bh *bh);
-void vdpy_get_edid(int handle, uint8_t *edid, size_t size);
-void vdpy_cursor_define(int handle, struct cursor *cur);
-void vdpy_cursor_move(int handle, uint32_t x, uint32_t y);
+void vdpy_get_edid(int handle, int scanout_id, uint8_t *edid, size_t size);
+void vdpy_cursor_define(int handle, int scanout_id, struct cursor *cur);
+void vdpy_cursor_move(int handle, int scanout_id, uint32_t x, uint32_t y);
int vdpy_deinit(int handle);
void gfx_ui_deinit();

--
2.25.1

Virtio-gpu is added to support the display for Guest VM. The Virtio-gpu driver in guest vm
will try to submit the cmd of framebuffer that needs to be displayed. The virtio-gpu BE driver
will call the vdisplay API to display the request framebuffer on the corresponding graphics
window. But now only one display is supported for each VM.
Based on the virtio-gpu spec, it can support multi-display so that the guest_vm can optimize
to submit the display regions.
This patch set will try to add the support of multi-display for guest_vm.
And it will cover the below parts.
1. Refine display API tso that the VGPU and VDISPLAY
module can add the function of multi-display/windows.
2. Refine the vdisplay module so that it can support multi-window
3. Refine the virtio-gpu BE module so that it can handle the multi-display request from guest_vm.


Zhao Yakui (8):
ACRN:DM:VDISPLAY: Refine display API to support multi scanout_window
ACRN:DM:VDisplay: vdpy_init connection returns the supported number of
window
ACRN:DM:VGPU: Add virtio_gpu_scanout structure to handle
virtio-gpu-cmds correctly
ACRN:DM:VGPU: Handle the virtio-gpu-cmds based on scanout_id in
cmd_request
ACRN:DM:VGPU: Handle the scanout_id for cursor virtio-gpu-cmd
ACRN:DM:VGPU: virtio-gpu-flush cmds check whether one scanout_win
needs to be displayed
ACRN:DM:VGPU: Calibrate the offset in dmabuf/pixman_image to display
the scanout_window
ACRN:DM:VGPU: Return the parsed scanout_num to virtio_gpu in Guest_VM

devicemodel/hw/pci/virtio/virtio_gpu.c | 249 ++++++++++++++++++++-----
devicemodel/hw/vdisplay_sdl.c | 18 +-
devicemodel/include/vdisplay.h | 15 +-
3 files changed, 225 insertions(+), 57 deletions(-)

--
2.25.1

On 8/8/2022 9:57 PM, Junjie Mao wrote:

"chenli.wei" <chenli.wei@...> writes:

On 8/5/2022 11:19 PM, Junjie Mao wrote:

Chenli Wei <chenli.wei@...> writes:

From: Chenli Wei <chenli.wei@...>

The current ACRN-Configurator just check the conflict of user setting.
have not check the conflict with native PCI device's bdf.

This patch add an assert to check the above conflict.

Tracked-On: #6690
Signed-off-by: Chenli Wei <chenli.wei@...>
---
misc/config_tools/schema/checks/vbdf_assignment.xsd | 10 ++++++++++
1 file changed, 10 insertions(+)

diff --git a/misc/config_tools/schema/checks/vbdf_assignment.xsd b/misc/config_tools/schema/checks/vbdf_assignment.xsd
index fde14c2b7..062b0fe67 100644
--- a/misc/config_tools/schema/checks/vbdf_assignment.xsd
+++ b/misc/config_tools/schema/checks/vbdf_assignment.xsd
@@ -14,4 +14,14 @@
</xs:annotation>
</xs:assert>
+
+ <xs:assert test="every $root in /acrn-config satisfies
+ every $vm in $root/vm satisfies
+ every $vbdf in $root/hv//vuart_connection[type='pci']/endpoint[vm_name=$vm/name]/vbdf/text() | $root/hv//IVSHMEM_VM[VM_NAME=$vm/name]/VBDF/text() satisfies

Shall we check only the BDFs of ivshmem/vUART devices for the service
VM? To other VMs the BDFs are generated by the config tools which should
be able to avoid BDF collision.

BTW, please do not mix white spaces and tabs.

I thinks the pre-launched VM's vBDF setting should also be checked if we don't
check every VM.

Aren't the vBDF of passthrough devices of a pre-launched VM allocated by
the config tools rather than specified by users?

OK, Let's check Service VM only.

"chenli.wei" <chenli.wei@...> writes:

On 8/5/2022 11:19 PM, Junjie Mao wrote:

Chenli Wei <chenli.wei@...> writes:

From: Chenli Wei <chenli.wei@...>

The current ACRN-Configurator just check the conflict of user setting.
have not check the conflict with native PCI device's bdf.

This patch add an assert to check the above conflict.

Tracked-On: #6690
Signed-off-by: Chenli Wei <chenli.wei@...>
---
misc/config_tools/schema/checks/vbdf_assignment.xsd | 10 ++++++++++
1 file changed, 10 insertions(+)

diff --git a/misc/config_tools/schema/checks/vbdf_assignment.xsd b/misc/config_tools/schema/checks/vbdf_assignment.xsd
index fde14c2b7..062b0fe67 100644
--- a/misc/config_tools/schema/checks/vbdf_assignment.xsd
+++ b/misc/config_tools/schema/checks/vbdf_assignment.xsd
@@ -14,4 +14,14 @@
</xs:annotation>
</xs:assert>
+
+ <xs:assert test="every $root in /acrn-config satisfies
+ every $vm in $root/vm satisfies
+ every $vbdf in $root/hv//vuart_connection[type='pci']/endpoint[vm_name=$vm/name]/vbdf/text() | $root/hv//IVSHMEM_VM[VM_NAME=$vm/name]/VBDF/text() satisfies

Shall we check only the BDFs of ivshmem/vUART devices for the service
VM? To other VMs the BDFs are generated by the config tools which should
be able to avoid BDF collision.

BTW, please do not mix white spaces and tabs.

I thinks the pre-launched VM's vBDF setting should also be checked if we don't
check every VM.

Aren't the vBDF of passthrough devices of a pre-launched VM allocated by
the config tools rather than specified by users?

--
Best Regards
Junjie Mao

From: Sun Peng <peng.p.sun@...>

Allow one VM have more than 1 virtual display for output. Till now, the
max virtual display number is 2. So guest VM can use dual display for
mirror and extend desktop mode. To specify multi-vdisplay, need use
acrn-dm parameters like this:
For fullscreen mode:

virtio-gpu,geometry=fullscreen:monitor_id1,geometry=fullscreen:monitor_id2

For window mode:

virtio-gpu,geometry=<width>x<height>+<x_off>+<y_off>,geometry=<width>x<height>+<x_off>+<y_off>

Signed-off-by: Sun Peng <peng.p.sun@...>
---
devicemodel/hw/vdisplay_sdl.c | 67 +++++++++++++++++++++--------------
1 file changed, 40 insertions(+), 27 deletions(-)

diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 28457c52e..c7a279ab6 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -32,7 +32,7 @@
#define VDPY_MIN_WIDTH 640
#define VDPY_MIN_HEIGHT 480
#define transto_10bits(color) (uint16_t)(color * 1024 + 0.5)
-#define VSCREEN_MAX_NUM 1
+#define VSCREEN_MAX_NUM 2

static unsigned char default_raw_argb[VDPY_DEFAULT_WIDTH * VDPY_DEFAULT_HEIGHT * 4];

@@ -1323,7 +1323,7 @@ gfx_ui_deinit()

int vdpy_parse_cmd_option(const char *opts)
{
- char *str;
+ char *str, *stropts, *tmp;
int snum, error;
struct vscreen *vscr;

@@ -1331,35 +1331,48 @@ int vdpy_parse_cmd_option(const char *opts)
vdpy.vscrs = calloc(VSCREEN_MAX_NUM, sizeof(struct vscreen));
vdpy.vscrs_num = 0;

- str = strcasestr(opts, "geometry=");
- vscr = vdpy.vscrs + vdpy.vscrs_num;
- if (opts && strcasestr(opts, "geometry=fullscreen")) {
- snum = sscanf(str, "geometry=fullscreen:%d", &vscr->pscreen_id);
- if (snum != 1) {
+ stropts = strdup(opts);
+ while ((str = strsep(&stropts, ",")) != NULL) {
+ vscr = vdpy.vscrs + vdpy.vscrs_num;
+ tmp = strcasestr(str, "geometry=");
+ if (str && strcasestr(str, "geometry=fullscreen")) {
+ snum = sscanf(tmp, "geometry=fullscreen:%d", &vscr->pscreen_id);
+ if (snum != 1) {
+ vscr->pscreen_id = 0;
+ }
+ vscr->width = VDPY_MAX_WIDTH;
+ vscr->height = VDPY_MAX_HEIGHT;
+ vscr->is_fullscreen = true;
+ pr_info("virtual display: fullscreen.\n");
+ vscr->info.xoff = vscr->org_x;
+ vscr->info.yoff = vscr->org_y;
+ vscr->info.width = vscr->width;
+ vscr->info.height = vscr->height;
+ vdpy.vscrs_num++;
+ } else if (str && strcasestr(str, "geometry=")) {
+ snum = sscanf(tmp, "geometry=%dx%d+%d+%d",
+ &vscr->width, &vscr->height,
+ &vscr->org_x, &vscr->org_y);
+ if (snum != 4) {
+ pr_err("incorrect geometry option. Should be"
+ " WxH+x+y\n");
+ error = -1;
+ }
+ vscr->is_fullscreen = false;
vscr->pscreen_id = 0;
+ pr_info("virtual display: windowed.\n");
+ vscr->info.xoff = vscr->org_x;
+ vscr->info.yoff = vscr->org_y;
+ vscr->info.width = vscr->width;
+ vscr->info.height = vscr->height;
+ vdpy.vscrs_num++;
}
- vscr->width = VDPY_MAX_WIDTH;
- vscr->height = VDPY_MAX_HEIGHT;
- vscr->is_fullscreen = true;
- vdpy.vscrs_num++;
- pr_info("virtual display: fullscreen.\n");
- } else if (opts && strcasestr(opts, "geometry=")) {
- snum = sscanf(str, "geometry=%dx%d+%d+%d",
- &vscr->width, &vscr->height,
- &vscr->org_x, &vscr->org_y);
- if (snum != 4) {
- pr_err("incorrect geometry option. Should be"
- " WxH+x+y\n");
- error = -1;
+ if (vdpy.vscrs_num > VSCREEN_MAX_NUM) {
+ pr_err("Too many virtual display that acrn-dm can't support!\n");
+ break;
}
- vscr->is_fullscreen = false;
- vdpy.vscrs_num++;
- pr_info("virtual display: windowed.\n");
}
+ free(stropts);

- vscr->info.xoff = 0;
- vscr->info.yoff = 0;
- vscr->info.width = vdpy.vscrs->width;
- vscr->info.height = vdpy.vscrs->height;
return error;
}
--
2.25.1

From: Sun Peng <peng.p.sun@...>

Add new concept "vscreen" to abstract all specs about screen in a
display server. This can provide convenience to add more screens
for one VM.

Signed-off-by: Sun Peng <peng.p.sun@...>
---
devicemodel/hw/vdisplay_sdl.c | 503 +++++++++++++++++++++-------------
1 file changed, 315 insertions(+), 188 deletions(-)

diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 7a098f4b2..28457c52e 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -32,6 +32,7 @@
#define VDPY_MIN_WIDTH 640
#define VDPY_MIN_HEIGHT 480
#define transto_10bits(color) (uint16_t)(color * 1024 + 0.5)
+#define VSCREEN_MAX_NUM 1

static unsigned char default_raw_argb[VDPY_DEFAULT_WIDTH * VDPY_DEFAULT_HEIGHT * 4];

@@ -40,8 +41,6 @@ struct state {
bool is_active;
bool is_wayland;
bool is_x11;
- bool is_fullscreen;
- uint64_t updates;
int n_connect;
};

@@ -51,27 +50,39 @@ struct egl_display_ops {
PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;
};

-static struct display {
+struct vscreen {
+ struct display_info info;
int pscreen_id;
SDL_Rect pscreen_rect;
- struct display_info info;
- struct state s;
- SDL_Texture *dpy_texture;
- SDL_Window *dpy_win;
- SDL_Renderer *dpy_renderer;
- pixman_image_t *dpy_img;
- pthread_t tid;
- int width, height; // Width/height of dpy_win
- int org_x, org_y;
- int guest_width, guest_height;
+ bool is_fullscreen;
+ int org_x;
+ int org_y;
+ int width;
+ int height;
+ int guest_width;
+ int guest_height;
struct surface surf;
struct cursor cur;
- SDL_Texture *cursor_tex;
+ SDL_Texture *surf_tex;
+ SDL_Texture *cur_tex;
+ int surf_updates;
+ int cur_updates;
+ SDL_Window *win;
+ SDL_Renderer *renderer;
+ pixman_image_t *img;
+ EGLImage egl_img;
+ /* Record the update_time that is activated from guest_vm */
+ struct timespec last_time;
+};
+
+static struct display {
+ struct state s;
+ struct vscreen *vscrs;
+ int vscrs_num;
+ pthread_t tid;
/* Add one UI_timer(33ms) to render the buffers from guest_vm */
struct acrn_timer ui_timer;
struct vdpy_display_bh ui_timer_bh;
- /* Record the update_time that is activated from guest_vm */
- struct timespec last_time;
// protect the request_list
pthread_mutex_t vdisplay_mutex;
// receive the signal that request is submitted
@@ -82,14 +93,11 @@ static struct display {
SDL_GLContext eglContext;
EGLDisplay eglDisplay;
struct egl_display_ops gl_ops;
- EGLImage cur_egl_img;
} vdpy = {
.s.is_ui_realized = false,
.s.is_active = false,
.s.is_wayland = false,
.s.is_x11 = false,
- .s.is_fullscreen = false,
- .s.updates = 0,
.s.n_connect = 0
};

@@ -514,10 +522,19 @@ void
vdpy_get_edid(int handle, int scanout_id, uint8_t *edid, size_t size)
{
struct edid_info edid_info;
+ struct vscreen *vscr;
+
+ if (scanout_id >= vdpy.vscrs_num)
+ return;
+
+ vscr = vdpy.vscrs + scanout_id;
+ if (vscr == NULL) {
+ return;
+ }

if (handle == vdpy.s.n_connect) {
- edid_info.prefx = vdpy.info.width;
- edid_info.prefy = vdpy.info.height;
+ edid_info.prefx = vscr->info.width;
+ edid_info.prefy = vscr->info.height;
edid_info.maxx = VDPY_MAX_WIDTH;
edid_info.maxy = VDPY_MAX_HEIGHT;
} else {
@@ -537,11 +554,21 @@ vdpy_get_edid(int handle, int scanout_id, uint8_t *edid, size_t size)
void
vdpy_get_display_info(int handle, int scanout_id, struct display_info *info)
{
+ struct vscreen *vscr;
+
+ if (scanout_id >= vdpy.vscrs_num)
+ return;
+
+ vscr = vdpy.vscrs + scanout_id;
+ if (vscr == NULL) {
+ return;
+ }
+
if (handle == vdpy.s.n_connect) {
- info->xoff = vdpy.info.xoff;
- info->yoff = vdpy.info.yoff;
- info->width = vdpy.info.width;
- info->height = vdpy.info.height;
+ info->xoff = vscr->info.xoff;
+ info->yoff = vscr->info.yoff;
+ info->width = vscr->info.width;
+ info->height = vscr->info.height;
} else {
info->xoff = 0;
info->yoff = 0;
@@ -554,6 +581,8 @@ static void
sdl_gl_display_init(void)
{
struct egl_display_ops *gl_ops = &vdpy.gl_ops;
+ struct vscreen *vscr;
+ int i;

/* obtain the eglDisplay/eglContext */
vdpy.eglDisplay = eglGetCurrentDisplay();
@@ -570,7 +599,15 @@ sdl_gl_display_init(void)
gl_ops->glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)
eglGetProcAddress("glEGLImageTargetTexture2DOES");

- vdpy.cur_egl_img = EGL_NO_IMAGE_KHR;
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = vdpy.vscrs + i;
+ if (vscr == NULL) {
+ continue;
+ }
+
+ vscr->egl_img = EGL_NO_IMAGE_KHR;
+ }
+
if ((gl_ops->eglCreateImageKHR == NULL) ||
(gl_ops->eglDestroyImageKHR == NULL) ||
(gl_ops->glEGLImageTargetTexture2DOES == NULL)) {
@@ -588,6 +625,7 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
pixman_image_t *src_img;
int format;
int access, i;
+ struct vscreen *vscr;

if (handle != vdpy.s.n_connect) {
return;
@@ -599,9 +637,18 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
return;
}

+ if (scanout_id >= vdpy.vscrs_num) {
+ return;
+ }
+
+ vscr = vdpy.vscrs + scanout_id;
+ if (vscr == NULL) {
+ return;
+ }
+
if (surf == NULL ) {
- vdpy.surf.width = 0;
- vdpy.surf.height = 0;
+ vscr->surf.width = 0;
+ vscr->surf.height = 0;
/* Need to use the default 640x480 for the SDL_Texture */
src_img = pixman_image_create_bits(PIXMAN_a8r8g8b8,
VDPY_MIN_WIDTH, VDPY_MIN_HEIGHT,
@@ -611,8 +658,8 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
pr_err("failed to create pixman_image\n");
return;
}
- vdpy.guest_width = VDPY_MIN_WIDTH;
- vdpy.guest_height = VDPY_MIN_HEIGHT;
+ vscr->guest_width = VDPY_MIN_WIDTH;
+ vscr->guest_height = VDPY_MIN_HEIGHT;
} else if (surf->surf_type == SURFACE_PIXMAN) {
src_img = pixman_image_create_bits(surf->surf_format,
surf->width, surf->height, surf->pixel,
@@ -621,21 +668,21 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
pr_err("failed to create pixman_image\n");
return;
}
- vdpy.surf = *surf;
- vdpy.guest_width = surf->width;
- vdpy.guest_height = surf->height;
+ vscr->surf = *surf;
+ vscr->guest_width = surf->width;
+ vscr->guest_height = surf->height;
} else if (surf->surf_type == SURFACE_DMABUF) {
src_img = NULL;
- vdpy.surf = *surf;
- vdpy.guest_width = surf->width;
- vdpy.guest_height = surf->height;
+ vscr->surf = *surf;
+ vscr->guest_width = surf->width;
+ vscr->guest_height = surf->height;
} else {
/* Unsupported type */
return;
}

- if (vdpy.dpy_texture) {
- SDL_DestroyTexture(vdpy.dpy_texture);
+ if (vscr->surf_tex) {
+ SDL_DestroyTexture(vscr->surf_tex);
}
if (surf && (surf->surf_type == SURFACE_DMABUF)) {
access = SDL_TEXTUREACCESS_STATIC;
@@ -666,23 +713,23 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
pixman_image_get_format(src_img));
}
}
- vdpy.dpy_texture = SDL_CreateTexture(vdpy.dpy_renderer,
+ vscr->surf_tex = SDL_CreateTexture(vscr->renderer,
format, access,
- vdpy.guest_width, vdpy.guest_height);
+ vscr->guest_width, vscr->guest_height);

- if (vdpy.dpy_texture == NULL) {
+ if (vscr->surf_tex == NULL) {
pr_err("Failed to create SDL_texture for surface.\n");
}

/* For the surf_switch, it will be updated in surface_update */
if (!surf) {
- SDL_UpdateTexture(vdpy.dpy_texture, NULL,
+ SDL_UpdateTexture(vscr->surf_tex, NULL,
pixman_image_get_data(src_img),
pixman_image_get_stride(src_img));

- SDL_RenderClear(vdpy.dpy_renderer);
- SDL_RenderCopy(vdpy.dpy_renderer, vdpy.dpy_texture, NULL, NULL);
- SDL_RenderPresent(vdpy.dpy_renderer);
+ SDL_RenderClear(vscr->renderer);
+ SDL_RenderCopy(vscr->renderer, vscr->surf_tex, NULL, NULL);
+ SDL_RenderPresent(vscr->renderer);
} else if (surf->surf_type == SURFACE_DMABUF) {
EGLImageKHR egl_img = EGL_NO_IMAGE_KHR;
EGLint attrs[64];
@@ -713,46 +760,58 @@ vdpy_surface_set(int handle, int scanout_id, struct surface *surf)
return;
}

- SDL_GL_BindTexture(vdpy.dpy_texture, NULL, NULL);
+ SDL_GL_BindTexture(vscr->surf_tex, NULL, NULL);
gl_ops->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_img);
- if (vdpy.cur_egl_img != EGL_NO_IMAGE_KHR)
+ if (vscr->egl_img != EGL_NO_IMAGE_KHR)
gl_ops->eglDestroyImageKHR(vdpy.eglDisplay,
- vdpy.cur_egl_img);
+ vscr->egl_img);

/* In theory the created egl_img can be released after it is bound
* to texture.
* Now it is released next time so that it is controlled correctly
*/
- vdpy.cur_egl_img = egl_img;
+ vscr->egl_img = egl_img;
}

- if (vdpy.dpy_img)
- pixman_image_unref(vdpy.dpy_img);
+ if (vscr->img)
+ pixman_image_unref(vscr->img);

if (surf == NULL) {
- SDL_SetWindowTitle(vdpy.dpy_win,
+ SDL_SetWindowTitle(vscr->win,
"Not activate display yet!");
} else {
- SDL_SetWindowTitle(vdpy.dpy_win,
+ SDL_SetWindowTitle(vscr->win,
"ACRN Virtual Monitor");
}
/* Replace the cur_img with the created_img */
- vdpy.dpy_img = src_img;
+ vscr->img = src_img;
}

void
-vdpy_cursor_position_transformation(struct display *vdpy, SDL_Rect *rect)
+vdpy_cursor_position_transformation(struct display *vdpy, int scanout_id, SDL_Rect *rect)
{
- rect->x = (vdpy->cur.x * vdpy->width) / vdpy->guest_width;
- rect->y = (vdpy->cur.y * vdpy->height) / vdpy->guest_height;
- rect->w = (vdpy->cur.width * vdpy->width) / vdpy->guest_width;
- rect->h = (vdpy->cur.height * vdpy->height) / vdpy->guest_height;
+ struct vscreen *vscr;
+
+ if (scanout_id >= vdpy->vscrs_num) {
+ return;
+ }
+
+ vscr = vdpy->vscrs + scanout_id;
+ if(vscr == NULL) {
+ return;
+ }
+
+ rect->x = (vscr->cur.x * vscr->width) / vscr->guest_width;
+ rect->y = (vscr->cur.y * vscr->height) / vscr->guest_height;
+ rect->w = (vscr->cur.width * vscr->width) / vscr->guest_width;
+ rect->h = (vscr->cur.height * vscr->height) / vscr->guest_height;
}

void
vdpy_surface_update(int handle, int scanout_id, struct surface *surf)
{
SDL_Rect cursor_rect;
+ struct vscreen *vscr;

if (handle != vdpy.s.n_connect) {
return;
@@ -769,32 +828,43 @@ vdpy_surface_update(int handle, int scanout_id, struct surface *surf)
return;
}

+ if (scanout_id >= vdpy.vscrs_num) {
+ return;
+ }
+
+ vscr = vdpy.vscrs + scanout_id;
+ if (vscr == NULL) {
+ return;
+ }
+
if (surf->surf_type == SURFACE_PIXMAN)
- SDL_UpdateTexture(vdpy.dpy_texture, NULL,
+ SDL_UpdateTexture(vscr->surf_tex, NULL,
surf->pixel,
surf->stride);

- SDL_RenderClear(vdpy.dpy_renderer);
- SDL_RenderCopy(vdpy.dpy_renderer, vdpy.dpy_texture, NULL, NULL);
+ SDL_RenderClear(vscr->renderer);
+ SDL_RenderCopy(vscr->renderer, vscr->surf_tex, NULL, NULL);

/* This should be handled after rendering the surface_texture.
* Otherwise it will be hidden
*/
- if (vdpy.cursor_tex) {
- vdpy_cursor_position_transformation(&vdpy, &cursor_rect);
- SDL_RenderCopy(vdpy.dpy_renderer, vdpy.cursor_tex,
+ if (vscr->cur_tex) {
+ vdpy_cursor_position_transformation(&vdpy, scanout_id, &cursor_rect);
+ SDL_RenderCopy(vscr->renderer, vscr->cur_tex,
NULL, &cursor_rect);
}

- SDL_RenderPresent(vdpy.dpy_renderer);
+ SDL_RenderPresent(vscr->renderer);

/* update the rendering time */
- clock_gettime(CLOCK_MONOTONIC, &vdpy.last_time);
+ clock_gettime(CLOCK_MONOTONIC, &vscr->last_time);
}

void
vdpy_cursor_define(int handle, int scanout_id, struct cursor *cur)
{
+ struct vscreen *vscr;
+
if (handle != vdpy.s.n_connect) {
return;
}
@@ -805,39 +875,55 @@ vdpy_cursor_define(int handle, int scanout_id, struct cursor *cur)
return;
}

+ if (scanout_id >= vdpy.vscrs_num) {
+ return;
+ }
+
if (cur->data == NULL)
return;

- if (vdpy.cursor_tex)
- SDL_DestroyTexture(vdpy.cursor_tex);
+ vscr = vdpy.vscrs + scanout_id;
+ if (vscr == NULL) {
+ return;
+ }
+
+ if (vscr->cur_tex)
+ SDL_DestroyTexture(vscr->cur_tex);

- vdpy.cursor_tex = SDL_CreateTexture(
- vdpy.dpy_renderer,
+ vscr->cur_tex = SDL_CreateTexture(
+ vscr->renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
cur->width, cur->height);
- if (vdpy.cursor_tex == NULL) {
+ if (vscr->cur_tex == NULL) {
pr_err("Failed to create sdl_cursor surface for %p.\n", cur);
return;
}

- SDL_SetTextureBlendMode(vdpy.cursor_tex, SDL_BLENDMODE_BLEND);
- vdpy.cur = *cur;
- SDL_UpdateTexture(vdpy.cursor_tex, NULL, cur->data, cur->width * 4);
+ SDL_SetTextureBlendMode(vscr->cur_tex, SDL_BLENDMODE_BLEND);
+ vscr->cur = *cur;
+ SDL_UpdateTexture(vscr->cur_tex, NULL, cur->data, cur->width * 4);
}

void
vdpy_cursor_move(int handle, int scanout_id, uint32_t x, uint32_t y)
{
+ struct vscreen *vscr;
+
if (handle != vdpy.s.n_connect) {
return;
}

+ if (scanout_id >= vdpy.vscrs_num) {
+ return;
+ }
+
+ vscr = vdpy.vscrs + scanout_id;
/* Only move the position of the cursor. The cursor_texture
* will be handled in surface_update
*/
- vdpy.cur.x = x;
- vdpy.cur.y = y;
+ vscr->cur.x = x;
+ vscr->cur.y = y;
}

static void
@@ -847,35 +933,41 @@ vdpy_sdl_ui_refresh(void *data)
struct timespec cur_time;
uint64_t elapsed_time;
SDL_Rect cursor_rect;
+ struct vscreen *vscr;
+ int i;

ui_vdpy = (struct display *)data;

- /* Skip it if no surface needs to be rendered */
- if (ui_vdpy->dpy_texture == NULL)
- return;
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = ui_vdpy->vscrs + i;

- clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ /* Skip it if no surface needs to be rendered */
+ if (vscr->surf_tex == NULL)
+ continue;

- elapsed_time = (cur_time.tv_sec - ui_vdpy->last_time.tv_sec) * 1000000000 +
- cur_time.tv_nsec - ui_vdpy->last_time.tv_nsec;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);

- /* the time interval is less than 10ms. Skip it */
- if (elapsed_time < 10000000)
- return;
+ elapsed_time = (cur_time.tv_sec - vscr->last_time.tv_sec) * 1000000000 +
+ cur_time.tv_nsec - vscr->last_time.tv_nsec;

- SDL_RenderClear(ui_vdpy->dpy_renderer);
- SDL_RenderCopy(ui_vdpy->dpy_renderer, ui_vdpy->dpy_texture, NULL, NULL);
+ /* the time interval is less than 10ms. Skip it */
+ if (elapsed_time < 10000000)
+ return;

- /* This should be handled after rendering the surface_texture.
- * Otherwise it will be hidden
- */
- if (ui_vdpy->cursor_tex) {
- vdpy_cursor_position_transformation(ui_vdpy, &cursor_rect);
- SDL_RenderCopy(ui_vdpy->dpy_renderer, ui_vdpy->cursor_tex,
- NULL, &cursor_rect);
- }
+ SDL_RenderClear(vscr->renderer);
+ SDL_RenderCopy(vscr->renderer, vscr->surf_tex, NULL, NULL);
+
+ /* This should be handled after rendering the surface_texture.
+ * Otherwise it will be hidden
+ */
+ if (vscr->cur_tex) {
+ vdpy_cursor_position_transformation(ui_vdpy, i, &cursor_rect);
+ SDL_RenderCopy(vscr->renderer, vscr->cur_tex,
+ NULL, &cursor_rect);
+ }

- SDL_RenderPresent(ui_vdpy->dpy_renderer);
+ SDL_RenderPresent(vscr->renderer);
+ }
}

static void
@@ -911,57 +1003,67 @@ vdpy_sdl_display_thread(void *data)
struct itimerspec ui_timer_spec;
int max_width, max_height;
int min_width, min_height;
+ struct vscreen *vscr;
+ int i;

- max_width = MIN(vdpy.pscreen_rect.w, VDPY_MAX_WIDTH);
- max_height = MIN(vdpy.pscreen_rect.h, VDPY_MAX_HEIGHT);
- min_width = MAX(vdpy.pscreen_rect.w, VDPY_MIN_WIDTH);
- min_height = MAX(vdpy.pscreen_rect.h, VDPY_MIN_HEIGHT);
- if (vdpy.width && vdpy.height) {
- /* clip the region between (640x480) and (1920x1080) */
- if (vdpy.width < min_width)
- vdpy.width = min_width;
- if (vdpy.width > max_width)
- vdpy.width = max_width;
- if (vdpy.height < min_height)
- vdpy.height = min_height;
- if (vdpy.height > max_height)
- vdpy.height = max_height;
- } else {
- /* the default window(1280x720) is created with undefined pos
- * when no geometry info is passed
- */
- vdpy.org_x = 0xFFFF;
- vdpy.org_y = 0xFFFF;
- vdpy.width = VDPY_DEFAULT_WIDTH;
- vdpy.height = VDPY_DEFAULT_HEIGHT;
- }
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = vdpy.vscrs + i;
+ if (vscr == NULL) {
+ continue;
+ }

- win_flags = SDL_WINDOW_OPENGL |
- SDL_WINDOW_ALWAYS_ON_TOP |
- SDL_WINDOW_SHOWN;
- if (vdpy.s.is_fullscreen) {
- win_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
- }
- vdpy.dpy_win = NULL;
- vdpy.dpy_renderer = NULL;
- vdpy.dpy_img = NULL;
- vdpy.org_x = vdpy.pscreen_rect.x;
- vdpy.org_y = vdpy.pscreen_rect.y;
- vdpy.dpy_win = SDL_CreateWindow("ACRN_DM",
- vdpy.org_x, vdpy.org_y,
- vdpy.width, vdpy.height,
+ max_width = MIN(vscr->pscreen_rect.w, VDPY_MAX_WIDTH);
+ max_height = MIN(vscr->pscreen_rect.h, VDPY_MAX_HEIGHT);
+ min_width = MAX(vscr->pscreen_rect.w, VDPY_MIN_WIDTH);
+ min_height = MAX(vscr->pscreen_rect.h, VDPY_MIN_HEIGHT);
+ if (vscr->width && vscr->height) {
+ /* clip the region between (640x480) and (1920x1080) */
+ if (vscr->width < min_width)
+ vscr->width = min_width;
+ if (vscr->width > max_width)
+ vscr->width = max_width;
+ if (vscr->height < min_height)
+ vscr->height = min_height;
+ if (vscr->height > max_height)
+ vscr->height = max_height;
+ } else {
+ /* the default window(1280x720) is created with undefined pos
+ * when no geometry info is passed
+ */
+ vscr->org_x = 0xFFFF;
+ vscr->org_y = 0xFFFF;
+ vscr->width = VDPY_DEFAULT_WIDTH;
+ vscr->height = VDPY_DEFAULT_HEIGHT;
+ }
+
+ win_flags = SDL_WINDOW_OPENGL |
+ SDL_WINDOW_ALWAYS_ON_TOP |
+ SDL_WINDOW_SHOWN;
+ if (vscr->is_fullscreen) {
+ win_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+ }
+ vscr->win = NULL;
+ vscr->renderer = NULL;
+ vscr->img = NULL;
+ vscr->org_x = vscr->pscreen_rect.x;
+ vscr->org_y = vscr->pscreen_rect.y;
+ vscr->win = SDL_CreateWindow("ACRN_DM",
+ vscr->org_x, vscr->org_y,
+ vscr->width, vscr->height,
win_flags);
- if (vdpy.dpy_win == NULL) {
- pr_err("Failed to Create SDL_Window\n");
- goto sdl_fail;
- }
- pr_info("SDL display bind to screen %d: [%d,%d,%d,%d].\n", vdpy.pscreen_id,
- vdpy.org_x, vdpy.org_y, vdpy.width, vdpy.height);
+ if (vscr->win == NULL) {
+ pr_err("Failed to Create SDL_Window\n");
+ goto sdl_fail;
+ }
+ pr_info("SDL display bind to screen %d: [%d,%d,%d,%d].\n", vscr->pscreen_id,
+ vscr->org_x, vscr->org_y, vscr->width, vscr->height);

- vdpy.dpy_renderer = SDL_CreateRenderer(vdpy.dpy_win, -1, 0);
- if (vdpy.dpy_renderer == NULL) {
- pr_err("Failed to Create GL_Renderer \n");
- goto sdl_fail;
+ vscr->renderer = SDL_CreateRenderer(vscr->win, -1, 0);
+ if (vscr->renderer == NULL) {
+ pr_err("Failed to Create GL_Renderer \n");
+ goto sdl_fail;
+ }
+ clock_gettime(CLOCK_MONOTONIC, &vscr->last_time);
}
sdl_gl_display_init();
pthread_mutex_init(&vdpy.vdisplay_mutex, NULL);
@@ -971,7 +1073,6 @@ vdpy_sdl_display_thread(void *data)

vdpy.ui_timer_bh.task_cb = vdpy_sdl_ui_refresh;
vdpy.ui_timer_bh.data = &vdpy;
- clock_gettime(CLOCK_MONOTONIC, &vdpy.last_time);
vdpy.ui_timer.clockid = CLOCK_MONOTONIC;
acrn_timer_init(&vdpy.ui_timer, vdpy_sdl_ui_timer, &vdpy);
ui_timer_spec.it_interval.tv_sec = 0;
@@ -1019,34 +1120,48 @@ vdpy_sdl_display_thread(void *data)
/* SDL display_thread will exit because of DM request */
pthread_mutex_destroy(&vdpy.vdisplay_mutex);
pthread_cond_destroy(&vdpy.vdisplay_signal);
- if (vdpy.dpy_img) {
- pixman_image_unref(vdpy.dpy_img);
- vdpy.dpy_img = NULL;
- }
- /* Continue to thread cleanup */

- if (vdpy.dpy_texture) {
- SDL_DestroyTexture(vdpy.dpy_texture);
- vdpy.dpy_texture = NULL;
- }
- if (vdpy.cursor_tex) {
- SDL_DestroyTexture(vdpy.cursor_tex);
- vdpy.cursor_tex = NULL;
- }
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = vdpy.vscrs + i;
+ if (vscr == NULL) {
+ continue;
+ }

- if (vdpy.egl_dmabuf_supported && (vdpy.cur_egl_img != EGL_NO_IMAGE_KHR))
- vdpy.gl_ops.eglDestroyImageKHR(vdpy.eglDisplay,
- vdpy.cur_egl_img);
+ if (vscr->img) {
+ pixman_image_unref(vscr->img);
+ vscr->img = NULL;
+ }
+ /* Continue to thread cleanup */

-sdl_fail:
+ if (vscr->surf_tex) {
+ SDL_DestroyTexture(vscr->surf_tex);
+ vscr->surf_tex = NULL;
+ }
+ if (vscr->cur_tex) {
+ SDL_DestroyTexture(vscr->cur_tex);
+ vscr->cur_tex = NULL;
+ }

- if (vdpy.dpy_renderer) {
- SDL_DestroyRenderer(vdpy.dpy_renderer);
- vdpy.dpy_renderer = NULL;
+ if (vdpy.egl_dmabuf_supported && (vscr->egl_img != EGL_NO_IMAGE_KHR))
+ vdpy.gl_ops.eglDestroyImageKHR(vdpy.eglDisplay,
+ vscr->egl_img);
}
- if (vdpy.dpy_win) {
- SDL_DestroyWindow(vdpy.dpy_win);
- vdpy.dpy_win = NULL;
+
+sdl_fail:
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = vdpy.vscrs + i;
+ if (vscr == NULL) {
+ continue;
+ }
+
+ if (vscr->renderer) {
+ SDL_DestroyRenderer(vscr->renderer);
+ vscr->renderer = NULL;
+ }
+ if (vscr->win) {
+ SDL_DestroyWindow(vscr->win);
+ vscr->win = NULL;
+ }
}

/* This is used to workaround the TLS issue of libEGL + libGLdispatch
@@ -1113,7 +1228,7 @@ vdpy_init(int *supported_wins)

vdpy.s.n_connect++;
if (supported_wins)
- *supported_wins = 1;
+ *supported_wins = vdpy.vscrs_num;
return vdpy.s.n_connect;
}

@@ -1146,6 +1261,8 @@ int
gfx_ui_init()
{
SDL_SysWMinfo info;
+ struct vscreen *vscr;
+ int i;

setenv("SDL_VIDEO_X11_FORCE_EGL", "1", 1);
setenv("SDL_OPENGL_ES_DRIVER", "1", 1);
@@ -1157,14 +1274,17 @@ gfx_ui_init()
return -1;
}

- SDL_GetDisplayBounds(vdpy.pscreen_id, &vdpy.pscreen_rect);
+ for (i = 0; i < vdpy.vscrs_num; i++) {
+ vscr = vdpy.vscrs + i;
+ SDL_GetDisplayBounds(vscr->pscreen_id, &vscr->pscreen_rect);

- if (vdpy.pscreen_rect.w < VDPY_MIN_WIDTH ||
- vdpy.pscreen_rect.h < VDPY_MIN_HEIGHT) {
- pr_err("Too small resolutions. Please check the "
- " graphics system\n");
- SDL_Quit();
- return -1;
+ if (vscr->pscreen_rect.w < VDPY_MIN_WIDTH ||
+ vscr->pscreen_rect.h < VDPY_MIN_HEIGHT) {
+ pr_err("Too small resolutions. Please check the "
+ " graphics system\n");
+ SDL_Quit();
+ return -1;
+ }
}

SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1");
@@ -1196,6 +1316,7 @@ gfx_ui_deinit()
return;
}

+ free(vdpy.vscrs);
SDL_Quit();
pr_info("SDL_Quit\r\n");
}
@@ -1204,35 +1325,41 @@ int vdpy_parse_cmd_option(const char *opts)
{
char *str;
int snum, error;
+ struct vscreen *vscr;

error = 0;
+ vdpy.vscrs = calloc(VSCREEN_MAX_NUM, sizeof(struct vscreen));
+ vdpy.vscrs_num = 0;

str = strcasestr(opts, "geometry=");
+ vscr = vdpy.vscrs + vdpy.vscrs_num;
if (opts && strcasestr(opts, "geometry=fullscreen")) {
- snum = sscanf(str, "geometry=fullscreen:%d", &vdpy.pscreen_id);
+ snum = sscanf(str, "geometry=fullscreen:%d", &vscr->pscreen_id);
if (snum != 1) {
- vdpy.pscreen_id = 0;
+ vscr->pscreen_id = 0;
}
- vdpy.width = VDPY_MAX_WIDTH;
- vdpy.height = VDPY_MAX_HEIGHT;
- vdpy.s.is_fullscreen = true;
+ vscr->width = VDPY_MAX_WIDTH;
+ vscr->height = VDPY_MAX_HEIGHT;
+ vscr->is_fullscreen = true;
+ vdpy.vscrs_num++;
pr_info("virtual display: fullscreen.\n");
} else if (opts && strcasestr(opts, "geometry=")) {
snum = sscanf(str, "geometry=%dx%d+%d+%d",
- &vdpy.width, &vdpy.height,
- &vdpy.org_x, &vdpy.org_y);
+ &vscr->width, &vscr->height,
+ &vscr->org_x, &vscr->org_y);
if (snum != 4) {
pr_err("incorrect geometry option. Should be"
" WxH+x+y\n");
error = -1;
}
- vdpy.s.is_fullscreen = false;
+ vscr->is_fullscreen = false;
+ vdpy.vscrs_num++;
pr_info("virtual display: windowed.\n");
}

- vdpy.info.xoff = 0;
- vdpy.info.yoff = 0;
- vdpy.info.width = vdpy.width;
- vdpy.info.height = vdpy.height;
+ vscr->info.xoff = 0;
+ vscr->info.yoff = 0;
+ vscr->info.width = vdpy.vscrs->width;
+ vscr->info.height = vdpy.vscrs->height;
return error;
}
--
2.25.1

From: Sun Peng <peng.p.sun@...>

To support full screen mode on one of multi-local-mornitor which
connected to SOS by monitor ID that customer specify. The monitor ID is
specified in acrn-dm's parameter like this:

virtio-gpu,geometry=fullscreen:monitor_id

For window mode, the vdisplay window always be shown on monitor 0,
because the customer can drag the window to anyone monitor. Besides, the
customer can set the monitor by x_off and y_off parameter like this:

virtio-gpu,geometry=<width>x<height>+<x_off>+<y_off>

Signed-off-by: Sun Peng <peng.p.sun@...>
---
devicemodel/hw/vdisplay_sdl.c | 43 ++++++++++++++++++++++-------------
1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/devicemodel/hw/vdisplay_sdl.c b/devicemodel/hw/vdisplay_sdl.c
index 65fd78d93..7a098f4b2 100644
--- a/devicemodel/hw/vdisplay_sdl.c
+++ b/devicemodel/hw/vdisplay_sdl.c
@@ -52,6 +52,8 @@ struct egl_display_ops {
};

static struct display {
+ int pscreen_id;
+ SDL_Rect pscreen_rect;
struct display_info info;
struct state s;
SDL_Texture *dpy_texture;
@@ -62,7 +64,6 @@ static struct display {
int width, height; // Width/height of dpy_win
int org_x, org_y;
int guest_width, guest_height;
- int screen;
struct surface surf;
struct cursor cur;
SDL_Texture *cursor_tex;
@@ -908,17 +909,23 @@ vdpy_sdl_display_thread(void *data)
uint32_t win_flags;
struct vdpy_display_bh *bh;
struct itimerspec ui_timer_spec;
+ int max_width, max_height;
+ int min_width, min_height;

+ max_width = MIN(vdpy.pscreen_rect.w, VDPY_MAX_WIDTH);
+ max_height = MIN(vdpy.pscreen_rect.h, VDPY_MAX_HEIGHT);
+ min_width = MAX(vdpy.pscreen_rect.w, VDPY_MIN_WIDTH);
+ min_height = MAX(vdpy.pscreen_rect.h, VDPY_MIN_HEIGHT);
if (vdpy.width && vdpy.height) {
/* clip the region between (640x480) and (1920x1080) */
- if (vdpy.width < VDPY_MIN_WIDTH)
- vdpy.width = VDPY_MIN_WIDTH;
- if (vdpy.width > VDPY_MAX_WIDTH)
- vdpy.width = VDPY_MAX_WIDTH;
- if (vdpy.height < VDPY_MIN_HEIGHT)
- vdpy.height = VDPY_MIN_HEIGHT;
- if (vdpy.height > VDPY_MAX_HEIGHT)
- vdpy.height = VDPY_MAX_HEIGHT;
+ if (vdpy.width < min_width)
+ vdpy.width = min_width;
+ if (vdpy.width > max_width)
+ vdpy.width = max_width;
+ if (vdpy.height < min_height)
+ vdpy.height = min_height;
+ if (vdpy.height > max_height)
+ vdpy.height = max_height;
} else {
/* the default window(1280x720) is created with undefined pos
* when no geometry info is passed
@@ -933,11 +940,13 @@ vdpy_sdl_display_thread(void *data)
SDL_WINDOW_ALWAYS_ON_TOP |
SDL_WINDOW_SHOWN;
if (vdpy.s.is_fullscreen) {
- win_flags |= SDL_WINDOW_FULLSCREEN;
+ win_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
vdpy.dpy_win = NULL;
vdpy.dpy_renderer = NULL;
vdpy.dpy_img = NULL;
+ vdpy.org_x = vdpy.pscreen_rect.x;
+ vdpy.org_y = vdpy.pscreen_rect.y;
vdpy.dpy_win = SDL_CreateWindow("ACRN_DM",
vdpy.org_x, vdpy.org_y,
vdpy.width, vdpy.height,
@@ -946,6 +955,9 @@ vdpy_sdl_display_thread(void *data)
pr_err("Failed to Create SDL_Window\n");
goto sdl_fail;
}
+ pr_info("SDL display bind to screen %d: [%d,%d,%d,%d].\n", vdpy.pscreen_id,
+ vdpy.org_x, vdpy.org_y, vdpy.width, vdpy.height);
+
vdpy.dpy_renderer = SDL_CreateRenderer(vdpy.dpy_win, -1, 0);
if (vdpy.dpy_renderer == NULL) {
pr_err("Failed to Create GL_Renderer \n");
@@ -1134,7 +1146,6 @@ int
gfx_ui_init()
{
SDL_SysWMinfo info;
- SDL_Rect disp_rect;

setenv("SDL_VIDEO_X11_FORCE_EGL", "1", 1);
setenv("SDL_OPENGL_ES_DRIVER", "1", 1);
@@ -1146,10 +1157,10 @@ gfx_ui_init()
return -1;
}

- SDL_GetDisplayBounds(0, &disp_rect);
+ SDL_GetDisplayBounds(vdpy.pscreen_id, &vdpy.pscreen_rect);

- if (disp_rect.w < VDPY_MIN_WIDTH ||
- disp_rect.h < VDPY_MIN_HEIGHT) {
+ if (vdpy.pscreen_rect.w < VDPY_MIN_WIDTH ||
+ vdpy.pscreen_rect.h < VDPY_MIN_HEIGHT) {
pr_err("Too small resolutions. Please check the "
" graphics system\n");
SDL_Quit();
@@ -1198,9 +1209,9 @@ int vdpy_parse_cmd_option(const char *opts)

str = strcasestr(opts, "geometry=");
if (opts && strcasestr(opts, "geometry=fullscreen")) {
- snum = sscanf(str, "geometry=fullscreen:%d", &vdpy.screen);
+ snum = sscanf(str, "geometry=fullscreen:%d", &vdpy.pscreen_id);
if (snum != 1) {
- vdpy.screen = 0;
+ vdpy.pscreen_id = 0;
}
vdpy.width = VDPY_MAX_WIDTH;
vdpy.height = VDPY_MAX_HEIGHT;
--
2.25.1

Acked-by: Eddie Dong <eddie.dong@...>

On 8/5/2022 11:19 PM, Junjie Mao wrote:

Chenli Wei <chenli.wei@...> writes:

From: Chenli Wei <chenli.wei@...>

The current ACRN-Configurator just check the conflict of user setting.
have not check the conflict with native PCI device's bdf.

This patch add an assert to check the above conflict.

Tracked-On: #6690
Signed-off-by: Chenli Wei <chenli.wei@...>
---
misc/config_tools/schema/checks/vbdf_assignment.xsd | 10 ++++++++++
1 file changed, 10 insertions(+)

diff --git a/misc/config_tools/schema/checks/vbdf_assignment.xsd b/misc/config_tools/schema/checks/vbdf_assignment.xsd
index fde14c2b7..062b0fe67 100644
--- a/misc/config_tools/schema/checks/vbdf_assignment.xsd
+++ b/misc/config_tools/schema/checks/vbdf_assignment.xsd
@@ -14,4 +14,14 @@
</xs:annotation>
</xs:assert>
+
+ <xs:assert test="every $root in /acrn-config satisfies
+ every $vm in $root/vm satisfies
+ every $vbdf in $root/hv//vuart_connection[type='pci']/endpoint[vm_name=$vm/name]/vbdf/text() | $root/hv//IVSHMEM_VM[VM_NAME=$vm/name]/VBDF/text() satisfies

Shall we check only the BDFs of ivshmem/vUART devices for the service
VM? To other VMs the BDFs are generated by the config tools which should
be able to avoid BDF collision.

BTW, please do not mix white spaces and tabs.

I thinks the pre-launched VM's vBDF setting should also be checked if we don't check every VM.

"Zhou, Wu" <wu.zhou@...> writes:

Some configurator settings are defined as 'feature DISABLED' style,
which could cause confusion to developers. This patch set is to change
them into straightforward 'ENABLED' style.

Including:
- MCE_ON_PSC_DISABLED -> MCE_ON_PSC_ENABLED
- ENFORCE_TURNOFF_AC -> AC_ENABLED
- ENFORCE_TURNOFF_GP -> GP_ENABLED

The names "AC_ENABLED" and "GP_ENABLED" are quite vague as AC and GP are
names of exceptions and it is not straightforward to say what it means
to enable them.

How about:

ENFORCE_TURNOFF_AC -> SPLIT_LOCK_DETECTION_ENABLED
ENFORCE_TURNOFF_GP -> UC_LOCK_DETECTION_ENABLED

With the change of configurator settings, the scenario data files and
doc files are changed accordingly.
MACROs generated by config-tools are changed to 'CONFIG_xxx_ENABLED' too.


Tracked-On: #7661

Signed-off-by: Wu Zhou <wu.zhou@...>

Wu Zhou (4):
config-tools: change 'DISABLED' settings to 'ENABLED'
doc: change 'DISABLED' settings to 'ENABLED'
config-tools: change 'DISABLED' settings to 'ENABLED' in config xml
hv: change 'DISABLED' settings to 'ENABLED'

doc/developer-guides/hld/hld-splitlock.rst | 2 +-
doc/tutorials/rtvm_performance_tips.rst | 2 +-
hypervisor/arch/x86/cpu.c | 8 ++++----
hypervisor/arch/x86/security.c | 2 +-
.../cfl-k700-i7/hybrid_launch_2user_vm.xml | 6 +++---
.../data/cfl-k700-i7/hybrid_rt.xml | 6 +++---
.../data/cfl-k700-i7/partitioned.xml | 6 +++---
.../cfl-k700-i7/shared_launch_6user_vm.xml | 6 +++---
.../generic_board/hybrid_launch_2user_vm.xml | 6 +++---
.../data/generic_board/hybrid_rt.xml | 4 ++--
.../data/generic_board/partitioned.xml | 6 +++---
.../generic_board/shared_launch_2user_vm.xml | 6 +++---
.../data/nuc11tnbi5/hybrid_launch_2user_vm.xml | 6 +++---
.../data/nuc11tnbi5/partitioned.xml | 6 +++---
.../data/nuc11tnbi5/shared_launch_6user_vm.xml | 6 +++---
misc/config_tools/data/qemu/shared.xml | 6 +++---
.../data/tgl-vecow-spc-7100-Corei7/hybrid.xml | 6 +++---
.../tgl-vecow-spc-7100-Corei7/partitioned.xml | 6 +++---
.../shared_launch_2user_vm.xml | 6 +++---
misc/config_tools/data/whl-ipc-i5/hybrid.xml | 6 +++---
.../hybrid_rt_launch_1user_vm_waag.xml | 6 +++---
.../data/whl-ipc-i5/partitioned.xml | 6 +++---
.../shared_launch_1user_vm_hardrt.xml | 6 +++---
.../shared_launch_1user_vm_vxworks.xml | 6 +++---
.../whl-ipc-i5/shared_launch_1user_vm_waag.xml | 6 +++---
.../data/whl-ipc-i5/shared_launch_2user_vm.xml | 6 +++---
.../data/whl-ipc-i5/shared_launch_6user_vm.xml | 6 +++---
misc/config_tools/schema/config.xsd | 18 +++++++++---------
misc/config_tools/xforms/config_common.xsl | 8 ++++----
29 files changed, 88 insertions(+), 88 deletions(-)

Please also update the
misc/config_tools/scenario_config/upgrader.py. Users will use that to
upgrade there scenario XMLs when future releases are out.

You can also update the existing XMLs by using that script.

--
Best Regards
Junjie Mao

Kunhui-Li <kunhuix.li@...> writes:

add escape charater to fix vBDF pattern match any character issue
for vUART and ivshmem.

Tracked-On: #7925
Signed-off-by: Kunhui-Li <kunhuix.li@...>

Reviewed-by: Junjie Mao <junjie.mao@...>

--
Best Regards
Junjie Mao

---
misc/config_tools/schema/types.xsd | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/config_tools/schema/types.xsd b/misc/config_tools/schema/types.xsd
index 4aa4c5cbc..1ebaeb8bf 100644
--- a/misc/config_tools/schema/types.xsd
+++ b/misc/config_tools/schema/types.xsd
@@ -182,7 +182,7 @@ Read more about the available scheduling options in :ref:`cpu_sharing`.</xs:docu
<xs:documentation>A string with up to two hex digits, a ``:``, two hex digits, a ``.``, and one digit between 0-7.</xs:documentation>
</xs:annotation>
<xs:restriction base="xs:string">
- <xs:pattern value="[0-9A-Fa-f]{1,2}:[0-1][0-9A-Fa-f].[0-7]" />
+ <xs:pattern value="[0-9A-Fa-f]{1,2}:[0-1][0-9A-Fa-f]\.[0-7]" />
</xs:restriction>
</xs:simpleType>

Chenli Wei <chenli.wei@...> writes:

From: Chenli Wei <chenli.wei@...>

The current ACRN-Configurator just check the conflict of user setting.
have not check the conflict with native PCI device's bdf.

This patch add an assert to check the above conflict.

Tracked-On: #6690
Signed-off-by: Chenli Wei <chenli.wei@...>
---
misc/config_tools/schema/checks/vbdf_assignment.xsd | 10 ++++++++++
1 file changed, 10 insertions(+)

diff --git a/misc/config_tools/schema/checks/vbdf_assignment.xsd b/misc/config_tools/schema/checks/vbdf_assignment.xsd
index fde14c2b7..062b0fe67 100644
--- a/misc/config_tools/schema/checks/vbdf_assignment.xsd
+++ b/misc/config_tools/schema/checks/vbdf_assignment.xsd
@@ -14,4 +14,14 @@
</xs:annotation>
</xs:assert>

+
+ <xs:assert test="every $root in /acrn-config satisfies
+ every $vm in $root/vm satisfies
+ every $vbdf in $root/hv//vuart_connection[type='pci']/endpoint[vm_name=$vm/name]/vbdf/text() | $root/hv//IVSHMEM_VM[VM_NAME=$vm/name]/VBDF/text() satisfies

Shall we check only the BDFs of ivshmem/vUART devices for the service
VM? To other VMs the BDFs are generated by the config tools which should
be able to avoid BDF collision.

BTW, please do not mix white spaces and tabs.

--
Best Regards
Junjie Mao

+ string-length(substring-after(/acrn-config//PCI_DEVICE/text(), $vbdf)) = 0">
+ <xs:annotation acrn:severity="error" acrn:report-on="$root/hv//vuart_connection[type='pci']/endpoint[vm_name=$vm/name and vbdf=$vbdf] | $root/hv//IVSHMEM_VM[VM_NAME=$vm/name and VBDF=$vbdf]">
+ <xs:documentation>VM "{$vm/name}" virtual UART controllers or IVSHMEM interfaces using BDF {$vbdf} conflict with native PCI device. Adjust the BDF of those devices to be unique.</xs:documentation>
+ </xs:annotation>
+ </xs:assert>
+
</xs:schema>

Chuang Ke <chuangx.ke@...> writes:

Tool doesn't generate I/O address. User needs to save twice, then the tool generates I/O address.
I change the save function into async function， and improved the promise chaining， now it can be responsible in time，and success generate in InterVM shared memory region， PCI and BDF.

Signed-off-by: Chuang-Ke <chuangx.ke@...>

Reviewed-by: Junjie Mao <junjie.mao@...>

One minor coding style issue below.

Tracked-On: #7942
---
.../packages/configurator/src/pages/Config.vue | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/misc/config_tools/configurator/packages/configurator/src/pages/Config.vue b/misc/config_tools/configurator/packages/configurator/src/pages/Config.vue
index 55e5c6ed7..6bfe1a788 100644
--- a/misc/config_tools/configurator/packages/configurator/src/pages/Config.vue
+++ b/misc/config_tools/configurator/packages/configurator/src/pages/Config.vue
@@ -415,7 +415,7 @@ export default {

return formErrors
},
- saveScenario() {
+ async saveScenario() {

Mind the indentation.

--
Best Regards
Junjie Mao

if (_.isEmpty(this.scenario.vm)) {
alert("Please add at least one VM")
return
@@ -425,7 +425,7 @@ export default {
if (errorFlag) {
return
}
- this.assignVMID()
+ await this.assignVMID()
let msg = [
"scenario xml saved\n",
"Settings validated\n",
@@ -442,10 +442,9 @@ export default {

this.scenario.hv.CACHE_REGION = configurator.cat.getScenarioDataFromCAT()

- let scenarioWithDefaults = this.applyScenarioDefaults(this.scenario)
+ let scenarioWithDefaults = await this.applyScenarioDefaults(this.scenario)
let scenarioXMLData = this.scenarioToXML(scenarioWithDefaults)
this.scenario = scenarioWithDefaults
- this.updateCurrentFormData()

this.scenario.vm.map((vmConfig) => {
if (vmConfig['load_order'] === 'POST_LAUNCHED_VM') {
@@ -458,6 +457,7 @@ export default {
// begin write down and verify

configurator.writeFile(this.WorkingFolder + 'scenario.xml', scenarioXMLData)
+ .then(() => {this.updateCurrentFormData()})
.then(() => {
// validate scenario and clean up the launch script
stepDone = 1

add escape charater to fix vBDF pattern match any character issue
for vUART and ivshmem.

Tracked-On: #7925
Signed-off-by: Kunhui-Li <kunhuix.li@...>
---
misc/config_tools/schema/types.xsd | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/config_tools/schema/types.xsd b/misc/config_tools/schema/types.xsd
index 4aa4c5cbc..1ebaeb8bf 100644
--- a/misc/config_tools/schema/types.xsd
+++ b/misc/config_tools/schema/types.xsd
@@ -182,7 +182,7 @@ Read more about the available scheduling options in :ref:`cpu_sharing`.</xs:docu
<xs:documentation>A string with up to two hex digits, a ``:``, two hex digits, a ``.``, and one digit between 0-7.</xs:documentation>
</xs:annotation>
<xs:restriction base="xs:string">
- <xs:pattern value="[0-9A-Fa-f]{1,2}:[0-1][0-9A-Fa-f].[0-7]" />
+ <xs:pattern value="[0-9A-Fa-f]{1,2}:[0-1][0-9A-Fa-f]\.[0-7]" />
</xs:restriction>
</xs:simpleType>

--
2.25.1