Merge tag 'pull-request-2022-07-05' of https://gitlab.com/thuth/qemu into staging
[qemu.git] / contrib / vhost-user-gpu / vugbm.c
1 /*
2 * Virtio vhost-user GPU Device
3 *
4 * DRM helpers
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 */
9
10 #include "qemu/osdep.h"
11 #include "vugbm.h"
12
13 static bool
14 mem_alloc_bo(struct vugbm_buffer *buf)
15 {
16 buf->mmap = g_malloc(buf->width * buf->height * 4);
17 buf->stride = buf->width * 4;
18 return true;
19 }
20
21 static void
22 mem_free_bo(struct vugbm_buffer *buf)
23 {
24 g_free(buf->mmap);
25 }
26
27 static bool
28 mem_map_bo(struct vugbm_buffer *buf)
29 {
30 return buf->mmap != NULL;
31 }
32
33 static void
34 mem_unmap_bo(struct vugbm_buffer *buf)
35 {
36 }
37
38 static void
39 mem_device_destroy(struct vugbm_device *dev)
40 {
41 }
42
43 #ifdef CONFIG_MEMFD
44 struct udmabuf_create {
45 uint32_t memfd;
46 uint32_t flags;
47 uint64_t offset;
48 uint64_t size;
49 };
50
51 #define UDMABUF_CREATE _IOW('u', 0x42, struct udmabuf_create)
52
53 static size_t
54 udmabuf_get_size(struct vugbm_buffer *buf)
55 {
56 return ROUND_UP(buf->width * buf->height * 4, qemu_real_host_page_size());
57 }
58
59 static bool
60 udmabuf_alloc_bo(struct vugbm_buffer *buf)
61 {
62 int ret;
63
64 buf->memfd = memfd_create("udmabuf-bo", MFD_ALLOW_SEALING);
65 if (buf->memfd < 0) {
66 return false;
67 }
68
69 ret = ftruncate(buf->memfd, udmabuf_get_size(buf));
70 if (ret < 0) {
71 close(buf->memfd);
72 return false;
73 }
74
75 ret = fcntl(buf->memfd, F_ADD_SEALS, F_SEAL_SHRINK);
76 if (ret < 0) {
77 close(buf->memfd);
78 return false;
79 }
80
81 buf->stride = buf->width * 4;
82
83 return true;
84 }
85
86 static void
87 udmabuf_free_bo(struct vugbm_buffer *buf)
88 {
89 close(buf->memfd);
90 }
91
92 static bool
93 udmabuf_map_bo(struct vugbm_buffer *buf)
94 {
95 buf->mmap = mmap(NULL, udmabuf_get_size(buf),
96 PROT_READ | PROT_WRITE, MAP_SHARED, buf->memfd, 0);
97 if (buf->mmap == MAP_FAILED) {
98 return false;
99 }
100
101 return true;
102 }
103
104 static bool
105 udmabuf_get_fd(struct vugbm_buffer *buf, int *fd)
106 {
107 struct udmabuf_create create = {
108 .memfd = buf->memfd,
109 .offset = 0,
110 .size = udmabuf_get_size(buf),
111 };
112
113 *fd = ioctl(buf->dev->fd, UDMABUF_CREATE, &create);
114
115 return *fd >= 0;
116 }
117
118 static void
119 udmabuf_unmap_bo(struct vugbm_buffer *buf)
120 {
121 munmap(buf->mmap, udmabuf_get_size(buf));
122 }
123
124 static void
125 udmabuf_device_destroy(struct vugbm_device *dev)
126 {
127 close(dev->fd);
128 }
129 #endif
130
131 #ifdef CONFIG_GBM
132 static bool
133 alloc_bo(struct vugbm_buffer *buf)
134 {
135 struct gbm_device *dev = buf->dev->dev;
136
137 assert(!buf->bo);
138
139 buf->bo = gbm_bo_create(dev, buf->width, buf->height,
140 buf->format,
141 GBM_BO_USE_RENDERING | GBM_BO_USE_LINEAR);
142
143 if (buf->bo) {
144 buf->stride = gbm_bo_get_stride(buf->bo);
145 return true;
146 }
147
148 return false;
149 }
150
151 static void
152 free_bo(struct vugbm_buffer *buf)
153 {
154 gbm_bo_destroy(buf->bo);
155 }
156
157 static bool
158 map_bo(struct vugbm_buffer *buf)
159 {
160 uint32_t stride;
161
162 buf->mmap = gbm_bo_map(buf->bo, 0, 0, buf->width, buf->height,
163 GBM_BO_TRANSFER_READ_WRITE, &stride,
164 &buf->mmap_data);
165
166 assert(stride == buf->stride);
167
168 return buf->mmap != NULL;
169 }
170
171 static void
172 unmap_bo(struct vugbm_buffer *buf)
173 {
174 gbm_bo_unmap(buf->bo, buf->mmap_data);
175 }
176
177 static bool
178 get_fd(struct vugbm_buffer *buf, int *fd)
179 {
180 *fd = gbm_bo_get_fd(buf->bo);
181
182 return *fd >= 0;
183 }
184
185 static void
186 device_destroy(struct vugbm_device *dev)
187 {
188 gbm_device_destroy(dev->dev);
189 }
190 #endif
191
192 void
193 vugbm_device_destroy(struct vugbm_device *dev)
194 {
195 if (!dev->inited) {
196 return;
197 }
198
199 dev->device_destroy(dev);
200 }
201
202 void
203 vugbm_device_init(struct vugbm_device *dev, int fd)
204 {
205 assert(!dev->inited);
206
207 #ifdef CONFIG_GBM
208 if (fd >= 0) {
209 dev->dev = gbm_create_device(fd);
210 }
211 if (dev->dev != NULL) {
212 dev->fd = fd;
213 dev->alloc_bo = alloc_bo;
214 dev->free_bo = free_bo;
215 dev->get_fd = get_fd;
216 dev->map_bo = map_bo;
217 dev->unmap_bo = unmap_bo;
218 dev->device_destroy = device_destroy;
219 dev->inited = true;
220 }
221 #endif
222 #ifdef CONFIG_MEMFD
223 if (!dev->inited && g_file_test("/dev/udmabuf", G_FILE_TEST_EXISTS)) {
224 dev->fd = open("/dev/udmabuf", O_RDWR);
225 if (dev->fd >= 0) {
226 g_debug("Using experimental udmabuf backend");
227 dev->alloc_bo = udmabuf_alloc_bo;
228 dev->free_bo = udmabuf_free_bo;
229 dev->get_fd = udmabuf_get_fd;
230 dev->map_bo = udmabuf_map_bo;
231 dev->unmap_bo = udmabuf_unmap_bo;
232 dev->device_destroy = udmabuf_device_destroy;
233 dev->inited = true;
234 }
235 }
236 #endif
237 if (!dev->inited) {
238 g_debug("Using mem fallback");
239 dev->alloc_bo = mem_alloc_bo;
240 dev->free_bo = mem_free_bo;
241 dev->map_bo = mem_map_bo;
242 dev->unmap_bo = mem_unmap_bo;
243 dev->device_destroy = mem_device_destroy;
244 dev->inited = true;
245 }
246 assert(dev->inited);
247 }
248
249 static bool
250 vugbm_buffer_map(struct vugbm_buffer *buf)
251 {
252 struct vugbm_device *dev = buf->dev;
253
254 return dev->map_bo(buf);
255 }
256
257 static void
258 vugbm_buffer_unmap(struct vugbm_buffer *buf)
259 {
260 struct vugbm_device *dev = buf->dev;
261
262 dev->unmap_bo(buf);
263 }
264
265 bool
266 vugbm_buffer_can_get_dmabuf_fd(struct vugbm_buffer *buffer)
267 {
268 if (!buffer->dev->get_fd) {
269 return false;
270 }
271
272 return true;
273 }
274
275 bool
276 vugbm_buffer_get_dmabuf_fd(struct vugbm_buffer *buffer, int *fd)
277 {
278 if (!vugbm_buffer_can_get_dmabuf_fd(buffer) ||
279 !buffer->dev->get_fd(buffer, fd)) {
280 g_warning("Failed to get dmabuf");
281 return false;
282 }
283
284 if (*fd < 0) {
285 g_warning("error: dmabuf_fd < 0");
286 return false;
287 }
288
289 return true;
290 }
291
292 bool
293 vugbm_buffer_create(struct vugbm_buffer *buffer, struct vugbm_device *dev,
294 uint32_t width, uint32_t height)
295 {
296 buffer->dev = dev;
297 buffer->width = width;
298 buffer->height = height;
299 buffer->format = GBM_FORMAT_XRGB8888;
300 buffer->stride = 0; /* modified during alloc */
301 if (!dev->alloc_bo(buffer)) {
302 g_warning("alloc_bo failed");
303 return false;
304 }
305
306 if (!vugbm_buffer_map(buffer)) {
307 g_warning("map_bo failed");
308 goto err;
309 }
310
311 return true;
312
313 err:
314 dev->free_bo(buffer);
315 return false;
316 }
317
318 void
319 vugbm_buffer_destroy(struct vugbm_buffer *buffer)
320 {
321 struct vugbm_device *dev = buffer->dev;
322
323 vugbm_buffer_unmap(buffer);
324 dev->free_bo(buffer);
325 }