关于harmonyos:互斥锁Mutex鸿蒙轻内核中处理临界资源独占的法官

34次阅读

共计 7975 个字符，预计需要花费 20 分钟才能阅读完成。

摘要： 本文率领大家一起分析鸿蒙轻内核的互斥锁模块的源代码，蕴含互斥锁的构造体、互斥锁池初始化、互斥锁创立删除、申请开释等。

本文分享自华为云社区《鸿蒙轻内核 M 核源码剖析系列十 互斥锁 Mutex》，原文作者：zhushy。

多任务环境下会存在多个工作拜访同一公共资源的场景，而有些公共资源是非共享的临界资源，只能被独占应用。鸿蒙轻内核应用互斥锁来防止这种抵触，互斥锁是一种非凡的二值性信号量，用于实现对临界资源的独占式解决。另外，互斥锁能够解决信号量存在的优先级翻转问题。用互斥锁解决临界资源的同步拜访时，如果有工作拜访该资源，则互斥锁为加锁状态。此时其余工作如果想拜访这个临界资源则会被阻塞，直到互斥锁被持有该锁的工作开释后，其余工作能力从新拜访该公共资源，此时互斥锁再次上锁，如此确保同一时刻只有一个工作正在拜访这个临界资源，保障了临界资源操作的完整性。

本文咱们来一起学习下鸿蒙轻内核互斥锁模块的源代码，本文中所波及的源码，以 OpenHarmony LiteOS- M 内核为例，均能够在开源站点 https://gitee.com/openharmony… 获取。

接下来，咱们看下互斥锁的构造体，互斥锁初始化，互斥锁罕用操作的源代码。

1、互斥锁构造体定义和罕用宏定义

1.1 互斥锁构造体定义

在文件 kernel\include\los_mux.h 定义的互斥锁管制块构造体 LosMuxCB，源代码如下，构造体成员的解释见正文局部。

typedef struct {
    UINT8 muxStat;       /**< 互斥锁状态：OS_MUX_UNUSED, OS_MUX_USED */
    UINT16 muxCount;     /**< 锁被持有的次数 */
    UINT32 muxID;        /**< 互斥锁 Id */
    LOS_DL_LIST muxList; /**< 互斥锁双向链表 */
    LosTaskCB *owner;    /**< 以后持有锁的工作 */
    UINT16 priority;     /**< 以后持有锁的工作的优先级，为防止优先级翻转，可能会更改工作的优先级，此时有备份的作用 */
} LosMuxCB;

1.2 互斥锁罕用宏定义

零碎反对创立多少互斥锁是依据开发板状况应用宏 LOSCFG_BASE_IPC_MUX_LIMIT 定义的，互斥锁 muxId 是 UINT32 类型的，muxId 取值为 [0,LOSCFG_BASE_IPC_MUX_LIMIT)，示意互斥锁池中各个的互斥锁的编号。

⑴处、⑵处的宏示意互斥锁的未应用、应用状态值。⑶处从互斥锁池中获取指定互斥锁 muxid 对应的互斥锁管制块。⑷处依据互斥锁双向链表中的链表节点指针 ptr 获取互斥锁管制块构造体指针。

⑴    #define OS_MUX_UNUSED 0

⑵    #define OS_MUX_USED   1

⑶    #define GET_MUX(muxid) (((LosMuxCB *)g_allMux) + (muxid))

⑷    #define GET_MUX_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosMuxCB, muxList)

2、互斥锁初始化

互斥锁在内核中默认开启，用户能够通过宏 LOSCFG_BASE_IPC_MUX 进行敞开。开启互斥锁的状况下，在系统启动时，在 kernel\src\los_init.c 中调用 OsMuxInit() 进行互斥锁模块初始化。

上面，咱们剖析下互斥锁初始化的代码。

⑴初始化双向循环链表 g_unusedMuxList，保护未应用的互斥锁。⑵处如果没有设置宏 LOSCFG_BASE_IPC_MUX，则返回错误码。⑶为互斥锁申请内存，如果申请失败，则返回谬误 LOS_ERRNO_MUX_NO_MEMORY
⑷循环每一个互斥锁进行初始化，为每一个互斥锁节点指定索引 muxID，muxStat 为未应用 OS_MUX_UNUSED，并把互斥锁节点插入未应用互斥锁双向链表 g_unusedMuxList。
⑷如果开启了互斥锁调测开关，则调用函数 UINT32 OsMuxDbgInit(VOID) 进行初始化。

