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 EGLBoolean
 436 _eglAddUserDriver(void)
 437 {
 438    const char *search_path = _eglGetSearchPath();
 439    char *env;
 440    size_t name_len = 0;
 441
 442    env = getenv("EGL_DRIVER");
 443 #if defined(_EGL_OS_UNIX)
 444    if (env && strchr(env, '/')) {
 445       search_path = "";
 446       if ((geteuid() != getuid() || getegid() != getgid())) {
 447          _eglLog(_EGL_DEBUG,
 448                "ignore EGL_DRIVER for setuid/setgid binaries");
 449          env = NULL;
 450       }
 451    }
 452    else if (env) {
 453       char *suffix = strchr(env, '.');
 454       name_len = (suffix) ? suffix - env : strlen(env);
 455    }
 456 #else
 457    if (env)
 458       name_len = strlen(env);
 459 #endif /* _EGL_OS_UNIX */
 460
 461    /*
 462     * Try built-in drivers first if we know the driver name.  This makes sure
 463     * we do not load the outdated external driver that is still on the
 464     * filesystem.
 465     */
 466    if (name_len) {
 467       _EGLModule *mod;
 468       EGLint i;
 469
 470       for (i = 0; _eglBuiltInDrivers[i].name; i++) {
 471          if (strlen(_eglBuiltInDrivers[i].name) == name_len &&
 472              !strncmp(_eglBuiltInDrivers[i].name, env, name_len)) {
 473             mod = _eglAddModule(env);
 474             if (mod)
 475                mod->BuiltIn = _eglBuiltInDrivers[i].main;
 476
 477             return EGL_TRUE;
 478          }
 479       }
 480    }
 481
 482    /* otherwise, treat env as a path */
 483    if (env) {
 484       _eglPreloadForEach(search_path, _eglLoaderFile, (void *) env);
 485
 486       return EGL_TRUE;
 487    }
 488
 489    return EGL_FALSE;
 490 }
 491
 492
 493 /**
 494  * Add egl_gallium to the module array.
 495  */
 496 static void
 497 _eglAddGalliumDriver(void)
 498 {
 499 #ifndef _EGL_BUILT_IN_DRIVER_GALLIUM
 500    void *external = (void *) "egl_gallium";
 501    _eglPreloadForEach(_eglGetSearchPath(), _eglLoaderFile, external);
 502 #endif
 503 }
 504
 505
 506 /**
 507  * Add built-in drivers to the module array.
 508  */
 509 static void
 510 _eglAddBuiltInDrivers(void)
 511 {
 512    _EGLModule *mod;
 513    EGLint i;
 514
 515    for (i = 0; _eglBuiltInDrivers[i].name; i++) {
 516       mod = _eglAddModule(_eglBuiltInDrivers[i].name);
 517       if (mod)
 518          mod->BuiltIn = _eglBuiltInDrivers[i].main;
 519    }
 520 }
 521
 522
 523 /**
 524  * Add drivers to the module array.  Drivers will be loaded as they are matched
 525  * to displays.
 526  */
 527 static EGLBoolean
 528 _eglAddDrivers(void)
 529 {
 530    if (_eglModules)
 531       return EGL_TRUE;
 532
 533    if (!_eglAddUserDriver()) {
 534       /*
 535        * Add other drivers only when EGL_DRIVER is not set.  The order here
 536        * decides the priorities.
 537        */
 538       _eglAddGalliumDriver();
 539       _eglAddBuiltInDrivers();
 540    }
 541
 542    return (_eglModules != NULL);
 543 }
 544
 545
 546 /**
 547  * A helper function for _eglMatchDriver.  It finds the first driver that can
 548  * initialize the display and return.
 549  */
 550 static _EGLDriver *
 551 _eglMatchAndInitialize(_EGLDisplay *dpy)
 552 {
 553    _EGLDriver *drv = NULL;
 554    EGLint i = 0;
 555
 556    if (!_eglAddDrivers()) {
 557       _eglLog(_EGL_WARNING, "failed to find any driver");
 558       return NULL;
 559    }
 560
 561    if (dpy->Driver) {
 562       drv = dpy->Driver;
 563       /* no re-matching? */
 564       if (!drv->API.Initialize(drv, dpy))
 565          drv = NULL;
 566       return drv;
 567    }
 568
 569    while (i < _eglModules->Size) {
 570       _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
 571
 572       if (!_eglLoadModule(mod)) {
 573          /* remove invalid modules */
 574          _eglEraseArray(_eglModules, i, _eglFreeModule);
 575          continue;
 576       }
 577
 578       if (mod->Driver->API.Initialize(mod->Driver, dpy)) {
 579          drv = mod->Driver;
 580          break;
 581       }
 582       else {
 583          i++;
 584       }
 585    }
 586
 587    return drv;
 588 }
 589
 590
 591 /**
 592  * Match a display to a driver.  The display is initialized unless test_only is
 593  * true.  The matching is done by finding the first driver that can initialize
 594  * the display.
 595  */
 596 _EGLDriver *
 597 _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean test_only)
 598 {
 599    _EGLDriver *best_drv;
 600
 601    assert(!dpy->Initialized);
 602
 603    _eglLockMutex(&_eglModuleMutex);
 604
 605    /* set options */
 606    dpy->Options.TestOnly = test_only;
 607    dpy->Options.UseFallback = EGL_FALSE;
 608
 609    best_drv = _eglMatchAndInitialize(dpy);
 610    if (!best_drv) {
 611       dpy->Options.UseFallback = EGL_TRUE;
 612       best_drv = _eglMatchAndInitialize(dpy);
 613    }
 614
 615    _eglUnlockMutex(&_eglModuleMutex);
 616
 617    if (best_drv) {
 618       _eglLog(_EGL_DEBUG, "the best driver is %s%s",
 619             best_drv->Name, (test_only) ? " (test only) " : "");
 620       if (!test_only) {
 621          dpy->Driver = best_drv;
 622          dpy->Initialized = EGL_TRUE;
 623       }
 624    }
 625
 626    return best_drv;
 627 }
 628
 629
 630 __eglMustCastToProperFunctionPointerType
 631 _eglGetDriverProc(const char *procname)
 632 {
 633    EGLint i;
 634    _EGLProc proc = NULL;
 635
 636    if (!_eglModules) {
 637       /* load the driver for the default display */
 638       EGLDisplay egldpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 639       _EGLDisplay *dpy = _eglLookupDisplay(egldpy);
 640       if (!dpy || !_eglMatchDriver(dpy, EGL_TRUE))
 641          return NULL;
 642    }
 643
 644    for (i = 0; i < _eglModules->Size; i++) {
 645       _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
 646
 647       if (!mod->Driver)
 648          break;
 649       proc = mod->Driver->API.GetProcAddress(mod->Driver, procname);
 650       if (proc)
 651          break;
 652    }
 653
 654    return proc;
 655 }
 656
 657
 658 /**
 659  * Unload all drivers.
 660  */
 661 void
 662 _eglUnloadDrivers(void)
 663 {
 664    /* this is called at atexit time */
 665    if (_eglModules) {
 666       _eglDestroyArray(_eglModules, _eglFreeModule);
 667       _eglModules = NULL;
 668    }
 669 }
 670
 671
 672 /**
 673  * Invoke a callback function on each EGL search path.
 674  *
 675  * The first argument of the callback function is the name of the search path.
 676  * The second argument is the length of the name.
 677  */
 678 void
 679 _eglSearchPathForEach(EGLBoolean (*callback)(const char *, size_t, void *),
 680                       void *callback_data)
 681 {
 682    const char *search_path = _eglGetSearchPath();
 683    _eglPreloadForEach(search_path, callback, callback_data);
 684 }