返回发烧友论坛
发 帖  

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

李建设
2020-12-16 14:03:51
阅读量0
鸿蒙系统
0
0
现在我们继续研究鸿蒙HDF架构，上回书说到经由HdfDeviceAttach()，HdfDevice节点不但添加进了DevHostService的devices列表，而且还和一个DeviceNodeExt联系起来了，呈现的示意图大致如下：
接着，HdfDeviceAttach()最后会调用nodeIf->LaunchNode()，这一步实际上调用的是HdfDeviceLaunchNode()，代码截选如下：
【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. int HdfDeviceLaunchNode(struct HdfDeviceNode *devNode, struct IHdfDevice *devInst)
  2. {
  3.     struct HdfDevice *device = (struct HdfDevice *)devInst;
  4.     . . . . . .
  5.     struct HdfDriverEntry *driverEntry = devNode->driverEntry;
  6.     const struct HdfDeviceInfo *deviceInfo = devNode->deviceInfo;
  7.     struct IHdfDeviceToken *deviceToken = NULL;

  9.     . . . . . .
  10.     int ret = driverEntry->Init(&devNode->deviceObject);
  11.     . . . . . .
  12.     ret = HdfDeviceNodePublishService(devNode, deviceInfo, devInst);
  13.     . . . . . .
  14.     deviceToken = devNode->token;
  15.     ret = DevmgrServiceClntAttachDevice(deviceInfo, deviceToken);
  16.     . . . . . .
  17.     return ret;
  18. }
复制代码
“Launch”本就是启动之意，在这里就是指启动与HdfDevice对应的驱动服务。所以此处会先调用一下driverEntry->Init()，并传入参数&devNode->deviceObject。这意味着要求驱动程序在初始化时，回填一下deviceObject里的service域。

接着，主要执行了两个动作：
1）发布驱动服务
2）挂接设备
我们会分两小节来阐述。

1.发布驱动服务
初始化完成后，就可以“发布”这个驱动服务了，HdfDeviceNodePublishService()的代码截选如下：
【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. static int HdfDeviceNodePublishService(struct HdfDeviceNode *devNode,
  2.                                        const struct HdfDeviceInfo *deviceInfo,
  3.                                        struct IHdfDevice *device)
  4. {
  5.     int status = HDF_SUCCESS;
  6.     . . . . . .
  7.     struct IDeviceNode *nodeIf = &devNode->super;
  8.     if ((deviceInfo->policy == SERVICE_POLICY_PUBLIC) ||
  9.         (deviceInfo->policy == SERVICE_POLICY_CAPACITY)) {
  10.         if (nodeIf->PublishService != NULL) {
  11.             // 其实调用的是 DeviceNodeExtPublishService()
  12.             status = nodeIf->PublishService(devNode, deviceInfo->svcName);
  13.         }
  14.     }
  15.     if (status == HDF_SUCCESS) {
  16.         status = HdfDeviceNodePublishLocalService(devNode, deviceInfo);
  17.     }
  18.     return status;
  19. }
复制代码
从字面上理解，如果一个设备是“公共型”或“功能型”的，则会调用nodeIf->PublishService()发布对应的驱动服务。而我们以前研究过，在HdfDeviceNode构造之时，我们可以看到为PublishService域设定了DeviceNodeExtPublishService()函数指针，因此上面代码中调用PublishService的地方，其实就是在调用这个函数。

【drivers/hdf/lite/manager/src/Hdf_device_node_ext.c】
  1. static int DeviceNodeExtPublishService(struct HdfDeviceNode *inst, const char *serviceName)
  2. {
  3.     const struct HdfDeviceInfo *deviceInfo = NULL;
  4.     struct HdfDeviceObject *deviceObject = NULL;
  5.     struct DeviceNodeExt *devNodeExt = (struct DeviceNodeExt *)inst;
  6.     . . . . . .
  7.     int ret = HdfDeviceNodePublishPublicService(inst, serviceName);
  8.     . . . . . .
  9.     deviceInfo = inst->deviceInfo;
  10.     deviceObject = &devNodeExt->super.deviceObject;
  11.     . . . . . .
  12.     if (deviceInfo->policy == SERVICE_POLICY_CAPACITY) {
  13.         devNodeExt->ioService = HdfIoServiceBind(serviceName, deviceInfo->permission);
  14.         if (devNodeExt->ioService != NULL) {
  15.             devNodeExt->ioService->target = (struct HdfObject*)(&inst->deviceObject);
  16.             static struct HdfIoDispatcher dispatcher = {
  17.                 .Dispatch = DeviceNodeExtDispatch
  18.             };
  19.             devNodeExt->ioService->dispatcher = &dispatcher;
  20.         } else {
  21.             . . . . . .
  22.         }
  23.     }
  24.     return HDF_SUCCESS;
  25. }
