关于信号量和互斥锁如何运作的两个问题

1、互斥锁和信号量都通过“许可证”来控制线程对共享资源的访问，书中直接使用了API，那么线程获取“许可证”这一过程过程在它的源码中是怎么实现的呢
2、书中提到互斥锁和信号量的本质是令牌的容器，那么在代码层面上互斥锁和信号量的表现形式是什么呢

kernel\liteos_m\kal\cmsis\cmsis_liteos2.c：

1. osStatus_t osMutexAcquire(osMutexId_t mutex_id, uint32_t timeout)
   
2. {
   
3.     UINT32 uwRet;
   
4. 
   
5.     if (mutex_id == NULL) {
   
6.         return osErrorParameter;
   
7.     }
   
8. 
   
9.     if (OS_INT_ACTIVE && (timeout != LOS_NO_WAIT)) {
   
10.         timeout = 0;
    
11.     }
    
12. 
    
13.     uwRet = LOS_MuxPend(((LosMuxCB *)mutex_id)->muxID, timeout);
    
14.     if (uwRet == LOS_OK) {
    
15.         return osOK;
    
16.     } else if (uwRet == LOS_ERRNO_MUX_TIMEOUT) {
    
17.         return osErrorTimeout;
    
18.     } else if (uwRet == LOS_ERRNO_MUX_INVALID) {
    
19.         return osErrorParameter;
    
20.     } else {
    
21.         return osErrorResource;
    
22.     }
    
23. }

复制代码

1. osStatus_t osMutexRelease(osMutexId_t mutex_id)
   
2. {
   
3.     UINT32 uwRet;
   
4. 
   
5.     if (mutex_id == NULL) {
   
6.         return osErrorParameter;
   
7.     }
   
8. 
   
9.     uwRet = LOS_MuxPost(((LosMuxCB *)mutex_id)->muxID);
   
10.     if (uwRet == LOS_OK) {
    
11.         return osOK;
    
12.     } else {
    
13.         return osErrorResource;
    
14.     }
    
15. }

复制代码

kernel\liteos_m\kernel\src\los_mux.c：

1. /*****************************************************************************
   
2. Function     : LOS_MuxPend
   
3. Description  : Specify the mutex P operation
   
4. Input        : muxHandle ------ Mutex operation handleone
   
5.               : timeOut   ------- waiting time
   
6. Output       : None
   
7. Return       : LOS_OK on success ,or error code on failure
   
8. *****************************************************************************/
   
9. LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout)
   
10. {
    
11.     UINT32 intSave;
    
12.     LosMuxCB *muxPended = NULL;
    
13.     UINT32 retErr;
    
14.     LosTaskCB *runningTask = NULL;
    
15. 
    
16.     if (muxHandle >= (UINT32)LOSCFG_BASE_IPC_MUX_LIMIT) {
    
17.         OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    
18.     }
    
19. 
    
20.     muxPended = GET_MUX(muxHandle);
    
21.     intSave = LOS_IntLock();
    
22.     retErr = OsMuxValidCheck(muxPended);
    
23.     if (retErr) {
    
24.         goto ERROR_MUX_PEND;
    
25.     }
    
26. 
    
27.     runningTask = (LosTaskCB *)g_losTask.runTask;
    
28.     if (muxPended->muxCount == 0) {
    
29.         muxPended->muxCount++;
    
30.         muxPended->owner = runningTask;
    
31.         muxPended->priority = runningTask->priority;
    
32.         LOS_IntRestore(intSave);
    
33.         return LOS_OK;
    
34.     }
    
35. 
    
36.     if (muxPended->owner == runningTask) {
    
37.         muxPended->muxCount++;
    
38.         LOS_IntRestore(intSave);
    
39.         return LOS_OK;
    
40.     }
    
41. 
    
42.     if (!timeout) {
    
43.         retErr = LOS_ERRNO_MUX_UNAVAILABLE;
    
44.         goto ERROR_MUX_PEND;
    
45.     }
    
46. 
    
47.     runningTask->taskMux = (VOID *)muxPended;
    
48. 
    
49.     if (muxPended->owner->priority > runningTask->priority) {
    
50.         OsTaskPriModify(muxPended->owner, runningTask->priority);
    
51.     }
    
52. 
    
53.     OsTaskWait(&muxPended->muxList, OS_TASK_STATUS_PEND, timeout);
    
54. 
    
55.     LOS_IntRestore(intSave);
    
56.     LOS_Schedule();
    
57. 
    
58.     if (runningTask->taskStatus & OS_TASK_STATUS_TIMEOUT) {
    
59.         intSave = LOS_IntLock();
    
60.         runningTask->taskStatus &= (~OS_TASK_STATUS_TIMEOUT);
    
61.         retErr = LOS_ERRNO_MUX_TIMEOUT;
    
62.         goto ERROR_MUX_PEND;
    
63.     }
    
64. 
    
65.     return LOS_OK;
    
66. 
    
67. ERROR_MUX_PEND:
    
68.     LOS_IntRestore(intSave);
    
69.     OS_RETURN_ERROR(retErr);
    
70. }

复制代码

1. /*****************************************************************************
   
2. Function     : LOS_MuxPost
   
3. Description  : Specify the mutex V operation,
   
4. Input        : muxHandle ------ Mutex operation handle
   
5. Output       : None
   
6. Return       : LOS_OK on success ,or error code on failure
   
7. *****************************************************************************/
   
8. LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle)
   
9. {
   
10.     UINT32 intSave;
    
11.     LosMuxCB *muxPosted = GET_MUX(muxHandle);
    
12.     LosTaskCB *resumedTask = NULL;
    
13.     LosTaskCB *runningTask = NULL;
    
14. 
    
15.     intSave = LOS_IntLock();
    
16. 
    
17.     if ((muxHandle >= (UINT32)LOSCFG_BASE_IPC_MUX_LIMIT) ||
    
18.         (muxPosted->muxStat == OS_MUX_UNUSED)) {
    
19.         LOS_IntRestore(intSave);
    
20.         OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    
21.     }
    
22. 
    
23.     runningTask = (LosTaskCB *)g_losTask.runTask;
    
24.     if ((muxPosted->muxCount == 0) || (muxPosted->owner != runningTask)) {
    
25.         LOS_IntRestore(intSave);
    
26.         OS_RETURN_ERROR(LOS_ERRNO_MUX_INVALID);
    
27.     }
    
28. 
    
29.     if (--(muxPosted->muxCount) != 0) {
    
30.         LOS_IntRestore(intSave);
    
31.         return LOS_OK;
    
32.     }
    
33. 
    
34.     if ((muxPosted->owner->priority) != muxPosted->priority) {
    
35.         OsTaskPriModify(muxPosted->owner, muxPosted->priority);
    
36.     }
    
37. 
    
38.     if (!LOS_ListEmpty(&muxPosted->muxList)) {
    
39.         resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(muxPosted->muxList)));
    
40. 
    
41.         muxPosted->muxCount = 1;
    
42.         muxPosted->owner = resumedTask;
    
43.         muxPosted->priority = resumedTask->priority;
    
44.         resumedTask->taskMux = NULL;
    
45. 
    
46.         OsTaskWake(resumedTask, OS_TASK_STATUS_PEND);
    
47. 
    
48.         LOS_IntRestore(intSave);
    
49.         LOS_Schedule();
    
50.     } else {
    
51.         LOS_IntRestore(intSave);
    
52.     }
    
53. 
    
54.     return LOS_OK;
    
55. }

复制代码

OH是开源的，可以自己追踪函数调用。