OpenHarmony驱动框架HDF中设备管理服务构建过程详解之一-51CTO.COM

前言

如下图，开源鸿蒙系统驱动框架HDF在内核中的实现，可以分为向用户层提供设备服务的管理模块(Manager)，和实际管理硬件的Host模块。

Manager分为DeviceManageService和 DeviceServiceManage，前者负责提供服务的设备，包括设备驱动匹配、设备驱动装载、设备启动等;后者负责关联设备提供的服务，包括管理Host端提供的设备服务，和接收用户发起的设备服务订阅请求。

图1 开源鸿蒙系统驱动框架软件架构模块图

本文主要关注点在DeviceManageService，叙述其如何启动设备、创建设备服务节点、装载驱动，以及发布服务的过程。

文章内容简介

开源鸿蒙系统驱动框架HDF内核实现部分完全使用C语言实现，也引入了面向对象编程的思想，使用C语言实现了诸如类继承、虚函数、单例类等的概念，使得HDF内核部分包含了大量的对象类型，对象类型又通过的接口形式对外提供服务。

为了向读者展现开源鸿蒙系统驱动框架HDF内核实现蓝图，本文仅仅介绍介绍DevMgr过程中Manager域和Host域内的对象类型与其接口，先奠定读者对HDF内对象类型的基本认识;然后，在下一篇文章中介绍DevMgrService如何启动设备、装载驱动、发布设备服务的整个过程。

本文章节内容如下：

DevMgr域中的对象类型及接口。
Host域中的对象类型及接口。

一、DevMgr域中的对象类型及接口

1、DevmgrService

（1） DevmgrService及接口

DevmgrService是设备管理的总入口，其Hosts域是一个双向链表，hcs设备配置中的所有Host设备被挂载在这个Hosts双向链表上。

DevmgrService内容及其接口定义如下：

struct IDevmgrService {
    struct HdfObject base;
    struct HdfDeviceObject object;
    // 将Host节点链接到DevMgr的hosts列表
    int (*AttachDeviceHost)(struct IDevmgrService *, uint16_t, struct IDevHostService *);
    // 将HDF设备节点以Token的形式连接到host的devices列表
    int (*AttachDevice)(struct IDevmgrService *, const struct HdfDeviceInfo *, struct IHdfDeviceToken *);
    // 启动DevmgrService服务
    int (*StartService)(struct IDevmgrService *);
    int (*PowerStateChange)(struct IDevmgrService *, enum HdfPowerState pEvent);
};

struct DevmgrService {
    struct IDevmgrService super;
    struct DListHead hosts;
    struct OsalMutex devMgrMutex;
};

由DevmgrService结构体的内容可知，DevmgrService只管理者host设备节点。有下面章节可知，Host节点下的所有设备则由Host自己管理。

（2）DevMgrService构建过程

下面DevMgrService构建过程，HDF内核实现部分中使用static局部变量实现了C++中单例类的概念，将DevMgrService作为一个单例类，所有的对象指向同一个实体。

 DevmgrServiceCreate()
    |  // C++，单例类概念
    |-> static struct DevmgrService devmgrServiceInstance;
    |-> DevmgrServiceConstruct(&devmgrServiceInstance)
        |-> devMgrSvcIf = (struct IDevmgrService *)inst;
        |
        |-> devMgrSvcIf->AttachDevice =  DevmgrServiceAttachDevice;
        |-> devMgrSvcIf->AttachDeviceHost = DevmgrServiceAttachDeviceHost;
        |-> devMgrSvcIf->StartService =  DevmgrServiceStartService;
        |-> devMgrSvcIf->PowerStateChange = DevmgrServicePowerStateChange;

（3） IDevmgrService接口介绍

StartService：DevmgrServiceStartService()。

DevmgrServiceStartService()主要功能是挂载并启动hcs设备配置中的所有host设备节点DevmgrService的hosts链表;然后，启动host节点，间接地启动Host节点下的所有设备(装载设备驱动、发布设备服务等)。

