Linux内核提供了统一的framebuffer显示驱动。Framebuffer是内核系统提供的图形硬件的抽象描述，称为buffer是因为它也占用了系统存储空间的一部分，是一块包含屏幕显示信息的缓冲区。Framebuffer借助于Linux文件系统向上层应用提供了统一而高效的操作接口，让用户空间运行的程序比较容易地适配多种显示设备。

Android系统中，每个显示屏被抽象为一个帧缓冲区，注册到FrameBuffer模块中，并在/dev/graphics目录下创建对应的fbX设备，framebuffer提供的设备节点为/dev/graphics/fb或者/dev/fb，Android系统在硬件抽象层中提供了一个Gralloc模块，封装了对帧缓冲区的所有访问操作。用户空间的应用程序在使用帧缓冲区之间，首先要加载Gralloc模块，并且获得一个gralloc设备和一个fb设备。有了gralloc设备之后，用户空间中的应用程序就可以申请分配一块图形缓冲区，并且将这块图形缓冲区映射到应用程序的地址空间来，以便可以向里面写入要绘制的画面的内容。

Android 硬件抽象库的加载简介

Android系统，为了隐藏各厂家自身特定硬件驱动实现细节，在用户空间定义了一套硬件抽象层，各厂商在Android的硬件抽象层实现特定硬件的操作细节，编译成动态库，以库的形式提供给用户使用。

hardware/libhardware/include/hardware/hardware.h 头文件中定义一个代表模块的结构体 (hw_module_t)，其中包含模块的版本、名称和作者等元数据。Android系统 会根据这些元数据来找到并正确加载 HAL 模块。

typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    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
    /** padding to 128 bytes, reserved for future use */
    uint32_t reserved[32-7];
#endif
} hw_module_t;

hw_module_t 结构体还包含指向另一个结构体 hw_module_methods_t 的指针，后面这个结构体包含指向相应模块的 open 函数的指针。此 open 函数用于与相关硬件（此 HAL 是其抽象形式）建立通信。每个硬件专用 HAL 通常都会使用该特定硬件的附加信息来扩展通用的 hw_module_t 结构体。例如，在相机 HAL 中，camera_module_t 结构体包含一个 hw_module_t 结构体以及相机专用的其他函数指针：

typedef struct camera_module {
    hw_module_t common;
    int (*get_number_of_cameras)(void);
    int (*get_camera_info)(int camera_id, struct camera_info *info);
} camera_module_t;

实现 HAL 并创建模块结构体时，您必须将其命名为 HAL_MODULE_INFO_SYM，以下是 Nexus 9 音频 HAL 的示例：

struct audio_module HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,
        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
        .hal_api_version = HARDWARE_HAL_API_VERSION,
        .id = AUDIO_HARDWARE_MODULE_ID,
        .name = "NVIDIA Tegra Audio HAL",
        .author = "The Android Open Source Project",
        .methods = &hal_module_methods,
    },
};

HAL 设备

设备是产品硬件的抽象表示。例如，一个音频模块可能包含主音频设备、USB 音频设备或蓝牙 A2DP 音频设备。

设备由 hw_device_t 结构体表示。与模块类似，每类设备都定义了一个通用 hw_device_t 的详细版本，其中包含指向特定硬件功能的函数指针。例如，audio_hw_device_t 结构体类型会包含指向音频设备操作的函数指针：

struct audio_hw_device {
    struct hw_device_t common;

    /**
     * used by audio flinger to enumerate what devices are supported by
     * each audio_hw_device implementation.
     *
     * Return value is a bitmask of 1 or more values of audio_devices_t
     */
    uint32_t (*get_supported_devices)(const struct audio_hw_device *dev);
  ...
};
typedef struct audio_hw_device audio_hw_device_t;

如何加载硬件抽象层的动态库？

int hw_get_module(const char *id, const struct hw_module_t **module)
{
    return hw_get_module_by_class(id, NULL, module);
}

参数为模块的ID，最终会返回一个hw_module_t的结构体保存在参数module中。
每个硬件抽象层模块都必须定义HAL_MODULE_INFO_SYM符号，并且有自己唯一的ID。

hw_get_module会遍历规定的几个目录来查找名称对应的动态库，找到库的路径后，会调用load函数使用dlopen打开找到的库，并依据HAL_MODULE_INFO_SYM_AS_STR（其值为HMI）获取到hw_module_t（即HAL_MODULE_INFO_SYM）结构体指针。以及把dlopen返回的handle保存在hw_module_t中，而hw_module_t HMI 结构是一个全局结构。

