Android HAL的被调用流程

 在Android系统中，对于硬件的操作，使用HAL Stub的方式来实现。HAL Stub的具体写法请参照Android中HAL如何向上层提供接口总结 。
       在我们写完HAL Stub之后，这个HAL Stub是如何被应用获取，如何被应用程序调用的呢？
       显然，由于HAL Stub本质上是一个.so,在调用之后，需要上层应用对其进行加载，然后才能调用。哪么，HAL Stub的加载器是如何实现对不同的Hardware HAL Stub进行通用性调用的呢? 按常规，每个Hareware HAL Stub应该有一个唯一的名字，且有一个通用的规则和一个入口函数。下面看看HAL Stub是如何实现这两个功能的。下面的描述以gralloc为例。

1. 唯一的id

[cpp]  view plain copy

1. #define GRALLOC_HARDWARE_MODULE_ID "gralloc"  

2. hw_module_t实例

每个硬件模块都有一个包含hw_module_t（为第一个成员）数据结构的实例，且实例的名字为:HAL_MODULE_INFO_SYM,它本身是一个宏定义，其定义如下：

hardware.h (通用的东东都在hardware.h和hardware.c中)

[cpp]  view plain copy

1. /** 
2.  * Name of the hal_module_info 
3.  */  
4. #define HAL_MODULE_INFO_SYM         HMI //.so中将一个符号HMI,获取此符号的地址，就获取到了对应的hw_module_t地址  
5.   
6. /** 
7.  * Name of the hal_module_info as a string 
8.  */  
9. #define HAL_MODULE_INFO_SYM_AS_STR  "HMI"  

 

[cpp]  view plain copy

1. /** 
2.  * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM 
3.  * and the fields of this data structure must begin with hw_module_t 
4.  * followed by module specific information. 
5.  */  
6. typedef struct gralloc_module_t {  
7.     struct hw_module_t common;  
8.       
9.     int (*registerBuffer)(struct gralloc_module_t const* module,  
10.             buffer_handle_t handle);  
11.   
12.     int (*unregisterBuffer)(struct gralloc_module_t const* module,  
13.             buffer_handle_t handle);  
14.       
15.     int (*lock)(struct gralloc_module_t const* module,  
16.             buffer_handle_t handle, int usage,  
17.             int l, int t, int w, int h,  
18.             void** vaddr);  
19.       
20.     int (*unlock)(struct gralloc_module_t const* module,  
21.             buffer_handle_t handle);  
22.   
23.     /* reserved for future use */  
24.     int (*perform)(struct gralloc_module_t const* module,  
25.             int operation, ... );  
26.     /* reserved for future use */  
27.     void* reserved_proc[7];  
28. }  

[cpp]  view plain copy

1. struct private_module_t {  
2.     gralloc_module_t base;  
3.   
4.     struct private_handle_t* framebuffer;  
5.     uint32_t flags;  
6.     uint32_t numBuffers;  
7.     uint32_t bufferMask;  
8.     pthread_mutex_t lock;  
9.     buffer_handle_t currentBuffer;  
10.     int pmem_master;  
11.     void* pmem_master_base;  
12.     unsigned long master_phys;  
13.     int gpu;  
14.     void* gpu_base;  
15.     int fb_map_offset;  
16.   
17.     struct fb_var_screeninfo info;  
18.     struct fb_fix_screeninfo finfo;  
19.     float xdpi;  
20.     float ydpi;  
21.     float fps;  
22. };  

其实例为：

[cpp]  view plain copy

1. static struct hw_module_methods_t gralloc_module_methods = {  
2.         open: gralloc_device_open  
3. };  

 

[cpp]  view plain copy

