[WIP] Implement cursor plane rendering for VirtIO GPU

Author: shengwen-tw

virtio-gpu.c

@@ -49,6 +49,7 @@ struct vgpu_resource_2d {
     uint32_t stride;
     uint32_t bits_per_pixel;
     uint32_t *image;
+    bool scanout_attached;
     /* Private: */
     uint32_t resource_id;
     size_t page_cnt;
@@ -169,6 +170,22 @@ PACKED(struct virtio_gpu_ctx_create {
     char debug_name[64];
 });
 
+PACKED(struct virtio_gpu_cursor_pos {
+    uint32_t scanout_id;
+    uint32_t x;
+    uint32_t y;
+    uint32_t padding;
+});
+
+PACKED(struct virtio_gpu_update_cursor {
+    struct vgpu_ctrl_hdr hdr;
+    struct virtio_gpu_cursor_pos pos;
+    uint32_t resource_id;
+    uint32_t hot_x;
+    uint32_t hot_y;
+    uint32_t padding;
+});
+
 /* clang-format off */
 PACKED(struct virtio_gpu_ctx_destroy {
     struct vgpu_ctrl_hdr hdr;
@@ -244,6 +261,7 @@ static struct vgpu_resource_2d *create_vgpu_resource_2d(int resource_id)
         return NULL;
 
     res->resource_id = resource_id;
+    res->scanout_attached = false;
     list_add(&res->list, &vgpu_res_2d_list);
     return res;
 }
@@ -267,15 +285,18 @@ static int destroy_vgpu_resource_2d(uint32_t resource_id)
     if (!res_2d)
         return -1;
 
-    window_lock(resource_id);
+    int scanout_id = res_2d->scanout_id;
+    if (res_2d->scanout_attached)
+        window_lock(scanout_id);
 
     /* Release the resource */
     free(res_2d->image);
     list_del(&res_2d->list);
     free(res_2d->iovec);
     free(res_2d);
 
-    window_unlock(resource_id);
+    if (res_2d->scanout_attached)
+        window_unlock(scanout_id);
 
     return 0;
 }
@@ -629,9 +650,11 @@ static void virtio_gpu_cmd_set_scanout_handler(virtio_gpu_state_t *vgpu,
 
     /* Linux's virtio-gpu driver may send scanout command
      * even if the resource does not exist */
-    if (res_2d)
+    if (res_2d) {
         /* Set scanout ID to proper 2D resource */
         res_2d->scanout_id = request->scanout_id;
+        res_2d->scanout_attached = true;
+    }
 
     /* Write response */
     struct vgpu_ctrl_hdr *response =
@@ -657,7 +680,9 @@ static void virtio_gpu_cmd_resource_flush_handler(virtio_gpu_state_t *vgpu,
         acquire_vgpu_resource_2d(request->resource_id);
 
     /* Trigger display window rendering */
+    window_lock(res_2d->scanout_id);
     window_render((struct gpu_resource *) res_2d);
+    window_unlock(res_2d->scanout_id);
 
     /* Write response */
     struct vgpu_ctrl_hdr *response =
@@ -670,36 +695,9 @@ static void virtio_gpu_cmd_resource_flush_handler(virtio_gpu_state_t *vgpu,
     *plen = sizeof(*response);
 }
 
-static void virtio_gpu_cmd_transfer_to_host_2d_handler(
-    virtio_gpu_state_t *vgpu,
-    struct virtq_desc *vq_desc,
-    uint32_t *plen)
+static void virtio_gpu_copy_image_from_pages(struct vgpu_trans_to_host_2d *req,
+                                             struct vgpu_resource_2d *res_2d)
 {
-    /* Read request */
-    struct vgpu_trans_to_host_2d *req =
-        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
-
-    /* Acquire 2D resource */
-    struct vgpu_resource_2d *res_2d =
-        acquire_vgpu_resource_2d(req->resource_id);
-
-    if (!res_2d) {
-        fprintf(stderr, "%s(): Failed to find 2D resource\n", __func__);
-        virtio_gpu_set_fail(vgpu);
-        return;
-    }
-
-    /* Check image boundary */
-    if (req->r.x > res_2d->width || req->r.y > res_2d->height ||
-        req->r.width > res_2d->width || req->r.height > res_2d->height ||
-        req->r.x + req->r.width > res_2d->width ||
-        req->r.y + req->r.height > res_2d->height) {
-        fprintf(stderr, "%s(): Invalid image size\n", __func__);
-        virtio_gpu_set_fail(vgpu);
-        return;
-    }
-
-    /* Transfer frame data from guest to host */
     uint32_t stride = res_2d->stride;
     uint32_t bpp = res_2d->bits_per_pixel / 8; /* Bytes per pixel */
     uint32_t width =
@@ -752,6 +750,54 @@ static void virtio_gpu_cmd_transfer_to_host_2d_handler(
             }
         }
     }
+}
+
+static void virtio_gpu_cursor_image_copy(struct vgpu_resource_2d *res_2d)
+{
+    /* The cursor resource is tightly packed and contiguous */
+    memcpy(res_2d->image, res_2d->iovec[0].iov_base,
+           sizeof(uint32_t) * CURSOR_WIDTH * CURSOR_HEIGHT);
+}
+
+static void virtio_gpu_cmd_transfer_to_host_2d_handler(
+    virtio_gpu_state_t *vgpu,
+    struct virtq_desc *vq_desc,
+    uint32_t *plen)
+{
+    /* Read request */
+    struct vgpu_trans_to_host_2d *req =
+        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
+
+    /* Acquire 2D resource */
+    struct vgpu_resource_2d *res_2d =
+        acquire_vgpu_resource_2d(req->resource_id);
+
+    if (!res_2d) {
+        fprintf(stderr, "%s(): Failed to find 2D resource\n", __func__);
+        virtio_gpu_set_fail(vgpu);
+        return;
+    }
+
+    /* Check image boundary */
+    if (req->r.x > res_2d->width || req->r.y > res_2d->height ||
+        req->r.width > res_2d->width || req->r.height > res_2d->height ||
+        req->r.x + req->r.width > res_2d->width ||
+        req->r.y + req->r.height > res_2d->height) {
+        fprintf(stderr, "%s(): Invalid image size\n", __func__);
+        virtio_gpu_set_fail(vgpu);
+        return;
+    }
+
+    uint32_t width =
+        (req->r.width < res_2d->width) ? req->r.width : res_2d->width;
+    uint32_t height =
+        (req->r.height < res_2d->height) ? req->r.height : res_2d->height;
+
+    /* Transfer frame data from guest to host */
+    if (width == CURSOR_WIDTH && height == CURSOR_HEIGHT)
+        virtio_gpu_cursor_image_copy(res_2d);
+    else
+        virtio_gpu_copy_image_from_pages(req, res_2d);
 
     /* Write response */
     struct vgpu_ctrl_hdr *response =
@@ -819,6 +865,27 @@ static void virtio_gpu_cmd_update_cursor_handler(virtio_gpu_state_t *vgpu,
                                                  struct virtq_desc *vq_desc,
                                                  uint32_t *plen)
 {
+    /* Read request */
+    struct virtio_gpu_update_cursor *cursor =
+        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
+
+    /* Update cursor image */
+    struct vgpu_resource_2d *res_2d =
+        acquire_vgpu_resource_2d(cursor->resource_id);
+
+    if (res_2d != NULL) {
+        window_lock(cursor->pos.scanout_id);
+        cursor_update((struct gpu_resource *) res_2d, cursor->pos.scanout_id,
+                      cursor->pos.x, cursor->pos.y);
+        window_unlock(cursor->pos.scanout_id);
+    } else if (cursor->resource_id == 0) {
+        window_lock(cursor->pos.scanout_id);
+        cursor_clear(cursor->pos.scanout_id);
+        window_unlock(cursor->pos.scanout_id);
+    } else {
+        fprintf(stderr, "Invalid resource ID %d.\n", cursor->resource_id);
+    }
+
     /* Write response */
     struct vgpu_ctrl_hdr *response =
         vgpu_mem_host_to_guest(vgpu, vq_desc[1].addr);
@@ -834,6 +901,15 @@ static void virtio_gpu_cmd_move_cursor_handler(virtio_gpu_state_t *vgpu,
                                                struct virtq_desc *vq_desc,
                                                uint32_t *plen)
 {
+    /* Read request */
+    struct virtio_gpu_update_cursor *cursor =
+        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
+
+    /* Move cursor to new position */
+    window_lock(cursor->pos.scanout_id);
+    cursor_move(cursor->pos.scanout_id, cursor->pos.x, cursor->pos.y);
+    window_unlock(cursor->pos.scanout_id);
+
     /* Write response */
     struct vgpu_ctrl_hdr *response =
         vgpu_mem_host_to_guest(vgpu, vq_desc[1].addr);