Debian Codegraph @

src/gfxstream/guest/platform/drm/DrmVirtGpuDevice.cpp

raw
1 /*
2 * Copyright 2022 Google
3 * SPDX-License-Identifier: MIT
4 */
5
6 #include <fcntl.h>
7 #include <pthread.h>
8 #include <stdlib.h>
9 #include <sys/mman.h>
10 #include <sys/stat.h>
11 #include <unistd.h>
12 #include <xf86drm.h>
13
14 #include <cerrno>
15 #include <cstring>
16 #include <fstream>
17 #include <string>
18
19 #include "DrmVirtGpu.h"
20 #include "drm-uapi/virtgpu_drm.h"
21 #include "util/detect_os.h"
22 #include "util/log.h"
23 #include "util/os_misc.h"
24
25 #ifdef MAJOR_IN_MKDEV
26 #include <sys/mkdev.h>
27 #endif
28 #ifdef MAJOR_IN_SYSMACROS
29 #include <sys/sysmacros.h>
30 #endif
31
32 #define VIRTGPU_PCI_VENDOR_ID 0x1af4
33 #define VIRTGPU_PCI_DEVICE_ID 0x1050
34
35 #define VIRTGPU_PARAM_CREATE_FENCE_PASSING 9 /* Fence passing */
36 #define VIRTGPU_PARAM_CREATE_GUEST_HANDLE 10 /* Host OS handle can be created from guest memory. */
37
38 #define PARAM(x) \
39 (struct VirtGpuParam) { x, #x, 0 }
40
41 static inline uint32_t align_up(uint32_t n, uint32_t a) { return ((n + a - 1) / a) * a; }
42
43 int32_t DrmVirtGpuDevice::openDevice() {
44 drmDevicePtr devs[8];
45 int32_t ret = -EINVAL;
46 int count = drmGetDevices2(0, devs, ARRAY_SIZE(devs));
47 if (count <= 0) {
48 mesa_logd("failed to enumerate DRM devices");
49 goto out;
50 }
51
52 for (int i = 0; i < count; i++) {
53 drmDevicePtr dev = devs[i];
54 bool supported_bus = false;
55
56 switch (dev->bustype) {
57 case DRM_BUS_PCI:
58 if (dev->deviceinfo.pci->vendor_id == VIRTGPU_PCI_VENDOR_ID &&
59 dev->deviceinfo.pci->device_id == VIRTGPU_PCI_DEVICE_ID)
60 supported_bus = true;
61 break;
62 case DRM_BUS_PLATFORM:
63 supported_bus = true;
64 break;
65 default:
66 break;
67 }
68
69 if (!supported_bus || !(dev->available_nodes & (1 << DRM_NODE_RENDER))) {
70 const char* name = "unknown";
71 for (uint32_t i = 0; i < DRM_NODE_MAX; i++) {
72 if (dev->available_nodes & (1 << i)) {
73 name = dev->nodes[i];
74 break;
75 }
76 }
77
78 mesa_logd("skipping DRM device %s", name);
79 continue;
80 }
81
82 const char* primary_path = dev->nodes[DRM_NODE_PRIMARY];
83 const char* node_path = dev->nodes[DRM_NODE_RENDER];
84
85 int fd = open(node_path, O_RDWR | O_CLOEXEC);
86 if (fd < 0) {
87 mesa_logd("failed to open %s", node_path);
88 ret = -errno;
89 goto out;
90 }
91
92 drmVersionPtr version = drmGetVersion(fd);
93 if (!version || strcmp(version->name, "virtio_gpu") || version->version_major != 0) {
94 if (version) {
95 mesa_logd("unknown DRM driver %s version %d", version->name,
96 version->version_major);
97 } else {
98 mesa_logd("failed to get DRM driver version");
99 }
100
101 if (version) {
102 drmFreeVersion(version);
103 }
104
105 close(fd);
106 ret = -errno;
107 goto out;
108 }
109
110 struct stat st;
111 if (stat(primary_path, &st) == 0) {
112 mHasPrimary = true;
113 mPrimaryMajor = major(st.st_rdev);
114 mPrimaryMinor = minor(st.st_rdev);
115 } else {
116 mHasPrimary = false;
117 mPrimaryMajor = 0;
118 mPrimaryMinor = 0;
119 }
120
121 stat(node_path, &st);
122 mRenderMajor = major(st.st_rdev);
123 mRenderMinor = minor(st.st_rdev);
124
125 mBusType = dev->bustype;
126 if (dev->bustype == DRM_BUS_PCI) {
127 mPciBusInfo = *dev->businfo.pci;
128 }
129
130 drmFreeVersion(version);
131 mesa_logd("using DRM device %s", node_path);
132
133 mDeviceHandle = static_cast<int64_t>(fd);
134 ret = 0;
135 break;
136 }
137
138 out:
139 drmFreeDevices(devs, count);
140 return ret;
141 }
142
143 DrmVirtGpuDevice::DrmVirtGpuDevice(enum VirtGpuCapset capset) : VirtGpuDevice(capset) {}
144
145 int32_t DrmVirtGpuDevice::init(int32_t descriptor) {
146 struct VirtGpuParam params[] = {
147 PARAM(VIRTGPU_PARAM_3D_FEATURES), PARAM(VIRTGPU_PARAM_CAPSET_QUERY_FIX),
148 PARAM(VIRTGPU_PARAM_RESOURCE_BLOB), PARAM(VIRTGPU_PARAM_HOST_VISIBLE),
149 PARAM(VIRTGPU_PARAM_CROSS_DEVICE), PARAM(VIRTGPU_PARAM_CONTEXT_INIT),
150 PARAM(VIRTGPU_PARAM_SUPPORTED_CAPSET_IDs), PARAM(VIRTGPU_PARAM_EXPLICIT_DEBUG_NAME),
151 PARAM(VIRTGPU_PARAM_CREATE_FENCE_PASSING),
152 PARAM(VIRTGPU_PARAM_CREATE_GUEST_HANDLE),
153 };
154
155 int ret = -EINVAL;
156 struct drm_virtgpu_get_caps get_caps = {0};
157 struct drm_virtgpu_context_init init = {0};
158 struct drm_virtgpu_context_set_param ctx_set_params[3] = {{0}};
159 const char* processName = nullptr;
160
161 memset(&mCaps, 0, sizeof(struct VirtGpuCaps));
162
163 #if DETECT_OS_ANDROID
164 processName = getprogname();
165 #endif
166
167 if (descriptor < 0) {
168 #if DETECT_OS_ANDROID
169 // Somebody needs to modify CF's SELinux rules to account for the syscalls used by
170 // drmGetDevices2().
171 mDeviceHandle = static_cast<int64_t>(drmOpenRender(128));
172 if (mDeviceHandle < 0) {
173 mesa_loge("Failed to open rendernode: %s", strerror(errno));
174 return -EINVAL;
175 }
176 #else
177 ret = openDevice();
178 if (ret < 0) {
179 mesa_logd("no virtio_gpu devices found");
180 return ret;
181 }
182 #endif
183 } else {
184 mDeviceHandle = dup(descriptor);
185 if (mDeviceHandle < 0) {
186 mesa_loge("Failed to dup rendernode: %s", strerror(errno));
187 return ret;
188 }
189 }
190
191 for (uint32_t i = 0; i < kParamMax; i++) {
192 struct drm_virtgpu_getparam get_param = {0};
193 get_param.param = params[i].param;
194 get_param.value = (uint64_t)(uintptr_t)&params[i].value;
195
196 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GETPARAM, &get_param);
197 if (ret) {
198 mesa_logd("Could not query virtgpu param from device: %s", params[i].name);
199 continue;
200 }
201
202 mCaps.params[i] = params[i].value;
203 }
204
205 #if !DETECT_OS_ANDROID
206 if ((mCaps.params[kParamSupportedCapsetIds] & (1 << VIRTGPU_DRM_CAPSET_GFXSTREAM_VULKAN)) ==
207 0) {
208 return -EINVAL;
209 }
210 #endif
211
212 auto capset = getCapset();
213 get_caps.cap_set_id = static_cast<uint32_t>(capset);
214 switch (capset) {
215 case kCapsetGfxStreamVulkan:
216 get_caps.size = sizeof(struct vulkanCapset);
217 get_caps.addr = (unsigned long long)&mCaps.vulkanCapset;
218 break;
219 case kCapsetGfxStreamGles:
220 get_caps.size = sizeof(struct glesCapset);
221 get_caps.addr = (unsigned long long)&mCaps.glesCapset;
222 break;
223 case kCapsetGfxStreamComposer:
224 get_caps.size = sizeof(struct composerCapset);
225 get_caps.addr = (unsigned long long)&mCaps.composerCapset;
226 break;
227 default:
228 get_caps.size = 0;
229 }
230
231 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GET_CAPS, &get_caps);
232 if (ret) {
233 // Don't fail get capabilities just yet, AEMU doesn't use this API
234 // yet (b/272121235);
235 mesa_loge("DRM_IOCTL_VIRTGPU_GET_CAPS failed with %s", strerror(errno));
236 }
237
238 // We always need an ASG blob in some cases, so always define blobAlignment
239 if (!mCaps.vulkanCapset.blobAlignment) {
240 mCaps.vulkanCapset.blobAlignment = 4096;
241 }
242
243 uint64_t guest_page_size = 4096;
244 os_get_page_size(&guest_page_size);
245 mCaps.vulkanCapset.blobAlignment =
246 std::max((uint32_t)guest_page_size, mCaps.vulkanCapset.blobAlignment);
247
248 ctx_set_params[0].param = VIRTGPU_CONTEXT_PARAM_NUM_RINGS;
249 ctx_set_params[0].value = 2;
250 init.num_params = 1;
251
252 if (capset != kCapsetNone) {
253 ctx_set_params[init.num_params].param = VIRTGPU_CONTEXT_PARAM_CAPSET_ID;
254 ctx_set_params[init.num_params].value = static_cast<uint32_t>(capset);
255 init.num_params++;
256 }
257
258 if (mCaps.params[kParamExplicitDebugName] && processName) {
259 ctx_set_params[init.num_params].param = VIRTGPU_CONTEXT_PARAM_DEBUG_NAME;
260 ctx_set_params[init.num_params].value = reinterpret_cast<uint64_t>(processName);
261 init.num_params++;
262 }
263
264 init.ctx_set_params = (unsigned long long)&ctx_set_params[0];
265 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_CONTEXT_INIT, &init);
266 if (ret) {
267 mesa_loge("DRM_IOCTL_VIRTGPU_CONTEXT_INIT failed with %s, continuing without context...",
268 strerror(errno));
269 }
270
271 return 0;
272 }
273
274 DrmVirtGpuDevice::~DrmVirtGpuDevice() { close(mDeviceHandle); }
275
276 struct VirtGpuCaps DrmVirtGpuDevice::getCaps(void) { return mCaps; }
277
278 int64_t DrmVirtGpuDevice::getDeviceHandle(void) { return mDeviceHandle; }
279
280 VirtGpuResourcePtr DrmVirtGpuDevice::createResource(uint32_t width, uint32_t height,
281 uint32_t stride, uint32_t size,
282 uint32_t virglFormat, uint32_t target,
283 uint32_t bind) {
284 drm_virtgpu_resource_create create = {
285 .target = target,
286 .format = virglFormat,
287 .bind = bind,
288 .width = width,
289 .height = height,
290 .depth = 1U,
291 .array_size = 1U,
292 .last_level = 0,
293 .nr_samples = 0,
294 .size = size,
295 .stride = stride,
296 };
297
298 int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
299 if (ret) {
300 mesa_loge("DRM_IOCTL_VIRTGPU_RESOURCE_CREATE failed with %s", strerror(errno));
301 return nullptr;
302 }
303
304 return std::make_shared<DrmVirtGpuResource>(
305 mDeviceHandle, create.bo_handle, create.res_handle, static_cast<uint64_t>(create.size));
306 }
307
308 VirtGpuResourcePtr DrmVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
309 int ret;
310 struct drm_virtgpu_resource_create_blob create = {0};
311
312 create.size = blobCreate.size;
313 create.blob_mem = blobCreate.blobMem;
314 create.blob_flags = blobCreate.flags;
315 create.blob_id = blobCreate.blobId;
316 create.cmd = (uint64_t)(uintptr_t)blobCreate.blobCmd;
317 create.cmd_size = blobCreate.blobCmdSize;
318
319 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB, &create);
320 if (ret < 0) {
321 mesa_loge("DRM_VIRTGPU_RESOURCE_CREATE_BLOB failed with %s", strerror(errno));
322 return nullptr;
323 }
324
325 return std::make_shared<DrmVirtGpuResource>(mDeviceHandle, create.bo_handle,
326 create.res_handle, blobCreate.size);
327 }
328
329 VirtGpuResourcePtr DrmVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
330 struct drm_virtgpu_resource_info info = {0};
331 uint32_t blobHandle;
332 int ret;
333
334 ret = drmPrimeFDToHandle(mDeviceHandle, handle.osHandle, &blobHandle);
335 close(handle.osHandle);
336 if (ret) {
337 mesa_loge("DRM_IOCTL_PRIME_FD_TO_HANDLE failed: %s", strerror(errno));
338 return nullptr;
339 }
340
341 info.bo_handle = blobHandle;
342 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, &info);
343 if (ret) {
344 mesa_loge("DRM_IOCTL_VIRTGPU_RESOURCE_INFO failed: %s", strerror(errno));
345 return nullptr;
346 }
347
348 return std::make_shared<DrmVirtGpuResource>(mDeviceHandle, blobHandle, info.res_handle,
349 static_cast<uint64_t>(info.size));
350 }
351
352 int DrmVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer,
353 const VirtGpuResource* blob) {
354 int ret;
355 struct drm_virtgpu_execbuffer exec = {0};
356 uint32_t blobHandle;
357
358 exec.flags = execbuffer.flags;
359 exec.size = execbuffer.command_size;
360 exec.ring_idx = execbuffer.ring_idx;
361 exec.command = (uint64_t)(uintptr_t)(execbuffer.command);
362 exec.fence_fd = -1;
363
364 if (blob) {
365 blobHandle = blob->getBlobHandle();
366 exec.bo_handles = (uint64_t)(uintptr_t)(&blobHandle);
367 exec.num_bo_handles = 1;
368 }
369
370 ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_EXECBUFFER, &exec);
371 if (ret) {
372 mesa_loge("DRM_IOCTL_VIRTGPU_EXECBUFFER failed: %s", strerror(errno));
373 return ret;
374 }
375
376 if (execbuffer.flags & kFenceOut) {
377 execbuffer.handle.osHandle = exec.fence_fd;
378 execbuffer.handle.type = kFenceHandleSyncFd;
379 }
380
381 return 0;
382 }
383
384 VirtGpuDevice* osCreateVirtGpuDevice(enum VirtGpuCapset capset, int32_t descriptor) {
385 auto device = new DrmVirtGpuDevice(capset);
386 int32_t ret = device->init(descriptor);
387 if (ret) {
388 delete device;
389 return nullptr;
390 }
391
392 return device;
393 }
394
395 bool DrmVirtGpuDevice::getDrmInfo(VirtGpuDrmInfo* drmInfo) {
396 drmInfo->hasPrimary = mHasPrimary;
397 drmInfo->hasRender = true;
398 drmInfo->primaryMajor = mPrimaryMajor;
399 drmInfo->primaryMinor = mPrimaryMinor;
400 drmInfo->renderMajor = mRenderMajor;
401 drmInfo->renderMinor = mRenderMinor;
402 return true;
403 }
404
405 bool DrmVirtGpuDevice::getPciBusInfo(VirtGpuPciBusInfo* pciBusInfo) {
406 if (mBusType != DRM_BUS_PCI) {
407 return false;
408 }
409
410 pciBusInfo->domain = mPciBusInfo.domain;
411 pciBusInfo->bus = mPciBusInfo.bus;
412 pciBusInfo->device = mPciBusInfo.dev;
413 pciBusInfo->function = mPciBusInfo.func;
414 return true;
415 }