| 1 |
/* |
| 2 |
* Copyright 2025 Mesa3D authors |
| 3 |
* SPDX-License-Identifier: MIT |
| 4 |
*/ |
| 5 |
|
| 6 |
#include "GfxStreamVulkanMapper.h" |
| 7 |
|
| 8 |
#include <cerrno> |
| 9 |
#include <cstdlib> |
| 10 |
#include <cstring> |
| 11 |
#include <vector> |
| 12 |
|
| 13 |
#include "util/detect_os.h" |
| 14 |
#include "util/log.h" |
| 15 |
#include "util/os_misc.h" |
| 16 |
#include "virtgpu_kumquat_ffi.h" |
| 17 |
|
| 18 |
#if DETECT_OS_WINDOWS |
| 19 |
#include <io.h> |
| 20 |
|
| 21 |
#include "vulkan/vulkan_win32.h" |
| 22 |
#define VK_LIBNAME "vulkan-1.dll" |
| 23 |
#else |
| 24 |
#include <unistd.h> |
| 25 |
#if DETECT_OS_APPLE |
| 26 |
#define VK_LIBNAME "libvulkan.1.dylib" |
| 27 |
#elif DETECT_OS_ANDROID |
| 28 |
#define VK_LIBNAME "libvulkan.so" |
| 29 |
#else |
| 30 |
#define VK_LIBNAME "libvulkan.so.1" |
| 31 |
#endif |
| 32 |
#endif |
| 33 |
|
| 34 |
constexpr char VK_DRIVER_FILES[] = "VK_DRIVER_FILES"; |
| 35 |
constexpr uint32_t kNvidiaVendorId = 0x10de; |
| 36 |
|
| 37 |
#define GET_PROC_ADDR_INSTANCE_LOCAL(x) \ |
| 38 |
PFN_vk##x vk_##x = (PFN_vk##x)vk_GetInstanceProcAddr(nullptr, "vk" #x) |
| 39 |
|
| 40 |
std::unique_ptr<GfxStreamVulkanMapper> sVkMapper; |
| 41 |
|
| 42 |
GfxStreamVulkanMapper::GfxStreamVulkanMapper() {} |
| 43 |
GfxStreamVulkanMapper::~GfxStreamVulkanMapper() {} |
| 44 |
|
| 45 |
static uint32_t chooseGfxQueueFamily(vk_uncompacted_dispatch_table* vk, VkPhysicalDevice phys_dev) { |
| 46 |
uint32_t family_idx = UINT32_MAX; |
| 47 |
uint32_t nProps = 0; |
| 48 |
|
| 49 |
vk->GetPhysicalDeviceQueueFamilyProperties(phys_dev, &nProps, NULL); |
| 50 |
std::vector<VkQueueFamilyProperties> props(nProps, VkQueueFamilyProperties{}); |
| 51 |
vk->GetPhysicalDeviceQueueFamilyProperties(phys_dev, &nProps, props.data()); |
| 52 |
// Choose the first graphics queue. |
| 53 |
for (uint32_t i = 0; i < nProps; ++i) { |
| 54 |
if ((props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && props[i].queueCount > 0) { |
| 55 |
family_idx = i; |
| 56 |
break; |
| 57 |
} |
| 58 |
} |
| 59 |
|
| 60 |
return family_idx; |
| 61 |
} |
| 62 |
|
| 63 |
bool GfxStreamVulkanMapper::initialize(DeviceId& deviceId) { |
| 64 |
mLoaderLib = util_dl_open(VK_LIBNAME); |
| 65 |
if (!mLoaderLib) { |
| 66 |
mesa_loge("failed to get loader library"); |
| 67 |
return false; |
| 68 |
} |
| 69 |
|
| 70 |
VkResult res; |
| 71 |
|
| 72 |
auto vk_GetInstanceProcAddr = |
| 73 |
(PFN_vkGetInstanceProcAddr)util_dl_get_proc_address(mLoaderLib, "vkGetInstanceProcAddr"); |
| 74 |
auto vk_GetDeviceProcAddr = |
| 75 |
(PFN_vkGetDeviceProcAddr)util_dl_get_proc_address(mLoaderLib, "vkGetDeviceProcAddr"); |
| 76 |
|
| 77 |
if (!vk_GetInstanceProcAddr || !vk_GetDeviceProcAddr) { |
| 78 |
mesa_loge("failed to get devuce or instance ProcAddr"); |
| 79 |
return false; |
| 80 |
} |
| 81 |
|
| 82 |
std::vector<const char*> externalMemoryInstanceExtNames = { |
| 83 |
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, |
| 84 |
}; |
| 85 |
|
| 86 |
VkInstanceCreateInfo instCi = { |
| 87 |
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, 0, 0, nullptr, 0, nullptr, 0, nullptr, |
| 88 |
}; |
| 89 |
|
| 90 |
VkApplicationInfo appInfo = { |
| 91 |
VK_STRUCTURE_TYPE_APPLICATION_INFO, |
| 92 |
0, |
| 93 |
"gfxstream_vk_mapper", |
| 94 |
1, |
| 95 |
"gfxstream_vk_mapper", |
| 96 |
1, |
| 97 |
VK_API_VERSION_1_1, |
| 98 |
}; |
| 99 |
|
| 100 |
instCi.pApplicationInfo = &appInfo; |
| 101 |
instCi.enabledExtensionCount = static_cast<uint32_t>(externalMemoryInstanceExtNames.size()); |
| 102 |
instCi.ppEnabledExtensionNames = externalMemoryInstanceExtNames.data(); |
| 103 |
|
| 104 |
GET_PROC_ADDR_INSTANCE_LOCAL(CreateInstance); |
| 105 |
res = vk_CreateInstance(&instCi, nullptr, &mInstance); |
| 106 |
if (res != VK_SUCCESS) { |
| 107 |
mesa_loge("failed to create VkMapper Instance"); |
| 108 |
return false; |
| 109 |
} |
| 110 |
|
| 111 |
vk_instance_uncompacted_dispatch_table_load(&mVk.instance, vk_GetInstanceProcAddr, mInstance); |
| 112 |
vk_physical_device_uncompacted_dispatch_table_load(&mVk.physical_device, vk_GetInstanceProcAddr, |
| 113 |
mInstance); |
| 114 |
|
| 115 |
uint32_t physicalDeviceCount = 0; |
| 116 |
std::vector<VkPhysicalDevice> physicalDevices; |
| 117 |
res = mVk.EnumeratePhysicalDevices(mInstance, &physicalDeviceCount, nullptr); |
| 118 |
if (res != VK_SUCCESS) { |
| 119 |
mesa_loge("failed to get physical device count"); |
| 120 |
return false; |
| 121 |
} |
| 122 |
|
| 123 |
physicalDevices.resize(physicalDeviceCount); |
| 124 |
res = mVk.EnumeratePhysicalDevices(mInstance, &physicalDeviceCount, physicalDevices.data()); |
| 125 |
if (res != VK_SUCCESS) { |
| 126 |
mesa_loge("failed to enumerate physical devices"); |
| 127 |
return false; |
| 128 |
} |
| 129 |
|
| 130 |
for (uint32_t i = 0; i < physicalDeviceCount; i++) { |
| 131 |
VkPhysicalDeviceIDProperties idProps = { |
| 132 |
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, |
| 133 |
}; |
| 134 |
|
| 135 |
VkPhysicalDeviceProperties2 deviceProps = { |
| 136 |
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, |
| 137 |
.pNext = reinterpret_cast<void*>(&idProps), |
| 138 |
}; |
| 139 |
|
| 140 |
mVk.GetPhysicalDeviceProperties2(physicalDevices[i], &deviceProps); |
| 141 |
if (memcmp(&idProps.deviceUUID[0], &deviceId.deviceUUID[0], VK_UUID_SIZE)) { |
| 142 |
continue; |
| 143 |
} |
| 144 |
|
| 145 |
if (memcmp(&idProps.driverUUID[0], &deviceId.driverUUID[0], VK_UUID_SIZE)) { |
| 146 |
continue; |
| 147 |
} |
| 148 |
|
| 149 |
std::vector<const char*> externalMemoryDeviceExtNames; |
| 150 |
externalMemoryDeviceExtNames.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); |
| 151 |
|
| 152 |
#if DETECT_OS_WINDOWS |
| 153 |
externalMemoryDeviceExtNames.push_back(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); |
| 154 |
#elif DETECT_OS_LINUX |
| 155 |
externalMemoryDeviceExtNames.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME); |
| 156 |
|
| 157 |
// Tesla V-100 doesn't work with dma-buf |
| 158 |
if (deviceProps.properties.vendorID != kNvidiaVendorId) { |
| 159 |
externalMemoryDeviceExtNames.push_back(VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME); |
| 160 |
} |
| 161 |
#endif |
| 162 |
|
| 163 |
VkPhysicalDevice physDev = physicalDevices[i]; |
| 164 |
uint32_t gfxQueueFamilyIdx = chooseGfxQueueFamily(&mVk, physDev); |
| 165 |
if (gfxQueueFamilyIdx == UINT32_MAX) { |
| 166 |
mesa_loge("failed to get gfx queue family idx"); |
| 167 |
return false; |
| 168 |
} |
| 169 |
|
| 170 |
float priority = 1.0f; |
| 171 |
VkDeviceQueueCreateInfo dqCi = { |
| 172 |
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, 0, 0, gfxQueueFamilyIdx, 1, &priority, |
| 173 |
}; |
| 174 |
|
| 175 |
VkDeviceCreateInfo dCi = {}; |
| 176 |
dCi.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; |
| 177 |
dCi.queueCreateInfoCount = 1; |
| 178 |
dCi.pQueueCreateInfos = &dqCi; |
| 179 |
dCi.enabledExtensionCount = static_cast<uint32_t>(externalMemoryDeviceExtNames.size()); |
| 180 |
dCi.ppEnabledExtensionNames = externalMemoryDeviceExtNames.data(); |
| 181 |
res = mVk.CreateDevice(physDev, &dCi, nullptr, &mDevice); |
| 182 |
if (res != VK_SUCCESS) { |
| 183 |
mesa_loge("failed to create device"); |
| 184 |
return false; |
| 185 |
} |
| 186 |
} |
| 187 |
|
| 188 |
vk_device_uncompacted_dispatch_table_load(&mVk.device, vk_GetDeviceProcAddr, mDevice); |
| 189 |
|
| 190 |
return true; |
| 191 |
} |
| 192 |
|
| 193 |
// The Tesla V-100 driver seems to enter a power management mode and stops being available to |
| 194 |
// the Vulkan loader if more than a certain number of VK instances are created in the same |
| 195 |
// process. |
| 196 |
// |
| 197 |
// This behavior is reproducible via: |
| 198 |
// |
| 199 |
// GfxstreamEnd2EndTests --gtest_filter="*MultiThreadedVkMapMemory*" |
| 200 |
// |
| 201 |
// Workaround this by having a singleton mapper per-process. |
| 202 |
GfxStreamVulkanMapper* GfxStreamVulkanMapper::getInstance(std::optional<DeviceId> deviceIdOpt) { |
| 203 |
if (sVkMapper == nullptr && deviceIdOpt) { |
| 204 |
// The idea is to make sure the gfxstream ICD isn't loaded when the mapper starts |
| 205 |
// up. The Nvidia ICD should be loaded. |
| 206 |
// |
| 207 |
// This is mostly useful for developers. For AOSP hermetic gfxstream end2end |
| 208 |
// testing, VK_DRIVER_FILES shouldn't be defined. For deqp-vk, this is |
| 209 |
// useful, but not safe for multi-threaded tests. For now, since this is only |
| 210 |
// used for end2end tests, we should be good. |
| 211 |
char* driver = os_get_option_dup(VK_DRIVER_FILES); |
| 212 |
|
| 213 |
os_unset_option(VK_DRIVER_FILES); |
| 214 |
sVkMapper = std::make_unique<GfxStreamVulkanMapper>(); |
| 215 |
if (!sVkMapper->initialize(*deviceIdOpt)) { |
| 216 |
sVkMapper = nullptr; |
| 217 |
return nullptr; |
| 218 |
} |
| 219 |
|
| 220 |
if (driver) { |
| 221 |
os_set_option(VK_DRIVER_FILES, driver, true); |
| 222 |
} |
| 223 |
free(driver); |
| 224 |
} |
| 225 |
|
| 226 |
return sVkMapper.get(); |
| 227 |
} |
| 228 |
|
| 229 |
int32_t GfxStreamVulkanMapper::map(struct VulkanMapperData* mapData) { |
| 230 |
VkMemoryAllocateInfo mai = {}; |
| 231 |
|
| 232 |
mai.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; |
| 233 |
mai.allocationSize = mapData->size; |
| 234 |
mai.memoryTypeIndex = mapData->memoryIdx; |
| 235 |
|
| 236 |
#if DETECT_OS_WINDOWS |
| 237 |
VkImportMemoryWin32HandleInfoKHR importInfo{ |
| 238 |
VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, |
| 239 |
0, |
| 240 |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, |
| 241 |
reinterpret_cast<HANDLE>(mapData->handle), |
| 242 |
L"", |
| 243 |
}; |
| 244 |
|
| 245 |
#elif DETECT_OS_LINUX |
| 246 |
VkExternalMemoryHandleTypeFlagBits flagBits; |
| 247 |
if (mapData->handleType == VIRTGPU_KUMQUAT_HANDLE_TYPE_MEM_DMABUF) { |
| 248 |
flagBits = (enum VkExternalMemoryHandleTypeFlagBits)(uint32_t(VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)); |
| 249 |
} else { |
| 250 |
flagBits = (enum VkExternalMemoryHandleTypeFlagBits)(uint32_t(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)); |
| 251 |
} |
| 252 |
|
| 253 |
VkImportMemoryFdInfoKHR importInfo{ |
| 254 |
VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, |
| 255 |
0, |
| 256 |
flagBits, |
| 257 |
static_cast<int>(mapData->handle), |
| 258 |
}; |
| 259 |
#endif |
| 260 |
|
| 261 |
mai.pNext = reinterpret_cast<void*>(&importInfo); |
| 262 |
|
| 263 |
VkResult result = mVk.AllocateMemory(mDevice, &mai, nullptr, &mapData->memory); |
| 264 |
if (result != VK_SUCCESS) { |
| 265 |
mesa_loge("failed to import memory"); |
| 266 |
return -EINVAL; |
| 267 |
} |
| 268 |
|
| 269 |
result = mVk.MapMemory(mDevice, mapData->memory, 0, mapData->size, 0, (void**)&mapData->ptr); |
| 270 |
if (result != VK_SUCCESS) { |
| 271 |
mesa_loge("failed to map memory"); |
| 272 |
return -EINVAL; |
| 273 |
} |
| 274 |
|
| 275 |
return 0; |
| 276 |
} |
| 277 |
|
| 278 |
void GfxStreamVulkanMapper::unmap(struct VulkanMapperData* mapData) { |
| 279 |
mVk.UnmapMemory(mDevice, mapData->memory); |
| 280 |
mVk.FreeMemory(mDevice, mapData->memory, nullptr); |
| 281 |
} |