将PENDING 注解成 `挂起/待办`, blocked 注解成 `阻塞`

    百图画鸿蒙 + 百文说内核 + 百万注源码  => 挖透鸿蒙内核源码
    鸿蒙研究站 | http://weharmonyos.com (国内)
              | https://weharmony.github.io (国外)
    oschina | https://my.oschina.net/weharmony
    博客园 | https://www.cnblogs.com/weharmony/
    知乎 | https://www.zhihu.com/people/weharmonyos
    csdn | https://blog.csdn.net/kuangyufei
    51cto | https://harmonyos.51cto.com/column/34
    掘金 | https://juejin.cn/user/756888642000808
    公众号 | 鸿蒙研究站 (weharmonyos)

kernel/base/include/los_task_pri.h

@@ -133,7 +133,7 @@ extern SPIN_LOCK_S g_taskSpin;//任务自旋锁
  *
  * The task is blocked.
  */
-#define OS_TASK_STATUS_PENDING      0x0010U ///< 任务状态: 挂起 ,意思在需等待其他外在资源引起的停止,例如互斥锁/信号量 == 
+#define OS_TASK_STATUS_PENDING      0x0010U ///< 任务状态: 挂起/待办 ,意思在需等待其他外在资源引起的停止,例如互斥锁/信号量 == 
 
 /**
  * @ingroup los_task
@@ -157,10 +157,10 @@ extern SPIN_LOCK_S g_taskSpin;//任务自旋锁
  *
  * The task is pend for a period of time.
  */
-#define OS_TASK_STATUS_PEND_TIME    0x0080U ///< 任务状态: 有时间限制的阻塞,例如等待某个事件时设置为时间到了就不等了
+#define OS_TASK_STATUS_PEND_TIME    0x0080U ///< 任务状态: 有时间限制的挂起/待办,例如等待某个事件时设置为时间到了就不等了
 
 #define OS_TASK_STATUS_BLOCKED      (OS_TASK_STATUS_INIT | OS_TASK_STATUS_PENDING | \
-                                     OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME) ///< 任务状态: 已屏蔽
+                                     OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME) ///< 任务状态: 阻塞
 
 /**
  * @ingroup los_task

kernel/base/ipc/los_signal.c

@@ -194,7 +194,7 @@ int OsTcbDispatch(LosTaskCB *stcb, siginfo_t *info)
         /* If signal is in wait list and mask list, need unblock it */ //如果信号在等待列表和掩码列表中，需要解除阻止
         if (LOS_ListEmpty(&sigcb->waitList)  ||
            (!LOS_ListEmpty(&sigcb->waitList) && !OsSigIsMember(&sigcb->sigwaitmask, info->si_signo))) {
-            OsSigAddSet(&sigcb->sigPendFlag, info->si_signo);//将信号加入阻塞集
+            OsSigAddSet(&sigcb->sigPendFlag, info->si_signo);//将信号加入挂起/待办集
         }
     } else {//信号没有被屏蔽的处理
         /* unmasked signal actions */
@@ -217,7 +217,7 @@ void OsSigMaskSwitch(LosTaskCB * const rtcb, sigset_t set)
     if (unmaskset != NULL_SIGNAL_SET) {
         /* pendlist do */
         rtcb->sig.sigFlag |= unmaskset;	//加入不屏蔽信号集
-        rtcb->sig.sigPendFlag ^= unmaskset;//从阻塞集中去掉unmaskset
+        rtcb->sig.sigPendFlag ^= unmaskset;//从挂起/待办集中去掉unmaskset
     }
 }
 

kernel/base/misc/task_shellcmd.c