DevmgrServiceStartService()
|-> DevmgrServiceStartDeviceHosts()
    |-> DriverInstallerGetInstance() //  installer
    | // (1) 为每一个Hcs配置中的Host设备创建一个DevHostClnt
    |-> HdfAttributeManagerGetHostList(&hostList);
    |-> HdfSListIteratorInit(&it, &hostList);
    |-> hostAttr = HdfSListIteratorNext(&it);
    |
    |-> hostClnt = DevHostServiceClntNewInstance(
    |                    hostAttr->hostId,
    |                    hostAttr->hostName);
    | // (2) 添加HostClnt到DevMgr的hosts链表
    |-> DListInsertTail(&hostClnt->node, &inst->hosts);
    |
    | // (3) 启动host设备对应的DevHostClnt。
    |-> hostClnt->hostPid = installer->StartDeviceHost()

AttachDeviceHost：DevmgrServiceAttachDeviceHost()。

DevmgrServiceAttachDeviceHost()遍历host节点先的所有设备信息，使用DriverLoader构建设备节点，装载驱动，发布服务，然后将设备链接到Host的devices列表。

DevmgrServiceAttachDeviceHost( struct IDevmgrService *inst, uint16_t hostId,
|                               struct IDevHostService *hostService) 
|
| // DevHostServiceClnt 已经在 StartDeviceHost() 内按照hcs设备配置树中的host节点创建
|-> struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, hostId);
|
|-> hostClnt->hostService = hostService;
|   // 获得Host节点下所有的设备节点配置信息
|-> hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList()
|-> hostClnt->devCount = HdfSListCount(hostClnt->deviceInfos);
|
|-> DevHostServiceClntInstallDriver(hostClnt)
    | // 遍历 Host 节点下的所有设备（设备+驱动），并将它们挂载到host的devices列表
    |-> HdfSListIteratorInit(&it, hostClnt->deviceInfos);
    |-> deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&it);
    |-> devHostSvcIf->AddDevice(devHostSvcIf, deviceInfo);

AttachDevice：DevmgrServiceAttachDevice。

被AttachDeviceHost接口实现DevmgrServiceAttachDeviceHost()调用，在完成host下的设备的驱动匹配、装载及设备服务发布后，将HdfDeviceNode以Token的Token 的形式挂接到 DevHostServiceClnt 的 devices 链表。具体过程如下：

DevmgrServiceAttachDevice(struct IDevmgrService *inst, 
|                          const struct HdfDeviceInfo *deviceInfo,
|                          struct IHdfDeviceToken *token)
|
|-> struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, deviceInfo->hostId);
|-> struct DeviceTokenClnt *tokenClnt = 
|                DeviceTokenClntNewInstance(token); // tokenClnt包含指针指向DeviceToken
|                |-> tokenClnt = (struct DeviceTokenClnt *)OsalMemCalloc(sizeof(struct DeviceTokenClnt));
|                |-> DeviceTokenClntConstruct(tokenClnt, tokenIf);
|                    |-> tokenClnt->tokenIf = tokenIf;
|
|-> tokenClnt->deviceInfo = deviceInfo;
|-> DevmgrServiceUpdateStatus(hostClnt, deviceInfo->deviceId, HDF_SERVICE_USABLE);
|-> HdfSListAdd(&hostClnt->devices, &tokenClnt->node);

2、DevHostServiceClnt

（1） DevHostServiceClnt对象类型

DevHostServiceClnt为Host域内DevHostService的概念在Manager域的一个表示，hostService成员为IDevHostService的指针，指向被DevHostService包含的IDevHostService对象地址。此处，又借鉴了C++中基类的概念。

