Android HAL的被调用流程

转自：http://blog.youkuaiyun.com/sfrysh/article/details/7931593
在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_tconst* module,
10. buffer_handle_t handle);
11. 
    
12. int (*unregisterBuffer)(struct gralloc_module_tconst* module,
13. buffer_handle_t handle);
14. 
    
15. int (*lock)(struct gralloc_module_tconst* 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_tconst* module,
21. buffer_handle_t handle);
22. 
    
23. /* reserved for future use */
24. int (*perform)(struct gralloc_module_tconst* 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 constchar *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 constint 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(constchar *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(constchar *class_id,constchar *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(constchar *id,conststruct 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方法获取。