1. struct private_module_t HAL_MODULE_INFO_SYM = {  
2.     base: {  
3.         common: {  
4.             tag: HARDWARE_MODULE_TAG,  
5.             version_major: 1,  
6.             version_minor: 0,  
7.             id: GRALLOC_HARDWARE_MODULE_ID,  
8.             name: "Graphics Memory Allocator Module",  
9.             author: "The Android Open Source Project",  
10.             methods: &gralloc_module_methods  
11.         },  
12.         registerBuffer: gralloc_register_buffer,  
13.         unregisterBuffer: gralloc_unregister_buffer,  
14.         lock: gralloc_lock,  
15.         unlock: gralloc_unlock,  
16.     },  
17.     framebuffer: 0,  
18.     flags: 0,  
19.     numBuffers: 0,  
20.     bufferMask: 0,  
21.     lock: PTHREAD_MUTEX_INITIALIZER,  
22.     currentBuffer: 0,  
23. };  

 3. 从HAL Stub(.so)中获取hw_module_t(即private_module_t)

       调用函数int hw_get_module(const char *id, const struct hw_module_t **module),其中id为就是1中所讲的GRALLOC_HARDWARE_MODULE_ID，第二个参数为我们要获取的hw_module_t。

        下面以在FramebufferNativeWindow::FramebufferNativeWindow中的调用流程为例（FramebufferNativeWindow实现FrameBuffer的管理，它主要被SurfaceFlinger使用，也可以被OpenGL Native程序使用。在本质上，它在Framebuffer之上实现了一个ANativeWindow，目前它只管理两个buffers:front and back buffer.）

[cpp]  view plain copy

1. FramebufferNativeWindow::FramebufferNativeWindow()   
2.     : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)  
3. {  
4.     hw_module_t const* module;  
5.     if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {  
6.         int stride;  
7.         int err;  
8.         int i;  
9.         err = framebuffer_open(module, &fbDev);  
10.         LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));  
11.           
12.         err = gralloc_open(module, &grDev);  
13.         LOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));  
14.   
15.         // bail out if we can't initialize the modules  
16.         if (!fbDev || !grDev)  
17.             return;  
18.           
19.         mUpdateOnDemand = (fbDev->setUpdateRect != 0);  
20.           
21.         // initialize the buffer FIFO  
22.         mNumBuffers = NUM_FRAME_BUFFERS;  
23.         mNumFreeBuffers = NUM_FRAME_BUFFERS;  
24.         mBufferHead = mNumBuffers-1;  
25.   
26.         for (i = 0; i < mNumBuffers; i++)  
27.         {  
28.                 buffers[i] = new NativeBuffer(  
29.                         fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);  
30.         }  
31.   
32.         for (i = 0; i < mNumBuffers; i++)  
33.         {  
34.                 err = grDev->alloc(grDev,  
35.                         fbDev->width, fbDev->height, fbDev->format,  
36.                         GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);  
37.   
38.                 LOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",  
39.                         i, fbDev->width, fbDev->height, strerror(-err));  
40.   
41.                 if (err)  
42.                 {  
43.                         mNumBuffers = i;  
44.                         mNumFreeBuffers = i;  
45.                         mBufferHead = mNumBuffers-1;  
46.                         break;  
47.                 }  
48.         }  
49.   
50.         const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags;   
51.         const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi;  
52.         const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi;  
53.         const_cast<int&>(ANativeWindow::minSwapInterval) =   
54.             fbDev->minSwapInterval;  
55.         const_cast<int&>(ANativeWindow::maxSwapInterval) =   
56.             fbDev->maxSwapInterval;  
57.     }   
58.     else   
59.     {  
60.          LOGE("Couldn't get gralloc module");  
61.     }  
62.   
63.     ANativeWindow::setSwapInterval = setSwapInterval;  
64.     ANativeWindow::dequeueBuffer = dequeueBuffer;  
65.     ANativeWindow::lockBuffer = lockBuffer;  
66.     ANativeWindow::queueBuffer = queueBuffer;  
67.     ANativeWindow::query = query;  
68.     ANativeWindow::perform = perform;  
69. }  

       看看关键的hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module)都做了些什么？它在hardware.c中实现。相关代码如下：

 

[cpp]  view plain copy

