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