Added Debug logs

Change-Id: Ie48186a54a76e8b258cb14c60b3f2ba53be46597
disantkumar · May 27, 2024 · c357479 · c357479
1 parent affd358
commit c357479
Show file tree

Hide file tree

Showing 12 changed files with 45 additions and 2 deletions.
diff --git a/src/egl/drivers/dri2/platform_drm.c b/src/egl/drivers/dri2/platform_drm.c
@@ -246,6 +246,7 @@ get_back_bo(struct dri2_egl_surface *dri2_surf)
          unsigned flags = surf->base.v0.flags;
          if (dri2_surf->base.ProtectedContent)
             flags |= GBM_BO_USE_PROTECTED;
+		 printf(">>>>> mesa::get_back_bo\n");
          dri2_surf->back->bo =
             gbm_bo_create(&dri2_dpy->gbm_dri->base, surf->base.v0.width,
                           surf->base.v0.height, surf->base.v0.format, flags);

diff --git a/src/gallium/auxiliary/target-helpers/drm_helper.h b/src/gallium/auxiliary/target-helpers/drm_helper.h
@@ -268,14 +268,18 @@ pipe_virtio_gpu_create_screen(int fd, const struct pipe_screen_config *config)
 {
    struct pipe_screen *screen = NULL;
 
+   printf(">>>> MESA::pipe_virtio_gpu_create_screen\n");
    /* Try native guest driver(s) first, and then fallback to virgl: */
 #ifdef GALLIUM_FREEDRENO
    if (!screen)
       screen = fd_drm_screen_create_renderonly(fd, NULL, config);
 #endif
 #ifdef GALLIUM_VIRGL
    if (!screen)
+   {
+   	  printf(">>>> MESA::pipe_virtio_gpu_create_screen::virgl_drm_screen_create\n");
       screen = virgl_drm_screen_create(fd, config);
+   }
 #endif
    return screen ? debug_screen_wrap(screen) : NULL;
 }