复制代码
这样说来，发布服务时其实分了两个部分，一个是发布public部分，一个是发布local部分。分别对应HdfDeviceNodePublishPublicService()和HdfDeviceNodePublishLocalService()。
1.1 发布Public Service部分【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. int HdfDeviceNodePublishPublicService(struct HdfDeviceNode *devNode, const char *svcName)
  2. {
  3.     if ((devNode == NULL) || (devNode->deviceObject.service == NULL)) {
  4.         HDF_LOGE("device method is null");
  5.         return HDF_FAILURE;
  6.     }
  7.     return DevSvcManagerClntAddService(svcName, &devNode->deviceObject);
  8. }
  9. 【drivers/hdf/frameworks/core/host/src/Devsvc_manager_clnt.c】

  11. int DevSvcManagerClntAddService(const char *svcName, struct HdfDeviceObject *service)
  12. {
  13.     struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance();
  14.     . . . . . .
  15.     struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf;
  16.     . . . . . .
  17.     // 其实调用的是 DevSvcManagerAddService()
  18.     return serviceManager->AddService(serviceManager, svcName, service);
  19. }
  20. 【drivers/hdf/frameworks/core/host/src/Devsvc_manager_clnt.c】

  22. struct DevSvcManagerClnt *DevSvcManagerClntGetInstance()
  23. {
  24.     static struct DevSvcManagerClnt *instance = NULL;
  25.     if (instance == NULL) {
  26.         static struct DevSvcManagerClnt singletonInstance;
  27.         DevSvcManagerClntConstruct(&singletonInstance);
  28.         instance = &singletonInstance;
  29.     }
  30.     return instance;
  31. }
复制代码
从代码看，系统中有一个“设备服务管理器”（DevSvcManager），那些功能型设备都会把自己注册进它。这个倒有点儿像Android里的SMS（Service Manager Service），所有系统核心服务都会向SMS里注册自己，以便其他应用可以从SMS查询并获取服务代理。实际上，鸿蒙系统在不少方面倒的确和Android有一定类比性，这个以后我们再对比看看，目前先放下不谈。

注册设备服务的那句serviceManager->AddService()实际上调用的是DevSvcManagerAddService()，该函数会尝试向“设备服务管理器”里添加一个管理节点（DevSvcRecord）：
【drivers/hdf/frameworks/core/manager/src/Devsvc_manager.c】
  1. int DevSvcManagerAddService(struct IDevSvcManager *inst, const char *svcName, struct HdfDeviceObject *service)
  2. {
  3.     struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst;
  4.     . . . . . .
  5.     struct DevSvcRecord *record = DevSvcRecordNewInstance();
  6.     . . . . . .
  7.     record->key = HdfStringMakeHashKey(svcName, 0);
  8.     record->value = service;
  9.     OsalMutexLock(&devSvcManager->mutex);
  10.     HdfSListAdd(&devSvcManager->services, &record->entry);
  11.     OsalMutexUnlock(&devSvcManager->mutex);
  12.     return HdfServiceObserverPublishService(&devSvcManager->observer, svcName, 0, SERVICE_POLICY_PUBLIC, (struct HdfObject *)service->service);
  13. }
复制代码

【drivers/hdf/frameworks/core/host/src/Hdf_service_observer.c】
  1. int HdfServiceObserverPublishService(struct HdfServiceObserver *observer,
  2.     const char *svcName, uint32_t matchId, uint16_t policy, struct HdfObject *service)
  3. {
  4.     struct HdfServiceObserverRecord *serviceRecord = NULL;
  5.     uint32_t serviceKey = HdfStringMakeHashKey(svcName, 0);
  6.     . . . . . .
  7.     serviceRecord = (struct HdfServiceObserverRecord *)HdfSListSearch(&observer->services, serviceKey, HdfServiceObserverRecordCompare);
  8.     if (serviceRecord == NULL) {
  9.         serviceRecord = HdfServiceObserverRecordObtain(serviceKey);
  10.         if (serviceRecord == NULL) {
  11.             HDF_LOGE("PublishService failed, serviceRecord is null");
  12.             return HDF_FAILURE;
  13.         }
  14.         serviceRecord->publisher = service;
  15.         serviceRecord->matchId = matchId;
  16.         serviceRecord->policy = policy;
  17.         HdfSListAdd(&observer->services, &serviceRecord->entry);
  18.     } else {
  19.         serviceRecord->publisher = service;
  20.         HdfServiceObserverRecordNotifySubscribers(serviceRecord, matchId, policy);
  21.     }
  22.     return HDF_SUCCESS;
  23. }
