opengl/libs/EGL/Loader.cpp

   1 /*
   2  ** Copyright 2007, The Android Open Source Project
   3  **
   4  ** Licensed under the Apache License, Version 2.0 (the "License");
   5  ** you may not use this file except in compliance with the License.
   6  ** You may obtain a copy of the License at
   7  **
   8  **     http://www.apache.org/licenses/LICENSE-2.0
   9  **
  10  ** Unless required by applicable law or agreed to in writing, software
  11  ** distributed under the License is distributed on an "AS IS" BASIS,
  12  ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  ** See the License for the specific language governing permissions and
  14  ** limitations under the License.
  15  */
  16
  17 #include <ctype.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <dlfcn.h>
  23 #include <limits.h>
  24 #include <dirent.h>
  25
  26 #include <cutils/log.h>
  27 #include <cutils/properties.h>
  28
  29 #include <EGL/egl.h>
  30
  31 #include "egldefs.h"
  32 #include "Loader.h"
  33
  34 // ----------------------------------------------------------------------------
  35 namespace android {
  36 // ----------------------------------------------------------------------------
  37
  38
  39 /*
  40  * EGL userspace drivers must be provided either:
  41  * - as a single library:
  42  *      /vendor/lib/egl/libGLES.so
  43  *
  44  * - as separate libraries:
  45  *      /vendor/lib/egl/libEGL.so
  46  *      /vendor/lib/egl/libGLESv1_CM.so
  47  *      /vendor/lib/egl/libGLESv2.so
  48  *
  49  * The software renderer for the emulator must be provided as a single
  50  * library at:
  51  *
  52  *      /system/lib/egl/libGLES_android.so
  53  *
  54  *
  55  * For backward compatibility and to facilitate the transition to
  56  * this new naming scheme, the loader will additionally look for:
  57  *
  58  *      /{vendor|system}/lib/egl/lib{GLES | [EGL|GLESv1_CM|GLESv2]}_*.so
  59  *
  60  */
  61
  62 ANDROID_SINGLETON_STATIC_INSTANCE( Loader )
  63
  64 /* This function is called to check whether we run inside the emulator,
  65  * and if this is the case whether GLES GPU emulation is supported.
  66  *
  67  * Returned values are:
  68  *  -1   -> not running inside the emulator
  69  *   0   -> running inside the emulator, but GPU emulation not supported
  70  *   1   -> running inside the emulator, GPU emulation is supported
  71  *          through the "emulation" host-side OpenGL ES implementation.
  72  *   2   -> running inside the emulator, GPU emulation is supported
  73  *          through a guest-side vendor driver's OpenGL ES implementation.
  74  */
  75 static int
  76 checkGlesEmulationStatus(void)
  77 {
  78     /* We're going to check for the following kernel parameters:
  79      *
  80      *    qemu=1                      -> tells us that we run inside the emulator
  81      *    android.qemu.gles=<number>  -> tells us the GLES GPU emulation status
  82      *
  83      * Note that we will return <number> if we find it. This let us support
  84      * more additionnal emulation modes in the future.
  85      */
  86     char  prop[PROPERTY_VALUE_MAX];
  87     int   result = -1;
  88
  89     /* First, check for qemu=1 */
  90     property_get("ro.kernel.qemu",prop,"0");
  91     if (atoi(prop) != 1)
  92         return -1;
  93
  94     /* We are in the emulator, get GPU status value */
  95     property_get("qemu.gles",prop,"0");
  96     return atoi(prop);
  97 }
  98
  99 // ----------------------------------------------------------------------------
 100
 101 static char const * getProcessCmdline() {
 102     long pid = getpid();
 103     char procPath[128];
 104     snprintf(procPath, 128, "/proc/%ld/cmdline", pid);
 105     FILE * file = fopen(procPath, "r");
 106     if (file) {
 107         static char cmdline[256];
 108         char *str = fgets(cmdline, sizeof(cmdline) - 1, file);
 109         fclose(file);
 110         if (str) {
 111             return cmdline;
 112         }
 113     }
 114     return NULL;
 115 }
 116
 117 // ----------------------------------------------------------------------------
 118
 119 Loader::driver_t::driver_t(void* gles)
 120 {
 121     dso[0] = gles;
 122     for (size_t i=1 ; i<NELEM(dso) ; i++)
 123         dso[i] = 0;
 124 }
 125
 126 Loader::driver_t::~driver_t()
 127 {
 128     for (size_t i=0 ; i<NELEM(dso) ; i++) {
 129         if (dso[i]) {
 130             dlclose(dso[i]);
 131             dso[i] = 0;
 132         }
 133     }
 134 }
 135
 136 status_t Loader::driver_t::set(void* hnd, int32_t api)
 137 {
 138     switch (api) {
 139         case EGL:
 140             dso[0] = hnd;
 141             break;
 142         case GLESv1_CM:
 143             dso[1] = hnd;
 144             break;
 145         case GLESv2:
 146             dso[2] = hnd;
 147             break;
 148         default:
 149             return BAD_INDEX;
 150     }
 151     return NO_ERROR;
 152 }
 153
 154 // ----------------------------------------------------------------------------
 155
 156 Loader::Loader()
 157     : getProcAddress(NULL) {
 158 }
 159
 160 Loader::~Loader() {
 161 }
 162
 163 static void* load_wrapper(const char* path) {
 164     void* so = dlopen(path, RTLD_NOW | RTLD_LOCAL);
 165     ALOGE_IF(!so, "dlopen(\"%s\") failed: %s", path, dlerror());
 166     return so;
 167 }
 168
 169 #ifndef EGL_WRAPPER_DIR
 170 #if defined(__LP64__)
 171 #define EGL_WRAPPER_DIR "/system/lib64"
 172 #else
 173 #define EGL_WRAPPER_DIR "/system/lib"
 174 #endif
 175 #endif
 176
 177 static void setEmulatorGlesValue(void) {
 178     char prop[PROPERTY_VALUE_MAX];
 179     property_get("ro.kernel.qemu", prop, "0");
 180     if (atoi(prop) != 1) return;
 181
 182     property_get("ro.kernel.qemu.gles",prop,"0");
 183     if (atoi(prop) == 1) {
 184         ALOGD("Emulator has host GPU support, qemu.gles is set to 1.");
 185         property_set("qemu.gles", "1");
 186         return;
 187     }
 188
 189     // for now, checking the following
 190     // directory is good enough for emulator system images
 191     const char* vendor_lib_path =
 192 #if defined(__LP64__)
 193         "/vendor/lib64/egl";
 194 #else
 195         "/vendor/lib/egl";
 196 #endif
 197
 198     const bool has_vendor_lib = (access(vendor_lib_path, R_OK) == 0);
 199     if (has_vendor_lib) {
 200         ALOGD("Emulator has vendor provided software renderer, qemu.gles is set to 2.");
 201         property_set("qemu.gles", "2");
 202     } else {
 203         ALOGD("Emulator without GPU support detected. "
 204               "Fallback to legacy software renderer, qemu.gles is set to 0.");
 205         property_set("qemu.gles", "0");
 206     }
 207 }
 208
 209 void* Loader::open(egl_connection_t* cnx)
 210 {
 211     void* dso;
 212     driver_t* hnd = 0;
 213
 214     setEmulatorGlesValue();
 215
 216     dso = load_driver("GLES", cnx, EGL | GLESv1_CM | GLESv2);
 217     if (dso) {
 218         hnd = new driver_t(dso);
 219     } else {
 220         // Always load EGL first
 221         dso = load_driver("EGL", cnx, EGL);
 222         if (dso) {
 223             hnd = new driver_t(dso);
 224             hnd->set( load_driver("GLESv1_CM", cnx, GLESv1_CM), GLESv1_CM );
 225             hnd->set( load_driver("GLESv2",    cnx, GLESv2),    GLESv2 );
 226         }
 227     }
 228
 229     LOG_ALWAYS_FATAL_IF(!hnd, "couldn't find an OpenGL ES implementation");
 230
 231     cnx->libEgl   = load_wrapper(EGL_WRAPPER_DIR "/libEGL.so");
 232     cnx->libGles2 = load_wrapper(EGL_WRAPPER_DIR "/libGLESv2.so");
 233     cnx->libGles1 = load_wrapper(EGL_WRAPPER_DIR "/libGLESv1_CM.so");
 234
 235     LOG_ALWAYS_FATAL_IF(!cnx->libEgl,
 236             "couldn't load system EGL wrapper libraries");
 237
 238     LOG_ALWAYS_FATAL_IF(!cnx->libGles2 || !cnx->libGles1,
 239             "couldn't load system OpenGL ES wrapper libraries");
 240
 241     return (void*)hnd;
 242 }
 243
 244 status_t Loader::close(void* driver)
 245 {
 246     driver_t* hnd = (driver_t*)driver;
 247     delete hnd;
 248     return NO_ERROR;
 249 }
 250
 251 void Loader::init_api(void* dso,
 252         char const * const * api,
 253         __eglMustCastToProperFunctionPointerType* curr,
 254         getProcAddressType getProcAddress)
 255 {
 256     const ssize_t SIZE = 256;
 257     char scrap[SIZE];
 258     while (*api) {
 259         char const * name = *api;
 260         __eglMustCastToProperFunctionPointerType f =
 261             (__eglMustCastToProperFunctionPointerType)dlsym(dso, name);
 262         if (f == NULL) {
 263             // couldn't find the entry-point, use eglGetProcAddress()
 264             f = getProcAddress(name);
 265         }
 266         if (f == NULL) {
 267             // Try without the OES postfix
 268             ssize_t index = ssize_t(strlen(name)) - 3;
 269             if ((index>0 && (index<SIZE-1)) && (!strcmp(name+index, "OES"))) {
 270                 strncpy(scrap, name, index);
 271                 scrap[index] = 0;
 272                 f = (__eglMustCastToProperFunctionPointerType)dlsym(dso, scrap);
 273                 //ALOGD_IF(f, "found <%s> instead", scrap);
 274             }
 275         }
 276         if (f == NULL) {
 277             // Try with the OES postfix
 278             ssize_t index = ssize_t(strlen(name)) - 3;
 279             if (index>0 && strcmp(name+index, "OES")) {
 280                 snprintf(scrap, SIZE, "%sOES", name);
 281                 f = (__eglMustCastToProperFunctionPointerType)dlsym(dso, scrap);
 282                 //ALOGD_IF(f, "found <%s> instead", scrap);
 283             }
 284         }
 285         if (f == NULL) {
 286             //ALOGD("%s", name);
 287             f = (__eglMustCastToProperFunctionPointerType)gl_unimplemented;
 288
 289             /*
 290              * GL_EXT_debug_label is special, we always report it as
 291              * supported, it's handled by GLES_trace. If GLES_trace is not
 292              * enabled, then these are no-ops.
 293              */
 294             if (!strcmp(name, "glInsertEventMarkerEXT")) {
 295                 f = (__eglMustCastToProperFunctionPointerType)gl_noop;
 296             } else if (!strcmp(name, "glPushGroupMarkerEXT")) {
 297                 f = (__eglMustCastToProperFunctionPointerType)gl_noop;
 298             } else if (!strcmp(name, "glPopGroupMarkerEXT")) {
 299                 f = (__eglMustCastToProperFunctionPointerType)gl_noop;
 300             }
 301         }
 302         *curr++ = f;
 303         api++;
 304     }
 305 }
 306
 307 void *Loader::load_driver(const char* kind,
 308         egl_connection_t* cnx, uint32_t mask)
 309 {
 310     class MatchFile {
 311     public:
 312         static String8 find(const char* kind) {
 313             String8 result;
 314             int emulationStatus = checkGlesEmulationStatus();
 315             switch (emulationStatus) {
 316                 case 0:
 317 #if defined(__LP64__)
 318                     result.setTo("/system/lib64/egl/libGLES_android.so");
 319 #else
 320                     result.setTo("/system/lib/egl/libGLES_android.so");
 321 #endif
 322                     return result;
 323                 case 1:
 324                     // Use host-side OpenGL through the "emulation" library
 325 #if defined(__LP64__)
 326                     result.appendFormat("/system/lib64/egl/lib%s_emulation.so", kind);
 327 #else
 328                     result.appendFormat("/system/lib/egl/lib%s_emulation.so", kind);
 329 #endif
 330                     return result;
 331                 default:
 332                     // Not in emulator, or use other guest-side implementation
 333                     break;
 334             }
 335
 336             String8 pattern;
 337             pattern.appendFormat("lib%s", kind);
 338             const char* const searchPaths[] = {
 339 #if defined(__LP64__)
 340                     "/vendor/lib64/egl",
 341                     "/system/lib64/egl"
 342 #else
 343                     "/vendor/lib/egl",
 344                     "/system/lib/egl"
 345 #endif
 346             };
 347
 348             // first, we search for the exact name of the GLES userspace
 349             // driver in both locations.
 350             // i.e.:
 351             //      libGLES.so, or:
 352             //      libEGL.so, libGLESv1_CM.so, libGLESv2.so
 353
 354             for (size_t i=0 ; i<NELEM(searchPaths) ; i++) {
 355                 if (find(result, pattern, searchPaths[i], true)) {
 356                     return result;
 357                 }
 358             }
 359
 360             // for compatibility with the old "egl.cfg" naming convention
 361             // we look for files that match:
 362             //      libGLES_*.so, or:
 363             //      libEGL_*.so, libGLESv1_CM_*.so, libGLESv2_*.so
 364
 365             pattern.append("_");
 366             for (size_t i=0 ; i<NELEM(searchPaths) ; i++) {
 367                 if (find(result, pattern, searchPaths[i], false)) {
 368                     return result;
 369                 }
 370             }
 371
 372             // we didn't find the driver. gah.
 373             result.clear();
 374             return result;
 375         }
 376
 377     private:
 378         static bool find(String8& result,
 379                 const String8& pattern, const char* const search, bool exact) {
 380             if (exact) {
 381                 String8 absolutePath;
 382                 absolutePath.appendFormat("%s/%s.so", search, pattern.string());
 383                 if (!access(absolutePath.string(), R_OK)) {
 384                     result = absolutePath;
 385                     return true;
 386                 }
 387                 return false;
 388             }
 389
 390             DIR* d = opendir(search);
 391             if (d != NULL) {
 392                 struct dirent cur;
 393                 struct dirent* e;
 394                 while (readdir_r(d, &cur, &e) == 0 && e) {
 395                     if (e->d_type == DT_DIR) {
 396                         continue;
 397                     }
 398                     if (!strcmp(e->d_name, "libGLES_android.so")) {
 399                         // always skip the software renderer
 400                         continue;
 401                     }
 402                     if (strstr(e->d_name, pattern.string()) == e->d_name) {
 403                         if (!strcmp(e->d_name + strlen(e->d_name) - 3, ".so")) {
 404                             result.clear();
 405                             result.appendFormat("%s/%s", search, e->d_name);
 406                             closedir(d);
 407                             return true;
 408                         }
 409                     }
 410                 }
 411                 closedir(d);
 412             }
 413             return false;
 414         }
 415     };
 416
 417
 418     String8 absolutePath = MatchFile::find(kind);
 419     if (absolutePath.isEmpty()) {
 420         // this happens often, we don't want to log an error
 421         return 0;
 422     }
 423     const char* const driver_absolute_path = absolutePath.string();
 424
 425     void* dso = dlopen(driver_absolute_path, RTLD_NOW | RTLD_LOCAL);
 426     if (dso == 0) {
 427         const char* err = dlerror();
 428         ALOGE("load_driver(%s): %s", driver_absolute_path, err?err:"unknown");
 429         return 0;
 430     }
 431
 432     ALOGD("loaded %s", driver_absolute_path);
 433
 434     if (mask & EGL) {
 435         getProcAddress = (getProcAddressType)dlsym(dso, "eglGetProcAddress");
 436
 437         ALOGE_IF(!getProcAddress,
 438                 "can't find eglGetProcAddress() in %s", driver_absolute_path);
 439
 440         egl_t* egl = &cnx->egl;
 441         __eglMustCastToProperFunctionPointerType* curr =
 442             (__eglMustCastToProperFunctionPointerType*)egl;
 443         char const * const * api = egl_names;
 444         while (*api) {
 445             char const * name = *api;
 446             __eglMustCastToProperFunctionPointerType f =
 447                 (__eglMustCastToProperFunctionPointerType)dlsym(dso, name);
 448             if (f == NULL) {
 449                 // couldn't find the entry-point, use eglGetProcAddress()
 450                 f = getProcAddress(name);
 451                 if (f == NULL) {
 452                     f = (__eglMustCastToProperFunctionPointerType)0;
 453                 }
 454             }
 455             *curr++ = f;
 456             api++;
 457         }
 458     }
 459
 460     if (mask & GLESv1_CM) {
 461         init_api(dso, gl_names,
 462             (__eglMustCastToProperFunctionPointerType*)
 463                 &cnx->hooks[egl_connection_t::GLESv1_INDEX]->gl,
 464             getProcAddress);
 465     }
 466
 467     if (mask & GLESv2) {
 468       init_api(dso, gl_names,
 469             (__eglMustCastToProperFunctionPointerType*)
 470                 &cnx->hooks[egl_connection_t::GLESv2_INDEX]->gl,
 471             getProcAddress);
 472     }
 473
 474     return dso;
 475 }
 476
 477 // ----------------------------------------------------------------------------
 478 }; // namespace android
 479 // ----------------------------------------------------------------------------