每个硬件抽象层必须有自己的ID以及HAL_MODULE_INFO_SYM符号，Gralloc也不例外

/**
 * The id of this module
 */
#define GRALLOC_HARDWARE_MODULE_ID "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,
};

hw_get_module硬件加载方法根据gralloc的ID, 查找到gralloc模块定义的HAL_MODULE_INFO_SYM并返回给hw_module_t结构，但是HAL_MODULE_INFO_SYM是private_module_t结构类型，如何赋值呢？

Gralloc模块数据结构分析

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; //一个互斥锁，用来保护结构体private_module_t的并行访问
    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; //用来描述显示屏的刷新频率
};

private_module_t负责管理显示驱动framebuffer相关的信息，包括framebuffer的fd, 有多少个缓存，系统帧缓冲区使用情况，动态可变的信息，固定属性的信息，显示屏的宽高，刷新率等信息。
private_module_t 第一个变量是gralloc_module_t结构。

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);
    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);

    /* reserved for future use */
    void* reserved_proc[3];
} gralloc_module_t;

gralloc_module_t 负责管理gralloc模块相关的操作，其第一个是属性是硬件抽象层规定的hw_module_t结构，其他都是关于gralloc模块图像buffer处理的相关操作方法。

hw_module_t结构如下：

/**
 * 任何一个硬件模块都必须有一个名称为 HAL_MODULE_INFO_SYM的数据结构
 * 并且这个数据结构必须以hw_module_t为第一个元素，其后再跟随这个模块特有的信息
 */
typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    uint32_t tag; //标签
    uint16_t module_api_version; //模块主设备号
    uint16_t hal_api_version; //模块从设备号
    const char *id; //模块ID
    const char *name; //名称
    const char *author; //作者
    struct hw_module_methods_t* methods; //操作模块的方法
    void* dso; //模块首地址

    uint64_t reserved[32-7]; //保留信息

} hw_module_t;

typedef struct hw_module_methods_t {
    /** Open a specific device */
    int (*open)(const struct hw_module_t* module, const char* id,
            struct hw_device_t** device);

} hw_module_methods_t;

硬件抽象层hw_module_t结构描述了硬件抽象层库相关的信息。如版本号，id, 名称，相关的操作方法等。
其中还定义了模块的打开模块的操作方法open.

根据以上的三个结构我们可以画出结构图如下：

gralloc数据结构

回到上面问题，为什么private_module_t可以赋值给hw_module_t呢？这样看就很简单了，private_module_t的第一个变量就是gralloc_module_t, 而gralloc_module_t的数据第一个元素就是hw_module_t。private_module_t的首地址和hw_module_t的首地址是一样的，所以可以直接赋值过去。

除了hw_module_t的数据结构外，gralloc模块还定义了两种设备相关的数据结构：

1: framebuffer_device_t 用来描述系统帧缓冲区的信息

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;//用来描述帧缓冲区交换前后两个图形缓冲区的最大时间间隔
    int reserved[8];//保留
    //用来设置帧缓冲区交换前后两个图形缓冲区的最小和最大时间间隔
    int (*setSwapInterval)(struct framebuffer_device_t* window,int interval);
    //用来设置帧缓冲区的更新区域
    int (*setUpdateRect)(struct framebuffer_device_t* window,int left, int top, int width, int height);
    //用来将图形缓冲区buffer的内容渲染到帧缓冲区中去
    int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer);
    //用来通知fb设备，图形缓冲区的组合工作已经完成
    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];

2:alloc_device_t 用于描述图像分配相关的信息

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设备打开过程分析

从上一节数据结构分析的过程中可知，设备打开的方法是在hw_module_t结构中定义的，定义打开的方法为

struct private_module_t HAL_MODULE_INFO_SYM = {
    .base = {
        .common = {
            ...
            .methods = &gralloc_module_methods
        },
        ....
    },
   ...
};