复制代码

对于“设备服务管理器”而言，当它要管理一个设备服务时，主要需要两个Record：
1）DevSvcRecord：每个服务对应一个DevSvcRecord，这个节点会插入DevSvcManager内部的services链表。如果发布服务时，发现对应的DevSvcRecord已经存在了，则会向所有订阅者发出通知。

2）HdfServiceObserverRecord：每个服务对应一个HdfServiceObserverRecord，这个节点会插入DevSvcManager内的observer部分（内部的services链表）里。每个HdfServiceObserverRecord负责维护一个“订阅者”链表，记录所有对该服务感兴趣的订阅者。

DevSvcRecord的value域是个HdfDeviceObject *指针，其实指向的就是和设备对应的DeviceNodeExt节点的deviceObject部分，根据我们以前储备的知识，我们知道这个deviceObject部分的service域指向的就是设备驱动实现的IDeviceIoService接口。

另外，从前面代码的serviceRecord->publisher = service一句，可以看到HdfServiceObserverRecord的publisher域，其实也是指向设备驱动实现的IDeviceIoService接口的。这样我们可以绘制如下的示意图：
当然，一开始HdfServiceObserverRecord里是“订阅者”链表为空啦，不过日后如果有其他服务注册为订阅者了，HdfServiceObserverRecordNotifySubscribers()就可以向它们发送通知了。发通知函数的代码如下：
【drivers/hdf/frameworks/core/host/src/Hdf_observer_record.c】
  1. void HdfServiceObserverRecordNotifySubscribers(struct HdfServiceObserverRecord *record, uint32_t matchId, uint16_t policy)
  2. {
  3.     struct HdfSListIterator it;
  4.     . . . . . .
  5.     OsalMutexLock(&record->obsRecMutex);
  6.     HdfSListIteratorInit(&it, &record->subscribers);
  7.     while (HdfSListIteratorHasNext(&it)) {
  8.         struct HdfServiceSubscriber *subscriber = (struct HdfServiceSubscriber *)HdfSListIteratorNext(&it);
  9.         if ((matchId == subscriber->matchId) || (policy != SERVICE_POLICY_PRIVATE)) {
  10.             subscriber->state = HDF_SUBSCRIBER_STATE_READY;
  11.             if (subscriber->callback.OnServiceConnected != NULL) {
  12.                 subscriber->callback.OnServiceConnected(subscriber->callback.deviceObject, record->publisher);
  13.             }
  14.         }
  15.     }
  16.     OsalMutexUnlock(&record->obsRecMutex);
  17. }
复制代码

其实就是在遍历订阅者链表，回调其callback部分的OnServiceConnected()函数。
订阅者链表里的每个节点是一个HdfServiceSubscriber，示意图如下：
以上这些其实都体现了鸿蒙系统里的一个观念，那就是“设备”其实可以被理解为“服务”。在单机系统里，一个设备的驱动程序可以被理解为一种特殊的库，上层软件通过类似函数调用的方式来调用库，从而操作这个设备。但如果要跨机器地操作设备，那么就不能直接调用函数了。一种较好地方式是将目标设备包装成一个逻辑上的服务，然后供大家使用。所以就必须把“驱动层次”和“服务层次”关联起来，这才有了前文所说的那么多数据机构。现在我们画一张大一点的示意图，把以上概念串一下：
图中画出了体现“设备（驱动）层次”和“服务层次”的两大管理者——DevmgrService和DevSvcManager，可供大家参考。

1.2 发布Local Service部分
看完了发布Public Service的部分，我们接着看HdfDeviceNodePublishService()里发布Local Service的部分。此时调用的是HdfDeviceNodePublishLocalService()。
【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. static int HdfDeviceNodePublishLocalService(
  2.     struct HdfDeviceNode *devNode, const struct HdfDeviceInfo *deviceInfo)
  3. {
  4.     uint32_t matchId;
  5.     . . . . . .
  6.     struct DevHostService *hostService = devNode->hostService;
  7.     . . . . . .
  8.     matchId = HdfMakeHardwareId(deviceInfo->hostId, deviceInfo->deviceId);
  9.     return HdfServiceObserverPublishService(&hostService->observer, deviceInfo->svcName,
  10.         matchId, deviceInfo->policy, (struct HdfObject *)devNode->deviceObject.service);
  11. }
复制代码

请注意，虽然也是在调用HdfServiceObserverPublishService()，但传入的第一个参数是&hostService->observer。也就是说，Public Service对应的监听部分，记录在DevSvcManager里，而Local Service对应的监听部分，则记录在其所属的DevHostService里。
现在我们可以画一张发布驱动的调用关系图：

