返回发烧友论坛
发 帖  

[文章]品读鸿蒙HDF架构（二）

李中宏
2020-12-16 11:42:48
阅读量0
鸿蒙系统
0
1
在前一篇文章里，我们阐述了在启动DeviceManager这个核心服务时，是如何生成所有的host配套设施的，下面我们来进一步剖析细节。

我们已经知道，一个Host对应一个DevHostServiceClnt和一个DevHostService，很明显主要行为都包含在后者内部。当后者启动时，会执行到DriverInstallerStartDeviceHost()，该函数又会调用DevHostServiceStartServie()，这些内容在前一篇文章里都说过。

我们不用去想太多调用细节，反正说起来就是要让一个DevHostServiceClnt和一个DevHostService“挂接”（attach）起来，挂接的动作里会进一步在DevHostService里安装设备驱动。这个挂接动作具体对应的函数就是DevmgrServiceClntAttachDeviceHost()。在上一篇文章里，我们没有展开讲这个函数，现在就从它说起。为了便于阅读，我将挂接动作的调用顺序先绘制出来，如下图所示：
1 挂接device Host
我用黄色框表达了DevmgrServiceClntAttachDeviceHost()一步，该函数代码截选如下：
【drivers/hdf/frameworks/core/host/src/Devmgr_service_clnt.c】
  1. int DevmgrServiceClntAttachDeviceHost(uint16_t hostId, struct IDevHostService *hostService)
  2. {
  3.     struct IDevmgrService *devMgrSvcIf = NULL;
  4.     . . . . . .
  5.     devMgrSvcIf = inst->devMgrSvcIf;
  6.     . . . . . .
  7.     // 实际调用的是DevmgrServiceAttachDeviceHost()
  8.     return devMgrSvcIf->AttachDeviceHost(devMgrSvcIf, hostId, hostService);
  9. }
复制代码
最后一句实际调用的是DevmgrServiceAttachDeviceHost()，代码截选如下：
【drivers/hdf/frameworks/core/manager/src/Devmgr_service.c】
  1. static int DevmgrServiceAttachDeviceHost(
  2.     struct IDevmgrService *inst, uint16_t hostId, struct IDevHostService *hostService)
  3. {
  4.     struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, hostId);
  5.     . . . . . .
  6.     hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList(hostClnt->hostId, hostClnt->hostName);
  7.     . . . . . .
  8.     hostClnt->hostService = hostService;
  9.     return DevHostServiceClntInstallDriver(hostClnt);
  10. }
复制代码
首先，遍历DevmgrService的hosts列表，根据hostId找到对应的DevHostServiceClnt对象，并给该DevHostServiceClnt对象的deviceInfos域和hostService域赋值，然后调用重头戏DevHostServiceClntInstallDriver()。
在获取这个host范畴的所有device信息时，也是去查询上一篇文章提到的配置树，树节点的类型为DeviceResourceNode，只不过上一次系统是去查找具有“hdf_manager”属性的节点，而此次是查找名字为hostName的节点，这个节点里包含着若干设备的信息，现在这些设备信息会被组织成一个HdfDeviceInfo链表。最终形成下面图中的结构：
1.1 安装host范畴内的设备驱动1.1.1 在每个host的DevHostService里添加设备
Attach动作的最后一步就是安装驱动啦，我们看一下这个DevHostServiceClntInstallDriver()函数：
【drivers/hdf/frameworks/core/manager/src/Devhost_service_clnt.c】
  1. int DevHostServiceClntInstallDriver(struct DevHostServiceClnt *hostClnt)
  2. {
  3.     . . . . . .
  4.     struct HdfSListIterator it;
  5.     struct HdfDeviceInfo *deviceInfo = NULL;
  6.     struct IDevHostService *devHostSvcIf = NULL;
  7.     . . . . . .
  8.     devHostSvcIf = (struct IDevHostService *)hostClnt->hostService;
  9.     . . . . . .
  10.     HdfSListIteratorInit(&it, hostClnt->deviceInfos);
  11.     while (HdfSListIteratorHasNext(&it)) {
  12.         deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&it);
  13.         if ((deviceInfo == NULL) || (deviceInfo->preload != DEVICE_PRELOAD_ENABLE)) {
  14.             continue;
  15.         }
  16.         // 实际调用的是 DevHostServiceAddDevice()
  17.         ret = devHostSvcIf->AddDevice(devHostSvcIf, deviceInfo);
  18.         . . . . . .
  19.     }
  20.     return HDF_SUCCESS;
  21. }