LITE_OS_SEC_TEXT_INIT UINT32 OsMuxInit(VOID)
{
    LosMuxCB *muxNode = NULL;
    UINT32 index;

⑴  LOS_ListInit(&g_unusedMuxList);

⑵  if (LOSCFG_BASE_IPC_MUX_LIMIT == 0) {return LOS_ERRNO_MUX_MAXNUM_ZERO;}

⑶  g_allMux = (LosMuxCB *)LOS_MemAlloc(m_aucSysMem0, (LOSCFG_BASE_IPC_MUX_LIMIT * sizeof(LosMuxCB)));
    if (g_allMux == NULL) {return LOS_ERRNO_MUX_NO_MEMORY;}

⑷  for (index = 0; index < LOSCFG_BASE_IPC_MUX_LIMIT; index++) {muxNode = ((LosMuxCB *)g_allMux) + index;
        muxNode->muxID = index;
        muxNode->muxStat = OS_MUX_UNUSED;
        LOS_ListTailInsert(&g_unusedMuxList, &muxNode->muxList);
    }
    return LOS_OK;
}

3、互斥锁罕用操作

3.1 互斥锁创立

咱们能够应用函数 UINT32 LOS_MuxCreate(UINT32 *muxHandle) 来创立互斥锁，上面通过剖析源码看看如何创立互斥锁的。

⑴判断未应用互斥锁链表 g_unusedMuxList 是否为空，如果没有能够应用的互斥锁，跳转到错误码。⑵处如果 g_unusedMuxList 不为空，则获取第一个可用的互斥锁节点，接着从双向链表 g_unusedMuxList 中删除，而后调用 GET_MUX_LIST 宏函数获取 LosMuxCB muxCreated，接着初始化创立的互斥锁信息，蕴含持有锁的次数、状态、优先级等信息。⑶初始化双向链表 &muxCreated->muxList，阻塞在这个互斥锁上的工作会挂在这个链表上。⑷赋值给输入参数 muxHandle，后续程序应用这个互斥锁 Id 对互斥锁进行其余操作。

LITE_OS_SEC_TEXT_INIT UINT32 LOS_MuxCreate(UINT32 *muxHandle)
{
    UINT32 intSave;
    LosMuxCB *muxCreated = NULL;
    LOS_DL_LIST *unusedMux = NULL;
    UINT32 errNo;
    UINT32 errLine;

    if (muxHandle == NULL) {return LOS_ERRNO_MUX_PTR_NULL;}

    intSave = LOS_IntLock();
⑴  if (LOS_ListEmpty(&g_unusedMuxList)) {LOS_IntRestore(intSave);
        OS_GOTO_ERR_HANDLER(LOS_ERRNO_MUX_ALL_BUSY);
    }

⑵  unusedMux = LOS_DL_LIST_FIRST(&(g_unusedMuxList));
    LOS_ListDelete(unusedMux);
    muxCreated = (GET_MUX_LIST(unusedMux));
    muxCreated->muxCount = 0;
    muxCreated->muxStat = OS_MUX_USED;
    muxCreated->priority = 0;
    muxCreated->owner = (LosTaskCB *)NULL;
⑶  LOS_ListInit(&muxCreated->muxList);
⑷  *muxHandle = (UINT32)muxCreated->muxID;
    LOS_IntRestore(intSave);
    OsHookCall(LOS_HOOK_TYPE_MUX_CREATE, muxCreated);
    return LOS_OK;
ERR_HANDLER:
    OS_RETURN_ERROR_P2(errLine, errNo);
}

3.2 互斥锁删除

咱们能够应用函数 LOS_MuxDelete(UINT32 muxHandle) 来删除互斥锁，上面通过剖析源码看看如何删除互斥锁的。

⑴处判断互斥锁 muxHandle 是否超过 LOSCFG_BASE_IPC_MUX_LIMIT，如果超过则返回错误码。⑵获取互斥锁管制块 LosMuxCB *muxDeleted。⑶如果要删除的互斥锁处于未应用状态，跳转到谬误标签进行解决。⑷如果互斥锁的持有者数量不为空，不容许删除，跳转到谬误标签进行解决。⑸把删除的互斥锁回收到未应用互斥锁双向链表 g_unusedMuxList，而后更新为未应用状态。

