Debian Codegraph @

src/gfxstream/guest/platform/kumquat/vulkan-mapper/GfxStreamVulkanMapper.cpp

raw
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 }