struct DevHostServiceClnt {
    struct DListHead node;               // 链表节点，host设备依次对象挂载在DevMgrService的hosts链表上
    struct HdfSList devices;             // 链表，挂载所有host下的所有设备（以token的形式）
    struct HdfSList *deviceInfos;        // 属于Host设备的所有子设备的devInfo信息
    Map *deviceHashMap;
    struct IDevHostService *hostService; // 指向Host域的host设备服务的实现
    uint16_t devCount;                   // 子设备个数
    uint16_t hostId;                     // 系统内Host设备节点标识，按照加载顺序依次+1；
    int hostPid;                         // 父Host设备节点标识
    const char *hostName;                // Host设备名
};

（2） DevHostServiceClnt 构建流程

DevHostServiceClnt的构建过程如下，若该DevHostServiceClnt不存在，则创建一个对象，初始化其hostService和deviceInfos成员，在其下的设备完全启动后，则将该对象链接到DevMgrService的hosts链表。

static int DevmgrServiceAttachDeviceHost(
    struct IDevmgrService *inst, uint16_t hostId, struct IDevHostService *hostService)
{
    struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, hostId);
    if (hostClnt == NULL) {
        HDF_LOGE("failed to attach device host, hostClnt is null");
        return HDF_FAILURE;
    }
    if (hostService == NULL) {
        HDF_LOGE("failed to attach device host, hostService is null");
        return HDF_FAILURE;
    }

    hostClnt->hostService = hostService;
    hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList(hostClnt->hostId, hostClnt->hostName);
    if (hostClnt->deviceInfos == NULL) {
        HDF_LOGW("failed to get device list ");
        return HDF_SUCCESS;
    }
    hostClnt->devCount = HdfSListCount(hostClnt->deviceInfos);
    return DevHostServiceClntInstallDriver(hostClnt);
}

二、Host域内对象类型与接口

1、DriverInstaller

（1） DriverInstaller 结构体内容描述

DriverInstaller的功能是根据Hcs设备配置文件中的host节点的名称，启动Host节点服务，包括依次创建Host节点下的所有设备、匹配设备驱动、初始化驱动，发布设备服务等。DriverInstaller的内容定义如下：

struct IDriverInstaller {
    struct HdfObject object;
    int (*StartDeviceHost)(uint32_t, const char *);
};
struct DriverInstaller {
    struct IDriverInstaller super;
};

（2） DriverInstaller构建过程

DriverInstaller 也作为单例类，使用同一个局部static变量实现。

DriverInstallerCreate()
|-> static struct DriverInstaller driverInstaller;
|
|-> DriverInstallerConstruct(&driverInstaller);
    |-> driverInstallIf->StartDeviceHost = DriverInstallerStartDeviceHost;

（3） DriverInstaller 接口简介StartDeviceHost : DriverInstallerStartDeviceHost()

DriverInstallerStartDeviceHost()名义上是启动Host节点服务，实则通过DevMgrService在Host域的client(DevmgrServiceClnt)挂载Host节点到DevMgrService的hosts链表，同时还通过DevHostService的AddDevice()接口将host节点其下的所有设备依次匹配驱动、加载驱动、发布设备服务等。

DriverInstallerStartDeviceHost(uint32_t devHostId, const char *devHostName)
| // 创建Host端DevService
|-> struct IDevHostService *hostServiceIf = DevHostServiceNewInstance(devHostId, devHostName);
|
| // hostServiceIf->StartService(hostServiceIf);
|-> DevHostServiceStartService()
    |-> DevmgrServiceClntAttachDeviceHost()
        | // 创建Host端的DevMgr的Client（“代理”，更合适）, DevmgrServiceClnt即IDevmgrService
        |-> struct DevmgrServiceClnt *inst = DevmgrServiceClntGetInstance();
        |
        | // 将hostService、devInfo和hostClnt关联，并装载匹配的设备驱动
        | // devMgrSvcIf->AttachDeviceHost()
        |-> DevmgrServiceAttachDeviceHost() 
            |-> struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, hostId);
            |-> hostClnt->hostService = hostService;
            |-> hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList()
            |-> DevHostServiceClntInstallDriver(hostClnt)

2、DriverLoader

（1） DriverLoader 结构体

