【Android】Android SurfaceFlinger之Gralloc

迈不过友情╰ 2022-07-12 12:45 224阅读 0赞

## 1、SurfaceFlinger模块 ##

Android中SurfaceFlinger与其它模块的关系图如下所示：

![这里写图片描述][SouthEast]

上图中，最底层的是Linux内核提供的framebuffer显示驱动，设备节点为/dev/graphics/fb\*或/dev/fb\*，其中fb0表示第一个monitor。HAL层提供了Gralloc和Composer，其中Gralloc包括fb和gralloc两个设备，fb负责打开内核中的framebuffer、初始化配置，gralloc管理帧缓冲区的分配和释放，而Composer为UI合成提供接口，直接使用者是SurfaceFlinger中的HWComposer，HWComposer管理HAL层的Composer并负责VSync信号的产生和控制。FramebufferNativeWindow是OpengGL ES在Android平台上本地化的中介之一，EGL为OpengGL ES配置本地窗口，OpengGL ES支持软件实现libagl和硬件实现libhgl，DisplayDevice用于构建OpenGL ES运行环境。

## 2、HAL与Gralloc ##

HAL是位于Linux Kernel之上的硬件抽象层，旨在降低Android系统与硬件的耦合性，提供了统一的硬件无关的抽象接口。Android的各子系统通常不会直接使用内核驱动，而是由HAL层来间接引用底层架构，显示系统也同样如此，它借助于HAL层来操作帧缓冲区，而完成这一中介任务的就是Gralloc，Android中源码位置在hardware/libhardware/modules/gralloc/，包括三个文件，framebuffer.cpp、gralloc.cpp和mapper.cpp。

为了做到与硬件无关的抽象配置，在hardware/libhardware/include/hardware.h中定义了三个重要的数据结构，如下所示：

struct hw_module_t;
    struct hw_module_methods_t;
    struct hw_device_t;

其中，hw\_module\_t有如下要求：

/** * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM * and the fields of this data structure must begin with hw_module_t * followed by module specific information. */
    typedef struct hw_module_t {
        uint32_t tag;
        uint16_t module_api_version;
        uint16_t hal_api_version;
        const char *id;
        const char *name;
        const char *author;
        struct hw_module_methods_t* methods;
        void* dso;
    #ifdef __LP64__
        uint64_t reserved[32-7];
    #else
        uint32_t reserved[32-7];
    #endif
    } hw_module_t;

也就是说，每个硬件模块都要有一个名为HAL\_MODULE\_INFO\_SYM的变量，这个变量的数据结构的第一个字段类型为hw\_module\_t，犹如面向对象编程语言如C++的继承机制一样，以实现接口抽象。下面看一下Gralloc是如何实现的。

struct private_module_t HAL_MODULE_INFO_SYM = {
        .base = {
            .common = {
                .tag = HARDWARE_MODULE_TAG,
                .version_major = 1,
                .version_minor = 0,
                .id = GRALLOC_HARDWARE_MODULE_ID,
                .name = "Graphics Memory Allocator Module",
                .author = "The Android Open Source Project",
                .methods = &gralloc_module_methods
            },
            .registerBuffer = gralloc_register_buffer,
            .unregisterBuffer = gralloc_unregister_buffer,
            .lock = gralloc_lock,
            .unlock = gralloc_unlock,
        },
        .framebuffer = 0,
        .flags = 0,
        .numBuffers = 0,
        .bufferMask = 0,
        .lock = PTHREAD_MUTEX_INITIALIZER,
        .currentBuffer = 0,
    };
    
    struct private_module_t {
        gralloc_module_t base;
    
        private_handle_t* framebuffer;
        uint32_t flags;
        uint32_t numBuffers;
        uint32_t bufferMask;
        pthread_mutex_t lock;
        buffer_handle_t currentBuffer;
        int pmem_master;
        void* pmem_master_base;
    
        struct fb_var_screeninfo info;
        struct fb_fix_screeninfo finfo;
        float xdpi;
        float ydpi;
        float fps;
    };
    
    typedef struct gralloc_module_t {
        struct hw_module_t common;
    
        int (*registerBuffer)(struct gralloc_module_t const* module,
                buffer_handle_t handle);
        int (*unregisterBuffer)(struct gralloc_module_t const* module,
                buffer_handle_t handle);
        int (*lock)(struct gralloc_module_t const* module,
                buffer_handle_t handle, int usage,
                int l, int t, int w, int h,
                void** vaddr);    
        int (*unlock)(struct gralloc_module_t const* module,
                buffer_handle_t handle);
        /* reserved for future use */
        int (*perform)(struct gralloc_module_t const* module,
                int operation, ... );
        int (*lock_ycbcr)(struct gralloc_module_t const* module,
                buffer_handle_t handle, int usage,
                int l, int t, int w, int h,
                struct android_ycbcr *ycbcr);
        int (*lockAsync)(struct gralloc_module_t const* module,
                buffer_handle_t handle, int usage,
                int l, int t, int w, int h,
                void** vaddr, int fenceFd);
        int (*unlockAsync)(struct gralloc_module_t const* module,
                buffer_handle_t handle, int* fenceFd);
        int (*lockAsync_ycbcr)(struct gralloc_module_t const* module,
                buffer_handle_t handle, int usage,
                int l, int t, int w, int h,
                struct android_ycbcr *ycbcr, int fenceFd);
        void* reserved_proc[3];
    } gralloc_module_t;

