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