1 /* 2 * Copyright 2018 Google 3 * SPDX-License-Identifier: MIT 4 */ 5 #pragma once 6 7 #include <vulkan/vulkan.h> 8 9 #include <atomic> 10 #include <functional> 11 #include <memory> 12 #include <mutex> 13 #include <optional> 14 #include <set> 15 #include <unordered_map> 16 17 #include "CommandBufferStagingStream.h" 18 #include "GfxStreamConnectionManager.h" 19 #include "HostVisibleMemoryVirtualization.h" 20 #include "Sync.h" 21 #include "VirtGpu.h" 22 #include "VulkanHandleMapping.h" 23 #include "VulkanHandles.h" 24 #include "goldfish_vk_transform_guest.h" 25 #include "util/perf/cpu_trace.h" 26 27 /// Use installed headers or locally defined Fuchsia-specific bits 28 #ifdef VK_USE_PLATFORM_FUCHSIA 29 30 #include <cutils/native_handle.h> 31 #include <fidl/fuchsia.hardware.goldfish/cpp/wire.h> 32 #include <fidl/fuchsia.sysmem/cpp/wire.h> 33 #include <lib/zx/channel.h> 34 #include <lib/zx/vmo.h> 35 #include <zircon/errors.h> 36 #include <zircon/process.h> 37 #include <zircon/rights.h> 38 #include <zircon/syscalls.h> 39 #include <zircon/syscalls/object.h> 40 41 #include <optional> 42 43 #include "services/service_connector.h" 44 45 #ifndef FUCHSIA_NO_TRACE 46 #include <lib/trace/event.h> 47 #endif 48 49 #define GET_STATUS_SAFE(result, member) ((result).ok() ? ((result)->member) : ZX_OK) 50 51 struct SetBufferCollectionImageConstraintsResult { 52 VkResult result; 53 fuchsia_sysmem::wire::BufferCollectionConstraints constraints; 54 std::vector<uint32_t> createInfoIndex; 55 }; 56 57 struct SetBufferCollectionBufferConstraintsResult { 58 VkResult result; 59 fuchsia_sysmem::wire::BufferCollectionConstraints constraints; 60 }; 61 62 #else 63 64 typedef uint32_t zx_handle_t; 65 typedef uint64_t zx_koid_t; 66 #define ZX_HANDLE_INVALID ((zx_handle_t)0) 67 #define ZX_KOID_INVALID ((zx_koid_t)0) 68 #endif // VK_USE_PLATFORM_FUCHSIA 69 70 /// Use installed headers or locally defined Android-specific bits 71 #ifdef VK_USE_PLATFORM_ANDROID_KHR 72 #include "AndroidHardwareBuffer.h" 73 #include "gfxstream/guest/GfxStreamGralloc.h" 74 #include <android/hardware_buffer.h> 75 #endif 76 77 #if GFXSTREAM_ENABLE_GUEST_GOLDFISH 78 /// Goldfish sync only used for AEMU -- should replace in virtio-gpu when possibe 79 #include "gfxstream/guest/goldfish_sync.h" 80 #endif 81 82 // This should be ABI identical with the variant in ResourceTracker.h 83 struct GfxStreamVkFeatureInfo { 84 bool hasDirectMem; 85 bool hasVulkan; 86 bool hasDeferredVulkanCommands; 87 bool hasVulkanNullOptionalStrings; 88 bool hasVulkanCreateResourcesWithRequirements; 89 bool hasVulkanIgnoredHandles; 90 bool hasVirtioGpuNext; 91 bool hasVulkanFreeMemorySync; 92 bool hasVirtioGpuNativeSync; 93 bool hasVulkanShaderFloat16Int8; 94 bool hasVulkanAsyncQueueSubmit; 95 bool hasVulkanQueueSubmitWithCommands; 96 bool hasVulkanBatchedDescriptorSetUpdate; 97 bool hasVulkanAsyncQsri; 98 bool hasVulkanAuxCommandMemory; 99 bool setupComplete; 100 }; 101 102 class HostConnection; 103 104 namespace gfxstream { 105 namespace vk { 106 107 class VkEncoder; 108 109 class ResourceTracker { 110 public: 111 ResourceTracker(); 112 ~ResourceTracker(); 113 static ResourceTracker* get(); 114 115 VulkanHandleMapping* createMapping(); 116 VulkanHandleMapping* destroyMapping(); 117 118 using HostConnectionGetFunc = GfxStreamConnectionManager* (*)(); 119 using VkEncoderGetFunc = VkEncoder* (*)(GfxStreamConnectionManager*); 120 using CleanupCallback = std::function<void()>; 121 122 struct ThreadingCallbacks { 123 HostConnectionGetFunc hostConnectionGetFunc = nullptr; 124 VkEncoderGetFunc vkEncoderGetFunc = nullptr; 125 }; 126 127 static uint32_t streamFeatureBits; 128 static ThreadingCallbacks threadingCallbacks; 129 130 #define HANDLE_REGISTER_DECL(type) \ 131 void register_##type(type); \ 132 void unregister_##type(type); 133 134 GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECL) 135 136 VkResult on_vkEnumerateInstanceExtensionProperties(void* context, VkResult input_result, 137 const char* pLayerName, 138 uint32_t* pPropertyCount, 139 VkExtensionProperties* pProperties); 140 141 VkResult on_vkEnumerateDeviceExtensionProperties(void* context, VkResult input_result, 142 VkPhysicalDevice physicalDevice, 143 const char* pLayerName, 144 uint32_t* pPropertyCount, 145 VkExtensionProperties* pProperties); 146 147 VkResult on_vkEnumeratePhysicalDevices(void* context, VkResult input_result, 148 VkInstance instance, uint32_t* pPhysicalDeviceCount, 149 VkPhysicalDevice* pPhysicalDevices); 150 151 void on_vkGetPhysicalDeviceFeatures2(void* context, VkPhysicalDevice physicalDevice, 152 VkPhysicalDeviceFeatures2* pFeatures); 153 void on_vkGetPhysicalDeviceFeatures2KHR(void* context, VkPhysicalDevice physicalDevice, 154 VkPhysicalDeviceFeatures2* pFeatures); 155 void on_vkGetPhysicalDeviceProperties(void* context, VkPhysicalDevice physicalDevice, 156 VkPhysicalDeviceProperties* pProperties); 157 void on_vkGetPhysicalDeviceProperties2(void* context, VkPhysicalDevice physicalDevice, 158 VkPhysicalDeviceProperties2* pProperties); 159 void on_vkGetPhysicalDeviceProperties2KHR(void* context, VkPhysicalDevice physicalDevice, 160 VkPhysicalDeviceProperties2* pProperties); 161 162 void on_vkGetPhysicalDeviceMemoryProperties( 163 void* context, VkPhysicalDevice physicalDevice, 164 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 165 void on_vkGetPhysicalDeviceMemoryProperties2( 166 void* context, VkPhysicalDevice physicalDevice, 167 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 168 void on_vkGetPhysicalDeviceMemoryProperties2KHR( 169 void* context, VkPhysicalDevice physicalDevice, 170 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 171 void on_vkGetDeviceQueue(void* context, VkDevice device, uint32_t queueFamilyIndex, 172 uint32_t queueIndex, VkQueue* pQueue); 173 void on_vkGetDeviceQueue2(void* context, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, 174 VkQueue* pQueue); 175 176 VkResult on_vkCreateInstance(void* context, VkResult input_result, 177 const VkInstanceCreateInfo* createInfo, 178 const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 179 VkResult on_vkCreateDevice(void* context, VkResult input_result, 180 VkPhysicalDevice physicalDevice, 181 const VkDeviceCreateInfo* pCreateInfo, 182 const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 183 void on_vkDestroyDevice_pre(void* context, VkDevice device, 184 const VkAllocationCallbacks* pAllocator); 185 186 VkResult on_vkAllocateMemory(void* context, VkResult input_result, VkDevice device, 187 const VkMemoryAllocateInfo* pAllocateInfo, 188 const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 189 void on_vkFreeMemory(void* context, VkDevice device, VkDeviceMemory memory, 190 const VkAllocationCallbacks* pAllocator); 191 192 VkResult on_vkMapMemory(void* context, VkResult input_result, VkDevice device, 193 VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, 194 VkMemoryMapFlags, void** ppData); 195 196 void on_vkUnmapMemory(void* context, VkDevice device, VkDeviceMemory memory); 197 198 VkResult on_vkCreateImage(void* context, VkResult input_result, VkDevice device, 199 const VkImageCreateInfo* pCreateInfo, 200 const VkAllocationCallbacks* pAllocator, VkImage* pImage); 201 void on_vkDestroyImage(void* context, VkDevice device, VkImage image, 202 const VkAllocationCallbacks* pAllocator); 203 204 void on_vkGetImageMemoryRequirements(void* context, VkDevice device, VkImage image, 205 VkMemoryRequirements* pMemoryRequirements); 206 void on_vkGetImageMemoryRequirements2(void* context, VkDevice device, 207 const VkImageMemoryRequirementsInfo2* pInfo, 208 VkMemoryRequirements2* pMemoryRequirements); 209 void on_vkGetImageMemoryRequirements2KHR(void* context, VkDevice device, 210 const VkImageMemoryRequirementsInfo2* pInfo, 211 VkMemoryRequirements2* pMemoryRequirements); 212 void on_vkGetImageSubresourceLayout(void* context, VkDevice device, VkImage image, 213 const VkImageSubresource* pSubresource, 214 VkSubresourceLayout* pLayout); 215 216 VkResult on_vkBindImageMemory(void* context, VkResult input_result, VkDevice device, 217 VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 218 VkResult on_vkBindImageMemory2(void* context, VkResult input_result, VkDevice device, 219 uint32_t bindingCount, const VkBindImageMemoryInfo* pBindInfos); 220 VkResult on_vkBindImageMemory2KHR(void* context, VkResult input_result, VkDevice device, 221 uint32_t bindingCount, 222 const VkBindImageMemoryInfo* pBindInfos); 223 224 VkResult on_vkCreateBuffer(void* context, VkResult input_result, VkDevice device, 225 const VkBufferCreateInfo* pCreateInfo, 226 const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 227 void on_vkDestroyBuffer(void* context, VkDevice device, VkBuffer buffer, 228 const VkAllocationCallbacks* pAllocator); 229 230 void on_vkGetBufferMemoryRequirements(void* context, VkDevice device, VkBuffer buffer, 231 VkMemoryRequirements* pMemoryRequirements); 232 void on_vkGetBufferMemoryRequirements2(void* context, VkDevice device, 233 const VkBufferMemoryRequirementsInfo2* pInfo, 234 VkMemoryRequirements2* pMemoryRequirements); 235 void on_vkGetBufferMemoryRequirements2KHR(void* context, VkDevice device, 236 const VkBufferMemoryRequirementsInfo2* pInfo, 237 VkMemoryRequirements2* pMemoryRequirements); 238 239 VkResult on_vkBindBufferMemory(void* context, VkResult input_result, VkDevice device, 240 VkBuffer buffer, VkDeviceMemory memory, 241 VkDeviceSize memoryOffset); 242 VkResult on_vkBindBufferMemory2(void* context, VkResult input_result, VkDevice device, 243 uint32_t bindInfoCount, 244 const VkBindBufferMemoryInfo* pBindInfos); 245 VkResult on_vkBindBufferMemory2KHR(void* context, VkResult input_result, VkDevice device, 246 uint32_t bindInfoCount, 247 const VkBindBufferMemoryInfo* pBindInfos); 248 249 VkResult on_vkCreateSemaphore(void* context, VkResult, VkDevice device, 250 const VkSemaphoreCreateInfo* pCreateInfo, 251 const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 252 void on_vkDestroySemaphore(void* context, VkDevice device, VkSemaphore semaphore, 253 const VkAllocationCallbacks* pAllocator); 254 VkResult on_vkGetSemaphoreFdKHR(void* context, VkResult, VkDevice device, 255 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); 256 VkResult on_vkImportSemaphoreFdKHR(void* context, VkResult, VkDevice device, 257 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 258 259 VkResult on_vkQueueSubmit(void* context, VkResult input_result, VkQueue queue, 260 uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 261 262 VkResult on_vkQueueSubmit2(void* context, VkResult input_result, VkQueue queue, 263 uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); 264 265 VkResult on_vkQueueWaitIdle(void* context, VkResult input_result, VkQueue queue); 266 267 void unwrap_vkCreateImage_pCreateInfo(const VkImageCreateInfo* pCreateInfo, 268 VkImageCreateInfo* local_pCreateInfo); 269 270 void unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out); 271 272 void unwrap_VkBindImageMemory2_pBindInfos(uint32_t bindInfoCount, 273 const VkBindImageMemoryInfo* inputBindInfos, 274 VkBindImageMemoryInfo* outputBindInfos); 275 276 VkResult on_vkGetMemoryFdKHR(void* context, VkResult input_result, VkDevice device, 277 const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); 278 VkResult on_vkGetMemoryFdPropertiesKHR(void* context, VkResult input_result, VkDevice device, 279 VkExternalMemoryHandleTypeFlagBits handleType, int fd, 280 VkMemoryFdPropertiesKHR* pMemoryFdProperties); 281 282 #ifdef VK_USE_PLATFORM_FUCHSIA 283 VkResult on_vkGetMemoryZirconHandleFUCHSIA(void* context, VkResult input_result, 284 VkDevice device, 285 const VkMemoryGetZirconHandleInfoFUCHSIA* pInfo, 286 uint32_t* pHandle); 287 VkResult on_vkGetMemoryZirconHandlePropertiesFUCHSIA( 288 void* context, VkResult input_result, VkDevice device, 289 VkExternalMemoryHandleTypeFlagBits handleType, uint32_t handle, 290 VkMemoryZirconHandlePropertiesFUCHSIA* pProperties); 291 VkResult on_vkGetSemaphoreZirconHandleFUCHSIA( 292 void* context, VkResult input_result, VkDevice device, 293 const VkSemaphoreGetZirconHandleInfoFUCHSIA* pInfo, uint32_t* pHandle); 294 VkResult on_vkImportSemaphoreZirconHandleFUCHSIA( 295 void* context, VkResult input_result, VkDevice device, 296 const VkImportSemaphoreZirconHandleInfoFUCHSIA* pInfo); 297 VkResult on_vkCreateBufferCollectionFUCHSIA(void* context, VkResult input_result, 298 VkDevice device, 299 const VkBufferCollectionCreateInfoFUCHSIA* pInfo, 300 const VkAllocationCallbacks* pAllocator, 301 VkBufferCollectionFUCHSIA* pCollection); 302 void on_vkDestroyBufferCollectionFUCHSIA(void* context, VkResult input_result, VkDevice device, 303 VkBufferCollectionFUCHSIA collection, 304 const VkAllocationCallbacks* pAllocator); 305 VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIA( 306 void* context, VkResult input_result, VkDevice device, VkBufferCollectionFUCHSIA collection, 307 const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); 308 VkResult on_vkSetBufferCollectionImageConstraintsFUCHSIA( 309 void* context, VkResult input_result, VkDevice device, VkBufferCollectionFUCHSIA collection, 310 const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); 311 VkResult on_vkGetBufferCollectionPropertiesFUCHSIA( 312 void* context, VkResult input_result, VkDevice device, VkBufferCollectionFUCHSIA collection, 313 VkBufferCollectionPropertiesFUCHSIA* pProperties); 314 315 VkResult setBufferCollectionImageConstraintsFUCHSIA( 316 VkEncoder* enc, VkDevice device, 317 fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* pCollection, 318 const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); 319 320 VkResult setBufferCollectionBufferConstraintsFUCHSIA( 321 fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* pCollection, 322 const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); 323 324 #endif 325 326 #ifdef VK_USE_PLATFORM_ANDROID_KHR 327 VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID( 328 void* context, VkResult input_result, VkDevice device, const AHardwareBuffer* buffer, 329 VkAndroidHardwareBufferPropertiesANDROID* pProperties); 330 VkResult on_vkGetMemoryAndroidHardwareBufferANDROID( 331 void* context, VkResult input_result, VkDevice device, 332 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); 333 #endif 334 335 VkResult on_vkCreateSamplerYcbcrConversion( 336 void* context, VkResult input_result, VkDevice device, 337 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 338 const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); 339 void on_vkDestroySamplerYcbcrConversion(void* context, VkDevice device, 340 VkSamplerYcbcrConversion ycbcrConversion, 341 const VkAllocationCallbacks* pAllocator); 342 VkResult on_vkCreateSamplerYcbcrConversionKHR( 343 void* context, VkResult input_result, VkDevice device, 344 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 345 const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); 346 void on_vkDestroySamplerYcbcrConversionKHR(void* context, VkDevice device, 347 VkSamplerYcbcrConversion ycbcrConversion, 348 const VkAllocationCallbacks* pAllocator); 349 350 VkResult on_vkCreateSampler(void* context, VkResult input_result, VkDevice device, 351 const VkSamplerCreateInfo* pCreateInfo, 352 const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 353 354 void on_vkGetPhysicalDeviceExternalFenceProperties( 355 void* context, VkPhysicalDevice physicalDevice, 356 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 357 VkExternalFenceProperties* pExternalFenceProperties); 358 359 void on_vkGetPhysicalDeviceExternalFencePropertiesKHR( 360 void* context, VkPhysicalDevice physicalDevice, 361 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 362 VkExternalFenceProperties* pExternalFenceProperties); 363 364 VkResult on_vkCreateFence(void* context, VkResult input_result, VkDevice device, 365 const VkFenceCreateInfo* pCreateInfo, 366 const VkAllocationCallbacks* pAllocator, VkFence* pFence); 367 368 void on_vkDestroyFence(void* context, VkDevice device, VkFence fence, 369 const VkAllocationCallbacks* pAllocator); 370 371 VkResult on_vkResetFences(void* context, VkResult input_result, VkDevice device, 372 uint32_t fenceCount, const VkFence* pFences); 373 374 VkResult on_vkImportFenceFdKHR(void* context, VkResult input_result, VkDevice device, 375 const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 376 377 VkResult on_vkGetFenceFdKHR(void* context, VkResult input_result, VkDevice device, 378 const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); 379 380 VkResult on_vkGetFenceStatus(void* context, VkResult input_result, VkDevice device, 381 VkFence fence); 382 383 VkResult on_vkWaitForFences(void* context, VkResult input_result, VkDevice device, 384 uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, 385 uint64_t timeout); 386 387 VkResult on_vkCreateDescriptorPool(void* context, VkResult input_result, VkDevice device, 388 const VkDescriptorPoolCreateInfo* pCreateInfo, 389 const VkAllocationCallbacks* pAllocator, 390 VkDescriptorPool* pDescriptorPool); 391 392 void on_vkDestroyDescriptorPool(void* context, VkDevice device, VkDescriptorPool descriptorPool, 393 const VkAllocationCallbacks* pAllocator); 394 395 VkResult on_vkResetDescriptorPool(void* context, VkResult input_result, VkDevice device, 396 VkDescriptorPool descriptorPool, 397 VkDescriptorPoolResetFlags flags); 398 399 VkResult on_vkAllocateDescriptorSets(void* context, VkResult input_result, VkDevice device, 400 const VkDescriptorSetAllocateInfo* pAllocateInfo, 401 VkDescriptorSet* pDescriptorSets); 402 403 VkResult on_vkFreeDescriptorSets(void* context, VkResult input_result, VkDevice device, 404 VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, 405 const VkDescriptorSet* pDescriptorSets); 406 407 VkResult on_vkCreateDescriptorSetLayout(void* context, VkResult input_result, VkDevice device, 408 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 409 const VkAllocationCallbacks* pAllocator, 410 VkDescriptorSetLayout* pSetLayout); 411 412 void on_vkUpdateDescriptorSets(void* context, VkDevice device, uint32_t descriptorWriteCount, 413 const VkWriteDescriptorSet* pDescriptorWrites, 414 uint32_t descriptorCopyCount, 415 const VkCopyDescriptorSet* pDescriptorCopies); 416 417 VkResult on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(void* context, VkResult input_result, 418 VkDevice device, VkDeviceMemory memory, 419 uint64_t* pAddress); 420 VkResult on_vkMapMemoryIntoAddressSpaceGOOGLE(void* context, VkResult input_result, 421 VkDevice device, VkDeviceMemory memory, 422 uint64_t* pAddress); 423 424 VkResult on_vkCreateDescriptorUpdateTemplate( 425 void* context, VkResult input_result, VkDevice device, 426 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 427 const VkAllocationCallbacks* pAllocator, 428 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 429 430 VkResult on_vkCreateDescriptorUpdateTemplateKHR( 431 void* context, VkResult input_result, VkDevice device, 432 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 433 const VkAllocationCallbacks* pAllocator, 434 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 435 436 void on_vkUpdateDescriptorSetWithTemplate(void* context, VkDevice device, 437 VkDescriptorSet descriptorSet, 438 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 439 const void* pData); 440 441 void on_vkUpdateDescriptorSetWithTemplateKHR(void* context, VkDevice device, 442 VkDescriptorSet descriptorSet, 443 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 444 const void* pData); 445 446 VkResult on_vkGetPhysicalDeviceImageFormatProperties2( 447 void* context, VkResult input_result, VkPhysicalDevice physicalDevice, 448 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 449 VkImageFormatProperties2* pImageFormatProperties); 450 451 VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR( 452 void* context, VkResult input_result, VkPhysicalDevice physicalDevice, 453 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 454 VkImageFormatProperties2* pImageFormatProperties); 455 456 void on_vkGetPhysicalDeviceExternalBufferProperties( 457 void* context, VkPhysicalDevice physicalDevice, 458 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 459 VkExternalBufferProperties* pExternalBufferProperties); 460 461 void on_vkGetPhysicalDeviceExternalBufferPropertiesKHR( 462 void* context, VkPhysicalDevice physicalDevice, 463 const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, 464 VkExternalBufferPropertiesKHR* pExternalBufferProperties); 465 466 void on_vkGetPhysicalDeviceExternalSemaphoreProperties( 467 void* context, VkPhysicalDevice physicalDevice, 468 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 469 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 470 471 void on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 472 void* context, VkPhysicalDevice physicalDevice, 473 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 474 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 475 476 void registerEncoderCleanupCallback(const VkEncoder* encoder, void* handle, 477 CleanupCallback callback); 478 void unregisterEncoderCleanupCallback(const VkEncoder* encoder, void* handle); 479 void onEncoderDeleted(const VkEncoder* encoder); 480 481 uint32_t syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* current); 482 uint32_t syncEncodersForQueue(VkQueue queue, VkEncoder* currentEncoder); 483 484 CommandBufferStagingStream::Alloc getAlloc(); 485 CommandBufferStagingStream::Free getFree(); 486 487 VkResult on_vkBeginCommandBuffer(void* context, VkResult input_result, 488 VkCommandBuffer commandBuffer, 489 const VkCommandBufferBeginInfo* pBeginInfo); 490 VkResult on_vkEndCommandBuffer(void* context, VkResult input_result, 491 VkCommandBuffer commandBuffer); 492 VkResult on_vkResetCommandBuffer(void* context, VkResult input_result, 493 VkCommandBuffer commandBuffer, 494 VkCommandBufferResetFlags flags); 495 496 VkResult on_vkCreateImageView(void* context, VkResult input_result, VkDevice device, 497 const VkImageViewCreateInfo* pCreateInfo, 498 const VkAllocationCallbacks* pAllocator, VkImageView* pView); 499 500 void on_vkCmdExecuteCommands(void* context, VkCommandBuffer commandBuffer, 501 uint32_t commandBufferCount, 502 const VkCommandBuffer* pCommandBuffers); 503 504 void on_vkCmdBindDescriptorSets(void* context, VkCommandBuffer commandBuffer, 505 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, 506 uint32_t firstSet, uint32_t descriptorSetCount, 507 const VkDescriptorSet* pDescriptorSets, 508 uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); 509 510 void on_vkCmdPipelineBarrier( 511 void* context, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, 512 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, 513 uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, 514 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, 515 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); 516 517 void on_vkDestroyDescriptorSetLayout(void* context, VkDevice device, 518 VkDescriptorSetLayout descriptorSetLayout, 519 const VkAllocationCallbacks* pAllocator); 520 521 VkResult on_vkAllocateCommandBuffers(void* context, VkResult input_result, VkDevice device, 522 const VkCommandBufferAllocateInfo* pAllocateInfo, 523 VkCommandBuffer* pCommandBuffers); 524 525 VkResult on_vkQueueSignalReleaseImageANDROID(void* context, VkResult input_result, 526 VkQueue queue, uint32_t waitSemaphoreCount, 527 const VkSemaphore* pWaitSemaphores, VkImage image, 528 int* pNativeFenceFd); 529 530 VkResult on_vkCreateGraphicsPipelines(void* context, VkResult input_result, VkDevice device, 531 VkPipelineCache pipelineCache, uint32_t createInfoCount, 532 const VkGraphicsPipelineCreateInfo* pCreateInfos, 533 const VkAllocationCallbacks* pAllocator, 534 VkPipeline* pPipelines); 535 536 uint8_t* getMappedPointer(VkDeviceMemory memory); 537 VkDeviceSize getMappedSize(VkDeviceMemory memory); 538 VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const; 539 bool isValidMemoryRange(const VkMappedMemoryRange& range); 540 541 void setupFeatures(const struct GfxStreamVkFeatureInfo* features); 542 void setupCaps(uint32_t& noRenderControlEnc); 543 void setupPlatformHelpers(); 544 545 void setThreadingCallbacks(const ThreadingCallbacks& callbacks); 546 bool hostSupportsVulkan() const; 547 bool usingDirectMapping() const; 548 uint32_t getStreamFeatures() const; 549 uint32_t getApiVersionFromInstance(VkInstance instance); 550 uint32_t getApiVersionFromDevice(VkDevice device); 551 bool hasInstanceExtension(VkInstance instance, const std::string& name); 552 bool hasDeviceExtension(VkDevice instance, const std::string& name); 553 VkDevice getDevice(VkCommandBuffer commandBuffer) const; 554 void addToCommandPool(VkCommandPool commandPool, uint32_t commandBufferCount, 555 VkCommandBuffer* pCommandBuffers); 556 void resetCommandPoolStagingInfo(VkCommandPool commandPool); 557 558 #ifdef __GNUC__ 559 #define ALWAYS_INLINE_GFXSTREAM 560 #elif 561 #define ALWAYS_INLINE_GFXSTREAM __attribute__((always_inline)) 562 #endif 563 564 static VkEncoder* getCommandBufferEncoder(VkCommandBuffer commandBuffer); 565 static VkEncoder* getQueueEncoder(VkQueue queue); 566 static VkEncoder* getThreadLocalEncoder(); 567 568 static void setSeqnoPtr(uint32_t* seqnoptr); 569 static ALWAYS_INLINE_GFXSTREAM uint32_t nextSeqno(); 570 static ALWAYS_INLINE_GFXSTREAM uint32_t getSeqno(); 571 572 // Transforms 573 void deviceMemoryTransform_tohost(VkDeviceMemory* memory, uint32_t memoryCount, 574 VkDeviceSize* offset, uint32_t offsetCount, 575 VkDeviceSize* size, uint32_t sizeCount, uint32_t* typeIndex, 576 uint32_t typeIndexCount, uint32_t* typeBits, 577 uint32_t typeBitsCount); 578 void deviceMemoryTransform_fromhost(VkDeviceMemory* memory, uint32_t memoryCount, 579 VkDeviceSize* offset, uint32_t offsetCount, 580 VkDeviceSize* size, uint32_t sizeCount, uint32_t* typeIndex, 581 uint32_t typeIndexCount, uint32_t* typeBits, 582 uint32_t typeBitsCount); 583 584 void transformImpl_VkExternalMemoryProperties_fromhost(VkExternalMemoryProperties* pProperties, 585 uint32_t); 586 void transformImpl_VkExternalMemoryProperties_tohost(VkExternalMemoryProperties* pProperties, 587 uint32_t); 588 void transformImpl_VkImageCreateInfo_fromhost(const VkImageCreateInfo*, uint32_t); 589 void transformImpl_VkImageCreateInfo_tohost(const VkImageCreateInfo*, uint32_t); 590 591 #define DEFINE_TRANSFORMED_TYPE_PROTOTYPE(type) \ 592 void transformImpl_##type##_tohost(type*, uint32_t); \ 593 void transformImpl_##type##_fromhost(type*, uint32_t); 594 595 LIST_TRIVIAL_TRANSFORMED_TYPES(DEFINE_TRANSFORMED_TYPE_PROTOTYPE) 596 597 private: 598 VulkanHandleMapping* mCreateMapping = nullptr; 599 VulkanHandleMapping* mDestroyMapping = nullptr; 600 601 uint32_t getColorBufferMemoryIndex(void* context, VkDevice device); 602 const VkPhysicalDeviceMemoryProperties& getPhysicalDeviceMemoryProperties( 603 void* context, VkDevice device, VkPhysicalDevice physicalDevice); 604 605 VkResult on_vkGetPhysicalDeviceImageFormatProperties2_common( 606 bool isKhr, void* context, VkResult input_result, VkPhysicalDevice physicalDevice, 607 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 608 VkImageFormatProperties2* pImageFormatProperties); 609 610 void on_vkGetPhysicalDeviceExternalBufferProperties_common( 611 bool isKhr, void* context, VkPhysicalDevice physicalDevice, 612 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 613 VkExternalBufferProperties* pExternalBufferProperties); 614 615 template <typename VkSubmitInfoType> 616 VkResult on_vkQueueSubmitTemplate(void* context, VkResult input_result, VkQueue queue, 617 uint32_t submitCount, const VkSubmitInfoType* pSubmits, 618 VkFence fence); 619 620 void freeDescriptorSetsIfHostAllocated(VkEncoder* enc, VkDevice device, 621 uint32_t descriptorSetCount, 622 const VkDescriptorSet* sets); 623 void clearDescriptorPoolAndUnregisterDescriptorSets(void* context, VkDevice device, 624 VkDescriptorPool pool); 625 626 void setDeviceInfo(VkDevice device, VkPhysicalDevice physdev, VkPhysicalDeviceProperties props, 627 VkPhysicalDeviceMemoryProperties memProps, uint32_t enabledExtensionCount, 628 const char* const* ppEnabledExtensionNames, const void* pNext); 629 630 void setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory, VkDeviceSize allocationSize, 631 uint8_t* ptr, uint32_t memoryTypeIndex, void* ahw, bool imported, 632 zx_handle_t vmoHandle, VirtGpuResourcePtr blobPtr); 633 634 void setImageInfo(VkImage image, VkDevice device, const VkImageCreateInfo* pCreateInfo); 635 636 bool supportsDeferredCommands() const; 637 bool supportsAsyncQueueSubmit() const; 638 bool supportsCreateResourcesWithRequirements() const; 639 640 int getHostInstanceExtensionIndex(const std::string& extName) const; 641 int getHostDeviceExtensionIndex(const std::string& extName) const; 642 643 CoherentMemoryPtr createCoherentMemory(VkDevice device, VkDeviceMemory mem, 644 const VkMemoryAllocateInfo& hostAllocationInfo, 645 VkEncoder* enc, VkResult& res); 646 VkResult allocateCoherentMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, 647 VkEncoder* enc, VkDeviceMemory* pMemory); 648 649 VkResult getCoherentMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkEncoder* enc, 650 VkDevice device, VkDeviceMemory* pMemory); 651 652 void transformImageMemoryRequirements2ForGuest(VkImage image, VkMemoryRequirements2* reqs2); 653 654 void transformBufferMemoryRequirements2ForGuest(VkBuffer buffer, VkMemoryRequirements2* reqs2); 655 656 void flushCommandBufferPendingCommandsBottomUp(void* context, VkQueue queue, 657 const std::vector<VkCommandBuffer>& workingSet); 658 659 template <class VkSubmitInfoType> 660 void flushStagingStreams(void* context, VkQueue queue, uint32_t submitCount, 661 const VkSubmitInfoType* pSubmits); 662 663 VkResult vkQueueSubmitEnc(VkEncoder* enc, VkQueue queue, uint32_t submitCount, 664 const VkSubmitInfo* pSubmits, VkFence fence); 665 666 VkResult vkQueueSubmitEnc(VkEncoder* enc, VkQueue queue, uint32_t submitCount, 667 const VkSubmitInfo2* pSubmits, VkFence fence); 668 669 VkResult initDescriptorUpdateTemplateBuffers( 670 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 671 VkDescriptorUpdateTemplate descriptorUpdateTemplate); 672 673 #if defined(VK_USE_PLATFORM_ANDROID_KHR) 674 VkResult exportSyncFdForQSRILocked(VkImage image, int* fd); 675 #endif 676 677 void setInstanceInfo(VkInstance instance, uint32_t enabledExtensionCount, 678 const char* const* ppEnabledExtensionNames, uint32_t apiVersion); 679 680 void resetCommandBufferStagingInfo(VkCommandBuffer commandBuffer, bool alsoResetPrimaries, 681 bool alsoClearPendingDescriptorSets); 682 683 void resetCommandBufferPendingTopology(VkCommandBuffer commandBuffer); 684 685 void clearCommandPool(VkCommandPool commandPool); 686 687 void ensureSyncDeviceFd(void); 688 689 #if defined(VK_USE_PLATFORM_ANDROID_KHR) 690 void unwrap_VkNativeBufferANDROID(const VkNativeBufferANDROID* inputNativeInfo, 691 VkNativeBufferANDROID* outputNativeInfo); 692 693 void unwrap_VkBindImageMemorySwapchainInfoKHR( 694 const VkBindImageMemorySwapchainInfoKHR* inputBimsi, 695 VkBindImageMemorySwapchainInfoKHR* outputBimsi); 696 #endif 697 698 #if defined(VK_USE_PLATFORM_FUCHSIA) 699 VkResult getBufferCollectionImageCreateInfoIndexLocked( 700 VkBufferCollectionFUCHSIA collection, fuchsia_sysmem::wire::BufferCollectionInfo2& info, 701 uint32_t* outCreateInfoIndex); 702 703 SetBufferCollectionImageConstraintsResult setBufferCollectionImageConstraintsImpl( 704 VkEncoder* enc, VkDevice device, 705 fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* pCollection, 706 const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); 707 708 VkResult setBufferCollectionConstraintsFUCHSIA( 709 VkEncoder* enc, VkDevice device, 710 fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* collection, 711 const VkImageCreateInfo* pImageInfo); 712 #endif 713 714 #ifdef VK_USE_PLATFORM_ANDROID_KHR 715 uint64_t getAHardwareBufferId(AHardwareBuffer* ahw); 716 #endif 717 718 void unregister_VkDescriptorSet_locked(VkDescriptorSet set); 719 720 #define HANDLE_DEFINE_TRIVIAL_INFO_STRUCT(type) \ 721 struct type##_Info { \ 722 uint32_t unused; \ 723 }; 724 GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_DEFINE_TRIVIAL_INFO_STRUCT) 725 726 struct VkInstance_Info { 727 uint32_t highestApiVersion; 728 std::set<std::string> enabledExtensions; 729 // Fodder for vkEnumeratePhysicalDevices. 730 std::vector<VkPhysicalDevice> physicalDevices; 731 }; 732 733 struct VkDevice_Info { 734 VkPhysicalDevice physdev; 735 VkPhysicalDeviceProperties props; 736 VkPhysicalDeviceMemoryProperties memProps; 737 uint32_t apiVersion; 738 std::set<std::string> enabledExtensions; 739 std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void*>> 740 deviceMemoryReportCallbacks; 741 }; 742 743 struct VkDeviceMemory_Info { 744 bool dedicated = false; 745 bool imported = false; 746 747 #ifdef VK_USE_PLATFORM_ANDROID_KHR 748 AHardwareBuffer* ahw = nullptr; 749 #endif 750 zx_handle_t vmoHandle = ZX_HANDLE_INVALID; 751 VkDevice device; 752 753 uint8_t* ptr = nullptr; 754 755 uint64_t blobId = 0; 756 uint64_t allocationSize = 0; 757 uint32_t memoryTypeIndex = 0; 758 uint64_t coherentMemorySize = 0; 759 uint64_t coherentMemoryOffset = 0; 760 761 #if defined(__ANDROID__) 762 GoldfishAddressSpaceBlockPtr goldfishBlock = nullptr; 763 #endif // defined(__ANDROID__) 764 CoherentMemoryPtr coherentMemory = nullptr; 765 VirtGpuResourcePtr blobPtr = nullptr; 766 }; 767 768 struct VkCommandBuffer_Info { 769 uint32_t placeholder; 770 }; 771 772 struct VkQueue_Info { 773 VkDevice device; 774 }; 775 776 // custom guest-side structs for images/buffers because of AHardwareBuffer :(( 777 struct VkImage_Info { 778 VkDevice device; 779 VkImageCreateInfo createInfo; 780 bool external = false; 781 VkExternalMemoryImageCreateInfo externalCreateInfo; 782 VkDeviceMemory currentBacking = VK_NULL_HANDLE; 783 VkDeviceSize currentBackingOffset = 0; 784 VkDeviceSize currentBackingSize = 0; 785 bool baseRequirementsKnown = false; 786 VkMemoryRequirements baseRequirements; 787 #ifdef VK_USE_PLATFORM_ANDROID_KHR 788 bool hasExternalFormat = false; 789 unsigned externalFourccFormat = 0; 790 std::vector<int> pendingQsriSyncFds; 791 #endif 792 #ifdef VK_USE_PLATFORM_FUCHSIA 793 bool isSysmemBackedMemory = false; 794 #endif 795 #ifdef LINUX_GUEST_BUILD 796 bool isDmaBufImage = false; 797 VkImage linearPeerImage = VK_NULL_HANDLE; 798 #endif 799 }; 800 801 struct VkBuffer_Info { 802 VkDevice device; 803 VkBufferCreateInfo createInfo; 804 bool external = false; 805 VkExternalMemoryBufferCreateInfo externalCreateInfo; 806 VkDeviceMemory currentBacking = VK_NULL_HANDLE; 807 VkDeviceSize currentBackingOffset = 0; 808 VkDeviceSize currentBackingSize = 0; 809 bool baseRequirementsKnown = false; 810 VkMemoryRequirements baseRequirements; 811 #ifdef VK_USE_PLATFORM_FUCHSIA 812 bool isSysmemBackedMemory = false; 813 #endif 814 }; 815 816 struct VkSemaphore_Info { 817 VkDevice device; 818 zx_handle_t eventHandle = ZX_HANDLE_INVALID; 819 zx_koid_t eventKoid = ZX_KOID_INVALID; 820 std::optional<int> syncFd = {}; 821 }; 822 823 struct VkDescriptorUpdateTemplate_Info { 824 uint32_t templateEntryCount = 0; 825 VkDescriptorUpdateTemplateEntry* templateEntries; 826 827 uint32_t imageInfoCount = 0; 828 uint32_t bufferInfoCount = 0; 829 uint32_t bufferViewCount = 0; 830 uint32_t inlineUniformBlockCount = 0; 831 uint32_t* imageInfoIndices; 832 uint32_t* bufferInfoIndices; 833 uint32_t* bufferViewIndices; 834 VkDescriptorImageInfo* imageInfos; 835 VkDescriptorBufferInfo* bufferInfos; 836 VkBufferView* bufferViews; 837 std::vector<uint8_t> inlineUniformBlockBuffer; 838 std::vector<uint32_t> inlineUniformBlockBytesPerBlocks; // bytes per uniform block 839 }; 840 841 struct VkFence_Info { 842 VkDevice device; 843 bool external = false; 844 VkExportFenceCreateInfo exportFenceCreateInfo; 845 #if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__) 846 // Note: -1 means already signaled. 847 std::optional<int> syncFd; 848 #endif 849 }; 850 851 struct VkDescriptorPool_Info { 852 uint32_t unused; 853 }; 854 855 struct VkDescriptorSet_Info { 856 uint32_t unused; 857 }; 858 859 struct VkDescriptorSetLayout_Info { 860 uint32_t unused; 861 }; 862 863 struct VkCommandPool_Info { 864 uint32_t unused; 865 }; 866 867 struct VkSampler_Info { 868 uint32_t unused; 869 }; 870 871 struct VkBufferCollectionFUCHSIA_Info { 872 #ifdef VK_USE_PLATFORM_FUCHSIA 873 std::optional<fuchsia_sysmem::wire::BufferCollectionConstraints> constraints; 874 std::optional<VkBufferCollectionPropertiesFUCHSIA> properties; 875 876 // the index of corresponding createInfo for each image format 877 // constraints in |constraints|. 878 std::vector<uint32_t> createInfoIndex; 879 #endif // VK_USE_PLATFORM_FUCHSIA 880 }; 881 882 VkDescriptorImageInfo filterNonexistentSampler(const VkDescriptorImageInfo& inputInfo); 883 884 void emitDeviceMemoryReport(VkDevice_Info info, VkDeviceMemoryReportEventTypeEXT type, 885 uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType, 886 uint64_t objectHandle, uint32_t heapIndex = 0); 887 888 void transformImageMemoryRequirementsForGuestLocked(VkImage image, VkMemoryRequirements* reqs); 889 CoherentMemoryPtr freeCoherentMemoryLocked(VkDeviceMemory memory, VkDeviceMemory_Info& info); 890 891 std::recursive_mutex mLock; 892 893 std::optional<const VkPhysicalDeviceMemoryProperties> mCachedPhysicalDeviceMemoryProps; 894 895 struct GfxStreamVkFeatureInfo mFeatureInfo = {}; 896 897 #if defined(__ANDROID__) 898 std::unique_ptr<GoldfishAddressSpaceBlockProvider> mGoldfishAddressSpaceBlockProvider; 899 #endif // defined(__ANDROID__) 900 901 #if defined(VK_USE_PLATFORM_ANDROID_KHR) 902 std::unique_ptr<gfxstream::Gralloc> mGralloc = nullptr; 903 #endif 904 905 std::unique_ptr<gfxstream::SyncHelper> mSyncHelper = nullptr; 906 907 struct VirtGpuCaps mCaps; 908 std::vector<VkExtensionProperties> mHostInstanceExtensions; 909 std::vector<VkExtensionProperties> mHostDeviceExtensions; 910 911 // 32 bits only for now, upper bits may be used later. 912 std::atomic<uint32_t> mAtomicId = 0; 913 #if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__) 914 int mSyncDeviceFd = -1; 915 #endif 916 917 #ifdef VK_USE_PLATFORM_FUCHSIA 918 fidl::WireSyncClient<fuchsia_hardware_goldfish::ControlDevice> mControlDevice; 919 fidl::WireSyncClient<fuchsia_sysmem::Allocator> mSysmemAllocator; 920 #endif 921 922 #define HANDLE_REGISTER_DECLARATION(type) std::unordered_map<type, type##_Info> info_##type; 923 924 GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECLARATION) 925 926 std::unordered_map<const VkEncoder*, std::unordered_map<void*, CleanupCallback>> 927 mEncoderCleanupCallbacks; 928 }; 929 930 } // namespace vk 931 } // namespace gfxstream 932