LITE_OS_SEC_TEXT_INIT UINT32 LOS_MuxDelete(UINT32 muxHandle)
{
    UINT32 intSave;
    LosMuxCB *muxDeleted = NULL;
    UINT32 errNo;
    UINT32 errLine;

⑴  if (muxHandle >= (UINT32)LOSCFG_BASE_IPC_MUX_LIMIT) {OS_GOTO_ERR_HANDLER(LOS_ERRNO_MUX_INVALID);
    }

⑵  muxDeleted = GET_MUX(muxHandle);
    intSave = LOS_IntLock();
⑶  if (muxDeleted->muxStat == OS_MUX_UNUSED) {LOS_IntRestore(intSave);
        OS_GOTO_ERR_HANDLER(LOS_ERRNO_MUX_INVALID);
    }

⑷  if ((!LOS_ListEmpty(&muxDeleted->muxList)) || muxDeleted->muxCount) {LOS_IntRestore(intSave);
        OS_GOTO_ERR_HANDLER(LOS_ERRNO_MUX_PENDED);
    }

⑸  LOS_ListAdd(&g_unusedMuxList, &muxDeleted->muxList);
    muxDeleted->muxStat = OS_MUX_UNUSED;

    LOS_IntRestore(intSave);

    OsHookCall(LOS_HOOK_TYPE_MUX_DELETE, muxDeleted);
    return LOS_OK;
ERR_HANDLER:
    OS_RETURN_ERROR_P2(errLine, errNo);
}

3.3 互斥锁申请

咱们能够应用函数 UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout) 来申请互斥锁，须要的 2 个参数别离是互斥锁 Id 和等待时间 timeout，单位 Tick，取值范畴为 [0, LOS_WAIT_FOREVER]。

上面通过剖析源码看看如何申请互斥锁的。

申请互斥锁时首先会进行互斥锁 Id、参数的合法性校验，这些比较简单。⑴处代码获取以后运行的工作，⑵如果互斥锁没有被持有，更新互斥锁的持有次数、持有者信息和优先级，实现互斥锁的申请。⑶处如果互斥锁的持有次数不为 0，并且被当前任务持有，能够持有次数加 1，再次嵌套持有，实现互斥锁的申请。如果代码执行到⑷，阐明申请的互斥锁被其余工作持有着，此时如果等待时间为 0，则申请失败返回。⑸处更新当前任务阻塞在申请的互斥锁上。

⑹处代码示意在以后申请互斥锁的工作优先级高于持有互斥锁的工作优先级时，批改持有互斥锁的优先级为当前任务的优先级。通过这样的批改，能够防止优先级翻转。⑺处调用函数 OsSchedTaskWait() 更新当前任务的状态，设置等待时间，而后调用函数 LOS_Schedule 触发任务调度。后续程序临时不再执行，须要等到能够获取互斥锁或者工夫超时。

如果工夫超时或者申请到互斥锁，零碎从新调度到执行此工作，程序从⑻处继续执行。如果是工夫超时，⑼处更新工作状态并返回码，申请互斥锁失败。如果胜利申请到互斥锁，执行⑽，返回胜利。

LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout)
{
    UINT32 intSave;
    LosMuxCB *muxPended = NULL;
    UINT32 retErr;
    LosTaskCB *runningTask = NULL;

    if (muxHandle >= (UINT32)LOSCFG_BASE_IPC_MUX_LIMIT) {OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    }

    muxPended = GET_MUX(muxHandle);
    intSave = LOS_IntLock();
    retErr = OsMuxValidCheck(muxPended);
    if (retErr) {goto ERROR_MUX_PEND;}

⑴  runningTask = (LosTaskCB *)g_losTask.runTask;
⑵  if (muxPended->muxCount == 0) {
        muxPended->muxCount++;
        muxPended->owner = runningTask;
        muxPended->priority = runningTask->priority;
        LOS_IntRestore(intSave);
        goto HOOK;
    }

⑶  if (muxPended->owner == runningTask) {
        muxPended->muxCount++;
        LOS_IntRestore(intSave);
        goto HOOK;
    }

⑷  if (!timeout) {
        retErr = LOS_ERRNO_MUX_UNAVAILABLE;
        goto ERROR_MUX_PEND;
    }

⑸  runningTask->taskMux = (VOID *)muxPended;

⑹  if (muxPended->owner->priority > runningTask->priority) {(VOID)OsSchedModifyTaskSchedParam(muxPended->owner, runningTask->priority);
    }

⑺  OsSchedTaskWait(&muxPended->muxList, timeout);

    LOS_IntRestore(intSave);
    OsHookCall(LOS_HOOK_TYPE_MUX_PEND, muxPended);
    LOS_Schedule();

⑻  intSave = LOS_IntLock();
    if (runningTask->taskStatus & OS_TASK_STATUS_TIMEOUT) {⑼      runningTask->taskStatus &= (~OS_TASK_STATUS_TIMEOUT);
        retErr = LOS_ERRNO_MUX_TIMEOUT;
        goto ERROR_MUX_PEND;
    }

    LOS_IntRestore(intSave);
⑽  return LOS_OK;

HOOK:
    OsHookCall(LOS_HOOK_TYPE_MUX_PEND, muxPended);
    return LOS_OK;

ERROR_MUX_PEND:
    LOS_IntRestore(intSave);
    OS_RETURN_ERROR(retErr);
}