复制代码
其实就是遍历一下该host范畴内的所有HdfDeviceInfo节点，如果节点的preload是“使能”的，就执行对应的AddDevice操作，即DevHostServiceAddDevice()函数，其代码截选如下：
【drivers/hdf/frameworks/core/host/src/Devhost_service.c】
  1. static int DevHostServiceAddDevice(struct IDevHostService *inst, const struct HdfDeviceInfo *deviceInfo)
  2. {
  3.     int ret = HDF_FAILURE;
  4.     struct HdfDevice *device = NULL;
  5.     struct HdfDeviceNode *devNode = NULL;
  6.     struct DevHostService *hostService = (struct DevHostService *)inst;
  7.     struct IDriverLoader *driverLoader =  HdfDriverLoaderGetInstance();
  8.     . . . . . .
  9.     device = DevHostServiceGetDevice(hostService, deviceInfo->deviceId);
  10.     . . . . . .
  11.     // 实际调用的是 HdfDriverLoaderLoadNode()
  12.     devNode = driverLoader->LoadNode(driverLoader, deviceInfo);
  13.     . . . . . .
  14.     devNode->hostService = hostService;
  15.     // 实际调用的是 HdfDeviceAttach()
  16.     ret = device->super.Attach(&device->super, devNode);
  17.     . . . . . .
  18.     return HDF_SUCCESS;
  19.     . . . . . .
  20. }
复制代码
在这个函数里，先调用DevHostServiceGetDevice()尝试从DevHostService的devices列表里查找与deviceId匹配的节点，如果找不到就创建一个新HdfDevice节点，并插入该列表。
当然，一开始devices列表是个空列表，此时只会创建新节点。反正经此一步，我们一般可以拿到一个可用的HdfDevice对象。接着利用驱动加载器加载一个和deviceInfo匹配的HdfDeviceNode节点。最后还需把得到的HdfDevice和HdfDeviceNode挂接起来。

1.1.1.1 加载HdfDeviceNode
加载HdfDeviceNode的动作实际上是HdfDriverLoaderLoadNode()，代码截选如下：
【drivers/hdf/frameworks/core/host/src/Hdf_driver_loader.c】
  1. static struct HdfDeviceNode *HdfDriverLoaderLoadNode(
  2.     struct IDriverLoader *loader, const struct HdfDeviceInfo *deviceInfo)
  3. {
  4.     struct HdfDriverEntry *driverEntry = NULL;
  5.     struct HdfDeviceNode *devNode = NULL;
  6.     . . . . . .
  7.     // 实际调用的是 HdfDriverLoaderGetDriverEntry()
  8.     driverEntry = loader->GetDriverEntry(deviceInfo);
  9.     . . . . . .
  10.     devNode = HdfDeviceNodeNewInstance();
  11.     . . . . . .
  12.     devNode->driverEntry = driverEntry;
  13.     devNode->deviceInfo = deviceInfo;
  14.     devNode->deviceObject.property = HcsGetNodeByMatchAttr(HcsGetRootNode(), deviceInfo->deviceMatchAttr);
  15.     . . . . . .
  16.     if ((deviceInfo->policy == SERVICE_POLICY_PUBLIC) ||
  17.         (deviceInfo->policy == SERVICE_POLICY_CAPACITY)) {
  18.         . . . . . .
  19.         if (driverEntry->Bind(&devNode->deviceObject) != 0) {
  20.             HDF_LOGE("bind driver failed");
  21.             HdfDeviceNodeFreeInstance(devNode);
  22.             return NULL;
  23.         }
  24.     }
  25.     return devNode;
  26. }
复制代码
HdfDeviceNode的定义如下：
【drivers/hdf/frameworks/core/host/include/Hdf_device_node.h】
  1. struct HdfDeviceNode {
  2.     struct IDeviceNode super;
  3.     struct HdfSListNode entry;
  4.     struct PowerStateToken *powerToken;
  5.     struct DevHostService *hostService;
  6.     struct HdfDeviceObject deviceObject;
  7.     struct IHdfDeviceToken *token;
  8.     struct HdfDriverEntry *driverEntry;
  9.     const struct HdfDeviceInfo *deviceInfo;
  10. };