DriverLoader主要是完成Host节点下的设备的装载，包括匹配驱动(GetDriverEntry())、初始化驱动、发布设备服务等。

struct IDriverLoader {
    struct HdfObject object;
    struct HdfDriverEntry *(*GetDriverEntry)(const struct HdfDeviceInfo *deviceInfo);
    struct HdfDeviceNode *(*LoadNode)(struct IDriverLoader *, const struct HdfDeviceInfo *deviceInfo);
    void (*UnLoadNode)(struct IDriverLoader *, const struct HdfDeviceInfo *deviceInfo);
};
struct HdfDriverLoader {
    struct IDriverLoader super;
};

（2） DriverLoader 构建

DriverLoader 同样也作为单例类，使用同一个局部static变量实现，比较其不独占任何设备，只是完成设备节点驱动的装载。

HdfDriverLoaderCreate()
|-> static struct HdfDriverLoader driverLoader;
|
|-> HdfDriverLoaderConstruct(&driverLoader);
    |-> struct IDriverLoader *driverLoaderIf = (struct IDriverLoader *)inst;
    |-> driverLoaderIf->LoadNode = HdfDriverLoaderLoadNode;
    |-> driverLoaderIf->UnLoadNode = HdfDriverLoaderUnLoadNode;
    |-> driverLoaderIf->GetDriverEntry = HdfDriverLoaderGetDriverEntry;

（3） DriverLoader 接口简介

GetDriverEntry : HdfDriverLoaderGetDriverEntry()。

从DriverEntry列表中获得指定设备的驱动：

HdfDriverLoaderGetDriverEntry()
|-> static struct HdfDriverEntry *driverEntry = NULL;
|-> static int32_t driverCount = 0;
|
|-> strcmp(deviceInfo->moduleName, driverEntry[i].moduleName) == 0
|-> return &driverEntry[i];

LoadNode ： HdfDriverLoaderLoadNode()。

简介调用自己的接口GetDriverEntry()完成驱动匹配，然后将设备驱动提供的ioService与HdfDeviceNode的IoService绑定。

HdfDriverLoaderLoadNode(struct IDriverLoader *loader,
|                          const struct HdfDeviceInfo *deviceInfo)
|    // 获得对应设备驱动对象
|-> driverEntry = loader->GetDriverEntry(deviceInfo);
|    // 创建设备节点
|-> devNode = HdfDeviceNodeNewInstance();
|    // 绑定驱动与设备节点
|-> devNode->driverEntry = driverEntry;
|-> devNode->deviceInfo = deviceInfo;
|   // 绑定设备服务与IoService
|-> driverEntry->Bind(&devNode->deviceObject)
|
|-> return devNode;

3、DevHostService

Sorry，前面引用了那么多Host，一直未明确其概念。 Host在开源鸿蒙系统中可以理解为平台设备子系统，例如display、Input、Network、Sensor、storage等，在这些子系统中又保护了多种接口的实现。以Display子系统为例，可以是SPI接口的设备，也可以是SDIO接口的设备;而具体到SPI设备，有包括了SPI设备1、2、3等。所以才有了“图1.1.1 DevMgr与host及设备关系图”描述的Host与设备之间的关系。

在host域中，使用DevHostService为host设备节点。

（1） DevHostService 结构体

DevHostService作为Host设备在Host域中的表示，管理着其下的所有设备，每一个具体的设备都以HdfDevice的形式挂载到DevHostService的devices链表，不同于DevHostServiceClnt对设备的管理。

