【Android】Android SurfaceFlinger之OpenGL库加载过程

待我称王封你为后i 2022-07-10 14:59 232阅读 0赞

## 1、egl\_init\_drivers ##

Android中OpenGL库加载从egl\_init\_drivers函数开始，源码位置在frameworks/native/opengl/libs/EGL/egl.cpp。

static pthread_mutex_t sInitDriverMutex = PTHREAD_MUTEX_INITIALIZER;
    
    EGLBoolean egl_init_drivers() {
        EGLBoolean res;
        pthread_mutex_lock(&sInitDriverMutex);
        res = egl_init_drivers_locked();
        pthread_mutex_unlock(&sInitDriverMutex);
        return res;
    }

初始化过程中使用了mutex进行同步保护，下面分析egl\_init\_drivers\_locked。

## 2、egl\_init\_drivers\_locked ##

// this mutex protects:
    // d->disp[]
    // egl_init_drivers_locked()
    //
    static EGLBoolean egl_init_drivers_locked() {
        if (sEarlyInitState) {
            // initialized by static ctor. should be set here.
            return EGL_FALSE;
        }
    
        // get our driver loader
        Loader& loader(Loader::getInstance());
    
        // dynamically load our EGL implementation
        egl_connection_t* cnx = &gEGLImpl;
        if (cnx->dso == 0) {
            cnx->hooks[egl_connection_t::GLESv1_INDEX] = &gHooks[egl_connection_t::GLESv1_INDEX]; cnx->hooks[egl_connection_t::GLESv2_INDEX] = &gHooks[egl_connection_t::GLESv2_INDEX]; cnx->dso = loader.open(cnx); } return cnx->dso ? EGL_TRUE : EGL_FALSE; }

从上面的egl\_init\_drivers\_locked实现中可以看出OpenGL库最终是通过loader对象完成的，首先看一下sEarlyInitState是何方神圣。

## 3、sEarlyInitState ##

static void early_egl_init(void)
    {
        int numHooks = sizeof(gHooksNoContext) / sizeof(EGLFuncPointer);
        EGLFuncPointer *iter = reinterpret_cast<EGLFuncPointer*>(&gHooksNoContext);
        for (int hook = 0; hook < numHooks; ++hook) {
            *(iter++) = reinterpret_cast<EGLFuncPointer>(gl_no_context);
        }
    
        setGLHooksThreadSpecific(&gHooksNoContext);
    }
    
    static pthread_once_t once_control = PTHREAD_ONCE_INIT;
    static int sEarlyInitState = pthread_once(&once_control, &early_egl_init);

sEarlyInitState为pthread\_once的返回值，成功时返回0。pthread\_once保证多线程时early\_egl\_init只执行一次，early\_egl\_init用来设置线程特有的数据（pthread\_setspecific/pthread\_getspecific），这也是一种数据共享方式。EGLFuncPointer为函数指针，如下所示：

typedef void (*__eglMustCastToProperFunctionPointerType)(void);
    typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer;

gHooksNoContext是个有趣的数据结构，如下所示：

// maximum number of GL extensions that can be used simultaneously in
    // a given process. this limitation exists because we need to have
    // a static function for each extension and currently these static functions
    // are generated at compile time.
    #define MAX_NUMBER_OF_GL_EXTENSIONS 256
    
    struct gl_hooks_t {
        struct gl_t {
            #include "entries.in"
        } gl;
        struct gl_ext_t {
            __eglMustCastToProperFunctionPointerType extensions[MAX_NUMBER_OF_GL_EXTENSIONS];
        } ext;
    };
    
    extern gl_hooks_t gHooksNoContext;

上面的gl\_t结构体实际上包含了同OpenGL函数一致的函数指针，通过“entries.in”和GL\_ENTRY进行扩展，如下所示：

#define GL_ENTRY(_r, _api, ...) _r (*(_api))(__VA_ARGS__);
    
    // entries.in
    GL_ENTRY(void, glActiveShaderProgram, GLuint pipeline, GLuint program)
    GL_ENTRY(void, glActiveShaderProgramEXT, GLuint pipeline, GLuint program)
    ...
    ...

