posix 线程代码部分注释 ,完善task模块的注释

鸿蒙内核源码分析系列 【 CSDN | OSCHINA | WIKI 】
鸿蒙内核源码注释中文版 【 CSDN仓 | Gitee仓 | Github仓 | Coding仓 】四大仓库每日同步更新代码和wiki
项目给鸿蒙内核源码逐行加上中文注解,详细阐述框架和代码细节, 精读 HarmonyOS 内核源码, 将迅速拔高对计算机整体理解,从此高屋建瓴看问题.

.gitignore

@@ -23,3 +23,4 @@ platform/board.ld
 apps/init/init
 apps/shell/shell
 lib/libc/musl
+zzz/pic

compat/posix/src/pprivate.h

@@ -63,8 +63,8 @@ posix 线程属性结构体
 
 #define PTHREAD_DATA_NAME_MAX 20
 /*
- * Thread control data structure
- * Per-thread information needed by POSIX
+ * Thread control data structure			//线程控制数据结构
+ * Per-thread information needed by POSIX	//POSIX所需的每个线程信息
  */
 typedef struct {
     pthread_attr_t      attr; /* Current thread attributes *///当前线程属性
@@ -87,7 +87,7 @@ typedef struct {
  * struct _pthread_data about thread object.
  * Note: numerical order here is important, do not rearrange.
  */
-#define PTHREAD_STATE_FREE       0  /* This structure is free for reuse */		//这种结构可以免费重复使用
+#define PTHREAD_STATE_FREE       0  /* This structure is free for reuse */		//空闲状态,可以反复使用
 #define PTHREAD_STATE_DETACHED   1  /* The thread is running but detached */	//线程正在运行，但已分离
 #define PTHREAD_STATE_RUNNING    2  /* The thread is running and will wait to join when it exits */	//线程正在运行，退出时将等待加入
 #define PTHREAD_STATE_JOIN       3  /* The thread has exited and is waiting to be joined */ //线程已退出，正在等待加入

compat/posix/src/pthread.c

@@ -47,13 +47,13 @@ extern "C" {
  * Array of pthread control structures. A pthread_t object is
  * "just" an index into this array.
  */ //pthread控制结构的数组。pthread_t对象只是这个数组的一个索引
-STATIC _pthread_data g_pthreadData[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
+STATIC _pthread_data g_pthreadData[LOSCFG_BASE_CORE_TSK_LIMIT + 1]; //128
 
-/* Count of number of threads that have exited and not been reaped. */
+/* Count of number of threads that have exited and not been reaped. */ //已退出但尚未获取的线程数的计数
 STATIC INT32 g_pthreadsExited = 0;
 
-/* this is to protect the pthread data */
-STATIC pthread_mutex_t g_pthreadsDataMutex = PTHREAD_MUTEX_INITIALIZER;
+/* this is to protect the pthread data */	//这是为了保护pthread数据
+STATIC pthread_mutex_t g_pthreadsDataMutex = PTHREAD_MUTEX_INITIALIZER; //posix 模块的互斥锁
 
 /* pointed to by PTHREAD_CANCELED */
 UINTPTR g_pthreadCanceledDummyVar;
@@ -61,15 +61,15 @@ UINTPTR g_pthreadCanceledDummyVar;
 /*
  * Private version of pthread_self() that returns a pointer to our internal
  * control structure.
- */
+ */ //获取当前线程的数据，返回指向内部控制结构的指针
 _pthread_data *pthread_get_self_data(void)
 {
-    UINT32 runningTaskPID = ((LosTaskCB *)(OsCurrTaskGet()))->taskID;
-    _pthread_data *data = &g_pthreadData[runningTaskPID];
+    UINT32 runningTaskPID = ((LosTaskCB *)(OsCurrTaskGet()))->taskID;//获取当前taskID
+    _pthread_data *data = &g_pthreadData[runningTaskPID];//获取当前线程的 posix 数据
 
     return data;
 }
-
+//以posix 方式获取线程的数据 参数为线程(task) id
 _pthread_data *pthread_get_data(pthread_t id)
 {
     _pthread_data *data = NULL;
@@ -79,12 +79,12 @@ _pthread_data *pthread_get_data(pthread_t id)
     }
 
     data = &g_pthreadData[id];
-    /* Check that this is a valid entry */
-    if ((data->state == PTHREAD_STATE_FREE) || (data->state == PTHREAD_STATE_EXITED)) {
+    /* Check that this is a valid entry */ //检查是否是一个有效的实体
+    if ((data->state == PTHREAD_STATE_FREE) || (data->state == PTHREAD_STATE_EXITED)) { 
         return NULL;
     }
 
-    /* Check that the entry matches the id */
+    /* Check that the entry matches the id */ //检查实体ID和参数ID是否一致
     if (data->id != id) {
         return NULL;
     }
@@ -118,24 +118,24 @@ STATIC VOID ProcessUnusedStatusTask(_pthread_data *data)
  * This function is called to tidy up and dispose of any threads that have
  * exited. This work must be done from a thread other than the one exiting.
  * Note: this function must be called with pthread_mutex locked.
- */
+ */ //这个函数必须在 持有 pthread_mutex 锁的情况下调用 ,该函数主要用于 posix 线程池和内核task池对退出情况的同步
 STATIC VOID PthreadReap(VOID)
 {
     UINT32 i;
     _pthread_data *data = NULL;
     /*
-     * Loop over the thread table looking for exited threads. The
+     * Loop over the thread table looking for exited threads. The //在线程池上循环，查找已退出的线程。
      * g_pthreadsExited counter springs us out of this once we have
      * found them all (and keeps us out if there are none to do).
      */
     for (i = 0; g_pthreadsExited && (i < g_taskMaxNum); i++) {
         data = &g_pthreadData[i];
-        if (data->state == PTHREAD_STATE_EXITED) {
+        if (data->state == PTHREAD_STATE_EXITED) { //找到一个退出线程
             /* the Huawei LiteOS not delete the dead TCB,so need to delete the TCB */
-            (VOID)LOS_TaskDelete(data->task->taskID);
-            if (data->task->taskStatus & OS_TASK_STATUS_UNUSED) {
-                ProcessUnusedStatusTask(data);
-                g_pthreadsExited--;
+            (VOID)LOS_TaskDelete(data->task->taskID);//删除这个task
+            if (data->task->taskStatus & OS_TASK_STATUS_UNUSED) {//如果task贴有未使用的标签
+                ProcessUnusedStatusTask(data);//posix线程数据清0,状态改为 free
+                g_pthreadsExited--;//退出线程计数器减少一个
             }
         }
     }
@@ -188,22 +188,22 @@ STATIC VOID SetPthreadDataAttr(const pthread_attr_t *userAttr, const pthread_t t
     created->stackmem     = taskCB->topOfStack;
     created->thread_data  = NULL;
 }
-
+//posix 初始化线程数据
 STATIC UINT32 InitPthreadData(pthread_t threadID, pthread_attr_t *userAttr,
                               const CHAR name[], size_t len)
 {
     errno_t err;
     UINT32 ret = LOS_OK;
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(threadID);
-    _pthread_data *created = &g_pthreadData[threadID];
+    LosTaskCB *taskCB = OS_TCB_FROM_TID(threadID);//取出task实体
+    _pthread_data *created = &g_pthreadData[threadID];//取出posix 对应的 线程实体
 
-    err = strncpy_s(created->name, sizeof(created->name), name, len);
+    err = strncpy_s(created->name, sizeof(created->name), name, len);//线程的名称用参数名称
     if (err != EOK) {
         PRINT_ERR("%s: %d, err: %d\n", __FUNCTION__, __LINE__, err);
         return LOS_NOK;
     }
-    userAttr->stacksize   = taskCB->stackSize;
-    err = memcpy_s(taskCB->taskName, OS_TCB_NAME_LEN, created->name, strlen(created->name));
+    userAttr->stacksize   = taskCB->stackSize;//栈大小用 task的
+    err = memcpy_s(taskCB->taskName, OS_TCB_NAME_LEN, created->name, strlen(created->name));//task名称用参数名称
     if (err != EOK) {
         PRINT_ERR("%s: %d, err: %d\n", __FUNCTION__, __LINE__, err);
         taskCB->taskName[0] = '\0';
@@ -211,11 +211,11 @@ STATIC UINT32 InitPthreadData(pthread_t threadID, pthread_attr_t *userAttr,
     }
 #if (LOSCFG_KERNEL_SMP == YES)
     if (userAttr->cpuset.__bits[0] > 0) {
-        taskCB->cpuAffiMask = (UINT16)userAttr->cpuset.__bits[0];
+        taskCB->cpuAffiMask = (UINT16)userAttr->cpuset.__bits[0];//指定task的CPU亲和力掩码
     }
 #endif
 
-    SetPthreadDataAttr(userAttr, threadID, taskCB, created);
+    SetPthreadDataAttr(userAttr, threadID, taskCB, created);//设置线程数据具体属性
     return ret;
 }
 //POSIX接口之 创建一个线程
@@ -224,7 +224,7 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
 {
     pthread_attr_t userAttr;
     UINT32 ret;
-    CHAR name[PTHREAD_DATA_NAME_MAX];
+    CHAR name[PTHREAD_DATA_NAME_MAX];//线程名称不能超过 20个字符
     STATIC UINT16 pthreadNumber = 1;
     TSK_INIT_PARAM_S taskInitParam = {0};
     UINT32 taskHandle;
@@ -239,33 +239,33 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     (VOID)memset_s(name, sizeof(name), 0, sizeof(name));
     (VOID)snprintf_s(name, sizeof(name), sizeof(name) - 1, "pth%02d", pthreadNumber);
     pthreadNumber++;
-
-    taskInitParam.pcName       = name;
-    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)startRoutine;
-    taskInitParam.auwArgs[0]   = (UINTPTR)arg;
-    taskInitParam.usTaskPrio   = (UINT16)userAttr.schedparam.sched_priority;
-    taskInitParam.uwStackSize  = userAttr.stacksize;
-    if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        taskInitParam.processID = OsGetKernelInitProcessID();
+	//参数的转化,适配
+    taskInitParam.pcName       = name;	//线程名称
+    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)startRoutine;//入口函数
+    taskInitParam.auwArgs[0]   = (UINTPTR)arg;	//入口函数的参数
+    taskInitParam.usTaskPrio   = (UINT16)userAttr.schedparam.sched_priority;//线程优先级
+    taskInitParam.uwStackSize  = userAttr.stacksize;//栈大小
+    if (OsProcessIsUserMode(OsCurrProcessGet())) {//当前进程是用户进程吗
+        taskInitParam.processID = OsGetKernelInitProcessID();// 赋予内核初始化进程ID 即:"Kprocess"进程
     } else {
-        taskInitParam.processID = OsCurrProcessGet()->processID;
+        taskInitParam.processID = OsCurrProcessGet()->processID;// 内核某个进程的ID
     }
-    if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {
+    if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {//线程间关系为 分离模式
         taskInitParam.uwResved = LOS_TASK_STATUS_DETACHED;
-    } else {
+    } else {////线程间关系为 联结模式
         /* Set the pthread default joinable */
         taskInitParam.uwResved = 0;
     }
 
-    PthreadReap();
-    ret = LOS_TaskCreateOnly(&taskHandle, &taskInitParam);
+    PthreadReap();// posix <--> liteos 数据同步
+    ret = LOS_TaskCreateOnly(&taskHandle, &taskInitParam);//创建一个任务
     if (ret == LOS_OK) {
-        *thread = (pthread_t)taskHandle;
-        ret = InitPthreadData(*thread, &userAttr, name, PTHREAD_DATA_NAME_MAX);
+        *thread = (pthread_t)taskHandle;//任务ID
+        ret = InitPthreadData(*thread, &userAttr, name, PTHREAD_DATA_NAME_MAX);//初始化线程数据
         if (ret != LOS_OK) {
             goto ERROR_OUT_WITH_TASK;
         }
-        (VOID)LOS_SetTaskScheduler(taskHandle, SCHED_RR, taskInitParam.usTaskPrio);
+        (VOID)LOS_SetTaskScheduler(taskHandle, SCHED_RR, taskInitParam.usTaskPrio);//设置任务的调度参数
     }
 
     if (ret == LOS_OK) {
@@ -284,7 +284,7 @@ ERROR_OUT:
 //POSIX接口之 终止当前线程
 void pthread_exit(void *retVal)
 {
-    _pthread_data *self = pthread_get_self_data();
+    _pthread_data *self = pthread_get_self_data();//获取当前线程实体
     UINT32 intSave;
 
     if (pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, (int *)0) != ENOERR) {
@@ -462,29 +462,29 @@ int pthread_detach(pthread_t thread)
 
     return ret;
 }
-
+//posix 设置线程的调度参数
 int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
 {
     _pthread_data *data = NULL;
     int ret;
 
-    if ((param == NULL) || (param->sched_priority > OS_TASK_PRIORITY_LOWEST)) {
+    if ((param == NULL) || (param->sched_priority > OS_TASK_PRIORITY_LOWEST)) {//优先级不能过 31级
         return EINVAL;
     }
 
-    if (policy != SCHED_RR) {
+    if (policy != SCHED_RR) {//必须是抢占式调度方式
         return EINVAL;
     }
 
     /* The parameters seem OK, change the thread. */
-    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
+    ret = pthread_mutex_lock(&g_pthreadsDataMutex);//持有posix 线程互斥锁
     if (ret != ENOERR) {
         return ret;
     }
 
-    data = pthread_get_data(thread);
+    data = pthread_get_data(thread);//获取线程实体数据
     if (data == NULL) {
-        ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
+        ret = pthread_mutex_unlock(&g_pthreadsDataMutex);//异常情况要释放锁
         if (ret != ENOERR) {
             return ret;
         }
@@ -492,18 +492,18 @@ int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param
     }
 
     /* Only support one policy now */
-    data->attr.schedpolicy = SCHED_RR;
-    data->attr.schedparam  = *param;
+    data->attr.schedpolicy = SCHED_RR; 	//鸿蒙目前仅支持 抢占式调度
+    data->attr.schedparam  = *param;	//调度参数
 
-    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
+    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);//释放锁
     if (ret != ENOERR) {
         return ret;
     }
-    (VOID)LOS_TaskPriSet((UINT32)thread, (UINT16)param->sched_priority);
+    (VOID)LOS_TaskPriSet((UINT32)thread, (UINT16)param->sched_priority);//设置调度的优先级
 
     return ENOERR;
 }
-
+//posix 获取线程的调度参数
 int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param)
 {
     _pthread_data *data = NULL;
@@ -513,23 +513,23 @@ int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *par
         return EINVAL;
     }
 
-    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
+    ret = pthread_mutex_lock(&g_pthreadsDataMutex);//持有posix 线程互斥锁
     if (ret != ENOERR) {
         return ret;
     }
 
-    data = pthread_get_data(thread);
+    data = pthread_get_data(thread);//获取线程实体数据
     if (data == NULL) {
         goto ERR_OUT;
     }
 
-    *policy = data->attr.schedpolicy;
-    *param = data->attr.schedparam;
+    *policy = data->attr.schedpolicy;//拿到调度方式
+    *param = data->attr.schedparam;//拿到调度参数
 
-    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
+    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);//释放锁
     return ret;
 ERR_OUT:
-    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
+    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);//异常情况下释放锁
     if (ret != ENOERR) {
         return ret;
     }
@@ -688,7 +688,7 @@ OUT:
     LOS_TaskUnlock();
     return ret;
 }
-//
+
 int pthread_cancel(pthread_t thread)
 {
     _pthread_data *data = NULL;
@@ -752,10 +752,10 @@ void pthread_testcancel(void)
     }
 }
 
-/* Get current thread id. */
+/* Get current thread id. */ //获取当前的线程ID
 pthread_t pthread_self(void)
 {
-    _pthread_data *data = pthread_get_self_data();
+    _pthread_data *data = pthread_get_self_data();//获取当前线程的实体
 
     return data->id;
 }

compat/posix/src/pthread_attr.c

@@ -37,18 +37,18 @@
 extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */
-//现实 POSIX   thread 接口
+//posix thread 属性初始化
 int pthread_attr_init(pthread_attr_t *attr)
 {
     if (attr == NULL) {
         return EINVAL;
     }
 
-    attr->detachstate                 = PTHREAD_CREATE_JOINABLE;
-    attr->schedpolicy                 = SCHED_RR;
+    attr->detachstate                 = PTHREAD_CREATE_JOINABLE;//默认线程采用联结方式
+    attr->schedpolicy                 = SCHED_RR;	//默认调度方式为抢占式 
     attr->schedparam.sched_priority   = LOSCFG_BASE_CORE_TSK_DEFAULT_PRIO;//默认线程优先级
-    attr->inheritsched                = PTHREAD_INHERIT_SCHED;
-    attr->scope                       = PTHREAD_SCOPE_PROCESS;
+    attr->inheritsched                = PTHREAD_INHERIT_SCHED;//表示新线程将继承创建线程的调度策略和参数 对应的就是 PTHREAD_EXPLICIT_SCHED
+    attr->scope                       = PTHREAD_SCOPE_PROCESS;//线程作用域,默认只在进程
     attr->stackaddr_set               = 0;
     attr->stackaddr                   = NULL;
     attr->stacksize_set               = 1;

fs/vfs/disk/disk_shellcmd.c

@@ -37,7 +37,15 @@
 #include "disk.h"
 #include "shcmd.h"
 #include "shell.h"
-
+/******************************************************
+命令功能
+partinfo命令用于查看系统识别的硬盘，SD卡多分区信息。
+命令格式
+partinfo <dev_inodename>
+参数说明
+dev_inodename 要查看的分区名字。
+例如:partinfo /dev/mmcblk0p0
+******************************************************/
 INT32 osShellCmdPartInfo(INT32 argc, const CHAR **argv)
 {
     struct inode *node = NULL;

kernel/base/core/los_process.c

@@ -1456,33 +1456,33 @@ EXIT:
     SCHEDULER_UNLOCK(intSave);
     return gid;
 }
-
+//获取当前进程的组ID
 LITE_OS_SEC_TEXT INT32 LOS_GetCurrProcessGroupID(VOID)
 {
     return LOS_GetProcessGroupID(OsCurrProcessGet()->processID);
 }
-
+//用户进程分配栈并初始化
 STATIC VOID *OsUserInitStackAlloc(UINT32 processID, UINT32 *size)
 {
     LosVmMapRegion *region = NULL;
-    LosProcessCB *processCB = OS_PCB_FROM_PID(processID);
-    UINT32 stackSize = ALIGN(OS_USER_TASK_STACK_SIZE, PAGE_SIZE);
-
+    LosProcessCB *processCB = OS_PCB_FROM_PID(processID);//获取当前进程实体
+    UINT32 stackSize = ALIGN(OS_USER_TASK_STACK_SIZE, PAGE_SIZE);//1M栈空间 按页对齐
+	//线性区分配虚拟内存
     region = LOS_RegionAlloc(processCB->vmSpace, 0, stackSize,
                              VM_MAP_REGION_FLAG_PERM_USER | VM_MAP_REGION_FLAG_PERM_READ |
-                             VM_MAP_REGION_FLAG_PERM_WRITE, 0);
+                             VM_MAP_REGION_FLAG_PERM_WRITE, 0);//可使用可读可写区
     if (region == NULL) {
         return NULL;
     }
 
-    LOS_SetRegionTypeAnon(region);
-    region->regionFlags |= VM_MAP_REGION_FLAG_STACK;
+    LOS_SetRegionTypeAnon(region);//匿名映射
+    region->regionFlags |= VM_MAP_REGION_FLAG_STACK;//标记该线性区为栈区
 
-    *size = stackSize;
+    *size = stackSize;//记录栈大小
 
     return (VOID *)(UINTPTR)region->range.base;
 }
-
+//执行回收和初始化,再利用
 LITE_OS_SEC_TEXT UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR *name,
                                              LosVmSpace *oldSpace, UINTPTR oldFiles)
 {
@@ -1596,7 +1596,9 @@ STATIC UINT32 OsUserInitProcessStart(UINT32 processID, TSK_INIT_PARAM_S *param)
 
     return LOS_OK;
 }
-//所有的用户进程都是使用同一个用户代码段描述符和用户数据段描述符，它们是__USER_CS和__USER_DS，也就是每个进程处于用户态时，它们的CS寄存器和DS寄存器中的值是相同的。当任何进程或者中断异常进入内核后，都是使用相同的内核代码段描述符和内核数据段描述符，它们是__KERNEL_CS和__KERNEL_DS。这里要明确记得，内核数据段实际上就是内核态堆栈段。
+//所有的用户进程都是使用同一个用户代码段描述符和用户数据段描述符，它们是__USER_CS和__USER_DS，
+//也就是每个进程处于用户态时，它们的CS寄存器和DS寄存器中的值是相同的。当任何进程或者中断异常进入内核后，
+//都是使用相同的内核代码段描述符和内核数据段描述符，它们是__KERNEL_CS和__KERNEL_DS。这里要明确记得，内核数据段实际上就是内核态堆栈段。
 LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
 {
     INT32 ret;

kernel/base/core/los_task.c

@@ -547,11 +547,11 @@ LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID **topStack, UINT32 stack
 {
     *topStack = (VOID *)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
 }
-
+//创建任务同步信号
 STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
 {
-#if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)
-    UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);
+#if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)//CPU多核情况下任务同步宏是否开启
+    UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);//创建一个syncSignal信号量
     if (ret != LOS_OK) {
         return LOS_ERRNO_TSK_MP_SYNC_RESOURCE;
     }
@@ -560,7 +560,7 @@ STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
 #endif
     return LOS_OK;
 }
-
+//删除任务同步信号
 STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
 {
 #if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)
@@ -569,7 +569,7 @@ STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
     (VOID)syncSignal;
 #endif
 }
-
+//同步信号等待
 LITE_OS_SEC_TEXT UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
 {
 #if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)
@@ -603,7 +603,7 @@ STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
     (VOID)taskCB;
 #endif
 }
-
+//释放任务内核资源
 STATIC VOID OsTaskKernelResourcesToFree(UINT32 syncSignal, UINTPTR topOfStack)
 {
     VOID *poolTmp = (VOID *)m_aucSysMem1;
@@ -733,7 +733,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_IN
     processCB = OS_PCB_FROM_PID(initParam->processID);//通过ID获取PCB ,单核进程数最多64个
     taskCB->processID = processCB->processID;//进程-线程的父子关系绑定
     mode = processCB->processMode;//调度方式同步process
-    LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));//插入进程的线程链表
+    LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));//挂入进程的线程链表
     if (mode == OS_USER_MODE) {//用户模式
         taskCB->userArea = initParam->userParam.userArea;
         taskCB->userMapBase = initParam->userParam.userMapBase;
@@ -744,10 +744,10 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_IN
     if (!processCB->threadNumber) {//进程线程数量为0时，
         processCB->threadGroupID = taskCB->taskID;//任务为线程组 组长
     }
-    processCB->threadNumber++;//这里说明 线程和TASK是一个意思 threadNumber代表活动线程数
+    processCB->threadNumber++;//这里说明 线程和TASK是一个意思 threadNumber代表活动线程数,thread消亡的时候会 threadNumber--
 
     numCount = processCB->threadCount;//代表总线程数，包括销毁的，只要存在过的都算，这个值也就是在这里用下，
-    processCB->threadCount++;
+    processCB->threadCount++;//线程总数++,注意这个数会一直累加的,哪怕thread最后退出了,这个统计这个进程曾经存在过的线程数量
     SCHEDULER_UNLOCK(intSave);
 
     if (initParam->pcName == NULL) {
@@ -757,7 +757,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_IN
         return LOS_OK;
     }
 
-    if (mode == OS_KERNEL_MODE) {
+    if (mode == OS_KERNEL_MODE) {//内核模式的情况
         ret = memcpy_s(taskCB->taskName, sizeof(CHAR) * OS_TCB_NAME_LEN, initParam->pcName, strlen(initParam->pcName));
         if (ret != EOK) {
             taskCB->taskName[0] = '\0';
@@ -785,7 +785,7 @@ LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
 
     return taskCB;
 }
-
+//只是创建一个任务,并不会加入就绪队列
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
     UINT32 intSave, errRet;
@@ -841,7 +841,7 @@ LOS_ERREND_REWIND_TCB:
 LOS_ERREND:
     return errRet;
 }
-//创建Task
+//创建Task,并加入就绪队列,申请调度
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
     UINT32 ret;
@@ -877,7 +877,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
 
     SCHEDULER_LOCK(intSave);
     taskCB->taskStatus &= ~OS_TASK_STATUS_INIT;//任务不再是初始化
-    OS_TASK_SCHED_QUEUE_ENQUEUE(taskCB, 0);//进入调度就绪队列,新任务是直接进入就绪队列的
+    OS_TASK_SCHED_QUEUE_ENQUEUE(taskCB, 0);//加入调度就绪队列,新任务是直接进入就绪队列的
     SCHEDULER_UNLOCK(intSave);
 
     /* in case created task not running on this core,

kernel/base/include/los_vm_map.h

@@ -77,8 +77,8 @@ struct page_mapping {
 */
 
 typedef struct VmMapRange {
-    VADDR_T             base;           /**< vm region base addr */
-    UINT32              size;           /**< vm region size */
+    VADDR_T             base;           /**< vm region base addr */ //线性区基地址
+    UINT32              size;           /**< vm region size */	//线性区大小
 } LosVmMapRange;
 
 struct VmMapRegion;
@@ -105,45 +105,45 @@ struct VmFileOps {// 文件操作
 };
 
 struct VmMapRegion {
-    LosRbNode           rbNode;         /**< region red-black tree node */
+    LosRbNode           rbNode;         /**< region red-black tree node */	//红黑树节点,主要是挂在VmSpace.regionRbTree
     LosVmSpace          *space;			//所属虚拟空间
-    LOS_DL_LIST         node;           /**< region dl list */
-    LosVmMapRange       range;          /**< region address range */
-    VM_OFFSET_T         pgOff;          /**< region page offset to file */
+    LOS_DL_LIST         node;           /**< region dl list */				//链表节点,主要是挂在VmSpace.regions上
+    LosVmMapRange       range;          /**< region address range */		//记录线性区的范围
+    VM_OFFSET_T         pgOff;          /**< region page offset to file */	//区域页面到文件的偏移量
     UINT32              regionFlags;   /**< region flags: cow, user_wired */
-    UINT32              shmid;          /**< shmid about shared region */
+    UINT32              shmid;          /**< shmid about shared region */	//shmid为共享线性区id
     UINT8               protectFlags;   /**< vm region protect flags: PROT_READ, PROT_WRITE, *///线性区中页框的访问许可权
-    UINT8               forkFlags;      /**< vm space fork flags: COPY, ZERO, */
-    UINT8               regionType;     /**< vm region type: ANON, FILE, DEV */
+    UINT8               forkFlags;      /**< vm space fork flags: COPY, ZERO, */	//fork的方式
+    UINT8               regionType;     /**< vm region type: ANON, FILE, DEV */	//映射类型是匿名,文件,还是设备,所谓匿名可理解为内存映射
     union {
         struct VmRegionFile {
-            unsigned int fileMagic;//具有特殊文件格式的文件，如C文件，它会有#include字样
+            unsigned int fileMagic;//具有特殊文件格式的文件,魔法数字.例如 stack top 的魔法数字为 0xCCCCCCCC
             struct file *file;		//文件指针
-            const LosVmFileOps *vmFOps;//文件处理函数
+            const LosVmFileOps *vmFOps;//文件处理各操作接口
         } rf;
         struct VmRegionAnon {
-            LOS_DL_LIST  node;          /**< region LosVmPage list */
+            LOS_DL_LIST  node;          /**< region LosVmPage list */ //线性区虚拟页链表
         } ra;
         struct VmRegionDev {
-            LOS_DL_LIST  node;          /**< region LosVmPage list */
-            const LosVmFileOps *vmFOps; //设备当文件处理
+            LOS_DL_LIST  node;          /**< region LosVmPage list */	//线性区虚拟页链表
+            const LosVmFileOps *vmFOps; //设备也是一种文件
         } rd;
     } unTypeData;
 };
 
 typedef struct VmSpace {
-    LOS_DL_LIST         node;           /**< vm space dl list */
-    LOS_DL_LIST         regions;        /**< region dl list */
-    LosRbTree           regionRbTree;   /**< region red-black tree root */
-    LosMux              regionMux;      /**< region list mutex lock */
-    VADDR_T             base;           /**< vm space base addr */
-    UINT32              size;           /**< vm space size */
-    VADDR_T             heapBase;       /**< vm space heap base address */
-    VADDR_T             heapNow;        /**< vm space heap base now */
-    LosVmMapRegion      *heap;          /**< heap region */
-    VADDR_T             mapBase;        /**< vm space mapping area base */
-    UINT32              mapSize;        /**< vm space mapping area size */
-    LosArchMmu          archMmu;        /**< vm mapping physical memory */
+    LOS_DL_LIST         node;           /**< vm space dl list */	//节点,主要用于通过它挂到全局虚拟空间链表上
+    LOS_DL_LIST         regions;        /**< region dl list */		//双循环链表方式管理虚拟空间的各个线性区
+    LosRbTree           regionRbTree;   /**< region red-black tree root */	//采用红黑树方式管理虚拟空间的各个线性区
+    LosMux              regionMux;      /**< region list mutex lock */	//虚拟空间的互斥锁
+    VADDR_T             base;           /**< vm space base addr */	//虚拟空间的基地址
+    UINT32              size;           /**< vm space size */		//虚拟空间大小
+    VADDR_T             heapBase;       /**< vm space heap base address */	//虚拟空间堆区基地址
+    VADDR_T             heapNow;        /**< vm space heap base now */		//记录虚拟空间分配到哪了
+    LosVmMapRegion      *heap;          /**< heap region */		//堆区
+    VADDR_T             mapBase;        /**< vm space mapping area base */	//虚拟空间映射区基地址
+    UINT32              mapSize;        /**< vm space mapping area size */	//虚拟空间映射区大小
+    LosArchMmu          archMmu;        /**< vm mapping physical memory */	//MMU记录和物理地址的映射情况
 #ifdef LOSCFG_DRIVERS_TZDRIVER
     VADDR_T             codeStart;      /**< user process code area start */
     VADDR_T             codeEnd;        /**< user process code area end */

kernel/include/los_task.h

@@ -492,19 +492,19 @@ typedef struct {
  * Information of specified parameters passed in during task creation.
  */
 typedef struct tagTskInitParam {//Task的初始化参数
-    TSK_ENTRY_FUNC  pfnTaskEntry;  /**< Task entrance function */
-    UINT16          usTaskPrio;    /**< Task priority */
-    UINT16          policy;        /**< Task policy */
-    UINTPTR         auwArgs[4];    /**< Task parameters, of which the maximum number is four */
-    UINT32          uwStackSize;   /**< Task stack size */
-    CHAR            *pcName;       /**< Task name */
+    TSK_ENTRY_FUNC  pfnTaskEntry;  /**< Task entrance function */	//任务的入口函数
+    UINT16          usTaskPrio;    /**< Task priority */	//任务优先级
+    UINT16          policy;        /**< Task policy */		//任务调度方式
+    UINTPTR         auwArgs[4];    /**< Task parameters, of which the maximum number is four */	//入口函数的参数,最多四个
+    UINT32          uwStackSize;   /**< Task stack size */	//任务栈大小
+    CHAR            *pcName;       /**< Task name */		//任务名称
 #if (LOSCFG_KERNEL_SMP == YES)
-    UINT16          usCpuAffiMask; /**< Task cpu affinity mask         */
+    UINT16          usCpuAffiMask; /**< Task cpu affinity mask         */	//任务cpu关联掩码
 #endif
     UINT32          uwResved;      /**< It is automatically deleted if set to LOS_TASK_STATUS_DETACHED.
-                                        It is unable to be deleted if set to 0. */
-    UINT16          consoleID;     /**< The console id of task belongs  */
-    UINT32          processID;
+                                        It is unable to be deleted if set to 0. */ //如果设置为LOS_TASK_STATUS_DETACHED，则自动删除。如果设置为0，则无法删除
+    UINT16          consoleID;     /**< The console id of task belongs  */ //任务的控制台id所属
+    UINT32          processID;	//进程ID
     UserTaskParam   userParam;	//用户参数
 } TSK_INIT_PARAM_S;
 

zzz/git/push.sh

 git add -A
-git commit -m  'shell 物理内存，虚拟内存，VDSO，文件操作 部分注释说明 
+git commit -m  'posix 线程代码部分注释 ,完善task模块的注释
 鸿蒙内核源码分析系列 【 CSDN | OSCHINA | WIKI 】
 鸿蒙内核源码注释中文版 【 CSDN仓 | Gitee仓 | Github仓 | Coding仓 】四大仓库每日同步更新代码和wiki
 项目给鸿蒙内核源码逐行加上中文注解,详细阐述框架和代码细节, 精读 HarmonyOS 内核源码, 将迅速拔高对计算机整体理解,从此高屋建瓴看问题.'