struct IDevHostService {
    struct HdfObject object;
    // 添加设备到DevHostService到devices链表
    int (*AddDevice)(struct IDevHostService *hostService, const struct HdfDeviceInfo *devInfo);
    int (*DelDevice)(struct IDevHostService *hostService, const struct HdfDeviceInfo *devInfo);
    // 启动host服务
    int (*StartService)(struct IDevHostService *hostService);
    int (*PmNotify)(struct IDevHostService *service, uint32_t powerState);
};
struct DevHostService {
    struct IDevHostService super;
    uint16_t hostId;                // host设备在系统中的唯一表示，按照加载顺序，依次+1
    const char *hostName;
    struct DListHead devices;       // 链表，挂载着host下所有设备的
    struct HdfServiceObserver observer;
    struct HdfSysEventNotifyNode sysEventNotifyNode;
｝

（2） DevHostService 构建流程

DevHostService对象的构建比较简单，分配内存，然后初始化，因为对应的是一个个的Host节点，所有也没有单例类的感念。

void DevHostServiceConstruct(struct DevHostService *service)
{
    struct IDevHostService *hostServiceIf = &service->super;
    if (hostServiceIf != NULL) {
        hostServiceIf->AddDevice = DevHostServiceAddDevice;
        hostServiceIf->DelDevice = DevHostServiceDelDevice;
        hostServiceIf->StartService = DevHostServiceStartService;
        hostServiceIf->PmNotify = DevHostServicePmNotify;
        DListHeadInit(&service->devices);
        HdfServiceObserverConstruct(&service->observer);
    }
}

（3） IDevHostService 接口简介

StartService : DevHostServiceStartService()。

DevHostServiceStartService()启动HostService，间接调用AddDevice接口，依次加载host下的所有子设备。

DevHostServiceStartService(struct IDevHostService *service)
|-> DevmgrServiceClntAttachDeviceHost()
    |  //  通过DevMgr在Host端的Client，调用
    |-> DevmgrServiceAttachDeviceHost()
        | // 将DevService和deviceInfo与DevHostClnt关联。
        |-> hostClnt->hostService = hostService;
        |-> hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList()
        |
        |-> DevHostServiceClntInstallDriver(hostClnt)
            |-> devHostSvcIf = (struct IDevHostService *)hostClnt->hostService;
            |-> HdfSListIteratorInit(&it, hostClnt->deviceInfos);
            |-> deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&it);
            |-> devHostSvcIf->AddDevice(devHostSvcIf, deviceInfo);

AddDevice : DevHostServiceAddDevice()。

DevHostServiceAddDevice()的功能前面有所带过，主要是根据deviceInfo创建HdfDevice对象、匹配设备驱动、装载设备驱动、DevHostServiceClnt的devcies链表等。

DevHostServiceAddDevice(struct IDevHostService *inst, struct HdfDeviceInfo *deviceInfo)
|-> struct HdfDevice *device = NULL;
|-> struct DevHostService *hostService = CONTAINER_OF(inst, struct DevHostService, super);
|
|-> device = DevHostServiceGetDevice(hostService, deviceInfo->deviceId);
|
|-> devNode = driverLoader->LoadNode(driverLoader, deviceInfo);
|                            |-> HdfDriverLoaderLoadNode()
|                                |-> 
|                                |-> 
|                                |-> driverEntry = loader->GetDriverEntry(deviceInfo);
|                                |                          |-> HdfDriverLoaderGetDriverEntry()
|                                | 
|                                |-> devNode = HdfDeviceNodeNewInstance();
|                                |-> devNode->driverEntry = driverEntry;
|                                |-> devNode->deviceInfo = deviceInfo;
|                                |-> devNode->deviceObject.xx = xx;
|                                | // 绑定HdfDevice与DeviceIoService
|                                | // Device -> service -> Dispatch
|                                |-> driverEntry->Bind(&devNode->deviceObject)
| // 将服务于设备相关联
|-> devNode->hostService = hostService;
| // 挂载DevNode到设备（同一接口设备类）的节点列表（一个设备类中的一个具体设备）
|-> device->super.Attach(&device->super, devNode);

4、HdfDevice

（1） HdfDevice 及接口

HdfDevice为Host下的设备在Host域内的表示，内容如下：

