v3d: Introduce a DRM shim for calling out to the simulator.
[mesa.git] / src / drm-shim / drm_shim.c
1 /*
2 * Copyright © 2018 Broadcom
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /**
25 * @file
26 *
27 * Implements wrappers of libc functions to fake having a DRM device that
28 * isn't actually present in the kernel.
29 */
30
31 /* Prevent glibc from defining open64 when we want to alias it. */
32 #undef _FILE_OFFSET_BITS
33 #define _LARGEFILE64_SOURCE
34
35 #include <stdbool.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <sys/ioctl.h>
41 #include <sys/mman.h>
42 #include <sys/stat.h>
43 #include <sys/sysmacros.h>
44 #include <stdarg.h>
45 #include <fcntl.h>
46 #include <dlfcn.h>
47 #include <dirent.h>
48 #include <c11/threads.h>
49 #include <drm-uapi/drm.h>
50
51 #include "util/set.h"
52 #include "util/u_debug.h"
53 #include "drm_shim.h"
54
55 #define REAL_FUNCTION_POINTER(x) typeof(x) *real_##x
56
57 static mtx_t shim_lock = _MTX_INITIALIZER_NP;
58 struct set *opendir_set;
59 bool drm_shim_debug;
60
61 /* If /dev/dri doesn't exist, we'll need an arbitrary pointer that wouldn't be
62 * returned by any other opendir() call so we can return just our fake node.
63 */
64 DIR *fake_dev_dri = (void *)&opendir_set;
65
66 /* XXX: implement REAL_FUNCTION_POINTER(close); */
67 REAL_FUNCTION_POINTER(closedir);
68 REAL_FUNCTION_POINTER(dup);
69 REAL_FUNCTION_POINTER(fcntl);
70 REAL_FUNCTION_POINTER(fopen);
71 REAL_FUNCTION_POINTER(ioctl);
72 REAL_FUNCTION_POINTER(mmap);
73 REAL_FUNCTION_POINTER(open);
74 REAL_FUNCTION_POINTER(opendir);
75 REAL_FUNCTION_POINTER(readdir);
76 REAL_FUNCTION_POINTER(readdir64);
77 REAL_FUNCTION_POINTER(readlink);
78 REAL_FUNCTION_POINTER(__xstat);
79 REAL_FUNCTION_POINTER(__xstat64);
80 REAL_FUNCTION_POINTER(__fxstat);
81 REAL_FUNCTION_POINTER(__fxstat64);
82
83 /* Full path of /dev/dri/renderD* */
84 static char *render_node_path;
85 /* renderD* */
86 static char *render_node_dirent_name;
87 /* /sys/dev/char/major:minor/device/subsystem */
88 static char *subsystem_path;
89 int render_node_minor = -1;
90
91 struct file_override {
92 const char *path;
93 char *contents;
94 };
95 static struct file_override file_overrides[10];
96 static int file_overrides_count;
97
98 /* Come up with a filename for a render node that doesn't actually exist on
99 * the system.
100 */
101 static void
102 get_dri_render_node_minor(void)
103 {
104 for (int i = 0; i < 10; i++) {
105 int minor = 128 + i;
106 asprintf(&render_node_dirent_name, "renderD%d", minor);
107 asprintf(&render_node_path, "/dev/dri/%s",
108 render_node_dirent_name);
109 struct stat st;
110 if (stat(render_node_path, &st) == -1) {
111
112 render_node_minor = minor;
113 return;
114 }
115 }
116
117 fprintf(stderr, "Couldn't find a spare render node slot\n");
118 }
119
120 static void *get_function_pointer(const char *name)
121 {
122 void *func = dlsym(RTLD_NEXT, name);
123 if (!func) {
124 fprintf(stderr, "Failed to resolve %s\n", name);
125 abort();
126 }
127 return func;
128 }
129
130 #define GET_FUNCTION_POINTER(x) real_##x = get_function_pointer(#x)
131
132 void
133 drm_shim_override_file(const char *contents, const char *path_format, ...)
134 {
135 assert(file_overrides_count < ARRAY_SIZE(file_overrides));
136
137 char *path;
138 va_list ap;
139 va_start(ap, path_format);
140 vasprintf(&path, path_format, ap);
141 va_end(ap);
142
143 struct file_override *override = &file_overrides[file_overrides_count++];
144 override->path = path;
145 override->contents = strdup(contents);
146 }
147
148 static void
149 destroy_shim(void)
150 {
151 _mesa_set_destroy(opendir_set, NULL);
152 free(render_node_path);
153 free(render_node_dirent_name);
154 free(subsystem_path);
155 }
156
157 /* Initialization, which will be called from the first general library call
158 * that might need to be wrapped with the shim.
159 */
160 static void
161 init_shim(void)
162 {
163 static bool inited = false;
164 drm_shim_debug = debug_get_bool_option("DRM_SHIM_DEBUG", false);
165
166 /* We can't lock this, because we recurse during initialization. */
167 if (inited)
168 return;
169
170 /* This comes first (and we're locked), to make sure we don't recurse
171 * during initialization.
172 */
173 inited = true;
174
175 opendir_set = _mesa_set_create(NULL,
176 _mesa_hash_string,
177 _mesa_key_string_equal);
178
179 GET_FUNCTION_POINTER(closedir);
180 GET_FUNCTION_POINTER(dup);
181 GET_FUNCTION_POINTER(fcntl);
182 GET_FUNCTION_POINTER(fopen);
183 GET_FUNCTION_POINTER(ioctl);
184 GET_FUNCTION_POINTER(mmap);
185 GET_FUNCTION_POINTER(open);
186 GET_FUNCTION_POINTER(opendir);
187 GET_FUNCTION_POINTER(readdir);
188 GET_FUNCTION_POINTER(readdir64);
189 GET_FUNCTION_POINTER(readlink);
190 GET_FUNCTION_POINTER(__xstat);
191 GET_FUNCTION_POINTER(__xstat64);
192 GET_FUNCTION_POINTER(__fxstat);
193 GET_FUNCTION_POINTER(__fxstat64);
194
195 get_dri_render_node_minor();
196
197 if (drm_shim_debug) {
198 fprintf(stderr, "Initializing DRM shim on %s\n",
199 render_node_path);
200 }
201
202 asprintf(&subsystem_path,
203 "/sys/dev/char/%d:%d/device/subsystem",
204 DRM_MAJOR, render_node_minor);
205
206 drm_shim_device_init();
207
208 atexit(destroy_shim);
209 }
210
211 /* Override libdrm's reading of various sysfs files for device enumeration. */
212 PUBLIC FILE *fopen(const char *path, const char *mode)
213 {
214 init_shim();
215
216 for (int i = 0; i < file_overrides_count; i++) {
217 if (strcmp(file_overrides[i].path, path) == 0) {
218 int fds[2];
219 pipe(fds);
220 write(fds[1], file_overrides[i].contents,
221 strlen(file_overrides[i].contents));
222 return fdopen(fds[0], "r");
223 }
224 }
225
226 return real_fopen(path, mode);
227 }
228 PUBLIC FILE *fopen64(const char *path, const char *mode)
229 __attribute__((alias("fopen")));
230
231 /* Intercepts open(render_node_path) to redirect it to the simulator. */
232 PUBLIC int open(const char *path, int flags, ...)
233 {
234 init_shim();
235
236 va_list ap;
237 va_start(ap, flags);
238 mode_t mode = va_arg(ap, mode_t);
239 va_end(ap);
240
241 if (strcmp(path, render_node_path) != 0)
242 return real_open(path, flags, mode);
243
244 int fd = real_open("/dev/null", O_RDWR, 0);
245
246 drm_shim_fd_register(fd, NULL);
247
248 return fd;
249 }
250 PUBLIC int open64(const char*, int, ...) __attribute__((alias("open")));
251
252 /* Fakes stat to return character device stuff for our fake render node. */
253 PUBLIC int __xstat(int ver, const char *path, struct stat *st)
254 {
255 init_shim();
256
257 /* Note: call real stat if we're in the process of probing for a free
258 * render node!
259 */
260 if (render_node_minor == -1)
261 return real___xstat(ver, path, st);
262
263 /* Fool libdrm's probe of whether the /sys dir for this char dev is
264 * there.
265 */
266 char *sys_dev_drm_dir;
267 asprintf(&sys_dev_drm_dir, "/sys/dev/char/%d:%d/device/drm",
268 DRM_MAJOR, render_node_minor);
269 if (strcmp(path, sys_dev_drm_dir) == 0) {
270 free(sys_dev_drm_dir);
271 return 0;
272 }
273 free(sys_dev_drm_dir);
274
275 if (strcmp(path, render_node_path) != 0)
276 return real___xstat(ver, path, st);
277
278 memset(st, 0, sizeof(*st));
279 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
280 st->st_mode = S_IFCHR;
281
282 return 0;
283 }
284
285 /* Fakes stat to return character device stuff for our fake render node. */
286 PUBLIC int __xstat64(int ver, const char *path, struct stat64 *st)
287 {
288 init_shim();
289
290 /* Note: call real stat if we're in the process of probing for a free
291 * render node!
292 */
293 if (render_node_minor == -1)
294 return real___xstat64(ver, path, st);
295
296 /* Fool libdrm's probe of whether the /sys dir for this char dev is
297 * there.
298 */
299 char *sys_dev_drm_dir;
300 asprintf(&sys_dev_drm_dir, "/sys/dev/char/%d:%d/device/drm",
301 DRM_MAJOR, render_node_minor);
302 if (strcmp(path, sys_dev_drm_dir) == 0) {
303 free(sys_dev_drm_dir);
304 return 0;
305 }
306 free(sys_dev_drm_dir);
307
308 if (strcmp(path, render_node_path) != 0)
309 return real___xstat64(ver, path, st);
310
311 memset(st, 0, sizeof(*st));
312 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
313 st->st_mode = S_IFCHR;
314
315 return 0;
316 }
317
318 /* Fakes fstat to return character device stuff for our fake render node. */
319 PUBLIC int __fxstat(int ver, int fd, struct stat *st)
320 {
321 init_shim();
322
323 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
324
325 if (!shim_fd)
326 return real___fxstat(ver, fd, st);
327
328 memset(st, 0, sizeof(*st));
329 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
330 st->st_mode = S_IFCHR;
331
332 return 0;
333 }
334
335 PUBLIC int __fxstat64(int ver, int fd, struct stat64 *st)
336 {
337 init_shim();
338
339 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
340
341 if (!shim_fd)
342 return real___fxstat64(ver, fd, st);
343
344 memset(st, 0, sizeof(*st));
345 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
346 st->st_mode = S_IFCHR;
347
348 return 0;
349 }
350
351 /* Tracks if the opendir was on /dev/dri. */
352 PUBLIC DIR *
353 opendir(const char *name)
354 {
355 init_shim();
356
357 DIR *dir = real_opendir(name);
358 if (strcmp(name, "/dev/dri") == 0) {
359 if (!dir) {
360 /* If /dev/dri didn't exist, we still want to be able to return our
361 * fake /dev/dri/render* even though we probably can't
362 * mkdir("/dev/dri"). Return a fake DIR pointer for that.
363 */
364 dir = fake_dev_dri;
365 }
366
367 mtx_lock(&shim_lock);
368 _mesa_set_add(opendir_set, dir);
369 mtx_unlock(&shim_lock);
370 }
371
372 return dir;
373 }
374
375 /* If we've reached the end of the real directory list and we're
376 * looking at /dev/dri, add our render node to the list.
377 */
378 PUBLIC struct dirent *
379 readdir(DIR *dir)
380 {
381 init_shim();
382
383 struct dirent *ent = NULL;
384
385 if (dir != fake_dev_dri)
386 ent = real_readdir(dir);
387 static struct dirent render_node_dirent = { 0 };
388
389 if (!ent) {
390 mtx_lock(&shim_lock);
391 if (_mesa_set_search(opendir_set, dir)) {
392 strcpy(render_node_dirent.d_name,
393 render_node_dirent_name);
394 ent = &render_node_dirent;
395 _mesa_set_remove_key(opendir_set, dir);
396 }
397 mtx_unlock(&shim_lock);
398 }
399
400 return ent;
401 }
402
403 /* If we've reached the end of the real directory list and we're
404 * looking at /dev/dri, add our render node to the list.
405 */
406 PUBLIC struct dirent64 *
407 readdir64(DIR *dir)
408 {
409 init_shim();
410
411 struct dirent64 *ent = NULL;
412 if (dir != fake_dev_dri)
413 ent = real_readdir64(dir);
414 static struct dirent64 render_node_dirent = { 0 };
415
416 if (!ent) {
417 mtx_lock(&shim_lock);
418 if (_mesa_set_search(opendir_set, dir)) {
419 strcpy(render_node_dirent.d_name,
420 render_node_dirent_name);
421 ent = &render_node_dirent;
422 _mesa_set_remove_key(opendir_set, dir);
423 }
424 mtx_unlock(&shim_lock);
425 }
426
427 return ent;
428 }
429
430 /* Cleans up tracking of opendir("/dev/dri") */
431 PUBLIC int
432 closedir(DIR *dir)
433 {
434 init_shim();
435
436 mtx_lock(&shim_lock);
437 _mesa_set_remove_key(opendir_set, dir);
438 mtx_unlock(&shim_lock);
439
440 if (dir != fake_dev_dri)
441 return real_closedir(dir);
442 else
443 return 0;
444 }
445
446 /* Handles libdrm's readlink to figure out what kind of device we have. */
447 PUBLIC ssize_t
448 readlink(const char *path, char *buf, size_t size)
449 {
450 init_shim();
451
452 if (strcmp(path, subsystem_path) != 0)
453 return real_readlink(path, buf, size);
454 strncpy(buf, "/platform", size);
455 buf[size - 1] = 0;
456
457 return strlen(buf) + 1;
458 }
459
460 /* Main entrypoint to DRM drivers: the ioctl syscall. We send all ioctls on
461 * our DRM fd to drm_shim_ioctl().
462 */
463 PUBLIC int
464 ioctl(int fd, unsigned long request, ...)
465 {
466 init_shim();
467
468 va_list ap;
469 va_start(ap, request);
470 void *arg = va_arg(ap, void *);
471 va_end(ap);
472
473 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
474 if (!shim_fd)
475 return real_ioctl(fd, request, arg);
476
477 return drm_shim_ioctl(fd, request, arg);
478 }
479
480 /* Gallium uses this to dup the incoming fd on gbm screen creation */
481 PUBLIC int
482 fcntl(int fd, int cmd, ...)
483 {
484 init_shim();
485
486 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
487
488 va_list ap;
489 va_start(ap, cmd);
490 void *arg = va_arg(ap, void *);
491 va_end(ap);
492
493 int ret = real_fcntl(fd, cmd, arg);
494
495 if (shim_fd && (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC))
496 drm_shim_fd_register(ret, shim_fd);
497
498 return ret;
499 }
500 PUBLIC int fcntl64(int, int, ...)
501 __attribute__((alias("fcntl")));
502
503 /* I wrote this when trying to fix gallium screen creation, leaving it around
504 * since it's probably good to have.
505 */
506 PUBLIC int
507 dup(int fd)
508 {
509 init_shim();
510
511 int ret = real_dup(fd);
512
513 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
514 if (shim_fd && ret >= 0)
515 drm_shim_fd_register(ret, shim_fd);
516
517 return ret;
518 }
519
520 PUBLIC void *
521 mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
522 {
523 init_shim();
524
525 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
526 if (shim_fd)
527 return drm_shim_mmap(shim_fd, length, prot, flags, fd, offset);
528
529 return real_mmap(addr, length, prot, flags, fd, offset);
530 }
531 PUBLIC void *mmap64(void*, size_t, int, int, int, off_t)
532 __attribute__((alias("mmap")));