1. /** Base path of the hal modules */  
2. #define HAL_LIBRARY_PATH1 "/system/lib/hw"  
3. #define HAL_LIBRARY_PATH2 "/vendor/lib/hw"  
4.   
5. /** 
6.  * There are a set of variant filename for modules. The form of the filename 
7.  * is "<MODULE_ID>.variant.so" so for the led module the Dream variants  
8.  * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be: 
9.  * 
10.  * led.trout.so 
11.  * led.msm7k.so 
12.  * led.ARMV6.so 
13.  * led.default.so 
14.  */  
15.   
16. static const char *variant_keys[] = {  
17.     "ro.hardware",  /* This goes first so that it can pick up a different 
18.                        file on the emulator. */  
19.     "ro.product.board",  
20.     "ro.board.platform",  
21.     "ro.arch"  
22. };  
23.   
24. static const int HAL_VARIANT_KEYS_COUNT =  
25.     (sizeof(variant_keys)/sizeof(variant_keys[0]));  
26.   
27. /** 
28.  * Load the file defined by the variant and if successful 
29.  * return the dlopen handle and the hmi. 
30.  * @return 0 = success, !0 = failure. 
31.  */  
32. static int load(const char *id,  
33.         const char *path,  
34.         const struct hw_module_t **pHmi)  
35. {  
36.     int status;  
37.     void *handle;  
38.     struct hw_module_t *hmi;  
39.   
40.     /* 
41.      * load the symbols resolving undefined symbols before 
42.      * dlopen returns. Since RTLD_GLOBAL is not or'd in with 
43.      * RTLD_NOW the external symbols will not be global 
44.      */  
45.     handle = dlopen(path, RTLD_NOW);  
46.     if (handle == NULL) {  
47.         char const *err_str = dlerror();  
48.         LOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");  
49.         status = -EINVAL;  
50.         goto done;  
51.     }  
52.   
53.     /* Get the address of the struct hal_module_info. */  
54.     const char *sym = HAL_MODULE_INFO_SYM_AS_STR;  
55.     hmi = (struct hw_module_t *)dlsym(handle, sym);  
56.     if (hmi == NULL) {  
57.         LOGE("load: couldn't find symbol %s", sym);  
58.         status = -EINVAL;  
59.         goto done;  
60.     }  
61.   
62.     /* Check that the id matches */  
63.     if (strcmp(id, hmi->id) != 0) {  
64.         LOGE("load: id=%s != hmi->id=%s", id, hmi->id);  
65.         status = -EINVAL;  
66.         goto done;  
67.     }  
68.   
69.     hmi->dso = handle;  
70.   
71.     /* success */  
72.     status = 0;  
73.   
74.     done:  
75.     if (status != 0) {  
76.         hmi = NULL;  
77.         if (handle != NULL) {  
78.             dlclose(handle);  
79.             handle = NULL;  
80.         }  
81.     } else {  
82.         LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",  
83.                 id, path, *pHmi, handle);  
84.     }  
85.   
86.     *pHmi = hmi;  
87.   
88.     return status;  
89. }  
90.   
91. int hw_get_module_by_class(const char *class_id, const char *inst,  
92.                            const struct hw_module_t **module)  
93. {  
94.     int status;  
95.     int i;  
96.     const struct hw_module_t *hmi = NULL;  
97.     char prop[PATH_MAX];  
98.     char path[PATH_MAX];  
99.     char name[PATH_MAX];  
100.   
101.     if (inst)  
102.         snprintf(name, PATH_MAX, "%s.%s", class_id, inst);  
103.     else  
104.         strlcpy(name, class_id, PATH_MAX);  
105.   
106.     /* 
107.      * Here we rely on the fact that calling dlopen multiple times on 
108.      * the same .so will simply increment a refcount (and not load 
109.      * a new copy of the library). 
110.      * We also assume that dlopen() is thread-safe. 
111.      */  
112.   
113.     /* Loop through the configuration variants looking for a module */  
114.     for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {  
115.         if (i < HAL_VARIANT_KEYS_COUNT) {  
116.             if (property_get(variant_keys[i], prop, NULL) == 0) {  
117.                 continue;  
118.             }  
119.             snprintf(path, sizeof(path), "%s/%s.%s.so",  
120.                      HAL_LIBRARY_PATH2, name, prop);  
121.             if (access(path, R_OK) == 0) break;  
122.   
123.             snprintf(path, sizeof(path), "%s/%s.%s.so",  
124.                      HAL_LIBRARY_PATH1, name, prop);  
125.             if (access(path, R_OK) == 0) break;  
126.         } else {  
127.             snprintf(path, sizeof(path), "%s/%s.default.so",  
128.                      HAL_LIBRARY_PATH1, name);  
129.             if (access(path, R_OK) == 0) break;  
130.         }  
131.     }  
132.   
133.     status = -ENOENT;  
134.     if (i < HAL_VARIANT_KEYS_COUNT+1) {  
135.         /* load the module, if this fails, we're doomed, and we should not try 
136.          * to load a different variant. */  
137.         status = load(class_id, path, module);  
138.     }  
139.   
140.     return status;  
141. }  
142.   
143. int hw_get_module(const char *id, const struct hw_module_t **module)  
144. {  
145.     return hw_get_module_by_class(id, NULL, module);  
146. }  

       其关键在于load函数中的下面两行代码：

