scons: Updates for targets/egl-static.
[mesa.git] / src / egl / main / egldriver.c
1 /**
2 * Functions for choosing and opening/loading device drivers.
3 */
4
5
6 #include <assert.h>
7 #include <string.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 #include "eglstring.h"
12 #include "egldefines.h"
13 #include "egldisplay.h"
14 #include "egldriver.h"
15 #include "egllog.h"
16 #include "eglmutex.h"
17
18 #if defined(_EGL_OS_UNIX)
19 #include <dlfcn.h>
20 #include <sys/types.h>
21 #include <dirent.h>
22 #include <unistd.h>
23 #endif
24
25
26 typedef struct _egl_module {
27 char *Path;
28 _EGLMain_t BuiltIn;
29 void *Handle;
30 _EGLDriver *Driver;
31 } _EGLModule;
32
33 static _EGL_DECLARE_MUTEX(_eglModuleMutex);
34 static _EGLArray *_eglModules;
35
36 const struct {
37 const char *name;
38 _EGLMain_t main;
39 } _eglBuiltInDrivers[] = {
40 #ifdef _EGL_BUILT_IN_DRIVER_GALLIUM
41 { "egl_gallium", _eglBuiltInDriverGALLIUM },
42 #endif
43 #ifdef _EGL_BUILT_IN_DRIVER_DRI2
44 { "egl_dri2", _eglBuiltInDriverDRI2 },
45 #endif
46 #ifdef _EGL_BUILT_IN_DRIVER_GLX
47 { "egl_glx", _eglBuiltInDriverGLX },
48 #endif
49 { NULL, NULL }
50 };
51
52 /**
53 * Wrappers for dlopen/dlclose()
54 */
55 #if defined(_EGL_OS_WINDOWS)
56
57
58 typedef HMODULE lib_handle;
59
60 static HMODULE
61 open_library(const char *filename)
62 {
63 return LoadLibrary(filename);
64 }
65
66 static void
67 close_library(HMODULE lib)
68 {
69 FreeLibrary(lib);
70 }
71
72
73 static const char *
74 library_suffix(void)
75 {
76 return ".dll";
77 }
78
79
80 #elif defined(_EGL_OS_UNIX)
81
82
83 typedef void * lib_handle;
84
85 static void *
86 open_library(const char *filename)
87 {
88 return dlopen(filename, RTLD_LAZY);
89 }
90
91 static void
92 close_library(void *lib)
93 {
94 dlclose(lib);
95 }
96
97
98 static const char *
99 library_suffix(void)
100 {
101 return ".so";
102 }
103
104
105 #endif
106
107
108 /**
109 * Open the named driver and find its bootstrap function: _eglMain().
110 */
111 static _EGLMain_t
112 _eglOpenLibrary(const char *driverPath, lib_handle *handle)
113 {
114 lib_handle lib;
115 _EGLMain_t mainFunc = NULL;
116 const char *error = "unknown error";
117
118 assert(driverPath);
119
120 _eglLog(_EGL_DEBUG, "dlopen(%s)", driverPath);
121 lib = open_library(driverPath);
122
123 #if defined(_EGL_OS_WINDOWS)
124 /* XXX untested */
125 if (lib)
126 mainFunc = (_EGLMain_t) GetProcAddress(lib, "_eglMain");
127 #elif defined(_EGL_OS_UNIX)
128 if (lib) {
129 union {
130 _EGLMain_t func;
131 void *ptr;
132 } tmp = { NULL };
133 /* direct cast gives a warning when compiled with -pedantic */
134 tmp.ptr = dlsym(lib, "_eglMain");
135 mainFunc = tmp.func;
136 if (!mainFunc)
137 error = dlerror();
138 }
139 else {
140 error = dlerror();
141 }
142 #endif
143
144 if (!lib) {
145 _eglLog(_EGL_WARNING, "Could not open driver %s (%s)",
146 driverPath, error);
147 return NULL;
148 }
149
150 if (!mainFunc) {
151 _eglLog(_EGL_WARNING, "_eglMain not found in %s (%s)",
152 driverPath, error);
153 if (lib)
154 close_library(lib);
155 return NULL;
156 }
157
158 *handle = lib;
159 return mainFunc;
160 }
161
162
163 /**
164 * Load a module and create the driver object.
165 */
166 static EGLBoolean
167 _eglLoadModule(_EGLModule *mod)
168 {
169 _EGLMain_t mainFunc;
170 lib_handle lib;
171 _EGLDriver *drv;
172
173 if (mod->Driver)
174 return EGL_TRUE;
175
176 if (mod->BuiltIn) {
177 lib = (lib_handle) NULL;
178 mainFunc = mod->BuiltIn;
179 }
180 else {
181 mainFunc = _eglOpenLibrary(mod->Path, &lib);
182 if (!mainFunc)
183 return EGL_FALSE;
184 }
185
186 drv = mainFunc(NULL);
187 if (!drv) {
188 if (lib)
189 close_library(lib);
190 return EGL_FALSE;
191 }
192
193 if (!drv->Name) {
194 _eglLog(_EGL_WARNING, "Driver loaded from %s has no name", mod->Path);
195 drv->Name = "UNNAMED";
196 }
197
198 mod->Handle = (void *) lib;
199 mod->Driver = drv;
200
201 return EGL_TRUE;
202 }
203
204
205 /**
206 * Unload a module.
207 */
208 static void
209 _eglUnloadModule(_EGLModule *mod)
210 {
211 #if defined(_EGL_OS_UNIX)
212 /* destroy the driver */
213 if (mod->Driver && mod->Driver->Unload)
214 mod->Driver->Unload(mod->Driver);
215
216 /*
217 * XXX At this point (atexit), the module might be the last reference to
218 * libEGL. Closing the module might unmap libEGL and give problems.
219 */
220 #if 0
221 if (mod->Handle)
222 close_library(mod->Handle);
223 #endif
224 #elif defined(_EGL_OS_WINDOWS)
225 /* XXX Windows unloads DLLs before atexit */
226 #endif
227
228 mod->Driver = NULL;
229 mod->Handle = NULL;
230 }
231
232
233 /**
234 * Add a module to the module array.
235 */
236 static _EGLModule *
237 _eglAddModule(const char *path)
238 {
239 _EGLModule *mod;
240 EGLint i;
241
242 if (!_eglModules) {
243 _eglModules = _eglCreateArray("Module", 8);
244 if (!_eglModules)
245 return NULL;
246 }
247
248 /* find duplicates */
249 for (i = 0; i < _eglModules->Size; i++) {
250 mod = _eglModules->Elements[i];
251 if (strcmp(mod->Path, path) == 0)
252 return mod;
253 }
254
255 /* allocate a new one */
256 mod = calloc(1, sizeof(*mod));
257 if (mod) {
258 mod->Path = _eglstrdup(path);
259 if (!mod->Path) {
260 free(mod);
261 mod = NULL;
262 }
263 }
264 if (mod) {
265 _eglAppendArray(_eglModules, (void *) mod);
266 _eglLog(_EGL_DEBUG, "added %s to module array", mod->Path);
267 }
268
269 return mod;
270 }
271
272
273 /**
274 * Free a module.
275 */
276 static void
277 _eglFreeModule(void *module)
278 {
279 _EGLModule *mod = (_EGLModule *) module;
280
281 _eglUnloadModule(mod);
282 free(mod->Path);
283 free(mod);
284 }
285
286
287 /**
288 * A loader function for use with _eglPreloadForEach. The loader data is the
289 * filename of the driver. This function stops on the first valid driver.
290 */
291 static EGLBoolean
292 _eglLoaderFile(const char *dir, size_t len, void *loader_data)
293 {
294 char path[1024];
295 const char *filename = (const char *) loader_data;
296 size_t flen = strlen(filename);
297
298 /* make a full path */
299 if (len + flen + 2 > sizeof(path))
300 return EGL_TRUE;
301 if (len) {
302 memcpy(path, dir, len);
303 path[len++] = '/';
304 }
305 memcpy(path + len, filename, flen);
306 len += flen;
307 path[len] = '\0';
308
309 if (library_suffix()) {
310 const char *suffix = library_suffix();
311 size_t slen = strlen(suffix);
312 const char *p;
313 EGLBoolean need_suffix;
314
315 p = filename + flen - slen;
316 need_suffix = (p < filename || strcmp(p, suffix) != 0);
317 if (need_suffix) {
318 /* overflow */
319 if (len + slen + 1 > sizeof(path))
320 return EGL_TRUE;
321 strcpy(path + len, suffix);
322 }
323 }
324
325 #if defined(_EGL_OS_UNIX)
326 /* check if the file exists */
327 if (access(path, F_OK))
328 return EGL_TRUE;
329 #endif
330
331 _eglAddModule(path);
332
333 return EGL_TRUE;
334 }
335
336
337 /**
338 * Run the callback function on each driver directory.
339 *
340 * The process may end prematurely if the callback function returns false.
341 */
342 static void
343 _eglPreloadForEach(const char *search_path,
344 EGLBoolean (*loader)(const char *, size_t, void *),
345 void *loader_data)
346 {
347 const char *cur, *next;
348 size_t len;
349
350 cur = search_path;
351 while (cur) {
352 next = strchr(cur, ':');
353 len = (next) ? next - cur : strlen(cur);
354
355 if (!loader(cur, len, loader_data))
356 break;
357
358 cur = (next) ? next + 1 : NULL;
359 }
360 }
361
362
363 /**
364 * Return a list of colon-separated driver directories.
365 */
366 static const char *
367 _eglGetSearchPath(void)
368 {
369 static char search_path[1024];
370
371 #if defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS)
372 if (search_path[0] == '\0') {
373 char *buf = search_path;
374 size_t len = sizeof(search_path);
375 EGLBoolean use_env;
376 char dir_sep;
377 int ret;
378
379 #if defined(_EGL_OS_UNIX)
380 use_env = (geteuid() == getuid() && getegid() == getgid());
381 dir_sep = '/';
382 #else
383 use_env = EGL_TRUE;
384 dir_sep = '\\';
385 #endif
386
387 if (use_env) {
388 char *p;
389
390 /* extract the dirname from EGL_DRIVER */
391 p = getenv("EGL_DRIVER");
392 if (p && strchr(p, dir_sep)) {
393 ret = _eglsnprintf(buf, len, "%s", p);
394 if (ret > 0 && ret < len) {
395 p = strrchr(buf, dir_sep);
396 *p++ = ':';
397
398 len -= p - buf;
399 buf = p;
400 }
401 }
402
403 /* append EGL_DRIVERS_PATH */
404 p = getenv("EGL_DRIVERS_PATH");
405 if (p) {
406 ret = _eglsnprintf(buf, len, "%s:", p);
407 if (ret > 0 && ret < len) {
408 buf += ret;
409 len -= ret;
410 }
411 }
412 }
413 else {
414 _eglLog(_EGL_DEBUG,
415 "ignore EGL_DRIVERS_PATH for setuid/setgid binaries");
416 }
417
418 ret = _eglsnprintf(buf, len, "%s", _EGL_DRIVER_SEARCH_DIR);
419 if (ret < 0 || ret >= len)
420 search_path[0] = '\0';
421
422 _eglLog(_EGL_DEBUG, "EGL search path is %s", search_path);
423 }
424 #endif /* defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS) */
425
426 return search_path;
427 }
428
429
430 /**
431 * Add the user driver to the module array.
432 *
433 * The user driver is specified by EGL_DRIVER.
434 */
435 static void
436 _eglAddUserDriver(void)
437 {
438 const char *search_path = _eglGetSearchPath();
439 char *env;
440
441 env = getenv("EGL_DRIVER");
442 #if defined(_EGL_OS_UNIX)
443 if (env && strchr(env, '/')) {
444 search_path = "";
445 if ((geteuid() != getuid() || getegid() != getgid())) {
446 _eglLog(_EGL_DEBUG,
447 "ignore EGL_DRIVER for setuid/setgid binaries");
448 env = NULL;
449 }
450 }
451 #endif /* _EGL_OS_UNIX */
452 if (env) {
453 _EGLModule *mod;
454 EGLint i;
455
456 /* env can be a path */
457 _eglPreloadForEach(search_path, _eglLoaderFile, (void *) env);
458 /* or the name of a built-in driver */
459 for (i = 0; _eglBuiltInDrivers[i].name; i++) {
460 if (!strcmp(_eglBuiltInDrivers[i].name, env)) {
461 mod = _eglAddModule(env);
462 if (mod)
463 mod->BuiltIn = _eglBuiltInDrivers[i].main;
464 }
465 }
466 }
467 }
468
469
470 /**
471 * Add egl_gallium to the module array.
472 */
473 static void
474 _eglAddGalliumDriver(void)
475 {
476 #ifndef _EGL_BUILT_IN_DRIVER_GALLIUM
477 void *external = (void *) "egl_gallium";
478 _eglPreloadForEach(_eglGetSearchPath(), _eglLoaderFile, external);
479 #endif
480 }
481
482
483 /**
484 * Add built-in drivers to the module array.
485 */
486 static void
487 _eglAddBuiltInDrivers(void)
488 {
489 _EGLModule *mod;
490 EGLint i;
491
492 for (i = 0; _eglBuiltInDrivers[i].name; i++) {
493 mod = _eglAddModule(_eglBuiltInDrivers[i].name);
494 if (mod)
495 mod->BuiltIn = _eglBuiltInDrivers[i].main;
496 }
497 }
498
499
500 /**
501 * Add drivers to the module array. Drivers will be loaded as they are matched
502 * to displays.
503 */
504 static EGLBoolean
505 _eglAddDrivers(void)
506 {
507 if (_eglModules)
508 return EGL_TRUE;
509
510 /* the order here decides the priorities of the drivers */
511 _eglAddUserDriver();
512 _eglAddGalliumDriver();
513 _eglAddBuiltInDrivers();
514
515 return (_eglModules != NULL);
516 }
517
518
519 /**
520 * Match a display to a driver. The display is initialized unless use_probe is
521 * true.
522 *
523 * The matching is done by finding the first driver that can initialize the
524 * display, or when use_probe is true, the driver with highest score.
525 */
526 _EGLDriver *
527 _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
528 {
529 _EGLModule *mod;
530 _EGLDriver *best_drv = NULL;
531 EGLint best_score = 0;
532 EGLint major, minor, i;
533
534 _eglLockMutex(&_eglModuleMutex);
535
536 if (!_eglAddDrivers()) {
537 _eglUnlockMutex(&_eglModuleMutex);
538 return EGL_FALSE;
539 }
540
541 /* match the loaded modules */
542 for (i = 0; i < _eglModules->Size; i++) {
543 mod = (_EGLModule *) _eglModules->Elements[i];
544 if (!mod->Driver)
545 break;
546
547 if (use_probe) {
548 EGLint score = (mod->Driver->Probe) ?
549 mod->Driver->Probe(mod->Driver, dpy) : 1;
550 if (score > best_score) {
551 best_drv = mod->Driver;
552 best_score = score;
553 }
554 }
555 else {
556 if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor)) {
557 best_drv = mod->Driver;
558 best_score = 100;
559 }
560 }
561 /* perfect match */
562 if (best_score >= 100)
563 break;
564 }
565
566 /* load more modules */
567 if (!best_drv) {
568 EGLint first_unloaded = i;
569
570 while (i < _eglModules->Size) {
571 mod = (_EGLModule *) _eglModules->Elements[i];
572 assert(!mod->Driver);
573
574 if (!_eglLoadModule(mod)) {
575 /* remove invalid modules */
576 _eglEraseArray(_eglModules, i, _eglFreeModule);
577 continue;
578 }
579
580 if (use_probe) {
581 best_score = (mod->Driver->Probe) ?
582 mod->Driver->Probe(mod->Driver, dpy) : 1;
583 }
584 else {
585 if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor))
586 best_score = 100;
587 }
588
589 if (best_score > 0) {
590 best_drv = mod->Driver;
591 /* loaded modules come before unloaded ones */
592 if (first_unloaded != i) {
593 void *tmp = _eglModules->Elements[i];
594 _eglModules->Elements[i] =
595 _eglModules->Elements[first_unloaded];
596 _eglModules->Elements[first_unloaded] = tmp;
597 }
598 break;
599 }
600 else {
601 _eglUnloadModule(mod);
602 i++;
603 }
604 }
605 }
606
607 _eglUnlockMutex(&_eglModuleMutex);
608
609 if (best_drv) {
610 _eglLog(_EGL_DEBUG, "the best driver is %s (score %d)",
611 best_drv->Name, best_score);
612 if (!use_probe) {
613 dpy->Driver = best_drv;
614 dpy->Initialized = EGL_TRUE;
615 dpy->APImajor = major;
616 dpy->APIminor = minor;
617 }
618 }
619
620 return best_drv;
621 }
622
623
624 __eglMustCastToProperFunctionPointerType
625 _eglGetDriverProc(const char *procname)
626 {
627 EGLint i;
628 _EGLProc proc = NULL;
629
630 if (!_eglModules) {
631 /* load the driver for the default display */
632 EGLDisplay egldpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
633 _EGLDisplay *dpy = _eglLookupDisplay(egldpy);
634 if (!dpy || !_eglMatchDriver(dpy, EGL_TRUE))
635 return NULL;
636 }
637
638 for (i = 0; i < _eglModules->Size; i++) {
639 _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
640
641 if (!mod->Driver)
642 break;
643 proc = mod->Driver->API.GetProcAddress(mod->Driver, procname);
644 if (proc)
645 break;
646 }
647
648 return proc;
649 }
650
651
652 /**
653 * Unload all drivers.
654 */
655 void
656 _eglUnloadDrivers(void)
657 {
658 /* this is called at atexit time */
659 if (_eglModules) {
660 _eglDestroyArray(_eglModules, _eglFreeModule);
661 _eglModules = NULL;
662 }
663 }
664
665
666 /**
667 * Invoke a callback function on each EGL search path.
668 *
669 * The first argument of the callback function is the name of the search path.
670 * The second argument is the length of the name.
671 */
672 void
673 _eglSearchPathForEach(EGLBoolean (*callback)(const char *, size_t, void *),
674 void *callback_data)
675 {
676 const char *search_path = _eglGetSearchPath();
677 _eglPreloadForEach(search_path, callback, callback_data);
678 }