可以看出，HAL\_MODULE\_INFO\_SYM通过private\_module\_t、gralloc\_module\_t最终包含了hw\_module\_t。

## 3、Gralloc模块加载过程 ##

Gralloc模块加载通过hardware/libhardware/include/hardware.h声明的如下函数完成。

int hw_get_module(const char *id, const struct hw_module_t **module);
    
    #define GRALLOC_HARDWARE_MODULE_ID "gralloc"

通过hw\_get\_module加载Gralloc时，参数id为GRALLOC\_HARDWARE\_MODULE\_ID，随后会走到如下hw\_get\_module\_by\_class函数，其中参数inst为NULL。

int hw_get_module_by_class(const char *class_id, const char *inst,
                               const struct hw_module_t **module)
    {
        int i = 0;
        char prop[PATH_MAX] = {
       0};
        char path[PATH_MAX] = {
       0};
        char name[PATH_MAX] = {
       0};
        char prop_name[PATH_MAX] = {
       0};
    
    
        if (inst)
            snprintf(name, PATH_MAX, "%s.%s", class_id, inst);
        else
            strlcpy(name, class_id, PATH_MAX);
    
        snprintf(prop_name, sizeof(prop_name), "ro.hardware.%s", name);
        if (property_get(prop_name, prop, NULL) > 0) {
            if (hw_module_exists(path, sizeof(path), name, prop) == 0) {
                goto found;
            }
        }
    
        for (i=0 ; i<HAL_VARIANT_KEYS_COUNT; i++) {
            if (property_get(variant_keys[i], prop, NULL) == 0) {
                continue;
            }
            if (hw_module_exists(path, sizeof(path), name, prop) == 0) {
                goto found;
            }
        }
    
        if (hw_module_exists(path, sizeof(path), name, "default") == 0) {
            goto found;
        }
    
        return -ENOENT;
    
    found:
        return load(class_id, path, module);
    }

hw\_get\_module\_by\_class的实现逻辑是先获取ro.hardware.graphic属性，属性获取成功后就到指定的目录检查gralloc库是否存在，对于64位的机器来说在如下几个目录检查：

#define HAL_LIBRARY_PATH1 "/system/lib64/hw"
    #define HAL_LIBRARY_PATH2 "/vendor/lib64/hw"
    #define HAL_LIBRARY_PATH3 "/odm/lib64/hw"

库的名字为gralloc..so。如果ro.hardware.graphic属性获取失败或者在指定的目录找不到gralloc库时就逐个获取如下几个属性：

"ro.hardware"
    "ro.product.board"
    "ro.board.platform"
    "ro.arch"