复制代码
可以看到，驱动加载器在创建HdfDeviceNode节点时，还是有一些工作要做的：
1）得加载相应设备的驱动程序入口，最终体现为HdfDriverEntry；
2）创建一个HdfDeviceNode对象，经过研究，我们可以看到最终创建的其实是HdfDeviceNode的派生类（DeviceNodeExt）对象；
3）把HdfDeviceNode节点和设备驱动程序绑定起来；

1.1.1.1.1 获取驱动入口
驱动加载器获取HdfDriverEntry的实际动作是HdfDriverLoaderGetDriverEntry()：
【drivers/hdf/lite/manager/src/Lite_driver_loader.c】
  1. struct HdfDriverEntry *HdfDriverLoaderGetDriverEntry(const struct HdfDeviceInfo *deviceInfo)
  2. {
  3.     int count = (int) (((uint8_t *)(HDF_DRIVER_END()) - (uint8_t *)(HDF_DRIVER_BEGIN())) / sizeof(size_t));
  4.     size_t *addrBegin = (size_t*)(HDF_DRIVER_BEGIN());
  5.     if ((deviceInfo == NULL) || (deviceInfo->moduleName == NULL) || (deviceInfo->svcName == NULL)) {
  6.         HDF_LOGE("Hdf get device entry failed, input deviceInfo is NULL!");
  7.         return NULL;
  8.     }

  10.     for (int i = 0; i < count; i++) {
  11.         struct HdfDriverEntry *driverEntry = (struct HdfDriverEntry *)(*addrBegin);
  12.         if (strcmp(deviceInfo->moduleName, driverEntry->moduleName) == 0) {
  13.             return driverEntry;
  14.         }
  15.         addrBegin++;
  16.     }
  17.     HDF_LOGE("Hdf get %s device entry failed!", deviceInfo->svcName);
  18.     return NULL;
  19. }
复制代码
其中，HdfDriverEntry的定义如下：
【drivers/hdf/frameworks/include/core/Hdf_device_desc.h】
  1. struct HdfDriverEntry {
  2.     int32_t moduleVersion;
  3.     const char *moduleName;
  4.     int32_t (*Bind)(struct HdfDeviceObject *deviceObject);
  5.     int32_t (*Init)(struct HdfDeviceObject *deviceObject);
  6.     void (*Release)(struct HdfDeviceObject *deviceObject);
  7. };
复制代码
现在我们来解释一下，HdfDriverLoaderGetDriverEntry()到底在干什么。我们设想，HDF会先加载需要的所有驱动程序，每个驱动程序内部都会构造一个HdfDriverEntry对象，而且会填好那个Bind域，这其实就是在填写一个回调函数指针，当然，也只有驱动程序自己知道该填写哪个函数指针。

HDF会把加载的所有驱动的HdfDriverEntry对象的起始地址汇总起来，形成一个类似地址数组的东西，这个数组的第一项的地址对应上面代码中的HDF_DRIVER_BEGIN()，最后一项的地址对应HDF_DRIVER_END()（最后一项不填内容）。示意图如下：
获取驱动入口时，就是在遍历这个指针数组，查询与moduleName匹配的节点。

1.1.1.1.2 创建HdfDeviceNode对象
接着尝试创建HdfDeviceNode对象，此时调用的HdfDeviceNodeNewInstance()函数如下：
【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. struct HdfDeviceNode *HdfDeviceNodeNewInstance()
  2. {
  3.     return (struct HdfDeviceNode *)HdfObjectManagerGetObject(HDF_OBJECT_ID_DEVICE_SERVICE);
  4. }
复制代码
又需要去查我们熟悉的对象创建表（g_liteObjectCreators），最终查到会调用DeviceNodeExtCreate()：
【drivers/hdf/lite/manager/src/Hdf_device_node_ext.c】
  1. struct HdfObject *DeviceNodeExtCreate()
  2. {
  3.     struct DeviceNodeExt *instance =
  4.         (struct DeviceNodeExt *)OsalMemCalloc(sizeof(struct DeviceNodeExt));
  5.     if (instance != NULL) {
  6.         DeviceNodeExtConstruct(instance);
  7.         instance->ioService = NULL;
  8.     }
  9.     return (struct HdfObject *)instance;
  10. }
复制代码
可以看到，实际创建的是一个DeviceNodeExt对象。DeviceNodeExt继承于HdfDeviceNode，定义如下：
【drivers/hdf/lite/include/manager/Hdf_device_node_ext.h】
  1. struct DeviceNodeExt {
  2.     struct HdfDeviceNode super;
  3.     struct HdfIoService *ioService;
  4. };