3.4 互斥锁开释

咱们能够应用函数 UINT32 LOS_MuxPost(UINT32 muxHandle) 来开释互斥锁，上面通过剖析源码看看如何开释互斥锁的。

开释互斥锁时首先会进行互斥锁 Id、参数的合法性校验，这些比较简单，自行浏览即可。⑴处如果要开释的互斥锁没有被持有、或者不是被当前任务持有，返回错误码。⑵互斥锁的持有数量减 1，如果不为 0，当前任务嵌套持有该互斥锁，不须要调度，返回开释互斥锁胜利。如果开释一次后，当前任务不再持有互斥锁，则执行⑶，如果持有互斥锁工作的优先级不等于互斥锁的备份优先级低，须要复原当前任务的优先级。

⑷如果互斥锁上还有其余工作阻塞着，获取阻塞的工作 resumedTask，该工作胜利获取到互斥锁，而后执行⑸更新互斥锁的持有信息。执行⑹更新工作 resumedTask 的状态，而后调用函数 LOS_Schedule 触发调度。

LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle)
{
    UINT32 intSave;
    LosMuxCB *muxPosted = GET_MUX(muxHandle);
    LosTaskCB *resumedTask = NULL;
    LosTaskCB *runningTask = NULL;

    intSave = LOS_IntLock();

    if ((muxHandle >= (UINT32)LOSCFG_BASE_IPC_MUX_LIMIT) ||
        (muxPosted->muxStat == OS_MUX_UNUSED)) {LOS_IntRestore(intSave);
        OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    }

    runningTask = (LosTaskCB *)g_losTask.runTask;
⑴  if ((muxPosted->muxCount == 0) || (muxPosted->owner != runningTask)) {LOS_IntRestore(intSave);
        OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    }

⑵  if (--(muxPosted->muxCount) != 0) {LOS_IntRestore(intSave);
        OsHookCall(LOS_HOOK_TYPE_MUX_POST, muxPosted);
        return LOS_OK;
    }

⑶  if ((muxPosted->owner->priority) != muxPosted->priority) {(VOID)OsSchedModifyTaskSchedParam(muxPosted->owner, muxPosted->priority);
    }

⑷  if (!LOS_ListEmpty(&muxPosted->muxList)) {resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(muxPosted->muxList)));

⑸      muxPosted->muxCount = 1;
        muxPosted->owner = resumedTask;
        muxPosted->priority = resumedTask->priority;
        resumedTask->taskMux = NULL;

⑹      OsSchedTaskWake(resumedTask);

        LOS_IntRestore(intSave);
        OsHookCall(LOS_HOOK_TYPE_MUX_POST, muxPosted);
        LOS_Schedule();} else {LOS_IntRestore(intSave);
    }

    return LOS_OK;
}

小结

本文率领大家一起分析了鸿蒙轻内核的互斥锁模块的源代码，蕴含互斥锁的构造体、互斥锁池初始化、互斥锁创立删除、申请开释等。感激浏览，如有任何问题、倡议，都能够留言给咱们：https://gitee.com/openharmony…。为了更容易找到鸿蒙轻内核代码仓，倡议拜访 https://gitee.com/openharmony…，关注 Watch、点赞 Star、并 Fork 到本人账户下，谢谢。

点击关注，第一工夫理解华为云陈腐技术~

正文完
harmonyos
发表至： harmonyos
2021-07-09
 0
关于harmonyos:踩准时钟节拍玩转时间转换鸿蒙轻内核时间管理有妙招
关于harmonyos:HarmonyOS-的分布式技术让小朋友爱上涂鸦
关于harmonyos:小白入门设备开发的芯路历程
关于harmonyos:多地政府支持鸿蒙产业发展OpenHarmony技术峰会即将召开