From 2db720330b877d4cd5e6c54024df80d59726e119 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Thu, 22 Apr 2021 15:30:38 -0700 Subject: [PATCH] venus: move vn_renderer_bo_ops to vn_renderer Signed-off-by: Chia-I Wu Reviewed-by: Yiwei Zhang Part-of: --- src/virtio/vulkan/vn_renderer.h | 99 +++++++++++++------------ src/virtio/vulkan/vn_renderer_virtgpu.c | 78 +++++++++---------- src/virtio/vulkan/vn_renderer_vtest.c | 80 ++++++++++---------- 3 files changed, 130 insertions(+), 127 deletions(-) diff --git a/src/virtio/vulkan/vn_renderer.h b/src/virtio/vulkan/vn_renderer.h index 2016ce7a661..4596321ff53 100644 --- a/src/virtio/vulkan/vn_renderer.h +++ b/src/virtio/vulkan/vn_renderer.h @@ -15,42 +15,9 @@ struct vn_renderer_shmem { void *mmap_ptr; }; -struct vn_renderer_bo_ops { - void (*destroy)(struct vn_renderer_bo *bo); - - /* import a VkDeviceMemory as the storage */ - VkResult (*init_gpu)(struct vn_renderer_bo *bo, - VkDeviceSize size, - vn_object_id mem_id, - VkMemoryPropertyFlags flags, - VkExternalMemoryHandleTypeFlags external_handles); - - /* import a dmabuf as the storage */ - VkResult (*init_dmabuf)(struct vn_renderer_bo *bo, - VkDeviceSize size, - int fd, - VkMemoryPropertyFlags flags, - VkExternalMemoryHandleTypeFlags external_handles); - - int (*export_dmabuf)(struct vn_renderer_bo *bo); - - /* map is not thread-safe */ - void *(*map)(struct vn_renderer_bo *bo); - - void (*flush)(struct vn_renderer_bo *bo, - VkDeviceSize offset, - VkDeviceSize size); - void (*invalidate)(struct vn_renderer_bo *bo, - VkDeviceSize offset, - VkDeviceSize size); -}; - struct vn_renderer_bo { atomic_int refcount; - uint32_t res_id; - - struct vn_renderer_bo_ops ops; }; enum vn_renderer_sync_flags { @@ -191,8 +158,6 @@ struct vn_renderer_ops { VkResult (*wait)(struct vn_renderer *renderer, const struct vn_renderer_wait *wait); - struct vn_renderer_bo *(*bo_create)(struct vn_renderer *renderer); - struct vn_renderer_sync *(*sync_create)(struct vn_renderer *renderer); }; @@ -203,9 +168,47 @@ struct vn_renderer_shmem_ops { struct vn_renderer_shmem *shmem); }; +struct vn_renderer_bo_ops { + struct vn_renderer_bo *(*create)(struct vn_renderer *renderer); + + /* import a VkDeviceMemory as the storage */ + VkResult (*init_gpu)(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, + VkDeviceSize size, + vn_object_id mem_id, + VkMemoryPropertyFlags flags, + VkExternalMemoryHandleTypeFlags external_handles); + + /* import a dmabuf as the storage */ + VkResult (*init_dmabuf)(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, + VkDeviceSize size, + int fd, + VkMemoryPropertyFlags flags, + VkExternalMemoryHandleTypeFlags external_handles); + + void (*destroy)(struct vn_renderer *renderer, struct vn_renderer_bo *bo); + + int (*export_dmabuf)(struct vn_renderer *renderer, + struct vn_renderer_bo *bo); + + /* map is not thread-safe */ + void *(*map)(struct vn_renderer *renderer, struct vn_renderer_bo *bo); + + void (*flush)(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, + VkDeviceSize offset, + VkDeviceSize size); + void (*invalidate)(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, + VkDeviceSize offset, + VkDeviceSize size); +}; + struct vn_renderer { struct vn_renderer_ops ops; struct vn_renderer_shmem_ops shmem_ops; + struct vn_renderer_bo_ops bo_ops; }; VkResult @@ -324,14 +327,14 @@ vn_renderer_bo_create_gpu(struct vn_renderer *renderer, VkExternalMemoryHandleTypeFlags external_handles, struct vn_renderer_bo **_bo) { - struct vn_renderer_bo *bo = renderer->ops.bo_create(renderer); + struct vn_renderer_bo *bo = renderer->bo_ops.create(renderer); if (!bo) return VK_ERROR_OUT_OF_HOST_MEMORY; - VkResult result = - bo->ops.init_gpu(bo, size, mem_id, flags, external_handles); + VkResult result = renderer->bo_ops.init_gpu(renderer, bo, size, mem_id, + flags, external_handles); if (result != VK_SUCCESS) { - bo->ops.destroy(bo); + renderer->bo_ops.destroy(renderer, bo); return result; } @@ -349,14 +352,14 @@ vn_renderer_bo_create_dmabuf(struct vn_renderer *renderer, VkExternalMemoryHandleTypeFlags external_handles, struct vn_renderer_bo **_bo) { - struct vn_renderer_bo *bo = renderer->ops.bo_create(renderer); + struct vn_renderer_bo *bo = renderer->bo_ops.create(renderer); if (!bo) return VK_ERROR_OUT_OF_HOST_MEMORY; - VkResult result = - bo->ops.init_dmabuf(bo, size, fd, flags, external_handles); + VkResult result = renderer->bo_ops.init_dmabuf(renderer, bo, size, fd, + flags, external_handles); if (result != VK_SUCCESS) { - bo->ops.destroy(bo); + renderer->bo_ops.destroy(renderer, bo); return result; } @@ -385,7 +388,7 @@ vn_renderer_bo_unref(struct vn_renderer *renderer, struct vn_renderer_bo *bo) if (old == 1) { atomic_thread_fence(memory_order_acquire); - bo->ops.destroy(bo); + renderer->bo_ops.destroy(renderer, bo); return true; } @@ -396,13 +399,13 @@ static inline int vn_renderer_bo_export_dmabuf(struct vn_renderer *renderer, struct vn_renderer_bo *bo) { - return bo->ops.export_dmabuf(bo); + return renderer->bo_ops.export_dmabuf(renderer, bo); } static inline void * vn_renderer_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *bo) { - return bo->ops.map(bo); + return renderer->bo_ops.map(renderer, bo); } static inline void @@ -411,7 +414,7 @@ vn_renderer_bo_flush(struct vn_renderer *renderer, VkDeviceSize offset, VkDeviceSize end) { - bo->ops.flush(bo, offset, end); + renderer->bo_ops.flush(renderer, bo, offset, end); } static inline void @@ -420,7 +423,7 @@ vn_renderer_bo_invalidate(struct vn_renderer *renderer, VkDeviceSize offset, VkDeviceSize size) { - bo->ops.invalidate(bo, offset, size); + renderer->bo_ops.invalidate(renderer, bo, offset, size); } static inline VkResult diff --git a/src/virtio/vulkan/vn_renderer_virtgpu.c b/src/virtio/vulkan/vn_renderer_virtgpu.c index 8b201b52cb7..b52a42c5d78 100644 --- a/src/virtio/vulkan/vn_renderer_virtgpu.c +++ b/src/virtio/vulkan/vn_renderer_virtgpu.c @@ -59,7 +59,6 @@ struct virtgpu_shmem { struct virtgpu_bo { struct vn_renderer_bo base; - struct virtgpu *gpu; uint32_t blob_flags; VkDeviceSize size; @@ -1054,7 +1053,8 @@ virtgpu_sync_create(struct vn_renderer *renderer) } static void -virtgpu_bo_invalidate(struct vn_renderer_bo *bo, +virtgpu_bo_invalidate(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, VkDeviceSize offset, VkDeviceSize size) { @@ -1062,7 +1062,8 @@ virtgpu_bo_invalidate(struct vn_renderer_bo *bo, } static void -virtgpu_bo_flush(struct vn_renderer_bo *bo, +virtgpu_bo_flush(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, VkDeviceSize offset, VkDeviceSize size) { @@ -1070,10 +1071,10 @@ virtgpu_bo_flush(struct vn_renderer_bo *bo, } static void * -virtgpu_bo_map(struct vn_renderer_bo *_bo) +virtgpu_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *_bo) { + struct virtgpu *gpu = (struct virtgpu *)renderer; struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; - struct virtgpu *gpu = bo->gpu; const bool mappable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_MAPPABLE; /* not thread-safe but is fine */ @@ -1084,10 +1085,11 @@ virtgpu_bo_map(struct vn_renderer_bo *_bo) } static int -virtgpu_bo_export_dmabuf(struct vn_renderer_bo *_bo) +virtgpu_bo_export_dmabuf(struct vn_renderer *renderer, + struct vn_renderer_bo *_bo) { + struct virtgpu *gpu = (struct virtgpu *)renderer; struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; - struct virtgpu *gpu = bo->gpu; const bool mappable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_MAPPABLE; const bool shareable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_SHAREABLE; @@ -1096,6 +1098,21 @@ virtgpu_bo_export_dmabuf(struct vn_renderer_bo *_bo) : -1; } +static void +virtgpu_bo_destroy(struct vn_renderer *renderer, struct vn_renderer_bo *_bo) +{ + struct virtgpu *gpu = (struct virtgpu *)renderer; + struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; + + if (bo->gem_handle) { + if (bo->gem_ptr) + munmap(bo->gem_ptr, bo->size); + virtgpu_ioctl_gem_close(gpu, bo->gem_handle); + } + + free(bo); +} + static uint32_t virtgpu_bo_blob_flags(VkMemoryPropertyFlags flags, VkExternalMemoryHandleTypeFlags external_handles) @@ -1112,14 +1129,15 @@ virtgpu_bo_blob_flags(VkMemoryPropertyFlags flags, } static VkResult -virtgpu_bo_init_dmabuf(struct vn_renderer_bo *_bo, +virtgpu_bo_init_dmabuf(struct vn_renderer *renderer, + struct vn_renderer_bo *_bo, VkDeviceSize size, int fd, VkMemoryPropertyFlags flags, VkExternalMemoryHandleTypeFlags external_handles) { + struct virtgpu *gpu = (struct virtgpu *)renderer; struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; - struct virtgpu *gpu = bo->gpu; struct drm_virtgpu_resource_info info; uint32_t gem_handle = 0; @@ -1161,14 +1179,15 @@ fail: } static VkResult -virtgpu_bo_init_gpu(struct vn_renderer_bo *_bo, +virtgpu_bo_init_gpu(struct vn_renderer *renderer, + struct vn_renderer_bo *_bo, VkDeviceSize size, vn_object_id mem_id, VkMemoryPropertyFlags flags, VkExternalMemoryHandleTypeFlags external_handles) { + struct virtgpu *gpu = (struct virtgpu *)renderer; struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; - struct virtgpu *gpu = bo->gpu; bo->blob_flags = virtgpu_bo_blob_flags(flags, external_handles); bo->size = size; @@ -1181,40 +1200,13 @@ virtgpu_bo_init_gpu(struct vn_renderer_bo *_bo, return bo->gem_handle ? VK_SUCCESS : VK_ERROR_OUT_OF_DEVICE_MEMORY; } -static void -virtgpu_bo_destroy(struct vn_renderer_bo *_bo) -{ - struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo; - struct virtgpu *gpu = bo->gpu; - - if (bo->gem_handle) { - if (bo->gem_ptr) - munmap(bo->gem_ptr, bo->size); - virtgpu_ioctl_gem_close(gpu, bo->gem_handle); - } - - free(bo); -} - static struct vn_renderer_bo * virtgpu_bo_create(struct vn_renderer *renderer) { - struct virtgpu *gpu = (struct virtgpu *)renderer; - struct virtgpu_bo *bo = calloc(1, sizeof(*bo)); if (!bo) return NULL; - bo->gpu = gpu; - - bo->base.ops.destroy = virtgpu_bo_destroy; - bo->base.ops.init_gpu = virtgpu_bo_init_gpu; - bo->base.ops.init_dmabuf = virtgpu_bo_init_dmabuf; - bo->base.ops.export_dmabuf = virtgpu_bo_export_dmabuf; - bo->base.ops.map = virtgpu_bo_map; - bo->base.ops.flush = virtgpu_bo_flush; - bo->base.ops.invalidate = virtgpu_bo_invalidate; - return &bo->base; } @@ -1505,12 +1497,20 @@ virtgpu_init(struct virtgpu *gpu) gpu->base.ops.get_info = virtgpu_get_info; gpu->base.ops.submit = virtgpu_submit; gpu->base.ops.wait = virtgpu_wait; - gpu->base.ops.bo_create = virtgpu_bo_create; gpu->base.ops.sync_create = virtgpu_sync_create; gpu->base.shmem_ops.create = virtgpu_shmem_create; gpu->base.shmem_ops.destroy = virtgpu_shmem_destroy; + gpu->base.bo_ops.create = virtgpu_bo_create; + gpu->base.bo_ops.init_gpu = virtgpu_bo_init_gpu; + gpu->base.bo_ops.init_dmabuf = virtgpu_bo_init_dmabuf; + gpu->base.bo_ops.destroy = virtgpu_bo_destroy; + gpu->base.bo_ops.export_dmabuf = virtgpu_bo_export_dmabuf; + gpu->base.bo_ops.map = virtgpu_bo_map; + gpu->base.bo_ops.flush = virtgpu_bo_flush; + gpu->base.bo_ops.invalidate = virtgpu_bo_invalidate; + return VK_SUCCESS; } diff --git a/src/virtio/vulkan/vn_renderer_vtest.c b/src/virtio/vulkan/vn_renderer_vtest.c index 26e6f8ecd3f..663688ac842 100644 --- a/src/virtio/vulkan/vn_renderer_vtest.c +++ b/src/virtio/vulkan/vn_renderer_vtest.c @@ -35,7 +35,6 @@ struct vtest_shmem { struct vtest_bo { struct vn_renderer_bo base; - struct vtest *vtest; uint32_t blob_flags; VkDeviceSize size; @@ -673,7 +672,8 @@ vtest_sync_create(struct vn_renderer *renderer) } static void -vtest_bo_invalidate(struct vn_renderer_bo *bo, +vtest_bo_invalidate(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, VkDeviceSize offset, VkDeviceSize size) { @@ -681,7 +681,8 @@ vtest_bo_invalidate(struct vn_renderer_bo *bo, } static void -vtest_bo_flush(struct vn_renderer_bo *bo, +vtest_bo_flush(struct vn_renderer *renderer, + struct vn_renderer_bo *bo, VkDeviceSize offset, VkDeviceSize size) { @@ -689,10 +690,10 @@ vtest_bo_flush(struct vn_renderer_bo *bo, } static void * -vtest_bo_map(struct vn_renderer_bo *_bo) +vtest_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *_bo) { + struct vtest *vtest = (struct vtest *)renderer; struct vtest_bo *bo = (struct vtest_bo *)_bo; - struct vtest *vtest = bo->vtest; const bool mappable = bo->blob_flags & VCMD_BLOB_FLAG_MAPPABLE; const bool shareable = bo->blob_flags & VCMD_BLOB_FLAG_SHAREABLE; @@ -723,13 +724,34 @@ vtest_bo_map(struct vn_renderer_bo *_bo) } static int -vtest_bo_export_dmabuf(struct vn_renderer_bo *_bo) +vtest_bo_export_dmabuf(struct vn_renderer *renderer, + struct vn_renderer_bo *_bo) { const struct vtest_bo *bo = (struct vtest_bo *)_bo; const bool shareable = bo->blob_flags & VCMD_BLOB_FLAG_SHAREABLE; return shareable ? os_dupfd_cloexec(bo->res_fd) : -1; } +static void +vtest_bo_destroy(struct vn_renderer *renderer, struct vn_renderer_bo *_bo) +{ + struct vtest *vtest = (struct vtest *)renderer; + struct vtest_bo *bo = (struct vtest_bo *)_bo; + + if (bo->base.res_id) { + if (bo->res_ptr) + munmap(bo->res_ptr, bo->size); + if (bo->res_fd >= 0) + close(bo->res_fd); + + mtx_lock(&vtest->sock_mutex); + vtest_vcmd_resource_unref(vtest, bo->base.res_id); + mtx_unlock(&vtest->sock_mutex); + } + + free(bo); +} + static uint32_t vtest_bo_blob_flags(VkMemoryPropertyFlags flags, VkExternalMemoryHandleTypeFlags external_handles) @@ -746,14 +768,15 @@ vtest_bo_blob_flags(VkMemoryPropertyFlags flags, } static VkResult -vtest_bo_init_gpu(struct vn_renderer_bo *_bo, +vtest_bo_init_gpu(struct vn_renderer *renderer, + struct vn_renderer_bo *_bo, VkDeviceSize size, vn_object_id mem_id, VkMemoryPropertyFlags flags, VkExternalMemoryHandleTypeFlags external_handles) { + struct vtest *vtest = (struct vtest *)renderer; struct vtest_bo *bo = (struct vtest_bo *)_bo; - struct vtest *vtest = bo->vtest; bo->blob_flags = vtest_bo_blob_flags(flags, external_handles); bo->size = size; @@ -767,46 +790,15 @@ vtest_bo_init_gpu(struct vn_renderer_bo *_bo, return VK_SUCCESS; } -static void -vtest_bo_destroy(struct vn_renderer_bo *_bo) -{ - struct vtest_bo *bo = (struct vtest_bo *)_bo; - struct vtest *vtest = bo->vtest; - - if (bo->base.res_id) { - if (bo->res_ptr) - munmap(bo->res_ptr, bo->size); - if (bo->res_fd >= 0) - close(bo->res_fd); - - mtx_lock(&vtest->sock_mutex); - vtest_vcmd_resource_unref(vtest, bo->base.res_id); - mtx_unlock(&vtest->sock_mutex); - } - - free(bo); -} - static struct vn_renderer_bo * vtest_bo_create(struct vn_renderer *renderer) { - struct vtest *vtest = (struct vtest *)renderer; - struct vtest_bo *bo = calloc(1, sizeof(*bo)); if (!bo) return NULL; - bo->vtest = vtest; bo->res_fd = -1; - bo->base.ops.destroy = vtest_bo_destroy; - bo->base.ops.init_gpu = vtest_bo_init_gpu; - bo->base.ops.init_dmabuf = NULL; - bo->base.ops.export_dmabuf = vtest_bo_export_dmabuf; - bo->base.ops.map = vtest_bo_map; - bo->base.ops.flush = vtest_bo_flush; - bo->base.ops.invalidate = vtest_bo_invalidate; - return &bo->base; } @@ -1056,12 +1048,20 @@ vtest_init(struct vtest *vtest) vtest->base.ops.get_info = vtest_get_info; vtest->base.ops.submit = vtest_submit; vtest->base.ops.wait = vtest_wait; - vtest->base.ops.bo_create = vtest_bo_create; vtest->base.ops.sync_create = vtest_sync_create; vtest->base.shmem_ops.create = vtest_shmem_create; vtest->base.shmem_ops.destroy = vtest_shmem_destroy; + vtest->base.bo_ops.create = vtest_bo_create; + vtest->base.bo_ops.init_gpu = vtest_bo_init_gpu; + vtest->base.bo_ops.init_dmabuf = NULL; + vtest->base.bo_ops.destroy = vtest_bo_destroy; + vtest->base.bo_ops.export_dmabuf = vtest_bo_export_dmabuf; + vtest->base.bo_ops.map = vtest_bo_map; + vtest->base.bo_ops.flush = vtest_bo_flush; + vtest->base.bo_ops.invalidate = vtest_bo_invalidate; + return VK_SUCCESS; }