@@ -322,23 +322,23 @@ STATIC VOID OsShellCmdProcessInfoData(const LosProcessCB *pcbArray, const INT32
 
 LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdConvertTskStatus(UINT16 taskStatus)
 {
-    if (taskStatus & OS_TASK_STATUS_INIT) {
+    if (taskStatus & OS_TASK_STATUS_INIT) {//初始化
         return (UINT8 *)"Init";
-    } else if (taskStatus & OS_TASK_STATUS_RUNNING) {
+    } else if (taskStatus & OS_TASK_STATUS_RUNNING) {//运行中
         return (UINT8 *)"Running";
-    } else if (taskStatus & OS_TASK_STATUS_READY) {
+    } else if (taskStatus & OS_TASK_STATUS_READY) {//已就绪
         return (UINT8 *)"Ready";
-    } else if (taskStatus & OS_TASK_STATUS_SUSPENDED) {
+    } else if (taskStatus & OS_TASK_STATUS_SUSPENDED) {//暂停
         return (UINT8 *)"Suspended";
-    } else if (taskStatus & OS_TASK_STATUS_DELAY) {
+    } else if (taskStatus & OS_TASK_STATUS_DELAY) {//延迟
         return (UINT8 *)"Delay";
-    } else if (taskStatus & OS_TASK_STATUS_PENDING) {
-        if (taskStatus & OS_TASK_STATUS_PEND_TIME) {
+    } else if (taskStatus & OS_TASK_STATUS_PENDING) {//挂起/待办
+        if (taskStatus & OS_TASK_STATUS_PEND_TIME) { //挂起/待办有时间限制
             return (UINT8 *)"PendTime";
         } else {
-            return (UINT8 *)"Pending";
+            return (UINT8 *)"Pending";//挂起/待办无时间限制
         }
-    } else if (taskStatus & OS_TASK_STATUS_EXIT) {
+    } else if (taskStatus & OS_TASK_STATUS_EXIT) {//退出
         return (UINT8 *)"Exit";
     }
 

kernel/base/sched/sched_sq/los_sched.c

@@ -53,10 +53,10 @@
 #define OS_SCHED_FIFO_TIMEOUT      0x7FFFFFFF
 #define OS_PRIORITY_QUEUE_NUM      32	///< 就绪队列数量
 #define PRIQUEUE_PRIOR0_BIT        0x80000000U
-#define OS_SCHED_TIME_SLICES_MIN   ((5000 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE)  /* 5ms 调度最小时间片 */
-#define OS_SCHED_TIME_SLICES_MAX   ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) ///< 调度最大时间片 
+#define OS_SCHED_TIME_SLICES_MIN   ((5000 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE)  /* 5ms 产生的时钟周期数 调度最小时间片 */
+#define OS_SCHED_TIME_SLICES_MAX   ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) ///< 调度最大时间片 20ms产生的时钟周期数
 #define OS_SCHED_TIME_SLICES_DIFF  (OS_SCHED_TIME_SLICES_MAX - OS_SCHED_TIME_SLICES_MIN) ///< 最大,最小二者差
-#define OS_SCHED_READY_MAX         30
+#define OS_SCHED_READY_MAX         30 ///< 某个任务优先级上挂的最大就绪任务数量
 #define OS_TIME_SLICE_MIN          (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */
 
 #define OS_CHECK_TASK_BLOCK (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PENDING | OS_TASK_STATUS_SUSPENDED)
@@ -69,29 +69,29 @@ typedef struct {
 
 /// 调度器
 typedef struct {
-    SchedQueue queueList[OS_PRIORITY_QUEUE_NUM];//进程优先级调度队列,默认32级
-    UINT32     queueBitmap;//进程优先级调度位图
-    SchedScan  taskScan;//函数指针,扫描任务的回调函数
-    SchedScan  swtmrScan;//函数指针,扫描定时器的回调函数
+    SchedQueue queueList[OS_PRIORITY_QUEUE_NUM];///< 进程优先级调度队列,默认32级
+    UINT32     queueBitmap;///< 进程优先级调度位图
+    SchedScan  taskScan;///< 函数指针,扫描任务的回调函数
+    SchedScan  swtmrScan;///< 函数指针,扫描定时器的回调函数
 } Sched;
 
-STATIC Sched *g_sched = NULL;//全局调度器
-STATIC UINT64 g_schedTickMaxResponseTime;
-UINT64 g_sysSchedStartTime = OS_64BIT_MAX;
+STATIC Sched *g_sched = NULL;///< 全局调度器
+STATIC UINT64 g_schedTickMaxResponseTime; //最大响应时间
+UINT64 g_sysSchedStartTime = OS_64BIT_MAX; ///< 系统调度开始时间
 
 #ifdef LOSCFG_SCHED_TICK_DEBUG
 #define OS_SCHED_DEBUG_DATA_NUM  1000
-typedef struct {
+typedef struct {//调试调度,每个CPU核一个
     UINT32 tickResporeTime[OS_SCHED_DEBUG_DATA_NUM];
     UINT32 index;
     UINT32 setTickCount;
     UINT64 oldResporeTime;
 } SchedTickDebug;
-STATIC SchedTickDebug *g_schedTickDebug = NULL;
-
+STATIC SchedTickDebug *g_schedTickDebug = NULL;///< 全局调度调试池
+/// 调试调度器初始化
 STATIC UINT32 OsSchedDebugInit(VOID)
 {
-    UINT32 size = sizeof(SchedTickDebug) * LOSCFG_KERNEL_CORE_NUM;
+    UINT32 size = sizeof(SchedTickDebug) * LOSCFG_KERNEL_CORE_NUM;//见核有份
     g_schedTickDebug = (SchedTickDebug *)LOS_MemAlloc(m_aucSysMem0, size);
     if (g_schedTickDebug == NULL) {
         return LOS_ERRNO_TSK_NO_MEMORY;
@@ -385,19 +385,19 @@ VOID OsSchedUpdateExpireTime(UINT64 startTime)
 
     OsSchedSetNextExpireTime(startTime, runTask->taskID, endTime, runTask->taskID);
 }
-/// 计算时间片
+/// 计算时间片,参数为进程优先级和任务优先级, 结论是同一个优先级下 任务越多,时间片越短
 STATIC INLINE UINT32 OsSchedCalculateTimeSlice(UINT16 proPriority, UINT16 priority)
 {
     UINT32 retTime;
     UINT32 readyTasks;
 
-    SchedQueue *queueList = &g_sched->queueList[proPriority];//拿到优先级调度队列
-    readyTasks = queueList->readyTasks[priority];
-    if (readyTasks > OS_SCHED_READY_MAX) {
-        return OS_SCHED_TIME_SLICES_MIN;
-    }
-    retTime = ((OS_SCHED_READY_MAX - readyTasks) * OS_SCHED_TIME_SLICES_DIFF) / OS_SCHED_READY_MAX;
-    return (retTime + OS_SCHED_TIME_SLICES_MIN);
+    SchedQueue *queueList = &g_sched->queueList[proPriority];//拿到进程优先级调度队列
+    readyTasks = queueList->readyTasks[priority];//获取指定优先级的任务数量
+    if (readyTasks > OS_SCHED_READY_MAX) {//如果就绪任务很多
+        return OS_SCHED_TIME_SLICES_MIN;//给个最小时间片 5ms
+    }// 0:15 | 1: 14.5 | 2:14 | 30: 0  
+    retTime = ((OS_SCHED_READY_MAX - readyTasks) * OS_SCHED_TIME_SLICES_DIFF) / OS_SCHED_READY_MAX;//时间片的算法
+    return (retTime + OS_SCHED_TIME_SLICES_MIN);// 20, 19.5, ... 5
 }
 
 STATIC INLINE VOID OsSchedPriQueueEnHead(UINT32 proPriority, LOS_DL_LIST *priqueueItem, UINT32 priority)
@@ -449,21 +449,21 @@ STATIC INLINE VOID OsSchedPriQueueEnTail(UINT32 proPriority, LOS_DL_LIST *prique
     LOS_ListTailInsert(&priQueueList[priority], priqueueItem);
     queueList->readyTasks[priority]++;
 }
-
+/// 1.找出指定优先级的调度队列 2.摘除指定任务优先级链表中的指定任务节点
 STATIC INLINE VOID OsSchedPriQueueDelete(UINT32 proPriority, LOS_DL_LIST *priqueueItem, UINT32 priority)
 {
-    SchedQueue *queueList = &g_sched->queueList[proPriority];
-    LOS_DL_LIST *priQueueList = &queueList->priQueueList[0];
-    UINT32 *bitMap = &queueList->queueBitmap;
+    SchedQueue *queueList = &g_sched->queueList[proPriority];//找到进程优先级对应的调度队列
+    LOS_DL_LIST *priQueueList = &queueList->priQueueList[0];//获取首个链表
+    UINT32 *bitMap = &queueList->queueBitmap;//获取位图
 
-    LOS_ListDelete(priqueueItem);
-    queueList->readyTasks[priority]--;
-    if (LOS_ListEmpty(&priQueueList[priority])) {
-        *bitMap &= ~(PRIQUEUE_PRIOR0_BIT >> priority);
-    }
+    LOS_ListDelete(priqueueItem);//摘除参数结点
+    queueList->readyTasks[priority]--;//对应任务数减少
+    if (LOS_ListEmpty(&priQueueList[priority])) {//如果该条线上没有了任务了
+        *bitMap &= ~(PRIQUEUE_PRIOR0_BIT >> priority);//将任务对应优先级的位 置0
+    }// ...111001110 --> ...111000110 
 
-    if (*bitMap == 0) {
-        g_sched->queueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> proPriority);
+    if (*bitMap == 0) {//如果变量变成0, 000000000
+        g_sched->queueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> proPriority);//将进程对应优先级的位 置0
     }
 }
 /// 唤醒因等待时间而阻塞的任务,例如在一个任务中执行 delay(100)这样的操作
@@ -477,9 +477,9 @@ STATIC INLINE VOID OsSchedWakePendTimeTask(UINT64 currTime, LosTaskCB *taskCB, B
     UINT16 tempStatus = taskCB->taskStatus;
     if (tempStatus & (OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY)) {//任务被挂起或被延迟执行
         taskCB->taskStatus &= ~(OS_TASK_STATUS_PENDING | OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY);//去掉这些标签
-        if (tempStatus & OS_TASK_STATUS_PENDING) {//如果贴有阻塞标签
+        if (tempStatus & OS_TASK_STATUS_PENDING) {//如果贴有挂起/待办标签
             taskCB->taskStatus |= OS_TASK_STATUS_TIMEOUT;//贴上时间到了的标签
-            LOS_ListDelete(&taskCB->pendList);//从阻塞链表中删除
+            LOS_ListDelete(&taskCB->pendList);//从挂起/待办链表中删除
             taskCB->taskMux = NULL;
             OsTaskWakeClearPendMask(taskCB);
         }
@@ -668,7 +668,7 @@ VOID OsSchedYield(VOID)
     runTask->timeSlice = 0;//时间片变成0,代表主动让出运行时间.
 
     runTask->startTime = OsGetCurrSchedTimeCycle();//重新获取开始时间
-    OsSchedTaskEnQueue(runTask);//跑队列尾部排队
+    OsSchedTaskEnQueue(runTask);//跑队尾排队
     OsSchedResched();//发起调度
 }
 ///延期调度
@@ -686,12 +686,12 @@ UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched)
     LosTaskCB *runTask = OsCurrTaskGet();//获取当前任务
     OsSchedTaskDeQueue(runTask);//将任务从就绪队列中删除
 
-    runTask->taskStatus |= OS_TASK_STATUS_PENDING;//任务状态改成阻塞
-    LOS_ListTailInsert(list, &runTask->pendList);//挂入阻塞链表
+    runTask->taskStatus |= OS_TASK_STATUS_PENDING;//任务状态改成挂起/待办
+    LOS_ListTailInsert(list, &runTask->pendList);//挂入挂起/待办链表
 
     if (ticks != LOS_WAIT_FOREVER) {//如果不是永久的等待
-        runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME;//标记为有时间的阻塞
-        runTask->waitTimes = ticks;//要阻塞多久
+        runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME;//标记为有时间的挂起/待办
+        runTask->waitTimes = ticks;//要挂起/待办多久
     }
 
     if (needSched == TRUE) {//是否需要调度
@@ -707,62 +707,62 @@ UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched)
 ///任务从等待链表中恢复,并从链表中摘除.
 VOID OsSchedTaskWake(LosTaskCB *resumedTask)
 {
-    LOS_ListDelete(&resumedTask->pendList);
-    resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING;
+    LOS_ListDelete(&resumedTask->pendList);// 1.先从待办链表上摘除
+    resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING;//撕掉挂起标签
 
-    if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) {
-        OsDeleteSortLink(&resumedTask->sortList, OS_SORT_LINK_TASK);
-        resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME;
+    if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) {//如果是有时间限制的挂起
+        OsDeleteSortLink(&resumedTask->sortList, OS_SORT_LINK_TASK);//从任务的CPU执行链表上摘除任务节点
+        resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME;//撕掉挂起有时间限制标签
     }
 
-    if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) {
+    if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) {//如果有暂停标签
 #ifdef LOSCFG_SCHED_DEBUG
-        resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime;
-        resumedTask->schedStat.pendCount++;
+        resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime;//记录暂停的时间
+        resumedTask->schedStat.pendCount++;//暂停的次数增加
 #endif
-        OsSchedTaskEnQueue(resumedTask);
+        OsSchedTaskEnQueue(resumedTask);//加入就绪链表
     }
 }
-
+/// 修改任务调度参数
 BOOL OsSchedModifyTaskSchedParam(LosTaskCB *taskCB, UINT16 policy, UINT16 priority)
 {
-    if (taskCB->policy != policy) {
+    if (taskCB->policy != policy) {//如果调度方式不一致
         taskCB->policy = policy;
-        taskCB->timeSlice = 0;
+        taskCB->timeSlice = 0;//时间片清0
     }
 
-    if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
-        OsSchedTaskDeQueue(taskCB);
-        taskCB->priority = priority;
-        OsSchedTaskEnQueue(taskCB);
+    if (taskCB->taskStatus & OS_TASK_STATUS_READY) {//如果是就绪状态
+        OsSchedTaskDeQueue(taskCB);//从就绪队列删除
+        taskCB->priority = priority;//设置任务优先级
+        OsSchedTaskEnQueue(taskCB);//从尾部加入就绪队列
         return TRUE;
     }
 
-    taskCB->priority = priority;
-    OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority); 
-    if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
-        OsSchedTaskEnQueue(taskCB);
+    taskCB->priority = priority;//设置任务优先级
+    OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority);//向往通知某任务优先级改变了 
+    if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {//如果任务处于初始状态
+        OsSchedTaskEnQueue(taskCB);//直接加入就绪队列, 进入就绪状态
         return TRUE;
     }
 
-    if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
+    if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {//处于运行状态
         return TRUE;
     }
 
     return FALSE;
 }
-///修改进程调度参数
+/// 修改进程调度参数
 BOOL OsSchedModifyProcessSchedParam(LosProcessCB *processCB, UINT16 policy, UINT16 priority)
 {
     LosTaskCB *taskCB = NULL;
     BOOL needSched = FALSE;
     (VOID)policy;
 
-    if (processCB->processStatus & OS_PROCESS_STATUS_READY) {
-        LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
-            if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
-                OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority);
-                OsSchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority);
+    if (processCB->processStatus & OS_PROCESS_STATUS_READY) {//如果是就绪状态
+        LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {//遍历进程的任务链表
+            if (taskCB->taskStatus & OS_TASK_STATUS_READY) {//如果任务处于就绪状态
+                OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority);//先从原任务优先级链表中摘除任务
+                OsSchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority);//在根据新优先级插入对应优先级链表中
                 needSched = TRUE;
             }
         }
@@ -874,15 +874,15 @@ VOID OsSchedTick(VOID)
     currCpu->schedFlag |= INT_PEND_TICK; //贴上外因触发的调度,这个外因指的就是tick时间到了
     currCpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME;//响应时间默认设最大
 }
-
+/// 设置空闲任务调度参数,空闲
 VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask)
 {
-    idleTask->policy = LOS_SCHED_IDLE;
-    idleTask->initTimeSlice = OS_SCHED_FIFO_TIMEOUT;
-    idleTask->timeSlice = idleTask->initTimeSlice;
-    OsSchedTaskEnQueue(idleTask);
+    idleTask->policy = LOS_SCHED_IDLE; //空闲方式,CPU没事干的时候就跑这个任务
+    idleTask->initTimeSlice = OS_SCHED_FIFO_TIMEOUT;//初始时间片超大
+    idleTask->timeSlice = idleTask->initTimeSlice;//剩余时间片超大
+    OsSchedTaskEnQueue(idleTask);//加入就绪队列
 }
-
+/// 重置回应时间
 VOID OsSchedResetSchedResponseTime(UINT64 responseTime)
 {
     Percpu *cpu = OsPercpuGet();

kernel/common/console.c

@@ -1647,7 +1647,7 @@ VOID OsWaitConsoleSendTaskPend(UINT32 taskID)//等待控制台发送任务结束
 
         taskCB = OS_TCB_FROM_TID(console->sendTaskID);
         while ((waitTime > 0) && (taskCB->taskEvent == NULL) && (taskID != console->sendTaskID)) {
-            LOS_Mdelay(1); /* 1: wait console task pend */ //等待控制台任务阻塞
+            LOS_Mdelay(1); /* 1: wait console task pend */ //等待控制台任务挂起/待办
             --waitTime;
         }
     }

kernel/extended/liteipc/hm_liteipc.c

@@ -98,7 +98,7 @@ STATIC HandleInfo g_cmsTask;	///< 应该是Service管理器的意思,因借助
 #else
 STATIC HandleInfo g_serviceHandleMap[MAX_SERVICE_NUM]; ///< 整个系统只能有一个 ServiceManager 用于管理 service
 #endif
-STATIC LOS_DL_LIST g_ipcPendlist;	///< 阻塞链表,上面挂等待读/写消息的任务LosTaskCB
+STATIC LOS_DL_LIST g_ipcPendlist;	///< 挂起/待办链表,上面挂等待读/写消息的任务LosTaskCB
 
 /* ipc lock */
 SPIN_LOCK_INIT(g_ipcSpin);//初始化IPC自旋锁

zzz/git/push.sh

 git add -A
-git commit -m  ' 同步官方最新代码
+git commit -m  ' 将PENDING 注解成 `挂起/待办`, blocked 注解成 `阻塞`
     百图画鸿蒙 + 百文说内核 + 百万注源码  => 挖透鸿蒙内核源码
     鸿蒙研究站 | http://weharmonyos.com (国内) 
               | https://weharmony.github.io (国外)