diff --git a/src/gallium/drivers/virgl/virgl_resource.c b/src/gallium/drivers/virgl/virgl_resource.c
@@ -677,6 +677,7 @@ static struct pipe_resource *virgl_resource_create_front(struct pipe_screen *scr
    else
       alloc_size = res->metadata.total_size;
 
+   printf(">>>> MESA::virgl_resource_create_front::vs->vws->resource_create\n");
    res->hw_res = vs->vws->resource_create(vs->vws, templ->target,
                                           map_front_private,
                                           templ->format, vbind,
@@ -709,6 +710,7 @@ static struct pipe_resource *virgl_resource_create_front(struct pipe_screen *scr
 static struct pipe_resource *virgl_resource_create(struct pipe_screen *screen,
                                                    const struct pipe_resource *templ)
 {
+   printf(">>>> MESA::virgl_resource_create::virgl_resource_create_front\n");
    return virgl_resource_create_front(screen, templ, NULL);
 }
 
@@ -732,6 +734,7 @@ static struct pipe_resource *virgl_resource_from_handle(struct pipe_screen *scre
    pipe_reference_init(&res->b.reference, 1);
 
    plane = winsys_stride = plane_offset = modifier = 0;
+   printf(">>>> MESA::virgl_resource_from_handle::resource_create_from_handle\n");
    res->hw_res = vs->vws->resource_create_from_handle(vs->vws, whandle,
                                                       &res->b,
                                                       &plane,
@@ -752,6 +755,7 @@ static struct pipe_resource *virgl_resource_from_handle(struct pipe_screen *scre
       modifier = 0;
    }
 
+   printf(">>>> MESA::virgl_resource_from_handle::virgl_resource_layout\n");
    virgl_resource_layout(&res->b, &res->metadata, plane, winsys_stride,
                          plane_offset, modifier);
 

diff --git a/src/gallium/frontends/dri/drisw.c b/src/gallium/frontends/dri/drisw.c
@@ -426,6 +426,7 @@ drisw_allocate_textures(struct dri_context *stctx,
       if (statts[i] == ST_ATTACHMENT_FRONT_LEFT &&
                  screen->base.screen->resource_create_front &&
                  loader->base.version >= 3) {
+		  printf(">>>> MESA::drisw_allocate_textures::screen->base.screen->resource_create_front\n");
          drawable->textures[statts[i]] =
             screen->base.screen->resource_create_front(screen->base.screen, &templ, (const void *)drawable);
       } else

diff --git a/src/gallium/winsys/virgl/drm/virgl_drm_winsys.c b/src/gallium/winsys/virgl/drm/virgl_drm_winsys.c
@@ -558,22 +558,32 @@ virgl_drm_winsys_resource_cache_create(struct virgl_winsys *qws,
    if (target == PIPE_BUFFER && (bind & VIRGL_BIND_CUSTOM))
        need_sync = true;
 
+   /*
    if ((bind & (VIRGL_BIND_SCANOUT | VIRGL_BIND_SHARED)) == (VIRGL_BIND_SCANOUT | VIRGL_BIND_SHARED))
+   {
+	   printf(">>>> MESA::virgl_drm_winsys_resource_cache_create::create_shared_scanout\n");
          res = virgl_drm_winsys_resource_create_shared_scanout(qws, target, format, bind,
                                                   width, height, depth,
                                                   array_size, last_level,
                                                   nr_samples, flags, size);
-   else if (flags & (VIRGL_RESOURCE_FLAG_MAP_PERSISTENT |
+   }
+   else */
+   if (flags & (VIRGL_RESOURCE_FLAG_MAP_PERSISTENT |
                 VIRGL_RESOURCE_FLAG_MAP_COHERENT))
+   {	   
+	   printf(">>>> MESA::virgl_drm_winsys_resource_cache_create::blob\n");
       res = virgl_drm_winsys_resource_create_blob(qws, target, format, bind,
                                                   width, height, depth,
                                                   array_size, last_level,
                                                   nr_samples, flags, size);
+   }
    else
+   {	   printf(">>>> MESA::virgl_drm_winsys_resource_cache_create::else\n");
       res = virgl_drm_winsys_resource_create(qws, target, format, bind, width,
                                              height, depth, array_size,
                                              last_level, nr_samples, size,
                                              need_sync);
+   }
    return res;
 }
 
@@ -1337,7 +1347,7 @@ virgl_drm_winsys_create(int drmFD)
    struct virgl_drm_winsys *qdws;
    int drm_version;
    int ret;
-
+   printf(">>>> MESA::virgl_drm_winsys_create\n");
    for (uint32_t i = 0; i < ARRAY_SIZE(params); i++) {
       struct drm_virtgpu_getparam getparam = { 0 };
       uint64_t value = 0;
@@ -1406,6 +1416,7 @@ virgl_drm_winsys_create(int drmFD)
 
    qdws->base.supports_coherent = params[param_resource_blob].value &&
                                   params[param_host_visible].value;
+   printf(">>>> MESA::virgl_drm_winsys_create::return\n");
    return &qdws->base;
 
 }
@@ -1476,6 +1487,7 @@ virgl_drm_screen_create(int fd, const struct pipe_screen_config *config)
 {
    struct pipe_screen *pscreen = NULL;
 
+   printf(">>>> MESA::virgl_drm_screen_create\n");
    simple_mtx_lock(&virgl_screen_mutex);
    if (!fd_tab) {
       fd_tab = _mesa_hash_table_create(NULL, hash_fd, equal_fd);
@@ -1490,6 +1502,7 @@ virgl_drm_screen_create(int fd, const struct pipe_screen_config *config)
       struct virgl_winsys *vws;
       int dup_fd = os_dupfd_cloexec(fd);
 
+      printf(">>>> MESA::virgl_drm_screen_create::virgl_drm_winsys_create\n");
       vws = virgl_drm_winsys_create(dup_fd);
       if (!vws) {
          close(dup_fd);
@@ -1511,5 +1524,6 @@ virgl_drm_screen_create(int fd, const struct pipe_screen_config *config)
 
 unlock:
    simple_mtx_unlock(&virgl_screen_mutex);
+   printf(">>>> MESA::virgl_drm_screen_create::return\n");
    return pscreen;
 }
diff --git a/src/virtio/vulkan/vn_renderer_virtgpu.c b/src/virtio/vulkan/vn_renderer_virtgpu.c
@@ -1634,6 +1634,7 @@ virtgpu_open(struct virtgpu *gpu)
 static VkResult
 virtgpu_init(struct virtgpu *gpu)
 {
+	printf(">>>> MESA::virtgpu_init\n");
    util_sparse_array_init(&gpu->shmem_array, sizeof(struct virtgpu_shmem),
                           1024);
    util_sparse_array_init(&gpu->bo_array, sizeof(struct virtgpu_bo), 1024);
@@ -1681,6 +1682,7 @@ virtgpu_init(struct virtgpu *gpu)
    gpu->base.sync_ops.read = virtgpu_sync_read;
    gpu->base.sync_ops.write = virtgpu_sync_write;
 
+   printf(">>>> MESA::virtgpu_init::end\n");
    return VK_SUCCESS;
 }
 
@@ -1697,6 +1699,7 @@ vn_renderer_create_virtgpu(struct vn_instance *instance,
    gpu->instance = instance;
    gpu->fd = -1;
 
+   printf(">>>> MESA::vn_renderer_create_virtgpu::virtgpu_init\n");
    VkResult result = virtgpu_init(gpu);
    if (result != VK_SUCCESS) {
       virtgpu_destroy(&gpu->base, alloc);

diff --git a/src/vulkan/wsi/wsi_common.c b/src/vulkan/wsi/wsi_common.c
@@ -361,19 +361,22 @@ configure_image(const struct wsi_swapchain *chain,
 {
    switch (params->image_type) {
    case WSI_IMAGE_TYPE_CPU: {
+		printf(">>>> MESA::configure_image::WSI_IMAGE_TYPE_CPU\n");
       const struct wsi_cpu_image_params *cpu_params =
          container_of(params, const struct wsi_cpu_image_params, base);
       return wsi_configure_cpu_image(chain, pCreateInfo, cpu_params, info);
    }
 #ifdef HAVE_LIBDRM
    case WSI_IMAGE_TYPE_DRM: {
+		printf(">>>> MESA::configure_image::WSI_IMAGE_TYPE_DRM\n");
       const struct wsi_drm_image_params *drm_params =
          container_of(params, const struct wsi_drm_image_params, base);
       return wsi_drm_configure_image(chain, pCreateInfo, drm_params, info);
    }
 #endif
 #ifdef _WIN32
    case WSI_IMAGE_TYPE_DXGI: {
+		printf(">>>> MESA::configure_image::WSI_IMAGE_TYPE_DXGI\n");
       const struct wsi_dxgi_image_params *dxgi_params =
          container_of(params, const struct wsi_dxgi_image_params, base);
       return wsi_dxgi_configure_image(chain, pCreateInfo, dxgi_params, info);
@@ -1764,13 +1767,15 @@ wsi_create_buffer_blit_context(const struct wsi_swapchain *chain,
       };
       __vk_append_struct(&buf_mem_info, &memory_export_info);
    }
+   printf(">>>> MESA::wsi_create_buffer_blit_context\n");
 #ifndef _WIN32
    VkImportMemoryFdInfoKHR memory_fd_info;
 
    if (info->display_device_is_virtgpu)
    {
       int fd = 0;
 
+	  printf(">>>> MESA::wsi_create_buffer_blit_context::virtgpu_alloc_and_export\n");
       fd = virtgpu_alloc_and_export(info->display_device_fd, info->linear_stride, info->linear_size);
       memory_fd_info = (VkImportMemoryFdInfoKHR){
          .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
@@ -2090,6 +2095,7 @@ wsi_create_cpu_buffer_image_mem(const struct wsi_swapchain *chain,
 {
    VkResult result;
 
+   printf(">>>> MESA::wsi_create_cpu_buffer_image_mem::wsi_create_buffer_blit_context\n");
    result = wsi_create_buffer_blit_context(chain, info, image, 0,
                                            false /* implicit_sync */);
    if (result != VK_SUCCESS)
@@ -2136,6 +2142,7 @@ wsi_configure_cpu_image(const struct wsi_swapchain *chain,
       return result;
 
    if (chain->blit.type != WSI_SWAPCHAIN_NO_BLIT) {
+	   printf(">>>> MESA::wsi_configure_cpu_image::wsi_create_cpu_buffer_image_mem\n");
       wsi_configure_buffer_image(chain, pCreateInfo,
                                  1 /* stride_align */,
                                  1 /* size_align */,
@@ -2145,6 +2152,7 @@ wsi_configure_cpu_image(const struct wsi_swapchain *chain,
       info->select_image_memory_type = wsi_select_device_memory_type;
       info->create_mem = wsi_create_cpu_buffer_image_mem;
    } else {
+	   printf(">>>> MESA::wsi_configure_cpu_image::wsi_create_cpu_linear_image_mem\n");
       /* Force the image to be linear */
       info->create.tiling = VK_IMAGE_TILING_LINEAR;
 

diff --git a/src/vulkan/wsi/wsi_common_display.c b/src/vulkan/wsi/wsi_common_display.c
@@ -2113,6 +2113,7 @@ wsi_display_surface_create_swapchain(
       return VK_ERROR_OUT_OF_HOST_MEMORY;
    }
 
+   printf(">>>> MESA::wsi_display_surface_create_swapchain::wsi_swapchain_init\n");
    VkResult result = wsi_swapchain_init(wsi_device, &chain->base, device,
                                         create_info, &image_params.base,
                                         allocator);

diff --git a/src/vulkan/wsi/wsi_common_drm.c b/src/vulkan/wsi/wsi_common_drm.c
@@ -727,6 +727,7 @@ wsi_create_prime_image_mem(const struct wsi_swapchain *chain,
                            const struct wsi_image_info *info,
                            struct wsi_image *image)
 {
+	printf(">>>> MESA::wsi_create_prime_image_mem::wsi_create_buffer_blit_context\n");
    VkResult result =
       wsi_create_buffer_blit_context(chain, info, image,
                                      VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
@@ -741,6 +742,9 @@ wsi_create_prime_image_mem(const struct wsi_swapchain *chain,
    image->drm_modifier = info->prime_use_linear_modifier ?
                          DRM_FORMAT_MOD_LINEAR : DRM_FORMAT_MOD_INVALID;
 
+   if(image->drm_modifier == DRM_FORMAT_MOD_LINEAR)
+   		printf(">>>> MESA::wsi_create_prime_image_mem::DRM_FORMAT_MOD_LINEAR\n");
+
    return VK_SUCCESS;
 }
 

diff --git a/src/vulkan/wsi/wsi_common_headless.c b/src/vulkan/wsi/wsi_common_headless.c
@@ -461,6 +461,7 @@ wsi_headless_surface_create_swapchain(VkIcdSurfaceBase *icd_surface,
       .same_gpu = true,
    };
 
+   printf(">>>> MESA::wsi_headless_surface_create_swapchain::wsi_swapchain_init\n");
    result = wsi_swapchain_init(wsi_device, &chain->base, device,
                                pCreateInfo, &drm_params.base, pAllocator);
    if (result != VK_SUCCESS) {

diff --git a/src/vulkan/wsi/wsi_common_wayland.c b/src/vulkan/wsi/wsi_common_wayland.c
@@ -2352,6 +2352,7 @@ wsi_wl_surface_create_swapchain(VkIcdSurfaceBase *icd_surface,
       image_params = &drm_image_params.base;
    }
 
+   printf(">>>> MESA::wsi_wl_surface_create_swapchain::wsi_swapchain_init\n");
    result = wsi_swapchain_init(wsi_device, &chain->base, device,
                                pCreateInfo, image_params, pAllocator);
    if (result != VK_SUCCESS)

diff --git a/src/vulkan/wsi/wsi_common_x11.c b/src/vulkan/wsi/wsi_common_x11.c
@@ -2500,6 +2500,7 @@ x11_surface_create_swapchain(VkIcdSurfaceBase *icd_surface,
       image_params = &drm_image_params.base;
    }
 
+   printf(">>>> MESA::x11_surface_create_swapchain::wsi_swapchain_init\n");
    result = wsi_swapchain_init(wsi_device, &chain->base, device, pCreateInfo,
                                image_params, pAllocator);