gl\_no\_context用于检查OpenGL函数调用是否设置了Context，其中用到了设置线程键的egl\_tls\_t类和收集函数调用栈帧的CallStack类。

static int gl_no_context() {
        if (egl_tls_t::logNoContextCall()) {
            char const* const error = "call to OpenGL ES API with "
                    "no current context (logged once per thread)";
            if (LOG_NDEBUG) {
                ALOGE(error);
            } else {
                LOG_ALWAYS_FATAL(error);
            }
            char value[PROPERTY_VALUE_MAX];
            property_get("debug.egl.callstack", value, "0");
            if (atoi(value)) {
                CallStack stack(LOG_TAG);
            }
        }
        return 0;
    }

随后，将修改过的gHooksNoContext通过setGLHooksThreadSpecific设置线程键，而\_\_get\_tls则是通过汇编实现的（不同的硬件有不同的汇编代码），如下所示：

void setGLHooksThreadSpecific(gl_hooks_t const *value) {
        setGlThreadSpecific(value);
    }
    
    void setGlThreadSpecific(gl_hooks_t const *value) {
        gl_hooks_t const * volatile * tls_hooks = get_tls_hooks();
        tls_hooks[TLS_SLOT_OPENGL_API] = value;
    }
    
    inline gl_hooks_t const * volatile * get_tls_hooks() {
        volatile void *tls_base = __get_tls();
        gl_hooks_t const * volatile * tls_hooks =
                reinterpret_cast<gl_hooks_t const * volatile *>(tls_base);
        return tls_hooks;
    }
    
    // Well-known TLS slots. What data goes in which slot is arbitrary unless otherwise noted.
    enum {
      TLS_SLOT_SELF = 0, // The kernel requires this specific slot for x86.
      TLS_SLOT_THREAD_ID,
      TLS_SLOT_ERRNO,
    
      // These two aren't used by bionic itself, but allow the graphics code to
      // access TLS directly rather than using the pthread API.
      TLS_SLOT_OPENGL_API = 3,
      TLS_SLOT_OPENGL = 4,
    
      // This slot is only used to pass information from the dynamic linker to
      // libc.so when the C library is loaded in to memory. The C runtime init
      // function will then clear it. Since its use is extremely temporary,
      // we reuse an existing location that isn't needed during libc startup.
      TLS_SLOT_BIONIC_PREINIT = TLS_SLOT_OPENGL_API,
    
      TLS_SLOT_STACK_GUARD = 5, // GCC requires this specific slot for x86.
      TLS_SLOT_DLERROR,
    
      // Fast storage for Thread::Current() in ART.
      TLS_SLOT_ART_THREAD_SELF,
    
      // Lets TSAN avoid using pthread_getspecific for finding the current thread
      // state.
      TLS_SLOT_TSAN,
    
      BIONIC_TLS_SLOTS // Must come last!
    };

## 4、egl\_connection\_t ##

在分析Loader前先来看一下egl\_connection\_t，其结构如下所示：

extern egl_connection_t gEGLImpl;
    extern gl_hooks_t gHooks[2];
    
    struct egl_connection_t {
        enum {
            GLESv1_INDEX = 0,
            GLESv2_INDEX = 1
        };
    
        inline egl_connection_t() : dso(0) { }
        void *              dso;
        gl_hooks_t *        hooks[2];
        EGLint              major;
        EGLint              minor;
        egl_t               egl;
    
        void*               libEgl;
        void*               libGles1;
        void*               libGles2;
    };

从上面的egl\_connection\_t结构体及前面的egl\_init\_drivers\_locked函数定义可以看出，包括两个hook，GLESv1和GLESv2，而dso则实际上指向了libEGL、libGLESv1和libGLESv2（从后面的Loader分析中可以看出），egl\_t类似于gl\_t，包含了一系列egl函数指针。下面着重分析Loader。

## 5、Loader-open ##

Loader是个单实例，如下所示：

class Loader : public Singleton<Loader>

从Loader::open开始，包括两部分，load\_driver和load\_wrapper，如下所示：

