新增控制台，事件，循环buf的代码注释，您知道工作台是如何创建的吗?

搜索 @note_pic 可以查看全部字符图
搜索 @note_why 是注者尚未看明白的地方，如果您看明白了，请告诉注者完善
搜索 @note_thinking 是注者的思考和吐槽的地方

README.md

@@ -7,7 +7,6 @@
 
 [![star](https://gitee.com/weharmony/kernel_liteos_a_note/badge/star.svg?theme=dark)](https://gitee.com/weharmony/kernel_liteos_a_note)[![fork](https://gitee.com/weharmony/kernel_liteos_a_note/badge/fork.svg?theme=dark)](https://gitee.com/weharmony/kernel_liteos_a_note)
 
-# ![](https://oscimg.oschina.net/oscnet/up-c1f5f5e88b38fcb25f274a2062384b0c61e.png)
 
 每个码农,职业生涯,都应精读一遍内核源码. 鸿蒙内核源码就是很好的精读项目.一旦熟悉内核代码级实现,将迅速拔高对计算机整体理解,从此高屋建瓴看问题.
 
@@ -22,6 +21,16 @@
 -   ### **致敬鸿蒙内核开发者**
     
     感谢开放原子开源基金会,鸿蒙内核开发者提供了如此优秀的源码,一了多年的夙愿,津津乐道于此.越深入精读内核源码,越能感受到设计者的精巧用心,创新突破. 向开发者致敬. 可以毫不夸张的说 **[OpenHarmony/kernel\_liteos\_a](https://gitee.com/openharmony/kernel_liteos_a)** 可作为大学C语言,数据结构,操作系统,汇编语言 四门课程的教学项目.如此宝库,不深入研究实在是太可惜了.
+
+    ### **在加注的源码中有哪些特殊的记号**
+
+    搜索 **[@note_pic]()** 可查看绘制的全部字符图
+
+    搜索 **[@note_why]()** 是注者尚未看明白的地方，如果您看明白了，请告诉注者完善
+
+    搜索 **[@note_thinking]()** 是注者的思考和吐槽鸿蒙源码的地方
+
+    若有好的建议请邮箱**kuangyufei@126.com**或私信联系.
     
 -   ### **理解内核的三个层级**
     
@@ -48,12 +57,6 @@
     另外用字符画了一些图方便理解,直接嵌入到头文件中,比如虚拟内存的全景图,因没有这些图是很难理解内存是如何管理的,后续还会陆续加入更多的图方便理解.
     
     ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028154344813.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2t1YW5neXVmZWk=,size_16,color_FFFFFF,t_70#pic_center)
-
-    ### **有哪些方便查找的记号**
-
-    搜索 @note_why 是笔者暂时没看懂的代码和疑惑, 如果有兴趣请帮笔者一起完善注解,让鸿蒙内核注解越来越清晰.
-    搜索 @note_pic 是笔者用字符画的一些图,用于方便理解. 目前所绘制的图不多,会陆续增加.
-    联系方式: kuangyufei@126.com 有好的建议请邮箱或私信联系.
     
 -   ### **仰望星空还是埋头走路**
     
@@ -72,4 +75,6 @@
     
     注释中文版 进入 >\> [鸿蒙内核源码注释中文版 【 Gitee仓](https://gitee.com/weharmony/kernel_liteos_a_note) | [CSDN仓](https://codechina.csdn.net/kuangyufei/kernel_liteos_a_note) | [Github仓](https://github.com/kuangyufei/kernel_liteos_a_note) | [Coding仓 】](https://weharmony.coding.net/public/harmony/kernel_liteos_a_note/git/files)阅读
     
-    内容仅代表个人观点,会反复修正,出精品注解,写精品文章,一律原创,转载需注明出处,不修改内容,不乱插广告,错漏之处欢迎指正笔者第一时间加以完善。
\ No newline at end of file
+    内容仅代表个人观点,会反复修正,出精品注解,写精品文章,一律原创,转载需注明出处,不修改内容,不乱插广告,错漏之处欢迎指正笔者第一时间加以完善。
+
+    # ![](https://oscimg.oschina.net/oscnet/up-c1f5f5e88b38fcb25f274a2062384b0c61e.png)
\ No newline at end of file

arch/arm/arm/src/los_exc.c

@@ -121,7 +121,7 @@ UINT32 OsGetSystemStatus(VOID)
 
     if (cpuID == INVALID_CPUID) {
         flag = OS_SYSTEM_NORMAL;
-    } else if (cpuID == ArchCurrCpuid()) {//真的是碰到了真在执行此处代码的CPU core
+    } else if (cpuID == ArchCurrCpuid()) {//碰到了正在执行此处代码的CPU core
         flag = OS_SYSTEM_EXC_CURR_CPU;//当前CPU
     } else {
         flag = OS_SYSTEM_EXC_OTHER_CPU;//其他CPU

kernel/base/core/los_task.c

@@ -1970,7 +1970,7 @@ LITE_OS_SEC_TEXT VOID OsWriteResourceEvent(UINT32 events)
 {
     (VOID)LOS_EventWrite(&g_resourceEvent, events);
 }
-
+//资源回收任务
 STATIC VOID OsResourceRecoveryTask(VOID)
 {
     UINT32 ret;
@@ -1978,15 +1978,15 @@ STATIC VOID OsResourceRecoveryTask(VOID)
     while (1) {
         ret = LOS_EventRead(&g_resourceEvent, OS_RESOURCE_EVENT_MASK,
                             LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
-        if (ret & (OS_RESOURCE_EVENT_FREE | OS_RESOURCE_EVENT_OOM)) {
-            OsTaskCBRecyleToFree();
+        if (ret & (OS_RESOURCE_EVENT_FREE | OS_RESOURCE_EVENT_OOM)) {//资源释放或异常情况
+            OsTaskCBRecyleToFree();//回收任务到空闲任务池
 
-            OsProcessCBRecyleToFree();
+            OsProcessCBRecyleToFree();//回收进程到空闲进程池
         }
 
-#ifdef LOSCFG_ENABLE_OOM_LOOP_TASK
-        if (ret & OS_RESOURCE_EVENT_OOM) {
-            (VOID)OomCheckProcess();
+#ifdef LOSCFG_ENABLE_OOM_LOOP_TASK //内存溢出监测任务开关
+        if (ret & OS_RESOURCE_EVENT_OOM) {//触发了这个事件
+            (VOID)OomCheckProcess();//检查进程
         }
 #endif
     }
@@ -2004,11 +2004,11 @@ LITE_OS_SEC_TEXT UINT32 OsCreateResourceFreeTask(VOID)
     }
 
     (VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
-    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsResourceRecoveryTask;
-    taskInitParam.uwStackSize = OS_TASK_RESOURCE_STATCI_SIZE;
+    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsResourceRecoveryTask;//入口函数
+    taskInitParam.uwStackSize = OS_TASK_RESOURCE_STATCI_SIZE;// 4K
     taskInitParam.pcName = "ResourcesTask";
     taskInitParam.usTaskPrio = OS_TASK_RESOURCE_FREE_PRIORITY;// 5
-    return LOS_TaskCreate(&taskID, &taskInitParam);
+    return LOS_TaskCreate(&taskID, &taskInitParam);//创建任务，并加入就绪队列，立即调度
 }
 
 #ifdef __cplusplus

kernel/base/include/los_task_pri.h

@@ -286,11 +286,11 @@ extern SPIN_LOCK_S g_taskSpin;//任务自旋锁
 #define LOSCFG_STACK_POINT_ALIGN_SIZE                       (sizeof(UINTPTR) * 2)
 #endif
 
-#define OS_TASK_RESOURCE_STATCI_SIZE    0x1000
-#define OS_TASK_RESOURCE_FREE_PRIORITY  5
-#define OS_RESOURCE_EVENT_MASK          0xFF
-#define OS_RESOURCE_EVENT_OOM           0x02
-#define OS_RESOURCE_EVENT_FREE          0x04
+#define OS_TASK_RESOURCE_STATCI_SIZE    0x1000	//4K
+#define OS_TASK_RESOURCE_FREE_PRIORITY  5		//回收资源任务的优先级
+#define OS_RESOURCE_EVENT_MASK          0xFF	//资源事件的掩码
+#define OS_RESOURCE_EVENT_OOM           0x02	//资源异常事件 暂时的理解是:OutOfMemory @note_thinking
+#define OS_RESOURCE_EVENT_FREE          0x04	//资源释放事件
 #define OS_TCB_NAME_LEN 32
 
 typedef struct {
@@ -308,7 +308,7 @@ typedef struct {
     VOID            *taskMux;           /**< Task-held mutex */		//task在等哪把锁
     VOID            *taskEvent;         /**< Task-held event */		//task在等哪个事件
     UINTPTR         args[4];            /**< Parameter, of which the maximum number is 4 */	//入口函数的参数 例如 main (int argc,char *argv[])
-    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */
+    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */	//任务的名称
     LOS_DL_LIST     pendList;           /**< Task pend node */		//如果任务阻塞时就通过它挂到各种阻塞情况的链表上,比如OsTaskWait时
     LOS_DL_LIST     threadList;         /**< thread list */			//挂到所属进程的线程链表上
     SortLinkList    sortList;           /**< Task sortlink node */	//挂到cpu core 的任务执行链表上
@@ -337,7 +337,7 @@ typedef struct {
     UINTPTR         userArea;			//使用区域,由运行时划定,根据运行态不同而不同
     UINTPTR         userMapBase;		//用户模式下的栈底位置
     UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
-    UINT32          processID;          /**< Which belong process */
+    UINT32          processID;          /**< Which belong process *///所属进程ID
     FutexNode       futex;				//实现快锁功能
     LOS_DL_LIST     joinList;           /**< join list */ //联结链表,允许任务之间相互释放彼此
     LOS_DL_LIST     lockList;           /**< Hold the lock list */	//拿到了哪些锁链表

kernel/base/ipc/los_event.c

@@ -44,7 +44,7 @@
 extern "C" {
 #endif
 #endif /* __cplusplus */
-//事件初始化
+//初始化一个事件控制块
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
 {
     UINT32 intSave;
@@ -81,53 +81,53 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMa
     }
     return LOS_OK;
 }
-
+////根据用户传入的事件值、事件掩码及校验模式，返回用户传入的事件是否符合预期
 LITE_OS_SEC_TEXT UINT32 OsEventPoll(UINT32 *eventID, UINT32 eventMask, UINT32 mode)
 {
     UINT32 ret = 0;
 
-    LOS_ASSERT(OsIntLocked());
-    LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));
+    LOS_ASSERT(OsIntLocked());//断言不允许中断了
+    LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));//任务自旋锁
 
-    if (mode & LOS_WAITMODE_OR) {
+    if (mode & LOS_WAITMODE_OR) {//如果模式是读取掩码中任意事件
         if ((*eventID & eventMask) != 0) {
             ret = *eventID & eventMask;
         }
-    } else {
-        if ((eventMask != 0) && (eventMask == (*eventID & eventMask))) {
+    } else {//等待全部事件发生
+        if ((eventMask != 0) && (eventMask == (*eventID & eventMask))) {//必须满足全部事件发生
             ret = *eventID & eventMask;
         }
     }
 
-    if (ret && (mode & LOS_WAITMODE_CLR)) {
+    if (ret && (mode & LOS_WAITMODE_CLR)) {//读取完成后清除事件
         *eventID = *eventID & ~ret;
     }
 
     return ret;
 }
-
+//检查读事件
 LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode)
 {
     UINT32 ret;
     LosTaskCB *runTask = NULL;
 
-    ret = OsEventParamCheck(eventCB, eventMask, mode);
+    ret = OsEventParamCheck(eventCB, eventMask, mode);//事件参数检查
     if (ret != LOS_OK) {
         return ret;
     }
 
-    if (OS_INT_ACTIVE) {
-        return LOS_ERRNO_EVENT_READ_IN_INTERRUPT;
+    if (OS_INT_ACTIVE) {//中断正在进行
+        return LOS_ERRNO_EVENT_READ_IN_INTERRUPT;//不能在中断发送时读事件
     }
 
-    runTask = OsCurrTaskGet();
-    if (runTask->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
+    runTask = OsCurrTaskGet();//获取当前任务
+    if (runTask->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {//任务属于系统任务
         OsBackTrace();
-        return LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK;
+        return LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK;//不能在系统任务中读取事件
     }
     return LOS_OK;
 }
-
+//读取指定事件类型的实现函数，超时时间为相对时间：单位为Tick
 LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode,
                                               UINT32 timeout, BOOL once)
 {
@@ -135,49 +135,49 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventM
     LosTaskCB *runTask = OsCurrTaskGet();
 
     if (once == FALSE) {
-        ret = OsEventPoll(&eventCB->uwEventID, eventMask, mode);
+        ret = OsEventPoll(&eventCB->uwEventID, eventMask, mode);//检测事件是否符合预期
     }
 
-    if (ret == 0) {
-        if (timeout == 0) {
+    if (ret == 0) {//不符合预期时
+        if (timeout == 0) {//不等待的情况
             return ret;
         }
 
-        if (!OsPreemptableInSched()) {
+        if (!OsPreemptableInSched()) {//不能抢占式调度
             return LOS_ERRNO_EVENT_READ_IN_LOCK;
         }
 
         runTask->eventMask = eventMask;
         runTask->eventMode = mode;
-        runTask->taskEvent = eventCB;
-        ret = OsTaskWait(&eventCB->stEventList, timeout, TRUE);
-        if (ret == LOS_ERRNO_TSK_TIMEOUT) {
+        runTask->taskEvent = eventCB;//事件控制块
+        ret = OsTaskWait(&eventCB->stEventList, timeout, TRUE);//任务进入等待状态，挂入阻塞链表
+        if (ret == LOS_ERRNO_TSK_TIMEOUT) {//如果返回超时
             runTask->taskEvent = NULL;
             return LOS_ERRNO_EVENT_READ_TIMEOUT;
         }
 
-        ret = OsEventPoll(&eventCB->uwEventID, eventMask, mode);
+        ret = OsEventPoll(&eventCB->uwEventID, eventMask, mode);//检测事件是否符合预期
     }
     return ret;
 }
-
+//读取指定事件类型，超时时间为相对时间：单位为Tick
 LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout,
                                            BOOL once)
 {
     UINT32 ret;
     UINT32 intSave;
 
-    ret = OsEventReadCheck(eventCB, eventMask, mode);
+    ret = OsEventReadCheck(eventCB, eventMask, mode);//读取事件检查
     if (ret != LOS_OK) {
         return ret;
     }
 
     SCHEDULER_LOCK(intSave);
-    ret = OsEventReadImp(eventCB, eventMask, mode, timeout, once);
+    ret = OsEventReadImp(eventCB, eventMask, mode, timeout, once);//读事件实现函数
     SCHEDULER_UNLOCK(intSave);
     return ret;
 }
-
+//事件恢复操作
 LITE_OS_SEC_TEXT STATIC UINT8 OsEventResume(LosTaskCB *resumedTask, const PEVENT_CB_S eventCB, UINT32 events)
 {
     UINT8 exitFlag = 0;
@@ -188,7 +188,7 @@ LITE_OS_SEC_TEXT STATIC UINT8 OsEventResume(LosTaskCB *resumedTask, const PEVENT
         exitFlag = 1;
 
         resumedTask->taskEvent = NULL;
-        OsTaskWake(resumedTask);
+        OsTaskWake(resumedTask);//唤醒任务
     }
 
     return exitFlag;
@@ -243,7 +243,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events,
     }
     return LOS_OK;
 }
-
+//根据用户传入的事件值、事件掩码及校验模式，返回用户传入的事件是否符合预期
 LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventID, UINT32 eventMask, UINT32 mode)
 {
     UINT32 ret;
@@ -259,12 +259,12 @@ LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventID, UINT32 eventMask, UINT32
     SCHEDULER_UNLOCK(intSave);
     return ret;
 }
-//读事件
+//读取指定事件类型，超时时间为相对时间：单位为Tick
 LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
 {
     return OsEventRead(eventCB, eventMask, mode, timeout, FALSE);
 }
-//写事件
+//写指定的事件类型
 LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events)
 {
     return OsEventWrite(eventCB, events, FALSE);
@@ -280,7 +280,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsEventWriteOnce(PEVENT_CB_S eventCB, UINT32 event
 {
     return OsEventWrite(eventCB, events, TRUE);
 }
-//事件销毁
+//销毁指定的事件控制块
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB)
 {
     UINT32 intSave;
@@ -301,7 +301,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB)
 
     return LOS_OK;
 }
-//事件清除
+//清除指定的事件类型
 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events)
 {
     UINT32 intSave;

kernel/base/ipc/los_signal.c

@@ -58,7 +58,8 @@ int raise(int sig)
 int OsSigIsMember(const sigset_t *set, int signo)
 {
     int ret = LOS_NOK;
-    /* In musl, sig No bits 00000100 present sig No 3, but  1<< 3 = 00001000, so signo needs minus 1 */ //@note_why 这里对musl的说明没看明白,为什么要-1呢?
+    /* In musl, sig No bits 00000100 present sig No 3, but  1<< 3 = 00001000, so signo needs minus 1 */ 
+	//@note_why 这里对musl的说明没看明白,为什么要-1呢?
     signo -= 1;
     /* Verify the signal */
     if (GOOD_SIGNO(signo)) {

kernel/base/mem/bestfit/los_memory.c

@@ -207,7 +207,7 @@ STATIC VOID OsMemNodeSave(LosMemDynNode *node);
     (((UINTPTR)(value) ^ ((UINTPTR)&(value))) == (UINTPTR)(-1))
 
 UINT8 *m_aucSysMem0 = NULL; //@note_why 不明白鸿蒙对虚拟内存分配为什么要用两个全局变量
-UINT8 *m_aucSysMem1 = NULL;	//auc是什么意思? 0和1又代表什么意思?
+UINT8 *m_aucSysMem1 = NULL;	//auc是什么意思? 变量名最后0和1又代表什么意思? 就不能整个好听的名字吗？@note_thinking
 
 #ifdef LOSCFG_BASE_MEM_NODE_SIZE_CHECK
 STATIC UINT8 g_memCheckLevel = LOS_MEM_CHECK_LEVEL_DEFAULT;

kernel/base/vm/oom.c

@@ -119,8 +119,8 @@ LITE_OS_SEC_TEXT_MINOR STATIC BOOL OomReclaimPageCache(VOID)
 }
 
 /*
- * check is low memory or not, if low memory, try to kill process.
- * return is kill process or not.
+ * check is low memory or not, if low memory, try to kill process. //检查内存是否不足，如果内存不足，请尝试终止进程。
+ * return is kill process or not. //返回是否kill进程
  */
 LITE_OS_SEC_TEXT_MINOR BOOL OomCheckProcess(VOID)
 {

kernel/common/console.c

@@ -67,7 +67,7 @@ STATIC SPIN_LOCK_INIT(g_consoleSpin);
 
 #define SHELL_ENTRYID_INVALID     0xFFFFFFFF
 #define SHELL_TASK_PRIORITY       9		//shell 的优先级为 9
-#define CONSOLE_CIRBUF_EVENT      0x02U	//控制台清除buffer事件	
+#define CONSOLE_CIRBUF_EVENT      0x02U	//控制台循环buffer事件	
 #define CONSOLE_SEND_TASK_EXIT    0x04U	//控制台发送任务退出事件
 #define CONSOLE_SEND_TASK_RUNNING 0x10U	//控制台发送任务正在执行事件
 
@@ -599,7 +599,7 @@ INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll
     }
     return ret;
 }
-
+//打开控制台
 STATIC INT32 ConsoleOpen(struct file *filep)
 {
     INT32 ret;
@@ -675,7 +675,7 @@ STATIC ssize_t DoRead(CONSOLE_CB *consoleCB, CHAR *buffer, size_t bufLen,
 
     return ret;
 }
-
+//控制台读数据
 STATIC ssize_t ConsoleRead(struct file *filep, CHAR *buffer, size_t bufLen)
 {
     INT32 ret;
@@ -737,7 +737,7 @@ ERROUT:
     set_errno(-ret);
     return VFS_ERROR;
 }
-
+//写入buf
 STATIC ssize_t DoWrite(CirBufSendCB *cirBufSendCB, CHAR *buffer, size_t bufLen)
 {
     INT32 cnt = 0;
@@ -761,7 +761,7 @@ STATIC ssize_t DoWrite(CirBufSendCB *cirBufSendCB, CHAR *buffer, size_t bufLen)
     LOS_CirBufUnlock(&cirBufSendCB->cirBufCB, intSave);
     /* Log is cached but not printed when a system exception occurs */
     if (OsGetSystemStatus() == OS_SYSTEM_NORMAL) {
-        (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_CIRBUF_EVENT);
+        (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_CIRBUF_EVENT);//写入循环buffer事件
     }
 #ifdef LOSCFG_SHELL_DMESG
     }
@@ -769,7 +769,7 @@ STATIC ssize_t DoWrite(CirBufSendCB *cirBufSendCB, CHAR *buffer, size_t bufLen)
 
     return cnt;
 }
-
+//控制台写数据
 STATIC ssize_t ConsoleWrite(struct file *filep, const CHAR *buffer, size_t bufLen)
 {
     INT32 ret;
@@ -784,7 +784,7 @@ STATIC ssize_t ConsoleWrite(struct file *filep, const CHAR *buffer, size_t bufLe
         goto ERROUT;
     }
 
-    userBuf = LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buffer, bufLen);
+    userBuf = LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buffer, bufLen);//是用户空间地址吗？
 
     ret = GetFilepOps(filep, &privFilep, &fileOps);
     if ((ret != ENOERR) || (fileOps->write == NULL) || (filep->f_priv == NULL)) {
@@ -924,7 +924,7 @@ STATIC const struct file_operations_vfs g_consoleDevOps = {
 #endif
     .unlink = NULL,
 };
-
+//控制台条款初始化
 STATIC VOID OsConsoleTermiosInit(CONSOLE_CB *consoleCB, const CHAR *deviceName)
 {
     struct termios consoleTermios;
@@ -951,7 +951,7 @@ STATIC VOID OsConsoleTermiosInit(CONSOLE_CB *consoleCB, const CHAR *deviceName)
     }
 #endif
 }
-
+//控制台文件初始化
 STATIC INT32 OsConsoleFileInit(CONSOLE_CB *consoleCB)
 {
     INT32 ret;
@@ -996,7 +996,7 @@ ERROUT_WITH_FULLPATH:
 /*
  * Initialized console control platform so that when we operate /dev/console
  * as if we are operating /dev/ttyS0 (uart0).
- */
+ *///初始化控制台控制平台，以便在操作/dev/console时，就好像我们在操作/dev/ttyS0（uart0）
 STATIC INT32 OsConsoleDevInit(CONSOLE_CB *consoleCB, const CHAR *deviceName)
 {
     INT32 ret;
@@ -1114,7 +1114,7 @@ ERROUT:
     set_errno(ret);
     return LOS_NOK;
 }
-
+//创建一个控制台循环buf
 STATIC CirBufSendCB *ConsoleCirBufCreate(VOID)
 {
     UINT32 ret;
@@ -1122,25 +1122,25 @@ STATIC CirBufSendCB *ConsoleCirBufCreate(VOID)
     CirBufSendCB *cirBufSendCB = NULL;
     CirBuf *cirBufCB = NULL;
 
-    cirBufSendCB = (CirBufSendCB *)LOS_MemAlloc(m_aucSysMem0, sizeof(CirBufSendCB));
+    cirBufSendCB = (CirBufSendCB *)LOS_MemAlloc(m_aucSysMem0, sizeof(CirBufSendCB));//分配一个循环buf发送控制块
     if (cirBufSendCB == NULL) {
         return NULL;
     }
-    (VOID)memset_s(cirBufSendCB, sizeof(CirBufSendCB), 0, sizeof(CirBufSendCB));
+    (VOID)memset_s(cirBufSendCB, sizeof(CirBufSendCB), 0, sizeof(CirBufSendCB));//清0
 
-    fifo = (CHAR *)LOS_MemAlloc(m_aucSysMem0, TELNET_CIRBUF_SIZE);
+    fifo = (CHAR *)LOS_MemAlloc(m_aucSysMem0, TELNET_CIRBUF_SIZE);//分配一个缓存 8K
     if (fifo == NULL) {
         goto ERROR_WITH_SENDCB;
     }
-    (VOID)memset_s(fifo, TELNET_CIRBUF_SIZE, 0, TELNET_CIRBUF_SIZE);
+    (VOID)memset_s(fifo, TELNET_CIRBUF_SIZE, 0, TELNET_CIRBUF_SIZE);//清0
 
     cirBufCB = &cirBufSendCB->cirBufCB;
-    ret = LOS_CirBufInit(cirBufCB, fifo, TELNET_CIRBUF_SIZE);
+    ret = LOS_CirBufInit(cirBufCB, fifo, TELNET_CIRBUF_SIZE);//初始化循环buf
     if (ret != LOS_OK) {
         goto ERROR_WITH_FIFO;
     }
 
-    (VOID)LOS_EventInit(&cirBufSendCB->sendEvent);
+    (VOID)LOS_EventInit(&cirBufSendCB->sendEvent);//事件初始化
     return cirBufSendCB;
 
 ERROR_WITH_FIFO:
@@ -1149,15 +1149,15 @@ ERROR_WITH_SENDCB:
     (VOID)LOS_MemFree(m_aucSysMem0, cirBufSendCB);
     return NULL;
 }
-
+//删除循环buf
 STATIC VOID ConsoleCirBufDelete(CirBufSendCB *cirBufSendCB)
 {
     CirBuf *cirBufCB = &cirBufSendCB->cirBufCB;
 
-    (VOID)LOS_MemFree(m_aucSysMem0, cirBufCB->fifo);
-    LOS_CirBufDeinit(cirBufCB);
-    (VOID)LOS_EventDestroy(&cirBufSendCB->sendEvent);
-    (VOID)LOS_MemFree(m_aucSysMem0, cirBufSendCB);
+    (VOID)LOS_MemFree(m_aucSysMem0, cirBufCB->fifo);//释放内存 8K
+    LOS_CirBufDeinit(cirBufCB);//清除初始化操作
+    (VOID)LOS_EventDestroy(&cirBufSendCB->sendEvent);//销毁事件
+    (VOID)LOS_MemFree(m_aucSysMem0, cirBufSendCB);//释放循环buf发送控制块
 }
 //控制台缓存初始化，创建一个 发送任务
 STATIC UINT32 OsConsoleBufInit(CONSOLE_CB *consoleCB)
@@ -1165,30 +1165,30 @@ STATIC UINT32 OsConsoleBufInit(CONSOLE_CB *consoleCB)
     UINT32 ret;
     TSK_INIT_PARAM_S initParam = {0};
 
-    consoleCB->cirBufSendCB = ConsoleCirBufCreate();
+    consoleCB->cirBufSendCB = ConsoleCirBufCreate();//创建控制台
     if (consoleCB->cirBufSendCB == NULL) {
         return LOS_NOK;
     }
 
-    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)ConsoleSendTask;
-    initParam.usTaskPrio   = SHELL_TASK_PRIORITY;
+    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)ConsoleSendTask;//
+    initParam.usTaskPrio   = SHELL_TASK_PRIORITY;	//优先级9
     initParam.auwArgs[0]   = (UINTPTR)consoleCB;
-    initParam.uwStackSize  = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
-    if (consoleCB->consoleID == CONSOLE_SERIAL) {
-        initParam.pcName   = "SendToSer";
+    initParam.uwStackSize  = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;	//16K
+    if (consoleCB->consoleID == CONSOLE_SERIAL) {//控制台的两种方式
+        initParam.pcName   = "SendToSer"; 
     } else {
         initParam.pcName   = "SendToTelnet";
     }
-    initParam.uwResved     = LOS_TASK_STATUS_DETACHED;
+    initParam.uwResved     = LOS_TASK_STATUS_DETACHED; //使用任务分离模式
 
-    ret = LOS_TaskCreate(&consoleCB->sendTaskID, &initParam);
-    if (ret != LOS_OK) {
-        ConsoleCirBufDelete(consoleCB->cirBufSendCB);
-        consoleCB->cirBufSendCB = NULL;
+    ret = LOS_TaskCreate(&consoleCB->sendTaskID, &initParam);//创建task 并加入就绪队列，申请立即调度
+    if (ret != LOS_OK) { //创建失败处理
+        ConsoleCirBufDelete(consoleCB->cirBufSendCB);//释放循环buf
+        consoleCB->cirBufSendCB = NULL;//置NULL
         return LOS_NOK;
     }
     (VOID)LOS_EventRead(&consoleCB->cirBufSendCB->sendEvent, CONSOLE_SEND_TASK_RUNNING,
-                        LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
+                        LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);//读取事件
 
     return LOS_OK;
 }
@@ -1198,7 +1198,7 @@ STATIC VOID OsConsoleBufDeinit(CONSOLE_CB *consoleCB)
     CirBufSendCB *cirBufSendCB = consoleCB->cirBufSendCB;
 
     consoleCB->cirBufSendCB = NULL;
-    (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_SEND_TASK_EXIT);
+    (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_SEND_TASK_EXIT);//写任务退出事件 ConsoleSendTask将会收到事件，退出死循环
 }
 //控制台描述符初始化
 STATIC CONSOLE_CB *OsConsoleCBInit(UINT32 consoleID)
@@ -1226,7 +1226,7 @@ STATIC VOID OsConsoleCBDeinit(CONSOLE_CB *consoleCB)
     consoleCB->name = NULL;
     (VOID)LOS_MemFree((VOID *)m_aucSysMem0, consoleCB);//释放控制台描述符所占用的内核内存
 }
-//创建一个控制台
+//创建一个控制台，这个函数的goto语句贼多
 STATIC CONSOLE_CB *OsConsoleCreate(UINT32 consoleID, const CHAR *deviceName)
 {
     INT32 ret;
@@ -1268,16 +1268,16 @@ STATIC CONSOLE_CB *OsConsoleCreate(UINT32 consoleID, const CHAR *deviceName)
     return consoleCB;
 
 ERR_WITH_DEV:
-    ret = (INT32)OsConsoleDevDeinit(consoleCB);
+    ret = (INT32)OsConsoleDevDeinit(consoleCB);//控制台设备取消初始化
     if (ret != LOS_OK) {
         PRINT_ERR("OsConsoleDevDeinit failed!\n");
     }
 ERR_WITH_SEM:
-    (VOID)LOS_SemDelete(consoleCB->consoleSem);
+    (VOID)LOS_SemDelete(consoleCB->consoleSem);//控制台信号量删除
 ERR_WITH_BUF:
-    OsConsoleBufDeinit(consoleCB);
+    OsConsoleBufDeinit(consoleCB);//控制台buf取消初始化
 ERR_WITH_NAME:
-    OsConsoleCBDeinit(consoleCB);
+    OsConsoleCBDeinit(consoleCB);//控制块取消初始化
     return NULL;
 }
 
@@ -1554,7 +1554,7 @@ VOID OsSetConsoleID(UINT32 newTaskID, UINT32 curTaskID)
 
     g_taskConsoleIDArray[newTaskID] = g_taskConsoleIDArray[curTaskID];
 }
-
+//将buf内容写到终端设备
 STATIC ssize_t WriteToTerminal(const CONSOLE_CB *consoleCB, const CHAR *buffer, size_t bufLen)
 {
     INT32 ret, fd;
@@ -1564,14 +1564,14 @@ STATIC ssize_t WriteToTerminal(const CONSOLE_CB *consoleCB, const CHAR *buffer,
     const struct file_operations_vfs *fileOps = NULL;
 
     fd = consoleCB->fd;
-    ret = fs_getfilep(fd, &filep);
-    ret = GetFilepOps(filep, &privFilep, &fileOps);
+    ret = fs_getfilep(fd, &filep);//获取文件指针
+    ret = GetFilepOps(filep, &privFilep, &fileOps);//获取文件的操作方法
 
     if ((fileOps == NULL) || (fileOps->write == NULL)) {
         ret = EFAULT;
         goto ERROUT;
     }
-    (VOID)fileOps->write(privFilep, buffer, bufLen);
+    (VOID)fileOps->write(privFilep, buffer, bufLen);//写入文件
 
     return cnt;
 
@@ -1589,45 +1589,45 @@ STATIC UINT32 ConsoleSendTask(UINTPTR param)
     UINT32 intSave;
     CHAR *buf = NULL;
 
-    (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_SEND_TASK_RUNNING);
+    (VOID)LOS_EventWrite(&cirBufSendCB->sendEvent, CONSOLE_SEND_TASK_RUNNING);//发送一个控制台任务正在运行的事件
 
     while (1) {
         ret = LOS_EventRead(&cirBufSendCB->sendEvent, CONSOLE_CIRBUF_EVENT | CONSOLE_SEND_TASK_EXIT,
-                            LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
-        if (ret == CONSOLE_CIRBUF_EVENT) {
-            size =  LOS_CirBufUsedSize(cirBufCB);
+                            LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);//读取循环buf或任务退出的事件
+        if (ret == CONSOLE_CIRBUF_EVENT) {//控制台循环buf事件发生
+            size =  LOS_CirBufUsedSize(cirBufCB);//循环buf使用大小
             if (size == 0) {
                 continue;
             }
-            buf = (CHAR *)LOS_MemAlloc(m_aucSysMem1, size + 1);
+            buf = (CHAR *)LOS_MemAlloc(m_aucSysMem1, size + 1);//分配接收cirbuf的内存
             if (buf == NULL) {
                 continue;
             }
-            (VOID)memset_s(buf, size + 1, 0, size + 1);
+            (VOID)memset_s(buf, size + 1, 0, size + 1);//清0
 
             LOS_CirBufLock(cirBufCB, &intSave);
-            (VOID)LOS_CirBufRead(cirBufCB, buf, size);
+            (VOID)LOS_CirBufRead(cirBufCB, buf, size);//读取循环cirBufCB至  buf
             LOS_CirBufUnlock(cirBufCB, intSave);
 
-            (VOID)WriteToTerminal(consoleCB, buf, size);
-            (VOID)LOS_MemFree(m_aucSysMem1, buf);
-        } else if (ret == CONSOLE_SEND_TASK_EXIT) {
-            break;
+            (VOID)WriteToTerminal(consoleCB, buf, size);//将buf数据写到控制台终端设备
+            (VOID)LOS_MemFree(m_aucSysMem1, buf);//清除buf
+        } else if (ret == CONSOLE_SEND_TASK_EXIT) {//收到任务退出的事件
+            break;//退出循环
         }
     }
 
-    ConsoleCirBufDelete(cirBufSendCB);
+    ConsoleCirBufDelete(cirBufSendCB);//删除循环buf,归还内存
     return LOS_OK;
 }
 
-#if (LOSCFG_KERNEL_SMP == YES)
+#if (LOSCFG_KERNEL_SMP == YES)//多处理器情况下
 VOID OsWaitConsoleSendTaskPend(UINT32 taskID)
 {
     UINT32 i;
     CONSOLE_CB *console = NULL;
     LosTaskCB *taskCB = NULL;
 
-    for (i = 0; i < CONSOLE_NUM; i++) {
+    for (i = 0; i < CONSOLE_NUM; i++) {//循环cpu core
         console = g_console[i];
         if (console == NULL) {
             continue;
@@ -1643,20 +1643,20 @@ VOID OsWaitConsoleSendTaskPend(UINT32 taskID)
         }
     }
 }
-
+//唤醒控制台发送任务
 VOID OsWakeConsoleSendTask(VOID)
 {
     UINT32 i;
     CONSOLE_CB *console = NULL;
 
-    for (i = 0; i < CONSOLE_NUM; i++) {
+    for (i = 0; i < CONSOLE_NUM; i++) {//循环控制台数量，只有2个
         console = g_console[i];
         if (console == NULL) {
             continue;
         }
 
-        if (console->cirBufSendCB != NULL) {
-            (VOID)LOS_EventWrite(&console->cirBufSendCB->sendEvent, CONSOLE_CIRBUF_EVENT);
+        if (console->cirBufSendCB != NULL) {//循环缓存描述符
+            (VOID)LOS_EventWrite(&console->cirBufSendCB->sendEvent, CONSOLE_CIRBUF_EVENT);//写循环缓存区buf事件
         }
     }
 }

kernel/common/console.h

@@ -70,34 +70,34 @@ extern "C" {
 #define CONSOLE_NUM                    2
 
 
-#define TELNET_CIRBUF_SIZE 0x2000
+#define TELNET_CIRBUF_SIZE 0x2000 //8K
 
 typedef struct {
-    CirBuf cirBufCB;        /* Circular buffer CB */
-    EVENT_CB_S sendEvent;   /* Inform telnet send task */
+    CirBuf cirBufCB;        /* Circular buffer CB */ //循环缓冲控制块
+    EVENT_CB_S sendEvent;   /* Inform telnet send task */ //通知telnet发送任务
 } CirBufSendCB;
-//控制台控制块结构体
+//控制台控制块(描述符)
 typedef struct {
     UINT32 consoleID;	//控制台ID
     UINT32 consoleType;	//控制台类型
-    UINT32 consoleSem;	//
+    UINT32 consoleSem;	//控制台信号量
     UINT32 shellEntryId;//shell的入口ID
-    UINT32 consoleMask;	
-    struct inode *devInode;
-    CHAR *name;
-    INT32 fd;
-    UINT32 refCount;
-    BOOL isNonBlock;
+    UINT32 consoleMask;	//控制台掩码
+    struct inode *devInode;//设备节点
+    CHAR *name;	//名称
+    INT32 fd;	//文件描述符
+    UINT32 refCount;	//引用次数
+    BOOL isNonBlock;	
 #ifdef LOSCFG_SHELL
-    VOID *shellHandle;
+    VOID *shellHandle;	//
 #endif
-    UINT32 sendTaskID;
-    CirBufSendCB *cirBufSendCB;
+    UINT32 sendTaskID;	//发送任务ID
+    CirBufSendCB *cirBufSendCB;	//循环缓冲描述符
     UINT8 fifo[CONSOLE_FIFO_SIZE];
     UINT32 fifoOut;
     UINT32 fifoIn;
     UINT32 currentLen;
-    struct termios consoleTermios;
+    struct termios consoleTermios; //控制台条款
 } CONSOLE_CB;
 
 extern INT32 system_console_init(const CHAR *deviceName);

kernel/common/los_cir_buf.c

@@ -36,76 +36,82 @@
 extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */
-
+//返回循环buf已使用的大小
 UINT32 LOS_CirBufUsedSize(CirBuf *cirbufCB)
 {
     UINT32 size;
     UINT32 intSave;
 
     LOS_SpinLockSave(&cirbufCB->lock, &intSave);
-    size = cirbufCB->size - cirbufCB->remain;
+    size = cirbufCB->size - cirbufCB->remain; //得到已使用大小
     LOS_SpinUnlockRestore(&cirbufCB->lock, intSave);
 
     return size;
 }
 
-/*
+/* 图形表示写循环buf linear 模式 ，图表示 写之前的样子 @note_pic 
  *                    startIdx
  *                    |
  *    0 0 0 0 0 0 0 0 X X X X X X X X 0 0 0 0 0 0
  *                                    |
  *                                  endIdx
- */
+ *///写操作的是endIdx    | X 表示剩余size index 从左到右递减
 STATIC UINT32 OsCirBufWriteLinear(CirBuf *cirbufCB, const CHAR *buf, UINT32 size)
 {
     UINT32 cpSize;
     errno_t err;
 
-    cpSize = (cirbufCB->remain < size) ? cirbufCB->remain : size;
+    cpSize = (cirbufCB->remain < size) ? cirbufCB->remain : size;//得到cp的大小
 
     if (cpSize == 0) {
         return 0;
     }
 
-    err = memcpy_s(cirbufCB->fifo + cirbufCB->endIdx, cirbufCB->remain, buf, cpSize);
+    err = memcpy_s(cirbufCB->fifo + cirbufCB->endIdx, cirbufCB->remain, buf, cpSize);//完成拷贝
     if (err != EOK) {
         return 0;
     }
 
-    cirbufCB->remain -= cpSize;
-    cirbufCB->endIdx += cpSize;
+    cirbufCB->remain -= cpSize;//写完了那总剩余size肯定是要减少的
+    cirbufCB->endIdx += cpSize;//结尾变大
 
     return cpSize;
 }
-
+/* 图形表示写循环buf        loop 模式 ，图表示 写之前的样子       @note_pic
+ *                    endIdx            第二阶段拷贝
+ *                    |               |             |
+ *    X X X X X X X X 0 0 0 0 0 0 0 0 X X X X X X X X
+ *    |               |               |
+ *     第一阶段拷贝                         startIdx
+ *///写操作的是endIdx | X 表示剩余size index 从左到右递减
 STATIC UINT32 OsCirBufWriteLoop(CirBuf *cirbufCB, const CHAR *buf, UINT32 size)
 {
     UINT32 right, cpSize;
     errno_t err;
 
-    right = cirbufCB->size - cirbufCB->endIdx;
-    cpSize = (right < size) ? right : size;
+    right = cirbufCB->size - cirbufCB->endIdx;//先计算右边部分
+    cpSize = (right < size) ? right : size;//算出cpSize，很可能要分两次
 
-    err = memcpy_s(cirbufCB->fifo + cirbufCB->endIdx, right, buf, cpSize);
+    err = memcpy_s(cirbufCB->fifo + cirbufCB->endIdx, right, buf, cpSize);//先拷贝一部分
     if (err != EOK) {
         return 0;
     }
 
-    cirbufCB->remain -= cpSize;
-    cirbufCB->endIdx += cpSize;
-    if (cirbufCB->endIdx == cirbufCB->size) {
-        cirbufCB->endIdx = 0;
+    cirbufCB->remain -= cpSize;//写完了那总剩余size肯定是要减少的
+    cirbufCB->endIdx += cpSize;//endIdx 增加，一直往后移
+    if (cirbufCB->endIdx == cirbufCB->size) {//这个相当于移到最后一个了
+        cirbufCB->endIdx = 0;//循环从这里开始
     }
 
-    if (cpSize == size) {
-        return size;
+    if (cpSize == size) {//拷贝完了的情况
+        return size;//返回size
     } else {
-        cpSize += OsCirBufWriteLinear(cirbufCB, buf + cpSize, size - cpSize);
+        cpSize += OsCirBufWriteLinear(cirbufCB, buf + cpSize, size - cpSize);//需第二次拷贝
     }
 
     return cpSize;
 }
-
+//写入数据到循环buf区
 UINT32 LOS_CirBufWrite(CirBuf *cirbufCB, const CHAR *buf, UINT32 size)
 {
     UINT32 cpSize = 0;
@@ -118,64 +124,76 @@ UINT32 LOS_CirBufWrite(CirBuf *cirbufCB, const CHAR *buf, UINT32 size)
         return 0;
     }
 
-    if (cirbufCB->startIdx <= cirbufCB->endIdx) {
-        cpSize = OsCirBufWriteLoop(cirbufCB, buf, size);
+    if (cirbufCB->startIdx <= cirbufCB->endIdx) {//开始位置在前面
+        cpSize = OsCirBufWriteLoop(cirbufCB, buf, size);//循环方式写入，分两次拷贝
     } else {
-        cpSize = OsCirBufWriteLinear(cirbufCB, buf, size);
+        cpSize = OsCirBufWriteLinear(cirbufCB, buf, size);//线性方式写入，分一次拷贝
     }
 
     return cpSize;
 }
-
+/* 图形表示读线性buf        linear 模式 ，图表示 读之前的样子         @note_pic
+ *                    endIdx            
+ *                    |               
+ *    X X X X X X X X 0 0 0 0 0 0 0 0 X X X X X X X X
+ *                   				  |
+ *                              	  startIdx
+ *///读操作的是startIdx | X 表示剩余size index 从左到右递减
 STATIC UINT32 OsCirBufReadLinear(CirBuf *cirbufCB, CHAR *buf, UINT32 size)
 {
     UINT32 cpSize, remain;
     errno_t err;
 
-    remain = cirbufCB->endIdx - cirbufCB->startIdx;
+    remain = cirbufCB->endIdx - cirbufCB->startIdx;//这里表示剩余可读区
     cpSize = (remain < size) ? remain : size;
 
     if (cpSize == 0) {
         return 0;
     }
 
-    err = memcpy_s(buf, size, cirbufCB->fifo + cirbufCB->startIdx, cpSize);
+    err = memcpy_s(buf, size, cirbufCB->fifo + cirbufCB->startIdx, cpSize);//完成拷贝
     if (err != EOK) {
         return 0;
     }
 
-    cirbufCB->remain += cpSize;
-    cirbufCB->startIdx += cpSize;
+    cirbufCB->remain += cpSize;//读完了那总剩余size肯定是要增加的
+    cirbufCB->startIdx += cpSize;//startIdx也要往前移动
 
     return cpSize;
 }
-
+/* 图形表示读循环buf loop 模式 ，图表示 读之前的样子 @note_pic 
+ *                    startIdx
+ *                    |
+ *    0 0 0 0 0 0 0 0 X X X X X X X X 0 0 0 0 0 0
+ *                                    |
+ *                                  endIdx
+ *///读操作的是startIdx    | X 表示剩余size index 从左到右递减
 STATIC UINT32 OsCirBufReadLoop(CirBuf *cirbufCB, CHAR *buf, UINT32 size)
 {
     UINT32 right, cpSize;
     errno_t err;
 
-    right = cirbufCB->size - cirbufCB->startIdx;
+    right = cirbufCB->size - cirbufCB->startIdx;//先算出要读取的部分
     cpSize = (right < size) ? right : size;
 
-    err = memcpy_s(buf, size, cirbufCB->fifo + cirbufCB->startIdx, cpSize);
+    err = memcpy_s(buf, size, cirbufCB->fifo + cirbufCB->startIdx, cpSize);//先读第一部分数据
     if (err != EOK) {
         return 0;
     }
 
-    cirbufCB->remain += cpSize;
-    cirbufCB->startIdx += cpSize;
-    if (cirbufCB->startIdx == cirbufCB->size) {
-        cirbufCB->startIdx = 0;
+    cirbufCB->remain += cpSize;//读完了那总剩余size肯定是要增加的
+    cirbufCB->startIdx += cpSize;//startIdx也要往前移动
+    if (cirbufCB->startIdx == cirbufCB->size) {//如果移动到头了
+        cirbufCB->startIdx = 0;//循环buf的关键,新的循环开始了
     }
 
     if (cpSize < size) {
-        cpSize += OsCirBufReadLinear(cirbufCB, buf + cpSize, size - cpSize);
+        cpSize += OsCirBufReadLinear(cirbufCB, buf + cpSize, size - cpSize);//剩余的就交给线性方式读取了
     }
 
     return cpSize;
 }
-
+//读取循环buf的数据
 UINT32 LOS_CirBufRead(CirBuf *cirbufCB, CHAR *buf, UINT32 size)
 {
     UINT32 cpSize;
@@ -188,31 +206,31 @@ UINT32 LOS_CirBufRead(CirBuf *cirbufCB, CHAR *buf, UINT32 size)
         return 0;
     }
 
-    if (cirbufCB->startIdx >= cirbufCB->endIdx) {
-        cpSize = OsCirBufReadLoop(cirbufCB, buf, size);
-    } else {
-        cpSize = OsCirBufReadLinear(cirbufCB, buf, size);
+    if (cirbufCB->startIdx >= cirbufCB->endIdx) {//开始位置大于结束位置的情况怎么读
+        cpSize = OsCirBufReadLoop(cirbufCB, buf, size);//循环读取buf
+    } else {//开始位置小于结束位置的情况怎么读
+        cpSize = OsCirBufReadLinear(cirbufCB, buf, size);//线性读取，读取 endIdx - startIdx 部分就行了，所以是线性读取 
     }
 
     return cpSize;
 }
-
+//初始化循环buf
 UINT32 LOS_CirBufInit(CirBuf *cirbufCB, CHAR *fifo, UINT32 size)
 {
     if ((cirbufCB == NULL) || (fifo == NULL)) {
         return LOS_NOK;
     }
 
-    (VOID)memset_s(cirbufCB, sizeof(CirBuf), 0, sizeof(CirBuf));
-    LOS_SpinInit(&cirbufCB->lock);
-    cirbufCB->size = size;
-    cirbufCB->remain = size;
-    cirbufCB->status = CBUF_USED;
-    cirbufCB->fifo = fifo;
+    (VOID)memset_s(cirbufCB, sizeof(CirBuf), 0, sizeof(CirBuf));//清0
+    LOS_SpinInit(&cirbufCB->lock);//自旋锁初始化
+    cirbufCB->size = size;	//记录size
+    cirbufCB->remain = size;//剩余size
+    cirbufCB->status = CBUF_USED;//标记为已使用
+    cirbufCB->fifo = fifo;	//顺序buf
 
     return LOS_OK;
 }
-
+//删除初始化操作，其实就是清0
 VOID LOS_CirBufDeinit(CirBuf *cirbufCB)
 {
     (VOID)memset_s(cirbufCB, sizeof(CirBuf), 0, sizeof(CirBuf));

kernel/common/los_cir_buf_pri.h

@@ -41,21 +41,22 @@ extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */
 
+//循环buf常用于控制台和socket buf,
 typedef enum {
-    CBUF_UNUSED,
-    CBUF_USED
+    CBUF_UNUSED,//未使用
+    CBUF_USED	//已使用
 } CirBufStatus;
 
 typedef struct {
-    UINT32 startIdx;
-    UINT32 endIdx;
-    UINT32 size;
-    UINT32 remain;
-    SPIN_LOCK_S lock;
-    CirBufStatus status;
-    CHAR *fifo;
+    UINT32 startIdx; 	//开始位置
+    UINT32 endIdx;		//结束位置
+    UINT32 size;		//大小
+    UINT32 remain;		//剩余多少
+    SPIN_LOCK_S lock;	//自旋锁
+    CirBufStatus status;//两种状态
+    CHAR *fifo;			//顺序buffer
 } CirBuf;
-
+//锁循环buf
 STATIC INLINE VOID LOS_CirBufLock(CirBuf *cirbufCB, UINT32 *intSave)
 {
     if (cirbufCB == NULL) {
@@ -63,7 +64,7 @@ STATIC INLINE VOID LOS_CirBufLock(CirBuf *cirbufCB, UINT32 *intSave)
     }
     LOS_SpinLockSave(&cirbufCB->lock, intSave);
 }
-
+//解锁循环buf
 STATIC INLINE VOID LOS_CirBufUnlock(CirBuf *cirbufCB, UINT32 intSave)
 {
     if (cirbufCB == NULL) {

kernel/include/los_event.h

@@ -50,19 +50,19 @@ extern "C" {
  * @ingroup los_event
  * Event reading mode: The task waits for all its expected events to occur.
  */
-#define LOS_WAITMODE_AND                    4U 	//事件读取模式：任务等待所有预期事件发生。
+#define LOS_WAITMODE_AND                    4U 	//事件读取模式：任务等待所有预期事件发生。读取掩码中所有事件类型，只有读取的所有事件类型都发生了，才能读取成功。
 
 /**
  * @ingroup los_event
  * Event reading mode: The task waits for any of its expected events to occur.
  */
-#define LOS_WAITMODE_OR                     2U 	//事件读取模式：任务等待任何预期事件发生。
+#define LOS_WAITMODE_OR                     2U 	//事件读取模式：任务等待任何预期事件发生。读取掩码中任一事件类型，读取的事件中任意一种事件类型发生了，就可以读取成功
 
 /**
  * @ingroup los_event
  * Event reading mode: The event flag is immediately cleared after the event is read.
  */
-#define LOS_WAITMODE_CLR                    1U	//事件读取模式：事件标志在读取事件后立即清除。
+#define LOS_WAITMODE_CLR                    1U	//事件读取模式：事件标志在读取事件后立即清除。表示读取成功后，对应事件类型位会自动清除
 
 /**
  * @ingroup los_event
@@ -162,9 +162,9 @@ extern "C" {
  * Event control structure
  */
 typedef struct tagEvent {
-    UINT32 uwEventID;        /**< Event mask in the event control block,
+    UINT32 uwEventID;        /**< Event mask in the event control block,//标识发生的事件类型位
                                   indicating the event that has been logically processed. */
-    LOS_DL_LIST stEventList; /**< Event control block linked list */
+    LOS_DL_LIST stEventList; /**< Event control block linked list *///读取事件任务链表
 } EVENT_CB_S, *PEVENT_CB_S;//一个是结构体,一个是指针
 
 /**

net/telnet/src/telnet_loop.c

@@ -512,32 +512,32 @@ STATIC INT32 TelnetdMain(VOID)
 }
 
 /*
- * Try to create telnetd task.
+ * Try to create telnetd task. 创建远程任务
  */
 STATIC VOID TelnetdTaskInit(VOID)
 {
     UINT32 ret;
     TSK_INIT_PARAM_S initParam = {0};
 
-    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)TelnetdMain;
-    initParam.uwStackSize = TELNET_TASK_STACK_SIZE;
+    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)TelnetdMain; //入口函数
+    initParam.uwStackSize = TELNET_TASK_STACK_SIZE; //8K
     initParam.pcName = "TelnetServer";
-    initParam.usTaskPrio = TELNET_TASK_PRIORITY;
-    initParam.uwResved = LOS_TASK_STATUS_DETACHED;
+    initParam.usTaskPrio = TELNET_TASK_PRIORITY; //优先级9
+    initParam.uwResved = LOS_TASK_STATUS_DETACHED;//任务分离模式
 
     if (atomic_read(&g_telnetTaskId) != 0) {
         PRINT_ERR("telnet server is already running!\n");
         return;
     }
 
-    ret = LOS_TaskCreate((UINT32 *)&g_telnetTaskId, &initParam);
+    ret = LOS_TaskCreate((UINT32 *)&g_telnetTaskId, &initParam);//创建任务，并加入就绪队列，立即申请调度
     if (ret != LOS_OK) {
         PRINT_ERR("failed to create telnet server task!\n");
     }
 }
 
 /*
- * Try to destroy telnetd task.
+ * Try to destroy telnetd task. 销毁远程任务
  */
 STATIC VOID TelnetdTaskDeinit(VOID)
 {

shell/full/src/base/shmsg.c

@@ -390,7 +390,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 ShellTask(UINTPTR param1,
     (VOID)param3;
     (VOID)param4;
 
-    while (1) {
+    while (1) {//死循环读事件
         PRINTK("\nOHOS # ");
         ret = LOS_EventRead(&shellCB->shellEvent,
                             0xFFF, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);//等待用户的输入完成 读取cmd命令

zzz/git/push.sh

 git add -A
-git commit -m  '您知道工作台是如何创建的码? 添加 VFS部分shell命令代码的注释 
-鸿蒙内核源码分析系列 【 CSDN | OSCHINA | WIKI 】
-鸿蒙内核源码注释中文版 【 CSDN仓 | Gitee仓 | Github仓 | Coding仓 】四大仓库每日同步更新
-项目给鸿蒙内核源码逐行加上中文注解,详细阐述框架和代码细节, 精读 HarmonyOS 内核源码, 将迅速拔高对计算机整体理解,从此高屋建瓴看问题.'
+git commit -m  '新增控制台，事件，循环buf的代码注释，您知道工作台是如何创建的吗? 
+搜索 @note_pic 可以查看全部字符图
+搜索 @note_why 是注者尚未看明白的地方，如果您看明白了，请告诉注者完善
+搜索 @note_thinking 是注者的思考和吐槽的地方
+'
 
 git push origin
 git push gitee_origin master