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_DRI2
  41    { "egl_dri2", _eglBuiltInDriverDRI2 },
  42 #endif
  43 #ifdef _EGL_BUILT_IN_DRIVER_GLX
  44    { "egl_glx", _eglBuiltInDriverGLX },
  45 #endif
  46    { NULL, NULL }
  47 };
  48
  49 /**
  50  * Wrappers for dlopen/dlclose()
  51  */
  52 #if defined(_EGL_OS_WINDOWS)
  53
  54
  55 typedef HMODULE lib_handle;
  56
  57 static HMODULE
  58 open_library(const char *filename)
  59 {
  60    return LoadLibrary(filename);
  61 }
  62
  63 static void
  64 close_library(HMODULE lib)
  65 {
  66    FreeLibrary(lib);
  67 }
  68
  69
  70 static const char *
  71 library_suffix(void)
  72 {
  73    return ".dll";
  74 }
  75
  76
  77 #elif defined(_EGL_OS_UNIX)
  78
  79
  80 typedef void * lib_handle;
  81
  82 static void *
  83 open_library(const char *filename)
  84 {
  85    return dlopen(filename, RTLD_LAZY);
  86 }
  87
  88 static void
  89 close_library(void *lib)
  90 {
  91    dlclose(lib);
  92 }
  93
  94
  95 static const char *
  96 library_suffix(void)
  97 {
  98    return ".so";
  99 }
 100
 101
 102 #endif
 103
 104
 105 /**
 106  * Open the named driver and find its bootstrap function: _eglMain().
 107  */
 108 static _EGLMain_t
 109 _eglOpenLibrary(const char *driverPath, lib_handle *handle)
 110 {
 111    lib_handle lib;
 112    _EGLMain_t mainFunc = NULL;
 113    const char *error = "unknown error";
 114
 115    assert(driverPath);
 116
 117    _eglLog(_EGL_DEBUG, "dlopen(%s)", driverPath);
 118    lib = open_library(driverPath);
 119
 120 #if defined(_EGL_OS_WINDOWS)
 121    /* XXX untested */
 122    if (lib)
 123       mainFunc = (_EGLMain_t) GetProcAddress(lib, "_eglMain");
 124 #elif defined(_EGL_OS_UNIX)
 125    if (lib) {
 126       union {
 127          _EGLMain_t func;
 128          void *ptr;
 129       } tmp = { NULL };
 130       /* direct cast gives a warning when compiled with -pedantic */
 131       tmp.ptr = dlsym(lib, "_eglMain");
 132       mainFunc = tmp.func;
 133       if (!mainFunc)
 134          error = dlerror();
 135    }
 136    else {
 137       error = dlerror();
 138    }
 139 #endif
 140
 141    if (!lib) {
 142       _eglLog(_EGL_WARNING, "Could not open driver %s (%s)",
 143               driverPath, error);
 144       if (!getenv("EGL_DRIVER"))
 145          _eglLog(_EGL_WARNING,
 146                  "The driver can be overridden by setting EGL_DRIVER");
 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 built-in drivers to the module array.
 472  */
 473 static void
 474 _eglAddBuiltInDrivers(void)
 475 {
 476    _EGLModule *mod;
 477    EGLint i;
 478
 479    for (i = 0; _eglBuiltInDrivers[i].name; i++) {
 480       mod = _eglAddModule(_eglBuiltInDrivers[i].name);
 481       if (mod)
 482          mod->BuiltIn = _eglBuiltInDrivers[i].main;
 483    }
 484 }
 485
 486
 487 /**
 488  * Add drivers to the module array.  Drivers will be loaded as they are matched
 489  * to displays.
 490  */
 491 static EGLBoolean
 492 _eglAddDrivers(void)
 493 {
 494    void *external = (void *) "egl_gallium";
 495
 496    if (_eglModules)
 497       return EGL_TRUE;
 498
 499    /* the order here decides the priorities of the drivers */
 500    _eglAddUserDriver();
 501    _eglPreloadForEach(_eglGetSearchPath(), _eglLoaderFile, external);
 502    _eglAddBuiltInDrivers();
 503
 504    return (_eglModules != NULL);
 505 }
 506
 507
 508 /**
 509  * Match a display to a driver.  The display is initialized unless use_probe is
 510  * true.
 511  *
 512  * The matching is done by finding the first driver that can initialize the
 513  * display, or when use_probe is true, the driver with highest score.
 514  */
 515 _EGLDriver *
 516 _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
 517 {
 518    _EGLModule *mod;
 519    _EGLDriver *best_drv = NULL;
 520    EGLint best_score = 0;
 521    EGLint major, minor, i;
 522
 523    _eglLockMutex(&_eglModuleMutex);
 524
 525    if (!_eglAddDrivers()) {
 526       _eglUnlockMutex(&_eglModuleMutex);
 527       return EGL_FALSE;
 528    }
 529
 530    /* match the loaded modules */
 531    for (i = 0; i < _eglModules->Size; i++) {
 532       mod = (_EGLModule *) _eglModules->Elements[i];
 533       if (!mod->Driver)
 534          break;
 535
 536       if (use_probe) {
 537          EGLint score = (mod->Driver->Probe) ?
 538             mod->Driver->Probe(mod->Driver, dpy) : 1;
 539          if (score > best_score) {
 540             best_drv = mod->Driver;
 541             best_score = score;
 542          }
 543       }
 544       else {
 545          if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor)) {
 546             best_drv = mod->Driver;
 547             best_score = 100;
 548          }
 549       }
 550       /* perfect match */
 551       if (best_score >= 100)
 552          break;
 553    }
 554
 555    /* load more modules */
 556    if (!best_drv) {
 557       EGLint first_unloaded = i;
 558
 559       while (i < _eglModules->Size) {
 560          mod = (_EGLModule *) _eglModules->Elements[i];
 561          assert(!mod->Driver);
 562
 563          if (!_eglLoadModule(mod)) {
 564             /* remove invalid modules */
 565             _eglEraseArray(_eglModules, i, _eglFreeModule);
 566             continue;
 567          }
 568
 569          if (use_probe) {
 570             best_score = (mod->Driver->Probe) ?
 571                mod->Driver->Probe(mod->Driver, dpy) : 1;
 572          }
 573          else {
 574             if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor))
 575                best_score = 100;
 576          }
 577
 578          if (best_score > 0) {
 579             best_drv = mod->Driver;
 580             /* loaded modules come before unloaded ones */
 581             if (first_unloaded != i) {
 582                void *tmp = _eglModules->Elements[i];
 583                _eglModules->Elements[i] =
 584                   _eglModules->Elements[first_unloaded];
 585                _eglModules->Elements[first_unloaded] = tmp;
 586             }
 587             break;
 588          }
 589          else {
 590             _eglUnloadModule(mod);
 591             i++;
 592          }
 593       }
 594    }
 595
 596    _eglUnlockMutex(&_eglModuleMutex);
 597
 598    if (best_drv) {
 599       _eglLog(_EGL_DEBUG, "the best driver is %s (score %d)",
 600             best_drv->Name, best_score);
 601       if (!use_probe) {
 602          dpy->Driver = best_drv;
 603          dpy->Initialized = EGL_TRUE;
 604          dpy->APImajor = major;
 605          dpy->APIminor = minor;
 606       }
 607    }
 608
 609    return best_drv;
 610 }
 611
 612
 613 __eglMustCastToProperFunctionPointerType
 614 _eglGetDriverProc(const char *procname)
 615 {
 616    EGLint i;
 617    _EGLProc proc = NULL;
 618
 619    if (!_eglModules) {
 620       /* load the driver for the default display */
 621       EGLDisplay egldpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 622       _EGLDisplay *dpy = _eglLookupDisplay(egldpy);
 623       if (!dpy || !_eglMatchDriver(dpy, EGL_TRUE))
 624          return NULL;
 625    }
 626
 627    for (i = 0; i < _eglModules->Size; i++) {
 628       _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
 629
 630       if (!mod->Driver)
 631          break;
 632       proc = mod->Driver->API.GetProcAddress(mod->Driver, procname);
 633       if (proc)
 634          break;
 635    }
 636
 637    return proc;
 638 }
 639
 640
 641 /**
 642  * Unload all drivers.
 643  */
 644 void
 645 _eglUnloadDrivers(void)
 646 {
 647    /* this is called at atexit time */
 648    if (_eglModules) {
 649       _eglDestroyArray(_eglModules, _eglFreeModule);
 650       _eglModules = NULL;
 651    }
 652 }
 653
 654
 655 /**
 656  * Invoke a callback function on each EGL search path.
 657  *
 658  * The first argument of the callback function is the name of the search path.
 659  * The second argument is the length of the name.
 660  */
 661 void
 662 _eglSearchPathForEach(EGLBoolean (*callback)(const char *, size_t, void *),
 663                       void *callback_data)
 664 {
 665    const char *search_path = _eglGetSearchPath();
 666    _eglPreloadForEach(search_path, callback, callback_data);
 667 }