static struct hw_module_methods_t gralloc_module_methods = {
        .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方法用来打开设备
参数hw_module_t为硬件抽象层加载得到的结构体
name 为打开目标设备的类型，分为两种

• 1：GRALLOC_HARDWARE_FB0 "fb0"
  打开framebuffer_device_t， 负责将图像缓冲区的内容渲染到帧缓冲区，显示到屏幕上
• 2：GRALLOC_HARDWARE_GPU0 "gpu0"
  打开alloc_device_t，负责图像缓冲区的分配和释放

参数hw_device_t为打开的设备保存的结构，返回给调用者

分别分析下打开两种设备的过程

1：打开GRALLOC_HARDWARE_FB0的过程

gralloc_device_open根据参数的不同来打开不同的设备，打开设备GRALLOC_HARDWARE_FB0，调用了fb_device_open方法

struct fb_context_t {
    framebuffer_device_t  device;
};


int fb_device_open(hw_module_t const* module, const char* name,
        hw_device_t** device)
{
    int status = -EINVAL;
    //判断设备名称是否是GRALLOC_HARDWARE_FB0，如果不是的直接返回打开失败
    if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
        //初始化设备framebuffer的上下文结构
        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);
        //初始化fb相关的操作函数
        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;
        //将fb映射到当前进程的地址空间
        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_context_t的数据结构， 并对其进行初始化，fb_context_t的device变量就是framebuffer_device_t，用来描述fb设备的。
同时还注册了操作fb设备的几个函数, 其中fb_post函数比较关键，负责将图形缓冲区的内容渲染到Framebuffer的显存中。
然后使用mapFrameBuffer函数来获取帧缓冲区的信息，然后将信息保存到framebuffer_device_t结构中，并将fb设备映射到当前进程。

再看下mapFrameBuffer做了什么操作？

int mapFrameBufferLocked(struct private_module_t* module)
{
    // framebuffer设备已经初始化则直接返回
    if (module->framebuffer) {
        return 0;
    }
   //从"/dev/graphics/和/dev/目录查找fb设备，并打开
    char const * const device_template[] = {
            "/dev/graphics/fb%u",
            "/dev/fb%u",
            0 };

    int fd = -1;
    int i=0;
    char name[64];

    while ((fd==-1) && device_template[i]) {
        snprintf(name, 64, device_template[i], 0);
        fd = open(name, O_RDWR, 0);
        i++;
    }
    if (fd < 0)
        return -errno;

    //获取framebuffer设备的不可变的信息
    struct fb_fix_screeninfo finfo;
    if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
        return -errno;

    //获取framebuffer设备的可变信息
    struct fb_var_screeninfo info;
    if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
        return -errno;

    info.reserved[0] = 0;
    info.reserved[1] = 0;
    info.reserved[2] = 0;
    info.xoffset = 0;
    info.yoffset = 0;
    info.activate = FB_ACTIVATE_NOW;

   //fb_var_screeninfo的成员变量xres和yres用来描述显示屏的可视分辨率，而成员变量xres_virtual和 
   yres_virtual用来描述显示屏的虚拟分辨率。
   //将虚拟分辨率的高度值设置为可视分辨率的高度值的NUM_BUFFERS倍
   //当前声明为双缓存
   info.yres_virtual = info.yres * NUM_BUFFERS;

   //默认为双缓冲，如果不支持，则移除双缓冲的标志flag
    uint32_t flags = PAGE_FLIP;
#if USE_PAN_DISPLAY
    if (ioctl(fd, FBIOPAN_DISPLAY, &info) == -1) {
        ALOGW("FBIOPAN_DISPLAY failed, page flipping not supported");
#else
    if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) {
        ALOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");
#endif
        info.yres_virtual = info.yres;
        flags &= ~PAGE_FLIP;
    }

    if (info.yres_virtual < info.yres * 2) {
        // we need at least 2 for page-flipping
        info.yres_virtual = info.yres;
        flags &= ~PAGE_FLIP;
        ALOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
                info.yres_virtual, info.yres*2);
    }

    if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
        return -errno;
    //计算屏幕刷新频率
    uint64_t  refreshQuotient =
    (
            uint64_t( info.upper_margin + info.lower_margin + info.yres )
            * ( info.left_margin  + info.right_margin + info.xres )
            * info.pixclock
    );

    /* Beware, info.pixclock might be 0 under emulation, so avoid a
     * division-by-0 here (SIGFPE on ARM) */
    int refreshRate = refreshQuotient > 0 ? (int)(1000000000000000LLU / refreshQuotient) : 0;