2 挂接设备我们回过头继续说前文的HdfDeviceLaunchNode()部分。该函数在调用完HdfDeviceNodePublishService()之后，接着就会调用DevmgrServiceClntAttachDevice()。
【drivers/hdf/frameworks/core/host/src/Devmgr_service_clnt.c】
  1. int DevmgrServiceClntAttachDevice(const struct HdfDeviceInfo *deviceInfo, struct IHdfDeviceToken *deviceToken)
  2. {
  3.     struct IDevmgrService *devMgrSvcIf = NULL;
  4.     struct DevmgrServiceClnt *inst = DevmgrServiceClntGetInstance();
  5.     . . . . . .
  6.     devMgrSvcIf = inst->devMgrSvcIf;
  7.     . . . . . .
  8.     // 实际调用的是 DevmgrServiceAttachDevice()
  9.     return devMgrSvcIf->AttachDevice(devMgrSvcIf, deviceInfo, deviceToken);
  10. }
复制代码

此处调用了DevmgrServiceAttachDevice()：
【drivers/hdf/frameworks/core/manager/src/Devmgr_service.c】
  1. static int DevmgrServiceAttachDevice(struct IDevmgrService *inst,
  2. const struct HdfDeviceInfo *deviceInfo, struct IHdfDeviceToken *token)
  3. {
  4.     . . . . . .
  5.     struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, deviceInfo->hostId);
  6.     . . . . . .
  7.     struct IDevHostService *hostService = hostClnt->hostService;
  8.     . . . . . .
  9.     struct DeviceTokenClnt *tokenClnt = DeviceTokenClntNewInstance(token);
  10.     . . . . . .
  11.     tokenClnt->deviceInfo = deviceInfo;
  12.     HdfSListAdd(&hostClnt->devices, &tokenClnt->node);
  13.     return HDF_SUCCESS;
  14. }
复制代码

主要就是向对应的DevHostServiceClnt的devices链表里，添加一个DeviceTokenClnt节点。简单地说就是，一个DevHostServiceClnt和一个DevHostService对应，每当向DevHostService里添加一个HdfDevice节点，相应地就需要在DevHostServiceClnt里添加一个DeviceTokenClnt节点。该节点的tokenIf域记录的IHdfDeviceToken指针，来自于DeviceNodeExt的token域。
说起来，DeviceNodeExt的token其实在DeviceNodeExt构造之时就创建了：
【drivers/hdf/frameworks/core/host/src/Hdf_device_node.c】
  1. void HdfDeviceNodeConstruct(struct HdfDeviceNode *devNode)
  2. {
  3.     if (devNode != NULL) {
  4.         struct IDeviceNode *nodeIf = &devNode->super;
  5.         HdfDeviceObjectConstruct(&devNode->deviceObject);
  6.         devNode->token = HdfDeviceTokenNewInstance();
  7.         nodeIf->LaunchNode = HdfDeviceLaunchNode;
  8.         nodeIf->PublishService = HdfDeviceNodePublishPublicService;
  9.     }
  10. }
复制代码

其中创建token时，调用的是HdfDeviceTokenNewInstance()。
【drivers/hdf/frameworks/core/host/src/Hdf_device_token.c】
  1. struct IHdfDeviceToken *HdfDeviceTokenNewInstance()
  2. {
  3.     return (struct IHdfDeviceToken *)HdfObjectManagerGetObject(HDF_OBJECT_ID_DEVICE_TOKEN);
  4. }
复制代码

【drivers/hdf/frameworks/core/host/src/Hdf_device_token.c】
  1. struct HdfObject *HdfDeviceTokenCreate()
  2. {
  3.     struct HdfDeviceToken *token = (struct HdfDeviceToken *)OsalMemCalloc(sizeof(struct HdfDeviceToken));
  4.     if (token != NULL) {
  5.         HdfDeviceTokenConstruct(token);
  6.     }
  7.     return (struct HdfObject *)token;
  8. }
复制代码

其中HdfDeviceToken的定义如下：
  1. struct HdfDeviceToken {
  2.     struct HdfSListNode node;
  3.     struct IHdfDeviceToken super;
  4. };
复制代码

咦，怎么又有bug的味道，HdfDeviceToken里应该把super放到第一个吧，否则怎么强制转化成struct HdfObject*呢？好在这个bug的危害不太大，后续版本可以调整一下。
现在我们可以再画一张图看看：

3 小结
经过以上分析，我们头脑中已经可以形成一套比较清楚的HDF逻辑结构了。总之就是将“设备（驱动）层次”和“服务层次”联系起来，该加的observer机制加上。好了，这次就先写到这儿，以后我们再补充其他内容。

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


举报

回帖

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