void* Loader::open(egl_connection_t* cnx)
    {
        void* dso;
        driver_t* hnd = 0;
    
        setEmulatorGlesValue();
    
        dso = load_driver("GLES", cnx, EGL | GLESv1_CM | GLESv2);
        if (dso) {
            hnd = new driver_t(dso);
        } else {
            // Always load EGL first
            dso = load_driver("EGL", cnx, EGL);
            if (dso) {
                hnd = new driver_t(dso);
                hnd->set( load_driver("GLESv1_CM", cnx, GLESv1_CM), GLESv1_CM );
                hnd->set( load_driver("GLESv2",    cnx, GLESv2),    GLESv2 );
            }
        }
    
        LOG_ALWAYS_FATAL_IF(!hnd, "couldn't find an OpenGL ES implementation");
    
        cnx->libEgl   = load_wrapper(EGL_WRAPPER_DIR "/libEGL.so");
        cnx->libGles2 = load_wrapper(EGL_WRAPPER_DIR "/libGLESv2.so");
        cnx->libGles1 = load_wrapper(EGL_WRAPPER_DIR "/libGLESv1_CM.so");
    
        LOG_ALWAYS_FATAL_IF(!cnx->libEgl,
                "couldn't load system EGL wrapper libraries");
    
        LOG_ALWAYS_FATAL_IF(!cnx->libGles2 || !cnx->libGles1,
                "couldn't load system OpenGL ES wrapper libraries");
    
        return (void*)hnd;
    }

在分析load\_driver和load\_wrapper之前，先来看一下driver\_t，这是个Loader类的内部结构体，如下所示：

struct driver_t {
            explicit driver_t(void* gles);
            ~driver_t();
            status_t set(void* hnd, int32_t api);
            void* dso[3];
        };

driver\_t的dso分别保存了EGL、GLESv1\_CM和GLESv2三个库。open函数中还调用了setEmulatorGlesValue，这个函数就是检查、设置一些模拟器属性（是否在模拟器中运行？在模拟中运行时是否有GPU支持？），比较简单，代码如下：

static void setEmulatorGlesValue(void) {
        char prop[PROPERTY_VALUE_MAX];
        property_get("ro.kernel.qemu", prop, "0");
        if (atoi(prop) != 1) return;
    
        property_get("ro.kernel.qemu.gles",prop,"0");
        if (atoi(prop) == 1) {
            ALOGD("Emulator has host GPU support, qemu.gles is set to 1.");
            property_set("qemu.gles", "1");
            return;
        }
    
        // for now, checking the following
        // directory is good enough for emulator system images
        const char* vendor_lib_path =
    #if defined(__LP64__)
            "/vendor/lib64/egl";
    #else
            "/vendor/lib/egl";
    #endif
    
        const bool has_vendor_lib = (access(vendor_lib_path, R_OK) == 0);
        if (has_vendor_lib) {
            ALOGD("Emulator has vendor provided software renderer, qemu.gles is set to 2.");
            property_set("qemu.gles", "2");
        } else {
            ALOGD("Emulator without GPU support detected. "
                  "Fallback to legacy software renderer, qemu.gles is set to 0.");
            property_set("qemu.gles", "0");
        }
    }

## 6、Loader-load\_driver ##

void *Loader::load_driver(const char* kind, egl_connection_t* cnx, uint32_t mask)
    {
    class MatchFile {};
    ...
    }

EGL驱动需要提供一个单一的库libGLES.so，或者是三个分开的库libEGL.so、libGLESv1\_CM.so和libGLESv2.so，模拟器中的软描画则需要提供单一的库libGLES\_android.so，为了兼容旧版本的“egl.cfg”文件配置，这几个库后面还可能加一个名称如\_emulation。在load\_driver函数中还有个内部类MatchFile，用于在某个lib目录中查找特定的OpenGL库是否存在，存在的话进而通过dlopen打开，dlopen成功后再通过dlsym逐个获取OpenGL所有API的地址并将它们保存下来。

## 7、load\_wrapper ##

load\_wrapper相对load\_driver来说较简单，就是dlopen一个so，如下所示：

static void* load_wrapper(const char* path) {
        void* so = dlopen(path, RTLD_NOW | RTLD_LOCAL);
        ALOGE_IF(!so, "dlopen(\"%s\") failed: %s", path, dlerror());
        return so;
    }