struct IHdfDevice {
    struct HdfObject object;
    // 挂载HdfDeviceNode到HdfDevice的node链表
    int (*Attach)(struct IHdfDevice *, struct HdfDeviceNode *);
    void (*Detach)(struct IHdfDevice *, struct HdfDeviceNode *);
};
struct HdfDevice {
    struct IHdfDevice super;
    struct DListHead node;
    struct DListHead devNodes;  // 某接口相同的设备类的具体设备节点，如I2C总线上挂着设备0，设备1
    uint16_t deviceId;          // 接口相同的设备类，例如UART、I2C等。
    uint16_t hostId;            // 应用子设备系统类，例如：display、Input、Network、Sensor、storage等。
};

（2） HdfDevice 构建流程

比较简单，分配对象内存空间，然后初始化接口和其中的链表：

void HdfDeviceConstruct(struct HdfDevice *device)
{
    device->super.Attach = HdfDeviceAttach;
    DListHeadInit(&device->devNodes);
}
struct HdfObject *HdfDeviceCreate()
{
    struct HdfDevice *device =
        (struct HdfDevice *)OsalMemCalloc(sizeof(struct HdfDevice));
    if (device != NULL) {
        HdfDeviceConstruct(device);
    }
    return (struct HdfObject *)device;
}

HdfDevice为Host域内一个设备的表示，一个HdfDevice可以对应多个DeviceNode节点，但是一个DeviceNode节点只对应一个设备驱动。即用户可以将设备驱动程序进行分层，协同完成对设备的支撑。

（3） IHdfDevice 接口 Attach 简介

HdfDeviceAttach()的功能是(1)将设备Node节点挂载到设备的DevNode检点链表上;(2)然后启动节点，即初始化驱动、发布设备服务等。

static int HdfDeviceAttach(struct IHdfDevice *devInst, struct HdfDeviceNode *devNode)
{
    struct HdfDevice *device = (struct HdfDevice *)devInst;
    struct IDeviceNode *nodeIf = (struct IDeviceNode *)devNode;
    if (device == NULL || nodeIf == NULL || nodeIf->LaunchNode == NULL) {
        HDF_LOGE("failed to attach device, input params invalid");
        return HDF_ERR_INVALID_PARAM;
    }
    DListInsertTail(&devNode->entry, &device->devNodes);
    return nodeIf->LaunchNode(devNode, devInst);
}

5、HdfDeviceNode(DeviceNodeExt)

设备节点，对应着一个设备服务节点，与DriverEntry一一对应。

（1） HdfDeviceNode与DeviceNodeExt对象类型定义

现在才是真正与驱动一一对应的设备节点，代表着一个服务设备。

struct IDeviceNode {
    struct HdfObject object;
    // 发布设备服务
    int (*PublishService)(struct HdfDeviceNode *, const char *);
    // 启动设备节点
    int (*LaunchNode)(struct HdfDeviceNode *, struct IHdfDevice *);
};
struct HdfDeviceNode {
    struct IDeviceNode super;
    struct DListHead entry;
    struct PowerStateToken *powerToken;
    struct DevHostService *hostService;
    struct HdfDeviceObject deviceObject;
    struct IHdfDeviceToken *token;
    struct HdfDriverEntry *driverEntry;
    const struct HdfDeviceInfo *deviceInfo;
};

struct DeviceNodeExt {
    struct HdfDeviceNode super;
    struct HdfIoService *ioService;
};

（2） DeviceNodeExt 构建流程

DeviceNodeExt包含HdfDeviceNode，在C++上表现为继承关系，构建过程如下：

DeviceNodeExtCreate()
|-> struct DeviceNodeExt *instance =
|            (struct DeviceNodeExt *)OsalMemCalloc();
|
|-> DeviceNodeExtConstruct()
    |-> HdfDeviceNodeConstruct()
    |    |-> struct IDeviceNode *nodeIf = &devNode->super;
    |    |-> devNode->token = HdfDeviceTokenNewInstance();
    |    |-> nodeIf->LaunchNode = HdfDeviceLaunchNode;
    |    |-> nodeIf->PublishService = HdfDeviceNodePublishPublicService; // 被覆盖
    |
    |-> nodeIf->PublishService = DeviceNodeExtPublishService;

