radeonsi: remove redundant si_shader_info:*(clip|cull)* fields
[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(realpath);
79 REAL_FUNCTION_POINTER(__xstat);
80 REAL_FUNCTION_POINTER(__xstat64);
81 REAL_FUNCTION_POINTER(__fxstat);
82 REAL_FUNCTION_POINTER(__fxstat64);
83
84 /* Full path of /dev/dri/renderD* */
85 static char *render_node_path;
86 /* renderD* */
87 static char *render_node_dirent_name;
88 /* /sys/dev/char/major:minor/device */
89 static char *device_path;
90 /* /sys/dev/char/major:minor/device/subsystem */
91 static char *subsystem_path;
92 int render_node_minor = -1;
93
94 struct file_override {
95 const char *path;
96 char *contents;
97 };
98 static struct file_override file_overrides[10];
99 static int file_overrides_count;
100 extern bool drm_shim_driver_prefers_first_render_node;
101
102 #define nfasprintf(...) \
103 { \
104 UNUSED int __ret = asprintf(__VA_ARGS__); \
105 assert(__ret >= 0); \
106 }
107 #define nfvasprintf(...) \
108 { \
109 UNUSED int __ret = vasprintf(__VA_ARGS__); \
110 assert(__ret >= 0); \
111 }
112
113 /* Pick the minor and filename for our shimmed render node. This can be
114 * either a new one that didn't exist on the system, or if the driver wants,
115 * it can replace the first render node.
116 */
117 static void
118 get_dri_render_node_minor(void)
119 {
120 for (int i = 0; i < 10; i++) {
121 UNUSED int minor = 128 + i;
122 nfasprintf(&render_node_dirent_name, "renderD%d", minor);
123 nfasprintf(&render_node_path, "/dev/dri/%s",
124 render_node_dirent_name);
125 struct stat st;
126 if (drm_shim_driver_prefers_first_render_node ||
127 stat(render_node_path, &st) == -1) {
128
129 render_node_minor = minor;
130 return;
131 }
132 }
133
134 fprintf(stderr, "Couldn't find a spare render node slot\n");
135 }
136
137 static void *get_function_pointer(const char *name)
138 {
139 void *func = dlsym(RTLD_NEXT, name);
140 if (!func) {
141 fprintf(stderr, "Failed to resolve %s\n", name);
142 abort();
143 }
144 return func;
145 }
146
147 #define GET_FUNCTION_POINTER(x) real_##x = get_function_pointer(#x)
148
149 void
150 drm_shim_override_file(const char *contents, const char *path_format, ...)
151 {
152 assert(file_overrides_count < ARRAY_SIZE(file_overrides));
153
154 char *path;
155 va_list ap;
156 va_start(ap, path_format);
157 nfvasprintf(&path, path_format, ap);
158 va_end(ap);
159
160 struct file_override *override = &file_overrides[file_overrides_count++];
161 override->path = path;
162 override->contents = strdup(contents);
163 }
164
165 static void
166 destroy_shim(void)
167 {
168 _mesa_set_destroy(opendir_set, NULL);
169 free(render_node_path);
170 free(render_node_dirent_name);
171 free(subsystem_path);
172 }
173
174 /* Initialization, which will be called from the first general library call
175 * that might need to be wrapped with the shim.
176 */
177 static void
178 init_shim(void)
179 {
180 static bool inited = false;
181 drm_shim_debug = debug_get_bool_option("DRM_SHIM_DEBUG", false);
182
183 /* We can't lock this, because we recurse during initialization. */
184 if (inited)
185 return;
186
187 /* This comes first (and we're locked), to make sure we don't recurse
188 * during initialization.
189 */
190 inited = true;
191
192 opendir_set = _mesa_set_create(NULL,
193 _mesa_hash_string,
194 _mesa_key_string_equal);
195
196 GET_FUNCTION_POINTER(closedir);
197 GET_FUNCTION_POINTER(dup);
198 GET_FUNCTION_POINTER(fcntl);
199 GET_FUNCTION_POINTER(fopen);
200 GET_FUNCTION_POINTER(ioctl);
201 GET_FUNCTION_POINTER(mmap);
202 GET_FUNCTION_POINTER(open);
203 GET_FUNCTION_POINTER(opendir);
204 GET_FUNCTION_POINTER(readdir);
205 GET_FUNCTION_POINTER(readdir64);
206 GET_FUNCTION_POINTER(readlink);
207 GET_FUNCTION_POINTER(realpath);
208 GET_FUNCTION_POINTER(__xstat);
209 GET_FUNCTION_POINTER(__xstat64);
210 GET_FUNCTION_POINTER(__fxstat);
211 GET_FUNCTION_POINTER(__fxstat64);
212
213 get_dri_render_node_minor();
214
215 if (drm_shim_debug) {
216 fprintf(stderr, "Initializing DRM shim on %s\n",
217 render_node_path);
218 }
219
220 nfasprintf(&device_path,
221 "/sys/dev/char/%d:%d/device",
222 DRM_MAJOR, render_node_minor);
223
224 nfasprintf(&subsystem_path,
225 "/sys/dev/char/%d:%d/device/subsystem",
226 DRM_MAJOR, render_node_minor);
227
228 drm_shim_device_init();
229
230 atexit(destroy_shim);
231 }
232
233 /* Override libdrm's reading of various sysfs files for device enumeration. */
234 PUBLIC FILE *fopen(const char *path, const char *mode)
235 {
236 init_shim();
237
238 for (int i = 0; i < file_overrides_count; i++) {
239 if (strcmp(file_overrides[i].path, path) == 0) {
240 int fds[2];
241 pipe(fds);
242 write(fds[1], file_overrides[i].contents,
243 strlen(file_overrides[i].contents));
244 close(fds[1]);
245 return fdopen(fds[0], "r");
246 }
247 }
248
249 return real_fopen(path, mode);
250 }
251 PUBLIC FILE *fopen64(const char *path, const char *mode)
252 __attribute__((alias("fopen")));
253
254 /* Intercepts open(render_node_path) to redirect it to the simulator. */
255 PUBLIC int open(const char *path, int flags, ...)
256 {
257 init_shim();
258
259 va_list ap;
260 va_start(ap, flags);
261 mode_t mode = va_arg(ap, mode_t);
262 va_end(ap);
263
264 if (strcmp(path, render_node_path) != 0)
265 return real_open(path, flags, mode);
266
267 int fd = real_open("/dev/null", O_RDWR, 0);
268
269 drm_shim_fd_register(fd, NULL);
270
271 return fd;
272 }
273 PUBLIC int open64(const char*, int, ...) __attribute__((alias("open")));
274
275 /* Fakes stat to return character device stuff for our fake render node. */
276 PUBLIC int __xstat(int ver, const char *path, struct stat *st)
277 {
278 init_shim();
279
280 /* Note: call real stat if we're in the process of probing for a free
281 * render node!
282 */
283 if (render_node_minor == -1)
284 return real___xstat(ver, path, st);
285
286 /* Fool libdrm's probe of whether the /sys dir for this char dev is
287 * there.
288 */
289 char *sys_dev_drm_dir;
290 nfasprintf(&sys_dev_drm_dir,
291 "/sys/dev/char/%d:%d/device/drm",
292 DRM_MAJOR, render_node_minor);
293 if (strcmp(path, sys_dev_drm_dir) == 0) {
294 free(sys_dev_drm_dir);
295 return 0;
296 }
297 free(sys_dev_drm_dir);
298
299 if (strcmp(path, render_node_path) != 0)
300 return real___xstat(ver, path, st);
301
302 memset(st, 0, sizeof(*st));
303 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
304 st->st_mode = S_IFCHR;
305
306 return 0;
307 }
308
309 /* Fakes stat to return character device stuff for our fake render node. */
310 PUBLIC int __xstat64(int ver, const char *path, struct stat64 *st)
311 {
312 init_shim();
313
314 /* Note: call real stat if we're in the process of probing for a free
315 * render node!
316 */
317 if (render_node_minor == -1)
318 return real___xstat64(ver, path, st);
319
320 /* Fool libdrm's probe of whether the /sys dir for this char dev is
321 * there.
322 */
323 char *sys_dev_drm_dir;
324 nfasprintf(&sys_dev_drm_dir,
325 "/sys/dev/char/%d:%d/device/drm",
326 DRM_MAJOR, render_node_minor);
327 if (strcmp(path, sys_dev_drm_dir) == 0) {
328 free(sys_dev_drm_dir);
329 return 0;
330 }
331 free(sys_dev_drm_dir);
332
333 if (strcmp(path, render_node_path) != 0)
334 return real___xstat64(ver, path, st);
335
336 memset(st, 0, sizeof(*st));
337 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
338 st->st_mode = S_IFCHR;
339
340 return 0;
341 }
342
343 /* Fakes fstat to return character device stuff for our fake render node. */
344 PUBLIC int __fxstat(int ver, int fd, struct stat *st)
345 {
346 init_shim();
347
348 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
349
350 if (!shim_fd)
351 return real___fxstat(ver, fd, st);
352
353 memset(st, 0, sizeof(*st));
354 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
355 st->st_mode = S_IFCHR;
356
357 return 0;
358 }
359
360 PUBLIC int __fxstat64(int ver, int fd, struct stat64 *st)
361 {
362 init_shim();
363
364 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
365
366 if (!shim_fd)
367 return real___fxstat64(ver, fd, st);
368
369 memset(st, 0, sizeof(*st));
370 st->st_rdev = makedev(DRM_MAJOR, render_node_minor);
371 st->st_mode = S_IFCHR;
372
373 return 0;
374 }
375
376 /* Tracks if the opendir was on /dev/dri. */
377 PUBLIC DIR *
378 opendir(const char *name)
379 {
380 init_shim();
381
382 DIR *dir = real_opendir(name);
383 if (strcmp(name, "/dev/dri") == 0) {
384 if (!dir) {
385 /* If /dev/dri didn't exist, we still want to be able to return our
386 * fake /dev/dri/render* even though we probably can't
387 * mkdir("/dev/dri"). Return a fake DIR pointer for that.
388 */
389 dir = fake_dev_dri;
390 }
391
392 mtx_lock(&shim_lock);
393 _mesa_set_add(opendir_set, dir);
394 mtx_unlock(&shim_lock);
395 }
396
397 return dir;
398 }
399
400 /* If we've reached the end of the real directory list and we're
401 * looking at /dev/dri, add our render node to the list.
402 */
403 PUBLIC struct dirent *
404 readdir(DIR *dir)
405 {
406 init_shim();
407
408 struct dirent *ent = NULL;
409
410 if (dir != fake_dev_dri)
411 ent = real_readdir(dir);
412 static struct dirent render_node_dirent = { 0 };
413
414 if (!ent) {
415 mtx_lock(&shim_lock);
416 if (_mesa_set_search(opendir_set, dir)) {
417 strcpy(render_node_dirent.d_name,
418 render_node_dirent_name);
419 ent = &render_node_dirent;
420 _mesa_set_remove_key(opendir_set, dir);
421 }
422 mtx_unlock(&shim_lock);
423 }
424
425 return ent;
426 }
427
428 /* If we've reached the end of the real directory list and we're
429 * looking at /dev/dri, add our render node to the list.
430 */
431 PUBLIC struct dirent64 *
432 readdir64(DIR *dir)
433 {
434 init_shim();
435
436 struct dirent64 *ent = NULL;
437 if (dir != fake_dev_dri)
438 ent = real_readdir64(dir);
439 static struct dirent64 render_node_dirent = { 0 };
440
441 if (!ent) {
442 mtx_lock(&shim_lock);
443 if (_mesa_set_search(opendir_set, dir)) {
444 strcpy(render_node_dirent.d_name,
445 render_node_dirent_name);
446 ent = &render_node_dirent;
447 _mesa_set_remove_key(opendir_set, dir);
448 }
449 mtx_unlock(&shim_lock);
450 }
451
452 return ent;
453 }
454
455 /* Cleans up tracking of opendir("/dev/dri") */
456 PUBLIC int
457 closedir(DIR *dir)
458 {
459 init_shim();
460
461 mtx_lock(&shim_lock);
462 _mesa_set_remove_key(opendir_set, dir);
463 mtx_unlock(&shim_lock);
464
465 if (dir != fake_dev_dri)
466 return real_closedir(dir);
467 else
468 return 0;
469 }
470
471 /* Handles libdrm's readlink to figure out what kind of device we have. */
472 PUBLIC ssize_t
473 readlink(const char *path, char *buf, size_t size)
474 {
475 init_shim();
476
477 if (strcmp(path, subsystem_path) != 0)
478 return real_readlink(path, buf, size);
479
480 static const struct {
481 const char *name;
482 int bus_type;
483 } bus_types[] = {
484 { "/pci", DRM_BUS_PCI },
485 { "/usb", DRM_BUS_USB },
486 { "/platform", DRM_BUS_PLATFORM },
487 { "/spi", DRM_BUS_PLATFORM },
488 { "/host1x", DRM_BUS_HOST1X },
489 };
490
491 for (uint32_t i = 0; i < ARRAY_SIZE(bus_types); i++) {
492 if (bus_types[i].bus_type != shim_device.bus_type)
493 continue;
494
495 strncpy(buf, bus_types[i].name, size);
496 buf[size - 1] = 0;
497 break;
498 }
499
500 return strlen(buf) + 1;
501 }
502
503 /* Handles libdrm's realpath to figure out what kind of device we have. */
504 PUBLIC char *
505 realpath(const char *path, char *resolved_path)
506 {
507 init_shim();
508
509 if (strcmp(path, device_path) != 0)
510 return real_realpath(path, resolved_path);
511
512 strcpy(resolved_path, path);
513
514 return resolved_path;
515 }
516
517 /* Main entrypoint to DRM drivers: the ioctl syscall. We send all ioctls on
518 * our DRM fd to drm_shim_ioctl().
519 */
520 PUBLIC int
521 ioctl(int fd, unsigned long request, ...)
522 {
523 init_shim();
524
525 va_list ap;
526 va_start(ap, request);
527 void *arg = va_arg(ap, void *);
528 va_end(ap);
529
530 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
531 if (!shim_fd)
532 return real_ioctl(fd, request, arg);
533
534 return drm_shim_ioctl(fd, request, arg);
535 }
536
537 /* Gallium uses this to dup the incoming fd on gbm screen creation */
538 PUBLIC int
539 fcntl(int fd, int cmd, ...)
540 {
541 init_shim();
542
543 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
544
545 va_list ap;
546 va_start(ap, cmd);
547 void *arg = va_arg(ap, void *);
548 va_end(ap);
549
550 int ret = real_fcntl(fd, cmd, arg);
551
552 if (shim_fd && (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC))
553 drm_shim_fd_register(ret, shim_fd);
554
555 return ret;
556 }
557 PUBLIC int fcntl64(int, int, ...)
558 __attribute__((alias("fcntl")));
559
560 /* I wrote this when trying to fix gallium screen creation, leaving it around
561 * since it's probably good to have.
562 */
563 PUBLIC int
564 dup(int fd)
565 {
566 init_shim();
567
568 int ret = real_dup(fd);
569
570 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
571 if (shim_fd && ret >= 0)
572 drm_shim_fd_register(ret, shim_fd);
573
574 return ret;
575 }
576
577 PUBLIC void *
578 mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
579 {
580 init_shim();
581
582 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
583 if (shim_fd)
584 return drm_shim_mmap(shim_fd, length, prot, flags, fd, offset);
585
586 return real_mmap(addr, length, prot, flags, fd, offset);
587 }
588 PUBLIC void *mmap64(void*, size_t, int, int, int, off_t)
589 __attribute__((alias("mmap")));