属性获取成功后，再到上面提到的几个目录查找gralloc..so，如果还是找不到，最后则查找Android默认的库gralloc.default.so。上面几个步骤中一旦找到了gralloc库，就立即通过dlopen函数打开，否则gralloc模块加载失败。dlopen成功后，通过dlsym获取HAL\_MODULE\_INFO\_SYM\_AS\_STR即名为HMI的函数地址，dlsym成功后再判断其模块id是否为gralloc，如果是的话，预示着gralloc模块加载成功，最后将dlopen结果保存到hw\_module\_t的dso成员，即一开始调用hw\_get\_module函数的参数module中，这是个二级指针，至此，Gralloc模块加载完成。总结一下，Gralloc模块的加载就是在指定的几个目录中逐个查找gralloc库，因为gralloc库有不同的表示形式，gralloc库存在的话进而使用dlopen、dlsym进行处理。

## 4、Gralloc接口 ##

从上面的数据结构中可以看出，gralloc\_module\_t继承了hw\_module\_t，进而包含了如下hw\_module\_methods\_t：

typedef struct hw_module_methods_t {
        int (*open)(const struct hw_module_t* module, const char* id,
                struct hw_device_t** device);
    
    } hw_module_methods_t;

这是一个重要的接口，目前只是一个函数指针open，用来打开某个特定的设备文件。既然有open，那么必然有close，在如下的hw\_device\_t中。

/** * Every device data structure must begin with hw_device_t * followed by module specific public methods and attributes. */
    typedef struct hw_device_t {
        uint32_t tag;
        uint32_t version;
    #ifdef __LP64__
        uint64_t reserved[12];
    #else
        uint32_t reserved[12];
    #endif
    
        int (*close)(struct hw_device_t* device);
    
    } hw_device_t;

上述open用来打开设备gpu0和fb0，两者用法类似，如下函数所示：

// gralloc.h
    
    #define GRALLOC_HARDWARE_GPU0 "gpu0"
    
    static inline int gralloc_open(const struct hw_module_t* module, 
            struct alloc_device_t** device) {
        return module->methods->open(module, 
                GRALLOC_HARDWARE_GPU0, TO_HW_DEVICE_T_OPEN(device));
    }
    
    static inline int gralloc_close(struct alloc_device_t* device) {
        return device->common.close(&device->common);
    }
    
    // fb.h
    
    #define GRALLOC_HARDWARE_FB0 "fb0"
    
    static inline int framebuffer_open(const struct hw_module_t* module,
            struct framebuffer_device_t** device) {
        return module->methods->open(module,
                GRALLOC_HARDWARE_FB0, TO_HW_DEVICE_T_OPEN(device));
    }
    
    static inline int framebuffer_close(struct framebuffer_device_t* device) {
        return device->common.close(&device->common);
    }

上面提到了每一个HAL模块如这里的Gralloc都应该有一个HAL\_MODULE\_INFO\_SYM，其中指定了open函数指针为gralloc\_device\_open函数，具体如下：

int gralloc_device_open(const hw_module_t* module, const char* name,
            hw_device_t** device)
    {
        int status = -EINVAL;
        if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
            gralloc_context_t *dev;
            dev = (gralloc_context_t*)malloc(sizeof(*dev));
    
            /* initialize our state here */
            memset(dev, 0, sizeof(*dev));
    
            /* initialize the procs */
            dev->device.common.tag = HARDWARE_DEVICE_TAG;
            dev->device.common.version = 0;
            dev->device.common.module = const_cast<hw_module_t*>(module);
            dev->device.common.close = gralloc_close;
    
            dev->device.alloc   = gralloc_alloc;
            dev->device.free    = gralloc_free;
    
            *device = &dev->device.common;
            status = 0;
        } else {
            status = fb_device_open(module, name, device);
        }
        return status;
    }

从上面的gralloc\_device\_open可以看出，会判断打开gpu还是fb，下面分开介绍。

## 5、device-gpu ##

gpu相关device的数据结构如下：

struct gralloc_context_t {
        alloc_device_t  device;
    };
    
    typedef struct alloc_device_t {
        struct hw_device_t common;
    
        int (*alloc)(struct alloc_device_t* dev,
                int w, int h, int format, int usage,
                buffer_handle_t* handle, int* stride);
    
        int (*free)(struct alloc_device_t* dev,
                buffer_handle_t handle);
    
        void (*dump)(struct alloc_device_t *dev, char *buff, int buff_len);
    
        void* reserved_proc[7];
    } alloc_device_t;