复制代码
其构造函数如下：
【drivers/hdf/lite/manager/src/Hdf_device_node_ext.c】
  1. static void DeviceNodeExtConstruct(struct DeviceNodeExt *inst)
  2. {
  3.     struct IDeviceNode *nodeIf = (struct IDeviceNode *)inst;
  4.     if (nodeIf != NULL) {
  5.         HdfDeviceNodeConstruct(&inst->super);
  6.         nodeIf->PublishService = DeviceNodeExtPublishService;
  7.     }
  8. }
复制代码
注意，它修改了继承来的PublishService域，将函数指针设为DeviceNodeExtPublishService了。

HdfDriverLoaderLoadNode()会给DeviceNodeExt的driverEntry域、deviceInfo域、deviceObject.property赋值，那么在进行绑定之前，DeviceNodeExt的示意图大概是这样的：

1.1.1.1.3绑定驱动入口
接下来要将刚刚创建的DeviceNodeExt节点和驱动入口绑定起来：
driverEntry->Bind(&devNode->deviceObject)
前文我们已经说了，每个程序会实现自己的Bind动作，而HDF只负责回调Bind。注意，回调时HDF需要传入DeviceNodeExt节点的deviceObject部分的指针，因为需要驱动程序填写其中的域。当然，我们从上图中可以看到，deviceObject部分只剩下service域（IDeviceIoService*）需要填写。那么很明显，一个驱动程序要能被HDF使用，那么它就得包含一个IDeviceIoService对象。IDeviceIoService的定义如下：
【drivers/hdf/frameworks/include/core/Hdf_device_desc.h】
  1. struct IDeviceIoService {
  2.     struct HdfObject object;
  3.     int32_t (*Open)(struct HdfDeviceIoClient *client);
  4.     int32_t (*Dispatch)(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply);
  5.     void (*Release)(struct HdfDeviceIoClient *client);
  6. };
复制代码
现在我们可以基于前文示意图，绘制一张DeviceNodeExt和驱动程序绑定后的示意图了，如下图：
1.1.1.2 挂接HdfDeviceNode
DevHostServiceAddDevice()在加载好DeviceNodeExt之后，调用了一句Attach：
  1. ret = device->super.Attach(&device->super, devNode);
复制代码
尝试把HdfDevice节点和DeviceNodeExt联系起来，这一句其实是调用HdfDeviceAttach()，相关代码如下：
【drivers/hdf/frameworks/core/host/include/Hdf_device.h】
  1. struct IHdfDevice {
  2.     struct HdfObject object;
  3.     int (*Attach)(struct IHdfDevice *, struct HdfDeviceNode *);
  4. };

  6. struct HdfDevice {
  7.     struct IHdfDevice super;
  8.     struct HdfSListNode node;
  9.     struct HdfSList services;
  10.     uint16_t deviceId;
  11.     uint16_t hostId;
  12. };
复制代码
【drivers/hdf/frameworks/core/host/src/Hdf_device.c】
  1. static int HdfDeviceAttach(struct IHdfDevice *devInst, struct HdfDeviceNode *devNode)
  2. {
  3.     struct HdfDevice *device = (struct HdfDevice *)devInst;
  4.     struct IDeviceNode *nodeIf = (struct IDeviceNode *)devNode;
  5.     . . . . . .
  6.     HdfSListAdd(&device->services, &devNode->entry);
  7.     // 实际调用的是 HdfDeviceLaunchNode()
  8.     return nodeIf->LaunchNode(devNode, devInst);
  9. }
复制代码
代码里先将DeviceNodeExt添加进HdfDevice的services列表里，然后调用了HdfDeviceLaunchNode()。

我们前文已经说过，HdfDevice节点在之前已经添加进DevHostService的devices列表了，现在它又和DeviceNodeExt联系起来了，再结合前文中的知识，我们可以画一张大一点儿的关系示意图了，如下：
至此，相信大家已经基本了解挂接设备host所形成的数据结构了，正如上图所示，每个host都会对应上图中红、绿、蓝三个范畴。大家不妨自己试着画画这张图，看看还会发现什么。至于HDF的其他方面，我们可以在其他文章里再探讨。

文章转自：侯亮（悠然红茶）


举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友