    if (refreshRate == 0) {
        // bleagh, bad info from the driver
        refreshRate = 60*1000;  // 60 Hz
    }
    //计算显示器像素密度
    if (int(info.width) <= 0 || int(info.height) <= 0) {
        // the driver doesn't return that information
        // default to 160 dpi
        info.width  = ((info.xres * 25.4f)/160.0f + 0.5f);
        info.height = ((info.yres * 25.4f)/160.0f + 0.5f);
    }

    float xdpi = (info.xres * 25.4f) / info.width;
    float ydpi = (info.yres * 25.4f) / info.height;
    float fps  = refreshRate / 1000.0f;

   //再次通过IO控制命令FBIOGET_FSCREENINFO来获得系统帧缓冲区的固定信息
    if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
        return -errno;

    if (finfo.smem_len <= 0)
        return -errno;

    //得到的系统帧缓冲区的其它信息来初始化参数module所描述的一个private_module_t结构体
    module->flags = flags;
    module->info = info;
    module->finfo = finfo;
    module->xdpi = xdpi;
    module->ydpi = ydpi;
    module->fps = fps;

    //整个系统帧缓冲区的大小=虚拟分辨率的高度值info.yres_virtual * 每一行所占用的字节数finfo.line_length,并将整个系统帧缓冲区的大小对齐到页面边界
    int err;
    size_t fbSize = roundUpToPageSize(finfo.line_length * info.yres_virtual);
   //创建一个private_handle_t，用来描述整个系统帧缓冲区的信息
    module->framebuffer = new private_handle_t(dup(fd), fbSize, 0);
    //计算整个系统帧缓冲区可以划分为多少个图形缓冲区来使用
    module->numBuffers = info.yres_virtual / info.yres;
    //初始化所有缓冲区为空闲状态
    module->bufferMask = 0;
    //将帧缓冲区映射到当前进程地址空间中
    void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (vaddr == MAP_FAILED) {
        ALOGE("Error mapping the framebuffer (%s)", strerror(errno));
        return -errno;
    }
   //系统帧缓冲区在当前进程的地址空间中的起始地址保存到private_handle_t的域base中
    module->framebuffer->base = intptr_t(vaddr);
    //清空缓冲区的内存空间
    memset(vaddr, 0, fbSize);
    return 0;
}

mapFrameBuffer函数做了几件事情
1：打开fb设备，获取fb驱动的相关信息
2：设置fb的 yres_virtual为双缓冲大小
3：计算像素密度
4：计算双缓冲大小，并将其映射到当前进程，将缓冲区起始地址宝尊在framebuffer_device_t的base属性中。

至此FB设备打开过程就分析完了，FB设备打开过程做了什么事情？

打开fb设备，根据fb设备初始化相关的显示信息，并把fb设备显存映射到当前进程方便访问，同时还注册了几个操作fb设备的方法。

打开GRALLOC_HARDWARE_GPU0的过程

gralloc设备使用结构体alloc_device_t来描述。结构体alloc_device_t有两个成员函数alloc和free，分别用来分配和释放图形缓冲区。

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;
    } 

首先创建了一个gralloc_context_t的上下文，gralloc_context_t的device就是alloc_device_t, 对其进行初始化 ，同时注册了几个操作alloc_device_t设备的函数， gralloc_alloc和gralloc_free用于分配和释放图形缓冲区。

什么地方打开了这两种设备？

分析了两种设备打开的过程， 但是什么时候会打开这两种设备呢？
1：FB设备打开时机

// Load and prepare the FB HAL, which uses the gralloc module.  Sets mFbDev.
int HWComposer::loadFbHalModule()
{
    hw_module_t const* module;

    int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
    if (err != 0) {
        ALOGE("%s module not found", GRALLOC_HARDWARE_MODULE_ID);
        return err;
    }

    return framebuffer_open(module, &mFbDev);
}

FB设备打开时机实在HWCompser构造函数中打开的，说明HWCompser会操作fb设备，渲染图像缓冲区到显示缓冲区， 具体在分析HWCompser的时候在进行分析。
2：gralloc设备打开时机

GraphicBufferAllocator::GraphicBufferAllocator()
    : mAllocDev(0)
{
    hw_module_t const* module;
    int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
    ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);
    if (err == 0) {
        gralloc_open(module, &mAllocDev);
    }
}

gralloc设备用于管理GraphicBuffer图形缓冲区，是在GraphicBufferAllocator中打开的，GraphicBufferAllocator负责图形缓冲区的分配和释放。后续在做详细分析
文章参考：Android图形显示之硬件抽象层Gralloc