[cpp]  view plain copy

1. const char *sym = HAL_MODULE_INFO_SYM_AS_STR;  
2. hmi = (struct hw_module_t *)dlsym(handle, sym);  

       在打开的.so中查找HMI符号的地址，并保存在hmi中。至此，.so中的hw_module_t已经被成功获取，从而可以根据它获取别的相关接口。

 4. 使用实例

代码如下：

[cpp]  view plain copy

1. GraphicBufferAllocator::GraphicBufferAllocator()  
2.     : mAllocDev(0)  
3. {  
4.     hw_module_t const* module;  
5.     int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);  
6.     LOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);  
7.     if (err == 0) {  
8.         gralloc_open(module, &mAllocDev);  
9.     }  
10. }  

 5. 总结

1）HAL通过hw_get_module函数获取hw_module_t

2）HAL通过hw_module_t->methods->open获取hw_device_t指针，并在此open函数中初始化hw_device_t的包装结构中的函数及hw_device_t中的close函数，如gralloc_device_open。
3）三个重要的数据结构：

    a） struct hw_device_t: 表示硬件设备，存储了各种硬件设备的公共属性和方法       

    b）struct hw_module_t: 可用hw_get_module进行加载的module

    c）struct hw_module_methods_t: 用于定义操作设备的方法，其中只定义了一个打开设备的方法open.  

 

[cpp]  view plain copy

1. typedef struct hw_module_t {  
2.     /** tag must be initialized to HARDWARE_MODULE_TAG */  
3.     uint32_t tag;  
4.   
5.     /** major version number for the module */  
6.     uint16_t version_major;  
7.   
8.     /** minor version number of the module */  
9.     uint16_t version_minor;  
10.   
11.     /** Identifier of module */  
12.     const char *id;  
13.   
14.     /** Name of this module */  
15.     const char *name;  
16.   
17.     /** Author/owner/implementor of the module */  
18.     const char *author;  
19.   
20.     /** Modules methods */  
21.     struct hw_module_methods_t* methods;  
22.   
23.     /** module's dso */  
24.     void* dso;  
25.   
26.     /** padding to 128 bytes, reserved for future use */  
27.     uint32_t reserved[32-7];  
28.   
29. } hw_module_t;  
30.   
31. typedef struct hw_module_methods_t {  
32.     /** Open a specific device */  
33.     int (*open)(const struct hw_module_t* module, const char* id,  
34.             struct hw_device_t** device);  
35.   
36. } hw_module_methods_t;  
37.   
38. /** 
39.  * Every device data structure must begin with hw_device_t 
40.  * followed by module specific public methods and attributes. 
41.  */  
42. typedef struct hw_device_t {  
43.     /** tag must be initialized to HARDWARE_DEVICE_TAG */  
44.     uint32_t tag;  
45.   
46.     /** version number for hw_device_t */  
47.     uint32_t version;  
48.   
49.     /** reference to the module this device belongs to */  
50.     struct hw_module_t* module;  
51.   
52.     /** padding reserved for future use */  
53.     uint32_t reserved[12];  
54.   
55.     /** Close this device */  
56.     int (*close)(struct hw_device_t* device);  
57.   
58. } hw_device_t;  

hw_device_t通过open方法获取。