（3） HdfDeviceNode 接口简介

LaunchNode : HdfDeviceLaunchNode()。

HdfDeviceLaunchNode()功能为启动设备节点，初始化设备驱动吗，间接地调用PublishService接口发布设备服务。

HdfDeviceLaunchNode(struct HdfDeviceNode *devNode, struct IHdfDevice *devInst)
|-> device = (struct HdfDevice *)devInst;
|-> driverEntry = devNode->driverEntry;
|
|    // （1）初始化设备驱动
|-> driverEntry->Init(&devNode->deviceObject);
|    // （2）发布设备服务，挂载
|-> HdfDeviceNodePublishService()
|    |  // 将设备节点发布到系统设备节点，并添加服务到DevSvcMgr的服务链表
|    |-> // nodeIf->PublishService()
|    |-> HdfDeviceNodePublishLocalService()
|
|    // （3）挂载HDFDevice到DevMgr的设备链表
|-> deviceToken = devNode->token;
|    // 挂载DevNode（通过DeviceToken）到DevHostServiceClnt的device链表上。
|-> DevmgrServiceClntAttachDevice()
    |-> DevmgrServiceClnt *inst = DevmgrServiceClntGetInstance();
    |-> devMgrSvcIf = inst->devMgrSvcIf;
    | // 将Device挂载DevMgr的设备链表上，以DeviceTokenClnt的形式挂载
    |-> devMgrSvcIf->AttachDevice(devMgrSvcIf, deviceInfo, deviceToken);

PublishService : HdfDeviceNodePublishPublicService()。

发布设备服务即为发布设备节点(DevNode)头部的HdfObject。

DeviceNodeExtPublishService(struct HdfDeviceNode *inst, const char *serviceName)
|-> HdfDeviceNodePublishPublicService() // 发布Public服务
|    |-> DevSvcManagerClntAddService()
|        |-> devSvcMgrClnt = DevSvcManagerClntGetInstance();
|        |-> serviceManager = devSvcMgrClnt->devSvcMgrIf; // SvcMgrClnt即为SvcMgr的代理
|        |   // 添加设备服务到设备服务管理器
|        |-> serviceManager->AddService(serviceManager, svcName, service);
|    
|    // 创建设备节点，返回与之关联的VnodeAdapter的ioService域
|-> devNodeExt->ioService = HdfIoServicePublish()
|-> static struct HdfIoDispatcher dispatcher = {
|->        .Dispatch = DeviceNodeExtDispatch
|-> };
|-> devNodeExt->ioService->dispatcher = &dispatcher;

6、HdfDriverEntry

HdfDriverEntry即设备驱动对象，对应一个设备节点。

struct HdfDriverEntry {
    // Driver version
    int32_t moduleVersion;    
    // Driver module name, to match the driver information in .hcs file
    const char *moduleName;
    //to bind DriverIoService to HdfDevService
    int32_t (*Bind)(struct HdfDeviceObject *deviceObject); //
    // Initializes the driver.
    int32_t (*Init)(struct HdfDeviceObject *deviceObject);    
    // Releases driver resources
    void (*Release)(struct HdfDeviceObject *deviceObject);
};

三、总结

至此，本文已经介绍了DevMgrService构建过程中遇到的绝大部分对象类型，其目的是先为读者勾画出每个对象类型的功能，使读者在阅读源码的初始阶段，可以在不深入调入流程的情况下，对DevMgrService的构建流程有个大概的印象，而不是被代码牵引，一层层向下深入，最后被众多的对象所淹没。

以此铺垫，在下一篇文章中，将介绍DevMgrService的构建过程，众多的对象类型，诸如DevHostServiceClnt、DevHostService、HdfDevice、HdfDeviceNode、HdfDriverEntry以及HdfDeviceToken等，将关联成一张负责的关系网。

想了解更多关于开源的内容，请访问：

51CTO 开源基础软件社区

https://ost.51cto.com。