在gralloc\_device\_open中，malloc一个gralloc\_context\_t，然后指定了对应的close、alloc和free接口，其中close用于free刚刚malloc的gralloc\_context\_t，alloc和free用于管理帧缓冲区，涉及字节对齐（包括页对齐）、共享内存、设备管理、内存映射等，以及一个新的数据结构private\_handle\_t（管理文件描述符），后面着重说明。

## 6、device-fb ##

framebuffer相关device的数据结构如下：

struct fb_context_t {
        framebuffer_device_t  device;
    };
    
    typedef struct framebuffer_device_t {
        struct hw_device_t common;
    
        const uint32_t  flags;
        const uint32_t  width;
        const uint32_t  height;
        const int       stride;
        const int       format;
        const float     xdpi;
        const float     ydpi;
        const float     fps;
        const int       minSwapInterval;
        const int       maxSwapInterval;
        const int       numFramebuffers;
        int reserved[7];
    
        int (*setSwapInterval)(struct framebuffer_device_t* window,
                int interval);
    
    
        int (*setUpdateRect)(struct framebuffer_device_t* window,
                int left, int top, int width, int height);
    
        int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer);
    
        int (*compositionComplete)(struct framebuffer_device_t* dev);
    
        void (*dump)(struct framebuffer_device_t* dev, char *buff, int buff_len);
    
        int (*enableScreen)(struct framebuffer_device_t* dev, int enable);
    
        void* reserved_proc[6];
    
    } framebuffer_device_t;

fb\_device\_open函数如下：

int fb_device_open(hw_module_t const* module, const char* name,
            hw_device_t** device)
    {
        int status = -EINVAL;
        if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
            fb_context_t *dev = (fb_context_t*)malloc(sizeof(*dev));
            memset(dev, 0, sizeof(*dev));
    
            dev->device.common.tag = HARDWARE_DEVICE_TAG;
            dev->device.common.version = 0;
            dev->device.common.module = const_cast<hw_module_t*>(module);
            dev->device.common.close = fb_close;
            dev->device.setSwapInterval = fb_setSwapInterval;
            dev->device.post            = fb_post;
            dev->device.setUpdateRect = 0;
    
            private_module_t* m = (private_module_t*)module;
            status = mapFrameBuffer(m);
            if (status >= 0) {
                int stride = m->finfo.line_length / (m->info.bits_per_pixel >> 3);
                int format = (m->info.bits_per_pixel == 32)
                             ? (m->info.red.offset ? HAL_PIXEL_FORMAT_BGRA_8888 : HAL_PIXEL_FORMAT_RGBX_8888)
                             : HAL_PIXEL_FORMAT_RGB_565;
                const_cast<uint32_t&>(dev->device.flags) = 0;
                const_cast<uint32_t&>(dev->device.width) = m->info.xres;
                const_cast<uint32_t&>(dev->device.height) = m->info.yres;
                const_cast<int&>(dev->device.stride) = stride;
                const_cast<int&>(dev->device.format) = format;
                const_cast<float&>(dev->device.xdpi) = m->xdpi;
                const_cast<float&>(dev->device.ydpi) = m->ydpi;
                const_cast<float&>(dev->device.fps) = m->fps;
                const_cast<int&>(dev->device.minSwapInterval) = 1;
                const_cast<int&>(dev->device.maxSwapInterval) = 1;
                *device = &dev->device.common;
            }
        }
        return status;
    }

可以看出，fb与gpu设备的处理类似，重要的一步在与mapFrameBuffer，此时有posix mutex作同步保护。这一步才是真正的open操作，首先尝试打开/dev/graphics/fb0、/dev/fb0，成功则继续，随后是一些ioctl操作，用于获取屏幕信息，并通过这些屏幕信息算出fb的长度，最后mmap映射到刚打开的fb0设备文件，长度为刚算出的fb长度。在打开gpu0时，可以像fb0一样分配framebuffer，也可以是普通的buffer，这个普通的buffer映射的为共享内存区，即文件描述符通过ashmem\_create\_region函数（属于Android的libcutils库）创建。

[SouthEast]: /images/20220710/2f76e6f3980e4f55ba305566705f4940.png